Diffie-Hellman 密钥交换完全指南

← 返回指南列表

Diffie-Hellman 密钥交换完全指南

Diffie-Hellman(DH,迪菲-赫尔曼密钥交换,1976 年)是历史上第一个公钥密码方案。它解决了一个核心问题:在不安全的信道上,两个从未通信过的实体如何安全地协商出一个共享密钥?

DH 不是加密,不是签名 —— 它是密钥协商协议。


一、核心概念

1.1 经典 DH 协议(基于有限域的乘法群)

CODE
公共参数 (公开):
    p = 大质数 (模数)
    g = 生成元 (模 p 的原根)

Alice 侧:                      Bob 侧:
a = 随机私钥 (秘密)            b = 随机私钥 (秘密)
A = g^a mod p (公钥)          B = g^b mod p (公钥)
    ┌─── 发送 A ────>                <─── 发送 B ───┐
    │                                                │
    └─ 计算: shared = B^a mod p = g^(ab) mod p        │
                                                       │
                                 计算: shared = A^b mod p = g^(ab) mod p ─┘

双方得到相同的共享密钥 = g^(ab) mod p

数学正确性:

CODE
Alice 计算: B^a mod p = (g^b mod p)^a mod p = g^(ab) mod p
Bob 计算:   A^b mod p = (g^a mod p)^b mod p = g^(ab) mod p

结果相同!

1.2 DH 的安全基础:离散对数问题 (DLP)

CODE
给定 g, p, A = g^a mod p
求 a = ?

这被认为是困难的(对于足够大的 p)。
已知最好的经典算法: 数域筛 (NFS)
    复杂度: L_p[1/3, (64/9)^(1/3)]
    对于 2048 位 p: 不可行
    对于 1024 位 p: 学术可破 (NSA 可能已破)

量子攻击: Shor 算法可多项式时间求解
    → 所有经典 DH 需要被后量子算法替代

1.3 Python 实现(仅教育用途)

PYTHON
import random

# 公共参数(简化示例,实际使用标准群)
p = 23  # 小质数,仅用于教学
g = 5   # 生成元

# Alice
a = random.randrange(2, p - 1)  # 私钥
A = pow(g, a, p)                # 公钥

# Bob
b = random.randrange(2, p - 1)  # 私钥
B = pow(g, b, p)                # 公钥

# 交换公钥后
shared_alice = pow(B, a, p)
shared_bob = pow(A, b, p)

print(f"Alice 私钥: {a}, 公钥: {A}")
print(f"Bob 私钥: {b}, 公钥: {B}")
print(f"Alice 计算共享: {shared_alice}")
print(f"Bob 计算共享: {shared_bob}")
print(f"相同? {shared_alice == shared_bob}")  # True

1.4 中间人攻击(MITM)和防御

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

二、DH 参数和标准群

2.1 安全参数要求

CODE
对于有限域 DH (FFDH):

1. 模数 p:
    至少 2048 位 → 128 位安全
    3072 位 → 192 位安全(NIST 推荐长期)
    4096 位 → 256 位安全

2. 子群阶 q (生成元 g 的阶):
    必须是大质数(至少 224 位)
    q | (p-1)
    防止 Pohlig-Hellman 分解攻击

3. 安全质数 (Sophie Germain prime):
    定义: p 和 q = (p-1)/2 都是质数
    则 g 的阶为 q 或 2q
    简化参数生成

常用形式: p = 2q + 1, q 为质数

2.2 标准 DH 群(RFC 3526 / RFC 7919)

IETF 已标准化若干预定义群参数,避免使用弱参数。

群名称 p 长度 安全性 典型用途
modp2048 2048 位 ~112 位 常见默认
modp3072 3072 位 ~128 位 TLS 1.2/1.3
modp4096 4096 位 ~150 位 高安全
modp6144 6144 位 ~175 位 极高安全
modp8192 8192 位 ~200 位 最高安全

OpenSSL 查看:

BASH
openssl dhparam -text -noout -in dhparam.pem
openssl dhparam -check -in dhparam.pem  # 检查参数

生成 DH 参数(非常慢!需要找大质数):

BASH
# 2048 位 DH 参数
openssl dhparam -out dhparam.pem 2048

# 4096 位(非常慢)
openssl dhparam -out dhparam_4096.pem 4096

2.3 Python DH 示例(cryptography 库)

