tests/basic: add CTR mode carry overflow test vectors
[libgcrypt.git] / cipher / blake2.c
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 /* USE_AVX indicates whether to compile with Intel AVX code. */
34 #undef USE_AVX
35 #if defined(__x86_64__) && defined(HAVE_GCC_INLINE_ASM_AVX) && \
36     (defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS) || \
37      defined(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS))
38 # define USE_AVX 1
39 #endif
40
41 /* USE_AVX2 indicates whether to compile with Intel AVX2 code. */
42 #undef USE_AVX2
43 #if defined(__x86_64__) && defined(HAVE_GCC_INLINE_ASM_AVX2) && \
44     (defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS) || \
45      defined(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS))
46 # define USE_AVX2 1
47 #endif
48
49 /* AMD64 assembly implementations use SystemV ABI, ABI conversion and additional
50  * stack to store XMM6-XMM15 needed on Win64. */
51 #undef ASM_FUNC_ABI
52 #undef ASM_EXTRA_STACK
53 #if defined(USE_AVX2) && defined(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS)
54 # define ASM_FUNC_ABI __attribute__((sysv_abi))
55 # define ASM_EXTRA_STACK (10 * 16)
56 #else
57 # define ASM_FUNC_ABI
58 # define ASM_EXTRA_STACK 0
59 #endif
60
61 #define BLAKE2B_BLOCKBYTES 128
62 #define BLAKE2B_OUTBYTES 64
63 #define BLAKE2B_KEYBYTES 64
64
65 #define BLAKE2S_BLOCKBYTES 64
66 #define BLAKE2S_OUTBYTES 32
67 #define BLAKE2S_KEYBYTES 32
68
69 typedef struct
70 {
71   u64 h[8];
72   u64 t[2];
73   u64 f[2];
74 } BLAKE2B_STATE;
75
76 struct blake2b_param_s
77 {
78   byte digest_length;
79   byte key_length;
80   byte fanout;
81   byte depth;
82   byte leaf_length[4];
83   byte node_offset[4];
84   byte xof_length[4];
85   byte node_depth;
86   byte inner_length;
87   byte reserved[14];
88   byte salt[16];
89   byte personal[16];
90 };
91
92 typedef struct BLAKE2B_CONTEXT_S
93 {
94   BLAKE2B_STATE state;
95   byte buf[BLAKE2B_BLOCKBYTES];
96   size_t buflen;
97   size_t outlen;
98 #ifdef USE_AVX2
99   unsigned int use_avx2:1;
100 #endif
101 } BLAKE2B_CONTEXT;
102
103 typedef struct
104 {
105   u32 h[8];
106   u32 t[2];
107   u32 f[2];
108 } BLAKE2S_STATE;
109
110 struct blake2s_param_s
111 {
112   byte digest_length;
113   byte key_length;
114   byte fanout;
115   byte depth;
116   byte leaf_length[4];
117   byte node_offset[4];
118   byte xof_length[2];
119   byte node_depth;
120   byte inner_length;
121   /* byte reserved[0]; */
122   byte salt[8];
123   byte personal[8];
124 };
125
126 typedef struct BLAKE2S_CONTEXT_S
127 {
128   BLAKE2S_STATE state;
129   byte buf[BLAKE2S_BLOCKBYTES];
130   size_t buflen;
131   size_t outlen;
132 #ifdef USE_AVX
133   unsigned int use_avx:1;
134 #endif
135 } BLAKE2S_CONTEXT;
136
137 typedef unsigned int (*blake2_transform_t)(void *S, const void *inblk,
138                                            size_t nblks);
139
140
141 static const u64 blake2b_IV[8] =
142 {
143   U64_C(0x6a09e667f3bcc908), U64_C(0xbb67ae8584caa73b),
144   U64_C(0x3c6ef372fe94f82b), U64_C(0xa54ff53a5f1d36f1),
145   U64_C(0x510e527fade682d1), U64_C(0x9b05688c2b3e6c1f),
146   U64_C(0x1f83d9abfb41bd6b), U64_C(0x5be0cd19137e2179)
147 };
148
149 static const u32 blake2s_IV[8] =
150 {
151   0x6A09E667UL, 0xBB67AE85UL, 0x3C6EF372UL, 0xA54FF53AUL,
152   0x510E527FUL, 0x9B05688CUL, 0x1F83D9ABUL, 0x5BE0CD19UL
153 };
154
155 static byte zero_block[BLAKE2B_BLOCKBYTES] = { 0, };
156
157
158 static void blake2_write(void *S, const void *inbuf, size_t inlen,
159                          byte *tmpbuf, size_t *tmpbuflen, size_t blkbytes,
160                          blake2_transform_t transform_fn)
161 {
162   const byte* in = inbuf;
163   unsigned int burn = 0;
164
165   if (inlen > 0)
166     {
167       size_t left = *tmpbuflen;
168       size_t fill = blkbytes - left;
169       size_t nblks;
170
171       if (inlen > fill)
172         {
173           if (fill > 0)
174             buf_cpy (tmpbuf + left, in, fill); /* Fill buffer */
175           left = 0;
176
177           burn = transform_fn (S, tmpbuf, 1); /* Increment counter + Compress */
178
179           in += fill;
180           inlen -= fill;
181
182           nblks = inlen / blkbytes - !(inlen % blkbytes);
183           if (nblks)
184             {
185               burn = transform_fn(S, in, nblks);
186               in += blkbytes * nblks;
187               inlen -= blkbytes * nblks;
188             }
189         }
190
191       gcry_assert (inlen > 0);
192
193       buf_cpy (tmpbuf + left, in, inlen);
194       *tmpbuflen = left + inlen;
195     }
196
197   if (burn)
198     _gcry_burn_stack (burn);
199
200   return;
201 }
202
203
204 static inline void blake2b_set_lastblock(BLAKE2B_STATE *S)
205 {
206   S->f[0] = U64_C(0xffffffffffffffff);
207 }
208
209 static inline int blake2b_is_lastblock(const BLAKE2B_STATE *S)
210 {
211   return S->f[0] != 0;
212 }
213
214 static inline void blake2b_increment_counter(BLAKE2B_STATE *S, const int inc)
215 {
216   S->t[0] += (u64)inc;
217   S->t[1] += (S->t[0] < (u64)inc) - (inc < 0);
218 }
219
220 static inline u64 rotr64(u64 x, u64 n)
221 {
222   return ((x >> (n & 63)) | (x << ((64 - n) & 63)));
223 }
224
225 static unsigned int blake2b_transform_generic(BLAKE2B_STATE *S,
226                                               const void *inblks,
227                                               size_t nblks)
228 {
229   static const byte blake2b_sigma[12][16] =
230   {
231     {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 },
232     { 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 },
233     { 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4 },
234     {  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8 },
235     {  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13 },
236     {  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9 },
237     { 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11 },
238     { 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10 },
239     {  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5 },
240     { 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0 },
241     {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 },
242     { 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 }
243   };
244   const byte* in = inblks;
245   u64 m[16];
246   u64 v[16];
247
248   while (nblks--)
249     {
250       /* Increment counter */
251       blake2b_increment_counter (S, BLAKE2B_BLOCKBYTES);
252
253       /* Compress */
254       m[0] = buf_get_le64 (in + 0 * sizeof(m[0]));
255       m[1] = buf_get_le64 (in + 1 * sizeof(m[0]));
256       m[2] = buf_get_le64 (in + 2 * sizeof(m[0]));
257       m[3] = buf_get_le64 (in + 3 * sizeof(m[0]));
258       m[4] = buf_get_le64 (in + 4 * sizeof(m[0]));
259       m[5] = buf_get_le64 (in + 5 * sizeof(m[0]));
260       m[6] = buf_get_le64 (in + 6 * sizeof(m[0]));
261       m[7] = buf_get_le64 (in + 7 * sizeof(m[0]));
262       m[8] = buf_get_le64 (in + 8 * sizeof(m[0]));
263       m[9] = buf_get_le64 (in + 9 * sizeof(m[0]));
264       m[10] = buf_get_le64 (in + 10 * sizeof(m[0]));
265       m[11] = buf_get_le64 (in + 11 * sizeof(m[0]));
266       m[12] = buf_get_le64 (in + 12 * sizeof(m[0]));
267       m[13] = buf_get_le64 (in + 13 * sizeof(m[0]));
268       m[14] = buf_get_le64 (in + 14 * sizeof(m[0]));
269       m[15] = buf_get_le64 (in + 15 * sizeof(m[0]));
270
271       v[ 0] = S->h[0];
272       v[ 1] = S->h[1];
273       v[ 2] = S->h[2];
274       v[ 3] = S->h[3];
275       v[ 4] = S->h[4];
276       v[ 5] = S->h[5];
277       v[ 6] = S->h[6];
278       v[ 7] = S->h[7];
279       v[ 8] = blake2b_IV[0];
280       v[ 9] = blake2b_IV[1];
281       v[10] = blake2b_IV[2];
282       v[11] = blake2b_IV[3];
283       v[12] = blake2b_IV[4] ^ S->t[0];
284       v[13] = blake2b_IV[5] ^ S->t[1];
285       v[14] = blake2b_IV[6] ^ S->f[0];
286       v[15] = blake2b_IV[7] ^ S->f[1];
287
288 #define G(r,i,a,b,c,d)                      \
289   do {                                      \
290     a = a + b + m[blake2b_sigma[r][2*i+0]]; \
291     d = rotr64(d ^ a, 32);                  \
292     c = c + d;                              \
293     b = rotr64(b ^ c, 24);                  \
294     a = a + b + m[blake2b_sigma[r][2*i+1]]; \
295     d = rotr64(d ^ a, 16);                  \
296     c = c + d;                              \
297     b = rotr64(b ^ c, 63);                  \
298   } while(0)
299
300 #define ROUND(r)                    \
301   do {                              \
302     G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
303     G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
304     G(r,2,v[ 2],v[ 6],v[10],v[14]); \
305     G(r,3,v[ 3],v[ 7],v[11],v[15]); \
306     G(r,4,v[ 0],v[ 5],v[10],v[15]); \
307     G(r,5,v[ 1],v[ 6],v[11],v[12]); \
308     G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
309     G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
310   } while(0)
311
312       ROUND(0);
313       ROUND(1);
314       ROUND(2);
315       ROUND(3);
316       ROUND(4);
317       ROUND(5);
318       ROUND(6);
319       ROUND(7);
320       ROUND(8);
321       ROUND(9);
322       ROUND(10);
323       ROUND(11);
324
325 #undef G
326 #undef ROUND
327
328       S->h[0] = S->h[0] ^ v[0] ^ v[0 + 8];
329       S->h[1] = S->h[1] ^ v[1] ^ v[1 + 8];
330       S->h[2] = S->h[2] ^ v[2] ^ v[2 + 8];
331       S->h[3] = S->h[3] ^ v[3] ^ v[3 + 8];
332       S->h[4] = S->h[4] ^ v[4] ^ v[4 + 8];
333       S->h[5] = S->h[5] ^ v[5] ^ v[5 + 8];
334       S->h[6] = S->h[6] ^ v[6] ^ v[6 + 8];
335       S->h[7] = S->h[7] ^ v[7] ^ v[7 + 8];
336
337       in += BLAKE2B_BLOCKBYTES;
338     }
339
340   return sizeof(void *) * 4 + sizeof(u64) * 16 * 2;
341 }
342
343 #ifdef USE_AVX2
344 unsigned int _gcry_blake2b_transform_amd64_avx2(BLAKE2B_STATE *S,
345                                                 const void *inblks,
346                                                 size_t nblks) ASM_FUNC_ABI;
347 #endif
348
349 static unsigned int blake2b_transform(void *ctx, const void *inblks,
350                                       size_t nblks)
351 {
352   BLAKE2B_CONTEXT *c = ctx;
353   unsigned int nburn;
354
355   if (0)
356     {}
357 #ifdef USE_AVX2
358   if (c->use_avx2)
359     nburn = _gcry_blake2b_transform_amd64_avx2(&c->state, inblks, nblks);
360 #endif
361   else
362     nburn = blake2b_transform_generic(&c->state, inblks, nblks);
363
364   if (nburn)
365     nburn += ASM_EXTRA_STACK;
366
367   return nburn;
368 }
369
370 static void blake2b_final(void *ctx)
371 {
372   BLAKE2B_CONTEXT *c = ctx;
373   BLAKE2B_STATE *S = &c->state;
374   unsigned int burn;
375   size_t i;
376
377   gcry_assert (sizeof(c->buf) >= c->outlen);
378   if (blake2b_is_lastblock(S))
379     return;
380
381   if (c->buflen < BLAKE2B_BLOCKBYTES)
382     memset (c->buf + c->buflen, 0, BLAKE2B_BLOCKBYTES - c->buflen); /* Padding */
383   blake2b_set_lastblock (S);
384   blake2b_increment_counter (S, (int)c->buflen - BLAKE2B_BLOCKBYTES);
385   burn = blake2b_transform (ctx, c->buf, 1);
386
387   /* Output full hash to buffer */
388   for (i = 0; i < 8; ++i)
389     buf_put_le64 (c->buf + sizeof(S->h[i]) * i, S->h[i]);
390
391   /* Zero out extra buffer bytes. */
392   if (c->outlen < sizeof(c->buf))
393     memset (c->buf + c->outlen, 0, sizeof(c->buf) - c->outlen);
394
395   if (burn)
396     _gcry_burn_stack (burn);
397 }
398
399 static byte *blake2b_read(void *ctx)
400 {
401   BLAKE2B_CONTEXT *c = ctx;
402   return c->buf;
403 }
404
405 static void blake2b_write(void *ctx, const void *inbuf, size_t inlen)
406 {
407   BLAKE2B_CONTEXT *c = ctx;
408   BLAKE2B_STATE *S = &c->state;
409   blake2_write(S, inbuf, inlen, c->buf, &c->buflen, BLAKE2B_BLOCKBYTES,
410                blake2b_transform);
411 }
412
413 static inline void blake2b_init_param(BLAKE2B_STATE *S,
414                                       const struct blake2b_param_s *P)
415 {
416   const byte *p = (const byte *)P;
417   size_t i;
418
419   /* init xors IV with input parameter block */
420
421   /* IV XOR ParamBlock */
422   for (i = 0; i < 8; ++i)
423     S->h[i] = blake2b_IV[i] ^ buf_get_le64(p + sizeof(S->h[i]) * i);
424 }
425
426 static inline gcry_err_code_t blake2b_init(BLAKE2B_CONTEXT *ctx,
427                                            const byte *key, size_t keylen)
428 {
429   struct blake2b_param_s P[1] = { { 0, } };
430   BLAKE2B_STATE *S = &ctx->state;
431
432   if (!ctx->outlen || ctx->outlen > BLAKE2B_OUTBYTES)
433     return GPG_ERR_INV_ARG;
434   if (sizeof(P[0]) != sizeof(u64) * 8)
435     return GPG_ERR_INTERNAL;
436   if (keylen && (!key || keylen > BLAKE2B_KEYBYTES))
437     return GPG_ERR_INV_KEYLEN;
438
439   P->digest_length = ctx->outlen;
440   P->key_length = keylen;
441   P->fanout = 1;
442   P->depth = 1;
443
444   blake2b_init_param (S, P);
445   wipememory (P, sizeof(P));
446
447   if (key)
448     {
449       blake2b_write (ctx, key, keylen);
450       blake2b_write (ctx, zero_block, BLAKE2B_BLOCKBYTES - keylen);
451     }
452
453   return 0;
454 }
455
456 static gcry_err_code_t blake2b_init_ctx(void *ctx, unsigned int flags,
457                                         const byte *key, size_t keylen,
458                                         unsigned int dbits)
459 {
460   BLAKE2B_CONTEXT *c = ctx;
461   unsigned int features = _gcry_get_hw_features ();
462
463   (void)features;
464   (void)flags;
465
466   memset (c, 0, sizeof (*c));
467
468 #ifdef USE_AVX2
469   c->use_avx2 = !!(features & HWF_INTEL_AVX2);
470 #endif
471
472   c->outlen = dbits / 8;
473   c->buflen = 0;
474   return blake2b_init(c, key, keylen);
475 }
476
477 static inline void blake2s_set_lastblock(BLAKE2S_STATE *S)
478 {
479   S->f[0] = 0xFFFFFFFFUL;
480 }
481
482 static inline int blake2s_is_lastblock(BLAKE2S_STATE *S)
483 {
484   return S->f[0] != 0;
485 }
486
487 static inline void blake2s_increment_counter(BLAKE2S_STATE *S, const int inc)
488 {
489   S->t[0] += (u32)inc;
490   S->t[1] += (S->t[0] < (u32)inc) - (inc < 0);
491 }
492
493 static unsigned int blake2s_transform_generic(BLAKE2S_STATE *S,
494                                               const void *inblks,
495                                               size_t nblks)
496 {
497   static const byte blake2s_sigma[10][16] =
498   {
499     {  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15 },
500     { 14, 10,  4,  8,  9, 15, 13,  6,  1, 12,  0,  2, 11,  7,  5,  3 },
501     { 11,  8, 12,  0,  5,  2, 15, 13, 10, 14,  3,  6,  7,  1,  9,  4 },
502     {  7,  9,  3,  1, 13, 12, 11, 14,  2,  6,  5, 10,  4,  0, 15,  8 },
503     {  9,  0,  5,  7,  2,  4, 10, 15, 14,  1, 11, 12,  6,  8,  3, 13 },
504     {  2, 12,  6, 10,  0, 11,  8,  3,  4, 13,  7,  5, 15, 14,  1,  9 },
505     { 12,  5,  1, 15, 14, 13,  4, 10,  0,  7,  6,  3,  9,  2,  8, 11 },
506     { 13, 11,  7, 14, 12,  1,  3,  9,  5,  0, 15,  4,  8,  6,  2, 10 },
507     {  6, 15, 14,  9, 11,  3,  0,  8, 12,  2, 13,  7,  1,  4, 10,  5 },
508     { 10,  2,  8,  4,  7,  6,  1,  5, 15, 11,  9, 14,  3, 12, 13 , 0 },
509   };
510   unsigned int burn = 0;
511   const byte* in = inblks;
512   u32 m[16];
513   u32 v[16];
514
515   while (nblks--)
516     {
517       /* Increment counter */
518       blake2s_increment_counter (S, BLAKE2S_BLOCKBYTES);
519
520       /* Compress */
521       m[0] = buf_get_le32 (in + 0 * sizeof(m[0]));
522       m[1] = buf_get_le32 (in + 1 * sizeof(m[0]));
523       m[2] = buf_get_le32 (in + 2 * sizeof(m[0]));
524       m[3] = buf_get_le32 (in + 3 * sizeof(m[0]));
525       m[4] = buf_get_le32 (in + 4 * sizeof(m[0]));
526       m[5] = buf_get_le32 (in + 5 * sizeof(m[0]));
527       m[6] = buf_get_le32 (in + 6 * sizeof(m[0]));
528       m[7] = buf_get_le32 (in + 7 * sizeof(m[0]));
529       m[8] = buf_get_le32 (in + 8 * sizeof(m[0]));
530       m[9] = buf_get_le32 (in + 9 * sizeof(m[0]));
531       m[10] = buf_get_le32 (in + 10 * sizeof(m[0]));
532       m[11] = buf_get_le32 (in + 11 * sizeof(m[0]));
533       m[12] = buf_get_le32 (in + 12 * sizeof(m[0]));
534       m[13] = buf_get_le32 (in + 13 * sizeof(m[0]));
535       m[14] = buf_get_le32 (in + 14 * sizeof(m[0]));
536       m[15] = buf_get_le32 (in + 15 * sizeof(m[0]));
537
538       v[ 0] = S->h[0];
539       v[ 1] = S->h[1];
540       v[ 2] = S->h[2];
541       v[ 3] = S->h[3];
542       v[ 4] = S->h[4];
543       v[ 5] = S->h[5];
544       v[ 6] = S->h[6];
545       v[ 7] = S->h[7];
546       v[ 8] = blake2s_IV[0];
547       v[ 9] = blake2s_IV[1];
548       v[10] = blake2s_IV[2];
549       v[11] = blake2s_IV[3];
550       v[12] = S->t[0] ^ blake2s_IV[4];
551       v[13] = S->t[1] ^ blake2s_IV[5];
552       v[14] = S->f[0] ^ blake2s_IV[6];
553       v[15] = S->f[1] ^ blake2s_IV[7];
554
555 #define G(r,i,a,b,c,d)                      \
556   do {                                      \
557     a = a + b + m[blake2s_sigma[r][2*i+0]]; \
558     d = ror(d ^ a, 16);                     \
559     c = c + d;                              \
560     b = ror(b ^ c, 12);                     \
561     a = a + b + m[blake2s_sigma[r][2*i+1]]; \
562     d = ror(d ^ a, 8);                      \
563     c = c + d;                              \
564     b = ror(b ^ c, 7);                      \
565   } while(0)
566
567 #define ROUND(r)                    \
568   do {                              \
569     G(r,0,v[ 0],v[ 4],v[ 8],v[12]); \
570     G(r,1,v[ 1],v[ 5],v[ 9],v[13]); \
571     G(r,2,v[ 2],v[ 6],v[10],v[14]); \
572     G(r,3,v[ 3],v[ 7],v[11],v[15]); \
573     G(r,4,v[ 0],v[ 5],v[10],v[15]); \
574     G(r,5,v[ 1],v[ 6],v[11],v[12]); \
575     G(r,6,v[ 2],v[ 7],v[ 8],v[13]); \
576     G(r,7,v[ 3],v[ 4],v[ 9],v[14]); \
577   } while(0)
578
579       ROUND(0);
580       ROUND(1);
581       ROUND(2);
582       ROUND(3);
583       ROUND(4);
584       ROUND(5);
585       ROUND(6);
586       ROUND(7);
587       ROUND(8);
588       ROUND(9);
589
590 #undef G
591 #undef ROUND
592
593       S->h[0] = S->h[0] ^ v[0] ^ v[0 + 8];
594       S->h[1] = S->h[1] ^ v[1] ^ v[1 + 8];
595       S->h[2] = S->h[2] ^ v[2] ^ v[2 + 8];
596       S->h[3] = S->h[3] ^ v[3] ^ v[3 + 8];
597       S->h[4] = S->h[4] ^ v[4] ^ v[4 + 8];
598       S->h[5] = S->h[5] ^ v[5] ^ v[5 + 8];
599       S->h[6] = S->h[6] ^ v[6] ^ v[6 + 8];
600       S->h[7] = S->h[7] ^ v[7] ^ v[7 + 8];
601
602       in += BLAKE2S_BLOCKBYTES;
603     }
604
605   return burn;
606 }
607
608 #ifdef USE_AVX
609 unsigned int _gcry_blake2s_transform_amd64_avx(BLAKE2S_STATE *S,
610                                                const void *inblks,
611                                                size_t nblks) ASM_FUNC_ABI;
612 #endif
613
614 static unsigned int blake2s_transform(void *ctx, const void *inblks,
615                                       size_t nblks)
616 {
617   BLAKE2S_CONTEXT *c = ctx;
618   unsigned int nburn;
619
620   if (0)
621     {}
622 #ifdef USE_AVX
623   if (c->use_avx)
624     nburn = _gcry_blake2s_transform_amd64_avx(&c->state, inblks, nblks);
625 #endif
626   else
627     nburn = blake2s_transform_generic(&c->state, inblks, nblks);
628
629   if (nburn)
630     nburn += ASM_EXTRA_STACK;
631
632   return nburn;
633 }
634
635 static void blake2s_final(void *ctx)
636 {
637   BLAKE2S_CONTEXT *c = ctx;
638   BLAKE2S_STATE *S = &c->state;
639   unsigned int burn;
640   size_t i;
641
642   gcry_assert (sizeof(c->buf) >= c->outlen);
643   if (blake2s_is_lastblock(S))
644     return;
645
646   if (c->buflen < BLAKE2S_BLOCKBYTES)
647     memset (c->buf + c->buflen, 0, BLAKE2S_BLOCKBYTES - c->buflen); /* Padding */
648   blake2s_set_lastblock (S);
649   blake2s_increment_counter (S, (int)c->buflen - BLAKE2S_BLOCKBYTES);
650   burn = blake2s_transform (ctx, c->buf, 1);
651
652   /* Output full hash to buffer */
653   for (i = 0; i < 8; ++i)
654     buf_put_le32 (c->buf + sizeof(S->h[i]) * i, S->h[i]);
655
656   /* Zero out extra buffer bytes. */
657   if (c->outlen < sizeof(c->buf))
658     memset (c->buf + c->outlen, 0, sizeof(c->buf) - c->outlen);
659
660   if (burn)
661     _gcry_burn_stack (burn);
662 }
663
664 static byte *blake2s_read(void *ctx)
665 {
666   BLAKE2S_CONTEXT *c = ctx;
667   return c->buf;
668 }
669
670 static void blake2s_write(void *ctx, const void *inbuf, size_t inlen)
671 {
672   BLAKE2S_CONTEXT *c = ctx;
673   BLAKE2S_STATE *S = &c->state;
674   blake2_write(S, inbuf, inlen, c->buf, &c->buflen, BLAKE2S_BLOCKBYTES,
675                blake2s_transform);
676 }
677
678 static inline void blake2s_init_param(BLAKE2S_STATE *S,
679                                       const struct blake2s_param_s *P)
680 {
681   const byte *p = (const byte *)P;
682   size_t i;
683
684   /* init2 xors IV with input parameter block */
685
686   /* IV XOR ParamBlock */
687   for (i = 0; i < 8; ++i)
688     S->h[i] ^= blake2s_IV[i] ^ buf_get_le32(&p[i * 4]);
689 }
690
691 static inline gcry_err_code_t blake2s_init(BLAKE2S_CONTEXT *ctx,
692                                            const byte *key, size_t keylen)
693 {
694   struct blake2s_param_s P[1] = { { 0, } };
695   BLAKE2S_STATE *S = &ctx->state;
696
697   if (!ctx->outlen || ctx->outlen > BLAKE2S_OUTBYTES)
698     return GPG_ERR_INV_ARG;
699   if (sizeof(P[0]) != sizeof(u32) * 8)
700     return GPG_ERR_INTERNAL;
701   if (keylen && (!key || keylen > BLAKE2S_KEYBYTES))
702     return GPG_ERR_INV_KEYLEN;
703
704   P->digest_length = ctx->outlen;
705   P->key_length = keylen;
706   P->fanout = 1;
707   P->depth = 1;
708
709   blake2s_init_param (S, P);
710   wipememory (P, sizeof(P));
711
712   if (key)
713     {
714       blake2s_write (ctx, key, keylen);
715       blake2s_write (ctx, zero_block, BLAKE2S_BLOCKBYTES - keylen);
716     }
717
718   return 0;
719 }
720
721 static gcry_err_code_t blake2s_init_ctx(void *ctx, unsigned int flags,
722                                         const byte *key, size_t keylen,
723                                         unsigned int dbits)
724 {
725   BLAKE2S_CONTEXT *c = ctx;
726   unsigned int features = _gcry_get_hw_features ();
727
728   (void)features;
729   (void)flags;
730
731   memset (c, 0, sizeof (*c));
732
733 #ifdef USE_AVX
734   c->use_avx = !!(features & HWF_INTEL_AVX);
735 #endif
736
737   c->outlen = dbits / 8;
738   c->buflen = 0;
739   return blake2s_init(c, key, keylen);
740 }
741
742 /* Selftests from "RFC 7693, Appendix E. BLAKE2b and BLAKE2s Self-Test
743  * Module C Source". */
744 static void selftest_seq(byte *out, size_t len, u32 seed)
745 {
746   size_t i;
747   u32 t, a, b;
748
749   a = 0xDEAD4BAD * seed;
750   b = 1;
751
752   for (i = 0; i < len; i++)
753     {
754       t = a + b;
755       a = b;
756       b = t;
757       out[i] = (t >> 24) & 0xFF;
758     }
759 }
760
761 static gpg_err_code_t
762 selftests_blake2b (int algo, int extended, selftest_report_func_t report)
763 {
764   static const byte blake2b_res[32] =
765   {
766     0xC2, 0x3A, 0x78, 0x00, 0xD9, 0x81, 0x23, 0xBD,
767     0x10, 0xF5, 0x06, 0xC6, 0x1E, 0x29, 0xDA, 0x56,
768     0x03, 0xD7, 0x63, 0xB8, 0xBB, 0xAD, 0x2E, 0x73,
769     0x7F, 0x5E, 0x76, 0x5A, 0x7B, 0xCC, 0xD4, 0x75
770   };
771   static const size_t b2b_md_len[4] = { 20, 32, 48, 64 };
772   static const size_t b2b_in_len[6] = { 0, 3, 128, 129, 255, 1024 };
773   size_t i, j, outlen, inlen;
774   byte in[1024], key[64];
775   BLAKE2B_CONTEXT ctx;
776   BLAKE2B_CONTEXT ctx2;
777   const char *what;
778   const char *errtxt;
779
780   (void)extended;
781
782   what = "rfc7693 BLAKE2b selftest";
783
784   /* 256-bit hash for testing */
785   if (blake2b_init_ctx(&ctx, 0, NULL, 0, 32 * 8))
786     {
787       errtxt = "init failed";
788       goto failed;
789     }
790
791   for (i = 0; i < 4; i++)
792     {
793       outlen = b2b_md_len[i];
794       for (j = 0; j < 6; j++)
795         {
796           inlen = b2b_in_len[j];
797
798           selftest_seq(in, inlen, inlen); /* unkeyed hash */
799           blake2b_init_ctx(&ctx2, 0, NULL, 0, outlen * 8);
800           blake2b_write(&ctx2, in, inlen);
801           blake2b_final(&ctx2);
802           blake2b_write(&ctx, ctx2.buf, outlen); /* hash the hash */
803
804           selftest_seq(key, outlen, outlen); /* keyed hash */
805           blake2b_init_ctx(&ctx2, 0, key, outlen, outlen * 8);
806           blake2b_write(&ctx2, in, inlen);
807           blake2b_final(&ctx2);
808           blake2b_write(&ctx, ctx2.buf, outlen); /* hash the hash */
809         }
810     }
811
812   /* compute and compare the hash of hashes */
813   blake2b_final(&ctx);
814   for (i = 0; i < 32; i++)
815     {
816       if (ctx.buf[i] != blake2b_res[i])
817         {
818           errtxt = "digest mismatch";
819           goto failed;
820         }
821     }
822
823   return 0;
824
825 failed:
826   if (report)
827     report ("digest", algo, what, errtxt);
828   return GPG_ERR_SELFTEST_FAILED;
829 }
830
831 static gpg_err_code_t
832 selftests_blake2s (int algo, int extended, selftest_report_func_t report)
833 {
834   static const byte blake2s_res[32] =
835   {
836     0x6A, 0x41, 0x1F, 0x08, 0xCE, 0x25, 0xAD, 0xCD,
837     0xFB, 0x02, 0xAB, 0xA6, 0x41, 0x45, 0x1C, 0xEC,
838     0x53, 0xC5, 0x98, 0xB2, 0x4F, 0x4F, 0xC7, 0x87,
839     0xFB, 0xDC, 0x88, 0x79, 0x7F, 0x4C, 0x1D, 0xFE
840   };
841   static const size_t b2s_md_len[4] = { 16, 20, 28, 32 };
842   static const size_t b2s_in_len[6] = { 0, 3, 64, 65, 255, 1024 };
843   size_t i, j, outlen, inlen;
844   byte in[1024], key[32];
845   BLAKE2S_CONTEXT ctx;
846   BLAKE2S_CONTEXT ctx2;
847   const char *what;
848   const char *errtxt;
849
850   (void)extended;
851
852   what = "rfc7693 BLAKE2s selftest";
853
854   /* 256-bit hash for testing */
855   if (blake2s_init_ctx(&ctx, 0, NULL, 0, 32 * 8))
856     {
857       errtxt = "init failed";
858       goto failed;
859     }
860
861   for (i = 0; i < 4; i++)
862     {
863       outlen = b2s_md_len[i];
864       for (j = 0; j < 6; j++)
865         {
866           inlen = b2s_in_len[j];
867
868           selftest_seq(in, inlen, inlen); /* unkeyed hash */
869           blake2s_init_ctx(&ctx2, 0, NULL, 0, outlen * 8);
870           blake2s_write(&ctx2, in, inlen);
871           blake2s_final(&ctx2);
872           blake2s_write(&ctx, ctx2.buf, outlen); /* hash the hash */
873
874           selftest_seq(key, outlen, outlen); /* keyed hash */
875           blake2s_init_ctx(&ctx2, 0, key, outlen, outlen * 8);
876           blake2s_write(&ctx2, in, inlen);
877           blake2s_final(&ctx2);
878           blake2s_write(&ctx, ctx2.buf, outlen); /* hash the hash */
879         }
880     }
881
882   /* compute and compare the hash of hashes */
883   blake2s_final(&ctx);
884   for (i = 0; i < 32; i++)
885     {
886       if (ctx.buf[i] != blake2s_res[i])
887         {
888           errtxt = "digest mismatch";
889           goto failed;
890         }
891     }
892
893   return 0;
894
895 failed:
896   if (report)
897     report ("digest", algo, what, errtxt);
898   return GPG_ERR_SELFTEST_FAILED;
899 }
900
901
902 gcry_err_code_t _gcry_blake2_init_with_key(void *ctx, unsigned int flags,
903                                            const unsigned char *key,
904                                            size_t keylen, int algo)
905 {
906   gcry_err_code_t rc;
907   switch (algo)
908     {
909     case GCRY_MD_BLAKE2B_512:
910       rc = blake2b_init_ctx (ctx, flags, key, keylen, 512);
911       break;
912     case GCRY_MD_BLAKE2B_384:
913       rc = blake2b_init_ctx (ctx, flags, key, keylen, 384);
914       break;
915     case GCRY_MD_BLAKE2B_256:
916       rc = blake2b_init_ctx (ctx, flags, key, keylen, 256);
917       break;
918     case GCRY_MD_BLAKE2B_160:
919       rc = blake2b_init_ctx (ctx, flags, key, keylen, 160);
920       break;
921     case GCRY_MD_BLAKE2S_256:
922       rc = blake2s_init_ctx (ctx, flags, key, keylen, 256);
923       break;
924     case GCRY_MD_BLAKE2S_224:
925       rc = blake2s_init_ctx (ctx, flags, key, keylen, 224);
926       break;
927     case GCRY_MD_BLAKE2S_160:
928       rc = blake2s_init_ctx (ctx, flags, key, keylen, 160);
929       break;
930     case GCRY_MD_BLAKE2S_128:
931       rc = blake2s_init_ctx (ctx, flags, key, keylen, 128);
932       break;
933     default:
934       rc = GPG_ERR_DIGEST_ALGO;
935       break;
936     }
937
938   return rc;
939 }
940
941
942 #define DEFINE_BLAKE2_VARIANT(bs, BS, dbits, oid_branch) \
943   static void blake2##bs##_##dbits##_init(void *ctx, unsigned int flags) \
944   { \
945     int err = blake2##bs##_init_ctx (ctx, flags, NULL, 0, dbits); \
946     gcry_assert (err == 0); \
947   } \
948   static void \
949   _gcry_blake2##bs##_##dbits##_hash_buffer(void *outbuf, \
950         const void *buffer, size_t length) \
951   { \
952     BLAKE2##BS##_CONTEXT hd; \
953     blake2##bs##_##dbits##_init (&hd, 0); \
954     blake2##bs##_write (&hd, buffer, length); \
955     blake2##bs##_final (&hd); \
956     memcpy (outbuf, blake2##bs##_read (&hd), dbits / 8); \
957   } \
958   static void \
959   _gcry_blake2##bs##_##dbits##_hash_buffers(void *outbuf, \
960         const gcry_buffer_t *iov, int iovcnt) \
961   { \
962     BLAKE2##BS##_CONTEXT hd; \
963     blake2##bs##_##dbits##_init (&hd, 0); \
964     for (;iovcnt > 0; iov++, iovcnt--) \
965       blake2##bs##_write (&hd, (const char*)iov[0].data + iov[0].off, \
966                           iov[0].len); \
967     blake2##bs##_final (&hd); \
968     memcpy (outbuf, blake2##bs##_read (&hd), dbits / 8); \
969   } \
970   static byte blake2##bs##_##dbits##_asn[] = { 0x30 }; \
971   static gcry_md_oid_spec_t oid_spec_blake2##bs##_##dbits[] = \
972     { \
973       { " 1.3.6.1.4.1.1722.12.2." oid_branch }, \
974       { NULL } \
975     }; \
976   gcry_md_spec_t _gcry_digest_spec_blake2##bs##_##dbits = \
977     { \
978       GCRY_MD_BLAKE2##BS##_##dbits, {0, 0}, \
979       "BLAKE2" #BS "_" #dbits, blake2##bs##_##dbits##_asn, \
980       DIM (blake2##bs##_##dbits##_asn), oid_spec_blake2##bs##_##dbits, \
981       dbits / 8, blake2##bs##_##dbits##_init, blake2##bs##_write, \
982       blake2##bs##_final, blake2##bs##_read, NULL, \
983       _gcry_blake2##bs##_##dbits##_hash_buffer, \
984       _gcry_blake2##bs##_##dbits##_hash_buffers, \
985       sizeof (BLAKE2##BS##_CONTEXT), selftests_blake2##bs \
986     };
987
988 DEFINE_BLAKE2_VARIANT(b, B, 512, "1.16")
989 DEFINE_BLAKE2_VARIANT(b, B, 384, "1.12")
990 DEFINE_BLAKE2_VARIANT(b, B, 256, "1.8")
991 DEFINE_BLAKE2_VARIANT(b, B, 160, "1.5")
992
993 DEFINE_BLAKE2_VARIANT(s, S, 256, "2.8")
994 DEFINE_BLAKE2_VARIANT(s, S, 224, "2.7")
995 DEFINE_BLAKE2_VARIANT(s, S, 160, "2.5")
996 DEFINE_BLAKE2_VARIANT(s, S, 128, "2.4")