/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 */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#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 */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#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 */
#include <string.h>
#include <openssl/params.h>
#include "internal/common.h"
#include "prov/proverr.h"

#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: 2026-05-30 06:06

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