magma-ctr-acpkm + magma-ctr-acpkm-omac

1 files changed, 288 insertions, 49 deletions

diff --git a/gost_crypt.c b/gost_crypt.c
index 268e311..54b4d95 100644
--- a/gost_crypt.c
+++ b/gost_crypt.c
@@ -12,6 +12,7 @@
 #include <openssl/rand.h>
 #include "e_gost_err.h"
 #include "gost_lcl.h"
+#include "gost_gost2015.h"
 
 #if !defined(CCGOST_DEBUG) && !defined(DEBUG)
 # ifndef NDEBUG
@@ -48,12 +49,24 @@ static int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
 
 static int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
                              const unsigned char *iv, int enc);
+static int magma_cipher_init_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+                             const unsigned char *iv, int enc);
 /* Handles block of data in CBC mode */
 static int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,
                                const unsigned char *in, size_t inl);
 static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,
                                const unsigned char *in, size_t inl);
 
+static int magma_cipher_do_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                               const unsigned char *in, size_t inl);
+
+/* set/get cipher parameters */
+static int magma_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params);
+static int magma_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params);
+/* Control function */
+static int magma_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
+static int magma_cipher_ctl_acpkm_omac(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr);
+
 static EVP_CIPHER *_hidden_Gost28147_89_cipher = NULL;
 const EVP_CIPHER *cipher_gost(void)
 {
@@ -217,16 +230,86 @@ const EVP_CIPHER *cipher_magma_ctr(void)
                                                   sizeof(struct
                                                          ossl_gost_cipher_ctx))
             || !EVP_CIPHER_meth_set_set_asn1_params(_hidden_magma_ctr,
-                                                    gost89_set_asn1_parameters)
+                                                    magma_set_asn1_parameters)
             || !EVP_CIPHER_meth_set_get_asn1_params(_hidden_magma_ctr,
-                                                    gost89_get_asn1_parameters)
-            || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_ctr, gost_cipher_ctl))) {
+                                                    magma_get_asn1_parameters)
+            || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_ctr, magma_cipher_ctl))) {
         EVP_CIPHER_meth_free(_hidden_magma_ctr);
         _hidden_magma_ctr = NULL;
     }
     return _hidden_magma_ctr;
 }
 
