MD5算法

来源：互联网发布：探索者软件破解版编辑：程序博客网时间：2024/06/06 00:21

#include <stdio.h>

typedef struct {

unsignedintstate[4];

unsignedintcount[2];

unsignedcharbuffer[64];

} MD5Context;

void MD5_Init(MD5Context * context);

void MD5_Update(MD5Context * context, unsigned char * buf, intlen);

void MD5_Final(MD5Context * context, unsigned chardigest[16]);

#define S11 7

#define S12 12

#define S13 17

#define S14 22

#define S21 5

#define S22 9

#define S23 14

#define S24 20

#define S31 4

#define S32 11

#define S33 16

#define S34 23

#define S41 6

#define S42 10

#define S43 15

#define S44 21

static unsigned char PADDING[64] =

{

0x80, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

};

#define F(x, y, z) (((x) & (y)) | ((~x)& (z)))

#define G(x, y, z) (((x) & (z)) | ((y)& (~z)))

#define H(x, y, z) ((x) ^ (y) ^ (z))

#define I(x, y, z) ((y) ^ ((x) | (~z)))

#define ROTATE_LEFT(x, n) (((x) <<(n)) | ((x) >> (32-(n))))

#define FF(a, b, c, d, x, s,ac)         \
   {                      \
    (a) +=F((b), (c), (d)) + (x) + (unsigned int)(ac); \
    (a) =ROTATE_LEFT((a),(s));          \
    (a) +=(b);                \
    }

#define GG(a, b, c, d, x, s,ac)         \
   {                      \
    (a) +=G((b), (c), (d)) + (x) + (unsigned int)(ac); \
    (a) =ROTATE_LEFT((a),(s));          \
    (a) +=(b);                \
    }

#define HH(a, b, c, d, x, s,ac)         \
   {                      \
    (a) +=H((b), (c), (d)) + (x) + (unsigned int)(ac); \
    (a) =ROTATE_LEFT((a),(s));          \
    (a) +=(b);                \
    }

#define II(a, b, c, d, x, s,ac)         \
   {                      \
    (a) +=I((b), (c), (d)) + (x) + (unsigned int)(ac); \
    (a) =ROTATE_LEFT((a),(s));          \
    (a) +=(b);                \
    }

