In all cases where the block size of the cipher is fixed, the key

parameters are as well. So make them template paramters.

The sole exception was AES, because you could either initialize AES
with a fixed key length, in which case it would only be that specific
key length, or not, in which case it would support any valid AES key
size. This is removed in this checkin; you have to specifically ask for
AES-128, AES-192, or AES-256, depending on which one you want.

This is probably actually a good thing, because every implementation
other than the base one (SSSE3, AES-NI, OpenSSL) did not support
"AES", only the versions with specific fixed key sizes. So forcing
the user to ask for the one they want ensures they get the ones
that are faster and/or safer.

30 files changed, 176 insertions, 137 deletions

diff --git a/src/block/aes/aes.cpp b/src/block/aes/aes.cpp
index b317fa735..7f6c5ea9c 100644
--- a/src/block/aes/aes.cpp
+++ b/src/block/aes/aes.cpp
@@ -410,13 +410,16 @@ const u32bit TD[1024] = {
    0x3C498B28, 0x0D9541FF, 0xA8017139, 0x0CB3DE08, 0xB4E49CD8, 0x56C19064,
    0xCB84617B, 0x32B670D5, 0x6C5C7448, 0xB85742D0 };
 
-}
-
 /*
 * AES Encryption
 */
-void AES::encrypt_n(const byte in[], byte out[], size_t blocks) const
+void aes_encrypt_n(const byte in[], byte out[],
+                   size_t blocks,
+                   const MemoryRegion<u32bit>& EK,
+                   const MemoryRegion<byte>& ME)
    {
+   const size_t BLOCK_SIZE = 16;
+
    const u32bit* TE0 = TE;
    const u32bit* TE1 = TE + 256;
    const u32bit* TE2 = TE + 512;
@@ -522,8 +525,12 @@ void AES::encrypt_n(const byte in[], byte out[], size_t blocks) const
 /*
 * AES Decryption
 */
-void AES::decrypt_n(const byte in[], byte out[], size_t blocks) const
+void aes_decrypt_n(const byte in[], byte out[], size_t blocks,
+                   const MemoryRegion<u32bit>& DK,
+                   const MemoryRegion<byte>& MD)
    {
+   const size_t BLOCK_SIZE = 16;
+
    const u32bit* TD0 = TD;
    const u32bit* TD1 = TD + 256;
    const u32bit* TD2 = TD + 512;
@@ -600,9 +607,19 @@ void AES::decrypt_n(const byte in[], byte out[], size_t blocks) const
    }
 
 /*
-* AES Key Schedule
+* AES Byte Substitution
 */
-void AES::key_schedule(const byte key[], size_t length)
+u32bit aes_S(u32bit input)
+   {
+   return make_u32bit(SE[get_byte(0, input)], SE[get_byte(1, input)],
+                      SE[get_byte(2, input)], SE[get_byte(3, input)]);
+   }
+
+void aes_key_schedule(const byte key[], size_t length,
+                      MemoryRegion<u32bit>& EK,
+                      MemoryRegion<u32bit>& DK,
+                      MemoryRegion<byte>& ME,
+                      MemoryRegion<byte>& MD)
    {
    static const u32bit RC[10] = {
       0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000,
@@ -618,11 +635,11 @@ void AES::key_schedule(const byte key[], size_t length)
 
    for(size_t i = X; i < 4*(rounds+1); i += X)
       {
-      XEK[i] = XEK[i-X] ^ S(rotate_left(XEK[i-1], 8)) ^ RC[(i-X)/X];
+      XEK[i] = XEK[i-X] ^ aes_S(rotate_left(XEK[i-1], 8)) ^ RC[(i-X)/X];
       for(size_t j = 1; j != X; ++j)
          {
          if(X == 8 && j == 4)
-            XEK[i+j] = XEK[i+j-X] ^ S(XEK[i+j-1]);
+            XEK[i+j] = XEK[i+j-X] ^ aes_S(XEK[i+j-1]);
          else
             XEK[i+j] = XEK[i+j-X] ^ XEK[i+j-1];
          }
@@ -652,38 +669,70 @@ void AES::key_schedule(const byte key[], size_t length)
    DK.set(&XDK[0], length + 24);
    }
 
-/*
-* AES Byte Substitution
-*/
-u32bit AES::S(u32bit input)
+}
+
+void AES_128::encrypt_n(const byte in[], byte out[], size_t blocks) const
    {
-   return make_u32bit(SE[get_byte(0, input)], SE[get_byte(1, input)],
-                      SE[get_byte(2, input)], SE[get_byte(3, input)]);
+   aes_encrypt_n(in, out, blocks, EK, ME);
    }
 
-/*
-* AES Constructor
-*/
-AES::AES() : BlockCipher_Fixed_Block_Size(16, 32, 8),
-             EK(0), ME(16), DK(0), MD(16)
+void AES_128::decrypt_n(const byte in[], byte out[], size_t blocks) const
    {
+   aes_decrypt_n(in, out, blocks, DK, MD);
    }
 
-/*
-* AES Constructor
-*/
-AES::AES(size_t key_size) : BlockCipher_Fixed_Block_Size(key_size),
-                            EK(key_size+24), ME(16),
-                            DK(key_size+24), MD(16)
+void AES_128::key_schedule(const byte key[], size_t length)
    {
-   if(key_size != 16 && key_size != 24 && key_size != 32)
-      throw Invalid_Key_Length(name(), key_size);
+   aes_key_schedule(key, length, EK, DK, ME, MD);
    }
 
-/*
-* Clear memory of sensitive data
-*/
-void AES::clear()
+void AES_128::clear()
+   {
+   zeroise(EK);
+   zeroise(DK);
+   zeroise(ME);
+   zeroise(MD);
+   }
+
+void AES_192::encrypt_n(const byte in[], byte out[], size_t blocks) const
+   {
+   aes_encrypt_n(in, out, blocks, EK, ME);
+   }
+
+void AES_192::decrypt_n(const byte in[], byte out[], size_t blocks) const
+   {
+   aes_decrypt_n(in, out, blocks, DK, MD);
+   }
+
+void AES_192::key_schedule(const byte key[], size_t length)
+   {
+   aes_key_schedule(key, length, EK, DK, ME, MD);
+   }
+
+void AES_192::clear()
+   {
+   zeroise(EK);
+   zeroise(DK);
+   zeroise(ME);
+   zeroise(MD);
+   }
+
+void AES_256::encrypt_n(const byte in[], byte out[], size_t blocks) const
+   {
+   aes_encrypt_n(in, out, blocks, EK, ME);
+   }
+
+void AES_256::decrypt_n(const byte in[], byte out[], size_t blocks) const
+   {
+   aes_decrypt_n(in, out, blocks, DK, MD);
+   }
+
+void AES_256::key_schedule(const byte key[], size_t length)
+   {
+   aes_key_schedule(key, length, EK, DK, ME, MD);
+   }
+
+void AES_256::clear()
    {
    zeroise(EK);
    zeroise(DK);
diff --git a/src/block/aes/aes.h b/src/block/aes/aes.h
index d2e051f83..a165f83b5 100644
--- a/src/block/aes/aes.h
+++ b/src/block/aes/aes.h
@@ -1,6 +1,6 @@
 /*
 * AES
-* (C) 1999-2009 Jack Lloyd
+* (C) 1999-2010 Jack Lloyd
 *
 * Distributed under the terms of the Botan license
 */
@@ -13,68 +13,69 @@
 namespace Botan {
 
 /**
-* Rijndael aka AES
+* AES-128
 */
-class BOTAN_DLL AES : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL AES_128 : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
-      std::string name() const { return "AES"; }
+      AES_128() : EK(40), DK(40), ME(16), MD(16) {}
 
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
       void decrypt_n(const byte in[], byte out[], size_t blocks) const;
 
       void clear();
-      BlockCipher* clone() const { return new AES; }
-
-      AES();
-
-      /**
-      * AES fixed to a particular key_size (16, 24, or 32 bytes)
-      * @param key_size the chosen fixed key size
-      */
-      AES(size_t key_size);
-   private:
-      void key_schedule(const byte[], size_t);
-      static u32bit S(u32bit);
 
-      SecureVector<u32bit> EK;
-      SecureVector<byte> ME;
-
-      SecureVector<u32bit > DK;
-      SecureVector<byte> MD;
-   };
-
-/**
-* AES-128
-*/
-class BOTAN_DLL AES_128 : public AES
-   {
-   public:
       std::string name() const { return "AES-128"; }
       BlockCipher* clone() const { return new AES_128; }
-      AES_128() : AES(16) {}
+   private:
+      void key_schedule(const byte key[], size_t length);
+
+      SecureVector<u32bit> EK, DK;
+      SecureVector<byte> ME, MD;
    };
 
 /**
 * AES-192
 */
-class BOTAN_DLL AES_192 : public AES
+class BOTAN_DLL AES_192 : public Block_Cipher_Fixed_Params<16, 24>
    {
    public:
+      AES_192() : EK(48), DK(48), ME(16), MD(16) {}
+
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+
+      void clear();
+
       std::string name() const { return "AES-192"; }
       BlockCipher* clone() const { return new AES_192; }
-      AES_192() : AES(24) {}
+   private:
+      void key_schedule(const byte key[], size_t length);
+
+      SecureVector<u32bit> EK, DK;
+      SecureVector<byte> ME, MD;
    };
 
 /**
 * AES-256
 */
-class BOTAN_DLL AES_256 : public AES
+class BOTAN_DLL AES_256 : public Block_Cipher_Fixed_Params<16, 32>
    {
    public:
+      AES_256() : EK(56), DK(56), ME(16), MD(16) {}
+
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+
+      void clear();
+
       std::string name() const { return "AES-256"; }
       BlockCipher* clone() const { return new AES_256; }
-      AES_256() : AES(32) {}
+   private:
+      void key_schedule(const byte key[], size_t length);
+
+      SecureVector<u32bit> EK, DK;
+      SecureVector<byte> ME, MD;
    };
 
 }
diff --git a/src/block/aes_ssse3/aes_ssse3.h b/src/block/aes_ssse3/aes_ssse3.h
index 59bb85f12..686b7999f 100644
--- a/src/block/aes_ssse3/aes_ssse3.h
+++ b/src/block/aes_ssse3/aes_ssse3.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * AES-128 using SSSE3
 */
-class BOTAN_DLL AES_128_SSSE3 : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL AES_128_SSSE3 : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,8 +25,7 @@ class BOTAN_DLL AES_128_SSSE3 : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "AES-128"; }
       BlockCipher* clone() const { return new AES_128_SSSE3; }
 
-      AES_128_SSSE3() : BlockCipher_Fixed_Block_Size(16),
-                        EK(44), DK(44) {}
+      AES_128_SSSE3() : EK(44), DK(44) {}
    private:
       void key_schedule(const byte[], size_t);
 
@@ -36,7 +35,7 @@ class BOTAN_DLL AES_128_SSSE3 : public BlockCipher_Fixed_Block_Size<16>
 /**
 * AES-192 using SSSE3
 */
-class BOTAN_DLL AES_192_SSSE3 : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL AES_192_SSSE3 : public Block_Cipher_Fixed_Params<16, 24>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -46,8 +45,7 @@ class BOTAN_DLL AES_192_SSSE3 : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "AES-192"; }
       BlockCipher* clone() const { return new AES_192_SSSE3; }
 
