/src/openssl/providers/implementations/kdfs/kbkdf.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 kbkdf_set_ctx_params_list
static const OSSL_PARAM kbkdf_set_ctx_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_INFO, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SEED, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_CIPHER, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MAC, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MODE, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_USE_L, NULL),
    OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR, NULL),
    OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_R, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_KEY_CHECK, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef kbkdf_set_ctx_params_st
struct kbkdf_set_ctx_params_st {
    OSSL_PARAM *cipher;
    OSSL_PARAM *digest;
    OSSL_PARAM *engine;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind_k;
# endif
    OSSL_PARAM *info[KBKDF_MAX_INFOS];
    int num_info;
    OSSL_PARAM *key;
    OSSL_PARAM *mac;
    OSSL_PARAM *mode;
    OSSL_PARAM *propq;
    OSSL_PARAM *r;
    OSSL_PARAM *salt;
    OSSL_PARAM *seed;
    OSSL_PARAM *sep;
    OSSL_PARAM *use_l;
};
#endif

#ifndef kbkdf_set_ctx_params_decoder
static int kbkdf_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct kbkdf_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("ipher", s + 1) == 0)) {
                    /* OSSL_KDF_PARAM_CIPHER */
                    if (ossl_unlikely(r->cipher != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->cipher = (OSSL_PARAM *)p;
                }
                break;
            case 'd':
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
                    /* OSSL_KDF_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 'i':
                if (ossl_likely(strcmp("nfo", s + 1) == 0)) {
                    /* OSSL_KDF_PARAM_INFO */
                    if (ossl_unlikely(r->num_info >= KBKDF_MAX_INFOS)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_TOO_MANY_RECORDS,
                                       "param %s present >%d times", s, KBKDF_MAX_INFOS);
                        return 0;
                    }
                    r->info[r->num_info++] = (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_KDF_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 'm':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    if (ossl_likely(strcmp("c", s + 2) == 0)) {
                        /* OSSL_KDF_PARAM_MAC */
                        if (ossl_unlikely(r->mac != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->mac = (OSSL_PARAM *)p;
                    }
                    break;
                case 'o':
                    if (ossl_likely(strcmp("de", s + 2) == 0)) {
                        /* OSSL_KDF_PARAM_MODE */
                        if (ossl_unlikely(r->mode != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->mode = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
                    /* OSSL_KDF_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;
                }
                break;
            case 'r':
                switch(s[1]) {
                default:
                    break;
                case '\0':
                    if (ossl_unlikely(r->r != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->r = (OSSL_PARAM *)p;
                }
                break;
            case 's':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    if (ossl_likely(strcmp("lt", s + 2) == 0)) {
                        /* OSSL_KDF_PARAM_SALT */
                        if (ossl_unlikely(r->salt != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->salt = (OSSL_PARAM *)p;
                    }
                    break;
                case 'e':
                    if (ossl_likely(strcmp("ed", s + 2) == 0)) {
                        /* OSSL_KDF_PARAM_SEED */
                        if (ossl_unlikely(r->seed != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->seed = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'u':
                switch(s[1]) {
                default:
                    break;
                case 's':
                    switch(s[2]) {
                    default:
                        break;
                    case 'e':
                        switch(s[3]) {
                        default:
                            break;
                        case '-':
                            switch(s[4]) {
                            default:
                                break;
                            case 'l':
                                switch(s[5]) {
                                default:
                                    break;
                                case '\0':
                                    if (ossl_unlikely(r->use_l != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->use_l = (OSSL_PARAM *)p;
                                }
                                break;
                            case 's':
                                if (ossl_likely(strcmp("eparator", s + 5) == 0)) {
                                    /* OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR */
                                    if (ossl_unlikely(r->sep != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->sep = (OSSL_PARAM *)p;
                                }
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef kbkdf_get_ctx_params_list
static const OSSL_PARAM kbkdf_get_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_KDF_PARAM_SIZE, NULL),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    OSSL_PARAM_END
};
#endif

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

#ifndef kbkdf_get_ctx_params_decoder
static int kbkdf_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct kbkdf_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 'f':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
                    /* OSSL_KDF_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_KDF_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 */

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 kbkdf_set_ctx_params_list
14		static const OSSL_PARAM kbkdf_set_ctx_params_list[] = {
15		OSSL_PARAM_octet_string(OSSL_KDF_PARAM_INFO, NULL, 0),
16		OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
17		OSSL_PARAM_octet_string(OSSL_KDF_PARAM_KEY, NULL, 0),
18		OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SEED, NULL, 0),
19		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),
20		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_CIPHER, NULL, 0),
21		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MAC, NULL, 0),
22		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MODE, NULL, 0),
23		OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
24		OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_USE_L, NULL),
25		OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR, NULL),
26		OSSL_PARAM_int(OSSL_KDF_PARAM_KBKDF_R, NULL),
27		# if defined(FIPS_MODULE)
28		OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_KEY_CHECK, NULL),
29		# endif
30		OSSL_PARAM_END
31		};
32		#endif
33
34		#ifndef kbkdf_set_ctx_params_st
35		struct kbkdf_set_ctx_params_st {
36		OSSL_PARAM *cipher;
37		OSSL_PARAM *digest;
38		OSSL_PARAM *engine;
39		# if defined(FIPS_MODULE)
40		OSSL_PARAM *ind_k;
41		# endif
42		OSSL_PARAM *info[KBKDF_MAX_INFOS];
43		int num_info;
44		OSSL_PARAM *key;
45		OSSL_PARAM *mac;
46		OSSL_PARAM *mode;
47		OSSL_PARAM *propq;
48		OSSL_PARAM *r;
49		OSSL_PARAM *salt;
50		OSSL_PARAM *seed;
51		OSSL_PARAM *sep;
52		OSSL_PARAM *use_l;
53		};
54		#endif
55
56		#ifndef kbkdf_set_ctx_params_decoder
57		static int kbkdf_set_ctx_params_decoder
58		(const OSSL_PARAM p, struct kbkdf_set_ctx_params_st r)
59	0	{
60	0	const char *s;
61
62	0	memset(r, 0, sizeof(*r));
63	0	if (p != NULL)
64	0	for (; (s = p->key) != NULL; p++)
65	0	switch(s[0]) {
66	0	default:
67	0	break;
68	0	case 'c':
69	0	if (ossl_likely(strcmp("ipher", s + 1) == 0)) {
70		/* OSSL_KDF_PARAM_CIPHER */
71	0	if (ossl_unlikely(r->cipher != NULL)) {
72	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
73	0	"param %s is repeated", s);
74	0	return 0;
75	0	}
76	0	r->cipher = (OSSL_PARAM *)p;
77	0	}
78	0	break;
79	0	case 'd':
80	0	if (ossl_likely(strcmp("igest", s + 1) == 0)) {
81		/* OSSL_KDF_PARAM_DIGEST */
82	0	if (ossl_unlikely(r->digest != NULL)) {
83	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
84	0	"param %s is repeated", s);
85	0	return 0;
86	0	}
87	0	r->digest = (OSSL_PARAM *)p;
88	0	}
89	0	break;
90	0	case 'e':
91	0	if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
92		/* OSSL_ALG_PARAM_ENGINE */
93	0	if (ossl_unlikely(r->engine != NULL)) {
94	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
95	0	"param %s is repeated", s);
96	0	return 0;
97	0	}
98	0	r->engine = (OSSL_PARAM *)p;
99	0	}
100	0	break;
101	0	case 'i':
102	0	if (ossl_likely(strcmp("nfo", s + 1) == 0)) {
103		/* OSSL_KDF_PARAM_INFO */
104	0	if (ossl_unlikely(r->num_info >= KBKDF_MAX_INFOS)) {
105	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_TOO_MANY_RECORDS,
106	0	"param %s present >%d times", s, KBKDF_MAX_INFOS);
107	0	return 0;
108	0	}
109	0	r->info[r->num_info++] = (OSSL_PARAM *)p;
110	0	}
111	0	break;
112	0	case 'k':
113	0	switch(s[1]) {
114	0	default:
115	0	break;
116	0	case 'e':
117	0	switch(s[2]) {
118	0	default:
119	0	break;
120	0	case 'y':
121	0	switch(s[3]) {
122	0	default:
123	0	break;
124	0	case '-':
125		# if defined(FIPS_MODULE)
126		if (ossl_likely(strcmp("check", s + 4) == 0)) {
127		/* OSSL_KDF_PARAM_FIPS_KEY_CHECK */
128		if (ossl_unlikely(r->ind_k != 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_k = (OSSL_PARAM *)p;
134		}
135		# endif
136	0	break;
137	0	case '\0':
138	0	if (ossl_unlikely(r->key != 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->key = (OSSL_PARAM *)p;
144	0	}
145	0	}
146	0	}
147	0	break;
148	0	case 'm':
149	0	switch(s[1]) {
150	0	default:
151	0	break;
152	0	case 'a':
153	0	if (ossl_likely(strcmp("c", s + 2) == 0)) {
154		/* OSSL_KDF_PARAM_MAC */
155	0	if (ossl_unlikely(r->mac != NULL)) {
156	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
157	0	"param %s is repeated", s);
158	0	return 0;
159	0	}
160	0	r->mac = (OSSL_PARAM *)p;
161	0	}
162	0	break;
163	0	case 'o':
164	0	if (ossl_likely(strcmp("de", s + 2) == 0)) {
165		/* OSSL_KDF_PARAM_MODE */
166	0	if (ossl_unlikely(r->mode != NULL)) {
167	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
168	0	"param %s is repeated", s);
169	0	return 0;
170	0	}
171	0	r->mode = (OSSL_PARAM *)p;
172	0	}
173	0	}
174	0	break;
175	0	case 'p':
176	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
177		/* OSSL_KDF_PARAM_PROPERTIES */
178	0	if (ossl_unlikely(r->propq != NULL)) {
179	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
180	0	"param %s is repeated", s);
181	0	return 0;
182	0	}
183	0	r->propq = (OSSL_PARAM *)p;
184	0	}
185	0	break;
186	0	case 'r':
187	0	switch(s[1]) {
188	0	default:
189	0	break;
190	0	case '\0':
191	0	if (ossl_unlikely(r->r != NULL)) {
192	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
193	0	"param %s is repeated", s);
194	0	return 0;
195	0	}
196	0	r->r = (OSSL_PARAM *)p;
197	0	}
198	0	break;
199	0	case 's':
200	0	switch(s[1]) {
201	0	default:
202	0	break;
203	0	case 'a':
204	0	if (ossl_likely(strcmp("lt", s + 2) == 0)) {
205		/* OSSL_KDF_PARAM_SALT */
206	0	if (ossl_unlikely(r->salt != NULL)) {
207	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
208	0	"param %s is repeated", s);
209	0	return 0;
210	0	}
211	0	r->salt = (OSSL_PARAM *)p;
212	0	}
213	0	break;
214	0	case 'e':
215	0	if (ossl_likely(strcmp("ed", s + 2) == 0)) {
216		/* OSSL_KDF_PARAM_SEED */
217	0	if (ossl_unlikely(r->seed != NULL)) {
218	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
219	0	"param %s is repeated", s);
220	0	return 0;
221	0	}
222	0	r->seed = (OSSL_PARAM *)p;
223	0	}
224	0	}
225	0	break;
226	0	case 'u':
227	0	switch(s[1]) {
228	0	default:
229	0	break;
230	0	case 's':
231	0	switch(s[2]) {
232	0	default:
233	0	break;
234	0	case 'e':
235	0	switch(s[3]) {
236	0	default:
237	0	break;
238	0	case '-':
239	0	switch(s[4]) {
240	0	default:
241	0	break;
242	0	case 'l':
243	0	switch(s[5]) {
244	0	default:
245	0	break;
246	0	case '\0':
247	0	if (ossl_unlikely(r->use_l != NULL)) {
248	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
249	0	"param %s is repeated", s);
250	0	return 0;
251	0	}
252	0	r->use_l = (OSSL_PARAM *)p;
253	0	}
254	0	break;
255	0	case 's':
256	0	if (ossl_likely(strcmp("eparator", s + 5) == 0)) {
257		/* OSSL_KDF_PARAM_KBKDF_USE_SEPARATOR */
258	0	if (ossl_unlikely(r->sep != NULL)) {
259	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
260	0	"param %s is repeated", s);
261	0	return 0;
262	0	}
263	0	r->sep = (OSSL_PARAM *)p;
264	0	}
265	0	}
266	0	}
267	0	}
268	0	}
269	0	}
270	0	return 1;
271	0	}
272		#endif
273		/* End of machine generated */
274
275		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
276		#ifndef kbkdf_get_ctx_params_list
277		static const OSSL_PARAM kbkdf_get_ctx_params_list[] = {
278		OSSL_PARAM_size_t(OSSL_KDF_PARAM_SIZE, NULL),
279		# if defined(FIPS_MODULE)
280		OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR, NULL),
281		# endif
282		OSSL_PARAM_END
283		};
284		#endif
285
286		#ifndef kbkdf_get_ctx_params_st
287		struct kbkdf_get_ctx_params_st {
288		# if defined(FIPS_MODULE)
289		OSSL_PARAM *ind;
290		# endif
291		OSSL_PARAM *size;
292		};
293		#endif
294
295		#ifndef kbkdf_get_ctx_params_decoder
296		static int kbkdf_get_ctx_params_decoder
297		(const OSSL_PARAM p, struct kbkdf_get_ctx_params_st r)
298	0	{
299	0	const char *s;
300
301	0	memset(r, 0, sizeof(*r));
302	0	if (p != NULL)
303	0	for (; (s = p->key) != NULL; p++)
304	0	switch(s[0]) {
305	0	default:
306	0	break;
307	0	case 'f':
308		# if defined(FIPS_MODULE)
309		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
310		/* OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR */
311		if (ossl_unlikely(r->ind != NULL)) {
312		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
313		"param %s is repeated", s);
314		return 0;
315		}
316		r->ind = (OSSL_PARAM *)p;
317		}
318		# endif
319	0	break;
320	0	case 's':
321	0	if (ossl_likely(strcmp("ize", s + 1) == 0)) {
322		/* OSSL_KDF_PARAM_SIZE */
323	0	if (ossl_unlikely(r->size != NULL)) {
324	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
325	0	"param %s is repeated", s);
326	0	return 0;
327	0	}
328	0	r->size = (OSSL_PARAM *)p;
329	0	}
330	0	}
331	0	return 1;
332	0	}
333		#endif
334		/* End of machine generated */