X-Git-Url: http://wagner.pp.ru/gitweb/?a=blobdiff_plain;f=gost_ec_keyx.c;h=a95df330f2546b757566b20e02666ab99ee6267b;hb=3ae260799030954cd98730e4ff613af6b4ef6ae0;hp=a32f4fd979bd3a5def022fa97937206f0dfcb5d3;hpb=12be7c21781eba9f7a37762e7e307571225c6c47;p=openssl-gost%2Fengine.git

diff --git a/gost_ec_keyx.c b/gost_ec_keyx.c
index a32f4fd..a95df33 100644
--- a/gost_ec_keyx.c
+++ b/gost_ec_keyx.c
@@ -18,9 +18,10 @@
 #include "gost_lcl.h"
 
 /* Implementation of CryptoPro VKO 34.10-2001/2012 algorithm */
-static int VKO_compute_key(unsigned char *shared_key, size_t shared_key_size,
-                           const EC_POINT *pub_key, EC_KEY *priv_key,
-                           const unsigned char *ukm, int dgst_nid)
+static int VKO_compute_key(unsigned char *shared_key,
+                           const EC_POINT *pub_key, const EC_KEY *priv_key,
+                           const unsigned char *ukm, const size_t ukm_size,
+                           const int vko_dgst_nid)
 {
     unsigned char *databuf = NULL;
     BIGNUM *UKM = NULL, *p = NULL, *order = NULL, *X = NULL, *Y = NULL;
@@ -29,10 +30,7 @@ static int VKO_compute_key(unsigned char *shared_key, size_t shared_key_size,
     BN_CTX *ctx = BN_CTX_new();
     EVP_MD_CTX *mdctx = NULL;
     const EVP_MD *md = NULL;
-    int effective_dgst_nid = (dgst_nid == NID_id_GostR3411_2012_512) ?
-        NID_id_GostR3411_2012_256 : dgst_nid;
-    int buf_len = (dgst_nid == NID_id_GostR3411_2012_512) ? 128 : 64,
-        half_len = buf_len >> 1;
+    int buf_len, half_len;
     int ret = 0;
 
     if (!ctx) {
@@ -41,19 +39,13 @@ static int VKO_compute_key(unsigned char *shared_key, size_t shared_key_size,
     }
     BN_CTX_start(ctx);
 
-    databuf = OPENSSL_zalloc(buf_len);
-    if (!databuf) {
-        GOSTerr(GOST_F_VKO_COMPUTE_KEY, ERR_R_MALLOC_FAILURE);
-        goto err;
-    }
-
-    md = EVP_get_digestbynid(effective_dgst_nid);
+    md = EVP_get_digestbynid(vko_dgst_nid);
     if (!md) {
         GOSTerr(GOST_F_VKO_COMPUTE_KEY, GOST_R_INVALID_DIGEST_TYPE);
         goto err;
     }
 
-    UKM = hashsum2bn(ukm, 8);
+    UKM = hashsum2bn(ukm, ukm_size);
     p = BN_CTX_get(ctx);
     order = BN_CTX_get(ctx);
     X = BN_CTX_get(ctx);
@@ -64,8 +56,17 @@ static int VKO_compute_key(unsigned char *shared_key, size_t shared_key_size,
         GOSTerr(GOST_F_VKO_COMPUTE_KEY, GOST_R_ERROR_POINT_MUL);
         goto err;
     }
-    EC_POINT_get_affine_coordinates_GFp(EC_KEY_get0_group(priv_key),
+    EC_POINT_get_affine_coordinates(EC_KEY_get0_group(priv_key),
                                         pnt, X, Y, ctx);
+
+    half_len = BN_num_bytes(order);
+    buf_len = 2 * half_len;
+    databuf = OPENSSL_zalloc(buf_len);
+    if (!databuf) {
+        GOSTerr(GOST_F_VKO_COMPUTE_KEY, ERR_R_MALLOC_FAILURE);
+        goto err;
+    }
+
     /*
      * Serialize elliptic curve point same way as we do it when saving key
      */
@@ -83,7 +84,7 @@ static int VKO_compute_key(unsigned char *shared_key, size_t shared_key_size,
     EVP_DigestInit_ex(mdctx, md, NULL);
     EVP_DigestUpdate(mdctx, databuf, buf_len);
     EVP_DigestFinal_ex(mdctx, shared_key, NULL);
-    ret = 32;
+    ret = (EVP_MD_size(md) > 0) ? EVP_MD_size(md) : 0;
 
  err:
     BN_free(UKM);
@@ -99,6 +100,59 @@ static int VKO_compute_key(unsigned char *shared_key, size_t shared_key_size,
     return ret;
 }
 
+/*
+ * keyout expected to be 64 bytes
+ * */
+static int gost_keg(const unsigned char *ukm_source, int pkey_nid,
+                    const EC_POINT *pub_key, const EC_KEY *priv_key,
+                    unsigned char *keyout)
+{
+/* Adjust UKM */
+    unsigned char real_ukm[16];
+    size_t keylen = 0;
+
+    memset(real_ukm, 0, 16);
+    if (memcmp(ukm_source, real_ukm, 16) == 0)
+        real_ukm[15] = 1;
+    else {
+        memcpy(real_ukm, ukm_source, 16);
+        BUF_reverse(real_ukm, NULL, 16);
+    }
+
+    switch (pkey_nid) {
+    case NID_id_GostR3410_2012_512:
+        keylen =
+            VKO_compute_key(keyout, pub_key, priv_key, real_ukm, 16,
+                            NID_id_GostR3411_2012_512);
+        return (keylen) ? keylen : 0;
+        break;
+
+    case NID_id_GostR3410_2012_256:
+        {
+            unsigned char tmpkey[32];
+            keylen =
+              VKO_compute_key(tmpkey, pub_key, priv_key, real_ukm, 16,
+                  NID_id_GostR3411_2012_256);
+
+            if (keylen == 0)
+                return 0;
+
+            if (gost_kdftree2012_256
+                (keyout, 64, tmpkey, 32, (const unsigned char *)"kdf tree", 8,
+                 ukm_source + 16, 8, 1) > 0)
+                keylen = 64;
+            else
+                keylen = 0;
+
+            OPENSSL_cleanse(tmpkey, 32);
+            return (keylen) ? keylen : 0;
+            break;
+        }
+    default:
+        return 0;
+    }
+}
+
 /*
  * EVP_PKEY_METHOD callback derive.
  * Implements VKO R 34.10-2001/2012 algorithms
@@ -119,20 +173,52 @@ int pkey_gost_ec_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
         GOSTerr(GOST_F_PKEY_GOST_EC_DERIVE, GOST_R_UKM_NOT_SET);
         return 0;
     }
+    /*
+     * shared_ukm_size = 8 stands for pre-2018 cipher suites
+     * It means 32 bytes of key length, 8 byte UKM, 32-bytes hash
+     *
+     * shared_ukm_size = 32 stands for pre-2018 cipher suites
+     * It means 64 bytes of shared_key, 16 bytes of UKM and either
+     * 64 bytes of hash or 64 bytes of TLSTREE output
+     * */
 
-    if (key == NULL) {
-        *keylen = 32;
-        return 1;
-    }
+    switch (data->shared_ukm_size) {
+    case 8:
+        {
+            if (key == NULL) {
+                *keylen = 32;
+                return 1;
+            }
+
+            EVP_PKEY_get_default_digest_nid(my_key, &dgst_nid);
+            if (dgst_nid == NID_id_GostR3411_2012_512)
+                dgst_nid = NID_id_GostR3411_2012_256;
 
-    EVP_PKEY_get_default_digest_nid(my_key, &dgst_nid);
+            *keylen =
+                VKO_compute_key(key,
+                                EC_KEY_get0_public_key(EVP_PKEY_get0(peer_key)),
+                                (EC_KEY *)EVP_PKEY_get0(my_key),
+                                data->shared_ukm, 8, dgst_nid);
+            return (*keylen) ? 1 : 0;
+        }
+        break;
+    case 32:
+        {
+            if (key == NULL) {
+                *keylen = 64;
+                return 1;
+            }
+
+            *keylen = gost_keg(data->shared_ukm, EVP_PKEY_id(my_key),
+                               EC_KEY_get0_public_key(EVP_PKEY_get0(peer_key)),
+                               (EC_KEY *)EVP_PKEY_get0(my_key), key);
+            return (*keylen) ? 1 : 0;
+        }
 
-    *keylen =
-        VKO_compute_key(key, 32,
-                        EC_KEY_get0_public_key(EVP_PKEY_get0(peer_key)),
-                        (EC_KEY *)EVP_PKEY_get0(my_key), data->shared_ukm,
-                        dgst_nid);
-    return (*keylen) ? 1 : 0;
+        break;
+    default:
+        return 0;
+    }
 }
 
 /*
@@ -142,10 +228,10 @@ int pkey_gost_ec_derive(EVP_PKEY_CTX *ctx, unsigned char *key, size_t *keylen)
 
 /*
  * EVP_PKEY_METHOD callback encrypt
- * Implementation of GOST2001 key transport, cryptopo variation
+ * Implementation of GOST2001/12 key transport, cryptopro variation
  */
 
-int pkey_GOST_ECcp_encrypt(EVP_PKEY_CTX *pctx, unsigned char *out,
+static int pkey_GOST_ECcp_encrypt(EVP_PKEY_CTX *pctx, unsigned char *out,
                            size_t *out_len, const unsigned char *key,
                            size_t key_len)
 {
@@ -200,10 +286,12 @@ int pkey_GOST_ECcp_encrypt(EVP_PKEY_CTX *pctx, unsigned char *out,
     if (out) {
         int dgst_nid = NID_undef;
         EVP_PKEY_get_default_digest_nid(pubk, &dgst_nid);
+        if (dgst_nid == NID_id_GostR3411_2012_512)
+            dgst_nid = NID_id_GostR3411_2012_256;
 
-        if (!VKO_compute_key(shared_key, 32,
+        if (!VKO_compute_key(shared_key,
                              EC_KEY_get0_public_key(EVP_PKEY_get0(pubk)),
-                             EVP_PKEY_get0(sec_key), ukm, dgst_nid)) {
+                             EVP_PKEY_get0(sec_key), ukm, 8, dgst_nid)) {
             GOSTerr(GOST_F_PKEY_GOST_ECCP_ENCRYPT,
                     GOST_R_ERROR_COMPUTING_SHARED_KEY);
             goto err;
@@ -258,9 +346,128 @@ int pkey_GOST_ECcp_encrypt(EVP_PKEY_CTX *pctx, unsigned char *out,
 
 /*
  * EVP_PKEY_METHOD callback decrypt
- * Implementation of GOST2001 key transport, cryptopo variation
+ * Implementation of GOST2018 key transport
+ */
+static int pkey_gost2018_encrypt(EVP_PKEY_CTX *pctx, unsigned char *out,
+                          size_t *out_len, const unsigned char *key,
+                          size_t key_len)
+{
+    PSKeyTransport_gost *pst = NULL;
+    EVP_PKEY *pubk = EVP_PKEY_CTX_get0_pkey(pctx);
+    struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(pctx);
+    int pkey_nid = EVP_PKEY_base_id(pubk);
+    unsigned char expkeys[64];
+    EVP_PKEY *sec_key = NULL;
+    int ret = 0;
+    int mac_nid = NID_undef;
+    size_t mac_len = 0;
+    int exp_len = 0, iv_len = 0;
+    unsigned char *exp_buf = NULL;
+    int key_is_ephemeral = 0;
+
+    switch (data->cipher_nid) {
+    case NID_magma_ctr:
+        mac_nid = NID_magma_mac;
+        mac_len = 8;
+        iv_len = 4;
+        break;
+    case NID_grasshopper_ctr:
+        mac_nid = NID_grasshopper_mac;
+        mac_len = 16;
+        iv_len = 8;
+        break;
+    default:
+        GOSTerr(GOST_F_PKEY_GOST2018_ENCRYPT, GOST_R_INVALID_CIPHER);
+        return -1;
+        break;
+    }
+    exp_len = key_len + mac_len;
+    exp_buf = OPENSSL_malloc(exp_len);
+    if (!exp_buf) {
+        GOSTerr(GOST_F_PKEY_GOST2018_ENCRYPT, ERR_R_MALLOC_FAILURE);
+        return -1;
+    }
+
+    sec_key = EVP_PKEY_CTX_get0_peerkey(pctx);
+    if (!sec_key)
+    {
+      sec_key = EVP_PKEY_new();
+      if (sec_key == NULL) {
+        GOSTerr(GOST_F_PKEY_GOST2018_ENCRYPT, ERR_R_MALLOC_FAILURE );
+        goto err;
+      }
+
+      if (!EVP_PKEY_assign(sec_key, EVP_PKEY_base_id(pubk), EC_KEY_new())
+          || !EVP_PKEY_copy_parameters(sec_key, pubk)
+          || !gost_ec_keygen(EVP_PKEY_get0(sec_key))) {
+        GOSTerr(GOST_F_PKEY_GOST2018_ENCRYPT,
+            GOST_R_ERROR_COMPUTING_SHARED_KEY);
+        goto err;
+      }
+      key_is_ephemeral = 1;
+    }
+
+    if (gost_keg(data->shared_ukm, pkey_nid,
+                 EC_KEY_get0_public_key(EVP_PKEY_get0(pubk)),
+                 EVP_PKEY_get0(sec_key), expkeys) <= 0) {
+        GOSTerr(GOST_F_PKEY_GOST2018_ENCRYPT,
+                GOST_R_ERROR_COMPUTING_EXPORT_KEYS);
+        goto err;
+    }
+
+    if (gost_kexp15(key, key_len, data->cipher_nid, expkeys + 32,
+                    mac_nid, expkeys + 0, data->shared_ukm + 24, iv_len,
+                    exp_buf, &exp_len) <= 0) {
+        GOSTerr(GOST_F_PKEY_GOST2018_ENCRYPT, GOST_R_CANNOT_PACK_EPHEMERAL_KEY);
+        goto err;
+    }
+
+    pst = PSKeyTransport_gost_new();
+    if (!pst) {
+        GOSTerr(GOST_F_PKEY_GOST2018_ENCRYPT, ERR_R_MALLOC_FAILURE);
+        goto err;
+    }
+
+    if (!ASN1_OCTET_STRING_set(pst->psexp, exp_buf, exp_len)) {
+        GOSTerr(GOST_F_PKEY_GOST2018_ENCRYPT, ERR_R_MALLOC_FAILURE);
+        goto err;
+    }
+
+    if (!X509_PUBKEY_set(&pst->ephem_key, out ? sec_key : pubk)) {
+        GOSTerr(GOST_F_PKEY_GOST2018_ENCRYPT, GOST_R_CANNOT_PACK_EPHEMERAL_KEY);
+        goto err;
+    }
+
+    if ((*out_len = i2d_PSKeyTransport_gost(pst, out ? &out : NULL)) > 0)
+        ret = 1;
+ err:
+    if (key_is_ephemeral)
+      EVP_PKEY_free(sec_key);
+
+    PSKeyTransport_gost_free(pst);
+    OPENSSL_free(exp_buf);
+    return ret;
+}
+
+int pkey_gost_encrypt(EVP_PKEY_CTX *pctx, unsigned char *out,
+                      size_t *out_len, const unsigned char *key, size_t key_len)
+{
+    struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(pctx);
+    if (data->shared_ukm == NULL || data->shared_ukm_size == 8)
+        return pkey_GOST_ECcp_encrypt(pctx, out, out_len, key, key_len);
+    else if (data->shared_ukm_size == 32)
+        return pkey_gost2018_encrypt(pctx, out, out_len, key, key_len);
+    else {
+        GOSTerr(GOST_F_PKEY_GOST_ENCRYPT, ERR_R_INTERNAL_ERROR);
+        return -1;
+    }
+}
+
+/*
+ * EVP_PKEY_METHOD callback decrypt
+ * Implementation of GOST2001/12 key transport, cryptopro variation
  */
-int pkey_GOST_ECcp_decrypt(EVP_PKEY_CTX *pctx, unsigned char *key,
+static int pkey_GOST_ECcp_decrypt(EVP_PKEY_CTX *pctx, unsigned char *key,
                            size_t *key_len, const unsigned char *in,
                            size_t in_len)
 {
@@ -322,9 +529,12 @@ int pkey_GOST_ECcp_decrypt(EVP_PKEY_CTX *pctx, unsigned char *key,
     memcpy(wrappedKey + 40, gkt->key_info->imit->data, 4);
 
     EVP_PKEY_get_default_digest_nid(priv, &dgst_nid);
-    if (!VKO_compute_key(sharedKey, 32,
+    if (dgst_nid == NID_id_GostR3411_2012_512)
+        dgst_nid = NID_id_GostR3411_2012_256;
+
+    if (!VKO_compute_key(sharedKey,
                          EC_KEY_get0_public_key(EVP_PKEY_get0(peerkey)),
-                         EVP_PKEY_get0(priv), wrappedKey, dgst_nid)) {
+                         EVP_PKEY_get0(priv), wrappedKey, 8, dgst_nid)) {
         GOSTerr(GOST_F_PKEY_GOST_ECCP_DECRYPT,
                 GOST_R_ERROR_COMPUTING_SHARED_KEY);
         goto err;
@@ -341,3 +551,97 @@ int pkey_GOST_ECcp_decrypt(EVP_PKEY_CTX *pctx, unsigned char *key,
     GOST_KEY_TRANSPORT_free(gkt);
     return ret;
 }
+
+/*
+ * EVP_PKEY_METHOD callback decrypt
+ * Implementation of GOST2018 key transport
+ */
+static int pkey_gost2018_decrypt(EVP_PKEY_CTX *pctx, unsigned char *key,
+                          size_t *key_len, const unsigned char *in,
+                          size_t in_len)
+{
+    const unsigned char *p = in;
+    struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(pctx);
+    EVP_PKEY *priv = EVP_PKEY_CTX_get0_pkey(pctx);
+    PSKeyTransport_gost *pst = NULL;
+    int ret = 0;
+    unsigned char expkeys[64];
+    EVP_PKEY *eph_key = NULL;
+    int pkey_nid = EVP_PKEY_base_id(priv);
+    int mac_nid = NID_undef;
+    int iv_len = 0;
+
+    switch (data->cipher_nid) {
+    case NID_magma_ctr:
+        mac_nid = NID_magma_mac;
+        iv_len = 4;
+        break;
+    case NID_grasshopper_ctr:
+        mac_nid = NID_grasshopper_mac;
+        iv_len = 8;
+        break;
+    default:
+        GOSTerr(GOST_F_PKEY_GOST2018_DECRYPT, GOST_R_INVALID_CIPHER);
+        return -1;
+        break;
+    }
+    if (!key) {
+        *key_len = 32;
+        return 1;
+    }
+
+    pst = d2i_PSKeyTransport_gost(NULL, (const unsigned char **)&p, in_len);
+    if (!pst) {
+        GOSTerr(GOST_F_PKEY_GOST2018_DECRYPT,
+                GOST_R_ERROR_PARSING_KEY_TRANSPORT_INFO);
+        return -1;
+    }
+
+    eph_key = X509_PUBKEY_get(pst->ephem_key);
+/*
+ * TODO beldmit
+   1.  Checks the next three conditions fulfilling and terminates the
+   connection with fatal error if not.
+
+   o  Q_eph is on the same curve as server public key;
+
+   o  Q_eph is not equal to zero point;
+
+   o  q * Q_eph is not equal to zero point.
+*/
+    if (gost_keg(data->shared_ukm, pkey_nid,
+                 EC_KEY_get0_public_key(EVP_PKEY_get0(eph_key)),
+                 EVP_PKEY_get0(priv), expkeys) <= 0) {
+        GOSTerr(GOST_F_PKEY_GOST2018_DECRYPT,
+                GOST_R_ERROR_COMPUTING_EXPORT_KEYS);
+        goto err;
+    }
+
+    if (gost_kimp15(ASN1_STRING_get0_data(pst->psexp),
+                    ASN1_STRING_length(pst->psexp), data->cipher_nid,
+                    expkeys + 32, mac_nid, expkeys + 0, data->shared_ukm + 24,
+                    iv_len, key) <= 0) {
+        GOSTerr(GOST_F_PKEY_GOST2018_DECRYPT, GOST_R_CANNOT_UNPACK_EPHEMERAL_KEY);
+        goto err;
+    }
+
+    ret = 1;
+ err:
+    EVP_PKEY_free(eph_key);
+    PSKeyTransport_gost_free(pst);
+    return ret;
+}
+
+int pkey_gost_decrypt(EVP_PKEY_CTX *pctx, unsigned char *key,
+                      size_t *key_len, const unsigned char *in, size_t in_len)
+{
+    struct gost_pmeth_data *data = EVP_PKEY_CTX_get_data(pctx);
+    if (data->shared_ukm == NULL || data->shared_ukm_size == 8)
+        return pkey_GOST_ECcp_decrypt(pctx, key, key_len, in, in_len);
+    else if (data->shared_ukm_size == 32)
+        return pkey_gost2018_decrypt(pctx, key, key_len, in, in_len);
+    else {
+        GOSTerr(GOST_F_PKEY_GOST_DECRYPT, ERR_R_INTERNAL_ERROR);
+        return -1;
+    }
+}