-      AES_192_SSSE3() : BlockCipher_Fixed_Block_Size(24),
-                        EK(52), DK(52) {}
+      AES_192_SSSE3() : EK(52), DK(52) {}
    private:
       void key_schedule(const byte[], size_t);
 
@@ -57,7 +55,7 @@ class BOTAN_DLL AES_192_SSSE3 : public BlockCipher_Fixed_Block_Size<16>
 /**
 * AES-256 using SSSE3
 */
-class BOTAN_DLL AES_256_SSSE3 : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL AES_256_SSSE3 : public Block_Cipher_Fixed_Params<16, 32>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -67,8 +65,7 @@ class BOTAN_DLL AES_256_SSSE3 : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "AES-256"; }
       BlockCipher* clone() const { return new AES_256_SSSE3; }
 
-      AES_256_SSSE3() : BlockCipher_Fixed_Block_Size(32),
-                        EK(60), DK(60) {}
+      AES_256_SSSE3() : EK(60), DK(60) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/block_cipher.h b/src/block/block_cipher.h
index 3e14e0739..b5a3c8439 100644
--- a/src/block/block_cipher.h
+++ b/src/block/block_cipher.h
@@ -115,17 +115,17 @@ class BOTAN_DLL BlockCipher : public SymmetricAlgorithm
       virtual void clear() = 0;
    };
 
