Coverage Report

Created: 2025-10-28 06:56

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