8 #include <botan/has160.h>     9 #include <botan/loadstor.h>    10 #include <botan/rotate.h>    22    E += 
rotate_left(A, rot) + (D ^ (B & (C ^ D))) + msg;
    32    E += 
rotate_left(A, rot) + (B ^ C ^ D) + msg + 0x5A827999;
    42    E += 
rotate_left(A, rot) + (C ^ (B | ~D)) + msg + 0x6ED9EBA1;
    52    E += 
rotate_left(A, rot) + (B ^ C ^ D) + msg + 0x8F1BBCDC;
    61 void HAS_160::compress_n(
const byte input[], 
size_t blocks)
    63    using namespace HAS_160_F;
    65    u32bit A = digest[0], B = digest[1], C = digest[2],
    66           D = digest[3], E = digest[4];
    68    for(
size_t i = 0; i != blocks; ++i)
    72       X[16] = X[ 0] ^ X[ 1] ^ X[ 2] ^ X[ 3];
    73       X[17] = X[ 4] ^ X[ 5] ^ X[ 6] ^ X[ 7];
    74       X[18] = X[ 8] ^ X[ 9] ^ X[10] ^ X[11];
    75       X[19] = X[12] ^ X[13] ^ X[14] ^ X[15];
    76       F1(A,B,C,D,E,X[18], 5);   
F1(E,A,B,C,D,X[ 0],11);
    77       F1(D,E,A,B,C,X[ 1], 7);   
F1(C,D,E,A,B,X[ 2],15);
    78       F1(B,C,D,E,A,X[ 3], 6);   
F1(A,B,C,D,E,X[19],13);
    79       F1(E,A,B,C,D,X[ 4], 8);   
F1(D,E,A,B,C,X[ 5],14);
    80       F1(C,D,E,A,B,X[ 6], 7);   
F1(B,C,D,E,A,X[ 7],12);
    81       F1(A,B,C,D,E,X[16], 9);   
F1(E,A,B,C,D,X[ 8],11);
    82       F1(D,E,A,B,C,X[ 9], 8);   
F1(C,D,E,A,B,X[10],15);
    83       F1(B,C,D,E,A,X[11], 6);   
F1(A,B,C,D,E,X[17],12);
    84       F1(E,A,B,C,D,X[12], 9);   
F1(D,E,A,B,C,X[13],14);
    85       F1(C,D,E,A,B,X[14], 5);   
F1(B,C,D,E,A,X[15],13);
    87       X[16] = X[ 3] ^ X[ 6] ^ X[ 9] ^ X[12];
    88       X[17] = X[ 2] ^ X[ 5] ^ X[ 8] ^ X[15];
    89       X[18] = X[ 1] ^ X[ 4] ^ X[11] ^ X[14];
    90       X[19] = X[ 0] ^ X[ 7] ^ X[10] ^ X[13];
    91       F2(A,B,C,D,E,X[18], 5);   
F2(E,A,B,C,D,X[ 3],11);
    92       F2(D,E,A,B,C,X[ 6], 7);   
F2(C,D,E,A,B,X[ 9],15);
    93       F2(B,C,D,E,A,X[12], 6);   
F2(A,B,C,D,E,X[19],13);
    94       F2(E,A,B,C,D,X[15], 8);   
F2(D,E,A,B,C,X[ 2],14);
    95       F2(C,D,E,A,B,X[ 5], 7);   
F2(B,C,D,E,A,X[ 8],12);
    96       F2(A,B,C,D,E,X[16], 9);   
F2(E,A,B,C,D,X[11],11);
    97       F2(D,E,A,B,C,X[14], 8);   
F2(C,D,E,A,B,X[ 1],15);
    98       F2(B,C,D,E,A,X[ 4], 6);   
F2(A,B,C,D,E,X[17],12);
    99       F2(E,A,B,C,D,X[ 7], 9);   
F2(D,E,A,B,C,X[10],14);
   100       F2(C,D,E,A,B,X[13], 5);   
