Branch data Line data Source code
# 1 : : // Copyright (c) 2014-2019 The Bitcoin Core developers
# 2 : : // Distributed under the MIT software license, see the accompanying
# 3 : : // file COPYING or http://www.opensource.org/licenses/mit-license.php.
# 4 : :
# 5 : : #include <crypto/sha256.h>
# 6 : : #include <crypto/common.h>
# 7 : :
# 8 : : #include <assert.h>
# 9 : : #include <string.h>
# 10 : :
# 11 : : #include <compat/cpuid.h>
# 12 : :
# 13 : : #if defined(__x86_64__) || defined(__amd64__) || defined(__i386__)
# 14 : : #if defined(USE_ASM)
# 15 : : namespace sha256_sse4
# 16 : : {
# 17 : : void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks);
# 18 : : }
# 19 : : #endif
# 20 : : #endif
# 21 : :
# 22 : : namespace sha256d64_sse41
# 23 : : {
# 24 : : void Transform_4way(unsigned char* out, const unsigned char* in);
# 25 : : }
# 26 : :
# 27 : : namespace sha256d64_avx2
# 28 : : {
# 29 : : void Transform_8way(unsigned char* out, const unsigned char* in);
# 30 : : }
# 31 : :
# 32 : : namespace sha256d64_shani
# 33 : : {
# 34 : : void Transform_2way(unsigned char* out, const unsigned char* in);
# 35 : : }
# 36 : :
# 37 : : namespace sha256_shani
# 38 : : {
# 39 : : void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks);
# 40 : : }
# 41 : :
# 42 : : // Internal implementation code.
# 43 : : namespace
# 44 : : {
# 45 : : /// Internal SHA-256 implementation.
# 46 : : namespace sha256
# 47 : : {
# 48 : 6891904 : uint32_t inline Ch(uint32_t x, uint32_t y, uint32_t z) { return z ^ (x & (y ^ z)); }
# 49 : 6891904 : uint32_t inline Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (z & (x | y)); }
# 50 : 6891904 : uint32_t inline Sigma0(uint32_t x) { return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10); }
# 51 : 6891904 : uint32_t inline Sigma1(uint32_t x) { return (x >> 6 | x << 26) ^ (x >> 11 | x << 21) ^ (x >> 25 | x << 7); }
# 52 : 5168928 : uint32_t inline sigma0(uint32_t x) { return (x >> 7 | x << 25) ^ (x >> 18 | x << 14) ^ (x >> 3); }
# 53 : 5168928 : uint32_t inline sigma1(uint32_t x) { return (x >> 17 | x << 15) ^ (x >> 19 | x << 13) ^ (x >> 10); }
# 54 : :
# 55 : : /** One round of SHA-256. */
# 56 : : void inline Round(uint32_t a, uint32_t b, uint32_t c, uint32_t& d, uint32_t e, uint32_t f, uint32_t g, uint32_t& h, uint32_t k)
# 57 : 6891904 : {
# 58 : 6891904 : uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k;
# 59 : 6891904 : uint32_t t2 = Sigma0(a) + Maj(a, b, c);
# 60 : 6891904 : d += t1;
# 61 : 6891904 : h = t1 + t2;
# 62 : 6891904 : }
# 63 : :
# 64 : : /** Initialize SHA-256 state. */
# 65 : : void inline Initialize(uint32_t* s)
# 66 : 599552432 : {
# 67 : 599552432 : s[0] = 0x6a09e667ul;
# 68 : 599552432 : s[1] = 0xbb67ae85ul;
# 69 : 599552432 : s[2] = 0x3c6ef372ul;
# 70 : 599552432 : s[3] = 0xa54ff53aul;
# 71 : 599552432 : s[4] = 0x510e527ful;
# 72 : 599552432 : s[5] = 0x9b05688cul;
# 73 : 599552432 : s[6] = 0x1f83d9abul;
# 74 : 599552432 : s[7] = 0x5be0cd19ul;
# 75 : 599552432 : }
# 76 : :
# 77 : : /** Perform a number of SHA-256 transformations, processing 64-byte chunks. */
# 78 : : void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks)
# 79 : 102301 : {
# 80 [ + + ]: 209987 : while (blocks--) {
# 81 : 107686 : uint32_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
# 82 : 107686 : uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
# 83 : :
# 84 : 107686 : Round(a, b, c, d, e, f, g, h, 0x428a2f98 + (w0 = ReadBE32(chunk + 0)));
# 85 : 107686 : Round(h, a, b, c, d, e, f, g, 0x71374491 + (w1 = ReadBE32(chunk + 4)));
# 86 : 107686 : Round(g, h, a, b, c, d, e, f, 0xb5c0fbcf + (w2 = ReadBE32(chunk + 8)));
# 87 : 107686 : Round(f, g, h, a, b, c, d, e, 0xe9b5dba5 + (w3 = ReadBE32(chunk + 12)));
# 88 : 107686 : Round(e, f, g, h, a, b, c, d, 0x3956c25b + (w4 = ReadBE32(chunk + 16)));
# 89 : 107686 : Round(d, e, f, g, h, a, b, c, 0x59f111f1 + (w5 = ReadBE32(chunk + 20)));
# 90 : 107686 : Round(c, d, e, f, g, h, a, b, 0x923f82a4 + (w6 = ReadBE32(chunk + 24)));
# 91 : 107686 : Round(b, c, d, e, f, g, h, a, 0xab1c5ed5 + (w7 = ReadBE32(chunk + 28)));
# 92 : 107686 : Round(a, b, c, d, e, f, g, h, 0xd807aa98 + (w8 = ReadBE32(chunk + 32)));
# 93 : 107686 : Round(h, a, b, c, d, e, f, g, 0x12835b01 + (w9 = ReadBE32(chunk + 36)));
# 94 : 107686 : Round(g, h, a, b, c, d, e, f, 0x243185be + (w10 = ReadBE32(chunk + 40)));
# 95 : 107686 : Round(f, g, h, a, b, c, d, e, 0x550c7dc3 + (w11 = ReadBE32(chunk + 44)));
# 96 : 107686 : Round(e, f, g, h, a, b, c, d, 0x72be5d74 + (w12 = ReadBE32(chunk + 48)));
# 97 : 107686 : Round(d, e, f, g, h, a, b, c, 0x80deb1fe + (w13 = ReadBE32(chunk + 52)));
# 98 : 107686 : Round(c, d, e, f, g, h, a, b, 0x9bdc06a7 + (w14 = ReadBE32(chunk + 56)));
# 99 : 107686 : Round(b, c, d, e, f, g, h, a, 0xc19bf174 + (w15 = ReadBE32(chunk + 60)));
# 100 : :
# 101 : 107686 : Round(a, b, c, d, e, f, g, h, 0xe49b69c1 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
# 102 : 107686 : Round(h, a, b, c, d, e, f, g, 0xefbe4786 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
# 103 : 107686 : Round(g, h, a, b, c, d, e, f, 0x0fc19dc6 + (w2 += sigma1(w0) + w11 + sigma0(w3)));
# 104 : 107686 : Round(f, g, h, a, b, c, d, e, 0x240ca1cc + (w3 += sigma1(w1) + w12 + sigma0(w4)));
# 105 : 107686 : Round(e, f, g, h, a, b, c, d, 0x2de92c6f + (w4 += sigma1(w2) + w13 + sigma0(w5)));
# 106 : 107686 : Round(d, e, f, g, h, a, b, c, 0x4a7484aa + (w5 += sigma1(w3) + w14 + sigma0(w6)));
# 107 : 107686 : Round(c, d, e, f, g, h, a, b, 0x5cb0a9dc + (w6 += sigma1(w4) + w15 + sigma0(w7)));
# 108 : 107686 : Round(b, c, d, e, f, g, h, a, 0x76f988da + (w7 += sigma1(w5) + w0 + sigma0(w8)));
# 109 : 107686 : Round(a, b, c, d, e, f, g, h, 0x983e5152 + (w8 += sigma1(w6) + w1 + sigma0(w9)));
# 110 : 107686 : Round(h, a, b, c, d, e, f, g, 0xa831c66d + (w9 += sigma1(w7) + w2 + sigma0(w10)));
# 111 : 107686 : Round(g, h, a, b, c, d, e, f, 0xb00327c8 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
# 112 : 107686 : Round(f, g, h, a, b, c, d, e, 0xbf597fc7 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
# 113 : 107686 : Round(e, f, g, h, a, b, c, d, 0xc6e00bf3 + (w12 += sigma1(w10) + w5 + sigma0(w13)));
# 114 : 107686 : Round(d, e, f, g, h, a, b, c, 0xd5a79147 + (w13 += sigma1(w11) + w6 + sigma0(w14)));
# 115 : 107686 : Round(c, d, e, f, g, h, a, b, 0x06ca6351 + (w14 += sigma1(w12) + w7 + sigma0(w15)));
# 116 : 107686 : Round(b, c, d, e, f, g, h, a, 0x14292967 + (w15 += sigma1(w13) + w8 + sigma0(w0)));
# 117 : :
# 118 : 107686 : Round(a, b, c, d, e, f, g, h, 0x27b70a85 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
# 119 : 107686 : Round(h, a, b, c, d, e, f, g, 0x2e1b2138 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
# 120 : 107686 : Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc + (w2 += sigma1(w0) + w11 + sigma0(w3)));
# 121 : 107686 : Round(f, g, h, a, b, c, d, e, 0x53380d13 + (w3 += sigma1(w1) + w12 + sigma0(w4)));
# 122 : 107686 : Round(e, f, g, h, a, b, c, d, 0x650a7354 + (w4 += sigma1(w2) + w13 + sigma0(w5)));
# 123 : 107686 : Round(d, e, f, g, h, a, b, c, 0x766a0abb + (w5 += sigma1(w3) + w14 + sigma0(w6)));
# 124 : 107686 : Round(c, d, e, f, g, h, a, b, 0x81c2c92e + (w6 += sigma1(w4) + w15 + sigma0(w7)));
# 125 : 107686 : Round(b, c, d, e, f, g, h, a, 0x92722c85 + (w7 += sigma1(w5) + w0 + sigma0(w8)));
# 126 : 107686 : Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1 + (w8 += sigma1(w6) + w1 + sigma0(w9)));
# 127 : 107686 : Round(h, a, b, c, d, e, f, g, 0xa81a664b + (w9 += sigma1(w7) + w2 + sigma0(w10)));
# 128 : 107686 : Round(g, h, a, b, c, d, e, f, 0xc24b8b70 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
# 129 : 107686 : Round(f, g, h, a, b, c, d, e, 0xc76c51a3 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
# 130 : 107686 : Round(e, f, g, h, a, b, c, d, 0xd192e819 + (w12 += sigma1(w10) + w5 + sigma0(w13)));
# 131 : 107686 : Round(d, e, f, g, h, a, b, c, 0xd6990624 + (w13 += sigma1(w11) + w6 + sigma0(w14)));
# 132 : 107686 : Round(c, d, e, f, g, h, a, b, 0xf40e3585 + (w14 += sigma1(w12) + w7 + sigma0(w15)));
# 133 : 107686 : Round(b, c, d, e, f, g, h, a, 0x106aa070 + (w15 += sigma1(w13) + w8 + sigma0(w0)));
# 134 : :
# 135 : 107686 : Round(a, b, c, d, e, f, g, h, 0x19a4c116 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
# 136 : 107686 : Round(h, a, b, c, d, e, f, g, 0x1e376c08 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
# 137 : 107686 : Round(g, h, a, b, c, d, e, f, 0x2748774c + (w2 += sigma1(w0) + w11 + sigma0(w3)));
# 138 : 107686 : Round(f, g, h, a, b, c, d, e, 0x34b0bcb5 + (w3 += sigma1(w1) + w12 + sigma0(w4)));
# 139 : 107686 : Round(e, f, g, h, a, b, c, d, 0x391c0cb3 + (w4 += sigma1(w2) + w13 + sigma0(w5)));
# 140 : 107686 : Round(d, e, f, g, h, a, b, c, 0x4ed8aa4a + (w5 += sigma1(w3) + w14 + sigma0(w6)));
# 141 : 107686 : Round(c, d, e, f, g, h, a, b, 0x5b9cca4f + (w6 += sigma1(w4) + w15 + sigma0(w7)));
# 142 : 107686 : Round(b, c, d, e, f, g, h, a, 0x682e6ff3 + (w7 += sigma1(w5) + w0 + sigma0(w8)));
# 143 : 107686 : Round(a, b, c, d, e, f, g, h, 0x748f82ee + (w8 += sigma1(w6) + w1 + sigma0(w9)));
# 144 : 107686 : Round(h, a, b, c, d, e, f, g, 0x78a5636f + (w9 += sigma1(w7) + w2 + sigma0(w10)));
# 145 : 107686 : Round(g, h, a, b, c, d, e, f, 0x84c87814 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
# 146 : 107686 : Round(f, g, h, a, b, c, d, e, 0x8cc70208 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
# 147 : 107686 : Round(e, f, g, h, a, b, c, d, 0x90befffa + (w12 += sigma1(w10) + w5 + sigma0(w13)));
# 148 : 107686 : Round(d, e, f, g, h, a, b, c, 0xa4506ceb + (w13 += sigma1(w11) + w6 + sigma0(w14)));
# 149 : 107686 : Round(c, d, e, f, g, h, a, b, 0xbef9a3f7 + (w14 + sigma1(w12) + w7 + sigma0(w15)));
# 150 : 107686 : Round(b, c, d, e, f, g, h, a, 0xc67178f2 + (w15 + sigma1(w13) + w8 + sigma0(w0)));
# 151 : :
# 152 : 107686 : s[0] += a;
# 153 : 107686 : s[1] += b;
# 154 : 107686 : s[2] += c;
# 155 : 107686 : s[3] += d;
# 156 : 107686 : s[4] += e;
# 157 : 107686 : s[5] += f;
# 158 : 107686 : s[6] += g;
# 159 : 107686 : s[7] += h;
# 160 : 107686 : chunk += 64;
# 161 : 107686 : }
# 162 : 102301 : }
# 163 : :
# 164 : : void TransformD64(unsigned char* out, const unsigned char* in)
# 165 : 0 : {
# 166 : : // Transform 1
# 167 : 0 : uint32_t a = 0x6a09e667ul;
# 168 : 0 : uint32_t b = 0xbb67ae85ul;
# 169 : 0 : uint32_t c = 0x3c6ef372ul;
# 170 : 0 : uint32_t d = 0xa54ff53aul;
# 171 : 0 : uint32_t e = 0x510e527ful;
# 172 : 0 : uint32_t f = 0x9b05688cul;
# 173 : 0 : uint32_t g = 0x1f83d9abul;
# 174 : 0 : uint32_t h = 0x5be0cd19ul;
# 175 : :
# 176 : 0 : uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
# 177 : :
# 178 : 0 : Round(a, b, c, d, e, f, g, h, 0x428a2f98ul + (w0 = ReadBE32(in + 0)));
# 179 : 0 : Round(h, a, b, c, d, e, f, g, 0x71374491ul + (w1 = ReadBE32(in + 4)));
# 180 : 0 : Round(g, h, a, b, c, d, e, f, 0xb5c0fbcful + (w2 = ReadBE32(in + 8)));
# 181 : 0 : Round(f, g, h, a, b, c, d, e, 0xe9b5dba5ul + (w3 = ReadBE32(in + 12)));
# 182 : 0 : Round(e, f, g, h, a, b, c, d, 0x3956c25bul + (w4 = ReadBE32(in + 16)));
# 183 : 0 : Round(d, e, f, g, h, a, b, c, 0x59f111f1ul + (w5 = ReadBE32(in + 20)));
# 184 : 0 : Round(c, d, e, f, g, h, a, b, 0x923f82a4ul + (w6 = ReadBE32(in + 24)));
# 185 : 0 : Round(b, c, d, e, f, g, h, a, 0xab1c5ed5ul + (w7 = ReadBE32(in + 28)));
# 186 : 0 : Round(a, b, c, d, e, f, g, h, 0xd807aa98ul + (w8 = ReadBE32(in + 32)));
# 187 : 0 : Round(h, a, b, c, d, e, f, g, 0x12835b01ul + (w9 = ReadBE32(in + 36)));
# 188 : 0 : Round(g, h, a, b, c, d, e, f, 0x243185beul + (w10 = ReadBE32(in + 40)));
# 189 : 0 : Round(f, g, h, a, b, c, d, e, 0x550c7dc3ul + (w11 = ReadBE32(in + 44)));
# 190 : 0 : Round(e, f, g, h, a, b, c, d, 0x72be5d74ul + (w12 = ReadBE32(in + 48)));
# 191 : 0 : Round(d, e, f, g, h, a, b, c, 0x80deb1feul + (w13 = ReadBE32(in + 52)));
# 192 : 0 : Round(c, d, e, f, g, h, a, b, 0x9bdc06a7ul + (w14 = ReadBE32(in + 56)));
# 193 : 0 : Round(b, c, d, e, f, g, h, a, 0xc19bf174ul + (w15 = ReadBE32(in + 60)));
# 194 : 0 : Round(a, b, c, d, e, f, g, h, 0xe49b69c1ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
# 195 : 0 : Round(h, a, b, c, d, e, f, g, 0xefbe4786ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
# 196 : 0 : Round(g, h, a, b, c, d, e, f, 0x0fc19dc6ul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
# 197 : 0 : Round(f, g, h, a, b, c, d, e, 0x240ca1ccul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
# 198 : 0 : Round(e, f, g, h, a, b, c, d, 0x2de92c6ful + (w4 += sigma1(w2) + w13 + sigma0(w5)));
# 199 : 0 : Round(d, e, f, g, h, a, b, c, 0x4a7484aaul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
# 200 : 0 : Round(c, d, e, f, g, h, a, b, 0x5cb0a9dcul + (w6 += sigma1(w4) + w15 + sigma0(w7)));
# 201 : 0 : Round(b, c, d, e, f, g, h, a, 0x76f988daul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
# 202 : 0 : Round(a, b, c, d, e, f, g, h, 0x983e5152ul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
# 203 : 0 : Round(h, a, b, c, d, e, f, g, 0xa831c66dul + (w9 += sigma1(w7) + w2 + sigma0(w10)));
# 204 : 0 : Round(g, h, a, b, c, d, e, f, 0xb00327c8ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
# 205 : 0 : Round(f, g, h, a, b, c, d, e, 0xbf597fc7ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
# 206 : 0 : Round(e, f, g, h, a, b, c, d, 0xc6e00bf3ul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
# 207 : 0 : Round(d, e, f, g, h, a, b, c, 0xd5a79147ul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
# 208 : 0 : Round(c, d, e, f, g, h, a, b, 0x06ca6351ul + (w14 += sigma1(w12) + w7 + sigma0(w15)));
# 209 : 0 : Round(b, c, d, e, f, g, h, a, 0x14292967ul + (w15 += sigma1(w13) + w8 + sigma0(w0)));
# 210 : 0 : Round(a, b, c, d, e, f, g, h, 0x27b70a85ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
# 211 : 0 : Round(h, a, b, c, d, e, f, g, 0x2e1b2138ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
# 212 : 0 : Round(g, h, a, b, c, d, e, f, 0x4d2c6dfcul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
# 213 : 0 : Round(f, g, h, a, b, c, d, e, 0x53380d13ul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
# 214 : 0 : Round(e, f, g, h, a, b, c, d, 0x650a7354ul + (w4 += sigma1(w2) + w13 + sigma0(w5)));
# 215 : 0 : Round(d, e, f, g, h, a, b, c, 0x766a0abbul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
# 216 : 0 : Round(c, d, e, f, g, h, a, b, 0x81c2c92eul + (w6 += sigma1(w4) + w15 + sigma0(w7)));
# 217 : 0 : Round(b, c, d, e, f, g, h, a, 0x92722c85ul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
# 218 : 0 : Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1ul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
# 219 : 0 : Round(h, a, b, c, d, e, f, g, 0xa81a664bul + (w9 += sigma1(w7) + w2 + sigma0(w10)));
# 220 : 0 : Round(g, h, a, b, c, d, e, f, 0xc24b8b70ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
# 221 : 0 : Round(f, g, h, a, b, c, d, e, 0xc76c51a3ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
# 222 : 0 : Round(e, f, g, h, a, b, c, d, 0xd192e819ul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
# 223 : 0 : Round(d, e, f, g, h, a, b, c, 0xd6990624ul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
# 224 : 0 : Round(c, d, e, f, g, h, a, b, 0xf40e3585ul + (w14 += sigma1(w12) + w7 + sigma0(w15)));
# 225 : 0 : Round(b, c, d, e, f, g, h, a, 0x106aa070ul + (w15 += sigma1(w13) + w8 + sigma0(w0)));
# 226 : 0 : Round(a, b, c, d, e, f, g, h, 0x19a4c116ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
# 227 : 0 : Round(h, a, b, c, d, e, f, g, 0x1e376c08ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
# 228 : 0 : Round(g, h, a, b, c, d, e, f, 0x2748774cul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
# 229 : 0 : Round(f, g, h, a, b, c, d, e, 0x34b0bcb5ul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
# 230 : 0 : Round(e, f, g, h, a, b, c, d, 0x391c0cb3ul + (w4 += sigma1(w2) + w13 + sigma0(w5)));
# 231 : 0 : Round(d, e, f, g, h, a, b, c, 0x4ed8aa4aul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
# 232 : 0 : Round(c, d, e, f, g, h, a, b, 0x5b9cca4ful + (w6 += sigma1(w4) + w15 + sigma0(w7)));
# 233 : 0 : Round(b, c, d, e, f, g, h, a, 0x682e6ff3ul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
# 234 : 0 : Round(a, b, c, d, e, f, g, h, 0x748f82eeul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
# 235 : 0 : Round(h, a, b, c, d, e, f, g, 0x78a5636ful + (w9 += sigma1(w7) + w2 + sigma0(w10)));
# 236 : 0 : Round(g, h, a, b, c, d, e, f, 0x84c87814ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
# 237 : 0 : Round(f, g, h, a, b, c, d, e, 0x8cc70208ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
# 238 : 0 : Round(e, f, g, h, a, b, c, d, 0x90befffaul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
# 239 : 0 : Round(d, e, f, g, h, a, b, c, 0xa4506cebul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
# 240 : 0 : Round(c, d, e, f, g, h, a, b, 0xbef9a3f7ul + (w14 + sigma1(w12) + w7 + sigma0(w15)));
# 241 : 0 : Round(b, c, d, e, f, g, h, a, 0xc67178f2ul + (w15 + sigma1(w13) + w8 + sigma0(w0)));
# 242 : :
# 243 : 0 : a += 0x6a09e667ul;
# 244 : 0 : b += 0xbb67ae85ul;
# 245 : 0 : c += 0x3c6ef372ul;
# 246 : 0 : d += 0xa54ff53aul;
# 247 : 0 : e += 0x510e527ful;
# 248 : 0 : f += 0x9b05688cul;
# 249 : 0 : g += 0x1f83d9abul;
# 250 : 0 : h += 0x5be0cd19ul;
# 251 : :
# 252 : 0 : uint32_t t0 = a, t1 = b, t2 = c, t3 = d, t4 = e, t5 = f, t6 = g, t7 = h;
# 253 : :
# 254 : : // Transform 2
# 255 : 0 : Round(a, b, c, d, e, f, g, h, 0xc28a2f98ul);
# 256 : 0 : Round(h, a, b, c, d, e, f, g, 0x71374491ul);
# 257 : 0 : Round(g, h, a, b, c, d, e, f, 0xb5c0fbcful);
# 258 : 0 : Round(f, g, h, a, b, c, d, e, 0xe9b5dba5ul);
# 259 : 0 : Round(e, f, g, h, a, b, c, d, 0x3956c25bul);
# 260 : 0 : Round(d, e, f, g, h, a, b, c, 0x59f111f1ul);
# 261 : 0 : Round(c, d, e, f, g, h, a, b, 0x923f82a4ul);
# 262 : 0 : Round(b, c, d, e, f, g, h, a, 0xab1c5ed5ul);
# 263 : 0 : Round(a, b, c, d, e, f, g, h, 0xd807aa98ul);
# 264 : 0 : Round(h, a, b, c, d, e, f, g, 0x12835b01ul);
# 265 : 0 : Round(g, h, a, b, c, d, e, f, 0x243185beul);
# 266 : 0 : Round(f, g, h, a, b, c, d, e, 0x550c7dc3ul);
# 267 : 0 : Round(e, f, g, h, a, b, c, d, 0x72be5d74ul);
# 268 : 0 : Round(d, e, f, g, h, a, b, c, 0x80deb1feul);
# 269 : 0 : Round(c, d, e, f, g, h, a, b, 0x9bdc06a7ul);
# 270 : 0 : Round(b, c, d, e, f, g, h, a, 0xc19bf374ul);
# 271 : 0 : Round(a, b, c, d, e, f, g, h, 0x649b69c1ul);
# 272 : 0 : Round(h, a, b, c, d, e, f, g, 0xf0fe4786ul);
# 273 : 0 : Round(g, h, a, b, c, d, e, f, 0x0fe1edc6ul);
# 274 : 0 : Round(f, g, h, a, b, c, d, e, 0x240cf254ul);
# 275 : 0 : Round(e, f, g, h, a, b, c, d, 0x4fe9346ful);
# 276 : 0 : Round(d, e, f, g, h, a, b, c, 0x6cc984beul);
# 277 : 0 : Round(c, d, e, f, g, h, a, b, 0x61b9411eul);
# 278 : 0 : Round(b, c, d, e, f, g, h, a, 0x16f988faul);
# 279 : 0 : Round(a, b, c, d, e, f, g, h, 0xf2c65152ul);
# 280 : 0 : Round(h, a, b, c, d, e, f, g, 0xa88e5a6dul);
# 281 : 0 : Round(g, h, a, b, c, d, e, f, 0xb019fc65ul);
# 282 : 0 : Round(f, g, h, a, b, c, d, e, 0xb9d99ec7ul);
# 283 : 0 : Round(e, f, g, h, a, b, c, d, 0x9a1231c3ul);
# 284 : 0 : Round(d, e, f, g, h, a, b, c, 0xe70eeaa0ul);
# 285 : 0 : Round(c, d, e, f, g, h, a, b, 0xfdb1232bul);
# 286 : 0 : Round(b, c, d, e, f, g, h, a, 0xc7353eb0ul);
# 287 : 0 : Round(a, b, c, d, e, f, g, h, 0x3069bad5ul);
# 288 : 0 : Round(h, a, b, c, d, e, f, g, 0xcb976d5ful);
# 289 : 0 : Round(g, h, a, b, c, d, e, f, 0x5a0f118ful);
# 290 : 0 : Round(f, g, h, a, b, c, d, e, 0xdc1eeefdul);
# 291 : 0 : Round(e, f, g, h, a, b, c, d, 0x0a35b689ul);
# 292 : 0 : Round(d, e, f, g, h, a, b, c, 0xde0b7a04ul);
# 293 : 0 : Round(c, d, e, f, g, h, a, b, 0x58f4ca9dul);
# 294 : 0 : Round(b, c, d, e, f, g, h, a, 0xe15d5b16ul);
# 295 : 0 : Round(a, b, c, d, e, f, g, h, 0x007f3e86ul);
# 296 : 0 : Round(h, a, b, c, d, e, f, g, 0x37088980ul);
# 297 : 0 : Round(g, h, a, b, c, d, e, f, 0xa507ea32ul);
# 298 : 0 : Round(f, g, h, a, b, c, d, e, 0x6fab9537ul);
# 299 : 0 : Round(e, f, g, h, a, b, c, d, 0x17406110ul);
# 300 : 0 : Round(d, e, f, g, h, a, b, c, 0x0d8cd6f1ul);
# 301 : 0 : Round(c, d, e, f, g, h, a, b, 0xcdaa3b6dul);
# 302 : 0 : Round(b, c, d, e, f, g, h, a, 0xc0bbbe37ul);
# 303 : 0 : Round(a, b, c, d, e, f, g, h, 0x83613bdaul);
# 304 : 0 : Round(h, a, b, c, d, e, f, g, 0xdb48a363ul);
# 305 : 0 : Round(g, h, a, b, c, d, e, f, 0x0b02e931ul);
# 306 : 0 : Round(f, g, h, a, b, c, d, e, 0x6fd15ca7ul);
# 307 : 0 : Round(e, f, g, h, a, b, c, d, 0x521afacaul);
# 308 : 0 : Round(d, e, f, g, h, a, b, c, 0x31338431ul);
# 309 : 0 : Round(c, d, e, f, g, h, a, b, 0x6ed41a95ul);
# 310 : 0 : Round(b, c, d, e, f, g, h, a, 0x6d437890ul);
# 311 : 0 : Round(a, b, c, d, e, f, g, h, 0xc39c91f2ul);
# 312 : 0 : Round(h, a, b, c, d, e, f, g, 0x9eccabbdul);
# 313 : 0 : Round(g, h, a, b, c, d, e, f, 0xb5c9a0e6ul);
# 314 : 0 : Round(f, g, h, a, b, c, d, e, 0x532fb63cul);
# 315 : 0 : Round(e, f, g, h, a, b, c, d, 0xd2c741c6ul);
# 316 : 0 : Round(d, e, f, g, h, a, b, c, 0x07237ea3ul);
# 317 : 0 : Round(c, d, e, f, g, h, a, b, 0xa4954b68ul);
# 318 : 0 : Round(b, c, d, e, f, g, h, a, 0x4c191d76ul);
# 319 : :
# 320 : 0 : w0 = t0 + a;
# 321 : 0 : w1 = t1 + b;
# 322 : 0 : w2 = t2 + c;
# 323 : 0 : w3 = t3 + d;
# 324 : 0 : w4 = t4 + e;
# 325 : 0 : w5 = t5 + f;
# 326 : 0 : w6 = t6 + g;
# 327 : 0 : w7 = t7 + h;
# 328 : :
# 329 : : // Transform 3
# 330 : 0 : a = 0x6a09e667ul;
# 331 : 0 : b = 0xbb67ae85ul;
# 332 : 0 : c = 0x3c6ef372ul;
# 333 : 0 : d = 0xa54ff53aul;
# 334 : 0 : e = 0x510e527ful;
# 335 : 0 : f = 0x9b05688cul;
# 336 : 0 : g = 0x1f83d9abul;
# 337 : 0 : h = 0x5be0cd19ul;
# 338 : :
# 339 : 0 : Round(a, b, c, d, e, f, g, h, 0x428a2f98ul + w0);
# 340 : 0 : Round(h, a, b, c, d, e, f, g, 0x71374491ul + w1);
# 341 : 0 : Round(g, h, a, b, c, d, e, f, 0xb5c0fbcful + w2);
# 342 : 0 : Round(f, g, h, a, b, c, d, e, 0xe9b5dba5ul + w3);
# 343 : 0 : Round(e, f, g, h, a, b, c, d, 0x3956c25bul + w4);
# 344 : 0 : Round(d, e, f, g, h, a, b, c, 0x59f111f1ul + w5);
# 345 : 0 : Round(c, d, e, f, g, h, a, b, 0x923f82a4ul + w6);
# 346 : 0 : Round(b, c, d, e, f, g, h, a, 0xab1c5ed5ul + w7);
# 347 : 0 : Round(a, b, c, d, e, f, g, h, 0x5807aa98ul);
# 348 : 0 : Round(h, a, b, c, d, e, f, g, 0x12835b01ul);
# 349 : 0 : Round(g, h, a, b, c, d, e, f, 0x243185beul);
# 350 : 0 : Round(f, g, h, a, b, c, d, e, 0x550c7dc3ul);
# 351 : 0 : Round(e, f, g, h, a, b, c, d, 0x72be5d74ul);
# 352 : 0 : Round(d, e, f, g, h, a, b, c, 0x80deb1feul);
# 353 : 0 : Round(c, d, e, f, g, h, a, b, 0x9bdc06a7ul);
# 354 : 0 : Round(b, c, d, e, f, g, h, a, 0xc19bf274ul);
# 355 : 0 : Round(a, b, c, d, e, f, g, h, 0xe49b69c1ul + (w0 += sigma0(w1)));
# 356 : 0 : Round(h, a, b, c, d, e, f, g, 0xefbe4786ul + (w1 += 0xa00000ul + sigma0(w2)));
# 357 : 0 : Round(g, h, a, b, c, d, e, f, 0x0fc19dc6ul + (w2 += sigma1(w0) + sigma0(w3)));
# 358 : 0 : Round(f, g, h, a, b, c, d, e, 0x240ca1ccul + (w3 += sigma1(w1) + sigma0(w4)));
# 359 : 0 : Round(e, f, g, h, a, b, c, d, 0x2de92c6ful + (w4 += sigma1(w2) + sigma0(w5)));
# 360 : 0 : Round(d, e, f, g, h, a, b, c, 0x4a7484aaul + (w5 += sigma1(w3) + sigma0(w6)));
# 361 : 0 : Round(c, d, e, f, g, h, a, b, 0x5cb0a9dcul + (w6 += sigma1(w4) + 0x100ul + sigma0(w7)));
# 362 : 0 : Round(b, c, d, e, f, g, h, a, 0x76f988daul + (w7 += sigma1(w5) + w0 + 0x11002000ul));
# 363 : 0 : Round(a, b, c, d, e, f, g, h, 0x983e5152ul + (w8 = 0x80000000ul + sigma1(w6) + w1));
# 364 : 0 : Round(h, a, b, c, d, e, f, g, 0xa831c66dul + (w9 = sigma1(w7) + w2));
# 365 : 0 : Round(g, h, a, b, c, d, e, f, 0xb00327c8ul + (w10 = sigma1(w8) + w3));
# 366 : 0 : Round(f, g, h, a, b, c, d, e, 0xbf597fc7ul + (w11 = sigma1(w9) + w4));
# 367 : 0 : Round(e, f, g, h, a, b, c, d, 0xc6e00bf3ul + (w12 = sigma1(w10) + w5));
# 368 : 0 : Round(d, e, f, g, h, a, b, c, 0xd5a79147ul + (w13 = sigma1(w11) + w6));
# 369 : 0 : Round(c, d, e, f, g, h, a, b, 0x06ca6351ul + (w14 = sigma1(w12) + w7 + 0x400022ul));
# 370 : 0 : Round(b, c, d, e, f, g, h, a, 0x14292967ul + (w15 = 0x100ul + sigma1(w13) + w8 + sigma0(w0)));
# 371 : 0 : Round(a, b, c, d, e, f, g, h, 0x27b70a85ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
# 372 : 0 : Round(h, a, b, c, d, e, f, g, 0x2e1b2138ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
# 373 : 0 : Round(g, h, a, b, c, d, e, f, 0x4d2c6dfcul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
# 374 : 0 : Round(f, g, h, a, b, c, d, e, 0x53380d13ul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
# 375 : 0 : Round(e, f, g, h, a, b, c, d, 0x650a7354ul + (w4 += sigma1(w2) + w13 + sigma0(w5)));
# 376 : 0 : Round(d, e, f, g, h, a, b, c, 0x766a0abbul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
# 377 : 0 : Round(c, d, e, f, g, h, a, b, 0x81c2c92eul + (w6 += sigma1(w4) + w15 + sigma0(w7)));
# 378 : 0 : Round(b, c, d, e, f, g, h, a, 0x92722c85ul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
# 379 : 0 : Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1ul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
# 380 : 0 : Round(h, a, b, c, d, e, f, g, 0xa81a664bul + (w9 += sigma1(w7) + w2 + sigma0(w10)));
# 381 : 0 : Round(g, h, a, b, c, d, e, f, 0xc24b8b70ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
# 382 : 0 : Round(f, g, h, a, b, c, d, e, 0xc76c51a3ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
# 383 : 0 : Round(e, f, g, h, a, b, c, d, 0xd192e819ul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
# 384 : 0 : Round(d, e, f, g, h, a, b, c, 0xd6990624ul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
# 385 : 0 : Round(c, d, e, f, g, h, a, b, 0xf40e3585ul + (w14 += sigma1(w12) + w7 + sigma0(w15)));
# 386 : 0 : Round(b, c, d, e, f, g, h, a, 0x106aa070ul + (w15 += sigma1(w13) + w8 + sigma0(w0)));
# 387 : 0 : Round(a, b, c, d, e, f, g, h, 0x19a4c116ul + (w0 += sigma1(w14) + w9 + sigma0(w1)));
# 388 : 0 : Round(h, a, b, c, d, e, f, g, 0x1e376c08ul + (w1 += sigma1(w15) + w10 + sigma0(w2)));
# 389 : 0 : Round(g, h, a, b, c, d, e, f, 0x2748774cul + (w2 += sigma1(w0) + w11 + sigma0(w3)));
# 390 : 0 : Round(f, g, h, a, b, c, d, e, 0x34b0bcb5ul + (w3 += sigma1(w1) + w12 + sigma0(w4)));
# 391 : 0 : Round(e, f, g, h, a, b, c, d, 0x391c0cb3ul + (w4 += sigma1(w2) + w13 + sigma0(w5)));
# 392 : 0 : Round(d, e, f, g, h, a, b, c, 0x4ed8aa4aul + (w5 += sigma1(w3) + w14 + sigma0(w6)));
# 393 : 0 : Round(c, d, e, f, g, h, a, b, 0x5b9cca4ful + (w6 += sigma1(w4) + w15 + sigma0(w7)));
# 394 : 0 : Round(b, c, d, e, f, g, h, a, 0x682e6ff3ul + (w7 += sigma1(w5) + w0 + sigma0(w8)));
# 395 : 0 : Round(a, b, c, d, e, f, g, h, 0x748f82eeul + (w8 += sigma1(w6) + w1 + sigma0(w9)));
# 396 : 0 : Round(h, a, b, c, d, e, f, g, 0x78a5636ful + (w9 += sigma1(w7) + w2 + sigma0(w10)));
# 397 : 0 : Round(g, h, a, b, c, d, e, f, 0x84c87814ul + (w10 += sigma1(w8) + w3 + sigma0(w11)));
# 398 : 0 : Round(f, g, h, a, b, c, d, e, 0x8cc70208ul + (w11 += sigma1(w9) + w4 + sigma0(w12)));
# 399 : 0 : Round(e, f, g, h, a, b, c, d, 0x90befffaul + (w12 += sigma1(w10) + w5 + sigma0(w13)));
# 400 : 0 : Round(d, e, f, g, h, a, b, c, 0xa4506cebul + (w13 += sigma1(w11) + w6 + sigma0(w14)));
# 401 : 0 : Round(c, d, e, f, g, h, a, b, 0xbef9a3f7ul + (w14 + sigma1(w12) + w7 + sigma0(w15)));
# 402 : 0 : Round(b, c, d, e, f, g, h, a, 0xc67178f2ul + (w15 + sigma1(w13) + w8 + sigma0(w0)));
# 403 : :
# 404 : : // Output
# 405 : 0 : WriteBE32(out + 0, a + 0x6a09e667ul);
# 406 : 0 : WriteBE32(out + 4, b + 0xbb67ae85ul);
# 407 : 0 : WriteBE32(out + 8, c + 0x3c6ef372ul);
# 408 : 0 : WriteBE32(out + 12, d + 0xa54ff53aul);
# 409 : 0 : WriteBE32(out + 16, e + 0x510e527ful);
# 410 : 0 : WriteBE32(out + 20, f + 0x9b05688cul);
# 411 : 0 : WriteBE32(out + 24, g + 0x1f83d9abul);
# 412 : 0 : WriteBE32(out + 28, h + 0x5be0cd19ul);
# 413 : 0 : }
# 414 : :
# 415 : : } // namespace sha256
# 416 : :
# 417 : : typedef void (*TransformType)(uint32_t*, const unsigned char*, size_t);
# 418 : : typedef void (*TransformD64Type)(unsigned char*, const unsigned char*);
# 419 : :
# 420 : : template<TransformType tr>
# 421 : : void TransformD64Wrapper(unsigned char* out, const unsigned char* in)
# 422 : 49769 : {
# 423 : 49769 : uint32_t s[8];
# 424 : 49769 : static const unsigned char padding1[64] = {
# 425 : 49769 : 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
# 426 : 49769 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
# 427 : 49769 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
# 428 : 49769 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0
# 429 : 49769 : };
# 430 : 49769 : unsigned char buffer2[64] = {
# 431 : 49769 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
# 432 : 49769 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
# 433 : 49769 : 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
# 434 : 49769 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0
# 435 : 49769 : };
# 436 : 49769 : sha256::Initialize(s);
# 437 : 49769 : tr(s, in, 1);
# 438 : 49769 : tr(s, padding1, 1);
# 439 : 49769 : WriteBE32(buffer2 + 0, s[0]);
# 440 : 49769 : WriteBE32(buffer2 + 4, s[1]);
# 441 : 49769 : WriteBE32(buffer2 + 8, s[2]);
# 442 : 49769 : WriteBE32(buffer2 + 12, s[3]);
# 443 : 49769 : WriteBE32(buffer2 + 16, s[4]);
# 444 : 49769 : WriteBE32(buffer2 + 20, s[5]);
# 445 : 49769 : WriteBE32(buffer2 + 24, s[6]);
# 446 : 49769 : WriteBE32(buffer2 + 28, s[7]);
# 447 : 49769 : sha256::Initialize(s);
# 448 : 49769 : tr(s, buffer2, 1);
# 449 : 49769 : WriteBE32(out + 0, s[0]);
# 450 : 49769 : WriteBE32(out + 4, s[1]);
# 451 : 49769 : WriteBE32(out + 8, s[2]);
# 452 : 49769 : WriteBE32(out + 12, s[3]);
# 453 : 49769 : WriteBE32(out + 16, s[4]);
# 454 : 49769 : WriteBE32(out + 20, s[5]);
# 455 : 49769 : WriteBE32(out + 24, s[6]);
# 456 : 49769 : WriteBE32(out + 28, s[7]);
# 457 : 49769 : }
# 458 : :
# 459 : : TransformType Transform = sha256::Transform;
# 460 : : TransformD64Type TransformD64 = sha256::TransformD64;
# 461 : : TransformD64Type TransformD64_2way = nullptr;
# 462 : : TransformD64Type TransformD64_4way = nullptr;
# 463 : : TransformD64Type TransformD64_8way = nullptr;
# 464 : :
# 465 : 1512 : bool SelfTest() {
# 466 : : // Input state (equal to the initial SHA256 state)
# 467 : 1512 : static const uint32_t init[8] = {
# 468 : 1512 : 0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul, 0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul
# 469 : 1512 : };
# 470 : : // Some random input data to test with
# 471 : 1512 : static const unsigned char data[641] = "-" // Intentionally not aligned
# 472 : 1512 : "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do "
# 473 : 1512 : "eiusmod tempor incididunt ut labore et dolore magna aliqua. Et m"
# 474 : 1512 : "olestie ac feugiat sed lectus vestibulum mattis ullamcorper. Mor"
# 475 : 1512 : "bi blandit cursus risus at ultrices mi tempus imperdiet nulla. N"
# 476 : 1512 : "unc congue nisi vita suscipit tellus mauris. Imperdiet proin fer"
# 477 : 1512 : "mentum leo vel orci. Massa tempor nec feugiat nisl pretium fusce"
# 478 : 1512 : " id velit. Telus in metus vulputate eu scelerisque felis. Mi tem"
# 479 : 1512 : "pus imperdiet nulla malesuada pellentesque. Tristique magna sit.";
# 480 : : // Expected output state for hashing the i*64 first input bytes above (excluding SHA256 padding).
# 481 : 1512 : static const uint32_t result[9][8] = {
# 482 : 1512 : {0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul, 0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul},
# 483 : 1512 : {0x91f8ec6bul, 0x4da10fe3ul, 0x1c9c292cul, 0x45e18185ul, 0x435cc111ul, 0x3ca26f09ul, 0xeb954caeul, 0x402a7069ul},
# 484 : 1512 : {0xcabea5acul, 0x374fb97cul, 0x182ad996ul, 0x7bd69cbful, 0x450ff900ul, 0xc1d2be8aul, 0x6a41d505ul, 0xe6212dc3ul},
# 485 : 1512 : {0xbcff09d6ul, 0x3e76f36eul, 0x3ecb2501ul, 0x78866e97ul, 0xe1c1e2fdul, 0x32f4eafful, 0x8aa6c4e5ul, 0xdfc024bcul},
# 486 : 1512 : {0xa08c5d94ul, 0x0a862f93ul, 0x6b7f2f40ul, 0x8f9fae76ul, 0x6d40439ful, 0x79dcee0cul, 0x3e39ff3aul, 0xdc3bdbb1ul},
# 487 : 1512 : {0x216a0895ul, 0x9f1a3662ul, 0xe99946f9ul, 0x87ba4364ul, 0x0fb5db2cul, 0x12bed3d3ul, 0x6689c0c7ul, 0x292f1b04ul},
# 488 : 1512 : {0xca3067f8ul, 0xbc8c2656ul, 0x37cb7e0dul, 0x9b6b8b0ful, 0x46dc380bul, 0xf1287f57ul, 0xc42e4b23ul, 0x3fefe94dul},
# 489 : 1512 : {0x3e4c4039ul, 0xbb6fca8cul, 0x6f27d2f7ul, 0x301e44a4ul, 0x8352ba14ul, 0x5769ce37ul, 0x48a1155ful, 0xc0e1c4c6ul},
# 490 : 1512 : {0xfe2fa9ddul, 0x69d0862bul, 0x1ae0db23ul, 0x471f9244ul, 0xf55c0145ul, 0xc30f9c3bul, 0x40a84ea0ul, 0x5b8a266cul},
# 491 : 1512 : };
# 492 : : // Expected output for each of the individual 8 64-byte messages under full double SHA256 (including padding).
# 493 : 1512 : static const unsigned char result_d64[256] = {
# 494 : 1512 : 0x09, 0x3a, 0xc4, 0xd0, 0x0f, 0xf7, 0x57, 0xe1, 0x72, 0x85, 0x79, 0x42, 0xfe, 0xe7, 0xe0, 0xa0,
# 495 : 1512 : 0xfc, 0x52, 0xd7, 0xdb, 0x07, 0x63, 0x45, 0xfb, 0x53, 0x14, 0x7d, 0x17, 0x22, 0x86, 0xf0, 0x52,
# 496 : 1512 : 0x48, 0xb6, 0x11, 0x9e, 0x6e, 0x48, 0x81, 0x6d, 0xcc, 0x57, 0x1f, 0xb2, 0x97, 0xa8, 0xd5, 0x25,
# 497 : 1512 : 0x9b, 0x82, 0xaa, 0x89, 0xe2, 0xfd, 0x2d, 0x56, 0xe8, 0x28, 0x83, 0x0b, 0xe2, 0xfa, 0x53, 0xb7,
# 498 : 1512 : 0xd6, 0x6b, 0x07, 0x85, 0x83, 0xb0, 0x10, 0xa2, 0xf5, 0x51, 0x3c, 0xf9, 0x60, 0x03, 0xab, 0x45,
# 499 : 1512 : 0x6c, 0x15, 0x6e, 0xef, 0xb5, 0xac, 0x3e, 0x6c, 0xdf, 0xb4, 0x92, 0x22, 0x2d, 0xce, 0xbf, 0x3e,
# 500 : 1512 : 0xe9, 0xe5, 0xf6, 0x29, 0x0e, 0x01, 0x4f, 0xd2, 0xd4, 0x45, 0x65, 0xb3, 0xbb, 0xf2, 0x4c, 0x16,
# 501 : 1512 : 0x37, 0x50, 0x3c, 0x6e, 0x49, 0x8c, 0x5a, 0x89, 0x2b, 0x1b, 0xab, 0xc4, 0x37, 0xd1, 0x46, 0xe9,
# 502 : 1512 : 0x3d, 0x0e, 0x85, 0xa2, 0x50, 0x73, 0xa1, 0x5e, 0x54, 0x37, 0xd7, 0x94, 0x17, 0x56, 0xc2, 0xd8,
# 503 : 1512 : 0xe5, 0x9f, 0xed, 0x4e, 0xae, 0x15, 0x42, 0x06, 0x0d, 0x74, 0x74, 0x5e, 0x24, 0x30, 0xce, 0xd1,
# 504 : 1512 : 0x9e, 0x50, 0xa3, 0x9a, 0xb8, 0xf0, 0x4a, 0x57, 0x69, 0x78, 0x67, 0x12, 0x84, 0x58, 0xbe, 0xc7,
# 505 : 1512 : 0x36, 0xaa, 0xee, 0x7c, 0x64, 0xa3, 0x76, 0xec, 0xff, 0x55, 0x41, 0x00, 0x2a, 0x44, 0x68, 0x4d,
# 506 : 1512 : 0xb6, 0x53, 0x9e, 0x1c, 0x95, 0xb7, 0xca, 0xdc, 0x7f, 0x7d, 0x74, 0x27, 0x5c, 0x8e, 0xa6, 0x84,
# 507 : 1512 : 0xb5, 0xac, 0x87, 0xa9, 0xf3, 0xff, 0x75, 0xf2, 0x34, 0xcd, 0x1a, 0x3b, 0x82, 0x2c, 0x2b, 0x4e,
# 508 : 1512 : 0x6a, 0x46, 0x30, 0xa6, 0x89, 0x86, 0x23, 0xac, 0xf8, 0xa5, 0x15, 0xe9, 0x0a, 0xaa, 0x1e, 0x9a,
# 509 : 1512 : 0xd7, 0x93, 0x6b, 0x28, 0xe4, 0x3b, 0xfd, 0x59, 0xc6, 0xed, 0x7c, 0x5f, 0xa5, 0x41, 0xcb, 0x51
# 510 : 1512 : };
# 511 : :
# 512 : :
# 513 : : // Test Transform() for 0 through 8 transformations.
# 514 [ + + ]: 15120 : for (size_t i = 0; i <= 8; ++i) {
# 515 : 13608 : uint32_t state[8];
# 516 : 13608 : std::copy(init, init + 8, state);
# 517 : 13608 : Transform(state, data + 1, i);
# 518 [ - + ]: 13608 : if (!std::equal(state, state + 8, result[i])) return false;
# 519 : 13608 : }
# 520 : :
# 521 : : // Test TransformD64
# 522 : 1512 : unsigned char out[32];
# 523 : 1512 : TransformD64(out, data + 1);
# 524 [ - + ]: 1512 : if (!std::equal(out, out + 32, result_d64)) return false;
# 525 : :
# 526 : : // Test TransformD64_2way, if available.
# 527 [ - + ]: 1512 : if (TransformD64_2way) {
# 528 : 0 : unsigned char out[64];
# 529 : 0 : TransformD64_2way(out, data + 1);
# 530 [ # # ]: 0 : if (!std::equal(out, out + 64, result_d64)) return false;
# 531 : 1512 : }
# 532 : :
# 533 : : // Test TransformD64_4way, if available.
# 534 [ + - ]: 1512 : if (TransformD64_4way) {
# 535 : 1512 : unsigned char out[128];
# 536 : 1512 : TransformD64_4way(out, data + 1);
# 537 [ - + ]: 1512 : if (!std::equal(out, out + 128, result_d64)) return false;
# 538 : 1512 : }
# 539 : :
# 540 : : // Test TransformD64_8way, if available.
# 541 [ + - ]: 1512 : if (TransformD64_8way) {
# 542 : 1512 : unsigned char out[256];
# 543 : 1512 : TransformD64_8way(out, data + 1);
# 544 [ - + ]: 1512 : if (!std::equal(out, out + 256, result_d64)) return false;
# 545 : 1512 : }
# 546 : :
# 547 : 1512 : return true;
# 548 : 1512 : }
# 549 : :
# 550 : : #if defined(USE_ASM) && (defined(__x86_64__) || defined(__amd64__) || defined(__i386__))
# 551 : : /** Check whether the OS has enabled AVX registers. */
# 552 : : bool AVXEnabled()
# 553 : 1512 : {
# 554 : 1512 : uint32_t a, d;
# 555 : 1512 : __asm__("xgetbv" : "=a"(a), "=d"(d) : "c"(0));
# 556 : 1512 : return (a & 6) == 6;
# 557 : 1512 : }
# 558 : : #endif
# 559 : : } // namespace
# 560 : :
# 561 : :
# 562 : : std::string SHA256AutoDetect()
# 563 : 1512 : {
# 564 : 1512 : std::string ret = "standard";
# 565 : 1512 : #if defined(USE_ASM) && defined(HAVE_GETCPUID)
# 566 : 1512 : bool have_sse4 = false;
# 567 : 1512 : bool have_xsave = false;
# 568 : 1512 : bool have_avx = false;
# 569 : 1512 : bool have_avx2 = false;
# 570 : 1512 : bool have_shani = false;
# 571 : 1512 : bool enabled_avx = false;
# 572 : :
# 573 : 1512 : (void)AVXEnabled;
# 574 : 1512 : (void)have_sse4;
# 575 : 1512 : (void)have_avx;
# 576 : 1512 : (void)have_xsave;
# 577 : 1512 : (void)have_avx2;
# 578 : 1512 : (void)have_shani;
# 579 : 1512 : (void)enabled_avx;
# 580 : :
# 581 : 1512 : uint32_t eax, ebx, ecx, edx;
# 582 : 1512 : GetCPUID(1, 0, eax, ebx, ecx, edx);
# 583 : 1512 : have_sse4 = (ecx >> 19) & 1;
# 584 : 1512 : have_xsave = (ecx >> 27) & 1;
# 585 : 1512 : have_avx = (ecx >> 28) & 1;
# 586 [ + - ][ + - ]: 1512 : if (have_xsave && have_avx) {
# 587 : 1512 : enabled_avx = AVXEnabled();
# 588 : 1512 : }
# 589 [ + - ]: 1512 : if (have_sse4) {
# 590 : 1512 : GetCPUID(7, 0, eax, ebx, ecx, edx);
# 591 : 1512 : have_avx2 = (ebx >> 5) & 1;
# 592 : 1512 : have_shani = (ebx >> 29) & 1;
# 593 : 1512 : }
# 594 : :
# 595 : 1512 : #if defined(ENABLE_SHANI) && !defined(BUILD_BITCOIN_INTERNAL)
# 596 [ - + ]: 1512 : if (have_shani) {
# 597 : 0 : Transform = sha256_shani::Transform;
# 598 : 0 : TransformD64 = TransformD64Wrapper<sha256_shani::Transform>;
# 599 : 0 : TransformD64_2way = sha256d64_shani::Transform_2way;
# 600 : 0 : ret = "shani(1way,2way)";
# 601 : 0 : have_sse4 = false; // Disable SSE4/AVX2;
# 602 : 0 : have_avx2 = false;
# 603 : 0 : }
# 604 : 1512 : #endif
# 605 : :
# 606 [ + - ]: 1512 : if (have_sse4) {
# 607 : 1512 : #if defined(__x86_64__) || defined(__amd64__)
# 608 : 1512 : Transform = sha256_sse4::Transform;
# 609 : 1512 : TransformD64 = TransformD64Wrapper<sha256_sse4::Transform>;
# 610 : 1512 : ret = "sse4(1way)";
# 611 : 1512 : #endif
# 612 : 1512 : #if defined(ENABLE_SSE41) && !defined(BUILD_BITCOIN_INTERNAL)
# 613 : 1512 : TransformD64_4way = sha256d64_sse41::Transform_4way;
# 614 : 1512 : ret += ",sse41(4way)";
# 615 : 1512 : #endif
# 616 : 1512 : }
# 617 : :
# 618 : 1512 : #if defined(ENABLE_AVX2) && !defined(BUILD_BITCOIN_INTERNAL)
# 619 [ + - ][ + - ]: 1512 : if (have_avx2 && have_avx && enabled_avx) {
# [ + - ]
# 620 : 1512 : TransformD64_8way = sha256d64_avx2::Transform_8way;
# 621 : 1512 : ret += ",avx2(8way)";
# 622 : 1512 : }
# 623 : 1512 : #endif
# 624 : 1512 : #endif
# 625 : :
# 626 : 1512 : assert(SelfTest());
# 627 : 1512 : return ret;
# 628 : 1512 : }
# 629 : :
# 630 : : ////// SHA-256
# 631 : :
# 632 : : CSHA256::CSHA256() : bytes(0)
# 633 : 303020538 : {
# 634 : 303020538 : sha256::Initialize(s);
# 635 : 303020538 : }
# 636 : :
# 637 : : CSHA256& CSHA256::Write(const unsigned char* data, size_t len)
# 638 : 3228631449 : {
# 639 : 3228631449 : const unsigned char* end = data + len;
# 640 : 3228631449 : size_t bufsize = bytes % 64;
# 641 [ + + ][ + + ]: 3228631449 : if (bufsize && bufsize + len >= 64) {
# 642 : : // Fill the buffer, and process it.
# 643 : 931964203 : memcpy(buf + bufsize, data, 64 - bufsize);
# 644 : 931964203 : bytes += 64 - bufsize;
# 645 : 931964203 : data += 64 - bufsize;
# 646 : 931964203 : Transform(s, buf, 1);
# 647 : 931964203 : bufsize = 0;
# 648 : 931964203 : }
# 649 [ + + ]: 3228631449 : if (end - data >= 64) {
# 650 : 1772108 : size_t blocks = (end - data) / 64;
# 651 : 1772108 : Transform(s, data, blocks);
# 652 : 1772108 : data += 64 * blocks;
# 653 : 1772108 : bytes += 64 * blocks;
# 654 : 1772108 : }
# 655 [ + + ]: 3228631449 : if (end > data) {
# 656 : : // Fill the buffer with what remains.
# 657 : 2615599452 : memcpy(buf + bufsize, data, end - data);
# 658 : 2615599452 : bytes += end - data;
# 659 : 2615599452 : }
# 660 : 3228631449 : return *this;
# 661 : 3228631449 : }
# 662 : :
# 663 : : void CSHA256::Finalize(unsigned char hash[OUTPUT_SIZE])
# 664 : 600481444 : {
# 665 : 600481444 : static const unsigned char pad[64] = {0x80};
# 666 : 600481444 : unsigned char sizedesc[8];
# 667 : 600481444 : WriteBE64(sizedesc, bytes << 3);
# 668 : 600481444 : Write(pad, 1 + ((119 - (bytes % 64)) % 64));
# 669 : 600481444 : Write(sizedesc, 8);
# 670 : 600481444 : WriteBE32(hash, s[0]);
# 671 : 600481444 : WriteBE32(hash + 4, s[1]);
# 672 : 600481444 : WriteBE32(hash + 8, s[2]);
# 673 : 600481444 : WriteBE32(hash + 12, s[3]);
# 674 : 600481444 : WriteBE32(hash + 16, s[4]);
# 675 : 600481444 : WriteBE32(hash + 20, s[5]);
# 676 : 600481444 : WriteBE32(hash + 24, s[6]);
# 677 : 600481444 : WriteBE32(hash + 28, s[7]);
# 678 : 600481444 : }
# 679 : :
# 680 : : CSHA256& CSHA256::Reset()
# 681 : 296433051 : {
# 682 : 296433051 : bytes = 0;
# 683 : 296433051 : sha256::Initialize(s);
# 684 : 296433051 : return *this;
# 685 : 296433051 : }
# 686 : :
# 687 : : void SHA256D64(unsigned char* out, const unsigned char* in, size_t blocks)
# 688 : 40836 : {
# 689 [ + - ]: 40836 : if (TransformD64_8way) {
# 690 [ + + ]: 121810 : while (blocks >= 8) {
# 691 : 80974 : TransformD64_8way(out, in);
# 692 : 80974 : out += 256;
# 693 : 80974 : in += 512;
# 694 : 80974 : blocks -= 8;
# 695 : 80974 : }
# 696 : 40836 : }
# 697 [ + - ]: 40836 : if (TransformD64_4way) {
# 698 [ + + ]: 44385 : while (blocks >= 4) {
# 699 : 3549 : TransformD64_4way(out, in);
# 700 : 3549 : out += 128;
# 701 : 3549 : in += 256;
# 702 : 3549 : blocks -= 4;
# 703 : 3549 : }
# 704 : 40836 : }
# 705 [ - + ]: 40836 : if (TransformD64_2way) {
# 706 [ # # ]: 0 : while (blocks >= 2) {
# 707 : 0 : TransformD64_2way(out, in);
# 708 : 0 : out += 64;
# 709 : 0 : in += 128;
# 710 : 0 : blocks -= 2;
# 711 : 0 : }
# 712 : 0 : }
# 713 [ + + ]: 89093 : while (blocks) {
# 714 : 48257 : TransformD64(out, in);
# 715 : 48257 : out += 32;
# 716 : 48257 : in += 64;
# 717 : 48257 : --blocks;
# 718 : 48257 : }
# 719 : 40836 : }
|