[CRYPTO] aes-generic: Make key generation exportable

This patch exports four tables and the set_key() routine. This ressources
can be shared by other AES implementations (aes-x86_64 for instance).
The decryption key has been turned around (deckey[0] is the first piece
of the key instead of deckey[keylen+20]). The encrypt/decrypt functions
are looking now identical (except they are using different tables and
key).

Signed-off-by: Sebastian Siewior <sebastian@breakpoint.cc>
Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au>

2 files changed, 136 insertions, 129 deletions

diff --git a/crypto/aes_generic.c b/crypto/aes_generic.c
index df8df4d346d2..cf30af74480f 100644
--- a/crypto/aes_generic.c
+++ b/crypto/aes_generic.c
@@ -47,11 +47,6 @@
  * ---------------------------------------------------------------------------
  */
 
-/* Some changes from the Gladman version:
-    s/RIJNDAEL(e_key)/E_KEY/g
-    s/RIJNDAEL(d_key)/D_KEY/g
-*/
-
 #include <crypto/aes.h>
 #include <linux/module.h>
 #include <linux/init.h>
@@ -60,32 +55,26 @@
 #include <linux/crypto.h>
 #include <asm/byteorder.h>
 
-/*
- * #define byte(x, nr) ((unsigned char)((x) >> (nr*8))) 
- */
 static inline u8 byte(const u32 x, const unsigned n)
 {
         return x >> (n << 3);
 }
 
-struct aes_ctx {
-        int key_length;
-        u32 buf[120];
-};
-
-#define E_KEY (&ctx->buf[0])
-#define D_KEY (&ctx->buf[60])
-
 static u8 pow_tab[256] __initdata;
 static u8 log_tab[256] __initdata;
 static u8 sbx_tab[256] __initdata;
 static u8 isb_tab[256] __initdata;
 static u32 rco_tab[10];
-static u32 ft_tab[4][256];
-static u32 it_tab[4][256];
 
-static u32 fl_tab[4][256];
-static u32 il_tab[4][256];
+u32 crypto_ft_tab[4][256];
+u32 crypto_fl_tab[4][256];
+u32 crypto_it_tab[4][256];
+u32 crypto_il_tab[4][256];
+
+EXPORT_SYMBOL_GPL(crypto_ft_tab);
+EXPORT_SYMBOL_GPL(crypto_fl_tab);
+EXPORT_SYMBOL_GPL(crypto_it_tab);
+EXPORT_SYMBOL_GPL(crypto_il_tab);
 
 static inline u8 __init f_mult(u8 a, u8 b)
 {
@@ -134,37 +123,37 @@ static void __init gen_tabs(void)
                 p = sbx_tab[i];
 
                 t = p;
-                fl_tab[0][i] = t;
-                fl_tab[1][i] = rol32(t, 8);
-                fl_tab[2][i] = rol32(t, 16);
-                fl_tab[3][i] = rol32(t, 24);
+                crypto_fl_tab[0][i] = t;
+                crypto_fl_tab[1][i] = rol32(t, 8);
+                crypto_fl_tab[2][i] = rol32(t, 16);
+                crypto_fl_tab[3][i] = rol32(t, 24);
 
                 t = ((u32) ff_mult(2, p)) |
                     ((u32) p << 8) |
                     ((u32) p << 16) | ((u32) ff_mult(3, p) << 24);
 
-                ft_tab[0][i] = t;
-                ft_tab[1][i] = rol32(t, 8);
-                ft_tab[2][i] = rol32(t, 16);
-                ft_tab[3][i] = rol32(t, 24);
+                crypto_ft_tab[0][i] = t;
+                crypto_ft_tab[1][i] = rol32(t, 8);
+                crypto_ft_tab[2][i] = rol32(t, 16);
+                crypto_ft_tab[3][i] = rol32(t, 24);
 
                 p = isb_tab[i];
 
                 t = p;
-                il_tab[0][i] = t;
-                il_tab[1][i] = rol32(t, 8);
-                il_tab[2][i] = rol32(t, 16);
-                il_tab[3][i] = rol32(t, 24);
+                crypto_il_tab[0][i] = t;
+                crypto_il_tab[1][i] = rol32(t, 8);
+                crypto_il_tab[2][i] = rol32(t, 16);
+                crypto_il_tab[3][i] = rol32(t, 24);
 
                 t = ((u32) ff_mult(14, p)) |
                     ((u32) ff_mult(9, p) << 8) |
                     ((u32) ff_mult(13, p) << 16) |
                     ((u32) ff_mult(11, p) << 24);
 
-                it_tab[0][i] = t;
-                it_tab[1][i] = rol32(t, 8);
-                it_tab[2][i] = rol32(t, 16);
-                it_tab[3][i] = rol32(t, 24);
+                crypto_it_tab[0][i] = t;
+                crypto_it_tab[1][i] = rol32(t, 8);
+                crypto_it_tab[2][i] = rol32(t, 16);
+                crypto_it_tab[3][i] = rol32(t, 24);
         }
 }
 