static void MD5_Encode(unsigned char * output, unsigned int *input, int len)
{
unsigned inti, j;
for (i = 0,j = 0; j < len; i++, j += 4)

{

output[j] = (unsigned char) (input[i] & 0xff);

output[j + 1] = (unsigned char) ((input[i]>> 8) & 0xff);

output[j + 2] = (unsigned char) ((input[i]>> 16) & 0xff);

output[j + 3] = (unsigned char) ((input[i]>> 24) & 0xff);

}

static void MD5_Decode(unsigned int * output, unsigned char *input, int len)

{

unsignedint i, j;

for (i =0, j = 0; j < len; i++, j += 4)

{

output[i] = ((unsigned int) input[j]) |

(((unsigned int) input[j + 1]) << 8)|

(((unsigned int) input[j + 2]) << 16)|

(((unsigned int) input[j + 3]) <<24);

}

static void MD5_Transform(unsigned int state[4], unsigned charblock[64])

{

unsignedint a = state[0], b = state[1], c = state[2], d = state[3],x[16];

MD5_Decode(x, block, 64);

FF(a, b,c, d, x[0], S11,0xd76aa478);

FF(d, a,b, c, x[1], S12,0xe8c7b756);

FF(c, d,a, b, x[2], S13,0x242070db);

FF(b, c,d, a, x[3], S14,0xc1bdceee);

FF(a, b,c, d, x[4], S11,0xf57c0faf);

FF(d, a,b, c, x[5], S12,0x4787c62a);

FF(c, d,a, b, x[6], S13,0xa8304613);

FF(b, c,d, a, x[7], S14,0xfd469501);

FF(a, b,c, d, x[8], S11,0x698098d8);

FF(d, a,b, c, x[9], S12,0x8b44f7af);

FF(c, d,a, b, x[10], S13,0xffff5bb1);

FF(b, c,d, a, x[11], S14,0x895cd7be);

FF(a, b,c, d, x[12], S11,0x6b901122);

FF(d, a,b, c, x[13], S12,0xfd987193);

FF(c, d,a, b, x[14], S13,0xa679438e);

FF(b, c,d, a, x[15], S14,0x49b40821);

GG(a, b,c, d, x[1], S21,0xf61e2562);

GG(d, a,b, c, x[6], S22,0xc040b340);

GG(c, d,a, b, x[11], S23,0x265e5a51);

GG(b, c,d, a, x[0], S24,0xe9b6c7aa);

GG(a, b,c, d, x[5], S21,0xd62f105d);

GG(d, a,b, c, x[10], S22,0x2441453);

GG(c, d,a, b, x[15], S23,0xd8a1e681);

GG(b, c,d, a, x[4], S24,0xe7d3fbc8);

GG(a, b,c, d, x[9], S21,0x21e1cde6);

GG(d, a,b, c, x[14], S22,0xc33707d6);

GG(c, d,a, b, x[3], S23,0xf4d50d87);

GG(b, c,d, a, x[8], S24,0x455a14ed);

GG(a, b,c, d, x[13], S21,0xa9e3e905);

GG(d, a,b, c, x[2], S22,0xfcefa3f8);

GG(c, d,a, b, x[7], S23,0x676f02d9);

GG(b, c,d, a, x[12], S24,0x8d2a4c8a);

HH(a, b,c, d, x[5], S31,0xfffa3942);

HH(d, a,b, c, x[8], S32,0x8771f681);

HH(c, d,a, b, x[11], S33,0x6d9d6122);

HH(b, c,d, a, x[14], S34,0xfde5380c);

HH(a, b,c, d, x[1], S31,0xa4beea44);

HH(d, a,b, c, x[4], S32,0x4bdecfa9);

HH(c, d,a, b, x[7], S33,0xf6bb4b60);

HH(b, c,d, a, x[10], S34,0xbebfbc70);

HH(a, b,c, d, x[13], S31,0x289b7ec6);

HH(d, a,b, c, x[0], S32,0xeaa127fa);

HH(c, d,a, b, x[3], S33,0xd4ef3085);

HH(b, c,d, a, x[6], S34, 0x4881d05);

HH(a, b,c, d, x[9], S31,0xd9d4d039);

HH(d, a,b, c, x[12], S32,0xe6db99e5);

HH(c, d,a, b, x[15], S33,0x1fa27cf8);

HH(b, c,d, a, x[2], S34,0xc4ac5665);

II(a, b,c, d, x[0], S41,0xf4292244);

II(d, a,b, c, x[7], S42,0x432aff97);

II(c, d,a, b, x[14], S43,0xab9423a7);

II(b, c,d, a, x[5], S44,0xfc93a039);

II(a, b,c, d, x[12], S41,0x655b59c3);

II(d, a,b, c, x[3], S42,0x8f0ccc92);

II(c, d,a, b, x[10], S43,0xffeff47d);

II(b, c,d, a, x[1], S44,0x85845dd1);

II(a, b,c, d, x[8], S41,0x6fa87e4f);

II(d, a,b, c, x[15], S42,0xfe2ce6e0);

II(c, d,a, b, x[6], S43,0xa3014314);

II(b, c,d, a, x[13], S44,0x4e0811a1);

II(a, b,c, d, x[4], S41,0xf7537e82);

II(d, a,b, c, x[11], S42,0xbd3af235);

II(c, d,a, b, x[2], S43,0x2ad7d2bb);

II(b, c,d, a, x[9], S44,0xeb86d391);

state[0]+= a;

state[1]+= b;

state[2]+= c;

state[3]+= d;

memset((char *) x, 0, sizeof(x));

}

void MD5_Init(MD5Context * context)

{

context->count[0] = context->count[1]= 0;

context->state[0] = 0x67452301;

context->state[1] = 0xefcdab89;

context->state[2] = 0x98badcfe;

context->state[3] = 0x10325476;

}

void MD5_Update(MD5Context * context, unsigned char * buf, intlen)

{

unsignedint i, index, partLen;

index =(unsigned int) ((context->count[0]>> 3) & 0x3F);

if((context->count[0] += ((unsigned int) len<< 3)) < ((unsignedint) len << 3))

context->count[1]++;

context->count[1] += ((unsigned int) len>> 29);

partLen =64 - index;

if (len>= partLen)

{

memcpy((char *)&context->buffer[index], (char *)buf, partLen);

MD5_Transform(context->state,context->buffer);

for (i = partLen; i + 63 < len; i += 64)

MD5_Transform(context->state,&buf[i]);

index = 0;

}

else

{

i = 0;

}

memcpy((char *)&context->buffer[index], (char *)&buf[i], len - i);

}

void MD5_Final(MD5Context * context, unsigned chardigest[16])

{

unsignedchar bits[8];

unsignedint index, padLen;

MD5_Encode(bits, context->count, 8);

index =(unsigned int) ((context->count[0]>> 3) & 0x3f);

padLen =(index < 56) ? (56 - index) : (120 - index);

MD5_Update(context, PADDING, padLen);

MD5_Update(context, bits, 8);

MD5_Encode(digest, context->state, 16);

memset((char *) context, 0, sizeof(*context));

}

void MD5_File (char * filename)

{

FILE*file;

MD5Context context;

unsignedchar buff[16];

inti,len;

unsignedchar buffer[0x0400];

if(!(file = fopen (filename, "rb")))

printf ("%s can't be opened\n", filename);

else

{

MD5_Init (&context);

while (len = fread (buffer, 1, 1024, file))

MD5_Update (&context, buffer, len);

MD5_Final(&context,buff);

fclose (file);

for(i=0;i<16;i++)

{

printf("%x",(buff[i] &0xF0)>>4);

printf("%x",buff[i] & 0x0F);

}

printf("\n");

}

int main()

{

int i=0,j,len,startTime,endTime;

MD5Context context;

unsignedchar buff[16];

char *str1 = "";

char *str2 = "abc";

char *str3 = "message digest";

char *str4 = "abcdefghijklmnopqrstuvwxyz";

char *str5 ="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

char *str6 ="12345678901234567890123456789012345678901234567890123456789012345678901234567890";

charstr[7][100] =

{

"",

"a",

"abc",

"message digest",

"abcdefghijklmnopqrstuvwxyz",

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789",

"12345678901234567890123456789012345678901234567890123456789012345678901234567890"

};

for(i=0;i<6;i++)

{

len = strlen(str[i]);

MD5_Init(&context);

MD5_Update(&context,(unsigned char *)str[i],len);

MD5_Final(&context,buff);

printf("MD5("%s") = \n",str[i]);

for(j=0;j<16;j++)

{

printf("%x",(buff[j] &0xF0)>>4);

printf("%x",buff[j] & 0x0F);

}

printf("\n***********************************************************\n");

    }

   printf("Wating...\n");

   MD5_File("D:\\VC\\md5\\Debug\\ss.doc");
   system("pause");
    return0;

}