PYTHON
from cryptography.hazmat.primitives.asymmetric import dh
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives import hashes

# 方式 1: 从预定义参数生成(推荐,速度快)
parameters = dh.generate_parameters(generator=2, key_size=2048)

# 方式 2: 从 PEM 加载
# parameters = serialization.load_pem_parameters(b"-----BEGIN DH PARAMETERS...")

# Alice 生成密钥对
alice_private = parameters.generate_private_key()
alice_public = alice_private.public_key()

# Bob 生成密钥对
bob_private = parameters.generate_private_key()
bob_public = bob_private.public_key()

# 序列化公钥(用于发送)
alice_pub_bytes = alice_public.public_bytes(
    encoding=serialization.Encoding.PEM,
    format=serialization.PublicFormat.SubjectPublicKeyInfo
)

# 交换公钥(假设在网络上传输)
# Alice 收到 Bob 的公钥,Bob 收到 Alice 的公钥

# Alice 计算共享密钥
shared_alice = alice_private.exchange(bob_public)
print(f"Alice 共享密钥长度: {len(shared_alice)} 字节")

# Bob 计算共享密钥
shared_bob = bob_private.exchange(alice_public)
print(f"Bob 共享密钥长度: {len(shared_bob)} 字节")

print(f"原始共享密钥相同? {shared_alice == shared_bob}")

# 用 HKDF 派生实际使用的密钥(混合 salt 和 context)
derived_alice = HKDF(
    algorithm=hashes.SHA256(),
    length=32,
    salt=None,
    info=b"application context v1",
).derive(shared_alice)

derived_bob = HKDF(
    algorithm=hashes.SHA256(),
    length=32,
    salt=None,
    info=b"application context v1",
).derive(shared_bob)

print(f"派生密钥相同? {derived_alice == derived_bob}")
print(f"派生密钥 (前 8 字节): {derived_alice[:8].hex()}")

三、ECDH(椭圆曲线 Diffie-Hellman)

ECDH 是 DH 在椭圆曲线上的实现。安全性更高,密钥更小。

3.1 原理

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

安全性比较(同安全强度下的密钥大小):

安全强度 RSA/FFDH ECDH
80 位 1024 位 160 位
112 位 2048 位 224 位
128 位 3072 位 256 位
192 位 7680 位 384 位
256 位 15360 位 512 位

ECDH 密钥大小仅为经典 DH 的 1/10,且速度更快。

3.2 常用曲线

曲线 位长 安全性(位) 标准 状态
secp256r1 (P-256) 256 128 NIST ✅ 标准
secp384r1 (P-384) 384 192 NIST ✅ 高安全
secp521r1 (P-521) 521 256 NIST ✅ 极高
X25519 255 128 RFC 7748 ✅ 现代首选
X448 448 224 RFC 7748 ✅ 现代高安全
secp256k1 256 128 de facto 区块链

3.3 X25519(Curve25519,现代首选)

CODE
曲线: y² = x³ + 486662x² + x (mod 2^255 - 19)
基点: x = 9
阶: 2^252 + 27742317777372353535851937790883648493 (大质数)

特点:
    ✅ 设计简单,常数时间实现,抗侧信道
    ✅ 公钥仅 32 字节
    ✅ 计算速度快(无分支,无表查找)
    ✅ TLS 1.3 默认支持
    ✅ Signal, WhatsApp, WireGuard, SSH 默认使用

Python X25519 示例:

PYTHON
from cryptography.hazmat.primitives.asymmetric.x25519 import (
    X25519PrivateKey, X25519PublicKey
)
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives import hashes, serialization

# Alice 生成密钥
alice_private = X25519PrivateKey.generate()
alice_public = alice_private.public_key()

# Bob 生成密钥
bob_private = X25519PrivateKey.generate()
bob_public = bob_private.public_key()

# 公钥可以序列化为 32 字节
alice_pub_raw = alice_public.public_bytes(
    encoding=serialization.Encoding.Raw,
    format=serialization.PublicFormat.Raw
)
print(f"X25519 公钥长度: {len(alice_pub_raw)} 字节")  # 32

# 从字节重建公钥
received_alice_pub = X25519PublicKey.from_public_bytes(alice_pub_raw)

# 计算共享密钥 (ECDH)
shared_alice = alice_private.exchange(bob_public)
shared_bob = bob_private.exchange(received_alice_pub)

