Improve performance of generic SHA256 implementation
[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 R(a,b,c,d,e,f,g,h,k,w) do                                 \
178           {                                                       \
179             t1 = (h) + Sum1((e)) + Cho((e),(f),(g)) + (k) + (w);  \
180             t2 = Sum0((a)) + Maj((a),(b),(c));                    \
181             d += t1;                                              \
182             h  = t1 + t2;                                         \
183           } while (0)
184
185 /* (4.2) same as SHA-1's F1.  */
186 #define Cho(x, y, z)  (z ^ (x & (y ^ z)))
187
188 /* (4.3) same as SHA-1's F3 */
189 #define Maj(x, y, z)  ((x & y) + (z & (x ^ y)))
190
191 /* (4.4) */
192 #define Sum0(x)       (ror (x, 2) ^ ror (x, 13) ^ ror (x, 22))
193
194 /* (4.5) */
195 #define Sum1(x)       (ror (x, 6) ^ ror (x, 11) ^ ror (x, 25))
196
197 /* Message expansion */
198 #define S0(x) (ror ((x), 7) ^ ror ((x), 18) ^ ((x) >> 3))       /* (4.6) */
199 #define S1(x) (ror ((x), 17) ^ ror ((x), 19) ^ ((x) >> 10))     /* (4.7) */
200 #define I(i) ( w[i] = buf_get_be32(data + i * 4) )
201 #define W(i) ( w[i&0x0f] =    S1(w[(i-2) &0x0f]) \
202                             +    w[(i-7) &0x0f]  \
203                             + S0(w[(i-15)&0x0f]) \
204                             +    w[(i-16)&0x0f] )
205
206 static unsigned int
207 transform_blk (void *ctx, const unsigned char *data)
208 {
209   SHA256_CONTEXT *hd = ctx;
210   static const u32 K[64] = {
211     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
212     0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
213     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
214     0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
215     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
216     0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
217     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
218     0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
219     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
220     0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
221     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
222     0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
223     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
224     0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
225     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
226     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
227   };
228
229   u32 a,b,c,d,e,f,g,h,t1,t2;
230   u32 w[16];
231
232   a = hd->h0;
233   b = hd->h1;
234   c = hd->h2;
235   d = hd->h3;
236   e = hd->h4;
237   f = hd->h5;
238   g = hd->h6;
239   h = hd->h7;
240
241   R(a, b, c, d, e, f, g, h, K[0], I(0));
242   R(h, a, b, c, d, e, f, g, K[1], I(1));
243   R(g, h, a, b, c, d, e, f, K[2], I(2));
244   R(f, g, h, a, b, c, d, e, K[3], I(3));
245   R(e, f, g, h, a, b, c, d, K[4], I(4));
246   R(d, e, f, g, h, a, b, c, K[5], I(5));
247   R(c, d, e, f, g, h, a, b, K[6], I(6));
248   R(b, c, d, e, f, g, h, a, K[7], I(7));
249   R(a, b, c, d, e, f, g, h, K[8], I(8));
250   R(h, a, b, c, d, e, f, g, K[9], I(9));
251   R(g, h, a, b, c, d, e, f, K[10], I(10));
252   R(f, g, h, a, b, c, d, e, K[11], I(11));
253   R(e, f, g, h, a, b, c, d, K[12], I(12));
254   R(d, e, f, g, h, a, b, c, K[13], I(13));
255   R(c, d, e, f, g, h, a, b, K[14], I(14));
256   R(b, c, d, e, f, g, h, a, K[15], I(15));
257
258   R(a, b, c, d, e, f, g, h, K[16], W(16));
259   R(h, a, b, c, d, e, f, g, K[17], W(17));
260   R(g, h, a, b, c, d, e, f, K[18], W(18));
261   R(f, g, h, a, b, c, d, e, K[19], W(19));
262   R(e, f, g, h, a, b, c, d, K[20], W(20));
263   R(d, e, f, g, h, a, b, c, K[21], W(21));
264   R(c, d, e, f, g, h, a, b, K[22], W(22));
265   R(b, c, d, e, f, g, h, a, K[23], W(23));
266   R(a, b, c, d, e, f, g, h, K[24], W(24));
267   R(h, a, b, c, d, e, f, g, K[25], W(25));
268   R(g, h, a, b, c, d, e, f, K[26], W(26));
269   R(f, g, h, a, b, c, d, e, K[27], W(27));
270   R(e, f, g, h, a, b, c, d, K[28], W(28));
271   R(d, e, f, g, h, a, b, c, K[29], W(29));
272   R(c, d, e, f, g, h, a, b, K[30], W(30));
273   R(b, c, d, e, f, g, h, a, K[31], W(31));
274
275   R(a, b, c, d, e, f, g, h, K[32], W(32));
276   R(h, a, b, c, d, e, f, g, K[33], W(33));
277   R(g, h, a, b, c, d, e, f, K[34], W(34));
278   R(f, g, h, a, b, c, d, e, K[35], W(35));
279   R(e, f, g, h, a, b, c, d, K[36], W(36));
280   R(d, e, f, g, h, a, b, c, K[37], W(37));
281   R(c, d, e, f, g, h, a, b, K[38], W(38));
282   R(b, c, d, e, f, g, h, a, K[39], W(39));
283   R(a, b, c, d, e, f, g, h, K[40], W(40));
284   R(h, a, b, c, d, e, f, g, K[41], W(41));
285   R(g, h, a, b, c, d, e, f, K[42], W(42));
286   R(f, g, h, a, b, c, d, e, K[43], W(43));
287   R(e, f, g, h, a, b, c, d, K[44], W(44));
288   R(d, e, f, g, h, a, b, c, K[45], W(45));
289   R(c, d, e, f, g, h, a, b, K[46], W(46));
290   R(b, c, d, e, f, g, h, a, K[47], W(47));
291
292   R(a, b, c, d, e, f, g, h, K[48], W(48));
293   R(h, a, b, c, d, e, f, g, K[49], W(49));
294   R(g, h, a, b, c, d, e, f, K[50], W(50));
295   R(f, g, h, a, b, c, d, e, K[51], W(51));
296   R(e, f, g, h, a, b, c, d, K[52], W(52));
297   R(d, e, f, g, h, a, b, c, K[53], W(53));
298   R(c, d, e, f, g, h, a, b, K[54], W(54));
299   R(b, c, d, e, f, g, h, a, K[55], W(55));
300   R(a, b, c, d, e, f, g, h, K[56], W(56));
301   R(h, a, b, c, d, e, f, g, K[57], W(57));
302   R(g, h, a, b, c, d, e, f, K[58], W(58));
303   R(f, g, h, a, b, c, d, e, K[59], W(59));
304   R(e, f, g, h, a, b, c, d, K[60], W(60));
305   R(d, e, f, g, h, a, b, c, K[61], W(61));
306   R(c, d, e, f, g, h, a, b, K[62], W(62));
307   R(b, c, d, e, f, g, h, a, K[63], W(63));
308
309   hd->h0 += a;
310   hd->h1 += b;
311   hd->h2 += c;
312   hd->h3 += d;
313   hd->h4 += e;
314   hd->h5 += f;
315   hd->h6 += g;
316   hd->h7 += h;
317
318   return /*burn_stack*/ 26*4+32;
319 }
320 #undef S0
321 #undef S1
322 #undef R
323
324
325 /* Assembly implementations use SystemV ABI, ABI conversion and additional
326  * stack to store XMM6-XMM15 needed on Win64. */
327 #undef ASM_FUNC_ABI
328 #undef ASM_EXTRA_STACK
329 #if defined(USE_SSSE3) || defined(USE_AVX) || defined(USE_AVX2)
330 # ifdef HAVE_COMPATIBLE_GCC_WIN64_PLATFORM_AS
331 #  define ASM_FUNC_ABI __attribute__((sysv_abi))
332 #  define ASM_EXTRA_STACK (10 * 16)
333 # else
334 #  define ASM_FUNC_ABI
335 #  define ASM_EXTRA_STACK 0
336 # endif
337 #endif
338
339
340 #ifdef USE_SSSE3
341 unsigned int _gcry_sha256_transform_amd64_ssse3(const void *input_data,
342                                                 u32 state[8],
343                                                 size_t num_blks) ASM_FUNC_ABI;
344 #endif
345
346 #ifdef USE_AVX
347 unsigned int _gcry_sha256_transform_amd64_avx(const void *input_data,
348                                               u32 state[8],
349                                               size_t num_blks) ASM_FUNC_ABI;
350 #endif
351
352 #ifdef USE_AVX2
353 unsigned int _gcry_sha256_transform_amd64_avx2(const void *input_data,
354                                                u32 state[8],
355                                                size_t num_blks) ASM_FUNC_ABI;
356 #endif
357
358
359 static unsigned int
360 transform (void *ctx, const unsigned char *data, size_t nblks)
361 {
362   SHA256_CONTEXT *hd = ctx;
363   unsigned int burn;
364
365 #ifdef USE_AVX2
366   if (hd->use_avx2)
367     return _gcry_sha256_transform_amd64_avx2 (data, &hd->h0, nblks)
368            + 4 * sizeof(void*) + ASM_EXTRA_STACK;
369 #endif
370
371 #ifdef USE_AVX
372   if (hd->use_avx)
373     return _gcry_sha256_transform_amd64_avx (data, &hd->h0, nblks)
374            + 4 * sizeof(void*) + ASM_EXTRA_STACK;
375 #endif
376
377 #ifdef USE_SSSE3
378   if (hd->use_ssse3)
379     return _gcry_sha256_transform_amd64_ssse3 (data, &hd->h0, nblks)
380            + 4 * sizeof(void*) + ASM_EXTRA_STACK;
381 #endif
382
383   do
384     {
385       burn = transform_blk (hd, data);
386       data += 64;
387     }
388   while (--nblks);
389
390 #ifdef ASM_EXTRA_STACK
391   /* 'transform_blk' is typically inlined and XMM6-XMM15 are stored at
392    *  the prologue of this function. Therefore need to add ASM_EXTRA_STACK to
393    *  here too.
394    */
395   burn += ASM_EXTRA_STACK;
396 #endif
397
398   return burn;
399 }
400
401
402 /*
403    The routine finally terminates the computation and returns the
404    digest.  The handle is prepared for a new cycle, but adding bytes
405    to the handle will the destroy the returned buffer.  Returns: 32
406    bytes with the message the digest.  */
407 static void
408 sha256_final(void *context)
409 {
410   SHA256_CONTEXT *hd = context;
411   u32 t, th, msb, lsb;
412   byte *p;
413   unsigned int burn;
414
415   _gcry_md_block_write (hd, NULL, 0); /* flush */;
416
417   t = hd->bctx.nblocks;
418   if (sizeof t == sizeof hd->bctx.nblocks)
419     th = hd->bctx.nblocks_high;
420   else
421     th = hd->bctx.nblocks >> 32;
422
423   /* multiply by 64 to make a byte count */
424   lsb = t << 6;
425   msb = (th << 6) | (t >> 26);
426   /* add the count */
427   t = lsb;
428   if ((lsb += hd->bctx.count) < t)
429     msb++;
430   /* multiply by 8 to make a bit count */
431   t = lsb;
432   lsb <<= 3;
433   msb <<= 3;
434   msb |= t >> 29;
435
436   if (hd->bctx.count < 56)
437     { /* enough room */
438       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad */
439       while (hd->bctx.count < 56)
440         hd->bctx.buf[hd->bctx.count++] = 0;  /* pad */
441     }
442   else
443     { /* need one extra block */
444       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad character */
445       while (hd->bctx.count < 64)
446         hd->bctx.buf[hd->bctx.count++] = 0;
447       _gcry_md_block_write (hd, NULL, 0);  /* flush */;
448       memset (hd->bctx.buf, 0, 56 ); /* fill next block with zeroes */
449     }
450   /* append the 64 bit count */
451   buf_put_be32(hd->bctx.buf + 56, msb);
452   buf_put_be32(hd->bctx.buf + 60, lsb);
453   burn = transform (hd, hd->bctx.buf, 1);
454   _gcry_burn_stack (burn);
455
456   p = hd->bctx.buf;
457 #define X(a) do { buf_put_be32(p, hd->h##a); p += 4; } while(0)
458   X(0);
459   X(1);
460   X(2);
461   X(3);
462   X(4);
463   X(5);
464   X(6);
465   X(7);
466 #undef X
467 }
468
469 static byte *
470 sha256_read (void *context)
471 {
472   SHA256_CONTEXT *hd = context;
473
474   return hd->bctx.buf;
475 }
476
477
478 \f
479 /*
480      Self-test section.
481  */
482
483
484 static gpg_err_code_t
485 selftests_sha224 (int extended, selftest_report_func_t report)
486 {
487   const char *what;
488   const char *errtxt;
489
490   what = "short string";
491   errtxt = _gcry_hash_selftest_check_one
492     (GCRY_MD_SHA224, 0,
493      "abc", 3,
494      "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
495      "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7", 28);
496   if (errtxt)
497     goto failed;
498
499   if (extended)
500     {
501       what = "long string";
502       errtxt = _gcry_hash_selftest_check_one
503         (GCRY_MD_SHA224, 0,
504          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
505          "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
506          "\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25", 28);
507       if (errtxt)
508         goto failed;
509
510       what = "one million \"a\"";
511       errtxt = _gcry_hash_selftest_check_one
512         (GCRY_MD_SHA224, 1,
513          NULL, 0,
514          "\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
515          "\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67", 28);
516       if (errtxt)
517         goto failed;
518     }
519
520   return 0; /* Succeeded. */
521
522  failed:
523   if (report)
524     report ("digest", GCRY_MD_SHA224, what, errtxt);
525   return GPG_ERR_SELFTEST_FAILED;
526 }
527
528 static gpg_err_code_t
529 selftests_sha256 (int extended, selftest_report_func_t report)
530 {
531   const char *what;
532   const char *errtxt;
533
534   what = "short string";
535   errtxt = _gcry_hash_selftest_check_one
536     (GCRY_MD_SHA256, 0,
537      "abc", 3,
538      "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
539      "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad", 32);
540   if (errtxt)
541     goto failed;
542
543   if (extended)
544     {
545       what = "long string";
546       errtxt = _gcry_hash_selftest_check_one
547         (GCRY_MD_SHA256, 0,
548          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
549          "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
550          "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1",
551          32);
552       if (errtxt)
553         goto failed;
554
555       what = "one million \"a\"";
556       errtxt = _gcry_hash_selftest_check_one
557         (GCRY_MD_SHA256, 1,
558          NULL, 0,
559          "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
560          "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0",
561          32);
562       if (errtxt)
563         goto failed;
564     }
565
566   return 0; /* Succeeded. */
567
568  failed:
569   if (report)
570     report ("digest", GCRY_MD_SHA256, what, errtxt);
571   return GPG_ERR_SELFTEST_FAILED;
572 }
573
574
575 /* Run a full self-test for ALGO and return 0 on success.  */
576 static gpg_err_code_t
577 run_selftests (int algo, int extended, selftest_report_func_t report)
578 {
579   gpg_err_code_t ec;
580
581   switch (algo)
582     {
583     case GCRY_MD_SHA224:
584       ec = selftests_sha224 (extended, report);
585       break;
586     case GCRY_MD_SHA256:
587       ec = selftests_sha256 (extended, report);
588       break;
589     default:
590       ec = GPG_ERR_DIGEST_ALGO;
591       break;
592
593     }
594   return ec;
595 }
596
597
598
599 \f
600 static byte asn224[19] = /* Object ID is 2.16.840.1.101.3.4.2.4 */
601   { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
602     0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
603     0x1C
604   };
605
606 static gcry_md_oid_spec_t oid_spec_sha224[] =
607   {
608     /* From RFC3874, Section 4 */
609     { "2.16.840.1.101.3.4.2.4" },
610     { NULL },
611   };
612
613 static byte asn256[19] = /* Object ID is  2.16.840.1.101.3.4.2.1 */
614   { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
615     0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
616     0x00, 0x04, 0x20 };
617
618 static gcry_md_oid_spec_t oid_spec_sha256[] =
619   {
620     /* According to the OpenPGP draft rfc2440-bis06 */
621     { "2.16.840.1.101.3.4.2.1" },
622     /* PKCS#1 sha256WithRSAEncryption */
623     { "1.2.840.113549.1.1.11" },
624
625     { NULL },
626   };
627
628 gcry_md_spec_t _gcry_digest_spec_sha224 =
629   {
630     GCRY_MD_SHA224, {0, 1},
631     "SHA224", asn224, DIM (asn224), oid_spec_sha224, 28,
632     sha224_init, _gcry_md_block_write, sha256_final, sha256_read, NULL,
633     sizeof (SHA256_CONTEXT),
634     run_selftests
635   };
636
637 gcry_md_spec_t _gcry_digest_spec_sha256 =
638   {
639     GCRY_MD_SHA256, {0, 1},
640     "SHA256", asn256, DIM (asn256), oid_spec_sha256, 32,
641     sha256_init, _gcry_md_block_write, sha256_final, sha256_read, NULL,
642     sizeof (SHA256_CONTEXT),
643     run_selftests
644   };