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

Source
/*
 * Copyright 2025 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 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 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 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),
    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 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 by util/perl/OpenSSL/paramnames.pm */
#ifndef cipher_generic_set_ctx_params_list
static 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 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 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 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: 2025-10-28 06:56

Line	Count	Source
1		/*
2		* Copyright 2025 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the Apache License 2.0 (the \"License\"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10
11
12		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
13		#ifndef ossl_cipher_generic_get_params_list
14		static 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 int ossl_cipher_generic_get_params_decoder
46		(const OSSL_PARAM p, struct ossl_cipher_generic_get_params_st r)
47	2.08k	{
48	2.08k	const char *s;
49
50	2.08k	memset(r, 0, sizeof(*r));
51	2.08k	if (p != NULL)
52	22.8k	for (; (s = p->key) != NULL; p++)
53	20.8k	switch(s[0]) {
54	0	default:
55	0	break;
56	2.08k	case 'a':
57	2.08k	if (ossl_likely(strcmp("ead", s + 1) == 0)) {
58		/* OSSL_CIPHER_PARAM_AEAD */
59	2.08k	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	2.08k	r->aead = (OSSL_PARAM *)p;
65	2.08k	}
66	2.08k	break;
67	2.08k	case 'b':
68	2.08k	if (ossl_likely(strcmp("locksize", s + 1) == 0)) {
69		/* OSSL_CIPHER_PARAM_BLOCK_SIZE */
70	2.08k	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	2.08k	r->bsize = (OSSL_PARAM *)p;
76	2.08k	}
77	2.08k	break;
78	4.16k	case 'c':
79	4.16k	switch(s[1]) {
80	0	default:
81	0	break;
82	2.08k	case 't':
83	2.08k	if (ossl_likely(strcmp("s", s + 2) == 0)) {
84		/* OSSL_CIPHER_PARAM_CTS */
85	2.08k	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	2.08k	r->cts = (OSSL_PARAM *)p;
91	2.08k	}
92	2.08k	break;
93	2.08k	case 'u':
94	2.08k	if (ossl_likely(strcmp("stom-iv", s + 2) == 0)) {
95		/* OSSL_CIPHER_PARAM_CUSTOM_IV */
96	2.08k	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	2.08k	r->custiv = (OSSL_PARAM *)p;
102	2.08k	}
103	4.16k	}
104	4.16k	break;
105	4.16k	case 'e':
106	2.08k	if (ossl_likely(strcmp("ncrypt-then-mac", s + 1) == 0)) {
107		/* OSSL_CIPHER_PARAM_ENCRYPT_THEN_MAC */
108	2.08k	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	2.08k	r->etm = (OSSL_PARAM *)p;
114	2.08k	}
115	2.08k	break;
116	2.08k	case 'h':
117	2.08k	if (ossl_likely(strcmp("as-randkey", s + 1) == 0)) {
118		/* OSSL_CIPHER_PARAM_HAS_RAND_KEY */
119	2.08k	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	2.08k	r->rand = (OSSL_PARAM *)p;
125	2.08k	}
126	2.08k	break;
127	2.08k	case 'i':
128	2.08k	if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
129		/* OSSL_CIPHER_PARAM_IVLEN */
130	2.08k	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	2.08k	r->ivlen = (OSSL_PARAM *)p;
136	2.08k	}
137	2.08k	break;
138	2.08k	case 'k':
139	2.08k	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
140		/* OSSL_CIPHER_PARAM_KEYLEN */
141	2.08k	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	2.08k	r->keylen = (OSSL_PARAM *)p;
147	2.08k	}
148	2.08k	break;
149	2.08k	case 'm':
150	2.08k	if (ossl_likely(strcmp("ode", s + 1) == 0)) {
151		/* OSSL_CIPHER_PARAM_MODE */
152	2.08k	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	2.08k	r->mode = (OSSL_PARAM *)p;
158	2.08k	}
159	2.08k	break;
160	2.08k	case 't':
161	2.08k	if (ossl_likely(strcmp("ls-multi", s + 1) == 0)) {
162		/* OSSL_CIPHER_PARAM_TLS1_MULTIBLOCK */
163	2.08k	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	2.08k	r->mb = (OSSL_PARAM *)p;
169	2.08k	}
170	20.8k	}
171	2.08k	return 1;
172	2.08k	}
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 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		OSSL_PARAM_END
187		};
188		#endif
189
190		#ifndef cipher_generic_get_ctx_params_st
191		struct cipher_generic_get_ctx_params_st {
192		OSSL_PARAM *iv;
193		OSSL_PARAM *ivlen;
194		OSSL_PARAM *keylen;
195		OSSL_PARAM *num;
196		OSSL_PARAM *pad;
197		OSSL_PARAM *tlsmac;
198		OSSL_PARAM *updiv;
199		};
200		#endif
201
202		#ifndef cipher_generic_get_ctx_params_decoder
203		static int cipher_generic_get_ctx_params_decoder
204		(const OSSL_PARAM p, struct cipher_generic_get_ctx_params_st r)
205	128	{
206	128	const char *s;
207
208	128	memset(r, 0, sizeof(*r));
209	128	if (p != NULL)
210	256	for (; (s = p->key) != NULL; p++)
211	128	switch(s[0]) {
212	0	default:
213	0	break;
214	32	case 'i':
215	32	switch(s[1]) {
216	0	default:
217	0	break;
218	32	case 'v':
219	32	switch(s[2]) {
220	0	default:
221	0	break;
222	32	case 'l':
223	32	if (ossl_likely(strcmp("en", s + 3) == 0)) {
224		/* OSSL_CIPHER_PARAM_IVLEN */
225	32	if (ossl_unlikely(r->ivlen != NULL)) {
226	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
227	0	"param %s is repeated", s);
228	0	return 0;
229	0	}
230	32	r->ivlen = (OSSL_PARAM *)p;
231	32	}
232	32	break;
233	32	case '\0':
234	0	if (ossl_unlikely(r->iv != NULL)) {
235	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
236	0	"param %s is repeated", s);
237	0	return 0;
238	0	}
239	0	r->iv = (OSSL_PARAM *)p;
240	32	}
241	32	}
242	32	break;
243	96	case 'k':
244	96	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
245		/* OSSL_CIPHER_PARAM_KEYLEN */
246	96	if (ossl_unlikely(r->keylen != 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	96	r->keylen = (OSSL_PARAM *)p;
252	96	}
253	96	break;
254	96	case 'n':
255	0	if (ossl_likely(strcmp("um", s + 1) == 0)) {
256		/* OSSL_CIPHER_PARAM_NUM */
257	0	if (ossl_unlikely(r->num != NULL)) {
258	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
259	0	"param %s is repeated", s);
260	0	return 0;
261	0	}
262	0	r->num = (OSSL_PARAM *)p;
263	0	}
264	0	break;
265	0	case 'p':
266	0	if (ossl_likely(strcmp("adding", s + 1) == 0)) {
267		/* OSSL_CIPHER_PARAM_PADDING */
268	0	if (ossl_unlikely(r->pad != NULL)) {
269	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
270	0	"param %s is repeated", s);
271	0	return 0;
272	0	}
273	0	r->pad = (OSSL_PARAM *)p;
274	0	}
275	0	break;
276	0	case 't':
277	0	if (ossl_likely(strcmp("ls-mac", s + 1) == 0)) {
278		/* OSSL_CIPHER_PARAM_TLS_MAC */
279	0	if (ossl_unlikely(r->tlsmac != NULL)) {
280	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
281	0	"param %s is repeated", s);
282	0	return 0;
283	0	}
284	0	r->tlsmac = (OSSL_PARAM *)p;
285	0	}
286	0	break;
287	0	case 'u':
288	0	if (ossl_likely(strcmp("pdated-iv", s + 1) == 0)) {
289		/* OSSL_CIPHER_PARAM_UPDATED_IV */
290	0	if (ossl_unlikely(r->updiv != NULL)) {
291	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
292	0	"param %s is repeated", s);
293	0	return 0;
294	0	}
295	0	r->updiv = (OSSL_PARAM *)p;
296	0	}
297	128	}
298	128	return 1;
299	128	}
300		#endif
301		/* End of machine generated */
302
303		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
304		#ifndef cipher_generic_set_ctx_params_list
305		static const OSSL_PARAM cipher_generic_set_ctx_params_list[] = {
306		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
307		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
308		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
309		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
310		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
311		OSSL_PARAM_END
312		};
313		#endif
314
315		#ifndef cipher_generic_set_ctx_params_st
316		struct cipher_generic_set_ctx_params_st {
317		OSSL_PARAM *bits;
318		OSSL_PARAM *num;
319		OSSL_PARAM *pad;
320		OSSL_PARAM *tlsmacsize;
321		OSSL_PARAM *tlsvers;
322		};
323		#endif
324
325		#ifndef cipher_generic_set_ctx_params_decoder
326		static int cipher_generic_set_ctx_params_decoder
327		(const OSSL_PARAM p, struct cipher_generic_set_ctx_params_st r)
328	0	{
329	0	const char *s;
330
331	0	memset(r, 0, sizeof(*r));
332	0	if (p != NULL)
333	0	for (; (s = p->key) != NULL; p++)
334	0	switch(s[0]) {
335	0	default:
336	0	break;
337	0	case 'n':
338	0	if (ossl_likely(strcmp("um", s + 1) == 0)) {
339		/* OSSL_CIPHER_PARAM_NUM */
340	0	if (ossl_unlikely(r->num != NULL)) {
341	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
342	0	"param %s is repeated", s);
343	0	return 0;
344	0	}
345	0	r->num = (OSSL_PARAM *)p;
346	0	}
347	0	break;
348	0	case 'p':
349	0	if (ossl_likely(strcmp("adding", s + 1) == 0)) {
350		/* OSSL_CIPHER_PARAM_PADDING */
351	0	if (ossl_unlikely(r->pad != NULL)) {
352	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
353	0	"param %s is repeated", s);
354	0	return 0;
355	0	}
356	0	r->pad = (OSSL_PARAM *)p;
357	0	}
358	0	break;
359	0	case 't':
360	0	switch(s[1]) {
361	0	default:
362	0	break;
363	0	case 'l':
364	0	switch(s[2]) {
365	0	default:
366	0	break;
367	0	case 's':
368	0	switch(s[3]) {
369	0	default:
370	0	break;
371	0	case '-':
372	0	switch(s[4]) {
373	0	default:
374	0	break;
375	0	case 'm':
376	0	if (ossl_likely(strcmp("ac-size", s + 5) == 0)) {
377		/* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
378	0	if (ossl_unlikely(r->tlsmacsize != NULL)) {
379	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
380	0	"param %s is repeated", s);
381	0	return 0;
382	0	}
383	0	r->tlsmacsize = (OSSL_PARAM *)p;
384	0	}
385	0	break;
386	0	case 'v':
387	0	if (ossl_likely(strcmp("ersion", s + 5) == 0)) {
388		/* OSSL_CIPHER_PARAM_TLS_VERSION */
389	0	if (ossl_unlikely(r->tlsvers != NULL)) {
390	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
391	0	"param %s is repeated", s);
392	0	return 0;
393	0	}
394	0	r->tlsvers = (OSSL_PARAM *)p;
395	0	}
396	0	}
397	0	}
398	0	}
399	0	}
400	0	break;
401	0	case 'u':
402	0	if (ossl_likely(strcmp("se-bits", s + 1) == 0)) {
403		/* OSSL_CIPHER_PARAM_USE_BITS */
404	0	if (ossl_unlikely(r->bits != NULL)) {
405	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
406	0	"param %s is repeated", s);
407	0	return 0;
408	0	}
409	0	r->bits = (OSSL_PARAM *)p;
410	0	}
411	0	}
412	0	return 1;
413	0	}
414		#endif
415		/* End of machine generated */
416
417		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
418		#ifndef cipher_var_keylen_set_ctx_params_list
419		static const OSSL_PARAM cipher_var_keylen_set_ctx_params_list[] = {
420		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
421		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
422		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
423		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
424		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
425		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
426		OSSL_PARAM_END
427		};
428		#endif
429
430		#ifndef cipher_var_keylen_set_ctx_params_st
431		struct cipher_var_keylen_set_ctx_params_st {
432		OSSL_PARAM *bits;
433		OSSL_PARAM *keylen;
434		OSSL_PARAM *num;
435		OSSL_PARAM *pad;
436		OSSL_PARAM *tlsmacsize;
437		OSSL_PARAM *tlsvers;
438		};
439		#endif
440
441		#ifndef cipher_var_keylen_set_ctx_params_decoder
442		static int cipher_var_keylen_set_ctx_params_decoder
443		(const OSSL_PARAM p, struct cipher_var_keylen_set_ctx_params_st r)
444	0	{
445	0	const char *s;
446
447	0	memset(r, 0, sizeof(*r));
448	0	if (p != NULL)
449	0	for (; (s = p->key) != NULL; p++)
450	0	switch(s[0]) {
451	0	default:
452	0	break;
453	0	case 'k':
454	0	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
455		/* OSSL_CIPHER_PARAM_KEYLEN */
456	0	if (ossl_unlikely(r->keylen != NULL)) {
457	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
458	0	"param %s is repeated", s);
459	0	return 0;
460	0	}
461	0	r->keylen = (OSSL_PARAM *)p;
462	0	}
463	0	break;
464	0	case 'n':
465	0	if (ossl_likely(strcmp("um", s + 1) == 0)) {
466		/* OSSL_CIPHER_PARAM_NUM */
467	0	if (ossl_unlikely(r->num != NULL)) {
468	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
469	0	"param %s is repeated", s);
470	0	return 0;
471	0	}
472	0	r->num = (OSSL_PARAM *)p;
473	0	}
474	0	break;
475	0	case 'p':
476	0	if (ossl_likely(strcmp("adding", s + 1) == 0)) {
477		/* OSSL_CIPHER_PARAM_PADDING */
478	0	if (ossl_unlikely(r->pad != NULL)) {
479	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
480	0	"param %s is repeated", s);
481	0	return 0;
482	0	}
483	0	r->pad = (OSSL_PARAM *)p;
484	0	}
485	0	break;
486	0	case 't':
487	0	switch(s[1]) {
488	0	default:
489	0	break;
490	0	case 'l':
491	0	switch(s[2]) {
492	0	default:
493	0	break;
494	0	case 's':
495	0	switch(s[3]) {
496	0	default:
497	0	break;
498	0	case '-':
499	0	switch(s[4]) {
500	0	default:
501	0	break;
502	0	case 'm':
503	0	if (ossl_likely(strcmp("ac-size", s + 5) == 0)) {
504		/* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
505	0	if (ossl_unlikely(r->tlsmacsize != NULL)) {
506	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
507	0	"param %s is repeated", s);
508	0	return 0;
509	0	}
510	0	r->tlsmacsize = (OSSL_PARAM *)p;
511	0	}
512	0	break;
513	0	case 'v':
514	0	if (ossl_likely(strcmp("ersion", s + 5) == 0)) {
515		/* OSSL_CIPHER_PARAM_TLS_VERSION */
516	0	if (ossl_unlikely(r->tlsvers != NULL)) {
517	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
518	0	"param %s is repeated", s);
519	0	return 0;
520	0	}
521	0	r->tlsvers = (OSSL_PARAM *)p;
522	0	}
523	0	}
524	0	}
525	0	}
526	0	}
527	0	break;
528	0	case 'u':
529	0	if (ossl_likely(strcmp("se-bits", s + 1) == 0)) {
530		/* OSSL_CIPHER_PARAM_USE_BITS */
531	0	if (ossl_unlikely(r->bits != NULL)) {
532	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
533	0	"param %s is repeated", s);
534	0	return 0;
535	0	}
536	0	r->bits = (OSSL_PARAM *)p;
537	0	}
538	0	}
539	0	return 1;
540	0	}
541		#endif
542		/* End of machine generated */