block: Add missing overrides

31 files changed, 228 insertions, 228 deletions

diff --git a/src/lib/block/aes/aes.h b/src/lib/block/aes/aes.h
index b57d4ce65..f8b8d2938 100644
--- a/src/lib/block/aes/aes.h
+++ b/src/lib/block/aes/aes.h
@@ -18,15 +18,15 @@ namespace Botan {
 class BOTAN_DLL AES_128 : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
+      void clear() override;
 
-      std::string name() const { return "AES-128"; }
-      BlockCipher* clone() const { return new AES_128; }
+      std::string name() const override { return "AES-128"; }
+      BlockCipher* clone() const override { return new AES_128; }
    private:
-      void key_schedule(const byte key[], size_t length);
+      void key_schedule(const byte key[], size_t length) override;
 
       secure_vector<u32bit> EK, DK;
       secure_vector<byte> ME, MD;
@@ -38,15 +38,15 @@ class BOTAN_DLL AES_128 : public Block_Cipher_Fixed_Params<16, 16>
 class BOTAN_DLL AES_192 : public Block_Cipher_Fixed_Params<16, 24>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
+      void clear() override;
 
-      std::string name() const { return "AES-192"; }
-      BlockCipher* clone() const { return new AES_192; }
+      std::string name() const override { return "AES-192"; }
+      BlockCipher* clone() const override { return new AES_192; }
    private:
-      void key_schedule(const byte key[], size_t length);
+      void key_schedule(const byte key[], size_t length) override;
 
       secure_vector<u32bit> EK, DK;
       secure_vector<byte> ME, MD;
@@ -58,15 +58,15 @@ class BOTAN_DLL AES_192 : public Block_Cipher_Fixed_Params<16, 24>
 class BOTAN_DLL AES_256 : public Block_Cipher_Fixed_Params<16, 32>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
+      void clear() override;
 
-      std::string name() const { return "AES-256"; }
-      BlockCipher* clone() const { return new AES_256; }
+      std::string name() const override { return "AES-256"; }
+      BlockCipher* clone() const override { return new AES_256; }
    private:
-      void key_schedule(const byte key[], size_t length);
+      void key_schedule(const byte key[], size_t length) override;
 
       secure_vector<u32bit> EK, DK;
       secure_vector<byte> ME, MD;
diff --git a/src/lib/block/aes_ni/aes_ni.h b/src/lib/block/aes_ni/aes_ni.h
index f329b409e..0f85c3482 100644
--- a/src/lib/block/aes_ni/aes_ni.h
+++ b/src/lib/block/aes_ni/aes_ni.h
@@ -18,16 +18,16 @@ namespace Botan {
 class BOTAN_DLL AES_128_NI : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
-      size_t parallelism() const { return 4; }
+      size_t parallelism() const override { return 4; }
 
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "AES-128"; }
-      BlockCipher* clone() const { return new AES_128_NI; }
+      void clear() override;
+      std::string name() const override { return "AES-128"; }
+      BlockCipher* clone() const override { return new AES_128_NI; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> EK, DK;
    };
@@ -38,16 +38,16 @@ class BOTAN_DLL AES_128_NI : public Block_Cipher_Fixed_Params<16, 16>
 class BOTAN_DLL AES_192_NI : public Block_Cipher_Fixed_Params<16, 24>
    {
    public:
-      size_t parallelism() const { return 4; }
+      size_t parallelism() const override { return 4; }
 
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "AES-192"; }
-      BlockCipher* clone() const { return new AES_192_NI; }
+      void clear() override;
+      std::string name() const override { return "AES-192"; }
+      BlockCipher* clone() const override { return new AES_192_NI; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> EK, DK;
    };
@@ -58,16 +58,16 @@ class BOTAN_DLL AES_192_NI : public Block_Cipher_Fixed_Params<16, 24>
 class BOTAN_DLL AES_256_NI : public Block_Cipher_Fixed_Params<16, 32>
    {
    public:
-      size_t parallelism() const { return 4; }
+      size_t parallelism() const override { return 4; }
 
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "AES-256"; }
-      BlockCipher* clone() const { return new AES_256_NI; }
+      void clear() override;
+      std::string name() const override { return "AES-256"; }
+      BlockCipher* clone() const override { return new AES_256_NI; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> EK, DK;
    };
diff --git a/src/lib/block/aes_ssse3/aes_ssse3.h b/src/lib/block/aes_ssse3/aes_ssse3.h
index 4e3df39e9..49e0346e4 100644
--- a/src/lib/block/aes_ssse3/aes_ssse3.h
+++ b/src/lib/block/aes_ssse3/aes_ssse3.h
@@ -18,14 +18,14 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "AES-128"; }
-      BlockCipher* clone() const { return new AES_128_SSSE3; }
+      void clear() override;
+      std::string name() const override { return "AES-128"; }
+      BlockCipher* clone() const override { return new AES_128_SSSE3; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> EK, DK;
    };
