Change the BlockCipher interface to support multi-block encryption and

decryption. Currently only used for counter mode. Doesn't offer much
advantage as-is (though might help slightly, in terms of cache effects),
but allows for SIMD implementations to process multiple blocks in parallel
when possible. Particularly thinking here of Serpent; TEA/XTEA also seem
promising in this sense, as is Threefish once that is implemented as a
standalone block cipher.

1 files changed, 71 insertions, 59 deletions

diff --git a/src/block/misty1/misty1.cpp b/src/block/misty1/misty1.cpp
index a35ff584d..8a92824cc 100644
--- a/src/block/misty1/misty1.cpp
+++ b/src/block/misty1/misty1.cpp
@@ -1,6 +1,6 @@
 /*
 * MISTY1
-* (C) 1999-2007 Jack Lloyd
+* (C) 1999-2009 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
@@ -102,89 +102,101 @@ u16bit FI(u16bit input, u16bit key7, u16bit key9)
 /*
 * MISTY1 Encryption
 */
-void MISTY1::enc(const byte in[], byte out[]) const
+void MISTY1::encrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u16bit B0 = load_be<u16bit>(in, 0);
-   u16bit B1 = load_be<u16bit>(in, 1);
-   u16bit B2 = load_be<u16bit>(in, 2);
-   u16bit B3 = load_be<u16bit>(in, 3);
-
-   for(u32bit j = 0; j != 12; j += 3)
+   for(u32bit i = 0; i != blocks; ++i)
       {
-      const u16bit* RK = EK + 8 * j;
+      u16bit B0 = load_be<u16bit>(in, 0);
+      u16bit B1 = load_be<u16bit>(in, 1);
+      u16bit B2 = load_be<u16bit>(in, 2);
+      u16bit B3 = load_be<u16bit>(in, 3);
 
-      B1 ^= B0 & RK[0];
-      B0 ^= B1 | RK[1];
-      B3 ^= B2 & RK[2];
-      B2 ^= B3 | RK[3];
+      for(u32bit j = 0; j != 12; j += 3)
+         {
+         const u16bit* RK = EK + 8 * j;
 
-      u32bit T0, T1;
+         B1 ^= B0 & RK[0];
+         B0 ^= B1 | RK[1];
+         B3 ^= B2 & RK[2];
+         B2 ^= B3 | RK[3];
 
-      T0  = FI(B0 ^ RK[ 4], RK[ 5], RK[ 6]) ^ B1;
-      T1  = FI(B1 ^ RK[ 7], RK[ 8], RK[ 9]) ^ T0;
-      T0  = FI(T0 ^ RK[10], RK[11], RK[12]) ^ T1;
+         u32bit T0, T1;
 
-      B2 ^= T1 ^ RK[13];
-      B3 ^= T0;
+         T0  = FI(B0 ^ RK[ 4], RK[ 5], RK[ 6]) ^ B1;
+         T1  = FI(B1 ^ RK[ 7], RK[ 8], RK[ 9]) ^ T0;
+         T0  = FI(T0 ^ RK[10], RK[11], RK[12]) ^ T1;
 
-      T0  = FI(B2 ^ RK[14], RK[15], RK[16]) ^ B3;
-      T1  = FI(B3 ^ RK[17], RK[18], RK[19]) ^ T0;
-      T0  = FI(T0 ^ RK[20], RK[21], RK[22]) ^ T1;
+         B2 ^= T1 ^ RK[13];
+         B3 ^= T0;
 
-      B0 ^= T1 ^ RK[23];
-      B1 ^= T0;
-      }
+         T0  = FI(B2 ^ RK[14], RK[15], RK[16]) ^ B3;
+         T1  = FI(B3 ^ RK[17], RK[18], RK[19]) ^ T0;
+         T0  = FI(T0 ^ RK[20], RK[21], RK[22]) ^ T1;
+
+         B0 ^= T1 ^ RK[23];
+         B1 ^= T0;
+         }
 
