Coverage Report

Created: 2026-09-12 06:55

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/openssl41/providers/implementations/rands/drbg_hash.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
#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 drbg_hash_get_ctx_params_list
21
static ossl_unused const OSSL_PARAM drbg_hash_get_ctx_params_list[] = {
22
    OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_DIGEST, NULL, 0),
23
    OSSL_PARAM_int(OSSL_RAND_PARAM_STATE, NULL),
24
    OSSL_PARAM_uint(OSSL_RAND_PARAM_STRENGTH, NULL),
25
    OSSL_PARAM_size_t(OSSL_RAND_PARAM_MAX_REQUEST, NULL),
26
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MIN_ENTROPYLEN, NULL),
27
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_ENTROPYLEN, NULL),
28
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MIN_NONCELEN, NULL),
29
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_NONCELEN, NULL),
30
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_PERSLEN, NULL),
31
    OSSL_PARAM_size_t(OSSL_DRBG_PARAM_MAX_ADINLEN, NULL),
32
    OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_COUNTER, NULL),
33
    OSSL_PARAM_time_t(OSSL_DRBG_PARAM_RESEED_TIME, NULL),
34
    OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_REQUESTS, NULL),
35
    OSSL_PARAM_uint64(OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL, NULL),
36
# if defined(FIPS_MODULE)
37
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR, NULL),
38
# endif
39
    OSSL_PARAM_END
40
};
41
#endif
42
43
#ifndef drbg_hash_get_ctx_params_st
44
struct drbg_hash_get_ctx_params_st {
45
    OSSL_PARAM *digest;
46
# if defined(FIPS_MODULE)
47
    OSSL_PARAM *ind;
48
# endif
49
    OSSL_PARAM *maxadlen;
50
    OSSL_PARAM *maxentlen;
51
    OSSL_PARAM *maxnonlen;
52
    OSSL_PARAM *maxperlen;
53
    OSSL_PARAM *maxreq;
54
    OSSL_PARAM *minentlen;
55
    OSSL_PARAM *minnonlen;
56
    OSSL_PARAM *reseed_cnt;
57
    OSSL_PARAM *reseed_int;
58
    OSSL_PARAM *reseed_req;
59
    OSSL_PARAM *reseed_time;
60
    OSSL_PARAM *state;
61
    OSSL_PARAM *str;
62
};
63
#endif
64
65
#ifndef drbg_hash_get_ctx_params_decoder
66
static ossl_unused int drbg_hash_get_ctx_params_decoder
67
    (const OSSL_PARAM *p, struct drbg_hash_get_ctx_params_st *r)
68
181
{
69
181
    const char *s;
70
71
181
    memset(r, 0, sizeof(*r));
72
181
    if (p != NULL)
73
362
        for (; (s = p->key) != NULL; p++)
74
181
            switch(s[0]) {
75
0
            default:
76
0
                break;
77
0
            case 'd':
78
0
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
79
                    /* OSSL_DRBG_PARAM_DIGEST */
80
0
                    if (ossl_unlikely(r->digest != NULL)) {
81
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
82
0
                                       "param %s is repeated", s);
83
0
                        return 0;
84
0
                    }
85
0
                    r->digest = (OSSL_PARAM *)p;
86
0
                }
87
0
                break;
88
0
            case 'f':
89
# if defined(FIPS_MODULE)
90
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
91
                    /* OSSL_KDF_PARAM_FIPS_APPROVED_INDICATOR */
92
                    if (ossl_unlikely(r->ind != NULL)) {
93
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
94
                                       "param %s is repeated", s);
95
                        return 0;
96
                    }
97
                    r->ind = (OSSL_PARAM *)p;
98
                }
99
# endif
100
0
                break;
101
181
            case 'm':
