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.

4 files changed, 110 insertions, 74 deletions

diff --git a/src/block/des/des.cpp b/src/block/des/des.cpp
index 37520e0fc..1c9d37e6b 100644
--- a/src/block/des/des.cpp
+++ b/src/block/des/des.cpp
@@ -139,51 +139,63 @@ void des_decrypt(u32bit& L, u32bit& R,
 /*
 * DES Encryption
 */
-void DES::enc(const byte in[], byte out[]) const
+void DES::encrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u64bit T = (DES_IPTAB1[in[0]]     ) | (DES_IPTAB1[in[1]] << 1) |
-              (DES_IPTAB1[in[2]] << 2) | (DES_IPTAB1[in[3]] << 3) |
-              (DES_IPTAB1[in[4]] << 4) | (DES_IPTAB1[in[5]] << 5) |
-              (DES_IPTAB1[in[6]] << 6) | (DES_IPTAB2[in[7]]     );
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      u64bit T = (DES_IPTAB1[in[0]]     ) | (DES_IPTAB1[in[1]] << 1) |
+         (DES_IPTAB1[in[2]] << 2) | (DES_IPTAB1[in[3]] << 3) |
+         (DES_IPTAB1[in[4]] << 4) | (DES_IPTAB1[in[5]] << 5) |
+         (DES_IPTAB1[in[6]] << 6) | (DES_IPTAB2[in[7]]     );
+
+      u32bit L = static_cast<u32bit>(T >> 32);
+      u32bit R = static_cast<u32bit>(T);
 
-   u32bit L = static_cast<u32bit>(T >> 32);
-   u32bit R = static_cast<u32bit>(T);
+      des_encrypt(L, R, round_key);
 
-   des_encrypt(L, R, round_key);
+      T = (DES_FPTAB1[get_byte(0, L)] << 5) | (DES_FPTAB1[get_byte(1, L)] << 3) |
+         (DES_FPTAB1[get_byte(2, L)] << 1) | (DES_FPTAB2[get_byte(3, L)] << 1) |
+         (DES_FPTAB1[get_byte(0, R)] << 4) | (DES_FPTAB1[get_byte(1, R)] << 2) |
+         (DES_FPTAB1[get_byte(2, R)]     ) | (DES_FPTAB2[get_byte(3, R)]     );
 
-   T = (DES_FPTAB1[get_byte(0, L)] << 5) | (DES_FPTAB1[get_byte(1, L)] << 3) |
-       (DES_FPTAB1[get_byte(2, L)] << 1) | (DES_FPTAB2[get_byte(3, L)] << 1) |
-       (DES_FPTAB1[get_byte(0, R)] << 4) | (DES_FPTAB1[get_byte(1, R)] << 2) |
-       (DES_FPTAB1[get_byte(2, R)]     ) | (DES_FPTAB2[get_byte(3, R)]     );
+      T = rotate_left(T, 32);
 
-   T = rotate_left(T, 32);
+      store_be(T, out);
 
-   store_be(T, out);
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
 * DES Decryption
 */
-void DES::dec(const byte in[], byte out[]) const
+void DES::decrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u64bit T = (DES_IPTAB1[in[0]]     ) | (DES_IPTAB1[in[1]] << 1) |
-              (DES_IPTAB1[in[2]] << 2) | (DES_IPTAB1[in[3]] << 3) |
-              (DES_IPTAB1[in[4]] << 4) | (DES_IPTAB1[in[5]] << 5) |
-              (DES_IPTAB1[in[6]] << 6) | (DES_IPTAB2[in[7]]     );
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      u64bit T = (DES_IPTAB1[in[0]]     ) | (DES_IPTAB1[in[1]] << 1) |
+         (DES_IPTAB1[in[2]] << 2) | (DES_IPTAB1[in[3]] << 3) |
+         (DES_IPTAB1[in[4]] << 4) | (DES_IPTAB1[in[5]] << 5) |
+         (DES_IPTAB1[in[6]] << 6) | (DES_IPTAB2[in[7]]     );
+
+      u32bit L = static_cast<u32bit>(T >> 32);
+      u32bit R = static_cast<u32bit>(T);
 
-   u32bit L = static_cast<u32bit>(T >> 32);
-   u32bit R = static_cast<u32bit>(T);
+      des_decrypt(L, R, round_key);
 
-   des_decrypt(L, R, round_key);
+      T = (DES_FPTAB1[get_byte(0, L)] << 5) | (DES_FPTAB1[get_byte(1, L)] << 3) |
+         (DES_FPTAB1[get_byte(2, L)] << 1) | (DES_FPTAB2[get_byte(3, L)] << 1) |
+         (DES_FPTAB1[get_byte(0, R)] << 4) | (DES_FPTAB1[get_byte(1, R)] << 2) |
+         (DES_FPTAB1[get_byte(2, R)]     ) | (DES_FPTAB2[get_byte(3, R)]     );
 
-   T = (DES_FPTAB1[get_byte(0, L)] << 5) | (DES_FPTAB1[get_byte(1, L)] << 3) |
-       (DES_FPTAB1[get_byte(2, L)] << 1) | (DES_FPTAB2[get_byte(3, L)] << 1) |
-       (DES_FPTAB1[get_byte(0, R)] << 4) | (DES_FPTAB1[get_byte(1, R)] << 2) |
-       (DES_FPTAB1[get_byte(2, R)]     ) | (DES_FPTAB2[get_byte(3, R)]     );
+      T = rotate_left(T, 32);
 
-   T = rotate_left(T, 32);
+      store_be(T, out);
 
-   store_be(T, out);
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
@@ -197,55 +209,67 @@ void DES::key_schedule(const byte key[], u32bit)
 /*
 * TripleDES Encryption
 */
-void TripleDES::enc(const byte in[], byte out[]) const
+void TripleDES::encrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u64bit T = (DES_IPTAB1[in[0]]     ) | (DES_IPTAB1[in[1]] << 1) |
-              (DES_IPTAB1[in[2]] << 2) | (DES_IPTAB1[in[3]] << 3) |
-              (DES_IPTAB1[in[4]] << 4) | (DES_IPTAB1[in[5]] << 5) |
-              (DES_IPTAB1[in[6]] << 6) | (DES_IPTAB2[in[7]]     );
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      u64bit T = (DES_IPTAB1[in[0]]     ) | (DES_IPTAB1[in[1]] << 1) |
+                 (DES_IPTAB1[in[2]] << 2) | (DES_IPTAB1[in[3]] << 3) |
+                 (DES_IPTAB1[in[4]] << 4) | (DES_IPTAB1[in[5]] << 5) |
+                 (DES_IPTAB1[in[6]] << 6) | (DES_IPTAB2[in[7]]     );
+
+      u32bit L = static_cast<u32bit>(T >> 32);
+      u32bit R = static_cast<u32bit>(T);
 
-   u32bit L = static_cast<u32bit>(T >> 32);
-   u32bit R = static_cast<u32bit>(T);
+      des_encrypt(L, R, round_key);
+      des_decrypt(R, L, round_key + 32);
+      des_encrypt(L, R, round_key + 64);
 
-   des_encrypt(L, R, round_key);
-   des_decrypt(R, L, round_key + 32);
-   des_encrypt(L, R, round_key + 64);
+      T = (DES_FPTAB1[get_byte(0, L)] << 5) | (DES_FPTAB1[get_byte(1, L)] << 3) |
+          (DES_FPTAB1[get_byte(2, L)] << 1) | (DES_FPTAB2[get_byte(3, L)] << 1) |
+          (DES_FPTAB1[get_byte(0, R)] << 4) | (DES_FPTAB1[get_byte(1, R)] << 2) |
+          (DES_FPTAB1[get_byte(2, R)]     ) | (DES_FPTAB2[get_byte(3, R)]     );
 
-   T = (DES_FPTAB1[get_byte(0, L)] << 5) | (DES_FPTAB1[get_byte(1, L)] << 3) |
-       (DES_FPTAB1[get_byte(2, L)] << 1) | (DES_FPTAB2[get_byte(3, L)] << 1) |
-       (DES_FPTAB1[get_byte(0, R)] << 4) | (DES_FPTAB1[get_byte(1, R)] << 2) |
-       (DES_FPTAB1[get_byte(2, R)]     ) | (DES_FPTAB2[get_byte(3, R)]     );
+      T = rotate_left(T, 32);
 
-   T = rotate_left(T, 32);
+      store_be(T, out);
 
-   store_be(T, out);
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
 * TripleDES Decryption
 */
-void TripleDES::dec(const byte in[], byte out[]) const
+void TripleDES::decrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   u64bit T = (DES_IPTAB1[in[0]]     ) | (DES_IPTAB1[in[1]] << 1) |
-              (DES_IPTAB1[in[2]] << 2) | (DES_IPTAB1[in[3]] << 3) |
-              (DES_IPTAB1[in[4]] << 4) | (DES_IPTAB1[in[5]] << 5) |
-              (DES_IPTAB1[in[6]] << 6) | (DES_IPTAB2[in[7]]     );
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      u64bit T = (DES_IPTAB1[in[0]]     ) | (DES_IPTAB1[in[1]] << 1) |
+                 (DES_IPTAB1[in[2]] << 2) | (DES_IPTAB1[in[3]] << 3) |
+                 (DES_IPTAB1[in[4]] << 4) | (DES_IPTAB1[in[5]] << 5) |
+                 (DES_IPTAB1[in[6]] << 6) | (DES_IPTAB2[in[7]]     );
+
+      u32bit L = static_cast<u32bit>(T >> 32);
+      u32bit R = static_cast<u32bit>(T);
 
-   u32bit L = static_cast<u32bit>(T >> 32);
-   u32bit R = static_cast<u32bit>(T);
+      des_decrypt(L, R, round_key + 64);
+      des_encrypt(R, L, round_key + 32);
+      des_decrypt(L, R, round_key);
 
-   des_decrypt(L, R, round_key + 64);
-   des_encrypt(R, L, round_key + 32);
-   des_decrypt(L, R, round_key);
+      T = (DES_FPTAB1[get_byte(0, L)] << 5) | (DES_FPTAB1[get_byte(1, L)] << 3) |
+          (DES_FPTAB1[get_byte(2, L)] << 1) | (DES_FPTAB2[get_byte(3, L)] << 1) |
+          (DES_FPTAB1[get_byte(0, R)] << 4) | (DES_FPTAB1[get_byte(1, R)] << 2) |
+          (DES_FPTAB1[get_byte(2, R)]     ) | (DES_FPTAB2[get_byte(3, R)]     );
 
-   T = (DES_FPTAB1[get_byte(0, L)] << 5) | (DES_FPTAB1[get_byte(1, L)] << 3) |
-       (DES_FPTAB1[get_byte(2, L)] << 1) | (DES_FPTAB2[get_byte(3, L)] << 1) |
-       (DES_FPTAB1[get_byte(0, R)] << 4) | (DES_FPTAB1[get_byte(1, R)] << 2) |
-       (DES_FPTAB1[get_byte(2, R)]     ) | (DES_FPTAB2[get_byte(3, R)]     );
+      T = rotate_left(T, 32);
 
-   T = rotate_left(T, 32);
+      store_be(T, out);
 
-   store_be(T, out);
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
diff --git a/src/block/des/des.h b/src/block/des/des.h
index 6fa59de5e..39d1ac404 100644
--- a/src/block/des/des.h
+++ b/src/block/des/des.h
@@ -23,8 +23,8 @@ class BOTAN_DLL DES : public BlockCipher
       BlockCipher* clone() const { return new DES; }
       DES() : BlockCipher(8, 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);
 
       SecureBuffer<u32bit, 32> round_key;
@@ -41,8 +41,8 @@ class BOTAN_DLL TripleDES : public BlockCipher
       BlockCipher* clone() const { return new TripleDES; }
       TripleDES() : BlockCipher(8, 16, 24, 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);
 
       SecureBuffer<u32bit, 96> round_key;
diff --git a/src/block/des/desx.cpp b/src/block/des/desx.cpp
index e557901d3..1fc1c47f2 100644
--- a/src/block/des/desx.cpp
+++ b/src/block/des/desx.cpp
@@ -13,21 +13,33 @@ namespace Botan {
 /*
 * DESX Encryption
 */
-void DESX::enc(const byte in[], byte out[]) const
+void DESX::encrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   xor_buf(out, in, K1.begin(), BLOCK_SIZE);
-   des.encrypt(out);
-   xor_buf(out, K2.begin(), BLOCK_SIZE);
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      xor_buf(out, in, K1.begin(), BLOCK_SIZE);
+      des.encrypt(out);
+      xor_buf(out, K2.begin(), BLOCK_SIZE);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
 * DESX Decryption
 */
-void DESX::dec(const byte in[], byte out[]) const
+void DESX::decrypt_n(const byte in[], byte out[], u32bit blocks) const
    {
-   xor_buf(out, in, K2.begin(), BLOCK_SIZE);
-   des.decrypt(out);
-   xor_buf(out, K1.begin(), BLOCK_SIZE);
+   for(u32bit i = 0; i != blocks; ++i)
+      {
+      xor_buf(out, in, K2.begin(), BLOCK_SIZE);
+      des.decrypt(out);
+      xor_buf(out, K1.begin(), BLOCK_SIZE);
+
+      in += BLOCK_SIZE;
+      out += BLOCK_SIZE;
+      }
    }
 
 /*
diff --git a/src/block/des/desx.h b/src/block/des/desx.h
index 49ecc2421..d71335071 100644
--- a/src/block/des/desx.h
+++ b/src/block/des/desx.h
@@ -23,8 +23,8 @@ class BOTAN_DLL DESX : public BlockCipher
       BlockCipher* clone() const { return new DESX; }
       DESX() : BlockCipher(8, 24) {}
    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);
       SecureBuffer<byte, 8> K1, K2;
       DES des;