MD5算法原理介绍与C++实现

最新推荐文章于 2024-07-26 13:15:00 发布

Dic0k

最新推荐文章于 2024-07-26 13:15:00 发布

阅读量4.6k

点赞数 6

分类专栏： Web-Security 文章标签： MD5 Web-Security 加密

本文链接：https://blog.csdn.net/dickdick111/article/details/84928228

版权

Web-Security 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

MD5算法原理介绍与C++实现

源代码传送门：https://github.com/dick20/Web-Security/tree/master/MD5

一. 算法原理概述

The MD5 message-digest algorithm is a widely used hash function producing a 128-bit hash value. Although MD5 was initially designed to be used as a cryptographic hash function, it has been found to suffer from extensive vulnerabilities. ——Wikipedia

MD5 使用 little-endian (小端模式)，输入任意不定长度信息，以512-bit 进行分组，生成四个32-bit 数据，最后联合输出固定128-bit 的信息摘要。
MD5 算法的基本过程为：填充、分块、缓冲区初始化、循环压缩、得出结果。

MD5的基本流程图如下

二. 总体结构

1.填充

在长度为 K bits 的原始消息数据尾部填充长度为 P bits 的标识100…0，1 $\leq$ P $\leq$ 512 (即至少要填充1个bit)，使得填充后的消息位数为：K + P $\equiv$ 448 (mod 512).

注意到当 K $\equiv$ 448 (mod 512) 时，需要 P= 512.

再向上述填充好的消息尾部附加 K 值的低64位 (即 K mod 264)，最后得到一个长度位数为 K + P + 6 $\equiv$ 0 (mod 512) 的消息。

2.分块

把填充后的消息结果分割为 L 个 512-bit 分组： $Y_0$ , $Y_1$ , …, $Y_{L-1}$ 。
分组结果也可表示成 N 个32-bit 字 $M_0$ , $M_1$ , …, $M_{N-1}$ ，N = L*16。

3.缓冲区初始化

初始化一个128-bit 的 MD 缓冲区，记为 $CV_q$ ，表示成4个32-bit寄存器 (A, B, C, D)； $CV_0$ = IV。迭代在 MD 缓冲区进行，最后一步的128-bit 输出即为算法结果。

寄存器 (A, B, C, D) 置16进制初值作为初始向量 IV，并采用小端存储 (little-endian) 的存储结构：
- A = 0x67452301
- B = 0xEFCDAB89
- C = 0x98BADCFE
- D = 0x10325476

4.循环压缩

以512-bit 消息分组为单位，每一分组 Yq (q = 0, 1, …, L-1) 经过4个循环的压缩算法，表示为：

$CV_0$ = IV
$CV_i$ = $H_{MD5}$ ( $CV_{i-1}$ , ${Y_i}$ )
输出结果：MD = $CV_L$ .

三. 模块分解

a. MD5 压缩函数 HMD5——轮函数

HMD5 从 CV 输入128位，从消息分组输入512位，完成4轮循环后，输出128位，用于下一轮输入的 CV 值。

每轮循环分别固定不同的生成函数 F, G, H, I，结合指定的 T 表元素 T[] 和消息分组的不同部分 X[] 做16次迭代运算，生成下一轮循环的输入。

4轮循环总共有64次迭代运算。

4轮循环中使用的生成函数(轮函数) g 是一个32位非线性逻辑函数，在相应各轮
的定义如下：

轮次	Function g	g(b,c,d)
1	F(b, c, d)	(b $\bigwedge$ c) $\bigvee$ (~b $\bigwedge$ d)
2	G(b, c, d)	( $\bigwedge d$ ) $\bigvee$ ( $\bigwedge$ ~d)
3	H(b, c, d)	b $\bigoplus$ c $\bigoplus$ d
4	I(b, c, d)	c $\bigoplus$ (b $\bigvee$ ~d)

b. MD5 压缩函数 HMD5——迭代运算

每轮循环中的一次迭代运算逻辑
(1) 对 A 迭代：a $\leftarrow$ b + ((a + g(b, c, d) + X[k] + T[i]) <<<s)
(2) 缓冲区 (A, B, C, D) 作循环轮换：(B, C, D, A) $\leftarrow$ (A, B, C, D)
说明：
- a, b, c, d : MD 缓冲区 (A, B, C, D) 的当前值。
- g : 轮函数 (F, G, H, I 中的一个)。
- <<<s : 将32位输入循环左移 (CLS) s 位。
- X[k] : 当前处理消息分组的第 k 个 (k = 0…15) 32位字，即
  $M_{q*16+k}$ 。
