crypto/ec/ec_lib.c

   1 /* crypto/ec/ec_lib.c */
   2 /* ====================================================================
   3  * Copyright (c) 1998-2001 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
  60 #include "ec_lcl.h"
  61
  62
  63 /* functions for EC_GROUP objects */
  64
  65 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
  66         {
  67         EC_GROUP *ret;
  68
  69         if (meth == NULL)
  70                 {
  71                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
  72                 return NULL;
  73                 }
  74         if (meth->group_init == 0)
  75                 {
  76                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  77                 return NULL;
  78                 }
  79
  80         ret = OPENSSL_malloc(sizeof *ret);
  81         if (ret == NULL)
  82                 {
  83                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
  84                 return NULL;
  85                 }
  86
  87         ret->meth = meth;
  88
  89         ret->extra_data = NULL;
  90         ret->extra_data_dup_func = 0;
  91         ret->extra_data_free_func = 0;
  92         ret->extra_data_clear_free_func = 0;
  93
  94         if (!meth->group_init(ret))
  95                 {
  96                 OPENSSL_free(ret);
  97                 return NULL;
  98                 }
  99
 100         return ret;
 101         }
 102
 103
 104 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
 105         {
 106         if (group->meth->group_set_curve_GFp == 0)
 107                 {
 108                 ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 109                 return 0;
 110                 }
 111         return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
 112         }
 113
 114
 115 void EC_GROUP_free(EC_GROUP *group)
 116         {
 117         if (group->meth->group_finish != 0)
 118                 group->meth->group_finish(group);
 119
 120         EC_GROUP_free_extra_data(group);
 121
 122         OPENSSL_free(group);
 123         }
 124
 125
 126 void EC_GROUP_clear_free(EC_GROUP *group)
 127         {
 128         if (group->meth->group_clear_finish != 0)
 129                 group->meth->group_clear_finish(group);
 130         else if (group->meth != NULL && group->meth->group_finish != 0)
 131                 group->meth->group_finish(group);
 132
 133         EC_GROUP_clear_free_extra_data(group);
 134
 135         memset(group, 0, sizeof *group);
 136         OPENSSL_free(group);
 137         }
 138
 139
 140 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 141         {
 142         if (dest->meth->group_copy == 0)
 143                 {
 144                 ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 145                 return 0;
 146                 }
 147         if (dest->meth != src->meth)
 148                 {
 149                 ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 150                 return 0;
 151                 }
 152         if (dest == src)
 153                 return 1;
 154
 155         EC_GROUP_clear_free_extra_data(dest);
 156         if (src->extra_data_dup_func)
 157                 {
 158                 if (src->extra_data != NULL)
 159                         {
 160                         dest->extra_data = src->extra_data_dup_func(src->extra_data);
 161                         if (dest->extra_data == NULL)
 162                                 return 0;
 163                         }
 164
 165                 dest->extra_data_dup_func = src->extra_data_dup_func;
 166                 dest->extra_data_free_func = src->extra_data_free_func;
 167                 dest->extra_data_clear_free_func = src->extra_data_clear_free_func;
 168                 }
 169
 170         return dest->meth->group_copy(dest, src);
 171         }
 172
 173
 174 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
 175         {
 176         if (group->meth->group_set_generator == 0)
 177                 {
 178                 ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 179                 return 0;
 180                 }
 181         return group->meth->group_set_generator(group, generator, order, cofactor);
 182         }
 183
 184
 185 /* TODO: 'set' and 'get' functions for EC_GROUPs */
 186
 187
 188 /* this has 'package' visibility */
 189 int EC_GROUP_set_extra_data(EC_GROUP *group, void *extra_data, void *(*extra_data_dup_func)(void *),
 190         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 191         {
 192         if ((group->extra_data != NULL)
 193                 || (group->extra_data_dup_func != 0)
 194                 || (group->extra_data_free_func != 0)
 195                 || (group->extra_data_clear_free_func != 0))
 196                 {
 197                 ECerr(EC_F_EC_GROUP_SET_EXTRA_DATA, EC_R_SLOT_FULL);
 198                 return 0;
 199                 }
 200
 201         group->extra_data = extra_data;
 202         group->extra_data_dup_func = extra_data_dup_func;
 203         group->extra_data_free_func = extra_data_free_func;
 204         group->extra_data_clear_free_func = extra_data_clear_free_func;
 205         return 1;
 206         }
 207
 208
 209 /* this has 'package' visibility */
 210 void *EC_GROUP_get_extra_data(EC_GROUP *group, void *(*extra_data_dup_func)(void *),
 211         void (*extra_data_free_func)(void *), void (*extra_data_clear_free_func)(void *))
 212         {
 213         if ((group->extra_data_dup_func != extra_data_dup_func)
 214                 || (group->extra_data_free_func != extra_data_free_func)
 215                 || (group->extra_data_clear_free_func != extra_data_clear_free_func))
 216                 {
 217                 ECerr(EC_F_EC_GROUP_GET_EXTRA_DATA, EC_R_NO_SUCH_EXTRA_DATA);
 218                 return NULL;
 219                 }
 220
 221         return group->extra_data;
 222         }
 223
 224
 225 /* this has 'package' visibility */
 226 void EC_GROUP_free_extra_data(EC_GROUP *group)
 227         {
 228         if (group->extra_data_free_func)
 229                 group->extra_data_free_func(group->extra_data);
 230         group->extra_data = NULL;
 231         group->extra_data_dup_func = 0;
 232         group->extra_data_free_func = 0;
 233         group->extra_data_clear_free_func = 0;
 234         }
 235
 236
 237 /* this has 'package' visibility */
 238 void EC_GROUP_clear_free_extra_data(EC_GROUP *group)
 239         {
 240         if (group->extra_data_clear_free_func)
 241                 group->extra_data_clear_free_func(group->extra_data);
 242         else if (group->extra_data_free_func)
 243                 group->extra_data_free_func(group->extra_data);
 244         group->extra_data = NULL;
 245         group->extra_data_dup_func = 0;
 246         group->extra_data_free_func = 0;
 247         group->extra_data_clear_free_func = 0;
 248         }
 249
 250
 251
 252 /* functions for EC_POINT objects */
 253
 254 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 255         {
 256         EC_POINT *ret;
 257
 258         if (group == NULL)
 259                 {
 260                 ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 261                 return NULL;
 262                 }
 263         if (group->meth->point_init == 0)
 264                 {
 265                 ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 266                 return NULL;
 267                 }
 268
 269         ret = OPENSSL_malloc(sizeof *ret);
 270         if (ret == NULL)
 271                 {
 272                 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 273                 return NULL;
 274                 }
 275
 276         ret->meth = group->meth;
 277
 278         if (!ret->meth->point_init(ret))
 279                 {
 280                 OPENSSL_free(ret);
 281                 return NULL;
 282                 }
 283
 284         return ret;
 285         }
 286
 287
 288 void EC_POINT_free(EC_POINT *point)
 289         {
 290         if (point->meth->point_finish != 0)
 291                 point->meth->point_finish(point);
 292         OPENSSL_free(point);
 293         }
 294
 295
 296 void EC_POINT_clear_free(EC_POINT *point)
 297         {
 298         if (point->meth->point_clear_finish != 0)
 299                 point->meth->point_clear_finish(point);
 300         else if (point->meth != NULL && point->meth->point_finish != 0)
 301                 point->meth->point_finish(point);
 302         memset(point, 0, sizeof *point);
 303         OPENSSL_free(point);
 304         }
 305
 306
 307 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 308         {
 309         if (dest->meth->point_copy == 0)
 310                 {
 311                 ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 312                 return 0;
 313                 }
 314         if (dest->meth != src->meth)
 315                 {
 316                 ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 317                 return 0;
 318                 }
 319         if (dest == src)
 320                 return 1;
 321         return dest->meth->point_copy(dest, src);
 322         }
 323
 324
 325 int EC_POINT_set_to_infinity(const EC_GROUP *group, EC_POINT *point)
 326         {
 327         if (group->meth->point_set_to_infinity == 0)
 328                 {
 329                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 330                 return 0;
 331                 }
 332         if (group->meth != point->meth)
 333                 {
 334                 ECerr(EC_F_EC_POINT_SET_TO_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 335                 return 0;
 336                 }
 337         return group->meth->point_set_to_infinity(group, point);
 338         }
 339
 340
 341 int EC_POINT_set_Jprojective_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 342         const BIGNUM *x, const BIGNUM *y, const BIGNUM *z, BN_CTX *ctx)
 343         {
 344         if (group->meth->point_set_Jprojective_coordinates_GFp == 0)
 345                 {
 346                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 347                 return 0;
 348                 }
 349         if (group->meth != point->meth)
 350                 {
 351                 ECerr(EC_F_EC_POINT_SET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 352                 return 0;
 353                 }
 354         return group->meth->point_set_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 355         }
 356
 357
 358 int EC_POINT_get_Jprojective_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 359         BIGNUM *x, BIGNUM *y, BIGNUM *z, BN_CTX *ctx)
 360         {
 361         if (group->meth->point_get_Jprojective_coordinates_GFp == 0)
 362                 {
 363                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 364                 return 0;
 365                 }
 366         if (group->meth != point->meth)
 367                 {
 368                 ECerr(EC_F_EC_POINT_GET_JPROJECTIVE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 369                 return 0;
 370                 }
 371         return group->meth->point_get_Jprojective_coordinates_GFp(group, point, x, y, z, ctx);
 372         }
 373
 374
 375 int EC_POINT_set_affine_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 376         const BIGNUM *x, const BIGNUM *y, BN_CTX *ctx)
 377         {
 378         if (group->meth->point_set_affine_coordinates_GFp == 0)
 379                 {
 380                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 381                 return 0;
 382                 }
 383         if (group->meth != point->meth)
 384                 {
 385                 ECerr(EC_F_EC_POINT_SET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 386                 return 0;
 387                 }
 388         return group->meth->point_set_affine_coordinates_GFp(group, point, x, y, ctx);
 389         }
 390
 391
 392 int EC_POINT_get_affine_coordinates_GFp(const EC_GROUP *group, const EC_POINT *point,
 393         BIGNUM *x, BIGNUM *y, BN_CTX *ctx)
 394         {
 395         if (group->meth->point_get_affine_coordinates_GFp == 0)
 396                 {
 397                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 398                 return 0;
 399                 }
 400         if (group->meth != point->meth)
 401                 {
 402                 ECerr(EC_F_EC_POINT_GET_AFFINE_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 403                 return 0;
 404                 }
 405         return group->meth->point_get_affine_coordinates_GFp(group, point, x, y, ctx);
 406         }
 407
 408
 409 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
 410         const BIGNUM *x, int y_bit, BN_CTX *ctx)
 411         {
 412         if (group->meth->point_set_compressed_coordinates_GFp == 0)
 413                 {
 414                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 415                 return 0;
 416                 }
 417         if (group->meth != point->meth)
 418                 {
 419                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
 420                 return 0;
 421                 }
 422         return group->meth->point_set_compressed_coordinates_GFp(group, point, x, y_bit, ctx);
 423         }
 424
 425
 426 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
 427         unsigned char *buf, size_t len, BN_CTX *ctx)
 428         {
 429         if (group->meth->point2oct == 0)
 430                 {
 431                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 432                 return 0;
 433                 }
 434         if (group->meth != point->meth)
 435                 {
 436                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
 437                 return 0;
 438                 }
 439         return group->meth->point2oct(group, point, form, buf, len, ctx);
 440         }
 441
 442
 443 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 444         const unsigned char *buf, size_t len, BN_CTX *ctx)
 445         {
 446         if (group->meth->oct2point == 0)
 447                 {
 448                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 449                 return 0;
 450                 }
 451         if (group->meth != point->meth)
 452                 {
 453                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
 454                 return 0;
 455                 }
 456         return group->meth->oct2point(group, point, buf, len, ctx);
 457         }
 458
 459
 460 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 461         {
 462         if (group->meth->add == 0)
 463                 {
 464                 ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 465                 return 0;
 466                 }
 467         if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
 468                 {
 469                 ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 470                 return 0;
 471                 }
 472         return group->meth->add(group, r, a, b, ctx);
 473         }
 474
 475
 476 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
 477         {
 478         if (group->meth->dbl == 0)
 479                 {
 480                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 481                 return 0;
 482                 }
 483         if ((group->meth != r->meth) || (r->meth != a->meth))
 484                 {
 485                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 486                 return 0;
 487                 }
 488         return group->meth->dbl(group, r, a, ctx);
 489         }
 490
 491
 492 int EC_POINT_invert(const EC_GROUP *group, EC_POINT *a, BN_CTX *ctx)
 493         {
 494         if (group->meth->dbl == 0)
 495                 {
 496                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 497                 return 0;
 498                 }
 499         if (group->meth != a->meth)
 500                 {
 501                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 502                 return 0;
 503                 }
 504         return group->meth->invert(group, a, ctx);
 505         }
 506
 507
 508 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 509         {
 510         if (group->meth->is_at_infinity == 0)
 511                 {
 512                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 513                 return 0;
 514                 }
 515         if (group->meth != point->meth)
 516                 {
 517                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 518                 return 0;
 519                 }
 520         return group->meth->is_at_infinity(group, point);
 521         }
 522
 523
 524 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
 525         {
 526         if (group->meth->is_on_curve == 0)
 527                 {
 528                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 529                 return 0;
 530                 }
 531         if (group->meth != point->meth)
 532                 {
 533                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
 534                 return 0;
 535                 }
 536         return group->meth->is_on_curve(group, point, ctx);
 537         }
 538
 539
 540 int EC_POINT_cmp(const EC_GROUP *group, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 541         {
 542         if (group->meth->point_cmp == 0)
 543                 {
 544                 ECerr(EC_F_EC_POINT_CMP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 545                 return 0;
 546                 }
 547         if ((group->meth != a->meth) || (a->meth != b->meth))
 548                 {
 549                 ECerr(EC_F_EC_POINT_CMP, EC_R_INCOMPATIBLE_OBJECTS);
 550                 return 0;
 551                 }
 552         return group->meth->point_cmp(group, a, b, ctx);
 553         }
 554
 555
 556 int EC_POINT_make_affine(const EC_GROUP *group, EC_POINT *point, BN_CTX *ctx)
 557         {
 558         if (group->meth->make_affine == 0)
 559                 {
 560                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 561                 return 0;
 562                 }
 563         if (group->meth != point->meth)
 564                 {
 565                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 566                 return 0;
 567                 }
 568         return group->meth->make_affine(group, point, ctx);
 569         }