Coverage Report

Created: 2026-09-13 06:13

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/openssl/providers/implementations/ciphers/ciphercommon.inc
Line
Count
Source
1
/*
2
 * Copyright 2025-2026 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 ossl_cipher_generic_get_params_list
21
static ossl_unused const OSSL_PARAM ossl_cipher_generic_get_params_list[] = {
22
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_MODE, NULL),
23
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
24
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
25
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_BLOCK_SIZE, NULL),
26
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_AEAD, NULL),
27
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_CUSTOM_IV, NULL),
28
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_CTS, NULL),
29
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK, NULL),
30
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_HAS_RAND_KEY, NULL),
31
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_ENCRYPT_THEN_MAC, NULL),
32
    OSSL_PARAM_END
33
};
34
#endif
35
36
#ifndef ossl_cipher_generic_get_params_st
37
struct ossl_cipher_generic_get_params_st {
38
    OSSL_PARAM *aead;
39
    OSSL_PARAM *bsize;
40
    OSSL_PARAM *cts;
41
    OSSL_PARAM *custiv;
42
    OSSL_PARAM *etm;
43
    OSSL_PARAM *ivlen;
44
    OSSL_PARAM *keylen;
45
    OSSL_PARAM *mb;
46
    OSSL_PARAM *mode;
47
    OSSL_PARAM *rand;
48
};
49
#endif
50
51
#ifndef ossl_cipher_generic_get_params_decoder
52
static ossl_unused int ossl_cipher_generic_get_params_decoder
53
    (const OSSL_PARAM *p, struct ossl_cipher_generic_get_params_st *r)
54
147
{
55
147
    const char *s;
56
57
147
    memset(r, 0, sizeof(*r));
58
147
    if (p != NULL)
59
1.61k
        for (; (s = p->key) != NULL; p++)
60
1.47k
            switch(s[0]) {
61
0
            default:
62
0
                break;
63
147
            case 'a':
64
147
                if (ossl_likely(strcmp("ead", s + 1) == 0)) {
65
                    /* OSSL_CIPHER_PARAM_AEAD */
66
147
                    if (ossl_unlikely(r->aead != NULL)) {
67
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
68
0
                                       "param %s is repeated", s);
69
0
                        return 0;
70
0
                    }
71
147
                    r->aead = (OSSL_PARAM *)p;
72
147
                }
73
147
                break;
74
147
            case 'b':
75
147
                if (ossl_likely(strcmp("locksize", s + 1) == 0)) {
76
                    /* OSSL_CIPHER_PARAM_BLOCK_SIZE */
77
147
                    if (ossl_unlikely(r->bsize != NULL)) {
78
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
79
0
                                       "param %s is repeated", s);
80
0
                        return 0;
81
0
                    }
82
147
                    r->bsize = (OSSL_PARAM *)p;
83
147
                }
84
147
                break;
85
294
            case 'c':
86
294
                switch(s[1]) {
87
0
                default:
88
0
                    break;
89
147
                case 't':
90
147
                    if (ossl_likely(strcmp("s", s + 2) == 0)) {
91
                        /* OSSL_CIPHER_PARAM_CTS */
92
147
                        if (ossl_unlikely(r->cts != NULL)) {
93
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
94
0
                                           "param %s is repeated", s);
95
0
                            return 0;
96
0
                        }
97
147
                        r->cts = (OSSL_PARAM *)p;
98
147
                    }
99
147
                    break;
100
147
                case 'u':
101
147
                    if (ossl_likely(strcmp("stom-iv", s + 2) == 0)) {
102
                        /* OSSL_CIPHER_PARAM_CUSTOM_IV */
103
147
                        if (ossl_unlikely(r->custiv != NULL)) {
104
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
105
0
                                           "param %s is repeated", s);
106
0
                            return 0;
107
0
                        }
108
147
                        r->custiv = (OSSL_PARAM *)p;
109
147
                    }
