crypto/ec/ec_lib.c

   1 /* crypto/ec/ec_lib.c */
   2 /* ====================================================================
   3  * Copyright (c) 1998-2002 The OpenSSL Project.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  *
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in
  14  *    the documentation and/or other materials provided with the
  15  *    distribution.
  16  *
  17  * 3. All advertising materials mentioning features or use of this
  18  *    software must display the following acknowledgment:
  19  *    "This product includes software developed by the OpenSSL Project
  20  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  21  *
  22  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  23  *    endorse or promote products derived from this software without
  24  *    prior written permission. For written permission, please contact
  25  *    openssl-core@openssl.org.
  26  *
  27  * 5. Products derived from this software may not be called "OpenSSL"
  28  *    nor may "OpenSSL" appear in their names without prior written
  29  *    permission of the OpenSSL Project.
  30  *
  31  * 6. Redistributions of any form whatsoever must retain the following
  32  *    acknowledgment:
  33  *    "This product includes software developed by the OpenSSL Project
  34  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  35  *
  36  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  37  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  38  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  39  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  40  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  41  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  42  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  43  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  44  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  45  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  46  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  47  * OF THE POSSIBILITY OF SUCH DAMAGE.
  48  * ====================================================================
  49  *
  50  * This product includes cryptographic software written by Eric Young
  51  * (eay@cryptsoft.com).  This product includes software written by Tim
  52  * Hudson (tjh@cryptsoft.com).
  53  *
  54  */
  55
  56 #include <string.h>
  57
  58 #include <openssl/err.h>
  59 #include <openssl/opensslv.h>
  60
  61 #include "ec_lcl.h"
  62
  63 static const char EC_version[] = "EC" OPENSSL_VERSION_PTEXT;
  64
  65
  66 /* functions for EC_GROUP objects */
  67
  68 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
  69         {
  70         EC_GROUP *ret;
  71
  72         if (meth == NULL)
  73                 {
  74                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
  75                 return NULL;
  76                 }
  77         if (meth->group_init == 0)
  78                 {
  79                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  80                 return NULL;
  81                 }
  82
  83         ret = OPENSSL_malloc(sizeof *ret);
  84         if (ret == NULL)
  85                 {
  86                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
  87                 return NULL;
  88                 }
  89
  90         ret->meth = meth;
  91
  92         ret->extra_data = NULL;
  93         ret->extra_data_dup_func = 0;
  94         ret->extra_data_free_func = 0;
  95         ret->extra_data_clear_free_func = 0;
  96
  97         ret->generator = NULL;
  98         BN_init(&ret->order);
  99         BN_init(&ret->cofactor);
 100
 101         ret->nid = 0;
 102
 103         if (!meth->group_init(ret))
 104                 {
 105                 OPENSSL_free(ret);
 106                 return NULL;
 107                 }
 108
 109         return ret;
 110         }
 111
 112
 113 void EC_GROUP_free(EC_GROUP *group)
 114         {
 115         if (!group) return;
 116
 117         if (group->meth->group_finish != 0)
 118                 group->meth->group_finish(group);
 119
 120         EC_GROUP_free_extra_data(group);
 121
 122         if (group->generator != NULL)
 123                 EC_POINT_free(group->generator);
 124         BN_free(&group->order);
 125         BN_free(&group->cofactor);
 126
 127         OPENSSL_free(group);
 128         }
 129
 130
 131 void EC_GROUP_clear_free(EC_GROUP *group)
 132         {
 133         if (!group) return;
 134
 135         if (group->meth->group_clear_finish != 0)
 136                 group->meth->group_clear_finish(group);
 137         else if (group->meth != NULL && group->meth->group_finish != 0)
 138                 group->meth->group_finish(group);
 139
 140         EC_GROUP_clear_free_extra_data(group);
 141
 142         if (group->generator != NULL)
 143                 EC_POINT_clear_free(group->generator);
 144         BN_clear_free(&group->order);
 145         BN_clear_free(&group->cofactor);
 146
 147         memset(group, 0, sizeof *group);
 148         OPENSSL_free(group);
 149         }
 150
 151
 152 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 153         {
 154         if (dest->meth->group_copy == 0)
 155                 {
 156                 ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 157                 return 0;
 158                 }
 159         if (dest->meth != src->meth)
 160                 {
 161                 ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 162                 return 0;
 163                 }
 164         if (dest == src)
 165                 return 1;
 166
 167         EC_GROUP_clear_free_extra_data(dest);
 168         if (src->extra_data_dup_func)
 169                 {
 170                 if (src->extra_data != NULL)
 171                         {
 172                         dest->extra_data = src->extra_data_dup_func(src->extra_data);
 173                         if (dest->extra_data == NULL)
 174                                 return 0;
 175                         }
 176
 177                 dest->extra_data_dup_func = src->extra_data_dup_func;
 178                 dest->extra_data_free_func = src->extra_data_free_func;
 179                 dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
 180                 }
 181
 182         if (src->generator != NULL)
 183                 {
 184                 if (dest->generator == NULL)
 185                         {
 186                         dest->generator = EC_POINT_new(dest);
 187                         if (dest->generator == NULL) return 0;
 188                         }
 189                 if (!EC_POINT_copy(dest->generator, src->generator)) return 0;
 190                 }
 191         else
 192                 {
 193                 /* src->generator == NULL */
 194                 if (dest->generator != NULL)
 195                         {
 196                         EC_POINT_clear_free(dest->generator);
 197                         dest->generator = NULL;
 198                         }
 199                 }
 200
 201         if (!BN_copy(&dest->order, &src->order)) return 0;
 202         if (!BN_copy(&dest->cofactor, &src->cofactor)) return 0;
 203
 204         dest->nid = src->nid;
 205
 206         return dest->meth->group_copy(dest, src);
 207         }
 208
 209
 210 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
 211         {
 212         return group->meth;
 213         }
 214
 215
 216 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
 217         {
 218         if (generator == NULL)
 219                 {
 220                 ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_PASSED_NULL_PARAMETER);
 221                 return 0   ;
 222                 }
 223
 224         if (group->generator == NULL)
 225                 {
 226                 group->generator = EC_POINT_new(group);
 227                 if (group->generator == NULL) return 0;
 228                 }
 229         if (!EC_POINT_copy(group->generator, generator)) return 0;
 230
 231         if (order != NULL)
 232                 { if (!BN_copy(&group->order, order)) return 0; }
 233         else
 234                 { if (!BN_zero(&group->order)) return 0; }
 235
 236         if (cofactor != NULL)
 237                 { if (!BN_copy(&group->cofactor, cofactor)) return 0; }
 238         else
 239                 { if (!BN_zero(&group->cofactor)) return 0; }
 240
 241         return 1;
 242         }
 243
 244
 245 EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
 246         {
 247         return group->generator;
 248         }
 249
 250
 251 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 252         {
 253         if (!BN_copy(order, &group->order))
 254                 return 0;
 255
 256         return !BN_is_zero(order);
 257         }
 258
 259
 260 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
 261         {
 262         if (!BN_copy(cofactor, &group->cofactor))
 263                 return 0;
 264
 265         return !BN_is_zero(&group->cofactor);
 266         }
 267
 268
 269 void EC_GROUP_set_nid(EC_GROUP *group, int nid)
 270         {
 271         group->nid = nid;
 272         }
 273
 274
 275 int EC_GROUP_get_nid(const EC_GROUP *group)
 276         {
 277         return group->nid;
 278         }
 279
 280
 281 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
 282         {
 283         if (group->meth->group_set_curve_GFp == 0)
 284                 {
 285                 ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 286                 return 0;
 287                 }
 288         return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
 289         }
 290
 291
 292 int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
 293         {
 294         if (group->meth->group_get_curve_GFp == 0)
 295                 {
 296                 ECerr(EC_F_EC_GROUP_GET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 297                 return 0;
 298                 }
 299         return group->meth->group_get_curve_GFp(group, p, a, b, ctx);
 300         }
 301
 302
 303 int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)
 304         {
 305         if (group->meth->group_check_discriminant == 0)
 306                 {
 307                 ECerr(EC_F_EC_GROUP_CHECK_DISCRIMINANT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 308                 return 0;
 309                 }
 310         return group->meth->group_check_discriminant(group, ctx);
 311         }
 312
 313
 314 /* this has 'package' visibility */
 315 int EC_GROUP_set_extra_data(EC_GROUP *group, void *extra_data, void *(*extra_data_dup_func)(void *),
 316         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 317         {
 318         if ((group->extra_data != NULL)
 319                 || (group->extra_data_dup_func != 0)
 320                 || (group->extra_data_free_func != 0)
 321                 || (group->extra_data_clear_free_func != 0))
 322                 {
 323                 ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
 324                 return 0;
 325                 }
 326
 327         group->extra_data = extra_data;
 328         group->extra_data_dup_func = extra_data_dup_func;
 329         group->extra_data_free_func = extra_data_free_func;
 330         group->extra_data_clear_free_func = extra_data_clear_free_func;
 331         return 1;
 332         }
 333
 334
 335 /* this has 'package' visibility */
 336 void *EC_GROUP_get_extra_data(const EC_GROUP *group, void *(*extra_data_dup_func)(void *),
 337         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 338         {
 339         if ((group->extra_data_dup_func != extra_data_dup_func)
 340                 || (group->extra_data_free_func != extra_data_free_func)
 341                 || (group->extra_data_clear_free_func != extra_data_clear_free_func))
 342                 {
 343                 ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
 344                 return NULL;
 345                 }
 346
 347         return group->extra_data;
 348         }
 349
 350
 351 /* this has 'package' visibility */
 352 void EC_GROUP_free_extra_data(EC_GROUP *group)
 353         {
 354         if (group->extra_data_free_func)
 355                 group->extra_data_free_func(group->extra_data);
 356         group->extra_data = NULL;
 357         group->extra_data_dup_func = 0;
 358         group->extra_data_free_func = 0;
 359         group->extra_data_clear_free_func = 0;
 360         }
 361
 362
 363 /* this has 'package' visibility */
 364 void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
 365         {
 366         if (group->extra_data_clear_free_func)
 367                 group->extra_data_clear_free_func(group->extra_data);
 368         else if (group->extra_data_free_func)
 369                 group->extra_data_free_func(group->extra_data);
 370         group->extra_data = NULL;
 371         group->extra_data_dup_func = 0;
 372         group->extra_data_free_func = 0;
 373         group->extra_data_clear_free_func = 0;
 374         }
 375
 376
 377 /* functions for EC_POINT objects */
 378
 379 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 380         {
 381         EC_POINT *ret;
 382
 383         if (group == NULL)
 384                 {
 385                 ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 386                 return NULL;
 387                 }
 388         if (group->meth->point_init == 0)
 389                 {
 390                 ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 391                 return NULL;
 392                 }
 393
 394         ret = OPENSSL_malloc(sizeof *ret);
 395         if (ret == NULL)
 396                 {
 397                 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 398                 return NULL;
 399                 }
 400
 401         ret->meth = group->meth;
 402
 403         if (!ret->meth->point_init(ret))
 404                 {
 405                 OPENSSL_free(ret);
 406                 return NULL;
 407                 }
 408
 409         return ret;
 410         }
 411
 412
 413 void EC_POINT_free(EC_POINT *point)
 414         {
 415         if (!point) return;
 416
 417         if (point->meth->point_finish != 0)
 418                 point->meth->point_finish(point);
 419         OPENSSL_free(point);
 420         }
 421
 422
 423 void EC_POINT_clear_free(EC_POINT *point)
 424         {
 425         if (!point) return;
 426
 427         if (point->meth->point_clear_finish != 0)
 428                 point->meth->point_clear_finish(point);
 429         else if (point->meth != NULL && point->meth->point_finish != 0)
 430                 point->meth->point_finish(point);
 431         memset(point, 0, sizeof *point);
 432         OPENSSL_free(point);
 433         }
 434
 435
 436 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 437         {
 438         if (dest->meth->point_copy == 0)
 439                 {
 440                 ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 441                 return 0;
 442                 }
 443         if (dest->meth != src->meth)
 444                 {
 445                 ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 446                 return 0;
 447                 }
 448         if (dest == src)
 449                 return 1;
 450         return dest->meth->point_copy(dest, src);
 451         }
 452
 453
 454 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
 455         {
 456         return point->meth;
 457         }
 458
 459
 460 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 461         {
 462         if (group->meth->point_set_to_infinity == 0)
 463                 {
 464                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 465                 return 0;
 466                 }
 467         if (group->meth != point->meth)
 468                 {
 469                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 470                 return 0;
 471                 }
 472         return group->meth->point_set_to_infinity(group, point);
 473         }
 474
 475
 476 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 477         const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
 478         {
 479         if (group->meth->point_set_Jprojective_coordinates_GFp == 0)
 480                 {
 481                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 482                 return 0;
 483                 }
 484         if (group->meth != point->meth)
 485                 {
 486                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 487                 return 0;
 488                 }
 489         return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 490         }
 491
 492
 493 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 494         BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
 495         {
 496         if (group->meth->point_get_Jprojective_coordinates_GFp == 0)
 497                 {
 498                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 499                 return 0;
 500                 }
 501         if (group->meth != point->meth)
 502                 {
 503                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 504                 return 0;
 505                 }
 506         return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 507         }
 508
 509
 510 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 511         const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
 512         {
 513         if (group->meth->point_set_affine_coordinates_GFp == 0)
 514                 {
 515                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 516                 return 0;
 517                 }
 518         if (group->meth != point->meth)
 519                 {
 520                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 521                 return 0;
 522                 }
 523         return group->meth->point_set_affine_coordinates_GFp(group, point, x, y, ctx);
 524         }
 525
 526
 527 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 528         BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
 529         {
 530         if (group->meth->point_get_affine_coordinates_GFp == 0)
 531                 {
 532                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 533                 return 0;
 534                 }
 535         if (group->meth != point->meth)
 536                 {
 537                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 538                 return 0;
 539                 }
 540         return group->meth->point_get_affine_coordinates_GFp(group, point, x, y, ctx);
 541         }
 542
 543
 544 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 545         const BIGNUM *x, int y_bit, BN_CTX *ctx)
 546         {
 547         if (group->meth->point_set_compressed_coordinates_GFp == 0)
 548                 {
 549                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 550                 return 0;
 551                 }
 552         if (group->meth != point->meth)
 553                 {
 554                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 555                 return 0;
 556                 }
 557         return group->meth->point_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx);
 558         }
 559
 560
 561 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
 562         unsigned char *buf, size_t len, BN_CTX *ctx)
 563         {
 564         if (group->meth->point2oct == 0)
 565                 {
 566                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 567                 return 0;
 568                 }
 569         if (group->meth != point->meth)
 570                 {
 571                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
 572                 return 0;
 573                 }
 574         return group->meth->point2oct(group, point, form, buf, len, ctx);
 575         }
 576
 577
 578 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 579         const unsigned char *buf, size_t len, BN_CTX *ctx)
 580         {
 581         if (group->meth->oct2point == 0)
 582                 {
 583                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 584                 return 0;
 585                 }
 586         if (group->meth != point->meth)
 587                 {
 588                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
 589                 return 0;
 590                 }
 591         return group->meth->oct2point(group, point, buf, len, ctx);
 592         }
 593
 594
 595 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 596         {
 597         if (group->meth->add == 0)
 598                 {
 599                 ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 600                 return 0;
 601                 }
 602         if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
 603                 {
 604                 ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 605                 return 0;
 606                 }
 607         return group->meth->add(group, r, a, b, ctx);
 608         }
 609
 610
 611 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
 612         {
 613         if (group->meth->dbl == 0)
 614                 {
 615                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 616                 return 0;
 617                 }
 618         if ((group->meth != r->meth) || (r->meth != a->meth))
 619                 {
 620                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 621                 return 0;
 622                 }
 623         return group->meth->dbl(group, r, a, ctx);
 624         }
 625
 626
 627 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
 628         {
 629         if (group->meth->dbl == 0)
 630                 {
 631                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 632                 return 0;
 633                 }
 634         if (group->meth != a->meth)
 635                 {
 636                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 637                 return 0;
 638                 }
 639         return group->meth->invert(group, a, ctx);
 640         }
 641
 642
 643 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 644         {
 645         if (group->meth->is_at_infinity == 0)
 646                 {
 647                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 648                 return 0;
 649                 }
 650         if (group->meth != point->meth)
 651                 {
 652                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 653                 return 0;
 654                 }
 655         return group->meth->is_at_infinity(group, point);
 656         }
 657
 658
 659 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
 660         {
 661         if (group->meth->is_on_curve == 0)
 662                 {
 663                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 664                 return 0;
 665                 }
 666         if (group->meth != point->meth)
 667                 {
 668                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
 669                 return 0;
 670                 }
 671         return group->meth->is_on_curve(group, point, ctx);
 672         }
 673
 674
 675 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 676         {
 677         if (group->meth->point_cmp == 0)
 678                 {
 679                 ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 680                 return 0;
 681                 }
 682         if ((group->meth != a->meth) || (a->meth != b->meth))
 683                 {
 684                 ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
 685                 return 0;
 686                 }
 687         return group->meth->point_cmp(group, a, b, ctx);
 688         }
 689
 690
 691 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
 692         {
 693         if (group->meth->make_affine == 0)
 694                 {
 695                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 696                 return 0;
 697                 }
 698         if (group->meth != point->meth)
 699                 {
 700                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 701                 return 0;
 702                 }
 703         return group->meth->make_affine(group, point, ctx);
 704         }
 705
 706
 707 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
 708         {
 709         size_t i;
 710
 711         if (group->meth->points_make_affine == 0)
 712                 {
 713                 ECerr(EC_F_EC_POINTS_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 714                 return 0;
 715                 }
 716         for (i = 0; i < num; i++)
 717                 {
 718                 if (group->meth != points[i]->meth)
 719                         {
 720                         ECerr(EC_F_EC_POINTS_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 721                         return 0;
 722                         }
 723                 }
 724         return group->meth->points_make_affine(group, num, points, ctx);
 725         }