Branch data Line data Source code
1 : : // Copyright (c) 2017-2022 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 : : // Based on the public domain implementation 'merged' by D. J. Bernstein
6 : : // See https://cr.yp.to/chacha.html.
7 : :
8 : : #include <crypto/common.h>
9 : : #include <crypto/chacha20.h>
10 : : #include <support/cleanse.h>
11 : : #include <span.h>
12 : :
13 : : #include <algorithm>
14 : : #include <string.h>
15 : :
16 : 2364647040 : constexpr static inline uint32_t rotl32(uint32_t v, int c) { return (v << c) | (v >> (32 - c)); }
17 : :
18 : : #define QUARTERROUND(a,b,c,d) \
19 : : a += b; d = rotl32(d ^ a, 16); \
20 : : c += d; b = rotl32(b ^ c, 12); \
21 : : a += b; d = rotl32(d ^ a, 8); \
22 : : c += d; b = rotl32(b ^ c, 7);
23 : :
24 : : #define REPEAT10(a) do { {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; {a}; } while(0)
25 : :
26 : 6009869 : void ChaCha20Aligned::SetKey(Span<const std::byte> key) noexcept
27 : : {
28 [ + - ]: 6009869 : assert(key.size() == KEYLEN);
29 [ + - + - ]: 6009869 : input[0] = ReadLE32(UCharCast(key.data() + 0));
30 [ + - + - ]: 6009869 : input[1] = ReadLE32(UCharCast(key.data() + 4));
31 [ + - + - ]: 6009869 : input[2] = ReadLE32(UCharCast(key.data() + 8));
32 [ + - + - ]: 6009869 : input[3] = ReadLE32(UCharCast(key.data() + 12));
33 [ + - + - ]: 6009869 : input[4] = ReadLE32(UCharCast(key.data() + 16));
34 [ + - + - ]: 6009869 : input[5] = ReadLE32(UCharCast(key.data() + 20));
35 [ + - + - ]: 6009869 : input[6] = ReadLE32(UCharCast(key.data() + 24));
36 [ + - + - ]: 6009869 : input[7] = ReadLE32(UCharCast(key.data() + 28));
37 : 6009869 : input[8] = 0;
38 : 6009869 : input[9] = 0;
39 : 6009869 : input[10] = 0;
40 : 6009869 : input[11] = 0;
41 : 6009869 : }
42 : :
43 : 3077223 : ChaCha20Aligned::~ChaCha20Aligned()
44 : : {
45 [ + - ]: 3077223 : memory_cleanse(input, sizeof(input));
46 : 3077223 : }
47 : :
48 : 3077223 : ChaCha20Aligned::ChaCha20Aligned(Span<const std::byte> key) noexcept
49 : : {
50 : 3077223 : SetKey(key);
51 : 3077223 : }
52 : :
53 : 32944 : void ChaCha20Aligned::Seek(Nonce96 nonce, uint32_t block_counter) noexcept
54 : : {
55 : 32944 : input[8] = block_counter;
56 : 32944 : input[9] = nonce.first;
57 : 32944 : input[10] = nonce.second;
58 : 32944 : input[11] = nonce.second >> 32;
59 : 32944 : }
60 : :
61 : 5074867 : inline void ChaCha20Aligned::Keystream(Span<std::byte> output) noexcept
62 : : {
63 [ + - ]: 5074867 : unsigned char* c = UCharCast(output.data());
64 : 5074867 : size_t blocks = output.size() / BLOCKLEN;
65 [ + - ]: 5074867 : assert(blocks * BLOCKLEN == output.size());
66 : :
67 : : uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
68 : : uint32_t j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15;
69 : :
70 [ + - ]: 5074867 : if (!blocks) return;
71 : :
72 : 5074867 : j4 = input[0];
73 : 5074867 : j5 = input[1];
74 : 5074867 : j6 = input[2];
75 : 5074867 : j7 = input[3];
76 : 5074867 : j8 = input[4];
77 : 5074867 : j9 = input[5];
78 : 5074867 : j10 = input[6];
79 : 5074867 : j11 = input[7];
80 : 5074867 : j12 = input[8];
81 : 5074867 : j13 = input[9];
82 : 5074867 : j14 = input[10];
83 : 5074867 : j15 = input[11];
84 : :
85 : 5895494 : for (;;) {
86 : 5895494 : x0 = 0x61707865;
87 : 5895494 : x1 = 0x3320646e;
88 : 5895494 : x2 = 0x79622d32;
89 : 5895494 : x3 = 0x6b206574;
90 : 5895494 : x4 = j4;
91 : 5895494 : x5 = j5;
92 : 5895494 : x6 = j6;
93 : 5895494 : x7 = j7;
94 : 5895494 : x8 = j8;
95 : 5895494 : x9 = j9;
96 : 5895494 : x10 = j10;
97 : 5895494 : x11 = j11;
98 : 5895494 : x12 = j12;
99 : 5895494 : x13 = j13;
100 : 5895494 : x14 = j14;
101 : 5895494 : x15 = j15;
102 : :
103 : : // The 20 inner ChaCha20 rounds are unrolled here for performance.
104 [ + - + - : 5895494 : REPEAT10(
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- + - + -
+ - + - +
- ]
105 : : QUARTERROUND( x0, x4, x8,x12);
106 : : QUARTERROUND( x1, x5, x9,x13);
107 : : QUARTERROUND( x2, x6,x10,x14);
108 : : QUARTERROUND( x3, x7,x11,x15);
109 : : QUARTERROUND( x0, x5,x10,x15);
110 : : QUARTERROUND( x1, x6,x11,x12);
111 : : QUARTERROUND( x2, x7, x8,x13);
112 : : QUARTERROUND( x3, x4, x9,x14);
113 : : );
114 : :
115 : 5895494 : x0 += 0x61707865;
116 : 5895494 : x1 += 0x3320646e;
117 : 5895494 : x2 += 0x79622d32;
118 : 5895494 : x3 += 0x6b206574;
119 : 5895494 : x4 += j4;
120 : 5895494 : x5 += j5;
121 : 5895494 : x6 += j6;
122 : 5895494 : x7 += j7;
123 : 5895494 : x8 += j8;
124 : 5895494 : x9 += j9;
125 : 5895494 : x10 += j10;
126 : 5895494 : x11 += j11;
127 : 5895494 : x12 += j12;
128 : 5895494 : x13 += j13;
129 : 5895494 : x14 += j14;
130 : 5895494 : x15 += j15;
131 : :
132 : 5895494 : ++j12;
133 [ + + ]: 5895494 : if (!j12) ++j13;
134 : :
135 [ + - ]: 5895494 : WriteLE32(c + 0, x0);
136 [ + - ]: 5895494 : WriteLE32(c + 4, x1);
137 [ + - ]: 5897204 : WriteLE32(c + 8, x2);
138 [ + - ]: 5895494 : WriteLE32(c + 12, x3);
139 [ + - ]: 5895494 : WriteLE32(c + 16, x4);
140 [ + - ]: 5897204 : WriteLE32(c + 20, x5);
141 [ + - ]: 5895494 : WriteLE32(c + 24, x6);
142 [ + - ]: 5895494 : WriteLE32(c + 28, x7);
143 [ + - ]: 5895494 : WriteLE32(c + 32, x8);
144 [ + - ]: 5895494 : WriteLE32(c + 36, x9);
145 [ + - ]: 5895494 : WriteLE32(c + 40, x10);
146 [ + - ]: 5895494 : WriteLE32(c + 44, x11);
147 [ + - ]: 5895494 : WriteLE32(c + 48, x12);
148 [ + - ]: 5895494 : WriteLE32(c + 52, x13);
149 [ + - ]: 5895494 : WriteLE32(c + 56, x14);
150 [ + - ]: 5895494 : WriteLE32(c + 60, x15);
151 : :
152 [ + + ]: 5895494 : if (blocks == 1) {
153 : 5074867 : input[8] = j12;
154 : 5074867 : input[9] = j13;
155 : 5074867 : return;
156 : : }
157 : 820627 : blocks -= 1;
158 : 820627 : c += BLOCKLEN;
159 : : }
160 : 5074867 : }
161 : :
162 : 9788 : inline void ChaCha20Aligned::Crypt(Span<const std::byte> in_bytes, Span<std::byte> out_bytes) noexcept
163 : : {
164 [ + - ]: 9788 : assert(in_bytes.size() == out_bytes.size());
165 : 9788 : const unsigned char* m = UCharCast(in_bytes.data());
166 : 9788 : unsigned char* c = UCharCast(out_bytes.data());
167 : 9788 : size_t blocks = out_bytes.size() / BLOCKLEN;
168 [ - + ]: 9788 : assert(blocks * BLOCKLEN == out_bytes.size());
169 : :
170 : : uint32_t x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
171 : : uint32_t j4, j5, j6, j7, j8, j9, j10, j11, j12, j13, j14, j15;
172 : :
173 [ + - ]: 9788 : if (!blocks) return;
174 : :
175 : 9788 : j4 = input[0];
176 : 9788 : j5 = input[1];
177 : 9788 : j6 = input[2];
178 : 9788 : j7 = input[3];
179 : 9788 : j8 = input[4];
180 : 9788 : j9 = input[5];
181 : 9788 : j10 = input[6];
182 : 9788 : j11 = input[7];
183 : 9788 : j12 = input[8];
184 : 9788 : j13 = input[9];
185 : 9788 : j14 = input[10];
186 : 9788 : j15 = input[11];
187 : :
188 : 1494028 : for (;;) {
189 : 1494028 : x0 = 0x61707865;
190 : 1494028 : x1 = 0x3320646e;
191 : 1494028 : x2 = 0x79622d32;
192 : 1494028 : x3 = 0x6b206574;
193 : 1494028 : x4 = j4;
194 : 1494028 : x5 = j5;
195 : 1494028 : x6 = j6;
196 : 1494028 : x7 = j7;
197 : 1494028 : x8 = j8;
198 : 1494028 : x9 = j9;
199 : 1494028 : x10 = j10;
200 : 1494028 : x11 = j11;
201 : 1494028 : x12 = j12;
202 : 1494028 : x13 = j13;
203 : 1494028 : x14 = j14;
204 : 1494028 : x15 = j15;
205 : :
206 : : // The 20 inner ChaCha20 rounds are unrolled here for performance.
207 : 1494028 : REPEAT10(
208 : : QUARTERROUND( x0, x4, x8,x12);
209 : : QUARTERROUND( x1, x5, x9,x13);
210 : : QUARTERROUND( x2, x6,x10,x14);
211 : : QUARTERROUND( x3, x7,x11,x15);
212 : : QUARTERROUND( x0, x5,x10,x15);
213 : : QUARTERROUND( x1, x6,x11,x12);
214 : : QUARTERROUND( x2, x7, x8,x13);
215 : : QUARTERROUND( x3, x4, x9,x14);
216 : : );
217 : :
218 : 1494028 : x0 += 0x61707865;
219 : 1494028 : x1 += 0x3320646e;
220 : 1494028 : x2 += 0x79622d32;
221 : 1494028 : x3 += 0x6b206574;
222 : 1494028 : x4 += j4;
223 : 1494028 : x5 += j5;
224 : 1494028 : x6 += j6;
225 : 1494028 : x7 += j7;
226 : 1494028 : x8 += j8;
227 : 1494028 : x9 += j9;
228 : 1494028 : x10 += j10;
229 : 1494028 : x11 += j11;
230 : 1494028 : x12 += j12;
231 : 1494028 : x13 += j13;
232 : 1494028 : x14 += j14;
233 : 1494028 : x15 += j15;
234 : :
235 [ + - ]: 1494028 : x0 ^= ReadLE32(m + 0);
236 [ + - ]: 1494028 : x1 ^= ReadLE32(m + 4);
237 [ + - ]: 1494028 : x2 ^= ReadLE32(m + 8);
238 [ + - ]: 1494028 : x3 ^= ReadLE32(m + 12);
239 [ + - ]: 1494028 : x4 ^= ReadLE32(m + 16);
240 [ + - ]: 1494028 : x5 ^= ReadLE32(m + 20);
241 [ + - ]: 1494028 : x6 ^= ReadLE32(m + 24);
242 [ + - ]: 1494028 : x7 ^= ReadLE32(m + 28);
243 [ + - ]: 1494028 : x8 ^= ReadLE32(m + 32);
244 [ + - ]: 1494028 : x9 ^= ReadLE32(m + 36);
245 [ + - ]: 1494028 : x10 ^= ReadLE32(m + 40);
246 [ + - ]: 1494028 : x11 ^= ReadLE32(m + 44);
247 [ + - ]: 1494028 : x12 ^= ReadLE32(m + 48);
248 [ + - ]: 1494028 : x13 ^= ReadLE32(m + 52);
249 [ + - ]: 1494028 : x14 ^= ReadLE32(m + 56);
250 [ + - ]: 1494028 : x15 ^= ReadLE32(m + 60);
251 : :
252 : 1494028 : ++j12;
253 [ + + ]: 1494028 : if (!j12) ++j13;
254 : :
255 : 1494028 : WriteLE32(c + 0, x0);
256 : 1494028 : WriteLE32(c + 4, x1);
257 : 1494028 : WriteLE32(c + 8, x2);
258 : 1494028 : WriteLE32(c + 12, x3);
259 : 1494028 : WriteLE32(c + 16, x4);
260 : 1494028 : WriteLE32(c + 20, x5);
261 : 1494028 : WriteLE32(c + 24, x6);
262 : 1494028 : WriteLE32(c + 28, x7);
263 : 1494028 : WriteLE32(c + 32, x8);
264 : 1494028 : WriteLE32(c + 36, x9);
265 : 1494028 : WriteLE32(c + 40, x10);
266 : 1494028 : WriteLE32(c + 44, x11);
267 : 1494028 : WriteLE32(c + 48, x12);
268 : 1494028 : WriteLE32(c + 52, x13);
269 : 1494028 : WriteLE32(c + 56, x14);
270 : 1494028 : WriteLE32(c + 60, x15);
271 : :
272 [ + + ]: 1494028 : if (blocks == 1) {
273 : 9788 : input[8] = j12;
274 : 9788 : input[9] = j13;
275 : 9788 : return;
276 : : }
277 : 1484240 : blocks -= 1;
278 : 1484240 : c += BLOCKLEN;
279 : 1484240 : m += BLOCKLEN;
280 : : }
281 : 9788 : }
282 : :
283 : 12970774 : void ChaCha20::Keystream(Span<std::byte> out) noexcept
284 : : {
285 [ + + ]: 12970774 : if (out.empty()) return;
286 [ + + ]: 12954495 : if (m_bufleft) {
287 [ + - ]: 9316234 : unsigned reuse = std::min<size_t>(m_bufleft, out.size());
288 [ + - ]: 9316234 : std::copy(m_buffer.end() - m_bufleft, m_buffer.end() - m_bufleft + reuse, out.begin());
289 : 9316234 : m_bufleft -= reuse;
290 : 9316234 : out = out.subspan(reuse);
291 : 9316234 : }
292 [ + + ]: 12954495 : if (out.size() >= m_aligned.BLOCKLEN) {
293 : 19661 : size_t blocks = out.size() / m_aligned.BLOCKLEN;
294 : 19661 : m_aligned.Keystream(out.first(blocks * m_aligned.BLOCKLEN));
295 : 19661 : out = out.subspan(blocks * m_aligned.BLOCKLEN);
296 : 19661 : }
297 [ + + ]: 12954495 : if (!out.empty()) {
298 [ + - ]: 5025067 : m_aligned.Keystream(m_buffer);
299 [ + - ]: 5025067 : std::copy(m_buffer.begin(), m_buffer.begin() + out.size(), out.begin());
300 : 5025067 : m_bufleft = m_aligned.BLOCKLEN - out.size();
301 : 5025067 : }
302 : 12970774 : }
303 : :
304 : 74557 : void ChaCha20::Crypt(Span<const std::byte> input, Span<std::byte> output) noexcept
305 : : {
306 [ + - ]: 74557 : assert(input.size() == output.size());
307 : :
308 [ + + ]: 74557 : if (!input.size()) return;
309 [ + + ]: 51031 : if (m_bufleft) {
310 [ + - ]: 29673 : unsigned reuse = std::min<size_t>(m_bufleft, input.size());
311 [ + + ]: 549130 : for (unsigned i = 0; i < reuse; i++) {
312 : 519457 : output[i] = input[i] ^ m_buffer[m_aligned.BLOCKLEN - m_bufleft + i];
313 : 519457 : }
314 : 29673 : m_bufleft -= reuse;
315 : 29673 : output = output.subspan(reuse);
316 : 29673 : input = input.subspan(reuse);
317 : 29673 : }
318 [ + + ]: 51031 : if (input.size() >= m_aligned.BLOCKLEN) {
319 : 9788 : size_t blocks = input.size() / m_aligned.BLOCKLEN;
320 : 9788 : m_aligned.Crypt(input.first(blocks * m_aligned.BLOCKLEN), output.first(blocks * m_aligned.BLOCKLEN));
321 : 9788 : output = output.subspan(blocks * m_aligned.BLOCKLEN);
322 : 9788 : input = input.subspan(blocks * m_aligned.BLOCKLEN);
323 : 9788 : }
324 [ + + ]: 51031 : if (!input.empty()) {
325 [ + - ]: 30003 : m_aligned.Keystream(m_buffer);
326 [ + + ]: 381126 : for (unsigned i = 0; i < input.size(); i++) {
327 : 351123 : output[i] = input[i] ^ m_buffer[i];
328 : 351123 : }
329 : 30003 : m_bufleft = m_aligned.BLOCKLEN - input.size();
330 : 30003 : }
331 : 74557 : }
332 : :
333 : 3077087 : ChaCha20::~ChaCha20()
334 : : {
335 [ + - ]: 3077087 : memory_cleanse(m_buffer.data(), m_buffer.size());
336 : 3077087 : }
337 : :
338 : 2932646 : void ChaCha20::SetKey(Span<const std::byte> key) noexcept
339 : : {
340 : 2932646 : m_aligned.SetKey(key);
341 : 2932646 : m_bufleft = 0;
342 [ + - ]: 2932646 : memory_cleanse(m_buffer.data(), m_buffer.size());
343 : 2932646 : }
344 : :
345 : 1710 : FSChaCha20::FSChaCha20(Span<const std::byte> key, uint32_t rekey_interval) noexcept :
346 : 1710 : m_chacha20(key), m_rekey_interval(rekey_interval)
347 : : {
348 [ + - ]: 1710 : assert(key.size() == KEYLEN);
349 : 1710 : }
350 : :
351 : 20555 : void FSChaCha20::Crypt(Span<const std::byte> input, Span<std::byte> output) noexcept
352 : : {
353 [ + - ]: 20555 : assert(input.size() == output.size());
354 : :
355 : : // Invoke internal stream cipher for actual encryption/decryption.
356 : 20555 : m_chacha20.Crypt(input, output);
357 : :
358 : : // Rekey after m_rekey_interval encryptions/decryptions.
359 [ + + ]: 20555 : if (++m_chunk_counter == m_rekey_interval) {
360 : : // Get new key from the stream cipher.
361 : : std::byte new_key[KEYLEN];
362 : 2424 : m_chacha20.Keystream(new_key);
363 : : // Update its key.
364 : 2424 : m_chacha20.SetKey(new_key);
365 : : // Wipe the key (a copy remains inside m_chacha20, where it'll be wiped on the next rekey
366 : : // or on destruction).
367 [ + - ]: 2424 : memory_cleanse(new_key, sizeof(new_key));
368 : : // Set the nonce for the new section of output.
369 [ + - ]: 2424 : m_chacha20.Seek({0, ++m_rekey_counter}, 0);
370 : : // Reset the chunk counter.
371 : 2424 : m_chunk_counter = 0;
372 : 2424 : }
373 : 20555 : }
|
