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 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 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 135 static void ml_dsa_free_key(void *keydata) 136 { 137 ossl_ml_dsa_key_free((ML_DSA_KEY *)keydata); 138 } 139 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 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 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 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 */ 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 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 }; 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 }; 317 static const OSSL_PARAM *ml_dsa_gettable_params(void *provctx) 318 { 319 return ml_dsa_params; 320 } 321 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 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 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 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 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 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 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 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