Refactor little-to-big-endian subroutine for magma

diff --git a/gost89.c b/gost89.c
index 90d5515d9c7041c7305a9279afe69fe85350532d..240bc7ace23418bf6a31229b6455549d870eb62c 100644 (file)
--- a/gost89.c
+++ b/gost89.c
@@ -328,6 +328,60 @@ void gostcrypt(gost_ctx * c, const byte * in, byte * out)
     out[7] = (byte) (n1 >> 24);
 }
 
+/* Low-level encryption routine - encrypts one 64 bit block*/
+void magmacrypt(gost_ctx * c, const byte * in, byte * out)
+{
+    register word32 n1, n2;     /* As named in the GOST */
+    n1 = in[7-0] | (in[7-1] << 8) | (in[7-2] << 16) | ((word32) in[7-3] << 24);
+    n2 = in[7-4] | (in[7-5] << 8) | (in[7-6] << 16) | ((word32) in[7-7] << 24);
+    /* Instead of swapping halves, swap names each round */
+
+    n2 ^= f(c, n1 + c->key[0] + c->mask[0]);
+    n1 ^= f(c, n2 + c->key[1] + c->mask[1]);
+    n2 ^= f(c, n1 + c->key[2] + c->mask[2]);
+    n1 ^= f(c, n2 + c->key[3] + c->mask[3]);
+    n2 ^= f(c, n1 + c->key[4] + c->mask[4]);
+    n1 ^= f(c, n2 + c->key[5] + c->mask[5]);
+    n2 ^= f(c, n1 + c->key[6] + c->mask[6]);
+    n1 ^= f(c, n2 + c->key[7] + c->mask[7]);
+
+    n2 ^= f(c, n1 + c->key[0] + c->mask[0]);
+    n1 ^= f(c, n2 + c->key[1] + c->mask[1]);
+    n2 ^= f(c, n1 + c->key[2] + c->mask[2]);
+    n1 ^= f(c, n2 + c->key[3] + c->mask[3]);
+    n2 ^= f(c, n1 + c->key[4] + c->mask[4]);
+    n1 ^= f(c, n2 + c->key[5] + c->mask[5]);
+    n2 ^= f(c, n1 + c->key[6] + c->mask[6]);
+    n1 ^= f(c, n2 + c->key[7] + c->mask[7]);
+
+    n2 ^= f(c, n1 + c->key[0] + c->mask[0]);
+    n1 ^= f(c, n2 + c->key[1] + c->mask[1]);
+    n2 ^= f(c, n1 + c->key[2] + c->mask[2]);
+    n1 ^= f(c, n2 + c->key[3] + c->mask[3]);
+    n2 ^= f(c, n1 + c->key[4] + c->mask[4]);
+    n1 ^= f(c, n2 + c->key[5] + c->mask[5]);
+    n2 ^= f(c, n1 + c->key[6] + c->mask[6]);
+    n1 ^= f(c, n2 + c->key[7] + c->mask[7]);
+
+    n2 ^= f(c, n1 + c->key[7] + c->mask[7]);
+    n1 ^= f(c, n2 + c->key[6] + c->mask[6]);
+    n2 ^= f(c, n1 + c->key[5] + c->mask[5]);
+    n1 ^= f(c, n2 + c->key[4] + c->mask[4]);
+    n2 ^= f(c, n1 + c->key[3] + c->mask[3]);
+    n1 ^= f(c, n2 + c->key[2] + c->mask[2]);
+    n2 ^= f(c, n1 + c->key[1] + c->mask[1]);
+    n1 ^= f(c, n2 + c->key[0] + c->mask[0]);
+
+    out[7-0] = (byte) (n2 & 0xff);
+    out[7-1] = (byte) ((n2 >> 8) & 0xff);
+    out[7-2] = (byte) ((n2 >> 16) & 0xff);
+    out[7-3] = (byte) (n2 >> 24);
+    out[7-4] = (byte) (n1 & 0xff);
+    out[7-5] = (byte) ((n1 >> 8) & 0xff);
+    out[7-6] = (byte) ((n1 >> 16) & 0xff);
+    out[7-7] = (byte) (n1 >> 24);
+}
+
 /* Low-level decryption routine. Decrypts one 64-bit block */
 void gostdecrypt(gost_ctx * c, const byte * in, byte * out)
 {
@@ -381,6 +435,59 @@ void gostdecrypt(gost_ctx * c, const byte * in, byte * out)
     out[7] = (byte) (n1 >> 24);
 }
 
