crypto/ec/ec_asn1.c

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