F2(B,C,D,E,A,X[ 0],13);
   102       X[16] = X[ 5] ^ X[ 7] ^ X[12] ^ X[14];
   103       X[17] = X[ 0] ^ X[ 2] ^ X[ 9] ^ X[11];
   104       X[18] = X[ 4] ^ X[ 6] ^ X[13] ^ X[15];
   105       X[19] = X[ 1] ^ X[ 3] ^ X[ 8] ^ X[10];
   106       F3(A,B,C,D,E,X[18], 5);   
F3(E,A,B,C,D,X[12],11);
   107       F3(D,E,A,B,C,X[ 5], 7);   
F3(C,D,E,A,B,X[14],15);
   108       F3(B,C,D,E,A,X[ 7], 6);   
F3(A,B,C,D,E,X[19],13);
   109       F3(E,A,B,C,D,X[ 0], 8);   
F3(D,E,A,B,C,X[ 9],14);
   110       F3(C,D,E,A,B,X[ 2], 7);   
F3(B,C,D,E,A,X[11],12);
   111       F3(A,B,C,D,E,X[16], 9);   
F3(E,A,B,C,D,X[ 4],11);
   112       F3(D,E,A,B,C,X[13], 8);   
F3(C,D,E,A,B,X[ 6],15);
   113       F3(B,C,D,E,A,X[15], 6);   
F3(A,B,C,D,E,X[17],12);
   114       F3(E,A,B,C,D,X[ 8], 9);   
F3(D,E,A,B,C,X[ 1],14);
   115       F3(C,D,E,A,B,X[10], 5);   
F3(B,C,D,E,A,X[ 3],13);
   117       X[16] = X[ 2] ^ X[ 7] ^ X[ 8] ^ X[13];
   118       X[17] = X[ 3] ^ X[ 4] ^ X[ 9] ^ X[14];
   119       X[18] = X[ 0] ^ X[ 5] ^ X[10] ^ X[15];
   120       X[19] = X[ 1] ^ X[ 6] ^ X[11] ^ X[12];
   121       F4(A,B,C,D,E,X[18], 5);   
F4(E,A,B,C,D,X[ 7],11);
   122       F4(D,E,A,B,C,X[ 2], 7);   
F4(C,D,E,A,B,X[13],15);
   123       F4(B,C,D,E,A,X[ 8], 6);   
F4(A,B,C,D,E,X[19],13);
   124       F4(E,A,B,C,D,X[ 3], 8);   
F4(D,E,A,B,C,X[14],14);
   125       F4(C,D,E,A,B,X[ 9], 7);   
F4(B,C,D,E,A,X[ 4],12);
   126       F4(A,B,C,D,E,X[16], 9);   
F4(E,A,B,C,D,X[15],11);
   127       F4(D,E,A,B,C,X[10], 8);   
F4(C,D,E,A,B,X[ 5],15);
   128       F4(B,C,D,E,A,X[ 0], 6);   
F4(A,B,C,D,E,X[17],12);
   129       F4(E,A,B,C,D,X[11], 9);   
F4(D,E,A,B,C,X[ 6],14);
   130       F4(C,D,E,A,B,X[ 1], 5);   
F4(B,C,D,E,A,X[12],13);
   132       A = (digest[0] += A);
   133       B = (digest[1] += B);
   134       C = (digest[2] += C);
   135       D = (digest[3] += D);
   136       E = (digest[4] += E);
   138       input += hash_block_size();
   145 void HAS_160::copy_out(
byte output[])
   147    for(
size_t i = 0; i != output_length(); i += 4)
   158    digest[0] = 0x67452301;
   159    digest[1] = 0xEFCDAB89;
   160    digest[2] = 0x98BADCFE;
   161    digest[3] = 0x10325476;
   162    digest[4] = 0xC3D2E1F0;
 T load_le(const byte in[], size_t off)
void store_le(u16bit in, byte out[2])
T rotate_left(T input, size_t rot)
void F2(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
void F3(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
void F4(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
void F1(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
void zeroise(MemoryRegion< T > &vec)