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