/*-======================- Copyright (c) 2007 -======================-
程序作者:

    Hacker Ans : 駭客任務(wù)組Ans軟件工作室
聯(lián)系方式:

    QQ:360038060
	[oopfans]群:13161288


修改時(shí)間:

    2007-03-09

功能描述:

    將原信息加密成MD5摘要,這個(gè)類的頭文件下面附上了ronald l. rivest在
	1992年8月向ieft提交的rfc1321.txt,這是一份最權(quán)威的文檔.

使用說(shuō)明:

	這個(gè)類是一個(gè)虛基類,要使用這個(gè)類必須繼承自這個(gè)類,并實(shí)現(xiàn)這個(gè)類里的
	virtual void OnProcessing(int PrcessNum)=0;純虛函數(shù),這個(gè)純虛函數(shù)
	用于在對(duì)一個(gè)較大文件進(jìn)行MD5計(jì)算時(shí),將處理進(jìn)度返回給用戶

版權(quán)聲明:

    許可任何單位,個(gè)人隨意使用,拷貝,修改,散布及出售這份代碼,但是必須保
    留此版權(quán)信息,以慰藉作者辛勤的勞動(dòng),及表明此代碼的來(lái)源,如若此份代碼
    有任何BUG,請(qǐng)通知作者,以便彌補(bǔ)作者由于水平所限而導(dǎo)致的一些錯(cuò)誤和不
    足,謝謝!

-======================- Copyright (c) 2006 -======================-*/

#ifndef _ZMD5
#define _ZMD5

#define for if(0); else for

//讀取文件的緩沖區(qū),這個(gè)值必須是64的整數(shù)倍
#define FILE_BUFFER_READ 1048576 

#pragma warning(disable:4786)
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

class ZMD5  
{
public:

	ZMD5();
	virtual ~ZMD5();

private:

	//四個(gè)寄存器具變量
	unsigned int A,B,C,D;

	//常量

	int S11, S21, S31, S41;
	int S12, S22, S32, S42;
	int S13, S23, S33, S43;
	int S14, S24, S34, S44;

	//對(duì)原始信息需要追加的字節(jié)數(shù)
	int m_AppendByte;

	//原始信息長(zhǎng)度,用一個(gè)64位整數(shù)記錄
	unsigned char m_MsgLen[8];

private:

	//位移函數(shù)

	unsigned int ROTATE_LEFT(unsigned int x,unsigned int n);
	unsigned int F(unsigned int x,unsigned int y,unsigned int z);
	unsigned int G(unsigned int x,unsigned int y,unsigned int z);
	unsigned int H(unsigned int x,unsigned int y,unsigned int z);
	unsigned int I(unsigned int x,unsigned int y,unsigned int z);

	//四輪變換函數(shù)

	void FF(unsigned int& a,unsigned int b,unsigned int c,unsigned int d,unsigned int x,int s,unsigned int ac);
	void GG(unsigned int& a,unsigned int b,unsigned int c,unsigned int d,unsigned int x,int s,unsigned int ac);
	void HH(unsigned int& a,unsigned int b,unsigned int c,unsigned int d,unsigned int x,int s,unsigned int ac);
	void II(unsigned int& a,unsigned int b,unsigned int c,unsigned int d,unsigned int x,int s,unsigned int ac);

	//初始化MD5所需參數(shù)
	void Init();

	//計(jì)算追加字節(jié)數(shù)及記錄原始信息長(zhǎng)度
	void Append(unsigned int MsgLen);

	//將原始信息以64字節(jié)進(jìn)行分組,進(jìn)行錯(cuò)位打亂
	void Transform(unsigned char Block[64]);

	//將寄存器A,B,C,D中最后保存的值轉(zhuǎn)換為十六進(jìn)制并返回給用戶
	string ToHex(bool UpperCase);

public:

	//計(jì)算字符串的MD5
	string GetMD5OfString(string InputMessage,bool UpperCase);

	//計(jì)算文件的MD5
	string GetMD5OfFile(const string FileName,bool UpperCase);

private:

	//文件的計(jì)算狀態(tài),GetMD5OfFile函數(shù)根據(jù)此值決定是否繼續(xù)計(jì)算
	bool m_bTerminate; 

public:

	//允許用戶從函數(shù)外部提前結(jié)束對(duì)GetMD5OfFile的調(diào)用
	void GetMD5OfFile_Stop();

protected:

	//純虛函數(shù),在計(jì)算文件MD5的過(guò)程中,通過(guò)Progress將處理進(jìn)度傳遞到子類中
	virtual void OnFileProcessing(int Progress)=0;

};

