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
 136     BN_MONT_CTX_free(group->mont_data);
 137
 138     EC_POINT_free(group->generator);
 139     BN_free(group->order);
 140     BN_free(group->cofactor);
 141
 142     if (group->seed)
 143         OPENSSL_free(group->seed);
 144
 145     OPENSSL_free(group);
 146 }
 147
 148 void EC_GROUP_clear_free(EC_GROUP *group)
 149 {
 150     if (!group)
 151         return;
 152
 153     if (group->meth->group_clear_finish != 0)
 154         group->meth->group_clear_finish(group);
 155     else if (group->meth->group_finish != 0)
 156         group->meth->group_finish(group);
 157
 158     EC_EX_DATA_clear_free_all_data(&group->extra_data);
 159
 160     BN_MONT_CTX_free(group->mont_data);
 161
 162     EC_POINT_clear_free(group->generator);
 163     BN_clear_free(group->order);
 164     BN_clear_free(group->cofactor);
 165     OPENSSL_clear_free(group->seed, group->seed_len);
 166     OPENSSL_clear_free(group, sizeof *group);
 167 }
 168
 169 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 170 {
 171     EC_EXTRA_DATA *d;
 172
 173     if (dest->meth->group_copy == 0) {
 174         ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 175         return 0;
 176     }
 177     if (dest->meth != src->meth) {
 178         ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 179         return 0;
 180     }
 181     if (dest == src)
 182         return 1;
 183
 184     EC_EX_DATA_free_all_data(&dest->extra_data);
 185
 186     for (d = src->extra_data; d != NULL; d = d->next) {
 187         void *t = d->dup_func(d->data);
 188
 189         if (t == NULL)
 190             return 0;
 191         if (!EC_EX_DATA_set_data
 192             (&dest->extra_data, t, d->dup_func, d->free_func,
 193              d->clear_free_func))
 194             return 0;
 195     }
 196
 197     if (src->mont_data != NULL) {
 198         if (dest->mont_data == NULL) {
 199             dest->mont_data = BN_MONT_CTX_new();
 200             if (dest->mont_data == NULL)
 201                 return 0;
 202         }
 203         if (!BN_MONT_CTX_copy(dest->mont_data, src->mont_data))
 204             return 0;
 205     } else {
 206         /* src->generator == NULL */
 207         BN_MONT_CTX_free(dest->mont_data);
 208         dest->mont_data = NULL;
 209     }
 210
 211     if (src->generator != NULL) {
 212         if (dest->generator == NULL) {
 213             dest->generator = EC_POINT_new(dest);
 214             if (dest->generator == NULL)
 215                 return 0;
 216         }
 217         if (!EC_POINT_copy(dest->generator, src->generator))
 218             return 0;
 219     } else {
 220         /* src->generator == NULL */
 221         EC_POINT_clear_free(dest->generator);
 222         dest->generator = NULL;
 223     }
 224
 225     if (!BN_copy(dest->order, src->order))
 226         return 0;
 227     if (!BN_copy(dest->cofactor, src->cofactor))
 228         return 0;
 229
 230     dest->curve_name = src->curve_name;
 231     dest->asn1_flag = src->asn1_flag;
 232     dest->asn1_form = src->asn1_form;
 233
 234     if (src->seed) {
 235         OPENSSL_free(dest->seed);
 236         dest->seed = OPENSSL_malloc(src->seed_len);
 237         if (dest->seed == NULL)
 238             return 0;
 239         if (!memcpy(dest->seed, src->seed, src->seed_len))
 240             return 0;
 241         dest->seed_len = src->seed_len;
 242     } else {
 243         OPENSSL_free(dest->seed);
 244         dest->seed = NULL;
 245         dest->seed_len = 0;
 246     }
 247
 248     return dest->meth->group_copy(dest, src);
 249 }
 250
 251 EC_GROUP *EC_GROUP_dup(const EC_GROUP *a)
 252 {
 253     EC_GROUP *t = NULL;
 254     int ok = 0;
 255
 256     if (a == NULL)
 257         return NULL;
 258
 259     if ((t = EC_GROUP_new(a->meth)) == NULL)
 260         return (NULL);
 261     if (!EC_GROUP_copy(t, a))
 262         goto err;
 263
 264     ok = 1;
 265
 266  err:
 267     if (!ok) {
 268         EC_GROUP_free(t);
 269         return NULL;
 270     }
 271         return t;
 272 }
 273
 274 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
 275 {
 276     return group->meth;
 277 }
 278
 279 int EC_METHOD_get_field_type(const EC_METHOD *meth)
 280 {
 281     return meth->field_type;
 282 }
 283
 284 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator,
 285                            const BIGNUM *order, const BIGNUM *cofactor)
 286 {
 287     if (generator == NULL) {
 288         ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_PASSED_NULL_PARAMETER);
 289         return 0;
 290     }
 291
 292     if (group->generator == NULL) {
 293         group->generator = EC_POINT_new(group);
 294         if (group->generator == NULL)
 295             return 0;
 296     }
 297     if (!EC_POINT_copy(group->generator, generator))
 298         return 0;
 299
 300     if (order != NULL) {
 301         if (!BN_copy(group->order, order))
 302             return 0;
 303     } else
 304         BN_zero(group->order);
 305
 306     if (cofactor != NULL) {
 307         if (!BN_copy(group->cofactor, cofactor))
 308             return 0;
 309     } else
 310         BN_zero(group->cofactor);
 311
 312     /*
 313      * We ignore the return value because some groups have an order with
 314      * factors of two, which makes the Montgomery setup fail.
 315      * |group->mont_data| will be NULL in this case.
 316      */
 317     ec_precompute_mont_data(group);
 318
 319     return 1;
 320 }
 321
 322 const EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
 323 {
 324     return group->generator;
 325 }
 326
 327 BN_MONT_CTX *EC_GROUP_get_mont_data(const EC_GROUP *group)
 328 {
 329     return group->mont_data;
 330 }
 331
 332 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 333 {
 334     if (!BN_copy(order, group->order))
 335         return 0;
 336
 337     return !BN_is_zero(order);
 338 }
 339
 340 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor,
 341                           BN_CTX *ctx)
 342 {
 343     if (!BN_copy(cofactor, group->cofactor))
 344         return 0;
 345
 346     return !BN_is_zero(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
 486     if (!ctx)
 487         ctx_new = ctx = BN_CTX_new();
 488     if (!ctx)
 489         return -1;
 490
 491     BN_CTX_start(ctx);
 492     a1 = BN_CTX_get(ctx);
 493     a2 = BN_CTX_get(ctx);
 494     a3 = BN_CTX_get(ctx);
 495     b1 = BN_CTX_get(ctx);
 496     b2 = BN_CTX_get(ctx);
 497     b3 = BN_CTX_get(ctx);
 498     if (!b3) {
 499         BN_CTX_end(ctx);
 500         BN_CTX_free(ctx_new);
 501         return -1;
 502     }
 503
 504     /*
 505      * XXX This approach assumes that the external representation of curves
 506      * over the same field type is the same.
 507      */
 508     if (!a->meth->group_get_curve(a, a1, a2, a3, ctx) ||
 509         !b->meth->group_get_curve(b, b1, b2, b3, ctx))
 510         r = 1;
 511
 512     if (r || BN_cmp(a1, b1) || BN_cmp(a2, b2) || BN_cmp(a3, b3))
 513         r = 1;
 514
 515     /* XXX EC_POINT_cmp() assumes that the methods are equal */
 516     if (r || EC_POINT_cmp(a, EC_GROUP_get0_generator(a),
 517                           EC_GROUP_get0_generator(b), ctx))
 518         r = 1;
 519
 520     if (!r) {
 521         /* compare the order and cofactor */
 522         if (!EC_GROUP_get_order(a, a1, ctx) ||
 523             !EC_GROUP_get_order(b, b1, ctx) ||
 524             !EC_GROUP_get_cofactor(a, a2, ctx) ||
 525             !EC_GROUP_get_cofactor(b, b2, ctx)) {
 526             BN_CTX_end(ctx);
 527             BN_CTX_free(ctx_new);
 528             return -1;
 529         }
 530         if (BN_cmp(a1, b1) || BN_cmp(a2, b2))
 531             r = 1;
 532     }
 533
 534     BN_CTX_end(ctx);
 535     BN_CTX_free(ctx_new);
 536
 537     return r;
 538 }
 539
 540 /* this has 'package' visibility */
 541 int EC_EX_DATA_set_data(EC_EXTRA_DATA **ex_data, void *data,
 542                         void *(*dup_func) (void *),
 543                         void (*free_func) (void *),
 544                         void (*clear_free_func) (void *))
 545 {
 546     EC_EXTRA_DATA *d;
 547
 548     if (ex_data == NULL)
 549         return 0;
 550
 551     for (d = *ex_data; d != NULL; d = d->next) {
 552         if (d->dup_func == dup_func && d->free_func == free_func
 553             && d->clear_free_func == clear_free_func) {
 554             ECerr(EC_F_EC_EX_DATA_SET_DATA, EC_R_SLOT_FULL);
 555             return 0;
 556         }
 557     }
 558
 559     if (data == NULL)
 560         /* no explicit entry needed */
 561         return 1;
 562
 563     d = OPENSSL_malloc(sizeof *d);
 564     if (d == NULL)
 565         return 0;
 566
 567     d->data = data;
 568     d->dup_func = dup_func;
 569     d->free_func = free_func;
 570     d->clear_free_func = clear_free_func;
 571
 572     d->next = *ex_data;
 573     *ex_data = d;
 574
 575     return 1;
 576 }
 577
 578 /* this has 'package' visibility */
 579 void *EC_EX_DATA_get_data(const EC_EXTRA_DATA *ex_data,
 580                           void *(*dup_func) (void *),
 581                           void (*free_func) (void *),
 582                           void (*clear_free_func) (void *))
 583 {
 584     const EC_EXTRA_DATA *d;
 585
 586     for (d = ex_data; d != NULL; d = d->next) {
 587         if (d->dup_func == dup_func && d->free_func == free_func
 588             && d->clear_free_func == clear_free_func)
 589             return d->data;
 590     }
 591
 592     return NULL;
 593 }
 594
 595 /* this has 'package' visibility */
 596 void EC_EX_DATA_free_data(EC_EXTRA_DATA **ex_data,
 597                           void *(*dup_func) (void *),
 598                           void (*free_func) (void *),
 599                           void (*clear_free_func) (void *))
 600 {
 601     EC_EXTRA_DATA **p;
 602
 603     if (ex_data == NULL)
 604         return;
 605
 606     for (p = ex_data; *p != NULL; p = &((*p)->next)) {
 607         if ((*p)->dup_func == dup_func && (*p)->free_func == free_func
 608             && (*p)->clear_free_func == clear_free_func) {
 609             EC_EXTRA_DATA *next = (*p)->next;
 610
 611             (*p)->free_func((*p)->data);
 612             OPENSSL_free(*p);
 613
 614             *p = next;
 615             return;
 616         }
 617     }
 618 }
 619
 620 /* this has 'package' visibility */
 621 void EC_EX_DATA_clear_free_data(EC_EXTRA_DATA **ex_data,
 622                                 void *(*dup_func) (void *),
 623                                 void (*free_func) (void *),
 624                                 void (*clear_free_func) (void *))
 625 {
 626     EC_EXTRA_DATA **p;
 627
 628     if (ex_data == NULL)
 629         return;
 630
 631     for (p = ex_data; *p != NULL; p = &((*p)->next)) {
 632         if ((*p)->dup_func == dup_func && (*p)->free_func == free_func
 633             && (*p)->clear_free_func == clear_free_func) {
 634             EC_EXTRA_DATA *next = (*p)->next;
 635
 636             (*p)->clear_free_func((*p)->data);
 637             OPENSSL_free(*p);
 638
 639             *p = next;
 640             return;
 641         }
 642     }
 643 }
 644
 645 /* this has 'package' visibility */
 646 void EC_EX_DATA_free_all_data(EC_EXTRA_DATA **ex_data)
 647 {
 648     EC_EXTRA_DATA *d;
 649
 650     if (ex_data == NULL)
 651         return;
 652
 653     d = *ex_data;
 654     while (d) {
 655         EC_EXTRA_DATA *next = d->next;
 656
 657         d->free_func(d->data);
 658         OPENSSL_free(d);
 659
 660         d = next;
 661     }
 662     *ex_data = NULL;
 663 }
 664
 665 /* this has 'package' visibility */
 666 void EC_EX_DATA_clear_free_all_data(EC_EXTRA_DATA **ex_data)
 667 {
 668     EC_EXTRA_DATA *d;
 669
 670     if (ex_data == NULL)
 671         return;
 672
 673     d = *ex_data;
 674     while (d) {
 675         EC_EXTRA_DATA *next = d->next;
 676
 677         d->clear_free_func(d->data);
 678         OPENSSL_free(d);
 679
 680         d = next;
 681     }
 682     *ex_data = NULL;
 683 }
 684
 685 /* functions for EC_POINT objects */
 686
 687 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 688 {
 689     EC_POINT *ret;
 690
 691     if (group == NULL) {
 692         ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 693         return NULL;
 694     }
 695     if (group->meth->point_init == 0) {
 696         ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 697         return NULL;
 698     }
 699
 700     ret = OPENSSL_malloc(sizeof *ret);
 701     if (ret == NULL) {
 702         ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 703         return NULL;
 704     }
 705
 706     ret->meth = group->meth;
 707
 708     if (!ret->meth->point_init(ret)) {
 709         OPENSSL_free(ret);
 710         return NULL;
 711     }
 712
 713     return ret;
 714 }
 715
 716 void EC_POINT_free(EC_POINT *point)
 717 {
 718     if (!point)
 719         return;
 720
 721     if (point->meth->point_finish != 0)
 722         point->meth->point_finish(point);
 723     OPENSSL_free(point);
 724 }
 725
 726 void EC_POINT_clear_free(EC_POINT *point)
 727 {
 728     if (!point)
 729         return;
 730
 731     if (point->meth->point_clear_finish != 0)
 732         point->meth->point_clear_finish(point);
 733     else if (point->meth->point_finish != 0)
 734         point->meth->point_finish(point);
 735     OPENSSL_clear_free(point, sizeof *point);
 736 }
 737
 738 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 739 {
 740     if (dest->meth->point_copy == 0) {
 741         ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 742         return 0;
 743     }
 744     if (dest->meth != src->meth) {
 745         ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 746         return 0;
 747     }
 748     if (dest == src)
 749         return 1;
 750     return dest->meth->point_copy(dest, src);
 751 }
 752
 753 EC_POINT *EC_POINT_dup(const EC_POINT *a, const EC_GROUP *group)
 754 {
 755     EC_POINT *t;
 756     int r;
 757
 758     if (a == NULL)
 759         return NULL;
 760
 761     t = EC_POINT_new(group);
 762     if (t == NULL)
 763         return (NULL);
 764     r = EC_POINT_copy(t, a);
 765     if (!r) {
 766         EC_POINT_free(t);
 767         return NULL;
 768     }
 769     return t;
 770 }
 771
 772 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
 773 {
 774     return point->meth;
 775 }
 776
 777 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 778 {
 779     if (group->meth->point_set_to_infinity == 0) {
 780         ECerr(EC_F_EC_POINT_SET_TO_INFINITY,
 781               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 782         return 0;
 783     }
 784     if (group->meth != point->meth) {
 785         ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 786         return 0;
 787     }
 788     return group->meth->point_set_to_infinity(group, point);
 789 }
 790
 791 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group,
 792                                              EC_POINT *point, const BIGNUM *x,
 793                                              const BIGNUM *y, const BIGNUM *z,
 794                                              BN_CTX *ctx)
 795 {
 796     if (group->meth->point_set_Jprojective_coordinates_GFp == 0) {
 797         ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP,
 798               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 799         return 0;
 800     }
 801     if (group->meth != point->meth) {
 802         ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP,
 803               EC_R_INCOMPATIBLE_OBJECTS);
 804         return 0;
 805     }
 806     return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x,
 807                                                               y, z, ctx);
 808 }
 809
 810 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group,
 811                                              const EC_POINT *point, BIGNUM *x,
 812                                              BIGNUM *y, BIGNUM *z,
 813                                              BN_CTX *ctx)
 814 {
 815     if (group->meth->point_get_Jprojective_coordinates_GFp == 0) {
 816         ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP,
 817               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 818         return 0;
 819     }
 820     if (group->meth != point->meth) {
 821         ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP,
 822               EC_R_INCOMPATIBLE_OBJECTS);
 823         return 0;
 824     }
 825     return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x,
 826                                                               y, z, ctx);
 827 }
 828
 829 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group,
 830                                         EC_POINT *point, const BIGNUM *x,
 831                                         const BIGNUM *y, BN_CTX *ctx)
 832 {
 833     if (group->meth->point_set_affine_coordinates == 0) {
 834         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP,
 835               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 836         return 0;
 837     }
 838     if (group->meth != point->meth) {
 839         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP,
 840               EC_R_INCOMPATIBLE_OBJECTS);
 841         return 0;
 842     }
 843     return group->meth->point_set_affine_coordinates(group, point, x, y, ctx);
 844 }
 845
 846 #ifndef OPENSSL_NO_EC2M
 847 int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group,
 848                                          EC_POINT *point, const BIGNUM *x,
 849                                          const BIGNUM *y, BN_CTX *ctx)
 850 {
 851     if (group->meth->point_set_affine_coordinates == 0) {
 852         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M,
 853               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 854         return 0;
 855     }
 856     if (group->meth != point->meth) {
 857         ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M,
 858               EC_R_INCOMPATIBLE_OBJECTS);
 859         return 0;
 860     }
 861     return group->meth->point_set_affine_coordinates(group, point, x, y, ctx);
 862 }
 863 #endif
 864
 865 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group,
 866                                         const EC_POINT *point, BIGNUM *x,
 867                                         BIGNUM *y, BN_CTX *ctx)
 868 {
 869     if (group->meth->point_get_affine_coordinates == 0) {
 870         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP,
 871               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 872         return 0;
 873     }
 874     if (group->meth != point->meth) {
 875         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP,
 876               EC_R_INCOMPATIBLE_OBJECTS);
 877         return 0;
 878     }
 879     return group->meth->point_get_affine_coordinates(group, point, x, y, ctx);
 880 }
 881
 882 #ifndef OPENSSL_NO_EC2M
 883 int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group,
 884                                          const EC_POINT *point, BIGNUM *x,
 885                                          BIGNUM *y, BN_CTX *ctx)
 886 {
 887     if (group->meth->point_get_affine_coordinates == 0) {
 888         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M,
 889               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 890         return 0;
 891     }
 892     if (group->meth != point->meth) {
 893         ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M,
 894               EC_R_INCOMPATIBLE_OBJECTS);
 895         return 0;
 896     }
 897     return group->meth->point_get_affine_coordinates(group, point, x, y, ctx);
 898 }
 899 #endif
 900
 901 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 902                  const EC_POINT *b, BN_CTX *ctx)
 903 {
 904     if (group->meth->add == 0) {
 905         ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 906         return 0;
 907     }
 908     if ((group->meth != r->meth) || (r->meth != a->meth)
 909         || (a->meth != b->meth)) {
 910         ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 911         return 0;
 912     }
 913     return group->meth->add(group, r, a, b, ctx);
 914 }
 915
 916 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a,
 917                  BN_CTX *ctx)
 918 {
 919     if (group->meth->dbl == 0) {
 920         ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 921         return 0;
 922     }
 923     if ((group->meth != r->meth) || (r->meth != a->meth)) {
 924         ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 925         return 0;
 926     }
 927     return group->meth->dbl(group, r, a, ctx);
 928 }
 929
 930 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
 931 {
 932     if (group->meth->invert == 0) {
 933         ECerr(EC_F_EC_POINT_INVERT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 934         return 0;
 935     }
 936     if (group->meth != a->meth) {
 937         ECerr(EC_F_EC_POINT_INVERT, EC_R_INCOMPATIBLE_OBJECTS);
 938         return 0;
 939     }
 940     return group->meth->invert(group, a, ctx);
 941 }
 942
 943 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 944 {
 945     if (group->meth->is_at_infinity == 0) {
 946         ECerr(EC_F_EC_POINT_IS_AT_INFINITY,
 947               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 948         return 0;
 949     }
 950     if (group->meth != point->meth) {
 951         ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 952         return 0;
 953     }
 954     return group->meth->is_at_infinity(group, point);
 955 }
 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 }