crypto/ec/ec_lib.c

   1 /* crypto/ec/ec_lib.c */
   2 /* ====================================================================
   3  * Copyright (c) 1998-2001 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         if (!meth->group_init(ret))
  98                 {
  99                 OPENSSL_free(ret);
 100                 return NULL;
 101                 }
 102
 103         return ret;
 104         }
 105
 106
 107 void EC_GROUP_free(EC_GROUP *group)
 108         {
 109         if (group->meth->group_finish != 0)
 110                 group->meth->group_finish(group);
 111
 112         EC_GROUP_free_extra_data(group);
 113
 114         OPENSSL_free(group);
 115         }
 116
 117
 118 void EC_GROUP_clear_free(EC_GROUP *group)
 119         {
 120         if (group->meth->group_clear_finish != 0)
 121                 group->meth->group_clear_finish(group);
 122         else if (group->meth != NULL && group->meth->group_finish != 0)
 123                 group->meth->group_finish(group);
 124
 125         EC_GROUP_clear_free_extra_data(group);
 126
 127         memset(group, 0, sizeof *group);
 128         OPENSSL_free(group);
 129         }
 130
 131
 132 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 133         {
 134         if (dest->meth->group_copy == 0)
 135                 {
 136                 ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 137                 return 0;
 138                 }
 139         if (dest->meth != src->meth)
 140                 {
 141                 ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 142                 return 0;
 143                 }
 144         if (dest == src)
 145                 return 1;
 146
 147         EC_GROUP_clear_free_extra_data(dest);
 148         if (src->extra_data_dup_func)
 149                 {
 150                 if (src->extra_data != NULL)
 151                         {
 152                         dest->extra_data = src->extra_data_dup_func(src->extra_data);
 153                         if (dest->extra_data == NULL)
 154                                 return 0;
 155                         }
 156
 157                 dest->extra_data_dup_func = src->extra_data_dup_func;
 158                 dest->extra_data_free_func = src->extra_data_free_func;
 159                 dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
 160                 }
 161
 162         return dest->meth->group_copy(dest, src);
 163         }
 164
 165
 166 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
 167         {
 168         return group->meth;
 169         }
 170
 171
 172 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
 173         {
 174         if (group->meth->group_set_curve_GFp == 0)
 175                 {
 176                 ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 177                 return 0;
 178                 }
 179         return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
 180         }
 181
 182
 183 int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
 184         {
 185         if (group->meth->group_get_curve_GFp == 0)
 186                 {
 187                 ECerr(EC_F_EC_GROUP_GET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 188                 return 0;
 189                 }
 190         return group->meth->group_get_curve_GFp(group, p, a, b, ctx);
 191         }
 192
 193
 194 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
 195         {
 196         if (group->meth->group_set_generator == 0)
 197                 {
 198                 ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 199                 return 0;
 200                 }
 201         return group->meth->group_set_generator(group, generator, order, cofactor);
 202         }
 203
 204
 205 EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
 206         {
 207         if (group->meth->group_get0_generator == 0)
 208                 {
 209                 ECerr(EC_F_EC_GROUP_GET0_GENERATOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 210                 return 0;
 211                 }
 212         return group->meth->group_get0_generator(group);
 213         }
 214
 215
 216 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 217         {
 218         if (group->meth->group_get_order == 0)
 219                 {
 220                 ECerr(EC_F_EC_GROUP_GET_ORDER, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 221                 return 0;
 222                 }
 223         return group->meth->group_get_order(group, order, ctx);
 224         }
 225
 226
 227 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
 228         {
 229         if (group->meth->group_get_cofactor == 0)
 230                 {
 231                 ECerr(EC_F_EC_GROUP_GET_COFACTOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 232                 return 0;
 233                 }
 234         return group->meth->group_get_cofactor(group, cofactor, ctx);
 235         }
 236
 237
 238 /* this has 'package' visibility */
 239 int EC_GROUP_set_extra_data(EC_GROUP *group, void *extra_data, void *(*extra_data_dup_func)(void *),
 240         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 241         {
 242         if ((group->extra_data != NULL)
 243                 || (group->extra_data_dup_func != 0)
 244                 || (group->extra_data_free_func != 0)
 245                 || (group->extra_data_clear_free_func != 0))
 246                 {
 247                 ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
 248                 return 0;
 249                 }
 250
 251         group->extra_data = extra_data;
 252         group->extra_data_dup_func = extra_data_dup_func;
 253         group->extra_data_free_func = extra_data_free_func;
 254         group->extra_data_clear_free_func = extra_data_clear_free_func;
 255         return 1;
 256         }
 257
 258
 259 /* this has 'package' visibility */
 260 void *EC_GROUP_get_extra_data(const EC_GROUP *group, void *(*extra_data_dup_func)(void *),
 261         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 262         {
 263         if ((group->extra_data_dup_func != extra_data_dup_func)
 264                 || (group->extra_data_free_func != extra_data_free_func)
 265                 || (group->extra_data_clear_free_func != extra_data_clear_free_func))
 266                 {
 267                 ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
 268                 return NULL;
 269                 }
 270
 271         return group->extra_data;
 272         }
 273
 274
 275 /* this has 'package' visibility */
 276 void EC_GROUP_free_extra_data(EC_GROUP *group)
 277         {
 278         if (group->extra_data_free_func)
 279                 group->extra_data_free_func(group->extra_data);
 280         group->extra_data = NULL;
 281         group->extra_data_dup_func = 0;
 282         group->extra_data_free_func = 0;
 283         group->extra_data_clear_free_func = 0;
 284         }
 285
 286
 287 /* this has 'package' visibility */
 288 void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
 289         {
 290         if (group->extra_data_clear_free_func)
 291                 group->extra_data_clear_free_func(group->extra_data);
 292         else if (group->extra_data_free_func)
 293                 group->extra_data_free_func(group->extra_data);
 294         group->extra_data = NULL;
 295         group->extra_data_dup_func = 0;
 296         group->extra_data_free_func = 0;
 297         group->extra_data_clear_free_func = 0;
 298         }
 299
 300
 301
 302 /* functions for EC_POINT objects */
 303
 304 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 305         {
 306         EC_POINT *ret;
 307
 308         if (group == NULL)
 309                 {
 310                 ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 311                 return NULL;
 312                 }
 313         if (group->meth->point_init == 0)
 314                 {
 315                 ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 316                 return NULL;
 317                 }
 318
 319         ret = OPENSSL_malloc(sizeof *ret);
 320         if (ret == NULL)
 321                 {
 322                 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 323                 return NULL;
 324                 }
 325
 326         ret->meth = group->meth;
 327
 328         if (!ret->meth->point_init(ret))
 329                 {
 330                 OPENSSL_free(ret);
 331                 return NULL;
 332                 }
 333
 334         return ret;
 335         }
 336
 337
 338 void EC_POINT_free(EC_POINT *point)
 339         {
 340         if (point->meth->point_finish != 0)
 341                 point->meth->point_finish(point);
 342         OPENSSL_free(point);
 343         }
 344
 345
 346 void EC_POINT_clear_free(EC_POINT *point)
 347         {
 348         if (point->meth->point_clear_finish != 0)
 349                 point->meth->point_clear_finish(point);
 350         else if (point->meth != NULL && point->meth->point_finish != 0)
 351                 point->meth->point_finish(point);
 352         memset(point, 0, sizeof *point);
 353         OPENSSL_free(point);
 354         }
 355
 356
 357 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 358         {
 359         if (dest->meth->point_copy == 0)
 360                 {
 361                 ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 362                 return 0;
 363                 }
 364         if (dest->meth != src->meth)
 365                 {
 366                 ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 367                 return 0;
 368                 }
 369         if (dest == src)
 370                 return 1;
 371         return dest->meth->point_copy(dest, src);
 372         }
 373
 374
 375 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
 376         {
 377         return point->meth;
 378         }
 379
 380
 381 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 382         {
 383         if (group->meth->point_set_to_infinity == 0)
 384                 {
 385                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 386                 return 0;
 387                 }
 388         if (group->meth != point->meth)
 389                 {
 390                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 391                 return 0;
 392                 }
 393         return group->meth->point_set_to_infinity(group, point);
 394         }
 395
 396
 397 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 398         const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
 399         {
 400         if (group->meth->point_set_Jprojective_coordinates_GFp == 0)
 401                 {
 402                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 403                 return 0;
 404                 }
 405         if (group->meth != point->meth)
 406                 {
 407                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 408                 return 0;
 409                 }
 410         return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 411         }
 412
 413
 414 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 415         BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
 416         {
 417         if (group->meth->point_get_Jprojective_coordinates_GFp == 0)
 418                 {
 419                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 420                 return 0;
 421                 }
 422         if (group->meth != point->meth)
 423                 {
 424                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 425                 return 0;
 426                 }
 427         return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 428         }
 429
 430
 431 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 432         const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
 433         {
 434         if (group->meth->point_set_affine_coordinates_GFp == 0)
 435                 {
 436                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 437                 return 0;
 438                 }
 439         if (group->meth != point->meth)
 440                 {
 441                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 442                 return 0;
 443                 }
 444         return group->meth->point_set_affine_coordinates_GFp(group, point, x, y, ctx);
 445         }
 446
 447
 448 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 449         BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
 450         {
 451         if (group->meth->point_get_affine_coordinates_GFp == 0)
 452                 {
 453                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 454                 return 0;
 455                 }
 456         if (group->meth != point->meth)
 457                 {
 458                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 459                 return 0;
 460                 }
 461         return group->meth->point_get_affine_coordinates_GFp(group, point, x, y, ctx);
 462         }
 463
 464
 465 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 466         const BIGNUM *x, int y_bit, BN_CTX *ctx)
 467         {
 468         if (group->meth->point_set_compressed_coordinates_GFp == 0)
 469                 {
 470                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 471                 return 0;
 472                 }
 473         if (group->meth != point->meth)
 474                 {
 475                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 476                 return 0;
 477                 }
 478         return group->meth->point_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx);
 479         }
 480
 481
 482 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
 483         unsigned char *buf, size_t len, BN_CTX *ctx)
 484         {
 485         if (group->meth->point2oct == 0)
 486                 {
 487                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 488                 return 0;
 489                 }
 490         if (group->meth != point->meth)
 491                 {
 492                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
 493                 return 0;
 494                 }
 495         return group->meth->point2oct(group, point, form, buf, len, ctx);
 496         }
 497
 498
 499 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 500         const unsigned char *buf, size_t len, BN_CTX *ctx)
 501         {
 502         if (group->meth->oct2point == 0)
 503                 {
 504                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 505                 return 0;
 506                 }
 507         if (group->meth != point->meth)
 508                 {
 509                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
 510                 return 0;
 511                 }
 512         return group->meth->oct2point(group, point, buf, len, ctx);
 513         }
 514
 515
 516 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 517         {
 518         if (group->meth->add == 0)
 519                 {
 520                 ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 521                 return 0;
 522                 }
 523         if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
 524                 {
 525                 ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 526                 return 0;
 527                 }
 528         return group->meth->add(group, r, a, b, ctx);
 529         }
 530
 531
 532 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
 533         {
 534         if (group->meth->dbl == 0)
 535                 {
 536                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 537                 return 0;
 538                 }
 539         if ((group->meth != r->meth) || (r->meth != a->meth))
 540                 {
 541                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 542                 return 0;
 543                 }
 544         return group->meth->dbl(group, r, a, ctx);
 545         }
 546
 547
 548 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
 549         {
 550         if (group->meth->dbl == 0)
 551                 {
 552                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 553                 return 0;
 554                 }
 555         if (group->meth != a->meth)
 556                 {
 557                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 558                 return 0;
 559                 }
 560         return group->meth->invert(group, a, ctx);
 561         }
 562
 563
 564 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 565         {
 566         if (group->meth->is_at_infinity == 0)
 567                 {
 568                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 569                 return 0;
 570                 }
 571         if (group->meth != point->meth)
 572                 {
 573                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 574                 return 0;
 575                 }
 576         return group->meth->is_at_infinity(group, point);
 577         }
 578
 579
 580 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
 581         {
 582         if (group->meth->is_on_curve == 0)
 583                 {
 584                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 585                 return 0;
 586                 }
 587         if (group->meth != point->meth)
 588                 {
 589                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
 590                 return 0;
 591                 }
 592         return group->meth->is_on_curve(group, point, ctx);
 593         }
 594
 595
 596 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 597         {
 598         if (group->meth->point_cmp == 0)
 599                 {
 600                 ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 601                 return 0;
 602                 }
 603         if ((group->meth != a->meth) || (a->meth != b->meth))
 604                 {
 605                 ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
 606                 return 0;
 607                 }
 608         return group->meth->point_cmp(group, a, b, ctx);
 609         }
 610
 611
 612 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
 613         {
 614         if (group->meth->make_affine == 0)
 615                 {
 616                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 617                 return 0;
 618                 }
 619         if (group->meth != point->meth)
 620                 {
 621                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 622                 return 0;
 623                 }
 624         return group->meth->make_affine(group, point, ctx);
 625         }
 626
 627
 628 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
 629         {
 630         size_t i;
 631
 632         if (group->meth->points_make_affine == 0)
 633                 {
 634                 ECerr(EC_F_EC_POINTS_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 635                 return 0;
 636                 }
 637         for (i = 0; i < num; i++)
 638                 {
 639                 if (group->meth != points[i]->meth)
 640                         {
 641                         ECerr(EC_F_EC_POINTS_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 642                         return 0;
 643                         }
 644                 }
 645         return group->meth->points_make_affine(group, num, points, ctx);
 646         }