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