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