/src/openssl40/providers/implementations/keymgmt/mlx_kmgmt.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 ml_kem_import_export_list
static const OSSL_PARAM ml_kem_import_export_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ml_kem_import_export_st
struct ml_kem_import_export_st {
    OSSL_PARAM *privkey;
    OSSL_PARAM *pubkey;
};
#endif

#ifndef ml_kem_import_export_decoder
static int ml_kem_import_export_decoder
    (const OSSL_PARAM *p, struct ml_kem_import_export_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 'p':
                switch(s[1]) {
                default:
                    break;
                case 'r':
                    if (ossl_likely(strcmp("iv", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PRIV_KEY */
                        if (ossl_unlikely(r->privkey != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->privkey = (OSSL_PARAM *)p;
                    }
                    break;
                case 'u':
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PUB_KEY */
                        if (ossl_unlikely(r->pubkey != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->pubkey = (OSSL_PARAM *)p;
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef mlx_get_params_list
static const OSSL_PARAM mlx_get_params_list[] = {
    OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
    OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
    OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef mlx_get_params_st
struct mlx_get_params_st {
    OSSL_PARAM *bits;
    OSSL_PARAM *maxsize;
    OSSL_PARAM *priv;
    OSSL_PARAM *pub;
    OSSL_PARAM *secbits;
    OSSL_PARAM *seccat;
};
#endif

#ifndef mlx_get_params_decoder
static int mlx_get_params_decoder
    (const OSSL_PARAM *p, struct mlx_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("its", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_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;
                }
                break;
            case 'e':
                if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
                    if (ossl_unlikely(r->pub != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->pub = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                if (ossl_likely(strcmp("ax-size", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_MAX_SIZE */
                    if (ossl_unlikely(r->maxsize != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->maxsize = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("riv", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_PRIV_KEY */
                    if (ossl_unlikely(r->priv != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->priv = (OSSL_PARAM *)p;
                }
                break;
            case 's':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    switch(s[2]) {
                    default:
                        break;
                    case 'c':
                        switch(s[3]) {
                        default:
                            break;
                        case 'u':
                            switch(s[4]) {
                            default:
                                break;
                            case 'r':
                                switch(s[5]) {
                                default:
                                    break;
                                case 'i':
                                    switch(s[6]) {
                                    default:
                                        break;
                                    case 't':
                                        switch(s[7]) {
                                        default:
                                            break;
                                        case 'y':
                                            switch(s[8]) {
                                            default:
                                                break;
                                            case '-':
                                                switch(s[9]) {
                                                default:
                                                    break;
                                                case 'b':
                                                    if (ossl_likely(strcmp("its", s + 10) == 0)) {
                                                        /* OSSL_PKEY_PARAM_SECURITY_BITS */
                                                        if (ossl_unlikely(r->secbits != NULL)) {
                                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                           "param %s is repeated", s);
                                                            return 0;
                                                        }
                                                        r->secbits = (OSSL_PARAM *)p;
                                                    }
                                                    break;
                                                case 'c':
                                                    if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
                                                        /* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
                                                        if (ossl_unlikely(r->seccat != NULL)) {
                                                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                                                           "param %s is repeated", s);
                                                            return 0;
                                                        }
                                                        r->seccat = (OSSL_PARAM *)p;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef mlx_set_params_list
static const OSSL_PARAM mlx_set_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef mlx_set_params_st
struct mlx_set_params_st {
    OSSL_PARAM *propq;
    OSSL_PARAM *pub;
};
#endif

#ifndef mlx_set_params_decoder
static int mlx_set_params_decoder
    (const OSSL_PARAM *p, struct mlx_set_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 (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
                    if (ossl_unlikely(r->pub != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->pub = (OSSL_PARAM *)p;
                }
                break;
            case 'p':
                if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_PROPERTIES */
                    if (ossl_unlikely(r->propq != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->propq = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef mlx_gen_set_params_list
static const OSSL_PARAM mlx_gen_set_params_list[] = {
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef mlx_gen_set_params_st
struct mlx_gen_set_params_st {
    OSSL_PARAM *propq;
};
#endif

#ifndef mlx_gen_set_params_decoder
static int mlx_gen_set_params_decoder
    (const OSSL_PARAM *p, struct mlx_gen_set_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            if (ossl_likely(strcmp("properties", s + 0) == 0)) {
                /* OSSL_PKEY_PARAM_PROPERTIES */
                if (ossl_unlikely(r->propq != NULL)) {
                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                   "param %s is repeated", s);
                    return 0;
                }
                r->propq = (OSSL_PARAM *)p;
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2026-09-12 06:55

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 ml_kem_import_export_list
14		static const OSSL_PARAM ml_kem_import_export_list[] = {
15		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
16		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
17		OSSL_PARAM_END
18		};
19		#endif
20
21		#ifndef ml_kem_import_export_st
22		struct ml_kem_import_export_st {
23		OSSL_PARAM *privkey;
24		OSSL_PARAM *pubkey;
25		};
26		#endif
27
28		#ifndef ml_kem_import_export_decoder
29		static int ml_kem_import_export_decoder
30		(const OSSL_PARAM p, struct ml_kem_import_export_st r)
31	97.2k	{
32	97.2k	const char *s;
33
34	97.2k	memset(r, 0, sizeof(*r));
35	97.2k	if (p != NULL)
36	194k	for (; (s = p->key) != NULL; p++)
37	97.2k	switch(s[0]) {
38	9	default:
39	9	break;
40	97.2k	case 'p':
41	97.2k	switch(s[1]) {
42	3	default:
43	3	break;
44	3	case 'r':
45	0	if (ossl_likely(strcmp("iv", s + 2) == 0)) {
46		/* OSSL_PKEY_PARAM_PRIV_KEY */
47	0	if (ossl_unlikely(r->privkey != NULL)) {
48	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
49	0	"param %s is repeated", s);
50	0	return 0;
51	0	}
52	0	r->privkey = (OSSL_PARAM *)p;
53	0	}
54	0	break;
55	97.2k	case 'u':
56	97.2k	if (ossl_likely(strcmp("b", s + 2) == 0)) {
57		/* OSSL_PKEY_PARAM_PUB_KEY */
58	97.2k	if (ossl_unlikely(r->pubkey != NULL)) {
59	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
60	0	"param %s is repeated", s);
61	0	return 0;
62	0	}
63	97.2k	r->pubkey = (OSSL_PARAM *)p;
64	97.2k	}
65	97.2k	}
66	97.2k	}
67	97.2k	return 1;
68	97.2k	}
69		#endif
70		/* End of machine generated */
71
72		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
73		#ifndef mlx_get_params_list
74		static const OSSL_PARAM mlx_get_params_list[] = {
75		OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
76		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
77		OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
78		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
79		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
80		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
81		OSSL_PARAM_END
82		};
83		#endif
84
85		#ifndef mlx_get_params_st
86		struct mlx_get_params_st {
87		OSSL_PARAM *bits;
88		OSSL_PARAM *maxsize;
89		OSSL_PARAM *priv;
90		OSSL_PARAM *pub;
91		OSSL_PARAM *secbits;
92		OSSL_PARAM *seccat;
93		};
94		#endif
95
96		#ifndef mlx_get_params_decoder
97		static int mlx_get_params_decoder
98		(const OSSL_PARAM p, struct mlx_get_params_st r)
99	145k	{
100	145k	const char *s;
101
102	145k	memset(r, 0, sizeof(*r));
103	145k	if (p != NULL)
104	434k	for (; (s = p->key) != NULL; p++)
105	289k	switch(s[0]) {
106	0	default:
107	0	break;
108	48.0k	case 'b':
109	48.0k	if (ossl_likely(strcmp("its", s + 1) == 0)) {
110		/* OSSL_PKEY_PARAM_BITS */
111	48.0k	if (ossl_unlikely(r->bits != NULL)) {
112	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
113	0	"param %s is repeated", s);
114	0	return 0;
115	0	}
116	48.0k	r->bits = (OSSL_PARAM *)p;
117	48.0k	}
118	48.0k	break;
119	97.2k	case 'e':
120	97.2k	if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
121		/* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
122	97.2k	if (ossl_unlikely(r->pub != NULL)) {
123	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
124	0	"param %s is repeated", s);
125	0	return 0;
126	0	}
127	97.2k	r->pub = (OSSL_PARAM *)p;
128	97.2k	}
129	97.2k	break;
130	97.2k	case 'm':
131	48.0k	if (ossl_likely(strcmp("ax-size", s + 1) == 0)) {
132		/* OSSL_PKEY_PARAM_MAX_SIZE */
133	48.0k	if (ossl_unlikely(r->maxsize != NULL)) {
134	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
135	0	"param %s is repeated", s);
136	0	return 0;
137	0	}
138	48.0k	r->maxsize = (OSSL_PARAM *)p;
139	48.0k	}
140	48.0k	break;
141	48.0k	case 'p':
142	0	if (ossl_likely(strcmp("riv", s + 1) == 0)) {
143		/* OSSL_PKEY_PARAM_PRIV_KEY */
144	0	if (ossl_unlikely(r->priv != NULL)) {
145	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
146	0	"param %s is repeated", s);
147	0	return 0;
148	0	}
149	0	r->priv = (OSSL_PARAM *)p;
150	0	}
151	0	break;
152	96.0k	case 's':
153	96.0k	switch(s[1]) {
154	0	default:
155	0	break;
156	96.0k	case 'e':
157	96.0k	switch(s[2]) {
158	0	default:
159	0	break;
160	96.0k	case 'c':
161	96.0k	switch(s[3]) {
162	0	default:
163	0	break;
164	96.0k	case 'u':
165	96.0k	switch(s[4]) {
166	0	default:
167	0	break;
168	96.0k	case 'r':
169	96.0k	switch(s[5]) {
170	0	default:
171	0	break;
172	96.0k	case 'i':
173	96.0k	switch(s[6]) {
174	0	default:
175	0	break;
176	96.0k	case 't':
177	96.0k	switch(s[7]) {
178	0	default:
179	0	break;
180	96.0k	case 'y':
181	96.0k	switch(s[8]) {
182	0	default:
183	0	break;
184	96.0k	case '-':
185	96.0k	switch(s[9]) {
186	0	default:
187	0	break;
188	48.0k	case 'b':
189	48.0k	if (ossl_likely(strcmp("its", s + 10) == 0)) {
190		/* OSSL_PKEY_PARAM_SECURITY_BITS */
191	48.0k	if (ossl_unlikely(r->secbits != NULL)) {
192	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
193	0	"param %s is repeated", s);
194	0	return 0;
195	0	}
196	48.0k	r->secbits = (OSSL_PARAM *)p;
197	48.0k	}
198	48.0k	break;
199	48.0k	case 'c':
200	48.0k	if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
201		/* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
202	48.0k	if (ossl_unlikely(r->seccat != NULL)) {
203	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
204	0	"param %s is repeated", s);
205	0	return 0;
206	0	}
207	48.0k	r->seccat = (OSSL_PARAM *)p;
208	48.0k	}
209	96.0k	}
210	96.0k	}
211	96.0k	}
212	96.0k	}
213	96.0k	}
214	96.0k	}
215	96.0k	}
216	96.0k	}
217	96.0k	}
218	289k	}
219	145k	return 1;
220	145k	}
221		#endif
222		/* End of machine generated */
223
224		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
225		#ifndef mlx_set_params_list
226		static const OSSL_PARAM mlx_set_params_list[] = {
227		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY, NULL, 0),
228		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
229		OSSL_PARAM_END
230		};
231		#endif
232
233		#ifndef mlx_set_params_st
234		struct mlx_set_params_st {
235		OSSL_PARAM *propq;
236		OSSL_PARAM *pub;
237		};
238		#endif
239
240		#ifndef mlx_set_params_decoder
241		static int mlx_set_params_decoder
242		(const OSSL_PARAM p, struct mlx_set_params_st r)
243	39	{
244	39	const char *s;
245
246	39	memset(r, 0, sizeof(*r));
247	39	if (p != NULL)
248	78	for (; (s = p->key) != NULL; p++)
249	39	switch(s[0]) {
250	0	default:
251	0	break;
252	39	case 'e':
253	39	if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
254		/* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
255	39	if (ossl_unlikely(r->pub != NULL)) {
256	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
257	0	"param %s is repeated", s);
258	0	return 0;
259	0	}
260	39	r->pub = (OSSL_PARAM *)p;
261	39	}
262	39	break;
263	39	case 'p':
264	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
265		/* OSSL_PKEY_PARAM_PROPERTIES */
266	0	if (ossl_unlikely(r->propq != NULL)) {
267	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
268	0	"param %s is repeated", s);
269	0	return 0;
270	0	}
271	0	r->propq = (OSSL_PARAM *)p;
272	0	}
273	39	}
274	39	return 1;
275	39	}
276		#endif
277		/* End of machine generated */
278
279		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
280		#ifndef mlx_gen_set_params_list
281		static const OSSL_PARAM mlx_gen_set_params_list[] = {
282		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
283		OSSL_PARAM_END
284		};
285		#endif
286
287		#ifndef mlx_gen_set_params_st
288		struct mlx_gen_set_params_st {
289		OSSL_PARAM *propq;
290		};
291		#endif
292
293		#ifndef mlx_gen_set_params_decoder
294		static int mlx_gen_set_params_decoder
295		(const OSSL_PARAM p, struct mlx_gen_set_params_st r)
296	96.0k	{
297	96.0k	const char *s;
298
299	96.0k	memset(r, 0, sizeof(*r));
300	96.0k	if (p != NULL)
301	96.0k	for (; (s = p->key) != NULL; p++)
302	48.0k	if (ossl_likely(strcmp("properties", s + 0) == 0)) {
303		/* OSSL_PKEY_PARAM_PROPERTIES */
304	0	if (ossl_unlikely(r->propq != NULL)) {
305	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
306	0	"param %s is repeated", s);
307	0	return 0;
308	0	}
309	0	r->propq = (OSSL_PARAM *)p;
310	0	}
311	96.0k	return 1;
312	96.0k	}
313		#endif
314		/* End of machine generated */