/src/openssl40/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 */
#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 by util/perl/OpenSSL/paramnames.pm */
#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_string(OSSL_CIPHER_PARAM_TLS_MAC, NULL, 0),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR, NULL),
# endif
    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 'f':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR */
                    if (!OSSL_PARAM_set_int((OSSL_PARAM *)p, 1))
                        return 0;
                }
# endif
                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 by util/perl/OpenSSL/paramnames.pm */
#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 by util/perl/OpenSSL/paramnames.pm */
#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-10-28 06:28

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