MD5源码

最新推荐文章于 2024-03-21 10:45:38 发布
最新推荐文章于 2024-03-21 10:45:38 发布
阅读量1.1k 收藏 1
点赞数
文章标签： transformation input cmd constants output byte

1、MD5ChecksumDefines.h（定义相关常量的头文件）
//Magic initialization constants
#define MD5_INIT_STATE_0 0x67452301
#define MD5_INIT_STATE_1 0xefcdab89
#define MD5_INIT_STATE_2 0x98badcfe
#define MD5_INIT_STATE_3 0x10325476

//Constants for Transform routine.
#define MD5_S11  7
#define MD5_S12 12
#define MD5_S13 17
#define MD5_S14 22
#define MD5_S21  5
#define MD5_S22  9
#define MD5_S23 14
#define MD5_S24 20
#define MD5_S31  4
#define MD5_S32 11
#define MD5_S33 16
#define MD5_S34 23
#define MD5_S41  6
#define MD5_S42 10
#define MD5_S43 15
#define MD5_S44 21

//Transformation Constants - Round 1
#define MD5_T01  0xd76aa478 //Transformation Constant 1
#define MD5_T02  0xe8c7b756 //Transformation Constant 2
#define MD5_T03  0x242070db //Transformation Constant 3
#define MD5_T04  0xc1bdceee //Transformation Constant 4
#define MD5_T05  0xf57c0faf //Transformation Constant 5
#define MD5_T06  0x4787c62a //Transformation Constant 6
#define MD5_T07  0xa8304613 //Transformation Constant 7
#define MD5_T08  0xfd469501 //Transformation Constant 8
#define MD5_T09  0x698098d8 //Transformation Constant 9
#define MD5_T10  0x8b44f7af //Transformation Constant 10
#define MD5_T11  0xffff5bb1 //Transformation Constant 11
#define MD5_T12  0x895cd7be //Transformation Constant 12
#define MD5_T13  0x6b901122 //Transformation Constant 13
#define MD5_T14  0xfd987193 //Transformation Constant 14
#define MD5_T15  0xa679438e //Transformation Constant 15
#define MD5_T16  0x49b40821 //Transformation Constant 16

//Transformation Constants - Round 2
#define MD5_T17  0xf61e2562 //Transformation Constant 17
#define MD5_T18  0xc040b340 //Transformation Constant 18
#define MD5_T19  0x265e5a51 //Transformation Constant 19
#define MD5_T20  0xe9b6c7aa //Transformation Constant 20
#define MD5_T21  0xd62f105d //Transformation Constant 21
#define MD5_T22  0x02441453 //Transformation Constant 22
#define MD5_T23  0xd8a1e681 //Transformation Constant 23
#define MD5_T24  0xe7d3fbc8 //Transformation Constant 24
#define MD5_T25  0x21e1cde6 //Transformation Constant 25
#define MD5_T26  0xc33707d6 //Transformation Constant 26
#define MD5_T27  0xf4d50d87 //Transformation Constant 27
#define MD5_T28  0x455a14ed //Transformation Constant 28
#define MD5_T29  0xa9e3e905 //Transformation Constant 29
#define MD5_T30  0xfcefa3f8 //Transformation Constant 30
#define MD5_T31  0x676f02d9 //Transformation Constant 31
#define MD5_T32  0x8d2a4c8a //Transformation Constant 32

//Transformation Constants - Round 3
#define MD5_T33  0xfffa3942 //Transformation Constant 33
#define MD5_T34  0x8771f681 //Transformation Constant 34
#define MD5_T35  0x6d9d6122 //Transformation Constant 35
#define MD5_T36  0xfde5380c //Transformation Constant 36
#define MD5_T37  0xa4beea44 //Transformation Constant 37
#define MD5_T38  0x4bdecfa9 //Transformation Constant 38
#define MD5_T39  0xf6bb4b60 //Transformation Constant 39
#define MD5_T40  0xbebfbc70 //Transformation Constant 40
#define MD5_T41  0x289b7ec6 //Transformation Constant 41
#define MD5_T42  0xeaa127fa //Transformation Constant 42
#define MD5_T43  0xd4ef3085 //Transformation Constant 43
#define MD5_T44  0x04881d05 //Transformation Constant 44
#define MD5_T45  0xd9d4d039 //Transformation Constant 45
#define MD5_T46  0xe6db99e5 //Transformation Constant 46
#define MD5_T47  0x1fa27cf8 //Transformation Constant 47
#define MD5_T48  0xc4ac5665 //Transformation Constant 48

