/src/openssl41/providers/implementations/keymgmt/ml_dsa_kmgmt.inc

Source
/*
 * Copyright 2025-2026 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 ml_dsa_import_params_list
static ossl_unused const OSSL_PARAM ml_dsa_import_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_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ml_dsa_import_params_st
struct ml_dsa_import_params_st {
    OSSL_PARAM *privkey;
    OSSL_PARAM *propq;
    OSSL_PARAM *pubkey;
    OSSL_PARAM *seed;
};
#endif

#ifndef ml_dsa_import_params_decoder
static ossl_unused int ml_dsa_import_params_decoder
    (const OSSL_PARAM *p, struct ml_dsa_import_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':
                    switch(s[2]) {
                    default:
                        break;
                    case 'i':
                        if (ossl_likely(strcmp("v", s + 3) == 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 'o':
                        if (ossl_likely(strcmp("perties", s + 3) == 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 '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 */
#ifndef ml_dsa_export_params_list
static ossl_unused const OSSL_PARAM ml_dsa_export_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_export_params_st
struct ml_dsa_export_params_st {
    OSSL_PARAM *privkey;
    OSSL_PARAM *pubkey;
    OSSL_PARAM *seed;
};
#endif

#ifndef ml_dsa_export_params_decoder
static ossl_unused int ml_dsa_export_params_decoder
    (const OSSL_PARAM *p, struct ml_dsa_export_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 */
#ifndef ml_dsa_get_params_list
static ossl_unused 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 ossl_unused 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 */
#ifndef ml_dsa_gen_set_params_list
static ossl_unused 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 ossl_unused 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 */

/* Machine generated */
#ifndef ml_dsa_new_key_ex_params_list
static ossl_unused const OSSL_PARAM ml_dsa_new_key_ex_params_list[] = {
    OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ml_dsa_new_key_ex_params_st
struct ml_dsa_new_key_ex_params_st {
    OSSL_PARAM *propq;
};
#endif

#ifndef ml_dsa_new_key_ex_params_decoder
static ossl_unused int ml_dsa_new_key_ex_params_decoder
    (const OSSL_PARAM *p, struct ml_dsa_new_key_ex_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-09-12 06:55

Line	Count	Source
1		/*
2		* Copyright 2025-2026 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 ml_dsa_import_params_list
21		static ossl_unused const OSSL_PARAM ml_dsa_import_params_list[] = {
22		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0),
23		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
24		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
25		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
26		OSSL_PARAM_END
27		};
28		#endif
29
30		#ifndef ml_dsa_import_params_st
31		struct ml_dsa_import_params_st {
32		OSSL_PARAM *privkey;
33		OSSL_PARAM *propq;
34		OSSL_PARAM *pubkey;
35		OSSL_PARAM *seed;
36		};
37		#endif
38
39		#ifndef ml_dsa_import_params_decoder
40		static ossl_unused int ml_dsa_import_params_decoder
41		(const OSSL_PARAM p, struct ml_dsa_import_params_st r)
42	26	{
43	26	const char *s;
44
45	26	memset(r, 0, sizeof(*r));
46	26	if (p != NULL)
47	52	for (; (s = p->key) != NULL; p++)
48	26	switch(s[0]) {
49	0	default:
50	0	break;
51	26	case 'p':
52	26	switch(s[1]) {
53	0	default:
54	0	break;
55	10	case 'r':
56	10	switch(s[2]) {
57	0	default:
58	0	break;
59	10	case 'i':
60	10	if (ossl_likely(strcmp("v", s + 3) == 0)) {
61		/* OSSL_PKEY_PARAM_PRIV_KEY */
62	10	if (ossl_unlikely(r->privkey != NULL)) {
63	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
64	0	"param %s is repeated", s);
65	0	return 0;
66	0	}
67	10	r->privkey = (OSSL_PARAM *)p;
68	10	}
69	10	break;
70	10	case 'o':
71	0	if (ossl_likely(strcmp("perties", s + 3) == 0)) {
72		/* OSSL_PKEY_PARAM_PROPERTIES */
73	0	if (ossl_unlikely(r->propq != NULL)) {
74	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
75	0	"param %s is repeated", s);
76	0	return 0;
77	0	}
78	0	r->propq = (OSSL_PARAM *)p;
79	0	}
80	10	}
81	10	break;
82	16	case 'u':
83	16	if (ossl_likely(strcmp("b", s + 2) == 0)) {
84		/* OSSL_PKEY_PARAM_PUB_KEY */
85	16	if (ossl_unlikely(r->pubkey != NULL)) {
86	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
87	0	"param %s is repeated", s);
88	0	return 0;
89	0	}
90	16	r->pubkey = (OSSL_PARAM *)p;
91	16	}
92	26	}
93	26	break;
94	26	case 's':
95	0	if (ossl_likely(strcmp("eed", s + 1) == 0)) {
96		/* OSSL_PKEY_PARAM_ML_DSA_SEED */
97	0	if (ossl_unlikely(r->seed != NULL)) {
98	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
99	0	"param %s is repeated", s);
100	0	return 0;
101	0	}
102	0	r->seed = (OSSL_PARAM *)p;
103	0	}
104	26	}
105	26	return 1;
106	26	}
107		#endif
108		/* End of machine generated */
109
110		/* Machine generated */
111		#ifndef ml_dsa_export_params_list
112		static ossl_unused const OSSL_PARAM ml_dsa_export_params_list[] = {
113		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0),
114		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
115		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
116		OSSL_PARAM_END
117		};
118		#endif
119
120		#ifndef ml_dsa_export_params_st
121		struct ml_dsa_export_params_st {
122		OSSL_PARAM *privkey;
123		OSSL_PARAM *pubkey;
124		OSSL_PARAM *seed;
125		};
126		#endif
127
128		#ifndef ml_dsa_export_params_decoder
129		static ossl_unused int ml_dsa_export_params_decoder
130		(const OSSL_PARAM p, struct ml_dsa_export_params_st r)
131		{
132		const char *s;
133
134		memset(r, 0, sizeof(*r));
135		if (p != NULL)
136		for (; (s = p->key) != NULL; p++)
137		switch(s[0]) {
138		default:
139		break;
140		case 'p':
141		switch(s[1]) {
142		default:
143		break;
144		case 'r':
145		if (ossl_likely(strcmp("iv", s + 2) == 0)) {
146		/* OSSL_PKEY_PARAM_PRIV_KEY */
147		if (ossl_unlikely(r->privkey != NULL)) {
148		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
149		"param %s is repeated", s);
150		return 0;
151		}
152		r->privkey = (OSSL_PARAM *)p;
153		}
154		break;
155		case 'u':
156		if (ossl_likely(strcmp("b", s + 2) == 0)) {
157		/* OSSL_PKEY_PARAM_PUB_KEY */
158		if (ossl_unlikely(r->pubkey != NULL)) {
159		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
160		"param %s is repeated", s);
161		return 0;
162		}
163		r->pubkey = (OSSL_PARAM *)p;
164		}
165		}
166		break;
167		case 's':
168		if (ossl_likely(strcmp("eed", s + 1) == 0)) {
169		/* OSSL_PKEY_PARAM_ML_DSA_SEED */
170		if (ossl_unlikely(r->seed != NULL)) {
171		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
172		"param %s is repeated", s);
173		return 0;
174		}
175		r->seed = (OSSL_PARAM *)p;
176		}
177		}
178		return 1;
179		}
180		#endif
181		/* End of machine generated */
182
183		/* Machine generated */
184		#ifndef ml_dsa_get_params_list
185		static ossl_unused const OSSL_PARAM ml_dsa_get_params_list[] = {
186		OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
187		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
188		OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
189		OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_CATEGORY, NULL),
190		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
191		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0),
192		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0),
193		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0),
194		OSSL_PARAM_END
195		};
196		#endif
197
198		#ifndef ml_dsa_get_params_st
199		struct ml_dsa_get_params_st {
200		OSSL_PARAM *bits;
201		OSSL_PARAM *dgstp;
202		OSSL_PARAM *maxsize;
203		OSSL_PARAM *privkey;
204		OSSL_PARAM *pubkey;
205		OSSL_PARAM *secbits;
206		OSSL_PARAM *seccat;
207		OSSL_PARAM *seed;
208		};
209		#endif
210
211		#ifndef ml_dsa_get_params_decoder
212		static ossl_unused int ml_dsa_get_params_decoder
213		(const OSSL_PARAM p, struct ml_dsa_get_params_st r)
214	2.23k	{
215	2.23k	const char *s;
216
217	2.23k	memset(r, 0, sizeof(*r));
218	2.23k	if (p != NULL)
219	10.1k	for (; (s = p->key) != NULL; p++)
220	7.89k	switch(s[0]) {
221	522	default:
222	522	break;
223	1.71k	case 'b':
224	1.71k	if (ossl_likely(strcmp("its", s + 1) == 0)) {
225		/* OSSL_PKEY_PARAM_BITS */
226	1.71k	if (ossl_unlikely(r->bits != 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.71k	r->bits = (OSSL_PARAM *)p;
232	1.71k	}
233	1.71k	break;
234	2.23k	case 'm':
235	2.23k	switch(s[1]) {
236	0	default:
237	0	break;
238	2.23k	case 'a':
239	2.23k	switch(s[2]) {
240	0	default:
241	0	break;
242	522	case 'n':
243	522	if (ossl_likely(strcmp("datory-digest", s + 3) == 0)) {
244		/* OSSL_PKEY_PARAM_MANDATORY_DIGEST */
245	522	if (ossl_unlikely(r->dgstp != 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	522	r->dgstp = (OSSL_PARAM *)p;
251	522	}
252	522	break;
253	1.71k	case 'x':
254	1.71k	if (ossl_likely(strcmp("-size", s + 3) == 0)) {
255		/* OSSL_PKEY_PARAM_MAX_SIZE */
256	1.71k	if (ossl_unlikely(r->maxsize != NULL)) {
257	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
258	0	"param %s is repeated", s);
259	0	return 0;
260	0	}
261	1.71k	r->maxsize = (OSSL_PARAM *)p;
262	1.71k	}
263	2.23k	}
264	2.23k	}
265	2.23k	break;
266	2.23k	case 'p':
267	0	switch(s[1]) {
268	0	default:
269	0	break;
270	0	case 'r':
271	0	if (ossl_likely(strcmp("iv", s + 2) == 0)) {
272		/* OSSL_PKEY_PARAM_PRIV_KEY */
273	0	if (ossl_unlikely(r->privkey != NULL)) {
274	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
275	0	"param %s is repeated", s);
276	0	return 0;
277	0	}
278	0	r->privkey = (OSSL_PARAM *)p;
279	0	}
280	0	break;
281	0	case 'u':
282	0	if (ossl_likely(strcmp("b", s + 2) == 0)) {
283		/* OSSL_PKEY_PARAM_PUB_KEY */
284	0	if (ossl_unlikely(r->pubkey != NULL)) {
285	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
286	0	"param %s is repeated", s);
287	0	return 0;
288	0	}
289	0	r->pubkey = (OSSL_PARAM *)p;
290	0	}
291	0	}
292	0	break;
293	3.42k	case 's':
294	3.42k	switch(s[1]) {
295	0	default:
296	0	break;
297	3.42k	case 'e':
298	3.42k	switch(s[2]) {
299	0	default:
300	0	break;
301	3.42k	case 'c':
302	3.42k	switch(s[3]) {
303	0	default:
304	0	break;
305	3.42k	case 'u':
306	3.42k	switch(s[4]) {
307	0	default:
308	0	break;
309	3.42k	case 'r':
310	3.42k	switch(s[5]) {
311	0	default:
312	0	break;
313	3.42k	case 'i':
314	3.42k	switch(s[6]) {
315	0	default:
316	0	break;
317	3.42k	case 't':
318	3.42k	switch(s[7]) {
319	0	default:
320	0	break;
321	3.42k	case 'y':
322	3.42k	switch(s[8]) {
323	0	default:
324	0	break;
325	3.42k	case '-':
326	3.42k	switch(s[9]) {
327	0	default:
328	0	break;
329	1.71k	case 'b':
330	1.71k	if (ossl_likely(strcmp("its", s + 10) == 0)) {
331		/* OSSL_PKEY_PARAM_SECURITY_BITS */
332	1.71k	if (ossl_unlikely(r->secbits != NULL)) {
333	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
334	0	"param %s is repeated", s);
335	0	return 0;
336	0	}
337	1.71k	r->secbits = (OSSL_PARAM *)p;
338	1.71k	}
339	1.71k	break;
340	1.71k	case 'c':
341	1.71k	if (ossl_likely(strcmp("ategory", s + 10) == 0)) {
342		/* OSSL_PKEY_PARAM_SECURITY_CATEGORY */
343	1.71k	if (ossl_unlikely(r->seccat != NULL)) {
344	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
345	0	"param %s is repeated", s);
346	0	return 0;
347	0	}
348	1.71k	r->seccat = (OSSL_PARAM *)p;
349	1.71k	}
350	3.42k	}
351	3.42k	}
352	3.42k	}
353	3.42k	}
354	3.42k	}
355	3.42k	}
356	3.42k	}
357	3.42k	break;
358	3.42k	case 'e':
359	0	if (ossl_likely(strcmp("d", s + 3) == 0)) {
360		/* OSSL_PKEY_PARAM_ML_DSA_SEED */
361	0	if (ossl_unlikely(r->seed != NULL)) {
362	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
363	0	"param %s is repeated", s);
364	0	return 0;
365	0	}
366	0	r->seed = (OSSL_PARAM *)p;
367	0	}
368	3.42k	}
369	3.42k	}
370	7.89k	}
371	2.23k	return 1;
372	2.23k	}
373		#endif
374		/* End of machine generated */
375
376		/* Machine generated */
377		#ifndef ml_dsa_gen_set_params_list
378		static ossl_unused const OSSL_PARAM ml_dsa_gen_set_params_list[] = {
379		OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0),
380		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
381		OSSL_PARAM_END
382		};
383		#endif
384
385		#ifndef ml_dsa_gen_set_params_st
386		struct ml_dsa_gen_set_params_st {
387		OSSL_PARAM *propq;
388		OSSL_PARAM *seed;
389		};
390		#endif
391
392		#ifndef ml_dsa_gen_set_params_decoder
393		static ossl_unused int ml_dsa_gen_set_params_decoder
394		(const OSSL_PARAM p, struct ml_dsa_gen_set_params_st r)
395	1.51k	{
396	1.51k	const char *s;
397
398	1.51k	memset(r, 0, sizeof(*r));
399	1.51k	if (p != NULL)
400	0	for (; (s = p->key) != NULL; p++)
401	0	switch(s[0]) {
402	0	default:
403	0	break;
404	0	case 'p':
405	0	if (ossl_likely(strcmp("roperties", s + 1) == 0)) {
406		/* OSSL_PKEY_PARAM_PROPERTIES */
407	0	if (ossl_unlikely(r->propq != NULL)) {
408	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
409	0	"param %s is repeated", s);
410	0	return 0;
411	0	}
412	0	r->propq = (OSSL_PARAM *)p;
413	0	}
414	0	break;
415	0	case 's':
416	0	if (ossl_likely(strcmp("eed", s + 1) == 0)) {
417		/* OSSL_PKEY_PARAM_ML_DSA_SEED */
418	0	if (ossl_unlikely(r->seed != NULL)) {
419	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
420	0	"param %s is repeated", s);
421	0	return 0;
422	0	}
423	0	r->seed = (OSSL_PARAM *)p;
424	0	}
425	0	}
426	1.51k	return 1;
427	1.51k	}
428		#endif
429		/* End of machine generated */
430
431		/* Machine generated */
432		#ifndef ml_dsa_new_key_ex_params_list
433		static ossl_unused const OSSL_PARAM ml_dsa_new_key_ex_params_list[] = {
434		OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
435		OSSL_PARAM_END
436		};
437		#endif
438
439		#ifndef ml_dsa_new_key_ex_params_st
440		struct ml_dsa_new_key_ex_params_st {
441		OSSL_PARAM *propq;
442		};
443		#endif
444
445		#ifndef ml_dsa_new_key_ex_params_decoder
446		static ossl_unused int ml_dsa_new_key_ex_params_decoder
447		(const OSSL_PARAM p, struct ml_dsa_new_key_ex_params_st r)
448	26	{
449	26	const char *s;
450
451	26	memset(r, 0, sizeof(*r));
452	26	if (p != NULL)
453	52	for (; (s = p->key) != NULL; p++)
454	26	if (ossl_likely(strcmp("properties", s + 0) == 0)) {
455		/* OSSL_PKEY_PARAM_PROPERTIES */
456	0	if (ossl_unlikely(r->propq != NULL)) {
457	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
458	0	"param %s is repeated", s);
459	0	return 0;
460	0	}
461	0	r->propq = (OSSL_PARAM *)p;
462	0	}
463	26	return 1;
464	26	}
465		#endif
466		/* End of machine generated */