Coverage Report

Created: 2025-10-28 06:56

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/openssl/providers/implementations/kdfs/hkdf.inc
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 hkdf_set_ctx_params_list
14
static const OSSL_PARAM hkdf_set_ctx_params_list[] = {
15
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MODE, NULL, 0),
16
    OSSL_PARAM_int(OSSL_KDF_PARAM_MODE, NULL),
17
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
18
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),
19
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_KEY, NULL, 0),
20
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
21
# if defined(FIPS_MODULE)
22
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_KEY_CHECK, NULL),
23
# endif
24
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_INFO, NULL, 0),
25
    OSSL_PARAM_END
26
};
27
#endif
28
29
#ifndef hkdf_set_ctx_params_st
30
struct hkdf_set_ctx_params_st {
31
    OSSL_PARAM *digest;
32
    OSSL_PARAM *engine;
33
# if defined(FIPS_MODULE)
34
    OSSL_PARAM *ind_k;
35
# endif
36
    OSSL_PARAM *info[HKDF_MAX_INFOS];
37
    int num_info;
38
    OSSL_PARAM *key;
39
    OSSL_PARAM *mode;
40
    OSSL_PARAM *propq;
41
    OSSL_PARAM *salt;
42
};
43
#endif
44
45
#ifndef hkdf_set_ctx_params_decoder
46
static int hkdf_set_ctx_params_decoder
47
    (const OSSL_PARAM *p, struct hkdf_set_ctx_params_st *r)
48
0
{
49
0
    const char *s;
50
51
0
    memset(r, 0, sizeof(*r));
52
0
    if (p != NULL)
53
0
        for (; (s = p->key) != NULL; p++)
54
0
            switch(s[0]) {
55
0
            default:
56
0
                break;
57
0
            case 'd':
58
0
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
59
                    /* OSSL_KDF_PARAM_DIGEST */
60
0
                    if (ossl_unlikely(r->digest != NULL)) {
61
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
62
0
                                       "param %s is repeated", s);
63
0
                        return 0;
64
0
                    }
65
0
                    r->digest = (OSSL_PARAM *)p;
66
0
                }
67
0
                break;
68
0
            case 'e':
69
0
                if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
70
                    /* OSSL_ALG_PARAM_ENGINE */
71
0
                    if (ossl_unlikely(r->engine != 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->engine = (OSSL_PARAM *)p;
77
0
                }
78
0
                break;
79
0
            case 'i':
80
0
                if (ossl_likely(strcmp("nfo", s + 1) == 0)) {
81
                    /* OSSL_KDF_PARAM_INFO */
82
0
                    if (ossl_unlikely(r->num_info >= HKDF_MAX_INFOS)) {
83
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_TOO_MANY_RECORDS,
84
0
                                       "param %s present >%d times", s, HKDF_MAX_INFOS);
85
0
                        return 0;
86
0
                    }
87
0
                    r->info[r->num_info++] = (OSSL_PARAM *)p;
88
0
                }
89
0
                break;
90
0
            case 'k':
91
0
                switch(s[1]) {
92
0
                default:
93
0
                    break;
94
0
                case 'e':
95
0
                    switch(s[2]) {
96
0
                    default:
97
0
                        break;
98
0
                    case 'y':
99
0
                        switch(s[3]) {
100
0
                        default:
101
0
                            break;
102
0
                        case '-':
103
# if defined(FIPS_MODULE)
104
                            if (ossl_likely(strcmp("check", s + 4) == 0)) {
105
                                /* OSSL_KDF_PARAM_FIPS_KEY_CHECK */
106
                                if (ossl_unlikely(r->ind_k != NULL)) {
107
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
108
                                                   "param %s is repeated", s);
109
                                    return 0;
110
                                }
111
                                r->ind_k = (OSSL_PARAM *)p;
112
                            }
113
# endif
114
0
                            break;
115
0
                        case '\0':
116
0
                            if (ossl_unlikely(r->key != 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->key = (OSSL_PARAM *)p;
122
0
                        }
123
0
                    }
124
0
                }
125
0
                break;
126
0
            case 'm':
127
0
                if (ossl_likely(strcmp("ode", s + 1) == 0)) {
128
                    /* OSSL_KDF_PARAM_MODE */
129
0
                    if (ossl_unlikely(r->mode != NULL)) {
130
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
131
0
                                       "param %s is repeated", s);
132
0
                        return 0;
133
0
                    }
134
0
                    r->mode = (OSSL_PARAM *)p;
135
0
                }
136
0
                break;
137
0
            case 'p':
138
0
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
139
                    /* OSSL_KDF_PARAM_PROPERTIES */
