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.

2 files changed, 86 insertions, 74 deletions

diff --git a/src/block/twofish/twofish.cpp b/src/block/twofish/twofish.cpp
index 9784b00a2..6a482a8f3 100644
--- a/src/block/twofish/twofish.cpp
+++ b/src/block/twofish/twofish.cpp
@@ -14,91 +14,103 @@ namespace Botan {
 /*
 * Twofish Encryption
 */
-void Twofish::enc(const byte in[], byte out[]) const
+void Twofish::encrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u32bit A = load_le<u32bit>(in, 0) ^ round_key[0];
-   u32bit B = load_le<u32bit>(in, 1) ^ round_key[1];
-   u32bit C = load_le<u32bit>(in, 2) ^ round_key[2];
-   u32bit D = load_le<u32bit>(in, 3) ^ round_key[3];
-
-   for(u32bit j = 0; j != 16; j += 2)
+   for(u32bit i = 0; i != blocks; ++i)
       {
-      u32bit X, Y;
-
-      X = SBox0[get_byte(3, A)] ^ SBox1[get_byte(2, A)] ^
-          SBox2[get_byte(1, A)] ^ SBox3[get_byte(0, A)];
-      Y = SBox0[get_byte(0, B)] ^ SBox1[get_byte(3, B)] ^
-          SBox2[get_byte(2, B)] ^ SBox3[get_byte(1, B)];
-      X += Y;
-      Y += X + round_key[2*j + 9];
-      X += round_key[2*j + 8];
-
-      C = rotate_right(C ^ X, 1);
-      D = rotate_left(D, 1) ^ Y;
-
-      X = SBox0[get_byte(3, C)] ^ SBox1[get_byte(2, C)] ^
-          SBox2[get_byte(1, C)] ^ SBox3[get_byte(0, C)];
-      Y = SBox0[get_byte(0, D)] ^ SBox1[get_byte(3, D)] ^
-          SBox2[get_byte(2, D)] ^ SBox3[get_byte(1, D)];
-      X += Y;
-      Y += X + round_key[2*j + 11];
-      X += round_key[2*j + 10];
-
-      A = rotate_right(A ^ X, 1);
-      B = rotate_left(B, 1) ^ Y;
-      }
+      u32bit A = load_le<u32bit>(in, 0) ^ round_key[0];
+      u32bit B = load_le<u32bit>(in, 1) ^ round_key[1];
+      u32bit C = load_le<u32bit>(in, 2) ^ round_key[2];
+      u32bit D = load_le<u32bit>(in, 3) ^ round_key[3];
 
-   C ^= round_key[4];
-   D ^= round_key[5];
-   A ^= round_key[6];
-   B ^= round_key[7];
+      for(u32bit j = 0; j != 16; j += 2)
+         {
+         u32bit X, Y;
+
+         X = SBox0[get_byte(3, A)] ^ SBox1[get_byte(2, A)] ^
+             SBox2[get_byte(1, A)] ^ SBox3[get_byte(0, A)];
+         Y = SBox0[get_byte(0, B)] ^ SBox1[get_byte(3, B)] ^
+             SBox2[get_byte(2, B)] ^ SBox3[get_byte(1, B)];
+         X += Y;
+         Y += X + round_key[2*j + 9];
+         X += round_key[2*j + 8];
+
+         C = rotate_right(C ^ X, 1);
+         D = rotate_left(D, 1) ^ Y;
+
+         X = SBox0[get_byte(3, C)] ^ SBox1[get_byte(2, C)] ^
+             SBox2[get_byte(1, C)] ^ SBox3[get_byte(0, C)];
+         Y = SBox0[get_byte(0, D)] ^ SBox1[get_byte(3, D)] ^
+             SBox2[get_byte(2, D)] ^ SBox3[get_byte(1, D)];
+         X += Y;
+         Y += X + round_key[2*j + 11];
+         X += round_key[2*j + 10];
+
+         A = rotate_right(A ^ X, 1);
+         B = rotate_left(B, 1) ^ Y;
+         }
 
-   store_le(out, C, D, A, B);
+      C ^= round_key[4];
+      D ^= round_key[5];
+      A ^= round_key[6];
+      B ^= round_key[7];
+
+      store_le(out, C, D, A, B);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
 * Twofish Decryption
 */
-void Twofish::dec(const byte in[], byte out[]) const
+void Twofish::decrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u32bit A = load_le<u32bit>(in, 0) ^ round_key[4];
-   u32bit B = load_le<u32bit>(in, 1) ^ round_key[5];
-   u32bit C = load_le<u32bit>(in, 2) ^ round_key[6];
-   u32bit D = load_le<u32bit>(in, 3) ^ round_key[7];
-
-   for(u32bit j = 0; j != 16; j += 2)
+   for(u32bit i = 0; i != blocks; ++i)
       {
-      u32bit X, Y;
-
-      X = SBox0[get_byte(3, A)] ^ SBox1[get_byte(2, A)] ^
-          SBox2[get_byte(1, A)] ^ SBox3[get_byte(0, A)];
-      Y = SBox0[get_byte(0, B)] ^ SBox1[get_byte(3, B)] ^
-          SBox2[get_byte(2, B)] ^ SBox3[get_byte(1, B)];
-      X += Y;
-      Y += X + round_key[39 - 2*j];
-      X += round_key[38 - 2*j];
-
-      C = rotate_left(C, 1) ^ X;
-      D = rotate_right(D ^ Y, 1);
-
-      X = SBox0[get_byte(3, C)] ^ SBox1[get_byte(2, C)] ^
-          SBox2[get_byte(1, C)] ^ SBox3[get_byte(0, C)];
-      Y = SBox0[get_byte(0, D)] ^ SBox1[get_byte(3, D)] ^
-          SBox2[get_byte(2, D)] ^ SBox3[get_byte(1, D)];
-      X += Y;
-      Y += X + round_key[37 - 2*j];
-      X += round_key[36 - 2*j];
-
-      A = rotate_left(A, 1) ^ X;
-      B = rotate_right(B ^ Y, 1);
-      }
+      u32bit A = load_le<u32bit>(in, 0) ^ round_key[4];
+      u32bit B = load_le<u32bit>(in, 1) ^ round_key[5];
+      u32bit C = load_le<u32bit>(in, 2) ^ round_key[6];
+      u32bit D = load_le<u32bit>(in, 3) ^ round_key[7];
 
-   C ^= round_key[0];
-   D ^= round_key[1];
-   A ^= round_key[2];
-   B ^= round_key[3];
+      for(u32bit j = 0; j != 16; j += 2)
+         {
+         u32bit X, Y;
+
+         X = SBox0[get_byte(3, A)] ^ SBox1[get_byte(2, A)] ^
+             SBox2[get_byte(1, A)] ^ SBox3[get_byte(0, A)];
+         Y = SBox0[get_byte(0, B)] ^ SBox1[get_byte(3, B)] ^
+             SBox2[get_byte(2, B)] ^ SBox3[get_byte(1, B)];
+         X += Y;
+         Y += X + round_key[39 - 2*j];
+         X += round_key[38 - 2*j];
+
+         C = rotate_left(C, 1) ^ X;
+         D = rotate_right(D ^ Y, 1);
+
+         X = SBox0[get_byte(3, C)] ^ SBox1[get_byte(2, C)] ^
+             SBox2[get_byte(1, C)] ^ SBox3[get_byte(0, C)];
+         Y = SBox0[get_byte(0, D)] ^ SBox1[get_byte(3, D)] ^
+             SBox2[get_byte(2, D)] ^ SBox3[get_byte(1, D)];
+         X += Y;
+         Y += X + round_key[37 - 2*j];
+         X += round_key[36 - 2*j];
+
+         A = rotate_left(A, 1) ^ X;
+         B = rotate_right(B ^ Y, 1);
+         }
 
-   store_le(out, C, D, A, B);
+      C ^= round_key[0];
+      D ^= round_key[1];
+      A ^= round_key[2];
+      B ^= round_key[3];
+
+      store_le(out, C, D, A, B);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
diff --git a/src/block/twofish/twofish.h b/src/block/twofish/twofish.h
index 0640e32f8..640fb58ad 100644
--- a/src/block/twofish/twofish.h
+++ b/src/block/twofish/twofish.h
@@ -23,8 +23,8 @@ class BOTAN_DLL Twofish : public BlockCipher
       BlockCipher* clone() const { return new Twofish; }
       Twofish() : BlockCipher(16, 16, 32, 8) {}
    private:
-      void enc(const byte[], byte[]) const;
-      void dec(const byte[], byte[]) const;
+      void encrypt_n(const byte in[], byte out[], u32bit blocks) const;
+      void decrypt_n(const byte in[], byte out[], u32bit blocks) const;
       void key_schedule(const byte[], u32bit);
 
       static void rs_mul(byte[4], byte, u32bit);