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