+static EVP_CIPHER *_hidden_magma_ctr_acpkm = NULL;
+const EVP_CIPHER *cipher_magma_ctr_acpkm(void)
+{
+    if (_hidden_magma_ctr_acpkm == NULL
+        && ((_hidden_magma_ctr_acpkm =
+             EVP_CIPHER_meth_new(NID_magma_ctr_acpkm, 1 /* block_size */ ,
+                                 32 /* key_size */ )) == NULL
+            || !EVP_CIPHER_meth_set_iv_length(_hidden_magma_ctr_acpkm, 4)
+            || !EVP_CIPHER_meth_set_flags(_hidden_magma_ctr_acpkm,
+                                          EVP_CIPH_CTR_MODE |
+                                          EVP_CIPH_NO_PADDING |
+                                          EVP_CIPH_CUSTOM_IV |
+                                          EVP_CIPH_RAND_KEY |
+                                          EVP_CIPH_ALWAYS_CALL_INIT)
+            || !EVP_CIPHER_meth_set_init(_hidden_magma_ctr_acpkm, magma_cipher_init)
+            || !EVP_CIPHER_meth_set_do_cipher(_hidden_magma_ctr_acpkm,
+                                              magma_cipher_do_ctr)
+            || !EVP_CIPHER_meth_set_cleanup(_hidden_magma_ctr_acpkm,
+                                            gost_cipher_cleanup)
+            || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_magma_ctr_acpkm,
+                                                  sizeof(struct
+                                                         ossl_gost_cipher_ctx))
+            || !EVP_CIPHER_meth_set_set_asn1_params(_hidden_magma_ctr_acpkm,
+                                                    magma_set_asn1_parameters)
+            || !EVP_CIPHER_meth_set_get_asn1_params(_hidden_magma_ctr_acpkm,
+                                                    magma_get_asn1_parameters)
+
+            || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_ctr_acpkm, magma_cipher_ctl))) {
+        EVP_CIPHER_meth_free(_hidden_magma_ctr_acpkm);
+        _hidden_magma_ctr_acpkm = NULL;
+    }
+    return _hidden_magma_ctr_acpkm;
+}
+
+static EVP_CIPHER *_hidden_magma_ctr_acpkm_omac = NULL;
+const EVP_CIPHER *cipher_magma_ctr_acpkm_omac(void)
+{
+    if (_hidden_magma_ctr_acpkm_omac == NULL
+        && ((_hidden_magma_ctr_acpkm_omac =
+             EVP_CIPHER_meth_new(NID_magma_ctr_acpkm_omac, 1 /* block_size */ ,
+                                 32 /* key_size */ )) == NULL
+            || !EVP_CIPHER_meth_set_iv_length(_hidden_magma_ctr_acpkm_omac, 4)
+            || !EVP_CIPHER_meth_set_flags(_hidden_magma_ctr_acpkm_omac,
+                                          EVP_CIPH_CTR_MODE |
+                                          EVP_CIPH_NO_PADDING |
+                                          EVP_CIPH_CUSTOM_IV |
+                                          EVP_CIPH_RAND_KEY |
+                                          EVP_CIPH_ALWAYS_CALL_INIT |
+																					EVP_CIPH_CUSTOM_COPY |
+																					EVP_CIPH_FLAG_CUSTOM_CIPHER |
+																					EVP_CIPH_FLAG_CIPHER_WITH_MAC)
+            || !EVP_CIPHER_meth_set_init(_hidden_magma_ctr_acpkm_omac, magma_cipher_init_ctr_acpkm_omac)
+            || !EVP_CIPHER_meth_set_do_cipher(_hidden_magma_ctr_acpkm_omac,
+                                              magma_cipher_do_ctr_acpkm_omac)
+            || !EVP_CIPHER_meth_set_cleanup(_hidden_magma_ctr_acpkm_omac,
+                                            gost_cipher_cleanup)
+            || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_magma_ctr_acpkm_omac,
+                                                  sizeof(struct
+                                                         ossl_gost_cipher_ctx))
+            || !EVP_CIPHER_meth_set_set_asn1_params(_hidden_magma_ctr_acpkm_omac,
+                                                    magma_set_asn1_parameters)
+            || !EVP_CIPHER_meth_set_get_asn1_params(_hidden_magma_ctr_acpkm_omac,
+                                                    magma_get_asn1_parameters)
+            || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_ctr_acpkm_omac, magma_cipher_ctl_acpkm_omac))) {
+        EVP_CIPHER_meth_free(_hidden_magma_ctr_acpkm_omac);
+        _hidden_magma_ctr_acpkm_omac = NULL;
+    }
+    return _hidden_magma_ctr_acpkm_omac;
+}
+
 static EVP_CIPHER *_hidden_magma_cbc = NULL;
 const EVP_CIPHER *cipher_magma_cbc(void)
 {
@@ -248,11 +331,7 @@ const EVP_CIPHER *cipher_magma_cbc(void)
             || !EVP_CIPHER_meth_set_impl_ctx_size(_hidden_magma_cbc,
                                                   sizeof(struct
                                                          ossl_gost_cipher_ctx))
-            || !EVP_CIPHER_meth_set_set_asn1_params(_hidden_magma_cbc,
-                                                    gost89_set_asn1_parameters)
-            || !EVP_CIPHER_meth_set_get_asn1_params(_hidden_magma_cbc,
-                                                    gost89_get_asn1_parameters)
-            || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_cbc, gost_cipher_ctl))) {
+            || !EVP_CIPHER_meth_set_ctrl(_hidden_magma_cbc, magma_cipher_ctl))) {
         EVP_CIPHER_meth_free(_hidden_magma_cbc);
         _hidden_magma_cbc = NULL;
     }
@@ -273,6 +352,10 @@ void cipher_gost_destroy(void)
     _hidden_magma_cbc = NULL;
     EVP_CIPHER_meth_free(_hidden_magma_ctr);
     _hidden_magma_ctr = NULL;
+    EVP_CIPHER_meth_free(_hidden_magma_ctr_acpkm);
+    _hidden_magma_ctr_acpkm = NULL;
+    EVP_CIPHER_meth_free(_hidden_magma_ctr_acpkm_omac);
+    _hidden_magma_ctr_acpkm_omac = NULL;
 }
 
 /* Implementation of GOST 28147-89 in MAC (imitovstavka) mode */
