use a generic EC_KEY structure (EC keys are not ECDSA specific)

Submitted by: Nils Larsch

4 files changed, 127 insertions, 109 deletions

diff --git a/crypto/evp/evp.h b/crypto/evp/evp.h
index 1a679d5e20..e4d60eeb4d 100644
--- a/crypto/evp/evp.h
+++ b/crypto/evp/evp.h
@@ -168,7 +168,8 @@
 #define EVP_PKEY_DSA3	NID_dsaWithSHA1
 #define EVP_PKEY_DSA4	NID_dsaWithSHA1_2
 #define EVP_PKEY_DH	NID_dhKeyAgreement
-#define EVP_PKEY_ECDSA	NID_X9_62_id_ecPublicKey
+#define EVP_PKEY_EC	NID_X9_62_id_ecPublicKey
+#define EVP_PKEY_ECDSA	EVP_PKEY_EC
 
 #ifdef	__cplusplus
 extern "C" {
@@ -193,8 +194,8 @@ struct evp_pkey_st
 #ifndef OPENSSL_NO_DH
 		struct dh_st *dh;	/* DH */
 #endif
-#ifndef OPENSSL_NO_ECDSA
-		struct ecdsa_st *ecdsa;	/* ECDSA */
+#ifndef OPENSSL_NO_EC
+		struct ec_key_st *eckey;/* ECC */
 #endif
 		} pkey;
 	int save_parameters;
@@ -454,9 +455,9 @@ typedef int (EVP_PBE_KEYGEN)(EVP_CIPHER_CTX *ctx, const char *pass, int passlen,
 					(char *)(dh))
 #endif
 
-#ifndef OPENSSL_NO_ECDSA
-#define EVP_PKEY_assign_ECDSA(pkey,ecdsa) EVP_PKEY_assign((pkey),EVP_PKEY_ECDSA,\
-                                        (char *)(ecdsa))
+#ifndef OPENSSL_NO_EC
+#define EVP_PKEY_assign_EC_KEY(pkey,eckey) EVP_PKEY_assign((pkey),EVP_PKEY_EC,\
+                                        (char *)(eckey))
 #endif
 
 /* Add some extra combinations */
@@ -785,10 +786,10 @@ struct dh_st;
 int EVP_PKEY_set1_DH(EVP_PKEY *pkey,struct dh_st *key);
 struct dh_st *EVP_PKEY_get1_DH(EVP_PKEY *pkey);
 #endif
-#ifndef OPENSSL_NO_ECDSA
-struct ecdsa_st;
-int EVP_PKEY_set1_ECDSA(EVP_PKEY *pkey,struct ecdsa_st *key);
-struct ecdsa_st *EVP_PKEY_get1_ECDSA(EVP_PKEY *pkey);
+#ifndef OPENSSL_NO_EC
+struct ec_key_st;
+int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey,struct ec_key_st *key);
+struct ec_key_st *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey);
 #endif
 
 EVP_PKEY *	EVP_PKEY_new(void);
@@ -848,6 +849,7 @@ void ERR_load_EVP_strings(void);
 /* Function codes. */
 #define EVP_F_D2I_PKEY					 100
 #define EVP_F_ECDSA_PKEY2PKCS8				 129
+#define EVP_F_EC_KEY_PKEY2PKCS8				 132
 #define EVP_F_EVP_CIPHERINIT				 123
 #define EVP_F_EVP_CIPHER_CTX_CTRL			 124
 #define EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH		 122
@@ -867,6 +869,7 @@ void ERR_load_EVP_strings(void);
 #define EVP_F_EVP_PKEY_GET1_DH				 119
 #define EVP_F_EVP_PKEY_GET1_DSA				 120
 #define EVP_F_EVP_PKEY_GET1_ECDSA			 130
+#define EVP_F_EVP_PKEY_GET1_EC_KEY			 131
 #define EVP_F_EVP_PKEY_GET1_RSA				 121
 #define EVP_F_EVP_PKEY_NEW				 106
 #define EVP_F_EVP_RIJNDAEL				 126
