/src/openssl40/providers/implementations/keymgmt/ml_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 ml_dsa_key_type_params_list
static const OSSL_PARAM ml_dsa_key_type_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, 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 ml_dsa_key_type_params_st
struct ml_dsa_key_type_params_st {
    OSSL_PARAM *privkey;
    OSSL_PARAM *pubkey;
    OSSL_PARAM *seed;
};
#endif

#ifndef ml_dsa_key_type_params_decoder
static int ml_dsa_key_type_params_decoder
    (const OSSL_PARAM *p, struct ml_dsa_key_type_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':
                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;
                    }
                }
                break;
            case 's':
                if (ossl_likely(strcmp("eed", s + 1) == 0)) {
                    /* OSSL_PKEY_PARAM_ML_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 */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef ml_dsa_get_params_list
static const OSSL_PARAM ml_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_ML_DSA_SEED, 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 ml_dsa_get_params_st
struct ml_dsa_get_params_st {
    OSSL_PARAM *bits;
    OSSL_PARAM *dgstp;
    OSSL_PARAM *maxsize;
    OSSL_PARAM *privkey;
    OSSL_PARAM *pubkey;
    OSSL_PARAM *secbits;
    OSSL_PARAM *seccat;
    OSSL_PARAM *seed;
};
#endif

#ifndef ml_dsa_get_params_decoder
static int ml_dsa_get_params_decoder
    (const OSSL_PARAM *p, struct ml_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->dgstp != NULL)) {
                                ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                               "param %s is repeated", s);
                                return 0;
                            }
                            r->dgstp = (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->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;
                    }
                }
                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;
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                        break;
                    case 'e':
                        if (ossl_likely(strcmp("d", s + 3) == 0)) {
                            /* OSSL_PKEY_PARAM_ML_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 */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef ml_dsa_gen_set_params_list
static const OSSL_PARAM ml_dsa_gen_set_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0),
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

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

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