MD5算法.docx

MD5算法.docx

《MD5算法.docx》由会员分享，可在线阅读，更多相关《MD5算法.docx（14页珍藏版）》请在冰豆网上搜索。

MD5算法

//MD5.h

/*

使用方法：

CMD5md5;

CStringcsMd5Buffer=md5.MD5（"astring"）;

执行完成之后csMd5Buffer中即存储了由"astring"计算得到的MD5值:

3a315533c0f34762e0c45e3d4e9d525c

*/

#definePROTO_LIST（list）list

/*

ConstantsforMD5Transformroutine.

*/

#defineS117

#defineS1212

#defineS1317

#defineS1422

#defineS215

#defineS229

#defineS2314

#defineS2420

#defineS314

#defineS3211

#defineS3316

#defineS3423

#defineS416

#defineS4210

#defineS4315

#defineS4421

/*

F,G,HandIarebasicMD5functions.

*/

#defineF（x,y,z）（（（x）&（y））|（（~x）&（z）））

#defineG（x,y,z）（（（x）&（z））|（（y）&（~z）））

#defineH（x,y,z）（（x）^（y）^（z））

#defineI（x,y,z）（（y）^（（x）|（~z）））

/*

ROTATE_LEFTrotatesxleftnbits.

*/

#defineROTATE_LEFT（x,n）（（（x）<<（n））|（（x）>>（32-（n））））

/*

FF,GG,HH,andIItransformationsforrounds1,2,3,and4.

Rotationisseparatefromadditiontopreventrecomputation.

*/

#defineFF（a,b,c,d,x,s,ac）{（a）+=F（（b）,（c）,（d））+（x）+（UINT4）（ac）;（a）=ROTATE_LEFT（（a）,（s））;（a）+=（b）;}

#defineGG（a,b,c,d,x,s,ac）{（a）+=G（（b）,（c）,（d））+（x）+（UINT4）（ac）;（a）=ROTATE_LEFT（（a）,（s））;（a）+=（b）;}

#defineHH（a,b,c,d,x,s,ac）{（a）+=H（（b）,（c）,（d））+（x）+（UINT4）（ac）;（a）=ROTATE_LEFT（（a）,（s））;（a）+=（b）;}

#defineII（a,b,c,d,x,s,ac）{（a）+=I（（b）,（c）,（d））+（x）+（UINT4）（ac）;（a）=ROTATE_LEFT（（a）,（s））;（a）+=（b）;}

#defineTEST_BLOCK_LEN1000

#defineTEST_BLOCK_COUNT1000

staticunsignedcharPADDING[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,

};

//CMD5类

classCMD5

{

private:

/*POINTERdefinesagenericpointertype*/

typedefunsignedchar*POINTER;

/*UINT2definesatwobyteword*/

typedefunsignedshortintUINT2;

/*UINT4definesafourbyteword*/

typedefunsignedlongintUINT4;

/*MD5context.*/

typedefstruct_MD5_CTX

{

UINT4state[4];/*state（ABCD）*/

UINT4count[2];/*numberofbits,modulo2^64（lsbfirst）*/

unsignedcharbuffer[64];/*inputbuffer*/

}MD5_CTX;

public:

CMD5（void）;

~CMD5（void）;

public:

CStringMD5（INconstchar*szText）;

private:

CMD5（CMD5&ObjMd5）;//禁用拷贝构造函数

CMD5&operator=（CMD5&ObjMd5）;//禁用等号

private:

voidMD5TransformPROTO_LIST（（UINT4[4],unsignedchar[64]））;

voidMD5_memcpyPROTO_LIST（（POINTER,POINTER,size_t））;

voidMD5_memsetPROTO_LIST（（POINTER,int,size_t））;

voidMD5InitPROTO_LIST（（MD5_CTX*））;

voidMD5UpdatePROTO_LIST（（MD5_CTX*,unsignedchar*,size_t））;

voidMD5FinalPROTO_LIST（（unsignedchar[16],MD5_CTX*））;

voidStringAddOnePROTO_LIST（（char*））;

voidEncodePROTO_LIST（（unsignedchar*,UINT4*,size_t））;

voidDecodePROTO_LIST（（UINT4*,unsignedchar*,size_t））;

};

//MD5.cpp//

//MD5.cpp:

定义DLL应用程序的入口点。

//

#include"stdafx.h"

#include

#include

#include

#include

#include

#include"MD5.h"

//有关类定义的信息，请参阅MD5.h

CMD5:

:

CMD5（）

{

}

