crypto/ec/ec_asn1.c

   1 /*
   2  * Written by Nils Larsch for the OpenSSL project.
   3  */
   4 /* ====================================================================
   5  * Copyright (c) 2000-2003 The OpenSSL Project.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  *
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  *
  19  * 3. All advertising materials mentioning features or use of this
  20  *    software must display the following acknowledgment:
  21  *    "This product includes software developed by the OpenSSL Project
  22  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
  23  *
  24  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  25  *    endorse or promote products derived from this software without
  26  *    prior written permission. For written permission, please contact
  27  *    licensing@OpenSSL.org.
  28  *
  29  * 5. Products derived from this software may not be called "OpenSSL"
  30  *    nor may "OpenSSL" appear in their names without prior written
  31  *    permission of the OpenSSL Project.
  32  *
  33  * 6. Redistributions of any form whatsoever must retain the following
  34  *    acknowledgment:
  35  *    "This product includes software developed by the OpenSSL Project
  36  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
  37  *
  38  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  39  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  40  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  41  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  42  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  43  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  44  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  45  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  46  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  47  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  48  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  49  * OF THE POSSIBILITY OF SUCH DAMAGE.
  50  * ====================================================================
  51  *
  52  * This product includes cryptographic software written by Eric Young
  53  * (eay@cryptsoft.com).  This product includes software written by Tim
  54  * Hudson (tjh@cryptsoft.com).
  55  *
  56  */
  57
  58 #include <string.h>
  59 #include "ec_lcl.h"
  60 #include <openssl/err.h>
  61 #include <openssl/asn1t.h>
  62 #include <openssl/objects.h>
  63
  64 int EC_GROUP_get_basis_type(const EC_GROUP *group)
  65 {
  66     int i = 0;
  67
  68     if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=
  69         NID_X9_62_characteristic_two_field)
  70         /* everything else is currently not supported */
  71         return 0;
  72
  73     while (group->poly[i] != 0)
  74         i++;
  75
  76     if (i == 4)
  77         return NID_X9_62_ppBasis;
  78     else if (i == 2)
  79         return NID_X9_62_tpBasis;
  80     else
  81         /* everything else is currently not supported */
  82         return 0;
  83 }
  84
  85 #ifndef OPENSSL_NO_EC2M
  86 int EC_GROUP_get_trinomial_basis(const EC_GROUP *group, unsigned int *k)
  87 {
  88     if (group == NULL)
  89         return 0;
  90
  91     if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=
  92         NID_X9_62_characteristic_two_field
  93         || !((group->poly[0] != 0) && (group->poly[1] != 0)
  94              && (group->poly[2] == 0))) {
  95         ECerr(EC_F_EC_GROUP_GET_TRINOMIAL_BASIS,
  96               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
  97         return 0;
  98     }
  99
 100     if (k)
 101         *k = group->poly[1];
 102
 103     return 1;
 104 }
 105
 106 int EC_GROUP_get_pentanomial_basis(const EC_GROUP *group, unsigned int *k1,
 107                                    unsigned int *k2, unsigned int *k3)
 108 {
 109     if (group == NULL)
 110         return 0;
 111
 112     if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=
 113         NID_X9_62_characteristic_two_field
 114         || !((group->poly[0] != 0) && (group->poly[1] != 0)
 115              && (group->poly[2] != 0) && (group->poly[3] != 0)
 116              && (group->poly[4] == 0))) {
 117         ECerr(EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS,
 118               ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
 119         return 0;
 120     }
 121
 122     if (k1)
 123         *k1 = group->poly[3];
 124     if (k2)
 125         *k2 = group->poly[2];
 126     if (k3)
 127         *k3 = group->poly[1];
 128
 129     return 1;
 130 }
 131 #endif
 132
 133 /* some structures needed for the asn1 encoding */
 134 typedef struct x9_62_pentanomial_st {
 135     long k1;
 136     long k2;
 137     long k3;
 138 } X9_62_PENTANOMIAL;
 139
 140 typedef struct x9_62_characteristic_two_st {
 141     long m;
 142     ASN1_OBJECT *type;
 143     union {
 144         char *ptr;
 145         /* NID_X9_62_onBasis */
 146         ASN1_NULL *onBasis;
 147         /* NID_X9_62_tpBasis */
 148         ASN1_INTEGER *tpBasis;
 149         /* NID_X9_62_ppBasis */
 150         X9_62_PENTANOMIAL *ppBasis;
 151         /* anything else */
 152         ASN1_TYPE *other;
 153     } p;
 154 } X9_62_CHARACTERISTIC_TWO;
 155
 156 typedef struct x9_62_fieldid_st {
 157     ASN1_OBJECT *fieldType;
 158     union {
 159         char *ptr;
 160         /* NID_X9_62_prime_field */
 161         ASN1_INTEGER *prime;
 162         /* NID_X9_62_characteristic_two_field */
 163         X9_62_CHARACTERISTIC_TWO *char_two;
 164         /* anything else */
 165         ASN1_TYPE *other;
 166     } p;
 167 } X9_62_FIELDID;
 168
 169 typedef struct x9_62_curve_st {
 170     ASN1_OCTET_STRING *a;
 171     ASN1_OCTET_STRING *b;
 172     ASN1_BIT_STRING *seed;
 173 } X9_62_CURVE;
 174
 175 typedef struct ec_parameters_st {
 176     long version;
 177     X9_62_FIELDID *fieldID;
 178     X9_62_CURVE *curve;
 179     ASN1_OCTET_STRING *base;
 180     ASN1_INTEGER *order;
 181     ASN1_INTEGER *cofactor;
 182 } ECPARAMETERS;
 183
 184 struct ecpk_parameters_st {
 185     int type;
 186     union {
 187         ASN1_OBJECT *named_curve;
 188         ECPARAMETERS *parameters;
 189         ASN1_NULL *implicitlyCA;
 190     } value;
 191 } /* ECPKPARAMETERS */ ;
 192
 193 /* SEC1 ECPrivateKey */
 194 typedef struct ec_privatekey_st {
 195     long version;
 196     ASN1_OCTET_STRING *privateKey;
 197     ECPKPARAMETERS *parameters;
 198     ASN1_BIT_STRING *publicKey;
 199 } EC_PRIVATEKEY;
 200
 201 /* the OpenSSL ASN.1 definitions */
 202 ASN1_SEQUENCE(X9_62_PENTANOMIAL) = {
 203         ASN1_SIMPLE(X9_62_PENTANOMIAL, k1, LONG),
 204         ASN1_SIMPLE(X9_62_PENTANOMIAL, k2, LONG),
 205         ASN1_SIMPLE(X9_62_PENTANOMIAL, k3, LONG)
 206 } static_ASN1_SEQUENCE_END(X9_62_PENTANOMIAL)
 207
 208 DECLARE_ASN1_ALLOC_FUNCTIONS(X9_62_PENTANOMIAL)
 209 IMPLEMENT_ASN1_ALLOC_FUNCTIONS(X9_62_PENTANOMIAL)
 210
 211 ASN1_ADB_TEMPLATE(char_two_def) = ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, p.other, ASN1_ANY);
 212
 213 ASN1_ADB(X9_62_CHARACTERISTIC_TWO) = {
 214         ADB_ENTRY(NID_X9_62_onBasis, ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, p.onBasis, ASN1_NULL)),
 215         ADB_ENTRY(NID_X9_62_tpBasis, ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, p.tpBasis, ASN1_INTEGER)),
 216         ADB_ENTRY(NID_X9_62_ppBasis, ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, p.ppBasis, X9_62_PENTANOMIAL))
 217 } ASN1_ADB_END(X9_62_CHARACTERISTIC_TWO, 0, type, 0, &char_two_def_tt, NULL);
 218
 219 ASN1_SEQUENCE(X9_62_CHARACTERISTIC_TWO) = {
 220         ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, m, LONG),
 221         ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, type, ASN1_OBJECT),
 222         ASN1_ADB_OBJECT(X9_62_CHARACTERISTIC_TWO)
 223 } static_ASN1_SEQUENCE_END(X9_62_CHARACTERISTIC_TWO)
 224
 225 DECLARE_ASN1_ALLOC_FUNCTIONS(X9_62_CHARACTERISTIC_TWO)
 226 IMPLEMENT_ASN1_ALLOC_FUNCTIONS(X9_62_CHARACTERISTIC_TWO)
 227
 228 ASN1_ADB_TEMPLATE(fieldID_def) = ASN1_SIMPLE(X9_62_FIELDID, p.other, ASN1_ANY);
 229
 230 ASN1_ADB(X9_62_FIELDID) = {
 231         ADB_ENTRY(NID_X9_62_prime_field, ASN1_SIMPLE(X9_62_FIELDID, p.prime, ASN1_INTEGER)),
 232         ADB_ENTRY(NID_X9_62_characteristic_two_field, ASN1_SIMPLE(X9_62_FIELDID, p.char_two, X9_62_CHARACTERISTIC_TWO))
 233 } ASN1_ADB_END(X9_62_FIELDID, 0, fieldType, 0, &fieldID_def_tt, NULL);
 234
 235 ASN1_SEQUENCE(X9_62_FIELDID) = {
 236         ASN1_SIMPLE(X9_62_FIELDID, fieldType, ASN1_OBJECT),
 237         ASN1_ADB_OBJECT(X9_62_FIELDID)
 238 } static_ASN1_SEQUENCE_END(X9_62_FIELDID)
 239
 240 ASN1_SEQUENCE(X9_62_CURVE) = {
 241         ASN1_SIMPLE(X9_62_CURVE, a, ASN1_OCTET_STRING),
 242         ASN1_SIMPLE(X9_62_CURVE, b, ASN1_OCTET_STRING),
 243         ASN1_OPT(X9_62_CURVE, seed, ASN1_BIT_STRING)
 244 } static_ASN1_SEQUENCE_END(X9_62_CURVE)
 245
 246 ASN1_SEQUENCE(ECPARAMETERS) = {
 247         ASN1_SIMPLE(ECPARAMETERS, version, LONG),
 248         ASN1_SIMPLE(ECPARAMETERS, fieldID, X9_62_FIELDID),
 249         ASN1_SIMPLE(ECPARAMETERS, curve, X9_62_CURVE),
 250         ASN1_SIMPLE(ECPARAMETERS, base, ASN1_OCTET_STRING),
 251         ASN1_SIMPLE(ECPARAMETERS, order, ASN1_INTEGER),
 252         ASN1_OPT(ECPARAMETERS, cofactor, ASN1_INTEGER)
 253 } static_ASN1_SEQUENCE_END(ECPARAMETERS)
 254
 255 DECLARE_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS)
 256 IMPLEMENT_ASN1_ALLOC_FUNCTIONS(ECPARAMETERS)
 257
 258 ASN1_CHOICE(ECPKPARAMETERS) = {
 259         ASN1_SIMPLE(ECPKPARAMETERS, value.named_curve, ASN1_OBJECT),
 260         ASN1_SIMPLE(ECPKPARAMETERS, value.parameters, ECPARAMETERS),
 261         ASN1_SIMPLE(ECPKPARAMETERS, value.implicitlyCA, ASN1_NULL)
 262 } static_ASN1_CHOICE_END(ECPKPARAMETERS)
 263
 264 DECLARE_ASN1_FUNCTIONS_const(ECPKPARAMETERS)
 265 DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECPKPARAMETERS, ECPKPARAMETERS)
 266 IMPLEMENT_ASN1_FUNCTIONS_const(ECPKPARAMETERS)
 267
 268 ASN1_SEQUENCE(EC_PRIVATEKEY) = {
 269         ASN1_SIMPLE(EC_PRIVATEKEY, version, LONG),
 270         ASN1_SIMPLE(EC_PRIVATEKEY, privateKey, ASN1_OCTET_STRING),
 271         ASN1_EXP_OPT(EC_PRIVATEKEY, parameters, ECPKPARAMETERS, 0),
 272         ASN1_EXP_OPT(EC_PRIVATEKEY, publicKey, ASN1_BIT_STRING, 1)
 273 } static_ASN1_SEQUENCE_END(EC_PRIVATEKEY)
 274
 275 DECLARE_ASN1_FUNCTIONS_const(EC_PRIVATEKEY)
 276 DECLARE_ASN1_ENCODE_FUNCTIONS_const(EC_PRIVATEKEY, EC_PRIVATEKEY)
 277 IMPLEMENT_ASN1_FUNCTIONS_const(EC_PRIVATEKEY)
 278
 279 /* some declarations of internal function */
 280
 281 /* ec_asn1_group2field() sets the values in a X9_62_FIELDID object */
 282 static int ec_asn1_group2fieldid(const EC_GROUP *, X9_62_FIELDID *);
 283 /* ec_asn1_group2curve() sets the values in a X9_62_CURVE object */
 284 static int ec_asn1_group2curve(const EC_GROUP *, X9_62_CURVE *);
 285 /*
 286  * ec_asn1_parameters2group() creates a EC_GROUP object from a ECPARAMETERS
 287  * object
 288  */
 289 static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *);
 290 /*
 291  * ec_asn1_group2parameters() creates a ECPARAMETERS object from a EC_GROUP
 292  * object
 293  */
 294 static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *,
 295                                               ECPARAMETERS *);
 296 /*
 297  * ec_asn1_pkparameters2group() creates a EC_GROUP object from a
 298  * ECPKPARAMETERS object
 299  */
 300 static EC_GROUP *ec_asn1_pkparameters2group(const ECPKPARAMETERS *);
 301 /*
 302  * ec_asn1_group2pkparameters() creates a ECPKPARAMETERS object from a
 303  * EC_GROUP object
 304  */
 305 static ECPKPARAMETERS *ec_asn1_group2pkparameters(const EC_GROUP *,
 306                                                   ECPKPARAMETERS *);
 307
 308 /* the function definitions */
 309
 310 static int ec_asn1_group2fieldid(const EC_GROUP *group, X9_62_FIELDID *field)
 311 {
 312     int ok = 0, nid;
 313     BIGNUM *tmp = NULL;
 314
 315     if (group == NULL || field == NULL)
 316         return 0;
 317
 318     /* clear the old values (if necessary) */
 319     ASN1_OBJECT_free(field->fieldType);
 320     ASN1_TYPE_free(field->p.other);
 321
 322     nid = EC_METHOD_get_field_type(EC_GROUP_method_of(group));
 323     /* set OID for the field */
 324     if ((field->fieldType = OBJ_nid2obj(nid)) == NULL) {
 325         ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_OBJ_LIB);
 326         goto err;
 327     }
 328
 329     if (nid == NID_X9_62_prime_field) {
 330         if ((tmp = BN_new()) == NULL) {
 331             ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
 332             goto err;
 333         }
 334         /* the parameters are specified by the prime number p */
 335         if (!EC_GROUP_get_curve_GFp(group, tmp, NULL, NULL, NULL)) {
 336             ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_EC_LIB);
 337             goto err;
 338         }
 339         /* set the prime number */
 340         field->p.prime = BN_to_ASN1_INTEGER(tmp, NULL);
 341         if (field->p.prime == NULL) {
 342             ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_ASN1_LIB);
 343             goto err;
 344         }
 345     } else                      /* nid == NID_X9_62_characteristic_two_field */
 346 #ifdef OPENSSL_NO_EC2M
 347     {
 348         ECerr(EC_F_EC_ASN1_GROUP2FIELDID, EC_R_GF2M_NOT_SUPPORTED);
 349         goto err;
 350     }
 351 #else
 352     {
 353         int field_type;
 354         X9_62_CHARACTERISTIC_TWO *char_two;
 355
 356         field->p.char_two = X9_62_CHARACTERISTIC_TWO_new();
 357         char_two = field->p.char_two;
 358
 359         if (char_two == NULL) {
 360             ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
 361             goto err;
 362         }
 363
 364         char_two->m = (long)EC_GROUP_get_degree(group);
 365
 366         field_type = EC_GROUP_get_basis_type(group);
 367
 368         if (field_type == 0) {
 369             ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_EC_LIB);
 370             goto err;
 371         }
 372         /* set base type OID */
 373         if ((char_two->type = OBJ_nid2obj(field_type)) == NULL) {
 374             ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_OBJ_LIB);
 375             goto err;
 376         }
 377
 378         if (field_type == NID_X9_62_tpBasis) {
 379             unsigned int k;
 380
 381             if (!EC_GROUP_get_trinomial_basis(group, &k))
 382                 goto err;
 383
 384             char_two->p.tpBasis = ASN1_INTEGER_new();
 385             if (char_two->p.tpBasis == NULL) {
 386                 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
 387                 goto err;
 388             }
 389             if (!ASN1_INTEGER_set(char_two->p.tpBasis, (long)k)) {
 390                 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_ASN1_LIB);
 391                 goto err;
 392             }
 393         } else if (field_type == NID_X9_62_ppBasis) {
 394             unsigned int k1, k2, k3;
 395
 396             if (!EC_GROUP_get_pentanomial_basis(group, &k1, &k2, &k3))
 397                 goto err;
 398
 399             char_two->p.ppBasis = X9_62_PENTANOMIAL_new();
 400             if (char_two->p.ppBasis == NULL) {
 401                 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
 402                 goto err;
 403             }
 404
 405             /* set k? values */
 406             char_two->p.ppBasis->k1 = (long)k1;
 407             char_two->p.ppBasis->k2 = (long)k2;
 408             char_two->p.ppBasis->k3 = (long)k3;
 409         } else {                /* field_type == NID_X9_62_onBasis */
 410
 411             /* for ONB the parameters are (asn1) NULL */
 412             char_two->p.onBasis = ASN1_NULL_new();
 413             if (char_two->p.onBasis == NULL) {
 414                 ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
 415                 goto err;
 416             }
 417         }
 418     }
 419 #endif
 420
 421     ok = 1;
 422
 423  err:
 424     BN_free(tmp);
 425     return (ok);
 426 }
 427
 428 static int ec_asn1_group2curve(const EC_GROUP *group, X9_62_CURVE *curve)
 429 {
 430     int ok = 0, nid;
 431     BIGNUM *tmp_1 = NULL, *tmp_2 = NULL;
 432     unsigned char *buffer_1 = NULL, *buffer_2 = NULL,
 433         *a_buf = NULL, *b_buf = NULL;
 434     size_t len_1, len_2;
 435     unsigned char char_zero = 0;
 436
 437     if (!group || !curve || !curve->a || !curve->b)
 438         return 0;
 439
 440     if ((tmp_1 = BN_new()) == NULL || (tmp_2 = BN_new()) == NULL) {
 441         ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE);
 442         goto err;
 443     }
 444
 445     nid = EC_METHOD_get_field_type(EC_GROUP_method_of(group));
 446
 447     /* get a and b */
 448     if (nid == NID_X9_62_prime_field) {
 449         if (!EC_GROUP_get_curve_GFp(group, NULL, tmp_1, tmp_2, NULL)) {
 450             ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_EC_LIB);
 451             goto err;
 452         }
 453     }
 454 #ifndef OPENSSL_NO_EC2M
 455     else {                      /* nid == NID_X9_62_characteristic_two_field */
 456
 457         if (!EC_GROUP_get_curve_GF2m(group, NULL, tmp_1, tmp_2, NULL)) {
 458             ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_EC_LIB);
 459             goto err;
 460         }
 461     }
 462 #endif
 463     len_1 = (size_t)BN_num_bytes(tmp_1);
 464     len_2 = (size_t)BN_num_bytes(tmp_2);
 465
 466     if (len_1 == 0) {
 467         /* len_1 == 0 => a == 0 */
 468         a_buf = &char_zero;
 469         len_1 = 1;
 470     } else {
 471         if ((buffer_1 = OPENSSL_malloc(len_1)) == NULL) {
 472             ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE);
 473             goto err;
 474         }
 475         if ((len_1 = BN_bn2bin(tmp_1, buffer_1)) == 0) {
 476             ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_BN_LIB);
 477             goto err;
 478         }
 479         a_buf = buffer_1;
 480     }
 481
 482     if (len_2 == 0) {
 483         /* len_2 == 0 => b == 0 */
 484         b_buf = &char_zero;
 485         len_2 = 1;
 486     } else {
 487         if ((buffer_2 = OPENSSL_malloc(len_2)) == NULL) {
 488             ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE);
 489             goto err;
 490         }
 491         if ((len_2 = BN_bn2bin(tmp_2, buffer_2)) == 0) {
 492             ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_BN_LIB);
 493             goto err;
 494         }
 495         b_buf = buffer_2;
 496     }
 497
 498     /* set a and b */
 499     if (!ASN1_OCTET_STRING_set(curve->a, a_buf, len_1) ||
 500         !ASN1_OCTET_STRING_set(curve->b, b_buf, len_2)) {
 501         ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_ASN1_LIB);
 502         goto err;
 503     }
 504
 505     /* set the seed (optional) */
 506     if (group->seed) {
 507         if (!curve->seed)
 508             if ((curve->seed = ASN1_BIT_STRING_new()) == NULL) {
 509                 ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_MALLOC_FAILURE);
 510                 goto err;
 511             }
 512         curve->seed->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
 513         curve->seed->flags |= ASN1_STRING_FLAG_BITS_LEFT;
 514         if (!ASN1_BIT_STRING_set(curve->seed, group->seed,
 515                                  (int)group->seed_len)) {
 516             ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_ASN1_LIB);
 517             goto err;
 518         }
 519     } else {
 520         ASN1_BIT_STRING_free(curve->seed);
 521         curve->seed = NULL;
 522     }
 523
 524     ok = 1;
 525
 526  err:
 527     OPENSSL_free(buffer_1);
 528     OPENSSL_free(buffer_2);
 529     BN_free(tmp_1);
 530     BN_free(tmp_2);
 531     return (ok);
 532 }
 533
 534 static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *group,
 535                                               ECPARAMETERS *param)
 536 {
 537     size_t len = 0;
 538     ECPARAMETERS *ret = NULL;
 539     BIGNUM *tmp = NULL;
 540     unsigned char *buffer = NULL;
 541     const EC_POINT *point = NULL;
 542     point_conversion_form_t form;
 543
 544     if ((tmp = BN_new()) == NULL) {
 545         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
 546         goto err;
 547     }
 548
 549     if (param == NULL) {
 550         if ((ret = ECPARAMETERS_new()) == NULL) {
 551             ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
 552             goto err;
 553         }
 554     } else
 555         ret = param;
 556
 557     /* set the version (always one) */
 558     ret->version = (long)0x1;
 559
 560     /* set the fieldID */
 561     if (!ec_asn1_group2fieldid(group, ret->fieldID)) {
 562         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
 563         goto err;
 564     }
 565
 566     /* set the curve */
 567     if (!ec_asn1_group2curve(group, ret->curve)) {
 568         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
 569         goto err;
 570     }
 571
 572     /* set the base point */
 573     if ((point = EC_GROUP_get0_generator(group)) == NULL) {
 574         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, EC_R_UNDEFINED_GENERATOR);
 575         goto err;
 576     }
 577
 578     form = EC_GROUP_get_point_conversion_form(group);
 579
 580     len = EC_POINT_point2buf(group, point, form, &buffer, NULL);
 581     if (len == 0) {
 582         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
 583         goto err;
 584     }
 585     if (ret->base == NULL && (ret->base = ASN1_OCTET_STRING_new()) == NULL) {
 586         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
 587         goto err;
 588     }
 589     if (!ASN1_OCTET_STRING_set(ret->base, buffer, len)) {
 590         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
 591         goto err;
 592     }
 593
 594     /* set the order */
 595     if (!EC_GROUP_get_order(group, tmp, NULL)) {
 596         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
 597         goto err;
 598     }
 599     ret->order = BN_to_ASN1_INTEGER(tmp, ret->order);
 600     if (ret->order == NULL) {
 601         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
 602         goto err;
 603     }
 604
 605     /* set the cofactor (optional) */
 606     if (EC_GROUP_get_cofactor(group, tmp, NULL)) {
 607         ret->cofactor = BN_to_ASN1_INTEGER(tmp, ret->cofactor);
 608         if (ret->cofactor == NULL) {
 609             ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
 610             goto err;
 611         }
 612     }
 613
 614     return ret;
 615
 616  err:
 617     if (!param)
 618         ECPARAMETERS_free(ret);
 619     BN_free(tmp);
 620     OPENSSL_free(buffer);
 621     return NULL;
 622 }
 623
 624 ECPKPARAMETERS *ec_asn1_group2pkparameters(const EC_GROUP *group,
 625                                            ECPKPARAMETERS *params)
 626 {
 627     int ok = 1, tmp;
 628     ECPKPARAMETERS *ret = params;
 629
 630     if (ret == NULL) {
 631         if ((ret = ECPKPARAMETERS_new()) == NULL) {
 632             ECerr(EC_F_EC_ASN1_GROUP2PKPARAMETERS, ERR_R_MALLOC_FAILURE);
 633             return NULL;
 634         }
 635     } else {
 636         if (ret->type == 0)
 637             ASN1_OBJECT_free(ret->value.named_curve);
 638         else if (ret->type == 1 && ret->value.parameters)
 639             ECPARAMETERS_free(ret->value.parameters);
 640     }
 641
 642     if (EC_GROUP_get_asn1_flag(group)) {
 643         /*
 644          * use the asn1 OID to describe the the elliptic curve parameters
 645          */
 646         tmp = EC_GROUP_get_curve_name(group);
 647         if (tmp) {
 648             ret->type = 0;
 649             if ((ret->value.named_curve = OBJ_nid2obj(tmp)) == NULL)
 650                 ok = 0;
 651         } else
 652             /* we don't kmow the nid => ERROR */
 653             ok = 0;
 654     } else {
 655         /* use the ECPARAMETERS structure */
 656         ret->type = 1;
 657         if ((ret->value.parameters =
 658              ec_asn1_group2parameters(group, NULL)) == NULL)
 659             ok = 0;
 660     }
 661
 662     if (!ok) {
 663         ECPKPARAMETERS_free(ret);
 664         return NULL;
 665     }
 666     return ret;
 667 }
 668
 669 static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params)
 670 {
 671     int ok = 0, tmp;
 672     EC_GROUP *ret = NULL;
 673     BIGNUM *p = NULL, *a = NULL, *b = NULL;
 674     EC_POINT *point = NULL;
 675     long field_bits;
 676
 677     if (!params->fieldID || !params->fieldID->fieldType ||
 678         !params->fieldID->p.ptr) {
 679         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 680         goto err;
 681     }
 682
 683     /* now extract the curve parameters a and b */
 684     if (!params->curve || !params->curve->a ||
 685         !params->curve->a->data || !params->curve->b ||
 686         !params->curve->b->data) {
 687         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 688         goto err;
 689     }
 690     a = BN_bin2bn(params->curve->a->data, params->curve->a->length, NULL);
 691     if (a == NULL) {
 692         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
 693         goto err;
 694     }
 695     b = BN_bin2bn(params->curve->b->data, params->curve->b->length, NULL);
 696     if (b == NULL) {
 697         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
 698         goto err;
 699     }
 700
 701     /* get the field parameters */
 702     tmp = OBJ_obj2nid(params->fieldID->fieldType);
 703     if (tmp == NID_X9_62_characteristic_two_field)
 704 #ifdef OPENSSL_NO_EC2M
 705     {
 706         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_GF2M_NOT_SUPPORTED);
 707         goto err;
 708     }
 709 #else
 710     {
 711         X9_62_CHARACTERISTIC_TWO *char_two;
 712
 713         char_two = params->fieldID->p.char_two;
 714
 715         field_bits = char_two->m;
 716         if (field_bits > OPENSSL_ECC_MAX_FIELD_BITS) {
 717             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_FIELD_TOO_LARGE);
 718             goto err;
 719         }
 720
 721         if ((p = BN_new()) == NULL) {
 722             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_MALLOC_FAILURE);
 723             goto err;
 724         }
 725
 726         /* get the base type */
 727         tmp = OBJ_obj2nid(char_two->type);
 728
 729         if (tmp == NID_X9_62_tpBasis) {
 730             long tmp_long;
 731
 732             if (!char_two->p.tpBasis) {
 733                 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 734                 goto err;
 735             }
 736
 737             tmp_long = ASN1_INTEGER_get(char_two->p.tpBasis);
 738
 739             if (!(char_two->m > tmp_long && tmp_long > 0)) {
 740                 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
 741                       EC_R_INVALID_TRINOMIAL_BASIS);
 742                 goto err;
 743             }
 744
 745             /* create the polynomial */
 746             if (!BN_set_bit(p, (int)char_two->m))
 747                 goto err;
 748             if (!BN_set_bit(p, (int)tmp_long))
 749                 goto err;
 750             if (!BN_set_bit(p, 0))
 751                 goto err;
 752         } else if (tmp == NID_X9_62_ppBasis) {
 753             X9_62_PENTANOMIAL *penta;
 754
 755             penta = char_two->p.ppBasis;
 756             if (!penta) {
 757                 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 758                 goto err;
 759             }
 760
 761             if (!
 762                 (char_two->m > penta->k3 && penta->k3 > penta->k2
 763                  && penta->k2 > penta->k1 && penta->k1 > 0)) {
 764                 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
 765                       EC_R_INVALID_PENTANOMIAL_BASIS);
 766                 goto err;
 767             }
 768
 769             /* create the polynomial */
 770             if (!BN_set_bit(p, (int)char_two->m))
 771                 goto err;
 772             if (!BN_set_bit(p, (int)penta->k1))
 773                 goto err;
 774             if (!BN_set_bit(p, (int)penta->k2))
 775                 goto err;
 776             if (!BN_set_bit(p, (int)penta->k3))
 777                 goto err;
 778             if (!BN_set_bit(p, 0))
 779                 goto err;
 780         } else if (tmp == NID_X9_62_onBasis) {
 781             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_NOT_IMPLEMENTED);
 782             goto err;
 783         } else {                /* error */
 784
 785             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 786             goto err;
 787         }
 788
 789         /* create the EC_GROUP structure */
 790         ret = EC_GROUP_new_curve_GF2m(p, a, b, NULL);
 791     }
 792 #endif
 793     else if (tmp == NID_X9_62_prime_field) {
 794         /* we have a curve over a prime field */
 795         /* extract the prime number */
 796         if (!params->fieldID->p.prime) {
 797             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 798             goto err;
 799         }
 800         p = ASN1_INTEGER_to_BN(params->fieldID->p.prime, NULL);
 801         if (p == NULL) {
 802             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
 803             goto err;
 804         }
 805
 806         if (BN_is_negative(p) || BN_is_zero(p)) {
 807             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_FIELD);
 808             goto err;
 809         }
 810
 811         field_bits = BN_num_bits(p);
 812         if (field_bits > OPENSSL_ECC_MAX_FIELD_BITS) {
 813             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_FIELD_TOO_LARGE);
 814             goto err;
 815         }
 816
 817         /* create the EC_GROUP structure */
 818         ret = EC_GROUP_new_curve_GFp(p, a, b, NULL);
 819     } else {
 820         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_FIELD);
 821         goto err;
 822     }
 823
 824     if (ret == NULL) {
 825         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
 826         goto err;
 827     }
 828
 829     /* extract seed (optional) */
 830     if (params->curve->seed != NULL) {
 831         OPENSSL_free(ret->seed);
 832         if ((ret->seed = OPENSSL_malloc(params->curve->seed->length)) == NULL) {
 833             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_MALLOC_FAILURE);
 834             goto err;
 835         }
 836         memcpy(ret->seed, params->curve->seed->data,
 837                params->curve->seed->length);
 838         ret->seed_len = params->curve->seed->length;
 839     }
 840
 841     if (!params->order || !params->base || !params->base->data) {
 842         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 843         goto err;
 844     }
 845
 846     if ((point = EC_POINT_new(ret)) == NULL)
 847         goto err;
 848
 849     /* set the point conversion form */
 850     EC_GROUP_set_point_conversion_form(ret, (point_conversion_form_t)
 851                                        (params->base->data[0] & ~0x01));
 852
 853     /* extract the ec point */
 854     if (!EC_POINT_oct2point(ret, point, params->base->data,
 855                             params->base->length, NULL)) {
 856         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
 857         goto err;
 858     }
 859
 860     /* extract the order */
 861     if ((a = ASN1_INTEGER_to_BN(params->order, a)) == NULL) {
 862         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
 863         goto err;
 864     }
 865     if (BN_is_negative(a) || BN_is_zero(a)) {
 866         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_GROUP_ORDER);
 867         goto err;
 868     }
 869     if (BN_num_bits(a) > (int)field_bits + 1) { /* Hasse bound */
 870         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_GROUP_ORDER);
 871         goto err;
 872     }
 873
 874     /* extract the cofactor (optional) */
 875     if (params->cofactor == NULL) {
 876         BN_free(b);
 877         b = NULL;
 878     } else if ((b = ASN1_INTEGER_to_BN(params->cofactor, b)) == NULL) {
 879         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
 880         goto err;
 881     }
 882     /* set the generator, order and cofactor (if present) */
 883     if (!EC_GROUP_set_generator(ret, point, a, b)) {
 884         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
 885         goto err;
 886     }
 887
 888     ok = 1;
 889
 890  err:
 891     if (!ok) {
 892         EC_GROUP_clear_free(ret);
 893         ret = NULL;
 894     }
 895
 896     BN_free(p);
 897     BN_free(a);
 898     BN_free(b);
 899     EC_POINT_free(point);
 900     return (ret);
 901 }
 902
 903 EC_GROUP *ec_asn1_pkparameters2group(const ECPKPARAMETERS *params)
 904 {
 905     EC_GROUP *ret = NULL;
 906     int tmp = 0;
 907
 908     if (params == NULL) {
 909         ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, EC_R_MISSING_PARAMETERS);
 910         return NULL;
 911     }
 912
 913     if (params->type == 0) {    /* the curve is given by an OID */
 914         tmp = OBJ_obj2nid(params->value.named_curve);
 915         if ((ret = EC_GROUP_new_by_curve_name(tmp)) == NULL) {
 916             ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP,
 917                   EC_R_EC_GROUP_NEW_BY_NAME_FAILURE);
 918             return NULL;
 919         }
 920         EC_GROUP_set_asn1_flag(ret, OPENSSL_EC_NAMED_CURVE);
 921     } else if (params->type == 1) { /* the parameters are given by a
 922                                      * ECPARAMETERS structure */
 923         ret = ec_asn1_parameters2group(params->value.parameters);
 924         if (!ret) {
 925             ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, ERR_R_EC_LIB);
 926             return NULL;
 927         }
 928         EC_GROUP_set_asn1_flag(ret, 0x0);
 929     } else if (params->type == 2) { /* implicitlyCA */
 930         return NULL;
 931     } else {
 932         ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, EC_R_ASN1_ERROR);
 933         return NULL;
 934     }
 935
 936     return ret;
 937 }
 938
 939 /* EC_GROUP <-> DER encoding of ECPKPARAMETERS */
 940
 941 EC_GROUP *d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len)
 942 {
 943     EC_GROUP *group = NULL;
 944     ECPKPARAMETERS *params = NULL;
 945     const unsigned char *p = *in;
 946
 947     if ((params = d2i_ECPKPARAMETERS(NULL, &p, len)) == NULL) {
 948         ECerr(EC_F_D2I_ECPKPARAMETERS, EC_R_D2I_ECPKPARAMETERS_FAILURE);
 949         ECPKPARAMETERS_free(params);
 950         return NULL;
 951     }
 952
 953     if ((group = ec_asn1_pkparameters2group(params)) == NULL) {
 954         ECerr(EC_F_D2I_ECPKPARAMETERS, EC_R_PKPARAMETERS2GROUP_FAILURE);
 955         ECPKPARAMETERS_free(params);
 956         return NULL;
 957     }
 958
 959     if (a) {
 960         EC_GROUP_clear_free(*a);
 961         *a = group;
 962     }
 963
 964     ECPKPARAMETERS_free(params);
 965     *in = p;
 966     return (group);
 967 }
 968
 969 int i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
 970 {
 971     int ret = 0;
 972     ECPKPARAMETERS *tmp = ec_asn1_group2pkparameters(a, NULL);
 973     if (tmp == NULL) {
 974         ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_GROUP2PKPARAMETERS_FAILURE);
 975         return 0;
 976     }
 977     if ((ret = i2d_ECPKPARAMETERS(tmp, out)) == 0) {
 978         ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_I2D_ECPKPARAMETERS_FAILURE);
 979         ECPKPARAMETERS_free(tmp);
 980         return 0;
 981     }
 982     ECPKPARAMETERS_free(tmp);
 983     return (ret);
 984 }
 985
 986 /* some EC_KEY functions */
 987
 988 EC_KEY *d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len)
 989 {
 990     EC_KEY *ret = NULL;
 991     EC_PRIVATEKEY *priv_key = NULL;
 992     const unsigned char *p = *in;
 993
 994     if ((priv_key = d2i_EC_PRIVATEKEY(NULL, &p, len)) == NULL) {
 995         ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
 996         return NULL;
 997     }
 998
 999     if (a == NULL || *a == NULL) {
1000         if ((ret = EC_KEY_new()) == NULL) {
1001             ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1002             goto err;
1003         }
1004     } else
1005         ret = *a;
1006
1007     if (priv_key->parameters) {
1008         EC_GROUP_clear_free(ret->group);
1009         ret->group = ec_asn1_pkparameters2group(priv_key->parameters);
1010     }
1011
1012     if (ret->group == NULL) {
1013         ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1014         goto err;
1015     }
1016
1017     ret->version = priv_key->version;
1018
1019     if (priv_key->privateKey) {
1020         if (ret->priv_key == NULL)
1021             ret->priv_key = BN_secure_new();
1022         if (ret->priv_key == NULL) {
1023             ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1024             goto err;
1025         }
1026         ret->priv_key = BN_bin2bn(ASN1_STRING_data(priv_key->privateKey),
1027                                   ASN1_STRING_length(priv_key->privateKey),
1028                                   ret->priv_key);
1029         if (ret->priv_key == NULL) {
1030             ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_BN_LIB);
1031             goto err;
1032         }
1033     } else {
1034         ECerr(EC_F_D2I_ECPRIVATEKEY, EC_R_MISSING_PRIVATE_KEY);
1035         goto err;
1036     }
1037
1038     EC_POINT_clear_free(ret->pub_key);
1039     ret->pub_key = EC_POINT_new(ret->group);
1040     if (ret->pub_key == NULL) {
1041         ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1042         goto err;
1043     }
1044
1045     if (priv_key->publicKey) {
1046         const unsigned char *pub_oct;
1047         int pub_oct_len;
1048
1049         pub_oct = ASN1_STRING_data(priv_key->publicKey);
1050         pub_oct_len = ASN1_STRING_length(priv_key->publicKey);
1051         /*
1052          * The first byte - point conversion form - must be present.
1053          */
1054         if (pub_oct_len <= 0) {
1055             ECerr(EC_F_D2I_ECPRIVATEKEY, EC_R_BUFFER_TOO_SMALL);
1056             goto err;
1057         }
1058         /* Save the point conversion form. */
1059         ret->conv_form = (point_conversion_form_t) (pub_oct[0] & ~0x01);
1060         if (!EC_POINT_oct2point(ret->group, ret->pub_key,
1061                                 pub_oct, (size_t)(pub_oct_len), NULL)) {
1062             ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1063             goto err;
1064         }
1065     } else {
1066         if (!EC_POINT_mul
1067             (ret->group, ret->pub_key, ret->priv_key, NULL, NULL, NULL)) {
1068             ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1069             goto err;
1070         }
1071         /* Remember the original private-key-only encoding. */
1072         ret->enc_flag |= EC_PKEY_NO_PUBKEY;
1073     }
1074
1075     if (a)
1076         *a = ret;
1077     EC_PRIVATEKEY_free(priv_key);
1078     *in = p;
1079     return (ret);
1080
1081  err:
1082     if (a == NULL || *a != ret)
1083         EC_KEY_free(ret);
1084     EC_PRIVATEKEY_free(priv_key);
1085     return NULL;
1086 }
1087
1088 int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
1089 {
1090     int ret = 0, ok = 0;
1091     unsigned char *buffer = NULL;
1092     size_t buf_len = 0, tmp_len, bn_len;
1093     EC_PRIVATEKEY *priv_key = NULL;
1094
1095     if (a == NULL || a->group == NULL || a->priv_key == NULL ||
1096         (!(a->enc_flag & EC_PKEY_NO_PUBKEY) && a->pub_key == NULL)) {
1097         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_PASSED_NULL_PARAMETER);
1098         goto err;
1099     }
1100
1101     if ((priv_key = EC_PRIVATEKEY_new()) == NULL) {
1102         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1103         goto err;
1104     }
1105
1106     priv_key->version = a->version;
1107
1108     bn_len = (size_t)BN_num_bytes(a->priv_key);
1109
1110     /* Octetstring may need leading zeros if BN is to short */
1111
1112     buf_len = (EC_GROUP_get_degree(a->group) + 7) / 8;
1113
1114     if (bn_len > buf_len) {
1115         ECerr(EC_F_I2D_ECPRIVATEKEY, EC_R_BUFFER_TOO_SMALL);
1116         goto err;
1117     }
1118
1119     buffer = OPENSSL_malloc(buf_len);
1120     if (buffer == NULL) {
1121         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1122         goto err;
1123     }
1124
1125     if (!BN_bn2bin(a->priv_key, buffer + buf_len - bn_len)) {
1126         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_BN_LIB);
1127         goto err;
1128     }
1129
1130     if (buf_len - bn_len > 0) {
1131         memset(buffer, 0, buf_len - bn_len);
1132     }
1133
1134     if (!ASN1_OCTET_STRING_set(priv_key->privateKey, buffer, buf_len)) {
1135         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_ASN1_LIB);
1136         goto err;
1137     }
1138
1139     if (!(a->enc_flag & EC_PKEY_NO_PARAMETERS)) {
1140         if ((priv_key->parameters =
1141              ec_asn1_group2pkparameters(a->group,
1142                                         priv_key->parameters)) == NULL) {
1143             ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1144             goto err;
1145         }
1146     }
1147
1148     if (!(a->enc_flag & EC_PKEY_NO_PUBKEY)) {
1149         priv_key->publicKey = ASN1_BIT_STRING_new();
1150         if (priv_key->publicKey == NULL) {
1151             ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1152             goto err;
1153         }
1154
1155         tmp_len = EC_POINT_point2oct(a->group, a->pub_key,
1156                                      a->conv_form, NULL, 0, NULL);
1157
1158         if (tmp_len > buf_len) {
1159             unsigned char *tmp_buffer = OPENSSL_realloc(buffer, tmp_len);
1160             if (!tmp_buffer) {
1161                 ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1162                 goto err;
1163             }
1164             buffer = tmp_buffer;
1165             buf_len = tmp_len;
1166         }
1167
1168         if (!EC_POINT_point2oct(a->group, a->pub_key,
1169                                 a->conv_form, buffer, buf_len, NULL)) {
1170             ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1171             goto err;
1172         }
1173
1174         priv_key->publicKey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
1175         priv_key->publicKey->flags |= ASN1_STRING_FLAG_BITS_LEFT;
1176         if (!ASN1_BIT_STRING_set(priv_key->publicKey, buffer, buf_len)) {
1177             ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_ASN1_LIB);
1178             goto err;
1179         }
1180     }
1181
1182     if ((ret = i2d_EC_PRIVATEKEY(priv_key, out)) == 0) {
1183         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1184         goto err;
1185     }
1186     ok = 1;
1187  err:
1188     OPENSSL_free(buffer);
1189     EC_PRIVATEKEY_free(priv_key);
1190     return (ok ? ret : 0);
1191 }
1192
1193 int i2d_ECParameters(EC_KEY *a, unsigned char **out)
1194 {
1195     if (a == NULL) {
1196         ECerr(EC_F_I2D_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
1197         return 0;
1198     }
1199     return i2d_ECPKParameters(a->group, out);
1200 }
1201
1202 EC_KEY *d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len)
1203 {
1204     EC_KEY *ret;
1205
1206     if (in == NULL || *in == NULL) {
1207         ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
1208         return NULL;
1209     }
1210
1211     if (a == NULL || *a == NULL) {
1212         if ((ret = EC_KEY_new()) == NULL) {
1213             ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_MALLOC_FAILURE);
1214             return NULL;
1215         }
1216     } else
1217         ret = *a;
1218
1219     if (!d2i_ECPKParameters(&ret->group, in, len)) {
1220         ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_EC_LIB);
1221         if (a == NULL || *a != ret)
1222              EC_KEY_free(ret);
1223         return NULL;
1224     }
1225
1226     if (a)
1227         *a = ret;
1228
1229     return ret;
1230 }
1231
1232 EC_KEY *o2i_ECPublicKey(EC_KEY **a, const unsigned char **in, long len)
1233 {
1234     EC_KEY *ret = NULL;
1235
1236     if (a == NULL || (*a) == NULL || (*a)->group == NULL) {
1237         /*
1238          * sorry, but a EC_GROUP-structur is necessary to set the public key
1239          */
1240         ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER);
1241         return 0;
1242     }
1243     ret = *a;
1244     if (ret->pub_key == NULL &&
1245         (ret->pub_key = EC_POINT_new(ret->group)) == NULL) {
1246         ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_MALLOC_FAILURE);
1247         return 0;
1248     }
1249     if (!EC_POINT_oct2point(ret->group, ret->pub_key, *in, len, NULL)) {
1250         ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_EC_LIB);
1251         return 0;
1252     }
1253     /* save the point conversion form */
1254     ret->conv_form = (point_conversion_form_t) (*in[0] & ~0x01);
1255     *in += len;
1256     return ret;
1257 }
1258
1259 int i2o_ECPublicKey(EC_KEY *a, unsigned char **out)
1260 {
1261     size_t buf_len = 0;
1262     int new_buffer = 0;
1263
1264     if (a == NULL) {
1265         ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER);
1266         return 0;
1267     }
1268
1269     buf_len = EC_POINT_point2oct(a->group, a->pub_key,
1270                                  a->conv_form, NULL, 0, NULL);
1271
1272     if (out == NULL || buf_len == 0)
1273         /* out == NULL => just return the length of the octet string */
1274         return buf_len;
1275
1276     if (*out == NULL) {
1277         if ((*out = OPENSSL_malloc(buf_len)) == NULL) {
1278             ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_MALLOC_FAILURE);
1279             return 0;
1280         }
1281         new_buffer = 1;
1282     }
1283     if (!EC_POINT_point2oct(a->group, a->pub_key, a->conv_form,
1284                             *out, buf_len, NULL)) {
1285         ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_EC_LIB);
1286         if (new_buffer) {
1287             OPENSSL_free(*out);
1288             *out = NULL;
1289         }
1290         return 0;
1291     }
1292     if (!new_buffer)
1293         *out += buf_len;
1294     return buf_len;
1295 }
1296
1297 ASN1_SEQUENCE(ECDSA_SIG) = {
1298         ASN1_SIMPLE(ECDSA_SIG, r, CBIGNUM),
1299         ASN1_SIMPLE(ECDSA_SIG, s, CBIGNUM)
1300 } static_ASN1_SEQUENCE_END(ECDSA_SIG)
1301
1302 DECLARE_ASN1_FUNCTIONS_const(ECDSA_SIG)
1303 DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECDSA_SIG, ECDSA_SIG)
1304 IMPLEMENT_ASN1_FUNCTIONS_const(ECDSA_SIG)
1305
1306 void ECDSA_SIG_get0(BIGNUM **pr, BIGNUM **ps, ECDSA_SIG *sig)
1307 {
1308     if (pr != NULL)
1309         *pr = sig->r;
1310     if (ps != NULL)
1311         *ps = sig->s;
1312 }
1313
1314 int ECDSA_size(const EC_KEY *r)
1315 {
1316     int ret, i;
1317     ASN1_INTEGER bs;
1318     BIGNUM *order = NULL;
1319     unsigned char buf[4];
1320     const EC_GROUP *group;
1321
1322     if (r == NULL)
1323         return 0;
1324     group = EC_KEY_get0_group(r);
1325     if (group == NULL)
1326         return 0;
1327
1328     if ((order = BN_new()) == NULL)
1329         return 0;
1330     if (!EC_GROUP_get_order(group, order, NULL)) {
1331         BN_clear_free(order);
1332         return 0;
1333     }
1334     i = BN_num_bits(order);
1335     bs.length = (i + 7) / 8;
1336     bs.data = buf;
1337     bs.type = V_ASN1_INTEGER;
1338     /* If the top bit is set the asn1 encoding is 1 larger. */
1339     buf[0] = 0xff;
1340
1341     i = i2d_ASN1_INTEGER(&bs, NULL);
1342     i += i;                     /* r and s */
1343     ret = ASN1_object_size(1, i, V_ASN1_SEQUENCE);
1344     BN_clear_free(order);
1345     return (ret);
1346 }