Coverage Report

Created: 2026-09-12 06:55

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/openssl41/providers/implementations/keymgmt/dh_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
#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 dh_get_params_list
21
static ossl_unused const OSSL_PARAM dh_get_params_list[] = {
22
    OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
23
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
24
    OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
25
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
26
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
27
    OSSL_PARAM_BN(OSSL_PKEY_PARAM_FFC_P, NULL, 0),
28
    OSSL_PARAM_BN(OSSL_PKEY_PARAM_FFC_Q, NULL, 0),
29
    OSSL_PARAM_BN(OSSL_PKEY_PARAM_FFC_G, NULL, 0),
30
    OSSL_PARAM_BN(OSSL_PKEY_PARAM_FFC_COFACTOR, NULL, 0),
31
    OSSL_PARAM_int(OSSL_PKEY_PARAM_FFC_GINDEX, NULL),
32
    OSSL_PARAM_int(OSSL_PKEY_PARAM_FFC_PCOUNTER, NULL),
33
    OSSL_PARAM_int(OSSL_PKEY_PARAM_FFC_H, NULL),
34
    OSSL_PARAM_int(OSSL_PKEY_PARAM_DH_PRIV_LEN, NULL),
35
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_FFC_SEED, NULL, 0),
36
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0),
37
    OSSL_PARAM_BN(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
38
    OSSL_PARAM_BN(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
39
    OSSL_PARAM_END
40
};
41
#endif
42
43
#ifndef dh_get_params_st
44
struct dh_get_params_st {
45
    OSSL_PARAM *bits;
46
    OSSL_PARAM *encpubkey;
47
    OSSL_PARAM *ffp.cofactor;
48
    OSSL_PARAM *ffp.g;
49
    OSSL_PARAM *ffp.g_index;
50
    OSSL_PARAM *ffp.group_name;
51
    OSSL_PARAM *ffp.h;
52
    OSSL_PARAM *ffp.p;
53
    OSSL_PARAM *ffp.p_counter;
54
    OSSL_PARAM *ffp.q;
55
    OSSL_PARAM *ffp.seed;
56
    OSSL_PARAM *maxsize;
57
    OSSL_PARAM *privkey;
58
    OSSL_PARAM *privlen;
59
    OSSL_PARAM *pubkey;
60
    OSSL_PARAM *secbits;
61
    OSSL_PARAM *seccat;
62
};
63
#endif
64
65
#ifndef dh_get_params_decoder
66
static ossl_unused int dh_get_params_decoder
67
    (const OSSL_PARAM *p, struct dh_get_params_st *r)
68
15.6k
{
69
15.6k
    const char *s;
70
71
15.6k
    memset(r, 0, sizeof(*r));
72
15.6k
    if (p != NULL)
73
65.0k
        for (; (s = p->key) != NULL; p++)
74
49.3k
            switch(s[0]) {
75
0
            default:
76
0
                break;
77
11.2k
            case 'b':
78
11.2k
                if (ossl_likely(strcmp("its", s + 1) == 0)) {
79
                    /* OSSL_PKEY_PARAM_BITS */
80
11.2k
                    if (ossl_unlikely(r->bits != 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
11.2k
                    r->bits = (OSSL_PARAM *)p;
86
11.2k
                }
87
11.2k
                break;
88
11.2k
            case 'e':
89
2.83k
                if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
90
                    /* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
91
2.83k
                    if (ossl_unlikely(r->encpubkey != NULL)) {
92
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
93
0
                                       "param %s is repeated", s);
94
0
                        return 0;
95
0
                    }
96
2.83k
                    r->encpubkey = (OSSL_PARAM *)p;
97
2.83k
                }
98
2.83k
                break;
99
2.83k
            case 'g':
100
507
                switch(s[1]) {
101
0
                default:
102
0
                    break;
103
0
                case 'i':
104
0
                    if (ossl_likely(strcmp("ndex", s + 2) == 0)) {
105
                        /* OSSL_PKEY_PARAM_FFC_GINDEX */
106
0
                        if (ossl_unlikely(r->ffp.g_index != NULL)) {
107
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
108
0
                                           "param %s is repeated", s);
109
0
                            return 0;
110
0
                        }
111
0
                        r->ffp.g_index = (OSSL_PARAM *)p;
112
0
                    }
113
0
                    break;
114
0
                case 'r':
115
0
                    if (ossl_likely(strcmp("oup", s + 2) == 0)) {
116
                        /* OSSL_PKEY_PARAM_GROUP_NAME */
117
0
                        if (ossl_unlikely(r->ffp.group_name != NULL)) {
118
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
119
0
                                           "param %s is repeated", s);
120
0
                            return 0;
121
0
                        }
122
0
                        r->ffp.group_name = (OSSL_PARAM *)p;
123
0
                    }
124
0
                    break;
125
507
                case '\0':
126
507
                    if (ossl_unlikely(r->ffp.g != 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
507
                    r->ffp.g = (OSSL_PARAM *)p;
132
507
                }
133
507
                break;
134
507
            case 'h':
135
0
                if (ossl_likely(strcmp("index", s + 1) == 0)) {
136
                    /* OSSL_PKEY_PARAM_FFC_H */
137
0
                    if (ossl_unlikely(r->ffp.h != 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->ffp.h = (OSSL_PARAM *)p;
143
0
                }
144
0
                break;
145
0
            case 'j':
146
0
                switch(s[1]) {
147
0
                default:
148
0
                    break;
149
0
                case '\0':
150
0
                    if (ossl_unlikely(r->ffp.cofactor != NULL)) {
151
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
152
0
                                       "param %s is repeated", s);
153
0
                        return 0;
154
0
                    }
155
0
                    r->ffp.cofactor = (OSSL_PARAM *)p;
156
0
                }
157
0
                break;
158
11.2k
            case 'm':
159
11.2k
                if (ossl_likely(strcmp("ax-size", s + 1) == 0)) {
160
                    /* OSSL_PKEY_PARAM_MAX_SIZE */
161
11.2k
                    if (ossl_unlikely(r->maxsize != NULL)) {
162
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
163
0
                                       "param %s is repeated", s);
164
0
                        return 0;
165
0
                    }
166
11.2k
                    r->maxsize = (OSSL_PARAM *)p;
167
11.2k
                }
168
11.2k
                break;
169
11.2k
            case 'p':
170
1.01k
                switch(s[1]) {
171
0
                default:
172
0
                    break;
173
0
                case 'c':
174
0
                    if (ossl_likely(strcmp("ounter", s + 2) == 0)) {
175
                        /* OSSL_PKEY_PARAM_FFC_PCOUNTER */
176
0
                        if (ossl_unlikely(r->ffp.p_counter != NULL)) {
177
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
178
0
                                           "param %s is repeated", s);
179
0
                            return 0;
180
0
                        }
181
0
                        r->ffp.p_counter = (OSSL_PARAM *)p;
182
0
                    }
183
0
                    break;
184
0
                case 'r':
185
0
                    switch(s[2]) {
186
0
                    default:
187
0
                        break;
188
0
                    case 'i':
189
0
                        switch(s[3]) {
190
0
                        default:
191
0
                            break;
192
0
                        case 'v':
193
0
                            switch(s[4]) {
194
0
                            default:
195
0
                                break;
196
0
                            case '_':
197
0
                                if (ossl_likely(strcmp("len", s + 5) == 0)) {
198
                                    /* OSSL_PKEY_PARAM_DH_PRIV_LEN */
199
0
                                    if (ossl_unlikely(r->privlen != NULL)) {
200
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
201
0
                                                       "param %s is repeated", s);
202
0
                                        return 0;
203
0
                                    }
204
0
                                    r->privlen = (OSSL_PARAM *)p;
205
0
                                }
206
0
                                break;
207
0
                            case '\0':
208
0
                                if (ossl_unlikely(r->privkey != 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->privkey = (OSSL_PARAM *)p;
214
0
                            }
215
0
                        }
216
0
                    }
217
0
                    break;
218
507
                case 'u':
219
507
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
220
                        /* OSSL_PKEY_PARAM_PUB_KEY */
221
507
                        if (ossl_unlikely(r->pubkey != NULL)) {
222
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
223
0
                                           "param %s is repeated", s);
224
0
                            return 0;
225
0
                        }
226
507
                        r->pubkey = (OSSL_PARAM *)p;
227
507
                    }
228
507
                    break;
229
507
                case '\0':
230
507
                    if (ossl_unlikely(r->ffp.p != NULL)) {
231
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
232
0
                                       "param %s is repeated", s);
233
0
                        return 0;
234
0
                    }
235
507
                    r->ffp.p = (OSSL_PARAM *)p;
236
1.01k
                }
