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 <openssl/err.h>
  57
  58 #include "ec_lcl.h"
  59
  60
  61 /* functions for EC_GROUP objects */
  62
  63 EC_GROUP *EC_GROUP_new(const EC_METHOD *meth)
  64         {
  65         EC_GROUP *ret;
  66
  67         if (meth == NULL)
  68                 {
  69                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_PASSED_NULL_PARAMETER);
  70                 return NULL;
  71                 }
  72         if (meth->group_init == 0)
  73                 {
  74                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  75                 return NULL;
  76                 }
  77
  78         ret = OPENSSL_malloc(sizeof *ret);
  79         if (ret == NULL)
  80                 {
  81                 ECerr(EC_F_EC_GROUP_NEW, ERR_R_MALLOC_FAILURE);
  82                 return NULL;
  83                 }
  84
  85         ret->meth = meth;
  86
  87         if (!meth->group_init(ret))
  88                 {
  89                 OPENSSL_free(ret);
  90                 return NULL;
  91                 }
  92
  93         return ret;
  94         }
  95
  96
  97 int EC_GROUP_set_curve_GFp(EC_GROUP *group, const BIGNUM *p, const BIGNUM *a, const BIGNUM *b, BN_CTX *ctx)
  98         {
  99         if (group->meth->group_set_curve_GFp == 0)
 100                 {
 101                 ECerr(EC_F_EC_GROUP_SET_CURVE_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 102                 return 0;
 103                 }
 104
 105         return group->meth->group_set_curve_GFp(group, p, a, b, ctx);
 106         }
 107
 108
 109 void EC_GROUP_free(EC_GROUP *group)
 110         {
 111         if (group->meth->group_finish != 0)
 112                 group->meth->group_finish(group);
 113         OPENSSL_free(group);
 114         }
 115
 116
 117 void EC_GROUP_clear_free(EC_GROUP *group)
 118         {
 119         if (group->meth->group_clear_finish != 0)
 120                 group->meth->group_clear_finish(group);
 121         else if (group->meth != NULL && group->meth->group_finish != 0)
 122                 group->meth->group_finish(group);
 123         memset(point, 0, sizeof *group);
 124         OPENSSL_free(group);
 125         }
 126
 127
 128 int EC_GROUP_copy(EC_GROUP *dest, const EC_GROUP *src)
 129         {
 130         if (dest->meth->group_copy == 0)
 131                 {
 132                 ECerr(EC_F_EC_GROUP_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 133                 return 0;
 134                 }
 135         if (dest->meth != src->meth)
 136                 {
 137                 ECerr(EC_F_EC_GROUP_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 138                 return 0;
 139                 }
 140
 141         return dest->meth->group_copy(dest, src);
 142         }
 143
 144
 145 int EC_GROUP_set_generator(EC_GROUP *group, const EC_POINT *generator, const BIGNUM *order, const BIGNUM *cofactor)
 146         {
 147         if (group->meth->group_set_generator == 0)
 148                 {
 149                 ECerr(EC_F_EC_GROUP_SET_GENERATOR, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 150                 return 0;
 151                 }
 152         return group->meth->group_set_generator(group, generator, order, cofactor);
 153         }
 154
 155
 156 /* TODO: 'get' functions for EC_GROUPs */
 157
 158
 159
 160 /* functions for EC_POINT objects */
 161
 162 EC_POINT *EC_POINT_new(const EC_GROUP *group)
 163         {
 164         EC_POINT *ret;
 165
 166         if (group == NULL)
 167                 {
 168                 ECerr(EC_F_EC_POINT_NEW, ERR_R_PASSED_NULL_PARAMETER);
 169                 return NULL;
 170                 }
 171         if (group->meth->point_init == 0)
 172                 {
 173                 ECerr(EC_F_EC_POINT_NEW, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 174                 return NULL;
 175                 }
 176
 177         ret = OPENSSL_malloc(sizeof *ret);
 178         if (ret == NULL)
 179                 {
 180                 ECerr(EC_F_EC_POINT_NEW, ERR_R_MALLOC_FAILURE);
 181                 return NULL;
 182                 }
 183
 184         ret->meth = group->meth;
 185
 186         if (!ret->meth->point_init(ret))
 187                 {
 188                 OPENSSL_free(ret);
 189                 return NULL;
 190                 }
 191
 192         return ret;
 193         }
 194
 195
 196 void EC_POINT_free(EC_POINT *point)
 197         {
 198         if (point->meth->point_finish != 0)
 199                 point->meth->point_finish(point);
 200         OPENSSL_free(point);
 201         }
 202
 203
 204 void EC_POINT_clear_free(EC_POINT *point)
 205         {
 206         if (point->meth->point_clear_finish != 0)
 207                 point->meth->point_clear_finish(point);
 208         else if (point->meth != NULL && point->meth->point_finish != 0)
 209                 point->meth->point_finish(point);
 210         memset(point, 0, sizeof *point);
 211         OPENSSL_free(point);
 212         }
 213
 214
 215 int EC_POINT_copy(EC_POINT *dest, const EC_POINT *src)
 216         {
 217         if (dest->meth->point_copy == 0)
 218                 {
 219                 ECerr(EC_F_EC_POINT_COPY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 220                 return 0;
 221                 }
 222         if (dest->meth != src->meth)
 223                 {
 224                 ECerr(EC_F_EC_POINT_COPY, EC_R_INCOMPATIBLE_OBJECTS);
 225                 return 0;
 226                 }
 227
 228         return dest->meth->point_copy(dest, src);
 229         }
 230
 231
 232 /* TODO: 'set' and 'get' functions for EC_POINTs */
 233
 234
 235 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
 236         unsigned char *buf, size_t len, BN_CTX *ctx)
 237         {
 238         if (group->meth->point2oct == 0)
 239                 {
 240                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 241                 return 0;
 242                 }
 243         if (group->meth != point->meth)
 244                 {
 245                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
 246                 return 0;
 247                 }
 248         return group->meth->point2oct(group, point, form, buf, len, ctx);
 249         }
 250
 251
 252 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 253         const unsigned char *buf, size_t len, BN_CTX *ctx)
 254         {
 255         if (group->meth->oct2point == 0)
 256                 {
 257                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 258                 return 0;
 259                 }
 260         if (group->meth != point->meth)
 261                 {
 262                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
 263                 return 0;
 264                 }
 265         return group->meth->oct2point(group, point, buf, len, ctx);
 266         }
 267
 268
 269 int EC_POINT_add(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, const EC_POINT *b, BN_CTX *ctx)
 270         {
 271         if (group->meth->add == 0)
 272                 {
 273                 ECerr(EC_F_EC_POINT_ADD, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 274                 return 0;
 275                 }
 276         if ((group->meth != r->meth) || (r->meth != a->meth) || (a->meth != b->meth))
 277                 {
 278                 ECerr(EC_F_EC_POINT_ADD, EC_R_INCOMPATIBLE_OBJECTS);
 279                 return 0;
 280                 }
 281         return group->meth->add(group, r, a, b, ctx);
 282         }
 283
 284
 285 int EC_POINT_dbl(const EC_GROUP *group, EC_POINT *r, const EC_POINT *a, BN_CTX *ctx)
 286         {
 287         if (group->meth->dbl == 0)
 288                 {
 289                 ECerr(EC_F_EC_POINT_DBL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 290                 return 0;
 291                 }
 292         if ((group->meth != r->meth) || (r->meth != a->meth))
 293                 {
 294                 ECerr(EC_F_EC_POINT_DBL, EC_R_INCOMPATIBLE_OBJECTS);
 295                 return 0;
 296                 }
 297         return group->meth->dbl(group, r, a, ctx);
 298         }
 299
 300
 301 int EC_POINT_is_at_infinity(const EC_GROUP *group, const EC_POINT *point)
 302         {
 303         if (group->meth->is_at_infinity == 0)
 304                 {
 305                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 306                 return 0;
 307                 }
 308         if (group->meth != point->meth)
 309                 {
 310                 ECerr(EC_F_EC_POINT_IS_AT_INFINITY, EC_R_INCOMPATIBLE_OBJECTS);
 311                 return 0;
 312                 }
 313         return group->meth->is_at_infinity(group, point);
 314         }
 315
 316
 317 int EC_POINT_is_on_curve(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
 318         {
 319         if (group->meth->is_on_curve == 0)
 320                 {
 321                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 322                 return 0;
 323                 }
 324         if (group->meth != point->meth)
 325                 {
 326                 ECerr(EC_F_EC_POINT_IS_ON_CURVE, EC_R_INCOMPATIBLE_OBJECTS);
 327                 return 0;
 328                 }
 329         return group->meth->is_on_curve(group, point, ctx);
 330         }
 331
 332
 333 int EC_POINT_make_affine(const EC_GROUP *group, const EC_POINT *point, BN_CTX *ctx)
 334         {
 335         if (group->meth->make_affine == 0)
 336                 {
 337                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 338                 return 0;
 339                 }
 340         if (group->meth != point->meth)
 341                 {
 342                 ECerr(EC_F_EC_POINT_MAKE_AFFINE, EC_R_INCOMPATIBLE_OBJECTS);
 343                 return 0;
 344                 }
 345         return group->meth->make_affine(group, point, ctx);
 346         }