Add crypto hash SM3.
[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 #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 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   const byte* in = inbuf;
129   unsigned int burn = 0;
130
131   if (inlen > 0)
132     {
133       size_t left = *tmpbuflen;
134       size_t fill = blkbytes - left;
135       size_t nblks;
136
137       if (inlen > fill)
138         {
139           if (fill > 0)
140             buf_cpy (tmpbuf + left, in, fill); /* Fill buffer */
141           left = 0;
142
143           burn = transform_fn (S, tmpbuf, 1); /* Increment counter + Compress */
144
145           in += fill;
146           inlen -= fill;
147
148           nblks = inlen / blkbytes - !(inlen % blkbytes);
149           if (nblks)
150             {
151               burn = transform_fn(S, in, nblks);
152               in += blkbytes * nblks;
153               inlen -= blkbytes * nblks;
154             }
155         }
156
157       gcry_assert (inlen > 0);
158
159       buf_cpy (tmpbuf + left, in, inlen);
160       *tmpbuflen = left + inlen;
161     }
162
163   if (burn)
164     _gcry_burn_stack (burn);
165
166   return;
167 }
168
169
170 static inline void blake2b_set_lastblock(BLAKE2B_STATE *S)
171 {
172   S->f[0] = U64_C(0xffffffffffffffff);
173 }
174
175 static inline int blake2b_is_lastblock(const BLAKE2B_STATE *S)
176 {
177   return S->f[0] != 0;
178 }
179
180 static inline void blake2b_increment_counter(BLAKE2B_STATE *S, const int inc)
181 {
182   S->t[0] += (u64)inc;
183   S->t[1] += (S->t[0] < (u64)inc) - (inc < 0);
184 }
185
186 static inline u64 rotr64(u64 x, u64 n)
187 {
188   return ((x >> (n & 63)) | (x << ((64 - n) & 63)));
189 }
190
191 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   BLAKE2B_STATE *S = vS;
210   const byte* in = inblks;
211   u64 m[16];
212   u64 v[16];
213
214   while (nblks--)
215     {
216       /* Increment counter */
217       blake2b_increment_counter (S, BLAKE2B_BLOCKBYTES);
218
219       /* Compress */
220       m[0] = buf_get_le64 (in + 0 * sizeof(m[0]));
221       m[1] = buf_get_le64 (in + 1 * sizeof(m[0]));
222       m[2] = buf_get_le64 (in + 2 * sizeof(m[0]));
223       m[3] = buf_get_le64 (in + 3 * sizeof(m[0]));
224       m[4] = buf_get_le64 (in + 4 * sizeof(m[0]));
225       m[5] = buf_get_le64 (in + 5 * sizeof(m[0]));
226       m[6] = buf_get_le64 (in + 6 * sizeof(m[0]));
227       m[7] = buf_get_le64 (in + 7 * sizeof(m[0]));
228       m[8] = buf_get_le64 (in + 8 * sizeof(m[0]));
229       m[9] = buf_get_le64 (in + 9 * sizeof(m[0]));
230       m[10] = buf_get_le64 (in + 10 * sizeof(m[0]));
231       m[11] = buf_get_le64 (in + 11 * sizeof(m[0]));
232       m[12] = buf_get_le64 (in + 12 * sizeof(m[0]));
233       m[13] = buf_get_le64 (in + 13 * sizeof(m[0]));
234       m[14] = buf_get_le64 (in + 14 * sizeof(m[0]));
235       m[15] = buf_get_le64 (in + 15 * sizeof(m[0]));
236
237       v[ 0] = S->h[0];
238       v[ 1] = S->h[1];
239       v[ 2] = S->h[2];
240       v[ 3] = S->h[3];
241       v[ 4] = S->h[4];
242       v[ 5] = S->h[5];
243       v[ 6] = S->h[6];
244       v[ 7] = S->h[7];
245       v[ 8] = blake2b_IV[0];
246       v[ 9] = blake2b_IV[1];
247       v[10] = blake2b_IV[2];
248       v[11] = blake2b_IV[3];
249       v[12] = blake2b_IV[4] ^ S->t[0];
250       v[13] = blake2b_IV[5] ^ S->t[1];
251       v[14] = blake2b_IV[6] ^ S->f[0];
252       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       ROUND(0);
279       ROUND(1);
280       ROUND(2);
281       ROUND(3);
282       ROUND(4);
283       ROUND(5);
284       ROUND(6);
285       ROUND(7);
286       ROUND(8);
287       ROUND(9);
288       ROUND(10);
289       ROUND(11);
290
291 #undef G
292 #undef ROUND
293
294       S->h[0] = S->h[0] ^ v[0] ^ v[0 + 8];
295       S->h[1] = S->h[1] ^ v[1] ^ v[1 + 8];
296       S->h[2] = S->h[2] ^ v[2] ^ v[2 + 8];
297       S->h[3] = S->h[3] ^ v[3] ^ v[3 + 8];
298       S->h[4] = S->h[4] ^ v[4] ^ v[4 + 8];
299       S->h[5] = S->h[5] ^ v[5] ^ v[5 + 8];
300       S->h[6] = S->h[6] ^ v[6] ^ v[6 + 8];
301       S->h[7] = S->h[7] ^ v[7] ^ v[7 + 8];
302
303       in += BLAKE2B_BLOCKBYTES;
304     }
305
306   return sizeof(void *) * 4 + sizeof(u64) * 16 * 2;
307 }
308
309 static void blake2b_final(void *ctx)
310 {
311   BLAKE2B_CONTEXT *c = ctx;
312   BLAKE2B_STATE *S = &c->state;
313   unsigned int burn;
314   size_t i;
315
316   gcry_assert (sizeof(c->buf) >= c->outlen);
317   if (blake2b_is_lastblock(S))
318     return;
319
320   if (c->buflen < BLAKE2B_BLOCKBYTES)
321     memset (c->buf + c->buflen, 0, BLAKE2B_BLOCKBYTES - c->buflen); /* Padding */
322   blake2b_set_lastblock (S);
323   blake2b_increment_counter (S, (int)c->buflen - BLAKE2B_BLOCKBYTES);
324   burn = blake2b_transform (S, c->buf, 1);
325
326   /* Output full hash to buffer */
327   for (i = 0; i < 8; ++i)
328     buf_put_le64 (c->buf + sizeof(S->h[i]) * i, S->h[i]);
329
330   /* Zero out extra buffer bytes. */
331   if (c->outlen < sizeof(c->buf))
332     memset (c->buf + c->outlen, 0, sizeof(c->buf) - c->outlen);
333
334   if (burn)
335     _gcry_burn_stack (burn);
336 }
337
338 static byte *blake2b_read(void *ctx)
339 {
340   BLAKE2B_CONTEXT *c = ctx;
341   return c->buf;
342 }
343
344 static void blake2b_write(void *ctx, const void *inbuf, size_t inlen)
345 {
346   BLAKE2B_CONTEXT *c = ctx;
347   BLAKE2B_STATE *S = &c->state;
348   blake2_write(S, inbuf, inlen, c->buf, &c->buflen, BLAKE2B_BLOCKBYTES,
349                blake2b_transform);
350 }
351
352 static inline void blake2b_init_param(BLAKE2B_STATE *S,
353                                       const struct blake2b_param_s *P)
354 {
355   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   for (i = 0; i < 8; ++i)
362     S->h[i] = blake2b_IV[i] ^ buf_get_le64(p + sizeof(S->h[i]) * i);
363 }
364
365 static inline gcry_err_code_t blake2b_init(BLAKE2B_CONTEXT *ctx,
366                                            const byte *key, size_t keylen)
367 {
368   struct blake2b_param_s P[1] = { { 0, } };
369   BLAKE2B_STATE *S = &ctx->state;
370
371   if (!ctx->outlen || ctx->outlen > BLAKE2B_OUTBYTES)
372     return GPG_ERR_INV_ARG;
373   if (sizeof(P[0]) != sizeof(u64) * 8)
374     return GPG_ERR_INTERNAL;
375   if (keylen && (!key || keylen > BLAKE2B_KEYBYTES))
376     return GPG_ERR_INV_KEYLEN;
377
378   P->digest_length = ctx->outlen;
379   P->key_length = keylen;
380   P->fanout = 1;
381   P->depth = 1;
382
383   blake2b_init_param (S, P);
384   wipememory (P, sizeof(P));
385
386   if (key)
387     {
388       blake2b_write (ctx, key, keylen);
389       blake2b_write (ctx, zero_block, BLAKE2B_BLOCKBYTES - keylen);
390     }
391
392   return 0;
393 }
394
395 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   BLAKE2B_CONTEXT *c = ctx;
400
401   (void)flags;
402
403   memset (c, 0, sizeof (*c));
404
405   c->outlen = dbits / 8;
406   c->buflen = 0;
407   return blake2b_init(c, key, keylen);
408 }
409
410 static inline void blake2s_set_lastblock(BLAKE2S_STATE *S)
411 {
412   S->f[0] = 0xFFFFFFFFUL;
413 }
414
415 static inline int blake2s_is_lastblock(BLAKE2S_STATE *S)
416 {
417   return S->f[0] != 0;
418 }
419
420 static inline void blake2s_increment_counter(BLAKE2S_STATE *S, const int inc)
421 {
422   S->t[0] += (u32)inc;
423   S->t[1] += (S->t[0] < (u32)inc) - (inc < 0);
424 }
425
426 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   BLAKE2S_STATE *S = vS;
443   unsigned int burn = 0;
444   const byte* in = inblks;
445   u32 m[16];
446   u32 v[16];
447
448   while (nblks--)
449     {
450       /* Increment counter */
451       blake2s_increment_counter (S, BLAKE2S_BLOCKBYTES);
452
453       /* Compress */
454       m[0] = buf_get_le32 (in + 0 * sizeof(m[0]));
455       m[1] = buf_get_le32 (in + 1 * sizeof(m[0]));
456       m[2] = buf_get_le32 (in + 2 * sizeof(m[0]));
457       m[3] = buf_get_le32 (in + 3 * sizeof(m[0]));
458       m[4] = buf_get_le32 (in + 4 * sizeof(m[0]));
459       m[5] = buf_get_le32 (in + 5 * sizeof(m[0]));
460       m[6] = buf_get_le32 (in + 6 * sizeof(m[0]));
461       m[7] = buf_get_le32 (in + 7 * sizeof(m[0]));
462       m[8] = buf_get_le32 (in + 8 * sizeof(m[0]));
463       m[9] = buf_get_le32 (in + 9 * sizeof(m[0]));
464       m[10] = buf_get_le32 (in + 10 * sizeof(m[0]));
465       m[11] = buf_get_le32 (in + 11 * sizeof(m[0]));
466       m[12] = buf_get_le32 (in + 12 * sizeof(m[0]));
467       m[13] = buf_get_le32 (in + 13 * sizeof(m[0]));
468       m[14] = buf_get_le32 (in + 14 * sizeof(m[0]));
469       m[15] = buf_get_le32 (in + 15 * sizeof(m[0]));
470
471       v[ 0] = S->h[0];
472       v[ 1] = S->h[1];
473       v[ 2] = S->h[2];
474       v[ 3] = S->h[3];
475       v[ 4] = S->h[4];
476       v[ 5] = S->h[5];
477       v[ 6] = S->h[6];
478       v[ 7] = S->h[7];
479       v[ 8] = blake2s_IV[0];
480       v[ 9] = blake2s_IV[1];
481       v[10] = blake2s_IV[2];
482       v[11] = blake2s_IV[3];
483       v[12] = S->t[0] ^ blake2s_IV[4];
484       v[13] = S->t[1] ^ blake2s_IV[5];
485       v[14] = S->f[0] ^ blake2s_IV[6];
486       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       ROUND(0);
513       ROUND(1);
514       ROUND(2);
515       ROUND(3);
516       ROUND(4);
517       ROUND(5);
518       ROUND(6);
519       ROUND(7);
520       ROUND(8);
521       ROUND(9);
522
523 #undef G
524 #undef ROUND
525
526       S->h[0] = S->h[0] ^ v[0] ^ v[0 + 8];
527       S->h[1] = S->h[1] ^ v[1] ^ v[1 + 8];
528       S->h[2] = S->h[2] ^ v[2] ^ v[2 + 8];
529       S->h[3] = S->h[3] ^ v[3] ^ v[3 + 8];
530       S->h[4] = S->h[4] ^ v[4] ^ v[4 + 8];
531       S->h[5] = S->h[5] ^ v[5] ^ v[5 + 8];
532       S->h[6] = S->h[6] ^ v[6] ^ v[6 + 8];
533       S->h[7] = S->h[7] ^ v[7] ^ v[7 + 8];
534
535       in += BLAKE2S_BLOCKBYTES;
536     }
537
538   return burn;
539 }
540
541 static void blake2s_final(void *ctx)
542 {
543   BLAKE2S_CONTEXT *c = ctx;
544   BLAKE2S_STATE *S = &c->state;
545   unsigned int burn;
546   size_t i;
547
548   gcry_assert (sizeof(c->buf) >= c->outlen);
549   if (blake2s_is_lastblock(S))
550     return;
551
552   if (c->buflen < BLAKE2S_BLOCKBYTES)
553     memset (c->buf + c->buflen, 0, BLAKE2S_BLOCKBYTES - c->buflen); /* Padding */
554   blake2s_set_lastblock (S);
555   blake2s_increment_counter (S, (int)c->buflen - BLAKE2S_BLOCKBYTES);
556   burn = blake2s_transform (S, c->buf, 1);
557
558   /* Output full hash to buffer */
559   for (i = 0; i < 8; ++i)
560     buf_put_le32 (c->buf + sizeof(S->h[i]) * i, S->h[i]);
561
562   /* Zero out extra buffer bytes. */
563   if (c->outlen < sizeof(c->buf))
564     memset (c->buf + c->outlen, 0, sizeof(c->buf) - c->outlen);
565
566   if (burn)
567     _gcry_burn_stack (burn);
568 }
569
570 static byte *blake2s_read(void *ctx)
571 {
572   BLAKE2S_CONTEXT *c = ctx;
573   return c->buf;
574 }
575
576 static void blake2s_write(void *ctx, const void *inbuf, size_t inlen)
577 {
578   BLAKE2S_CONTEXT *c = ctx;
579   BLAKE2S_STATE *S = &c->state;
580   blake2_write(S, inbuf, inlen, c->buf, &c->buflen, BLAKE2S_BLOCKBYTES,
581                blake2s_transform);
582 }
583
584 static inline void blake2s_init_param(BLAKE2S_STATE *S,
585                                       const struct blake2s_param_s *P)
586 {
587   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   for (i = 0; i < 8; ++i)
594     S->h[i] ^= blake2s_IV[i] ^ buf_get_le32(&p[i * 4]);
595 }
596
597 static inline gcry_err_code_t blake2s_init(BLAKE2S_CONTEXT *ctx,
598                                            const byte *key, size_t keylen)
599 {
600   struct blake2s_param_s P[1] = { { 0, } };
601   BLAKE2S_STATE *S = &ctx->state;
602
603   if (!ctx->outlen || ctx->outlen > BLAKE2S_OUTBYTES)
604     return GPG_ERR_INV_ARG;
605   if (sizeof(P[0]) != sizeof(u32) * 8)
606     return GPG_ERR_INTERNAL;
607   if (keylen && (!key || keylen > BLAKE2S_KEYBYTES))
608     return GPG_ERR_INV_KEYLEN;
609
610   P->digest_length = ctx->outlen;
611   P->key_length = keylen;
612   P->fanout = 1;
613   P->depth = 1;
614
615   blake2s_init_param (S, P);
616   wipememory (P, sizeof(P));
617
618   if (key)
619     {
620       blake2s_write (ctx, key, keylen);
621       blake2s_write (ctx, zero_block, BLAKE2S_BLOCKBYTES - keylen);
622     }
623
624   return 0;
625 }
626
627 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   BLAKE2S_CONTEXT *c = ctx;
632
633   (void)flags;
634
635   memset (c, 0, sizeof (*c));
636
637   c->outlen = dbits / 8;
638   c->buflen = 0;
639   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 static void selftest_seq(byte *out, size_t len, u32 seed)
645 {
646   size_t i;
647   u32 t, a, b;
648
649   a = 0xDEAD4BAD * seed;
650   b = 1;
651
652   for (i = 0; i < len; i++)
653     {
654       t = a + b;
655       a = b;
656       b = t;
657       out[i] = (t >> 24) & 0xFF;
658     }
659 }
660
661 static gpg_err_code_t
662 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   what = "rfc7693 BLAKE2b selftest";
683
684   /* 256-bit hash for testing */
685   if (blake2b_init_ctx(&ctx, 0, NULL, 0, 32 * 8))
686     {
687       errtxt = "init failed";
688       goto failed;
689     }
690
691   for (i = 0; i < 4; i++)
692     {
693       outlen = b2b_md_len[i];
694       for (j = 0; j < 6; j++)
695         {
696           inlen = b2b_in_len[j];
697
698           selftest_seq(in, inlen, inlen); /* unkeyed hash */
699           blake2b_init_ctx(&ctx2, 0, NULL, 0, outlen * 8);
700           blake2b_write(&ctx2, in, inlen);
701           blake2b_final(&ctx2);
702           blake2b_write(&ctx, ctx2.buf, outlen); /* hash the hash */
703
704           selftest_seq(key, outlen, outlen); /* keyed hash */
705           blake2b_init_ctx(&ctx2, 0, key, outlen, outlen * 8);
706           blake2b_write(&ctx2, in, inlen);
707           blake2b_final(&ctx2);
708           blake2b_write(&ctx, ctx2.buf, outlen); /* hash the hash */
709         }
710     }
711
712   /* compute and compare the hash of hashes */
713   blake2b_final(&ctx);
714   for (i = 0; i < 32; i++)
715     {
716       if (ctx.buf[i] != blake2b_res[i])
717         {
718           errtxt = "digest mismatch";
719           goto failed;
720         }
721     }
722
723   return 0;
724
725 failed:
726   if (report)
727     report ("digest", algo, what, errtxt);
728   return GPG_ERR_SELFTEST_FAILED;
729 }
730
731 static gpg_err_code_t
732 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   what = "rfc7693 BLAKE2s selftest";
753
754   /* 256-bit hash for testing */
755   if (blake2s_init_ctx(&ctx, 0, NULL, 0, 32 * 8))
756     {
757       errtxt = "init failed";
758       goto failed;
759     }
760
761   for (i = 0; i < 4; i++)
762     {
763       outlen = b2s_md_len[i];
764       for (j = 0; j < 6; j++)
765         {
766           inlen = b2s_in_len[j];
767
768           selftest_seq(in, inlen, inlen); /* unkeyed hash */
769           blake2s_init_ctx(&ctx2, 0, NULL, 0, outlen * 8);
770           blake2s_write(&ctx2, in, inlen);
771           blake2s_final(&ctx2);
772           blake2s_write(&ctx, ctx2.buf, outlen); /* hash the hash */
773
774           selftest_seq(key, outlen, outlen); /* keyed hash */
775           blake2s_init_ctx(&ctx2, 0, key, outlen, outlen * 8);
776           blake2s_write(&ctx2, in, inlen);
777           blake2s_final(&ctx2);
778           blake2s_write(&ctx, ctx2.buf, outlen); /* hash the hash */
779         }
780     }
781
782   /* compute and compare the hash of hashes */
783   blake2s_final(&ctx);
784   for (i = 0; i < 32; i++)
785     {
786       if (ctx.buf[i] != blake2s_res[i])
787         {
788           errtxt = "digest mismatch";
789           goto failed;
790         }
791     }
792
793   return 0;
794
795 failed:
796   if (report)
797     report ("digest", algo, what, errtxt);
798   return GPG_ERR_SELFTEST_FAILED;
799 }
800
801
802 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   switch (algo)
808     {
809     case GCRY_MD_BLAKE2B_512:
810       rc = blake2b_init_ctx (ctx, flags, key, keylen, 512);
811       break;
812     case GCRY_MD_BLAKE2B_384:
813       rc = blake2b_init_ctx (ctx, flags, key, keylen, 384);
814       break;
815     case GCRY_MD_BLAKE2B_256:
816       rc = blake2b_init_ctx (ctx, flags, key, keylen, 256);
817       break;
818     case GCRY_MD_BLAKE2B_160:
819       rc = blake2b_init_ctx (ctx, flags, key, keylen, 160);
820       break;
821     case GCRY_MD_BLAKE2S_256:
822       rc = blake2s_init_ctx (ctx, flags, key, keylen, 256);
823       break;
824     case GCRY_MD_BLAKE2S_224:
825       rc = blake2s_init_ctx (ctx, flags, key, keylen, 224);
826       break;
827     case GCRY_MD_BLAKE2S_160:
828       rc = blake2s_init_ctx (ctx, flags, key, keylen, 160);
829       break;
830     case GCRY_MD_BLAKE2S_128:
831       rc = blake2s_init_ctx (ctx, flags, key, keylen, 128);
832       break;
833     default:
834       rc = GPG_ERR_DIGEST_ALGO;
835       break;
836     }
837
838   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 DEFINE_BLAKE2_VARIANT(b, B, 512, "1.16")
865 DEFINE_BLAKE2_VARIANT(b, B, 384, "1.12")
866 DEFINE_BLAKE2_VARIANT(b, B, 256, "1.8")
867 DEFINE_BLAKE2_VARIANT(b, B, 160, "1.5")
868
869 DEFINE_BLAKE2_VARIANT(s, S, 256, "2.8")
870 DEFINE_BLAKE2_VARIANT(s, S, 224, "2.7")
871 DEFINE_BLAKE2_VARIANT(s, S, 160, "2.5")
872 DEFINE_BLAKE2_VARIANT(s, S, 128, "2.4")