@@ -36,14 +36,14 @@ class BOTAN_DLL AES_128_SSSE3 : public Block_Cipher_Fixed_Params<16, 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "AES-192"; }
-      BlockCipher* clone() const { return new AES_192_SSSE3; }
+      void clear() override;
+      std::string name() const override { return "AES-192"; }
+      BlockCipher* clone() const override { return new AES_192_SSSE3; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> EK, DK;
    };
@@ -54,14 +54,14 @@ class BOTAN_DLL AES_192_SSSE3 : public Block_Cipher_Fixed_Params<16, 24>
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "AES-256"; }
-      BlockCipher* clone() const { return new AES_256_SSSE3; }
+      void clear() override;
+      std::string name() const override { return "AES-256"; }
+      BlockCipher* clone() const override { return new AES_256_SSSE3; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> EK, DK;
    };
diff --git a/src/lib/block/block_cipher.h b/src/lib/block/block_cipher.h
index 060dbb29b..08bf18fd3 100644
--- a/src/lib/block/block_cipher.h
+++ b/src/lib/block/block_cipher.h
@@ -151,9 +151,9 @@ class Block_Cipher_Fixed_Params : public BlockCipher
    {
    public:
       enum { BLOCK_SIZE = BS };
-      size_t block_size() const { return BS; }
+      size_t block_size() const override { return BS; }
 
-      Key_Length_Specification key_spec() const
+      Key_Length_Specification key_spec() const override
          {
          return Key_Length_Specification(KMIN, KMAX, KMOD);
          }
diff --git a/src/lib/block/blowfish/blowfish.h b/src/lib/block/blowfish/blowfish.h
index 8653bb7d6..e1042465f 100644
--- a/src/lib/block/blowfish/blowfish.h
+++ b/src/lib/block/blowfish/blowfish.h
@@ -18,8 +18,8 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
       /**
       * Modified EKSBlowfish key schedule, used for bcrypt password hashing
@@ -27,11 +27,11 @@ class BOTAN_DLL Blowfish : public Block_Cipher_Fixed_Params<8, 1, 56>
       void eks_key_schedule(const byte key[], size_t key_length,
                             const byte salt[16], size_t workfactor);
 
-      void clear();
-      std::string name() const { return "Blowfish"; }
-      BlockCipher* clone() const { return new Blowfish; }
+      void clear() override;
+      std::string name() const override { return "Blowfish"; }
+      BlockCipher* clone() const override { return new Blowfish; }
    private:
-      void key_schedule(const byte key[], size_t length);
+      void key_schedule(const byte key[], size_t length) override;
 
       void key_expansion(const byte key[],
                          size_t key_length,
diff --git a/src/lib/block/camellia/camellia.h b/src/lib/block/camellia/camellia.h
index ea08ce2a2..884cb2bd7 100644
--- a/src/lib/block/camellia/camellia.h
+++ b/src/lib/block/camellia/camellia.h
@@ -18,14 +18,14 @@ namespace Botan {
 class BOTAN_DLL Camellia_128 : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "Camellia-128"; }
-      BlockCipher* clone() const { return new Camellia_128; }
+      void clear() override;
+      std::string name() const override { return "Camellia-128"; }
+      BlockCipher* clone() const override { return new Camellia_128; }
    private:
-      void key_schedule(const byte key[], size_t length);
+      void key_schedule(const byte key[], size_t length) override;
 
       secure_vector<u64bit> SK;
    };
@@ -36,14 +36,14 @@ class BOTAN_DLL Camellia_128 : public Block_Cipher_Fixed_Params<16, 16>
 class BOTAN_DLL Camellia_192 : public Block_Cipher_Fixed_Params<16, 24>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "Camellia-192"; }
-      BlockCipher* clone() const { return new Camellia_192; }
+      void clear() override;
+      std::string name() const override { return "Camellia-192"; }
+      BlockCipher* clone() const override { return new Camellia_192; }
    private:
-      void key_schedule(const byte key[], size_t length);
+      void key_schedule(const byte key[], size_t length) override;
 
       secure_vector<u64bit> SK;
    };
@@ -54,14 +54,14 @@ class BOTAN_DLL Camellia_192 : public Block_Cipher_Fixed_Params<16, 24>
 class BOTAN_DLL Camellia_256 : public Block_Cipher_Fixed_Params<16, 32>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "Camellia-256"; }
-      BlockCipher* clone() const { return new Camellia_256; }
+      void clear() override;
+      std::string name() const override { return "Camellia-256"; }
+      BlockCipher* clone() const override { return new Camellia_256; }
    private:
-      void key_schedule(const byte key[], size_t length);
+      void key_schedule(const byte key[], size_t length) override;
 
       secure_vector<u64bit> SK;
    };
diff --git a/src/lib/block/cascade/cascade.h b/src/lib/block/cascade/cascade.h
index e96c34549..386f1bd21 100644
--- a/src/lib/block/cascade/cascade.h
+++ b/src/lib/block/cascade/cascade.h
@@ -18,20 +18,20 @@ namespace Botan {
 class BOTAN_DLL Cascade_Cipher : public BlockCipher
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      size_t block_size() const { return m_block; }
+      size_t block_size() const override { return m_block; }
 
-      Key_Length_Specification key_spec() const
+      Key_Length_Specification key_spec() const override
          {
          return Key_Length_Specification(m_cipher1->maximum_keylength() +
                                          m_cipher2->maximum_keylength());
          }
 
-      void clear();
-      std::string name() const;
-      BlockCipher* clone() const;
+      void clear() override;
+      std::string name() const override;
+      BlockCipher* clone() const override;
 
       static Cascade_Cipher* make(const Spec& spec);
 
@@ -45,7 +45,7 @@ class BOTAN_DLL Cascade_Cipher : public BlockCipher
       Cascade_Cipher(const Cascade_Cipher&) = delete;
       Cascade_Cipher& operator=(const Cascade_Cipher&) = delete;
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       size_t m_block;
       std::unique_ptr<BlockCipher> m_cipher1, m_cipher2;
diff --git a/src/lib/block/cast/cast128.h b/src/lib/block/cast/cast128.h
index ed28d6a71..2a0f4462a 100644
--- a/src/lib/block/cast/cast128.h
+++ b/src/lib/block/cast/cast128.h
@@ -18,15 +18,15 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "CAST-128"; }
-      BlockCipher* clone() const { return new CAST_128; }
+      void clear() override;
+      std::string name() const override { return "CAST-128"; }
+      BlockCipher* clone() const override { return new CAST_128; }
 
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       static void cast_ks(secure_vector<u32bit>& ks,
                           secure_vector<u32bit>& user_key);
diff --git a/src/lib/block/cast/cast256.h b/src/lib/block/cast/cast256.h
index 206b4d83e..9f7546711 100644
--- a/src/lib/block/cast/cast256.h
+++ b/src/lib/block/cast/cast256.h
@@ -18,14 +18,14 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "CAST-256"; }
-      BlockCipher* clone() const { return new CAST_256; }
+      void clear() override;
+      std::string name() const override { return "CAST-256"; }
+      BlockCipher* clone() const override { return new CAST_256; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> MK;
       secure_vector<byte> RK;
diff --git a/src/lib/block/des/des.h b/src/lib/block/des/des.h
index aa201e560..1a2fdc5c9 100644
--- a/src/lib/block/des/des.h
+++ b/src/lib/block/des/des.h
@@ -18,14 +18,14 @@ namespace Botan {
 class BOTAN_DLL DES : public Block_Cipher_Fixed_Params<8, 8>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "DES"; }
-      BlockCipher* clone() const { return new DES; }
+      void clear() override;
+      std::string name() const override { return "DES"; }
+      BlockCipher* clone() const override { return new DES; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> round_key;
    };
@@ -36,14 +36,14 @@ class BOTAN_DLL DES : public Block_Cipher_Fixed_Params<8, 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "TripleDES"; }
-      BlockCipher* clone() const { return new TripleDES; }
+      void clear() override;
+      std::string name() const override { return "TripleDES"; }
+      BlockCipher* clone() const override { return new TripleDES; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> round_key;
    };
diff --git a/src/lib/block/des/desx.h b/src/lib/block/des/desx.h
index f324ed7d5..0f155b241 100644
--- a/src/lib/block/des/desx.h
+++ b/src/lib/block/des/desx.h
@@ -18,14 +18,14 @@ namespace Botan {
 class BOTAN_DLL DESX : public Block_Cipher_Fixed_Params<8, 24>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "DESX"; }
-      BlockCipher* clone() const { return new DESX; }
+      void clear() override;
+      std::string name() const override { return "DESX"; }
+      BlockCipher* clone() const override { return new DESX; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
       secure_vector<byte> K1, K2;
       DES des;
    };
diff --git a/src/lib/block/gost_28147/gost_28147.h b/src/lib/block/gost_28147/gost_28147.h
index 6d6e546f2..3cf1c4578 100644
--- a/src/lib/block/gost_28147/gost_28147.h
+++ b/src/lib/block/gost_28147/gost_28147.h
@@ -52,13 +52,13 @@ class BOTAN_DLL GOST_28147_89_Params
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
+      void clear() override;
 
-      std::string name() const;
-      BlockCipher* clone() const { return new GOST_28147_89(SBOX); }
+      std::string name() const override;
+      BlockCipher* clone() const override { return new GOST_28147_89(SBOX); }
 
       /**
       * @param params the sbox parameters to use
@@ -68,7 +68,7 @@ class BOTAN_DLL GOST_28147_89 : public Block_Cipher_Fixed_Params<8, 32>
       GOST_28147_89(const std::vector<u32bit>& other_SBOX) :
          SBOX(other_SBOX), EK(8) {}
 
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       /*
       * The sbox is not secret, this is just a larger expansion of it
diff --git a/src/lib/block/idea/idea.h b/src/lib/block/idea/idea.h
index 3c01ad873..68d4d61b0 100644
--- a/src/lib/block/idea/idea.h
+++ b/src/lib/block/idea/idea.h
@@ -18,12 +18,12 @@ namespace Botan {
 class BOTAN_DLL IDEA : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "IDEA"; }
-      BlockCipher* clone() const { return new IDEA; }
+      void clear() override;
+      std::string name() const override { return "IDEA"; }
+      BlockCipher* clone() const override { return new IDEA; }
    protected:
       /**
       * @return const reference to encryption subkeys
@@ -36,7 +36,7 @@ class BOTAN_DLL IDEA : public Block_Cipher_Fixed_Params<8, 16>
       const secure_vector<u16bit>& get_DK() const { return DK; }
 
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u16bit> EK, DK;
    };
diff --git a/src/lib/block/idea_sse2/idea_sse2.h b/src/lib/block/idea_sse2/idea_sse2.h
index 10d19688e..18ea7c74d 100644
--- a/src/lib/block/idea_sse2/idea_sse2.h
+++ b/src/lib/block/idea_sse2/idea_sse2.h
@@ -18,12 +18,12 @@ namespace Botan {
 class BOTAN_DLL IDEA_SSE2 : public IDEA
    {
    public:
-      size_t parallelism() const { return 8; }
+      size_t parallelism() const override { return 8; }
 
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      BlockCipher* clone() const { return new IDEA_SSE2; }
+      BlockCipher* clone() const override { return new IDEA_SSE2; }
    };
 
 }
diff --git a/src/lib/block/kasumi/kasumi.h b/src/lib/block/kasumi/kasumi.h
index 97e8dbb31..9f86279af 100644
--- a/src/lib/block/kasumi/kasumi.h
+++ b/src/lib/block/kasumi/kasumi.h
@@ -18,14 +18,14 @@ namespace Botan {
 class BOTAN_DLL KASUMI : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "KASUMI"; }
-      BlockCipher* clone() const { return new KASUMI; }
+      void clear() override;
+      std::string name() const override { return "KASUMI"; }
+      BlockCipher* clone() const override { return new KASUMI; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u16bit> EK;
    };
diff --git a/src/lib/block/lion/lion.h b/src/lib/block/lion/lion.h
index 451ee9f88..d03d1d1a0 100644
--- a/src/lib/block/lion/lion.h
+++ b/src/lib/block/lion/lion.h
@@ -48,7 +48,7 @@ class BOTAN_DLL Lion : public BlockCipher
            StreamCipher* cipher,
            size_t block_size);
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       size_t left_size() const { return m_hash->output_length(); }
       size_t right_size() const { return m_block_size - left_size(); }
diff --git a/src/lib/block/mars/mars.h b/src/lib/block/mars/mars.h
index 90de963ce..250fd2731 100644
--- a/src/lib/block/mars/mars.h
+++ b/src/lib/block/mars/mars.h
@@ -18,14 +18,14 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "MARS"; }
-      BlockCipher* clone() const { return new MARS; }
+      void clear() override;
+      std::string name() const override { return "MARS"; }
+      BlockCipher* clone() const override { return new MARS; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> EK;
    };
diff --git a/src/lib/block/misty1/misty1.h b/src/lib/block/misty1/misty1.h
index 177c2c0b5..56153f929 100644
--- a/src/lib/block/misty1/misty1.h
+++ b/src/lib/block/misty1/misty1.h
@@ -18,14 +18,14 @@ namespace Botan {
 class BOTAN_DLL MISTY1 : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "MISTY1"; }
-      BlockCipher* clone() const { return new MISTY1; }
+      void clear() override;
+      std::string name() const override { return "MISTY1"; }
+      BlockCipher* clone() const override { return new MISTY1; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u16bit> EK, DK;
    };
diff --git a/src/lib/block/noekeon/noekeon.h b/src/lib/block/noekeon/noekeon.h
index 36be5903c..7b5b6d11b 100644
--- a/src/lib/block/noekeon/noekeon.h
+++ b/src/lib/block/noekeon/noekeon.h
@@ -18,12 +18,12 @@ namespace Botan {
 class BOTAN_DLL Noekeon : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "Noekeon"; }
-      BlockCipher* clone() const { return new Noekeon; }
+      void clear() override;
+      std::string name() const override { return "Noekeon"; }
+      BlockCipher* clone() const override { return new Noekeon; }
    protected:
       /**
       * The Noekeon round constants
@@ -41,7 +41,7 @@ class BOTAN_DLL Noekeon : public Block_Cipher_Fixed_Params<16, 16>
       const secure_vector<u32bit>& get_DK() const { return DK; }
 
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
       secure_vector<u32bit> EK, DK;
    };
 
diff --git a/src/lib/block/noekeon_simd/noekeon_simd.h b/src/lib/block/noekeon_simd/noekeon_simd.h
index eaf48a364..8d40d13dd 100644
--- a/src/lib/block/noekeon_simd/noekeon_simd.h
+++ b/src/lib/block/noekeon_simd/noekeon_simd.h
@@ -18,12 +18,12 @@ namespace Botan {
 class BOTAN_DLL Noekeon_SIMD : public Noekeon
    {
    public:
-      size_t parallelism() const { return 4; }
+      size_t parallelism() const override { return 4; }
 
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      BlockCipher* clone() const { return new Noekeon_SIMD; }
+      BlockCipher* clone() const override { return new Noekeon_SIMD; }
    };
 
 }
diff --git a/src/lib/block/rc2/rc2.h b/src/lib/block/rc2/rc2.h
index 1ae58e186..11956f408 100644
--- a/src/lib/block/rc2/rc2.h
+++ b/src/lib/block/rc2/rc2.h
@@ -18,8 +18,8 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
       /**
       * Return the code of the effective key bits
@@ -28,11 +28,11 @@ class BOTAN_DLL RC2 : public Block_Cipher_Fixed_Params<8, 1, 32>
       */
       static byte EKB_code(size_t bits);
 
-      void clear();
-      std::string name() const { return "RC2"; }
-      BlockCipher* clone() const { return new RC2; }
+      void clear() override;
+      std::string name() const override { return "RC2"; }
+      BlockCipher* clone() const override { return new RC2; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u16bit> K;
    };
diff --git a/src/lib/block/rc5/rc5.h b/src/lib/block/rc5/rc5.h
index 782d0592c..b8ff1c3f7 100644
--- a/src/lib/block/rc5/rc5.h
+++ b/src/lib/block/rc5/rc5.h
@@ -18,12 +18,12 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const;
-      BlockCipher* clone() const { return new RC5(rounds); }
+      void clear() override;
+      std::string name() const override;
+      BlockCipher* clone() const override { return new RC5(rounds); }
 
       /**
       * @param rounds the number of RC5 rounds to run. Must be between
@@ -31,7 +31,7 @@ class BOTAN_DLL RC5 : public Block_Cipher_Fixed_Params<8, 1, 32>
       */
       RC5(size_t rounds);
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       size_t rounds;
       secure_vector<u32bit> S;
diff --git a/src/lib/block/rc6/rc6.h b/src/lib/block/rc6/rc6.h
index 282d56639..1ff7304ed 100644
--- a/src/lib/block/rc6/rc6.h
+++ b/src/lib/block/rc6/rc6.h
@@ -18,14 +18,14 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "RC6"; }
-      BlockCipher* clone() const { return new RC6; }
+      void clear() override;
+      std::string name() const override { return "RC6"; }
+      BlockCipher* clone() const override { return new RC6; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       secure_vector<u32bit> S;
    };
