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 3951808 : uint32_t inline Ch(uint32_t x, uint32_t y, uint32_t z) { return z ^ (x & (y ^ z)); }
49 3951808 : uint32_t inline Maj(uint32_t x, uint32_t y, uint32_t z) { return (x & y) | (z & (x | y)); }
50 3951808 : uint32_t inline Sigma0(uint32_t x) { return (x >> 2 | x << 30) ^ (x >> 13 | x << 19) ^ (x >> 22 | x << 10); }
51 3951808 : uint32_t inline Sigma1(uint32_t x) { return (x >> 6 | x << 26) ^ (x >> 11 | x << 21) ^ (x >> 25 | x << 7); }
52 2963856 : uint32_t inline sigma0(uint32_t x) { return (x >> 7 | x << 25) ^ (x >> 18 | x << 14) ^ (x >> 3); }
53 2963856 : 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 3951808 : 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 : {
58 3951808 : uint32_t t1 = h + Sigma1(e) + Ch(e, f, g) + k;
59 3951808 : uint32_t t2 = Sigma0(a) + Maj(a, b, c);
60 3951808 : d += t1;
61 3951808 : h = t1 + t2;
62 3951808 : }
63 :
64 : /** Initialize SHA-256 state. */
65 22178068 : void inline Initialize(uint32_t* s)
66 : {
67 22178068 : s[0] = 0x6a09e667ul;
68 22178068 : s[1] = 0xbb67ae85ul;
69 22178068 : s[2] = 0x3c6ef372ul;
70 22178068 : s[3] = 0xa54ff53aul;
71 22178068 : s[4] = 0x510e527ful;
72 22178068 : s[5] = 0x9b05688cul;
73 22178068 : s[6] = 0x1f83d9abul;
74 22178068 : s[7] = 0x5be0cd19ul;
75 22178068 : }
76 :
77 : /** Perform a number of SHA-256 transformations, processing 64-byte chunks. */
78 57722 : void Transform(uint32_t* s, const unsigned char* chunk, size_t blocks)
79 : {
80 119469 : while (blocks--) {
81 61747 : 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 : uint32_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
83 :
84 61747 : Round(a, b, c, d, e, f, g, h, 0x428a2f98 + (w0 = ReadBE32(chunk + 0)));
85 61747 : Round(h, a, b, c, d, e, f, g, 0x71374491 + (w1 = ReadBE32(chunk + 4)));
86 61747 : Round(g, h, a, b, c, d, e, f, 0xb5c0fbcf + (w2 = ReadBE32(chunk + 8)));
87 61747 : Round(f, g, h, a, b, c, d, e, 0xe9b5dba5 + (w3 = ReadBE32(chunk + 12)));
88 61747 : Round(e, f, g, h, a, b, c, d, 0x3956c25b + (w4 = ReadBE32(chunk + 16)));
89 61747 : Round(d, e, f, g, h, a, b, c, 0x59f111f1 + (w5 = ReadBE32(chunk + 20)));
90 61747 : Round(c, d, e, f, g, h, a, b, 0x923f82a4 + (w6 = ReadBE32(chunk + 24)));
91 61747 : Round(b, c, d, e, f, g, h, a, 0xab1c5ed5 + (w7 = ReadBE32(chunk + 28)));
92 61747 : Round(a, b, c, d, e, f, g, h, 0xd807aa98 + (w8 = ReadBE32(chunk + 32)));
93 61747 : Round(h, a, b, c, d, e, f, g, 0x12835b01 + (w9 = ReadBE32(chunk + 36)));
94 61747 : Round(g, h, a, b, c, d, e, f, 0x243185be + (w10 = ReadBE32(chunk + 40)));
95 61747 : Round(f, g, h, a, b, c, d, e, 0x550c7dc3 + (w11 = ReadBE32(chunk + 44)));
96 61747 : Round(e, f, g, h, a, b, c, d, 0x72be5d74 + (w12 = ReadBE32(chunk + 48)));
97 61747 : Round(d, e, f, g, h, a, b, c, 0x80deb1fe + (w13 = ReadBE32(chunk + 52)));
98 61747 : Round(c, d, e, f, g, h, a, b, 0x9bdc06a7 + (w14 = ReadBE32(chunk + 56)));
99 61747 : Round(b, c, d, e, f, g, h, a, 0xc19bf174 + (w15 = ReadBE32(chunk + 60)));
100 :
101 61747 : Round(a, b, c, d, e, f, g, h, 0xe49b69c1 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
102 61747 : Round(h, a, b, c, d, e, f, g, 0xefbe4786 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
103 61747 : Round(g, h, a, b, c, d, e, f, 0x0fc19dc6 + (w2 += sigma1(w0) + w11 + sigma0(w3)));
104 61747 : Round(f, g, h, a, b, c, d, e, 0x240ca1cc + (w3 += sigma1(w1) + w12 + sigma0(w4)));
105 61747 : Round(e, f, g, h, a, b, c, d, 0x2de92c6f + (w4 += sigma1(w2) + w13 + sigma0(w5)));
106 61747 : Round(d, e, f, g, h, a, b, c, 0x4a7484aa + (w5 += sigma1(w3) + w14 + sigma0(w6)));
107 61747 : Round(c, d, e, f, g, h, a, b, 0x5cb0a9dc + (w6 += sigma1(w4) + w15 + sigma0(w7)));
108 61747 : Round(b, c, d, e, f, g, h, a, 0x76f988da + (w7 += sigma1(w5) + w0 + sigma0(w8)));
109 61747 : Round(a, b, c, d, e, f, g, h, 0x983e5152 + (w8 += sigma1(w6) + w1 + sigma0(w9)));
110 61747 : Round(h, a, b, c, d, e, f, g, 0xa831c66d + (w9 += sigma1(w7) + w2 + sigma0(w10)));
111 61747 : Round(g, h, a, b, c, d, e, f, 0xb00327c8 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
112 61747 : Round(f, g, h, a, b, c, d, e, 0xbf597fc7 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
113 61747 : Round(e, f, g, h, a, b, c, d, 0xc6e00bf3 + (w12 += sigma1(w10) + w5 + sigma0(w13)));
114 61747 : Round(d, e, f, g, h, a, b, c, 0xd5a79147 + (w13 += sigma1(w11) + w6 + sigma0(w14)));
115 61747 : Round(c, d, e, f, g, h, a, b, 0x06ca6351 + (w14 += sigma1(w12) + w7 + sigma0(w15)));
116 61747 : Round(b, c, d, e, f, g, h, a, 0x14292967 + (w15 += sigma1(w13) + w8 + sigma0(w0)));
117 :
118 61747 : Round(a, b, c, d, e, f, g, h, 0x27b70a85 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
119 61747 : Round(h, a, b, c, d, e, f, g, 0x2e1b2138 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
120 61747 : Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc + (w2 += sigma1(w0) + w11 + sigma0(w3)));
121 61747 : Round(f, g, h, a, b, c, d, e, 0x53380d13 + (w3 += sigma1(w1) + w12 + sigma0(w4)));
122 61747 : Round(e, f, g, h, a, b, c, d, 0x650a7354 + (w4 += sigma1(w2) + w13 + sigma0(w5)));
123 61747 : Round(d, e, f, g, h, a, b, c, 0x766a0abb + (w5 += sigma1(w3) + w14 + sigma0(w6)));
124 61747 : Round(c, d, e, f, g, h, a, b, 0x81c2c92e + (w6 += sigma1(w4) + w15 + sigma0(w7)));
125 61747 : Round(b, c, d, e, f, g, h, a, 0x92722c85 + (w7 += sigma1(w5) + w0 + sigma0(w8)));
126 61747 : Round(a, b, c, d, e, f, g, h, 0xa2bfe8a1 + (w8 += sigma1(w6) + w1 + sigma0(w9)));
127 61747 : Round(h, a, b, c, d, e, f, g, 0xa81a664b + (w9 += sigma1(w7) + w2 + sigma0(w10)));
128 61747 : Round(g, h, a, b, c, d, e, f, 0xc24b8b70 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
129 61747 : Round(f, g, h, a, b, c, d, e, 0xc76c51a3 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
130 61747 : Round(e, f, g, h, a, b, c, d, 0xd192e819 + (w12 += sigma1(w10) + w5 + sigma0(w13)));
131 61747 : Round(d, e, f, g, h, a, b, c, 0xd6990624 + (w13 += sigma1(w11) + w6 + sigma0(w14)));
132 61747 : Round(c, d, e, f, g, h, a, b, 0xf40e3585 + (w14 += sigma1(w12) + w7 + sigma0(w15)));
133 61747 : Round(b, c, d, e, f, g, h, a, 0x106aa070 + (w15 += sigma1(w13) + w8 + sigma0(w0)));
134 :
135 61747 : Round(a, b, c, d, e, f, g, h, 0x19a4c116 + (w0 += sigma1(w14) + w9 + sigma0(w1)));
136 61747 : Round(h, a, b, c, d, e, f, g, 0x1e376c08 + (w1 += sigma1(w15) + w10 + sigma0(w2)));
137 61747 : Round(g, h, a, b, c, d, e, f, 0x2748774c + (w2 += sigma1(w0) + w11 + sigma0(w3)));
138 61747 : Round(f, g, h, a, b, c, d, e, 0x34b0bcb5 + (w3 += sigma1(w1) + w12 + sigma0(w4)));
139 61747 : Round(e, f, g, h, a, b, c, d, 0x391c0cb3 + (w4 += sigma1(w2) + w13 + sigma0(w5)));
140 61747 : Round(d, e, f, g, h, a, b, c, 0x4ed8aa4a + (w5 += sigma1(w3) + w14 + sigma0(w6)));
141 61747 : Round(c, d, e, f, g, h, a, b, 0x5b9cca4f + (w6 += sigma1(w4) + w15 + sigma0(w7)));
142 61747 : Round(b, c, d, e, f, g, h, a, 0x682e6ff3 + (w7 += sigma1(w5) + w0 + sigma0(w8)));
143 61747 : Round(a, b, c, d, e, f, g, h, 0x748f82ee + (w8 += sigma1(w6) + w1 + sigma0(w9)));
144 61747 : Round(h, a, b, c, d, e, f, g, 0x78a5636f + (w9 += sigma1(w7) + w2 + sigma0(w10)));
145 61747 : Round(g, h, a, b, c, d, e, f, 0x84c87814 + (w10 += sigma1(w8) + w3 + sigma0(w11)));
146 61747 : Round(f, g, h, a, b, c, d, e, 0x8cc70208 + (w11 += sigma1(w9) + w4 + sigma0(w12)));
147 61747 : Round(e, f, g, h, a, b, c, d, 0x90befffa + (w12 += sigma1(w10) + w5 + sigma0(w13)));
148 61747 : Round(d, e, f, g, h, a, b, c, 0xa4506ceb + (w13 += sigma1(w11) + w6 + sigma0(w14)));
149 61747 : Round(c, d, e, f, g, h, a, b, 0xbef9a3f7 + (w14 + sigma1(w12) + w7 + sigma0(w15)));
150 61747 : Round(b, c, d, e, f, g, h, a, 0xc67178f2 + (w15 + sigma1(w13) + w8 + sigma0(w0)));
151 :
152 61747 : s[0] += a;
153 61747 : s[1] += b;
154 61747 : s[2] += c;
155 61747 : s[3] += d;
156 61747 : s[4] += e;
157 61747 : s[5] += f;
158 61747 : s[6] += g;
159 61747 : s[7] += h;
160 61747 : chunk += 64;
161 61747 : }
162 57722 : }
163 :
164 0 : void TransformD64(unsigned char* out, const unsigned char* in)
165 : {
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 : 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 29973 : void TransformD64Wrapper(unsigned char* out, const unsigned char* in)
422 : {
423 29973 : uint32_t s[8];
424 : static const unsigned char padding1[64] = {
425 : 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
426 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
427 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
428 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0
429 : };
430 29973 : unsigned char buffer2[64] = {
431 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
432 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
433 : 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
434 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0
435 : };
436 29973 : sha256::Initialize(s);
437 29973 : tr(s, in, 1);
438 29973 : tr(s, padding1, 1);
439 29973 : WriteBE32(buffer2 + 0, s[0]);
440 29973 : WriteBE32(buffer2 + 4, s[1]);
441 29973 : WriteBE32(buffer2 + 8, s[2]);
442 29973 : WriteBE32(buffer2 + 12, s[3]);
443 29973 : WriteBE32(buffer2 + 16, s[4]);
444 29973 : WriteBE32(buffer2 + 20, s[5]);
445 29973 : WriteBE32(buffer2 + 24, s[6]);
446 29973 : WriteBE32(buffer2 + 28, s[7]);
447 29973 : sha256::Initialize(s);
448 29973 : tr(s, buffer2, 1);
449 29973 : WriteBE32(out + 0, s[0]);
450 29973 : WriteBE32(out + 4, s[1]);
451 29973 : WriteBE32(out + 8, s[2]);
452 29973 : WriteBE32(out + 12, s[3]);
453 29973 : WriteBE32(out + 16, s[4]);
454 29973 : WriteBE32(out + 20, s[5]);
455 29973 : WriteBE32(out + 24, s[6]);
456 29973 : WriteBE32(out + 28, s[7]);
457 29973 : }
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 992 : bool SelfTest() {
466 : // Input state (equal to the initial SHA256 state)
467 : static const uint32_t init[8] = {
468 : 0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul, 0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul
469 : };
470 : // Some random input data to test with
471 : static const unsigned char data[641] = "-" // Intentionally not aligned
472 : "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do "
473 : "eiusmod tempor incididunt ut labore et dolore magna aliqua. Et m"
474 : "olestie ac feugiat sed lectus vestibulum mattis ullamcorper. Mor"
475 : "bi blandit cursus risus at ultrices mi tempus imperdiet nulla. N"
476 : "unc congue nisi vita suscipit tellus mauris. Imperdiet proin fer"
477 : "mentum leo vel orci. Massa tempor nec feugiat nisl pretium fusce"
478 : " id velit. Telus in metus vulputate eu scelerisque felis. Mi tem"
479 : "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 : static const uint32_t result[9][8] = {
482 : {0x6a09e667ul, 0xbb67ae85ul, 0x3c6ef372ul, 0xa54ff53aul, 0x510e527ful, 0x9b05688cul, 0x1f83d9abul, 0x5be0cd19ul},
483 : {0x91f8ec6bul, 0x4da10fe3ul, 0x1c9c292cul, 0x45e18185ul, 0x435cc111ul, 0x3ca26f09ul, 0xeb954caeul, 0x402a7069ul},
484 : {0xcabea5acul, 0x374fb97cul, 0x182ad996ul, 0x7bd69cbful, 0x450ff900ul, 0xc1d2be8aul, 0x6a41d505ul, 0xe6212dc3ul},
485 : {0xbcff09d6ul, 0x3e76f36eul, 0x3ecb2501ul, 0x78866e97ul, 0xe1c1e2fdul, 0x32f4eafful, 0x8aa6c4e5ul, 0xdfc024bcul},
486 : {0xa08c5d94ul, 0x0a862f93ul, 0x6b7f2f40ul, 0x8f9fae76ul, 0x6d40439ful, 0x79dcee0cul, 0x3e39ff3aul, 0xdc3bdbb1ul},
487 : {0x216a0895ul, 0x9f1a3662ul, 0xe99946f9ul, 0x87ba4364ul, 0x0fb5db2cul, 0x12bed3d3ul, 0x6689c0c7ul, 0x292f1b04ul},
488 : {0xca3067f8ul, 0xbc8c2656ul, 0x37cb7e0dul, 0x9b6b8b0ful, 0x46dc380bul, 0xf1287f57ul, 0xc42e4b23ul, 0x3fefe94dul},
489 : {0x3e4c4039ul, 0xbb6fca8cul, 0x6f27d2f7ul, 0x301e44a4ul, 0x8352ba14ul, 0x5769ce37ul, 0x48a1155ful, 0xc0e1c4c6ul},
490 : {0xfe2fa9ddul, 0x69d0862bul, 0x1ae0db23ul, 0x471f9244ul, 0xf55c0145ul, 0xc30f9c3bul, 0x40a84ea0ul, 0x5b8a266cul},
491 : };
492 : // Expected output for each of the individual 8 64-byte messages under full double SHA256 (including padding).
493 : static const unsigned char result_d64[256] = {
494 : 0x09, 0x3a, 0xc4, 0xd0, 0x0f, 0xf7, 0x57, 0xe1, 0x72, 0x85, 0x79, 0x42, 0xfe, 0xe7, 0xe0, 0xa0,
495 : 0xfc, 0x52, 0xd7, 0xdb, 0x07, 0x63, 0x45, 0xfb, 0x53, 0x14, 0x7d, 0x17, 0x22, 0x86, 0xf0, 0x52,
496 : 0x48, 0xb6, 0x11, 0x9e, 0x6e, 0x48, 0x81, 0x6d, 0xcc, 0x57, 0x1f, 0xb2, 0x97, 0xa8, 0xd5, 0x25,
497 : 0x9b, 0x82, 0xaa, 0x89, 0xe2, 0xfd, 0x2d, 0x56, 0xe8, 0x28, 0x83, 0x0b, 0xe2, 0xfa, 0x53, 0xb7,
498 : 0xd6, 0x6b, 0x07, 0x85, 0x83, 0xb0, 0x10, 0xa2, 0xf5, 0x51, 0x3c, 0xf9, 0x60, 0x03, 0xab, 0x45,
499 : 0x6c, 0x15, 0x6e, 0xef, 0xb5, 0xac, 0x3e, 0x6c, 0xdf, 0xb4, 0x92, 0x22, 0x2d, 0xce, 0xbf, 0x3e,
500 : 0xe9, 0xe5, 0xf6, 0x29, 0x0e, 0x01, 0x4f, 0xd2, 0xd4, 0x45, 0x65, 0xb3, 0xbb, 0xf2, 0x4c, 0x16,
501 : 0x37, 0x50, 0x3c, 0x6e, 0x49, 0x8c, 0x5a, 0x89, 0x2b, 0x1b, 0xab, 0xc4, 0x37, 0xd1, 0x46, 0xe9,
502 : 0x3d, 0x0e, 0x85, 0xa2, 0x50, 0x73, 0xa1, 0x5e, 0x54, 0x37, 0xd7, 0x94, 0x17, 0x56, 0xc2, 0xd8,
503 : 0xe5, 0x9f, 0xed, 0x4e, 0xae, 0x15, 0x42, 0x06, 0x0d, 0x74, 0x74, 0x5e, 0x24, 0x30, 0xce, 0xd1,
504 : 0x9e, 0x50, 0xa3, 0x9a, 0xb8, 0xf0, 0x4a, 0x57, 0x69, 0x78, 0x67, 0x12, 0x84, 0x58, 0xbe, 0xc7,
505 : 0x36, 0xaa, 0xee, 0x7c, 0x64, 0xa3, 0x76, 0xec, 0xff, 0x55, 0x41, 0x00, 0x2a, 0x44, 0x68, 0x4d,
506 : 0xb6, 0x53, 0x9e, 0x1c, 0x95, 0xb7, 0xca, 0xdc, 0x7f, 0x7d, 0x74, 0x27, 0x5c, 0x8e, 0xa6, 0x84,
507 : 0xb5, 0xac, 0x87, 0xa9, 0xf3, 0xff, 0x75, 0xf2, 0x34, 0xcd, 0x1a, 0x3b, 0x82, 0x2c, 0x2b, 0x4e,
508 : 0x6a, 0x46, 0x30, 0xa6, 0x89, 0x86, 0x23, 0xac, 0xf8, 0xa5, 0x15, 0xe9, 0x0a, 0xaa, 0x1e, 0x9a,
509 : 0xd7, 0x93, 0x6b, 0x28, 0xe4, 0x3b, 0xfd, 0x59, 0xc6, 0xed, 0x7c, 0x5f, 0xa5, 0x41, 0xcb, 0x51
510 : };
511 :
512 :
513 : // Test Transform() for 0 through 8 transformations.
514 9920 : for (size_t i = 0; i <= 8; ++i) {
515 8928 : uint32_t state[8];
516 8928 : std::copy(init, init + 8, state);
517 8928 : Transform(state, data + 1, i);
518 8928 : if (!std::equal(state, state + 8, result[i])) return false;
519 8928 : }
520 :
521 : // Test TransformD64
522 992 : unsigned char out[32];
523 992 : TransformD64(out, data + 1);
524 992 : if (!std::equal(out, out + 32, result_d64)) return false;
525 :
526 : // Test TransformD64_2way, if available.
527 992 : 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 0 : }
532 :
533 : // Test TransformD64_4way, if available.
534 992 : if (TransformD64_4way) {
535 992 : unsigned char out[128];
536 992 : TransformD64_4way(out, data + 1);
537 992 : if (!std::equal(out, out + 128, result_d64)) return false;
538 992 : }
539 :
540 : // Test TransformD64_8way, if available.
541 992 : if (TransformD64_8way) {
542 992 : unsigned char out[256];
543 992 : TransformD64_8way(out, data + 1);
544 992 : if (!std::equal(out, out + 256, result_d64)) return false;
545 992 : }
546 :
547 992 : return true;
548 992 : }
549 :
550 : #if defined(USE_ASM) && (defined(__x86_64__) || defined(__amd64__) || defined(__i386__))
551 : /** Check whether the OS has enabled AVX registers. */
552 992 : bool AVXEnabled()
553 : {
554 : uint32_t a, d;
555 992 : __asm__("xgetbv" : "=a"(a), "=d"(d) : "c"(0));
556 992 : return (a & 6) == 6;
557 : }
558 : #endif
559 : } // namespace
560 :
561 :
562 992 : std::string SHA256AutoDetect()
563 : {
564 992 : std::string ret = "standard";
565 : #if defined(USE_ASM) && defined(HAVE_GETCPUID)
566 : bool have_sse4 = false;
567 : bool have_xsave = false;
568 : bool have_avx = false;
569 : bool have_avx2 = false;
570 : bool have_shani = false;
571 : bool enabled_avx = false;
572 :
573 : (void)AVXEnabled;
574 : (void)have_sse4;
575 : (void)have_avx;
576 : (void)have_xsave;
577 : (void)have_avx2;
578 : (void)have_shani;
579 : (void)enabled_avx;
580 :
581 992 : uint32_t eax, ebx, ecx, edx;
582 992 : GetCPUID(1, 0, eax, ebx, ecx, edx);
583 992 : have_sse4 = (ecx >> 19) & 1;
584 992 : have_xsave = (ecx >> 27) & 1;
585 992 : have_avx = (ecx >> 28) & 1;
586 992 : if (have_xsave && have_avx) {
587 992 : enabled_avx = AVXEnabled();
588 992 : }
589 992 : if (have_sse4) {
590 992 : GetCPUID(7, 0, eax, ebx, ecx, edx);
591 992 : have_avx2 = (ebx >> 5) & 1;
592 992 : have_shani = (ebx >> 29) & 1;
593 992 : }
594 :
595 : #if defined(ENABLE_SHANI) && !defined(BUILD_BITCOIN_INTERNAL)
596 992 : 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 : have_sse4 = false; // Disable SSE4/AVX2;
602 : have_avx2 = false;
603 0 : }
604 : #endif
605 :
606 992 : if (have_sse4) {
607 : #if defined(__x86_64__) || defined(__amd64__)
608 992 : Transform = sha256_sse4::Transform;
609 992 : TransformD64 = TransformD64Wrapper<sha256_sse4::Transform>;
610 992 : ret = "sse4(1way)";
611 : #endif
612 : #if defined(ENABLE_SSE41) && !defined(BUILD_BITCOIN_INTERNAL)
613 992 : TransformD64_4way = sha256d64_sse41::Transform_4way;
614 992 : ret += ",sse41(4way)";
615 : #endif
616 : }
617 :
618 : #if defined(ENABLE_AVX2) && !defined(BUILD_BITCOIN_INTERNAL)
619 992 : if (have_avx2 && have_avx && enabled_avx) {
620 992 : TransformD64_8way = sha256d64_avx2::Transform_8way;
621 992 : ret += ",avx2(8way)";
622 : }
623 : #endif
624 : #endif
625 :
626 992 : assert(SelfTest());
627 : return ret;
628 992 : }
629 :
630 : ////// SHA-256
631 :
632 25540104 : CSHA256::CSHA256() : bytes(0)
633 12769991 : {
634 12770113 : sha256::Initialize(s);
635 25540104 : }
636 :
637 228541478 : CSHA256& CSHA256::Write(const unsigned char* data, size_t len)
638 : {
639 228541478 : const unsigned char* end = data + len;
640 228541478 : size_t bufsize = bytes % 64;
641 228541478 : if (bufsize && bufsize + len >= 64) {
642 : // Fill the buffer, and process it.
643 50283970 : memcpy(buf + bufsize, data, 64 - bufsize);
644 50283970 : bytes += 64 - bufsize;
645 50283970 : data += 64 - bufsize;
646 50283970 : Transform(s, buf, 1);
647 : bufsize = 0;
648 50283970 : }
649 228550862 : if (end - data >= 64) {
650 1457318 : size_t blocks = (end - data) / 64;
651 1457318 : Transform(s, data, blocks);
652 1457318 : data += 64 * blocks;
653 1457318 : bytes += 64 * blocks;
654 1457318 : }
655 228545081 : if (end > data) {
656 : // Fill the buffer with what remains.
657 199723909 : memcpy(buf + bufsize, data, end - data);
658 199723909 : bytes += end - data;
659 199723909 : }
660 228550450 : return *this;
661 : }
662 :
663 22674742 : void CSHA256::Finalize(unsigned char hash[OUTPUT_SIZE])
664 : {
665 : static const unsigned char pad[64] = {0x80};
666 22674742 : unsigned char sizedesc[8];
667 22674742 : WriteBE64(sizedesc, bytes << 3);
668 22674742 : Write(pad, 1 + ((119 - (bytes % 64)) % 64));
669 22674742 : Write(sizedesc, 8);
670 22674742 : WriteBE32(hash, s[0]);
671 22674742 : WriteBE32(hash + 4, s[1]);
672 22674742 : WriteBE32(hash + 8, s[2]);
673 22674742 : WriteBE32(hash + 12, s[3]);
674 22674742 : WriteBE32(hash + 16, s[4]);
675 22674742 : WriteBE32(hash + 20, s[5]);
676 22674742 : WriteBE32(hash + 24, s[6]);
677 22674742 : WriteBE32(hash + 28, s[7]);
678 22674742 : }
679 :
680 9348154 : CSHA256& CSHA256::Reset()
681 : {
682 9348154 : bytes = 0;
683 9348154 : sha256::Initialize(s);
684 9348154 : return *this;
685 : }
686 :
687 22542 : void SHA256D64(unsigned char* out, const unsigned char* in, size_t blocks)
688 : {
689 22542 : if (TransformD64_8way) {
690 75305 : while (blocks >= 8) {
691 52763 : TransformD64_8way(out, in);
692 52763 : out += 256;
693 52763 : in += 512;
694 52763 : blocks -= 8;
695 : }
696 : }
697 22542 : if (TransformD64_4way) {
698 25388 : while (blocks >= 4) {
699 2846 : TransformD64_4way(out, in);
700 2846 : out += 128;
701 2846 : in += 256;
702 2846 : blocks -= 4;
703 : }
704 : }
705 22542 : 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 : }
712 : }
713 51523 : while (blocks) {
714 28981 : TransformD64(out, in);
715 28981 : out += 32;
716 28981 : in += 64;
717 28981 : --blocks;
718 : }
719 22542 : }
|
