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