CMD5:

:

~CMD5（void）

{

}

/*

Digestsastringandprintstheresult.

*/

CStringCMD5:

:

MD5（INconstchar*szText）

{

charszMD5StringBuffer[33];

memset（szMD5StringBuffer,0,33）;

MD5_CTXcontext;

MD5Init（&context）;

MD5Update（&context,（unsignedchar*）szText,strlen（szText））;

unsignedchardigest[16];

MD5Final（digest,&context）;

for（inti=0;i<16;i++）

{

sprintf（&（szMD5StringBuffer[2*i]）,"%02x",（unsignedchar）digest[i]）;

}

returnCString（szMD5StringBuffer）;

}

/*

MD5initialization.BeginsanMD5operation,writinganewcontext.

*/

voidCMD5:

:

MD5Init（MD5_CTX*context）

{

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

/*

Loadmagicinitializationconstants.

*/

context->state[0]=0x67452301;

context->state[1]=0xefcdab89;

context->state[2]=0x98badcfe;

context->state[3]=0x10325476;

}

/*

MD5blockupdateoperation.ContinuesanMD5message-digest

operation,processinganothermessageblock,andupdatingthe

context.

*/

voidCMD5:

:

MD5Update（

MD5_CTX*context,/*context*/

unsignedchar*input,/*inputblock*/

size_tinputLen/*lengthofinputblock*/

）

{

size_ti,index,partLen;

/*Computenumberofbytesmod64*/

index=（size_t）（（context->count[0]>>3）&0x3F）;

/*Updatenumberofbits*/

if（（context->count[0]+=（（UINT4）inputLen<<3））

<（（UINT4）inputLen<<3））

context->count[1]++;

context->count[1]+=（（UINT4）inputLen>>29）;

partLen=64-index;

/*Transformasmanytimesaspossible.*/

if（inputLen>=partLen）{

MD5_memcpy

（（POINTER）&context->buffer[index],（POINTER）input,partLen）;

MD5Transform（context->state,context->buffer）;

for（i=partLen;i+63

MD5Transform（context->state,&input[i]）;

index=0;

}

else

i=0;

/*Bufferremaininginput*/

MD5_memcpy

（（POINTER）&context->buffer[index],（POINTER）&input[i],

inputLen-i）;

}

/*

MD5finalization.EndsanMD5message-digestoperation,writingthe

themessagedigestandzeroizingthecontext.

*/

voidCMD5:

:

MD5Final（

unsignedchardigest[16],/*messagedigest*/

MD5_CTX*context/*context*/

）

{

unsignedcharbits[8];

size_tindex,padLen;

/*Savenumberofbits*/

Encode（bits,context->count,8）;

/*Padoutto56mod64.*/

index=（size_t）（（context->count[0]>>3）&0x3f）;

padLen=（index<56）?

（56-index）:

（120-index）;

MD5Update（context,PADDING,padLen）;

/*Appendlength（beforepadding）*/

MD5Update（context,bits,8）;

/*Storestateindigest*/

Encode（digest,context->state,16）;

/*Zeroizesensitiveinformation.*/

MD5_memset（（POINTER）context,0,sizeof（*context））;

}

/*

MD5basictransformation.Transformsstatebasedonblock.

*/

voidCMD5:

:

MD5Transform（

UINT4state[4],

unsignedcharblock[64]

）

