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