26 #if defined(BYTE_ORDER) && defined(BIG_ENDIAN) && BYTE_ORDER == BIG_ENDIAN
27 #define SHA_BIG_ENDIAN
37 Buf[
I & 15] =
rol(Buf[(
I + 13) & 15] ^ Buf[(
I + 8) & 15] ^ Buf[(
I + 2) & 15] ^
45 E += ((
B & (
C ^
D)) ^
D) +
blk0(Buf,
I) + 0x5A827999 +
rol(A, 5);
51 E += ((
B & (
C ^
D)) ^
D) +
blk(Buf,
I) + 0x5A827999 +
rol(A, 5);
57 E += (
B ^
C ^
D) +
blk(Buf,
I) + 0x6ED9EBA1 +
rol(A, 5);
63 E += (((
B |
C) &
D) | (
B &
C)) +
blk(Buf,
I) + 0x8F1BBCDC +
rol(A, 5);
69 E += (
B ^
C ^
D) +
blk(Buf,
I) + 0xCA62C1D6 +
rol(A, 5);
74 #define SHA1_K0 0x5a827999
75 #define SHA1_K20 0x6ed9eba1
76 #define SHA1_K40 0x8f1bbcdc
77 #define SHA1_K60 0xca62c1d6
79 #define SEED_0 0x67452301
80 #define SEED_1 0xefcdab89
81 #define SEED_2 0x98badcfe
82 #define SEED_3 0x10325476
83 #define SEED_4 0xc3d2e1f0
86 InternalState.State[0] =
SEED_0;
87 InternalState.State[1] =
SEED_1;
88 InternalState.State[2] =
SEED_2;
89 InternalState.State[3] =
SEED_3;
90 InternalState.State[4] =
SEED_4;
91 InternalState.ByteCount = 0;
92 InternalState.BufferOffset = 0;
95 void SHA1::hashBlock() {
103 r0(A,
B,
C,
D,
E, 0, InternalState.Buffer.L);
104 r0(
E, A,
B,
C,
D, 1, InternalState.Buffer.L);
105 r0(
D,
E, A,
B,
C, 2, InternalState.Buffer.L);
106 r0(
C,
D,
E, A,
B, 3, InternalState.Buffer.L);
107 r0(
B,
C,
D,
E, A, 4, InternalState.Buffer.L);
108 r0(A,
B,
C,
D,
E, 5, InternalState.Buffer.L);
109 r0(
E, A,
B,
C,
D, 6, InternalState.Buffer.L);
110 r0(
D,
E, A,
B,
C, 7, InternalState.Buffer.L);
111 r0(
C,
D,
E, A,
B, 8, InternalState.Buffer.L);
112 r0(
B,
C,
D,
E, A, 9, InternalState.Buffer.L);
113 r0(A,
B,
C,
D,
E, 10, InternalState.Buffer.L);
114 r0(
E, A,
B,
C,
D, 11, InternalState.Buffer.L);
115 r0(
D,
E, A,
B,
C, 12, InternalState.Buffer.L);
116 r0(
C,
D,
E, A,
B, 13, InternalState.Buffer.L);
117 r0(
B,
C,
D,
E, A, 14, InternalState.Buffer.L);
118 r0(A,
B,
C,
D,
E, 15, InternalState.Buffer.L);
119 r1(
E, A,
B,
C,
D, 16, InternalState.Buffer.L);
120 r1(
D,
E, A,
B,
C, 17, InternalState.Buffer.L);
121 r1(
C,
D,
E, A,
B, 18, InternalState.Buffer.L);
122 r1(
B,
C,
D,
E, A, 19, InternalState.Buffer.L);
124 r2(A,
B,
C,
D,
E, 20, InternalState.Buffer.L);
125 r2(
E, A,
B,
C,
D, 21, InternalState.Buffer.L);
126 r2(
D,
E, A,
B,
C, 22, InternalState.Buffer.L);
127 r2(
C,
D,
E, A,
B, 23, InternalState.Buffer.L);
128 r2(
B,
C,
D,
E, A, 24, InternalState.Buffer.L);
129 r2(A,
B,
C,
D,
E, 25, InternalState.Buffer.L);
130 r2(
E, A,
B,
C,
D, 26, InternalState.Buffer.L);
131 r2(
D,
E, A,
B,
C, 27, InternalState.Buffer.L);
132 r2(
C,
D,
E, A,
B, 28, InternalState.Buffer.L);
133 r2(
B,
C,
D,
E, A, 29, InternalState.Buffer.L);
134 r2(A,
B,
C,
D,
E, 30, InternalState.Buffer.L);
135 r2(
E, A,
B,
C,
D, 31, InternalState.Buffer.L);
136 r2(
D,
E, A,
B,
C, 32, InternalState.Buffer.L);
137 r2(
C,
D,
E, A,
B, 33, InternalState.Buffer.L);
138 r2(
B,
C,
D,
E, A, 34, InternalState.Buffer.L);
139 r2(A,
B,
C,
D,
E, 35, InternalState.Buffer.L);
140 r2(
E, A,
B,
C,
D, 36, InternalState.Buffer.L);
141 r2(
D,
E, A,
B,
C, 37, InternalState.Buffer.L);
142 r2(
C,
D,
E, A,
B, 38, InternalState.Buffer.L);
143 r2(
B,
C,
D,
E, A, 39, InternalState.Buffer.L);
145 r3(A,
B,
C,
D,
E, 40, InternalState.Buffer.L);
146 r3(
E, A,
B,
C,
D, 41, InternalState.Buffer.L);
147 r3(
D,
E, A,
B,
C, 42, InternalState.Buffer.L);
148 r3(
C,
D,
E, A,
B, 43, InternalState.Buffer.L);
149 r3(
B,
C,
D,
E, A, 44, InternalState.Buffer.L);
150 r3(A,
B,
C,
D,
E, 45, InternalState.Buffer.L);
151 r3(
E, A,
B,
C,
D, 46, InternalState.Buffer.L);
152 r3(
D,
E, A,
B,
C, 47, InternalState.Buffer.L);
153 r3(
C,
D,
E, A,
B, 48, InternalState.Buffer.L);
154 r3(
B,
C,
D,
E, A, 49, InternalState.Buffer.L);
155 r3(A,
B,
C,
D,
E, 50, InternalState.Buffer.L);
156 r3(
E, A,
B,
C,
D, 51, InternalState.Buffer.L);
157 r3(
D,
E, A,
B,
C, 52, InternalState.Buffer.L);
158 r3(
C,
D,
E, A,
B, 53, InternalState.Buffer.L);
159 r3(
B,
C,
D,
E, A, 54, InternalState.Buffer.L);
160 r3(A,
B,
C,
D,
E, 55, InternalState.Buffer.L);
161 r3(
E, A,
B,
C,
D, 56, InternalState.Buffer.L);
162 r3(
D,
E, A,
B,
C, 57, InternalState.Buffer.L);
163 r3(
C,
D,
E, A,
B, 58, InternalState.Buffer.L);
164 r3(
B,
C,
D,
E, A, 59, InternalState.Buffer.L);
166 r4(A,
B,
C,
D,
E, 60, InternalState.Buffer.L);
167 r4(
E, A,
B,
C,
D, 61, InternalState.Buffer.L);
168 r4(
D,
E, A,
B,
C, 62, InternalState.Buffer.L);
169 r4(
C,
D,
E, A,
B, 63, InternalState.Buffer.L);
170 r4(
B,
C,
D,
E, A, 64, InternalState.Buffer.L);
171 r4(A,
B,
C,
D,
E, 65, InternalState.Buffer.L);
172 r4(
E, A,
B,
C,
D, 66, InternalState.Buffer.L);
173 r4(
D,
E, A,
B,
C, 67, InternalState.Buffer.L);
174 r4(
C,
D,
E, A,
B, 68, InternalState.Buffer.L);
175 r4(
B,
C,
D,
E, A, 69, InternalState.Buffer.L);
176 r4(A,
B,
C,
D,
E, 70, InternalState.Buffer.L);
177 r4(
E, A,
B,
C,
D, 71, InternalState.Buffer.L);
178 r4(
D,
E, A,
B,
C, 72, InternalState.Buffer.L);
179 r4(
C,
D,
E, A,
B, 73, InternalState.Buffer.L);
180 r4(
B,
C,
D,
E, A, 74, InternalState.Buffer.L);
181 r4(A,
B,
C,
D,
E, 75, InternalState.Buffer.L);
182 r4(
E, A,
B,
C,
D, 76, InternalState.Buffer.L);
183 r4(
D,
E, A,
B,
C, 77, InternalState.Buffer.L);
184 r4(
C,
D,
E, A,
B, 78, InternalState.Buffer.L);
185 r4(
B,
C,
D,
E, A, 79, InternalState.Buffer.L);
187 InternalState.State[0] += A;
188 InternalState.State[1] +=
B;
189 InternalState.State[2] +=
C;
190 InternalState.State[3] +=
D;
191 InternalState.State[4] +=
E;
194 void SHA1::addUncounted(uint8_t
Data) {
195 #ifdef SHA_BIG_ENDIAN
196 InternalState.Buffer.C[InternalState.BufferOffset] =
Data;
198 InternalState.Buffer.C[InternalState.BufferOffset ^ 3] =
Data;
201 InternalState.BufferOffset++;
202 if (InternalState.BufferOffset == BLOCK_LENGTH) {
204 InternalState.BufferOffset = 0;
208 void SHA1::writebyte(uint8_t
Data) {
209 ++InternalState.ByteCount;
214 InternalState.ByteCount +=
Data.size();
217 if (InternalState.BufferOffset > 0) {
218 const size_t Remainder = std::min<size_t>(
219 Data.size(), BLOCK_LENGTH - InternalState.BufferOffset);
220 for (
size_t I = 0;
I < Remainder; ++
I)
221 addUncounted(
Data[
I]);
226 while (
Data.size() >= BLOCK_LENGTH) {
227 assert(InternalState.BufferOffset == 0);
228 static_assert(BLOCK_LENGTH % 4 == 0,
"");
229 constexpr
size_t BLOCK_LENGTH_32 = BLOCK_LENGTH / 4;
230 for (
size_t I = 0;
I < BLOCK_LENGTH_32; ++
I)
233 Data =
Data.drop_front(BLOCK_LENGTH);
237 for (uint8_t
C :
Data)
251 while (InternalState.BufferOffset != 56)
258 addUncounted(InternalState.ByteCount >> 29);
259 addUncounted(InternalState.ByteCount >>
261 addUncounted(InternalState.ByteCount >> 13);
262 addUncounted(InternalState.ByteCount >> 5);
263 addUncounted(InternalState.ByteCount << 3);
266 void SHA1::final(std::array<uint32_t, HASH_LENGTH / 4> &HashResult) {
270 #ifdef SHA_BIG_ENDIAN
272 for (
int i = 0;
i < 5;
i++) {
273 HashResult[
i] = InternalState.State[
i];
277 for (
int i = 0;
i < 5;
i++) {
278 HashResult[
i] = (((InternalState.State[
i]) << 24) & 0xff000000) |
279 (((InternalState.State[
i]) << 8) & 0x00ff0000) |
280 (((InternalState.State[
i]) >> 8) & 0x0000ff00) |
281 (((InternalState.State[
i]) >> 24) & 0x000000ff);
288 std::array<
uint32_t, HASH_LENGTH / 4> HashResult;
289 std::array<uint8_t, HASH_LENGTH> ReturnResult;
291 static_assert(
sizeof(HashResult) ==
sizeof(ReturnResult),
"");
297 auto StateToRestore = InternalState;
302 InternalState = StateToRestore;