Coverage Report

Created: 2025-10-28 06:56

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/openssl/providers/implementations/keymgmt/ecx_kmgmt.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 ecx_imexport_types_list
14
static const OSSL_PARAM ecx_imexport_types_list[] = {
15
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
16
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
17
    OSSL_PARAM_END
18
};
19
#endif
20
21
#ifndef ecx_imexport_types_st
22
struct ecx_imexport_types_st {
23
    OSSL_PARAM *priv;
24
    OSSL_PARAM *pub;
25
};
26
#endif
27
28
#ifndef ecx_imexport_types_decoder
29
static int ecx_imexport_types_decoder
30
    (const OSSL_PARAM *p, struct ecx_imexport_types_st *r)
31
0
{
32
0
    const char *s;
33
34
0
    memset(r, 0, sizeof(*r));
35
0
    if (p != NULL)
36
0
        for (; (s = p->key) != NULL; p++)
37
0
            switch(s[0]) {
38
0
            default:
39
0
                break;
40
0
            case 'p':
41
0
                switch(s[1]) {
42
0
                default:
43
0
                    break;
44
0
                case 'r':
45
0
                    if (ossl_likely(strcmp("iv", s + 2) == 0)) {
46
                        /* OSSL_PKEY_PARAM_PRIV_KEY */
47
0
                        if (ossl_unlikely(r->priv != NULL)) {
48
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
49
0
                                           "param %s is repeated", s);
50
0
                            return 0;
51
0
                        }
52
0
                        r->priv = (OSSL_PARAM *)p;
53
0
                    }
54
0
                    break;
55
0
                case 'u':
56
0
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
57
                        /* OSSL_PKEY_PARAM_PUB_KEY */
58
0
                        if (ossl_unlikely(r->pub != NULL)) {
59
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
60
0
                                           "param %s is repeated", s);
61
0
                            return 0;
62
0
                        }
63
0
                        r->pub = (OSSL_PARAM *)p;
64
0
                    }
65
0
                }
66
0
            }
67
0
    return 1;
68
0
}
69
#endif
70
/* End of machine generated */
71
72
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
73
#ifndef ecx_get_params_list
74
static const OSSL_PARAM ecx_get_params_list[] = {
75
    OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
76
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
77
    OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
78
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
79
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
80
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
81
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
82
# if defined(FIPS_MODULE)
83
    OSSL_PARAM_int(OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR, NULL),
84
# endif
85
    OSSL_PARAM_END
86
};
87
#endif
88
89
#ifndef ecx_get_params_st
90
struct ecx_get_params_st {
91
    OSSL_PARAM *bits;
92
    OSSL_PARAM *encpub;
93
# if defined(FIPS_MODULE)
94
    OSSL_PARAM *ind;
95
# endif
96
    OSSL_PARAM *priv;
97
    OSSL_PARAM *pub;
98
    OSSL_PARAM *secbits;
99
    OSSL_PARAM *seccat;
100
    OSSL_PARAM *size;
101
};
102
#endif
103
104
#ifndef ecx_get_params_decoder
105
static int ecx_get_params_decoder
106
    (const OSSL_PARAM *p, struct ecx_get_params_st *r)
107
0
{
108
0
    const char *s;
109
110
0
    memset(r, 0, sizeof(*r));
111
0
    if (p != NULL)
112
0
        for (; (s = p->key) != NULL; p++)
113
0
            switch(s[0]) {
114
0
            default:
115
0
                break;
116
0
            case 'b':
117
0
                if (ossl_likely(strcmp("its", s + 1) == 0)) {
118
                    /* OSSL_PKEY_PARAM_BITS */
119
0
                    if (ossl_unlikely(r->bits != NULL)) {
120
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
121
0
                                       "param %s is repeated", s);
122
0
                        return 0;
123
0
                    }
124
0
                    r->bits = (OSSL_PARAM *)p;
125
0
                }
126
0
                break;
127
0
            case 'e':
128
0
                if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
129
                    /* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
130
0
                    if (ossl_unlikely(r->encpub != NULL)) {
131
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
132
0
                                       "param %s is repeated", s);
133
0
                        return 0;
134
0
                    }
135
0
                    r->encpub = (OSSL_PARAM *)p;
136
0
                }
137
0
                break;
138
0
            case 'f':
139
# if defined(FIPS_MODULE)
140
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
141
                    /* OSSL_PKEY_PARAM_FIPS_APPROVED_INDICATOR */
142
                    if (ossl_unlikely(r->ind != NULL)) {
143
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
144
                                       "param %s is repeated", s);
145
                        return 0;
146
                    }
147
                    r->ind = (OSSL_PARAM *)p;
148
                }