print(f"X25519 共享密钥相同? {shared_alice == shared_bob}")
print(f"共享密钥 (前 8 字节): {shared_alice[:8].hex()}")

# HKDF 派生会话密钥
session_key = HKDF(
    algorithm=hashes.SHA256(),
    length=32,
    salt=b"HKDF salt",
    info=b"handshake data v1",
).derive(shared_alice)

print(f"会话密钥 (前 8 字节): {session_key[:8].hex()}")

使用 cryptography 库的通用 ECDH:

PYTHON
from cryptography.hazmat.primitives.asymmetric import ec

# P-256 (NIST 曲线)
alice_private = ec.generate_private_key(ec.SECP256R1())
bob_private = ec.generate_private_key(ec.SECP256R1())

# 交换公钥
shared_alice = alice_private.exchange(ec.ECDH(), bob_private.public_key())
shared_bob = bob_private.exchange(ec.ECDH(), alice_private.public_key())

print(f"P-256 共享密钥: {shared_alice == shared_bob}")
print(f"共享密钥长度: {len(shared_alice)} 字节 (32 = 256 位)")

# P-384
alice_p384 = ec.generate_private_key(ec.SECP384R1())
bob_p384 = ec.generate_private_key(ec.SECP384R1())
shared = alice_p384.exchange(ec.ECDH(), bob_p384.public_key())
print(f"P-384 共享密钥长度: {len(shared)} 字节 (48 = 384 位)")

四、前向保密(Forward Secrecy / Perfect Forward Secrecy)

4.1 概念

CODE
前向保密 (FS/PFS):
    如果长期私钥被泄露,之前的会话密钥仍然安全。
    
没有前向保密的问题 (TLS 1.2 RSA 密钥交换):
    1. 客户端用服务器 RSA 公钥加密 Pre-Master Secret
    2. 服务器用 RSA 私钥解密
    3. 攻击者如果获得 RSA 私钥 → 可以解密所有历史流量
    
有前向保密的方案 (ECDHE/DHE):
    1. 每次会话生成临时 DH/ECDH 密钥对
    2. 服务器用长期 RSA/ECDSA 私钥签名临时公钥(认证)
    3. 双方完成 DH 交换,得到共享密钥
    4. 会话结束后立即销毁临时私钥
    5. 即使长期私钥泄露 → 无法恢复临时 DH 私钥 → 无法解密历史流量

4.2 前向保密的重要性

CODE
场景: 你的 TLS 证书 RSA 私钥被盗(例如通过供应链攻击)
    无 FS: 攻击者可以解密所有过去两年的加密流量
    有 FS: 攻击者只能解密未来的流量(直到用户更换证书)

现代系统强制要求前向保密:
    TLS 1.3: 只支持 (EC)DHE (有前向保密)
    Signal Protocol: 每次消息都有前向保密 (三重 Diffie-Hellman + Double Ratchet)
    WireGuard: 基于 Noise 协议,有前向保密
    SSH: 默认使用 ECDHE 有前向保密

4.3 双棘轮(Double Ratchet)算法

CODE
Signal Protocol 的核心 (前向保密 + 后向保密):

    初始共享密钥 = X3DH (三重 DH)
    
    之后每条消息:
        1. DH 棘轮: 定期更换 DH 密钥对
        2. 对称密钥棘轮: 用 HKDF 从旧密钥派生新密钥
        3. 销毁旧密钥
        
    结果:
        每个消息密钥独立
        泄露任一密钥仅影响该消息及其后消息
        之前的消息仍安全 (前向保密)

五、认证密钥交换:从 DH 到 (EC)DHE

5.1 基本 DH 的问题

CODE
原始 DH 缺少认证:
    攻击者可以进行中间人攻击
    你不知道你在和谁交换密钥

解决方案: 认证 DH 公钥

5.2 DHE(带签名的 DH,TLS 1.2)

CODE
TLS 1.2 DHE_RSA_WITH_AES_128_GCM_SHA256:

1. 客户端发送 ClientHello (支持的密码套件)
2. 服务器回应:
    a. ServerHello (选择 DHE)
    b. 证书 (含 RSA 公钥)
    c. ServerKeyExchange = (p, g, g^b mod p) 的 RSA 签名
3. 客户端:
    a. 验证证书(信任链)
    b. 验证签名(服务器公钥验证 (p, g, g^b) 的签名)
    c. 生成自己的 DH 公钥 g^a mod p
    d. 发送给服务器