@@ -896,6 +899,7 @@ void ERR_load_EVP_strings(void);
 #define EVP_R_EXPECTING_A_DH_KEY			 128
 #define EVP_R_EXPECTING_A_DSA_KEY			 129
 #define EVP_R_EXPECTING_A_ECDSA_KEY			 141
+#define EVP_R_EXPECTING_A_EC_KEY			 142
 #define EVP_R_INITIALIZATION_ERROR			 134
 #define EVP_R_INPUT_NOT_INITIALIZED			 111
 #define EVP_R_INVALID_KEY_LENGTH			 130
diff --git a/crypto/evp/evp_err.c b/crypto/evp/evp_err.c
index e6c71d4e01..815ce63b3b 100644
--- a/crypto/evp/evp_err.c
+++ b/crypto/evp/evp_err.c
@@ -1,6 +1,6 @@
 /* crypto/evp/evp_err.c */
 /* ====================================================================
- * Copyright (c) 1999 The OpenSSL Project.  All rights reserved.
+ * Copyright (c) 1999-2002 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
@@ -68,6 +68,7 @@ static ERR_STRING_DATA EVP_str_functs[]=
 	{
 {ERR_PACK(0,EVP_F_D2I_PKEY,0),	"D2I_PKEY"},
 {ERR_PACK(0,EVP_F_ECDSA_PKEY2PKCS8,0),	"ECDSA_PKEY2PKCS8"},
+{ERR_PACK(0,EVP_F_EC_KEY_PKEY2PKCS8,0),	"EC_KEY_PKEY2PKCS8"},
 {ERR_PACK(0,EVP_F_EVP_CIPHERINIT,0),	"EVP_CipherInit"},
 {ERR_PACK(0,EVP_F_EVP_CIPHER_CTX_CTRL,0),	"EVP_CIPHER_CTX_ctrl"},
 {ERR_PACK(0,EVP_F_EVP_CIPHER_CTX_SET_KEY_LENGTH,0),	"EVP_CIPHER_CTX_set_key_length"},
@@ -86,7 +87,8 @@ static ERR_STRING_DATA EVP_str_functs[]=
 {ERR_PACK(0,EVP_F_EVP_PKEY_ENCRYPT,0),	"EVP_PKEY_encrypt"},
 {ERR_PACK(0,EVP_F_EVP_PKEY_GET1_DH,0),	"EVP_PKEY_get1_DH"},
 {ERR_PACK(0,EVP_F_EVP_PKEY_GET1_DSA,0),	"EVP_PKEY_get1_DSA"},
-{ERR_PACK(0,EVP_F_EVP_PKEY_GET1_ECDSA,0),	"EVP_PKEY_get1_ECDSA"},
+{ERR_PACK(0,EVP_F_EVP_PKEY_GET1_ECDSA,0),	"EVP_PKEY_GET1_ECDSA"},
+{ERR_PACK(0,EVP_F_EVP_PKEY_GET1_EC_KEY,0),	"EVP_PKEY_get1_EC_KEY"},
 {ERR_PACK(0,EVP_F_EVP_PKEY_GET1_RSA,0),	"EVP_PKEY_get1_RSA"},
 {ERR_PACK(0,EVP_F_EVP_PKEY_NEW,0),	"EVP_PKEY_new"},
 {ERR_PACK(0,EVP_F_EVP_RIJNDAEL,0),	"EVP_RIJNDAEL"},
@@ -119,6 +121,7 @@ static ERR_STRING_DATA EVP_str_reasons[]=
 {EVP_R_EXPECTING_A_DH_KEY                ,"expecting a dh key"},
 {EVP_R_EXPECTING_A_DSA_KEY               ,"expecting a dsa key"},
 {EVP_R_EXPECTING_A_ECDSA_KEY             ,"expecting a ecdsa key"},
+{EVP_R_EXPECTING_A_EC_KEY                ,"expecting a ec key"},
 {EVP_R_INITIALIZATION_ERROR              ,"initialization error"},
 {EVP_R_INPUT_NOT_INITIALIZED             ,"input not initialized"},
 {EVP_R_INVALID_KEY_LENGTH                ,"invalid key length"},
diff --git a/crypto/evp/evp_pkey.c b/crypto/evp/evp_pkey.c
index 1772647b16..25f920201f 100644
--- a/crypto/evp/evp_pkey.c
+++ b/crypto/evp/evp_pkey.c
@@ -65,8 +65,8 @@
 #ifndef OPENSSL_NO_DSA
 static int dsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8inf, EVP_PKEY *pkey);
 #endif
-#ifndef OPENSSL_NO_ECDSA
-static int ecdsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8inf, EVP_PKEY *pkey);
+#ifndef OPENSSL_NO_EC
+static int eckey_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8inf, EVP_PKEY *pkey);
 #endif
 
 /* Extract a private key from a PKCS8 structure */
