d46d9cb11f88a3faac0d38993da654286bdf4d1e
[libgcrypt.git] / cipher / keccak.c
1 /* keccak.c - SHA3 hash functions
2  * Copyright (C) 2015  g10 Code GmbH
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
21 #include <config.h>
22 #include <string.h>
23 #include "g10lib.h"
24 #include "bithelp.h"
25 #include "bufhelp.h"
26 #include "cipher.h"
27 #include "hash-common.h"
28
29
30
31 /* USE_64BIT indicates whether to use 64-bit generic implementation.
32  * USE_32BIT indicates whether to use 32-bit generic implementation. */
33 #undef USE_64BIT
34 #if defined(__x86_64__) || SIZEOF_UNSIGNED_LONG == 8
35 # define USE_64BIT 1
36 #else
37 # define USE_32BIT 1
38 #endif
39
40
41 /* USE_64BIT_BMI2 indicates whether to compile with 64-bit Intel BMI2 code. */
42 #undef USE_64BIT_BMI2
43 #if defined(USE_64BIT) && defined(HAVE_GCC_INLINE_ASM_BMI2)
44 # define USE_64BIT_BMI2 1
45 #endif
46
47
48 /* USE_64BIT_SHLD indicates whether to compile with 64-bit Intel SHLD code. */
49 #undef USE_64BIT_SHLD
50 #if defined(USE_64BIT) && defined (__GNUC__) && defined(__x86_64__)
51 # define USE_64BIT_SHLD 1
52 #endif
53
54
55 /* USE_32BIT_BMI2 indicates whether to compile with 32-bit Intel BMI2 code. */
56 #undef USE_32BIT_BMI2
57 #if defined(USE_32BIT) && defined(HAVE_GCC_INLINE_ASM_BMI2)
58 # define USE_32BIT_BMI2 1
59 #endif
60
61
62 #ifdef USE_64BIT
63 # define NEED_COMMON64 1
64 #endif
65
66 #ifdef USE_32BIT
67 # define NEED_COMMON32BI 1
68 #endif
69
70
71 #define SHA3_DELIMITED_SUFFIX 0x06
72 #define SHAKE_DELIMITED_SUFFIX 0x1F
73
74
75 typedef struct
76 {
77   union {
78 #ifdef NEED_COMMON64
79     u64 state64[25];
80 #endif
81 #ifdef NEED_COMMON32BI
82     u32 state32bi[50];
83 #endif
84   } u;
85 } KECCAK_STATE;
86
87
88 typedef struct
89 {
90   unsigned int (*permute)(KECCAK_STATE *hd);
91   unsigned int (*absorb)(KECCAK_STATE *hd, int pos, const byte *lanes,
92                          unsigned int nlanes, int blocklanes);
93   unsigned int (*extract_inplace) (KECCAK_STATE *hd, unsigned int outlen);
94 } keccak_ops_t;
95
96
97 typedef struct KECCAK_CONTEXT_S
98 {
99   KECCAK_STATE state;
100   unsigned int outlen;
101   unsigned int blocksize;
102   unsigned int count;
103   const keccak_ops_t *ops;
104 } KECCAK_CONTEXT;
105
106
107
108 #ifdef NEED_COMMON64
109
110 static const u64 round_consts_64bit[24] =
111 {
112   U64_C(0x0000000000000001), U64_C(0x0000000000008082),
113   U64_C(0x800000000000808A), U64_C(0x8000000080008000),
114   U64_C(0x000000000000808B), U64_C(0x0000000080000001),
115   U64_C(0x8000000080008081), U64_C(0x8000000000008009),
116   U64_C(0x000000000000008A), U64_C(0x0000000000000088),
117   U64_C(0x0000000080008009), U64_C(0x000000008000000A),
118   U64_C(0x000000008000808B), U64_C(0x800000000000008B),
119   U64_C(0x8000000000008089), U64_C(0x8000000000008003),
120   U64_C(0x8000000000008002), U64_C(0x8000000000000080),
121   U64_C(0x000000000000800A), U64_C(0x800000008000000A),
122   U64_C(0x8000000080008081), U64_C(0x8000000000008080),
123   U64_C(0x0000000080000001), U64_C(0x8000000080008008)
124 };
125
126 static unsigned int
127 keccak_extract_inplace64(KECCAK_STATE *hd, unsigned int outlen)
128 {
129   unsigned int i;
130
131   for (i = 0; i < outlen / 8 + !!(outlen % 8); i++)
132     {
133       hd->u.state64[i] = le_bswap64(hd->u.state64[i]);
134     }
135
136   return 0;
137 }
138
139 #endif /* NEED_COMMON64 */
140
141
142 #ifdef NEED_COMMON32BI
143
144 static const u32 round_consts_32bit[2 * 24] =
145 {
146   0x00000001UL, 0x00000000UL, 0x00000000UL, 0x00000089UL,
147   0x00000000UL, 0x8000008bUL, 0x00000000UL, 0x80008080UL,
148   0x00000001UL, 0x0000008bUL, 0x00000001UL, 0x00008000UL,
149   0x00000001UL, 0x80008088UL, 0x00000001UL, 0x80000082UL,
150   0x00000000UL, 0x0000000bUL, 0x00000000UL, 0x0000000aUL,
151   0x00000001UL, 0x00008082UL, 0x00000000UL, 0x00008003UL,
152   0x00000001UL, 0x0000808bUL, 0x00000001UL, 0x8000000bUL,
153   0x00000001UL, 0x8000008aUL, 0x00000001UL, 0x80000081UL,
154   0x00000000UL, 0x80000081UL, 0x00000000UL, 0x80000008UL,
155   0x00000000UL, 0x00000083UL, 0x00000000UL, 0x80008003UL,
156   0x00000001UL, 0x80008088UL, 0x00000000UL, 0x80000088UL,
157   0x00000001UL, 0x00008000UL, 0x00000000UL, 0x80008082UL
158 };
159
160 static unsigned int
161 keccak_extract_inplace32bi(KECCAK_STATE *hd, unsigned int outlen)
162 {
163   unsigned int i;
164   u32 x0;
165   u32 x1;
166   u32 t;
167
168   for (i = 0; i < outlen / 8 + !!(outlen % 8); i++)
169     {
170       x0 = hd->u.state32bi[i * 2 + 0];
171       x1 = hd->u.state32bi[i * 2 + 1];
172
173       t = (x0 & 0x0000FFFFUL) + (x1 << 16);
174       x1 = (x0 >> 16) + (x1 & 0xFFFF0000UL);
175       x0 = t;
176       t = (x0 ^ (x0 >> 8)) & 0x0000FF00UL; x0 = x0 ^ t ^ (t << 8);
177       t = (x0 ^ (x0 >> 4)) & 0x00F000F0UL; x0 = x0 ^ t ^ (t << 4);
178       t = (x0 ^ (x0 >> 2)) & 0x0C0C0C0CUL; x0 = x0 ^ t ^ (t << 2);
179       t = (x0 ^ (x0 >> 1)) & 0x22222222UL; x0 = x0 ^ t ^ (t << 1);
180       t = (x1 ^ (x1 >> 8)) & 0x0000FF00UL; x1 = x1 ^ t ^ (t << 8);
181       t = (x1 ^ (x1 >> 4)) & 0x00F000F0UL; x1 = x1 ^ t ^ (t << 4);
182       t = (x1 ^ (x1 >> 2)) & 0x0C0C0C0CUL; x1 = x1 ^ t ^ (t << 2);
183       t = (x1 ^ (x1 >> 1)) & 0x22222222UL; x1 = x1 ^ t ^ (t << 1);
184
185       hd->u.state32bi[i * 2 + 0] = le_bswap32(x0);
186       hd->u.state32bi[i * 2 + 1] = le_bswap32(x1);
187     }
188
189   return 0;
190 }
191
192 static inline void
193 keccak_absorb_lane32bi(u32 *lane, u32 x0, u32 x1)
194 {
195   u32 t;
196
197   t = (x0 ^ (x0 >> 1)) & 0x22222222UL; x0 = x0 ^ t ^ (t << 1);
198   t = (x0 ^ (x0 >> 2)) & 0x0C0C0C0CUL; x0 = x0 ^ t ^ (t << 2);
199   t = (x0 ^ (x0 >> 4)) & 0x00F000F0UL; x0 = x0 ^ t ^ (t << 4);
200   t = (x0 ^ (x0 >> 8)) & 0x0000FF00UL; x0 = x0 ^ t ^ (t << 8);
201   t = (x1 ^ (x1 >> 1)) & 0x22222222UL; x1 = x1 ^ t ^ (t << 1);
202   t = (x1 ^ (x1 >> 2)) & 0x0C0C0C0CUL; x1 = x1 ^ t ^ (t << 2);
203   t = (x1 ^ (x1 >> 4)) & 0x00F000F0UL; x1 = x1 ^ t ^ (t << 4);
204   t = (x1 ^ (x1 >> 8)) & 0x0000FF00UL; x1 = x1 ^ t ^ (t << 8);
205   lane[0] ^= (x0 & 0x0000FFFFUL) + (x1 << 16);
206   lane[1] ^= (x0 >> 16) + (x1 & 0xFFFF0000UL);
207 }
208
209 #endif /* NEED_COMMON32BI */
210
211
212 /* Construct generic 64-bit implementation. */
213 #ifdef USE_64BIT
214
215 # define ANDN64(x, y) (~(x) & (y))
216 # define ROL64(x, n) (((x) << ((unsigned int)n & 63)) | \
217                       ((x) >> ((64 - (unsigned int)(n)) & 63)))
218
219 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute64
220 # include "keccak_permute_64.h"
221
222 # undef ANDN64
223 # undef ROL64
224 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
225
226 static unsigned int
227 keccak_absorb_lanes64(KECCAK_STATE *hd, int pos, const byte *lanes,
228                       unsigned int nlanes, int blocklanes)
229 {
230   unsigned int burn = 0;
231
232   while (nlanes)
233     {
234       hd->u.state64[pos] ^= buf_get_le64(lanes);
235       lanes += 8;
236       nlanes--;
237
238       if (++pos == blocklanes)
239         {
240           burn = keccak_f1600_state_permute64(hd);
241           pos = 0;
242         }
243     }
244
245   return burn;
246 }
247
248 static const keccak_ops_t keccak_generic64_ops =
249 {
250   .permute = keccak_f1600_state_permute64,
251   .absorb = keccak_absorb_lanes64,
252   .extract_inplace = keccak_extract_inplace64,
253 };
254
255 #endif /* USE_64BIT */
256
257
258 /* Construct 64-bit Intel SHLD implementation. */
259 #ifdef USE_64BIT_SHLD
260
261 # define ANDN64(x, y) (~(x) & (y))
262 # define ROL64(x, n) ({ \
263                         u64 tmp = (x); \
264                         asm ("shldq %1, %0, %0" \
265                              : "+r" (tmp) \
266                              : "J" ((n) & 63) \
267                              : "cc"); \
268                         tmp; })
269
270 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute64_shld
271 # include "keccak_permute_64.h"
272
273 # undef ANDN64
274 # undef ROL64
275 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
276
277 static unsigned int
278 keccak_absorb_lanes64_shld(KECCAK_STATE *hd, int pos, const byte *lanes,
279                            unsigned int nlanes, int blocklanes)
280 {
281   unsigned int burn = 0;
282
283   while (nlanes)
284     {
285       hd->u.state64[pos] ^= buf_get_le64(lanes);
286       lanes += 8;
287       nlanes--;
288
289       if (++pos == blocklanes)
290         {
291           burn = keccak_f1600_state_permute64_shld(hd);
292           pos = 0;
293         }
294     }
295
296   return burn;
297 }
298
299 static const keccak_ops_t keccak_shld_64_ops =
300 {
301   .permute = keccak_f1600_state_permute64_shld,
302   .absorb = keccak_absorb_lanes64_shld,
303   .extract_inplace = keccak_extract_inplace64,
304 };
305
306 #endif /* USE_64BIT_SHLD */
307
308
309 /* Construct 64-bit Intel BMI2 implementation. */
310 #ifdef USE_64BIT_BMI2
311
312 # define ANDN64(x, y) ({ \
313                         u64 tmp; \
314                         asm ("andnq %2, %1, %0" \
315                              : "=r" (tmp) \
316                              : "r0" (x), "rm" (y)); \
317                         tmp; })
318
319 # define ROL64(x, n) ({ \
320                         u64 tmp; \
321                         asm ("rorxq %2, %1, %0" \
322                              : "=r" (tmp) \
323                              : "rm0" (x), "J" (64 - ((n) & 63))); \
324                         tmp; })
325
326 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute64_bmi2
327 # include "keccak_permute_64.h"
328
329 # undef ANDN64
330 # undef ROL64
331 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
332
333 static unsigned int
334 keccak_absorb_lanes64_bmi2(KECCAK_STATE *hd, int pos, const byte *lanes,
335                            unsigned int nlanes, int blocklanes)
336 {
337   unsigned int burn = 0;
338
339   while (nlanes)
340     {
341       hd->u.state64[pos] ^= buf_get_le64(lanes);
342       lanes += 8;
343       nlanes--;
344
345       if (++pos == blocklanes)
346         {
347           burn = keccak_f1600_state_permute64_bmi2(hd);
348           pos = 0;
349         }
350     }
351
352   return burn;
353 }
354
355 static const keccak_ops_t keccak_bmi2_64_ops =
356 {
357   .permute = keccak_f1600_state_permute64_bmi2,
358   .absorb = keccak_absorb_lanes64_bmi2,
359   .extract_inplace = keccak_extract_inplace64,
360 };
361
362 #endif /* USE_64BIT_BMI2 */
363
364
365 /* Construct generic 32-bit implementation. */
366 #ifdef USE_32BIT
367
368 # define ANDN32(x, y) (~(x) & (y))
369 # define ROL32(x, n) (((x) << ((unsigned int)n & 31)) | \
370                       ((x) >> ((32 - (unsigned int)(n)) & 31)))
371
372 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute32bi
373 # include "keccak_permute_32.h"
374
375 # undef ANDN32
376 # undef ROL32
377 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
378
379 static unsigned int
380 keccak_absorb_lanes32bi(KECCAK_STATE *hd, int pos, const byte *lanes,
381                         unsigned int nlanes, int blocklanes)
382 {
383   unsigned int burn = 0;
384
385   while (nlanes)
386     {
387       keccak_absorb_lane32bi(&hd->u.state32bi[pos * 2],
388                              buf_get_le32(lanes + 0),
389                              buf_get_le32(lanes + 4));
390       lanes += 8;
391       nlanes--;
392
393       if (++pos == blocklanes)
394         {
395           burn = keccak_f1600_state_permute32bi(hd);
396           pos = 0;
397         }
398     }
399
400   return burn;
401 }
402
403 static const keccak_ops_t keccak_generic32bi_ops =
404 {
405   .permute = keccak_f1600_state_permute32bi,
406   .absorb = keccak_absorb_lanes32bi,
407   .extract_inplace = keccak_extract_inplace32bi,
408 };
409
410 #endif /* USE_32BIT */
411
412
413 /* Construct 32-bit Intel BMI2 implementation. */
414 #ifdef USE_32BIT_BMI2
415
416 # define ANDN32(x, y) ({ \
417                         u32 tmp; \
418                         asm ("andnl %2, %1, %0" \
419                              : "=r" (tmp) \
420                              : "r0" (x), "rm" (y)); \
421                         tmp; })
422
423 # define ROL32(x, n) ({ \
424                         u32 tmp; \
425                         asm ("rorxl %2, %1, %0" \
426                              : "=r" (tmp) \
427                              : "rm0" (x), "J" (32 - ((n) & 31))); \
428                         tmp; })
429
430 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute32bi_bmi2
431 # include "keccak_permute_32.h"
432
433 # undef ANDN32
434 # undef ROL32
435 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
436
437 static inline u32 pext(u32 x, u32 mask)
438 {
439   u32 tmp;
440   asm ("pextl %2, %1, %0" : "=r" (tmp) : "r0" (x), "rm" (mask));
441   return tmp;
442 }
443
444 static inline u32 pdep(u32 x, u32 mask)
445 {
446   u32 tmp;
447   asm ("pdepl %2, %1, %0" : "=r" (tmp) : "r0" (x), "rm" (mask));
448   return tmp;
449 }
450
451 static inline void
452 keccak_absorb_lane32bi_bmi2(u32 *lane, u32 x0, u32 x1)
453 {
454   x0 = pdep(pext(x0, 0x55555555), 0x0000ffff) | (pext(x0, 0xaaaaaaaa) << 16);
455   x1 = pdep(pext(x1, 0x55555555), 0x0000ffff) | (pext(x1, 0xaaaaaaaa) << 16);
456
457   lane[0] ^= (x0 & 0x0000FFFFUL) + (x1 << 16);
458   lane[1] ^= (x0 >> 16) + (x1 & 0xFFFF0000UL);
459 }
460
461 static unsigned int
462 keccak_absorb_lanes32bi_bmi2(KECCAK_STATE *hd, int pos, const byte *lanes,
463                              unsigned int nlanes, int blocklanes)
464 {
465   unsigned int burn = 0;
466
467   while (nlanes)
468     {
469       keccak_absorb_lane32bi_bmi2(&hd->u.state32bi[pos * 2],
470                                   buf_get_le32(lanes + 0),
471                                   buf_get_le32(lanes + 4));
472       lanes += 8;
473       nlanes--;
474
475       if (++pos == blocklanes)
476         {
477           burn = keccak_f1600_state_permute32bi_bmi2(hd);
478           pos = 0;
479         }
480     }
481
482   return burn;
483 }
484
485 static unsigned int
486 keccak_extract_inplace32bi_bmi2(KECCAK_STATE *hd, unsigned int outlen)
487 {
488   unsigned int i;
489   u32 x0;
490   u32 x1;
491   u32 t;
492
493   for (i = 0; i < outlen / 8 + !!(outlen % 8); i++)
494     {
495       x0 = hd->u.state32bi[i * 2 + 0];
496       x1 = hd->u.state32bi[i * 2 + 1];
497
498       t = (x0 & 0x0000FFFFUL) + (x1 << 16);
499       x1 = (x0 >> 16) + (x1 & 0xFFFF0000UL);
500       x0 = t;
501
502       x0 = pdep(pext(x0, 0xffff0001), 0xaaaaaaab) | pdep(x0 >> 1, 0x55555554);
503       x1 = pdep(pext(x1, 0xffff0001), 0xaaaaaaab) | pdep(x1 >> 1, 0x55555554);
504
505       hd->u.state32bi[i * 2 + 0] = le_bswap32(x0);
506       hd->u.state32bi[i * 2 + 1] = le_bswap32(x1);
507     }
508
509   return 0;
510 }
511
512 static const keccak_ops_t keccak_bmi2_32bi_ops =
513 {
514   .permute = keccak_f1600_state_permute32bi_bmi2,
515   .absorb = keccak_absorb_lanes32bi_bmi2,
516   .extract_inplace = keccak_extract_inplace32bi_bmi2,
517 };
518
519 #endif /* USE_32BIT */
520
521
522 static void
523 keccak_write (void *context, const void *inbuf_arg, size_t inlen)
524 {
525   KECCAK_CONTEXT *ctx = context;
526   const size_t bsize = ctx->blocksize;
527   const size_t blocklanes = bsize / 8;
528   const byte *inbuf = inbuf_arg;
529   unsigned int nburn, burn = 0;
530   unsigned int count, i;
531   unsigned int pos, nlanes;
532
533   count = ctx->count;
534
535   if (inlen && (count % 8))
536     {
537       byte lane[8] = { 0, };
538
539       /* Complete absorbing partial input lane. */
540
541       pos = count / 8;
542
543       for (i = count % 8; inlen && i < 8; i++)
544         {
545           lane[i] = *inbuf++;
546           inlen--;
547           count++;
548         }
549
550       if (count == bsize)
551         count = 0;
552
553       nburn = ctx->ops->absorb(&ctx->state, pos, lane, 1,
554                                (count % 8) ? -1 : blocklanes);
555       burn = nburn > burn ? nburn : burn;
556     }
557
558   /* Absorb full input lanes. */
559
560   pos = count / 8;
561   nlanes = inlen / 8;
562   if (nlanes > 0)
563     {
564       nburn = ctx->ops->absorb(&ctx->state, pos, inbuf, nlanes, blocklanes);
565       burn = nburn > burn ? nburn : burn;
566       inlen -= nlanes * 8;
567       inbuf += nlanes * 8;
568       count += nlanes * 8;
569       count = count % bsize;
570     }
571
572   if (inlen)
573     {
574       byte lane[8] = { 0, };
575
576       /* Absorb remaining partial input lane. */
577
578       pos = count / 8;
579
580       for (i = count % 8; inlen && i < 8; i++)
581         {
582           lane[i] = *inbuf++;
583           inlen--;
584           count++;
585         }
586
587       nburn = ctx->ops->absorb(&ctx->state, pos, lane, 1, -1);
588       burn = nburn > burn ? nburn : burn;
589
590       gcry_assert(count < bsize);
591     }
592
593   ctx->count = count;
594
595   if (burn)
596     _gcry_burn_stack (burn);
597 }
598
599
600 static void
601 keccak_init (int algo, void *context, unsigned int flags)
602 {
603   KECCAK_CONTEXT *ctx = context;
604   KECCAK_STATE *hd = &ctx->state;
605   unsigned int features = _gcry_get_hw_features ();
606
607   (void)flags;
608   (void)features;
609
610   memset (hd, 0, sizeof *hd);
611
612   ctx->count = 0;
613
614   /* Select generic implementation. */
615 #ifdef USE_64BIT
616   ctx->ops = &keccak_generic64_ops;
617 #elif defined USE_32BIT
618   ctx->ops = &keccak_generic32bi_ops;
619 #endif
620
621   /* Select optimized implementation based in hw features. */
622   if (0) {}
623 #ifdef USE_64BIT_BMI2
624   else if (features & HWF_INTEL_BMI2)
625     ctx->ops = &keccak_bmi2_64_ops;
626 #endif
627 #ifdef USE_32BIT_BMI2
628   else if (features & HWF_INTEL_BMI2)
629     ctx->ops = &keccak_bmi2_32bi_ops;
630 #endif
631 #ifdef USE_64BIT_SHLD
632   else if (features & HWF_INTEL_FAST_SHLD)
633     ctx->ops = &keccak_shld_64_ops;
634 #endif
635
636   /* Set input block size, in Keccak terms this is called 'rate'. */
637
638   switch (algo)
639     {
640     case GCRY_MD_SHA3_224:
641       ctx->blocksize = 1152 / 8;
642       ctx->outlen = 224 / 8;
643       break;
644     case GCRY_MD_SHA3_256:
645       ctx->blocksize = 1088 / 8;
646       ctx->outlen = 256 / 8;
647       break;
648     case GCRY_MD_SHA3_384:
649       ctx->blocksize = 832 / 8;
650       ctx->outlen = 384 / 8;
651       break;
652     case GCRY_MD_SHA3_512:
653       ctx->blocksize = 576 / 8;
654       ctx->outlen = 512 / 8;
655       break;
656     default:
657       BUG();
658     }
659 }
660
661 static void
662 sha3_224_init (void *context, unsigned int flags)
663 {
664   keccak_init (GCRY_MD_SHA3_224, context, flags);
665 }
666
667 static void
668 sha3_256_init (void *context, unsigned int flags)
669 {
670   keccak_init (GCRY_MD_SHA3_256, context, flags);
671 }
672
673 static void
674 sha3_384_init (void *context, unsigned int flags)
675 {
676   keccak_init (GCRY_MD_SHA3_384, context, flags);
677 }
678
679 static void
680 sha3_512_init (void *context, unsigned int flags)
681 {
682   keccak_init (GCRY_MD_SHA3_512, context, flags);
683 }
684
685
686 /* The routine final terminates the computation and
687  * returns the digest.
688  * The handle is prepared for a new cycle, but adding bytes to the
689  * handle will the destroy the returned buffer.
690  * Returns: 64 bytes representing the digest.  When used for sha384,
691  * we take the leftmost 48 of those bytes.
692  */
693 static void
694 keccak_final (void *context)
695 {
696   KECCAK_CONTEXT *ctx = context;
697   KECCAK_STATE *hd = &ctx->state;
698   const size_t bsize = ctx->blocksize;
699   const byte suffix = SHA3_DELIMITED_SUFFIX;
700   unsigned int nburn, burn = 0;
701   unsigned int lastbytes;
702   byte lane[8];
703
704   lastbytes = ctx->count;
705
706   /* Do the padding and switch to the squeezing phase */
707
708   /* Absorb the last few bits and add the first bit of padding (which
709      coincides with the delimiter in delimited suffix) */
710   buf_put_le64(lane, (u64)suffix << ((lastbytes % 8) * 8));
711   nburn = ctx->ops->absorb(&ctx->state, lastbytes / 8, lane, 1, -1);
712   burn = nburn > burn ? nburn : burn;
713
714   /* Add the second bit of padding. */
715   buf_put_le64(lane, (u64)0x80 << (((bsize - 1) % 8) * 8));
716   nburn = ctx->ops->absorb(&ctx->state, (bsize - 1) / 8, lane, 1, -1);
717   burn = nburn > burn ? nburn : burn;
718
719   /* Switch to the squeezing phase. */
720   nburn = ctx->ops->permute(hd);
721   burn = nburn > burn ? nburn : burn;
722
723   /* Squeeze out all the output blocks */
724   if (ctx->outlen < bsize)
725     {
726       /* Output SHA3 digest. */
727       nburn = ctx->ops->extract_inplace(hd, ctx->outlen);
728       burn = nburn > burn ? nburn : burn;
729     }
730   else
731     {
732       /* Output SHAKE digest. */
733       BUG();
734     }
735
736   wipememory(lane, sizeof(lane));
737   if (burn)
738     _gcry_burn_stack (burn);
739 }
740
741
742 static byte *
743 keccak_read (void *context)
744 {
745   KECCAK_CONTEXT *ctx = (KECCAK_CONTEXT *) context;
746   KECCAK_STATE *hd = &ctx->state;
747   return (byte *)&hd->u;
748 }
749
750
751 \f
752 /*
753      Self-test section.
754  */
755
756
757 static gpg_err_code_t
758 selftests_keccak (int algo, int extended, selftest_report_func_t report)
759 {
760   const char *what;
761   const char *errtxt;
762   const char *short_hash;
763   const char *long_hash;
764   const char *one_million_a_hash;
765   int hash_len;
766
767   switch (algo)
768   {
769     default:
770       BUG();
771
772     case GCRY_MD_SHA3_224:
773       short_hash =
774         "\xe6\x42\x82\x4c\x3f\x8c\xf2\x4a\xd0\x92\x34\xee\x7d\x3c\x76\x6f"
775         "\xc9\xa3\xa5\x16\x8d\x0c\x94\xad\x73\xb4\x6f\xdf";
776       long_hash =
777         "\x54\x3e\x68\x68\xe1\x66\x6c\x1a\x64\x36\x30\xdf\x77\x36\x7a\xe5"
778         "\xa6\x2a\x85\x07\x0a\x51\xc1\x4c\xbf\x66\x5c\xbc";
779       one_million_a_hash =
780         "\xd6\x93\x35\xb9\x33\x25\x19\x2e\x51\x6a\x91\x2e\x6d\x19\xa1\x5c"
781         "\xb5\x1c\x6e\xd5\xc1\x52\x43\xe7\xa7\xfd\x65\x3c";
782       hash_len = 28;
783       break;
784
785     case GCRY_MD_SHA3_256:
786       short_hash =
787         "\x3a\x98\x5d\xa7\x4f\xe2\x25\xb2\x04\x5c\x17\x2d\x6b\xd3\x90\xbd"
788         "\x85\x5f\x08\x6e\x3e\x9d\x52\x5b\x46\xbf\xe2\x45\x11\x43\x15\x32";
789       long_hash =
790         "\x91\x6f\x60\x61\xfe\x87\x97\x41\xca\x64\x69\xb4\x39\x71\xdf\xdb"
791         "\x28\xb1\xa3\x2d\xc3\x6c\xb3\x25\x4e\x81\x2b\xe2\x7a\xad\x1d\x18";
792       one_million_a_hash =
793         "\x5c\x88\x75\xae\x47\x4a\x36\x34\xba\x4f\xd5\x5e\xc8\x5b\xff\xd6"
794         "\x61\xf3\x2a\xca\x75\xc6\xd6\x99\xd0\xcd\xcb\x6c\x11\x58\x91\xc1";
795       hash_len = 32;
796       break;
797
798     case GCRY_MD_SHA3_384:
799       short_hash =
800         "\xec\x01\x49\x82\x88\x51\x6f\xc9\x26\x45\x9f\x58\xe2\xc6\xad\x8d"
801         "\xf9\xb4\x73\xcb\x0f\xc0\x8c\x25\x96\xda\x7c\xf0\xe4\x9b\xe4\xb2"
802         "\x98\xd8\x8c\xea\x92\x7a\xc7\xf5\x39\xf1\xed\xf2\x28\x37\x6d\x25";
803       long_hash =
804         "\x79\x40\x7d\x3b\x59\x16\xb5\x9c\x3e\x30\xb0\x98\x22\x97\x47\x91"
805         "\xc3\x13\xfb\x9e\xcc\x84\x9e\x40\x6f\x23\x59\x2d\x04\xf6\x25\xdc"
806         "\x8c\x70\x9b\x98\xb4\x3b\x38\x52\xb3\x37\x21\x61\x79\xaa\x7f\xc7";
807       one_million_a_hash =
808         "\xee\xe9\xe2\x4d\x78\xc1\x85\x53\x37\x98\x34\x51\xdf\x97\xc8\xad"
809         "\x9e\xed\xf2\x56\xc6\x33\x4f\x8e\x94\x8d\x25\x2d\x5e\x0e\x76\x84"
810         "\x7a\xa0\x77\x4d\xdb\x90\xa8\x42\x19\x0d\x2c\x55\x8b\x4b\x83\x40";
811       hash_len = 48;
812       break;
813
814     case GCRY_MD_SHA3_512:
815       short_hash =
816         "\xb7\x51\x85\x0b\x1a\x57\x16\x8a\x56\x93\xcd\x92\x4b\x6b\x09\x6e"
817         "\x08\xf6\x21\x82\x74\x44\xf7\x0d\x88\x4f\x5d\x02\x40\xd2\x71\x2e"
818         "\x10\xe1\x16\xe9\x19\x2a\xf3\xc9\x1a\x7e\xc5\x76\x47\xe3\x93\x40"
819         "\x57\x34\x0b\x4c\xf4\x08\xd5\xa5\x65\x92\xf8\x27\x4e\xec\x53\xf0";
820       long_hash =
821         "\xaf\xeb\xb2\xef\x54\x2e\x65\x79\xc5\x0c\xad\x06\xd2\xe5\x78\xf9"
822         "\xf8\xdd\x68\x81\xd7\xdc\x82\x4d\x26\x36\x0f\xee\xbf\x18\xa4\xfa"
823         "\x73\xe3\x26\x11\x22\x94\x8e\xfc\xfd\x49\x2e\x74\xe8\x2e\x21\x89"
824         "\xed\x0f\xb4\x40\xd1\x87\xf3\x82\x27\x0c\xb4\x55\xf2\x1d\xd1\x85";
825       one_million_a_hash =
826         "\x3c\x3a\x87\x6d\xa1\x40\x34\xab\x60\x62\x7c\x07\x7b\xb9\x8f\x7e"
827         "\x12\x0a\x2a\x53\x70\x21\x2d\xff\xb3\x38\x5a\x18\xd4\xf3\x88\x59"
828         "\xed\x31\x1d\x0a\x9d\x51\x41\xce\x9c\xc5\xc6\x6e\xe6\x89\xb2\x66"
829         "\xa8\xaa\x18\xac\xe8\x28\x2a\x0e\x0d\xb5\x96\xc9\x0b\x0a\x7b\x87";
830       hash_len = 64;
831       break;
832   }
833
834   what = "short string";
835   errtxt = _gcry_hash_selftest_check_one (algo, 0, "abc", 3, short_hash,
836                                           hash_len);
837   if (errtxt)
838     goto failed;
839
840   if (extended)
841     {
842       what = "long string";
843       errtxt = _gcry_hash_selftest_check_one
844         (algo, 0,
845         "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
846         "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 112,
847         long_hash, hash_len);
848       if (errtxt)
849         goto failed;
850
851       what = "one million \"a\"";
852       errtxt = _gcry_hash_selftest_check_one (algo, 1, NULL, 0,
853                                               one_million_a_hash, hash_len);
854       if (errtxt)
855         goto failed;
856     }
857
858   return 0; /* Succeeded. */
859
860 failed:
861   if (report)
862     report ("digest", algo, what, errtxt);
863   return GPG_ERR_SELFTEST_FAILED;
864 }
865
866
867 /* Run a full self-test for ALGO and return 0 on success.  */
868 static gpg_err_code_t
869 run_selftests (int algo, int extended, selftest_report_func_t report)
870 {
871   gpg_err_code_t ec;
872
873   switch (algo)
874     {
875     case GCRY_MD_SHA3_224:
876     case GCRY_MD_SHA3_256:
877     case GCRY_MD_SHA3_384:
878     case GCRY_MD_SHA3_512:
879       ec = selftests_keccak (algo, extended, report);
880       break;
881     default:
882       ec = GPG_ERR_DIGEST_ALGO;
883       break;
884     }
885
886   return ec;
887 }
888
889
890
891 \f
892 static byte sha3_224_asn[] = { 0x30 };
893 static gcry_md_oid_spec_t oid_spec_sha3_224[] =
894   {
895     { "2.16.840.1.101.3.4.2.7" },
896     /* PKCS#1 sha3_224WithRSAEncryption */
897     { "?" },
898     { NULL }
899   };
900 static byte sha3_256_asn[] = { 0x30 };
901 static gcry_md_oid_spec_t oid_spec_sha3_256[] =
902   {
903     { "2.16.840.1.101.3.4.2.8" },
904     /* PKCS#1 sha3_256WithRSAEncryption */
905     { "?" },
906     { NULL }
907   };
908 static byte sha3_384_asn[] = { 0x30 };
909 static gcry_md_oid_spec_t oid_spec_sha3_384[] =
910   {
911     { "2.16.840.1.101.3.4.2.9" },
912     /* PKCS#1 sha3_384WithRSAEncryption */
913     { "?" },
914     { NULL }
915   };
916 static byte sha3_512_asn[] = { 0x30 };
917 static gcry_md_oid_spec_t oid_spec_sha3_512[] =
918   {
919     { "2.16.840.1.101.3.4.2.10" },
920     /* PKCS#1 sha3_512WithRSAEncryption */
921     { "?" },
922     { NULL }
923   };
924
925
926 gcry_md_spec_t _gcry_digest_spec_sha3_224 =
927   {
928     GCRY_MD_SHA3_224, {0, 1},
929     "SHA3-224", sha3_224_asn, DIM (sha3_224_asn), oid_spec_sha3_224, 28,
930     sha3_224_init, keccak_write, keccak_final, keccak_read, NULL,
931     sizeof (KECCAK_CONTEXT),
932     run_selftests
933   };
934 gcry_md_spec_t _gcry_digest_spec_sha3_256 =
935   {
936     GCRY_MD_SHA3_256, {0, 1},
937     "SHA3-256", sha3_256_asn, DIM (sha3_256_asn), oid_spec_sha3_256, 32,
938     sha3_256_init, keccak_write, keccak_final, keccak_read, NULL,
939     sizeof (KECCAK_CONTEXT),
940     run_selftests
941   };
942 gcry_md_spec_t _gcry_digest_spec_sha3_384 =
943   {
944     GCRY_MD_SHA3_384, {0, 1},
945     "SHA3-384", sha3_384_asn, DIM (sha3_384_asn), oid_spec_sha3_384, 48,
946     sha3_384_init, keccak_write, keccak_final, keccak_read, NULL,
947     sizeof (KECCAK_CONTEXT),
948     run_selftests
949   };
950 gcry_md_spec_t _gcry_digest_spec_sha3_512 =
951   {
952     GCRY_MD_SHA3_512, {0, 1},
953     "SHA3-512", sha3_512_asn, DIM (sha3_512_asn), oid_spec_sha3_512, 64,
954     sha3_512_init, keccak_write, keccak_final, keccak_read, NULL,
955     sizeof (KECCAK_CONTEXT),
956     run_selftests
957   };