crypto/ec/ec_oct.c

   1 /* crypto/ec/ec_lib.c */
   2 /*
   3  * Originally written by Bodo Moeller for the OpenSSL project.
   4  */
   5 /* ====================================================================
   6  * Copyright (c) 1998-2003 The OpenSSL Project.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  *
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in
  17  *    the documentation and/or other materials provided with the
  18  *    distribution.
  19  *
  20  * 3. All advertising materials mentioning features or use of this
  21  *    software must display the following acknowledgment:
  22  *    "This product includes software developed by the OpenSSL Project
  23  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  24  *
  25  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26  *    endorse or promote products derived from this software without
  27  *    prior written permission. For written permission, please contact
  28  *    openssl-core@openssl.org.
  29  *
  30  * 5. Products derived from this software may not be called "OpenSSL"
  31  *    nor may "OpenSSL" appear in their names without prior written
  32  *    permission of the OpenSSL Project.
  33  *
  34  * 6. Redistributions of any form whatsoever must retain the following
  35  *    acknowledgment:
  36  *    "This product includes software developed by the OpenSSL Project
  37  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  38  *
  39  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51  * ====================================================================
  52  *
  53  * This product includes cryptographic software written by Eric Young
  54  * (eay@cryptsoft.com).  This product includes software written by Tim
  55  * Hudson (tjh@cryptsoft.com).
  56  *
  57  */
  58 /* ====================================================================
  59  * Copyright 2002 Sun Microsystems, Inc. ALL RIGHTS RESERVED.
  60  * Binary polynomial ECC support in OpenSSL originally developed by
  61  * SUN MICROSYSTEMS, INC., and contributed to the OpenSSL project.
  62  */
  63
  64 #include <string.h>
  65
  66 #include <openssl/err.h>
  67 #include <openssl/opensslv.h>
  68
  69 #include "ec_lcl.h"
  70
  71 int EC_POINT_set_compressed_coordinates_GFp(const EC_GROUP *group, EC_POINT *point,
  72         const BIGNUM *x, int y_bit, BN_CTX *ctx)
  73         {
  74         if (group->meth->point_set_compressed_coordinates == 0
  75                 && !(group->meth->flags & EC_FLAGS_DEFAULT_OCT))
  76                 {
  77                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  78                 return 0;
  79                 }
  80         if (group->meth != point->meth)
  81                 {
  82                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_INCOMPATIBLE_OBJECTS);
  83                 return 0;
  84                 }
  85         if(group->meth->flags & EC_FLAGS_DEFAULT_OCT)
  86                 {
  87                 if (group->meth->field_type == NID_X9_62_prime_field)
  88                         return ec_GFp_simple_set_compressed_coordinates(
  89                                         group, point, x, y_bit, ctx);
  90                 else
  91 #ifdef OPENSSL_NO_EC2M
  92                         {
  93                         ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GFP, EC_R_GF2M_NOT_SUPPORTED);
  94                         return 0;
  95                         }
  96 #else
  97                         return ec_GF2m_simple_set_compressed_coordinates(
  98                                         group, point, x, y_bit, ctx);
  99 #endif
 100                 }
 101         return group->meth->point_set_compressed_coordinates(group, point, x, y_bit, ctx);
 102         }
 103
 104 #ifndef OPENSSL_NO_EC2M
 105 int EC_POINT_set_compressed_coordinates_GF2m(const EC_GROUP *group, EC_POINT *point,
 106         const BIGNUM *x, int y_bit, BN_CTX *ctx)
 107         {
 108         if (group->meth->point_set_compressed_coordinates == 0
 109                 && !(group->meth->flags & EC_FLAGS_DEFAULT_OCT))
 110                 {
 111                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 112                 return 0;
 113                 }
 114         if (group->meth != point->meth)
 115                 {
 116                 ECerr(EC_F_EC_POINT_SET_COMPRESSED_COORDINATES_GF2M, EC_R_INCOMPATIBLE_OBJECTS);
 117                 return 0;
 118                 }
 119         if(group->meth->flags & EC_FLAGS_DEFAULT_OCT)
 120                 {
 121                 if (group->meth->field_type == NID_X9_62_prime_field)
 122                         return ec_GFp_simple_set_compressed_coordinates(
 123                                         group, point, x, y_bit, ctx);
 124                 else
 125                         return ec_GF2m_simple_set_compressed_coordinates(
 126                                         group, point, x, y_bit, ctx);
 127                 }
 128         return group->meth->point_set_compressed_coordinates(group, point, x, y_bit, ctx);
 129         }
 130 #endif
 131
 132 size_t EC_POINT_point2oct(const EC_GROUP *group, const EC_POINT *point, point_conversion_form_t form,
 133         unsigned char *buf, size_t len, BN_CTX *ctx)
 134         {
 135         if (group->meth->point2oct == 0
 136                 && !(group->meth->flags & EC_FLAGS_DEFAULT_OCT))
 137                 {
 138                 ECerr(EC_F_EC_POINT_POINT2OCT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 139                 return 0;
 140                 }
 141         if (group->meth != point->meth)
 142                 {
 143                 ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_INCOMPATIBLE_OBJECTS);
 144                 return 0;
 145                 }
 146         if(group->meth->flags & EC_FLAGS_DEFAULT_OCT)
 147                 {
 148                 if (group->meth->field_type == NID_X9_62_prime_field)
 149                         return ec_GFp_simple_point2oct(group, point,
 150                                                         form, buf, len, ctx);
 151                 else
 152 #ifdef OPENSSL_NO_EC2M
 153                         {
 154                         ECerr(EC_F_EC_POINT_POINT2OCT, EC_R_GF2M_NOT_SUPPORTED);
 155                         return 0;
 156                         }
 157 #else
 158                         return ec_GF2m_simple_point2oct(group, point,
 159                                                         form, buf, len, ctx);
 160 #endif
 161                 }
 162
 163         return group->meth->point2oct(group, point, form, buf, len, ctx);
 164         }
 165
 166
 167 int EC_POINT_oct2point(const EC_GROUP *group, EC_POINT *point,
 168         const unsigned char *buf, size_t len, BN_CTX *ctx)
 169         {
 170         if (group->meth->oct2point == 0
 171                 && !(group->meth->flags & EC_FLAGS_DEFAULT_OCT))
 172                 {
 173                 ECerr(EC_F_EC_POINT_OCT2POINT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 174                 return 0;
 175                 }
 176         if (group->meth != point->meth)
 177                 {
 178                 ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_INCOMPATIBLE_OBJECTS);
 179                 return 0;
 180                 }
 181         if(group->meth->flags & EC_FLAGS_DEFAULT_OCT)
 182                 {
 183                 if (group->meth->field_type == NID_X9_62_prime_field)
 184                         return ec_GFp_simple_oct2point(group, point,
 185                                                         buf, len, ctx);
 186                 else
 187 #ifdef OPENSSL_NO_EC2M
 188                         {
 189                         ECerr(EC_F_EC_POINT_OCT2POINT, EC_R_GF2M_NOT_SUPPORTED);
 190                         return 0;
 191                         }
 192 #else
 193                         return ec_GF2m_simple_oct2point(group, point,
 194                                                         buf, len, ctx);
 195 #endif
 196                 }
 197         return group->meth->oct2point(group, point, buf, len, ctx);
 198         }
 199