/src/openssl/providers/implementations/macs/kmac_prov.inc

Source
/*
 * Copyright 2025 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the \"License\").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */



/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#ifndef kmac_new_list
static const OSSL_PARAM kmac_new_list[] = {
    OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_DIGEST, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef kmac_new_st
struct kmac_new_st {
    OSSL_PARAM *digest;
    OSSL_PARAM *propq;
};
#endif

#ifndef kmac_new_decoder
static int kmac_new_decoder
    (const OSSL_PARAM *p, struct kmac_new_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'd':
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_DIGEST */
                    if (ossl_unlikely(r->digest != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->digest = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_PROPERTIES */
                    if (ossl_unlikely(r->propq != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->propq = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#ifndef kmac_get_ctx_params_list
static const OSSL_PARAM kmac_get_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
    OSSL_PARAM_size_t(OSSL_MAC_PARAM_BLOCK_SIZE, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef kmac_get_ctx_params_st
struct kmac_get_ctx_params_st {
    OSSL_PARAM *bsize;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
    OSSL_PARAM *size;
};
#endif

#ifndef kmac_get_ctx_params_decoder
static int kmac_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct kmac_get_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'b':
                if (ossl_likely(strcmp("lock-size", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_BLOCK_SIZE */
                    if (ossl_unlikely(r->bsize != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->bsize = (OSSL_PARAM *)p;
                }
                break;
            case 'f':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
                    /* OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR */
                    if (ossl_unlikely(r->ind != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ind = (OSSL_PARAM *)p;
                }
# endif
                break;
            case 's':
                if (ossl_likely(strcmp("ize", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_SIZE */
                    if (ossl_unlikely(r->size != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->size = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#ifndef kmac_set_ctx_params_list
static const OSSL_PARAM kmac_set_ctx_params_list[] = {
    OSSL_PARAM_int(OSSL_MAC_PARAM_XOF, NULL),
    OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
    OSSL_PARAM_octet_string(OSSL_MAC_PARAM_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_MAC_PARAM_CUSTOM, NULL, 0),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_MAC_PARAM_FIPS_KEY_CHECK, NULL),
# endif
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef kmac_set_ctx_params_st
struct kmac_set_ctx_params_st {
    OSSL_PARAM *custom;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind_k;
# endif
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind_sht;
# endif
    OSSL_PARAM *key;
    OSSL_PARAM *size;
    OSSL_PARAM *xof;
};
#endif

#ifndef kmac_set_ctx_params_decoder
static int kmac_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct kmac_set_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'c':
                if (ossl_likely(strcmp("ustom", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_CUSTOM */
                    if (ossl_unlikely(r->custom != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->custom = (OSSL_PARAM *)p;
                }
                break;
            case 'k':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 'y':
                        switch(s[3]) {
                        default:
                            break;
                        case '-':
# if defined(FIPS_MODULE)
                            if (ossl_likely(strcmp("check", s + 4) == 0)) {
                                /* OSSL_MAC_PARAM_FIPS_KEY_CHECK */
                                if (ossl_unlikely(r->ind_k != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->ind_k = (OSSL_PARAM *)p;
                            }
# endif
                            break;
                        case '\0':
                            if (ossl_unlikely(r->key != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->key = (OSSL_PARAM *)p;
                        }
                    }
                }
                break;
            case 'n':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("o-short-mac", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC */
                    if (ossl_unlikely(r->ind_sht != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ind_sht = (OSSL_PARAM *)p;
                }
# endif
                break;
            case 's':
                if (ossl_likely(strcmp("ize", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_SIZE */
                    if (ossl_unlikely(r->size != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->size = (OSSL_PARAM *)p;
                }
                break;
            case 'x':
                if (ossl_likely(strcmp("of", s + 1) == 0)) {
                    /* OSSL_MAC_PARAM_XOF */
                    if (ossl_unlikely(r->xof != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->xof = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2026-05-20 07:05

Line	Count	Source
1		/*
2		* Copyright 2025 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the \"License\"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10
11
12		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
13		#include <string.h>
14		#include <openssl/params.h>
15		#include "internal/common.h"
16		#include "prov/proverr.h"
17
18		#ifndef kmac_new_list
19		static const OSSL_PARAM kmac_new_list[] = {
20		OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_DIGEST, NULL, 0),
21		OSSL_PARAM_utf8_string(OSSL_MAC_PARAM_PROPERTIES, NULL, 0),
22		OSSL_PARAM_END
23		};
24		#endif
25
26		#ifndef kmac_new_st
27		struct kmac_new_st {
28		OSSL_PARAM *digest;
29		OSSL_PARAM *propq;
30		};
31		#endif
32
33		#ifndef kmac_new_decoder
34		static int kmac_new_decoder
35		(const OSSL_PARAM p, struct kmac_new_st r)
36	0	{
37	0	const char *s;
38
39	0	memset(r, 0, sizeof(*r));
40	0	if (p != NULL)
41	0	for (; (s = p->key) != NULL; p++)
42	0	switch(s[0]) {
43	0	default:
44	0	break;
45	0	case 'd':
46	0	if (ossl_likely(strcmp("igest", s + 1) == 0)) {
47		/* OSSL_MAC_PARAM_DIGEST */
48	0	if (ossl_unlikely(r->digest != NULL)) {
49	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
50	0	"param %s is repeated", s);
51	0	return 0;
52	0	}
53	0	r->digest = (OSSL_PARAM *)p;
54	0	}
55	0	break;
56	0	case 'p':
57	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
58		/* OSSL_MAC_PARAM_PROPERTIES */
59	0	if (ossl_unlikely(r->propq != NULL)) {
60	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
61	0	"param %s is repeated", s);
62	0	return 0;
63	0	}
64	0	r->propq = (OSSL_PARAM *)p;
65	0	}
66	0	}
67	0	return 1;
68	0	}
69		#endif
70		/* End of machine generated */
71
72		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
73		#include <string.h>
74		#include <openssl/params.h>
75		#include "internal/common.h"
76		#include "prov/proverr.h"
77
78		#ifndef kmac_get_ctx_params_list
79		static const OSSL_PARAM kmac_get_ctx_params_list[] = {
80		OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
81		OSSL_PARAM_size_t(OSSL_MAC_PARAM_BLOCK_SIZE, NULL),
82		# if defined(FIPS_MODULE)
83		OSSL_PARAM_int(OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR, NULL),
84		# endif
85		OSSL_PARAM_END
86		};
87		#endif
88
89		#ifndef kmac_get_ctx_params_st
90		struct kmac_get_ctx_params_st {
91		OSSL_PARAM *bsize;
92		# if defined(FIPS_MODULE)
93		OSSL_PARAM *ind;
94		# endif
95		OSSL_PARAM *size;
96		};
97		#endif
98
99		#ifndef kmac_get_ctx_params_decoder
100		static int kmac_get_ctx_params_decoder
101		(const OSSL_PARAM p, struct kmac_get_ctx_params_st r)
102	0	{
103	0	const char *s;
104
105	0	memset(r, 0, sizeof(*r));
106	0	if (p != NULL)
107	0	for (; (s = p->key) != NULL; p++)
108	0	switch(s[0]) {
109	0	default:
110	0	break;
111	0	case 'b':
112	0	if (ossl_likely(strcmp("lock-size", s + 1) == 0)) {
113		/* OSSL_MAC_PARAM_BLOCK_SIZE */
114	0	if (ossl_unlikely(r->bsize != NULL)) {
115	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
116	0	"param %s is repeated", s);
117	0	return 0;
118	0	}
119	0	r->bsize = (OSSL_PARAM *)p;
120	0	}
121	0	break;
122	0	case 'f':
123		# if defined(FIPS_MODULE)
124		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
125		/* OSSL_ALG_PARAM_FIPS_APPROVED_INDICATOR */
126		if (ossl_unlikely(r->ind != NULL)) {
127		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
128		"param %s is repeated", s);
129		return 0;
130		}
131		r->ind = (OSSL_PARAM *)p;
132		}
133		# endif
134	0	break;
135	0	case 's':
136	0	if (ossl_likely(strcmp("ize", s + 1) == 0)) {
137		/* OSSL_MAC_PARAM_SIZE */
138	0	if (ossl_unlikely(r->size != NULL)) {
139	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
140	0	"param %s is repeated", s);
141	0	return 0;
142	0	}
143	0	r->size = (OSSL_PARAM *)p;
144	0	}
145	0	}
146	0	return 1;
147	0	}
148		#endif
149		/* End of machine generated */
150
151		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
152		#include <string.h>
153		#include <openssl/params.h>
154		#include "internal/common.h"
155		#include "prov/proverr.h"
156
157		#ifndef kmac_set_ctx_params_list
158		static const OSSL_PARAM kmac_set_ctx_params_list[] = {
159		OSSL_PARAM_int(OSSL_MAC_PARAM_XOF, NULL),
160		OSSL_PARAM_size_t(OSSL_MAC_PARAM_SIZE, NULL),
161		OSSL_PARAM_octet_string(OSSL_MAC_PARAM_KEY, NULL, 0),
162		OSSL_PARAM_octet_string(OSSL_MAC_PARAM_CUSTOM, NULL, 0),
163		# if defined(FIPS_MODULE)
164		OSSL_PARAM_int(OSSL_MAC_PARAM_FIPS_KEY_CHECK, NULL),
165		# endif
166		# if defined(FIPS_MODULE)
167		OSSL_PARAM_int(OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC, NULL),
168		# endif
169		OSSL_PARAM_END
170		};
171		#endif
172
173		#ifndef kmac_set_ctx_params_st
174		struct kmac_set_ctx_params_st {
175		OSSL_PARAM *custom;
176		# if defined(FIPS_MODULE)
177		OSSL_PARAM *ind_k;
178		# endif
179		# if defined(FIPS_MODULE)
180		OSSL_PARAM *ind_sht;
181		# endif
182		OSSL_PARAM *key;
183		OSSL_PARAM *size;
184		OSSL_PARAM *xof;
185		};
186		#endif
187
188		#ifndef kmac_set_ctx_params_decoder
189		static int kmac_set_ctx_params_decoder
190		(const OSSL_PARAM p, struct kmac_set_ctx_params_st r)
191	0	{
192	0	const char *s;
193
194	0	memset(r, 0, sizeof(*r));
195	0	if (p != NULL)
196	0	for (; (s = p->key) != NULL; p++)
197	0	switch(s[0]) {
198	0	default:
199	0	break;
200	0	case 'c':
201	0	if (ossl_likely(strcmp("ustom", s + 1) == 0)) {
202		/* OSSL_MAC_PARAM_CUSTOM */
203	0	if (ossl_unlikely(r->custom != NULL)) {
204	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
205	0	"param %s is repeated", s);
206	0	return 0;
207	0	}
208	0	r->custom = (OSSL_PARAM *)p;
209	0	}
210	0	break;
211	0	case 'k':
212	0	switch(s[1]) {
213	0	default:
214	0	break;
215	0	case 'e':
216	0	switch(s[2]) {
217	0	default:
218	0	break;
219	0	case 'y':
220	0	switch(s[3]) {
221	0	default:
222	0	break;
223	0	case '-':
224		# if defined(FIPS_MODULE)
225		if (ossl_likely(strcmp("check", s + 4) == 0)) {
226		/* OSSL_MAC_PARAM_FIPS_KEY_CHECK */
227		if (ossl_unlikely(r->ind_k != NULL)) {
228		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
229		"param %s is repeated", s);
230		return 0;
231		}
232		r->ind_k = (OSSL_PARAM *)p;
233		}
234		# endif
235	0	break;
236	0	case '\0':
237	0	if (ossl_unlikely(r->key != NULL)) {
238	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
239	0	"param %s is repeated", s);
240	0	return 0;
241	0	}
242	0	r->key = (OSSL_PARAM *)p;
243	0	}
244	0	}
245	0	}
246	0	break;
247	0	case 'n':
248		# if defined(FIPS_MODULE)
249		if (ossl_likely(strcmp("o-short-mac", s + 1) == 0)) {
250		/* OSSL_MAC_PARAM_FIPS_NO_SHORT_MAC */
251		if (ossl_unlikely(r->ind_sht != NULL)) {
252		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
253		"param %s is repeated", s);
254		return 0;
255		}
256		r->ind_sht = (OSSL_PARAM *)p;
257		}
258		# endif
259	0	break;
260	0	case 's':
261	0	if (ossl_likely(strcmp("ize", s + 1) == 0)) {
262		/* OSSL_MAC_PARAM_SIZE */
263	0	if (ossl_unlikely(r->size != NULL)) {
264	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
265	0	"param %s is repeated", s);
266	0	return 0;
267	0	}
268	0	r->size = (OSSL_PARAM *)p;
269	0	}
270	0	break;
271	0	case 'x':
272	0	if (ossl_likely(strcmp("of", s + 1) == 0)) {
273		/* OSSL_MAC_PARAM_XOF */
274	0	if (ossl_unlikely(r->xof != NULL)) {
275	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
276	0	"param %s is repeated", s);
277	0	return 0;
278	0	}
279	0	r->xof = (OSSL_PARAM *)p;
280	0	}
281	0	}
282	0	return 1;
283	0	}
284		#endif
285		/* End of machine generated */