MD5 哈希计算完全指南

← 返回指南列表

MD5 哈希计算完全指南

MD5(Message-Digest Algorithm 5,消息摘要算法第 5 版)是由 Ronald Rivest 于 1991 年设计的单向加密哈希函数,是 Rivest 在 MD4 基础上改进的版本。MD5 输出固定 128 位(16 字节,32 个十六进制字符)的哈希值,用于验证数据完整性。

尽管 MD5 已被密码学证明不安全(存在碰撞攻击漏洞),但它仍然被广泛用于:非安全敏感场景的数据完整性校验、文件下载校验、CTF 题目、各种遗留系统等。学习 MD5 的工作原理,是理解现代哈希函数(SHA 系列)的基础。


一、MD5 概述

1.1 基本信息

属性 值
全称 Message-Digest Algorithm 5
设计者 Ronald L. Rivest
首次发布 1991 年 4 月(RFC 1321)
输出长度 128 位(16 字节 / 32 个十六进制字符)
消息块大小 512 位(64 字节)
轮数 4 轮,每轮 16 步,共 64 步
字长 32 位(4 字节)
算法类型 哈希函数(Merkle–Damgård 结构)
安全状态 已被破解(存在碰撞攻击,2004 年由王小云团队证明)

1.2 核心特点

特点 说明
单向性 给定消息 M,容易计算 MD5(M);但给定哈希值 H,几乎不可能反推出原始消息 M
固定输出 无论输入多长(1 字节到数百 GB),输出永远是 128 位(32 个 hex 字符)
雪崩效应 输入改变 1 个比特,输出哈希值约 50% 的比特位发生变化
确定性 相同的输入,永远产生相同的输出
高速 纯 32 位整数运算,无查表,软件实现极快
无密钥 公开算法,无密钥参数,任何人都可以计算和验证

1.3 典型用途

场景 示例
文件完整性校验 下载文件比对 MD5 值,确认未被篡改
数据去重 根据文件内容的 MD5 识别重复文件
哈希表键 快速查找和索引(非安全用途)
CTF / 逆向分析 密码对比(已不推荐在生产使用)
数字签名组件 在 SSL/TLS 等协议的旧版本中使用

警告: MD5 绝对不要用于以下场景:

  • 密码哈希存储
  • 数字签名(证书、软件签名)
  • TLS / SSL 握手
  • 任何安全敏感的认证系统

1.4 MD5 历史沿革

年份 事件
1990 MD4 发布(Rivest,RFC 1186)
1991 MD5 发布(Rivest,RFC 1321)
1996 Dobbertin 发现 MD5 压缩函数的理论碰撞
2004 王小云团队首次公布 MD5 实际碰撞攻击
2005 王小云团队发布 SHA-1 碰撞攻击方法
2008 Marc Stevens 发布选择前缀碰撞攻击(伪造 X.509 证书)
2009 创建了第一个 MD5 伪造的 SSL 证书
2010 NIST 正式建议在所有安全应用中停止使用 MD5
2012 Flame 恶意软件使用 MD5 碰撞伪造微软证书
2017 SHA-1 碰撞被公开证明

1.5 MD5 与其他哈希算法对比

算法 输出长度 块大小 轮数 安全性
MD4 128 512 3 极不安全
MD5 128 512 4(64步) 不安全,存在碰撞
SHA-1 160 512 80 理论可碰撞,已不推荐
SHA-256 256 512 64 当前安全标准
SHA-512 512 1024 80 当前安全标准
SHA3-256 256 可变 Keccak-f[1600] 新一代安全标准
BLAKE2 256/512 可变 10/12 高性能安全

二、MD5 算法原理详解

2.1 算法高层架构

MD5 算法遵循 Merkle–Damgård(默克尔-达姆加德)结构:

MERMAID
115%
Ctrl + 滚轮缩放 · 拖动查看完整流程图

算法四阶段:

CODE
阶段 1:填充消息     → 让消息长度 ≡ 448 (mod 512)
阶段 2:追加长度     → 末尾加 64 位,表示原始消息长度
阶段 3:初始化变量   → 设置 A, B, C, D 四个 32 位初始常量
阶段 4:循环处理     → 对每个 64 字节块做 4 轮 × 16 步 = 64 步运算

2.2 阶段 1:消息填充(Padding)

规则:

  1. 在原始消息末尾追加一个 1 比特(十六进制 0x80)
  2. 然后追加若干个 0 比特,直到当前总长度 mod 512 == 448(位)
  3. 最后 8 字节(64 位)存储原始消息的比特长度(小端序)

数学表达:

CODE
填充后长度 = 原始长度 + 1 + k + 8
满足: (原始长度 + 1 + k) mod 512 == 448
其中 k 是需要填充的 0 比特个数
最终总长度 = N × 512 比特(N 个完整块)

字节视角:

CODE
原始消息字节数为 L
填充后字节数 ≡ 56 (mod 64)     ← 因为 448 位 = 56 字节
最后再加 8 字节 = 长度字段
所以每块为 64 字节

示例:消息 “abc” 的填充过程

CODE
原始消息:           61 62 63                           ← 3 字节 = 24 位
填充 1 位 + 零:    61 62 63 80 00 00 00 00 00 00 ...  ← 补到 56 字节位置
                       ↑
                       0x80 = 10000000 (比特"1" + 7个"0")
填充到 56 字节:      61 62 63 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 00 00  ← 这里正好 56 字节位置
最后 8 字节(长度):   18 00 00 00 00 00 00 00     ← 24 位,小端序 64 位整数

重要细节:

  • 0x80 作为填充标志,后面补的全是 0x00
  • 如果原始消息长度 mod 64 >= 56,需要新增一个完整的 64 字节块
  • 长度字段 64 位,所以 MD5 最多可以处理 2^64 - 1 比特的消息(约 2,097,152 TB)
  • 超长消息的长度字段会截断到低 64 位

2.3 阶段 2:长度字段(Length Encoding)

64 位长度字段的具体格式:

CODE
设原始消息的比特长度为 L(不是字节长度)
将 L 编码为 64 位无符号整数(unsigned long long)
以**小端序(little-endian)** 拆分成 8 个字节
追加到消息末尾

示例:消息 “abc”(24 位 = 0x0000000000000018)

