md: Simplify the message digest dispatcher md.c.
[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.count = 0;
74   hd->bctx.blocksize = 64;
75   hd->bctx.bwrite = transform;
76 }
77
78
79 static void
80 sha224_init (void *context)
81 {
82   SHA256_CONTEXT *hd = context;
83
84   hd->h0 = 0xc1059ed8;
85   hd->h1 = 0x367cd507;
86   hd->h2 = 0x3070dd17;
87   hd->h3 = 0xf70e5939;
88   hd->h4 = 0xffc00b31;
89   hd->h5 = 0x68581511;
90   hd->h6 = 0x64f98fa7;
91   hd->h7 = 0xbefa4fa4;
92
93   hd->bctx.nblocks = 0;
94   hd->bctx.count = 0;
95   hd->bctx.blocksize = 64;
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 unsigned int
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 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   for (i=0; i < 16; i++)
185     w[i] = buf_get_be32(data + i * 4);
186   for (; i < 64; i++)
187     w[i] = S1(w[i-2]) + w[i-7] + S0(w[i-15]) + w[i-16];
188
189   for (i=0; i < 64;)
190     {
191 #if 0
192       R(a,b,c,d,e,f,g,h,K[i],w[i]);
193       i++;
194 #else
195       t1 = h + Sum1 (e) + Cho (e, f, g) + K[i] + w[i];
196       t2 = Sum0 (a) + Maj (a, b, c);
197       d += t1;
198       h  = t1 + t2;
199
200       t1 = g + Sum1 (d) + Cho (d, e, f) + K[i+1] + w[i+1];
201       t2 = Sum0 (h) + Maj (h, a, b);
202       c += t1;
203       g  = t1 + t2;
204
205       t1 = f + Sum1 (c) + Cho (c, d, e) + K[i+2] + w[i+2];
206       t2 = Sum0 (g) + Maj (g, h, a);
207       b += t1;
208       f  = t1 + t2;
209
210       t1 = e + Sum1 (b) + Cho (b, c, d) + K[i+3] + w[i+3];
211       t2 = Sum0 (f) + Maj (f, g, h);
212       a += t1;
213       e  = t1 + t2;
214
215       t1 = d + Sum1 (a) + Cho (a, b, c) + K[i+4] + w[i+4];
216       t2 = Sum0 (e) + Maj (e, f, g);
217       h += t1;
218       d  = t1 + t2;
219
220       t1 = c + Sum1 (h) + Cho (h, a, b) + K[i+5] + w[i+5];
221       t2 = Sum0 (d) + Maj (d, e, f);
222       g += t1;
223       c  = t1 + t2;
224
225       t1 = b + Sum1 (g) + Cho (g, h, a) + K[i+6] + w[i+6];
226       t2 = Sum0 (c) + Maj (c, d, e);
227       f += t1;
228       b  = t1 + t2;
229
230       t1 = a + Sum1 (f) + Cho (f, g, h) + K[i+7] + w[i+7];
231       t2 = Sum0 (b) + Maj (b, c, d);
232       e += t1;
233       a  = t1 + t2;
234
235       i += 8;
236 #endif
237     }
238
239   hd->h0 += a;
240   hd->h1 += b;
241   hd->h2 += c;
242   hd->h3 += d;
243   hd->h4 += e;
244   hd->h5 += f;
245   hd->h6 += g;
246   hd->h7 += h;
247
248   return /*burn_stack*/ 74*4+32;
249 }
250 #undef S0
251 #undef S1
252 #undef R
253
254
255 /*
256    The routine finally terminates the computation and returns the
257    digest.  The handle is prepared for a new cycle, but adding bytes
258    to the handle will the destroy the returned buffer.  Returns: 32
259    bytes with the message the digest.  */
260 static void
261 sha256_final(void *context)
262 {
263   SHA256_CONTEXT *hd = context;
264   u32 t, msb, lsb;
265   byte *p;
266   unsigned int burn;
267
268   _gcry_md_block_write (hd, NULL, 0); /* flush */;
269
270   t = hd->bctx.nblocks;
271   /* multiply by 64 to make a byte count */
272   lsb = t << 6;
273   msb = t >> 26;
274   /* add the count */
275   t = lsb;
276   if ((lsb += hd->bctx.count) < t)
277     msb++;
278   /* multiply by 8 to make a bit count */
279   t = lsb;
280   lsb <<= 3;
281   msb <<= 3;
282   msb |= t >> 29;
283
284   if (hd->bctx.count < 56)
285     { /* enough room */
286       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad */
287       while (hd->bctx.count < 56)
288         hd->bctx.buf[hd->bctx.count++] = 0;  /* pad */
289     }
290   else
291     { /* need one extra block */
292       hd->bctx.buf[hd->bctx.count++] = 0x80; /* pad character */
293       while (hd->bctx.count < 64)
294         hd->bctx.buf[hd->bctx.count++] = 0;
295       _gcry_md_block_write (hd, NULL, 0);  /* flush */;
296       memset (hd->bctx.buf, 0, 56 ); /* fill next block with zeroes */
297     }
298   /* append the 64 bit count */
299   buf_put_be32(hd->bctx.buf + 56, msb);
300   buf_put_be32(hd->bctx.buf + 60, lsb);
301   burn = transform (hd, hd->bctx.buf);
302   _gcry_burn_stack (burn);
303
304   p = hd->bctx.buf;
305 #define X(a) do { *(u32*)p = be_bswap32(hd->h##a); p += 4; } while(0)
306   X(0);
307   X(1);
308   X(2);
309   X(3);
310   X(4);
311   X(5);
312   X(6);
313   X(7);
314 #undef X
315 }
316
317 static byte *
318 sha256_read (void *context)
319 {
320   SHA256_CONTEXT *hd = context;
321
322   return hd->bctx.buf;
323 }
324
325
326 \f
327 /*
328      Self-test section.
329  */
330
331
332 static gpg_err_code_t
333 selftests_sha224 (int extended, selftest_report_func_t report)
334 {
335   const char *what;
336   const char *errtxt;
337
338   what = "short string";
339   errtxt = _gcry_hash_selftest_check_one
340     (GCRY_MD_SHA224, 0,
341      "abc", 3,
342      "\x23\x09\x7d\x22\x34\x05\xd8\x22\x86\x42\xa4\x77\xbd\xa2\x55\xb3"
343      "\x2a\xad\xbc\xe4\xbd\xa0\xb3\xf7\xe3\x6c\x9d\xa7", 28);
344   if (errtxt)
345     goto failed;
346
347   if (extended)
348     {
349       what = "long string";
350       errtxt = _gcry_hash_selftest_check_one
351         (GCRY_MD_SHA224, 0,
352          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
353          "\x75\x38\x8b\x16\x51\x27\x76\xcc\x5d\xba\x5d\xa1\xfd\x89\x01\x50"
354          "\xb0\xc6\x45\x5c\xb4\xf5\x8b\x19\x52\x52\x25\x25", 28);
355       if (errtxt)
356         goto failed;
357
358       what = "one million \"a\"";
359       errtxt = _gcry_hash_selftest_check_one
360         (GCRY_MD_SHA224, 1,
361          NULL, 0,
362          "\x20\x79\x46\x55\x98\x0c\x91\xd8\xbb\xb4\xc1\xea\x97\x61\x8a\x4b"
363          "\xf0\x3f\x42\x58\x19\x48\xb2\xee\x4e\xe7\xad\x67", 28);
364       if (errtxt)
365         goto failed;
366     }
367
368   return 0; /* Succeeded. */
369
370  failed:
371   if (report)
372     report ("digest", GCRY_MD_SHA224, what, errtxt);
373   return GPG_ERR_SELFTEST_FAILED;
374 }
375
376 static gpg_err_code_t
377 selftests_sha256 (int extended, selftest_report_func_t report)
378 {
379   const char *what;
380   const char *errtxt;
381
382   what = "short string";
383   errtxt = _gcry_hash_selftest_check_one
384     (GCRY_MD_SHA256, 0,
385      "abc", 3,
386      "\xba\x78\x16\xbf\x8f\x01\xcf\xea\x41\x41\x40\xde\x5d\xae\x22\x23"
387      "\xb0\x03\x61\xa3\x96\x17\x7a\x9c\xb4\x10\xff\x61\xf2\x00\x15\xad", 32);
388   if (errtxt)
389     goto failed;
390
391   if (extended)
392     {
393       what = "long string";
394       errtxt = _gcry_hash_selftest_check_one
395         (GCRY_MD_SHA256, 0,
396          "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56,
397          "\x24\x8d\x6a\x61\xd2\x06\x38\xb8\xe5\xc0\x26\x93\x0c\x3e\x60\x39"
398          "\xa3\x3c\xe4\x59\x64\xff\x21\x67\xf6\xec\xed\xd4\x19\xdb\x06\xc1",
399          32);
400       if (errtxt)
401         goto failed;
402
403       what = "one million \"a\"";
404       errtxt = _gcry_hash_selftest_check_one
405         (GCRY_MD_SHA256, 1,
406          NULL, 0,
407          "\xcd\xc7\x6e\x5c\x99\x14\xfb\x92\x81\xa1\xc7\xe2\x84\xd7\x3e\x67"
408          "\xf1\x80\x9a\x48\xa4\x97\x20\x0e\x04\x6d\x39\xcc\xc7\x11\x2c\xd0",
409          32);
410       if (errtxt)
411         goto failed;
412     }
413
414   return 0; /* Succeeded. */
415
416  failed:
417   if (report)
418     report ("digest", GCRY_MD_SHA256, what, errtxt);
419   return GPG_ERR_SELFTEST_FAILED;
420 }
421
422
423 /* Run a full self-test for ALGO and return 0 on success.  */
424 static gpg_err_code_t
425 run_selftests (int algo, int extended, selftest_report_func_t report)
426 {
427   gpg_err_code_t ec;
428
429   switch (algo)
430     {
431     case GCRY_MD_SHA224:
432       ec = selftests_sha224 (extended, report);
433       break;
434     case GCRY_MD_SHA256:
435       ec = selftests_sha256 (extended, report);
436       break;
437     default:
438       ec = GPG_ERR_DIGEST_ALGO;
439       break;
440
441     }
442   return ec;
443 }
444
445
446
447 \f
448 static byte asn224[19] = /* Object ID is 2.16.840.1.101.3.4.2.4 */
449   { 0x30, 0x2D, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86, 0x48,
450     0x01, 0x65, 0x03, 0x04, 0x02, 0x04, 0x05, 0x00, 0x04,
451     0x1C
452   };
453
454 static gcry_md_oid_spec_t oid_spec_sha224[] =
455   {
456     /* From RFC3874, Section 4 */
457     { "2.16.840.1.101.3.4.2.4" },
458     { NULL },
459   };
460
461 static byte asn256[19] = /* Object ID is  2.16.840.1.101.3.4.2.1 */
462   { 0x30, 0x31, 0x30, 0x0d, 0x06, 0x09, 0x60, 0x86,
463     0x48, 0x01, 0x65, 0x03, 0x04, 0x02, 0x01, 0x05,
464     0x00, 0x04, 0x20 };
465
466 static gcry_md_oid_spec_t oid_spec_sha256[] =
467   {
468     /* According to the OpenPGP draft rfc2440-bis06 */
469     { "2.16.840.1.101.3.4.2.1" },
470     /* PKCS#1 sha256WithRSAEncryption */
471     { "1.2.840.113549.1.1.11" },
472
473     { NULL },
474   };
475
476 gcry_md_spec_t _gcry_digest_spec_sha224 =
477   {
478     GCRY_MD_SHA224, {0, 1},
479     "SHA224", asn224, DIM (asn224), oid_spec_sha224, 28,
480     sha224_init, _gcry_md_block_write, sha256_final, sha256_read,
481     sizeof (SHA256_CONTEXT),
482     run_selftests
483   };
484
485 gcry_md_spec_t _gcry_digest_spec_sha256 =
486   {
487     GCRY_MD_SHA256, {0, 1},
488     "SHA256", asn256, DIM (asn256), oid_spec_sha256, 32,
489     sha256_init, _gcry_md_block_write, sha256_final, sha256_read,
490     sizeof (SHA256_CONTEXT),
491     run_selftests
492   };