140
0
                    if (ossl_unlikely(r->propq != 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->propq = (OSSL_PARAM *)p;
146
0
                }
147
0
                break;
148
0
            case 's':
149
0
                if (ossl_likely(strcmp("alt", s + 1) == 0)) {
150
                    /* OSSL_KDF_PARAM_SALT */
151
0
                    if (ossl_unlikely(r->salt != NULL)) {
152
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
153
0
                                       "param %s is repeated", s);
154
0
                        return 0;
155
0
                    }
156
0
                    r->salt = (OSSL_PARAM *)p;
157
0
                }
158
0
            }
159
0
    return 1;
160
0
}
161
#endif
162
/* End of machine generated */
163
164
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
165
#ifndef hkdf_get_ctx_params_list
166
static const OSSL_PARAM hkdf_get_ctx_params_list[] = {
167
    OSSL_PARAM_size_t(OSSL_KDF_PARAM_SIZE, NULL),
168
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),
169
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MODE, NULL, 0),
170
    OSSL_PARAM_int(OSSL_KDF_PARAM_MODE, NULL),
171
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
172
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_INFO, NULL, 0),
173
# if defined(FIPS_MODULE)
174
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR, NULL),
175
# endif
176
    OSSL_PARAM_END
177
};
178
#endif
179
180
#ifndef hkdf_get_ctx_params_st
181
struct hkdf_get_ctx_params_st {
182
    OSSL_PARAM *digest;
183
# if defined(FIPS_MODULE)
184
    OSSL_PARAM *ind;
185
# endif
186
    OSSL_PARAM *info;
187
    OSSL_PARAM *mode;
188
    OSSL_PARAM *salt;
189
    OSSL_PARAM *size;
190
};
191
#endif
192
193
#ifndef hkdf_get_ctx_params_decoder
194
static int hkdf_get_ctx_params_decoder
195
    (const OSSL_PARAM *p, struct hkdf_get_ctx_params_st *r)
196
0
{
197
0
    const char *s;
198
199
0
    memset(r, 0, sizeof(*r));
200
0
    if (p != NULL)
201
0
        for (; (s = p->key) != NULL; p++)
202
0
            switch(s[0]) {
203
0
            default:
204
0
                break;
205
0
            case 'd':
206
0
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
207
                    /* OSSL_KDF_PARAM_DIGEST */
208
0
                    if (ossl_unlikely(r->digest != NULL)) {
209
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
210
0
                                       "param %s is repeated", s);
211
0
                        return 0;
212
0
                    }
213
0
                    r->digest = (OSSL_PARAM *)p;
214
0
                }
215
0
                break;
216
0
            case 'f':
217
# if defined(FIPS_MODULE)
218
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
219
                    /* OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR */
220
                    if (ossl_unlikely(r->ind != NULL)) {
221
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
222
                                       "param %s is repeated", s);
223
                        return 0;
224
                    }
225
                    r->ind = (OSSL_PARAM *)p;
226
                }
227
# endif
228
0
                break;
229
0
            case 'i':
230
0
                if (ossl_likely(strcmp("nfo", s + 1) == 0)) {
231
                    /* OSSL_KDF_PARAM_INFO */
232
0
                    if (ossl_unlikely(r->info != NULL)) {
233
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
234
0
                                       "param %s is repeated", s);
235
0
                        return 0;
236
0
                    }
237
0
                    r->info = (OSSL_PARAM *)p;
238
0
                }
239
0
                break;
240
0
            case 'm':
241
0
                if (ossl_likely(strcmp("ode", s + 1) == 0)) {
242
                    /* OSSL_KDF_PARAM_MODE */
243
0
                    if (ossl_unlikely(r->mode != NULL)) {
244
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
245
0
                                       "param %s is repeated", s);
246
0
                        return 0;
247
0
                    }
248
0
                    r->mode = (OSSL_PARAM *)p;
249
0
                }
250
0
                break;
251
0
            case 's':
252
0
                switch(s[1]) {
253
0
                default:
254
0
                    break;
255
0
                case 'a':
256
0
                    if (ossl_likely(strcmp("lt", s + 2) == 0)) {
257
                        /* OSSL_KDF_PARAM_SALT */
258
0
                        if (ossl_unlikely(r->salt != 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->salt = (OSSL_PARAM *)p;
264
0
                    }
265
0
                    break;
266
0
                case 'i':
267
0
                    if (ossl_likely(strcmp("ze", s + 2) == 0)) {
268
                        /* OSSL_KDF_PARAM_SIZE */
269
0
                        if (ossl_unlikely(r->size != NULL)) {
270
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
271
0
                                           "param %s is repeated", s);
272
0
                            return 0;
273
0
                        }
274
0
                        r->size = (OSSL_PARAM *)p;
275
0
                    }
276
0
                }
277
0
            }
