MD5算法详解

已于 2024-08-22 00:03:26 修改
阅读量5.6w 收藏 248
点赞数 55
分类专栏： 密码学 文章标签： MD5
于 2018-07-16 17:30:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/goodnameused/article/details/81068697
版权

0x00 前言

MD5是一种哈希算法，用来保证信息的完整性。
就一段信息对应一个哈希值，且不能通过哈希值推出这段信息，而且还需要保证不存在任意两段不相同的信息对应同一个哈希值。不过MD5算法算出来的值也就16个字节（16*8=128，即128位），肯定存在相同的，找到另一个所花时间长短而已。

参考资料:
1、 The MD5 Message-Digest Algorithm
2、The MD5 Message-Digest Algorithm 中文版

0x01 填充信息

在计算机中，数据存储都是二进制存储的，所以任意一个文件都是些二进制。
每个文件（消息）的大小（长短）都不一样，所以在计算MD5值之前，要将这些文件（消息）用特定内容填充到指定的情况为止。（这里的大小长度是指字节数），本文约定用s_m表示原本的文件（消息）的大小（长度），s_mb表示单位位bit（位），s_mB表示单位为Byte（字节）。

填充的过程如下：
1.先判断消息的长度 s_mb % 512 == 448 ，就是长度对512求余等于448。（这里的512、448是“位”为单位，转成“字节”就是64、56，即s_mB % 64 == 56 填充动作一定要进行，不管消息长度是否符合要求。）

2.如果长度满足 s_mb % 512 == 448，就在文件（消息）的末尾处添加64位（8字节）的值，值的内容是原消息的长度（以位为单位）

3.如果长度不满足要求，就执行以下操作：
（1）填充1个1
（2）填充0，直到满足满足过程的第一步。
注意：这里是以位为单位，假如是以字节为单位，第一个填充的是0x80（1000 0000），然后就填0x0，填充到56个字节
（3）最后填充8个字节，使得整个消息的长度满足64的倍数即m_sB == k * 64 (m_sb == k * 512)。
举例：消息内容为“gnubd”，就能得到以下内容

67 6E 75 62 64 80 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
00 00 00 00 00 00 00 00 28 00 00 00 00 00 00 00

注意到最后面这里有个0x28，数8个字节，就是0x0000000000000028，刚刚好是十进制的40，消息的内容是5个字节，也就是40位，还要注意到这里是小端字节序存储

0x02 数据说明

填充信息满足要求后就要开始计算MD5值了，首先先把需要的东西先列出来：

DWORD md5::A = 0x67452301;
DWORD md5::B = 0xEFCDAB89;
DWORD md5::C = 0x98BADCFE;
DWORD md5::D = 0x10325476;

DWORD md5::T[64] = {
	0xD76AA478,0xE8C7B756,0x242070DB,0xC1BDCEEE,0xF57C0FAF,0x4787C62A,0xA8304613,0xFD469501,
	0x698098D8,0x8B44F7AF,0xFFFF5BB1,0x895CD7BE,0x6B901122,0xFD987193,0xA679438E,0x49B40821,
	0xF61E2562,0xC040B340,0x265E5A51,0xE9B6C7AA,0xD62F105D,0x02441453,0xD8A1E681,0xE7D3FBC8,
	0x21E1CDE6,0xC33707D6,0xF4D50D87,0x455A14ED,0xA9E3E905,0xFCEFA3F8,0x676F02D9,0x8D2A4C8A,
	0xFFFA3942,0x8771F681,0x6D9D6122,0xFDE5380C,0xA4BEEA44,0x4BDECFA9,0xF6BB4B60,0xBEBFBC70,
	0x289B7EC6,0xEAA127FA,0xD4EF3085,0x04881D05,0xD9D4D039,0xE6DB99E5,0x1FA27CF8,0xC4AC5665,
	0xF4292244,0x432AFF97,0xAB9423A7,0xFC93A039,0x655B59C3,0x8F0CCC92,0xFFEFF47D,0x85845DD1,
	0x6FA87E4F,0xFE2CE6E0,0xA3014314,0x4E0811A1,0xF7537E82,0xBD3AF235,0x2AD7D2BB,0xEB86D391
	};

