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