crypto/ec/ec_lib.c

   1 /* crypto/ec/ec_lib.c */
   2 /* ====================================================================
   3  * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  * 3. All advertising materials mentioning features or use of this
  18  *    software must display the following acknowledgment:
  19  *    "This product includes software developed by the OpenSSL Project
  20  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  21  *
  22  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  23  *    endorse or promote products derived from this software without
  24  *    prior written permission. For written permission, please contact
  25  *    openssl-core@openssl.org.
  26  *
  27  * 5. Products derived from this software may not be called "OpenSSL"
  28  *    nor may "OpenSSL" appear in their names without prior written
  29  *    permission of the OpenSSL Project.
  30  *
  31  * 6. Redistributions of any form whatsoever must retain the following
  32  *    acknowledgment:
  33  *    "This product includes software developed by the OpenSSL Project
  34  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  35  *
  36  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  37  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  39  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  42  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  43  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  45  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  47  * OF THE POSSIBILITY OF SUCH DAMAGE.
  48  * ====================================================================
  49  *
  50  * This product includes cryptographic software written by Eric Young
  51  * (eay@cryptsoft.com).  This product includes software written by Tim
  52  * Hudson (tjh@cryptsoft.com).
  53  *
  54  */
  55
  56 #include <string.h>
  57
  58 #include <openssl/err.h>
  59 #include <openssl/opensslv.h>
  60
  61 #include "ec_lcl.h"
  62
  63 static const char EC_version[] = "EC" OPENSSL_VERSION_PTEXT;
  64
  65
  66 /* functions for EC_GROUP objects */
  67
  68 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
  69         {
  70         EC_GROUP *ret;
  71
  72         if (meth == NULL)
  73                 {
  74                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
  75                 return NULL;
  76                 }
  77         if (meth->group_init == 0)
  78                 {
  79                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  80                 return NULL;
  81                 }
  82
  83         ret = OPENSSL_malloc(sizeof *ret);
  84         if (ret == NULL)
  85                 {
  86                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
  87                 return NULL;
  88                 }
  89
  90         ret->meth = meth;
  91
  92         ret->extra_data = NULL;
  93         ret->extra_data_dup_func = 0;
  94         ret->extra_data_free_func = 0;
  95         ret->extra_data_clear_free_func = 0;
  96
  97         ret->generator = NULL;
  98         BN_init(&ret->order);
  99         BN_init(&ret->cofactor);
 100
 101         ret->nid = 0;
 102         ret->asn1_flag = OPENSSL_EC_EXPLICIT | OPENSSL_EC_COMPRESSED;
 103
 104         ret->seed = NULL;
 105         ret->seed_len = 0;
 106
 107         if (!meth->group_init(ret))
 108                 {
 109                 OPENSSL_free(ret);
 110                 return NULL;
 111                 }
 112
 113         return ret;
 114         }
 115
 116
 117 void EC_GROUP_free(EC_GROUP *group)
 118         {
 119         if (!group) return;
 120
 121         if (group->meth->group_finish != 0)
 122                 group->meth->group_finish(group);
 123
 124         EC_GROUP_free_extra_data(group);
 125
 126         if (group->generator != NULL)
 127                 EC_POINT_free(group->generator);
 128         BN_free(&group->order);
 129         BN_free(&group->cofactor);
 130
 131         if (group->seed)
 132                 OPENSSL_free(group->seed);
 133
 134         OPENSSL_free(group);
 135         }
 136
 137
 138 void EC_GROUP_clear_free(EC_GROUP *group)
 139         {
 140         if (!group) return;
 141
 142         if (group->meth->group_clear_finish != 0)
 143                 group->meth->group_clear_finish(group);
 144         else if (group->meth != NULL && group->meth->group_finish != 0)
 145                 group->meth->group_finish(group);
 146
 147         EC_GROUP_clear_free_extra_data(group);
 148
 149         if (group->generator != NULL)
 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                 {
 156                 memset(group->seed, 0, group->seed_len);
 157                 OPENSSL_free(group->seed);
 158                 }
 159
 160         memset(group, 0, sizeof *group);
 161         OPENSSL_free(group);
 162         }
 163
 164
 165 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 166         {
 167         if (dest->meth->group_copy == 0)
 168                 {
 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                 {
 174                 ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 175                 return 0;
 176                 }
 177         if (dest == src)
 178                 return 1;
 179
 180         EC_GROUP_clear_free_extra_data(dest);
 181         if (src->extra_data_dup_func)
 182                 {
 183                 if (src->extra_data != NULL)
 184                         {
 185                         dest->extra_data = src->extra_data_dup_func(src->extra_data);
 186                         if (dest->extra_data == NULL)
 187                                 return 0;
 188                         }
 189
 190                 dest->extra_data_dup_func = src->extra_data_dup_func;
 191                 dest->extra_data_free_func = src->extra_data_free_func;
 192                 dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
 193                 }
 194
 195         if (src->generator != NULL)
 196                 {
 197                 if (dest->generator == NULL)
 198                         {
 199                         dest->generator = EC_POINT_new(dest);
 200                         if (dest->generator == NULL) return 0;
 201                         }
 202                 if (!EC_POINT_copy(dest->generator, src->generator)) return 0;
 203                 }
 204         else
 205                 {
 206                 /* src->generator == NULL */
 207                 if (dest->generator != NULL)
 208                         {
 209                         EC_POINT_clear_free(dest->generator);
 210                         dest->generator = NULL;
 211                         }
 212                 }
 213
 214         if (!BN_copy(&dest->order, &src->order)) return 0;
 215         if (!BN_copy(&dest->cofactor, &src->cofactor)) return 0;
 216
 217         dest->nid = src->nid;
 218         dest->asn1_flag = src->asn1_flag;
 219
 220         if (src->seed)
 221                 {
 222                 if (dest->seed)
 223                         OPENSSL_free(dest->seed);
 224                 dest->seed = OPENSSL_malloc(src->seed_len);
 225                 if (dest->seed == NULL)
 226                         return 0;
 227                 if (!memcpy(dest->seed, src->seed, src->seed_len))
 228                         return 0;
 229                 dest->seed_len = src->seed_len;
 230                 }
 231         else
 232                 {
 233                 if (dest->seed)
 234                         OPENSSL_free(dest->seed);
 235                 dest->seed = NULL;
 236                 dest->seed_len = 0;
 237                 }
 238
 239
 240         return dest->meth->group_copy(dest, src);
 241         }
 242
 243
 244 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
 245         {
 246         return group->meth;
 247         }
 248
 249
 250 int EC_METHOD_get_field_type(const EC_METHOD *meth)
 251         {
 252         return meth->field_type;
 253         }
 254
 255
 256 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
 257         {
 258         if (generator == NULL)
 259                 {
 260                 ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_PASSED_NULL_PARAMETER);
 261                 return 0   ;
 262                 }
 263
 264         if (group->generator == NULL)
 265                 {
 266                 group->generator = EC_POINT_new(group);
 267                 if (group->generator == NULL) return 0;
 268                 }
 269         if (!EC_POINT_copy(group->generator, generator)) return 0;
 270
 271         if (order != NULL)
 272                 { if (!BN_copy(&group->order, order)) return 0; }
 273         else
 274                 { if (!BN_zero(&group->order)) return 0; }
 275
 276         if (cofactor != NULL)
 277                 { if (!BN_copy(&group->cofactor, cofactor)) return 0; }
 278         else
 279                 { if (!BN_zero(&group->cofactor)) return 0; }
 280
 281         return 1;
 282         }
 283
 284
 285 EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
 286         {
 287         return group->generator;
 288         }
 289
 290
 291 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 292         {
 293         if (!BN_copy(order, &group->order))
 294                 return 0;
 295
 296         return !BN_is_zero(order);
 297         }
 298
 299
 300 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
 301         {
 302         if (!BN_copy(cofactor, &group->cofactor))
 303                 return 0;
 304
 305         return !BN_is_zero(&group->cofactor);
 306         }
 307
 308
 309 void EC_GROUP_set_nid(EC_GROUP *group, int nid)
 310         {
 311         group->nid = nid;
 312         }
 313
 314
 315 int EC_GROUP_get_nid(const EC_GROUP *group)
 316         {
 317         return group->nid;
 318         }
 319
 320
 321 void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag)
 322         {
 323         group->asn1_flag = flag;
 324         }
 325
 326
 327 int EC_GROUP_get_asn1_flag(const EC_GROUP *group)
 328         {
 329         return group->asn1_flag;
 330         }
 331
 332
 333 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
 334         {
 335         if (group->meth->group_set_curve_GFp == 0)
 336                 {
 337                 ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 338                 return 0;
 339                 }
 340         return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
 341         }
 342
 343
 344 int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
 345         {
 346         if (group->meth->group_get_curve_GFp == 0)
 347                 {
 348                 ECerr(EC_F_EC_GROUP_GET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 349                 return 0;
 350                 }
 351         return group->meth->group_get_curve_GFp(group, p, a, b, ctx);
 352         }
 353
 354
 355 int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)
 356         {
 357         if (group->meth->group_check_discriminant == 0)
 358                 {
 359                 ECerr(EC_F_EC_GROUP_CHECK_DISCRIMINANT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 360                 return 0;
 361                 }
 362         return group->meth->group_check_discriminant(group, ctx);
 363         }
 364
 365
 366 /* this has 'package' visibility */
 367 int EC_GROUP_set_extra_data(EC_GROUP *group, void *extra_data, void *(*extra_data_dup_func)(void *),
 368         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 369         {
 370         if ((group->extra_data != NULL)
 371                 || (group->extra_data_dup_func != 0)
 372                 || (group->extra_data_free_func != 0)
 373                 || (group->extra_data_clear_free_func != 0))
 374                 {
 375                 ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
 376                 return 0;
 377                 }
 378
 379         group->extra_data = extra_data;
 380         group->extra_data_dup_func = extra_data_dup_func;
 381         group->extra_data_free_func = extra_data_free_func;
 382         group->extra_data_clear_free_func = extra_data_clear_free_func;
 383         return 1;
 384         }
 385
 386
 387 /* this has 'package' visibility */
 388 void *EC_GROUP_get_extra_data(const EC_GROUP *group, void *(*extra_data_dup_func)(void *),
 389         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 390         {
 391         if ((group->extra_data_dup_func != extra_data_dup_func)
 392                 || (group->extra_data_free_func != extra_data_free_func)
 393                 || (group->extra_data_clear_free_func != extra_data_clear_free_func))
 394                 {
 395                 ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
 396                 return NULL;
 397                 }
 398
 399         return group->extra_data;
 400         }
 401
 402
 403 /* this has 'package' visibility */
 404 void EC_GROUP_free_extra_data(EC_GROUP *group)
 405         {
 406         if (group->extra_data_free_func)
 407                 group->extra_data_free_func(group->extra_data);
 408         group->extra_data = NULL;
 409         group->extra_data_dup_func = 0;
 410         group->extra_data_free_func = 0;
 411         group->extra_data_clear_free_func = 0;
 412         }
 413
 414
 415 /* this has 'package' visibility */
 416 void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
 417         {
 418         if (group->extra_data_clear_free_func)
 419                 group->extra_data_clear_free_func(group->extra_data);
 420         else if (group->extra_data_free_func)
 421                 group->extra_data_free_func(group->extra_data);
 422         group->extra_data = NULL;
 423         group->extra_data_dup_func = 0;
 424         group->extra_data_free_func = 0;
 425         group->extra_data_clear_free_func = 0;
 426         }
 427
 428
 429 /* functions for EC_POINT objects */
 430
 431 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 432         {
 433         EC_POINT *ret;
 434
 435         if (group == NULL)
 436                 {
 437                 ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 438                 return NULL;
 439                 }
 440         if (group->meth->point_init == 0)
 441                 {
 442                 ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 443                 return NULL;
 444                 }
 445
 446         ret = OPENSSL_malloc(sizeof *ret);
 447         if (ret == NULL)
 448                 {
 449                 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 450                 return NULL;
 451                 }
 452
 453         ret->meth = group->meth;
 454
 455         if (!ret->meth->point_init(ret))
 456                 {
 457                 OPENSSL_free(ret);
 458                 return NULL;
 459                 }
 460
 461         return ret;
 462         }
 463
 464
 465 void EC_POINT_free(EC_POINT *point)
 466         {
 467         if (!point) return;
 468
 469         if (point->meth->point_finish != 0)
 470                 point->meth->point_finish(point);
 471         OPENSSL_free(point);
 472         }
 473
 474
 475 void EC_POINT_clear_free(EC_POINT *point)
 476         {
 477         if (!point) return;
 478
 479         if (point->meth->point_clear_finish != 0)
 480                 point->meth->point_clear_finish(point);
 481         else if (point->meth != NULL && point->meth->point_finish != 0)
 482                 point->meth->point_finish(point);
 483         memset(point, 0, sizeof *point);
 484         OPENSSL_free(point);
 485         }
 486
 487
 488 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 489         {
 490         if (dest->meth->point_copy == 0)
 491                 {
 492                 ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 493                 return 0;
 494                 }
 495         if (dest->meth != src->meth)
 496                 {
 497                 ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 498                 return 0;
 499                 }
 500         if (dest == src)
 501                 return 1;
 502         return dest->meth->point_copy(dest, src);
 503         }
 504
 505
 506 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
 507         {
 508         return point->meth;
 509         }
 510
 511
 512 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 513         {
 514         if (group->meth->point_set_to_infinity == 0)
 515                 {
 516                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 517                 return 0;
 518                 }
 519         if (group->meth != point->meth)
 520                 {
 521                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 522                 return 0;
 523                 }
 524         return group->meth->point_set_to_infinity(group, point);
 525         }
 526
 527
 528 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 529         const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
 530         {
 531         if (group->meth->point_set_Jprojective_coordinates_GFp == 0)
 532                 {
 533                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 534                 return 0;
 535                 }
 536         if (group->meth != point->meth)
 537                 {
 538                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 539                 return 0;
 540                 }
 541         return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 542         }
 543
 544
 545 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 546         BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
 547         {
 548         if (group->meth->point_get_Jprojective_coordinates_GFp == 0)
 549                 {
 550                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 551                 return 0;
 552                 }
 553         if (group->meth != point->meth)
 554                 {
 555                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 556                 return 0;
 557                 }
 558         return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 559         }
 560
 561
 562 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 563         const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
 564         {
 565         if (group->meth->point_set_affine_coordinates_GFp == 0)
 566                 {
 567                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 568                 return 0;
 569                 }
 570         if (group->meth != point->meth)
 571                 {
 572                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 573                 return 0;
 574                 }
 575         return group->meth->point_set_affine_coordinates_GFp(group, point, x, y, ctx);
 576         }
 577
 578
 579 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 580         BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
 581         {
 582         if (group->meth->point_get_affine_coordinates_GFp == 0)
 583                 {
 584                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 585                 return 0;
 586                 }
 587         if (group->meth != point->meth)
 588                 {
 589                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 590                 return 0;
 591                 }
 592         return group->meth->point_get_affine_coordinates_GFp(group, point, x, y, ctx);
 593         }
 594
 595
 596 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 597         const BIGNUM *x, int y_bit, BN_CTX *ctx)
 598         {
 599         if (group->meth->point_set_compressed_coordinates_GFp == 0)
 600                 {
 601                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 602                 return 0;
 603                 }
 604         if (group->meth != point->meth)
 605                 {
 606                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 607                 return 0;
 608                 }
 609         return group->meth->point_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx);
 610         }
 611
 612
 613 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
 614         unsigned char *buf, size_t len, BN_CTX *ctx)
 615         {
 616         if (group->meth->point2oct == 0)
 617                 {
 618                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 619                 return 0;
 620                 }
 621         if (group->meth != point->meth)
 622                 {
 623                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
 624                 return 0;
 625                 }
 626         return group->meth->point2oct(group, point, form, buf, len, ctx);
 627         }
 628
 629
 630 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 631         const unsigned char *buf, size_t len, BN_CTX *ctx)
 632         {
 633         if (group->meth->oct2point == 0)
 634                 {
 635                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 636                 return 0;
 637                 }
 638         if (group->meth != point->meth)
 639                 {
 640                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
 641                 return 0;
 642                 }
 643         return group->meth->oct2point(group, point, buf, len, ctx);
 644         }
 645
 646
 647 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 648         {
 649         if (group->meth->add == 0)
 650                 {
 651                 ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 652                 return 0;
 653                 }
 654         if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
 655                 {
 656                 ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 657                 return 0;
 658                 }
 659         return group->meth->add(group, r, a, b, ctx);
 660         }
 661
 662
 663 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
 664         {
 665         if (group->meth->dbl == 0)
 666                 {
 667                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 668                 return 0;
 669                 }
 670         if ((group->meth != r->meth) || (r->meth != a->meth))
 671                 {
 672                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 673                 return 0;
 674                 }
 675         return group->meth->dbl(group, r, a, ctx);
 676         }
 677
 678
 679 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
 680         {
 681         if (group->meth->dbl == 0)
 682                 {
 683                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 684                 return 0;
 685                 }
 686         if (group->meth != a->meth)
 687                 {
 688                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 689                 return 0;
 690                 }
 691         return group->meth->invert(group, a, ctx);
 692         }
 693
 694
 695 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 696         {
 697         if (group->meth->is_at_infinity == 0)
 698                 {
 699                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 700                 return 0;
 701                 }
 702         if (group->meth != point->meth)
 703                 {
 704                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 705                 return 0;
 706                 }
 707         return group->meth->is_at_infinity(group, point);
 708         }
 709
 710
 711 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
 712         {
 713         if (group->meth->is_on_curve == 0)
 714                 {
 715                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 716                 return 0;
 717                 }
 718         if (group->meth != point->meth)
 719                 {
 720                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
 721                 return 0;
 722                 }
 723         return group->meth->is_on_curve(group, point, ctx);
 724         }
 725
 726
 727 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 728         {
 729         if (group->meth->point_cmp == 0)
 730                 {
 731                 ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 732                 return 0;
 733                 }
 734         if ((group->meth != a->meth) || (a->meth != b->meth))
 735                 {
 736                 ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
 737                 return 0;
 738                 }
 739         return group->meth->point_cmp(group, a, b, ctx);
 740         }
 741
 742
 743 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
 744         {
 745         if (group->meth->make_affine == 0)
 746                 {
 747                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 748                 return 0;
 749                 }
 750         if (group->meth != point->meth)
 751                 {
 752                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 753                 return 0;
 754                 }
 755         return group->meth->make_affine(group, point, ctx);
 756         }
 757
 758
 759 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
 760         {
 761         size_t i;
 762
 763         if (group->meth->points_make_affine == 0)
 764                 {
 765                 ECerr(EC_F_EC_POINTS_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 766                 return 0;
 767                 }
 768         for (i = 0; i < num; i++)
 769                 {
 770                 if (group->meth != points[i]->meth)
 771                         {
 772                         ECerr(EC_F_EC_POINTS_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 773                         return 0;
 774                         }
 775                 }
 776         return group->meth->points_make_affine(group, num, points, ctx);
 777         }