/src/openssl41/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 <openssl/e_os2.h>
#include "internal/common.h"
#include "prov/proverr.h"

/* Machine generated */
#ifndef kmac_new_list
static ossl_unused 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 ossl_unused 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 */
#ifndef kmac_get_ctx_params_list
static ossl_unused 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 ossl_unused 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 */
#ifndef kmac_set_ctx_params_list
static ossl_unused 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 ossl_unused 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-09-12 06:55

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