+/* Low-level decryption routine. Decrypts one 64-bit block */
+void magmadecrypt(gost_ctx * c, const byte * in, byte * out)
+{
+    register word32 n1, n2;     /* As named in the GOST */
+    n1 = in[7-0] | (in[7-1] << 8) | (in[7-2] << 16) | ((word32) in[7-3] << 24);
+    n2 = in[7-4] | (in[7-5] << 8) | (in[7-6] << 16) | ((word32) in[7-7] << 24);
+
+    n2 ^= f(c, n1 + c->key[0] + c->mask[0]);
+    n1 ^= f(c, n2 + c->key[1] + c->mask[1]);
+    n2 ^= f(c, n1 + c->key[2] + c->mask[2]);
+    n1 ^= f(c, n2 + c->key[3] + c->mask[3]);
+    n2 ^= f(c, n1 + c->key[4] + c->mask[4]);
+    n1 ^= f(c, n2 + c->key[5] + c->mask[5]);
+    n2 ^= f(c, n1 + c->key[6] + c->mask[6]);
+    n1 ^= f(c, n2 + c->key[7] + c->mask[7]);
+
+    n2 ^= f(c, n1 + c->key[7] + c->mask[7]);
+    n1 ^= f(c, n2 + c->key[6] + c->mask[6]);
+    n2 ^= f(c, n1 + c->key[5] + c->mask[5]);
+    n1 ^= f(c, n2 + c->key[4] + c->mask[4]);
+    n2 ^= f(c, n1 + c->key[3] + c->mask[3]);
+    n1 ^= f(c, n2 + c->key[2] + c->mask[2]);
+    n2 ^= f(c, n1 + c->key[1] + c->mask[1]);
+    n1 ^= f(c, n2 + c->key[0] + c->mask[0]);
+
+    n2 ^= f(c, n1 + c->key[7] + c->mask[7]);
+    n1 ^= f(c, n2 + c->key[6] + c->mask[6]);
+    n2 ^= f(c, n1 + c->key[5] + c->mask[5]);
+    n1 ^= f(c, n2 + c->key[4] + c->mask[4]);
+    n2 ^= f(c, n1 + c->key[3] + c->mask[3]);
+    n1 ^= f(c, n2 + c->key[2] + c->mask[2]);
+    n2 ^= f(c, n1 + c->key[1] + c->mask[1]);
+    n1 ^= f(c, n2 + c->key[0] + c->mask[0]);
+
+    n2 ^= f(c, n1 + c->key[7] + c->mask[7]);
+    n1 ^= f(c, n2 + c->key[6] + c->mask[6]);
+    n2 ^= f(c, n1 + c->key[5] + c->mask[5]);
+    n1 ^= f(c, n2 + c->key[4] + c->mask[4]);
+    n2 ^= f(c, n1 + c->key[3] + c->mask[3]);
+    n1 ^= f(c, n2 + c->key[2] + c->mask[2]);
+    n2 ^= f(c, n1 + c->key[1] + c->mask[1]);
+    n1 ^= f(c, n2 + c->key[0] + c->mask[0]);
+
+    out[7-0] = (byte) (n2 & 0xff);
+    out[7-1] = (byte) ((n2 >> 8) & 0xff);
+    out[7-2] = (byte) ((n2 >> 16) & 0xff);
+    out[7-3] = (byte) (n2 >> 24);
+    out[7-4] = (byte) (n1 & 0xff);
+    out[7-5] = (byte) ((n1 >> 8) & 0xff);
+    out[7-6] = (byte) ((n1 >> 16) & 0xff);
+    out[7-7] = (byte) (n1 >> 24);
+}
+
 
 /* Encrypts several blocks in ECB mode */
 void gost_enc(gost_ctx * c, const byte * clear, byte * cipher, int blocks)

