treat 'out' like i2d functions do; cf. asn1_item_flags_i2d (crypto/asn/tasn_enc.c)
[openssl.git] / crypto / ec / ec_asn1.c
index 90b64b0..f31ac45 100644 (file)
@@ -1,6 +1,9 @@
 /* crypto/ec/ec_asn1.c */
+/*
+ * Written by Nils Larsch for the OpenSSL project.
+ */
 /* ====================================================================
- * Copyright (c) 2000-2002 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 2000-2003 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  *
  */
 
+#include <string.h>
 #include "ec_lcl.h"
 #include <openssl/err.h>
 #include <openssl/asn1t.h>
 #include <openssl/objects.h>
 
+
+int EC_GROUP_get_basis_type(const EC_GROUP *group)
+       {
+       int i=0;
+
+       if (EC_METHOD_get_field_type(EC_GROUP_method_of(group)) !=
+               NID_X9_62_characteristic_two_field)
+               /* everything else is currently not supported */
+               return 0;
+
+       while (group->poly[i] != 0)
+               i++;
+
+       if (i == 4)
+               return NID_X9_62_ppBasis;
+       else if (i == 2)
+               return NID_X9_62_tpBasis;
+       else
+               /* everything else is currently not supported */
+               return 0;
+       }
+
+int EC_GROUP_get_trinomial_basis(const EC_GROUP *group, unsigned int *k)
+       {
+       if (group == NULL)
+               return 0;
+
+       if (EC_GROUP_method_of(group)->group_set_curve != ec_GF2m_simple_group_set_curve
+           || !((group->poly[0] != 0) && (group->poly[1] != 0) && (group->poly[2] == 0)))
+               {
+               ECerr(EC_F_EC_GROUP_GET_TRINOMIAL_BASIS, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+               return 0;
+               }
+
+       if (k)
+               *k = group->poly[1];
+
+       return 1;
+       }
+
+int EC_GROUP_get_pentanomial_basis(const EC_GROUP *group, unsigned int *k1,
+       unsigned int *k2, unsigned int *k3)
+       {
+       if (group == NULL)
+               return 0;
+
+       if (EC_GROUP_method_of(group)->group_set_curve != ec_GF2m_simple_group_set_curve
+           || !((group->poly[0] != 0) && (group->poly[1] != 0) && (group->poly[2] != 0) && (group->poly[3] != 0) && (group->poly[4] == 0)))
+               {
+               ECerr(EC_F_EC_GROUP_GET_PENTANOMIAL_BASIS, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+               return 0;
+               }
+
+       if (k1)
+               *k1 = group->poly[3];
+       if (k2)
+               *k2 = group->poly[2];
+       if (k3)
+               *k3 = group->poly[1];
+
+       return 1;
+       }
+
+
+
 /* some structures needed for the asn1 encoding */
 typedef struct x9_62_fieldid_st {
         ASN1_OBJECT *fieldType;
@@ -65,15 +134,15 @@ typedef struct x9_62_fieldid_st {
         } X9_62_FIELDID;
 
 typedef struct x9_62_characteristic_two_st {
-       ASN1_INTEGER *m;
+       long m;
        ASN1_OBJECT  *basis;
        ASN1_TYPE    *parameters;
        } X9_62_CHARACTERISTIC_TWO;
 
 typedef struct x9_62_pentanomial_st {
-       ASN1_INTEGER k1;
-       ASN1_INTEGER k2;
-       ASN1_INTEGER k3;
+       long k1;
+       long k2;
+       long k3;
        } X9_62_PENTANOMIAL;
 
 typedef struct x9_62_curve_st {
@@ -82,14 +151,14 @@ typedef struct x9_62_curve_st {
         ASN1_BIT_STRING   *seed;
         } X9_62_CURVE;
 
-struct ec_parameters_st {
-        ASN1_INTEGER      *version;
+typedef struct ec_parameters_st {
+        long              version;
         X9_62_FIELDID     *fieldID;
         X9_62_CURVE       *curve;
         ASN1_OCTET_STRING *base;
         ASN1_INTEGER      *order;
         ASN1_INTEGER      *cofactor;
-        }/* ECPARAMETERS */;
+        } ECPARAMETERS;
 
 struct ecpk_parameters_st {
        int     type;
@@ -100,6 +169,14 @@ struct ecpk_parameters_st {
        } value;
        }/* ECPKPARAMETERS */;
 
+/* SEC1 ECPrivateKey */
+typedef struct ec_privatekey_st {
+       long              version;
+       ASN1_OCTET_STRING *privateKey;
+        ECPKPARAMETERS    *parameters;
+       ASN1_BIT_STRING   *publicKey;
+       } EC_PRIVATEKEY;
+
 /* the OpenSSL asn1 definitions */
 
 ASN1_SEQUENCE(X9_62_FIELDID) = {
@@ -112,7 +189,7 @@ DECLARE_ASN1_ENCODE_FUNCTIONS_const(X9_62_FIELDID, X9_62_FIELDID)
 IMPLEMENT_ASN1_FUNCTIONS_const(X9_62_FIELDID)
 
 ASN1_SEQUENCE(X9_62_CHARACTERISTIC_TWO) = {
-       ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, m, ASN1_INTEGER),
+       ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, m, LONG),
        ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, basis, ASN1_OBJECT),
        ASN1_SIMPLE(X9_62_CHARACTERISTIC_TWO, parameters, ASN1_ANY)
 } ASN1_SEQUENCE_END(X9_62_CHARACTERISTIC_TWO)
@@ -122,9 +199,9 @@ DECLARE_ASN1_ENCODE_FUNCTIONS_const(X9_62_CHARACTERISTIC_TWO, X9_62_CHARACTERIST
 IMPLEMENT_ASN1_FUNCTIONS_const(X9_62_CHARACTERISTIC_TWO)
 
 ASN1_SEQUENCE(X9_62_PENTANOMIAL) = {
-       ASN1_SIMPLE(X9_62_PENTANOMIAL, k1, ASN1_INTEGER),
-       ASN1_SIMPLE(X9_62_PENTANOMIAL, k2, ASN1_INTEGER),
-       ASN1_SIMPLE(X9_62_PENTANOMIAL, k3, ASN1_INTEGER)
+       ASN1_SIMPLE(X9_62_PENTANOMIAL, k1, LONG),
+       ASN1_SIMPLE(X9_62_PENTANOMIAL, k2, LONG),
+       ASN1_SIMPLE(X9_62_PENTANOMIAL, k3, LONG)
 } ASN1_SEQUENCE_END(X9_62_PENTANOMIAL)
 
 DECLARE_ASN1_FUNCTIONS_const(X9_62_PENTANOMIAL)
@@ -142,15 +219,16 @@ DECLARE_ASN1_ENCODE_FUNCTIONS_const(X9_62_CURVE, X9_62_CURVE)
 IMPLEMENT_ASN1_FUNCTIONS_const(X9_62_CURVE)
 
 ASN1_SEQUENCE(ECPARAMETERS) = {
-       ASN1_SIMPLE(ECPARAMETERS, version, ASN1_INTEGER),
+       ASN1_SIMPLE(ECPARAMETERS, version, LONG),
        ASN1_SIMPLE(ECPARAMETERS, fieldID, X9_62_FIELDID),
        ASN1_SIMPLE(ECPARAMETERS, curve, X9_62_CURVE),
        ASN1_SIMPLE(ECPARAMETERS, base, ASN1_OCTET_STRING),
        ASN1_SIMPLE(ECPARAMETERS, order, ASN1_INTEGER),
-       ASN1_SIMPLE(ECPARAMETERS, cofactor, ASN1_INTEGER)
+       ASN1_OPT(ECPARAMETERS, cofactor, ASN1_INTEGER)
 } ASN1_SEQUENCE_END(ECPARAMETERS)
 
 DECLARE_ASN1_FUNCTIONS_const(ECPARAMETERS)
+DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECPARAMETERS, ECPARAMETERS)
 IMPLEMENT_ASN1_FUNCTIONS_const(ECPARAMETERS)
 
 ASN1_CHOICE(ECPKPARAMETERS) = {
@@ -160,31 +238,56 @@ ASN1_CHOICE(ECPKPARAMETERS) = {
 } ASN1_CHOICE_END(ECPKPARAMETERS)
 
 DECLARE_ASN1_FUNCTIONS_const(ECPKPARAMETERS)
+DECLARE_ASN1_ENCODE_FUNCTIONS_const(ECPKPARAMETERS, ECPKPARAMETERS)
 IMPLEMENT_ASN1_FUNCTIONS_const(ECPKPARAMETERS)
 
 ASN1_SEQUENCE(EC_PRIVATEKEY) = {
        ASN1_SIMPLE(EC_PRIVATEKEY, version, LONG),
        ASN1_SIMPLE(EC_PRIVATEKEY, privateKey, ASN1_OCTET_STRING),
-       ASN1_OPT(EC_PRIVATEKEY, parameters, ECPKPARAMETERS),
-       ASN1_OPT(EC_PRIVATEKEY, publicKey, ASN1_BIT_STRING)
+       ASN1_EXP_OPT(EC_PRIVATEKEY, parameters, ECPKPARAMETERS, 0),
+       ASN1_EXP_OPT(EC_PRIVATEKEY, publicKey, ASN1_BIT_STRING, 1)
 } ASN1_SEQUENCE_END(EC_PRIVATEKEY)
 
+DECLARE_ASN1_FUNCTIONS_const(EC_PRIVATEKEY)
+DECLARE_ASN1_ENCODE_FUNCTIONS_const(EC_PRIVATEKEY, EC_PRIVATEKEY)
 IMPLEMENT_ASN1_FUNCTIONS_const(EC_PRIVATEKEY)
 
-/* some internal functions */
+/* some declarations of internal function */
 
+/* ec_asn1_group2field() creates a X9_62_FIELDID object from a 
+ * EC_GROUP object */
 static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *, X9_62_FIELDID *);
+/* ec_asn1_group2curve() creates a X9_62_CURVE object from a 
+ * EC_GROUP object */
 static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *, X9_62_CURVE *);
+/* ec_asn1_parameters2group() creates a EC_GROUP object from a
+ * ECPARAMETERS object */
 static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *); 