//Transformation Constants - Round 4
#define MD5_T49  0xf4292244 //Transformation Constant 49
#define MD5_T50  0x432aff97 //Transformation Constant 50
#define MD5_T51  0xab9423a7 //Transformation Constant 51
#define MD5_T52  0xfc93a039 //Transformation Constant 52
#define MD5_T53  0x655b59c3 //Transformation Constant 53
#define MD5_T54  0x8f0ccc92 //Transformation Constant 54
#define MD5_T55  0xffeff47d //Transformation Constant 55
#define MD5_T56  0x85845dd1 //Transformation Constant 56
#define MD5_T57  0x6fa87e4f //Transformation Constant 57
#define MD5_T58  0xfe2ce6e0 //Transformation Constant 58
#define MD5_T59  0xa3014314 //Transformation Constant 59
#define MD5_T60  0x4e0811a1 //Transformation Constant 60
#define MD5_T61  0xf7537e82 //Transformation Constant 61
#define MD5_T62  0xbd3af235 //Transformation Constant 62
#define MD5_T63  0x2ad7d2bb //Transformation Constant 63
#define MD5_T64  0xeb86d391 //Transformation Constant 64


//Null data (except for first BYTE) used to finalise the checksum calculation
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
};
2、CountChecksum.h（md5校验和类的头文件）
class CMD5Checksum 
{
public:
//interface functions for the RSA MD5 calculation
static CString GetMD5(BYTE* pBuf, UINT nLength);
static CString GetMD5(CFile& File);
static CString GetMD5(const CString& strFilePath);

protected:
//constructor/destructor
CMD5Checksum();
virtual ~CMD5Checksum() {};

//RSA MD5 implementation
void Transform(BYTE Block[64]);
void Update(BYTE* Input, ULONG nInputLen);
CString Final();
inline DWORD RotateLeft(DWORD x, int n);
inline void FF( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);
inline void GG( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);
inline void HH( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);
inline void II( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T);

//utility functions
void DWordToByte(BYTE* Output, DWORD* Input, UINT nLength);
void ByteToDWord(DWORD* Output, BYTE* Input, UINT nLength);

private:
BYTE  m_lpszBuffer[64];  //input buffer
ULONG m_nCount[2];   //number of bits, modulo 2^64 (lsb first)
ULONG m_lMD5[4];   //MD5 checksum
};