@@ -458,28 +541,6 @@ static int gost_cipher_init_param(EVP_CIPHER_CTX *ctx,
     return 1;
 }
 
-static int magma_cipher_init_param(EVP_CIPHER_CTX *ctx,
-                                   const unsigned char *key,
-                                   const unsigned char *iv, int enc,
-                                   int paramNID, int mode)
-{
-    struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
-    if (EVP_CIPHER_CTX_get_app_data(ctx) == NULL) {
-        if (!gost_cipher_set_param(c, NID_id_tc26_gost_28147_param_Z))
-            return 0;
-        EVP_CIPHER_CTX_set_app_data(ctx, EVP_CIPHER_CTX_get_cipher_data(ctx));
-    }
-    if (key)
-        magma_key(&(c->cctx), key);
-    if (iv) {
-        memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv,
-               EVP_CIPHER_CTX_iv_length(ctx));
-    }
-    memcpy(EVP_CIPHER_CTX_iv_noconst(ctx),
-           EVP_CIPHER_CTX_original_iv(ctx), EVP_CIPHER_CTX_iv_length(ctx));
-    return 1;
-}
-
 static int gost_cipher_init_cnt(EVP_CIPHER_CTX *ctx,
                                 const unsigned char *key,
                                 const unsigned char *iv,
@@ -533,8 +594,74 @@ int gost_cipher_init_cbc(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 int magma_cipher_init(EVP_CIPHER_CTX *ctx, const unsigned char *key,
                       const unsigned char *iv, int enc)
 {
-    return magma_cipher_init_param(ctx, key, iv, enc, NID_undef,
-                                   EVP_CIPH_CBC_MODE);
+    struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
+    /* FIXME this is just initializtion check */
+    if (EVP_CIPHER_CTX_get_app_data(ctx) == NULL) {
+        if (!gost_cipher_set_param(c, NID_id_tc26_gost_28147_param_Z))
+            return 0;
+        EVP_CIPHER_CTX_set_app_data(ctx, EVP_CIPHER_CTX_get_cipher_data(ctx));
+    }
+    if (key)
+        magma_key(&(c->cctx), key);
+    if (iv) {
+        memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv,
+               EVP_CIPHER_CTX_iv_length(ctx));
+    }
+    memcpy(EVP_CIPHER_CTX_iv_noconst(ctx),
+           EVP_CIPHER_CTX_original_iv(ctx), EVP_CIPHER_CTX_iv_length(ctx));
+
+    if (EVP_CIPHER_CTX_nid(ctx) == NID_magma_ctr_acpkm
+     || EVP_CIPHER_CTX_nid(ctx) == NID_magma_ctr_acpkm_omac) {
+       c->key_meshing = 1024;
+    } else {
+       c->key_meshing = 0;
+    }
+
+    return 1;
+}
+
+/* Initializes EVP_CIPHER_CTX with default values */
+int magma_cipher_init_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, const unsigned char *key,
+                      const unsigned char *iv, int enc)
+{
+	if (key) {
+    struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
+		unsigned char keys[64];
+		const EVP_MD *md = EVP_get_digestbynid(NID_magma_mac);
+		EVP_PKEY *mac_key;
+
+		if (md == NULL)
+			return 0;
+
+		if (enc) {
+			if (RAND_bytes(c->kdf_seed, 8) != 1)
+				return 0;
+		}
+
+		if (gost_kdftree2012_256(keys, 64, key, 32, (const unsigned char *)"kdf tree", 8, c->kdf_seed, 8, 1) <= 0)
+			return 0;
+
+		c->omac_ctx = EVP_MD_CTX_new();
+		mac_key = EVP_PKEY_new_mac_key(NID_magma_mac, NULL, keys+32, 32);
+
+		if (mac_key == NULL || c->omac_ctx == NULL) {
+			EVP_PKEY_free(mac_key);
+			OPENSSL_cleanse(keys, sizeof(keys));
+			return 0;
+		}
+
+		if (EVP_DigestInit_ex(c->omac_ctx, md, NULL) <= 0 ||
+			EVP_DigestSignInit(c->omac_ctx, NULL, md, NULL, mac_key) <= 0) {
+			EVP_PKEY_free(mac_key);
+			OPENSSL_cleanse(keys, sizeof(keys));
+			return 0;
+		}
+		EVP_PKEY_free(mac_key);
+		OPENSSL_cleanse(keys + 32, sizeof(keys) - 32);
+
+		return magma_cipher_init(ctx, keys, iv, enc);
+	}
+	return magma_cipher_init(ctx, key, iv, enc);
 }
 
 /*
@@ -696,7 +823,7 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,
             EVP_CIPHER_CTX_set_num(ctx, 0);
         } else {
             EVP_CIPHER_CTX_set_num(ctx, j);
-            return 1;
+            return inl;
         }
     }
 
@@ -710,6 +837,9 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,
             out_ptr[j] = buf[7 - j] ^ in_ptr[j];
         }
         ctr64_inc(iv);
+        c->count += 8;
+        if (c->key_meshing && (c->count % c->key_meshing == 0))
+            acpkm_magma_key_meshing(&(c->cctx));
     }
 
 /* Process the rest of plaintext */