-static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *, 
-                                              ECPARAMETERS *);
+/* ec_asn1_group2parameters() creates a ECPARAMETERS object from a 
+ * EC_GROUP object */
+static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *,ECPARAMETERS *);
+/* ec_asn1_pkparameters2group() creates a EC_GROUP object from a
+ * ECPKPARAMETERS object */
+static EC_GROUP *ec_asn1_pkparameters2group(const ECPKPARAMETERS *); 
+/* ec_asn1_group2pkparameters() creates a ECPKPARAMETERS object from a 
+ * EC_GROUP object */
+static ECPKPARAMETERS *ec_asn1_group2pkparameters(const EC_GROUP *, 
+       ECPKPARAMETERS *);
+
+
+/* the function definitions */
 
 static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group, 
                                           X9_62_FIELDID *field)
        {
-       int           ok=0, nid;
-       X9_62_FIELDID *ret=NULL;
-       BIGNUM        *tmp=NULL;
+       int                     ok=0, nid;
+       X9_62_FIELDID           *ret = NULL;
+       X9_62_CHARACTERISTIC_TWO *char_two = NULL;
+       X9_62_PENTANOMIAL       *penta = NULL;
+       BIGNUM                  *tmp = NULL;
+       unsigned char           *buffer = NULL;
+       unsigned char           *pp;
+       size_t                  buf_len = 0;
        
        if (field == NULL)
                {
@@ -197,6 +300,7 @@ static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group,
        else
                {       
                ret = field;
+               /* clear the old values */
                if (ret->fieldType != NULL)
                        ASN1_OBJECT_free(ret->fieldType);
                if (ret->parameters != NULL)
@@ -204,31 +308,34 @@ static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group,
                }
 
        nid = EC_METHOD_get_field_type(EC_GROUP_method_of(group));
-
+       /* set OID for the field */
        if ((ret->fieldType = OBJ_nid2obj(nid)) == NULL)
                {
                ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_OBJ_LIB);
                goto err;
                }
 
-       if (nid == NID_X9_62_prime_field)
-               {
-               if ((tmp = BN_new()) == NULL) 
+       if ((ret->parameters = ASN1_TYPE_new()) == NULL)
                        {
                        ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
                        goto err;
                        }
-               if ((ret->parameters = ASN1_TYPE_new()) == NULL)
+
+       if (nid == NID_X9_62_prime_field)
+               {
+               if ((tmp = BN_new()) == NULL) 
                        {
                        ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
                        goto err;
                        }
+               /* the parameters are specified by the prime number p */
                ret->parameters->type = V_ASN1_INTEGER;
                if (!EC_GROUP_get_curve_GFp(group, tmp, NULL, NULL, NULL))
                        {
                        ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_EC_LIB);
                        goto err;
                        }
+               /* set the prime number */
                ret->parameters->value.integer = BN_to_ASN1_INTEGER(tmp, NULL);
                if (ret->parameters->value.integer == NULL)
                        {
@@ -236,8 +343,108 @@ static X9_62_FIELDID *ec_asn1_group2field(const EC_GROUP *group,
                        goto err;
                        }
                }
-       else
-               goto err;
+       else    /* nid == NID_X9_62_characteristic_two_field */
+               {
+               int             field_type;
+
+               char_two = X9_62_CHARACTERISTIC_TWO_new();
+               if (char_two == NULL)
+                       {
+                       ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
+                       goto err;
+                       }
+       
+               char_two->m = (long)EC_GROUP_get_degree(group);
+
+               field_type = EC_GROUP_get_basis_type(group);
+
+               if (field_type == 0)
+                       {
+                       ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_EC_LIB);
+                       goto err;
+                       }
+               /* set base type OID */
+               if ((char_two->basis = OBJ_nid2obj(field_type)) == NULL)
+                       {
+                       ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_OBJ_LIB);
+                       goto err;
+                       }
+
+               if (field_type == NID_X9_62_tpBasis)
+                       {
+                       unsigned int k;
+
+                       if (!EC_GROUP_get_trinomial_basis(group, &k))
+                               goto err;
+
+                       char_two->parameters->type = V_ASN1_INTEGER;
+                       char_two->parameters->value.integer = 
+                               ASN1_INTEGER_new();
+                       if (char_two->parameters->value.integer == NULL)
+                               {
+                               ECerr(EC_F_EC_ASN1_GROUP2FIELDID,
+                                       ERR_R_ASN1_LIB);
+                               goto err;
+                               }
+                       if (!ASN1_INTEGER_set(char_two->parameters->value.integer, (long)k))
+                               {
+                               ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS,
+                                       ERR_R_ASN1_LIB);
+                               goto err;
+                               }
+                       }
+               else if (field_type == NID_X9_62_ppBasis)
+                       {
+                       unsigned int k1, k2, k3;
+
+                       if (!EC_GROUP_get_pentanomial_basis(group, &k1, &k2, &k3))
+                               goto err;
+
+                       penta = X9_62_PENTANOMIAL_new();
+                       /* set k? values */
+                       penta->k1 = (long)k1;
+                       penta->k2 = (long)k2;
+                       penta->k3 = (long)k3;
+                       /* get the length of the encoded structure */
+                       buf_len = i2d_X9_62_PENTANOMIAL(penta, NULL);
+                       if ((buffer = OPENSSL_malloc(buf_len)) == NULL)
+                               {
+                               ECerr(EC_F_EC_ASN1_GROUP2FIELDID,
+                                       ERR_R_MALLOC_FAILURE);
+                               goto err;
+                               }
+                       pp = buffer;
+                       i2d_X9_62_PENTANOMIAL(penta, &pp);
+                       /* set the encoded pentanomial */
+                       char_two->parameters->type=V_ASN1_SEQUENCE;
+                       char_two->parameters->value.sequence=ASN1_STRING_new();
+                       ASN1_STRING_set(char_two->parameters->value.sequence,
+                               buffer, buf_len);
+
+                       OPENSSL_free(buffer);
+                       buffer = NULL;
+                       }
+               else /* field_type == NID_X9_62_onBasis */
+                       {
+                       /* for ONB the parameters are (asn1) NULL */
+                       char_two->parameters->type = V_ASN1_NULL;
+                       }
+               /* encoded the X9_62_CHARACTERISTIC_TWO structure */
+               buf_len = i2d_X9_62_CHARACTERISTIC_TWO(char_two, NULL);
+
+               if ((buffer = OPENSSL_malloc(buf_len)) == NULL)
+                       {
+                       ECerr(EC_F_EC_ASN1_GROUP2FIELDID, ERR_R_MALLOC_FAILURE);
+                       goto err;
+                       }
+               pp = buffer;
+               i2d_X9_62_CHARACTERISTIC_TWO(char_two, &pp);
+               /* set the encoded parameters */
+               ret->parameters->type = V_ASN1_SEQUENCE;
+               ret->parameters->value.sequence = ASN1_STRING_new();
+               ASN1_STRING_set(ret->parameters->value.sequence,
+                               buffer, buf_len);
+               }
 
        ok = 1;
 
