C ++ implements md5 encryption or unique identification of computing files, and md5 Encryption

C ++ implements md5 encryption or unique identification of computing files, and md5 Encryption

I uploaded many classes on the network to implement md5 encryption for C ++. As for the class which is original, I dare not speculate. I just declare that I have reprinted it and support originality.

For the md5 encryption algorithm, I provide two files:

# Ifndef MD5_H # define MD5_H # include <string> # include <fstream>/* Type define */typedef unsigned char byte; typedef unsigned int uint32; 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 (); string ToMD5 (const string & str); // in this case, you only need to call this function to complete the encryption process private: void update (const byte * input, size_t length); void final (); void transform (const byte block [64]); 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, si Ze_t length);/* class uncopyable */MD5 (const MD5 &); MD5 & operator = (const MD5 &); private: uint32 _ state [4]; /* state (ABCD) */uint32 _ count [2];/* number of bits, modulo 2 ^ 64 (low-order word first) */byte _ buffer [64];/* input buffer */byte _ digest [16];/* message digest */bool _ finished;/* calculate finished? */Static const byte PADDING [64];/* padding for calculate */static const char HEX [16]; enum {BUFFER_SIZE = 1024 };}; # endif/* MD5_H */

# Include "md5.h" # include "string. h "const string MD5_Key =" wow "; 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 S12 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; () = ROTATE_LEFT (a), (s); (a) + = (B);} const byte MD5: PADDING [64] = {0x80 }; const char MD5: HEX [16] = {'0', '1', '2', '3', '4', '5', '6 ', '7', '8', '9', '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 [0] = _ count [1] = 0;/* Load magic initialization constants. */_ state [0] = 0x67452301; _ state [1] = 0xefcdab89; _ state [2] = 0x98badcfe; _ state [3] = 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> 0) {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 [0]> 3) & 0x3f ); /* update number of bits */if (_ count [0] + = (uint32) length <3) <(uint32) length <3 )) {++ _ count [1];} _ count [1] + = (uint32) length> 29); partLen = 64-index; /* transform as same times as possible. */if (length> = partLen) {memcpy (& _ buffer [index], input, partLen); transform (_ buffer); for (I = partLen; I + 63 <length; I + = 64) {transform (& input [I ]);} Index = 0;} else {I = 0;}/* Buffer remaining input */memcpy (& _ buffer [index], & input [I], length-I);}/* MD5 finalization. ends an MD5 message-_ digest operation, writing the message _ digest and zeroizing the context. */void MD5: final () {byte bits [8]; uint32 oldState [4]; uint32 oldCount [2]; uint32 index, padLen; /* Save current state and count. */memcpy (oldState, _ state, 16); mem Cpy (oldCount, _ count, 8);/* Save number of bits */encode (_ count, bits, 8);/* Pad out to 56 mod 64. */index = (uint32) (_ count [0]> 3) & 0x3f); padLen = (index <56 )? (56-index): (120-index); update (PADDING, padLen);/* Append length (before padding) */update (bits, 8 ); /* Store state in digest */encode (_ state, _ digest, 16);/* Restore current state and count. */memcpy (_ state, oldState, 16); memcpy (_ count, oldCount, 8);}/* MD5 basic transformation. transforms _ state based on block. */void MD5: transform (const byte block [64]) {uint32 a = _ state [0], B = _ state [1], c = _ state [2], d = _ state [3], x [16]; decode (block, x, 64);/* Round 1 */FF (, 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,, 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,, 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,, 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 (, 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,, x [9], S44, 0xeb86d391);/* 64 */_ state [0] + = a; _ state [1] + = B; _ state [2] + = c; _ state [3] + = 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 = 0, j = 0; j <length; ++ I, j + = 4) {output [j] = (byte) (input [I] & 0xff); output [j + 1] = (byte) (input [I]> 8) & 0xff); output [j + 2] = (byte) (input [I]> 16) & 0xff ); output [j + 3] = (byte) (input [I]> 24) & 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 = 0, j = 0; j <length; ++ I, j + = 4) {output [I] = (uint32) input [j]) | (uint32) input [j + 1]) <8) | (uint32) input [j + 2]) <16) | (uint32) input [j + 3]) <24 );}} /* Convert byte array to hex string. */string MD5: bytesToHexString (const byte * input, size_t length) {string str; str. reserve (length <1); for (size_t I = 0; I <length; ++ I) {int t = input [I]; int a = t/16; int B = t % 16; str. append (1, HEX [a]); str. append (1, HEX [B]);} return str;}/* Convert digest to string value */string MD5: toString () {return bytesToHexString (digest (), 16);} string MD5: ToMD5 (const string & str) // MD5 encryption, where key = xyf, key must be added before encryption {const string str_word = str + MD5_Key; reset (); update (str_word); return toString ();}

So how to call it?

MD5 md5; // defines the MD5 class md5.update ("xxxxxx"); // because the update function only receives the string type, it uses getbuffer () function Conversion CString is stringchar * p = md5.toString (). c_str ();

However, you must call the md5.reset () method to reset the md5 value of another string.