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