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