-template<size_t N>
-class BlockCipher_Fixed_Block_Size : public BlockCipher
+/**
+* Represents a block cipher with a single fixed block size
+*/
+template<size_t BS, size_t KMIN, size_t KMAX = 0, size_t KMOD = 1>
+class Block_Cipher_Fixed_Params : public BlockCipher
    {
    public:
-      BlockCipher_Fixed_Block_Size(size_t kmin,
-                                   size_t kmax = 0,
-                                   size_t kmod = 1) :
-         BlockCipher(kmin, kmax, kmod) {}
+      Block_Cipher_Fixed_Params() : BlockCipher(KMIN, KMAX, KMOD) {}
 
-      enum { BLOCK_SIZE = N };
-      size_t block_size() const { return N; }
+      enum { BLOCK_SIZE = BS };
+      size_t block_size() const { return BS; }
    };
 
 }
diff --git a/src/block/blowfish/blowfish.h b/src/block/blowfish/blowfish.h
index c9bf8b2e0..b89ffcaaa 100644
--- a/src/block/blowfish/blowfish.h
+++ b/src/block/blowfish/blowfish.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * Blowfish
 */
-class BOTAN_DLL Blowfish : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL Blowfish : public Block_Cipher_Fixed_Params<8, 1, 56>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL Blowfish : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "Blowfish"; }
       BlockCipher* clone() const { return new Blowfish; }
 
