调用:
CMD5_VC::MD5(pBuf, nLength);
CMD5_VC::MD5(fFile);
CMD5_VC::MD5(strFilePath);
原代码:
// MD5Checksumh: interface for the MD5Checksum class
//
//////////////////////////////////////////////////////////////////////
#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 CMD5_VC
{
public:
//interface functions for the RSA MD5 calculation
static CString MD5(BYTE pBuf, UINT nLength);
static CString MD5(CFile& File);
static CString MD5(const CString& strFilePath);
protected:
//constructor/destructor
CMD5_VC();
virtual ~CMD5_VC() {};
//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_)
//////////////////////////////////////////////////////////////////////////////////
//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 // 2
#define MD5_T03 0x242070db // 3
#define MD5_T04 0xc1bdceee // 4
#define MD5_T05 0xf57c0faf // 5
#define MD5_T06 0x4787c62a // 6
#define MD5_T07 0xa8304613 // 7
#define MD5_T08 0xfd469501 // 8
#define MD5_T09 0x698098d8 // 9
#define MD5_T10 0x8b44f7af // 10
#define MD5_T11 0xffff5bb1 // 11
#define MD5_T12 0x895cd7be // 12
#define MD5_T13 0x6b901122 // 13
#define MD5_T14 0xfd987193 // 14
#define MD5_T15 0xa679438e // 15
#define MD5_T16 0x49b40821 // 16
//s - Round 2
#define MD5_T17 0xf61e2562 // 17
#define MD5_T18 0xc040b340 // 18
#define MD5_T19 0x265e5a51 // 19
#define MD5_T20 0xe9b6c7aa // 20
#define MD5_T21 0xd62f105d // 21
#define MD5_T22 0x02441453 // 22
#define MD5_T23 0xd8a1e681 // 23
#define MD5_T24 0xe7d3fbc8 // 24
#define MD5_T25 0x21e1cde6 // 25
#define MD5_T26 0xc33707d6 // 26
#define MD5_T27 0xf4d50d87 // 27
#define MD5_T28 0x455a14ed // 28
#define MD5_T29 0xa9e3e905 // 29
#define MD5_T30 0xfcefa3f8 // 30
#define MD5_T31 0x676f02d9 // 31
#define MD5_T32 0x8d2a4c8a // 32
//s - Round 3
#define MD5_T33 0xfffa3942 // 33
#define MD5_T34 0x8771f681 // 34
#define MD5_T35 0x6d9d6122 // 35
#define MD5_T36 0xfde5380c // 36
#define MD5_T37 0xa4beea44 // 37
#define MD5_T38 0x4bdecfa9 // 38
#define MD5_T39 0xf6bb4b60 // 39
#define MD5_T40 0xbebfbc70 // 40
#define MD5_T41 0x289b7ec6 // 41
#define MD5_T42 0xeaa127fa // 42
#define MD5_T43 0xd4ef3085 // 43
#define MD5_T44 0x04881d05 // 44
#define MD5_T45 0xd9d4d039 // 45
#define MD5_T46 0xe6db99e5 // 46
#define MD5_T47 0x1fa27cf8 // 47
#define MD5_T48 0xc4ac5665 // 48
//s - Round 4
#define MD5_T49 0xf4292244 // 49
#define MD5_T50 0x432aff97 // 50
#define MD5_T51 0xab9423a7 // 51
#define MD5_T52 0xfc93a039 // 52
#define MD5_T53 0x655b59c3 // 53
#define MD5_T54 0x8f0ccc92 // 54
#define MD5_T55 0xffeff47d // 55
#define MD5_T56 0x85845dd1 // 56
#define MD5_T57 0x6fa87e4f // 57
#define MD5_T58 0xfe2ce6e0 // 58
#define MD5_T59 0xa3014314 // 59
#define MD5_T60 0x4e0811a1 // 60
#define MD5_T61 0xf7537e82 // 61
#define MD5_T62 0xbd3af235 // 62
#define MD5_T63 0x2ad7d2bb // 63
#define MD5_T64 0xeb86d391 // 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
};
// MD5Checksumcpp: implementation of the MD5Checksum class
//
//////////////////////////////////////////////////////////////////////
#include "stdafxh"
#include "MD5_VCh"
#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif
CString CMD5_VC::MD5(const CString& strFilePath)
{
//open the file as a binary file in readonly mode, denying write access
CFile File(strFilePath, CFile::modeRead | CFile::shareDenyWrite | CFile::typeBinary);
//the file has been successfully opened, so now get and return its checksum
return MD5(File);
}
CString CMD5_VC::MD5(CFile& File)
{
try
{
CMD5_VC MD5_VC; //MD5_VC 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 = FileRead( Buffer, nBufferSize )) > 0 )
{
MD5_VCUpdate( Buffer, nLength );
}
//finalise the checksum and return it
return MD5_VCFinal();
}
//report any file exceptions in debug mode only
catch (CFileException e )
{
TRACE0("CMD5_VC::MD5: CFileException caught");
throw e;
}
}
CString CMD5_VC::MD5(BYTE pBuf, UINT nLength)
{
//entry invariants
AfxIsValidAddress(pBuf,nLength,FALSE);
//calculate and return the checksum
CMD5_VC MD5_VC;
MD5_VCUpdate( pBuf, nLength );
return MD5_VCFinal();
}
DWORD CMD5_VC::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));
}
void CMD5_VC::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;
}
void CMD5_VC::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;
}
void CMD5_VC::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;
}
void CMD5_VC::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;
}
void CMD5_VC::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;
}
CMD5_VC::CMD5_VC()
{
// 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;
}
void CMD5_VC::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;
}
}
void CMD5_VC::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);
}
}
CString CMD5_VC::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) {
StrFormat("0%X",lpszMD5[i]);
}
else {
StrFormat("%X",lpszMD5[i]);
}
ASSERT( StrGetLength() == 2 );
strMD5 += Str;
}
ASSERT( strMD5GetLength() == 32 );
return strMD5;
}
void CMD5_VC::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);
}
你把下面的代码复制下来，保存成md5libh，然后在C代码中：
#include "md5libh" 即可
其中：
char MDString (char string);是对字符串进行MD5
char MDFile (char filename);是对文件进行MD5
以下是代码
//--------------------------------
/ MD5libh - md5 library
/
/ Copyright (C) 1990-2, RSA Data Security, Inc Created 1990 All
rights reserved
RSA Data Security, Inc makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose It is provided "as is"
without express or implied warranty of any kind
These notices must be retained in any copies of any part of this
documentation and/or software
/
/ The following makes MD default to MD5 if it has not already been
defined with C compiler flags
/
#include <stdioh>
#include <timeh>
#include <stringh>
#define MD 5
/ GLOBALH - RSAREF types and constants
/
/ PROTOTYPES should be set to one if and only if the compiler supports
function argument prototyping
The following makes PROTOTYPES default to 0 if it has not already
been defined with C compiler flags
/
#ifndef PROTOTYPES
#define PROTOTYPES 0
#endif
/ POINTER defines a generic pointer type /
typedef unsigned char POINTER;
/ UINT2 defines a two byte word /
typedef unsigned short int UINT2;
/ UINT4 defines a four byte word /
typedef unsigned long int UINT4;
/ PROTO_LIST is defined depending on how PROTOTYPES is defined above
If using PROTOTYPES, then PROTO_LIST returns the list, otherwise it
returns an empty list
/
#if PROTOTYPES
#define PROTO_LIST(list) list
#else
#define PROTO_LIST(list) ()
#endif
/ Length of test block, number of test blocks
/
#define TEST_BLOCK_LEN 1000
#define TEST_BLOCK_COUNT 1000
/ Constants for MD5Transform routine
/
#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
char MDString PROTO_LIST ((char ));
char MDFile PROTO_LIST ((char ));
char hmac_md5(char text, char key);
typedef struct {
UINT4 state[4]; / state (ABCD) /
UINT4 count[2]; / number of bits, modulo 2^64 (lsb first) /
unsigned char buffer[64]; / input buffer /
} MD5_CTX;
/void MD5Init PROTO_LIST ((MD5_CTX ));
void MD5Update PROTO_LIST
((MD5_CTX , unsigned char , unsigned int));
void MD5Final PROTO_LIST ((unsigned char [16], MD5_CT X ));
static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64]));
static void Encode PROTO_LIST
((unsigned char , UINT4 , unsigned int));
static void Decode PROTO_LIST
((UINT4 , unsigned char , unsigned int));
static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int));
static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int));
/
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
};
/ F, G, H and I are basic MD5 functions
/
#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)))
/ ROTATE_LEFT rotates x left n bits
/
#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n))))
/ FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4
Rotation is separate from addition to prevent recomputation
/
#define FF(a, b, c, d, x, s, ac) {(a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b);}
#define GG(a, b, c, d, x, s, ac) {(a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b);}
#define HH(a, b, c, d, x, s, ac) {(a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b);}
#define II(a, b, c, d, x, s, ac) {(a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); (a) = ROTATE_LEFT ((a), (s)); (a) += (b);}
void MD5Init (MD5_CTX context);
void MD5Update(MD5_CTX context, unsigned char input,unsigned int inputLen);
void MD5Final (unsigned char digest[16], MD5_CTX context);
static void MD5Transform (UINT4 [4], unsigned char [64]) ;
static void Encode(unsigned char , UINT4 , unsigned int);
static void Decode (UINT4 , unsigned char , unsigned int);
static void MD5_memcpy(POINTER, POINTER, unsigned int);
static void MD5_memset(POINTER, int, unsigned int);
/ MD5 initialization Begins an MD5 operation, writing a new context
/
void MD5Init (MD5_CTX context)
/ context /
{
context->count[0] = context->count[1] = 0;
/ Load magic initialization constants
/
context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}
/ MD5 block update operation Continues an MD5 message-digest
operation, processing another message block, and updating the
context
/
void MD5Update (MD5_CTX context, unsigned char input,unsigned int inputLen )
/ context /
/ input block /
/ length of input block /
{
unsigned int i, index, partLen;
/ Compute number of bytes mod 64 /
index = (unsigned int)((context->count[0] >> 3) & 0x3F);
/ Update number of bits /
if ((context->count[0] += ((UINT4)inputLen << 3))
< ((UINT4)inputLen << 3))
context->count[1]++;
context->count[1] += ((UINT4)inputLen >> 29);
partLen = 64 - index;
/ Transform as many times as possible
/
if (inputLen >= partLen) {
MD5_memcpy
((POINTER)&context->buffer[index], (POINTER)input, partLen);
MD5Transform (context->state, context->buffer);
for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform (context->state, &input[i]);
index = 0;
}
else
i = 0;
/ Buffer remaining input /
MD5_memcpy
((POINTER)&context->buffer[index], (POINTER)&input[i],
inputLen-i);
}
/ MD5 finalization Ends an MD5 message-digest operation, writing the
the message digest and zeroizing the context
/
void MD5Final (unsigned char digest[16], MD5_CTX context)
/ message digest /
/ context /
{
unsigned char bits[8];
unsigned int index, padLen;
/ Save number of bits /
Encode (bits, context->count, 8);
/ Pad out to 56 mod 64
/
index = (unsigned int)((context->count[0] >> 3) & 0x3f);
padLen = (index < 56) (56 - index) : (120 - index);
MD5Update (context,(unsigned char) PADDING, padLen);
/ Append length (before padding) /
MD5Update (context, bits, 8);
/ Store state in digest /
Encode (digest, context->state, 16);
/ Zeroize sensitive information
/
MD5_memset ((POINTER)context, 0, sizeof (context));
}
/ MD5 basic transformation Transforms state based on block
/
static void MD5Transform (UINT4 state[4],
unsigned char block[64])
{
int i=0;
UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
Decode (x, block, 64);
/ Round 1 /
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 /
/ Round 2 /
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 /
/ Round 3 /
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 /
/ Round 4 /
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;
/ Zeroize sensitive information
/
MD5_memset ((POINTER)x, 0, sizeof (x));
}
/ Encodes input (UINT4) into output (unsigned char) Assumes len is
a multiple of 4
/
static void Encode (unsigned char output,
UINT4 input,
unsigned int len)
{
unsigned int i, 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);
}
}
/ Decodes input (unsigned char) into output (UINT4) Assumes len is
a multiple of 4
/
static void Decode (UINT4 output,
unsigned char input,
unsigned int len)
{
unsigned int i, j;
for (i = 0, j = 0; j < len; i++, j += 4)
output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) |
(((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24);
}
/ Note: Replace "for loop" with standard memcpy if possible
/
static void MD5_memcpy (POINTER output,
POINTER input,
unsigned int len)
{
unsigned int i;
for (i = 0; i < len; i++)
output[i] = input[i];
}
/ Note: Replace "for loop" with standard memset if possible
/
static void MD5_memset (POINTER output,
int value,
unsigned int len)
{
unsigned int i;
for (i = 0; i < len; i++)
((char )output)[i] = (char)value;
}
/ Digests a string and prints the result
/
char MDString (char string)
{
MD5_CTX context;
unsigned char digest[16];
char output1[32];
static char output[33]={""};
unsigned int len = strlen (string);
int i;
MD5Init (&context);
MD5Update (&context, (unsigned char)string, len);
MD5Final (digest, &context);
for (i = 0; i < 16; i++)
{sprintf(&(output1[2i]),"%02x",(unsigned char)digest[i]);
sprintf(&(output1[2i+1]),"%02x",(unsigned char)(digest[i]<<4));
}
for(i=0;i<32;i++)
output[i]=output1[i];
return output;
}
/ Digests a file and prints the result
/
char MDFile (char filename)
{ static char output[33]={""};
FILE file;
MD5_CTX context;
int len;
unsigned char buffer[1024], digest[16];
int i;
char output1[32];
if ((file = fopen (filename, "rb")) == NULL)
{ printf ("%s can't be openedn", filename);
return 0;
}
else {
MD5Init (&context);
while (len = fread (buffer, 1, 1024, file))
MD5Update (&context, buffer, len);
MD5Final (digest, &context);
fclose (file);
for (i = 0; i < 16; i++)
{sprintf(&(output1[2i]),"%02x",(unsigned char)digest[i]);
sprintf(&(output1[2i+1]),"%02x",(unsigned char)(digest[i]<<4));
}
for(i=0;i<32;i++)
output[i]=output1[i];
return output;
}
}
char hmac_md5(char text,char key)
{
char digest[16];
char output1[32];
static char output[33]={""};
MD5_CTX context;
unsigned char k_ipad[65]; / inner padding -
key XORd with ipad
/
unsigned char k_opad[65]; / outer padding -
key XORd with opad
/
unsigned char tk[16];
int i;
int text_len = strlen (text);
int key_len=strlen(key);
/ if key is longer than 64 bytes reset it to key=MD5(key) /
if (key_len > 64) {
MD5_CTX tctx;
MD5Init(&tctx);
MD5Update(&tctx,(unsigned char) key, key_len);
MD5Final(tk, &tctx);
key = (char)tk;
key_len = 16;
}
/
the HMAC_MD5 transform looks like:
MD5(K XOR opad, MD5(K XOR ipad, text))
where K is an n byte key
ipad is the byte 0x36 repeated 64 times
opad is the byte 0x5c repeated 64 times
and text is the data being protected
/
/ start out by storing key in pads /
/bzero( k_ipad, sizeof k_ipad);
bzero( k_opad, sizeof k_opad);
/
for(i=0;i<65;i++)
k_ipad[i]=(unsigned char)0;
for(i=0;i<65;i++)
k_opad[i]=(unsigned char)0;
/bcopy( key, k_ipad, key_len);
bcopy( key, k_opad, key_len);
/
for(i=0;i<key_len;i++)
{k_ipad[i]=(unsigned char)key[i];
k_opad[i]=(unsigned char)key[i];
}
/ XOR key with ipad and opad values /
for (i=0; i<64; i++) {
k_ipad[i] ^= 0x36;
k_opad[i] ^= 0x5c;
}
/
perform inner MD5
/
MD5Init(&context); / init context for 1st
pass /
MD5Update(&context, k_ipad, 64); / start with inner pad /
MD5Update(&context, (unsigned char)text, text_len); / then text of datagram
/
MD5Final((unsigned char)digest, &context); / finish up 1st pass /
/
perform outer MD5
/
MD5Init(&context); / init context for 2nd
pass /
MD5Update(&context, k_opad, 64); / start with outer pad /
MD5Update(&context,(unsigned char) digest, 16); / then results of 1st
hash /
MD5Final((unsigned char)digest, &context); / finish up 2nd pass /
for (i = 0; i < 16; i++)
{sprintf(&(output1[2i]),"%02x",(unsigned char)digest[i]);
sprintf(&(output1[2i+1]),"%02x",(unsigned char)(digest[i]<<4));
}
for(i=0;i<32;i++)
output[i]=output1[i];
return output;
}
以上就是关于如何在Delphi中使用md5全部的内容，包括:如何在Delphi中使用md5、求一首英文歌，男生唱的，其中一句歌词是oh baby ,it's a mad world、格言的英文翻译等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）