@@ -80,8 +80,8 @@ EVP_PKEY *EVP_PKCS82PKEY (PKCS8_PRIV_KEY_INFO *p8)
 #ifndef OPENSSL_NO_DSA
 	DSA *dsa = NULL;
 #endif
-#ifndef OPENSSL_NO_ECDSA
-	ECDSA    *ecdsa = NULL;
+#ifndef OPENSSL_NO_EC
+	EC_KEY *eckey = NULL;
 #endif
 #if !defined(OPENSSL_NO_DSA) || !defined(OPENSSL_NO_ECDSA)
 	ASN1_INTEGER *privkey;
@@ -236,34 +236,37 @@ EVP_PKEY *EVP_PKCS82PKEY (PKCS8_PRIV_KEY_INFO *p8)
 		else /* nid == NID_ecdsa_with_SHA1 */
 		{
 #ifndef OPENSSL_NO_ECDSA
-			if ((ecdsa = d2i_ECDSAParameters(NULL, &cp, plen)) == NULL)
+			if ((eckey = d2i_ECParameters(NULL, &cp, 
+				plen)) == NULL)
 			{
 				EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
 				goto err;
 			}
-			if ((ecdsa->priv_key = ASN1_INTEGER_to_BN(privkey, NULL)) == NULL)
+			if ((eckey->priv_key = ASN1_INTEGER_to_BN(privkey, 
+				NULL)) == NULL)
 			{
 				EVPerr(EVP_F_EVP_PKCS82PKEY, EVP_R_DECODE_ERROR);
 				goto err;
 			}
-			if ((ecdsa->pub_key = EC_POINT_new(ecdsa->group)) == NULL)
+			if ((eckey->pub_key = EC_POINT_new(eckey->group)) == NULL)
 			{
 				EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
 				goto err;
 			}
-			if (!EC_POINT_copy(ecdsa->pub_key, EC_GROUP_get0_generator(ecdsa->group)))
+			if (!EC_POINT_copy(eckey->pub_key, 
+				EC_GROUP_get0_generator(eckey->group)))
 			{
 				EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
 				goto err;
 			}
-			if (!EC_POINT_mul(ecdsa->group, ecdsa->pub_key, ecdsa->priv_key,
-					  NULL, NULL, ctx))
+			if (!EC_POINT_mul(eckey->group, eckey->pub_key, 
+				eckey->priv_key, NULL, NULL, ctx))
 			{
 				EVPerr(EVP_F_EVP_PKCS82PKEY, ERR_R_EC_LIB);
 				goto err;
 			}
 			
-			EVP_PKEY_assign_ECDSA(pkey, ecdsa);
+			EVP_PKEY_assign_EC_KEY(pkey, eckey);
 			BN_CTX_free(ctx);
 			if (n_stack) sk_ASN1_TYPE_pop_free(n_stack, ASN1_TYPE_free);
 			else
@@ -280,8 +283,9 @@ err:
 #ifndef OPENSSL_NO_DSA
 		if (dsa)   DSA_free(dsa);
 #endif
-#ifndef OPENSSL_NO_ECDSA
-		if (ecdsa) ECDSA_free(ecdsa);
+#ifndef OPENSSL_NO_EC
+		if (eckey) 
+			EC_KEY_free(eckey);
 #endif
 		if (pkey)  EVP_PKEY_free(pkey);
 		return NULL;
@@ -348,7 +352,7 @@ PKCS8_PRIV_KEY_INFO *EVP_PKEY2PKCS8_broken(EVP_PKEY *pkey, int broken)
 #endif
 #ifndef OPENSSL_NO_ECDSA
 		case EVP_PKEY_ECDSA:
-		if (!ecdsa_pkey2pkcs8(p8, pkey))
+		if (!eckey_pkey2pkcs8(p8, pkey))
 		{
 			PKCS8_PRIV_KEY_INFO_free(p8);
 			return(NULL);
@@ -499,53 +503,54 @@ static int dsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey)
 }
 #endif
 