-      Blowfish() : BlockCipher_Fixed_Block_Size(1, 56), S(1024), P(18) {}
+      Blowfish() : S(1024), P(18) {}
    private:
       void key_schedule(const byte[], size_t);
       void generate_sbox(MemoryRegion<u32bit>& box,
diff --git a/src/block/cast/cast128.h b/src/block/cast/cast128.h
index 3ecbcaa5a..10c646c94 100644
--- a/src/block/cast/cast128.h
+++ b/src/block/cast/cast128.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * CAST-128
 */
-class BOTAN_DLL CAST_128 : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL CAST_128 : public Block_Cipher_Fixed_Params<8, 11, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL CAST_128 : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "CAST-128"; }
       BlockCipher* clone() const { return new CAST_128; }
 
-      CAST_128() : BlockCipher_Fixed_Block_Size(11, 16), MK(16), RK(16) {}
+      CAST_128() : MK(16), RK(16) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/cast/cast256.h b/src/block/cast/cast256.h
index 0dda7f0d7..2f2beef47 100644
--- a/src/block/cast/cast256.h
+++ b/src/block/cast/cast256.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * CAST-256
 */
-class BOTAN_DLL CAST_256 : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL CAST_256 : public Block_Cipher_Fixed_Params<16, 4, 32, 4>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL CAST_256 : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "CAST-256"; }
       BlockCipher* clone() const { return new CAST_256; }
 
