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