C++計算檔案MD5值

阿新 • • 發佈：2019-01-28

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
};

CMD5Checksum.h

#if !defined(AFX_MD5CHECKSUM_H__2BC7928E_4C15_11D3_B2EE_A4A60E20D2C3__INCLUDED_)
#define AFX_MD5CHECKSUM_H__2BC7928E_4C15_11D3_B2EE_A4A60E20D2C3__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
/*****************************************************************************************

  
*****************************************************************************************/
class CMD5Checksum  
{
public:
 static CString GetMD5OfString(CString strString);
 //interface functions for the RSA MD5 calculation
 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
 inline void DWordToByte(BYTE* Output, DWORD* Input, UINT nLength);
 inline 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_)

MD5Checksum.cpp

#include "stdafx.h"
#include "MD5Checksum.h"
#include "MD5ChecksumDefines.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


/*****************************************************************************************

*****************************************************************************************/
CString CMD5Checksum::GetMD5(const CString& strFilePath)
{
	try
	{ 
		CFile file;
		if(file.Open(strFilePath,CFile::modeRead)==0)
			return _T("");

		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 );
		}

		file.Close();

		//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::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(_T("0%X"),lpszMD5[i]);
		}
		else
		{ 
			Str.Format(_T("%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);
}



CString CMD5Checksum::GetMD5OfString(CString strString)
{
	try
	{ 
		CMD5Checksum MD5Checksum;   //checksum object 
		int nLength = strString.GetLength();       //number of bytes read from the file
		//const int nBufferSize = 1024; //checksum the file in blocks of 1024 bytes
		BYTE *Buffer;   //buffer for data read from the file
		Buffer=(BYTE*)(strString.GetBuffer(nLength));
		//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;
	}
}

呼叫的地方：

m_strFileMD5 = CMD5Checksum::GetMD5(m_strFilePath);

C++計算檔案MD5值

MD5ChecksumDefines.h //Magic initialization constants #define MD5_INIT_STATE_0 0x67452301 #define MD5_INIT_STATE_1 0xefcdab89 #define MD5

解決spark-md5.js和java計算檔案md5值不一致問題

正確程式碼如下 java import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.IOException; impor

C# 計算檔案SHA256值

public static Byte[] SHA256Encrypt(string StrIn) { var sha256 = new SHA256Managed(); var Asc = new ASCIIEnc

C語言計算檔案MD5

　　計算MD5這種很標準的東西，一般直接使用別人寫好的了就行，本文主要針對寫好的介面測試一下如何使用的問題。下面是MD5的實現 md5.h #ifndef MD5_H #define MD5_H typedef struct

獲取apk證書檔案MD5值

已有apk檔案，想要獲取簽名檔案的MD5簽名信息方法一　　1.先把apk解壓　　2.在META_INF目錄下找到xxx.RSA檔案　　3.確保安裝了jdk並且正確配置了環境變數　　4.cmd中執行keytool -printcert -file xxxx.RSA目錄

獲取大檔案MD5值（JAVA）

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

瀏覽器獲取檔案MD5值

能做到大檔案md5值的獲取，但是檔案越大耗時越久。 spark-md5工具包：https://download.csdn.net/download/weixin_36524613/10545957 <!DOCTYPE html> <html lang="en"> &l

Python校驗檔案MD5值

import hashlib import os def GetFileMd5(filename): if not os.path.isfile(filename): return myHash = hashlib.md5() f = open(filenam

如何計算檔案MD5 sha1 -- 微軟MD5/SHA1 校驗工具 Microsoft File Checksum Integrity Verifier

微軟出品的小工具（Microsoft File Checksum Integrity Verifier）。 https://www.microsoft.com/en-us/download/detai

js跟java計算檔案MD5不一致問題

最近專案中發現js跟java算出的MD5值不一樣，經比較發現是js問題。因為在js中，甚至二進位制流都是利用UTF-16編碼的，而大多數計算md5值的方案都是基於二進位制流的, 所以需要將js讀出來的二進位制流（已經被轉換成UTF-16編碼）還原成二進位制流。latin—1

JAVA File類的hashCode()和計算檔案hash值的區別

File類的hashCode()和計算檔案的hash值是不同的東西。區別： File類的hashCode()只是計算檔案的相對路徑hash值。計算檔案的hash值是計算檔案內容的hash值。 File類的hashCode()測試程式碼： String filePath

c++ 生成檔案MD5

md5.h #ifndef MD5_H #define MD5_H #include <string> #include <fstream> /* Type define */ typedef unsigned char byt

視訊檔案MD5值獲取及校驗

最近在做大檔案分割，分片上傳，達到充分利用網路頻寬 > 檔案的上傳與下載極易出錯，尤其涉及使用斷點續傳方式上傳或下載的檔案。 > 目的：校驗MD5值是為了防止在傳輸的過程當中丟包或者資料包被篡改 MD5值得作用：任何一個字串或檔案，無論是可執行程

JAVA獲取檔案MD5值

/** * Md5校驗工具類 * @author Fengwx */ public class MD5Util { private static final char[] hexDigits = {'0', '1', '2', '3', '4', '5',

使用python計算檔案MD5

需要用到hashlib具體指令碼如下#! /usr/bin/env python # coding=utf-8 import os import sys import hashlib def md5sum(filename): if not os.path.isf

python選取資料夾，然後計算該資料夾下所有檔案的md5值，並列出md5值相同的檔案到log中

因為在處理手機相簿的時候，發現有些照片儲存了好多次，為了保證一張圖片不被多次儲存，所以想到通過計算圖片md5值的方式來進行篩選。圖片的md5值計算，使用python非常方便。執行該py之後，會有一個對話方塊，通過選擇目錄，即可遍歷該目錄及子目錄下所有檔案，計算出md5值，並將md5值重複

最近在清理重複檔案的時候發現一個MD5值計算工具

http://www.pc-tools.net/win32/md5sums/ 在這裡可以下載到該工具。 Download: md5sums-1.2.zip [28 K] 使用方法md5sums.txt檔案中有講到。初衷是本地存放了大量的照片，由於人

C++實現md5加密或計算檔案的唯一性識別

由於網路上傳了很多關於C++實現md5加密的類，至於那個是原創，我不敢妄加猜測，只是這裡我宣告我是轉載的，並支援原創。對於md5加密演算法，我提供兩檔案： #ifndef MD5_H #define MD5_H #include <string> #i

用python計算檔案的md5值

在Python中內建了md5的實現，就是md5模組，因此可以很簡單的處理比較兩個檔案是否一致的問題。如以下程式碼片斷： import os,sys,md5 f1 = open(’f:/1.txt’,’r’) f2 = open(’f:/1.txt’,’r’) print

[C#] 計算大檔案的MD5的兩種方式(直接呼叫方法計算，流計算-適用於大檔案)

通過.NET中的預設類實現，但是採用不同類，針對不同的情況：具體如下：類： /// <summary> /// 檔案MD5操作類 /// </summary> public class MD5Checker {

C++計算檔案MD5值

相關推薦