VC++取MD5算法记录下以后用得到（转）

这个是网上扒下来的 作者已经无法知道是谁了

MD5.h

 #ifndef MD5_H
 #define MD5_H 

 #include <string>
 #include <fstream> 

 /* Type define */
 typedef unsigned char byte;
 typedef unsigned int uint32;
 typedef unsigned int uint4;

 using std::string;
 using std::ifstream;

 /* MD5 declaration. */
 class MD5 {
 public:
     MD5();
     MD5(const void *input, size_t length);
     MD5(const string &str);
     MD5(ifstream &in);
     void update(const void *input, size_t length);
     void update(const string &str);
     void update(ifstream &in);
     const byte* digest();
     string toString();
     void reset();

     inline uint4 rotate_left(uint4 x, int n);
     inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
     inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
     inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
     inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);

 private:
     void update(const byte *input, size_t length);
     void final();
     void transform(const byte block[]);
     void encode(const uint32 *input, byte *output, size_t length);
     void decode(const byte *input, uint32 *output, size_t length);
     string bytesToHexString(const byte *input, size_t length);

     /* class uncopyable */
     MD5(const MD5&);
     MD5& operator=(const MD5&);
 private:
     uint32 _state[]; /* state (ABCD) */
     uint32 _count[]; /* number of bits, modulo 2^64 (low-order word first) */
     byte _buffer[]; /* input buffer */
     byte _digest[]; /* message digest */
     bool _finished; /* calculate finished ? */

     static const byte PADDING[]; /* padding for calculate */
     static const char HEX[];
     static const size_t BUFFER_SIZE = ;
 };

 string FileDigest(const string &file);

 #endif/*MD5_H*/ 

