crypto/ec/ec_lib.c

   1 /* crypto/ec/ec_lib.c */
   2 /*
   3  * Originally written by Bodo Moeller for the OpenSSL project.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 1998-2003 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    openssl-core@openssl.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58 /* ====================================================================
  59  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  60  * Binary polynomial ECC support in OpenSSL originally developed by
  61  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
  62  */
  63
  64 #include <string.h>
  65
  66 #include <openssl/err.h>
  67 #include <openssl/opensslv.h>
  68
  69 #include "ec_lcl.h"
  70
  71 /* functions for EC_GROUP objects */
  72
  73 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
  74 {
  75     EC_GROUP *ret;
  76
  77     if (meth == NULL) {
  78         ECerr(EC_F_EC_GROUP_NEW, EC_R_SLOT_FULL);
  79         return NULL;
  80     }
  81     if (meth->group_init == 0) {
  82         ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  83         return NULL;
  84     }
  85
  86     ret = OPENSSL_malloc(sizeof(*ret));
  87     if (ret == NULL) {
  88         ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
  89         return NULL;
  90     }
  91
  92     ret->meth = meth;
  93
  94     ret->extra_data = NULL;
  95     ret->mont_data = NULL;
  96
  97     ret->generator = NULL;
  98     ret->order = BN_new();
  99     ret->cofactor = NULL;
 100     if (!ret->order)
 101         goto err;
 102     ret->cofactor = BN_new();
 103     if (!ret->cofactor)
 104         goto err;
 105
 106     ret->curve_name = 0;
 107     ret->asn1_flag = OPENSSL_EC_NAMED_CURVE;
 108     ret->asn1_form = POINT_CONVERSION_UNCOMPRESSED;
 109
 110     ret->seed = NULL;
 111     ret->seed_len = 0;
 112
 113     if (!meth->group_init(ret))
 114         goto err;
 115
 116     return ret;
 117  err:
 118     BN_free(ret->order);
 119     BN_free(ret->cofactor);
 120     OPENSSL_free(ret);
 121     return NULL;
 122 }
 123
 124 void EC_GROUP_free(EC_GROUP *group)
 125 {
 126     if (!group)
 127         return;
 128
 129     if (group->meth->group_finish != 0)
 130         group->meth->group_finish(group);
 131
 132     EC_EX_DATA_free_all_data(&group->extra_data);
 133     BN_MONT_CTX_free(group->mont_data);
 134     EC_POINT_free(group->generator);
 135     BN_free(group->order);
 136     BN_free(group->cofactor);
 137     OPENSSL_free(group->seed);
 138     OPENSSL_free(group);
 139 }
 140
 141 void EC_GROUP_clear_free(EC_GROUP *group)
 142 {
 143     if (!group)
 144         return;
 145
 146     if (group->meth->group_clear_finish != 0)
 147         group->meth->group_clear_finish(group);
 148     else if (group->meth->group_finish != 0)
 149         group->meth->group_finish(group);
 150
 151     EC_EX_DATA_clear_free_all_data(&group->extra_data);
 152
 153     BN_MONT_CTX_free(group->mont_data);
 154
 155     EC_POINT_clear_free(group->generator);
 156     BN_clear_free(group->order);
 157     BN_clear_free(group->cofactor);
 158     OPENSSL_clear_free(group->seed, group->seed_len);
 159     OPENSSL_clear_free(group, sizeof(*group));
 160 }
 161
 162 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 163 {
 164     EC_EXTRA_DATA *d;
 165
 166     if (dest->meth->group_copy == 0) {
 167         ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 168         return 0;
 169     }
 170     if (dest->meth != src->meth) {
 171         ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 172         return 0;
 173     }
 174     if (dest == src)
 175         return 1;
 176
 177     EC_EX_DATA_free_all_data(&dest->extra_data);
 178
 179     for (d = src->extra_data; d != NULL; d = d->next) {
 180         void *t = d->dup_func(d->data);
 181
 182         if (t == NULL)
 183             return 0;
 184         if (!EC_EX_DATA_set_data
 185             (&dest->extra_data, t, d->dup_func, d->free_func,
 186              d->clear_free_func))
 187             return 0;
 188     }
 189
 190     if (src->mont_data != NULL) {
 191         if (dest->mont_data == NULL) {
 192             dest->mont_data = BN_MONT_CTX_new();
 193             if (dest->mont_data == NULL)
 194                 return 0;
 195         }
 196         if (!BN_MONT_CTX_copy(dest->mont_data, src->mont_data))
 197             return 0;
 198     } else {
 199         /* src->generator == NULL */
 200         BN_MONT_CTX_free(dest->mont_data);
 201         dest->mont_data = NULL;
 202     }
 203
 204     if (src->generator != NULL) {
 205         if (dest->generator == NULL) {
 206             dest->generator = EC_POINT_new(dest);
 207             if (dest->generator == NULL)
 208                 return 0;
 209         }
 210         if (!EC_POINT_copy(dest->generator, src->generator))
 211             return 0;
 212     } else {
 213         /* src->generator == NULL */
 214         EC_POINT_clear_free(dest->generator);
 215         dest->generator = NULL;
 216     }
 217
 218     if (!BN_copy(dest->order, src->order))
 219         return 0;
 220     if (!BN_copy(dest->cofactor, src->cofactor))
 221         return 0;
 222
 223     dest->curve_name = src->curve_name;
 224     dest->asn1_flag = src->asn1_flag;
 225     dest->asn1_form = src->asn1_form;
 226
 227     if (src->seed) {
 228         OPENSSL_free(dest->seed);
 229         dest->seed = OPENSSL_malloc(src->seed_len);
 230         if (dest->seed == NULL)
 231             return 0;
 232         if (!memcpy(dest->seed, src->seed, src->seed_len))
 233             return 0;
 234         dest->seed_len = src->seed_len;
 235     } else {
 236         OPENSSL_free(dest->seed);
 237         dest->seed = NULL;
 238         dest->seed_len = 0;
 239     }
 240
 241     return dest->meth->group_copy(dest, src);
 242 }
 243
 244 EC_GROUP *EC_GROUP_dup(const EC_GROUP *a)
 245 {
 246     EC_GROUP *t = NULL;
 247     int ok = 0;
 248
 249     if (a == NULL)
 250         return NULL;
 251
 252     if ((t = EC_GROUP_new(a->meth)) == NULL)
 253         return (NULL);
 254     if (!EC_GROUP_copy(t, a))
 255         goto err;
 256
 257     ok = 1;
 258
 259  err:
 260     if (!ok) {
 261         EC_GROUP_free(t);
 262         return NULL;
 263     }
 264         return t;
 265 }
 266
 267 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
 268 {
 269     return group->meth;
 270 }
 271
 272 int EC_METHOD_get_field_type(const EC_METHOD *meth)
 273 {
 274     return meth->field_type;
 275 }
 276
 277 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
 278                            const BIGNUM *order, const BIGNUM *cofactor)
 279 {
 280     if (generator == NULL) {
 281         ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_PASSED_NULL_PARAMETER);
 282         return 0;
 283     }
 284
 285     if (group->generator == NULL) {
 286         group->generator = EC_POINT_new(group);
 287         if (group->generator == NULL)
 288             return 0;
 289     }
 290     if (!EC_POINT_copy(group->generator, generator))
 291         return 0;
 292
 293     if (order != NULL) {
 294         if (!BN_copy(group->order, order))
 295             return 0;
 296     } else
 297         BN_zero(group->order);
 298
 299     if (cofactor != NULL) {
 300         if (!BN_copy(group->cofactor, cofactor))
 301             return 0;
 302     } else
 303         BN_zero(group->cofactor);
 304
 305     /*
 306      * We ignore the return value because some groups have an order with
 307      * factors of two, which makes the Montgomery setup fail.
 308      * |group->mont_data| will be NULL in this case.
 309      */
 310     ec_precompute_mont_data(group);
 311
 312     return 1;
 313 }
 314
 315 const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
 316 {
 317     return group->generator;
 318 }
 319
 320 BN_MONT_CTX *EC_GROUP_get_mont_data(const EC_GROUP *group)
 321 {
 322     return group->mont_data;
 323 }
 324
 325 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 326 {
 327     if (!BN_copy(order, group->order))
 328         return 0;
 329
 330     return !BN_is_zero(order);
 331 }
 332
 333 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor,
 334                           BN_CTX *ctx)
 335 {
 336     if (!BN_copy(cofactor, group->cofactor))
 337         return 0;
 338
 339     return !BN_is_zero(group->cofactor);
 340 }
 341
 342 void EC_GROUP_set_curve_name(EC_GROUP *group, int nid)
 343 {
 344     group->curve_name = nid;
 345 }
 346
 347 int EC_GROUP_get_curve_name(const EC_GROUP *group)
 348 {
 349     return group->curve_name;
 350 }
 351
 352 void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag)
 353 {
 354     group->asn1_flag = flag;
 355 }
 356
 357 int EC_GROUP_get_asn1_flag(const EC_GROUP *group)
 358 {
 359     return group->asn1_flag;
 360 }
 361
 362 void EC_GROUP_set_point_conversion_form(EC_GROUP *group,
 363                                         point_conversion_form_t form)
 364 {
 365     group->asn1_form = form;
 366 }
 367
 368 point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP
 369                                                            *group)
 370 {
 371     return group->asn1_form;
 372 }
 373
 374 size_t EC_GROUP_set_seed(EC_GROUP *group, const unsigned char *p, size_t len)
 375 {
 376     OPENSSL_free(group->seed);
 377     group->seed = NULL;
 378     group->seed_len = 0;
 379
 380     if (!len || !p)
 381         return 1;
 382
 383     if ((group->seed = OPENSSL_malloc(len)) == NULL)
 384         return 0;
 385     memcpy(group->seed, p, len);
 386     group->seed_len = len;
 387
 388     return len;
 389 }
 390
 391 unsigned char *EC_GROUP_get0_seed(const EC_GROUP *group)
 392 {
 393     return group->seed;
 394 }
 395
 396 size_t EC_GROUP_get_seed_len(const EC_GROUP *group)
 397 {
 398     return group->seed_len;
 399 }
 400
 401 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
 402                            const BIGNUM *b, BN_CTX *ctx)
 403 {
 404     if (group->meth->group_set_curve == 0) {
 405         ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 406         return 0;
 407     }
 408     return group->meth->group_set_curve(group, p, a, b, ctx);
 409 }
 410
 411 int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a,
 412                            BIGNUM *b, BN_CTX *ctx)
 413 {
 414     if (group->meth->group_get_curve == 0) {
 415         ECerr(EC_F_EC_GROUP_GET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 416         return 0;
 417     }
 418     return group->meth->group_get_curve(group, p, a, b, ctx);
 419 }
 420
 421 #ifndef OPENSSL_NO_EC2M
 422 int EC_GROUP_set_curve_GF2m(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a,
 423                             const BIGNUM *b, BN_CTX *ctx)
 424 {
 425     if (group->meth->group_set_curve == 0) {
 426         ECerr(EC_F_EC_GROUP_SET_CURVE_GF2M,
 427               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 428         return 0;
 429     }
 430     return group->meth->group_set_curve(group, p, a, b, ctx);
 431 }
 432
 433 int EC_GROUP_get_curve_GF2m(const EC_GROUP *group, BIGNUM *p, BIGNUM *a,
 434                             BIGNUM *b, BN_CTX *ctx)
 435 {
 436     if (group->meth->group_get_curve == 0) {
 437         ECerr(EC_F_EC_GROUP_GET_CURVE_GF2M,
 438               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 439         return 0;
 440     }
 441     return group->meth->group_get_curve(group, p, a, b, ctx);
 442 }
 443 #endif
 444
 445 int EC_GROUP_get_degree(const EC_GROUP *group)
 446 {
 447     if (group->meth->group_get_degree == 0) {
 448         ECerr(EC_F_EC_GROUP_GET_DEGREE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 449         return 0;
 450     }
 451     return group->meth->group_get_degree(group);
 452 }
 453
 454 int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)
 455 {
 456     if (group->meth->group_check_discriminant == 0) {
 457         ECerr(EC_F_EC_GROUP_CHECK_DISCRIMINANT,
 458               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 459         return 0;
 460     }
 461     return group->meth->group_check_discriminant(group, ctx);
 462 }
 463
 464 int EC_GROUP_cmp(const EC_GROUP *a, const EC_GROUP *b, BN_CTX *ctx)
 465 {
 466     int r = 0;
 467     BIGNUM *a1, *a2, *a3, *b1, *b2, *b3;
 468     BN_CTX *ctx_new = NULL;
 469
 470     /* compare the field types */
 471     if (EC_METHOD_get_field_type(EC_GROUP_method_of(a)) !=
 472         EC_METHOD_get_field_type(EC_GROUP_method_of(b)))
 473         return 1;
 474     /* compare the curve name (if present in both) */
 475     if (EC_GROUP_get_curve_name(a) && EC_GROUP_get_curve_name(b) &&
 476         EC_GROUP_get_curve_name(a) != EC_GROUP_get_curve_name(b))
 477         return 1;
 478
 479     if (!ctx)
 480         ctx_new = ctx = BN_CTX_new();
 481     if (!ctx)
 482         return -1;
 483
 484     BN_CTX_start(ctx);
 485     a1 = BN_CTX_get(ctx);
 486     a2 = BN_CTX_get(ctx);
 487     a3 = BN_CTX_get(ctx);
 488     b1 = BN_CTX_get(ctx);
 489     b2 = BN_CTX_get(ctx);
 490     b3 = BN_CTX_get(ctx);
 491     if (!b3) {
 492         BN_CTX_end(ctx);
 493         BN_CTX_free(ctx_new);
 494         return -1;
 495     }
 496
 497     /*
 498      * XXX This approach assumes that the external representation of curves
 499      * over the same field type is the same.
 500      */
 501     if (!a->meth->group_get_curve(a, a1, a2, a3, ctx) ||
 502         !b->meth->group_get_curve(b, b1, b2, b3, ctx))
 503         r = 1;
 504
 505     if (r || BN_cmp(a1, b1) || BN_cmp(a2, b2) || BN_cmp(a3, b3))
 506         r = 1;
 507
 508     /* XXX EC_POINT_cmp() assumes that the methods are equal */
 509     if (r || EC_POINT_cmp(a, EC_GROUP_get0_generator(a),
 510                           EC_GROUP_get0_generator(b), ctx))
 511         r = 1;
 512
 513     if (!r) {
 514         /* compare the order and cofactor */
 515         if (!EC_GROUP_get_order(a, a1, ctx) ||
 516             !EC_GROUP_get_order(b, b1, ctx) ||
 517             !EC_GROUP_get_cofactor(a, a2, ctx) ||
 518             !EC_GROUP_get_cofactor(b, b2, ctx)) {
 519             BN_CTX_end(ctx);
 520             BN_CTX_free(ctx_new);
 521             return -1;
 522         }
 523         if (BN_cmp(a1, b1) || BN_cmp(a2, b2))
 524             r = 1;
 525     }
 526
 527     BN_CTX_end(ctx);
 528     BN_CTX_free(ctx_new);
 529
 530     return r;
 531 }
 532
 533 /* this has 'package' visibility */
 534 int EC_EX_DATA_set_data(EC_EXTRA_DATA **ex_data, void *data,
 535                         void *(*dup_func) (void *),
 536                         void (*free_func) (void *),
 537                         void (*clear_free_func) (void *))
 538 {
 539     EC_EXTRA_DATA *d;
 540
 541     if (ex_data == NULL)
 542         return 0;
 543
 544     for (d = *ex_data; d != NULL; d = d->next) {
 545         if (d->dup_func == dup_func && d->free_func == free_func
 546             && d->clear_free_func == clear_free_func) {
 547             ECerr(EC_F_EC_EX_DATA_SET_DATA, EC_R_SLOT_FULL);
 548             return 0;
 549         }
 550     }
 551
 552     if (data == NULL)
 553         /* no explicit entry needed */
 554         return 1;
 555
 556     d = OPENSSL_malloc(sizeof(*d));
 557     if (d == NULL)
 558         return 0;
 559
 560     d->data = data;
 561     d->dup_func = dup_func;
 562     d->free_func = free_func;
 563     d->clear_free_func = clear_free_func;
 564
 565     d->next = *ex_data;
 566     *ex_data = d;
 567
 568     return 1;
 569 }
 570
 571 /* this has 'package' visibility */
 572 void *EC_EX_DATA_get_data(const EC_EXTRA_DATA *ex_data,
 573                           void *(*dup_func) (void *),
 574                           void (*free_func) (void *),
 575                           void (*clear_free_func) (void *))
 576 {
 577     const EC_EXTRA_DATA *d;
 578
 579     for (d = ex_data; d != NULL; d = d->next) {
 580         if (d->dup_func == dup_func && d->free_func == free_func
 581             && d->clear_free_func == clear_free_func)
 582             return d->data;
 583     }
 584
 585     return NULL;
 586 }
 587
 588 /* this has 'package' visibility */
 589 void EC_EX_DATA_free_data(EC_EXTRA_DATA **ex_data,
 590                           void *(*dup_func) (void *),
 591                           void (*free_func) (void *),
 592                           void (*clear_free_func) (void *))
 593 {
 594     EC_EXTRA_DATA **p;
 595
 596     if (ex_data == NULL)
 597         return;
 598
 599     for (p = ex_data; *p != NULL; p = &((*p)->next)) {
 600         if ((*p)->dup_func == dup_func && (*p)->free_func == free_func
 601             && (*p)->clear_free_func == clear_free_func) {
 602             EC_EXTRA_DATA *next = (*p)->next;
 603
 604             (*p)->free_func((*p)->data);
 605             OPENSSL_free(*p);
 606
 607             *p = next;
 608             return;
 609         }
 610     }
 611 }
 612
 613 /* this has 'package' visibility */
 614 void EC_EX_DATA_clear_free_data(EC_EXTRA_DATA **ex_data,
 615                                 void *(*dup_func) (void *),
 616                                 void (*free_func) (void *),
 617                                 void (*clear_free_func) (void *))
 618 {
 619     EC_EXTRA_DATA **p;
 620
 621     if (ex_data == NULL)
 622         return;
 623
 624     for (p = ex_data; *p != NULL; p = &((*p)->next)) {
 625         if ((*p)->dup_func == dup_func && (*p)->free_func == free_func
 626             && (*p)->clear_free_func == clear_free_func) {
 627             EC_EXTRA_DATA *next = (*p)->next;
 628
 629             (*p)->clear_free_func((*p)->data);
 630             OPENSSL_free(*p);
 631
 632             *p = next;
 633             return;
 634         }
 635     }
 636 }
 637
 638 /* this has 'package' visibility */
 639 void EC_EX_DATA_free_all_data(EC_EXTRA_DATA **ex_data)
 640 {
 641     EC_EXTRA_DATA *d;
 642
 643     if (ex_data == NULL)
 644         return;
 645
 646     d = *ex_data;
 647     while (d) {
 648         EC_EXTRA_DATA *next = d->next;
 649
 650         d->free_func(d->data);
 651         OPENSSL_free(d);
 652
 653         d = next;
 654     }
 655     *ex_data = NULL;
 656 }
 657
 658 /* this has 'package' visibility */
 659 void EC_EX_DATA_clear_free_all_data(EC_EXTRA_DATA **ex_data)
 660 {
 661     EC_EXTRA_DATA *d;
 662
 663     if (ex_data == NULL)
 664         return;
 665
 666     d = *ex_data;
 667     while (d) {
 668         EC_EXTRA_DATA *next = d->next;
 669
 670         d->clear_free_func(d->data);
 671         OPENSSL_free(d);
 672
 673         d = next;
 674     }
 675     *ex_data = NULL;
 676 }
 677
 678 /* functions for EC_POINT objects */
 679
 680 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 681 {
 682     EC_POINT *ret;
 683
 684     if (group == NULL) {
 685         ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 686         return NULL;
 687     }
 688     if (group->meth->point_init == 0) {
 689         ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 690         return NULL;
 691     }
 692
 693     ret = OPENSSL_malloc(sizeof(*ret));
 694     if (ret == NULL) {
 695         ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 696         return NULL;
 697     }
 698
 699     ret->meth = group->meth;
 700
 701     if (!ret->meth->point_init(ret)) {
 702         OPENSSL_free(ret);
 703         return NULL;
 704     }
 705
 706     return ret;
 707 }
 708
 709 void EC_POINT_free(EC_POINT *point)
 710 {
 711     if (!point)
 712         return;
 713
 714     if (point->meth->point_finish != 0)
 715         point->meth->point_finish(point);
 716     OPENSSL_free(point);
 717 }
 718
 719 void EC_POINT_clear_free(EC_POINT *point)
 720 {
 721     if (!point)
 722         return;
 723
 724     if (point->meth->point_clear_finish != 0)
 725         point->meth->point_clear_finish(point);
 726     else if (point->meth->point_finish != 0)
 727         point->meth->point_finish(point);
 728     OPENSSL_clear_free(point, sizeof(*point));
 729 }
 730
 731 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 732 {
 733     if (dest->meth->point_copy == 0) {
 734         ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 735         return 0;
 736     }
 737     if (dest->meth != src->meth) {
 738         ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 739         return 0;
 740     }
 741     if (dest == src)
 742         return 1;
 743     return dest->meth->point_copy(dest, src);
 744 }
 745
 746 EC_POINT *EC_POINT_dup(const EC_POINT *a, const EC_GROUP *group)
 747 {
 748     EC_POINT *t;
 749     int r;
 750
 751     if (a == NULL)
 752         return NULL;
 753
 754     t = EC_POINT_new(group);
 755     if (t == NULL)
 756         return (NULL);
 757     r = EC_POINT_copy(t, a);
 758     if (!r) {
 759         EC_POINT_free(t);
 760         return NULL;
 761     }
 762     return t;
 763 }
 764
 765 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
 766 {
 767     return point->meth;
 768 }
 769
 770 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 771 {
 772     if (group->meth->point_set_to_infinity == 0) {
 773         ECerr(EC_F_EC_POINT_SET_TO_INFINITY,
 774               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 775         return 0;
 776     }
 777     if (group->meth != point->meth) {
 778         ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 779         return 0;
 780     }
 781     return group->meth->point_set_to_infinity(group, point);
 782 }
 783
 784 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group,
 785                                              EC_POINT *point, const BIGNUM *x,
 786                                              const BIGNUM *y, const BIGNUM *z,
 787                                              BN_CTX *ctx)
 788 {
 789     if (group->meth->point_set_Jprojective_coordinates_GFp == 0) {
 790         ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP,
 791               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 792         return 0;
 793     }
 794     if (group->meth != point->meth) {
 795         ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP,
 796               EC_R_INCOMPATIBLE_OBJECTS);
 797         return 0;
 798     }
 799     return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x,
 800                                                               y, z, ctx);
 801 }
 802
 803 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
 804                                              const EC_POINT *point, BIGNUM *x,
 805                                              BIGNUM *y, BIGNUM *z,
 806                                              BN_CTX *ctx)
 807 {
 808     if (group->meth->point_get_Jprojective_coordinates_GFp == 0) {
 809         ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP,
 810               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 811         return 0;
 812     }
 813     if (group->meth != point->meth) {
 814         ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP,
 815               EC_R_INCOMPATIBLE_OBJECTS);
 816         return 0;
 817     }
 818     return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x,
 819                                                               y, z, ctx);
 820 }
 821
 822 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group,
 823                                         EC_POINT *point, const BIGNUM *x,
 824                                         const BIGNUM *y, BN_CTX *ctx)
 825 {
 826     if (group->meth->point_set_affine_coordinates == 0) {
 827         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP,
 828               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 829         return 0;
 830     }
 831     if (group->meth != point->meth) {
 832         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP,
 833               EC_R_INCOMPATIBLE_OBJECTS);
 834         return 0;
 835     }
 836     return group->meth->point_set_affine_coordinates(group, point, x, y, ctx);
 837 }
 838
 839 #ifndef OPENSSL_NO_EC2M
 840 int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group,
 841                                          EC_POINT *point, const BIGNUM *x,
 842                                          const BIGNUM *y, BN_CTX *ctx)
 843 {
 844     if (group->meth->point_set_affine_coordinates == 0) {
 845         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M,
 846               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 847         return 0;
 848     }
 849     if (group->meth != point->meth) {
 850         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M,
 851               EC_R_INCOMPATIBLE_OBJECTS);
 852         return 0;
 853     }
 854     return group->meth->point_set_affine_coordinates(group, point, x, y, ctx);
 855 }
 856 #endif
 857
 858 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group,
 859                                         const EC_POINT *point, BIGNUM *x,
 860                                         BIGNUM *y, BN_CTX *ctx)
 861 {
 862     if (group->meth->point_get_affine_coordinates == 0) {
 863         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP,
 864               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 865         return 0;
 866     }
 867     if (group->meth != point->meth) {
 868         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP,
 869               EC_R_INCOMPATIBLE_OBJECTS);
 870         return 0;
 871     }
 872     return group->meth->point_get_affine_coordinates(group, point, x, y, ctx);
 873 }
 874
 875 #ifndef OPENSSL_NO_EC2M
 876 int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group,
 877                                          const EC_POINT *point, BIGNUM *x,
 878                                          BIGNUM *y, BN_CTX *ctx)
 879 {
 880     if (group->meth->point_get_affine_coordinates == 0) {
 881         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M,
 882               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 883         return 0;
 884     }
 885     if (group->meth != point->meth) {
 886         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M,
 887               EC_R_INCOMPATIBLE_OBJECTS);
 888         return 0;
 889     }
 890     return group->meth->point_get_affine_coordinates(group, point, x, y, ctx);
 891 }
 892 #endif
 893
 894 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 895                  const EC_POINT *b, BN_CTX *ctx)
 896 {
 897     if (group->meth->add == 0) {
 898         ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 899         return 0;
 900     }
 901     if ((group->meth != r->meth) || (r->meth != a->meth)
 902         || (a->meth != b->meth)) {
 903         ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 904         return 0;
 905     }
 906     return group->meth->add(group, r, a, b, ctx);
 907 }
 908
 909 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 910                  BN_CTX *ctx)
 911 {
 912     if (group->meth->dbl == 0) {
 913         ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 914         return 0;
 915     }
 916     if ((group->meth != r->meth) || (r->meth != a->meth)) {
 917         ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 918         return 0;
 919     }
 920     return group->meth->dbl(group, r, a, ctx);
 921 }
 922
 923 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
 924 {
 925     if (group->meth->invert == 0) {
 926         ECerr(EC_F_EC_POINT_INVERT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 927         return 0;
 928     }
 929     if (group->meth != a->meth) {
 930         ECerr(EC_F_EC_POINT_INVERT, EC_R_INCOMPATIBLE_OBJECTS);
 931         return 0;
 932     }
 933     return group->meth->invert(group, a, ctx);
 934 }
 935
 936 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 937 {
 938     if (group->meth->is_at_infinity == 0) {
 939         ECerr(EC_F_EC_POINT_IS_AT_INFINITY,
 940               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 941         return 0;
 942     }
 943     if (group->meth != point->meth) {
 944         ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 945         return 0;
 946     }
 947     return group->meth->is_at_infinity(group, point);
 948 }
 949
 950 /*
 951  * Check whether an EC_POINT is on the curve or not. Note that the return
 952  * value for this function should NOT be treated as a boolean. Return values:
 953  *  1: The point is on the curve
 954  *  0: The point is not on the curve
 955  * -1: An error occurred
 956  */
 957 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point,
 958                          BN_CTX *ctx)
 959 {
 960     if (group->meth->is_on_curve == 0) {
 961         ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 962         return 0;
 963     }
 964     if (group->meth != point->meth) {
 965         ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
 966         return 0;
 967     }
 968     return group->meth->is_on_curve(group, point, ctx);
 969 }
 970
 971 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b,
 972                  BN_CTX *ctx)
 973 {
 974     if (group->meth->point_cmp == 0) {
 975         ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 976         return -1;
 977     }
 978     if ((group->meth != a->meth) || (a->meth != b->meth)) {
 979         ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
 980         return -1;
 981     }
 982     return group->meth->point_cmp(group, a, b, ctx);
 983 }
 984
 985 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
 986 {
 987     if (group->meth->make_affine == 0) {
 988         ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 989         return 0;
 990     }
 991     if (group->meth != point->meth) {
 992         ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 993         return 0;
 994     }
 995     return group->meth->make_affine(group, point, ctx);
 996 }
 997
 998 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num,
 999                           EC_POINT *points[], BN_CTX *ctx)
