常用算法 之 MD5

什麼是 MD5

  全稱是 MD5 消息摘要算法（The MD5 Message-Digest Algorithm），對輸入任意長度的消息進行處理，最終產生一個128位的消息摘要（散列值（hash value））。不同的輸入得到的不同的結果（唯一性）。MD5 由美國密碼學家羅納德·李維斯特（Ronald Linn Rivest）設計，於1992年公開，用以取代MD4算法。這套算法的程序在 RFC 1321 中被加以規範（具體見附件）。

1. MD5 是 MD4 的升級版，MD4 是麻省理工學院教授 Ronald Rivest 於1990年設計的一種信息摘要算法，目前用的也不是很多。再之前還有個 MD2，好像是 1989年發佈的，目前基本已被淘汰。
2. 散列（Hash）： 把任意長度的輸入（又叫做預映射， pre-image），通過散列算法，變換成固定長度的輸出，該輸出就是散列值。
3. *雜湊衝撞/散列衝撞： 發現兩段原文對應同一個MD5，則稱爲一次雜湊散列碰撞。

與 MD4 區別

根據規範文檔，主要有以下幾點：

1. 增加了第四輪.
2. 每一步均有唯一的加法常數.
3. 爲減弱第二輪中函數G的對稱性從(X&Y)|(X&Z)|(Y&Z)變爲(X&Z)|(Y&(~Z))
4. 第一步加上了上一步的結果，這將引起更快的雪崩效應.
5. 改變了第二輪和第三輪中訪問消息子分組的次序，使其更不相似.
6. 近似優化了每一輪中的循環左移位移量以實現更快的雪崩效應，各輪的位移量互不相同.

安全性

  1996年後被證實存在弱點，可以被加以破解。2004年，證實MD5算法無法防止碰撞（collision）。2004年的國際密碼討論年會（CRYPTO）尾聲，王小云及其研究同事展示了MD5、SHA-0及其他相關散列函數的散列衝撞。

實現原理

  MD5 以 512 位分組來處理輸入的信息，且每一分組又被劃分爲16個32位子分組，經過了一系列的處理後，算法的輸出由四個32位分組組成，將這四個32位分組級聯後將生成一個128位散列值。根據算法文檔的描述，總共可以分爲五步：

• 第一步：附加填充位： 如果輸入信息的長度(bit)對512求餘的結果不等於448，就需要填充使得對512求餘的結果等於448。這裏主要是爲了保證計算的最後一定爲512bits。具體看參見後文源碼的函數：void MD5Final(MD5_CTX *context, unsigned char digest[16])
  填充方法：在消息後面進行填充，填充第一位爲1，其餘爲0。

• 第二步：附加長度： 用64位來存儲填充前信息長度。這64位加在第一步結果的後面。將總的比特位位數附加到最後一包的最後，進行轉換。

• 第三步：初始化 MD 緩衝區： 四個字（每個字32位）緩衝區（A，B，C，D）用於計算消息摘要。依次爲：A = 0x67452301，B = 0xEFCDAB89，C = 0x98BADCFE，D = 0x10325476

• 第四步：處理輸入的數據：

  1. 規範定義了四個輔助函數，每個函數將三個32位字作爲輸入，併產生一個32位字作爲輸出。（&是與,|是或,~是非,^是異或）

  	#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))
  

  2. 設Mj表示消息的第j個子分組（從0到15）

  	FF(a,b,c,d,Mj,s,ti) 表示 a=b+((a+F(b,c,d)+Mj+ti)<<<s)
  	GG(a,b,c,d,Mj,s,ti) 表示 a=b+((a+G(b,c,d)+Mj+ti)<<<s)
  	HH(a,b,c,d,Mj,s,ti) 表示 a=b+((a+H(b,c,d)+Mj+ti)<<<s)
  	II(a,b,c,d,Mj,s,ti) 表示 a=b+((a+I(b,c,d)+Mj+ti)<<<s)
  

  3. 四輪運算

