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  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  57  * Binary polynomial ECC support in OpenSSL originally developed by
  58  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
  59  */
  60
  61 #include <string.h>
  62
  63 #include <openssl/err.h>
  64 #include <openssl/opensslv.h>
  65
  66 #include "ec_lcl.h"
  67
  68 static const char EC_version[] = "EC" OPENSSL_VERSION_PTEXT;
  69
  70
  71 /* functions for EC_GROUP objects */
  72
  73 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
  74         {
  75         EC_GROUP *ret;
  76
  77         if (meth == NULL)
  78                 {
  79                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
  80                 return NULL;
  81                 }
  82         if (meth->group_init == 0)
  83                 {
  84                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  85                 return NULL;
  86                 }
  87
  88         ret = OPENSSL_malloc(sizeof *ret);
  89         if (ret == NULL)
  90                 {
  91                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
  92                 return NULL;
  93                 }
  94
  95         ret->meth = meth;
  96
  97         ret->extra_data = NULL;
  98         ret->extra_data_dup_func = 0;
  99         ret->extra_data_free_func = 0;
 100         ret->extra_data_clear_free_func = 0;
 101
 102         ret->generator = NULL;
 103         BN_init(&ret->order);
 104         BN_init(&ret->cofactor);
 105
 106         ret->curve_name = 0;
 107         ret->asn1_flag  = 0;
 108         ret->asn1_form  = POINT_CONVERSION_UNCOMPRESSED;
 109
 110         ret->seed = NULL;
 111         ret->seed_len = 0;
 112
 113         if (!meth->group_init(ret))
 114                 {
 115                 OPENSSL_free(ret);
 116                 return NULL;
 117                 }
 118
 119         return ret;
 120         }
 121
 122
 123 void EC_GROUP_free(EC_GROUP *group)
 124         {
 125         if (!group) return;
 126
 127         if (group->meth->group_finish != 0)
 128                 group->meth->group_finish(group);
 129
 130         EC_GROUP_free_extra_data(group);
 131
 132         if (group->generator != NULL)
 133                 EC_POINT_free(group->generator);
 134         BN_free(&group->order);
 135         BN_free(&group->cofactor);
 136
 137         if (group->seed)
 138                 OPENSSL_free(group->seed);
 139
 140         OPENSSL_free(group);
 141         }
 142
 143
 144 void EC_GROUP_clear_free(EC_GROUP *group)
 145         {
 146         if (!group) return;
 147
 148         if (group->meth->group_clear_finish != 0)
 149                 group->meth->group_clear_finish(group);
 150         else if (group->meth != NULL && group->meth->group_finish != 0)
 151                 group->meth->group_finish(group);
 152
 153         EC_GROUP_clear_free_extra_data(group);
 154
 155         if (group->generator != NULL)
 156                 EC_POINT_clear_free(group->generator);
 157         BN_clear_free(&group->order);
 158         BN_clear_free(&group->cofactor);
 159
 160         if (group->seed)
 161                 {
 162                 memset(group->seed, 0, group->seed_len);
 163                 OPENSSL_free(group->seed);
 164                 }
 165
 166         memset(group, 0, sizeof *group);
 167         OPENSSL_free(group);
 168         }
 169
 170
 171 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 172         {
 173         if (dest->meth->group_copy == 0)
 174                 {
 175                 ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 176                 return 0;
 177                 }
 178         if (dest->meth != src->meth)
 179                 {
 180                 ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 181                 return 0;
 182                 }
 183         if (dest == src)
 184                 return 1;
 185
 186         EC_GROUP_clear_free_extra_data(dest);
 187         if (src->extra_data_dup_func)
 188                 {
 189                 if (src->extra_data != NULL)
 190                         {
 191                         dest->extra_data = src->extra_data_dup_func(src->extra_data);
 192                         if (dest->extra_data == NULL)
 193                                 return 0;
 194                         }
 195
 196                 dest->extra_data_dup_func = src->extra_data_dup_func;
 197                 dest->extra_data_free_func = src->extra_data_free_func;
 198                 dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
 199                 }
 200
 201         if (src->generator != NULL)
 202                 {
 203                 if (dest->generator == NULL)
 204                         {
 205                         dest->generator = EC_POINT_new(dest);
 206                         if (dest->generator == NULL) return 0;
 207                         }
 208                 if (!EC_POINT_copy(dest->generator, src->generator)) return 0;
 209                 }
 210         else
 211                 {
 212                 /* src->generator == NULL */
 213                 if (dest->generator != NULL)
 214                         {
 215                         EC_POINT_clear_free(dest->generator);
 216                         dest->generator = NULL;
 217                         }
 218                 }
 219
 220         if (!BN_copy(&dest->order, &src->order)) return 0;
 221         if (!BN_copy(&dest->cofactor, &src->cofactor)) return 0;
 222
 223         dest->curve_name = src->curve_name;
 224         dest->asn1_flag  = src->asn1_flag;
 225         dest->asn1_form  = src->asn1_form;
 226
 227         if (src->seed)
 228                 {
 229                 if (dest->seed)
 230                         OPENSSL_free(dest->seed);
 231                 dest->seed = OPENSSL_malloc(src->seed_len);
 232                 if (dest->seed == NULL)
 233                         return 0;
 234                 if (!memcpy(dest->seed, src->seed, src->seed_len))
 235                         return 0;
 236                 dest->seed_len = src->seed_len;
 237                 }
 238         else
 239                 {
 240                 if (dest->seed)
 241                         OPENSSL_free(dest->seed);
 242                 dest->seed = NULL;
 243                 dest->seed_len = 0;
 244                 }
 245
 246
 247         return dest->meth->group_copy(dest, src);
 248         }
 249
 250
 251 EC_GROUP *EC_GROUP_dup(const EC_GROUP *a)
 252         {
 253         EC_GROUP *t = NULL;
 254         int ok = 0;
 255
 256         if (a == NULL) return NULL;
 257
 258         if ((t = EC_GROUP_new(a->meth)) == NULL) return(NULL);
 259         if (!EC_GROUP_copy(t, a)) goto err;
 260
 261         ok = 1;
 262
 263   err:
 264         if (!ok)
 265                 {
 266                 if (t) EC_GROUP_free(t);
 267                 return NULL;
 268                 }
 269         else return t;
 270         }
 271
 272
 273 const EC_METHOD *EC_GROUP_method_of(const EC_GROUP *group)
 274         {
 275         return group->meth;
 276         }
 277
 278
 279 int EC_METHOD_get_field_type(const EC_METHOD *meth)
 280         {
 281         return meth->field_type;
 282         }
 283
 284
 285 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
 286         {
 287         if (generator == NULL)
 288                 {
 289                 ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_PASSED_NULL_PARAMETER);
 290                 return 0   ;
 291                 }
 292
 293         if (group->generator == NULL)
 294                 {
 295                 group->generator = EC_POINT_new(group);
 296                 if (group->generator == NULL) return 0;
 297                 }
 298         if (!EC_POINT_copy(group->generator, generator)) return 0;
 299
 300         if (order != NULL)
 301                 { if (!BN_copy(&group->order, order)) return 0; }
 302         else
 303                 { if (!BN_zero(&group->order)) return 0; }
 304
 305         if (cofactor != NULL)
 306                 { if (!BN_copy(&group->cofactor, cofactor)) return 0; }
 307         else
 308                 { if (!BN_zero(&group->cofactor)) return 0; }
 309
 310         return 1;
 311         }
 312
 313
 314 EC_POINT *EC_GROUP_get0_generator(const EC_GROUP *group)
 315         {
 316         return group->generator;
 317         }
 318
 319
 320 int EC_GROUP_get_order(const EC_GROUP *group, BIGNUM *order, BN_CTX *ctx)
 321         {
 322         if (!BN_copy(order, &group->order))
 323                 return 0;
 324
 325         return !BN_is_zero(order);
 326         }
 327
 328
 329 int EC_GROUP_get_cofactor(const EC_GROUP *group, BIGNUM *cofactor, BN_CTX *ctx)
 330         {
 331         if (!BN_copy(cofactor, &group->cofactor))
 332                 return 0;
 333
 334         return !BN_is_zero(&group->cofactor);
 335         }
 336
 337
 338 void EC_GROUP_set_nid(EC_GROUP *group, int nid)
 339         {
 340         group->curve_name = nid;
 341         }
 342
 343
 344 int EC_GROUP_get_nid(const EC_GROUP *group)
 345         {
 346         return group->curve_name;
 347         }
 348
 349
 350 void EC_GROUP_set_asn1_flag(EC_GROUP *group, int flag)
 351         {
 352         group->asn1_flag = flag;
 353         }
 354
 355
 356 int EC_GROUP_get_asn1_flag(const EC_GROUP *group)
 357         {
 358         return group->asn1_flag;
 359         }
 360
 361
 362 void EC_GROUP_set_point_conversion_form(EC_GROUP *group,
 363                                         point_conversion_form_t form)
 364         {
 365         group->asn1_form = form;
 366         }
 367
 368
 369 point_conversion_form_t EC_GROUP_get_point_conversion_form(const EC_GROUP *group)
 370         {
 371         return group->asn1_form;
 372         }
 373
 374
 375 size_t EC_GROUP_set_seed(EC_GROUP *group, const unsigned char *p, size_t len)
 376         {
 377         if (group->seed)
 378                 {
 379                 OPENSSL_free(group->seed);
 380                 group->seed = NULL;
 381                 group->seed_len = 0;
 382                 }
 383
 384         if (!len || !p)
 385                 return 1;
 386
 387         if ((group->seed = OPENSSL_malloc(len)) == NULL)
 388                 return 0;
 389         memcpy(group->seed, p, len);
 390         group->seed_len = len;
 391
 392         return len;
 393         }
 394
 395
 396 unsigned char *EC_GROUP_get0_seed(const EC_GROUP *group)
 397         {
 398         return group->seed;
 399         }
 400
 401
 402 size_t EC_GROUP_get_seed_len(const EC_GROUP *group)
 403         {
 404         return group->seed_len;
 405         }
 406
 407
 408 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
 409         {
 410         if (group->meth->group_set_curve == 0)
 411                 {
 412                 ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 413                 return 0;
 414                 }
 415         return group->meth->group_set_curve(group, p, a, b, ctx);
 416         }
 417
 418
 419 int EC_GROUP_get_curve_GFp(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
 420         {
 421         if (group->meth->group_get_curve == 0)
 422                 {
 423                 ECerr(EC_F_EC_GROUP_GET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 424                 return 0;
 425                 }
 426         return group->meth->group_get_curve(group, p, a, b, ctx);
 427         }
 428
 429
 430 int EC_GROUP_set_curve_GF2m(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
 431         {
 432         if (group->meth->group_set_curve == 0)
 433                 {
 434                 ECerr(EC_F_EC_GROUP_SET_CURVE_GF2M, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 435                 return 0;
 436                 }
 437         return group->meth->group_set_curve(group, p, a, b, ctx);
 438         }
 439
 440
 441 int EC_GROUP_get_curve_GF2m(const EC_GROUP *group, BIGNUM *p, BIGNUM *a, BIGNUM *b, BN_CTX *ctx)
 442         {
 443         if (group->meth->group_get_curve == 0)
 444                 {
 445                 ECerr(EC_F_EC_GROUP_GET_CURVE_GF2M, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 446                 return 0;
 447                 }
 448         return group->meth->group_get_curve(group, p, a, b, ctx);
 449         }
 450
 451
 452 int EC_GROUP_get_degree(const EC_GROUP *group)
 453         {
 454         if (group->meth->group_get_degree == 0)
 455                 {
 456                 ECerr(EC_F_EC_GROUP_GET_DEGREE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 457                 return 0;
 458                 }
 459         return group->meth->group_get_degree(group);
 460         }
 461
 462
 463 int EC_GROUP_check_discriminant(const EC_GROUP *group, BN_CTX *ctx)
 464         {
 465         if (group->meth->group_check_discriminant == 0)
 466                 {
 467                 ECerr(EC_F_EC_GROUP_CHECK_DISCRIMINANT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 468                 return 0;
 469                 }
 470         return group->meth->group_check_discriminant(group, ctx);
 471         }
 472
 473
 474 /* this has 'package' visibility */
 475 int EC_GROUP_set_extra_data(EC_GROUP *group, void *extra_data, void *(*extra_data_dup_func)(void *),
 476         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 477         {
 478         if ((group->extra_data != NULL)
 479                 || (group->extra_data_dup_func != 0)
 480                 || (group->extra_data_free_func != 0)
 481                 || (group->extra_data_clear_free_func != 0))
 482                 {
 483                 ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
 484                 return 0;
 485                 }
 486
 487         group->extra_data = extra_data;
 488         group->extra_data_dup_func = extra_data_dup_func;
 489         group->extra_data_free_func = extra_data_free_func;
 490         group->extra_data_clear_free_func = extra_data_clear_free_func;
 491         return 1;
 492         }
 493
 494
 495 /* this has 'package' visibility */
 496 void *EC_GROUP_get_extra_data(const EC_GROUP *group, void *(*extra_data_dup_func)(void *),
 497         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 498         {
 499         if ((group->extra_data_dup_func != extra_data_dup_func)
 500                 || (group->extra_data_free_func != extra_data_free_func)
 501                 || (group->extra_data_clear_free_func != extra_data_clear_free_func))
 502                 {
 503                 ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
 504                 return NULL;
 505                 }
 506
 507         return group->extra_data;
 508         }
 509
 510
 511 /* this has 'package' visibility */
 512 void EC_GROUP_free_extra_data(EC_GROUP *group)
 513         {
 514         if (group->extra_data_free_func)
 515                 group->extra_data_free_func(group->extra_data);
 516         group->extra_data = NULL;
 517         group->extra_data_dup_func = 0;
 518         group->extra_data_free_func = 0;
 519         group->extra_data_clear_free_func = 0;
 520         }
 521
 522
 523 /* this has 'package' visibility */
 524 void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
 525         {
 526         if (group->extra_data_clear_free_func)
 527                 group->extra_data_clear_free_func(group->extra_data);
 528         else if (group->extra_data_free_func)
 529                 group->extra_data_free_func(group->extra_data);
 530         group->extra_data = NULL;
 531         group->extra_data_dup_func = 0;
 532         group->extra_data_free_func = 0;
 533         group->extra_data_clear_free_func = 0;
 534         }
 535
 536
 537 /* functions for EC_POINT objects */
 538
 539 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 540         {
 541         EC_POINT *ret;
 542
 543         if (group == NULL)
 544                 {
 545                 ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 546                 return NULL;
 547                 }
 548         if (group->meth->point_init == 0)
 549                 {
 550                 ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 551                 return NULL;
 552                 }
 553
 554         ret = OPENSSL_malloc(sizeof *ret);
 555         if (ret == NULL)
 556                 {
 557                 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 558                 return NULL;
 559                 }
 560
 561         ret->meth = group->meth;
 562
 563         if (!ret->meth->point_init(ret))
 564                 {
 565                 OPENSSL_free(ret);
 566                 return NULL;
 567                 }
 568
 569         return ret;
 570         }
 571
 572
 573 void EC_POINT_free(EC_POINT *point)
 574         {
 575         if (!point) return;
 576
 577         if (point->meth->point_finish != 0)
 578                 point->meth->point_finish(point);
 579         OPENSSL_free(point);
 580         }
 581
 582
 583 void EC_POINT_clear_free(EC_POINT *point)
 584         {
 585         if (!point) return;
 586
 587         if (point->meth->point_clear_finish != 0)
 588                 point->meth->point_clear_finish(point);
 589         else if (point->meth != NULL && point->meth->point_finish != 0)
 590                 point->meth->point_finish(point);
 591         memset(point, 0, sizeof *point);
 592         OPENSSL_free(point);
 593         }
 594
 595
 596 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 597         {
 598         if (dest->meth->point_copy == 0)
 599                 {
 600                 ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 601                 return 0;
 602                 }
 603         if (dest->meth != src->meth)
 604                 {
 605                 ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 606                 return 0;
 607                 }
 608         if (dest == src)
 609                 return 1;
 610         return dest->meth->point_copy(dest, src);
 611         }
 612
 613
 614 EC_POINT *EC_POINT_dup(const EC_POINT *a, const EC_GROUP *group)
 615         {
 616         EC_POINT *t;
 617         int r;
 618
 619         if (a == NULL) return NULL;
 620
 621         t = EC_POINT_new(group);
 622         if (t == NULL) return(NULL);
 623         r = EC_POINT_copy(t, a);
 624         if (!r)
 625                 {
 626                 EC_POINT_free(t);
 627                 return NULL;
 628                 }
 629         else return t;
 630         }
 631
 632
 633 const EC_METHOD *EC_POINT_method_of(const EC_POINT *point)
 634         {
 635         return point->meth;
 636         }
 637
 638
 639 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 640         {
 641         if (group->meth->point_set_to_infinity == 0)
 642                 {
 643                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 644                 return 0;
 645                 }
 646         if (group->meth != point->meth)
 647                 {
 648                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 649                 return 0;
 650                 }
 651         return group->meth->point_set_to_infinity(group, point);
 652         }
 653
 654
 655 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 656         const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
 657         {
 658         if (group->meth->point_set_Jprojective_coordinates == 0)
 659                 {
 660                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 661                 return 0;
 662                 }
 663         if (group->meth != point->meth)
 664                 {
 665                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 666                 return 0;
 667                 }
 668         return group->meth->point_set_Jprojective_coordinates(group, point, x, y, z, ctx);
 669         }
 670
 671
 672 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 673         BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
 674         {
 675         if (group->meth->point_get_Jprojective_coordinates == 0)
 676                 {
 677                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 678                 return 0;
 679                 }
 680         if (group->meth != point->meth)
 681                 {
 682                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 683                 return 0;
 684                 }
 685         return group->meth->point_get_Jprojective_coordinates(group, point, x, y, z, ctx);
 686         }
 687
 688
 689 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 690         const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
 691         {
 692         if (group->meth->point_set_affine_coordinates == 0)
 693                 {
 694                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 695                 return 0;
 696                 }
 697         if (group->meth != point->meth)
 698                 {
 699                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 700                 return 0;
 701                 }
 702         return group->meth->point_set_affine_coordinates(group, point, x, y, ctx);
 703         }
 704
 705
 706 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 707         BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
 708         {
 709         if (group->meth->point_get_affine_coordinates == 0)
 710                 {
 711                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 712                 return 0;
 713                 }
 714         if (group->meth != point->meth)
 715                 {
 716                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 717                 return 0;
 718                 }
 719         return group->meth->point_get_affine_coordinates(group, point, x, y, ctx);
 720         }
 721
 722
 723 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 724         const BIGNUM *x, int y_bit, BN_CTX *ctx)
 725         {
 726         if (group->meth->point_set_compressed_coordinates == 0)
 727                 {
 728                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 729                 return 0;
 730                 }
 731         if (group->meth != point->meth)
 732                 {
 733                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 734                 return 0;
 735                 }
 736         return group->meth->point_set_compressed_coordinates(group, point, x, y_bit, ctx);
 737         }
 738
 739
 740 int EC_POINT_set_Jprojective_coordinates_GF2m(const EC_GROUP *group, EC_POINT *point,
 741         const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
 742         {
 743         if (group->meth->point_set_Jprojective_coordinates == 0)
 744                 {
 745                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GF2M, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 746                 return 0;
 747                 }
 748         if (group->meth != point->meth)
 749                 {
 750                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GF2M, EC_R_INCOMPATIBLE_OBJECTS);
 751                 return 0;
 752                 }
 753         return group->meth->point_set_Jprojective_coordinates(group, point, x, y, z, ctx);
 754         }
 755
 756
 757 int EC_POINT_get_Jprojective_coordinates_GF2m(const EC_GROUP *group, const EC_POINT *point,
 758         BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
 759         {
 760         if (group->meth->point_get_Jprojective_coordinates == 0)
 761                 {
 762                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GF2M, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 763                 return 0;
 764                 }
 765         if (group->meth != point->meth)
 766                 {
 767                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GF2M, EC_R_INCOMPATIBLE_OBJECTS);
 768                 return 0;
 769                 }
 770         return group->meth->point_get_Jprojective_coordinates(group, point, x, y, z, ctx);
 771         }
 772
 773
 774 int EC_POINT_set_affine_coordinates_GF2m(const EC_GROUP *group, EC_POINT *point,
 775         const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
 776         {
 777         if (group->meth->point_set_affine_coordinates == 0)
 778                 {
 779                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 780                 return 0;
 781                 }
 782         if (group->meth != point->meth)
 783                 {
 784                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GF2M, EC_R_INCOMPATIBLE_OBJECTS);
 785                 return 0;
 786                 }
 787         return group->meth->point_set_affine_coordinates(group, point, x, y, ctx);
 788         }
 789
 790
 791 int EC_POINT_get_affine_coordinates_GF2m(const EC_GROUP *group, const EC_POINT *point,
 792         BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
 793         {
 794         if (group->meth->point_get_affine_coordinates == 0)
 795                 {
 796                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 797                 return 0;
 798                 }
 799         if (group->meth != point->meth)
 800                 {
 801                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GF2M, EC_R_INCOMPATIBLE_OBJECTS);
 802                 return 0;
 803                 }
 804         return group->meth->point_get_affine_coordinates(group, point, x, y, ctx);
 805         }
 806
 807
 808 int EC_POINT_set_compressed_coordinates_GF2m(const EC_GROUP *group, EC_POINT *point,
 809         const BIGNUM *x, int y_bit, BN_CTX *ctx)
 810         {
 811         if (group->meth->point_set_compressed_coordinates == 0)
 812                 {
 813                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 814                 return 0;
 815                 }
 816         if (group->meth != point->meth)
 817                 {
 818                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M, EC_R_INCOMPATIBLE_OBJECTS);
 819                 return 0;
 820                 }
 821         return group->meth->point_set_compressed_coordinates(group, point, x, y_bit, ctx);
 822         }
 823
 824
 825 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
 826         unsigned char *buf, size_t len, BN_CTX *ctx)
 827         {
 828         if (group->meth->point2oct == 0)
 829                 {
 830                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 831                 return 0;
 832                 }
 833         if (group->meth != point->meth)
 834                 {
 835                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
 836                 return 0;
 837                 }
 838         return group->meth->point2oct(group, point, form, buf, len, ctx);
 839         }
 840
 841
 842 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 843         const unsigned char *buf, size_t len, BN_CTX *ctx)
 844         {
 845         if (group->meth->oct2point == 0)
 846                 {
 847                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 848                 return 0;
 849                 }
 850         if (group->meth != point->meth)
 851                 {
 852                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
 853                 return 0;
 854                 }
 855         return group->meth->oct2point(group, point, buf, len, ctx);
 856         }
 857
 858
 859 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 860         {
 861         if (group->meth->add == 0)
 862                 {
 863                 ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 864                 return 0;
 865                 }
 866         if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
 867                 {
 868                 ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 869                 return 0;
 870                 }
 871         return group->meth->add(group, r, a, b, ctx);
 872         }
 873
 874
 875 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
 876         {
 877         if (group->meth->dbl == 0)
 878                 {
 879                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 880                 return 0;
 881                 }
 882         if ((group->meth != r->meth) || (r->meth != a->meth))
 883                 {
 884                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 885                 return 0;
 886                 }
 887         return group->meth->dbl(group, r, a, ctx);
 888         }
 889
 890
 891 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
 892         {
 893         if (group->meth->dbl == 0)
 894                 {
 895                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 896                 return 0;
 897                 }
 898         if (group->meth != a->meth)
 899                 {
 900                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 901                 return 0;
 902                 }
 903         return group->meth->invert(group, a, ctx);
 904         }
 905
 906
 907 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 908         {
 909         if (group->meth->is_at_infinity == 0)
 910                 {
 911                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 912                 return 0;
 913                 }
 914         if (group->meth != point->meth)
 915                 {
 916                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 917                 return 0;
 918                 }
 919         return group->meth->is_at_infinity(group, point);
 920         }
 921
 922
 923 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
 924         {
 925         if (group->meth->is_on_curve == 0)
 926                 {
 927                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 928                 return 0;
 929                 }
 930         if (group->meth != point->meth)
 931                 {
 932                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
 933                 return 0;
 934                 }
 935         return group->meth->is_on_curve(group, point, ctx);
 936         }
 937
 938
 939 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 940         {
 941         if (group->meth->point_cmp == 0)
 942                 {
 943                 ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 944                 return 0;
 945                 }
 946         if ((group->meth != a->meth) || (a->meth != b->meth))
 947                 {
 948                 ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
 949                 return 0;
 950                 }
 951         return group->meth->point_cmp(group, a, b, ctx);
 952         }
 953
 954
 955 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
 956         {
 957         if (group->meth->make_affine == 0)
 958                 {
 959                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 960                 return 0;
 961                 }
 962         if (group->meth != point->meth)
 963                 {
 964                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 965                 return 0;
 966                 }
 967         return group->meth->make_affine(group, point, ctx);
 968         }
 969
 970
 971 int EC_POINTs_make_affine(const EC_GROUP *group, size_t num, EC_POINT *points[], BN_CTX *ctx)
 972         {
 973         size_t i;
 974
 975         if (group->meth->points_make_affine == 0)
 976                 {
 977                 ECerr(EC_F_EC_POINTS_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 978                 return 0;
 979                 }
 980         for (i = 0; i < num; i++)
 981                 {
 982                 if (group->meth != points[i]->meth)
 983                         {
 984                         ECerr(EC_F_EC_POINTS_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 985                         return 0;
 986                         }
 987                 }
 988         return group->meth->points_make_affine(group, num, points, ctx);
 989         }