237
1.01k
                break;
238
1.01k
            case 'q':
239
0
                switch(s[1]) {
240
0
                default:
241
0
                    break;
242
0
                case '\0':
243
0
                    if (ossl_unlikely(r->ffp.q != 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->ffp.q = (OSSL_PARAM *)p;
249
0
                }
250
0
                break;
251
22.5k
            case 's':
252
22.5k
                switch(s[1]) {
253
0
                default:
254
0
                    break;
255
22.5k
                case 'e':
256
22.5k
                    switch(s[2]) {
257
0
                    default:
258
0
                        break;
259
22.5k
                    case 'c':
260
22.5k
                        switch(s[3]) {
261
0
                        default:
262
0
                            break;
263
22.5k
                        case 'u':
264
22.5k
                            switch(s[4]) {
265
0
                            default:
266
0
                                break;
267
22.5k
                            case 'r':
268
22.5k
                                switch(s[5]) {
269
0
                                default:
270
0
                                    break;
271
22.5k
                                case 'i':
272
22.5k
                                    switch(s[6]) {
273
0
                                    default:
274
0
                                        break;
275
22.5k
                                    case 't':
276
22.5k
                                        switch(s[7]) {
277
0
                                        default:
278
0
                                            break;
279
22.5k
                                        case 'y':
280
22.5k
                                            switch(s[8]) {
281
0
                                            default:
282
0
                                                break;
283
22.5k
                                            case '-':
284
22.5k
                                                switch(s[9]) {
285
0
                                                default:
286
0
                                                    break;
287
11.2k
                                                case 'b':
288
11.2k
                                                    if (ossl_likely(strcmp("its", s + 10) == 0)) {
289
                                                        /* OSSL_PKEY_PARAM_SECURITY_BITS */
290
11.2k
                                                        if (ossl_unlikely(r->secbits != NULL)) {
291
0
                                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
292
0
                                                                           "param %s is repeated", s);
293
0
                                                            return 0;
294
0
                                                        }
295
11.2k
                                                        r->secbits = (OSSL_PARAM *)p;
296
11.2k
                                                    }
297
11.2k
                                                    break;
298
11.2k
                                                case 'c':
299
11.2k
                                                    if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
300
                                                        /* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
301
11.2k
                                                        if (ossl_unlikely(r->seccat != NULL)) {
302
0
                                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
303
0
                                                                           "param %s is repeated", s);
304
0
                                                            return 0;
305
0
                                                        }
306
11.2k
                                                        r->seccat = (OSSL_PARAM *)p;
307
11.2k
                                                    }
308
22.5k
                                                }
309
22.5k
                                            }
310
22.5k
                                        }
311
22.5k
                                    }
312
22.5k
                                }
313
22.5k
                            }
314
22.5k
                        }
315
22.5k
                        break;
316
22.5k
                    case 'e':
317
0
                        if (ossl_likely(strcmp("d", s + 3) == 0)) {
318
                            /* OSSL_PKEY_PARAM_FFC_SEED */
319
0
                            if (ossl_unlikely(r->ffp.seed != NULL)) {
320
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
321
0
                                               "param %s is repeated", s);
322
0
                                return 0;
323
0
                            }
324
0
                            r->ffp.seed = (OSSL_PARAM *)p;
325
0
                        }
326
22.5k
                    }
327
22.5k
                }
328
49.3k
            }
329
15.6k
    return 1;
330
15.6k
}
331
#endif
332
/* End of machine generated */
333
334
/* Machine generated */
335
#ifndef dh_set_params_list
336
static ossl_unused const OSSL_PARAM dh_set_params_list[] = {
337
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
338
    OSSL_PARAM_END
339
};
340
#endif
341
342
#ifndef dh_set_params_st
343
struct dh_set_params_st {
344
    OSSL_PARAM *encpubkey;
345
};
346
#endif
347
348
#ifndef dh_set_params_decoder
349
static ossl_unused int dh_set_params_decoder
350
    (const OSSL_PARAM *p, struct dh_set_params_st *r)
351
401
{
352
401
    const char *s;
353
354
401
    memset(r, 0, sizeof(*r));
355
401
    if (p != NULL)
356
802
        for (; (s = p->key) != NULL; p++)
357
401
            if (ossl_likely(strcmp("encoded-pub-key", s + 0) == 0)) {
358
                /* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
359
401
                if (ossl_unlikely(r->encpubkey != NULL)) {
360
0
                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
361
0
                                   "param %s is repeated", s);
362
0
                    return 0;
363
0
                }
364
401
                r->encpubkey = (OSSL_PARAM *)p;
365
401
            }
366
401
    return 1;
367
401
}
368
#endif
369
/* End of machine generated */
370
371
/* Machine generated */
372
#ifndef dhx_gen_set_params_list
373
static ossl_unused const OSSL_PARAM dhx_gen_set_params_list[] = {
374
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_FFC_TYPE, NULL, 0),
375
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0),
376
    OSSL_PARAM_int(OSSL_PKEY_PARAM_DH_PRIV_LEN, NULL),
377
    OSSL_PARAM_size_t(OSSL_PKEY_PARAM_FFC_PBITS, NULL),
378
    OSSL_PARAM_size_t(OSSL_PKEY_PARAM_FFC_QBITS, NULL),
379
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST, NULL, 0),
380
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_FFC_DIGEST_PROPS, NULL, 0),
381
    OSSL_PARAM_int(OSSL_PKEY_PARAM_FFC_GINDEX, NULL),
382
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_FFC_SEED, NULL, 0),
383
    OSSL_PARAM_int(OSSL_PKEY_PARAM_FFC_PCOUNTER, NULL),
384
    OSSL_PARAM_int(OSSL_PKEY_PARAM_FFC_H, NULL),
385
    OSSL_PARAM_END
386
};
387
#endif
388
389
#ifndef dhx_gen_set_params_st
390
struct dhx_gen_set_params_st {
391
    OSSL_PARAM *digest;
392
    OSSL_PARAM *g_index;
393
    OSSL_PARAM *group_name;
394
    OSSL_PARAM *h;
395
    OSSL_PARAM *p_counter;
396
    OSSL_PARAM *pbits;
397
    OSSL_PARAM *privlen;
398
    OSSL_PARAM *propq;
399
    OSSL_PARAM *qbits;
400
    OSSL_PARAM *seed;
401
    OSSL_PARAM *type;
402
};
403
#endif
404
405
#ifndef dhx_gen_set_params_decoder
406
static ossl_unused int dhx_gen_set_params_decoder
407
    (const OSSL_PARAM *p, struct dhx_gen_set_params_st *r)
408
0
{
409
0
    const char *s;
410
411
0
    memset(r, 0, sizeof(*r));
412
0
    if (p != NULL)
413
0
        for (; (s = p->key) != NULL; p++)
414
0
            switch(s[0]) {
415
0
            default:
416
0
                break;
417
0
            case 'd':
418
0
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
419
                    /* OSSL_PKEY_PARAM_FFC_DIGEST */
420
0
                    if (ossl_unlikely(r->digest != NULL)) {
421
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
422
0
                                       "param %s is repeated", s);
423
0
                        return 0;
424
0
                    }
425
0
                    r->digest = (OSSL_PARAM *)p;
426
0
                }
427
0
                break;
428
0
            case 'g':
429
0
                switch(s[1]) {
430
0
                default:
431
0
                    break;
432
0
                case 'i':
433
0
                    if (ossl_likely(strcmp("ndex", s + 2) == 0)) {
434
                        /* OSSL_PKEY_PARAM_FFC_GINDEX */
435
0
                        if (ossl_unlikely(r->g_index != NULL)) {
436
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
437
0
                                           "param %s is repeated", s);
438
0
                            return 0;
439
0
                        }
440
0
                        r->g_index = (OSSL_PARAM *)p;
441
0
                    }
442
0
                    break;
443
0
                case 'r':
444
0
                    if (ossl_likely(strcmp("oup", s + 2) == 0)) {
445
                        /* OSSL_PKEY_PARAM_GROUP_NAME */
446
0
                        if (ossl_unlikely(r->group_name != NULL)) {
447
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
448
0
                                           "param %s is repeated", s);
449
0
                            return 0;
450
0
                        }
451
0
                        r->group_name = (OSSL_PARAM *)p;
452
0
                    }