@@ -249,6 +456,12 @@ err :      if (!ok)
        }
        if (tmp)
                BN_free(tmp);
+       if (char_two)
+               X9_62_CHARACTERISTIC_TWO_free(char_two);
+       if (penta)
+               X9_62_PENTANOMIAL_free(penta);
+       if (buffer)
+               OPENSSL_free(buffer);
        return(ret);
 }
 
@@ -301,57 +514,63 @@ static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *group,
                        ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_EC_LIB);
                        goto err;
                        }
+               }
+       else    /* nid == NID_X9_62_characteristic_two_field */
+               {
+               if (!EC_GROUP_get_curve_GF2m(group, NULL, tmp_1, tmp_2, NULL))
+                       {
+                       ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_EC_LIB);
+                       goto err;
+                       }
+               }
 
-               len_1 = (size_t)BN_num_bytes(tmp_1);
-               len_2 = (size_t)BN_num_bytes(tmp_2);
+       len_1 = (size_t)BN_num_bytes(tmp_1);
+       len_2 = (size_t)BN_num_bytes(tmp_2);
 
-               if (len_1 == 0)
+       if (len_1 == 0)
+               {
+               /* len_1 == 0 => a == 0 */
+               a_buf = &char_zero;
+               len_1 = 1;
+               }
+       else
+               {
+               if ((buffer_1 = OPENSSL_malloc(len_1)) == NULL)
                        {
-                       /* len_1 == 0 => a == 0 */
-                       a_buf = &char_zero;
-                       len_1 = 1;
+                       ECerr(EC_F_EC_ASN1_GROUP2CURVE,
+                             ERR_R_MALLOC_FAILURE);
+                       goto err;
                        }
-               else
+               if ( (len_1 = BN_bn2bin(tmp_1, buffer_1)) == 0)
                        {
-                       if ((buffer_1 = OPENSSL_malloc(len_1)) == NULL)
-                               {
-                               ECerr(EC_F_EC_ASN1_GROUP2CURVE,
-                                     ERR_R_MALLOC_FAILURE);
-                               goto err;
-                               }
-                       if ( (len_1 = BN_bn2bin(tmp_1, buffer_1)) == 0)
-                               {
-                               ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_BN_LIB);
-                               goto err;
-                               }
-                       a_buf = buffer_1;
+                       ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_BN_LIB);
+                       goto err;
                        }
