File Coverage

deps/libgit2/src/hash/sha1/sha1dc/sha1.c

Criterion	Covered	Total	%
statement	185	298	62.0
branch	24	40	60.0
condition			n/a
subroutine			n/a
pod			n/a
total	209	338	61.8

line	stmt	bran	code
1			/***
2			* Copyright 2017 Marc Stevens , 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
10			#include
11			#include
12			#include
13			#ifdef __unix__
14			#include /* 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 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 /
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 or /
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 or or /
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	0		static void sha1_compression_W(uint32_t ihv[5], const uint32_t W[80])
293			{
294	0		uint32_t a = ihv[0], b = ihv[1], c = ihv[2], d = ihv[3], e = ihv[4];
295
296	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 0);
297	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 1);
298	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 2);
299	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 3);
300	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 4);
301	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 5);
302	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 6);
303	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 7);
304	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 8);
305	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 9);
306	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 10);
307	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 11);
308	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 12);
309	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 13);
310	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 14);
311	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(a, b, c, d, e, W, 15);
312	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(e, a, b, c, d, W, 16);
313	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(d, e, a, b, c, W, 17);
314	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(c, d, e, a, b, W, 18);
315	0		HASHCLASH_SHA1COMPRESS_ROUND1_STEP(b, c, d, e, a, W, 19);
316
317	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 20);
318	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 21);
319	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 22);
320	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 23);
321	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 24);
322	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 25);
323	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 26);
324	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 27);
325	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 28);
326	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 29);
327	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 30);
328	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 31);
329	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 32);
330	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 33);
331	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 34);
332	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(a, b, c, d, e, W, 35);
333	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(e, a, b, c, d, W, 36);
334	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(d, e, a, b, c, W, 37);
335	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(c, d, e, a, b, W, 38);
336	0		HASHCLASH_SHA1COMPRESS_ROUND2_STEP(b, c, d, e, a, W, 39);
337
338	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 40);
339	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 41);
340	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 42);
341	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 43);
342	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 44);
343	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 45);
344	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 46);
345	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 47);
346	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 48);
347	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 49);
348	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 50);
349	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 51);
350	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 52);
351	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 53);
352	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 54);
353	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(a, b, c, d, e, W, 55);
354	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(e, a, b, c, d, W, 56);
355	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(d, e, a, b, c, W, 57);
356	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(c, d, e, a, b, W, 58);
357	0		HASHCLASH_SHA1COMPRESS_ROUND3_STEP(b, c, d, e, a, W, 59);
358
359	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 60);
360	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 61);
361	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 62);
362	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 63);
363	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 64);
364	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 65);
365	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 66);
366	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 67);
367	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 68);
368	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 69);
369	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 70);
370	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 71);
371	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 72);
372	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 73);
373	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 74);
374	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(a, b, c, d, e, W, 75);
375	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(e, a, b, c, d, W, 76);
376	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(d, e, a, b, c, W, 77);
377	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(c, d, e, a, b, W, 78);
378	0		HASHCLASH_SHA1COMPRESS_ROUND4_STEP(b, c, d, e, a, W, 79);
379
380	0		ihv[0] += a; ihv[1] += b; ihv[2] += c; ihv[3] += d; ihv[4] += e;
381	0		}
382
383
384
385	4141		void sha1_compression_states(uint32_t ihv[5], const uint32_t m[16], uint32_t W[80], uint32_t states[80][5])
386			{
387	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		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	4141		SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 20, temp);
496
497			#ifdef DOSTORESTATE21
498			SHA1_STORE_STATE(21)
499			#endif
500	4141		SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 21, temp);
501
502			#ifdef DOSTORESTATE22
503			SHA1_STORE_STATE(22)
504			#endif
505	4141		SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 22, temp);
506
507			#ifdef DOSTORESTATE23
508			SHA1_STORE_STATE(23)
509			#endif
510	4141		SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 23, temp);
511
512			#ifdef DOSTORESTATE24
513			SHA1_STORE_STATE(24)
514			#endif
515	4141		SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 24, temp);
516
517			#ifdef DOSTORESTATE25
518			SHA1_STORE_STATE(25)
519			#endif
520	4141		SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 25, temp);
521
522			#ifdef DOSTORESTATE26
523			SHA1_STORE_STATE(26)
524			#endif
525	4141		SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 26, temp);
526
527			#ifdef DOSTORESTATE27
528			SHA1_STORE_STATE(27)
529			#endif
530	4141		SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 27, temp);
531
532			#ifdef DOSTORESTATE28
533			SHA1_STORE_STATE(28)
534			#endif
535	4141		SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 28, temp);
536
537			#ifdef DOSTORESTATE29
538			SHA1_STORE_STATE(29)
539			#endif
540	4141		SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 29, temp);
541
542			#ifdef DOSTORESTATE30
543			SHA1_STORE_STATE(30)
544			#endif
545	4141		SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 30, temp);
546
547			#ifdef DOSTORESTATE31
548			SHA1_STORE_STATE(31)
549			#endif
550	4141		SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 31, temp);
551
552			#ifdef DOSTORESTATE32
553			SHA1_STORE_STATE(32)
554			#endif
555	4141		SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 32, temp);
556
557			#ifdef DOSTORESTATE33
558			SHA1_STORE_STATE(33)
559			#endif
560	4141		SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 33, temp);
561
562			#ifdef DOSTORESTATE34
563			SHA1_STORE_STATE(34)
564			#endif
565	4141		SHA1COMPRESS_FULL_ROUND2_STEP(b, c, d, e, a, W, 34, temp);
566
567			#ifdef DOSTORESTATE35
568			SHA1_STORE_STATE(35)
569			#endif
570	4141		SHA1COMPRESS_FULL_ROUND2_STEP(a, b, c, d, e, W, 35, temp);
571
572			#ifdef DOSTORESTATE36
573			SHA1_STORE_STATE(36)
574			#endif
575	4141		SHA1COMPRESS_FULL_ROUND2_STEP(e, a, b, c, d, W, 36, temp);
576
577			#ifdef DOSTORESTATE37
578			SHA1_STORE_STATE(37)
579			#endif
580	4141		SHA1COMPRESS_FULL_ROUND2_STEP(d, e, a, b, c, W, 37, temp);
581
582			#ifdef DOSTORESTATE38
583			SHA1_STORE_STATE(38)
584			#endif
585	4141		SHA1COMPRESS_FULL_ROUND2_STEP(c, d, e, a, b, W, 38, temp);
586
587			#ifdef DOSTORESTATE39
588			SHA1_STORE_STATE(39)
589			#endif
590	4141		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	4141		SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 40, temp);
598
599			#ifdef DOSTORESTATE41
600			SHA1_STORE_STATE(41)
601			#endif
602	4141		SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 41, temp);
603
604			#ifdef DOSTORESTATE42
605			SHA1_STORE_STATE(42)
606			#endif
607	4141		SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 42, temp);
608
609			#ifdef DOSTORESTATE43
610			SHA1_STORE_STATE(43)
611			#endif
612	4141		SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 43, temp);
613
614			#ifdef DOSTORESTATE44
615			SHA1_STORE_STATE(44)
616			#endif
617	4141		SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 44, temp);
618
619			#ifdef DOSTORESTATE45
620			SHA1_STORE_STATE(45)
621			#endif
622	4141		SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 45, temp);
623
624			#ifdef DOSTORESTATE46
625			SHA1_STORE_STATE(46)
626			#endif
627	4141		SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 46, temp);
628
629			#ifdef DOSTORESTATE47
630			SHA1_STORE_STATE(47)
631			#endif
632	4141		SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 47, temp);
633
634			#ifdef DOSTORESTATE48
635			SHA1_STORE_STATE(48)
636			#endif
637	4141		SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 48, temp);
638
639			#ifdef DOSTORESTATE49
640			SHA1_STORE_STATE(49)
641			#endif
642	4141		SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 49, temp);
643
644			#ifdef DOSTORESTATE50
645			SHA1_STORE_STATE(50)
646			#endif
647	4141		SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 50, temp);
648
649			#ifdef DOSTORESTATE51
650			SHA1_STORE_STATE(51)
651			#endif
652	4141		SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 51, temp);
653
654			#ifdef DOSTORESTATE52
655			SHA1_STORE_STATE(52)
656			#endif
657	4141		SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 52, temp);
658
659			#ifdef DOSTORESTATE53
660			SHA1_STORE_STATE(53)
661			#endif
662	4141		SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 53, temp);
663
664			#ifdef DOSTORESTATE54
665			SHA1_STORE_STATE(54)
666			#endif
667	4141		SHA1COMPRESS_FULL_ROUND3_STEP(b, c, d, e, a, W, 54, temp);
668
669			#ifdef DOSTORESTATE55
670			SHA1_STORE_STATE(55)
671			#endif
672	4141		SHA1COMPRESS_FULL_ROUND3_STEP(a, b, c, d, e, W, 55, temp);
673
674			#ifdef DOSTORESTATE56
675			SHA1_STORE_STATE(56)
676			#endif
677	4141		SHA1COMPRESS_FULL_ROUND3_STEP(e, a, b, c, d, W, 56, temp);
678
679			#ifdef DOSTORESTATE57
680			SHA1_STORE_STATE(57)
681			#endif
682	4141		SHA1COMPRESS_FULL_ROUND3_STEP(d, e, a, b, c, W, 57, temp);
683
684			#ifdef DOSTORESTATE58
685	4141		SHA1_STORE_STATE(58)
686			#endif
687	4141		SHA1COMPRESS_FULL_ROUND3_STEP(c, d, e, a, b, W, 58, temp);
688
689			#ifdef DOSTORESTATE59
690			SHA1_STORE_STATE(59)
691			#endif
692	4141		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	4141		SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 60, temp);
701
702			#ifdef DOSTORESTATE61
703			SHA1_STORE_STATE(61)
704			#endif
705	4141		SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 61, temp);
706
707			#ifdef DOSTORESTATE62
708			SHA1_STORE_STATE(62)
709			#endif
710	4141		SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 62, temp);
711
712			#ifdef DOSTORESTATE63
713			SHA1_STORE_STATE(63)
714			#endif
715	4141		SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 63, temp);
716
717			#ifdef DOSTORESTATE64
718			SHA1_STORE_STATE(64)
719			#endif
720	4141		SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 64, temp);
721
722			#ifdef DOSTORESTATE65
723	4141		SHA1_STORE_STATE(65)
724			#endif
725	4141		SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 65, temp);
726
727			#ifdef DOSTORESTATE66
728			SHA1_STORE_STATE(66)
729			#endif
730	4141		SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 66, temp);
731
732			#ifdef DOSTORESTATE67
733			SHA1_STORE_STATE(67)
734			#endif
735	4141		SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 67, temp);
736
737			#ifdef DOSTORESTATE68
738			SHA1_STORE_STATE(68)
739			#endif
740	4141		SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 68, temp);
741
742			#ifdef DOSTORESTATE69
743			SHA1_STORE_STATE(69)
744			#endif
745	4141		SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 69, temp);
746
747			#ifdef DOSTORESTATE70
748			SHA1_STORE_STATE(70)
749			#endif
750	4141		SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 70, temp);
751
752			#ifdef DOSTORESTATE71
753			SHA1_STORE_STATE(71)
754			#endif
755	4141		SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 71, temp);
756
757			#ifdef DOSTORESTATE72
758			SHA1_STORE_STATE(72)
759			#endif
760	4141		SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 72, temp);
761
762			#ifdef DOSTORESTATE73
763			SHA1_STORE_STATE(73)
764			#endif
765	4141		SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 73, temp);
766
767			#ifdef DOSTORESTATE74
768			SHA1_STORE_STATE(74)
769			#endif
770	4141		SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 74, temp);
771
772			#ifdef DOSTORESTATE75
773			SHA1_STORE_STATE(75)
774			#endif
775	4141		SHA1COMPRESS_FULL_ROUND4_STEP(a, b, c, d, e, W, 75, temp);
776
777			#ifdef DOSTORESTATE76
778			SHA1_STORE_STATE(76)
779			#endif
780	4141		SHA1COMPRESS_FULL_ROUND4_STEP(e, a, b, c, d, W, 76, temp);
781
782			#ifdef DOSTORESTATE77
783			SHA1_STORE_STATE(77)
784			#endif
785	4141		SHA1COMPRESS_FULL_ROUND4_STEP(d, e, a, b, c, W, 77, temp);
786
787			#ifdef DOSTORESTATE78
788			SHA1_STORE_STATE(78)
789			#endif
790	4141		SHA1COMPRESS_FULL_ROUND4_STEP(c, d, e, a, b, W, 78, temp);
791
792			#ifdef DOSTORESTATE79
793			SHA1_STORE_STATE(79)
794			#endif
795	4141		SHA1COMPRESS_FULL_ROUND4_STEP(b, c, d, e, a, W, 79, temp);
796
797
798
799	4141		ihv[0] += a; ihv[1] += b; ihv[2] += c; ihv[3] += d; ihv[4] += e;
800	4141		}
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	306		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	24		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	165		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	165		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	153		sha1recompress_fast_58(ihvin, ihvout, me2, state);
1600	153		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	12		sha1recompress_fast_65(ihvin, ihvout, me2, state);
1635	12		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	0		abort();
1709			}
1710
1711	165		}
1712
1713
1714
1715	4141		static void sha1_process(SHA1_CTX* ctx, const uint32_t block[16])
1716			{
1717			unsigned i, j;
1718	4141		uint32_t ubc_dv_mask[DVMASKSIZE] = { 0xFFFFFFFF };
1719			uint32_t ihvtmp[5];
1720
1721	4141		ctx->ihv1[0] = ctx->ihv[0];
1722	4141		ctx->ihv1[1] = ctx->ihv[1];
1723	4141		ctx->ihv1[2] = ctx->ihv[2];
1724	4141		ctx->ihv1[3] = ctx->ihv[3];
1725	4141		ctx->ihv1[4] = ctx->ihv[4];
1726
1727	4141		sha1_compression_states(ctx->ihv, block, ctx->m1, ctx->states);
1728
1729	4141	50	if (ctx->detect_coll)
1730			{
1731	4141	50	if (ctx->ubc_check)
1732			{
1733	4141		ubc_check(ctx->m1, ubc_dv_mask);
1734			}
1735
1736	4141	100	if (ubc_dv_mask[0] != 0)
1737			{
1738	5313	100	for (i = 0; sha1_dvs[i].dvType != 0; ++i)
1739			{
1740	5152	100	if (ubc_dv_mask[0] & ((uint32_t)(1) << sha1_dvs[i].maskb))
1741			{
1742	13365	100	for (j = 0; j < 80; ++j)
1743	13200		ctx->m2[j] = ctx->m1[j] ^ sha1_dvs[i].dm[j];
1744
1745	165		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	165	50	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	165	50	\|\| (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]))))
		0
1750			{
1751	0		ctx->found_collision = 1;
1752
1753	0	0	if (ctx->safe_hash)
1754			{
1755	0		sha1_compression_W(ctx->ihv, ctx->m1);
1756	0		sha1_compression_W(ctx->ihv, ctx->m1);
1757			}
1758
1759	0		break;
1760			}
1761			}
1762			}
1763			}
1764			}
1765	4141		}
1766
1767	1445		void SHA1DCInit(SHA1_CTX* ctx)
1768			{
1769	1445		ctx->total = 0;
1770	1445		ctx->ihv[0] = 0x67452301;
1771	1445		ctx->ihv[1] = 0xEFCDAB89;
1772	1445		ctx->ihv[2] = 0x98BADCFE;
1773	1445		ctx->ihv[3] = 0x10325476;
1774	1445		ctx->ihv[4] = 0xC3D2E1F0;
1775	1445		ctx->found_collision = 0;
1776	1445		ctx->safe_hash = SHA1DC_INIT_SAFE_HASH_DEFAULT;
1777	1445		ctx->ubc_check = 1;
1778	1445		ctx->detect_coll = 1;
1779	1445		ctx->reduced_round_coll = 0;
1780	1445		ctx->callback = NULL;
1781	1445		}
1782
1783	0		void SHA1DCSetSafeHash(SHA1_CTX* ctx, int safehash)
1784			{
1785	0	0	if (safehash)
1786	0		ctx->safe_hash = 1;
1787			else
1788	0		ctx->safe_hash = 0;
1789	0		}
1790
1791
1792	0		void SHA1DCSetUseUBC(SHA1_CTX* ctx, int ubc_check)
1793			{
1794	0	0	if (ubc_check)
1795	0		ctx->ubc_check = 1;
1796			else
1797	0		ctx->ubc_check = 0;
1798	0		}
1799
1800	0		void SHA1DCSetUseDetectColl(SHA1_CTX* ctx, int detect_coll)
1801			{
1802	0	0	if (detect_coll)
1803	0		ctx->detect_coll = 1;
1804			else
1805	0		ctx->detect_coll = 0;
1806	0		}
1807
1808	0		void SHA1DCSetDetectReducedRoundCollision(SHA1_CTX* ctx, int reduced_round_coll)
1809			{
1810	0	0	if (reduced_round_coll)
1811	0		ctx->reduced_round_coll = 1;
1812			else
1813	0		ctx->reduced_round_coll = 0;
1814	0		}
1815
1816	0		void SHA1DCSetCallback(SHA1_CTX* ctx, collision_block_callback callback)
1817			{
1818	0		ctx->callback = callback;
1819	0		}
1820
1821	4262		void SHA1DCUpdate(SHA1_CTX* ctx, const char* buf, size_t len)
1822			{
1823			unsigned left, fill;
1824
1825	4262	100	if (len == 0)
1826	79		return;
1827
1828	4183		left = ctx->total & 63;
1829	4183		fill = 64 - left;
1830
1831	4183	100	if (left && len >= fill)
		100
1832			{
1833	834		ctx->total += fill;
1834	834		memcpy(ctx->buffer + left, buf, fill);
1835	834		sha1_process(ctx, (uint32_t*)(ctx->buffer));
1836	834		buf += fill;
1837	834		len -= fill;
1838	834		left = 0;
1839			}
1840	6103	100	while (len >= 64)
1841			{
1842	1920		ctx->total += 64;
1843
1844			#if defined(SHA1DC_ALLOW_UNALIGNED_ACCESS)
1845	1920		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	1920		buf += 64;
1851	1920		len -= 64;
1852			}
1853	4183	100	if (len > 0)
1854			{
1855	4180		ctx->total += len;
1856	4180		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	1387		int SHA1DCFinal(unsigned char output[20], SHA1_CTX *ctx)
1869			{
1870	1387		uint32_t last = ctx->total & 63;
1871	1387	100	uint32_t padn = (last < 56) ? (56 - last) : (120 - last);
1872			uint64_t total;
1873	1387		SHA1DCUpdate(ctx, (const char*)(sha1_padding), padn);
1874
1875	1387		total = ctx->total - padn;
1876	1387		total <<= 3;
1877	1387		ctx->buffer[56] = (unsigned char)(total >> 56);
1878	1387		ctx->buffer[57] = (unsigned char)(total >> 48);
1879	1387		ctx->buffer[58] = (unsigned char)(total >> 40);
1880	1387		ctx->buffer[59] = (unsigned char)(total >> 32);
1881	1387		ctx->buffer[60] = (unsigned char)(total >> 24);
1882	1387		ctx->buffer[61] = (unsigned char)(total >> 16);
1883	1387		ctx->buffer[62] = (unsigned char)(total >> 8);
1884	1387		ctx->buffer[63] = (unsigned char)(total);
1885	1387		sha1_process(ctx, (uint32_t*)(ctx->buffer));
1886	1387		output[0] = (unsigned char)(ctx->ihv[0] >> 24);
1887	1387		output[1] = (unsigned char)(ctx->ihv[0] >> 16);
1888	1387		output[2] = (unsigned char)(ctx->ihv[0] >> 8);
1889	1387		output[3] = (unsigned char)(ctx->ihv[0]);
1890	1387		output[4] = (unsigned char)(ctx->ihv[1] >> 24);
1891	1387		output[5] = (unsigned char)(ctx->ihv[1] >> 16);
1892	1387		output[6] = (unsigned char)(ctx->ihv[1] >> 8);
1893	1387		output[7] = (unsigned char)(ctx->ihv[1]);
1894	1387		output[8] = (unsigned char)(ctx->ihv[2] >> 24);
1895	1387		output[9] = (unsigned char)(ctx->ihv[2] >> 16);
1896	1387		output[10] = (unsigned char)(ctx->ihv[2] >> 8);
1897	1387		output[11] = (unsigned char)(ctx->ihv[2]);
1898	1387		output[12] = (unsigned char)(ctx->ihv[3] >> 24);
1899	1387		output[13] = (unsigned char)(ctx->ihv[3] >> 16);
1900	1387		output[14] = (unsigned char)(ctx->ihv[3] >> 8);
1901	1387		output[15] = (unsigned char)(ctx->ihv[3]);
1902	1387		output[16] = (unsigned char)(ctx->ihv[4] >> 24);
1903	1387		output[17] = (unsigned char)(ctx->ihv[4] >> 16);
1904	1387		output[18] = (unsigned char)(ctx->ihv[4] >> 8);
1905	1387		output[19] = (unsigned char)(ctx->ihv[4]);
1906	1387		return ctx->found_collision;
1907			}
1908
1909			#ifdef SHA1DC_CUSTOM_TRAILING_INCLUDE_SHA1_C
1910			#include SHA1DC_CUSTOM_TRAILING_INCLUDE_SHA1_C
1911			#endif