4. 服务器收到 g^a,计算 g^(ab) mod p
5. 双方派生会话密钥

密钥交换 = DH(有前向保密)
认证 = RSA 签名(防止中间人)

5.3 ECDHE(椭圆曲线版本,TLS 1.2/1.3)

CODE
与 DHE 类似,使用 ECDH(如 X25519, P-256)替代 DH:
    - 速度快 10-100 倍
    - 公钥更小 (32 vs 256 字节)
    - 现代系统默认

TLS 1.3 只支持 ECDHE/DHE(强制前向保密)
    不支持 RSA 密钥交换

TLS 1.2 抓包示例中的 KeyExchange:

BASH
# 查看服务器支持的密钥交换方法
openssl s_client -connect example.com:443 -tls1_2 -cipher EDH+aRSA:AES128-GCM-SHA256
openssl s_client -connect example.com:443 -tls1_2 -cipher ECDHE+RSA+AES128-GCM-SHA256

# TLS 1.3
openssl s_client -connect example.com:443 -tls1_3
# 查看协商的密钥交换曲线 (X25519/P-256/P-384)

六、X3DH(扩展三重 DH,Signal Protocol)

X3DH(Extended Triple Diffie-Hellman)是 Signal Protocol 的密钥协商方案,用于在异步环境中建立端到端加密会话。

CODE
X3DH 提供:
    前向保密 (Forward secrecy)
    后向保密 (Post-compromise security)
    异步密钥协商(无需在线同时)
    身份认证

协议流程(简化):

Alice 的长期身份密钥 (IKa)
Alice 的签名预密钥 (SPKa) = 签名密钥, 签名(SHA256(SPKa), IKa)
Alice 的一次性预密钥 (OPKa) = 可选

Bob 的长期身份密钥 (IKb)
Bob 的签名预密钥 (SPKb)
Bob 的一次性预密钥 (OPKb)

Alice 向 Bob 发送初始消息:
    1. Alice 生成临时 ECDH 密钥 EKa
    2. 计算 4 个 DH 共享:
        DH1 = DH(IKa, SPKb)
        DH2 = DH(EKa, IKb)
        DH3 = DH(EKa, SPKb)
        DH4 = DH(EKa, OPKb) (如果有 OPK)
    3. SK = KDF(DH1 || DH2 || DH3 || DH4)
    4. 发送 (IKa, EKa, 可选 OPK 标识, 加密消息)

Bob 收到后:
    1. 加载自己的 IKb, SPKb, 对应 OPKb
    2. 计算同样的 4 个 DH 共享
    3. 得到相同的 SK

之后使用 Double Ratchet 进行后续消息加密

X3DH 的核心创新:通过预发布预密钥,实现异步密钥协商(接收方不需要在线)。


七、实际部署:DH 参数的常见漏洞

7.1 Logjam 攻击(CVE-2015-4000)

CODE
漏洞原理:
    许多服务器使用相同的 512/1024 位 DH 群参数
    DLP 计算在同一群中只需进行一次
    NFS 预计算 → 对所有使用相同群的服务器可行

影响:
    2015 年: 约 8% 的 HTTPS 服务器使用 512 位可破群
    NSA 可能已预计算了常见的 1024 位群

防御:
    ✅ 使用 2048 位及以上的 DH 群 (modp2048 及以上)
    ✅ 使用 ECDHE (椭圆曲线) 替代 DHE
    ✅ 使用标准群参数,不要自定义

7.2 弱生成元(小 subgroup 攻击)

CODE
如果生成元 g 的阶不是大质数 q,而是小值:
    攻击者可以在子群中求解离散对数
    → 恢复私钥的一部分

防御:
    检查 g 的阶是大质数 q
    使用标准群 (RFC 3526/7919)
    使用安全质数 p = 2q + 1

7.3 固定私钥

CODE
如果服务器从不轮换 DH 私钥:
    → 同一 DH 公钥被多次使用
    → 攻击者可以对长期使用的公钥进行离线攻击

防御:
    每次会话生成新的临时 DH 密钥对
    TLS 的 (EC)DHE 默认就是如此

7.4 不验证对方公钥

CODE
无签名认证的 DH = 纯 DH = 容易 MITM

防御:
    ✅ 使用证书签名 DH 公钥 (TLS)
    ✅ 使用预共享对称密钥认证 (PSK)
    ✅ 使用口令认证 (PAKE)
    ✅ 使用长期身份密钥签名临时 DH 公钥 (Signal X3DH)