+               a_buf = buffer_1;
+               }
 
-               if (len_2 == 0)
+       if (len_2 == 0)
+               {
+               /* len_2 == 0 => b == 0 */
+               b_buf = &char_zero;
+               len_2 = 1;
+               }
+       else
+               {
+               if ((buffer_2 = OPENSSL_malloc(len_2)) == NULL)
                        {
-                       /* len_2 == 0 => b == 0 */
-                       b_buf = &char_zero;
-                       len_2 = 1;
+                       ECerr(EC_F_EC_ASN1_GROUP2CURVE,
+                             ERR_R_MALLOC_FAILURE);
+                       goto err;
                        }
-               else
+               if ( (len_2 = BN_bn2bin(tmp_2, buffer_2)) == 0)
                        {
-                       if ((buffer_2 = OPENSSL_malloc(len_2)) == NULL)
-                               {
-                               ECerr(EC_F_EC_ASN1_GROUP2CURVE,
-                                     ERR_R_MALLOC_FAILURE);
-                               goto err;
-                               }
-                       if ( (len_2 = BN_bn2bin(tmp_2, buffer_2)) == 0)
-                               {
-                               ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_BN_LIB);
-                               goto err;
-                               }
-                       b_buf = buffer_2;
+                       ECerr(EC_F_EC_ASN1_GROUP2CURVE, ERR_R_BN_LIB);
+                       goto err;
                        }
+               b_buf = buffer_2;
                }
-       else
-               goto err;
-
+       
        /* set a and b */
        if ((ret->a = M_ASN1_OCTET_STRING_new()) == NULL || 
            (ret->b = M_ASN1_OCTET_STRING_new()) == NULL )
@@ -383,11 +602,11 @@ static X9_62_CURVE *ec_asn1_group2curve(const EC_GROUP *group,
        ok = 1;
 
 err :  if (!ok)
-       {
+               {
                if (ret && !curve)
                        X9_62_CURVE_free(ret);
                ret = NULL;
-       }
+               }
        if (buffer_1)
                OPENSSL_free(buffer_1);
        if (buffer_2)
@@ -397,7 +616,7 @@ err :       if (!ok)
        if (tmp_2)
                BN_free(tmp_2);
        return(ret);
-}
+       }
 
 static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *group,
                                               ECPARAMETERS *param)
@@ -429,16 +648,7 @@ static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *group,
                ret = param;
 
        /* set the version (always one) */
-       if (ret->version == NULL && !(ret->version = ASN1_INTEGER_new()))
-               {
-               ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_MALLOC_FAILURE);
-               goto err;
-               }
-       if (!ASN1_INTEGER_set(ret->version, (long)0x1))
-               {
-               ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
-               goto err;
-               }
+       ret->version = (long)0x1;
 
        /* set the fieldID */
        ret->fieldID = ec_asn1_group2field(group, ret->fieldID);
@@ -505,17 +715,15 @@ static ECPARAMETERS *ec_asn1_group2parameters(const EC_GROUP *group,
                goto err;
                }
 
-       /* set the cofactor */
-       if (!EC_GROUP_get_cofactor(group, tmp, NULL))
-               {
-               ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_EC_LIB);
-               goto err;
-               }
-       ret->cofactor = BN_to_ASN1_INTEGER(tmp, ret->cofactor);
-       if (ret->cofactor == NULL)
+       /* set the cofactor (optional) */
+       if (EC_GROUP_get_cofactor(group, tmp, NULL))
                {
-               ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
-               goto err;
+               ret->cofactor = BN_to_ASN1_INTEGER(tmp, ret->cofactor);
+               if (ret->cofactor == NULL)
+                       {
+                       ECerr(EC_F_EC_ASN1_GROUP2PARAMETERS, ERR_R_ASN1_LIB);
+                       goto err;
+                       }
                }
 
        ok = 1;
@@ -533,7 +741,7 @@ err :       if(!ok)
        return(ret);
        }
 