-#ifndef OPENSSL_NO_ECDSA
-static int ecdsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey)
+#ifndef OPENSSL_NO_EC
+static int eckey_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey)
 {
 	ASN1_STRING 	  *params=NULL;
 	ASN1_INTEGER      *prkey=NULL;
 	ASN1_TYPE         *ttmp=NULL;
-	STACK_OF(ASN1_TYPE) *necdsa=NULL;
+	STACK_OF(ASN1_TYPE) *neckey=NULL;
 	unsigned char 	  *p=NULL, *q=NULL;
 	int len=0;
 	EC_POINT	  *point=NULL;
 
-	if (pkey->pkey.ecdsa == NULL || pkey->pkey.ecdsa->group == NULL)
+	if (pkey->pkey.eckey == NULL || pkey->pkey.eckey->group == NULL)
 	{
-		EVPerr(EVP_F_ECDSA_PKEY2PKCS8, EVP_R_MISSING_PARAMETERS);
+		EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, EVP_R_MISSING_PARAMETERS);
 		return 0;
 	}
 	p8->pkeyalg->algorithm = OBJ_nid2obj(NID_ecdsa_with_SHA1);
-	len = i2d_ECDSAParameters(pkey->pkey.ecdsa, NULL);
+	len = i2d_ECParameters(pkey->pkey.eckey, NULL);
 	if ((p = OPENSSL_malloc(len)) == NULL)
 	{
-		EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+		EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
 		return 0;
 	}
 	q = p;
-	if (!i2d_ECDSAParameters(pkey->pkey.ecdsa, &q))
+	if (!i2d_ECParameters(pkey->pkey.eckey, &q))
 	{
-		EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_ECDSA_LIB);
+		EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_ECDSA_LIB);
 		OPENSSL_free(p);
 		return 0;
 	}
 	if ((params = ASN1_STRING_new()) == NULL)
 	{
-		EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+		EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
 		OPENSSL_free(p);
 		return 0;
 		
 	}
 	if (!ASN1_STRING_set(params, p, len))
 	{
-		EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_ASN1_LIB);
+		EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_ASN1_LIB);
 		OPENSSL_free(p);
 		return 0;
 	}
 	OPENSSL_free(p);
-	if ((prkey = BN_to_ASN1_INTEGER(pkey->pkey.ecdsa->priv_key, NULL)) == NULL)
+	if ((prkey = BN_to_ASN1_INTEGER(pkey->pkey.eckey->priv_key, NULL)) 
+		== NULL)
 	{
-		EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_ASN1_LIB);
+		EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_ASN1_LIB);
 		return 0;
 	}
 
@@ -557,7 +562,7 @@ static int ecdsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey)
 		if (!ASN1_pack_string((char *)prkey, i2d_ASN1_INTEGER,
 					 &p8->pkey->value.octet_string)) 
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
 			M_ASN1_INTEGER_free(prkey);
 			return 0;
 		}
@@ -572,134 +577,137 @@ static int ecdsa_pkey2pkcs8(PKCS8_PRIV_KEY_INFO *p8, EVP_PKEY *pkey)
 
 		p8->pkeyalg->parameter->value.sequence = params;
 		p8->pkeyalg->parameter->type = V_ASN1_SEQUENCE;
