1 /***
2 * Copyright 2017 Marc Stevens <marc@marc-stevens.nl>, Dan Shumow (danshu@microsoft.com)
3 * Distributed under the MIT Software License.
4 * See accompanying file LICENSE.txt or copy at
5 * https://opensource.org/licenses/MIT
6 ***/
7
8 #include <string.h>
9 #include <memory.h>
10 #include <stdio.h>
11 #include <stdlib.h>
12
13 #include "sha1.h"
14 #include "ubc_check.h"
15
16
17 /*
18 Because Little-Endian architectures are most common,
19 we only set SHA1DC_BIGENDIAN if one of these conditions is met.
20 Note that all MSFT platforms are little endian,
21 so none of these will be defined under the MSC compiler.
22 If you are compiling on a big endian platform and your compiler does not define one of these,
23 you will have to add whatever macros your tool chain defines to indicate Big-Endianness.
24 */
25 #ifdef SHA1DC_BIGENDIAN
26 #undef SHA1DC_BIGENDIAN
27 #endif
28 #if (!defined SHA1DC_FORCE_LITTLEENDIAN) && \
29 ((defined(__BYTE_ORDER) && (__BYTE_ORDER == __BIG_ENDIAN)) || \
30 (defined(__BYTE_ORDER__) && (__BYTE_ORDER__ == __BIG_ENDIAN__)) || \
31 defined(__BIG_ENDIAN__) || defined(__ARMEB__) || defined(__THUMBEB__) || defined(__AARCH64EB__) || \
32 defined(_MIPSEB) || defined(__MIPSEB) || defined(__MIPSEB__) || defined(SHA1DC_FORCE_BIGENDIAN))
33
34 #define SHA1DC_BIGENDIAN
35
36 #endif /*ENDIANNESS SELECTION*/
37
38 #define rotate_right(x,n) (((x)>>(n))|((x)<<(32-(n))))
39 #define rotate_left(x,n) (((x)<<(n))|((x)>>(32-(n))))
40
41 #define sha1_bswap32(x) \
42 {x = ((x << 8) & 0xFF00FF00) | ((x >> 8) & 0xFF00FF); x = (x << 16) | (x >> 16);}
43
44 #define sha1_mix(W, t) (rotate_left(W[t - 3] ^ W[t - 8] ^ W[t - 14] ^ W[t - 16], 1))
45
46 #ifdef SHA1DC_BIGENDIAN
47 #define sha1_load(m, t, temp) { temp = m[t]; }
48 #else
49 #define sha1_load(m, t, temp) { temp = m[t]; sha1_bswap32(temp); }
50 #endif
51
52 #define sha1_store(W, t, x) *(volatile uint32_t *)&W[t] = x
53
54 #define sha1_f1(b,c,d) ((d)^((b)&((c)^(d))))
55 #define sha1_f2(b,c,d) ((b)^(c)^(d))
56 #define sha1_f3(b,c,d) (((b)&(c))+((d)&((b)^(c))))
57 #define sha1_f4(b,c,d) ((b)^(c)^(d))
58
59 #define HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, m, t) \
60 { e += rotate_left(a, 5) + sha1_f1(b,c,d) + 0x5A827999 + m[t]; b = rotate_left(b, 30); }
61 #define HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, m, t) \
62 { e += rotate_left(a, 5) + sha1_f2(b,c,d) + 0x6ED9EBA1 + m[t]; b = rotate_left(b, 30); }
63 #define HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, m, t) \
64 { e += rotate_left(a, 5) + sha1_f3(b,c,d) + 0x8F1BBCDC + m[t]; b = rotate_left(b, 30); }
65 #define HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, m, t) \
66 { e += rotate_left(a, 5) + sha1_f4(b,c,d) + 0xCA62C1D6 + m[t]; b = rotate_left(b, 30); }
67
68 #define HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, m, t) \
69 { b = rotate_right(b, 30); e -= rotate_left(a, 5) + sha1_f1(b,c,d) + 0x5A827999 + m[t]; }
70 #define HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, m, t) \
71 { b = rotate_right(b, 30); e -= rotate_left(a, 5) + sha1_f2(b,c,d) + 0x6ED9EBA1 + m[t]; }
72 #define HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, m, t) \
73 { b = rotate_right(b, 30); e -= rotate_left(a, 5) + sha1_f3(b,c,d) + 0x8F1BBCDC + m[t]; }
74 #define HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, m, t) \
75 { b = rotate_right(b, 30); e -= rotate_left(a, 5) + sha1_f4(b,c,d) + 0xCA62C1D6 + m[t]; }
76
77 #define SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, t, temp) \
78 {sha1_load(m, t, temp); sha1_store(W, t, temp); e += temp + rotate_left(a, 5) + sha1_f1(b,c,d) + 0x5A827999; b = rotate_left(b, 30);}
79
80 #define SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(a, b, c, d, e, W, t, temp) \
81 {temp = sha1_mix(W, t); sha1_store(W, t, temp); e += temp + rotate_left(a, 5) + sha1_f1(b,c,d) + 0x5A827999; b = rotate_left(b, 30); }
82
83 #define SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, t, temp) \
84 {temp = sha1_mix(W, t); sha1_store(W, t, temp); e += temp + rotate_left(a, 5) + sha1_f2(b,c,d) + 0x6ED9EBA1; b = rotate_left(b, 30); }
85
86 #define SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, t, temp) \
87 {temp = sha1_mix(W, t); sha1_store(W, t, temp); e += temp + rotate_left(a, 5) + sha1_f3(b,c,d) + 0x8F1BBCDC; b = rotate_left(b, 30); }
88
89 #define SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, t, temp) \
90 {temp = sha1_mix(W, t); sha1_store(W, t, temp); e += temp + rotate_left(a, 5) + sha1_f4(b,c,d) + 0xCA62C1D6; b = rotate_left(b, 30); }
91
92
93 #define SHA1_STORE_STATE(i) states[i][0] = a; states[i][1] = b; states[i][2] = c; states[i][3] = d; states[i][4] = e;
94
95 #ifdef BUILDNOCOLLDETECTSHA1COMPRESSION
sha1_compression(uint32_t ihv[5],const uint32_t m[16])96 void sha1_compression(uint32_t ihv[5], const uint32_t m[16])
97 {
98 uint32_t W[80];
99 uint32_t a,b,c,d,e;
100 unsigned i;
101
102 memcpy(W, m, 16 * 4);
103 for (i = 16; i < 80; ++i)
104 W[i] = sha1_mix(W, i);
105
106 a = ihv[0]; b = ihv[1]; c = ihv[2]; d = ihv[3]; e = ihv[4];
107
108 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 0);
109 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 1);
110 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 2);
111 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 3);
112 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 4);
113 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 5);
114 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 6);
115 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 7);
116 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 8);
117 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 9);
118 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 10);
119 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 11);
120 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 12);
121 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 13);
122 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 14);
123 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 15);
124 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 16);
125 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 17);
126 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 18);
127 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 19);
128
129 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 20);
130 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 21);
131 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 22);
132 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 23);
133 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 24);
134 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 25);
135 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 26);
136 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 27);
137 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 28);
138 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 29);
139 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 30);
140 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 31);
141 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 32);
142 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 33);
143 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 34);
144 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 35);
145 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 36);
146 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 37);
147 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 38);
148 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 39);
149
150 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 40);
151 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 41);
152 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 42);
153 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 43);
154 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 44);
155 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 45);
156 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 46);
157 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 47);
158 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 48);
159 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 49);
160 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 50);
161 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 51);
162 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 52);
163 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 53);
164 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 54);
165 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 55);
166 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 56);
167 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 57);
168 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 58);
169 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 59);
170
171 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 60);
172 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 61);
173 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 62);
174 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 63);
175 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 64);
176 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 65);
177 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 66);
178 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 67);
179 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 68);
180 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 69);
181 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 70);
182 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 71);
183 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 72);
184 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 73);
185 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 74);
186 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 75);
187 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 76);
188 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 77);
189 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 78);
190 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 79);
191
192 ihv[0] += a; ihv[1] += b; ihv[2] += c; ihv[3] += d; ihv[4] += e;
193 }
194 #endif /*BUILDNOCOLLDETECTSHA1COMPRESSION*/
195
196
sha1_compression_W(uint32_t ihv[5],const uint32_t W[80])197 static void sha1_compression_W(uint32_t ihv[5], const uint32_t W[80])
198 {
199 uint32_t a = ihv[0], b = ihv[1], c = ihv[2], d = ihv[3], e = ihv[4];
200
201 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 0);
202 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 1);
203 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 2);
204 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 3);
205 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 4);
206 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 5);
207 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 6);
208 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 7);
209 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 8);
210 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 9);
211 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 10);
212 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 11);
213 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 12);
214 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 13);
215 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 14);
216 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 15);
217 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 16);
218 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 17);
219 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 18);
220 HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 19);
221
222 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 20);
223 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 21);
224 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 22);
225 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 23);
226 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 24);
227 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 25);
228 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 26);
229 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 27);
230 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 28);
231 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 29);
232 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 30);
233 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 31);
234 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 32);
235 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 33);
236 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 34);
237 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 35);
238 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 36);
239 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 37);
240 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 38);
241 HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 39);
242
243 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 40);
244 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 41);
245 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 42);
246 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 43);
247 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 44);
248 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 45);
249 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 46);
250 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 47);
251 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 48);
252 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 49);
253 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 50);
254 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 51);
255 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 52);
256 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 53);
257 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 54);
258 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 55);
259 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 56);
260 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 57);
261 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 58);
262 HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 59);
263
264 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 60);
265 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 61);
266 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 62);
267 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 63);
268 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 64);
269 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 65);
270 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 66);
271 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 67);
272 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 68);
273 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 69);
274 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 70);
275 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 71);
276 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 72);
277 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 73);
278 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 74);
279 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 75);
280 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 76);
281 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 77);
282 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 78);
283 HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 79);
284
285 ihv[0] += a; ihv[1] += b; ihv[2] += c; ihv[3] += d; ihv[4] += e;
286 }
287
288
289
sha1_compression_states(uint32_t ihv[5],const uint32_t m[16],uint32_t W[80],uint32_t states[80][5])290 void sha1_compression_states(uint32_t ihv[5], const uint32_t m[16], uint32_t W[80], uint32_t states[80][5])
291 {
292 uint32_t a = ihv[0], b = ihv[1], c = ihv[2], d = ihv[3], e = ihv[4];
293 uint32_t temp;
294
295 #ifdef DOSTORESTATE00
296 SHA1_STORE_STATE(0)
297 #endif
298 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 0, temp);
299
300 #ifdef DOSTORESTATE01
301 SHA1_STORE_STATE(1)
302 #endif
303 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(e, a, b, c, d, m, W, 1, temp);
304
305 #ifdef DOSTORESTATE02
306 SHA1_STORE_STATE(2)
307 #endif
308 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(d, e, a, b, c, m, W, 2, temp);
309
310 #ifdef DOSTORESTATE03
311 SHA1_STORE_STATE(3)
312 #endif
313 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(c, d, e, a, b, m, W, 3, temp);
314
315 #ifdef DOSTORESTATE04
316 SHA1_STORE_STATE(4)
317 #endif
318 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(b, c, d, e, a, m, W, 4, temp);
319
320 #ifdef DOSTORESTATE05
321 SHA1_STORE_STATE(5)
322 #endif
323 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 5, temp);
324
325 #ifdef DOSTORESTATE06
326 SHA1_STORE_STATE(6)
327 #endif
328 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(e, a, b, c, d, m, W, 6, temp);
329
330 #ifdef DOSTORESTATE07
331 SHA1_STORE_STATE(7)
332 #endif
333 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(d, e, a, b, c, m, W, 7, temp);
334
335 #ifdef DOSTORESTATE08
336 SHA1_STORE_STATE(8)
337 #endif
338 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(c, d, e, a, b, m, W, 8, temp);
339
340 #ifdef DOSTORESTATE09
341 SHA1_STORE_STATE(9)
342 #endif
343 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(b, c, d, e, a, m, W, 9, temp);
344
345 #ifdef DOSTORESTATE10
346 SHA1_STORE_STATE(10)
347 #endif
348 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 10, temp);
349
350 #ifdef DOSTORESTATE11
351 SHA1_STORE_STATE(11)
352 #endif
353 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(e, a, b, c, d, m, W, 11, temp);
354
355 #ifdef DOSTORESTATE12
356 SHA1_STORE_STATE(12)
357 #endif
358 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(d, e, a, b, c, m, W, 12, temp);
359
360 #ifdef DOSTORESTATE13
361 SHA1_STORE_STATE(13)
362 #endif
363 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(c, d, e, a, b, m, W, 13, temp);
364
365 #ifdef DOSTORESTATE14
366 SHA1_STORE_STATE(14)
367 #endif
368 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(b, c, d, e, a, m, W, 14, temp);
369
370 #ifdef DOSTORESTATE15
371 SHA1_STORE_STATE(15)
372 #endif
373 SHA1COMPRESS_FULL_ROUND1_STEP_LOAD(a, b, c, d, e, m, W, 15, temp);
374
375 #ifdef DOSTORESTATE16
376 SHA1_STORE_STATE(16)
377 #endif
378 SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(e, a, b, c, d, W, 16, temp);
379
380 #ifdef DOSTORESTATE17
381 SHA1_STORE_STATE(17)
382 #endif
383 SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(d, e, a, b, c, W, 17, temp);
384
385 #ifdef DOSTORESTATE18
386 SHA1_STORE_STATE(18)
387 #endif
388 SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(c, d, e, a, b, W, 18, temp);
389
390 #ifdef DOSTORESTATE19
391 SHA1_STORE_STATE(19)
392 #endif
393 SHA1COMPRESS_FULL_ROUND1_STEP_EXPAND(b, c, d, e, a, W, 19, temp);
394
395
396
397 #ifdef DOSTORESTATE20
398 SHA1_STORE_STATE(20)
399 #endif
400 SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 20, temp);
401
402 #ifdef DOSTORESTATE21
403 SHA1_STORE_STATE(21)
404 #endif
405 SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 21, temp);
406
407 #ifdef DOSTORESTATE22
408 SHA1_STORE_STATE(22)
409 #endif
410 SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 22, temp);
411
412 #ifdef DOSTORESTATE23
413 SHA1_STORE_STATE(23)
414 #endif
415 SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 23, temp);
416
417 #ifdef DOSTORESTATE24
418 SHA1_STORE_STATE(24)
419 #endif
420 SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 24, temp);
421
422 #ifdef DOSTORESTATE25
423 SHA1_STORE_STATE(25)
424 #endif
425 SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 25, temp);
426
427 #ifdef DOSTORESTATE26
428 SHA1_STORE_STATE(26)
429 #endif
430 SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 26, temp);
431
432 #ifdef DOSTORESTATE27
433 SHA1_STORE_STATE(27)
434 #endif
435 SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 27, temp);
436
437 #ifdef DOSTORESTATE28
438 SHA1_STORE_STATE(28)
439 #endif
440 SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 28, temp);
441
442 #ifdef DOSTORESTATE29
443 SHA1_STORE_STATE(29)
444 #endif
445 SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 29, temp);
446
447 #ifdef DOSTORESTATE30
448 SHA1_STORE_STATE(30)
449 #endif
450 SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 30, temp);
451
452 #ifdef DOSTORESTATE31
453 SHA1_STORE_STATE(31)
454 #endif
455 SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 31, temp);
456
457 #ifdef DOSTORESTATE32
458 SHA1_STORE_STATE(32)
459 #endif
460 SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 32, temp);
461
462 #ifdef DOSTORESTATE33
463 SHA1_STORE_STATE(33)
464 #endif
465 SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 33, temp);
466
467 #ifdef DOSTORESTATE34
468 SHA1_STORE_STATE(34)
469 #endif
470 SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 34, temp);
471
472 #ifdef DOSTORESTATE35
473 SHA1_STORE_STATE(35)
474 #endif
475 SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 35, temp);
476
477 #ifdef DOSTORESTATE36
478 SHA1_STORE_STATE(36)
479 #endif
480 SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 36, temp);
481
482 #ifdef DOSTORESTATE37
483 SHA1_STORE_STATE(37)
484 #endif
485 SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 37, temp);
486
487 #ifdef DOSTORESTATE38
488 SHA1_STORE_STATE(38)
489 #endif
490 SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 38, temp);
491
492 #ifdef DOSTORESTATE39
493 SHA1_STORE_STATE(39)
494 #endif
495 SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 39, temp);
496
497
498
499 #ifdef DOSTORESTATE40
500 SHA1_STORE_STATE(40)
501 #endif
502 SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 40, temp);
503
504 #ifdef DOSTORESTATE41
505 SHA1_STORE_STATE(41)
506 #endif
507 SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 41, temp);
508
509 #ifdef DOSTORESTATE42
510 SHA1_STORE_STATE(42)
511 #endif
512 SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 42, temp);
513
514 #ifdef DOSTORESTATE43
515 SHA1_STORE_STATE(43)
516 #endif
517 SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 43, temp);
518
519 #ifdef DOSTORESTATE44
520 SHA1_STORE_STATE(44)
521 #endif
522 SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 44, temp);
523
524 #ifdef DOSTORESTATE45
525 SHA1_STORE_STATE(45)
526 #endif
527 SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 45, temp);
528
529 #ifdef DOSTORESTATE46
530 SHA1_STORE_STATE(46)
531 #endif
532 SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 46, temp);
533
534 #ifdef DOSTORESTATE47
535 SHA1_STORE_STATE(47)
536 #endif
537 SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 47, temp);
538
539 #ifdef DOSTORESTATE48
540 SHA1_STORE_STATE(48)
541 #endif
542 SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 48, temp);
543
544 #ifdef DOSTORESTATE49
545 SHA1_STORE_STATE(49)
546 #endif
547 SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 49, temp);
548
549 #ifdef DOSTORESTATE50
550 SHA1_STORE_STATE(50)
551 #endif
552 SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 50, temp);
553
554 #ifdef DOSTORESTATE51
555 SHA1_STORE_STATE(51)
556 #endif
557 SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 51, temp);
558
559 #ifdef DOSTORESTATE52
560 SHA1_STORE_STATE(52)
561 #endif
562 SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 52, temp);
563
564 #ifdef DOSTORESTATE53
565 SHA1_STORE_STATE(53)
566 #endif
567 SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 53, temp);
568
569 #ifdef DOSTORESTATE54
570 SHA1_STORE_STATE(54)
571 #endif
572 SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 54, temp);
573
574 #ifdef DOSTORESTATE55
575 SHA1_STORE_STATE(55)
576 #endif
577 SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 55, temp);
578
579 #ifdef DOSTORESTATE56
580 SHA1_STORE_STATE(56)
581 #endif
582 SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 56, temp);
583
584 #ifdef DOSTORESTATE57
585 SHA1_STORE_STATE(57)
586 #endif
587 SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 57, temp);
588
589 #ifdef DOSTORESTATE58
590 SHA1_STORE_STATE(58)
591 #endif
592 SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 58, temp);
593
594 #ifdef DOSTORESTATE59
595 SHA1_STORE_STATE(59)
596 #endif
597 SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 59, temp);
598
599
600
601
602 #ifdef DOSTORESTATE60
603 SHA1_STORE_STATE(60)
604 #endif
605 SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 60, temp);
606
607 #ifdef DOSTORESTATE61
608 SHA1_STORE_STATE(61)
609 #endif
610 SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 61, temp);
611
612 #ifdef DOSTORESTATE62
613 SHA1_STORE_STATE(62)
614 #endif
615 SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 62, temp);
616
617 #ifdef DOSTORESTATE63
618 SHA1_STORE_STATE(63)
619 #endif
620 SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 63, temp);
621
622 #ifdef DOSTORESTATE64
623 SHA1_STORE_STATE(64)
624 #endif
625 SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 64, temp);
626
627 #ifdef DOSTORESTATE65
628 SHA1_STORE_STATE(65)
629 #endif
630 SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 65, temp);
631
632 #ifdef DOSTORESTATE66
633 SHA1_STORE_STATE(66)
634 #endif
635 SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 66, temp);
636
637 #ifdef DOSTORESTATE67
638 SHA1_STORE_STATE(67)
639 #endif
640 SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 67, temp);
641
642 #ifdef DOSTORESTATE68
643 SHA1_STORE_STATE(68)
644 #endif
645 SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 68, temp);
646
647 #ifdef DOSTORESTATE69
648 SHA1_STORE_STATE(69)
649 #endif
650 SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 69, temp);
651
652 #ifdef DOSTORESTATE70
653 SHA1_STORE_STATE(70)
654 #endif
655 SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 70, temp);
656
657 #ifdef DOSTORESTATE71
658 SHA1_STORE_STATE(71)
659 #endif
660 SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 71, temp);
661
662 #ifdef DOSTORESTATE72
663 SHA1_STORE_STATE(72)
664 #endif
665 SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 72, temp);
666
667 #ifdef DOSTORESTATE73
668 SHA1_STORE_STATE(73)
669 #endif
670 SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 73, temp);
671
672 #ifdef DOSTORESTATE74
673 SHA1_STORE_STATE(74)
674 #endif
675 SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 74, temp);
676
677 #ifdef DOSTORESTATE75
678 SHA1_STORE_STATE(75)
679 #endif
680 SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 75, temp);
681
682 #ifdef DOSTORESTATE76
683 SHA1_STORE_STATE(76)
684 #endif
685 SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 76, temp);
686
687 #ifdef DOSTORESTATE77
688 SHA1_STORE_STATE(77)
689 #endif
690 SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 77, temp);
691
692 #ifdef DOSTORESTATE78
693 SHA1_STORE_STATE(78)
694 #endif
695 SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 78, temp);
696
697 #ifdef DOSTORESTATE79
698 SHA1_STORE_STATE(79)
699 #endif
700 SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 79, temp);
701
702
703
704 ihv[0] += a; ihv[1] += b; ihv[2] += c; ihv[3] += d; ihv[4] += e;
705 }
706
707
708
709
710 #define SHA1_RECOMPRESS(t) \
711 static void sha1recompress_fast_ ## t (uint32_t ihvin[5], uint32_t ihvout[5], const uint32_t me2[80], const uint32_t state[5]) \
712 { \
713 uint32_t a = state[0], b = state[1], c = state[2], d = state[3], e = state[4]; \
714 if (t > 79) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 79); \
715 if (t > 78) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 78); \
716 if (t > 77) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 77); \
717 if (t > 76) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 76); \
718 if (t > 75) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 75); \
719 if (t > 74) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 74); \
720 if (t > 73) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 73); \
721 if (t > 72) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 72); \
722 if (t > 71) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 71); \
723 if (t > 70) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 70); \
724 if (t > 69) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 69); \
725 if (t > 68) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 68); \
726 if (t > 67) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 67); \
727 if (t > 66) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 66); \
728 if (t > 65) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 65); \
729 if (t > 64) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(b, c, d, e, a, me2, 64); \
730 if (t > 63) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(c, d, e, a, b, me2, 63); \
731 if (t > 62) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(d, e, a, b, c, me2, 62); \
732 if (t > 61) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(e, a, b, c, d, me2, 61); \
733 if (t > 60) HASHCLASH_SHA1COMPRESS_ROUND4_STEP_BW(a, b, c, d, e, me2, 60); \
734 if (t > 59) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 59); \
735 if (t > 58) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 58); \
736 if (t > 57) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 57); \
737 if (t > 56) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 56); \
738 if (t > 55) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 55); \
739 if (t > 54) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 54); \
740 if (t > 53) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 53); \
741 if (t > 52) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 52); \
742 if (t > 51) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 51); \
743 if (t > 50) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 50); \
744 if (t > 49) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 49); \
745 if (t > 48) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 48); \
746 if (t > 47) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 47); \
747 if (t > 46) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 46); \
748 if (t > 45) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 45); \
749 if (t > 44) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(b, c, d, e, a, me2, 44); \
750 if (t > 43) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(c, d, e, a, b, me2, 43); \
751 if (t > 42) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(d, e, a, b, c, me2, 42); \
752 if (t > 41) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(e, a, b, c, d, me2, 41); \
753 if (t > 40) HASHCLASH_SHA1COMPRESS_ROUND3_STEP_BW(a, b, c, d, e, me2, 40); \
754 if (t > 39) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 39); \
755 if (t > 38) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 38); \
756 if (t > 37) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 37); \
757 if (t > 36) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 36); \
758 if (t > 35) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 35); \
759 if (t > 34) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 34); \
760 if (t > 33) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 33); \
761 if (t > 32) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 32); \
762 if (t > 31) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 31); \
763 if (t > 30) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 30); \
764 if (t > 29) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 29); \
765 if (t > 28) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 28); \
766 if (t > 27) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 27); \
767 if (t > 26) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 26); \
768 if (t > 25) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 25); \
769 if (t > 24) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(b, c, d, e, a, me2, 24); \
770 if (t > 23) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(c, d, e, a, b, me2, 23); \
771 if (t > 22) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(d, e, a, b, c, me2, 22); \
772 if (t > 21) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(e, a, b, c, d, me2, 21); \
773 if (t > 20) HASHCLASH_SHA1COMPRESS_ROUND2_STEP_BW(a, b, c, d, e, me2, 20); \
774 if (t > 19) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 19); \
775 if (t > 18) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 18); \
776 if (t > 17) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 17); \
777 if (t > 16) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 16); \
778 if (t > 15) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 15); \
779 if (t > 14) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 14); \
780 if (t > 13) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 13); \
781 if (t > 12) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 12); \
782 if (t > 11) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 11); \
783 if (t > 10) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 10); \
784 if (t > 9) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 9); \
785 if (t > 8) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 8); \
786 if (t > 7) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 7); \
787 if (t > 6) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 6); \
788 if (t > 5) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 5); \
789 if (t > 4) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(b, c, d, e, a, me2, 4); \
790 if (t > 3) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(c, d, e, a, b, me2, 3); \
791 if (t > 2) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(d, e, a, b, c, me2, 2); \
792 if (t > 1) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(e, a, b, c, d, me2, 1); \
793 if (t > 0) HASHCLASH_SHA1COMPRESS_ROUND1_STEP_BW(a, b, c, d, e, me2, 0); \
794 ihvin[0] = a; ihvin[1] = b; ihvin[2] = c; ihvin[3] = d; ihvin[4] = e; \
795 a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4]; \
796 if (t <= 0) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 0); \
797 if (t <= 1) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 1); \
798 if (t <= 2) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 2); \
799 if (t <= 3) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 3); \
800 if (t <= 4) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 4); \
801 if (t <= 5) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 5); \
802 if (t <= 6) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 6); \
803 if (t <= 7) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 7); \
804 if (t <= 8) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 8); \
805 if (t <= 9) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 9); \
806 if (t <= 10) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 10); \
807 if (t <= 11) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 11); \
808 if (t <= 12) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 12); \
809 if (t <= 13) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 13); \
810 if (t <= 14) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 14); \
811 if (t <= 15) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, me2, 15); \
812 if (t <= 16) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, me2, 16); \
813 if (t <= 17) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, me2, 17); \
814 if (t <= 18) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, me2, 18); \
815 if (t <= 19) HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, me2, 19); \
816 if (t <= 20) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 20); \
817 if (t <= 21) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 21); \
818 if (t <= 22) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 22); \
819 if (t <= 23) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 23); \
820 if (t <= 24) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 24); \
821 if (t <= 25) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 25); \
822 if (t <= 26) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 26); \
823 if (t <= 27) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 27); \
824 if (t <= 28) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 28); \
825 if (t <= 29) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 29); \
826 if (t <= 30) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 30); \
827 if (t <= 31) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 31); \
828 if (t <= 32) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 32); \
829 if (t <= 33) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 33); \
830 if (t <= 34) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 34); \
831 if (t <= 35) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, me2, 35); \
832 if (t <= 36) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, me2, 36); \
833 if (t <= 37) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, me2, 37); \
834 if (t <= 38) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, me2, 38); \
835 if (t <= 39) HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, me2, 39); \
836 if (t <= 40) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 40); \
837 if (t <= 41) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 41); \
838 if (t <= 42) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 42); \
839 if (t <= 43) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 43); \
840 if (t <= 44) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 44); \
841 if (t <= 45) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 45); \
842 if (t <= 46) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 46); \
843 if (t <= 47) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 47); \
844 if (t <= 48) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 48); \
845 if (t <= 49) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 49); \
846 if (t <= 50) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 50); \
847 if (t <= 51) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 51); \
848 if (t <= 52) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 52); \
849 if (t <= 53) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 53); \
850 if (t <= 54) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 54); \
851 if (t <= 55) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, me2, 55); \
852 if (t <= 56) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, me2, 56); \
853 if (t <= 57) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, me2, 57); \
854 if (t <= 58) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, me2, 58); \
855 if (t <= 59) HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, me2, 59); \
856 if (t <= 60) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 60); \
857 if (t <= 61) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 61); \
858 if (t <= 62) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 62); \
859 if (t <= 63) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 63); \
860 if (t <= 64) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 64); \
861 if (t <= 65) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 65); \
862 if (t <= 66) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 66); \
863 if (t <= 67) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 67); \
864 if (t <= 68) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 68); \
865 if (t <= 69) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 69); \
866 if (t <= 70) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 70); \
867 if (t <= 71) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 71); \
868 if (t <= 72) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 72); \
869 if (t <= 73) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 73); \
870 if (t <= 74) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 74); \
871 if (t <= 75) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, me2, 75); \
872 if (t <= 76) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, me2, 76); \
873 if (t <= 77) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, me2, 77); \
874 if (t <= 78) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, me2, 78); \
875 if (t <= 79) HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, me2, 79); \
876 ihvout[0] = ihvin[0] + a; ihvout[1] = ihvin[1] + b; ihvout[2] = ihvin[2] + c; ihvout[3] = ihvin[3] + d; ihvout[4] = ihvin[4] + e; \
877 }
878
879 #ifdef DOSTORESTATE0
880 SHA1_RECOMPRESS(0)
881 #endif
882
883 #ifdef DOSTORESTATE1
884 SHA1_RECOMPRESS(1)
885 #endif
886
887 #ifdef DOSTORESTATE2
888 SHA1_RECOMPRESS(2)
889 #endif
890
891 #ifdef DOSTORESTATE3
892 SHA1_RECOMPRESS(3)
893 #endif
894
895 #ifdef DOSTORESTATE4
896 SHA1_RECOMPRESS(4)
897 #endif
898
899 #ifdef DOSTORESTATE5
900 SHA1_RECOMPRESS(5)
901 #endif
902
903 #ifdef DOSTORESTATE6
904 SHA1_RECOMPRESS(6)
905 #endif
906
907 #ifdef DOSTORESTATE7
908 SHA1_RECOMPRESS(7)
909 #endif
910
911 #ifdef DOSTORESTATE8
912 SHA1_RECOMPRESS(8)
913 #endif
914
915 #ifdef DOSTORESTATE9
916 SHA1_RECOMPRESS(9)
917 #endif
918
919 #ifdef DOSTORESTATE10
920 SHA1_RECOMPRESS(10)
921 #endif
922
923 #ifdef DOSTORESTATE11
924 SHA1_RECOMPRESS(11)
925 #endif
926
927 #ifdef DOSTORESTATE12
928 SHA1_RECOMPRESS(12)
929 #endif
930
931 #ifdef DOSTORESTATE13
932 SHA1_RECOMPRESS(13)
933 #endif
934
935 #ifdef DOSTORESTATE14
936 SHA1_RECOMPRESS(14)
937 #endif
938
939 #ifdef DOSTORESTATE15
940 SHA1_RECOMPRESS(15)
941 #endif
942
943 #ifdef DOSTORESTATE16
944 SHA1_RECOMPRESS(16)
945 #endif
946
947 #ifdef DOSTORESTATE17
948 SHA1_RECOMPRESS(17)
949 #endif
950
951 #ifdef DOSTORESTATE18
952 SHA1_RECOMPRESS(18)
953 #endif
954
955 #ifdef DOSTORESTATE19
956 SHA1_RECOMPRESS(19)
957 #endif
958
959 #ifdef DOSTORESTATE20
960 SHA1_RECOMPRESS(20)
961 #endif
962
963 #ifdef DOSTORESTATE21
964 SHA1_RECOMPRESS(21)
965 #endif
966
967 #ifdef DOSTORESTATE22
968 SHA1_RECOMPRESS(22)
969 #endif
970
971 #ifdef DOSTORESTATE23
972 SHA1_RECOMPRESS(23)
973 #endif
974
975 #ifdef DOSTORESTATE24
976 SHA1_RECOMPRESS(24)
977 #endif
978
979 #ifdef DOSTORESTATE25
980 SHA1_RECOMPRESS(25)
981 #endif
982
983 #ifdef DOSTORESTATE26
984 SHA1_RECOMPRESS(26)
985 #endif
986
987 #ifdef DOSTORESTATE27
988 SHA1_RECOMPRESS(27)
989 #endif
990
991 #ifdef DOSTORESTATE28
992 SHA1_RECOMPRESS(28)
993 #endif
994
995 #ifdef DOSTORESTATE29
996 SHA1_RECOMPRESS(29)
997 #endif
998
999 #ifdef DOSTORESTATE30
1000 SHA1_RECOMPRESS(30)
1001 #endif
1002
1003 #ifdef DOSTORESTATE31
1004 SHA1_RECOMPRESS(31)
1005 #endif
1006
1007 #ifdef DOSTORESTATE32
1008 SHA1_RECOMPRESS(32)
1009 #endif
1010
1011 #ifdef DOSTORESTATE33
1012 SHA1_RECOMPRESS(33)
1013 #endif
1014
1015 #ifdef DOSTORESTATE34
1016 SHA1_RECOMPRESS(34)
1017 #endif
1018
1019 #ifdef DOSTORESTATE35
1020 SHA1_RECOMPRESS(35)
1021 #endif
1022
1023 #ifdef DOSTORESTATE36
1024 SHA1_RECOMPRESS(36)
1025 #endif
1026
1027 #ifdef DOSTORESTATE37
1028 SHA1_RECOMPRESS(37)
1029 #endif
1030
1031 #ifdef DOSTORESTATE38
1032 SHA1_RECOMPRESS(38)
1033 #endif
1034
1035 #ifdef DOSTORESTATE39
1036 SHA1_RECOMPRESS(39)
1037 #endif
1038
1039 #ifdef DOSTORESTATE40
1040 SHA1_RECOMPRESS(40)
1041 #endif
1042
1043 #ifdef DOSTORESTATE41
1044 SHA1_RECOMPRESS(41)
1045 #endif
1046
1047 #ifdef DOSTORESTATE42
1048 SHA1_RECOMPRESS(42)
1049 #endif
1050
1051 #ifdef DOSTORESTATE43
1052 SHA1_RECOMPRESS(43)
1053 #endif
1054
1055 #ifdef DOSTORESTATE44
1056 SHA1_RECOMPRESS(44)
1057 #endif
1058
1059 #ifdef DOSTORESTATE45
1060 SHA1_RECOMPRESS(45)
1061 #endif
1062
1063 #ifdef DOSTORESTATE46
1064 SHA1_RECOMPRESS(46)
1065 #endif
1066
1067 #ifdef DOSTORESTATE47
1068 SHA1_RECOMPRESS(47)
1069 #endif
1070
1071 #ifdef DOSTORESTATE48
1072 SHA1_RECOMPRESS(48)
1073 #endif
1074
1075 #ifdef DOSTORESTATE49
1076 SHA1_RECOMPRESS(49)
1077 #endif
1078
1079 #ifdef DOSTORESTATE50
1080 SHA1_RECOMPRESS(50)
1081 #endif
1082
1083 #ifdef DOSTORESTATE51
1084 SHA1_RECOMPRESS(51)
1085 #endif
1086
1087 #ifdef DOSTORESTATE52
1088 SHA1_RECOMPRESS(52)
1089 #endif
1090
1091 #ifdef DOSTORESTATE53
1092 SHA1_RECOMPRESS(53)
1093 #endif
1094
1095 #ifdef DOSTORESTATE54
1096 SHA1_RECOMPRESS(54)
1097 #endif
1098
1099 #ifdef DOSTORESTATE55
1100 SHA1_RECOMPRESS(55)
1101 #endif
1102
1103 #ifdef DOSTORESTATE56
1104 SHA1_RECOMPRESS(56)
1105 #endif
1106
1107 #ifdef DOSTORESTATE57
1108 SHA1_RECOMPRESS(57)
1109 #endif
1110
1111 #ifdef DOSTORESTATE58
1112 SHA1_RECOMPRESS(58)
1113 #endif
1114
1115 #ifdef DOSTORESTATE59
1116 SHA1_RECOMPRESS(59)
1117 #endif
1118
1119 #ifdef DOSTORESTATE60
1120 SHA1_RECOMPRESS(60)
1121 #endif
1122
1123 #ifdef DOSTORESTATE61
1124 SHA1_RECOMPRESS(61)
1125 #endif
1126
1127 #ifdef DOSTORESTATE62
1128 SHA1_RECOMPRESS(62)
1129 #endif
1130
1131 #ifdef DOSTORESTATE63
1132 SHA1_RECOMPRESS(63)
1133 #endif
1134
1135 #ifdef DOSTORESTATE64
1136 SHA1_RECOMPRESS(64)
1137 #endif
1138
1139 #ifdef DOSTORESTATE65
1140 SHA1_RECOMPRESS(65)
1141 #endif
1142
1143 #ifdef DOSTORESTATE66
1144 SHA1_RECOMPRESS(66)
1145 #endif
1146
1147 #ifdef DOSTORESTATE67
1148 SHA1_RECOMPRESS(67)
1149 #endif
1150
1151 #ifdef DOSTORESTATE68
1152 SHA1_RECOMPRESS(68)
1153 #endif
1154
1155 #ifdef DOSTORESTATE69
1156 SHA1_RECOMPRESS(69)
1157 #endif
1158
1159 #ifdef DOSTORESTATE70
1160 SHA1_RECOMPRESS(70)
1161 #endif
1162
1163 #ifdef DOSTORESTATE71
1164 SHA1_RECOMPRESS(71)
1165 #endif
1166
1167 #ifdef DOSTORESTATE72
1168 SHA1_RECOMPRESS(72)
1169 #endif
1170
1171 #ifdef DOSTORESTATE73
1172 SHA1_RECOMPRESS(73)
1173 #endif
1174
1175 #ifdef DOSTORESTATE74
1176 SHA1_RECOMPRESS(74)
1177 #endif
1178
1179 #ifdef DOSTORESTATE75
1180 SHA1_RECOMPRESS(75)
1181 #endif
1182
1183 #ifdef DOSTORESTATE76
1184 SHA1_RECOMPRESS(76)
1185 #endif
1186
1187 #ifdef DOSTORESTATE77
1188 SHA1_RECOMPRESS(77)
1189 #endif
1190
1191 #ifdef DOSTORESTATE78
1192 SHA1_RECOMPRESS(78)
1193 #endif
1194
1195 #ifdef DOSTORESTATE79
1196 SHA1_RECOMPRESS(79)
1197 #endif
1198
sha1_recompression_step(uint32_t step,uint32_t ihvin[5],uint32_t ihvout[5],const uint32_t me2[80],const uint32_t state[5])1199 static void sha1_recompression_step(uint32_t step, uint32_t ihvin[5], uint32_t ihvout[5], const uint32_t me2[80], const uint32_t state[5])
1200 {
1201 switch (step)
1202 {
1203 #ifdef DOSTORESTATE0
1204 case 0:
1205 sha1recompress_fast_0(ihvin, ihvout, me2, state);
1206 break;
1207 #endif
1208 #ifdef DOSTORESTATE1
1209 case 1:
1210 sha1recompress_fast_1(ihvin, ihvout, me2, state);
1211 break;
1212 #endif
1213 #ifdef DOSTORESTATE2
1214 case 2:
1215 sha1recompress_fast_2(ihvin, ihvout, me2, state);
1216 break;
1217 #endif
1218 #ifdef DOSTORESTATE3
1219 case 3:
1220 sha1recompress_fast_3(ihvin, ihvout, me2, state);
1221 break;
1222 #endif
1223 #ifdef DOSTORESTATE4
1224 case 4:
1225 sha1recompress_fast_4(ihvin, ihvout, me2, state);
1226 break;
1227 #endif
1228 #ifdef DOSTORESTATE5
1229 case 5:
1230 sha1recompress_fast_5(ihvin, ihvout, me2, state);
1231 break;
1232 #endif
1233 #ifdef DOSTORESTATE6
1234 case 6:
1235 sha1recompress_fast_6(ihvin, ihvout, me2, state);
1236 break;
1237 #endif
1238 #ifdef DOSTORESTATE7
1239 case 7:
1240 sha1recompress_fast_7(ihvin, ihvout, me2, state);
1241 break;
1242 #endif
1243 #ifdef DOSTORESTATE8
1244 case 8:
1245 sha1recompress_fast_8(ihvin, ihvout, me2, state);
1246 break;
1247 #endif
1248 #ifdef DOSTORESTATE9
1249 case 9:
1250 sha1recompress_fast_9(ihvin, ihvout, me2, state);
1251 break;
1252 #endif
1253 #ifdef DOSTORESTATE10
1254 case 10:
1255 sha1recompress_fast_10(ihvin, ihvout, me2, state);
1256 break;
1257 #endif
1258 #ifdef DOSTORESTATE11
1259 case 11:
1260 sha1recompress_fast_11(ihvin, ihvout, me2, state);
1261 break;
1262 #endif
1263 #ifdef DOSTORESTATE12
1264 case 12:
1265 sha1recompress_fast_12(ihvin, ihvout, me2, state);
1266 break;
1267 #endif
1268 #ifdef DOSTORESTATE13
1269 case 13:
1270 sha1recompress_fast_13(ihvin, ihvout, me2, state);
1271 break;
1272 #endif
1273 #ifdef DOSTORESTATE14
1274 case 14:
1275 sha1recompress_fast_14(ihvin, ihvout, me2, state);
1276 break;
1277 #endif
1278 #ifdef DOSTORESTATE15
1279 case 15:
1280 sha1recompress_fast_15(ihvin, ihvout, me2, state);
1281 break;
1282 #endif
1283 #ifdef DOSTORESTATE16
1284 case 16:
1285 sha1recompress_fast_16(ihvin, ihvout, me2, state);
1286 break;
1287 #endif
1288 #ifdef DOSTORESTATE17
1289 case 17:
1290 sha1recompress_fast_17(ihvin, ihvout, me2, state);
1291 break;
1292 #endif
1293 #ifdef DOSTORESTATE18
1294 case 18:
1295 sha1recompress_fast_18(ihvin, ihvout, me2, state);
1296 break;
1297 #endif
1298 #ifdef DOSTORESTATE19
1299 case 19:
1300 sha1recompress_fast_19(ihvin, ihvout, me2, state);
1301 break;
1302 #endif
1303 #ifdef DOSTORESTATE20
1304 case 20:
1305 sha1recompress_fast_20(ihvin, ihvout, me2, state);
1306 break;
1307 #endif
1308 #ifdef DOSTORESTATE21
1309 case 21:
1310 sha1recompress_fast_21(ihvin, ihvout, me2, state);
1311 break;
1312 #endif
1313 #ifdef DOSTORESTATE22
1314 case 22:
1315 sha1recompress_fast_22(ihvin, ihvout, me2, state);
1316 break;
1317 #endif
1318 #ifdef DOSTORESTATE23
1319 case 23:
1320 sha1recompress_fast_23(ihvin, ihvout, me2, state);
1321 break;
1322 #endif
1323 #ifdef DOSTORESTATE24
1324 case 24:
1325 sha1recompress_fast_24(ihvin, ihvout, me2, state);
1326 break;
1327 #endif
1328 #ifdef DOSTORESTATE25
1329 case 25:
1330 sha1recompress_fast_25(ihvin, ihvout, me2, state);
1331 break;
1332 #endif
1333 #ifdef DOSTORESTATE26
1334 case 26:
1335 sha1recompress_fast_26(ihvin, ihvout, me2, state);
1336 break;
1337 #endif
1338 #ifdef DOSTORESTATE27
1339 case 27:
1340 sha1recompress_fast_27(ihvin, ihvout, me2, state);
1341 break;
1342 #endif
1343 #ifdef DOSTORESTATE28
1344 case 28:
1345 sha1recompress_fast_28(ihvin, ihvout, me2, state);
1346 break;
1347 #endif
1348 #ifdef DOSTORESTATE29
1349 case 29:
1350 sha1recompress_fast_29(ihvin, ihvout, me2, state);
1351 break;
1352 #endif
1353 #ifdef DOSTORESTATE30
1354 case 30:
1355 sha1recompress_fast_30(ihvin, ihvout, me2, state);
1356 break;
1357 #endif
1358 #ifdef DOSTORESTATE31
1359 case 31:
1360 sha1recompress_fast_31(ihvin, ihvout, me2, state);
1361 break;
1362 #endif
1363 #ifdef DOSTORESTATE32
1364 case 32:
1365 sha1recompress_fast_32(ihvin, ihvout, me2, state);
1366 break;
1367 #endif
1368 #ifdef DOSTORESTATE33
1369 case 33:
1370 sha1recompress_fast_33(ihvin, ihvout, me2, state);
1371 break;
1372 #endif
1373 #ifdef DOSTORESTATE34
1374 case 34:
1375 sha1recompress_fast_34(ihvin, ihvout, me2, state);
1376 break;
1377 #endif
1378 #ifdef DOSTORESTATE35
1379 case 35:
1380 sha1recompress_fast_35(ihvin, ihvout, me2, state);
1381 break;
1382 #endif
1383 #ifdef DOSTORESTATE36
1384 case 36:
1385 sha1recompress_fast_36(ihvin, ihvout, me2, state);
1386 break;
1387 #endif
1388 #ifdef DOSTORESTATE37
1389 case 37:
1390 sha1recompress_fast_37(ihvin, ihvout, me2, state);
1391 break;
1392 #endif
1393 #ifdef DOSTORESTATE38
1394 case 38:
1395 sha1recompress_fast_38(ihvin, ihvout, me2, state);
1396 break;
1397 #endif
1398 #ifdef DOSTORESTATE39
1399 case 39:
1400 sha1recompress_fast_39(ihvin, ihvout, me2, state);
1401 break;
1402 #endif
1403 #ifdef DOSTORESTATE40
1404 case 40:
1405 sha1recompress_fast_40(ihvin, ihvout, me2, state);
1406 break;
1407 #endif
1408 #ifdef DOSTORESTATE41
1409 case 41:
1410 sha1recompress_fast_41(ihvin, ihvout, me2, state);
1411 break;
1412 #endif
1413 #ifdef DOSTORESTATE42
1414 case 42:
1415 sha1recompress_fast_42(ihvin, ihvout, me2, state);
1416 break;
1417 #endif
1418 #ifdef DOSTORESTATE43
1419 case 43:
1420 sha1recompress_fast_43(ihvin, ihvout, me2, state);
1421 break;
1422 #endif
1423 #ifdef DOSTORESTATE44
1424 case 44:
1425 sha1recompress_fast_44(ihvin, ihvout, me2, state);
1426 break;
1427 #endif
1428 #ifdef DOSTORESTATE45
1429 case 45:
1430 sha1recompress_fast_45(ihvin, ihvout, me2, state);
1431 break;
1432 #endif
1433 #ifdef DOSTORESTATE46
1434 case 46:
1435 sha1recompress_fast_46(ihvin, ihvout, me2, state);
1436 break;
1437 #endif
1438 #ifdef DOSTORESTATE47
1439 case 47:
1440 sha1recompress_fast_47(ihvin, ihvout, me2, state);
1441 break;
1442 #endif
1443 #ifdef DOSTORESTATE48
1444 case 48:
1445 sha1recompress_fast_48(ihvin, ihvout, me2, state);
1446 break;
1447 #endif
1448 #ifdef DOSTORESTATE49
1449 case 49:
1450 sha1recompress_fast_49(ihvin, ihvout, me2, state);
1451 break;
1452 #endif
1453 #ifdef DOSTORESTATE50
1454 case 50:
1455 sha1recompress_fast_50(ihvin, ihvout, me2, state);
1456 break;
1457 #endif
1458 #ifdef DOSTORESTATE51
1459 case 51:
1460 sha1recompress_fast_51(ihvin, ihvout, me2, state);
1461 break;
1462 #endif
1463 #ifdef DOSTORESTATE52
1464 case 52:
1465 sha1recompress_fast_52(ihvin, ihvout, me2, state);
1466 break;
1467 #endif
1468 #ifdef DOSTORESTATE53
1469 case 53:
1470 sha1recompress_fast_53(ihvin, ihvout, me2, state);
1471 break;
1472 #endif
1473 #ifdef DOSTORESTATE54
1474 case 54:
1475 sha1recompress_fast_54(ihvin, ihvout, me2, state);
1476 break;
1477 #endif
1478 #ifdef DOSTORESTATE55
1479 case 55:
1480 sha1recompress_fast_55(ihvin, ihvout, me2, state);
1481 break;
1482 #endif
1483 #ifdef DOSTORESTATE56
1484 case 56:
1485 sha1recompress_fast_56(ihvin, ihvout, me2, state);
1486 break;
1487 #endif
1488 #ifdef DOSTORESTATE57
1489 case 57:
1490 sha1recompress_fast_57(ihvin, ihvout, me2, state);
1491 break;
1492 #endif
1493 #ifdef DOSTORESTATE58
1494 case 58:
1495 sha1recompress_fast_58(ihvin, ihvout, me2, state);
1496 break;
1497 #endif
1498 #ifdef DOSTORESTATE59
1499 case 59:
1500 sha1recompress_fast_59(ihvin, ihvout, me2, state);
1501 break;
1502 #endif
1503 #ifdef DOSTORESTATE60
1504 case 60:
1505 sha1recompress_fast_60(ihvin, ihvout, me2, state);
1506 break;
1507 #endif
1508 #ifdef DOSTORESTATE61
1509 case 61:
1510 sha1recompress_fast_61(ihvin, ihvout, me2, state);
1511 break;
1512 #endif
1513 #ifdef DOSTORESTATE62
1514 case 62:
1515 sha1recompress_fast_62(ihvin, ihvout, me2, state);
1516 break;
1517 #endif
1518 #ifdef DOSTORESTATE63
1519 case 63:
1520 sha1recompress_fast_63(ihvin, ihvout, me2, state);
1521 break;
1522 #endif
1523 #ifdef DOSTORESTATE64
1524 case 64:
1525 sha1recompress_fast_64(ihvin, ihvout, me2, state);
1526 break;
1527 #endif
1528 #ifdef DOSTORESTATE65
1529 case 65:
1530 sha1recompress_fast_65(ihvin, ihvout, me2, state);
1531 break;
1532 #endif
1533 #ifdef DOSTORESTATE66
1534 case 66:
1535 sha1recompress_fast_66(ihvin, ihvout, me2, state);
1536 break;
1537 #endif
1538 #ifdef DOSTORESTATE67
1539 case 67:
1540 sha1recompress_fast_67(ihvin, ihvout, me2, state);
1541 break;
1542 #endif
1543 #ifdef DOSTORESTATE68
1544 case 68:
1545 sha1recompress_fast_68(ihvin, ihvout, me2, state);
1546 break;
1547 #endif
1548 #ifdef DOSTORESTATE69
1549 case 69:
1550 sha1recompress_fast_69(ihvin, ihvout, me2, state);
1551 break;
1552 #endif
1553 #ifdef DOSTORESTATE70
1554 case 70:
1555 sha1recompress_fast_70(ihvin, ihvout, me2, state);
1556 break;
1557 #endif
1558 #ifdef DOSTORESTATE71
1559 case 71:
1560 sha1recompress_fast_71(ihvin, ihvout, me2, state);
1561 break;
1562 #endif
1563 #ifdef DOSTORESTATE72
1564 case 72:
1565 sha1recompress_fast_72(ihvin, ihvout, me2, state);
1566 break;
1567 #endif
1568 #ifdef DOSTORESTATE73
1569 case 73:
1570 sha1recompress_fast_73(ihvin, ihvout, me2, state);
1571 break;
1572 #endif
1573 #ifdef DOSTORESTATE74
1574 case 74:
1575 sha1recompress_fast_74(ihvin, ihvout, me2, state);
1576 break;
1577 #endif
1578 #ifdef DOSTORESTATE75
1579 case 75:
1580 sha1recompress_fast_75(ihvin, ihvout, me2, state);
1581 break;
1582 #endif
1583 #ifdef DOSTORESTATE76
1584 case 76:
1585 sha1recompress_fast_76(ihvin, ihvout, me2, state);
1586 break;
1587 #endif
1588 #ifdef DOSTORESTATE77
1589 case 77:
1590 sha1recompress_fast_77(ihvin, ihvout, me2, state);
1591 break;
1592 #endif
1593 #ifdef DOSTORESTATE78
1594 case 78:
1595 sha1recompress_fast_78(ihvin, ihvout, me2, state);
1596 break;
1597 #endif
1598 #ifdef DOSTORESTATE79
1599 case 79:
1600 sha1recompress_fast_79(ihvin, ihvout, me2, state);
1601 break;
1602 #endif
1603 default:
1604 abort();
1605 }
1606
1607 }
1608
1609
1610
sha1_process(SHA1_CTX * ctx,const uint32_t block[16])1611 static void sha1_process(SHA1_CTX* ctx, const uint32_t block[16])
1612 {
1613 unsigned i, j;
1614 uint32_t ubc_dv_mask[DVMASKSIZE] = { 0xFFFFFFFF };
1615 uint32_t ihvtmp[5];
1616
1617 ctx->ihv1[0] = ctx->ihv[0];
1618 ctx->ihv1[1] = ctx->ihv[1];
1619 ctx->ihv1[2] = ctx->ihv[2];
1620 ctx->ihv1[3] = ctx->ihv[3];
1621 ctx->ihv1[4] = ctx->ihv[4];
1622
1623 sha1_compression_states(ctx->ihv, block, ctx->m1, ctx->states);
1624
1625 if (ctx->detect_coll)
1626 {
1627 if (ctx->ubc_check)
1628 {
1629 ubc_check(ctx->m1, ubc_dv_mask);
1630 }
1631
1632 if (ubc_dv_mask[0] != 0)
1633 {
1634 for (i = 0; sha1_dvs[i].dvType != 0; ++i)
1635 {
1636 if (ubc_dv_mask[0] & ((uint32_t)(1) << sha1_dvs[i].maskb))
1637 {
1638 for (j = 0; j < 80; ++j)
1639 ctx->m2[j] = ctx->m1[j] ^ sha1_dvs[i].dm[j];
1640
1641 sha1_recompression_step(sha1_dvs[i].testt, ctx->ihv2, ihvtmp, ctx->m2, ctx->states[sha1_dvs[i].testt]);
1642
1643 /* to verify SHA-1 collision detection code with collisions for reduced-step SHA-1 */
1644 if ((0 == ((ihvtmp[0] ^ ctx->ihv[0]) | (ihvtmp[1] ^ ctx->ihv[1]) | (ihvtmp[2] ^ ctx->ihv[2]) | (ihvtmp[3] ^ ctx->ihv[3]) | (ihvtmp[4] ^ ctx->ihv[4])))
1645 || (ctx->reduced_round_coll && 0==((ctx->ihv1[0] ^ ctx->ihv2[0]) | (ctx->ihv1[1] ^ ctx->ihv2[1]) | (ctx->ihv1[2] ^ ctx->ihv2[2]) | (ctx->ihv1[3] ^ ctx->ihv2[3]) | (ctx->ihv1[4] ^ ctx->ihv2[4]))))
1646 {
1647 ctx->found_collision = 1;
1648
1649 if (ctx->safe_hash)
1650 {
1651 sha1_compression_W(ctx->ihv, ctx->m1);
1652 sha1_compression_W(ctx->ihv, ctx->m1);
1653 }
1654
1655 break;
1656 }
1657 }
1658 }
1659 }
1660 }
1661 }
1662
SHA1DCInit(SHA1_CTX * ctx)1663 void SHA1DCInit(SHA1_CTX* ctx)
1664 {
1665 ctx->total = 0;
1666 ctx->ihv[0] = 0x67452301;
1667 ctx->ihv[1] = 0xEFCDAB89;
1668 ctx->ihv[2] = 0x98BADCFE;
1669 ctx->ihv[3] = 0x10325476;
1670 ctx->ihv[4] = 0xC3D2E1F0;
1671 ctx->found_collision = 0;
1672 ctx->safe_hash = 1;
1673 ctx->ubc_check = 1;
1674 ctx->detect_coll = 1;
1675 ctx->reduced_round_coll = 0;
1676 ctx->callback = NULL;
1677 }
1678
SHA1DCSetSafeHash(SHA1_CTX * ctx,int safehash)1679 void SHA1DCSetSafeHash(SHA1_CTX* ctx, int safehash)
1680 {
1681 if (safehash)
1682 ctx->safe_hash = 1;
1683 else
1684 ctx->safe_hash = 0;
1685 }
1686
1687
SHA1DCSetUseUBC(SHA1_CTX * ctx,int ubc_check)1688 void SHA1DCSetUseUBC(SHA1_CTX* ctx, int ubc_check)
1689 {
1690 if (ubc_check)
1691 ctx->ubc_check = 1;
1692 else
1693 ctx->ubc_check = 0;
1694 }
1695
SHA1DCSetUseDetectColl(SHA1_CTX * ctx,int detect_coll)1696 void SHA1DCSetUseDetectColl(SHA1_CTX* ctx, int detect_coll)
1697 {
1698 if (detect_coll)
1699 ctx->detect_coll = 1;
1700 else
1701 ctx->detect_coll = 0;
1702 }
1703
SHA1DCSetDetectReducedRoundCollision(SHA1_CTX * ctx,int reduced_round_coll)1704 void SHA1DCSetDetectReducedRoundCollision(SHA1_CTX* ctx, int reduced_round_coll)
1705 {
1706 if (reduced_round_coll)
1707 ctx->reduced_round_coll = 1;
1708 else
1709 ctx->reduced_round_coll = 0;
1710 }
1711
SHA1DCSetCallback(SHA1_CTX * ctx,collision_block_callback callback)1712 void SHA1DCSetCallback(SHA1_CTX* ctx, collision_block_callback callback)
1713 {
1714 ctx->callback = callback;
1715 }
1716
SHA1DCUpdate(SHA1_CTX * ctx,const char * buf,size_t len)1717 void SHA1DCUpdate(SHA1_CTX* ctx, const char* buf, size_t len)
1718 {
1719 unsigned left, fill;
1720 if (len == 0)
1721 return;
1722
1723 left = ctx->total & 63;
1724 fill = 64 - left;
1725
1726 if (left && len >= fill)
1727 {
1728 ctx->total += fill;
1729 memcpy(ctx->buffer + left, buf, fill);
1730 sha1_process(ctx, (uint32_t*)(ctx->buffer));
1731 buf += fill;
1732 len -= fill;
1733 left = 0;
1734 }
1735 while (len >= 64)
1736 {
1737 ctx->total += 64;
1738 sha1_process(ctx, (uint32_t*)(buf));
1739 buf += 64;
1740 len -= 64;
1741 }
1742 if (len > 0)
1743 {
1744 ctx->total += len;
1745 memcpy(ctx->buffer + left, buf, len);
1746 }
1747 }
1748
1749 static const unsigned char sha1_padding[64] =
1750 {
1751 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1752 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1753 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1754 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
1755 };
1756
SHA1DCFinal(unsigned char output[20],SHA1_CTX * ctx)1757 int SHA1DCFinal(unsigned char output[20], SHA1_CTX *ctx)
1758 {
1759 uint32_t last = ctx->total & 63;
1760 uint32_t padn = (last < 56) ? (56 - last) : (120 - last);
1761 uint64_t total;
1762 SHA1DCUpdate(ctx, (const char*)(sha1_padding), padn);
1763
1764 total = ctx->total - padn;
1765 total <<= 3;
1766 ctx->buffer[56] = (unsigned char)(total >> 56);
1767 ctx->buffer[57] = (unsigned char)(total >> 48);
1768 ctx->buffer[58] = (unsigned char)(total >> 40);
1769 ctx->buffer[59] = (unsigned char)(total >> 32);
1770 ctx->buffer[60] = (unsigned char)(total >> 24);
1771 ctx->buffer[61] = (unsigned char)(total >> 16);
1772 ctx->buffer[62] = (unsigned char)(total >> 8);
1773 ctx->buffer[63] = (unsigned char)(total);
1774 sha1_process(ctx, (uint32_t*)(ctx->buffer));
1775 output[0] = (unsigned char)(ctx->ihv[0] >> 24);
1776 output[1] = (unsigned char)(ctx->ihv[0] >> 16);
1777 output[2] = (unsigned char)(ctx->ihv[0] >> 8);
1778 output[3] = (unsigned char)(ctx->ihv[0]);
1779 output[4] = (unsigned char)(ctx->ihv[1] >> 24);
1780 output[5] = (unsigned char)(ctx->ihv[1] >> 16);
1781 output[6] = (unsigned char)(ctx->ihv[1] >> 8);
1782 output[7] = (unsigned char)(ctx->ihv[1]);
1783 output[8] = (unsigned char)(ctx->ihv[2] >> 24);
1784 output[9] = (unsigned char)(ctx->ihv[2] >> 16);
1785 output[10] = (unsigned char)(ctx->ihv[2] >> 8);
1786 output[11] = (unsigned char)(ctx->ihv[2]);
1787 output[12] = (unsigned char)(ctx->ihv[3] >> 24);
1788 output[13] = (unsigned char)(ctx->ihv[3] >> 16);
1789 output[14] = (unsigned char)(ctx->ihv[3] >> 8);
1790 output[15] = (unsigned char)(ctx->ihv[3]);
1791 output[16] = (unsigned char)(ctx->ihv[4] >> 24);
1792 output[17] = (unsigned char)(ctx->ihv[4] >> 16);
1793 output[18] = (unsigned char)(ctx->ihv[4] >> 8);
1794 output[19] = (unsigned char)(ctx->ihv[4]);
1795 return ctx->found_collision;
1796 }
1797