crypto/ec/ec_lib.c

   1 /*
   2  * Copyright 2001-2016 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  12  * Binary polynomial ECC support in OpenSSL originally developed by
  13  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
  14  */
  15
  16 #include <string.h>
  17
  18 #include <openssl/err.h>
  19 #include <openssl/opensslv.h>
  20
  21 #include "ec_lcl.h"
  22
  23 /* functions for EC_GROUP objects */
  24
  25 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
  26 {
  27     EC_GROUP *ret;
  28
  29     if (meth == NULL) {
  30         ECerr(EC_F_EC_GROUP_NEW, EC_R_SLOT_FULL);
  31         return NULL;
  32     }
  33     if (meth->group_init == 0) {
  34         ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  35         return NULL;
  36     }
  37
  38     ret = OPENSSL_zalloc(sizeof(*ret));
  39     if (ret == NULL) {
  40         ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
  41         return NULL;
  42     }
  43
  44     ret->meth = meth;
  45     if ((ret->meth->flags & EC_FLAGS_CUSTOM_CURVE) == 0) {
  46         ret->order = BN_new();
  47         if (ret->order == NULL)
  48             goto err;
  49         ret->cofactor = BN_new();
  50         if (ret->cofactor == NULL)
  51             goto err;
  52     }
  53     ret->asn1_flag = OPENSSL_EC_NAMED_CURVE;
  54     ret->asn1_form = POINT_CONVERSION_UNCOMPRESSED;
  55     if (!meth->group_init(ret))
  56         goto err;
  57     return ret;
  58
  59  err:
  60     BN_free(ret->order);
  61     BN_free(ret->cofactor);
  62     OPENSSL_free(ret);
  63     return NULL;
  64 }
  65
  66 void EC_pre_comp_free(EC_GROUP *group)
  67 {
  68     switch (group->pre_comp_type) {
  69     default:
  70         break;
  71 #ifdef ECP_NISTZ256_REFERENCE_IMPLEMENTATION
  72     case PCT_nistz256:
  73         EC_nistz256_pre_comp_free(group->pre_comp.nistz256);
  74         break;
  75 #endif
  76 #ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
  77     case PCT_nistp224:
  78         EC_nistp224_pre_comp_free(group->pre_comp.nistp224);
  79         break;
  80     case PCT_nistp256:
  81         EC_nistp256_pre_comp_free(group->pre_comp.nistp256);
  82         break;
  83     case PCT_nistp521:
  84         EC_nistp521_pre_comp_free(group->pre_comp.nistp521);
  85         break;
  86 #endif
  87     case PCT_ec:
  88         EC_ec_pre_comp_free(group->pre_comp.ec);
  89         break;
  90     }
  91     group->pre_comp.ec = NULL;
  92 }
  93
  94 void EC_GROUP_free(EC_GROUP *group)
  95 {
  96     if (!group)
  97         return;
  98
  99     if (group->meth->group_finish != 0)
 100         group->meth->group_finish(group);
 101
 102     EC_pre_comp_free(group);
 103     BN_MONT_CTX_free(group->mont_data);
 104     EC_POINT_free(group->generator);
 105     BN_free(group->order);
 106     BN_free(group->cofactor);
 107     OPENSSL_free(group->seed);
 108     OPENSSL_free(group);
 109 }
 110
 111 void EC_GROUP_clear_free(EC_GROUP *group)
 112 {
 113     if (!group)
 114         return;
 115
 116     if (group->meth->group_clear_finish != 0)
 117         group->meth->group_clear_finish(group);
 118     else if (group->meth->group_finish != 0)
 119         group->meth->group_finish(group);
 120
 121     EC_pre_comp_free(group);
 122     BN_MONT_CTX_free(group->mont_data);
 123     EC_POINT_clear_free(group->generator);
 124     BN_clear_free(group->order);
 125     BN_clear_free(group->cofactor);
 126     OPENSSL_clear_free(group->seed, group->seed_len);
 127     OPENSSL_clear_free(group, sizeof(*group));
 128 }
 129
 130 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 131 {
 132     if (dest->meth->group_copy == 0) {
 133         ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 134         return 0;
 135     }
 136     if (dest->meth != src->meth) {
 137         ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 138         return 0;
 139     }
 140     if (dest == src)
 141         return 1;
 142
 143     /* Copy precomputed */
 144     dest->pre_comp_type = src->pre_comp_type;
 145     switch (src->pre_comp_type) {
 146     default:
 147         dest->pre_comp.ec = NULL;
 148         break;
 149 #ifdef ECP_NISTZ256_REFERENCE_IMPLEMENTATION
 150     case PCT_nistz256:
 151         dest->pre_comp.nistz256 = EC_nistz256_pre_comp_dup(src->pre_comp.nistz256);
 152         break;
 153 #endif
 154 #ifndef OPENSSL_NO_EC_NISTP_64_GCC_128
 155     case PCT_nistp224:
 156         dest->pre_comp.nistp224 = EC_nistp224_pre_comp_dup(src->pre_comp.nistp224);
 157         break;
 158     case PCT_nistp256:
 159         dest->pre_comp.nistp256 = EC_nistp256_pre_comp_dup(src->pre_comp.nistp256);
 160         break;
 161     case PCT_nistp521:
 162         dest->pre_comp.nistp521 = EC_nistp521_pre_comp_dup(src->pre_comp.nistp521);
 163         break;
 164 #endif
 165     case PCT_ec:
 166         dest->pre_comp.ec = EC_ec_pre_comp_dup(src->pre_comp.ec);
 167         break;
 168     }
 169
 170     if (src->mont_data != NULL) {
 171         if (dest->mont_data == NULL) {
 172             dest->mont_data = BN_MONT_CTX_new();
 173             if (dest->mont_data == NULL)
 174                 return 0;
 175         }
 176         if (!BN_MONT_CTX_copy(dest->mont_data, src->mont_data))
 177             return 0;
 178     } else {
 179         /* src->generator == NULL */
 180         BN_MONT_CTX_free(dest->mont_data);
 181         dest->mont_data = NULL;
 182     }
 183
 184     if (src->generator != NULL) {
 185         if (dest->generator == NULL) {
 186             dest->generator = EC_POINT_new(dest);
 187             if (dest->generator == NULL)
 188                 return 0;
 189         }
 190         if (!EC_POINT_copy(dest->generator, src->generator))
 191             return 0;
 192     } else {
 193         /* src->generator == NULL */
 194         EC_POINT_clear_free(dest->generator);
 195         dest->generator = NULL;
 196     }
 197
 198     if ((src->meth->flags & EC_FLAGS_CUSTOM_CURVE) == 0) {
 199         if (!BN_copy(dest->order, src->order))
 200             return 0;
 201         if (!BN_copy(dest->cofactor, src->cofactor))
 202             return 0;
 203     }
 204
 205     dest->curve_name = src->curve_name;
 206     dest->asn1_flag = src->asn1_flag;
 207     dest->asn1_form = src->asn1_form;
 208
 209     if (src->seed) {
 210         OPENSSL_free(dest->seed);
 211         dest->seed = OPENSSL_malloc(src->seed_len);
 212         if (dest->seed == NULL)
 213             return 0;
 214         if (!memcpy(dest->seed, src->seed, src->seed_len))
 215             return 0;
 216         dest->seed_len = src->seed_len;
 217     } else {
 218         OPENSSL_free(dest->seed);
 219         dest->seed = NULL;
 220         dest->seed_len = 0;
 221     }
 222
 223     return dest->meth->group_copy(dest, src);
 224 }
 225
 226 EC_GROUP *EC_GROUP_dup(const EC_GROUP *a)
 227 {
 228     EC_GROUP *t = NULL;
 229     int ok = 0;
 230
 231     if (a == NULL)
 232         return NULL;
 233
 234     if ((t = EC_GROUP_new(a->meth)) == NULL)
 235         return (NULL);
 236     if (!EC_GROUP_copy(t, a))
 237         goto err;
 238
 239     ok = 1;
 240
 241  err:
 242     if (!ok) {
 243         EC_GROUP_free(t);
 244         return NULL;
 245     }
 246         return t;
 247 }
 248
 249 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
 250 {
 251     return group->meth;
 252 }
 253
 254 int EC_METHOD_get_field_type(const EC_METHOD *meth)
 255 {
 256     return meth->field_type;
 257 }
 258
 259 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
 260                            const BIGNUM *order, const BIGNUM *cofactor)
 261 {
 262     if (generator == NULL) {
 263         ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_PASSED_NULL_PARAMETER);
 264         return 0;
 265     }
 266
 267     if (group->generator == NULL) {
 268         group->generator = EC_POINT_new(group);
 269         if (group->generator == NULL)
 270             return 0;
 271     }
 272     if (!EC_POINT_copy(group->generator, generator))
 273         return 0;
 274
 275     if (order != NULL) {
 276         if (!BN_copy(group->order, order))
 277             return 0;
 278     } else
 279         BN_zero(group->order);
 280
 281     if (cofactor != NULL) {
 282         if (!BN_copy(group->cofactor, cofactor))
 283             return 0;
 284     } else
 285         BN_zero(group->cofactor);
 286
 287     /*
 288      * Some groups have an order with
 289      * factors of two, which makes the Montgomery setup fail.
 290      * |group->mont_data| will be NULL in this case.
 291      */
 292     if (BN_is_odd(group->order)) {
 293         return ec_precompute_mont_data(group);
 294     }
 295
 296     BN_MONT_CTX_free(group->mont_data);
 297     group->mont_data = NULL;
 298     return 1;
 299 }
 300
 301 const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
 302 {
 303     return group->generator;
 304 }
 305
 306 BN_MONT_CTX *EC_GROUP_get_mont_data(const EC_GROUP *group)
 307 {
 308     return group->mont_data;
 309 }
 310
 311 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 312 {
 313     if (group->order == NULL)
 314         return 0;
 315     if (!BN_copy(order, group->order))
 316         return 0;
 317
 318     return !BN_is_zero(order);
 319 }
 320
 321 const BIGNUM *EC_GROUP_get0_order(const EC_GROUP *group)
 322 {
 323     return group->order;
 324 }
 325
 326 int EC_GROUP_order_bits(const EC_GROUP *group)
 327 {
 328     OPENSSL_assert(group->meth->group_order_bits != NULL);
 329     return group->meth->group_order_bits(group);
 330 }
 331
 332 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor,
 333                           BN_CTX *ctx)
 334 {
 335
 336     if (group->cofactor == NULL)
 337         return 0;
 338     if (!BN_copy(cofactor, group->cofactor))
 339         return 0;
 340
 341     return !BN_is_zero(group->cofactor);
 342 }
 343
 344 const BIGNUM *EC_GROUP_get0_cofactor(const EC_GROUP *group)
 345 {
 346     return group->cofactor;
 347 }
 348
 349 void EC_GROUP_set_curve_name(EC_GROUP *group, int nid)
 350 {
 351     group->curve_name = nid;
 352 }
 353
 354 int EC_GROUP_get_curve_name(const EC_GROUP *group)
 355 {
 356     return group->curve_name;
 357 }
 358
 359 void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag)
 360 {
 361     group->asn1_flag = flag;
 362 }
 363
 364 int EC_GROUP_get_asn1_flag(const EC_GROUP *group)
 365 {
 366     return group->asn1_flag;
 367 }
 368
 369 void EC_GROUP_set_point_conversion_form(EC_GROUP *group,
 370                                         point_conversion_form_t form)
 371 {
 372     group->asn1_form = form;
 373 }
 374
 375 point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP
 376                                                            *group)
 377 {
 378     return group->asn1_form;
 379 }
 380
 381 size_t EC_GROUP_set_seed(EC_GROUP *group, const unsigned char *p, size_t len)
 382 {
 383     OPENSSL_free(group->seed);
 384     group->seed = NULL;
 385     group->seed_len = 0;
 386
 387     if (!len || !p)
 388         return 1;
 389
 390     if ((group->seed = OPENSSL_malloc(len)) == NULL)
 391         return 0;
 392     memcpy(group->seed, p, len);
 393     group->seed_len = len;
 394
 395     return len;
 396 }
 397
 398 unsigned char *EC_GROUP_get0_seed(const EC_GROUP *group)
 399 {
 400     return group->seed;
 401 }
 402
 403 size_t EC_GROUP_get_seed_len(const EC_GROUP *group)
 404 {
 405     return group->seed_len;
 406 }
 407
 408 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
 409                            const BIGNUM *b, BN_CTX *ctx)
 410 {
 411     if (group->meth->group_set_curve == 0) {
 412         ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 413         return 0;
 414     }
 415     return group->meth->group_set_curve(group, p, a, b, ctx);
 416 }
 417
 418 int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a,
 419                            BIGNUM *b, BN_CTX *ctx)
 420 {
 421     if (group->meth->group_get_curve == 0) {
 422         ECerr(EC_F_EC_GROUP_GET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 423         return 0;
 424     }
 425     return group->meth->group_get_curve(group, p, a, b, ctx);
 426 }
 427
 428 #ifndef OPENSSL_NO_EC2M
 429 int EC_GROUP_set_curve_GF2m(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
 430                             const BIGNUM *b, BN_CTX *ctx)
 431 {
 432     if (group->meth->group_set_curve == 0) {
 433         ECerr(EC_F_EC_GROUP_SET_CURVE_GF2M,
 434               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 435         return 0;
 436     }
 437     return group->meth->group_set_curve(group, p, a, b, ctx);
 438 }
 439
 440 int EC_GROUP_get_curve_GF2m(const EC_GROUP *group, BIGNUM *p, BIGNUM *a,
 441                             BIGNUM *b, BN_CTX *ctx)
 442 {
 443     if (group->meth->group_get_curve == 0) {
 444         ECerr(EC_F_EC_GROUP_GET_CURVE_GF2M,
 445               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 446         return 0;
 447     }
 448     return group->meth->group_get_curve(group, p, a, b, ctx);
 449 }
 450 #endif
 451
 452 int EC_GROUP_get_degree(const EC_GROUP *group)
 453 {
 454     if (group->meth->group_get_degree == 0) {
 455         ECerr(EC_F_EC_GROUP_GET_DEGREE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 456         return 0;
 457     }
 458     return group->meth->group_get_degree(group);
 459 }
 460
 461 int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)
 462 {
 463     if (group->meth->group_check_discriminant == 0) {
 464         ECerr(EC_F_EC_GROUP_CHECK_DISCRIMINANT,
 465               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 466         return 0;
 467     }
 468     return group->meth->group_check_discriminant(group, ctx);
 469 }
 470
 471 int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx)
 472 {
 473     int r = 0;
 474     BIGNUM *a1, *a2, *a3, *b1, *b2, *b3;
 475     BN_CTX *ctx_new = NULL;
 476
 477     /* compare the field types */
 478     if (EC_METHOD_get_field_type(EC_GROUP_method_of(a)) !=
 479         EC_METHOD_get_field_type(EC_GROUP_method_of(b)))
 480         return 1;
 481     /* compare the curve name (if present in both) */
 482     if (EC_GROUP_get_curve_name(a) && EC_GROUP_get_curve_name(b) &&
 483         EC_GROUP_get_curve_name(a) != EC_GROUP_get_curve_name(b))
 484         return 1;
 485     if (a->meth->flags & EC_FLAGS_CUSTOM_CURVE)
 486         return 0;
 487
 488     if (ctx == NULL)
 489         ctx_new = ctx = BN_CTX_new();
 490     if (ctx == NULL)
 491         return -1;
 492
 493     BN_CTX_start(ctx);
 494     a1 = BN_CTX_get(ctx);
 495     a2 = BN_CTX_get(ctx);
 496     a3 = BN_CTX_get(ctx);
 497     b1 = BN_CTX_get(ctx);
 498     b2 = BN_CTX_get(ctx);
 499     b3 = BN_CTX_get(ctx);
 500     if (b3 == NULL) {
 501         BN_CTX_end(ctx);
 502         BN_CTX_free(ctx_new);
 503         return -1;
 504     }
 505
 506     /*
 507      * XXX This approach assumes that the external representation of curves
 508      * over the same field type is the same.
 509      */
 510     if (!a->meth->group_get_curve(a, a1, a2, a3, ctx) ||
 511         !b->meth->group_get_curve(b, b1, b2, b3, ctx))
 512         r = 1;
 513
 514     if (r || BN_cmp(a1, b1) || BN_cmp(a2, b2) || BN_cmp(a3, b3))
 515         r = 1;
 516
 517     /* XXX EC_POINT_cmp() assumes that the methods are equal */
 518     if (r || EC_POINT_cmp(a, EC_GROUP_get0_generator(a),
 519                           EC_GROUP_get0_generator(b), ctx))
 520         r = 1;
 521
 522     if (!r) {
 523         const BIGNUM *ao, *bo, *ac, *bc;
 524         /* compare the order and cofactor */
 525         ao = EC_GROUP_get0_order(a);
 526         bo = EC_GROUP_get0_order(b);
 527         ac = EC_GROUP_get0_cofactor(a);
 528         bc = EC_GROUP_get0_cofactor(b);
 529         if (ao == NULL || bo == NULL) {
 530             BN_CTX_end(ctx);
 531             BN_CTX_free(ctx_new);
 532             return -1;
 533         }
 534         if (BN_cmp(ao, bo) || BN_cmp(ac, bc))
 535             r = 1;
 536     }
 537
 538     BN_CTX_end(ctx);
 539     BN_CTX_free(ctx_new);
 540
 541     return r;
 542 }
 543
 544 /* functions for EC_POINT objects */
 545
 546 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 547 {
 548     EC_POINT *ret;
 549
 550     if (group == NULL) {
 551         ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 552         return NULL;
 553     }
 554     if (group->meth->point_init == 0) {
 555         ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 556         return NULL;
 557     }
 558
 559     ret = OPENSSL_zalloc(sizeof(*ret));
 560     if (ret == NULL) {
 561         ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 562         return NULL;
 563     }
 564
 565     ret->meth = group->meth;
 566
 567     if (!ret->meth->point_init(ret)) {
 568         OPENSSL_free(ret);
 569         return NULL;
 570     }
 571
 572     return ret;
 573 }
 574
 575 void EC_POINT_free(EC_POINT *point)
 576 {
 577     if (!point)
 578         return;
 579
 580     if (point->meth->point_finish != 0)
 581         point->meth->point_finish(point);
 582     OPENSSL_free(point);
 583 }
 584
 585 void EC_POINT_clear_free(EC_POINT *point)
 586 {
 587     if (!point)
 588         return;
 589
 590     if (point->meth->point_clear_finish != 0)
 591         point->meth->point_clear_finish(point);
 592     else if (point->meth->point_finish != 0)
 593         point->meth->point_finish(point);
 594     OPENSSL_clear_free(point, sizeof(*point));
 595 }
 596
 597 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 598 {
 599     if (dest->meth->point_copy == 0) {
 600         ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 601         return 0;
 602     }
 603     if (dest->meth != src->meth) {
 604         ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 605         return 0;
 606     }
 607     if (dest == src)
 608         return 1;
 609     return dest->meth->point_copy(dest, src);
 610 }
 611
 612 EC_POINT *EC_POINT_dup(const EC_POINT *a, const EC_GROUP *group)
 613 {
 614     EC_POINT *t;
 615     int r;
 616
 617     if (a == NULL)
 618         return NULL;
 619
 620     t = EC_POINT_new(group);
 621     if (t == NULL)
 622         return (NULL);
 623     r = EC_POINT_copy(t, a);
 624     if (!r) {
 625         EC_POINT_free(t);
 626         return NULL;
 627     }
 628     return t;
 629 }
 630
 631 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
 632 {
 633     return point->meth;
 634 }
 635
 636 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 637 {
 638     if (group->meth->point_set_to_infinity == 0) {
 639         ECerr(EC_F_EC_POINT_SET_TO_INFINITY,
 640               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 641         return 0;
 642     }
 643     if (group->meth != point->meth) {
 644         ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 645         return 0;
 646     }
 647     return group->meth->point_set_to_infinity(group, point);
 648 }
 649
 650 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group,
 651                                              EC_POINT *point, const BIGNUM *x,
 652                                              const BIGNUM *y, const BIGNUM *z,
 653                                              BN_CTX *ctx)
 654 {
 655     if (group->meth->point_set_Jprojective_coordinates_GFp == 0) {
 656         ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP,
 657               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 658         return 0;
 659     }
 660     if (group->meth != point->meth) {
 661         ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP,
 662               EC_R_INCOMPATIBLE_OBJECTS);
 663         return 0;
 664     }
 665     return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x,
 666                                                               y, z, ctx);
 667 }
 668
 669 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
 670                                              const EC_POINT *point, BIGNUM *x,
 671                                              BIGNUM *y, BIGNUM *z,
 672                                              BN_CTX *ctx)
 673 {
 674     if (group->meth->point_get_Jprojective_coordinates_GFp == 0) {
 675         ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP,
 676               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 677         return 0;
 678     }
 679     if (group->meth != point->meth) {
 680         ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP,
 681               EC_R_INCOMPATIBLE_OBJECTS);
 682         return 0;
 683     }
 684     return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x,
 685                                                               y, z, ctx);
 686 }
 687
 688 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group,
 689                                         EC_POINT *point, const BIGNUM *x,
 690                                         const BIGNUM *y, BN_CTX *ctx)
 691 {
 692     if (group->meth->point_set_affine_coordinates == 0) {
 693         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP,
 694               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 695         return 0;
 696     }
 697     if (group->meth != point->meth) {
 698         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP,
 699               EC_R_INCOMPATIBLE_OBJECTS);
 700         return 0;
 701     }
 702     if (!group->meth->point_set_affine_coordinates(group, point, x, y, ctx))
 703         return 0;
 704
 705     if (EC_POINT_is_on_curve(group, point, ctx) <= 0) {
 706         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP,
 707               EC_R_POINT_IS_NOT_ON_CURVE);
 708         return 0;
 709     }
 710     return 1;
 711 }
 712
 713 #ifndef OPENSSL_NO_EC2M
 714 int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group,
 715                                          EC_POINT *point, const BIGNUM *x,
 716                                          const BIGNUM *y, BN_CTX *ctx)
 717 {
 718     if (group->meth->point_set_affine_coordinates == 0) {
 719         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M,
 720               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 721         return 0;
 722     }
 723     if (group->meth != point->meth) {
 724         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M,
 725               EC_R_INCOMPATIBLE_OBJECTS);
 726         return 0;
 727     }
 728     if (!group->meth->point_set_affine_coordinates(group, point, x, y, ctx))
 729         return 0;
 730
 731     if (EC_POINT_is_on_curve(group, point, ctx) <= 0) {
 732         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M,
 733               EC_R_POINT_IS_NOT_ON_CURVE);
 734         return 0;
 735     }
 736     return 1;
 737 }
 738 #endif
 739
 740 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group,
 741                                         const EC_POINT *point, BIGNUM *x,
 742                                         BIGNUM *y, BN_CTX *ctx)
 743 {
 744     if (group->meth->point_get_affine_coordinates == 0) {
 745         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP,
 746               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 747         return 0;
 748     }
 749     if (group->meth != point->meth) {
 750         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP,
 751               EC_R_INCOMPATIBLE_OBJECTS);
 752         return 0;
 753     }
 754     return group->meth->point_get_affine_coordinates(group, point, x, y, ctx);
 755 }
 756
 757 #ifndef OPENSSL_NO_EC2M
 758 int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group,
 759                                          const EC_POINT *point, BIGNUM *x,
 760                                          BIGNUM *y, BN_CTX *ctx)
 761 {
 762     if (group->meth->point_get_affine_coordinates == 0) {
 763         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M,
 764               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 765         return 0;
 766     }
 767     if (group->meth != point->meth) {
 768         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M,
 769               EC_R_INCOMPATIBLE_OBJECTS);
 770         return 0;
 771     }
 772     return group->meth->point_get_affine_coordinates(group, point, x, y, ctx);
 773 }
 774 #endif
 775
 776 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 777                  const EC_POINT *b, BN_CTX *ctx)
 778 {
 779     if (group->meth->add == 0) {
 780         ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 781         return 0;
 782     }
 783     if ((group->meth != r->meth) || (r->meth != a->meth)
 784         || (a->meth != b->meth)) {
 785         ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 786         return 0;
 787     }
 788     return group->meth->add(group, r, a, b, ctx);
 789 }
 790
 791 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 792                  BN_CTX *ctx)
 793 {
 794     if (group->meth->dbl == 0) {
 795         ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 796         return 0;
 797     }
 798     if ((group->meth != r->meth) || (r->meth != a->meth)) {
 799         ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 800         return 0;
 801     }
 802     return group->meth->dbl(group, r, a, ctx);
 803 }
 804
 805 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
 806 {
 807     if (group->meth->invert == 0) {
 808         ECerr(EC_F_EC_POINT_INVERT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 809         return 0;
 810     }
 811     if (group->meth != a->meth) {
 812         ECerr(EC_F_EC_POINT_INVERT, EC_R_INCOMPATIBLE_OBJECTS);
 813         return 0;
 814     }
 815     return group->meth->invert(group, a, ctx);
 816 }
 817
 818 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 819 {
 820     if (group->meth->is_at_infinity == 0) {
 821         ECerr(EC_F_EC_POINT_IS_AT_INFINITY,
 822               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 823         return 0;
 824     }
 825     if (group->meth != point->meth) {
 826         ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 827         return 0;
 828     }
 829     return group->meth->is_at_infinity(group, point);
 830 }
 831
 832 /*
 833  * Check whether an EC_POINT is on the curve or not. Note that the return
 834  * value for this function should NOT be treated as a boolean. Return values:
 835  *  1: The point is on the curve
 836  *  0: The point is not on the curve
 837  * -1: An error occurred
 838  */
 839 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
 840                          BN_CTX *ctx)
 841 {
 842     if (group->meth->is_on_curve == 0) {
 843         ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 844         return 0;
 845     }
 846     if (group->meth != point->meth) {
 847         ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
 848         return 0;
 849     }
 850     return group->meth->is_on_curve(group, point, ctx);
 851 }
 852
 853 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
 854                  BN_CTX *ctx)
 855 {
 856     if (group->meth->point_cmp == 0) {
 857         ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 858         return -1;
 859     }
 860     if ((group->meth != a->meth) || (a->meth != b->meth)) {
 861         ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
 862         return -1;
 863     }
 864     return group->meth->point_cmp(group, a, b, ctx);
 865 }
 866
 867 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
 868 {
 869     if (group->meth->make_affine == 0) {
 870         ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 871         return 0;
 872     }
 873     if (group->meth != point->meth) {
 874         ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 875         return 0;
 876     }
 877     return group->meth->make_affine(group, point, ctx);
 878 }
 879
 880 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num,
 881                           EC_POINT *points[], BN_CTX *ctx)
 882 {
 883     size_t i;
 884
 885     if (group->meth->points_make_affine == 0) {
 886         ECerr(EC_F_EC_POINTS_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 887         return 0;
 888     }
 889     for (i = 0; i < num; i++) {
 890         if (group->meth != points[i]->meth) {
 891             ECerr(EC_F_EC_POINTS_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 892             return 0;
 893         }
 894     }
 895     return group->meth->points_make_affine(group, num, points, ctx);
 896 }
 897
 898 /*
 899  * Functions for point multiplication. If group->meth->mul is 0, we use the
 900  * wNAF-based implementations in ec_mult.c; otherwise we dispatch through
 901  * methods.
 902  */
 903
 904 int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
 905                   size_t num, const EC_POINT *points[],
 906                   const BIGNUM *scalars[], BN_CTX *ctx)
 907 {
 908     if (group->meth->mul == 0)
 909         /* use default */
 910         return ec_wNAF_mul(group, r, scalar, num, points, scalars, ctx);
 911
 912     return group->meth->mul(group, r, scalar, num, points, scalars, ctx);
 913 }
 914
 915 int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
 916                  const EC_POINT *point, const BIGNUM *p_scalar, BN_CTX *ctx)
 917 {
 918     /* just a convenient interface to EC_POINTs_mul() */
 919
 920     const EC_POINT *points[1];
 921     const BIGNUM *scalars[1];
 922
 923     points[0] = point;
 924     scalars[0] = p_scalar;
 925
 926     return EC_POINTs_mul(group, r, g_scalar,
 927                          (point != NULL
 928                           && p_scalar != NULL), points, scalars, ctx);
 929 }
 930
 931 int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx)
 932 {
 933     if (group->meth->mul == 0)
 934         /* use default */
 935         return ec_wNAF_precompute_mult(group, ctx);
 936
 937     if (group->meth->precompute_mult != 0)
 938         return group->meth->precompute_mult(group, ctx);
 939     else
 940         return 1;               /* nothing to do, so report success */
 941 }
 942
 943 int EC_GROUP_have_precompute_mult(const EC_GROUP *group)
 944 {
 945     if (group->meth->mul == 0)
 946         /* use default */
 947         return ec_wNAF_have_precompute_mult(group);
 948
 949     if (group->meth->have_precompute_mult != 0)
 950         return group->meth->have_precompute_mult(group);
 951     else
 952         return 0;               /* cannot tell whether precomputation has
 953                                  * been performed */
 954 }
 955
 956 /*
 957  * ec_precompute_mont_data sets |group->mont_data| from |group->order| and
 958  * returns one on success. On error it returns zero.
 959  */
 960 int ec_precompute_mont_data(EC_GROUP *group)
 961 {
 962     BN_CTX *ctx = BN_CTX_new();
 963     int ret = 0;
 964
 965     BN_MONT_CTX_free(group->mont_data);
 966     group->mont_data = NULL;
 967
 968     if (ctx == NULL)
 969         goto err;
 970
 971     group->mont_data = BN_MONT_CTX_new();
 972     if (group->mont_data == NULL)
 973         goto err;
 974
 975     if (!BN_MONT_CTX_set(group->mont_data, group->order, ctx)) {
 976         BN_MONT_CTX_free(group->mont_data);
 977         group->mont_data = NULL;
 978         goto err;
 979     }
 980
 981     ret = 1;
 982
 983  err:
 984
 985     BN_CTX_free(ctx);
 986     return ret;
 987 }
 988
 989 int EC_KEY_set_ex_data(EC_KEY *key, int idx, void *arg)
 990 {
 991     return CRYPTO_set_ex_data(&key->ex_data, idx, arg);
 992 }
 993
 994 void *EC_KEY_get_ex_data(const EC_KEY *key, int idx)
 995 {
 996     return CRYPTO_get_ex_data(&key->ex_data, idx);
 997 }
 998
 999 int ec_group_simple_order_bits(const EC_GROUP *group)
1000 {
1001     if (group->order == NULL)
1002         return 0;
1003     return BN_num_bits(group->order);
1004 }