Move all modules into src/ directory

37 files changed, 3193 insertions, 0 deletions

diff --git a/src/hash/fork256/fork256.cpp b/src/hash/fork256/fork256.cpp
new file mode 100644
index 000000000..5ac779cab
--- /dev/null
+++ b/src/hash/fork256/fork256.cpp
@@ -0,0 +1,143 @@
+/*************************************************
+* FORK-256 Source File                           *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/fork256.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* FORK-256 Step Function                         *
+*************************************************/
+inline void step(u32bit& A, u32bit& B, u32bit& C, u32bit& D,
+                 u32bit& E, u32bit& F, u32bit& G, u32bit& H,
+                 u32bit M1, u32bit M2, u32bit D1, u32bit D2)
+   {
+   u32bit T0, T1;
+
+   A += M1; T0 = A + (rotate_left(A,  7) ^ rotate_left(A, 22));
+   A += D1; T1 = A ^ (rotate_left(A, 13) + rotate_left(A, 27));
+
+   B = (B + T0) ^ T1;
+   C = (C + rotate_left(T0,  5)) ^ rotate_left(T1,  9);
+   D = (D + rotate_left(T0, 17)) ^ rotate_left(T1, 21);
+
+   E += M2; T0 = E ^ (rotate_left(E, 13) + rotate_left(E, 27));
+   E += D2; T1 = E + (rotate_left(E,  7) ^ rotate_left(E, 22));
+
+   F = (F + T0) ^ T1;
+   G = (G + rotate_left(T0,  9)) ^ rotate_left(T1,  5);
+   H = (H + rotate_left(T0, 21)) ^ rotate_left(T1, 17);
+   }
+
+}
+
+/*************************************************
+* FORK-256 Compression Function                   *
+*************************************************/
+void FORK_256::hash(const byte input[])
+   {
+   const u32bit DELTA[16] = {
+      0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1,
+      0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3,
+      0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174
+   };
+
+   u32bit A1, B1, C1, D1, E1, F1, G1, H1;
+   u32bit A2, B2, C2, D2, E2, F2, G2, H2;
+   u32bit A3, B3, C3, D3, E3, F3, G3, H3;
+   u32bit A4, B4, C4, D4, E4, F4, G4, H4;
+
+   A1 = A2 = A3 = A4 = digest[0];
+   B1 = B2 = B3 = B4 = digest[1];
+   C1 = C2 = C3 = C4 = digest[2];
+   D1 = D2 = D3 = D4 = digest[3];
+   E1 = E2 = E3 = E4 = digest[4];
+   F1 = F2 = F3 = F4 = digest[5];
+   G1 = G2 = G3 = G4 = digest[6];
+   H1 = H2 = H3 = H4 = digest[7];
+
+   for(u32bit j = 0; j != 16; ++j)
+      M[j] = load_be<u32bit>(input, j);
+
+   step(A1, B1, C1, D1, E1, F1, G1, H1, M[ 0], M[ 1], DELTA[ 0], DELTA[ 1]);
+   step(A2, B2, C2, D2, E2, F2, G2, H2, M[14], M[15], DELTA[15], DELTA[14]);
+   step(A3, B3, C3, D3, E3, F3, G3, H3, M[ 7], M[ 6], DELTA[ 1], DELTA[ 0]);
+   step(A4, B4, C4, D4, E4, F4, G4, H4, M[ 5], M[12], DELTA[14], DELTA[15]);
+
+   step(H1, A1, B1, C1, D1, E1, F1, G1, M[ 2], M[ 3], DELTA[ 2], DELTA[ 3]);
+   step(H2, A2, B2, C2, D2, E2, F2, G2, M[11], M[ 9], DELTA[13], DELTA[12]);
+   step(H3, A3, B3, C3, D3, E3, F3, G3, M[10], M[14], DELTA[ 3], DELTA[ 2]);
+   step(H4, A4, B4, C4, D4, E4, F4, G4, M[ 1], M[ 8], DELTA[12], DELTA[13]);
+
+   step(G1, H1, A1, B1, C1, D1, E1, F1, M[ 4], M[ 5], DELTA[ 4], DELTA[ 5]);
+   step(G2, H2, A2, B2, C2, D2, E2, F2, M[ 8], M[10], DELTA[11], DELTA[10]);
+   step(G3, H3, A3, B3, C3, D3, E3, F3, M[13], M[ 2], DELTA[ 5], DELTA[ 4]);
+   step(G4, H4, A4, B4, C4, D4, E4, F4, M[15], M[ 0], DELTA[10], DELTA[11]);
+
+   step(F1, G1, H1, A1, B1, C1, D1, E1, M[ 6], M[ 7], DELTA[ 6], DELTA[ 7]);
+   step(F2, G2, H2, A2, B2, C2, D2, E2, M[ 3], M[ 4], DELTA[ 9], DELTA[ 8]);
+   step(F3, G3, H3, A3, B3, C3, D3, E3, M[ 9], M[12], DELTA[ 7], DELTA[ 6]);
+   step(F4, G4, H4, A4, B4, C4, D4, E4, M[13], M[11], DELTA[ 8], DELTA[ 9]);
+
+   step(E1, F1, G1, H1, A1, B1, C1, D1, M[ 8], M[ 9], DELTA[ 8], DELTA[ 9]);
+   step(E2, F2, G2, H2, A2, B2, C2, D2, M[ 2], M[13], DELTA[ 7], DELTA[ 6]);
+   step(E3, F3, G3, H3, A3, B3, C3, D3, M[11], M[ 4], DELTA[ 9], DELTA[ 8]);
+   step(E4, F4, G4, H4, A4, B4, C4, D4, M[ 3], M[10], DELTA[ 6], DELTA[ 7]);
+
+   step(D1, E1, F1, G1, H1, A1, B1, C1, M[10], M[11], DELTA[10], DELTA[11]);
+   step(D2, E2, F2, G2, H2, A2, B2, C2, M[ 0], M[ 5], DELTA[ 5], DELTA[ 4]);
+   step(D3, E3, F3, G3, H3, A3, B3, C3, M[15], M[ 8], DELTA[11], DELTA[10]);
+   step(D4, E4, F4, G4, H4, A4, B4, C4, M[ 9], M[ 2], DELTA[ 4], DELTA[ 5]);
+
+   step(C1, D1, E1, F1, G1, H1, A1, B1, M[12], M[13], DELTA[12], DELTA[13]);
+   step(C2, D2, E2, F2, G2, H2, A2, B2, M[ 6], M[ 7], DELTA[ 3], DELTA[ 2]);
+   step(C3, D3, E3, F3, G3, H3, A3, B3, M[ 5], M[ 0], DELTA[13], DELTA[12]);
+   step(C4, D4, E4, F4, G4, H4, A4, B4, M[ 7], M[14], DELTA[ 2], DELTA[ 3]);
+
+   step(B1, C1, D1, E1, F1, G1, H1, A1, M[14], M[15], DELTA[14], DELTA[15]);
+   step(B2, C2, D2, E2, F2, G2, H2, A2, M[12], M[ 1], DELTA[ 1], DELTA[ 0]);
+   step(B3, C3, D3, E3, F3, G3, H3, A3, M[ 1], M[ 3], DELTA[15], DELTA[14]);
+   step(B4, C4, D4, E4, F4, G4, H4, A4, M[ 4], M[ 6], DELTA[ 0], DELTA[ 1]);
+
+   digest[0] += (A1 + A2) ^ (A3 + A4);
+   digest[1] += (B1 + B2) ^ (B3 + B4);
+   digest[2] += (C1 + C2) ^ (C3 + C4);
+   digest[3] += (D1 + D2) ^ (D3 + D4);
+   digest[4] += (E1 + E2) ^ (E3 + E4);
+   digest[5] += (F1 + F2) ^ (F3 + F4);
+   digest[6] += (G1 + G2) ^ (G3 + G4);
+   digest[7] += (H1 + H2) ^ (H3 + H4);
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void FORK_256::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_be(digest[j/4], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void FORK_256::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   digest[0] = 0x6A09E667;
+   digest[1] = 0xBB67AE85;
+   digest[2] = 0x3C6EF372;
+   digest[3] = 0xA54FF53A;
+   digest[4] = 0x510E527F;
+   digest[5] = 0x9B05688C;
+   digest[6] = 0x1F83D9AB;
+   digest[7] = 0x5BE0CD19;
+   }
+
+}
diff --git a/src/hash/fork256/fork256.h b/src/hash/fork256/fork256.h
new file mode 100644
index 000000000..8ad9c1f8d
--- /dev/null
+++ b/src/hash/fork256/fork256.h
@@ -0,0 +1,33 @@
+/*************************************************
+* FORK-256 Header File                           *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_FORK_256_H__
+#define BOTAN_FORK_256_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* FORK-256                                       *
+*************************************************/
+class BOTAN_DLL FORK_256 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "FORK-256"; }
+      HashFunction* clone() const { return new FORK_256; }
+      FORK_256() : MDx_HashFunction(32, 64, true, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 8> digest;
+      SecureBuffer<u32bit, 16> M;
+   };
+
+}
+
+#endif
diff --git a/src/hash/fork256/modinfo.txt b/src/hash/fork256/modinfo.txt
new file mode 100644
index 000000000..677834b63
--- /dev/null
+++ b/src/hash/fork256/modinfo.txt
@@ -0,0 +1,10 @@
+realname "FORK-256"
+
+define FORK_256
+
+load_on auto
+
+<add>
+fork256.cpp
+fork256.h
+</add>
diff --git a/src/hash/has160/has160.cpp b/src/hash/has160/has160.cpp
new file mode 100644
index 000000000..422e4916a
--- /dev/null
+++ b/src/hash/has160/has160.cpp
@@ -0,0 +1,142 @@
+/*************************************************
+* HAS-160 Source File                            *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/has160.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* HAS-160 F1 Function                            *
+*************************************************/
+inline void F1(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
+               u32bit msg, u32bit rot)
+   {
+   E += rotate_left(A, rot) + (D ^ (B & (C ^ D))) + msg;
+   B  = rotate_left(B, 10);
+   }
+
+/*************************************************
+* HAS-160 F2 Function                            *
+*************************************************/
+inline void F2(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
+               u32bit msg, u32bit rot)
+   {
+   E += rotate_left(A, rot) + (B ^ C ^ D) + msg + 0x5A827999;
+   B  = rotate_left(B, 17);
+   }
+
+/*************************************************
+* HAS-160 F3 Function                            *
+*************************************************/
+inline void F3(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
+               u32bit msg, u32bit rot)
+   {
+   E += rotate_left(A, rot) + (C ^ (B | ~D)) + msg + 0x6ED9EBA1;
+   B  = rotate_left(B, 25);
+   }
+
+/*************************************************
+* HAS-160 F4 Function                            *
+*************************************************/
+inline void F4(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E,
+               u32bit msg, u32bit rot)
+   {
+   E += rotate_left(A, rot) + (B ^ C ^ D) + msg + 0x8F1BBCDC;
+   B  = rotate_left(B, 30);
+   }
+
+}
+
+/*************************************************
+* HAS-160 Compression Function                   *
+*************************************************/
+void HAS_160::hash(const byte input[])
+   {
+   for(u32bit j = 0; j != 16; ++j)
+      X[j] = load_le<u32bit>(input, j);
+
+   u32bit A = digest[0], B = digest[1], C = digest[2],
+          D = digest[3], E = digest[4];
+
+   X[16] = X[ 0] ^ X[ 1] ^ X[ 2] ^ X[ 3];
+   X[17] = X[ 4] ^ X[ 5] ^ X[ 6] ^ X[ 7];
+   X[18] = X[ 8] ^ X[ 9] ^ X[10] ^ X[11];
+   X[19] = X[12] ^ X[13] ^ X[14] ^ X[15];
+   F1(A,B,C,D,E,X[18], 5);   F1(E,A,B,C,D,X[ 0],11);   F1(D,E,A,B,C,X[ 1], 7);
+   F1(C,D,E,A,B,X[ 2],15);   F1(B,C,D,E,A,X[ 3], 6);   F1(A,B,C,D,E,X[19],13);
+   F1(E,A,B,C,D,X[ 4], 8);   F1(D,E,A,B,C,X[ 5],14);   F1(C,D,E,A,B,X[ 6], 7);
+   F1(B,C,D,E,A,X[ 7],12);   F1(A,B,C,D,E,X[16], 9);   F1(E,A,B,C,D,X[ 8],11);
+   F1(D,E,A,B,C,X[ 9], 8);   F1(C,D,E,A,B,X[10],15);   F1(B,C,D,E,A,X[11], 6);
+   F1(A,B,C,D,E,X[17],12);   F1(E,A,B,C,D,X[12], 9);   F1(D,E,A,B,C,X[13],14);
+   F1(C,D,E,A,B,X[14], 5);   F1(B,C,D,E,A,X[15],13);
+
+   X[16] = X[ 3] ^ X[ 6] ^ X[ 9] ^ X[12];
+   X[17] = X[ 2] ^ X[ 5] ^ X[ 8] ^ X[15];
+   X[18] = X[ 1] ^ X[ 4] ^ X[11] ^ X[14];
+   X[19] = X[ 0] ^ X[ 7] ^ X[10] ^ X[13];
+   F2(A,B,C,D,E,X[18], 5);   F2(E,A,B,C,D,X[ 3],11);   F2(D,E,A,B,C,X[ 6], 7);
+   F2(C,D,E,A,B,X[ 9],15);   F2(B,C,D,E,A,X[12], 6);   F2(A,B,C,D,E,X[19],13);
+   F2(E,A,B,C,D,X[15], 8);   F2(D,E,A,B,C,X[ 2],14);   F2(C,D,E,A,B,X[ 5], 7);
+   F2(B,C,D,E,A,X[ 8],12);   F2(A,B,C,D,E,X[16], 9);   F2(E,A,B,C,D,X[11],11);
+   F2(D,E,A,B,C,X[14], 8);   F2(C,D,E,A,B,X[ 1],15);   F2(B,C,D,E,A,X[ 4], 6);
+   F2(A,B,C,D,E,X[17],12);   F2(E,A,B,C,D,X[ 7], 9);   F2(D,E,A,B,C,X[10],14);
+   F2(C,D,E,A,B,X[13], 5);   F2(B,C,D,E,A,X[ 0],13);
+
+   X[16] = X[ 5] ^ X[ 7] ^ X[12] ^ X[14];
+   X[17] = X[ 0] ^ X[ 2] ^ X[ 9] ^ X[11];
+   X[18] = X[ 4] ^ X[ 6] ^ X[13] ^ X[15];
+   X[19] = X[ 1] ^ X[ 3] ^ X[ 8] ^ X[10];
+   F3(A,B,C,D,E,X[18], 5);   F3(E,A,B,C,D,X[12],11);   F3(D,E,A,B,C,X[ 5], 7);
+   F3(C,D,E,A,B,X[14],15);   F3(B,C,D,E,A,X[ 7], 6);   F3(A,B,C,D,E,X[19],13);
+   F3(E,A,B,C,D,X[ 0], 8);   F3(D,E,A,B,C,X[ 9],14);   F3(C,D,E,A,B,X[ 2], 7);
+   F3(B,C,D,E,A,X[11],12);   F3(A,B,C,D,E,X[16], 9);   F3(E,A,B,C,D,X[ 4],11);
+   F3(D,E,A,B,C,X[13], 8);   F3(C,D,E,A,B,X[ 6],15);   F3(B,C,D,E,A,X[15], 6);
+   F3(A,B,C,D,E,X[17],12);   F3(E,A,B,C,D,X[ 8], 9);   F3(D,E,A,B,C,X[ 1],14);
+   F3(C,D,E,A,B,X[10], 5);   F3(B,C,D,E,A,X[ 3],13);
+
+   X[16] = X[ 2] ^ X[ 7] ^ X[ 8] ^ X[13];
+   X[17] = X[ 3] ^ X[ 4] ^ X[ 9] ^ X[14];
+   X[18] = X[ 0] ^ X[ 5] ^ X[10] ^ X[15];
+   X[19] = X[ 1] ^ X[ 6] ^ X[11] ^ X[12];
+   F4(A,B,C,D,E,X[18], 5);   F4(E,A,B,C,D,X[ 7],11);   F4(D,E,A,B,C,X[ 2], 7);
+   F4(C,D,E,A,B,X[13],15);   F4(B,C,D,E,A,X[ 8], 6);   F4(A,B,C,D,E,X[19],13);
+   F4(E,A,B,C,D,X[ 3], 8);   F4(D,E,A,B,C,X[14],14);   F4(C,D,E,A,B,X[ 9], 7);
+   F4(B,C,D,E,A,X[ 4],12);   F4(A,B,C,D,E,X[16], 9);   F4(E,A,B,C,D,X[15],11);
+   F4(D,E,A,B,C,X[10], 8);   F4(C,D,E,A,B,X[ 5],15);   F4(B,C,D,E,A,X[ 0], 6);
+   F4(A,B,C,D,E,X[17],12);   F4(E,A,B,C,D,X[11], 9);   F4(D,E,A,B,C,X[ 6],14);
+   F4(C,D,E,A,B,X[ 1], 5);   F4(B,C,D,E,A,X[12],13);
+
+   digest[0] += A; digest[1] += B; digest[2] += C;
+   digest[3] += D; digest[4] += E;
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void HAS_160::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_le(digest[j/4], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void HAS_160::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   X.clear();
+   digest[0] = 0x67452301;
+   digest[1] = 0xEFCDAB89;
+   digest[2] = 0x98BADCFE;
+   digest[3] = 0x10325476;
+   digest[4] = 0xC3D2E1F0;
+   }
+
+}
diff --git a/src/hash/has160/has160.h b/src/hash/has160/has160.h
new file mode 100644
index 000000000..9e35bfdca
--- /dev/null
+++ b/src/hash/has160/has160.h
@@ -0,0 +1,33 @@
+/*************************************************
+* HAS-160 Header File                            *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_HAS_160_H__
+#define BOTAN_HAS_160_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* HAS-160                                        *
+*************************************************/
+class BOTAN_DLL HAS_160 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "HAS-160"; }
+      HashFunction* clone() const { return new HAS_160; }
+      HAS_160() : MDx_HashFunction(20, 64, false, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 20> X;
+      SecureBuffer<u32bit, 5> digest;
+   };
+
+}
+
+#endif
diff --git a/src/hash/has160/modinfo.txt b/src/hash/has160/modinfo.txt
new file mode 100644
index 000000000..7574ba293
--- /dev/null
+++ b/src/hash/has160/modinfo.txt
@@ -0,0 +1,10 @@
+realname "HAS-160"
+
+define HAS_160
+
+load_on auto
+
+<add>
+has160.cpp
+has160.h
+</add>
diff --git a/src/hash/md2/md2.cpp b/src/hash/md2/md2.cpp
new file mode 100644
index 000000000..c609eda10
--- /dev/null
+++ b/src/hash/md2/md2.cpp
@@ -0,0 +1,106 @@
+/*************************************************
+* MD2 Source File                                *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/md2.h>
+#include <botan/xor_buf.h>
+
+namespace Botan {
+
+/*************************************************
+* MD2 Compression Function                       *
+*************************************************/
+void MD2::hash(const byte input[])
+   {
+   static const byte SBOX[256] = {
+      0x29, 0x2E, 0x43, 0xC9, 0xA2, 0xD8, 0x7C, 0x01, 0x3D, 0x36, 0x54, 0xA1,
+      0xEC, 0xF0, 0x06, 0x13, 0x62, 0xA7, 0x05, 0xF3, 0xC0, 0xC7, 0x73, 0x8C,
+      0x98, 0x93, 0x2B, 0xD9, 0xBC, 0x4C, 0x82, 0xCA, 0x1E, 0x9B, 0x57, 0x3C,
+      0xFD, 0xD4, 0xE0, 0x16, 0x67, 0x42, 0x6F, 0x18, 0x8A, 0x17, 0xE5, 0x12,
+      0xBE, 0x4E, 0xC4, 0xD6, 0xDA, 0x9E, 0xDE, 0x49, 0xA0, 0xFB, 0xF5, 0x8E,
+      0xBB, 0x2F, 0xEE, 0x7A, 0xA9, 0x68, 0x79, 0x91, 0x15, 0xB2, 0x07, 0x3F,
+      0x94, 0xC2, 0x10, 0x89, 0x0B, 0x22, 0x5F, 0x21, 0x80, 0x7F, 0x5D, 0x9A,
+      0x5A, 0x90, 0x32, 0x27, 0x35, 0x3E, 0xCC, 0xE7, 0xBF, 0xF7, 0x97, 0x03,
+      0xFF, 0x19, 0x30, 0xB3, 0x48, 0xA5, 0xB5, 0xD1, 0xD7, 0x5E, 0x92, 0x2A,
+      0xAC, 0x56, 0xAA, 0xC6, 0x4F, 0xB8, 0x38, 0xD2, 0x96, 0xA4, 0x7D, 0xB6,
+      0x76, 0xFC, 0x6B, 0xE2, 0x9C, 0x74, 0x04, 0xF1, 0x45, 0x9D, 0x70, 0x59,
+      0x64, 0x71, 0x87, 0x20, 0x86, 0x5B, 0xCF, 0x65, 0xE6, 0x2D, 0xA8, 0x02,
+      0x1B, 0x60, 0x25, 0xAD, 0xAE, 0xB0, 0xB9, 0xF6, 0x1C, 0x46, 0x61, 0x69,
+      0x34, 0x40, 0x7E, 0x0F, 0x55, 0x47, 0xA3, 0x23, 0xDD, 0x51, 0xAF, 0x3A,
+      0xC3, 0x5C, 0xF9, 0xCE, 0xBA, 0xC5, 0xEA, 0x26, 0x2C, 0x53, 0x0D, 0x6E,
+      0x85, 0x28, 0x84, 0x09, 0xD3, 0xDF, 0xCD, 0xF4, 0x41, 0x81, 0x4D, 0x52,
+      0x6A, 0xDC, 0x37, 0xC8, 0x6C, 0xC1, 0xAB, 0xFA, 0x24, 0xE1, 0x7B, 0x08,
+      0x0C, 0xBD, 0xB1, 0x4A, 0x78, 0x88, 0x95, 0x8B, 0xE3, 0x63, 0xE8, 0x6D,
+      0xE9, 0xCB, 0xD5, 0xFE, 0x3B, 0x00, 0x1D, 0x39, 0xF2, 0xEF, 0xB7, 0x0E,
+      0x66, 0x58, 0xD0, 0xE4, 0xA6, 0x77, 0x72, 0xF8, 0xEB, 0x75, 0x4B, 0x0A,
+      0x31, 0x44, 0x50, 0xB4, 0x8F, 0xED, 0x1F, 0x1A, 0xDB, 0x99, 0x8D, 0x33,
+      0x9F, 0x11, 0x83, 0x14 };
+
+   X.copy(16, input, HASH_BLOCK_SIZE);
+   xor_buf(X + 32, X, X + 16, HASH_BLOCK_SIZE);
+   byte T = 0;
+   for(u32bit j = 0; j != 18; ++j)
+      {
+      for(u32bit k = 0; k != 48; k += 8)
+         {
+         T = X[k  ] ^= SBOX[T]; T = X[k+1] ^= SBOX[T];
+         T = X[k+2] ^= SBOX[T]; T = X[k+3] ^= SBOX[T];
+         T = X[k+4] ^= SBOX[T]; T = X[k+5] ^= SBOX[T];
+         T = X[k+6] ^= SBOX[T]; T = X[k+7] ^= SBOX[T];
+         }
+      T += j;
+      }
+   T = checksum[15];
+   for(u32bit j = 0; j != HASH_BLOCK_SIZE; ++j)
+      T = checksum[j] ^= SBOX[input[j] ^ T];
+   }
+
+/*************************************************
+* Update the hash                                *
+*************************************************/
+void MD2::add_data(const byte input[], u32bit length)
+   {
+   buffer.copy(position, input, length);
+   if(position + length >= HASH_BLOCK_SIZE)
+      {
+      hash(buffer.begin());
+      input += (HASH_BLOCK_SIZE - position);
+      length -= (HASH_BLOCK_SIZE - position);
+      while(length >= HASH_BLOCK_SIZE)
+         {
+         hash(input);
+         input += HASH_BLOCK_SIZE;
+         length -= HASH_BLOCK_SIZE;
+         }
+      buffer.copy(input, length);
+      position = 0;
+      }
+   position += length;
+   }
+
+/*************************************************
+* Finalize a MD2 Hash                            *
+*************************************************/
+void MD2::final_result(byte output[])
+   {
+   for(u32bit j = position; j != HASH_BLOCK_SIZE; ++j)
+      buffer[j] = static_cast<byte>(HASH_BLOCK_SIZE - position);
+   hash(buffer);
+   hash(checksum);
+   copy_mem(output, X.begin(), OUTPUT_LENGTH);
+   clear();
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void MD2::clear() throw()
+   {
+   X.clear();
+   checksum.clear();
+   buffer.clear();
+   position = 0;
+   }
+
+}
diff --git a/src/hash/md2/md2.h b/src/hash/md2/md2.h
new file mode 100644
index 000000000..2c53d1cf0
--- /dev/null
+++ b/src/hash/md2/md2.h
@@ -0,0 +1,35 @@
+/*************************************************
+* MD2 Header File                                *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_MD2_H__
+#define BOTAN_MD2_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* MD2                                            *
+*************************************************/
+class BOTAN_DLL MD2 : public HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "MD2"; }
+      HashFunction* clone() const { return new MD2; }
+      MD2() : HashFunction(16, 16) { clear(); }
+   private:
+      void add_data(const byte[], u32bit);
+      void hash(const byte[]);
+      void final_result(byte[]);
+
+      SecureBuffer<byte, 48> X;
+      SecureBuffer<byte, 16> checksum, buffer;
+      u32bit position;
+   };
+
+}
+
+#endif
diff --git a/src/hash/md2/modinfo.txt b/src/hash/md2/modinfo.txt
new file mode 100644
index 000000000..ff33e1eb3
--- /dev/null
+++ b/src/hash/md2/modinfo.txt
@@ -0,0 +1,10 @@
+realname "MD2"
+
+define MD2
+
+load_on auto
+
+<add>
+md2.cpp
+md2.h
+</add>
diff --git a/src/hash/md4/md4.cpp b/src/hash/md4/md4.cpp
new file mode 100644
index 000000000..e2a18f424
--- /dev/null
+++ b/src/hash/md4/md4.cpp
@@ -0,0 +1,99 @@
+/*************************************************
+* MD4 Source File                                *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/md4.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* MD4 FF Function                                *
+*************************************************/
+inline void FF(u32bit& A, u32bit B, u32bit C, u32bit D, u32bit M, byte S)
+   {
+   A += (D ^ (B & (C ^ D))) + M;
+   A  = rotate_left(A, S);
+   }
+
+/*************************************************
+* MD4 GG Function                                *
+*************************************************/
+inline void GG(u32bit& A, u32bit B, u32bit C, u32bit D, u32bit M, byte S)
+   {
+   A += ((B & C) | (D & (B | C))) + M + 0x5A827999;
+   A  = rotate_left(A, S);
+   }
+
+/*************************************************
+* MD4 HH Function                                *
+*************************************************/
+inline void HH(u32bit& A, u32bit B, u32bit C, u32bit D, u32bit M, byte S)
+   {
+   A += (B ^ C ^ D) + M + 0x6ED9EBA1;
+   A  = rotate_left(A, S);
+   }
+
+}
+
+/*************************************************
+* MD4 Compression Function                       *
+*************************************************/
+void MD4::hash(const byte input[])
+   {
+   for(u32bit j = 0; j != 16; ++j)
+      M[j] = load_le<u32bit>(input, j);
+
+   u32bit A = digest[0], B = digest[1], C = digest[2], D = digest[3];
+
+   FF(A,B,C,D,M[ 0], 3);   FF(D,A,B,C,M[ 1], 7);   FF(C,D,A,B,M[ 2],11);
+   FF(B,C,D,A,M[ 3],19);   FF(A,B,C,D,M[ 4], 3);   FF(D,A,B,C,M[ 5], 7);
+   FF(C,D,A,B,M[ 6],11);   FF(B,C,D,A,M[ 7],19);   FF(A,B,C,D,M[ 8], 3);
+   FF(D,A,B,C,M[ 9], 7);   FF(C,D,A,B,M[10],11);   FF(B,C,D,A,M[11],19);
+   FF(A,B,C,D,M[12], 3);   FF(D,A,B,C,M[13], 7);   FF(C,D,A,B,M[14],11);
+   FF(B,C,D,A,M[15],19);
+
+   GG(A,B,C,D,M[ 0], 3);   GG(D,A,B,C,M[ 4], 5);   GG(C,D,A,B,M[ 8], 9);
+   GG(B,C,D,A,M[12],13);   GG(A,B,C,D,M[ 1], 3);   GG(D,A,B,C,M[ 5], 5);
+   GG(C,D,A,B,M[ 9], 9);   GG(B,C,D,A,M[13],13);   GG(A,B,C,D,M[ 2], 3);
+   GG(D,A,B,C,M[ 6], 5);   GG(C,D,A,B,M[10], 9);   GG(B,C,D,A,M[14],13);
+   GG(A,B,C,D,M[ 3], 3);   GG(D,A,B,C,M[ 7], 5);   GG(C,D,A,B,M[11], 9);
+   GG(B,C,D,A,M[15],13);
+
+   HH(A,B,C,D,M[ 0], 3);   HH(D,A,B,C,M[ 8], 9);   HH(C,D,A,B,M[ 4],11);
+   HH(B,C,D,A,M[12],15);   HH(A,B,C,D,M[ 2], 3);   HH(D,A,B,C,M[10], 9);
+   HH(C,D,A,B,M[ 6],11);   HH(B,C,D,A,M[14],15);   HH(A,B,C,D,M[ 1], 3);
+   HH(D,A,B,C,M[ 9], 9);   HH(C,D,A,B,M[ 5],11);   HH(B,C,D,A,M[13],15);
+   HH(A,B,C,D,M[ 3], 3);   HH(D,A,B,C,M[11], 9);   HH(C,D,A,B,M[ 7],11);
+   HH(B,C,D,A,M[15],15);
+
+   digest[0] += A;   digest[1] += B;   digest[2] += C;   digest[3] += D;
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void MD4::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_le(digest[j/4], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void MD4::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   M.clear();
+   digest[0] = 0x67452301;
+   digest[1] = 0xEFCDAB89;
+   digest[2] = 0x98BADCFE;
+   digest[3] = 0x10325476;
+   }
+
+}
diff --git a/src/hash/md4/md4.h b/src/hash/md4/md4.h
new file mode 100644
index 000000000..4bb5e3903
--- /dev/null
+++ b/src/hash/md4/md4.h
@@ -0,0 +1,33 @@
+/*************************************************
+* MD4 Header File                                *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_MD4_H__
+#define BOTAN_MD4_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* MD4                                            *
+*************************************************/
+class BOTAN_DLL MD4 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "MD4"; }
+      HashFunction* clone() const { return new MD4; }
+      MD4() : MDx_HashFunction(16, 64, false, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 48> M;
+      SecureBuffer<u32bit, 4> digest;
+   };
+
+}
+
+#endif
diff --git a/src/hash/md4/modinfo.txt b/src/hash/md4/modinfo.txt
new file mode 100644
index 000000000..6d32dbd90
--- /dev/null
+++ b/src/hash/md4/modinfo.txt
@@ -0,0 +1,10 @@
+realname "MD4"
+
+define MD4
+
+load_on auto
+
+<add>
+md4.cpp
+md4.h
+</add>
diff --git a/src/hash/md5/md5.cpp b/src/hash/md5/md5.cpp
new file mode 100644
index 000000000..2fd75f0fb
--- /dev/null
+++ b/src/hash/md5/md5.cpp
@@ -0,0 +1,127 @@
+/*************************************************
+* MD5 Source File                                *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/md5.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* MD5 FF Function                                *
+*************************************************/
+inline void FF(u32bit& A, u32bit B, u32bit C, u32bit D, u32bit msg,
+               byte S, u32bit magic)
+   {
+   A += (D ^ (B & (C ^ D))) + msg + magic;
+   A  = rotate_left(A, S) + B;
+   }
+
+/*************************************************
+* MD5 GG Function                                *
+*************************************************/
+inline void GG(u32bit& A, u32bit B, u32bit C, u32bit D, u32bit msg,
+               byte S, u32bit magic)
+   {
+   A += (C ^ (D & (B ^ C))) + msg + magic;
+   A  = rotate_left(A, S) + B;
+   }
+
+/*************************************************
+* MD5 HH Function                                *
+*************************************************/
+inline void HH(u32bit& A, u32bit B, u32bit C, u32bit D, u32bit msg,
+               byte S, u32bit magic)
+   {
+   A += (B ^ C ^ D) + msg + magic;
+   A  = rotate_left(A, S) + B;
+   }
+
+/*************************************************
+* MD5 II Function                                *
+*************************************************/
+inline void II(u32bit& A, u32bit B, u32bit C, u32bit D, u32bit msg,
+               byte S, u32bit magic)
+   {
+   A += (C ^ (B | ~D)) + msg + magic;
+   A  = rotate_left(A, S) + B;
+   }
+
+}
+
+/*************************************************
+* MD5 Compression Function                       *
+*************************************************/
+void MD5::hash(const byte input[])
+   {
+   for(u32bit j = 0; j != 16; ++j)
+      M[j] = load_le<u32bit>(input, j);
+
+   u32bit A = digest[0], B = digest[1], C = digest[2], D = digest[3];
+
+   FF(A,B,C,D,M[ 0], 7,0xD76AA478);   FF(D,A,B,C,M[ 1],12,0xE8C7B756);
+   FF(C,D,A,B,M[ 2],17,0x242070DB);   FF(B,C,D,A,M[ 3],22,0xC1BDCEEE);
+   FF(A,B,C,D,M[ 4], 7,0xF57C0FAF);   FF(D,A,B,C,M[ 5],12,0x4787C62A);
+   FF(C,D,A,B,M[ 6],17,0xA8304613);   FF(B,C,D,A,M[ 7],22,0xFD469501);
+   FF(A,B,C,D,M[ 8], 7,0x698098D8);   FF(D,A,B,C,M[ 9],12,0x8B44F7AF);
+   FF(C,D,A,B,M[10],17,0xFFFF5BB1);   FF(B,C,D,A,M[11],22,0x895CD7BE);
+   FF(A,B,C,D,M[12], 7,0x6B901122);   FF(D,A,B,C,M[13],12,0xFD987193);
+   FF(C,D,A,B,M[14],17,0xA679438E);   FF(B,C,D,A,M[15],22,0x49B40821);
+
+   GG(A,B,C,D,M[ 1], 5,0xF61E2562);   GG(D,A,B,C,M[ 6], 9,0xC040B340);
+   GG(C,D,A,B,M[11],14,0x265E5A51);   GG(B,C,D,A,M[ 0],20,0xE9B6C7AA);
+   GG(A,B,C,D,M[ 5], 5,0xD62F105D);   GG(D,A,B,C,M[10], 9,0x02441453);
+   GG(C,D,A,B,M[15],14,0xD8A1E681);   GG(B,C,D,A,M[ 4],20,0xE7D3FBC8);
+   GG(A,B,C,D,M[ 9], 5,0x21E1CDE6);   GG(D,A,B,C,M[14], 9,0xC33707D6);
+   GG(C,D,A,B,M[ 3],14,0xF4D50D87);   GG(B,C,D,A,M[ 8],20,0x455A14ED);
+   GG(A,B,C,D,M[13], 5,0xA9E3E905);   GG(D,A,B,C,M[ 2], 9,0xFCEFA3F8);
+   GG(C,D,A,B,M[ 7],14,0x676F02D9);   GG(B,C,D,A,M[12],20,0x8D2A4C8A);
+
+   HH(A,B,C,D,M[ 5], 4,0xFFFA3942);   HH(D,A,B,C,M[ 8],11,0x8771F681);
+   HH(C,D,A,B,M[11],16,0x6D9D6122);   HH(B,C,D,A,M[14],23,0xFDE5380C);
+   HH(A,B,C,D,M[ 1], 4,0xA4BEEA44);   HH(D,A,B,C,M[ 4],11,0x4BDECFA9);
+   HH(C,D,A,B,M[ 7],16,0xF6BB4B60);   HH(B,C,D,A,M[10],23,0xBEBFBC70);
+   HH(A,B,C,D,M[13], 4,0x289B7EC6);   HH(D,A,B,C,M[ 0],11,0xEAA127FA);
+   HH(C,D,A,B,M[ 3],16,0xD4EF3085);   HH(B,C,D,A,M[ 6],23,0x04881D05);
+   HH(A,B,C,D,M[ 9], 4,0xD9D4D039);   HH(D,A,B,C,M[12],11,0xE6DB99E5);
+   HH(C,D,A,B,M[15],16,0x1FA27CF8);   HH(B,C,D,A,M[ 2],23,0xC4AC5665);
+
+   II(A,B,C,D,M[ 0], 6,0xF4292244);   II(D,A,B,C,M[ 7],10,0x432AFF97);
+   II(C,D,A,B,M[14],15,0xAB9423A7);   II(B,C,D,A,M[ 5],21,0xFC93A039);
+   II(A,B,C,D,M[12], 6,0x655B59C3);   II(D,A,B,C,M[ 3],10,0x8F0CCC92);
+   II(C,D,A,B,M[10],15,0xFFEFF47D);   II(B,C,D,A,M[ 1],21,0x85845DD1);
+   II(A,B,C,D,M[ 8], 6,0x6FA87E4F);   II(D,A,B,C,M[15],10,0xFE2CE6E0);
+   II(C,D,A,B,M[ 6],15,0xA3014314);   II(B,C,D,A,M[13],21,0x4E0811A1);
+   II(A,B,C,D,M[ 4], 6,0xF7537E82);   II(D,A,B,C,M[11],10,0xBD3AF235);
+   II(C,D,A,B,M[ 2],15,0x2AD7D2BB);   II(B,C,D,A,M[ 9],21,0xEB86D391);
+
+   digest[0] += A; digest[1] += B; digest[2] += C; digest[3] += D;
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void MD5::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_le(digest[j/4], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void MD5::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   M.clear();
+   digest[0] = 0x67452301;
+   digest[1] = 0xEFCDAB89;
+   digest[2] = 0x98BADCFE;
+   digest[3] = 0x10325476;
+   }
+
+}
diff --git a/src/hash/md5/md5.h b/src/hash/md5/md5.h
new file mode 100644
index 000000000..9634c526d
--- /dev/null
+++ b/src/hash/md5/md5.h
@@ -0,0 +1,33 @@
+/*************************************************
+* MD5 Header File                                *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_MD5_H__
+#define BOTAN_MD5_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* MD5                                            *
+*************************************************/
+class BOTAN_DLL MD5 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "MD5"; }
+      HashFunction* clone() const { return new MD5; }
+      MD5() : MDx_HashFunction(16, 64, false, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 16> M;
+      SecureBuffer<u32bit, 4> digest;
+   };
+
+}
+
+#endif
diff --git a/src/hash/md5/modinfo.txt b/src/hash/md5/modinfo.txt
new file mode 100644
index 000000000..fb17add4a
--- /dev/null
+++ b/src/hash/md5/modinfo.txt
@@ -0,0 +1,10 @@
+realname "MD5"
+
+define MD5
+
+load_on auto
+
+<add>
+md5.cpp
+md5.h
+</add>
diff --git a/src/hash/rmd128/modinfo.txt b/src/hash/rmd128/modinfo.txt
new file mode 100644
index 000000000..9be80268b
--- /dev/null
+++ b/src/hash/rmd128/modinfo.txt
@@ -0,0 +1,10 @@
+realname "RIPEMD-128"
+
+define RIPEMD_128
+
+load_on auto
+
+<add>
+rmd128.cpp
+rmd128.h
+</add>
diff --git a/src/hash/rmd128/rmd128.cpp b/src/hash/rmd128/rmd128.cpp
new file mode 100644
index 000000000..4c33350b6
--- /dev/null
+++ b/src/hash/rmd128/rmd128.cpp
@@ -0,0 +1,166 @@
+/*************************************************
+* RIPEMD-128 Source File                         *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/rmd128.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* RIPEMD-128 F1 Function                         *
+*************************************************/
+inline void F1(u32bit& A, u32bit B, u32bit C, u32bit D,
+               u32bit msg, u32bit shift)
+   {
+   A += (B ^ C ^ D) + msg;
+   A  = rotate_left(A, shift);
+   }
+
+/*************************************************
+* RIPEMD-128 F2 Function                         *
+*************************************************/
+inline void F2(u32bit& A, u32bit B, u32bit C, u32bit D,
+               u32bit msg, u32bit shift, u32bit magic)
+   {
+   A += (D ^ (B & (C ^ D))) + msg + magic;
+   A  = rotate_left(A, shift);
+   }
+
+/*************************************************
+* RIPEMD-128 F3 Function                         *
+*************************************************/
+inline void F3(u32bit& A, u32bit B, u32bit C, u32bit D,
+               u32bit msg, u32bit shift, u32bit magic)
+   {
+   A += (D ^ (B | ~C)) + msg + magic;
+   A  = rotate_left(A, shift);
+   }
+
+/*************************************************
+* RIPEMD-128 F4 Function                         *
+*************************************************/
+inline void F4(u32bit& A, u32bit B, u32bit C, u32bit D,
+               u32bit msg, u32bit shift, u32bit magic)
+   {
+   A += (C ^ (D & (B ^ C))) + msg + magic;
+   A  = rotate_left(A, shift);
+   }
+
+}
+
+/*************************************************
+* RIPEMD-128 Compression Function                *
+*************************************************/
+void RIPEMD_128::hash(const byte input[])
+   {
+   for(u32bit j = 0; j != 16; ++j)
+      M[j] = load_le<u32bit>(input, j);
+
+   u32bit A1 = digest[0], A2 = A1, B1 = digest[1], B2 = B1,
+          C1 = digest[2], C2 = C1, D1 = digest[3], D2 = D1;
+
+   const u32bit MAGIC2 = 0x5A827999, MAGIC3 = 0x6ED9EBA1,
+                MAGIC4 = 0x8F1BBCDC, MAGIC5 = 0x50A28BE6,
+                MAGIC6 = 0x5C4DD124, MAGIC7 = 0x6D703EF3;
+
+   F1(A1,B1,C1,D1,M[ 0],11       );   F4(A2,B2,C2,D2,M[ 5], 8,MAGIC5);
+   F1(D1,A1,B1,C1,M[ 1],14       );   F4(D2,A2,B2,C2,M[14], 9,MAGIC5);
+   F1(C1,D1,A1,B1,M[ 2],15       );   F4(C2,D2,A2,B2,M[ 7], 9,MAGIC5);
+   F1(B1,C1,D1,A1,M[ 3],12       );   F4(B2,C2,D2,A2,M[ 0],11,MAGIC5);
+   F1(A1,B1,C1,D1,M[ 4], 5       );   F4(A2,B2,C2,D2,M[ 9],13,MAGIC5);
+   F1(D1,A1,B1,C1,M[ 5], 8       );   F4(D2,A2,B2,C2,M[ 2],15,MAGIC5);
+   F1(C1,D1,A1,B1,M[ 6], 7       );   F4(C2,D2,A2,B2,M[11],15,MAGIC5);
+   F1(B1,C1,D1,A1,M[ 7], 9       );   F4(B2,C2,D2,A2,M[ 4], 5,MAGIC5);
+   F1(A1,B1,C1,D1,M[ 8],11       );   F4(A2,B2,C2,D2,M[13], 7,MAGIC5);
+   F1(D1,A1,B1,C1,M[ 9],13       );   F4(D2,A2,B2,C2,M[ 6], 7,MAGIC5);
+   F1(C1,D1,A1,B1,M[10],14       );   F4(C2,D2,A2,B2,M[15], 8,MAGIC5);
+   F1(B1,C1,D1,A1,M[11],15       );   F4(B2,C2,D2,A2,M[ 8],11,MAGIC5);
+   F1(A1,B1,C1,D1,M[12], 6       );   F4(A2,B2,C2,D2,M[ 1],14,MAGIC5);
+   F1(D1,A1,B1,C1,M[13], 7       );   F4(D2,A2,B2,C2,M[10],14,MAGIC5);
+   F1(C1,D1,A1,B1,M[14], 9       );   F4(C2,D2,A2,B2,M[ 3],12,MAGIC5);
+   F1(B1,C1,D1,A1,M[15], 8       );   F4(B2,C2,D2,A2,M[12], 6,MAGIC5);
+
+   F2(A1,B1,C1,D1,M[ 7], 7,MAGIC2);   F3(A2,B2,C2,D2,M[ 6], 9,MAGIC6);
+   F2(D1,A1,B1,C1,M[ 4], 6,MAGIC2);   F3(D2,A2,B2,C2,M[11],13,MAGIC6);
+   F2(C1,D1,A1,B1,M[13], 8,MAGIC2);   F3(C2,D2,A2,B2,M[ 3],15,MAGIC6);
+   F2(B1,C1,D1,A1,M[ 1],13,MAGIC2);   F3(B2,C2,D2,A2,M[ 7], 7,MAGIC6);
+   F2(A1,B1,C1,D1,M[10],11,MAGIC2);   F3(A2,B2,C2,D2,M[ 0],12,MAGIC6);
+   F2(D1,A1,B1,C1,M[ 6], 9,MAGIC2);   F3(D2,A2,B2,C2,M[13], 8,MAGIC6);
+   F2(C1,D1,A1,B1,M[15], 7,MAGIC2);   F3(C2,D2,A2,B2,M[ 5], 9,MAGIC6);
+   F2(B1,C1,D1,A1,M[ 3],15,MAGIC2);   F3(B2,C2,D2,A2,M[10],11,MAGIC6);
+   F2(A1,B1,C1,D1,M[12], 7,MAGIC2);   F3(A2,B2,C2,D2,M[14], 7,MAGIC6);
+   F2(D1,A1,B1,C1,M[ 0],12,MAGIC2);   F3(D2,A2,B2,C2,M[15], 7,MAGIC6);
+   F2(C1,D1,A1,B1,M[ 9],15,MAGIC2);   F3(C2,D2,A2,B2,M[ 8],12,MAGIC6);
+   F2(B1,C1,D1,A1,M[ 5], 9,MAGIC2);   F3(B2,C2,D2,A2,M[12], 7,MAGIC6);
+   F2(A1,B1,C1,D1,M[ 2],11,MAGIC2);   F3(A2,B2,C2,D2,M[ 4], 6,MAGIC6);
+   F2(D1,A1,B1,C1,M[14], 7,MAGIC2);   F3(D2,A2,B2,C2,M[ 9],15,MAGIC6);
+   F2(C1,D1,A1,B1,M[11],13,MAGIC2);   F3(C2,D2,A2,B2,M[ 1],13,MAGIC6);
+   F2(B1,C1,D1,A1,M[ 8],12,MAGIC2);   F3(B2,C2,D2,A2,M[ 2],11,MAGIC6);
+
+   F3(A1,B1,C1,D1,M[ 3],11,MAGIC3);   F2(A2,B2,C2,D2,M[15], 9,MAGIC7);
+   F3(D1,A1,B1,C1,M[10],13,MAGIC3);   F2(D2,A2,B2,C2,M[ 5], 7,MAGIC7);
+   F3(C1,D1,A1,B1,M[14], 6,MAGIC3);   F2(C2,D2,A2,B2,M[ 1],15,MAGIC7);
+   F3(B1,C1,D1,A1,M[ 4], 7,MAGIC3);   F2(B2,C2,D2,A2,M[ 3],11,MAGIC7);
+   F3(A1,B1,C1,D1,M[ 9],14,MAGIC3);   F2(A2,B2,C2,D2,M[ 7], 8,MAGIC7);
+   F3(D1,A1,B1,C1,M[15], 9,MAGIC3);   F2(D2,A2,B2,C2,M[14], 6,MAGIC7);
+   F3(C1,D1,A1,B1,M[ 8],13,MAGIC3);   F2(C2,D2,A2,B2,M[ 6], 6,MAGIC7);
+   F3(B1,C1,D1,A1,M[ 1],15,MAGIC3);   F2(B2,C2,D2,A2,M[ 9],14,MAGIC7);
+   F3(A1,B1,C1,D1,M[ 2],14,MAGIC3);   F2(A2,B2,C2,D2,M[11],12,MAGIC7);
+   F3(D1,A1,B1,C1,M[ 7], 8,MAGIC3);   F2(D2,A2,B2,C2,M[ 8],13,MAGIC7);
+   F3(C1,D1,A1,B1,M[ 0],13,MAGIC3);   F2(C2,D2,A2,B2,M[12], 5,MAGIC7);
+   F3(B1,C1,D1,A1,M[ 6], 6,MAGIC3);   F2(B2,C2,D2,A2,M[ 2],14,MAGIC7);
+   F3(A1,B1,C1,D1,M[13], 5,MAGIC3);   F2(A2,B2,C2,D2,M[10],13,MAGIC7);
+   F3(D1,A1,B1,C1,M[11],12,MAGIC3);   F2(D2,A2,B2,C2,M[ 0],13,MAGIC7);
+   F3(C1,D1,A1,B1,M[ 5], 7,MAGIC3);   F2(C2,D2,A2,B2,M[ 4], 7,MAGIC7);
+   F3(B1,C1,D1,A1,M[12], 5,MAGIC3);   F2(B2,C2,D2,A2,M[13], 5,MAGIC7);
+
+   F4(A1,B1,C1,D1,M[ 1],11,MAGIC4);   F1(A2,B2,C2,D2,M[ 8],15       );
+   F4(D1,A1,B1,C1,M[ 9],12,MAGIC4);   F1(D2,A2,B2,C2,M[ 6], 5       );
+   F4(C1,D1,A1,B1,M[11],14,MAGIC4);   F1(C2,D2,A2,B2,M[ 4], 8       );
+   F4(B1,C1,D1,A1,M[10],15,MAGIC4);   F1(B2,C2,D2,A2,M[ 1],11       );
+   F4(A1,B1,C1,D1,M[ 0],14,MAGIC4);   F1(A2,B2,C2,D2,M[ 3],14       );
+   F4(D1,A1,B1,C1,M[ 8],15,MAGIC4);   F1(D2,A2,B2,C2,M[11],14       );
+   F4(C1,D1,A1,B1,M[12], 9,MAGIC4);   F1(C2,D2,A2,B2,M[15], 6       );
+   F4(B1,C1,D1,A1,M[ 4], 8,MAGIC4);   F1(B2,C2,D2,A2,M[ 0],14       );
+   F4(A1,B1,C1,D1,M[13], 9,MAGIC4);   F1(A2,B2,C2,D2,M[ 5], 6       );
+   F4(D1,A1,B1,C1,M[ 3],14,MAGIC4);   F1(D2,A2,B2,C2,M[12], 9       );
+   F4(C1,D1,A1,B1,M[ 7], 5,MAGIC4);   F1(C2,D2,A2,B2,M[ 2],12       );
+   F4(B1,C1,D1,A1,M[15], 6,MAGIC4);   F1(B2,C2,D2,A2,M[13], 9       );
+   F4(A1,B1,C1,D1,M[14], 8,MAGIC4);   F1(A2,B2,C2,D2,M[ 9],12       );
+   F4(D1,A1,B1,C1,M[ 5], 6,MAGIC4);   F1(D2,A2,B2,C2,M[ 7], 5       );
+   F4(C1,D1,A1,B1,M[ 6], 5,MAGIC4);   F1(C2,D2,A2,B2,M[10],15       );
+   F4(B1,C1,D1,A1,M[ 2],12,MAGIC4);   F1(B2,C2,D2,A2,M[14], 8       );
+
+   D2        = digest[1] + C1 + D2; digest[1] = digest[2] + D1 + A2;
+   digest[2] = digest[3] + A1 + B2; digest[3] = digest[0] + B1 + C2;
+   digest[0] = D2;
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void RIPEMD_128::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_le(digest[j/4], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void RIPEMD_128::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   M.clear();
+   digest[0] = 0x67452301;
+   digest[1] = 0xEFCDAB89;
+   digest[2] = 0x98BADCFE;
+   digest[3] = 0x10325476;
+   }
+
+}
diff --git a/src/hash/rmd128/rmd128.h b/src/hash/rmd128/rmd128.h
new file mode 100644
index 000000000..2cb98e516
--- /dev/null
+++ b/src/hash/rmd128/rmd128.h
@@ -0,0 +1,33 @@
+/*************************************************
+* RIPEMD-128 Header File                         *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_RIPEMD_128_H__
+#define BOTAN_RIPEMD_128_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* RIPEMD-128                                     *
+*************************************************/
+class BOTAN_DLL RIPEMD_128 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "RIPEMD-128"; }
+      HashFunction* clone() const { return new RIPEMD_128; }
+      RIPEMD_128() : MDx_HashFunction(16, 64, false, true) { clear(); }
+  private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 16> M;
+      SecureBuffer<u32bit, 4> digest;
+   };
+
+}
+
+#endif
diff --git a/src/hash/rmd160/modinfo.txt b/src/hash/rmd160/modinfo.txt
new file mode 100644
index 000000000..11183b03e
--- /dev/null
+++ b/src/hash/rmd160/modinfo.txt
@@ -0,0 +1,10 @@
+realname "RIPEMD-160"
+
+define RIPEMD_160
+
+load_on auto
+
+<add>
+rmd160.cpp
+rmd160.h
+</add>
diff --git a/src/hash/rmd160/rmd160.cpp b/src/hash/rmd160/rmd160.cpp
new file mode 100644
index 000000000..20c0ad4f1
--- /dev/null
+++ b/src/hash/rmd160/rmd160.cpp
@@ -0,0 +1,201 @@
+/*************************************************
+* RIPEMD-160 Source File                         *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/rmd160.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* RIPEMD-160 F1 Function                         *
+*************************************************/
+inline void F1(u32bit& A, u32bit B, u32bit& C, u32bit D, u32bit E,
+               u32bit msg, u32bit shift)
+   {
+   A += (B ^ C ^ D) + msg;
+   A  = rotate_left(A, shift) + E;
+   C  = rotate_left(C, 10);
+   }
+
+/*************************************************
+* RIPEMD-160 F2 Function                         *
+*************************************************/
+inline void F2(u32bit& A, u32bit B, u32bit& C, u32bit D, u32bit E,
+               u32bit msg, u32bit shift, u32bit magic)
+   {
+   A += (D ^ (B & (C ^ D))) + msg + magic;
+   A  = rotate_left(A, shift) + E;
+   C  = rotate_left(C, 10);
+   }
+
+/*************************************************
+* RIPEMD-160 F3 Function                         *
+*************************************************/
+inline void F3(u32bit& A, u32bit B, u32bit& C, u32bit D, u32bit E,
+               u32bit msg, u32bit shift, u32bit magic)
+   {
+   A += (D ^ (B | ~C)) + msg + magic;
+   A  = rotate_left(A, shift) + E;
+   C  = rotate_left(C, 10);
+   }
+
+/*************************************************
+* RIPEMD-160 F4 Function                         *
+*************************************************/
+inline void F4(u32bit& A, u32bit B, u32bit& C, u32bit D, u32bit E,
+               u32bit msg, u32bit shift, u32bit magic)
+   {
+   A += (C ^ (D & (B ^ C))) + msg + magic;
+   A  = rotate_left(A, shift) + E;
+   C  = rotate_left(C, 10);
+   }
+
+/*************************************************
+* RIPEMD-160 F5 Function                         *
+*************************************************/
+inline void F5(u32bit& A, u32bit B, u32bit& C, u32bit D, u32bit E,
+               u32bit msg, u32bit shift, u32bit magic)
+   {
+   A += (B ^ (C | ~D)) + msg + magic;
+   A  = rotate_left(A, shift) + E;
+   C  = rotate_left(C, 10);
+   }
+
+}
+
+/*************************************************
+* RIPEMD-160 Compression Function                *
+*************************************************/
+void RIPEMD_160::hash(const byte input[])
+   {
+   for(u32bit j = 0; j != 16; ++j)
+      M[j] = load_le<u32bit>(input, j);
+
+   u32bit A1 = digest[0], A2 = A1, B1 = digest[1], B2 = B1,
+          C1 = digest[2], C2 = C1, D1 = digest[3], D2 = D1,
+          E1 = digest[4], E2 = E1;
+
+   const u32bit MAGIC2 = 0x5A827999, MAGIC3 = 0x6ED9EBA1,
+                MAGIC4 = 0x8F1BBCDC, MAGIC5 = 0xA953FD4E,
+                MAGIC6 = 0x50A28BE6, MAGIC7 = 0x5C4DD124,
+                MAGIC8 = 0x6D703EF3, MAGIC9 = 0x7A6D76E9;
+
+   F1(A1,B1,C1,D1,E1,M[ 0],11       );   F5(A2,B2,C2,D2,E2,M[ 5], 8,MAGIC6);
+   F1(E1,A1,B1,C1,D1,M[ 1],14       );   F5(E2,A2,B2,C2,D2,M[14], 9,MAGIC6);
+   F1(D1,E1,A1,B1,C1,M[ 2],15       );   F5(D2,E2,A2,B2,C2,M[ 7], 9,MAGIC6);
+   F1(C1,D1,E1,A1,B1,M[ 3],12       );   F5(C2,D2,E2,A2,B2,M[ 0],11,MAGIC6);
+   F1(B1,C1,D1,E1,A1,M[ 4], 5       );   F5(B2,C2,D2,E2,A2,M[ 9],13,MAGIC6);
+   F1(A1,B1,C1,D1,E1,M[ 5], 8       );   F5(A2,B2,C2,D2,E2,M[ 2],15,MAGIC6);
+   F1(E1,A1,B1,C1,D1,M[ 6], 7       );   F5(E2,A2,B2,C2,D2,M[11],15,MAGIC6);
+   F1(D1,E1,A1,B1,C1,M[ 7], 9       );   F5(D2,E2,A2,B2,C2,M[ 4], 5,MAGIC6);
+   F1(C1,D1,E1,A1,B1,M[ 8],11       );   F5(C2,D2,E2,A2,B2,M[13], 7,MAGIC6);
+   F1(B1,C1,D1,E1,A1,M[ 9],13       );   F5(B2,C2,D2,E2,A2,M[ 6], 7,MAGIC6);
+   F1(A1,B1,C1,D1,E1,M[10],14       );   F5(A2,B2,C2,D2,E2,M[15], 8,MAGIC6);
+   F1(E1,A1,B1,C1,D1,M[11],15       );   F5(E2,A2,B2,C2,D2,M[ 8],11,MAGIC6);
+   F1(D1,E1,A1,B1,C1,M[12], 6       );   F5(D2,E2,A2,B2,C2,M[ 1],14,MAGIC6);
+   F1(C1,D1,E1,A1,B1,M[13], 7       );   F5(C2,D2,E2,A2,B2,M[10],14,MAGIC6);
+   F1(B1,C1,D1,E1,A1,M[14], 9       );   F5(B2,C2,D2,E2,A2,M[ 3],12,MAGIC6);
+   F1(A1,B1,C1,D1,E1,M[15], 8       );   F5(A2,B2,C2,D2,E2,M[12], 6,MAGIC6);
+
+   F2(E1,A1,B1,C1,D1,M[ 7], 7,MAGIC2);   F4(E2,A2,B2,C2,D2,M[ 6], 9,MAGIC7);
+   F2(D1,E1,A1,B1,C1,M[ 4], 6,MAGIC2);   F4(D2,E2,A2,B2,C2,M[11],13,MAGIC7);
+   F2(C1,D1,E1,A1,B1,M[13], 8,MAGIC2);   F4(C2,D2,E2,A2,B2,M[ 3],15,MAGIC7);
+   F2(B1,C1,D1,E1,A1,M[ 1],13,MAGIC2);   F4(B2,C2,D2,E2,A2,M[ 7], 7,MAGIC7);
+   F2(A1,B1,C1,D1,E1,M[10],11,MAGIC2);   F4(A2,B2,C2,D2,E2,M[ 0],12,MAGIC7);
+   F2(E1,A1,B1,C1,D1,M[ 6], 9,MAGIC2);   F4(E2,A2,B2,C2,D2,M[13], 8,MAGIC7);
+   F2(D1,E1,A1,B1,C1,M[15], 7,MAGIC2);   F4(D2,E2,A2,B2,C2,M[ 5], 9,MAGIC7);
+   F2(C1,D1,E1,A1,B1,M[ 3],15,MAGIC2);   F4(C2,D2,E2,A2,B2,M[10],11,MAGIC7);
+   F2(B1,C1,D1,E1,A1,M[12], 7,MAGIC2);   F4(B2,C2,D2,E2,A2,M[14], 7,MAGIC7);
+   F2(A1,B1,C1,D1,E1,M[ 0],12,MAGIC2);   F4(A2,B2,C2,D2,E2,M[15], 7,MAGIC7);
+   F2(E1,A1,B1,C1,D1,M[ 9],15,MAGIC2);   F4(E2,A2,B2,C2,D2,M[ 8],12,MAGIC7);
+   F2(D1,E1,A1,B1,C1,M[ 5], 9,MAGIC2);   F4(D2,E2,A2,B2,C2,M[12], 7,MAGIC7);
+   F2(C1,D1,E1,A1,B1,M[ 2],11,MAGIC2);   F4(C2,D2,E2,A2,B2,M[ 4], 6,MAGIC7);
+   F2(B1,C1,D1,E1,A1,M[14], 7,MAGIC2);   F4(B2,C2,D2,E2,A2,M[ 9],15,MAGIC7);
+   F2(A1,B1,C1,D1,E1,M[11],13,MAGIC2);   F4(A2,B2,C2,D2,E2,M[ 1],13,MAGIC7);
+   F2(E1,A1,B1,C1,D1,M[ 8],12,MAGIC2);   F4(E2,A2,B2,C2,D2,M[ 2],11,MAGIC7);
+
+   F3(D1,E1,A1,B1,C1,M[ 3],11,MAGIC3);   F3(D2,E2,A2,B2,C2,M[15], 9,MAGIC8);
+   F3(C1,D1,E1,A1,B1,M[10],13,MAGIC3);   F3(C2,D2,E2,A2,B2,M[ 5], 7,MAGIC8);
+   F3(B1,C1,D1,E1,A1,M[14], 6,MAGIC3);   F3(B2,C2,D2,E2,A2,M[ 1],15,MAGIC8);
+   F3(A1,B1,C1,D1,E1,M[ 4], 7,MAGIC3);   F3(A2,B2,C2,D2,E2,M[ 3],11,MAGIC8);
+   F3(E1,A1,B1,C1,D1,M[ 9],14,MAGIC3);   F3(E2,A2,B2,C2,D2,M[ 7], 8,MAGIC8);
+   F3(D1,E1,A1,B1,C1,M[15], 9,MAGIC3);   F3(D2,E2,A2,B2,C2,M[14], 6,MAGIC8);
+   F3(C1,D1,E1,A1,B1,M[ 8],13,MAGIC3);   F3(C2,D2,E2,A2,B2,M[ 6], 6,MAGIC8);
+   F3(B1,C1,D1,E1,A1,M[ 1],15,MAGIC3);   F3(B2,C2,D2,E2,A2,M[ 9],14,MAGIC8);
+   F3(A1,B1,C1,D1,E1,M[ 2],14,MAGIC3);   F3(A2,B2,C2,D2,E2,M[11],12,MAGIC8);
+   F3(E1,A1,B1,C1,D1,M[ 7], 8,MAGIC3);   F3(E2,A2,B2,C2,D2,M[ 8],13,MAGIC8);
+   F3(D1,E1,A1,B1,C1,M[ 0],13,MAGIC3);   F3(D2,E2,A2,B2,C2,M[12], 5,MAGIC8);
+   F3(C1,D1,E1,A1,B1,M[ 6], 6,MAGIC3);   F3(C2,D2,E2,A2,B2,M[ 2],14,MAGIC8);
+   F3(B1,C1,D1,E1,A1,M[13], 5,MAGIC3);   F3(B2,C2,D2,E2,A2,M[10],13,MAGIC8);
+   F3(A1,B1,C1,D1,E1,M[11],12,MAGIC3);   F3(A2,B2,C2,D2,E2,M[ 0],13,MAGIC8);
+   F3(E1,A1,B1,C1,D1,M[ 5], 7,MAGIC3);   F3(E2,A2,B2,C2,D2,M[ 4], 7,MAGIC8);
+   F3(D1,E1,A1,B1,C1,M[12], 5,MAGIC3);   F3(D2,E2,A2,B2,C2,M[13], 5,MAGIC8);
+
+   F4(C1,D1,E1,A1,B1,M[ 1],11,MAGIC4);   F2(C2,D2,E2,A2,B2,M[ 8],15,MAGIC9);
+   F4(B1,C1,D1,E1,A1,M[ 9],12,MAGIC4);   F2(B2,C2,D2,E2,A2,M[ 6], 5,MAGIC9);
+   F4(A1,B1,C1,D1,E1,M[11],14,MAGIC4);   F2(A2,B2,C2,D2,E2,M[ 4], 8,MAGIC9);
+   F4(E1,A1,B1,C1,D1,M[10],15,MAGIC4);   F2(E2,A2,B2,C2,D2,M[ 1],11,MAGIC9);
+   F4(D1,E1,A1,B1,C1,M[ 0],14,MAGIC4);   F2(D2,E2,A2,B2,C2,M[ 3],14,MAGIC9);
+   F4(C1,D1,E1,A1,B1,M[ 8],15,MAGIC4);   F2(C2,D2,E2,A2,B2,M[11],14,MAGIC9);
+   F4(B1,C1,D1,E1,A1,M[12], 9,MAGIC4);   F2(B2,C2,D2,E2,A2,M[15], 6,MAGIC9);
+   F4(A1,B1,C1,D1,E1,M[ 4], 8,MAGIC4);   F2(A2,B2,C2,D2,E2,M[ 0],14,MAGIC9);
+   F4(E1,A1,B1,C1,D1,M[13], 9,MAGIC4);   F2(E2,A2,B2,C2,D2,M[ 5], 6,MAGIC9);
+   F4(D1,E1,A1,B1,C1,M[ 3],14,MAGIC4);   F2(D2,E2,A2,B2,C2,M[12], 9,MAGIC9);
+   F4(C1,D1,E1,A1,B1,M[ 7], 5,MAGIC4);   F2(C2,D2,E2,A2,B2,M[ 2],12,MAGIC9);
+   F4(B1,C1,D1,E1,A1,M[15], 6,MAGIC4);   F2(B2,C2,D2,E2,A2,M[13], 9,MAGIC9);
+   F4(A1,B1,C1,D1,E1,M[14], 8,MAGIC4);   F2(A2,B2,C2,D2,E2,M[ 9],12,MAGIC9);
+   F4(E1,A1,B1,C1,D1,M[ 5], 6,MAGIC4);   F2(E2,A2,B2,C2,D2,M[ 7], 5,MAGIC9);
+   F4(D1,E1,A1,B1,C1,M[ 6], 5,MAGIC4);   F2(D2,E2,A2,B2,C2,M[10],15,MAGIC9);
+   F4(C1,D1,E1,A1,B1,M[ 2],12,MAGIC4);   F2(C2,D2,E2,A2,B2,M[14], 8,MAGIC9);
+
+   F5(B1,C1,D1,E1,A1,M[ 4], 9,MAGIC5);   F1(B2,C2,D2,E2,A2,M[12], 8       );
+   F5(A1,B1,C1,D1,E1,M[ 0],15,MAGIC5);   F1(A2,B2,C2,D2,E2,M[15], 5       );
+   F5(E1,A1,B1,C1,D1,M[ 5], 5,MAGIC5);   F1(E2,A2,B2,C2,D2,M[10],12       );
+   F5(D1,E1,A1,B1,C1,M[ 9],11,MAGIC5);   F1(D2,E2,A2,B2,C2,M[ 4], 9       );
+   F5(C1,D1,E1,A1,B1,M[ 7], 6,MAGIC5);   F1(C2,D2,E2,A2,B2,M[ 1],12       );
+   F5(B1,C1,D1,E1,A1,M[12], 8,MAGIC5);   F1(B2,C2,D2,E2,A2,M[ 5], 5       );
+   F5(A1,B1,C1,D1,E1,M[ 2],13,MAGIC5);   F1(A2,B2,C2,D2,E2,M[ 8],14       );
+   F5(E1,A1,B1,C1,D1,M[10],12,MAGIC5);   F1(E2,A2,B2,C2,D2,M[ 7], 6       );
+   F5(D1,E1,A1,B1,C1,M[14], 5,MAGIC5);   F1(D2,E2,A2,B2,C2,M[ 6], 8       );
+   F5(C1,D1,E1,A1,B1,M[ 1],12,MAGIC5);   F1(C2,D2,E2,A2,B2,M[ 2],13       );
+   F5(B1,C1,D1,E1,A1,M[ 3],13,MAGIC5);   F1(B2,C2,D2,E2,A2,M[13], 6       );
+   F5(A1,B1,C1,D1,E1,M[ 8],14,MAGIC5);   F1(A2,B2,C2,D2,E2,M[14], 5       );
+   F5(E1,A1,B1,C1,D1,M[11],11,MAGIC5);   F1(E2,A2,B2,C2,D2,M[ 0],15       );
+   F5(D1,E1,A1,B1,C1,M[ 6], 8,MAGIC5);   F1(D2,E2,A2,B2,C2,M[ 3],13       );
+   F5(C1,D1,E1,A1,B1,M[15], 5,MAGIC5);   F1(C2,D2,E2,A2,B2,M[ 9],11       );
+   F5(B1,C1,D1,E1,A1,M[13], 6,MAGIC5);   F1(B2,C2,D2,E2,A2,M[11],11       );
+
+   C1        = digest[1] + C1 + D2; digest[1] = digest[2] + D1 + E2;
+   digest[2] = digest[3] + E1 + A2; digest[3] = digest[4] + A1 + B2;
+   digest[4] = digest[0] + B1 + C2; digest[0] = C1;
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void RIPEMD_160::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_le(digest[j/4], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void RIPEMD_160::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   M.clear();
+   digest[0] = 0x67452301;
+   digest[1] = 0xEFCDAB89;
+   digest[2] = 0x98BADCFE;
+   digest[3] = 0x10325476;
+   digest[4] = 0xC3D2E1F0;
+   }
+
+}
diff --git a/src/hash/rmd160/rmd160.h b/src/hash/rmd160/rmd160.h
new file mode 100644
index 000000000..0544f21cc
--- /dev/null
+++ b/src/hash/rmd160/rmd160.h
@@ -0,0 +1,33 @@
+/*************************************************
+* RIPEMD-160 Header File                         *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_RIPEMD_160_H__
+#define BOTAN_RIPEMD_160_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* RIPEMD-160                                     *
+*************************************************/
+class BOTAN_DLL RIPEMD_160 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "RIPEMD-160"; }
+      HashFunction* clone() const { return new RIPEMD_160; }
+      RIPEMD_160() : MDx_HashFunction(20, 64, false, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 16> M;
+      SecureBuffer<u32bit, 5> digest;
+   };
+
+}
+
+#endif
diff --git a/src/hash/sha1/modinfo.txt b/src/hash/sha1/modinfo.txt
new file mode 100644
index 000000000..38cea256c
--- /dev/null
+++ b/src/hash/sha1/modinfo.txt
@@ -0,0 +1,10 @@
+realname "SHA-1"
+
+define SHA1
+
+load_on auto
+
+<add>
+sha160.cpp
+sha160.h
+</add>
diff --git a/src/hash/sha1/sha160.cpp b/src/hash/sha1/sha160.cpp
new file mode 100644
index 000000000..baafec1db
--- /dev/null
+++ b/src/hash/sha1/sha160.cpp
@@ -0,0 +1,143 @@
+/*************************************************
+* SHA-160 Source File                            *
+* (C) 1999-2008 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/sha160.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* SHA-160 F1 Function                            *
+*************************************************/
+inline void F1(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
+   {
+   E += (D ^ (B & (C ^ D))) + msg + 0x5A827999 + rotate_left(A, 5);
+   B  = rotate_left(B, 30);
+   }
+
+/*************************************************
+* SHA-160 F2 Function                            *
+*************************************************/
+inline void F2(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
+   {
+   E += (B ^ C ^ D) + msg + 0x6ED9EBA1 + rotate_left(A, 5);
+   B  = rotate_left(B, 30);
+   }
+
+/*************************************************
+* SHA-160 F3 Function                            *
+*************************************************/
+inline void F3(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
+   {
+   E += ((B & C) | ((B | C) & D)) + msg + 0x8F1BBCDC + rotate_left(A, 5);
+   B  = rotate_left(B, 30);
+   }
+
+/*************************************************
+* SHA-160 F4 Function                            *
+*************************************************/
+inline void F4(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
+   {
+   E += (B ^ C ^ D) + msg + 0xCA62C1D6 + rotate_left(A, 5);
+   B  = rotate_left(B, 30);
+   }
+
+}
+
+/*************************************************
+* SHA-160 Compression Function                   *
+*************************************************/
+void SHA_160::hash(const byte input[])
+   {
+   for(u32bit j = 0; j != 16; j += 4)
+      {
+      W[j  ] = load_be<u32bit>(input, j);
+      W[j+1] = load_be<u32bit>(input, j+1);
+      W[j+2] = load_be<u32bit>(input, j+2);
+      W[j+3] = load_be<u32bit>(input, j+3);
+      }
+
+   for(u32bit j = 16; j != 80; j += 4)
+      {
+      W[j  ] = rotate_left((W[j-3] ^ W[j-8] ^ W[j-14] ^ W[j-16]), 1);
+      W[j+1] = rotate_left((W[j-2] ^ W[j-7] ^ W[j-13] ^ W[j-15]), 1);
+      W[j+2] = rotate_left((W[j-1] ^ W[j-6] ^ W[j-12] ^ W[j-14]), 1);
+      W[j+3] = rotate_left((W[j  ] ^ W[j-5] ^ W[j-11] ^ W[j-13]), 1);
+      }
+
+   u32bit A = digest[0], B = digest[1], C = digest[2],
+          D = digest[3], E = digest[4];
+
+   F1(A,B,C,D,E,W[ 0]);   F1(E,A,B,C,D,W[ 1]);   F1(D,E,A,B,C,W[ 2]);
+   F1(C,D,E,A,B,W[ 3]);   F1(B,C,D,E,A,W[ 4]);   F1(A,B,C,D,E,W[ 5]);
+   F1(E,A,B,C,D,W[ 6]);   F1(D,E,A,B,C,W[ 7]);   F1(C,D,E,A,B,W[ 8]);
+   F1(B,C,D,E,A,W[ 9]);   F1(A,B,C,D,E,W[10]);   F1(E,A,B,C,D,W[11]);
+   F1(D,E,A,B,C,W[12]);   F1(C,D,E,A,B,W[13]);   F1(B,C,D,E,A,W[14]);
+   F1(A,B,C,D,E,W[15]);   F1(E,A,B,C,D,W[16]);   F1(D,E,A,B,C,W[17]);
+   F1(C,D,E,A,B,W[18]);   F1(B,C,D,E,A,W[19]);
+
+   F2(A,B,C,D,E,W[20]);   F2(E,A,B,C,D,W[21]);   F2(D,E,A,B,C,W[22]);
+   F2(C,D,E,A,B,W[23]);   F2(B,C,D,E,A,W[24]);   F2(A,B,C,D,E,W[25]);
+   F2(E,A,B,C,D,W[26]);   F2(D,E,A,B,C,W[27]);   F2(C,D,E,A,B,W[28]);
+   F2(B,C,D,E,A,W[29]);   F2(A,B,C,D,E,W[30]);   F2(E,A,B,C,D,W[31]);
+   F2(D,E,A,B,C,W[32]);   F2(C,D,E,A,B,W[33]);   F2(B,C,D,E,A,W[34]);
+   F2(A,B,C,D,E,W[35]);   F2(E,A,B,C,D,W[36]);   F2(D,E,A,B,C,W[37]);
+   F2(C,D,E,A,B,W[38]);   F2(B,C,D,E,A,W[39]);
+
+   F3(A,B,C,D,E,W[40]);   F3(E,A,B,C,D,W[41]);   F3(D,E,A,B,C,W[42]);
+   F3(C,D,E,A,B,W[43]);   F3(B,C,D,E,A,W[44]);   F3(A,B,C,D,E,W[45]);
+   F3(E,A,B,C,D,W[46]);   F3(D,E,A,B,C,W[47]);   F3(C,D,E,A,B,W[48]);
+   F3(B,C,D,E,A,W[49]);   F3(A,B,C,D,E,W[50]);   F3(E,A,B,C,D,W[51]);
+   F3(D,E,A,B,C,W[52]);   F3(C,D,E,A,B,W[53]);   F3(B,C,D,E,A,W[54]);
+   F3(A,B,C,D,E,W[55]);   F3(E,A,B,C,D,W[56]);   F3(D,E,A,B,C,W[57]);
+   F3(C,D,E,A,B,W[58]);   F3(B,C,D,E,A,W[59]);
+
+   F4(A,B,C,D,E,W[60]);   F4(E,A,B,C,D,W[61]);   F4(D,E,A,B,C,W[62]);
+   F4(C,D,E,A,B,W[63]);   F4(B,C,D,E,A,W[64]);   F4(A,B,C,D,E,W[65]);
+   F4(E,A,B,C,D,W[66]);   F4(D,E,A,B,C,W[67]);   F4(C,D,E,A,B,W[68]);
+   F4(B,C,D,E,A,W[69]);   F4(A,B,C,D,E,W[70]);   F4(E,A,B,C,D,W[71]);
+   F4(D,E,A,B,C,W[72]);   F4(C,D,E,A,B,W[73]);   F4(B,C,D,E,A,W[74]);
+   F4(A,B,C,D,E,W[75]);   F4(E,A,B,C,D,W[76]);   F4(D,E,A,B,C,W[77]);
+   F4(C,D,E,A,B,W[78]);   F4(B,C,D,E,A,W[79]);
+
+   digest[0] += A; digest[1] += B; digest[2] += C;
+   digest[3] += D; digest[4] += E;
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void SHA_160::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_be(digest[j/4], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void SHA_160::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   W.clear();
+   digest[0] = 0x67452301;
+   digest[1] = 0xEFCDAB89;
+   digest[2] = 0x98BADCFE;
+   digest[3] = 0x10325476;
+   digest[4] = 0xC3D2E1F0;
+   }
+
+/*************************************************
+* SHA_160 Constructor                            *
+*************************************************/
+SHA_160::SHA_160() : MDx_HashFunction(20, 64, true, true), W(80)
+   {
+   clear();
+   }
+
+}
diff --git a/src/hash/sha1/sha160.h b/src/hash/sha1/sha160.h
new file mode 100644
index 000000000..022ab9514
--- /dev/null
+++ b/src/hash/sha1/sha160.h
@@ -0,0 +1,33 @@
+/*************************************************
+* SHA-160 Header File                            *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_SHA_160_H__
+#define BOTAN_SHA_160_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* SHA-160                                        *
+*************************************************/
+class BOTAN_DLL SHA_160 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "SHA-160"; }
+      HashFunction* clone() const { return new SHA_160; }
+      SHA_160();
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 5> digest;
+      SecureVector<u32bit> W;
+   };
+
+}
+
+#endif
diff --git a/src/hash/sha2/modinfo.txt b/src/hash/sha2/modinfo.txt
new file mode 100644
index 000000000..c7dc29fac
--- /dev/null
+++ b/src/hash/sha2/modinfo.txt
@@ -0,0 +1,12 @@
+realname "SHA-2 (256, 384, 512)"
+
+define SHA2
+
+load_on auto
+
+<add>
+sha256.cpp
+sha256.h
+sha_64.cpp
+sha_64.h
+</add>
diff --git a/src/hash/sha2/sha256.cpp b/src/hash/sha2/sha256.cpp
new file mode 100644
index 000000000..6031d177f
--- /dev/null
+++ b/src/hash/sha2/sha256.cpp
@@ -0,0 +1,124 @@
+/*************************************************
+* SHA-256 Source File                            *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/sha256.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* SHA-256 Rho Function                           *
+*************************************************/
+inline u32bit rho(u32bit X, u32bit rot1, u32bit rot2, u32bit rot3)
+   {
+   return (rotate_right(X, rot1) ^ rotate_right(X, rot2) ^
+           rotate_right(X, rot3));
+   }
+
+/*************************************************
+* SHA-256 Sigma Function                         *
+*************************************************/
+inline u32bit sigma(u32bit X, u32bit rot1, u32bit rot2, u32bit shift)
+   {
+   return (rotate_right(X, rot1) ^ rotate_right(X, rot2) ^ (X >> shift));
+   }
+
+/*************************************************
+* SHA-256 F1 Function                            *
+*************************************************/
+inline void F1(u32bit A, u32bit B, u32bit C, u32bit& D,
+               u32bit E, u32bit F, u32bit G, u32bit& H,
+               u32bit msg, u32bit magic)
+   {
+   magic += rho(E, 6, 11, 25) + ((E & F) ^ (~E & G)) + msg;
+   D += magic + H;
+   H += magic + rho(A, 2, 13, 22) + ((A & B) ^ (A & C) ^ (B & C));
+   }
+
+}
+
+/*************************************************
+* SHA-256 Compression Function                   *
+*************************************************/
+void SHA_256::hash(const byte input[])
+   {
+   for(u32bit j = 0; j != 16; ++j)
+      W[j] = load_be<u32bit>(input, j);
+   for(u32bit j = 16; j != 64; ++j)
+      W[j] = sigma(W[j- 2], 17, 19, 10) + W[j- 7] +
+             sigma(W[j-15],  7, 18,  3) + W[j-16];
+
+   u32bit A = digest[0], B = digest[1], C = digest[2],
+          D = digest[3], E = digest[4], F = digest[5],
+          G = digest[6], H = digest[7];
+
+   F1(A,B,C,D,E,F,G,H,W[ 0],0x428A2F98);  F1(H,A,B,C,D,E,F,G,W[ 1],0x71374491);
+   F1(G,H,A,B,C,D,E,F,W[ 2],0xB5C0FBCF);  F1(F,G,H,A,B,C,D,E,W[ 3],0xE9B5DBA5);
+   F1(E,F,G,H,A,B,C,D,W[ 4],0x3956C25B);  F1(D,E,F,G,H,A,B,C,W[ 5],0x59F111F1);
+   F1(C,D,E,F,G,H,A,B,W[ 6],0x923F82A4);  F1(B,C,D,E,F,G,H,A,W[ 7],0xAB1C5ED5);
+   F1(A,B,C,D,E,F,G,H,W[ 8],0xD807AA98);  F1(H,A,B,C,D,E,F,G,W[ 9],0x12835B01);
+   F1(G,H,A,B,C,D,E,F,W[10],0x243185BE);  F1(F,G,H,A,B,C,D,E,W[11],0x550C7DC3);
+   F1(E,F,G,H,A,B,C,D,W[12],0x72BE5D74);  F1(D,E,F,G,H,A,B,C,W[13],0x80DEB1FE);
+   F1(C,D,E,F,G,H,A,B,W[14],0x9BDC06A7);  F1(B,C,D,E,F,G,H,A,W[15],0xC19BF174);
+   F1(A,B,C,D,E,F,G,H,W[16],0xE49B69C1);  F1(H,A,B,C,D,E,F,G,W[17],0xEFBE4786);
+   F1(G,H,A,B,C,D,E,F,W[18],0x0FC19DC6);  F1(F,G,H,A,B,C,D,E,W[19],0x240CA1CC);
+   F1(E,F,G,H,A,B,C,D,W[20],0x2DE92C6F);  F1(D,E,F,G,H,A,B,C,W[21],0x4A7484AA);
+   F1(C,D,E,F,G,H,A,B,W[22],0x5CB0A9DC);  F1(B,C,D,E,F,G,H,A,W[23],0x76F988DA);
+   F1(A,B,C,D,E,F,G,H,W[24],0x983E5152);  F1(H,A,B,C,D,E,F,G,W[25],0xA831C66D);
+   F1(G,H,A,B,C,D,E,F,W[26],0xB00327C8);  F1(F,G,H,A,B,C,D,E,W[27],0xBF597FC7);
+   F1(E,F,G,H,A,B,C,D,W[28],0xC6E00BF3);  F1(D,E,F,G,H,A,B,C,W[29],0xD5A79147);
+   F1(C,D,E,F,G,H,A,B,W[30],0x06CA6351);  F1(B,C,D,E,F,G,H,A,W[31],0x14292967);
+   F1(A,B,C,D,E,F,G,H,W[32],0x27B70A85);  F1(H,A,B,C,D,E,F,G,W[33],0x2E1B2138);
+   F1(G,H,A,B,C,D,E,F,W[34],0x4D2C6DFC);  F1(F,G,H,A,B,C,D,E,W[35],0x53380D13);
+   F1(E,F,G,H,A,B,C,D,W[36],0x650A7354);  F1(D,E,F,G,H,A,B,C,W[37],0x766A0ABB);
+   F1(C,D,E,F,G,H,A,B,W[38],0x81C2C92E);  F1(B,C,D,E,F,G,H,A,W[39],0x92722C85);
+   F1(A,B,C,D,E,F,G,H,W[40],0xA2BFE8A1);  F1(H,A,B,C,D,E,F,G,W[41],0xA81A664B);
+   F1(G,H,A,B,C,D,E,F,W[42],0xC24B8B70);  F1(F,G,H,A,B,C,D,E,W[43],0xC76C51A3);
+   F1(E,F,G,H,A,B,C,D,W[44],0xD192E819);  F1(D,E,F,G,H,A,B,C,W[45],0xD6990624);
+   F1(C,D,E,F,G,H,A,B,W[46],0xF40E3585);  F1(B,C,D,E,F,G,H,A,W[47],0x106AA070);
+   F1(A,B,C,D,E,F,G,H,W[48],0x19A4C116);  F1(H,A,B,C,D,E,F,G,W[49],0x1E376C08);
+   F1(G,H,A,B,C,D,E,F,W[50],0x2748774C);  F1(F,G,H,A,B,C,D,E,W[51],0x34B0BCB5);
+   F1(E,F,G,H,A,B,C,D,W[52],0x391C0CB3);  F1(D,E,F,G,H,A,B,C,W[53],0x4ED8AA4A);
+   F1(C,D,E,F,G,H,A,B,W[54],0x5B9CCA4F);  F1(B,C,D,E,F,G,H,A,W[55],0x682E6FF3);
+   F1(A,B,C,D,E,F,G,H,W[56],0x748F82EE);  F1(H,A,B,C,D,E,F,G,W[57],0x78A5636F);
+   F1(G,H,A,B,C,D,E,F,W[58],0x84C87814);  F1(F,G,H,A,B,C,D,E,W[59],0x8CC70208);
+   F1(E,F,G,H,A,B,C,D,W[60],0x90BEFFFA);  F1(D,E,F,G,H,A,B,C,W[61],0xA4506CEB);
+   F1(C,D,E,F,G,H,A,B,W[62],0xBEF9A3F7);  F1(B,C,D,E,F,G,H,A,W[63],0xC67178F2);
+
+   digest[0] += A; digest[1] += B; digest[2] += C;
+   digest[3] += D; digest[4] += E; digest[5] += F;
+   digest[6] += G; digest[7] += H;
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void SHA_256::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 4)
+      store_be(digest[j/4], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void SHA_256::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   W.clear();
+   digest[0] = 0x6A09E667;
+   digest[1] = 0xBB67AE85;
+   digest[2] = 0x3C6EF372;
+   digest[3] = 0xA54FF53A;
+   digest[4] = 0x510E527F;
+   digest[5] = 0x9B05688C;
+   digest[6] = 0x1F83D9AB;
+   digest[7] = 0x5BE0CD19;
+   }
+
+}
diff --git a/src/hash/sha2/sha256.h b/src/hash/sha2/sha256.h
new file mode 100644
index 000000000..cdbe02822
--- /dev/null
+++ b/src/hash/sha2/sha256.h
@@ -0,0 +1,33 @@
+/*************************************************
+* SHA-256 Header File                            *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_SHA_256_H__
+#define BOTAN_SHA_256_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* SHA-256                                        *
+*************************************************/
+class BOTAN_DLL SHA_256 : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "SHA-256"; }
+      HashFunction* clone() const { return new SHA_256; }
+      SHA_256() : MDx_HashFunction(32, 64, true, true) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u32bit, 64> W;
+      SecureBuffer<u32bit, 8> digest;
+   };
+
+}
+
+#endif
diff --git a/src/hash/sha2/sha_64.cpp b/src/hash/sha2/sha_64.cpp
new file mode 100644
index 000000000..7f4a28fec
--- /dev/null
+++ b/src/hash/sha2/sha_64.cpp
@@ -0,0 +1,197 @@
+/*************************************************
+* SHA-{384,512} Source File                      *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/sha_64.h>
+#include <botan/loadstor.h>
+#include <botan/bit_ops.h>
+
+namespace Botan {
+
+namespace {
+
+/*************************************************
+* SHA-{384,512} Rho Function                     *
+*************************************************/
+inline u64bit rho(u64bit X, u32bit rot1, u32bit rot2, u32bit rot3)
+   {
+   return (rotate_right(X, rot1) ^ rotate_right(X, rot2) ^
+           rotate_right(X, rot3));
+   }
+
+/*************************************************
+* SHA-{384,512} F1 Function                      *
+*************************************************/
+inline void F1(u64bit A, u64bit B, u64bit C, u64bit& D,
+               u64bit E, u64bit F, u64bit G, u64bit& H,
+               u64bit msg, u64bit magic)
+   {
+   magic += rho(E, 14, 18, 41) + ((E & F) ^ (~E & G)) + msg;
+   D += magic + H;
+   H += magic + rho(A, 28, 34, 39) + ((A & B) ^ (A & C) ^ (B & C));
+   }
+
+/*************************************************
+* SHA-{384,512} Sigma Function                   *
+*************************************************/
+inline u64bit sigma(u64bit X, u32bit rot1, u32bit rot2, u32bit shift)
+   {
+   return (rotate_right(X, rot1) ^ rotate_right(X, rot2) ^ (X >> shift));
+   }
+
+}
+
+/*************************************************
+* SHA-{384,512} Compression Function             *
+*************************************************/
+void SHA_64_BASE::hash(const byte input[])
+   {
+   for(u32bit j = 0; j != 16; ++j)
+      W[j] = load_be<u64bit>(input, j);
+
+   for(u32bit j = 16; j != 80; ++j)
+      W[j] = sigma(W[j- 2], 19, 61,  6) + W[j- 7] +
+             sigma(W[j-15],  1,  8,  7) + W[j-16];
+
+   u64bit A = digest[0], B = digest[1], C = digest[2],
+          D = digest[3], E = digest[4], F = digest[5],
+          G = digest[6], H = digest[7];
+
+   F1(A,B,C,D,E,F,G,H,W[ 0],0x428A2F98D728AE22);
+   F1(H,A,B,C,D,E,F,G,W[ 1],0x7137449123EF65CD);
+   F1(G,H,A,B,C,D,E,F,W[ 2],0xB5C0FBCFEC4D3B2F);
+   F1(F,G,H,A,B,C,D,E,W[ 3],0xE9B5DBA58189DBBC);
+   F1(E,F,G,H,A,B,C,D,W[ 4],0x3956C25BF348B538);
+   F1(D,E,F,G,H,A,B,C,W[ 5],0x59F111F1B605D019);
+   F1(C,D,E,F,G,H,A,B,W[ 6],0x923F82A4AF194F9B);
+   F1(B,C,D,E,F,G,H,A,W[ 7],0xAB1C5ED5DA6D8118);
+   F1(A,B,C,D,E,F,G,H,W[ 8],0xD807AA98A3030242);
+   F1(H,A,B,C,D,E,F,G,W[ 9],0x12835B0145706FBE);
+   F1(G,H,A,B,C,D,E,F,W[10],0x243185BE4EE4B28C);
+   F1(F,G,H,A,B,C,D,E,W[11],0x550C7DC3D5FFB4E2);
+   F1(E,F,G,H,A,B,C,D,W[12],0x72BE5D74F27B896F);
+   F1(D,E,F,G,H,A,B,C,W[13],0x80DEB1FE3B1696B1);
+   F1(C,D,E,F,G,H,A,B,W[14],0x9BDC06A725C71235);
+   F1(B,C,D,E,F,G,H,A,W[15],0xC19BF174CF692694);
+   F1(A,B,C,D,E,F,G,H,W[16],0xE49B69C19EF14AD2);
+   F1(H,A,B,C,D,E,F,G,W[17],0xEFBE4786384F25E3);
+   F1(G,H,A,B,C,D,E,F,W[18],0x0FC19DC68B8CD5B5);
+   F1(F,G,H,A,B,C,D,E,W[19],0x240CA1CC77AC9C65);
+   F1(E,F,G,H,A,B,C,D,W[20],0x2DE92C6F592B0275);
+   F1(D,E,F,G,H,A,B,C,W[21],0x4A7484AA6EA6E483);
+   F1(C,D,E,F,G,H,A,B,W[22],0x5CB0A9DCBD41FBD4);
+   F1(B,C,D,E,F,G,H,A,W[23],0x76F988DA831153B5);
+   F1(A,B,C,D,E,F,G,H,W[24],0x983E5152EE66DFAB);
+   F1(H,A,B,C,D,E,F,G,W[25],0xA831C66D2DB43210);
+   F1(G,H,A,B,C,D,E,F,W[26],0xB00327C898FB213F);
+   F1(F,G,H,A,B,C,D,E,W[27],0xBF597FC7BEEF0EE4);
+   F1(E,F,G,H,A,B,C,D,W[28],0xC6E00BF33DA88FC2);
+   F1(D,E,F,G,H,A,B,C,W[29],0xD5A79147930AA725);
+   F1(C,D,E,F,G,H,A,B,W[30],0x06CA6351E003826F);
+   F1(B,C,D,E,F,G,H,A,W[31],0x142929670A0E6E70);
+   F1(A,B,C,D,E,F,G,H,W[32],0x27B70A8546D22FFC);
+   F1(H,A,B,C,D,E,F,G,W[33],0x2E1B21385C26C926);
+   F1(G,H,A,B,C,D,E,F,W[34],0x4D2C6DFC5AC42AED);
+   F1(F,G,H,A,B,C,D,E,W[35],0x53380D139D95B3DF);
+   F1(E,F,G,H,A,B,C,D,W[36],0x650A73548BAF63DE);
+   F1(D,E,F,G,H,A,B,C,W[37],0x766A0ABB3C77B2A8);
+   F1(C,D,E,F,G,H,A,B,W[38],0x81C2C92E47EDAEE6);
+   F1(B,C,D,E,F,G,H,A,W[39],0x92722C851482353B);
+   F1(A,B,C,D,E,F,G,H,W[40],0xA2BFE8A14CF10364);
+   F1(H,A,B,C,D,E,F,G,W[41],0xA81A664BBC423001);
+   F1(G,H,A,B,C,D,E,F,W[42],0xC24B8B70D0F89791);
+   F1(F,G,H,A,B,C,D,E,W[43],0xC76C51A30654BE30);
+   F1(E,F,G,H,A,B,C,D,W[44],0xD192E819D6EF5218);
+   F1(D,E,F,G,H,A,B,C,W[45],0xD69906245565A910);
+   F1(C,D,E,F,G,H,A,B,W[46],0xF40E35855771202A);
+   F1(B,C,D,E,F,G,H,A,W[47],0x106AA07032BBD1B8);
+   F1(A,B,C,D,E,F,G,H,W[48],0x19A4C116B8D2D0C8);
+   F1(H,A,B,C,D,E,F,G,W[49],0x1E376C085141AB53);
+   F1(G,H,A,B,C,D,E,F,W[50],0x2748774CDF8EEB99);
+   F1(F,G,H,A,B,C,D,E,W[51],0x34B0BCB5E19B48A8);
+   F1(E,F,G,H,A,B,C,D,W[52],0x391C0CB3C5C95A63);
+   F1(D,E,F,G,H,A,B,C,W[53],0x4ED8AA4AE3418ACB);
+   F1(C,D,E,F,G,H,A,B,W[54],0x5B9CCA4F7763E373);
+   F1(B,C,D,E,F,G,H,A,W[55],0x682E6FF3D6B2B8A3);
+   F1(A,B,C,D,E,F,G,H,W[56],0x748F82EE5DEFB2FC);
+   F1(H,A,B,C,D,E,F,G,W[57],0x78A5636F43172F60);
+   F1(G,H,A,B,C,D,E,F,W[58],0x84C87814A1F0AB72);
+   F1(F,G,H,A,B,C,D,E,W[59],0x8CC702081A6439EC);
+   F1(E,F,G,H,A,B,C,D,W[60],0x90BEFFFA23631E28);
+   F1(D,E,F,G,H,A,B,C,W[61],0xA4506CEBDE82BDE9);
+   F1(C,D,E,F,G,H,A,B,W[62],0xBEF9A3F7B2C67915);
+   F1(B,C,D,E,F,G,H,A,W[63],0xC67178F2E372532B);
+   F1(A,B,C,D,E,F,G,H,W[64],0xCA273ECEEA26619C);
+   F1(H,A,B,C,D,E,F,G,W[65],0xD186B8C721C0C207);
+   F1(G,H,A,B,C,D,E,F,W[66],0xEADA7DD6CDE0EB1E);
+   F1(F,G,H,A,B,C,D,E,W[67],0xF57D4F7FEE6ED178);
+   F1(E,F,G,H,A,B,C,D,W[68],0x06F067AA72176FBA);
+   F1(D,E,F,G,H,A,B,C,W[69],0x0A637DC5A2C898A6);
+   F1(C,D,E,F,G,H,A,B,W[70],0x113F9804BEF90DAE);
+   F1(B,C,D,E,F,G,H,A,W[71],0x1B710B35131C471B);
+   F1(A,B,C,D,E,F,G,H,W[72],0x28DB77F523047D84);
+   F1(H,A,B,C,D,E,F,G,W[73],0x32CAAB7B40C72493);
+   F1(G,H,A,B,C,D,E,F,W[74],0x3C9EBE0A15C9BEBC);
+   F1(F,G,H,A,B,C,D,E,W[75],0x431D67C49C100D4C);
+   F1(E,F,G,H,A,B,C,D,W[76],0x4CC5D4BECB3E42B6);
+   F1(D,E,F,G,H,A,B,C,W[77],0x597F299CFC657E2A);
+   F1(C,D,E,F,G,H,A,B,W[78],0x5FCB6FAB3AD6FAEC);
+   F1(B,C,D,E,F,G,H,A,W[79],0x6C44198C4A475817);
+
+   digest[0] += A; digest[1] += B; digest[2] += C;
+   digest[3] += D; digest[4] += E; digest[5] += F;
+   digest[6] += G; digest[7] += H;
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void SHA_64_BASE::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 8)
+      store_be(digest[j/8], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void SHA_64_BASE::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   W.clear();
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void SHA_384::clear() throw()
+   {
+   SHA_64_BASE::clear();
+   digest[0] = 0xCBBB9D5DC1059ED8;
+   digest[1] = 0x629A292A367CD507;
+   digest[2] = 0x9159015A3070DD17;
+   digest[3] = 0x152FECD8F70E5939;
+   digest[4] = 0x67332667FFC00B31;
+   digest[5] = 0x8EB44A8768581511;
+   digest[6] = 0xDB0C2E0D64F98FA7;
+   digest[7] = 0x47B5481DBEFA4FA4;
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void SHA_512::clear() throw()
+   {
+   SHA_64_BASE::clear();
+   digest[0] = 0x6A09E667F3BCC908;
+   digest[1] = 0xBB67AE8584CAA73B;
+   digest[2] = 0x3C6EF372FE94F82B;
+   digest[3] = 0xA54FF53A5F1D36F1;
+   digest[4] = 0x510E527FADE682D1;
+   digest[5] = 0x9B05688C2B3E6C1F;
+   digest[6] = 0x1F83D9ABFB41BD6B;
+   digest[7] = 0x5BE0CD19137E2179;
+   }
+
+}
diff --git a/src/hash/sha2/sha_64.h b/src/hash/sha2/sha_64.h
new file mode 100644
index 000000000..e590d088d
--- /dev/null
+++ b/src/hash/sha2/sha_64.h
@@ -0,0 +1,55 @@
+/*************************************************
+* SHA-{384,512} Header File                      *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_SHA_64BIT_H__
+#define BOTAN_SHA_64BIT_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* SHA-{384,512} Base                             *
+*************************************************/
+class BOTAN_DLL SHA_64_BASE : public MDx_HashFunction
+   {
+   protected:
+      void clear() throw();
+      SHA_64_BASE(u32bit out) : MDx_HashFunction(out, 128, true, true, 16) {}
+      SecureBuffer<u64bit, 8> digest;
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      SecureBuffer<u64bit, 80> W;
+   };
+
+/*************************************************
+* SHA-384                                        *
+*************************************************/
+class BOTAN_DLL SHA_384 : public SHA_64_BASE
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "SHA-384"; }
+      HashFunction* clone() const { return new SHA_384; }
+      SHA_384() : SHA_64_BASE(48) { clear(); }
+   };
+
+/*************************************************
+* SHA-512                                        *
+*************************************************/
+class BOTAN_DLL SHA_512 : public SHA_64_BASE
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "SHA-512"; }
+      HashFunction* clone() const { return new SHA_512; }
+      SHA_512() : SHA_64_BASE(64) { clear(); }
+   };
+
+}
+
+#endif
diff --git a/src/hash/tiger/modinfo.txt b/src/hash/tiger/modinfo.txt
new file mode 100644
index 000000000..e117d6701
--- /dev/null
+++ b/src/hash/tiger/modinfo.txt
@@ -0,0 +1,11 @@
+realname "Tiger"
+
+define TIGER
+
+load_on auto
+
+<add>
+tig_tab.cpp
+tiger.cpp
+tiger.h
+</add>
diff --git a/src/hash/tiger/tig_tab.cpp b/src/hash/tiger/tig_tab.cpp
new file mode 100644
index 000000000..6d476f4b3
--- /dev/null
+++ b/src/hash/tiger/tig_tab.cpp
@@ -0,0 +1,362 @@
+/*************************************************
+* S-Box Tables for Tiger                         *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/tiger.h>
+
+namespace Botan {
+
+const u64bit Tiger::SBOX1[256] = {
+   0x02AAB17CF7E90C5E, 0xAC424B03E243A8EC, 0x72CD5BE30DD5FCD3,
+   0x6D019B93F6F97F3A, 0xCD9978FFD21F9193, 0x7573A1C9708029E2,
+   0xB164326B922A83C3, 0x46883EEE04915870, 0xEAACE3057103ECE6,
+   0xC54169B808A3535C, 0x4CE754918DDEC47C, 0x0AA2F4DFDC0DF40C,
+   0x10B76F18A74DBEFA, 0xC6CCB6235AD1AB6A, 0x13726121572FE2FF,
+   0x1A488C6F199D921E, 0x4BC9F9F4DA0007CA, 0x26F5E6F6E85241C7,
+   0x859079DBEA5947B6, 0x4F1885C5C99E8C92, 0xD78E761EA96F864B,
+   0x8E36428C52B5C17D, 0x69CF6827373063C1, 0xB607C93D9BB4C56E,
+   0x7D820E760E76B5EA, 0x645C9CC6F07FDC42, 0xBF38A078243342E0,
+   0x5F6B343C9D2E7D04, 0xF2C28AEB600B0EC6, 0x6C0ED85F7254BCAC,
+   0x71592281A4DB4FE5, 0x1967FA69CE0FED9F, 0xFD5293F8B96545DB,
+   0xC879E9D7F2A7600B, 0x860248920193194E, 0xA4F9533B2D9CC0B3,
+   0x9053836C15957613, 0xDB6DCF8AFC357BF1, 0x18BEEA7A7A370F57,
+   0x037117CA50B99066, 0x6AB30A9774424A35, 0xF4E92F02E325249B,
+   0x7739DB07061CCAE1, 0xD8F3B49CECA42A05, 0xBD56BE3F51382F73,
+   0x45FAED5843B0BB28, 0x1C813D5C11BF1F83, 0x8AF0E4B6D75FA169,
+   0x33EE18A487AD9999, 0x3C26E8EAB1C94410, 0xB510102BC0A822F9,
+   0x141EEF310CE6123B, 0xFC65B90059DDB154, 0xE0158640C5E0E607,
+   0x884E079826C3A3CF, 0x930D0D9523C535FD, 0x35638D754E9A2B00,
+   0x4085FCCF40469DD5, 0xC4B17AD28BE23A4C, 0xCAB2F0FC6A3E6A2E,
+   0x2860971A6B943FCD, 0x3DDE6EE212E30446, 0x6222F32AE01765AE,
+   0x5D550BB5478308FE, 0xA9EFA98DA0EDA22A, 0xC351A71686C40DA7,
+   0x1105586D9C867C84, 0xDCFFEE85FDA22853, 0xCCFBD0262C5EEF76,
+   0xBAF294CB8990D201, 0xE69464F52AFAD975, 0x94B013AFDF133E14,
+   0x06A7D1A32823C958, 0x6F95FE5130F61119, 0xD92AB34E462C06C0,
+   0xED7BDE33887C71D2, 0x79746D6E6518393E, 0x5BA419385D713329,
+   0x7C1BA6B948A97564, 0x31987C197BFDAC67, 0xDE6C23C44B053D02,
+   0x581C49FED002D64D, 0xDD474D6338261571, 0xAA4546C3E473D062,
+   0x928FCE349455F860, 0x48161BBACAAB94D9, 0x63912430770E6F68,
+   0x6EC8A5E602C6641C, 0x87282515337DDD2B, 0x2CDA6B42034B701B,
+   0xB03D37C181CB096D, 0xE108438266C71C6F, 0x2B3180C7EB51B255,
+   0xDF92B82F96C08BBC, 0x5C68C8C0A632F3BA, 0x5504CC861C3D0556,
+   0xABBFA4E55FB26B8F, 0x41848B0AB3BACEB4, 0xB334A273AA445D32,
+   0xBCA696F0A85AD881, 0x24F6EC65B528D56C, 0x0CE1512E90F4524A,
+   0x4E9DD79D5506D35A, 0x258905FAC6CE9779, 0x2019295B3E109B33,
+   0xF8A9478B73A054CC, 0x2924F2F934417EB0, 0x3993357D536D1BC4,
+   0x38A81AC21DB6FF8B, 0x47C4FBF17D6016BF, 0x1E0FAADD7667E3F5,
+   0x7ABCFF62938BEB96, 0xA78DAD948FC179C9, 0x8F1F98B72911E50D,
+   0x61E48EAE27121A91, 0x4D62F7AD31859808, 0xECEBA345EF5CEAEB,
+   0xF5CEB25EBC9684CE, 0xF633E20CB7F76221, 0xA32CDF06AB8293E4,
+   0x985A202CA5EE2CA4, 0xCF0B8447CC8A8FB1, 0x9F765244979859A3,
+   0xA8D516B1A1240017, 0x0BD7BA3EBB5DC726, 0xE54BCA55B86ADB39,
+   0x1D7A3AFD6C478063, 0x519EC608E7669EDD, 0x0E5715A2D149AA23,
+   0x177D4571848FF194, 0xEEB55F3241014C22, 0x0F5E5CA13A6E2EC2,
+   0x8029927B75F5C361, 0xAD139FABC3D6E436, 0x0D5DF1A94CCF402F,
+   0x3E8BD948BEA5DFC8, 0xA5A0D357BD3FF77E, 0xA2D12E251F74F645,
+   0x66FD9E525E81A082, 0x2E0C90CE7F687A49, 0xC2E8BCBEBA973BC5,
+   0x000001BCE509745F, 0x423777BBE6DAB3D6, 0xD1661C7EAEF06EB5,
+   0xA1781F354DAACFD8, 0x2D11284A2B16AFFC, 0xF1FC4F67FA891D1F,
+   0x73ECC25DCB920ADA, 0xAE610C22C2A12651, 0x96E0A810D356B78A,
+   0x5A9A381F2FE7870F, 0xD5AD62EDE94E5530, 0xD225E5E8368D1427,
+   0x65977B70C7AF4631, 0x99F889B2DE39D74F, 0x233F30BF54E1D143,
+   0x9A9675D3D9A63C97, 0x5470554FF334F9A8, 0x166ACB744A4F5688,
+   0x70C74CAAB2E4AEAD, 0xF0D091646F294D12, 0x57B82A89684031D1,
+   0xEFD95A5A61BE0B6B, 0x2FBD12E969F2F29A, 0x9BD37013FEFF9FE8,
+   0x3F9B0404D6085A06, 0x4940C1F3166CFE15, 0x09542C4DCDF3DEFB,
+   0xB4C5218385CD5CE3, 0xC935B7DC4462A641, 0x3417F8A68ED3B63F,
+   0xB80959295B215B40, 0xF99CDAEF3B8C8572, 0x018C0614F8FCB95D,
+   0x1B14ACCD1A3ACDF3, 0x84D471F200BB732D, 0xC1A3110E95E8DA16,
+   0x430A7220BF1A82B8, 0xB77E090D39DF210E, 0x5EF4BD9F3CD05E9D,
+   0x9D4FF6DA7E57A444, 0xDA1D60E183D4A5F8, 0xB287C38417998E47,
+   0xFE3EDC121BB31886, 0xC7FE3CCC980CCBEF, 0xE46FB590189BFD03,
+   0x3732FD469A4C57DC, 0x7EF700A07CF1AD65, 0x59C64468A31D8859,
+   0x762FB0B4D45B61F6, 0x155BAED099047718, 0x68755E4C3D50BAA6,
+   0xE9214E7F22D8B4DF, 0x2ADDBF532EAC95F4, 0x32AE3909B4BD0109,
+   0x834DF537B08E3450, 0xFA209DA84220728D, 0x9E691D9B9EFE23F7,
+   0x0446D288C4AE8D7F, 0x7B4CC524E169785B, 0x21D87F0135CA1385,
+   0xCEBB400F137B8AA5, 0x272E2B66580796BE, 0x3612264125C2B0DE,
+   0x057702BDAD1EFBB2, 0xD4BABB8EACF84BE9, 0x91583139641BC67B,
+   0x8BDC2DE08036E024, 0x603C8156F49F68ED, 0xF7D236F7DBEF5111,
+   0x9727C4598AD21E80, 0xA08A0896670A5FD7, 0xCB4A8F4309EBA9CB,
+   0x81AF564B0F7036A1, 0xC0B99AA778199ABD, 0x959F1EC83FC8E952,
+   0x8C505077794A81B9, 0x3ACAAF8F056338F0, 0x07B43F50627A6778,
+   0x4A44AB49F5ECCC77, 0x3BC3D6E4B679EE98, 0x9CC0D4D1CF14108C,
+   0x4406C00B206BC8A0, 0x82A18854C8D72D89, 0x67E366B35C3C432C,
+   0xB923DD61102B37F2, 0x56AB2779D884271D, 0xBE83E1B0FF1525AF,
+   0xFB7C65D4217E49A9, 0x6BDBE0E76D48E7D4, 0x08DF828745D9179E,
+   0x22EA6A9ADD53BD34, 0xE36E141C5622200A, 0x7F805D1B8CB750EE,
+   0xAFE5C7A59F58E837, 0xE27F996A4FB1C23C, 0xD3867DFB0775F0D0,
+   0xD0E673DE6E88891A, 0x123AEB9EAFB86C25, 0x30F1D5D5C145B895,
+   0xBB434A2DEE7269E7, 0x78CB67ECF931FA38, 0xF33B0372323BBF9C,
+   0x52D66336FB279C74, 0x505F33AC0AFB4EAA, 0xE8A5CD99A2CCE187,
+   0x534974801E2D30BB, 0x8D2D5711D5876D90, 0x1F1A412891BC038E,
+   0xD6E2E71D82E56648, 0x74036C3A497732B7, 0x89B67ED96361F5AB,
+   0xFFED95D8F1EA02A2, 0xE72B3BD61464D43D, 0xA6300F170BDC4820,
+   0xEBC18760ED78A77A };
+
+const u64bit Tiger::SBOX2[256] = {
+   0xE6A6BE5A05A12138, 0xB5A122A5B4F87C98, 0x563C6089140B6990,
+   0x4C46CB2E391F5DD5, 0xD932ADDBC9B79434, 0x08EA70E42015AFF5,
+   0xD765A6673E478CF1, 0xC4FB757EAB278D99, 0xDF11C6862D6E0692,
+   0xDDEB84F10D7F3B16, 0x6F2EF604A665EA04, 0x4A8E0F0FF0E0DFB3,
+   0xA5EDEEF83DBCBA51, 0xFC4F0A2A0EA4371E, 0xE83E1DA85CB38429,
+   0xDC8FF882BA1B1CE2, 0xCD45505E8353E80D, 0x18D19A00D4DB0717,
+   0x34A0CFEDA5F38101, 0x0BE77E518887CAF2, 0x1E341438B3C45136,
+   0xE05797F49089CCF9, 0xFFD23F9DF2591D14, 0x543DDA228595C5CD,
+   0x661F81FD99052A33, 0x8736E641DB0F7B76, 0x15227725418E5307,
+   0xE25F7F46162EB2FA, 0x48A8B2126C13D9FE, 0xAFDC541792E76EEA,
+   0x03D912BFC6D1898F, 0x31B1AAFA1B83F51B, 0xF1AC2796E42AB7D9,
+   0x40A3A7D7FCD2EBAC, 0x1056136D0AFBBCC5, 0x7889E1DD9A6D0C85,
+   0xD33525782A7974AA, 0xA7E25D09078AC09B, 0xBD4138B3EAC6EDD0,
+   0x920ABFBE71EB9E70, 0xA2A5D0F54FC2625C, 0xC054E36B0B1290A3,
+   0xF6DD59FF62FE932B, 0x3537354511A8AC7D, 0xCA845E9172FADCD4,
+   0x84F82B60329D20DC, 0x79C62CE1CD672F18, 0x8B09A2ADD124642C,
+   0xD0C1E96A19D9E726, 0x5A786A9B4BA9500C, 0x0E020336634C43F3,
+   0xC17B474AEB66D822, 0x6A731AE3EC9BAAC2, 0x8226667AE0840258,
+   0x67D4567691CAECA5, 0x1D94155C4875ADB5, 0x6D00FD985B813FDF,
+   0x51286EFCB774CD06, 0x5E8834471FA744AF, 0xF72CA0AEE761AE2E,
+   0xBE40E4CDAEE8E09A, 0xE9970BBB5118F665, 0x726E4BEB33DF1964,
+   0x703B000729199762, 0x4631D816F5EF30A7, 0xB880B5B51504A6BE,
+   0x641793C37ED84B6C, 0x7B21ED77F6E97D96, 0x776306312EF96B73,
+   0xAE528948E86FF3F4, 0x53DBD7F286A3F8F8, 0x16CADCE74CFC1063,
+   0x005C19BDFA52C6DD, 0x68868F5D64D46AD3, 0x3A9D512CCF1E186A,
+   0x367E62C2385660AE, 0xE359E7EA77DCB1D7, 0x526C0773749ABE6E,
+   0x735AE5F9D09F734B, 0x493FC7CC8A558BA8, 0xB0B9C1533041AB45,
+   0x321958BA470A59BD, 0x852DB00B5F46C393, 0x91209B2BD336B0E5,
+   0x6E604F7D659EF19F, 0xB99A8AE2782CCB24, 0xCCF52AB6C814C4C7,
+   0x4727D9AFBE11727B, 0x7E950D0C0121B34D, 0x756F435670AD471F,
+   0xF5ADD442615A6849, 0x4E87E09980B9957A, 0x2ACFA1DF50AEE355,
+   0xD898263AFD2FD556, 0xC8F4924DD80C8FD6, 0xCF99CA3D754A173A,
+   0xFE477BACAF91BF3C, 0xED5371F6D690C12D, 0x831A5C285E687094,
+   0xC5D3C90A3708A0A4, 0x0F7F903717D06580, 0x19F9BB13B8FDF27F,
+   0xB1BD6F1B4D502843, 0x1C761BA38FFF4012, 0x0D1530C4E2E21F3B,
+   0x8943CE69A7372C8A, 0xE5184E11FEB5CE66, 0x618BDB80BD736621,
+   0x7D29BAD68B574D0B, 0x81BB613E25E6FE5B, 0x071C9C10BC07913F,
+   0xC7BEEB7909AC2D97, 0xC3E58D353BC5D757, 0xEB017892F38F61E8,
+   0xD4EFFB9C9B1CC21A, 0x99727D26F494F7AB, 0xA3E063A2956B3E03,
+   0x9D4A8B9A4AA09C30, 0x3F6AB7D500090FB4, 0x9CC0F2A057268AC0,
+   0x3DEE9D2DEDBF42D1, 0x330F49C87960A972, 0xC6B2720287421B41,
+   0x0AC59EC07C00369C, 0xEF4EAC49CB353425, 0xF450244EEF0129D8,
+   0x8ACC46E5CAF4DEB6, 0x2FFEAB63989263F7, 0x8F7CB9FE5D7A4578,
+   0x5BD8F7644E634635, 0x427A7315BF2DC900, 0x17D0C4AA2125261C,
+   0x3992486C93518E50, 0xB4CBFEE0A2D7D4C3, 0x7C75D6202C5DDD8D,
+   0xDBC295D8E35B6C61, 0x60B369D302032B19, 0xCE42685FDCE44132,
+   0x06F3DDB9DDF65610, 0x8EA4D21DB5E148F0, 0x20B0FCE62FCD496F,
+   0x2C1B912358B0EE31, 0xB28317B818F5A308, 0xA89C1E189CA6D2CF,
+   0x0C6B18576AAADBC8, 0xB65DEAA91299FAE3, 0xFB2B794B7F1027E7,
+   0x04E4317F443B5BEB, 0x4B852D325939D0A6, 0xD5AE6BEEFB207FFC,
+   0x309682B281C7D374, 0xBAE309A194C3B475, 0x8CC3F97B13B49F05,
+   0x98A9422FF8293967, 0x244B16B01076FF7C, 0xF8BF571C663D67EE,
+   0x1F0D6758EEE30DA1, 0xC9B611D97ADEB9B7, 0xB7AFD5887B6C57A2,
+   0x6290AE846B984FE1, 0x94DF4CDEACC1A5FD, 0x058A5BD1C5483AFF,
+   0x63166CC142BA3C37, 0x8DB8526EB2F76F40, 0xE10880036F0D6D4E,
+   0x9E0523C9971D311D, 0x45EC2824CC7CD691, 0x575B8359E62382C9,
+   0xFA9E400DC4889995, 0xD1823ECB45721568, 0xDAFD983B8206082F,
+   0xAA7D29082386A8CB, 0x269FCD4403B87588, 0x1B91F5F728BDD1E0,
+   0xE4669F39040201F6, 0x7A1D7C218CF04ADE, 0x65623C29D79CE5CE,
+   0x2368449096C00BB1, 0xAB9BF1879DA503BA, 0xBC23ECB1A458058E,
+   0x9A58DF01BB401ECC, 0xA070E868A85F143D, 0x4FF188307DF2239E,
+   0x14D565B41A641183, 0xEE13337452701602, 0x950E3DCF3F285E09,
+   0x59930254B9C80953, 0x3BF299408930DA6D, 0xA955943F53691387,
+   0xA15EDECAA9CB8784, 0x29142127352BE9A0, 0x76F0371FFF4E7AFB,
+   0x0239F450274F2228, 0xBB073AF01D5E868B, 0xBFC80571C10E96C1,
+   0xD267088568222E23, 0x9671A3D48E80B5B0, 0x55B5D38AE193BB81,
+   0x693AE2D0A18B04B8, 0x5C48B4ECADD5335F, 0xFD743B194916A1CA,
+   0x2577018134BE98C4, 0xE77987E83C54A4AD, 0x28E11014DA33E1B9,
+   0x270CC59E226AA213, 0x71495F756D1A5F60, 0x9BE853FB60AFEF77,
+   0xADC786A7F7443DBF, 0x0904456173B29A82, 0x58BC7A66C232BD5E,
+   0xF306558C673AC8B2, 0x41F639C6B6C9772A, 0x216DEFE99FDA35DA,
+   0x11640CC71C7BE615, 0x93C43694565C5527, 0xEA038E6246777839,
+   0xF9ABF3CE5A3E2469, 0x741E768D0FD312D2, 0x0144B883CED652C6,
+   0xC20B5A5BA33F8552, 0x1AE69633C3435A9D, 0x97A28CA4088CFDEC,
+   0x8824A43C1E96F420, 0x37612FA66EEEA746, 0x6B4CB165F9CF0E5A,
+   0x43AA1C06A0ABFB4A, 0x7F4DC26FF162796B, 0x6CBACC8E54ED9B0F,
+   0xA6B7FFEFD2BB253E, 0x2E25BC95B0A29D4F, 0x86D6A58BDEF1388C,
+   0xDED74AC576B6F054, 0x8030BDBC2B45805D, 0x3C81AF70E94D9289,
+   0x3EFF6DDA9E3100DB, 0xB38DC39FDFCC8847, 0x123885528D17B87E,
+   0xF2DA0ED240B1B642, 0x44CEFADCD54BF9A9, 0x1312200E433C7EE6,
+   0x9FFCC84F3A78C748, 0xF0CD1F72248576BB, 0xEC6974053638CFE4,
+   0x2BA7B67C0CEC4E4C, 0xAC2F4DF3E5CE32ED, 0xCB33D14326EA4C11,
+   0xA4E9044CC77E58BC, 0x5F513293D934FCEF, 0x5DC9645506E55444,
+   0x50DE418F317DE40A, 0x388CB31A69DDE259, 0x2DB4A83455820A86,
+   0x9010A91E84711AE9, 0x4DF7F0B7B1498371, 0xD62A2EABC0977179,
+   0x22FAC097AA8D5C0E };
+
+const u64bit Tiger::SBOX3[256] = {
+   0xF49FCC2FF1DAF39B, 0x487FD5C66FF29281, 0xE8A30667FCDCA83F,
+   0x2C9B4BE3D2FCCE63, 0xDA3FF74B93FBBBC2, 0x2FA165D2FE70BA66,
+   0xA103E279970E93D4, 0xBECDEC77B0E45E71, 0xCFB41E723985E497,
+   0xB70AAA025EF75017, 0xD42309F03840B8E0, 0x8EFC1AD035898579,
+   0x96C6920BE2B2ABC5, 0x66AF4163375A9172, 0x2174ABDCCA7127FB,
+   0xB33CCEA64A72FF41, 0xF04A4933083066A5, 0x8D970ACDD7289AF5,
+   0x8F96E8E031C8C25E, 0xF3FEC02276875D47, 0xEC7BF310056190DD,
+   0xF5ADB0AEBB0F1491, 0x9B50F8850FD58892, 0x4975488358B74DE8,
+   0xA3354FF691531C61, 0x0702BBE481D2C6EE, 0x89FB24057DEDED98,
+   0xAC3075138596E902, 0x1D2D3580172772ED, 0xEB738FC28E6BC30D,
+   0x5854EF8F63044326, 0x9E5C52325ADD3BBE, 0x90AA53CF325C4623,
+   0xC1D24D51349DD067, 0x2051CFEEA69EA624, 0x13220F0A862E7E4F,
+   0xCE39399404E04864, 0xD9C42CA47086FCB7, 0x685AD2238A03E7CC,
+   0x066484B2AB2FF1DB, 0xFE9D5D70EFBF79EC, 0x5B13B9DD9C481854,
+   0x15F0D475ED1509AD, 0x0BEBCD060EC79851, 0xD58C6791183AB7F8,
+   0xD1187C5052F3EEE4, 0xC95D1192E54E82FF, 0x86EEA14CB9AC6CA2,
+   0x3485BEB153677D5D, 0xDD191D781F8C492A, 0xF60866BAA784EBF9,
+   0x518F643BA2D08C74, 0x8852E956E1087C22, 0xA768CB8DC410AE8D,
+   0x38047726BFEC8E1A, 0xA67738B4CD3B45AA, 0xAD16691CEC0DDE19,
+   0xC6D4319380462E07, 0xC5A5876D0BA61938, 0x16B9FA1FA58FD840,
+   0x188AB1173CA74F18, 0xABDA2F98C99C021F, 0x3E0580AB134AE816,
+   0x5F3B05B773645ABB, 0x2501A2BE5575F2F6, 0x1B2F74004E7E8BA9,
+   0x1CD7580371E8D953, 0x7F6ED89562764E30, 0xB15926FF596F003D,
+   0x9F65293DA8C5D6B9, 0x6ECEF04DD690F84C, 0x4782275FFF33AF88,
+   0xE41433083F820801, 0xFD0DFE409A1AF9B5, 0x4325A3342CDB396B,
+   0x8AE77E62B301B252, 0xC36F9E9F6655615A, 0x85455A2D92D32C09,
+   0xF2C7DEA949477485, 0x63CFB4C133A39EBA, 0x83B040CC6EBC5462,
+   0x3B9454C8FDB326B0, 0x56F56A9E87FFD78C, 0x2DC2940D99F42BC6,
+   0x98F7DF096B096E2D, 0x19A6E01E3AD852BF, 0x42A99CCBDBD4B40B,
+   0xA59998AF45E9C559, 0x366295E807D93186, 0x6B48181BFAA1F773,
+   0x1FEC57E2157A0A1D, 0x4667446AF6201AD5, 0xE615EBCACFB0F075,
+   0xB8F31F4F68290778, 0x22713ED6CE22D11E, 0x3057C1A72EC3C93B,
+   0xCB46ACC37C3F1F2F, 0xDBB893FD02AAF50E, 0x331FD92E600B9FCF,
+   0xA498F96148EA3AD6, 0xA8D8426E8B6A83EA, 0xA089B274B7735CDC,
+   0x87F6B3731E524A11, 0x118808E5CBC96749, 0x9906E4C7B19BD394,
+   0xAFED7F7E9B24A20C, 0x6509EADEEB3644A7, 0x6C1EF1D3E8EF0EDE,
+   0xB9C97D43E9798FB4, 0xA2F2D784740C28A3, 0x7B8496476197566F,
+   0x7A5BE3E6B65F069D, 0xF96330ED78BE6F10, 0xEEE60DE77A076A15,
+   0x2B4BEE4AA08B9BD0, 0x6A56A63EC7B8894E, 0x02121359BA34FEF4,
+   0x4CBF99F8283703FC, 0x398071350CAF30C8, 0xD0A77A89F017687A,
+   0xF1C1A9EB9E423569, 0x8C7976282DEE8199, 0x5D1737A5DD1F7ABD,
+   0x4F53433C09A9FA80, 0xFA8B0C53DF7CA1D9, 0x3FD9DCBC886CCB77,
+   0xC040917CA91B4720, 0x7DD00142F9D1DCDF, 0x8476FC1D4F387B58,
+   0x23F8E7C5F3316503, 0x032A2244E7E37339, 0x5C87A5D750F5A74B,
+   0x082B4CC43698992E, 0xDF917BECB858F63C, 0x3270B8FC5BF86DDA,
+   0x10AE72BB29B5DD76, 0x576AC94E7700362B, 0x1AD112DAC61EFB8F,
+   0x691BC30EC5FAA427, 0xFF246311CC327143, 0x3142368E30E53206,
+   0x71380E31E02CA396, 0x958D5C960AAD76F1, 0xF8D6F430C16DA536,
+   0xC8FFD13F1BE7E1D2, 0x7578AE66004DDBE1, 0x05833F01067BE646,
+   0xBB34B5AD3BFE586D, 0x095F34C9A12B97F0, 0x247AB64525D60CA8,
+   0xDCDBC6F3017477D1, 0x4A2E14D4DECAD24D, 0xBDB5E6D9BE0A1EEB,
+   0x2A7E70F7794301AB, 0xDEF42D8A270540FD, 0x01078EC0A34C22C1,
+   0xE5DE511AF4C16387, 0x7EBB3A52BD9A330A, 0x77697857AA7D6435,
+   0x004E831603AE4C32, 0xE7A21020AD78E312, 0x9D41A70C6AB420F2,
+   0x28E06C18EA1141E6, 0xD2B28CBD984F6B28, 0x26B75F6C446E9D83,
+   0xBA47568C4D418D7F, 0xD80BADBFE6183D8E, 0x0E206D7F5F166044,
+   0xE258A43911CBCA3E, 0x723A1746B21DC0BC, 0xC7CAA854F5D7CDD3,
+   0x7CAC32883D261D9C, 0x7690C26423BA942C, 0x17E55524478042B8,
+   0xE0BE477656A2389F, 0x4D289B5E67AB2DA0, 0x44862B9C8FBBFD31,
+   0xB47CC8049D141365, 0x822C1B362B91C793, 0x4EB14655FB13DFD8,
+   0x1ECBBA0714E2A97B, 0x6143459D5CDE5F14, 0x53A8FBF1D5F0AC89,
+   0x97EA04D81C5E5B00, 0x622181A8D4FDB3F3, 0xE9BCD341572A1208,
+   0x1411258643CCE58A, 0x9144C5FEA4C6E0A4, 0x0D33D06565CF620F,
+   0x54A48D489F219CA1, 0xC43E5EAC6D63C821, 0xA9728B3A72770DAF,
+   0xD7934E7B20DF87EF, 0xE35503B61A3E86E5, 0xCAE321FBC819D504,
+   0x129A50B3AC60BFA6, 0xCD5E68EA7E9FB6C3, 0xB01C90199483B1C7,
+   0x3DE93CD5C295376C, 0xAED52EDF2AB9AD13, 0x2E60F512C0A07884,
+   0xBC3D86A3E36210C9, 0x35269D9B163951CE, 0x0C7D6E2AD0CDB5FA,
+   0x59E86297D87F5733, 0x298EF221898DB0E7, 0x55000029D1A5AA7E,
+   0x8BC08AE1B5061B45, 0xC2C31C2B6C92703A, 0x94CC596BAF25EF42,
+   0x0A1D73DB22540456, 0x04B6A0F9D9C4179A, 0xEFFDAFA2AE3D3C60,
+   0xF7C8075BB49496C4, 0x9CC5C7141D1CD4E3, 0x78BD1638218E5534,
+   0xB2F11568F850246A, 0xEDFABCFA9502BC29, 0x796CE5F2DA23051B,
+   0xAAE128B0DC93537C, 0x3A493DA0EE4B29AE, 0xB5DF6B2C416895D7,
+   0xFCABBD25122D7F37, 0x70810B58105DC4B1, 0xE10FDD37F7882A90,
+   0x524DCAB5518A3F5C, 0x3C9E85878451255B, 0x4029828119BD34E2,
+   0x74A05B6F5D3CECCB, 0xB610021542E13ECA, 0x0FF979D12F59E2AC,
+   0x6037DA27E4F9CC50, 0x5E92975A0DF1847D, 0xD66DE190D3E623FE,
+   0x5032D6B87B568048, 0x9A36B7CE8235216E, 0x80272A7A24F64B4A,
+   0x93EFED8B8C6916F7, 0x37DDBFF44CCE1555, 0x4B95DB5D4B99BD25,
+   0x92D3FDA169812FC0, 0xFB1A4A9A90660BB6, 0x730C196946A4B9B2,
+   0x81E289AA7F49DA68, 0x64669A0F83B1A05F, 0x27B3FF7D9644F48B,
+   0xCC6B615C8DB675B3, 0x674F20B9BCEBBE95, 0x6F31238275655982,
+   0x5AE488713E45CF05, 0xBF619F9954C21157, 0xEABAC46040A8EAE9,
+   0x454C6FE9F2C0C1CD, 0x419CF6496412691C, 0xD3DC3BEF265B0F70,
+   0x6D0E60F5C3578A9E };
+
+const u64bit Tiger::SBOX4[256] = {
+   0x5B0E608526323C55, 0x1A46C1A9FA1B59F5, 0xA9E245A17C4C8FFA,
+   0x65CA5159DB2955D7, 0x05DB0A76CE35AFC2, 0x81EAC77EA9113D45,
+   0x528EF88AB6AC0A0D, 0xA09EA253597BE3FF, 0x430DDFB3AC48CD56,
+   0xC4B3A67AF45CE46F, 0x4ECECFD8FBE2D05E, 0x3EF56F10B39935F0,
+   0x0B22D6829CD619C6, 0x17FD460A74DF2069, 0x6CF8CC8E8510ED40,
+   0xD6C824BF3A6ECAA7, 0x61243D581A817049, 0x048BACB6BBC163A2,
+   0xD9A38AC27D44CC32, 0x7FDDFF5BAAF410AB, 0xAD6D495AA804824B,
+   0xE1A6A74F2D8C9F94, 0xD4F7851235DEE8E3, 0xFD4B7F886540D893,
+   0x247C20042AA4BFDA, 0x096EA1C517D1327C, 0xD56966B4361A6685,
+   0x277DA5C31221057D, 0x94D59893A43ACFF7, 0x64F0C51CCDC02281,
+   0x3D33BCC4FF6189DB, 0xE005CB184CE66AF1, 0xFF5CCD1D1DB99BEA,
+   0xB0B854A7FE42980F, 0x7BD46A6A718D4B9F, 0xD10FA8CC22A5FD8C,
+   0xD31484952BE4BD31, 0xC7FA975FCB243847, 0x4886ED1E5846C407,
+   0x28CDDB791EB70B04, 0xC2B00BE2F573417F, 0x5C9590452180F877,
+   0x7A6BDDFFF370EB00, 0xCE509E38D6D9D6A4, 0xEBEB0F00647FA702,
+   0x1DCC06CF76606F06, 0xE4D9F28BA286FF0A, 0xD85A305DC918C262,
+   0x475B1D8732225F54, 0x2D4FB51668CCB5FE, 0xA679B9D9D72BBA20,
+   0x53841C0D912D43A5, 0x3B7EAA48BF12A4E8, 0x781E0E47F22F1DDF,
+   0xEFF20CE60AB50973, 0x20D261D19DFFB742, 0x16A12B03062A2E39,
+   0x1960EB2239650495, 0x251C16FED50EB8B8, 0x9AC0C330F826016E,
+   0xED152665953E7671, 0x02D63194A6369570, 0x5074F08394B1C987,
+   0x70BA598C90B25CE1, 0x794A15810B9742F6, 0x0D5925E9FCAF8C6C,
+   0x3067716CD868744E, 0x910AB077E8D7731B, 0x6A61BBDB5AC42F61,
+   0x93513EFBF0851567, 0xF494724B9E83E9D5, 0xE887E1985C09648D,
+   0x34B1D3C675370CFD, 0xDC35E433BC0D255D, 0xD0AAB84234131BE0,
+   0x08042A50B48B7EAF, 0x9997C4EE44A3AB35, 0x829A7B49201799D0,
+   0x263B8307B7C54441, 0x752F95F4FD6A6CA6, 0x927217402C08C6E5,
+   0x2A8AB754A795D9EE, 0xA442F7552F72943D, 0x2C31334E19781208,
+   0x4FA98D7CEAEE6291, 0x55C3862F665DB309, 0xBD0610175D53B1F3,
+   0x46FE6CB840413F27, 0x3FE03792DF0CFA59, 0xCFE700372EB85E8F,
+   0xA7BE29E7ADBCE118, 0xE544EE5CDE8431DD, 0x8A781B1B41F1873E,
+   0xA5C94C78A0D2F0E7, 0x39412E2877B60728, 0xA1265EF3AFC9A62C,
+   0xBCC2770C6A2506C5, 0x3AB66DD5DCE1CE12, 0xE65499D04A675B37,
+   0x7D8F523481BFD216, 0x0F6F64FCEC15F389, 0x74EFBE618B5B13C8,
+   0xACDC82B714273E1D, 0xDD40BFE003199D17, 0x37E99257E7E061F8,
+   0xFA52626904775AAA, 0x8BBBF63A463D56F9, 0xF0013F1543A26E64,
+   0xA8307E9F879EC898, 0xCC4C27A4150177CC, 0x1B432F2CCA1D3348,
+   0xDE1D1F8F9F6FA013, 0x606602A047A7DDD6, 0xD237AB64CC1CB2C7,
+   0x9B938E7225FCD1D3, 0xEC4E03708E0FF476, 0xFEB2FBDA3D03C12D,
+   0xAE0BCED2EE43889A, 0x22CB8923EBFB4F43, 0x69360D013CF7396D,
+   0x855E3602D2D4E022, 0x073805BAD01F784C, 0x33E17A133852F546,
+   0xDF4874058AC7B638, 0xBA92B29C678AA14A, 0x0CE89FC76CFAADCD,
+   0x5F9D4E0908339E34, 0xF1AFE9291F5923B9, 0x6E3480F60F4A265F,
+   0xEEBF3A2AB29B841C, 0xE21938A88F91B4AD, 0x57DFEFF845C6D3C3,
+   0x2F006B0BF62CAAF2, 0x62F479EF6F75EE78, 0x11A55AD41C8916A9,
+   0xF229D29084FED453, 0x42F1C27B16B000E6, 0x2B1F76749823C074,
+   0x4B76ECA3C2745360, 0x8C98F463B91691BD, 0x14BCC93CF1ADE66A,
+   0x8885213E6D458397, 0x8E177DF0274D4711, 0xB49B73B5503F2951,
+   0x10168168C3F96B6B, 0x0E3D963B63CAB0AE, 0x8DFC4B5655A1DB14,
+   0xF789F1356E14DE5C, 0x683E68AF4E51DAC1, 0xC9A84F9D8D4B0FD9,
+   0x3691E03F52A0F9D1, 0x5ED86E46E1878E80, 0x3C711A0E99D07150,
+   0x5A0865B20C4E9310, 0x56FBFC1FE4F0682E, 0xEA8D5DE3105EDF9B,
+   0x71ABFDB12379187A, 0x2EB99DE1BEE77B9C, 0x21ECC0EA33CF4523,
+   0x59A4D7521805C7A1, 0x3896F5EB56AE7C72, 0xAA638F3DB18F75DC,
+   0x9F39358DABE9808E, 0xB7DEFA91C00B72AC, 0x6B5541FD62492D92,
+   0x6DC6DEE8F92E4D5B, 0x353F57ABC4BEEA7E, 0x735769D6DA5690CE,
+   0x0A234AA642391484, 0xF6F9508028F80D9D, 0xB8E319A27AB3F215,
+   0x31AD9C1151341A4D, 0x773C22A57BEF5805, 0x45C7561A07968633,
+   0xF913DA9E249DBE36, 0xDA652D9B78A64C68, 0x4C27A97F3BC334EF,
+   0x76621220E66B17F4, 0x967743899ACD7D0B, 0xF3EE5BCAE0ED6782,
+   0x409F753600C879FC, 0x06D09A39B5926DB6, 0x6F83AEB0317AC588,
+   0x01E6CA4A86381F21, 0x66FF3462D19F3025, 0x72207C24DDFD3BFB,
+   0x4AF6B6D3E2ECE2EB, 0x9C994DBEC7EA08DE, 0x49ACE597B09A8BC4,
+   0xB38C4766CF0797BA, 0x131B9373C57C2A75, 0xB1822CCE61931E58,
+   0x9D7555B909BA1C0C, 0x127FAFDD937D11D2, 0x29DA3BADC66D92E4,
+   0xA2C1D57154C2ECBC, 0x58C5134D82F6FE24, 0x1C3AE3515B62274F,
+   0xE907C82E01CB8126, 0xF8ED091913E37FCB, 0x3249D8F9C80046C9,
+   0x80CF9BEDE388FB63, 0x1881539A116CF19E, 0x5103F3F76BD52457,
+   0x15B7E6F5AE47F7A8, 0xDBD7C6DED47E9CCF, 0x44E55C410228BB1A,
+   0xB647D4255EDB4E99, 0x5D11882BB8AAFC30, 0xF5098BBB29D3212A,
+   0x8FB5EA14E90296B3, 0x677B942157DD025A, 0xFB58E7C0A390ACB5,
+   0x89D3674C83BD4A01, 0x9E2DA4DF4BF3B93B, 0xFCC41E328CAB4829,
+   0x03F38C96BA582C52, 0xCAD1BDBD7FD85DB2, 0xBBB442C16082AE83,
+   0xB95FE86BA5DA9AB0, 0xB22E04673771A93F, 0x845358C9493152D8,
+   0xBE2A488697B4541E, 0x95A2DC2DD38E6966, 0xC02C11AC923C852B,
+   0x2388B1990DF2A87B, 0x7C8008FA1B4F37BE, 0x1F70D0C84D54E503,
+   0x5490ADEC7ECE57D4, 0x002B3C27D9063A3A, 0x7EAEA3848030A2BF,
+   0xC602326DED2003C0, 0x83A7287D69A94086, 0xC57A5FCB30F57A8A,
+   0xB56844E479EBE779, 0xA373B40F05DCBCE9, 0xD71A786E88570EE2,
+   0x879CBACDBDE8F6A0, 0x976AD1BCC164A32F, 0xAB21E25E9666D78B,
+   0x901063AAE5E5C33C, 0x9818B34448698D90, 0xE36487AE3E1E8ABB,
+   0xAFBDF931893BDCB4, 0x6345A0DC5FBBD519, 0x8628FE269B9465CA,
+   0x1E5D01603F9C51EC, 0x4DE44006A15049B7, 0xBF6C70E5F776CBB1,
+   0x411218F2EF552BED, 0xCB0C0708705A36A3, 0xE74D14754F986044,
+   0xCD56D9430EA8280E, 0xC12591D7535F5065, 0xC83223F1720AEF96,
+   0xC3A0396F7363A51F };
+
+}
diff --git a/src/hash/tiger/tiger.cpp b/src/hash/tiger/tiger.cpp
new file mode 100644
index 000000000..78bba0521
--- /dev/null
+++ b/src/hash/tiger/tiger.cpp
@@ -0,0 +1,155 @@
+/*************************************************
+* Tiger Source File                              *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/tiger.h>
+#include <botan/loadstor.h>
+#include <botan/parsing.h>
+
+namespace Botan {
+
+/*************************************************
+* Tiger Compression Function                     *
+*************************************************/
+void Tiger::hash(const byte input[])
+   {
+   for(u32bit j = 0; j != 8; ++j)
+      X[j] = load_le<u64bit>(input, j);
+
+   u64bit A = digest[0], B = digest[1], C = digest[2];
+
+   pass(A, B, C, X, 5); mix(X);
+   pass(C, A, B, X, 7); mix(X);
+   pass(B, C, A, X, 9);
+
+   for(u32bit j = 3; j != PASS; ++j)
+      {
+      mix(X);
+      pass(A, B, C, X, 9);
+      u64bit T = A; A = C; C = B; B = T;
+      }
+
+   digest[0] ^= A; digest[1] = B - digest[1]; digest[2] += C;
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void Tiger::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; ++j)
+      output[j] = get_byte(7 - (j % 8), digest[j/8]);
+   }
+
+/*************************************************
+* Tiger Pass                                     *
+*************************************************/
+void Tiger::pass(u64bit& A, u64bit& B, u64bit& C, u64bit X[8], byte mul)
+   {
+   C ^= X[0];
+   A -= SBOX1[get_byte(7, C)] ^ SBOX2[get_byte(5, C)] ^
+        SBOX3[get_byte(3, C)] ^ SBOX4[get_byte(1, C)];
+   B += SBOX1[get_byte(0, C)] ^ SBOX2[get_byte(2, C)] ^
+        SBOX3[get_byte(4, C)] ^ SBOX4[get_byte(6, C)];
+   B *= mul;
+
+   A ^= X[1];
+   B -= SBOX1[get_byte(7, A)] ^ SBOX2[get_byte(5, A)] ^
+        SBOX3[get_byte(3, A)] ^ SBOX4[get_byte(1, A)];
+   C += SBOX1[get_byte(0, A)] ^ SBOX2[get_byte(2, A)] ^
+        SBOX3[get_byte(4, A)] ^ SBOX4[get_byte(6, A)];
+   C *= mul;
+
+   B ^= X[2];
+   C -= SBOX1[get_byte(7, B)] ^ SBOX2[get_byte(5, B)] ^
+        SBOX3[get_byte(3, B)] ^ SBOX4[get_byte(1, B)];
+   A += SBOX1[get_byte(0, B)] ^ SBOX2[get_byte(2, B)] ^
+        SBOX3[get_byte(4, B)] ^ SBOX4[get_byte(6, B)];
+   A *= mul;
+
+   C ^= X[3];
+   A -= SBOX1[get_byte(7, C)] ^ SBOX2[get_byte(5, C)] ^
+        SBOX3[get_byte(3, C)] ^ SBOX4[get_byte(1, C)];
+   B += SBOX1[get_byte(0, C)] ^ SBOX2[get_byte(2, C)] ^
+        SBOX3[get_byte(4, C)] ^ SBOX4[get_byte(6, C)];
+   B *= mul;
+
+   A ^= X[4];
+   B -= SBOX1[get_byte(7, A)] ^ SBOX2[get_byte(5, A)] ^
+        SBOX3[get_byte(3, A)] ^ SBOX4[get_byte(1, A)];
+   C += SBOX1[get_byte(0, A)] ^ SBOX2[get_byte(2, A)] ^
+        SBOX3[get_byte(4, A)] ^ SBOX4[get_byte(6, A)];
+   C *= mul;
+
+   B ^= X[5];
+   C -= SBOX1[get_byte(7, B)] ^ SBOX2[get_byte(5, B)] ^
+        SBOX3[get_byte(3, B)] ^ SBOX4[get_byte(1, B)];
+   A += SBOX1[get_byte(0, B)] ^ SBOX2[get_byte(2, B)] ^
+        SBOX3[get_byte(4, B)] ^ SBOX4[get_byte(6, B)];
+   A *= mul;
+
+   C ^= X[6];
+   A -= SBOX1[get_byte(7, C)] ^ SBOX2[get_byte(5, C)] ^
+        SBOX3[get_byte(3, C)] ^ SBOX4[get_byte(1, C)];
+   B += SBOX1[get_byte(0, C)] ^ SBOX2[get_byte(2, C)] ^
+        SBOX3[get_byte(4, C)] ^ SBOX4[get_byte(6, C)];
+   B *= mul;
+
+   A ^= X[7];
+   B -= SBOX1[get_byte(7, A)] ^ SBOX2[get_byte(5, A)] ^
+        SBOX3[get_byte(3, A)] ^ SBOX4[get_byte(1, A)];
+   C += SBOX1[get_byte(0, A)] ^ SBOX2[get_byte(2, A)] ^
+        SBOX3[get_byte(4, A)] ^ SBOX4[get_byte(6, A)];
+   C *= mul;
+   }
+
+/*************************************************
+* Tiger Mixing Function                          *
+*************************************************/
+void Tiger::mix(u64bit X[8])
+   {
+   X[0] -= X[7] ^ 0xA5A5A5A5A5A5A5A5; X[1] ^= X[0];
+   X[2] += X[1]; X[3] -= X[2] ^ ((~X[1]) << 19); X[4] ^= X[3];
+   X[5] += X[4]; X[6] -= X[5] ^ ((~X[4]) >> 23); X[7] ^= X[6];
+   X[0] += X[7]; X[1] -= X[0] ^ ((~X[7]) << 19); X[2] ^= X[1];
+   X[3] += X[2]; X[4] -= X[3] ^ ((~X[2]) >> 23); X[5] ^= X[4];
+   X[6] += X[5]; X[7] -= X[6] ^ 0x0123456789ABCDEF;
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void Tiger::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   X.clear();
+   digest[0] = 0x0123456789ABCDEF;
+   digest[1] = 0xFEDCBA9876543210;
+   digest[2] = 0xF096A5B4C3B2E187;
+   }
+
+/*************************************************
+* Return the name of this type                   *
+*************************************************/
+std::string Tiger::name() const
+   {
+   return "Tiger(" + to_string(OUTPUT_LENGTH) + "," + to_string(PASS) + ")";
+   }
+
+/*************************************************
+* Tiger Constructor                              *
+*************************************************/
+Tiger::Tiger(u32bit hashlen, u32bit pass) :
+   MDx_HashFunction(hashlen, 64, false, false), PASS(pass)
+   {
+   if(OUTPUT_LENGTH != 16 && OUTPUT_LENGTH != 20 && OUTPUT_LENGTH != 24)
+      throw Invalid_Argument("Tiger: Illegal hash output size: " +
+                             to_string(OUTPUT_LENGTH));
+   if(PASS < 3)
+      throw Invalid_Argument("Tiger: Invalid number of passes: "
+                             + to_string(PASS));
+   clear();
+   }
+
+}
diff --git a/src/hash/tiger/tiger.h b/src/hash/tiger/tiger.h
new file mode 100644
index 000000000..4c95fa784
--- /dev/null
+++ b/src/hash/tiger/tiger.h
@@ -0,0 +1,42 @@
+/*************************************************
+* Tiger Header File                              *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_TIGER_H__
+#define BOTAN_TIGER_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* Tiger                                          *
+*************************************************/
+class BOTAN_DLL Tiger : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const;
+      HashFunction* clone() const { return new Tiger(OUTPUT_LENGTH); }
+      Tiger(u32bit = 24, u32bit = 3);
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      static void pass(u64bit&, u64bit&, u64bit&, u64bit[8], byte);
+      static void mix(u64bit[8]);
+
+      static const u64bit SBOX1[256];
+      static const u64bit SBOX2[256];
+      static const u64bit SBOX3[256];
+      static const u64bit SBOX4[256];
+
+      SecureBuffer<u64bit, 8> X;
+      SecureBuffer<u64bit, 3> digest;
+      const u32bit PASS;
+   };
+
+}
+
+#endif
diff --git a/src/hash/whirlpool/modinfo.txt b/src/hash/whirlpool/modinfo.txt
new file mode 100644
index 000000000..9d069efee
--- /dev/null
+++ b/src/hash/whirlpool/modinfo.txt
@@ -0,0 +1,11 @@
+realname "Whirlpool"
+
+define WHIRLPOOL
+
+load_on auto
+
+<add>
+whrl_tab.cpp
+whrlpool.cpp
+whrlpool.h
+</add>
diff --git a/src/hash/whirlpool/whrl_tab.cpp b/src/hash/whirlpool/whrl_tab.cpp
new file mode 100644
index 000000000..bd616ca27
--- /dev/null
+++ b/src/hash/whirlpool/whrl_tab.cpp
@@ -0,0 +1,538 @@
+/*************************************************
+* Diffusion Tables for Whirlpool                 *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/whrlpool.h>
+
+namespace Botan {
+
+const u64bit Whirlpool::C0[256] = {
+0x18186018C07830D8, 0x23238C2305AF4626, 0xC6C63FC67EF991B8, 0xE8E887E8136FCDFB,
+0x878726874CA113CB, 0xB8B8DAB8A9626D11, 0x0101040108050209, 0x4F4F214F426E9E0D,
+0x3636D836ADEE6C9B, 0xA6A6A2A6590451FF, 0xD2D26FD2DEBDB90C, 0xF5F5F3F5FB06F70E,
+0x7979F979EF80F296, 0x6F6FA16F5FCEDE30, 0x91917E91FCEF3F6D, 0x52525552AA07A4F8,
+0x60609D6027FDC047, 0xBCBCCABC89766535, 0x9B9B569BACCD2B37, 0x8E8E028E048C018A,
+0xA3A3B6A371155BD2, 0x0C0C300C603C186C, 0x7B7BF17BFF8AF684, 0x3535D435B5E16A80,
+0x1D1D741DE8693AF5, 0xE0E0A7E05347DDB3, 0xD7D77BD7F6ACB321, 0xC2C22FC25EED999C,
+0x2E2EB82E6D965C43, 0x4B4B314B627A9629, 0xFEFEDFFEA321E15D, 0x575741578216AED5,
+0x15155415A8412ABD, 0x7777C1779FB6EEE8, 0x3737DC37A5EB6E92, 0xE5E5B3E57B56D79E,
+0x9F9F469F8CD92313, 0xF0F0E7F0D317FD23, 0x4A4A354A6A7F9420, 0xDADA4FDA9E95A944,
+0x58587D58FA25B0A2, 0xC9C903C906CA8FCF, 0x2929A429558D527C, 0x0A0A280A5022145A,
+0xB1B1FEB1E14F7F50, 0xA0A0BAA0691A5DC9, 0x6B6BB16B7FDAD614, 0x85852E855CAB17D9,
+0xBDBDCEBD8173673C, 0x5D5D695DD234BA8F, 0x1010401080502090, 0xF4F4F7F4F303F507,
+0xCBCB0BCB16C08BDD, 0x3E3EF83EEDC67CD3, 0x0505140528110A2D, 0x676781671FE6CE78,
+0xE4E4B7E47353D597, 0x27279C2725BB4E02, 0x4141194132588273, 0x8B8B168B2C9D0BA7,
+0xA7A7A6A7510153F6, 0x7D7DE97DCF94FAB2, 0x95956E95DCFB3749, 0xD8D847D88E9FAD56,
+0xFBFBCBFB8B30EB70, 0xEEEE9FEE2371C1CD, 0x7C7CED7CC791F8BB, 0x6666856617E3CC71,
+0xDDDD53DDA68EA77B, 0x17175C17B84B2EAF, 0x4747014702468E45, 0x9E9E429E84DC211A,
+0xCACA0FCA1EC589D4, 0x2D2DB42D75995A58, 0xBFBFC6BF9179632E, 0x07071C07381B0E3F,
+0xADAD8EAD012347AC, 0x5A5A755AEA2FB4B0, 0x838336836CB51BEF, 0x3333CC3385FF66B6,
+0x636391633FF2C65C, 0x02020802100A0412, 0xAAAA92AA39384993, 0x7171D971AFA8E2DE,
+0xC8C807C80ECF8DC6, 0x19196419C87D32D1, 0x494939497270923B, 0xD9D943D9869AAF5F,
+0xF2F2EFF2C31DF931, 0xE3E3ABE34B48DBA8, 0x5B5B715BE22AB6B9, 0x88881A8834920DBC,
+0x9A9A529AA4C8293E, 0x262698262DBE4C0B, 0x3232C8328DFA64BF, 0xB0B0FAB0E94A7D59,
+0xE9E983E91B6ACFF2, 0x0F0F3C0F78331E77, 0xD5D573D5E6A6B733, 0x80803A8074BA1DF4,
+0xBEBEC2BE997C6127, 0xCDCD13CD26DE87EB, 0x3434D034BDE46889, 0x48483D487A759032,
+0xFFFFDBFFAB24E354, 0x7A7AF57AF78FF48D, 0x90907A90F4EA3D64, 0x5F5F615FC23EBE9D,
+0x202080201DA0403D, 0x6868BD6867D5D00F, 0x1A1A681AD07234CA, 0xAEAE82AE192C41B7,
+0xB4B4EAB4C95E757D, 0x54544D549A19A8CE, 0x93937693ECE53B7F, 0x222288220DAA442F,
+0x64648D6407E9C863, 0xF1F1E3F1DB12FF2A, 0x7373D173BFA2E6CC, 0x12124812905A2482,
+0x40401D403A5D807A, 0x0808200840281048, 0xC3C32BC356E89B95, 0xECEC97EC337BC5DF,
+0xDBDB4BDB9690AB4D, 0xA1A1BEA1611F5FC0, 0x8D8D0E8D1C830791, 0x3D3DF43DF5C97AC8,
+0x97976697CCF1335B, 0x0000000000000000, 0xCFCF1BCF36D483F9, 0x2B2BAC2B4587566E,
+0x7676C57697B3ECE1, 0x8282328264B019E6, 0xD6D67FD6FEA9B128, 0x1B1B6C1BD87736C3,
+0xB5B5EEB5C15B7774, 0xAFAF86AF112943BE, 0x6A6AB56A77DFD41D, 0x50505D50BA0DA0EA,
+0x45450945124C8A57, 0xF3F3EBF3CB18FB38, 0x3030C0309DF060AD, 0xEFEF9BEF2B74C3C4,
+0x3F3FFC3FE5C37EDA, 0x55554955921CAAC7, 0xA2A2B2A2791059DB, 0xEAEA8FEA0365C9E9,
+0x656589650FECCA6A, 0xBABAD2BAB9686903, 0x2F2FBC2F65935E4A, 0xC0C027C04EE79D8E,
+0xDEDE5FDEBE81A160, 0x1C1C701CE06C38FC, 0xFDFDD3FDBB2EE746, 0x4D4D294D52649A1F,
+0x92927292E4E03976, 0x7575C9758FBCEAFA, 0x06061806301E0C36, 0x8A8A128A249809AE,
+0xB2B2F2B2F940794B, 0xE6E6BFE66359D185, 0x0E0E380E70361C7E, 0x1F1F7C1FF8633EE7,
+0x6262956237F7C455, 0xD4D477D4EEA3B53A, 0xA8A89AA829324D81, 0x96966296C4F43152,
+0xF9F9C3F99B3AEF62, 0xC5C533C566F697A3, 0x2525942535B14A10, 0x59597959F220B2AB,
+0x84842A8454AE15D0, 0x7272D572B7A7E4C5, 0x3939E439D5DD72EC, 0x4C4C2D4C5A619816,
+0x5E5E655ECA3BBC94, 0x7878FD78E785F09F, 0x3838E038DDD870E5, 0x8C8C0A8C14860598,
+0xD1D163D1C6B2BF17, 0xA5A5AEA5410B57E4, 0xE2E2AFE2434DD9A1, 0x616199612FF8C24E,
+0xB3B3F6B3F1457B42, 0x2121842115A54234, 0x9C9C4A9C94D62508, 0x1E1E781EF0663CEE,
+0x4343114322528661, 0xC7C73BC776FC93B1, 0xFCFCD7FCB32BE54F, 0x0404100420140824,
+0x51515951B208A2E3, 0x99995E99BCC72F25, 0x6D6DA96D4FC4DA22, 0x0D0D340D68391A65,
+0xFAFACFFA8335E979, 0xDFDF5BDFB684A369, 0x7E7EE57ED79BFCA9, 0x242490243DB44819,
+0x3B3BEC3BC5D776FE, 0xABAB96AB313D4B9A, 0xCECE1FCE3ED181F0, 0x1111441188552299,
+0x8F8F068F0C890383, 0x4E4E254E4A6B9C04, 0xB7B7E6B7D1517366, 0xEBEB8BEB0B60CBE0,
+0x3C3CF03CFDCC78C1, 0x81813E817CBF1FFD, 0x94946A94D4FE3540, 0xF7F7FBF7EB0CF31C,
+0xB9B9DEB9A1676F18, 0x13134C13985F268B, 0x2C2CB02C7D9C5851, 0xD3D36BD3D6B8BB05,
+0xE7E7BBE76B5CD38C, 0x6E6EA56E57CBDC39, 0xC4C437C46EF395AA, 0x03030C03180F061B,
+0x565645568A13ACDC, 0x44440D441A49885E, 0x7F7FE17FDF9EFEA0, 0xA9A99EA921374F88,
+0x2A2AA82A4D825467, 0xBBBBD6BBB16D6B0A, 0xC1C123C146E29F87, 0x53535153A202A6F1,
+0xDCDC57DCAE8BA572, 0x0B0B2C0B58271653, 0x9D9D4E9D9CD32701, 0x6C6CAD6C47C1D82B,
+0x3131C43195F562A4, 0x7474CD7487B9E8F3, 0xF6F6FFF6E309F115, 0x464605460A438C4C,
+0xACAC8AAC092645A5, 0x89891E893C970FB5, 0x14145014A04428B4, 0xE1E1A3E15B42DFBA,
+0x16165816B04E2CA6, 0x3A3AE83ACDD274F7, 0x6969B9696FD0D206, 0x09092409482D1241,
+0x7070DD70A7ADE0D7, 0xB6B6E2B6D954716F, 0xD0D067D0CEB7BD1E, 0xEDED93ED3B7EC7D6,
+0xCCCC17CC2EDB85E2, 0x424215422A578468, 0x98985A98B4C22D2C, 0xA4A4AAA4490E55ED,
+0x2828A0285D885075, 0x5C5C6D5CDA31B886, 0xF8F8C7F8933FED6B, 0x8686228644A411C2 };
+
+const u64bit Whirlpool::C1[256] = {
+0xD818186018C07830, 0x2623238C2305AF46, 0xB8C6C63FC67EF991, 0xFBE8E887E8136FCD,
+0xCB878726874CA113, 0x11B8B8DAB8A9626D, 0x0901010401080502, 0x0D4F4F214F426E9E,
+0x9B3636D836ADEE6C, 0xFFA6A6A2A6590451, 0x0CD2D26FD2DEBDB9, 0x0EF5F5F3F5FB06F7,
+0x967979F979EF80F2, 0x306F6FA16F5FCEDE, 0x6D91917E91FCEF3F, 0xF852525552AA07A4,
+0x4760609D6027FDC0, 0x35BCBCCABC897665, 0x379B9B569BACCD2B, 0x8A8E8E028E048C01,
+0xD2A3A3B6A371155B, 0x6C0C0C300C603C18, 0x847B7BF17BFF8AF6, 0x803535D435B5E16A,
+0xF51D1D741DE8693A, 0xB3E0E0A7E05347DD, 0x21D7D77BD7F6ACB3, 0x9CC2C22FC25EED99,
+0x432E2EB82E6D965C, 0x294B4B314B627A96, 0x5DFEFEDFFEA321E1, 0xD5575741578216AE,
+0xBD15155415A8412A, 0xE87777C1779FB6EE, 0x923737DC37A5EB6E, 0x9EE5E5B3E57B56D7,
+0x139F9F469F8CD923, 0x23F0F0E7F0D317FD, 0x204A4A354A6A7F94, 0x44DADA4FDA9E95A9,
+0xA258587D58FA25B0, 0xCFC9C903C906CA8F, 0x7C2929A429558D52, 0x5A0A0A280A502214,
+0x50B1B1FEB1E14F7F, 0xC9A0A0BAA0691A5D, 0x146B6BB16B7FDAD6, 0xD985852E855CAB17,
+0x3CBDBDCEBD817367, 0x8F5D5D695DD234BA, 0x9010104010805020, 0x07F4F4F7F4F303F5,
+0xDDCBCB0BCB16C08B, 0xD33E3EF83EEDC67C, 0x2D0505140528110A, 0x78676781671FE6CE,
+0x97E4E4B7E47353D5, 0x0227279C2725BB4E, 0x7341411941325882, 0xA78B8B168B2C9D0B,
+0xF6A7A7A6A7510153, 0xB27D7DE97DCF94FA, 0x4995956E95DCFB37, 0x56D8D847D88E9FAD,
+0x70FBFBCBFB8B30EB, 0xCDEEEE9FEE2371C1, 0xBB7C7CED7CC791F8, 0x716666856617E3CC,
+0x7BDDDD53DDA68EA7, 0xAF17175C17B84B2E, 0x454747014702468E, 0x1A9E9E429E84DC21,
+0xD4CACA0FCA1EC589, 0x582D2DB42D75995A, 0x2EBFBFC6BF917963, 0x3F07071C07381B0E,
+0xACADAD8EAD012347, 0xB05A5A755AEA2FB4, 0xEF838336836CB51B, 0xB63333CC3385FF66,
+0x5C636391633FF2C6, 0x1202020802100A04, 0x93AAAA92AA393849, 0xDE7171D971AFA8E2,
+0xC6C8C807C80ECF8D, 0xD119196419C87D32, 0x3B49493949727092, 0x5FD9D943D9869AAF,
+0x31F2F2EFF2C31DF9, 0xA8E3E3ABE34B48DB, 0xB95B5B715BE22AB6, 0xBC88881A8834920D,
+0x3E9A9A529AA4C829, 0x0B262698262DBE4C, 0xBF3232C8328DFA64, 0x59B0B0FAB0E94A7D,
+0xF2E9E983E91B6ACF, 0x770F0F3C0F78331E, 0x33D5D573D5E6A6B7, 0xF480803A8074BA1D,
+0x27BEBEC2BE997C61, 0xEBCDCD13CD26DE87, 0x893434D034BDE468, 0x3248483D487A7590,
+0x54FFFFDBFFAB24E3, 0x8D7A7AF57AF78FF4, 0x6490907A90F4EA3D, 0x9D5F5F615FC23EBE,
+0x3D202080201DA040, 0x0F6868BD6867D5D0, 0xCA1A1A681AD07234, 0xB7AEAE82AE192C41,
+0x7DB4B4EAB4C95E75, 0xCE54544D549A19A8, 0x7F93937693ECE53B, 0x2F222288220DAA44,
+0x6364648D6407E9C8, 0x2AF1F1E3F1DB12FF, 0xCC7373D173BFA2E6, 0x8212124812905A24,
+0x7A40401D403A5D80, 0x4808082008402810, 0x95C3C32BC356E89B, 0xDFECEC97EC337BC5,
+0x4DDBDB4BDB9690AB, 0xC0A1A1BEA1611F5F, 0x918D8D0E8D1C8307, 0xC83D3DF43DF5C97A,
+0x5B97976697CCF133, 0x0000000000000000, 0xF9CFCF1BCF36D483, 0x6E2B2BAC2B458756,
+0xE17676C57697B3EC, 0xE68282328264B019, 0x28D6D67FD6FEA9B1, 0xC31B1B6C1BD87736,
+0x74B5B5EEB5C15B77, 0xBEAFAF86AF112943, 0x1D6A6AB56A77DFD4, 0xEA50505D50BA0DA0,
+0x5745450945124C8A, 0x38F3F3EBF3CB18FB, 0xAD3030C0309DF060, 0xC4EFEF9BEF2B74C3,
+0xDA3F3FFC3FE5C37E, 0xC755554955921CAA, 0xDBA2A2B2A2791059, 0xE9EAEA8FEA0365C9,
+0x6A656589650FECCA, 0x03BABAD2BAB96869, 0x4A2F2FBC2F65935E, 0x8EC0C027C04EE79D,
+0x60DEDE5FDEBE81A1, 0xFC1C1C701CE06C38, 0x46FDFDD3FDBB2EE7, 0x1F4D4D294D52649A,
+0x7692927292E4E039, 0xFA7575C9758FBCEA, 0x3606061806301E0C, 0xAE8A8A128A249809,
+0x4BB2B2F2B2F94079, 0x85E6E6BFE66359D1, 0x7E0E0E380E70361C, 0xE71F1F7C1FF8633E,
+0x556262956237F7C4, 0x3AD4D477D4EEA3B5, 0x81A8A89AA829324D, 0x5296966296C4F431,
+0x62F9F9C3F99B3AEF, 0xA3C5C533C566F697, 0x102525942535B14A, 0xAB59597959F220B2,
+0xD084842A8454AE15, 0xC57272D572B7A7E4, 0xEC3939E439D5DD72, 0x164C4C2D4C5A6198,
+0x945E5E655ECA3BBC, 0x9F7878FD78E785F0, 0xE53838E038DDD870, 0x988C8C0A8C148605,
+0x17D1D163D1C6B2BF, 0xE4A5A5AEA5410B57, 0xA1E2E2AFE2434DD9, 0x4E616199612FF8C2,
+0x42B3B3F6B3F1457B, 0x342121842115A542, 0x089C9C4A9C94D625, 0xEE1E1E781EF0663C,
+0x6143431143225286, 0xB1C7C73BC776FC93, 0x4FFCFCD7FCB32BE5, 0x2404041004201408,
+0xE351515951B208A2, 0x2599995E99BCC72F, 0x226D6DA96D4FC4DA, 0x650D0D340D68391A,
+0x79FAFACFFA8335E9, 0x69DFDF5BDFB684A3, 0xA97E7EE57ED79BFC, 0x19242490243DB448,
+0xFE3B3BEC3BC5D776, 0x9AABAB96AB313D4B, 0xF0CECE1FCE3ED181, 0x9911114411885522,
+0x838F8F068F0C8903, 0x044E4E254E4A6B9C, 0x66B7B7E6B7D15173, 0xE0EBEB8BEB0B60CB,
+0xC13C3CF03CFDCC78, 0xFD81813E817CBF1F, 0x4094946A94D4FE35, 0x1CF7F7FBF7EB0CF3,
+0x18B9B9DEB9A1676F, 0x8B13134C13985F26, 0x512C2CB02C7D9C58, 0x05D3D36BD3D6B8BB,
+0x8CE7E7BBE76B5CD3, 0x396E6EA56E57CBDC, 0xAAC4C437C46EF395, 0x1B03030C03180F06,
+0xDC565645568A13AC, 0x5E44440D441A4988, 0xA07F7FE17FDF9EFE, 0x88A9A99EA921374F,
+0x672A2AA82A4D8254, 0x0ABBBBD6BBB16D6B, 0x87C1C123C146E29F, 0xF153535153A202A6,
+0x72DCDC57DCAE8BA5, 0x530B0B2C0B582716, 0x019D9D4E9D9CD327, 0x2B6C6CAD6C47C1D8,
+0xA43131C43195F562, 0xF37474CD7487B9E8, 0x15F6F6FFF6E309F1, 0x4C464605460A438C,
+0xA5ACAC8AAC092645, 0xB589891E893C970F, 0xB414145014A04428, 0xBAE1E1A3E15B42DF,
+0xA616165816B04E2C, 0xF73A3AE83ACDD274, 0x066969B9696FD0D2, 0x4109092409482D12,
+0xD77070DD70A7ADE0, 0x6FB6B6E2B6D95471, 0x1ED0D067D0CEB7BD, 0xD6EDED93ED3B7EC7,
+0xE2CCCC17CC2EDB85, 0x68424215422A5784, 0x2C98985A98B4C22D, 0xEDA4A4AAA4490E55,
+0x752828A0285D8850, 0x865C5C6D5CDA31B8, 0x6BF8F8C7F8933FED, 0xC28686228644A411 };
+
+const u64bit Whirlpool::C2[256] = {
+0x30D818186018C078, 0x462623238C2305AF, 0x91B8C6C63FC67EF9, 0xCDFBE8E887E8136F,
+0x13CB878726874CA1, 0x6D11B8B8DAB8A962, 0x0209010104010805, 0x9E0D4F4F214F426E,
+0x6C9B3636D836ADEE, 0x51FFA6A6A2A65904, 0xB90CD2D26FD2DEBD, 0xF70EF5F5F3F5FB06,
+0xF2967979F979EF80, 0xDE306F6FA16F5FCE, 0x3F6D91917E91FCEF, 0xA4F852525552AA07,
+0xC04760609D6027FD, 0x6535BCBCCABC8976, 0x2B379B9B569BACCD, 0x018A8E8E028E048C,
+0x5BD2A3A3B6A37115, 0x186C0C0C300C603C, 0xF6847B7BF17BFF8A, 0x6A803535D435B5E1,
+0x3AF51D1D741DE869, 0xDDB3E0E0A7E05347, 0xB321D7D77BD7F6AC, 0x999CC2C22FC25EED,
+0x5C432E2EB82E6D96, 0x96294B4B314B627A, 0xE15DFEFEDFFEA321, 0xAED5575741578216,
+0x2ABD15155415A841, 0xEEE87777C1779FB6, 0x6E923737DC37A5EB, 0xD79EE5E5B3E57B56,
+0x23139F9F469F8CD9, 0xFD23F0F0E7F0D317, 0x94204A4A354A6A7F, 0xA944DADA4FDA9E95,
+0xB0A258587D58FA25, 0x8FCFC9C903C906CA, 0x527C2929A429558D, 0x145A0A0A280A5022,
+0x7F50B1B1FEB1E14F, 0x5DC9A0A0BAA0691A, 0xD6146B6BB16B7FDA, 0x17D985852E855CAB,
+0x673CBDBDCEBD8173, 0xBA8F5D5D695DD234, 0x2090101040108050, 0xF507F4F4F7F4F303,
+0x8BDDCBCB0BCB16C0, 0x7CD33E3EF83EEDC6, 0x0A2D050514052811, 0xCE78676781671FE6,
+0xD597E4E4B7E47353, 0x4E0227279C2725BB, 0x8273414119413258, 0x0BA78B8B168B2C9D,
+0x53F6A7A7A6A75101, 0xFAB27D7DE97DCF94, 0x374995956E95DCFB, 0xAD56D8D847D88E9F,
+0xEB70FBFBCBFB8B30, 0xC1CDEEEE9FEE2371, 0xF8BB7C7CED7CC791, 0xCC716666856617E3,
+0xA77BDDDD53DDA68E, 0x2EAF17175C17B84B, 0x8E45474701470246, 0x211A9E9E429E84DC,
+0x89D4CACA0FCA1EC5, 0x5A582D2DB42D7599, 0x632EBFBFC6BF9179, 0x0E3F07071C07381B,
+0x47ACADAD8EAD0123, 0xB4B05A5A755AEA2F, 0x1BEF838336836CB5, 0x66B63333CC3385FF,
+0xC65C636391633FF2, 0x041202020802100A, 0x4993AAAA92AA3938, 0xE2DE7171D971AFA8,
+0x8DC6C8C807C80ECF, 0x32D119196419C87D, 0x923B494939497270, 0xAF5FD9D943D9869A,
+0xF931F2F2EFF2C31D, 0xDBA8E3E3ABE34B48, 0xB6B95B5B715BE22A, 0x0DBC88881A883492,
+0x293E9A9A529AA4C8, 0x4C0B262698262DBE, 0x64BF3232C8328DFA, 0x7D59B0B0FAB0E94A,
+0xCFF2E9E983E91B6A, 0x1E770F0F3C0F7833, 0xB733D5D573D5E6A6, 0x1DF480803A8074BA,
+0x6127BEBEC2BE997C, 0x87EBCDCD13CD26DE, 0x68893434D034BDE4, 0x903248483D487A75,
+0xE354FFFFDBFFAB24, 0xF48D7A7AF57AF78F, 0x3D6490907A90F4EA, 0xBE9D5F5F615FC23E,
+0x403D202080201DA0, 0xD00F6868BD6867D5, 0x34CA1A1A681AD072, 0x41B7AEAE82AE192C,
+0x757DB4B4EAB4C95E, 0xA8CE54544D549A19, 0x3B7F93937693ECE5, 0x442F222288220DAA,
+0xC86364648D6407E9, 0xFF2AF1F1E3F1DB12, 0xE6CC7373D173BFA2, 0x248212124812905A,
+0x807A40401D403A5D, 0x1048080820084028, 0x9B95C3C32BC356E8, 0xC5DFECEC97EC337B,
+0xAB4DDBDB4BDB9690, 0x5FC0A1A1BEA1611F, 0x07918D8D0E8D1C83, 0x7AC83D3DF43DF5C9,
+0x335B97976697CCF1, 0x0000000000000000, 0x83F9CFCF1BCF36D4, 0x566E2B2BAC2B4587,
+0xECE17676C57697B3, 0x19E68282328264B0, 0xB128D6D67FD6FEA9, 0x36C31B1B6C1BD877,
+0x7774B5B5EEB5C15B, 0x43BEAFAF86AF1129, 0xD41D6A6AB56A77DF, 0xA0EA50505D50BA0D,
+0x8A5745450945124C, 0xFB38F3F3EBF3CB18, 0x60AD3030C0309DF0, 0xC3C4EFEF9BEF2B74,
+0x7EDA3F3FFC3FE5C3, 0xAAC755554955921C, 0x59DBA2A2B2A27910, 0xC9E9EAEA8FEA0365,
+0xCA6A656589650FEC, 0x6903BABAD2BAB968, 0x5E4A2F2FBC2F6593, 0x9D8EC0C027C04EE7,
+0xA160DEDE5FDEBE81, 0x38FC1C1C701CE06C, 0xE746FDFDD3FDBB2E, 0x9A1F4D4D294D5264,
+0x397692927292E4E0, 0xEAFA7575C9758FBC, 0x0C3606061806301E, 0x09AE8A8A128A2498,
+0x794BB2B2F2B2F940, 0xD185E6E6BFE66359, 0x1C7E0E0E380E7036, 0x3EE71F1F7C1FF863,
+0xC4556262956237F7, 0xB53AD4D477D4EEA3, 0x4D81A8A89AA82932, 0x315296966296C4F4,
+0xEF62F9F9C3F99B3A, 0x97A3C5C533C566F6, 0x4A102525942535B1, 0xB2AB59597959F220,
+0x15D084842A8454AE, 0xE4C57272D572B7A7, 0x72EC3939E439D5DD, 0x98164C4C2D4C5A61,
+0xBC945E5E655ECA3B, 0xF09F7878FD78E785, 0x70E53838E038DDD8, 0x05988C8C0A8C1486,
+0xBF17D1D163D1C6B2, 0x57E4A5A5AEA5410B, 0xD9A1E2E2AFE2434D, 0xC24E616199612FF8,
+0x7B42B3B3F6B3F145, 0x42342121842115A5, 0x25089C9C4A9C94D6, 0x3CEE1E1E781EF066,
+0x8661434311432252, 0x93B1C7C73BC776FC, 0xE54FFCFCD7FCB32B, 0x0824040410042014,
+0xA2E351515951B208, 0x2F2599995E99BCC7, 0xDA226D6DA96D4FC4, 0x1A650D0D340D6839,
+0xE979FAFACFFA8335, 0xA369DFDF5BDFB684, 0xFCA97E7EE57ED79B, 0x4819242490243DB4,
+0x76FE3B3BEC3BC5D7, 0x4B9AABAB96AB313D, 0x81F0CECE1FCE3ED1, 0x2299111144118855,
+0x03838F8F068F0C89, 0x9C044E4E254E4A6B, 0x7366B7B7E6B7D151, 0xCBE0EBEB8BEB0B60,
+0x78C13C3CF03CFDCC, 0x1FFD81813E817CBF, 0x354094946A94D4FE, 0xF31CF7F7FBF7EB0C,
+0x6F18B9B9DEB9A167, 0x268B13134C13985F, 0x58512C2CB02C7D9C, 0xBB05D3D36BD3D6B8,
+0xD38CE7E7BBE76B5C, 0xDC396E6EA56E57CB, 0x95AAC4C437C46EF3, 0x061B03030C03180F,
+0xACDC565645568A13, 0x885E44440D441A49, 0xFEA07F7FE17FDF9E, 0x4F88A9A99EA92137,
+0x54672A2AA82A4D82, 0x6B0ABBBBD6BBB16D, 0x9F87C1C123C146E2, 0xA6F153535153A202,
+0xA572DCDC57DCAE8B, 0x16530B0B2C0B5827, 0x27019D9D4E9D9CD3, 0xD82B6C6CAD6C47C1,
+0x62A43131C43195F5, 0xE8F37474CD7487B9, 0xF115F6F6FFF6E309, 0x8C4C464605460A43,
+0x45A5ACAC8AAC0926, 0x0FB589891E893C97, 0x28B414145014A044, 0xDFBAE1E1A3E15B42,
+0x2CA616165816B04E, 0x74F73A3AE83ACDD2, 0xD2066969B9696FD0, 0x124109092409482D,
+0xE0D77070DD70A7AD, 0x716FB6B6E2B6D954, 0xBD1ED0D067D0CEB7, 0xC7D6EDED93ED3B7E,
+0x85E2CCCC17CC2EDB, 0x8468424215422A57, 0x2D2C98985A98B4C2, 0x55EDA4A4AAA4490E,
+0x50752828A0285D88, 0xB8865C5C6D5CDA31, 0xED6BF8F8C7F8933F, 0x11C28686228644A4 };
+
+const u64bit Whirlpool::C3[256] = {
+0x7830D818186018C0, 0xAF462623238C2305, 0xF991B8C6C63FC67E, 0x6FCDFBE8E887E813,
+0xA113CB878726874C, 0x626D11B8B8DAB8A9, 0x0502090101040108, 0x6E9E0D4F4F214F42,
+0xEE6C9B3636D836AD, 0x0451FFA6A6A2A659, 0xBDB90CD2D26FD2DE, 0x06F70EF5F5F3F5FB,
+0x80F2967979F979EF, 0xCEDE306F6FA16F5F, 0xEF3F6D91917E91FC, 0x07A4F852525552AA,
+0xFDC04760609D6027, 0x766535BCBCCABC89, 0xCD2B379B9B569BAC, 0x8C018A8E8E028E04,
+0x155BD2A3A3B6A371, 0x3C186C0C0C300C60, 0x8AF6847B7BF17BFF, 0xE16A803535D435B5,
+0x693AF51D1D741DE8, 0x47DDB3E0E0A7E053, 0xACB321D7D77BD7F6, 0xED999CC2C22FC25E,
+0x965C432E2EB82E6D, 0x7A96294B4B314B62, 0x21E15DFEFEDFFEA3, 0x16AED55757415782,
+0x412ABD15155415A8, 0xB6EEE87777C1779F, 0xEB6E923737DC37A5, 0x56D79EE5E5B3E57B,
+0xD923139F9F469F8C, 0x17FD23F0F0E7F0D3, 0x7F94204A4A354A6A, 0x95A944DADA4FDA9E,
+0x25B0A258587D58FA, 0xCA8FCFC9C903C906, 0x8D527C2929A42955, 0x22145A0A0A280A50,
+0x4F7F50B1B1FEB1E1, 0x1A5DC9A0A0BAA069, 0xDAD6146B6BB16B7F, 0xAB17D985852E855C,
+0x73673CBDBDCEBD81, 0x34BA8F5D5D695DD2, 0x5020901010401080, 0x03F507F4F4F7F4F3,
+0xC08BDDCBCB0BCB16, 0xC67CD33E3EF83EED, 0x110A2D0505140528, 0xE6CE78676781671F,
+0x53D597E4E4B7E473, 0xBB4E0227279C2725, 0x5882734141194132, 0x9D0BA78B8B168B2C,
+0x0153F6A7A7A6A751, 0x94FAB27D7DE97DCF, 0xFB374995956E95DC, 0x9FAD56D8D847D88E,
+0x30EB70FBFBCBFB8B, 0x71C1CDEEEE9FEE23, 0x91F8BB7C7CED7CC7, 0xE3CC716666856617,
+0x8EA77BDDDD53DDA6, 0x4B2EAF17175C17B8, 0x468E454747014702, 0xDC211A9E9E429E84,
+0xC589D4CACA0FCA1E, 0x995A582D2DB42D75, 0x79632EBFBFC6BF91, 0x1B0E3F07071C0738,
+0x2347ACADAD8EAD01, 0x2FB4B05A5A755AEA, 0xB51BEF838336836C, 0xFF66B63333CC3385,
+0xF2C65C636391633F, 0x0A04120202080210, 0x384993AAAA92AA39, 0xA8E2DE7171D971AF,
+0xCF8DC6C8C807C80E, 0x7D32D119196419C8, 0x70923B4949394972, 0x9AAF5FD9D943D986,
+0x1DF931F2F2EFF2C3, 0x48DBA8E3E3ABE34B, 0x2AB6B95B5B715BE2, 0x920DBC88881A8834,
+0xC8293E9A9A529AA4, 0xBE4C0B262698262D, 0xFA64BF3232C8328D, 0x4A7D59B0B0FAB0E9,
+0x6ACFF2E9E983E91B, 0x331E770F0F3C0F78, 0xA6B733D5D573D5E6, 0xBA1DF480803A8074,
+0x7C6127BEBEC2BE99, 0xDE87EBCDCD13CD26, 0xE468893434D034BD, 0x75903248483D487A,
+0x24E354FFFFDBFFAB, 0x8FF48D7A7AF57AF7, 0xEA3D6490907A90F4, 0x3EBE9D5F5F615FC2,
+0xA0403D202080201D, 0xD5D00F6868BD6867, 0x7234CA1A1A681AD0, 0x2C41B7AEAE82AE19,
+0x5E757DB4B4EAB4C9, 0x19A8CE54544D549A, 0xE53B7F93937693EC, 0xAA442F222288220D,
+0xE9C86364648D6407, 0x12FF2AF1F1E3F1DB, 0xA2E6CC7373D173BF, 0x5A24821212481290,
+0x5D807A40401D403A, 0x2810480808200840, 0xE89B95C3C32BC356, 0x7BC5DFECEC97EC33,
+0x90AB4DDBDB4BDB96, 0x1F5FC0A1A1BEA161, 0x8307918D8D0E8D1C, 0xC97AC83D3DF43DF5,
+0xF1335B97976697CC, 0x0000000000000000, 0xD483F9CFCF1BCF36, 0x87566E2B2BAC2B45,
+0xB3ECE17676C57697, 0xB019E68282328264, 0xA9B128D6D67FD6FE, 0x7736C31B1B6C1BD8,
+0x5B7774B5B5EEB5C1, 0x2943BEAFAF86AF11, 0xDFD41D6A6AB56A77, 0x0DA0EA50505D50BA,
+0x4C8A574545094512, 0x18FB38F3F3EBF3CB, 0xF060AD3030C0309D, 0x74C3C4EFEF9BEF2B,
+0xC37EDA3F3FFC3FE5, 0x1CAAC75555495592, 0x1059DBA2A2B2A279, 0x65C9E9EAEA8FEA03,
+0xECCA6A656589650F, 0x686903BABAD2BAB9, 0x935E4A2F2FBC2F65, 0xE79D8EC0C027C04E,
+0x81A160DEDE5FDEBE, 0x6C38FC1C1C701CE0, 0x2EE746FDFDD3FDBB, 0x649A1F4D4D294D52,
+0xE0397692927292E4, 0xBCEAFA7575C9758F, 0x1E0C360606180630, 0x9809AE8A8A128A24,
+0x40794BB2B2F2B2F9, 0x59D185E6E6BFE663, 0x361C7E0E0E380E70, 0x633EE71F1F7C1FF8,
+0xF7C4556262956237, 0xA3B53AD4D477D4EE, 0x324D81A8A89AA829, 0xF4315296966296C4,
+0x3AEF62F9F9C3F99B, 0xF697A3C5C533C566, 0xB14A102525942535, 0x20B2AB59597959F2,
+0xAE15D084842A8454, 0xA7E4C57272D572B7, 0xDD72EC3939E439D5, 0x6198164C4C2D4C5A,
+0x3BBC945E5E655ECA, 0x85F09F7878FD78E7, 0xD870E53838E038DD, 0x8605988C8C0A8C14,
+0xB2BF17D1D163D1C6, 0x0B57E4A5A5AEA541, 0x4DD9A1E2E2AFE243, 0xF8C24E616199612F,
+0x457B42B3B3F6B3F1, 0xA542342121842115, 0xD625089C9C4A9C94, 0x663CEE1E1E781EF0,
+0x5286614343114322, 0xFC93B1C7C73BC776, 0x2BE54FFCFCD7FCB3, 0x1408240404100420,
+0x08A2E351515951B2, 0xC72F2599995E99BC, 0xC4DA226D6DA96D4F, 0x391A650D0D340D68,
+0x35E979FAFACFFA83, 0x84A369DFDF5BDFB6, 0x9BFCA97E7EE57ED7, 0xB44819242490243D,
+0xD776FE3B3BEC3BC5, 0x3D4B9AABAB96AB31, 0xD181F0CECE1FCE3E, 0x5522991111441188,
+0x8903838F8F068F0C, 0x6B9C044E4E254E4A, 0x517366B7B7E6B7D1, 0x60CBE0EBEB8BEB0B,
+0xCC78C13C3CF03CFD, 0xBF1FFD81813E817C, 0xFE354094946A94D4, 0x0CF31CF7F7FBF7EB,
+0x676F18B9B9DEB9A1, 0x5F268B13134C1398, 0x9C58512C2CB02C7D, 0xB8BB05D3D36BD3D6,
+0x5CD38CE7E7BBE76B, 0xCBDC396E6EA56E57, 0xF395AAC4C437C46E, 0x0F061B03030C0318,
+0x13ACDC565645568A, 0x49885E44440D441A, 0x9EFEA07F7FE17FDF, 0x374F88A9A99EA921,
+0x8254672A2AA82A4D, 0x6D6B0ABBBBD6BBB1, 0xE29F87C1C123C146, 0x02A6F153535153A2,
+0x8BA572DCDC57DCAE, 0x2716530B0B2C0B58, 0xD327019D9D4E9D9C, 0xC1D82B6C6CAD6C47,
+0xF562A43131C43195, 0xB9E8F37474CD7487, 0x09F115F6F6FFF6E3, 0x438C4C464605460A,
+0x2645A5ACAC8AAC09, 0x970FB589891E893C, 0x4428B414145014A0, 0x42DFBAE1E1A3E15B,
+0x4E2CA616165816B0, 0xD274F73A3AE83ACD, 0xD0D2066969B9696F, 0x2D12410909240948,
+0xADE0D77070DD70A7, 0x54716FB6B6E2B6D9, 0xB7BD1ED0D067D0CE, 0x7EC7D6EDED93ED3B,
+0xDB85E2CCCC17CC2E, 0x578468424215422A, 0xC22D2C98985A98B4, 0x0E55EDA4A4AAA449,
+0x8850752828A0285D, 0x31B8865C5C6D5CDA, 0x3FED6BF8F8C7F893, 0xA411C28686228644 };
+
+const u64bit Whirlpool::C4[256] = {
+0xC07830D818186018, 0x05AF462623238C23, 0x7EF991B8C6C63FC6, 0x136FCDFBE8E887E8,
+0x4CA113CB87872687, 0xA9626D11B8B8DAB8, 0x0805020901010401, 0x426E9E0D4F4F214F,
+0xADEE6C9B3636D836, 0x590451FFA6A6A2A6, 0xDEBDB90CD2D26FD2, 0xFB06F70EF5F5F3F5,
+0xEF80F2967979F979, 0x5FCEDE306F6FA16F, 0xFCEF3F6D91917E91, 0xAA07A4F852525552,
+0x27FDC04760609D60, 0x89766535BCBCCABC, 0xACCD2B379B9B569B, 0x048C018A8E8E028E,
+0x71155BD2A3A3B6A3, 0x603C186C0C0C300C, 0xFF8AF6847B7BF17B, 0xB5E16A803535D435,
+0xE8693AF51D1D741D, 0x5347DDB3E0E0A7E0, 0xF6ACB321D7D77BD7, 0x5EED999CC2C22FC2,
+0x6D965C432E2EB82E, 0x627A96294B4B314B, 0xA321E15DFEFEDFFE, 0x8216AED557574157,
+0xA8412ABD15155415, 0x9FB6EEE87777C177, 0xA5EB6E923737DC37, 0x7B56D79EE5E5B3E5,
+0x8CD923139F9F469F, 0xD317FD23F0F0E7F0, 0x6A7F94204A4A354A, 0x9E95A944DADA4FDA,
+0xFA25B0A258587D58, 0x06CA8FCFC9C903C9, 0x558D527C2929A429, 0x5022145A0A0A280A,
+0xE14F7F50B1B1FEB1, 0x691A5DC9A0A0BAA0, 0x7FDAD6146B6BB16B, 0x5CAB17D985852E85,
+0x8173673CBDBDCEBD, 0xD234BA8F5D5D695D, 0x8050209010104010, 0xF303F507F4F4F7F4,
+0x16C08BDDCBCB0BCB, 0xEDC67CD33E3EF83E, 0x28110A2D05051405, 0x1FE6CE7867678167,
+0x7353D597E4E4B7E4, 0x25BB4E0227279C27, 0x3258827341411941, 0x2C9D0BA78B8B168B,
+0x510153F6A7A7A6A7, 0xCF94FAB27D7DE97D, 0xDCFB374995956E95, 0x8E9FAD56D8D847D8,
+0x8B30EB70FBFBCBFB, 0x2371C1CDEEEE9FEE, 0xC791F8BB7C7CED7C, 0x17E3CC7166668566,
+0xA68EA77BDDDD53DD, 0xB84B2EAF17175C17, 0x02468E4547470147, 0x84DC211A9E9E429E,
+0x1EC589D4CACA0FCA, 0x75995A582D2DB42D, 0x9179632EBFBFC6BF, 0x381B0E3F07071C07,
+0x012347ACADAD8EAD, 0xEA2FB4B05A5A755A, 0x6CB51BEF83833683, 0x85FF66B63333CC33,
+0x3FF2C65C63639163, 0x100A041202020802, 0x39384993AAAA92AA, 0xAFA8E2DE7171D971,
+0x0ECF8DC6C8C807C8, 0xC87D32D119196419, 0x7270923B49493949, 0x869AAF5FD9D943D9,
+0xC31DF931F2F2EFF2, 0x4B48DBA8E3E3ABE3, 0xE22AB6B95B5B715B, 0x34920DBC88881A88,
+0xA4C8293E9A9A529A, 0x2DBE4C0B26269826, 0x8DFA64BF3232C832, 0xE94A7D59B0B0FAB0,
+0x1B6ACFF2E9E983E9, 0x78331E770F0F3C0F, 0xE6A6B733D5D573D5, 0x74BA1DF480803A80,
+0x997C6127BEBEC2BE, 0x26DE87EBCDCD13CD, 0xBDE468893434D034, 0x7A75903248483D48,
+0xAB24E354FFFFDBFF, 0xF78FF48D7A7AF57A, 0xF4EA3D6490907A90, 0xC23EBE9D5F5F615F,
+0x1DA0403D20208020, 0x67D5D00F6868BD68, 0xD07234CA1A1A681A, 0x192C41B7AEAE82AE,
+0xC95E757DB4B4EAB4, 0x9A19A8CE54544D54, 0xECE53B7F93937693, 0x0DAA442F22228822,
+0x07E9C86364648D64, 0xDB12FF2AF1F1E3F1, 0xBFA2E6CC7373D173, 0x905A248212124812,
+0x3A5D807A40401D40, 0x4028104808082008, 0x56E89B95C3C32BC3, 0x337BC5DFECEC97EC,
+0x9690AB4DDBDB4BDB, 0x611F5FC0A1A1BEA1, 0x1C8307918D8D0E8D, 0xF5C97AC83D3DF43D,
+0xCCF1335B97976697, 0x0000000000000000, 0x36D483F9CFCF1BCF, 0x4587566E2B2BAC2B,
+0x97B3ECE17676C576, 0x64B019E682823282, 0xFEA9B128D6D67FD6, 0xD87736C31B1B6C1B,
+0xC15B7774B5B5EEB5, 0x112943BEAFAF86AF, 0x77DFD41D6A6AB56A, 0xBA0DA0EA50505D50,
+0x124C8A5745450945, 0xCB18FB38F3F3EBF3, 0x9DF060AD3030C030, 0x2B74C3C4EFEF9BEF,
+0xE5C37EDA3F3FFC3F, 0x921CAAC755554955, 0x791059DBA2A2B2A2, 0x0365C9E9EAEA8FEA,
+0x0FECCA6A65658965, 0xB9686903BABAD2BA, 0x65935E4A2F2FBC2F, 0x4EE79D8EC0C027C0,
+0xBE81A160DEDE5FDE, 0xE06C38FC1C1C701C, 0xBB2EE746FDFDD3FD, 0x52649A1F4D4D294D,
+0xE4E0397692927292, 0x8FBCEAFA7575C975, 0x301E0C3606061806, 0x249809AE8A8A128A,
+0xF940794BB2B2F2B2, 0x6359D185E6E6BFE6, 0x70361C7E0E0E380E, 0xF8633EE71F1F7C1F,
+0x37F7C45562629562, 0xEEA3B53AD4D477D4, 0x29324D81A8A89AA8, 0xC4F4315296966296,
+0x9B3AEF62F9F9C3F9, 0x66F697A3C5C533C5, 0x35B14A1025259425, 0xF220B2AB59597959,
+0x54AE15D084842A84, 0xB7A7E4C57272D572, 0xD5DD72EC3939E439, 0x5A6198164C4C2D4C,
+0xCA3BBC945E5E655E, 0xE785F09F7878FD78, 0xDDD870E53838E038, 0x148605988C8C0A8C,
+0xC6B2BF17D1D163D1, 0x410B57E4A5A5AEA5, 0x434DD9A1E2E2AFE2, 0x2FF8C24E61619961,
+0xF1457B42B3B3F6B3, 0x15A5423421218421, 0x94D625089C9C4A9C, 0xF0663CEE1E1E781E,
+0x2252866143431143, 0x76FC93B1C7C73BC7, 0xB32BE54FFCFCD7FC, 0x2014082404041004,
+0xB208A2E351515951, 0xBCC72F2599995E99, 0x4FC4DA226D6DA96D, 0x68391A650D0D340D,
+0x8335E979FAFACFFA, 0xB684A369DFDF5BDF, 0xD79BFCA97E7EE57E, 0x3DB4481924249024,
+0xC5D776FE3B3BEC3B, 0x313D4B9AABAB96AB, 0x3ED181F0CECE1FCE, 0x8855229911114411,
+0x0C8903838F8F068F, 0x4A6B9C044E4E254E, 0xD1517366B7B7E6B7, 0x0B60CBE0EBEB8BEB,
+0xFDCC78C13C3CF03C, 0x7CBF1FFD81813E81, 0xD4FE354094946A94, 0xEB0CF31CF7F7FBF7,
+0xA1676F18B9B9DEB9, 0x985F268B13134C13, 0x7D9C58512C2CB02C, 0xD6B8BB05D3D36BD3,
+0x6B5CD38CE7E7BBE7, 0x57CBDC396E6EA56E, 0x6EF395AAC4C437C4, 0x180F061B03030C03,
+0x8A13ACDC56564556, 0x1A49885E44440D44, 0xDF9EFEA07F7FE17F, 0x21374F88A9A99EA9,
+0x4D8254672A2AA82A, 0xB16D6B0ABBBBD6BB, 0x46E29F87C1C123C1, 0xA202A6F153535153,
+0xAE8BA572DCDC57DC, 0x582716530B0B2C0B, 0x9CD327019D9D4E9D, 0x47C1D82B6C6CAD6C,
+0x95F562A43131C431, 0x87B9E8F37474CD74, 0xE309F115F6F6FFF6, 0x0A438C4C46460546,
+0x092645A5ACAC8AAC, 0x3C970FB589891E89, 0xA04428B414145014, 0x5B42DFBAE1E1A3E1,
+0xB04E2CA616165816, 0xCDD274F73A3AE83A, 0x6FD0D2066969B969, 0x482D124109092409,
+0xA7ADE0D77070DD70, 0xD954716FB6B6E2B6, 0xCEB7BD1ED0D067D0, 0x3B7EC7D6EDED93ED,
+0x2EDB85E2CCCC17CC, 0x2A57846842421542, 0xB4C22D2C98985A98, 0x490E55EDA4A4AAA4,
+0x5D8850752828A028, 0xDA31B8865C5C6D5C, 0x933FED6BF8F8C7F8, 0x44A411C286862286 };
+
+const u64bit Whirlpool::C5[256] = {
+0x18C07830D8181860, 0x2305AF462623238C, 0xC67EF991B8C6C63F, 0xE8136FCDFBE8E887,
+0x874CA113CB878726, 0xB8A9626D11B8B8DA, 0x0108050209010104, 0x4F426E9E0D4F4F21,
+0x36ADEE6C9B3636D8, 0xA6590451FFA6A6A2, 0xD2DEBDB90CD2D26F, 0xF5FB06F70EF5F5F3,
+0x79EF80F2967979F9, 0x6F5FCEDE306F6FA1, 0x91FCEF3F6D91917E, 0x52AA07A4F8525255,
+0x6027FDC04760609D, 0xBC89766535BCBCCA, 0x9BACCD2B379B9B56, 0x8E048C018A8E8E02,
+0xA371155BD2A3A3B6, 0x0C603C186C0C0C30, 0x7BFF8AF6847B7BF1, 0x35B5E16A803535D4,
+0x1DE8693AF51D1D74, 0xE05347DDB3E0E0A7, 0xD7F6ACB321D7D77B, 0xC25EED999CC2C22F,
+0x2E6D965C432E2EB8, 0x4B627A96294B4B31, 0xFEA321E15DFEFEDF, 0x578216AED5575741,
+0x15A8412ABD151554, 0x779FB6EEE87777C1, 0x37A5EB6E923737DC, 0xE57B56D79EE5E5B3,
+0x9F8CD923139F9F46, 0xF0D317FD23F0F0E7, 0x4A6A7F94204A4A35, 0xDA9E95A944DADA4F,
+0x58FA25B0A258587D, 0xC906CA8FCFC9C903, 0x29558D527C2929A4, 0x0A5022145A0A0A28,
+0xB1E14F7F50B1B1FE, 0xA0691A5DC9A0A0BA, 0x6B7FDAD6146B6BB1, 0x855CAB17D985852E,
+0xBD8173673CBDBDCE, 0x5DD234BA8F5D5D69, 0x1080502090101040, 0xF4F303F507F4F4F7,
+0xCB16C08BDDCBCB0B, 0x3EEDC67CD33E3EF8, 0x0528110A2D050514, 0x671FE6CE78676781,
+0xE47353D597E4E4B7, 0x2725BB4E0227279C, 0x4132588273414119, 0x8B2C9D0BA78B8B16,
+0xA7510153F6A7A7A6, 0x7DCF94FAB27D7DE9, 0x95DCFB374995956E, 0xD88E9FAD56D8D847,
+0xFB8B30EB70FBFBCB, 0xEE2371C1CDEEEE9F, 0x7CC791F8BB7C7CED, 0x6617E3CC71666685,
+0xDDA68EA77BDDDD53, 0x17B84B2EAF17175C, 0x4702468E45474701, 0x9E84DC211A9E9E42,
+0xCA1EC589D4CACA0F, 0x2D75995A582D2DB4, 0xBF9179632EBFBFC6, 0x07381B0E3F07071C,
+0xAD012347ACADAD8E, 0x5AEA2FB4B05A5A75, 0x836CB51BEF838336, 0x3385FF66B63333CC,
+0x633FF2C65C636391, 0x02100A0412020208, 0xAA39384993AAAA92, 0x71AFA8E2DE7171D9,
+0xC80ECF8DC6C8C807, 0x19C87D32D1191964, 0x497270923B494939, 0xD9869AAF5FD9D943,
+0xF2C31DF931F2F2EF, 0xE34B48DBA8E3E3AB, 0x5BE22AB6B95B5B71, 0x8834920DBC88881A,
+0x9AA4C8293E9A9A52, 0x262DBE4C0B262698, 0x328DFA64BF3232C8, 0xB0E94A7D59B0B0FA,
+0xE91B6ACFF2E9E983, 0x0F78331E770F0F3C, 0xD5E6A6B733D5D573, 0x8074BA1DF480803A,
+0xBE997C6127BEBEC2, 0xCD26DE87EBCDCD13, 0x34BDE468893434D0, 0x487A75903248483D,
+0xFFAB24E354FFFFDB, 0x7AF78FF48D7A7AF5, 0x90F4EA3D6490907A, 0x5FC23EBE9D5F5F61,
+0x201DA0403D202080, 0x6867D5D00F6868BD, 0x1AD07234CA1A1A68, 0xAE192C41B7AEAE82,
+0xB4C95E757DB4B4EA, 0x549A19A8CE54544D, 0x93ECE53B7F939376, 0x220DAA442F222288,
+0x6407E9C86364648D, 0xF1DB12FF2AF1F1E3, 0x73BFA2E6CC7373D1, 0x12905A2482121248,
+0x403A5D807A40401D, 0x0840281048080820, 0xC356E89B95C3C32B, 0xEC337BC5DFECEC97,
+0xDB9690AB4DDBDB4B, 0xA1611F5FC0A1A1BE, 0x8D1C8307918D8D0E, 0x3DF5C97AC83D3DF4,
+0x97CCF1335B979766, 0x0000000000000000, 0xCF36D483F9CFCF1B, 0x2B4587566E2B2BAC,
+0x7697B3ECE17676C5, 0x8264B019E6828232, 0xD6FEA9B128D6D67F, 0x1BD87736C31B1B6C,
+0xB5C15B7774B5B5EE, 0xAF112943BEAFAF86, 0x6A77DFD41D6A6AB5, 0x50BA0DA0EA50505D,
+0x45124C8A57454509, 0xF3CB18FB38F3F3EB, 0x309DF060AD3030C0, 0xEF2B74C3C4EFEF9B,
+0x3FE5C37EDA3F3FFC, 0x55921CAAC7555549, 0xA2791059DBA2A2B2, 0xEA0365C9E9EAEA8F,
+0x650FECCA6A656589, 0xBAB9686903BABAD2, 0x2F65935E4A2F2FBC, 0xC04EE79D8EC0C027,
+0xDEBE81A160DEDE5F, 0x1CE06C38FC1C1C70, 0xFDBB2EE746FDFDD3, 0x4D52649A1F4D4D29,
+0x92E4E03976929272, 0x758FBCEAFA7575C9, 0x06301E0C36060618, 0x8A249809AE8A8A12,
+0xB2F940794BB2B2F2, 0xE66359D185E6E6BF, 0x0E70361C7E0E0E38, 0x1FF8633EE71F1F7C,
+0x6237F7C455626295, 0xD4EEA3B53AD4D477, 0xA829324D81A8A89A, 0x96C4F43152969662,
+0xF99B3AEF62F9F9C3, 0xC566F697A3C5C533, 0x2535B14A10252594, 0x59F220B2AB595979,
+0x8454AE15D084842A, 0x72B7A7E4C57272D5, 0x39D5DD72EC3939E4, 0x4C5A6198164C4C2D,
+0x5ECA3BBC945E5E65, 0x78E785F09F7878FD, 0x38DDD870E53838E0, 0x8C148605988C8C0A,
+0xD1C6B2BF17D1D163, 0xA5410B57E4A5A5AE, 0xE2434DD9A1E2E2AF, 0x612FF8C24E616199,
+0xB3F1457B42B3B3F6, 0x2115A54234212184, 0x9C94D625089C9C4A, 0x1EF0663CEE1E1E78,
+0x4322528661434311, 0xC776FC93B1C7C73B, 0xFCB32BE54FFCFCD7, 0x0420140824040410,
+0x51B208A2E3515159, 0x99BCC72F2599995E, 0x6D4FC4DA226D6DA9, 0x0D68391A650D0D34,
+0xFA8335E979FAFACF, 0xDFB684A369DFDF5B, 0x7ED79BFCA97E7EE5, 0x243DB44819242490,
+0x3BC5D776FE3B3BEC, 0xAB313D4B9AABAB96, 0xCE3ED181F0CECE1F, 0x1188552299111144,
+0x8F0C8903838F8F06, 0x4E4A6B9C044E4E25, 0xB7D1517366B7B7E6, 0xEB0B60CBE0EBEB8B,
+0x3CFDCC78C13C3CF0, 0x817CBF1FFD81813E, 0x94D4FE354094946A, 0xF7EB0CF31CF7F7FB,
+0xB9A1676F18B9B9DE, 0x13985F268B13134C, 0x2C7D9C58512C2CB0, 0xD3D6B8BB05D3D36B,
+0xE76B5CD38CE7E7BB, 0x6E57CBDC396E6EA5, 0xC46EF395AAC4C437, 0x03180F061B03030C,
+0x568A13ACDC565645, 0x441A49885E44440D, 0x7FDF9EFEA07F7FE1, 0xA921374F88A9A99E,
+0x2A4D8254672A2AA8, 0xBBB16D6B0ABBBBD6, 0xC146E29F87C1C123, 0x53A202A6F1535351,
+0xDCAE8BA572DCDC57, 0x0B582716530B0B2C, 0x9D9CD327019D9D4E, 0x6C47C1D82B6C6CAD,
+0x3195F562A43131C4, 0x7487B9E8F37474CD, 0xF6E309F115F6F6FF, 0x460A438C4C464605,
+0xAC092645A5ACAC8A, 0x893C970FB589891E, 0x14A04428B4141450, 0xE15B42DFBAE1E1A3,
+0x16B04E2CA6161658, 0x3ACDD274F73A3AE8, 0x696FD0D2066969B9, 0x09482D1241090924,
+0x70A7ADE0D77070DD, 0xB6D954716FB6B6E2, 0xD0CEB7BD1ED0D067, 0xED3B7EC7D6EDED93,
+0xCC2EDB85E2CCCC17, 0x422A578468424215, 0x98B4C22D2C98985A, 0xA4490E55EDA4A4AA,
+0x285D8850752828A0, 0x5CDA31B8865C5C6D, 0xF8933FED6BF8F8C7, 0x8644A411C2868622 };
+
+const u64bit Whirlpool::C6[256] = {
+0x6018C07830D81818, 0x8C2305AF46262323, 0x3FC67EF991B8C6C6, 0x87E8136FCDFBE8E8,
+0x26874CA113CB8787, 0xDAB8A9626D11B8B8, 0x0401080502090101, 0x214F426E9E0D4F4F,
+0xD836ADEE6C9B3636, 0xA2A6590451FFA6A6, 0x6FD2DEBDB90CD2D2, 0xF3F5FB06F70EF5F5,
+0xF979EF80F2967979, 0xA16F5FCEDE306F6F, 0x7E91FCEF3F6D9191, 0x5552AA07A4F85252,
+0x9D6027FDC0476060, 0xCABC89766535BCBC, 0x569BACCD2B379B9B, 0x028E048C018A8E8E,
+0xB6A371155BD2A3A3, 0x300C603C186C0C0C, 0xF17BFF8AF6847B7B, 0xD435B5E16A803535,
+0x741DE8693AF51D1D, 0xA7E05347DDB3E0E0, 0x7BD7F6ACB321D7D7, 0x2FC25EED999CC2C2,
+0xB82E6D965C432E2E, 0x314B627A96294B4B, 0xDFFEA321E15DFEFE, 0x41578216AED55757,
+0x5415A8412ABD1515, 0xC1779FB6EEE87777, 0xDC37A5EB6E923737, 0xB3E57B56D79EE5E5,
+0x469F8CD923139F9F, 0xE7F0D317FD23F0F0, 0x354A6A7F94204A4A, 0x4FDA9E95A944DADA,
+0x7D58FA25B0A25858, 0x03C906CA8FCFC9C9, 0xA429558D527C2929, 0x280A5022145A0A0A,
+0xFEB1E14F7F50B1B1, 0xBAA0691A5DC9A0A0, 0xB16B7FDAD6146B6B, 0x2E855CAB17D98585,
+0xCEBD8173673CBDBD, 0x695DD234BA8F5D5D, 0x4010805020901010, 0xF7F4F303F507F4F4,
+0x0BCB16C08BDDCBCB, 0xF83EEDC67CD33E3E, 0x140528110A2D0505, 0x81671FE6CE786767,
+0xB7E47353D597E4E4, 0x9C2725BB4E022727, 0x1941325882734141, 0x168B2C9D0BA78B8B,
+0xA6A7510153F6A7A7, 0xE97DCF94FAB27D7D, 0x6E95DCFB37499595, 0x47D88E9FAD56D8D8,
+0xCBFB8B30EB70FBFB, 0x9FEE2371C1CDEEEE, 0xED7CC791F8BB7C7C, 0x856617E3CC716666,
+0x53DDA68EA77BDDDD, 0x5C17B84B2EAF1717, 0x014702468E454747, 0x429E84DC211A9E9E,
+0x0FCA1EC589D4CACA, 0xB42D75995A582D2D, 0xC6BF9179632EBFBF, 0x1C07381B0E3F0707,
+0x8EAD012347ACADAD, 0x755AEA2FB4B05A5A, 0x36836CB51BEF8383, 0xCC3385FF66B63333,
+0x91633FF2C65C6363, 0x0802100A04120202, 0x92AA39384993AAAA, 0xD971AFA8E2DE7171,
+0x07C80ECF8DC6C8C8, 0x6419C87D32D11919, 0x39497270923B4949, 0x43D9869AAF5FD9D9,
+0xEFF2C31DF931F2F2, 0xABE34B48DBA8E3E3, 0x715BE22AB6B95B5B, 0x1A8834920DBC8888,
+0x529AA4C8293E9A9A, 0x98262DBE4C0B2626, 0xC8328DFA64BF3232, 0xFAB0E94A7D59B0B0,
+0x83E91B6ACFF2E9E9, 0x3C0F78331E770F0F, 0x73D5E6A6B733D5D5, 0x3A8074BA1DF48080,
+0xC2BE997C6127BEBE, 0x13CD26DE87EBCDCD, 0xD034BDE468893434, 0x3D487A7590324848,
+0xDBFFAB24E354FFFF, 0xF57AF78FF48D7A7A, 0x7A90F4EA3D649090, 0x615FC23EBE9D5F5F,
+0x80201DA0403D2020, 0xBD6867D5D00F6868, 0x681AD07234CA1A1A, 0x82AE192C41B7AEAE,
+0xEAB4C95E757DB4B4, 0x4D549A19A8CE5454, 0x7693ECE53B7F9393, 0x88220DAA442F2222,
+0x8D6407E9C8636464, 0xE3F1DB12FF2AF1F1, 0xD173BFA2E6CC7373, 0x4812905A24821212,
+0x1D403A5D807A4040, 0x2008402810480808, 0x2BC356E89B95C3C3, 0x97EC337BC5DFECEC,
+0x4BDB9690AB4DDBDB, 0xBEA1611F5FC0A1A1, 0x0E8D1C8307918D8D, 0xF43DF5C97AC83D3D,
+0x6697CCF1335B9797, 0x0000000000000000, 0x1BCF36D483F9CFCF, 0xAC2B4587566E2B2B,
+0xC57697B3ECE17676, 0x328264B019E68282, 0x7FD6FEA9B128D6D6, 0x6C1BD87736C31B1B,
+0xEEB5C15B7774B5B5, 0x86AF112943BEAFAF, 0xB56A77DFD41D6A6A, 0x5D50BA0DA0EA5050,
+0x0945124C8A574545, 0xEBF3CB18FB38F3F3, 0xC0309DF060AD3030, 0x9BEF2B74C3C4EFEF,
+0xFC3FE5C37EDA3F3F, 0x4955921CAAC75555, 0xB2A2791059DBA2A2, 0x8FEA0365C9E9EAEA,
+0x89650FECCA6A6565, 0xD2BAB9686903BABA, 0xBC2F65935E4A2F2F, 0x27C04EE79D8EC0C0,
+0x5FDEBE81A160DEDE, 0x701CE06C38FC1C1C, 0xD3FDBB2EE746FDFD, 0x294D52649A1F4D4D,
+0x7292E4E039769292, 0xC9758FBCEAFA7575, 0x1806301E0C360606, 0x128A249809AE8A8A,
+0xF2B2F940794BB2B2, 0xBFE66359D185E6E6, 0x380E70361C7E0E0E, 0x7C1FF8633EE71F1F,
+0x956237F7C4556262, 0x77D4EEA3B53AD4D4, 0x9AA829324D81A8A8, 0x6296C4F431529696,
+0xC3F99B3AEF62F9F9, 0x33C566F697A3C5C5, 0x942535B14A102525, 0x7959F220B2AB5959,
+0x2A8454AE15D08484, 0xD572B7A7E4C57272, 0xE439D5DD72EC3939, 0x2D4C5A6198164C4C,
+0x655ECA3BBC945E5E, 0xFD78E785F09F7878, 0xE038DDD870E53838, 0x0A8C148605988C8C,
+0x63D1C6B2BF17D1D1, 0xAEA5410B57E4A5A5, 0xAFE2434DD9A1E2E2, 0x99612FF8C24E6161,
+0xF6B3F1457B42B3B3, 0x842115A542342121, 0x4A9C94D625089C9C, 0x781EF0663CEE1E1E,
+0x1143225286614343, 0x3BC776FC93B1C7C7, 0xD7FCB32BE54FFCFC, 0x1004201408240404,
+0x5951B208A2E35151, 0x5E99BCC72F259999, 0xA96D4FC4DA226D6D, 0x340D68391A650D0D,
+0xCFFA8335E979FAFA, 0x5BDFB684A369DFDF, 0xE57ED79BFCA97E7E, 0x90243DB448192424,
+0xEC3BC5D776FE3B3B, 0x96AB313D4B9AABAB, 0x1FCE3ED181F0CECE, 0x4411885522991111,
+0x068F0C8903838F8F, 0x254E4A6B9C044E4E, 0xE6B7D1517366B7B7, 0x8BEB0B60CBE0EBEB,
+0xF03CFDCC78C13C3C, 0x3E817CBF1FFD8181, 0x6A94D4FE35409494, 0xFBF7EB0CF31CF7F7,
+0xDEB9A1676F18B9B9, 0x4C13985F268B1313, 0xB02C7D9C58512C2C, 0x6BD3D6B8BB05D3D3,
+0xBBE76B5CD38CE7E7, 0xA56E57CBDC396E6E, 0x37C46EF395AAC4C4, 0x0C03180F061B0303,
+0x45568A13ACDC5656, 0x0D441A49885E4444, 0xE17FDF9EFEA07F7F, 0x9EA921374F88A9A9,
+0xA82A4D8254672A2A, 0xD6BBB16D6B0ABBBB, 0x23C146E29F87C1C1, 0x5153A202A6F15353,
+0x57DCAE8BA572DCDC, 0x2C0B582716530B0B, 0x4E9D9CD327019D9D, 0xAD6C47C1D82B6C6C,
+0xC43195F562A43131, 0xCD7487B9E8F37474, 0xFFF6E309F115F6F6, 0x05460A438C4C4646,
+0x8AAC092645A5ACAC, 0x1E893C970FB58989, 0x5014A04428B41414, 0xA3E15B42DFBAE1E1,
+0x5816B04E2CA61616, 0xE83ACDD274F73A3A, 0xB9696FD0D2066969, 0x2409482D12410909,
+0xDD70A7ADE0D77070, 0xE2B6D954716FB6B6, 0x67D0CEB7BD1ED0D0, 0x93ED3B7EC7D6EDED,
+0x17CC2EDB85E2CCCC, 0x15422A5784684242, 0x5A98B4C22D2C9898, 0xAAA4490E55EDA4A4,
+0xA0285D8850752828, 0x6D5CDA31B8865C5C, 0xC7F8933FED6BF8F8, 0x228644A411C28686 };
+
+const u64bit Whirlpool::C7[256] = {
+0x186018C07830D818, 0x238C2305AF462623, 0xC63FC67EF991B8C6, 0xE887E8136FCDFBE8,
+0x8726874CA113CB87, 0xB8DAB8A9626D11B8, 0x0104010805020901, 0x4F214F426E9E0D4F,
+0x36D836ADEE6C9B36, 0xA6A2A6590451FFA6, 0xD26FD2DEBDB90CD2, 0xF5F3F5FB06F70EF5,
+0x79F979EF80F29679, 0x6FA16F5FCEDE306F, 0x917E91FCEF3F6D91, 0x525552AA07A4F852,
+0x609D6027FDC04760, 0xBCCABC89766535BC, 0x9B569BACCD2B379B, 0x8E028E048C018A8E,
+0xA3B6A371155BD2A3, 0x0C300C603C186C0C, 0x7BF17BFF8AF6847B, 0x35D435B5E16A8035,
+0x1D741DE8693AF51D, 0xE0A7E05347DDB3E0, 0xD77BD7F6ACB321D7, 0xC22FC25EED999CC2,
+0x2EB82E6D965C432E, 0x4B314B627A96294B, 0xFEDFFEA321E15DFE, 0x5741578216AED557,
+0x155415A8412ABD15, 0x77C1779FB6EEE877, 0x37DC37A5EB6E9237, 0xE5B3E57B56D79EE5,
+0x9F469F8CD923139F, 0xF0E7F0D317FD23F0, 0x4A354A6A7F94204A, 0xDA4FDA9E95A944DA,
+0x587D58FA25B0A258, 0xC903C906CA8FCFC9, 0x29A429558D527C29, 0x0A280A5022145A0A,
+0xB1FEB1E14F7F50B1, 0xA0BAA0691A5DC9A0, 0x6BB16B7FDAD6146B, 0x852E855CAB17D985,
+0xBDCEBD8173673CBD, 0x5D695DD234BA8F5D, 0x1040108050209010, 0xF4F7F4F303F507F4,
+0xCB0BCB16C08BDDCB, 0x3EF83EEDC67CD33E, 0x05140528110A2D05, 0x6781671FE6CE7867,
+0xE4B7E47353D597E4, 0x279C2725BB4E0227, 0x4119413258827341, 0x8B168B2C9D0BA78B,
+0xA7A6A7510153F6A7, 0x7DE97DCF94FAB27D, 0x956E95DCFB374995, 0xD847D88E9FAD56D8,
+0xFBCBFB8B30EB70FB, 0xEE9FEE2371C1CDEE, 0x7CED7CC791F8BB7C, 0x66856617E3CC7166,
+0xDD53DDA68EA77BDD, 0x175C17B84B2EAF17, 0x47014702468E4547, 0x9E429E84DC211A9E,
+0xCA0FCA1EC589D4CA, 0x2DB42D75995A582D, 0xBFC6BF9179632EBF, 0x071C07381B0E3F07,
+0xAD8EAD012347ACAD, 0x5A755AEA2FB4B05A, 0x8336836CB51BEF83, 0x33CC3385FF66B633,
+0x6391633FF2C65C63, 0x020802100A041202, 0xAA92AA39384993AA, 0x71D971AFA8E2DE71,
+0xC807C80ECF8DC6C8, 0x196419C87D32D119, 0x4939497270923B49, 0xD943D9869AAF5FD9,
+0xF2EFF2C31DF931F2, 0xE3ABE34B48DBA8E3, 0x5B715BE22AB6B95B, 0x881A8834920DBC88,
+0x9A529AA4C8293E9A, 0x2698262DBE4C0B26, 0x32C8328DFA64BF32, 0xB0FAB0E94A7D59B0,
+0xE983E91B6ACFF2E9, 0x0F3C0F78331E770F, 0xD573D5E6A6B733D5, 0x803A8074BA1DF480,
+0xBEC2BE997C6127BE, 0xCD13CD26DE87EBCD, 0x34D034BDE4688934, 0x483D487A75903248,
+0xFFDBFFAB24E354FF, 0x7AF57AF78FF48D7A, 0x907A90F4EA3D6490, 0x5F615FC23EBE9D5F,
+0x2080201DA0403D20, 0x68BD6867D5D00F68, 0x1A681AD07234CA1A, 0xAE82AE192C41B7AE,
+0xB4EAB4C95E757DB4, 0x544D549A19A8CE54, 0x937693ECE53B7F93, 0x2288220DAA442F22,
+0x648D6407E9C86364, 0xF1E3F1DB12FF2AF1, 0x73D173BFA2E6CC73, 0x124812905A248212,
+0x401D403A5D807A40, 0x0820084028104808, 0xC32BC356E89B95C3, 0xEC97EC337BC5DFEC,
+0xDB4BDB9690AB4DDB, 0xA1BEA1611F5FC0A1, 0x8D0E8D1C8307918D, 0x3DF43DF5C97AC83D,
+0x976697CCF1335B97, 0x0000000000000000, 0xCF1BCF36D483F9CF, 0x2BAC2B4587566E2B,
+0x76C57697B3ECE176, 0x82328264B019E682, 0xD67FD6FEA9B128D6, 0x1B6C1BD87736C31B,
+0xB5EEB5C15B7774B5, 0xAF86AF112943BEAF, 0x6AB56A77DFD41D6A, 0x505D50BA0DA0EA50,
+0x450945124C8A5745, 0xF3EBF3CB18FB38F3, 0x30C0309DF060AD30, 0xEF9BEF2B74C3C4EF,
+0x3FFC3FE5C37EDA3F, 0x554955921CAAC755, 0xA2B2A2791059DBA2, 0xEA8FEA0365C9E9EA,
+0x6589650FECCA6A65, 0xBAD2BAB9686903BA, 0x2FBC2F65935E4A2F, 0xC027C04EE79D8EC0,
+0xDE5FDEBE81A160DE, 0x1C701CE06C38FC1C, 0xFDD3FDBB2EE746FD, 0x4D294D52649A1F4D,
+0x927292E4E0397692, 0x75C9758FBCEAFA75, 0x061806301E0C3606, 0x8A128A249809AE8A,
+0xB2F2B2F940794BB2, 0xE6BFE66359D185E6, 0x0E380E70361C7E0E, 0x1F7C1FF8633EE71F,
+0x62956237F7C45562, 0xD477D4EEA3B53AD4, 0xA89AA829324D81A8, 0x966296C4F4315296,
+0xF9C3F99B3AEF62F9, 0xC533C566F697A3C5, 0x25942535B14A1025, 0x597959F220B2AB59,
+0x842A8454AE15D084, 0x72D572B7A7E4C572, 0x39E439D5DD72EC39, 0x4C2D4C5A6198164C,
+0x5E655ECA3BBC945E, 0x78FD78E785F09F78, 0x38E038DDD870E538, 0x8C0A8C148605988C,
+0xD163D1C6B2BF17D1, 0xA5AEA5410B57E4A5, 0xE2AFE2434DD9A1E2, 0x6199612FF8C24E61,
+0xB3F6B3F1457B42B3, 0x21842115A5423421, 0x9C4A9C94D625089C, 0x1E781EF0663CEE1E,
+0x4311432252866143, 0xC73BC776FC93B1C7, 0xFCD7FCB32BE54FFC, 0x0410042014082404,
+0x515951B208A2E351, 0x995E99BCC72F2599, 0x6DA96D4FC4DA226D, 0x0D340D68391A650D,
+0xFACFFA8335E979FA, 0xDF5BDFB684A369DF, 0x7EE57ED79BFCA97E, 0x2490243DB4481924,
+0x3BEC3BC5D776FE3B, 0xAB96AB313D4B9AAB, 0xCE1FCE3ED181F0CE, 0x1144118855229911,
+0x8F068F0C8903838F, 0x4E254E4A6B9C044E, 0xB7E6B7D1517366B7, 0xEB8BEB0B60CBE0EB,
+0x3CF03CFDCC78C13C, 0x813E817CBF1FFD81, 0x946A94D4FE354094, 0xF7FBF7EB0CF31CF7,
+0xB9DEB9A1676F18B9, 0x134C13985F268B13, 0x2CB02C7D9C58512C, 0xD36BD3D6B8BB05D3,
+0xE7BBE76B5CD38CE7, 0x6EA56E57CBDC396E, 0xC437C46EF395AAC4, 0x030C03180F061B03,
+0x5645568A13ACDC56, 0x440D441A49885E44, 0x7FE17FDF9EFEA07F, 0xA99EA921374F88A9,
+0x2AA82A4D8254672A, 0xBBD6BBB16D6B0ABB, 0xC123C146E29F87C1, 0x535153A202A6F153,
+0xDC57DCAE8BA572DC, 0x0B2C0B582716530B, 0x9D4E9D9CD327019D, 0x6CAD6C47C1D82B6C,
+0x31C43195F562A431, 0x74CD7487B9E8F374, 0xF6FFF6E309F115F6, 0x4605460A438C4C46,
+0xAC8AAC092645A5AC, 0x891E893C970FB589, 0x145014A04428B414, 0xE1A3E15B42DFBAE1,
+0x165816B04E2CA616, 0x3AE83ACDD274F73A, 0x69B9696FD0D20669, 0x092409482D124109,
+0x70DD70A7ADE0D770, 0xB6E2B6D954716FB6, 0xD067D0CEB7BD1ED0, 0xED93ED3B7EC7D6ED,
+0xCC17CC2EDB85E2CC, 0x4215422A57846842, 0x985A98B4C22D2C98, 0xA4AAA4490E55EDA4,
+0x28A0285D88507528, 0x5C6D5CDA31B8865C, 0xF8C7F8933FED6BF8, 0x86228644A411C286 };
+
+}
diff --git a/src/hash/whirlpool/whrlpool.cpp b/src/hash/whirlpool/whrlpool.cpp
new file mode 100644
index 000000000..9319a8b2a
--- /dev/null
+++ b/src/hash/whirlpool/whrlpool.cpp
@@ -0,0 +1,140 @@
+/*************************************************
+* Whirlpool Source File                          *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#include <botan/whrlpool.h>
+#include <botan/loadstor.h>
+
+namespace Botan {
+
+/*************************************************
+* Whirlpool Compression Function                 *
+*************************************************/
+void Whirlpool::hash(const byte in[])
+   {
+   static const u64bit RC[10] = {
+      0x1823C6E887B8014F, 0x36A6D2F5796F9152,
+      0x60BC9B8EA30C7B35, 0x1DE0D7C22E4BFE57,
+      0x157737E59FF04ADA, 0x58C9290AB1A06B85,
+      0xBD5D10F4CB3E0567, 0xE427418BA77D95D8,
+      0xFBEE7C66DD17479E, 0xCA2DBF07AD5A8333
+   };
+
+   for(u32bit j = 0; j != 8; ++j)
+      M[j] = load_be<u64bit>(in, j);
+
+   u64bit K0, K1, K2, K3, K4, K5, K6, K7;
+   K0 = digest[0]; K1 = digest[1]; K2 = digest[2]; K3 = digest[3];
+   K4 = digest[4]; K5 = digest[5]; K6 = digest[6]; K7 = digest[7];
+
+   u64bit B0, B1, B2, B3, B4, B5, B6, B7;
+   B0 = K0 ^ M[0]; B1 = K1 ^ M[1]; B2 = K2 ^ M[2]; B3 = K3 ^ M[3];
+   B4 = K4 ^ M[4]; B5 = K5 ^ M[5]; B6 = K6 ^ M[6]; B7 = K7 ^ M[7];
+
+   for(u32bit j = 0; j != 10; ++j)
+      {
+      u64bit T0, T1, T2, T3, T4, T5, T6, T7;
+      T0 = C0[get_byte(0, K0)] ^ C1[get_byte(1, K7)] ^
+           C2[get_byte(2, K6)] ^ C3[get_byte(3, K5)] ^
+           C4[get_byte(4, K4)] ^ C5[get_byte(5, K3)] ^
+           C6[get_byte(6, K2)] ^ C7[get_byte(7, K1)] ^ RC[j];
+      T1 = C0[get_byte(0, K1)] ^ C1[get_byte(1, K0)] ^
+           C2[get_byte(2, K7)] ^ C3[get_byte(3, K6)] ^
+           C4[get_byte(4, K5)] ^ C5[get_byte(5, K4)] ^
+           C6[get_byte(6, K3)] ^ C7[get_byte(7, K2)];
+      T2 = C0[get_byte(0, K2)] ^ C1[get_byte(1, K1)] ^
+           C2[get_byte(2, K0)] ^ C3[get_byte(3, K7)] ^
+           C4[get_byte(4, K6)] ^ C5[get_byte(5, K5)] ^
+           C6[get_byte(6, K4)] ^ C7[get_byte(7, K3)];
+      T3 = C0[get_byte(0, K3)] ^ C1[get_byte(1, K2)] ^
+           C2[get_byte(2, K1)] ^ C3[get_byte(3, K0)] ^
+           C4[get_byte(4, K7)] ^ C5[get_byte(5, K6)] ^
+           C6[get_byte(6, K5)] ^ C7[get_byte(7, K4)];
+      T4 = C0[get_byte(0, K4)] ^ C1[get_byte(1, K3)] ^
+           C2[get_byte(2, K2)] ^ C3[get_byte(3, K1)] ^
+           C4[get_byte(4, K0)] ^ C5[get_byte(5, K7)] ^
+           C6[get_byte(6, K6)] ^ C7[get_byte(7, K5)];
+      T5 = C0[get_byte(0, K5)] ^ C1[get_byte(1, K4)] ^
+           C2[get_byte(2, K3)] ^ C3[get_byte(3, K2)] ^
+           C4[get_byte(4, K1)] ^ C5[get_byte(5, K0)] ^
+           C6[get_byte(6, K7)] ^ C7[get_byte(7, K6)];
+      T6 = C0[get_byte(0, K6)] ^ C1[get_byte(1, K5)] ^
+           C2[get_byte(2, K4)] ^ C3[get_byte(3, K3)] ^
+           C4[get_byte(4, K2)] ^ C5[get_byte(5, K1)] ^
+           C6[get_byte(6, K0)] ^ C7[get_byte(7, K7)];
+      T7 = C0[get_byte(0, K7)] ^ C1[get_byte(1, K6)] ^
+           C2[get_byte(2, K5)] ^ C3[get_byte(3, K4)] ^
+           C4[get_byte(4, K3)] ^ C5[get_byte(5, K2)] ^
+           C6[get_byte(6, K1)] ^ C7[get_byte(7, K0)];
+
+      K0 = T0; K1 = T1; K2 = T2; K3 = T3;
+      K4 = T4; K5 = T5; K6 = T6; K7 = T7;
+
+      T0 = C0[get_byte(0, B0)] ^ C1[get_byte(1, B7)] ^
+           C2[get_byte(2, B6)] ^ C3[get_byte(3, B5)] ^
+           C4[get_byte(4, B4)] ^ C5[get_byte(5, B3)] ^
+           C6[get_byte(6, B2)] ^ C7[get_byte(7, B1)] ^ K0;
+      T1 = C0[get_byte(0, B1)] ^ C1[get_byte(1, B0)] ^
+           C2[get_byte(2, B7)] ^ C3[get_byte(3, B6)] ^
+           C4[get_byte(4, B5)] ^ C5[get_byte(5, B4)] ^
+           C6[get_byte(6, B3)] ^ C7[get_byte(7, B2)] ^ K1;
+      T2 = C0[get_byte(0, B2)] ^ C1[get_byte(1, B1)] ^
+           C2[get_byte(2, B0)] ^ C3[get_byte(3, B7)] ^
+           C4[get_byte(4, B6)] ^ C5[get_byte(5, B5)] ^
+           C6[get_byte(6, B4)] ^ C7[get_byte(7, B3)] ^ K2;
+      T3 = C0[get_byte(0, B3)] ^ C1[get_byte(1, B2)] ^
+           C2[get_byte(2, B1)] ^ C3[get_byte(3, B0)] ^
+           C4[get_byte(4, B7)] ^ C5[get_byte(5, B6)] ^
+           C6[get_byte(6, B5)] ^ C7[get_byte(7, B4)] ^ K3;
+      T4 = C0[get_byte(0, B4)] ^ C1[get_byte(1, B3)] ^
+           C2[get_byte(2, B2)] ^ C3[get_byte(3, B1)] ^
+           C4[get_byte(4, B0)] ^ C5[get_byte(5, B7)] ^
+           C6[get_byte(6, B6)] ^ C7[get_byte(7, B5)] ^ K4;
+      T5 = C0[get_byte(0, B5)] ^ C1[get_byte(1, B4)] ^
+           C2[get_byte(2, B3)] ^ C3[get_byte(3, B2)] ^
+           C4[get_byte(4, B1)] ^ C5[get_byte(5, B0)] ^
+           C6[get_byte(6, B7)] ^ C7[get_byte(7, B6)] ^ K5;
+      T6 = C0[get_byte(0, B6)] ^ C1[get_byte(1, B5)] ^
+           C2[get_byte(2, B4)] ^ C3[get_byte(3, B3)] ^
+           C4[get_byte(4, B2)] ^ C5[get_byte(5, B1)] ^
+           C6[get_byte(6, B0)] ^ C7[get_byte(7, B7)] ^ K6;
+      T7 = C0[get_byte(0, B7)] ^ C1[get_byte(1, B6)] ^
+           C2[get_byte(2, B5)] ^ C3[get_byte(3, B4)] ^
+           C4[get_byte(4, B3)] ^ C5[get_byte(5, B2)] ^
+           C6[get_byte(6, B1)] ^ C7[get_byte(7, B0)] ^ K7;
+
+      B0 = T0; B1 = T1; B2 = T2; B3 = T3;
+      B4 = T4; B5 = T5; B6 = T6; B7 = T7;
+      }
+
+   digest[0] ^= B0 ^ M[0];
+   digest[1] ^= B1 ^ M[1];
+   digest[2] ^= B2 ^ M[2];
+   digest[3] ^= B3 ^ M[3];
+   digest[4] ^= B4 ^ M[4];
+   digest[5] ^= B5 ^ M[5];
+   digest[6] ^= B6 ^ M[6];
+   digest[7] ^= B7 ^ M[7];
+   }
+
+/*************************************************
+* Copy out the digest                            *
+*************************************************/
+void Whirlpool::copy_out(byte output[])
+   {
+   for(u32bit j = 0; j != OUTPUT_LENGTH; j += 8)
+      store_be(digest[j/8], output + j);
+   }
+
+/*************************************************
+* Clear memory of sensitive data                 *
+*************************************************/
+void Whirlpool::clear() throw()
+   {
+   MDx_HashFunction::clear();
+   M.clear();
+   digest.clear();
+   }
+
+}
diff --git a/src/hash/whirlpool/whrlpool.h b/src/hash/whirlpool/whrlpool.h
new file mode 100644
index 000000000..22f747520
--- /dev/null
+++ b/src/hash/whirlpool/whrlpool.h
@@ -0,0 +1,40 @@
+/*************************************************
+* Whirlpool Header File                          *
+* (C) 1999-2007 Jack Lloyd                       *
+*************************************************/
+
+#ifndef BOTAN_WHIRLPOOL_H__
+#define BOTAN_WHIRLPOOL_H__
+
+#include <botan/mdx_hash.h>
+
+namespace Botan {
+
+/*************************************************
+* Whirlpool                                      *
+*************************************************/
+class BOTAN_DLL Whirlpool : public MDx_HashFunction
+   {
+   public:
+      void clear() throw();
+      std::string name() const { return "Whirlpool"; }
+      HashFunction* clone() const { return new Whirlpool; }
+      Whirlpool() : MDx_HashFunction(64, 64, true, true, 32) { clear(); }
+   private:
+      void hash(const byte[]);
+      void copy_out(byte[]);
+
+      static const u64bit C0[256];
+      static const u64bit C1[256];
+      static const u64bit C2[256];
+      static const u64bit C3[256];
+      static const u64bit C4[256];
+      static const u64bit C5[256];
+      static const u64bit C6[256];
+      static const u64bit C7[256];
+      SecureBuffer<u64bit, 8> M, digest;
+   };
+
+}
+
+#endif