crypto/ec/ec_key.c

   1 /*
   2  * Copyright 2002-2023 The OpenSSL Project Authors. All Rights Reserved.
   3  * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved
   4  *
   5  * Licensed under the Apache License 2.0 (the "License").  You may not use
   6  * this file except in compliance with the License.  You can obtain a copy
   7  * in the file LICENSE in the source distribution or at
   8  * https://www.openssl.org/source/license.html
   9  */
  10
  11 /*
  12  * EC_KEY low level APIs are deprecated for public use, but still ok for
  13  * internal use.
  14  */
  15 #include "internal/deprecated.h"
  16
  17 #include "internal/cryptlib.h"
  18 #include <string.h>
  19 #include "ec_local.h"
  20 #include "internal/refcount.h"
  21 #include <openssl/err.h>
  22 #ifndef FIPS_MODULE
  23 # include <openssl/engine.h>
  24 #endif
  25 #include <openssl/self_test.h>
  26 #include "prov/providercommon.h"
  27 #include "prov/ecx.h"
  28 #include "crypto/bn.h"
  29
  30 static int ecdsa_keygen_pairwise_test(EC_KEY *eckey, OSSL_CALLBACK *cb,
  31                                       void *cbarg);
  32
  33 #ifndef FIPS_MODULE
  34 EC_KEY *EC_KEY_new(void)
  35 {
  36     return ossl_ec_key_new_method_int(NULL, NULL, NULL);
  37 }
  38 #endif
  39
  40 EC_KEY *EC_KEY_new_ex(OSSL_LIB_CTX *ctx, const char *propq)
  41 {
  42     return ossl_ec_key_new_method_int(ctx, propq, NULL);
  43 }
  44
  45 EC_KEY *EC_KEY_new_by_curve_name_ex(OSSL_LIB_CTX *ctx, const char *propq,
  46                                     int nid)
  47 {
  48     EC_KEY *ret = EC_KEY_new_ex(ctx, propq);
  49     if (ret == NULL)
  50         return NULL;
  51     ret->group = EC_GROUP_new_by_curve_name_ex(ctx, propq, nid);
  52     if (ret->group == NULL) {
  53         EC_KEY_free(ret);
  54         return NULL;
  55     }
  56     if (ret->meth->set_group != NULL
  57         && ret->meth->set_group(ret, ret->group) == 0) {
  58         EC_KEY_free(ret);
  59         return NULL;
  60     }
  61     return ret;
  62 }
  63
  64 #ifndef FIPS_MODULE
  65 EC_KEY *EC_KEY_new_by_curve_name(int nid)
  66 {
  67     return EC_KEY_new_by_curve_name_ex(NULL, NULL, nid);
  68 }
  69 #endif
  70
  71 void EC_KEY_free(EC_KEY *r)
  72 {
  73     int i;
  74
  75     if (r == NULL)
  76         return;
  77
  78     CRYPTO_DOWN_REF(&r->references, &i);
  79     REF_PRINT_COUNT("EC_KEY", r);
  80     if (i > 0)
  81         return;
  82     REF_ASSERT_ISNT(i < 0);
  83
  84     if (r->meth != NULL && r->meth->finish != NULL)
  85         r->meth->finish(r);
  86
  87 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
  88     ENGINE_finish(r->engine);
  89 #endif
  90
  91     if (r->group && r->group->meth->keyfinish)
  92         r->group->meth->keyfinish(r);
  93
  94 #ifndef FIPS_MODULE
  95     CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, r, &r->ex_data);
  96 #endif
  97     CRYPTO_FREE_REF(&r->references);
  98     EC_GROUP_free(r->group);
  99     EC_POINT_free(r->pub_key);
 100     BN_clear_free(r->priv_key);
 101     OPENSSL_free(r->propq);
 102
 103     OPENSSL_clear_free((void *)r, sizeof(EC_KEY));
 104 }
 105
 106 EC_KEY *EC_KEY_copy(EC_KEY *dest, const EC_KEY *src)
 107 {
 108     if (dest == NULL || src == NULL) {
 109         ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER);
 110         return NULL;
 111     }
 112     if (src->meth != dest->meth) {
 113         if (dest->meth->finish != NULL)
 114             dest->meth->finish(dest);
 115         if (dest->group && dest->group->meth->keyfinish)
 116             dest->group->meth->keyfinish(dest);
 117 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 118         if (ENGINE_finish(dest->engine) == 0)
 119             return 0;
 120         dest->engine = NULL;
 121 #endif
 122     }
 123     dest->libctx = src->libctx;
 124     /* copy the parameters */
 125     if (src->group != NULL) {
 126         /* clear the old group */
 127         EC_GROUP_free(dest->group);
 128         dest->group = ossl_ec_group_new_ex(src->libctx, src->propq,
 129                                            src->group->meth);
 130         if (dest->group == NULL)
 131             return NULL;
 132         if (!EC_GROUP_copy(dest->group, src->group))
 133             return NULL;
 134
 135         /*  copy the public key */
 136         if (src->pub_key != NULL) {
 137             EC_POINT_free(dest->pub_key);
 138             dest->pub_key = EC_POINT_new(src->group);
 139             if (dest->pub_key == NULL)
 140                 return NULL;
 141             if (!EC_POINT_copy(dest->pub_key, src->pub_key))
 142                 return NULL;
 143         }
 144         /* copy the private key */
 145         if (src->priv_key != NULL) {
 146             if (dest->priv_key == NULL) {
 147                 dest->priv_key = BN_new();
 148                 if (dest->priv_key == NULL)
 149                     return NULL;
 150             }
 151             if (!BN_copy(dest->priv_key, src->priv_key))
 152                 return NULL;
 153             if (src->group->meth->keycopy
 154                 && src->group->meth->keycopy(dest, src) == 0)
 155                 return NULL;
 156         }
 157     }
 158
 159
 160     /* copy the rest */
 161     dest->enc_flag = src->enc_flag;
 162     dest->conv_form = src->conv_form;
 163     dest->version = src->version;
 164     dest->flags = src->flags;
 165 #ifndef FIPS_MODULE
 166     if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_EC_KEY,
 167                             &dest->ex_data, &src->ex_data))
 168         return NULL;
 169 #endif
 170
 171     if (src->meth != dest->meth) {
 172 #if !defined(OPENSSL_NO_ENGINE) && !defined(FIPS_MODULE)
 173         if (src->engine != NULL && ENGINE_init(src->engine) == 0)
 174             return NULL;
 175         dest->engine = src->engine;
 176 #endif
 177         dest->meth = src->meth;
 178     }
 179
 180     if (src->meth->copy != NULL && src->meth->copy(dest, src) == 0)
 181         return NULL;
 182
 183     dest->dirty_cnt++;
 184
 185     return dest;
 186 }
 187
 188 EC_KEY *EC_KEY_dup(const EC_KEY *ec_key)
 189 {
 190     return ossl_ec_key_dup(ec_key, OSSL_KEYMGMT_SELECT_ALL);
 191 }
 192
 193 int EC_KEY_up_ref(EC_KEY *r)
 194 {
 195     int i;
 196
 197     if (CRYPTO_UP_REF(&r->references, &i) <= 0)
 198         return 0;
 199
 200     REF_PRINT_COUNT("EC_KEY", r);
 201     REF_ASSERT_ISNT(i < 2);
 202     return ((i > 1) ? 1 : 0);
 203 }
 204
 205 ENGINE *EC_KEY_get0_engine(const EC_KEY *eckey)
 206 {
 207     return eckey->engine;
 208 }
 209
 210 int EC_KEY_generate_key(EC_KEY *eckey)
 211 {
 212     if (eckey == NULL || eckey->group == NULL) {
 213         ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER);
 214         return 0;
 215     }
 216     if (eckey->meth->keygen != NULL) {
 217         int ret;
 218
 219         ret = eckey->meth->keygen(eckey);
 220         if (ret == 1)
 221             eckey->dirty_cnt++;
 222
 223         return ret;
 224     }
 225     ERR_raise(ERR_LIB_EC, EC_R_OPERATION_NOT_SUPPORTED);
 226     return 0;
 227 }
 228
 229 int ossl_ec_key_gen(EC_KEY *eckey)
 230 {
 231     int ret;
 232
 233     ret = eckey->group->meth->keygen(eckey);
 234
 235     if (ret == 1)
 236         eckey->dirty_cnt++;
 237     return ret;
 238 }
 239
 240 /*
 241  * Refer: FIPS 140-3 IG 10.3.A Additional Comment 1
 242  * Perform a KAT by duplicating the public key generation.
 243  *
 244  * NOTE: This issue requires a background understanding, provided in a separate
 245  * document; the current IG 10.3.A AC1 is insufficient regarding the PCT for
 246  * the key agreement scenario.
 247  *
 248  * Currently IG 10.3.A requires PCT in the mode of use prior to use of the
 249  * key pair, citing the PCT defined in the associated standard. For key
 250  * agreement, the only PCT defined in SP 800-56A is that of Section 5.6.2.4:
 251  * the comparison of the original public key to a newly calculated public key.
 252  */
 253 static int ecdsa_keygen_knownanswer_test(EC_KEY *eckey, BN_CTX *ctx,
 254                                          OSSL_CALLBACK *cb, void *cbarg)
 255 {
 256     int len, ret = 0;
 257     OSSL_SELF_TEST *st = NULL;
 258     unsigned char bytes[512] = {0};
 259     EC_POINT *pub_key2 = EC_POINT_new(eckey->group);
 260
 261     if (pub_key2 == NULL)
 262         return 0;
 263
 264     st = OSSL_SELF_TEST_new(cb, cbarg);
 265     if (st == NULL)
 266         return 0;
 267
 268     OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_PCT_KAT,
 269                                OSSL_SELF_TEST_DESC_PCT_ECDSA);
 270
 271     /* pub_key = priv_key * G (where G is a point on the curve) */
 272     if (!EC_POINT_mul(eckey->group, pub_key2, eckey->priv_key, NULL, NULL, ctx))
 273         goto err;
 274
 275     if (BN_num_bytes(pub_key2->X) > (int)sizeof(bytes))
 276         goto err;
 277     len = BN_bn2bin(pub_key2->X, bytes);
 278     if (OSSL_SELF_TEST_oncorrupt_byte(st, bytes)
 279             && BN_bin2bn(bytes, len, pub_key2->X) == NULL)
 280         goto err;
 281     ret = !EC_POINT_cmp(eckey->group, eckey->pub_key, pub_key2, ctx);
 282
 283 err:
 284     OSSL_SELF_TEST_onend(st, ret);
 285     OSSL_SELF_TEST_free(st);
 286     EC_POINT_free(pub_key2);
 287     return ret;
 288 }
 289
 290 /*
 291  * ECC Key generation.
 292  * See SP800-56AR3 5.6.1.2.2 "Key Pair Generation by Testing Candidates"
 293  *
 294  * Params:
 295  *     libctx A context containing an optional self test callback.
 296  *     eckey An EC key object that contains domain params. The generated keypair
 297  *           is stored in this object.
 298  *     pairwise_test Set to non zero to perform a pairwise test. If the test
 299  *                   fails then the keypair is not generated,
 300  * Returns 1 if the keypair was generated or 0 otherwise.
 301  */
 302 static int ec_generate_key(EC_KEY *eckey, int pairwise_test)
 303 {
 304     int ok = 0;
 305     BIGNUM *priv_key = NULL;
 306     const BIGNUM *tmp = NULL;
 307     BIGNUM *order = NULL;
 308     EC_POINT *pub_key = NULL;
 309     const EC_GROUP *group = eckey->group;
 310     BN_CTX *ctx = BN_CTX_secure_new_ex(eckey->libctx);
 311     int sm2 = EC_KEY_get_flags(eckey) & EC_FLAG_SM2_RANGE ? 1 : 0;
 312
 313     if (ctx == NULL)
 314         goto err;
 315
 316     if (eckey->priv_key == NULL) {
 317         priv_key = BN_secure_new();
 318         if (priv_key == NULL)
 319             goto err;
 320     } else
 321         priv_key = eckey->priv_key;
 322
 323     /*
 324      * Steps (1-2): Check domain parameters and security strength.
 325      * These steps must be done by the user. This would need to be
 326      * stated in the security policy.
 327      */
 328
 329     tmp = EC_GROUP_get0_order(group);
 330     if (tmp == NULL)
 331         goto err;
 332
 333     /*
 334      * Steps (3-7): priv_key = DRBG_RAND(order_n_bits) (range [1, n-1]).
 335      * Although this is slightly different from the standard, it is effectively
 336      * equivalent as it gives an unbiased result ranging from 1..n-1. It is also
 337      * faster as the standard needs to retry more often. Also doing
 338      * 1 + rand[0..n-2] would effect the way that tests feed dummy entropy into
 339      * rand so the simpler backward compatible method has been used here.
 340      */
 341
 342     /* range of SM2 private key is [1, n-1) */
 343     if (sm2) {
 344         order = BN_new();
 345         if (order == NULL || !BN_sub(order, tmp, BN_value_one()))
 346             goto err;
 347     } else {
 348         order = BN_dup(tmp);
 349         if (order == NULL)
 350             goto err;
 351     }
 352
 353     do
 354         if (!BN_priv_rand_range_ex(priv_key, order, 0, ctx))
 355             goto err;
 356     while (BN_is_zero(priv_key)) ;
 357
 358     if (eckey->pub_key == NULL) {
 359         pub_key = EC_POINT_new(group);
 360         if (pub_key == NULL)
 361             goto err;
 362     } else
 363         pub_key = eckey->pub_key;
 364
 365     /* Step (8) : pub_key = priv_key * G (where G is a point on the curve) */
 366     if (!EC_POINT_mul(group, pub_key, priv_key, NULL, NULL, ctx))
 367         goto err;
 368
 369     eckey->priv_key = priv_key;
 370     eckey->pub_key = pub_key;
 371     priv_key = NULL;
 372     pub_key = NULL;
 373
 374     eckey->dirty_cnt++;
 375
 376 #ifdef FIPS_MODULE
 377     pairwise_test = 1;
 378 #endif /* FIPS_MODULE */
 379
 380     ok = 1;
 381     if (pairwise_test) {
 382         OSSL_CALLBACK *cb = NULL;
 383         void *cbarg = NULL;
 384
 385         OSSL_SELF_TEST_get_callback(eckey->libctx, &cb, &cbarg);
 386         ok = ecdsa_keygen_pairwise_test(eckey, cb, cbarg)
 387              && ecdsa_keygen_knownanswer_test(eckey, ctx, cb, cbarg);
 388     }
 389 err:
 390     /* Step (9): If there is an error return an invalid keypair. */
 391     if (!ok) {
 392         ossl_set_error_state(OSSL_SELF_TEST_TYPE_PCT);
 393         BN_clear(eckey->priv_key);
 394         if (eckey->pub_key != NULL)
 395             EC_POINT_set_to_infinity(group, eckey->pub_key);
 396     }
 397
 398     EC_POINT_free(pub_key);
 399     BN_clear_free(priv_key);
 400     BN_CTX_free(ctx);
 401     BN_free(order);
 402     return ok;
 403 }
 404
 405 #ifndef FIPS_MODULE
 406 /*
 407  * This is similar to ec_generate_key(), except it uses an ikm to
 408  * derive the private key.
 409  */
 410 int ossl_ec_generate_key_dhkem(EC_KEY *eckey,
 411                                const unsigned char *ikm, size_t ikmlen)
 412 {
 413     int ok = 0;
 414
 415     if (eckey->priv_key == NULL) {
 416         eckey->priv_key = BN_secure_new();
 417         if (eckey->priv_key == NULL)
 418             goto err;
 419     }
 420     if (ossl_ec_dhkem_derive_private(eckey, eckey->priv_key, ikm, ikmlen) <= 0)
 421         goto err;
 422     if (eckey->pub_key == NULL) {
 423         eckey->pub_key = EC_POINT_new(eckey->group);
 424         if (eckey->pub_key == NULL)
 425             goto err;
 426     }
 427     if (!ossl_ec_key_simple_generate_public_key(eckey))
 428         goto err;
 429
 430     ok = 1;
 431 err:
 432     if (!ok) {
 433         BN_clear_free(eckey->priv_key);
 434         eckey->priv_key = NULL;
 435         if (eckey->pub_key != NULL)
 436             EC_POINT_set_to_infinity(eckey->group, eckey->pub_key);
 437     }
 438     return ok;
 439 }
 440 #endif
 441
 442 int ossl_ec_key_simple_generate_key(EC_KEY *eckey)
 443 {
 444     return ec_generate_key(eckey, 0);
 445 }
 446
 447 int ossl_ec_key_simple_generate_public_key(EC_KEY *eckey)
 448 {
 449     int ret;
 450     BN_CTX *ctx = BN_CTX_new_ex(eckey->libctx);
 451
 452     if (ctx == NULL)
 453         return 0;
 454
 455     /*
 456      * See SP800-56AR3 5.6.1.2.2: Step (8)
 457      * pub_key = priv_key * G (where G is a point on the curve)
 458      */
 459     ret = EC_POINT_mul(eckey->group, eckey->pub_key, eckey->priv_key, NULL,
 460                        NULL, ctx);
 461
 462     BN_CTX_free(ctx);
 463     if (ret == 1)
 464         eckey->dirty_cnt++;
 465
 466     return ret;
 467 }
 468
 469 int EC_KEY_check_key(const EC_KEY *eckey)
 470 {
 471     if (eckey == NULL || eckey->group == NULL || eckey->pub_key == NULL) {
 472         ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER);
 473         return 0;
 474     }
 475
 476     if (eckey->group->meth->keycheck == NULL) {
 477         ERR_raise(ERR_LIB_EC, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 478         return 0;
 479     }
 480
 481     return eckey->group->meth->keycheck(eckey);
 482 }
 483
 484 /*
 485  * Check the range of the EC public key.
 486  * See SP800-56A R3 Section 5.6.2.3.3 (Part 2)
 487  * i.e.
 488  *  - If q = odd prime p: Verify that xQ and yQ are integers in the
 489  *    interval[0, p - 1], OR
 490  *  - If q = 2m: Verify that xQ and yQ are bit strings of length m bits.
 491  * Returns 1 if the public key has a valid range, otherwise it returns 0.
 492  */
 493 static int ec_key_public_range_check(BN_CTX *ctx, const EC_KEY *key)
 494 {
 495     int ret = 0;
 496     BIGNUM *x, *y;
 497
 498     BN_CTX_start(ctx);
 499     x = BN_CTX_get(ctx);
 500     y = BN_CTX_get(ctx);
 501     if (y == NULL)
 502         goto err;
 503
 504     if (!EC_POINT_get_affine_coordinates(key->group, key->pub_key, x, y, ctx))
 505         goto err;
 506
 507     if (EC_GROUP_get_field_type(key->group) == NID_X9_62_prime_field) {
 508         if (BN_is_negative(x)
 509             || BN_cmp(x, key->group->field) >= 0
 510             || BN_is_negative(y)
 511             || BN_cmp(y, key->group->field) >= 0) {
 512             goto err;
 513         }
 514     } else {
 515         int m = EC_GROUP_get_degree(key->group);
 516         if (BN_num_bits(x) > m || BN_num_bits(y) > m) {
 517             goto err;
 518         }
 519     }
 520     ret = 1;
 521 err:
 522     BN_CTX_end(ctx);
 523     return ret;
 524 }
 525
 526 /*
 527  * ECC Partial Public-Key Validation as specified in SP800-56A R3
 528  * Section 5.6.2.3.4 ECC Partial Public-Key Validation Routine.
 529  */
 530 int ossl_ec_key_public_check_quick(const EC_KEY *eckey, BN_CTX *ctx)
 531 {
 532     if (eckey == NULL || eckey->group == NULL || eckey->pub_key == NULL) {
 533         ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER);
 534         return 0;
 535     }
 536
 537     /* 5.6.2.3.3 (Step 1): Q != infinity */
 538     if (EC_POINT_is_at_infinity(eckey->group, eckey->pub_key)) {
 539         ERR_raise(ERR_LIB_EC, EC_R_POINT_AT_INFINITY);
 540         return 0;
 541     }
 542
 543     /* 5.6.2.3.3 (Step 2) Test if the public key is in range */
 544     if (!ec_key_public_range_check(ctx, eckey)) {
 545         ERR_raise(ERR_LIB_EC, EC_R_COORDINATES_OUT_OF_RANGE);
 546         return 0;
 547     }
 548
 549     /* 5.6.2.3.3 (Step 3) is the pub_key on the elliptic curve */
 550     if (EC_POINT_is_on_curve(eckey->group, eckey->pub_key, ctx) <= 0) {
 551         ERR_raise(ERR_LIB_EC, EC_R_POINT_IS_NOT_ON_CURVE);
 552         return 0;
 553     }
 554     return 1;
 555 }
 556
 557 /*
 558  * ECC Key validation as specified in SP800-56A R3.
 559  * Section 5.6.2.3.3 ECC Full Public-Key Validation Routine.
 560  */
 561 int ossl_ec_key_public_check(const EC_KEY *eckey, BN_CTX *ctx)
 562 {
 563     int ret = 0;
 564     EC_POINT *point = NULL;
 565     const BIGNUM *order = NULL;
 566
 567     if (!ossl_ec_key_public_check_quick(eckey, ctx))
 568         return 0;
 569
 570     point = EC_POINT_new(eckey->group);
 571     if (point == NULL)
 572         return 0;
 573
 574     order = eckey->group->order;
 575     if (BN_is_zero(order)) {
 576         ERR_raise(ERR_LIB_EC, EC_R_INVALID_GROUP_ORDER);
 577         goto err;
 578     }
 579     /* 5.6.2.3.3 (Step 4) : pub_key * order is the point at infinity. */
 580     if (!EC_POINT_mul(eckey->group, point, NULL, eckey->pub_key, order, ctx)) {
 581         ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
 582         goto err;
 583     }
 584     if (!EC_POINT_is_at_infinity(eckey->group, point)) {
 585         ERR_raise(ERR_LIB_EC, EC_R_WRONG_ORDER);
 586         goto err;
 587     }
 588     ret = 1;
 589 err:
 590     EC_POINT_free(point);
 591     return ret;
 592 }
 593
 594 /*
 595  * ECC Key validation as specified in SP800-56A R3.
 596  * Section 5.6.2.1.2 Owner Assurance of Private-Key Validity
 597  * The private key is in the range [1, order-1]
 598  */
 599 int ossl_ec_key_private_check(const EC_KEY *eckey)
 600 {
 601     if (eckey == NULL || eckey->group == NULL || eckey->priv_key == NULL) {
 602         ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER);
 603         return 0;
 604     }
 605     if (BN_cmp(eckey->priv_key, BN_value_one()) < 0
 606         || BN_cmp(eckey->priv_key, eckey->group->order) >= 0) {
 607         ERR_raise(ERR_LIB_EC, EC_R_INVALID_PRIVATE_KEY);
 608         return 0;
 609     }
 610     return 1;
 611 }
 612
 613 /*
 614  * ECC Key validation as specified in SP800-56A R3.
 615  * Section 5.6.2.1.4 Owner Assurance of Pair-wise Consistency (b)
 616  * Check if generator * priv_key = pub_key
 617  */
 618 int ossl_ec_key_pairwise_check(const EC_KEY *eckey, BN_CTX *ctx)
 619 {
 620     int ret = 0;
 621     EC_POINT *point = NULL;
 622
 623     if (eckey == NULL
 624        || eckey->group == NULL
 625        || eckey->pub_key == NULL
 626        || eckey->priv_key == NULL) {
 627         ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER);
 628         return 0;
 629     }
 630
 631     point = EC_POINT_new(eckey->group);
 632     if (point == NULL)
 633         goto err;
 634
 635
 636     if (!EC_POINT_mul(eckey->group, point, eckey->priv_key, NULL, NULL, ctx)) {
 637         ERR_raise(ERR_LIB_EC, ERR_R_EC_LIB);
 638         goto err;
 639     }
 640     if (EC_POINT_cmp(eckey->group, point, eckey->pub_key, ctx) != 0) {
 641         ERR_raise(ERR_LIB_EC, EC_R_INVALID_PRIVATE_KEY);
 642         goto err;
 643     }
 644     ret = 1;
 645 err:
 646     EC_POINT_free(point);
 647     return ret;
 648 }
 649
 650
 651 /*
 652  * ECC Key validation as specified in SP800-56A R3.
 653  *    Section 5.6.2.3.3 ECC Full Public-Key Validation
 654  *    Section 5.6.2.1.2 Owner Assurance of Private-Key Validity
 655  *    Section 5.6.2.1.4 Owner Assurance of Pair-wise Consistency
 656  * NOTES:
 657  *    Before calling this method in fips mode, there should be an assurance that
 658  *    an approved elliptic-curve group is used.
 659  * Returns 1 if the key is valid, otherwise it returns 0.
 660  */
 661 int ossl_ec_key_simple_check_key(const EC_KEY *eckey)
 662 {
 663     int ok = 0;
 664     BN_CTX *ctx = NULL;
 665
 666     if (eckey == NULL) {
 667         ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER);
 668         return 0;
 669     }
 670     if ((ctx = BN_CTX_new_ex(eckey->libctx)) == NULL)
 671         return 0;
 672
 673     if (!ossl_ec_key_public_check(eckey, ctx))
 674         goto err;
 675
 676     if (eckey->priv_key != NULL) {
 677         if (!ossl_ec_key_private_check(eckey)
 678             || !ossl_ec_key_pairwise_check(eckey, ctx))
 679             goto err;
 680     }
 681     ok = 1;
 682 err:
 683     BN_CTX_free(ctx);
 684     return ok;
 685 }
 686
 687 int EC_KEY_set_public_key_affine_coordinates(EC_KEY *key, BIGNUM *x,
 688                                              BIGNUM *y)
 689 {
 690     BN_CTX *ctx = NULL;
 691     BIGNUM *tx, *ty;
 692     EC_POINT *point = NULL;
 693     int ok = 0;
 694
 695     if (key == NULL || key->group == NULL || x == NULL || y == NULL) {
 696         ERR_raise(ERR_LIB_EC, ERR_R_PASSED_NULL_PARAMETER);
 697         return 0;
 698     }
 699     ctx = BN_CTX_new_ex(key->libctx);
 700     if (ctx == NULL)
 701         return 0;
 702
 703     BN_CTX_start(ctx);
 704     point = EC_POINT_new(key->group);
 705
 706     if (point == NULL)
 707         goto err;
 708
 709     tx = BN_CTX_get(ctx);
 710     ty = BN_CTX_get(ctx);
 711     if (ty == NULL)
 712         goto err;
 713
 714     if (!EC_POINT_set_affine_coordinates(key->group, point, x, y, ctx))
 715         goto err;
 716     if (!EC_POINT_get_affine_coordinates(key->group, point, tx, ty, ctx))
 717         goto err;
 718
 719     /*
 720      * Check if retrieved coordinates match originals. The range check is done
 721      * inside EC_KEY_check_key().
 722      */
 723     if (BN_cmp(x, tx) || BN_cmp(y, ty)) {
 724         ERR_raise(ERR_LIB_EC, EC_R_COORDINATES_OUT_OF_RANGE);
 725         goto err;
 726     }
 727
 728     /* EC_KEY_set_public_key updates dirty_cnt */
 729     if (!EC_KEY_set_public_key(key, point))
 730         goto err;
 731
 732     if (EC_KEY_check_key(key) == 0)
 733         goto err;
 734
 735     ok = 1;
 736
 737  err:
 738     BN_CTX_end(ctx);
 739     BN_CTX_free(ctx);
 740     EC_POINT_free(point);
 741     return ok;
 742
 743 }
 744
 745 OSSL_LIB_CTX *ossl_ec_key_get_libctx(const EC_KEY *key)
 746 {
 747     return key->libctx;
 748 }
 749
 750 const char *ossl_ec_key_get0_propq(const EC_KEY *key)
 751 {
 752     return key->propq;
 753 }
 754
 755 void ossl_ec_key_set0_libctx(EC_KEY *key, OSSL_LIB_CTX *libctx)
 756 {
 757     key->libctx = libctx;
 758     /* Do we need to propagate this to the group? */
 759 }
 760
 761 const EC_GROUP *EC_KEY_get0_group(const EC_KEY *key)
 762 {
 763     return key->group;
 764 }
 765
 766 int EC_KEY_set_group(EC_KEY *key, const EC_GROUP *group)
 767 {
 768     if (key->meth->set_group != NULL && key->meth->set_group(key, group) == 0)
 769         return 0;
 770     EC_GROUP_free(key->group);
 771     key->group = EC_GROUP_dup(group);
 772     if (key->group != NULL && EC_GROUP_get_curve_name(key->group) == NID_sm2)
 773         EC_KEY_set_flags(key, EC_FLAG_SM2_RANGE);
 774
 775     key->dirty_cnt++;
 776     return (key->group == NULL) ? 0 : 1;
 777 }
 778
 779 const BIGNUM *EC_KEY_get0_private_key(const EC_KEY *key)
 780 {
 781     return key->priv_key;
 782 }
 783
 784 int EC_KEY_set_private_key(EC_KEY *key, const BIGNUM *priv_key)
 785 {
 786     int fixed_top;
 787     const BIGNUM *order = NULL;
 788     BIGNUM *tmp_key = NULL;
 789
 790     if (key->group == NULL || key->group->meth == NULL)
 791         return 0;
 792
 793     /*
 794      * Not only should key->group be set, but it should also be in a valid
 795      * fully initialized state.
 796      *
 797      * Specifically, to operate in constant time, we need that the group order
 798      * is set, as we use its length as the fixed public size of any scalar used
 799      * as an EC private key.
 800      */
 801     order = EC_GROUP_get0_order(key->group);
 802     if (order == NULL || BN_is_zero(order))
 803         return 0; /* This should never happen */
 804
 805     if (key->group->meth->set_private != NULL
 806         && key->group->meth->set_private(key, priv_key) == 0)
 807         return 0;
 808     if (key->meth->set_private != NULL
 809         && key->meth->set_private(key, priv_key) == 0)
 810         return 0;
 811
 812     /*
 813      * Return `0` to comply with legacy behavior for this function, see
 814      * https://github.com/openssl/openssl/issues/18744#issuecomment-1195175696
 815      */
 816     if (priv_key == NULL) {
 817         BN_clear_free(key->priv_key);
 818         key->priv_key = NULL;
 819         return 0; /* intentional for legacy compatibility */
 820     }
 821
 822     /*
 823      * We should never leak the bit length of the secret scalar in the key,
 824      * so we always set the `BN_FLG_CONSTTIME` flag on the internal `BIGNUM`
 825      * holding the secret scalar.
 826      *
 827      * This is important also because `BN_dup()` (and `BN_copy()`) do not
 828      * propagate the `BN_FLG_CONSTTIME` flag from the source `BIGNUM`, and
 829      * this brings an extra risk of inadvertently losing the flag, even when
 830      * the caller specifically set it.
 831      *
 832      * The propagation has been turned on and off a few times in the past
 833      * years because in some conditions has shown unintended consequences in
 834      * some code paths, so at the moment we can't fix this in the BN layer.
 835      *
 836      * In `EC_KEY_set_private_key()` we can work around the propagation by
 837      * manually setting the flag after `BN_dup()` as we know for sure that
 838      * inside the EC module the `BN_FLG_CONSTTIME` is always treated
 839      * correctly and should not generate unintended consequences.
 840      *
 841      * Setting the BN_FLG_CONSTTIME flag alone is never enough, we also have
 842      * to preallocate the BIGNUM internal buffer to a fixed public size big
 843      * enough that operations performed during the processing never trigger
 844      * a realloc which would leak the size of the scalar through memory
 845      * accesses.
 846      *
 847      * Fixed Length
 848      * ------------
 849      *
 850      * The order of the large prime subgroup of the curve is our choice for
 851      * a fixed public size, as that is generally the upper bound for
 852      * generating a private key in EC cryptosystems and should fit all valid
 853      * secret scalars.
 854      *
 855      * For preallocating the BIGNUM storage we look at the number of "words"
 856      * required for the internal representation of the order, and we
 857      * preallocate 2 extra "words" in case any of the subsequent processing
 858      * might temporarily overflow the order length.
 859      */
 860     tmp_key = BN_dup(priv_key);
 861     if (tmp_key == NULL)
 862         return 0;
 863
 864     BN_set_flags(tmp_key, BN_FLG_CONSTTIME);
 865
 866     fixed_top = bn_get_top(order) + 2;
 867     if (bn_wexpand(tmp_key, fixed_top) == NULL) {
 868         BN_clear_free(tmp_key);
 869         return 0;
 870     }
 871
 872     BN_clear_free(key->priv_key);
 873     key->priv_key = tmp_key;
 874     key->dirty_cnt++;
 875
 876     return 1;
 877 }
 878
 879 const EC_POINT *EC_KEY_get0_public_key(const EC_KEY *key)
 880 {
 881     return key->pub_key;
 882 }
 883
 884 int EC_KEY_set_public_key(EC_KEY *key, const EC_POINT *pub_key)
 885 {
 886     if (key->meth->set_public != NULL
 887         && key->meth->set_public(key, pub_key) == 0)
 888         return 0;
 889     EC_POINT_free(key->pub_key);
 890     key->pub_key = EC_POINT_dup(pub_key, key->group);
 891     key->dirty_cnt++;
 892     return (key->pub_key == NULL) ? 0 : 1;
 893 }
 894
 895 unsigned int EC_KEY_get_enc_flags(const EC_KEY *key)
 896 {
 897     return key->enc_flag;
 898 }
 899
 900 void EC_KEY_set_enc_flags(EC_KEY *key, unsigned int flags)
 901 {
 902     key->enc_flag = flags;
 903 }
 904
 905 point_conversion_form_t EC_KEY_get_conv_form(const EC_KEY *key)
 906 {
 907     return key->conv_form;
 908 }
 909
 910 void EC_KEY_set_conv_form(EC_KEY *key, point_conversion_form_t cform)
 911 {
 912     key->conv_form = cform;
 913     if (key->group != NULL)
 914         EC_GROUP_set_point_conversion_form(key->group, cform);
 915 }
 916
 917 void EC_KEY_set_asn1_flag(EC_KEY *key, int flag)
 918 {
 919     if (key->group != NULL)
 920         EC_GROUP_set_asn1_flag(key->group, flag);
 921 }
 922
 923 #ifndef OPENSSL_NO_DEPRECATED_3_0
 924 int EC_KEY_precompute_mult(EC_KEY *key, BN_CTX *ctx)
 925 {
 926     if (key->group == NULL)
 927         return 0;
 928     return EC_GROUP_precompute_mult(key->group, ctx);
 929 }
 930 #endif
 931
 932 int EC_KEY_get_flags(const EC_KEY *key)
 933 {
 934     return key->flags;
 935 }
 936
 937 void EC_KEY_set_flags(EC_KEY *key, int flags)
 938 {
 939     key->flags |= flags;
 940     key->dirty_cnt++;
 941 }
 942
 943 void EC_KEY_clear_flags(EC_KEY *key, int flags)
 944 {
 945     key->flags &= ~flags;
 946     key->dirty_cnt++;
 947 }
 948
 949 int EC_KEY_decoded_from_explicit_params(const EC_KEY *key)
 950 {
 951     if (key == NULL || key->group == NULL)
 952         return -1;
 953     return key->group->decoded_from_explicit_params;
 954 }
 955
 956 size_t EC_KEY_key2buf(const EC_KEY *key, point_conversion_form_t form,
 957                         unsigned char **pbuf, BN_CTX *ctx)
 958 {
 959     if (key == NULL || key->pub_key == NULL || key->group == NULL)
 960         return 0;
 961     return EC_POINT_point2buf(key->group, key->pub_key, form, pbuf, ctx);
 962 }
 963
 964 int EC_KEY_oct2key(EC_KEY *key, const unsigned char *buf, size_t len,
 965                    BN_CTX *ctx)
 966 {
 967     if (key == NULL || key->group == NULL)
 968         return 0;
 969     if (key->pub_key == NULL)
 970         key->pub_key = EC_POINT_new(key->group);
 971     if (key->pub_key == NULL)
 972         return 0;
 973     if (EC_POINT_oct2point(key->group, key->pub_key, buf, len, ctx) == 0)
 974         return 0;
 975     key->dirty_cnt++;
 976     /*
 977      * Save the point conversion form.
 978      * For non-custom curves the first octet of the buffer (excluding
 979      * the last significant bit) contains the point conversion form.
 980      * EC_POINT_oct2point() has already performed sanity checking of
 981      * the buffer so we know it is valid.
 982      */
 983     if ((key->group->meth->flags & EC_FLAGS_CUSTOM_CURVE) == 0)
 984         key->conv_form = (point_conversion_form_t)(buf[0] & ~0x01);
 985     return 1;
 986 }
 987
 988 size_t EC_KEY_priv2oct(const EC_KEY *eckey,
 989                        unsigned char *buf, size_t len)
 990 {
 991     if (eckey->group == NULL || eckey->group->meth == NULL)
 992         return 0;
 993     if (eckey->group->meth->priv2oct == NULL) {
 994         ERR_raise(ERR_LIB_EC, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 995         return 0;
 996     }
 997
 998     return eckey->group->meth->priv2oct(eckey, buf, len);
 999 }
1000
1001 size_t ossl_ec_key_simple_priv2oct(const EC_KEY *eckey,
1002                                    unsigned char *buf, size_t len)
1003 {
1004     size_t buf_len;
1005
1006     buf_len = (EC_GROUP_order_bits(eckey->group) + 7) / 8;
1007     if (eckey->priv_key == NULL)
1008         return 0;
1009     if (buf == NULL)
1010         return buf_len;
1011     else if (len < buf_len)
1012         return 0;
1013
1014     /* Octetstring may need leading zeros if BN is to short */
1015
1016     if (BN_bn2binpad(eckey->priv_key, buf, buf_len) == -1) {
1017         ERR_raise(ERR_LIB_EC, EC_R_BUFFER_TOO_SMALL);
1018         return 0;
1019     }
1020
1021     return buf_len;
1022 }
1023
1024 int EC_KEY_oct2priv(EC_KEY *eckey, const unsigned char *buf, size_t len)
1025 {
1026     int ret;
1027
1028     if (eckey->group == NULL || eckey->group->meth == NULL)
1029         return 0;
1030     if (eckey->group->meth->oct2priv == NULL) {
1031         ERR_raise(ERR_LIB_EC, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1032         return 0;
1033     }
1034     ret = eckey->group->meth->oct2priv(eckey, buf, len);
1035     if (ret == 1)
1036         eckey->dirty_cnt++;
1037     return ret;
1038 }
1039
1040 int ossl_ec_key_simple_oct2priv(EC_KEY *eckey, const unsigned char *buf,
1041                                 size_t len)
1042 {
1043     if (eckey->priv_key == NULL)
1044         eckey->priv_key = BN_secure_new();
1045     if (eckey->priv_key == NULL) {
1046         ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
1047         return 0;
1048     }
1049     if (BN_bin2bn(buf, len, eckey->priv_key) == NULL) {
1050         ERR_raise(ERR_LIB_EC, ERR_R_BN_LIB);
1051         return 0;
1052     }
1053     eckey->dirty_cnt++;
1054     return 1;
1055 }
1056
1057 size_t EC_KEY_priv2buf(const EC_KEY *eckey, unsigned char **pbuf)
1058 {
1059     size_t len;
1060     unsigned char *buf;
1061
1062     len = EC_KEY_priv2oct(eckey, NULL, 0);
1063     if (len == 0)
1064         return 0;
1065     if ((buf = OPENSSL_malloc(len)) == NULL)
1066         return 0;
1067     len = EC_KEY_priv2oct(eckey, buf, len);
1068     if (len == 0) {
1069         OPENSSL_free(buf);
1070         return 0;
1071     }
1072     *pbuf = buf;
1073     return len;
1074 }
1075
1076 int EC_KEY_can_sign(const EC_KEY *eckey)
1077 {
1078     if (eckey->group == NULL || eckey->group->meth == NULL
1079         || (eckey->group->meth->flags & EC_FLAGS_NO_SIGN))
1080         return 0;
1081     return 1;
1082 }
1083
1084 /*
1085  * FIPS 140-2 IG 9.9 AS09.33
1086  * Perform a sign/verify operation.
1087  *
1088  * NOTE: When generating keys for key-agreement schemes - FIPS 140-2 IG 9.9
1089  * states that no additional pairwise tests are required (apart from the tests
1090  * specified in SP800-56A) when generating keys. Hence pairwise ECDH tests are
1091  * omitted here.
1092  */
1093 static int ecdsa_keygen_pairwise_test(EC_KEY *eckey, OSSL_CALLBACK *cb,
1094                                       void *cbarg)
1095 {
1096     int ret = 0;
1097     unsigned char dgst[16] = {0};
1098     int dgst_len = (int)sizeof(dgst);
1099     ECDSA_SIG *sig = NULL;
1100     OSSL_SELF_TEST *st = NULL;
1101
1102     st = OSSL_SELF_TEST_new(cb, cbarg);
1103     if (st == NULL)
1104         return 0;
1105
1106     OSSL_SELF_TEST_onbegin(st, OSSL_SELF_TEST_TYPE_PCT,
1107                            OSSL_SELF_TEST_DESC_PCT_ECDSA);
1108
1109     sig = ECDSA_do_sign(dgst, dgst_len, eckey);
1110     if (sig == NULL)
1111         goto err;
1112
1113     OSSL_SELF_TEST_oncorrupt_byte(st, dgst);
1114
1115     if (ECDSA_do_verify(dgst, dgst_len, sig, eckey) != 1)
1116         goto err;
1117
1118     ret = 1;
1119 err:
1120     OSSL_SELF_TEST_onend(st, ret);
1121     OSSL_SELF_TEST_free(st);
1122     ECDSA_SIG_free(sig);
1123     return ret;
1124 }