/src/openssl/providers/implementations/signature/ml_dsa_sig.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_set_ctx_params_list
static const OSSL_PARAM ml_dsa_set_ctx_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_TEST_ENTROPY, NULL, 0),
    OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, NULL),
    OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, NULL),
    OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MU, NULL),
    OSSL_PARAM_END
};
#endif

#ifndef ml_dsa_set_ctx_params_st
struct ml_dsa_set_ctx_params_st {
    OSSL_PARAM *ctx;
    OSSL_PARAM *det;
    OSSL_PARAM *ent;
    OSSL_PARAM *msgenc;
    OSSL_PARAM *mu;
};
#endif

#ifndef ml_dsa_set_ctx_params_decoder
static int ml_dsa_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct ml_dsa_set_ctx_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 'c':
                if (ossl_likely(strcmp("ontext-string", s + 1) == 0)) {
                    /* OSSL_SIGNATURE_PARAM_CONTEXT_STRING */
                    if (ossl_unlikely(r->ctx != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ctx = (OSSL_PARAM *)p;
                }
                break;
            case 'd':
                if (ossl_likely(strcmp("eterministic", s + 1) == 0)) {
                    /* OSSL_SIGNATURE_PARAM_DETERMINISTIC */
                    if (ossl_unlikely(r->det != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->det = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    if (ossl_likely(strcmp("ssage-encoding", s + 2) == 0)) {
                        /* OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING */
                        if (ossl_unlikely(r->msgenc != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->msgenc = (OSSL_PARAM *)p;
                    }
                    break;
                case 'u':
                    switch(s[2]) {
                    default:
                        break;
                    case '\0':
                        if (ossl_unlikely(r->mu != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->mu = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 't':
                if (ossl_likely(strcmp("est-entropy", s + 1) == 0)) {
                    /* OSSL_SIGNATURE_PARAM_TEST_ENTROPY */
                    if (ossl_unlikely(r->ent != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ent = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

/* Machine generated by util/perl/OpenSSL/paramnames.pm */
#ifndef ml_dsa_verifymsg_set_ctx_params_list
static const OSSL_PARAM ml_dsa_verifymsg_set_ctx_params_list[] = {
    OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING, NULL, 0),
    OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_TEST_ENTROPY, NULL, 0),
    OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, NULL),
    OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, NULL),
    OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MU, NULL),
    OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_SIGNATURE, NULL, 0),
    OSSL_PARAM_END
};
#endif

#ifndef ml_dsa_verifymsg_set_ctx_params_st
struct ml_dsa_verifymsg_set_ctx_params_st {
    OSSL_PARAM *ctx;
    OSSL_PARAM *det;
    OSSL_PARAM *ent;
    OSSL_PARAM *msgenc;
    OSSL_PARAM *mu;
    OSSL_PARAM *sig;
};
#endif

#ifndef ml_dsa_verifymsg_set_ctx_params_decoder
static int ml_dsa_verifymsg_set_ctx_params_decoder
    (const OSSL_PARAM *p, struct ml_dsa_verifymsg_set_ctx_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 'c':
                if (ossl_likely(strcmp("ontext-string", s + 1) == 0)) {
                    /* OSSL_SIGNATURE_PARAM_CONTEXT_STRING */
                    if (ossl_unlikely(r->ctx != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ctx = (OSSL_PARAM *)p;
                }
                break;
            case 'd':
                if (ossl_likely(strcmp("eterministic", s + 1) == 0)) {
                    /* OSSL_SIGNATURE_PARAM_DETERMINISTIC */
                    if (ossl_unlikely(r->det != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->det = (OSSL_PARAM *)p;
                }
                break;
            case 'm':
                switch(s[1]) {
                default:
                    break;
                case 'e':
                    if (ossl_likely(strcmp("ssage-encoding", s + 2) == 0)) {
                        /* OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING */
                        if (ossl_unlikely(r->msgenc != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->msgenc = (OSSL_PARAM *)p;
                    }
                    break;
                case 'u':
                    switch(s[2]) {
                    default:
                        break;
                    case '\0':
                        if (ossl_unlikely(r->mu != NULL)) {
                            ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                           "param %s is repeated", s);
                            return 0;
                        }
                        r->mu = (OSSL_PARAM *)p;
                    }
                }
                break;
            case 's':
                if (ossl_likely(strcmp("ignature", s + 1) == 0)) {
                    /* OSSL_SIGNATURE_PARAM_SIGNATURE */
                    if (ossl_unlikely(r->sig != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->sig = (OSSL_PARAM *)p;
                }
                break;
            case 't':
                if (ossl_likely(strcmp("est-entropy", s + 1) == 0)) {
                    /* OSSL_SIGNATURE_PARAM_TEST_ENTROPY */
                    if (ossl_unlikely(r->ent != NULL)) {
                        ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                       "param %s is repeated", s);
                        return 0;
                    }
                    r->ent = (OSSL_PARAM *)p;
                }
            }
    return 1;
}
#endif
/* End of machine generated */

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

#ifndef ml_dsa_get_ctx_params_st
struct ml_dsa_get_ctx_params_st {
    OSSL_PARAM *id;
};
#endif

#ifndef ml_dsa_get_ctx_params_decoder
static int ml_dsa_get_ctx_params_decoder
    (const OSSL_PARAM *p, struct ml_dsa_get_ctx_params_st *r)
{
    const char *s;

    memset(r, 0, sizeof(*r));
    if (p != NULL)
        for (; (s = p->key) != NULL; p++)
            if (ossl_likely(strcmp("algorithm-id", s + 0) == 0)) {
                /* OSSL_SIGNATURE_PARAM_ALGORITHM_ID */
                if (ossl_unlikely(r->id != NULL)) {
                    ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
                                   "param %s is repeated", s);
                    return 0;
                }
                r->id = (OSSL_PARAM *)p;
            }
    return 1;
}
#endif
/* End of machine generated */

Coverage Report

Created: 2025-11-11 06:20

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_set_ctx_params_list
14		static const OSSL_PARAM ml_dsa_set_ctx_params_list[] = {
15		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING, NULL, 0),
16		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_TEST_ENTROPY, NULL, 0),
17		OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, NULL),
18		OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, NULL),
19		OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MU, NULL),
20		OSSL_PARAM_END
21		};
22		#endif
23
24		#ifndef ml_dsa_set_ctx_params_st
25		struct ml_dsa_set_ctx_params_st {
26		OSSL_PARAM *ctx;
27		OSSL_PARAM *det;
28		OSSL_PARAM *ent;
29		OSSL_PARAM *msgenc;
30		OSSL_PARAM *mu;
31		};
32		#endif
33
34		#ifndef ml_dsa_set_ctx_params_decoder
35		static int ml_dsa_set_ctx_params_decoder
36		(const OSSL_PARAM p, struct ml_dsa_set_ctx_params_st r)
37		{
38		const char *s;
39
40		memset(r, 0, sizeof(*r));
41		if (p != NULL)
42		for (; (s = p->key) != NULL; p++)
43		switch(s[0]) {
44		default:
45		break;
46		case 'c':
47		if (ossl_likely(strcmp("ontext-string", s + 1) == 0)) {
48		/* OSSL_SIGNATURE_PARAM_CONTEXT_STRING */
49		if (ossl_unlikely(r->ctx != NULL)) {
50		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
51		"param %s is repeated", s);
52		return 0;
53		}
54		r->ctx = (OSSL_PARAM *)p;
55		}
56		break;
57		case 'd':
58		if (ossl_likely(strcmp("eterministic", s + 1) == 0)) {
59		/* OSSL_SIGNATURE_PARAM_DETERMINISTIC */
60		if (ossl_unlikely(r->det != NULL)) {
61		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
62		"param %s is repeated", s);
63		return 0;
64		}
65		r->det = (OSSL_PARAM *)p;
66		}
67		break;
68		case 'm':
69		switch(s[1]) {
70		default:
71		break;
72		case 'e':
73		if (ossl_likely(strcmp("ssage-encoding", s + 2) == 0)) {
74		/* OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING */
75		if (ossl_unlikely(r->msgenc != NULL)) {
76		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
77		"param %s is repeated", s);
78		return 0;
79		}
80		r->msgenc = (OSSL_PARAM *)p;
81		}
82		break;
83		case 'u':
84		switch(s[2]) {
85		default:
86		break;
87		case '\0':
88		if (ossl_unlikely(r->mu != NULL)) {
89		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
90		"param %s is repeated", s);
91		return 0;
92		}
93		r->mu = (OSSL_PARAM *)p;
94		}
95		}
96		break;
97		case 't':
98		if (ossl_likely(strcmp("est-entropy", s + 1) == 0)) {
99		/* OSSL_SIGNATURE_PARAM_TEST_ENTROPY */
100		if (ossl_unlikely(r->ent != NULL)) {
101		ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
102		"param %s is repeated", s);
103		return 0;
104		}
105		r->ent = (OSSL_PARAM *)p;
106		}
107		}
108		return 1;
109		}
110		#endif
111		/* End of machine generated */
112
113		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
114		#ifndef ml_dsa_verifymsg_set_ctx_params_list
115		static const OSSL_PARAM ml_dsa_verifymsg_set_ctx_params_list[] = {
116		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_CONTEXT_STRING, NULL, 0),
117		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_TEST_ENTROPY, NULL, 0),
118		OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_DETERMINISTIC, NULL),
119		OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING, NULL),
120		OSSL_PARAM_int(OSSL_SIGNATURE_PARAM_MU, NULL),
121		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_SIGNATURE, NULL, 0),
122		OSSL_PARAM_END
123		};
124		#endif
125
126		#ifndef ml_dsa_verifymsg_set_ctx_params_st
127		struct ml_dsa_verifymsg_set_ctx_params_st {
128		OSSL_PARAM *ctx;
129		OSSL_PARAM *det;
130		OSSL_PARAM *ent;
131		OSSL_PARAM *msgenc;
132		OSSL_PARAM *mu;
133		OSSL_PARAM *sig;
134		};
135		#endif
136
137		#ifndef ml_dsa_verifymsg_set_ctx_params_decoder
138		static int ml_dsa_verifymsg_set_ctx_params_decoder
139		(const OSSL_PARAM p, struct ml_dsa_verifymsg_set_ctx_params_st r)
140	0	{
141	0	const char *s;
142
143	0	memset(r, 0, sizeof(*r));
144	0	if (p != NULL)
145	0	for (; (s = p->key) != NULL; p++)
146	0	switch(s[0]) {
147	0	default:
148	0	break;
149	0	case 'c':
150	0	if (ossl_likely(strcmp("ontext-string", s + 1) == 0)) {
151		/* OSSL_SIGNATURE_PARAM_CONTEXT_STRING */
152	0	if (ossl_unlikely(r->ctx != NULL)) {
153	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
154	0	"param %s is repeated", s);
155	0	return 0;
156	0	}
157	0	r->ctx = (OSSL_PARAM *)p;
158	0	}
159	0	break;
160	0	case 'd':
161	0	if (ossl_likely(strcmp("eterministic", s + 1) == 0)) {
162		/* OSSL_SIGNATURE_PARAM_DETERMINISTIC */
163	0	if (ossl_unlikely(r->det != NULL)) {
164	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
165	0	"param %s is repeated", s);
166	0	return 0;
167	0	}
168	0	r->det = (OSSL_PARAM *)p;
169	0	}
170	0	break;
171	0	case 'm':
172	0	switch(s[1]) {
173	0	default:
174	0	break;
175	0	case 'e':
176	0	if (ossl_likely(strcmp("ssage-encoding", s + 2) == 0)) {
177		/* OSSL_SIGNATURE_PARAM_MESSAGE_ENCODING */
178	0	if (ossl_unlikely(r->msgenc != NULL)) {
179	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
180	0	"param %s is repeated", s);
181	0	return 0;
182	0	}
183	0	r->msgenc = (OSSL_PARAM *)p;
184	0	}
185	0	break;
186	0	case 'u':
187	0	switch(s[2]) {
188	0	default:
189	0	break;
190	0	case '\0':
191	0	if (ossl_unlikely(r->mu != NULL)) {
192	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
193	0	"param %s is repeated", s);
194	0	return 0;
195	0	}
196	0	r->mu = (OSSL_PARAM *)p;
197	0	}
198	0	}
199	0	break;
200	0	case 's':
201	0	if (ossl_likely(strcmp("ignature", s + 1) == 0)) {
202		/* OSSL_SIGNATURE_PARAM_SIGNATURE */
203	0	if (ossl_unlikely(r->sig != NULL)) {
204	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
205	0	"param %s is repeated", s);
206	0	return 0;
207	0	}
208	0	r->sig = (OSSL_PARAM *)p;
209	0	}
210	0	break;
211	0	case 't':
212	0	if (ossl_likely(strcmp("est-entropy", s + 1) == 0)) {
213		/* OSSL_SIGNATURE_PARAM_TEST_ENTROPY */
214	0	if (ossl_unlikely(r->ent != NULL)) {
215	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
216	0	"param %s is repeated", s);
217	0	return 0;
218	0	}
219	0	r->ent = (OSSL_PARAM *)p;
220	0	}
221	0	}
222	0	return 1;
223	0	}
224		#endif
225		/* End of machine generated */
226
227		/* Machine generated by util/perl/OpenSSL/paramnames.pm */
228		#ifndef ml_dsa_get_ctx_params_list
229		static const OSSL_PARAM ml_dsa_get_ctx_params_list[] = {
230		OSSL_PARAM_octet_string(OSSL_SIGNATURE_PARAM_ALGORITHM_ID, NULL, 0),
231		OSSL_PARAM_END
232		};
233		#endif
234
235		#ifndef ml_dsa_get_ctx_params_st
236		struct ml_dsa_get_ctx_params_st {
237		OSSL_PARAM *id;
238		};
239		#endif
240
241		#ifndef ml_dsa_get_ctx_params_decoder
242		static int ml_dsa_get_ctx_params_decoder
243		(const OSSL_PARAM p, struct ml_dsa_get_ctx_params_st r)
244	0	{
245	0	const char *s;
246
247	0	memset(r, 0, sizeof(*r));
248	0	if (p != NULL)
249	0	for (; (s = p->key) != NULL; p++)
250	0	if (ossl_likely(strcmp("algorithm-id", s + 0) == 0)) {
251		/* OSSL_SIGNATURE_PARAM_ALGORITHM_ID */
252	0	if (ossl_unlikely(r->id != NULL)) {
253	0	ERR_raise_data(ERR_LIB_PROV, PROV_R_REPEATED_PARAMETER,
254	0	"param %s is repeated", s);
255	0	return 0;
256	0	}
257	0	r->id = (OSSL_PARAM *)p;
258	0	}
259	0	return 1;
260	0	}
261		#endif
262		/* End of machine generated */