110
294
                }
111
294
                break;
112
294
            case 'e':
113
147
                if (ossl_likely(strcmp("ncrypt-then-mac", s + 1) == 0)) {
114
                    /* OSSL_CIPHER_PARAM_ENCRYPT_THEN_MAC */
115
147
                    if (ossl_unlikely(r->etm != 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
147
                    r->etm = (OSSL_PARAM *)p;
121
147
                }
122
147
                break;
123
147
            case 'h':
124
147
                if (ossl_likely(strcmp("as-randkey", s + 1) == 0)) {
125
                    /* OSSL_CIPHER_PARAM_HAS_RAND_KEY */
126
147
                    if (ossl_unlikely(r->rand != 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
147
                    r->rand = (OSSL_PARAM *)p;
132
147
                }
133
147
                break;
134
147
            case 'i':
135
147
                if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
136
                    /* OSSL_CIPHER_PARAM_IVLEN */
137
147
                    if (ossl_unlikely(r->ivlen != 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
147
                    r->ivlen = (OSSL_PARAM *)p;
143
147
                }
144
147
                break;
145
147
            case 'k':
146
147
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
147
                    /* OSSL_CIPHER_PARAM_KEYLEN */
148
147
                    if (ossl_unlikely(r->keylen != 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
147
                    r->keylen = (OSSL_PARAM *)p;
154
147
                }
155
147
                break;
156
147
            case 'm':
157
147
                if (ossl_likely(strcmp("ode", s + 1) == 0)) {
158
                    /* OSSL_CIPHER_PARAM_MODE */
159
147
                    if (ossl_unlikely(r->mode != 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
147
                    r->mode = (OSSL_PARAM *)p;
165
147
                }
166
147
                break;
167
147
            case 't':
168
147
                if (ossl_likely(strcmp("ls-multi", s + 1) == 0)) {
169
                    /* OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK */
170
147
                    if (ossl_unlikely(r->mb != NULL)) {
171
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
172
0
                                       "param %s is repeated", s);
173
0
                        return 0;
174
0
                    }
175
147
                    r->mb = (OSSL_PARAM *)p;
176
147
                }
177
1.47k
            }
178
147
    return 1;
179
147
}
180
#endif
181
/* End of machine generated */
182
183
/* Machine generated */
184
#ifndef cipher_generic_get_ctx_params_list
185
static ossl_unused const OSSL_PARAM cipher_generic_get_ctx_params_list[] = {
186
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
187
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
188
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
189
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
190
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
191
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
192
    OSSL_PARAM_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC, NULL, 0),
193
    OSSL_PARAM_END
194
};
195
#endif
196
197
#ifndef cipher_generic_get_ctx_params_st
198
struct cipher_generic_get_ctx_params_st {
199
    OSSL_PARAM *iv;
200
    OSSL_PARAM *ivlen;
201
    OSSL_PARAM *keylen;
202
    OSSL_PARAM *num;
203
    OSSL_PARAM *pad;
204
    OSSL_PARAM *tlsmac;
205
    OSSL_PARAM *updiv;
206
};
207
#endif
208
209
#ifndef cipher_generic_get_ctx_params_decoder
210
static ossl_unused int cipher_generic_get_ctx_params_decoder
211
    (const OSSL_PARAM *p, struct cipher_generic_get_ctx_params_st *r)
212
601
{
213
601
    const char *s;
214
215
601
    memset(r, 0, sizeof(*r));
216
601
    if (p != NULL)
217
1.20k
        for (; (s = p->key) != NULL; p++)
218
601
            switch(s[0]) {
219
0
            default:
220
0
                break;
221
136
            case 'i':
222
136
                switch(s[1]) {
223
0
                default:
224
0
                    break;
225
136
                case 'v':
226
136
                    switch(s[2]) {
227
0
                    default:
228
0
                        break;
229
136
                    case 'l':
230
136
                        if (ossl_likely(strcmp("en", s + 3) == 0)) {
231
                            /* OSSL_CIPHER_PARAM_IVLEN */
232
136
                            if (ossl_unlikely(r->ivlen != NULL)) {
233
0
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
234
0
                                               "param %s is repeated", s);
235
0
                                return 0;
236
0
                            }
237
136
                            r->ivlen = (OSSL_PARAM *)p;
238
136
                        }
239
136
                        break;
240
136
                    case '\0':
241
0
                        if (ossl_unlikely(r->iv != NULL)) {
242
0
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
243
0
                                           "param %s is repeated", s);
244
0
                            return 0;
245
0
                        }
246
0
                        r->iv = (OSSL_PARAM *)p;
247
136
                    }
248
136
                }
249
136
                break;
250
465
            case 'k':
251
465
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
252
                    /* OSSL_CIPHER_PARAM_KEYLEN */
253
465
                    if (ossl_unlikely(r->keylen != NULL)) {
254
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
255
0
                                       "param %s is repeated", s);
256
0
                        return 0;
257
0
                    }
258
465
                    r->keylen = (OSSL_PARAM *)p;
259
465
                }
260
465
                break;
261
465
            case 'n':
262
0
                if (ossl_likely(strcmp("um", s + 1) == 0)) {
263
                    /* OSSL_CIPHER_PARAM_NUM */
264
0
                    if (ossl_unlikely(r->num != NULL)) {
265
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
266
0
                                       "param %s is repeated", s);
267
0
                        return 0;
268
0
                    }
269
0
                    r->num = (OSSL_PARAM *)p;
270
0
                }
271
0
                break;
272
0
            case 'p':
273
0
                if (ossl_likely(strcmp("adding", s + 1) == 0)) {
274
                    /* OSSL_CIPHER_PARAM_PADDING */
275
0
                    if (ossl_unlikely(r->pad != NULL)) {
276
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
277
0
                                       "param %s is repeated", s);
278
0
                        return 0;
279
0
                    }
280
0
                    r->pad = (OSSL_PARAM *)p;
281
0
                }