DWORD md5::s[64]={
	7,12,17,22,7,12,17,22,7,12,17,22,7,12,17,22,
	5,9,14,20,5,9,14,20,5,9,14,20,5,9,14,20,
	4,11,16,23,4,11,16,23,4,11,16,23,4,11,16,23,
	6,10,15,21,6,10,15,21,6,10,15,21,6,10,15,21
};

DWORD md5::m[64]={
	0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,
	1,6,11,0,5,10,15,4,9,14,3,8,13,2,7,12,
	5,8,11,14,1,4,7,10,13,0,3,6,9,12,15,2,
	0,7,14,5,12,3,10,1,8,15,6,13,4,11,2,9
};

看上去很复杂，其实不是。
首先前4个数值A、B、C、D，它们原本的值是这样的：

A = 0x01234567
B = 0x89ABCDEF
C = 0xFEDCBA89
D = 0x76543210

小端存储的情况下，为了保证ABCD4个值在内存中的显示情况为上面情况，所以要调整数字的位置，故实际情况是：

A = 0x67452301;
B = 0xEFCDAB89;
C = 0x98BADCFE;
D = 0x10325476;

0x03 处理信息

经过信息填充后，填充后的信息长度肯定是512位（64字节）的倍数，也就是说每512位（64字节）为1段可以分成n段，（n大于等于1），对于每一段信息（512位，64字节）又划分成16小段（每段32位，4个字节，用x表示）

用上面的消息为例，x为

x[16] = {0x676E7562, 0x64800000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
         0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x28000000, 0x00000000}

对于每一段信息，都会经过下列的运算处理，共4种函数

FF(a,b,c,d,x,s,ti)
GG(a,b,c,d,x,s,ti)
HH(a,b,c,d,x,s,ti)
II(a,b,c,d,x,s,ti)

对于每种函数都会共执行64次
执行顺序是：
先执行16次FF，再执行16次GG，再执行16次HH，最后执行16次II，可以把这个4种函数各执行16次看作一次周期，那么这样的周期有4个，可以简单理解为：

for(i = 0; i < 4; ++i) {
 	FF(16); //括号内为执行次数
 	GG(16);
 	HH(16);
 	II(16);
}

函数的内容分别是：

void md5::FF(DWORD &a,DWORD &b,DWORD &c,DWORD &d,DWORD x,DWORD s,DWORD ti){
	DWORD temp = F(b,c,d) + a + x + ti;
	temp = (temp<<s)|(temp>>(32-s));
	a = b + temp; 
}

void md5::GG(DWORD &a,DWORD &b,DWORD &c,DWORD &d,DWORD x,DWORD s,DWORD ti){
	DWORD temp = G(b,c,d) + a + x + ti;
	temp = (temp<<s)|(temp>>(32-s));
	a = b + temp; 
}

void md5::HH(DWORD &a,DWORD &b,DWORD &c,DWORD &d,DWORD x,DWORD s,DWORD ti){
	DWORD temp = H(b,c,d) + a + x + ti;
	temp = (temp<<s)|(temp>>(32-s));
	a = b + temp; 
}

void md5::II(DWORD &a,DWORD &b,DWORD &c,DWORD &d,DWORD x,DWORD s,DWORD ti){
	DWORD temp = I(b,c,d) + a + x + ti;
	temp = (temp<<s)|(temp>>(32-s));
	a = b + temp; 
}

#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，I分别是：

DWORD md5::F(DWORD X,DWORD Y,DWORD Z){
	return (X&Y)|((~X)&Z);
}

DWORD md5::G(DWORD X,DWORD Y,DWORD Z){
	return (X&Z)|(Y&(~Z));
}

DWORD md5::H(DWORD X,DWORD Y,DWORD Z){
	return X^Y^Z;
}

DWORD md5::I(DWORD X,DWORD Y,DWORD Z){
	return Y^(X|(~Z));
}

调用举例说明

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

x是上面每一段的16个小段了，其中m[j]表示每次函数处理的小段都不同，按照一定的顺序来处理每个小段，其中的顺序就在x中保存了。
Sxx是循环左移的位数，也有一定顺序。
T是常数，共64个，意味着64次的函数调用都是用不同的数值
对于第一段消息（前512位（64个字节））传入的a，b，c，d的值是上面的ABCD4个有规律的值。
第一段消息处理完后（即4个函数各执行了16次之后），得到新的a，b，c，d的值，将它们分别加上原来a，b，c，d的值（即计算前的值），作为下一段消息（第2个512位（64个字节））的初始a，b，c，d的值。