@@ -184,69 +173,69 @@ static void __init gen_tabs(void)
 } while (0)
 
 #define ls_box(x)               \
-        fl_tab[0][byte(x, 0)] ^ \
-        fl_tab[1][byte(x, 1)] ^ \
-        fl_tab[2][byte(x, 2)] ^ \
-        fl_tab[3][byte(x, 3)]
+        crypto_fl_tab[0][byte(x, 0)] ^  \
+        crypto_fl_tab[1][byte(x, 1)] ^  \
+        crypto_fl_tab[2][byte(x, 2)] ^  \
+        crypto_fl_tab[3][byte(x, 3)]
 
 #define loop4(i)        do {            \
         t = ror32(t, 8);                \
         t = ls_box(t) ^ rco_tab[i];     \
-        t ^= E_KEY[4 * i];              \
-        E_KEY[4 * i + 4] = t;           \
-        t ^= E_KEY[4 * i + 1];          \
-        E_KEY[4 * i + 5] = t;           \
-        t ^= E_KEY[4 * i + 2];          \
-        E_KEY[4 * i + 6] = t;           \
-        t ^= E_KEY[4 * i + 3];          \
-        E_KEY[4 * i + 7] = t;           \
+        t ^= ctx->key_enc[4 * i];               \
+        ctx->key_enc[4 * i + 4] = t;            \
+        t ^= ctx->key_enc[4 * i + 1];           \
+        ctx->key_enc[4 * i + 5] = t;            \
+        t ^= ctx->key_enc[4 * i + 2];           \
+        ctx->key_enc[4 * i + 6] = t;            \
+        t ^= ctx->key_enc[4 * i + 3];           \
+        ctx->key_enc[4 * i + 7] = t;            \
 } while (0)
 
 #define loop6(i)        do {            \
         t = ror32(t, 8);                \
         t = ls_box(t) ^ rco_tab[i];     \
-        t ^= E_KEY[6 * i];              \
-        E_KEY[6 * i + 6] = t;           \
-        t ^= E_KEY[6 * i + 1];          \
-        E_KEY[6 * i + 7] = t;           \
-        t ^= E_KEY[6 * i + 2];          \
-        E_KEY[6 * i + 8] = t;           \
-        t ^= E_KEY[6 * i + 3];          \
-        E_KEY[6 * i + 9] = t;           \
-        t ^= E_KEY[6 * i + 4];          \
-        E_KEY[6 * i + 10] = t;          \
-        t ^= E_KEY[6 * i + 5];          \
-        E_KEY[6 * i + 11] = t;          \
+        t ^= ctx->key_enc[6 * i];               \
+        ctx->key_enc[6 * i + 6] = t;            \
+        t ^= ctx->key_enc[6 * i + 1];           \
+        ctx->key_enc[6 * i + 7] = t;            \
+        t ^= ctx->key_enc[6 * i + 2];           \
+        ctx->key_enc[6 * i + 8] = t;            \
+        t ^= ctx->key_enc[6 * i + 3];           \
+        ctx->key_enc[6 * i + 9] = t;            \
+        t ^= ctx->key_enc[6 * i + 4];           \
+        ctx->key_enc[6 * i + 10] = t;           \
+        t ^= ctx->key_enc[6 * i + 5];           \
+        ctx->key_enc[6 * i + 11] = t;           \
 } while (0)
 
 #define loop8(i)        do {                    \
         t = ror32(t, 8);                        \
         t = ls_box(t) ^ rco_tab[i];             \