@@ -717,20 +847,47 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,
         for (j = 0; j < 8; j++) {
             b[7 - j] = iv[j];
         }
-        gostcrypt(&(c->cctx), iv, buf);
-        ctr64_inc(iv);
+        gostcrypt(&(c->cctx), b, buf);
+
         for (j = 0; i < inl; j++, i++) {
             out_ptr[j] = buf[7 - j] ^ in_ptr[j];
         }
 
+        ctr64_inc(iv);
+        c->count += 8;
+        if (c->key_meshing && (c->count % c->key_meshing == 0))
+            acpkm_magma_key_meshing(&(c->cctx));
+
         EVP_CIPHER_CTX_set_num(ctx, j);
     } else {
         EVP_CIPHER_CTX_set_num(ctx, 0);
     }
 
-    return 1;
+    return inl;
 }
 
+/* MAGMA encryption in CTR mode */
+static int magma_cipher_do_ctr_acpkm_omac(EVP_CIPHER_CTX *ctx, unsigned char *out,
+                               const unsigned char *in, size_t inl)
+{
+  struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
+
+	if (in == NULL && inl == 0) /* Final call */
+		return gost2015_final_call(ctx, c->omac_ctx, MAGMA_MAC_MAX_SIZE, c->tag, magma_cipher_do_ctr);
+
+	/* As in and out can be the same pointer, process unencrypted here */
+	if (EVP_CIPHER_CTX_encrypting(ctx))
+		EVP_DigestSignUpdate(c->omac_ctx, in, inl);
+
+  if (magma_cipher_do_ctr(ctx, out, in, inl) != inl)
+      return -1;
+
+	/* As in and out can be the same pointer, process decrypted here */
+	if (!EVP_CIPHER_CTX_encrypting(ctx))
+		EVP_DigestSignUpdate(c->omac_ctx, out, inl);
+
+	return inl;
+}
 /* GOST encryption in CFB mode */
 int gost_cipher_do_cfb(EVP_CIPHER_CTX *ctx, unsigned char *out,
                        const unsigned char *in, size_t inl)
