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)