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     const BIGNUM *tmp;
 540     unsigned char *buffer = NULL;
 541     const EC_POINT *point = NULL;
 542     point_conversion_form_t form;
 543
 544     if (param == NULL) {
 545         if ((ret = ECPARAMETERS_new()) == NULL) {
 546             ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
 547             goto err;
 548         }
 549     } else
 550         ret = param;
 551
 552     /* set the version (always one) */
 553     ret->version = (long)0x1;
 554
 555     /* set the fieldID */
 556     if (!ec_asn1_group2fieldid(group, ret->fieldID)) {
 557         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
 558         goto err;
 559     }
 560
 561     /* set the curve */
 562     if (!ec_asn1_group2curve(group, ret->curve)) {
 563         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
 564         goto err;
 565     }
 566
 567     /* set the base point */
 568     if ((point = EC_GROUP_get0_generator(group)) == NULL) {
 569         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, EC_R_UNDEFINED_GENERATOR);
 570         goto err;
 571     }
 572
 573     form = EC_GROUP_get_point_conversion_form(group);
 574
 575     len = EC_POINT_point2buf(group, point, form, &buffer, NULL);
 576     if (len == 0) {
 577         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
 578         goto err;
 579     }
 580     if (ret->base == NULL && (ret->base = ASN1_OCTET_STRING_new()) == NULL) {
 581         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
 582         goto err;
 583     }
 584     if (!ASN1_OCTET_STRING_set(ret->base, buffer, len)) {
 585         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
 586         goto err;
 587     }
 588
 589     /* set the order */
 590     tmp = EC_GROUP_get0_order(group);
 591     if (tmp == NULL) {
 592         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
 593         goto err;
 594     }
 595     ret->order = BN_to_ASN1_INTEGER(tmp, ret->order);
 596     if (ret->order == NULL) {
 597         ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
 598         goto err;
 599     }
 600
 601     /* set the cofactor (optional) */
 602     tmp = EC_GROUP_get0_cofactor(group);
 603     if (tmp != NULL) {
 604         ret->cofactor = BN_to_ASN1_INTEGER(tmp, ret->cofactor);
 605         if (ret->cofactor == NULL) {
 606             ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
 607             goto err;
 608         }
 609     }
 610
 611     return ret;
 612
 613  err:
 614     if (!param)
 615         ECPARAMETERS_free(ret);
 616     OPENSSL_free(buffer);
 617     return NULL;
 618 }
 619
 620 ECPKPARAMETERS *ec_asn1_group2pkparameters(const EC_GROUP *group,
 621                                            ECPKPARAMETERS *params)
 622 {
 623     int ok = 1, tmp;
 624     ECPKPARAMETERS *ret = params;
 625
 626     if (ret == NULL) {
 627         if ((ret = ECPKPARAMETERS_new()) == NULL) {
 628             ECerr(EC_F_EC_ASN1_GROUP2PKPARAMETERS, ERR_R_MALLOC_FAILURE);
 629             return NULL;
 630         }
 631     } else {
 632         if (ret->type == 0)
 633             ASN1_OBJECT_free(ret->value.named_curve);
 634         else if (ret->type == 1 && ret->value.parameters)
 635             ECPARAMETERS_free(ret->value.parameters);
 636     }
 637
 638     if (EC_GROUP_get_asn1_flag(group)) {
 639         /*
 640          * use the asn1 OID to describe the the elliptic curve parameters
 641          */
 642         tmp = EC_GROUP_get_curve_name(group);
 643         if (tmp) {
 644             ret->type = 0;
 645             if ((ret->value.named_curve = OBJ_nid2obj(tmp)) == NULL)
 646                 ok = 0;
 647         } else
 648             /* we don't kmow the nid => ERROR */
 649             ok = 0;
 650     } else {
 651         /* use the ECPARAMETERS structure */
 652         ret->type = 1;
 653         if ((ret->value.parameters =
 654              ec_asn1_group2parameters(group, NULL)) == NULL)
 655             ok = 0;
 656     }
 657
 658     if (!ok) {
 659         ECPKPARAMETERS_free(ret);
 660         return NULL;
 661     }
 662     return ret;
 663 }
 664
 665 static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params)
 666 {
 667     int ok = 0, tmp;
 668     EC_GROUP *ret = NULL;
 669     BIGNUM *p = NULL, *a = NULL, *b = NULL;
 670     EC_POINT *point = NULL;
 671     long field_bits;
 672
 673     if (!params->fieldID || !params->fieldID->fieldType ||
 674         !params->fieldID->p.ptr) {
 675         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 676         goto err;
 677     }
 678
 679     /* now extract the curve parameters a and b */
 680     if (!params->curve || !params->curve->a ||
 681         !params->curve->a->data || !params->curve->b ||
 682         !params->curve->b->data) {
 683         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 684         goto err;
 685     }
 686     a = BN_bin2bn(params->curve->a->data, params->curve->a->length, NULL);
 687     if (a == NULL) {
 688         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
 689         goto err;
 690     }
 691     b = BN_bin2bn(params->curve->b->data, params->curve->b->length, NULL);
 692     if (b == NULL) {
 693         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
 694         goto err;
 695     }
 696
 697     /* get the field parameters */
 698     tmp = OBJ_obj2nid(params->fieldID->fieldType);
 699     if (tmp == NID_X9_62_characteristic_two_field)
 700 #ifdef OPENSSL_NO_EC2M
 701     {
 702         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_GF2M_NOT_SUPPORTED);
 703         goto err;
 704     }
 705 #else
 706     {
 707         X9_62_CHARACTERISTIC_TWO *char_two;
 708
 709         char_two = params->fieldID->p.char_two;
 710
 711         field_bits = char_two->m;
 712         if (field_bits > OPENSSL_ECC_MAX_FIELD_BITS) {
 713             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_FIELD_TOO_LARGE);
 714             goto err;
 715         }
 716
 717         if ((p = BN_new()) == NULL) {
 718             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_MALLOC_FAILURE);
 719             goto err;
 720         }
 721
 722         /* get the base type */
 723         tmp = OBJ_obj2nid(char_two->type);
 724
 725         if (tmp == NID_X9_62_tpBasis) {
 726             long tmp_long;
 727
 728             if (!char_two->p.tpBasis) {
 729                 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 730                 goto err;
 731             }
 732
 733             tmp_long = ASN1_INTEGER_get(char_two->p.tpBasis);
 734
 735             if (!(char_two->m > tmp_long && tmp_long > 0)) {
 736                 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
 737                       EC_R_INVALID_TRINOMIAL_BASIS);
 738                 goto err;
 739             }
 740
 741             /* create the polynomial */
 742             if (!BN_set_bit(p, (int)char_two->m))
 743                 goto err;
 744             if (!BN_set_bit(p, (int)tmp_long))
 745                 goto err;
 746             if (!BN_set_bit(p, 0))
 747                 goto err;
 748         } else if (tmp == NID_X9_62_ppBasis) {
 749             X9_62_PENTANOMIAL *penta;
 750
 751             penta = char_two->p.ppBasis;
 752             if (!penta) {
 753                 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 754                 goto err;
 755             }
 756
 757             if (!
 758                 (char_two->m > penta->k3 && penta->k3 > penta->k2
 759                  && penta->k2 > penta->k1 && penta->k1 > 0)) {
 760                 ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
 761                       EC_R_INVALID_PENTANOMIAL_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)penta->k1))
 769                 goto err;
 770             if (!BN_set_bit(p, (int)penta->k2))
 771                 goto err;
 772             if (!BN_set_bit(p, (int)penta->k3))
 773                 goto err;
 774             if (!BN_set_bit(p, 0))
 775                 goto err;
 776         } else if (tmp == NID_X9_62_onBasis) {
 777             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_NOT_IMPLEMENTED);
 778             goto err;
 779         } else {                /* error */
 780
 781             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 782             goto err;
 783         }
 784
 785         /* create the EC_GROUP structure */
 786         ret = EC_GROUP_new_curve_GF2m(p, a, b, NULL);
 787     }
 788 #endif
 789     else if (tmp == NID_X9_62_prime_field) {
 790         /* we have a curve over a prime field */
 791         /* extract the prime number */
 792         if (!params->fieldID->p.prime) {
 793             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 794             goto err;
 795         }
 796         p = ASN1_INTEGER_to_BN(params->fieldID->p.prime, NULL);
 797         if (p == NULL) {
 798             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
 799             goto err;
 800         }
 801
 802         if (BN_is_negative(p) || BN_is_zero(p)) {
 803             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_FIELD);
 804             goto err;
 805         }
 806
 807         field_bits = BN_num_bits(p);
 808         if (field_bits > OPENSSL_ECC_MAX_FIELD_BITS) {
 809             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_FIELD_TOO_LARGE);
 810             goto err;
 811         }
 812
 813         /* create the EC_GROUP structure */
 814         ret = EC_GROUP_new_curve_GFp(p, a, b, NULL);
 815     } else {
 816         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_FIELD);
 817         goto err;
 818     }
 819
 820     if (ret == NULL) {
 821         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
 822         goto err;
 823     }
 824
 825     /* extract seed (optional) */
 826     if (params->curve->seed != NULL) {
 827         OPENSSL_free(ret->seed);
 828         if ((ret->seed = OPENSSL_malloc(params->curve->seed->length)) == NULL) {
 829             ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_MALLOC_FAILURE);
 830             goto err;
 831         }
 832         memcpy(ret->seed, params->curve->seed->data,
 833                params->curve->seed->length);
 834         ret->seed_len = params->curve->seed->length;
 835     }
 836
 837     if (!params->order || !params->base || !params->base->data) {
 838         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
 839         goto err;
 840     }
 841
 842     if ((point = EC_POINT_new(ret)) == NULL)
 843         goto err;
 844
 845     /* set the point conversion form */
 846     EC_GROUP_set_point_conversion_form(ret, (point_conversion_form_t)
 847                                        (params->base->data[0] & ~0x01));
 848
 849     /* extract the ec point */
 850     if (!EC_POINT_oct2point(ret, point, params->base->data,
 851                             params->base->length, NULL)) {
 852         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
 853         goto err;
 854     }
 855
 856     /* extract the order */
 857     if ((a = ASN1_INTEGER_to_BN(params->order, a)) == NULL) {
 858         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
 859         goto err;
 860     }
 861     if (BN_is_negative(a) || BN_is_zero(a)) {
 862         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_GROUP_ORDER);
 863         goto err;
 864     }
 865     if (BN_num_bits(a) > (int)field_bits + 1) { /* Hasse bound */
 866         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_INVALID_GROUP_ORDER);
 867         goto err;
 868     }
 869
 870     /* extract the cofactor (optional) */
 871     if (params->cofactor == NULL) {
 872         BN_free(b);
 873         b = NULL;
 874     } else if ((b = ASN1_INTEGER_to_BN(params->cofactor, b)) == NULL) {
 875         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
 876         goto err;
 877     }
 878     /* set the generator, order and cofactor (if present) */
 879     if (!EC_GROUP_set_generator(ret, point, a, b)) {
 880         ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
 881         goto err;
 882     }
 883
 884     ok = 1;
 885
 886  err:
 887     if (!ok) {
 888         EC_GROUP_clear_free(ret);
 889         ret = NULL;
 890     }
 891
 892     BN_free(p);
 893     BN_free(a);
 894     BN_free(b);
 895     EC_POINT_free(point);
 896     return (ret);
 897 }
 898
 899 EC_GROUP *ec_asn1_pkparameters2group(const ECPKPARAMETERS *params)
 900 {
 901     EC_GROUP *ret = NULL;
 902     int tmp = 0;
 903
 904     if (params == NULL) {
 905         ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, EC_R_MISSING_PARAMETERS);
 906         return NULL;
 907     }
 908
 909     if (params->type == 0) {    /* the curve is given by an OID */
 910         tmp = OBJ_obj2nid(params->value.named_curve);
 911         if ((ret = EC_GROUP_new_by_curve_name(tmp)) == NULL) {
 912             ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP,
 913                   EC_R_EC_GROUP_NEW_BY_NAME_FAILURE);
 914             return NULL;
 915         }
 916         EC_GROUP_set_asn1_flag(ret, OPENSSL_EC_NAMED_CURVE);
 917     } else if (params->type == 1) { /* the parameters are given by a
 918                                      * ECPARAMETERS structure */
 919         ret = ec_asn1_parameters2group(params->value.parameters);
 920         if (!ret) {
 921             ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, ERR_R_EC_LIB);
 922             return NULL;
 923         }
 924         EC_GROUP_set_asn1_flag(ret, 0x0);
 925     } else if (params->type == 2) { /* implicitlyCA */
 926         return NULL;
 927     } else {
 928         ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, EC_R_ASN1_ERROR);
 929         return NULL;
 930     }
 931
 932     return ret;
 933 }
 934
 935 /* EC_GROUP <-> DER encoding of ECPKPARAMETERS */
 936
 937 EC_GROUP *d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len)
 938 {
 939     EC_GROUP *group = NULL;
 940     ECPKPARAMETERS *params = NULL;
 941     const unsigned char *p = *in;
 942
 943     if ((params = d2i_ECPKPARAMETERS(NULL, &p, len)) == NULL) {
 944         ECerr(EC_F_D2I_ECPKPARAMETERS, EC_R_D2I_ECPKPARAMETERS_FAILURE);
 945         ECPKPARAMETERS_free(params);
 946         return NULL;
 947     }
 948
 949     if ((group = ec_asn1_pkparameters2group(params)) == NULL) {
 950         ECerr(EC_F_D2I_ECPKPARAMETERS, EC_R_PKPARAMETERS2GROUP_FAILURE);
 951         ECPKPARAMETERS_free(params);
 952         return NULL;
 953     }
 954
 955     if (a) {
 956         EC_GROUP_clear_free(*a);
 957         *a = group;
 958     }
 959
 960     ECPKPARAMETERS_free(params);
 961     *in = p;
 962     return (group);
 963 }
 964
 965 int i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
 966 {
 967     int ret = 0;
 968     ECPKPARAMETERS *tmp = ec_asn1_group2pkparameters(a, NULL);
 969     if (tmp == NULL) {
 970         ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_GROUP2PKPARAMETERS_FAILURE);
 971         return 0;
 972     }
 973     if ((ret = i2d_ECPKPARAMETERS(tmp, out)) == 0) {
 974         ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_I2D_ECPKPARAMETERS_FAILURE);
 975         ECPKPARAMETERS_free(tmp);
 976         return 0;
 977     }
 978     ECPKPARAMETERS_free(tmp);
 979     return (ret);
 980 }
 981
 982 /* some EC_KEY functions */
 983
 984 EC_KEY *d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len)
 985 {
 986     EC_KEY *ret = NULL;
 987     EC_PRIVATEKEY *priv_key = NULL;
 988     const unsigned char *p = *in;
 989
 990     if ((priv_key = d2i_EC_PRIVATEKEY(NULL, &p, len)) == NULL) {
 991         ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
 992         return NULL;
 993     }
 994
 995     if (a == NULL || *a == NULL) {
 996         if ((ret = EC_KEY_new()) == NULL) {
 997             ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
 998             goto err;
 999         }
1000     } else
1001         ret = *a;
1002
1003     if (priv_key->parameters) {
1004         EC_GROUP_clear_free(ret->group);
1005         ret->group = ec_asn1_pkparameters2group(priv_key->parameters);
1006     }
1007
1008     if (ret->group == NULL) {
1009         ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1010         goto err;
1011     }
1012
1013     ret->version = priv_key->version;
1014
1015     if (priv_key->privateKey) {
1016         ASN1_OCTET_STRING *pkey = priv_key->privateKey;
1017         if (EC_KEY_oct2priv(ret, ASN1_STRING_data(pkey),
1018                             ASN1_STRING_length(pkey)) == 0)
1019             goto err;
1020     } else {
1021         ECerr(EC_F_D2I_ECPRIVATEKEY, EC_R_MISSING_PRIVATE_KEY);
1022         goto err;
1023     }
1024
1025     EC_POINT_clear_free(ret->pub_key);
1026     ret->pub_key = EC_POINT_new(ret->group);
1027     if (ret->pub_key == NULL) {
1028         ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1029         goto err;
1030     }
1031
1032     if (priv_key->publicKey) {
1033         const unsigned char *pub_oct;
1034         int pub_oct_len;
1035
1036         pub_oct = ASN1_STRING_data(priv_key->publicKey);
1037         pub_oct_len = ASN1_STRING_length(priv_key->publicKey);
1038         /*
1039          * The first byte - point conversion form - must be present.
1040          */
1041         if (pub_oct_len <= 0) {
1042             ECerr(EC_F_D2I_ECPRIVATEKEY, EC_R_BUFFER_TOO_SMALL);
1043             goto err;
1044         }
1045         /* Save the point conversion form. */
1046         ret->conv_form = (point_conversion_form_t) (pub_oct[0] & ~0x01);
1047         if (!EC_POINT_oct2point(ret->group, ret->pub_key,
1048                                 pub_oct, (size_t)(pub_oct_len), NULL)) {
1049             ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1050             goto err;
1051         }
1052     } else {
1053         if (!EC_POINT_mul
1054             (ret->group, ret->pub_key, ret->priv_key, NULL, NULL, NULL)) {
1055             ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
1056             goto err;
1057         }
1058         /* Remember the original private-key-only encoding. */
1059         ret->enc_flag |= EC_PKEY_NO_PUBKEY;
1060     }
1061
1062     if (a)
1063         *a = ret;
1064     EC_PRIVATEKEY_free(priv_key);
1065     *in = p;
1066     return (ret);
1067
1068  err:
1069     if (a == NULL || *a != ret)
1070         EC_KEY_free(ret);
1071     EC_PRIVATEKEY_free(priv_key);
1072     return NULL;
1073 }
1074
1075 int i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
1076 {
1077     int ret = 0, ok = 0;
1078     unsigned char *priv= NULL, *pub= NULL;
1079     size_t privlen = 0, publen = 0;
1080
1081     EC_PRIVATEKEY *priv_key = NULL;
1082
1083     if (a == NULL || a->group == NULL ||
1084         (!(a->enc_flag & EC_PKEY_NO_PUBKEY) && a->pub_key == NULL)) {
1085         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_PASSED_NULL_PARAMETER);
1086         goto err;
1087     }
1088
1089     if ((priv_key = EC_PRIVATEKEY_new()) == NULL) {
1090         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1091         goto err;
1092     }
1093
1094     priv_key->version = a->version;
1095
1096     privlen = EC_KEY_priv2buf(a, &priv);
1097
1098     if (privlen == 0) {
1099         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1100         goto err;
1101     }
1102
1103     ASN1_STRING_set0(priv_key->privateKey, priv, privlen);
1104     priv = NULL;
1105
1106     if (!(a->enc_flag & EC_PKEY_NO_PARAMETERS)) {
1107         if ((priv_key->parameters =
1108              ec_asn1_group2pkparameters(a->group,
1109                                         priv_key->parameters)) == NULL) {
1110             ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1111             goto err;
1112         }
1113     }
1114
1115     if (!(a->enc_flag & EC_PKEY_NO_PUBKEY)) {
1116         priv_key->publicKey = ASN1_BIT_STRING_new();
1117         if (priv_key->publicKey == NULL) {
1118             ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
1119             goto err;
1120         }
1121
1122         publen = EC_KEY_key2buf(a, a->conv_form, &pub, NULL);
1123
1124         if (publen == 0) {
1125             ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1126             goto err;
1127         }
1128
1129         priv_key->publicKey->flags &= ~(ASN1_STRING_FLAG_BITS_LEFT | 0x07);
1130         priv_key->publicKey->flags |= ASN1_STRING_FLAG_BITS_LEFT;
1131         ASN1_STRING_set0(priv_key->publicKey, pub, publen);
1132         pub = NULL;
1133     }
1134
1135     if ((ret = i2d_EC_PRIVATEKEY(priv_key, out)) == 0) {
1136         ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
1137         goto err;
1138     }
1139     ok = 1;
1140  err:
1141     OPENSSL_clear_free(priv, privlen);
1142     OPENSSL_free(pub);
1143     EC_PRIVATEKEY_free(priv_key);
1144     return (ok ? ret : 0);
1145 }
1146
1147 int i2d_ECParameters(EC_KEY *a, unsigned char **out)
1148 {
1149     if (a == NULL) {
1150         ECerr(EC_F_I2D_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
1151         return 0;
1152     }
1153     return i2d_ECPKParameters(a->group, out);
1154 }
1155
1156 EC_KEY *d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len)
1157 {
1158     EC_KEY *ret;
1159
1160     if (in == NULL || *in == NULL) {
1161         ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
1162         return NULL;
1163     }
1164
1165     if (a == NULL || *a == NULL) {
1166         if ((ret = EC_KEY_new()) == NULL) {
1167             ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_MALLOC_FAILURE);
1168             return NULL;
1169         }
1170     } else
1171         ret = *a;
1172
1173     if (!d2i_ECPKParameters(&ret->group, in, len)) {
1174         ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_EC_LIB);
1175         if (a == NULL || *a != ret)
1176              EC_KEY_free(ret);
1177         return NULL;
1178     }
1179
1180     if (a)
1181         *a = ret;
1182
1183     return ret;
1184 }
1185
1186 EC_KEY *o2i_ECPublicKey(EC_KEY **a, const unsigned char **in, long len)
1187 {
1188     EC_KEY *ret = NULL;
1189
1190     if (a == NULL || (*a) == NULL || (*a)->group == NULL) {
1191         /*
1192          * sorry, but a EC_GROUP-structur is necessary to set the public key
1193          */
1194         ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER);
1195         return 0;
1196     }
1197     ret = *a;
1198     if (ret->pub_key == NULL &&
1199         (ret->pub_key = EC_POINT_new(ret->group)) == NULL) {
1200         ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_MALLOC_FAILURE);
1201         return 0;
1202     }
1203     if (!EC_POINT_oct2point(ret->group, ret->pub_key, *in, len, NULL)) {
1204         ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_EC_LIB);
1205         return 0;
1206     }
1207     /* save the point conversion form */
1208     ret->conv_form = (point_conversion_form_t) (*in[0] & ~0x01);
1209     *in += len;
1210     return ret;
1211 }
1212
1213 int i2o_ECPublicKey(EC_KEY *a, unsigned char **out)
1214 {
1215     size_t buf_len = 0;
1216     int new_buffer = 0;
1217
1218     if (a == NULL) {
1219         ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER);
1220         return 0;
1221     }
1222
1223     buf_len = EC_POINT_point2oct(a->group, a->pub_key,
1224                                  a->conv_form, NULL, 0, NULL);
1225
1226     if (out == NULL || buf_len == 0)
1227         /* out == NULL => just return the length of the octet string */
1228         return buf_len;
1229
1230     if (*out == NULL) {
1231         if ((*out = OPENSSL_malloc(buf_len)) == NULL) {
1232             ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_MALLOC_FAILURE);
1233             return 0;
1234         }
1235         new_buffer = 1;
1236     }
1237     if (!EC_POINT_point2oct(a->group, a->pub_key, a->conv_form,
1238                             *out, buf_len, NULL)) {
1239         ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_EC_LIB);
1240         if (new_buffer) {
1241             OPENSSL_free(*out);
1242             *out = NULL;
1243         }
1244         return 0;
1245     }
1246     if (!new_buffer)
1247         *out += buf_len;
1248     return buf_len;
1249 }
1250
1251 ASN1_SEQUENCE(ECDSA_SIG) = {
1252         ASN1_SIMPLE(ECDSA_SIG, r, CBIGNUM),
1253         ASN1_SIMPLE(ECDSA_SIG, s, CBIGNUM)
1254 } static_ASN1_SEQUENCE_END(ECDSA_SIG)
1255
1256 DECLARE_ASN1_FUNCTIONS_const(ECDSA_SIG)
1257 DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECDSA_SIG, ECDSA_SIG)
1258 IMPLEMENT_ASN1_FUNCTIONS_const(ECDSA_SIG)
1259
1260 void ECDSA_SIG_get0(BIGNUM **pr, BIGNUM **ps, ECDSA_SIG *sig)
1261 {
1262     if (pr != NULL)
1263         *pr = sig->r;
1264     if (ps != NULL)
1265         *ps = sig->s;
1266 }
1267
1268 int ECDSA_size(const EC_KEY *r)
1269 {
1270     int ret, i;
1271     ASN1_INTEGER bs;
1272     unsigned char buf[4];
1273     const EC_GROUP *group;
1274
1275     if (r == NULL)
1276         return 0;
1277     group = EC_KEY_get0_group(r);
1278     if (group == NULL)
1279         return 0;
1280
1281     i = EC_GROUP_order_bits(group);
1282     if (i == 0)
1283         return 0;
1284     bs.length = (i + 7) / 8;
1285     bs.data = buf;
1286     bs.type = V_ASN1_INTEGER;
1287     /* If the top bit is set the asn1 encoding is 1 larger. */
1288     buf[0] = 0xff;
1289
1290     i = i2d_ASN1_INTEGER(&bs, NULL);
1291     i += i;                     /* r and s */
1292     ret = ASN1_object_size(1, i, V_ASN1_SEQUENCE);
1293     return (ret);
1294 }