SHA 哈希家族完全指南

← 返回指南列表

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 算法分类

CODE
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 各算法的输出示例

PYTHON
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()}")

输出:

CODE
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)结构将任意长度输入映射为固定长度输出:

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

步骤:

  1. 填充:使总长度为块大小的整数倍
  2. 拆分:将填充后的消息分成固定大小的块
  3. 迭代:每块与状态变量通过压缩函数 f 结合,更新状态
  4. 输出:最终状态即为哈希值

2.2 填充方案(SHA-256 示例)

CODE
输入消息长度: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 位)

CODE
原消息: 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 位:

CODE
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 字)

CODE
对于 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 轮):

CODE
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:更新哈希值

CODE
H0 = H0 + a (mod 2^32)
H1 = H1 + b
...
H7 = H7 + h

步骤 5:输出

CODE
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,教育用途)

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

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

参数:

参数 含义 典型值
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 个操作(简记为 θ ρ π χ ι):

CODE
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 填充:

CODE
追加: 0x06 || 0x00 || ... || 0x00 || 0x80(中间全 0)
或简化: 0x01 || 0x00 || ... || 0x80(取决于具体实现)

这确保了消息扩展的安全性(与 Merkle-Damgård 不同)

3.5 Python SHA-3 示例

PYTHON
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 攻击原理

CODE
已知: 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)

PYTHON
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 工具:

BASH
# 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消息认证码完全指南》。

计算公式:

CODE
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 实现:

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 生日悖论

碰撞攻击理论下界:

CODE
在 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 哈希值:

CODE
文件 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 文件完整性验证

BASH
# 生成 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

PYTHON
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 证书和数字签名

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

PYTHON
# 这是错误的!
password_hash = hashlib.sha256(password.encode()).hexdigest()
# 问题:相同密码产生相同哈希 → 彩虹表攻击

✅ 正确:使用 salted password hashing

PYTHON
# 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 认证

CODE
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 版本控制

BASH
# 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
# 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 命令行

BASH
# 文件哈希
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 长度扩展攻击

CODE
题目类型: 给定 MAC = SHA256(key || msg) 和 msg,不知道 key
目标: 构造 MAC = SHA256(key || msg || pad || new_msg)

工具: hash_extender, hlextend, hmac_extender

9.2 MD5/SHA-1 碰撞

CODE
题目类型: 文件必须满足某些条件且哈希值符合要求
工具: fastcoll (MD5 快速碰撞), sha1collider

9.3 彩虹表/在线查询

CODE
题目类型: 给出弱密码的 SHA-1/MD5,反查原文
工具: crackstation.net, hashes.com

9.4 已知哈希前缀

CODE
题目类型: 已知部分哈希或哈希关系,恢复消息
考察点: Merkle-Damgård 结构性质

总结

SHA 哈希家族是现代密码学的基础构建块:

  1. MD5 ❌ — 已彻底破解,仅用于非安全场景(如测试/遗留系统兼容)
  2. SHA-1 ⚠️ — 已实际碰撞,应停止用于签名,正在淘汰中
  3. SHA-2(SHA-256/SHA-512) ✅ — 当前标准,广泛部署,性能好
  4. SHA-3(Keccak) ✅ — 新一代标准,结构完全不同,免疫长度扩展攻击
  5. 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 的部署;在需要长期保护的场景考虑后量子算法。