453
0
                }
454
0
                break;
455
0
            case 'h':
456
0
                if (ossl_likely(strcmp("index", s + 1) == 0)) {
457
                    /* OSSL_PKEY_PARAM_FFC_H */
458
0
                    if (ossl_unlikely(r->h != NULL)) {
459
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
460
0
                                       "param %s is repeated", s);
461
0
                        return 0;
462
0
                    }
463
0
                    r->h = (OSSL_PARAM *)p;
464
0
                }
465
0
                break;
466
0
            case 'p':
467
0
                switch(s[1]) {
468
0
                default:
469
0
                    break;
470
0
                case 'b':
471
0
                    if (ossl_likely(strcmp("its", s + 2) == 0)) {
472
                        /* OSSL_PKEY_PARAM_FFC_PBITS */
473
0
                        if (ossl_unlikely(r->pbits != NULL)) {
474
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
475
0
                                           "param %s is repeated", s);
476
0
                            return 0;
477
0
                        }
478
0
                        r->pbits = (OSSL_PARAM *)p;
479
0
                    }
480
0
                    break;
481
0
                case 'c':
482
0
                    if (ossl_likely(strcmp("ounter", s + 2) == 0)) {
483
                        /* OSSL_PKEY_PARAM_FFC_PCOUNTER */
484
0
                        if (ossl_unlikely(r->p_counter != NULL)) {
485
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
486
0
                                           "param %s is repeated", s);
487
0
                            return 0;
488
0
                        }
