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