102
181
                switch(s[1]) {
103
0
                default:
104
0
                    break;
105
181
                case 'a':
106
181
                    switch(s[2]) {
107
0
                    default:
108
0
                        break;
109
181
                    case 'x':
110
181
                        switch(s[3]) {
111
0
                        default:
112
0
                            break;
113
181
                        case '_':
114
181
                            switch(s[4]) {
115
0
                            default:
116
0
                                break;
117
0
                            case 'a':
118
0
                                if (ossl_likely(strcmp("dinlen", s + 5) == 0)) {
119
                                    /* OSSL_DRBG_PARAM_MAX_ADINLEN */
120
0
                                    if (ossl_unlikely(r->maxadlen != NULL)) {
121
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
122
0
                                                       "param %s is repeated", s);
123
0
                                        return 0;
124
0
                                    }
125
0
                                    r->maxadlen = (OSSL_PARAM *)p;
126
0
                                }
127
0
                                break;
128
0
                            case 'e':
129
0
                                if (ossl_likely(strcmp("ntropylen", s + 5) == 0)) {
130
                                    /* OSSL_DRBG_PARAM_MAX_ENTROPYLEN */
131
0
                                    if (ossl_unlikely(r->maxentlen != 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->maxentlen = (OSSL_PARAM *)p;
137
0
                                }
138
0
                                break;
139
0
                            case 'n':
140
0
                                if (ossl_likely(strcmp("oncelen", s + 5) == 0)) {
141
                                    /* OSSL_DRBG_PARAM_MAX_NONCELEN */
142
0
                                    if (ossl_unlikely(r->maxnonlen != NULL)) {
143
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
144
0
                                                       "param %s is repeated", s);
145
0
                                        return 0;
146
0
                                    }
147
0
                                    r->maxnonlen = (OSSL_PARAM *)p;
148
0
                                }
149
0
                                break;
150
0
                            case 'p':
151
0
                                if (ossl_likely(strcmp("erslen", s + 5) == 0)) {
152
                                    /* OSSL_DRBG_PARAM_MAX_PERSLEN */
153
0
                                    if (ossl_unlikely(r->maxperlen != NULL)) {
154
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
155
0
                                                       "param %s is repeated", s);
156
0
                                        return 0;
157
0
                                    }
158
0
                                    r->maxperlen = (OSSL_PARAM *)p;
159
0
                                }
160
0
                                break;
161
181
                            case 'r':
162
181
                                if (ossl_likely(strcmp("equest", s + 5) == 0)) {
163
                                    /* OSSL_RAND_PARAM_MAX_REQUEST */
164
181
                                    if (ossl_unlikely(r->maxreq != NULL)) {
165
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
166
0
                                                       "param %s is repeated", s);
167
0
                                        return 0;
168
0
                                    }
169
181
                                    r->maxreq = (OSSL_PARAM *)p;
170
181
                                }
171
181
                            }
172
181
                        }
173
181
                    }
174
181
                    break;
175
181
                case 'i':
176
0
                    switch(s[2]) {
177
0
                    default:
178
0
                        break;
179
0
                    case 'n':
180
0
                        switch(s[3]) {
181
0
                        default:
182
0
                            break;
183
0
                        case '_':
184
0
                            switch(s[4]) {
185
0
                            default:
186
0
                                break;
187
0
                            case 'e':
188
0
                                if (ossl_likely(strcmp("ntropylen", s + 5) == 0)) {
189
                                    /* OSSL_DRBG_PARAM_MIN_ENTROPYLEN */
190
0
                                    if (ossl_unlikely(r->minentlen != NULL)) {
191
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
192
0
                                                       "param %s is repeated", s);
193
0
                                        return 0;
194
0
                                    }
195
0
                                    r->minentlen = (OSSL_PARAM *)p;
196
0
                                }
197
0
                                break;
198
0
                            case 'n':
199
0
                                if (ossl_likely(strcmp("oncelen", s + 5) == 0)) {
200
                                    /* OSSL_DRBG_PARAM_MIN_NONCELEN */
201
0
                                    if (ossl_unlikely(r->minnonlen != NULL)) {
202
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
203
0
                                                       "param %s is repeated", s);
204
0
                                        return 0;
205
0
                                    }
206
0
                                    r->minnonlen = (OSSL_PARAM *)p;
207
0
                                }
208
0
                            }