八、完整 HTTPS 密钥交换示例

8.1 TLS 1.2 ECDHE 握手(简化)

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

8.2 TLS 1.3 密钥交换(更简洁)

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

8.3 Python + cryptography 库简化的 TLS 握手

PYTHON
"""
简化的密钥交换示例(无网络连接,仅演示密码学部分)
"""
from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey
from cryptography.hazmat.primitives.asymmetric.ed25519 import (
    Ed25519PrivateKey, Ed25519PublicKey
)
from cryptography.hazmat.primitives.kdf.hkdf import HKDF
from cryptography.hazmat.primitives import hashes, serialization

# ============= 服务器初始化 =============
# 长期身份密钥 (用于签名, 类似证书)
server_identity = Ed25519PrivateKey.generate()
server_identity_pub = server_identity.public_key()

# 服务器预加载的 DH 参数(每次握手不同)
def server_generate_ephemeral():
    return X25519PrivateKey.generate()

# ============= 客户端初始化 =============
client_identity = Ed25519PrivateKey.generate()

# ============= 握手 =============
# 1. 服务器生成临时 ECDHE 密钥对, 签名
server_eph = server_generate_ephemeral()
server_eph_pub_bytes = server_eph.public_key().public_bytes(
    encoding=serialization.Encoding.Raw,
    format=serialization.PublicFormat.Raw
)

# 签名临时公钥(防止 MITM)
signature = server_identity.sign(server_eph_pub_bytes)

# 2. 客户端验证签名,生成自己的 ECDHE 密钥对
# 在实际 TLS 中,客户端先验证服务器证书链
client_eph = X25519PrivateKey.generate()

try:
    # 验证服务器临时公钥的签名(需要预存服务器身份公钥)
    server_identity_pub.verify(signature, server_eph_pub_bytes)
    print("签名验证: 通过")
except Exception:
    print("签名验证: 失败 - 可能中间人攻击")
    raise

# 3. 客户端计算共享密钥
server_eph_pub_received = b""  # 实际从网络接收
from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PublicKey
server_eph_pub_received = X25519PublicKey.from_public_bytes(server_eph_pub_bytes)

# 4. 实际 ECDH 交换
client_shared = client_eph.exchange(server_eph_pub_received)

# 5. 服务器收到客户端公钥后
client_eph_pub_bytes = client_eph.public_key().public_bytes(
    encoding=serialization.Encoding.Raw,
    format=serialization.PublicFormat.Raw
)
client_eph_pub = X25519PublicKey.from_public_bytes(client_eph_pub_bytes)
server_shared = server_eph.exchange(client_eph_pub)

print(f"客户端共享: {client_shared.hex()}")
print(f"服务器共享: {server_shared.hex()}")
print(f"相同? {client_shared == server_shared}")

# 6. 用 HKDF 派生会话密钥
def derive_session_key(shared, salt, info):
    return HKDF(
        algorithm=hashes.SHA256(),
        length=32,
        salt=salt,
        info=info,
    ).derive(shared)

client_key = derive_session_key(client_shared, b"tls 1.3 salt", b"server write key")
server_key = derive_session_key(server_shared, b"tls 1.3 salt", b"server write key")

print(f"会话密钥匹配? {client_key == server_key}")

九、量子攻击与后量子密钥交换

9.1 Shor 算法的威胁

CODE
Shor 算法可在 O(log n)^3 量子时间内求解:
    1. 大整数分解 → 破 RSA
    2. 离散对数 → 破 DH, DSA, ElGamal
    3. 椭圆曲线离散对数 → 破 ECDH, ECDSA, Ed25519

对于所有经典 DH/ECDH, Shor 算法都可破解:
    X25519: 约需 2500 万逻辑量子比特
    secp256k1: 同样可破
    RSA-2048: 约需 2000 万逻辑量子比特

估计: 2030s 可能出现实用的 Shor 机器

9.2 NIST 后量子密钥交换标准(2024)

算法 类型 公钥 密文 安全性
CRYSTALS-Kyber-768 格密码 1184 B 1088 B AES-128
CRYSTALS-Kyber-1024 格密码 1568 B 1568 B AES-256

应用状态(2024):

