/src/openssl41/providers/implementations/ciphers/ciphercommon.inc

Source
/*
 * Copyright 2025-2026 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the Apache License 2.0 (the \"License\").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */



/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#include <string.h>
#include <openssl/params.h>
#include <openssl/e_os2.h>
#include "internal/common.h"
#include "prov/proverr.h"

/* Machine generated */
#ifndef ossl_cipher_generic_get_params_list
static ossl_unused const OSSL_PARAM ossl_cipher_generic_get_params_list[] = {
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_MODE, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_BLOCK_SIZE, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_AEAD, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_CUSTOM_IV, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_CTS, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_HAS_RAND_KEY, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_ENCRYPT_THEN_MAC, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef ossl_cipher_generic_get_params_st
struct ossl_cipher_generic_get_params_st {
    OSSL_PARAM *aead;
    OSSL_PARAM *bsize;
    OSSL_PARAM *cts;
    OSSL_PARAM *custiv;
    OSSL_PARAM *etm;
    OSSL_PARAM *ivlen;
    OSSL_PARAM *keylen;
    OSSL_PARAM *mb;
    OSSL_PARAM *mode;
    OSSL_PARAM *rand;
};
#endif

#ifndef ossl_cipher_generic_get_params_decoder
static ossl_unused int ossl_cipher_generic_get_params_decoder
    (const OSSL_PARAM *p, struct ossl_cipher_generic_get_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'a':
                if (ossl_likely(strcmp("ead", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_AEAD */
                    if (ossl_unlikely(r->aead != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->aead = (OSSL_PARAM *)p;
                }
                break;
            case 'b':
                if (ossl_likely(strcmp("locksize", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_BLOCK_SIZE */
                    if (ossl_unlikely(r->bsize != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->bsize = (OSSL_PARAM *)p;
                }
                break;
            case 'c':
                switch(s[1]) {
                default:
                    break;
                case 't':
                    if (ossl_likely(strcmp("s", s + 2) == 0)) {
                        /* OSSL_CIPHER_PARAM_CTS */
                        if (ossl_unlikely(r->cts != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->cts = (OSSL_PARAM *)p;
                    }
                    break;
                case 'u':
                    if (ossl_likely(strcmp("stom-iv", s + 2) == 0)) {
                        /* OSSL_CIPHER_PARAM_CUSTOM_IV */
                        if (ossl_unlikely(r->custiv != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->custiv = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'e':
                if (ossl_likely(strcmp("ncrypt-then-mac", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_ENCRYPT_THEN_MAC */
                    if (ossl_unlikely(r->etm != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->etm = (OSSL_PARAM *)p;
                }
                break;
            case 'h':
                if (ossl_likely(strcmp("as-randkey", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_HAS_RAND_KEY */
                    if (ossl_unlikely(r->rand != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->rand = (OSSL_PARAM *)p;
                }
                break;
            case 'i':
                if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_IVLEN */
                    if (ossl_unlikely(r->ivlen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ivlen = (OSSL_PARAM *)p;
                }
                break;
            case 'k':
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_KEYLEN */
                    if (ossl_unlikely(r->keylen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->keylen = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                if (ossl_likely(strcmp("ode", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_MODE */
                    if (ossl_unlikely(r->mode != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->mode = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                if (ossl_likely(strcmp("ls-multi", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK */
                    if (ossl_unlikely(r->mb != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->mb = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef cipher_generic_get_ctx_params_list
static ossl_unused const OSSL_PARAM cipher_generic_get_ctx_params_list[] = {
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
    OSSL_PARAM_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef cipher_generic_get_ctx_params_st
struct cipher_generic_get_ctx_params_st {
    OSSL_PARAM *iv;
    OSSL_PARAM *ivlen;
    OSSL_PARAM *keylen;
    OSSL_PARAM *num;
    OSSL_PARAM *pad;
    OSSL_PARAM *tlsmac;
    OSSL_PARAM *updiv;
};
#endif

#ifndef cipher_generic_get_ctx_params_decoder
static ossl_unused int cipher_generic_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct cipher_generic_get_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'i':
                switch(s[1]) {
                default:
                    break;
                case 'v':
                    switch(s[2]) {
                    default:
                        break;
                    case 'l':
                        if (ossl_likely(strcmp("en", s + 3) == 0)) {
                            /* OSSL_CIPHER_PARAM_IVLEN */
                            if (ossl_unlikely(r->ivlen != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->ivlen = (OSSL_PARAM *)p;
                        }
                        break;
                    case '\0':
                        if (ossl_unlikely(r->iv != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->iv = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'k':
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_KEYLEN */
                    if (ossl_unlikely(r->keylen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->keylen = (OSSL_PARAM *)p;
                }
                break;
            case 'n':
                if (ossl_likely(strcmp("um", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_NUM */
                    if (ossl_unlikely(r->num != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->num = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("adding", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_PADDING */
                    if (ossl_unlikely(r->pad != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->pad = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                if (ossl_likely(strcmp("ls-mac", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_TLS_MAC */
                    if (ossl_unlikely(r->tlsmac != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->tlsmac = (OSSL_PARAM *)p;
                }
                break;
            case 'u':
                if (ossl_likely(strcmp("pdated-iv", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_UPDATED_IV */
                    if (ossl_unlikely(r->updiv != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->updiv = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef cipher_generic_set_ctx_params_list
static ossl_unused const OSSL_PARAM cipher_generic_set_ctx_params_list[] = {
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef cipher_generic_set_ctx_params_st
struct cipher_generic_set_ctx_params_st {
    OSSL_PARAM *bits;
    OSSL_PARAM *num;
    OSSL_PARAM *pad;
    OSSL_PARAM *tlsmacsize;
    OSSL_PARAM *tlsvers;
};
#endif

#ifndef cipher_generic_set_ctx_params_decoder
static ossl_unused int cipher_generic_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct cipher_generic_set_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'n':
                if (ossl_likely(strcmp("um", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_NUM */
                    if (ossl_unlikely(r->num != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->num = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("adding", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_PADDING */
                    if (ossl_unlikely(r->pad != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->pad = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                switch(s[1]) {
                default:
                    break;
                case 'l':
                    switch(s[2]) {
                    default:
                        break;
                    case 's':
                        switch(s[3]) {
                        default:
                            break;
                        case '-':
                            switch(s[4]) {
                            default:
                                break;
                            case 'm':
                                if (ossl_likely(strcmp("ac-size", s + 5) == 0)) {
                                    /* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
                                    if (ossl_unlikely(r->tlsmacsize != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->tlsmacsize = (OSSL_PARAM *)p;
                                }
                                break;
                            case 'v':
                                if (ossl_likely(strcmp("ersion", s + 5) == 0)) {
                                    /* OSSL_CIPHER_PARAM_TLS_VERSION */
                                    if (ossl_unlikely(r->tlsvers != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->tlsvers = (OSSL_PARAM *)p;
                                }
                            }
                        }
                    }
                }
                break;
            case 'u':
                if (ossl_likely(strcmp("se-bits", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_USE_BITS */
                    if (ossl_unlikely(r->bits != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->bits = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef cipher_var_keylen_set_ctx_params_list
static ossl_unused const OSSL_PARAM cipher_var_keylen_set_ctx_params_list[] = {
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef cipher_var_keylen_set_ctx_params_st
struct cipher_var_keylen_set_ctx_params_st {
    OSSL_PARAM *bits;
    OSSL_PARAM *keylen;
    OSSL_PARAM *num;
    OSSL_PARAM *pad;
    OSSL_PARAM *tlsmacsize;
    OSSL_PARAM *tlsvers;
};
#endif

#ifndef cipher_var_keylen_set_ctx_params_decoder
static ossl_unused int cipher_var_keylen_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct cipher_var_keylen_set_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            switch(s[0]) {
            default:
                break;
            case 'k':
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_KEYLEN */
                    if (ossl_unlikely(r->keylen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->keylen = (OSSL_PARAM *)p;
                }
                break;
            case 'n':
                if (ossl_likely(strcmp("um", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_NUM */
                    if (ossl_unlikely(r->num != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->num = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("adding", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_PADDING */
                    if (ossl_unlikely(r->pad != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->pad = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                switch(s[1]) {
                default:
                    break;
                case 'l':
                    switch(s[2]) {
                    default:
                        break;
                    case 's':
                        switch(s[3]) {
                        default:
                            break;
                        case '-':
                            switch(s[4]) {
                            default:
                                break;
                            case 'm':
                                if (ossl_likely(strcmp("ac-size", s + 5) == 0)) {
                                    /* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
                                    if (ossl_unlikely(r->tlsmacsize != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->tlsmacsize = (OSSL_PARAM *)p;
                                }
                                break;
                            case 'v':
                                if (ossl_likely(strcmp("ersion", s + 5) == 0)) {
                                    /* OSSL_CIPHER_PARAM_TLS_VERSION */
                                    if (ossl_unlikely(r->tlsvers != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->tlsvers = (OSSL_PARAM *)p;
                                }
                            }
                        }
                    }
                }
                break;
            case 'u':
                if (ossl_likely(strcmp("se-bits", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_USE_BITS */
                    if (ossl_unlikely(r->bits != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->bits = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2026-09-12 06:55

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	1.16M	{
55	1.16M	const char *s;
56
57	1.16M	memset(r, 0, sizeof(*r));
58	1.16M	if (p != NULL)
59	2.38M	for (; (s = p->key) != NULL; p++)
60	1.21M	switch(s[0]) {
61	1.15M	default:
62	1.15M	break;
63	1.15M	case 'a':
64	5.55k	if (ossl_likely(strcmp("ead", s + 1) == 0)) {
65		/* OSSL_CIPHER_PARAM_AEAD */
66	5.55k	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	5.55k	r->aead = (OSSL_PARAM *)p;
72	5.55k	}
73	5.55k	break;
74	5.55k	case 'b':
75	5.55k	if (ossl_likely(strcmp("locksize", s + 1) == 0)) {
76		/* OSSL_CIPHER_PARAM_BLOCK_SIZE */
77	5.55k	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	5.55k	r->bsize = (OSSL_PARAM *)p;
83	5.55k	}
84	5.55k	break;
85	11.1k	case 'c':
86	11.1k	switch(s[1]) {
87	0	default:
88	0	break;
89	5.55k	case 't':
90	5.55k	if (ossl_likely(strcmp("s", s + 2) == 0)) {
91		/* OSSL_CIPHER_PARAM_CTS */
92	5.55k	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	5.55k	r->cts = (OSSL_PARAM *)p;
98	5.55k	}
99	5.55k	break;
100	5.55k	case 'u':
101	5.55k	if (ossl_likely(strcmp("stom-iv", s + 2) == 0)) {
102		/* OSSL_CIPHER_PARAM_CUSTOM_IV */
103	5.55k	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	5.55k	r->custiv = (OSSL_PARAM *)p;
109	5.55k	}
110	11.1k	}
111	11.1k	break;
112	11.1k	case 'e':
113	5.55k	if (ossl_likely(strcmp("ncrypt-then-mac", s + 1) == 0)) {
114		/* OSSL_CIPHER_PARAM_ENCRYPT_THEN_MAC */
115	5.55k	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	5.55k	r->etm = (OSSL_PARAM *)p;
121	5.55k	}
122	5.55k	break;
123	5.55k	case 'h':
124	5.55k	if (ossl_likely(strcmp("as-randkey", s + 1) == 0)) {
125		/* OSSL_CIPHER_PARAM_HAS_RAND_KEY */
126	5.55k	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	5.55k	r->rand = (OSSL_PARAM *)p;
132	5.55k	}
133	5.55k	break;
134	5.55k	case 'i':
135	5.55k	if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
136		/* OSSL_CIPHER_PARAM_IVLEN */
137	5.55k	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	5.55k	r->ivlen = (OSSL_PARAM *)p;
143	5.55k	}
144	5.55k	break;
145	5.55k	case 'k':
146	5.55k	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
147		/* OSSL_CIPHER_PARAM_KEYLEN */
148	5.55k	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	5.55k	r->keylen = (OSSL_PARAM *)p;
154	5.55k	}
155	5.55k	break;
156	5.55k	case 'm':
157	5.55k	if (ossl_likely(strcmp("ode", s + 1) == 0)) {
158		/* OSSL_CIPHER_PARAM_MODE */
159	5.55k	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	5.55k	r->mode = (OSSL_PARAM *)p;
165	5.55k	}
166	5.55k	break;
167	5.55k	case 't':
168	5.55k	if (ossl_likely(strcmp("ls-multi", s + 1) == 0)) {
169		/* OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK */
170	5.55k	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	5.55k	r->mb = (OSSL_PARAM *)p;
176	5.55k	}
177	1.21M	}
178	1.16M	return 1;
179	1.16M	}
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	172k	{
213	172k	const char *s;
214
215	172k	memset(r, 0, sizeof(*r));
216	172k	if (p != NULL)
217	345k	for (; (s = p->key) != NULL; p++)
218	172k	switch(s[0]) {
219	0	default:
220	0	break;
221	4.63k	case 'i':
222	4.63k	switch(s[1]) {
223	0	default:
224	0	break;
225	4.63k	case 'v':
226	4.63k	switch(s[2]) {
227	0	default:
228	0	break;
229	4.63k	case 'l':
230	4.63k	if (ossl_likely(strcmp("en", s + 3) == 0)) {
231		/* OSSL_CIPHER_PARAM_IVLEN */
232	4.63k	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	4.63k	r->ivlen = (OSSL_PARAM *)p;
238	4.63k	}
239	4.63k	break;
240	4.63k	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	4.63k	}
248	4.63k	}
249	4.63k	break;
250	117k	case 'k':
251	117k	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
252		/* OSSL_CIPHER_PARAM_KEYLEN */
253	117k	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	117k	r->keylen = (OSSL_PARAM *)p;
259	117k	}
260	117k	break;
261	117k	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	50.5k	case 't':
284	50.5k	if (ossl_likely(strcmp("ls-mac", s + 1) == 0)) {
285		/* OSSL_CIPHER_PARAM_TLS_MAC */
286	50.5k	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	50.5k	r->tlsmac = (OSSL_PARAM *)p;
292	50.5k	}
293	50.5k	break;
294	50.5k	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	172k	}
305	172k	return 1;
306	172k	}
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	3.52k	{
336	3.52k	const char *s;
337
338	3.52k	memset(r, 0, sizeof(*r));
339	3.52k	if (p != NULL)
340	10.4k	for (; (s = p->key) != NULL; p++)
341	6.93k	switch(s[0]) {
342	0	default:
343	0	break;
344	90	case 'n':
345	90	if (ossl_likely(strcmp("um", s + 1) == 0)) {
346		/* OSSL_CIPHER_PARAM_NUM */
347	90	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	90	r->num = (OSSL_PARAM *)p;
353	90	}
354	90	break;
355	472	case 'p':
356	472	if (ossl_likely(strcmp("adding", s + 1) == 0)) {
357		/* OSSL_CIPHER_PARAM_PADDING */
358	472	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	472	r->pad = (OSSL_PARAM *)p;
364	472	}
365	472	break;
366	6.28k	case 't':
367	6.28k	switch(s[1]) {
368	0	default:
369	0	break;
370	6.28k	case 'l':
371	6.28k	switch(s[2]) {
372	0	default:
373	0	break;
374	6.28k	case 's':
375	6.28k	switch(s[3]) {
376	0	default:
377	0	break;
378	6.28k	case '-':
379	6.28k	switch(s[4]) {
380	0	default:
381	0	break;
382	3.14k	case 'm':
383	3.14k	if (ossl_likely(strcmp("ac-size", s + 5) == 0)) {
384		/* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
385	3.14k	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	3.14k	r->tlsmacsize = (OSSL_PARAM *)p;
391	3.14k	}
392	3.14k	break;
393	3.14k	case 'v':
394	3.14k	if (ossl_likely(strcmp("ersion", s + 5) == 0)) {
395		/* OSSL_CIPHER_PARAM_TLS_VERSION */
396	3.14k	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	3.14k	r->tlsvers = (OSSL_PARAM *)p;
402	3.14k	}
403	6.28k	}
404	6.28k	}
405	6.28k	}
406	6.28k	}
407	6.28k	break;
408	6.28k	case 'u':
409	90	if (ossl_likely(strcmp("se-bits", s + 1) == 0)) {
410		/* OSSL_CIPHER_PARAM_USE_BITS */
411	90	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	90	r->bits = (OSSL_PARAM *)p;
417	90	}
418	6.93k	}
419	3.52k	return 1;
420	3.52k	}
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 */