489
0
                        r->p_counter = (OSSL_PARAM *)p;
490
0
                    }
491
0
                    break;
492
0
                case 'r':
493
0
                    switch(s[2]) {
494
0
                    default:
495
0
                        break;
496
0
                    case 'i':
497
0
                        if (ossl_likely(strcmp("v_len", s + 3) == 0)) {
498
                            /* OSSL_PKEY_PARAM_DH_PRIV_LEN */
499
0
                            if (ossl_unlikely(r->privlen != NULL)) {
500
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
501
0
                                               "param %s is repeated", s);
502
0
                                return 0;
503
0
                            }
504
0
                            r->privlen = (OSSL_PARAM *)p;
505
0
                        }
506
0
                        break;
507
0
                    case 'o':
508
0
                        if (ossl_likely(strcmp("perties", s + 3) == 0)) {
509
                            /* OSSL_PKEY_PARAM_FFC_DIGEST_PROPS */
510
0
                            if (ossl_unlikely(r->propq != NULL)) {
511
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
512
0
                                               "param %s is repeated", s);
513
0
                                return 0;
514
0
                            }
515
0
                            r->propq = (OSSL_PARAM *)p;
516
0
                        }
517
0
                    }
518
0
                }
519
0
                break;
520
0
            case 'q':
521
0
                if (ossl_likely(strcmp("bits", s + 1) == 0)) {
522
                    /* OSSL_PKEY_PARAM_FFC_QBITS */
523
0
                    if (ossl_unlikely(r->qbits != NULL)) {
524
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
525
0
                                       "param %s is repeated", s);
526
0
                        return 0;
527
0
                    }