282
0
                break;
283
0
            case 't':
284
0
                if (ossl_likely(strcmp("ls-mac", s + 1) == 0)) {
285
                    /* OSSL_CIPHER_PARAM_TLS_MAC */
286
0
                    if (ossl_unlikely(r->tlsmac != 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->tlsmac = (OSSL_PARAM *)p;
292
0
                }
293
0
                break;
294
0
            case 'u':
295
0
                if (ossl_likely(strcmp("pdated-iv", s + 1) == 0)) {
296
                    /* OSSL_CIPHER_PARAM_UPDATED_IV */
297
0
                    if (ossl_unlikely(r->updiv != NULL)) {
298
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
299
0
                                       "param %s is repeated", s);
300
0
                        return 0;
301
0
                    }
302
0
                    r->updiv = (OSSL_PARAM *)p;
303
0
                }
304
601
            }
305
601
    return 1;
306
601
}
307
#endif
308
/* End of machine generated */
309
310
/* Machine generated */
311
#ifndef cipher_generic_set_ctx_params_list
312
static ossl_unused const OSSL_PARAM cipher_generic_set_ctx_params_list[] = {
313
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
314
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
315
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
316
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
317
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
318
    OSSL_PARAM_END
319
};
320
#endif
321
322
#ifndef cipher_generic_set_ctx_params_st
323
struct cipher_generic_set_ctx_params_st {
324
    OSSL_PARAM *bits;
325
    OSSL_PARAM *num;
326
    OSSL_PARAM *pad;
327
    OSSL_PARAM *tlsmacsize;
328
    OSSL_PARAM *tlsvers;
329
};
330
#endif
331
332
#ifndef cipher_generic_set_ctx_params_decoder
333
static ossl_unused int cipher_generic_set_ctx_params_decoder
334
    (const OSSL_PARAM *p, struct cipher_generic_set_ctx_params_st *r)
