/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 */
#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 *engine;
    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 'e':
                if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
                    /* OSSL_ALG_PARAM_ENGINE */
                    if (ossl_unlikely(r->engine != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->engine = (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 */
#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 */
#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: 2025-11-07 06:36

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