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