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