335
0
{
336
0
    const char *s;
337
338
0
    memset(r, 0, sizeof(*r));
339
0
    if (p != NULL)
340
0
        for (; (s = p->key) != NULL; p++)
341
0
            switch(s[0]) {
342
0
            default:
343
0
                break;
344
0
            case 'n':
345
0
                if (ossl_likely(strcmp("um", s + 1) == 0)) {
346
                    /* OSSL_CIPHER_PARAM_NUM */
347
0
                    if (ossl_unlikely(r->num != NULL)) {
348
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
349
0
                                       "param %s is repeated", s);
350
0
                        return 0;
351
0
                    }
352
0
                    r->num = (OSSL_PARAM *)p;
353
0
                }
354
0
                break;
355
0
            case 'p':
356
0
                if (ossl_likely(strcmp("adding", s + 1) == 0)) {
357
                    /* OSSL_CIPHER_PARAM_PADDING */
358
0
                    if (ossl_unlikely(r->pad != NULL)) {
359
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
360
0
                                       "param %s is repeated", s);
361
0
                        return 0;
362
0
                    }
363
0
                    r->pad = (OSSL_PARAM *)p;
364
0
                }
365
0
                break;
366
0
            case 't':
367
0
                switch(s[1]) {
368
0
                default:
369
0
                    break;
370
0
                case 'l':
371
0
                    switch(s[2]) {
372
0
                    default:
373
0
                        break;
374
0
                    case 's':
375
0
                        switch(s[3]) {
376
0
                        default:
377
0
                            break;
378
0
                        case '-':
379
0
                            switch(s[4]) {
380
0
                            default:
381
0
                                break;
382
0
                            case 'm':
383
0
                                if (ossl_likely(strcmp("ac-size", s + 5) == 0)) {
384
                                    /* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
385
0
                                    if (ossl_unlikely(r->tlsmacsize != NULL)) {
386
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
387
0
                                                       "param %s is repeated", s);
388
0
                                        return 0;
389
0
                                    }
390
0
                                    r->tlsmacsize = (OSSL_PARAM *)p;
391
0
                                }
392
0
                                break;
393
0
                            case 'v':
394
0
                                if (ossl_likely(strcmp("ersion", s + 5) == 0)) {
395
                                    /* OSSL_CIPHER_PARAM_TLS_VERSION */
396
0
                                    if (ossl_unlikely(r->tlsvers != NULL)) {
397
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
398
0
                                                       "param %s is repeated", s);
399
0
                                        return 0;
400
0
                                    }
401
0
                                    r->tlsvers = (OSSL_PARAM *)p;
402
0
                                }
403
0
                            }
404
0
                        }
405
0
                    }
406
0
                }
407
0
                break;
408
0
            case 'u':
409
0
                if (ossl_likely(strcmp("se-bits", s + 1) == 0)) {
410
                    /* OSSL_CIPHER_PARAM_USE_BITS */
411
0
                    if (ossl_unlikely(r->bits != NULL)) {
412
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
413
0
                                       "param %s is repeated", s);
414
0
                        return 0;
415
0
                    }
416
0
                    r->bits = (OSSL_PARAM *)p;
417
0
                }
418
0
            }
419
0
    return 1;
420
0
}
421
#endif
422
/* End of machine generated */
423
424
/* Machine generated */
425
#ifndef cipher_var_keylen_set_ctx_params_list
426
static ossl_unused const OSSL_PARAM cipher_var_keylen_set_ctx_params_list[] = {
427
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
428
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
429
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
430
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
431
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
432
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
433
    OSSL_PARAM_END
434
};
435
#endif
436
437
#ifndef cipher_var_keylen_set_ctx_params_st
438
struct cipher_var_keylen_set_ctx_params_st {
439
    OSSL_PARAM *bits;
440
    OSSL_PARAM *keylen;
441
    OSSL_PARAM *num;
442
    OSSL_PARAM *pad;
443
    OSSL_PARAM *tlsmacsize;
444
    OSSL_PARAM *tlsvers;
445
};
446
#endif
447
448
#ifndef cipher_var_keylen_set_ctx_params_decoder
449
static ossl_unused int cipher_var_keylen_set_ctx_params_decoder
450
    (const OSSL_PARAM *p, struct cipher_var_keylen_set_ctx_params_st *r)
