1 files changed, 70 insertions, 21 deletions

diff --git a/src/lib/libcrypto/ec/ec_key.c b/src/lib/libcrypto/ec/ec_key.c
index fcdf461d20..f57e078c7f 100644
--- a/src/lib/libcrypto/ec/ec_key.c
+++ b/src/lib/libcrypto/ec/ec_key.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: ec_key.c,v 1.22 2018/11/09 23:39:45 tb Exp $ */
+/* $OpenBSD: ec_key.c,v 1.23 2019/01/19 01:07:00 tb Exp $ */
 /*
  * Written by Nils Larsch for the OpenSSL project.
  */
@@ -65,30 +65,18 @@
 
 #include <openssl/opensslconf.h>
 
+#ifndef OPENSSL_NO_ENGINE
+#include <openssl/engine.h>
+#endif
+#include <openssl/err.h>
+
 #include "bn_lcl.h"
 #include "ec_lcl.h"
-#include <openssl/err.h>
 
 EC_KEY *
 EC_KEY_new(void)
 {
-        EC_KEY *ret;
-
-        ret = malloc(sizeof(EC_KEY));
-        if (ret == NULL) {
-                ECerror(ERR_R_MALLOC_FAILURE);
-                return (NULL);
-        }
-        ret->version = 1;
-        ret->flags = 0;
-        ret->group = NULL;
-        ret->pub_key = NULL;
-        ret->priv_key = NULL;
-        ret->enc_flag = 0;
-        ret->conv_form = POINT_CONVERSION_UNCOMPRESSED;
-        ret->references = 1;
-        ret->method_data = NULL;
-        return (ret);
+        return EC_KEY_new_method(NULL);
 }
 
 EC_KEY *
@@ -102,6 +90,11 @@ EC_KEY_new_by_curve_name(int nid)
                 EC_KEY_free(ret);
                 return NULL;
         }
+        if (ret->meth->set_group != NULL &&
+            ret->meth->set_group(ret, ret->group) == 0) {
+                EC_KEY_free(ret);
+                return NULL;
+        }
         return ret;
 }
 
@@ -117,6 +110,14 @@ EC_KEY_free(EC_KEY * r)
         if (i > 0)
                 return;
 
+        if (r->meth != NULL && r->meth->finish != NULL)
+                r->meth->finish(r);
+
+#ifndef OPENSSL_NO_ENGINE
+        ENGINE_finish(r->engine);
+#endif
+        CRYPTO_free_ex_data(CRYPTO_EX_INDEX_EC_KEY, r, &r->ex_data);
+
         EC_GROUP_free(r->group);
         EC_POINT_free(r->pub_key);
         BN_clear_free(r->priv_key);
@@ -135,6 +136,15 @@ EC_KEY_copy(EC_KEY * dest, const EC_KEY * src)
                 ECerror(ERR_R_PASSED_NULL_PARAMETER);
                 return NULL;
         }
+        if (src->meth != dest->meth) {
+                if (dest->meth != NULL && dest->meth->finish != NULL)
+                        dest->meth->finish(dest);
+#ifndef OPENSSL_NO_ENGINE
+                if (ENGINE_finish(dest->engine) == 0)
+                        return 0;
+                dest->engine = NULL;
+#endif
+        }
         /* copy the parameters */
         if (src->group) {
                 const EC_METHOD *meth = EC_GROUP_method_of(src->group);
@@ -184,14 +194,32 @@ EC_KEY_copy(EC_KEY * dest, const EC_KEY * src)
         dest->version = src->version;
         dest->flags = src->flags;
 
+        if (!CRYPTO_dup_ex_data(CRYPTO_EX_INDEX_EC_KEY, &dest->ex_data,
+            &((EC_KEY *)src)->ex_data)) /* XXX const */
+                return NULL;
+
+        if (src->meth != dest->meth) {
+#ifndef OPENSSL_NO_ENGINE
+                if (src->engine != NULL && ENGINE_init(src->engine) == 0)
+                        return 0;
+                dest->engine = src->engine;
+#endif
+                dest->meth = src->meth;
+        }
+
+        if (src->meth != NULL && src->meth->copy != NULL &&
+            src->meth->copy(dest, src) == 0)
+                return 0;
+
         return dest;
 }
 
 EC_KEY *
 EC_KEY_dup(const EC_KEY * ec_key)
 {
-        EC_KEY *ret = EC_KEY_new();
-        if (ret == NULL)
+        EC_KEY *ret;
+
+        if ((ret = EC_KEY_new_method(ec_key->engine)) == NULL)
                 return NULL;
         if (EC_KEY_copy(ret, ec_key) == NULL) {
                 EC_KEY_free(ret);
@@ -207,6 +235,18 @@ EC_KEY_up_ref(EC_KEY * r)
         return ((i > 1) ? 1 : 0);
 }
 
+int
+EC_KEY_set_ex_data(EC_KEY *r, int idx, void *arg)
+{
+        return CRYPTO_set_ex_data(&r->ex_data, idx, arg);
+}
+
+void *
+EC_KEY_get_ex_data(const EC_KEY *r, int idx)
+{
+        return CRYPTO_get_ex_data(&r->ex_data, idx);
+}
+
 int 
 EC_KEY_generate_key(EC_KEY *eckey)
 {
@@ -407,6 +447,9 @@ EC_KEY_get0_group(const EC_KEY * key)
 int 
 EC_KEY_set_group(EC_KEY * key, const EC_GROUP * group)
 {
+        if (key->meth->set_group != NULL &&
+            key->meth->set_group(key, group) == 0)
+                return 0;
         EC_GROUP_free(key->group);
         key->group = EC_GROUP_dup(group);
         return (key->group == NULL) ? 0 : 1;
@@ -421,6 +464,9 @@ EC_KEY_get0_private_key(const EC_KEY * key)
 int 
 EC_KEY_set_private_key(EC_KEY * key, const BIGNUM * priv_key)
 {
+        if (key->meth->set_private != NULL &&
+            key->meth->set_private(key, priv_key) == 0)
+                return 0;
         BN_clear_free(key->priv_key);
         key->priv_key = BN_dup(priv_key);
         return (key->priv_key == NULL) ? 0 : 1;
@@ -435,6 +481,9 @@ EC_KEY_get0_public_key(const EC_KEY * key)
 int 
 EC_KEY_set_public_key(EC_KEY * key, const EC_POINT * pub_key)
 {
+        if (key->meth->set_public != NULL &&
+            key->meth->set_public(key, pub_key) == 0)
+                return 0;
         EC_POINT_free(key->pub_key);
         key->pub_key = EC_POINT_dup(pub_key, key->group);
         return (key->pub_key == NULL) ? 0 : 1;