doc: Fix typo.
[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 /* USE_64BIT_ARM_NEON indicates whether to enable 64-bit ARM/NEON assembly
63  * code. */
64 #undef USE_64BIT_ARM_NEON
65 #ifdef ENABLE_NEON_SUPPORT
66 # if defined(HAVE_ARM_ARCH_V6) && defined(__ARMEL__) \
67      && defined(HAVE_COMPATIBLE_GCC_ARM_PLATFORM_AS) \
68      && defined(HAVE_GCC_INLINE_ASM_NEON)
69 #  define USE_64BIT_ARM_NEON 1
70 # endif
71 #endif /*ENABLE_NEON_SUPPORT*/
72
73
74 #if defined(USE_64BIT) || defined(USE_64BIT_ARM_NEON)
75 # define NEED_COMMON64 1
76 #endif
77
78 #ifdef USE_32BIT
79 # define NEED_COMMON32BI 1
80 #endif
81
82
83 #define SHA3_DELIMITED_SUFFIX 0x06
84 #define SHAKE_DELIMITED_SUFFIX 0x1F
85
86
87 typedef struct
88 {
89   union {
90 #ifdef NEED_COMMON64
91     u64 state64[25];
92 #endif
93 #ifdef NEED_COMMON32BI
94     u32 state32bi[50];
95 #endif
96   } u;
97 } KECCAK_STATE;
98
99
100 typedef struct
101 {
102   unsigned int (*permute)(KECCAK_STATE *hd);
103   unsigned int (*absorb)(KECCAK_STATE *hd, int pos, const byte *lanes,
104                          unsigned int nlanes, int blocklanes);
105   unsigned int (*extract) (KECCAK_STATE *hd, unsigned int pos, byte *outbuf,
106                            unsigned int outlen);
107 } keccak_ops_t;
108
109
110 typedef struct KECCAK_CONTEXT_S
111 {
112   KECCAK_STATE state;
113   unsigned int outlen;
114   unsigned int blocksize;
115   unsigned int count;
116   unsigned int suffix;
117   const keccak_ops_t *ops;
118 } KECCAK_CONTEXT;
119
120
121
122 #ifdef NEED_COMMON64
123
124 const u64 _gcry_keccak_round_consts_64bit[24 + 1] =
125 {
126   U64_C(0x0000000000000001), U64_C(0x0000000000008082),
127   U64_C(0x800000000000808A), U64_C(0x8000000080008000),
128   U64_C(0x000000000000808B), U64_C(0x0000000080000001),
129   U64_C(0x8000000080008081), U64_C(0x8000000000008009),
130   U64_C(0x000000000000008A), U64_C(0x0000000000000088),
131   U64_C(0x0000000080008009), U64_C(0x000000008000000A),
132   U64_C(0x000000008000808B), U64_C(0x800000000000008B),
133   U64_C(0x8000000000008089), U64_C(0x8000000000008003),
134   U64_C(0x8000000000008002), U64_C(0x8000000000000080),
135   U64_C(0x000000000000800A), U64_C(0x800000008000000A),
136   U64_C(0x8000000080008081), U64_C(0x8000000000008080),
137   U64_C(0x0000000080000001), U64_C(0x8000000080008008),
138   U64_C(0xFFFFFFFFFFFFFFFF)
139 };
140
141 static unsigned int
142 keccak_extract64(KECCAK_STATE *hd, unsigned int pos, byte *outbuf,
143                  unsigned int outlen)
144 {
145   unsigned int i;
146
147   /* NOTE: when pos == 0, hd and outbuf may point to same memory (SHA-3). */
148
149   for (i = pos; i < pos + outlen / 8 + !!(outlen % 8); i++)
150     {
151       u64 tmp = hd->u.state64[i];
152       buf_put_le64(outbuf, tmp);
153       outbuf += 8;
154     }
155
156   return 0;
157 }
158
159 #endif /* NEED_COMMON64 */
160
161
162 #ifdef NEED_COMMON32BI
163
164 static const u32 round_consts_32bit[2 * 24] =
165 {
166   0x00000001UL, 0x00000000UL, 0x00000000UL, 0x00000089UL,
167   0x00000000UL, 0x8000008bUL, 0x00000000UL, 0x80008080UL,
168   0x00000001UL, 0x0000008bUL, 0x00000001UL, 0x00008000UL,
169   0x00000001UL, 0x80008088UL, 0x00000001UL, 0x80000082UL,
170   0x00000000UL, 0x0000000bUL, 0x00000000UL, 0x0000000aUL,
171   0x00000001UL, 0x00008082UL, 0x00000000UL, 0x00008003UL,
172   0x00000001UL, 0x0000808bUL, 0x00000001UL, 0x8000000bUL,
173   0x00000001UL, 0x8000008aUL, 0x00000001UL, 0x80000081UL,
174   0x00000000UL, 0x80000081UL, 0x00000000UL, 0x80000008UL,
175   0x00000000UL, 0x00000083UL, 0x00000000UL, 0x80008003UL,
176   0x00000001UL, 0x80008088UL, 0x00000000UL, 0x80000088UL,
177   0x00000001UL, 0x00008000UL, 0x00000000UL, 0x80008082UL
178 };
179
180 static unsigned int
181 keccak_extract32bi(KECCAK_STATE *hd, unsigned int pos, byte *outbuf,
182                    unsigned int outlen)
183 {
184   unsigned int i;
185   u32 x0;
186   u32 x1;
187   u32 t;
188
189   /* NOTE: when pos == 0, hd and outbuf may point to same memory (SHA-3). */
190
191   for (i = pos; i < pos + outlen / 8 + !!(outlen % 8); i++)
192     {
193       x0 = hd->u.state32bi[i * 2 + 0];
194       x1 = hd->u.state32bi[i * 2 + 1];
195
196       t = (x0 & 0x0000FFFFUL) + (x1 << 16);
197       x1 = (x0 >> 16) + (x1 & 0xFFFF0000UL);
198       x0 = t;
199       t = (x0 ^ (x0 >> 8)) & 0x0000FF00UL; x0 = x0 ^ t ^ (t << 8);
200       t = (x0 ^ (x0 >> 4)) & 0x00F000F0UL; x0 = x0 ^ t ^ (t << 4);
201       t = (x0 ^ (x0 >> 2)) & 0x0C0C0C0CUL; x0 = x0 ^ t ^ (t << 2);
202       t = (x0 ^ (x0 >> 1)) & 0x22222222UL; x0 = x0 ^ t ^ (t << 1);
203       t = (x1 ^ (x1 >> 8)) & 0x0000FF00UL; x1 = x1 ^ t ^ (t << 8);
204       t = (x1 ^ (x1 >> 4)) & 0x00F000F0UL; x1 = x1 ^ t ^ (t << 4);
205       t = (x1 ^ (x1 >> 2)) & 0x0C0C0C0CUL; x1 = x1 ^ t ^ (t << 2);
206       t = (x1 ^ (x1 >> 1)) & 0x22222222UL; x1 = x1 ^ t ^ (t << 1);
207
208       buf_put_le32(&outbuf[0], x0);
209       buf_put_le32(&outbuf[4], x1);
210       outbuf += 8;
211     }
212
213   return 0;
214 }
215
216 static inline void
217 keccak_absorb_lane32bi(u32 *lane, u32 x0, u32 x1)
218 {
219   u32 t;
220
221   t = (x0 ^ (x0 >> 1)) & 0x22222222UL; x0 = x0 ^ t ^ (t << 1);
222   t = (x0 ^ (x0 >> 2)) & 0x0C0C0C0CUL; x0 = x0 ^ t ^ (t << 2);
223   t = (x0 ^ (x0 >> 4)) & 0x00F000F0UL; x0 = x0 ^ t ^ (t << 4);
224   t = (x0 ^ (x0 >> 8)) & 0x0000FF00UL; x0 = x0 ^ t ^ (t << 8);
225   t = (x1 ^ (x1 >> 1)) & 0x22222222UL; x1 = x1 ^ t ^ (t << 1);
226   t = (x1 ^ (x1 >> 2)) & 0x0C0C0C0CUL; x1 = x1 ^ t ^ (t << 2);
227   t = (x1 ^ (x1 >> 4)) & 0x00F000F0UL; x1 = x1 ^ t ^ (t << 4);
228   t = (x1 ^ (x1 >> 8)) & 0x0000FF00UL; x1 = x1 ^ t ^ (t << 8);
229   lane[0] ^= (x0 & 0x0000FFFFUL) + (x1 << 16);
230   lane[1] ^= (x0 >> 16) + (x1 & 0xFFFF0000UL);
231 }
232
233 #endif /* NEED_COMMON32BI */
234
235
236 /* Construct generic 64-bit implementation. */
237 #ifdef USE_64BIT
238
239 #if __GNUC__ >= 4 && defined(__x86_64__)
240
241 static inline void absorb_lanes64_8(u64 *dst, const byte *in)
242 {
243   asm ("movdqu 0*16(%[dst]), %%xmm0\n\t"
244        "movdqu 0*16(%[in]), %%xmm4\n\t"
245        "movdqu 1*16(%[dst]), %%xmm1\n\t"
246        "movdqu 1*16(%[in]), %%xmm5\n\t"
247        "movdqu 2*16(%[dst]), %%xmm2\n\t"
248        "movdqu 3*16(%[dst]), %%xmm3\n\t"
249        "pxor %%xmm4, %%xmm0\n\t"
250        "pxor %%xmm5, %%xmm1\n\t"
251        "movdqu 2*16(%[in]), %%xmm4\n\t"
252        "movdqu 3*16(%[in]), %%xmm5\n\t"
253        "movdqu %%xmm0, 0*16(%[dst])\n\t"
254        "pxor %%xmm4, %%xmm2\n\t"
255        "movdqu %%xmm1, 1*16(%[dst])\n\t"
256        "pxor %%xmm5, %%xmm3\n\t"
257        "movdqu %%xmm2, 2*16(%[dst])\n\t"
258        "movdqu %%xmm3, 3*16(%[dst])\n\t"
259        :
260        : [dst] "r" (dst), [in] "r" (in)
261        : "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "memory");
262 }
263
264 static inline void absorb_lanes64_4(u64 *dst, const byte *in)
265 {
266   asm ("movdqu 0*16(%[dst]), %%xmm0\n\t"
267        "movdqu 0*16(%[in]), %%xmm4\n\t"
268        "movdqu 1*16(%[dst]), %%xmm1\n\t"
269        "movdqu 1*16(%[in]), %%xmm5\n\t"
270        "pxor %%xmm4, %%xmm0\n\t"
271        "pxor %%xmm5, %%xmm1\n\t"
272        "movdqu %%xmm0, 0*16(%[dst])\n\t"
273        "movdqu %%xmm1, 1*16(%[dst])\n\t"
274        :
275        : [dst] "r" (dst), [in] "r" (in)
276        : "xmm0", "xmm1", "xmm4", "xmm5", "memory");
277 }
278
279 static inline void absorb_lanes64_2(u64 *dst, const byte *in)
280 {
281   asm ("movdqu 0*16(%[dst]), %%xmm0\n\t"
282        "movdqu 0*16(%[in]), %%xmm4\n\t"
283        "pxor %%xmm4, %%xmm0\n\t"
284        "movdqu %%xmm0, 0*16(%[dst])\n\t"
285        :
286        : [dst] "r" (dst), [in] "r" (in)
287        : "xmm0", "xmm4", "memory");
288 }
289
290 #else /* __x86_64__ */
291
292 static inline void absorb_lanes64_8(u64 *dst, const byte *in)
293 {
294   dst[0] ^= buf_get_le64(in + 8 * 0);
295   dst[1] ^= buf_get_le64(in + 8 * 1);
296   dst[2] ^= buf_get_le64(in + 8 * 2);
297   dst[3] ^= buf_get_le64(in + 8 * 3);
298   dst[4] ^= buf_get_le64(in + 8 * 4);
299   dst[5] ^= buf_get_le64(in + 8 * 5);
300   dst[6] ^= buf_get_le64(in + 8 * 6);
301   dst[7] ^= buf_get_le64(in + 8 * 7);
302 }
303
304 static inline void absorb_lanes64_4(u64 *dst, const byte *in)
305 {
306   dst[0] ^= buf_get_le64(in + 8 * 0);
307   dst[1] ^= buf_get_le64(in + 8 * 1);
308   dst[2] ^= buf_get_le64(in + 8 * 2);
309   dst[3] ^= buf_get_le64(in + 8 * 3);
310 }
311
312 static inline void absorb_lanes64_2(u64 *dst, const byte *in)
313 {
314   dst[0] ^= buf_get_le64(in + 8 * 0);
315   dst[1] ^= buf_get_le64(in + 8 * 1);
316 }
317
318 #endif /* !__x86_64__ */
319
320 static inline void absorb_lanes64_1(u64 *dst, const byte *in)
321 {
322   dst[0] ^= buf_get_le64(in + 8 * 0);
323 }
324
325
326 # define ANDN64(x, y) (~(x) & (y))
327 # define ROL64(x, n) (((x) << ((unsigned int)n & 63)) | \
328                       ((x) >> ((64 - (unsigned int)(n)) & 63)))
329
330 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute64
331 # define KECCAK_F1600_ABSORB_FUNC_NAME keccak_absorb_lanes64
332 # include "keccak_permute_64.h"
333
334 # undef ANDN64
335 # undef ROL64
336 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
337 # undef KECCAK_F1600_ABSORB_FUNC_NAME
338
339 static const keccak_ops_t keccak_generic64_ops =
340 {
341   .permute = keccak_f1600_state_permute64,
342   .absorb = keccak_absorb_lanes64,
343   .extract = keccak_extract64,
344 };
345
346 #endif /* USE_64BIT */
347
348
349 /* Construct 64-bit Intel SHLD implementation. */
350 #ifdef USE_64BIT_SHLD
351
352 # define ANDN64(x, y) (~(x) & (y))
353 # define ROL64(x, n) ({ \
354                         u64 tmp = (x); \
355                         asm ("shldq %1, %0, %0" \
356                              : "+r" (tmp) \
357                              : "J" ((n) & 63) \
358                              : "cc"); \
359                         tmp; })
360
361 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute64_shld
362 # define KECCAK_F1600_ABSORB_FUNC_NAME keccak_absorb_lanes64_shld
363 # include "keccak_permute_64.h"
364
365 # undef ANDN64
366 # undef ROL64
367 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
368 # undef KECCAK_F1600_ABSORB_FUNC_NAME
369
370 static const keccak_ops_t keccak_shld_64_ops =
371 {
372   .permute = keccak_f1600_state_permute64_shld,
373   .absorb = keccak_absorb_lanes64_shld,
374   .extract = keccak_extract64,
375 };
376
377 #endif /* USE_64BIT_SHLD */
378
379
380 /* Construct 64-bit Intel BMI2 implementation. */
381 #ifdef USE_64BIT_BMI2
382
383 # define ANDN64(x, y) ({ \
384                         u64 tmp; \
385                         asm ("andnq %2, %1, %0" \
386                              : "=r" (tmp) \
387                              : "r0" (x), "rm" (y)); \
388                         tmp; })
389
390 # define ROL64(x, n) ({ \
391                         u64 tmp; \
392                         asm ("rorxq %2, %1, %0" \
393                              : "=r" (tmp) \
394                              : "rm0" (x), "J" (64 - ((n) & 63))); \
395                         tmp; })
396
397 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute64_bmi2
398 # define KECCAK_F1600_ABSORB_FUNC_NAME keccak_absorb_lanes64_bmi2
399 # include "keccak_permute_64.h"
400
401 # undef ANDN64
402 # undef ROL64
403 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
404 # undef KECCAK_F1600_ABSORB_FUNC_NAME
405
406 static const keccak_ops_t keccak_bmi2_64_ops =
407 {
408   .permute = keccak_f1600_state_permute64_bmi2,
409   .absorb = keccak_absorb_lanes64_bmi2,
410   .extract = keccak_extract64,
411 };
412
413 #endif /* USE_64BIT_BMI2 */
414
415
416 /* 64-bit ARMv7/NEON implementation. */
417 #ifdef USE_64BIT_ARM_NEON
418
419 unsigned int _gcry_keccak_permute_armv7_neon(u64 *state);
420 unsigned int _gcry_keccak_absorb_lanes64_armv7_neon(u64 *state, int pos,
421                                                     const byte *lanes,
422                                                     unsigned int nlanes,
423                                                     int blocklanes);
424
425 static unsigned int keccak_permute64_armv7_neon(KECCAK_STATE *hd)
426 {
427   return _gcry_keccak_permute_armv7_neon(hd->u.state64);
428 }
429
430 static unsigned int
431 keccak_absorb_lanes64_armv7_neon(KECCAK_STATE *hd, int pos, const byte *lanes,
432                                  unsigned int nlanes, int blocklanes)
433 {
434   if (blocklanes < 0)
435     {
436       /* blocklanes == -1, permutationless absorb from keccak_final. */
437
438       while (nlanes)
439         {
440           hd->u.state64[pos] ^= buf_get_le64(lanes);
441           lanes += 8;
442           nlanes--;
443         }
444
445       return 0;
446     }
447   else
448     {
449       return _gcry_keccak_absorb_lanes64_armv7_neon(hd->u.state64, pos, lanes,
450                                                     nlanes, blocklanes);
451     }
452 }
453
454 static const keccak_ops_t keccak_armv7_neon_64_ops =
455 {
456   .permute = keccak_permute64_armv7_neon,
457   .absorb = keccak_absorb_lanes64_armv7_neon,
458   .extract = keccak_extract64,
459 };
460
461 #endif /* USE_64BIT_ARM_NEON */
462
463
464 /* Construct generic 32-bit implementation. */
465 #ifdef USE_32BIT
466
467 # define ANDN32(x, y) (~(x) & (y))
468 # define ROL32(x, n) (((x) << ((unsigned int)n & 31)) | \
469                       ((x) >> ((32 - (unsigned int)(n)) & 31)))
470
471 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute32bi
472 # include "keccak_permute_32.h"
473
474 # undef ANDN32
475 # undef ROL32
476 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
477
478 static unsigned int
479 keccak_absorb_lanes32bi(KECCAK_STATE *hd, int pos, const byte *lanes,
480                         unsigned int nlanes, int blocklanes)
481 {
482   unsigned int burn = 0;
483
484   while (nlanes)
485     {
486       keccak_absorb_lane32bi(&hd->u.state32bi[pos * 2],
487                              buf_get_le32(lanes + 0),
488                              buf_get_le32(lanes + 4));
489       lanes += 8;
490       nlanes--;
491
492       if (++pos == blocklanes)
493         {
494           burn = keccak_f1600_state_permute32bi(hd);
495           pos = 0;
496         }
497     }
498
499   return burn;
500 }
501
502 static const keccak_ops_t keccak_generic32bi_ops =
503 {
504   .permute = keccak_f1600_state_permute32bi,
505   .absorb = keccak_absorb_lanes32bi,
506   .extract = keccak_extract32bi,
507 };
508
509 #endif /* USE_32BIT */
510
511
512 /* Construct 32-bit Intel BMI2 implementation. */
513 #ifdef USE_32BIT_BMI2
514
515 # define ANDN32(x, y) ({ \
516                         u32 tmp; \
517                         asm ("andnl %2, %1, %0" \
518                              : "=r" (tmp) \
519                              : "r0" (x), "rm" (y)); \
520                         tmp; })
521
522 # define ROL32(x, n) ({ \
523                         u32 tmp; \
524                         asm ("rorxl %2, %1, %0" \
525                              : "=r" (tmp) \
526                              : "rm0" (x), "J" (32 - ((n) & 31))); \
527                         tmp; })
528
529 # define KECCAK_F1600_PERMUTE_FUNC_NAME keccak_f1600_state_permute32bi_bmi2
530 # include "keccak_permute_32.h"
531
532 # undef ANDN32
533 # undef ROL32
534 # undef KECCAK_F1600_PERMUTE_FUNC_NAME
535
536 static inline u32 pext(u32 x, u32 mask)
537 {
538   u32 tmp;
539   asm ("pextl %2, %1, %0" : "=r" (tmp) : "r0" (x), "rm" (mask));
540   return tmp;
541 }
542
543 static inline u32 pdep(u32 x, u32 mask)
544 {
545   u32 tmp;
546   asm ("pdepl %2, %1, %0" : "=r" (tmp) : "r0" (x), "rm" (mask));
547   return tmp;
548 }
549
550 static inline void
551 keccak_absorb_lane32bi_bmi2(u32 *lane, u32 x0, u32 x1)
552 {
553   x0 = pdep(pext(x0, 0x55555555), 0x0000ffff) | (pext(x0, 0xaaaaaaaa) << 16);
554   x1 = pdep(pext(x1, 0x55555555), 0x0000ffff) | (pext(x1, 0xaaaaaaaa) << 16);
555
556   lane[0] ^= (x0 & 0x0000FFFFUL) + (x1 << 16);
557   lane[1] ^= (x0 >> 16) + (x1 & 0xFFFF0000UL);
558 }
559
560 static unsigned int
561 keccak_absorb_lanes32bi_bmi2(KECCAK_STATE *hd, int pos, const byte *lanes,
562                              unsigned int nlanes, int blocklanes)
563 {
564   unsigned int burn = 0;
565
566   while (nlanes)
567     {
568       keccak_absorb_lane32bi_bmi2(&hd->u.state32bi[pos * 2],
569                                   buf_get_le32(lanes + 0),
570                                   buf_get_le32(lanes + 4));
571       lanes += 8;
572       nlanes--;
573
574       if (++pos == blocklanes)
575         {
576           burn = keccak_f1600_state_permute32bi_bmi2(hd);
577           pos = 0;
578         }
579     }
580
581   return burn;
582 }
583
584 static unsigned int
585 keccak_extract32bi_bmi2(KECCAK_STATE *hd, unsigned int pos, byte *outbuf,
586                         unsigned int outlen)
587 {
588   unsigned int i;
589   u32 x0;
590   u32 x1;
591   u32 t;
592
593   /* NOTE: when pos == 0, hd and outbuf may point to same memory (SHA-3). */
594
595   for (i = pos; i < pos + outlen / 8 + !!(outlen % 8); i++)
596     {
597       x0 = hd->u.state32bi[i * 2 + 0];
598       x1 = hd->u.state32bi[i * 2 + 1];
599
600       t = (x0 & 0x0000FFFFUL) + (x1 << 16);
601       x1 = (x0 >> 16) + (x1 & 0xFFFF0000UL);
602       x0 = t;
603
604       x0 = pdep(pext(x0, 0xffff0001), 0xaaaaaaab) | pdep(x0 >> 1, 0x55555554);
605       x1 = pdep(pext(x1, 0xffff0001), 0xaaaaaaab) | pdep(x1 >> 1, 0x55555554);
606
607       buf_put_le32(&outbuf[0], x0);
608       buf_put_le32(&outbuf[4], x1);
609       outbuf += 8;
610     }
611
612   return 0;
613 }
614
615 static const keccak_ops_t keccak_bmi2_32bi_ops =
616 {
617   .permute = keccak_f1600_state_permute32bi_bmi2,
618   .absorb = keccak_absorb_lanes32bi_bmi2,
619   .extract = keccak_extract32bi_bmi2,
620 };
621
622 #endif /* USE_32BIT */
623
624
625 static void
626 keccak_write (void *context, const void *inbuf_arg, size_t inlen)
627 {
628   KECCAK_CONTEXT *ctx = context;
629   const size_t bsize = ctx->blocksize;
630   const size_t blocklanes = bsize / 8;
631   const byte *inbuf = inbuf_arg;
632   unsigned int nburn, burn = 0;
633   unsigned int count, i;
634   unsigned int pos, nlanes;
635
636   count = ctx->count;
637
638   if (inlen && (count % 8))
639     {
640       byte lane[8] = { 0, };
641
642       /* Complete absorbing partial input lane. */
643
644       pos = count / 8;
645
646       for (i = count % 8; inlen && i < 8; i++)
647         {
648           lane[i] = *inbuf++;
649           inlen--;
650           count++;
651         }
652
653       if (count == bsize)
654         count = 0;
655
656       nburn = ctx->ops->absorb(&ctx->state, pos, lane, 1,
657                                (count % 8) ? -1 : blocklanes);
658       burn = nburn > burn ? nburn : burn;
659     }
660
661   /* Absorb full input lanes. */
662
663   pos = count / 8;
664   nlanes = inlen / 8;
665   if (nlanes > 0)
666     {
667       nburn = ctx->ops->absorb(&ctx->state, pos, inbuf, nlanes, blocklanes);
668       burn = nburn > burn ? nburn : burn;
669       inlen -= nlanes * 8;
670       inbuf += nlanes * 8;
671       count += nlanes * 8;
672       count = count % bsize;
673     }
674
675   if (inlen)
676     {
677       byte lane[8] = { 0, };
678
679       /* Absorb remaining partial input lane. */
680
681       pos = count / 8;
682
683       for (i = count % 8; inlen && i < 8; i++)
684         {
685           lane[i] = *inbuf++;
686           inlen--;
687           count++;
688         }
689
690       nburn = ctx->ops->absorb(&ctx->state, pos, lane, 1, -1);
691       burn = nburn > burn ? nburn : burn;
692
693       gcry_assert(count < bsize);
694     }
695
696   ctx->count = count;
697
698   if (burn)
699     _gcry_burn_stack (burn);
700 }
701
702
703 static void
704 keccak_init (int algo, void *context, unsigned int flags)
705 {
706   KECCAK_CONTEXT *ctx = context;
707   KECCAK_STATE *hd = &ctx->state;
708   unsigned int features = _gcry_get_hw_features ();
709
710   (void)flags;
711   (void)features;
712
713   memset (hd, 0, sizeof *hd);
714
715   ctx->count = 0;
716
717   /* Select generic implementation. */
718 #ifdef USE_64BIT
719   ctx->ops = &keccak_generic64_ops;
720 #elif defined USE_32BIT
721   ctx->ops = &keccak_generic32bi_ops;
722 #endif
723
724   /* Select optimized implementation based in hw features. */
725   if (0) {}
726 #ifdef USE_64BIT_ARM_NEON
727   else if (features & HWF_ARM_NEON)
728     ctx->ops = &keccak_armv7_neon_64_ops;
729 #endif
730 #ifdef USE_64BIT_BMI2
731   else if (features & HWF_INTEL_BMI2)
732     ctx->ops = &keccak_bmi2_64_ops;
733 #endif
734 #ifdef USE_32BIT_BMI2
735   else if (features & HWF_INTEL_BMI2)
736     ctx->ops = &keccak_bmi2_32bi_ops;
737 #endif
738 #ifdef USE_64BIT_SHLD
739   else if (features & HWF_INTEL_FAST_SHLD)
740     ctx->ops = &keccak_shld_64_ops;
741 #endif
742
743   /* Set input block size, in Keccak terms this is called 'rate'. */
744
745   switch (algo)
746     {
747     case GCRY_MD_SHA3_224:
748       ctx->suffix = SHA3_DELIMITED_SUFFIX;
749       ctx->blocksize = 1152 / 8;
750       ctx->outlen = 224 / 8;
751       break;
752     case GCRY_MD_SHA3_256:
753       ctx->suffix = SHA3_DELIMITED_SUFFIX;
754       ctx->blocksize = 1088 / 8;
755       ctx->outlen = 256 / 8;
756       break;
757     case GCRY_MD_SHA3_384:
758       ctx->suffix = SHA3_DELIMITED_SUFFIX;
759       ctx->blocksize = 832 / 8;
760       ctx->outlen = 384 / 8;
761       break;
762     case GCRY_MD_SHA3_512:
763       ctx->suffix = SHA3_DELIMITED_SUFFIX;
764       ctx->blocksize = 576 / 8;
765       ctx->outlen = 512 / 8;
766       break;
767     case GCRY_MD_SHAKE128:
768       ctx->suffix = SHAKE_DELIMITED_SUFFIX;
769       ctx->blocksize = 1344 / 8;
770       ctx->outlen = 0;
771       break;
772     case GCRY_MD_SHAKE256:
773       ctx->suffix = SHAKE_DELIMITED_SUFFIX;
774       ctx->blocksize = 1088 / 8;
775       ctx->outlen = 0;
776       break;
777     default:
778       BUG();
779     }
780 }
781
782 static void
783 sha3_224_init (void *context, unsigned int flags)
784 {
785   keccak_init (GCRY_MD_SHA3_224, context, flags);
786 }
787
788 static void
789 sha3_256_init (void *context, unsigned int flags)
790 {
791   keccak_init (GCRY_MD_SHA3_256, context, flags);
792 }
793
794 static void
795 sha3_384_init (void *context, unsigned int flags)
796 {
797   keccak_init (GCRY_MD_SHA3_384, context, flags);
798 }
799
800 static void
801 sha3_512_init (void *context, unsigned int flags)
802 {
803   keccak_init (GCRY_MD_SHA3_512, context, flags);
804 }
805
806 static void
807 shake128_init (void *context, unsigned int flags)
808 {
809   keccak_init (GCRY_MD_SHAKE128, context, flags);
810 }
811
812 static void
813 shake256_init (void *context, unsigned int flags)
814 {
815   keccak_init (GCRY_MD_SHAKE256, context, flags);
816 }
817
818 /* The routine final terminates the computation and
819  * returns the digest.
820  * The handle is prepared for a new cycle, but adding bytes to the
821  * handle will the destroy the returned buffer.
822  * Returns: 64 bytes representing the digest.  When used for sha384,
823  * we take the leftmost 48 of those bytes.
824  */
825 static void
826 keccak_final (void *context)
827 {
828   KECCAK_CONTEXT *ctx = context;
829   KECCAK_STATE *hd = &ctx->state;
830   const size_t bsize = ctx->blocksize;
831   const byte suffix = ctx->suffix;
832   unsigned int nburn, burn = 0;
833   unsigned int lastbytes;
834   byte lane[8];
835
836   lastbytes = ctx->count;
837
838   /* Do the padding and switch to the squeezing phase */
839
840   /* Absorb the last few bits and add the first bit of padding (which
841      coincides with the delimiter in delimited suffix) */
842   buf_put_le64(lane, (u64)suffix << ((lastbytes % 8) * 8));
843   nburn = ctx->ops->absorb(&ctx->state, lastbytes / 8, lane, 1, -1);
844   burn = nburn > burn ? nburn : burn;
845
846   /* Add the second bit of padding. */
847   buf_put_le64(lane, (u64)0x80 << (((bsize - 1) % 8) * 8));
848   nburn = ctx->ops->absorb(&ctx->state, (bsize - 1) / 8, lane, 1, -1);
849   burn = nburn > burn ? nburn : burn;
850
851   if (suffix == SHA3_DELIMITED_SUFFIX)
852     {
853       /* Switch to the squeezing phase. */
854       nburn = ctx->ops->permute(hd);
855       burn = nburn > burn ? nburn : burn;
856
857       /* Squeeze out the SHA3 digest. */
858       nburn = ctx->ops->extract(hd, 0, (void *)hd, ctx->outlen);
859       burn = nburn > burn ? nburn : burn;
860     }
861   else
862     {
863       /* Output for SHAKE can now be read with md_extract(). */
864
865       ctx->count = 0;
866     }
867
868   wipememory(lane, sizeof(lane));
869   if (burn)
870     _gcry_burn_stack (burn);
871 }
872
873
874 static byte *
875 keccak_read (void *context)
876 {
877   KECCAK_CONTEXT *ctx = (KECCAK_CONTEXT *) context;
878   KECCAK_STATE *hd = &ctx->state;
879   return (byte *)&hd->u;
880 }
881
882
883 static void
884 keccak_extract (void *context, void *out, size_t outlen)
885 {
886   KECCAK_CONTEXT *ctx = context;
887   KECCAK_STATE *hd = &ctx->state;
888   const size_t bsize = ctx->blocksize;
889   unsigned int nburn, burn = 0;
890   byte *outbuf = out;
891   unsigned int nlanes;
892   unsigned int nleft;
893   unsigned int count;
894   unsigned int i;
895   byte lane[8];
896
897   count = ctx->count;
898
899   while (count && outlen && (outlen < 8 || count % 8))
900     {
901       /* Extract partial lane. */
902       nburn = ctx->ops->extract(hd, count / 8, lane, 8);
903       burn = nburn > burn ? nburn : burn;
904
905       for (i = count % 8; outlen && i < 8; i++)
906         {
907           *outbuf++ = lane[i];
908           outlen--;
909           count++;
910         }
911
912       gcry_assert(count <= bsize);
913
914       if (count == bsize)
915         count = 0;
916     }
917
918   if (outlen >= 8 && count)
919     {
920       /* Extract tail of partial block. */
921       nlanes = outlen / 8;
922       nleft = (bsize - count) / 8;
923       nlanes = nlanes < nleft ? nlanes : nleft;
924
925       nburn = ctx->ops->extract(hd, count / 8, outbuf, nlanes * 8);
926       burn = nburn > burn ? nburn : burn;
927       outlen -= nlanes * 8;
928       outbuf += nlanes * 8;
929       count += nlanes * 8;
930
931       gcry_assert(count <= bsize);
932
933       if (count == bsize)
934         count = 0;
935     }
936
937   while (outlen >= bsize)
938     {
939       gcry_assert(count == 0);
940
941       /* Squeeze more. */
942       nburn = ctx->ops->permute(hd);
943       burn = nburn > burn ? nburn : burn;
944
945       /* Extract full block. */
946       nburn = ctx->ops->extract(hd, 0, outbuf, bsize);
947       burn = nburn > burn ? nburn : burn;
948
949       outlen -= bsize;
950       outbuf += bsize;
951     }
952
953   if (outlen)
954     {
955       gcry_assert(outlen < bsize);
956
957       if (count == 0)
958         {
959           /* Squeeze more. */
960           nburn = ctx->ops->permute(hd);
961           burn = nburn > burn ? nburn : burn;
962         }
963
964       if (outlen >= 8)
965         {
966           /* Extract head of partial block. */
967           nlanes = outlen / 8;
968           nburn = ctx->ops->extract(hd, count / 8, outbuf, nlanes * 8);
969           burn = nburn > burn ? nburn : burn;
970           outlen -= nlanes * 8;
971           outbuf += nlanes * 8;
972           count += nlanes * 8;
973
974           gcry_assert(count < bsize);
975         }
976
977       if (outlen)
978         {
979           /* Extract head of partial lane. */
980           nburn = ctx->ops->extract(hd, count / 8, lane, 8);
981           burn = nburn > burn ? nburn : burn;
982
983           for (i = count % 8; outlen && i < 8; i++)
984             {
985               *outbuf++ = lane[i];
986               outlen--;
987               count++;
988             }
989
990           gcry_assert(count < bsize);
991         }
992     }
993
994   ctx->count = count;
995
996   if (burn)
997     _gcry_burn_stack (burn);
998 }
999
1000
1001 \f
1002 /*
1003      Self-test section.
1004  */
1005
1006
1007 static gpg_err_code_t
1008 selftests_keccak (int algo, int extended, selftest_report_func_t report)
1009 {
1010   const char *what;
1011   const char *errtxt;
1012   const char *short_hash;
1013   const char *long_hash;
1014   const char *one_million_a_hash;
1015   int hash_len;
1016
1017   switch (algo)
1018   {
1019     default:
1020       BUG();
1021
1022     case GCRY_MD_SHA3_224:
1023       short_hash =
1024         "\xe6\x42\x82\x4c\x3f\x8c\xf2\x4a\xd0\x92\x34\xee\x7d\x3c\x76\x6f"
1025         "\xc9\xa3\xa5\x16\x8d\x0c\x94\xad\x73\xb4\x6f\xdf";
1026       long_hash =
1027         "\x54\x3e\x68\x68\xe1\x66\x6c\x1a\x64\x36\x30\xdf\x77\x36\x7a\xe5"
1028         "\xa6\x2a\x85\x07\x0a\x51\xc1\x4c\xbf\x66\x5c\xbc";
1029       one_million_a_hash =
1030         "\xd6\x93\x35\xb9\x33\x25\x19\x2e\x51\x6a\x91\x2e\x6d\x19\xa1\x5c"
1031         "\xb5\x1c\x6e\xd5\xc1\x52\x43\xe7\xa7\xfd\x65\x3c";
1032       hash_len = 28;
1033       break;
1034
1035     case GCRY_MD_SHA3_256:
1036       short_hash =
1037         "\x3a\x98\x5d\xa7\x4f\xe2\x25\xb2\x04\x5c\x17\x2d\x6b\xd3\x90\xbd"
1038         "\x85\x5f\x08\x6e\x3e\x9d\x52\x5b\x46\xbf\xe2\x45\x11\x43\x15\x32";
1039       long_hash =
1040         "\x91\x6f\x60\x61\xfe\x87\x97\x41\xca\x64\x69\xb4\x39\x71\xdf\xdb"
1041         "\x28\xb1\xa3\x2d\xc3\x6c\xb3\x25\x4e\x81\x2b\xe2\x7a\xad\x1d\x18";
1042       one_million_a_hash =
1043         "\x5c\x88\x75\xae\x47\x4a\x36\x34\xba\x4f\xd5\x5e\xc8\x5b\xff\xd6"
1044         "\x61\xf3\x2a\xca\x75\xc6\xd6\x99\xd0\xcd\xcb\x6c\x11\x58\x91\xc1";
1045       hash_len = 32;
1046       break;
1047
1048     case GCRY_MD_SHA3_384:
1049       short_hash =
1050         "\xec\x01\x49\x82\x88\x51\x6f\xc9\x26\x45\x9f\x58\xe2\xc6\xad\x8d"
1051         "\xf9\xb4\x73\xcb\x0f\xc0\x8c\x25\x96\xda\x7c\xf0\xe4\x9b\xe4\xb2"
1052         "\x98\xd8\x8c\xea\x92\x7a\xc7\xf5\x39\xf1\xed\xf2\x28\x37\x6d\x25";
1053       long_hash =
1054         "\x79\x40\x7d\x3b\x59\x16\xb5\x9c\x3e\x30\xb0\x98\x22\x97\x47\x91"
1055         "\xc3\x13\xfb\x9e\xcc\x84\x9e\x40\x6f\x23\x59\x2d\x04\xf6\x25\xdc"
1056         "\x8c\x70\x9b\x98\xb4\x3b\x38\x52\xb3\x37\x21\x61\x79\xaa\x7f\xc7";
1057       one_million_a_hash =
1058         "\xee\xe9\xe2\x4d\x78\xc1\x85\x53\x37\x98\x34\x51\xdf\x97\xc8\xad"
1059         "\x9e\xed\xf2\x56\xc6\x33\x4f\x8e\x94\x8d\x25\x2d\x5e\x0e\x76\x84"
1060         "\x7a\xa0\x77\x4d\xdb\x90\xa8\x42\x19\x0d\x2c\x55\x8b\x4b\x83\x40";
1061       hash_len = 48;
1062       break;
1063
1064     case GCRY_MD_SHA3_512:
1065       short_hash =
1066         "\xb7\x51\x85\x0b\x1a\x57\x16\x8a\x56\x93\xcd\x92\x4b\x6b\x09\x6e"
1067         "\x08\xf6\x21\x82\x74\x44\xf7\x0d\x88\x4f\x5d\x02\x40\xd2\x71\x2e"
1068         "\x10\xe1\x16\xe9\x19\x2a\xf3\xc9\x1a\x7e\xc5\x76\x47\xe3\x93\x40"
1069         "\x57\x34\x0b\x4c\xf4\x08\xd5\xa5\x65\x92\xf8\x27\x4e\xec\x53\xf0";
1070       long_hash =
1071         "\xaf\xeb\xb2\xef\x54\x2e\x65\x79\xc5\x0c\xad\x06\xd2\xe5\x78\xf9"
1072         "\xf8\xdd\x68\x81\xd7\xdc\x82\x4d\x26\x36\x0f\xee\xbf\x18\xa4\xfa"
1073         "\x73\xe3\x26\x11\x22\x94\x8e\xfc\xfd\x49\x2e\x74\xe8\x2e\x21\x89"
1074         "\xed\x0f\xb4\x40\xd1\x87\xf3\x82\x27\x0c\xb4\x55\xf2\x1d\xd1\x85";
1075       one_million_a_hash =
1076         "\x3c\x3a\x87\x6d\xa1\x40\x34\xab\x60\x62\x7c\x07\x7b\xb9\x8f\x7e"
1077         "\x12\x0a\x2a\x53\x70\x21\x2d\xff\xb3\x38\x5a\x18\xd4\xf3\x88\x59"
1078         "\xed\x31\x1d\x0a\x9d\x51\x41\xce\x9c\xc5\xc6\x6e\xe6\x89\xb2\x66"
1079         "\xa8\xaa\x18\xac\xe8\x28\x2a\x0e\x0d\xb5\x96\xc9\x0b\x0a\x7b\x87";
1080       hash_len = 64;
1081       break;
1082
1083     case GCRY_MD_SHAKE128:
1084       short_hash =
1085         "\x58\x81\x09\x2d\xd8\x18\xbf\x5c\xf8\xa3\xdd\xb7\x93\xfb\xcb\xa7"
1086         "\x40\x97\xd5\xc5\x26\xa6\xd3\x5f\x97\xb8\x33\x51\x94\x0f\x2c\xc8";
1087       long_hash =
1088         "\x7b\x6d\xf6\xff\x18\x11\x73\xb6\xd7\x89\x8d\x7f\xf6\x3f\xb0\x7b"
1089         "\x7c\x23\x7d\xaf\x47\x1a\x5a\xe5\x60\x2a\xdb\xcc\xef\x9c\xcf\x4b";
1090       one_million_a_hash =
1091         "\x9d\x22\x2c\x79\xc4\xff\x9d\x09\x2c\xf6\xca\x86\x14\x3a\xa4\x11"
1092         "\xe3\x69\x97\x38\x08\xef\x97\x09\x32\x55\x82\x6c\x55\x72\xef\x58";
1093       hash_len = 32;
1094       break;
1095
1096     case GCRY_MD_SHAKE256:
1097       short_hash =
1098         "\x48\x33\x66\x60\x13\x60\xa8\x77\x1c\x68\x63\x08\x0c\xc4\x11\x4d"
1099         "\x8d\xb4\x45\x30\xf8\xf1\xe1\xee\x4f\x94\xea\x37\xe7\x8b\x57\x39";
1100       long_hash =
1101         "\x98\xbe\x04\x51\x6c\x04\xcc\x73\x59\x3f\xef\x3e\xd0\x35\x2e\xa9"
1102         "\xf6\x44\x39\x42\xd6\x95\x0e\x29\xa3\x72\xa6\x81\xc3\xde\xaf\x45";
1103       one_million_a_hash =
1104         "\x35\x78\xa7\xa4\xca\x91\x37\x56\x9c\xdf\x76\xed\x61\x7d\x31\xbb"
1105         "\x99\x4f\xca\x9c\x1b\xbf\x8b\x18\x40\x13\xde\x82\x34\xdf\xd1\x3a";
1106       hash_len = 32;
1107       break;
1108   }
1109
1110   what = "short string";
1111   errtxt = _gcry_hash_selftest_check_one (algo, 0, "abc", 3, short_hash,
1112                                           hash_len);
1113   if (errtxt)
1114     goto failed;
1115
1116   if (extended)
1117     {
1118       what = "long string";
1119       errtxt = _gcry_hash_selftest_check_one
1120         (algo, 0,
1121         "abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmn"
1122         "hijklmnoijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu", 112,
1123         long_hash, hash_len);
1124       if (errtxt)
1125         goto failed;
1126
1127       what = "one million \"a\"";
1128       errtxt = _gcry_hash_selftest_check_one (algo, 1, NULL, 0,
1129                                               one_million_a_hash, hash_len);
1130       if (errtxt)
1131         goto failed;
1132     }
1133
1134   return 0; /* Succeeded. */
1135
1136 failed:
1137   if (report)
1138     report ("digest", algo, what, errtxt);
1139   return GPG_ERR_SELFTEST_FAILED;
1140 }
1141
1142
1143 /* Run a full self-test for ALGO and return 0 on success.  */
1144 static gpg_err_code_t
1145 run_selftests (int algo, int extended, selftest_report_func_t report)
1146 {
1147   gpg_err_code_t ec;
1148
1149   switch (algo)
1150     {
1151     case GCRY_MD_SHA3_224:
1152     case GCRY_MD_SHA3_256:
1153     case GCRY_MD_SHA3_384:
1154     case GCRY_MD_SHA3_512:
1155     case GCRY_MD_SHAKE128:
1156     case GCRY_MD_SHAKE256:
1157       ec = selftests_keccak (algo, extended, report);
1158       break;
1159     default:
1160       ec = GPG_ERR_DIGEST_ALGO;
1161       break;
1162     }
1163
1164   return ec;
1165 }
1166
1167
1168
1169 \f
1170 static byte sha3_224_asn[] = { 0x30 };
1171 static gcry_md_oid_spec_t oid_spec_sha3_224[] =
1172   {
1173     { "2.16.840.1.101.3.4.2.7" },
1174     /* PKCS#1 sha3_224WithRSAEncryption */
1175     { "?" },
1176     { NULL }
1177   };
1178 static byte sha3_256_asn[] = { 0x30 };
1179 static gcry_md_oid_spec_t oid_spec_sha3_256[] =
1180   {
1181     { "2.16.840.1.101.3.4.2.8" },
1182     /* PKCS#1 sha3_256WithRSAEncryption */
1183     { "?" },
1184     { NULL }
1185   };
1186 static byte sha3_384_asn[] = { 0x30 };
1187 static gcry_md_oid_spec_t oid_spec_sha3_384[] =
1188   {
1189     { "2.16.840.1.101.3.4.2.9" },
1190     /* PKCS#1 sha3_384WithRSAEncryption */
1191     { "?" },
1192     { NULL }
1193   };
1194 static byte sha3_512_asn[] = { 0x30 };
1195 static gcry_md_oid_spec_t oid_spec_sha3_512[] =
1196   {
1197     { "2.16.840.1.101.3.4.2.10" },
1198     /* PKCS#1 sha3_512WithRSAEncryption */
1199     { "?" },
1200     { NULL }
1201   };
1202 static byte shake128_asn[] = { 0x30 };
1203 static gcry_md_oid_spec_t oid_spec_shake128[] =
1204   {
1205     { "2.16.840.1.101.3.4.2.11" },
1206     /* PKCS#1 shake128WithRSAEncryption */
1207     { "?" },
1208     { NULL }
1209   };
1210 static byte shake256_asn[] = { 0x30 };
1211 static gcry_md_oid_spec_t oid_spec_shake256[] =
1212   {
1213     { "2.16.840.1.101.3.4.2.12" },
1214     /* PKCS#1 shake256WithRSAEncryption */
1215     { "?" },
1216     { NULL }
1217   };
1218
1219 gcry_md_spec_t _gcry_digest_spec_sha3_224 =
1220   {
1221     GCRY_MD_SHA3_224, {0, 1},
1222     "SHA3-224", sha3_224_asn, DIM (sha3_224_asn), oid_spec_sha3_224, 28,
1223     sha3_224_init, keccak_write, keccak_final, keccak_read, NULL,
1224     sizeof (KECCAK_CONTEXT),
1225     run_selftests
1226   };
1227 gcry_md_spec_t _gcry_digest_spec_sha3_256 =
1228   {
1229     GCRY_MD_SHA3_256, {0, 1},
1230     "SHA3-256", sha3_256_asn, DIM (sha3_256_asn), oid_spec_sha3_256, 32,
1231     sha3_256_init, keccak_write, keccak_final, keccak_read, NULL,
1232     sizeof (KECCAK_CONTEXT),
1233     run_selftests
1234   };
1235 gcry_md_spec_t _gcry_digest_spec_sha3_384 =
1236   {
1237     GCRY_MD_SHA3_384, {0, 1},
1238     "SHA3-384", sha3_384_asn, DIM (sha3_384_asn), oid_spec_sha3_384, 48,
1239     sha3_384_init, keccak_write, keccak_final, keccak_read, NULL,
1240     sizeof (KECCAK_CONTEXT),
1241     run_selftests
1242   };
1243 gcry_md_spec_t _gcry_digest_spec_sha3_512 =
1244   {
1245     GCRY_MD_SHA3_512, {0, 1},
1246     "SHA3-512", sha3_512_asn, DIM (sha3_512_asn), oid_spec_sha3_512, 64,
1247     sha3_512_init, keccak_write, keccak_final, keccak_read, NULL,
1248     sizeof (KECCAK_CONTEXT),
1249     run_selftests
1250   };
1251 gcry_md_spec_t _gcry_digest_spec_shake128 =
1252   {
1253     GCRY_MD_SHAKE128, {0, 1},
1254     "SHAKE128", shake128_asn, DIM (shake128_asn), oid_spec_shake128, 0,
1255     shake128_init, keccak_write, keccak_final, NULL, keccak_extract,
1256     sizeof (KECCAK_CONTEXT),
1257     run_selftests
1258   };
1259 gcry_md_spec_t _gcry_digest_spec_shake256 =
1260   {
1261     GCRY_MD_SHAKE256, {0, 1},
1262     "SHAKE256", shake256_asn, DIM (shake256_asn), oid_spec_shake256, 0,
1263     shake256_init, keccak_write, keccak_final, NULL, keccak_extract,
1264     sizeof (KECCAK_CONTEXT),
1265     run_selftests
1266   };