src/utils/mkFileSum.c

   1 /*
   2  * This file is part of the aMule project.
   3  *
   4  * Copyright (c) 2003-2011 aMule Team ( admin@amule.org / http://www.amule.org )
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either
   9  * version 2 of the License, or (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, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  19  */
  20
  21 /*
  22  * This program generates an md5sum from a C/C++ source file.
  23  * Basic preprocessing is applied to the source (comment removal,
  24  * whitespace normalization), so only real code change will result
  25  * in md5sum change.
  26  *
  27  * Preprocessor code is written by Dévai Tamás (gonosztopi@amule.org)
  28  * md5 code is taken from src/MD5Sum.cpp
  29  *
  30  * Usage: the program takes input from stdin and places output to stdout.
  31  * This behaviour cannot be altered.
  32  */
  33
  34 #include <inttypes.h>
  35 #include <stdio.h>
  36
  37 typedef unsigned char *POINTER;
  38 typedef uint16_t UINT2;
  39 typedef uint32_t UINT4;
  40
  41 typedef struct {
  42   UINT4 state[4];
  43   UINT4 count[2];
  44   unsigned char buffer[64];
  45 } MD5_CTX;
  46
  47 void MD5Init(MD5_CTX *);
  48 void MD5Update(MD5_CTX *, const unsigned char *, unsigned int);
  49 void MD5Final(unsigned char [16], MD5_CTX *);
  50
  51
  52 const int table[][9] = {
  53         { 0x0206, 0x0206, 0x0008, 0x0100, 0x0101, 0x0102, 0x000e, 0x0100, 0x00ff },
  54         { 0x0101, 0x0101, 0x0101, 0x0101, 0x0100, 0x0101, 0x010b, 0x0101, 0x00ff },
  55         { 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0100, 0x010c, 0x0102, 0x00ff },
  56         { 0x0003, 0x0003, 0x0003, 0x0009, 0x0003, 0x0003, 0x0003, 0x0003, 0x00ff },
  57         { 0x0006, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x0004, 0x00ff },
  58         { 0x0206, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x0005, 0x00ff },
  59         { 0x0006, 0x0006, 0x0007, 0x0100, 0x0101, 0x0102, 0x000d, 0x0100, 0x00ff },
  60         { 0x0606, 0x0606, 0x0004, 0x000f, 0x0401, 0x0402, 0x050a, 0x0400, 0x04ff },
  61         { 0x0606, 0x0606, 0x0005, 0x0003, 0x0401, 0x0402, 0x050a, 0x0400, 0x04ff },
  62         { 0x0003, 0x0003, 0x0000, 0x0003, 0x0003, 0x0003, 0x0003, 0x0003, 0x00ff },
  63         { 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x0100, 0x00ff },
  64         { 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x00ff },
  65         { 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x00ff },
  66         { 0x0006, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x00ff },
  67         { 0x0206, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x00ff },
  68         { 0x000f, 0x000f, 0x000f, 0x0010, 0x000f, 0x000f, 0x000f, 0x000f, 0x00ff },
  69         { 0x000f, 0x000f, 0x0006, 0x000f, 0x000f, 0x000f, 0x000f, 0x000f, 0x00ff }
  70 };
  71
  72 int GetCharCode(int c)
  73 {
  74         if (c == '\r' || c == '\n') return 0;
  75         if (c == ' ' || c == '\t') return 1;
  76         if (c == '/') return 2;
  77         if (c == '*') return 3;
  78         if (c == '\"') return 4;
  79         if (c == '\'') return 5;
  80         if (c == '\\') return 6;
  81         if (c == EOF) return 8;
  82         return 7;
  83 }
  84
  85 int main()
  86 {
  87         int state = 0;
  88         MD5_CTX context;
  89         unsigned char digest[16];
  90         unsigned char buffer[1024];
  91         int count = 0;
  92
  93         MD5Init(&context);
  94
  95         while (state != 0x00ff) {
  96                 int c = getchar();
  97                 state = table[state][GetCharCode(c)];
  98                 if (state & 0x0800) {
  99                         buffer[count++] = '\\';
 100                 }
 101                 if (state & 0x0400) {
 102                         buffer[count++] = '/';
 103                 }
 104                 if (state & 0x0200) {
 105                         buffer[count++] = ' ';
 106                 }
 107                 if (state & 0x0100) {
 108                         buffer[count++] = c;
 109                 }
 110                 state &= 0x00ff;
 111                 if (count > 1020) {
 112                         MD5Update(&context, buffer, count);
 113                         count = 0;
 114                 }
 115         }
 116         MD5Update(&context, buffer, count);
 117         MD5Final(digest, &context);
 118         for (count = 0; count < 16; count++) printf("%02x", digest[count]);
 119         putchar('\n');
 120         return 0;
 121 }
 122
 123
 124 #define S11 7
 125 #define S12 12
 126 #define S13 17
 127 #define S14 22
 128 #define S21 5
 129 #define S22 9
 130 #define S23 14
 131 #define S24 20
 132 #define S31 4
 133 #define S32 11
 134 #define S33 16
 135 #define S34 23
 136 #define S41 6
 137 #define S42 10
 138 #define S43 15
 139 #define S44 21
 140
 141 static void MD5Transform (UINT4 [4], const unsigned char [64]);
 142 static void Encode (unsigned char *, UINT4 *, unsigned int);
 143 static void Decode (UINT4 *, const unsigned char *, unsigned int);
 144 static void MD5_memcpy (POINTER, POINTER, unsigned int);
 145 static void MD5_memset (POINTER, int, unsigned int);
 146
 147 static unsigned char PADDING[64] = {
 148   0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 149   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 150   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
 151 };
 152
 153 /* F, G, H and I are basic MD5 functions.
 154  */
 155 #define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
 156 #define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
 157 #define H(x, y, z) ((x) ^ (y) ^ (z))
 158 #define I(x, y, z) ((y) ^ ((x) | (~z)))
 159
 160 /* ROTATE_LEFT rotates x left n bits.
 161         15-April-2003 Sony: use MSVC intrinsic to save some cycles
 162  */
 163 #ifdef _MSC_VER
 164 #pragma intrinsic(_rotl)
 165 #define ROTATE_LEFT(x, n) _rotl((x), (n))
 166 #else
 167 #define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
 168 #endif
 169
 170 /* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
 171 Rotation is separate from addition to prevent recomputation.
 172 */
 173 /* Defines must be on one line to work with GCC-2.95.3 */
 174 #define FF(a, b, c, d, x, s, ac) { (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b); }
 175 #define GG(a, b, c, d, x, s, ac) { (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b); }
 176 #define HH(a, b, c, d, x, s, ac) { (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b); }
 177 #define II(a, b, c, d, x, s, ac) { (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b); }
 178
 179 /* MD5 initialization. Begins an MD5 operation, writing a new context.
 180  */
 181 void MD5Init (MD5_CTX *context)
 182 {
 183   context->count[0] = context->count[1] = 0;
 184   /* Load magic initialization constants.
 185 */
 186   context->state[0] = 0x67452301;
 187   context->state[1] = 0xefcdab89;
 188   context->state[2] = 0x98badcfe;
 189   context->state[3] = 0x10325476;
 190 }
 191
 192 /* MD5 block update operation. Continues an MD5 message-digest
 193   operation, processing another message block, and updating the
 194   context.
 195  */
 196 void MD5Update (MD5_CTX *context, const unsigned char *input, unsigned int inputLen)
 197 {
 198         unsigned int i, index, partLen;
 199
 200         /* Compute number of bytes mod 64 */
 201         index = (unsigned int)((context->count[0] >> 3) & 0x3F);
 202
 203         /* Update number of bits */
 204         if ((context->count[0] += ((UINT4)inputLen << 3)) < ((UINT4)inputLen << 3)) {
 205                 context->count[1]++;
 206         }
 207         context->count[1] += ((UINT4)inputLen >> 29);
 208         partLen = 64 - index;
 209
 210         /* Transform as many times as possible. */
 211         if (inputLen >= partLen) {
 212                 MD5_memcpy((POINTER)&context->buffer[index], (POINTER)input, partLen);
 213                 MD5Transform (context->state, context->buffer);
 214
 215                 for (i = partLen; i + 63 < inputLen; i += 64) {
 216                         MD5Transform (context->state, &input[i]);
 217                 }
 218                 index = 0;
 219         } else {
 220                 i = 0;
 221         }
 222         /* Buffer remaining input */
 223         MD5_memcpy((POINTER)&context->buffer[index], (POINTER)&input[i], inputLen-i);
 224 }
 225
 226 /* MD5 finalization. Ends an MD5 message-digest operation, writing the
 227  * the message digest and zeroizing the context.
 228  */
 229 void MD5Final (unsigned char digest[16], MD5_CTX *context)
 230 {
 231         unsigned char bits[8];
 232         unsigned int index, padLen;
 233
 234         /* Save number of bits */
 235         Encode (bits, context->count, 8);
 236
 237         /* Pad out to 56 mod 64. */
 238         index = (unsigned int)((context->count[0] >> 3) & 0x3f);
 239         padLen = (index < 56) ? (56 - index) : (120 - index);
 240         MD5Update (context, PADDING, padLen);
 241
 242         /* Append length (before padding) */
 243         MD5Update (context, bits, 8);
 244         /* Store state in digest */
 245         Encode (digest, context->state, 16);
 246
 247         /* Zeroize sensitive information.*/
 248         MD5_memset ((POINTER)context, 0, sizeof (*context));
 249 }
 250
 251 /* MD5 basic transformation. Transforms state based on block.
 252  */
 253 static void MD5Transform (UINT4 state[4], const unsigned char block[64])
 254 {
 255   UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
 256
 257   Decode (x, block, 64);
 258
 259   /* Round 1 */
 260   FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
 261   FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
 262   FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
 263   FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
 264   FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
 265   FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
 266   FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
 267   FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
 268   FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
 269   FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
 270   FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
 271   FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
 272   FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
 273   FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
 274   FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
 275   FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
 276
 277  /* Round 2 */
 278   GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
 279   GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
 280   GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
 281   GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
 282   GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
 283   GG (d, a, b, c, x[10], S22,  0x2441453); /* 22 */
 284   GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
 285   GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
 286   GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
 287   GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
 288   GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
 289   GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
 290   GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
 291   GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
 292   GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
 293   GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
 294
 295   /* Round 3 */
 296   HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
 297   HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
 298   HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
 299   HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
 300   HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
 301   HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
 302   HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
 303   HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
 304   HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
 305   HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
 306   HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
 307   HH (b, c, d, a, x[ 6], S34,  0x4881d05); /* 44 */
 308   HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
 309   HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
 310   HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
 311   HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
 312
 313   /* Round 4 */
 314   II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
 315   II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
 316   II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
 317   II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
 318   II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
 319   II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
 320   II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
 321   II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
 322   II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
 323   II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
 324   II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
 325   II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
 326   II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
 327   II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
 328   II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
 329   II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
 330
 331   state[0] += a;
 332   state[1] += b;
 333   state[2] += c;
 334   state[3] += d;
 335
 336   /* Zeroize sensitive information.
 337    */
 338   MD5_memset ((POINTER)x, 0, sizeof (x));
 339 }
 340
 341 /* Encodes input (UINT4) into output (unsigned char). Assumes len is
 342   a multiple of 4.
 343  */
 344 static void Encode (unsigned char *output, UINT4 *input, unsigned int len)
 345 {
 346   unsigned int i, j;
 347
 348   for (i = 0, j = 0; j < len; i++, j += 4) {
 349  output[j] = (unsigned char)(input[i] & 0xff);
 350  output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
 351  output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
 352  output[j+3] = (unsigned char)((input[i] >> 24) & 0xff);
 353   }
 354 }
 355
 356 /* Decodes input (unsigned char) into output (UINT4). Assumes len is
 357   a multiple of 4.
 358  */
 359 static void Decode (UINT4 *output, const unsigned char *input, unsigned int len)
 360 {
 361   unsigned int i, j;
 362
 363   for (i = 0, j = 0; j < len; i++, j += 4)
 364  output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
 365    (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
 366 }
 367
 368 /* Note: Replace "for loop" with standard memcpy if possible.
 369  */
 370
 371 static void MD5_memcpy (POINTER output, POINTER input, unsigned int len)
 372 {
 373   unsigned int i;
 374
 375   for (i = 0; i < len; i++)
 376  output[i] = input[i];
 377 }
 378
 379 /* Note: Replace "for loop" with standard memset if possible.
 380  */
 381 static void MD5_memset (POINTER output, int value, unsigned int len)
 382 {
 383   unsigned int i;
 384
 385   for (i = 0; i < len; i++)
 386  ((char *)output)[i] = (char)value;
 387 }