bufhelp: use one-byte aligned type for unaligned memory accesses
[libgcrypt.git] / cipher / gost28147.c
index 862e7d6..4ff80b4 100644 (file)
 #include "types.h"
 #include "g10lib.h"
 #include "cipher.h"
-
-
-#define max(a, b) (((a) > (b)) ? (a) : (b))
-
-
-/* This is an s-box from RFC4357, named GostR3411-94-TestParamSet
- * For now it is the only s-box supported, as libgcrypt lacks mechanism
- * for passing parameters to cipher in a usefull way. */
-unsigned char test_sbox[16 * 8] = {
-  0x4, 0xE, 0x5, 0x7, 0x6, 0x4, 0xD, 0x1,
-  0xA, 0xB, 0x8, 0xD, 0xC, 0xB, 0xB, 0xF,
-  0x9, 0x4, 0x1, 0xA, 0x7, 0xA, 0x4, 0xD,
-  0x2, 0xC, 0xD, 0x1, 0x1, 0x0, 0x1, 0x0,
-
-  0xD, 0x6, 0xA, 0x0, 0x5, 0x7, 0x3, 0x5,
-  0x8, 0xD, 0x3, 0x8, 0xF, 0x2, 0xF, 0x7,
-  0x0, 0xF, 0x4, 0x9, 0xD, 0x1, 0x5, 0xA,
-  0xE, 0xA, 0x2, 0xF, 0x8, 0xD, 0x9, 0x4,
-
-  0x6, 0x2, 0xE, 0xE, 0x4, 0x3, 0x0, 0x9,
-  0xB, 0x3, 0xF, 0x4, 0xA, 0x6, 0xA, 0x2,
-  0x1, 0x8, 0xC, 0x6, 0x9, 0x8, 0xE, 0x3,
-  0xC, 0x1, 0x7, 0xC, 0xE, 0x5, 0x7, 0xE,
-
-  0x7, 0x0, 0x6, 0xB, 0x0, 0x9, 0x6, 0x6,
-  0xF, 0x7, 0x0, 0x2, 0x3, 0xC, 0x8, 0xB,
-  0x5, 0x5, 0x9, 0x5, 0xB, 0xF, 0x2, 0x8,
-  0x3, 0x9, 0xB, 0x3, 0x2, 0xE, 0xC, 0xC,
-};
+#include "bufhelp.h"
 
 #include "gost.h"
+#include "gost-sb.h"
 
 static gcry_err_code_t
 gost_setkey (void *c, const byte *key, unsigned keylen)
@@ -74,59 +47,31 @@ gost_setkey (void *c, const byte *key, unsigned keylen)
   if (keylen != 256 / 8)
     return GPG_ERR_INV_KEYLEN;
 
+  if (!ctx->sbox)
+    ctx->sbox = sbox_test_3411;
+
   for (i = 0; i < 8; i++)
     {
-      ctx->key[i] = (key[4 * i + 3] << 24) |
-                    (key[4 * i + 2] << 16) |
-                    (key[4 * i + 1] <<  8) |
-                    (key[4 * i + 0] <<  0);
+      ctx->key[i] = buf_get_le32(&key[4*i]);
     }
   return GPG_ERR_NO_ERROR;
 }
 
-static void
-gost_set_subst (GOST28147_context *ctx, unsigned char *sbox)
-{
-  unsigned i, j;
-  for (i = 0; i < 4; i++)
-    {
-       for (j = 0; j < 256; j++)
-         {
-           ctx->subst[i][j] = sbox[ (j & 0xf) * 8 + 2 * i + 0] |
-                             (sbox[ (j >> 4)  * 8 + 2 * i + 1] << 4);
-         }
-    }
-  ctx->subst_set = 1;
-}
-
 static u32
 gost_val (GOST28147_context *ctx, u32 cm1, int subkey)
 {
   cm1 += ctx->key[subkey];
-  cm1 = (ctx->subst[0][ (cm1 >>  0) & 0xff] <<  0) |
-        (ctx->subst[1][ (cm1 >>  8) & 0xff] <<  8) |
-        (ctx->subst[2][ (cm1 >> 16) & 0xff] << 16) |
-        (ctx->subst[3][ (cm1 >> 24) & 0xff] << 24);
-  return (cm1 << 11) | (cm1 >> 21);
+  cm1 = ctx->sbox[0*256 + ((cm1 >>  0) & 0xff)] |
+        ctx->sbox[1*256 + ((cm1 >>  8) & 0xff)] |
+        ctx->sbox[2*256 + ((cm1 >> 16) & 0xff)] |
+        ctx->sbox[3*256 + ((cm1 >> 24) & 0xff)];
+  return cm1;
 }
 
 static unsigned int