209
0
                        }
210
0
                    }
211
181
                }
212
181
                break;
213
181
            case 'r':
214
0
                switch(s[1]) {
215
0
                default:
216
0
                    break;
217
0
                case 'e':
218
0
                    switch(s[2]) {
219
0
                    default:
220
0
                        break;
221
0
                    case 's':
222
0
                        switch(s[3]) {
223
0
                        default:
224
0
                            break;
225
0
                        case 'e':
226
0
                            switch(s[4]) {
227
0
                            default:
228
0
                                break;
229
0
                            case 'e':
230
0
                                switch(s[5]) {
231
0
                                default:
232
0
                                    break;
233
0
                                case 'd':
234
0
                                    switch(s[6]) {
235
0
                                    default:
236
0
                                        break;
237
0
                                    case '_':
238
0
                                        switch(s[7]) {
239
0
                                        default:
240
0
                                            break;
241
0
                                        case 'c':
242
0
                                            if (ossl_likely(strcmp("ounter", s + 8) == 0)) {
243
                                                /* OSSL_DRBG_PARAM_RESEED_COUNTER */
244
0
                                                if (ossl_unlikely(r->reseed_cnt != NULL)) {
245
0
                                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
246
0
                                                                   "param %s is repeated", s);
247
0
                                                    return 0;
248
0
                                                }
249
0
                                                r->reseed_cnt = (OSSL_PARAM *)p;
250
0
                                            }
251
0
                                            break;
252
0
                                        case 'r':
253
0
                                            if (ossl_likely(strcmp("equests", s + 8) == 0)) {
254
                                                /* OSSL_DRBG_PARAM_RESEED_REQUESTS */
255
0
                                                if (ossl_unlikely(r->reseed_req != 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
0
                                                r->reseed_req = (OSSL_PARAM *)p;
261
0
                                            }
262
0
                                            break;
263
0
                                        case 't':
264
0
                                            switch(s[8]) {
265
0
                                            default:
266
0
                                                break;
267
0
                                            case 'i':
268
0
                                                switch(s[9]) {
269
0
                                                default:
270
0
                                                    break;
271
0
                                                case 'm':
272
0
                                                    switch(s[10]) {
273
0
                                                    default:
274
0
                                                        break;
275
0
                                                    case 'e':
276
0
                                                        switch(s[11]) {
277
0
                                                        default:
278
0
                                                            break;
279
0
                                                        case '_':
280
0
                                                            if (ossl_likely(strcmp("interval", s + 12) == 0)) {
281
                                                                /* OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL */
282
0
                                                                if (ossl_unlikely(r->reseed_int != NULL)) {
283
0
                                                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
284
0
                                                                                   "param %s is repeated", s);
285
0
                                                                    return 0;
286
0
                                                                }
287
0
                                                                r->reseed_int = (OSSL_PARAM *)p;
288
0
                                                            }
289
0
                                                            break;
290
0
                                                        case '\0':
291
0
                                                            if (ossl_unlikely(r->reseed_time != NULL)) {
292
0
                                                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
293
0
                                                                               "param %s is repeated", s);
294
0
                                                                return 0;
295
0
                                                            }
296
0
                                                            r->reseed_time = (OSSL_PARAM *)p;
297
0
                                                        }
298
0
                                                    }
299
0
                                                }
300
0
                                            }
301
0
                                        }
302
0
                                    }
303
0
                                }
304
0
                            }
305
0
                        }
306
0
                    }
307
0
                }
308
0
                break;
309
0
            case 's':
