/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 */
#include <string.h>
#include <openssl/params.h>
#include <openssl/e_os2.h>
#include "internal/common.h"
#include "prov/proverr.h"

/* Machine generated */
#ifndef ml_kem_import_export_list
static ossl_unused 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 ossl_unused 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 */
#ifndef mlx_get_params_list
static ossl_unused 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 ossl_unused 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 */
#ifndef mlx_set_params_list
static ossl_unused 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 ossl_unused 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 */
#ifndef mlx_gen_set_params_list
static ossl_unused 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 ossl_unused 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-13 06:13

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