-      CAST_256() : BlockCipher_Fixed_Block_Size(4, 32, 4), MK(48), RK(48) {}
+      CAST_256() : MK(48), RK(48) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/des/des.h b/src/block/des/des.h
index d758cc4c1..db5a375e0 100644
--- a/src/block/des/des.h
+++ b/src/block/des/des.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * DES
 */
-class BOTAN_DLL DES : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL DES : public Block_Cipher_Fixed_Params<8, 8>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL DES : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "DES"; }
       BlockCipher* clone() const { return new DES; }
 
-      DES() : BlockCipher_Fixed_Block_Size(8), round_key(32) {}
+      DES() : round_key(32) {}
    private:
       void key_schedule(const byte[], size_t);
 
@@ -35,7 +35,7 @@ class BOTAN_DLL DES : public BlockCipher_Fixed_Block_Size<8>
 /**
 * Triple DES
 */
-class BOTAN_DLL TripleDES : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL TripleDES : public Block_Cipher_Fixed_Params<8, 16, 24, 8>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -45,7 +45,7 @@ class BOTAN_DLL TripleDES : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "TripleDES"; }
       BlockCipher* clone() const { return new TripleDES; }
 
-      TripleDES() : BlockCipher_Fixed_Block_Size(16, 24, 8), round_key(96) {}
+      TripleDES() : round_key(96) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/des/desx.h b/src/block/des/desx.h
index 962575529..993eca86b 100644
--- a/src/block/des/desx.h
+++ b/src/block/des/desx.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * DESX
 */
-class BOTAN_DLL DESX : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL DESX : public Block_Cipher_Fixed_Params<8, 24>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL DESX : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "DESX"; }
       BlockCipher* clone() const { return new DESX; }
 
-      DESX() : BlockCipher_Fixed_Block_Size(24), K1(8), K2(8) {}
+      DESX() : K1(8), K2(8) {}
    private:
       void key_schedule(const byte[], size_t);
       SecureVector<byte> K1, K2;
diff --git a/src/block/gost_28147/gost_28147.cpp b/src/block/gost_28147/gost_28147.cpp
index 9adc0d568..07f3359cd 100644
--- a/src/block/gost_28147/gost_28147.cpp
+++ b/src/block/gost_28147/gost_28147.cpp
@@ -52,7 +52,7 @@ GOST_28147_89_Params::GOST_28147_89_Params(const std::string& n) : name(n)
 * GOST Constructor
 */
 GOST_28147_89::GOST_28147_89(const GOST_28147_89_Params& param) :
-   BlockCipher_Fixed_Block_Size(32), SBOX(1024), EK(8)
+   SBOX(1024), EK(8)
    {
    // Convert the parallel 4x4 sboxes into larger word-based sboxes
    for(size_t i = 0; i != 4; ++i)
diff --git a/src/block/gost_28147/gost_28147.h b/src/block/gost_28147/gost_28147.h
index adf542bbe..75ba74c44 100644
--- a/src/block/gost_28147/gost_28147.h
+++ b/src/block/gost_28147/gost_28147.h
@@ -49,7 +49,7 @@ class BOTAN_DLL GOST_28147_89_Params
 /**
 * GOST 28147-89
 */
-class BOTAN_DLL GOST_28147_89 : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL GOST_28147_89 : public Block_Cipher_Fixed_Params<8, 32>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -66,7 +66,7 @@ class BOTAN_DLL GOST_28147_89 : public BlockCipher_Fixed_Block_Size<8>
       GOST_28147_89(const GOST_28147_89_Params& params);
    private:
       GOST_28147_89(const SecureVector<u32bit>& other_SBOX) :
-         BlockCipher_Fixed_Block_Size(32), SBOX(other_SBOX), EK(8) {}
+         SBOX(other_SBOX), EK(8) {}
 
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/idea/idea.h b/src/block/idea/idea.h
index 3552d282f..42fa60c47 100644
--- a/src/block/idea/idea.h
+++ b/src/block/idea/idea.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * IDEA
 */
-class BOTAN_DLL IDEA : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL IDEA : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL IDEA : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "IDEA"; }
       BlockCipher* clone() const { return new IDEA; }
 
