diff options
Diffstat (limited to 'botan/src/hash')
71 files changed, 6038 insertions, 0 deletions
diff --git a/botan/src/hash/fork256/fork256.cpp b/botan/src/hash/fork256/fork256.cpp new file mode 100644 index 0000000..f80bff4 --- /dev/null +++ b/botan/src/hash/fork256/fork256.cpp @@ -0,0 +1,149 @@ +/* +* FORK-256 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/fork256.h> +#include <botan/loadstor.h> +#include <botan/rotate.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::compress_n(const byte input[], u32bit blocks) + { + const u32bit DELTA[16] = { + 0x428A2F98, 0x71374491, 0xB5C0FBCF, 0xE9B5DBA5, 0x3956C25B, 0x59F111F1, + 0x923F82A4, 0xAB1C5ED5, 0xD807AA98, 0x12835B01, 0x243185BE, 0x550C7DC3, + 0x72BE5D74, 0x80DEB1FE, 0x9BDC06A7, 0xC19BF174 + }; + + for(u32bit i = 0; i != blocks; ++i) + { + 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); + input += HASH_BLOCK_SIZE; + + 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/botan/src/hash/fork256/fork256.h b/botan/src/hash/fork256/fork256.h new file mode 100644 index 0000000..70d336c --- /dev/null +++ b/botan/src/hash/fork256/fork256.h @@ -0,0 +1,35 @@ +/* +* FORK-256 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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 compress_n(const byte[], u32bit blocks); + void copy_out(byte[]); + + SecureBuffer<u32bit, 8> digest; + SecureBuffer<u32bit, 16> M; + }; + +} + +#endif diff --git a/botan/src/hash/fork256/info.txt b/botan/src/hash/fork256/info.txt new file mode 100644 index 0000000..ae0c9f1 --- /dev/null +++ b/botan/src/hash/fork256/info.txt @@ -0,0 +1,14 @@ +realname "FORK-256" + +define FORK_256 + +load_on auto + +<add> +fork256.cpp +fork256.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/gost_3411/gost_3411.cpp b/botan/src/hash/gost_3411/gost_3411.cpp new file mode 100644 index 0000000..5cbb8a7 --- /dev/null +++ b/botan/src/hash/gost_3411/gost_3411.cpp @@ -0,0 +1,236 @@ +/* +* GOST 34.11 +* (C) 2009 Jack Lloyd +*/ + +#include <botan/gost_3411.h> +#include <botan/loadstor.h> +#include <botan/rotate.h> +#include <botan/xor_buf.h> + +namespace Botan { + +/** +* GOST 34.11 Constructor +*/ +GOST_34_11::GOST_34_11() : + HashFunction(32, 32), + cipher(GOST_28147_89_Params("R3411_CryptoPro")) + { + count = 0; + position = 0; + } + +void GOST_34_11::clear() throw() + { + cipher.clear(); + sum.clear(); + hash.clear(); + count = 0; + position = 0; + } + +/** +* Hash additional inputs +*/ +void GOST_34_11::add_data(const byte input[], u32bit length) + { + count += length; + + if(position) + { + buffer.copy(position, input, length); + + if(position + length >= HASH_BLOCK_SIZE) + { + compress_n(buffer.begin(), 1); + input += (HASH_BLOCK_SIZE - position); + length -= (HASH_BLOCK_SIZE - position); + position = 0; + } + } + + const u32bit full_blocks = length / HASH_BLOCK_SIZE; + const u32bit remaining = length % HASH_BLOCK_SIZE; + + if(full_blocks) + compress_n(input, full_blocks); + + buffer.copy(position, input + full_blocks * HASH_BLOCK_SIZE, remaining); + position += remaining; + } + +/** +* The GOST 34.11 compression function +*/ +void GOST_34_11::compress_n(const byte input[], u32bit blocks) + { + for(u32bit i = 0; i != blocks; ++i) + { + for(u32bit j = 0, carry = 0; j != 32; ++j) + { + u16bit s = sum[j] + input[32*i+j] + carry; + carry = get_byte(0, s); + sum[j] = get_byte(1, s); + } + + byte S[32] = { 0 }; + + u64bit U[4], V[4]; + + for(u32bit j = 0; j != 4; ++j) + { + U[j] = load_be<u64bit>(hash, j); + V[j] = load_be<u64bit>(input + 32*i, j); + } + + for(u32bit j = 0; j != 4; ++j) + { + byte key[32] = { 0 }; + + // P transformation + for(size_t k = 0; k != 4; ++k) + for(size_t l = 0; l != 8; ++l) + key[4*l+k] = get_byte(l, U[k]) ^ get_byte(l, V[k]); + + cipher.set_key(key, 32); + cipher.encrypt(hash + 8*j, S + 8*j); + + if(j == 3) + break; + + // A(x) + u64bit A_U = U[0]; + U[0] = U[1]; + U[1] = U[2]; + U[2] = U[3]; + U[3] = U[0] ^ A_U; + + if(j == 1) // C_3 + { + U[0] ^= (u64bit) 0x00FF00FF00FF00FFULL; + U[1] ^= (u64bit) 0xFF00FF00FF00FF00ULL; + U[2] ^= (u64bit) 0x00FFFF00FF0000FFULL; + U[3] ^= (u64bit) 0xFF000000FFFF00FFULL; + } + + // A(A(x)) + u64bit AA_V_1 = V[0] ^ V[1]; + u64bit AA_V_2 = V[1] ^ V[2]; + V[0] = V[2]; + V[1] = V[3]; + V[2] = AA_V_1; + V[3] = AA_V_2; + } + + byte S2[32] = { 0 }; + + // 12 rounds of psi + S2[ 0] = S[24]; + S2[ 1] = S[25]; + S2[ 2] = S[26]; + S2[ 3] = S[27]; + S2[ 4] = S[28]; + S2[ 5] = S[29]; + S2[ 6] = S[30]; + S2[ 7] = S[31]; + S2[ 8] = S[ 0] ^ S[ 2] ^ S[ 4] ^ S[ 6] ^ S[24] ^ S[30]; + S2[ 9] = S[ 1] ^ S[ 3] ^ S[ 5] ^ S[ 7] ^ S[25] ^ S[31]; + S2[10] = S[ 0] ^ S[ 8] ^ S[24] ^ S[26] ^ S[30]; + S2[11] = S[ 1] ^ S[ 9] ^ S[25] ^ S[27] ^ S[31]; + S2[12] = S[ 0] ^ S[ 4] ^ S[ 6] ^ S[10] ^ S[24] ^ S[26] ^ S[28] ^ S[30]; + S2[13] = S[ 1] ^ S[ 5] ^ S[ 7] ^ S[11] ^ S[25] ^ S[27] ^ S[29] ^ S[31]; + S2[14] = S[ 0] ^ S[ 4] ^ S[ 8] ^ S[12] ^ S[24] ^ S[26] ^ S[28]; + S2[15] = S[ 1] ^ S[ 5] ^ S[ 9] ^ S[13] ^ S[25] ^ S[27] ^ S[29]; + S2[16] = S[ 2] ^ S[ 6] ^ S[10] ^ S[14] ^ S[26] ^ S[28] ^ S[30]; + S2[17] = S[ 3] ^ S[ 7] ^ S[11] ^ S[15] ^ S[27] ^ S[29] ^ S[31]; + S2[18] = S[ 0] ^ S[ 2] ^ S[ 6] ^ S[ 8] ^ S[12] ^ S[16] ^ S[24] ^ S[28]; + S2[19] = S[ 1] ^ S[ 3] ^ S[ 7] ^ S[ 9] ^ S[13] ^ S[17] ^ S[25] ^ S[29]; + S2[20] = S[ 2] ^ S[ 4] ^ S[ 8] ^ S[10] ^ S[14] ^ S[18] ^ S[26] ^ S[30]; + S2[21] = S[ 3] ^ S[ 5] ^ S[ 9] ^ S[11] ^ S[15] ^ S[19] ^ S[27] ^ S[31]; + S2[22] = S[ 0] ^ S[ 2] ^ S[10] ^ S[12] ^ S[16] ^ S[20] ^ S[24] ^ S[28] ^ S[30]; + S2[23] = S[ 1] ^ S[ 3] ^ S[11] ^ S[13] ^ S[17] ^ S[21] ^ S[25] ^ S[29] ^ S[31]; + S2[24] = S[ 0] ^ S[ 6] ^ S[12] ^ S[14] ^ S[18] ^ S[22] ^ S[24] ^ S[26]; + S2[25] = S[ 1] ^ S[ 7] ^ S[13] ^ S[15] ^ S[19] ^ S[23] ^ S[25] ^ S[27]; + S2[26] = S[ 2] ^ S[ 8] ^ S[14] ^ S[16] ^ S[20] ^ S[24] ^ S[26] ^ S[28]; + S2[27] = S[ 3] ^ S[ 9] ^ S[15] ^ S[17] ^ S[21] ^ S[25] ^ S[27] ^ S[29]; + S2[28] = S[ 4] ^ S[10] ^ S[16] ^ S[18] ^ S[22] ^ S[26] ^ S[28] ^ S[30]; + S2[29] = S[ 5] ^ S[11] ^ S[17] ^ S[19] ^ S[23] ^ S[27] ^ S[29] ^ S[31]; + S2[30] = S[ 0] ^ S[ 2] ^ S[ 4] ^ S[12] ^ S[18] ^ S[20] ^ S[28]; + S2[31] = S[ 1] ^ S[ 3] ^ S[ 5] ^ S[13] ^ S[19] ^ S[21] ^ S[29]; + + xor_buf(S, S2, input + 32*i, 32); + + S2[0] = S[0] ^ S[2] ^ S[4] ^ S[6] ^ S[24] ^ S[30]; + S2[1] = S[1] ^ S[3] ^ S[5] ^ S[7] ^ S[25] ^ S[31]; + + copy_mem(S, S+2, 30); + S[30] = S2[0]; + S[31] = S2[1]; + + xor_buf(S, hash, 32); + + // 61 rounds of psi + S2[ 0] = S[ 2] ^ S[ 6] ^ S[14] ^ S[20] ^ S[22] ^ S[26] ^ S[28] ^ S[30]; + S2[ 1] = S[ 3] ^ S[ 7] ^ S[15] ^ S[21] ^ S[23] ^ S[27] ^ S[29] ^ S[31]; + S2[ 2] = S[ 0] ^ S[ 2] ^ S[ 6] ^ S[ 8] ^ S[16] ^ S[22] ^ S[28]; + S2[ 3] = S[ 1] ^ S[ 3] ^ S[ 7] ^ S[ 9] ^ S[17] ^ S[23] ^ S[29]; + S2[ 4] = S[ 2] ^ S[ 4] ^ S[ 8] ^ S[10] ^ S[18] ^ S[24] ^ S[30]; + S2[ 5] = S[ 3] ^ S[ 5] ^ S[ 9] ^ S[11] ^ S[19] ^ S[25] ^ S[31]; + S2[ 6] = S[ 0] ^ S[ 2] ^ S[10] ^ S[12] ^ S[20] ^ S[24] ^ S[26] ^ S[30]; + S2[ 7] = S[ 1] ^ S[ 3] ^ S[11] ^ S[13] ^ S[21] ^ S[25] ^ S[27] ^ S[31]; + S2[ 8] = S[ 0] ^ S[ 6] ^ S[12] ^ S[14] ^ S[22] ^ S[24] ^ S[26] ^ S[28] ^ S[30]; + S2[ 9] = S[ 1] ^ S[ 7] ^ S[13] ^ S[15] ^ S[23] ^ S[25] ^ S[27] ^ S[29] ^ S[31]; + S2[10] = S[ 0] ^ S[ 4] ^ S[ 6] ^ S[ 8] ^ S[14] ^ S[16] ^ S[26] ^ S[28]; + S2[11] = S[ 1] ^ S[ 5] ^ S[ 7] ^ S[ 9] ^ S[15] ^ S[17] ^ S[27] ^ S[29]; + S2[12] = S[ 2] ^ S[ 6] ^ S[ 8] ^ S[10] ^ S[16] ^ S[18] ^ S[28] ^ S[30]; + S2[13] = S[ 3] ^ S[ 7] ^ S[ 9] ^ S[11] ^ S[17] ^ S[19] ^ S[29] ^ S[31]; + S2[14] = S[ 0] ^ S[ 2] ^ S[ 6] ^ S[ 8] ^ S[10] ^ S[12] ^ S[18] ^ S[20] ^ S[24]; + S2[15] = S[ 1] ^ S[ 3] ^ S[ 7] ^ S[ 9] ^ S[11] ^ S[13] ^ S[19] ^ S[21] ^ S[25]; + S2[16] = S[ 2] ^ S[ 4] ^ S[ 8] ^ S[10] ^ S[12] ^ S[14] ^ S[20] ^ S[22] ^ S[26]; + S2[17] = S[ 3] ^ S[ 5] ^ S[ 9] ^ S[11] ^ S[13] ^ S[15] ^ S[21] ^ S[23] ^ S[27]; + S2[18] = S[ 4] ^ S[ 6] ^ S[10] ^ S[12] ^ S[14] ^ S[16] ^ S[22] ^ S[24] ^ S[28]; + S2[19] = S[ 5] ^ S[ 7] ^ S[11] ^ S[13] ^ S[15] ^ S[17] ^ S[23] ^ S[25] ^ S[29]; + S2[20] = S[ 6] ^ S[ 8] ^ S[12] ^ S[14] ^ S[16] ^ S[18] ^ S[24] ^ S[26] ^ S[30]; + S2[21] = S[ 7] ^ S[ 9] ^ S[13] ^ S[15] ^ S[17] ^ S[19] ^ S[25] ^ S[27] ^ S[31]; + S2[22] = S[ 0] ^ S[ 2] ^ S[ 4] ^ S[ 6] ^ S[ 8] ^ S[10] ^ S[14] ^ S[16] ^ S[18] ^ S[20] ^ S[24] ^ S[26] ^ S[28] ^ S[30]; + S2[23] = S[ 1] ^ S[ 3] ^ S[ 5] ^ S[ 7] ^ S[ 9] ^ S[11] ^ S[15] ^ S[17] ^ S[19] ^ S[21] ^ S[25] ^ S[27] ^ S[29] ^ S[31]; + S2[24] = S[ 0] ^ S[ 8] ^ S[10] ^ S[12] ^ S[16] ^ S[18] ^ S[20] ^ S[22] ^ S[24] ^ S[26] ^ S[28]; + S2[25] = S[ 1] ^ S[ 9] ^ S[11] ^ S[13] ^ S[17] ^ S[19] ^ S[21] ^ S[23] ^ S[25] ^ S[27] ^ S[29]; + S2[26] = S[ 2] ^ S[10] ^ S[12] ^ S[14] ^ S[18] ^ S[20] ^ S[22] ^ S[24] ^ S[26] ^ S[28] ^ S[30]; + S2[27] = S[ 3] ^ S[11] ^ S[13] ^ S[15] ^ S[19] ^ S[21] ^ S[23] ^ S[25] ^ S[27] ^ S[29] ^ S[31]; + S2[28] = S[ 0] ^ S[ 2] ^ S[ 6] ^ S[12] ^ S[14] ^ S[16] ^ S[20] ^ S[22] ^ S[26] ^ S[28]; + S2[29] = S[ 1] ^ S[ 3] ^ S[ 7] ^ S[13] ^ S[15] ^ S[17] ^ S[21] ^ S[23] ^ S[27] ^ S[29]; + S2[30] = S[ 2] ^ S[ 4] ^ S[ 8] ^ S[14] ^ S[16] ^ S[18] ^ S[22] ^ S[24] ^ S[28] ^ S[30]; + S2[31] = S[ 3] ^ S[ 5] ^ S[ 9] ^ S[15] ^ S[17] ^ S[19] ^ S[23] ^ S[25] ^ S[29] ^ S[31]; + + hash.copy(S2, 32); + } + } + +/** +* Produce the final GOST 34.11 output +*/ +void GOST_34_11::final_result(byte out[]) + { + if(position) + { + clear_mem(buffer.begin() + position, buffer.size() - position); + compress_n(buffer, 1); + } + + SecureBuffer<byte, 32> length_buf; + const u64bit bit_count = count * 8; + store_le(bit_count, length_buf); + + SecureBuffer<byte, 32> sum_buf(sum); + + compress_n(length_buf, 1); + compress_n(sum_buf, 1); + + copy_mem(out, hash.begin(), 32); + + clear(); + } + +} diff --git a/botan/src/hash/gost_3411/gost_3411.h b/botan/src/hash/gost_3411/gost_3411.h new file mode 100644 index 0000000..c695550 --- /dev/null +++ b/botan/src/hash/gost_3411/gost_3411.h @@ -0,0 +1,41 @@ +/** +* GOST 34.11 +* (C) 2009 Jack Lloyd +*/ + +#ifndef BOTAN_GOST_3411_H__ +#define BOTAN_GOST_3411_H__ + +#include <botan/hash.h> +#include <botan/gost_28147.h> + +namespace Botan { + +/** +* GOST 34.11 +*/ +class BOTAN_DLL GOST_34_11 : public HashFunction + { + public: + void clear() throw(); + std::string name() const { return "GOST-R-34.11-94" ; } + HashFunction* clone() const { return new GOST_34_11; } + + GOST_34_11(); + protected: + void compress_n(const byte input[], u32bit blocks); + + void add_data(const byte[], u32bit); + void final_result(byte[]); + + GOST_28147_89 cipher; + SecureBuffer<byte, 32> buffer; + SecureBuffer<byte, 32> sum; + SecureBuffer<byte, 32> hash; + u64bit count; + u32bit position; + }; + +} + +#endif diff --git a/botan/src/hash/gost_3411/info.txt b/botan/src/hash/gost_3411/info.txt new file mode 100644 index 0000000..65b9475 --- /dev/null +++ b/botan/src/hash/gost_3411/info.txt @@ -0,0 +1,14 @@ +realname "GOST 34.11" + +define GOST_34_11 + +load_on auto + +<add> +gost_3411.cpp +gost_3411.h +</add> + +<requires> +gost_28147 +</requires> diff --git a/botan/src/hash/has160/has160.cpp b/botan/src/hash/has160/has160.cpp new file mode 100644 index 0000000..9a505d3 --- /dev/null +++ b/botan/src/hash/has160/has160.cpp @@ -0,0 +1,159 @@ +/* +* HAS-160 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/has160.h> +#include <botan/loadstor.h> +#include <botan/rotate.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::compress_n(const byte input[], u32bit blocks) + { + for(u32bit i = 0; i != blocks; ++i) + { + 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/botan/src/hash/has160/has160.h b/botan/src/hash/has160/has160.h new file mode 100644 index 0000000..44bb63b --- /dev/null +++ b/botan/src/hash/has160/has160.h @@ -0,0 +1,35 @@ +/* +* HAS-160 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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 compress_n(const byte[], u32bit blocks); + void copy_out(byte[]); + + SecureBuffer<u32bit, 20> X; + SecureBuffer<u32bit, 5> digest; + }; + +} + +#endif diff --git a/botan/src/hash/has160/info.txt b/botan/src/hash/has160/info.txt new file mode 100644 index 0000000..a945f32 --- /dev/null +++ b/botan/src/hash/has160/info.txt @@ -0,0 +1,14 @@ +realname "HAS-160" + +define HAS_160 + +load_on auto + +<add> +has160.cpp +has160.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/hash.h b/botan/src/hash/hash.h new file mode 100644 index 0000000..a30234b --- /dev/null +++ b/botan/src/hash/hash.h @@ -0,0 +1,52 @@ +/** +* Hash Function Base Class +* (C) 1999-2008 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_HASH_FUNCTION_BASE_CLASS_H__ +#define BOTAN_HASH_FUNCTION_BASE_CLASS_H__ + +#include <botan/buf_comp.h> +#include <string> + +namespace Botan { + +/** +* This class represents hash function (message digest) objects. +*/ +class BOTAN_DLL HashFunction : public BufferedComputation + { + public: + /** + * The hash block size as defined for this algorithm. + */ + const u32bit HASH_BLOCK_SIZE; + + /** + * Get a new object representing the same algorithm as *this + */ + virtual HashFunction* clone() const = 0; + + /** + * Get the name of this algorithm. + * @return the name of this algorithm + */ + virtual std::string name() const = 0; + + /** + * Reset the internal state of this object. + */ + virtual void clear() throw() = 0; + + HashFunction(u32bit hash_len, u32bit block_len = 0) : + BufferedComputation(hash_len), HASH_BLOCK_SIZE(block_len) {} + virtual ~HashFunction() {} + private: + HashFunction& operator=(const HashFunction&); + }; + +} + +#endif diff --git a/botan/src/hash/info.txt b/botan/src/hash/info.txt new file mode 100644 index 0000000..ce55f7d --- /dev/null +++ b/botan/src/hash/info.txt @@ -0,0 +1,11 @@ +realname "Hash Functions" + +load_on auto + +<add> +hash.h +</add> + +<requires> +buf_comp +</requires> diff --git a/botan/src/hash/md2/info.txt b/botan/src/hash/md2/info.txt new file mode 100644 index 0000000..ff33e1e --- /dev/null +++ b/botan/src/hash/md2/info.txt @@ -0,0 +1,10 @@ +realname "MD2" + +define MD2 + +load_on auto + +<add> +md2.cpp +md2.h +</add> diff --git a/botan/src/hash/md2/md2.cpp b/botan/src/hash/md2/md2.cpp new file mode 100644 index 0000000..c67e72b --- /dev/null +++ b/botan/src/hash/md2/md2.cpp @@ -0,0 +1,108 @@ +/* +* MD2 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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/botan/src/hash/md2/md2.h b/botan/src/hash/md2/md2.h new file mode 100644 index 0000000..9337c43 --- /dev/null +++ b/botan/src/hash/md2/md2.h @@ -0,0 +1,37 @@ +/* +* MD2 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_MD2_H__ +#define BOTAN_MD2_H__ + +#include <botan/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/botan/src/hash/md4/info.txt b/botan/src/hash/md4/info.txt new file mode 100644 index 0000000..fc9cbe1 --- /dev/null +++ b/botan/src/hash/md4/info.txt @@ -0,0 +1,14 @@ +realname "MD4" + +define MD4 + +load_on auto + +<add> +md4.cpp +md4.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/md4/md4.cpp b/botan/src/hash/md4/md4.cpp new file mode 100644 index 0000000..39e3c8c --- /dev/null +++ b/botan/src/hash/md4/md4.cpp @@ -0,0 +1,108 @@ +/* +* MD4 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/md4.h> +#include <botan/loadstor.h> +#include <botan/rotate.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::compress_n(const byte input[], u32bit blocks) + { + u32bit A = digest[0], B = digest[1], C = digest[2], D = digest[3]; + + for(u32bit i = 0; i != blocks; ++i) + { + for(u32bit j = 0; j != 16; ++j) + M[j] = load_le<u32bit>(input, j); + input += HASH_BLOCK_SIZE; + + 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); + + A = (digest[0] += A); + B = (digest[1] += B); + C = (digest[2] += C); + D = (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/botan/src/hash/md4/md4.h b/botan/src/hash/md4/md4.h new file mode 100644 index 0000000..df6f229 --- /dev/null +++ b/botan/src/hash/md4/md4.h @@ -0,0 +1,36 @@ +/* +* MD4 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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(); } + protected: + void compress_n(const byte input[], u32bit blocks); + void hash_old(const byte[]); + void copy_out(byte[]); + + SecureBuffer<u32bit, 48> M; + SecureBuffer<u32bit, 4> digest; + }; + +} + +#endif diff --git a/botan/src/hash/md4_ia32/info.txt b/botan/src/hash/md4_ia32/info.txt new file mode 100644 index 0000000..fee7dd1 --- /dev/null +++ b/botan/src/hash/md4_ia32/info.txt @@ -0,0 +1,35 @@ +realname "MD4 (IA-32)" + +define MD4_IA32 + +load_on asm_ok + +<add> +md4_ia32_imp.S +md4_ia32.cpp +md4_ia32.h +</add> + +<arch> +ia32 +</arch> + +<cc> +gcc +icc +</cc> + +# ELF systems +<os> +linux +freebsd +dragonfly +netbsd +openbsd +solaris +</os> + +<requires> +asm_ia32 +md4 +</requires> diff --git a/botan/src/hash/md4_ia32/md4_ia32.cpp b/botan/src/hash/md4_ia32/md4_ia32.cpp new file mode 100644 index 0000000..12fe71d --- /dev/null +++ b/botan/src/hash/md4_ia32/md4_ia32.cpp @@ -0,0 +1,27 @@ +/* +* MD4 (IA-32) +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/md4_ia32.h> +#include <botan/loadstor.h> + +namespace Botan { + +extern "C" void botan_md4_ia32_compress(u32bit[4], const byte[64], u32bit[16]); + +/* +* MD4 Compression Function +*/ +void MD4_IA32::compress_n(const byte input[], u32bit blocks) + { + for(u32bit i = 0; i != blocks; ++i) + { + botan_md4_ia32_compress(digest, input, M); + input += HASH_BLOCK_SIZE; + } + } + +} diff --git a/botan/src/hash/md4_ia32/md4_ia32.h b/botan/src/hash/md4_ia32/md4_ia32.h new file mode 100644 index 0000000..f01d148 --- /dev/null +++ b/botan/src/hash/md4_ia32/md4_ia32.h @@ -0,0 +1,28 @@ +/* +* MD4 (IA-32) +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_MD4_IA32_H__ +#define BOTAN_MD4_IA32_H__ + +#include <botan/md4.h> + +namespace Botan { + +/* +* MD4 +*/ +class BOTAN_DLL MD4_IA32 : public MD4 + { + public: + HashFunction* clone() const { return new MD4_IA32; } + private: + void compress_n(const byte[], u32bit blocks); + }; + +} + +#endif diff --git a/botan/src/hash/md4_ia32/md4_ia32_imp.S b/botan/src/hash/md4_ia32/md4_ia32_imp.S new file mode 100644 index 0000000..ca04cbe --- /dev/null +++ b/botan/src/hash/md4_ia32/md4_ia32_imp.S @@ -0,0 +1,137 @@ +/* +* MD4 Source File +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/asm_macr.h> + +START_LISTING(md4_ia32.S) + +START_FUNCTION(botan_md4_ia32_compress) + SPILL_REGS() + +#define PUSHED 4 + + ASSIGN(EBP, ARG(2)) /* input block */ + ASSIGN(EDI, ARG(3)) /* expanded words */ + + ZEROIZE(ESI) + +START_LOOP(.LOAD_INPUT) + ADD_IMM(ESI, 4) + + ASSIGN(EAX, ARRAY4(EBP, 0)) + ASSIGN(EBX, ARRAY4(EBP, 1)) + ASSIGN(ECX, ARRAY4(EBP, 2)) + ASSIGN(EDX, ARRAY4(EBP, 3)) + + ADD_IMM(EBP, 16) + + ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-4), EAX) + ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-3), EBX) + ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-2), ECX) + ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-1), EDX) +LOOP_UNTIL_EQ(ESI, 16, .LOAD_INPUT) + + ASSIGN(EBP, ARG(1)) + ASSIGN(EAX, ARRAY4(EBP, 0)) + ASSIGN(EBX, ARRAY4(EBP, 1)) + ASSIGN(ECX, ARRAY4(EBP, 2)) + ASSIGN(EDX, ARRAY4(EBP, 3)) + +#define MSG EDI +#define T1 ESI +#define T2 EBP + +#define FF(A, B, C, D, N, S) \ + ASSIGN(T1, ARRAY4(MSG, N)) ; \ + ASSIGN(T2, C) ; \ + XOR(T2, D) ; \ + AND(T2, B) ; \ + XOR(T2, D) ; \ + ADD(A, T1) ; \ + ADD(A, T2) ; \ + ROTL_IMM(A, S) ; + +#define GG(A, B, C, D, N, S) \ + ASSIGN(T1, ARRAY4(MSG, N)) ; \ + ASSIGN(T2, B) ; \ + OR(T2, C) ; \ + AND(T2, D) ; \ + ADD3_IMM(A, T1, 0x5A827999) ; \ + ASSIGN(T1, B) ; \ + AND(T1, C) ; \ + OR(T2, T1) ; \ + ADD(A, T2) ; \ + ROTL_IMM(A, S) ; + +#define HH(A, B, C, D, N, S) \ + ASSIGN(T1, ARRAY4(MSG, N)) ; \ + ASSIGN(T2, B) ; \ + XOR(T2, C) ; \ + XOR(T2, D) ; \ + ADD3_IMM(A, T1, 0x6ED9EBA1) ; \ + ADD(A, T2) ; \ + ROTL_IMM(A, S) ; + + FF(EAX,EBX,ECX,EDX, 0, 3); + FF(EDX,EAX,EBX,ECX, 1, 7); + FF(ECX,EDX,EAX,EBX, 2,11); + FF(EBX,ECX,EDX,EAX, 3,19); + FF(EAX,EBX,ECX,EDX, 4, 3); + FF(EDX,EAX,EBX,ECX, 5, 7); + FF(ECX,EDX,EAX,EBX, 6,11); + FF(EBX,ECX,EDX,EAX, 7,19); + FF(EAX,EBX,ECX,EDX, 8, 3); + FF(EDX,EAX,EBX,ECX, 9, 7); + FF(ECX,EDX,EAX,EBX,10,11); + FF(EBX,ECX,EDX,EAX,11,19); + FF(EAX,EBX,ECX,EDX,12, 3); + FF(EDX,EAX,EBX,ECX,13, 7); + FF(ECX,EDX,EAX,EBX,14,11); + FF(EBX,ECX,EDX,EAX,15,19); + + GG(EAX,EBX,ECX,EDX, 0, 3); + GG(EDX,EAX,EBX,ECX, 4, 5); + GG(ECX,EDX,EAX,EBX, 8, 9); + GG(EBX,ECX,EDX,EAX,12,13); + GG(EAX,EBX,ECX,EDX, 1, 3); + GG(EDX,EAX,EBX,ECX, 5, 5); + GG(ECX,EDX,EAX,EBX, 9, 9); + GG(EBX,ECX,EDX,EAX,13,13); + GG(EAX,EBX,ECX,EDX, 2, 3); + GG(EDX,EAX,EBX,ECX, 6, 5); + GG(ECX,EDX,EAX,EBX,10, 9); + GG(EBX,ECX,EDX,EAX,14,13); + GG(EAX,EBX,ECX,EDX, 3, 3); + GG(EDX,EAX,EBX,ECX, 7, 5); + GG(ECX,EDX,EAX,EBX,11, 9); + GG(EBX,ECX,EDX,EAX,15,13); + + HH(EAX,EBX,ECX,EDX, 0, 3); + HH(EDX,EAX,EBX,ECX, 8, 9); + HH(ECX,EDX,EAX,EBX, 4,11); + HH(EBX,ECX,EDX,EAX,12,15); + HH(EAX,EBX,ECX,EDX, 2, 3); + HH(EDX,EAX,EBX,ECX,10, 9); + HH(ECX,EDX,EAX,EBX, 6,11); + HH(EBX,ECX,EDX,EAX,14,15); + HH(EAX,EBX,ECX,EDX, 1, 3); + HH(EDX,EAX,EBX,ECX, 9, 9); + HH(ECX,EDX,EAX,EBX, 5,11); + HH(EBX,ECX,EDX,EAX,13,15); + HH(EAX,EBX,ECX,EDX, 3, 3); + HH(EDX,EAX,EBX,ECX,11, 9); + HH(ECX,EDX,EAX,EBX, 7,11); + HH(EBX,ECX,EDX,EAX,15,15); + + ASSIGN(EBP, ARG(1)) + ADD(ARRAY4(EBP, 0), EAX) + ADD(ARRAY4(EBP, 1), EBX) + ADD(ARRAY4(EBP, 2), ECX) + ADD(ARRAY4(EBP, 3), EDX) + + RESTORE_REGS() +END_FUNCTION(botan_md4_ia32_compress) diff --git a/botan/src/hash/md5/info.txt b/botan/src/hash/md5/info.txt new file mode 100644 index 0000000..525a45a --- /dev/null +++ b/botan/src/hash/md5/info.txt @@ -0,0 +1,14 @@ +realname "MD5" + +define MD5 + +load_on auto + +<add> +md5.cpp +md5.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/md5/md5.cpp b/botan/src/hash/md5/md5.cpp new file mode 100644 index 0000000..7c280aa --- /dev/null +++ b/botan/src/hash/md5/md5.cpp @@ -0,0 +1,136 @@ +/* +* MD5 +* (C) 1999-2008 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/md5.h> +#include <botan/loadstor.h> +#include <botan/rotate.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::compress_n(const byte input[], u32bit blocks) + { + u32bit A = digest[0], B = digest[1], C = digest[2], D = digest[3]; + + for(u32bit i = 0; i != blocks; ++i) + { + for(u32bit j = 0; j != 16; ++j) + M[j] = load_le<u32bit>(input, j); + input += HASH_BLOCK_SIZE; + + 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); + + A = (digest[0] += A); + B = (digest[1] += B); + C = (digest[2] += C); + D = (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/botan/src/hash/md5/md5.h b/botan/src/hash/md5/md5.h new file mode 100644 index 0000000..85f684d --- /dev/null +++ b/botan/src/hash/md5/md5.h @@ -0,0 +1,35 @@ +/** +* MD5 +* (C) 1999-2008 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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(); } + protected: + void compress_n(const byte[], u32bit blocks); + void copy_out(byte[]); + + SecureBuffer<u32bit, 16> M; + SecureBuffer<u32bit, 4> digest; + }; + +} + +#endif diff --git a/botan/src/hash/md5_ia32/info.txt b/botan/src/hash/md5_ia32/info.txt new file mode 100644 index 0000000..ad9923b --- /dev/null +++ b/botan/src/hash/md5_ia32/info.txt @@ -0,0 +1,35 @@ +realname "MD5 (IA-32)" + +define MD5_IA32 + +load_on asm_ok + +<add> +md5_ia32_imp.S +md5_ia32.cpp +md5_ia32.h +</add> + +<arch> +ia32 +</arch> + +<cc> +gcc +icc +</cc> + +# ELF systems +<os> +linux +freebsd +dragonfly +netbsd +openbsd +solaris +</os> + +<requires> +asm_ia32 +md5 +</requires> diff --git a/botan/src/hash/md5_ia32/md5_ia32.cpp b/botan/src/hash/md5_ia32/md5_ia32.cpp new file mode 100644 index 0000000..443569b --- /dev/null +++ b/botan/src/hash/md5_ia32/md5_ia32.cpp @@ -0,0 +1,32 @@ +/* +* MD5 (IA-32) +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/md5_ia32.h> +#include <botan/loadstor.h> + +namespace Botan { + +namespace { + +extern "C" +void botan_md5_ia32_compress(u32bit[4], const byte[64], u32bit[16]); + +} + +/* +* MD5 Compression Function +*/ +void MD5_IA32::compress_n(const byte input[], u32bit blocks) + { + for(u32bit i = 0; i != blocks; ++i) + { + botan_md5_ia32_compress(digest, input, M); + input += HASH_BLOCK_SIZE; + } + } + +} diff --git a/botan/src/hash/md5_ia32/md5_ia32.h b/botan/src/hash/md5_ia32/md5_ia32.h new file mode 100644 index 0000000..723d724 --- /dev/null +++ b/botan/src/hash/md5_ia32/md5_ia32.h @@ -0,0 +1,28 @@ +/* +* MD5 (IA-32) +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_MD5_IA32_H__ +#define BOTAN_MD5_IA32_H__ + +#include <botan/md5.h> + +namespace Botan { + +/* +* MD5 +*/ +class BOTAN_DLL MD5_IA32 : public MD5 + { + public: + HashFunction* clone() const { return new MD5_IA32; } + private: + void compress_n(const byte[], u32bit blocks); + }; + +} + +#endif diff --git a/botan/src/hash/md5_ia32/md5_ia32_imp.S b/botan/src/hash/md5_ia32/md5_ia32_imp.S new file mode 100644 index 0000000..8087bbd --- /dev/null +++ b/botan/src/hash/md5_ia32/md5_ia32_imp.S @@ -0,0 +1,166 @@ +/* +* MD5 Source File +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/asm_macr.h> + +START_LISTING(md5_ia32.S) + +START_FUNCTION(botan_md5_ia32_compress) + SPILL_REGS() + +#define PUSHED 4 + + ASSIGN(EBP, ARG(2)) /* input block */ + ASSIGN(EDI, ARG(3)) /* expanded words */ + + ZEROIZE(ESI) + +START_LOOP(.LOAD_INPUT) + ADD_IMM(ESI, 4) + + ASSIGN(EAX, ARRAY4(EBP, 0)) + ASSIGN(EBX, ARRAY4(EBP, 1)) + ASSIGN(ECX, ARRAY4(EBP, 2)) + ASSIGN(EDX, ARRAY4(EBP, 3)) + + ADD_IMM(EBP, 16) + + ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-4), EAX) + ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-3), EBX) + ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-2), ECX) + ASSIGN(ARRAY4_INDIRECT(EDI,ESI,-1), EDX) +LOOP_UNTIL_EQ(ESI, 16, .LOAD_INPUT) + + ASSIGN(EBP, ARG(1)) + ASSIGN(EAX, ARRAY4(EBP, 0)) + ASSIGN(EBX, ARRAY4(EBP, 1)) + ASSIGN(ECX, ARRAY4(EBP, 2)) + ASSIGN(EDX, ARRAY4(EBP, 3)) + +#define MSG EDI +#define T1 ESI +#define T2 EBP + +#define FF(A, B, C, D, N, S, MAGIC) \ + ASSIGN(T1, ARRAY4(MSG, N)) ; \ + ASSIGN(T2, C) ; \ + XOR(T2, D) ; \ + AND(T2, B) ; \ + XOR(T2, D) ; \ + ADD3_IMM(A, T1, MAGIC) ; \ + ADD(A, T2) ; \ + ROTL_IMM(A, S) ; \ + ADD(A, B) ; + +#define GG(A, B, C, D, N, S, MAGIC) \ + ASSIGN(T1, ARRAY4(MSG, N)) ; \ + ASSIGN(T2, B) ; \ + XOR(T2, C) ; \ + AND(T2, D) ; \ + XOR(T2, C) ; \ + ADD3_IMM(A, T1, MAGIC) ; \ + ADD(A, T2) ; \ + ROTL_IMM(A, S) ; \ + ADD(A, B) ; + +#define HH(A, B, C, D, N, S, MAGIC) \ + ASSIGN(T1, ARRAY4(MSG, N)) ; \ + ASSIGN(T2, B) ; \ + XOR(T2, C) ; \ + XOR(T2, D) ; \ + ADD3_IMM(A, T1, MAGIC) ; \ + ADD(A, T2) ; \ + ROTL_IMM(A, S) ; \ + ADD(A, B) ; + +#define II(A, B, C, D, N, S, MAGIC) \ + ASSIGN(T1, ARRAY4(MSG, N)) ; \ + ASSIGN(T2, D) ; \ + NOT(T2) ; \ + OR(T2, B) ; \ + XOR(T2, C) ; \ + ADD3_IMM(A, T1, MAGIC) ; \ + ADD(A, T2) ; \ + ROTL_IMM(A, S) ; \ + ADD(A, B) ; + + FF(EAX,EBX,ECX,EDX, 0, 7,0xD76AA478); + FF(EDX,EAX,EBX,ECX, 1,12,0xE8C7B756); + FF(ECX,EDX,EAX,EBX, 2,17,0x242070DB); + FF(EBX,ECX,EDX,EAX, 3,22,0xC1BDCEEE); + FF(EAX,EBX,ECX,EDX, 4, 7,0xF57C0FAF); + FF(EDX,EAX,EBX,ECX, 5,12,0x4787C62A); + FF(ECX,EDX,EAX,EBX, 6,17,0xA8304613); + FF(EBX,ECX,EDX,EAX, 7,22,0xFD469501); + FF(EAX,EBX,ECX,EDX, 8, 7,0x698098D8); + FF(EDX,EAX,EBX,ECX, 9,12,0x8B44F7AF); + FF(ECX,EDX,EAX,EBX,10,17,0xFFFF5BB1); + FF(EBX,ECX,EDX,EAX,11,22,0x895CD7BE); + FF(EAX,EBX,ECX,EDX,12, 7,0x6B901122); + FF(EDX,EAX,EBX,ECX,13,12,0xFD987193); + FF(ECX,EDX,EAX,EBX,14,17,0xA679438E); + FF(EBX,ECX,EDX,EAX,15,22,0x49B40821); + + GG(EAX,EBX,ECX,EDX, 1, 5,0xF61E2562); + GG(EDX,EAX,EBX,ECX, 6, 9,0xC040B340); + GG(ECX,EDX,EAX,EBX,11,14,0x265E5A51); + GG(EBX,ECX,EDX,EAX, 0,20,0xE9B6C7AA); + GG(EAX,EBX,ECX,EDX, 5, 5,0xD62F105D); + GG(EDX,EAX,EBX,ECX,10, 9,0x02441453); + GG(ECX,EDX,EAX,EBX,15,14,0xD8A1E681); + GG(EBX,ECX,EDX,EAX, 4,20,0xE7D3FBC8); + GG(EAX,EBX,ECX,EDX, 9, 5,0x21E1CDE6); + GG(EDX,EAX,EBX,ECX,14, 9,0xC33707D6); + GG(ECX,EDX,EAX,EBX, 3,14,0xF4D50D87); + GG(EBX,ECX,EDX,EAX, 8,20,0x455A14ED); + GG(EAX,EBX,ECX,EDX,13, 5,0xA9E3E905); + GG(EDX,EAX,EBX,ECX, 2, 9,0xFCEFA3F8); + GG(ECX,EDX,EAX,EBX, 7,14,0x676F02D9); + GG(EBX,ECX,EDX,EAX,12,20,0x8D2A4C8A); + + HH(EAX,EBX,ECX,EDX, 5, 4,0xFFFA3942); + HH(EDX,EAX,EBX,ECX, 8,11,0x8771F681); + HH(ECX,EDX,EAX,EBX,11,16,0x6D9D6122); + HH(EBX,ECX,EDX,EAX,14,23,0xFDE5380C); + HH(EAX,EBX,ECX,EDX, 1, 4,0xA4BEEA44); + HH(EDX,EAX,EBX,ECX, 4,11,0x4BDECFA9); + HH(ECX,EDX,EAX,EBX, 7,16,0xF6BB4B60); + HH(EBX,ECX,EDX,EAX,10,23,0xBEBFBC70); + HH(EAX,EBX,ECX,EDX,13, 4,0x289B7EC6); + HH(EDX,EAX,EBX,ECX, 0,11,0xEAA127FA); + HH(ECX,EDX,EAX,EBX, 3,16,0xD4EF3085); + HH(EBX,ECX,EDX,EAX, 6,23,0x04881D05); + HH(EAX,EBX,ECX,EDX, 9, 4,0xD9D4D039); + HH(EDX,EAX,EBX,ECX,12,11,0xE6DB99E5); + HH(ECX,EDX,EAX,EBX,15,16,0x1FA27CF8); + HH(EBX,ECX,EDX,EAX, 2,23,0xC4AC5665); + + II(EAX,EBX,ECX,EDX, 0, 6,0xF4292244); + II(EDX,EAX,EBX,ECX, 7,10,0x432AFF97); + II(ECX,EDX,EAX,EBX,14,15,0xAB9423A7); + II(EBX,ECX,EDX,EAX, 5,21,0xFC93A039); + II(EAX,EBX,ECX,EDX,12, 6,0x655B59C3); + II(EDX,EAX,EBX,ECX, 3,10,0x8F0CCC92); + II(ECX,EDX,EAX,EBX,10,15,0xFFEFF47D); + II(EBX,ECX,EDX,EAX, 1,21,0x85845DD1); + II(EAX,EBX,ECX,EDX, 8, 6,0x6FA87E4F); + II(EDX,EAX,EBX,ECX,15,10,0xFE2CE6E0); + II(ECX,EDX,EAX,EBX, 6,15,0xA3014314); + II(EBX,ECX,EDX,EAX,13,21,0x4E0811A1); + II(EAX,EBX,ECX,EDX, 4, 6,0xF7537E82); + II(EDX,EAX,EBX,ECX,11,10,0xBD3AF235); + II(ECX,EDX,EAX,EBX, 2,15,0x2AD7D2BB); + II(EBX,ECX,EDX,EAX, 9,21,0xEB86D391); + + ASSIGN(EBP, ARG(1)) + ADD(ARRAY4(EBP, 0), EAX) + ADD(ARRAY4(EBP, 1), EBX) + ADD(ARRAY4(EBP, 2), ECX) + ADD(ARRAY4(EBP, 3), EDX) + + RESTORE_REGS() +END_FUNCTION(botan_md5_ia32_compress) diff --git a/botan/src/hash/mdx_hash/info.txt b/botan/src/hash/mdx_hash/info.txt new file mode 100644 index 0000000..412c933 --- /dev/null +++ b/botan/src/hash/mdx_hash/info.txt @@ -0,0 +1,10 @@ +realname "MDx Hash Base" + +define MDX_HASH_FUNCTION + +load_on dep + +<add> +mdx_hash.cpp +mdx_hash.h +</add> diff --git a/botan/src/hash/mdx_hash/mdx_hash.cpp b/botan/src/hash/mdx_hash/mdx_hash.cpp new file mode 100644 index 0000000..b630ec2 --- /dev/null +++ b/botan/src/hash/mdx_hash/mdx_hash.cpp @@ -0,0 +1,105 @@ +/** +* Merkle-Damgard Hash Function +* (C) 1999-2008 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/mdx_hash.h> +#include <botan/exceptn.h> +#include <botan/loadstor.h> + +namespace Botan { + +/** +* MDx_HashFunction Constructor +*/ +MDx_HashFunction::MDx_HashFunction(u32bit hash_len, u32bit block_len, + bool byte_end, bool bit_end, + u32bit cnt_size) : + HashFunction(hash_len, block_len), buffer(block_len), + BIG_BYTE_ENDIAN(byte_end), BIG_BIT_ENDIAN(bit_end), COUNT_SIZE(cnt_size) + { + if(COUNT_SIZE >= OUTPUT_LENGTH || COUNT_SIZE >= HASH_BLOCK_SIZE) + throw Invalid_Argument("MDx_HashFunction: COUNT_SIZE is too big"); + count = position = 0; + } + +/** +* Clear memory of sensitive data +*/ +void MDx_HashFunction::clear() throw() + { + buffer.clear(); + count = position = 0; + } + +/** +* Update the hash +*/ +void MDx_HashFunction::add_data(const byte input[], u32bit length) + { + count += length; + + if(position) + { + buffer.copy(position, input, length); + + if(position + length >= HASH_BLOCK_SIZE) + { + compress_n(buffer.begin(), 1); + input += (HASH_BLOCK_SIZE - position); + length -= (HASH_BLOCK_SIZE - position); + position = 0; + } + } + + const u32bit full_blocks = length / HASH_BLOCK_SIZE; + const u32bit remaining = length % HASH_BLOCK_SIZE; + + if(full_blocks) + compress_n(input, full_blocks); + + buffer.copy(position, input + full_blocks * HASH_BLOCK_SIZE, remaining); + position += remaining; + } + +/** +* Finalize a hash +*/ +void MDx_HashFunction::final_result(byte output[]) + { + buffer[position] = (BIG_BIT_ENDIAN ? 0x80 : 0x01); + for(u32bit j = position+1; j != HASH_BLOCK_SIZE; ++j) + buffer[j] = 0; + + if(position >= HASH_BLOCK_SIZE - COUNT_SIZE) + { + compress_n(buffer, 1); + buffer.clear(); + } + + write_count(buffer + HASH_BLOCK_SIZE - COUNT_SIZE); + + compress_n(buffer, 1); + copy_out(output); + clear(); + } + +/** +* Write the count bits to the buffer +*/ +void MDx_HashFunction::write_count(byte out[]) + { + if(COUNT_SIZE < 8) + throw Invalid_State("MDx_HashFunction::write_count: COUNT_SIZE < 8"); + + const u64bit bit_count = count * 8; + + if(BIG_BYTE_ENDIAN) + store_be(bit_count, out + COUNT_SIZE - 8); + else + store_le(bit_count, out + COUNT_SIZE - 8); + } + +} diff --git a/botan/src/hash/mdx_hash/mdx_hash.h b/botan/src/hash/mdx_hash/mdx_hash.h new file mode 100644 index 0000000..0c3aa78 --- /dev/null +++ b/botan/src/hash/mdx_hash/mdx_hash.h @@ -0,0 +1,42 @@ +/** +* MDx Hash Function +* (C) 1999-2008 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_MDX_BASE_H__ +#define BOTAN_MDX_BASE_H__ + +#include <botan/hash.h> + +namespace Botan { + +/** +* MDx Hash Function Base Class +*/ +class BOTAN_DLL MDx_HashFunction : public HashFunction + { + public: + MDx_HashFunction(u32bit, u32bit, bool, bool, u32bit = 8); + virtual ~MDx_HashFunction() {} + protected: + void add_data(const byte[], u32bit); + void final_result(byte output[]); + virtual void compress_n(const byte block[], u32bit block_n) = 0; + + void clear() throw(); + virtual void copy_out(byte[]) = 0; + virtual void write_count(byte[]); + private: + SecureVector<byte> buffer; + u64bit count; + u32bit position; + + const bool BIG_BYTE_ENDIAN, BIG_BIT_ENDIAN; + const u32bit COUNT_SIZE; + }; + +} + +#endif diff --git a/botan/src/hash/par_hash/info.txt b/botan/src/hash/par_hash/info.txt new file mode 100644 index 0000000..45716aa --- /dev/null +++ b/botan/src/hash/par_hash/info.txt @@ -0,0 +1,10 @@ +realname "Parallel Hash" + +define PARALLEL_HASH + +load_on auto + +<add> +par_hash.cpp +par_hash.h +</add> diff --git a/botan/src/hash/par_hash/par_hash.cpp b/botan/src/hash/par_hash/par_hash.cpp new file mode 100644 index 0000000..4b0c7c4 --- /dev/null +++ b/botan/src/hash/par_hash/par_hash.cpp @@ -0,0 +1,103 @@ +/* +* Parallel +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/par_hash.h> + +namespace Botan { + +namespace { + +/* +* Return the sum of the hash sizes +*/ +u32bit sum_of_hash_lengths(const std::vector<HashFunction*>& hashes) + { + u32bit sum = 0; + + for(u32bit j = 0; j != hashes.size(); ++j) + sum += hashes[j]->OUTPUT_LENGTH; + + return sum; + } + +} + +/* +* Update the hash +*/ +void Parallel::add_data(const byte input[], u32bit length) + { + for(u32bit j = 0; j != hashes.size(); ++j) + hashes[j]->update(input, length); + } + +/* +* Finalize the hash +*/ +void Parallel::final_result(byte hash[]) + { + u32bit offset = 0; + for(u32bit j = 0; j != hashes.size(); ++j) + { + hashes[j]->final(hash + offset); + offset += hashes[j]->OUTPUT_LENGTH; + } + } + +/* +* Return the name of this type +*/ +std::string Parallel::name() const + { + std::string hash_names; + for(u32bit j = 0; j != hashes.size(); ++j) + { + if(j) + hash_names += ','; + hash_names += hashes[j]->name(); + } + return "Parallel(" + hash_names + ")"; + } + +/* +* Return a clone of this object +*/ +HashFunction* Parallel::clone() const + { + std::vector<HashFunction*> hash_copies; + for(u32bit j = 0; j != hashes.size(); ++j) + hash_copies.push_back(hashes[j]->clone()); + return new Parallel(hash_copies); + } + +/* +* Clear memory of sensitive data +*/ +void Parallel::clear() throw() + { + for(u32bit j = 0; j != hashes.size(); ++j) + hashes[j]->clear(); + } + +/* +* Parallel Constructor +*/ +Parallel::Parallel(const std::vector<HashFunction*>& hash_in) : + HashFunction(sum_of_hash_lengths(hash_in)), hashes(hash_in) + { + } + +/* +* Parallel Destructor +*/ +Parallel::~Parallel() + { + for(u32bit j = 0; j != hashes.size(); ++j) + delete hashes[j]; + } + +} diff --git a/botan/src/hash/par_hash/par_hash.h b/botan/src/hash/par_hash/par_hash.h new file mode 100644 index 0000000..7e75c27 --- /dev/null +++ b/botan/src/hash/par_hash/par_hash.h @@ -0,0 +1,36 @@ +/* +* Parallel Hash +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_PARALLEL_HASH_H__ +#define BOTAN_PARALLEL_HASH_H__ + +#include <botan/hash.h> +#include <vector> + +namespace Botan { + +/* +* Parallel +*/ +class BOTAN_DLL Parallel : public HashFunction + { + public: + void clear() throw(); + std::string name() const; + HashFunction* clone() const; + + Parallel(const std::vector<HashFunction*>&); + ~Parallel(); + private: + void add_data(const byte[], u32bit); + void final_result(byte[]); + std::vector<HashFunction*> hashes; + }; + +} + +#endif diff --git a/botan/src/hash/rmd128/info.txt b/botan/src/hash/rmd128/info.txt new file mode 100644 index 0000000..402271d --- /dev/null +++ b/botan/src/hash/rmd128/info.txt @@ -0,0 +1,14 @@ +realname "RIPEMD-128" + +define RIPEMD_128 + +load_on auto + +<add> +rmd128.cpp +rmd128.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/rmd128/rmd128.cpp b/botan/src/hash/rmd128/rmd128.cpp new file mode 100644 index 0000000..8b2c0cc --- /dev/null +++ b/botan/src/hash/rmd128/rmd128.cpp @@ -0,0 +1,172 @@ +/* +* RIPEMD-128 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/rmd128.h> +#include <botan/loadstor.h> +#include <botan/rotate.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::compress_n(const byte input[], u32bit blocks) + { + for(u32bit i = 0; i != blocks; ++i) + { + for(u32bit j = 0; j != 16; ++j) + M[j] = load_le<u32bit>(input, j); + input += HASH_BLOCK_SIZE; + + 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/botan/src/hash/rmd128/rmd128.h b/botan/src/hash/rmd128/rmd128.h new file mode 100644 index 0000000..031ae57 --- /dev/null +++ b/botan/src/hash/rmd128/rmd128.h @@ -0,0 +1,35 @@ +/* +* RIPEMD-128 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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 compress_n(const byte[], u32bit blocks); + void copy_out(byte[]); + + SecureBuffer<u32bit, 16> M; + SecureBuffer<u32bit, 4> digest; + }; + +} + +#endif diff --git a/botan/src/hash/rmd160/info.txt b/botan/src/hash/rmd160/info.txt new file mode 100644 index 0000000..af4b5c2 --- /dev/null +++ b/botan/src/hash/rmd160/info.txt @@ -0,0 +1,14 @@ +realname "RIPEMD-160" + +define RIPEMD_160 + +load_on auto + +<add> +rmd160.cpp +rmd160.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/rmd160/rmd160.cpp b/botan/src/hash/rmd160/rmd160.cpp new file mode 100644 index 0000000..863de84 --- /dev/null +++ b/botan/src/hash/rmd160/rmd160.cpp @@ -0,0 +1,210 @@ +/* +* RIPEMD-160 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/rmd160.h> +#include <botan/loadstor.h> +#include <botan/rotate.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::compress_n(const byte input[], u32bit blocks) + { + const u32bit MAGIC2 = 0x5A827999, MAGIC3 = 0x6ED9EBA1, + MAGIC4 = 0x8F1BBCDC, MAGIC5 = 0xA953FD4E, + MAGIC6 = 0x50A28BE6, MAGIC7 = 0x5C4DD124, + MAGIC8 = 0x6D703EF3, MAGIC9 = 0x7A6D76E9; + + for(u32bit i = 0; i != blocks; ++i) + { + for(u32bit j = 0; j != 16; ++j) + M[j] = load_le<u32bit>(input, j); + input += HASH_BLOCK_SIZE; + + 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; + + 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/botan/src/hash/rmd160/rmd160.h b/botan/src/hash/rmd160/rmd160.h new file mode 100644 index 0000000..f2babc5 --- /dev/null +++ b/botan/src/hash/rmd160/rmd160.h @@ -0,0 +1,35 @@ +/* +* RIPEMD-160 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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 compress_n(const byte[], u32bit blocks); + void copy_out(byte[]); + + SecureBuffer<u32bit, 16> M; + SecureBuffer<u32bit, 5> digest; + }; + +} + +#endif diff --git a/botan/src/hash/sha1/info.txt b/botan/src/hash/sha1/info.txt new file mode 100644 index 0000000..a0ae30b --- /dev/null +++ b/botan/src/hash/sha1/info.txt @@ -0,0 +1,14 @@ +realname "SHA-1" + +define SHA1 + +load_on auto + +<add> +sha160.cpp +sha160.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/sha1/sha160.cpp b/botan/src/hash/sha1/sha160.cpp new file mode 100644 index 0000000..45323a1 --- /dev/null +++ b/botan/src/hash/sha1/sha160.cpp @@ -0,0 +1,162 @@ +/* +* SHA-160 +* (C) 1999-2008 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/sha160.h> +#include <botan/loadstor.h> +#include <botan/rotate.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::compress_n(const byte input[], u32bit blocks) + { + u32bit A = digest[0], B = digest[1], C = digest[2], + D = digest[3], E = digest[4]; + + for(u32bit i = 0; i != blocks; ++i) + { + 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); + } + input += HASH_BLOCK_SIZE; + + 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); + } + + 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]); + + A = (digest[0] += A); + B = (digest[1] += B); + C = (digest[2] += C); + D = (digest[3] += D); + E = (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(); + } + +/* +* SHA_160 Constructor +*/ +SHA_160::SHA_160(u32bit W_size) : + MDx_HashFunction(20, 64, true, true), W(W_size) + { + clear(); + } + +} diff --git a/botan/src/hash/sha1/sha160.h b/botan/src/hash/sha1/sha160.h new file mode 100644 index 0000000..232cf03 --- /dev/null +++ b/botan/src/hash/sha1/sha160.h @@ -0,0 +1,38 @@ +/* +* SHA-160 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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(); + + protected: + SHA_160(u32bit W_size); + + void compress_n(const byte[], u32bit blocks); + void copy_out(byte[]); + + SecureBuffer<u32bit, 5> digest; + SecureVector<u32bit> W; + }; + +} + +#endif diff --git a/botan/src/hash/sha1_amd64/info.txt b/botan/src/hash/sha1_amd64/info.txt new file mode 100644 index 0000000..ddbc7d3 --- /dev/null +++ b/botan/src/hash/sha1_amd64/info.txt @@ -0,0 +1,34 @@ +realname "SHA-1 (x86-64 assembler)" + +define SHA1_AMD64 + +load_on asm_ok + +<add> +sha1_amd64_imp.S +sha1_amd64.cpp +sha1_amd64.h +</add> + +<arch> +amd64 +</arch> + +<cc> +gcc +icc +</cc> + +# ELF systems +<os> +linux +netbsd +openbsd +solaris +</os> + +<requires> +amd64_eng +asm_amd64 +sha1 +</requires> diff --git a/botan/src/hash/sha1_amd64/sha1_amd64.cpp b/botan/src/hash/sha1_amd64/sha1_amd64.cpp new file mode 100644 index 0000000..0efbd85 --- /dev/null +++ b/botan/src/hash/sha1_amd64/sha1_amd64.cpp @@ -0,0 +1,31 @@ +/* +* SHA-160 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/sha1_amd64.h> + +namespace Botan { + +namespace { + +extern "C" +void botan_sha160_amd64_compress(u32bit[5], const byte[64], u32bit[80]); + +} + +/* +* SHA-160 Compression Function +*/ +void SHA_160_AMD64::compress_n(const byte input[], u32bit blocks) + { + for(u32bit i = 0; i != blocks; ++i) + { + botan_sha160_amd64_compress(digest, input, W); + input += HASH_BLOCK_SIZE; + } + } + +} diff --git a/botan/src/hash/sha1_amd64/sha1_amd64.h b/botan/src/hash/sha1_amd64/sha1_amd64.h new file mode 100644 index 0000000..f182627 --- /dev/null +++ b/botan/src/hash/sha1_amd64/sha1_amd64.h @@ -0,0 +1,28 @@ +/* +* SHA-160 (x86-64) +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_SHA_160_AMD64_H__ +#define BOTAN_SHA_160_AMD64_H__ + +#include <botan/sha160.h> + +namespace Botan { + +/* +* SHA-160 +*/ +class BOTAN_DLL SHA_160_AMD64 : public SHA_160 + { + public: + HashFunction* clone() const { return new SHA_160_AMD64; } + private: + void compress_n(const byte[], u32bit blocks); + }; + +} + +#endif diff --git a/botan/src/hash/sha1_amd64/sha1_amd64_imp.S b/botan/src/hash/sha1_amd64/sha1_amd64_imp.S new file mode 100644 index 0000000..34a8318 --- /dev/null +++ b/botan/src/hash/sha1_amd64/sha1_amd64_imp.S @@ -0,0 +1,260 @@ +/* +* SHA-160 Source File +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/asm_macr.h> + +START_LISTING(sha1_amd64.S) + +START_FUNCTION(botan_sha160_amd64_compress) + +#define DIGEST_ARR %rdi +#define INPUT %rsi +#define W %rdx +#define LOOP_CTR %eax + +#define A %r8d +#define B %r9d +#define C %r10d +#define D %r11d +#define E %ecx + + ZEROIZE(LOOP_CTR) + +ALIGN; +.LOOP_LOAD_INPUT: + addl $8, %eax + + movq ARRAY8(INPUT, 0), %r8 + movq ARRAY8(INPUT, 1), %r9 + movq ARRAY8(INPUT, 2), %r10 + movq ARRAY8(INPUT, 3), %r11 + + bswap %r8 + bswap %r9 + bswap %r10 + bswap %r11 + + rolq $32, %r8 + rolq $32, %r9 + rolq $32, %r10 + rolq $32, %r11 + + movq %r8, ARRAY8(W, 0) + movq %r9, ARRAY8(W, 1) + movq %r10, ARRAY8(W, 2) + movq %r11, ARRAY8(W, 3) + + addq $32, W + addq $32, INPUT + + cmp IMM(16), LOOP_CTR + jne .LOOP_LOAD_INPUT + +/* +#define A %r8d +#define B %r9d +#define C %r10d +#define D %r11d +#define E %ecx +*/ + +ALIGN; +.LOOP_EXPANSION: + addl $4, LOOP_CTR + + ZEROIZE(A) + ASSIGN(B, ARRAY4(W, -1)) + ASSIGN(C, ARRAY4(W, -2)) + ASSIGN(D, ARRAY4(W, -3)) + + XOR(A, ARRAY4(W, -5)) + XOR(B, ARRAY4(W, -6)) + XOR(C, ARRAY4(W, -7)) + XOR(D, ARRAY4(W, -8)) + + XOR(A, ARRAY4(W, -11)) + XOR(B, ARRAY4(W, -12)) + XOR(C, ARRAY4(W, -13)) + XOR(D, ARRAY4(W, -14)) + + XOR(A, ARRAY4(W, -13)) + XOR(B, ARRAY4(W, -14)) + XOR(C, ARRAY4(W, -15)) + XOR(D, ARRAY4(W, -16)) + + ROTL_IMM(D, 1) + ROTL_IMM(C, 1) + ROTL_IMM(B, 1) + XOR(A, D) + ROTL_IMM(A, 1) + + ASSIGN(ARRAY4(W, 0), D) + ASSIGN(ARRAY4(W, 1), C) + ASSIGN(ARRAY4(W, 2), B) + ASSIGN(ARRAY4(W, 3), A) + + addq $16, W + cmp IMM(80), LOOP_CTR + jne .LOOP_EXPANSION + + subq $320, W + +#define MAGIC1 0x5A827999 +#define MAGIC2 0x6ED9EBA1 +#define MAGIC3 0x8F1BBCDC +#define MAGIC4 0xCA62C1D6 + +#define T %esi +#define T2 %eax + +#define F1(A, B, C, D, E, F, N) \ + ASSIGN(T2, ARRAY4(W, N)) ; \ + ASSIGN(A, F) ; \ + ROTL_IMM(F, 5) ; \ + ADD(F, E) ; \ + ASSIGN(E, C) ; \ + XOR(E, D) ; \ + ADD3_IMM(F, T2, MAGIC1) ; \ + AND(E, B) ; \ + XOR(E, D) ; \ + ROTR_IMM(B, 2) ; \ + ADD(E, F) ; + +#define F2_4(A, B, C, D, E, F, N, MAGIC) \ + ASSIGN(T2, ARRAY4(W, N)) ; \ + ASSIGN(A, F) ; \ + ROTL_IMM(F, 5) ; \ + ADD(F, E) ; \ + ASSIGN(E, B) ; \ + XOR(E, C) ; \ + ADD3_IMM(F, T2, MAGIC) ; \ + XOR(E, D) ; \ + ROTR_IMM(B, 2) ; \ + ADD(E, F) ; + +#define F3(A, B, C, D, E, F, N) \ + ASSIGN(T2, ARRAY4(W, N)) ; \ + ASSIGN(A, F) ; \ + ROTL_IMM(F, 5) ; \ + ADD(F, E) ; \ + ASSIGN(E, B) ; \ + OR(E, C) ; \ + AND(E, D) ; \ + ADD3_IMM(F, T2, MAGIC3) ; \ + ASSIGN(T2, B) ; \ + AND(T2, C) ; \ + OR(E, T2) ; \ + ROTR_IMM(B, 2) ; \ + ADD(E, F) ; + +#define F2(A, B, C, D, E, F, W) \ + F2_4(A, B, C, D, E, F, W, MAGIC2) + +#define F4(A, B, C, D, E, F, W) \ + F2_4(A, B, C, D, E, F, W, MAGIC4) + + ASSIGN(T, ARRAY4(DIGEST_ARR, 0)) + ASSIGN(B, ARRAY4(DIGEST_ARR, 1)) + ASSIGN(C, ARRAY4(DIGEST_ARR, 2)) + ASSIGN(D, ARRAY4(DIGEST_ARR, 3)) + ASSIGN(E, ARRAY4(DIGEST_ARR, 4)) + + /* First Round */ + F1(A, B, C, D, E, T, 0) + F1(T, A, B, C, D, E, 1) + F1(E, T, A, B, C, D, 2) + F1(D, E, T, A, B, C, 3) + F1(C, D, E, T, A, B, 4) + F1(B, C, D, E, T, A, 5) + F1(A, B, C, D, E, T, 6) + F1(T, A, B, C, D, E, 7) + F1(E, T, A, B, C, D, 8) + F1(D, E, T, A, B, C, 9) + F1(C, D, E, T, A, B, 10) + F1(B, C, D, E, T, A, 11) + F1(A, B, C, D, E, T, 12) + F1(T, A, B, C, D, E, 13) + F1(E, T, A, B, C, D, 14) + F1(D, E, T, A, B, C, 15) + F1(C, D, E, T, A, B, 16) + F1(B, C, D, E, T, A, 17) + F1(A, B, C, D, E, T, 18) + F1(T, A, B, C, D, E, 19) + + /* Second Round */ + F2(E, T, A, B, C, D, 20) + F2(D, E, T, A, B, C, 21) + F2(C, D, E, T, A, B, 22) + F2(B, C, D, E, T, A, 23) + F2(A, B, C, D, E, T, 24) + F2(T, A, B, C, D, E, 25) + F2(E, T, A, B, C, D, 26) + F2(D, E, T, A, B, C, 27) + F2(C, D, E, T, A, B, 28) + F2(B, C, D, E, T, A, 29) + F2(A, B, C, D, E, T, 30) + F2(T, A, B, C, D, E, 31) + F2(E, T, A, B, C, D, 32) + F2(D, E, T, A, B, C, 33) + F2(C, D, E, T, A, B, 34) + F2(B, C, D, E, T, A, 35) + F2(A, B, C, D, E, T, 36) + F2(T, A, B, C, D, E, 37) + F2(E, T, A, B, C, D, 38) + F2(D, E, T, A, B, C, 39) + + /* Third Round */ + F3(C, D, E, T, A, B, 40) + F3(B, C, D, E, T, A, 41) + F3(A, B, C, D, E, T, 42) + F3(T, A, B, C, D, E, 43) + F3(E, T, A, B, C, D, 44) + F3(D, E, T, A, B, C, 45) + F3(C, D, E, T, A, B, 46) + F3(B, C, D, E, T, A, 47) + F3(A, B, C, D, E, T, 48) + F3(T, A, B, C, D, E, 49) + F3(E, T, A, B, C, D, 50) + F3(D, E, T, A, B, C, 51) + F3(C, D, E, T, A, B, 52) + F3(B, C, D, E, T, A, 53) + F3(A, B, C, D, E, T, 54) + F3(T, A, B, C, D, E, 55) + F3(E, T, A, B, C, D, 56) + F3(D, E, T, A, B, C, 57) + F3(C, D, E, T, A, B, 58) + F3(B, C, D, E, T, A, 59) + + /* Fourth Round */ + F4(A, B, C, D, E, T, 60) + F4(T, A, B, C, D, E, 61) + F4(E, T, A, B, C, D, 62) + F4(D, E, T, A, B, C, 63) + F4(C, D, E, T, A, B, 64) + F4(B, C, D, E, T, A, 65) + F4(A, B, C, D, E, T, 66) + F4(T, A, B, C, D, E, 67) + F4(E, T, A, B, C, D, 68) + F4(D, E, T, A, B, C, 69) + F4(C, D, E, T, A, B, 70) + F4(B, C, D, E, T, A, 71) + F4(A, B, C, D, E, T, 72) + F4(T, A, B, C, D, E, 73) + F4(E, T, A, B, C, D, 74) + F4(D, E, T, A, B, C, 75) + F4(C, D, E, T, A, B, 76) + F4(B, C, D, E, T, A, 77) + F4(A, B, C, D, E, T, 78) + F4(T, A, B, C, D, E, 79) + + ADD(ARRAY4(DIGEST_ARR, 0), D) + ADD(ARRAY4(DIGEST_ARR, 1), T) + ADD(ARRAY4(DIGEST_ARR, 2), A) + ADD(ARRAY4(DIGEST_ARR, 3), B) + ADD(ARRAY4(DIGEST_ARR, 4), C) + +END_FUNCTION(botan_sha160_amd64_compress) diff --git a/botan/src/hash/sha1_ia32/info.txt b/botan/src/hash/sha1_ia32/info.txt new file mode 100644 index 0000000..bfb3211 --- /dev/null +++ b/botan/src/hash/sha1_ia32/info.txt @@ -0,0 +1,35 @@ +realname "SHA-1 (IA-32)" + +define SHA1_IA32 + +load_on asm_ok + +<add> +sha1_ia32_imp.S +sha1_ia32.cpp +sha1_ia32.h +</add> + +<arch> +ia32 +</arch> + +<cc> +gcc +icc +</cc> + +# ELF systems +<os> +linux +freebsd +dragonfly +netbsd +openbsd +solaris +</os> + +<requires> +asm_ia32 +sha1 +</requires> diff --git a/botan/src/hash/sha1_ia32/sha1_ia32.cpp b/botan/src/hash/sha1_ia32/sha1_ia32.cpp new file mode 100644 index 0000000..0fa0b6b --- /dev/null +++ b/botan/src/hash/sha1_ia32/sha1_ia32.cpp @@ -0,0 +1,32 @@ +/* +* SHA-160 (IA-32) +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/sha1_ia32.h> +#include <botan/loadstor.h> + +namespace Botan { + +namespace { + +extern "C" +void botan_sha160_ia32_compress(u32bit[5], const byte[64], u32bit[81]); + +} + +/* +* SHA-160 Compression Function +*/ +void SHA_160_IA32::compress_n(const byte input[], u32bit blocks) + { + for(u32bit i = 0; i != blocks; ++i) + { + botan_sha160_ia32_compress(digest, input, W); + input += HASH_BLOCK_SIZE; + } + } + +} diff --git a/botan/src/hash/sha1_ia32/sha1_ia32.h b/botan/src/hash/sha1_ia32/sha1_ia32.h new file mode 100644 index 0000000..fd34971 --- /dev/null +++ b/botan/src/hash/sha1_ia32/sha1_ia32.h @@ -0,0 +1,31 @@ +/* +* SHA-160 (IA-32) +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_SHA_160_IA32_H__ +#define BOTAN_SHA_160_IA32_H__ + +#include <botan/sha160.h> + +namespace Botan { + +/* +* SHA-160 +*/ +class BOTAN_DLL SHA_160_IA32 : public SHA_160 + { + public: + HashFunction* clone() const { return new SHA_160_IA32; } + + // Note 81 instead of normal 80: IA-32 asm needs an extra temp + SHA_160_IA32() : SHA_160(81) {} + private: + void compress_n(const byte[], u32bit blocks); + }; + +} + +#endif diff --git a/botan/src/hash/sha1_ia32/sha1_ia32_imp.S b/botan/src/hash/sha1_ia32/sha1_ia32_imp.S new file mode 100644 index 0000000..e76b9fb --- /dev/null +++ b/botan/src/hash/sha1_ia32/sha1_ia32_imp.S @@ -0,0 +1,244 @@ +/* +* SHA-160 Source File +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/asm_macr.h> + +START_LISTING(sha1_ia32.S) + +START_FUNCTION(botan_sha160_ia32_compress) + SPILL_REGS() + +#define PUSHED 4 + + ASSIGN(EDI, ARG(2)) + ASSIGN(EBP, ARG(3)) + + ZEROIZE(ESI) + +START_LOOP(.LOAD_INPUT) + ADD_IMM(ESI, 4) + + ASSIGN(EAX, ARRAY4(EDI, 0)) + ASSIGN(EBX, ARRAY4(EDI, 1)) + ASSIGN(ECX, ARRAY4(EDI, 2)) + ASSIGN(EDX, ARRAY4(EDI, 3)) + + ADD_IMM(EDI, 16) + + BSWAP(EAX) + BSWAP(EBX) + BSWAP(ECX) + BSWAP(EDX) + + ASSIGN(ARRAY4_INDIRECT(EBP,ESI,-4), EAX) + ASSIGN(ARRAY4_INDIRECT(EBP,ESI,-3), EBX) + ASSIGN(ARRAY4_INDIRECT(EBP,ESI,-2), ECX) + ASSIGN(ARRAY4_INDIRECT(EBP,ESI,-1), EDX) +LOOP_UNTIL_EQ(ESI, 16, .LOAD_INPUT) + + ADD2_IMM(EDI, EBP, 64) + +START_LOOP(.EXPANSION) + ADD_IMM(ESI, 4) + + ZEROIZE(EAX) + ASSIGN(EBX, ARRAY4(EDI, -1)) + ASSIGN(ECX, ARRAY4(EDI, -2)) + ASSIGN(EDX, ARRAY4(EDI, -3)) + + XOR(EAX, ARRAY4(EDI, -5)) + XOR(EBX, ARRAY4(EDI, -6)) + XOR(ECX, ARRAY4(EDI, -7)) + XOR(EDX, ARRAY4(EDI, -8)) + + XOR(EAX, ARRAY4(EDI, -11)) + XOR(EBX, ARRAY4(EDI, -12)) + XOR(ECX, ARRAY4(EDI, -13)) + XOR(EDX, ARRAY4(EDI, -14)) + + XOR(EAX, ARRAY4(EDI, -13)) + XOR(EBX, ARRAY4(EDI, -14)) + XOR(ECX, ARRAY4(EDI, -15)) + XOR(EDX, ARRAY4(EDI, -16)) + + ROTL_IMM(EDX, 1) + ROTL_IMM(ECX, 1) + ROTL_IMM(EBX, 1) + XOR(EAX, EDX) + ROTL_IMM(EAX, 1) + + ASSIGN(ARRAY4(EDI, 0), EDX) + ASSIGN(ARRAY4(EDI, 1), ECX) + ASSIGN(ARRAY4(EDI, 2), EBX) + ASSIGN(ARRAY4(EDI, 3), EAX) + + ADD_IMM(EDI, 16) +LOOP_UNTIL_EQ(ESI, 80, .EXPANSION) + +#define MAGIC1 0x5A827999 +#define MAGIC2 0x6ED9EBA1 +#define MAGIC3 0x8F1BBCDC +#define MAGIC4 0xCA62C1D6 + +#define MSG ESP +#define T2 EBP + +#define F1(A, B, C, D, E, F, N) \ + ASSIGN(T2, ARRAY4(MSG, N)) ; \ + ASSIGN(A, F) ; \ + ROTL_IMM(F, 5) ; \ + ADD(F, E) ; \ + ASSIGN(E, C) ; \ + XOR(E, D) ; \ + ADD3_IMM(F, T2, MAGIC1) ; \ + AND(E, B) ; \ + XOR(E, D) ; \ + ROTR_IMM(B, 2) ; \ + ADD(E, F) ; + +#define F2_4(A, B, C, D, E, F, N, MAGIC) \ + ASSIGN(T2, ARRAY4(MSG, N)) ; \ + ASSIGN(A, F) ; \ + ROTL_IMM(F, 5) ; \ + ADD(F, E) ; \ + ASSIGN(E, B) ; \ + XOR(E, C) ; \ + ADD3_IMM(F, T2, MAGIC) ; \ + XOR(E, D) ; \ + ROTR_IMM(B, 2) ; \ + ADD(E, F) ; + +#define F3(A, B, C, D, E, F, N) \ + ASSIGN(T2, ARRAY4(MSG, N)) ; \ + ASSIGN(A, F) ; \ + ROTL_IMM(F, 5) ; \ + ADD(F, E) ; \ + ASSIGN(E, B) ; \ + OR(E, C) ; \ + AND(E, D) ; \ + ADD3_IMM(F, T2, MAGIC3) ; \ + ASSIGN(T2, B) ; \ + AND(T2, C) ; \ + OR(E, T2) ; \ + ROTR_IMM(B, 2) ; \ + ADD(E, F) ; + +#define F2(A, B, C, D, E, F, MSG) \ + F2_4(A, B, C, D, E, F, MSG, MAGIC2) + +#define F4(A, B, C, D, E, F, MSG) \ + F2_4(A, B, C, D, E, F, MSG, MAGIC4) + + ASSIGN(EAX, ARG(1)) + ASSIGN(EDI, ARRAY4(EAX, 0)) + ASSIGN(EBX, ARRAY4(EAX, 1)) + ASSIGN(ECX, ARRAY4(EAX, 2)) + ASSIGN(EDX, ARRAY4(EAX, 3)) + ASSIGN(ESI, ARRAY4(EAX, 4)) + + ASSIGN(ARRAY4(EBP, 80), ESP) + ASSIGN(ESP, EBP) + + /* First Round */ + F1(EAX, EBX, ECX, EDX, ESI, EDI, 0) + F1(EDI, EAX, EBX, ECX, EDX, ESI, 1) + F1(ESI, EDI, EAX, EBX, ECX, EDX, 2) + F1(EDX, ESI, EDI, EAX, EBX, ECX, 3) + F1(ECX, EDX, ESI, EDI, EAX, EBX, 4) + F1(EBX, ECX, EDX, ESI, EDI, EAX, 5) + F1(EAX, EBX, ECX, EDX, ESI, EDI, 6) + F1(EDI, EAX, EBX, ECX, EDX, ESI, 7) + F1(ESI, EDI, EAX, EBX, ECX, EDX, 8) + F1(EDX, ESI, EDI, EAX, EBX, ECX, 9) + F1(ECX, EDX, ESI, EDI, EAX, EBX, 10) + F1(EBX, ECX, EDX, ESI, EDI, EAX, 11) + F1(EAX, EBX, ECX, EDX, ESI, EDI, 12) + F1(EDI, EAX, EBX, ECX, EDX, ESI, 13) + F1(ESI, EDI, EAX, EBX, ECX, EDX, 14) + F1(EDX, ESI, EDI, EAX, EBX, ECX, 15) + F1(ECX, EDX, ESI, EDI, EAX, EBX, 16) + F1(EBX, ECX, EDX, ESI, EDI, EAX, 17) + F1(EAX, EBX, ECX, EDX, ESI, EDI, 18) + F1(EDI, EAX, EBX, ECX, EDX, ESI, 19) + + /* Second Round */ + F2(ESI, EDI, EAX, EBX, ECX, EDX, 20) + F2(EDX, ESI, EDI, EAX, EBX, ECX, 21) + F2(ECX, EDX, ESI, EDI, EAX, EBX, 22) + F2(EBX, ECX, EDX, ESI, EDI, EAX, 23) + F2(EAX, EBX, ECX, EDX, ESI, EDI, 24) + F2(EDI, EAX, EBX, ECX, EDX, ESI, 25) + F2(ESI, EDI, EAX, EBX, ECX, EDX, 26) + F2(EDX, ESI, EDI, EAX, EBX, ECX, 27) + F2(ECX, EDX, ESI, EDI, EAX, EBX, 28) + F2(EBX, ECX, EDX, ESI, EDI, EAX, 29) + F2(EAX, EBX, ECX, EDX, ESI, EDI, 30) + F2(EDI, EAX, EBX, ECX, EDX, ESI, 31) + F2(ESI, EDI, EAX, EBX, ECX, EDX, 32) + F2(EDX, ESI, EDI, EAX, EBX, ECX, 33) + F2(ECX, EDX, ESI, EDI, EAX, EBX, 34) + F2(EBX, ECX, EDX, ESI, EDI, EAX, 35) + F2(EAX, EBX, ECX, EDX, ESI, EDI, 36) + F2(EDI, EAX, EBX, ECX, EDX, ESI, 37) + F2(ESI, EDI, EAX, EBX, ECX, EDX, 38) + F2(EDX, ESI, EDI, EAX, EBX, ECX, 39) + + /* Third Round */ + F3(ECX, EDX, ESI, EDI, EAX, EBX, 40) + F3(EBX, ECX, EDX, ESI, EDI, EAX, 41) + F3(EAX, EBX, ECX, EDX, ESI, EDI, 42) + F3(EDI, EAX, EBX, ECX, EDX, ESI, 43) + F3(ESI, EDI, EAX, EBX, ECX, EDX, 44) + F3(EDX, ESI, EDI, EAX, EBX, ECX, 45) + F3(ECX, EDX, ESI, EDI, EAX, EBX, 46) + F3(EBX, ECX, EDX, ESI, EDI, EAX, 47) + F3(EAX, EBX, ECX, EDX, ESI, EDI, 48) + F3(EDI, EAX, EBX, ECX, EDX, ESI, 49) + F3(ESI, EDI, EAX, EBX, ECX, EDX, 50) + F3(EDX, ESI, EDI, EAX, EBX, ECX, 51) + F3(ECX, EDX, ESI, EDI, EAX, EBX, 52) + F3(EBX, ECX, EDX, ESI, EDI, EAX, 53) + F3(EAX, EBX, ECX, EDX, ESI, EDI, 54) + F3(EDI, EAX, EBX, ECX, EDX, ESI, 55) + F3(ESI, EDI, EAX, EBX, ECX, EDX, 56) + F3(EDX, ESI, EDI, EAX, EBX, ECX, 57) + F3(ECX, EDX, ESI, EDI, EAX, EBX, 58) + F3(EBX, ECX, EDX, ESI, EDI, EAX, 59) + + /* Fourth Round */ + F4(EAX, EBX, ECX, EDX, ESI, EDI, 60) + F4(EDI, EAX, EBX, ECX, EDX, ESI, 61) + F4(ESI, EDI, EAX, EBX, ECX, EDX, 62) + F4(EDX, ESI, EDI, EAX, EBX, ECX, 63) + F4(ECX, EDX, ESI, EDI, EAX, EBX, 64) + F4(EBX, ECX, EDX, ESI, EDI, EAX, 65) + F4(EAX, EBX, ECX, EDX, ESI, EDI, 66) + F4(EDI, EAX, EBX, ECX, EDX, ESI, 67) + F4(ESI, EDI, EAX, EBX, ECX, EDX, 68) + F4(EDX, ESI, EDI, EAX, EBX, ECX, 69) + F4(ECX, EDX, ESI, EDI, EAX, EBX, 70) + F4(EBX, ECX, EDX, ESI, EDI, EAX, 71) + F4(EAX, EBX, ECX, EDX, ESI, EDI, 72) + F4(EDI, EAX, EBX, ECX, EDX, ESI, 73) + F4(ESI, EDI, EAX, EBX, ECX, EDX, 74) + F4(EDX, ESI, EDI, EAX, EBX, ECX, 75) + F4(ECX, EDX, ESI, EDI, EAX, EBX, 76) + F4(EBX, ECX, EDX, ESI, EDI, EAX, 77) + F4(EAX, EBX, ECX, EDX, ESI, EDI, 78) + F4(EDI, EAX, EBX, ECX, EDX, ESI, 79) + + ASSIGN(ESP, ARRAY4(ESP, 80)) + + ASSIGN(EBP, ARG(1)) + ADD(ARRAY4(EBP, 0), EDX) + ADD(ARRAY4(EBP, 1), EDI) + ADD(ARRAY4(EBP, 2), EAX) + ADD(ARRAY4(EBP, 3), EBX) + ADD(ARRAY4(EBP, 4), ECX) + + RESTORE_REGS() +END_FUNCTION(botan_sha160_ia32_compress) diff --git a/botan/src/hash/sha1_sse2/info.txt b/botan/src/hash/sha1_sse2/info.txt new file mode 100644 index 0000000..b8d693b --- /dev/null +++ b/botan/src/hash/sha1_sse2/info.txt @@ -0,0 +1,28 @@ +realname "SHA-1 (SSE2)" + +define SHA1_SSE2 + +load_on auto + +<add> +sha1_sse2_imp.cpp +sha1_sse2.cpp +sha1_sse2.h +</add> + +<arch> +pentium-m +pentium4 +prescott +amd64 +</arch> + +<cc> +gcc +icc +</cc> + +<requires> +sha1 +sse2_eng +</requires> diff --git a/botan/src/hash/sha1_sse2/sha1_sse2.cpp b/botan/src/hash/sha1_sse2/sha1_sse2.cpp new file mode 100644 index 0000000..dddc06b --- /dev/null +++ b/botan/src/hash/sha1_sse2/sha1_sse2.cpp @@ -0,0 +1,24 @@ +/* +* SHA-160 (SSE2) +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/sha1_sse2.h> + +namespace Botan { + +/* +* SHA-160 Compression Function +*/ +void SHA_160_SSE2::compress_n(const byte input[], u32bit blocks) + { + for(u32bit i = 0; i != blocks; ++i) + { + botan_sha1_sse2_compress(digest, reinterpret_cast<const u32bit*>(input)); + input += HASH_BLOCK_SIZE; + } + } + +} diff --git a/botan/src/hash/sha1_sse2/sha1_sse2.h b/botan/src/hash/sha1_sse2/sha1_sse2.h new file mode 100644 index 0000000..0f8eebe --- /dev/null +++ b/botan/src/hash/sha1_sse2/sha1_sse2.h @@ -0,0 +1,31 @@ +/* +* SHA-160 +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_SHA_160_SSE2_H__ +#define BOTAN_SHA_160_SSE2_H__ + +#include <botan/sha160.h> + +namespace Botan { + +/* +* SHA-160 +*/ +class BOTAN_DLL SHA_160_SSE2 : public SHA_160 + { + public: + HashFunction* clone() const { return new SHA_160_SSE2; } + SHA_160_SSE2() : SHA_160(0) {} // no W needed + private: + void compress_n(const byte[], u32bit blocks); + }; + +extern "C" void botan_sha1_sse2_compress(u32bit[5], const u32bit*); + +} + +#endif diff --git a/botan/src/hash/sha1_sse2/sha1_sse2_imp.cpp b/botan/src/hash/sha1_sse2/sha1_sse2_imp.cpp new file mode 100644 index 0000000..90a8dcc --- /dev/null +++ b/botan/src/hash/sha1_sse2/sha1_sse2_imp.cpp @@ -0,0 +1,331 @@ +/* this code is public domain. + + * dean gaudet <dean@arctic.org> + + * this code was inspired by this paper: + + * SHA: A Design for Parallel Architectures? + * Antoon Bosselaers, Ren´e Govaerts and Joos Vandewalle + * <http://www.esat.kuleuven.ac.be/~cosicart/pdf/AB-9700.pdf> + + * more information available on this implementation here: + + * http://arctic.org/~dean/crypto/sha1.html + + * version: 2 + */ + +/* + * Lightly modified for Botan, tested under GCC 4.1.1 and ICC 9.1 + * on a Linux/Core2 system. + + */ +#include <botan/sha1_sse2.h> +#include <xmmintrin.h> + +namespace Botan { + +namespace { + +typedef union { + u32bit u32[4]; + __m128i u128; + } v4si __attribute__((aligned(16))); + +static const v4si K00_19 = { { 0x5a827999, 0x5a827999, 0x5a827999, 0x5a827999 } }; +static const v4si K20_39 = { { 0x6ed9eba1, 0x6ed9eba1, 0x6ed9eba1, 0x6ed9eba1 } }; +static const v4si K40_59 = { { 0x8f1bbcdc, 0x8f1bbcdc, 0x8f1bbcdc, 0x8f1bbcdc } }; +static const v4si K60_79 = { { 0xca62c1d6, 0xca62c1d6, 0xca62c1d6, 0xca62c1d6 } }; + +#define UNALIGNED 1 +#if UNALIGNED +#define load(p) _mm_loadu_si128(p) +#else +#define load(p) (*p) +#endif + + +/* +the first 16 bytes only need byte swapping + +prepared points to 4x u32bit, 16-byte aligned + +W points to the 4 dwords which need preparing -- +and is overwritten with the swapped bytes +*/ +#define prep00_15(prep, W) do { \ + __m128i r1, r2; \ + \ + r1 = (W); \ + if (1) { \ + r1 = _mm_shufflehi_epi16(r1, _MM_SHUFFLE(2, 3, 0, 1)); \ + r1 = _mm_shufflelo_epi16(r1, _MM_SHUFFLE(2, 3, 0, 1)); \ + r2 = _mm_slli_epi16(r1, 8); \ + r1 = _mm_srli_epi16(r1, 8); \ + r1 = _mm_or_si128(r1, r2); \ + (W) = r1; \ + } \ + (prep).u128 = _mm_add_epi32(K00_19.u128, r1); \ + } while(0) + + + +/* +for each multiple of 4, t, we want to calculate this: + +W[t+0] = rol(W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16], 1); +W[t+1] = rol(W[t-2] ^ W[t-7] ^ W[t-13] ^ W[t-15], 1); +W[t+2] = rol(W[t-1] ^ W[t-6] ^ W[t-12] ^ W[t-14], 1); +W[t+3] = rol(W[t] ^ W[t-5] ^ W[t-11] ^ W[t-13], 1); + +we'll actually calculate this: + +W[t+0] = rol(W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16], 1); +W[t+1] = rol(W[t-2] ^ W[t-7] ^ W[t-13] ^ W[t-15], 1); +W[t+2] = rol(W[t-1] ^ W[t-6] ^ W[t-12] ^ W[t-14], 1); +W[t+3] = rol( 0 ^ W[t-5] ^ W[t-11] ^ W[t-13], 1); +W[t+3] ^= rol(W[t+0], 1); + +the parameters are: + +W0 = &W[t-16]; +W1 = &W[t-12]; +W2 = &W[t- 8]; +W3 = &W[t- 4]; + +and on output: +prepared = W0 + K +W0 = W[t]..W[t+3] +*/ + +/* note that there is a step here where i want to do a rol by 1, which +* normally would look like this: +* +* r1 = psrld r0,$31 +* r0 = pslld r0,$1 +* r0 = por r0,r1 +* +* but instead i do this: +* +* r1 = pcmpltd r0,zero +* r0 = paddd r0,r0 +* r0 = psub r0,r1 +* +* because pcmpltd and paddd are availabe in both MMX units on +* efficeon, pentium-m, and opteron but shifts are available in +* only one unit. +*/ +#define prep(prep, XW0, XW1, XW2, XW3, K) do { \ + __m128i r0, r1, r2, r3; \ + \ + /* load W[t-4] 16-byte aligned, and shift */ \ + r3 = _mm_srli_si128((XW3), 4); \ + r0 = (XW0); \ + /* get high 64-bits of XW0 into low 64-bits */ \ + r1 = _mm_shuffle_epi32((XW0), _MM_SHUFFLE(1,0,3,2)); \ + /* load high 64-bits of r1 */ \ + r1 = _mm_unpacklo_epi64(r1, (XW1)); \ + r2 = (XW2); \ + \ + r0 = _mm_xor_si128(r1, r0); \ + r2 = _mm_xor_si128(r3, r2); \ + r0 = _mm_xor_si128(r2, r0); \ + /* unrotated W[t]..W[t+2] in r0 ... still need W[t+3] */ \ + \ + r2 = _mm_slli_si128(r0, 12); \ + r1 = _mm_cmplt_epi32(r0, _mm_setzero_si128()); \ + r0 = _mm_add_epi32(r0, r0); /* shift left by 1 */ \ + r0 = _mm_sub_epi32(r0, r1); /* r0 has W[t]..W[t+2] */ \ + \ + r3 = _mm_srli_epi32(r2, 30); \ + r2 = _mm_slli_epi32(r2, 2); \ + \ + r0 = _mm_xor_si128(r0, r3); \ + r0 = _mm_xor_si128(r0, r2); /* r0 now has W[t+3] */ \ + \ + (XW0) = r0; \ + (prep).u128 = _mm_add_epi32(r0, (K).u128); \ + } while(0) + + +static inline u32bit rol(u32bit src, u32bit amt) + { + /* gcc and icc appear to turn this into a rotate */ + return (src << amt) | (src >> (32 - amt)); + } + + +static inline u32bit f00_19(u32bit x, u32bit y, u32bit z) + { + /* FIPS 180-2 says this: (x & y) ^ (~x & z) + * but we can calculate it in fewer steps. + */ + return ((y ^ z) & x) ^ z; + } + + +static inline u32bit f20_39(u32bit x, u32bit y, u32bit z) + { + return (x ^ z) ^ y; + } + + +static inline u32bit f40_59(u32bit x, u32bit y, u32bit z) + { + /* FIPS 180-2 says this: (x & y) ^ (x & z) ^ (y & z) + * but we can calculate it in fewer steps. + */ + return (x & z) | ((x | z) & y); + } + + +static inline u32bit f60_79(u32bit x, u32bit y, u32bit z) + { + return f20_39(x, y, z); + } + +#define step(nn_mm, xa, xb, xc, xd, xe, xt, input) do { \ + (xt) = (input) + f##nn_mm((xb), (xc), (xd)); \ + (xb) = rol((xb), 30); \ + (xt) += ((xe) + rol((xa), 5)); \ + } while(0) + +} + +extern "C" void botan_sha1_sse2_compress(u32bit H[5], + const u32bit* inputu) + { + const __m128i * input = (const __m128i *)inputu; + __m128i W0, W1, W2, W3; + v4si prep0, prep1, prep2; + u32bit a, b, c, d, e, t; + + a = H[0]; + b = H[1]; + c = H[2]; + d = H[3]; + e = H[4]; + + /* i've tried arranging the SSE2 code to be 4, 8, 12, and 16 + * steps ahead of the integer code. 12 steps ahead seems + * to produce the best performance. -dean + */ + W0 = load(&input[0]); + prep00_15(prep0, W0); /* prepare for 00 through 03 */ + W1 = load(&input[1]); + prep00_15(prep1, W1); /* prepare for 04 through 07 */ + W2 = load(&input[2]); + prep00_15(prep2, W2); /* prepare for 08 through 11 */ + + W3 = load(&input[3]); + step(00_19, a, b, c, d, e, t, prep0.u32[0]); /* 00 */ + step(00_19, t, a, b, c, d, e, prep0.u32[1]); /* 01 */ + step(00_19, e, t, a, b, c, d, prep0.u32[2]); /* 02 */ + step(00_19, d, e, t, a, b, c, prep0.u32[3]); /* 03 */ + prep00_15(prep0, W3); + step(00_19, c, d, e, t, a, b, prep1.u32[0]); /* 04 */ + step(00_19, b, c, d, e, t, a, prep1.u32[1]); /* 05 */ + step(00_19, a, b, c, d, e, t, prep1.u32[2]); /* 06 */ + step(00_19, t, a, b, c, d, e, prep1.u32[3]); /* 07 */ + prep(prep1, W0, W1, W2, W3, K00_19); /* prepare for 16 through 19 */ + step(00_19, e, t, a, b, c, d, prep2.u32[0]); /* 08 */ + step(00_19, d, e, t, a, b, c, prep2.u32[1]); /* 09 */ + step(00_19, c, d, e, t, a, b, prep2.u32[2]); /* 10 */ + step(00_19, b, c, d, e, t, a, prep2.u32[3]); /* 11 */ + prep(prep2, W1, W2, W3, W0, K20_39); /* prepare for 20 through 23 */ + step(00_19, a, b, c, d, e, t, prep0.u32[0]); /* 12 */ + step(00_19, t, a, b, c, d, e, prep0.u32[1]); /* 13 */ + step(00_19, e, t, a, b, c, d, prep0.u32[2]); /* 14 */ + step(00_19, d, e, t, a, b, c, prep0.u32[3]); /* 15 */ + prep(prep0, W2, W3, W0, W1, K20_39); + step(00_19, c, d, e, t, a, b, prep1.u32[0]); /* 16 */ + step(00_19, b, c, d, e, t, a, prep1.u32[1]); /* 17 */ + step(00_19, a, b, c, d, e, t, prep1.u32[2]); /* 18 */ + step(00_19, t, a, b, c, d, e, prep1.u32[3]); /* 19 */ + + prep(prep1, W3, W0, W1, W2, K20_39); + step(20_39, e, t, a, b, c, d, prep2.u32[0]); /* 20 */ + step(20_39, d, e, t, a, b, c, prep2.u32[1]); /* 21 */ + step(20_39, c, d, e, t, a, b, prep2.u32[2]); /* 22 */ + step(20_39, b, c, d, e, t, a, prep2.u32[3]); /* 23 */ + prep(prep2, W0, W1, W2, W3, K20_39); + step(20_39, a, b, c, d, e, t, prep0.u32[0]); /* 24 */ + step(20_39, t, a, b, c, d, e, prep0.u32[1]); /* 25 */ + step(20_39, e, t, a, b, c, d, prep0.u32[2]); /* 26 */ + step(20_39, d, e, t, a, b, c, prep0.u32[3]); /* 27 */ + prep(prep0, W1, W2, W3, W0, K20_39); + step(20_39, c, d, e, t, a, b, prep1.u32[0]); /* 28 */ + step(20_39, b, c, d, e, t, a, prep1.u32[1]); /* 29 */ + step(20_39, a, b, c, d, e, t, prep1.u32[2]); /* 30 */ + step(20_39, t, a, b, c, d, e, prep1.u32[3]); /* 31 */ + prep(prep1, W2, W3, W0, W1, K40_59); + step(20_39, e, t, a, b, c, d, prep2.u32[0]); /* 32 */ + step(20_39, d, e, t, a, b, c, prep2.u32[1]); /* 33 */ + step(20_39, c, d, e, t, a, b, prep2.u32[2]); /* 34 */ + step(20_39, b, c, d, e, t, a, prep2.u32[3]); /* 35 */ + prep(prep2, W3, W0, W1, W2, K40_59); + step(20_39, a, b, c, d, e, t, prep0.u32[0]); /* 36 */ + step(20_39, t, a, b, c, d, e, prep0.u32[1]); /* 37 */ + step(20_39, e, t, a, b, c, d, prep0.u32[2]); /* 38 */ + step(20_39, d, e, t, a, b, c, prep0.u32[3]); /* 39 */ + + prep(prep0, W0, W1, W2, W3, K40_59); + step(40_59, c, d, e, t, a, b, prep1.u32[0]); /* 40 */ + step(40_59, b, c, d, e, t, a, prep1.u32[1]); /* 41 */ + step(40_59, a, b, c, d, e, t, prep1.u32[2]); /* 42 */ + step(40_59, t, a, b, c, d, e, prep1.u32[3]); /* 43 */ + prep(prep1, W1, W2, W3, W0, K40_59); + step(40_59, e, t, a, b, c, d, prep2.u32[0]); /* 44 */ + step(40_59, d, e, t, a, b, c, prep2.u32[1]); /* 45 */ + step(40_59, c, d, e, t, a, b, prep2.u32[2]); /* 46 */ + step(40_59, b, c, d, e, t, a, prep2.u32[3]); /* 47 */ + prep(prep2, W2, W3, W0, W1, K40_59); + step(40_59, a, b, c, d, e, t, prep0.u32[0]); /* 48 */ + step(40_59, t, a, b, c, d, e, prep0.u32[1]); /* 49 */ + step(40_59, e, t, a, b, c, d, prep0.u32[2]); /* 50 */ + step(40_59, d, e, t, a, b, c, prep0.u32[3]); /* 51 */ + prep(prep0, W3, W0, W1, W2, K60_79); + step(40_59, c, d, e, t, a, b, prep1.u32[0]); /* 52 */ + step(40_59, b, c, d, e, t, a, prep1.u32[1]); /* 53 */ + step(40_59, a, b, c, d, e, t, prep1.u32[2]); /* 54 */ + step(40_59, t, a, b, c, d, e, prep1.u32[3]); /* 55 */ + prep(prep1, W0, W1, W2, W3, K60_79); + step(40_59, e, t, a, b, c, d, prep2.u32[0]); /* 56 */ + step(40_59, d, e, t, a, b, c, prep2.u32[1]); /* 57 */ + step(40_59, c, d, e, t, a, b, prep2.u32[2]); /* 58 */ + step(40_59, b, c, d, e, t, a, prep2.u32[3]); /* 59 */ + + prep(prep2, W1, W2, W3, W0, K60_79); + step(60_79, a, b, c, d, e, t, prep0.u32[0]); /* 60 */ + step(60_79, t, a, b, c, d, e, prep0.u32[1]); /* 61 */ + step(60_79, e, t, a, b, c, d, prep0.u32[2]); /* 62 */ + step(60_79, d, e, t, a, b, c, prep0.u32[3]); /* 63 */ + prep(prep0, W2, W3, W0, W1, K60_79); + step(60_79, c, d, e, t, a, b, prep1.u32[0]); /* 64 */ + step(60_79, b, c, d, e, t, a, prep1.u32[1]); /* 65 */ + step(60_79, a, b, c, d, e, t, prep1.u32[2]); /* 66 */ + step(60_79, t, a, b, c, d, e, prep1.u32[3]); /* 67 */ + prep(prep1, W3, W0, W1, W2, K60_79); + step(60_79, e, t, a, b, c, d, prep2.u32[0]); /* 68 */ + step(60_79, d, e, t, a, b, c, prep2.u32[1]); /* 69 */ + step(60_79, c, d, e, t, a, b, prep2.u32[2]); /* 70 */ + step(60_79, b, c, d, e, t, a, prep2.u32[3]); /* 71 */ + + step(60_79, a, b, c, d, e, t, prep0.u32[0]); /* 72 */ + step(60_79, t, a, b, c, d, e, prep0.u32[1]); /* 73 */ + step(60_79, e, t, a, b, c, d, prep0.u32[2]); /* 74 */ + step(60_79, d, e, t, a, b, c, prep0.u32[3]); /* 75 */ + /* no more input to prepare */ + step(60_79, c, d, e, t, a, b, prep1.u32[0]); /* 76 */ + step(60_79, b, c, d, e, t, a, prep1.u32[1]); /* 77 */ + step(60_79, a, b, c, d, e, t, prep1.u32[2]); /* 78 */ + step(60_79, t, a, b, c, d, e, prep1.u32[3]); /* 79 */ + /* e, t, a, b, c, d */ + H[0] += e; + H[1] += t; + H[2] += a; + H[3] += b; + H[4] += c; + } + +} diff --git a/botan/src/hash/sha2/info.txt b/botan/src/hash/sha2/info.txt new file mode 100644 index 0000000..9b92ff3 --- /dev/null +++ b/botan/src/hash/sha2/info.txt @@ -0,0 +1,16 @@ +realname "SHA-2 (224, 256, 384, 512)" + +define SHA2 + +load_on auto + +<add> +sha2_32.cpp +sha2_32.h +sha2_64.cpp +sha2_64.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/sha2/sha2_32.cpp b/botan/src/hash/sha2/sha2_32.cpp new file mode 100644 index 0000000..9da2ec2 --- /dev/null +++ b/botan/src/hash/sha2/sha2_32.cpp @@ -0,0 +1,193 @@ +/* +* SHA-{224,256} +* (C) 1999-2008 Jack Lloyd +* 2007 FlexSecure GmbH +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/sha2_32.h> +#include <botan/loadstor.h> +#include <botan/rotate.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_224_256_BASE::compress_n(const byte input[], u32bit blocks) + { + 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]; + + for(u32bit i = 0; i != blocks; ++i) + { + for(u32bit j = 0; j != 16; ++j) + W[j] = load_be<u32bit>(input, j); + input += HASH_BLOCK_SIZE; + + 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]; + + 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); + + A = (digest[0] += A); + B = (digest[1] += B); + C = (digest[2] += C); + D = (digest[3] += D); + E = (digest[4] += E); + F = (digest[5] += F); + G = (digest[6] += G); + H = (digest[7] += H); + } + } + +/* +* Copy out the digest +*/ +void SHA_224_256_BASE::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_224_256_BASE::clear() throw() + { + MDx_HashFunction::clear(); + W.clear(); + } + +/* +* Clear memory of sensitive data +*/ +void SHA_224::clear() throw() + { + SHA_224_256_BASE::clear(); + digest[0] = 0xc1059ed8; + digest[1] = 0x367cd507; + digest[2] = 0x3070dd17; + digest[3] = 0xf70e5939; + digest[4] = 0xffc00b31; + digest[5] = 0x68581511; + digest[6] = 0x64f98fa7; + digest[7] = 0xbefa4fa4; + } + +/* +* Clear memory of sensitive data +*/ +void SHA_256::clear() throw() + { + SHA_224_256_BASE::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/botan/src/hash/sha2/sha2_32.h b/botan/src/hash/sha2/sha2_32.h new file mode 100644 index 0000000..05083d1 --- /dev/null +++ b/botan/src/hash/sha2/sha2_32.h @@ -0,0 +1,59 @@ +/* +* SHA-{224,256} +* (C) 1999-2008 Jack Lloyd +* 2007 FlexSecure GmbH +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_SHA_256_H__ +#define BOTAN_SHA_256_H__ + +#include <botan/mdx_hash.h> + +namespace Botan { + +/* +* SHA-{224,256} Base +*/ +class BOTAN_DLL SHA_224_256_BASE : public MDx_HashFunction + { + protected: + void clear() throw(); + SHA_224_256_BASE(u32bit out) : + MDx_HashFunction(out, 64, true, true) { clear(); } + + SecureBuffer<u32bit, 64> W; + SecureBuffer<u32bit, 8> digest; + private: + void compress_n(const byte[], u32bit blocks); + void copy_out(byte[]); + }; + +/* +* SHA-224 +*/ +class BOTAN_DLL SHA_224 : public SHA_224_256_BASE + { + public: + void clear() throw(); + std::string name() const { return "SHA-224"; } + HashFunction* clone() const { return new SHA_224; } + SHA_224() : SHA_224_256_BASE(28) { clear(); } + }; + +/* +* SHA-256 +*/ +class BOTAN_DLL SHA_256 : public SHA_224_256_BASE + { + public: + void clear() throw(); + std::string name() const { return "SHA-256"; } + HashFunction* clone() const { return new SHA_256; } + SHA_256() : SHA_224_256_BASE(32) { clear (); } + }; + +} + +#endif diff --git a/botan/src/hash/sha2/sha2_64.cpp b/botan/src/hash/sha2/sha2_64.cpp new file mode 100644 index 0000000..c2a8749 --- /dev/null +++ b/botan/src/hash/sha2/sha2_64.cpp @@ -0,0 +1,208 @@ +/* +* SHA-{384,512} +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/sha2_64.h> +#include <botan/loadstor.h> +#include <botan/rotate.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_384_512_BASE::compress_n(const byte input[], u32bit blocks) + { + 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]; + + for(u32bit i = 0; i != blocks; ++i) + { + for(u32bit j = 0; j != 16; ++j) + W[j] = load_be<u64bit>(input, j); + input += HASH_BLOCK_SIZE; + + 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]; + + F1(A, B, C, D, E, F, G, H, W[ 0], (u64bit) 0x428A2F98D728AE22ULL); + F1(H, A, B, C, D, E, F, G, W[ 1], (u64bit) 0x7137449123EF65CDULL); + F1(G, H, A, B, C, D, E, F, W[ 2], (u64bit) 0xB5C0FBCFEC4D3B2FULL); + F1(F, G, H, A, B, C, D, E, W[ 3], (u64bit) 0xE9B5DBA58189DBBCULL); + F1(E, F, G, H, A, B, C, D, W[ 4], (u64bit) 0x3956C25BF348B538ULL); + F1(D, E, F, G, H, A, B, C, W[ 5], (u64bit) 0x59F111F1B605D019ULL); + F1(C, D, E, F, G, H, A, B, W[ 6], (u64bit) 0x923F82A4AF194F9BULL); + F1(B, C, D, E, F, G, H, A, W[ 7], (u64bit) 0xAB1C5ED5DA6D8118ULL); + F1(A, B, C, D, E, F, G, H, W[ 8], (u64bit) 0xD807AA98A3030242ULL); + F1(H, A, B, C, D, E, F, G, W[ 9], (u64bit) 0x12835B0145706FBEULL); + F1(G, H, A, B, C, D, E, F, W[10], (u64bit) 0x243185BE4EE4B28CULL); + F1(F, G, H, A, B, C, D, E, W[11], (u64bit) 0x550C7DC3D5FFB4E2ULL); + F1(E, F, G, H, A, B, C, D, W[12], (u64bit) 0x72BE5D74F27B896FULL); + F1(D, E, F, G, H, A, B, C, W[13], (u64bit) 0x80DEB1FE3B1696B1ULL); + F1(C, D, E, F, G, H, A, B, W[14], (u64bit) 0x9BDC06A725C71235ULL); + F1(B, C, D, E, F, G, H, A, W[15], (u64bit) 0xC19BF174CF692694ULL); + F1(A, B, C, D, E, F, G, H, W[16], (u64bit) 0xE49B69C19EF14AD2ULL); + F1(H, A, B, C, D, E, F, G, W[17], (u64bit) 0xEFBE4786384F25E3ULL); + F1(G, H, A, B, C, D, E, F, W[18], (u64bit) 0x0FC19DC68B8CD5B5ULL); + F1(F, G, H, A, B, C, D, E, W[19], (u64bit) 0x240CA1CC77AC9C65ULL); + F1(E, F, G, H, A, B, C, D, W[20], (u64bit) 0x2DE92C6F592B0275ULL); + F1(D, E, F, G, H, A, B, C, W[21], (u64bit) 0x4A7484AA6EA6E483ULL); + F1(C, D, E, F, G, H, A, B, W[22], (u64bit) 0x5CB0A9DCBD41FBD4ULL); + F1(B, C, D, E, F, G, H, A, W[23], (u64bit) 0x76F988DA831153B5ULL); + F1(A, B, C, D, E, F, G, H, W[24], (u64bit) 0x983E5152EE66DFABULL); + F1(H, A, B, C, D, E, F, G, W[25], (u64bit) 0xA831C66D2DB43210ULL); + F1(G, H, A, B, C, D, E, F, W[26], (u64bit) 0xB00327C898FB213FULL); + F1(F, G, H, A, B, C, D, E, W[27], (u64bit) 0xBF597FC7BEEF0EE4ULL); + F1(E, F, G, H, A, B, C, D, W[28], (u64bit) 0xC6E00BF33DA88FC2ULL); + F1(D, E, F, G, H, A, B, C, W[29], (u64bit) 0xD5A79147930AA725ULL); + F1(C, D, E, F, G, H, A, B, W[30], (u64bit) 0x06CA6351E003826FULL); + F1(B, C, D, E, F, G, H, A, W[31], (u64bit) 0x142929670A0E6E70ULL); + F1(A, B, C, D, E, F, G, H, W[32], (u64bit) 0x27B70A8546D22FFCULL); + F1(H, A, B, C, D, E, F, G, W[33], (u64bit) 0x2E1B21385C26C926ULL); + F1(G, H, A, B, C, D, E, F, W[34], (u64bit) 0x4D2C6DFC5AC42AEDULL); + F1(F, G, H, A, B, C, D, E, W[35], (u64bit) 0x53380D139D95B3DFULL); + F1(E, F, G, H, A, B, C, D, W[36], (u64bit) 0x650A73548BAF63DEULL); + F1(D, E, F, G, H, A, B, C, W[37], (u64bit) 0x766A0ABB3C77B2A8ULL); + F1(C, D, E, F, G, H, A, B, W[38], (u64bit) 0x81C2C92E47EDAEE6ULL); + F1(B, C, D, E, F, G, H, A, W[39], (u64bit) 0x92722C851482353BULL); + F1(A, B, C, D, E, F, G, H, W[40], (u64bit) 0xA2BFE8A14CF10364ULL); + F1(H, A, B, C, D, E, F, G, W[41], (u64bit) 0xA81A664BBC423001ULL); + F1(G, H, A, B, C, D, E, F, W[42], (u64bit) 0xC24B8B70D0F89791ULL); + F1(F, G, H, A, B, C, D, E, W[43], (u64bit) 0xC76C51A30654BE30ULL); + F1(E, F, G, H, A, B, C, D, W[44], (u64bit) 0xD192E819D6EF5218ULL); + F1(D, E, F, G, H, A, B, C, W[45], (u64bit) 0xD69906245565A910ULL); + F1(C, D, E, F, G, H, A, B, W[46], (u64bit) 0xF40E35855771202AULL); + F1(B, C, D, E, F, G, H, A, W[47], (u64bit) 0x106AA07032BBD1B8ULL); + F1(A, B, C, D, E, F, G, H, W[48], (u64bit) 0x19A4C116B8D2D0C8ULL); + F1(H, A, B, C, D, E, F, G, W[49], (u64bit) 0x1E376C085141AB53ULL); + F1(G, H, A, B, C, D, E, F, W[50], (u64bit) 0x2748774CDF8EEB99ULL); + F1(F, G, H, A, B, C, D, E, W[51], (u64bit) 0x34B0BCB5E19B48A8ULL); + F1(E, F, G, H, A, B, C, D, W[52], (u64bit) 0x391C0CB3C5C95A63ULL); + F1(D, E, F, G, H, A, B, C, W[53], (u64bit) 0x4ED8AA4AE3418ACBULL); + F1(C, D, E, F, G, H, A, B, W[54], (u64bit) 0x5B9CCA4F7763E373ULL); + F1(B, C, D, E, F, G, H, A, W[55], (u64bit) 0x682E6FF3D6B2B8A3ULL); + F1(A, B, C, D, E, F, G, H, W[56], (u64bit) 0x748F82EE5DEFB2FCULL); + F1(H, A, B, C, D, E, F, G, W[57], (u64bit) 0x78A5636F43172F60ULL); + F1(G, H, A, B, C, D, E, F, W[58], (u64bit) 0x84C87814A1F0AB72ULL); + F1(F, G, H, A, B, C, D, E, W[59], (u64bit) 0x8CC702081A6439ECULL); + F1(E, F, G, H, A, B, C, D, W[60], (u64bit) 0x90BEFFFA23631E28ULL); + F1(D, E, F, G, H, A, B, C, W[61], (u64bit) 0xA4506CEBDE82BDE9ULL); + F1(C, D, E, F, G, H, A, B, W[62], (u64bit) 0xBEF9A3F7B2C67915ULL); + F1(B, C, D, E, F, G, H, A, W[63], (u64bit) 0xC67178F2E372532BULL); + F1(A, B, C, D, E, F, G, H, W[64], (u64bit) 0xCA273ECEEA26619CULL); + F1(H, A, B, C, D, E, F, G, W[65], (u64bit) 0xD186B8C721C0C207ULL); + F1(G, H, A, B, C, D, E, F, W[66], (u64bit) 0xEADA7DD6CDE0EB1EULL); + F1(F, G, H, A, B, C, D, E, W[67], (u64bit) 0xF57D4F7FEE6ED178ULL); + F1(E, F, G, H, A, B, C, D, W[68], (u64bit) 0x06F067AA72176FBAULL); + F1(D, E, F, G, H, A, B, C, W[69], (u64bit) 0x0A637DC5A2C898A6ULL); + F1(C, D, E, F, G, H, A, B, W[70], (u64bit) 0x113F9804BEF90DAEULL); + F1(B, C, D, E, F, G, H, A, W[71], (u64bit) 0x1B710B35131C471BULL); + F1(A, B, C, D, E, F, G, H, W[72], (u64bit) 0x28DB77F523047D84ULL); + F1(H, A, B, C, D, E, F, G, W[73], (u64bit) 0x32CAAB7B40C72493ULL); + F1(G, H, A, B, C, D, E, F, W[74], (u64bit) 0x3C9EBE0A15C9BEBCULL); + F1(F, G, H, A, B, C, D, E, W[75], (u64bit) 0x431D67C49C100D4CULL); + F1(E, F, G, H, A, B, C, D, W[76], (u64bit) 0x4CC5D4BECB3E42B6ULL); + F1(D, E, F, G, H, A, B, C, W[77], (u64bit) 0x597F299CFC657E2AULL); + F1(C, D, E, F, G, H, A, B, W[78], (u64bit) 0x5FCB6FAB3AD6FAECULL); + F1(B, C, D, E, F, G, H, A, W[79], (u64bit) 0x6C44198C4A475817ULL); + + A = (digest[0] += A); + B = (digest[1] += B); + C = (digest[2] += C); + D = (digest[3] += D); + E = (digest[4] += E); + F = (digest[5] += F); + G = (digest[6] += G); + H = (digest[7] += H); + } + } + +/* +* Copy out the digest +*/ +void SHA_384_512_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_384_512_BASE::clear() throw() + { + MDx_HashFunction::clear(); + W.clear(); + } + +/* +* Clear memory of sensitive data +*/ +void SHA_384::clear() throw() + { + SHA_384_512_BASE::clear(); + digest[0] = (u64bit) 0xCBBB9D5DC1059ED8ULL; + digest[1] = (u64bit) 0x629A292A367CD507ULL; + digest[2] = (u64bit) 0x9159015A3070DD17ULL; + digest[3] = (u64bit) 0x152FECD8F70E5939ULL; + digest[4] = (u64bit) 0x67332667FFC00B31ULL; + digest[5] = (u64bit) 0x8EB44A8768581511ULL; + digest[6] = (u64bit) 0xDB0C2E0D64F98FA7ULL; + digest[7] = (u64bit) 0x47B5481DBEFA4FA4ULL; + } + +/* +* Clear memory of sensitive data +*/ +void SHA_512::clear() throw() + { + SHA_384_512_BASE::clear(); + digest[0] = (u64bit) 0x6A09E667F3BCC908ULL; + digest[1] = (u64bit) 0xBB67AE8584CAA73BULL; + digest[2] = (u64bit) 0x3C6EF372FE94F82BULL; + digest[3] = (u64bit) 0xA54FF53A5F1D36F1ULL; + digest[4] = (u64bit) 0x510E527FADE682D1ULL; + digest[5] = (u64bit) 0x9B05688C2B3E6C1FULL; + digest[6] = (u64bit) 0x1F83D9ABFB41BD6BULL; + digest[7] = (u64bit) 0x5BE0CD19137E2179ULL; + } + +} diff --git a/botan/src/hash/sha2/sha2_64.h b/botan/src/hash/sha2/sha2_64.h new file mode 100644 index 0000000..dcc6dc8 --- /dev/null +++ b/botan/src/hash/sha2/sha2_64.h @@ -0,0 +1,60 @@ +/* +* SHA-{384,512} +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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_384_512_BASE : public MDx_HashFunction + { + protected: + void clear() throw(); + + SHA_384_512_BASE(u32bit out) : + MDx_HashFunction(out, 128, true, true, 16) {} + + SecureBuffer<u64bit, 8> digest; + private: + void compress_n(const byte[], u32bit blocks); + void copy_out(byte[]); + + SecureBuffer<u64bit, 80> W; + }; + +/* +* SHA-384 +*/ +class BOTAN_DLL SHA_384 : public SHA_384_512_BASE + { + public: + void clear() throw(); + std::string name() const { return "SHA-384"; } + HashFunction* clone() const { return new SHA_384; } + SHA_384() : SHA_384_512_BASE(48) { clear(); } + }; + +/* +* SHA-512 +*/ +class BOTAN_DLL SHA_512 : public SHA_384_512_BASE + { + public: + void clear() throw(); + std::string name() const { return "SHA-512"; } + HashFunction* clone() const { return new SHA_512; } + SHA_512() : SHA_384_512_BASE(64) { clear(); } + }; + +} + +#endif diff --git a/botan/src/hash/skein/info.txt b/botan/src/hash/skein/info.txt new file mode 100644 index 0000000..bab8497 --- /dev/null +++ b/botan/src/hash/skein/info.txt @@ -0,0 +1,14 @@ +realname "Skein" + +define SKEIN_512 + +load_on auto + +<add> +skein_512.cpp +skein_512.h +</add> + +<requires> +alloc +</requires> diff --git a/botan/src/hash/skein/skein_512.cpp b/botan/src/hash/skein/skein_512.cpp new file mode 100644 index 0000000..da4715d --- /dev/null +++ b/botan/src/hash/skein/skein_512.cpp @@ -0,0 +1,262 @@ +/** +* The Skein-512 hash function +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/skein_512.h> +#include <botan/loadstor.h> +#include <botan/parsing.h> +#include <botan/exceptn.h> +#include <algorithm> + +namespace Botan { + +namespace { + +enum type_code { + SKEIN_KEY = 0, + SKEIN_CONFIG = 4, + SKEIN_PERSONALIZATION = 8, + SKEIN_PUBLIC_KEY = 12, + SKEIN_KEY_IDENTIFIER = 16, + SKEIN_NONCE = 20, + SKEIN_MSG = 48, + SKEIN_OUTPUT = 63 +}; + +void ubi_512(u64bit H[9], u64bit T[], const byte msg[], u64bit msg_len) + { + do + { + const u64bit to_proc = std::min<u64bit>(msg_len, 64); + T[0] += to_proc; + + u64bit M[8] = { 0 }; + for(u32bit j = 0; j != to_proc / 8; ++j) + M[j] = load_le<u64bit>(msg, j); + + if(to_proc % 8) + { + for(u32bit j = 0; j != to_proc % 8; ++j) + M[to_proc/8] |= ((u64bit)msg[8*(to_proc/8)+j] << (8*j)); + } + + H[8] = H[0] ^ H[1] ^ H[2] ^ H[3] ^ + H[4] ^ H[5] ^ H[6] ^ H[7] ^ (u64bit) 0x5555555555555555ULL; + + T[2] = T[0] ^ T[1]; + + u64bit X0 = M[0] + H[0]; + u64bit X1 = M[1] + H[1]; + u64bit X2 = M[2] + H[2]; + u64bit X3 = M[3] + H[3]; + u64bit X4 = M[4] + H[4]; + u64bit X5 = M[5] + H[5] + T[0]; + u64bit X6 = M[6] + H[6] + T[1]; + u64bit X7 = M[7] + H[7]; + +#define THREEFISH_ROUND(I1,I2,I3,I4,I5,I6,I7,I8,ROT1,ROT2,ROT3,ROT4) \ + do { \ + X##I1 += X##I2; X##I2 = rotate_left(X##I2, ROT1) ^ X##I1; \ + X##I3 += X##I4; X##I4 = rotate_left(X##I4, ROT2) ^ X##I3; \ + X##I5 += X##I6; X##I6 = rotate_left(X##I6, ROT3) ^ X##I5; \ + X##I7 += X##I8; X##I8 = rotate_left(X##I8, ROT4) ^ X##I7; \ + } while(0); + +#define THREEFISH_INJECT_KEY(r) \ + do { \ + X0 += H[(r ) % 9]; \ + X1 += H[(r+1) % 9]; \ + X2 += H[(r+2) % 9]; \ + X3 += H[(r+3) % 9]; \ + X4 += H[(r+4) % 9]; \ + X5 += H[(r+5) % 9] + T[(r ) % 3]; \ + X6 += H[(r+6) % 9] + T[(r+1) % 3]; \ + X7 += H[(r+7) % 9] + (r); \ + } while(0); + +#define THREEFISH_8_ROUNDS(R1,R2) \ + do { \ + THREEFISH_ROUND(0,1,2,3,4,5,6,7, 46,36,19,37); \ + THREEFISH_ROUND(2,1,4,7,6,5,0,3, 33,27,14,42); \ + THREEFISH_ROUND(4,1,6,3,0,5,2,7, 17,49,36,39); \ + THREEFISH_ROUND(6,1,0,7,2,5,4,3, 44, 9,54,56); \ + \ + THREEFISH_INJECT_KEY(R1); \ + \ + THREEFISH_ROUND(0,1,2,3,4,5,6,7, 39,30,34,24); \ + THREEFISH_ROUND(2,1,4,7,6,5,0,3, 13,50,10,17); \ + THREEFISH_ROUND(4,1,6,3,0,5,2,7, 25,29,39,43); \ + THREEFISH_ROUND(6,1,0,7,2,5,4,3, 8,35,56,22); \ + \ + THREEFISH_INJECT_KEY(R2); \ + } while(0); + + THREEFISH_8_ROUNDS(1,2); + THREEFISH_8_ROUNDS(3,4); + THREEFISH_8_ROUNDS(5,6); + THREEFISH_8_ROUNDS(7,8); + THREEFISH_8_ROUNDS(9,10); + THREEFISH_8_ROUNDS(11,12); + THREEFISH_8_ROUNDS(13,14); + THREEFISH_8_ROUNDS(15,16); + THREEFISH_8_ROUNDS(17,18); + + // message feed forward + H[0] = X0 ^ M[0]; + H[1] = X1 ^ M[1]; + H[2] = X2 ^ M[2]; + H[3] = X3 ^ M[3]; + H[4] = X4 ^ M[4]; + H[5] = X5 ^ M[5]; + H[6] = X6 ^ M[6]; + H[7] = X7 ^ M[7]; + + T[1] &= ~((u64bit)1 << 62); // clear first flag if set + + msg_len -= to_proc; + msg += to_proc; + } while(msg_len); + } + +void reset_tweak(u64bit T[3], type_code type, bool final) + { + T[0] = 0; + T[1] = ((u64bit)type << 56) | ((u64bit)1 << 62) | ((u64bit)final << 63); + } + +void initial_block(u64bit H[9], u64bit T[3], u32bit output_bits, + const std::string& personalization) + { + clear_mem(H, 9); + + // ASCII("SHA3") followed by version (0x0001) code + byte config_str[32] = { 0x53, 0x48, 0x41, 0x33, 0x01, 0x00, 0 }; + store_le(output_bits, config_str + 8); + + reset_tweak(T, SKEIN_CONFIG, true); + ubi_512(H, T, config_str, sizeof(config_str)); + + if(personalization != "") + { + /* + This is a limitation of this implementation, and not of the + algorithm specification. Could be fixed relatively easily, but + doesn't seem worth the trouble. + */ + if(personalization.length() > 64) + throw Invalid_Argument("Skein personalization must be <= 64 bytes"); + + const byte* bits = reinterpret_cast<const byte*>(personalization.data()); + + reset_tweak(T, SKEIN_PERSONALIZATION, true); + ubi_512(H, T, bits, personalization.length()); + } + + reset_tweak(T, SKEIN_MSG, false); + } + +} + +Skein_512::Skein_512(u32bit arg_output_bits, + const std::string& arg_personalization) : + HashFunction(arg_output_bits / 8, 64), + personalization(arg_personalization), + output_bits(arg_output_bits) + { + if(output_bits == 0 || output_bits % 8 != 0) + throw Invalid_Argument("Bad output bits size for Skein-512"); + + buf_pos = 0; + initial_block(H, T, output_bits, personalization); + } + +std::string Skein_512::name() const + { + return "Skein-512(" + to_string(output_bits) + ")"; + } + +HashFunction* Skein_512::clone() const + { + return new Skein_512(output_bits, personalization); + } + +void Skein_512::clear() throw() + { + H.clear(); + T.clear(); + buffer.clear(); + buf_pos = 0; + } + +void Skein_512::add_data(const byte input[], u32bit length) + { + if(length == 0) + return; + + if(buf_pos) + { + buffer.copy(buf_pos, input, length); + if(buf_pos + length > 64) + { + ubi_512(H, T, &buffer[0], buffer.size()); + + input += (64 - buf_pos); + length -= (64 - buf_pos); + buf_pos = 0; + } + } + + const u32bit full_blocks = (length - 1) / 64; + + if(full_blocks) + ubi_512(H, T, input, 64*full_blocks); + + length -= full_blocks * 64; + + buffer.copy(buf_pos, input + full_blocks * 64, length); + buf_pos += length; + } + +void Skein_512::final_result(byte out[]) + { + T[1] |= ((u64bit)1 << 63); // final block flag + + for(u32bit i = buf_pos; i != buffer.size(); ++i) + buffer[i] = 0; + + ubi_512(H, T, &buffer[0], buf_pos); + + byte counter[8] = { 0 }; + + u32bit out_bytes = output_bits / 8; + + SecureBuffer<u64bit, 9> H_out; + + while(out_bytes) + { + const u32bit to_proc = std::min<u32bit>(out_bytes, 64); + + H_out.copy(H.begin(), 8); + + reset_tweak(T, SKEIN_OUTPUT, true); + ubi_512(H_out, T, counter, sizeof(counter)); + + for(u32bit i = 0; i != to_proc; ++i) + out[i] = get_byte(7-i%8, H_out[i/8]); + + out_bytes -= to_proc; + out += to_proc; + + for(u32bit i = 0; i != sizeof(counter); ++i) + if(++counter[i]) + break; + } + + buf_pos = 0; + initial_block(H, T, output_bits, personalization); + } + +} diff --git a/botan/src/hash/skein/skein_512.h b/botan/src/hash/skein/skein_512.h new file mode 100644 index 0000000..fa558fc --- /dev/null +++ b/botan/src/hash/skein/skein_512.h @@ -0,0 +1,41 @@ +/** +* The Skein-512 hash function +* (C) 2009 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#ifndef BOTAN_SKEIN_512_H__ +#define BOTAN_SKEIN_512_H__ + +#include <botan/secmem.h> +#include <botan/hash.h> +#include <string> + +namespace Botan { + +class BOTAN_DLL Skein_512 : public HashFunction + { + public: + Skein_512(u32bit output_bits = 512, + const std::string& personalization = ""); + + HashFunction* clone() const; + std::string name() const; + void clear() throw(); + private: + void add_data(const byte input[], u32bit length); + void final_result(byte out[]); + + std::string personalization; + u32bit output_bits; + SecureBuffer<u64bit, 9> H; + SecureBuffer<u64bit, 3> T; + + SecureBuffer<byte, 64> buffer; + u32bit buf_pos; + }; + +} + +#endif diff --git a/botan/src/hash/tiger/info.txt b/botan/src/hash/tiger/info.txt new file mode 100644 index 0000000..7d4cd71 --- /dev/null +++ b/botan/src/hash/tiger/info.txt @@ -0,0 +1,15 @@ +realname "Tiger" + +define TIGER + +load_on auto + +<add> +tig_tab.cpp +tiger.cpp +tiger.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/tiger/tig_tab.cpp b/botan/src/hash/tiger/tig_tab.cpp new file mode 100644 index 0000000..6fc8686 --- /dev/null +++ b/botan/src/hash/tiger/tig_tab.cpp @@ -0,0 +1,364 @@ +/* +* S-Box Tables for Tiger +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/tiger.h> + +namespace Botan { + +const u64bit Tiger::SBOX1[256] = { + (u64bit) 0x02AAB17CF7E90C5EULL, (u64bit) 0xAC424B03E243A8ECULL, (u64bit) 0x72CD5BE30DD5FCD3ULL, + (u64bit) 0x6D019B93F6F97F3AULL, (u64bit) 0xCD9978FFD21F9193ULL, (u64bit) 0x7573A1C9708029E2ULL, + (u64bit) 0xB164326B922A83C3ULL, (u64bit) 0x46883EEE04915870ULL, (u64bit) 0xEAACE3057103ECE6ULL, + (u64bit) 0xC54169B808A3535CULL, (u64bit) 0x4CE754918DDEC47CULL, (u64bit) 0x0AA2F4DFDC0DF40CULL, + (u64bit) 0x10B76F18A74DBEFAULL, (u64bit) 0xC6CCB6235AD1AB6AULL, (u64bit) 0x13726121572FE2FFULL, + (u64bit) 0x1A488C6F199D921EULL, (u64bit) 0x4BC9F9F4DA0007CAULL, (u64bit) 0x26F5E6F6E85241C7ULL, + (u64bit) 0x859079DBEA5947B6ULL, (u64bit) 0x4F1885C5C99E8C92ULL, (u64bit) 0xD78E761EA96F864BULL, + (u64bit) 0x8E36428C52B5C17DULL, (u64bit) 0x69CF6827373063C1ULL, (u64bit) 0xB607C93D9BB4C56EULL, + (u64bit) 0x7D820E760E76B5EAULL, (u64bit) 0x645C9CC6F07FDC42ULL, (u64bit) 0xBF38A078243342E0ULL, + (u64bit) 0x5F6B343C9D2E7D04ULL, (u64bit) 0xF2C28AEB600B0EC6ULL, (u64bit) 0x6C0ED85F7254BCACULL, + (u64bit) 0x71592281A4DB4FE5ULL, (u64bit) 0x1967FA69CE0FED9FULL, (u64bit) 0xFD5293F8B96545DBULL, + (u64bit) 0xC879E9D7F2A7600BULL, (u64bit) 0x860248920193194EULL, (u64bit) 0xA4F9533B2D9CC0B3ULL, + (u64bit) 0x9053836C15957613ULL, (u64bit) 0xDB6DCF8AFC357BF1ULL, (u64bit) 0x18BEEA7A7A370F57ULL, + (u64bit) 0x037117CA50B99066ULL, (u64bit) 0x6AB30A9774424A35ULL, (u64bit) 0xF4E92F02E325249BULL, + (u64bit) 0x7739DB07061CCAE1ULL, (u64bit) 0xD8F3B49CECA42A05ULL, (u64bit) 0xBD56BE3F51382F73ULL, + (u64bit) 0x45FAED5843B0BB28ULL, (u64bit) 0x1C813D5C11BF1F83ULL, (u64bit) 0x8AF0E4B6D75FA169ULL, + (u64bit) 0x33EE18A487AD9999ULL, (u64bit) 0x3C26E8EAB1C94410ULL, (u64bit) 0xB510102BC0A822F9ULL, + (u64bit) 0x141EEF310CE6123BULL, (u64bit) 0xFC65B90059DDB154ULL, (u64bit) 0xE0158640C5E0E607ULL, + (u64bit) 0x884E079826C3A3CFULL, (u64bit) 0x930D0D9523C535FDULL, (u64bit) 0x35638D754E9A2B00ULL, + (u64bit) 0x4085FCCF40469DD5ULL, (u64bit) 0xC4B17AD28BE23A4CULL, (u64bit) 0xCAB2F0FC6A3E6A2EULL, + (u64bit) 0x2860971A6B943FCDULL, (u64bit) 0x3DDE6EE212E30446ULL, (u64bit) 0x6222F32AE01765AEULL, + (u64bit) 0x5D550BB5478308FEULL, (u64bit) 0xA9EFA98DA0EDA22AULL, (u64bit) 0xC351A71686C40DA7ULL, + (u64bit) 0x1105586D9C867C84ULL, (u64bit) 0xDCFFEE85FDA22853ULL, (u64bit) 0xCCFBD0262C5EEF76ULL, + (u64bit) 0xBAF294CB8990D201ULL, (u64bit) 0xE69464F52AFAD975ULL, (u64bit) 0x94B013AFDF133E14ULL, + (u64bit) 0x06A7D1A32823C958ULL, (u64bit) 0x6F95FE5130F61119ULL, (u64bit) 0xD92AB34E462C06C0ULL, + (u64bit) 0xED7BDE33887C71D2ULL, (u64bit) 0x79746D6E6518393EULL, (u64bit) 0x5BA419385D713329ULL, + (u64bit) 0x7C1BA6B948A97564ULL, (u64bit) 0x31987C197BFDAC67ULL, (u64bit) 0xDE6C23C44B053D02ULL, + (u64bit) 0x581C49FED002D64DULL, (u64bit) 0xDD474D6338261571ULL, (u64bit) 0xAA4546C3E473D062ULL, + (u64bit) 0x928FCE349455F860ULL, (u64bit) 0x48161BBACAAB94D9ULL, (u64bit) 0x63912430770E6F68ULL, + (u64bit) 0x6EC8A5E602C6641CULL, (u64bit) 0x87282515337DDD2BULL, (u64bit) 0x2CDA6B42034B701BULL, + (u64bit) 0xB03D37C181CB096DULL, (u64bit) 0xE108438266C71C6FULL, (u64bit) 0x2B3180C7EB51B255ULL, + (u64bit) 0xDF92B82F96C08BBCULL, (u64bit) 0x5C68C8C0A632F3BAULL, (u64bit) 0x5504CC861C3D0556ULL, + (u64bit) 0xABBFA4E55FB26B8FULL, (u64bit) 0x41848B0AB3BACEB4ULL, (u64bit) 0xB334A273AA445D32ULL, + (u64bit) 0xBCA696F0A85AD881ULL, (u64bit) 0x24F6EC65B528D56CULL, (u64bit) 0x0CE1512E90F4524AULL, + (u64bit) 0x4E9DD79D5506D35AULL, (u64bit) 0x258905FAC6CE9779ULL, (u64bit) 0x2019295B3E109B33ULL, + (u64bit) 0xF8A9478B73A054CCULL, (u64bit) 0x2924F2F934417EB0ULL, (u64bit) 0x3993357D536D1BC4ULL, + (u64bit) 0x38A81AC21DB6FF8BULL, (u64bit) 0x47C4FBF17D6016BFULL, (u64bit) 0x1E0FAADD7667E3F5ULL, + (u64bit) 0x7ABCFF62938BEB96ULL, (u64bit) 0xA78DAD948FC179C9ULL, (u64bit) 0x8F1F98B72911E50DULL, + (u64bit) 0x61E48EAE27121A91ULL, (u64bit) 0x4D62F7AD31859808ULL, (u64bit) 0xECEBA345EF5CEAEBULL, + (u64bit) 0xF5CEB25EBC9684CEULL, (u64bit) 0xF633E20CB7F76221ULL, (u64bit) 0xA32CDF06AB8293E4ULL, + (u64bit) 0x985A202CA5EE2CA4ULL, (u64bit) 0xCF0B8447CC8A8FB1ULL, (u64bit) 0x9F765244979859A3ULL, + (u64bit) 0xA8D516B1A1240017ULL, (u64bit) 0x0BD7BA3EBB5DC726ULL, (u64bit) 0xE54BCA55B86ADB39ULL, + (u64bit) 0x1D7A3AFD6C478063ULL, (u64bit) 0x519EC608E7669EDDULL, (u64bit) 0x0E5715A2D149AA23ULL, + (u64bit) 0x177D4571848FF194ULL, (u64bit) 0xEEB55F3241014C22ULL, (u64bit) 0x0F5E5CA13A6E2EC2ULL, + (u64bit) 0x8029927B75F5C361ULL, (u64bit) 0xAD139FABC3D6E436ULL, (u64bit) 0x0D5DF1A94CCF402FULL, + (u64bit) 0x3E8BD948BEA5DFC8ULL, (u64bit) 0xA5A0D357BD3FF77EULL, (u64bit) 0xA2D12E251F74F645ULL, + (u64bit) 0x66FD9E525E81A082ULL, (u64bit) 0x2E0C90CE7F687A49ULL, (u64bit) 0xC2E8BCBEBA973BC5ULL, + (u64bit) 0x000001BCE509745FULL, (u64bit) 0x423777BBE6DAB3D6ULL, (u64bit) 0xD1661C7EAEF06EB5ULL, + (u64bit) 0xA1781F354DAACFD8ULL, (u64bit) 0x2D11284A2B16AFFCULL, (u64bit) 0xF1FC4F67FA891D1FULL, + (u64bit) 0x73ECC25DCB920ADAULL, (u64bit) 0xAE610C22C2A12651ULL, (u64bit) 0x96E0A810D356B78AULL, + (u64bit) 0x5A9A381F2FE7870FULL, (u64bit) 0xD5AD62EDE94E5530ULL, (u64bit) 0xD225E5E8368D1427ULL, + (u64bit) 0x65977B70C7AF4631ULL, (u64bit) 0x99F889B2DE39D74FULL, (u64bit) 0x233F30BF54E1D143ULL, + (u64bit) 0x9A9675D3D9A63C97ULL, (u64bit) 0x5470554FF334F9A8ULL, (u64bit) 0x166ACB744A4F5688ULL, + (u64bit) 0x70C74CAAB2E4AEADULL, (u64bit) 0xF0D091646F294D12ULL, (u64bit) 0x57B82A89684031D1ULL, + (u64bit) 0xEFD95A5A61BE0B6BULL, (u64bit) 0x2FBD12E969F2F29AULL, (u64bit) 0x9BD37013FEFF9FE8ULL, + (u64bit) 0x3F9B0404D6085A06ULL, (u64bit) 0x4940C1F3166CFE15ULL, (u64bit) 0x09542C4DCDF3DEFBULL, + (u64bit) 0xB4C5218385CD5CE3ULL, (u64bit) 0xC935B7DC4462A641ULL, (u64bit) 0x3417F8A68ED3B63FULL, + (u64bit) 0xB80959295B215B40ULL, (u64bit) 0xF99CDAEF3B8C8572ULL, (u64bit) 0x018C0614F8FCB95DULL, + (u64bit) 0x1B14ACCD1A3ACDF3ULL, (u64bit) 0x84D471F200BB732DULL, (u64bit) 0xC1A3110E95E8DA16ULL, + (u64bit) 0x430A7220BF1A82B8ULL, (u64bit) 0xB77E090D39DF210EULL, (u64bit) 0x5EF4BD9F3CD05E9DULL, + (u64bit) 0x9D4FF6DA7E57A444ULL, (u64bit) 0xDA1D60E183D4A5F8ULL, (u64bit) 0xB287C38417998E47ULL, + (u64bit) 0xFE3EDC121BB31886ULL, (u64bit) 0xC7FE3CCC980CCBEFULL, (u64bit) 0xE46FB590189BFD03ULL, + (u64bit) 0x3732FD469A4C57DCULL, (u64bit) 0x7EF700A07CF1AD65ULL, (u64bit) 0x59C64468A31D8859ULL, + (u64bit) 0x762FB0B4D45B61F6ULL, (u64bit) 0x155BAED099047718ULL, (u64bit) 0x68755E4C3D50BAA6ULL, + (u64bit) 0xE9214E7F22D8B4DFULL, (u64bit) 0x2ADDBF532EAC95F4ULL, (u64bit) 0x32AE3909B4BD0109ULL, + (u64bit) 0x834DF537B08E3450ULL, (u64bit) 0xFA209DA84220728DULL, (u64bit) 0x9E691D9B9EFE23F7ULL, + (u64bit) 0x0446D288C4AE8D7FULL, (u64bit) 0x7B4CC524E169785BULL, (u64bit) 0x21D87F0135CA1385ULL, + (u64bit) 0xCEBB400F137B8AA5ULL, (u64bit) 0x272E2B66580796BEULL, (u64bit) 0x3612264125C2B0DEULL, + (u64bit) 0x057702BDAD1EFBB2ULL, (u64bit) 0xD4BABB8EACF84BE9ULL, (u64bit) 0x91583139641BC67BULL, + (u64bit) 0x8BDC2DE08036E024ULL, (u64bit) 0x603C8156F49F68EDULL, (u64bit) 0xF7D236F7DBEF5111ULL, + (u64bit) 0x9727C4598AD21E80ULL, (u64bit) 0xA08A0896670A5FD7ULL, (u64bit) 0xCB4A8F4309EBA9CBULL, + (u64bit) 0x81AF564B0F7036A1ULL, (u64bit) 0xC0B99AA778199ABDULL, (u64bit) 0x959F1EC83FC8E952ULL, + (u64bit) 0x8C505077794A81B9ULL, (u64bit) 0x3ACAAF8F056338F0ULL, (u64bit) 0x07B43F50627A6778ULL, + (u64bit) 0x4A44AB49F5ECCC77ULL, (u64bit) 0x3BC3D6E4B679EE98ULL, (u64bit) 0x9CC0D4D1CF14108CULL, + (u64bit) 0x4406C00B206BC8A0ULL, (u64bit) 0x82A18854C8D72D89ULL, (u64bit) 0x67E366B35C3C432CULL, + (u64bit) 0xB923DD61102B37F2ULL, (u64bit) 0x56AB2779D884271DULL, (u64bit) 0xBE83E1B0FF1525AFULL, + (u64bit) 0xFB7C65D4217E49A9ULL, (u64bit) 0x6BDBE0E76D48E7D4ULL, (u64bit) 0x08DF828745D9179EULL, + (u64bit) 0x22EA6A9ADD53BD34ULL, (u64bit) 0xE36E141C5622200AULL, (u64bit) 0x7F805D1B8CB750EEULL, + (u64bit) 0xAFE5C7A59F58E837ULL, (u64bit) 0xE27F996A4FB1C23CULL, (u64bit) 0xD3867DFB0775F0D0ULL, + (u64bit) 0xD0E673DE6E88891AULL, (u64bit) 0x123AEB9EAFB86C25ULL, (u64bit) 0x30F1D5D5C145B895ULL, + (u64bit) 0xBB434A2DEE7269E7ULL, (u64bit) 0x78CB67ECF931FA38ULL, (u64bit) 0xF33B0372323BBF9CULL, + (u64bit) 0x52D66336FB279C74ULL, (u64bit) 0x505F33AC0AFB4EAAULL, (u64bit) 0xE8A5CD99A2CCE187ULL, + (u64bit) 0x534974801E2D30BBULL, (u64bit) 0x8D2D5711D5876D90ULL, (u64bit) 0x1F1A412891BC038EULL, + (u64bit) 0xD6E2E71D82E56648ULL, (u64bit) 0x74036C3A497732B7ULL, (u64bit) 0x89B67ED96361F5ABULL, + (u64bit) 0xFFED95D8F1EA02A2ULL, (u64bit) 0xE72B3BD61464D43DULL, (u64bit) 0xA6300F170BDC4820ULL, + (u64bit) 0xEBC18760ED78A77AULL }; + +const u64bit Tiger::SBOX2[256] = { + (u64bit) 0xE6A6BE5A05A12138ULL, (u64bit) 0xB5A122A5B4F87C98ULL, (u64bit) 0x563C6089140B6990ULL, + (u64bit) 0x4C46CB2E391F5DD5ULL, (u64bit) 0xD932ADDBC9B79434ULL, (u64bit) 0x08EA70E42015AFF5ULL, + (u64bit) 0xD765A6673E478CF1ULL, (u64bit) 0xC4FB757EAB278D99ULL, (u64bit) 0xDF11C6862D6E0692ULL, + (u64bit) 0xDDEB84F10D7F3B16ULL, (u64bit) 0x6F2EF604A665EA04ULL, (u64bit) 0x4A8E0F0FF0E0DFB3ULL, + (u64bit) 0xA5EDEEF83DBCBA51ULL, (u64bit) 0xFC4F0A2A0EA4371EULL, (u64bit) 0xE83E1DA85CB38429ULL, + (u64bit) 0xDC8FF882BA1B1CE2ULL, (u64bit) 0xCD45505E8353E80DULL, (u64bit) 0x18D19A00D4DB0717ULL, + (u64bit) 0x34A0CFEDA5F38101ULL, (u64bit) 0x0BE77E518887CAF2ULL, (u64bit) 0x1E341438B3C45136ULL, + (u64bit) 0xE05797F49089CCF9ULL, (u64bit) 0xFFD23F9DF2591D14ULL, (u64bit) 0x543DDA228595C5CDULL, + (u64bit) 0x661F81FD99052A33ULL, (u64bit) 0x8736E641DB0F7B76ULL, (u64bit) 0x15227725418E5307ULL, + (u64bit) 0xE25F7F46162EB2FAULL, (u64bit) 0x48A8B2126C13D9FEULL, (u64bit) 0xAFDC541792E76EEAULL, + (u64bit) 0x03D912BFC6D1898FULL, (u64bit) 0x31B1AAFA1B83F51BULL, (u64bit) 0xF1AC2796E42AB7D9ULL, + (u64bit) 0x40A3A7D7FCD2EBACULL, (u64bit) 0x1056136D0AFBBCC5ULL, (u64bit) 0x7889E1DD9A6D0C85ULL, + (u64bit) 0xD33525782A7974AAULL, (u64bit) 0xA7E25D09078AC09BULL, (u64bit) 0xBD4138B3EAC6EDD0ULL, + (u64bit) 0x920ABFBE71EB9E70ULL, (u64bit) 0xA2A5D0F54FC2625CULL, (u64bit) 0xC054E36B0B1290A3ULL, + (u64bit) 0xF6DD59FF62FE932BULL, (u64bit) 0x3537354511A8AC7DULL, (u64bit) 0xCA845E9172FADCD4ULL, + (u64bit) 0x84F82B60329D20DCULL, (u64bit) 0x79C62CE1CD672F18ULL, (u64bit) 0x8B09A2ADD124642CULL, + (u64bit) 0xD0C1E96A19D9E726ULL, (u64bit) 0x5A786A9B4BA9500CULL, (u64bit) 0x0E020336634C43F3ULL, + (u64bit) 0xC17B474AEB66D822ULL, (u64bit) 0x6A731AE3EC9BAAC2ULL, (u64bit) 0x8226667AE0840258ULL, + (u64bit) 0x67D4567691CAECA5ULL, (u64bit) 0x1D94155C4875ADB5ULL, (u64bit) 0x6D00FD985B813FDFULL, + (u64bit) 0x51286EFCB774CD06ULL, (u64bit) 0x5E8834471FA744AFULL, (u64bit) 0xF72CA0AEE761AE2EULL, + (u64bit) 0xBE40E4CDAEE8E09AULL, (u64bit) 0xE9970BBB5118F665ULL, (u64bit) 0x726E4BEB33DF1964ULL, + (u64bit) 0x703B000729199762ULL, (u64bit) 0x4631D816F5EF30A7ULL, (u64bit) 0xB880B5B51504A6BEULL, + (u64bit) 0x641793C37ED84B6CULL, (u64bit) 0x7B21ED77F6E97D96ULL, (u64bit) 0x776306312EF96B73ULL, + (u64bit) 0xAE528948E86FF3F4ULL, (u64bit) 0x53DBD7F286A3F8F8ULL, (u64bit) 0x16CADCE74CFC1063ULL, + (u64bit) 0x005C19BDFA52C6DDULL, (u64bit) 0x68868F5D64D46AD3ULL, (u64bit) 0x3A9D512CCF1E186AULL, + (u64bit) 0x367E62C2385660AEULL, (u64bit) 0xE359E7EA77DCB1D7ULL, (u64bit) 0x526C0773749ABE6EULL, + (u64bit) 0x735AE5F9D09F734BULL, (u64bit) 0x493FC7CC8A558BA8ULL, (u64bit) 0xB0B9C1533041AB45ULL, + (u64bit) 0x321958BA470A59BDULL, (u64bit) 0x852DB00B5F46C393ULL, (u64bit) 0x91209B2BD336B0E5ULL, + (u64bit) 0x6E604F7D659EF19FULL, (u64bit) 0xB99A8AE2782CCB24ULL, (u64bit) 0xCCF52AB6C814C4C7ULL, + (u64bit) 0x4727D9AFBE11727BULL, (u64bit) 0x7E950D0C0121B34DULL, (u64bit) 0x756F435670AD471FULL, + (u64bit) 0xF5ADD442615A6849ULL, (u64bit) 0x4E87E09980B9957AULL, (u64bit) 0x2ACFA1DF50AEE355ULL, + (u64bit) 0xD898263AFD2FD556ULL, (u64bit) 0xC8F4924DD80C8FD6ULL, (u64bit) 0xCF99CA3D754A173AULL, + (u64bit) 0xFE477BACAF91BF3CULL, (u64bit) 0xED5371F6D690C12DULL, (u64bit) 0x831A5C285E687094ULL, + (u64bit) 0xC5D3C90A3708A0A4ULL, (u64bit) 0x0F7F903717D06580ULL, (u64bit) 0x19F9BB13B8FDF27FULL, + (u64bit) 0xB1BD6F1B4D502843ULL, (u64bit) 0x1C761BA38FFF4012ULL, (u64bit) 0x0D1530C4E2E21F3BULL, + (u64bit) 0x8943CE69A7372C8AULL, (u64bit) 0xE5184E11FEB5CE66ULL, (u64bit) 0x618BDB80BD736621ULL, + (u64bit) 0x7D29BAD68B574D0BULL, (u64bit) 0x81BB613E25E6FE5BULL, (u64bit) 0x071C9C10BC07913FULL, + (u64bit) 0xC7BEEB7909AC2D97ULL, (u64bit) 0xC3E58D353BC5D757ULL, (u64bit) 0xEB017892F38F61E8ULL, + (u64bit) 0xD4EFFB9C9B1CC21AULL, (u64bit) 0x99727D26F494F7ABULL, (u64bit) 0xA3E063A2956B3E03ULL, + (u64bit) 0x9D4A8B9A4AA09C30ULL, (u64bit) 0x3F6AB7D500090FB4ULL, (u64bit) 0x9CC0F2A057268AC0ULL, + (u64bit) 0x3DEE9D2DEDBF42D1ULL, (u64bit) 0x330F49C87960A972ULL, (u64bit) 0xC6B2720287421B41ULL, + (u64bit) 0x0AC59EC07C00369CULL, (u64bit) 0xEF4EAC49CB353425ULL, (u64bit) 0xF450244EEF0129D8ULL, + (u64bit) 0x8ACC46E5CAF4DEB6ULL, (u64bit) 0x2FFEAB63989263F7ULL, (u64bit) 0x8F7CB9FE5D7A4578ULL, + (u64bit) 0x5BD8F7644E634635ULL, (u64bit) 0x427A7315BF2DC900ULL, (u64bit) 0x17D0C4AA2125261CULL, + (u64bit) 0x3992486C93518E50ULL, (u64bit) 0xB4CBFEE0A2D7D4C3ULL, (u64bit) 0x7C75D6202C5DDD8DULL, + (u64bit) 0xDBC295D8E35B6C61ULL, (u64bit) 0x60B369D302032B19ULL, (u64bit) 0xCE42685FDCE44132ULL, + (u64bit) 0x06F3DDB9DDF65610ULL, (u64bit) 0x8EA4D21DB5E148F0ULL, (u64bit) 0x20B0FCE62FCD496FULL, + (u64bit) 0x2C1B912358B0EE31ULL, (u64bit) 0xB28317B818F5A308ULL, (u64bit) 0xA89C1E189CA6D2CFULL, + (u64bit) 0x0C6B18576AAADBC8ULL, (u64bit) 0xB65DEAA91299FAE3ULL, (u64bit) 0xFB2B794B7F1027E7ULL, + (u64bit) 0x04E4317F443B5BEBULL, (u64bit) 0x4B852D325939D0A6ULL, (u64bit) 0xD5AE6BEEFB207FFCULL, + (u64bit) 0x309682B281C7D374ULL, (u64bit) 0xBAE309A194C3B475ULL, (u64bit) 0x8CC3F97B13B49F05ULL, + (u64bit) 0x98A9422FF8293967ULL, (u64bit) 0x244B16B01076FF7CULL, (u64bit) 0xF8BF571C663D67EEULL, + (u64bit) 0x1F0D6758EEE30DA1ULL, (u64bit) 0xC9B611D97ADEB9B7ULL, (u64bit) 0xB7AFD5887B6C57A2ULL, + (u64bit) 0x6290AE846B984FE1ULL, (u64bit) 0x94DF4CDEACC1A5FDULL, (u64bit) 0x058A5BD1C5483AFFULL, + (u64bit) 0x63166CC142BA3C37ULL, (u64bit) 0x8DB8526EB2F76F40ULL, (u64bit) 0xE10880036F0D6D4EULL, + (u64bit) 0x9E0523C9971D311DULL, (u64bit) 0x45EC2824CC7CD691ULL, (u64bit) 0x575B8359E62382C9ULL, + (u64bit) 0xFA9E400DC4889995ULL, (u64bit) 0xD1823ECB45721568ULL, (u64bit) 0xDAFD983B8206082FULL, + (u64bit) 0xAA7D29082386A8CBULL, (u64bit) 0x269FCD4403B87588ULL, (u64bit) 0x1B91F5F728BDD1E0ULL, + (u64bit) 0xE4669F39040201F6ULL, (u64bit) 0x7A1D7C218CF04ADEULL, (u64bit) 0x65623C29D79CE5CEULL, + (u64bit) 0x2368449096C00BB1ULL, (u64bit) 0xAB9BF1879DA503BAULL, (u64bit) 0xBC23ECB1A458058EULL, + (u64bit) 0x9A58DF01BB401ECCULL, (u64bit) 0xA070E868A85F143DULL, (u64bit) 0x4FF188307DF2239EULL, + (u64bit) 0x14D565B41A641183ULL, (u64bit) 0xEE13337452701602ULL, (u64bit) 0x950E3DCF3F285E09ULL, + (u64bit) 0x59930254B9C80953ULL, (u64bit) 0x3BF299408930DA6DULL, (u64bit) 0xA955943F53691387ULL, + (u64bit) 0xA15EDECAA9CB8784ULL, (u64bit) 0x29142127352BE9A0ULL, (u64bit) 0x76F0371FFF4E7AFBULL, + (u64bit) 0x0239F450274F2228ULL, (u64bit) 0xBB073AF01D5E868BULL, (u64bit) 0xBFC80571C10E96C1ULL, + (u64bit) 0xD267088568222E23ULL, (u64bit) 0x9671A3D48E80B5B0ULL, (u64bit) 0x55B5D38AE193BB81ULL, + (u64bit) 0x693AE2D0A18B04B8ULL, (u64bit) 0x5C48B4ECADD5335FULL, (u64bit) 0xFD743B194916A1CAULL, + (u64bit) 0x2577018134BE98C4ULL, (u64bit) 0xE77987E83C54A4ADULL, (u64bit) 0x28E11014DA33E1B9ULL, + (u64bit) 0x270CC59E226AA213ULL, (u64bit) 0x71495F756D1A5F60ULL, (u64bit) 0x9BE853FB60AFEF77ULL, + (u64bit) 0xADC786A7F7443DBFULL, (u64bit) 0x0904456173B29A82ULL, (u64bit) 0x58BC7A66C232BD5EULL, + (u64bit) 0xF306558C673AC8B2ULL, (u64bit) 0x41F639C6B6C9772AULL, (u64bit) 0x216DEFE99FDA35DAULL, + (u64bit) 0x11640CC71C7BE615ULL, (u64bit) 0x93C43694565C5527ULL, (u64bit) 0xEA038E6246777839ULL, + (u64bit) 0xF9ABF3CE5A3E2469ULL, (u64bit) 0x741E768D0FD312D2ULL, (u64bit) 0x0144B883CED652C6ULL, + (u64bit) 0xC20B5A5BA33F8552ULL, (u64bit) 0x1AE69633C3435A9DULL, (u64bit) 0x97A28CA4088CFDECULL, + (u64bit) 0x8824A43C1E96F420ULL, (u64bit) 0x37612FA66EEEA746ULL, (u64bit) 0x6B4CB165F9CF0E5AULL, + (u64bit) 0x43AA1C06A0ABFB4AULL, (u64bit) 0x7F4DC26FF162796BULL, (u64bit) 0x6CBACC8E54ED9B0FULL, + (u64bit) 0xA6B7FFEFD2BB253EULL, (u64bit) 0x2E25BC95B0A29D4FULL, (u64bit) 0x86D6A58BDEF1388CULL, + (u64bit) 0xDED74AC576B6F054ULL, (u64bit) 0x8030BDBC2B45805DULL, (u64bit) 0x3C81AF70E94D9289ULL, + (u64bit) 0x3EFF6DDA9E3100DBULL, (u64bit) 0xB38DC39FDFCC8847ULL, (u64bit) 0x123885528D17B87EULL, + (u64bit) 0xF2DA0ED240B1B642ULL, (u64bit) 0x44CEFADCD54BF9A9ULL, (u64bit) 0x1312200E433C7EE6ULL, + (u64bit) 0x9FFCC84F3A78C748ULL, (u64bit) 0xF0CD1F72248576BBULL, (u64bit) 0xEC6974053638CFE4ULL, + (u64bit) 0x2BA7B67C0CEC4E4CULL, (u64bit) 0xAC2F4DF3E5CE32EDULL, (u64bit) 0xCB33D14326EA4C11ULL, + (u64bit) 0xA4E9044CC77E58BCULL, (u64bit) 0x5F513293D934FCEFULL, (u64bit) 0x5DC9645506E55444ULL, + (u64bit) 0x50DE418F317DE40AULL, (u64bit) 0x388CB31A69DDE259ULL, (u64bit) 0x2DB4A83455820A86ULL, + (u64bit) 0x9010A91E84711AE9ULL, (u64bit) 0x4DF7F0B7B1498371ULL, (u64bit) 0xD62A2EABC0977179ULL, + (u64bit) 0x22FAC097AA8D5C0EULL }; + +const u64bit Tiger::SBOX3[256] = { + (u64bit) 0xF49FCC2FF1DAF39BULL, (u64bit) 0x487FD5C66FF29281ULL, (u64bit) 0xE8A30667FCDCA83FULL, + (u64bit) 0x2C9B4BE3D2FCCE63ULL, (u64bit) 0xDA3FF74B93FBBBC2ULL, (u64bit) 0x2FA165D2FE70BA66ULL, + (u64bit) 0xA103E279970E93D4ULL, (u64bit) 0xBECDEC77B0E45E71ULL, (u64bit) 0xCFB41E723985E497ULL, + (u64bit) 0xB70AAA025EF75017ULL, (u64bit) 0xD42309F03840B8E0ULL, (u64bit) 0x8EFC1AD035898579ULL, + (u64bit) 0x96C6920BE2B2ABC5ULL, (u64bit) 0x66AF4163375A9172ULL, (u64bit) 0x2174ABDCCA7127FBULL, + (u64bit) 0xB33CCEA64A72FF41ULL, (u64bit) 0xF04A4933083066A5ULL, (u64bit) 0x8D970ACDD7289AF5ULL, + (u64bit) 0x8F96E8E031C8C25EULL, (u64bit) 0xF3FEC02276875D47ULL, (u64bit) 0xEC7BF310056190DDULL, + (u64bit) 0xF5ADB0AEBB0F1491ULL, (u64bit) 0x9B50F8850FD58892ULL, (u64bit) 0x4975488358B74DE8ULL, + (u64bit) 0xA3354FF691531C61ULL, (u64bit) 0x0702BBE481D2C6EEULL, (u64bit) 0x89FB24057DEDED98ULL, + (u64bit) 0xAC3075138596E902ULL, (u64bit) 0x1D2D3580172772EDULL, (u64bit) 0xEB738FC28E6BC30DULL, + (u64bit) 0x5854EF8F63044326ULL, (u64bit) 0x9E5C52325ADD3BBEULL, (u64bit) 0x90AA53CF325C4623ULL, + (u64bit) 0xC1D24D51349DD067ULL, (u64bit) 0x2051CFEEA69EA624ULL, (u64bit) 0x13220F0A862E7E4FULL, + (u64bit) 0xCE39399404E04864ULL, (u64bit) 0xD9C42CA47086FCB7ULL, (u64bit) 0x685AD2238A03E7CCULL, + (u64bit) 0x066484B2AB2FF1DBULL, (u64bit) 0xFE9D5D70EFBF79ECULL, (u64bit) 0x5B13B9DD9C481854ULL, + (u64bit) 0x15F0D475ED1509ADULL, (u64bit) 0x0BEBCD060EC79851ULL, (u64bit) 0xD58C6791183AB7F8ULL, + (u64bit) 0xD1187C5052F3EEE4ULL, (u64bit) 0xC95D1192E54E82FFULL, (u64bit) 0x86EEA14CB9AC6CA2ULL, + (u64bit) 0x3485BEB153677D5DULL, (u64bit) 0xDD191D781F8C492AULL, (u64bit) 0xF60866BAA784EBF9ULL, + (u64bit) 0x518F643BA2D08C74ULL, (u64bit) 0x8852E956E1087C22ULL, (u64bit) 0xA768CB8DC410AE8DULL, + (u64bit) 0x38047726BFEC8E1AULL, (u64bit) 0xA67738B4CD3B45AAULL, (u64bit) 0xAD16691CEC0DDE19ULL, + (u64bit) 0xC6D4319380462E07ULL, (u64bit) 0xC5A5876D0BA61938ULL, (u64bit) 0x16B9FA1FA58FD840ULL, + (u64bit) 0x188AB1173CA74F18ULL, (u64bit) 0xABDA2F98C99C021FULL, (u64bit) 0x3E0580AB134AE816ULL, + (u64bit) 0x5F3B05B773645ABBULL, (u64bit) 0x2501A2BE5575F2F6ULL, (u64bit) 0x1B2F74004E7E8BA9ULL, + (u64bit) 0x1CD7580371E8D953ULL, (u64bit) 0x7F6ED89562764E30ULL, (u64bit) 0xB15926FF596F003DULL, + (u64bit) 0x9F65293DA8C5D6B9ULL, (u64bit) 0x6ECEF04DD690F84CULL, (u64bit) 0x4782275FFF33AF88ULL, + (u64bit) 0xE41433083F820801ULL, (u64bit) 0xFD0DFE409A1AF9B5ULL, (u64bit) 0x4325A3342CDB396BULL, + (u64bit) 0x8AE77E62B301B252ULL, (u64bit) 0xC36F9E9F6655615AULL, (u64bit) 0x85455A2D92D32C09ULL, + (u64bit) 0xF2C7DEA949477485ULL, (u64bit) 0x63CFB4C133A39EBAULL, (u64bit) 0x83B040CC6EBC5462ULL, + (u64bit) 0x3B9454C8FDB326B0ULL, (u64bit) 0x56F56A9E87FFD78CULL, (u64bit) 0x2DC2940D99F42BC6ULL, + (u64bit) 0x98F7DF096B096E2DULL, (u64bit) 0x19A6E01E3AD852BFULL, (u64bit) 0x42A99CCBDBD4B40BULL, + (u64bit) 0xA59998AF45E9C559ULL, (u64bit) 0x366295E807D93186ULL, (u64bit) 0x6B48181BFAA1F773ULL, + (u64bit) 0x1FEC57E2157A0A1DULL, (u64bit) 0x4667446AF6201AD5ULL, (u64bit) 0xE615EBCACFB0F075ULL, + (u64bit) 0xB8F31F4F68290778ULL, (u64bit) 0x22713ED6CE22D11EULL, (u64bit) 0x3057C1A72EC3C93BULL, + (u64bit) 0xCB46ACC37C3F1F2FULL, (u64bit) 0xDBB893FD02AAF50EULL, (u64bit) 0x331FD92E600B9FCFULL, + (u64bit) 0xA498F96148EA3AD6ULL, (u64bit) 0xA8D8426E8B6A83EAULL, (u64bit) 0xA089B274B7735CDCULL, + (u64bit) 0x87F6B3731E524A11ULL, (u64bit) 0x118808E5CBC96749ULL, (u64bit) 0x9906E4C7B19BD394ULL, + (u64bit) 0xAFED7F7E9B24A20CULL, (u64bit) 0x6509EADEEB3644A7ULL, (u64bit) 0x6C1EF1D3E8EF0EDEULL, + (u64bit) 0xB9C97D43E9798FB4ULL, (u64bit) 0xA2F2D784740C28A3ULL, (u64bit) 0x7B8496476197566FULL, + (u64bit) 0x7A5BE3E6B65F069DULL, (u64bit) 0xF96330ED78BE6F10ULL, (u64bit) 0xEEE60DE77A076A15ULL, + (u64bit) 0x2B4BEE4AA08B9BD0ULL, (u64bit) 0x6A56A63EC7B8894EULL, (u64bit) 0x02121359BA34FEF4ULL, + (u64bit) 0x4CBF99F8283703FCULL, (u64bit) 0x398071350CAF30C8ULL, (u64bit) 0xD0A77A89F017687AULL, + (u64bit) 0xF1C1A9EB9E423569ULL, (u64bit) 0x8C7976282DEE8199ULL, (u64bit) 0x5D1737A5DD1F7ABDULL, + (u64bit) 0x4F53433C09A9FA80ULL, (u64bit) 0xFA8B0C53DF7CA1D9ULL, (u64bit) 0x3FD9DCBC886CCB77ULL, + (u64bit) 0xC040917CA91B4720ULL, (u64bit) 0x7DD00142F9D1DCDFULL, (u64bit) 0x8476FC1D4F387B58ULL, + (u64bit) 0x23F8E7C5F3316503ULL, (u64bit) 0x032A2244E7E37339ULL, (u64bit) 0x5C87A5D750F5A74BULL, + (u64bit) 0x082B4CC43698992EULL, (u64bit) 0xDF917BECB858F63CULL, (u64bit) 0x3270B8FC5BF86DDAULL, + (u64bit) 0x10AE72BB29B5DD76ULL, (u64bit) 0x576AC94E7700362BULL, (u64bit) 0x1AD112DAC61EFB8FULL, + (u64bit) 0x691BC30EC5FAA427ULL, (u64bit) 0xFF246311CC327143ULL, (u64bit) 0x3142368E30E53206ULL, + (u64bit) 0x71380E31E02CA396ULL, (u64bit) 0x958D5C960AAD76F1ULL, (u64bit) 0xF8D6F430C16DA536ULL, + (u64bit) 0xC8FFD13F1BE7E1D2ULL, (u64bit) 0x7578AE66004DDBE1ULL, (u64bit) 0x05833F01067BE646ULL, + (u64bit) 0xBB34B5AD3BFE586DULL, (u64bit) 0x095F34C9A12B97F0ULL, (u64bit) 0x247AB64525D60CA8ULL, + (u64bit) 0xDCDBC6F3017477D1ULL, (u64bit) 0x4A2E14D4DECAD24DULL, (u64bit) 0xBDB5E6D9BE0A1EEBULL, + (u64bit) 0x2A7E70F7794301ABULL, (u64bit) 0xDEF42D8A270540FDULL, (u64bit) 0x01078EC0A34C22C1ULL, + (u64bit) 0xE5DE511AF4C16387ULL, (u64bit) 0x7EBB3A52BD9A330AULL, (u64bit) 0x77697857AA7D6435ULL, + (u64bit) 0x004E831603AE4C32ULL, (u64bit) 0xE7A21020AD78E312ULL, (u64bit) 0x9D41A70C6AB420F2ULL, + (u64bit) 0x28E06C18EA1141E6ULL, (u64bit) 0xD2B28CBD984F6B28ULL, (u64bit) 0x26B75F6C446E9D83ULL, + (u64bit) 0xBA47568C4D418D7FULL, (u64bit) 0xD80BADBFE6183D8EULL, (u64bit) 0x0E206D7F5F166044ULL, + (u64bit) 0xE258A43911CBCA3EULL, (u64bit) 0x723A1746B21DC0BCULL, (u64bit) 0xC7CAA854F5D7CDD3ULL, + (u64bit) 0x7CAC32883D261D9CULL, (u64bit) 0x7690C26423BA942CULL, (u64bit) 0x17E55524478042B8ULL, + (u64bit) 0xE0BE477656A2389FULL, (u64bit) 0x4D289B5E67AB2DA0ULL, (u64bit) 0x44862B9C8FBBFD31ULL, + (u64bit) 0xB47CC8049D141365ULL, (u64bit) 0x822C1B362B91C793ULL, (u64bit) 0x4EB14655FB13DFD8ULL, + (u64bit) 0x1ECBBA0714E2A97BULL, (u64bit) 0x6143459D5CDE5F14ULL, (u64bit) 0x53A8FBF1D5F0AC89ULL, + (u64bit) 0x97EA04D81C5E5B00ULL, (u64bit) 0x622181A8D4FDB3F3ULL, (u64bit) 0xE9BCD341572A1208ULL, + (u64bit) 0x1411258643CCE58AULL, (u64bit) 0x9144C5FEA4C6E0A4ULL, (u64bit) 0x0D33D06565CF620FULL, + (u64bit) 0x54A48D489F219CA1ULL, (u64bit) 0xC43E5EAC6D63C821ULL, (u64bit) 0xA9728B3A72770DAFULL, + (u64bit) 0xD7934E7B20DF87EFULL, (u64bit) 0xE35503B61A3E86E5ULL, (u64bit) 0xCAE321FBC819D504ULL, + (u64bit) 0x129A50B3AC60BFA6ULL, (u64bit) 0xCD5E68EA7E9FB6C3ULL, (u64bit) 0xB01C90199483B1C7ULL, + (u64bit) 0x3DE93CD5C295376CULL, (u64bit) 0xAED52EDF2AB9AD13ULL, (u64bit) 0x2E60F512C0A07884ULL, + (u64bit) 0xBC3D86A3E36210C9ULL, (u64bit) 0x35269D9B163951CEULL, (u64bit) 0x0C7D6E2AD0CDB5FAULL, + (u64bit) 0x59E86297D87F5733ULL, (u64bit) 0x298EF221898DB0E7ULL, (u64bit) 0x55000029D1A5AA7EULL, + (u64bit) 0x8BC08AE1B5061B45ULL, (u64bit) 0xC2C31C2B6C92703AULL, (u64bit) 0x94CC596BAF25EF42ULL, + (u64bit) 0x0A1D73DB22540456ULL, (u64bit) 0x04B6A0F9D9C4179AULL, (u64bit) 0xEFFDAFA2AE3D3C60ULL, + (u64bit) 0xF7C8075BB49496C4ULL, (u64bit) 0x9CC5C7141D1CD4E3ULL, (u64bit) 0x78BD1638218E5534ULL, + (u64bit) 0xB2F11568F850246AULL, (u64bit) 0xEDFABCFA9502BC29ULL, (u64bit) 0x796CE5F2DA23051BULL, + (u64bit) 0xAAE128B0DC93537CULL, (u64bit) 0x3A493DA0EE4B29AEULL, (u64bit) 0xB5DF6B2C416895D7ULL, + (u64bit) 0xFCABBD25122D7F37ULL, (u64bit) 0x70810B58105DC4B1ULL, (u64bit) 0xE10FDD37F7882A90ULL, + (u64bit) 0x524DCAB5518A3F5CULL, (u64bit) 0x3C9E85878451255BULL, (u64bit) 0x4029828119BD34E2ULL, + (u64bit) 0x74A05B6F5D3CECCBULL, (u64bit) 0xB610021542E13ECAULL, (u64bit) 0x0FF979D12F59E2ACULL, + (u64bit) 0x6037DA27E4F9CC50ULL, (u64bit) 0x5E92975A0DF1847DULL, (u64bit) 0xD66DE190D3E623FEULL, + (u64bit) 0x5032D6B87B568048ULL, (u64bit) 0x9A36B7CE8235216EULL, (u64bit) 0x80272A7A24F64B4AULL, + (u64bit) 0x93EFED8B8C6916F7ULL, (u64bit) 0x37DDBFF44CCE1555ULL, (u64bit) 0x4B95DB5D4B99BD25ULL, + (u64bit) 0x92D3FDA169812FC0ULL, (u64bit) 0xFB1A4A9A90660BB6ULL, (u64bit) 0x730C196946A4B9B2ULL, + (u64bit) 0x81E289AA7F49DA68ULL, (u64bit) 0x64669A0F83B1A05FULL, (u64bit) 0x27B3FF7D9644F48BULL, + (u64bit) 0xCC6B615C8DB675B3ULL, (u64bit) 0x674F20B9BCEBBE95ULL, (u64bit) 0x6F31238275655982ULL, + (u64bit) 0x5AE488713E45CF05ULL, (u64bit) 0xBF619F9954C21157ULL, (u64bit) 0xEABAC46040A8EAE9ULL, + (u64bit) 0x454C6FE9F2C0C1CDULL, (u64bit) 0x419CF6496412691CULL, (u64bit) 0xD3DC3BEF265B0F70ULL, + (u64bit) 0x6D0E60F5C3578A9EULL }; + +const u64bit Tiger::SBOX4[256] = { + (u64bit) 0x5B0E608526323C55ULL, (u64bit) 0x1A46C1A9FA1B59F5ULL, (u64bit) 0xA9E245A17C4C8FFAULL, + (u64bit) 0x65CA5159DB2955D7ULL, (u64bit) 0x05DB0A76CE35AFC2ULL, (u64bit) 0x81EAC77EA9113D45ULL, + (u64bit) 0x528EF88AB6AC0A0DULL, (u64bit) 0xA09EA253597BE3FFULL, (u64bit) 0x430DDFB3AC48CD56ULL, + (u64bit) 0xC4B3A67AF45CE46FULL, (u64bit) 0x4ECECFD8FBE2D05EULL, (u64bit) 0x3EF56F10B39935F0ULL, + (u64bit) 0x0B22D6829CD619C6ULL, (u64bit) 0x17FD460A74DF2069ULL, (u64bit) 0x6CF8CC8E8510ED40ULL, + (u64bit) 0xD6C824BF3A6ECAA7ULL, (u64bit) 0x61243D581A817049ULL, (u64bit) 0x048BACB6BBC163A2ULL, + (u64bit) 0xD9A38AC27D44CC32ULL, (u64bit) 0x7FDDFF5BAAF410ABULL, (u64bit) 0xAD6D495AA804824BULL, + (u64bit) 0xE1A6A74F2D8C9F94ULL, (u64bit) 0xD4F7851235DEE8E3ULL, (u64bit) 0xFD4B7F886540D893ULL, + (u64bit) 0x247C20042AA4BFDAULL, (u64bit) 0x096EA1C517D1327CULL, (u64bit) 0xD56966B4361A6685ULL, + (u64bit) 0x277DA5C31221057DULL, (u64bit) 0x94D59893A43ACFF7ULL, (u64bit) 0x64F0C51CCDC02281ULL, + (u64bit) 0x3D33BCC4FF6189DBULL, (u64bit) 0xE005CB184CE66AF1ULL, (u64bit) 0xFF5CCD1D1DB99BEAULL, + (u64bit) 0xB0B854A7FE42980FULL, (u64bit) 0x7BD46A6A718D4B9FULL, (u64bit) 0xD10FA8CC22A5FD8CULL, + (u64bit) 0xD31484952BE4BD31ULL, (u64bit) 0xC7FA975FCB243847ULL, (u64bit) 0x4886ED1E5846C407ULL, + (u64bit) 0x28CDDB791EB70B04ULL, (u64bit) 0xC2B00BE2F573417FULL, (u64bit) 0x5C9590452180F877ULL, + (u64bit) 0x7A6BDDFFF370EB00ULL, (u64bit) 0xCE509E38D6D9D6A4ULL, (u64bit) 0xEBEB0F00647FA702ULL, + (u64bit) 0x1DCC06CF76606F06ULL, (u64bit) 0xE4D9F28BA286FF0AULL, (u64bit) 0xD85A305DC918C262ULL, + (u64bit) 0x475B1D8732225F54ULL, (u64bit) 0x2D4FB51668CCB5FEULL, (u64bit) 0xA679B9D9D72BBA20ULL, + (u64bit) 0x53841C0D912D43A5ULL, (u64bit) 0x3B7EAA48BF12A4E8ULL, (u64bit) 0x781E0E47F22F1DDFULL, + (u64bit) 0xEFF20CE60AB50973ULL, (u64bit) 0x20D261D19DFFB742ULL, (u64bit) 0x16A12B03062A2E39ULL, + (u64bit) 0x1960EB2239650495ULL, (u64bit) 0x251C16FED50EB8B8ULL, (u64bit) 0x9AC0C330F826016EULL, + (u64bit) 0xED152665953E7671ULL, (u64bit) 0x02D63194A6369570ULL, (u64bit) 0x5074F08394B1C987ULL, + (u64bit) 0x70BA598C90B25CE1ULL, (u64bit) 0x794A15810B9742F6ULL, (u64bit) 0x0D5925E9FCAF8C6CULL, + (u64bit) 0x3067716CD868744EULL, (u64bit) 0x910AB077E8D7731BULL, (u64bit) 0x6A61BBDB5AC42F61ULL, + (u64bit) 0x93513EFBF0851567ULL, (u64bit) 0xF494724B9E83E9D5ULL, (u64bit) 0xE887E1985C09648DULL, + (u64bit) 0x34B1D3C675370CFDULL, (u64bit) 0xDC35E433BC0D255DULL, (u64bit) 0xD0AAB84234131BE0ULL, + (u64bit) 0x08042A50B48B7EAFULL, (u64bit) 0x9997C4EE44A3AB35ULL, (u64bit) 0x829A7B49201799D0ULL, + (u64bit) 0x263B8307B7C54441ULL, (u64bit) 0x752F95F4FD6A6CA6ULL, (u64bit) 0x927217402C08C6E5ULL, + (u64bit) 0x2A8AB754A795D9EEULL, (u64bit) 0xA442F7552F72943DULL, (u64bit) 0x2C31334E19781208ULL, + (u64bit) 0x4FA98D7CEAEE6291ULL, (u64bit) 0x55C3862F665DB309ULL, (u64bit) 0xBD0610175D53B1F3ULL, + (u64bit) 0x46FE6CB840413F27ULL, (u64bit) 0x3FE03792DF0CFA59ULL, (u64bit) 0xCFE700372EB85E8FULL, + (u64bit) 0xA7BE29E7ADBCE118ULL, (u64bit) 0xE544EE5CDE8431DDULL, (u64bit) 0x8A781B1B41F1873EULL, + (u64bit) 0xA5C94C78A0D2F0E7ULL, (u64bit) 0x39412E2877B60728ULL, (u64bit) 0xA1265EF3AFC9A62CULL, + (u64bit) 0xBCC2770C6A2506C5ULL, (u64bit) 0x3AB66DD5DCE1CE12ULL, (u64bit) 0xE65499D04A675B37ULL, + (u64bit) 0x7D8F523481BFD216ULL, (u64bit) 0x0F6F64FCEC15F389ULL, (u64bit) 0x74EFBE618B5B13C8ULL, + (u64bit) 0xACDC82B714273E1DULL, (u64bit) 0xDD40BFE003199D17ULL, (u64bit) 0x37E99257E7E061F8ULL, + (u64bit) 0xFA52626904775AAAULL, (u64bit) 0x8BBBF63A463D56F9ULL, (u64bit) 0xF0013F1543A26E64ULL, + (u64bit) 0xA8307E9F879EC898ULL, (u64bit) 0xCC4C27A4150177CCULL, (u64bit) 0x1B432F2CCA1D3348ULL, + (u64bit) 0xDE1D1F8F9F6FA013ULL, (u64bit) 0x606602A047A7DDD6ULL, (u64bit) 0xD237AB64CC1CB2C7ULL, + (u64bit) 0x9B938E7225FCD1D3ULL, (u64bit) 0xEC4E03708E0FF476ULL, (u64bit) 0xFEB2FBDA3D03C12DULL, + (u64bit) 0xAE0BCED2EE43889AULL, (u64bit) 0x22CB8923EBFB4F43ULL, (u64bit) 0x69360D013CF7396DULL, + (u64bit) 0x855E3602D2D4E022ULL, (u64bit) 0x073805BAD01F784CULL, (u64bit) 0x33E17A133852F546ULL, + (u64bit) 0xDF4874058AC7B638ULL, (u64bit) 0xBA92B29C678AA14AULL, (u64bit) 0x0CE89FC76CFAADCDULL, + (u64bit) 0x5F9D4E0908339E34ULL, (u64bit) 0xF1AFE9291F5923B9ULL, (u64bit) 0x6E3480F60F4A265FULL, + (u64bit) 0xEEBF3A2AB29B841CULL, (u64bit) 0xE21938A88F91B4ADULL, (u64bit) 0x57DFEFF845C6D3C3ULL, + (u64bit) 0x2F006B0BF62CAAF2ULL, (u64bit) 0x62F479EF6F75EE78ULL, (u64bit) 0x11A55AD41C8916A9ULL, + (u64bit) 0xF229D29084FED453ULL, (u64bit) 0x42F1C27B16B000E6ULL, (u64bit) 0x2B1F76749823C074ULL, + (u64bit) 0x4B76ECA3C2745360ULL, (u64bit) 0x8C98F463B91691BDULL, (u64bit) 0x14BCC93CF1ADE66AULL, + (u64bit) 0x8885213E6D458397ULL, (u64bit) 0x8E177DF0274D4711ULL, (u64bit) 0xB49B73B5503F2951ULL, + (u64bit) 0x10168168C3F96B6BULL, (u64bit) 0x0E3D963B63CAB0AEULL, (u64bit) 0x8DFC4B5655A1DB14ULL, + (u64bit) 0xF789F1356E14DE5CULL, (u64bit) 0x683E68AF4E51DAC1ULL, (u64bit) 0xC9A84F9D8D4B0FD9ULL, + (u64bit) 0x3691E03F52A0F9D1ULL, (u64bit) 0x5ED86E46E1878E80ULL, (u64bit) 0x3C711A0E99D07150ULL, + (u64bit) 0x5A0865B20C4E9310ULL, (u64bit) 0x56FBFC1FE4F0682EULL, (u64bit) 0xEA8D5DE3105EDF9BULL, + (u64bit) 0x71ABFDB12379187AULL, (u64bit) 0x2EB99DE1BEE77B9CULL, (u64bit) 0x21ECC0EA33CF4523ULL, + (u64bit) 0x59A4D7521805C7A1ULL, (u64bit) 0x3896F5EB56AE7C72ULL, (u64bit) 0xAA638F3DB18F75DCULL, + (u64bit) 0x9F39358DABE9808EULL, (u64bit) 0xB7DEFA91C00B72ACULL, (u64bit) 0x6B5541FD62492D92ULL, + (u64bit) 0x6DC6DEE8F92E4D5BULL, (u64bit) 0x353F57ABC4BEEA7EULL, (u64bit) 0x735769D6DA5690CEULL, + (u64bit) 0x0A234AA642391484ULL, (u64bit) 0xF6F9508028F80D9DULL, (u64bit) 0xB8E319A27AB3F215ULL, + (u64bit) 0x31AD9C1151341A4DULL, (u64bit) 0x773C22A57BEF5805ULL, (u64bit) 0x45C7561A07968633ULL, + (u64bit) 0xF913DA9E249DBE36ULL, (u64bit) 0xDA652D9B78A64C68ULL, (u64bit) 0x4C27A97F3BC334EFULL, + (u64bit) 0x76621220E66B17F4ULL, (u64bit) 0x967743899ACD7D0BULL, (u64bit) 0xF3EE5BCAE0ED6782ULL, + (u64bit) 0x409F753600C879FCULL, (u64bit) 0x06D09A39B5926DB6ULL, (u64bit) 0x6F83AEB0317AC588ULL, + (u64bit) 0x01E6CA4A86381F21ULL, (u64bit) 0x66FF3462D19F3025ULL, (u64bit) 0x72207C24DDFD3BFBULL, + (u64bit) 0x4AF6B6D3E2ECE2EBULL, (u64bit) 0x9C994DBEC7EA08DEULL, (u64bit) 0x49ACE597B09A8BC4ULL, + (u64bit) 0xB38C4766CF0797BAULL, (u64bit) 0x131B9373C57C2A75ULL, (u64bit) 0xB1822CCE61931E58ULL, + (u64bit) 0x9D7555B909BA1C0CULL, (u64bit) 0x127FAFDD937D11D2ULL, (u64bit) 0x29DA3BADC66D92E4ULL, + (u64bit) 0xA2C1D57154C2ECBCULL, (u64bit) 0x58C5134D82F6FE24ULL, (u64bit) 0x1C3AE3515B62274FULL, + (u64bit) 0xE907C82E01CB8126ULL, (u64bit) 0xF8ED091913E37FCBULL, (u64bit) 0x3249D8F9C80046C9ULL, + (u64bit) 0x80CF9BEDE388FB63ULL, (u64bit) 0x1881539A116CF19EULL, (u64bit) 0x5103F3F76BD52457ULL, + (u64bit) 0x15B7E6F5AE47F7A8ULL, (u64bit) 0xDBD7C6DED47E9CCFULL, (u64bit) 0x44E55C410228BB1AULL, + (u64bit) 0xB647D4255EDB4E99ULL, (u64bit) 0x5D11882BB8AAFC30ULL, (u64bit) 0xF5098BBB29D3212AULL, + (u64bit) 0x8FB5EA14E90296B3ULL, (u64bit) 0x677B942157DD025AULL, (u64bit) 0xFB58E7C0A390ACB5ULL, + (u64bit) 0x89D3674C83BD4A01ULL, (u64bit) 0x9E2DA4DF4BF3B93BULL, (u64bit) 0xFCC41E328CAB4829ULL, + (u64bit) 0x03F38C96BA582C52ULL, (u64bit) 0xCAD1BDBD7FD85DB2ULL, (u64bit) 0xBBB442C16082AE83ULL, + (u64bit) 0xB95FE86BA5DA9AB0ULL, (u64bit) 0xB22E04673771A93FULL, (u64bit) 0x845358C9493152D8ULL, + (u64bit) 0xBE2A488697B4541EULL, (u64bit) 0x95A2DC2DD38E6966ULL, (u64bit) 0xC02C11AC923C852BULL, + (u64bit) 0x2388B1990DF2A87BULL, (u64bit) 0x7C8008FA1B4F37BEULL, (u64bit) 0x1F70D0C84D54E503ULL, + (u64bit) 0x5490ADEC7ECE57D4ULL, (u64bit) 0x002B3C27D9063A3AULL, (u64bit) 0x7EAEA3848030A2BFULL, + (u64bit) 0xC602326DED2003C0ULL, (u64bit) 0x83A7287D69A94086ULL, (u64bit) 0xC57A5FCB30F57A8AULL, + (u64bit) 0xB56844E479EBE779ULL, (u64bit) 0xA373B40F05DCBCE9ULL, (u64bit) 0xD71A786E88570EE2ULL, + (u64bit) 0x879CBACDBDE8F6A0ULL, (u64bit) 0x976AD1BCC164A32FULL, (u64bit) 0xAB21E25E9666D78BULL, + (u64bit) 0x901063AAE5E5C33CULL, (u64bit) 0x9818B34448698D90ULL, (u64bit) 0xE36487AE3E1E8ABBULL, + (u64bit) 0xAFBDF931893BDCB4ULL, (u64bit) 0x6345A0DC5FBBD519ULL, (u64bit) 0x8628FE269B9465CAULL, + (u64bit) 0x1E5D01603F9C51ECULL, (u64bit) 0x4DE44006A15049B7ULL, (u64bit) 0xBF6C70E5F776CBB1ULL, + (u64bit) 0x411218F2EF552BEDULL, (u64bit) 0xCB0C0708705A36A3ULL, (u64bit) 0xE74D14754F986044ULL, + (u64bit) 0xCD56D9430EA8280EULL, (u64bit) 0xC12591D7535F5065ULL, (u64bit) 0xC83223F1720AEF96ULL, + (u64bit) 0xC3A0396F7363A51FULL }; + +} diff --git a/botan/src/hash/tiger/tiger.cpp b/botan/src/hash/tiger/tiger.cpp new file mode 100644 index 0000000..08af9c7 --- /dev/null +++ b/botan/src/hash/tiger/tiger.cpp @@ -0,0 +1,164 @@ +/* +* Tiger +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/tiger.h> +#include <botan/exceptn.h> +#include <botan/loadstor.h> +#include <botan/parsing.h> + +namespace Botan { + +/* +* Tiger Compression Function +*/ +void Tiger::compress_n(const byte input[], u32bit blocks) + { + u64bit A = digest[0], B = digest[1], C = digest[2]; + + for(u32bit i = 0; i != blocks; ++i) + { + for(u32bit j = 0; j != 8; ++j) + X[j] = load_le<u64bit>(input, j); + input += HASH_BLOCK_SIZE; + + 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; + } + + A = (digest[0] ^= A); + B = digest[1] = B - digest[1]; + C = (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] ^ (u64bit) 0xA5A5A5A5A5A5A5A5ULL; 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] ^ (u64bit) 0x0123456789ABCDEFULL; + } + +/* +* Clear memory of sensitive data +*/ +void Tiger::clear() throw() + { + MDx_HashFunction::clear(); + X.clear(); + digest[0] = (u64bit) 0x0123456789ABCDEFULL; + digest[1] = (u64bit) 0xFEDCBA9876543210ULL; + digest[2] = (u64bit) 0xF096A5B4C3B2E187ULL; + } + +/* +* 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/botan/src/hash/tiger/tiger.h b/botan/src/hash/tiger/tiger.h new file mode 100644 index 0000000..63184a9 --- /dev/null +++ b/botan/src/hash/tiger/tiger.h @@ -0,0 +1,44 @@ +/* +* Tiger +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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 compress_n(const byte[], u32bit block); + 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/botan/src/hash/whirlpool/info.txt b/botan/src/hash/whirlpool/info.txt new file mode 100644 index 0000000..be55b5c --- /dev/null +++ b/botan/src/hash/whirlpool/info.txt @@ -0,0 +1,15 @@ +realname "Whirlpool" + +define WHIRLPOOL + +load_on auto + +<add> +whrl_tab.cpp +whrlpool.cpp +whrlpool.h +</add> + +<requires> +mdx_hash +</requires> diff --git a/botan/src/hash/whirlpool/whrl_tab.cpp b/botan/src/hash/whirlpool/whrl_tab.cpp new file mode 100644 index 0000000..7ece927 --- /dev/null +++ b/botan/src/hash/whirlpool/whrl_tab.cpp @@ -0,0 +1,540 @@ +/* +* Diffusion Tables for Whirlpool +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/whrlpool.h> + +namespace Botan { + +const u64bit Whirlpool::C0[256] = { +(u64bit) 0x18186018C07830D8ULL, (u64bit) 0x23238C2305AF4626ULL, (u64bit) 0xC6C63FC67EF991B8ULL, (u64bit) 0xE8E887E8136FCDFBULL, +(u64bit) 0x878726874CA113CBULL, (u64bit) 0xB8B8DAB8A9626D11ULL, (u64bit) 0x0101040108050209ULL, (u64bit) 0x4F4F214F426E9E0DULL, +(u64bit) 0x3636D836ADEE6C9BULL, (u64bit) 0xA6A6A2A6590451FFULL, (u64bit) 0xD2D26FD2DEBDB90CULL, (u64bit) 0xF5F5F3F5FB06F70EULL, +(u64bit) 0x7979F979EF80F296ULL, (u64bit) 0x6F6FA16F5FCEDE30ULL, (u64bit) 0x91917E91FCEF3F6DULL, (u64bit) 0x52525552AA07A4F8ULL, +(u64bit) 0x60609D6027FDC047ULL, (u64bit) 0xBCBCCABC89766535ULL, (u64bit) 0x9B9B569BACCD2B37ULL, (u64bit) 0x8E8E028E048C018AULL, +(u64bit) 0xA3A3B6A371155BD2ULL, (u64bit) 0x0C0C300C603C186CULL, (u64bit) 0x7B7BF17BFF8AF684ULL, (u64bit) 0x3535D435B5E16A80ULL, +(u64bit) 0x1D1D741DE8693AF5ULL, (u64bit) 0xE0E0A7E05347DDB3ULL, (u64bit) 0xD7D77BD7F6ACB321ULL, (u64bit) 0xC2C22FC25EED999CULL, +(u64bit) 0x2E2EB82E6D965C43ULL, (u64bit) 0x4B4B314B627A9629ULL, (u64bit) 0xFEFEDFFEA321E15DULL, (u64bit) 0x575741578216AED5ULL, +(u64bit) 0x15155415A8412ABDULL, (u64bit) 0x7777C1779FB6EEE8ULL, (u64bit) 0x3737DC37A5EB6E92ULL, (u64bit) 0xE5E5B3E57B56D79EULL, +(u64bit) 0x9F9F469F8CD92313ULL, (u64bit) 0xF0F0E7F0D317FD23ULL, (u64bit) 0x4A4A354A6A7F9420ULL, (u64bit) 0xDADA4FDA9E95A944ULL, +(u64bit) 0x58587D58FA25B0A2ULL, (u64bit) 0xC9C903C906CA8FCFULL, (u64bit) 0x2929A429558D527CULL, (u64bit) 0x0A0A280A5022145AULL, +(u64bit) 0xB1B1FEB1E14F7F50ULL, (u64bit) 0xA0A0BAA0691A5DC9ULL, (u64bit) 0x6B6BB16B7FDAD614ULL, (u64bit) 0x85852E855CAB17D9ULL, +(u64bit) 0xBDBDCEBD8173673CULL, (u64bit) 0x5D5D695DD234BA8FULL, (u64bit) 0x1010401080502090ULL, (u64bit) 0xF4F4F7F4F303F507ULL, +(u64bit) 0xCBCB0BCB16C08BDDULL, (u64bit) 0x3E3EF83EEDC67CD3ULL, (u64bit) 0x0505140528110A2DULL, (u64bit) 0x676781671FE6CE78ULL, +(u64bit) 0xE4E4B7E47353D597ULL, (u64bit) 0x27279C2725BB4E02ULL, (u64bit) 0x4141194132588273ULL, (u64bit) 0x8B8B168B2C9D0BA7ULL, +(u64bit) 0xA7A7A6A7510153F6ULL, (u64bit) 0x7D7DE97DCF94FAB2ULL, (u64bit) 0x95956E95DCFB3749ULL, (u64bit) 0xD8D847D88E9FAD56ULL, +(u64bit) 0xFBFBCBFB8B30EB70ULL, (u64bit) 0xEEEE9FEE2371C1CDULL, (u64bit) 0x7C7CED7CC791F8BBULL, (u64bit) 0x6666856617E3CC71ULL, +(u64bit) 0xDDDD53DDA68EA77BULL, (u64bit) 0x17175C17B84B2EAFULL, (u64bit) 0x4747014702468E45ULL, (u64bit) 0x9E9E429E84DC211AULL, +(u64bit) 0xCACA0FCA1EC589D4ULL, (u64bit) 0x2D2DB42D75995A58ULL, (u64bit) 0xBFBFC6BF9179632EULL, (u64bit) 0x07071C07381B0E3FULL, +(u64bit) 0xADAD8EAD012347ACULL, (u64bit) 0x5A5A755AEA2FB4B0ULL, (u64bit) 0x838336836CB51BEFULL, (u64bit) 0x3333CC3385FF66B6ULL, +(u64bit) 0x636391633FF2C65CULL, (u64bit) 0x02020802100A0412ULL, (u64bit) 0xAAAA92AA39384993ULL, (u64bit) 0x7171D971AFA8E2DEULL, +(u64bit) 0xC8C807C80ECF8DC6ULL, (u64bit) 0x19196419C87D32D1ULL, (u64bit) 0x494939497270923BULL, (u64bit) 0xD9D943D9869AAF5FULL, +(u64bit) 0xF2F2EFF2C31DF931ULL, (u64bit) 0xE3E3ABE34B48DBA8ULL, (u64bit) 0x5B5B715BE22AB6B9ULL, (u64bit) 0x88881A8834920DBCULL, +(u64bit) 0x9A9A529AA4C8293EULL, (u64bit) 0x262698262DBE4C0BULL, (u64bit) 0x3232C8328DFA64BFULL, (u64bit) 0xB0B0FAB0E94A7D59ULL, +(u64bit) 0xE9E983E91B6ACFF2ULL, (u64bit) 0x0F0F3C0F78331E77ULL, (u64bit) 0xD5D573D5E6A6B733ULL, (u64bit) 0x80803A8074BA1DF4ULL, +(u64bit) 0xBEBEC2BE997C6127ULL, (u64bit) 0xCDCD13CD26DE87EBULL, (u64bit) 0x3434D034BDE46889ULL, (u64bit) 0x48483D487A759032ULL, +(u64bit) 0xFFFFDBFFAB24E354ULL, (u64bit) 0x7A7AF57AF78FF48DULL, (u64bit) 0x90907A90F4EA3D64ULL, (u64bit) 0x5F5F615FC23EBE9DULL, +(u64bit) 0x202080201DA0403DULL, (u64bit) 0x6868BD6867D5D00FULL, (u64bit) 0x1A1A681AD07234CAULL, (u64bit) 0xAEAE82AE192C41B7ULL, +(u64bit) 0xB4B4EAB4C95E757DULL, (u64bit) 0x54544D549A19A8CEULL, (u64bit) 0x93937693ECE53B7FULL, (u64bit) 0x222288220DAA442FULL, +(u64bit) 0x64648D6407E9C863ULL, (u64bit) 0xF1F1E3F1DB12FF2AULL, (u64bit) 0x7373D173BFA2E6CCULL, (u64bit) 0x12124812905A2482ULL, +(u64bit) 0x40401D403A5D807AULL, (u64bit) 0x0808200840281048ULL, (u64bit) 0xC3C32BC356E89B95ULL, (u64bit) 0xECEC97EC337BC5DFULL, +(u64bit) 0xDBDB4BDB9690AB4DULL, (u64bit) 0xA1A1BEA1611F5FC0ULL, (u64bit) 0x8D8D0E8D1C830791ULL, (u64bit) 0x3D3DF43DF5C97AC8ULL, +(u64bit) 0x97976697CCF1335BULL, (u64bit) 0x0000000000000000ULL, (u64bit) 0xCFCF1BCF36D483F9ULL, (u64bit) 0x2B2BAC2B4587566EULL, +(u64bit) 0x7676C57697B3ECE1ULL, (u64bit) 0x8282328264B019E6ULL, (u64bit) 0xD6D67FD6FEA9B128ULL, (u64bit) 0x1B1B6C1BD87736C3ULL, +(u64bit) 0xB5B5EEB5C15B7774ULL, (u64bit) 0xAFAF86AF112943BEULL, (u64bit) 0x6A6AB56A77DFD41DULL, (u64bit) 0x50505D50BA0DA0EAULL, +(u64bit) 0x45450945124C8A57ULL, (u64bit) 0xF3F3EBF3CB18FB38ULL, (u64bit) 0x3030C0309DF060ADULL, (u64bit) 0xEFEF9BEF2B74C3C4ULL, +(u64bit) 0x3F3FFC3FE5C37EDAULL, (u64bit) 0x55554955921CAAC7ULL, (u64bit) 0xA2A2B2A2791059DBULL, (u64bit) 0xEAEA8FEA0365C9E9ULL, +(u64bit) 0x656589650FECCA6AULL, (u64bit) 0xBABAD2BAB9686903ULL, (u64bit) 0x2F2FBC2F65935E4AULL, (u64bit) 0xC0C027C04EE79D8EULL, +(u64bit) 0xDEDE5FDEBE81A160ULL, (u64bit) 0x1C1C701CE06C38FCULL, (u64bit) 0xFDFDD3FDBB2EE746ULL, (u64bit) 0x4D4D294D52649A1FULL, +(u64bit) 0x92927292E4E03976ULL, (u64bit) 0x7575C9758FBCEAFAULL, (u64bit) 0x06061806301E0C36ULL, (u64bit) 0x8A8A128A249809AEULL, +(u64bit) 0xB2B2F2B2F940794BULL, (u64bit) 0xE6E6BFE66359D185ULL, (u64bit) 0x0E0E380E70361C7EULL, (u64bit) 0x1F1F7C1FF8633EE7ULL, +(u64bit) 0x6262956237F7C455ULL, (u64bit) 0xD4D477D4EEA3B53AULL, (u64bit) 0xA8A89AA829324D81ULL, (u64bit) 0x96966296C4F43152ULL, +(u64bit) 0xF9F9C3F99B3AEF62ULL, (u64bit) 0xC5C533C566F697A3ULL, (u64bit) 0x2525942535B14A10ULL, (u64bit) 0x59597959F220B2ABULL, +(u64bit) 0x84842A8454AE15D0ULL, (u64bit) 0x7272D572B7A7E4C5ULL, (u64bit) 0x3939E439D5DD72ECULL, (u64bit) 0x4C4C2D4C5A619816ULL, +(u64bit) 0x5E5E655ECA3BBC94ULL, (u64bit) 0x7878FD78E785F09FULL, (u64bit) 0x3838E038DDD870E5ULL, (u64bit) 0x8C8C0A8C14860598ULL, +(u64bit) 0xD1D163D1C6B2BF17ULL, (u64bit) 0xA5A5AEA5410B57E4ULL, (u64bit) 0xE2E2AFE2434DD9A1ULL, (u64bit) 0x616199612FF8C24EULL, +(u64bit) 0xB3B3F6B3F1457B42ULL, (u64bit) 0x2121842115A54234ULL, (u64bit) 0x9C9C4A9C94D62508ULL, (u64bit) 0x1E1E781EF0663CEEULL, +(u64bit) 0x4343114322528661ULL, (u64bit) 0xC7C73BC776FC93B1ULL, (u64bit) 0xFCFCD7FCB32BE54FULL, (u64bit) 0x0404100420140824ULL, +(u64bit) 0x51515951B208A2E3ULL, (u64bit) 0x99995E99BCC72F25ULL, (u64bit) 0x6D6DA96D4FC4DA22ULL, (u64bit) 0x0D0D340D68391A65ULL, +(u64bit) 0xFAFACFFA8335E979ULL, (u64bit) 0xDFDF5BDFB684A369ULL, (u64bit) 0x7E7EE57ED79BFCA9ULL, (u64bit) 0x242490243DB44819ULL, +(u64bit) 0x3B3BEC3BC5D776FEULL, (u64bit) 0xABAB96AB313D4B9AULL, (u64bit) 0xCECE1FCE3ED181F0ULL, (u64bit) 0x1111441188552299ULL, +(u64bit) 0x8F8F068F0C890383ULL, (u64bit) 0x4E4E254E4A6B9C04ULL, (u64bit) 0xB7B7E6B7D1517366ULL, (u64bit) 0xEBEB8BEB0B60CBE0ULL, +(u64bit) 0x3C3CF03CFDCC78C1ULL, (u64bit) 0x81813E817CBF1FFDULL, (u64bit) 0x94946A94D4FE3540ULL, (u64bit) 0xF7F7FBF7EB0CF31CULL, +(u64bit) 0xB9B9DEB9A1676F18ULL, (u64bit) 0x13134C13985F268BULL, (u64bit) 0x2C2CB02C7D9C5851ULL, (u64bit) 0xD3D36BD3D6B8BB05ULL, +(u64bit) 0xE7E7BBE76B5CD38CULL, (u64bit) 0x6E6EA56E57CBDC39ULL, (u64bit) 0xC4C437C46EF395AAULL, (u64bit) 0x03030C03180F061BULL, +(u64bit) 0x565645568A13ACDCULL, (u64bit) 0x44440D441A49885EULL, (u64bit) 0x7F7FE17FDF9EFEA0ULL, (u64bit) 0xA9A99EA921374F88ULL, +(u64bit) 0x2A2AA82A4D825467ULL, (u64bit) 0xBBBBD6BBB16D6B0AULL, (u64bit) 0xC1C123C146E29F87ULL, (u64bit) 0x53535153A202A6F1ULL, +(u64bit) 0xDCDC57DCAE8BA572ULL, (u64bit) 0x0B0B2C0B58271653ULL, (u64bit) 0x9D9D4E9D9CD32701ULL, (u64bit) 0x6C6CAD6C47C1D82BULL, +(u64bit) 0x3131C43195F562A4ULL, (u64bit) 0x7474CD7487B9E8F3ULL, (u64bit) 0xF6F6FFF6E309F115ULL, (u64bit) 0x464605460A438C4CULL, +(u64bit) 0xACAC8AAC092645A5ULL, (u64bit) 0x89891E893C970FB5ULL, (u64bit) 0x14145014A04428B4ULL, (u64bit) 0xE1E1A3E15B42DFBAULL, +(u64bit) 0x16165816B04E2CA6ULL, (u64bit) 0x3A3AE83ACDD274F7ULL, (u64bit) 0x6969B9696FD0D206ULL, (u64bit) 0x09092409482D1241ULL, +(u64bit) 0x7070DD70A7ADE0D7ULL, (u64bit) 0xB6B6E2B6D954716FULL, (u64bit) 0xD0D067D0CEB7BD1EULL, (u64bit) 0xEDED93ED3B7EC7D6ULL, +(u64bit) 0xCCCC17CC2EDB85E2ULL, (u64bit) 0x424215422A578468ULL, (u64bit) 0x98985A98B4C22D2CULL, (u64bit) 0xA4A4AAA4490E55EDULL, +(u64bit) 0x2828A0285D885075ULL, (u64bit) 0x5C5C6D5CDA31B886ULL, (u64bit) 0xF8F8C7F8933FED6BULL, (u64bit) 0x8686228644A411C2ULL }; + +const u64bit Whirlpool::C1[256] = { +(u64bit) 0xD818186018C07830ULL, (u64bit) 0x2623238C2305AF46ULL, (u64bit) 0xB8C6C63FC67EF991ULL, (u64bit) 0xFBE8E887E8136FCDULL, +(u64bit) 0xCB878726874CA113ULL, (u64bit) 0x11B8B8DAB8A9626DULL, (u64bit) 0x0901010401080502ULL, (u64bit) 0x0D4F4F214F426E9EULL, +(u64bit) 0x9B3636D836ADEE6CULL, (u64bit) 0xFFA6A6A2A6590451ULL, (u64bit) 0x0CD2D26FD2DEBDB9ULL, (u64bit) 0x0EF5F5F3F5FB06F7ULL, +(u64bit) 0x967979F979EF80F2ULL, (u64bit) 0x306F6FA16F5FCEDEULL, (u64bit) 0x6D91917E91FCEF3FULL, (u64bit) 0xF852525552AA07A4ULL, +(u64bit) 0x4760609D6027FDC0ULL, (u64bit) 0x35BCBCCABC897665ULL, (u64bit) 0x379B9B569BACCD2BULL, (u64bit) 0x8A8E8E028E048C01ULL, +(u64bit) 0xD2A3A3B6A371155BULL, (u64bit) 0x6C0C0C300C603C18ULL, (u64bit) 0x847B7BF17BFF8AF6ULL, (u64bit) 0x803535D435B5E16AULL, +(u64bit) 0xF51D1D741DE8693AULL, (u64bit) 0xB3E0E0A7E05347DDULL, (u64bit) 0x21D7D77BD7F6ACB3ULL, (u64bit) 0x9CC2C22FC25EED99ULL, +(u64bit) 0x432E2EB82E6D965CULL, (u64bit) 0x294B4B314B627A96ULL, (u64bit) 0x5DFEFEDFFEA321E1ULL, (u64bit) 0xD5575741578216AEULL, +(u64bit) 0xBD15155415A8412AULL, (u64bit) 0xE87777C1779FB6EEULL, (u64bit) 0x923737DC37A5EB6EULL, (u64bit) 0x9EE5E5B3E57B56D7ULL, +(u64bit) 0x139F9F469F8CD923ULL, (u64bit) 0x23F0F0E7F0D317FDULL, (u64bit) 0x204A4A354A6A7F94ULL, (u64bit) 0x44DADA4FDA9E95A9ULL, +(u64bit) 0xA258587D58FA25B0ULL, (u64bit) 0xCFC9C903C906CA8FULL, (u64bit) 0x7C2929A429558D52ULL, (u64bit) 0x5A0A0A280A502214ULL, +(u64bit) 0x50B1B1FEB1E14F7FULL, (u64bit) 0xC9A0A0BAA0691A5DULL, (u64bit) 0x146B6BB16B7FDAD6ULL, (u64bit) 0xD985852E855CAB17ULL, +(u64bit) 0x3CBDBDCEBD817367ULL, (u64bit) 0x8F5D5D695DD234BAULL, (u64bit) 0x9010104010805020ULL, (u64bit) 0x07F4F4F7F4F303F5ULL, +(u64bit) 0xDDCBCB0BCB16C08BULL, (u64bit) 0xD33E3EF83EEDC67CULL, (u64bit) 0x2D0505140528110AULL, (u64bit) 0x78676781671FE6CEULL, +(u64bit) 0x97E4E4B7E47353D5ULL, (u64bit) 0x0227279C2725BB4EULL, (u64bit) 0x7341411941325882ULL, (u64bit) 0xA78B8B168B2C9D0BULL, +(u64bit) 0xF6A7A7A6A7510153ULL, (u64bit) 0xB27D7DE97DCF94FAULL, (u64bit) 0x4995956E95DCFB37ULL, (u64bit) 0x56D8D847D88E9FADULL, +(u64bit) 0x70FBFBCBFB8B30EBULL, (u64bit) 0xCDEEEE9FEE2371C1ULL, (u64bit) 0xBB7C7CED7CC791F8ULL, (u64bit) 0x716666856617E3CCULL, +(u64bit) 0x7BDDDD53DDA68EA7ULL, (u64bit) 0xAF17175C17B84B2EULL, (u64bit) 0x454747014702468EULL, (u64bit) 0x1A9E9E429E84DC21ULL, +(u64bit) 0xD4CACA0FCA1EC589ULL, (u64bit) 0x582D2DB42D75995AULL, (u64bit) 0x2EBFBFC6BF917963ULL, (u64bit) 0x3F07071C07381B0EULL, +(u64bit) 0xACADAD8EAD012347ULL, (u64bit) 0xB05A5A755AEA2FB4ULL, (u64bit) 0xEF838336836CB51BULL, (u64bit) 0xB63333CC3385FF66ULL, +(u64bit) 0x5C636391633FF2C6ULL, (u64bit) 0x1202020802100A04ULL, (u64bit) 0x93AAAA92AA393849ULL, (u64bit) 0xDE7171D971AFA8E2ULL, +(u64bit) 0xC6C8C807C80ECF8DULL, (u64bit) 0xD119196419C87D32ULL, (u64bit) 0x3B49493949727092ULL, (u64bit) 0x5FD9D943D9869AAFULL, +(u64bit) 0x31F2F2EFF2C31DF9ULL, (u64bit) 0xA8E3E3ABE34B48DBULL, (u64bit) 0xB95B5B715BE22AB6ULL, (u64bit) 0xBC88881A8834920DULL, +(u64bit) 0x3E9A9A529AA4C829ULL, (u64bit) 0x0B262698262DBE4CULL, (u64bit) 0xBF3232C8328DFA64ULL, (u64bit) 0x59B0B0FAB0E94A7DULL, +(u64bit) 0xF2E9E983E91B6ACFULL, (u64bit) 0x770F0F3C0F78331EULL, (u64bit) 0x33D5D573D5E6A6B7ULL, (u64bit) 0xF480803A8074BA1DULL, +(u64bit) 0x27BEBEC2BE997C61ULL, (u64bit) 0xEBCDCD13CD26DE87ULL, (u64bit) 0x893434D034BDE468ULL, (u64bit) 0x3248483D487A7590ULL, +(u64bit) 0x54FFFFDBFFAB24E3ULL, (u64bit) 0x8D7A7AF57AF78FF4ULL, (u64bit) 0x6490907A90F4EA3DULL, (u64bit) 0x9D5F5F615FC23EBEULL, +(u64bit) 0x3D202080201DA040ULL, (u64bit) 0x0F6868BD6867D5D0ULL, (u64bit) 0xCA1A1A681AD07234ULL, (u64bit) 0xB7AEAE82AE192C41ULL, +(u64bit) 0x7DB4B4EAB4C95E75ULL, (u64bit) 0xCE54544D549A19A8ULL, (u64bit) 0x7F93937693ECE53BULL, (u64bit) 0x2F222288220DAA44ULL, +(u64bit) 0x6364648D6407E9C8ULL, (u64bit) 0x2AF1F1E3F1DB12FFULL, (u64bit) 0xCC7373D173BFA2E6ULL, (u64bit) 0x8212124812905A24ULL, +(u64bit) 0x7A40401D403A5D80ULL, (u64bit) 0x4808082008402810ULL, (u64bit) 0x95C3C32BC356E89BULL, (u64bit) 0xDFECEC97EC337BC5ULL, +(u64bit) 0x4DDBDB4BDB9690ABULL, (u64bit) 0xC0A1A1BEA1611F5FULL, (u64bit) 0x918D8D0E8D1C8307ULL, (u64bit) 0xC83D3DF43DF5C97AULL, +(u64bit) 0x5B97976697CCF133ULL, (u64bit) 0x0000000000000000ULL, (u64bit) 0xF9CFCF1BCF36D483ULL, (u64bit) 0x6E2B2BAC2B458756ULL, +(u64bit) 0xE17676C57697B3ECULL, (u64bit) 0xE68282328264B019ULL, (u64bit) 0x28D6D67FD6FEA9B1ULL, (u64bit) 0xC31B1B6C1BD87736ULL, +(u64bit) 0x74B5B5EEB5C15B77ULL, (u64bit) 0xBEAFAF86AF112943ULL, (u64bit) 0x1D6A6AB56A77DFD4ULL, (u64bit) 0xEA50505D50BA0DA0ULL, +(u64bit) 0x5745450945124C8AULL, (u64bit) 0x38F3F3EBF3CB18FBULL, (u64bit) 0xAD3030C0309DF060ULL, (u64bit) 0xC4EFEF9BEF2B74C3ULL, +(u64bit) 0xDA3F3FFC3FE5C37EULL, (u64bit) 0xC755554955921CAAULL, (u64bit) 0xDBA2A2B2A2791059ULL, (u64bit) 0xE9EAEA8FEA0365C9ULL, +(u64bit) 0x6A656589650FECCAULL, (u64bit) 0x03BABAD2BAB96869ULL, (u64bit) 0x4A2F2FBC2F65935EULL, (u64bit) 0x8EC0C027C04EE79DULL, +(u64bit) 0x60DEDE5FDEBE81A1ULL, (u64bit) 0xFC1C1C701CE06C38ULL, (u64bit) 0x46FDFDD3FDBB2EE7ULL, (u64bit) 0x1F4D4D294D52649AULL, +(u64bit) 0x7692927292E4E039ULL, (u64bit) 0xFA7575C9758FBCEAULL, (u64bit) 0x3606061806301E0CULL, (u64bit) 0xAE8A8A128A249809ULL, +(u64bit) 0x4BB2B2F2B2F94079ULL, (u64bit) 0x85E6E6BFE66359D1ULL, (u64bit) 0x7E0E0E380E70361CULL, (u64bit) 0xE71F1F7C1FF8633EULL, +(u64bit) 0x556262956237F7C4ULL, (u64bit) 0x3AD4D477D4EEA3B5ULL, (u64bit) 0x81A8A89AA829324DULL, (u64bit) 0x5296966296C4F431ULL, +(u64bit) 0x62F9F9C3F99B3AEFULL, (u64bit) 0xA3C5C533C566F697ULL, (u64bit) 0x102525942535B14AULL, (u64bit) 0xAB59597959F220B2ULL, +(u64bit) 0xD084842A8454AE15ULL, (u64bit) 0xC57272D572B7A7E4ULL, (u64bit) 0xEC3939E439D5DD72ULL, (u64bit) 0x164C4C2D4C5A6198ULL, +(u64bit) 0x945E5E655ECA3BBCULL, (u64bit) 0x9F7878FD78E785F0ULL, (u64bit) 0xE53838E038DDD870ULL, (u64bit) 0x988C8C0A8C148605ULL, +(u64bit) 0x17D1D163D1C6B2BFULL, (u64bit) 0xE4A5A5AEA5410B57ULL, (u64bit) 0xA1E2E2AFE2434DD9ULL, (u64bit) 0x4E616199612FF8C2ULL, +(u64bit) 0x42B3B3F6B3F1457BULL, (u64bit) 0x342121842115A542ULL, (u64bit) 0x089C9C4A9C94D625ULL, (u64bit) 0xEE1E1E781EF0663CULL, +(u64bit) 0x6143431143225286ULL, (u64bit) 0xB1C7C73BC776FC93ULL, (u64bit) 0x4FFCFCD7FCB32BE5ULL, (u64bit) 0x2404041004201408ULL, +(u64bit) 0xE351515951B208A2ULL, (u64bit) 0x2599995E99BCC72FULL, (u64bit) 0x226D6DA96D4FC4DAULL, (u64bit) 0x650D0D340D68391AULL, +(u64bit) 0x79FAFACFFA8335E9ULL, (u64bit) 0x69DFDF5BDFB684A3ULL, (u64bit) 0xA97E7EE57ED79BFCULL, (u64bit) 0x19242490243DB448ULL, +(u64bit) 0xFE3B3BEC3BC5D776ULL, (u64bit) 0x9AABAB96AB313D4BULL, (u64bit) 0xF0CECE1FCE3ED181ULL, (u64bit) 0x9911114411885522ULL, +(u64bit) 0x838F8F068F0C8903ULL, (u64bit) 0x044E4E254E4A6B9CULL, (u64bit) 0x66B7B7E6B7D15173ULL, (u64bit) 0xE0EBEB8BEB0B60CBULL, +(u64bit) 0xC13C3CF03CFDCC78ULL, (u64bit) 0xFD81813E817CBF1FULL, (u64bit) 0x4094946A94D4FE35ULL, (u64bit) 0x1CF7F7FBF7EB0CF3ULL, +(u64bit) 0x18B9B9DEB9A1676FULL, (u64bit) 0x8B13134C13985F26ULL, (u64bit) 0x512C2CB02C7D9C58ULL, (u64bit) 0x05D3D36BD3D6B8BBULL, +(u64bit) 0x8CE7E7BBE76B5CD3ULL, (u64bit) 0x396E6EA56E57CBDCULL, (u64bit) 0xAAC4C437C46EF395ULL, (u64bit) 0x1B03030C03180F06ULL, +(u64bit) 0xDC565645568A13ACULL, (u64bit) 0x5E44440D441A4988ULL, (u64bit) 0xA07F7FE17FDF9EFEULL, (u64bit) 0x88A9A99EA921374FULL, +(u64bit) 0x672A2AA82A4D8254ULL, (u64bit) 0x0ABBBBD6BBB16D6BULL, (u64bit) 0x87C1C123C146E29FULL, (u64bit) 0xF153535153A202A6ULL, +(u64bit) 0x72DCDC57DCAE8BA5ULL, (u64bit) 0x530B0B2C0B582716ULL, (u64bit) 0x019D9D4E9D9CD327ULL, (u64bit) 0x2B6C6CAD6C47C1D8ULL, +(u64bit) 0xA43131C43195F562ULL, (u64bit) 0xF37474CD7487B9E8ULL, (u64bit) 0x15F6F6FFF6E309F1ULL, (u64bit) 0x4C464605460A438CULL, +(u64bit) 0xA5ACAC8AAC092645ULL, (u64bit) 0xB589891E893C970FULL, (u64bit) 0xB414145014A04428ULL, (u64bit) 0xBAE1E1A3E15B42DFULL, +(u64bit) 0xA616165816B04E2CULL, (u64bit) 0xF73A3AE83ACDD274ULL, (u64bit) 0x066969B9696FD0D2ULL, (u64bit) 0x4109092409482D12ULL, +(u64bit) 0xD77070DD70A7ADE0ULL, (u64bit) 0x6FB6B6E2B6D95471ULL, (u64bit) 0x1ED0D067D0CEB7BDULL, (u64bit) 0xD6EDED93ED3B7EC7ULL, +(u64bit) 0xE2CCCC17CC2EDB85ULL, (u64bit) 0x68424215422A5784ULL, (u64bit) 0x2C98985A98B4C22DULL, (u64bit) 0xEDA4A4AAA4490E55ULL, +(u64bit) 0x752828A0285D8850ULL, (u64bit) 0x865C5C6D5CDA31B8ULL, (u64bit) 0x6BF8F8C7F8933FEDULL, (u64bit) 0xC28686228644A411ULL }; + +const u64bit Whirlpool::C2[256] = { +(u64bit) 0x30D818186018C078ULL, (u64bit) 0x462623238C2305AFULL, (u64bit) 0x91B8C6C63FC67EF9ULL, (u64bit) 0xCDFBE8E887E8136FULL, +(u64bit) 0x13CB878726874CA1ULL, (u64bit) 0x6D11B8B8DAB8A962ULL, (u64bit) 0x0209010104010805ULL, (u64bit) 0x9E0D4F4F214F426EULL, +(u64bit) 0x6C9B3636D836ADEEULL, (u64bit) 0x51FFA6A6A2A65904ULL, (u64bit) 0xB90CD2D26FD2DEBDULL, (u64bit) 0xF70EF5F5F3F5FB06ULL, +(u64bit) 0xF2967979F979EF80ULL, (u64bit) 0xDE306F6FA16F5FCEULL, (u64bit) 0x3F6D91917E91FCEFULL, (u64bit) 0xA4F852525552AA07ULL, +(u64bit) 0xC04760609D6027FDULL, (u64bit) 0x6535BCBCCABC8976ULL, (u64bit) 0x2B379B9B569BACCDULL, (u64bit) 0x018A8E8E028E048CULL, +(u64bit) 0x5BD2A3A3B6A37115ULL, (u64bit) 0x186C0C0C300C603CULL, (u64bit) 0xF6847B7BF17BFF8AULL, (u64bit) 0x6A803535D435B5E1ULL, +(u64bit) 0x3AF51D1D741DE869ULL, (u64bit) 0xDDB3E0E0A7E05347ULL, (u64bit) 0xB321D7D77BD7F6ACULL, (u64bit) 0x999CC2C22FC25EEDULL, +(u64bit) 0x5C432E2EB82E6D96ULL, (u64bit) 0x96294B4B314B627AULL, (u64bit) 0xE15DFEFEDFFEA321ULL, (u64bit) 0xAED5575741578216ULL, +(u64bit) 0x2ABD15155415A841ULL, (u64bit) 0xEEE87777C1779FB6ULL, (u64bit) 0x6E923737DC37A5EBULL, (u64bit) 0xD79EE5E5B3E57B56ULL, +(u64bit) 0x23139F9F469F8CD9ULL, (u64bit) 0xFD23F0F0E7F0D317ULL, (u64bit) 0x94204A4A354A6A7FULL, (u64bit) 0xA944DADA4FDA9E95ULL, +(u64bit) 0xB0A258587D58FA25ULL, (u64bit) 0x8FCFC9C903C906CAULL, (u64bit) 0x527C2929A429558DULL, (u64bit) 0x145A0A0A280A5022ULL, +(u64bit) 0x7F50B1B1FEB1E14FULL, (u64bit) 0x5DC9A0A0BAA0691AULL, (u64bit) 0xD6146B6BB16B7FDAULL, (u64bit) 0x17D985852E855CABULL, +(u64bit) 0x673CBDBDCEBD8173ULL, (u64bit) 0xBA8F5D5D695DD234ULL, (u64bit) 0x2090101040108050ULL, (u64bit) 0xF507F4F4F7F4F303ULL, +(u64bit) 0x8BDDCBCB0BCB16C0ULL, (u64bit) 0x7CD33E3EF83EEDC6ULL, (u64bit) 0x0A2D050514052811ULL, (u64bit) 0xCE78676781671FE6ULL, +(u64bit) 0xD597E4E4B7E47353ULL, (u64bit) 0x4E0227279C2725BBULL, (u64bit) 0x8273414119413258ULL, (u64bit) 0x0BA78B8B168B2C9DULL, +(u64bit) 0x53F6A7A7A6A75101ULL, (u64bit) 0xFAB27D7DE97DCF94ULL, (u64bit) 0x374995956E95DCFBULL, (u64bit) 0xAD56D8D847D88E9FULL, +(u64bit) 0xEB70FBFBCBFB8B30ULL, (u64bit) 0xC1CDEEEE9FEE2371ULL, (u64bit) 0xF8BB7C7CED7CC791ULL, (u64bit) 0xCC716666856617E3ULL, +(u64bit) 0xA77BDDDD53DDA68EULL, (u64bit) 0x2EAF17175C17B84BULL, (u64bit) 0x8E45474701470246ULL, (u64bit) 0x211A9E9E429E84DCULL, +(u64bit) 0x89D4CACA0FCA1EC5ULL, (u64bit) 0x5A582D2DB42D7599ULL, (u64bit) 0x632EBFBFC6BF9179ULL, (u64bit) 0x0E3F07071C07381BULL, +(u64bit) 0x47ACADAD8EAD0123ULL, (u64bit) 0xB4B05A5A755AEA2FULL, (u64bit) 0x1BEF838336836CB5ULL, (u64bit) 0x66B63333CC3385FFULL, +(u64bit) 0xC65C636391633FF2ULL, (u64bit) 0x041202020802100AULL, (u64bit) 0x4993AAAA92AA3938ULL, (u64bit) 0xE2DE7171D971AFA8ULL, +(u64bit) 0x8DC6C8C807C80ECFULL, (u64bit) 0x32D119196419C87DULL, (u64bit) 0x923B494939497270ULL, (u64bit) 0xAF5FD9D943D9869AULL, +(u64bit) 0xF931F2F2EFF2C31DULL, (u64bit) 0xDBA8E3E3ABE34B48ULL, (u64bit) 0xB6B95B5B715BE22AULL, (u64bit) 0x0DBC88881A883492ULL, +(u64bit) 0x293E9A9A529AA4C8ULL, (u64bit) 0x4C0B262698262DBEULL, (u64bit) 0x64BF3232C8328DFAULL, (u64bit) 0x7D59B0B0FAB0E94AULL, +(u64bit) 0xCFF2E9E983E91B6AULL, (u64bit) 0x1E770F0F3C0F7833ULL, (u64bit) 0xB733D5D573D5E6A6ULL, (u64bit) 0x1DF480803A8074BAULL, +(u64bit) 0x6127BEBEC2BE997CULL, (u64bit) 0x87EBCDCD13CD26DEULL, (u64bit) 0x68893434D034BDE4ULL, (u64bit) 0x903248483D487A75ULL, +(u64bit) 0xE354FFFFDBFFAB24ULL, (u64bit) 0xF48D7A7AF57AF78FULL, (u64bit) 0x3D6490907A90F4EAULL, (u64bit) 0xBE9D5F5F615FC23EULL, +(u64bit) 0x403D202080201DA0ULL, (u64bit) 0xD00F6868BD6867D5ULL, (u64bit) 0x34CA1A1A681AD072ULL, (u64bit) 0x41B7AEAE82AE192CULL, +(u64bit) 0x757DB4B4EAB4C95EULL, (u64bit) 0xA8CE54544D549A19ULL, (u64bit) 0x3B7F93937693ECE5ULL, (u64bit) 0x442F222288220DAAULL, +(u64bit) 0xC86364648D6407E9ULL, (u64bit) 0xFF2AF1F1E3F1DB12ULL, (u64bit) 0xE6CC7373D173BFA2ULL, (u64bit) 0x248212124812905AULL, +(u64bit) 0x807A40401D403A5DULL, (u64bit) 0x1048080820084028ULL, (u64bit) 0x9B95C3C32BC356E8ULL, (u64bit) 0xC5DFECEC97EC337BULL, +(u64bit) 0xAB4DDBDB4BDB9690ULL, (u64bit) 0x5FC0A1A1BEA1611FULL, (u64bit) 0x07918D8D0E8D1C83ULL, (u64bit) 0x7AC83D3DF43DF5C9ULL, +(u64bit) 0x335B97976697CCF1ULL, (u64bit) 0x0000000000000000ULL, (u64bit) 0x83F9CFCF1BCF36D4ULL, (u64bit) 0x566E2B2BAC2B4587ULL, +(u64bit) 0xECE17676C57697B3ULL, (u64bit) 0x19E68282328264B0ULL, (u64bit) 0xB128D6D67FD6FEA9ULL, (u64bit) 0x36C31B1B6C1BD877ULL, +(u64bit) 0x7774B5B5EEB5C15BULL, (u64bit) 0x43BEAFAF86AF1129ULL, (u64bit) 0xD41D6A6AB56A77DFULL, (u64bit) 0xA0EA50505D50BA0DULL, +(u64bit) 0x8A5745450945124CULL, (u64bit) 0xFB38F3F3EBF3CB18ULL, (u64bit) 0x60AD3030C0309DF0ULL, (u64bit) 0xC3C4EFEF9BEF2B74ULL, +(u64bit) 0x7EDA3F3FFC3FE5C3ULL, (u64bit) 0xAAC755554955921CULL, (u64bit) 0x59DBA2A2B2A27910ULL, (u64bit) 0xC9E9EAEA8FEA0365ULL, +(u64bit) 0xCA6A656589650FECULL, (u64bit) 0x6903BABAD2BAB968ULL, (u64bit) 0x5E4A2F2FBC2F6593ULL, (u64bit) 0x9D8EC0C027C04EE7ULL, +(u64bit) 0xA160DEDE5FDEBE81ULL, (u64bit) 0x38FC1C1C701CE06CULL, (u64bit) 0xE746FDFDD3FDBB2EULL, (u64bit) 0x9A1F4D4D294D5264ULL, +(u64bit) 0x397692927292E4E0ULL, (u64bit) 0xEAFA7575C9758FBCULL, (u64bit) 0x0C3606061806301EULL, (u64bit) 0x09AE8A8A128A2498ULL, +(u64bit) 0x794BB2B2F2B2F940ULL, (u64bit) 0xD185E6E6BFE66359ULL, (u64bit) 0x1C7E0E0E380E7036ULL, (u64bit) 0x3EE71F1F7C1FF863ULL, +(u64bit) 0xC4556262956237F7ULL, (u64bit) 0xB53AD4D477D4EEA3ULL, (u64bit) 0x4D81A8A89AA82932ULL, (u64bit) 0x315296966296C4F4ULL, +(u64bit) 0xEF62F9F9C3F99B3AULL, (u64bit) 0x97A3C5C533C566F6ULL, (u64bit) 0x4A102525942535B1ULL, (u64bit) 0xB2AB59597959F220ULL, +(u64bit) 0x15D084842A8454AEULL, (u64bit) 0xE4C57272D572B7A7ULL, (u64bit) 0x72EC3939E439D5DDULL, (u64bit) 0x98164C4C2D4C5A61ULL, +(u64bit) 0xBC945E5E655ECA3BULL, (u64bit) 0xF09F7878FD78E785ULL, (u64bit) 0x70E53838E038DDD8ULL, (u64bit) 0x05988C8C0A8C1486ULL, +(u64bit) 0xBF17D1D163D1C6B2ULL, (u64bit) 0x57E4A5A5AEA5410BULL, (u64bit) 0xD9A1E2E2AFE2434DULL, (u64bit) 0xC24E616199612FF8ULL, +(u64bit) 0x7B42B3B3F6B3F145ULL, (u64bit) 0x42342121842115A5ULL, (u64bit) 0x25089C9C4A9C94D6ULL, (u64bit) 0x3CEE1E1E781EF066ULL, +(u64bit) 0x8661434311432252ULL, (u64bit) 0x93B1C7C73BC776FCULL, (u64bit) 0xE54FFCFCD7FCB32BULL, (u64bit) 0x0824040410042014ULL, +(u64bit) 0xA2E351515951B208ULL, (u64bit) 0x2F2599995E99BCC7ULL, (u64bit) 0xDA226D6DA96D4FC4ULL, (u64bit) 0x1A650D0D340D6839ULL, +(u64bit) 0xE979FAFACFFA8335ULL, (u64bit) 0xA369DFDF5BDFB684ULL, (u64bit) 0xFCA97E7EE57ED79BULL, (u64bit) 0x4819242490243DB4ULL, +(u64bit) 0x76FE3B3BEC3BC5D7ULL, (u64bit) 0x4B9AABAB96AB313DULL, (u64bit) 0x81F0CECE1FCE3ED1ULL, (u64bit) 0x2299111144118855ULL, +(u64bit) 0x03838F8F068F0C89ULL, (u64bit) 0x9C044E4E254E4A6BULL, (u64bit) 0x7366B7B7E6B7D151ULL, (u64bit) 0xCBE0EBEB8BEB0B60ULL, +(u64bit) 0x78C13C3CF03CFDCCULL, (u64bit) 0x1FFD81813E817CBFULL, (u64bit) 0x354094946A94D4FEULL, (u64bit) 0xF31CF7F7FBF7EB0CULL, +(u64bit) 0x6F18B9B9DEB9A167ULL, (u64bit) 0x268B13134C13985FULL, (u64bit) 0x58512C2CB02C7D9CULL, (u64bit) 0xBB05D3D36BD3D6B8ULL, +(u64bit) 0xD38CE7E7BBE76B5CULL, (u64bit) 0xDC396E6EA56E57CBULL, (u64bit) 0x95AAC4C437C46EF3ULL, (u64bit) 0x061B03030C03180FULL, +(u64bit) 0xACDC565645568A13ULL, (u64bit) 0x885E44440D441A49ULL, (u64bit) 0xFEA07F7FE17FDF9EULL, (u64bit) 0x4F88A9A99EA92137ULL, +(u64bit) 0x54672A2AA82A4D82ULL, (u64bit) 0x6B0ABBBBD6BBB16DULL, (u64bit) 0x9F87C1C123C146E2ULL, (u64bit) 0xA6F153535153A202ULL, +(u64bit) 0xA572DCDC57DCAE8BULL, (u64bit) 0x16530B0B2C0B5827ULL, (u64bit) 0x27019D9D4E9D9CD3ULL, (u64bit) 0xD82B6C6CAD6C47C1ULL, +(u64bit) 0x62A43131C43195F5ULL, (u64bit) 0xE8F37474CD7487B9ULL, (u64bit) 0xF115F6F6FFF6E309ULL, (u64bit) 0x8C4C464605460A43ULL, +(u64bit) 0x45A5ACAC8AAC0926ULL, (u64bit) 0x0FB589891E893C97ULL, (u64bit) 0x28B414145014A044ULL, (u64bit) 0xDFBAE1E1A3E15B42ULL, +(u64bit) 0x2CA616165816B04EULL, (u64bit) 0x74F73A3AE83ACDD2ULL, (u64bit) 0xD2066969B9696FD0ULL, (u64bit) 0x124109092409482DULL, +(u64bit) 0xE0D77070DD70A7ADULL, (u64bit) 0x716FB6B6E2B6D954ULL, (u64bit) 0xBD1ED0D067D0CEB7ULL, (u64bit) 0xC7D6EDED93ED3B7EULL, +(u64bit) 0x85E2CCCC17CC2EDBULL, (u64bit) 0x8468424215422A57ULL, (u64bit) 0x2D2C98985A98B4C2ULL, (u64bit) 0x55EDA4A4AAA4490EULL, +(u64bit) 0x50752828A0285D88ULL, (u64bit) 0xB8865C5C6D5CDA31ULL, (u64bit) 0xED6BF8F8C7F8933FULL, (u64bit) 0x11C28686228644A4ULL }; + +const u64bit Whirlpool::C3[256] = { +(u64bit) 0x7830D818186018C0ULL, (u64bit) 0xAF462623238C2305ULL, (u64bit) 0xF991B8C6C63FC67EULL, (u64bit) 0x6FCDFBE8E887E813ULL, +(u64bit) 0xA113CB878726874CULL, (u64bit) 0x626D11B8B8DAB8A9ULL, (u64bit) 0x0502090101040108ULL, (u64bit) 0x6E9E0D4F4F214F42ULL, +(u64bit) 0xEE6C9B3636D836ADULL, (u64bit) 0x0451FFA6A6A2A659ULL, (u64bit) 0xBDB90CD2D26FD2DEULL, (u64bit) 0x06F70EF5F5F3F5FBULL, +(u64bit) 0x80F2967979F979EFULL, (u64bit) 0xCEDE306F6FA16F5FULL, (u64bit) 0xEF3F6D91917E91FCULL, (u64bit) 0x07A4F852525552AAULL, +(u64bit) 0xFDC04760609D6027ULL, (u64bit) 0x766535BCBCCABC89ULL, (u64bit) 0xCD2B379B9B569BACULL, (u64bit) 0x8C018A8E8E028E04ULL, +(u64bit) 0x155BD2A3A3B6A371ULL, (u64bit) 0x3C186C0C0C300C60ULL, (u64bit) 0x8AF6847B7BF17BFFULL, (u64bit) 0xE16A803535D435B5ULL, +(u64bit) 0x693AF51D1D741DE8ULL, (u64bit) 0x47DDB3E0E0A7E053ULL, (u64bit) 0xACB321D7D77BD7F6ULL, (u64bit) 0xED999CC2C22FC25EULL, +(u64bit) 0x965C432E2EB82E6DULL, (u64bit) 0x7A96294B4B314B62ULL, (u64bit) 0x21E15DFEFEDFFEA3ULL, (u64bit) 0x16AED55757415782ULL, +(u64bit) 0x412ABD15155415A8ULL, (u64bit) 0xB6EEE87777C1779FULL, (u64bit) 0xEB6E923737DC37A5ULL, (u64bit) 0x56D79EE5E5B3E57BULL, +(u64bit) 0xD923139F9F469F8CULL, (u64bit) 0x17FD23F0F0E7F0D3ULL, (u64bit) 0x7F94204A4A354A6AULL, (u64bit) 0x95A944DADA4FDA9EULL, +(u64bit) 0x25B0A258587D58FAULL, (u64bit) 0xCA8FCFC9C903C906ULL, (u64bit) 0x8D527C2929A42955ULL, (u64bit) 0x22145A0A0A280A50ULL, +(u64bit) 0x4F7F50B1B1FEB1E1ULL, (u64bit) 0x1A5DC9A0A0BAA069ULL, (u64bit) 0xDAD6146B6BB16B7FULL, (u64bit) 0xAB17D985852E855CULL, +(u64bit) 0x73673CBDBDCEBD81ULL, (u64bit) 0x34BA8F5D5D695DD2ULL, (u64bit) 0x5020901010401080ULL, (u64bit) 0x03F507F4F4F7F4F3ULL, +(u64bit) 0xC08BDDCBCB0BCB16ULL, (u64bit) 0xC67CD33E3EF83EEDULL, (u64bit) 0x110A2D0505140528ULL, (u64bit) 0xE6CE78676781671FULL, +(u64bit) 0x53D597E4E4B7E473ULL, (u64bit) 0xBB4E0227279C2725ULL, (u64bit) 0x5882734141194132ULL, (u64bit) 0x9D0BA78B8B168B2CULL, +(u64bit) 0x0153F6A7A7A6A751ULL, (u64bit) 0x94FAB27D7DE97DCFULL, (u64bit) 0xFB374995956E95DCULL, (u64bit) 0x9FAD56D8D847D88EULL, +(u64bit) 0x30EB70FBFBCBFB8BULL, (u64bit) 0x71C1CDEEEE9FEE23ULL, (u64bit) 0x91F8BB7C7CED7CC7ULL, (u64bit) 0xE3CC716666856617ULL, +(u64bit) 0x8EA77BDDDD53DDA6ULL, (u64bit) 0x4B2EAF17175C17B8ULL, (u64bit) 0x468E454747014702ULL, (u64bit) 0xDC211A9E9E429E84ULL, +(u64bit) 0xC589D4CACA0FCA1EULL, (u64bit) 0x995A582D2DB42D75ULL, (u64bit) 0x79632EBFBFC6BF91ULL, (u64bit) 0x1B0E3F07071C0738ULL, +(u64bit) 0x2347ACADAD8EAD01ULL, (u64bit) 0x2FB4B05A5A755AEAULL, (u64bit) 0xB51BEF838336836CULL, (u64bit) 0xFF66B63333CC3385ULL, +(u64bit) 0xF2C65C636391633FULL, (u64bit) 0x0A04120202080210ULL, (u64bit) 0x384993AAAA92AA39ULL, (u64bit) 0xA8E2DE7171D971AFULL, +(u64bit) 0xCF8DC6C8C807C80EULL, (u64bit) 0x7D32D119196419C8ULL, (u64bit) 0x70923B4949394972ULL, (u64bit) 0x9AAF5FD9D943D986ULL, +(u64bit) 0x1DF931F2F2EFF2C3ULL, (u64bit) 0x48DBA8E3E3ABE34BULL, (u64bit) 0x2AB6B95B5B715BE2ULL, (u64bit) 0x920DBC88881A8834ULL, +(u64bit) 0xC8293E9A9A529AA4ULL, (u64bit) 0xBE4C0B262698262DULL, (u64bit) 0xFA64BF3232C8328DULL, (u64bit) 0x4A7D59B0B0FAB0E9ULL, +(u64bit) 0x6ACFF2E9E983E91BULL, (u64bit) 0x331E770F0F3C0F78ULL, (u64bit) 0xA6B733D5D573D5E6ULL, (u64bit) 0xBA1DF480803A8074ULL, +(u64bit) 0x7C6127BEBEC2BE99ULL, (u64bit) 0xDE87EBCDCD13CD26ULL, (u64bit) 0xE468893434D034BDULL, (u64bit) 0x75903248483D487AULL, +(u64bit) 0x24E354FFFFDBFFABULL, (u64bit) 0x8FF48D7A7AF57AF7ULL, (u64bit) 0xEA3D6490907A90F4ULL, (u64bit) 0x3EBE9D5F5F615FC2ULL, +(u64bit) 0xA0403D202080201DULL, (u64bit) 0xD5D00F6868BD6867ULL, (u64bit) 0x7234CA1A1A681AD0ULL, (u64bit) 0x2C41B7AEAE82AE19ULL, +(u64bit) 0x5E757DB4B4EAB4C9ULL, (u64bit) 0x19A8CE54544D549AULL, (u64bit) 0xE53B7F93937693ECULL, (u64bit) 0xAA442F222288220DULL, +(u64bit) 0xE9C86364648D6407ULL, (u64bit) 0x12FF2AF1F1E3F1DBULL, (u64bit) 0xA2E6CC7373D173BFULL, (u64bit) 0x5A24821212481290ULL, +(u64bit) 0x5D807A40401D403AULL, (u64bit) 0x2810480808200840ULL, (u64bit) 0xE89B95C3C32BC356ULL, (u64bit) 0x7BC5DFECEC97EC33ULL, +(u64bit) 0x90AB4DDBDB4BDB96ULL, (u64bit) 0x1F5FC0A1A1BEA161ULL, (u64bit) 0x8307918D8D0E8D1CULL, (u64bit) 0xC97AC83D3DF43DF5ULL, +(u64bit) 0xF1335B97976697CCULL, (u64bit) 0x0000000000000000ULL, (u64bit) 0xD483F9CFCF1BCF36ULL, (u64bit) 0x87566E2B2BAC2B45ULL, +(u64bit) 0xB3ECE17676C57697ULL, (u64bit) 0xB019E68282328264ULL, (u64bit) 0xA9B128D6D67FD6FEULL, (u64bit) 0x7736C31B1B6C1BD8ULL, +(u64bit) 0x5B7774B5B5EEB5C1ULL, (u64bit) 0x2943BEAFAF86AF11ULL, (u64bit) 0xDFD41D6A6AB56A77ULL, (u64bit) 0x0DA0EA50505D50BAULL, +(u64bit) 0x4C8A574545094512ULL, (u64bit) 0x18FB38F3F3EBF3CBULL, (u64bit) 0xF060AD3030C0309DULL, (u64bit) 0x74C3C4EFEF9BEF2BULL, +(u64bit) 0xC37EDA3F3FFC3FE5ULL, (u64bit) 0x1CAAC75555495592ULL, (u64bit) 0x1059DBA2A2B2A279ULL, (u64bit) 0x65C9E9EAEA8FEA03ULL, +(u64bit) 0xECCA6A656589650FULL, (u64bit) 0x686903BABAD2BAB9ULL, (u64bit) 0x935E4A2F2FBC2F65ULL, (u64bit) 0xE79D8EC0C027C04EULL, +(u64bit) 0x81A160DEDE5FDEBEULL, (u64bit) 0x6C38FC1C1C701CE0ULL, (u64bit) 0x2EE746FDFDD3FDBBULL, (u64bit) 0x649A1F4D4D294D52ULL, +(u64bit) 0xE0397692927292E4ULL, (u64bit) 0xBCEAFA7575C9758FULL, (u64bit) 0x1E0C360606180630ULL, (u64bit) 0x9809AE8A8A128A24ULL, +(u64bit) 0x40794BB2B2F2B2F9ULL, (u64bit) 0x59D185E6E6BFE663ULL, (u64bit) 0x361C7E0E0E380E70ULL, (u64bit) 0x633EE71F1F7C1FF8ULL, +(u64bit) 0xF7C4556262956237ULL, (u64bit) 0xA3B53AD4D477D4EEULL, (u64bit) 0x324D81A8A89AA829ULL, (u64bit) 0xF4315296966296C4ULL, +(u64bit) 0x3AEF62F9F9C3F99BULL, (u64bit) 0xF697A3C5C533C566ULL, (u64bit) 0xB14A102525942535ULL, (u64bit) 0x20B2AB59597959F2ULL, +(u64bit) 0xAE15D084842A8454ULL, (u64bit) 0xA7E4C57272D572B7ULL, (u64bit) 0xDD72EC3939E439D5ULL, (u64bit) 0x6198164C4C2D4C5AULL, +(u64bit) 0x3BBC945E5E655ECAULL, (u64bit) 0x85F09F7878FD78E7ULL, (u64bit) 0xD870E53838E038DDULL, (u64bit) 0x8605988C8C0A8C14ULL, +(u64bit) 0xB2BF17D1D163D1C6ULL, (u64bit) 0x0B57E4A5A5AEA541ULL, (u64bit) 0x4DD9A1E2E2AFE243ULL, (u64bit) 0xF8C24E616199612FULL, +(u64bit) 0x457B42B3B3F6B3F1ULL, (u64bit) 0xA542342121842115ULL, (u64bit) 0xD625089C9C4A9C94ULL, (u64bit) 0x663CEE1E1E781EF0ULL, +(u64bit) 0x5286614343114322ULL, (u64bit) 0xFC93B1C7C73BC776ULL, (u64bit) 0x2BE54FFCFCD7FCB3ULL, (u64bit) 0x1408240404100420ULL, +(u64bit) 0x08A2E351515951B2ULL, (u64bit) 0xC72F2599995E99BCULL, (u64bit) 0xC4DA226D6DA96D4FULL, (u64bit) 0x391A650D0D340D68ULL, +(u64bit) 0x35E979FAFACFFA83ULL, (u64bit) 0x84A369DFDF5BDFB6ULL, (u64bit) 0x9BFCA97E7EE57ED7ULL, (u64bit) 0xB44819242490243DULL, +(u64bit) 0xD776FE3B3BEC3BC5ULL, (u64bit) 0x3D4B9AABAB96AB31ULL, (u64bit) 0xD181F0CECE1FCE3EULL, (u64bit) 0x5522991111441188ULL, +(u64bit) 0x8903838F8F068F0CULL, (u64bit) 0x6B9C044E4E254E4AULL, (u64bit) 0x517366B7B7E6B7D1ULL, (u64bit) 0x60CBE0EBEB8BEB0BULL, +(u64bit) 0xCC78C13C3CF03CFDULL, (u64bit) 0xBF1FFD81813E817CULL, (u64bit) 0xFE354094946A94D4ULL, (u64bit) 0x0CF31CF7F7FBF7EBULL, +(u64bit) 0x676F18B9B9DEB9A1ULL, (u64bit) 0x5F268B13134C1398ULL, (u64bit) 0x9C58512C2CB02C7DULL, (u64bit) 0xB8BB05D3D36BD3D6ULL, +(u64bit) 0x5CD38CE7E7BBE76BULL, (u64bit) 0xCBDC396E6EA56E57ULL, (u64bit) 0xF395AAC4C437C46EULL, (u64bit) 0x0F061B03030C0318ULL, +(u64bit) 0x13ACDC565645568AULL, (u64bit) 0x49885E44440D441AULL, (u64bit) 0x9EFEA07F7FE17FDFULL, (u64bit) 0x374F88A9A99EA921ULL, +(u64bit) 0x8254672A2AA82A4DULL, (u64bit) 0x6D6B0ABBBBD6BBB1ULL, (u64bit) 0xE29F87C1C123C146ULL, (u64bit) 0x02A6F153535153A2ULL, +(u64bit) 0x8BA572DCDC57DCAEULL, (u64bit) 0x2716530B0B2C0B58ULL, (u64bit) 0xD327019D9D4E9D9CULL, (u64bit) 0xC1D82B6C6CAD6C47ULL, +(u64bit) 0xF562A43131C43195ULL, (u64bit) 0xB9E8F37474CD7487ULL, (u64bit) 0x09F115F6F6FFF6E3ULL, (u64bit) 0x438C4C464605460AULL, +(u64bit) 0x2645A5ACAC8AAC09ULL, (u64bit) 0x970FB589891E893CULL, (u64bit) 0x4428B414145014A0ULL, (u64bit) 0x42DFBAE1E1A3E15BULL, +(u64bit) 0x4E2CA616165816B0ULL, (u64bit) 0xD274F73A3AE83ACDULL, (u64bit) 0xD0D2066969B9696FULL, (u64bit) 0x2D12410909240948ULL, +(u64bit) 0xADE0D77070DD70A7ULL, (u64bit) 0x54716FB6B6E2B6D9ULL, (u64bit) 0xB7BD1ED0D067D0CEULL, (u64bit) 0x7EC7D6EDED93ED3BULL, +(u64bit) 0xDB85E2CCCC17CC2EULL, (u64bit) 0x578468424215422AULL, (u64bit) 0xC22D2C98985A98B4ULL, (u64bit) 0x0E55EDA4A4AAA449ULL, +(u64bit) 0x8850752828A0285DULL, (u64bit) 0x31B8865C5C6D5CDAULL, (u64bit) 0x3FED6BF8F8C7F893ULL, (u64bit) 0xA411C28686228644ULL }; + +const u64bit Whirlpool::C4[256] = { +(u64bit) 0xC07830D818186018ULL, (u64bit) 0x05AF462623238C23ULL, (u64bit) 0x7EF991B8C6C63FC6ULL, (u64bit) 0x136FCDFBE8E887E8ULL, +(u64bit) 0x4CA113CB87872687ULL, (u64bit) 0xA9626D11B8B8DAB8ULL, (u64bit) 0x0805020901010401ULL, (u64bit) 0x426E9E0D4F4F214FULL, +(u64bit) 0xADEE6C9B3636D836ULL, (u64bit) 0x590451FFA6A6A2A6ULL, (u64bit) 0xDEBDB90CD2D26FD2ULL, (u64bit) 0xFB06F70EF5F5F3F5ULL, +(u64bit) 0xEF80F2967979F979ULL, (u64bit) 0x5FCEDE306F6FA16FULL, (u64bit) 0xFCEF3F6D91917E91ULL, (u64bit) 0xAA07A4F852525552ULL, +(u64bit) 0x27FDC04760609D60ULL, (u64bit) 0x89766535BCBCCABCULL, (u64bit) 0xACCD2B379B9B569BULL, (u64bit) 0x048C018A8E8E028EULL, +(u64bit) 0x71155BD2A3A3B6A3ULL, (u64bit) 0x603C186C0C0C300CULL, (u64bit) 0xFF8AF6847B7BF17BULL, (u64bit) 0xB5E16A803535D435ULL, +(u64bit) 0xE8693AF51D1D741DULL, (u64bit) 0x5347DDB3E0E0A7E0ULL, (u64bit) 0xF6ACB321D7D77BD7ULL, (u64bit) 0x5EED999CC2C22FC2ULL, +(u64bit) 0x6D965C432E2EB82EULL, (u64bit) 0x627A96294B4B314BULL, (u64bit) 0xA321E15DFEFEDFFEULL, (u64bit) 0x8216AED557574157ULL, +(u64bit) 0xA8412ABD15155415ULL, (u64bit) 0x9FB6EEE87777C177ULL, (u64bit) 0xA5EB6E923737DC37ULL, (u64bit) 0x7B56D79EE5E5B3E5ULL, +(u64bit) 0x8CD923139F9F469FULL, (u64bit) 0xD317FD23F0F0E7F0ULL, (u64bit) 0x6A7F94204A4A354AULL, (u64bit) 0x9E95A944DADA4FDAULL, +(u64bit) 0xFA25B0A258587D58ULL, (u64bit) 0x06CA8FCFC9C903C9ULL, (u64bit) 0x558D527C2929A429ULL, (u64bit) 0x5022145A0A0A280AULL, +(u64bit) 0xE14F7F50B1B1FEB1ULL, (u64bit) 0x691A5DC9A0A0BAA0ULL, (u64bit) 0x7FDAD6146B6BB16BULL, (u64bit) 0x5CAB17D985852E85ULL, +(u64bit) 0x8173673CBDBDCEBDULL, (u64bit) 0xD234BA8F5D5D695DULL, (u64bit) 0x8050209010104010ULL, (u64bit) 0xF303F507F4F4F7F4ULL, +(u64bit) 0x16C08BDDCBCB0BCBULL, (u64bit) 0xEDC67CD33E3EF83EULL, (u64bit) 0x28110A2D05051405ULL, (u64bit) 0x1FE6CE7867678167ULL, +(u64bit) 0x7353D597E4E4B7E4ULL, (u64bit) 0x25BB4E0227279C27ULL, (u64bit) 0x3258827341411941ULL, (u64bit) 0x2C9D0BA78B8B168BULL, +(u64bit) 0x510153F6A7A7A6A7ULL, (u64bit) 0xCF94FAB27D7DE97DULL, (u64bit) 0xDCFB374995956E95ULL, (u64bit) 0x8E9FAD56D8D847D8ULL, +(u64bit) 0x8B30EB70FBFBCBFBULL, (u64bit) 0x2371C1CDEEEE9FEEULL, (u64bit) 0xC791F8BB7C7CED7CULL, (u64bit) 0x17E3CC7166668566ULL, +(u64bit) 0xA68EA77BDDDD53DDULL, (u64bit) 0xB84B2EAF17175C17ULL, (u64bit) 0x02468E4547470147ULL, (u64bit) 0x84DC211A9E9E429EULL, +(u64bit) 0x1EC589D4CACA0FCAULL, (u64bit) 0x75995A582D2DB42DULL, (u64bit) 0x9179632EBFBFC6BFULL, (u64bit) 0x381B0E3F07071C07ULL, +(u64bit) 0x012347ACADAD8EADULL, (u64bit) 0xEA2FB4B05A5A755AULL, (u64bit) 0x6CB51BEF83833683ULL, (u64bit) 0x85FF66B63333CC33ULL, +(u64bit) 0x3FF2C65C63639163ULL, (u64bit) 0x100A041202020802ULL, (u64bit) 0x39384993AAAA92AAULL, (u64bit) 0xAFA8E2DE7171D971ULL, +(u64bit) 0x0ECF8DC6C8C807C8ULL, (u64bit) 0xC87D32D119196419ULL, (u64bit) 0x7270923B49493949ULL, (u64bit) 0x869AAF5FD9D943D9ULL, +(u64bit) 0xC31DF931F2F2EFF2ULL, (u64bit) 0x4B48DBA8E3E3ABE3ULL, (u64bit) 0xE22AB6B95B5B715BULL, (u64bit) 0x34920DBC88881A88ULL, +(u64bit) 0xA4C8293E9A9A529AULL, (u64bit) 0x2DBE4C0B26269826ULL, (u64bit) 0x8DFA64BF3232C832ULL, (u64bit) 0xE94A7D59B0B0FAB0ULL, +(u64bit) 0x1B6ACFF2E9E983E9ULL, (u64bit) 0x78331E770F0F3C0FULL, (u64bit) 0xE6A6B733D5D573D5ULL, (u64bit) 0x74BA1DF480803A80ULL, +(u64bit) 0x997C6127BEBEC2BEULL, (u64bit) 0x26DE87EBCDCD13CDULL, (u64bit) 0xBDE468893434D034ULL, (u64bit) 0x7A75903248483D48ULL, +(u64bit) 0xAB24E354FFFFDBFFULL, (u64bit) 0xF78FF48D7A7AF57AULL, (u64bit) 0xF4EA3D6490907A90ULL, (u64bit) 0xC23EBE9D5F5F615FULL, +(u64bit) 0x1DA0403D20208020ULL, (u64bit) 0x67D5D00F6868BD68ULL, (u64bit) 0xD07234CA1A1A681AULL, (u64bit) 0x192C41B7AEAE82AEULL, +(u64bit) 0xC95E757DB4B4EAB4ULL, (u64bit) 0x9A19A8CE54544D54ULL, (u64bit) 0xECE53B7F93937693ULL, (u64bit) 0x0DAA442F22228822ULL, +(u64bit) 0x07E9C86364648D64ULL, (u64bit) 0xDB12FF2AF1F1E3F1ULL, (u64bit) 0xBFA2E6CC7373D173ULL, (u64bit) 0x905A248212124812ULL, +(u64bit) 0x3A5D807A40401D40ULL, (u64bit) 0x4028104808082008ULL, (u64bit) 0x56E89B95C3C32BC3ULL, (u64bit) 0x337BC5DFECEC97ECULL, +(u64bit) 0x9690AB4DDBDB4BDBULL, (u64bit) 0x611F5FC0A1A1BEA1ULL, (u64bit) 0x1C8307918D8D0E8DULL, (u64bit) 0xF5C97AC83D3DF43DULL, +(u64bit) 0xCCF1335B97976697ULL, (u64bit) 0x0000000000000000ULL, (u64bit) 0x36D483F9CFCF1BCFULL, (u64bit) 0x4587566E2B2BAC2BULL, +(u64bit) 0x97B3ECE17676C576ULL, (u64bit) 0x64B019E682823282ULL, (u64bit) 0xFEA9B128D6D67FD6ULL, (u64bit) 0xD87736C31B1B6C1BULL, +(u64bit) 0xC15B7774B5B5EEB5ULL, (u64bit) 0x112943BEAFAF86AFULL, (u64bit) 0x77DFD41D6A6AB56AULL, (u64bit) 0xBA0DA0EA50505D50ULL, +(u64bit) 0x124C8A5745450945ULL, (u64bit) 0xCB18FB38F3F3EBF3ULL, (u64bit) 0x9DF060AD3030C030ULL, (u64bit) 0x2B74C3C4EFEF9BEFULL, +(u64bit) 0xE5C37EDA3F3FFC3FULL, (u64bit) 0x921CAAC755554955ULL, (u64bit) 0x791059DBA2A2B2A2ULL, (u64bit) 0x0365C9E9EAEA8FEAULL, +(u64bit) 0x0FECCA6A65658965ULL, (u64bit) 0xB9686903BABAD2BAULL, (u64bit) 0x65935E4A2F2FBC2FULL, (u64bit) 0x4EE79D8EC0C027C0ULL, +(u64bit) 0xBE81A160DEDE5FDEULL, (u64bit) 0xE06C38FC1C1C701CULL, (u64bit) 0xBB2EE746FDFDD3FDULL, (u64bit) 0x52649A1F4D4D294DULL, +(u64bit) 0xE4E0397692927292ULL, (u64bit) 0x8FBCEAFA7575C975ULL, (u64bit) 0x301E0C3606061806ULL, (u64bit) 0x249809AE8A8A128AULL, +(u64bit) 0xF940794BB2B2F2B2ULL, (u64bit) 0x6359D185E6E6BFE6ULL, (u64bit) 0x70361C7E0E0E380EULL, (u64bit) 0xF8633EE71F1F7C1FULL, +(u64bit) 0x37F7C45562629562ULL, (u64bit) 0xEEA3B53AD4D477D4ULL, (u64bit) 0x29324D81A8A89AA8ULL, (u64bit) 0xC4F4315296966296ULL, +(u64bit) 0x9B3AEF62F9F9C3F9ULL, (u64bit) 0x66F697A3C5C533C5ULL, (u64bit) 0x35B14A1025259425ULL, (u64bit) 0xF220B2AB59597959ULL, +(u64bit) 0x54AE15D084842A84ULL, (u64bit) 0xB7A7E4C57272D572ULL, (u64bit) 0xD5DD72EC3939E439ULL, (u64bit) 0x5A6198164C4C2D4CULL, +(u64bit) 0xCA3BBC945E5E655EULL, (u64bit) 0xE785F09F7878FD78ULL, (u64bit) 0xDDD870E53838E038ULL, (u64bit) 0x148605988C8C0A8CULL, +(u64bit) 0xC6B2BF17D1D163D1ULL, (u64bit) 0x410B57E4A5A5AEA5ULL, (u64bit) 0x434DD9A1E2E2AFE2ULL, (u64bit) 0x2FF8C24E61619961ULL, +(u64bit) 0xF1457B42B3B3F6B3ULL, (u64bit) 0x15A5423421218421ULL, (u64bit) 0x94D625089C9C4A9CULL, (u64bit) 0xF0663CEE1E1E781EULL, +(u64bit) 0x2252866143431143ULL, (u64bit) 0x76FC93B1C7C73BC7ULL, (u64bit) 0xB32BE54FFCFCD7FCULL, (u64bit) 0x2014082404041004ULL, +(u64bit) 0xB208A2E351515951ULL, (u64bit) 0xBCC72F2599995E99ULL, (u64bit) 0x4FC4DA226D6DA96DULL, (u64bit) 0x68391A650D0D340DULL, +(u64bit) 0x8335E979FAFACFFAULL, (u64bit) 0xB684A369DFDF5BDFULL, (u64bit) 0xD79BFCA97E7EE57EULL, (u64bit) 0x3DB4481924249024ULL, +(u64bit) 0xC5D776FE3B3BEC3BULL, (u64bit) 0x313D4B9AABAB96ABULL, (u64bit) 0x3ED181F0CECE1FCEULL, (u64bit) 0x8855229911114411ULL, +(u64bit) 0x0C8903838F8F068FULL, (u64bit) 0x4A6B9C044E4E254EULL, (u64bit) 0xD1517366B7B7E6B7ULL, (u64bit) 0x0B60CBE0EBEB8BEBULL, +(u64bit) 0xFDCC78C13C3CF03CULL, (u64bit) 0x7CBF1FFD81813E81ULL, (u64bit) 0xD4FE354094946A94ULL, (u64bit) 0xEB0CF31CF7F7FBF7ULL, +(u64bit) 0xA1676F18B9B9DEB9ULL, (u64bit) 0x985F268B13134C13ULL, (u64bit) 0x7D9C58512C2CB02CULL, (u64bit) 0xD6B8BB05D3D36BD3ULL, +(u64bit) 0x6B5CD38CE7E7BBE7ULL, (u64bit) 0x57CBDC396E6EA56EULL, (u64bit) 0x6EF395AAC4C437C4ULL, (u64bit) 0x180F061B03030C03ULL, +(u64bit) 0x8A13ACDC56564556ULL, (u64bit) 0x1A49885E44440D44ULL, (u64bit) 0xDF9EFEA07F7FE17FULL, (u64bit) 0x21374F88A9A99EA9ULL, +(u64bit) 0x4D8254672A2AA82AULL, (u64bit) 0xB16D6B0ABBBBD6BBULL, (u64bit) 0x46E29F87C1C123C1ULL, (u64bit) 0xA202A6F153535153ULL, +(u64bit) 0xAE8BA572DCDC57DCULL, (u64bit) 0x582716530B0B2C0BULL, (u64bit) 0x9CD327019D9D4E9DULL, (u64bit) 0x47C1D82B6C6CAD6CULL, +(u64bit) 0x95F562A43131C431ULL, (u64bit) 0x87B9E8F37474CD74ULL, (u64bit) 0xE309F115F6F6FFF6ULL, (u64bit) 0x0A438C4C46460546ULL, +(u64bit) 0x092645A5ACAC8AACULL, (u64bit) 0x3C970FB589891E89ULL, (u64bit) 0xA04428B414145014ULL, (u64bit) 0x5B42DFBAE1E1A3E1ULL, +(u64bit) 0xB04E2CA616165816ULL, (u64bit) 0xCDD274F73A3AE83AULL, (u64bit) 0x6FD0D2066969B969ULL, (u64bit) 0x482D124109092409ULL, +(u64bit) 0xA7ADE0D77070DD70ULL, (u64bit) 0xD954716FB6B6E2B6ULL, (u64bit) 0xCEB7BD1ED0D067D0ULL, (u64bit) 0x3B7EC7D6EDED93EDULL, +(u64bit) 0x2EDB85E2CCCC17CCULL, (u64bit) 0x2A57846842421542ULL, (u64bit) 0xB4C22D2C98985A98ULL, (u64bit) 0x490E55EDA4A4AAA4ULL, +(u64bit) 0x5D8850752828A028ULL, (u64bit) 0xDA31B8865C5C6D5CULL, (u64bit) 0x933FED6BF8F8C7F8ULL, (u64bit) 0x44A411C286862286ULL }; + +const u64bit Whirlpool::C5[256] = { +(u64bit) 0x18C07830D8181860ULL, (u64bit) 0x2305AF462623238CULL, (u64bit) 0xC67EF991B8C6C63FULL, (u64bit) 0xE8136FCDFBE8E887ULL, +(u64bit) 0x874CA113CB878726ULL, (u64bit) 0xB8A9626D11B8B8DAULL, (u64bit) 0x0108050209010104ULL, (u64bit) 0x4F426E9E0D4F4F21ULL, +(u64bit) 0x36ADEE6C9B3636D8ULL, (u64bit) 0xA6590451FFA6A6A2ULL, (u64bit) 0xD2DEBDB90CD2D26FULL, (u64bit) 0xF5FB06F70EF5F5F3ULL, +(u64bit) 0x79EF80F2967979F9ULL, (u64bit) 0x6F5FCEDE306F6FA1ULL, (u64bit) 0x91FCEF3F6D91917EULL, (u64bit) 0x52AA07A4F8525255ULL, +(u64bit) 0x6027FDC04760609DULL, (u64bit) 0xBC89766535BCBCCAULL, (u64bit) 0x9BACCD2B379B9B56ULL, (u64bit) 0x8E048C018A8E8E02ULL, +(u64bit) 0xA371155BD2A3A3B6ULL, (u64bit) 0x0C603C186C0C0C30ULL, (u64bit) 0x7BFF8AF6847B7BF1ULL, (u64bit) 0x35B5E16A803535D4ULL, +(u64bit) 0x1DE8693AF51D1D74ULL, (u64bit) 0xE05347DDB3E0E0A7ULL, (u64bit) 0xD7F6ACB321D7D77BULL, (u64bit) 0xC25EED999CC2C22FULL, +(u64bit) 0x2E6D965C432E2EB8ULL, (u64bit) 0x4B627A96294B4B31ULL, (u64bit) 0xFEA321E15DFEFEDFULL, (u64bit) 0x578216AED5575741ULL, +(u64bit) 0x15A8412ABD151554ULL, (u64bit) 0x779FB6EEE87777C1ULL, (u64bit) 0x37A5EB6E923737DCULL, (u64bit) 0xE57B56D79EE5E5B3ULL, +(u64bit) 0x9F8CD923139F9F46ULL, (u64bit) 0xF0D317FD23F0F0E7ULL, (u64bit) 0x4A6A7F94204A4A35ULL, (u64bit) 0xDA9E95A944DADA4FULL, +(u64bit) 0x58FA25B0A258587DULL, (u64bit) 0xC906CA8FCFC9C903ULL, (u64bit) 0x29558D527C2929A4ULL, (u64bit) 0x0A5022145A0A0A28ULL, +(u64bit) 0xB1E14F7F50B1B1FEULL, (u64bit) 0xA0691A5DC9A0A0BAULL, (u64bit) 0x6B7FDAD6146B6BB1ULL, (u64bit) 0x855CAB17D985852EULL, +(u64bit) 0xBD8173673CBDBDCEULL, (u64bit) 0x5DD234BA8F5D5D69ULL, (u64bit) 0x1080502090101040ULL, (u64bit) 0xF4F303F507F4F4F7ULL, +(u64bit) 0xCB16C08BDDCBCB0BULL, (u64bit) 0x3EEDC67CD33E3EF8ULL, (u64bit) 0x0528110A2D050514ULL, (u64bit) 0x671FE6CE78676781ULL, +(u64bit) 0xE47353D597E4E4B7ULL, (u64bit) 0x2725BB4E0227279CULL, (u64bit) 0x4132588273414119ULL, (u64bit) 0x8B2C9D0BA78B8B16ULL, +(u64bit) 0xA7510153F6A7A7A6ULL, (u64bit) 0x7DCF94FAB27D7DE9ULL, (u64bit) 0x95DCFB374995956EULL, (u64bit) 0xD88E9FAD56D8D847ULL, +(u64bit) 0xFB8B30EB70FBFBCBULL, (u64bit) 0xEE2371C1CDEEEE9FULL, (u64bit) 0x7CC791F8BB7C7CEDULL, (u64bit) 0x6617E3CC71666685ULL, +(u64bit) 0xDDA68EA77BDDDD53ULL, (u64bit) 0x17B84B2EAF17175CULL, (u64bit) 0x4702468E45474701ULL, (u64bit) 0x9E84DC211A9E9E42ULL, +(u64bit) 0xCA1EC589D4CACA0FULL, (u64bit) 0x2D75995A582D2DB4ULL, (u64bit) 0xBF9179632EBFBFC6ULL, (u64bit) 0x07381B0E3F07071CULL, +(u64bit) 0xAD012347ACADAD8EULL, (u64bit) 0x5AEA2FB4B05A5A75ULL, (u64bit) 0x836CB51BEF838336ULL, (u64bit) 0x3385FF66B63333CCULL, +(u64bit) 0x633FF2C65C636391ULL, (u64bit) 0x02100A0412020208ULL, (u64bit) 0xAA39384993AAAA92ULL, (u64bit) 0x71AFA8E2DE7171D9ULL, +(u64bit) 0xC80ECF8DC6C8C807ULL, (u64bit) 0x19C87D32D1191964ULL, (u64bit) 0x497270923B494939ULL, (u64bit) 0xD9869AAF5FD9D943ULL, +(u64bit) 0xF2C31DF931F2F2EFULL, (u64bit) 0xE34B48DBA8E3E3ABULL, (u64bit) 0x5BE22AB6B95B5B71ULL, (u64bit) 0x8834920DBC88881AULL, +(u64bit) 0x9AA4C8293E9A9A52ULL, (u64bit) 0x262DBE4C0B262698ULL, (u64bit) 0x328DFA64BF3232C8ULL, (u64bit) 0xB0E94A7D59B0B0FAULL, +(u64bit) 0xE91B6ACFF2E9E983ULL, (u64bit) 0x0F78331E770F0F3CULL, (u64bit) 0xD5E6A6B733D5D573ULL, (u64bit) 0x8074BA1DF480803AULL, +(u64bit) 0xBE997C6127BEBEC2ULL, (u64bit) 0xCD26DE87EBCDCD13ULL, (u64bit) 0x34BDE468893434D0ULL, (u64bit) 0x487A75903248483DULL, +(u64bit) 0xFFAB24E354FFFFDBULL, (u64bit) 0x7AF78FF48D7A7AF5ULL, (u64bit) 0x90F4EA3D6490907AULL, (u64bit) 0x5FC23EBE9D5F5F61ULL, +(u64bit) 0x201DA0403D202080ULL, (u64bit) 0x6867D5D00F6868BDULL, (u64bit) 0x1AD07234CA1A1A68ULL, (u64bit) 0xAE192C41B7AEAE82ULL, +(u64bit) 0xB4C95E757DB4B4EAULL, (u64bit) 0x549A19A8CE54544DULL, (u64bit) 0x93ECE53B7F939376ULL, (u64bit) 0x220DAA442F222288ULL, +(u64bit) 0x6407E9C86364648DULL, (u64bit) 0xF1DB12FF2AF1F1E3ULL, (u64bit) 0x73BFA2E6CC7373D1ULL, (u64bit) 0x12905A2482121248ULL, +(u64bit) 0x403A5D807A40401DULL, (u64bit) 0x0840281048080820ULL, (u64bit) 0xC356E89B95C3C32BULL, (u64bit) 0xEC337BC5DFECEC97ULL, +(u64bit) 0xDB9690AB4DDBDB4BULL, (u64bit) 0xA1611F5FC0A1A1BEULL, (u64bit) 0x8D1C8307918D8D0EULL, (u64bit) 0x3DF5C97AC83D3DF4ULL, +(u64bit) 0x97CCF1335B979766ULL, (u64bit) 0x0000000000000000ULL, (u64bit) 0xCF36D483F9CFCF1BULL, (u64bit) 0x2B4587566E2B2BACULL, +(u64bit) 0x7697B3ECE17676C5ULL, (u64bit) 0x8264B019E6828232ULL, (u64bit) 0xD6FEA9B128D6D67FULL, (u64bit) 0x1BD87736C31B1B6CULL, +(u64bit) 0xB5C15B7774B5B5EEULL, (u64bit) 0xAF112943BEAFAF86ULL, (u64bit) 0x6A77DFD41D6A6AB5ULL, (u64bit) 0x50BA0DA0EA50505DULL, +(u64bit) 0x45124C8A57454509ULL, (u64bit) 0xF3CB18FB38F3F3EBULL, (u64bit) 0x309DF060AD3030C0ULL, (u64bit) 0xEF2B74C3C4EFEF9BULL, +(u64bit) 0x3FE5C37EDA3F3FFCULL, (u64bit) 0x55921CAAC7555549ULL, (u64bit) 0xA2791059DBA2A2B2ULL, (u64bit) 0xEA0365C9E9EAEA8FULL, +(u64bit) 0x650FECCA6A656589ULL, (u64bit) 0xBAB9686903BABAD2ULL, (u64bit) 0x2F65935E4A2F2FBCULL, (u64bit) 0xC04EE79D8EC0C027ULL, +(u64bit) 0xDEBE81A160DEDE5FULL, (u64bit) 0x1CE06C38FC1C1C70ULL, (u64bit) 0xFDBB2EE746FDFDD3ULL, (u64bit) 0x4D52649A1F4D4D29ULL, +(u64bit) 0x92E4E03976929272ULL, (u64bit) 0x758FBCEAFA7575C9ULL, (u64bit) 0x06301E0C36060618ULL, (u64bit) 0x8A249809AE8A8A12ULL, +(u64bit) 0xB2F940794BB2B2F2ULL, (u64bit) 0xE66359D185E6E6BFULL, (u64bit) 0x0E70361C7E0E0E38ULL, (u64bit) 0x1FF8633EE71F1F7CULL, +(u64bit) 0x6237F7C455626295ULL, (u64bit) 0xD4EEA3B53AD4D477ULL, (u64bit) 0xA829324D81A8A89AULL, (u64bit) 0x96C4F43152969662ULL, +(u64bit) 0xF99B3AEF62F9F9C3ULL, (u64bit) 0xC566F697A3C5C533ULL, (u64bit) 0x2535B14A10252594ULL, (u64bit) 0x59F220B2AB595979ULL, +(u64bit) 0x8454AE15D084842AULL, (u64bit) 0x72B7A7E4C57272D5ULL, (u64bit) 0x39D5DD72EC3939E4ULL, (u64bit) 0x4C5A6198164C4C2DULL, +(u64bit) 0x5ECA3BBC945E5E65ULL, (u64bit) 0x78E785F09F7878FDULL, (u64bit) 0x38DDD870E53838E0ULL, (u64bit) 0x8C148605988C8C0AULL, +(u64bit) 0xD1C6B2BF17D1D163ULL, (u64bit) 0xA5410B57E4A5A5AEULL, (u64bit) 0xE2434DD9A1E2E2AFULL, (u64bit) 0x612FF8C24E616199ULL, +(u64bit) 0xB3F1457B42B3B3F6ULL, (u64bit) 0x2115A54234212184ULL, (u64bit) 0x9C94D625089C9C4AULL, (u64bit) 0x1EF0663CEE1E1E78ULL, +(u64bit) 0x4322528661434311ULL, (u64bit) 0xC776FC93B1C7C73BULL, (u64bit) 0xFCB32BE54FFCFCD7ULL, (u64bit) 0x0420140824040410ULL, +(u64bit) 0x51B208A2E3515159ULL, (u64bit) 0x99BCC72F2599995EULL, (u64bit) 0x6D4FC4DA226D6DA9ULL, (u64bit) 0x0D68391A650D0D34ULL, +(u64bit) 0xFA8335E979FAFACFULL, (u64bit) 0xDFB684A369DFDF5BULL, (u64bit) 0x7ED79BFCA97E7EE5ULL, (u64bit) 0x243DB44819242490ULL, +(u64bit) 0x3BC5D776FE3B3BECULL, (u64bit) 0xAB313D4B9AABAB96ULL, (u64bit) 0xCE3ED181F0CECE1FULL, (u64bit) 0x1188552299111144ULL, +(u64bit) 0x8F0C8903838F8F06ULL, (u64bit) 0x4E4A6B9C044E4E25ULL, (u64bit) 0xB7D1517366B7B7E6ULL, (u64bit) 0xEB0B60CBE0EBEB8BULL, +(u64bit) 0x3CFDCC78C13C3CF0ULL, (u64bit) 0x817CBF1FFD81813EULL, (u64bit) 0x94D4FE354094946AULL, (u64bit) 0xF7EB0CF31CF7F7FBULL, +(u64bit) 0xB9A1676F18B9B9DEULL, (u64bit) 0x13985F268B13134CULL, (u64bit) 0x2C7D9C58512C2CB0ULL, (u64bit) 0xD3D6B8BB05D3D36BULL, +(u64bit) 0xE76B5CD38CE7E7BBULL, (u64bit) 0x6E57CBDC396E6EA5ULL, (u64bit) 0xC46EF395AAC4C437ULL, (u64bit) 0x03180F061B03030CULL, +(u64bit) 0x568A13ACDC565645ULL, (u64bit) 0x441A49885E44440DULL, (u64bit) 0x7FDF9EFEA07F7FE1ULL, (u64bit) 0xA921374F88A9A99EULL, +(u64bit) 0x2A4D8254672A2AA8ULL, (u64bit) 0xBBB16D6B0ABBBBD6ULL, (u64bit) 0xC146E29F87C1C123ULL, (u64bit) 0x53A202A6F1535351ULL, +(u64bit) 0xDCAE8BA572DCDC57ULL, (u64bit) 0x0B582716530B0B2CULL, (u64bit) 0x9D9CD327019D9D4EULL, (u64bit) 0x6C47C1D82B6C6CADULL, +(u64bit) 0x3195F562A43131C4ULL, (u64bit) 0x7487B9E8F37474CDULL, (u64bit) 0xF6E309F115F6F6FFULL, (u64bit) 0x460A438C4C464605ULL, +(u64bit) 0xAC092645A5ACAC8AULL, (u64bit) 0x893C970FB589891EULL, (u64bit) 0x14A04428B4141450ULL, (u64bit) 0xE15B42DFBAE1E1A3ULL, +(u64bit) 0x16B04E2CA6161658ULL, (u64bit) 0x3ACDD274F73A3AE8ULL, (u64bit) 0x696FD0D2066969B9ULL, (u64bit) 0x09482D1241090924ULL, +(u64bit) 0x70A7ADE0D77070DDULL, (u64bit) 0xB6D954716FB6B6E2ULL, (u64bit) 0xD0CEB7BD1ED0D067ULL, (u64bit) 0xED3B7EC7D6EDED93ULL, +(u64bit) 0xCC2EDB85E2CCCC17ULL, (u64bit) 0x422A578468424215ULL, (u64bit) 0x98B4C22D2C98985AULL, (u64bit) 0xA4490E55EDA4A4AAULL, +(u64bit) 0x285D8850752828A0ULL, (u64bit) 0x5CDA31B8865C5C6DULL, (u64bit) 0xF8933FED6BF8F8C7ULL, (u64bit) 0x8644A411C2868622ULL }; + +const u64bit Whirlpool::C6[256] = { +(u64bit) 0x6018C07830D81818ULL, (u64bit) 0x8C2305AF46262323ULL, (u64bit) 0x3FC67EF991B8C6C6ULL, (u64bit) 0x87E8136FCDFBE8E8ULL, +(u64bit) 0x26874CA113CB8787ULL, (u64bit) 0xDAB8A9626D11B8B8ULL, (u64bit) 0x0401080502090101ULL, (u64bit) 0x214F426E9E0D4F4FULL, +(u64bit) 0xD836ADEE6C9B3636ULL, (u64bit) 0xA2A6590451FFA6A6ULL, (u64bit) 0x6FD2DEBDB90CD2D2ULL, (u64bit) 0xF3F5FB06F70EF5F5ULL, +(u64bit) 0xF979EF80F2967979ULL, (u64bit) 0xA16F5FCEDE306F6FULL, (u64bit) 0x7E91FCEF3F6D9191ULL, (u64bit) 0x5552AA07A4F85252ULL, +(u64bit) 0x9D6027FDC0476060ULL, (u64bit) 0xCABC89766535BCBCULL, (u64bit) 0x569BACCD2B379B9BULL, (u64bit) 0x028E048C018A8E8EULL, +(u64bit) 0xB6A371155BD2A3A3ULL, (u64bit) 0x300C603C186C0C0CULL, (u64bit) 0xF17BFF8AF6847B7BULL, (u64bit) 0xD435B5E16A803535ULL, +(u64bit) 0x741DE8693AF51D1DULL, (u64bit) 0xA7E05347DDB3E0E0ULL, (u64bit) 0x7BD7F6ACB321D7D7ULL, (u64bit) 0x2FC25EED999CC2C2ULL, +(u64bit) 0xB82E6D965C432E2EULL, (u64bit) 0x314B627A96294B4BULL, (u64bit) 0xDFFEA321E15DFEFEULL, (u64bit) 0x41578216AED55757ULL, +(u64bit) 0x5415A8412ABD1515ULL, (u64bit) 0xC1779FB6EEE87777ULL, (u64bit) 0xDC37A5EB6E923737ULL, (u64bit) 0xB3E57B56D79EE5E5ULL, +(u64bit) 0x469F8CD923139F9FULL, (u64bit) 0xE7F0D317FD23F0F0ULL, (u64bit) 0x354A6A7F94204A4AULL, (u64bit) 0x4FDA9E95A944DADAULL, +(u64bit) 0x7D58FA25B0A25858ULL, (u64bit) 0x03C906CA8FCFC9C9ULL, (u64bit) 0xA429558D527C2929ULL, (u64bit) 0x280A5022145A0A0AULL, +(u64bit) 0xFEB1E14F7F50B1B1ULL, (u64bit) 0xBAA0691A5DC9A0A0ULL, (u64bit) 0xB16B7FDAD6146B6BULL, (u64bit) 0x2E855CAB17D98585ULL, +(u64bit) 0xCEBD8173673CBDBDULL, (u64bit) 0x695DD234BA8F5D5DULL, (u64bit) 0x4010805020901010ULL, (u64bit) 0xF7F4F303F507F4F4ULL, +(u64bit) 0x0BCB16C08BDDCBCBULL, (u64bit) 0xF83EEDC67CD33E3EULL, (u64bit) 0x140528110A2D0505ULL, (u64bit) 0x81671FE6CE786767ULL, +(u64bit) 0xB7E47353D597E4E4ULL, (u64bit) 0x9C2725BB4E022727ULL, (u64bit) 0x1941325882734141ULL, (u64bit) 0x168B2C9D0BA78B8BULL, +(u64bit) 0xA6A7510153F6A7A7ULL, (u64bit) 0xE97DCF94FAB27D7DULL, (u64bit) 0x6E95DCFB37499595ULL, (u64bit) 0x47D88E9FAD56D8D8ULL, +(u64bit) 0xCBFB8B30EB70FBFBULL, (u64bit) 0x9FEE2371C1CDEEEEULL, (u64bit) 0xED7CC791F8BB7C7CULL, (u64bit) 0x856617E3CC716666ULL, +(u64bit) 0x53DDA68EA77BDDDDULL, (u64bit) 0x5C17B84B2EAF1717ULL, (u64bit) 0x014702468E454747ULL, (u64bit) 0x429E84DC211A9E9EULL, +(u64bit) 0x0FCA1EC589D4CACAULL, (u64bit) 0xB42D75995A582D2DULL, (u64bit) 0xC6BF9179632EBFBFULL, (u64bit) 0x1C07381B0E3F0707ULL, +(u64bit) 0x8EAD012347ACADADULL, (u64bit) 0x755AEA2FB4B05A5AULL, (u64bit) 0x36836CB51BEF8383ULL, (u64bit) 0xCC3385FF66B63333ULL, +(u64bit) 0x91633FF2C65C6363ULL, (u64bit) 0x0802100A04120202ULL, (u64bit) 0x92AA39384993AAAAULL, (u64bit) 0xD971AFA8E2DE7171ULL, +(u64bit) 0x07C80ECF8DC6C8C8ULL, (u64bit) 0x6419C87D32D11919ULL, (u64bit) 0x39497270923B4949ULL, (u64bit) 0x43D9869AAF5FD9D9ULL, +(u64bit) 0xEFF2C31DF931F2F2ULL, (u64bit) 0xABE34B48DBA8E3E3ULL, (u64bit) 0x715BE22AB6B95B5BULL, (u64bit) 0x1A8834920DBC8888ULL, +(u64bit) 0x529AA4C8293E9A9AULL, (u64bit) 0x98262DBE4C0B2626ULL, (u64bit) 0xC8328DFA64BF3232ULL, (u64bit) 0xFAB0E94A7D59B0B0ULL, +(u64bit) 0x83E91B6ACFF2E9E9ULL, (u64bit) 0x3C0F78331E770F0FULL, (u64bit) 0x73D5E6A6B733D5D5ULL, (u64bit) 0x3A8074BA1DF48080ULL, +(u64bit) 0xC2BE997C6127BEBEULL, (u64bit) 0x13CD26DE87EBCDCDULL, (u64bit) 0xD034BDE468893434ULL, (u64bit) 0x3D487A7590324848ULL, +(u64bit) 0xDBFFAB24E354FFFFULL, (u64bit) 0xF57AF78FF48D7A7AULL, (u64bit) 0x7A90F4EA3D649090ULL, (u64bit) 0x615FC23EBE9D5F5FULL, +(u64bit) 0x80201DA0403D2020ULL, (u64bit) 0xBD6867D5D00F6868ULL, (u64bit) 0x681AD07234CA1A1AULL, (u64bit) 0x82AE192C41B7AEAEULL, +(u64bit) 0xEAB4C95E757DB4B4ULL, (u64bit) 0x4D549A19A8CE5454ULL, (u64bit) 0x7693ECE53B7F9393ULL, (u64bit) 0x88220DAA442F2222ULL, +(u64bit) 0x8D6407E9C8636464ULL, (u64bit) 0xE3F1DB12FF2AF1F1ULL, (u64bit) 0xD173BFA2E6CC7373ULL, (u64bit) 0x4812905A24821212ULL, +(u64bit) 0x1D403A5D807A4040ULL, (u64bit) 0x2008402810480808ULL, (u64bit) 0x2BC356E89B95C3C3ULL, (u64bit) 0x97EC337BC5DFECECULL, +(u64bit) 0x4BDB9690AB4DDBDBULL, (u64bit) 0xBEA1611F5FC0A1A1ULL, (u64bit) 0x0E8D1C8307918D8DULL, (u64bit) 0xF43DF5C97AC83D3DULL, +(u64bit) 0x6697CCF1335B9797ULL, (u64bit) 0x0000000000000000ULL, (u64bit) 0x1BCF36D483F9CFCFULL, (u64bit) 0xAC2B4587566E2B2BULL, +(u64bit) 0xC57697B3ECE17676ULL, (u64bit) 0x328264B019E68282ULL, (u64bit) 0x7FD6FEA9B128D6D6ULL, (u64bit) 0x6C1BD87736C31B1BULL, +(u64bit) 0xEEB5C15B7774B5B5ULL, (u64bit) 0x86AF112943BEAFAFULL, (u64bit) 0xB56A77DFD41D6A6AULL, (u64bit) 0x5D50BA0DA0EA5050ULL, +(u64bit) 0x0945124C8A574545ULL, (u64bit) 0xEBF3CB18FB38F3F3ULL, (u64bit) 0xC0309DF060AD3030ULL, (u64bit) 0x9BEF2B74C3C4EFEFULL, +(u64bit) 0xFC3FE5C37EDA3F3FULL, (u64bit) 0x4955921CAAC75555ULL, (u64bit) 0xB2A2791059DBA2A2ULL, (u64bit) 0x8FEA0365C9E9EAEAULL, +(u64bit) 0x89650FECCA6A6565ULL, (u64bit) 0xD2BAB9686903BABAULL, (u64bit) 0xBC2F65935E4A2F2FULL, (u64bit) 0x27C04EE79D8EC0C0ULL, +(u64bit) 0x5FDEBE81A160DEDEULL, (u64bit) 0x701CE06C38FC1C1CULL, (u64bit) 0xD3FDBB2EE746FDFDULL, (u64bit) 0x294D52649A1F4D4DULL, +(u64bit) 0x7292E4E039769292ULL, (u64bit) 0xC9758FBCEAFA7575ULL, (u64bit) 0x1806301E0C360606ULL, (u64bit) 0x128A249809AE8A8AULL, +(u64bit) 0xF2B2F940794BB2B2ULL, (u64bit) 0xBFE66359D185E6E6ULL, (u64bit) 0x380E70361C7E0E0EULL, (u64bit) 0x7C1FF8633EE71F1FULL, +(u64bit) 0x956237F7C4556262ULL, (u64bit) 0x77D4EEA3B53AD4D4ULL, (u64bit) 0x9AA829324D81A8A8ULL, (u64bit) 0x6296C4F431529696ULL, +(u64bit) 0xC3F99B3AEF62F9F9ULL, (u64bit) 0x33C566F697A3C5C5ULL, (u64bit) 0x942535B14A102525ULL, (u64bit) 0x7959F220B2AB5959ULL, +(u64bit) 0x2A8454AE15D08484ULL, (u64bit) 0xD572B7A7E4C57272ULL, (u64bit) 0xE439D5DD72EC3939ULL, (u64bit) 0x2D4C5A6198164C4CULL, +(u64bit) 0x655ECA3BBC945E5EULL, (u64bit) 0xFD78E785F09F7878ULL, (u64bit) 0xE038DDD870E53838ULL, (u64bit) 0x0A8C148605988C8CULL, +(u64bit) 0x63D1C6B2BF17D1D1ULL, (u64bit) 0xAEA5410B57E4A5A5ULL, (u64bit) 0xAFE2434DD9A1E2E2ULL, (u64bit) 0x99612FF8C24E6161ULL, +(u64bit) 0xF6B3F1457B42B3B3ULL, (u64bit) 0x842115A542342121ULL, (u64bit) 0x4A9C94D625089C9CULL, (u64bit) 0x781EF0663CEE1E1EULL, +(u64bit) 0x1143225286614343ULL, (u64bit) 0x3BC776FC93B1C7C7ULL, (u64bit) 0xD7FCB32BE54FFCFCULL, (u64bit) 0x1004201408240404ULL, +(u64bit) 0x5951B208A2E35151ULL, (u64bit) 0x5E99BCC72F259999ULL, (u64bit) 0xA96D4FC4DA226D6DULL, (u64bit) 0x340D68391A650D0DULL, +(u64bit) 0xCFFA8335E979FAFAULL, (u64bit) 0x5BDFB684A369DFDFULL, (u64bit) 0xE57ED79BFCA97E7EULL, (u64bit) 0x90243DB448192424ULL, +(u64bit) 0xEC3BC5D776FE3B3BULL, (u64bit) 0x96AB313D4B9AABABULL, (u64bit) 0x1FCE3ED181F0CECEULL, (u64bit) 0x4411885522991111ULL, +(u64bit) 0x068F0C8903838F8FULL, (u64bit) 0x254E4A6B9C044E4EULL, (u64bit) 0xE6B7D1517366B7B7ULL, (u64bit) 0x8BEB0B60CBE0EBEBULL, +(u64bit) 0xF03CFDCC78C13C3CULL, (u64bit) 0x3E817CBF1FFD8181ULL, (u64bit) 0x6A94D4FE35409494ULL, (u64bit) 0xFBF7EB0CF31CF7F7ULL, +(u64bit) 0xDEB9A1676F18B9B9ULL, (u64bit) 0x4C13985F268B1313ULL, (u64bit) 0xB02C7D9C58512C2CULL, (u64bit) 0x6BD3D6B8BB05D3D3ULL, +(u64bit) 0xBBE76B5CD38CE7E7ULL, (u64bit) 0xA56E57CBDC396E6EULL, (u64bit) 0x37C46EF395AAC4C4ULL, (u64bit) 0x0C03180F061B0303ULL, +(u64bit) 0x45568A13ACDC5656ULL, (u64bit) 0x0D441A49885E4444ULL, (u64bit) 0xE17FDF9EFEA07F7FULL, (u64bit) 0x9EA921374F88A9A9ULL, +(u64bit) 0xA82A4D8254672A2AULL, (u64bit) 0xD6BBB16D6B0ABBBBULL, (u64bit) 0x23C146E29F87C1C1ULL, (u64bit) 0x5153A202A6F15353ULL, +(u64bit) 0x57DCAE8BA572DCDCULL, (u64bit) 0x2C0B582716530B0BULL, (u64bit) 0x4E9D9CD327019D9DULL, (u64bit) 0xAD6C47C1D82B6C6CULL, +(u64bit) 0xC43195F562A43131ULL, (u64bit) 0xCD7487B9E8F37474ULL, (u64bit) 0xFFF6E309F115F6F6ULL, (u64bit) 0x05460A438C4C4646ULL, +(u64bit) 0x8AAC092645A5ACACULL, (u64bit) 0x1E893C970FB58989ULL, (u64bit) 0x5014A04428B41414ULL, (u64bit) 0xA3E15B42DFBAE1E1ULL, +(u64bit) 0x5816B04E2CA61616ULL, (u64bit) 0xE83ACDD274F73A3AULL, (u64bit) 0xB9696FD0D2066969ULL, (u64bit) 0x2409482D12410909ULL, +(u64bit) 0xDD70A7ADE0D77070ULL, (u64bit) 0xE2B6D954716FB6B6ULL, (u64bit) 0x67D0CEB7BD1ED0D0ULL, (u64bit) 0x93ED3B7EC7D6EDEDULL, +(u64bit) 0x17CC2EDB85E2CCCCULL, (u64bit) 0x15422A5784684242ULL, (u64bit) 0x5A98B4C22D2C9898ULL, (u64bit) 0xAAA4490E55EDA4A4ULL, +(u64bit) 0xA0285D8850752828ULL, (u64bit) 0x6D5CDA31B8865C5CULL, (u64bit) 0xC7F8933FED6BF8F8ULL, (u64bit) 0x228644A411C28686ULL }; + +const u64bit Whirlpool::C7[256] = { +(u64bit) 0x186018C07830D818ULL, (u64bit) 0x238C2305AF462623ULL, (u64bit) 0xC63FC67EF991B8C6ULL, (u64bit) 0xE887E8136FCDFBE8ULL, +(u64bit) 0x8726874CA113CB87ULL, (u64bit) 0xB8DAB8A9626D11B8ULL, (u64bit) 0x0104010805020901ULL, (u64bit) 0x4F214F426E9E0D4FULL, +(u64bit) 0x36D836ADEE6C9B36ULL, (u64bit) 0xA6A2A6590451FFA6ULL, (u64bit) 0xD26FD2DEBDB90CD2ULL, (u64bit) 0xF5F3F5FB06F70EF5ULL, +(u64bit) 0x79F979EF80F29679ULL, (u64bit) 0x6FA16F5FCEDE306FULL, (u64bit) 0x917E91FCEF3F6D91ULL, (u64bit) 0x525552AA07A4F852ULL, +(u64bit) 0x609D6027FDC04760ULL, (u64bit) 0xBCCABC89766535BCULL, (u64bit) 0x9B569BACCD2B379BULL, (u64bit) 0x8E028E048C018A8EULL, +(u64bit) 0xA3B6A371155BD2A3ULL, (u64bit) 0x0C300C603C186C0CULL, (u64bit) 0x7BF17BFF8AF6847BULL, (u64bit) 0x35D435B5E16A8035ULL, +(u64bit) 0x1D741DE8693AF51DULL, (u64bit) 0xE0A7E05347DDB3E0ULL, (u64bit) 0xD77BD7F6ACB321D7ULL, (u64bit) 0xC22FC25EED999CC2ULL, +(u64bit) 0x2EB82E6D965C432EULL, (u64bit) 0x4B314B627A96294BULL, (u64bit) 0xFEDFFEA321E15DFEULL, (u64bit) 0x5741578216AED557ULL, +(u64bit) 0x155415A8412ABD15ULL, (u64bit) 0x77C1779FB6EEE877ULL, (u64bit) 0x37DC37A5EB6E9237ULL, (u64bit) 0xE5B3E57B56D79EE5ULL, +(u64bit) 0x9F469F8CD923139FULL, (u64bit) 0xF0E7F0D317FD23F0ULL, (u64bit) 0x4A354A6A7F94204AULL, (u64bit) 0xDA4FDA9E95A944DAULL, +(u64bit) 0x587D58FA25B0A258ULL, (u64bit) 0xC903C906CA8FCFC9ULL, (u64bit) 0x29A429558D527C29ULL, (u64bit) 0x0A280A5022145A0AULL, +(u64bit) 0xB1FEB1E14F7F50B1ULL, (u64bit) 0xA0BAA0691A5DC9A0ULL, (u64bit) 0x6BB16B7FDAD6146BULL, (u64bit) 0x852E855CAB17D985ULL, +(u64bit) 0xBDCEBD8173673CBDULL, (u64bit) 0x5D695DD234BA8F5DULL, (u64bit) 0x1040108050209010ULL, (u64bit) 0xF4F7F4F303F507F4ULL, +(u64bit) 0xCB0BCB16C08BDDCBULL, (u64bit) 0x3EF83EEDC67CD33EULL, (u64bit) 0x05140528110A2D05ULL, (u64bit) 0x6781671FE6CE7867ULL, +(u64bit) 0xE4B7E47353D597E4ULL, (u64bit) 0x279C2725BB4E0227ULL, (u64bit) 0x4119413258827341ULL, (u64bit) 0x8B168B2C9D0BA78BULL, +(u64bit) 0xA7A6A7510153F6A7ULL, (u64bit) 0x7DE97DCF94FAB27DULL, (u64bit) 0x956E95DCFB374995ULL, (u64bit) 0xD847D88E9FAD56D8ULL, +(u64bit) 0xFBCBFB8B30EB70FBULL, (u64bit) 0xEE9FEE2371C1CDEEULL, (u64bit) 0x7CED7CC791F8BB7CULL, (u64bit) 0x66856617E3CC7166ULL, +(u64bit) 0xDD53DDA68EA77BDDULL, (u64bit) 0x175C17B84B2EAF17ULL, (u64bit) 0x47014702468E4547ULL, (u64bit) 0x9E429E84DC211A9EULL, +(u64bit) 0xCA0FCA1EC589D4CAULL, (u64bit) 0x2DB42D75995A582DULL, (u64bit) 0xBFC6BF9179632EBFULL, (u64bit) 0x071C07381B0E3F07ULL, +(u64bit) 0xAD8EAD012347ACADULL, (u64bit) 0x5A755AEA2FB4B05AULL, (u64bit) 0x8336836CB51BEF83ULL, (u64bit) 0x33CC3385FF66B633ULL, +(u64bit) 0x6391633FF2C65C63ULL, (u64bit) 0x020802100A041202ULL, (u64bit) 0xAA92AA39384993AAULL, (u64bit) 0x71D971AFA8E2DE71ULL, +(u64bit) 0xC807C80ECF8DC6C8ULL, (u64bit) 0x196419C87D32D119ULL, (u64bit) 0x4939497270923B49ULL, (u64bit) 0xD943D9869AAF5FD9ULL, +(u64bit) 0xF2EFF2C31DF931F2ULL, (u64bit) 0xE3ABE34B48DBA8E3ULL, (u64bit) 0x5B715BE22AB6B95BULL, (u64bit) 0x881A8834920DBC88ULL, +(u64bit) 0x9A529AA4C8293E9AULL, (u64bit) 0x2698262DBE4C0B26ULL, (u64bit) 0x32C8328DFA64BF32ULL, (u64bit) 0xB0FAB0E94A7D59B0ULL, +(u64bit) 0xE983E91B6ACFF2E9ULL, (u64bit) 0x0F3C0F78331E770FULL, (u64bit) 0xD573D5E6A6B733D5ULL, (u64bit) 0x803A8074BA1DF480ULL, +(u64bit) 0xBEC2BE997C6127BEULL, (u64bit) 0xCD13CD26DE87EBCDULL, (u64bit) 0x34D034BDE4688934ULL, (u64bit) 0x483D487A75903248ULL, +(u64bit) 0xFFDBFFAB24E354FFULL, (u64bit) 0x7AF57AF78FF48D7AULL, (u64bit) 0x907A90F4EA3D6490ULL, (u64bit) 0x5F615FC23EBE9D5FULL, +(u64bit) 0x2080201DA0403D20ULL, (u64bit) 0x68BD6867D5D00F68ULL, (u64bit) 0x1A681AD07234CA1AULL, (u64bit) 0xAE82AE192C41B7AEULL, +(u64bit) 0xB4EAB4C95E757DB4ULL, (u64bit) 0x544D549A19A8CE54ULL, (u64bit) 0x937693ECE53B7F93ULL, (u64bit) 0x2288220DAA442F22ULL, +(u64bit) 0x648D6407E9C86364ULL, (u64bit) 0xF1E3F1DB12FF2AF1ULL, (u64bit) 0x73D173BFA2E6CC73ULL, (u64bit) 0x124812905A248212ULL, +(u64bit) 0x401D403A5D807A40ULL, (u64bit) 0x0820084028104808ULL, (u64bit) 0xC32BC356E89B95C3ULL, (u64bit) 0xEC97EC337BC5DFECULL, +(u64bit) 0xDB4BDB9690AB4DDBULL, (u64bit) 0xA1BEA1611F5FC0A1ULL, (u64bit) 0x8D0E8D1C8307918DULL, (u64bit) 0x3DF43DF5C97AC83DULL, +(u64bit) 0x976697CCF1335B97ULL, (u64bit) 0x0000000000000000ULL, (u64bit) 0xCF1BCF36D483F9CFULL, (u64bit) 0x2BAC2B4587566E2BULL, +(u64bit) 0x76C57697B3ECE176ULL, (u64bit) 0x82328264B019E682ULL, (u64bit) 0xD67FD6FEA9B128D6ULL, (u64bit) 0x1B6C1BD87736C31BULL, +(u64bit) 0xB5EEB5C15B7774B5ULL, (u64bit) 0xAF86AF112943BEAFULL, (u64bit) 0x6AB56A77DFD41D6AULL, (u64bit) 0x505D50BA0DA0EA50ULL, +(u64bit) 0x450945124C8A5745ULL, (u64bit) 0xF3EBF3CB18FB38F3ULL, (u64bit) 0x30C0309DF060AD30ULL, (u64bit) 0xEF9BEF2B74C3C4EFULL, +(u64bit) 0x3FFC3FE5C37EDA3FULL, (u64bit) 0x554955921CAAC755ULL, (u64bit) 0xA2B2A2791059DBA2ULL, (u64bit) 0xEA8FEA0365C9E9EAULL, +(u64bit) 0x6589650FECCA6A65ULL, (u64bit) 0xBAD2BAB9686903BAULL, (u64bit) 0x2FBC2F65935E4A2FULL, (u64bit) 0xC027C04EE79D8EC0ULL, +(u64bit) 0xDE5FDEBE81A160DEULL, (u64bit) 0x1C701CE06C38FC1CULL, (u64bit) 0xFDD3FDBB2EE746FDULL, (u64bit) 0x4D294D52649A1F4DULL, +(u64bit) 0x927292E4E0397692ULL, (u64bit) 0x75C9758FBCEAFA75ULL, (u64bit) 0x061806301E0C3606ULL, (u64bit) 0x8A128A249809AE8AULL, +(u64bit) 0xB2F2B2F940794BB2ULL, (u64bit) 0xE6BFE66359D185E6ULL, (u64bit) 0x0E380E70361C7E0EULL, (u64bit) 0x1F7C1FF8633EE71FULL, +(u64bit) 0x62956237F7C45562ULL, (u64bit) 0xD477D4EEA3B53AD4ULL, (u64bit) 0xA89AA829324D81A8ULL, (u64bit) 0x966296C4F4315296ULL, +(u64bit) 0xF9C3F99B3AEF62F9ULL, (u64bit) 0xC533C566F697A3C5ULL, (u64bit) 0x25942535B14A1025ULL, (u64bit) 0x597959F220B2AB59ULL, +(u64bit) 0x842A8454AE15D084ULL, (u64bit) 0x72D572B7A7E4C572ULL, (u64bit) 0x39E439D5DD72EC39ULL, (u64bit) 0x4C2D4C5A6198164CULL, +(u64bit) 0x5E655ECA3BBC945EULL, (u64bit) 0x78FD78E785F09F78ULL, (u64bit) 0x38E038DDD870E538ULL, (u64bit) 0x8C0A8C148605988CULL, +(u64bit) 0xD163D1C6B2BF17D1ULL, (u64bit) 0xA5AEA5410B57E4A5ULL, (u64bit) 0xE2AFE2434DD9A1E2ULL, (u64bit) 0x6199612FF8C24E61ULL, +(u64bit) 0xB3F6B3F1457B42B3ULL, (u64bit) 0x21842115A5423421ULL, (u64bit) 0x9C4A9C94D625089CULL, (u64bit) 0x1E781EF0663CEE1EULL, +(u64bit) 0x4311432252866143ULL, (u64bit) 0xC73BC776FC93B1C7ULL, (u64bit) 0xFCD7FCB32BE54FFCULL, (u64bit) 0x0410042014082404ULL, +(u64bit) 0x515951B208A2E351ULL, (u64bit) 0x995E99BCC72F2599ULL, (u64bit) 0x6DA96D4FC4DA226DULL, (u64bit) 0x0D340D68391A650DULL, +(u64bit) 0xFACFFA8335E979FAULL, (u64bit) 0xDF5BDFB684A369DFULL, (u64bit) 0x7EE57ED79BFCA97EULL, (u64bit) 0x2490243DB4481924ULL, +(u64bit) 0x3BEC3BC5D776FE3BULL, (u64bit) 0xAB96AB313D4B9AABULL, (u64bit) 0xCE1FCE3ED181F0CEULL, (u64bit) 0x1144118855229911ULL, +(u64bit) 0x8F068F0C8903838FULL, (u64bit) 0x4E254E4A6B9C044EULL, (u64bit) 0xB7E6B7D1517366B7ULL, (u64bit) 0xEB8BEB0B60CBE0EBULL, +(u64bit) 0x3CF03CFDCC78C13CULL, (u64bit) 0x813E817CBF1FFD81ULL, (u64bit) 0x946A94D4FE354094ULL, (u64bit) 0xF7FBF7EB0CF31CF7ULL, +(u64bit) 0xB9DEB9A1676F18B9ULL, (u64bit) 0x134C13985F268B13ULL, (u64bit) 0x2CB02C7D9C58512CULL, (u64bit) 0xD36BD3D6B8BB05D3ULL, +(u64bit) 0xE7BBE76B5CD38CE7ULL, (u64bit) 0x6EA56E57CBDC396EULL, (u64bit) 0xC437C46EF395AAC4ULL, (u64bit) 0x030C03180F061B03ULL, +(u64bit) 0x5645568A13ACDC56ULL, (u64bit) 0x440D441A49885E44ULL, (u64bit) 0x7FE17FDF9EFEA07FULL, (u64bit) 0xA99EA921374F88A9ULL, +(u64bit) 0x2AA82A4D8254672AULL, (u64bit) 0xBBD6BBB16D6B0ABBULL, (u64bit) 0xC123C146E29F87C1ULL, (u64bit) 0x535153A202A6F153ULL, +(u64bit) 0xDC57DCAE8BA572DCULL, (u64bit) 0x0B2C0B582716530BULL, (u64bit) 0x9D4E9D9CD327019DULL, (u64bit) 0x6CAD6C47C1D82B6CULL, +(u64bit) 0x31C43195F562A431ULL, (u64bit) 0x74CD7487B9E8F374ULL, (u64bit) 0xF6FFF6E309F115F6ULL, (u64bit) 0x4605460A438C4C46ULL, +(u64bit) 0xAC8AAC092645A5ACULL, (u64bit) 0x891E893C970FB589ULL, (u64bit) 0x145014A04428B414ULL, (u64bit) 0xE1A3E15B42DFBAE1ULL, +(u64bit) 0x165816B04E2CA616ULL, (u64bit) 0x3AE83ACDD274F73AULL, (u64bit) 0x69B9696FD0D20669ULL, (u64bit) 0x092409482D124109ULL, +(u64bit) 0x70DD70A7ADE0D770ULL, (u64bit) 0xB6E2B6D954716FB6ULL, (u64bit) 0xD067D0CEB7BD1ED0ULL, (u64bit) 0xED93ED3B7EC7D6EDULL, +(u64bit) 0xCC17CC2EDB85E2CCULL, (u64bit) 0x4215422A57846842ULL, (u64bit) 0x985A98B4C22D2C98ULL, (u64bit) 0xA4AAA4490E55EDA4ULL, +(u64bit) 0x28A0285D88507528ULL, (u64bit) 0x5C6D5CDA31B8865CULL, (u64bit) 0xF8C7F8933FED6BF8ULL, (u64bit) 0x86228644A411C286ULL }; + +} diff --git a/botan/src/hash/whirlpool/whrlpool.cpp b/botan/src/hash/whirlpool/whrlpool.cpp new file mode 100644 index 0000000..53c057b --- /dev/null +++ b/botan/src/hash/whirlpool/whrlpool.cpp @@ -0,0 +1,146 @@ +/* +* Whirlpool +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#include <botan/whrlpool.h> +#include <botan/loadstor.h> + +namespace Botan { + +/* +* Whirlpool Compression Function +*/ +void Whirlpool::compress_n(const byte in[], u32bit blocks) + { + static const u64bit RC[10] = { + (u64bit) 0x1823C6E887B8014FULL, (u64bit) 0x36A6D2F5796F9152ULL, + (u64bit) 0x60BC9B8EA30C7B35ULL, (u64bit) 0x1DE0D7C22E4BFE57ULL, + (u64bit) 0x157737E59FF04ADAULL, (u64bit) 0x58C9290AB1A06B85ULL, + (u64bit) 0xBD5D10F4CB3E0567ULL, (u64bit) 0xE427418BA77D95D8ULL, + (u64bit) 0xFBEE7C66DD17479EULL, (u64bit) 0xCA2DBF07AD5A8333ULL + }; + + for(u32bit i = 0; i != blocks; ++i) + { + for(u32bit j = 0; j != 8; ++j) + M[j] = load_be<u64bit>(in, j); + in += HASH_BLOCK_SIZE; + + 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/botan/src/hash/whirlpool/whrlpool.h b/botan/src/hash/whirlpool/whrlpool.h new file mode 100644 index 0000000..b72ff60 --- /dev/null +++ b/botan/src/hash/whirlpool/whrlpool.h @@ -0,0 +1,42 @@ +/* +* Whirlpool +* (C) 1999-2007 Jack Lloyd +* +* Distributed under the terms of the Botan license +*/ + +#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 compress_n(const byte[], u32bit blocks); + 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 |