md5calc.c

传奇3源程序, 用vc开发的

/***********************************************************
 * md5寁嶼傾儖僑儕僘儉
 *
 * 僜乕僗僐乕僪偼埲壓偺URL傪嶲峫偵偟傑偟偨
 * http://www.geocities.co.jp/SiliconValley-Oakland/8878/lab17/lab17.html
 *
 ***********************************************************/

#include "md5calc.h"
#include <string.h>
#include <stdio.h>

#ifndef UINT_MAX
#define UINT_MAX 4294967295U
#endif

// 僌儘乕僶儖曄悢
static unsigned int *pX;

// Stirng Table
static const unsigned int T[] = {
   0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, //0
   0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501, //4
   0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, //8
   0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821, //12
   0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, //16
   0xd62f105d,  0x2441453, 0xd8a1e681, 0xe7d3fbc8, //20
   0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, //24
   0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a, //28
   0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, //32
   0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70, //36
   0x289b7ec6, 0xeaa127fa, 0xd4ef3085,  0x4881d05, //40
   0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665, //44
   0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, //48
   0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1, //52
   0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, //56
   0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391  //60
};

// ROTATE_LEFT偼 x 傪嵍偵n價僢僩夞揮偝偣傞丅偙傟偼RFC偐傜偦偺傑傑棳梡
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))

// 偦偺懠偺寁嶼偵巊偆娭悢
static unsigned int F(unsigned int X, unsigned int Y, unsigned int Z)
{
   return (X & Y) | (~X & Z);
}
static unsigned int G(unsigned int X, unsigned int Y, unsigned int Z)
{
   return (X & Z) | (Y & ~Z);
}
static unsigned int H(unsigned int X, unsigned int Y, unsigned int Z)
{
   return X ^ Y ^ Z;
}
static unsigned int I(unsigned int X, unsigned int Y, unsigned int Z)
{
   return Y ^ (X | ~Z);
}

static unsigned int Round(unsigned int a, unsigned int b, unsigned int FGHI,
                     unsigned int k, unsigned int s, unsigned int i)
{
   return b + ROTATE_LEFT(a + FGHI + pX[k] + T[i], s);
}

static void Round1(unsigned int *a, unsigned int b, unsigned int c,
		unsigned int d,unsigned int k, unsigned int s, unsigned int i)
{
	*a = Round(*a, b, F(b,c,d), k, s, i);
}
static void Round2(unsigned int *a, unsigned int b, unsigned int c,
		unsigned int d,unsigned int k, unsigned int s, unsigned int i)
{
	*a = Round(*a, b, G(b,c,d), k, s, i);
}
static void Round3(unsigned int *a, unsigned int b, unsigned int c,
		unsigned int d,unsigned int k, unsigned int s, unsigned int i)
{
	*a = Round(*a, b, H(b,c,d), k, s, i);
}
static void Round4(unsigned int *a, unsigned int b, unsigned int c,
		unsigned int d,unsigned int k, unsigned int s, unsigned int i)
{
	*a = Round(*a, b, I(b,c,d), k, s, i);
}