@@ -853,8 +1010,9 @@ static int gost_cipher_do_cnt(EVP_CIPHER_CTX *ctx, unsigned char *out,
 /* Cleaning up of EVP_CIPHER_CTX */
 int gost_cipher_cleanup(EVP_CIPHER_CTX *ctx)
 {
-    gost_destroy(&((struct ossl_gost_cipher_ctx *)
-                   EVP_CIPHER_CTX_get_cipher_data(ctx))->cctx);
+    struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
+		EVP_MD_CTX_free(c->omac_ctx);
+    gost_destroy(&(c->cctx));
     EVP_CIPHER_CTX_set_app_data(ctx, NULL);
     return 1;
 }
@@ -863,17 +1021,6 @@ int gost_cipher_cleanup(EVP_CIPHER_CTX *ctx)
 int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
 {
     switch (type) {
-#if 0
-    case EVP_CTRL_INIT:
-        {
-            struct ossl_gost_cipher_ctx *c =
-                EVP_CIPHER_CTX_get_cipher_data(ctx);
-            if (c == NULL) {
-                return -1;
-            }
-            return gost_cipher_set_param(c, arg);
-        }
-#endif
     case EVP_CTRL_RAND_KEY:
         {
             if (RAND_priv_bytes
@@ -953,6 +1100,70 @@ int gost_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
     return 1;
 }
 
+/* Control function for gost cipher */
+int magma_cipher_ctl(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
+{
+    switch (type) {
+    case EVP_CTRL_RAND_KEY:
+            if (RAND_priv_bytes
+                ((unsigned char *)ptr, EVP_CIPHER_CTX_key_length(ctx)) <= 0) {
+                GOSTerr(GOST_F_GOST_CIPHER_CTL, GOST_R_RNG_ERROR);
+                return -1;
+            }
+            break;
+    case EVP_CTRL_KEY_MESH:
+        {
+            struct ossl_gost_cipher_ctx *c =
+                EVP_CIPHER_CTX_get_cipher_data(ctx);
+
+            if (c == NULL) {
+                return -1;
+            }
+
+            if (c->count != 0) {
+                return -1;
+            }
+
+            c->key_meshing = arg;
+            return 1;
+        }
+    default:
+        GOSTerr(GOST_F_MAGMA_CIPHER_CTL, GOST_R_UNSUPPORTED_CIPHER_CTL_COMMAND);
+        return -1;
+    }
+    return 1;
+}
+
+static int magma_cipher_ctl_acpkm_omac(EVP_CIPHER_CTX *ctx, int type, int arg, void *ptr)
+{
+	switch (type)
+	{
+		case EVP_CTRL_PROCESS_UNPROTECTED:
+		{
+			struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
+			STACK_OF(X509_ATTRIBUTE) *x = ptr;
+      return gost2015_process_unprotected_attributes(x, arg, MAGMA_MAC_MAX_SIZE, c->tag);
+		}
+    case EVP_CTRL_COPY: {
+			EVP_CIPHER_CTX *out = ptr;
+      struct ossl_gost_cipher_ctx *in_cctx  = EVP_CIPHER_CTX_get_cipher_data(ctx);
+      struct ossl_gost_cipher_ctx *out_cctx = EVP_CIPHER_CTX_get_cipher_data(out);
+
+			if (in_cctx->omac_ctx == out_cctx->omac_ctx) {
+				out_cctx->omac_ctx = EVP_MD_CTX_new();
+				if (out_cctx->omac_ctx == NULL) {
+					GOSTerr(GOST_F_MAGMA_CIPHER_CTL_ACPKM_OMAC, ERR_R_MALLOC_FAILURE);
+					return -1;
+				}
+			}
+			return EVP_MD_CTX_copy(out_cctx->omac_ctx, in_cctx->omac_ctx);
+		}
+		default:
+			return magma_cipher_ctl(ctx, type, arg, ptr);
+			break;
+	}
+}
+
 /* Set cipher parameters from ASN1 structure */
 int gost89_set_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
 {
@@ -1044,6 +1255,34 @@ int gost89_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
     return 1;
 }
 
+#define MAGMA_UKM_LEN 12
+static int magma_set_asn1_parameters (EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
+{
+  struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
+	c->key_meshing = 8192;
+
+	return gost2015_set_asn1_params(params, EVP_CIPHER_CTX_original_iv(ctx), 4,
+		c->kdf_seed);
+}
+
+static int magma_get_asn1_parameters(EVP_CIPHER_CTX *ctx, ASN1_TYPE *params)
+{
+  struct ossl_gost_cipher_ctx *c = EVP_CIPHER_CTX_get_cipher_data(ctx);
+	unsigned char iv[16];
+
+	c->key_meshing = 8192;
+
+	if (gost2015_get_asn1_params(params, MAGMA_UKM_LEN, iv, 4, c->kdf_seed) < 0)
+	    return -1;
+
+	memcpy(EVP_CIPHER_CTX_iv_noconst(ctx), iv, sizeof(iv));
+	memcpy((unsigned char *)EVP_CIPHER_CTX_original_iv(ctx), iv, sizeof(iv));
+	/* Key meshing 8 kb*/
+	c->key_meshing = 8192;
+
+	return 1;
+}
+
 static int gost_imit_init(EVP_MD_CTX *ctx, gost_subst_block * block)
 {
     struct ossl_gost_imit_ctx *c = EVP_MD_CTX_md_data(ctx);