- T[i] : T 表的第 i 个元素，32位字；T 表总共有64个元素，也
  称为加法常数。
- +: 模 232 加法

c. MD5 压缩函数 HMD5——各轮循环的 X[k]

各轮循环中第 i 次迭代 (i = 1…16) 使用的 X[k] 的确定：
设 j = i -1：

第1轮迭代：k = j.
- 顺序使用 X[0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15]
第2轮迭代：k = (1 + 5j) mod 16
- 顺序使用 X[1, 6,11, 0, 5,10,15, 4, 9,14, 3, 8,13, 2, 7,12]
第3轮迭代：k = (5 + 3j) mod 16.
- 顺序使用 X[5, 8,11,14, 1, 4, 7,10,13, 0, 3, 6, 9,12,15, 2]
第4轮迭代：k = 7j mod 16.
- 顺序使用 X[0, 7,14, 5,12, 3,10, 1, 8,15, 6,13 , 4,11, 2, 9]

d. MD5 压缩函数 HMD5——T表的生成

T[i] = int($ 2^{32} *|sin(i)|$)

int 取整函数，sin 正弦函数，以 i 作为弧度输入

各次迭代运算采用的 T 值：

T[ 1… 4] = { 0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee }
T[ 5… 8] = { 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501 }
T[ 9…12] = { 0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be }
T[13…16] = { 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821 }
T[17…20] = { 0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa }
T[21…24] = { 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8 }
T[25…28] = { 0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed }
T[29…32] = { 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a }
T[33…36] = { 0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c }
T[37…40] = { 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70 }
T[41…44] = { 0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05 }
T[45…48] = { 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665 }
T[49…52] = { 0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039 }
T[53…56] = { 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1 }
T[57…60] = { 0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1 }
T[61…64] = { 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391

e. MD5 压缩函数 HMD5——左循环移位的 s 值

各次迭代运算采用的左循环移位的 s 值：

s[ 1…16] = { 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22 }
s[17…32] = { 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20 }
s[33…48] = { 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23 }
s[49…64] = { 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21 }

四. 数据结构

我的MD5算法使用了C++类的设计来实现，主要使用数组来表示循环移位表，unsigned int与unsigned char来表示不同的位数，char为8位，int为32位，在不同的表示函数中各有作用，故需要对其进行转换。

	unsigned int state[4];		// 四个寄存器，MD缓冲区，共128位
	unsigned int count[2];		// 统计长度，仅保留前64位
	unsigned char buffer[512];	// 输入
	unsigned char digest[128];	// 输出

表示state状态时，我使用的是16进制表达64位，这样较简便

	// 初始化获取IV
	state[0] = 0x67452301;
	state[1] = 0xefcdab89;
	state[2] = 0x98badcfe;
	state[3] = 0x10325476;

关于S表，则直接用二维数组

// 左循环移位表
int s[4][4] = {{7,12,17,22},{5,9,14,20},{4,11,16,23},{6,10,15,21}};

对于填充的内容，是1000···000，最多512位，最少要有一位，这是根据填充长度来决定的，使用我直接要预设填充长度为512位。

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

表示轮函数，则直接根据T表来进行书写。例如下面

	H_F(a, b, c, d, x[0], s[0][0], 0xd76aa478);
	H_F(d, a, b, c, x[1], s[0][1], 0xe8c7b756);
	H_F(c, d, a, b, x[2], s[0][2], 0x242070db);
	···

关于int与char的转换，是这次算法实现比较关键的部分，因为关于使用byte还是bit取决于函数的需要。以下第一个函数是int转为char，将1个int转为4个char，这里使用位运算+移位的方法，不断取8位转化为char。第二个函数是char转int，也像之前类似，不过是要将4个char转为1个int，这里用到的是移位+或运算，这样就可以得到1个32位int类型。

void my_md5::int_to_char(unsigned char *output,  const unsigned int  *input, int length){
	for (int i = 0, j = 0; i < length; ++i)
	{
		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;
		j += 4;
	}
}

void my_md5::char_to_int(unsigned int  *output, const unsigned char *input, int length){
	for (int i = 0, j = 0; i < length; i += 4)
	{
		output[j] = input[i] | (input[i+1] << 8) | (input[i+2] << 16) | (input[i+3] << 24);
		j++;
	}
}

五. 源代码

1.MD5类设计

class my_md5
{
public:
	my_md5(string& str);
	my_md5(); 
	void update(const unsigned char* input_str, int str_length);
	// 将128位结果，转化为16个byte输出
	void show_result();
    // 对输入的字符串进行MD5加密
	void decode_string(string& str);
	~my_md5();
	
private:
	unsigned int state[4];		// 四个寄存器，MD缓冲区，共128位
	unsigned int count[2];		// 统计长度，仅保留前64位
	unsigned char buffer[512];	// 输入
	unsigned char digest[128];	// 输出
	bool is_padding;
	char result[33];			// 32位的输出结果

	// 私有辅助函数，用以变换
	// 对于其中一个区块做变换
	void transform(unsigned char block[64]);
	// 填充函数，添加长度
	void padding();
	// 以下两个函数用以将32位的unsigned int与8位的unsigned char互相转换输出
	void int_to_char(unsigned char *output,  const unsigned int  *input, int length);
	void char_to_int(unsigned int  *output, const unsigned char *input, int length);
	// 左移函数
	unsigned int shift_left(unsigned int num, int pos);
	// 轮函数
	unsigned int F(unsigned int b, unsigned int c, unsigned int d);
	unsigned int G(unsigned int b, unsigned int c, unsigned int d);
	unsigned int H(unsigned int b, unsigned int c, unsigned int d);
	unsigned int I(unsigned int b, unsigned int c, unsigned int d);
	// 压缩函数
	void H_F(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int x, unsigned int s, unsigned int Ti);
	void H_G(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int x, unsigned int s, unsigned int Ti);
	void H_H(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int x, unsigned int s, unsigned int Ti);
	void H_I(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int x, unsigned int s, unsigned int Ti);
};

该类的公有函数包括两个构造函数，带参的构造函数是直接加密一个字符串，而缺省构造函数仅构造对象，需要调用decode_string(string& str);来进行多次加密。

show_result()函数是将128位digest结果转化为32位16进制来进行输出显示。

update()就是更新函数，会在里面调用私有函数transform来进行轮函数变换。

私有函数包括transform，里面包含64次迭代运算，分别利用下面的轮函数F, G, H, I与压缩函数H_F, H_G, H_H, H_I .

左移函数shift_left，根据位数来进行循环左移

F, G, H, I都是轮函数，根据MD5算法提供的函数表来进行构造。压缩函数亦然。

2.Transform函数变换

由于Transform函数是需要进行对于一个block来进行处理，压缩变换，64次迭代运算。里面所用到的压缩函数，MD缓冲区，轮函数，左移运算，T表。

以下是一次迭代运算的示意图：

unsigned int my_md5::shift_left(unsigned int num, int pos){
	return (num << pos) | (num >> (32 - pos));
}

unsigned int my_md5::F(unsigned int b, unsigned int c, unsigned int d){
	return (b & c) | ((~b) & d);
}  

unsigned int my_md5::G(unsigned int b, unsigned int c, unsigned int d){
	return (b & d) | (c & (~d)); 
}

unsigned int my_md5::H(unsigned int b, unsigned int c, unsigned int d){
	return (b ^ c ^ d);
}

unsigned int my_md5::I(unsigned int b, unsigned int c, unsigned int d){
	return (c ^ (b | ~d));
}

void my_md5::H_F(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int x, unsigned int s, unsigned int Ti){
	a = shift_left(a + F(b, c, d) + x + Ti, s) + b;
}

void my_md5::H_G(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int x, unsigned int s, unsigned int Ti){
	a = shift_left(a + G(b, c, d) + x + Ti, s) + b;
}

void my_md5::H_H(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int x, unsigned int s, unsigned int Ti){
	a = shift_left(a + H(b, c, d) + x + Ti, s) + b;
}

void my_md5::H_I(unsigned int &a, unsigned int b, unsigned int c, unsigned int d, unsigned int x, unsigned int s, unsigned int Ti){
	a = shift_left(a + I(b, c, d) + x + Ti, s) + b;
}

Transform函数要经过64次迭代运算，然后将计算好的state保存，下面由于篇幅就不一一展示，只写出一次迭代的。

void my_md5::transform(unsigned char block[64]){
	// 获取IV的state数据
	unsigned int a = state[0], b = state[1], c = state[2], d = state[3];
	unsigned int x[16];
	// 将8位char转为32位int，当前处理消息分组的第 k 个 (k = 0..15) 32位字
	char_to_int(x, block, 64);
 	
	H_F(a, b, c, d, x[0], s[0][0], 0xd76aa478);
    ···
    H_G(a, b, c, d, x[1], s[1][0], 0xf61e2562);
    ···
    H_H(a, b, c, d, x[5], s[2][0], 0xfffa3942);
    ···
    H_I(a, b, c, d, x[0], s[3][0], 0xf4292244);
    ···
    state[0] += a;
	state[1] += b;
	state[2] += c;
	state[3] += d;
}

3.输入字符串与输出加密后结果

输入函数必须还要进行初始化，因为上次的加密结果仍保存在state，不进行初始化会导致加密失败。

初始化是赋值给state初始向量IV，并采用小端存储的存储结构。将count记录长度，以及digest记录结果的数组赋值回0.

然后就可以执行update与padding操作了，执行完上面两个函数，结果存放在4个state中，故需要将4个state的结果连接起来放在digest中，便于后面转化回16进制输出。

void my_md5::decode_string(string& str){
	// 每次执行前，都要初始化一次 
	state[0] = 0x67452301;
	state[1] = 0xefcdab89;
	state[2] = 0x98badcfe;
	state[3] = 0x10325476;
	is_padding = false;
	memset(count, 0, sizeof(count));
	memset(digest, '\0', sizeof(digest));
	update((unsigned char*)(str.c_str()),str.size());
	padding();
	// 将4个state的结果连接起来放在digest中 
	int_to_char(digest, state, 16);
}

输出函数只是简单的将128位2进制转化为32位16进制，并输出结果。

void my_md5::show_result(){
	// 转化为16进制
	result[32] = '\0';
	for(int i=0; i<16; ++i){
		sprintf(result+i*2, "%02x", digest[i]);
	}
	cout << "解密结果：" << endl;
	cout << result << endl;
}

4.update函数与padding函数填充

update函数的处理是判断输入字符串的长度，并记录其长度到count数组中，接着进行分组进行transform函数，这里每一个分组要512bits。

	int index = (count[0] >> 3) & 0x3f;
	// 使用count时，将2个32位转成64bit来处理
	count[0] += str_length << 3;
	if(count[0] < (str_length << 3)){
		count[1]++;
	}
	// 需要填补的长度
	int padding_length = 64 - index;
	if (str_length >= padding_length)
	{
		// 将数据放入buffer中进行处理
		memcpy(buffer+index, input_str, padding_length);
		transform(buffer);
		// 分组处理 
		for (int i = padding_length; i+64 < str_length; i+=64)
		{
			transform((unsigned char*)input_str+i);
		}
		index = 0;
	}
	memcpy(buffer+index,input_str,str_length);
}