1000 {
1001     size_t i;
1002
1003     if (group->meth->points_make_affine == 0) {
1004         ECerr(EC_F_EC_POINTS_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
1005         return 0;
1006     }
1007     for (i = 0; i < num; i++) {
1008         if (group->meth != points[i]->meth) {
1009             ECerr(EC_F_EC_POINTS_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
1010             return 0;
1011         }
1012     }
1013     return group->meth->points_make_affine(group, num, points, ctx);
1014 }
1015
1016 /*
1017  * Functions for point multiplication. If group->meth->mul is 0, we use the
1018  * wNAF-based implementations in ec_mult.c; otherwise we dispatch through
1019  * methods.
1020  */
1021
1022 int EC_POINTs_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *scalar,
1023                   size_t num, const EC_POINT *points[],
1024                   const BIGNUM *scalars[], BN_CTX *ctx)
1025 {
1026     if (group->meth->mul == 0)
1027         /* use default */
1028         return ec_wNAF_mul(group, r, scalar, num, points, scalars, ctx);
1029
1030     return group->meth->mul(group, r, scalar, num, points, scalars, ctx);
1031 }
1032
1033 int EC_POINT_mul(const EC_GROUP *group, EC_POINT *r, const BIGNUM *g_scalar,
1034                  const EC_POINT *point, const BIGNUM *p_scalar, BN_CTX *ctx)
1035 {
1036     /* just a convenient interface to EC_POINTs_mul() */
1037
1038     const EC_POINT *points[1];
1039     const BIGNUM *scalars[1];
1040
1041     points[0] = point;
1042     scalars[0] = p_scalar;
1043
1044     return EC_POINTs_mul(group, r, g_scalar,
1045                          (point != NULL
1046                           && p_scalar != NULL), points, scalars, ctx);
1047 }
1048
1049 int EC_GROUP_precompute_mult(EC_GROUP *group, BN_CTX *ctx)
1050 {
1051     if (group->meth->mul == 0)
1052         /* use default */
1053         return ec_wNAF_precompute_mult(group, ctx);
1054
1055     if (group->meth->precompute_mult != 0)
1056         return group->meth->precompute_mult(group, ctx);
1057     else
1058         return 1;               /* nothing to do, so report success */
1059 }
1060
1061 int EC_GROUP_have_precompute_mult(const EC_GROUP *group)
1062 {
1063     if (group->meth->mul == 0)
1064         /* use default */
1065         return ec_wNAF_have_precompute_mult(group);
1066
1067     if (group->meth->have_precompute_mult != 0)
1068         return group->meth->have_precompute_mult(group);
1069     else
1070         return 0;               /* cannot tell whether precomputation has
1071                                  * been performed */
1072 }
1073
1074 /*
1075  * ec_precompute_mont_data sets |group->mont_data| from |group->order| and
1076  * returns one on success. On error it returns zero.
1077  */
1078 int ec_precompute_mont_data(EC_GROUP *group)
1079 {
1080     BN_CTX *ctx = BN_CTX_new();
1081     int ret = 0;
1082
1083     BN_MONT_CTX_free(group->mont_data);
1084     group->mont_data = NULL;
1085
1086     if (ctx == NULL)
1087         goto err;
1088
1089     group->mont_data = BN_MONT_CTX_new();
1090     if (!group->mont_data)
1091         goto err;
1092
1093     if (!BN_MONT_CTX_set(group->mont_data, group->order, ctx)) {
1094         BN_MONT_CTX_free(group->mont_data);
1095         group->mont_data = NULL;
1096         goto err;
1097     }
1098
1099     ret = 1;
1100
1101  err:
1102
1103     BN_CTX_free(ctx);
1104     return ret;
1105 }