diff --git a/src/lib/block/safer/safer_sk.h b/src/lib/block/safer/safer_sk.h
index d346c739e..74241d4e6 100644
--- a/src/lib/block/safer/safer_sk.h
+++ b/src/lib/block/safer/safer_sk.h
@@ -18,12 +18,12 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const;
-      BlockCipher* clone() const;
+      void clear() override;
+      std::string name() const override;
+      BlockCipher* clone() const override;
 
       /**
       * @param rounds the number of rounds to use - must be between 1
@@ -31,7 +31,7 @@ class BOTAN_DLL SAFER_SK : public Block_Cipher_Fixed_Params<8, 16>
       */
       SAFER_SK(size_t rounds);
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       size_t rounds;
       secure_vector<byte> EK;
diff --git a/src/lib/block/seed/seed.h b/src/lib/block/seed/seed.h
index d98d6e798..431af7309 100644
--- a/src/lib/block/seed/seed.h
+++ b/src/lib/block/seed/seed.h
@@ -18,14 +18,14 @@ namespace Botan {
 class BOTAN_DLL SEED : public Block_Cipher_Fixed_Params<16, 16>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "SEED"; }
-      BlockCipher* clone() const { return new SEED; }
+      void clear() override;
+      std::string name() const override { return "SEED"; }
+      BlockCipher* clone() const override { return new SEED; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       class G_FUNC
          {
diff --git a/src/lib/block/serpent/serpent.h b/src/lib/block/serpent/serpent.h
index a3f5d0817..7fdf4600d 100644
--- a/src/lib/block/serpent/serpent.h
+++ b/src/lib/block/serpent/serpent.h
@@ -18,12 +18,12 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "Serpent"; }
-      BlockCipher* clone() const { return new Serpent; }
+      void clear() override;
+      std::string name() const override { return "Serpent"; }
+      BlockCipher* clone() const override { return new Serpent; }
    protected:
       /**
       * For use by subclasses using SIMD, asm, etc
@@ -42,7 +42,7 @@ class BOTAN_DLL Serpent : public Block_Cipher_Fixed_Params<16, 16, 32, 8>
          }
 
    private:
-      void key_schedule(const byte key[], size_t length);
+      void key_schedule(const byte key[], size_t length) override;
       secure_vector<u32bit> round_key;
    };
 
diff --git a/src/lib/block/serpent_simd/serp_simd.h b/src/lib/block/serpent_simd/serp_simd.h
index cde5bf112..373d47fa1 100644
--- a/src/lib/block/serpent_simd/serp_simd.h
+++ b/src/lib/block/serpent_simd/serp_simd.h
@@ -18,12 +18,12 @@ namespace Botan {
 class BOTAN_DLL Serpent_SIMD : public Serpent
    {
    public:
-      size_t parallelism() const { return 4; }
+      size_t parallelism() const override { return 4; }
 
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      BlockCipher* clone() const { return new Serpent_SIMD; }
+      BlockCipher* clone() const override { return new Serpent_SIMD; }
    };
 
 }
diff --git a/src/lib/block/tea/tea.h b/src/lib/block/tea/tea.h
index 55e6d8309..3c5b4773e 100644
--- a/src/lib/block/tea/tea.h
+++ b/src/lib/block/tea/tea.h
@@ -18,14 +18,14 @@ namespace Botan {
 class BOTAN_DLL TEA : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "TEA"; }
-      BlockCipher* clone() const { return new TEA; }
+      void clear() override;
+      std::string name() const override { return "TEA"; }
+      BlockCipher* clone() const override { return new TEA; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
       secure_vector<u32bit> K;
    };
 
diff --git a/src/lib/block/twofish/twofish.h b/src/lib/block/twofish/twofish.h
index f6e030df2..c6af1a030 100644
--- a/src/lib/block/twofish/twofish.h
+++ b/src/lib/block/twofish/twofish.h
@@ -18,14 +18,14 @@ namespace Botan {
 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;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "Twofish"; }
-      BlockCipher* clone() const { return new Twofish; }
+      void clear() override;
+      std::string name() const override { return "Twofish"; }
+      BlockCipher* clone() const override { return new Twofish; }
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
 
       static void rs_mul(byte[4], byte, size_t);
 
diff --git a/src/lib/block/xtea/xtea.h b/src/lib/block/xtea/xtea.h
index 4de0bea72..ea5c39418 100644
--- a/src/lib/block/xtea/xtea.h
+++ b/src/lib/block/xtea/xtea.h
@@ -18,12 +18,12 @@ namespace Botan {
 class BOTAN_DLL XTEA : public Block_Cipher_Fixed_Params<8, 16>
    {
    public:
-      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 encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
 
-      void clear();
-      std::string name() const { return "XTEA"; }
-      BlockCipher* clone() const { return new XTEA; }
+      void clear() override;
+      std::string name() const override { return "XTEA"; }
+      BlockCipher* clone() const override { return new XTEA; }
    protected:
       /**
       * @return const reference to the key schedule
@@ -31,7 +31,7 @@ class BOTAN_DLL XTEA : public Block_Cipher_Fixed_Params<8, 16>
       const secure_vector<u32bit>& get_EK() const { return EK; }
 
    private:
-      void key_schedule(const byte[], size_t);
+      void key_schedule(const byte[], size_t) override;
       secure_vector<u32bit> EK;
    };
 
diff --git a/src/lib/block/xtea_simd/xtea_simd.h b/src/lib/block/xtea_simd/xtea_simd.h
index 451dc8c8d..04280f1ae 100644
--- a/src/lib/block/xtea_simd/xtea_simd.h
+++ b/src/lib/block/xtea_simd/xtea_simd.h
@@ -18,11 +18,11 @@ namespace Botan {
 class BOTAN_DLL XTEA_SIMD : public XTEA
    {
    public:
-      size_t parallelism() const { return 8; }
+      size_t parallelism() const override { return 8; }
 
-      void encrypt_n(const byte in[], byte out[], size_t blocks) const;
-      void decrypt_n(const byte in[], byte out[], size_t blocks) const;
-      BlockCipher* clone() const { return new XTEA_SIMD; }
+      void encrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      void decrypt_n(const byte in[], byte out[], size_t blocks) const override;
+      BlockCipher* clone() const override { return new XTEA_SIMD; }
    };
 
 }