SHA 哈希家族完全指南
SHA(Secure Hash Algorithm,安全哈希算法)是密码学哈希函数的一族标准,由美国 NSA 设计、NIST 标准化。SHA 家族是当今数字世界中最重要的密码学原语之一,用于数字签名、证书、区块链、文件完整性验证等几乎所有需要密码学保证的场景。
核心性质(所有密码学哈希函数都应满足):
- 单向性:给定 h,找 x 使得 H(x) = h 不可行
- 抗碰撞:找 x ≠ y 使得 H(x) = H(y) 不可行
- 雪崩效应:输入 1 位变化 → 输出约一半位变化
- 确定性:相同输入永远产生相同输出
- 固定长度:不论输入多大,输出长度固定
一、SHA 家族概览
1.1 各版本对比
| 算法 | 标准 | 输出长度 | 块大小 | 结构 | 安全性 | 推荐状态 |
|---|---|---|---|---|---|---|
| MD5 | RFC 1321 | 128 位 | 512 位 | Merkle-Damgård | ❌ 已破 | 不推荐 |
| SHA-1 | FIPS 180-1 | 160 位 | 512 位 | Merkle-Damgård | ⚠️ 已破 | 淘汰中 |
| SHA-224 | FIPS 180-4 | 224 位 | 512 位 | Merkle-Damgård | ✅ | 兼容用 |
| SHA-256 | FIPS 180-4 | 256 位 | 512 位 | Merkle-Damgård | ✅ | 推荐 |
| SHA-384 | FIPS 180-4 | 384 位 | 1024 位 | Merkle-Damgård | ✅ | 高安全 |
| SHA-512 | FIPS 180-4 | 512 位 | 1024 位 | Merkle-Damgård | ✅ | 高安全 |
| SHA-512/224 | FIPS 180-4 | 224 位 | 1024 位 | SHA-512 截断 | ✅ | 兼容 |
| SHA-512/256 | FIPS 180-4 | 256 位 | 1024 位 | SHA-512 截断 | ✅ | 兼容 |
| SHA3-224 | FIPS 202 | 224 位 | 1152 位 | Keccak 海绵 | ✅ | 新应用 |
| SHA3-256 | FIPS 202 | 256 位 | 1088 位 | Keccak 海绵 | ✅ | 新应用推荐 |
| SHA3-384 | FIPS 202 | 384 位 | 832 位 | Keccak 海绵 | ✅ | 高安全 |
| SHA3-512 | FIPS 202 | 512 位 | 576 位 | Keccak 海绵 | ✅ | 最高安全 |
| SHAKE128 | FIPS 202 | 任意 | 1344 位 | 可扩展输出 | ✅ | 自定义长度 |
| SHAKE256 | FIPS 202 | 任意 | 1088 位 | 可扩展输出 | ✅ | 自定义长度 |
1.2 算法分类
Merkle-Damgård 结构 (MD 家族):
├── MD5 (Rivest, 1992)
├── SHA-0 (NSA, 1993, 已废弃)
├── SHA-1 (NSA, 1995)
└── SHA-2 家族 (NSA, 2001)
├── SHA-224 (SHA-256 的变体)
├── SHA-256
├── SHA-384 (SHA-512 的变体)
├── SHA-512
├── SHA-512/224
└── SHA-512/256
Keccak / 海绵结构 (SHA-3 家族, 2015):
├── SHA3-224
├── SHA3-256
├── SHA3-384
├── SHA3-512
├── SHAKE128 (XOF)
└── SHAKE256 (XOF)
1.3 各算法的输出示例
import hashlib
text = b"The quick brown fox jumps over the lazy dog"
print(f"MD5: {hashlib.md5(text).hexdigest()}")
print(f"SHA-1: {hashlib.sha1(text).hexdigest()}")
print(f"SHA-224: {hashlib.sha224(text).hexdigest()}")
print(f"SHA-256: {hashlib.sha256(text).hexdigest()}")
print(f"SHA-384: {hashlib.sha384(text).hexdigest()}")
print(f"SHA-512: {hashlib.sha512(text).hexdigest()}")
print(f"SHA3-256: {hashlib.sha3_256(text).hexdigest()}")
print(f"SHA3-512: {hashlib.sha3_512(text).hexdigest()}")
输出:
MD5: 9e107d9d372bb6826bd81dd0dc282977
SHA-1: 2fd4e1c67a2d28fced849ee1bb76e7391b93eb12
SHA-224: 730e109bd7a8a32b1cb9d9a09aa235fad3c51e17a43b118a
SHA-256: d7a8fbb307d7809469ca9abcb0082e4f8d5651e46d3cdb762d02d0bf37c9e592
SHA-384: ca737f1014a48f4c0b6dd43cb177b0afd9e5169367544c494011e3317dbf9a509cb1e5dc1e85a941bbee3d7f2afbc9b1
SHA-512: 07e547d9586f6a73f73fbac0435ed76951218fb7d0c8d788a309d785436bbb642e93a252a954f23912547d1e8a3b5ed6e1bfd7097821233fa0538f3db854fee6
SHA3-256: 69070dda01975c8c120c3aada1b282394e7f032fa9cf32f4cb2259a0897dfc04
SHA3-512: 01dedd5de4ef14642445ba5f5b97c15e47b9ad931326e4b0727cd94cefc44fff23f07bf543ad43b543b0444396411b5b4ad0dc31e4c810281cd09e1c7a67a8d8
二、Merkle-Damgård 结构(SHA-1 和 SHA-2)
2.1 总体结构
Merkle-Damgård(MD)结构将任意长度输入映射为固定长度输出:
步骤:
- 填充:使总长度为块大小的整数倍
- 拆分:将填充后的消息分成固定大小的块
- 迭代:每块与状态变量通过压缩函数 f 结合,更新状态
- 输出:最终状态即为哈希值
2.2 填充方案(SHA-256 示例)
输入消息长度:L 位
步骤 1:追加 1 位 "1"
M || 1
步骤 2:追加 k 位 "0",使得 (L + 1 + k + 64) 是 512 的倍数
即:(L + 1 + k) mod 512 = 448
步骤 3:追加 64 位表示原始消息长度 L(大端序)
总长度:512 位的整数倍
示例:消息 “abc”(L = 24 位)
原消息: 01100001 01100010 01100011 (24 位 = 3 字节)
步骤 1: 01100001 01100010 01100011 1
步骤 2: 补 423 个 0,使 24 + 1 + 423 = 448
步骤 3: 追加 0x0000000000000018 (64 位表示长度 24)
最终: 512 位 = 64 字节(正好 1 个块)
SHA-512 类似,但块大小 1024 位,长度字段 128 位。
2.3 SHA-256 压缩函数详解
步骤 1:设置初始哈希值(8 个 32 位字)
这些初始值来自前 8 个质数平方根的小数部分的前 32 位:
H0 = 0x6a09e667 (sqrt(2) 的小数部分)
H1 = 0xbb67ae85 (sqrt(3))
H2 = 0x3c6ef372 (sqrt(5))
H3 = 0xa54ff53a (sqrt(7))
H4 = 0x510e527f (sqrt(11))
H5 = 0x9b05688c (sqrt(13))
H6 = 0x1f83d9ab (sqrt(17))
H7 = 0x5be0cd19 (sqrt(19))
步骤 2:消息扩展(扩展 16 字 → 64 字)
对于 i = 0 到 15:
W[i] = 第 i 个 32 位消息块
对于 i = 16 到 63:
S0 = ROTR(W[i-15], 7) XOR ROTR(W[i-15], 18) XOR SHR(W[i-15], 3)
S1 = ROTR(W[i-2], 17) XOR ROTR(W[i-2], 19) XOR SHR(W[i-2], 10)
W[i] = W[i-16] + S0 + W[i-7] + S1 (mod 2^32)
其中:
- ROTR(x, n) = 循环右移 n 位
- SHR(x, n) = 逻辑右移 n 位
步骤 3:64 轮压缩
使用 8 个状态变量 a, b, c, d, e, f, g, h 从当前哈希值 H0-H7 初始化。
每轮计算(共 64 轮):
S1 = ROTR(e, 6) XOR ROTR(e, 11) XOR ROTR(e, 25)
ch = (e AND f) XOR (NOT e AND g)
temp1 = h + S1 + ch + K[i] + W[i]
S0 = ROTR(a, 2) XOR ROTR(a, 13) XOR ROTR(a, 22)
maj = (a AND b) XOR (a AND c) XOR (b AND c)
temp2 = S0 + maj
h = g
g = f
f = e
e = d + temp1
d = c
c = b
b = a
a = temp1 + temp2
其中 K[i] 是 64 个常数(前 64 个质数立方根的小数部分前 32 位)。
步骤 4:更新哈希值
H0 = H0 + a (mod 2^32)
H1 = H1 + b
...
H7 = H7 + h
步骤 5:输出
SHA-256 输出 = H0 || H1 || H2 || H3 || H4 || H5 || H6 || H7
2.4 SHA-1 结构(简化说明)
SHA-1 与 SHA-256 类似,但:
- 输出 160 位(5 个 32 位字)
- 块大小 512 位
- 80 轮(不是 64 轮)
- 使用不同的压缩函数(含 5 个状态变量 A-E)
SHA-1 的致命弱点:2017 年由 Google 和 CWI 公布实际碰撞攻击(2020 年选择前缀碰撞成本约 5 万美元),已不可用于签名。
2.5 Python 实现(SHA-256,教育用途)
def right_rotate(n, bits, total=32):
"""32 位循环右移"""
return (n >> bits) | (n << (total - bits)) & ((1 << total) - 1)
def sha256(message):
"""SHA-256 纯 Python 实现(教育用途)"""
# 初始哈希值
h0, h1, h2, h3 = 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a
h4, h5, h6, h7 = 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
# 64 个轮常数(前 64 个质数立方根的小数部分)
K = [
0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
]
if isinstance(message, str):
message = message.encode()
# 消息长度(位)
original_length = len(message) * 8
# 步骤 1:追加 0x80(1000 0000)
message += b'\x80'
# 步骤 2:补 0,使长度 mod 64 = 56(留下 8 字节存长度)
while (len(message) % 64) != 56:
message += b'\x00'
# 步骤 3:追加 64 位大端序长度
message += original_length.to_bytes(8, 'big')
# 处理每个 64 字节块
for chunk_start in range(0, len(message), 64):
chunk = message[chunk_start:chunk_start + 64]
# 消息扩展:16 → 64 个 32 位字
W = [0] * 64
for i in range(16):
W[i] = int.from_bytes(chunk[i*4:(i+1)*4], 'big')
for i in range(16, 64):
s0 = right_rotate(W[i-15], 7) ^ right_rotate(W[i-15], 18) ^ (W[i-15] >> 3)
s1 = right_rotate(W[i-2], 17) ^ right_rotate(W[i-2], 19) ^ (W[i-2] >> 10)
W[i] = (W[i-16] + s0 + W[i-7] + s1) & 0xFFFFFFFF
# 初始化工作变量
a, b, c, d, e, f, g, h = h0, h1, h2, h3, h4, h5, h6, h7
# 64 轮压缩
for i in range(64):
S1 = right_rotate(e, 6) ^ right_rotate(e, 11) ^ right_rotate(e, 25)
ch = (e & f) ^ ((~e) & g) & 0xFFFFFFFF
temp1 = (h + S1 + ch + K[i] + W[i]) & 0xFFFFFFFF
S0 = right_rotate(a, 2) ^ right_rotate(a, 13) ^ right_rotate(a, 22)
maj = (a & b) ^ (a & c) ^ (b & c)
temp2 = (S0 + maj) & 0xFFFFFFFF
h = g
g = f
f = e
e = (d + temp1) & 0xFFFFFFFF
d = c
c = b
b = a
a = (temp1 + temp2) & 0xFFFFFFFF
# 更新哈希值
h0 = (h0 + a) & 0xFFFFFFFF
h1 = (h1 + b) & 0xFFFFFFFF
h2 = (h2 + c) & 0xFFFFFFFF
h3 = (h3 + d) & 0xFFFFFFFF
h4 = (h4 + e) & 0xFFFFFFFF
h5 = (h5 + f) & 0xFFFFFFFF
h6 = (h6 + g) & 0xFFFFFFFF
h7 = (h7 + h) & 0xFFFFFFFF
# 输出 256 位 = 32 字节
return b''.join(h.to_bytes(4, 'big') for h in [h0, h1, h2, h3, h4, h5, h6, h7])
# 测试
print(sha256(b"").hex())
# e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
print(sha256(b"abc").hex())
# ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad
# 与标准库对比
import hashlib
print(hashlib.sha256(b"abc").hexdigest()) # 相同
三、SHA-3(Keccak 海绵结构)
SHA-3 是 NIST 在 2007-2012 年举行公开竞赛后选中的新哈希函数标准(2015 年 FIPS 202)。获胜者是由 Guido Bertoni、Joan Daemen(AES 设计者之一)、Michaël Peeters 和 Gilles Van Assche 设计的 Keccak。
3.1 为什么需要 SHA-3?
| 原因 | 说明 |
|---|---|
| 防御性过渡 | MD5 已破、SHA-1 被攻击,SHA-2 虽安全但结构相同 |
| 不同的数学基础 | 与 SHA-1/SHA-2 使用完全不同的结构(海绵 vs MD) |
| 设计更简洁 | 更少的操作,更好的并行化潜力 |
| 可扩展输出 (XOF) | SHAKE 支持任意长度输出 |
3.2 海绵结构(Sponge Construction)
参数:
| 参数 | 含义 | 典型值 |
|---|---|---|
| b | 状态总大小 | 1600 位 |
| r | 位速率(rate,每次吸收/挤出的位数) | 1152, 1088, 832, 576 |
| c | 容量(capacity,不直接与输入/输出交互的位数) | c = b - r |
| d | 输出长度 | 224, 256, 384, 512 |
SHA-3 各版本参数:
| 算法 | 速率 r | 容量 c | 输出 d |
|---|---|---|---|
| SHA3-224 | 1152 | 448 | 224 |
| SHA3-256 | 1088 | 512 | 256 |
| SHA3-384 | 832 | 768 | 384 |
| SHA3-512 | 576 | 1024 | 512 |
| SHAKE128 | 1344 | 256 | 任意,至少 128 |
| SHAKE256 | 1088 | 512 | 任意,至少 256 |
重要原则:c 越大 → 安全性越高,但速度越慢(因为每轮处理的消息越少)
3.3 Keccak-f[1600] 置换函数
状态是 5×5×64 位 = 1600 位(5×5 个 64 位字)。
一轮 Keccak-f 包含 5 个操作(简记为 θ ρ π χ ι):
1. θ (Theta): 列奇偶性
每行 XOR 左右列的奇偶性
2. ρ (Rho): 行移位
每个 lane 循环左移指定位数
3. π (Pi): 行置换
重新排列 lanes 的位置
4. χ (Chi): 非线性变换
lane[x, y] = lane[x, y] XOR (NOT lane[x+1, y] AND lane[x+2, y])
5. ι (Iota): 轮常数加
与轮常数 XOR
总轮数:24 轮
3.4 SHA-3 填充
Keccak 使用 10*1 填充:
追加: 0x06 || 0x00 || ... || 0x00 || 0x80(中间全 0)
或简化: 0x01 || 0x00 || ... || 0x80(取决于具体实现)
这确保了消息扩展的安全性(与 Merkle-Damgård 不同)
3.5 Python SHA-3 示例
import hashlib
# SHA-3 基本用法
print(hashlib.sha3_256(b"abc").hexdigest())
# 3a985da74fe225b2045c172d6bd390bd855f086e3e9d525b46bfe24511431532
# SHAKE(可扩展输出函数)
shake = hashlib.shake_256(b"test")
print(shake.hexdigest(16)) # 16 字节 = 128 位输出
print(shake.hexdigest(32)) # 32 字节 = 256 位输出
print(shake.hexdigest(64)) # 64 字节 = 512 位输出
# SHAKE 可以产生任意长度输出(甚至 1000 字节!)
shake_long = hashlib.shake_128(b"data")
print(shake_long.hexdigest(128))
四、长度扩展攻击(Length Extension Attack)
SHA-1 和 SHA-2(Merkle-Damgård 结构)的致命弱点:
4.1 攻击原理
已知: H(key || message) = hash(攻击者不知道 key)
目标: 计算 H(key || message || padding || new_message)
由于 MD 结构将哈希输出作为下一轮的初始状态:
H(key || msg || pad || new_msg) = f(hash, process(new_msg))
攻击者可以:
1. 将已知 hash 作为初始 IV
2. 继续在末尾追加新消息
3. 计算出有效的哈希值
4. 伪造出 key || msg || pad || new_msg 的有效 MAC!
4.2 攻击示例(H(key || msg) 构造伪造 MAC)
import hashlib
import struct
# 场景:服务器使用 H(key || message) 作为 MAC(这是错误的,应该用 HMAC)
key = b"secret_key_unknown_to_attacker"
message = b"user=admin"
mac = hashlib.sha256(key + message).hexdigest()
print(f"原始 MAC: {mac}")
# 攻击者只知道 message 和 mac,不知道 key
# 但可以构造:key || message || padding || new_message
# 1. 构造原始消息的填充(攻击者可以计算,因为只需要长度)
original_length = len(key) + len(message)
# 攻击者不知道 len(key),但可以尝试各种长度(CTF 题目中通常给出或暴力)
# 2. 构造伪造:从已知 hash 继续哈希
# 需要把 hash 转成可继续使用的状态
def forge_extension(known_hash, original_data_length, new_message):
"""长度扩展攻击(简化版)"""
# 恢复 SHA-256 状态
h_bytes = bytes.fromhex(known_hash)
h = [int.from_bytes(h_bytes[i*4:(i+1)*4], 'big') for i in range(8)]
# 计算原消息 + 填充后的总长度(用于伪造)
pad_length = 64 - (original_data_length % 64)
if pad_length < 9:
pad_length += 64
total_padded = original_data_length + pad_length
# 构造伪造消息填充(模拟 SHA-256 内部处理)
forged_padding = b'\x80' + b'\x00' * (pad_length - 9) + \
(original_data_length * 8).to_bytes(8, 'big')
# 构造新消息的块(从恢复状态继续哈希)
# ... 实际实现需要模拟 hashlib 内部状态,这是复杂部分
# 使用专门的工具(如 hash_extender / hlextend 库)
return forged_padding, total_padded
实际 CTF 工具:
# hash_extender / hlextend
./hash_extender \
--data "user=admin" \
--secret 10 \ # 假设密钥 10 字节
--append "&role=root" \
--hash d9a8a3bc... \
--format sha256
4.3 防御方案
| 方案 | 说明 |
|---|---|
| 使用 HMAC | H(key |
| SHA-3 | 海绵结构天然免疫长度扩展攻击 |
| HMAC-SHA256 | 标准做法,既安全又高效 |
五、HMAC(带密钥的哈希消息认证码)
HMAC(RFC 2104)是使用哈希函数的密钥认证方案。详细内容见《HMAC消息认证码完全指南》。
计算公式:
HMAC(K, m) = H((K XOR opad) || H((K XOR ipad) || m))
其中:
ipad = 0x36 重复 B 次
opad = 0x5C 重复 B 次
B = 哈希函数块大小(64 for SHA-1/SHA-256, 128 for SHA-512)
K = 密钥(短于 B 则补 0,长于 B 则先哈希)
Python 实现:
import hmac, hashlib
key = b"my_secret_key"
message = b"authenticated message"
# 标准库方法
mac = hmac.new(key, message, hashlib.sha256)
print(f"HMAC-SHA256: {mac.hexdigest()}")
# 自己实现
def custom_hmac(key, message, hash_func=hashlib.sha256, block_size=64):
if len(key) > block_size:
key = hash_func(key).digest()
key = key + b'\x00' * (block_size - len(key))
o_key_pad = bytes(b ^ 0x5c for b in key)
i_key_pad = bytes(b ^ 0x36 for b in key)
return hash_func(o_key_pad + hash_func(i_key_pad + message).digest()).hexdigest()
print(f"自定义 HMAC: {custom_hmac(key, message)}") # 应该相同
六、密码学哈希函数的安全性分析
6.1 攻击模型
| 攻击类型 | 目标 | 复杂度 |
|---|---|---|
| 原像攻击 (Preimage) | 给定 h,找 x 使 H(x) = h | 2^n |
| 第二原像 (Second Preimage) | 给定 x,找 y ≠ x 使 H(y) = H(x) | 2^(n/2) ~ 2^n |
| 碰撞攻击 (Collision) | 找 x ≠ y 使 H(x) = H(y) | 2^(n/2)(生日悖论) |
6.2 生日悖论
碰撞攻击理论下界:
在 2^n 种可能输出中,约 2^(n/2) 次尝试就能找到碰撞(概率约 50%)
举例:
MD5 (128 位): 约 2^64 次尝试
SHA-1 (160 位): 约 2^80 次尝试
SHA-256: 约 2^128 次尝试
SHA3-512: 约 2^256 次尝试
安全位数(Collision Resistance):
| 哈希 | 输出 | 实际安全(碰撞) | 状态 |
|---|---|---|---|
| MD5 | 128 | < 2^18 | ❌ 已破(2004年) |
| SHA-1 | 160 | ~ 2^61 | ⚠️ 已破(2017年首次碰撞) |
| SHA-256 | 256 | 2^128 | ✅ |
| SHA-512 | 512 | 2^256 | ✅ |
| SHA3-256 | 256 | 2^128 | ✅ |
| SHA3-512 | 512 | 2^256 | ✅ |
6.3 各算法破解历史
| 年份 | 事件 | 影响 |
|---|---|---|
| 1996 | MD5 差分攻击理论 | MD5 不再推荐用于新应用 |
| 2004 | MD5 实际碰撞(王小云) | MD5 彻底不适合安全用途 |
| 2005 | SHA-1 理论攻击(< 2^69) | SHA-1 安全性存疑 |
| 2017 | SHA-1 首次实际碰撞(Google/CWI) | SHA-1 推荐退役 |
| 2020 | SHA-1 选择前缀碰撞成本 $50K | 数字签名必须禁用 SHA-1 |
| 2024 | SHA-2 无实际攻击 | SHA-256/SHA-512 安全 |
6.4 SHA-1 实际碰撞(2017 Shattered 攻击)
Google 和 CWI 产生了两个不同的 PDF 文件,具有相同 SHA-1 哈希值:
文件 A: pdf-shattered-1.pdf → 320字节不同
文件 B: pdf-shattered-2.pdf → 相同 SHA-1
代价: 约 6,500 CPU 年(单线程)和 110 GPU 年
花费: 估计 $100K+
NIST 迁移时间表:
- 2017 年起:禁止 SHA-1 用于数字签名
- 2030 年起:SHA-1 完全淘汰
七、实际应用场景
7.1 文件完整性验证
# 生成 SHA-256 校验和
sha256sum file.iso > file.iso.sha256
# 验证
sha256sum -c file.iso.sha256
# file.iso: OK
# macOS
shasum -a 256 file.iso
# Windows PowerShell
Get-FileHash -Algorithm SHA256 file.iso
7.2 区块链
Bitcoin:双重 SHA-256
import hashlib
def bitcoin_hash(data):
"""Bitcoin 使用双 SHA-256"""
return hashlib.sha256(hashlib.sha256(data).digest()).digest()
# 区块头哈希 = PoW 证明
block_header = b"\x01\x00\x00\x00..." # 简化
block_hash = bitcoin_hash(block_header)
Ethereum:Keccak-256(注意:不是标准 SHA3-256,是 SHA-3 竞赛原始版本)
7.3 证书和数字签名
X.509 证书签名流程:
1. 取证书内容(TBSCertificate = To-Be-Signed)
2. 计算 SHA-256 哈希
3. 用 CA 的 RSA 私钥签名(RSA-PSS)
4. 客户端用 CA 公钥验证签名
TLS 1.3 握手签名:
1. 签名握手消息哈希
2. 用 RSA-PSS + SHA-256 或 Ed25519
7.4 密码存储
❌ 错误:直接存储密码哈希(无 salt)
# 这是错误的!
password_hash = hashlib.sha256(password.encode()).hexdigest()
# 问题:相同密码产生相同哈希 → 彩虹表攻击
✅ 正确:使用 salted password hashing
# PBKDF2
import hashlib, os
salt = os.urandom(16)
key = hashlib.pbkdf2_hmac('sha256', password.encode(), salt, 100000)
# 存储: salt + key
# Argon2id(推荐)
from argon2 import PasswordHasher
ph = PasswordHasher(time_cost=3, memory_cost=65536, parallelism=4)
hash = ph.hash(password) # 包含 salt、参数、哈希值
ph.verify(hash, password)
7.5 API 认证
HMAC API 认证流程:
客户端:
1. 构造签名串(method || path || timestamp || body)
2. HMAC-SHA256(key, 签名串) = signature
3. 发送: Authorization: HMAC-SHA256 key_id:signature:timestamp
服务器:
1. 查找 key_id 对应的密钥
2. 检查时间戳在有效期(防重放)
3. 重新计算 HMAC 并比较
4. 比较必须用常量时间函数(防时序攻击)
7.6 Git 版本控制
# Git 用 SHA-1 计算对象 ID
git hash-object file.txt
# 输出: 2e65efe2a145dda7ee51d1741299f848e5bf757ec
# Git 正在迁移到 SHA-256
# Git 2.29+ 支持 SHA-256 仓库
git init --object-format=sha256
八、SHA 家族的使用建议
8.1 选型表
| 场景 | 推荐算法 | 理由 |
|---|---|---|
| 通用哈希 | SHA-256 | 最广泛支持,性能好 |
| 高安全需求 | SHA-384 或 SHA3-256 | 对量子攻击有更好防御力 |
| 密码存储 | Argon2id 或 PBKDF2-HMAC-SHA256 | 慢速哈希函数 |
| MAC/认证 | HMAC-SHA256 或 HMAC-SHA3-256 | 防长度扩展 |
| 数字签名 | SHA-256 + RSA-PSS / ECDSA / Ed25519 | 标准签名 |
| 文件完整性 | SHA-256 或 BLAKE2b | 快速且安全 |
| 新协议/应用 | SHA-3 系列 | 未来安全方向 |
| 禁止使用 | ❌ MD5, ❌ SHA-1 | 已被破解 |
8.2 性能对比(粗略,软件实现)
| 算法 | 相对速度(SHA-256 = 1.0) | 备注 |
|---|---|---|
| MD5 | 1.5x | 快但不安全 |
| SHA-1 | 1.3x | 较快但不安全 |
| SHA-256 | 1.0x | 基准 |
| SHA-512 | 1.5x | 在 64 位平台更快 |
| SHA3-256 | 0.8x | 稍慢 |
| SHA3-512 | 0.5x | 较慢 |
| BLAKE2b | 2.5x | 更快的替代品 |
8.3 密码学哈希 vs 非密码学哈希
| 用途 | 例子 | 需要密码学哈希吗? |
|---|---|---|
| 哈希表/字典 | Python dict, Hash Map | ❌ 不需要 |
| 数据库分片 | 一致性哈希 | ❌ 不需要 |
| Bloom filter | 去重过滤器 | ⚠️ 视情况 |
| 文件去重 | content-hash | ⚠️ 防碰撞需要 |
| 数字签名 | 证书签名 | ✅ 必须 |
| 密码存储 | 用户密码 | ✅ 必须 |
| 消息认证 | HMAC | ✅ 必须 |
| 区块链 | PoW | ✅ 必须 |
| Git/版本控制 | 内容寻址 | ✅ 抗碰撞 |
8.4 常见哈希库
# Python 标准库 hashlib(推荐,最广泛支持)
import hashlib
h = hashlib.sha256(b"data").hexdigest()
h = hashlib.sha3_256(b"data").hexdigest()
h = hashlib.shake_256(b"data").hexdigest(32)
# PyCryptodome(含更多功能)
from Crypto.Hash import SHA256, SHA3_256, HMAC
h = SHA256.new(data=b"data").hexdigest()
# cryptography(更高级 API)
from cryptography.hazmat.primitives import hashes
digest = hashes.Hash(hashes.SHA256())
digest.update(b"data")
h = digest.finalize()
8.5 OpenSSL 命令行
# 文件哈希
openssl dgst -sha256 file.txt
openssl dgst -sha3-256 file.txt
# 字符串哈希
echo -n "message" | openssl dgst -sha256
# 所有支持的哈希算法
openssl dgst -list | grep -E "sha|SHA|md|MD"
九、CTF 中的哈希题目
9.1 长度扩展攻击
题目类型: 给定 MAC = SHA256(key || msg) 和 msg,不知道 key
目标: 构造 MAC = SHA256(key || msg || pad || new_msg)
工具: hash_extender, hlextend, hmac_extender
9.2 MD5/SHA-1 碰撞
题目类型: 文件必须满足某些条件且哈希值符合要求
工具: fastcoll (MD5 快速碰撞), sha1collider
9.3 彩虹表/在线查询
题目类型: 给出弱密码的 SHA-1/MD5,反查原文
工具: crackstation.net, hashes.com
9.4 已知哈希前缀
题目类型: 已知部分哈希或哈希关系,恢复消息
考察点: Merkle-Damgård 结构性质
总结
SHA 哈希家族是现代密码学的基础构建块:
- MD5 ❌ — 已彻底破解,仅用于非安全场景(如测试/遗留系统兼容)
- SHA-1 ⚠️ — 已实际碰撞,应停止用于签名,正在淘汰中
- SHA-2(SHA-256/SHA-512) ✅ — 当前标准,广泛部署,性能好
- SHA-3(Keccak) ✅ — 新一代标准,结构完全不同,免疫长度扩展攻击
- BLAKE2(非 SHA 但实用) — 更快的替代品,安全级别高
最佳实践:
- 新系统默认使用 SHA-256
- 高安全需求使用 SHA-384 或 SHA3-256
- 需要 MAC 时使用 HMAC-SHA256
- 存储密码使用 Argon2id 或 PBKDF2-HMAC-SHA256 (100K+ 轮)
- 数字签名使用 RSA-PSS + SHA-256 或 Ed25519
- 需要 XOF(可变长度输出)使用 SHAKE128/SHAKE256
安全迁移原则:发现 SHA-1 的地方尽快升级到 SHA-2;关注 SHA-3 的部署;在需要长期保护的场景考虑后量子算法。