-ECPKPARAMETERS *EC_ASN1_group2pkparameters(const EC_GROUP *group, 
+ECPKPARAMETERS *ec_asn1_group2pkparameters(const EC_GROUP *group, 
                                            ECPKPARAMETERS *params)
        {
        int            ok = 1, tmp;
@@ -569,15 +777,8 @@ ECPKPARAMETERS *EC_ASN1_group2pkparameters(const EC_GROUP *group,
                                ok = 0;
                        }
                else
-                       {
-                       /* we have no nid => use the normal
-                        * ECPARAMETERS structure 
-                        */
-                       ret->type = 1;
-                       if ((ret->value.parameters = ec_asn1_group2parameters(
-                            group, NULL)) == NULL)
-                               ok = 0;
-                       }
+                       /* we don't kmow the nid => ERROR */
+                       ok = 0;
                }
        else
                {       
@@ -598,10 +799,13 @@ ECPKPARAMETERS *EC_ASN1_group2pkparameters(const EC_GROUP *group,
 
 static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params)
        {
-       int       ok=0, tmp;
-       EC_GROUP  *ret=NULL;
-       BIGNUM    *p=NULL, *a=NULL, *b=NULL;
-       EC_POINT  *point=NULL;
+       int                     ok = 0, tmp;
+       EC_GROUP                *ret = NULL;
+       BIGNUM                  *p = NULL, *a = NULL, *b = NULL;
+       EC_POINT                *point=NULL;
+       X9_62_CHARACTERISTIC_TWO *char_two = NULL;
+       X9_62_PENTANOMIAL       *penta = NULL;
+       unsigned char           *pp;
 
        if (!params->fieldID || !params->fieldID->fieldType || 
            !params->fieldID->parameters)
@@ -610,67 +814,153 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params)
                goto err;
                }
 
-       tmp = OBJ_obj2nid(params->fieldID->fieldType);
-
-       if (tmp == NID_X9_62_characteristic_two_field)
+       /* now extract the curve parameters a and b */
+       if (!params->curve || !params->curve->a || 
+           !params->curve->a->data || !params->curve->b ||
+           !params->curve->b->data)
                {
-               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_NOT_IMPLEMENTED);
+               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
                goto err;
                }
-       else if (tmp == NID_X9_62_prime_field)
+       a = BN_bin2bn(params->curve->a->data, params->curve->a->length, NULL);
+       if (a == NULL)
                {
-               /* we have a curve over a prime field */
-               /* extract the prime number */
-               if (params->fieldID->parameters->type != V_ASN1_INTEGER ||
-                   !params->fieldID->parameters->value.integer)
+               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
+               goto err;
+               }
+       b = BN_bin2bn(params->curve->b->data, params->curve->b->length, NULL);
+       if (b == NULL)
+               {
+               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
+               goto err;
+               }
+
+       /* get the field parameters */
+       tmp = OBJ_obj2nid(params->fieldID->fieldType);
+
+       if (tmp == NID_X9_62_characteristic_two_field)
+               {
+               ASN1_TYPE *parameters = params->fieldID->parameters;
+
+               if (parameters->type !=  V_ASN1_SEQUENCE)
                        {
                        ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
                        goto err;
                        }
-               p = ASN1_INTEGER_to_BN(params->fieldID->parameters->value.integer, NULL);
-               if (p == NULL)
+
+               if ((p = BN_new()) == NULL)
+                       {
+                       ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, 
+                             ERR_R_MALLOC_FAILURE);
+                       goto err;
+                       }
+
+               /* extract the X9_62_CHARACTERISTIC_TWO object */
+               pp = M_ASN1_STRING_data(parameters->value.sequence);
+               char_two = d2i_X9_62_CHARACTERISTIC_TWO(NULL, 
+                       (const unsigned char **) &pp,
+                       M_ASN1_STRING_length(parameters->value.sequence));
+               if (char_two == NULL)
                        {
                        ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
                        goto err;
                        }
-               /* now extract the curve parameters a and b */
-               if (!params->curve || !params->curve->a || 
-                   !params->curve->a->data || !params->curve->b ||
-                   !params->curve->b->data)
+               /* get the base type */
+               tmp = OBJ_obj2nid(char_two->basis);
+
+               if (tmp ==  NID_X9_62_tpBasis)
+                       {
+                       long tmp_long;
+
+                       if (char_two->parameters->type != V_ASN1_INTEGER ||
+                               char_two->parameters->value.integer == NULL)
+                               {
+                               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
+                                       EC_R_ASN1_ERROR);
+                               goto err;
+                               }
+
+                       tmp_long = ASN1_INTEGER_get(char_two->parameters->value.integer);
+                       /* create the polynomial */
+                       if (!BN_set_bit(p, (int)char_two->m)) goto err;
+                       if (!BN_set_bit(p, (int)tmp_long)) goto err;
+                       if (!BN_set_bit(p, 0)) goto err;
+                       }
+               else if (tmp == NID_X9_62_ppBasis)
+                       {
+                       if (char_two->parameters->type != V_ASN1_SEQUENCE ||
+                               char_two->parameters->value.sequence == NULL)
+                               {
+                               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
+                                       EC_R_ASN1_ERROR);
+                               goto err;
+                               }
+                       /* extract the pentanomial data */
+                       pp = M_ASN1_STRING_data(
+                               char_two->parameters->value.sequence);
+                       penta = d2i_X9_62_PENTANOMIAL(NULL,
+                               (const unsigned char **) &pp,
+                               M_ASN1_STRING_length(
+                               char_two->parameters->value.sequence));
+                       if (penta == NULL)
+                               {
+                               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
+                                       ERR_R_ASN1_LIB);
+                               goto err;
+                               }
+                       /* create the polynomial */
+                       if (!BN_set_bit(p, (int)char_two->m)) goto err;
+                       if (!BN_set_bit(p, (int)penta->k1)) goto err;
+                       if (!BN_set_bit(p, (int)penta->k2)) goto err;
+                       if (!BN_set_bit(p, (int)penta->k3)) goto err;
+                       if (!BN_set_bit(p, 0)) goto err;
+                       }
+               else if (tmp == NID_X9_62_onBasis)
+                       {
+                       ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP,
+                               EC_R_NOT_IMPLEMENTED);
+                       goto err;
+                       }
+               else /* error */
                        {
                        ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
                        goto err;
                        }
-               a = BN_bin2bn(params->curve->a->data, 
-                             params->curve->a->length, NULL);
-               if (a == NULL)
+
+               /* create the EC_GROUP structure */
+               ret = EC_GROUP_new_curve_GF2m(p, a, b, NULL);
+               if (ret == NULL)
+                       {
+                       ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
+                       goto err;
+                       }
+               }
+       else if (tmp == NID_X9_62_prime_field)
+               {
+               /* we have a curve over a prime field */
+               /* extract the prime number */
+               if (params->fieldID->parameters->type != V_ASN1_INTEGER ||
+                   !params->fieldID->parameters->value.integer)
                        {
-                       ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
+                       ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
                        goto err;
                        }
-               b = BN_bin2bn(params->curve->b->data, params->curve->b->length, NULL);
-               if (b == NULL)
+               p = ASN1_INTEGER_to_BN(params->fieldID->parameters->value.integer, NULL);
+               if (p == NULL)
                        {
-                       ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_BN_LIB);
+                       ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
                        goto err;
                        }
                /* create the EC_GROUP structure */
