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