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