hash: Add missing overrides

21 files changed, 143 insertions, 143 deletions

diff --git a/src/lib/hash/checksum/adler32/adler32.h b/src/lib/hash/checksum/adler32/adler32.h
index f3767b786..307236d6d 100644
--- a/src/lib/hash/checksum/adler32/adler32.h
+++ b/src/lib/hash/checksum/adler32/adler32.h
@@ -18,17 +18,17 @@ namespace Botan {
 class BOTAN_DLL Adler32 : public HashFunction
    {
    public:
-      std::string name() const { return "Adler32"; }
-      size_t output_length() const { return 4; }
-      HashFunction* clone() const { return new Adler32; }
+      std::string name() const override { return "Adler32"; }
+      size_t output_length() const override { return 4; }
+      HashFunction* clone() const override { return new Adler32; }
 
-      void clear() { S1 = 1; S2 = 0; }
+      void clear() override { S1 = 1; S2 = 0; }
 
       Adler32() { clear(); }
       ~Adler32() { clear(); }
    private:
-      void add_data(const byte[], size_t);
-      void final_result(byte[]);
+      void add_data(const byte[], size_t) override;
+      void final_result(byte[]) override;
       u16bit S1, S2;
    };
 
diff --git a/src/lib/hash/checksum/crc24/crc24.h b/src/lib/hash/checksum/crc24/crc24.h
index a5cc090ad..8df8bd727 100644
--- a/src/lib/hash/checksum/crc24/crc24.h
+++ b/src/lib/hash/checksum/crc24/crc24.h
@@ -18,17 +18,17 @@ namespace Botan {
 class BOTAN_DLL CRC24 : public HashFunction
    {
    public:
-      std::string name() const { return "CRC24"; }
-      size_t output_length() const { return 3; }
-      HashFunction* clone() const { return new CRC24; }
+      std::string name() const override { return "CRC24"; }
+      size_t output_length() const override { return 3; }
+      HashFunction* clone() const override { return new CRC24; }
 
-      void clear() { crc = 0xB704CE; }
+      void clear() override { crc = 0xB704CE; }
 
       CRC24() { clear(); }
       ~CRC24() { clear(); }
    private:
-      void add_data(const byte[], size_t);
-      void final_result(byte[]);
+      void add_data(const byte[], size_t) override;
+      void final_result(byte[]) override;
       u32bit crc;
    };
 
diff --git a/src/lib/hash/checksum/crc32/crc32.h b/src/lib/hash/checksum/crc32/crc32.h
index 503b18b7a..8ae95d42a 100644
--- a/src/lib/hash/checksum/crc32/crc32.h
+++ b/src/lib/hash/checksum/crc32/crc32.h
@@ -18,17 +18,17 @@ namespace Botan {
 class BOTAN_DLL CRC32 : public HashFunction
    {
    public:
-      std::string name() const { return "CRC32"; }
-      size_t output_length() const { return 4; }
-      HashFunction* clone() const { return new CRC32; }
+      std::string name() const override { return "CRC32"; }
+      size_t output_length() const override { return 4; }
+      HashFunction* clone() const override { return new CRC32; }
 
-      void clear() { crc = 0xFFFFFFFF; }
+      void clear() override { crc = 0xFFFFFFFF; }
 
       CRC32() { clear(); }
       ~CRC32() { clear(); }
    private:
-      void add_data(const byte[], size_t);
-      void final_result(byte[]);
+      void add_data(const byte[], size_t) override;
+      void final_result(byte[]) override;
       u32bit crc;
    };
 
diff --git a/src/lib/hash/comb4p/comb4p.h b/src/lib/hash/comb4p/comb4p.h
index d2e9587c2..1a99934a2 100644
--- a/src/lib/hash/comb4p/comb4p.h
+++ b/src/lib/hash/comb4p/comb4p.h
@@ -25,29 +25,29 @@ class BOTAN_DLL Comb4P : public HashFunction
       */
       Comb4P(HashFunction* h1, HashFunction* h2);
 
-      size_t hash_block_size() const;
+      size_t hash_block_size() const override;
 
-      size_t output_length() const
+      size_t output_length() const override
          {
          return m_hash1->output_length() + m_hash2->output_length();
          }
 
       static Comb4P* make(const Spec& spec);
       
-      HashFunction* clone() const
+      HashFunction* clone() const override
          {
          return new Comb4P(m_hash1->clone(), m_hash2->clone());
          }
 
-      std::string name() const
+      std::string name() const override
          {
          return "Comb4P(" + m_hash1->name() + "," + m_hash2->name() + ")";
          }
 
-      void clear();
+      void clear() override;
    private:
-      void add_data(const byte input[], size_t length);
-      void final_result(byte out[]);
+      void add_data(const byte input[], size_t length) override;
+      void final_result(byte out[]) override;
 
       std::unique_ptr<HashFunction> m_hash1, m_hash2;
    };
diff --git a/src/lib/hash/gost_3411/gost_3411.h b/src/lib/hash/gost_3411/gost_3411.h
index fb636e30e..2ad96dbdb 100644
--- a/src/lib/hash/gost_3411/gost_3411.h
+++ b/src/lib/hash/gost_3411/gost_3411.h
@@ -19,19 +19,19 @@ namespace Botan {
 class BOTAN_DLL GOST_34_11 : public HashFunction
    {
    public:
-      std::string name() const { return "GOST-R-34.11-94" ; }
-      size_t output_length() const { return 32; }
-      size_t hash_block_size() const { return 32; }
-      HashFunction* clone() const { return new GOST_34_11; }
+      std::string name() const override { return "GOST-R-34.11-94" ; }
+      size_t output_length() const override { return 32; }
+      size_t hash_block_size() const override { return 32; }
+      HashFunction* clone() const override { return new GOST_34_11; }
 
-      void clear();
+      void clear() override;
 
       GOST_34_11();
    private:
       void compress_n(const byte input[], size_t blocks);
 
-      void add_data(const byte[], size_t);
-      void final_result(byte[]);
+      void add_data(const byte[], size_t) override;
+      void final_result(byte[]) override;
 
       GOST_28147_89 cipher;
       secure_vector<byte> buffer, sum, hash;
diff --git a/src/lib/hash/has160/has160.h b/src/lib/hash/has160/has160.h
index e7ad42e62..75d0bda90 100644
--- a/src/lib/hash/has160/has160.h
+++ b/src/lib/hash/has160/has160.h
@@ -19,17 +19,17 @@ namespace Botan {
 class BOTAN_DLL HAS_160 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "HAS-160"; }
-      size_t output_length() const { return 20; }
-      HashFunction* clone() const { return new HAS_160; }
+      std::string name() const override { return "HAS-160"; }
+      size_t output_length() const override { return 20; }
+      HashFunction* clone() const override { return new HAS_160; }
 
-      void clear();
+      void clear() override;
 
       HAS_160() : MDx_HashFunction(64, false, true), X(20), digest(5)
          { clear(); }
    private:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       secure_vector<u32bit> X, digest;
    };
diff --git a/src/lib/hash/keccak/keccak.h b/src/lib/hash/keccak/keccak.h
index a115d8f7f..0e7d3d5d1 100644
--- a/src/lib/hash/keccak/keccak.h
+++ b/src/lib/hash/keccak/keccak.h
@@ -27,15 +27,15 @@ class BOTAN_DLL Keccak_1600 : public HashFunction
       */
       Keccak_1600(size_t output_bits = 512);
 
-      size_t hash_block_size() const { return bitrate / 8; }
-      size_t output_length() const { return output_bits / 8; }
+      size_t hash_block_size() const override { return bitrate / 8; }
+      size_t output_length() const override { return output_bits / 8; }
 
-      HashFunction* clone() const;
-      std::string name() const;
-      void clear();
+      HashFunction* clone() const override;
+      std::string name() const override;
+      void clear() override;
    private:
-      void add_data(const byte input[], size_t length);
-      void final_result(byte out[]);
+      void add_data(const byte input[], size_t length) override;
+      void final_result(byte out[]) override;
 
       size_t output_bits, bitrate;
       secure_vector<u64bit> S;
diff --git a/src/lib/hash/md2/md2.h b/src/lib/hash/md2/md2.h
index bde390385..62f1b8a9f 100644
--- a/src/lib/hash/md2/md2.h
+++ b/src/lib/hash/md2/md2.h
@@ -18,19 +18,19 @@ namespace Botan {
 class BOTAN_DLL MD2 : public HashFunction
    {
    public:
-      std::string name() const { return "MD2"; }
-      size_t output_length() const { return 16; }
-      size_t hash_block_size() const { return 16; }
-      HashFunction* clone() const { return new MD2; }
+      std::string name() const override { return "MD2"; }
+      size_t output_length() const override { return 16; }
+      size_t hash_block_size() const override { return 16; }
+      HashFunction* clone() const override { return new MD2; }
 
-      void clear();
+      void clear() override;
 
       MD2() : X(48), checksum(16), buffer(16)
          { clear(); }
    private:
-      void add_data(const byte[], size_t);
+      void add_data(const byte[], size_t) override;
       void hash(const byte[]);
-      void final_result(byte[]);
+      void final_result(byte[]) override;
 
       secure_vector<byte> X, checksum, buffer;
       size_t position;
diff --git a/src/lib/hash/md4/md4.h b/src/lib/hash/md4/md4.h
index 3d38550c2..182da4ab2 100644
--- a/src/lib/hash/md4/md4.h
+++ b/src/lib/hash/md4/md4.h
@@ -18,17 +18,17 @@ namespace Botan {
 class BOTAN_DLL MD4 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "MD4"; }
-      size_t output_length() const { return 16; }
-      HashFunction* clone() const { return new MD4; }
+      std::string name() const override { return "MD4"; }
+      size_t output_length() const override { return 16; }
+      HashFunction* clone() const override { return new MD4; }
 
-      void clear();
+      void clear() override;
 
       MD4() : MDx_HashFunction(64, false, true), M(16), digest(4)
          { clear(); }
    protected:
-      void compress_n(const byte input[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte input[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       /**
       * The message buffer, exposed for use by subclasses (x86 asm)
diff --git a/src/lib/hash/md5/md5.h b/src/lib/hash/md5/md5.h
index bbdc11aa6..9c5e548c0 100644
--- a/src/lib/hash/md5/md5.h
+++ b/src/lib/hash/md5/md5.h
@@ -18,17 +18,17 @@ namespace Botan {
 class BOTAN_DLL MD5 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "MD5"; }
-      size_t output_length() const { return 16; }
-      HashFunction* clone() const { return new MD5; }
+      std::string name() const override { return "MD5"; }
+      size_t output_length() const override { return 16; }
+      HashFunction* clone() const override { return new MD5; }
 
-      void clear();
+      void clear() override;
 
       MD5() : MDx_HashFunction(64, false, true), M(16), digest(4)
          { clear(); }
    protected:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       /**
       * The message buffer, exposed for use by subclasses (x86 asm)
diff --git a/src/lib/hash/mdx_hash/mdx_hash.h b/src/lib/hash/mdx_hash/mdx_hash.h
index 9671cbe81..2652d9ea6 100644
--- a/src/lib/hash/mdx_hash/mdx_hash.h
+++ b/src/lib/hash/mdx_hash/mdx_hash.h
@@ -29,10 +29,10 @@ class BOTAN_DLL MDx_HashFunction : public HashFunction
                        bool big_bit_endian,
                        size_t counter_size = 8);
 
-      size_t hash_block_size() const { return buffer.size(); }
+      size_t hash_block_size() const override { return buffer.size(); }
    protected:
-      void add_data(const byte input[], size_t length);
-      void final_result(byte output[]);
+      void add_data(const byte input[], size_t length) override;
+      void final_result(byte output[]) override;
 
       /**
       * Run the hash's compression function over a set of blocks
@@ -41,7 +41,7 @@ class BOTAN_DLL MDx_HashFunction : public HashFunction
       */
       virtual void compress_n(const byte blocks[], size_t block_n) = 0;
 
-      void clear();
+      void clear() override;
 
       /**
       * Copy the output to the buffer
diff --git a/src/lib/hash/par_hash/par_hash.h b/src/lib/hash/par_hash/par_hash.h
index 58900043a..0410e6826 100644
--- a/src/lib/hash/par_hash/par_hash.h
+++ b/src/lib/hash/par_hash/par_hash.h
@@ -19,11 +19,11 @@ namespace Botan {
 class BOTAN_DLL Parallel : public HashFunction
    {
    public:
-      void clear();
-      std::string name() const;
-      HashFunction* clone() const;
+      void clear() override;
+      std::string name() const override;
+      HashFunction* clone() const override;
 
-      size_t output_length() const;
+      size_t output_length() const override;
 
       /**
       * @param hashes a set of hashes to compute in parallel
@@ -37,8 +37,8 @@ class BOTAN_DLL Parallel : public HashFunction
    private:
       Parallel() {}
 
-      void add_data(const byte[], size_t);
-      void final_result(byte[]);
+      void add_data(const byte[], size_t) override;
+      void final_result(byte[]) override;
 
       std::vector<std::unique_ptr<HashFunction>> hashes;
    };
diff --git a/src/lib/hash/rmd128/rmd128.h b/src/lib/hash/rmd128/rmd128.h
index a91122c79..ea1eb2286 100644
--- a/src/lib/hash/rmd128/rmd128.h
+++ b/src/lib/hash/rmd128/rmd128.h
@@ -18,17 +18,17 @@ namespace Botan {
 class BOTAN_DLL RIPEMD_128 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "RIPEMD-128"; }
-      size_t output_length() const { return 16; }
-      HashFunction* clone() const { return new RIPEMD_128; }
+      std::string name() const override { return "RIPEMD-128"; }
+      size_t output_length() const override { return 16; }
+      HashFunction* clone() const override { return new RIPEMD_128; }
 
-      void clear();
+      void clear() override;
 
       RIPEMD_128() : MDx_HashFunction(64, false, true), M(16), digest(4)
          { clear(); }
    private:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       secure_vector<u32bit> M, digest;
    };
diff --git a/src/lib/hash/rmd160/rmd160.h b/src/lib/hash/rmd160/rmd160.h
index a4f428c37..ad7182404 100644
--- a/src/lib/hash/rmd160/rmd160.h
+++ b/src/lib/hash/rmd160/rmd160.h
@@ -18,17 +18,17 @@ namespace Botan {
 class BOTAN_DLL RIPEMD_160 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "RIPEMD-160"; }
-      size_t output_length() const { return 20; }
-      HashFunction* clone() const { return new RIPEMD_160; }
+      std::string name() const override { return "RIPEMD-160"; }
+      size_t output_length() const override { return 20; }
+      HashFunction* clone() const override { return new RIPEMD_160; }
 
-      void clear();
+      void clear() override;
 
       RIPEMD_160() : MDx_HashFunction(64, false, true), M(16), digest(5)
          { clear(); }
    private:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       secure_vector<u32bit> M, digest;
    };
diff --git a/src/lib/hash/sha1/sha160.h b/src/lib/hash/sha1/sha160.h
index fbafb5c7d..6328d74c4 100644
--- a/src/lib/hash/sha1/sha160.h
+++ b/src/lib/hash/sha1/sha160.h
@@ -18,11 +18,11 @@ namespace Botan {
 class BOTAN_DLL SHA_160 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "SHA-160"; }
-      size_t output_length() const { return 20; }
-      HashFunction* clone() const { return new SHA_160; }
+      std::string name() const override { return "SHA-160"; }
+      size_t output_length() const override { return 20; }
+      HashFunction* clone() const override { return new SHA_160; }
 
-      void clear();
+      void clear() override;
 
       SHA_160() : MDx_HashFunction(64, true, true), digest(5), W(80)
          {
@@ -41,8 +41,8 @@ class BOTAN_DLL SHA_160 : public MDx_HashFunction
          clear();
          }
 
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       /**
       * The digest value, exposed for use by subclasses (asm, SSE2)
diff --git a/src/lib/hash/sha1_sse2/sha1_sse2.h b/src/lib/hash/sha1_sse2/sha1_sse2.h
index fc74c41b7..20bb63727 100644
--- a/src/lib/hash/sha1_sse2/sha1_sse2.h
+++ b/src/lib/hash/sha1_sse2/sha1_sse2.h
@@ -18,10 +18,10 @@ namespace Botan {
 class BOTAN_DLL SHA_160_SSE2 : public SHA_160
    {
    public:
-      HashFunction* clone() const { return new SHA_160_SSE2; }
+      HashFunction* clone() const override { return new SHA_160_SSE2; }
       SHA_160_SSE2() : SHA_160(0) {} // no W needed
    private:
-      void compress_n(const byte[], size_t blocks);
+      void compress_n(const byte[], size_t blocks) override;
    };
 
 }
diff --git a/src/lib/hash/sha2_32/sha2_32.h b/src/lib/hash/sha2_32/sha2_32.h
index 2ea12860d..e51087dc1 100644
--- a/src/lib/hash/sha2_32/sha2_32.h
+++ b/src/lib/hash/sha2_32/sha2_32.h
@@ -19,17 +19,17 @@ namespace Botan {
 class BOTAN_DLL SHA_224 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "SHA-224"; }
-      size_t output_length() const { return 28; }
-      HashFunction* clone() const { return new SHA_224; }
+      std::string name() const override { return "SHA-224"; }
+      size_t output_length() const override { return 28; }
+      HashFunction* clone() const override { return new SHA_224; }
 
-      void clear();
+      void clear() override;
 
       SHA_224() : MDx_HashFunction(64, true, true), digest(8)
          { clear(); }
    private:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       secure_vector<u32bit> digest;
    };
@@ -40,17 +40,17 @@ class BOTAN_DLL SHA_224 : public MDx_HashFunction
 class BOTAN_DLL SHA_256 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "SHA-256"; }
-      size_t output_length() const { return 32; }
-      HashFunction* clone() const { return new SHA_256; }
+      std::string name() const override { return "SHA-256"; }
+      size_t output_length() const override { return 32; }
+      HashFunction* clone() const override { return new SHA_256; }
 
-      void clear();
+      void clear() override;
 
       SHA_256() : MDx_HashFunction(64, true, true), digest(8)
          { clear(); }
    private:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       secure_vector<u32bit> digest;
    };
diff --git a/src/lib/hash/sha2_64/sha2_64.h b/src/lib/hash/sha2_64/sha2_64.h
index 2956d94e8..5aae5effe 100644
--- a/src/lib/hash/sha2_64/sha2_64.h
+++ b/src/lib/hash/sha2_64/sha2_64.h
@@ -18,17 +18,17 @@ namespace Botan {
 class BOTAN_DLL SHA_384 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "SHA-384"; }
-      size_t output_length() const { return 48; }
-      HashFunction* clone() const { return new SHA_384; }
+      std::string name() const override { return "SHA-384"; }
+      size_t output_length() const override { return 48; }
+      HashFunction* clone() const override { return new SHA_384; }
 
-      void clear();
+      void clear() override;
 
       SHA_384() : MDx_HashFunction(128, true, true, 16), m_digest(8)
          { clear(); }
    private:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       secure_vector<u64bit> m_digest;
    };
@@ -39,17 +39,17 @@ class BOTAN_DLL SHA_384 : public MDx_HashFunction
 class BOTAN_DLL SHA_512 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "SHA-512"; }
-      size_t output_length() const { return 64; }
-      HashFunction* clone() const { return new SHA_512; }
+      std::string name() const override { return "SHA-512"; }
+      size_t output_length() const override { return 64; }
+      HashFunction* clone() const override { return new SHA_512; }
 
-      void clear();
+      void clear() override;
 
       SHA_512() : MDx_HashFunction(128, true, true, 16), m_digest(8)
          { clear(); }
    private:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       secure_vector<u64bit> m_digest;
    };
@@ -60,16 +60,16 @@ class BOTAN_DLL SHA_512 : public MDx_HashFunction
 class BOTAN_DLL SHA_512_256 : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "SHA-512/256"; }
-      size_t output_length() const { return 32; }
-      HashFunction* clone() const { return new SHA_512_256; }
+      std::string name() const override { return "SHA-512/256"; }
+      size_t output_length() const override { return 32; }
+      HashFunction* clone() const override { return new SHA_512_256; }
 
-      void clear();
+      void clear() override;
 
       SHA_512_256() : MDx_HashFunction(128, true, true, 16), m_digest(8) { clear(); }
    private:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       secure_vector<u64bit> m_digest;
    };
diff --git a/src/lib/hash/skein/skein_512.h b/src/lib/hash/skein/skein_512.h
index 3ae9fcdc3..dceb34854 100644
--- a/src/lib/hash/skein/skein_512.h
+++ b/src/lib/hash/skein/skein_512.h
@@ -29,14 +29,14 @@ class BOTAN_DLL Skein_512 : public HashFunction
       Skein_512(size_t output_bits = 512,
                 const std::string& personalization = "");
 
-      size_t hash_block_size() const { return 64; }
-      size_t output_length() const { return output_bits / 8; }
+      size_t hash_block_size() const override { return 64; }
+      size_t output_length() const override { return output_bits / 8; }
 
       static Skein_512* make(const Spec& spec);
 
-      HashFunction* clone() const;
-      std::string name() const;
-      void clear();
+      HashFunction* clone() const override;
+      std::string name() const override;
+      void clear() override;
    private:
       enum type_code {
          SKEIN_KEY = 0,
@@ -49,8 +49,8 @@ class BOTAN_DLL Skein_512 : public HashFunction
          SKEIN_OUTPUT = 63
       };
 
-      void add_data(const byte input[], size_t length);
-      void final_result(byte out[]);
+      void add_data(const byte input[], size_t length) override;
+      void final_result(byte out[]) override;
 
       void ubi_512(const byte msg[], size_t msg_len);
 
diff --git a/src/lib/hash/tiger/tiger.h b/src/lib/hash/tiger/tiger.h
index df3b869fb..986186dda 100644
--- a/src/lib/hash/tiger/tiger.h
+++ b/src/lib/hash/tiger/tiger.h
@@ -18,15 +18,15 @@ namespace Botan {
 class BOTAN_DLL Tiger : public MDx_HashFunction
    {
    public:
-      std::string name() const;
-      size_t output_length() const { return hash_len; }
+      std::string name() const override;
+      size_t output_length() const override { return hash_len; }
 
-      HashFunction* clone() const
+      HashFunction* clone() const override
          {
          return new Tiger(output_length(), passes);
          }
 
-      void clear();
+      void clear() override;
 
       /**
       * @param out_size specifies the output length; can be 16, 20, or 24
@@ -34,8 +34,8 @@ class BOTAN_DLL Tiger : public MDx_HashFunction
       */
       Tiger(size_t out_size = 24, size_t passes = 3);
    private:
-      void compress_n(const byte[], size_t block);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t block) override;
+      void copy_out(byte[]) override;
 
       static void pass(u64bit& A, u64bit& B, u64bit& C,
                        const secure_vector<u64bit>& M,
diff --git a/src/lib/hash/whirlpool/whrlpool.h b/src/lib/hash/whirlpool/whrlpool.h
index 4f067f18d..ba91da080 100644
--- a/src/lib/hash/whirlpool/whrlpool.h
+++ b/src/lib/hash/whirlpool/whrlpool.h
@@ -18,17 +18,17 @@ namespace Botan {
 class BOTAN_DLL Whirlpool : public MDx_HashFunction
    {
    public:
-      std::string name() const { return "Whirlpool"; }
-      size_t output_length() const { return 64; }
-      HashFunction* clone() const { return new Whirlpool; }
+      std::string name() const override { return "Whirlpool"; }
+      size_t output_length() const override { return 64; }
+      HashFunction* clone() const override { return new Whirlpool; }
 
-      void clear();
+      void clear() override;
 
       Whirlpool() : MDx_HashFunction(64, true, true, 32), M(8), digest(8)
          { clear(); }
    private:
-      void compress_n(const byte[], size_t blocks);
-      void copy_out(byte[]);
+      void compress_n(const byte[], size_t blocks) override;
+      void copy_out(byte[]) override;
 
       static const u64bit C0[256];
       static const u64bit C1[256];