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

#ifndef slh_dsa_import_list
static 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 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 by util/perl/OpenSSL/paramnames.pm */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#ifndef slh_dsa_get_params_list
static 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 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 by util/perl/OpenSSL/paramnames.pm */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#ifndef slh_dsa_gen_set_params_list
static 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 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-05-30 06:06

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