1 // Copyright (c) 2014 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.
5 #include "crypto/sha256.h"
7 #include "crypto/common.h"
11 // Internal implementation code.
14 /// Internal SHA-256 implementation.
17 uint32_t inline Ch(uint32_t x
, uint32_t y
, uint32_t z
) { return z
^ (x
& (y
^ z
)); }
18 uint32_t inline Maj(uint32_t x
, uint32_t y
, uint32_t z
) { return (x
& y
) | (z
& (x
| y
)); }
19 uint32_t inline Sigma0(uint32_t x
) { return (x
>> 2 | x
<< 30) ^ (x
>> 13 | x
<< 19) ^ (x
>> 22 | x
<< 10); }
20 uint32_t inline Sigma1(uint32_t x
) { return (x
>> 6 | x
<< 26) ^ (x
>> 11 | x
<< 21) ^ (x
>> 25 | x
<< 7); }
21 uint32_t inline sigma0(uint32_t x
) { return (x
>> 7 | x
<< 25) ^ (x
>> 18 | x
<< 14) ^ (x
>> 3); }
22 uint32_t inline sigma1(uint32_t x
) { return (x
>> 17 | x
<< 15) ^ (x
>> 19 | x
<< 13) ^ (x
>> 10); }
24 /** One round of SHA-256. */
25 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
, uint32_t w
)
27 uint32_t t1
= h
+ Sigma1(e
) + Ch(e
, f
, g
) + k
+ w
;
28 uint32_t t2
= Sigma0(a
) + Maj(a
, b
, c
);
33 /** Initialize SHA-256 state. */
34 void inline Initialize(uint32_t* s
)
46 /** Perform one SHA-256 transformation, processing a 64-byte chunk. */
47 void Transform(uint32_t* s
, const unsigned char* chunk
)
49 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];
50 uint32_t w0
, w1
, w2
, w3
, w4
, w5
, w6
, w7
, w8
, w9
, w10
, w11
, w12
, w13
, w14
, w15
;
52 Round(a
, b
, c
, d
, e
, f
, g
, h
, 0x428a2f98, w0
= ReadBE32(chunk
+ 0));
53 Round(h
, a
, b
, c
, d
, e
, f
, g
, 0x71374491, w1
= ReadBE32(chunk
+ 4));
54 Round(g
, h
, a
, b
, c
, d
, e
, f
, 0xb5c0fbcf, w2
= ReadBE32(chunk
+ 8));
55 Round(f
, g
, h
, a
, b
, c
, d
, e
, 0xe9b5dba5, w3
= ReadBE32(chunk
+ 12));
56 Round(e
, f
, g
, h
, a
, b
, c
, d
, 0x3956c25b, w4
= ReadBE32(chunk
+ 16));
57 Round(d
, e
, f
, g
, h
, a
, b
, c
, 0x59f111f1, w5
= ReadBE32(chunk
+ 20));
58 Round(c
, d
, e
, f
, g
, h
, a
, b
, 0x923f82a4, w6
= ReadBE32(chunk
+ 24));
59 Round(b
, c
, d
, e
, f
, g
, h
, a
, 0xab1c5ed5, w7
= ReadBE32(chunk
+ 28));
60 Round(a
, b
, c
, d
, e
, f
, g
, h
, 0xd807aa98, w8
= ReadBE32(chunk
+ 32));
61 Round(h
, a
, b
, c
, d
, e
, f
, g
, 0x12835b01, w9
= ReadBE32(chunk
+ 36));
62 Round(g
, h
, a
, b
, c
, d
, e
, f
, 0x243185be, w10
= ReadBE32(chunk
+ 40));
63 Round(f
, g
, h
, a
, b
, c
, d
, e
, 0x550c7dc3, w11
= ReadBE32(chunk
+ 44));
64 Round(e
, f
, g
, h
, a
, b
, c
, d
, 0x72be5d74, w12
= ReadBE32(chunk
+ 48));
65 Round(d
, e
, f
, g
, h
, a
, b
, c
, 0x80deb1fe, w13
= ReadBE32(chunk
+ 52));
66 Round(c
, d
, e
, f
, g
, h
, a
, b
, 0x9bdc06a7, w14
= ReadBE32(chunk
+ 56));
67 Round(b
, c
, d
, e
, f
, g
, h
, a
, 0xc19bf174, w15
= ReadBE32(chunk
+ 60));
69 Round(a
, b
, c
, d
, e
, f
, g
, h
, 0xe49b69c1, w0
+= sigma1(w14
) + w9
+ sigma0(w1
));
70 Round(h
, a
, b
, c
, d
, e
, f
, g
, 0xefbe4786, w1
+= sigma1(w15
) + w10
+ sigma0(w2
));
71 Round(g
, h
, a
, b
, c
, d
, e
, f
, 0x0fc19dc6, w2
+= sigma1(w0
) + w11
+ sigma0(w3
));
72 Round(f
, g
, h
, a
, b
, c
, d
, e
, 0x240ca1cc, w3
+= sigma1(w1
) + w12
+ sigma0(w4
));
73 Round(e
, f
, g
, h
, a
, b
, c
, d
, 0x2de92c6f, w4
+= sigma1(w2
) + w13
+ sigma0(w5
));
74 Round(d
, e
, f
, g
, h
, a
, b
, c
, 0x4a7484aa, w5
+= sigma1(w3
) + w14
+ sigma0(w6
));
75 Round(c
, d
, e
, f
, g
, h
, a
, b
, 0x5cb0a9dc, w6
+= sigma1(w4
) + w15
+ sigma0(w7
));
76 Round(b
, c
, d
, e
, f
, g
, h
, a
, 0x76f988da, w7
+= sigma1(w5
) + w0
+ sigma0(w8
));
77 Round(a
, b
, c
, d
, e
, f
, g
, h
, 0x983e5152, w8
+= sigma1(w6
) + w1
+ sigma0(w9
));
78 Round(h
, a
, b
, c
, d
, e
, f
, g
, 0xa831c66d, w9
+= sigma1(w7
) + w2
+ sigma0(w10
));
79 Round(g
, h
, a
, b
, c
, d
, e
, f
, 0xb00327c8, w10
+= sigma1(w8
) + w3
+ sigma0(w11
));
80 Round(f
, g
, h
, a
, b
, c
, d
, e
, 0xbf597fc7, w11
+= sigma1(w9
) + w4
+ sigma0(w12
));
81 Round(e
, f
, g
, h
, a
, b
, c
, d
, 0xc6e00bf3, w12
+= sigma1(w10
) + w5
+ sigma0(w13
));
82 Round(d
, e
, f
, g
, h
, a
, b
, c
, 0xd5a79147, w13
+= sigma1(w11
) + w6
+ sigma0(w14
));
83 Round(c
, d
, e
, f
, g
, h
, a
, b
, 0x06ca6351, w14
+= sigma1(w12
) + w7
+ sigma0(w15
));
84 Round(b
, c
, d
, e
, f
, g
, h
, a
, 0x14292967, w15
+= sigma1(w13
) + w8
+ sigma0(w0
));
86 Round(a
, b
, c
, d
, e
, f
, g
, h
, 0x27b70a85, w0
+= sigma1(w14
) + w9
+ sigma0(w1
));
87 Round(h
, a
, b
, c
, d
, e
, f
, g
, 0x2e1b2138, w1
+= sigma1(w15
) + w10
+ sigma0(w2
));
88 Round(g
, h
, a
, b
, c
, d
, e
, f
, 0x4d2c6dfc, w2
+= sigma1(w0
) + w11
+ sigma0(w3
));
89 Round(f
, g
, h
, a
, b
, c
, d
, e
, 0x53380d13, w3
+= sigma1(w1
) + w12
+ sigma0(w4
));
90 Round(e
, f
, g
, h
, a
, b
, c
, d
, 0x650a7354, w4
+= sigma1(w2
) + w13
+ sigma0(w5
));
91 Round(d
, e
, f
, g
, h
, a
, b
, c
, 0x766a0abb, w5
+= sigma1(w3
) + w14
+ sigma0(w6
));
92 Round(c
, d
, e
, f
, g
, h
, a
, b
, 0x81c2c92e, w6
+= sigma1(w4
) + w15
+ sigma0(w7
));
93 Round(b
, c
, d
, e
, f
, g
, h
, a
, 0x92722c85, w7
+= sigma1(w5
) + w0
+ sigma0(w8
));
94 Round(a
, b
, c
, d
, e
, f
, g
, h
, 0xa2bfe8a1, w8
+= sigma1(w6
) + w1
+ sigma0(w9
));
95 Round(h
, a
, b
, c
, d
, e
, f
, g
, 0xa81a664b, w9
+= sigma1(w7
) + w2
+ sigma0(w10
));
96 Round(g
, h
, a
, b
, c
, d
, e
, f
, 0xc24b8b70, w10
+= sigma1(w8
) + w3
+ sigma0(w11
));
97 Round(f
, g
, h
, a
, b
, c
, d
, e
, 0xc76c51a3, w11
+= sigma1(w9
) + w4
+ sigma0(w12
));
98 Round(e
, f
, g
, h
, a
, b
, c
, d
, 0xd192e819, w12
+= sigma1(w10
) + w5
+ sigma0(w13
));
99 Round(d
, e
, f
, g
, h
, a
, b
, c
, 0xd6990624, w13
+= sigma1(w11
) + w6
+ sigma0(w14
));
100 Round(c
, d
, e
, f
, g
, h
, a
, b
, 0xf40e3585, w14
+= sigma1(w12
) + w7
+ sigma0(w15
));
101 Round(b
, c
, d
, e
, f
, g
, h
, a
, 0x106aa070, w15
+= sigma1(w13
) + w8
+ sigma0(w0
));
103 Round(a
, b
, c
, d
, e
, f
, g
, h
, 0x19a4c116, w0
+= sigma1(w14
) + w9
+ sigma0(w1
));
104 Round(h
, a
, b
, c
, d
, e
, f
, g
, 0x1e376c08, w1
+= sigma1(w15
) + w10
+ sigma0(w2
));
105 Round(g
, h
, a
, b
, c
, d
, e
, f
, 0x2748774c, w2
+= sigma1(w0
) + w11
+ sigma0(w3
));
106 Round(f
, g
, h
, a
, b
, c
, d
, e
, 0x34b0bcb5, w3
+= sigma1(w1
) + w12
+ sigma0(w4
));
107 Round(e
, f
, g
, h
, a
, b
, c
, d
, 0x391c0cb3, w4
+= sigma1(w2
) + w13
+ sigma0(w5
));
108 Round(d
, e
, f
, g
, h
, a
, b
, c
, 0x4ed8aa4a, w5
+= sigma1(w3
) + w14
+ sigma0(w6
));
109 Round(c
, d
, e
, f
, g
, h
, a
, b
, 0x5b9cca4f, w6
+= sigma1(w4
) + w15
+ sigma0(w7
));
110 Round(b
, c
, d
, e
, f
, g
, h
, a
, 0x682e6ff3, w7
+= sigma1(w5
) + w0
+ sigma0(w8
));
111 Round(a
, b
, c
, d
, e
, f
, g
, h
, 0x748f82ee, w8
+= sigma1(w6
) + w1
+ sigma0(w9
));
112 Round(h
, a
, b
, c
, d
, e
, f
, g
, 0x78a5636f, w9
+= sigma1(w7
) + w2
+ sigma0(w10
));
113 Round(g
, h
, a
, b
, c
, d
, e
, f
, 0x84c87814, w10
+= sigma1(w8
) + w3
+ sigma0(w11
));
114 Round(f
, g
, h
, a
, b
, c
, d
, e
, 0x8cc70208, w11
+= sigma1(w9
) + w4
+ sigma0(w12
));
115 Round(e
, f
, g
, h
, a
, b
, c
, d
, 0x90befffa, w12
+= sigma1(w10
) + w5
+ sigma0(w13
));
116 Round(d
, e
, f
, g
, h
, a
, b
, c
, 0xa4506ceb, w13
+= sigma1(w11
) + w6
+ sigma0(w14
));
117 Round(c
, d
, e
, f
, g
, h
, a
, b
, 0xbef9a3f7, w14
+ sigma1(w12
) + w7
+ sigma0(w15
));
118 Round(b
, c
, d
, e
, f
, g
, h
, a
, 0xc67178f2, w15
+ sigma1(w13
) + w8
+ sigma0(w0
));
130 } // namespace sha256
136 CSHA256::CSHA256() : bytes(0)
138 sha256::Initialize(s
);
141 CSHA256
& CSHA256::Write(const unsigned char* data
, size_t len
)
143 const unsigned char* end
= data
+ len
;
144 size_t bufsize
= bytes
% 64;
145 if (bufsize
&& bufsize
+ len
>= 64) {
146 // Fill the buffer, and process it.
147 memcpy(buf
+ bufsize
, data
, 64 - bufsize
);
148 bytes
+= 64 - bufsize
;
149 data
+= 64 - bufsize
;
150 sha256::Transform(s
, buf
);
153 while (end
>= data
+ 64) {
154 // Process full chunks directly from the source.
155 sha256::Transform(s
, data
);
160 // Fill the buffer with what remains.
161 memcpy(buf
+ bufsize
, data
, end
- data
);
167 void CSHA256::Finalize(unsigned char hash
[OUTPUT_SIZE
])
169 static const unsigned char pad
[64] = {0x80};
170 unsigned char sizedesc
[8];
171 WriteBE64(sizedesc
, bytes
<< 3);
172 Write(pad
, 1 + ((119 - (bytes
% 64)) % 64));
174 WriteBE32(hash
, s
[0]);
175 WriteBE32(hash
+ 4, s
[1]);
176 WriteBE32(hash
+ 8, s
[2]);
177 WriteBE32(hash
+ 12, s
[3]);
178 WriteBE32(hash
+ 16, s
[4]);
179 WriteBE32(hash
+ 20, s
[5]);
180 WriteBE32(hash
+ 24, s
[6]);
181 WriteBE32(hash
+ 28, s
[7]);
184 CSHA256
& CSHA256::Reset()
187 sha256::Initialize(s
);