#endif // !defined(AFX_MD5CHECKSUM_H__2BC7928E_4C15_11D3_B2EE_A4A60E20D2C3__INCLUDED_)
3、CountChecksum.cpp （md5校验和类的实现文件）
/*****************************************************************************************
FUNCTION:  CMD5Checksum::GetMD5
DETAILS:  static, public
DESCRIPTION: Gets the MD5 checksum for a specified file
RETURNS:  CString : the hexadecimal MD5 checksum for the specified file
ARGUMENTS:  CString& strFilePath : the full pathname of the specified file
NOTES:   Provides an interface to the CMD5Checksum class. ''strFilePath'' name should
    hold the full pathname of the file, eg C:/My Documents/Arcticle.txt.
    NB. If any problems occur with opening or reading this file, a CFileException
    will be thrown; callers of this function should be ready to catch this
    exception.
*****************************************************************************************/
CString CMD5Checksum::GetMD5(const CString& strFilePath)
{
//open the file as a binary file in readonly mode, denying write access
CFile File(strFilePath, CFile::shareDenyNone);
//the file has been successfully opened, so now get and return its checksum
return GetMD5(File);
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::GetMD5
DETAILS:  static, public
DESCRIPTION: Gets the MD5 checksum for a specified file
RETURNS:  CString : the hexadecimal MD5 checksum for the specified file
ARGUMENTS:  CFile& File : the specified file
NOTES:   Provides an interface to the CMD5Checksum class. ''File'' should be open in
    binary readonly mode before calling this function.
    NB. Callers of this function should be ready to catch any CFileException
    thrown by the CFile functions
*****************************************************************************************/
CString CMD5Checksum::GetMD5(CFile& File)
{
try
{
  CMD5Checksum MD5Checksum;  //checksum object
  int nLength = 0;    //number of bytes read from the file
  const int nBufferSize = 1024; //checksum the file in blocks of 1024 bytes
  BYTE Buffer[nBufferSize];  //buffer for data read from the file

  //checksum the file in blocks of 1024 bytes
  while ((nLength = File.Read( Buffer, nBufferSize )) > 0 )
  {
   MD5Checksum.Update( Buffer, nLength );
  }

  //finalise the checksum and return it
  return MD5Checksum.Final();
}

//report any file exceptions in debug mode only
catch (CFileException* e )
{
  TRACE0("CMD5Checksum::GetMD5: CFileException caught");
  throw e;
}
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::GetMD5
DETAILS:  static, public
DESCRIPTION: Gets the MD5 checksum for data in a BYTE array
RETURNS:  CString : the hexadecimal MD5 checksum for the specified data
ARGUMENTS:  BYTE* pBuf  : pointer to the BYTE array
    UINT nLength : number of BYTEs of data to be checksumed
NOTES:   Provides an interface to the CMD5Checksum class. Any data that can
    be cast to a BYTE array of known length can be checksummed by this
    function. Typically, CString and char arrays will be checksumed,
    although this function can be used to check the integrity of any BYTE array.
    A buffer of zero length can be checksummed; all buffers of zero length
    will return the same checksum.
*****************************************************************************************/
CString CMD5Checksum::GetMD5(BYTE* pBuf, UINT nLength)
{
//entry invariants
AfxIsValidAddress(pBuf,nLength,FALSE);

//calculate and return the checksum
CMD5Checksum MD5Checksum;
MD5Checksum.Update( pBuf, nLength );
return MD5Checksum.Final();
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::RotateLeft
DETAILS:  private
DESCRIPTION: Rotates the bits in a 32 bit DWORD left by a specified amount
RETURNS:  The rotated DWORD
ARGUMENTS:  DWORD x : the value to be rotated
    int n   : the number of bits to rotate by
*****************************************************************************************/
DWORD CMD5Checksum::RotateLeft(DWORD x, int n)
{
//check that DWORD is 4 bytes long - true in Visual C++ 6 and 32 bit Windows
ASSERT( sizeof(x) == 4 );

//rotate and return x
return (x << n) | (x >> (32-n));
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::FF
DETAILS:  protected
DESCRIPTION: Implementation of basic MD5 transformation algorithm
RETURNS:  none
ARGUMENTS:  DWORD &A, B, C, D : Current (partial) checksum
    DWORD X           : Input data
    DWORD S     : MD5_SXX Transformation constant
    DWORD T     : MD5_TXX Transformation constant
NOTES:   None
*****************************************************************************************/
void CMD5Checksum::FF( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
DWORD F = (B & C) | (~B & D);
A += F + X + T;
A = RotateLeft(A, S);
A += B;
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::GG
DETAILS:  protected
DESCRIPTION: Implementation of basic MD5 transformation algorithm
RETURNS:  none
ARGUMENTS:  DWORD &A, B, C, D : Current (partial) checksum
    DWORD X           : Input data
    DWORD S     : MD5_SXX Transformation constant
    DWORD T     : MD5_TXX Transformation constant
NOTES:   None
*****************************************************************************************/
void CMD5Checksum::GG( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
DWORD G = (B & D) | (C & ~D);
A += G + X + T;
A = RotateLeft(A, S);
A += B;
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::HH
DETAILS:  protected
DESCRIPTION: Implementation of basic MD5 transformation algorithm
RETURNS:  none
ARGUMENTS:  DWORD &A, B, C, D : Current (partial) checksum
    DWORD X           : Input data
    DWORD S     : MD5_SXX Transformation constant
    DWORD T     : MD5_TXX Transformation constant
NOTES:   None
*****************************************************************************************/
void CMD5Checksum::HH( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
DWORD H = (B ^ C ^ D);
A += H + X + T;
A = RotateLeft(A, S);
A += B;
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::II
DETAILS:  protected
DESCRIPTION: Implementation of basic MD5 transformation algorithm
RETURNS:  none
ARGUMENTS:  DWORD &A, B, C, D : Current (partial) checksum
    DWORD X           : Input data
    DWORD S     : MD5_SXX Transformation constant
    DWORD T     : MD5_TXX Transformation constant
NOTES:   None
*****************************************************************************************/
void CMD5Checksum::II( DWORD& A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
DWORD I = (C ^ (B | ~D));
A += I + X + T;
A = RotateLeft(A, S);
A += B;
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::ByteToDWord
DETAILS:  private
DESCRIPTION: Transfers the data in an 8 bit array to a 32 bit array
RETURNS:  void
ARGUMENTS:  DWORD* Output : the 32 bit (unsigned long) destination array
    BYTE* Input   : the 8 bit (unsigned char) source array
    UINT nLength  : the number of 8 bit data items in the source array
NOTES:   Four BYTES from the input array are transferred to each DWORD entry
    of the output array. The first BYTE is transferred to the bits (0-7)
    of the output DWORD, the second BYTE to bits 8-15 etc.
    The algorithm assumes that the input array is a multiple of 4 bytes long
    so that there is a perfect fit into the array of 32 bit words.
*****************************************************************************************/
void CMD5Checksum::ByteToDWord(DWORD* Output, BYTE* Input, UINT nLength)
{
//entry invariants
ASSERT( nLength % 4 == 0 );
ASSERT( AfxIsValidAddress(Output, nLength/4, TRUE) );
ASSERT( AfxIsValidAddress(Input, nLength, FALSE) );

//initialisations
UINT i=0; //index to Output array
UINT j=0; //index to Input array

//transfer the data by shifting and copying
for ( ; j < nLength; i++, j += 4)
{
  Output[i] = (ULONG)Input[j]   |
     (ULONG)Input[j+1] << 8 |
     (ULONG)Input[j+2] << 16 |
     (ULONG)Input[j+3] << 24;
}
}

/*****************************************************************************************
FUNCTION:  CMD5Checksum::Transform
DETAILS:  protected
DESCRIPTION: MD5 basic transformation algorithm;  transforms ''m_lMD5''
RETURNS:  void
ARGUMENTS:  BYTE Block[64]
NOTES:   An MD5 checksum is calculated by four rounds of ''Transformation''.
    The MD5 checksum currently held in m_lMD5 is merged by the
    transformation process with data passed in ''Block''. 
*****************************************************************************************/
void CMD5Checksum::Transform(BYTE Block[64])
{
//initialise local data with current checksum
ULONG a = m_lMD5[0];
ULONG b = m_lMD5[1];
ULONG c = m_lMD5[2];
ULONG d = m_lMD5[3];

//copy BYTES from input ''Block'' to an array of ULONGS ''X''
ULONG X[16];
ByteToDWord( X, Block, 64 );

//Perform Round 1 of the transformation
FF (a, b, c, d, X[ 0], MD5_S11, MD5_T01);
FF (d, a, b, c, X[ 1], MD5_S12, MD5_T02);
FF (c, d, a, b, X[ 2], MD5_S13, MD5_T03);
FF (b, c, d, a, X[ 3], MD5_S14, MD5_T04);
FF (a, b, c, d, X[ 4], MD5_S11, MD5_T05);
FF (d, a, b, c, X[ 5], MD5_S12, MD5_T06);
FF (c, d, a, b, X[ 6], MD5_S13, MD5_T07);
FF (b, c, d, a, X[ 7], MD5_S14, MD5_T08);
FF (a, b, c, d, X[ 8], MD5_S11, MD5_T09);
FF (d, a, b, c, X[ 9], MD5_S12, MD5_T10);
FF (c, d, a, b, X[10], MD5_S13, MD5_T11);
FF (b, c, d, a, X[11], MD5_S14, MD5_T12);
FF (a, b, c, d, X[12], MD5_S11, MD5_T13);
FF (d, a, b, c, X[13], MD5_S12, MD5_T14);
FF (c, d, a, b, X[14], MD5_S13, MD5_T15);
FF (b, c, d, a, X[15], MD5_S14, MD5_T16);

//Perform Round 2 of the transformation
GG (a, b, c, d, X[ 1], MD5_S21, MD5_T17);
GG (d, a, b, c, X[ 6], MD5_S22, MD5_T18);
GG (c, d, a, b, X[11], MD5_S23, MD5_T19);
GG (b, c, d, a, X[ 0], MD5_S24, MD5_T20);
GG (a, b, c, d, X[ 5], MD5_S21, MD5_T21);
GG (d, a, b, c, X[10], MD5_S22, MD5_T22);
GG (c, d, a, b, X[15], MD5_S23, MD5_T23);
GG (b, c, d, a, X[ 4], MD5_S24, MD5_T24);
GG (a, b, c, d, X[ 9], MD5_S21, MD5_T25);
GG (d, a, b, c, X[14], MD5_S22, MD5_T26);
GG (c, d, a, b, X[ 3], MD5_S23, MD5_T27);
GG (b, c, d, a, X[ 8], MD5_S24, MD5_T28);
GG (a, b, c, d, X[13], MD5_S21, MD5_T29);
GG (d, a, b, c, X[ 2], MD5_S22, MD5_T30);
GG (c, d, a, b, X[ 7], MD5_S23, MD5_T31);
GG (b, c, d, a, X[12], MD5_S24, MD5_T32);

//Perform Round 3 of the transformation
HH (a, b, c, d, X[ 5], MD5_S31, MD5_T33);
HH (d, a, b, c, X[ 8], MD5_S32, MD5_T34);
HH (c, d, a, b, X[11], MD5_S33, MD5_T35);
HH (b, c, d, a, X[14], MD5_S34, MD5_T36);
HH (a, b, c, d, X[ 1], MD5_S31, MD5_T37);
HH (d, a, b, c, X[ 4], MD5_S32, MD5_T38);
HH (c, d, a, b, X[ 7], MD5_S33, MD5_T39);
HH (b, c, d, a, X[10], MD5_S34, MD5_T40);
HH (a, b, c, d, X[13], MD5_S31, MD5_T41);
HH (d, a, b, c, X[ 0], MD5_S32, MD5_T42);
HH (c, d, a, b, X[ 3], MD5_S33, MD5_T43);
HH (b, c, d, a, X[ 6], MD5_S34, MD5_T44);
HH (a, b, c, d, X[ 9], MD5_S31, MD5_T45);
HH (d, a, b, c, X[12], MD5_S32, MD5_T46);
HH (c, d, a, b, X[15], MD5_S33, MD5_T47);
HH (b, c, d, a, X[ 2], MD5_S34, MD5_T48);

//Perform Round 4 of the transformation
II (a, b, c, d, X[ 0], MD5_S41, MD5_T49);
II (d, a, b, c, X[ 7], MD5_S42, MD5_T50);
II (c, d, a, b, X[14], MD5_S43, MD5_T51);
II (b, c, d, a, X[ 5], MD5_S44, MD5_T52);
II (a, b, c, d, X[12], MD5_S41, MD5_T53);
II (d, a, b, c, X[ 3], MD5_S42, MD5_T54);
II (c, d, a, b, X[10], MD5_S43, MD5_T55);
II (b, c, d, a, X[ 1], MD5_S44, MD5_T56);
II (a, b, c, d, X[ 8], MD5_S41, MD5_T57);
II (d, a, b, c, X[15], MD5_S42, MD5_T58);
II (c, d, a, b, X[ 6], MD5_S43, MD5_T59);
II (b, c, d, a, X[13], MD5_S44, MD5_T60);
II (a, b, c, d, X[ 4], MD5_S41, MD5_T61);
II (d, a, b, c, X[11], MD5_S42, MD5_T62);
II (c, d, a, b, X[ 2], MD5_S43, MD5_T63);
II (b, c, d, a, X[ 9], MD5_S44, MD5_T64);

//add the transformed values to the current checksum
m_lMD5[0] += a;
m_lMD5[1] += b;
m_lMD5[2] += c;
m_lMD5[3] += d;
}


/*****************************************************************************************
CONSTRUCTOR: CMD5Checksum
DESCRIPTION: Initialises member data
ARGUMENTS:  None
NOTES:   None
*****************************************************************************************/
CMD5Checksum::CMD5Checksum()
{
// zero members
memset( m_lpszBuffer, 0, 64 );
m_nCount[0] = m_nCount[1] = 0;

// Load magic state initialization constants
m_lMD5[0] = MD5_INIT_STATE_0;
m_lMD5[1] = MD5_INIT_STATE_1;
m_lMD5[2] = MD5_INIT_STATE_2;
m_lMD5[3] = MD5_INIT_STATE_3;
}

/*****************************************************************************************
FUNCTION:  CMD5Checksum::DWordToByte
DETAILS:  private
DESCRIPTION: Transfers the data in an 32 bit array to a 8 bit array
RETURNS:  void
ARGUMENTS:  BYTE* Output  : the 8 bit destination array
    DWORD* Input  : the 32 bit source array
    UINT nLength  : the number of 8 bit data items in the source array
NOTES:   One DWORD from the input array is transferred into four BYTES
    in the output array. The first (0-7) bits of the first DWORD are
    transferred to the first output BYTE, bits bits 8-15 are transferred from
    the second BYTE etc.
   
    The algorithm assumes that the output array is a multiple of 4 bytes long
    so that there is a perfect fit of 8 bit BYTES into the 32 bit DWORDs.
*****************************************************************************************/
void CMD5Checksum::DWordToByte(BYTE* Output, DWORD* Input, UINT nLength )
{
//entry invariants
ASSERT( nLength % 4 == 0 );
ASSERT( AfxIsValidAddress(Output, nLength, TRUE) );
ASSERT( AfxIsValidAddress(Input, nLength/4, FALSE) );

//transfer the data by shifting and copying
UINT i = 0;
UINT j = 0;
for ( ; j < nLength; i++, j += 4)
{
  Output[j] =   (UCHAR)(Input[i] & 0xff);
  Output[j+1] = (UCHAR)((Input[i] >> 8) & 0xff);
  Output[j+2] = (UCHAR)((Input[i] >> 16) & 0xff);
  Output[j+3] = (UCHAR)((Input[i] >> 24) & 0xff);
}
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::Final
DETAILS:  protected
DESCRIPTION: Implementation of main MD5 checksum algorithm; ends the checksum calculation.
RETURNS:  CString : the final hexadecimal MD5 checksum result
ARGUMENTS:  None
NOTES:   Performs the final MD5 checksum calculation (''Update'' does most of the work,
    this function just finishes the calculation.)
*****************************************************************************************/
CString CMD5Checksum::Final()
{
//Save number of bits
BYTE Bits[8];
DWordToByte( Bits, m_nCount, 8 );

//Pad out to 56 mod 64.
UINT nIndex = (UINT)((m_nCount[0] >> 3) & 0x3f);
UINT nPadLen = (nIndex < 56) ? (56 - nIndex) : (120 - nIndex);
Update( PADDING, nPadLen );

//Append length (before padding)
Update( Bits, 8 );

//Store final state in ''lpszMD5''
const int nMD5Size = 16;
unsigned char lpszMD5[ nMD5Size ];
DWordToByte( lpszMD5, m_lMD5, nMD5Size );

//Convert the hexadecimal checksum to a CString
CString strMD5;
for ( int i=0; i < nMD5Size; i++)
{
  CString Str;
  if (lpszMD5[i] == 0) {
   Str = CString("00");
  }
  else if (lpszMD5[i] <= 15)  {
   Str.Format("0%x",lpszMD5[i]);
  }
  else {
   Str.Format("%x",lpszMD5[i]);
  }

  ASSERT( Str.GetLength() == 2 );
  strMD5 += Str;
}
ASSERT( strMD5.GetLength() == 32 );
return strMD5;
}


/*****************************************************************************************
FUNCTION:  CMD5Checksum::Update
DETAILS:  protected
DESCRIPTION: Implementation of main MD5 checksum algorithm
RETURNS:  void
ARGUMENTS:  BYTE* Input    : input block
    UINT nInputLen : length of input block
NOTES:   Computes the partial MD5 checksum for ''nInputLen'' bytes of data in ''Input''
*****************************************************************************************/
void CMD5Checksum::Update( BYTE* Input, ULONG nInputLen )
{
//Compute number of bytes mod 64
UINT nIndex = (UINT)((m_nCount[0] >> 3) & 0x3F);

//Update number of bits
if ( ( m_nCount[0] += nInputLen << 3 )  <  ( nInputLen << 3) )
{
  m_nCount[1]++;
}
m_nCount[1] += (nInputLen >> 29);

//Transform as many times as possible.
UINT i=0; 
UINT nPartLen = 64 - nIndex;
if (nInputLen >= nPartLen) 
{
  memcpy( &m_lpszBuffer[nIndex], Input, nPartLen );
  Transform( m_lpszBuffer );
  for (i = nPartLen; i + 63 < nInputLen; i += 64)
  {
   Transform( &Input[i] );
  }
  nIndex = 0;
}
else
{
  i = 0;
}

// Buffer remaining input
memcpy( &m_lpszBuffer[nIndex], &Input[i], nInputLen-i);

}

  

iu_81
关注
易语言取16位MD5源码-易语言
06-13
标题中的"易语言取16位MD5源码"指的是使用易语言实现的一个功能，即获取任意字符串的16位MD5值。MD5通常产生32位的十六进制表示，而"16位"可能是指取MD5结果的前半部分或后半部分，用于特定的需求，例如简化显示或...
易语言自制MD5源码-易语言
06-13
在这个“易语言自制MD5源码”项目中，我们关注的是如何在易语言中实现MD5算法。 MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，它能将任意长度的数据转化为固定长度的128位（16字节）摘要，通常以32...
MD5 源码
dlycmsmoses的专栏
02-14 403
package com.dlycms.system.util.MD5; import java.security.MessageDigest; public class MD5 { public static String toMD5(String str) { // 实例化加密对象 MessageDigest md5 = null; try { md5 =
MD5源码（C语言描述）
propor的专栏
03-21 1165
MD5源码（C语言描述）
MD5（原理+代码+分析）
Eternal嘉的博客
05-03 2647
MD5（原理+代码+分析）
Md5实现算法源码
小样
04-23 3633
本文档中只包含源码，如需查看md5的加密过程可以移步我的另外一篇博客 http://blog.csdn.net/ygy162/article/details/70502579 package defire.com.utils; public class MD5 { static final String hexs[]={"0","1","2","3","4","5","6","
C语言MD5源码及实例
huabiaochen的博客
08-18 6738
C语言 MD5源码 md5c.h: ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 /* POINTER defines a generic pointer type */  typedef unsigned cha
易语言改变自身MD5源码
06-04
在这个标题为“易语言改变自身MD5源码”的资源中，我们可以推测其内容是关于如何在易语言环境中编写代码来动态修改程序自身的MD5值。 MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，可以将任意长度...
易语言改变自身MD5源码-易语言
06-13
在“易语言改变自身MD5源码”这个主题中，我们主要探讨的是如何利用易语言来实现对自身程序代码的MD5值进行修改的技术。MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，它可以将任意长度的输入转化为...
易语言源码易语言改变自身MD5源码.rar
02-19
易语言源码易语言改变自身MD5源码.rar 易语言源码易语言改变自身MD5源码.rar 易语言源码易语言改变自身MD5源码.rar 易语言源码易语言改变自身MD5源码.rar 易语言源码易语言改变自身MD5源码.rar 易语言源码...
Cmd5_md5解密网站代码,MD5查询站源码
03-20
Cmd5_md5解密网站代码,MD5查询站源码
md5源码，C语言
Tody Guo的专栏
10-10 1104
为了避免卡脖子工程，Linux系统上面的md5sum在Windows系统下没有64位的版本，那只能自己动手写一个能检查的小工具。 目的是为了能在64位的WinPE下运行。 下面就直接上代码，网络Copy的一些md5的代码拿过来在VS2019上编译不过，现在终于调试通过了。 这个代码是用来检查md5summer产生的md5文件作为标准检查的。其他需要学习的人，可以自己编写，反正这个核心就是md5.cpp的算法内容 md5.h的头文件内容 #ifndef __MD5_H__ #define __MD
MD5加密工具类
weixin_42638610的博客
11-30 333
import java.security.MessageDigest; /** * @Author:wenxin * @Description: * @Date:Created in 9:46 2018/11/30 * Modified By: */ public class MD5Utils { private static final String hexDigIts[...
分享一些免费的MD5解密网站
热门推荐
christ2的专栏
07-11 6万+
最近下载了几个mdb文件，里面几万条md5和几千条sha512（居然还有站长用512直接放在库中的，尼玛多占空间啊），我用C#写了个工具暴力了一小部分，大概不到3%吧， 花了我两天，电脑卡得要死，效果太差，而且越到后面越难，还是算了吧。于是朋友介绍了几个免费的md5解密网站，也有几个是自己找的，有些觉得效果还可以，有些却是极品，在这里分享给大家，顺便做个评测： 1. http://www.cmd...
MD5加密（纯代码）
心中有侠
08-08 1万+
import java.math.BigInteger; import java.security.MessageDigest; public class MD5 { /** * 对字符串md5加密(小写字母+数字) * * @param str 传入要加密的字符串 * @return MD5加密后的字符串 */ p...
bulldog-1靶机 write up 源码 MD5解密得到密码到后台 命令执行&&绕过 反弹shell string分析文件得到密码提权
YouthBelief的博客
11-30 1985
bulldog-1靶机 write up0x00 环境搭建0x01 信息收集0x02 漏洞挖掘web漏洞思路ssh 利用思路步骤1：浏览网页 爆破目录步骤二： 破解hash步骤三：利用密码登录后台步骤四：利用命令执行（需要尝试绕过方法）步骤五：反弹shell0x03 提升权限步骤六：查看系统用户，确定需要关注的用户步骤七：查找每个用户的文件步骤八：拼接root密码提权0x04 思路总结 0x00 环境搭建 下载链接 https://download.vulnhub.com/bulldog/bulld
基于JavaWeb的门店管理系统源代码+数据库
09-25
基于JavaWeb的门店管理系统源代码+数据库
基于国产自研的简洁易扩展warm-flow工作流设计源码
最新发布
09-25
本项目为国产自研的warm-flow工作流设计源码，采用简洁的架构设计，仅需6张基础表，却能实现全面的功能。代码结构清晰，组件独立且易于扩展，非常适合中小型项目使用。源码包含215个文件，涵盖158个Java源文件、32个XML配置文件、7个SQL文件等，旨在为用户提供高效、灵活的工作流解决方案。
Java JNI例子-创建DLL、项目导入DLL、IDEA配置JNI、JNI调用DLL（该DLL同时依赖第三方DLL）
09-25
Java JNI例子-创建DLL、项目导入DLL、IDEA配置JNI、JNI调用DLL（该DLL同时依赖第三方DLL）
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值