Remove modebase entirely. It made doing optimizations rather obnoxious and

didn't really contribute much in terms of code savings. CBC, CFB, and CTS
now derive directly from Keyed_Filter. All the other modes already did this.

11 files changed, 393 insertions, 271 deletions

diff --git a/src/filters/modes/cbc/cbc.cpp b/src/filters/modes/cbc/cbc.cpp
index a52f4b2e1..48ecdf509 100644
--- a/src/filters/modes/cbc/cbc.cpp
+++ b/src/filters/modes/cbc/cbc.cpp
@@ -16,11 +16,14 @@ namespace Botan {
 */
 CBC_Encryption::CBC_Encryption(BlockCipher* ciph,
                                BlockCipherModePaddingMethod* pad) :
-   BlockCipherMode(ciph, "CBC", ciph->BLOCK_SIZE),
-   padder(pad)
+   cipher(ciph), padder(pad)
    {
-   if(!padder->valid_blocksize(BLOCK_SIZE))
+   if(!padder->valid_blocksize(cipher->BLOCK_SIZE))
       throw Invalid_Block_Size(name(), padder->name());
+
+   buffer.resize(cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   position = 0;
    }
 
 /*
@@ -30,31 +33,48 @@ CBC_Encryption::CBC_Encryption(BlockCipher* ciph,
                                BlockCipherModePaddingMethod* pad,
                                const SymmetricKey& key,
                                const InitializationVector& iv) :
-   BlockCipherMode(ciph, "CBC", ciph->BLOCK_SIZE),
-   padder(pad)
+   cipher(ciph), padder(pad)
    {
-   if(!padder->valid_blocksize(BLOCK_SIZE))
+   if(!padder->valid_blocksize(cipher->BLOCK_SIZE))
       throw Invalid_Block_Size(name(), padder->name());
+
+   buffer.resize(cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   position = 0;
+
    set_key(key);
    set_iv(iv);
    }
 
 /*
+* Set the IV
+*/
+void CBC_Encryption::set_iv(const InitializationVector& iv)
+   {
+   if(iv.length() != state.size())
+      throw Invalid_IV_Length(name(), iv.length());
+
+   state = iv.bits_of();
+   buffer.clear();
+   position = 0;
+   }
+
+/*
 * Encrypt in CBC mode
 */
 void CBC_Encryption::write(const byte input[], u32bit length)
    {
    while(length)
       {
-      u32bit xored = std::min(BLOCK_SIZE - position, length);
+      u32bit xored = std::min(cipher->BLOCK_SIZE - position, length);
       xor_buf(state + position, input, xored);
       input += xored;
       length -= xored;
       position += xored;
-      if(position == BLOCK_SIZE)
+      if(position == cipher->BLOCK_SIZE)
          {
          cipher->encrypt(state);
-         send(state, BLOCK_SIZE);
+         send(state, cipher->BLOCK_SIZE);
          position = 0;
          }
       }
@@ -65,9 +85,9 @@ void CBC_Encryption::write(const byte input[], u32bit length)
 */
 void CBC_Encryption::end_msg()
    {
-   SecureVector<byte> padding(BLOCK_SIZE);
+   SecureVector<byte> padding(cipher->BLOCK_SIZE);
    padder->pad(padding, padding.size(), position);
-   write(padding, padder->pad_bytes(BLOCK_SIZE, position));
+   write(padding, padder->pad_bytes(cipher->BLOCK_SIZE, position));
    if(position != 0)
       throw Exception(name() + ": Did not pad to full blocksize");
    }
@@ -77,7 +97,7 @@ void CBC_Encryption::end_msg()
 */
 std::string CBC_Encryption::name() const
    {
-   return (cipher->name() + "/" + mode_name + "/" + padder->name());
+   return (cipher->name() + "/CBC/" + padder->name());
    }
 
 /*
@@ -85,12 +105,15 @@ std::string CBC_Encryption::name() const
 */
 CBC_Decryption::CBC_Decryption(BlockCipher* ciph,
                                BlockCipherModePaddingMethod* pad) :
-   BlockCipherMode(ciph, "CBC", ciph->BLOCK_SIZE),
-   padder(pad)
+   cipher(ciph), padder(pad)
    {
-   if(!padder->valid_blocksize(BLOCK_SIZE))
+   if(!padder->valid_blocksize(cipher->BLOCK_SIZE))
       throw Invalid_Block_Size(name(), padder->name());
-   temp.resize(BLOCK_SIZE);
+
+   buffer.resize(cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   temp.resize(cipher->BLOCK_SIZE);
+   position = 0;
    }
 
 /*
@@ -100,32 +123,50 @@ CBC_Decryption::CBC_Decryption(BlockCipher* ciph,
                                BlockCipherModePaddingMethod* pad,
                                const SymmetricKey& key,
                                const InitializationVector& iv) :
-   BlockCipherMode(ciph, "CBC", ciph->BLOCK_SIZE),
-   padder(pad)
+   cipher(ciph), padder(pad)
    {
-   if(!padder->valid_blocksize(BLOCK_SIZE))
+   if(!padder->valid_blocksize(cipher->BLOCK_SIZE))
       throw Invalid_Block_Size(name(), padder->name());
-   temp.resize(BLOCK_SIZE);
+
+   buffer.resize(cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   temp.resize(cipher->BLOCK_SIZE);
+   position = 0;
+
    set_key(key);
    set_iv(iv);
    }
 
 /*
+* Set the IV
+*/
+void CBC_Decryption::set_iv(const InitializationVector& iv)
+   {
+   if(iv.length() != state.size())
+      throw Invalid_IV_Length(name(), iv.length());
+
+   state = iv.bits_of();
+   buffer.clear();
+   position = 0;
+   }
+
+/*
 * Decrypt in CBC mode
 */
 void CBC_Decryption::write(const byte input[], u32bit length)
    {
    while(length)
       {
-      if(position == BLOCK_SIZE)
+      if(position == cipher->BLOCK_SIZE)
          {
          cipher->decrypt(buffer, temp);
-         xor_buf(temp, state, BLOCK_SIZE);
-         send(temp, BLOCK_SIZE);
+         xor_buf(temp, state, cipher->BLOCK_SIZE);
+         send(temp, cipher->BLOCK_SIZE);
          state = buffer;
          position = 0;
          }
-      u32bit added = std::min(BLOCK_SIZE - position, length);
+
+      u32bit added = std::min(cipher->BLOCK_SIZE - position, length);
       buffer.copy(position, input, added);
       input += added;
       length -= added;
@@ -138,11 +179,11 @@ void CBC_Decryption::write(const byte input[], u32bit length)
 */
 void CBC_Decryption::end_msg()
    {
-   if(position != BLOCK_SIZE)
+   if(position != cipher->BLOCK_SIZE)
       throw Decoding_Error(name());
    cipher->decrypt(buffer, temp);
-   xor_buf(temp, state, BLOCK_SIZE);
-   send(temp, padder->unpad(temp, BLOCK_SIZE));
+   xor_buf(temp, state, cipher->BLOCK_SIZE);
+   send(temp, padder->unpad(temp, cipher->BLOCK_SIZE));
    state = buffer;
    position = 0;
    }
@@ -152,7 +193,7 @@ void CBC_Decryption::end_msg()
 */
 std::string CBC_Decryption::name() const
    {
-   return (cipher->name() + "/" + mode_name + "/" + padder->name());
+   return (cipher->name() + "/CBC/" + padder->name());
    }
 
 }
diff --git a/src/filters/modes/cbc/cbc.h b/src/filters/modes/cbc/cbc.h
index a926ac180..91ab21ab6 100644
--- a/src/filters/modes/cbc/cbc.h
+++ b/src/filters/modes/cbc/cbc.h
@@ -8,7 +8,8 @@
 #ifndef BOTAN_CBC_H__
 #define BOTAN_CBC_H__
 
-#include <botan/modebase.h>
+#include <botan/block_cipher.h>
+#include <botan/key_filt.h>
 #include <botan/mode_pad.h>
 
 namespace Botan {
@@ -16,38 +17,69 @@ namespace Botan {
 /*
 * CBC Encryption
 */
-class BOTAN_DLL CBC_Encryption : public BlockCipherMode
+class BOTAN_DLL CBC_Encryption : public Keyed_Filter
    {
    public:
-      CBC_Encryption(BlockCipher*, BlockCipherModePaddingMethod*);
-      CBC_Encryption(BlockCipher*, BlockCipherModePaddingMethod*,
-                     const SymmetricKey&, const InitializationVector&);
+      std::string name() const;
+
+      void set_iv(const InitializationVector&);
+
+      void set_key(const SymmetricKey& key) { cipher->set_key(key); }
+
+      bool valid_keylength(u32bit key_len) const
+         { return cipher->valid_keylength(key_len); }
+
+      CBC_Encryption(BlockCipher* cipher,
+                     BlockCipherModePaddingMethod* padding);
+
+      CBC_Encryption(BlockCipher* cipher,
+                     BlockCipherModePaddingMethod* padding,
+                     const SymmetricKey& key,
+                     const InitializationVector& iv);
 
       ~CBC_Encryption() { delete padder; }
    private:
-      std::string name() const;
       void write(const byte[], u32bit);
       void end_msg();
+
+      BlockCipher* cipher;
       const BlockCipherModePaddingMethod* padder;
+      SecureVector<byte> buffer, state;
+      u32bit position;
    };
 
 /*
 * CBC Decryption
 */
-class BOTAN_DLL CBC_Decryption : public BlockCipherMode
+class BOTAN_DLL CBC_Decryption : public Keyed_Filter
    {
    public:
-      CBC_Decryption(BlockCipher*, BlockCipherModePaddingMethod*);
-      CBC_Decryption(BlockCipher*, BlockCipherModePaddingMethod*,
-                     const SymmetricKey&, const InitializationVector&);
+      std::string name() const;
+
+      void set_iv(const InitializationVector&);
+
+      void set_key(const SymmetricKey& key) { cipher->set_key(key); }
+
+      bool valid_keylength(u32bit key_len) const
+         { return cipher->valid_keylength(key_len); }
+
+      CBC_Decryption(BlockCipher* cipher,
+                     BlockCipherModePaddingMethod* padding);
+
+      CBC_Decryption(BlockCipher* cipher,
+                     BlockCipherModePaddingMethod* padding,
+                     const SymmetricKey& key,
+                     const InitializationVector& iv);
 
       ~CBC_Decryption() { delete padder; }
    private:
-      std::string name() const;
       void write(const byte[], u32bit);
       void end_msg();
+
+      BlockCipher* cipher;
       const BlockCipherModePaddingMethod* padder;
-      SecureVector<byte> temp;
+      SecureVector<byte> buffer, state, temp;
+      u32bit position;
    };
 
 }
diff --git a/src/filters/modes/cfb/cfb.cpp b/src/filters/modes/cfb/cfb.cpp
index 777673d6f..778d47484 100644
--- a/src/filters/modes/cfb/cfb.cpp
+++ b/src/filters/modes/cfb/cfb.cpp
@@ -12,30 +12,21 @@
 
 namespace Botan {
 
-namespace {
-
 /*
-* Check the feedback size
+* CFB Encryption Constructor
 */
-void check_feedback(u32bit BLOCK_SIZE, u32bit FEEDBACK_SIZE, u32bit bits,
-                    const std::string& name)
+CFB_Encryption::CFB_Encryption(BlockCipher* ciph, u32bit fback_bits)
    {
-   if(FEEDBACK_SIZE == 0 || FEEDBACK_SIZE > BLOCK_SIZE || bits % 8 != 0)
-      throw Invalid_Argument(name + ": Invalid feedback size " +
-                             to_string(bits));
-   }
+   cipher = ciph;
+   feedback = fback_bits ? fback_bits / 8: cipher->BLOCK_SIZE;
 
-}
+   buffer.resize(cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   position = 0;
 
-/*
-* CFB Encryption Constructor
-*/
-CFB_Encryption::CFB_Encryption(BlockCipher* ciph,
-                               u32bit fback_bits) :
-   BlockCipherMode(ciph, "CFB", ciph->BLOCK_SIZE, 1),
-   FEEDBACK_SIZE(fback_bits ? fback_bits / 8: BLOCK_SIZE)
-   {
-   check_feedback(BLOCK_SIZE, FEEDBACK_SIZE, fback_bits, name());
+   if(feedback == 0 || fback_bits % 8 != 0 || feedback > cipher->BLOCK_SIZE)
+      throw Invalid_Argument("CFB_Encryption: Invalid feedback size " +
+                             to_string(fback_bits));
    }
 
 /*
@@ -44,15 +35,35 @@ CFB_Encryption::CFB_Encryption(BlockCipher* ciph,
 CFB_Encryption::CFB_Encryption(BlockCipher* ciph,
                                const SymmetricKey& key,
                                const InitializationVector& iv,
-                               u32bit fback_bits) :
-   BlockCipherMode(ciph, "CFB", ciph->BLOCK_SIZE, 1),
-   FEEDBACK_SIZE(fback_bits ? fback_bits / 8: BLOCK_SIZE)
+                               u32bit fback_bits)
    {
-   check_feedback(BLOCK_SIZE, FEEDBACK_SIZE, fback_bits, name());
+   cipher = ciph;
+   feedback = fback_bits ? fback_bits / 8: cipher->BLOCK_SIZE;
+
+   buffer.resize(cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   position = 0;
+
+   if(feedback == 0 || fback_bits % 8 != 0 || feedback > cipher->BLOCK_SIZE)
+      throw Invalid_Argument("CFB_Encryption: Invalid feedback size " +
+                             to_string(fback_bits));
+
    set_key(key);
    set_iv(iv);
    }
 
+void CFB_Encryption::set_iv(const InitializationVector& iv)
+   {
+   if(iv.length() != state.size())
+      throw Invalid_IV_Length(name(), iv.length());
+
+   state = iv.bits_of();
+   buffer.clear();
+   position = 0;
+
+   cipher->encrypt(state, buffer);
+   }
+
 /*
 * Encrypt data in CFB mode
 */
@@ -60,38 +71,39 @@ void CFB_Encryption::write(const byte input[], u32bit length)
    {
    while(length)
       {
-      u32bit xored = std::min(FEEDBACK_SIZE - position, length);
+      u32bit xored = std::min(feedback - position, length);
       xor_buf(buffer + position, input, xored);
       send(buffer + position, xored);
       input += xored;
       length -= xored;
       position += xored;
-      if(position == FEEDBACK_SIZE)
-         feedback();
+
+      if(position == feedback)
+         {
+         for(u32bit j = 0; j != cipher->BLOCK_SIZE - feedback; ++j)
+            state[j] = state[j + feedback];
+         state.copy(cipher->BLOCK_SIZE - feedback, buffer, feedback);
+         cipher->encrypt(state, buffer);
+         position = 0;
+         }
       }
    }
 
 /*
-* Do the feedback
+* CFB Decryption Constructor
 */
-void CFB_Encryption::feedback()
+CFB_Decryption::CFB_Decryption(BlockCipher* ciph, u32bit fback_bits)
    {
-   for(u32bit j = 0; j != BLOCK_SIZE - FEEDBACK_SIZE; ++j)
-      state[j] = state[j + FEEDBACK_SIZE];
-   state.copy(BLOCK_SIZE - FEEDBACK_SIZE, buffer, FEEDBACK_SIZE);
-   cipher->encrypt(state, buffer);
+   cipher = ciph;
+   feedback = fback_bits ? fback_bits / 8: cipher->BLOCK_SIZE;
+
+   buffer.resize(cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
    position = 0;
-   }
 
-/*
-* CFB Decryption Constructor
-*/
-CFB_Decryption::CFB_Decryption(BlockCipher* ciph,
-                               u32bit fback_bits) :
-   BlockCipherMode(ciph, "CFB", ciph->BLOCK_SIZE, 1),
-   FEEDBACK_SIZE(fback_bits ? fback_bits / 8 : BLOCK_SIZE)
-   {
-   check_feedback(BLOCK_SIZE, FEEDBACK_SIZE, fback_bits, name());
+   if(feedback == 0 || fback_bits % 8 != 0 || feedback > cipher->BLOCK_SIZE)
+      throw Invalid_Argument("CFB_Decryption: Invalid feedback size " +
+                             to_string(fback_bits));
    }
 
 /*
@@ -100,15 +112,35 @@ CFB_Decryption::CFB_Decryption(BlockCipher* ciph,
 CFB_Decryption::CFB_Decryption(BlockCipher* ciph,
                                const SymmetricKey& key,
                                const InitializationVector& iv,
-                               u32bit fback_bits) :
-   BlockCipherMode(ciph, "CFB", ciph->BLOCK_SIZE, 1),
-   FEEDBACK_SIZE(fback_bits ? fback_bits / 8 : BLOCK_SIZE)
+                               u32bit fback_bits)
    {
-   check_feedback(BLOCK_SIZE, FEEDBACK_SIZE, fback_bits, name());
+   cipher = ciph;
+   feedback = fback_bits ? fback_bits / 8: cipher->BLOCK_SIZE;
+
+   buffer.resize(cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   position = 0;
+
+   if(feedback == 0 || fback_bits % 8 != 0 || feedback > cipher->BLOCK_SIZE)
+      throw Invalid_Argument("CFB_Decryption: Invalid feedback size " +
+                             to_string(fback_bits));
+
    set_key(key);
    set_iv(iv);
    }
 
+void CFB_Decryption::set_iv(const InitializationVector& iv)
+   {
+   if(iv.length() != state.size())
+      throw Invalid_IV_Length(name(), iv.length());
+
+   state = iv.bits_of();
+   buffer.clear();
+   position = 0;
+
+   cipher->encrypt(state, buffer);
+   }
+
 /*
 * Decrypt data in CFB mode
 */
@@ -116,28 +148,22 @@ void CFB_Decryption::write(const byte input[], u32bit length)
    {
    while(length)
       {
-      u32bit xored = std::min(FEEDBACK_SIZE - position, length);
+      u32bit xored = std::min(feedback - position, length);
       xor_buf(buffer + position, input, xored);
       send(buffer + position, xored);
       buffer.copy(position, input, xored);
       input += xored;
       length -= xored;
       position += xored;
-      if(position == FEEDBACK_SIZE)
-         feedback();
+      if(position == feedback)
+         {
+         for(u32bit j = 0; j != cipher->BLOCK_SIZE - feedback; ++j)
+            state[j] = state[j + feedback];
+         state.copy(cipher->BLOCK_SIZE - feedback, buffer, feedback);
+         cipher->encrypt(state, buffer);
+         position = 0;
+         }
       }
    }
 
-/*
-* Do the feedback
-*/
-void CFB_Decryption::feedback()
-   {
-   for(u32bit j = 0; j != BLOCK_SIZE - FEEDBACK_SIZE; ++j)
-      state[j] = state[j + FEEDBACK_SIZE];
-   state.copy(BLOCK_SIZE - FEEDBACK_SIZE, buffer, FEEDBACK_SIZE);
-   cipher->encrypt(state, buffer);
-   position = 0;
-   }
-
 }
diff --git a/src/filters/modes/cfb/cfb.h b/src/filters/modes/cfb/cfb.h
index 7810c00e4..917125e46 100644
--- a/src/filters/modes/cfb/cfb.h
+++ b/src/filters/modes/cfb/cfb.h
@@ -8,38 +8,67 @@
 #ifndef BOTAN_CFB_H__
 #define BOTAN_CFB_H__
 
-#include <botan/modebase.h>
+#include <botan/block_cipher.h>
+#include <botan/key_filt.h>
 
 namespace Botan {
 
 /*
 * CFB Encryption
 */
-class BOTAN_DLL CFB_Encryption : public BlockCipherMode
+class BOTAN_DLL CFB_Encryption : public Keyed_Filter
    {
    public:
-      CFB_Encryption(BlockCipher*, u32bit = 0);
-      CFB_Encryption(BlockCipher*, const SymmetricKey&,
-                     const InitializationVector&, u32bit = 0);
+      std::string name() const { return cipher->name() + "/CFB"; }
+
+      void set_iv(const InitializationVector&);
+
+      void set_key(const SymmetricKey& key) { cipher->set_key(key); }
+
+      bool valid_keylength(u32bit key_len) const
+         { return cipher->valid_keylength(key_len); }
+
+      CFB_Encryption(BlockCipher* cipher, u32bit feedback = 0);
+
+      CFB_Encryption(BlockCipher* cipher,
+                     const SymmetricKey& key,
+                     const InitializationVector& iv,
+                     u32bit feedback = 0);
    private:
       void write(const byte[], u32bit);
-      void feedback();
-      const u32bit FEEDBACK_SIZE;
+
+      BlockCipher* cipher;
+      SecureVector<byte> buffer, state;
+      u32bit position, feedback;
    };
 
 /*
 * CFB Decryption
 */
-class BOTAN_DLL CFB_Decryption : public BlockCipherMode
+class BOTAN_DLL CFB_Decryption : public Keyed_Filter
    {
    public:
-      CFB_Decryption(BlockCipher*, u32bit = 0);
-      CFB_Decryption(BlockCipher*, const SymmetricKey&,
-                     const InitializationVector&, u32bit = 0);
+      std::string name() const { return cipher->name() + "/CFB"; }
+
+      void set_iv(const InitializationVector&);
+
+      void set_key(const SymmetricKey& key) { cipher->set_key(key); }
+
+      bool valid_keylength(u32bit key_len) const
+         { return cipher->valid_keylength(key_len); }
+
+      CFB_Decryption(BlockCipher* cipher, u32bit feedback = 0);
+
+      CFB_Decryption(BlockCipher* cipher,
+                     const SymmetricKey& key,
+                     const InitializationVector& iv,
+                     u32bit feedback = 0);
    private:
       void write(const byte[], u32bit);
-      void feedback();
-      const u32bit FEEDBACK_SIZE;
+
+      BlockCipher* cipher;
+      SecureVector<byte> buffer, state;
+      u32bit position, feedback;
    };
 
 }
diff --git a/src/filters/modes/cts/cts.cpp b/src/filters/modes/cts/cts.cpp
index 226a31898..3a15a1d68 100644
--- a/src/filters/modes/cts/cts.cpp
+++ b/src/filters/modes/cts/cts.cpp
@@ -12,13 +12,53 @@
 namespace Botan {
 
 /*
+* CTS Encryption Constructor
+*/
+CTS_Encryption::CTS_Encryption(BlockCipher* ciph) :
+   cipher(ciph)
+   {
+   buffer.resize(2 * cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   position = 0;
+   }
+
+/*
+* CTS Encryption Constructor
+*/
+CTS_Encryption::CTS_Encryption(BlockCipher* ciph,
+                               const SymmetricKey& key,
+                               const InitializationVector& iv) :
+   cipher(ciph)
+   {
+   buffer.resize(2 * cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   position = 0;
+
+   set_key(key);
+   set_iv(iv);
+   }
+
+/*
+* Set the IV
+*/
+void CTS_Encryption::set_iv(const InitializationVector& iv)
+   {
+   if(iv.length() != state.size())
+      throw Invalid_IV_Length(name(), iv.length());
+
+   state = iv.bits_of();
+   buffer.clear();
+   position = 0;
+   }
+
+/*
 * Encrypt a block
 */
 void CTS_Encryption::encrypt(const byte block[])
    {
-   xor_buf(state, block, BLOCK_SIZE);
+   xor_buf(state, block, cipher->BLOCK_SIZE);
    cipher->encrypt(state);
-   send(state, BLOCK_SIZE);
+   send(state, cipher->BLOCK_SIZE);
    }
 
 /*
@@ -26,7 +66,7 @@ void CTS_Encryption::encrypt(const byte block[])
 */
 void CTS_Encryption::write(const byte input[], u32bit length)
    {
-   u32bit copied = std::min(BUFFER_SIZE - position, length);
+   u32bit copied = std::min(buffer.size() - position, length);
    buffer.copy(position, input, copied);
    length -= copied;
    input += copied;
@@ -35,21 +75,21 @@ void CTS_Encryption::write(const byte input[], u32bit length)
    if(length == 0) return;
 
    encrypt(buffer);
-   if(length > BLOCK_SIZE)
+   if(length > cipher->BLOCK_SIZE)
       {
-      encrypt(buffer + BLOCK_SIZE);
-      while(length > 2*BLOCK_SIZE)
+      encrypt(buffer + cipher->BLOCK_SIZE);
+      while(length > 2*cipher->BLOCK_SIZE)
          {
          encrypt(input);
-         length -= BLOCK_SIZE;
-         input += BLOCK_SIZE;
+         length -= cipher->BLOCK_SIZE;
+         input += cipher->BLOCK_SIZE;
          }
       position = 0;
       }
    else
       {
-      copy_mem(buffer.begin(), buffer + BLOCK_SIZE, BLOCK_SIZE);
-      position = BLOCK_SIZE;
+      copy_mem(buffer.begin(), buffer + cipher->BLOCK_SIZE, cipher->BLOCK_SIZE);
+      position = cipher->BLOCK_SIZE;
       }
    buffer.copy(position, input, length);
    position += length;
@@ -60,14 +100,56 @@ void CTS_Encryption::write(const byte input[], u32bit length)
 */
 void CTS_Encryption::end_msg()
    {
-   if(position < BLOCK_SIZE + 1)
+   if(position < cipher->BLOCK_SIZE + 1)
       throw Exception("CTS_Encryption: insufficient data to encrypt");
-   xor_buf(state, buffer, BLOCK_SIZE);
+   xor_buf(state, buffer, cipher->BLOCK_SIZE);
    cipher->encrypt(state);
    SecureVector<byte> cn = state;
-   clear_mem(buffer + position, BUFFER_SIZE - position);
-   encrypt(buffer + BLOCK_SIZE);
-   send(cn, position - BLOCK_SIZE);
+   clear_mem(buffer + position, buffer.size() - position);
+   encrypt(buffer + cipher->BLOCK_SIZE);
+   send(cn, position - cipher->BLOCK_SIZE);
+   }
+
+/*
+* CTS Decryption Constructor
+*/
+CTS_Decryption::CTS_Decryption(BlockCipher* ciph) :
+   cipher(ciph)
+   {
+   buffer.resize(2 * cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   temp.resize(cipher->BLOCK_SIZE);
+   position = 0;
+   }
+
+/*
+* CTS Decryption Constructor
+*/
+CTS_Decryption::CTS_Decryption(BlockCipher* ciph,
+                               const SymmetricKey& key,
+                               const InitializationVector& iv) :
+   cipher(ciph)
+   {
+   buffer.resize(2 * cipher->BLOCK_SIZE);
+   state.resize(cipher->BLOCK_SIZE);
+   temp.resize(cipher->BLOCK_SIZE);
+   position = 0;
+
+   set_key(key);
+   set_iv(iv);
+   }
+
+/*
+* Set the IV
+*/
+void CTS_Decryption::set_iv(const InitializationVector& iv)
+   {
+   if(iv.length() != state.size())
+      throw Invalid_IV_Length(name(), iv.length());
+
+   state = iv.bits_of();
+   buffer.clear();
+   position = 0;
    }
 
 /*
@@ -76,9 +158,9 @@ void CTS_Encryption::end_msg()
 void CTS_Decryption::decrypt(const byte block[])
    {
    cipher->decrypt(block, temp);
-   xor_buf(temp, state, BLOCK_SIZE);
-   send(temp, BLOCK_SIZE);
-   state.copy(block, BLOCK_SIZE);
+   xor_buf(temp, state, cipher->BLOCK_SIZE);
+   send(temp, cipher->BLOCK_SIZE);
+   state.copy(block, cipher->BLOCK_SIZE);
    }
 
 /*
@@ -86,7 +168,7 @@ void CTS_Decryption::decrypt(const byte block[])
 */
 void CTS_Decryption::write(const byte input[], u32bit length)
    {
-   u32bit copied = std::min(BUFFER_SIZE - position, length);
+   u32bit copied = std::min(buffer.size() - position, length);
    buffer.copy(position, input, copied);
    length -= copied;
    input += copied;
@@ -95,21 +177,21 @@ void CTS_Decryption::write(const byte input[], u32bit length)
    if(length == 0) return;
 
    decrypt(buffer);
-   if(length > BLOCK_SIZE)
+   if(length > cipher->BLOCK_SIZE)
       {
-      decrypt(buffer + BLOCK_SIZE);
-      while(length > 2*BLOCK_SIZE)
+      decrypt(buffer + cipher->BLOCK_SIZE);
+      while(length > 2*cipher->BLOCK_SIZE)
          {
          decrypt(input);
-         length -= BLOCK_SIZE;
-         input += BLOCK_SIZE;
+         length -= cipher->BLOCK_SIZE;
+         input += cipher->BLOCK_SIZE;
          }
       position = 0;
       }
    else
       {
-      copy_mem(buffer.begin(), buffer + BLOCK_SIZE, BLOCK_SIZE);
-      position = BLOCK_SIZE;
+      copy_mem(buffer.begin(), buffer + cipher->BLOCK_SIZE, cipher->BLOCK_SIZE);
+      position = cipher->BLOCK_SIZE;
       }
    buffer.copy(position, input, length);
    position += length;
@@ -121,14 +203,14 @@ void CTS_Decryption::write(const byte input[], u32bit length)
 void CTS_Decryption::end_msg()
    {
    cipher->decrypt(buffer, temp);
-   xor_buf(temp, buffer + BLOCK_SIZE, position - BLOCK_SIZE);
+   xor_buf(temp, buffer + cipher->BLOCK_SIZE, position - cipher->BLOCK_SIZE);
    SecureVector<byte> xn = temp;
-   copy_mem(buffer + position, xn + (position - BLOCK_SIZE),
-            BUFFER_SIZE - position);
-   cipher->decrypt(buffer + BLOCK_SIZE, temp);
-   xor_buf(temp, state, BLOCK_SIZE);
-   send(temp, BLOCK_SIZE);
-   send(xn, position - BLOCK_SIZE);
+   copy_mem(buffer + position, xn + (position - cipher->BLOCK_SIZE),
+            buffer.size() - position);
+   cipher->decrypt(buffer + cipher->BLOCK_SIZE, temp);
+   xor_buf(temp, state, cipher->BLOCK_SIZE);
+   send(temp, cipher->BLOCK_SIZE);
+   send(xn, position - cipher->BLOCK_SIZE);
    }
 
 }
diff --git a/src/filters/modes/cts/cts.h b/src/filters/modes/cts/cts.h
index 1a2cae44e..4a7513fa0 100644
--- a/src/filters/modes/cts/cts.h
+++ b/src/filters/modes/cts/cts.h
@@ -8,51 +8,69 @@
 #ifndef BOTAN_CTS_H__
 #define BOTAN_CTS_H__
 
-#include <botan/modebase.h>
 #include <botan/block_cipher.h>
+#include <botan/key_filt.h>
 
 namespace Botan {
 
 /*
 * CTS Encryption
 */
-class BOTAN_DLL CTS_Encryption : public BlockCipherMode
+class BOTAN_DLL CTS_Encryption : public Keyed_Filter
    {
    public:
-      CTS_Encryption(BlockCipher* ciph) :
-         BlockCipherMode(ciph, "CTS", ciph->BLOCK_SIZE, 0, 2) {}
+      std::string name() const { return cipher->name() + "/CTS"; }
 
-      CTS_Encryption(BlockCipher* ciph,
+      void set_iv(const InitializationVector&);
+
+      void set_key(const SymmetricKey& key) { cipher->set_key(key); }
+
+      bool valid_keylength(u32bit key_len) const
+         { return cipher->valid_keylength(key_len); }
+
+      CTS_Encryption(BlockCipher* cipher);
+
+      CTS_Encryption(BlockCipher* cipher,
                      const SymmetricKey& key,
-                     const InitializationVector& iv) :
-         BlockCipherMode(ciph, "CTS", ciph->BLOCK_SIZE, 0, 2)
-         { set_key(key); set_iv(iv); }
+                     const InitializationVector& iv);
    private:
       void write(const byte[], u32bit);
       void end_msg();
       void encrypt(const byte[]);
+
+      BlockCipher* cipher;
+      SecureVector<byte> buffer, state;
+      u32bit position;
    };
 
 /*
 * CTS Decryption
 */
-class BOTAN_DLL CTS_Decryption : public BlockCipherMode
+class BOTAN_DLL CTS_Decryption : public Keyed_Filter
    {
    public:
-      CTS_Decryption(BlockCipher* ciph) :
-         BlockCipherMode(ciph, "CTS", ciph->BLOCK_SIZE, 0, 2)
-         { temp.resize(BLOCK_SIZE); }
+      std::string name() const { return cipher->name() + "/CTS"; }
 
-      CTS_Decryption(BlockCipher* ciph,
+      void set_iv(const InitializationVector&);
+
+      void set_key(const SymmetricKey& key) { cipher->set_key(key); }
+
+      bool valid_keylength(u32bit key_len) const
+         { return cipher->valid_keylength(key_len); }
+
+      CTS_Decryption(BlockCipher* cipher);
+
+      CTS_Decryption(BlockCipher* cipher,
                      const SymmetricKey& key,
-                     const InitializationVector& iv) :
-         BlockCipherMode(ciph, "CTS", ciph->BLOCK_SIZE, 0, 2)
-         { set_key(key); set_iv(iv); temp.resize(BLOCK_SIZE); }
+                     const InitializationVector& iv);
    private:
       void write(const byte[], u32bit);
       void end_msg();
       void decrypt(const byte[]);
-      SecureVector<byte> temp;
+
+      BlockCipher* cipher;
+      SecureVector<byte> buffer, state, temp;
+      u32bit position;
    };
 
 }
diff --git a/src/filters/modes/ecb/ecb.h b/src/filters/modes/ecb/ecb.h
index f0d75fdc3..2b3b3fe83 100644
--- a/src/filters/modes/ecb/ecb.h
+++ b/src/filters/modes/ecb/ecb.h
@@ -8,7 +8,6 @@
 #ifndef BOTAN_ECB_H__
 #define BOTAN_ECB_H__
 
-#include <botan/basefilt.h>
 #include <botan/block_cipher.h>
 #include <botan/mode_pad.h>
 #include <botan/key_filt.h>
diff --git a/src/filters/modes/info.txt b/src/filters/modes/info.txt
deleted file mode 100644
index 6d27c9709..000000000
--- a/src/filters/modes/info.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-define CIPHER_MODEBASE
-
-<requires>
-block
-filters
-</requires>
diff --git a/src/filters/modes/mode_pad/mode_pad.cpp b/src/filters/modes/mode_pad/mode_pad.cpp
index 2204c28b5..94f84fa03 100644
--- a/src/filters/modes/mode_pad/mode_pad.cpp
+++ b/src/filters/modes/mode_pad/mode_pad.cpp
@@ -120,8 +120,7 @@ u32bit OneAndZeros_Padding::unpad(const byte block[], u32bit size) const
 */
 bool OneAndZeros_Padding::valid_blocksize(u32bit size) const
    {
-   if(size) return true;
-   else     return false;
+   return (size > 0);
    }
 
 }
diff --git a/src/filters/modes/modebase.cpp b/src/filters/modes/modebase.cpp
deleted file mode 100644
index 59ee55a8a..000000000
--- a/src/filters/modes/modebase.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-/*
-* Block Cipher Mode
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#include <botan/modebase.h>
-
-namespace Botan {
-
-/*
-* Block Cipher Mode Constructor
-*/
-BlockCipherMode::BlockCipherMode(BlockCipher* cipher_ptr,
-                                 const std::string& cipher_mode_name,
-                                 u32bit iv_size, u32bit iv_meth,
-                                 u32bit buf_mult) :
-   BLOCK_SIZE(cipher_ptr->BLOCK_SIZE), BUFFER_SIZE(buf_mult * BLOCK_SIZE),
-   IV_METHOD(iv_meth), mode_name(cipher_mode_name)
-   {
-   cipher = cipher_ptr;
-   buffer.resize(BUFFER_SIZE);
-   state.resize(iv_size);
-   position = 0;
-   }
-
-/*
-* Return the name of this type
-*/
-std::string BlockCipherMode::name() const
-   {
-   return (cipher->name() + "/" + mode_name);
-   }
-
-/*
-* Set the IV
-*/
-void BlockCipherMode::set_iv(const InitializationVector& new_iv)
-   {
-   if(new_iv.length() != state.size())
-      throw Invalid_IV_Length(name(), new_iv.length());
-
-   state = new_iv.bits_of();
-   buffer.clear();
-   position = 0;
-
-   if(IV_METHOD == 1)
-      cipher->encrypt(state, buffer);
-   else if(IV_METHOD == 2)
-      cipher->encrypt(state);
-   }
-
-}
diff --git a/src/filters/modes/modebase.h b/src/filters/modes/modebase.h
deleted file mode 100644
index 4a15524b6..000000000
--- a/src/filters/modes/modebase.h
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
-* Block Cipher Mode
-* (C) 1999-2007 Jack Lloyd
-*
-* Distributed under the terms of the Botan license
-*/
-
-#ifndef BOTAN_MODEBASE_H__
-#define BOTAN_MODEBASE_H__
-
-#include <botan/key_filt.h>
-#include <botan/block_cipher.h>
-
-namespace Botan {
-
-/**
-* This class represents an abstract block cipher mode
-*/
-class BOTAN_DLL BlockCipherMode : public Keyed_Filter
-   {
-   public:
-      std::string name() const;
-
-      void set_iv(const InitializationVector&);
-      void set_key(const SymmetricKey& key) { cipher->set_key(key); }
-
-      bool valid_keylength(u32bit key_len) const
-         { return cipher->valid_keylength(key_len); }
-
-      BlockCipherMode(BlockCipher*, const std::string&,
-                      u32bit, u32bit = 0, u32bit = 1);
-
-      virtual ~BlockCipherMode() { delete cipher; }
-   protected:
-      const u32bit BLOCK_SIZE, BUFFER_SIZE, IV_METHOD;
-      const std::string mode_name;
-      BlockCipher* cipher;
-      SecureVector<byte> buffer, state;
-      u32bit position;
-   };
-
-}
-
-#endif