MD5.cpp

 #include "md5.h" 

 using namespace std;

 /* 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 

 /* 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)+ac; \
 //(a) = ROTATE_LEFT((a), (s)); \
 //(a) += (b); \
 //}
 //#define GG(a, b, c, d, x, s, ac) { \
 //(a) += G((b), (c), (d)) + (x)+ac; \
 //(a) = ROTATE_LEFT((a), (s)); \
 //(a) += (b); \
 //}
 //#define HH(a, b, c, d, x, s, ac) { \
 //(a) += H((b), (c), (d)) + (x)+ac; \
 //(a) = ROTATE_LEFT((a), (s)); \
 //(a) += (b); \
 //}
 //#define II(a, b, c, d, x, s, ac) { \
 //(a) += I((b), (c), (d)) + (x)+ac; \
 //(a) = ROTATE_LEFT((a), (s)); \
 //(a) += (b); \
 //}

 inline uint4 MD5::rotate_left(uint4 x, int n) {
     return (x << n) | (x >> ( - n));
 }

 inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
     a = rotate_left(a + F(b, c, d) + x + ac, s) + b;
 }

 inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
     a = rotate_left(a + G(b, c, d) + x + ac, s) + b;
 }

 inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
     a = rotate_left(a + H(b, c, d) + x + ac, s) + b;
 }

 inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
     a = rotate_left(a + I(b, c, d) + x + ac, s) + b;
 }

 const byte MD5::PADDING[] = { 0x80 };
 const char MD5::HEX[] = {
     '', '', '', '',
     '', '', '', '',
     '', '', 'a', 'b',
     'c', 'd', 'e', 'f'
 };

 /* Default construct. */
 MD5::MD5() {
     reset();
 }

 /* Construct a MD5 object with a input buffer. */
 MD5::MD5(const void *input, size_t length) {
     reset();
     update(input, length);
 }

 /* Construct a MD5 object with a string. */
 MD5::MD5(const string &str) {
     reset();
     update(str);
 }

 /* Construct a MD5 object with a file. */
 MD5::MD5(ifstream &in) {
     reset();
     update(in);
 }

 /* Return the message-digest */
 const byte* MD5::digest() {
     if (!_finished) {
         _finished = true;
         final();
     }
     return _digest;
 }

 /* Reset the calculate state */
 void MD5::reset() {

     _finished = false;
     /* reset number of bits. */
     _count[] = _count[] = ;
     /* Load magic initialization constants. */
     _state[] = 0x67452301;
     _state[] = 0xefcdab89;
     _state[] = 0x98badcfe;
     _state[] = 0x10325476;
 }

 /* Updating the context with a input buffer. */
 void MD5::update(const void *input, size_t length) {
     update((const byte*)input, length);
 }

 /* Updating the context with a string. */
 void MD5::update(const string &str) {
     update((const byte*)str.c_str(), str.length());
 }

 /* Updating the context with a file. */
 void MD5::update(ifstream &in) {

     if (!in)
         return;

     std::streamsize length;
     char buffer[BUFFER_SIZE];
     while (!in.eof()) {
         in.read(buffer, BUFFER_SIZE);
         length = in.gcount();
         if (length > )
             update(buffer, length);
     }
     in.close();
 }

 /* MD5 block update operation. Continues an MD5 message-digest
 operation, processing another message block, and updating the
 context.
 */
 void MD5::update(const byte *input, size_t length) {

     uint32 i, index, partLen;

     _finished = false;

     /* Compute number of bytes mod 64 */
     index = (uint32)((_count[] >> ) & 0x3f);

     /* update number of bits */
     if ((_count[] += ((uint32)length << )) < ((uint32)length << ))
         _count[]++;
     _count[] += ((uint32)length >> );

     partLen =  - index;

     /* transform as many times as possible. */
     if (length >= partLen) {

         memcpy(&_buffer[index], input, partLen);
         transform(_buffer);

         for (i = partLen; i +  < length; i += )
             transform(&input[i]);
         index = ;

     }
     else {
         i = ;
     }

     /* Buffer remaining input */
     memcpy(&_buffer[index], &input[i], length - i);
 }

 /* MD5 finalization. Ends an MD5 message-_digest operation, writing the
 the message _digest and zeroizing the context.
 */
 void MD5::final() {

     byte bits[];
     uint32 oldState[];
     uint32 oldCount[];
     uint32 index, padLen;

     /* Save current state and count. */
     memcpy(oldState, _state, );
     memcpy(oldCount, _count, );

     /* Save number of bits */
     encode(_count, bits, );

     /* Pad out to 56 mod 64. */
     index = (uint32)((_count[] >> ) & 0x3f);
     padLen = (index < ) ? ( - index) : ( - index);
     update(PADDING, padLen);

     /* Append length (before padding) */
     update(bits, );

     /* Store state in digest */
     encode(_state, _digest, );

     /* Restore current state and count. */
     memcpy(_state, oldState, );
     memcpy(_count, oldCount, );
 }

 /* MD5 basic transformation. Transforms _state based on block. */
 void MD5::transform(const byte block[]) {

     uint32 a = _state[], b = _state[], c = _state[], d = _state[], x[];

     decode(block, x, );

     /* Round 1 */
     FF(a, b, c, d, x[], S11, 0xd76aa478); /* 1 */
     FF(d, a, b, c, x[], S12, 0xe8c7b756); /* 2 */
     FF(c, d, a, b, x[], S13, 0x242070db); /* 3 */
     FF(b, c, d, a, x[], S14, 0xc1bdceee); /* 4 */
     FF(a, b, c, d, x[], S11, 0xf57c0faf); /* 5 */
     FF(d, a, b, c, x[], S12, 0x4787c62a); /* 6 */
     FF(c, d, a, b, x[], S13, 0xa8304613); /* 7 */
     FF(b, c, d, a, x[], S14, 0xfd469501); /* 8 */
     FF(a, b, c, d, x[], S11, 0x698098d8); /* 9 */
     FF(d, a, b, c, x[], S12, 0x8b44f7af); /* 10 */
     FF(c, d, a, b, x[], S13, 0xffff5bb1); /* 11 */
     FF(b, c, d, a, x[], S14, 0x895cd7be); /* 12 */
     FF(a, b, c, d, x[], S11, 0x6b901122); /* 13 */
     FF(d, a, b, c, x[], S12, 0xfd987193); /* 14 */
     FF(c, d, a, b, x[], S13, 0xa679438e); /* 15 */
     FF(b, c, d, a, x[], S14, 0x49b40821); /* 16 */

                                             /* Round 2 */
     GG(a, b, c, d, x[], S21, 0xf61e2562); /* 17 */
     GG(d, a, b, c, x[], S22, 0xc040b340); /* 18 */
     GG(c, d, a, b, x[], S23, 0x265e5a51); /* 19 */
     GG(b, c, d, a, x[], S24, 0xe9b6c7aa); /* 20 */
     GG(a, b, c, d, x[], S21, 0xd62f105d); /* 21 */
     GG(d, a, b, c, x[], S22, 0x2441453); /* 22 */
     GG(c, d, a, b, x[], S23, 0xd8a1e681); /* 23 */
     GG(b, c, d, a, x[], S24, 0xe7d3fbc8); /* 24 */
     GG(a, b, c, d, x[], S21, 0x21e1cde6); /* 25 */
     GG(d, a, b, c, x[], S22, 0xc33707d6); /* 26 */
     GG(c, d, a, b, x[], S23, 0xf4d50d87); /* 27 */
     GG(b, c, d, a, x[], S24, 0x455a14ed); /* 28 */
     GG(a, b, c, d, x[], S21, 0xa9e3e905); /* 29 */
     GG(d, a, b, c, x[], S22, 0xfcefa3f8); /* 30 */
     GG(c, d, a, b, x[], S23, 0x676f02d9); /* 31 */
     GG(b, c, d, a, x[], S24, 0x8d2a4c8a); /* 32 */

                                             /* Round 3 */
     HH(a, b, c, d, x[], S31, 0xfffa3942); /* 33 */
     HH(d, a, b, c, x[], S32, 0x8771f681); /* 34 */
     HH(c, d, a, b, x[], S33, 0x6d9d6122); /* 35 */
     HH(b, c, d, a, x[], S34, 0xfde5380c); /* 36 */
     HH(a, b, c, d, x[], S31, 0xa4beea44); /* 37 */
     HH(d, a, b, c, x[], S32, 0x4bdecfa9); /* 38 */
     HH(c, d, a, b, x[], S33, 0xf6bb4b60); /* 39 */
     HH(b, c, d, a, x[], S34, 0xbebfbc70); /* 40 */
     HH(a, b, c, d, x[], S31, 0x289b7ec6); /* 41 */
     HH(d, a, b, c, x[], S32, 0xeaa127fa); /* 42 */
     HH(c, d, a, b, x[], S33, 0xd4ef3085); /* 43 */
     HH(b, c, d, a, x[], S34, 0x4881d05); /* 44 */
     HH(a, b, c, d, x[], S31, 0xd9d4d039); /* 45 */
     HH(d, a, b, c, x[], S32, 0xe6db99e5); /* 46 */
     HH(c, d, a, b, x[], S33, 0x1fa27cf8); /* 47 */
     HH(b, c, d, a, x[], S34, 0xc4ac5665); /* 48 */

                                            /* Round 4 */
     II(a, b, c, d, x[], S41, 0xf4292244); /* 49 */
     II(d, a, b, c, x[], S42, 0x432aff97); /* 50 */
     II(c, d, a, b, x[], S43, 0xab9423a7); /* 51 */
     II(b, c, d, a, x[], S44, 0xfc93a039); /* 52 */
     II(a, b, c, d, x[], S41, 0x655b59c3); /* 53 */
     II(d, a, b, c, x[], S42, 0x8f0ccc92); /* 54 */
     II(c, d, a, b, x[], S43, 0xffeff47d); /* 55 */
     II(b, c, d, a, x[], S44, 0x85845dd1); /* 56 */
     II(a, b, c, d, x[], S41, 0x6fa87e4f); /* 57 */
     II(d, a, b, c, x[], S42, 0xfe2ce6e0); /* 58 */
     II(c, d, a, b, x[], S43, 0xa3014314); /* 59 */
     II(b, c, d, a, x[], S44, 0x4e0811a1); /* 60 */
     II(a, b, c, d, x[], S41, 0xf7537e82); /* 61 */
     II(d, a, b, c, x[], S42, 0xbd3af235); /* 62 */
     II(c, d, a, b, x[], S43, 0x2ad7d2bb); /* 63 */
     II(b, c, d, a, x[], S44, 0xeb86d391); /* 64 */

     _state[] += a;
     _state[] += b;
     _state[] += c;
     _state[] += d;
 }

 /* Encodes input (ulong) into output (byte). Assumes length is
 a multiple of 4.
 */
 void MD5::encode(const uint32 *input, byte *output, size_t length) {

     for (size_t i = , j = ; j<length; i++, j += ) {
         output[j] = (byte)(input[i] & 0xff);
         output[j + ] = (byte)((input[i] >> ) & 0xff);
         output[j + ] = (byte)((input[i] >> ) & 0xff);
         output[j + ] = (byte)((input[i] >> ) & 0xff);
     }
 }

 /* Decodes input (byte) into output (ulong). Assumes length is
 a multiple of 4.
 */
 void MD5::decode(const byte *input, uint32 *output, size_t length) {

     for (size_t i = , j = ; j<length; i++, j += ) {
         output[i] = ((uint32)input[j]) | (((uint32)input[j + ]) << ) |
             (((uint32)input[j + ]) << ) | (((uint32)input[j + ]) << );
     }
 }

 /* Convert byte array to hex string. */
 string MD5::bytesToHexString(const byte *input, size_t length) {
     string str;
     str.reserve(length << );
     for (size_t i = ; i < length; i++) {
         int t = input[i];
         int a = t / ;
         int b = t % ;
         str.append(, HEX[a]);
         str.append(, HEX[b]);
     }
     return str;
 }

 /* Convert digest to string value */
 string MD5::toString() {
     return bytesToHexString(digest(), );
 }

 //得到二进制文件的MD5码
 string FileDigest(const string &file) {
     ifstream in(file.c_str(), ios::binary);
     if (!in)
         return "";

     MD5 md5;
     md5.reset();
     std::streamsize length;
     char buffer[];
     while (!in.eof()) {
         in.read(buffer, );
         length = in.gcount();
         if (length > )
             md5.update(buffer, length);
     }
     in.close();
     return md5.toString();
 }

调用main.cpp

 // Md5Test.cpp : 定义控制台应用程序的入口点。
 //

 #include "stdafx.h"
 #include "MD5.h"
 #include <fstream>
 #include <process.h>
 int main()
 {
     std::ifstream of("ReadMe.txt", std::ios::in | std::ios::binary);
     if (!of.is_open())return ;
     MD5 fileMd5(of);
     printf("%s\r\n", fileMd5.toString().c_str());
     MD5 strMd5("");
     printf("%s\r\n", strMd5.toString().c_str());
     system("pause");
     return ;
 }