1
AES-128：经典暴力搜索 2^128 次 → Grover 搜索 2^64 次
2
AES-256：经典暴力搜索 2^256 次 → Grover 搜索 2^128 次
3

4
结论：AES-256 在量子时代仍然安全（2^128 次搜索不可行）
5
      AES-128 需要升级到 AES-256

1
# 格的简单示例：二维格
2
# 格 = 基向量的所有整数线性组合
3
import numpy as np
4

5
# 两个基向量
6
b1 = np.array([2, 1])  # 基向量 1
7
b2 = np.array([1, 3])  # 基向量 2
8

9
# 生成格点
10
lattice_points = []
11
for i in range(-3, 4):
12
    for j in range(-3, 4):
13
        point = i * b1 + j * b2
14
        lattice_points.append(point)
15

16
# 格上的困难问题：给定目标点，找最近的格点
17
# 这就是 CVP (Closest Vector Problem) ——Kyber 的安全基础
18
target = np.array([3.7, 2.3])
19
# 暴力搜索在低维可行，但在 1000+ 维不可行

1
# 使用 liboqs 的 Kyber 密钥封装
2
# 安装
3
pip install liboqs-python
4

5
# 运行 Kyber768 密钥封装
6
python3 -c "
7
import oqs
8
with oqs.KeyEncapsulation('Kyber768') as kem:
9
    pk = kem.generate_keypair()
10
    ct, ss_enc = kem.encap_secret(pk)
11
    ss_dec = kem.decap_secret(ct)
12
    assert ss_enc == ss_dec
13
    print(f'Shared secret: {ss_enc.hex()[:32]}...')
14
    print(f'Ciphertext size: {len(ct)} bytes')
15
    print(f'Public key size: {len(pk)} bytes')
16
"

1
二维格示例：
2
    ·   ·   ·   ·
3
    ·   ·   ·   ·
4
    ·   ·   ·   ·
5
    ·   ·   ·   ·
6

7
每个点都是基向量的整数线性组合

1
标准线性方程组（无误差）：       带误差的线性方程组（LWE）：
2
4x + 3y = 17                    4x + 3y ≈ 17 + e₁
3
2x + 5y = 19                    2x + 5y ≈ 19 + e₂
4
7x + 1y = 23                    7x + 1y ≈ 23 + e₃
5

6
解法：高斯消元法                  解法：？没有已知的高效经典算法
7
                                  量子计算机也无法有效解决

1
# 使用 liboqs-python 测试 Kyber
2
from oqs import KeyEncapsulation
3

4
# 密钥生成
5
kem = KeyEncapsulation("Kyber768")
6
public_key = kem.generate_keypair()
7

8
# 封装（替代 ECDH 密钥交换）
9
ciphertext, shared_secret_enc = kem.encap_secret(public_key)
10

11
# 解封装
12
shared_secret_dec = kem.decap_secret(ciphertext)
13

14
assert shared_secret_enc == shared_secret_dec

1
# 使用 liboqs-python 测试 Dilithium
2
from oqs import Signature
3

4
# 密钥生成
5
signer = Signature("Dilithium3")
6
public_key = signer.generate_keypair()
7

8
# 签名
9
message = b"Hello, post-quantum world!"
10
signature = signer.sign(message)
11

12
# 验证
13
verifier = Signature("Dilithium3")
14
is_valid = verifier.verify(message, signature, public_key)
15
assert is_valid

1
# 混合密钥交换：ECDH + Kyber
2
from cryptography.hazmat.primitives.asymmetric import ec
3
from oqs import KeyEncapsulation
4
import hashlib
5

6
# 1. 传统 ECDH 密钥交换
7
ecdh_private = ec.generate_private_key(ec.SECP256R1())
8
ecdh_shared = ecdh_private.exchange(ec.ECDH(), peer_ecdh_public)
9

10
# 2. 后量子 Kyber 密钥封装
11
kem = KeyEncapsulation("Kyber768")
12
kyber_ciphertext, kyber_shared = kem.encap_secret(peer_kyber_pk)
13

14
# 3. 混合共享密钥 = KDF(ECDH共享 || Kyber共享)
15
hybrid_shared = hashlib.sha256(ecdh_shared + kyber_shared).digest()

1
TLS 1.3 PQC 混合密码套件：
2
X25519Kyber768Draft00 — Chrome 116+ 默认启用
3
X25519MLKEM768 — FIPS 203 发布后的标准名称
4

5
握手流程：
6
1. ClientHello 包含 X25519 + Kyber768 的公钥
7
2. ServerHello 返回 X25519 + Kyber768 的公钥
8
3. 两个密钥交换的共享密钥通过 KDF 混合
9
4. 即使 Kyber 被破解，X25519 仍然保护连接
10
5. 即使 X25519 被量子破解，Kyber 仍然保护连接

1
// Go: 密码学敏捷性设计示例
2
type CryptoSuite struct {
3
    KEM     string  // "X25519", "Kyber768", "X25519Kyber768"
4
    Sign    string  // "ECDSA-P256", "Dilithium3", "ECDSA-Dilithium"
5
    Symmetric string // "AES-256-GCM"
6
    MinLevel  int    // 最低安全等级（1-5）
7
}
8

9
var SupportedSuites = []CryptoSuite{
10
    {KEM: "X25519Kyber768", Sign: "ECDSA-Dilithium3", Symmetric: "AES-256-GCM", MinLevel: 3},
11
    {KEM: "Kyber768", Sign: "Dilithium3", Symmetric: "AES-256-GCM", MinLevel: 3},
12
    {KEM: "X25519", Sign: "ECDSA-P256", Symmetric: "AES-256-GCM", MinLevel: 1},
13
}

1
# 使用 oqs-provider 编译的 OpenSSL 配置混合 TLS
2
# 1. 安装 liboqs 和 oqs-provider
3
git clone https://github.com/open-quantum-safe/liboqs.git
4
cd liboqs && mkdir build && cd build
5
cmake -DCMAKE_INSTALL_PREFIX=/usr/local .. && make -j$(nproc) && sudo make install
6

7
# 2. 生成混合密钥对（Kyber768 + X25519）
8
openssl req -x509 -new -nodes \
9
  -newkey "kyber768:x25519" \
10
  -keyout hybrid-key.pem -out hybrid-cert.pem \
11
  -days 365 -subj "/CN=hybrid-test"
12

13
# 3. 启动混合 TLS 服务器
14
openssl s_server -cert hybrid-cert.pem -key hybrid-key.pem \
15
  -accept 4433 -www -groups "kyber768:x25519"

1
# 使用 liboqs + OpenSSL 3.x 生成 PQC 密钥对
2
openssl req -new -newkey kyber768 -keyout kyber.key -out kyber.csr
3

4
# 生成混合证书（ECDH + Kyber）
5
openssl req -new -newkey ec:p-256 -keyout hybrid.key \
6
    -addkey kyber768 -out hybrid.csr
7

8
# 查看混合证书
9
openssl x509 -in hybrid.crt -text -noout