278
0
    return 1;
279
0
}
280
#endif
281
/* End of machine generated */
282
283
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
284
#ifndef hkdf_fixed_digest_set_ctx_params_list
285
static const OSSL_PARAM hkdf_fixed_digest_set_ctx_params_list[] = {
286
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MODE, NULL, 0),
287
    OSSL_PARAM_int(OSSL_KDF_PARAM_MODE, NULL),
288
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_KEY, NULL, 0),
289
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
290
# if defined(FIPS_MODULE)
291
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_KEY_CHECK, NULL),
292
# endif
293
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_INFO, NULL, 0),
294
    OSSL_PARAM_END
295
};
296
#endif
297
298
#ifndef hkdf_fixed_digest_set_ctx_params_st
299
struct hkdf_fixed_digest_set_ctx_params_st {
300
    OSSL_PARAM *digest;
301
# if defined(FIPS_MODULE)
302
    OSSL_PARAM *ind_k;
303
# endif
304
    OSSL_PARAM *info[HKDF_MAX_INFOS];
305
    int num_info;
306
    OSSL_PARAM *key;
307
    OSSL_PARAM *mode;
308
    OSSL_PARAM *salt;
309
};
310
#endif
311
312
#ifndef hkdf_fixed_digest_set_ctx_params_decoder
313
static int hkdf_fixed_digest_set_ctx_params_decoder
314
    (const OSSL_PARAM *p, struct hkdf_fixed_digest_set_ctx_params_st *r)
315
0
{
316
0
    const char *s;
317
318
0
    memset(r, 0, sizeof(*r));
319
0
    if (p != NULL)
320
0
        for (; (s = p->key) != NULL; p++)
321
0
            switch(s[0]) {
322
0
            default:
323
0
                break;
324
0
            case 'd':
325
0
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
326
                    /* OSSL_KDF_PARAM_DIGEST */
327
0
                    if (ossl_unlikely(r->digest != NULL)) {
328
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
329
0
                                       "param %s is repeated", s);
330
0
                        return 0;
331
0
                    }
332
0
                    r->digest = (OSSL_PARAM *)p;
333
0
                }
334
0
                break;
335
0
            case 'i':
336
0
                if (ossl_likely(strcmp("nfo", s + 1) == 0)) {
337
                    /* OSSL_KDF_PARAM_INFO */
338
0
                    if (ossl_unlikely(r->num_info >= HKDF_MAX_INFOS)) {
339
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_TOO_MANY_RECORDS,
340
0
                                       "param %s present >%d times", s, HKDF_MAX_INFOS);
341
0
                        return 0;
342
0
                    }
343
0
                    r->info[r->num_info++] = (OSSL_PARAM *)p;
344
0
                }
345
0
                break;
346
0
            case 'k':
347
0
                switch(s[1]) {
348
0
                default:
349
0
                    break;
350
0
                case 'e':
351
0
                    switch(s[2]) {
352
0
                    default:
353
0
                        break;
354
0
                    case 'y':
355
0
                        switch(s[3]) {
356
0
                        default:
357
0
                            break;
358
0
                        case '-':
359
# if defined(FIPS_MODULE)
360
                            if (ossl_likely(strcmp("check", s + 4) == 0)) {
361
                                /* OSSL_KDF_PARAM_FIPS_KEY_CHECK */
362
                                if (ossl_unlikely(r->ind_k != NULL)) {
363
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
364
                                                   "param %s is repeated", s);
365
                                    return 0;
366
                                }
367
                                r->ind_k = (OSSL_PARAM *)p;
368
                            }
369
# endif
370
0
                            break;
371
0
                        case '\0':
372
0
                            if (ossl_unlikely(r->key != NULL)) {
373
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
374
0
                                               "param %s is repeated", s);
375
0
                                return 0;
376
0
                            }
377
0
                            r->key = (OSSL_PARAM *)p;
378
0
                        }
379
0
                    }
380
0
                }
381
0
                break;
382
0
            case 'm':
383
0
                if (ossl_likely(strcmp("ode", s + 1) == 0)) {
384
                    /* OSSL_KDF_PARAM_MODE */
385
0
                    if (ossl_unlikely(r->mode != NULL)) {
386
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
387
0
                                       "param %s is repeated", s);
388
0
                        return 0;
389
0
                    }
390
0
                    r->mode = (OSSL_PARAM *)p;
391
0
                }
392
0
                break;
