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