scripts/mkhash.c

   1 /*
   2  * Copyright (C) 2016 Felix Fietkau <nbd@nbd.name>
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  *
  16  * -- MD5 code:
  17  *
  18  * This is an OpenSSL-compatible implementation of the RSA Data Security, Inc.
  19  * MD5 Message-Digest Algorithm (RFC 1321).
  20  *
  21  * Homepage:
  22  * http://openwall.info/wiki/people/solar/software/public-domain-source-code/md5
  23  *
  24  * Author:
  25  * Alexander Peslyak, better known as Solar Designer <solar at openwall.com>
  26  *
  27  * This software was written by Alexander Peslyak in 2001.  No copyright is
  28  * claimed, and the software is hereby placed in the public domain.
  29  * In case this attempt to disclaim copyright and place the software in the
  30  * public domain is deemed null and void, then the software is
  31  * Copyright (c) 2001 Alexander Peslyak and it is hereby released to the
  32  * general public under the following terms:
  33  *
  34  * Redistribution and use in source and binary forms, with or without
  35  * modification, are permitted.
  36  *
  37  * There's ABSOLUTELY NO WARRANTY, express or implied.
  38  *
  39  * (This is a heavily cut-down "BSD license".)
  40  *
  41  * This differs from Colin Plumb's older public domain implementation in that
  42  * no exactly 32-bit integer data type is required (any 32-bit or wider
  43  * unsigned integer data type will do), there's no compile-time endianness
  44  * configuration, and the function prototypes match OpenSSL's.  No code from
  45  * Colin Plumb's implementation has been reused; this comment merely compares
  46  * the properties of the two independent implementations.
  47  *
  48  * The primary goals of this implementation are portability and ease of use.
  49  * It is meant to be fast, but not as fast as possible.  Some known
  50  * optimizations are not included to reduce source code size and avoid
  51  * compile-time configuration.
  52  *
  53  * -- SHA256 Code:
  54  *
  55  * Copyright 2005 Colin Percival
  56  * All rights reserved.
  57  *
  58  * Redistribution and use in source and binary forms, with or without
  59  * modification, are permitted provided that the following conditions
  60  * are met:
  61  * 1. Redistributions of source code must retain the above copyright
  62  *    notice, this list of conditions and the following disclaimer.
  63  * 2. Redistributions in binary form must reproduce the above copyright
  64  *    notice, this list of conditions and the following disclaimer in the
  65  *    documentation and/or other materials provided with the distribution.
  66  *
  67  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  68  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  69  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  70  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  71  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  72  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  73  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  74  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  75  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  76  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  77  * SUCH DAMAGE.
  78  */
  79
  80
  81
  82 #include <endian.h>
  83 #include <stdio.h>
  84 #include <string.h>
  85 #include <stdint.h>
  86 #include <stdbool.h>
  87 #include <unistd.h>
  88
  89 #define ARRAY_SIZE(_n) (sizeof(_n) / sizeof((_n)[0]))
  90
  91 static void
  92 be32enc(void *buf, uint32_t u)
  93 {
  94         uint8_t *p = buf;
  95
  96         p[0] = ((uint8_t) ((u >> 24) & 0xff));
  97         p[1] = ((uint8_t) ((u >> 16) & 0xff));
  98         p[2] = ((uint8_t) ((u >> 8) & 0xff));
  99         p[3] = ((uint8_t) (u & 0xff));
 100 }
 101
 102 static void
 103 be64enc(void *buf, uint64_t u)
 104 {
 105         uint8_t *p = buf;
 106
 107         be32enc(p, ((uint32_t) (u >> 32)));
 108         be32enc(p + 4, ((uint32_t) (u & 0xffffffffULL)));
 109 }
 110
 111
 112 static uint16_t
 113 be16dec(const void *buf)
 114 {
 115         const uint8_t *p = buf;
 116
 117         return (((uint16_t) p[0]) << 8) | p[1];
 118 }
 119
 120 static uint32_t
 121 be32dec(const void *buf)
 122 {
 123         const uint8_t *p = buf;
 124
 125         return (((uint32_t) be16dec(p)) << 16) | be16dec(p + 2);
 126 }
 127
 128 #define MD5_DIGEST_LENGTH       16
 129
 130 typedef struct MD5_CTX {
 131         uint32_t lo, hi;
 132         uint32_t a, b, c, d;
 133         unsigned char buffer[64];
 134 } MD5_CTX;
 135
 136 /*
 137  * The basic MD5 functions.
 138  *
 139  * F and G are optimized compared to their RFC 1321 definitions for
 140  * architectures that lack an AND-NOT instruction, just like in Colin Plumb's
 141  * implementation.
 142  */
 143 #define F(x, y, z)                      ((z) ^ ((x) & ((y) ^ (z))))
 144 #define G(x, y, z)                      ((y) ^ ((z) & ((x) ^ (y))))
 145 #define H(x, y, z)                      (((x) ^ (y)) ^ (z))
 146 #define H2(x, y, z)                     ((x) ^ ((y) ^ (z)))
 147 #define I(x, y, z)                      ((y) ^ ((x) | ~(z)))
 148
 149 /*
 150  * The MD5 transformation for all four rounds.
 151  */
 152 #define STEP(f, a, b, c, d, x, t, s) \
 153         (a) += f((b), (c), (d)) + (x) + (t); \
 154         (a) = (((a) << (s)) | (((a) & 0xffffffff) >> (32 - (s)))); \
 155         (a) += (b);
 156
 157 /*
 158  * SET reads 4 input bytes in little-endian byte order and stores them
 159  * in a properly aligned word in host byte order.
 160  */
 161 #if __BYTE_ORDER == __LITTLE_ENDIAN
 162 #define SET(n) \
 163         (*(uint32_t *)&ptr[(n) * 4])
 164 #define GET(n) \
 165         SET(n)
 166 #else
 167 #define SET(n) \
 168         (block[(n)] = \
 169         (uint32_t)ptr[(n) * 4] | \
 170         ((uint32_t)ptr[(n) * 4 + 1] << 8) | \
 171         ((uint32_t)ptr[(n) * 4 + 2] << 16) | \
 172         ((uint32_t)ptr[(n) * 4 + 3] << 24))
 173 #define GET(n) \
 174         (block[(n)])
 175 #endif
 176
 177 /*
 178  * This processes one or more 64-byte data blocks, but does NOT update
 179  * the bit counters.  There are no alignment requirements.
 180  */
 181 static const void *MD5_body(MD5_CTX *ctx, const void *data, unsigned long size)
 182 {
 183         const unsigned char *ptr;
 184         uint32_t a, b, c, d;
 185         uint32_t saved_a, saved_b, saved_c, saved_d;
 186 #if __BYTE_ORDER != __LITTLE_ENDIAN
 187         uint32_t block[16];
 188 #endif
 189
 190         ptr = (const unsigned char *)data;
 191
 192         a = ctx->a;
 193         b = ctx->b;
 194         c = ctx->c;
 195         d = ctx->d;
 196
 197         do {
 198                 saved_a = a;
 199                 saved_b = b;
 200                 saved_c = c;
 201                 saved_d = d;
 202
 203 /* Round 1 */
 204                 STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
 205                 STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
 206                 STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
 207                 STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
 208                 STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
 209                 STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
 210                 STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
 211                 STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
 212                 STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
 213                 STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
 214                 STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
 215                 STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
 216                 STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
 217                 STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
 218                 STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
 219                 STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
 220
 221 /* Round 2 */
 222                 STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
 223                 STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
 224                 STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
 225                 STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
 226                 STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
 227                 STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
 228                 STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
 229                 STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
 230                 STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
 231                 STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
 232                 STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
 233                 STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
 234                 STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
 235                 STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
 236                 STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
 237                 STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
 238
 239 /* Round 3 */
 240                 STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
 241                 STEP(H2, d, a, b, c, GET(8), 0x8771f681, 11)
 242                 STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
 243                 STEP(H2, b, c, d, a, GET(14), 0xfde5380c, 23)
 244                 STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
 245                 STEP(H2, d, a, b, c, GET(4), 0x4bdecfa9, 11)
 246                 STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
 247                 STEP(H2, b, c, d, a, GET(10), 0xbebfbc70, 23)
 248                 STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
 249                 STEP(H2, d, a, b, c, GET(0), 0xeaa127fa, 11)
 250                 STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
 251                 STEP(H2, b, c, d, a, GET(6), 0x04881d05, 23)
 252                 STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
 253                 STEP(H2, d, a, b, c, GET(12), 0xe6db99e5, 11)
 254                 STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
 255                 STEP(H2, b, c, d, a, GET(2), 0xc4ac5665, 23)
 256
 257 /* Round 4 */
 258                 STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
 259                 STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
 260                 STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
 261                 STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
 262                 STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
 263                 STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
 264                 STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
 265                 STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
 266                 STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
 267                 STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
 268                 STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
 269                 STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
 270                 STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
 271                 STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
 272                 STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
 273                 STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
 274
 275                 a += saved_a;
 276                 b += saved_b;
 277                 c += saved_c;
 278                 d += saved_d;
 279
 280                 ptr += 64;
 281         } while (size -= 64);
 282
 283         ctx->a = a;
 284         ctx->b = b;
 285         ctx->c = c;
 286         ctx->d = d;
 287
 288         return ptr;
 289 }
 290
 291 void MD5_begin(MD5_CTX *ctx)
 292 {
 293         ctx->a = 0x67452301;
 294         ctx->b = 0xefcdab89;
 295         ctx->c = 0x98badcfe;
 296         ctx->d = 0x10325476;
 297
 298         ctx->lo = 0;
 299         ctx->hi = 0;
 300 }
 301
 302 static void
 303 MD5_hash(const void *data, size_t size, MD5_CTX *ctx)
 304 {
 305         uint32_t saved_lo;
 306         unsigned long used, available;
 307
 308         saved_lo = ctx->lo;
 309         if ((ctx->lo = (saved_lo + size) & 0x1fffffff) < saved_lo)
 310                 ctx->hi++;
 311         ctx->hi += size >> 29;
 312
 313         used = saved_lo & 0x3f;
 314
 315         if (used) {
 316                 available = 64 - used;
 317
 318                 if (size < available) {
 319                         memcpy(&ctx->buffer[used], data, size);
 320                         return;
 321                 }
 322
 323                 memcpy(&ctx->buffer[used], data, available);
 324                 data = (const unsigned char *)data + available;
 325                 size -= available;
 326                 MD5_body(ctx, ctx->buffer, 64);
 327         }
 328
 329         if (size >= 64) {
 330                 data = MD5_body(ctx, data, size & ~((size_t) 0x3f));
 331                 size &= 0x3f;
 332         }
 333
 334         memcpy(ctx->buffer, data, size);
 335 }
 336
 337 static void
 338 MD5_end(void *resbuf, MD5_CTX *ctx)
 339 {
 340         unsigned char *result = resbuf;
 341         unsigned long used, available;
 342
 343         used = ctx->lo & 0x3f;
 344
 345         ctx->buffer[used++] = 0x80;
 346
 347         available = 64 - used;
 348
 349         if (available < 8) {
 350                 memset(&ctx->buffer[used], 0, available);
 351                 MD5_body(ctx, ctx->buffer, 64);
 352                 used = 0;
 353                 available = 64;
 354         }
 355
 356         memset(&ctx->buffer[used], 0, available - 8);
 357
 358         ctx->lo <<= 3;
 359         ctx->buffer[56] = ctx->lo;
 360         ctx->buffer[57] = ctx->lo >> 8;
 361         ctx->buffer[58] = ctx->lo >> 16;
 362         ctx->buffer[59] = ctx->lo >> 24;
 363         ctx->buffer[60] = ctx->hi;
 364         ctx->buffer[61] = ctx->hi >> 8;
 365         ctx->buffer[62] = ctx->hi >> 16;
 366         ctx->buffer[63] = ctx->hi >> 24;
 367
 368         MD5_body(ctx, ctx->buffer, 64);
 369
 370         result[0] = ctx->a;
 371         result[1] = ctx->a >> 8;
 372         result[2] = ctx->a >> 16;
 373         result[3] = ctx->a >> 24;
 374         result[4] = ctx->b;
 375         result[5] = ctx->b >> 8;
 376         result[6] = ctx->b >> 16;
 377         result[7] = ctx->b >> 24;
 378         result[8] = ctx->c;
 379         result[9] = ctx->c >> 8;
 380         result[10] = ctx->c >> 16;
 381         result[11] = ctx->c >> 24;
 382         result[12] = ctx->d;
 383         result[13] = ctx->d >> 8;
 384         result[14] = ctx->d >> 16;
 385         result[15] = ctx->d >> 24;
 386
 387         memset(ctx, 0, sizeof(*ctx));
 388 }
 389
 390 #define SHA256_BLOCK_LENGTH             64
 391 #define SHA256_DIGEST_LENGTH            32
 392 #define SHA256_DIGEST_STRING_LENGTH     (SHA256_DIGEST_LENGTH * 2 + 1)
 393
 394 typedef struct SHA256Context {
 395         uint32_t state[8];
 396         uint64_t count;
 397         uint8_t buf[SHA256_BLOCK_LENGTH];
 398 } SHA256_CTX;
 399
 400 #if BYTE_ORDER == BIG_ENDIAN
 401
 402 /* Copy a vector of big-endian uint32_t into a vector of bytes */
 403 #define be32enc_vect(dst, src, len)     \
 404         memcpy((void *)dst, (const void *)src, (size_t)len)
 405
 406 /* Copy a vector of bytes into a vector of big-endian uint32_t */
 407 #define be32dec_vect(dst, src, len)     \
 408         memcpy((void *)dst, (const void *)src, (size_t)len)
 409
 410 #else /* BYTE_ORDER != BIG_ENDIAN */
 411
 412 /*
 413  * Encode a length len/4 vector of (uint32_t) into a length len vector of
 414  * (unsigned char) in big-endian form.  Assumes len is a multiple of 4.
 415  */
 416 static void
 417 be32enc_vect(unsigned char *dst, const uint32_t *src, size_t len)
 418 {
 419         size_t i;
 420
 421         for (i = 0; i < len / 4; i++)
 422                 be32enc(dst + i * 4, src[i]);
 423 }
 424
 425 /*
 426  * Decode a big-endian length len vector of (unsigned char) into a length
 427  * len/4 vector of (uint32_t).  Assumes len is a multiple of 4.
 428  */
 429 static void
 430 be32dec_vect(uint32_t *dst, const unsigned char *src, size_t len)
 431 {
 432         size_t i;
 433
 434         for (i = 0; i < len / 4; i++)
 435                 dst[i] = be32dec(src + i * 4);
 436 }
 437
 438 #endif /* BYTE_ORDER != BIG_ENDIAN */
 439
 440
 441 /* Elementary functions used by SHA256 */
 442 #define Ch(x, y, z)     ((x & (y ^ z)) ^ z)
 443 #define Maj(x, y, z)    ((x & (y | z)) | (y & z))
 444 #define ROTR(x, n)      ((x >> n) | (x << (32 - n)))
 445
 446 /*
 447  * SHA256 block compression function.  The 256-bit state is transformed via
 448  * the 512-bit input block to produce a new state.
 449  */
 450 static void
 451 SHA256_Transform(uint32_t * state, const unsigned char block[64])
 452 {
 453         /* SHA256 round constants. */
 454         static const uint32_t K[64] = {
 455                 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
 456                 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
 457                 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
 458                 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
 459                 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
 460                 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
 461                 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
 462                 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
 463                 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
 464                 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
 465                 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
 466                 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
 467                 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
 468                 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
 469                 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
 470                 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 471         };
 472         uint32_t W[64];
 473         uint32_t S[8];
 474         int i;
 475
 476 #define S0(x)           (ROTR(x, 2) ^ ROTR(x, 13) ^ ROTR(x, 22))
 477 #define S1(x)           (ROTR(x, 6) ^ ROTR(x, 11) ^ ROTR(x, 25))
 478 #define s0(x)           (ROTR(x, 7) ^ ROTR(x, 18) ^ (x >> 3))
 479 #define s1(x)           (ROTR(x, 17) ^ ROTR(x, 19) ^ (x >> 10))
 480
 481 /* SHA256 round function */
 482 #define RND(a, b, c, d, e, f, g, h, k)                  \
 483         h += S1(e) + Ch(e, f, g) + k;                   \
 484         d += h;                                         \
 485         h += S0(a) + Maj(a, b, c);
 486
 487 /* Adjusted round function for rotating state */
 488 #define RNDr(S, W, i, ii)                       \
 489         RND(S[(64 - i) % 8], S[(65 - i) % 8],   \
 490             S[(66 - i) % 8], S[(67 - i) % 8],   \
 491             S[(68 - i) % 8], S[(69 - i) % 8],   \
 492             S[(70 - i) % 8], S[(71 - i) % 8],   \
 493             W[i + ii] + K[i + ii])
 494
 495 /* Message schedule computation */
 496 #define MSCH(W, ii, i)                          \
 497         W[i + ii + 16] = s1(W[i + ii + 14]) + W[i + ii + 9] + s0(W[i + ii + 1]) + W[i + ii]
 498
 499         /* 1. Prepare the first part of the message schedule W. */
 500         be32dec_vect(W, block, 64);
 501
 502         /* 2. Initialize working variables. */
 503         memcpy(S, state, 32);
 504
 505         /* 3. Mix. */
 506         for (i = 0; i < 64; i += 16) {
 507                 RNDr(S, W, 0, i);
 508                 RNDr(S, W, 1, i);
 509                 RNDr(S, W, 2, i);
 510                 RNDr(S, W, 3, i);
 511                 RNDr(S, W, 4, i);
 512                 RNDr(S, W, 5, i);
 513                 RNDr(S, W, 6, i);
 514                 RNDr(S, W, 7, i);
 515                 RNDr(S, W, 8, i);
 516                 RNDr(S, W, 9, i);
 517                 RNDr(S, W, 10, i);
 518                 RNDr(S, W, 11, i);
 519                 RNDr(S, W, 12, i);
 520                 RNDr(S, W, 13, i);
 521                 RNDr(S, W, 14, i);
 522                 RNDr(S, W, 15, i);
 523
 524                 if (i == 48)
 525                         break;
 526                 MSCH(W, 0, i);
 527                 MSCH(W, 1, i);
 528                 MSCH(W, 2, i);
 529                 MSCH(W, 3, i);
 530                 MSCH(W, 4, i);
 531                 MSCH(W, 5, i);
 532                 MSCH(W, 6, i);
 533                 MSCH(W, 7, i);
 534                 MSCH(W, 8, i);
 535                 MSCH(W, 9, i);
 536                 MSCH(W, 10, i);
 537                 MSCH(W, 11, i);
 538                 MSCH(W, 12, i);
 539                 MSCH(W, 13, i);
 540                 MSCH(W, 14, i);
 541                 MSCH(W, 15, i);
 542         }
 543
 544 #undef S0
 545 #undef s0
 546 #undef S1
 547 #undef s1
 548 #undef RND
 549 #undef RNDr
 550 #undef MSCH
 551
 552         /* 4. Mix local working variables into global state */
 553         for (i = 0; i < 8; i++)
 554                 state[i] += S[i];
 555 }
 556
 557 static unsigned char PAD[64] = {
 558         0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 559         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 560         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 561         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 562 };
 563
 564 /* Add padding and terminating bit-count. */
 565 static void
 566 SHA256_Pad(SHA256_CTX * ctx)
 567 {
 568         size_t r;
 569
 570         /* Figure out how many bytes we have buffered. */
 571         r = (ctx->count >> 3) & 0x3f;
 572
 573         /* Pad to 56 mod 64, transforming if we finish a block en route. */
 574         if (r < 56) {
 575                 /* Pad to 56 mod 64. */
 576                 memcpy(&ctx->buf[r], PAD, 56 - r);
 577         } else {
 578                 /* Finish the current block and mix. */
 579                 memcpy(&ctx->buf[r], PAD, 64 - r);
 580                 SHA256_Transform(ctx->state, ctx->buf);
 581
 582                 /* The start of the final block is all zeroes. */
 583                 memset(&ctx->buf[0], 0, 56);
 584         }
 585
 586         /* Add the terminating bit-count. */
 587         be64enc(&ctx->buf[56], ctx->count);
 588
 589         /* Mix in the final block. */
 590         SHA256_Transform(ctx->state, ctx->buf);
 591 }
 592
 593 /* SHA-256 initialization.  Begins a SHA-256 operation. */
 594 static void
 595 SHA256_Init(SHA256_CTX * ctx)
 596 {
 597
 598         /* Zero bits processed so far */
 599         ctx->count = 0;
 600
 601         /* Magic initialization constants */
 602         ctx->state[0] = 0x6A09E667;
 603         ctx->state[1] = 0xBB67AE85;
 604         ctx->state[2] = 0x3C6EF372;
 605         ctx->state[3] = 0xA54FF53A;
 606         ctx->state[4] = 0x510E527F;
 607         ctx->state[5] = 0x9B05688C;
 608         ctx->state[6] = 0x1F83D9AB;
 609         ctx->state[7] = 0x5BE0CD19;
 610 }
 611
 612 /* Add bytes into the hash */
 613 static void
 614 SHA256_Update(SHA256_CTX * ctx, const void *in, size_t len)
 615 {
 616         uint64_t bitlen;
 617         uint32_t r;
 618         const unsigned char *src = in;
 619
 620         /* Number of bytes left in the buffer from previous updates */
 621         r = (ctx->count >> 3) & 0x3f;
 622
 623         /* Convert the length into a number of bits */
 624         bitlen = len << 3;
 625
 626         /* Update number of bits */
 627         ctx->count += bitlen;
 628
 629         /* Handle the case where we don't need to perform any transforms */
 630         if (len < 64 - r) {
 631                 memcpy(&ctx->buf[r], src, len);
 632                 return;
 633         }
 634
 635         /* Finish the current block */
 636         memcpy(&ctx->buf[r], src, 64 - r);
 637         SHA256_Transform(ctx->state, ctx->buf);
 638         src += 64 - r;
 639         len -= 64 - r;
 640
 641         /* Perform complete blocks */
 642         while (len >= 64) {
 643                 SHA256_Transform(ctx->state, src);
 644                 src += 64;
 645                 len -= 64;
 646         }
 647
 648         /* Copy left over data into buffer */
 649         memcpy(ctx->buf, src, len);
 650 }
 651
 652 /*
 653  * SHA-256 finalization.  Pads the input data, exports the hash value,
 654  * and clears the context state.
 655  */
 656 static void
 657 SHA256_Final(unsigned char digest[static SHA256_DIGEST_LENGTH], SHA256_CTX *ctx)
 658 {
 659         /* Add padding */
 660         SHA256_Pad(ctx);
 661
 662         /* Write the hash */
 663         be32enc_vect(digest, ctx->state, SHA256_DIGEST_LENGTH);
 664
 665         /* Clear the context state */
 666         memset(ctx, 0, sizeof(*ctx));
 667 }
 668
 669 static void *hash_buf(FILE *f, int *len)
 670 {
 671         static char buf[1024];
 672
 673         *len = fread(buf, 1, sizeof(buf), f);
 674
 675         return *len > 0 ? buf : NULL;
 676 }
 677
 678 static char *hash_string(unsigned char *buf, int len)
 679 {
 680         static char str[SHA256_DIGEST_LENGTH * 2 + 1];
 681         int i;
 682
 683         if (len * 2 + 1 > sizeof(str))
 684                 return NULL;
 685
 686         for (i = 0; i < len; i++)
 687                 sprintf(&str[i * 2], "%02x", buf[i]);
 688
 689         return str;
 690 }
 691
 692 static const char *md5_hash(FILE *f)
 693 {
 694         MD5_CTX ctx;
 695         unsigned char val[MD5_DIGEST_LENGTH];
 696         void *buf;
 697         int len;
 698
 699         MD5_begin(&ctx);
 700         while ((buf = hash_buf(f, &len)) != NULL)
 701                 MD5_hash(buf, len, &ctx);
 702         MD5_end(val, &ctx);
 703
 704         return hash_string(val, MD5_DIGEST_LENGTH);
 705 }
 706
 707 static const char *sha256_hash(FILE *f)
 708 {
 709         SHA256_CTX ctx;
 710         unsigned char val[SHA256_DIGEST_LENGTH];
 711         void *buf;
 712         int len;
 713
 714         SHA256_Init(&ctx);
 715         while ((buf = hash_buf(f, &len)) != NULL)
 716                 SHA256_Update(&ctx, buf, len);
 717         SHA256_Final(val, &ctx);
 718
 719         return hash_string(val, SHA256_DIGEST_LENGTH);
 720 }
 721
 722
 723 struct hash_type {
 724         const char *name;
 725         const char *(*func)(FILE *f);
 726         int len;
 727 };
 728
 729 struct hash_type types[] = {
 730         { "md5", md5_hash, MD5_DIGEST_LENGTH },
 731         { "sha256", sha256_hash, SHA256_DIGEST_LENGTH },
 732 };
 733
 734
 735 static int usage(const char *progname)
 736 {
 737         int i;
 738
 739         fprintf(stderr, "Usage: %s <hash type> [<file>...]\n"
 740                 "Supported hash types:", progname);
 741
 742         for (i = 0; i < ARRAY_SIZE(types); i++)
 743                 fprintf(stderr, "%s %s", i ? "," : "", types[i].name);
 744
 745         fprintf(stderr, "\n");
 746         return 1;
 747 }
 748
 749 static struct hash_type *get_hash_type(const char *name)
 750 {
 751         int i;
 752
 753         for (i = 0; i < ARRAY_SIZE(types); i++) {
 754                 struct hash_type *t = &types[i];
 755
 756                 if (!strcmp(t->name, name))
 757                         return t;
 758         }
 759         return NULL;
 760 }
 761
 762
 763 static int hash_file(struct hash_type *t, const char *filename, bool add_filename)
 764 {
 765         const char *str;
 766
 767         if (!filename || !strcmp(filename, "-")) {
 768                 str = t->func(stdin);
 769         } else {
 770                 FILE *f = fopen(filename, "r");
 771
 772                 if (!f) {
 773                         fprintf(stderr, "Failed to open '%s'\n", filename);
 774                         return 1;
 775                 }
 776                 str = t->func(f);
 777                 fclose(f);
 778         }
 779
 780         if (!str) {
 781                 fprintf(stderr, "Failed to generate hash\n");
 782                 return 1;
 783         }
 784
 785         if (add_filename)
 786                 printf("%s %s\n", str, filename ? filename : "-");
 787         else
 788                 printf("%s\n", str);
 789         return 0;
 790 }
 791
 792
 793 int main(int argc, char **argv)
 794 {
 795         struct hash_type *t;
 796         const char *progname = argv[0];
 797         int i, ch;
 798         bool add_filename = false;
 799
 800         while ((ch = getopt(argc, argv, "n")) != -1) {
 801                 switch (ch) {
 802                 case 'n':
 803                         add_filename = true;
 804                         break;
 805                 default:
 806                         return usage(progname);
 807                 }
 808         }
 809
 810         argc -= optind;
 811         argv += optind;
 812
 813         if (argc < 1)
 814                 return usage(progname);
 815
 816         t = get_hash_type(argv[0]);
 817         if (!t)
 818                 return usage(progname);
 819
 820         if (argc < 2)
 821                 return hash_file(t, NULL, add_filename);
 822
 823         for (i = 0; i < argc - 1; i++)
 824                 hash_file(t, argv[1 + i], add_filename);
 825
 826         return 0;
 827 }