diff --git a/gost89.h b/gost89.h
index f201363c0c1cc5d261b7c72a4197f69a8d2cd462..f8a83bbb9d47a5a03eb0ea51ab3c5483a7cc88f9 100644 (file)
--- a/gost89.h
+++ b/gost89.h
@@ -59,6 +59,10 @@ void gost_dec_cfb(gost_ctx * ctx, const byte * iv, const byte * cipher,
 void gostcrypt(gost_ctx * c, const byte * in, byte * out);
 /* Decrypt one  block */
 void gostdecrypt(gost_ctx * c, const byte * in, byte * out);
+/* Encrypt one  block */
+void magmacrypt(gost_ctx * c, const byte * in, byte * out);
+/* Decrypt one  block */
+void magmadecrypt(gost_ctx * c, const byte * in, byte * out);
 /* Set key into context */
 void gost_key(gost_ctx * c, const byte * k);
 /* Set key into context without key mask */

diff --git a/gost_crypt.c b/gost_crypt.c
index 8f8e0d382ff05bd340f504b34e29f5a49830454b..6d68f62ba2b9084660c351535c76fd6c85ed6804 100644 (file)
--- a/gost_crypt.c
+++ b/gost_crypt.c
@@ -607,13 +607,9 @@ static int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,
         while (inl > 0) {
 
             for (i = 0; i < 8; i++) {
-                b[7 - i] = iv[i] ^ in_ptr[i];
-            }
-            gostcrypt(&(c->cctx), b, d);
-
-            for (i = 0; i < 8; i++) {
-                out_ptr[7 - i] = d[i];
+                out_ptr[i] = iv[i] ^ in_ptr[i];
             }
+            magmacrypt(&(c->cctx), out_ptr, out_ptr);
             memcpy(iv, out_ptr, 8);
             out_ptr += 8;
             in_ptr += 8;
@@ -621,13 +617,10 @@ static int magma_cipher_do_cbc(EVP_CIPHER_CTX *ctx, unsigned char *out,
         }
     } else {
         while (inl > 0) {
-            for (i = 0; i < 8; i++) {
-                d[7 - i] = in_ptr[i];
-            }
-            gostdecrypt(&(c->cctx), d, b);
+            magmadecrypt(&(c->cctx), in_ptr, b);
             memcpy(d, in_ptr, 8);
             for (i = 0; i < 8; i++) {
-                out_ptr[i] = iv[i] ^ b[7 - i];
+                out_ptr[i] = iv[i] ^ b[i];
             }
             memcpy(iv, d, 8);
             out_ptr += 8;
@@ -667,10 +660,9 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,
     unsigned char *iv = EVP_CIPHER_CTX_iv_noconst(ctx);
     unsigned int num = EVP_CIPHER_CTX_num(ctx);
     size_t blocks, i, lasted = inl;
-    unsigned char b[8];
 /* Process partial blocks */
     while ((num & MAGMA_BLOCK_MASK) && lasted) {
-        *out_ptr++ = *in_ptr++ ^ buf[7 - (num & MAGMA_BLOCK_MASK)];
+        *out_ptr++ = *in_ptr++ ^ buf[num & MAGMA_BLOCK_MASK];
         --lasted;
         num++;
     }
@@ -679,12 +671,9 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,
 /* Process full blocks */
     for (i = 0; i < blocks; i++) {
         apply_acpkm_magma(c, &num);
+        magmacrypt(&(c->cctx), iv, buf);
         for (j = 0; j < 8; j++) {
-            b[7 - j] = iv[j];
-        }
-        gostcrypt(&(c->cctx), b, buf);
-        for (j = 0; j < 8; j++) {
-            out_ptr[j] = buf[7 - j] ^ in_ptr[j];
+            out_ptr[j] = buf[j] ^ in_ptr[j];
         }
         ctr64_inc(iv);
         c->count += MAGMA_BLOCK_SIZE;
@@ -697,15 +686,12 @@ static int magma_cipher_do_ctr(EVP_CIPHER_CTX *ctx, unsigned char *out,
 /* Process the rest of plaintext */
     if (lasted > 0) {
         apply_acpkm_magma(c, &num);
-        for (j = 0; j < 8; j++) {
-            b[7 - j] = iv[j];
-        }
-        gostcrypt(&(c->cctx), b, buf);
+        magmacrypt(&(c->cctx), iv, buf);
 
         for (i = 0; i < lasted; i++)
-            out_ptr[i] = buf[7 - i] ^ in_ptr[i];
+            out_ptr[i] = buf[i] ^ in_ptr[i];
         ctr64_inc(iv);
-        c->count += j;
+        c->count += 8;
         num += lasted;
     }
     EVP_CIPHER_CTX_set_num(ctx, num);