CODE
已部署:
    Chrome/Edge: X25519 + Kyber-768
    Firefox: X25519 + Kyber-768
    TLS 1.3 + OpenSSL 3.2+: 支持 X25519Kyber768Draft00
    
混合模式:
    传统 (X25519) + 后量子 (Kyber-768) 并行
    任一算法安全 → 整个密钥交换安全
    
未来:
    Kyber 将被标准化为 TLS 1.3 的默认密钥交换
    SSH、WireGuard、Signal 等将陆续迁移

9.3 为什么要用混合模式?

CODE
X25519Kyber768:
    共享密钥 = X25519_shared XOR Kyber768_shared
    
安全性:
    如果 X25519 被量子破解 → Kyber-768 仍安全
    如果 Kyber-768 有密码分析缺陷 → X25519 仍安全
    双保险直到后量子密码学成熟

十、密码学协议中的 DH/ECDH 速查

10.1 各协议使用情况

协议 密钥交换方法 曲线/群 前向保密
TLS 1.0/1.1 RSA / DHE / ECDHE modp/secp256r1 可选
TLS 1.2 RSA / DHE / ECDHE modp2048/P-256/X25519 可选
TLS 1.3 (EC)DHE 强制 X25519/P-256/P-384 ✅ 强制
TLS 1.3 (混合) X25519 + Kyber-768 现代 ✅ 量子安全
SSH curve25519-sha256@libssh.org X25519 ✅
Signal X3DH + Double Ratchet X25519 ✅ 每条消息
WireGuard Noise_IKpsk2 X25519 ✅
IPsec (IKEv2) ECDHE P-256/P-384 ✅
PGP/GPG ElGamal / ECDH secp256k1/P-256 ⚠️ 取决于实现

10.2 SSH 中的密钥交换

BASH
# 查看支持的 KEX 算法
ssh -Q kex

# 推荐配置 (~/.ssh/config)
Host *
    KexAlgorithms curve25519-sha256@libssh.org,diffie-hellman-group-exchange-sha256
    Ciphers chacha20-poly1305@openssh.com,aes256-gcm@openssh.com,aes128-gcm@openssh.com
    MACs hmac-sha2-512-etm@openssh.com,hmac-sha2-256-etm@openssh.com

# 服务器配置 (/etc/ssh/sshd_config)
KexAlgorithms curve25519-sha256@libssh.org,diffie-hellman-group16-sha512,diffie-hellman-group18-sha512

10.3 TLS 配置最佳实践

NGINX
# nginx TLS 1.2/1.3 配置
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers off;

# TLS 1.3 默认就是好的
ssl_conf_command Ciphersuites TLS_AES_256_GCM_SHA384:TLS_CHACHA20_POLY1305_SHA256:TLS_AES_128_GCM_SHA256;

# TLS 1.2 安全配置(仅保留前向保密的套件)
ssl_ciphers 'ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256';
ssl_ecdh_curve X25519:P-256:P-384;  # 首选曲线

十一、CTF 中的 DH/ECDH

11.1 经典题目

题目类型 说明 解题思路
小 p 攻击 p 太小(< 1000 位) 直接计算离散对数 (SageMath discrete_log)
弱生成元 g 的阶是小质数 Pohlig-Hellman 分解
重用私钥 相同 a 用于多次交换 从已知值恢复私钥
子群约束 p-1 有小因子 Lim-Lee 小子群攻击
不验证对方公钥 MITM 场景 构造伪造公钥

11.2 小 p 攻击示例(SageMath)

PYTHON
"""
已知 p, g, A = g^a mod p
小 p (< 约 500 位) → 直接求离散对数

SageMath 代码 (Sage 是 CTF 常用工具):

    p = 13407807929... (给定的质数)
    g = 5
    A = 123456789... (公钥)
    
    F = GF(p)
    a = discrete_log(F(A), F(g))
    print(f"私钥 a = {a}")

Python sympy 等效 (可能较慢):
"""
from sympy.ntheory.residue_ntheory import discrete_log

p = 23  # 小质数
g = 5
A = 8  # g^a mod p = 8

try:
    a = discrete_log(p, A, g)
    print(f"私钥: {a}")
    print(f"验证: {pow(g, a, p)} == {A}? {pow(g, a, p) == A}")
except Exception:
    print("计算失败")

11.3 Pohlig-Hellman 分解

