lib/sha256.c

   1 /* sha256.c - Functions to compute SHA256 and SHA224 message digest of files or
   2    memory blocks according to the NIST specification FIPS-180-2.
   3
   4    Copyright (C) 2005, 2006 Free Software Foundation, Inc.
   5
   6    This program is free software; you can redistribute it and/or modify it
   7    under the terms of the GNU General Public License as published by the
   8    Free Software Foundation; either version 2, or (at your option) any
   9    later version.
  10
  11    This program 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 General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software Foundation,
  18    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  19
  20 /* Written by David Madore, considerably copypasting from
  21    Scott G. Miller's sha1.c
  22 */
  23
  24 #ifdef HAVE_CONFIG_H
  25 # include <config.h>
  26 #endif
  27
  28 #include "sha256.h"
  29
  30 #include <stddef.h>
  31 #include <string.h>
  32
  33 #if USE_UNLOCKED_IO
  34 # include "unlocked-io.h"
  35 #endif
  36
  37 #ifdef WORDS_BIGENDIAN
  38 # define SWAP(n) (n)
  39 #else
  40 # define SWAP(n) \
  41     (((n) << 24) | (((n) & 0xff00) << 8) | (((n) >> 8) & 0xff00) | ((n) >> 24))
  42 #endif
  43
  44 #define BLOCKSIZE 4096
  45 #if BLOCKSIZE % 64 != 0
  46 # error "invalid BLOCKSIZE"
  47 #endif
  48
  49 /* This array contains the bytes used to pad the buffer to the next
  50    64-byte boundary.  */
  51 static const unsigned char fillbuf[64] = { 0x80, 0 /* , 0, 0, ...  */ };
  52
  53
  54 /*
  55   Takes a pointer to a 256 bit block of data (eight 32 bit ints) and
  56   intializes it to the start constants of the SHA256 algorithm.  This
  57   must be called before using hash in the call to sha256_hash
  58 */
  59 void
  60 sha256_init_ctx (struct sha256_ctx *ctx)
  61 {
  62   ctx->state[0] = 0x6a09e667UL;
  63   ctx->state[1] = 0xbb67ae85UL;
  64   ctx->state[2] = 0x3c6ef372UL;
  65   ctx->state[3] = 0xa54ff53aUL;
  66   ctx->state[4] = 0x510e527fUL;
  67   ctx->state[5] = 0x9b05688cUL;
  68   ctx->state[6] = 0x1f83d9abUL;
  69   ctx->state[7] = 0x5be0cd19UL;
  70
  71   ctx->total[0] = ctx->total[1] = 0;
  72   ctx->buflen = 0;
  73 }
  74
  75 void
  76 sha224_init_ctx (struct sha256_ctx *ctx)
  77 {
  78   ctx->state[0] = 0xc1059ed8UL;
  79   ctx->state[1] = 0x367cd507UL;
  80   ctx->state[2] = 0x3070dd17UL;
  81   ctx->state[3] = 0xf70e5939UL;
  82   ctx->state[4] = 0xffc00b31UL;
  83   ctx->state[5] = 0x68581511UL;
  84   ctx->state[6] = 0x64f98fa7UL;
  85   ctx->state[7] = 0xbefa4fa4UL;
  86
  87   ctx->total[0] = ctx->total[1] = 0;
  88   ctx->buflen = 0;
  89 }
  90
  91 /* Put result from CTX in first 32 bytes following RESBUF.  The result
  92    must be in little endian byte order.
  93
  94    IMPORTANT: On some systems it is required that RESBUF is correctly
  95    aligned for a 32-bit value.  */
  96 void *
  97 sha256_read_ctx (const struct sha256_ctx *ctx, void *resbuf)
  98 {
  99   int i;
 100
 101   for (i = 0; i < 8; i++)
 102     ((uint32_t *) resbuf)[i] = SWAP (ctx->state[i]);
 103
 104   return resbuf;
 105 }
 106
 107 void *
 108 sha224_read_ctx (const struct sha256_ctx *ctx, void *resbuf)
 109 {
 110   int i;
 111
 112   for (i = 0; i < 7; i++)
 113     ((uint32_t *) resbuf)[i] = SWAP (ctx->state[i]);
 114
 115   return resbuf;
 116 }
 117
 118 /* Process the remaining bytes in the internal buffer and the usual
 119    prolog according to the standard and write the result to RESBUF.
 120
 121    IMPORTANT: On some systems it is required that RESBUF is correctly
 122    aligned for a 32-bit value.  */
 123 static void
 124 sha256_conclude_ctx (struct sha256_ctx *ctx)
 125 {
 126   /* Take yet unprocessed bytes into account.  */
 127   uint32_t bytes = ctx->buflen;
 128   size_t size = (bytes < 56) ? 64 / 4 : 64 * 2 / 4;
 129
 130   /* Now count remaining bytes.  */
 131   ctx->total[0] += bytes;
 132   if (ctx->total[0] < bytes)
 133     ++ctx->total[1];
 134
 135   /* Put the 64-bit file length in *bits* at the end of the buffer.  */
 136   ctx->buffer[size - 2] = SWAP ((ctx->total[1] << 3) | (ctx->total[0] >> 29));
 137   ctx->buffer[size - 1] = SWAP (ctx->total[0] << 3);
 138
 139   memcpy (&((char *) ctx->buffer)[bytes], fillbuf, (size - 2) * 4 - bytes);
 140
 141   /* Process last bytes.  */
 142   sha256_process_block (ctx->buffer, size * 4, ctx);
 143 }
 144
 145 void *
 146 sha256_finish_ctx (struct sha256_ctx *ctx, void *resbuf)
 147 {
 148   sha256_conclude_ctx (ctx);
 149   return sha256_read_ctx (ctx, resbuf);
 150 }
 151
 152 void *
 153 sha224_finish_ctx (struct sha256_ctx *ctx, void *resbuf)
 154 {
 155   sha256_conclude_ctx (ctx);
 156   return sha224_read_ctx (ctx, resbuf);
 157 }
 158
 159 /* Compute SHA256 message digest for bytes read from STREAM.  The
 160    resulting message digest number will be written into the 32 bytes
 161    beginning at RESBLOCK.  */
 162 int
 163 sha256_stream (FILE *stream, void *resblock)
 164 {
 165   struct sha256_ctx ctx;
 166   char buffer[BLOCKSIZE + 72];
 167   size_t sum;
 168
 169   /* Initialize the computation context.  */
 170   sha256_init_ctx (&ctx);
 171
 172   /* Iterate over full file contents.  */
 173   while (1)
 174     {
 175       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
 176          computation function processes the whole buffer so that with the
 177          next round of the loop another block can be read.  */
 178       size_t n;
 179       sum = 0;
 180
 181       /* Read block.  Take care for partial reads.  */
 182       while (1)
 183         {
 184           n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
 185
 186           sum += n;
 187
 188           if (sum == BLOCKSIZE)
 189             break;
 190
 191           if (n == 0)
 192             {
 193               /* Check for the error flag IFF N == 0, so that we don't
 194                  exit the loop after a partial read due to e.g., EAGAIN
 195                  or EWOULDBLOCK.  */
 196               if (ferror (stream))
 197                 return 1;
 198               goto process_partial_block;
 199             }
 200
 201           /* We've read at least one byte, so ignore errors.  But always
 202              check for EOF, since feof may be true even though N > 0.
 203              Otherwise, we could end up calling fread after EOF.  */
 204           if (feof (stream))
 205             goto process_partial_block;
 206         }
 207
 208       /* Process buffer with BLOCKSIZE bytes.  Note that
 209                         BLOCKSIZE % 64 == 0
 210        */
 211       sha256_process_block (buffer, BLOCKSIZE, &ctx);
 212     }
 213
 214  process_partial_block:;
 215
 216   /* Process any remaining bytes.  */
 217   if (sum > 0)
 218     sha256_process_bytes (buffer, sum, &ctx);
 219
 220   /* Construct result in desired memory.  */
 221   sha256_finish_ctx (&ctx, resblock);
 222   return 0;
 223 }
 224
 225 /* FIXME: Avoid code duplication */
 226 int
 227 sha224_stream (FILE *stream, void *resblock)
 228 {
 229   struct sha256_ctx ctx;
 230   char buffer[BLOCKSIZE + 72];
 231   size_t sum;
 232
 233   /* Initialize the computation context.  */
 234   sha224_init_ctx (&ctx);
 235
 236   /* Iterate over full file contents.  */
 237   while (1)
 238     {
 239       /* We read the file in blocks of BLOCKSIZE bytes.  One call of the
 240          computation function processes the whole buffer so that with the
 241          next round of the loop another block can be read.  */
 242       size_t n;
 243       sum = 0;
 244
 245       /* Read block.  Take care for partial reads.  */
 246       while (1)
 247         {
 248           n = fread (buffer + sum, 1, BLOCKSIZE - sum, stream);
 249
 250           sum += n;
 251
 252           if (sum == BLOCKSIZE)
 253             break;
 254
 255           if (n == 0)
 256             {
 257               /* Check for the error flag IFF N == 0, so that we don't
 258                  exit the loop after a partial read due to e.g., EAGAIN
 259                  or EWOULDBLOCK.  */
 260               if (ferror (stream))
 261                 return 1;
 262               goto process_partial_block;
 263             }
 264
 265           /* We've read at least one byte, so ignore errors.  But always
 266              check for EOF, since feof may be true even though N > 0.
 267              Otherwise, we could end up calling fread after EOF.  */
 268           if (feof (stream))
 269             goto process_partial_block;
 270         }
 271
 272       /* Process buffer with BLOCKSIZE bytes.  Note that
 273                         BLOCKSIZE % 64 == 0
 274        */
 275       sha256_process_block (buffer, BLOCKSIZE, &ctx);
 276     }
 277
 278  process_partial_block:;
 279
 280   /* Process any remaining bytes.  */
 281   if (sum > 0)
 282     sha256_process_bytes (buffer, sum, &ctx);
 283
 284   /* Construct result in desired memory.  */
 285   sha224_finish_ctx (&ctx, resblock);
 286   return 0;
 287 }
 288
 289 /* Compute SHA512 message digest for LEN bytes beginning at BUFFER.  The
 290    result is always in little endian byte order, so that a byte-wise
 291    output yields to the wanted ASCII representation of the message
 292    digest.  */
 293 void *
 294 sha256_buffer (const char *buffer, size_t len, void *resblock)
 295 {
 296   struct sha256_ctx ctx;
 297
 298   /* Initialize the computation context.  */
 299   sha256_init_ctx (&ctx);
 300
 301   /* Process whole buffer but last len % 64 bytes.  */
 302   sha256_process_bytes (buffer, len, &ctx);
 303
 304   /* Put result in desired memory area.  */
 305   return sha256_finish_ctx (&ctx, resblock);
 306 }
 307
 308 void *
 309 sha224_buffer (const char *buffer, size_t len, void *resblock)
 310 {
 311   struct sha256_ctx ctx;
 312
 313   /* Initialize the computation context.  */
 314   sha224_init_ctx (&ctx);
 315
 316   /* Process whole buffer but last len % 64 bytes.  */
 317   sha256_process_bytes (buffer, len, &ctx);
 318
 319   /* Put result in desired memory area.  */
 320   return sha224_finish_ctx (&ctx, resblock);
 321 }
 322
 323 void
 324 sha256_process_bytes (const void *buffer, size_t len, struct sha256_ctx *ctx)
 325 {
 326   /* When we already have some bits in our internal buffer concatenate
 327      both inputs first.  */
 328   if (ctx->buflen != 0)
 329     {
 330       size_t left_over = ctx->buflen;
 331       size_t add = 128 - left_over > len ? len : 128 - left_over;
 332
 333       memcpy (&((char *) ctx->buffer)[left_over], buffer, add);
 334       ctx->buflen += add;
 335
 336       if (ctx->buflen > 64)
 337         {
 338           sha256_process_block (ctx->buffer, ctx->buflen & ~63, ctx);
 339
 340           ctx->buflen &= 63;
 341           /* The regions in the following copy operation cannot overlap.  */
 342           memcpy (ctx->buffer,
 343                   &((char *) ctx->buffer)[(left_over + add) & ~63],
 344                   ctx->buflen);
 345         }
 346
 347       buffer = (const char *) buffer + add;
 348       len -= add;
 349     }
 350
 351   /* Process available complete blocks.  */
 352   if (len >= 64)
 353     {
 354 #if !_STRING_ARCH_unaligned
 355 # define alignof(type) offsetof (struct { char c; type x; }, x)
 356 # define UNALIGNED_P(p) (((size_t) p) % alignof (uint32_t) != 0)
 357       if (UNALIGNED_P (buffer))
 358         while (len > 64)
 359           {
 360             sha256_process_block (memcpy (ctx->buffer, buffer, 64), 64, ctx);
 361             buffer = (const char *) buffer + 64;
 362             len -= 64;
 363           }
 364       else
 365 #endif
 366         {
 367           sha256_process_block (buffer, len & ~63, ctx);
 368           buffer = (const char *) buffer + (len & ~63);
 369           len &= 63;
 370         }
 371     }
 372
 373   /* Move remaining bytes in internal buffer.  */
 374   if (len > 0)
 375     {
 376       size_t left_over = ctx->buflen;
 377
 378       memcpy (&((char *) ctx->buffer)[left_over], buffer, len);
 379       left_over += len;
 380       if (left_over >= 64)
 381         {
 382           sha256_process_block (ctx->buffer, 64, ctx);
 383           left_over -= 64;
 384           memcpy (ctx->buffer, &ctx->buffer[16], left_over);
 385         }
 386       ctx->buflen = left_over;
 387     }
 388 }
 389
 390 /* --- Code below is the primary difference between sha1.c and sha256.c --- */
 391
 392 /* SHA256 round constants */
 393 #define K(I) sha256_round_constants[I]
 394 static const uint32_t sha256_round_constants[64] = {
 395   0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
 396   0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
 397   0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
 398   0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
 399   0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
 400   0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
 401   0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
 402   0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
 403   0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
 404   0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
 405   0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL,
 406   0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
 407   0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL,
 408   0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL,
 409   0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
 410   0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL,
 411 };
 412
 413 /* Round functions.  */
 414 #define F2(A,B,C) ( ( A & B ) | ( C & ( A | B ) ) )
 415 #define F1(E,F,G) ( G ^ ( E & ( F ^ G ) ) )
 416
 417 /* Process LEN bytes of BUFFER, accumulating context into CTX.
 418    It is assumed that LEN % 64 == 0.
 419    Most of this code comes from GnuPG's cipher/sha1.c.  */
 420
 421 void
 422 sha256_process_block (const void *buffer, size_t len, struct sha256_ctx *ctx)
 423 {
 424   const uint32_t *words = buffer;
 425   size_t nwords = len / sizeof (uint32_t);
 426   const uint32_t *endp = words + nwords;
 427   uint32_t x[16];
 428   uint32_t a = ctx->state[0];
 429   uint32_t b = ctx->state[1];
 430   uint32_t c = ctx->state[2];
 431   uint32_t d = ctx->state[3];
 432   uint32_t e = ctx->state[4];
 433   uint32_t f = ctx->state[5];
 434   uint32_t g = ctx->state[6];
 435   uint32_t h = ctx->state[7];
 436
 437   /* First increment the byte count.  FIPS PUB 180-2 specifies the possible
 438      length of the file up to 2^64 bits.  Here we only compute the
 439      number of bytes.  Do a double word increment.  */
 440   ctx->total[0] += len;
 441   if (ctx->total[0] < len)
 442     ++ctx->total[1];
 443
 444 #define rol(x, n) (((x) << (n)) | ((x) >> (32 - (n))))
 445 #define S0(x) (rol(x,25)^rol(x,14)^(x>>3))
 446 #define S1(x) (rol(x,15)^rol(x,13)^(x>>10))
 447 #define SS0(x) (rol(x,30)^rol(x,19)^rol(x,10))
 448 #define SS1(x) (rol(x,26)^rol(x,21)^rol(x,7))
 449
 450 #define M(I) ( tm =   S1(x[(I-2)&0x0f]) + x[(I-7)&0x0f] \
 451                     + S0(x[(I-15)&0x0f]) + x[I&0x0f]    \
 452                , x[I&0x0f] = tm )
 453
 454 #define R(A,B,C,D,E,F,G,H,K,M)  do { t0 = SS0(A) + F2(A,B,C); \
 455                                      t1 = H + SS1(E)  \
 456                                       + F1(E,F,G)     \
 457                                       + K             \
 458                                       + M;            \
 459                                      D += t1;  H = t0 + t1; \
 460                                } while(0)
 461
 462   while (words < endp)
 463     {
 464       uint32_t tm;
 465       uint32_t t0, t1;
 466       int t;
 467       /* FIXME: see sha1.c for a better implementation.  */
 468       for (t = 0; t < 16; t++)
 469         {
 470           x[t] = SWAP (*words);
 471           words++;
 472         }
 473
 474       R( a, b, c, d, e, f, g, h, K( 0), x[ 0] );
 475       R( h, a, b, c, d, e, f, g, K( 1), x[ 1] );
 476       R( g, h, a, b, c, d, e, f, K( 2), x[ 2] );
 477       R( f, g, h, a, b, c, d, e, K( 3), x[ 3] );
 478       R( e, f, g, h, a, b, c, d, K( 4), x[ 4] );
 479       R( d, e, f, g, h, a, b, c, K( 5), x[ 5] );
 480       R( c, d, e, f, g, h, a, b, K( 6), x[ 6] );
 481       R( b, c, d, e, f, g, h, a, K( 7), x[ 7] );
 482       R( a, b, c, d, e, f, g, h, K( 8), x[ 8] );
 483       R( h, a, b, c, d, e, f, g, K( 9), x[ 9] );
 484       R( g, h, a, b, c, d, e, f, K(10), x[10] );
 485       R( f, g, h, a, b, c, d, e, K(11), x[11] );
 486       R( e, f, g, h, a, b, c, d, K(12), x[12] );
 487       R( d, e, f, g, h, a, b, c, K(13), x[13] );
 488       R( c, d, e, f, g, h, a, b, K(14), x[14] );
 489       R( b, c, d, e, f, g, h, a, K(15), x[15] );
 490       R( a, b, c, d, e, f, g, h, K(16), M(16) );
 491       R( h, a, b, c, d, e, f, g, K(17), M(17) );
 492       R( g, h, a, b, c, d, e, f, K(18), M(18) );
 493       R( f, g, h, a, b, c, d, e, K(19), M(19) );
 494       R( e, f, g, h, a, b, c, d, K(20), M(20) );
 495       R( d, e, f, g, h, a, b, c, K(21), M(21) );
 496       R( c, d, e, f, g, h, a, b, K(22), M(22) );
 497       R( b, c, d, e, f, g, h, a, K(23), M(23) );
 498       R( a, b, c, d, e, f, g, h, K(24), M(24) );
 499       R( h, a, b, c, d, e, f, g, K(25), M(25) );
 500       R( g, h, a, b, c, d, e, f, K(26), M(26) );
 501       R( f, g, h, a, b, c, d, e, K(27), M(27) );
 502       R( e, f, g, h, a, b, c, d, K(28), M(28) );
 503       R( d, e, f, g, h, a, b, c, K(29), M(29) );
 504       R( c, d, e, f, g, h, a, b, K(30), M(30) );
 505       R( b, c, d, e, f, g, h, a, K(31), M(31) );
 506       R( a, b, c, d, e, f, g, h, K(32), M(32) );
 507       R( h, a, b, c, d, e, f, g, K(33), M(33) );
 508       R( g, h, a, b, c, d, e, f, K(34), M(34) );
 509       R( f, g, h, a, b, c, d, e, K(35), M(35) );
 510       R( e, f, g, h, a, b, c, d, K(36), M(36) );
 511       R( d, e, f, g, h, a, b, c, K(37), M(37) );
 512       R( c, d, e, f, g, h, a, b, K(38), M(38) );
 513       R( b, c, d, e, f, g, h, a, K(39), M(39) );
 514       R( a, b, c, d, e, f, g, h, K(40), M(40) );
 515       R( h, a, b, c, d, e, f, g, K(41), M(41) );
 516       R( g, h, a, b, c, d, e, f, K(42), M(42) );
 517       R( f, g, h, a, b, c, d, e, K(43), M(43) );
 518       R( e, f, g, h, a, b, c, d, K(44), M(44) );
 519       R( d, e, f, g, h, a, b, c, K(45), M(45) );
 520       R( c, d, e, f, g, h, a, b, K(46), M(46) );
 521       R( b, c, d, e, f, g, h, a, K(47), M(47) );
 522       R( a, b, c, d, e, f, g, h, K(48), M(48) );
 523       R( h, a, b, c, d, e, f, g, K(49), M(49) );
 524       R( g, h, a, b, c, d, e, f, K(50), M(50) );
 525       R( f, g, h, a, b, c, d, e, K(51), M(51) );
 526       R( e, f, g, h, a, b, c, d, K(52), M(52) );
 527       R( d, e, f, g, h, a, b, c, K(53), M(53) );
 528       R( c, d, e, f, g, h, a, b, K(54), M(54) );
 529       R( b, c, d, e, f, g, h, a, K(55), M(55) );
 530       R( a, b, c, d, e, f, g, h, K(56), M(56) );
 531       R( h, a, b, c, d, e, f, g, K(57), M(57) );
 532       R( g, h, a, b, c, d, e, f, K(58), M(58) );
 533       R( f, g, h, a, b, c, d, e, K(59), M(59) );
 534       R( e, f, g, h, a, b, c, d, K(60), M(60) );
 535       R( d, e, f, g, h, a, b, c, K(61), M(61) );
 536       R( c, d, e, f, g, h, a, b, K(62), M(62) );
 537       R( b, c, d, e, f, g, h, a, K(63), M(63) );
 538
 539       a = ctx->state[0] += a;
 540       b = ctx->state[1] += b;
 541       c = ctx->state[2] += c;
 542       d = ctx->state[3] += d;
 543       e = ctx->state[4] += e;
 544       f = ctx->state[5] += f;
 545       g = ctx->state[6] += g;
 546       h = ctx->state[7] += h;
 547     }
 548 }