• 第五步：輸出： 作爲輸出產生的消息摘要是A，B，C，D。也就是說，我們從A的低位字節開始，以D的高位字節結束。

源碼

  在RFC 1321文檔中，作者不進給出了算法的具體描述以及與 MD4 的區別，還給出了一套實現好的 C 代碼，下文說明就是基於該代碼的。代碼稍微簡化了一下，因此與原文中的代碼可能稍有不同。
  以下源碼有非常詳細的註釋，具體參看註釋即可，不在做過多說明。

• MD5.h

#ifndef MD5_H
#define MD5_H

/* MD5 context. */
typedef struct
{
	/* 存儲原始信息的bits數長度(不包括填充的bits)，最長爲 2^64 bits。如果消息長度大於2^64，則只使用其低64位的值，即（消息長度 對 2^64取模） */
	unsigned int count[2];
	/* 四個32bits數，用於存放最終計算得到的消息摘要。當消息長度大於 512bits時，也用於存放每個512bits的中間結果 */ 
	unsigned int state[4];
	/*存放輸入的信息的緩衝區，512bits */
	unsigned char buffer[64];
} MD5_CTX;

void MD5Init(MD5_CTX *context);
void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen);
void MD5Final(MD5_CTX *context, unsigned char digest[16]);
#endif

• MD5.c

#include <string.h>
#include "MD5.h"

/* MD5轉換用到的常量，是算法本身規定的 */
#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

/* MD5算法本身規定的基本函數 */
#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))

/* 實現將x循環左移n位
 */
#define ROTATE_LEFT(x, n) ((x << n) | (x >> (32 - n)))

/** MD5算法本身規定的 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;                      \
}

/** 
 * 用於bits填充的緩衝區，爲什麼要64個字節呢？因爲當欲加密的信息的bits數被512除其餘數爲448時， 
 * 需要填充的bits的最大值爲512=64*8 。 
**/
unsigned char PADDING[] = {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};

static void MD5Transform(unsigned int state[4], unsigned char block[64]);
static void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len);
static void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len);