#endif

//	rfc1321.txt full content
//
//	Network Working Group                                          R. Rivest
//	Request for Comments: 1321           MIT Laboratory for Computer Science
//												 and RSA Data Security, Inc.
//																  April 1992
//
//
//						 The MD5 Message-Digest Algorithm
//
//	Status of this Memo
//
//	   This memo provides information for the Internet community.  It does
//	   not specify an Internet standard.  Distribution of this memo is
//	   unlimited.
//
//	Acknowlegements
//
//	   We would like to thank Don Coppersmith, Burt Kaliski, Ralph Merkle,
//	   David Chaum, and Noam Nisan for numerous helpful comments and
//	   suggestions.
//
//	Table of Contents
//
//	   1. Executive Summary                                                1
//	   2. Terminology and Notation                                         2
//	   3. MD5 Algorithm Description                                        3
//	   4. Summary                                                          6
//	   5. Differences Between MD4 and MD5                                  6
//	   References                                                          7
//	   APPENDIX A - Reference Implementation                               7
//	   Security Considerations                                            21
//	   Author's Address                                                   21
//
//	1. Executive Summary
//
//	   This document describes the MD5 message-digest algorithm. The
//	   algorithm takes as input a message of arbitrary length and produces
//	   as output a 128-bit "fingerprint" or "message digest" of the input.
//	   It is conjectured that it is computationally infeasible to produce
//	   two messages having the same message digest, or to produce any
//	   message having a given prespecified target message digest. The MD5
//	   algorithm is intended for digital signature applications, where a
//	   large file must be "compressed" in a secure manner before being
//	   encrypted with a private (secret) key under a public-key cryptosystem
//	   such as RSA.
//
//	Rivest                                                          [Page 1]
//	
//	RFC 1321              MD5 Message-Digest Algorithm            April 1992
//
//
//	   The MD5 algorithm is designed to be quite fast on 32-bit machines. In
//	   addition, the MD5 algorithm does not require any large substitution
//	   tables; the algorithm can be coded quite compactly.
//
//	   The MD5 algorithm is an extension of the MD4 message-digest algorithm
//	   1,2]. MD5 is slightly slower than MD4, but is more "conservative" in
//	   design. MD5 was designed because it was felt that MD4 was perhaps
//	   being adopted for use more quickly than justified by the existing
//	   critical review; because MD4 was designed to be exceptionally fast,
//	   it is "at the edge" in terms of risking successful cryptanalytic
//	   attack. MD5 backs off a bit, giving up a little in speed for a much
//	   greater likelihood of ultimate security. It incorporates some
//	   suggestions made by various reviewers, and contains additional
//	   optimizations. The MD5 algorithm is being placed in the public domain
//	   for review and possible adoption as a standard.
//
//	   For OSI-based applications, MD5's object identifier is
//
//	   md5 OBJECT IDENTIFIER ::=
//		 iso(1) member-body(2) US(840) rsadsi(113549) digestAlgorithm(2) 5}
//
//	   In the X.509 type AlgorithmIdentifier [3], the parameters for MD5
//	   should have type NULL.
//
//	2. Terminology and Notation
//
//	   In this document a "word" is a 32-bit quantity and a "byte" is an
//	   eight-bit quantity. A sequence of bits can be interpreted in a
//	   natural manner as a sequence of bytes, where each consecutive group
//	   of eight bits is interpreted as a byte with the high-order (most
//	   significant) bit of each byte listed first. Similarly, a sequence of
//	   bytes can be interpreted as a sequence of 32-bit words, where each
//	   consecutive group of four bytes is interpreted as a word with the
//	   low-order (least significant) byte given first.
//
//	   Let x_i denote "x sub i". If the subscript is an expression, we
//	   surround it in braces, as in x_{i+1}. Similarly, we use ^ for
//	   superscripts (exponentiation), so that x^i denotes x to the i-th
//	   power.
//
//	   Let the symbol "+" denote addition of words (i.e., modulo-2^32
//	   addition). Let X <<< s denote the 32-bit value obtained by circularly
//	   shifting (rotating) X left by s bit positions. Let not(X) denote the
//	   bit-wise complement of X, and let X v Y denote the bit-wise OR of X
//	   and Y. Let X xor Y denote the bit-wise XOR of X and Y, and let XY
//	   denote the bit-wise AND of X and Y.
//
//	Rivest                                                          [Page 2]
//	
//	RFC 1321              MD5 Message-Digest Algorithm            April 1992
//
//
//	3. MD5 Algorithm Description
//
//	   We begin by supposing that we have a b-bit message as input, and that
//	   we wish to find its message digest. Here b is an arbitrary
//	   nonnegative integer; b may be zero, it need not be a multiple of
//	   eight, and it may be arbitrarily large. We imagine the bits of the
//	   message written down as follows:
//
//			  m_0 m_1 ... m_{b-1}
//
//	   The following five steps are performed to compute the message digest
//	   of the message.
//
//	3.1 Step 1. Append Padding Bits
//
//	   The message is "padded" (extended) so that its length (in bits) is
//	   congruent to 448, modulo 512. That is, the message is extended so
//	   that it is just 64 bits shy of being a multiple of 512 bits long.
//	   Padding is always performed, even if the length of the message is
//	   already congruent to 448, modulo 512.
//
//	   Padding is performed as follows: a single "1" bit is appended to the
//	   message, and then "0" bits are appended so that the length in bits of
//	   the padded message becomes congruent to 448, modulo 512. In all, at
//	   least one bit and at most 512 bits are appended.
//
//	3.2 Step 2. Append Length
//
//	   A 64-bit representation of b (the length of the message before the
//	   padding bits were added) is appended to the result of the previous
//	   step. In the unlikely event that b is greater than 2^64, then only
//	   the low-order 64 bits of b are used. (These bits are appended as two
//	   32-bit words and appended low-order word first in accordance with the
//	   previous conventions.)
//
//	   At this point the resulting message (after padding with bits and with
//	   b) has a length that is an exact multiple of 512 bits. Equivalently,
//	   this message has a length that is an exact multiple of 16 (32-bit)
//	   words. Let M[0 ... N-1] denote the words of the resulting message,
//	   where N is a multiple of 16.
//
//	3.3 Step 3. Initialize MD Buffer
//
//	   A four-word buffer (A,B,C,D) is used to compute the message digest.
//	   Here each of A, B, C, D is a 32-bit register. These registers are
//	   initialized to the following values in hexadecimal, low-order bytes
//	   first):
//
//	Rivest                                                          [Page 3]
//	
//	RFC 1321              MD5 Message-Digest Algorithm            April 1992
//
//
//			  word A: 01 23 45 67
//			  word B: 89 ab cd ef
//			  word C: fe dc ba 98
//			  word D: 76 54 32 10
//
//	3.4 Step 4. Process Message in 16-Word Blocks
//
//	   We first define four auxiliary functions that each take as input
//	   three 32-bit words and produce as output one 32-bit word.
//
//			  F(X,Y,Z) = XY v not(X) Z
//			  G(X,Y,Z) = XZ v Y not(Z)
//			  H(X,Y,Z) = X xor Y xor Z
//			  I(X,Y,Z) = Y xor (X v not(Z))
//
//	   In each bit position F acts as a conditional: if X then Y else Z.
//	   The function F could have been defined using + instead of v since XY
//	   and not(X)Z will never have 1's in the same bit position.) It is
//	   interesting to note that if the bits of X, Y, and Z are independent
//	   and unbiased, the each bit of F(X,Y,Z) will be independent and
//	   unbiased.
//
//	   The functions G, H, and I are similar to the function F, in that they
//	   act in "bitwise parallel" to produce their output from the bits of X,
//	   Y, and Z, in such a manner that if the corresponding bits of X, Y,
//	   and Z are independent and unbiased, then each bit of G(X,Y,Z),
//	   H(X,Y,Z), and I(X,Y,Z) will be independent and unbiased. Note that
//	   the function H is the bit-wise "xor" or "parity" function of its
//	   inputs.
//
//	   This step uses a 64-element table T[1 ... 64] constructed from the
//	   sine function. Let T[i] denote the i-th element of the table, which
//	   is equal to the integer part of 4294967296 times abs(sin(i)), where i
//	   is in radians. The elements of the table are given in the appendix.
//
//	   Do the following:
//
//	   /* Process each 16-word block. */
//	   For i = 0 to N/16-1 do
//
//		 /* Copy block i into X. */
//		 For j = 0 to 15 do
//		   Set X[j] to M[i*16+j].
//		 end /* of loop on j */
//
//		 /* Save A as AA, B as BB, C as CC, and D as DD. */
//		 AA = A
//		 BB = B
//
//	Rivest                                                          [Page 4]
//	
//	RFC 1321              MD5 Message-Digest Algorithm            April 1992
//
//
//		 CC = C
//		 DD = D
//
//		 /* Round 1. */