1 /* 2 * Copyright 2020-2024 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 * Low level APIs related to EC_KEY are deprecated for public use, 12 * but still ok for internal use. 13 */ 14 #include "internal/deprecated.h" 15 16 #include <openssl/core_names.h> 17 #include <openssl/objects.h> 18 #include <openssl/params.h> 19 #include <openssl/err.h> 20 #ifndef FIPS_MODULE 21 #include <openssl/engine.h> 22 #include <openssl/x509.h> 23 #endif 24 #include "crypto/bn.h" 25 #include "crypto/ec.h" 26 #include "ec_local.h" 27 #include "internal/e_os.h" 28 #include "internal/nelem.h" 29 #include "internal/param_build_set.h" 30 31 /* Mapping between a flag and a name */ 32 static const OSSL_ITEM encoding_nameid_map[] = { 33 { OPENSSL_EC_EXPLICIT_CURVE, OSSL_PKEY_EC_ENCODING_EXPLICIT }, 34 { OPENSSL_EC_NAMED_CURVE, OSSL_PKEY_EC_ENCODING_GROUP }, 35 }; 36 37 static const OSSL_ITEM check_group_type_nameid_map[] = { 38 { 0, OSSL_PKEY_EC_GROUP_CHECK_DEFAULT }, 39 { EC_FLAG_CHECK_NAMED_GROUP, OSSL_PKEY_EC_GROUP_CHECK_NAMED }, 40 { EC_FLAG_CHECK_NAMED_GROUP_NIST, OSSL_PKEY_EC_GROUP_CHECK_NAMED_NIST }, 41 }; 42 43 static const OSSL_ITEM format_nameid_map[] = { 44 { (int)POINT_CONVERSION_UNCOMPRESSED, OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_UNCOMPRESSED }, 45 { (int)POINT_CONVERSION_COMPRESSED, OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_COMPRESSED }, 46 { (int)POINT_CONVERSION_HYBRID, OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_HYBRID }, 47 }; 48 49 int ossl_ec_encoding_name2id(const char *name) 50 { 51 size_t i, sz; 52 53 /* Return the default value if there is no name */ 54 if (name == NULL) 55 return OPENSSL_EC_NAMED_CURVE; 56 57 for (i = 0, sz = OSSL_NELEM(encoding_nameid_map); i < sz; i++) { 58 if (OPENSSL_strcasecmp(name, encoding_nameid_map[i].ptr) == 0) 59 return encoding_nameid_map[i].id; 60 } 61 return -1; 62 } 63 64 static char *ec_param_encoding_id2name(int id) 65 { 66 size_t i, sz; 67 68 for (i = 0, sz = OSSL_NELEM(encoding_nameid_map); i < sz; i++) { 69 if (id == (int)encoding_nameid_map[i].id) 70 return encoding_nameid_map[i].ptr; 71 } 72 return NULL; 73 } 74 75 char *ossl_ec_check_group_type_id2name(int id) 76 { 77 size_t i, sz; 78 79 for (i = 0, sz = OSSL_NELEM(check_group_type_nameid_map); i < sz; i++) { 80 if (id == (int)check_group_type_nameid_map[i].id) 81 return check_group_type_nameid_map[i].ptr; 82 } 83 return NULL; 84 } 85 86 static int ec_check_group_type_name2id(const char *name) 87 { 88 size_t i, sz; 89 90 /* Return the default value if there is no name */ 91 if (name == NULL) 92 return 0; 93 94 for (i = 0, sz = OSSL_NELEM(check_group_type_nameid_map); i < sz; i++) { 95 if (OPENSSL_strcasecmp(name, check_group_type_nameid_map[i].ptr) == 0) 96 return check_group_type_nameid_map[i].id; 97 } 98 return -1; 99 } 100 101 int ossl_ec_set_check_group_type_from_name(EC_KEY *ec, const char *name) 102 { 103 int flags = ec_check_group_type_name2id(name); 104 105 if (flags == -1) 106 return 0; 107 EC_KEY_clear_flags(ec, EC_FLAG_CHECK_NAMED_GROUP_MASK); 108 EC_KEY_set_flags(ec, flags); 109 return 1; 110 } 111 112 static int ec_set_check_group_type_from_param(EC_KEY *ec, const OSSL_PARAM *p) 113 { 114 const char *name = NULL; 115 int status = 0; 116 117 switch (p->data_type) { 118 case OSSL_PARAM_UTF8_STRING: 119 name = p->data; 120 status = (name != NULL); 121 break; 122 case OSSL_PARAM_UTF8_PTR: 123 status = OSSL_PARAM_get_utf8_ptr(p, &name); 124 break; 125 } 126 if (status) 127 return ossl_ec_set_check_group_type_from_name(ec, name); 128 return 0; 129 } 130 131 int ossl_ec_pt_format_name2id(const char *name) 132 { 133 size_t i, sz; 134 135 /* Return the default value if there is no name */ 136 if (name == NULL) 137 return (int)POINT_CONVERSION_UNCOMPRESSED; 138 139 for (i = 0, sz = OSSL_NELEM(format_nameid_map); i < sz; i++) { 140 if (OPENSSL_strcasecmp(name, format_nameid_map[i].ptr) == 0) 141 return format_nameid_map[i].id; 142 } 143 return -1; 144 } 145 146 char *ossl_ec_pt_format_id2name(int id) 147 { 148 size_t i, sz; 149 150 for (i = 0, sz = OSSL_NELEM(format_nameid_map); i < sz; i++) { 151 if (id == (int)format_nameid_map[i].id) 152 return format_nameid_map[i].ptr; 153 } 154 return NULL; 155 } 156 157 static int ec_group_explicit_todata(const EC_GROUP *group, OSSL_PARAM_BLD *tmpl, 158 OSSL_PARAM params[], BN_CTX *bnctx, 159 unsigned char **genbuf) 160 { 161 int ret = 0, fid; 162 const char *field_type; 163 const OSSL_PARAM *param = NULL; 164 const OSSL_PARAM *param_p = NULL; 165 const OSSL_PARAM *param_a = NULL; 166 const OSSL_PARAM *param_b = NULL; 167 168 fid = EC_GROUP_get_field_type(group); 169 170 if (fid == NID_X9_62_prime_field) { 171 field_type = SN_X9_62_prime_field; 172 } else if (fid == NID_X9_62_characteristic_two_field) { 173 #ifdef OPENSSL_NO_EC2M 174 ERR_raise(ERR_LIB_EC, EC_R_GF2M_NOT_SUPPORTED); 175 goto err; 176 #else 177 field_type = SN_X9_62_characteristic_two_field; 178 #endif 179 } else { 180 ERR_raise(ERR_LIB_EC, EC_R_INVALID_FIELD); 181 return 0; 182 } 183 184 param_p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_P); 185 param_a = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_A); 186 param_b = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_B); 187 if (tmpl != NULL || param_p != NULL || param_a != NULL || param_b != NULL) { 188 BIGNUM *p = BN_CTX_get(bnctx); 189 BIGNUM *a = BN_CTX_get(bnctx); 190 BIGNUM *b = BN_CTX_get(bnctx); 191 192 if (b == NULL) { 193 ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB); 194 goto err; 195 } 196 197 if (!EC_GROUP_get_curve(group, p, a, b, bnctx)) { 198 ERR_raise(ERR_LIB_EC, EC_R_INVALID_CURVE); 199 goto err; 200 } 201 if (!ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_P, p) 202 || !ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_A, a) 203 || !ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_B, b)) { 204 ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB); 205 goto err; 206 } 207 } 208 209 param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_ORDER); 210 if (tmpl != NULL || param != NULL) { 211 const BIGNUM *order = EC_GROUP_get0_order(group); 212 213 if (order == NULL) { 214 ERR_raise(ERR_LIB_EC, EC_R_INVALID_GROUP_ORDER); 215 goto err; 216 } 217 if (!ossl_param_build_set_bn(tmpl, params, OSSL_PKEY_PARAM_EC_ORDER, 218 order)) { 219 ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB); 220 goto err; 221 } 222 } 223 224 param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_FIELD_TYPE); 225 if (tmpl != NULL || param != NULL) { 226 if (!ossl_param_build_set_utf8_string(tmpl, params, 227 OSSL_PKEY_PARAM_EC_FIELD_TYPE, 228 field_type)) { 229 ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB); 230 goto err; 231 } 232 } 233 234 param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_GENERATOR); 235 if (tmpl != NULL || param != NULL) { 236 size_t genbuf_len; 237 const EC_POINT *genpt = EC_GROUP_get0_generator(group); 238 point_conversion_form_t genform = EC_GROUP_get_point_conversion_form(group); 239 240 if (genpt == NULL) { 241 ERR_raise(ERR_LIB_EC, EC_R_INVALID_GENERATOR); 242 goto err; 243 } 244 genbuf_len = EC_POINT_point2buf(group, genpt, genform, genbuf, bnctx); 245 if (genbuf_len == 0) { 246 ERR_raise(ERR_LIB_EC, EC_R_INVALID_GENERATOR); 247 goto err; 248 } 249 if (!ossl_param_build_set_octet_string(tmpl, params, 250 OSSL_PKEY_PARAM_EC_GENERATOR, 251 *genbuf, genbuf_len)) { 252 ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB); 253 goto err; 254 } 255 } 256 257 param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_COFACTOR); 258 if (tmpl != NULL || param != NULL) { 259 const BIGNUM *cofactor = EC_GROUP_get0_cofactor(group); 260 261 if (cofactor != NULL 262 && !ossl_param_build_set_bn(tmpl, params, 263 OSSL_PKEY_PARAM_EC_COFACTOR, cofactor)) { 264 ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB); 265 goto err; 266 } 267 } 268 269 param = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_SEED); 270 if (tmpl != NULL || param != NULL) { 271 unsigned char *seed = EC_GROUP_get0_seed(group); 272 size_t seed_len = EC_GROUP_get_seed_len(group); 273 274 if (seed != NULL 275 && seed_len > 0 276 && !ossl_param_build_set_octet_string(tmpl, params, 277 OSSL_PKEY_PARAM_EC_SEED, 278 seed, seed_len)) { 279 ERR_raise(ERR_LIB_EC, ERR_R_CRYPTO_LIB); 280 goto err; 281 } 282 } 283 ret = 1; 284 err: 285 return ret; 286 } 287 288 int ossl_ec_group_todata(const EC_GROUP *group, OSSL_PARAM_BLD *tmpl, 289 OSSL_PARAM params[], OSSL_LIB_CTX *libctx, 290 const char *propq, 291 BN_CTX *bnctx, unsigned char **genbuf) 292 { 293 int ret = 0, curve_nid, encoding_flag; 294 const char *encoding_name, *pt_form_name; 295 point_conversion_form_t genform; 296 297 if (group == NULL) { 298 ERR_raise(ERR_LIB_EC, EC_R_PASSED_NULL_PARAMETER); 299 return 0; 300 } 301 302 genform = EC_GROUP_get_point_conversion_form(group); 303 pt_form_name = ossl_ec_pt_format_id2name(genform); 304 if (pt_form_name == NULL 305 || !ossl_param_build_set_utf8_string( 306 tmpl, params, 307 OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT, pt_form_name)) { 308 ERR_raise(ERR_LIB_EC, EC_R_INVALID_FORM); 309 return 0; 310 } 311 encoding_flag = EC_GROUP_get_asn1_flag(group) & OPENSSL_EC_NAMED_CURVE; 312 encoding_name = ec_param_encoding_id2name(encoding_flag); 313 if (encoding_name == NULL 314 || !ossl_param_build_set_utf8_string(tmpl, params, 315 OSSL_PKEY_PARAM_EC_ENCODING, 316 encoding_name)) { 317 ERR_raise(ERR_LIB_EC, EC_R_INVALID_ENCODING); 318 return 0; 319 } 320 321 if (!ossl_param_build_set_int(tmpl, params, 322 OSSL_PKEY_PARAM_EC_DECODED_FROM_EXPLICIT_PARAMS, 323 group->decoded_from_explicit_params)) 324 return 0; 325 326 curve_nid = EC_GROUP_get_curve_name(group); 327 328 /* 329 * Get the explicit parameters in these two cases: 330 * - We do not have a template, i.e. specific parameters are requested 331 * - The curve is not a named curve 332 */ 333 if (tmpl == NULL || curve_nid == NID_undef) 334 if (!ec_group_explicit_todata(group, tmpl, params, bnctx, genbuf)) 335 goto err; 336 337 if (curve_nid != NID_undef) { 338 /* Named curve */ 339 const char *curve_name = OSSL_EC_curve_nid2name(curve_nid); 340 341 if (curve_name == NULL 342 || !ossl_param_build_set_utf8_string(tmpl, params, 343 OSSL_PKEY_PARAM_GROUP_NAME, 344 curve_name)) { 345 ERR_raise(ERR_LIB_EC, EC_R_INVALID_CURVE); 346 goto err; 347 } 348 } 349 ret = 1; 350 err: 351 return ret; 352 } 353 354 /* 355 * The intention with the "backend" source file is to offer backend support 356 * for legacy backends (EVP_PKEY_ASN1_METHOD and EVP_PKEY_METHOD) and provider 357 * implementations alike. 358 */ 359 int ossl_ec_set_ecdh_cofactor_mode(EC_KEY *ec, int mode) 360 { 361 const EC_GROUP *ecg = EC_KEY_get0_group(ec); 362 const BIGNUM *cofactor; 363 /* 364 * mode can be only 0 for disable, or 1 for enable here. 365 * 366 * This is in contrast with the same parameter on an ECDH EVP_PKEY_CTX that 367 * also supports mode == -1 with the meaning of "reset to the default for 368 * the associated key". 369 */ 370 if (mode < 0 || mode > 1) 371 return 0; 372 373 if ((cofactor = EC_GROUP_get0_cofactor(ecg)) == NULL) 374 return 0; 375 376 /* ECDH cofactor mode has no effect if cofactor is 1 */ 377 if (BN_is_one(cofactor)) 378 return 1; 379 380 if (mode == 1) 381 EC_KEY_set_flags(ec, EC_FLAG_COFACTOR_ECDH); 382 else if (mode == 0) 383 EC_KEY_clear_flags(ec, EC_FLAG_COFACTOR_ECDH); 384 385 return 1; 386 } 387 388 /* 389 * Callers of ossl_ec_key_fromdata MUST make sure that ec_key_params_fromdata has 390 * been called before! 391 * 392 * This function only gets the bare keypair, domain parameters and other 393 * parameters are treated separately, and domain parameters are required to 394 * define a keypair. 395 */ 396 int ossl_ec_key_fromdata(EC_KEY *ec, const OSSL_PARAM params[], int include_private) 397 { 398 const OSSL_PARAM *param_priv_key = NULL, *param_pub_key = NULL; 399 BN_CTX *ctx = NULL; 400 BIGNUM *priv_key = NULL; 401 unsigned char *pub_key = NULL; 402 size_t pub_key_len; 403 const EC_GROUP *ecg = NULL; 404 EC_POINT *pub_point = NULL; 405 int ok = 0; 406 407 ecg = EC_KEY_get0_group(ec); 408 if (ecg == NULL) 409 return 0; 410 411 param_pub_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY); 412 if (include_private) 413 param_priv_key = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY); 414 415 ctx = BN_CTX_new_ex(ossl_ec_key_get_libctx(ec)); 416 if (ctx == NULL) 417 goto err; 418 419 if (param_pub_key != NULL) 420 if (!OSSL_PARAM_get_octet_string(param_pub_key, 421 (void **)&pub_key, 0, &pub_key_len) 422 || (pub_point = EC_POINT_new(ecg)) == NULL 423 || !EC_POINT_oct2point(ecg, pub_point, pub_key, pub_key_len, ctx)) 424 goto err; 425 426 if (param_priv_key != NULL && include_private) { 427 int fixed_words; 428 const BIGNUM *order; 429 430 /* 431 * Key import/export should never leak the bit length of the secret 432 * scalar in the key. 433 * 434 * For this reason, on export we use padded BIGNUMs with fixed length. 435 * 436 * When importing we also should make sure that, even if short lived, 437 * the newly created BIGNUM is marked with the BN_FLG_CONSTTIME flag as 438 * soon as possible, so that any processing of this BIGNUM might opt for 439 * constant time implementations in the backend. 440 * 441 * Setting the BN_FLG_CONSTTIME flag alone is never enough, we also have 442 * to preallocate the BIGNUM internal buffer to a fixed public size big 443 * enough that operations performed during the processing never trigger 444 * a realloc which would leak the size of the scalar through memory 445 * accesses. 446 * 447 * Fixed Length 448 * ------------ 449 * 450 * The order of the large prime subgroup of the curve is our choice for 451 * a fixed public size, as that is generally the upper bound for 452 * generating a private key in EC cryptosystems and should fit all valid 453 * secret scalars. 454 * 455 * For padding on export we just use the bit length of the order 456 * converted to bytes (rounding up). 457 * 458 * For preallocating the BIGNUM storage we look at the number of "words" 459 * required for the internal representation of the order, and we 460 * preallocate 2 extra "words" in case any of the subsequent processing 461 * might temporarily overflow the order length. 462 */ 463 order = EC_GROUP_get0_order(ecg); 464 if (order == NULL || BN_is_zero(order)) 465 goto err; 466 467 fixed_words = bn_get_top(order) + 2; 468 469 if ((priv_key = BN_secure_new()) == NULL) 470 goto err; 471 if (bn_wexpand(priv_key, fixed_words) == NULL) 472 goto err; 473 BN_set_flags(priv_key, BN_FLG_CONSTTIME); 474 475 if (!OSSL_PARAM_get_BN(param_priv_key, &priv_key)) 476 goto err; 477 } 478 479 if (priv_key != NULL 480 && !EC_KEY_set_private_key(ec, priv_key)) 481 goto err; 482 483 if (pub_point != NULL 484 && !EC_KEY_set_public_key(ec, pub_point)) 485 goto err; 486 487 ok = 1; 488 489 err: 490 BN_CTX_free(ctx); 491 BN_clear_free(priv_key); 492 OPENSSL_free(pub_key); 493 EC_POINT_free(pub_point); 494 return ok; 495 } 496 497 int ossl_ec_group_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) 498 { 499 int ok = 0; 500 EC_GROUP *group = NULL; 501 502 if (ec == NULL) 503 return 0; 504 505 group = EC_GROUP_new_from_params(params, ossl_ec_key_get_libctx(ec), 506 ossl_ec_key_get0_propq(ec)); 507 508 if (!EC_KEY_set_group(ec, group)) 509 goto err; 510 ok = 1; 511 err: 512 EC_GROUP_free(group); 513 return ok; 514 } 515 516 static int ec_key_point_format_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) 517 { 518 const OSSL_PARAM *p; 519 int format = -1; 520 521 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT); 522 if (p != NULL) { 523 if (!ossl_ec_pt_format_param2id(p, &format)) { 524 ERR_raise(ERR_LIB_EC, EC_R_INVALID_FORM); 525 return 0; 526 } 527 EC_KEY_set_conv_form(ec, format); 528 } 529 return 1; 530 } 531 532 static int ec_key_group_check_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) 533 { 534 const OSSL_PARAM *p; 535 536 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE); 537 if (p != NULL) 538 return ec_set_check_group_type_from_param(ec, p); 539 return 1; 540 } 541 542 static int ec_set_include_public(EC_KEY *ec, int include) 543 { 544 int flags = EC_KEY_get_enc_flags(ec); 545 546 if (!include) 547 flags |= EC_PKEY_NO_PUBKEY; 548 else 549 flags &= ~EC_PKEY_NO_PUBKEY; 550 EC_KEY_set_enc_flags(ec, flags); 551 return 1; 552 } 553 554 int ossl_ec_key_otherparams_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) 555 { 556 const OSSL_PARAM *p; 557 558 if (ec == NULL) 559 return 0; 560 561 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_USE_COFACTOR_ECDH); 562 if (p != NULL) { 563 int mode; 564 565 if (!OSSL_PARAM_get_int(p, &mode) 566 || !ossl_ec_set_ecdh_cofactor_mode(ec, mode)) 567 return 0; 568 } 569 570 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC); 571 if (p != NULL) { 572 int include = 1; 573 574 if (!OSSL_PARAM_get_int(p, &include) 575 || !ec_set_include_public(ec, include)) 576 return 0; 577 } 578 if (!ec_key_point_format_fromdata(ec, params)) 579 return 0; 580 if (!ec_key_group_check_fromdata(ec, params)) 581 return 0; 582 return 1; 583 } 584 585 int ossl_ec_key_is_foreign(const EC_KEY *ec) 586 { 587 #ifndef FIPS_MODULE 588 if (ec->engine != NULL || EC_KEY_get_method(ec) != EC_KEY_OpenSSL()) 589 return 1; 590 #endif 591 return 0; 592 } 593 594 EC_KEY *ossl_ec_key_dup(const EC_KEY *src, int selection) 595 { 596 EC_KEY *ret; 597 598 if (src == NULL) { 599 ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER); 600 return NULL; 601 } 602 603 if ((ret = ossl_ec_key_new_method_int(src->libctx, src->propq, 604 src->engine)) 605 == NULL) 606 return NULL; 607 608 /* copy the parameters */ 609 if (src->group != NULL 610 && (selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0) { 611 ret->group = ossl_ec_group_new_ex(src->libctx, src->propq, 612 src->group->meth); 613 if (ret->group == NULL 614 || !EC_GROUP_copy(ret->group, src->group)) 615 goto err; 616 617 if (src->meth != NULL) 618 ret->meth = src->meth; 619 } 620 621 /* copy the public key */ 622 if (src->pub_key != NULL 623 && (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) { 624 if (ret->group == NULL) 625 /* no parameter-less keys allowed */ 626 goto err; 627 ret->pub_key = EC_POINT_new(ret->group); 628 if (ret->pub_key == NULL 629 || !EC_POINT_copy(ret->pub_key, src->pub_key)) 630 goto err; 631 } 632 633 /* copy the private key */ 634 if (src->priv_key != NULL 635 && (selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) { 636 if (ret->group == NULL) 637 /* no parameter-less keys allowed */ 638 goto err; 639 ret->priv_key = BN_new(); 640 if (ret->priv_key == NULL || !BN_copy(ret->priv_key, src->priv_key)) 641 goto err; 642 if (ret->group->meth->keycopy 643 && ret->group->meth->keycopy(ret, src) == 0) 644 goto err; 645 } 646 647 /* copy the rest */ 648 if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0) { 649 ret->enc_flag = src->enc_flag; 650 ret->conv_form = src->conv_form; 651 } 652 653 ret->version = src->version; 654 ret->flags = src->flags; 655 656 #ifndef FIPS_MODULE 657 if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_EC_KEY, 658 &ret->ex_data, &src->ex_data)) 659 goto err; 660 #endif 661 662 if (ret->meth != NULL && ret->meth->copy != NULL) { 663 if ((selection 664 & OSSL_KEYMGMT_SELECT_KEYPAIR) 665 != OSSL_KEYMGMT_SELECT_KEYPAIR) 666 goto err; 667 if (ret->meth->copy(ret, src) == 0) 668 goto err; 669 } 670 671 return ret; 672 err: 673 EC_KEY_free(ret); 674 return NULL; 675 } 676 677 int ossl_ec_encoding_param2id(const OSSL_PARAM *p, int *id) 678 { 679 const char *name = NULL; 680 int status = 0; 681 682 switch (p->data_type) { 683 case OSSL_PARAM_UTF8_STRING: 684 /* The OSSL_PARAM functions have no support for this */ 685 name = p->data; 686 status = (name != NULL); 687 break; 688 case OSSL_PARAM_UTF8_PTR: 689 status = OSSL_PARAM_get_utf8_ptr(p, &name); 690 break; 691 } 692 if (status) { 693 int i = ossl_ec_encoding_name2id(name); 694 695 if (i >= 0) { 696 *id = i; 697 return 1; 698 } 699 } 700 return 0; 701 } 702 703 int ossl_ec_pt_format_param2id(const OSSL_PARAM *p, int *id) 704 { 705 const char *name = NULL; 706 int status = 0; 707 708 switch (p->data_type) { 709 case OSSL_PARAM_UTF8_STRING: 710 /* The OSSL_PARAM functions have no support for this */ 711 name = p->data; 712 status = (name != NULL); 713 break; 714 case OSSL_PARAM_UTF8_PTR: 715 status = OSSL_PARAM_get_utf8_ptr(p, &name); 716 break; 717 } 718 if (status) { 719 int i = ossl_ec_pt_format_name2id(name); 720 721 if (i >= 0) { 722 *id = i; 723 return 1; 724 } 725 } 726 return 0; 727 } 728 729 #ifndef FIPS_MODULE 730 int ossl_x509_algor_is_sm2(const X509_ALGOR *palg) 731 { 732 int ptype = 0; 733 const void *pval = NULL; 734 735 X509_ALGOR_get0(NULL, &ptype, &pval, palg); 736 737 if (ptype == V_ASN1_OBJECT) 738 return OBJ_obj2nid((ASN1_OBJECT *)pval) == NID_sm2; 739 740 if (ptype == V_ASN1_SEQUENCE) { 741 const ASN1_STRING *str = pval; 742 const unsigned char *der = str->data; 743 int derlen = str->length; 744 EC_GROUP *group; 745 int ret; 746 747 if ((group = d2i_ECPKParameters(NULL, &der, derlen)) == NULL) 748 ret = 0; 749 else 750 ret = (EC_GROUP_get_curve_name(group) == NID_sm2); 751 752 EC_GROUP_free(group); 753 return ret; 754 } 755 756 return 0; 757 } 758 759 EC_KEY *ossl_ec_key_param_from_x509_algor(const X509_ALGOR *palg, 760 OSSL_LIB_CTX *libctx, const char *propq) 761 { 762 int ptype = 0; 763 const void *pval = NULL; 764 EC_KEY *eckey = NULL; 765 EC_GROUP *group = NULL; 766 767 X509_ALGOR_get0(NULL, &ptype, &pval, palg); 768 if ((eckey = EC_KEY_new_ex(libctx, propq)) == NULL) { 769 ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB); 770 goto ecerr; 771 } 772 773 if (ptype == V_ASN1_SEQUENCE) { 774 const ASN1_STRING *pstr = pval; 775 const unsigned char *pm = pstr->data; 776 int pmlen = pstr->length; 777 778 if (d2i_ECParameters(&eckey, &pm, pmlen) == NULL) { 779 ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR); 780 goto ecerr; 781 } 782 } else if (ptype == V_ASN1_OBJECT) { 783 const ASN1_OBJECT *poid = pval; 784 785 /* 786 * type == V_ASN1_OBJECT => the parameters are given by an asn1 OID 787 */ 788 789 group = EC_GROUP_new_by_curve_name_ex(libctx, propq, OBJ_obj2nid(poid)); 790 if (group == NULL) 791 goto ecerr; 792 EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE); 793 if (EC_KEY_set_group(eckey, group) == 0) 794 goto ecerr; 795 EC_GROUP_free(group); 796 } else { 797 ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR); 798 goto ecerr; 799 } 800 801 return eckey; 802 803 ecerr: 804 EC_KEY_free(eckey); 805 EC_GROUP_free(group); 806 return NULL; 807 } 808 809 EC_KEY *ossl_ec_key_from_pkcs8(const PKCS8_PRIV_KEY_INFO *p8inf, 810 OSSL_LIB_CTX *libctx, const char *propq) 811 { 812 const unsigned char *p = NULL; 813 int pklen; 814 EC_KEY *eckey = NULL; 815 const X509_ALGOR *palg; 816 817 if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8inf)) 818 return 0; 819 eckey = ossl_ec_key_param_from_x509_algor(palg, libctx, propq); 820 if (eckey == NULL) 821 goto err; 822 823 /* We have parameters now set private key */ 824 if (!d2i_ECPrivateKey(&eckey, &p, pklen)) { 825 ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR); 826 goto err; 827 } 828 829 return eckey; 830 err: 831 EC_KEY_free(eckey); 832 return NULL; 833 } 834 #endif 835
Indexes created Sat Feb 28 05:31:39 UTC 2026