/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 */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#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;
# 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 '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 */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

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