/* MD5 initialization. Begins an MD5 operation, writing a new context. */  
/* 初始化md5的結構 */
void MD5Init(MD5_CTX *context)
{
	/* 將當前的有效信息的長度設成 0 */
	context->count[0] = 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. */
/* 將與加密的信息傳遞給md5結構，可以多次調用 
context：初始化過了的md5結構 
input：欲加密的信息，可以任意長 
inputLen：指定input的長度 
*/
void MD5Update(MD5_CTX *context, unsigned char *input, unsigned int inputlen)
{
	unsigned int i = 0, index = 0, partlen = 0;

	/* 計算已有信息的bits長度的字節數的模64（64bytes = 512bits）。 用於判斷已有信息加上當前傳過來的信息的總長度能不能達到 512bits， 如果能夠達到則對湊夠的512bits進行一次處理 */
	index = (context->count[0] >> 3) & 0x3F;	/* (context->count[0] >> 3) = context->count[0]/8 ,即：算字節數； 後面的 & 3F 就是 Mod 64 */
	partlen = 64 - index;						/* 計算已有的字節數長度還差多少字節可以湊成 64Bytes（512bits） */
	/* 保存輸入信息的比特位數 */
	context->count[0] += inputlen << 3;
	if (context->count[0] < (inputlen << 3))
	{
		context->count[1]++;
	}
	context->count[1] += inputlen >> 29;

	/* 如果當前輸入的字節數 大於 已有字節數長度補足64字節整倍數所差的字節數 */
	if (inputlen >= partlen)
	{
		/* 用當前輸入的內容把 context->buffer 的內容補足 512bits */
		memcpy(&context->buffer[index], input, partlen);
		/* 用基本函數對填充滿的512bits（已經保存到context->buffer中） 做一次轉換，轉換結果保存到context->state中 */
		MD5Transform(context->state, context->buffer);
		/* 對當前輸入的剩餘字節做轉換（如果剩餘的字節大於512bits的話 ）， 轉換結果保存到context->state中 */
		for (i = partlen; i + 64 <= inputlen; i += 64)
		{
			MD5Transform(context->state, &input[i]);
		}
		index = 0;
	}
	else
	{
		i = 0;
	}
	/*將輸入緩衝區中的不足填充滿512bits的剩餘內容填充到context->buffer中，留待以後再作處理*/
	memcpy(&context->buffer[index], &input[i], inputlen - i);
}

/* MD5 finalization. Ends an MD5 message-digest operation, writing the 
  the message digest and zeroizing the context. */  
/*獲取加密 的最終結果 
digest：保存最終的加密串 
context：你前面初始化並填入了信息的md5結構 
*/
void MD5Final(MD5_CTX *context, unsigned char digest[16])
{
	unsigned int index = 0, padlen = 0;
	unsigned char bits[8];

	/* 計算已有信息的bits長度的字節數的模64（64bytes = 512bits）。 */ 
	index = (context->count[0] >> 3) & 0x3F;
	/* 計算需要填充的字節數，padLen的取值範圍在1-64之間 */
	padlen = (index < 56) ? (56 - index) : (120 - index);

	/* 將要被轉換的信息(所有的)的bits長度拷貝到bits中 */
	MD5Encode(bits, context->count, 8);
	/*  */
	MD5Update(context, PADDING, padlen);

	/* 補上原始信息的bits長度（bits長度固定的用64bits表示），這一次能夠恰巧湊夠512bits，不會多也不會少 */
	MD5Update(context, bits, 8);

	/* 將最終的結果保存到digest中。ok，終於大功告成了 */
	MD5Encode(digest, context->state, 16);
}

/* Encodes input (UINT4) into output (unsigned char). Assumes len is 
  a multiple of 4. */  
/*將4字節的整數copy到字符形式的緩衝區中 
output：用於輸出的字符緩衝區 
input：欲轉換的四字節的整數形式的數組 
len：output緩衝區的長度，要求是4的整數倍 
*/  
static void MD5Encode(unsigned char *output, unsigned int *input, unsigned int len)
{
	unsigned int i = 0, j = 0;
	while (j < len)
	{
		output[j] = input[i] & 0xFF;
		output[j + 1] = (input[i] >> 8) & 0xFF;
		output[j + 2] = (input[i] >> 16) & 0xFF;
		output[j + 3] = (input[i] >> 24) & 0xFF;
		i++;
		j += 4;
	}
}

/* Decodes input (unsigned char) into output (UINT4). Assumes len is 
  a multiple of 4. */  
/*與上面的函數正好相反，這一個把字符形式的緩衝區中的數據copy到4字節的整數中（即以整數形式保存） 
output：保存轉換出的整數 
input：欲轉換的字符緩衝區 
len：輸入的字符緩衝區的長度，要求是4的整數倍 
*/ 
static void MD5Decode(unsigned int *output, unsigned char *input, unsigned int len)
{
	unsigned int i = 0, j = 0;
	while (j < len)
	{
		output[i] = (input[j]) |
					(input[j + 1] << 8) |
					(input[j + 2] << 16) |
					(input[j + 3] << 24);
		i++;
		j += 4;
	}
}

/* MD5 basic transformation. Transforms state based on block. */  
/* 
對512bits信息(即block緩衝區)進行一次處理，每次處理包括四輪 
state[4]：md5結構中的state[4]，用於保存對512bits信息加密的中間結果或者最終結果 
block[64]：欲加密的512bits信息 
*/
static void MD5Transform(unsigned int state[4], unsigned char block[64])
{
	unsigned int a = state[0];
	unsigned int b = state[1];
	unsigned int c = state[2];
	unsigned int d = state[3];
	unsigned int x[64];

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

附件

1. rfc1321