-gost_encrypt_block (void *c, byte *outbuf, const byte *inbuf)
+_gost_encrypt_data (void *c, u32 *o1, u32 *o2, u32 n1, u32 n2)
 {
   GOST28147_context *ctx = c;
-  u32 n1, n2;
-
-  if (!ctx->subst_set)
-    gost_set_subst (ctx, test_sbox);
-
-  n1 =  (inbuf[0] << 0) |
-        (inbuf[1] << 8) |
-        (inbuf[2] << 16) |
-        (inbuf[3] << 24);
-  n2 =  (inbuf[4] << 0) |
-        (inbuf[5] << 8) |
-        (inbuf[6] << 16) |
-        (inbuf[7] << 24);
 
   n2 ^= gost_val (ctx, n1, 0); n1 ^= gost_val (ctx, n2, 1);
   n2 ^= gost_val (ctx, n1, 2); n1 ^= gost_val (ctx, n2, 3);
@@ -148,27 +93,41 @@ gost_encrypt_block (void *c, byte *outbuf, const byte *inbuf)
   n2 ^= gost_val (ctx, n1, 3); n1 ^= gost_val (ctx, n2, 2);
   n2 ^= gost_val (ctx, n1, 1); n1 ^= gost_val (ctx, n2, 0);
 
-  outbuf[0 + 0] = (n2 >> (0 * 8)) & 0xff;
-  outbuf[1 + 0] = (n2 >> (1 * 8)) & 0xff;
-  outbuf[2 + 0] = (n2 >> (2 * 8)) & 0xff;
-  outbuf[3 + 0] = (n2 >> (3 * 8)) & 0xff;
-  outbuf[0 + 4] = (n1 >> (0 * 8)) & 0xff;
-  outbuf[1 + 4] = (n1 >> (1 * 8)) & 0xff;
-  outbuf[2 + 4] = (n1 >> (2 * 8)) & 0xff;
-  outbuf[3 + 4] = (n1 >> (3 * 8)) & 0xff;
+  *o1 = n2;
+  *o2 = n1;
 
   return /* burn_stack */ 4*sizeof(void*) /* func call */ +
                           3*sizeof(void*) /* stack */ +
-                          max( 4*sizeof(void*) /* gost_val call */,
-                               3*sizeof(void*) /* gost_set_subst call */ +
-                               2*sizeof(void*) /* gost_set subst stack*/ );
+                          4*sizeof(void*) /* gost_val call */;
+}
+
+static unsigned int
+gost_encrypt_block (void *c, byte *outbuf, const byte *inbuf)
+{
+  GOST28147_context *ctx = c;
+  u32 n1, n2;
+  unsigned int burn;
+
+  n1 = buf_get_le32 (inbuf);
+  n2 = buf_get_le32 (inbuf+4);
+
+  burn = _gost_encrypt_data(ctx, &n1, &n2, n1, n2);
+
+  buf_put_le32 (outbuf+0, n1);
+  buf_put_le32 (outbuf+4, n2);
+
+  return /* burn_stack */ burn + 6*sizeof(void*) /* func call */;
 }
 
-unsigned int _gcry_gost_enc_one (GOST28147_context *c, const byte *key,
-    byte *out, byte *in)
+unsigned int _gcry_gost_enc_data (GOST28147_context *c, const u32 *key,
+    u32 *o1, u32 *o2, u32 n1, u32 n2, int cryptopro)
 {
-  gost_setkey (c, key, 32);
-  return gost_encrypt_block (c, out, in);
+  if (cryptopro)
+    c->sbox = sbox_CryptoPro_3411;
+  else
+    c->sbox = sbox_test_3411;
+  memcpy (c->key, key, 8*4);
+  return _gost_encrypt_data (c, o1, o2, n1, n2) + 7 * sizeof(void *);
 }
 
 static unsigned int
@@ -177,17 +136,8 @@ gost_decrypt_block (void *c, byte *outbuf, const byte *inbuf)
   GOST28147_context *ctx = c;
   u32 n1, n2;
 