310
0
                switch(s[1]) {
311
0
                default:
312
0
                    break;
313
0
                case 't':
314
0
                    switch(s[2]) {
315
0
                    default:
316
0
                        break;
317
0
                    case 'a':
318
0
                        if (ossl_likely(strcmp("te", s + 3) == 0)) {
319
                            /* OSSL_RAND_PARAM_STATE */
320
0
                            if (ossl_unlikely(r->state != NULL)) {
321
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
322
0
                                               "param %s is repeated", s);
323
0
                                return 0;
324
0
                            }
325
0
                            r->state = (OSSL_PARAM *)p;
326
0
                        }
327
0
                        break;
328
0
                    case 'r':
329
0
                        if (ossl_likely(strcmp("ength", s + 3) == 0)) {
330
                            /* OSSL_RAND_PARAM_STRENGTH */
331
0
                            if (ossl_unlikely(r->str != NULL)) {
332
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
333
0
                                               "param %s is repeated", s);
334
0
                                return 0;
335
0
                            }
336
0
                            r->str = (OSSL_PARAM *)p;
337
0
                        }
338
0
                    }
339
0
                }
340
181
            }
341
181
    return 1;
342
181
}
343
#endif
344
/* End of machine generated */
345
346
/* Machine generated */
347
#ifndef drbg_hash_set_ctx_params_list
348
static ossl_unused const OSSL_PARAM drbg_hash_set_ctx_params_list[] = {
349
    OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_PROPERTIES, NULL, 0),
350
    OSSL_PARAM_utf8_string(OSSL_DRBG_PARAM_DIGEST, NULL, 0),
351
    OSSL_PARAM_utf8_string(OSSL_PROV_PARAM_CORE_PROV_NAME, NULL, 0),
352
    OSSL_PARAM_uint(OSSL_DRBG_PARAM_RESEED_REQUESTS, NULL),
353
    OSSL_PARAM_uint64(OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL, NULL),
354
# if defined(FIPS_MODULE)
355
    OSSL_PARAM_int(OSSL_KDF_PARAM_FIPS_DIGEST_CHECK, NULL),
356
# endif
357
    OSSL_PARAM_END
358
};
359
#endif
360
361
#ifndef drbg_hash_set_ctx_params_st
362
struct drbg_hash_set_ctx_params_st {
363
    OSSL_PARAM *digest;
364
# if defined(FIPS_MODULE)
365
    OSSL_PARAM *ind_d;
366
# endif
367
    OSSL_PARAM *propq;
368
    OSSL_PARAM *prov;
369
    OSSL_PARAM *reseed_req;
370
    OSSL_PARAM *reseed_time;
371
};
372
#endif
373
374
#ifndef drbg_hash_set_ctx_params_decoder
375
static ossl_unused int drbg_hash_set_ctx_params_decoder
376
    (const OSSL_PARAM *p, struct drbg_hash_set_ctx_params_st *r)
377
187
{
378
187
    const char *s;
379
380
187
    memset(r, 0, sizeof(*r));
381
187
    if (p != NULL)
382
1.12k
        for (; (s = p->key) != NULL; p++)
383
935
            switch(s[0]) {
384
0
            default:
385
0
                break;
386
187
            case 'd':
387
187
                switch(s[1]) {
388
0
                default:
389
0
                    break;
390
187
                case 'i':
391
187
                    switch(s[2]) {
392
0
                    default:
393
0
                        break;
394
187
                    case 'g':
395
187
                        switch(s[3]) {
396
0
                        default:
397
0
                            break;
398
187
                        case 'e':
399
187
                            switch(s[4]) {
400
0
                            default:
401
0
                                break;
402
187
                            case 's':
403
187
                                switch(s[5]) {
404
0
                                default:
405
0
                                    break;
406
187
                                case 't':
407
187
                                    switch(s[6]) {
408
0
                                    default:
409
0
                                        break;
410
0
                                    case '-':
411
# if defined(FIPS_MODULE)
412
                                        if (ossl_likely(strcmp("check", s + 7) == 0)) {
413
                                            /* OSSL_KDF_PARAM_FIPS_DIGEST_CHECK */
414
                                            if (ossl_unlikely(r->ind_d != NULL)) {
415
                                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
416
                                                               "param %s is repeated", s);
417
                                                return 0;
418
                                            }
419
                                            r->ind_d = (OSSL_PARAM *)p;
420
                                        }
421
# endif
422
0
                                        break;
423
187
                                    case '\0':
424
187
                                        if (ossl_unlikely(r->digest != NULL)) {
425
0
                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
426
0
                                                           "param %s is repeated", s);
427
0
                                            return 0;
428
0
                                        }
429
187
                                        r->digest = (OSSL_PARAM *)p;
430
187
                                    }
431
187
                                }
432
187
                            }
433
187
                        }
434
187
                    }
435
187
                }