149
# endif
150
0
                break;
151
0
            case 'm':
152
0
                if (ossl_likely(strcmp("ax-size", s + 1) == 0)) {
153
                    /* OSSL_PKEY_PARAM_MAX_SIZE */
154
0
                    if (ossl_unlikely(r->size != NULL)) {
155
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
156
0
                                       "param %s is repeated", s);
157
0
                        return 0;
158
0
                    }
159
0
                    r->size = (OSSL_PARAM *)p;
160
0
                }
161
0
                break;
162
0
            case 'p':
163
0
                switch(s[1]) {
164
0
                default:
165
0
                    break;
166
0
                case 'r':
167
0
                    if (ossl_likely(strcmp("iv", s + 2) == 0)) {
168
                        /* OSSL_PKEY_PARAM_PRIV_KEY */
169
0
                        if (ossl_unlikely(r->priv != NULL)) {
170
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
171
0
                                           "param %s is repeated", s);
172
0
                            return 0;
173
0
                        }
174
0
                        r->priv = (OSSL_PARAM *)p;
175
0
                    }
176
0
                    break;
177
0
                case 'u':
178
0
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
179
                        /* OSSL_PKEY_PARAM_PUB_KEY */
180
0
                        if (ossl_unlikely(r->pub != NULL)) {
181
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
182
0
                                           "param %s is repeated", s);
183
0
                            return 0;
184
0
                        }
185
0
                        r->pub = (OSSL_PARAM *)p;
186
0
                    }
187
0
                }
188
0
                break;
189
0
            case 's':