-/* TODO */
                ret = EC_GROUP_new_curve_GFp(p, a, b, NULL);
                if (ret == NULL)
                        {
                        ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
                        goto err;
                        }
-               /* create the generator */
-               if ((point = EC_POINT_new(ret)) == NULL) goto err;
-               }
-       else 
-               {
-               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_UNKNOWN_FIELD);
-               goto err;
                }
 
+       /* extract seed (optional) */
        if (params->curve->seed != NULL)
                {
                if (ret->seed != NULL)
@@ -686,22 +976,19 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params)
                ret->seed_len = params->curve->seed->length;
                }
 
-       if (!params->order || !params->cofactor || !params->base ||
-           !params->base->data)
+       if (!params->order || !params->base || !params->base->data)
                {
                ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
                goto err;
                }
 
+       if ((point = EC_POINT_new(ret)) == NULL) goto err;
 
-       a = ASN1_INTEGER_to_BN(params->order, a);
-       b = ASN1_INTEGER_to_BN(params->cofactor, b);
-       if (!a || !b)
-               {
-               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
-               goto err;
-               }
+       /* set the point conversion form */
+       EC_GROUP_set_point_conversion_form(ret, (point_conversion_form_t)
+                               (params->base->data[0] & ~0x01));
 
+       /* extract the ec point */
        if (!EC_POINT_oct2point(ret, point, params->base->data, 
                                params->base->length, NULL))
                {
@@ -709,10 +996,29 @@ static EC_GROUP *ec_asn1_parameters2group(const ECPARAMETERS *params)
                goto err;
                }
 
-       /* set the point conversion form */
-       EC_GROUP_set_point_conversion_form(ret, (point_conversion_form_t)
-                               (params->base->data[0] & ~0x01));
-
+       /* extract the order */
+       if ((a = ASN1_INTEGER_to_BN(params->order, a)) == NULL)
+               {
+               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
+               goto err;
+               }
+       
+       /* extract the cofactor (optional) */
+       if (params->cofactor == NULL)
+               {
+               if (b)
+                       {
+                       BN_free(b);
+                       b = NULL;
+                       }
+               }
+       else
+               if ((b = ASN1_INTEGER_to_BN(params->cofactor, b)) == NULL)
+                       {
+                       ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_ASN1_LIB);
+                       goto err;
+                       }
+       /* set the generator, order and cofactor (if present) */
        if (!EC_GROUP_set_generator(ret, point, a, b))
                {
                ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, ERR_R_EC_LIB);
@@ -736,10 +1042,14 @@ err:     if (!ok)
                BN_free(b);
        if (point)      
                EC_POINT_free(point);
+       if (char_two)
+               X9_62_CHARACTERISTIC_TWO_free(char_two);
+       if (penta)
+               X9_62_PENTANOMIAL_free(penta);
        return(ret);
 }
 
-EC_GROUP *EC_ASN1_pkparameters2group(const ECPKPARAMETERS *params)
+EC_GROUP *ec_asn1_pkparameters2group(const ECPKPARAMETERS *params)
        {
        EC_GROUP *ret=NULL;
        int      tmp=0;
@@ -754,7 +1064,7 @@ EC_GROUP *EC_ASN1_pkparameters2group(const ECPKPARAMETERS *params)
        if (params->type == 0)
                { /* the curve is given by an OID */
                tmp = OBJ_obj2nid(params->value.named_curve);
-               if ((ret = EC_GROUP_new_by_name(tmp)) == NULL)
+               if ((ret = EC_GROUP_new_by_nid(tmp)) == NULL)
                        {
                        ECerr(EC_F_EC_ASN1_PKPARAMETERS2GROUP, 
                              EC_R_EC_GROUP_NEW_BY_NAME_FAILURE);
@@ -778,43 +1088,16 @@ EC_GROUP *EC_ASN1_pkparameters2group(const ECPKPARAMETERS *params)
                return NULL;
                }
        else
-       {
-               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
-               return NULL;
-       }
-
-       return ret;
-}
-
-/* EC_GROUP <-> DER encoding of EC[PK]PARAMETERS */
-
-EC_GROUP *d2i_ECParameters(EC_GROUP **a, const unsigned char **in, long len)
-       {
-       EC_GROUP        *group  = NULL;
-       ECPARAMETERS    *params = NULL;
-
-       if ((params = d2i_ECPARAMETERS(NULL, in, len)) == NULL)
                {
-               ECerr(EC_F_D2I_ECPARAMETERS, EC_R_D2I_ECPARAMETERS_FAILURE);
-               ECPARAMETERS_free(params);
+               ECerr(EC_F_EC_ASN1_PARAMETERS2GROUP, EC_R_ASN1_ERROR);
                return NULL;
                }
-       
-       if ((group = ec_asn1_parameters2group(params)) == NULL)
-               {
-               ECerr(EC_F_D2I_ECPARAMETERS, EC_R_PARAMETERS2GROUP_FAILURE);
-               return NULL; 
-               }
 
-       if (a && *a)
-               EC_GROUP_clear_free(*a);
-       if (a)
-               *a = group;
-
-       ECPARAMETERS_free(params);
-       return(group);
+       return ret;
        }
 
+/* EC_GROUP <-> DER encoding of ECPKPARAMETERS */
+
 EC_GROUP *d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len)
        {
        EC_GROUP        *group  = NULL;
@@ -827,7 +1110,7 @@ EC_GROUP *d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len)
                return NULL;
                }
        
-       if ((group = EC_ASN1_pkparameters2group(params)) == NULL)
+       if ((group = ec_asn1_pkparameters2group(params)) == NULL)
                {
                ECerr(EC_F_D2I_ECPKPARAMETERS, EC_R_PKPARAMETERS2GROUP_FAILURE);
                return NULL; 
@@ -843,40 +1126,351 @@ EC_GROUP *d2i_ECPKParameters(EC_GROUP **a, const unsigned char **in, long len)
        return(group);
        }
 
