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->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                 {
 110                 OPENSSL_free(ret);
 111                 return NULL;
 112                 }
 113
 114         return ret;
 115         }
 116
 117
 118 void EC_GROUP_free(EC_GROUP *group)
 119         {
 120         if (!group) return;
 121
 122         if (group->meth->group_finish != 0)
 123                 group->meth->group_finish(group);
 124
 125         EC_GROUP_free_extra_data(group);
 126
 127         if (group->generator != NULL)
 128                 EC_POINT_free(group->generator);
 129         BN_free(&group->order);
 130         BN_free(&group->cofactor);
 131
 132         if (group->seed)
 133                 OPENSSL_free(group->seed);
 134
 135         OPENSSL_free(group);
 136         }
 137
 138
 139 void EC_GROUP_clear_free(EC_GROUP *group)
 140         {
 141         if (!group) return;
 142
 143         if (group->meth->group_clear_finish != 0)
 144                 group->meth->group_clear_finish(group);
 145         else if (group->meth != NULL && group->meth->group_finish != 0)
 146                 group->meth->group_finish(group);
 147
 148         EC_GROUP_clear_free_extra_data(group);
 149
 150         if (group->generator != NULL)
 151                 EC_POINT_clear_free(group->generator);
 152         BN_clear_free(&group->order);
 153         BN_clear_free(&group->cofactor);
 154
 155         if (group->seed)
 156                 {
 157                 memset(group->seed, 0, group->seed_len);
 158                 OPENSSL_free(group->seed);
 159                 }
 160
 161         memset(group, 0, sizeof *group);
 162         OPENSSL_free(group);
 163         }
 164
 165
 166 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 167         {
 168         if (dest->meth->group_copy == 0)
 169                 {
 170                 ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 171                 return 0;
 172                 }
 173         if (dest->meth != src->meth)
 174                 {
 175                 ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 176                 return 0;
 177                 }
 178         if (dest == src)
 179                 return 1;
 180
 181         EC_GROUP_clear_free_extra_data(dest);
 182         if (src->extra_data_dup_func)
 183                 {
 184                 if (src->extra_data != NULL)
 185                         {
 186                         dest->extra_data = src->extra_data_dup_func(src->extra_data);
 187                         if (dest->extra_data == NULL)
 188                                 return 0;
 189                         }
 190
 191                 dest->extra_data_dup_func = src->extra_data_dup_func;
 192                 dest->extra_data_free_func = src->extra_data_free_func;
 193                 dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
 194                 }
 195
 196         if (src->generator != NULL)
 197                 {
 198                 if (dest->generator == NULL)
 199                         {
 200                         dest->generator = EC_POINT_new(dest);
 201                         if (dest->generator == NULL) return 0;
 202                         }
 203                 if (!EC_POINT_copy(dest->generator, src->generator)) return 0;
 204                 }
 205         else
 206                 {
 207                 /* src->generator == NULL */
 208                 if (dest->generator != NULL)
 209                         {
 210                         EC_POINT_clear_free(dest->generator);
 211                         dest->generator = NULL;
 212                         }
 213                 }
 214
 215         if (!BN_copy(&dest->order, &src->order)) return 0;
 216         if (!BN_copy(&dest->cofactor, &src->cofactor)) return 0;
 217
 218         dest->curve_name = src->curve_name;
 219         dest->asn1_flag  = src->asn1_flag;
 220         dest->asn1_form  = src->asn1_form;
 221
 222         if (src->seed)
 223                 {
 224                 if (dest->seed)
 225                         OPENSSL_free(dest->seed);
 226                 dest->seed = OPENSSL_malloc(src->seed_len);
 227                 if (dest->seed == NULL)
 228                         return 0;
 229                 if (!memcpy(dest->seed, src->seed, src->seed_len))
 230                         return 0;
 231                 dest->seed_len = src->seed_len;
 232                 }
 233         else
 234                 {
 235                 if (dest->seed)
 236                         OPENSSL_free(dest->seed);
 237                 dest->seed = NULL;
 238                 dest->seed_len = 0;
 239                 }
 240
 241
 242         return dest->meth->group_copy(dest, src);
 243         }
 244
 245
 246 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
 247         {
 248         return group->meth;
 249         }
 250
 251
 252 int EC_METHOD_get_field_type(const EC_METHOD *meth)
 253         {
 254         return meth->field_type;
 255         }
 256
 257
 258 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
 259         {
 260         if (generator == NULL)
 261                 {
 262                 ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_PASSED_NULL_PARAMETER);
 263                 return 0   ;
 264                 }
 265
 266         if (group->generator == NULL)
 267                 {
 268                 group->generator = EC_POINT_new(group);
 269                 if (group->generator == NULL) return 0;
 270                 }
 271         if (!EC_POINT_copy(group->generator, generator)) return 0;
 272
 273         if (order != NULL)
 274                 { if (!BN_copy(&group->order, order)) return 0; }
 275         else
 276                 { if (!BN_zero(&group->order)) return 0; }
 277
 278         if (cofactor != NULL)
 279                 { if (!BN_copy(&group->cofactor, cofactor)) return 0; }
 280         else
 281                 { if (!BN_zero(&group->cofactor)) return 0; }
 282
 283         return 1;
 284         }
 285
 286
 287 EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
 288         {
 289         return group->generator;
 290         }
 291
 292
 293 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 294         {
 295         if (!BN_copy(order, &group->order))
 296                 return 0;
 297
 298         return !BN_is_zero(order);
 299         }
 300
 301
 302 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
 303         {
 304         if (!BN_copy(cofactor, &group->cofactor))
 305                 return 0;
 306
 307         return !BN_is_zero(&group->cofactor);
 308         }
 309
 310
 311 void EC_GROUP_set_nid(EC_GROUP *group, int nid)
 312         {
 313         group->curve_name = nid;
 314         }
 315
 316
 317 int EC_GROUP_get_nid(const EC_GROUP *group)
 318         {
 319         return group->curve_name;
 320         }
 321
 322
 323 void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag)
 324         {
 325         group->asn1_flag = flag;
 326         }
 327
 328
 329 int EC_GROUP_get_asn1_flag(const EC_GROUP *group)
 330         {
 331         return group->asn1_flag;
 332         }
 333
 334
 335 void EC_GROUP_set_point_conversion_form(EC_GROUP *group,
 336                                         point_conversion_form_t form)
 337         {
 338         group->asn1_form = form;
 339         }
 340
 341
 342 point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *group)
 343         {
 344         return group->asn1_form;
 345         }
 346
 347
 348 size_t EC_GROUP_set_seed(EC_GROUP *group, const unsigned char *p, size_t len)
 349         {
 350         if (group->seed)
 351                 {
 352                 OPENSSL_free(group->seed);
 353                 group->seed = NULL;
 354                 group->seed_len = 0;
 355                 }
 356
 357         if (!len || !p)
 358                 return 1;
 359
 360         if ((group->seed = OPENSSL_malloc(len)) == NULL)
 361                 return 0;
 362         memcpy(group->seed, p, len);
 363         group->seed_len = len;
 364
 365         return len;
 366         }
 367
 368
 369 unsigned char *EC_GROUP_get0_seed(const EC_GROUP *group)
 370         {
 371         return group->seed;
 372         }
 373
 374
 375 size_t EC_GROUP_get_seed_len(const EC_GROUP *group)
 376         {
 377         return group->seed_len;
 378         }
 379
 380
 381 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
 382         {
 383         if (group->meth->group_set_curve_GFp == 0)
 384                 {
 385                 ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 386                 return 0;
 387                 }
 388         return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
 389         }
 390
 391
 392 int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
 393         {
 394         if (group->meth->group_get_curve_GFp == 0)
 395                 {
 396                 ECerr(EC_F_EC_GROUP_GET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 397                 return 0;
 398                 }
 399         return group->meth->group_get_curve_GFp(group, p, a, b, ctx);
 400         }
 401
 402
 403 int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)
 404         {
 405         if (group->meth->group_check_discriminant == 0)
 406                 {
 407                 ECerr(EC_F_EC_GROUP_CHECK_DISCRIMINANT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 408                 return 0;
 409                 }
 410         return group->meth->group_check_discriminant(group, ctx);
 411         }
 412
 413
 414 /* this has 'package' visibility */
 415 int EC_GROUP_set_extra_data(EC_GROUP *group, void *extra_data, void *(*extra_data_dup_func)(void *),
 416         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 417         {
 418         if ((group->extra_data != NULL)
 419                 || (group->extra_data_dup_func != 0)
 420                 || (group->extra_data_free_func != 0)
 421                 || (group->extra_data_clear_free_func != 0))
 422                 {
 423                 ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
 424                 return 0;
 425                 }
 426
 427         group->extra_data = extra_data;
 428         group->extra_data_dup_func = extra_data_dup_func;
 429         group->extra_data_free_func = extra_data_free_func;
 430         group->extra_data_clear_free_func = extra_data_clear_free_func;
 431         return 1;
 432         }
 433
 434
 435 /* this has 'package' visibility */
 436 void *EC_GROUP_get_extra_data(const EC_GROUP *group, void *(*extra_data_dup_func)(void *),
 437         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 438         {
 439         if ((group->extra_data_dup_func != extra_data_dup_func)
 440                 || (group->extra_data_free_func != extra_data_free_func)
 441                 || (group->extra_data_clear_free_func != extra_data_clear_free_func))
 442                 {
 443                 ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
 444                 return NULL;
 445                 }
 446
 447         return group->extra_data;
 448         }
 449
 450
 451 /* this has 'package' visibility */
 452 void EC_GROUP_free_extra_data(EC_GROUP *group)
 453         {
 454         if (group->extra_data_free_func)
 455                 group->extra_data_free_func(group->extra_data);
 456         group->extra_data = NULL;
 457         group->extra_data_dup_func = 0;
 458         group->extra_data_free_func = 0;
 459         group->extra_data_clear_free_func = 0;
 460         }
 461
 462
 463 /* this has 'package' visibility */
 464 void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
 465         {
 466         if (group->extra_data_clear_free_func)
 467                 group->extra_data_clear_free_func(group->extra_data);
 468         else if (group->extra_data_free_func)
 469                 group->extra_data_free_func(group->extra_data);
 470         group->extra_data = NULL;
 471         group->extra_data_dup_func = 0;
 472         group->extra_data_free_func = 0;
 473         group->extra_data_clear_free_func = 0;
 474         }
 475
 476
 477 /* functions for EC_POINT objects */
 478
 479 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 480         {
 481         EC_POINT *ret;
 482
 483         if (group == NULL)
 484                 {
 485                 ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 486                 return NULL;
 487                 }
 488         if (group->meth->point_init == 0)
 489                 {
 490                 ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 491                 return NULL;
 492                 }
 493
 494         ret = OPENSSL_malloc(sizeof *ret);
 495         if (ret == NULL)
 496                 {
 497                 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 498                 return NULL;
 499                 }
 500
 501         ret->meth = group->meth;
 502
 503         if (!ret->meth->point_init(ret))
 504                 {
 505                 OPENSSL_free(ret);
 506                 return NULL;
 507                 }
 508
 509         return ret;
 510         }
 511
 512
 513 void EC_POINT_free(EC_POINT *point)
 514         {
 515         if (!point) return;
 516
 517         if (point->meth->point_finish != 0)
 518                 point->meth->point_finish(point);
 519         OPENSSL_free(point);
 520         }
 521
 522
 523 void EC_POINT_clear_free(EC_POINT *point)
 524         {
 525         if (!point) return;
 526
 527         if (point->meth->point_clear_finish != 0)
 528                 point->meth->point_clear_finish(point);
 529         else if (point->meth != NULL && point->meth->point_finish != 0)
 530                 point->meth->point_finish(point);
 531         memset(point, 0, sizeof *point);
 532         OPENSSL_free(point);
 533         }
 534
 535
 536 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 537         {
 538         if (dest->meth->point_copy == 0)
 539                 {
 540                 ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 541                 return 0;
 542                 }
 543         if (dest->meth != src->meth)
 544                 {
 545                 ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 546                 return 0;
 547                 }
 548         if (dest == src)
 549                 return 1;
 550         return dest->meth->point_copy(dest, src);
 551         }
 552
 553
 554 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
 555         {
 556         return point->meth;
 557         }
 558
 559
 560 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 561         {
 562         if (group->meth->point_set_to_infinity == 0)
 563                 {
 564                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 565                 return 0;
 566                 }
 567         if (group->meth != point->meth)
 568                 {
 569                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 570                 return 0;
 571                 }
 572         return group->meth->point_set_to_infinity(group, point);
 573         }
 574
 575
 576 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 577         const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
 578         {
 579         if (group->meth->point_set_Jprojective_coordinates_GFp == 0)
 580                 {
 581                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 582                 return 0;
 583                 }
 584         if (group->meth != point->meth)
 585                 {
 586                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 587                 return 0;
 588                 }
 589         return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 590         }
 591
 592
 593 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 594         BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
 595         {
 596         if (group->meth->point_get_Jprojective_coordinates_GFp == 0)
 597                 {
 598                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 599                 return 0;
 600                 }
 601         if (group->meth != point->meth)
 602                 {
 603                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 604                 return 0;
 605                 }
 606         return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 607         }
 608
 609
 610 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 611         const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
 612         {
 613         if (group->meth->point_set_affine_coordinates_GFp == 0)
 614                 {
 615                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 616                 return 0;
 617                 }
 618         if (group->meth != point->meth)
 619                 {
 620                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 621                 return 0;
 622                 }
 623         return group->meth->point_set_affine_coordinates_GFp(group, point, x, y, ctx);
 624         }
 625
 626
 627 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 628         BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
 629         {
 630         if (group->meth->point_get_affine_coordinates_GFp == 0)
 631                 {
 632                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 633                 return 0;
 634                 }
 635         if (group->meth != point->meth)
 636                 {
 637                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 638                 return 0;
 639                 }
 640         return group->meth->point_get_affine_coordinates_GFp(group, point, x, y, ctx);
 641         }
 642
 643
 644 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 645         const BIGNUM *x, int y_bit, BN_CTX *ctx)
 646         {
 647         if (group->meth->point_set_compressed_coordinates_GFp == 0)
 648                 {
 649                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 650                 return 0;
 651                 }
 652         if (group->meth != point->meth)
 653                 {
 654                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 655                 return 0;
 656                 }
 657         return group->meth->point_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx);
 658         }
 659
 660
 661 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
 662         unsigned char *buf, size_t len, BN_CTX *ctx)
 663         {
 664         if (group->meth->point2oct == 0)
 665                 {
 666                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 667                 return 0;
 668                 }
 669         if (group->meth != point->meth)
 670                 {
 671                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
 672                 return 0;
 673                 }
 674         return group->meth->point2oct(group, point, form, buf, len, ctx);
 675         }
 676
 677
 678 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 679         const unsigned char *buf, size_t len, BN_CTX *ctx)
 680         {
 681         if (group->meth->oct2point == 0)
 682                 {
 683                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 684                 return 0;
 685                 }
 686         if (group->meth != point->meth)
 687                 {
 688                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
 689                 return 0;
 690                 }
 691         return group->meth->oct2point(group, point, buf, len, ctx);
 692         }
 693
 694
 695 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 696         {
 697         if (group->meth->add == 0)
 698                 {
 699                 ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 700                 return 0;
 701                 }
 702         if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
 703                 {
 704                 ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 705                 return 0;
 706                 }
 707         return group->meth->add(group, r, a, b, ctx);
 708         }
 709
 710
 711 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
 712         {
 713         if (group->meth->dbl == 0)
 714                 {
 715                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 716                 return 0;
 717                 }
 718         if ((group->meth != r->meth) || (r->meth != a->meth))
 719                 {
 720                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 721                 return 0;
 722                 }
 723         return group->meth->dbl(group, r, a, ctx);
 724         }
 725
 726
 727 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
 728         {
 729         if (group->meth->dbl == 0)
 730                 {
 731                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 732                 return 0;
 733                 }
 734         if (group->meth != a->meth)
 735                 {
 736                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 737                 return 0;
 738                 }
 739         return group->meth->invert(group, a, ctx);
 740         }
 741
 742
 743 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 744         {
 745         if (group->meth->is_at_infinity == 0)
 746                 {
 747                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 748                 return 0;
 749                 }
 750         if (group->meth != point->meth)
 751                 {
 752                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 753                 return 0;
 754                 }
 755         return group->meth->is_at_infinity(group, point);
 756         }
 757
 758
 759 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
 760         {
 761         if (group->meth->is_on_curve == 0)
 762                 {
 763                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 764                 return 0;
 765                 }
 766         if (group->meth != point->meth)
 767                 {
 768                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
 769                 return 0;
 770                 }
 771         return group->meth->is_on_curve(group, point, ctx);
 772         }
 773
 774
 775 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 776         {
 777         if (group->meth->point_cmp == 0)
 778                 {
 779                 ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 780                 return 0;
 781                 }
 782         if ((group->meth != a->meth) || (a->meth != b->meth))
 783                 {
 784                 ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
 785                 return 0;
 786                 }
 787         return group->meth->point_cmp(group, a, b, ctx);
 788         }
 789
 790
 791 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
 792         {
 793         if (group->meth->make_affine == 0)
 794                 {
 795                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 796                 return 0;
 797                 }
 798         if (group->meth != point->meth)
 799                 {
 800                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 801                 return 0;
 802                 }
 803         return group->meth->make_affine(group, point, ctx);
 804         }
 805
 806
 807 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
 808         {
 809         size_t i;
 810
 811         if (group->meth->points_make_affine == 0)
 812                 {
 813                 ECerr(EC_F_EC_POINTS_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 814                 return 0;
 815                 }
 816         for (i = 0; i < num; i++)
 817                 {
 818                 if (group->meth != points[i]->meth)
 819                         {
 820                         ECerr(EC_F_EC_POINTS_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 821                         return 0;
 822                         }
 823                 }
 824         return group->meth->points_make_affine(group, num, points, ctx);
 825         }