528
0
                    r->qbits = (OSSL_PARAM *)p;
529
0
                }
530
0
                break;
531
0
            case 's':
532
0
                switch(s[1]) {
533
0
                default:
534
0
                    break;
535
0
                case 'a':
536
0
                    if (ossl_likely(strcmp("feprime-generator", s + 2) == 0)) {
537
                        /* OSSL_PKEY_PARAM_DH_GENERATOR */
538
0
                        ERR_raise_data(ERR_LIB_PROV, ERR_R_UNSUPPORTED,
539
0
                                       "param %s is unsupported", s);
540
0
                        return 0;
541
0
                    }
542
0
                    break;
543
0
                case 'e':
544
0
                    if (ossl_likely(strcmp("ed", s + 2) == 0)) {
545
                        /* OSSL_PKEY_PARAM_FFC_SEED */
546
0
                        if (ossl_unlikely(r->seed != NULL)) {
547
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
548
0
                                           "param %s is repeated", s);
549
0
                            return 0;
550
0
                        }
551
0
                        r->seed = (OSSL_PARAM *)p;
552
0
                    }
553
0
                }
554
0
                break;
555
0
            case 't':
556
0
                if (ossl_likely(strcmp("ype", s + 1) == 0)) {
557
                    /* OSSL_PKEY_PARAM_FFC_TYPE */
558
0
                    if (ossl_unlikely(r->type != NULL)) {
559
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
560
0
                                       "param %s is repeated", s);
561
0
                        return 0;
562
0
                    }