393
0
            case 's':
394
0
                if (ossl_likely(strcmp("alt", s + 1) == 0)) {
395
                    /* OSSL_KDF_PARAM_SALT */
396
0
                    if (ossl_unlikely(r->salt != NULL)) {
397
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
398
0
                                       "param %s is repeated", s);
399
0
                        return 0;
400
0
                    }
401
0
                    r->salt = (OSSL_PARAM *)p;
402
0
                }
403
0
            }
404
0
    return 1;
405
0
}
406
#endif
407
/* End of machine generated */
408
409
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
410
#ifndef kdf_tls1_3_set_ctx_params_list
411
static const OSSL_PARAM kdf_tls1_3_set_ctx_params_list[] = {
412
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_MODE, NULL, 0),
413
    OSSL_PARAM_int(OSSL_KDF_PARAM_MODE, NULL),
414
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
415
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_DIGEST, NULL, 0),
416
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_KEY, NULL, 0),
417
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_SALT, NULL, 0),
418
# if defined(FIPS_MODULE)
419
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_KEY_CHECK, NULL),
420
# endif
421
# if defined(FIPS_MODULE)
422
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_DIGEST_CHECK, NULL),
423
# endif
424
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_PREFIX, NULL, 0),
425
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_LABEL, NULL, 0),
426
    OSSL_PARAM_octet_string(OSSL_KDF_PARAM_DATA, NULL, 0),
427
    OSSL_PARAM_END
428
};
429
#endif
430
431
#ifndef kdf_tls1_3_set_ctx_params_st
432
struct kdf_tls1_3_set_ctx_params_st {
433
    OSSL_PARAM *data;
434
    OSSL_PARAM *digest;
435
    OSSL_PARAM *engine;
436
# if defined(FIPS_MODULE)
437
    OSSL_PARAM *ind_d;
438
# endif
439
# if defined(FIPS_MODULE)
440
    OSSL_PARAM *ind_k;
441
# endif
442
    OSSL_PARAM *key;
443
    OSSL_PARAM *label;
444
    OSSL_PARAM *mode;
445
    OSSL_PARAM *prefix;
446
    OSSL_PARAM *propq;
447
    OSSL_PARAM *salt;
448
};
449
#endif
450
451
#ifndef kdf_tls1_3_set_ctx_params_decoder
452
static int kdf_tls1_3_set_ctx_params_decoder
453
    (const OSSL_PARAM *p, struct kdf_tls1_3_set_ctx_params_st *r)
454
0
{
455
0
    const char *s;
456
457
0
    memset(r, 0, sizeof(*r));
458
0
    if (p != NULL)
459
0
        for (; (s = p->key) != NULL; p++)
460
0
            switch(s[0]) {
461
0
            default:
462
0
                break;
463
0
            case 'd':
464
0
                switch(s[1]) {
465
0
                default:
466
0
                    break;
467
0
                case 'a':
468
0
                    if (ossl_likely(strcmp("ta", s + 2) == 0)) {
469
                        /* OSSL_KDF_PARAM_DATA */
470
0
                        if (ossl_unlikely(r->data != NULL)) {
471
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
472
0
                                           "param %s is repeated", s);
473
0
                            return 0;
474
0
                        }
475
0
                        r->data = (OSSL_PARAM *)p;
476
0
                    }
477
0
                    break;
478
0
                case 'i':
479
0
                    switch(s[2]) {
480
0
                    default:
481
0
                        break;
482
0
                    case 'g':
483
0
                        switch(s[3]) {
484
0
                        default:
485
0
                            break;
486
0
                        case 'e':
487
0
                            switch(s[4]) {
488
0
                            default:
489
0
                                break;
490
0
                            case 's':
491
0
                                switch(s[5]) {
492
0
                                default:
493
0
                                    break;
494
0
                                case 't':
495
0
                                    switch(s[6]) {
496
0
                                    default:
497
0
                                        break;
498
0
                                    case '-':
499
# if defined(FIPS_MODULE)
500
                                        if (ossl_likely(strcmp("check", s + 7) == 0)) {
501
                                            /* OSSL_KDF_PARAM_FIPS_DIGEST_CHECK */
502
                                            if (ossl_unlikely(r->ind_d != NULL)) {
503
                                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
504
                                                               "param %s is repeated", s);
505
                                                return 0;
506
                                            }
507
                                            r->ind_d = (OSSL_PARAM *)p;
508
                                        }
509
# endif
510
0
                                        break;
511
0
                                    case '\0':
512
0
                                        if (ossl_unlikely(r->digest != NULL)) {
513
0
                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
514
0
                                                           "param %s is repeated", s);
515
0
                                            return 0;
516
0
                                        }
517
0
                                        r->digest = (OSSL_PARAM *)p;
518
0
                                    }
519
0
                                }
520
0
                            }
521
0
                        }
522
0
                    }
