home *** CD-ROM | disk | FTP | other *** search
/ GameStar 2006 March / Gamestar_82_2006-03_dvd.iso / DVDStar / Editace / quake4_sdkv10.exe / source / idlib / hashing / MD5.cpp < prev    next >
C/C++ Source or Header  |  2005-11-14  |  8KB  |  266 lines
  1.  
  2. #include "../precompiled.h"
  3. #pragma hdrstop
  4.  
  5. /*
  6.    MD5 Message Digest Algorithm. (RFC1321)
  7. */
  8.  
  9. /*
  10.  
  11. This code implements the MD5 message-digest algorithm.
  12. The algorithm is due to Ron Rivest.  This code was
  13. written by Colin Plumb in 1993, no copyright is claimed.
  14. This code is in the public domain; do with it what you wish.
  15.  
  16. Equivalent code is available from RSA Data Security, Inc.
  17. This code has been tested against that, and is equivalent,
  18. except that you don't need to include two pages of legalese
  19. with every copy.
  20.  
  21. To compute the message digest of a chunk of bytes, declare an
  22. MD5Context structure, pass it to MD5Init, call MD5Update as
  23. needed on buffers full of bytes, and then call MD5Final, which
  24. will fill a supplied 16-byte array with the digest.
  25.  
  26. */
  27.  
  28. /* MD5 context. */
  29. typedef struct
  30. {
  31.     unsigned int    state[4];
  32.     unsigned int    bits[2];
  33.     unsigned char    in[64];
  34. } MD5_CTX;
  35.  
  36. /* The four core functions - F1 is optimized somewhat */
  37. /* #define F1(x, y, z) (x & y | ~x & z) */
  38. #define F1(x, y, z) (z ^ (x & (y ^ z)))
  39. #define F2(x, y, z) F1(z, x, y)
  40. #define F3(x, y, z) (x ^ y ^ z)
  41. #define F4(x, y, z) (y ^ (x | ~z))
  42.  
  43. /* This is the central step in the MD5 algorithm. */
  44. #define MD5STEP(f, w, x, y, z, data, s) ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
  45.  
  46. /*
  47. =================
  48. MD5_Transform
  49.  
  50. The core of the MD5 algorithm, this alters an existing MD5 hash to
  51. reflect the addition of 16 longwords of new data.  MD5Update blocks
  52. the data and converts bytes into longwords for this routine.
  53. =================
  54. */
  55. void MD5_Transform( unsigned int state[4], unsigned int const in[16] ) {
  56.     register unsigned int a, b, c, d;
  57.  
  58.     a = state[0];
  59.     b = state[1];
  60.     c = state[2];
  61.     d = state[3];
  62.  
  63.     MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
  64.     MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
  65.     MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
  66.     MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
  67.     MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
  68.     MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
  69.     MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
  70.     MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
  71.     MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
  72.     MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
  73.     MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
  74.     MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
  75.     MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
  76.     MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
  77.     MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
  78.     MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
  79.  
  80.     MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
  81.     MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
  82.     MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
  83.     MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
  84.     MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
  85.     MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
  86.     MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
  87.     MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
  88.     MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
  89.     MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
  90.     MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
  91.     MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
  92.     MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
  93.     MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
  94.     MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
  95.     MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
  96.  
  97.     MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
  98.     MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
  99.     MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
  100.     MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
  101.     MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
  102.     MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
  103.     MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
  104.     MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
  105.     MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
  106.     MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
  107.     MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
  108.     MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
  109.     MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
  110.     MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
  111.     MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
  112.     MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
  113.  
  114.     MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
  115.     MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
  116.     MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
  117.     MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
  118.     MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
  119.     MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
  120.     MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
  121.     MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
  122.     MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
  123.     MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
  124.     MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
  125.     MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
  126.     MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
  127.     MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
  128.     MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
  129.     MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
  130.  
  131.     state[0] += a;
  132.     state[1] += b;
  133.     state[2] += c;
  134.     state[3] += d;
  135. }
  136.  
  137. /*
  138. ==================
  139. MD5_Init
  140.  
  141. MD5 initialization. Begins an MD5 operation, writing a new context.
  142. ==================
  143. */
  144. void MD5_Init( MD5_CTX *ctx ) {
  145.     ctx->state[0] = 0x67452301;
  146.     ctx->state[1] = 0xefcdab89;
  147.     ctx->state[2] = 0x98badcfe;
  148.     ctx->state[3] = 0x10325476;
  149.  
  150.     ctx->bits[0] = 0;
  151.     ctx->bits[1] = 0;
  152. }
  153.  
  154. /*
  155. ===================
  156. MD5_Update
  157.  
  158. MD5 block update operation. Continues an MD5 message-digest operation,
  159. processing another message block, and updating the context.
  160. ===================
  161. */
  162. void MD5_Update( MD5_CTX *ctx, unsigned char const *buf, unsigned int len ) {
  163.     unsigned int t;
  164.  
  165.     /* Update bitcount */
  166.  
  167.     t = ctx->bits[0];
  168.     if ( ( ctx->bits[0] = t + ( (unsigned int) len << 3 ) ) < t ) {
  169.         ctx->bits[1]++;         /* Carry from low to high */
  170.     }
  171.     ctx->bits[1] += len >> 29;
  172.  
  173.     t = ( t >> 3 ) & 0x3f;        /* Bytes already in shsInfo->data */
  174.  
  175.     /* Handle any leading odd-sized chunks */
  176.  
  177.     if ( t ) {
  178.         unsigned char *p = (unsigned char *) ctx->in + t;
  179.  
  180.         t = 64 - t;
  181.         if ( len < t ) {
  182.             memcpy( p, buf, len );
  183.             return;
  184.         }
  185.         memcpy( p, buf, t );
  186.         MD5_Transform( ctx->state, (unsigned int *) ctx->in );
  187.         buf += t;
  188.         len -= t;
  189.     }
  190.     /* Process data in 64-byte chunks */
  191.  
  192.     while( len >= 64 ) {
  193.         memcpy( ctx->in, buf, 64 );
  194.         MD5_Transform( ctx->state, (unsigned int *) ctx->in );
  195.         buf += 64;
  196.         len -= 64;
  197.     }
  198.  
  199.     /* Handle any remaining bytes of data. */
  200.     memcpy( ctx->in, buf, len );
  201. }
  202.  
  203. /*
  204. ===============
  205. MD5_Final
  206.  
  207. MD5 finalization. Ends an MD5 message-digest operation,
  208. writing the message digest and zeroizing the context.
  209. ===============
  210. */
  211. void MD5_Final( MD5_CTX *ctx, unsigned char digest[16] ) {
  212.     unsigned count;
  213.     unsigned char *p;
  214.  
  215.     /* Compute number of bytes mod 64 */
  216.     count = ( ctx->bits[0] >> 3 ) & 0x3F;
  217.  
  218.     /* Set the first char of padding to 0x80.  This is safe since there is
  219.        always at least one byte free */
  220.     p = ctx->in + count;
  221.     *p++ = 0x80;
  222.  
  223.     /* Bytes of padding needed to make 64 bytes */
  224.     count = 64 - 1 - count;
  225.  
  226.     /* Pad out to 56 mod 64 */
  227.     if ( count < 8 ) {
  228.         /* Two lots of padding:  Pad the first block to 64 bytes */
  229.         memset( p, 0, count );
  230.         MD5_Transform( ctx->state, (unsigned int *) ctx->in );
  231.  
  232.         /* Now fill the next block with 56 bytes */
  233.         memset( ctx->in, 0, 56 );
  234.     } else {
  235.         /* Pad block to 56 bytes */
  236.         memset( p, 0, count - 8 );
  237.     }
  238.  
  239.     /* Append length in bits and transform */
  240.     ((unsigned int *) ctx->in)[14] = ctx->bits[0];
  241.     ((unsigned int *) ctx->in)[15] = ctx->bits[1];
  242.  
  243.     MD5_Transform( ctx->state, (unsigned int *) ctx->in );
  244.     memcpy( digest, ctx->state, 16 );
  245.     memset( ctx, 0, sizeof( ctx ) );        /* In case it's sensitive */
  246. }
  247.  
  248. /*
  249. ===============
  250. MD5_BlockChecksum
  251. ===============
  252. */
  253. unsigned long MD5_BlockChecksum( const void *data, int length ) {
  254.     unsigned long    digest[4];
  255.     unsigned long    val;
  256.     MD5_CTX            ctx;
  257.  
  258.     MD5_Init( &ctx );
  259.     MD5_Update( &ctx, (unsigned char *)data, length );
  260.     MD5_Final( &ctx, (unsigned char *)digest );
  261.  
  262.     val = digest[0] ^ digest[1] ^ digest[2] ^ digest[3];
  263.  
  264.     return val;
  265. }
  266.