563
0
                    r->type = (OSSL_PARAM *)p;
564
0
                }
565
0
            }
566
0
    return 1;
567
0
}
568
#endif
569
/* End of machine generated */
570
571
/* Machine generated */
572
#ifndef dh_gen_set_params_list
573
static ossl_unused const OSSL_PARAM dh_gen_set_params_list[] = {
574
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_FFC_TYPE, NULL, 0),
575
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_GROUP_NAME, NULL, 0),
576
    OSSL_PARAM_int(OSSL_PKEY_PARAM_DH_PRIV_LEN, NULL),
577
    OSSL_PARAM_size_t(OSSL_PKEY_PARAM_FFC_PBITS, NULL),
578
    OSSL_PARAM_int(OSSL_PKEY_PARAM_DH_GENERATOR, NULL),
579
    OSSL_PARAM_END
580
};
581
#endif
582
583
#ifndef dh_gen_set_params_st
584
struct dh_gen_set_params_st {
585
    OSSL_PARAM *generator;
586
    OSSL_PARAM *group_name;
587
    OSSL_PARAM *pbits;
588
    OSSL_PARAM *privlen;
589
    OSSL_PARAM *type;
590
};
591
#endif
592
593
#ifndef dh_gen_set_params_decoder
594
static ossl_unused int dh_gen_set_params_decoder
595
    (const OSSL_PARAM *p, struct dh_gen_set_params_st *r)