padding函数则是需要填充1000···000，以及补充64位的count。在填充完毕后，再进行update操作，这样就可以实现对字符串的填充处理。

nsigned 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};
	if(!is_padding){
		unsigned char bits[8];
		// 将2个int转为64位bit 
		int_to_char(bits, count, 8);
		int index = (count[0] >> 3) & 0x3f;
		// 预留8位是给length，所以计算填充要减去8 
		int padding_length = index < 56 ? (56 - index) : (120 - index);
 		// 填补1000....0，即padding数组，长度为pad_len 
		update(padding, padding_length);
		// 对于长度8位进行处理 
		update(bits, 8);
		is_padding = true;
	}
}

5. Main函数

main函数主要是实现简单的命令行交互，构建MD5对象来执行期中的函数。这里唯一需要注意的只是使用getline函数来处理带空格的字符串。

#include "my_md5.h"
#include "my_md5.cpp"
 
int main()
{
	string str;
	cout << "MD5加密程序已启动"  << endl;
	my_md5 m;
	while(true){
		cout << "---------------------------------------" << endl;
		cout << "请输入需要加密的字符串，exit表示退出程序" << endl;
		getline(cin,str);
		if(str == "exit") break;
		m.decode_string(str);
		m.show_result();
	}
	return 0;
}

六. 编译运行结果

测试一

根据Wiki中提供的第一个例子来进行测试

"The quick brown fox jumps over the lazy dog"

解密结果一致

测试二

根据Wiki中提供的第二个例子来进行测试，这次只多加了一个句号，但是加密结果与测试一完全不一样。

"The quick brown fox jumps over the lazy dog."

解密结果一致

测试三

我自己在网上MD5在线加密进行测试

"Hello,MD5"

解密结果一致

所以，根据上述的测试可以得出结论算法实现正确，程序执行无误。

Dic0k

关注

6
点赞
踩
20

收藏

觉得还不错? 一键收藏
3
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录