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

Source
/*
 * Copyright 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 tdes_get_params_list
static ossl_unused const OSSL_PARAM tdes_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_CUSTOM_IV, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_HAS_RAND_KEY, NULL),
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_DECRYPT_ONLY, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef tdes_get_params_st
struct tdes_get_params_st {
    OSSL_PARAM *common.bsize;
    OSSL_PARAM *common.custiv;
    OSSL_PARAM *common.ivlen;
    OSSL_PARAM *common.keylen;
    OSSL_PARAM *common.mode;
    OSSL_PARAM *common.rand;
    OSSL_PARAM *decrypt;
};
#endif

#ifndef tdes_get_params_decoder
static ossl_unused int tdes_get_params_decoder
    (const OSSL_PARAM *p, struct tdes_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 'b':
                if (ossl_likely(strcmp("locksize", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_BLOCK_SIZE */
                    if (ossl_unlikely(r->common.bsize != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.bsize = (OSSL_PARAM *)p;
                }
                break;
            case 'c':
                if (ossl_likely(strcmp("ustom-iv", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_CUSTOM_IV */
                    if (ossl_unlikely(r->common.custiv != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.custiv = (OSSL_PARAM *)p;
                }
                break;
            case 'd':
                if (ossl_likely(strcmp("ecrypt-only", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_DECRYPT_ONLY */
                    if (ossl_unlikely(r->decrypt != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->decrypt = (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->common.rand != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.rand = (OSSL_PARAM *)p;
                }
                break;
            case 'i':
                if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_IVLEN */
                    if (ossl_unlikely(r->common.ivlen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.ivlen = (OSSL_PARAM *)p;
                }
                break;
            case 'k':
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_KEYLEN */
                    if (ossl_unlikely(r->common.keylen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.keylen = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                if (ossl_likely(strcmp("ode", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_MODE */
                    if (ossl_unlikely(r->common.mode != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.mode = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

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

#ifndef tdes_get_ctx_params_st
struct tdes_get_ctx_params_st {
    OSSL_PARAM *common.iv;
    OSSL_PARAM *common.ivlen;
    OSSL_PARAM *common.keylen;
    OSSL_PARAM *common.num;
    OSSL_PARAM *common.pad;
    OSSL_PARAM *common.tlsmac;
    OSSL_PARAM *common.updiv;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
    OSSL_PARAM *rand;
};
#endif

#ifndef tdes_get_ctx_params_decoder
static ossl_unused int tdes_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct tdes_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_unlikely(r->ind != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ind = (OSSL_PARAM *)p;
                }
# 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->common.ivlen != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->common.ivlen = (OSSL_PARAM *)p;
                        }
                        break;
                    case '\0':
                        if (ossl_unlikely(r->common.iv != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->common.iv = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 'k':
                if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_KEYLEN */
                    if (ossl_unlikely(r->common.keylen != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.keylen = (OSSL_PARAM *)p;
                }
                break;
            case 'n':
                if (ossl_likely(strcmp("um", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_NUM */
                    if (ossl_unlikely(r->common.num != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.num = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("adding", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_PADDING */
                    if (ossl_unlikely(r->common.pad != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.pad = (OSSL_PARAM *)p;
                }
                break;
            case 'r':
                if (ossl_likely(strcmp("andkey", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_RANDOM_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 't':
                if (ossl_likely(strcmp("ls-mac", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_TLS_MAC */
                    if (ossl_unlikely(r->common.tlsmac != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.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->common.updiv != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.updiv = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef tdes_set_ctx_params_list
static ossl_unused const OSSL_PARAM tdes_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),
# if defined(FIPS_MODULE)
    OSSL_PARAM_int(OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK, NULL),
# endif
    OSSL_PARAM_END
};
#endif

#ifndef tdes_set_ctx_params_st
struct tdes_set_ctx_params_st {
    OSSL_PARAM *common.bits;
    OSSL_PARAM *common.num;
    OSSL_PARAM *common.pad;
    OSSL_PARAM *common.tlsmacsize;
    OSSL_PARAM *common.tlsvers;
# if defined(FIPS_MODULE)
    OSSL_PARAM *ind;
# endif
};
#endif

#ifndef tdes_set_ctx_params_decoder
static ossl_unused int tdes_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct tdes_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 'e':
# if defined(FIPS_MODULE)
                if (ossl_likely(strcmp("ncrypt-check", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK */
                    if (ossl_unlikely(r->ind != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ind = (OSSL_PARAM *)p;
                }
# endif
                break;
            case 'n':
                if (ossl_likely(strcmp("um", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_NUM */
                    if (ossl_unlikely(r->common.num != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.num = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("adding", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_PADDING */
                    if (ossl_unlikely(r->common.pad != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.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->common.tlsmacsize != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->common.tlsmacsize = (OSSL_PARAM *)p;
                                }
                                break;
                            case 'v':
                                if (ossl_likely(strcmp("ersion", s + 5) == 0)) {
                                    /* OSSL_CIPHER_PARAM_TLS_VERSION */
                                    if (ossl_unlikely(r->common.tlsvers != NULL)) {
                                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                       "param %s is repeated", s);
                                        return 0;
                                    }
                                    r->common.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->common.bits != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->common.bits = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2026-09-12 06:55

Line	Count	Source
1		/*
2		* Copyright 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 tdes_get_params_list
21		static ossl_unused const OSSL_PARAM tdes_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_CUSTOM_IV, NULL),
27		OSSL_PARAM_int(OSSL_CIPHER_PARAM_HAS_RAND_KEY, NULL),
28		OSSL_PARAM_int(OSSL_CIPHER_PARAM_DECRYPT_ONLY, NULL),
29		OSSL_PARAM_END
30		};
31		#endif
32
33		#ifndef tdes_get_params_st
34		struct tdes_get_params_st {
35		OSSL_PARAM *common.bsize;
36		OSSL_PARAM *common.custiv;
37		OSSL_PARAM *common.ivlen;
38		OSSL_PARAM *common.keylen;
39		OSSL_PARAM *common.mode;
40		OSSL_PARAM *common.rand;
41		OSSL_PARAM *decrypt;
42		};
43		#endif
44
45		#ifndef tdes_get_params_decoder
46		static ossl_unused int tdes_get_params_decoder
47		(const OSSL_PARAM p, struct tdes_get_params_st r)
48	29.1k	{
49	29.1k	const char *s;
50
51	29.1k	memset(r, 0, sizeof(*r));
52	29.1k	if (p != NULL)
53	59.8k	for (; (s = p->key) != NULL; p++)
54	30.6k	switch(s[0]) {
55	510	default:
56	510	break;
57	510	case 'b':
58	170	if (ossl_likely(strcmp("locksize", s + 1) == 0)) {
59		/* OSSL_CIPHER_PARAM_BLOCK_SIZE */
60	170	if (ossl_unlikely(r->common.bsize != NULL)) {
61	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
62	0	"param %s is repeated", s);
63	0	return 0;
64	0	}
65	170	r->common.bsize = (OSSL_PARAM *)p;
66	170	}
67	170	break;
68	340	case 'c':
69	340	if (ossl_likely(strcmp("ustom-iv", s + 1) == 0)) {
70		/* OSSL_CIPHER_PARAM_CUSTOM_IV */
71	170	if (ossl_unlikely(r->common.custiv != NULL)) {
72	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
73	0	"param %s is repeated", s);
74	0	return 0;
75	0	}
76	170	r->common.custiv = (OSSL_PARAM *)p;
77	170	}
78	340	break;
79	28.9k	case 'd':
80	28.9k	if (ossl_likely(strcmp("ecrypt-only", s + 1) == 0)) {
81		/* OSSL_CIPHER_PARAM_DECRYPT_ONLY */
82	28.9k	if (ossl_unlikely(r->decrypt != NULL)) {
83	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
84	0	"param %s is repeated", s);
85	0	return 0;
86	0	}
87	28.9k	r->decrypt = (OSSL_PARAM *)p;
88	28.9k	}
89	28.9k	break;
90	28.9k	case 'h':
91	170	if (ossl_likely(strcmp("as-randkey", s + 1) == 0)) {
92		/* OSSL_CIPHER_PARAM_HAS_RAND_KEY */
93	170	if (ossl_unlikely(r->common.rand != NULL)) {
94	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
95	0	"param %s is repeated", s);
96	0	return 0;
97	0	}
98	170	r->common.rand = (OSSL_PARAM *)p;
99	170	}
100	170	break;
101	170	case 'i':
102	170	if (ossl_likely(strcmp("vlen", s + 1) == 0)) {
103		/* OSSL_CIPHER_PARAM_IVLEN */
104	170	if (ossl_unlikely(r->common.ivlen != NULL)) {
105	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
106	0	"param %s is repeated", s);
107	0	return 0;
108	0	}
109	170	r->common.ivlen = (OSSL_PARAM *)p;
110	170	}
111	170	break;
112	170	case 'k':
113	170	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
114		/* OSSL_CIPHER_PARAM_KEYLEN */
115	170	if (ossl_unlikely(r->common.keylen != 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	170	r->common.keylen = (OSSL_PARAM *)p;
121	170	}
122	170	break;
123	170	case 'm':
124	170	if (ossl_likely(strcmp("ode", s + 1) == 0)) {
125		/* OSSL_CIPHER_PARAM_MODE */
126	170	if (ossl_unlikely(r->common.mode != 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	170	r->common.mode = (OSSL_PARAM *)p;
132	170	}
133	30.6k	}
134	29.1k	return 1;
135	29.1k	}
136		#endif
137		/* End of machine generated */
138
139		/* Machine generated */
140		#ifndef tdes_get_ctx_params_list
141		static ossl_unused const OSSL_PARAM tdes_get_ctx_params_list[] = {
142		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
143		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
144		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
145		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
146		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
147		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
148		OSSL_PARAM_octet_ptr(OSSL_CIPHER_PARAM_TLS_MAC, NULL, 0),
149		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_RANDOM_KEY, NULL, 0),
150		# if defined(FIPS_MODULE)
151		OSSL_PARAM_int(OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR, NULL),
152		# endif
153		OSSL_PARAM_END
154		};
155		#endif
156
157		#ifndef tdes_get_ctx_params_st
158		struct tdes_get_ctx_params_st {
159		OSSL_PARAM *common.iv;
160		OSSL_PARAM *common.ivlen;
161		OSSL_PARAM *common.keylen;
162		OSSL_PARAM *common.num;
163		OSSL_PARAM *common.pad;
164		OSSL_PARAM *common.tlsmac;
165		OSSL_PARAM *common.updiv;
166		# if defined(FIPS_MODULE)
167		OSSL_PARAM *ind;
168		# endif
169		OSSL_PARAM *rand;
170		};
171		#endif
172
173		#ifndef tdes_get_ctx_params_decoder
174		static ossl_unused int tdes_get_ctx_params_decoder
175		(const OSSL_PARAM p, struct tdes_get_ctx_params_st r)
176	30.4k	{
177	30.4k	const char *s;
178
179	30.4k	memset(r, 0, sizeof(*r));
180	30.4k	if (p != NULL)
181	60.9k	for (; (s = p->key) != NULL; p++)
182	30.4k	switch(s[0]) {
183	0	default:
184	0	break;
185	0	case 'f':
186		# if defined(FIPS_MODULE)
187		if (ossl_likely(strcmp("ips-indicator", s + 1) == 0)) {
188		/* OSSL_CIPHER_PARAM_FIPS_APPROVED_INDICATOR */
189		if (ossl_unlikely(r->ind != NULL)) {
190		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
191		"param %s is repeated", s);
192		return 0;
193		}
194		r->ind = (OSSL_PARAM *)p;
195		}
196		# endif
197	0	break;
198	962	case 'i':
199	962	switch(s[1]) {
200	0	default:
201	0	break;
202	962	case 'v':
203	962	switch(s[2]) {
204	0	default:
205	0	break;
206	962	case 'l':
207	962	if (ossl_likely(strcmp("en", s + 3) == 0)) {
208		/* OSSL_CIPHER_PARAM_IVLEN */
209	962	if (ossl_unlikely(r->common.ivlen != NULL)) {
210	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
211	0	"param %s is repeated", s);
212	0	return 0;
213	0	}
214	962	r->common.ivlen = (OSSL_PARAM *)p;
215	962	}
216	962	break;
217	962	case '\0':
218	0	if (ossl_unlikely(r->common.iv != NULL)) {
219	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
220	0	"param %s is repeated", s);
221	0	return 0;
222	0	}
223	0	r->common.iv = (OSSL_PARAM *)p;
224	962	}
225	962	}
226	962	break;
227	972	case 'k':
228	972	if (ossl_likely(strcmp("eylen", s + 1) == 0)) {
229		/* OSSL_CIPHER_PARAM_KEYLEN */
230	972	if (ossl_unlikely(r->common.keylen != NULL)) {
231	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
232	0	"param %s is repeated", s);
233	0	return 0;
234	0	}
235	972	r->common.keylen = (OSSL_PARAM *)p;
236	972	}
237	972	break;
238	972	case 'n':
239	0	if (ossl_likely(strcmp("um", s + 1) == 0)) {
240		/* OSSL_CIPHER_PARAM_NUM */
241	0	if (ossl_unlikely(r->common.num != NULL)) {
242	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
243	0	"param %s is repeated", s);
244	0	return 0;
245	0	}
246	0	r->common.num = (OSSL_PARAM *)p;
247	0	}
248	0	break;
249	0	case 'p':
250	0	if (ossl_likely(strcmp("adding", s + 1) == 0)) {
251		/* OSSL_CIPHER_PARAM_PADDING */
252	0	if (ossl_unlikely(r->common.pad != NULL)) {
253	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
254	0	"param %s is repeated", s);
255	0	return 0;
256	0	}
257	0	r->common.pad = (OSSL_PARAM *)p;
258	0	}
259	0	break;
260	0	case 'r':
261	0	if (ossl_likely(strcmp("andkey", s + 1) == 0)) {
262		/* OSSL_CIPHER_PARAM_RANDOM_KEY */
263	0	if (ossl_unlikely(r->rand != NULL)) {
264	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
265	0	"param %s is repeated", s);
266	0	return 0;
267	0	}
268	0	r->rand = (OSSL_PARAM *)p;
269	0	}
270	0	break;
271	28.5k	case 't':
272	28.5k	if (ossl_likely(strcmp("ls-mac", s + 1) == 0)) {
273		/* OSSL_CIPHER_PARAM_TLS_MAC */
274	28.5k	if (ossl_unlikely(r->common.tlsmac != NULL)) {
275	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
276	0	"param %s is repeated", s);
277	0	return 0;
278	0	}
279	28.5k	r->common.tlsmac = (OSSL_PARAM *)p;
280	28.5k	}
281	28.5k	break;
282	28.5k	case 'u':
283	0	if (ossl_likely(strcmp("pdated-iv", s + 1) == 0)) {
284		/* OSSL_CIPHER_PARAM_UPDATED_IV */
285	0	if (ossl_unlikely(r->common.updiv != NULL)) {
286	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
287	0	"param %s is repeated", s);
288	0	return 0;
289	0	}
290	0	r->common.updiv = (OSSL_PARAM *)p;
291	0	}
292	30.4k	}
293	30.4k	return 1;
294	30.4k	}
295		#endif
296		/* End of machine generated */
297
298		/* Machine generated */
299		#ifndef tdes_set_ctx_params_list
300		static ossl_unused const OSSL_PARAM tdes_set_ctx_params_list[] = {
301		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
302		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
303		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_USE_BITS, NULL),
304		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_TLS_VERSION, NULL),
305		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_TLS_MAC_SIZE, NULL),
306		# if defined(FIPS_MODULE)
307		OSSL_PARAM_int(OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK, NULL),
308		# endif
309		OSSL_PARAM_END
310		};
311		#endif
312
313		#ifndef tdes_set_ctx_params_st
314		struct tdes_set_ctx_params_st {
315		OSSL_PARAM *common.bits;
316		OSSL_PARAM *common.num;
317		OSSL_PARAM *common.pad;
318		OSSL_PARAM *common.tlsmacsize;
319		OSSL_PARAM *common.tlsvers;
320		# if defined(FIPS_MODULE)
321		OSSL_PARAM *ind;
322		# endif
323		};
324		#endif
325
326		#ifndef tdes_set_ctx_params_decoder
327		static ossl_unused int tdes_set_ctx_params_decoder
328		(const OSSL_PARAM p, struct tdes_set_ctx_params_st r)
329	2.08k	{
330	2.08k	const char *s;
331
332	2.08k	memset(r, 0, sizeof(*r));
333	2.08k	if (p != NULL)
334	2.72k	for (; (s = p->key) != NULL; p++)
335	1.83k	switch(s[0]) {
336	0	default:
337	0	break;
338	0	case 'e':
339		# if defined(FIPS_MODULE)
340		if (ossl_likely(strcmp("ncrypt-check", s + 1) == 0)) {
341		/* OSSL_CIPHER_PARAM_FIPS_ENCRYPT_CHECK */
342		if (ossl_unlikely(r->ind != NULL)) {
343		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
344		"param %s is repeated", s);
345		return 0;
346		}
347		r->ind = (OSSL_PARAM *)p;
348		}
349		# endif
350	0	break;
351	17	case 'n':
352	17	if (ossl_likely(strcmp("um", s + 1) == 0)) {
353		/* OSSL_CIPHER_PARAM_NUM */
354	17	if (ossl_unlikely(r->common.num != NULL)) {
355	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
356	0	"param %s is repeated", s);
357	0	return 0;
358	0	}
359	17	r->common.num = (OSSL_PARAM *)p;
360	17	}
361	17	break;
362	17	case 'p':
363	17	if (ossl_likely(strcmp("adding", s + 1) == 0)) {
364		/* OSSL_CIPHER_PARAM_PADDING */
365	17	if (ossl_unlikely(r->common.pad != NULL)) {
366	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
367	0	"param %s is repeated", s);
368	0	return 0;
369	0	}
370	17	r->common.pad = (OSSL_PARAM *)p;
371	17	}
372	17	break;
373	1.78k	case 't':
374	1.78k	switch(s[1]) {
375	0	default:
376	0	break;
377	1.78k	case 'l':
378	1.78k	switch(s[2]) {
379	0	default:
380	0	break;
381	1.78k	case 's':
382	1.78k	switch(s[3]) {
383	0	default:
384	0	break;
385	1.78k	case '-':
386	1.78k	switch(s[4]) {
387	0	default:
388	0	break;
389	891	case 'm':
390	891	if (ossl_likely(strcmp("ac-size", s + 5) == 0)) {
391		/* OSSL_CIPHER_PARAM_TLS_MAC_SIZE */
392	891	if (ossl_unlikely(r->common.tlsmacsize != NULL)) {
393	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
394	0	"param %s is repeated", s);
395	0	return 0;
396	0	}
397	891	r->common.tlsmacsize = (OSSL_PARAM *)p;
398	891	}
399	891	break;
400	891	case 'v':
401	891	if (ossl_likely(strcmp("ersion", s + 5) == 0)) {
402		/* OSSL_CIPHER_PARAM_TLS_VERSION */
403	891	if (ossl_unlikely(r->common.tlsvers != NULL)) {
404	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
405	0	"param %s is repeated", s);
406	0	return 0;
407	0	}
408	891	r->common.tlsvers = (OSSL_PARAM *)p;
409	891	}
410	1.78k	}
411	1.78k	}
412	1.78k	}
413	1.78k	}
414	1.78k	break;
415	1.78k	case 'u':
416	17	if (ossl_likely(strcmp("se-bits", s + 1) == 0)) {
417		/* OSSL_CIPHER_PARAM_USE_BITS */
418	17	if (ossl_unlikely(r->common.bits != NULL)) {
419	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
420	0	"param %s is repeated", s);
421	0	return 0;
422	0	}
423	17	r->common.bits = (OSSL_PARAM *)p;
424	17	}
425	1.83k	}
426	2.08k	return 1;
427	2.08k	}
428		#endif
429		/* End of machine generated */