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

#ifndef slh_dsa_import_st
struct slh_dsa_import_st {
    OSSL_PARAM *priv;
    OSSL_PARAM *pub;
};
#endif

#ifndef slh_dsa_import_decoder
static ossl_unused int slh_dsa_import_decoder
    (const OSSL_PARAM *p, struct slh_dsa_import_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->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 'u':
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PUB_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;
                    }
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated */
#ifndef slh_dsa_get_params_list
static ossl_unused const OSSL_PARAM slh_dsa_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_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
    OSSL_PARAM_END
};
#endif

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

#ifndef slh_dsa_get_params_decoder
static ossl_unused int slh_dsa_get_params_decoder
    (const OSSL_PARAM *p, struct slh_dsa_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 'm':
                switch(s[1]) {
                default:
                    break;
                case 'a':
                    switch(s[2]) {
                    default:
                        break;
                    case 'n':
                        if (ossl_likely(strcmp("datory-digest", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_MANDATORY_DIGEST */
                            if (ossl_unlikely(r->mandgst != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->mandgst = (OSSL_PARAM *)p;
                        }
                        break;
                    case 'x':
                        if (ossl_likely(strcmp("-size", s + 3) == 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':
                switch(s[1]) {
                default:
                    break;
                case 'r':
                    if (ossl_likely(strcmp("iv", s + 2) == 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 'u':
                    if (ossl_likely(strcmp("b", s + 2) == 0)) {
                        /* OSSL_PKEY_PARAM_PUB_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 '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 slh_dsa_gen_set_params_list
static ossl_unused const OSSL_PARAM slh_dsa_gen_set_params_list[] = {
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_SLH_DSA_SEED, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef slh_dsa_gen_set_params_st
struct slh_dsa_gen_set_params_st {
    OSSL_PARAM *propq;
    OSSL_PARAM *seed;
};
#endif

#ifndef slh_dsa_gen_set_params_decoder
static ossl_unused int slh_dsa_gen_set_params_decoder
    (const OSSL_PARAM *p, struct slh_dsa_gen_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 '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;
                }
                break;
            case 's':
                if (ossl_likely(strcmp("eed", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_SLH_DSA_SEED */
                    if (ossl_unlikely(r->seed != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->seed = (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		#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 slh_dsa_import_list
21		static ossl_unused const OSSL_PARAM slh_dsa_import_list[] = {
22		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
23		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
24		OSSL_PARAM_END
25		};
26		#endif
27
28		#ifndef slh_dsa_import_st
29		struct slh_dsa_import_st {
30		OSSL_PARAM *priv;
31		OSSL_PARAM *pub;
32		};
33		#endif
34
35		#ifndef slh_dsa_import_decoder
36		static ossl_unused int slh_dsa_import_decoder
37		(const OSSL_PARAM p, struct slh_dsa_import_st r)
38	419	{
39	419	const char *s;
40
41	419	memset(r, 0, sizeof(*r));
42	419	if (p != NULL)
43	1.25k	for (; (s = p->key) != NULL; p++)
44	838	switch(s[0]) {
45	0	default:
46	0	break;
47	838	case 'p':
48	838	switch(s[1]) {
49	0	default:
50	0	break;
51	419	case 'r':
52	419	if (ossl_likely(strcmp("iv", s + 2) == 0)) {
53		/* OSSL_PKEY_PARAM_PRIV_KEY */
54	419	if (ossl_unlikely(r->priv != 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	419	r->priv = (OSSL_PARAM *)p;
60	419	}
61	419	break;
62	419	case 'u':
63	419	if (ossl_likely(strcmp("b", s + 2) == 0)) {
64		/* OSSL_PKEY_PARAM_PUB_KEY */
65	419	if (ossl_unlikely(r->pub != 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	419	r->pub = (OSSL_PARAM *)p;
71	419	}
72	838	}
73	838	}
74	419	return 1;
75	419	}
76		#endif
77		/* End of machine generated */
78
79		/* Machine generated */
80		#ifndef slh_dsa_get_params_list
81		static ossl_unused const OSSL_PARAM slh_dsa_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_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
87		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
88		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
89		OSSL_PARAM_END
90		};
91		#endif
92
93		#ifndef slh_dsa_get_params_st
94		struct slh_dsa_get_params_st {
95		OSSL_PARAM *bits;
96		OSSL_PARAM *mandgst;
97		OSSL_PARAM *maxsize;
98		OSSL_PARAM *priv;
99		OSSL_PARAM *pub;
100		OSSL_PARAM *secbits;
101		OSSL_PARAM *seccat;
102		};
103		#endif
104
105		#ifndef slh_dsa_get_params_decoder
106		static ossl_unused int slh_dsa_get_params_decoder
107		(const OSSL_PARAM p, struct slh_dsa_get_params_st r)
108	1.56k	{
109	1.56k	const char *s;
110
111	1.56k	memset(r, 0, sizeof(*r));
112	1.56k	if (p != NULL)
113	7.84k	for (; (s = p->key) != NULL; p++)
114	6.27k	switch(s[0]) {
115	0	default:
116	0	break;
117	1.56k	case 'b':
118	1.56k	if (ossl_likely(strcmp("its", s + 1) == 0)) {
119		/* OSSL_PKEY_PARAM_BITS */
120	1.56k	if (ossl_unlikely(r->bits != NULL)) {
121	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
122	0	"param %s is repeated", s);
123	0	return 0;
124	0	}
125	1.56k	r->bits = (OSSL_PARAM *)p;
126	1.56k	}
127	1.56k	break;
128	1.56k	case 'm':
129	1.56k	switch(s[1]) {
130	0	default:
131	0	break;
132	1.56k	case 'a':
133	1.56k	switch(s[2]) {
134	0	default:
135	0	break;
136	0	case 'n':
137	0	if (ossl_likely(strcmp("datory-digest", s + 3) == 0)) {
138		/* OSSL_PKEY_PARAM_MANDATORY_DIGEST */
139	0	if (ossl_unlikely(r->mandgst != NULL)) {
140	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
141	0	"param %s is repeated", s);
142	0	return 0;
143	0	}
144	0	r->mandgst = (OSSL_PARAM *)p;
145	0	}
146	0	break;
147	1.56k	case 'x':
148	1.56k	if (ossl_likely(strcmp("-size", s + 3) == 0)) {
149		/* OSSL_PKEY_PARAM_MAX_SIZE */
150	1.56k	if (ossl_unlikely(r->maxsize != NULL)) {
151	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
152	0	"param %s is repeated", s);
153	0	return 0;
154	0	}
155	1.56k	r->maxsize = (OSSL_PARAM *)p;
156	1.56k	}
157	1.56k	}
158	1.56k	}
159	1.56k	break;
160	1.56k	case 'p':
161	0	switch(s[1]) {
162	0	default:
163	0	break;
164	0	case 'r':
165	0	if (ossl_likely(strcmp("iv", s + 2) == 0)) {
166		/* OSSL_PKEY_PARAM_PRIV_KEY */
167	0	if (ossl_unlikely(r->priv != 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->priv = (OSSL_PARAM *)p;
173	0	}
174	0	break;
175	0	case 'u':
176	0	if (ossl_likely(strcmp("b", s + 2) == 0)) {
177		/* OSSL_PKEY_PARAM_PUB_KEY */
178	0	if (ossl_unlikely(r->pub != 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->pub = (OSSL_PARAM *)p;
184	0	}
185	0	}
186	0	break;
187	3.13k	case 's':
188	3.13k	switch(s[1]) {
189	0	default:
190	0	break;
191	3.13k	case 'e':
192	3.13k	switch(s[2]) {
193	0	default:
194	0	break;
195	3.13k	case 'c':
196	3.13k	switch(s[3]) {
197	0	default:
198	0	break;
199	3.13k	case 'u':
200	3.13k	switch(s[4]) {
201	0	default:
202	0	break;
203	3.13k	case 'r':
204	3.13k	switch(s[5]) {
205	0	default:
206	0	break;
207	3.13k	case 'i':
208	3.13k	switch(s[6]) {
209	0	default:
210	0	break;
211	3.13k	case 't':
212	3.13k	switch(s[7]) {
213	0	default:
214	0	break;
215	3.13k	case 'y':
216	3.13k	switch(s[8]) {
217	0	default:
218	0	break;
219	3.13k	case '-':
220	3.13k	switch(s[9]) {
221	0	default:
222	0	break;
223	1.56k	case 'b':
224	1.56k	if (ossl_likely(strcmp("its", s + 10) == 0)) {
225		/* OSSL_PKEY_PARAM_SECURITY_BITS */
226	1.56k	if (ossl_unlikely(r->secbits != NULL)) {
227	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
228	0	"param %s is repeated", s);
229	0	return 0;
230	0	}
231	1.56k	r->secbits = (OSSL_PARAM *)p;
232	1.56k	}
233	1.56k	break;
234	1.56k	case 'c':
235	1.56k	if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
236		/* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
237	1.56k	if (ossl_unlikely(r->seccat != NULL)) {
238	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
239	0	"param %s is repeated", s);
240	0	return 0;
241	0	}
242	1.56k	r->seccat = (OSSL_PARAM *)p;
243	1.56k	}
244	3.13k	}
245	3.13k	}
246	3.13k	}
247	3.13k	}
248	3.13k	}
249	3.13k	}
250	3.13k	}
251	3.13k	}
252	3.13k	}
253	6.27k	}
254	1.56k	return 1;
255	1.56k	}
256		#endif
257		/* End of machine generated */
258
259		/* Machine generated */
260		#ifndef slh_dsa_gen_set_params_list
261		static ossl_unused const OSSL_PARAM slh_dsa_gen_set_params_list[] = {
262		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
263		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_SLH_DSA_SEED, NULL, 0),
264		OSSL_PARAM_END
265		};
266		#endif
267
268		#ifndef slh_dsa_gen_set_params_st
269		struct slh_dsa_gen_set_params_st {
270		OSSL_PARAM *propq;
271		OSSL_PARAM *seed;
272		};
273		#endif
274
275		#ifndef slh_dsa_gen_set_params_decoder
276		static ossl_unused int slh_dsa_gen_set_params_decoder
277		(const OSSL_PARAM p, struct slh_dsa_gen_set_params_st r)
278	1.19k	{
279	1.19k	const char *s;
280
281	1.19k	memset(r, 0, sizeof(*r));
282	1.19k	if (p != NULL)
283	0	for (; (s = p->key) != NULL; p++)
284	0	switch(s[0]) {
285	0	default:
286	0	break;
287	0	case 'p':
288	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
289		/* OSSL_PKEY_PARAM_PROPERTIES */
290	0	if (ossl_unlikely(r->propq != NULL)) {
291	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
292	0	"param %s is repeated", s);
293	0	return 0;
294	0	}
295	0	r->propq = (OSSL_PARAM *)p;
296	0	}
297	0	break;
298	0	case 's':
299	0	if (ossl_likely(strcmp("eed", s + 1) == 0)) {
300		/* OSSL_PKEY_PARAM_SLH_DSA_SEED */
301	0	if (ossl_unlikely(r->seed != NULL)) {
302	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
303	0	"param %s is repeated", s);
304	0	return 0;
305	0	}
306	0	r->seed = (OSSL_PARAM *)p;
307	0	}
308	0	}
309	1.19k	return 1;
310	1.19k	}
311		#endif
312		/* End of machine generated */