/src/openssl/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),
# 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 */
#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-10-16 07:31

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