crypto/libressl/crypto/ec/ec_lib.c

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