当每段消息（512位，64个字节）都处理完之后，得到的a，b，c，d的值，按照地址的顺序从低到高打印对应的值，就是所求的MD5值。

MD5算法的Flash讲解演示
06-28
一个关于MD5算法的演示Flash，详细讲解该算法的每一步骤，比起直接看代码更容易理解算法
MD5算法原理的说明
03-01
测试： zhong7758521 : 50945d41c5b4f365296a68ea416dc2c7 UJRdQcW082UpamjqQW3Cxw== 博文链接：https://graduate.iteye.com/blog/239817
MD5——算法（密码验证）
最新发布
awaya111的博客
04-18 793
发送方使用私钥对数据的MD5哈希值进行加密，生成数字签名并将其附加在数据中发送，接收方收到数据后私用发送方的公钥进行解密数字签名，在计算数据中md5哈希值并与解密后的数字签名进行比较，以验证数据的完整性和真实性。密码存储：md5算法可以在用于加密密码并存储在数据库中，当用户登录时，系统对用户输入的密码进行MD5哈希运算，然后与数据库中存储的md5哈希值进行比较，以验证密码的正确性。四轮循环操作：MD5算法将输入消息分为若干个512位的数据块，每个数据块经过四轮循环操作，对寄存器中的值进行更新。
matlab实现md5算法,md5算法详解,matlab
09-10
用matlab实现的一个md5算法，有详细的注释说明
信息摘要算法之一：MD5算法解析及实现
weixin_30838921的博客
10-14 1014
MD5即Message-Digest Algorithm 5（信息-摘要算法5），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD5实现。 1、MD5算法简介 MD5在90年代初由MIT的计算机科学实验室和RSA Data Security Inc发明，经MD2、MD3和MD4发展而来。 MD5将任意长度的“字节串”变换成一个128...
MD5加密算法（c语言实现）
热门推荐
haroroda的博客
05-23 4万+
对课本和网上MD5加密算法模糊定义不清楚和不理解的请点进来~~~
MD5算法
随便积累点东西
11-06 1万+
 MD5（单向散列算法）的全称是Message-Digest Algorithm 5（信息-摘要算法），经MD2、MD3和MD4发展而来。MD5算法的使用不需要支付任何版权费用。    MD5功能：    输入任意长度的信息，经过处理，输出为128位的信息（数字指纹）；    不同的输入得到的不同的结果（唯一性）；    根据128位的输出结果不可能反推出输入的信息（不可逆）；     MD5属不