{

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

Decode（x,block,64）;

/*Round1*/

FF（a,b,c,d,x[0],S11,0xd76aa478）;/*1*/

FF（d,a,b,c,x[1],S12,0xe8c7b756）;/*2*/

FF（c,d,a,b,x[2],S13,0x242070db）;/*3*/

FF（b,c,d,a,x[3],S14,0xc1bdceee）;/*4*/

FF（a,b,c,d,x[4],S11,0xf57c0faf）;/*5*/

FF（d,a,b,c,x[5],S12,0x4787c62a）;/*6*/

FF（c,d,a,b,x[6],S13,0xa8304613）;/*7*/

FF（b,c,d,a,x[7],S14,0xfd469501）;/*8*/

FF（a,b,c,d,x[8],S11,0x698098d8）;/*9*/

FF（d,a,b,c,x[9],S12,0x8b44f7af）;/*10*/

FF（c,d,a,b,x[10],S13,0xffff5bb1）;/*11*/

FF（b,c,d,a,x[11],S14,0x895cd7be）;/*12*/

FF（a,b,c,d,x[12],S11,0x6b901122）;/*13*/

FF（d,a,b,c,x[13],S12,0xfd987193）;/*14*/

FF（c,d,a,b,x[14],S13,0xa679438e）;/*15*/

FF（b,c,d,a,x[15],S14,0x49b40821）;/*16*/

/*Round2*/

GG（a,b,c,d,x[1],S21,0xf61e2562）;/*17*/

GG（d,a,b,c,x[6],S22,0xc040b340）;/*18*/

GG（c,d,a,b,x[11],S23,0x265e5a51）;/*19*/

GG（b,c,d,a,x[0],S24,0xe9b6c7aa）;/*20*/

GG（a,b,c,d,x[5],S21,0xd62f105d）;/*21*/

GG（d,a,b,c,x[10],S22,0x2441453）;/*22*/

GG（c,d,a,b,x[15],S23,0xd8a1e681）;/*23*/

GG（b,c,d,a,x[4],S24,0xe7d3fbc8）;/*24*/

GG（a,b,c,d,x[9],S21,0x21e1cde6）;/*25*/

GG（d,a,b,c,x[14],S22,0xc33707d6）;/*26*/

GG（c,d,a,b,x[3],S23,0xf4d50d87）;/*27*/

GG（b,c,d,a,x[8],S24,0x455a14ed）;/*28*/

GG（a,b,c,d,x[13],S21,0xa9e3e905）;/*29*/

GG（d,a,b,c,x[2],S22,0xfcefa3f8）;/*30*/

GG（c,d,a,b,x[7],S23,0x676f02d9）;/*31*/

GG（b,c,d,a,x[12],S24,0x8d2a4c8a）;/*32*/

/*Round3*/

HH（a,b,c,d,x[5],S31,0xfffa3942）;/*33*/

HH（d,a,b,c,x[8],S32,0x8771f681）;/*34*/

HH（c,d,a,b,x[11],S33,0x6d9d6122）;/*35*/

HH（b,c,d,a,x[14],S34,0xfde5380c）;/*36*/

HH（a,b,c,d,x[1],S31,0xa4beea44）;/*37*/

HH（d,a,b,c,x[4],S32,0x4bdecfa9）;/*38*/

HH（c,d,a,b,x[7],S33,0xf6bb4b60）;/*39*/

HH（b,c,d,a,x[10],S34,0xbebfbc70）;/*40*/

HH（a,b,c,d,x[13],S31,0x289b7ec6）;/*41*/

HH（d,a,b,c,x[0],S32,0xeaa127fa）;/*42*/

HH（c,d,a,b,x[3],S33,0xd4ef3085）;/*43*/

HH（b,c,d,a,x[6],S34,0x4881d05）;/*44*/

HH（a,b,c,d,x[9],S31,0xd9d4d039）;/*45*/

HH（d,a,b,c,x[12],S32,0xe6db99e5）;/*46*/

HH（c,d,a,b,x[15],S33,0x1fa27cf8）;/*47*/

HH（b,c,d,a,x[2],S34,0xc4ac5665）;/*48*/

/*Round4*/

II（a,b,c,d,x[0],S41,0xf4292244）;/*49*/

II（d,a,b,c,x[7],S42,0x432aff97）;/*50*/

II（c,d,a,b,x[14],S43,0xab9423a7）;/*51*/

II（b,c,d,a,x[5],S44,0xfc93a039）;/*52*/

II（a,b,c,d,x[12],S41,0x655b59c3）;/*53*/

II（d,a,b,c,x[3],S42,0x8f0ccc92）;/*54*/

II（c,d,a,b,x[10],S43,0xffeff47d）;/*55*/

II（b,c,d,a,x[1],S44,0x85845dd1）;/*56*/

II（a,b,c,d,x[8],S41,0x6fa87e4f）;/*57*/

II（d,a,b,c,x[15],S42,0xfe2ce6e0）;/*58*/

II（c,d,a,b,x[6],S43,0xa3014314）;/*59*/

II（b,c,d,a,x[13],S44,0x4e0811a1）;/*60*/

II（a,b,c,d,x[4],S41,0xf7537e82）;/*61*/

II（d,a,b,c,x[11],S42,0xbd3af235）;/*62*/

II（c,d,a,b,x[2],S43,0x2ad7d2bb）;/*63*/

II（b,c,d,a,x[9],S44,0xeb86d391）;/*64*/

state[0]+=a;

state[1]+=b;

state[2]+=c;

state[3]+=d;

/*Zeroizesensitiveinformation.*/

MD5_memset（（POINTER）x,0,sizeof（x））;

}

/*

Encode