-      IDEA() : BlockCipher_Fixed_Block_Size(16), EK(52), DK(52) {}
+      IDEA() : EK(52), DK(52) {}
    protected:
       /**
       * @return const reference to encryption subkeys
diff --git a/src/block/kasumi/kasumi.h b/src/block/kasumi/kasumi.h
index 7b416f193..7871aa170 100644
--- a/src/block/kasumi/kasumi.h
+++ b/src/block/kasumi/kasumi.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * KASUMI, the block cipher used in 3G telephony
 */
-class BOTAN_DLL KASUMI : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL KASUMI : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL KASUMI : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "KASUMI"; }
       BlockCipher* clone() const { return new KASUMI; }
 
-      KASUMI() : BlockCipher_Fixed_Block_Size(16), EK(64) {}
+      KASUMI() : EK(64) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/mars/mars.h b/src/block/mars/mars.h
index 7a53d116b..5ca05f886 100644
--- a/src/block/mars/mars.h
+++ b/src/block/mars/mars.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * MARS, IBM's candidate for AES
 */
-class BOTAN_DLL MARS : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL MARS : public Block_Cipher_Fixed_Params<16, 16, 32, 4>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL MARS : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "MARS"; }
       BlockCipher* clone() const { return new MARS; }
 
-      MARS() : BlockCipher_Fixed_Block_Size(16, 32, 4), EK(40) {}
+      MARS() : EK(40) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/misty1/misty1.cpp b/src/block/misty1/misty1.cpp
index 56a995b76..36c25a814 100644
--- a/src/block/misty1/misty1.cpp
+++ b/src/block/misty1/misty1.cpp
@@ -251,9 +251,7 @@ void MISTY1::key_schedule(const byte key[], size_t length)
 /*
 * MISTY1 Constructor
 */
-MISTY1::MISTY1(size_t rounds) :
-   BlockCipher_Fixed_Block_Size(16),
-   EK(100), DK(100)
+MISTY1::MISTY1(size_t rounds) : EK(100), DK(100)
    {
    if(rounds != 8)
       throw Invalid_Argument("MISTY1: Invalid number of rounds: "
diff --git a/src/block/misty1/misty1.h b/src/block/misty1/misty1.h
index 3bd05b4c6..14d8a2958 100644
--- a/src/block/misty1/misty1.h
+++ b/src/block/misty1/misty1.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * MISTY1
 */
-class BOTAN_DLL MISTY1 : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL MISTY1 : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
diff --git a/src/block/noekeon/noekeon.h b/src/block/noekeon/noekeon.h
index 79c627579..7c5c73dcb 100644
--- a/src/block/noekeon/noekeon.h
+++ b/src/block/noekeon/noekeon.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * Noekeon
 */
-class BOTAN_DLL Noekeon : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL Noekeon : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL Noekeon : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "Noekeon"; }
       BlockCipher* clone() const { return new Noekeon; }
 
-      Noekeon() : BlockCipher_Fixed_Block_Size(16), EK(4), DK(4) {}
+      Noekeon() : EK(4), DK(4) {}
    protected:
       /**
       * The Noekeon round constants
diff --git a/src/block/rc2/rc2.h b/src/block/rc2/rc2.h
index ad4b1a308..1ebad1e73 100644
--- a/src/block/rc2/rc2.h
+++ b/src/block/rc2/rc2.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * RC2
 */
-class BOTAN_DLL RC2 : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL RC2 : public Block_Cipher_Fixed_Params<8, 1, 32>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -32,7 +32,7 @@ class BOTAN_DLL RC2 : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "RC2"; }
       BlockCipher* clone() const { return new RC2; }
 
