8 #include <botan/sha160.h>     9 #include <botan/loadstor.h>    10 #include <botan/rotate.h>    23    E += (D ^ (B & (C ^ D))) + msg + 0x5A827999 + 
rotate_left(A, 5);
    32    E += (B ^ C ^ D) + msg + 0x6ED9EBA1 + 
rotate_left(A, 5);
    41    E += ((B & C) | ((B | C) & D)) + msg + 0x8F1BBCDC + 
rotate_left(A, 5);
    50    E += (B ^ C ^ D) + msg + 0xCA62C1D6 + 
rotate_left(A, 5);
    63    using namespace SHA1_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       for(
size_t j = 16; j != 80; j += 8)
    74          W[j  ] = 
rotate_left((W[j-3] ^ W[j-8] ^ W[j-14] ^ W[j-16]), 1);
    75          W[j+1] = 
rotate_left((W[j-2] ^ W[j-7] ^ W[j-13] ^ W[j-15]), 1);
    76          W[j+2] = 
rotate_left((W[j-1] ^ W[j-6] ^ W[j-12] ^ W[j-14]), 1);
    77          W[j+3] = 
rotate_left((W[j  ] ^ W[j-5] ^ W[j-11] ^ W[j-13]), 1);
    78          W[j+4] = 
rotate_left((W[j+1] ^ W[j-4] ^ W[j-10] ^ W[j-12]), 1);
    79          W[j+5] = 
rotate_left((W[j+2] ^ W[j-3] ^ W[j- 9] ^ W[j-11]), 1);
    80          W[j+6] = 
rotate_left((W[j+3] ^ W[j-2] ^ W[j- 8] ^ W[j-10]), 1);
    81          W[j+7] = 
rotate_left((W[j+4] ^ W[j-1] ^ W[j- 7] ^ W[j- 9]), 1);
    84       F1(A, B, C, D, E, W[ 0]);   
F1(E, A, B, C, D, W[ 1]);
    85       F1(D, E, A, B, C, W[ 2]);   
F1(C, D, E, A, B, W[ 3]);
    86       F1(B, C, D, E, A, W[ 4]);   
F1(A, B, C, D, E, W[ 5]);
    87       F1(E, A, B, C, D, W[ 6]);   
F1(D, E, A, B, C, W[ 7]);
    88       F1(C, D, E, A, B, W[ 8]);   
F1(B, C, D, E, A, W[ 9]);
    89       F1(A, B, C, D, E, W[10]);   
F1(E, A, B, C, D, W[11]);
    90       F1(D, E, A, B, C, W[12]);   
F1(C, D, E, A, B, W[13]);
    91       F1(B, C, D, E, A, W[14]);   
F1(A, B, C, D, E, W[15]);
    92       F1(E, A, B, C, D, W[16]);   
F1(D, E, A, B, C, W[17]);
    93       F1(C, D, E, A, B, W[18]);   
F1(B, C, D, E, A, W[19]);
    95       F2(A, B, C, D, E, W[20]);   
F2(E, A, B, C, D, W[21]);
    96       F2(D, E, A, B, C, W[22]);   
F2(C, D, E, A, B, W[23]);
    97       F2(B, C, D, E, A, W[24]);   
F2(A, B, C, D, E, W[25]);
    98       F2(E, A, B, C, D, W[26]);   
F2(D, E, A, B, C, W[27]);
    99       F2(C, D, E, A, B, W[28]);   
F2(B, C, D, E, A, W[29]);
   100       F2(A, B, C, D, E, W[30]);   
F2(E, A, B, C, D, W[31]);
   101       F2(D, E, A, B, C, W[32]);   
F2(C, D, E, A, B, W[33]);
   102       F2(B, C, D, E, A, W[34]);   
F2(A, B, C, D, E, W[35]);
   103       F2(E, A, B, C, D, W[36]);   
F2(D, E, A, B, C, W[37]);
   104       F2(C, D, E, A, B, W[38]);   
F2(B, C, D, E, A, W[39]);
   106       F3(A, B, C, D, E, W[40]);   
F3(E, A, B, C, D, W[41]);
   107       F3(D, E, A, B, C, W[42]);   
F3(C, D, E, A, B, W[43]);
   108       F3(B, C, D, E, A, W[44]);   
F3(A, B, C, D, E, W[45]);
   109       F3(E, A, B, C, D, W[46]);   
F3(D, E, A, B, C, W[47]);
   110       F3(C, D, E, A, B, W[48]);   
F3(B, C, D, E, A, W[49]);
   111       F3(A, B, C, D, E, W[50]);   
F3(E, A, B, C, D, W[51]);
   112       F3(D, E, A, B, C, W[52]);   
F3(C, D, E, A, B, W[53]);
   113       F3(B, C, D, E, A, W[54]);   
F3(A, B, C, D, E, W[55]);
   114       F3(E, A, B, C, D, W[56]);   
F3(D, E, A, B, C, W[57]);
   115       F3(C, D, E, A, B, W[58]);   
F3(B, C, D, E, A, W[59]);
   117       F4(A, B, C, D, E, W[60]);   
F4(E, A, B, C, D, W[61]);
   118       F4(D, E, A, B, C, W[62]);   
F4(C, D, E, A, B, W[63]);
   119       F4(B, C, D, E, A, W[64]);   
F4(A, B, C, D, E, W[65]);
   120       F4(E, A, B, C, D, W[66]);   
F4(D, E, A, B, C, W[67]);
   121       F4(C, D, E, A, B, W[68]);   
F4(B, C, D, E, A, W[69]);
   122       F4(A, B, C, D, E, W[70]);   
F4(E, A, B, C, D, W[71]);
   123       F4(D, E, A, B, C, W[72]);   
F4(C, D, E, A, B, W[73]);
   124       F4(B, C, D, E, A, W[74]);   
F4(A, B, C, D, E, W[75]);
   125       F4(E, A, B, C, D, W[76]);   
F4(D, E, A, B, C, W[77]);
   126       F4(C, D, E, A, B, W[78]);   
F4(B, C, D, E, A, W[79]);
   128       A = (digest[0] += A);
   129       B = (digest[1] += B);
   130       C = (digest[2] += C);
   131       D = (digest[3] += D);
   132       E = (digest[4] += E);
   134       input += hash_block_size();
   143    for(
size_t i = 0; i != output_length(); i += 4)
   154    digest[0] = 0x67452301;
   155    digest[1] = 0xEFCDAB89;
   156    digest[2] = 0x98BADCFE;
   157    digest[3] = 0x10325476;
   158    digest[4] = 0xC3D2E1F0;
 T load_be(const byte in[], size_t off)
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 compress_n(const byte[], size_t blocks)
void F4(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
void store_be(u16bit in, byte out[2])
void F1(u32bit A, u32bit &B, u32bit C, u32bit D, u32bit &E, u32bit msg, u32bit rot)
void zeroise(MemoryRegion< T > &vec)