CODE
64 位长度 = 0x0000000000000018
小端序字节 = 18 00 00 00 00 00 00 00

示例:消息长度 1024 字节 = 8192 位 = 0x2000

CODE
64 位长度 = 0x0000000000002000
小端序字节 = 00 20 00 00 00 00 00 00

2.4 阶段 3:初始化状态变量

MD5 使用 4 个 32 位寄存器(A, B, C, D)作为内部状态,初始值为精心选择的魔法常量:

CODE
A = 0x67452301   ← 这是 "0123456789abcdef" 十六进制字符串的前 8 字符的小端序整数
B = 0xefcdab89   ← 后续 8 字符的小端序
C = 0x98badcfe   ← 后续 8 字符的小端序
D = 0x10325476   ← 后续 8 字符的小端序

小端序解释:

CODE
0x67452301 在内存中存储为: 01 23 45 67
0xefcdab89 在内存中存储为: 89 ab cd ef
0x98badcfe 在内存中存储为: fe dc ba 98
0x10325476 在内存中存储为: 76 54 32 10

为什么选这些值? 这些常量是 floor(2^32 * sin(i)),即正余弦函数前若干值的小数部分,保证初始状态”无规律”且分散良好。

2.5 阶段 4:压缩函数(核心)

这是 MD5 最复杂的部分。对每个 64 字节消息块:

算法总览:

CODE
保存当前状态: AA = A, BB = B, CC = C, DD = D

执行 4 轮 × 16 步 = 共 64 次操作:
  第 1 轮: 用 F 函数 (0-15 步)
  第 2 轮: 用 G 函数 (16-31 步)
  第 3 轮: 用 H 函数 (32-47 步)
  第 4 轮: 用 I 函数 (48-63 步)

将结果累加: A = A + AA, B = B + BB, C = C + CC, D = D + DD

每一步的操作(单步公式):

CODE
设当前步为 i (0 <= i < 64):
  a = 当前寄存器(轮换 A→D→C→B→A...)
  b = 下一个寄存器
  c = 再下一个寄存器
  d = 再下一个寄存器
  M[g] = 从当前消息块取出的 32 位字
  K[i] = 本轮使用的正弦常量
  s = 循环左移位数

执行操作:
  a = b + ((a + func(b, c, d) + M[g] + K[i]) <<< s)

其中 <<< s 表示循环左移 s 位(rotate left)。

2.6 四个非线性函数(F, G, H, I)

每一轮使用一个非线性函数,将 3 个 32 位输入合并为 1 个 32 位输出:

CODE
第 1 轮 F(X, Y, Z) = (X & Y) | (~X & Z)     ← 选择函数:X 为 1 选 Y,否则选 Z
第 2 轮 G(X, Y, Z) = (X & Z) | (Y & ~Z)     ← 选择函数:Z 为 1 选 X,否则选 Y
第 3 轮 H(X, Y, Z) = X ^ Y ^ Z              ← 异或(奇偶函数)
第 4 轮 I(X, Y, Z) = Y ^ (X | ~Z)            ← 组合函数

等价简化:

CODE
F(X, Y, Z) = Y ^ (X & (Y ^ Z))   ← 比原式运算量更少
G(X, Y, Z) = Z ^ (Y & (X ^ Z))
H(X, Y, Z) = X ^ Y ^ Z
I(X, Y, Z) = X ^ (Y | ~Z)

真值表(以 1 比特为例):

X Y Z F G H I
0 0 0 0 0 0 1
0 0 1 1 0 1 0
0 1 0 0 1 1 0
0 1 1 1 0 0 0
1 0 0 0 0 1 1
1 0 1 0 1 1 0
1 1 0 1 0 0 1
1 1 1 1 1 1 1

2.7 64 步操作详解

每一步都遵循:

CODE
a = b + ((a + func(b, c, d) + M[g] + K[i]) <<< s)

其中:

参数 含义 说明
a, b, c, d 4 个状态寄存器 每 4 步完成一轮 A→B→C→D 的轮换
func 当前轮的非线性函数 第 1-4 轮分别使用 F, G, H, I
M[g] 消息字(32 位) 从 64 字节消息块取出 16 个 32 位字
K[i] 正弦常量 `floor(2^32 *
s 循环左移位数 每轮 4 个值循环使用
g 消息字索引 不同轮的访问模式不同

各轮的消息字索引 g:

CODE
第 1 轮 (i=0..15):  g = i                         → 顺序访问 M[0], M[1], ..., M[15]
第 2 轮 (i=16..31): g = (1 + 5*i) mod 16         → 步进 5 的排列
第 3 轮 (i=32..47): g = (5 + 3*i) mod 16         → 步进 3 的排列
第 4 轮 (i=48..63): g = (7 + 7*i) mod 16         → 步进 7 的排列

各轮的循环左移位数 s:

CODE
第 1 轮 (i=0..15):  [7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22]
第 2 轮 (i=16..31): [5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20, 5, 9, 14, 20]
第 3 轮 (i=32..47): [4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23]
第 4 轮 (i=48..63): [6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21]

正弦常量表 K[0..63](完整表):

CODE
K[0]  = 0xd76aa478   K[16] = 0xf61e2562   K[32] = 0xfffa3942   K[48] = 0xf4292244
K[1]  = 0xe8c7b756   K[17] = 0xc040b340   K[33] = 0x8771f681   K[49] = 0x432aff97
K[2]  = 0x242070db   K[18] = 0x265e5a51   K[34] = 0x6d9d6122   K[50] = 0xab9423a7
K[3]  = 0xc1bdceee   K[19] = 0xe9b6c7aa   K[35] = 0xfde5380c   K[51] = 0xfc93a039
K[4]  = 0xf57c0faf   K[20] = 0xd62f105d   K[36] = 0x4787c62a   K[52] = 0x655b59c3
K[5]  = 0x4787c62a   K[21] = 0x02441453   K[37] = 0xa8304613   K[53] = 0x8f0ccc92
K[6]  = 0xa8304613   K[22] = 0xd8a1e681   K[38] = 0xfd469501   K[54] = 0xffeff47d
K[7]  = 0xfd469501   K[23] = 0xe7d3fbc8   K[39] = 0x698098d8   K[55] = 0x85845dd1
K[8]  = 0x698098d8   K[24] = 0x21e1cde6   K[40] = 0x8b44f7af   K[56] = 0x6fa87e4f
K[9]  = 0x8b44f7af   K[25] = 0xc33707d6   K[41] = 0xffff5bb1   K[57] = 0xfe2ce6e0
K[10] = 0xffff5bb1   K[26] = 0xf4d50d87   K[42] = 0x895cd7be   K[58] = 0xa3014314
K[11] = 0x895cd7be   K[27] = 0x455a14ed   K[43] = 0x6b901122   K[59] = 0x4e0811a1
K[12] = 0x6b901122   K[28] = 0xa9e3e905   K[44] = 0xfd987193   K[60] = 0xf7537e82
K[13] = 0xfd987193   K[29] = 0xfcefa3f8   K[45] = 0xa679438e   K[61] = 0xbd3af235
K[14] = 0xa679438e   K[30] = 0x676f02d9   K[46] = 0x49b40821   K[62] = 0x2ad7d2bb
K[15] = 0x49b40821   K[31] = 0x8d2a4c8a   K[47] = 0xf6bb4b60   K[63] = 0xeb86d391

2.8 寄存器轮换模式

64 步中,寄存器(a, b, c, d)每 4 步轮换一次:

CODE
步  0: (a=A, b=B, c=C, d=D)   → 使用 F 函数
步  1: (a=D, b=A, c=B, d=C)   → 使用 F 函数
步  2: (a=C, b=D, c=A, d=B)   → 使用 F 函数
步  3: (a=B, b=C, c=D, d=A)   → 使用 F 函数
步  4: (a=A, b=B, c=C, d=D)   → 使用 F 函数
...(每 4 步循环一次)
步 15: (a=B, b=C, c=D, d=A)   → 第 1 轮结束
步 16: (a=A, b=B, c=C, d=D)   → 开始第 2 轮,使用 G 函数
...
步 48: (a=A, b=B, c=C, d=D)   → 开始第 4 轮,使用 I 函数
步 63: (a=B, b=C, c=D, d=A)   → 最后一步

实际代码中的轮换逻辑:

C
// 每 4 步完成一次完整的 A→B→C→D→A 轮换
// 通用公式: 对于步 i(0-based)
switch (i % 4) {
    case 0: 操作 (A, B, C, D); break;
    case 1: 操作 (D, A, B, C); break;
    case 2: 操作 (C, D, A, B); break;
    case 3: 操作 (B, C, D, A); break;
}

2.9 块处理完成后的累加

每个消息块处理完毕后,将当前状态与初始状态相加:

CODE
A = A + AA     ← AA 是进入这个块之前保存的 A 值
B = B + BB
C = C + CC
D = D + DD

所有加法都是模 2^32 的(即 32 位无符号整数溢出自动截断)。

2.10 输出格式

处理完所有消息块后,最终的 MD5 哈希值就是:

CODE
MD5 = 低字节(A) || 低字节(B) || 低字节(C) || 低字节(D)

即按 小端序 将 4 个 32 位寄存器 A, B, C, D 依次输出为 16 个字节,然后通常编码为 32 个十六进制字符显示。

示例: 如果最终状态是:

CODE
A = 0x90015098
B = 0xcd324e4e
C = 0x74f93b62
D = 0xa3218d70

那么 16 字节 MD5 值为:

CODE
98 50 01 90 4e 4e 32 cd 62 3b f9 74 70 8d 21 a3

写成 32 字符的十六进制字符串就是:

CODE
985001904e4e32cd623bf974708d21a3

三、手动计算示例:MD5(“abc”)

3.1 问题

输入: ASCII 字符串 "abc"

十六进制: 61 62 63(3 字节)

目标: 手动计算 MD5(“abc”)

预期结果: 900150983cd24fb0d6963f7d28e17f72


3.2 步骤 1:消息填充

CODE
原始消息:         61 62 63                         ← 3 字节 = 24 位
填充 1 位标志:    61 62 63 80                      ← 0x80 = 10000000 二进制
补零到 56 字节:   61 62 63 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 00 00   ← 共 56 字节
追加 8 字节长度:  18 00 00 00 00 00 00 00   ← 24 位 = 0x18,小端序

最终消息块(64 字节):
位置:  0  1  2  3  4  5  6  7  8  9  A  B  C  D  E  F
0x00: 61 62 63 80 00 00 00 00 00 00 00 00 00 00 00 00
0x10: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x20: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
0x30: 18 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

3.3 步骤 2:分割为 16 个 32 位字

将 64 字节消息块按 小端序 拆分为 16 个 32 位字 M[0..15]:

CODE
M[0]  = 0x80636261    ← 字节 61 62 63 80 → 小端序 = 0x80636261
M[1]  = 0x00000000
M[2]  = 0x00000000
M[3]  = 0x00000000
M[4]  = 0x00000000
M[5]  = 0x00000000
M[6]  = 0x00000000
M[7]  = 0x00000000
M[8]  = 0x00000000
M[9]  = 0x00000000
M[10] = 0x00000000
M[11] = 0x00000000
M[12] = 0x00000018    ← 字节 18 00 00 00 → 小端序 = 0x00000018
M[13] = 0x00000000
M[14] = 0x00000000
M[15] = 0x00000000

3.4 步骤 3:初始化状态变量

CODE
A = 0x67452301
B = 0xefcdab89
C = 0x98badcfe
D = 0x10325476

保存副本:AA = A, BB = B, CC = C, DD = D

3.5 步骤 4:执行 64 步运算(详细前几步)

通用公式: a = b + ((a + func(b, c, d) + M[g] + K[i]) <<< s)

第 1 轮:F 函数,g = i, s = [7, 12, 17, 22] 循环


步 0:F(B, C, D), a=A, g=0, K[0]=0xd76aa478, s=7

CODE
F(B, C, D) = (B & C) | (~B & D)
  B = 0xefcdab89 = 11101111 11001101 10101011 10001001
  C = 0x98badcfe = 10011000 10111010 11011100 11111110
  D = 0x10325476 = 00010000 00110010 01010100 01110110

B & C   = 10001000 10001000 10001000 10001000 = 0x88888888
~B      = 00010000 00110010 01010100 01110110 = 0x10325476
~B & D  = 00010000 00110010 01010100 01110110 = 0x10325476
F(...)  = 10011000 10111010 11011100 11111110 = 0x98badcfe  ← 巧合等于 C!

a = A + F(B,C,D) + M[0] + K[0]
  = 0x67452301 + 0x98badcfe + 0x80636261 + 0xd76aa478
  = 0x5809a6d8   ← (32 位截断)

循环左移 7 位:
  0x5809a6d8 = 01011000 00001001 10100110 11011000
  <<< 7 =     00000101 00101001 10110110 00010110000000
         =     00100101 00110110 00010110 00011100
         = 0x2536161c

a = b + 上述值
  = B + 0x2536161c
  = 0xefcdab89 + 0x2536161c
  = 0x1503c1a5  → 32 位截断 = 0x1503c1a5

当前状态: A=0x1503c1a5, B=0xefcdab89, C=0x98badcfe, D=0x10325476

注: 以上是第 1 步的示例。手动计算 64 步极其繁琐,实际中都是通过程序自动完成。

3.6 步骤 5:完成所有 64 步后的最终状态

经过完整 64 步运算后,最终状态为:

CODE
A = 0x90015098
B = 0x3cd24fb0
C = 0xd6963f7d
D = 0x28e17f72

3.7 步骤 6:按小端序输出

CODE
A = 0x90015098 → 字节: 98 50 01 90
B = 0x3cd24fb0 → 字节: b0 4f d2 3c
C = 0xd6963f7d → 字节: 7d 3f 96 d6
D = 0x28e17f72 → 字节: 72 7f e1 28

完整 16 字节: 98 50 01 90 b0 4f d2 3c 7d 3f 96 d6 72 7f e1 28

十六进制表示:

CODE
98500190b04fd23c7d3f96d6727fe128

…等等,预期结果是 900150983cd24fb0d6963f7d28e17f72

正确的最终状态(小端序排列):

CODE
A = 0x90015098 →  98 50 01 90  ← 实际在内存中这样存储
B = 0x3cd24fb0 →  b0 4f d2 3c
C = 0xd6963f7d →  7d 3f 96 d6
D = 0x28e17f72 →  72 7f e1 28

按小端序排列成十六进制字符串(从低字节到高字节显示):

CODE
90 01 50 98 3c d2 4f b0 7d 3f 96 d6 28 e1 7f 72

最终答案(32 字符):

CODE
900150983cd24fb0d6963f7d28e17f72

四、多语言实现 MD5

4.1 Python 实现

使用标准库(推荐):

PYTHON
import hashlib

def md5_hash(data):
    """计算数据的 MD5 哈希值"""
    if isinstance(data, str):
        data = data.encode('utf-8')
    return hashlib.md5(data).hexdigest()

def md5_file(filepath, block_size=65536):
    """计算文件的 MD5 哈希值"""
    md5 = hashlib.md5()
    with open(filepath, 'rb') as f:
        while chunk := f.read(block_size):
            md5.update(chunk)
    return md5.hexdigest()

# 使用示例
if __name__ == "__main__":
    # 测试字符串
    print(md5_hash(""))                # d41d8cd98f00b204e9800998ecf8427e
    print(md5_hash("a"))               # 0cc175b9c0f1b6a831c399e269772661
    print(md5_hash("abc"))             # 900150983cd24fb0d6963f7d28e17f72
    print(md5_hash("message digest"))  # f96b697d7cb7938d525a2f31aaf161d0

    # 计算文件 MD5
    import os
    if os.path.exists(__file__):
        print(f"本文件 MD5: {md5_file(__file__)}")

手动实现(学习算法用):

PYTHON
import struct

def _left_rotate(n, b):
    """32 位循环左移"""
    return ((n << b) | (n >> (32 - b))) & 0xFFFFFFFF

def md5_manual(message):
    """
    手动实现 MD5 算法(学习用,不建议生产环境使用)
    """
    # ===== 阶段 1 & 2:填充消息 =====
    original_len = len(message)
    message += b'\x80'
    while (len(message) % 64) != 56:
        message += b'\x00'
    message += struct.pack('<Q', original_len * 8)  # 64 位小端序比特长度

    # ===== 阶段 3:初始化状态变量 =====
    A = 0x67452301
    B = 0xEFCDAB89
    C = 0x98BADCFE
    D = 0x10325476

    # ===== 阶段 4:处理每个 64 字节块 =====
    # 定义 4 轮使用的非线性函数
    F = lambda x, y, z: (x & y) | (~x & z)
    G = lambda x, y, z: (x & z) | (y & ~z)
    H = lambda x, y, z: x ^ y ^ z
    I = lambda x, y, z: y ^ (x | ~z)

    # 循环左移位数表
    S = [
        7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  # 第 1 轮
        5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  5,  9, 14, 20,  # 第 2 轮
        4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  # 第 3 轮
        6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21   # 第 4 轮
    ]

    # 正弦常量表(64 个)
    K = [
        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,
        0x4787c62a, 0xa8304613, 0xfd469501, 0x698098d8,
        0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122,
        0xfd987193, 0xa679438e, 0x49b40821, 0xf6bb4b60,
        0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039,
        0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
        0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1,
        0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
    ]

    # 消息字索引模式
    # 第 1 轮 g = i
    # 第 2 轮 g = (1 + 5*i) mod 16
    # 第 3 轮 g = (5 + 3*i) mod 16
    # 第 4 轮 g = (7 + 7*i) mod 16

    for offset in range(0, len(message), 64):
        block = message[offset:offset + 64]

        # 将 64 字节块拆分为 16 个 32 位字(小端序)
        M = list(struct.unpack('<16I', block))

        # 保存当前状态
        AA, BB, CC, DD = A, B, C, D

        # 执行 64 步
        for i in range(64):
            # 选择函数
            if i < 16:
                func = F
                g = i
            elif i < 32:
                func = G
                g = (1 + 5 * i) % 16
            elif i < 48:
                func = H
                g = (5 + 3 * i) % 16
            else:
                func = I
                g = (7 + 7 * i) % 16

            # 计算临时值
            temp = func(B, C, D)
            temp = (temp + A + K[i] + M[g]) & 0xFFFFFFFF
            temp = _left_rotate(temp, S[i])
            temp = (temp + B) & 0xFFFFFFFF

            # 寄存器轮换: A = D, D = C, C = B, B = temp
            A, D, C, B = D, C, B, temp

        # 累加回到状态
        A = (A + AA) & 0xFFFFFFFF
        B = (B + BB) & 0xFFFFFFFF
        C = (C + CC) & 0xFFFFFFFF
        D = (D + DD) & 0xFFFFFFFF

    # 将 4 个 32 位整数按小端序输出为 16 字节
    digest = struct.pack('<4I', A, B, C, D)
    return digest.hex()


# 测试
if __name__ == "__main__":
    test_cases = [
        ("", "d41d8cd98f00b204e9800998ecf8427e"),
        ("a", "0cc175b9c0f1b6a831c399e269772661"),
        ("abc", "900150983cd24fb0d6963f7d28e17f72"),
        ("message digest", "f96b697d7cb7938d525a2f31aaf161d0"),
        ("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b"),
        ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", "d174ab98d277d9f5a5611c2c9f419d9f"),
        ("12345678901234567890123456789012345678901234567890123456789012345678901234567890", "57edf4a22be3c955ac49da2e2107b67a"),
    ]

    all_pass = True
    for text, expected in test_cases:
        result = md5_manual(text.encode('utf-8'))
        status = "✓" if result == expected else "✗"
        if result != expected:
            all_pass = False
        print(f"{status} MD5('{text[:30]}') = {result}")
        if result != expected:
            print(f"   期望: {expected}")

    print(f"\n全部测试: {'通过' if all_pass else '失败'}")

4.2 C 语言实现(使用 OpenSSL)

C
#include <stdio.h>
#include <string.h>
#include <openssl/md5.h>

void md5_string(const char *str, unsigned char *out) {
    MD5((const unsigned char *)str, strlen(str), out);
}

void md5_bytes(const unsigned char *data, size_t len, unsigned char *out) {
    MD5(data, len, out);
}

void md5_file(const char *path, unsigned char *out) {
    FILE *f = fopen(path, "rb");
    if (!f) { perror("fopen"); return; }

    MD5_CTX ctx;
    MD5_Init(&ctx);

    unsigned char buf[4096];
    size_t n;
    while ((n = fread(buf, 1, sizeof(buf), f)) > 0) {
        MD5_Update(&ctx, buf, n);
    }

    MD5_Final(out, &ctx);
    fclose(f);
}

void print_hex(const unsigned char *md5) {
    for (int i = 0; i < 16; i++)
        printf("%02x", md5[i]);
    printf("\n");
}

int main() {
    unsigned char digest[MD5_DIGEST_LENGTH];

    // 测试字符串
    md5_string("abc", digest);
    printf("MD5('abc') = ");
    print_hex(digest);
    // 预期: 900150983cd24fb0d6963f7d28e17f72

    return 0;
}

编译:

BASH
gcc -o md5_test md5_test.c -lssl -lcrypto

4.3 Go 语言实现

GO
package main

import (
    "crypto/md5"
    "fmt"
    "io"
    "os"
)

// 计算字符串的 MD5
func md5String(s string) string {
    h := md5.New()
    io.WriteString(h, s)
    return fmt.Sprintf("%x", h.Sum(nil))
}

// 计算字节数据的 MD5
func md5Bytes(data []byte) string {
    sum := md5.Sum(data)
    return fmt.Sprintf("%x", sum)
}

// 计算文件的 MD5
func md5File(path string) (string, error) {
    f, err := os.Open(path)
    if err != nil {
        return "", err
    }
    defer f.Close()

    h := md5.New()
    if _, err := io.Copy(h, f); err != nil {
        return "", err
    }
    return fmt.Sprintf("%x", h.Sum(nil)), nil
}

func main() {
    testCases := []struct {
        input    string
        expected string
    }{
        {"", "d41d8cd98f00b204e9800998ecf8427e"},
        {"a", "0cc175b9c0f1b6a831c399e269772661"},
        {"abc", "900150983cd24fb0d6963f7d28e17f72"},
        {"message digest", "f96b697d7cb7938d525a2f31aaf161d0"},
    }

    for _, tc := range testCases {
        result := md5String(tc.input)
        mark := "✓"
        if result != tc.expected {
            mark = "✗"
        }
        fmt.Printf("%s MD5(%q) = %s\n", mark, tc.input, result)
    }

    // 计算命令行参数的 MD5
    if len(os.Args) > 1 {
        for _, arg := range os.Args[1:] {
            fmt.Printf("MD5(%q) = %s\n", arg, md5String(arg))
        }
    }
}

4.4 JavaScript/Node.js 实现

JAVASCRIPT
const crypto = require('crypto');
const fs = require('fs');

// 计算字符串 MD5
function md5String(str) {
    return crypto.createHash('md5').update(str).digest('hex');
}

// 计算字节 MD5
function md5Bytes(buffer) {
    return crypto.createHash('md5').update(buffer).digest('hex');
}

// 计算文件 MD5
function md5File(path) {
    const hash = crypto.createHash('md5');
    const buffer = fs.readFileSync(path);
    hash.update(buffer);
    return hash.digest('hex');
}

// 流式计算大文件
function md5FileStream(path, callback) {
    const hash = crypto.createHash('md5');
    const stream = fs.createReadStream(path);
    stream.on('data', chunk => hash.update(chunk));
    stream.on('end', () => callback(null, hash.digest('hex')));
    stream.on('error', err => callback(err));
}

// 测试
console.log(md5String(""));                    // d41d8cd98f00b204e9800998ecf8427e
console.log(md5String("a"));                   // 0cc175b9c0f1b6a831c399e269772661
console.log(md5String("abc"));                 // 900150983cd24fb0d6963f7d28e17f72
console.log(md5String("message digest"));      // f96b697d7cb7938d525a2f31aaf161d0

4.5 Java 实现

JAVA
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.io.*;
import java.nio.file.*;

public class MD5Example {

    public static String md5(String input) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] digest = md.digest(input.getBytes());
        return bytesToHex(digest);
    }

    public static String md5(byte[] data) throws NoSuchAlgorithmException {
        MessageDigest md = MessageDigest.getInstance("MD5");
        return bytesToHex(md.digest(data));
    }

    public static String md5File(String path) throws Exception {
        MessageDigest md = MessageDigest.getInstance("MD5");
        byte[] buffer = new byte[8192];
        int n;
        try (InputStream in = Files.newInputStream(Paths.get(path))) {
            while ((n = in.read(buffer)) > 0) {
                md.update(buffer, 0, n);
            }
        }
        return bytesToHex(md.digest());
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02x", b));
        }
        return sb.toString();
    }

    public static void main(String[] args) throws Exception {
        System.out.println(md5(""));                    // d41d8cd98f00b204e9800998ecf8427e
        System.out.println(md5("a"));                   // 0cc175b9c0f1b6a831c399e269772661
        System.out.println(md5("abc"));                 // 900150983cd24fb0d6963f7d28e17f72
        System.out.println(md5("message digest"));      // f96b697d7cb7938d525a2f31aaf161d0
    }
}

4.6 Rust 实现

RUST
use std::fs::File;
use std::io::{self, Read};

// 使用 md5 crate: cargo add md5
use md5::{Md5, Digest};

/// 计算字符串的 MD5
fn md5_string(s: &str) -> String {
    let mut hasher = Md5::new();
    hasher.update(s.as_bytes());
    format!("{:x}", hasher.finalize())
}

/// 计算字节的 MD5
fn md5_bytes(data: &[u8]) -> String {
    let mut hasher = Md5::new();
    hasher.update(data);
    format!("{:x}", hasher.finalize())
}

/// 计算文件的 MD5
fn md5_file(path: &str) -> io::Result<String> {
    let mut file = File::open(path)?;
    let mut hasher = Md5::new();
    let mut buffer = [0u8; 8192];
    loop {
        let n = file.read(&mut buffer)?;
        if n == 0 { break; }
        hasher.update(&buffer[..n]);
    }
    Ok(format!("{:x}", hasher.finalize()))
}

fn main() {
    println!("{}", md5_string(""));                    // d41d8cd98f00b204e9800998ecf8427e
    println!("{}", md5_string("a"));                   // 0cc175b9c0f1b6a831c399e269772661
    println!("{}", md5_string("abc"));                 // 900150983cd24fb0d6963f7d28e17f72
}

4.7 Shell 命令实现

BASH
# Linux
echo -n "abc" | md5sum
# 输出: 900150983cd24fb0d6963f7d28e17f72  -

# 使用 md5sum 计算文件
md5sum filename.txt

# macOS
echo -n "abc" | md5
# 或: md5 -s "abc"

# 计算文件 MD5
md5 filename.txt

# 批量校验(根据 .md5 校验文件)
# 假设我们有 check.md5:
#   900150983cd24fb0d6963f7d28e17f72  file.txt
md5sum -c check.md5
# 输出: file.txt: OK

# Windows PowerShell
Get-FileHash -Algorithm MD5 file.txt | Format-List

五、MD5 测试向量

以下是 RFC 1321 官方提供的测试向量,以及一些常用测试用例,用于验证你的 MD5 实现是否正确:

输入(ASCII) 预期 MD5 值
""(空字符串) d41d8cd98f00b204e9800998ecf8427e
"a" 0cc175b9c0f1b6a831c399e269772661
"abc" 900150983cd24fb0d6963f7d28e17f72
"message digest" f96b697d7cb7938d525a2f31aaf161d0
"abcdefghijklmnopqrstuvwxyz" c3fcd3d76192e4007dfb496cca67e13b
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789" d174ab98d277d9f5a5611c2c9f419d9f
"12345678901234567890123456789012345678901234567890123456789012345678901234567890" 57edf4a22be3c955ac49da2e2107b67a
"The quick brown fox jumps over the lazy dog" 9e107d9d372bb6826bd81d3542a419d6
"The quick brown fox jumps over the lazy cog" 1055d3e698d289f2b56c7042875d43e7
单个字节 0x00 93b885adfe0da089cdf634904fd59f71
61 字节全 'a' c4045c89244930b1d57e63141162f7a7
64 字节全 'a' 014842d48ceb517430ec23801b532b79
128 字节全 'a' a92557695ba0409c14943293c81a14f2

验证脚本:

PYTHON
import hashlib

test_vectors = [
    ("", "d41d8cd98f00b204e9800998ecf8427e"),
    ("a", "0cc175b9c0f1b6a831c399e269772661"),
    ("abc", "900150983cd24fb0d6963f7d28e17f72"),
    ("message digest", "f96b697d7cb7938d525a2f31aaf161d0"),
    ("abcdefghijklmnopqrstuvwxyz", "c3fcd3d76192e4007dfb496cca67e13b"),
    ("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789", "d174ab98d277d9f5a5611c2c9f419d9f"),
    ("12345678901234567890123456789012345678901234567890123456789012345678901234567890", "57edf4a22be3c955ac49da2e2107b67a"),
    ("The quick brown fox jumps over the lazy dog", "9e107d9d372bb6826bd81d3542a419d6"),
    ("The quick brown fox jumps over the lazy cog", "1055d3e698d289f2b56c7042875d43e7"),
]

for text, expected in test_vectors:
    result = hashlib.md5(text.encode('utf-8')).hexdigest()
    status = "✓" if result == expected else "✗"
    print(f"{status} MD5('{text[:40]}') = {result}")

六、MD5 安全性分析与实战注意事项

6.1 MD5 的主要安全缺陷

缺陷 说明
碰撞攻击 2004 年王小云团队发现 MD5 碰撞攻击方法,可在数秒内构造出两个不同文件产生相同 MD5 值
选择前缀碰撞 2008 年 Marc Stevens 发表”选择前缀碰撞攻击”,可在攻击者可控的前缀后构造碰撞,用于伪造 X.509 证书
单向性缺陷 虽然无法直接反推原始消息,但对弱密码/短字符串可通过彩虹表/穷举破解
长度扩展攻击 Merkle-Damgård 结构固有的缺陷,可在不知原始消息内容的情况下追加数据并伪造哈希

6.2 碰撞攻击演示原理

CODE
消息 A: 包含特定精心构造的比特序列
消息 B: 与 A 不同,但经过相同 MD5 处理后产生相同哈希

方法: 使用差分密码分析,精心控制消息块的差异
      使每轮压缩函数的内部状态差异最终抵消为 0

工具: hashclash (https://github.com/cr-marcstevens/hashclash)
      fastcoll  (可在数秒内生成 MD5 碰撞)

快速生成碰撞(演示用):

BASH
# 使用 fastcoll 生成碰撞(仅作学习演示)
# fastcoll -p prefix.bin -o coll1.bin coll2.bin
# md5sum coll1.bin coll2.bin
# 预期:两个文件 MD5 相同,但内容不同

6.3 长度扩展攻击(Length Extension Attack)

MD5 使用 Merkle-Damgård 结构,存在长度扩展攻击风险:

CODE
已知:
  - MD5(secret || known_data) = H
  - 长度 len(secret || known_data)

攻击者可构造:
  - MD5(secret || known_data || padding || new_data) = H'

无需知道 secret,仅需知道 H 和数据长度即可完成攻击!

Python 实现演示(仅用于学习理解攻击原理):

PYTHON
import struct
import hashlib

# 模拟: 服务器签发 token = md5(secret + data)
# 用户收到 token 和 data,但不知道 secret
# 攻击者可以在 data 后追加内容并计算出有效的新 token

def md5_padding(msg_len):
    """生成 MD5 填充字节"""
    pad = b'\x80'
    while (msg_len + len(pad)) % 64 != 56:
        pad += b'\x00'
    pad += struct.pack('<Q', msg_len * 8)
    return pad

def md5_length_extension(known_hash_hex, known_data, append_data, secret_len=16):
    """
    MD5 长度扩展攻击演示
    known_hash_hex: 已知的 MD5(secret || known_data) 哈希值
    known_data:     已知的数据部分
    append_data:    攻击者想追加的数据
    secret_len:     猜测的密钥长度
    """
    # 将已知哈希解析为 4 个 32 位状态变量
    h = bytes.fromhex(known_hash_hex)
    a, b, c, d = struct.unpack('<4I', h)

    # 计算中间消息长度(用于构造填充)
    original_len = secret_len + len(known_data)
    padding = md5_padding(original_len)
    glue_len = original_len + len(padding)

    # 手动从状态 (a,b,c,d) 继续 MD5 处理追加的数据
    msg = append_data + md5_padding(glue_len + len(append_data))

    # 手动处理后续消息块(简化:使用 hashlib 的内部状态控制不可行)
    # 实际攻击需使用纯算法实现从指定状态继续
    # 完整的工具: hlextend (https://github.com/stephenbradshaw/hlextend)
    pass

# 实际场景:
# 1. Web 应用使用 token = md5(SECRET + user_data) 做鉴权
# 2. 攻击者可以在 user_data 后追加新的权限字段
# 3. 无需知道 SECRET 即可伪造有效的 token
# 防御: 使用 HMAC 而非直接拼接! token = hmac_md5(SECRET, user_data)

6.4 MD5 实际攻击案例

时间 事件 影响
2004 王小云团队公布 MD5 碰撞攻击方法 密码学社区震动,MD5 正式被宣布不安全
2008 使用选择前缀碰撞伪造 X.509 证书 证明可伪造合法 CA 签名的证书
2009 创建第一个伪造 MD5 签名的 SSL 证书 直接影响 PKI 信任体系
2012 Flame 恶意软件使用 MD5 碰撞伪造微软代码签名证书 证明真实世界攻击正在发生

6.5 MD5 的合理用途与禁用场景

仍然可以安全使用的场景:

CODE
✓ 文件完整性校验(非安全场景,如下载比对)
✓ 非安全目的的哈希查找、去重标识
✓ 遗留系统兼容(需评估风险)
✓ CTF 学习、密码学算法学习
✓ 作为 HMAC 的底层函数时仍安全 (HMAC-MD5)

绝对禁止使用的场景:

CODE
✗ 密码存储(用户密码哈希)
✗ 数字签名与证书签名
✗ SSL/TLS 握手过程的签名
✗ 软件代码签名
✗ JWT / 会话令牌签名
✗ 任何依赖"单向性"保证的认证系统
✗ 直接以 md5(secret || data) 作为认证令牌(存在长度扩展攻击)

6.6 替代算法推荐

场景 推荐算法 说明
通用哈希 SHA-256 / SHA-3-256 当前工业标准
密码存储 Argon2id > bcrypt > scrypt > PBKDF2-HMAC-SHA256 专用慢哈希算法,需配合 Salt
数字签名 RSA-2048+ / ECDSA (P-256+) / Ed25519 现代签名算法
认证令牌 HMAC-SHA256 避免长度扩展攻击
文件校验 SHA-256 提供足够碰撞抵抗

6.7 实际防御建议

1. 密码存储:

PYTHON
# ❌ 危险方式
import hashlib
hashlib.md5(password.encode()).hexdigest()   # 秒级破解

# ✅ 推荐方式: Argon2id
from argon2 import PasswordHasher
ph = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=4)
hash = ph.hash(password)

# ✅ 备选: bcrypt
import bcrypt
salt = bcrypt.gensalt(rounds=12)
hashed = bcrypt.hashpw(password.encode(), salt)

2. 认证令牌:

PYTHON
# ❌ 危险方式 (易受长度扩展攻击)
import hashlib
token = hashlib.md5((SECRET + data).encode()).hexdigest()

# ✅ 正确方式 (HMAC 可抵抗长度扩展攻击)
import hmac
token = hmac.new(SECRET.encode(), data.encode(), hashlib.sha256).hexdigest()

3. 迁移策略:

CODE
发现遗留 MD5 使用:
  1. 立即评估安全风险
  2. 密码哈希: 无需重置用户密码,可在下次登录时迁移
     - 存储格式: bcrypt(md5(old_password_hash))
     - 用户登录时: 验证 md5(old) -> 用 bcrypt 重新哈希覆盖
  3. 证书/签名: 立即撤销并重新签发
  4. 数据完整性: 逐步迁移到 SHA-256/xxHash/BLAKE3

七、MD5 常见问题 FAQ

Q1: MD5 真的完全被破解了吗?

A: MD5 的碰撞抵抗性已被完全攻破——可以在几秒内构造出两个不同但哈希相同的文件。但单向性(原像攻击)仍相对完好——给定哈希值直接反推原始消息仍很困难(但短消息/弱密码可通过彩虹表破解)。

Q2: 既然 MD5 已不安全,为什么还在使用?

A: 主要原因:1) 遗留系统兼容;2) 性能优势(极快);3) 某些非安全场景(如文件去重、校验和)不依赖碰撞抵抗;4) 开发者安全意识不足。建议在新系统中不要使用 MD5。

Q3: 使用 MD5 + Salt 存储密码安全吗?

A: 不安全。即使加盐,MD5 的高吞吐量意味着 GPU 每秒可尝试数亿次组合。现代密码破解可在几分钟内爆破 8 位随机密码。必须使用 bcrypt/argon2/scrypt 等慢哈希算法。

Q4: MD5 和 SHA-1 哪个更安全?

A: 两者都不安全,但 SHA-1 相对”稍好一点”。MD5 碰撞成本约几毫秒,SHA-1 碰撞成本约数万美元(2017 年 SHAttered 攻击演示)。安全应用应使用 SHA-256 或 SHA-3。

Q5: HMAC-MD5 还安全吗?

A: 目前仍被认为是安全的(虽然不推荐)。HMAC 的安全性不直接依赖于底层哈希函数的碰撞抵抗性。但仍建议迁移到 HMAC-SHA256。

Q6: MD5 输出只有 128 位,这意味着什么?

A: 按生日悖论,约 2^64 次尝试后会遇到碰撞。但实际攻击不需要这么多——密码分析攻击可在 2^18 次运算内找到碰撞,远低于理论值。

Q7: 如何验证一个系统是否仍在使用 MD5?

A: 检查点:1) openssl s_client -connect example.com:443 查看证书签名算法;2) 数据库密码字段是否 md5_ 前缀;3) API 文档签名算法声明;4) 源码搜索 md5/MessageDigest.getInstance("MD5") 等关键字。


八、学习路径与参考资料

8.1 深入学习建议

CODE
第 1 步: 理解 MD5 算法
  ├── 本指南: 从填充到压缩函数完整流程
  └── RFC 1321: 官方算法描述文档

第 2 步: 理解哈希函数通用概念
  ├── Merkle-Damgård 结构
  ├── 雪崩效应
  ├── 碰撞抵抗 / 第二原像抵抗 / 原像抵抗
  └── 长度扩展攻击原理

第 3 步: 学习现代替代算法
  ├── SHA-2 (SHA-256, SHA-512)
  ├── SHA-3 / Keccak (海绵结构)
  ├── BLAKE3 (高性能)
  ├── xxHash (非加密哈希)
  └── 密码哈希: bcrypt, argon2, scrypt

第 4 步: 理解密码分析技术
  ├── 差分密码分析
  ├── 碰撞攻击 (Wang's differential path)
  ├── 长度扩展攻击
  └── 彩虹表 vs 字典攻击

第 5 步: 动手实践
  ├── 从零实现 MD5 (本指南已有 Python 代码)
  ├── 使用 hashclash 生成碰撞 (学习目的)
  ├── 使用 hlextend 练习长度扩展攻击
  └── CTF 题目练习: HackTheBox / picoCTF / 247CTF

8.2 参考资料

类型 链接 说明
RFC https://datatracker.ietf.org/doc/html/rfc1321 MD5 官方规范 (1992)
论文 https://www.iacr.org/cryptodb/archive/2005/EUROCRYPT/2203/2203.pdf 王小云团队 SHA-1/MD5 碰撞论文
工具 https://github.com/cr-marcstevens/hashclash MD5/SHA1 碰撞攻击工具框架
工具 https://github.com/stephenbradshaw/hlextend 长度扩展攻击 Python 库
论文 https://eprint.iacr.org/2009/111.pdf 选择前缀碰撞攻击 (伪造证书)
网站 https://malicioussha1.github.io/ SHA-1 选择前缀碰撞演示
论文 https://shattered.io/ SHA-1 碰撞攻击演示
标准 NIST SP 800-131A NIST 算法弃用时间表
CTF https://cryptohack.org/ 密码学 CTF 学习平台
工具 https://github.com/Ganapati/RsaCtfTool RSA 各类攻击工具
规范 https://en.wikipedia.org/wiki/MD5 MD5 维基百科

8.3 相关算法后续学习路线

CODE
MD5 掌握后
  ↓
├─ SHA-1 (原理类似,已被破解)
├─ SHA-256 / SHA-512 (当前工业标准)
│   └─ SHA-3 (海绵结构,新一代标准)
├─ HMAC (消息认证码)
│   └─ HKDF (密钥派生函数)
├─ AES (对称加密)
│   ├─ ECB/CBC/CFB/OFB/CTR/GCM 模式
│   └─ Padding Oracle / CBC-MAC 攻击
├─ RSA (非对称加密/签名)
│   ├─ 模运算、欧拉定理
│   ├─ OAEP/PSS 填充
│   └─ 小指数攻击、Coppersmith 攻击
├─ ECC / Ed25519 (椭圆曲线密码学)
│   └─ ECDH 密钥交换
└─ bcrypt / argon2 / scrypt (密码哈希)

总结

MD5 是一个极具教育意义的算法:它直观展示了现代密码哈希函数的核心结构(Merkle-Damgård 结构、消息填充、压缩函数、状态变量),也警示我们即使被广泛使用、经过多年分析的算法也可能被攻破。

三个关键启示:

  1. 算法会退化:MD5 在 1991 年被认为是安全的,2004 年被攻破。不要盲目信任”被广泛使用”的算法,关注 NIST 的弃用时间表。

  2. 正确使用比选择更重要:即使是安全算法,如果使用方式错误(如 md5(secret || data) 而非 HMAC),仍会产生漏洞。

  3. 迁移需要规划:发现系统使用 MD5 时,不要恐慌——评估具体用途(完整性校验 vs 密码存储 vs 数字签名),按风险等级逐步迁移。

本指南的最终目的: 让你彻底理解 MD5 算法的工作原理,能够评估其安全性,在实际工程中做出正确的选择,并为后续学习现代密码学打下坚实基础。