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/param_build.h> 13 #include <openssl/self_test.h> 14 #include <openssl/proverr.h> 15 #include "crypto/slh_dsa.h" 16 #include "internal/fips.h" 17 #include "internal/param_build_set.h" 18 #include "prov/implementations.h" 19 #include "prov/providercommon.h" 20 #include "prov/provider_ctx.h" 21 22 #ifdef FIPS_MODULE 23 static int slh_dsa_fips140_pairwise_test(const SLH_DSA_KEY *key, 24 SLH_DSA_HASH_CTX *ctx); 25 #endif /* FIPS_MODULE */ 26 27 static OSSL_FUNC_keymgmt_free_fn slh_dsa_free_key; 28 static OSSL_FUNC_keymgmt_has_fn slh_dsa_has; 29 static OSSL_FUNC_keymgmt_match_fn slh_dsa_match; 30 static OSSL_FUNC_keymgmt_import_fn slh_dsa_import; 31 static OSSL_FUNC_keymgmt_export_fn slh_dsa_export; 32 static OSSL_FUNC_keymgmt_import_types_fn slh_dsa_imexport_types; 33 static OSSL_FUNC_keymgmt_export_types_fn slh_dsa_imexport_types; 34 static OSSL_FUNC_keymgmt_load_fn slh_dsa_load; 35 static OSSL_FUNC_keymgmt_get_params_fn slh_dsa_get_params; 36 static OSSL_FUNC_keymgmt_gettable_params_fn slh_dsa_gettable_params; 37 static OSSL_FUNC_keymgmt_validate_fn slh_dsa_validate; 38 static OSSL_FUNC_keymgmt_gen_init_fn slh_dsa_gen_init; 39 static OSSL_FUNC_keymgmt_gen_cleanup_fn slh_dsa_gen_cleanup; 40 static OSSL_FUNC_keymgmt_gen_set_params_fn slh_dsa_gen_set_params; 41 static OSSL_FUNC_keymgmt_gen_settable_params_fn slh_dsa_gen_settable_params; 42 static OSSL_FUNC_keymgmt_dup_fn slh_dsa_dup_key; 43 44 #define SLH_DSA_POSSIBLE_SELECTIONS (OSSL_KEYMGMT_SELECT_KEYPAIR) 45 46 struct slh_dsa_gen_ctx { 47 SLH_DSA_HASH_CTX *ctx; 48 OSSL_LIB_CTX *libctx; 49 char *propq; 50 uint8_t entropy[SLH_DSA_MAX_N * 3]; 51 size_t entropy_len; 52 }; 53 54 static void *slh_dsa_new_key(void *provctx, const char *alg) 55 { 56 if (!ossl_prov_is_running()) 57 return 0; 58 59 return ossl_slh_dsa_key_new(PROV_LIBCTX_OF(provctx), NULL, alg); 60 } 61 62 static void slh_dsa_free_key(void *keydata) 63 { 64 ossl_slh_dsa_key_free((SLH_DSA_KEY *)keydata); 65 } 66 67 static void *slh_dsa_dup_key(const void *keydata_from, int selection) 68 { 69 if (ossl_prov_is_running()) 70 return ossl_slh_dsa_key_dup(keydata_from, selection); 71 return NULL; 72 } 73 74 static int slh_dsa_has(const void *keydata, int selection) 75 { 76 const SLH_DSA_KEY *key = keydata; 77 78 if (!ossl_prov_is_running() || key == NULL) 79 return 0; 80 if ((selection & SLH_DSA_POSSIBLE_SELECTIONS) == 0) 81 return 1; /* the selection is not missing */ 82 83 return ossl_slh_dsa_key_has(key, selection); 84 } 85 86 static int slh_dsa_match(const void *keydata1, const void *keydata2, int selection) 87 { 88 const SLH_DSA_KEY *key1 = keydata1; 89 const SLH_DSA_KEY *key2 = keydata2; 90 91 if (!ossl_prov_is_running()) 92 return 0; 93 if (key1 == NULL || key2 == NULL) 94 return 0; 95 return ossl_slh_dsa_key_equal(key1, key2, selection); 96 } 97 98 static int slh_dsa_validate(const void *key_data, int selection, int check_type) 99 { 100 const SLH_DSA_KEY *key = key_data; 101 102 if (!slh_dsa_has(key, selection)) 103 return 0; 104 105 if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == OSSL_KEYMGMT_SELECT_KEYPAIR) 106 return ossl_slh_dsa_key_pairwise_check(key); 107 return 1; 108 } 109 110 static int slh_dsa_import(void *keydata, int selection, const OSSL_PARAM params[]) 111 { 112 SLH_DSA_KEY *key = keydata; 113 int include_priv; 114 115 if (!ossl_prov_is_running() || key == NULL) 116 return 0; 117 118 if ((selection & SLH_DSA_POSSIBLE_SELECTIONS) == 0) 119 return 0; 120 121 include_priv = ((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0); 122 return ossl_slh_dsa_key_fromdata(key, params, include_priv); 123 } 124 125 #define SLH_DSA_IMEXPORTABLE_PARAMETERS \ 126 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PUB_KEY, NULL, 0), \ 127 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_PRIV_KEY, NULL, 0) 128 129 static const OSSL_PARAM slh_dsa_key_types[] = { 130 SLH_DSA_IMEXPORTABLE_PARAMETERS, 131 OSSL_PARAM_END 132 }; 133 static const OSSL_PARAM *slh_dsa_imexport_types(int selection) 134 { 135 if ((selection & SLH_DSA_POSSIBLE_SELECTIONS) == 0) 136 return NULL; 137 return slh_dsa_key_types; 138 } 139 140 static const OSSL_PARAM slh_dsa_params[] = { 141 OSSL_PARAM_int(OSSL_PKEY_PARAM_BITS, NULL), 142 OSSL_PARAM_int(OSSL_PKEY_PARAM_SECURITY_BITS, NULL), 143 OSSL_PARAM_int(OSSL_PKEY_PARAM_MAX_SIZE, NULL), 144 OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_MANDATORY_DIGEST, NULL, 0), 145 SLH_DSA_IMEXPORTABLE_PARAMETERS, 146 OSSL_PARAM_END 147 }; 148 static const OSSL_PARAM *slh_dsa_gettable_params(void *provctx) 149 { 150 return slh_dsa_params; 151 } 152 153 static int key_to_params(SLH_DSA_KEY *key, OSSL_PARAM_BLD *tmpl, 154 int selection) 155 { 156 /* Error if there is no key or public key */ 157 if (key == NULL || ossl_slh_dsa_key_get_pub(key) == NULL) 158 return 0; 159 160 if (((selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) 161 && ossl_slh_dsa_key_get_priv(key) != NULL) 162 if (ossl_param_build_set_octet_string(tmpl, NULL, 163 OSSL_PKEY_PARAM_PRIV_KEY, 164 ossl_slh_dsa_key_get_priv(key), 165 ossl_slh_dsa_key_get_priv_len(key)) 166 != 1) 167 return 0; 168 169 if ((selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) == 0) 170 return 1; 171 172 return ossl_param_build_set_octet_string(tmpl, NULL, 173 OSSL_PKEY_PARAM_PUB_KEY, 174 ossl_slh_dsa_key_get_pub(key), 175 ossl_slh_dsa_key_get_pub_len(key)); 176 } 177 178 static int slh_dsa_get_params(void *keydata, OSSL_PARAM params[]) 179 { 180 SLH_DSA_KEY *key = keydata; 181 OSSL_PARAM *p; 182 const uint8_t *pub, *priv; 183 184 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_BITS)) != NULL 185 && !OSSL_PARAM_set_int(p, 8 * ossl_slh_dsa_key_get_pub_len(key))) 186 return 0; 187 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_SECURITY_BITS)) != NULL 188 && !OSSL_PARAM_set_int(p, 8 * ossl_slh_dsa_key_get_n(key))) 189 return 0; 190 if ((p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MAX_SIZE)) != NULL 191 && !OSSL_PARAM_set_int(p, ossl_slh_dsa_key_get_sig_len(key))) 192 return 0; 193 194 priv = ossl_slh_dsa_key_get_priv(key); 195 if (priv != NULL) { 196 p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PRIV_KEY); 197 /* Note: ossl_slh_dsa_key_get_priv_len() includes the public key */ 198 if (p != NULL 199 && !OSSL_PARAM_set_octet_string(p, priv, 200 ossl_slh_dsa_key_get_priv_len(key))) 201 return 0; 202 } 203 pub = ossl_slh_dsa_key_get_pub(key); 204 if (pub != NULL) { 205 p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_PUB_KEY); 206 if (p != NULL 207 && !OSSL_PARAM_set_octet_string(p, pub, 208 ossl_slh_dsa_key_get_pub_len(key))) 209 return 0; 210 } 211 /* 212 * This allows apps to use an empty digest, so that the old API 213 * for digest signing can be used. 214 */ 215 p = OSSL_PARAM_locate(params, OSSL_PKEY_PARAM_MANDATORY_DIGEST); 216 if (p != NULL && !OSSL_PARAM_set_utf8_string(p, "")) 217 return 0; 218 return 1; 219 } 220 221 static int slh_dsa_export(void *keydata, int selection, OSSL_CALLBACK *param_cb, 222 void *cbarg) 223 { 224 SLH_DSA_KEY *key = keydata; 225 OSSL_PARAM_BLD *tmpl; 226 OSSL_PARAM *params = NULL; 227 int ret = 0; 228 229 if (!ossl_prov_is_running() || key == NULL) 230 return 0; 231 232 if ((selection & OSSL_KEYMGMT_SELECT_KEYPAIR) == 0) 233 return 0; 234 235 tmpl = OSSL_PARAM_BLD_new(); 236 if (tmpl == NULL) 237 return 0; 238 239 if (!key_to_params(key, tmpl, selection)) 240 goto err; 241 242 params = OSSL_PARAM_BLD_to_param(tmpl); 243 if (params == NULL) 244 goto err; 245 246 ret = param_cb(params, cbarg); 247 OSSL_PARAM_free(params); 248 err: 249 OSSL_PARAM_BLD_free(tmpl); 250 return ret; 251 } 252 253 static void *slh_dsa_load(const void *reference, size_t reference_sz) 254 { 255 SLH_DSA_KEY *key = NULL; 256 257 if (ossl_prov_is_running() && reference_sz == sizeof(key)) { 258 /* The contents of the reference is the address to our object */ 259 key = *(SLH_DSA_KEY **)reference; 260 /* We grabbed, so we detach it */ 261 *(SLH_DSA_KEY **)reference = NULL; 262 return key; 263 } 264 return NULL; 265 } 266 267 static void *slh_dsa_gen_init(void *provctx, int selection, 268 const OSSL_PARAM params[]) 269 { 270 OSSL_LIB_CTX *libctx = PROV_LIBCTX_OF(provctx); 271 struct slh_dsa_gen_ctx *gctx = NULL; 272 273 if (!ossl_prov_is_running()) 274 return NULL; 275 276 if ((gctx = OPENSSL_zalloc(sizeof(*gctx))) != NULL) { 277 gctx->libctx = libctx; 278 if (!slh_dsa_gen_set_params(gctx, params)) { 279 OPENSSL_free(gctx); 280 gctx = NULL; 281 } 282 } 283 return gctx; 284 } 285 286 #ifdef FIPS_MODULE 287 /* 288 * Refer to FIPS 140-3 IG 10.3.A Additional Comment 1 289 * Perform a pairwise test for SLH_DSA by signing and verifying a signature. 290 */ 291 static int slh_dsa_fips140_pairwise_test(const SLH_DSA_KEY *key, 292 SLH_DSA_HASH_CTX *ctx) 293 { 294 int ret = 0; 295 OSSL_SELF_TEST *st = NULL; 296 OSSL_CALLBACK *cb = NULL; 297 void *cb_arg = NULL; 298 uint8_t msg[16] = { 0 }; 299 size_t msg_len = sizeof(msg); 300 uint8_t *sig = NULL; 301 size_t sig_len; 302 OSSL_LIB_CTX *lib_ctx; 303 int alloc_ctx = 0; 304 305 /* During self test, it is a waste to do this test */ 306 if (ossl_fips_self_testing()) 307 return 1; 308 309 if (ctx == NULL) { 310 ctx = ossl_slh_dsa_hash_ctx_new(key); 311 if (ctx == NULL) 312 return 0; 313 alloc_ctx = 1; 314 } 315 lib_ctx = ossl_slh_dsa_key_get0_libctx(key); 316 317 OSSL_SELF_TEST_get_callback(lib_ctx, &cb, &cb_arg); 318 st = OSSL_SELF_TEST_new(cb, cb_arg); 319 if (st == NULL) 320 goto err; 321 322 OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_PCT, 323 OSSL_SELF_TEST_DESC_PCT_SLH_DSA); 324 325 sig_len = ossl_slh_dsa_key_get_sig_len(key); 326 sig = OPENSSL_malloc(sig_len); 327 if (sig == NULL) 328 goto err; 329 330 if (ossl_slh_dsa_sign(ctx, msg, msg_len, NULL, 0, NULL, 0, 331 sig, &sig_len, sig_len) 332 != 1) 333 goto err; 334 335 OSSL_SELF_TEST_oncorrupt_byte(st, sig); 336 337 if (ossl_slh_dsa_verify(ctx, msg, msg_len, NULL, 0, 0, sig, sig_len) != 1) 338 goto err; 339 340 ret = 1; 341 err: 342 if (alloc_ctx) 343 ossl_slh_dsa_hash_ctx_free(ctx); 344 OPENSSL_free(sig); 345 OSSL_SELF_TEST_onend(st, ret); 346 OSSL_SELF_TEST_free(st); 347 return ret; 348 } 349 #endif /* FIPS_MODULE */ 350 351 static void *slh_dsa_gen(void *genctx, const char *alg) 352 { 353 struct slh_dsa_gen_ctx *gctx = genctx; 354 SLH_DSA_KEY *key = NULL; 355 SLH_DSA_HASH_CTX *ctx = NULL; 356 357 if (!ossl_prov_is_running()) 358 return NULL; 359 key = ossl_slh_dsa_key_new(gctx->libctx, gctx->propq, alg); 360 if (key == NULL) 361 return NULL; 362 ctx = ossl_slh_dsa_hash_ctx_new(key); 363 if (ctx == NULL) 364 goto err; 365 if (!ossl_slh_dsa_generate_key(ctx, key, gctx->libctx, 366 gctx->entropy, gctx->entropy_len)) 367 goto err; 368 #ifdef FIPS_MODULE 369 if (!slh_dsa_fips140_pairwise_test(key, ctx)) { 370 ossl_set_error_state(OSSL_SELF_TEST_TYPE_PCT); 371 goto err; 372 } 373 #endif /* FIPS_MODULE */ 374 ossl_slh_dsa_hash_ctx_free(ctx); 375 return key; 376 err: 377 ossl_slh_dsa_hash_ctx_free(ctx); 378 ossl_slh_dsa_key_free(key); 379 return NULL; 380 } 381 382 static int slh_dsa_gen_set_params(void *genctx, const OSSL_PARAM params[]) 383 { 384 struct slh_dsa_gen_ctx *gctx = genctx; 385 const OSSL_PARAM *p; 386 387 if (gctx == NULL) 388 return 0; 389 390 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_SLH_DSA_SEED); 391 if (p != NULL) { 392 void *vp = gctx->entropy; 393 size_t len = sizeof(gctx->entropy); 394 395 if (!OSSL_PARAM_get_octet_string(p, &vp, len, &(gctx->entropy_len))) { 396 gctx->entropy_len = 0; 397 return 0; 398 } 399 } 400 401 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PROPERTIES); 402 if (p != NULL) { 403 if (p->data_type != OSSL_PARAM_UTF8_STRING) 404 return 0; 405 OPENSSL_free(gctx->propq); 406 gctx->propq = OPENSSL_strdup(p->data); 407 if (gctx->propq == NULL) 408 return 0; 409 } 410 return 1; 411 } 412 413 static const OSSL_PARAM *slh_dsa_gen_settable_params(ossl_unused void *genctx, 414 ossl_unused void *provctx) 415 { 416 static OSSL_PARAM settable[] = { 417 OSSL_PARAM_utf8_string(OSSL_PKEY_PARAM_PROPERTIES, NULL, 0), 418 OSSL_PARAM_octet_string(OSSL_PKEY_PARAM_SLH_DSA_SEED, NULL, 0), 419 OSSL_PARAM_END 420 }; 421 return settable; 422 } 423 424 static void slh_dsa_gen_cleanup(void *genctx) 425 { 426 struct slh_dsa_gen_ctx *gctx = genctx; 427 428 if (gctx == NULL) 429 return; 430 431 OPENSSL_cleanse(gctx->entropy, gctx->entropy_len); 432 OPENSSL_free(gctx->propq); 433 OPENSSL_free(gctx); 434 } 435 436 #define MAKE_KEYMGMT_FUNCTIONS(alg, fn) \ 437 static OSSL_FUNC_keymgmt_new_fn slh_dsa_##fn##_new_key; \ 438 static OSSL_FUNC_keymgmt_gen_fn slh_dsa_##fn##_gen; \ 439 static void *slh_dsa_##fn##_new_key(void *provctx) \ 440 { \ 441 return slh_dsa_new_key(provctx, alg); \ 442 } \ 443 static void *slh_dsa_##fn##_gen(void *genctx, OSSL_CALLBACK *osslcb, void *cbarg) \ 444 { \ 445 return slh_dsa_gen(genctx, alg); \ 446 } \ 447 const OSSL_DISPATCH ossl_slh_dsa_##fn##_keymgmt_functions[] = { \ 448 { OSSL_FUNC_KEYMGMT_NEW, (void (*)(void))slh_dsa_##fn##_new_key }, \ 449 { OSSL_FUNC_KEYMGMT_FREE, (void (*)(void))slh_dsa_free_key }, \ 450 { OSSL_FUNC_KEYMGMT_DUP, (void (*)(void))slh_dsa_dup_key }, \ 451 { OSSL_FUNC_KEYMGMT_HAS, (void (*)(void))slh_dsa_has }, \ 452 { OSSL_FUNC_KEYMGMT_MATCH, (void (*)(void))slh_dsa_match }, \ 453 { OSSL_FUNC_KEYMGMT_IMPORT, (void (*)(void))slh_dsa_import }, \ 454 { OSSL_FUNC_KEYMGMT_IMPORT_TYPES, (void (*)(void))slh_dsa_imexport_types }, \ 455 { OSSL_FUNC_KEYMGMT_EXPORT, (void (*)(void))slh_dsa_export }, \ 456 { OSSL_FUNC_KEYMGMT_EXPORT_TYPES, (void (*)(void))slh_dsa_imexport_types }, \ 457 { OSSL_FUNC_KEYMGMT_LOAD, (void (*)(void))slh_dsa_load }, \ 458 { OSSL_FUNC_KEYMGMT_GET_PARAMS, (void (*)(void))slh_dsa_get_params }, \ 459 { OSSL_FUNC_KEYMGMT_GETTABLE_PARAMS, (void (*)(void))slh_dsa_gettable_params }, \ 460 { OSSL_FUNC_KEYMGMT_VALIDATE, (void (*)(void))slh_dsa_validate }, \ 461 { OSSL_FUNC_KEYMGMT_GEN_INIT, (void (*)(void))slh_dsa_gen_init }, \ 462 { OSSL_FUNC_KEYMGMT_GEN, (void (*)(void))slh_dsa_##fn##_gen }, \ 463 { OSSL_FUNC_KEYMGMT_GEN_CLEANUP, (void (*)(void))slh_dsa_gen_cleanup }, \ 464 { OSSL_FUNC_KEYMGMT_GEN_SET_PARAMS, \ 465 (void (*)(void))slh_dsa_gen_set_params }, \ 466 { OSSL_FUNC_KEYMGMT_GEN_SETTABLE_PARAMS, \ 467 (void (*)(void))slh_dsa_gen_settable_params }, \ 468 OSSL_DISPATCH_END \ 469 } 470 471 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-128s", sha2_128s); 472 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-128f", sha2_128f); 473 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-192s", sha2_192s); 474 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-192f", sha2_192f); 475 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-256s", sha2_256s); 476 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHA2-256f", sha2_256f); 477 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-128s", shake_128s); 478 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-128f", shake_128f); 479 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-192s", shake_192s); 480 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-192f", shake_192f); 481 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-256s", shake_256s); 482 MAKE_KEYMGMT_FUNCTIONS("SLH-DSA-SHAKE-256f", shake_256f); 483