596
2.97k
{
597
2.97k
    const char *s;
598
599
2.97k
    memset(r, 0, sizeof(*r));
600
2.97k
    if (p != NULL)
601
1.56k
        for (; (s = p->key) != NULL; p++)
602
780
            switch(s[0]) {
603
0
            default:
604
0
                break;
605
0
            case 'd':
606
0
                if (ossl_likely(strcmp("igest", s + 1) == 0)) {
607
                    /* OSSL_PKEY_PARAM_FFC_DIGEST */
608
0
                    ERR_raise_data(ERR_LIB_PROV, ERR_R_UNSUPPORTED,
609
0
                                   "param %s is unsupported", s);
610
0
                    return 0;
611
0
                }
612
0
                break;
613
780
            case 'g':
614
780
                switch(s[1]) {
615
0
                default:
616
0
                    break;
617
0
                case 'i':
618
0
                    if (ossl_likely(strcmp("ndex", s + 2) == 0)) {
619
                        /* OSSL_PKEY_PARAM_FFC_GINDEX */
620
0
                        ERR_raise_data(ERR_LIB_PROV, ERR_R_UNSUPPORTED,
621
0
                                       "param %s is unsupported", s);
622
0
                        return 0;
623
0
                    }
624
0
                    break;
625
780
                case 'r':
626
780
                    if (ossl_likely(strcmp("oup", s + 2) == 0)) {
627
                        /* OSSL_PKEY_PARAM_GROUP_NAME */
628
780
                        if (ossl_unlikely(r->group_name != NULL)) {
629
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
630
0
                                           "param %s is repeated", s);
631
0
                            return 0;
632
0
                        }
633
780
                        r->group_name = (OSSL_PARAM *)p;
634
780
                    }
635
780
                }
636
780
                break;
637
780
            case 'h':
638
0
                if (ossl_likely(strcmp("index", s + 1) == 0)) {
639
                    /* OSSL_PKEY_PARAM_FFC_H */
640
0
                    ERR_raise_data(ERR_LIB_PROV, ERR_R_UNSUPPORTED,
641
0
                                   "param %s is unsupported", s);
642
0
                    return 0;
643
0
                }
644
0
                break;
645
0
            case 'p':
646
0
                switch(s[1]) {
647
0
                default:
648
0
                    break;
649
0
                case 'b':
650
0
                    if (ossl_likely(strcmp("its", s + 2) == 0)) {
651
                        /* OSSL_PKEY_PARAM_FFC_PBITS */
652
0
                        if (ossl_unlikely(r->pbits != NULL)) {
653
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
654
0
                                           "param %s is repeated", s);
655
0
                            return 0;
656
0
                        }
657
0
                        r->pbits = (OSSL_PARAM *)p;
658
0
                    }
659
0
                    break;
660
0
                case 'c':
661
0
                    if (ossl_likely(strcmp("ounter", s + 2) == 0)) {
662
                        /* OSSL_PKEY_PARAM_FFC_PCOUNTER */
663
0
                        ERR_raise_data(ERR_LIB_PROV, ERR_R_UNSUPPORTED,
664
0
                                       "param %s is unsupported", s);
665
0
                        return 0;
666
0
                    }
667
0
                    break;
668
0
                case 'r':
669
0
                    switch(s[2]) {
670
0
                    default:
671
0
                        break;
672
0
                    case 'i':
673
0
                        if (ossl_likely(strcmp("v_len", s + 3) == 0)) {
674
                            /* OSSL_PKEY_PARAM_DH_PRIV_LEN */
675
0
                            if (ossl_unlikely(r->privlen != NULL)) {
676
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
677
0
                                               "param %s is repeated", s);
678
0
                                return 0;
679
0
                            }
680
0
                            r->privlen = (OSSL_PARAM *)p;
681
0
                        }
682
0
                        break;
683
0
                    case 'o':
684
0
                        if (ossl_likely(strcmp("perties", s + 3) == 0)) {
685
                            /* OSSL_PKEY_PARAM_FFC_DIGEST_PROPS */
686
0
                            ERR_raise_data(ERR_LIB_PROV, ERR_R_UNSUPPORTED,
687
0
                                           "param %s is unsupported", s);
688
0
                            return 0;
689
0
                        }
690
0
                    }
691
0
                }
692
0
                break;
693
0
            case 'q':
694
0
                if (ossl_likely(strcmp("bits", s + 1) == 0)) {
695
                    /* OSSL_PKEY_PARAM_FFC_QBITS */
696
0
                    ERR_raise_data(ERR_LIB_PROV, ERR_R_UNSUPPORTED,
697
0
                                   "param %s is unsupported", s);
698
0
                    return 0;
699
0
                }
700
0
                break;
701
0
            case 's':
702
0
                switch(s[1]) {
703
0
                default:
704
0
                    break;
705
0
                case 'a':
706
0
                    if (ossl_likely(strcmp("feprime-generator", s + 2) == 0)) {
707
                        /* OSSL_PKEY_PARAM_DH_GENERATOR */
708
0
                        if (ossl_unlikely(r->generator != NULL)) {
709
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
710
0
                                           "param %s is repeated", s);
711
0
                            return 0;
712
0
                        }
713
0
                        r->generator = (OSSL_PARAM *)p;
714
0
                    }
715
0
                    break;
716
0
                case 'e':
717
0
                    if (ossl_likely(strcmp("ed", s + 2) == 0)) {
718
                        /* OSSL_PKEY_PARAM_FFC_SEED */
719
0
                        ERR_raise_data(ERR_LIB_PROV, ERR_R_UNSUPPORTED,
720
0
                                       "param %s is unsupported", s);
721
0
                        return 0;
722
0
                    }
723
0
                }
724
0
                break;
725
0
            case 't':
726
0
                if (ossl_likely(strcmp("ype", s + 1) == 0)) {
727
                    /* OSSL_PKEY_PARAM_FFC_TYPE */
728
0
                    if (ossl_unlikely(r->type != NULL)) {
729
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
730
0
                                       "param %s is repeated", s);
731
0
                        return 0;
732
0
                    }
733
0
                    r->type = (OSSL_PARAM *)p;
734
0
                }
735
780
            }
736
2.97k
    return 1;
737
2.97k
}
738
#endif
739
/* End of machine generated */