1 /*
2 * Copyright 2024-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 #include <openssl/core_dispatch.h>
11 #include <openssl/core_names.h>
12 #include <openssl/evp.h>
13 #include <openssl/param_build.h>
14 #include <openssl/proverr.h>
15 #include <openssl/self_test.h>
16 #include "crypto/ml_dsa.h"
17 #include "internal/fips.h"
18 #include "internal/param_build_set.h"
19 #include "prov/implementations.h"
20 #include "prov/providercommon.h"
21 #include "prov/provider_ctx.h"
22 #include "prov/ml_dsa.h"
23
24 static OSSL_FUNC_keymgmt_free_fn ml_dsa_free_key;
25 static OSSL_FUNC_keymgmt_has_fn ml_dsa_has;
26 static OSSL_FUNC_keymgmt_match_fn ml_dsa_match;
27 static OSSL_FUNC_keymgmt_import_fn ml_dsa_import;
28 static OSSL_FUNC_keymgmt_export_fn ml_dsa_export;
29 static OSSL_FUNC_keymgmt_import_types_fn ml_dsa_imexport_types;
30 static OSSL_FUNC_keymgmt_export_types_fn ml_dsa_imexport_types;
31 static OSSL_FUNC_keymgmt_dup_fn ml_dsa_dup_key;
32 static OSSL_FUNC_keymgmt_get_params_fn ml_dsa_get_params;
33 static OSSL_FUNC_keymgmt_gettable_params_fn ml_dsa_gettable_params;
34 static OSSL_FUNC_keymgmt_validate_fn ml_dsa_validate;
35 static OSSL_FUNC_keymgmt_gen_init_fn ml_dsa_gen_init;
36 static OSSL_FUNC_keymgmt_gen_cleanup_fn ml_dsa_gen_cleanup;
37 static OSSL_FUNC_keymgmt_gen_set_params_fn ml_dsa_gen_set_params;
38 static OSSL_FUNC_keymgmt_gen_settable_params_fn ml_dsa_gen_settable_params;
39 #ifndef FIPS_MODULE
40 static OSSL_FUNC_keymgmt_load_fn ml_dsa_load;
41 #endif
42
43 struct ml_dsa_gen_ctx {
44 PROV_CTX *provctx;
45 char *propq;
46 uint8_t entropy[32];
47 size_t entropy_len;
48 };
49
50 #ifdef FIPS_MODULE
ml_dsa_pairwise_test(const ML_DSA_KEY * key)51 static int ml_dsa_pairwise_test(const ML_DSA_KEY *key)
52 {
53 OSSL_SELF_TEST *st = NULL;
54 OSSL_CALLBACK *cb = NULL;
55 OSSL_LIB_CTX *ctx;
56 void *cbarg = NULL;
57 static const uint8_t msg[] = { 80, 108, 117, 103, 104 };
58 uint8_t rnd[ML_DSA_ENTROPY_LEN];
59 uint8_t sig[ML_DSA_87_SIG_LEN];
60 size_t sig_len = 0;
61 int ret = 0;
62
63 if (!ml_dsa_has(key, OSSL_KEYMGMT_SELECT_KEYPAIR)
64 || ossl_fips_self_testing())
65 return 1;
66
67 /*
68 * The functions `OSSL_SELF_TEST_*` will return directly if parameter `st`
69 * is NULL.
70 */
71 ctx = ossl_ml_dsa_key_get0_libctx(key);
72 OSSL_SELF_TEST_get_callback(ctx, &cb, &cbarg);
73
74 if ((st = OSSL_SELF_TEST_new(cb, cbarg)) == NULL)
75 return 0;
76
77 OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_PCT,
78 OSSL_SELF_TEST_DESC_PCT_ML_DSA);
79
80 memset(rnd, 0, sizeof(rnd));
81 memset(sig, 0, sizeof(sig));
82
83 if (ossl_ml_dsa_sign(key, 0, msg, sizeof(msg), NULL, 0, rnd, sizeof(rnd), 0,
84 sig, &sig_len, sizeof(sig)) <= 0)
85 goto err;
86
87 OSSL_SELF_TEST_oncorrupt_byte(st, sig);
88
89 if (ossl_ml_dsa_verify(key, 0, msg, sizeof(msg), NULL, 0, 0,
90 sig, sig_len) <= 0)
91 goto err;
92
93 ret = 1;
94 err:
95 OSSL_SELF_TEST_onend(st, ret);
96 OSSL_SELF_TEST_free(st);
97 return ret;
98 }
99 #endif
100
ossl_prov_ml_dsa_new(PROV_CTX * ctx,const char * propq,int evp_type)101 ML_DSA_KEY *ossl_prov_ml_dsa_new(PROV_CTX *ctx, const char *propq, int evp_type)
102 {
103 ML_DSA_KEY *key;
104
105 if (!ossl_prov_is_running())
106 return 0;
107
108 key = ossl_ml_dsa_key_new(PROV_LIBCTX_OF(ctx), propq, evp_type);
109 /*
110 * When decoding, if the key ends up "loaded" into the same provider, these
111 * are the correct config settings, otherwise, new values will be assigned
112 * on import into a different provider. The "load" API does not pass along
113 * the provider context.
114 */
115 if (key != NULL) {
116 int flags_set = 0, flags_clr = 0;
117
118 if (ossl_prov_ctx_get_bool_param(
119 ctx, OSSL_PKEY_PARAM_ML_DSA_RETAIN_SEED, 1))
120 flags_set |= ML_DSA_KEY_RETAIN_SEED;
121 else
122 flags_clr = ML_DSA_KEY_RETAIN_SEED;
123
124 if (ossl_prov_ctx_get_bool_param(
125 ctx, OSSL_PKEY_PARAM_ML_DSA_PREFER_SEED, 1))
126 flags_set |= ML_DSA_KEY_PREFER_SEED;
127 else
128 flags_clr |= ML_DSA_KEY_PREFER_SEED;
129
130 ossl_ml_dsa_set_prekey(key, flags_set, flags_clr, NULL, 0, NULL, 0);
131 }
132 return key;
133 }
134
ml_dsa_free_key(void * keydata)135 static void ml_dsa_free_key(void *keydata)
136 {
137 ossl_ml_dsa_key_free((ML_DSA_KEY *)keydata);
138 }
139
ml_dsa_dup_key(const void * keydata_from,int selection)140 static void *ml_dsa_dup_key(const void *keydata_from, int selection)
141 {
142 if (ossl_prov_is_running())
143 return ossl_ml_dsa_key_dup(keydata_from, selection);
144 return NULL;
145 }
146
ml_dsa_has(const void * keydata,int selection)147 static int ml_dsa_has(const void *keydata, int selection)
148 {
149 const ML_DSA_KEY *key = keydata;
150
151 if (!ossl_prov_is_running() || key == NULL)
152 return 0;
153 if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
154 return 1; /* the selection is not missing */
155
156 return ossl_ml_dsa_key_has(key, selection);
157 }
158
ml_dsa_match(const void * keydata1,const void * keydata2,int selection)159 static int ml_dsa_match(const void *keydata1, const void *keydata2, int selection)
160 {
161 const ML_DSA_KEY *key1 = keydata1;
162 const ML_DSA_KEY *key2 = keydata2;
163
164 if (!ossl_prov_is_running())
165 return 0;
166 if (key1 == NULL || key2 == NULL)
167 return 0;
168 return ossl_ml_dsa_key_equal(key1, key2, selection);
169 }
170
ml_dsa_validate(const void * key_data,int selection,int check_type)171 static int ml_dsa_validate(const void *key_data, int selection, int check_type)
172 {
173 const ML_DSA_KEY *key = key_data;
174
175 if (!ml_dsa_has(key, selection))
176 return 0;
177
178 if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == OSSL_KEYMGMT_SELECT_KEYPAIR)
179 return ossl_ml_dsa_key_pairwise_check(key);
180 return 1;
181 }
182
183 /**
184 * @brief Load a ML_DSA key from raw data.
185 *
186 * @param key An ML_DSA key to load into
187 * @param params An array of parameters containing key data.
188 * @param include_private Set to 1 to optionally include the private key data
189 * if it exists.
190 * @returns 1 on success, or 0 on failure.
191 */
ml_dsa_key_fromdata(ML_DSA_KEY * key,const OSSL_PARAM params[],int include_private)192 static int ml_dsa_key_fromdata(ML_DSA_KEY *key, const OSSL_PARAM params[],
193 int include_private)
194 {
195 const OSSL_PARAM *p = NULL;
196 const ML_DSA_PARAMS *key_params = ossl_ml_dsa_key_params(key);
197 const uint8_t *pk = NULL, *sk = NULL, *seed = NULL;
198 size_t pk_len = 0, sk_len = 0, seed_len = 0;
199
200 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY);
201 if (p != NULL
202 && !OSSL_PARAM_get_octet_string_ptr(p, (const void **)&pk, &pk_len))
203 return 0;
204 if (pk != NULL && pk_len != key_params->pk_len) {
205 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH,
206 "Invalid %s public key length", key_params->alg);
207 return 0;
208 }
209
210 /* Private key is optional */
211 if (include_private) {
212 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ML_DSA_SEED);
213 if (p != NULL
214 && !OSSL_PARAM_get_octet_string_ptr(p, (const void **)&seed,
215 &seed_len))
216 return 0;
217 if (seed != NULL && seed_len != ML_DSA_SEED_BYTES) {
218 ERR_raise(ERR_LIB_PROV, PROV_R_INVALID_SEED_LENGTH);
219 return 0;
220 }
221 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY);
222 if (p != NULL
223 && !OSSL_PARAM_get_octet_string_ptr(p, (const void **)&sk, &sk_len))
224 return 0;
225 if (sk != NULL && sk_len != key_params->sk_len) {
226 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY_LENGTH,
227 "Invalid %s private key length", key_params->alg);
228 return 0;
229 }
230 }
231
232 /* The caller MUST specify at least one of seed, private or public keys. */
233 if (seed_len == 0 && pk_len == 0 && sk_len == 0) {
234 ERR_raise(ERR_LIB_PROV, PROV_R_MISSING_KEY);
235 return 0;
236 }
237
238 if (seed_len != 0
239 && (sk_len == 0
240 || (ossl_ml_dsa_key_get_prov_flags(key) & ML_DSA_KEY_PREFER_SEED))) {
241 if (!ossl_ml_dsa_set_prekey(key, 0, 0, seed, seed_len, sk, sk_len))
242 return 0;
243 if (!ossl_ml_dsa_generate_key(key)) {
244 ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GENERATE_KEY);
245 return 0;
246 }
247 } else if (sk_len > 0) {
248 if (!ossl_ml_dsa_sk_decode(key, sk, sk_len))
249 return 0;
250 } else if (pk_len > 0) {
251 if (!ossl_ml_dsa_pk_decode(key, pk, pk_len))
252 return 0;
253 }
254
255 /* Error if the supplied public key does not match the generated key */
256 if (pk_len == 0
257 || seed_len + sk_len == 0
258 || memcmp(ossl_ml_dsa_key_get_pub(key), pk, pk_len) == 0)
259 return 1;
260 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY,
261 "explicit %s public key does not match private",
262 key_params->alg);
263 ossl_ml_dsa_key_reset(key);
264 return 0;
265 }
266
ml_dsa_import(void * keydata,int selection,const OSSL_PARAM params[])267 static int ml_dsa_import(void *keydata, int selection, const OSSL_PARAM params[])
268 {
269 ML_DSA_KEY *key = keydata;
270 int include_priv;
271 int res;
272
273 if (!ossl_prov_is_running() || key == NULL)
274 return 0;
275
276 if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
277 return 0;
278
279 include_priv = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);
280 res = ml_dsa_key_fromdata(key, params, include_priv);
281 #ifdef FIPS_MODULE
282 if (res > 0) {
283 res = ml_dsa_pairwise_test(key);
284 if (!res) {
285 ossl_ml_dsa_key_reset(key);
286 ossl_set_error_state(OSSL_SELF_TEST_TYPE_PCT_IMPORT);
287 }
288 }
289 #endif /* FIPS_MODULE */
290 return res;
291 }
292
293 #define ML_DSA_IMEXPORTABLE_PARAMETERS \
294 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0), \
295 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0), \
296 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0)
297
298 static const OSSL_PARAM ml_dsa_key_types[] = {
299 ML_DSA_IMEXPORTABLE_PARAMETERS,
300 OSSL_PARAM_END
301 };
ml_dsa_imexport_types(int selection)302 static const OSSL_PARAM *ml_dsa_imexport_types(int selection)
303 {
304 if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
305 return NULL;
306 return ml_dsa_key_types;
307 }
308
309 static const OSSL_PARAM ml_dsa_params[] = {
310 OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL),
311 OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL),
312 OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL),
313 OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0),
314 ML_DSA_IMEXPORTABLE_PARAMETERS,
315 OSSL_PARAM_END
316 };
ml_dsa_gettable_params(void * provctx)317 static const OSSL_PARAM *ml_dsa_gettable_params(void *provctx)
318 {
319 return ml_dsa_params;
320 }
321
ml_dsa_get_params(void * keydata,OSSL_PARAM params[])322 static int ml_dsa_get_params(void *keydata, OSSL_PARAM params[])
323 {
324 ML_DSA_KEY *key = keydata;
325 OSSL_PARAM *p;
326 const uint8_t *pub, *priv, *seed;
327
328 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL
329 && !OSSL_PARAM_set_int(p, 8 * ossl_ml_dsa_key_get_pub_len(key)))
330 return 0;
331 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL
332 && !OSSL_PARAM_set_int(p, ossl_ml_dsa_key_get_collision_strength_bits(key)))
333 return 0;
334 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL
335 && !OSSL_PARAM_set_int(p, ossl_ml_dsa_key_get_sig_len(key)))
336 return 0;
337
338 pub = ossl_ml_dsa_key_get_pub(key);
339 priv = ossl_ml_dsa_key_get_priv(key);
340 seed = ossl_ml_dsa_key_get_seed(key);
341
342 if (seed != NULL
343 && (p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_ML_DSA_SEED)) != NULL
344 && !OSSL_PARAM_set_octet_string(p, seed, ML_DSA_SEED_BYTES))
345 return 0;
346 if (priv != NULL
347 && (p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PRIV_KEY)) != NULL
348 && !OSSL_PARAM_set_octet_string(p, priv,
349 ossl_ml_dsa_key_get_priv_len(key)))
350 return 0;
351 if (pub != NULL
352 && (p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY)) != NULL
353 && !OSSL_PARAM_set_octet_string(p, pub,
354 ossl_ml_dsa_key_get_pub_len(key)))
355 return 0;
356 /*
357 * This allows apps to use an empty digest, so that the old API
358 * for digest signing can be used.
359 */
360 p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MANDATORY_DIGEST);
361 if (p != NULL && !OSSL_PARAM_set_utf8_string(p, ""))
362 return 0;
363
364 return 1;
365 }
366
ml_dsa_export(void * keydata,int selection,OSSL_CALLBACK * param_cb,void * cbarg)367 static int ml_dsa_export(void *keydata, int selection,
368 OSSL_CALLBACK *param_cb, void *cbarg)
369 {
370 ML_DSA_KEY *key = keydata;
371 OSSL_PARAM params[4];
372 const uint8_t *buf;
373 int include_private, pnum = 0;
374
375 if (!ossl_prov_is_running() || key == NULL)
376 return 0;
377
378 if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0)
379 return 0;
380
381 include_private = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0);
382
383 /*
384 * Note that if the seed is present, both the seed and the private key are
385 * exported. The recipient will have a choice.
386 */
387 if (include_private) {
388 if ((buf = ossl_ml_dsa_key_get_seed(key)) != NULL) {
389 params[pnum++] = OSSL_PARAM_construct_octet_string
390 (OSSL_PKEY_PARAM_ML_DSA_SEED, (void *)buf, ML_DSA_SEED_BYTES);
391 }
392 if ((buf = ossl_ml_dsa_key_get_priv(key)) != NULL) {
393 params[pnum++] = OSSL_PARAM_construct_octet_string
394 (OSSL_PKEY_PARAM_PRIV_KEY, (void *)buf,
395 ossl_ml_dsa_key_get_priv_len(key));
396 }
397 }
398 if (((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0)
399 && ((buf = ossl_ml_dsa_key_get_pub(key)) != NULL)) {
400 params[pnum++] = OSSL_PARAM_construct_octet_string
401 (OSSL_PKEY_PARAM_PUB_KEY, (void *)buf,
402 ossl_ml_dsa_key_get_pub_len(key));
403 }
404 if (pnum == 0)
405 return 0;
406 params[pnum] = OSSL_PARAM_construct_end();
407 return param_cb(params, cbarg);
408 }
409
410 #ifndef FIPS_MODULE
ml_dsa_load(const void * reference,size_t reference_sz)411 static void *ml_dsa_load(const void *reference, size_t reference_sz)
412 {
413 ML_DSA_KEY *key = NULL;
414 const ML_DSA_PARAMS *key_params;
415 const uint8_t *sk, *seed;
416
417 if (ossl_prov_is_running() && reference_sz == sizeof(key)) {
418 /* The contents of the reference is the address to our object */
419 key = *(ML_DSA_KEY **)reference;
420 /* We grabbed, so we detach it */
421 *(ML_DSA_KEY **)reference = NULL;
422 /* All done, if the pubkey is present. */
423 if (key == NULL || ossl_ml_dsa_key_get_pub(key) != NULL)
424 return key;
425 /* Handle private prekey inputs. */
426 sk = ossl_ml_dsa_key_get_priv(key);
427 seed = ossl_ml_dsa_key_get_seed(key);
428 if (seed != NULL
429 && (sk == NULL || (ossl_ml_dsa_key_get_prov_flags(key)
430 & ML_DSA_KEY_PREFER_SEED))) {
431 if (ossl_ml_dsa_generate_key(key))
432 return key;
433 } else if (sk != NULL) {
434 if (ossl_ml_dsa_sk_decode(key, sk,
435 ossl_ml_dsa_key_get_priv_len(key)))
436 return key;
437 key_params = ossl_ml_dsa_key_params(key);
438 ERR_raise_data(ERR_LIB_PROV, PROV_R_INVALID_KEY,
439 "error parsing %s private key",
440 key_params->alg);
441 } else {
442 return key;
443 }
444 }
445
446 ossl_ml_dsa_key_free(key);
447 return NULL;
448 }
449 #endif
450
ml_dsa_gen_init(void * provctx,int selection,const OSSL_PARAM params[])451 static void *ml_dsa_gen_init(void *provctx, int selection,
452 const OSSL_PARAM params[])
453 {
454 struct ml_dsa_gen_ctx *gctx = NULL;
455
456 if (!ossl_prov_is_running())
457 return NULL;
458
459 if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL) {
460 gctx->provctx = provctx;
461 if (!ml_dsa_gen_set_params(gctx, params)) {
462 OPENSSL_free(gctx);
463 gctx = NULL;
464 }
465 }
466 return gctx;
467 }
468
ml_dsa_gen(void * genctx,int evp_type)469 static void *ml_dsa_gen(void *genctx, int evp_type)
470 {
471 struct ml_dsa_gen_ctx *gctx = genctx;
472 ML_DSA_KEY *key = NULL;
473
474 if (!ossl_prov_is_running())
475 return NULL;
476 key = ossl_prov_ml_dsa_new(gctx->provctx, gctx->propq, evp_type);
477 if (key == NULL)
478 return NULL;
479 if (gctx->entropy_len != 0
480 && !ossl_ml_dsa_set_prekey(key, 0, 0,
481 gctx->entropy, gctx->entropy_len, NULL, 0))
482 goto err;
483 if (!ossl_ml_dsa_generate_key(key)) {
484 ERR_raise(ERR_LIB_PROV, PROV_R_FAILED_TO_GENERATE_KEY);
485 goto err;
486 }
487 #ifdef FIPS_MODULE
488 if (!ml_dsa_pairwise_test(key)) {
489 ossl_set_error_state(OSSL_SELF_TEST_TYPE_PCT);
490 goto err;
491 }
492 #endif
493 return key;
494 err:
495 ossl_ml_dsa_key_free(key);
496 return NULL;
497 }
498
ml_dsa_gen_set_params(void * genctx,const OSSL_PARAM params[])499 static int ml_dsa_gen_set_params(void *genctx, const OSSL_PARAM params[])
500 {
501 struct ml_dsa_gen_ctx *gctx = genctx;
502 const OSSL_PARAM *p;
503
504 if (gctx == NULL)
505 return 0;
506
507 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_ML_DSA_SEED);
508 if (p != NULL) {
509 void *vp = gctx->entropy;
510 size_t len = sizeof(gctx->entropy);
511
512 if (!OSSL_PARAM_get_octet_string(p, &vp, len, &(gctx->entropy_len))) {
513 gctx->entropy_len = 0;
514 return 0;
515 }
516 }
517
518 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PROPERTIES);
519 if (p != NULL) {
520 OPENSSL_free(gctx->propq);
521 gctx->propq = NULL;
522 if (!OSSL_PARAM_get_utf8_string(p, &gctx->propq, 0))
523 return 0;
524 }
525 return 1;
526 }
527
ml_dsa_gen_settable_params(ossl_unused void * genctx,ossl_unused void * provctx)528 static const OSSL_PARAM *ml_dsa_gen_settable_params(ossl_unused void *genctx,
529 ossl_unused void *provctx)
530 {
531 static OSSL_PARAM settable[] = {
532 OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0),
533 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_ML_DSA_SEED, NULL, 0),
534 OSSL_PARAM_END
535 };
536 return settable;
537 }
538
ml_dsa_gen_cleanup(void * genctx)539 static void ml_dsa_gen_cleanup(void *genctx)
540 {
541 struct ml_dsa_gen_ctx *gctx = genctx;
542
543 if (gctx == NULL)
544 return;
545
546 OPENSSL_cleanse(gctx->entropy, gctx->entropy_len);
547 OPENSSL_free(gctx->propq);
548 OPENSSL_free(gctx);
549 }
550
551 #ifndef FIPS_MODULE
552 # define DISPATCH_LOAD_FN \
553 { OSSL_FUNC_KEYMGMT_LOAD, (OSSL_FUNC) ml_dsa_load },
554 #else
555 # define DISPATCH_LOAD_FN /* Non-FIPS only */
556 #endif
557
558 #define MAKE_KEYMGMT_FUNCTIONS(alg) \
559 static OSSL_FUNC_keymgmt_new_fn ml_dsa_##alg##_new_key; \
560 static OSSL_FUNC_keymgmt_gen_fn ml_dsa_##alg##_gen; \
561 static void *ml_dsa_##alg##_new_key(void *provctx) \
562 { \
563 return ossl_prov_ml_dsa_new(provctx, NULL, EVP_PKEY_ML_DSA_##alg); \
564 } \
565 static void *ml_dsa_##alg##_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg)\
566 { \
567 return ml_dsa_gen(genctx, EVP_PKEY_ML_DSA_##alg); \
568 } \
569 const OSSL_DISPATCH ossl_ml_dsa_##alg##_keymgmt_functions[] = { \
570 { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))ml_dsa_##alg##_new_key }, \
571 { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))ml_dsa_free_key }, \
572 { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))ml_dsa_has }, \
573 { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))ml_dsa_match }, \
574 { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))ml_dsa_import }, \
575 { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))ml_dsa_imexport_types },\
576 { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))ml_dsa_export }, \
577 { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))ml_dsa_imexport_types },\
578 DISPATCH_LOAD_FN \
579 { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*) (void))ml_dsa_get_params }, \
580 { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*) (void))ml_dsa_gettable_params },\
581 { OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))ml_dsa_validate }, \
582 { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))ml_dsa_gen_init }, \
583 { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))ml_dsa_##alg##_gen }, \
584 { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))ml_dsa_gen_cleanup }, \
585 { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, \
586 (void (*)(void))ml_dsa_gen_set_params }, \
587 { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS, \
588 (void (*)(void))ml_dsa_gen_settable_params }, \
589 { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))ml_dsa_dup_key }, \
590 OSSL_DISPATCH_END \
591 }
592
593 MAKE_KEYMGMT_FUNCTIONS(44);
594 MAKE_KEYMGMT_FUNCTIONS(65);
595 MAKE_KEYMGMT_FUNCTIONS(87);
596