523
0
                }
524
0
                break;
525
0
            case 'e':
526
0
                if (ossl_likely(strcmp("ngine", s + 1) == 0)) {
527
                    /* OSSL_ALG_PARAM_ENGINE */
528
0
                    if (ossl_unlikely(r->engine != NULL)) {
529
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
530
0
                                       "param %s is repeated", s);
531
0
                        return 0;
532
0
                    }
533
0
                    r->engine = (OSSL_PARAM *)p;
534
0
                }
535
0
                break;
536
0
            case 'k':
537
0
                switch(s[1]) {
538
0
                default:
539
0
                    break;
540
0
                case 'e':
541
0
                    switch(s[2]) {
542
0
                    default:
543
0
                        break;
544
0
                    case 'y':
545
0
                        switch(s[3]) {
546
0
                        default:
547
0
                            break;
548
0
                        case '-':
549
# if defined(FIPS_MODULE)
550
                            if (ossl_likely(strcmp("check", s + 4) == 0)) {
551
                                /* OSSL_KDF_PARAM_FIPS_KEY_CHECK */
552
                                if (ossl_unlikely(r->ind_k != NULL)) {
553
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
554
                                                   "param %s is repeated", s);
555
                                    return 0;
556
                                }
557
                                r->ind_k = (OSSL_PARAM *)p;
558
                            }
559
# endif
560
0
                            break;
561
0
                        case '\0':
562
0
                            if (ossl_unlikely(r->key != NULL)) {
563
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
564
0
                                               "param %s is repeated", s);
565
0
                                return 0;
566
0
                            }
567
0
                            r->key = (OSSL_PARAM *)p;
568
0
                        }
569
0
                    }
570
0
                }
571
0
                break;
572
0
            case 'l':
573
0
                if (ossl_likely(strcmp("abel", s + 1) == 0)) {
574
                    /* OSSL_KDF_PARAM_LABEL */
575
0
                    if (ossl_unlikely(r->label != NULL)) {
576
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
577
0
                                       "param %s is repeated", s);
578
0
                        return 0;
579
0
                    }
580
0
                    r->label = (OSSL_PARAM *)p;
581
0
                }
582
0
                break;
583
0
            case 'm':
584
0
                if (ossl_likely(strcmp("ode", s + 1) == 0)) {
585
                    /* OSSL_KDF_PARAM_MODE */
586
0
                    if (ossl_unlikely(r->mode != NULL)) {
587
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
588
0
                                       "param %s is repeated", s);
589
0
                        return 0;
590
0
                    }
591
0
                    r->mode = (OSSL_PARAM *)p;
592
0
                }
593
0
                break;
594
0
            case 'p':
595
0
                switch(s[1]) {
596
0
                default:
597
0
                    break;
598
0
                case 'r':
599
0
                    switch(s[2]) {
600
0
                    default:
601
0
                        break;
602
0
                    case 'e':
603
0
                        if (ossl_likely(strcmp("fix", s + 3) == 0)) {
604
                            /* OSSL_KDF_PARAM_PREFIX */
605
0
                            if (ossl_unlikely(r->prefix != NULL)) {
606
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
607
0
                                               "param %s is repeated", s);
608
0
                                return 0;
609
0
                            }
610
0
                            r->prefix = (OSSL_PARAM *)p;
611
0
                        }
612
0
                        break;
613
0
                    case 'o':
614
0
                        if (ossl_likely(strcmp("perties", s + 3) == 0)) {
615
                            /* OSSL_KDF_PARAM_PROPERTIES */
616
0
                            if (ossl_unlikely(r->propq != NULL)) {
617
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
618
0
                                               "param %s is repeated", s);
619
0
                                return 0;
620
0
                            }
621
0
                            r->propq = (OSSL_PARAM *)p;
622
0
                        }
623
0
                    }
624
0
                }
625
0
                break;
626
0
            case 's':
627
0
                if (ossl_likely(strcmp("alt", s + 1) == 0)) {
628
                    /* OSSL_KDF_PARAM_SALT */
629
0
                    if (ossl_unlikely(r->salt != NULL)) {
630
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
631
0
                                       "param %s is repeated", s);
632
0
                        return 0;
633
0
                    }
634
0
                    r->salt = (OSSL_PARAM *)p;
635
0
                }
636
0
            }
637
0
    return 1;
638
0
}
639
#endif
640
/* End of machine generated */