451
0
{
452
0
    const char *s;
453
454
0
    memset(r, 0, sizeof(*r));
455
0
    if (p != NULL)
456
0
        for (; (s = p->key) != NULL; p++)
457
0
            switch(s[0]) {
458
0
            default:
459
0
                break;
460
0
            case 'k':
461
0
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
462
                    /* OSSL_CIPHER_PARAM_KEYLEN */
463
0
                    if (ossl_unlikely(r->keylen != 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
0
                    r->keylen = (OSSL_PARAM *)p;
469
0
                }
470
0
                break;
471
0
            case 'n':
472
0
                if (ossl_likely(strcmp("um", s + 1) == 0)) {
473
                    /* OSSL_CIPHER_PARAM_NUM */
474
0
                    if (ossl_unlikely(r->num != NULL)) {
475
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
476
0
                                       "param %s is repeated", s);
477
0
                        return 0;
478
0
                    }
479
0
                    r->num = (OSSL_PARAM *)p;
480
0
                }
481
0
                break;
482
0
            case 'p':
483
0
                if (ossl_likely(strcmp("adding", s + 1) == 0)) {
484
                    /* OSSL_CIPHER_PARAM_PADDING */
485
0
                    if (ossl_unlikely(r->pad != NULL)) {
486
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
487
0
                                       "param %s is repeated", s);
488
0
                        return 0;
489
0
                    }
490
0
                    r->pad = (OSSL_PARAM *)p;
491
0
                }
492
0
                break;
493
0
            case 't':
494
0
                switch(s[1]) {
495
0
                default:
496
0
                    break;
497
0
                case 'l':
498
0
                    switch(s[2]) {
499
0
                    default:
500
0
                        break;
501
0
                    case 's':
502
0
                        switch(s[3]) {
503
0
                        default:
504
0
                            break;
505
0
                        case '-':
506
0
                            switch(s[4]) {
507
0
                            default:
508
0
                                break;
509
0
                            case 'm':
510
0
                                if (ossl_likely(strcmp("ac-size", s + 5) == 0)) {
511
                                    /* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
512
0
                                    if (ossl_unlikely(r->tlsmacsize != NULL)) {
513
0
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
514
0
                                                       "param %s is repeated", s);
515
0
                                        return 0;
516
0
                                    }
517
0
                                    r->tlsmacsize = (OSSL_PARAM *)p;
518
0
                                }
519
0
                                break;
520
0
                            case 'v':
521
0
                                if (ossl_likely(strcmp("ersion", s + 5) == 0)) {
522
                                    /* OSSL_CIPHER_PARAM_TLS_VERSION */
523
0
                                    if (ossl_unlikely(r->tlsvers != 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->tlsvers = (OSSL_PARAM *)p;
529
0
                                }
530
0
                            }
531
0
                        }
532
0
                    }
533
0
                }
534
0
                break;
535
0
            case 'u':
536
0
                if (ossl_likely(strcmp("se-bits", s + 1) == 0)) {
537
                    /* OSSL_CIPHER_PARAM_USE_BITS */
538
0
                    if (ossl_unlikely(r->bits != NULL)) {
539
0
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
540
0
                                       "param %s is repeated", s);
541
0
                        return 0;
542
0
                    }
543
0
                    r->bits = (OSSL_PARAM *)p;
544
0
                }
545
0
            }
546
0
    return 1;
547
0
}
548
#endif
549
/* End of machine generated */