hwf-x86: add detection for Intel CPUs with fast SHLD instruction
[libgcrypt.git] / cipher / sha256.c
1 /* sha256.c - SHA256 hash function
2  * Copyright (C) 2003, 2006, 2008, 2009 Free Software Foundation, Inc.
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 /*  Test vectors:
22
23     "abc"
24     SHA224: 23097d22 3405d822 8642a477 bda255b3 2aadbce4 bda0b3f7 e36c9da7
25     SHA256: ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad
26
27     "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"
28     SHA224: 75388b16 512776cc 5dba5da1 fd890150 b0c6455c b4f58b19 52522525
29     SHA256: 248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1
30
31     "a" one million times
32     SHA224: 20794655 980c91d8 bbb4c1ea 97618a4b f03f4258 1948b2ee 4ee7ad67
33     SHA256: cdc76e5c 9914fb92 81a1c7e2 84d73e67 f1809a48 a497200e 046d39cc c7112cd0
34
35  */
36
37
38 #include <config.h>
39 #include <stdio.h>
40 #include <stdlib.h>
41 #include <string.h>
42
43 #include "g10lib.h"
44 #include "bithelp.h"
45 #include "bufhelp.h"
46 #include "cipher.h"
47 #include "hash-common.h"
48
49
50 /* USE_SSSE3 indicates whether to compile with Intel SSSE3 code. */
51 #undef USE_SSSE3
52 #if defined(__x86_64__) && defined(HAVE_GCC_INLINE_ASM_SSSE3) && \
53     defined(HAVE_INTEL_SYNTAX_PLATFORM_AS) && \
54     (defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS) || \
55      defined(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS))
56 # define USE_SSSE3 1
57 #endif
58
59 /* USE_AVX indicates whether to compile with Intel AVX code. */
60 #undef USE_AVX
61 #if defined(__x86_64__) && defined(HAVE_GCC_INLINE_ASM_AVX) && \
62     defined(HAVE_INTEL_SYNTAX_PLATFORM_AS) && \
63     (defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS) || \
64      defined(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS))
65 # define USE_AVX 1
66 #endif
67
68 /* USE_AVX2 indicates whether to compile with Intel AVX2/BMI2 code. */
69 #undef USE_AVX2
70 #if defined(__x86_64__) && defined(HAVE_GCC_INLINE_ASM_AVX2) && \
71     defined(HAVE_GCC_INLINE_ASM_BMI2) && \
72     defined(HAVE_INTEL_SYNTAX_PLATFORM_AS) && \
73     (defined(HAVE_COMPATIBLE_GCC_AMD64_PLATFORM_AS) || \
74      defined(HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS))
75 # define USE_AVX2 1
76 #endif
77
78
79 typedef struct {
80   gcry_md_block_ctx_t bctx;
81   u32  h0,h1,h2,h3,h4,h5,h6,h7;
82 #ifdef USE_SSSE3
83   unsigned int use_ssse3:1;
84 #endif
85 #ifdef USE_AVX
86   unsigned int use_avx:1;
87 #endif
88 #ifdef USE_AVX2
89   unsigned int use_avx2:1;
90 #endif
91 } SHA256_CONTEXT;
92
93
94 static unsigned int
95 transform (void *c, const unsigned char *data, size_t nblks);
96
97
98 static void
99 sha256_init (void *context, unsigned int flags)
100 {
101   SHA256_CONTEXT *hd = context;
102   unsigned int features = _gcry_get_hw_features ();
103
104   (void)flags;
105
106   hd->h0 = 0x6a09e667;
107   hd->h1 = 0xbb67ae85;
108   hd->h2 = 0x3c6ef372;
109   hd->h3 = 0xa54ff53a;
110   hd->h4 = 0x510e527f;
111   hd->h5 = 0x9b05688c;
112   hd->h6 = 0x1f83d9ab;
113   hd->h7 = 0x5be0cd19;
114
115   hd->bctx.nblocks = 0;
116   hd->bctx.nblocks_high = 0;
117   hd->bctx.count = 0;
118   hd->bctx.blocksize = 64;
119   hd->bctx.bwrite = transform;
120
121 #ifdef USE_SSSE3
122   hd->use_ssse3 = (features & HWF_INTEL_SSSE3) != 0;
123 #endif
124 #ifdef USE_AVX
125   /* AVX implementation uses SHLD which is known to be slow on non-Intel CPUs.
126    * Therefore use this implementation on Intel CPUs only. */
127   hd->use_avx = (features & HWF_INTEL_AVX) && (features & HWF_INTEL_FAST_SHLD);
128 #endif
129 #ifdef USE_AVX2
130   hd->use_avx2 = (features & HWF_INTEL_AVX2) && (features & HWF_INTEL_BMI2);
131 #endif
132   (void)features;
133 }
134
135
136 static void
137 sha224_init (void *context, unsigned int flags)
138 {
139   SHA256_CONTEXT *hd = context;
140   unsigned int features = _gcry_get_hw_features ();
141
142   (void)flags;
143
144   hd->h0 = 0xc1059ed8;
145   hd->h1 = 0x367cd507;
146   hd->h2 = 0x3070dd17;
147   hd->h3 = 0xf70e5939;
148   hd->h4 = 0xffc00b31;
149   hd->h5 = 0x68581511;
150   hd->h6 = 0x64f98fa7;
151   hd->h7 = 0xbefa4fa4;
152
153   hd->bctx.nblocks = 0;
154   hd->bctx.nblocks_high = 0;
155   hd->bctx.count = 0;
156   hd->bctx.blocksize = 64;
157   hd->bctx.bwrite = transform;
158
159 #ifdef USE_SSSE3
160   hd->use_ssse3 = (features & HWF_INTEL_SSSE3) != 0;
161 #endif
162 #ifdef USE_AVX
163   /* AVX implementation uses SHLD which is known to be slow on non-Intel CPUs.
164    * Therefore use this implementation on Intel CPUs only. */
165   hd->use_avx = (features & HWF_INTEL_AVX) && (features & HWF_INTEL_FAST_SHLD);
166 #endif
167 #ifdef USE_AVX2
168   hd->use_avx2 = (features & HWF_INTEL_AVX2) && (features & HWF_INTEL_BMI2);
169 #endif
170   (void)features;
171 }
172
173
174 /*
175   Transform the message X which consists of 16 32-bit-words. See FIPS
176   180-2 for details.  */
177 #define S0(x) (ror ((x), 7) ^ ror ((x), 18) ^ ((x) >> 3))       /* (4.6) */
178 #define S1(x) (ror ((x), 17) ^ ror ((x), 19) ^ ((x) >> 10))     /* (4.7) */
179 #define R(a,b,c,d,e,f,g,h,k,w) do                                 \
180           {                                                       \
181             t1 = (h) + Sum1((e)) + Cho((e),(f),(g)) + (k) + (w);  \
182             t2 = Sum0((a)) + Maj((a),(b),(c));                    \
183             h = g;                                                \
184             g = f;                                                \
185             f = e;                                                \
186             e = d + t1;                                           \
187             d = c;                                                \
188             c = b;                                                \
189             b = a;                                                \
190             a = t1 + t2;                                          \
191           } while (0)
192
193 /* (4.2) same as SHA-1's F1.  */
194 static inline u32
195 Cho (u32 x, u32 y, u32 z)
196 {
197   return (z ^ (x & (y ^ z)));
198 }
199
200 /* (4.3) same as SHA-1's F3 */
201 static inline u32
202 Maj (u32 x, u32 y, u32 z)
203 {
204   return ((x & y) | (z & (x|y)));
205 }
206
207 /* (4.4) */
208 static inline u32
209 Sum0 (u32 x)
210 {
211   return (ror (x, 2) ^ ror (x, 13) ^ ror (x, 22));
212 }
213
214 /* (4.5) */
215 static inline u32
216 Sum1 (u32 x)
217 {
218   return (ror (x, 6) ^ ror (x, 11) ^ ror (x, 25));
219 }
220
221
222 static unsigned int
223 transform_blk (void *ctx, const unsigned char *data)
224 {
225   SHA256_CONTEXT *hd = ctx;
226   static const u32 K[64] = {
227     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
228     0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
229     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
230     0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
231     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
232     0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
233     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
234     0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
235     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
236     0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
237     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
238     0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
239     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
240     0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
241     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
242     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
243   };
244
245   u32 a,b,c,d,e,f,g,h,t1,t2;
246   u32 w[64];
247   int i;
248
249   a = hd->h0;
250   b = hd->h1;
251   c = hd->h2;
252   d = hd->h3;
253   e = hd->h4;
254   f = hd->h5;
255   g = hd->h6;
256   h = hd->h7;
257
258   for (i=0; i < 16; i++)
259     w[i] = buf_get_be32(data + i * 4);
260   for (; i < 64; i++)
261     w[i] = S1(w[i-2]) + w[i-7] + S0(w[i-15]) + w[i-16];
262
263   for (i=0; i < 64;)
264     {
265 #if 0
266       R(a,b,c,d,e,f,g,h,K[i],w[i]);
267       i++;
268 #else
269       t1 = h + Sum1 (e) + Cho (e, f, g) + K[i] + w[i];
270       t2 = Sum0 (a) + Maj (a, b, c);
271       d += t1;
272       h  = t1 + t2;
273
274       t1 = g + Sum1 (d) + Cho (d, e, f) + K[i+1] + w[i+1];
275       t2 = Sum0 (h) + Maj (h, a, b);
276       c += t1;
277       g  = t1 + t2;
278
279       t1 = f + Sum1 (c) + Cho (c, d, e) + K[i+2] + w[i+2];
280       t2 = Sum0 (g) + Maj (g, h, a);
281       b += t1;
282       f  = t1 + t2;
283
284       t1 = e + Sum1 (b) + Cho (b, c, d) + K[i+3] + w[i+3];
285       t2 = Sum0 (f) + Maj (f, g, h);
286       a += t1;
287       e  = t1 + t2;
288
289       t1 = d + Sum1 (a) + Cho (a, b, c) + K[i+4] + w[i+4];
290       t2 = Sum0 (e) + Maj (e, f, g);
291       h += t1;
292       d  = t1 + t2;
293
294       t1 = c + Sum1 (h) + Cho (h, a, b) + K[i+5] + w[i+5];
295       t2 = Sum0 (d) + Maj (d, e, f);
296       g += t1;
297       c  = t1 + t2;
298
299       t1 = b + Sum1 (g) + Cho (g, h, a) + K[i+6] + w[i+6];
300       t2 = Sum0 (c) + Maj (c, d, e);
301       f += t1;
302       b  = t1 + t2;
303
304       t1 = a + Sum1 (f) + Cho (f, g, h) + K[i+7] + w[i+7];
305       t2 = Sum0 (b) + Maj (b, c, d);
306       e += t1;
307       a  = t1 + t2;
308
309       i += 8;
310 #endif
311     }
312
313   hd->h0 += a;
314   hd->h1 += b;
315   hd->h2 += c;
316   hd->h3 += d;
317   hd->h4 += e;
318   hd->h5 += f;
319   hd->h6 += g;
320   hd->h7 += h;
321
322   return /*burn_stack*/ 74*4+32;
323 }
324 #undef S0
325 #undef S1
326 #undef R
327
328
329 /* Assembly implementations use SystemV ABI, ABI conversion and additional
330  * stack to store XMM6-XMM15 needed on Win64. */
331 #undef ASM_FUNC_ABI
332 #undef ASM_EXTRA_STACK
333 #if defined(USE_SSSE3) || defined(USE_AVX) || defined(USE_AVX2)
334 # ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
335 #  define ASM_FUNC_ABI __attribute__((sysv_abi))
336 #  define ASM_EXTRA_STACK (10 * 16)
337 # else
338 #  define ASM_FUNC_ABI
339 #  define ASM_EXTRA_STACK 0
340 # endif
341 #endif
342
343
344 #ifdef USE_SSSE3
345 unsigned int _gcry_sha256_transform_amd64_ssse3(const void *input_data,
346                                                 u32 state[8],
347                                                 size_t num_blks) ASM_FUNC_ABI;
348 #endif
349
350 #ifdef USE_AVX
351 unsigned int _gcry_sha256_transform_amd64_avx(const void *input_data,
352                                               u32 state[8],
353                                               size_t num_blks) ASM_FUNC_ABI;
354 #endif
355
356 #ifdef USE_AVX2
357 unsigned int _gcry_sha256_transform_amd64_avx2(const void *input_data,
358                                                u32 state[8],
359                                                size_t num_blks) ASM_FUNC_ABI;
360 #endif
361
362
363 static unsigned int
364 transform (void *ctx, const unsigned char *data, size_t nblks)
365 {
366   SHA256_CONTEXT *hd = ctx;
367   unsigned int burn;
368
369 #ifdef USE_AVX2
370   if (hd->use_avx2)
371     return _gcry_sha256_transform_amd64_avx2 (data, &hd->h0, nblks)
372            + 4 * sizeof(void*) + ASM_EXTRA_STACK;
373 #endif
374
375 #ifdef USE_AVX
376   if (hd->use_avx)
377     return _gcry_sha256_transform_amd64_avx (data, &hd->h0, nblks)
378            + 4 * sizeof(void*) + ASM_EXTRA_STACK;
379 #endif
380
381 #ifdef USE_SSSE3
382   if (hd->use_ssse3)
383     return _gcry_sha256_transform_amd64_ssse3 (data, &hd->h0, nblks)
384            + 4 * sizeof(void*) + ASM_EXTRA_STACK;
385 #endif
386
387   do
388     {
389       burn = transform_blk (hd, data);
390       data += 64;
391     }
392   while (--nblks);
393
394 #ifdef ASM_EXTRA_STACK
395   /* 'transform_blk' is typically inlined and XMM6-XMM15 are stored at
396    *  the prologue of this function. Therefore need to add ASM_EXTRA_STACK to
397    *  here too.
398    */
399   burn += ASM_EXTRA_STACK;
400 #endif
401
402   return burn;
403 }
404
405
406 /*
407    The routine finally terminates the computation and returns the
408    digest.  The handle is prepared for a new cycle, but adding bytes
409    to the handle will the destroy the returned buffer.  Returns: 32
410    bytes with the message the digest.  */
411 static void
412 sha256_final(void *context)
413 {
414   SHA256_CONTEXT *hd = context;
415   u32 t, th, msb, lsb;
416   byte *p;
417   unsigned int burn;
418
419   _gcry_md_block_write (hd, NULL, 0); /* flush */;
420
421   t = hd->bctx.nblocks;
422   if (sizeof t == sizeof hd->bctx.nblocks)
423     th = hd->bctx.nblocks_high;
424   else
425     th = hd->bctx.nblocks >> 32;
426
427   /* multiply by 64 to make a byte count */
428   lsb = t << 6;
429   msb = (th << 6) | (t >> 26);
430   /* add the count */
431   t = lsb;
432   if ((lsb += hd->bctx.count) < t)
433     msb++;
434   /* multiply by 8 to make a bit count */
435   t = lsb;
436   lsb <<= 3;
437   msb <<= 3;
438   msb |= t >> 29;
439
440   if (hd->bctx.count < 56)
441     { /* enough room */
442       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad */
443       while (hd->bctx.count < 56)
444         hd->bctx.buf[hd->bctx.count++] = 0;  /* pad */
445     }
446   else
447     { /* need one extra block */
448       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad character */
449       while (hd->bctx.count < 64)
450         hd->bctx.buf[hd->bctx.count++] = 0;
451       _gcry_md_block_write (hd, NULL, 0);  /* flush */;
452       memset (hd->bctx.buf, 0, 56 ); /* fill next block with zeroes */
453     }
454   /* append the 64 bit count */
455   buf_put_be32(hd->bctx.buf + 56, msb);
456   buf_put_be32(hd->bctx.buf + 60, lsb);
457   burn = transform (hd, hd->bctx.buf, 1);
458   _gcry_burn_stack (burn);
459
460   p = hd->bctx.buf;
461 #define X(a) do { buf_put_be32(p, hd->h##a); p += 4; } while(0)
462   X(0);
463   X(1);
464   X(2);
465   X(3);
466   X(4);
467   X(5);
468   X(6);
469   X(7);
470 #undef X
471 }
472
473 static byte *
474 sha256_read (void *context)
475 {
476   SHA256_CONTEXT *hd = context;
477
478   return hd->bctx.buf;
479 }
480
481
482 \f
483 /*
484      Self-test section.
485  */
486
487
488 static gpg_err_code_t
489 selftests_sha224 (int extended, selftest_report_func_t report)
490 {
491   const char *what;
492   const char *errtxt;
493
494   what = "short string";
495   errtxt = _gcry_hash_selftest_check_one
496     (GCRY_MD_SHA224, 0,
497      "abc", 3,
498      "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
499      "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7", 28);
500   if (errtxt)
501     goto failed;
502
503   if (extended)
504     {
505       what = "long string";
506       errtxt = _gcry_hash_selftest_check_one
507         (GCRY_MD_SHA224, 0,
508          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
509          "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
510          "\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25", 28);
511       if (errtxt)
512         goto failed;
513
514       what = "one million \"a\"";
515       errtxt = _gcry_hash_selftest_check_one
516         (GCRY_MD_SHA224, 1,
517          NULL, 0,
518          "\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
519          "\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67", 28);
520       if (errtxt)
521         goto failed;
522     }
523
524   return 0; /* Succeeded. */
525
526  failed:
527   if (report)
528     report ("digest", GCRY_MD_SHA224, what, errtxt);
529   return GPG_ERR_SELFTEST_FAILED;
530 }
531
532 static gpg_err_code_t
533 selftests_sha256 (int extended, selftest_report_func_t report)
534 {
535   const char *what;
536   const char *errtxt;
537
538   what = "short string";
539   errtxt = _gcry_hash_selftest_check_one
540     (GCRY_MD_SHA256, 0,
541      "abc", 3,
542      "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
543      "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad", 32);
544   if (errtxt)
545     goto failed;
546
547   if (extended)
548     {
549       what = "long string";
550       errtxt = _gcry_hash_selftest_check_one
551         (GCRY_MD_SHA256, 0,
552          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
553          "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
554          "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1",
555          32);
556       if (errtxt)
557         goto failed;
558
559       what = "one million \"a\"";
560       errtxt = _gcry_hash_selftest_check_one
561         (GCRY_MD_SHA256, 1,
562          NULL, 0,
563          "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
564          "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0",
565          32);
566       if (errtxt)
567         goto failed;
568     }
569
570   return 0; /* Succeeded. */
571
572  failed:
573   if (report)
574     report ("digest", GCRY_MD_SHA256, what, errtxt);
575   return GPG_ERR_SELFTEST_FAILED;
576 }
577
578
579 /* Run a full self-test for ALGO and return 0 on success.  */
580 static gpg_err_code_t
581 run_selftests (int algo, int extended, selftest_report_func_t report)
582 {
583   gpg_err_code_t ec;
584
585   switch (algo)
586     {
587     case GCRY_MD_SHA224:
588       ec = selftests_sha224 (extended, report);
589       break;
590     case GCRY_MD_SHA256:
591       ec = selftests_sha256 (extended, report);
592       break;
593     default:
594       ec = GPG_ERR_DIGEST_ALGO;
595       break;
596
597     }
598   return ec;
599 }
600
601
602
603 \f
604 static byte asn224[19] = /* Object ID is 2.16.840.1.101.3.4.2.4 */
605   { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
606     0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
607     0x1C
608   };
609
610 static gcry_md_oid_spec_t oid_spec_sha224[] =
611   {
612     /* From RFC3874, Section 4 */
613     { "2.16.840.1.101.3.4.2.4" },
614     { NULL },
615   };
616
617 static byte asn256[19] = /* Object ID is  2.16.840.1.101.3.4.2.1 */
618   { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
619     0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
620     0x00, 0x04, 0x20 };
621
622 static gcry_md_oid_spec_t oid_spec_sha256[] =
623   {
624     /* According to the OpenPGP draft rfc2440-bis06 */
625     { "2.16.840.1.101.3.4.2.1" },
626     /* PKCS#1 sha256WithRSAEncryption */
627     { "1.2.840.113549.1.1.11" },
628
629     { NULL },
630   };
631
632 gcry_md_spec_t _gcry_digest_spec_sha224 =
633   {
634     GCRY_MD_SHA224, {0, 1},
635     "SHA224", asn224, DIM (asn224), oid_spec_sha224, 28,
636     sha224_init, _gcry_md_block_write, sha256_final, sha256_read,
637     sizeof (SHA256_CONTEXT),
638     run_selftests
639   };
640
641 gcry_md_spec_t _gcry_digest_spec_sha256 =
642   {
643     GCRY_MD_SHA256, {0, 1},
644     "SHA256", asn256, DIM (asn256), oid_spec_sha256, 32,
645     sha256_init, _gcry_md_block_write, sha256_final, sha256_read,
646     sizeof (SHA256_CONTEXT),
647     run_selftests
648   };