436
187
                break;
437
374
            case 'p':
438
374
                switch(s[1]) {
439
0
                default:
440
0
                    break;
441
374
                case 'r':
442
374
                    switch(s[2]) {
443
0
                    default:
444
0
                        break;
445
374
                    case 'o':
446
374
                        switch(s[3]) {
447
0
                        default:
448
0
                            break;
449
187
                        case 'p':
450
187
                            if (ossl_likely(strcmp("erties", s + 4) == 0)) {
451
                                /* OSSL_DRBG_PARAM_PROPERTIES */
452
187
                                if (ossl_unlikely(r->propq != NULL)) {
453
0
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
454
0
                                                   "param %s is repeated", s);
455
0
                                    return 0;
456
0
                                }
457
187
                                r->propq = (OSSL_PARAM *)p;
458
187
                            }
459
187
                            break;
460
187
                        case 'v':
461
187
                            if (ossl_likely(strcmp("ider-name", s + 4) == 0)) {
462
                                /* OSSL_PROV_PARAM_CORE_PROV_NAME */
463
187
                                if (ossl_unlikely(r->prov != NULL)) {
464
0
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
465
0
                                                   "param %s is repeated", s);
466
0
                                    return 0;
467
0
                                }
468
187
                                r->prov = (OSSL_PARAM *)p;
469
187
                            }
470
374
                        }
471
374
                    }
472
374
                }
473
374
                break;
474
374
            case 'r':
475
374
                switch(s[1]) {
476
0
                default:
477
0
                    break;
478
374
                case 'e':
479
374
                    switch(s[2]) {
480
0
                    default:
481
0
                        break;
482
374
                    case 's':
483
374
                        switch(s[3]) {
484
0
                        default:
485
0
                            break;
486
374
                        case 'e':
487
374
                            switch(s[4]) {
488
0
                            default:
489
0
                                break;
490
374
                            case 'e':
491
374
                                switch(s[5]) {
492
0
                                default:
493
0
                                    break;
494
374
                                case 'd':
495
374
                                    switch(s[6]) {
496
0
                                    default:
497
0
                                        break;
498
374
                                    case '_':
499
374
                                        switch(s[7]) {
500
0
                                        default:
501
0
                                            break;
502
187
                                        case 'r':
503
187
                                            if (ossl_likely(strcmp("equests", s + 8) == 0)) {
504
                                                /* OSSL_DRBG_PARAM_RESEED_REQUESTS */
505
187
                                                if (ossl_unlikely(r->reseed_req != NULL)) {
506
0
                                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
507
0
                                                                   "param %s is repeated", s);
508
0
                                                    return 0;
509
0
                                                }
510
187
                                                r->reseed_req = (OSSL_PARAM *)p;
511
187
                                            }
512
187
                                            break;
513
187
                                        case 't':
514
187
                                            if (ossl_likely(strcmp("ime_interval", s + 8) == 0)) {
515
                                                /* OSSL_DRBG_PARAM_RESEED_TIME_INTERVAL */
516
187
                                                if (ossl_unlikely(r->reseed_time != NULL)) {
517
0
                                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
518
0
                                                                   "param %s is repeated", s);
519
0
                                                    return 0;
520
0
                                                }
521
187
                                                r->reseed_time = (OSSL_PARAM *)p;
522
187
                                            }
523
374
                                        }
524
374
                                    }
525
374
                                }
526
374
                            }
527
374
                        }
528
374
                    }
529
374
                }
530
935
            }
531
187
    return 1;
532
187
}
533
#endif
534
/* End of machine generated */