toys/lsb/md5sum.c

   1 /* md5sum.c - Calculate RFC 1321 md5 hash and sha1 hash.
   2  *
   3  * Copyright 2012 Rob Landley <rob@landley.net>
   4  *
   5  * See http://refspecs.linuxfoundation.org/LSB_4.1.0/LSB-Core-generic/LSB-Core-generic/md5sum.html
   6  * and http://www.ietf.org/rfc/rfc1321.txt
   7  *
   8  * They're combined this way to share infrastructure, and because md5sum is
   9  * and LSB standard command, sha1sum is just a good idea.
  10
  11 USE_MD5SUM(NEWTOY(md5sum, "b", TOYFLAG_USR|TOYFLAG_BIN))
  12 USE_SHA1SUM(NEWTOY(sha1sum, "b", TOYFLAG_USR|TOYFLAG_BIN))
  13
  14 config MD5SUM
  15   bool "md5sum"
  16   default y
  17   help
  18     usage: md5sum [FILE]...
  19
  20     Calculate md5 hash for each input file, reading from stdin if none.
  21     Output one hash (16 hex digits) for each input file, followed by
  22     filename.
  23
  24     -b  brief (hash only, no filename)
  25
  26 config SHA1SUM
  27   bool "sha1sum"
  28   default y
  29   help
  30     usage: sha1sum [FILE]...
  31
  32     calculate sha1 hash for each input file, reading from stdin if none.
  33     Output one hash (20 hex digits) for each input file, followed by
  34     filename.
  35
  36     -b  brief (hash only, no filename)
  37 */
  38
  39 #define FOR_md5sum
  40 #include "toys.h"
  41
  42 GLOBALS(
  43   unsigned state[5];
  44   unsigned oldstate[5];
  45   uint64_t count;
  46   union {
  47     char c[64];
  48     unsigned i[16];
  49   } buffer;
  50 )
  51
  52 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits))))
  53
  54 // for(i=0; i<64; i++) md5table[i] = abs(sin(i+1))*(1<<32);  But calculating
  55 // that involves not just floating point but pulling in -lm (and arguing with
  56 // C about whether 1<<32 is a valid thing to do on 32 bit platforms) so:
  57
  58 static uint32_t md5table[64] = {
  59   0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a,
  60   0xa8304613, 0xfd469501, 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be,
  61   0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, 0xf61e2562, 0xc040b340,
  62   0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
  63   0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8,
  64   0x676f02d9, 0x8d2a4c8a, 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c,
  65   0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, 0x289b7ec6, 0xeaa127fa,
  66   0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
  67   0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92,
  68   0xffeff47d, 0x85845dd1, 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
  69   0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
  70 };
  71
  72 static const uint8_t md5rot[64] = {
  73   7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
  74   5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20,
  75   4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
  76   6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21
  77 };
  78
  79 // Mix next 64 bytes of data into md5 hash
  80
  81 static void md5_transform(void)
  82 {
  83   unsigned x[4], *b = TT.buffer.i;
  84   int i;
  85
  86   memcpy(x, TT.state, sizeof(x));
  87
  88   for (i=0; i<64; i++) {
  89     unsigned int in, temp, swap;
  90     if (i<16) {
  91       in = i;
  92       temp = x[1];
  93       temp = (temp & x[2]) | ((~temp) & x[3]);
  94     } else if (i<32) {
  95       in = (1+(5*i))&15;
  96       temp = x[3];
  97       temp = (x[1] & temp) | (x[2] & ~temp);
  98     } else if (i<48) {
  99       in = (3*i+5)&15;
 100       temp = x[1] ^ x[2] ^ x[3];
 101     } else {
 102       in = (7*i)&15;
 103       temp = x[2] ^ (x[1] | ~x[3]);
 104     }
 105     temp += x[0] + b[in] + md5table[i];
 106     swap = x[3];
 107     x[3] = x[2];
 108     x[2] = x[1];
 109     x[1] += rol(temp, md5rot[i]);
 110     x[0] = swap;
 111   }
 112   for (i=0; i<4; i++) TT.state[i] += x[i];
 113 }
 114
 115 // Mix next 64 bytes of data into sha1 hash.
 116
 117 static const unsigned rconsts[]={0x5A827999,0x6ED9EBA1,0x8F1BBCDC,0xCA62C1D6};
 118
 119 static void sha1_transform(void)
 120 {
 121   int i, j, k, count;
 122   unsigned *block = TT.buffer.i;
 123   unsigned *rot[5], *temp;
 124
 125   // Copy context->state[] to working vars
 126   for (i=0; i<5; i++) {
 127     TT.oldstate[i] = TT.state[i];
 128     rot[i] = TT.state + i;
 129   }
 130   // 4 rounds of 20 operations each.
 131   for (i=count=0; i<4; i++) {
 132     for (j=0; j<20; j++) {
 133       unsigned work;
 134
 135       work = *rot[2] ^ *rot[3];
 136       if (!i) work = (work & *rot[1]) ^ *rot[3];
 137       else {
 138         if (i==2) work = ((*rot[1]|*rot[2])&*rot[3])|(*rot[1]&*rot[2]);
 139         else work ^= *rot[1];
 140       }
 141
 142       if (!i && j<16)
 143         work += block[count] = (rol(block[count],24)&0xFF00FF00)
 144                              | (rol(block[count],8)&0x00FF00FF);
 145       else
 146         work += block[count&15] = rol(block[(count+13)&15]
 147               ^ block[(count+8)&15] ^ block[(count+2)&15] ^ block[count&15], 1);
 148       *rot[4] += work + rol(*rot[0],5) + rconsts[i];
 149       *rot[1] = rol(*rot[1],30);
 150
 151       // Rotate by one for next time.
 152       temp = rot[4];
 153       for (k=4; k; k--) rot[k] = rot[k-1];
 154       *rot = temp;
 155       count++;
 156     }
 157   }
 158   // Add the previous values of state[]
 159   for (i=0; i<5; i++) TT.state[i] += TT.oldstate[i];
 160 }
 161
 162 // Fill the 64-byte working buffer and call transform() when full.
 163
 164 static void hash_update(char *data, unsigned int len, void (*transform)(void))
 165 {
 166   unsigned int i, j;
 167
 168   j = TT.count & 63;
 169   TT.count += len;
 170
 171   for (;;) {
 172     // Grab next chunk of data, return if it's not enough to process a frame
 173     i = 64 - j;
 174     if (i>len) i = len;
 175     memcpy(TT.buffer.c+j, data, i);
 176     if (j+i != 64) break;
 177
 178     // Process a frame
 179     if (IS_BIG_ENDIAN)
 180       for (j=0; j<16; j++) TT.buffer.i[j] = SWAP_LE32(TT.buffer.i[j]);
 181     transform();
 182     j=0;
 183     data += i;
 184     len -= i;
 185   }
 186 }
 187
 188 // Callback for loopfiles()
 189
 190 static void do_hash(int fd, char *name)
 191 {
 192   uint64_t count;
 193   int i, sha1=toys.which->name[0]=='s';;
 194   char buf;
 195   void (*transform)(void);
 196
 197   /* SHA1 initialization constants  (md5sum uses first 4) */
 198   TT.state[0] = 0x67452301;
 199   TT.state[1] = 0xEFCDAB89;
 200   TT.state[2] = 0x98BADCFE;
 201   TT.state[3] = 0x10325476;
 202   TT.state[4] = 0xC3D2E1F0;
 203   TT.count = 0;
 204
 205   transform = sha1 ? sha1_transform : md5_transform;
 206   for (;;) {
 207     i = read(fd, toybuf, sizeof(toybuf));
 208     if (i<1) break;
 209     hash_update(toybuf, i, transform);
 210   }
 211
 212   count = TT.count << 3;
 213
 214   // End the message by appending a "1" bit to the data, ending with the
 215   // message size (in bits, big endian), and adding enough zero bits in
 216   // between to pad to the end of the next 64-byte frame.
 217   //
 218   // Since our input up to now has been in whole bytes, we can deal with
 219   // bytes here too.
 220
 221   buf = 0x80;
 222   do {
 223     hash_update(&buf, 1, transform);
 224     buf = 0;
 225   } while ((TT.count & 63) != 56);
 226   count = sha1 ? SWAP_BE64(count) : SWAP_LE64(count);
 227   hash_update((void *)&count, 8, transform);
 228
 229   if (sha1)
 230     for (i = 0; i < 20; i++)
 231       printf("%02x", 255&(TT.state[i>>2] >> ((3-(i & 3)) * 8)));
 232   else for (i=0; i<4; i++) printf("%08x", bswap_32(TT.state[i]));
 233
 234   // Wipe variables. Cryptographer paranoia.
 235   memset(&TT, 0, sizeof(TT));
 236
 237   printf((toys.optflags & FLAG_b) ? "\n" : "  %s\n", name);
 238 }
 239
 240 void md5sum_main(void)
 241 {
 242   loopfiles(toys.optargs, do_hash);
 243 }
 244
 245 void sha1sum_main(void)
 246 {
 247   md5sum_main();
 248 }