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