static void MD5_Round_Calculate(const unsigned char *block,
	unsigned int *A2, unsigned int *B2, unsigned int *C2, unsigned int *D2)
{
	//create X 昁梫側偺偱
	unsigned int X[16]; //512bit 64byte
	int j,k;

	//Save A as AA, B as BB, C as CC, and D as DD (A,B,C,D偺曐懚)
	unsigned int A=*A2, B=*B2, C=*C2, D=*D2;
	unsigned int AA = A,BB = B,CC = C,DD = D;
	
	//儔僂儞僪偺寁嶼偺堊偵巇曽側偔戝堟曄悢傪丅丅丅 for Round1...4
	pX = X;

	//Copy block(padding_message) i into X
	for (j=0,k=0; j<64; j+=4,k++)
		X[k] = ( (unsigned int )block[j] )         // 8byte*4 -> 32byte 曄姺
			| ( ((unsigned int )block[j+1]) << 8 ) // RFC偱偄偆Decode偲偄偆娭悢
			| ( ((unsigned int )block[j+2]) << 16 )
			| ( ((unsigned int )block[j+3]) << 24 );


   //Round 1
   Round1(&A,B,C,D,  0, 7,  0); Round1(&D,A,B,C,  1, 12,  1); Round1(&C,D,A,B,  2, 17,  2); Round1(&B,C,D,A,  3, 22,  3);
   Round1(&A,B,C,D,  4, 7,  4); Round1(&D,A,B,C,  5, 12,  5); Round1(&C,D,A,B,  6, 17,  6); Round1(&B,C,D,A,  7, 22,  7);
   Round1(&A,B,C,D,  8, 7,  8); Round1(&D,A,B,C,  9, 12,  9); Round1(&C,D,A,B, 10, 17, 10); Round1(&B,C,D,A, 11, 22, 11);
   Round1(&A,B,C,D, 12, 7, 12); Round1(&D,A,B,C, 13, 12, 13); Round1(&C,D,A,B, 14, 17, 14); Round1(&B,C,D,A, 15, 22, 15);

   //Round 2
   Round2(&A,B,C,D,  1, 5, 16); Round2(&D,A,B,C,  6, 9, 17); Round2(&C,D,A,B, 11, 14, 18); Round2(&B,C,D,A,  0, 20, 19);
   Round2(&A,B,C,D,  5, 5, 20); Round2(&D,A,B,C, 10, 9, 21); Round2(&C,D,A,B, 15, 14, 22); Round2(&B,C,D,A,  4, 20, 23);
   Round2(&A,B,C,D,  9, 5, 24); Round2(&D,A,B,C, 14, 9, 25); Round2(&C,D,A,B,  3, 14, 26); Round2(&B,C,D,A,  8, 20, 27);
   Round2(&A,B,C,D, 13, 5, 28); Round2(&D,A,B,C,  2, 9, 29); Round2(&C,D,A,B,  7, 14, 30); Round2(&B,C,D,A, 12, 20, 31);

   //Round 3
   Round3(&A,B,C,D,  5, 4, 32); Round3(&D,A,B,C,  8, 11, 33); Round3(&C,D,A,B, 11, 16, 34); Round3(&B,C,D,A, 14, 23, 35);
   Round3(&A,B,C,D,  1, 4, 36); Round3(&D,A,B,C,  4, 11, 37); Round3(&C,D,A,B,  7, 16, 38); Round3(&B,C,D,A, 10, 23, 39);
   Round3(&A,B,C,D, 13, 4, 40); Round3(&D,A,B,C,  0, 11, 41); Round3(&C,D,A,B,  3, 16, 42); Round3(&B,C,D,A,  6, 23, 43);
   Round3(&A,B,C,D,  9, 4, 44); Round3(&D,A,B,C, 12, 11, 45); Round3(&C,D,A,B, 15, 16, 46); Round3(&B,C,D,A,  2, 23, 47);

   //Round 4
   Round4(&A,B,C,D,  0, 6, 48); Round4(&D,A,B,C,  7, 10, 49); Round4(&C,D,A,B, 14, 15, 50); Round4(&B,C,D,A,  5, 21, 51);
   Round4(&A,B,C,D, 12, 6, 52); Round4(&D,A,B,C,  3, 10, 53); Round4(&C,D,A,B, 10, 15, 54); Round4(&B,C,D,A,  1, 21, 55);
   Round4(&A,B,C,D,  8, 6, 56); Round4(&D,A,B,C, 15, 10, 57); Round4(&C,D,A,B,  6, 15, 58); Round4(&B,C,D,A, 13, 21, 59);
   Round4(&A,B,C,D,  4, 6, 60); Round4(&D,A,B,C, 11, 10, 61); Round4(&C,D,A,B,  2, 15, 62); Round4(&B,C,D,A,  9, 21, 63);

   // Then perform the following additions. (壛嶼偟傑偟傚偆)
   *A2 = A + AA;
   *B2 = B + BB;
   *C2 = C + CC;
   *D2 = D + DD;

   //婡枾忣曬偺僋儕傾
   memset(pX, 0, sizeof(X));
}

//-------------------------------------------------------------------
// 奜晹梡娭悢