-int i2d_ECParameters(const EC_GROUP *a, unsigned char **out)
+int i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
        {
        int             ret=0;
-       ECPARAMETERS    *tmp = ec_asn1_group2parameters(a, NULL);
+       ECPKPARAMETERS  *tmp = ec_asn1_group2pkparameters(a, NULL);
        if (tmp == NULL)
                {
-               ECerr(EC_F_I2D_ECPARAMETERS, EC_R_GROUP2PARAMETERS_FAILURE);
+               ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_GROUP2PKPARAMETERS_FAILURE);
                return 0;
                }
-       if ((ret = i2d_ECPARAMETERS(tmp, out)) == 0)
+       if ((ret = i2d_ECPKPARAMETERS(tmp, out)) == 0)
                {
-               ECerr(EC_F_I2D_ECPARAMETERS, EC_R_I2D_EC_PARAMETERS_FAILURE);
-               ECPARAMETERS_free(tmp);
+               ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_I2D_ECPKPARAMETERS_FAILURE);
+               ECPKPARAMETERS_free(tmp);
                return 0;
                }       
-       ECPARAMETERS_free(tmp);
+       ECPKPARAMETERS_free(tmp);
        return(ret);
        }
 
-int i2d_ECPKParameters(const EC_GROUP *a, unsigned char **out)
+/* some EC_KEY functions */
+
+EC_KEY *d2i_ECPrivateKey(EC_KEY **a, const unsigned char **in, long len)
        {
-       int             ret=0;
-       ECPKPARAMETERS  *tmp = EC_ASN1_group2pkparameters(a, NULL);
-       if (tmp == NULL)
+       int             ok=0;
+       EC_KEY          *ret=NULL;
+       EC_PRIVATEKEY   *priv_key=NULL;
+
+       if ((priv_key = EC_PRIVATEKEY_new()) == NULL)
                {
-               ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_GROUP2PKPARAMETERS_FAILURE);
+               ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_MALLOC_FAILURE);
+               return NULL;
+               }
+
+       if ((priv_key = d2i_EC_PRIVATEKEY(&priv_key, in, len)) == NULL)
+               {
+               ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
+               EC_PRIVATEKEY_free(priv_key);
+               return NULL;
+               }
+
+       if (a == NULL || *a == NULL)
+               {
+               if ((ret = EC_KEY_new()) == NULL)       
+                       {
+                       ECerr(EC_F_D2I_ECPRIVATEKEY,
+                                 ERR_R_MALLOC_FAILURE);
+                       goto err;
+                       }
+               if (a)
+                       *a = ret;
+               }
+       else
+               ret = *a;
+
+       if (priv_key->parameters)
+               {
+               if (ret->group)
+                       EC_GROUP_clear_free(ret->group);
+               ret->group = ec_asn1_pkparameters2group(priv_key->parameters);
+               }
+
+       if (ret->group == NULL)
+               {
+               ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
+               goto err;
+               }
+
+       ret->version = priv_key->version;
+
+       if (priv_key->privateKey)
+               {
+               ret->priv_key = BN_bin2bn(
+                       M_ASN1_STRING_data(priv_key->privateKey),
+                       M_ASN1_STRING_length(priv_key->privateKey),
+                       ret->priv_key);
+               if (ret->priv_key == NULL)
+                       {
+                       ECerr(EC_F_D2I_ECPRIVATEKEY,
+                              ERR_R_BN_LIB);
+                       goto err;
+                       }
+               }
+       else
+               {
+               ECerr(EC_F_D2I_ECPRIVATEKEY, 
+                      EC_R_MISSING_PRIVATE_KEY);
+               goto err;
+               }
+
+       if (priv_key->publicKey)
+               {
+               if (ret->pub_key)
+                       EC_POINT_clear_free(ret->pub_key);
+               ret->pub_key = EC_POINT_new(ret->group);
+               if (ret->pub_key == NULL)
+                       {
+                       ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
+                       goto err;
+                       }
+               if (!EC_POINT_oct2point(ret->group, ret->pub_key,
+                       M_ASN1_STRING_data(priv_key->publicKey),
+                       M_ASN1_STRING_length(priv_key->publicKey), NULL))
+                       {
+                       ECerr(EC_F_D2I_ECPRIVATEKEY, ERR_R_EC_LIB);
+                       goto err;
+                       }
+               }
+
+       ok = 1;
+err:
+       if (!ok)
+               {
+               if (ret)
+                       EC_KEY_free(ret);
+               ret = NULL;
+               }
+
+       if (priv_key)
+               EC_PRIVATEKEY_free(priv_key);
+
+       return(ret);
+       }
+
+int    i2d_ECPrivateKey(EC_KEY *a, unsigned char **out)
+       {
+       int             ret=0, ok=0;
+       unsigned char   *buffer=NULL;
+       size_t          buf_len=0, tmp_len;
+       EC_PRIVATEKEY   *priv_key=NULL;
+
+       if (a == NULL || a->group == NULL || a->priv_key == NULL)
+               {
+               ECerr(EC_F_I2D_ECPRIVATEKEY,
+                      ERR_R_PASSED_NULL_PARAMETER);
+               goto err;
+               }
+
+       if ((priv_key = EC_PRIVATEKEY_new()) == NULL)
+               {
+               ECerr(EC_F_I2D_ECPRIVATEKEY,
+                      ERR_R_MALLOC_FAILURE);
+               goto err;
+               }
+
+       priv_key->version = a->version;
+
+       buf_len = (size_t)BN_num_bytes(a->priv_key);
+       buffer = OPENSSL_malloc(buf_len);
+       if (buffer == NULL)
+               {
+               ECerr(EC_F_I2D_ECPRIVATEKEY,
+                      ERR_R_MALLOC_FAILURE);
+               goto err;
+               }
+       
+       if (!BN_bn2bin(a->priv_key, buffer))
+               {
+               ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_BN_LIB);
+               goto err;
+               }
+
+       if (!M_ASN1_OCTET_STRING_set(priv_key->privateKey, buffer, buf_len))
+               {
+               ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_ASN1_LIB);
+               goto err;
+               }       
+
+       if (!(a->enc_flag & EC_PKEY_NO_PARAMETERS))
+               {
+               if ((priv_key->parameters = ec_asn1_group2pkparameters(
+                       a->group, priv_key->parameters)) == NULL)
+                       {
+                       ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
+                       goto err;
+                       }
+               }
+
+       if (!(a->enc_flag & EC_PKEY_NO_PUBKEY))
+               {
+               priv_key->publicKey = M_ASN1_BIT_STRING_new();
+               if (priv_key->publicKey == NULL)
+                       {
+                       ECerr(EC_F_I2D_ECPRIVATEKEY,
+                               ERR_R_MALLOC_FAILURE);
+                       goto err;
+                       }
+
+               tmp_len = EC_POINT_point2oct(a->group, a->pub_key, 
+                               a->conv_form, NULL, 0, NULL);
+
+               if (tmp_len > buf_len)
+                       buffer = OPENSSL_realloc(buffer, tmp_len);
+               if (buffer == NULL)
+                       {
+                       ECerr(EC_F_I2D_ECPRIVATEKEY,
+                               ERR_R_MALLOC_FAILURE);
+                       goto err;
+                       }
+
+               buf_len = tmp_len;
+
+               if (!EC_POINT_point2oct(a->group, a->pub_key, 
+                       a->conv_form, buffer, buf_len, NULL))
+                       {
+                       ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
+                       goto err;
+                       }
+
+               if (!M_ASN1_BIT_STRING_set(priv_key->publicKey, buffer, 
+                               buf_len))
+                       {
+                       ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_ASN1_LIB);
+                       goto err;
+                       }
+               }
+
+       if ((ret = i2d_EC_PRIVATEKEY(priv_key, out)) == 0)
+               {
+               ECerr(EC_F_I2D_ECPRIVATEKEY, ERR_R_EC_LIB);
+               goto err;
+               }
+       ok=1;
+err:
+       if (buffer)
+               OPENSSL_free(buffer);
+       if (priv_key)
+               EC_PRIVATEKEY_free(priv_key);
+       return(ok?ret:0);
+       }
+
+int i2d_ECParameters(EC_KEY *a, unsigned char **out)
+       {
+       if (a == NULL)
+               {
+               ECerr(EC_F_I2D_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
                return 0;
                }
-       if ((ret = i2d_ECPKPARAMETERS(tmp, out)) == 0)
+       return i2d_ECPKParameters(a->group, out);
+       }
+
+EC_KEY *d2i_ECParameters(EC_KEY **a, const unsigned char **in, long len)
+       {
+       EC_GROUP *group;
+       EC_KEY   *ret;
+
+       if (in == NULL || *in == NULL)
                {
-               ECerr(EC_F_I2D_ECPKPARAMETERS, EC_R_I2D_ECPKPARAMETERS_FAILURE);
-               ECPKPARAMETERS_free(tmp);
+               ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_PASSED_NULL_PARAMETER);
+               return NULL;
+               }
+
+       group = d2i_ECPKParameters(NULL, in, len);
+
+       if (group == NULL)
+               {
+               ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_EC_LIB);
+               return NULL;
+               }
+
+       if (a == NULL || *a == NULL)
+               {
+               if ((ret = EC_KEY_new()) == NULL)
+                       {
+                       ECerr(EC_F_D2I_ECPARAMETERS, ERR_R_MALLOC_FAILURE);
+                       return NULL;
+                       }
+               if (a)
+                       *a = ret;
+               }
+       else
+               ret = *a;
+
+       if (ret->group)
+               EC_GROUP_clear_free(ret->group);
+
+       ret->group = group;
+       
+       return ret;
+       }
+
+EC_KEY *o2i_ECPublicKey(EC_KEY **a, const unsigned char **in, long len)
+       {
+       EC_KEY *ret=NULL;
+
+       if (a == NULL || (*a) == NULL || (*a)->group == NULL)
+               {
+               /* sorry, but a EC_GROUP-structur is necessary
+                 * to set the public key */
+               ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER);
                return 0;
-               }       
-       ECPKPARAMETERS_free(tmp);
-       return(ret);
+               }
+       ret = *a;
+       if (ret->pub_key == NULL && 
+               (ret->pub_key = EC_POINT_new(ret->group)) == NULL)
+               {
+               ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_MALLOC_FAILURE);
+               return 0;
+               }
+       if (!EC_POINT_oct2point(ret->group, ret->pub_key, *in, len, NULL))
+               {
+               ECerr(EC_F_O2I_ECPUBLICKEY, ERR_R_EC_LIB);
+               return 0;
+               }
+       /* save the point conversion form */
+       ret->conv_form = (point_conversion_form_t)(*in[0] & ~0x01);
+       *in += len;
+       return ret;
+       }
+
+int i2o_ECPublicKey(EC_KEY *a, unsigned char **out)
+       {
+        size_t buf_len=0;
+       int new_buffer = 0;
+
+        if (a == NULL) 
+               {
+               ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_PASSED_NULL_PARAMETER);
+               return 0;
+               }
+
+        buf_len = EC_POINT_point2oct(a->group, a->pub_key, 
+                              a->conv_form, NULL, 0, NULL);
+
+       if (out == NULL || buf_len == 0)
+       /* out == NULL => just return the length of the octet string */
+               return buf_len;
+
+       if (*out == NULL)
+               {
+               if ((*out = OPENSSL_malloc(buf_len)) == NULL)
+                       {
+                       ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_MALLOC_FAILURE);
+                       return 0;
+                       }
+               new_buffer = 1;
+               }
+        if (!EC_POINT_point2oct(a->group, a->pub_key, a->conv_form,
+                               *out, buf_len, NULL))
+               {
+               ECerr(EC_F_I2O_ECPUBLICKEY, ERR_R_EC_LIB);
+               OPENSSL_free(*out);
+               *out = NULL;
+               return 0;
+               }
+       if (!new_buffer)
+               *out += buf_len;
+       return buf_len;
        }