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