-   B1 ^= B0 & EK[96];
-   B0 ^= B1 | EK[97];
-   B3 ^= B2 & EK[98];
-   B2 ^= B3 | EK[99];
+      B1 ^= B0 & EK[96];
+      B0 ^= B1 | EK[97];
+      B3 ^= B2 & EK[98];
+      B2 ^= B3 | EK[99];
 
-   store_be(out, B2, B3, B0, B1);
+      store_be(out, B2, B3, B0, B1);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
 * MISTY1 Decryption
 */
-void MISTY1::dec(const byte in[], byte out[]) const
+void MISTY1::decrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u16bit B0 = load_be<u16bit>(in, 2);
-   u16bit B1 = load_be<u16bit>(in, 3);
-   u16bit B2 = load_be<u16bit>(in, 0);
-   u16bit B3 = load_be<u16bit>(in, 1);
-
-   for(u32bit j = 0; j != 12; j += 3)
+   for(u32bit i = 0; i != blocks; ++i)
       {
-      const u16bit* RK = DK + 8 * j;
+      u16bit B0 = load_be<u16bit>(in, 2);
+      u16bit B1 = load_be<u16bit>(in, 3);
+      u16bit B2 = load_be<u16bit>(in, 0);
+      u16bit B3 = load_be<u16bit>(in, 1);
 
-      B2 ^= B3 | RK[0];
-      B3 ^= B2 & RK[1];
-      B0 ^= B1 | RK[2];
-      B1 ^= B0 & RK[3];
+      for(u32bit j = 0; j != 12; j += 3)
+         {
+         const u16bit* RK = DK + 8 * j;
 
-      u32bit T0, T1;
+         B2 ^= B3 | RK[0];
+         B3 ^= B2 & RK[1];
+         B0 ^= B1 | RK[2];
+         B1 ^= B0 & RK[3];
 
-      T0  = FI(B2 ^ RK[ 4], RK[ 5], RK[ 6]) ^ B3;
-      T1  = FI(B3 ^ RK[ 7], RK[ 8], RK[ 9]) ^ T0;
-      T0  = FI(T0 ^ RK[10], RK[11], RK[12]) ^ T1;
+         u32bit T0, T1;
 
-      B0 ^= T1 ^ RK[13];
-      B1 ^= T0;
+         T0  = FI(B2 ^ RK[ 4], RK[ 5], RK[ 6]) ^ B3;
+         T1  = FI(B3 ^ RK[ 7], RK[ 8], RK[ 9]) ^ T0;
+         T0  = FI(T0 ^ RK[10], RK[11], RK[12]) ^ T1;
 
-      T0  = FI(B0 ^ RK[14], RK[15], RK[16]) ^ B1;
-      T1  = FI(B1 ^ RK[17], RK[18], RK[19]) ^ T0;
-      T0  = FI(T0 ^ RK[20], RK[21], RK[22]) ^ T1;
+         B0 ^= T1 ^ RK[13];
+         B1 ^= T0;
 
-      B2 ^= T1 ^ RK[23];
-      B3 ^= T0;
-      }
+         T0  = FI(B0 ^ RK[14], RK[15], RK[16]) ^ B1;
+         T1  = FI(B1 ^ RK[17], RK[18], RK[19]) ^ T0;
+         T0  = FI(T0 ^ RK[20], RK[21], RK[22]) ^ T1;
+
+         B2 ^= T1 ^ RK[23];
+         B3 ^= T0;
+         }
 
-   B2 ^= B3 | DK[96];
-   B3 ^= B2 & DK[97];
-   B0 ^= B1 | DK[98];
-   B1 ^= B0 & DK[99];
+      B2 ^= B3 | DK[96];
+      B3 ^= B2 & DK[97];
+      B0 ^= B1 | DK[98];
+      B1 ^= B0 & DK[99];
 
-   store_be(out, B0, B1, B2, B3);
+      store_be(out, B0, B1, B2, B3);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*