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