sha1dc/sha1.c

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