Line data Source code
1 : /* blake2.c - BLAKE2b and BLAKE2s hash functions (RFC 7693)
2 : * Copyright (C) 2017 Jussi Kivilinna <jussi.kivilinna@iki.fi>
3 : *
4 : * This file is part of Libgcrypt.
5 : *
6 : * Libgcrypt is free software; you can redistribute it and/or modify
7 : * it under the terms of the GNU Lesser general Public License as
8 : * published by the Free Software Foundation; either version 2.1 of
9 : * the License, or (at your option) any later version.
10 : *
11 : * Libgcrypt is distributed in the hope that it will be useful,
12 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : * GNU Lesser General Public License for more details.
15 : *
16 : * You should have received a copy of the GNU Lesser General Public
17 : * License along with this program; if not, see <http://www.gnu.org/licenses/>.
18 : */
19 :
20 : /* The code is based on public-domain/CC0 BLAKE2 reference implementation
21 : * by Samual Neves, at https://github.com/BLAKE2/BLAKE2/tree/master/ref
22 : * Copyright 2012, Samuel Neves <sneves@dei.uc.pt>
23 : */
24 :
25 : #include <config.h>
26 : #include <string.h>
27 : #include "g10lib.h"
28 : #include "bithelp.h"
29 : #include "bufhelp.h"
30 : #include "cipher.h"
31 : #include "hash-common.h"
32 :
33 : #define BLAKE2B_BLOCKBYTES 128
34 : #define BLAKE2B_OUTBYTES 64
35 : #define BLAKE2B_KEYBYTES 64
36 :
37 : #define BLAKE2S_BLOCKBYTES 64
38 : #define BLAKE2S_OUTBYTES 32
39 : #define BLAKE2S_KEYBYTES 32
40 :
41 : typedef struct
42 : {
43 : u64 h[8];
44 : u64 t[2];
45 : u64 f[2];
46 : } BLAKE2B_STATE;
47 :
48 : struct blake2b_param_s
49 : {
50 : byte digest_length;
51 : byte key_length;
52 : byte fanout;
53 : byte depth;
54 : byte leaf_length[4];
55 : byte node_offset[4];
56 : byte xof_length[4];
57 : byte node_depth;
58 : byte inner_length;
59 : byte reserved[14];
60 : byte salt[16];
61 : byte personal[16];
62 : };
63 :
64 : typedef struct BLAKE2B_CONTEXT_S
65 : {
66 : BLAKE2B_STATE state;
67 : byte buf[BLAKE2B_BLOCKBYTES];
68 : size_t buflen;
69 : size_t outlen;
70 : } BLAKE2B_CONTEXT;
71 :
72 : typedef struct
73 : {
74 : u32 h[8];
75 : u32 t[2];
76 : u32 f[2];
77 : } BLAKE2S_STATE;
78 :
79 : struct blake2s_param_s
80 : {
81 : byte digest_length;
82 : byte key_length;
83 : byte fanout;
84 : byte depth;
85 : byte leaf_length[4];
86 : byte node_offset[4];
87 : byte xof_length[2];
88 : byte node_depth;
89 : byte inner_length;
90 : /* byte reserved[0]; */
91 : byte salt[8];
92 : byte personal[8];
93 : };
94 :
95 : typedef struct BLAKE2S_CONTEXT_S
96 : {
97 : BLAKE2S_STATE state;
98 : byte buf[BLAKE2S_BLOCKBYTES];
99 : size_t buflen;
100 : size_t outlen;
101 : } BLAKE2S_CONTEXT;
102 :
103 : typedef unsigned int (*blake2_transform_t)(void *S, const void *inblk,
104 : size_t nblks);
105 :
106 :
107 : static const u64 blake2b_IV[8] =
108 : {
109 : U64_C(0x6a09e667f3bcc908), U64_C(0xbb67ae8584caa73b),
110 : U64_C(0x3c6ef372fe94f82b), U64_C(0xa54ff53a5f1d36f1),
111 : U64_C(0x510e527fade682d1), U64_C(0x9b05688c2b3e6c1f),
112 : U64_C(0x1f83d9abfb41bd6b), U64_C(0x5be0cd19137e2179)
113 : };
114 :
115 : static const u32 blake2s_IV[8] =
116 : {
117 : 0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
118 : 0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
119 : };
120 :
121 : static byte zero_block[BLAKE2B_BLOCKBYTES] = { 0, };
122 :
123 :
124 8280498 : static void blake2_write(void *S, const void *inbuf, size_t inlen,
125 : byte *tmpbuf, size_t *tmpbuflen, size_t blkbytes,
126 : blake2_transform_t transform_fn)
127 : {
128 8280498 : const byte* in = inbuf;
129 8280498 : unsigned int burn = 0;
130 :
131 8280498 : if (inlen > 0)
132 : {
133 8272598 : size_t left = *tmpbuflen;
134 8272598 : size_t fill = blkbytes - left;
135 : size_t nblks;
136 :
137 8272598 : if (inlen > fill)
138 : {
139 346998 : if (fill > 0)
140 129198 : buf_cpy (tmpbuf + left, in, fill); /* Fill buffer */
141 346998 : left = 0;
142 :
143 346998 : burn = transform_fn (S, tmpbuf, 1); /* Increment counter + Compress */
144 :
145 346998 : in += fill;
146 346998 : inlen -= fill;
147 :
148 346998 : nblks = inlen / blkbytes - !(inlen % blkbytes);
149 346998 : if (nblks)
150 : {
151 78430 : burn = transform_fn(S, in, nblks);
152 78430 : in += blkbytes * nblks;
153 78430 : inlen -= blkbytes * nblks;
154 : }
155 : }
156 :
157 8272598 : gcry_assert (inlen > 0);
158 :
159 8272598 : buf_cpy (tmpbuf + left, in, inlen);
160 8272598 : *tmpbuflen = left + inlen;
161 : }
162 :
163 8280498 : if (burn)
164 148616 : _gcry_burn_stack (burn);
165 :
166 8280498 : return;
167 : }
168 :
169 :
170 59242 : static inline void blake2b_set_lastblock(BLAKE2B_STATE *S)
171 : {
172 59242 : S->f[0] = U64_C(0xffffffffffffffff);
173 59242 : }
174 :
175 59242 : static inline int blake2b_is_lastblock(const BLAKE2B_STATE *S)
176 : {
177 59242 : return S->f[0] != 0;
178 : }
179 :
180 445726 : static inline void blake2b_increment_counter(BLAKE2B_STATE *S, const int inc)
181 : {
182 445726 : S->t[0] += (u64)inc;
183 445726 : S->t[1] += (S->t[0] < (u64)inc) - (inc < 0);
184 445726 : }
185 :
186 148409856 : static inline u64 rotr64(u64 x, u64 n)
187 : {
188 148409856 : return ((x >> (n & 63)) | (x << ((64 - n) & 63)));
189 : }
190 :
191 233968 : static unsigned int blake2b_transform(void *vS, const void *inblks,
192 : size_t nblks)
193 : {
194 : static const byte blake2b_sigma[12][16] =
195 : {
196 : { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
197 : { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
198 : { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
199 : { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
200 : { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
201 : { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
202 : { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
203 : { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
204 : { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
205 : { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 },
206 : { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
207 : { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 }
208 : };
209 233968 : BLAKE2B_STATE *S = vS;
210 233968 : const byte* in = inblks;
211 : u64 m[16];
212 : u64 v[16];
213 :
214 854420 : while (nblks--)
215 : {
216 : /* Increment counter */
217 386484 : blake2b_increment_counter (S, BLAKE2B_BLOCKBYTES);
218 :
219 : /* Compress */
220 386484 : m[0] = buf_get_le64 (in + 0 * sizeof(m[0]));
221 386484 : m[1] = buf_get_le64 (in + 1 * sizeof(m[0]));
222 386484 : m[2] = buf_get_le64 (in + 2 * sizeof(m[0]));
223 386484 : m[3] = buf_get_le64 (in + 3 * sizeof(m[0]));
224 386484 : m[4] = buf_get_le64 (in + 4 * sizeof(m[0]));
225 386484 : m[5] = buf_get_le64 (in + 5 * sizeof(m[0]));
226 386484 : m[6] = buf_get_le64 (in + 6 * sizeof(m[0]));
227 386484 : m[7] = buf_get_le64 (in + 7 * sizeof(m[0]));
228 386484 : m[8] = buf_get_le64 (in + 8 * sizeof(m[0]));
229 386484 : m[9] = buf_get_le64 (in + 9 * sizeof(m[0]));
230 386484 : m[10] = buf_get_le64 (in + 10 * sizeof(m[0]));
231 386484 : m[11] = buf_get_le64 (in + 11 * sizeof(m[0]));
232 386484 : m[12] = buf_get_le64 (in + 12 * sizeof(m[0]));
233 386484 : m[13] = buf_get_le64 (in + 13 * sizeof(m[0]));
234 386484 : m[14] = buf_get_le64 (in + 14 * sizeof(m[0]));
235 386484 : m[15] = buf_get_le64 (in + 15 * sizeof(m[0]));
236 :
237 386484 : v[ 0] = S->h[0];
238 386484 : v[ 1] = S->h[1];
239 386484 : v[ 2] = S->h[2];
240 386484 : v[ 3] = S->h[3];
241 386484 : v[ 4] = S->h[4];
242 386484 : v[ 5] = S->h[5];
243 386484 : v[ 6] = S->h[6];
244 386484 : v[ 7] = S->h[7];
245 386484 : v[ 8] = blake2b_IV[0];
246 386484 : v[ 9] = blake2b_IV[1];
247 386484 : v[10] = blake2b_IV[2];
248 386484 : v[11] = blake2b_IV[3];
249 386484 : v[12] = blake2b_IV[4] ^ S->t[0];
250 386484 : v[13] = blake2b_IV[5] ^ S->t[1];
251 386484 : v[14] = blake2b_IV[6] ^ S->f[0];
252 386484 : v[15] = blake2b_IV[7] ^ S->f[1];
253 :
254 : #define G(r,i,a,b,c,d) \
255 : do { \
256 : a = a + b + m[blake2b_sigma[r][2*i+0]]; \
257 : d = rotr64(d ^ a, 32); \
258 : c = c + d; \
259 : b = rotr64(b ^ c, 24); \
260 : a = a + b + m[blake2b_sigma[r][2*i+1]]; \
261 : d = rotr64(d ^ a, 16); \
262 : c = c + d; \
263 : b = rotr64(b ^ c, 63); \
264 : } while(0)
265 :
266 : #define ROUND(r) \
267 : do { \
268 : G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
269 : G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
270 : G(r,2,v[ 2],v[ 6],v[10],v[14]); \
271 : G(r,3,v[ 3],v[ 7],v[11],v[15]); \
272 : G(r,4,v[ 0],v[ 5],v[10],v[15]); \
273 : G(r,5,v[ 1],v[ 6],v[11],v[12]); \
274 : G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
275 : G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
276 : } while(0)
277 :
278 386484 : ROUND(0);
279 386484 : ROUND(1);
280 386484 : ROUND(2);
281 386484 : ROUND(3);
282 386484 : ROUND(4);
283 386484 : ROUND(5);
284 386484 : ROUND(6);
285 386484 : ROUND(7);
286 386484 : ROUND(8);
287 386484 : ROUND(9);
288 386484 : ROUND(10);
289 386484 : ROUND(11);
290 :
291 : #undef G
292 : #undef ROUND
293 :
294 386484 : S->h[0] = S->h[0] ^ v[0] ^ v[0 + 8];
295 386484 : S->h[1] = S->h[1] ^ v[1] ^ v[1 + 8];
296 386484 : S->h[2] = S->h[2] ^ v[2] ^ v[2 + 8];
297 386484 : S->h[3] = S->h[3] ^ v[3] ^ v[3 + 8];
298 386484 : S->h[4] = S->h[4] ^ v[4] ^ v[4 + 8];
299 386484 : S->h[5] = S->h[5] ^ v[5] ^ v[5 + 8];
300 386484 : S->h[6] = S->h[6] ^ v[6] ^ v[6 + 8];
301 386484 : S->h[7] = S->h[7] ^ v[7] ^ v[7 + 8];
302 :
303 386484 : in += BLAKE2B_BLOCKBYTES;
304 : }
305 :
306 233968 : return sizeof(void *) * 4 + sizeof(u64) * 16 * 2;
307 : }
308 :
309 59242 : static void blake2b_final(void *ctx)
310 : {
311 59242 : BLAKE2B_CONTEXT *c = ctx;
312 59242 : BLAKE2B_STATE *S = &c->state;
313 : unsigned int burn;
314 : size_t i;
315 :
316 59242 : gcry_assert (sizeof(c->buf) >= c->outlen);
317 59242 : if (blake2b_is_lastblock(S))
318 0 : return;
319 :
320 59242 : if (c->buflen < BLAKE2B_BLOCKBYTES)
321 59150 : memset (c->buf + c->buflen, 0, BLAKE2B_BLOCKBYTES - c->buflen); /* Padding */
322 59242 : blake2b_set_lastblock (S);
323 59242 : blake2b_increment_counter (S, (int)c->buflen - BLAKE2B_BLOCKBYTES);
324 59242 : burn = blake2b_transform (S, c->buf, 1);
325 :
326 : /* Output full hash to buffer */
327 533178 : for (i = 0; i < 8; ++i)
328 473936 : buf_put_le64 (c->buf + sizeof(S->h[i]) * i, S->h[i]);
329 :
330 : /* Zero out extra buffer bytes. */
331 59242 : if (c->outlen < sizeof(c->buf))
332 59242 : memset (c->buf + c->outlen, 0, sizeof(c->buf) - c->outlen);
333 :
334 59242 : if (burn)
335 59242 : _gcry_burn_stack (burn);
336 : }
337 :
338 56592 : static byte *blake2b_read(void *ctx)
339 : {
340 56592 : BLAKE2B_CONTEXT *c = ctx;
341 56592 : return c->buf;
342 : }
343 :
344 4135828 : static void blake2b_write(void *ctx, const void *inbuf, size_t inlen)
345 : {
346 4135828 : BLAKE2B_CONTEXT *c = ctx;
347 4135828 : BLAKE2B_STATE *S = &c->state;
348 4135828 : blake2_write(S, inbuf, inlen, c->buf, &c->buflen, BLAKE2B_BLOCKBYTES,
349 : blake2b_transform);
350 4135828 : }
351 :
352 6792 : static inline void blake2b_init_param(BLAKE2B_STATE *S,
353 : const struct blake2b_param_s *P)
354 : {
355 6792 : const byte *p = (const byte *)P;
356 : size_t i;
357 :
358 : /* init xors IV with input parameter block */
359 :
360 : /* IV XOR ParamBlock */
361 61128 : for (i = 0; i < 8; ++i)
362 54336 : S->h[i] = blake2b_IV[i] ^ buf_get_le64(p + sizeof(S->h[i]) * i);
363 6792 : }
364 :
365 6792 : static inline gcry_err_code_t blake2b_init(BLAKE2B_CONTEXT *ctx,
366 : const byte *key, size_t keylen)
367 : {
368 6792 : struct blake2b_param_s P[1] = { { 0, } };
369 6792 : BLAKE2B_STATE *S = &ctx->state;
370 :
371 6792 : if (!ctx->outlen || ctx->outlen > BLAKE2B_OUTBYTES)
372 0 : return GPG_ERR_INV_ARG;
373 : if (sizeof(P[0]) != sizeof(u64) * 8)
374 : return GPG_ERR_INTERNAL;
375 6792 : if (keylen && (!key || keylen > BLAKE2B_KEYBYTES))
376 0 : return GPG_ERR_INV_KEYLEN;
377 :
378 6792 : P->digest_length = ctx->outlen;
379 6792 : P->key_length = keylen;
380 6792 : P->fanout = 1;
381 6792 : P->depth = 1;
382 :
383 6792 : blake2b_init_param (S, P);
384 6792 : wipememory (P, sizeof(P));
385 :
386 6792 : if (key)
387 : {
388 114 : blake2b_write (ctx, key, keylen);
389 114 : blake2b_write (ctx, zero_block, BLAKE2B_BLOCKBYTES - keylen);
390 : }
391 :
392 6792 : return 0;
393 : }
394 :
395 6792 : static gcry_err_code_t blake2b_init_ctx(void *ctx, unsigned int flags,
396 : const byte *key, size_t keylen,
397 : unsigned int dbits)
398 : {
399 6792 : BLAKE2B_CONTEXT *c = ctx;
400 :
401 : (void)flags;
402 :
403 6792 : memset (c, 0, sizeof (*c));
404 :
405 6792 : c->outlen = dbits / 8;
406 6792 : c->buflen = 0;
407 6792 : return blake2b_init(c, key, keylen);
408 : }
409 :
410 67768 : static inline void blake2s_set_lastblock(BLAKE2S_STATE *S)
411 : {
412 67768 : S->f[0] = 0xFFFFFFFFUL;
413 67768 : }
414 :
415 67768 : static inline int blake2s_is_lastblock(BLAKE2S_STATE *S)
416 : {
417 67768 : return S->f[0] != 0;
418 : }
419 :
420 744968 : static inline void blake2s_increment_counter(BLAKE2S_STATE *S, const int inc)
421 : {
422 744968 : S->t[0] += (u32)inc;
423 744968 : S->t[1] += (S->t[0] < (u32)inc) - (inc < 0);
424 744968 : }
425 :
426 318470 : static unsigned int blake2s_transform(void *vS, const void *inblks,
427 : size_t nblks)
428 : {
429 : static const byte blake2s_sigma[10][16] =
430 : {
431 : { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 },
432 : { 14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3 },
433 : { 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4 },
434 : { 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8 },
435 : { 9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13 },
436 : { 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9 },
437 : { 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11 },
438 : { 13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10 },
439 : { 6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5 },
440 : { 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13 , 0 },
441 : };
442 318470 : BLAKE2S_STATE *S = vS;
443 318470 : unsigned int burn = 0;
444 318470 : const byte* in = inblks;
445 : u32 m[16];
446 : u32 v[16];
447 :
448 1314140 : while (nblks--)
449 : {
450 : /* Increment counter */
451 677200 : blake2s_increment_counter (S, BLAKE2S_BLOCKBYTES);
452 :
453 : /* Compress */
454 677200 : m[0] = buf_get_le32 (in + 0 * sizeof(m[0]));
455 677200 : m[1] = buf_get_le32 (in + 1 * sizeof(m[0]));
456 677200 : m[2] = buf_get_le32 (in + 2 * sizeof(m[0]));
457 677200 : m[3] = buf_get_le32 (in + 3 * sizeof(m[0]));
458 677200 : m[4] = buf_get_le32 (in + 4 * sizeof(m[0]));
459 677200 : m[5] = buf_get_le32 (in + 5 * sizeof(m[0]));
460 677200 : m[6] = buf_get_le32 (in + 6 * sizeof(m[0]));
461 677200 : m[7] = buf_get_le32 (in + 7 * sizeof(m[0]));
462 677200 : m[8] = buf_get_le32 (in + 8 * sizeof(m[0]));
463 677200 : m[9] = buf_get_le32 (in + 9 * sizeof(m[0]));
464 677200 : m[10] = buf_get_le32 (in + 10 * sizeof(m[0]));
465 677200 : m[11] = buf_get_le32 (in + 11 * sizeof(m[0]));
466 677200 : m[12] = buf_get_le32 (in + 12 * sizeof(m[0]));
467 677200 : m[13] = buf_get_le32 (in + 13 * sizeof(m[0]));
468 677200 : m[14] = buf_get_le32 (in + 14 * sizeof(m[0]));
469 677200 : m[15] = buf_get_le32 (in + 15 * sizeof(m[0]));
470 :
471 677200 : v[ 0] = S->h[0];
472 677200 : v[ 1] = S->h[1];
473 677200 : v[ 2] = S->h[2];
474 677200 : v[ 3] = S->h[3];
475 677200 : v[ 4] = S->h[4];
476 677200 : v[ 5] = S->h[5];
477 677200 : v[ 6] = S->h[6];
478 677200 : v[ 7] = S->h[7];
479 677200 : v[ 8] = blake2s_IV[0];
480 677200 : v[ 9] = blake2s_IV[1];
481 677200 : v[10] = blake2s_IV[2];
482 677200 : v[11] = blake2s_IV[3];
483 677200 : v[12] = S->t[0] ^ blake2s_IV[4];
484 677200 : v[13] = S->t[1] ^ blake2s_IV[5];
485 677200 : v[14] = S->f[0] ^ blake2s_IV[6];
486 677200 : v[15] = S->f[1] ^ blake2s_IV[7];
487 :
488 : #define G(r,i,a,b,c,d) \
489 : do { \
490 : a = a + b + m[blake2s_sigma[r][2*i+0]]; \
491 : d = ror(d ^ a, 16); \
492 : c = c + d; \
493 : b = ror(b ^ c, 12); \
494 : a = a + b + m[blake2s_sigma[r][2*i+1]]; \
495 : d = ror(d ^ a, 8); \
496 : c = c + d; \
497 : b = ror(b ^ c, 7); \
498 : } while(0)
499 :
500 : #define ROUND(r) \
501 : do { \
502 : G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
503 : G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
504 : G(r,2,v[ 2],v[ 6],v[10],v[14]); \
505 : G(r,3,v[ 3],v[ 7],v[11],v[15]); \
506 : G(r,4,v[ 0],v[ 5],v[10],v[15]); \
507 : G(r,5,v[ 1],v[ 6],v[11],v[12]); \
508 : G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
509 : G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
510 : } while(0)
511 :
512 677200 : ROUND(0);
513 677200 : ROUND(1);
514 677200 : ROUND(2);
515 677200 : ROUND(3);
516 677200 : ROUND(4);
517 677200 : ROUND(5);
518 677200 : ROUND(6);
519 677200 : ROUND(7);
520 677200 : ROUND(8);
521 677200 : ROUND(9);
522 :
523 : #undef G
524 : #undef ROUND
525 :
526 677200 : S->h[0] = S->h[0] ^ v[0] ^ v[0 + 8];
527 677200 : S->h[1] = S->h[1] ^ v[1] ^ v[1 + 8];
528 677200 : S->h[2] = S->h[2] ^ v[2] ^ v[2 + 8];
529 677200 : S->h[3] = S->h[3] ^ v[3] ^ v[3 + 8];
530 677200 : S->h[4] = S->h[4] ^ v[4] ^ v[4 + 8];
531 677200 : S->h[5] = S->h[5] ^ v[5] ^ v[5 + 8];
532 677200 : S->h[6] = S->h[6] ^ v[6] ^ v[6 + 8];
533 677200 : S->h[7] = S->h[7] ^ v[7] ^ v[7 + 8];
534 :
535 677200 : in += BLAKE2S_BLOCKBYTES;
536 : }
537 :
538 318470 : return burn;
539 : }
540 :
541 67768 : static void blake2s_final(void *ctx)
542 : {
543 67768 : BLAKE2S_CONTEXT *c = ctx;
544 67768 : BLAKE2S_STATE *S = &c->state;
545 : unsigned int burn;
546 : size_t i;
547 :
548 67768 : gcry_assert (sizeof(c->buf) >= c->outlen);
549 67768 : if (blake2s_is_lastblock(S))
550 0 : return;
551 :
552 67768 : if (c->buflen < BLAKE2S_BLOCKBYTES)
553 67634 : memset (c->buf + c->buflen, 0, BLAKE2S_BLOCKBYTES - c->buflen); /* Padding */
554 67768 : blake2s_set_lastblock (S);
555 67768 : blake2s_increment_counter (S, (int)c->buflen - BLAKE2S_BLOCKBYTES);
556 67768 : burn = blake2s_transform (S, c->buf, 1);
557 :
558 : /* Output full hash to buffer */
559 609912 : for (i = 0; i < 8; ++i)
560 542144 : buf_put_le32 (c->buf + sizeof(S->h[i]) * i, S->h[i]);
561 :
562 : /* Zero out extra buffer bytes. */
563 67768 : if (c->outlen < sizeof(c->buf))
564 67768 : memset (c->buf + c->outlen, 0, sizeof(c->buf) - c->outlen);
565 :
566 67768 : if (burn)
567 0 : _gcry_burn_stack (burn);
568 : }
569 :
570 65118 : static byte *blake2s_read(void *ctx)
571 : {
572 65118 : BLAKE2S_CONTEXT *c = ctx;
573 65118 : return c->buf;
574 : }
575 :
576 4144670 : static void blake2s_write(void *ctx, const void *inbuf, size_t inlen)
577 : {
578 4144670 : BLAKE2S_CONTEXT *c = ctx;
579 4144670 : BLAKE2S_STATE *S = &c->state;
580 4144670 : blake2_write(S, inbuf, inlen, c->buf, &c->buflen, BLAKE2S_BLOCKBYTES,
581 : blake2s_transform);
582 4144670 : }
583 :
584 7252 : static inline void blake2s_init_param(BLAKE2S_STATE *S,
585 : const struct blake2s_param_s *P)
586 : {
587 7252 : const byte *p = (const byte *)P;
588 : size_t i;
589 :
590 : /* init2 xors IV with input parameter block */
591 :
592 : /* IV XOR ParamBlock */
593 65268 : for (i = 0; i < 8; ++i)
594 58016 : S->h[i] ^= blake2s_IV[i] ^ buf_get_le32(&p[i * 4]);
595 7252 : }
596 :
597 7252 : static inline gcry_err_code_t blake2s_init(BLAKE2S_CONTEXT *ctx,
598 : const byte *key, size_t keylen)
599 : {
600 7252 : struct blake2s_param_s P[1] = { { 0, } };
601 7252 : BLAKE2S_STATE *S = &ctx->state;
602 :
603 7252 : if (!ctx->outlen || ctx->outlen > BLAKE2S_OUTBYTES)
604 0 : return GPG_ERR_INV_ARG;
605 : if (sizeof(P[0]) != sizeof(u32) * 8)
606 : return GPG_ERR_INTERNAL;
607 7252 : if (keylen && (!key || keylen > BLAKE2S_KEYBYTES))
608 0 : return GPG_ERR_INV_KEYLEN;
609 :
610 7252 : P->digest_length = ctx->outlen;
611 7252 : P->key_length = keylen;
612 7252 : P->fanout = 1;
613 7252 : P->depth = 1;
614 :
615 7252 : blake2s_init_param (S, P);
616 7252 : wipememory (P, sizeof(P));
617 :
618 7252 : if (key)
619 : {
620 128 : blake2s_write (ctx, key, keylen);
621 128 : blake2s_write (ctx, zero_block, BLAKE2S_BLOCKBYTES - keylen);
622 : }
623 :
624 7252 : return 0;
625 : }
626 :
627 7252 : static gcry_err_code_t blake2s_init_ctx(void *ctx, unsigned int flags,
628 : const byte *key, size_t keylen,
629 : unsigned int dbits)
630 : {
631 7252 : BLAKE2S_CONTEXT *c = ctx;
632 :
633 : (void)flags;
634 :
635 7252 : memset (c, 0, sizeof (*c));
636 :
637 7252 : c->outlen = dbits / 8;
638 7252 : c->buflen = 0;
639 7252 : return blake2s_init(c, key, keylen);
640 : }
641 :
642 : /* Selftests from "RFC 7693, Appendix E. BLAKE2b and BLAKE2s Self-Test
643 : * Module C Source". */
644 384 : static void selftest_seq(byte *out, size_t len, u32 seed)
645 : {
646 : size_t i;
647 : u32 t, a, b;
648 :
649 384 : a = 0xDEAD4BAD * seed;
650 384 : b = 1;
651 :
652 53824 : for (i = 0; i < len; i++)
653 : {
654 53440 : t = a + b;
655 53440 : a = b;
656 53440 : b = t;
657 53440 : out[i] = (t >> 24) & 0xFF;
658 : }
659 384 : }
660 :
661 : static gpg_err_code_t
662 4 : selftests_blake2b (int algo, int extended, selftest_report_func_t report)
663 : {
664 : static const byte blake2b_res[32] =
665 : {
666 : 0xC2, 0x3A, 0x78, 0x00, 0xD9, 0x81, 0x23, 0xBD,
667 : 0x10, 0xF5, 0x06, 0xC6, 0x1E, 0x29, 0xDA, 0x56,
668 : 0x03, 0xD7, 0x63, 0xB8, 0xBB, 0xAD, 0x2E, 0x73,
669 : 0x7F, 0x5E, 0x76, 0x5A, 0x7B, 0xCC, 0xD4, 0x75
670 : };
671 : static const size_t b2b_md_len[4] = { 20, 32, 48, 64 };
672 : static const size_t b2b_in_len[6] = { 0, 3, 128, 129, 255, 1024 };
673 : size_t i, j, outlen, inlen;
674 : byte in[1024], key[64];
675 : BLAKE2B_CONTEXT ctx;
676 : BLAKE2B_CONTEXT ctx2;
677 : const char *what;
678 : const char *errtxt;
679 :
680 : (void)extended;
681 :
682 4 : what = "rfc7693 BLAKE2b selftest";
683 :
684 : /* 256-bit hash for testing */
685 4 : if (blake2b_init_ctx(&ctx, 0, NULL, 0, 32 * 8))
686 : {
687 0 : errtxt = "init failed";
688 0 : goto failed;
689 : }
690 :
691 20 : for (i = 0; i < 4; i++)
692 : {
693 16 : outlen = b2b_md_len[i];
694 112 : for (j = 0; j < 6; j++)
695 : {
696 96 : inlen = b2b_in_len[j];
697 :
698 96 : selftest_seq(in, inlen, inlen); /* unkeyed hash */
699 96 : blake2b_init_ctx(&ctx2, 0, NULL, 0, outlen * 8);
700 96 : blake2b_write(&ctx2, in, inlen);
701 96 : blake2b_final(&ctx2);
702 96 : blake2b_write(&ctx, ctx2.buf, outlen); /* hash the hash */
703 :
704 96 : selftest_seq(key, outlen, outlen); /* keyed hash */
705 96 : blake2b_init_ctx(&ctx2, 0, key, outlen, outlen * 8);
706 96 : blake2b_write(&ctx2, in, inlen);
707 96 : blake2b_final(&ctx2);
708 96 : blake2b_write(&ctx, ctx2.buf, outlen); /* hash the hash */
709 : }
710 : }
711 :
712 : /* compute and compare the hash of hashes */
713 4 : blake2b_final(&ctx);
714 132 : for (i = 0; i < 32; i++)
715 : {
716 128 : if (ctx.buf[i] != blake2b_res[i])
717 : {
718 0 : errtxt = "digest mismatch";
719 0 : goto failed;
720 : }
721 : }
722 :
723 4 : return 0;
724 :
725 : failed:
726 0 : if (report)
727 0 : report ("digest", algo, what, errtxt);
728 0 : return GPG_ERR_SELFTEST_FAILED;
729 : }
730 :
731 : static gpg_err_code_t
732 4 : selftests_blake2s (int algo, int extended, selftest_report_func_t report)
733 : {
734 : static const byte blake2s_res[32] =
735 : {
736 : 0x6A, 0x41, 0x1F, 0x08, 0xCE, 0x25, 0xAD, 0xCD,
737 : 0xFB, 0x02, 0xAB, 0xA6, 0x41, 0x45, 0x1C, 0xEC,
738 : 0x53, 0xC5, 0x98, 0xB2, 0x4F, 0x4F, 0xC7, 0x87,
739 : 0xFB, 0xDC, 0x88, 0x79, 0x7F, 0x4C, 0x1D, 0xFE
740 : };
741 : static const size_t b2s_md_len[4] = { 16, 20, 28, 32 };
742 : static const size_t b2s_in_len[6] = { 0, 3, 64, 65, 255, 1024 };
743 : size_t i, j, outlen, inlen;
744 : byte in[1024], key[32];
745 : BLAKE2S_CONTEXT ctx;
746 : BLAKE2S_CONTEXT ctx2;
747 : const char *what;
748 : const char *errtxt;
749 :
750 : (void)extended;
751 :
752 4 : what = "rfc7693 BLAKE2s selftest";
753 :
754 : /* 256-bit hash for testing */
755 4 : if (blake2s_init_ctx(&ctx, 0, NULL, 0, 32 * 8))
756 : {
757 0 : errtxt = "init failed";
758 0 : goto failed;
759 : }
760 :
761 20 : for (i = 0; i < 4; i++)
762 : {
763 16 : outlen = b2s_md_len[i];
764 112 : for (j = 0; j < 6; j++)
765 : {
766 96 : inlen = b2s_in_len[j];
767 :
768 96 : selftest_seq(in, inlen, inlen); /* unkeyed hash */
769 96 : blake2s_init_ctx(&ctx2, 0, NULL, 0, outlen * 8);
770 96 : blake2s_write(&ctx2, in, inlen);
771 96 : blake2s_final(&ctx2);
772 96 : blake2s_write(&ctx, ctx2.buf, outlen); /* hash the hash */
773 :
774 96 : selftest_seq(key, outlen, outlen); /* keyed hash */
775 96 : blake2s_init_ctx(&ctx2, 0, key, outlen, outlen * 8);
776 96 : blake2s_write(&ctx2, in, inlen);
777 96 : blake2s_final(&ctx2);
778 96 : blake2s_write(&ctx, ctx2.buf, outlen); /* hash the hash */
779 : }
780 : }
781 :
782 : /* compute and compare the hash of hashes */
783 4 : blake2s_final(&ctx);
784 132 : for (i = 0; i < 32; i++)
785 : {
786 128 : if (ctx.buf[i] != blake2s_res[i])
787 : {
788 0 : errtxt = "digest mismatch";
789 0 : goto failed;
790 : }
791 : }
792 :
793 4 : return 0;
794 :
795 : failed:
796 0 : if (report)
797 0 : report ("digest", algo, what, errtxt);
798 0 : return GPG_ERR_SELFTEST_FAILED;
799 : }
800 :
801 :
802 50 : gcry_err_code_t _gcry_blake2_init_with_key(void *ctx, unsigned int flags,
803 : const unsigned char *key,
804 : size_t keylen, int algo)
805 : {
806 : gcry_err_code_t rc;
807 50 : switch (algo)
808 : {
809 : case GCRY_MD_BLAKE2B_512:
810 6 : rc = blake2b_init_ctx (ctx, flags, key, keylen, 512);
811 6 : break;
812 : case GCRY_MD_BLAKE2B_384:
813 4 : rc = blake2b_init_ctx (ctx, flags, key, keylen, 384);
814 4 : break;
815 : case GCRY_MD_BLAKE2B_256:
816 4 : rc = blake2b_init_ctx (ctx, flags, key, keylen, 256);
817 4 : break;
818 : case GCRY_MD_BLAKE2B_160:
819 4 : rc = blake2b_init_ctx (ctx, flags, key, keylen, 160);
820 4 : break;
821 : case GCRY_MD_BLAKE2S_256:
822 8 : rc = blake2s_init_ctx (ctx, flags, key, keylen, 256);
823 8 : break;
824 : case GCRY_MD_BLAKE2S_224:
825 8 : rc = blake2s_init_ctx (ctx, flags, key, keylen, 224);
826 8 : break;
827 : case GCRY_MD_BLAKE2S_160:
828 8 : rc = blake2s_init_ctx (ctx, flags, key, keylen, 160);
829 8 : break;
830 : case GCRY_MD_BLAKE2S_128:
831 8 : rc = blake2s_init_ctx (ctx, flags, key, keylen, 128);
832 8 : break;
833 : default:
834 0 : rc = GPG_ERR_DIGEST_ALGO;
835 0 : break;
836 : }
837 :
838 50 : return rc;
839 : }
840 :
841 :
842 : #define DEFINE_BLAKE2_VARIANT(bs, BS, dbits, oid_branch) \
843 : static void blake2##bs##_##dbits##_init(void *ctx, unsigned int flags) \
844 : { \
845 : int err = blake2##bs##_init_ctx (ctx, flags, NULL, 0, dbits); \
846 : gcry_assert (err == 0); \
847 : } \
848 : static byte blake2##bs##_##dbits##_asn[] = { 0x30 }; \
849 : static gcry_md_oid_spec_t oid_spec_blake2##bs##_##dbits[] = \
850 : { \
851 : { " 1.3.6.1.4.1.1722.12.2." oid_branch }, \
852 : { NULL } \
853 : }; \
854 : gcry_md_spec_t _gcry_digest_spec_blake2##bs##_##dbits = \
855 : { \
856 : GCRY_MD_BLAKE2##BS##_##dbits, {0, 0}, \
857 : "BLAKE2" #BS "_" #dbits, blake2##bs##_##dbits##_asn, \
858 : DIM (blake2##bs##_##dbits##_asn), oid_spec_blake2##bs##_##dbits, \
859 : dbits / 8, blake2##bs##_##dbits##_init, blake2##bs##_write, \
860 : blake2##bs##_final, blake2##bs##_read, NULL, \
861 : sizeof (BLAKE2##BS##_CONTEXT), selftests_blake2##bs \
862 : };
863 :
864 2792 : DEFINE_BLAKE2_VARIANT(b, B, 512, "1.16")
865 1262 : DEFINE_BLAKE2_VARIANT(b, B, 384, "1.12")
866 1262 : DEFINE_BLAKE2_VARIANT(b, B, 256, "1.8")
867 1262 : DEFINE_BLAKE2_VARIANT(b, B, 160, "1.5")
868 :
869 2794 : DEFINE_BLAKE2_VARIANT(s, S, 256, "2.8")
870 1482 : DEFINE_BLAKE2_VARIANT(s, S, 224, "2.7")
871 1482 : DEFINE_BLAKE2_VARIANT(s, S, 160, "2.5")
872 1266 : DEFINE_BLAKE2_VARIANT(s, S, 128, "2.4")
|
