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