190
0
                switch(s[1]) {
191
0
                default:
192
0
                    break;
193
0
                case 'e':
194
0
                    switch(s[2]) {
195
0
                    default:
196
0
                        break;
197
0
                    case 'c':
198
0
                        switch(s[3]) {
199
0
                        default:
200
0
                            break;
201
0
                        case 'u':
202
0
                            switch(s[4]) {
203
0
                            default:
204
0
                                break;
205
0
                            case 'r':
206
0
                                switch(s[5]) {
207
0
                                default:
208
0
                                    break;
209
0
                                case 'i':
210
0
                                    switch(s[6]) {
211
0
                                    default:
212
0
                                        break;
213
0
                                    case 't':
214
0
                                        switch(s[7]) {
215
0
                                        default:
216
0
                                            break;
217
0
                                        case 'y':
218
0
                                            switch(s[8]) {
219
0
                                            default:
220
0
                                                break;
221
0
                                            case '-':
222
0
                                                switch(s[9]) {
223
0
                                                default:
224
0
                                                    break;
225
0
                                                case 'b':
226
0
                                                    if (ossl_likely(strcmp("its", s + 10) == 0)) {
227
                                                        /* OSSL_PKEY_PARAM_SECURITY_BITS */
228
0
                                                        if (ossl_unlikely(r->secbits != NULL)) {
229
0
                                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
230
0
                                                                           "param %s is repeated", s);
231
0
                                                            return 0;
232
0
                                                        }
233
0
                                                        r->secbits = (OSSL_PARAM *)p;
234
0
                                                    }
235
0
                                                    break;
236
0
                                                case 'c':
237
0
                                                    if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
238
                                                        /* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
239
0
                                                        if (ossl_unlikely(r->seccat != 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
0
                                                        r->seccat = (OSSL_PARAM *)p;
245
0
                                                    }
246
0
                                                }
247
0
                                            }
248
0
                                        }
249
0
                                    }
250
0
                                }
251
0
                            }
252
0
                        }
253
0
                    }
254
0
                }
255
0
            }
256
0
    return 1;
257
0
}
258
#endif
259
/* End of machine generated */
260
261
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
262
#ifndef ed_get_params_list
263
static const OSSL_PARAM ed_get_params_list[] = {
264
    OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
265
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
266
    OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
267
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
268
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
269
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
270
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
271
    OSSL_PARAM_END
272
};
273
#endif
274
275
#ifndef ed_get_params_st
276
struct ed_get_params_st {
277
    OSSL_PARAM *bits;
278
    OSSL_PARAM *digest;
279
    OSSL_PARAM *priv;
280
    OSSL_PARAM *pub;
281
    OSSL_PARAM *secbits;
282
    OSSL_PARAM *seccat;
283
    OSSL_PARAM *size;
284
};
285
#endif
286
287
#ifndef ed_get_params_decoder
288
static int ed_get_params_decoder
289
    (const OSSL_PARAM *p, struct ed_get_params_st *r)
290
0
{
291
0
    const char *s;
292
293
0
    memset(r, 0, sizeof(*r));
294
0
    if (p != NULL)
295
0
        for (; (s = p->key) != NULL; p++)
296
0
            switch(s[0]) {
297
0
            default:
298
0
                break;
299
0
            case 'b':
300
0
                if (ossl_likely(strcmp("its", s + 1) == 0)) {
301
                    /* OSSL_PKEY_PARAM_BITS */
302
0
                    if (ossl_unlikely(r->bits != NULL)) {
303
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
304
0
                                       "param %s is repeated", s);
305
0
                        return 0;
306
0
                    }
307
0
                    r->bits = (OSSL_PARAM *)p;
308
0
                }
309
0
                break;
310
0
            case 'm':
311
0
                switch(s[1]) {
312
0
                default:
313
0
                    break;
314
0
                case 'a':
315
0
                    switch(s[2]) {
316
0
                    default:
317
0
                        break;
318
0
                    case 'n':
319
0
                        if (ossl_likely(strcmp("datory-digest", s + 3) == 0)) {
320
                            /* OSSL_PKEY_PARAM_MANDATORY_DIGEST */
321
0
                            if (ossl_unlikely(r->digest != 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->digest = (OSSL_PARAM *)p;
327
0
                        }
328
0
                        break;
329
0
                    case 'x':
330
0
                        if (ossl_likely(strcmp("-size", s + 3) == 0)) {
331
                            /* OSSL_PKEY_PARAM_MAX_SIZE */
332
0
                            if (ossl_unlikely(r->size != NULL)) {
333
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
334
0
                                               "param %s is repeated", s);
335
0
                                return 0;
336
0
                            }
337
0
                            r->size = (OSSL_PARAM *)p;
338
0
                        }
339
0
                    }
340
0
                }
341
0
                break;
342
0
            case 'p':
343
0
                switch(s[1]) {
344
0
                default:
345
0
                    break;
346
0
                case 'r':
347
0
                    if (ossl_likely(strcmp("iv", s + 2) == 0)) {
348
                        /* OSSL_PKEY_PARAM_PRIV_KEY */
349
0
                        if (ossl_unlikely(r->priv != NULL)) {
350
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
351
0
                                           "param %s is repeated", s);
352
0
                            return 0;
353
0
                        }
354
0
                        r->priv = (OSSL_PARAM *)p;
355
0
                    }
356
0
                    break;
357
0
                case 'u':
358
0
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
359
                        /* OSSL_PKEY_PARAM_PUB_KEY */
360
0
                        if (ossl_unlikely(r->pub != NULL)) {
361
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
362
0
                                           "param %s is repeated", s);
363
0
                            return 0;
364
0
                        }
365
0
                        r->pub = (OSSL_PARAM *)p;
366
0
                    }
367
0
                }
368
0
                break;
369
0
            case 's':
370
0
                switch(s[1]) {
371
0
                default:
372
0
                    break;
373
0
                case 'e':
374
0
                    switch(s[2]) {
375
0
                    default:
376
0
                        break;
377
0
                    case 'c':
378
0
                        switch(s[3]) {
379
0
                        default:
380
0
                            break;
381
0
                        case 'u':
382
0
                            switch(s[4]) {
383
0
                            default:
384
0
                                break;
385
0
                            case 'r':
386
0
                                switch(s[5]) {
387
0
                                default:
388
0
                                    break;
389
0
                                case 'i':
390
0
                                    switch(s[6]) {
391
0
                                    default:
392
0
                                        break;
393
0
                                    case 't':
394
0
                                        switch(s[7]) {
395
0
                                        default:
396
0
                                            break;
397
0
                                        case 'y':
398
0
                                            switch(s[8]) {
399
0
                                            default:
400
0
                                                break;
401
0
                                            case '-':
402
0
                                                switch(s[9]) {
403
0
                                                default:
404
0
                                                    break;
405
0
                                                case 'b':
406
0
                                                    if (ossl_likely(strcmp("its", s + 10) == 0)) {
407
                                                        /* OSSL_PKEY_PARAM_SECURITY_BITS */
408
0
                                                        if (ossl_unlikely(r->secbits != NULL)) {
409
0
                                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
410
0
                                                                           "param %s is repeated", s);
411
0
                                                            return 0;
412
0
                                                        }
413
0
                                                        r->secbits = (OSSL_PARAM *)p;
414
0
                                                    }
415
0
                                                    break;
416
0
                                                case 'c':
417
0
                                                    if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
418
                                                        /* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
419
0
                                                        if (ossl_unlikely(r->seccat != NULL)) {
420
0
                                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
421
0
                                                                           "param %s is repeated", s);
422
0
                                                            return 0;
423
0
                                                        }
424
0
                                                        r->seccat = (OSSL_PARAM *)p;
425
0
                                                    }
426
0
                                                }
427
0
                                            }
428
0
                                        }
429
0
                                    }
430
0
                                }
431
0
                            }
432
0
                        }
433
0
                    }
434
0
                }
435
0
            }
436
0
    return 1;
437
0
}
438
#endif
439
/* End of machine generated */
440
441
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
442
#ifndef ecx_set_params_list
443
static const OSSL_PARAM ecx_set_params_list[] = {
444
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
445
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
446
    OSSL_PARAM_END
447
};
448
#endif
449
450
#ifndef ecx_set_params_st
451
struct ecx_set_params_st {
452
    OSSL_PARAM *propq;
453
    OSSL_PARAM *pub;
454
};
455
#endif
456
457
#ifndef ecx_set_params_decoder
458
static int ecx_set_params_decoder
459
    (const OSSL_PARAM *p, struct ecx_set_params_st *r)
460
0
{
461
0
    const char *s;
462
463
0
    memset(r, 0, sizeof(*r));
464
0
    if (p != NULL)
465
0
        for (; (s = p->key) != NULL; p++)
466
0
            switch(s[0]) {
467
0
            default:
468
0
                break;
469
0
            case 'e':
470
0
                if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
471
                    /* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
472
0
                    if (ossl_unlikely(r->pub != NULL)) {
473
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
474
0
                                       "param %s is repeated", s);
475
0
                        return 0;
476
0
                    }
477
0
                    r->pub = (OSSL_PARAM *)p;
478
0
                }
479
0
                break;
480
0
            case 'p':
481
0
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
482
                    /* OSSL_PKEY_PARAM_PROPERTIES */
483
0
                    if (ossl_unlikely(r->propq != NULL)) {
484
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
485
0
                                       "param %s is repeated", s);
486
0
                        return 0;
487
0
                    }
488
0
                    r->propq = (OSSL_PARAM *)p;
489
0
                }
490
0
            }
491
0
    return 1;
492
0
}
493
#endif
494
/* End of machine generated */
495
496
/* Machine generated by util/perl/OpenSSL/paramnames.pm */
497
#ifndef ecx_gen_set_params_list
498
static const OSSL_PARAM ecx_gen_set_params_list[] = {
499
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0),
500
    OSSL_PARAM_utf8_string(OSSL_KDF_PARAM_PROPERTIES, NULL, 0),
501
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_DHKEM_IKM, NULL, 0),
502
    OSSL_PARAM_END
503
};
504
#endif
505
506
#ifndef ecx_gen_set_params_st
507
struct ecx_gen_set_params_st {
508
    OSSL_PARAM *group;
509
    OSSL_PARAM *ikm;
510
    OSSL_PARAM *kdfpropq;
511
};
512
#endif
513
514
#ifndef ecx_gen_set_params_decoder
515
static int ecx_gen_set_params_decoder
516
    (const OSSL_PARAM *p, struct ecx_gen_set_params_st *r)
517
0
{
518
0
    const char *s;
519
520
0
    memset(r, 0, sizeof(*r));
521
0
    if (p != NULL)
522
0
        for (; (s = p->key) != NULL; p++)
523
0
            switch(s[0]) {
524
0
            default:
525
0
                break;
526
0
            case 'd':
527
0
                if (ossl_likely(strcmp("hkem-ikm", s + 1) == 0)) {
528
                    /* OSSL_PKEY_PARAM_DHKEM_IKM */
529
0
                    if (ossl_unlikely(r->ikm != NULL)) {
530
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
531
0
                                       "param %s is repeated", s);
532
0
                        return 0;
533
0
                    }
534
0
                    r->ikm = (OSSL_PARAM *)p;
535
0
                }
536
0
                break;
537
0
            case 'g':
538
0
                if (ossl_likely(strcmp("roup", s + 1) == 0)) {
539
                    /* OSSL_PKEY_PARAM_GROUP_NAME */
540
0
                    if (ossl_unlikely(r->group != NULL)) {
541
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
542
0
                                       "param %s is repeated", s);
543
0
                        return 0;
544
0
                    }
545
0
                    r->group = (OSSL_PARAM *)p;
546
0
                }
547
0
                break;
548
0
            case 'p':
549
0
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
550
                    /* OSSL_KDF_PARAM_PROPERTIES */
551
0
                    if (ossl_unlikely(r->kdfpropq != NULL)) {
552
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
553
0
                                       "param %s is repeated", s);
554
0
                        return 0;
555
0
                    }
556
0
                    r->kdfpropq = (OSSL_PARAM *)p;
557
0
                }
558
0
            }
559
0
    return 1;
560
0
}
561
#endif
562
/* End of machine generated */