/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 */
#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 */
#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 */
#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-04-09 06:50

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