-      RC2() : BlockCipher_Fixed_Block_Size(1, 32), K(64) {}
+      RC2() : K(64) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/rc5/rc5.cpp b/src/block/rc5/rc5.cpp
index d9e74683c..cfcc4cb64 100644
--- a/src/block/rc5/rc5.cpp
+++ b/src/block/rc5/rc5.cpp
@@ -122,7 +122,7 @@ std::string RC5::name() const
 /*
 * RC5 Constructor
 */
-RC5::RC5(size_t rounds) : BlockCipher_Fixed_Block_Size(1, 32)
+RC5::RC5(size_t rounds)
    {
    if(rounds < 8 || rounds > 32 || (rounds % 4 != 0))
       throw Invalid_Argument("RC5: Invalid number of rounds " +
diff --git a/src/block/rc5/rc5.h b/src/block/rc5/rc5.h
index cb282af4e..c69705471 100644
--- a/src/block/rc5/rc5.h
+++ b/src/block/rc5/rc5.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * RC5
 */
-class BOTAN_DLL RC5 : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL RC5 : public Block_Cipher_Fixed_Params<8, 1, 32>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
diff --git a/src/block/rc6/rc6.h b/src/block/rc6/rc6.h
index 8446138e0..af7b62316 100644
--- a/src/block/rc6/rc6.h
+++ b/src/block/rc6/rc6.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * RC6, Ron Rivest's AES candidate
 */
-class BOTAN_DLL RC6 : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL RC6 : public Block_Cipher_Fixed_Params<16, 1, 32>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL RC6 : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "RC6"; }
       BlockCipher* clone() const { return new RC6; }
 
-      RC6() : BlockCipher_Fixed_Block_Size(1, 32), S(44) {}
+      RC6() : S(44) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/safer/safer_sk.cpp b/src/block/safer/safer_sk.cpp
index 941c4fed8..59a6cc276 100644
--- a/src/block/safer/safer_sk.cpp
+++ b/src/block/safer/safer_sk.cpp
@@ -131,8 +131,7 @@ BlockCipher* SAFER_SK::clone() const
 /*
 * SAFER-SK Constructor
 */
-SAFER_SK::SAFER_SK(size_t rounds) :
-   BlockCipher_Fixed_Block_Size(16)
+SAFER_SK::SAFER_SK(size_t rounds)
    {
    if(rounds > 13 || rounds == 0)
       throw Invalid_Argument(name() + ": Invalid number of rounds");
diff --git a/src/block/safer/safer_sk.h b/src/block/safer/safer_sk.h
index 2fde757bd..803afffa0 100644
--- a/src/block/safer/safer_sk.h
+++ b/src/block/safer/safer_sk.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * SAFER-SK
 */
-class BOTAN_DLL SAFER_SK : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL SAFER_SK : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
diff --git a/src/block/seed/seed.h b/src/block/seed/seed.h
index 649e28a68..979312930 100644
--- a/src/block/seed/seed.h
+++ b/src/block/seed/seed.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * SEED, a Korean block cipher
 */
-class BOTAN_DLL SEED : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL SEED : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL SEED : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "SEED"; }
       BlockCipher* clone() const { return new SEED; }
 
-      SEED() : BlockCipher_Fixed_Block_Size(16), K(32) {}
+      SEED() : K(32) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/serpent/serpent.h b/src/block/serpent/serpent.h
index fccdcf214..33bd747cd 100644
--- a/src/block/serpent/serpent.h
+++ b/src/block/serpent/serpent.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * Serpent, an AES finalist
 */
-class BOTAN_DLL Serpent : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL Serpent : public Block_Cipher_Fixed_Params<16, 16, 32, 8>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,8 +25,7 @@ class BOTAN_DLL Serpent : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "Serpent"; }
       BlockCipher* clone() const { return new Serpent; }
 