-		necdsa = sk_ASN1_TYPE_new_null();
-		if (necdsa == NULL || (ttmp = ASN1_TYPE_new()) == NULL)
+		neckey = sk_ASN1_TYPE_new_null();
+		if (neckey == NULL || (ttmp = ASN1_TYPE_new()) == NULL)
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			return 0;
 		}
 
-		if ((point = EC_GROUP_get0_generator(pkey->pkey.ecdsa->group)) == NULL)
+		if ((point = EC_GROUP_get0_generator(pkey->pkey.eckey->group)) 
+			== NULL)
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_EC_LIB);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_EC_LIB);
 			return 0;
 		}
-		len = EC_POINT_point2oct(pkey->pkey.ecdsa->group, point, ECDSA_get_conversion_form(pkey->pkey.ecdsa),
-				         NULL, 0, NULL);
+		len = EC_POINT_point2oct(pkey->pkey.eckey->group, point, 
+			pkey->pkey.eckey->conv_form, NULL, 0, NULL);
 		p = OPENSSL_malloc(len);
-		if (!len || !p || !EC_POINT_point2oct(pkey->pkey.ecdsa->group, point,
-			ECDSA_get_conversion_form(pkey->pkey.ecdsa), p, len, NULL))
+		if (!len || !p || !EC_POINT_point2oct(pkey->pkey.eckey->group, 
+			point, pkey->pkey.eckey->conv_form, p, len, NULL))
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_EC_LIB);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_EC_LIB);
 			OPENSSL_free(p);
 			return 0;
 		}
-		if ((ttmp->value.octet_string = ASN1_OCTET_STRING_new()) == NULL)
+		if ((ttmp->value.octet_string =ASN1_OCTET_STRING_new()) == NULL)
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
 			return 0;
 		}
 		if (!ASN1_OCTET_STRING_set(ttmp->value.octet_string, p, len))
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, EVP_R_ASN1_LIB);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, EVP_R_ASN1_LIB);
 			return 0;
 		}
 		OPENSSL_free(p);
 		
 		ttmp->type = V_ASN1_OCTET_STRING;
-		if (!sk_ASN1_TYPE_push(necdsa, ttmp))
+		if (!sk_ASN1_TYPE_push(neckey, ttmp))
 		{
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			ASN1_INTEGER_free(prkey);
 			return 0;
 		}
 
 		if ((ttmp = ASN1_TYPE_new()) == NULL)
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
 			return 0;
 		}
 		ttmp->value.integer = prkey;
 		ttmp->type = V_ASN1_INTEGER;
-		if (!sk_ASN1_TYPE_push(necdsa, ttmp))
+		if (!sk_ASN1_TYPE_push(neckey, ttmp))
 		{
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			ASN1_INTEGER_free(prkey);
 			return 0;
 		}
 
-		if ((p8->pkey->value.octet_string = ASN1_OCTET_STRING_new()) == NULL)
+		if ((p8->pkey->value.octet_string = ASN1_OCTET_STRING_new()) 
+			== NULL)
 		{	
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			return 0;
 		}
 
-		if (!ASN1_seq_pack_ASN1_TYPE(necdsa, i2d_ASN1_TYPE,
+		if (!ASN1_seq_pack_ASN1_TYPE(neckey, i2d_ASN1_TYPE,
 					 &p8->pkey->value.octet_string->data,
 					 &p8->pkey->value.octet_string->length)) 
 		{
 
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			return 0;
 		}
-		sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+		sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 		break;
 
 		case PKCS8_EMBEDDED_PARAM:
 
 		p8->pkeyalg->parameter->type = V_ASN1_NULL;
-		necdsa = sk_ASN1_TYPE_new_null();
+		neckey = sk_ASN1_TYPE_new_null();
 		if ((ttmp = ASN1_TYPE_new()) == NULL)
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			ASN1_INTEGER_free(prkey);
 			return 0;
 		}
 		ttmp->value.sequence = params;
 		ttmp->type = V_ASN1_SEQUENCE;
-		if (!sk_ASN1_TYPE_push(necdsa, ttmp))
+		if (!sk_ASN1_TYPE_push(neckey, ttmp))
 		{
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			ASN1_INTEGER_free(prkey);
 			return 0;
 		}
 
 		if ((ttmp = ASN1_TYPE_new()) == NULL)
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			ASN1_INTEGER_free(prkey);
 			return 0;
 		}
 		ttmp->value.integer = prkey;
 		ttmp->type = V_ASN1_INTEGER;
