/src/openssl/providers/implementations/ciphers/cipher_rc2.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 rc2_get_ctx_params_list
static ossl_unused const OSSL_PARAM rc2_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_size_t(OSSL_CIPHER_PARAM_RC2_KEYBITS, NULL),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef rc2_get_ctx_params_st
struct rc2_get_ctx_params_st {
    OSSL_PARAM *algid;
    OSSL_PARAM *bits;
    OSSL_PARAM *common.iv;
    OSSL_PARAM *common.ivlen;
    OSSL_PARAM *common.keylen;
    OSSL_PARAM *common.num;
    OSSL_PARAM *common.pad;
    OSSL_PARAM *common.updiv;
    OSSL_PARAM *oldid;
};
#endif

#ifndef rc2_get_ctx_params_decoder
static ossl_unused int rc2_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct rc2_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 'a':
                switch(s[1]) {
                default:
                    break;
                case 'l':
                    switch(s[2]) {
                    default:
                        break;
                    case 'g':
                        switch(s[3]) {
                        default:
                            break;
                        case '_':
                            if (ossl_likely(strcmp("id_param", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD */
                                if (ossl_unlikely(r->oldid != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->oldid = (OSSL_PARAM *)p;
                            }
                            break;
                        case 'o':
                            if (ossl_likely(strcmp("rithm-id-params", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS */
                                if (ossl_unlikely(r->algid != NULL)) {
                                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                   "param %s is repeated", s);
                                    return 0;
                                }
                                r->algid = (OSSL_PARAM *)p;
                            }
                        }
                    }
                }
                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':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 'y':
                        switch(s[3]) {
                        default:
                            break;
                        case 'b':
                            if (ossl_likely(strcmp("its", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_RC2_KEYBITS */
                                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;
                            }
                            break;
                        case 'l':
                            if (ossl_likely(strcmp("en", s + 4) == 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 '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 rc2_set_ctx_params_list
static ossl_unused const OSSL_PARAM rc2_set_ctx_params_list[] = {
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
    OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
    OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_RC2_KEYBITS, NULL),
    OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef rc2_set_ctx_params_st
struct rc2_set_ctx_params_st {
    OSSL_PARAM *algid;
    OSSL_PARAM *bits;
    OSSL_PARAM *common.keylen;
    OSSL_PARAM *common.num;
    OSSL_PARAM *common.pad;
};
#endif

#ifndef rc2_set_ctx_params_decoder
static ossl_unused int rc2_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct rc2_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 'a':
                if (ossl_likely(strcmp("lgorithm-id-params", s + 1) == 0)) {
                    /* OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS */
                    if (ossl_unlikely(r->algid != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->algid = (OSSL_PARAM *)p;
                }
                break;
            case 'k':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 'y':
                        switch(s[3]) {
                        default:
                            break;
                        case 'b':
                            if (ossl_likely(strcmp("its", s + 4) == 0)) {
                                /* OSSL_CIPHER_PARAM_RC2_KEYBITS */
                                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;
                            }
                            break;
                        case 'l':
                            if (ossl_likely(strcmp("en", s + 4) == 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;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2026-09-13 06:13

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 rc2_get_ctx_params_list
21		static ossl_unused const OSSL_PARAM rc2_get_ctx_params_list[] = {
22		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
23		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_IVLEN, NULL),
24		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
25		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
26		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_IV, NULL, 0),
27		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_UPDATED_IV, NULL, 0),
28		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_RC2_KEYBITS, NULL),
29		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS, NULL, 0),
30		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD, NULL, 0),
31		OSSL_PARAM_END
32		};
33		#endif
34
35		#ifndef rc2_get_ctx_params_st
36		struct rc2_get_ctx_params_st {
37		OSSL_PARAM *algid;
38		OSSL_PARAM *bits;
39		OSSL_PARAM *common.iv;
40		OSSL_PARAM *common.ivlen;
41		OSSL_PARAM *common.keylen;
42		OSSL_PARAM *common.num;
43		OSSL_PARAM *common.pad;
44		OSSL_PARAM *common.updiv;
45		OSSL_PARAM *oldid;
46		};
47		#endif
48
49		#ifndef rc2_get_ctx_params_decoder
50		static ossl_unused int rc2_get_ctx_params_decoder
51		(const OSSL_PARAM p, struct rc2_get_ctx_params_st r)
52	0	{
53	0	const char *s;
54
55	0	memset(r, 0, sizeof(*r));
56	0	if (p != NULL)
57	0	for (; (s = p->key) != NULL; p++)
58	0	switch(s[0]) {
59	0	default:
60	0	break;
61	0	case 'a':
62	0	switch(s[1]) {
63	0	default:
64	0	break;
65	0	case 'l':
66	0	switch(s[2]) {
67	0	default:
68	0	break;
69	0	case 'g':
70	0	switch(s[3]) {
71	0	default:
72	0	break;
73	0	case '_':
74	0	if (ossl_likely(strcmp("id_param", s + 4) == 0)) {
75		/* OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS_OLD */
76	0	if (ossl_unlikely(r->oldid != NULL)) {
77	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
78	0	"param %s is repeated", s);
79	0	return 0;
80	0	}
81	0	r->oldid = (OSSL_PARAM *)p;
82	0	}
83	0	break;
84	0	case 'o':
85	0	if (ossl_likely(strcmp("rithm-id-params", s + 4) == 0)) {
86		/* OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS */
87	0	if (ossl_unlikely(r->algid != NULL)) {
88	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
89	0	"param %s is repeated", s);
90	0	return 0;
91	0	}
92	0	r->algid = (OSSL_PARAM *)p;
93	0	}
94	0	}
95	0	}
96	0	}
97	0	break;
98	0	case 'i':
99	0	switch(s[1]) {
100	0	default:
101	0	break;
102	0	case 'v':
103	0	switch(s[2]) {
104	0	default:
105	0	break;
106	0	case 'l':
107	0	if (ossl_likely(strcmp("en", s + 3) == 0)) {
108		/* OSSL_CIPHER_PARAM_IVLEN */
109	0	if (ossl_unlikely(r->common.ivlen != NULL)) {
110	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
111	0	"param %s is repeated", s);
112	0	return 0;
113	0	}
114	0	r->common.ivlen = (OSSL_PARAM *)p;
115	0	}
116	0	break;
117	0	case '\0':
118	0	if (ossl_unlikely(r->common.iv != NULL)) {
119	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
120	0	"param %s is repeated", s);
121	0	return 0;
122	0	}
123	0	r->common.iv = (OSSL_PARAM *)p;
124	0	}
125	0	}
126	0	break;
127	0	case 'k':
128	0	switch(s[1]) {
129	0	default:
130	0	break;
131	0	case 'e':
132	0	switch(s[2]) {
133	0	default:
134	0	break;
135	0	case 'y':
136	0	switch(s[3]) {
137	0	default:
138	0	break;
139	0	case 'b':
140	0	if (ossl_likely(strcmp("its", s + 4) == 0)) {
141		/* OSSL_CIPHER_PARAM_RC2_KEYBITS */
142	0	if (ossl_unlikely(r->bits != NULL)) {
143	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
144	0	"param %s is repeated", s);
145	0	return 0;
146	0	}
147	0	r->bits = (OSSL_PARAM *)p;
148	0	}
149	0	break;
150	0	case 'l':
151	0	if (ossl_likely(strcmp("en", s + 4) == 0)) {
152		/* OSSL_CIPHER_PARAM_KEYLEN */
153	0	if (ossl_unlikely(r->common.keylen != NULL)) {
154	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
155	0	"param %s is repeated", s);
156	0	return 0;
157	0	}
158	0	r->common.keylen = (OSSL_PARAM *)p;
159	0	}
160	0	}
161	0	}
162	0	}
163	0	break;
164	0	case 'n':
165	0	if (ossl_likely(strcmp("um", s + 1) == 0)) {
166		/* OSSL_CIPHER_PARAM_NUM */
167	0	if (ossl_unlikely(r->common.num != NULL)) {
168	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
169	0	"param %s is repeated", s);
170	0	return 0;
171	0	}
172	0	r->common.num = (OSSL_PARAM *)p;
173	0	}
174	0	break;
175	0	case 'p':
176	0	if (ossl_likely(strcmp("adding", s + 1) == 0)) {
177		/* OSSL_CIPHER_PARAM_PADDING */
178	0	if (ossl_unlikely(r->common.pad != NULL)) {
179	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
180	0	"param %s is repeated", s);
181	0	return 0;
182	0	}
183	0	r->common.pad = (OSSL_PARAM *)p;
184	0	}
185	0	break;
186	0	case 'u':
187	0	if (ossl_likely(strcmp("pdated-iv", s + 1) == 0)) {
188		/* OSSL_CIPHER_PARAM_UPDATED_IV */
189	0	if (ossl_unlikely(r->common.updiv != NULL)) {
190	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
191	0	"param %s is repeated", s);
192	0	return 0;
193	0	}
194	0	r->common.updiv = (OSSL_PARAM *)p;
195	0	}
196	0	}
197	0	return 1;
198	0	}
199		#endif
200		/* End of machine generated */
201
202		/* Machine generated */
203		#ifndef rc2_set_ctx_params_list
204		static ossl_unused const OSSL_PARAM rc2_set_ctx_params_list[] = {
205		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_PADDING, NULL),
206		OSSL_PARAM_uint(OSSL_CIPHER_PARAM_NUM, NULL),
207		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_KEYLEN, NULL),
208		OSSL_PARAM_size_t(OSSL_CIPHER_PARAM_RC2_KEYBITS, NULL),
209		OSSL_PARAM_octet_string(OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS, NULL, 0),
210		OSSL_PARAM_END
211		};
212		#endif
213
214		#ifndef rc2_set_ctx_params_st
215		struct rc2_set_ctx_params_st {
216		OSSL_PARAM *algid;
217		OSSL_PARAM *bits;
218		OSSL_PARAM *common.keylen;
219		OSSL_PARAM *common.num;
220		OSSL_PARAM *common.pad;
221		};
222		#endif
223
224		#ifndef rc2_set_ctx_params_decoder
225		static ossl_unused int rc2_set_ctx_params_decoder
226		(const OSSL_PARAM p, struct rc2_set_ctx_params_st r)
227	0	{
228	0	const char *s;
229
230	0	memset(r, 0, sizeof(*r));
231	0	if (p != NULL)
232	0	for (; (s = p->key) != NULL; p++)
233	0	switch(s[0]) {
234	0	default:
235	0	break;
236	0	case 'a':
237	0	if (ossl_likely(strcmp("lgorithm-id-params", s + 1) == 0)) {
238		/* OSSL_CIPHER_PARAM_ALGORITHM_ID_PARAMS */
239	0	if (ossl_unlikely(r->algid != NULL)) {
240	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
241	0	"param %s is repeated", s);
242	0	return 0;
243	0	}
244	0	r->algid = (OSSL_PARAM *)p;
245	0	}
246	0	break;
247	0	case 'k':
248	0	switch(s[1]) {
249	0	default:
250	0	break;
251	0	case 'e':
252	0	switch(s[2]) {
253	0	default:
254	0	break;
255	0	case 'y':
256	0	switch(s[3]) {
257	0	default:
258	0	break;
259	0	case 'b':
260	0	if (ossl_likely(strcmp("its", s + 4) == 0)) {
261		/* OSSL_CIPHER_PARAM_RC2_KEYBITS */
262	0	if (ossl_unlikely(r->bits != NULL)) {
263	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
264	0	"param %s is repeated", s);
265	0	return 0;
266	0	}
267	0	r->bits = (OSSL_PARAM *)p;
268	0	}
269	0	break;
270	0	case 'l':
271	0	if (ossl_likely(strcmp("en", s + 4) == 0)) {
272		/* OSSL_CIPHER_PARAM_KEYLEN */
273	0	if (ossl_unlikely(r->common.keylen != NULL)) {
274	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
275	0	"param %s is repeated", s);
276	0	return 0;
277	0	}
278	0	r->common.keylen = (OSSL_PARAM *)p;
279	0	}
280	0	}
281	0	}
282	0	}
283	0	break;
284	0	case 'n':
285	0	if (ossl_likely(strcmp("um", s + 1) == 0)) {
286		/* OSSL_CIPHER_PARAM_NUM */
287	0	if (ossl_unlikely(r->common.num != 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->common.num = (OSSL_PARAM *)p;
293	0	}
294	0	break;
295	0	case 'p':
296	0	if (ossl_likely(strcmp("adding", s + 1) == 0)) {
297		/* OSSL_CIPHER_PARAM_PADDING */
298	0	if (ossl_unlikely(r->common.pad != 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->common.pad = (OSSL_PARAM *)p;
304	0	}
305	0	}
306	0	return 1;
307	0	}
308		#endif
309		/* End of machine generated */