Use hash transform function return type for passing burn stack depth
[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 "cipher.h"
46 #include "hash-common.h"
47
48 typedef struct {
49   gcry_md_block_ctx_t bctx;
50   u32  h0,h1,h2,h3,h4,h5,h6,h7;
51 } SHA256_CONTEXT;
52
53 static unsigned int
54 transform (void *c, const unsigned char *data);
55
56
57 static void
58 sha256_init (void *context)
59 {
60   SHA256_CONTEXT *hd = context;
61
62   hd->h0 = 0x6a09e667;
63   hd->h1 = 0xbb67ae85;
64   hd->h2 = 0x3c6ef372;
65   hd->h3 = 0xa54ff53a;
66   hd->h4 = 0x510e527f;
67   hd->h5 = 0x9b05688c;
68   hd->h6 = 0x1f83d9ab;
69   hd->h7 = 0x5be0cd19;
70
71   hd->bctx.nblocks = 0;
72   hd->bctx.count = 0;
73   hd->bctx.blocksize = 64;
74   hd->bctx.bwrite = transform;
75 }
76
77
78 static void
79 sha224_init (void *context)
80 {
81   SHA256_CONTEXT *hd = context;
82
83   hd->h0 = 0xc1059ed8;
84   hd->h1 = 0x367cd507;
85   hd->h2 = 0x3070dd17;
86   hd->h3 = 0xf70e5939;
87   hd->h4 = 0xffc00b31;
88   hd->h5 = 0x68581511;
89   hd->h6 = 0x64f98fa7;
90   hd->h7 = 0xbefa4fa4;
91
92   hd->bctx.nblocks = 0;
93   hd->bctx.count = 0;
94   hd->bctx.blocksize = 64;
95   hd->bctx.bwrite = transform;
96 }
97
98
99 /*
100   Transform the message X which consists of 16 32-bit-words. See FIPS
101   180-2 for details.  */
102 #define S0(x) (ror ((x), 7) ^ ror ((x), 18) ^ ((x) >> 3))       /* (4.6) */
103 #define S1(x) (ror ((x), 17) ^ ror ((x), 19) ^ ((x) >> 10))     /* (4.7) */
104 #define R(a,b,c,d,e,f,g,h,k,w) do                                 \
105           {                                                       \
106             t1 = (h) + Sum1((e)) + Cho((e),(f),(g)) + (k) + (w);  \
107             t2 = Sum0((a)) + Maj((a),(b),(c));                    \
108             h = g;                                                \
109             g = f;                                                \
110             f = e;                                                \
111             e = d + t1;                                           \
112             d = c;                                                \
113             c = b;                                                \
114             b = a;                                                \
115             a = t1 + t2;                                          \
116           } while (0)
117
118 /* (4.2) same as SHA-1's F1.  */
119 static inline u32
120 Cho (u32 x, u32 y, u32 z)
121 {
122   return (z ^ (x & (y ^ z)));
123 }
124
125 /* (4.3) same as SHA-1's F3 */
126 static inline u32
127 Maj (u32 x, u32 y, u32 z)
128 {
129   return ((x & y) | (z & (x|y)));
130 }
131
132 /* (4.4) */
133 static inline u32
134 Sum0 (u32 x)
135 {
136   return (ror (x, 2) ^ ror (x, 13) ^ ror (x, 22));
137 }
138
139 /* (4.5) */
140 static inline u32
141 Sum1 (u32 x)
142 {
143   return (ror (x, 6) ^ ror (x, 11) ^ ror (x, 25));
144 }
145
146
147 static unsigned int
148 transform (void *ctx, const unsigned char *data)
149 {
150   SHA256_CONTEXT *hd = ctx;
151   static const u32 K[64] = {
152     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
153     0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
154     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
155     0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
156     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
157     0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
158     0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
159     0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
160     0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
161     0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
162     0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
163     0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
164     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
165     0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
166     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
167     0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
168   };
169
170   u32 a,b,c,d,e,f,g,h,t1,t2;
171   u32 x[16];
172   u32 w[64];
173   int i;
174
175   a = hd->h0;
176   b = hd->h1;
177   c = hd->h2;
178   d = hd->h3;
179   e = hd->h4;
180   f = hd->h5;
181   g = hd->h6;
182   h = hd->h7;
183
184 #ifdef WORDS_BIGENDIAN
185   memcpy (x, data, 64);
186 #else
187   {
188     byte *p2;
189
190     for (i=0, p2=(byte*)x; i < 16; i++, p2 += 4 )
191       {
192         p2[3] = *data++;
193         p2[2] = *data++;
194         p2[1] = *data++;
195         p2[0] = *data++;
196       }
197   }
198 #endif
199
200   for (i=0; i < 16; i++)
201     w[i] = x[i];
202   for (; i < 64; i++)
203     w[i] = S1(w[i-2]) + w[i-7] + S0(w[i-15]) + w[i-16];
204
205   for (i=0; i < 64;)
206     {
207 #if 0
208       R(a,b,c,d,e,f,g,h,K[i],w[i]);
209       i++;
210 #else
211       t1 = h + Sum1 (e) + Cho (e, f, g) + K[i] + w[i];
212       t2 = Sum0 (a) + Maj (a, b, c);
213       d += t1;
214       h  = t1 + t2;
215
216       t1 = g + Sum1 (d) + Cho (d, e, f) + K[i+1] + w[i+1];
217       t2 = Sum0 (h) + Maj (h, a, b);
218       c += t1;
219       g  = t1 + t2;
220
221       t1 = f + Sum1 (c) + Cho (c, d, e) + K[i+2] + w[i+2];
222       t2 = Sum0 (g) + Maj (g, h, a);
223       b += t1;
224       f  = t1 + t2;
225
226       t1 = e + Sum1 (b) + Cho (b, c, d) + K[i+3] + w[i+3];
227       t2 = Sum0 (f) + Maj (f, g, h);
228       a += t1;
229       e  = t1 + t2;
230
231       t1 = d + Sum1 (a) + Cho (a, b, c) + K[i+4] + w[i+4];
232       t2 = Sum0 (e) + Maj (e, f, g);
233       h += t1;
234       d  = t1 + t2;
235
236       t1 = c + Sum1 (h) + Cho (h, a, b) + K[i+5] + w[i+5];
237       t2 = Sum0 (d) + Maj (d, e, f);
238       g += t1;
239       c  = t1 + t2;
240
241       t1 = b + Sum1 (g) + Cho (g, h, a) + K[i+6] + w[i+6];
242       t2 = Sum0 (c) + Maj (c, d, e);
243       f += t1;
244       b  = t1 + t2;
245
246       t1 = a + Sum1 (f) + Cho (f, g, h) + K[i+7] + w[i+7];
247       t2 = Sum0 (b) + Maj (b, c, d);
248       e += t1;
249       a  = t1 + t2;
250
251       i += 8;
252 #endif
253     }
254
255   hd->h0 += a;
256   hd->h1 += b;
257   hd->h2 += c;
258   hd->h3 += d;
259   hd->h4 += e;
260   hd->h5 += f;
261   hd->h6 += g;
262   hd->h7 += h;
263
264   return /*burn_stack*/ 74*4+32;
265 }
266 #undef S0
267 #undef S1
268 #undef R
269
270
271 /*
272    The routine finally terminates the computation and returns the
273    digest.  The handle is prepared for a new cycle, but adding bytes
274    to the handle will the destroy the returned buffer.  Returns: 32
275    bytes with the message the digest.  */
276 static void
277 sha256_final(void *context)
278 {
279   SHA256_CONTEXT *hd = context;
280   u32 t, msb, lsb;
281   byte *p;
282   unsigned int burn;
283
284   _gcry_md_block_write (hd, NULL, 0); /* flush */;
285
286   t = hd->bctx.nblocks;
287   /* multiply by 64 to make a byte count */
288   lsb = t << 6;
289   msb = t >> 26;
290   /* add the count */
291   t = lsb;
292   if ((lsb += hd->bctx.count) < t)
293     msb++;
294   /* multiply by 8 to make a bit count */
295   t = lsb;
296   lsb <<= 3;
297   msb <<= 3;
298   msb |= t >> 29;
299
300   if (hd->bctx.count < 56)
301     { /* enough room */
302       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad */
303       while (hd->bctx.count < 56)
304         hd->bctx.buf[hd->bctx.count++] = 0;  /* pad */
305     }
306   else
307     { /* need one extra block */
308       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad character */
309       while (hd->bctx.count < 64)
310         hd->bctx.buf[hd->bctx.count++] = 0;
311       _gcry_md_block_write (hd, NULL, 0);  /* flush */;
312       memset (hd->bctx.buf, 0, 56 ); /* fill next block with zeroes */
313     }
314   /* append the 64 bit count */
315   hd->bctx.buf[56] = msb >> 24;
316   hd->bctx.buf[57] = msb >> 16;
317   hd->bctx.buf[58] = msb >>  8;
318   hd->bctx.buf[59] = msb;
319   hd->bctx.buf[60] = lsb >> 24;
320   hd->bctx.buf[61] = lsb >> 16;
321   hd->bctx.buf[62] = lsb >>  8;
322   hd->bctx.buf[63] = lsb;
323   burn = transform (hd, hd->bctx.buf);
324   _gcry_burn_stack (burn);
325
326   p = hd->bctx.buf;
327 #ifdef WORDS_BIGENDIAN
328 #define X(a) do { *(u32*)p = hd->h##a ; p += 4; } while(0)
329 #else /* little endian */
330 #define X(a) do { *p++ = hd->h##a >> 24; *p++ = hd->h##a >> 16;  \
331                   *p++ = hd->h##a >> 8; *p++ = hd->h##a; } while(0)
332 #endif
333   X(0);
334   X(1);
335   X(2);
336   X(3);
337   X(4);
338   X(5);
339   X(6);
340   X(7);
341 #undef X
342 }
343
344 static byte *
345 sha256_read (void *context)
346 {
347   SHA256_CONTEXT *hd = context;
348
349   return hd->bctx.buf;
350 }
351
352
353 \f
354 /*
355      Self-test section.
356  */
357
358
359 static gpg_err_code_t
360 selftests_sha224 (int extended, selftest_report_func_t report)
361 {
362   const char *what;
363   const char *errtxt;
364
365   what = "short string";
366   errtxt = _gcry_hash_selftest_check_one
367     (GCRY_MD_SHA224, 0,
368      "abc", 3,
369      "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
370      "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7", 28);
371   if (errtxt)
372     goto failed;
373
374   if (extended)
375     {
376       what = "long string";
377       errtxt = _gcry_hash_selftest_check_one
378         (GCRY_MD_SHA224, 0,
379          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
380          "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
381          "\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25", 28);
382       if (errtxt)
383         goto failed;
384
385       what = "one million \"a\"";
386       errtxt = _gcry_hash_selftest_check_one
387         (GCRY_MD_SHA224, 1,
388          NULL, 0,
389          "\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
390          "\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67", 28);
391       if (errtxt)
392         goto failed;
393     }
394
395   return 0; /* Succeeded. */
396
397  failed:
398   if (report)
399     report ("digest", GCRY_MD_SHA224, what, errtxt);
400   return GPG_ERR_SELFTEST_FAILED;
401 }
402
403 static gpg_err_code_t
404 selftests_sha256 (int extended, selftest_report_func_t report)
405 {
406   const char *what;
407   const char *errtxt;
408
409   what = "short string";
410   errtxt = _gcry_hash_selftest_check_one
411     (GCRY_MD_SHA256, 0,
412      "abc", 3,
413      "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
414      "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad", 32);
415   if (errtxt)
416     goto failed;
417
418   if (extended)
419     {
420       what = "long string";
421       errtxt = _gcry_hash_selftest_check_one
422         (GCRY_MD_SHA256, 0,
423          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
424          "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
425          "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1",
426          32);
427       if (errtxt)
428         goto failed;
429
430       what = "one million \"a\"";
431       errtxt = _gcry_hash_selftest_check_one
432         (GCRY_MD_SHA256, 1,
433          NULL, 0,
434          "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
435          "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0",
436          32);
437       if (errtxt)
438         goto failed;
439     }
440
441   return 0; /* Succeeded. */
442
443  failed:
444   if (report)
445     report ("digest", GCRY_MD_SHA256, what, errtxt);
446   return GPG_ERR_SELFTEST_FAILED;
447 }
448
449
450 /* Run a full self-test for ALGO and return 0 on success.  */
451 static gpg_err_code_t
452 run_selftests (int algo, int extended, selftest_report_func_t report)
453 {
454   gpg_err_code_t ec;
455
456   switch (algo)
457     {
458     case GCRY_MD_SHA224:
459       ec = selftests_sha224 (extended, report);
460       break;
461     case GCRY_MD_SHA256:
462       ec = selftests_sha256 (extended, report);
463       break;
464     default:
465       ec = GPG_ERR_DIGEST_ALGO;
466       break;
467
468     }
469   return ec;
470 }
471
472
473
474 \f
475 static byte asn224[19] = /* Object ID is 2.16.840.1.101.3.4.2.4 */
476   { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
477     0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
478     0x1C
479   };
480
481 static gcry_md_oid_spec_t oid_spec_sha224[] =
482   {
483     /* From RFC3874, Section 4 */
484     { "2.16.840.1.101.3.4.2.4" },
485     { NULL },
486   };
487
488 static byte asn256[19] = /* Object ID is  2.16.840.1.101.3.4.2.1 */
489   { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
490     0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
491     0x00, 0x04, 0x20 };
492
493 static gcry_md_oid_spec_t oid_spec_sha256[] =
494   {
495     /* According to the OpenPGP draft rfc2440-bis06 */
496     { "2.16.840.1.101.3.4.2.1" },
497     /* PKCS#1 sha256WithRSAEncryption */
498     { "1.2.840.113549.1.1.11" },
499
500     { NULL },
501   };
502
503 gcry_md_spec_t _gcry_digest_spec_sha224 =
504   {
505     "SHA224", asn224, DIM (asn224), oid_spec_sha224, 28,
506     sha224_init, _gcry_md_block_write, sha256_final, sha256_read,
507     sizeof (SHA256_CONTEXT)
508   };
509 md_extra_spec_t _gcry_digest_extraspec_sha224 =
510   {
511     run_selftests
512   };
513
514 gcry_md_spec_t _gcry_digest_spec_sha256 =
515   {
516     "SHA256", asn256, DIM (asn256), oid_spec_sha256, 32,
517     sha256_init, _gcry_md_block_write, sha256_final, sha256_read,
518     sizeof (SHA256_CONTEXT)
519   };
520 md_extra_spec_t _gcry_digest_extraspec_sha256 =
521   {
522     run_selftests
523   };