-		if (!sk_ASN1_TYPE_push(necdsa, ttmp))
+		if (!sk_ASN1_TYPE_push(neckey, ttmp))
 		{
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			ASN1_INTEGER_free(prkey);
 			return 0;
 		}
 
-		if ((p8->pkey->value.octet_string = ASN1_OCTET_STRING_new()) == NULL)
+		if ((p8->pkey->value.octet_string = ASN1_OCTET_STRING_new()) 
+			== NULL)
 		{
-			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			EVPerr(EVP_F_EC_KEY_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			return 0;
 		}
 
-		if (!ASN1_seq_pack_ASN1_TYPE(necdsa, i2d_ASN1_TYPE,
+		if (!ASN1_seq_pack_ASN1_TYPE(neckey, i2d_ASN1_TYPE,
 					 &p8->pkey->value.octet_string->data,
 					 &p8->pkey->value.octet_string->length)) 
 		{
 			EVPerr(EVP_F_ECDSA_PKEY2PKCS8, ERR_R_MALLOC_FAILURE);
-			sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+			sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 			return 0;
 		}
-		sk_ASN1_TYPE_pop_free(necdsa, ASN1_TYPE_free);
+		sk_ASN1_TYPE_pop_free(neckey, ASN1_TYPE_free);
 		break;
 	}
 	return 1;
diff --git a/crypto/evp/p_lib.c b/crypto/evp/p_lib.c
index fcb5711753..ac0556b488 100644
--- a/crypto/evp/p_lib.c
+++ b/crypto/evp/p_lib.c
@@ -79,8 +79,8 @@ int EVP_PKEY_bits(EVP_PKEY *pkey)
 	else if (pkey->type == EVP_PKEY_DSA)
 		return(BN_num_bits(pkey->pkey.dsa->p));
 #endif
-#ifndef OPENSSL_NO_ECDSA
-	else if (pkey->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+	else if (pkey->type == EVP_PKEY_EC)
 		{
 		BIGNUM *order = BN_new();
 		int ret;
@@ -90,7 +90,7 @@ int EVP_PKEY_bits(EVP_PKEY *pkey)
 			ERR_clear_error();
 			return 0;
 			}
-		if (!EC_GROUP_get_order(pkey->pkey.ecdsa->group, order, NULL))
+		if (!EC_GROUP_get_order(pkey->pkey.eckey->group, order, NULL))
 			{
 			ERR_clear_error();
 			return 0;
@@ -117,9 +117,9 @@ int EVP_PKEY_size(EVP_PKEY *pkey)
 		if (pkey->type == EVP_PKEY_DSA)
 		return(DSA_size(pkey->pkey.dsa));
 #endif
-#ifndef OPENSSL_NO_ECDSA
-		if (pkey->type == EVP_PKEY_ECDSA)
-		return(ECDSA_size(pkey->pkey.ecdsa));
+#ifndef OPENSSL_NO_EC
+		if (pkey->type == EVP_PKEY_EC)
+		return(ECDSA_size(pkey->pkey.eckey));
 #endif
 
 	return(0);
@@ -181,13 +181,16 @@ int EVP_PKEY_copy_parameters(EVP_PKEY *to, EVP_PKEY *from)
 		to->pkey.dsa->g=a;
 		}
 #endif
-#ifndef OPENSSL_NO_ECDSA
+#ifndef OPENSSL_NO_EC
 	if (to->type == EVP_PKEY_ECDSA)
 		{
-		if (to->pkey.ecdsa->group != NULL)
-			EC_GROUP_free(to->pkey.ecdsa->group);
-		if ((to->pkey.ecdsa->group = EC_GROUP_new(EC_GROUP_method_of(from->pkey.ecdsa->group))) == NULL) goto err;
-		if (!EC_GROUP_copy(to->pkey.ecdsa->group,from->pkey.ecdsa->group)) goto err;
+		if (to->pkey.eckey->group != NULL)
+			EC_GROUP_free(to->pkey.eckey->group);
+		if ((to->pkey.eckey->group = EC_GROUP_new(
+			EC_GROUP_method_of(from->pkey.eckey->group))) == NULL) 
+			goto err;
+		if (!EC_GROUP_copy(to->pkey.eckey->group,
+			from->pkey.eckey->group)) goto err;
 		}
 #endif
 	return(1);
@@ -207,10 +210,10 @@ int EVP_PKEY_missing_parameters(EVP_PKEY *pkey)
 			return(1);
 		}
 #endif
-#ifndef OPENSSL_NO_ECDSA
-	if (pkey->type == EVP_PKEY_ECDSA)
+#ifndef OPENSSL_NO_EC
+	if (pkey->type == EVP_PKEY_EC)
 		{
-		if (pkey->pkey.ecdsa->group == NULL)
+		if (pkey->pkey.eckey->group == NULL)
 			return(1);
 		}
 #endif
@@ -303,24 +306,24 @@ DSA *EVP_PKEY_get1_DSA(EVP_PKEY *pkey)
 }
 #endif
 
-#ifndef OPENSSL_NO_ECDSA
+#ifndef OPENSSL_NO_EC
 
-int EVP_PKEY_set1_ECDSA(EVP_PKEY *pkey, ECDSA *key)
+int EVP_PKEY_set1_EC_KEY(EVP_PKEY *pkey, EC_KEY *key)
 {
-	int ret = EVP_PKEY_assign_ECDSA(pkey,key);
-	if (ret) CRYPTO_add(&key->references, 1,CRYPTO_LOCK_ECDSA);
+	int ret = EVP_PKEY_assign_EC_KEY(pkey,key);
+	if (ret) CRYPTO_add(&key->references, 1, CRYPTO_LOCK_EC);
 		return ret;
 }
 
-ECDSA *EVP_PKEY_get1_ECDSA(EVP_PKEY *pkey)
+EC_KEY *EVP_PKEY_get1_EC_KEY(EVP_PKEY *pkey)
 {
-	if (pkey->type != EVP_PKEY_ECDSA)
+	if (pkey->type != EVP_PKEY_EC)
 	{
-		EVPerr(EVP_F_EVP_PKEY_GET1_ECDSA, EVP_R_EXPECTING_A_ECDSA_KEY);
+		EVPerr(EVP_F_EVP_PKEY_GET1_EC_KEY, EVP_R_EXPECTING_A_EC_KEY);
 		return NULL;
 	}
-	CRYPTO_add(&pkey->pkey.ecdsa->references, 1, CRYPTO_LOCK_ECDSA);
-	return pkey->pkey.ecdsa;
+	CRYPTO_add(&pkey->pkey.eckey->references, 1, CRYPTO_LOCK_EC);
+	return pkey->pkey.eckey;
 }
 #endif
 
@@ -361,8 +364,8 @@ int EVP_PKEY_type(int type)
 		return(EVP_PKEY_DSA);
 	case EVP_PKEY_DH:
 		return(EVP_PKEY_DH);
-	case EVP_PKEY_ECDSA:
-		return(EVP_PKEY_ECDSA);
+	case EVP_PKEY_EC:
+		return(EVP_PKEY_EC);
 	default:
 		return(NID_undef);
 		}
@@ -408,9 +411,9 @@ static void EVP_PKEY_free_it(EVP_PKEY *x)
 		DSA_free(x->pkey.dsa);
 		break;
 #endif
-#ifndef OPENSSL_NO_ECDSA
-	case EVP_PKEY_ECDSA:
-		ECDSA_free(x->pkey.ecdsa);
+#ifndef OPENSSL_NO_EC
+	case EVP_PKEY_EC:
+		EC_KEY_free(x->pkey.eckey);
 		break;
 #endif
 #ifndef OPENSSL_NO_DH