1 /* 2 * Copyright 2020-2022 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 "e_os.h" 28 #include "internal/param_build_set.h" 29 30 /* Mapping between a flag and a name */ 31 static const OSSL_ITEM encoding_nameid_map[] = { 32 { OPENSSL_EC_EXPLICIT_CURVE, OSSL_PKEY_EC_ENCODING_EXPLICIT }, 33 { OPENSSL_EC_NAMED_CURVE, OSSL_PKEY_EC_ENCODING_GROUP }, 34 }; 35 36 static const OSSL_ITEM check_group_type_nameid_map[] = { 37 { 0, OSSL_PKEY_EC_GROUP_CHECK_DEFAULT }, 38 { EC_FLAG_CHECK_NAMED_GROUP, OSSL_PKEY_EC_GROUP_CHECK_NAMED }, 39 { EC_FLAG_CHECK_NAMED_GROUP_NIST, OSSL_PKEY_EC_GROUP_CHECK_NAMED_NIST }, 40 }; 41 42 static const OSSL_ITEM format_nameid_map[] = { 43 { (int)POINT_CONVERSION_UNCOMPRESSED, OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_UNCOMPRESSED }, 44 { (int)POINT_CONVERSION_COMPRESSED, OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_COMPRESSED }, 45 { (int)POINT_CONVERSION_HYBRID, OSSL_PKEY_EC_POINT_CONVERSION_FORMAT_HYBRID }, 46 }; 47 48 int ossl_ec_encoding_name2id(const char *name) 49 { 50 size_t i, sz; 51 52 /* Return the default value if there is no name */ 53 if (name == NULL) 54 return OPENSSL_EC_NAMED_CURVE; 55 56 for (i = 0, sz = OSSL_NELEM(encoding_nameid_map); i < sz; i++) { 57 if (OPENSSL_strcasecmp(name, encoding_nameid_map[i].ptr) == 0) 58 return encoding_nameid_map[i].id; 59 } 60 return -1; 61 } 62 63 static char *ec_param_encoding_id2name(int id) 64 { 65 size_t i, sz; 66 67 for (i = 0, sz = OSSL_NELEM(encoding_nameid_map); i < sz; i++) { 68 if (id == (int)encoding_nameid_map[i].id) 69 return encoding_nameid_map[i].ptr; 70 } 71 return NULL; 72 } 73 74 char *ossl_ec_check_group_type_id2name(int id) 75 { 76 size_t i, sz; 77 78 for (i = 0, sz = OSSL_NELEM(check_group_type_nameid_map); i < sz; i++) { 79 if (id == (int)check_group_type_nameid_map[i].id) 80 return check_group_type_nameid_map[i].ptr; 81 } 82 return NULL; 83 } 84 85 static int ec_check_group_type_name2id(const char *name) 86 { 87 size_t i, sz; 88 89 /* Return the default value if there is no name */ 90 if (name == NULL) 91 return 0; 92 93 for (i = 0, sz = OSSL_NELEM(check_group_type_nameid_map); i < sz; i++) { 94 if (OPENSSL_strcasecmp(name, check_group_type_nameid_map[i].ptr) == 0) 95 return check_group_type_nameid_map[i].id; 96 } 97 return -1; 98 } 99 100 int ossl_ec_set_check_group_type_from_name(EC_KEY *ec, const char *name) 101 { 102 int flags = ec_check_group_type_name2id(name); 103 104 if (flags == -1) 105 return 0; 106 EC_KEY_clear_flags(ec, EC_FLAG_CHECK_NAMED_GROUP_MASK); 107 EC_KEY_set_flags(ec, flags); 108 return 1; 109 } 110 111 static int ec_set_check_group_type_from_param(EC_KEY *ec, const OSSL_PARAM *p) 112 { 113 const char *name = NULL; 114 int status = 0; 115 116 switch (p->data_type) { 117 case OSSL_PARAM_UTF8_STRING: 118 name = p->data; 119 status = (name != NULL); 120 break; 121 case OSSL_PARAM_UTF8_PTR: 122 status = OSSL_PARAM_get_utf8_ptr(p, &name); 123 break; 124 } 125 if (status) 126 return ossl_ec_set_check_group_type_from_name(ec, name); 127 return 0; 128 } 129 130 int ossl_ec_pt_format_name2id(const char *name) 131 { 132 size_t i, sz; 133 134 /* Return the default value if there is no name */ 135 if (name == NULL) 136 return (int)POINT_CONVERSION_UNCOMPRESSED; 137 138 for (i = 0, sz = OSSL_NELEM(format_nameid_map); i < sz; i++) { 139 if (OPENSSL_strcasecmp(name, format_nameid_map[i].ptr) == 0) 140 return format_nameid_map[i].id; 141 } 142 return -1; 143 } 144 145 char *ossl_ec_pt_format_id2name(int id) 146 { 147 size_t i, sz; 148 149 for (i = 0, sz = OSSL_NELEM(format_nameid_map); i < sz; i++) { 150 if (id == (int)format_nameid_map[i].id) 151 return format_nameid_map[i].ptr; 152 } 153 return NULL; 154 } 155 156 static int ec_group_explicit_todata(const EC_GROUP *group, OSSL_PARAM_BLD *tmpl, 157 OSSL_PARAM params[], BN_CTX *bnctx, 158 unsigned char **genbuf) 159 { 160 int ret = 0, fid; 161 const char *field_type; 162 const OSSL_PARAM *param = NULL; 163 const OSSL_PARAM *param_p = NULL; 164 const OSSL_PARAM *param_a = NULL; 165 const OSSL_PARAM *param_b = NULL; 166 167 fid = EC_GROUP_get_field_type(group); 168 169 if (fid == NID_X9_62_prime_field) { 170 field_type = SN_X9_62_prime_field; 171 } else if (fid == NID_X9_62_characteristic_two_field) { 172 #ifdef OPENSSL_NO_EC2M 173 ERR_raise(ERR_LIB_EC, EC_R_GF2M_NOT_SUPPORTED); 174 goto err; 175 #else 176 field_type = SN_X9_62_characteristic_two_field; 177 #endif 178 } else { 179 ERR_raise(ERR_LIB_EC, EC_R_INVALID_FIELD); 180 return 0; 181 } 182 183 param_p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_P); 184 param_a = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_A); 185 param_b = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_B); 186 if (tmpl != NULL || param_p != NULL || param_a != NULL || param_b != NULL) 187 { 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_MALLOC_FAILURE); 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_MALLOC_FAILURE); 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_MALLOC_FAILURE); 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_MALLOC_FAILURE); 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_MALLOC_FAILURE); 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_MALLOC_FAILURE); 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_MALLOC_FAILURE); 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 = 412 OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PUB_KEY); 413 if (include_private) 414 param_priv_key = 415 OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_PRIV_KEY); 416 417 ctx = BN_CTX_new_ex(ossl_ec_key_get_libctx(ec)); 418 if (ctx == NULL) 419 goto err; 420 421 if (param_pub_key != NULL) 422 if (!OSSL_PARAM_get_octet_string(param_pub_key, 423 (void **)&pub_key, 0, &pub_key_len) 424 || (pub_point = EC_POINT_new(ecg)) == NULL 425 || !EC_POINT_oct2point(ecg, pub_point, pub_key, pub_key_len, ctx)) 426 goto err; 427 428 if (param_priv_key != NULL && include_private) { 429 int fixed_words; 430 const BIGNUM *order; 431 432 /* 433 * Key import/export should never leak the bit length of the secret 434 * scalar in the key. 435 * 436 * For this reason, on export we use padded BIGNUMs with fixed length. 437 * 438 * When importing we also should make sure that, even if short lived, 439 * the newly created BIGNUM is marked with the BN_FLG_CONSTTIME flag as 440 * soon as possible, so that any processing of this BIGNUM might opt for 441 * constant time implementations in the backend. 442 * 443 * Setting the BN_FLG_CONSTTIME flag alone is never enough, we also have 444 * to preallocate the BIGNUM internal buffer to a fixed public size big 445 * enough that operations performed during the processing never trigger 446 * a realloc which would leak the size of the scalar through memory 447 * accesses. 448 * 449 * Fixed Length 450 * ------------ 451 * 452 * The order of the large prime subgroup of the curve is our choice for 453 * a fixed public size, as that is generally the upper bound for 454 * generating a private key in EC cryptosystems and should fit all valid 455 * secret scalars. 456 * 457 * For padding on export we just use the bit length of the order 458 * converted to bytes (rounding up). 459 * 460 * For preallocating the BIGNUM storage we look at the number of "words" 461 * required for the internal representation of the order, and we 462 * preallocate 2 extra "words" in case any of the subsequent processing 463 * might temporarily overflow the order length. 464 */ 465 order = EC_GROUP_get0_order(ecg); 466 if (order == NULL || BN_is_zero(order)) 467 goto err; 468 469 fixed_words = bn_get_top(order) + 2; 470 471 if ((priv_key = BN_secure_new()) == NULL) 472 goto err; 473 if (bn_wexpand(priv_key, fixed_words) == NULL) 474 goto err; 475 BN_set_flags(priv_key, BN_FLG_CONSTTIME); 476 477 if (!OSSL_PARAM_get_BN(param_priv_key, &priv_key)) 478 goto err; 479 } 480 481 if (priv_key != NULL 482 && !EC_KEY_set_private_key(ec, priv_key)) 483 goto err; 484 485 if (pub_point != NULL 486 && !EC_KEY_set_public_key(ec, pub_point)) 487 goto err; 488 489 ok = 1; 490 491 err: 492 BN_CTX_free(ctx); 493 BN_clear_free(priv_key); 494 OPENSSL_free(pub_key); 495 EC_POINT_free(pub_point); 496 return ok; 497 } 498 499 int ossl_ec_group_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) 500 { 501 int ok = 0; 502 EC_GROUP *group = NULL; 503 504 if (ec == NULL) 505 return 0; 506 507 group = EC_GROUP_new_from_params(params, ossl_ec_key_get_libctx(ec), 508 ossl_ec_key_get0_propq(ec)); 509 510 if (!EC_KEY_set_group(ec, group)) 511 goto err; 512 ok = 1; 513 err: 514 EC_GROUP_free(group); 515 return ok; 516 } 517 518 static int ec_key_point_format_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) 519 { 520 const OSSL_PARAM *p; 521 int format = -1; 522 523 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_POINT_CONVERSION_FORMAT); 524 if (p != NULL) { 525 if (!ossl_ec_pt_format_param2id(p, &format)) { 526 ECerr(0, EC_R_INVALID_FORM); 527 return 0; 528 } 529 EC_KEY_set_conv_form(ec, format); 530 } 531 return 1; 532 } 533 534 static int ec_key_group_check_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) 535 { 536 const OSSL_PARAM *p; 537 538 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_GROUP_CHECK_TYPE); 539 if (p != NULL) 540 return ec_set_check_group_type_from_param(ec, p); 541 return 1; 542 } 543 544 static int ec_set_include_public(EC_KEY *ec, int include) 545 { 546 int flags = EC_KEY_get_enc_flags(ec); 547 548 if (!include) 549 flags |= EC_PKEY_NO_PUBKEY; 550 else 551 flags &= ~EC_PKEY_NO_PUBKEY; 552 EC_KEY_set_enc_flags(ec, flags); 553 return 1; 554 } 555 556 int ossl_ec_key_otherparams_fromdata(EC_KEY *ec, const OSSL_PARAM params[]) 557 { 558 const OSSL_PARAM *p; 559 560 if (ec == NULL) 561 return 0; 562 563 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_USE_COFACTOR_ECDH); 564 if (p != NULL) { 565 int mode; 566 567 if (!OSSL_PARAM_get_int(p, &mode) 568 || !ossl_ec_set_ecdh_cofactor_mode(ec, mode)) 569 return 0; 570 } 571 572 p = OSSL_PARAM_locate_const(params, OSSL_PKEY_PARAM_EC_INCLUDE_PUBLIC); 573 if (p != NULL) { 574 int include = 1; 575 576 if (!OSSL_PARAM_get_int(p, &include) 577 || !ec_set_include_public(ec, include)) 578 return 0; 579 } 580 if (!ec_key_point_format_fromdata(ec, params)) 581 return 0; 582 if (!ec_key_group_check_fromdata(ec, params)) 583 return 0; 584 return 1; 585 } 586 587 int ossl_ec_key_is_foreign(const EC_KEY *ec) 588 { 589 #ifndef FIPS_MODULE 590 if (ec->engine != NULL || EC_KEY_get_method(ec) != EC_KEY_OpenSSL()) 591 return 1; 592 #endif 593 return 0; 594 595 } 596 597 EC_KEY *ossl_ec_key_dup(const EC_KEY *src, int selection) 598 { 599 EC_KEY *ret; 600 601 if (src == NULL) { 602 ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER); 603 return NULL; 604 } 605 606 if ((ret = ossl_ec_key_new_method_int(src->libctx, src->propq, 607 src->engine)) == NULL) 608 return NULL; 609 610 /* copy the parameters */ 611 if (src->group != NULL 612 && (selection & OSSL_KEYMGMT_SELECT_DOMAIN_PARAMETERS) != 0) { 613 ret->group = ossl_ec_group_new_ex(src->libctx, src->propq, 614 src->group->meth); 615 if (ret->group == NULL 616 || !EC_GROUP_copy(ret->group, src->group)) 617 goto err; 618 619 if (src->meth != NULL) { 620 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE) 621 if (src->engine != NULL && ENGINE_init(src->engine) == 0) 622 goto err; 623 ret->engine = src->engine; 624 #endif 625 ret->meth = src->meth; 626 } 627 } 628 629 /* copy the public key */ 630 if (src->pub_key != NULL 631 && (selection & OSSL_KEYMGMT_SELECT_PUBLIC_KEY) != 0) { 632 if (ret->group == NULL) 633 /* no parameter-less keys allowed */ 634 goto err; 635 ret->pub_key = EC_POINT_new(ret->group); 636 if (ret->pub_key == NULL 637 || !EC_POINT_copy(ret->pub_key, src->pub_key)) 638 goto err; 639 } 640 641 /* copy the private key */ 642 if (src->priv_key != NULL 643 && (selection & OSSL_KEYMGMT_SELECT_PRIVATE_KEY) != 0) { 644 if (ret->group == NULL) 645 /* no parameter-less keys allowed */ 646 goto err; 647 ret->priv_key = BN_new(); 648 if (ret->priv_key == NULL || !BN_copy(ret->priv_key, src->priv_key)) 649 goto err; 650 if (ret->group->meth->keycopy 651 && ret->group->meth->keycopy(ret, src) == 0) 652 goto err; 653 } 654 655 /* copy the rest */ 656 if ((selection & OSSL_KEYMGMT_SELECT_OTHER_PARAMETERS) != 0) { 657 ret->enc_flag = src->enc_flag; 658 ret->conv_form = src->conv_form; 659 } 660 661 ret->version = src->version; 662 ret->flags = src->flags; 663 664 #ifndef FIPS_MODULE 665 if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_EC_KEY, 666 &ret->ex_data, &src->ex_data)) 667 goto err; 668 #endif 669 670 if (ret->meth != NULL && ret->meth->copy != NULL) { 671 if ((selection 672 & OSSL_KEYMGMT_SELECT_KEYPAIR) != OSSL_KEYMGMT_SELECT_KEYPAIR) 673 goto err; 674 if (ret->meth->copy(ret, src) == 0) 675 goto err; 676 } 677 678 return ret; 679 err: 680 EC_KEY_free(ret); 681 return NULL; 682 } 683 684 int ossl_ec_encoding_param2id(const OSSL_PARAM *p, int *id) 685 { 686 const char *name = NULL; 687 int status = 0; 688 689 switch (p->data_type) { 690 case OSSL_PARAM_UTF8_STRING: 691 /* The OSSL_PARAM functions have no support for this */ 692 name = p->data; 693 status = (name != NULL); 694 break; 695 case OSSL_PARAM_UTF8_PTR: 696 status = OSSL_PARAM_get_utf8_ptr(p, &name); 697 break; 698 } 699 if (status) { 700 int i = ossl_ec_encoding_name2id(name); 701 702 if (i >= 0) { 703 *id = i; 704 return 1; 705 } 706 } 707 return 0; 708 } 709 710 int ossl_ec_pt_format_param2id(const OSSL_PARAM *p, int *id) 711 { 712 const char *name = NULL; 713 int status = 0; 714 715 switch (p->data_type) { 716 case OSSL_PARAM_UTF8_STRING: 717 /* The OSSL_PARAM functions have no support for this */ 718 name = p->data; 719 status = (name != NULL); 720 break; 721 case OSSL_PARAM_UTF8_PTR: 722 status = OSSL_PARAM_get_utf8_ptr(p, &name); 723 break; 724 } 725 if (status) { 726 int i = ossl_ec_pt_format_name2id(name); 727 728 if (i >= 0) { 729 *id = i; 730 return 1; 731 } 732 } 733 return 0; 734 } 735 736 #ifndef FIPS_MODULE 737 int ossl_x509_algor_is_sm2(const X509_ALGOR *palg) 738 { 739 int ptype = 0; 740 const void *pval = NULL; 741 742 X509_ALGOR_get0(NULL, &ptype, &pval, palg); 743 744 if (ptype == V_ASN1_OBJECT) 745 return OBJ_obj2nid((ASN1_OBJECT *)pval) == NID_sm2; 746 747 if (ptype == V_ASN1_SEQUENCE) { 748 const ASN1_STRING *str = pval; 749 const unsigned char *der = str->data; 750 int derlen = str->length; 751 EC_GROUP *group; 752 int ret; 753 754 if ((group = d2i_ECPKParameters(NULL, &der, derlen)) == NULL) 755 ret = 0; 756 else 757 ret = (EC_GROUP_get_curve_name(group) == NID_sm2); 758 759 EC_GROUP_free(group); 760 return ret; 761 } 762 763 return 0; 764 } 765 766 EC_KEY *ossl_ec_key_param_from_x509_algor(const X509_ALGOR *palg, 767 OSSL_LIB_CTX *libctx, const char *propq) 768 { 769 int ptype = 0; 770 const void *pval = NULL; 771 EC_KEY *eckey = NULL; 772 EC_GROUP *group = NULL; 773 774 X509_ALGOR_get0(NULL, &ptype, &pval, palg); 775 if ((eckey = EC_KEY_new_ex(libctx, propq)) == NULL) { 776 ERR_raise(ERR_LIB_EC, ERR_R_MALLOC_FAILURE); 777 goto ecerr; 778 } 779 780 if (ptype == V_ASN1_SEQUENCE) { 781 const ASN1_STRING *pstr = pval; 782 const unsigned char *pm = pstr->data; 783 int pmlen = pstr->length; 784 785 786 if (d2i_ECParameters(&eckey, &pm, pmlen) == NULL) { 787 ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR); 788 goto ecerr; 789 } 790 } else if (ptype == V_ASN1_OBJECT) { 791 const ASN1_OBJECT *poid = pval; 792 793 /* 794 * type == V_ASN1_OBJECT => the parameters are given by an asn1 OID 795 */ 796 797 group = EC_GROUP_new_by_curve_name_ex(libctx, propq, OBJ_obj2nid(poid)); 798 if (group == NULL) 799 goto ecerr; 800 EC_GROUP_set_asn1_flag(group, OPENSSL_EC_NAMED_CURVE); 801 if (EC_KEY_set_group(eckey, group) == 0) 802 goto ecerr; 803 EC_GROUP_free(group); 804 } else { 805 ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR); 806 goto ecerr; 807 } 808 809 return eckey; 810 811 ecerr: 812 EC_KEY_free(eckey); 813 EC_GROUP_free(group); 814 return NULL; 815 } 816 817 EC_KEY *ossl_ec_key_from_pkcs8(const PKCS8_PRIV_KEY_INFO *p8inf, 818 OSSL_LIB_CTX *libctx, const char *propq) 819 { 820 const unsigned char *p = NULL; 821 int pklen; 822 EC_KEY *eckey = NULL; 823 const X509_ALGOR *palg; 824 825 if (!PKCS8_pkey_get0(NULL, &p, &pklen, &palg, p8inf)) 826 return 0; 827 eckey = ossl_ec_key_param_from_x509_algor(palg, libctx, propq); 828 if (eckey == NULL) 829 goto err; 830 831 /* We have parameters now set private key */ 832 if (!d2i_ECPrivateKey(&eckey, &p, pklen)) { 833 ERR_raise(ERR_LIB_EC, EC_R_DECODE_ERROR); 834 goto err; 835 } 836 837 return eckey; 838 err: 839 EC_KEY_free(eckey); 840 return NULL; 841 } 842 #endif 843