/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 "internal/common.h"
#include "prov/proverr.h"

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

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

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

#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-07-23 06:28

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