-  if (!ctx->subst_set)
-    gost_set_subst (ctx, test_sbox);
-
-  n1 =  (inbuf[0] << 0) |
-        (inbuf[1] << 8) |
-        (inbuf[2] << 16) |
-        (inbuf[3] << 24);
-  n2 =  (inbuf[4] << 0) |
-        (inbuf[5] << 8) |
-        (inbuf[6] << 16) |
-        (inbuf[7] << 24);
+  n1 = buf_get_le32 (inbuf);
+  n2 = buf_get_le32 (inbuf+4);
 
   n2 ^= gost_val (ctx, n1, 0); n1 ^= gost_val (ctx, n2, 1);
   n2 ^= gost_val (ctx, n1, 2); n1 ^= gost_val (ctx, n2, 3);
@@ -209,27 +159,69 @@ gost_decrypt_block (void *c, byte *outbuf, const byte *inbuf)
   n2 ^= gost_val (ctx, n1, 3); n1 ^= gost_val (ctx, n2, 2);
   n2 ^= gost_val (ctx, n1, 1); n1 ^= gost_val (ctx, n2, 0);
 
-  outbuf[0 + 0] = (n2 >> (0 * 8)) & 0xff;
-  outbuf[1 + 0] = (n2 >> (1 * 8)) & 0xff;
-  outbuf[2 + 0] = (n2 >> (2 * 8)) & 0xff;
-  outbuf[3 + 0] = (n2 >> (3 * 8)) & 0xff;
-  outbuf[0 + 4] = (n1 >> (0 * 8)) & 0xff;
-  outbuf[1 + 4] = (n1 >> (1 * 8)) & 0xff;
-  outbuf[2 + 4] = (n1 >> (2 * 8)) & 0xff;
-  outbuf[3 + 4] = (n1 >> (3 * 8)) & 0xff;
+  buf_put_le32 (outbuf+0, n2);
+  buf_put_le32 (outbuf+4, n1);
 
   return /* burn_stack */ 4*sizeof(void*) /* func call */ +
                           3*sizeof(void*) /* stack */ +
-                          max( 4*sizeof(void*) /* gost_val call */,
-                               3*sizeof(void*) /* gost_set_subst call */ +
-                               2*sizeof(void*) /* gost_set subst stack*/ );
+                          4*sizeof(void*) /* gost_val call */;
+}
+
+static gpg_err_code_t
+gost_set_sbox (GOST28147_context *ctx, const char *oid)
+{
+  int i;
+
+  for (i = 0; gost_oid_map[i].oid; i++)
+    {
+      if (!strcmp(gost_oid_map[i].oid, oid))
+        {
+          ctx->sbox = gost_oid_map[i].sbox;
+          return 0;
+        }
+    }
+  return GPG_ERR_VALUE_NOT_FOUND;
 }
 
+static gpg_err_code_t
+gost_set_extra_info (void *c, int what, const void *buffer, size_t buflen)
+{
+  GOST28147_context *ctx = c;
+  gpg_err_code_t ec = 0;
+
+  (void)buffer;
+  (void)buflen;
+
+  switch (what)
+    {
+    case GCRYCTL_SET_SBOX:
+      ec = gost_set_sbox (ctx, buffer);
+      break;
+
+    default:
+      ec = GPG_ERR_INV_OP;
+      break;
+    }
+  return ec;
+}
+
+static gcry_cipher_oid_spec_t oids_gost28147[] =
+  {
+    /* { "1.2.643.2.2.31.0", GCRY_CIPHER_MODE_CNTGOST }, */
+    { "1.2.643.2.2.31.1", GCRY_CIPHER_MODE_CFB },
+    { "1.2.643.2.2.31.2", GCRY_CIPHER_MODE_CFB },
+    { "1.2.643.2.2.31.3", GCRY_CIPHER_MODE_CFB },
+    { "1.2.643.2.2.31.4", GCRY_CIPHER_MODE_CFB },
+    { NULL }
+  };
+
 gcry_cipher_spec_t _gcry_cipher_spec_gost28147 =
   {
-    "GOST28147", NULL, NULL, 8, 256,
+    GCRY_CIPHER_GOST28147, {0, 0},
+    "GOST28147", NULL, oids_gost28147, 8, 256,
     sizeof (GOST28147_context),
     gost_setkey,
     gost_encrypt_block,
     gost_decrypt_block,
+    NULL, NULL, NULL, gost_set_extra_info,
   };