MD5算法步骤详解
weixin_30414245的博客
08-27 1280
转自MD5算法步骤详解 之前要写一个MD5程序，但是从网络上看到的资料基本上一样，只是讲了一个大概。经过我自己的实践，我决定写一个心得，给需要实现MD5，但又不要求很高深的编程知识的童鞋参考。不多说了，直接进入正题。 MD5算法是什么，MD5的历史由来等等我都不介绍了，想要了解的童鞋直接百度吧，见谅~~我们直接讲算法步骤。我的事例是对一个字符串进行MD5加密，没...
算法基础--MD5算法介绍
积木的笔记
06-03 5810
MD5算法是Hash算法的一种，叫做讯息摘要演算法。所谓摘要，从字面意思理解，是指内容的大概。在MD5算法中，这个摘要是指将任意数据映射成一个128位长的摘要信息。并且其是不可逆的，即从摘要信息无法反向推演中原文，在演算过程中，原文的内容也是有丢失的。
MD5算法全解析
jsyjst的博客
11-13 9284
前言 这段时间刚好正在做软件安全的实验和课设，学习了各种加密算法，比如对称加密算法的DES,AES；非对称加密算法的RSA,再如今天要讲的主角-单向加密算法的MD5。为什么这么多算法，MD5成为了今天的猪脚呢？，这是因为个人感觉在目前Android开发中MD5算是比较常用的，所以很值得一讲。所以今天让我带你们来全面认识我们的主角MD5。 一、基本概念 1. 单向加密算法 在介绍MD5算法前，很有必...
MD5算法详细流程(pdf)
10-14
网上现成的md5代码很多，但如果你想了解算法或自己写一个，本文可以作为参考。
matlab实现md5算法,md5算法详解,matlab源码.zip
09-30
MATLAB源码可能包含了MD5算法的完整实现，包括如何将输入数据转换为适合MD5处理的格式，如何执行迭代过程，以及如何将最终的128位摘要转换为可读的32位十六进制字符串。通过研究这些源码，你可以深入理解MD5算法的...
一篇文章从零搞懂 MD5（逆天口算MD5）
lshen12345678的博客
03-17 1086
轮次函数公式第一轮F(X,Y,Z)第二轮G(X,Y,Z)第三轮H(X,Y,Z)X ⊕ Y ⊕ Z第四轮I(X,Y,Z)通过本文，你已掌握了 MD5 的核心原理，包括数据填充、链接变量初始化、四轮循环运算以及结果组合。虽然手动计算 MD5 较为复杂，但理解其流程有助于你在实际开发中正确应用哈希算法。记住，在实际项目中，应优先使用成熟的加密库，而非自行实现。
MD5加密
听海的博客
04-20 8983
MD5加密。
MD5算法深度解析与完整C语言实现
weixin_47902631的博客
02-26 2762
MD5（Message-Digest Algorithm 5）由Ronald Rivest于1992年设计，可生成128位（16字节）的哈希值。数据填充：将输入长度填充至512位的倍数分块处理：以512位分组进行迭代计算非线性函数：四轮共64步的位级运算结果组合：输出四个32位寄存器的连接值此博文主要是讲述在C语言中MD5的具体实现方法，在嵌入式系统中经常会用到此类的数据校验方式，例如在OTA过程中对于分段数据的校验。下面是正文，文末是完整的.h.c文件。
什么是MD5
jlcheerful的博客
02-04 2399
笔记
MD5详解
xcxhzjl的博客
12-19 7073
一、介绍 二、特点 三、性质 四、用途 五、算法原理 六、破解 七、MD5较MD4所做的改进
oracle中md5加密解密_Oracle中的MD5加密详解
05-25
在Oracle中，可以使用DBMS_CRYPTO包中的函数来实现MD5加密和解密。 MD5加密的步骤如下： 1. 将原始数据转换成二进制数据。 2. 对二进制数据进行填充，使其长度为512的整数倍。 3. 将填充后的数据分成512位的数据块，每个数据块包含16个32位的字。 4. 对每个数据块进行4轮循环运算，每轮运算包含16个步骤，每个步骤都是基于位运算和非线性函数计算得到的。 5. 将最后一个数据块的结果进行累加，并输出128位的MD5值。 下面是使用DBMS_CRYPTO包中的函数实现MD5加密和解密的示例： ``` -- MD5加密 DECLARE l_text VARCHAR2(32767) := 'hello world'; l_key RAW(2000) := UTL_RAW.CAST_TO_RAW('secret key'); l_hash RAW(16); BEGIN l_hash := DBMS_CRYPTO.HASH(UTL_RAW.CAST_TO_RAW(l_text), DBMS_CRYPTO.HASH_MD5); DBMS_OUTPUT.PUT_LINE('MD5 hash of ' || l_text || ': ' || UTL_RAW.CAST_TO_VARCHAR2(l_hash)); END; -- MD5解密（无法解密） DECLARE l_text VARCHAR2(32767) := 'hello world'; l_key RAW(2000) := UTL_RAW.CAST_TO_RAW('secret key'); l_hash RAW(16); l_decrypt RAW(2000); BEGIN l_hash := DBMS_CRYPTO.HASH(UTL_RAW.CAST_TO_RAW(l_text), DBMS_CRYPTO.HASH_MD5); DBMS_OUTPUT.PUT_LINE('MD5 hash of ' || l_text || ': ' || UTL_RAW.CAST_TO_VARCHAR2(l_hash)); -- MD5是不可逆的加密算法，无法解密。 END; ``` 需要注意的是，MD5是一种不可逆的加密算法，无法对其进行解密。因此，上面的MD5解密示例实际上是无法解密的。
评论 12
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值