CODE
当 p-1 只有小因子时 (p-1 = q1 * q2 * ... * qk):
    可以对每个小 qi 分别求解离散对数
    然后用中国剩余定理 (CRT) 合并
    → O(sum(sqrt(qi))) 复杂度 → 如果所有 qi 都小,可破

防御:
    p-1 必须有一个大质因子
    使用安全质数 p = 2q + 1 (q 是大质数)
    使用标准群参数

十二、常见问题 FAQ

Q1: DH 和 ECDH 有什么区别?

答: 数学结构不同。DH 在有限域 Z_p 上工作;ECDH 在椭圆曲线上工作。相同安全强度下,ECDH 的密钥大小、计算速度都优于 DH。现代系统默认用 ECDH。

Q2: 为什么 DH 共享密钥还要用 HKDF/KDF?

答: DH 的原始共享密钥是一个群元素(对 ECDH 是曲线点的 x 坐标),具有代数结构,不是均匀随机。KDF(如 HKDF)将其转换为均匀随机的比特串,并可以分离开多个密钥(加密/认证密钥)。

Q3: 什么是前向保密?重要吗?

答: 每次会话使用临时密钥,即使长期私钥泄露也不影响历史流量。非常重要!现代系统(TLS 1.3、SSH、Signal、WireGuard)都强制要求前向保密。

Q4: X25519、P-256、secp256k1 应该选哪个?

答:

  • X25519: 现代首选,快、小、安全(TLS 1.3、Signal、WireGuard)
  • P-256 (secp256r1): NIST 标准,FIPS 合规,最广泛支持
  • secp256k1: 主要用于 Bitcoin/Ethereum 等区块链,性能好但非通用标准

Q5: DH/ECDH 能加密消息吗?

答: 不能。DH/ECDH 只是密钥协商,用于生成共享密钥。实际加密需要配合对称加密(如 AES-GCM、ChaCha20-Poly1305)。

Q6: 如果量子计算机可以破 DH,我们现在应该怎么办?

答: 短期(< 10 年): 继续使用 ECDH(X25519/P-256),因为 Shor 级别的量子计算机还不存在。长期: 关注后量子密码学(Kyber 等)。混合模式(X25519 + Kyber-768)已在 Chrome/Firefox/OpenSSL 中部署,是过渡方案。


总结

Diffie-Hellman 是现代密码学的基石,要点:

1. 核心原理

CODE
公共参数: (p, g) 或 曲线(E, G)
私钥: a (Alice), b (Bob)
公钥: A = g^a mod p 或 a*G
共享: g^(ab) mod p 或 (a*b)*G
    ↓ 双方相同
    HKDF/KDF
    ↓
会话密钥 (AES 密钥等)

2. 演化历史

CODE
1976: DH 概念提出 (Whitfield Diffie & Martin Hellman)
1985: ECC 椭圆曲线密码学 (Neal Koblitz & Victor Miller)
2006: Curve25519 (Daniel J. Bernstein)
2013: Signal X3DH (基于 ECDH 的异步密钥交换)
2015: Logjam 攻击揭示 DH 参数漏洞
2018: TLS 1.3 强制前向保密 (ECDH)
2024: NIST Kyber 后量子标准,X25519 + Kyber 混合上线

3. 选择建议

场景 推荐 说明
通用 TLS/SSL X25519 或 P-256 TLS 1.3 默认曲线
高安全需求 X448 或 P-384 192 位安全强度
SSH curve25519-sha256@libssh.org OpenSSH 默认
Signal/WhatsApp X25519 (X3DH + Double Ratchet) 端到端加密
WireGuard X25519 (Noise IK) 极简 VPN 协议
长期加密 (量子前) X25519 + Kyber768 (混合) TLS 1.3 后量子
CTF 题目 Pohlig-Hellman / 小群攻击 通常有参数漏洞

4. 实现要点

  • ✅ 使用标准库(OpenSSL / Go crypto / Python cryptography / libsodium)
  • ✅ 不要自己实现椭圆曲线数学
  • ✅ 前向保密:每次会话用新的临时密钥
  • ✅ 认证:用签名(ECDSA/Ed25519/RSA-PSS)验证对方公钥
  • ✅ 密钥派生:用 HKDF 从共享密钥派生出多个专用密钥
  • ❌ 不要用小的自定义 DH 群参数(< 2048 位危险)
  • ❌ 不要用无认证的纯 DH(容易 MITM)
  • ❌ 不要把 DH 共享密钥直接当作 AES 密钥(必须经过 KDF)