-      Serpent() : BlockCipher_Fixed_Block_Size(16, 32, 8),
-                  round_key(132) {}
+      Serpent() : round_key(132) {}
    protected:
       /**
       * For use by subclasses using SIMD, asm, etc
diff --git a/src/block/skipjack/skipjack.h b/src/block/skipjack/skipjack.h
index 73ae28de2..051d35351 100644
--- a/src/block/skipjack/skipjack.h
+++ b/src/block/skipjack/skipjack.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * Skipjack, a NSA designed cipher used in Fortezza
 */
-class BOTAN_DLL Skipjack : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL Skipjack : public Block_Cipher_Fixed_Params<8, 10>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL Skipjack : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "Skipjack"; }
       BlockCipher* clone() const { return new Skipjack; }
 
-      Skipjack() : BlockCipher_Fixed_Block_Size(10), FTAB(2560) {}
+      Skipjack() : FTAB(2560) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/square/square.h b/src/block/square/square.h
index d6df63131..5147c0383 100644
--- a/src/block/square/square.h
+++ b/src/block/square/square.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * Square
 */
-class BOTAN_DLL Square : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL Square : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,9 +25,7 @@ class BOTAN_DLL Square : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "Square"; }
       BlockCipher* clone() const { return new Square; }
 
-      Square() : BlockCipher_Fixed_Block_Size(16),
-                 EK(28), DK(28), ME(32), MD(32) {}
-
+      Square() : EK(28), DK(28), ME(32), MD(32) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/tea/tea.h b/src/block/tea/tea.h
index a7318ba5c..0290b112f 100644
--- a/src/block/tea/tea.h
+++ b/src/block/tea/tea.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * TEA
 */
-class BOTAN_DLL TEA : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL TEA : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL TEA : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "TEA"; }
       BlockCipher* clone() const { return new TEA; }
 
-      TEA() : BlockCipher_Fixed_Block_Size(16), K(4) {}
+      TEA() : K(4) {}
    private:
       void key_schedule(const byte[], size_t);
       SecureVector<u32bit> K;
diff --git a/src/block/twofish/twofish.h b/src/block/twofish/twofish.h
index a212bd285..7594bdcfd 100644
--- a/src/block/twofish/twofish.h
+++ b/src/block/twofish/twofish.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * Twofish, an AES finalist
 */
-class BOTAN_DLL Twofish : public BlockCipher_Fixed_Block_Size<16>
+class BOTAN_DLL Twofish : public Block_Cipher_Fixed_Params<16, 16, 32, 8>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,9 +25,7 @@ class BOTAN_DLL Twofish : public BlockCipher_Fixed_Block_Size<16>
       std::string name() const { return "Twofish"; }
       BlockCipher* clone() const { return new Twofish; }
 
-      Twofish() : BlockCipher_Fixed_Block_Size(16, 32, 8),
-                  SB(1024), RK(40) {}
-
+      Twofish() : SB(1024), RK(40) {}
    private:
       void key_schedule(const byte[], size_t);
 
diff --git a/src/block/xtea/xtea.h b/src/block/xtea/xtea.h
index 539725be8..985e9d6d1 100644
--- a/src/block/xtea/xtea.h
+++ b/src/block/xtea/xtea.h
@@ -15,7 +15,7 @@ namespace Botan {
 /**
 * XTEA
 */
-class BOTAN_DLL XTEA : public BlockCipher_Fixed_Block_Size<8>
+class BOTAN_DLL XTEA : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
       void encrypt_n(const byte in[], byte out[], size_t blocks) const;
@@ -25,7 +25,7 @@ class BOTAN_DLL XTEA : public BlockCipher_Fixed_Block_Size<8>
       std::string name() const { return "XTEA"; }
       BlockCipher* clone() const { return new XTEA; }
 
-      XTEA() : BlockCipher_Fixed_Block_Size(16), EK(64) {}
+      XTEA() : EK(64) {}
    protected:
       /**
       * @return const reference to the key schedule