/src/openssl/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: 2025-11-07 06:36

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	0	{
32	0	const char *s;
33
34	0	memset(r, 0, sizeof(*r));
35	0	if (p != NULL)
36	0	for (; (s = p->key) != NULL; p++)
37	0	switch(s[0]) {
38	0	default:
39	0	break;
40	0	case 'p':
41	0	switch(s[1]) {
42	0	default:
43	0	break;
44	0	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	0	case 'u':
56	0	if (ossl_likely(strcmp("b", s + 2) == 0)) {
57		/* OSSL_PKEY_PARAM_PUB_KEY */
58	0	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	0	r->pubkey = (OSSL_PARAM *)p;
64	0	}
65	0	}
66	0	}
67	0	return 1;
68	0	}
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	0	{
100	0	const char *s;
101
102	0	memset(r, 0, sizeof(*r));
103	0	if (p != NULL)
104	0	for (; (s = p->key) != NULL; p++)
105	0	switch(s[0]) {
106	0	default:
107	0	break;
108	0	case 'b':
109	0	if (ossl_likely(strcmp("its", s + 1) == 0)) {
110		/* OSSL_PKEY_PARAM_BITS */
111	0	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	0	r->bits = (OSSL_PARAM *)p;
117	0	}
118	0	break;
119	0	case 'e':
120	0	if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
121		/* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
122	0	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	0	r->pub = (OSSL_PARAM *)p;
128	0	}
129	0	break;
130	0	case 'm':
131	0	if (ossl_likely(strcmp("ax-size", s + 1) == 0)) {
132		/* OSSL_PKEY_PARAM_MAX_SIZE */
133	0	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	0	r->maxsize = (OSSL_PARAM *)p;
139	0	}
140	0	break;
141	0	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	0	case 's':
153	0	switch(s[1]) {
154	0	default:
155	0	break;
156	0	case 'e':
157	0	switch(s[2]) {
158	0	default:
159	0	break;
160	0	case 'c':
161	0	switch(s[3]) {
162	0	default:
163	0	break;
164	0	case 'u':
165	0	switch(s[4]) {
166	0	default:
167	0	break;
168	0	case 'r':
169	0	switch(s[5]) {
170	0	default:
171	0	break;
172	0	case 'i':
173	0	switch(s[6]) {
174	0	default:
175	0	break;
176	0	case 't':
177	0	switch(s[7]) {
178	0	default:
179	0	break;
180	0	case 'y':
181	0	switch(s[8]) {
182	0	default:
183	0	break;
184	0	case '-':
185	0	switch(s[9]) {
186	0	default:
187	0	break;
188	0	case 'b':
189	0	if (ossl_likely(strcmp("its", s + 10) == 0)) {
190		/* OSSL_PKEY_PARAM_SECURITY_BITS */
191	0	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	0	r->secbits = (OSSL_PARAM *)p;
197	0	}
198	0	break;
199	0	case 'c':
200	0	if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
201		/* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
202	0	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	0	r->seccat = (OSSL_PARAM *)p;
208	0	}
209	0	}
210	0	}
211	0	}
212	0	}
213	0	}
214	0	}
215	0	}
216	0	}
217	0	}
218	0	}
219	0	return 1;
220	0	}
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	0	{
244	0	const char *s;
245
246	0	memset(r, 0, sizeof(*r));
247	0	if (p != NULL)
248	0	for (; (s = p->key) != NULL; p++)
249	0	switch(s[0]) {
250	0	default:
251	0	break;
252	0	case 'e':
253	0	if (ossl_likely(strcmp("ncoded-pub-key", s + 1) == 0)) {
254		/* OSSL_PKEY_PARAM_ENCODED_PUBLIC_KEY */
255	0	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	0	r->pub = (OSSL_PARAM *)p;
261	0	}
262	0	break;
263	0	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	0	}
274	0	return 1;
275	0	}
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	0	{
297	0	const char *s;
298
299	0	memset(r, 0, sizeof(*r));
300	0	if (p != NULL)
301	0	for (; (s = p->key) != NULL; p++)
302	0	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	0	return 1;
312	0	}
313		#endif
314		/* End of machine generated */