/** string偼晞崋壔偟偨偄暥帤楍偱output偼晞崋壔偝傟偨僶僀僫儕 */
void MD5_String2binary(const char * string, char * output)
{
//var
   /*8bit*/
   unsigned char padding_message[64]; //奼挘儊僢僙乕僕 512bit 64byte
   unsigned char *pstring;             //尰嵼憱嵏拲拞偺string偺埵抲傪曐帩
//   unsigned char digest[16];
   /*32bit*/
   unsigned int string_byte_len,    //string偺僶僀僩挿傪曐帩
                   string_bit_len,     //string偺價僢僩挿傪曐帩
                   copy_len,           //1-3偱巊偆巆偭偨僶僀僩悢
                   msg_digest[4];      //儊僢僙乕僕僟僀僕僃僗僩 128bit 4byte
   unsigned int *A = &msg_digest[0], //RFC偵懃偭偨儊僢僙乕僕僟僀僕僃僗僩乮偺儕僼傽儗儞僗乯
                   *B = &msg_digest[1],
                   *C = &msg_digest[2],
                   *D = &msg_digest[3];
	int i;

//prog
   //Step 3. Initialize MD Buffer (A,B,C,D偺弶婜壔;僗僥僢僾俁偱偡偑巇曽側偔愭摢偵)
   *A = 0x67452301;
   *B = 0xefcdab89;
   *C = 0x98badcfe;
   *D = 0x10325476;

   //Step 1. Append Padding Bits (晞崋價僢僩偺奼挘)
   //1-1
   string_byte_len = strlen(string);    //暥帤楍偺僶僀僩挿傪庢摼
   pstring = (unsigned char *)string; //尰嵼偺暥帤楍偺埵抲傪僙僢僩

   //1-2 挿偝偑俇係僶僀僩枹枮偵側傞傑偱寁嶼傪孞傝曉偡
   for (i=string_byte_len; 64<=i; i-=64,pstring+=64)
        MD5_Round_Calculate(pstring, A,B,C,D);

   //1-3
   copy_len = string_byte_len % 64;                               //巆偭偨僶僀僩悢傪嶼弌
   strncpy((char *)padding_message, (char *)pstring, copy_len); //奼挘價僢僩楍傊儊僢僙乕僕傪僐僺乕
   memset(padding_message+copy_len, 0, 64 - copy_len);           //奼挘價僢僩挿偵側傞傑偱0偱杽傔傞
   padding_message[copy_len] |= 0x80;                            //儊僢僙乕僕偺師偼1

   //1-4 
   //巆傝偑56僶僀僩埲忋乮俇係僶僀僩枹枮乯側傜偽俇係僶僀僩偵奼挘偟偰寁嶼
   if (56 <= copy_len) {
       MD5_Round_Calculate(padding_message, A,B,C,D);

       memset(padding_message, 0, 56); //怴偨偵俆俇僶僀僩傪侽偱杽傔傞
   }


   //Step 2. Append Length (挿偝偺忣曬傪捛壛)
   string_bit_len = string_byte_len * 8;             //僶僀僩挿偐傜價僢僩挿傊乮壓埵俁俀僶僀僩乯
   memcpy(&padding_message[56], &string_bit_len, 4); //壓埵俁俀僶僀僩傪僙僢僩

   //壓埵俁俀僶僀僩偩偗偱偼價僢僩挿傪昞尰偱偒側偄偲偒偼忋埵偵寘忋偘
  if (UINT_MAX / 8 < string_byte_len) {
      unsigned int high = (string_byte_len - UINT_MAX / 8) * 8;
      memcpy(&padding_message[60], &high, 4);
  } else
      memset(&padding_message[60], 0, 4); //偙偺応崌偼忋埵偵偼侽偱傛偄

   //Step 4. Process Message in 16-Word Blocks (MD5偺寁嶼)
   MD5_Round_Calculate(padding_message, A,B,C,D);


   //Step 5. Output (弌椡)
   memcpy(output,msg_digest,16);
//   memcpy(digest, msg_digest, 16); //8byte*4 <- 32byte 曄姺 RFC偱偄偆Encode偲偄偆娭悢
/*   sprintf(output,
           "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
           digest[ 0], digest[ 1], digest[ 2], digest[ 3],
           digest[ 4], digest[ 5], digest[ 6], digest[ 7],
           digest[ 8], digest[ 9], digest[10], digest[11],
           digest[12], digest[13], digest[14], digest[15]);*/
}

/** string偼晞崋壔偟偨偄暥帤楍偱output偼晞崋壔偝傟偨暥帤楍 */
void MD5_String(const char * string, char * output)
{
   unsigned char digest[16];

	MD5_String2binary(string,digest);
	sprintf(output,
		"%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x",
		digest[ 0], digest[ 1], digest[ 2], digest[ 3],
		digest[ 4], digest[ 5], digest[ 6], digest[ 7],
		digest[ 8], digest[ 9], digest[10], digest[11],
		digest[12], digest[13], digest[14], digest[15]);
}