Mathematics on kenji.blog

利用费马小定理的加密基础与实现

Fri, 11 Sep 2026 22:00:00 +0900

1. 引言：支撑现代密码学的数学奥秘

在现代数字社会，尤其是基于互联网的通信中，“加密”已经成为不可或缺的基础设施技术。我们在网络浏览器上通过HTTPS安全地浏览网站、在网上银行进行金融交易、在即时通讯应用上进行私密交流，这一切的背后，都是由基于高级数学理论的加密协议在发挥作用。其中发挥关键作用的是“公钥加密算法”，其代表就是 RSA加密。

包括RSA加密在内的许多加密算法的安全性与合理性，都极大地依赖于17世纪法国数学家皮埃尔·德·费马（Pierre de Fermat）发现的一个非常优美且强大的定理。那就是 费马小定理（Fermat’s Little Theorem）。此外，将其一般化的莱昂哈德·欧拉（Leonhard Euler）定理也在密码学理论中发挥了决定性作用。

本文将从基础开始全面解析，纯数学的发现——费马小定理，是如何被应用到现代实用的加密技术中，特别是在“素数测试”和“RSA加密”中的。本篇将是一份非常详细的技术指南，涵盖数学证明、加密与解密的机制，以及使用 C++ 和 Python 进行的具体算法实现。

2. 同余与模运算基础

要理解费马小定理，首先需要熟悉“模运算（同余式）”这一数学概念。模运算是一种关注除以某个固定数（称为模数）后所得“余数”的计算体系。因为类似于钟表表盘（12小时转一圈）的计算，所以也被称为“时钟算术”。

当整数 $a$ 和 $b$ 除以正整数 $n$ 的余数相等时，在数学上可以这样描述：

$$ a \equiv b \pmod n $$

这读作“在模 $n$ 下 $a$ 和 $b$ 同余”。例如，17 除以 5 的余数是 2，12 除以 5 的余数也是 2。因此，可以写成如下形式：

$$ 17 \equiv 12 \pmod 5 \equiv 2 \pmod 5 $$

在模运算中，常规的四则运算（加、减、乘）依然成立。

加法: 如果 $a \equiv b \pmod n$ 且 $c \equiv d \pmod n$，那么 $a + c \equiv b + d \pmod n$
减法: 如果 $a \equiv b \pmod n$ 且 $c \equiv d \pmod n$，那么 $a - c \equiv b - d \pmod n$
乘法: 如果 $a \equiv b \pmod n$ 且 $c \equiv d \pmod n$，那么 $a \times c \equiv b \times d \pmod n$
幂运算: 如果 $a \equiv b \pmod n$，那么对于任意自然数 $k$，都有 $a^k \equiv b^k \pmod n$

但是，关于除法则需要特别注意。通常情况下，即使 $a \times c \equiv b \times c \pmod n$，也不能直接将两边同时除以 $c$ 得到 $a \equiv b \pmod n$。这只有在 $c$ 和 $n$ 互质（最大公约数为1）的情况下才成立。这个“模逆元”的概念，在后文所述的RSA加密密钥生成中极其重要。

3. 费马小定理的数学背景与证明

掌握了模运算的基础后，让我们进入正题，来看费马小定理。

3.1 定理的定义

费马小定理的表述如下：

费马小定理 (Fermat’s Little Theorem) 设 $p$ 为一个素数，且 $a$ 是任意一个不是 $p$ 的倍数的整数（即 $a$ 和 $p$ 互质）。此时，以下同余式成立：
$$ a^{p-1} \equiv 1 \pmod p $$

另外，去掉“$a$ 不是 $p$ 的倍数”这一条件，将其表述为对所有整数 $a$ 都成立的形式也很常见。这种情况下，两边同时乘以 $a$，变成如下形式：

$$ a^p \equiv a \pmod p $$

3.2 通过具体例子进行验证

定理是否真的成立呢？让我们用具体的数字来验证一下。假设素数 $p = 5$。则 $p-1 = 4$。选择一个不是 $p$ 的倍数的整数作为 $a$。

当 $a = 2$ 时: $2^{5-1} = 2^4 = 16$。$16 \div 5 = 3$ 余 $1$。因此 $16 \equiv 1 \pmod 5$。（成立）
当 $a = 3$ 时: $3^{5-1} = 3^4 = 81$。$81 \div 5 = 16$ 余 $1$。因此 $81 \equiv 1 \pmod 5$。（成立）
当 $a = 4$ 时: $4^{5-1} = 4^4 = 256$。$256 \div 5 = 51$ 余 $1$。因此 $256 \equiv 1 \pmod 5$。（成立）

就像这样，无论选择什么样的 $a$（只要不是5的倍数），其4次方除以5的余数一定为1。这看起来像魔法，但其实源于素数所具有的优美性质。

3.3 定理的数学证明

为什么会成立这样的定理呢？这里介绍一种使用剩余类集合的优雅证明方法。

考虑集合 $S = \{1, 2, 3, \dots, p-1\}$。这些是除以 $p$ 后余数为 $1$ 到 $p-1$ 的整数的代表元。现在，考虑一个新集合 $T$，它是将 $S$ 中的每个元素都乘以与 $p$ 互质的整数 $a$ 得到的：

$$ T = \{1a, 2a, 3a, \dots, (p-1)a\} $$

考虑集合 $T$ 的各个元素除以 $p$ 的余数。令人惊讶的是，这些余数，虽然顺序可能发生改变，但它们组成的集合与原来的集合 $S$ 完全一致。这是因为：

$T$ 的元素不可能成为 $p$ 的倍数（因为 $a$ 和原来的元素都不是 $p$ 的倍数）。
在 $T$ 中，不存在在模 $p$ 下同余的两个不同元素。如果 $ia \equiv ja \pmod p$ （其中 $i \neq j$），因为 $a$ 和 $p$ 互质，所以可以除以 $a$，得到 $i \equiv j \pmod p$，这导致矛盾。

因此，$S$ 中所有元素的乘积，与 $T$ 中所有元素的乘积，在模 $p$ 下是同余的。

$$ (1a) \times (2a) \times \dots \times ((p-1)a) \equiv 1 \times 2 \times \dots \times (p-1) \pmod p $$

整理左边，因为有 $p-1$ 个 $a$，所以：

$$ a^{p-1} \cdot (p-1)! \equiv (p-1)! \pmod p $$

因为 $(p-1)!$ 与 $p$ 互质，所以两边可以同时除以 $(p-1)!$，最终导出以下定理：

$$ a^{p-1} \equiv 1 \pmod p $$

这就是费马小定理的证明。

4. 欧拉函数与欧拉定理

费马小定理是关于“素数 $p$”的定理，而将其推广到“任意正整数 $n$”的人，正是莱昂哈德·欧拉。要理解RSA加密，这种推广是必不可少的。

4.1 欧拉函数 $\phi(n)$

欧拉的totient函数（或称欧拉的 $\phi$ 函数） $\phi(n)$，是一个表示“从 $1$ 到 $n$ 的整数中，与 $n$ 互质的数的个数”的函数。

对于素数 $p$，从 $1$ 到 $p-1$ 的所有整数都与 $p$ 互质，因此 $\phi(p) = p - 1$。
对于两个不同的素数 $p, q$，它们的乘积 $n = p \times q$，$\phi(n)$ 可以通过一个非常简单的公式求出： $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

这个性质，构成了RSA加密中密钥生成的核心逻辑。

4.2 欧拉定理

欧拉对费马小定理进行了如下的推广。

欧拉定理 (Euler’s Theorem) 对于正整数 $n$ 以及与其互质的整数 $a$，以下等式成立：
$$ a^{\phi(n)} \equiv 1 \pmod n $$

如果 $n$ 是素数 $p$，那么 $\phi(p) = p - 1$，此时就变成了费马小定理本身（$a^{p-1} \equiv 1 \pmod p$）。换句话说，费马小定理只是欧拉定理的一个特例。

5. 寻找巨大的素数：费马素性测试

在加密技术（如RSA加密或Diffie-Hellman密钥交换等）中，需要高速地找出长达数百位的“巨大素数”。然而，为了判断一个巨大的数 $N$ 是否为素数，如果尝试用 $2$ 到 $\sqrt{N}$ 之间的所有数去试除，这种“试除法”可能需要耗费宇宙寿命般的时间。

于是，利用费马小定理逆向思维的“概率素性测试”——费马测试（Fermat Primality Test） 登场了。

5.1 什么是概率素性测试

根据费马小定理，如果 $p$ 是素数，那么对于任意的 $a$ ($1 < a < p$)，$a^{p-1} \equiv 1 \pmod p$ 必定成立。取其逆否命题，可以说：“如果对于某个 $a$，$a^{p-1} \not\equiv 1 \pmod p$，那么 $p$ 绝对不是素数（是合数）”。

因此，如果想判断 $N$ 是否为素数，可以随机选取几个 $a$，计算 $a^{N-1} \pmod N$ 看是否等于 $1$。如果只要有一次得出除 $1$ 以外的结果，就可以确定 $N$ 是合数。如果尝试多次结果都为 $1$，就可以以很高的概率判断 $N$ “可能是一个素数”。

5.2 算法解说与流程图

费马测试的算法如下：

flowchart TD Start["开始"] --> Input["输入待判断的数 p 和测试次数 k"] Input --> LoopStart["循环 i = 0 到 k-1"] LoopStart --> Condition{"i < k ?"} Condition -- "Yes" --> RandomA["在 1 < a < p-1 范围内随机选取整数 a"] RandomA --> Calc["计算模幂 a^(p-1) mod p"] Calc --> CheckPrime{"结果是 1 吗？"} CheckPrime -- "No" --> ReturnComposite["p 是合数（确定）"] CheckPrime -- "Yes" --> Increment["i 递增"] Increment --> Condition Condition -- "No" --> ReturnPrime["p 可能是素数（概率性）"] ReturnComposite --> End["结束"] ReturnPrime --> End

5.3 卡迈克尔数（伪素数）的陷阱

费马测试速度极快，但也存在一个重大的缺点。那就是存在这样一种恶魔般的数：虽然是合数，但对于所有的 $a$，都满足 $a^{N-1} \equiv 1 \pmod N$。这被称为 卡迈克尔数 (Carmichael numbers)。最小的卡迈克尔数是 $561$ ($3 \times 11 \times 17$)。

因为卡迈克尔数的存在，单纯的费马测试无法做出绝对的素数判定。因此，在实际的加密系统（如OpenSSL等）中，标准使用的是改进了费马测试的 米勒-拉宾（Miller-Rabin）素性测试。米勒-拉宾测试能够识破卡迈克尔数，从而将误判的概率实质上降至零。

5.4 高速模幂运算（反复平方法）

在素性测试算法中需要计算 $a^{N-1} \pmod N$，但当 $N$ 非常巨大时，$a^{N-1}$ 的位数将是天文数字，计算机的内存根本装不下。解决这个问题的方法是 反复平方法（Exponentiation by Squaring） 或模幂运算。通过在计算的每一步都取模（mod N），始终保持数值小于 $N$，从而实现极高速（计算复杂度为 $O(\log N)$）的计算。

6. 素性测试与模幂的实现

那么，让我们用C++和Python来实现费马素性测试和反复平方法吧。

6.1 C++ 实现

在C++中，标准的整数类型很容易溢出，因此处理巨大的数字通常需要高精度整数库（如GMP等），但这里为了理解算法，展示在64位整数（unsigned long long）范围内的实现。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


#include <iostream>
#include <random>

using namespace std;

// 高速模幂运算 (a^b mod m) - 反复平方法
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // 当 b 的最低位为 1 时，结果乘以 a
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // 为防止溢出扩展为128位
 }
 // a 自身平方
 a = (__int128)a * a % m;
 // b 右移（减半）
 b /= 2;
 }
 return result;
}

// 费马素性测试
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

 random_device rd;
 mt19937_64 gen(rd());
 uniform_int_distribution<unsigned long long> dis(2, p - 2);

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // 如果 a^(p-1) mod p 不等于 1，则是合数
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // 可能是素数
}

int main() {
 unsigned long long num = 1000000007; // 已知的素数
 if (fermat_is_prime(num, 10)) {
 cout << num << " is probably prime." << endl;
 } else {
 cout << num << " is composite." << endl;
 }
 return 0;
}

6.2 Python 实现

Python的内置整数类型支持高精度整数，所以完全不需要担心溢出问题。此外，Python的内置函数 pow(a, b, m) 内部就是使用了反复平方法，因此速度非常快。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


import random

def fermat_is_prime(p, iterations=5):
 """
 使用费马素性测试进行概率素数判断
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # 在 2 到 p-2 之间随机选取数字 a
 a = random.randint(2, p - 2)
 # 计算 a^(p-1) mod p。内置的 pow 函数速度很快。
 if pow(a, p - 1, p) != 1:
 return False # 确定是合数

 return True # 可能是素数

# 测试
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} 可能是素数。")
else:
 print(f"{number_to_test} 是合数。")

7. 在RSA加密中的应用：费马与欧拉的结晶

费马小定理（以及欧拉定理）最伟大的应用领域，就是1977年由Rivest、Shamir和Adleman三人开发的 RSA加密。 RSA加密是一种革命性的“公钥加密”系统，它实现了一种机制：用于加密的密钥（公钥）对全世界公开，而用于解密的密钥（私钥）只有接收者本人知晓。

这种非对称性，是基于“对巨大的合数进行质因数分解极其困难”的计算复杂性安全保证的。

7.1 RSA加密机制（密钥生成、加密、解密）

让我们通过Mermaid的时序图来了解RSA加密的整体通信流程。

sequenceDiagram participant Alice["爱丽丝 (接收者)"] participant Bob["鲍勃 (发送者)"] Alice->>Alice: "生成巨大的素数 p, q" Alice->>Alice: "计算 N = p * q, φ(N) = (p-1)(q-1)" Alice->>Alice: "计算公钥 e 和私钥 d (e*d ≡ 1 mod φ(N))" Alice->>Bob: "发送公钥 (N, e)" Note over Bob: "准备明文 M (M < N)" Bob->>Bob: "计算密文 C = M^e mod N" Bob->>Alice: "发送密文 C" Alice->>Alice: "计算明文 M = C^d mod N 进行解密"

以下将解说数学上的详细步骤。

步骤1：密钥生成（接收者爱丽丝的操作）

随机生成两个巨大的素数 $p$ 和 $q$（这里会用到前面提到的素性测试算法）。
计算它们的乘积 $N = p \times q$。这个 $N$ 是公开的。
利用欧拉函数，计算 $\phi(N) = (p-1)(q-1)$。
选择一个与 $\phi(N)$ 互质的整数 $e$ （公开指数）（通常使用 $e = 65537$）。
计算 $e$ 的模逆元 $d$ （私有指数）。即，找到满足以下条件的 $d$： $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ 这个计算需要用到 扩展欧几里得算法。

至此，公钥为 $(N, e)$，私钥为 $(N, d)$。（$p, q, \phi(N)$ 应立即销毁或严格保密）。

步骤2：加密（发送者鲍勃的操作）

假设鲍勃想给爱丽丝发送消息 $M$（$M$ 是字符数字化后的数值，且 $0 \le M < N$）。鲍勃使用爱丽丝的公钥 $(N, e)$，进行如下计算生成密文 $C$：

$$ C \equiv M^e \pmod N $$

然后通过网络将这个 $C$ 发送给爱丽丝。

步骤3：解密（接收者爱丽丝的操作）

收到密文 $C$ 的爱丽丝，使用只有自己知道的私钥 $d$ 进行如下计算：

$$ M' \equiv C^d \pmod N $$

令人惊奇的是，这个计算结果 $M'$ 与原始消息 $M$ 完全一致。

7.2 为什么能够解密？（数学证明）

在这里，费马小定理（欧拉定理）发挥了真正的价值。为什么 $C^d \pmod N$ 能够还原成 $M$ 呢？

展开解密的公式。因为 $C \equiv M^e \pmod N$，所以：

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

在密钥生成步骤中，我们选择 $d$ 使得 $e \cdot d \equiv 1 \pmod{\phi(N)}$。这意味着存在一个整数 $k$，可以写成如下形式：

$$ e \cdot d = 1 + k \cdot \phi(N) $$

将此代入上面的公式：

$$ M^{ed} = M^{1 + k \cdot \phi(N)} = M \cdot M^{k \cdot \phi(N)} = M \cdot (M^{\phi(N)})^k \pmod N $$

此时，欧拉定理 ($M^{\phi(N)} \equiv 1 \pmod N$) 就登场了。（※严格来说，这要求 $M$ 和 $N$ 互质，但在RSA中，$M$ 和 $N$ 不互质的概率是天文数字级别的低，而且利用中国剩余定理可以证明即使不互质等式也成立）。

应用欧拉定理，由于 $M^{\phi(N)} \equiv 1$，因此：

$$ M \cdot (1)^k \equiv M \pmod N $$

漂亮地还原了 $M$！几百年前费马和欧拉发现的数字规律，完美地保证了现代数字通信的机密性。

8. RSA加密的玩具实现 (Python)

仅凭理论可能难以有直观感受，所以我们用Python来实际实现一下RSA加密的密钥生成、加密、解密的过程。这是一个用于教学的“玩具实现（Toy Implementation）”，但所使用的数学原理与实际完全相同。

求模逆元 $d$ 的“扩展欧几里得算法”也会包含在实现中。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86


import random

# 求最大公约数
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# 扩展欧几里得算法 (求 ax + by = gcd(a,b) 中的 x, y)
# 用于寻找 e*d ≡ 1 (mod φ(N)) 中的 d
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('逆元不存在')
 else:
 return x % phi

# 素数生成函数（简易版：生成较小的素数）
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # 用简易判断替代前面提到的费马测试
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# RSA 密钥生成
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # 防止 p 和 q 相同
 while p == q:
 q = generate_prime(bits)

 n = p * q
 phi = (p - 1) * (q - 1)

 # e 通常使用 65537 等素数，但这里随机选择
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # 计算私钥 d
 d = mod_inverse(e, phi)

 # 公钥 (e, n), 私钥 (d, n)
 return ((e, n), (d, n))

def encrypt(pk, plaintext):
 e, n = pk
 # 计算 plaintext^e mod n
 cipher = [pow(ord(char), e, n) for char in plaintext]
 return cipher

def decrypt(sk, ciphertext):
 d, n = sk
 # 计算 cipher^d mod n，并转换回字符
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# 运行示例
if __name__ == '__main__':
 print("--- RSA加密 玩具实现 ---")
 public_key, private_key = generate_keypair(bits=12) # 使用12位素数

 print(f"公钥 (e, n): {public_key}")
 print(f"私钥 (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\n原始消息: {message}")

 # 加密
 encrypted_msg = encrypt(public_key, message)
 print(f"密文: {encrypted_msg}")

 # 解密
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"解密后的消息: {decrypted_msg}")

运行这段代码，你会看到字符数组被转换成陌生的数字数组（密文），然后通过私钥又完美地恢复成了原始字符串。

9. 结语：数学之美与实用性的交汇点

17世纪皮埃尔·德·费马发现这个“小定理”时，没有人觉得这会有什么用处。费马本人也是出于纯粹的数学探求欲才去研究数论的。

然而，在大约300年后的20世纪70年代，计算机网络黎明期，作为确立安全通信协议不可或缺的加密技术，费马定理迎来了戏剧性的复苏。基于费马小定理的素性测试技术和基于欧拉定理的RSA加密，字面意义上支撑了现代的互联网基础设施。

我们每天不经意间发送的微信消息、在淘宝上的购物，这一切都在 $a^{p-1} \equiv 1 \pmod p$ 这个简单而优美的数学公式之上舞动。费马小定理告诉我们，无论数学多么抽象，总有一天它必然会为人类所用。

在学习编程和密码学理论时，理解其基础的数学结构，将成为深入理解那些作为黑盒提供的库的行为、并设计出更加安全的系统的强大武器。

格密码（Lattice-based cryptography）的数学直觉

Fri, 11 Sep 2026 21:00:00 +0900

1. 引言：后量子密码（PQC）的黎明与格密码的崛起

支撑现代社会数字基础设施的是以RSA密码和椭圆曲线密码（ECC）为首的公钥密码技术。这些密码方案的安全性建立在“整数分解问题”或“离散对数问题”等被认为使用传统经典计算机无法高效求解（需要指数级时间）的数学难题之上。

然而，彼得·秀尔（Peter Shor）在1994年提出的“Shor算法”在密码学界引起了轩然大波。该算法在数学上证明了，一旦大规模量子计算机问世，便能在多项式时间内解决整数分解问题和离散对数问题。这意味着目前被广泛使用的公钥密码在未来将变得完全可以被破解。

为了应对这种“量子计算机的威胁（Quantum Threat）”，亟需研究即使使用量子计算机也难以破解的新型密码方案。这就是被称为“后量子密码（Post-Quantum Cryptography: PQC）”或“抗量子计算密码”的领域。

PQC有几种有力的候选方案。包括基于哈希的密码、基于编码的密码、多变量多项式密码、同源密码等，其中目前最受瞩目、也是NIST（美国国家标准与技术研究院）PQC标准化进程核心的便是“格密码（Lattice-based cryptography）”。与其他方案相比，格密码的加解密处理速度非常快，而且具有被称为“从最坏情况复杂度（Worst-case complexity）归约到平均情况复杂度（Average-case complexity）”的特性，在密码学理论中拥有极强的安全性证明。

本文将从格密码的基础——“格（Lattice）”的数学定义出发，深入剖析格上的困难问题：SVP（最短向量问题）和CVP（最近向量问题），以及作为现代格密码心脏的“LWE问题（Learning With Errors）”，并结合数学公式、几何直觉以及具体的数值计算例子，进行透彻的讲解。

2. 格（Lattice）的数学定义与几何直觉

2.1 向量空间与格

在数学中，“格（Lattice）”是指在$n$维实向量空间 $\mathbb{R}^n$ 内规则排列的离散点的集合。它与线性代数中学习的向量空间（Vector Space）相似，但存在决定性的区别。向量空间是由基向量通过“实数系数”的线性组合表示的连续空间，而格则是通过基向量的“整数系数”的线性组合表示的离散空间。

让我们给出严谨的数学定义。考虑在$m$维实向量空间 $\mathbb{R}^m$ 中的 $n$ 个（$n \le m$）线性无关向量 $\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n$。将这些向量作为列向量构成的矩阵记为 $B = [\mathbf{b}_1, \mathbf{b}_2, \dots, \mathbf{b}_n] \in \mathbb{R}^{m \times n}$。这个 $B$ 被称为格的“基（Basis）”。

由这个基 $B$ 生成的格 $\mathcal{L}(B)$ 定义如下：

$$ \mathcal{L}(B) = \left\{ \sum_{i=1}^{n} x_i \mathbf{b}_i \mathrel{\bigg|} x_i \in \mathbb{Z} \right\} = \{ B \mathbf{x} \mid \mathbf{x} \in \mathbb{Z}^n \} $$

这里的重点是，系数 $x_i$ 被限定为整数 $\mathbb{Z}$，而不是实数 $\mathbb{R}$。因此，它并不是空间中无限存在的连续点，而是形成了像等距排列的交叉点一样的“离散点集”。

2.2 几何学意象

以二维平面 $\mathbb{R}^2$ 为例。如果我们选择基向量 $\mathbf{b}_1 = \begin{pmatrix} 1 \\ 0 \end{pmatrix}$ 和 $\mathbf{b}_2 = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$，由它们生成的格就是坐标平面上所有整数坐标 $(x, y) \in \mathbb{Z}^2$ 的集合。这是最简单的“方格”。

然而，格并不总是正交的。例如，考虑基向量 $\mathbf{b}_1 = \begin{pmatrix} 2 \\ 1 \end{pmatrix}$ 和 $\mathbf{b}_2 = \begin{pmatrix} 1 \\ 3 \end{pmatrix}$，它们生成的点就像是倾斜扭曲的网格的交点。

2.3 基的非唯一性与幺模变换

有一个涉及格密码安全性根基的重要性质。那就是“生成同一个格的基有无数个”。

例如，刚才由 $\mathbf{b}_1 = (1, 0)^T, \mathbf{b}_2 = (0, 1)^T$ 生成的 $\mathbb{Z}^2$ 格，即使使用 $\mathbf{b}'_1 = (1, 1)^T, \mathbf{b}'_2 = (2, 3)^T$ 这组基，也会生成完全相同的格 $\mathbb{Z}^2$。

某个基 $B$ 和另一个基 $B'$ 生成相同格的充要条件是，存在一个整数元素构成的矩阵 $U \in \mathbb{Z}^{n \times n}$，其行列式为 $\det(U) = \pm 1$，并且可以表示为：

$$ B' = B U $$

这样的矩阵 $U$ 被称为“幺模矩阵（Unimodular matrix）”。

在密码学应用中，基本思路是使用“好基（接近正交且由短向量组成的基）”作为私钥，而使用“坏基（相互极度倾斜且由非常长的向量组成的基）”作为公钥。当维度较高时，从坏基计算出好基将变得非常困难。这就是格密码的基本直觉。

3. 格上的计算困难问题

格密码的安全性依赖于求解格上特定数学问题的困难性。这里介绍最基本也是最著名的两个问题。

3.1 最短向量问题（Shortest Vector Problem: SVP）

SVP是格理论中最经典且最著名的问题。

定义（SVP）: 给定任意一个格的基 $B$，找到该格 $\mathcal{L}(B)$ 中除零向量以外欧几里得范数（长度）最小的向量 $\mathbf{v}$。

用数学公式表示，即寻找使 $\min_{\mathbf{v} \in \mathcal{L}(B) \setminus \{\mathbf{0}\}} \| \mathbf{v} \|$ 成立的 $\mathbf{v}$。这个最小长度记作 $\lambda_1(\mathcal{L})$，被称为“格的第一连续极小值（First successive minimum）”。

在二维或三维的低维度下，我们可以通过画图用肉眼找到最短向量。或者可以使用高斯格基约化算法等高效地求解。但是，当维度 $n$ 达到数百至数千这样的高维时，已知严格求解SVP是NP困难的。

在实际密码中，通常不寻找严格的最短向量，而是寻找“近似短的向量”，即近似SVP（$\gamma$-SVP）。当近似系数 $\gamma$ 为多项式大小时，这个问题仍然被认为是非常困难的。

3.2 最近向量问题（Closest Vector Problem: CVP）

CVP在格密码中也是极其重要的问题。

定义（CVP）: 给定任意格基 $B$ 和空间内任意目标向量 $\mathbf{t} \in \mathbb{R}^m$（不一定是格点），在格点中找到距离 $\mathbf{t}$ 最近的格点 $\mathbf{v} \in \mathcal{L}(B)$。

用数学公式表示，即寻找使 $\min_{\mathbf{v} \in \mathcal{L}(B)} \| \mathbf{v} - \mathbf{t} \|$ 成立的格点 $\mathbf{v}$。

与SVP一样，CVP在高维空间中也是NP困难的。从密码学应用的角度来看，后文将提到的LWE问题与CVP的特殊变种（Bounded Distance Decoding: BDD）有着密切的关系。

3.3 为什么高维情况下无法求解？（LLL与BKZ的极限）

作为求解高维格问题的著名算法，有LLL算法（Lenstra-Lenstra-Lovász algorithm）。LLL算法能在多项式时间内运行，可以将格基约化（Reduction）到某种程度上的“好基”。然而，LLL算法所能找到的最短向量，其长度与真实最短向量相比，具有指数级（$2^{\mathcal{O}(n)}$）的近似系数，因此不足以破解密码的安全性。

如果使用基于LLL改进的更强力的基约化算法（如BKZ，Block Korkine-Zolotarev算法），可以找到更短的向量，但其计算量会随着块大小呈指数级增长。在格密码中，就是通过估算这种BKZ算法的运行时间来决定安全参数（例如维度 $n$ 的大小）。在目前的PQC标准参数中，维度 $n$ 通常选择在500到1000以上的值，据称即使使用超级计算机或未来的量子计算机，破解所需的时间也将超过宇宙的年龄。

4. LWE问题（Learning With Errors）的数学公式化

大部分现代格密码都基于Oded Regev在2005年提出的“LWE问题（Learning With Errors）”。LWE问题的美妙之处在于其公式化的简洁性，以及它拥有“从最坏情况复杂度到平均情况复杂度的归约”这一强大的数学证明。

4.1 无噪声的线性方程组

为了理解LWE问题，我们先来考虑一个没有噪声的简单线性方程组。假设有一个未知的秘密向量 $\mathbf{s} \in \mathbb{Z}_q^n$（各个分量是 $0$ 到 $q-1$ 的整数）。这里 $q$ 是一个素数。

选择随机的系数向量 $\mathbf{a}_1, \mathbf{a}_2, \dots \in \mathbb{Z}_q^n$，并计算它们与秘密向量 $\mathbf{s}$ 的内积对 $q$ 取模的结果： $b_1 = \langle \mathbf{a}_1, \mathbf{s} \rangle \pmod q$ $b_2 = \langle \mathbf{a}_2, \mathbf{s} \rangle \pmod q$ $\vdots$

如果给出足够数量（$n$个以上）的 $(\mathbf{a}_i, b_i)$ 数对，我们就可以使用线性代数中的“高斯消元法（Gaussian elimination）”轻松恢复出秘密向量 $\mathbf{s}$。这是一个可以在多项式时间内轻松求解的问题。

4.2 LWE问题的定义：加入噪声

那么，如果在该问题中加入微小的“噪声（误差）”会怎样呢？这就是LWE问题的本质。

对于未知的秘密向量 $\mathbf{s} \in \mathbb{Z}_q^n$，我们在每个方程的结果中加入一个小的误差 $e_i \in \mathbb{Z}_q$。 $b_i = \langle \mathbf{a}_i, \mathbf{s} \rangle + e_i \pmod q$

在这里，$e_i$ 是均值为0，标准差相对较小（例如从类似正态分布的离散高斯分布中选取）的小整数值。我们所得到的信息是随机向量 $\mathbf{a}_i$ 与加上误差计算得出的 $b_i$ 组成的数对列表： $( \mathbf{a}_1, b_1 ), ( \mathbf{a}_2, b_2 ), \dots, ( \mathbf{a}_m, b_m )$

用矩阵表示这个过程会非常简洁。使用随机矩阵 $A \in \mathbb{Z}_q^{m \times n}$、秘密向量 $\mathbf{s} \in \mathbb{Z}_q^n$、误差向量 $\mathbf{e} \in \mathbb{Z}_q^m$，可以写成：

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q $$

提供给我们的只有 $A$ 和 $\mathbf{b}$。从中求解 $\mathbf{s}$ 的问题就是“搜索LWE问题（Search LWE problem）”。

由于混入了误差 $e_i$，如果尝试使用高斯消元法，在方程加减的过程中误差会呈指数级放大，从而无法得到正确的答案。乍一看只是简单的线性方程组，但仅仅加入了这种微小的噪声，问题的难度就骤升至NP困难级别。

4.3 判定LWE问题（Decision LWE）

在密码学理论的证明中，频繁使用的是搜索LWE问题的一个变种——“判定LWE问题（Decision LWE problem）”。

判定LWE问题是指，给定从以下两个分布中获取的样本列表，判定它们来自哪一个分布的问题：

LWE分布: 刻意计算出的 $(A, \mathbf{b} = A\mathbf{s} + \mathbf{e} \pmod q)$
均匀随机分布: 由完全随机选择的矩阵 $A$ 和向量 $\mathbf{u}$ 构成的 $(A, \mathbf{u})$

令人惊讶的是，如果恰当地选择LWE问题的参数，从LWE分布中获得的样本数对，与完全随机的数据对之间将变得“计算上不可区分（Computationally Indistinguishable）”。这个性质成为了基于LWE的密码能够生成“与随机数无法区分的密文”的理论依据。

4.4 从最坏情况复杂度到平均情况复杂度的归约（Regev定理）

Oded Regev最大的贡献，就是通过数学证明将LWE问题的难度与前文所述格问题（SVP和CVP）的难度联系在了一起。

他使用量子归约（Quantum reduction）证明了：“如果存在能在平均情况下（对于随机选择的 $A$ 和 $\mathbf{e}$）在多项式时间内求解LWE问题的算法，那么就存在能在多项式时间内求解任意格的最坏情况（最困难的情况）Gap-SVP的量子算法”。（后来Peikert等人也证明了经典归约）。

这在密码学理论中是一个梦幻般的性质。因为它消除了“密码被破解，可能只是因为我们恰好选择了一个弱密钥（平均情况的一部分）”的担忧，并提供了强有力的保证：“如果平均的LWE能被解决，那么格上所有最困难的问题都能被解决（所以LWE绝对是困难的）”。

graph TD A["最坏情况格问题 (Gap-SVP, SIVP)"] -->|量子/经典归约| B["平均情况LWE问题"] B -->|密码学构造| C["基于LWE的密码系统 (PKE, KEM, FHE)"] style A fill:#ffcccc,stroke:#ff0000,stroke-width:2px,color:#000 style B fill:#ccffcc,stroke:#00aa00,stroke-width:2px,color:#000 style C fill:#ccccff,stroke:#0000ff,stroke-width:2px,color:#000

5. 使用LWE构建公钥密码方案（Regev密码）

理解了LWE问题的困难性之后，我们来看看Oded Regev提出的基本公钥密码方案，了解如何利用它进行加解密。这里我们将讲解加密1比特消息 $M \in \{0, 1\}$ 的最基本机制。

5.1 密钥生成（Key Generation）

作为系统参数，确定作为模数的素数 $q$、维度 $n$ 以及方程数量 $m$（$m > n \log q$）。
作为私钥，随机选择向量 $\mathbf{s} \in \mathbb{Z}_q^n$。
生成随机矩阵 $A \in \mathbb{Z}_q^{m \times n}$。
从离散高斯分布等误差分布中选择一个小的误差向量 $\mathbf{e} \in \mathbb{Z}_q^m$。
计算向量 $\mathbf{b} = A \mathbf{s} + \mathbf{e} \pmod q$。
公钥（Public Key）为 $(A, \mathbf{b})$。
私钥（Secret Key）为 $\mathbf{s}$。

公钥本身正是“LWE问题的一个实例”。由于从公钥 $(A, \mathbf{b})$ 求出私钥 $\mathbf{s}$ 等同于求解搜索LWE问题，因此其安全性得到了保障。

5.2 加密（Encryption）

爱丽丝使用鲍勃的公钥 $(A, \mathbf{b})$，对1比特的消息 $M \in \{0, 1\}$ 进行加密。

选择一个随机的二进制向量（分量为0或1）$\mathbf{r} \in \{0, 1\}^m$。
作为密文的前半部分，计算向量 $\mathbf{u} = A^T \mathbf{r} \pmod q$。（$A^T$ 是 $A$ 的转置矩阵。也就是说，将 $A$ 中对应 $\mathbf{r}$ 分量为1的行进行相加）。
作为密文的后半部分，计算标量 $v = \mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q$。（如果消息 $M$ 为0，则什么都不加；如果为 $1$，则加上正好是 $q$ 一半的值 $\lfloor \frac{q}{2} \rfloor$）。
密文（Ciphertext）即为 $(\mathbf{u}, v)$。

加密直观的含义是，对于公钥矩阵 $A$ 和向量 $\mathbf{b}$，取其“随机子集的和”。由于判定LWE问题的困难性，该密文 $(\mathbf{u}, v)$ 看起来与完全随机的向量和均匀随机数不可区分（语义安全性：Semantic Security）。

flowchart LR M["消息 M 属于 {0,1}"] --> Enc PK["公钥 (A, b)"] --> Enc r["随机二进制向量 r"] --> Enc subgraph Enc ["加密过程"] direction TB u_calc["u = A^T * r mod q"] v_calc["v = b^T * r + M * floor(q/2) mod q"] end Enc --> CT["密文 (u, v)"]

5.3 解密（Decryption）

鲍勃使用私钥 $\mathbf{s}$ 对密文 $(\mathbf{u}, v)$ 进行解密。

计算以下值： $D = v - \mathbf{s}^T \mathbf{u} \pmod q$
如果计算结果接近 $0$，则输出 $M=0$；如果接近 $\lfloor \frac{q}{2} \rfloor$，则输出 $M=1$。

为什么这样就能解密呢？让我们从数学上展开来看。回想一下 $\mathbf{b} = A \mathbf{s} + \mathbf{e}$。

$$ \begin{aligned} v - \mathbf{s}^T \mathbf{u} &= (\mathbf{b}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T (A^T \mathbf{r}) \\ &= ((A \mathbf{s} + \mathbf{e})^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= (\mathbf{s}^T A^T \mathbf{r} + \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor) - \mathbf{s}^T A^T \mathbf{r} \\ &= \mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor \pmod q \end{aligned} $$

在这里，公式中的 $\mathbf{s}^T A^T \mathbf{r}$ 被完美地抵消消失了！剩下的只有 $\mathbf{e}^T \mathbf{r} + M \cdot \lfloor \frac{q}{2} \rfloor$。

$\mathbf{e}$ 是分量极小的噪声向量，而 $\mathbf{r}$ 是分量为0或1的二进制向量。因此，它们的内积 $\mathbf{e}^T \mathbf{r}$（如果参数选择得当）也会保持在一个相对较小的值。

如果 $M=0$，结果变为 $\mathbf{e}^T \mathbf{r}$，这是一个接近 $0$ 的小值。
如果 $M=1$，结果变为 $\mathbf{e}^T \mathbf{r} + \lfloor \frac{q}{2} \rfloor$，它将位于 $q$ 的一半值 $\lfloor \frac{q}{2} \rfloor$ 的附近。

如果参数设计使得误差 $\mathbf{e}^T \mathbf{r}$ 的绝对值能够控制在 $\frac{q}{4}$ 以内，鲍勃只需观察计算结果是更接近 $0$ 还是 $\lfloor \frac{q}{2} \rfloor$，就能准确地判定（恢复）消息 $M$。这就是基于LWE的密码能够正常运作的精妙机制。

flowchart LR CT["密文 (u, v)"] --> Dec SK["私钥 s"] --> Dec subgraph Dec ["解密过程"] direction TB calc["计算 D = v - s^T * u mod q"] check["检查 D 是更接近 0 还是 q/2"] end calc --> check Dec --> M_out["恢复出的消息 M"]

6. 使用具体数值的LWE密码玩具示例

仅仅罗列公式可能很难有切实的感受，所以让我们实际设定非常小的数值参数，来追踪一下从加密到解密的计算过程。（※在现实的密码系统中，为了确保安全性，通常会使用 $n$ 为500以上、$q$ 为数千以上的值）

【参数设定】

模数 $q = 17$ （素数。因此取值范围在 $0$ 到 $16$ 之间）
维度 $n = 2$
方程数量 $m = 4$
假设要加密消息 $M = 1$。
消息的偏移量：$\lfloor \frac{q}{2} \rfloor = \lfloor \frac{17}{2} \rfloor = 8$

【1. 密钥生成阶段】 鲍勃随机选择私钥 $\mathbf{s}$、矩阵 $A$ 以及误差向量 $\mathbf{e}$。

$$ \mathbf{s} = \begin{pmatrix} 3 \\ 4 \end{pmatrix} \in \mathbb{Z}_{17}^2 $$ $$ A = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \in \mathbb{Z}_{17}^{4 \times 2} $$ $$ \mathbf{e} = \begin{pmatrix} 1 \\ -1 \\ 0 \\ 2 \end{pmatrix} \equiv \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} \pmod{17} $$

接着计算公钥 $\mathbf{b}$。

$$ A \mathbf{s} = \begin{pmatrix} 2 & 15 \\ 1 & 8 \\ 14 & 5 \\ 9 & 10 \end{pmatrix} \begin{pmatrix} 3 \\ 4 \end{pmatrix} = \begin{pmatrix} 2\times 3 + 15\times 4 \\ 1\times 3 + 8\times 4 \\ 14\times 3 + 5\times 4 \\ 9\times 3 + 10\times 4 \end{pmatrix} = \begin{pmatrix} 6 + 60 \\ 3 + 32 \\ 42 + 20 \\ 27 + 40 \end{pmatrix} = \begin{pmatrix} 66 \\ 35 \\ 62 \\ 67 \end{pmatrix} $$

将其对 17 取模。($66 = 17 \times 3 + 15$ 等)

$$ A \mathbf{s} \pmod{17} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} $$

加上误差向量 $\mathbf{e}$。

$$ \mathbf{b} = A \mathbf{s} + \mathbf{e} = \begin{pmatrix} 15 \\ 1 \\ 11 \\ 16 \end{pmatrix} + \begin{pmatrix} 1 \\ 16 \\ 0 \\ 2 \end{pmatrix} = \begin{pmatrix} 16 \\ 17 \\ 11 \\ 18 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 0 \\ 11 \\ 1 \end{pmatrix} \pmod{17} $$

公钥为 $A$ 和 $\mathbf{b} = (16, 0, 11, 1)^T$。

【2. 加密阶段】 爱丽丝加密消息 $M = 1$。选择随机向量 $\mathbf{r}$。这里设 $\mathbf{r} = (1, 0, 1, 0)^T$。

计算 $\mathbf{u}$。

$$ \mathbf{u} = A^T \mathbf{r} = \begin{pmatrix} 2 & 1 & 14 & 9 \\ 15 & 8 & 5 & 10 \end{pmatrix} \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = \begin{pmatrix} 2 \times 1 + 14 \times 1 \\ 15 \times 1 + 5 \times 1 \end{pmatrix} = \begin{pmatrix} 16 \\ 20 \end{pmatrix} \equiv \begin{pmatrix} 16 \\ 3 \end{pmatrix} \pmod{17} $$

计算 $v$。

$$ \mathbf{b}^T \mathbf{r} = (16, 0, 11, 1) \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \end{pmatrix} = 16 \times 1 + 11 \times 1 = 27 \equiv 10 \pmod{17} $$

加上对应消息 $M=1$ 的值 $\lfloor 17/2 \rfloor = 8$。

$$ v = \mathbf{b}^T \mathbf{r} + M \cdot 8 = 10 + 1 \times 8 = 18 \equiv 1 \pmod{17} $$

爱丽丝将密文 $(\mathbf{u}, v) = \left( \begin{pmatrix} 16 \\ 3 \end{pmatrix}, 1 \right)$ 发送给鲍勃。

【3. 解密阶段】 鲍勃收到密文后，使用私钥 $\mathbf{s} = (3, 4)^T$ 进行解密。解密处理公式：计算 $D = v - \mathbf{s}^T \mathbf{u} \pmod{17}$。

$$ \mathbf{s}^T \mathbf{u} = (3, 4) \begin{pmatrix} 16 \\ 3 \end{pmatrix} = 3 \times 16 + 4 \times 3 = 48 + 12 = 60 \equiv 9 \pmod{17} $$ $$ D = v - \mathbf{s}^T \mathbf{u} = 1 - 9 = -8 \pmod{17} $$

在这里，在模17的世界里，$-8$ 等于 $9$（$-8 + 17 = 9$）。判定得到的值 $D = 9$ 是更接近 $0$ 还是 $8$（$\lfloor 17/2 \rfloor$）。由于 $9$ 显然比 $0$ 更接近 $8$，所以鲍勃成功地正确恢复出了 $M = 1$！

为什么会变成 $9$ 呢？回想一下刚才的证明。误差部分为 $\mathbf{e}^T \mathbf{r} = (1, -1, 0, 2) (1, 0, 1, 0)^T = 1 \times 1 + 0 \times 1 = 1$。因此，计算结果变为 $\mathbf{e}^T \mathbf{r} + M \cdot 8 = 1 + 8 = 9$，我们确认了计算得出了与理论一致的值。

7. 走向实用化的演进：Ring-LWE 与 Module-LWE

到目前为止我们所解释的标准LWE问题（Standard LWE）拥有极其强大的安全性证明，但在实际应用中却有一个致命的弱点。那就是“密钥尺寸巨大”和“计算成本高昂”。

在Standard LWE中，公钥包含一个巨大的矩阵 $A \in \mathbb{Z}_q^{m \times n}$。当参数 $n$ 达到数百至数千时，这个矩阵的尺寸会达到几兆字节，每次在互联网通信协议（如TLS）中传输都会显得过于沉重。另外，矩阵与向量的乘法需要 $\mathcal{O}(n^2)$ 的计算量。

为了解决这个问题，人们引入了将多项式环（Polynomial rings）这种代数结构融入格中的“Ring-LWE（RLWE）”和“Module-LWE（MLWE）”。

7.1 Ring-LWE 的直觉

在Ring-LWE中，将向量和矩阵替换为多项式环 $\mathcal{R}_q = \mathbb{Z}_q[X]/(X^n + 1)$ 上的元素（多项式）。（这里的 $n$ 通常选择为2的幂）。

Standard LWE的公钥是一个矩阵 $A$，而在Ring-LWE中则使用单一的多项式 $a(x)$。私钥 $s(x)$ 和误差 $e(x)$ 也变成了多项式。方程如下所示：

$$ b(x) = a(x) \cdot s(x) + e(x) \pmod q $$

因为这是多项式的乘法，所以通过使用类似于快速傅里叶变换（FFT）的“数论变换（Number Theoretic Transform: NTT）”，可以将计算量急剧削减到 $\mathcal{O}(n \log n)$。此外，由于公钥的尺寸也从矩阵缩小到了单一的多项式，数据尺寸减少到了 $\mathcal{O}(n)$。这在通信带宽上带来了压倒性的优势。

从数学上看，Ring-LWE并不是一般的格，而是归结为被称为“理想格（Ideal Lattice）”的具有特殊对称性的格上的问题。

7.2 Module-LWE 与 NIST 的标准化（Kyber / ML-KEM）

Ring-LWE虽然高效，但也存在着一些担忧，即理想格特殊的代数结构未来可能会成为被攻击的突破口。因此，结合了Standard LWE的保守安全性与Ring-LWE的高效性，做到了“两全其美”的，便是“Module-LWE（MLWE）”。

在Module-LWE中，考虑的是以多项式为元素的小型矩阵和向量。也就是说，处理的是环上的模（Module）。目前，NIST选定作为PQC密钥封装机制（KEM）标准的“CRYSTALS-Kyber”（标准化名称：ML-KEM），正是基于这个Module-LWE问题的困难性所构建的。

8. 为什么对量子计算机也是安全的？

最后，我们来探讨一下核心问题：“为什么人们认为格密码即使使用量子计算机也无法被破解？”。

量子计算机能够破解RSA密码和椭圆曲线密码的Shor算法，其本质是一个求解“隐藏子群问题（Hidden Subgroup Problem: HSP）”的算法。RSA和ECC背后的数学结构（有限阿贝尔群）具有周期性，通过使用被称为量子傅里叶变换（QFT）的量子算法特有操作，可以一口气提取出这个周期（隐藏的子群）。

然而，格问题有着根本的不同。尽管格也具有周期性，但在SVP和CVP中需要求解的是“最短距离”或“去除噪声”这种几何上的非线性性质。即使直接套用像Shor算法中那样的“阿贝尔群上的量子傅里叶变换”，也无法高效地提取出成为格问题解答的有用信息。迄今为止，尚未发现能够在多项式时间内求解SVP或LWE的量子算法，人们普遍相信，即便拥有量子计算机的并行计算能力，也只有近乎穷举的搜索（如利用Grover算法带来的平方根加速程度）才是有效的手段。

9. 总结

本文从格密码的数学直觉出发，详细讲解了从格的几何学定义，到LWE问题的公式化，再到构建公钥密码的全过程。

格（Lattice） 是由基向量的整数系数线性组合表示的离散空间，在高维空间中，寻找接近正交的“好基”（SVP）是非常困难的。
LWE问题（Learning With Errors） 是求解带噪声的线性方程组的问题，由于它被归约到格的最坏情况问题的困难性，从而提供了强大的安全性依据。
利用LWE问题，通过刻意添加或消除噪声的巧妙机制，实现了加解密（Regev密码）。
在现实的协议中，为了提高通信效率和计算速度，采用了使用多项式环的 Ring-LWE 和 Module-LWE，这成为了NIST标准 ML-KEM 的基础。

在量子计算机这一前所未有的计算范式转变日益逼近的背景下，脱胎于经典线性代数和数论深渊的“格密码”，将承担起未来互联网安全基石的重任，这着实是一个充满浪漫色彩的故事。作为格密码基础的数学绝非高不可攀，只要具备线性代数和概率的基础知识，就足以理解其美妙的结构。希望本文能为您理解作为PQC核心的格密码提供一些帮助。

黎曼猜想与素数分布：与现代密码学的深刻联系

Fri, 11 Sep 2026 16:00:00 +0900

1. 引言：素数这一宇宙奥秘与黎曼猜想

“素数（Prime Numbers）”是只能被1和自身整除的自然数，在数学世界中被称为“原子”。2, 3, 5, 7, 11, 13… 这串数列乍看之下显得杂乱无章、随机出现。自从古希腊数学家欧几里得证明“素数有无限多个”以来，无数数学家试图解开隐藏在素数排列中的规律。

在探索素数之谜的道路上，最接近真相的是1859年由德国数学家波恩哈德·黎曼（Bernhard Riemann）提出的**“黎曼猜想（Riemann Hypothesis）”**。黎曼猜想是现代数学中最重要且未解决的难题之一，也是克雷数学研究所设立的千禧年大奖难题之一，悬赏100万美元。

乍看之下，关于素数分布的纯数学难题似乎与我们的日常生活毫不相干。然而，支撑现代社会基础设施的互联网安全，尤其是RSA加密和椭圆曲线密码学（ECC）等现代密码技术，都深深依赖于巨大素数的性质。

本文将带领读者进行一次数学之旅，从素数分布、素数定理、黎曼zeta函数，一直深入到黎曼猜想的核心，并极其详尽地探讨它如何与现代密码技术产生联系，以及如果黎曼猜想被证明，世界将会发生怎样的改变。

2. 素数定理与素数分布：高斯的发现

为了理解素数是如何分布的，数学家们引入了素数计数函数（Prime-counting function） $\pi(x)$，它表示“小于或等于某个数 $x$ 的素数有多少个”。

例如：

$\pi(10) = 4$ （2, 3, 5, 7）
$\pi(100) = 25$
$\pi(1000) = 168$

15岁的天才数学家卡尔·弗里德里希·高斯（Carl Friedrich Gauss）计算了庞大的素数表，并发现素数出现的频率与自然对数 $\ln x$ 成反比而递减。也就是说，他推测在一个数 $x$ 附近找到素数的概率大约是 $\frac{1}{\ln x}$。

用积分来表达这个推测，就得到了对数积分（Logarithmic integral） $\text{Li}(x)$：

$$ \text{Li}(x) = \int_{2}^{x} \frac{dt}{\ln t} $$

高斯的猜想后来在1896年由雅克·阿达马和夏尔-让·德拉瓦莱·普桑分别独立证明，确立为素数定理（Prime Number Theorem, PNT）。

$$ \lim_{x \to \infty} \frac{\pi(x)}{\text{Li}(x)} = 1 $$

或者近似地表示为：

$$ \pi(x) \sim \frac{x}{\ln x} $$

通过这个定理可知，从宏观来看，素数具有非常平滑且可预测的分布。然而，从微观来看，$\pi(x)$ 和 $\text{Li}(x)$ 之间始终存在着“误差”或者说“波动”。这种波动的本质，正是黎曼猜想试图解开的最大谜团。

3. 黎曼zeta函数与欧拉乘积

分析素数分布最强大的武器是黎曼zeta函数（Riemann Zeta Function）。它最初是由莱昂哈德·欧拉（Leonhard Euler）针对实数 $s > 1$ 定义的无穷级数。

$$ \zeta(s) = \sum_{n=1}^\infty \frac{1}{n^s} = 1 + \frac{1}{2^s} + \frac{1}{3^s} + \frac{1}{4^s} + \dots $$

欧拉最大的功绩之一，是证明了这个无穷级数可以表示为关于所有素数 $p$ 的无穷乘积。这就是欧拉乘积（Euler Product Formula）。

$$ \zeta(s) = \prod_{p \text{ prime}} \frac{1}{1 - p^{-s}} = \left( \frac{1}{1 - 2^{-s}} \right) \left( \frac{1}{1 - 3^{-s}} \right) \left( \frac{1}{1 - 5^{-s}} \right) \dots $$

对于这个证明的直观理解是：将右边各项作为等比级数展开，然后将它们相乘，根据算术基本定理（所有自然数都可以唯一地表示为素数的乘积），左边自然数倒数和的形式会被完美地重构出来。

仅仅这一个数学公式，就搭建起了分析学（无穷级数、连续函数）与数论（素数、离散数）之间的桥梁。 研究zeta函数，就等同于研究素数的分布。

4. 解析延拓与向复平面的扩展

黎曼的天才之处在于，他将欧拉原本只在实数范围内考虑的 $\zeta(s)$ 的变量 $s$，扩展到了复数 $s = \sigma + it$（$\sigma$ 是实部，$t$ 是虚部）。

最初的无穷级数只在 $\sigma > 1$ 时收敛，但黎曼使用了“解析延拓（Analytic Continuation）”的方法，扩展了 $\zeta(s)$ 的定义，使其在除了极点 $s = 1$ 之外的整个复平面上都有意义。

他进一步推导出了zeta函数满足的优美函数方程（Functional equation）：

$$ \zeta(s) = 2^s \pi^{s-1} \sin\left(\frac{\pi s}{2}\right) \Gamma(1-s) \zeta(1-s) $$

这里的 $\Gamma(x)$ 是伽玛函数。通过这个方程，可以从右半平面的性质得知左半平面的性质。

零点（Zeros of the Zeta Function）

使zeta函数值为0的复数 $s$ 被称为“零点”。从函数方程可知，当 $s$ 是负偶数（$-2, -4, -6, \dots$）时，由于 $\sin(\pi s / 2)$ 变为0，因此 $\zeta(s) = 0$。这些被称为平凡零点（Trivial zeros）。

然而，在素数分布中真正重要的是其他零点，也就是存在于 $0 \le \sigma \le 1$ 的“临界带（Critical strip）”中的非平凡零点（Non-trivial zeros）。

5. 黎曼猜想的核心与显式公式

黎曼计算了少数几个零点，并提出了一个惊人的猜想。这就是黎曼猜想。

黎曼猜想 (Riemann Hypothesis) 黎曼zeta函数 $\zeta(s)$ 的所有非平凡零点，其实部都在 $1/2$ 的直线上（$\text{Re}(s) = 1/2$）。

这条实部为1/2的直线被称为“临界线（Critical line）”。

graph TD A["黎曼zeta函数 ζ(s)"] --> B["通过解析延拓扩展至复平面"] B --> C["平凡零点 (s = -2, -4, -6 ...)"] B --> D["非平凡零点 (0 <= Re(s) <= 1)"] D --> E["黎曼猜想"] E --> F["所有非平凡零点都在 Re(s) = 1/2 上"] F --> G["通向素数分布误差项极限的证明"]

为什么黎曼猜想如此重要？那是因为zeta函数的零点完全决定了素数的分布。

黎曼以及后来的数学家冯·曼戈尔特推导出了精确描述素数分布的“显式公式（Explicit formula）”。使用切比雪夫函数 $\psi(x)$ 可以表示为如下形式：

$$ \psi(x) = x - \sum_{\rho} \frac{x^\rho}{\rho} - \ln(2\pi) - \frac{1}{2}\ln(1 - x^{-2}) $$

这里 $\rho$ 是对zeta函数的所有非平凡零点求和。主项是 $x$ （这对应于素数定理），由此加上或减去取决于零点 $\rho$ 的波状项，就能还原出素数呈阶梯状的精确分布。可以说，非平凡零点代表了素数分布的“频率（波）”。

如果黎曼猜想成立，即所有非平凡零点 $\rho$ 的实部恰好都是 $1/2$，那么理论上素数定理的误差项将被限制在可以想象的最小范围内：

$$ |\pi(x) - \text{Li}(x)| \le \frac{1}{8\pi} \sqrt{x} \ln x \quad \text{for} \quad x \ge 2657 $$

也就是说，如果黎曼猜想为真，就能证明素数以我们所能想象到的最“规则、美丽”的方式分布着。

6. 现代密码技术与素数不可分割的关系

到此为止都是深奥的纯数学世界，但这素数的性质在根基上支撑着现代的数字社会。其代表就是以RSA加密为首的公钥加密方式。

互联网上的信用卡支付、密码传输、区块链电子签名等，所有通信的安全性都依赖于“素数”。

RSA加密的原理

RSA加密的安全性基于一个数学事实（整数分解问题）：“对大位数的合数进行质因数分解非常困难”。

密钥生成: 随机选择两个巨大的素数 $p$ 和 $q$（例如各为2048位）。将它们相乘计算出 $N = p \times q$。这个 $N$ 将成为公钥的一部分。利用欧拉函数 $\phi(N) = (p-1)(q-1)$，生成私钥 $d$。
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
加密与解密: 明文 $M$ 会利用公钥 $e, N$ 转换为密文 $C$。
$$ C \equiv M^e \pmod{N} $$
只有拥有私钥 $d$ 的人才能解密。
$$ M \equiv C^d \pmod{N} $$

graph LR A["明文 (Plaintext)"] --> B["用公钥(e, N)加密"] B --> C["密文 (Ciphertext)"] C --> D["用私钥(d)解密"] D --> E["原始明文"] F["攻击者 (Attacker)"] -- "尝试对N进行质因数分解" --> C F -.-> G["如果不知道p和q，d就无法计算"]

要破解RSA加密，就必须从巨大的 $N$ 中找出原来的素数 $p$ 和 $q$（进行质因数分解）。即使使用当前主流的算法（如普通数域筛选法：GNFS等），并动用超级计算机来分解几百位数的数字，据说也需要远远超过宇宙年龄的时间。

7. 黎曼猜想对密码技术的影响

那么，处于纯数学顶点的“黎曼猜想”与“密码技术”是如何交汇的呢？

7.1. 素数生成算法（素性测试）与广义黎曼猜想（GRH）

为了运行RSA加密，首先需要生成巨大的素数 $p$ 和 $q$。然而，要可靠且高速地判断“某个数是否为素数”并非易事。

目前在实际应用中使用的是一种被称为**米勒-拉宾素性测试（Miller-Rabin primality test）**的概率算法。这种算法速度很快，但存在以极低概率将合数误判为素数的“伪素数”风险。

然而，如果假设将黎曼猜想扩展到狄利克雷L函数上的**“广义黎曼猜想（Generalized Riemann Hypothesis, GRH）”为真，情况将发生戏剧性的变化。如果GRH为真，那么在数学上就能保证米勒-拉宾测试的测试次数上限，使其从概率算法升华为“确定性多项式时间算法”**（这是在AKS素性测试被发现之前就已知晓的重大事实）。

换言之，黎曼猜想（及其推广）在“能否带着绝对的自信、高速地生成巨大素数”这一密码基石的生成中，起到了直接背书的作用。

7.2. 与质因数分解算法的关系

在评估密码破解方算法（如普通数域筛选法等）的计算复杂度时，关于素数分布的知识也是不可或缺的。许多质因数分解算法都依赖于“光滑数（Smooth numbers：仅含有较小质因数的数字）”的分布。

为了严格评估光滑数出现的频率，需要对素数分布有深刻的理解，这里也充分利用了直接联系zeta函数和黎曼猜想的解析数论技巧。如果黎曼猜想被证明，并且素数分布的误差被完全确定，那么将有可能更准确地看清质因数分解算法的性能极限。

8. 如果黎曼猜想被证明，密码会被破解吗？

像都市传说一样，有人说“一旦黎曼猜想被解开，RSA加密就会瞬间崩溃”，但这在数学上是不准确的。

黎曼猜想的证明本身，并不会直接产生一种能让质因数分解戏剧性加速的魔法算法。因为黎曼猜想终究是关于素数“宏观分布规律性”的定理，并不能直接告诉我们个别的数字 $N$ 能被哪个素数整除（局部性质）。

然而，影响并非为零。因为在证明黎曼猜想的过程中，极有可能发现“新的数学工具”或“未知的分析方法”。回顾历史，当费马大定理或庞加莱猜想被证明时，在这个过程中发展出的新理论让整个数学界实现了巨大的飞跃。

如果确立了某种能够完全操控黎曼zeta函数零点性质的未知代数几何学方法或非交换几何学方法，那么这可能会导致发现具有突破性的质因数分解算法（例如将计算复杂度降低到多项式时间的经典算法），这种可能性是无法否认的。正因如此，密码学家们绝对无法将视线从黎曼猜想的动向上移开。

量子计算机与Shor算法

对于密码技术而言，更直接、更现实的威胁不是黎曼猜想的证明，而是量子计算机。彼得·秀尔（Peter Shor）在1994年发表的“Shor算法”证明，如果拥有性能足够强大的量子计算机，就能在多项式时间内解决质因数分解问题。这将导致RSA加密和椭圆曲线加密被从根本上破解。

目前，全世界都在推进向即使是量子计算机也无法破解的“抗量子密码（Post-Quantum Cryptography, PQC）”（如格密码等）的过渡。依赖于素数的密码技术在某种意义上可能正在迎来其黄金时代的落幕，但素数本身的数学价值将永远不会消失。

9. 结语：数学的抽象性与现实社会的交汇点

graph TD A["对纯粹数学的探索"] --> B["阐明黎曼猜想"] B --> C["对素数分布的完全理解"] C --> D["数论、代数几何学的飞跃发展"] D -.-> E["新质因数分解算法的可能性"] E -.-> F["更新密码技术的安全性评估"] A --> G["应用数学、计算机科学"] G --> H["提高素数判定、密钥生成的效率"] H --> F

自古希腊以来对素数不懈的探索，通过黎曼这位天才，升华为了复平面上优美的交响乐（zeta函数的零点）。令人惊叹的是，那纯粹无暇的数学结晶，历经数个世纪，如今已被应用为保障互联网社会安全的最强盾牌。

黎曼猜想是一个同时象征着数学所具有的“抽象之美”与“对物理世界、现实社会惊人的适用能力”的存在。

当这座尚未有人登顶的巍峨数学高山在未来的某一天被征服时，我们不仅将完全理解素数这一宇宙真理，而且会对信息化社会的基础产生全新的视角。学习密码技术，本身也是一趟追溯人类智慧历史的旅程。

使用C++实现的高速素数判定算法（Miller-Rabin法等）

Fri, 11 Sep 2026 14:00:00 +0900

前言：为什么需要高速的素数判定

在信息科学、密码学理论以及算法竞赛的世界中，快速且准确地判断“一个数是否为素数”是一个非常重要且基础的课题。例如，支撑现代互联网社会安全的RSA加密等公钥加密体制，其安全性的基础就在于巨大素数的生成及其相乘的困难性（大整数分解的困难性）。因此，能够瞬间辨别出巨大数是否为素数的技术，毫不夸张地说，正是支撑数字社会根基的技术。

此外，在算法竞赛（如AtCoder、Codeforces等）中，素数判定也是一个高频主题。面对限制条件为 $N \le 10^{18}$ 这样巨大的输入，如果要求在1秒内进行数万次素数判定，传统的朴素算法绝对无法在规定时间内完成（会导致超时：Time Limit Exceeded, TLE）。

本文将从朴素的素数判定算法开始，介绍概率性素数判定法“费马测试”，以及克服了其弱点、在实际应用中堪称最强级别的高速算法——“米勒-拉宾（Miller-Rabin）素数判定法”。我们将从数学背景到高度优化的C++实现，进行彻底的讲解。特别是针对64位整数（$N < 2^{64}$），我们不仅停留在概率性判定上，还将详细说明“能够100%确定是否为素数（确定性判定）”的方法，并提供可直接应用于实战的C++源代码。

1. 素数判定的基础与试除法 (Trial Division)

素数（Prime number）是指在大于1的自然数中，除了1和它本身以外不再有其他正因数的数。如果严格按照素数的定义，要判断一个整数 $N$ 是否为素数，只需用从 $2$ 到 $N-1$ 的所有整数去尝试除 $N$，如果都无法整除，则是素数；如果哪怕有一次能整除，则是合数（非素数）。

然而，这种方法的时间复杂度为 $O(N)$。当 $N$ 是像 $10^{18}$ 这样的巨大数字时，即使是现代计算机也会消耗极其漫长的时间来进行计算。

试除法的优化：探索至 $\sqrt{N}$

当合数 $N$ 可以表示为 $a \times b = N$ （$a \le b$）时，必然有 $a \le \sqrt{N}$。因此，素数判定的循环不需要执行到 $N-1$，只需检查到 $\sqrt{N}$ 就足够了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


#include <iostream>

// 使用试除法进行素数判定 (O(sqrt(N)))
bool is_prime_trial_division(long long n) {
 if (n <= 1) return false;
 if (n == 2 || n == 3) return true;
 if (n % 2 == 0) return false;

 // 只检查3以上的奇数
 for (long long i = 3; i * i <= n; i += 2) {
 if (n % i == 0) return false;
 }
 return true;
}

该算法的时间复杂度为 $O(\sqrt{N})$。如果 $N \le 10^{12}$ 左右，可以瞬间计算完成；但如果 $N \approx 10^{18}$，循环次数约为 $10^9$ 次，即使使用C++编译器，也需要数百毫秒到几秒的时间，因此不适合进行多次判定。

2. 费马测试：概率性素数判定的开端

为了突破试除法的局限性，人们利用数论定理提出了“概率性算法（Probabilistic Algorithm）”。其中最具代表性的就是利用费马小定理的“费马测试（Fermat Primality Test）”。

费马小定理 (Fermat’s Little Theorem)

皮埃尔·德·费马（Pierre de Fermat）发现的这一定理主张如下：

对于任意素数 $p$ 和任意与 $p$ 互质（不是 $p$ 的倍数）的整数 $a$，以下同余式成立：
$$ a^{p-1} \equiv 1 \pmod p $$

取该定理的逆否命题，可以说：“对于某个整数 $N$ 及与 $N$ 互质的整数 $a$，如果 $a^{N-1} \not\equiv 1 \pmod N$ 成立，那么 $N$ 必定是合数。”费马测试正是利用这一性质，针对待判定的数 $N$ 选择一个随机的底数（base）$a$，计算 $a^{N-1} \pmod N$ 并确认其结果是否为 $1$。

快速幂取模（反复平方法）

为了进行费马测试，必须能够高速计算 $a^{N-1} \pmod N$ 这种巨大的幂运算。为此，我们使用“反复平方法（Modular Exponentiation / Binary Exponentiation）”。其时间复杂度为 $O(\log N)$，计算速度非常快。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// 使用反复平方法计算 a^b mod m
long long mod_pow(long long a, long long b, long long m) {
 long long res = 1;
 a %= m;
 while (b > 0) {
 if (b & 1) res = (__int128_t)res * a % m;
 a = (__int128_t)a * a % m;
 b >>= 1;
 }
 return res;
}

※ 在此代码中，为了防止溢出，我们使用了GCC/Clang的扩展类型 __int128_t（128位整数）来保存中间的乘积。

伪素数与卡迈克尔数 (Carmichael Numbers)

费马测试虽然非常强大，但存在一个致命的弱点。那就是：存在一些数 $N$，尽管它是合数，但对于所有的 $a$ （与 $N$ 互质的 $a$），$a^{N-1} \equiv 1 \pmod N$ 都能成立。

这种数被称为“绝对伪素数”或“卡迈克尔数”。最小的卡迈克尔数是 $561 = 3 \times 11 \times 17$。由于卡迈克尔数的存在，仅靠费马测试无法进行“100%概率”的确定性判定。无论你尝试多少个不同的 $a$，像 $561$ 这样的数始终会伪装成素数骗过测试。

3. 米勒-拉宾素数判定法 (Miller-Rabin Primality Test)

出色地克服了费马测试弱点（卡迈克尔数的存在）的方法，是由加里·米勒（Gary L. Miller）和迈克尔·拉宾（Michael O. Rabin）提出的“米勒-拉宾素数判定法”。目前，作为实用的高速素数判定算法，它在各种编程语言的内部库以及密码系统的密钥生成中得到了最广泛的应用。

数学原理

米勒-拉宾算法除了利用费马小定理外，还利用了这样一个性质：“在以素数为模的剩余系（$\mathbb{Z}/p\mathbb{Z}$）中，方程 $x^2 \equiv 1 \pmod p$ 的解仅限于 $x \equiv 1$ 或 $x \equiv -1$”（当模为合数时，可能存在除此以外的非平凡平方根）。

待判定的奇数 $N$ 减去 $1$ 得到的 $N-1$ 必定是偶数。因此，我们可以将 $N-1$ 尽可能多地除以 $2$，表示为以下形式：

$$ N-1 = d \cdot 2^s $$

（其中，$d$ 为奇数，$s \ge 1$）

对于任意底数 $a$ （$1 < a < N-1$），我们会根据费马小定理验证 $a^{N-1} \equiv 1 \pmod N$ 是否成立，但这个计算是分阶段进行的。具体来说，就是依次连续进行平方计算：$a^d, a^{d \cdot 2}, a^{d \cdot 4}, \ldots, a^{d \cdot 2^s}$。

米勒-拉宾测试判定 $N$ 为“素数（或者以极高的概率为素数）”的条件是，以下任意一项成立：

$a^d \equiv 1 \pmod N$
存在某个 $r$ （$0 \le r < s$），使得 $a^{d \cdot 2^r} \equiv -1 \pmod N$ 成立。 ※ 在C++的取模运算中，$-1 \pmod N$ 相当于 $N-1$。

如果 $N$ 是素数，那么对于任意的 $a$，该条件必定满足。反之，如果 $N$ 是合数，在随机选择 $a$ 时，满足该条件（即被骗过）的概率在数学上被证明为不超过 $\frac{1}{4}$。只要进行 $k$ 次独立的测试，误判的概率就会小于 $\left(\frac{1}{4}\right)^k$，在实际应用中可以视作零。不存在像卡迈克尔数那样“绝对能蒙混过关”的数。

米勒-拉宾法的算法流程（Mermaid流程图）

下图展示了米勒-拉宾素数判定法中一次测试（针对单一底数 $a$ 的测试）的逻辑流程。

graph TD Start["测试开始 (输入: N, a)"] --> CalcDS["计算满足 N-1 = d * 2^s 的 d (奇数) 和 s"] CalcDS --> CalcX["计算 x = a^d mod N"] CalcX --> CheckX1{"x == 1 或 x == N-1 ?"} CheckX1 -- "Yes" --> ReturnTrue["可能是素数 (Probably Prime)"] CheckX1 -- "No" --> LoopStart["从 r = 1 到 s-1 开始循环"] LoopStart --> LoopCondition{"r < s ?"} LoopCondition -- "No" --> ReturnFalse["确认为合数 (Composite)"] LoopCondition -- "Yes" --> SquareX["计算 x = (x * x) mod N"] SquareX --> CheckXMinus1{"x == N - 1 ?"} CheckXMinus1 -- "Yes" --> ReturnTrue CheckXMinus1 -- "No" --> CheckXOne{"x == 1 ?"} CheckXOne -- "Yes" --> ReturnFalse CheckXOne -- "No" --> LoopNext["r 增加 1 并继续"] LoopNext --> LoopCondition

4. 针对64位整数的确定性判定

米勒-拉宾素数判定法本质上是“概率性”算法，但如果 $N$ 的上限是固定的，通过测试特定的一组 $a$ （底数），就能够“100%确切地”进行素数判定。这被称为 确定性米勒-拉宾测试（Deterministic Miller-Rabin Test）。

根据Jim Sinclair等人的研究，对于 $N < 2^{64}$ （约 $1.8 \times 10^{19}$）的所有整数，只要选取以下 $7$ 个素数作为底数 $a$ 进行测试，就足以实现完全确定性的判定。

需要测试的底数 $a$ 列表: {2, 325, 9375, 28178, 450775, 9780504, 1795265022}

或者，使用另一组广为人知的 $12$ 个素数，同样能够在 $N < 2^{64}$ 的范围内进行完美判定： {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}

在本次实现中，为了兼顾算法的简洁性与高可靠性，我们采用基于后者 $12$ 个素数（或更为优化的 $7$ 个基底）的方法。在C++的实现中，通过条件分支划分数值范围，进行优化以将测试次数降至最低。

5. 使用C++的高级实现 (Highly Optimized C++ Implementation)

接下来，我们将结合迄今为止的数学理论与算法设计，展示现代C++中最强级别的米勒-拉宾素数判定函数的实现代码。

实现要点

避免64位整数乘法的溢出: 当 $N \approx 10^{18}$ 时，取模乘法中的 $x \times x$ 最大可达 $10^{36}$，会轻松超过普通64位整数（uint64_t 或 long long）的最大值 $1.8 \times 10^{19}$ 导致溢出。为了解决这个问题，我们使用GCC和Clang的扩展类型 __int128_t（或 unsigned __int128），在进行128位精度的计算后再取模。这样一来，无需复杂的算法也能高速完成取模乘法。
确定性基底的选择: 当 $N$ 的值较小时，优化代码使得只需测试少量的底数（base）。

完整的C++源代码

下面给出可用于实战的最终版源代码。您可以直接将此代码复制到算法竞赛等环境中使用。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96


#include <iostream>
#include <vector>
#include <cstdint>
#include <initializer_list>

using namespace std;

// 使用 128 位整数进行高速的 (a * b) mod m 计算
inline uint64_t mod_mul(uint64_t a, uint64_t b, uint64_t m) {
 return (uint64_t)((unsigned __int128)a * b % m);
}

// 使用反复平方法计算 (base^exp) mod m
uint64_t mod_pow(uint64_t base, uint64_t exp, uint64_t m) {
 uint64_t res = 1;
 base %= m;
 while (exp > 0) {
 if (exp & 1) res = mod_mul(res, base, m);
 base = mod_mul(base, base, m);
 exp >>= 1;
 }
 return res;
}

// 基于米勒-拉宾素数判定法的 64 位整数确定性判定
bool is_prime_miller_rabin(uint64_t n) {
 // 边界值与小素数的提前判定
 if (n < 2) return false;
 if (n == 2 || n == 3 || n == 5 || n == 7) return true;
 if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) return false;

 // 分解为 n-1 = d * 2^s 的形式
 uint64_t d = n - 1;
 int s = 0;
 while ((d & 1) == 0) {
 d >>= 1;
 s++;
 }

 // 判定所用的底数 (bases) 列表
 // 根据 N 的大小，将需要测试的基底数量优化到最低限度
 vector<uint64_t> bases;
 if (n < 4759123141ULL) {
 bases = {2, 7, 61};
 } else if (n < 1122004669633ULL) {
 bases = {2, 13, 23, 1662803};
 } else {
 // 对于所有 N < 2^64 的数，都能提供确定性判定的 7 个底数
 bases = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
 }

 // 对每个底数执行测试
 for (uint64_t a : bases) {
 a %= n;
 if (a == 0) continue; // 当 a 为 n 的倍数时无法判定，但能说明 n 不是素数

 uint64_t x = mod_pow(a, d, n);
 if (x == 1 || x == n - 1) continue; // 满足第一条件，进入下一个底数

 bool composite = true;
 // 循环 s-1 次 (x = x^2 mod n)
 for (int r = 1; r < s; r++) {
 x = mod_mul(x, x, n);
 if (x == n - 1) {
 composite = false; // 满足第二条件，可能是素数
 break;
 }
 }

 // 如果所有条件都不满足，则确认为合数
 if (composite) return false;
 }

 // 所有基底都满足条件，则确认为素数
 return true;
}

int main() {
 // 测试用例
 vector<uint64_t> test_cases = {
 1000000007, // 著名的素数
 998244353, // 著名的素数
 1000000000000000003, // 10^18 附近的素数
 1000000000000000007, // 合数 (10^18 + 7)
 561, // 卡迈克尔数 (合数)
 18446744073709551557ULL // 2^64 附近最大的素数之一
 };

 for (uint64_t n : test_cases) {
 cout << n << " is "
 << (is_prime_miller_rabin(n) ? "Prime" : "Composite")
 << endl;
 }

 return 0;
}

6. 算法的时间复杂度与性能评估

接下来探讨所实现算法的性能。

时间复杂度 (Time Complexity)

试除法: $O(\sqrt{N})$
费马测试: 幂运算 $O(\log N) \times k$ （$k$ 为尝试次数）
米勒-拉宾法: 幂运算及内部循环 $O(\log N) \times k$

在64位环境（$N \le 2^{64}$）下，上述确定性米勒-拉宾法最多只验证 $7$ 个基底。因此，可将 $k \le 7$ 视为常数，整体的时间复杂度严格来说就是 $O(\log N)$。即使在最坏情况下（$N \approx 10^{19}$），执行步骤也最多只有 $7 \times 64 = 448$ 步基本运算，运行时间在数微秒（$10^{-6}$ 秒）以内。与试除法的 $O(\sqrt{N})$（循环次数 $\approx 4 \times 10^9$ 次）相比，实现了 数百万倍的性能提升。

进一步优化：蒙哥马利乘法 (Montgomery Multiplication)

在本文的实现中，我们使用了128位整数扩展类型 __int128_t 来进行除法（取模运算 %）。即使在现代CPU上，整数除法（DIV指令）也是比加法和乘法花费更多周期（数十个周期）的高成本指令。

追求极限优化的代码库作者或竞赛选手，有时会采用被称为 蒙哥马利乘法（Montgomery Multiplication） 的技术。蒙哥马利乘法通过将数字映射到特殊的“蒙哥马利空间”，是一种能将高成本的取模运算（除法）替换为“仅需位移和乘法”的惊人算法。将此技术引入到米勒-拉宾判定的取模乘法中，可将执行速度进一步提升2到3倍左右。由于这是一个极其深奥的主题，我希望能在另一篇文章中对其进行详细讲解。

7. 总结

本文从素数判定的基础一直讲解到了进阶内容。让我们回顾一下要点：

试除法 确切可靠，但由于时间复杂度为 $O(\sqrt{N})$，当 $N$ 超过 $10^{12}$ 时缺乏实用性。
费马测试 在 $O(\log N)$ 内极其快速，但有着被卡迈克尔数等绝对伪素数欺骗的致命弱点。
米勒-拉宾素数判定法 解决了费马测试的弱点，是最具实用性且最强的算法。
在使用C++实现时，通过运用 __int128_t 可以安全地处理64位整数的乘法溢出。
在64位整数范围（$N < 2^{64}$）内，通过选取 $7$ 个或 $12$ 个特定的素数作为底数，可以进行确定性（100%准确）而非概率性的素数判定。

在涉及大数字计算的领域，高速的素数判定是一项不可或缺的技术。本文提供的C++米勒-拉宾源代码健壮可靠，可直接应用于实战。请务必在您的项目或算法竞赛中尝试使用它。

graph LR TrialDivision["试除法 (O(√N))"] --> Fermat["费马测试 (O(log N), 存在弱点)"] Fermat --> MillerRabin["米勒-拉宾法 (O(log N), 可转化为确定性)"] MillerRabin --> Montgomery["+ 蒙哥马利乘法 (常数倍加速)"] style MillerRabin fill:#f9f,stroke:#333,stroke-width:2px

编程与数学交织的算法世界是如此美丽且深奥。希望能为您的学习带来帮助。

参考资料 (Reference):

Pomerance, C., Selfridge, J. L., & Wagstaff, S. S. (1980). The pseudoprimes to 25.10^9. Mathematics of Computation.
Sinclair, J. (2011). Deterministic Miller-Rabin primality testing.

【数学解说】让高中生也能看懂的RSA加密原理

Fri, 11 Sep 2026 13:00:00 +0900

互联网社会安全的基础技术之一是“RSA加密”。在线购物的信用卡支付、与朋友的SNS交流、公司机密信息的收发等，我们每天都在不经意间使用的很多通信，都是由RSA加密或其后继技术保护着的。

然而，一听到“密码（加密）”，你可能会想象出间谍电影中出现的复杂密码机，或者只有少数天才才能理解的超高级数学。确实，现代密码学基于高级数学，但RSA加密的根本原理，只要有高中学过的数学（整数的性质、素数、同余式等）知识就足以理解。

本文将以高中数学知识为起点，逐步彻底解说RSA加密是基于怎样的数学原理运行的，以及为什么破解它如此困难。为了让稍微不擅长数学的人也能理解，我们将结合具体例子进行详细说明。

1. 对称加密与非对称加密（公开密钥加密）

在进入RSA加密的数学原理之前，我们先来整理一下加密的基本概念。加密方式大致分为“对称加密（共享密钥加密）”和“非对称加密（公开密钥加密）”两种。

1.1 对称加密方式的局限性

自古以来使用的密码大多被称为“对称加密方式”。这是一种在“加密（将消息转换为秘密的密文）”和“解密（将密文还原为原始消息）”时使用相同密钥的方式。

例如，爱丽丝想给鲍勃发送一封秘密信件。爱丽丝用挂锁（对称密钥）把信锁在盒子里。鲍勃要打开那个盒子，就必须拥有与爱丽丝使用的相同的钥匙。

这种方式存在一个大问题，那就是“密钥分发问题”。相隔遥远的爱丽丝和鲍勃在第一次通信时，该如何共享密钥而不被窃听呢？如果在邮寄密钥的途中被第三方窃取，之后的加密通信将全部泄露。

1.2 划时代的发明“公开密钥加密方式”

为了解决这个密钥分发问题而发明的就是“公开密钥加密方式”。RSA加密也是其中一种。

在公开密钥加密方式中，使用**“用于加密的密钥（公钥）”和“用于解密的密钥（私钥）”这两个不同的密钥**。

接收者鲍勃创建一对“公钥”和“私钥”。
鲍勃将“公钥”向全世界公开（任何人获取都可以）。
发送者爱丽丝使用鲍勃的“公钥”对消息进行加密并发送。
加密后的消息，只有拥有鲍勃“私钥”的人（即鲍勃自己）才能解密。

如果用挂锁来比喻，鲍勃制作了许多“处于打开状态的挂锁（公钥）”并散布到全世界。爱丽丝把要寄给鲍勃的信放进盒子里，捡起鲍勃的挂锁“咔哒”一声锁上。挂锁一旦锁上，就只能用鲍勃拥有的“万能钥匙（私钥）”才能打开。即使有人中途偷了盒子，因为没有万能钥匙也无法打开。

graph TD A["爱丽丝 (发送者)"] --> B["明文 (消息)"] B --> C["加密处理"] D["鲍勃的公钥 (任何人皆可获取)"] --> C C --> E["通过互联网发送: 密文"] E --> F["解密处理"] G["鲍勃的私钥 (仅鲍勃拥有)"] --> F F --> H["还原的明文 (消息)"] H --> I["鲍勃 (接收者)"]

为了实现这个划时代的系统，需要一种**“单向函数（单向的数学谜题）”**，即“用公钥很容易加密，但如果没有私钥绝对无法解密”。作为这个谜题的部件而被看中的，就是我们熟知的“素数（质数）”。

2. 支撑RSA加密的数学基础1：素数与素因数分解

RSA加密的安全性基于**“对巨大数字进行素因数分解非常困难”**这一数学事实。

2.1 什么是素数

素数是指“只能被1和自身整除的、大于1的自然数”。例如：$2, 3, 5, 7, 11, 13, 17, 19, 23...$

素数就像是所有整数的“原子”。任何自然数都可以分解成素数相乘的形式。这被称为素因数分解。例如，$60 = 2^2 \times 3 \times 5$，如果不考虑顺序，素因数分解的方式只有一种，这就是著名的“算术基本定理”。

2.2 素因数分解的困难性（单向函数）

这里重要的是**“乘法很容易，但素因数分解很难”**这种非对称性。

例如，请心算下面两个素数的乘法： $11 \times 13 = ?$ 这很简单吧。答案是 $143$。

那么，下面这个数呢？请对 $323$ 进行素因数分解。怎么样？应该会花点时间吧。（答案是 $17 \times 19$）。

如果数字很小，人类还能勉强计算出来，但当数字变大时，即使使用计算机，计算也会呈爆炸式增长。目前主流的RSA加密中，使用了2048位（十进制约600位）这样极其巨大的素数 $p$ 和 $q$ 相乘得到的数 $N = p \times q$。

当给出两个巨大的素数 $p$ 和 $q$ 时，计算机计算 $N$ 只需要一瞬间（不到一毫秒）。然而，反过来如果只给出 $N$，要找出原来的 $p$ 和 $q$，即使让目前最快的超级计算机运行数万亿年也解不出来。

这种**“计算的非对称性（去向容易，逆向困难）”**，构成了公钥和私钥之间关系的基础。

3. 支撑RSA加密的数学基础2：同余式（模运算）

RSA加密的计算，并不是我们在日常生活中使用的无限变大的加法或乘法，而是在除以某个数后的“余数”世界里进行的。这被称为同余式（模运算）。

3.1 钟表数学

模运算常被比喻为“钟表数学”。假设现在是10点，那么5小时后是几点？虽然 $10 + 5 = 15$ 点，但在普通的12小时制钟表上，我们会回答“3点”。这是因为15除以12的余数是3。

在数学世界中，这被写成如下形式：

$$ 15 \equiv 3 \pmod{12} $$

读作“15和3在模12下同余（除以12的余数相等）”。

3.2 同余式的基本性质

同余式有着与等式（$=$）非常相似且非常方便的性质。设模数（除数）为 $N$。当 $a \equiv b \pmod N$ 且 $c \equiv d \pmod N$ 时，以下性质成立：

加法: $a + c \equiv b + d \pmod N$
减法: $a - c \equiv b - d \pmod N$
乘法: $a \times c \equiv b \times d \pmod N$
乘方: $a^k \equiv b^k \pmod N$ （$k$ 为自然数）

特别重要的是“乘方”的性质。这意味着**“余数的乘方，等于乘方的余数”**。例如，假设我们想求 $7^{100}$ 除以 $5$ 的余数。如果要老老实实地把 $7$ 乘100次再除以 $5$，那简直是场灾难。但如果使用同余式的性质，因为 $7 \equiv 2 \pmod 5$，所以 $7^{100} \equiv 2^{100} \pmod 5$，计算就会变得非常简单。在密码学的世界里，因为要处理非常大的数字的乘方，所以这个性质是必不可少的。

4. 支撑RSA加密的数学基础3：欧拉函数与欧拉定理

接下来的部分是RSA加密核心的魔法数学。作为“费马小定理”的推广，“欧拉定理”即将登场。

4.1 欧拉函数 $\phi(N)$

欧拉函数（$\phi$ 函数）是指，对于某个自然数 $N$，**“返回从1到 $N$ 的自然数中，与 $N$ 互质（最大公约数为1）的数的个数”**的函数。

我们来看几个例子：

$\phi(5)$: 在 1, 2, 3, 4, 5 中，与 5 互质的数有 1, 2, 3, 4，共4个。因此 $\phi(5) = 4$。
$\phi(6)$: 在 1, 2, 3, 4, 5, 6 中，与 6 互质的数有 1, 5，共2个。因此 $\phi(6) = 2$。

【素数时的特殊性质】 当 $p$ 是素数时，从1到 $p-1$ 的所有数都与 $p$ 互质。因此，

$$ \phi(p) = p - 1 $$

【素数乘积时的特殊性质】 对于两个不同的素数 $p$ 和 $q$，如果 $N = p \times q$，那么 $\phi(N)$ 可以通过以下计算轻松求出：

$$ \phi(N) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

这个性质起到了RSA加密中“秘密后门（陷门）”的作用。知道 $p$ 和 $q$ 的人（密钥创建者）可以瞬间计算出 $\phi(N)$，而只知道 $N$ 的第三方，除非对 $N$ 进行素因数分解，否则无法求出 $\phi(N)$。

4.2 欧拉定理

莱昂哈德·欧拉利用这个 $\phi(N)$，证明了以下这个优美的定理。

欧拉定理： 当整数 $a$ 和 $N$ 互质时，以下同余式成立。

$$ a^{\phi(N)} \equiv 1 \pmod N $$

这是一个惊人的性质，意思是“将某个数 $a$ 连续相乘 $\phi(N)$ 次后除以 $N$，余数必定是 $1$”。（当 $N$ 为素数 $p$ 时，变为 $a^{p-1} \equiv 1 \pmod p$，这被称为费马小定理）。

让我们对这个欧拉定理进行变形。在等式两边再乘一次 $a$。

$$ a^{\phi(N) + 1} \equiv a \pmod N $$

进一步地，对于任意整数 $k$，$a^{k \cdot \phi(N)}$ 也等于 $1^k = 1$，因此以下等式成立：

$$ a^{k \cdot \phi(N) + 1} \equiv a \pmod N $$

这个公式正是让RSA加密实现**“加密后再解密就能恢复原状”**这一魔法的根本原理。

5. RSA加密的算法：密钥生成、加密、解密的步骤

基础知识准备齐全后，终于可以来看RSA加密的具体步骤了。RSA加密大致分为“1. 密钥生成”、“2. 加密”和“3. 解密”三个阶段。

flowchart TD A1["1. 选择素数 p, q"] --> A2["计算 N = p × q"] A1 --> A3["计算 φ(N) = (p-1)(q-1)"] A3 --> A4["选择与 φ(N) 互质的 e"] A3 --> A5["计算 d 使 e × d ≡ 1 (mod φ(N))"] A2 --> A6["公钥 (N, e)"] A4 --> A6 A5 --> A7["私钥 d"] B1["2. 明文消息 M"] --> B2["计算 C ≡ M^e (mod N)"] A6 -.-> B2 B2 --> B3["发送密文 C"] B3 --> C1["3. 收到密文 C"] C1 --> C2["计算 M ≡ C^d (mod N)"] A7 -.-> C2 C2 --> C3["获取原始明文消息 M"]

5.1 密钥生成（Key Generation）

接收者鲍勃将生成属于自己的“公钥”和“私钥”。

选择素数: 随机选择两个大素数 $p$ 和 $q$。
计算模数 $N$: 计算 $N = p \times q$。这个 $N$ 是公开的。
计算 $\phi(N)$: 计算欧拉函数 $\phi(N) = (p - 1)(q - 1)$。这是只有鲍勃知道的秘密数字。
选择公钥 $e$: 选择一个满足 $1 < e < \phi(N)$，且与 $\phi(N)$ 互质的整数 $e$。
计算私钥 $d$: 找到一个满足以下条件的整数 $d$。 $$ e \times d \equiv 1 \pmod{\phi(N)} $$ 换句话说，就是寻找“一个数 $d$，使得 $e \times d$ 除以 $\phi(N)$ 的余数是 $1$”。

到这里，密钥的准备就完成了。

公钥: $(N, e)$ 的组合。向全世界公开。
私钥: $d$。绝对不能告诉任何人。

5.2 加密（Encryption）

假设爱丽丝想给鲍勃发送秘密消息 $M$。（$M$ 是将文字数字化的结果，且 $0 \le M < N$）。爱丽丝使用鲍勃的公钥 $(N, e)$ 进行如下计算：

$$ C \equiv M^e \pmod N $$

计算“消息 $M$ 的 $e$ 次方，除以 $N$ 的余数 $C$”。这个 $C$ 就是密文。

5.3 解密（Decryption）

鲍勃收到了密文 $C$。鲍勃使用私钥 $d$ 进行如下计算：

$$ M \equiv C^d \pmod N $$

计算“密文 $C$ 的 $d$ 次方，除以 $N$ 的余数”，结果竟然奇迹般地恢复成了原始消息 $M$！

6. 为什么解密能恢复原状？（数学证明）

你可能会感到疑惑：“为什么只要对 $C$ 求 $d$ 次方，就能恢复成原来的 $M$ 呢？”这时，刚才提到的“欧拉定理”就要大显身手了。

我们将加密公式 $C = M^e$ 代入解密的计算公式 $C^d \pmod N$ 中看看。

$$ C^d \equiv (M^e)^d \equiv M^{ed} \pmod N $$

这里，请回想一下密钥生成步骤的第5步。鲍勃在生成 $d$ 时，是按照满足 $e \times d \equiv 1 \pmod{\phi(N)}$ 来选择的。这意味着“$ed$ 是 $\phi(N)$ 的倍数加上 $1$”。使用整数 $k$ 可以写成如下形式：

$$ ed = k \cdot \phi(N) + 1 $$

将其代入指数部分，并利用指数法则进行分解：

$$ M^{ed} = M^{k \cdot \phi(N) + 1} = M^{k \cdot \phi(N)} \times M^1 = (M^{\phi(N)})^k \times M $$

假设消息 $M$ 和 $N$ 互质，根据欧拉定理，会有 $M^{\phi(N)} \equiv 1 \pmod N$。

$$ (M^{\phi(N)})^k \times M \equiv 1^k \times M \equiv M \pmod N $$

因此，下面这个式子完美成立了：

$$ C^d \equiv M \pmod N $$

爱丽丝不知道 $d$，窃听者也不知道 $d$，所以只有拥有 $d$ 的鲍勃，才能从 $C$ 中提取出 $M$。

7. 具体例子：用小素数手工计算体验RSA

让我们实际使用小数字（素数），来模拟一次爱丽丝向鲍勃发送加密通信的过程吧。

【鲍勃的密钥生成阶段】

选择两个素数 $p=11$, $q=13$。
计算 $N = 11 \times 13 = 143$。
计算 $\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$。
选择与 $\phi(N)=120$ 互质的公钥 $e$。这里我们选 $e=7$。
求解私钥 $d$。寻找满足 $7 \times d \equiv 1 \pmod{120}$ 的 $d$。在方程 $7d = 120k + 1$ 中，当 $k=6$ 时右边为 $721$，$721 \div 7 = 103$。因此，$d = 103$。

公钥：$(N=143, e=7)$
私钥：$d=103$

【爱丽丝的加密阶段】 假设要发送消息 $M = 9$。公式：$C \equiv 9^7 \pmod{143}$ $9^7 = 4,782,969$。除以 143 后商是 $33447$，余数为 $48$。所以密文 $C = 48$。

【鲍勃的解密阶段】 鲍勃收到密文 $C = 48$，使用私钥 $d = 103$ 进行解密。公式：$M \equiv 48^{103} \pmod{143}$ 如果在计算器上执行 (48 ** 103) % 143，结果精彩地显示为“9”！我们成功收到了原来的消息。

8. 求私钥 $d$ 的方法：扩展欧几里得算法

在手工计算的例子中，我们是靠直觉寻找 $k$ 来得出 $d=103$ 的，但当数字达到几百位时，这种方法就行不通了。实际的程序中会使用名为**“扩展欧几里得算法”**的算法。

求解 $7d \equiv 1 \pmod{120}$，就等同于寻找满足 $7d + 120y = 1$ 的整数 $d$ 和 $y$。通过逆向推导欧几里得算法，就可以机械地求出这个解。

$120 \div 7 = 17$ 余 $1$
变形后得到，$1 = 120 - 17 \times 7$
也就是说，$-17 \times 7 \equiv 1 \pmod{120}$

$-17$ 在模 $120$ 的世界里，与 $120 - 17 = 103$ 意义相同。因此，瞬间就能求出 $d = 103$。这种方法无论数字多大，都能非常快速地进行计算。

9. RSA加密的另一面：数字签名

RSA加密非常棒的一点是，通过反转公钥和私钥的作用，它还可以用作**“数字签名”**。

在加密时，是“用公钥加密 $\Rightarrow$ 用私钥解密”，而在数字签名中，步骤变成了“用私钥加密 $\Rightarrow$ 用公钥解密”。

flowchart TD A1["1. 爱丽丝用私钥生成签名"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["发送消息 M 和签名 S"] A3 --> B1["2. 鲍勃用公钥验证签名"] B1 --> B2["计算 M' ≡ S^e (mod N)"] B2 --> B3["确认 M' 和 M 是否一致"]

爱丽丝使用自己的私钥 $d$ 对消息进行转换（这就是签名 $S$），然后发送给鲍勃。鲍勃使用爱丽丝的公钥 $e$ 进行验证计算。如果计算结果与原始消息一致，就能同时证明“这是只有爱丽丝的私钥才能生成的数据”以及“消息在传输过程中没有被篡改”。

10. 通过程序感受RSA加密

手工计算非常困难的乘方计算，如果使用Python就能非常轻松地实现。以下是可以体验RSA加密核心逻辑的Python代码。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


def gcd(a, b):
 """求最大公约数"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """求私钥 d（利用 Python 3.8 及以上版本的内置功能）"""
 return pow(e, -1, phi)

# 1. 密钥生成
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"公钥: (N={N}, e={e}), 私钥: d={d}")

# 2. 加密
message = 9
ciphertext = pow(message, e, N)
print(f"密文: {ciphertext}")

# 3. 解密
decrypted_message = pow(ciphertext, d, N)
print(f"解密后的消息: {decrypted_message}")

Python 的 pow(base, exp, mod) 函数在内部使用了称为“快速幂（反复平方法）”的高效算法，所以即使是几百位的数字，也能在一瞬间完成计算。

11. 总结与未来的密码技术

我们以高中数学知识为基础，揭开了RSA加密原理的面纱。

素因数分解的困难性: $p \times q = N$ 很容易计算，但从 $N$ 找出 $p, q$ 却极其困难。
同余式与欧拉定理: 根据 $a^{\phi(N)} \equiv 1 \pmod N$ 这一法则，完成了“乘方某次后恢复原状”的魔法陷门。
公钥与私钥: 任何人都可以加密，但只有合法的接收者才能解密。

目前使用的RSA加密中，$N$ 超过600位，即使动员全世界的超级计算机，进行素因数分解也需要花费超过宇宙年龄的时间。然而，随着近年来“量子计算机”研究的推进，如果在未来投入实用，通过“秀尔算法”，这种素因数分解可能会被瞬间破解。因此，目前世界各地正在加紧开发连量子计算机都无法破解的“抗量子计算密码（后量子密码学）”。

那些常被认为“没有用处”的高级数学，实际上正在底层默默保护着我们的日常生活。RSA加密正是向我们展示这种数学深度与美感的最佳教材。希望通过这篇文章，能让您哪怕多感受到一点密码学与数学的乐趣。

什么是完全同态加密（FHE）？解密下一代安全的核心

Fri, 11 Sep 2026 11:00:00 +0900

随着云计算和AI技术作为社会基础设施的普及，“数据隐私”与“数据利用”之间的权衡已成为最重要的问题之一。虽然医疗数据、金融信息和个人生物特征信息等高度机密数据在云端交由AI进行分析的需求日益增长，但出于安全考虑，不少企业仍对向外部发送数据犹豫不决。

传统的加密技术（如AES和RSA等）擅长保护存储中的数据（Data at Rest）和网络传输中的数据（Data in Transit）。然而，当服务器端对数据进行搜索或机器学习等处理（计算）时（Data in Use），必须先解密恢复为明文。如果在解密的这一时刻服务器遭到黑客攻击，或者内部的恶意管理员窥探数据，将直接导致信息泄露。

克服“处理时解密”这一根本弱点的梦幻技术，便是完全同态加密（Fully Homomorphic Encryption: FHE）。利用FHE，可以在保持数据加密且完全不解密的情况下进行计算处理，并仅将结果的密文返回给客户端。

本文将从FHE的概念、历史、Craig Gentry的突破性进展、数学基础（如Ring-LWE），到其面临的最大挑战“噪声”及其解决方案（自举，Bootstrapping），以及最新的实现库，全面深入地解析作为下一代安全核心的FHE。

1. 什么是同态加密？基本概念

“同态（Homomorphic）”是代数术语，指在具有某种结构的集合之间，能够保持运算结构不变地进行映射的性质。在密码学理论中，“同态性”指的是明文空间中的运算与密文空间中的运算相对应的性质。

用简单的数学公式表示，设明文 $m_1$ 和 $m_2$ 的加密函数为 $E(\cdot)$，解密函数为 $D(\cdot)$。当明文上的运算（如加法或乘法等）记为 $\circ$，密文上的运算记为 $\diamond$ 时，成立以下关系：

$$ D(E(m_1) \diamond E(m_2)) = m_1 \circ m_2 $$

也就是说，对密文 $E(m_1)$ 和 $E(m_2)$ 施加某种运算 $\diamond$ 后，将其结果解密，会与原始明文之间进行 $\circ$ 运算的结果一致。

云计算中的数据流

使用FHE的云处理架构与传统的完全不同。下图展示了利用FHE进行安全数据处理的流程。

服务器虽然接收到加密后的数据 $E(x)$，但由于没有私钥，绝对无法得知数据的内容。然而，通过利用FHE的性质，可以对密文应用函数 $f$（例如机器学习的推理模型）并生成 $E(f(x))$。客户端接收到该结果后，通过自己的私钥解密，便可获得目标结果 $y = f(x)$。

2. 同态加密的发展历史：PHE, SHE, FHE

同态加密并不是一蹴而就达到现在的“完全”形态的。根据能够实现的运算类型和次数，它大致可分为三个阶段。

Partially Homomorphic Encryption (PHE: 部分同态加密)

PHE是仅能无限制地进行加法或乘法其中一种运算的加密方式。实际上，具有这种性质的加密算法自古就已存在。

RSA加密（对乘法的同态性） RSA加密无意中具有乘法同态性。设明文为 $m_1, m_2$，公钥为 $(e, N)$，则： $$ E(m_1) = m_1^e \pmod N $$ $$ E(m_2) = m_2^e \pmod N $$ 将它们相乘： $$ E(m_1) \times E(m_2) = (m_1 \cdot m_2)^e \pmod N = E(m_1 \times m_2) $$ 这样，密文之间的乘法就对应于明文的乘法。
Paillier加密（对加法的同态性） 1999年发明的Paillier加密具有加法同态性。它已被实际应用于电子投票（汇总加密选票，仅解密最终结果）等场景中。

Somewhat Homomorphic Encryption (SHE: 有限同态加密)

这是一种可以同时执行加法和乘法的加密方式，但可运算的次数（电路深度）有限制。由于后文将提到的“噪声”积累，当进行超过一定次数的乘法运算后，就会变得无法解密。2005年的BGN（Boneh-Goh-Nissim）加密等就属于此类，但在进行实际复杂的计算（如深度学习等）时存在局限性。

Fully Homomorphic Encryption (FHE: 完全同态加密)

这是一种可以无限制次数地同时执行加法和乘法运算的加密方式。正如信息论中的图灵完备性一样，只要能够无限地组合加法（相当于XOR）和乘法（相当于AND），在原理上就意味着可以在保持加密状态下执行任何可计算的函数和算法。

FHE长期以来被称为“密码学界的圣杯”，甚至有人认为它是不可能实现的。然而，在2009年，当时正在斯坦福大学攻读博士学位的 Craig Gentry 提出了基于理想格（Ideal Lattices）的首个FHE方案，震惊了世界。

3. FHE的数学基础：LWE问题和Ring-LWE

目前主流的许多FHE方案都基于LWE（Learning With Errors，容错学习）问题，这是“格密码（Lattice-based Cryptography）”——也以抗量子计算机密码（Post-Quantum Cryptography）而闻名——中的一个数学难题。

LWE问题的直观理解

使用高斯消元法等方法，求解线性方程组是很容易的。

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 \equiv 12 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 \equiv 8 \pmod{17} \\ \vdots \end{cases} $$

然而，如果在该方程组的结果中加入极微小的“随机误差（噪声）” $e$，会发生什么呢？

$$ \begin{cases} 3s_1 + 4s_2 + 2s_3 + e_1 \equiv 13 \pmod{17} \\ 1s_1 + 9s_2 + 5s_3 + e_2 \equiv 7 \pmod{17} \\ \vdots \end{cases} $$

仅仅加入这个误差 $e$，寻找秘密变量向量 $\vec{s}$ 的问题就会转变为一个即使使用现代超级计算机或量子计算机也难以破解的NP困难问题。这就是LWE问题。

Ring-LWE问题（RLWE）

标准的LWE问题由于包含矩阵运算，存在密钥尺寸非常大（甚至可能达到千兆字节级别）且计算效率低下的问题。为了解决这一问题，引入了使用多项式环上运算的Ring-LWE（RLWE）问题。

在RLWE中，元素属于多项式环 $R_q = \mathbb{Z}_q[x] / (x^N + 1)$（其中 $N$ 是2的幂，$q$ 是作为模的素数）。设私钥为多项式 $s(x)$，一个随机多项式为 $a(x)$，小噪声多项式为 $e(x)$，那么公钥就是以下对：

$$ (a(x), b(x)) \quad \text{where} \quad b(x) = -a(x) \cdot s(x) + e(x) \pmod q $$

在加密时，将利用这种多项式的性质对明文 $m(x)$ 进行编码，并生成密文。

4. 最大障碍“噪声”与Gentry的自举（Bootstrapping）

在理解FHE时，最重要的概念就是**“噪声管理”**。

在基于LWE/RLWE的密码中，为了保证安全性，会有意加入较小的“噪声（误差）”。将明文 $m$ 的密文 $c$ 解密的过程，粗略地说，可以用以下公式表示：

$$ D(c) = (c \cdot s) \pmod q = m + \text{noise} $$

在解密时，通过舍入等操作去除这个 noise 即可得到正确的明文 $m$。然而，一旦在密文之间进行同态运算（尤其是乘法），这种噪声就会急剧放大。

同态加法: 噪声以加法的方式增加（$e_1 + e_2$）。这种增加相对较慢。
同态加法的同态性数学表示: $$ E(m_1) \oplus E(m_2) = E(m_1 + m_2) $$
同态乘法: 噪声呈爆炸性倍乘（因为它包含了 $e_1 \times e_2$ 等项）。仅仅经过几次乘法运算，噪声就会超过阈值 $q/2$，导致无法进行正确的舍入处理，从而解密失败。
同态乘法的同态性数学表示: $$ E(m_1) \otimes E(m_2) = E(m_1 \times m_2) $$

这就是FHE长期无法实现，只能停留在SHE（次数受限）阶段的原因。

自举（Bootstrapping）的魔力

Craig Gentry的天才贡献在于他发明了一种被称为**“自举（Bootstrapping）”**的降噪技术。这是密码学领域的一次范式转变。

直观上，这个操作就是“在密文充满噪声而崩溃之前，在保持加密的状态下对其进行‘解密’清理，然后重新放入一个新密文中”。

假设有一个噪声变得很大的密文 $C_{noisy}$。
客户端预先将使用公钥“加密后的私钥 $sk$” $E_{pk}(sk)$（称之为自举密钥）发送给服务器。
服务器对 $C_{noisy}$ 执行同态的解密电路（Decryption Circuit）。
具体来说，就是利用 $E_{pk}(sk)$ 对 $E_{pk}(C_{noisy})$ 进行“在加密空间内的解密”。
尽管这个解密电路本身也是同态运算，会产生新的噪声，但其输出的新密文 $C_{fresh}$ 的噪声会被重置为一个特定的“固定水平”。

graph LR A["高噪声密文 C_noisy"] --> B["同态解密电路 (Eval_Dec)"] C["加密后的私钥 E(sk)"] --> B B --> D["低噪声密文 C_fresh"] style B fill:#ffeeba,stroke:#ffc107

通过在计算过程中定期执行这种自举操作，理论上就可以计算无限深度的电路（实现了FHE）。然而，在Gentry最初的方案中，这种自举处理一次需要数十分钟甚至数小时，计算成本高得令人绝望。

5. FHE的世代与主要方案的演进

为了使FHE走向实用化，全世界的密码学家们竞相改进算法。如今，FHE主要可分为四个世代或家族。

第二代：整数的精确运算 (BGV, BFV)

这是在2011年至2012年间出现的 BGV（Brakerski-Gentry-Vaikuntanathan） 和 BFV（Brakerski/Fan-Vercauteren） 方案。它们以RLWE为基础，适合进行整数的模运算（精确计算）。其特点是支持类似SIMD（单指令多数据）的批处理（Batching）技术，可以将数千个数据槽塞入一个巨大的多项式密文中，从而一次性进行并行计算。

第三代：加速自举 (GSW, FHEW, TFHE)

2013年的 GSW（Gentry-Sahai-Waters） 方案使FHE的结构变得更加简单。在其基础上发展而来的，便是当今的主流方案之一：TFHE（Fast Fully Homomorphic Encryption over the Torus）。 TFHE的特点在于其自举速度极快（毫秒级）。它擅长在门级（如AND、XOR等逻辑电路）进行运算，且密文尺寸相对较小，非常适合快速评估任意逻辑电路。

第四代：专注于近似计算与机器学习 (CKKS)

2017年由Cheon等人提出的 CKKS（Cheon-Kim-Kim-Song） 方案，可以说是当前AI与机器学习隐私保护领域的终极技术。相较于以往的FHE固执于“精确的整数计算”，CKKS支持在加密状态下进行**“浮点数的近似计算”**。在神经网络训练或推理等允许微小误差的实数计算中，它展现出压倒性的性能优势。

下表总结了根据不同目的选择方案的方法。

方案名称	擅长的数据类型	推荐的使用用例	特点
BFV / BGV	整数 (Integer)	精确的统计计算、金融数据汇总、数据库搜索	通过SIMD批处理实现高吞吐量
CKKS	实数 (Real/Complex)	机器学习 (DNN, 逻辑回归)、信号处理	利用近似计算实现加速、重缩放
TFHE	布尔值 (Boolean)	任意逻辑电路、字符串搜索、非线性函数评估	超高速自举（毫秒级）

6. 实践：FHE库及概念性代码

如今，有许多开源库可供使用，即使没有深厚的密码学知识，也可以轻松利用FHE。

Microsoft SEAL (Simple Encrypted Arithmetic Library)：支持BFV、BGV和CKKS的C++库，是行业标准之一。其Python绑定版本 TenSEAL 在AI工程师中非常受欢迎。
Zama (Concrete)：基于TFHE的框架。可以使用Rust/Python编写，并提供了将现有的PyTorch模型编译并运行在FHE上的功能（Concrete ML）。
OpenFHE：PALISADE的继任者，支持所有主要方案的综合性C++库。

使用Python（TenSEAL）进行FHE编程的示例

在这里，我们展示一段使用CKKS方案，在加密状态下对实数向量进行加法和乘法运算的概念性Python代码示例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


import tenseal as ts

# 1. 上下文设置 (包含密钥生成)
# 使用CKKS方案，将多项式的次数设置为8192
context = ts.context(
 ts.SCHEME_TYPE.CKKS,
 poly_modulus_degree=8192,
 coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40 # 实数的缩放因子

# 2. 客户端：数据加密
vector1 = [1.5, 2.5, 3.5]
vector2 = [2.0, 3.0, 4.0]

# 将明文向量转换为密文 (原本应该在客户端执行)
enc_v1 = ts.ckks_vector(context, vector1)
enc_v2 = ts.ckks_vector(context, vector2)

# 3. 服务器端：在加密状态下进行运算 (保护Data in Use)
# 服务器不知道明文，但可以执行加法和乘法
enc_add = enc_v1 + enc_v2
enc_mul = enc_v1 * enc_v2

# 4. 客户端：结果解密
# 只有拥有私钥的客户端才能看到结果
res_add = enc_add.decrypt()
res_mul = enc_mul.decrypt()

print(f"解密后的加法结果: {res_add}")
# 输出示例: [3.5000001, 5.5000001, 7.5000002] (因为是近似计算，会包含微小误差)

print(f"解密后的乘法结果: {res_mul}")
# 输出示例: [3.0000002, 7.5000005, 14.0000003]

正如上述代码所示，可以通过像 enc_v1 + enc_v2 这样重载常规Python运算符，直观地编写密文之间的计算。在服务器端，它可以在完全不知道向量内容的情况下完成向量运算。

7. FHE的挑战：性能与硬件加速

FHE在理论上提供了完美的安全性，但其实用化面临的最大挑战是**“性能开销”**。

计算开销：与明文计算相比，密文计算在CPU上的速度要慢几千倍甚至几万倍。多项式的乘法以及自举过程都需要进行大量的FFT（快速傅里叶变换）或NTT（数论变换）计算。
数据大小膨胀 (Ciphertext Expansion)：只需几个字节的明文，加密后就可能变成数兆字节。这会严重挤占内存带宽和网络带宽。

硬件解决方案的探索

为了克服这一开销，世界各地正在研发FHE专用的硬件加速器（支持ASIC、FPGA、GPU等）。

GPU加速：正在利用NVIDIA等强大的GPU，对NTT运算和自举进行并行化的尝试。据报道，其速度相比纯软件实现提升了数十倍（例如：100x.ai，Zama的TFHE-rs CUDA backend）。
DARPA DPRIVE 项目：美国国防高级研究计划局（DARPA）正在推进旨在将FHE的计算速度提升至与明文处理执行速度同等水平（开销控制在10倍以内）的专用硬件开发项目“DPRIVE (Data Protection in Virtual Environments)”，Intel、Microsoft、Intellectual Ventures等公司均有参与。
FPU (FHE Processing Unit) 的出现：Cornami、Optalysys等初创公司正着手研发使用光计算或特殊硅架构的FHE专用芯片。

在不久的将来，也许会迎来如同AI领域中NPU（Neural Processing Unit）一般，服务器或云基础设施标配“FPU”的时代。

8. 期待的应用用例

随着FHE逐渐达到实用的速度，它有望在以下领域带来颠覆性的创新。

医疗与基因组分析的隐私保护：通过对多家医院拥有的患者病历数据和DNA数据使用FHE加密，并在云端交由AI进行训练，可以在不违反隐私法规（如HIPAA和GDPR）的前提下，开展高精度的癌症诊断模型或新药研发。
金融机构的欺诈检测与反洗钱 (AML)：相互竞争的银行之间无需透露客户的账户信息或交易记录，即可在加密状态下比对彼此的数据，从而实现跨行分析，以检测庞大的非法汇款网络。
安全的AI推理API (MaaS: Model as a Service)：用户可以将自己的声音、面部图像或提示词加密后发送给AI服务（如ChatGPT等LLM）。AI提供商在完全不知道用户输入内容的情况下生成回答，并以密文形式返回。这将完全消除“AI会学习/窥探个人信息”的担忧。

9. 结论：密码学的未来走向“不可见计算”

正如20世纪70年代公钥加密（RSA）的发明使得互联网上的安全通信（如HTTPS）成为可能一样，Craig Gentry发明的FHE是密码学历史上最重要的里程碑之一。

如今，完全同态加密（FHE）已经走出实验室理论的范畴，进入了由Microsoft、IBM、Intel、Google以及众多初创企业为了实用化而展开激烈竞争的阶段。尽管仍面临计算成本和数据大小等挑战，但得益于算法的精进和硬件加速器的演进，其性能正以超越摩尔定律的速度持续提升。

在几年后，“对加密数据进行计算”将不再是一件特别的事情，而将成为云服务中标准数据保护的最佳实践。在数据驱动型社会中，FHE能够实现极致隐私保护与数据充分利用的完美结合，它无疑是下一代安全的核心。

椭圆曲线密码学（ECC）的数学基础与C++实现

Fri, 11 Sep 2026 10:00:00 +0900

椭圆曲线密码学（ECC）的数学基础与C++实现

在现代密码技术中，**椭圆曲线密码学（Elliptic Curve Cryptography: ECC）**发挥着极其重要的作用。从我们日常的互联网通信（HTTPS/TLS）、智能手机的安全隔离区（Secure Enclave）、通过SSH进行的服务器身份验证、FIDO等无密码认证，甚至到比特币和以太坊等加密资产，可以说现代数字社会的信任基础正是由ECC支撑的。

本文将从其背后的优美且深奥的数学理论（有限体上的代数几何学）出发，深入探讨椭圆曲线密码学是如何运作的，并结合C++的实际实现方法，乃至防止侧信道攻击（计时攻击）的安全编码技巧，以压倒性的篇幅为您进行彻底的讲解。

1. 为什么选择椭圆曲线密码学？（与RSA的比较）

说到公钥密码体制的代名词，长期以来一直非RSA密码莫属。RSA密码的安全性基于“大分解合成数的质因数分解的困难性”。然而，随着计算机计算能力的提高，为了维持安全性，必须不断增加RSA的密钥长度（模数的位数）。目前，建议的密钥长度至少为2048位，如果要求更安全，则推荐使用3072位或4096位。

相比之下，椭圆曲线密码学（ECC）的安全基础是另一种数学困难性，即**“椭圆曲线上的离散对数问题（ECDLP）”**。直到现在，尚未发现能够有效解决ECDLP的算法（如亚指数时间算法），即使是已知最有效的攻击方法也需要指数级的时间。

正是因为这一特性，ECC具有一个决定性的优势：能够在极短的密钥长度下实现与RSA同等的安全强度。

安全强度（位）	RSA密码的密钥长度（位）	椭圆曲线密码的密钥长度（位）	密钥长度比率
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

如上表所示，为了获得128位的安全强度（目前的标准强度），RSA需要3072位的密钥，而ECC仅需256位。这使得减少计算量、降低内存使用量和节约网络带宽成为可能，特别是在资源有限的物联网设备和智能卡环境中，ECC拥有压倒性的优势。

2. 数学准备：群论与有限体世界

为了真正理解椭圆曲线密码学，必须掌握抽象代数（群论和域论）的基本概念。在此，我们简要总结构建ECC所需的前提知识。

2.1. 群（Group）与阿贝尔群

**群（Group）**是指由一个集合 $G$ 及其上的二元运算（此处假设为加法 $+$）组成的集合 $(G, +)$，且满足以下四个公理：

封闭性（Closure）: 对于任意的 $a, b \in G$，$a + b \in G$ 成立。
结合律（Associativity）: 对于任意的 $a, b, c \in G$，$(a + b) + c = a + (b + c)$ 成立。
单位元的存在性（Identity element）: 存在元素 $e \in G$，使得对于任意的 $a \in G$，$a + e = e + a = a$ 成立。在加法群中，该单位元通常记为 $0$ 或 $\mathcal{O}$。
逆元的存在性（Inverse element）: 对于任意的 $a \in G$，存在元素 $b \in G$，使得 $a + b = b + a = e$。该 $b$ 记作 $-a$。

此外，如果改变运算顺序结果不变，即满足以下条件的群被称为阿贝尔群（交换群）：

交换律（Commutativity）: 对于任意的 $a, b \in G$，$a + b = b + a$ 成立。

椭圆曲线上的点集，通过定义特定的加法规则，构成了这种阿贝尔群。

2.2. 有限体（Finite Field）

在密码学理论中，我们使用的不是像实数或复数那样具有连续且无限元素的域，而是元素数量有限的**有限体（Finite Field）**或称伽罗瓦域（Galois Field）。

最基本的有限体是使用素数 $p$ 构成的素体 $\mathbb{F}_p$。它是在整数集合 $\{0, 1, 2, \dots, p-1\}$ 上，定义了模 $p$（除以 $p$ 的余数）的四则运算（加法、减法、乘法、除法）。

加法: $(a + b) \pmod p$
减法: $(a - b) \pmod p$
乘法: $(a \times b) \pmod p$
除法: $a \times b^{-1} \pmod p$ （这里 $b^{-1}$ 是模 $p$ 下 $b$ 的乘法逆元）

**乘法逆元（Modular Multiplicative Inverse）**的计算在密码学实现中极为重要。为了求出满足 $b \times b^{-1} \equiv 1 \pmod p$ 的 $b^{-1}$，主要使用以下两种算法：

扩展欧几里得算法（Extended Euclidean Algorithm）: 速度快，但根据实现的不同，处理时间可能依赖于输入值，从而存在计时攻击的风险。
费马小定理（Fermat’s Little Theorem）: 当 $p$ 为素数且 $b \neq 0$ 时，$b^{p-1} \equiv 1 \pmod p$ 成立。两边同除以 $b$，可得 $b^{p-2} \equiv b^{-1} \pmod p$。也就是说，通过计算 $b$ 的 $p-2$ 次方即可求得逆元。因为幂运算容易实现为常数时间操作，所以密码学实现中通常更倾向于使用这种方法。

3. 椭圆曲线的方程与几何学

3.1. 魏尔斯特拉斯标准型

**椭圆曲线（Elliptic Curve）通常由以下被称为魏尔斯特拉斯标准型（Weierstrass normal form）**的方程所定义的平面曲线：

$$ y^2 = x^3 + ax + b $$

在这里，$a$ 和 $b$ 是常数。为了确保曲线没有奇异点（自交点或尖点）（即这是一条平滑曲线），要求以下判别式（Discriminant） $\Delta$ 不为零：

$$ \Delta = -16(4a^3 + 27b^2) \neq 0 $$

带有奇异点的曲线会破坏密码学的安全性，因此必须选择满足该条件的系数 $a, b$。

3.2. 无穷远点（Point at Infinity）

为了使椭圆曲线在数学上构成一个完备的群，除了平面上的点之外，我们引入了一个称为**“无穷远点（Point at Infinity）”**的虚拟点。记作 $\mathcal{O}$（字母 O）。

无穷远点 $\mathcal{O}$ 被定义为所有垂直线在无穷远处的交点。在群论中，这个无穷远点 $\mathcal{O}$ 作为加法中的单位元（零）发挥作用。

也就是说，对于曲线上的任意点 $P$，以下等式成立：

$$ P + \mathcal{O} = \mathcal{O} + P = P $$

另外，点 $P = (x, y)$ 的逆元 $-P$，定义为关于 x 轴对称的点 $(x, -y)$。因此：

$$ P + (-P) = \mathcal{O} $$

成立。

4. 椭圆曲线上的群运算（点的加法与二倍算）

椭圆曲线密码学的核心在于曲线上点与点之间的**“加法（Addition）”**运算。这不同于普通整数的加法，它是基于几何操作来定义的。

4.1. 几何加法（切线与割线法 / Tangent and Chord Method）

将曲线上不同的两点 $P$ 和 $Q$ 相加，求得新点 $R$ ($R = P + Q$) 的步骤如下：

画一条穿过点 $P$ 和点 $Q$ 的直线（割线）。
根据代数几何学的定理，这条直线必然与椭圆曲线相交于第三个点（我们称之为 $-R$）。
将交点 $-R$ 关于 x 轴对称翻转（即 y 坐标的符号反转）得到的点，就是我们所求的点 $R$。

graph TD Step1["画一条连接 P(x1, y1) 和 Q(x2, y2) 的直线"] --> Step2["找到与曲线的第三个交点 -R"] Step2 --> Step3["将 -R 沿 x 轴翻转，得到 R(x3, y3)"] Step3 -.-> Result["这就是 R = P + Q"]

4.2. 点的二倍算（Point Doubling）

如果要在点 $P$ 上加上相同的点 $P$（$P + P = 2P$），我们无法画出穿过两点的直线。在这种情况下，我们要画出曲线在点 $P$ 处的切线（Tangent）。

画出曲线在点 $P$ 处的切线。
该切线将与曲线相交于另一个点 $-R$。
将交点关于 x 轴对称翻转得到的点，就是所求的点 $R = 2P$。

4.3. 代数计算公式

我们需要将几何操作转化为代数公式，以便计算机可以进行计算。所有的运算都在**有限体 $\mathbb{F}_p$ 上（模 $p$）**进行。

设点 $P = (x_1, y_1)$，点 $Q = (x_2, y_2)$。并且设计算结果的点为 $R = P + Q = (x_3, y_3)$。

设直线的斜率为 $\lambda$（Lambda）。

【情况1：当 $P \neq Q$ 时（点的加法）】 斜率 $\lambda$ 是两点间的变化率。

$$ \lambda \equiv \frac{y_2 - y_1}{x_2 - x_1} \pmod p $$ $$ \lambda \equiv (y_2 - y_1) \cdot (x_2 - x_1)^{-1} \pmod p $$

利用这个 $\lambda$，$x_3, y_3$ 可以如下求出：

$$ x_3 \equiv \lambda^2 - x_1 - x_2 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

【情况2：当 $P = Q$ 时（点的二倍算）】 斜率 $\lambda$ 即通过求导得到的切线斜率。（隐式对 $y^2 = x^3 + ax + b$ 求导）

$$ 2y \cdot y' = 3x^2 + a \implies y' = \frac{3x^2 + a}{2y} $$

因此，

$$ \lambda \equiv (3x_1^2 + a) \cdot (2y_1)^{-1} \pmod p $$

$x_3, y_3$ 的公式形式与加法相同，但由于 $x_2 = x_1$，结果如下：

$$ x_3 \equiv \lambda^2 - 2x_1 \pmod p $$ $$ y_3 \equiv \lambda(x_1 - x_3) - y_1 \pmod p $$

[!IMPORTANT] 这些公式包含了形如 $(x_2 - x_1)^{-1}$ 或 $(2y_1)^{-1}$ 的除法（模逆元的计算）。模逆元的计算成本非常高，因此在实际实现中，通常会使用诸如**“雅可比坐标系（Jacobian Coordinates）”**等射影坐标系来延迟除法运算。

5. 标量乘法与椭圆曲线离散对数问题（ECDLP）

在椭圆曲线密码学中，计算量最大且构成安全核心的运算是标量乘法（Scalar Multiplication）。

5.1. 什么是标量乘法

将某一点 $P$ 相加 $k$ 次的操作称为标量乘法，记作 $kP$。

$$ kP = \underbrace{P + P + \dots + P}_{k\text{次}} $$

在这里，$k$ 是一个非常大的整数（例如 256 位的整数）。

5.2. 椭圆曲线离散对数问题（ECDLP）

椭圆曲线密码学的安全性取决于以下问题的困难性：

椭圆曲线离散对数问题 (Elliptic Curve Discrete Logarithm Problem: ECDLP) 给定已知点 $P$（基点）和计算结果点 $Q$，求满足 $Q = kP$ 的标量 $k$。

利用后文所述的算法，由 $k$ 和 $P$ 计算 $Q$（正向）是很简单的（多项式时间），但由 $P$ 和 $Q$ 逆推 $k$（反向）除了暴力穷举外没有有效的解法，实际上是不可能的（单向函数）。在密码协议中，$k$ 对应“私钥”，$Q$ 对应“公钥”。

5.3. Double-and-Add 算法

如果 $k$ 是一个巨大的数（例如 $2^{256}$），那么就算宇宙寿命耗尽，也无法完成将 $P$ 愚直地相加 $k$ 次的操作。因此，为了快速执行标量乘法，我们使用了Double-and-Add 方法（二进制法）。

这是计算整数快速幂的“重复平方求幂法”的椭圆曲线版本。将标量 $k$ 表示为二进制数，然后从高位到低位依次处理。

将保存结果的点 $R$ 初始化为 $\mathcal{O}$。
从 $k$ 的最高位到最低位重复以下操作：
- 将 $R$ 翻倍（Point Doubling: $R = 2R$）
- 如果当前位为 1，则在 $R$ 上加上 $P$（Point Addition: $R = R + P$）

通过该算法，计算量从 $O(k)$ 剧烈减少到 $O(\log_2 k)$，从而使得在现实时间（毫秒级）内完成计算成为可能。

6. 椭圆曲线迪菲-赫尔曼（ECDH）密钥交换

在此，我们将讲解 ECC 最典型的应用案例——ECDH（Elliptic Curve Diffie-Hellman）密钥交换协议的机制。ECDH 是爱丽丝和鲍勃在可能被窃听的通信信道上，安全地生成并共享共同私钥（会话密钥）的机制（这也是 TLS 握手的核心）。

【前提参数（域参数）】 双方预先共享了所使用的椭圆曲线 $E$、素数 $p$ 以及基点 $G$。（例如 NIST P-256 或 secp256k1 等）

sequenceDiagram participant Alice as "Alice (爱丽丝)" participant Bob as "Bob (鲍勃)" Note over Alice,Bob: "公开参数: 曲线 E, 基点 G, 素数 p" Alice->>Alice: "生成私钥 d_A (随机整数)" Alice->>Alice: "计算公钥 Q_A = d_A * G" Bob->>Bob: "生成私钥 d_B (随机整数)" Bob->>Bob: "计算公钥 Q_B = d_B * G" Alice->>Bob: "发送公钥 Q_A (明文)" Bob->>Alice: "发送公钥 Q_B (明文)" Alice->>Alice: "计算共享密钥 S = d_A * Q_B" Bob->>Bob: "计算共享密钥 S = d_B * Q_A" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "双方的计算结果 S 完全一致！"

窃听者（伊芙）可以截获通信路径上流动的 $G$、$Q_A$、$Q_B$，但由于 ECDLP 的困难性，无法从 $Q_A = d_A \cdot G$ 推导得出爱丽丝的私钥 $d_A$。此外，即使将 $Q_A$ 和 $Q_B$ 相乘也不会得到共享密钥 $S$，因此窃听者无法计算出 $S$。

7. 实现中的陷阱：侧信道攻击及其对策

即使在理论上是完美的密码算法，在将其实现为程序的过程中，也有可能产生漏洞。这就是**“侧信道攻击（Side-Channel Attack）”**。

7.1. 计时攻击（Timing Attack）

让我们回顾一下前面提到的 Double-and-Add 算法。

1
2
3
4
5
6
7
8


// 脆弱的 Double-and-Add 伪代码
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // 总是执行
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // 只有当位为 1 时才执行！
 }
}

这个实现存在一个致命的缺陷。由于只有当位为 1 时才会执行 Point Addition，所以当位为 1 时所需的计算时间会比位为 0 时稍微长一些。此外，处理器的分支预测和缓存内存的行为也会发生变化。攻击者通过对这微小的计算时间（或功耗）差异进行数千次的统计观测，就可以逐位完全还原出私钥 $k$ 的二进制序列。这就是计时攻击。

7.2. Constant-Time（恒定时间）实现：Montgomery Ladder

为了防止计时攻击，我们需要采用一种无论**私钥的位值如何，执行的指令序列和计算时间始终保持不变（Constant-Time）**的算法。

其代表性的例子就是蒙哥马利阶梯（Montgomery Ladder）。

graph TD Start["初始化: R0 = O, R1 = P"] --> LoopStart["对于每个位 i (从最高位开始)"] LoopStart --> Cond{"k_i 的值是？"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["进入下一位"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"全部位完成"| End["结束: R0 即为结果 (kP)"]

Montgomery Ladder 的优美之处在于，无论位是 0 还是 1，都会**“始终执行一次 Point Addition 和一次 Point Doubling”**。这样就完全排除了计算时间对数据的依赖性。

然而，如果代码中存在分支（if (k_i == 0)）本身，那么由于编译器的优化或CPU的分支预测，执行时间仍然有波动的风险。因此，在实际的恒定时间实现中，我们会消除条件分支（if语句），转而使用基于位运算的条件交换（Conditional Swap）。

8. 使用 C++ 实现椭圆曲线密码学

从这里开始，我们将把理论转化为 C++ 代码。虽然实际实用的密码学库（如 OpenSSL 或 libsodium 等）使用了高度的汇编优化和雅可比坐标系，但在这里为了加深对数学的理解，我们将展示一个使用仿射坐标系且易于理解的 Constant-Time 实现的基础框架。

假设大整数运算使用 boost::multiprecision::cpp_int。

8.1. 模运算与逆元

首先，定义有限体上的运算辅助函数。实现基于费马小定理的逆元计算。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35


#include <iostream>
#include <vector>
#include <stdexcept>
#include <boost/multiprecision/cpp_int.hpp>

using namespace boost::multiprecision;

// 以 secp256k1 的素数 p 和参数为例
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// 返回正余数的模运算
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

// 模幂运算 (x^y mod m)
cpp_int powerMod(cpp_int base, cpp_int exp, cpp_int m) {
 cpp_int res = 1;
 base = mod(base, m);
 while (exp > 0) {
 if (exp % 2 == 1) res = mod(res * base, m);
 base = mod(base * base, m);
 exp /= 2;
 }
 return res;
}

// 使用费马小定理的模逆元
cpp_int modInverse(cpp_int n, cpp_int m) {
 // 前提 m 是素数: n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. 点的表示与群运算（加法・二倍算）

通过标志位管理无穷远点的 Point 结构体，并实现加法公式。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


struct Point {
 cpp_int x;
 cpp_int y;
 bool isInfinity;

 // 生成无穷远点
 Point() : x(0), y(0), isInfinity(true) {}

 // 生成普通点
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// 椭圆曲线上点的加法 (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = 无穷远点
 }

 cpp_int lambda;
 if (P.x == Q.x && P.y == Q.y) {
 // Point Doubling (当 P = Q 时)
 // lambda = (3x^2 + a) / 2y
 cpp_int num = mod(3 * P.x * P.x + a, p);
 cpp_int den = modInverse(mod(2 * P.y, p), p);
 lambda = mod(num * den, p);
 } else {
 // Point Addition (当 P != Q 时)
 // lambda = (y2 - y1) / (x2 - x1)
 cpp_int num = mod(Q.y - P.y, p);
 cpp_int den = modInverse(mod(Q.x - P.x, p), p);
 lambda = mod(num * den, p);
 }

 cpp_int x3 = mod(lambda * lambda - P.x - Q.x, p);
 cpp_int y3 = mod(lambda * (P.x - x3) - P.y, p);

 return Point(x3, y3);
}

8.3. Constant-Time 条件交换（Conditional Swap）的实现

当根据私钥的位值交换变量内容时，不使用 if 语句，而是仅使用位运算（掩码）来进行交换。这样执行路径就会完全保持一致。

[!TIP] 在实际实现中，像 cpp_int 这样动态分配的多精度整数类并不适合 Constant-Time 处理。因为内存分配和数组大小的变化会泄露计时信息。在实用库中，使用固定长度（例如 uint64_t × 4 个元素的数组）来表示，并实现位级别的掩码处理。以下是概念性示例。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


// 概念性的 Constant-Time Swap (假设使用定长整数)
// 如果 bit 为 1，则交换 P1 和 P2；如果为 0，则不交换
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit 为 0 或 1。如果 bit=1，则掩码全为 1 (0xFF..)；为 0，则全为 0。
 // (为了便于说明，这里假设定长 BigInt 类的每个字为 w)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // y 坐标和 isInfinity 标志位也进行相同处理
 }
 */

 // ※ 尽管使用 boost::multiprecision 实现完全的恒定时间交换很困难，
 // 但在这里，为了理解逻辑，我们仅通过分支语句进行模拟。
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. 使用 Montgomery Ladder 的标量乘法

结合前文所述的 pointAdd 和 cswap，实现安全的标量乘法。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


// 标量乘法 k * P (Montgomery Ladder 方式)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // 无穷远点
 Point R1 = P;

 // 获取 k 的位长 (若是 secp256k1 则为 256 位)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // 获取第 i 位的值 (0 或 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // 如果 bit == 1，则交换 R0 和 R1
 cswap(R0, R1, bit);

 // 总是执行相同的运算 (Point Addition 和 Point Doubling)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // 如果 bit == 1，为了恢复状态，再次进行交换
 cswap(R0, R1, bit);
 }

 return R0;
}

通过这一实现逻辑，无论标量 $k$ 的每一位是 0 还是 1，在每次循环迭代内执行的运算（cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap）流程完全相同，可以有效防止通过计时和缓存访问模式差异而导致的机密信息泄露。

9. 总结

初看椭圆曲线密码学（ECC），可能会让人感到奇怪：“为什么画条直线并翻转交点这种几何操作能成为密码呢？”然而，将其映射到有限体这一离散世界中，就可以构建出极佳的单向函数（离散对数问题），这正是数学与密码学奇迹般融合的产物。

本文讲解了以下几个要点：

相对 RSA 的优势: 能在非常短的密钥长度下提供强大的安全性，是现代移动互联网和物联网时代的最佳选择。
群论与有限体基础: 构成 ECC 基础的数学结构。
加法和二倍算公式: 使用魏尔斯特拉斯方程实现代数群运算的方法。
侧信道攻击的威胁: 依赖于私钥位值的条件分支会导致致命漏洞。
Constant-Time（恒定时间）实现: 使用 Montgomery Ladder 和 Conditional Swap 来均衡硬件级别的行为，从而防范攻击的 C++ 编码技术。

实际上，因为极高的安全风险，业界不建议（“Don’t roll your own crypto”）自行编写用于生产环境的密码学库。然而，深入理解其内部运行的算法和数学背景，对于设计和运维更安全、高性能系统的工程师来说，必定是一件不可或缺的强大武器。

在下一篇文章中，我们将进一步深入探讨使用这种椭圆曲线的数字签名算法——ECDSA（Elliptic Curve Digital Signature Algorithm） 的机制，以及比特币中所采用的 Schnorr 签名。

是否存在超越GNFS（普通数域筛选法）的算法？

Fri, 11 Sep 2026 09:00:00 +0900

1. 引言：整数分解与现代密码学的根基

现代社会中互联网通信的安全性在很大程度上依赖于公开密钥密码体制RSA的安全性。而RSA密码的安全性是基于“大合数分解难度”这一数学假设。如果发现了极其高效的整数分解算法，全球的通信基础设施将从根本上崩溃。

目前，在使用经典计算机分解大整数时，**普通数域筛选法（GNFS: General Number Field Sieve）**作为最快、最强的算法占据着统治地位。GNFS是在1980年代后期提出的特殊数域筛选法（SNFS）的扩展基础上诞生的，直到今天，它依然保持着分解RSA-768和RSA-250等巨大合数的记录。

然而，密码学家和数学家们始终抱有如下疑问：“是否存在超越GNFS的经典算法？”“经典计算机的极限在哪里？”以及，“量子计算机将如何打破这一僵局？”

本文将深入剖析GNFS背后的深邃数学结构，并对多项式选择、筛选处理、以及利用Block Wiedemann方法的线性代数步骤等进行详细的技术分析。此外，还将探讨通过Coppersmith改进等方法对GNFS进行扩展的技术，并从数学角度比较和解释经典次指数时间（Sub-exponential time）算法与量子多项式时间算法之间的决定性差异。

2. 渐进复杂度与L记号（L-notation）

在评估整数分解算法的计算复杂度时，标准的多项式时间表示（如 $O(n^k)$ 等）不再适用，为了表示相对于输入 $n$ 的位数的次指数时间，我们使用L记号（L-notation）。L记号的定义如下：

$$ L_n[\alpha, c] = \exp \left( (c + o(1)) (\ln n)^\alpha (\ln \ln n)^{1-\alpha} \right) $$

在这里，$n$ 是待分解的整数，$\ln n$ 是自然对数，与 $n$ 的位长成正比。

当 $\alpha = 0$ 时：$L_n[0, c] = \exp(c \ln \ln n) = (\ln n)^c$，表示相对于位长的多项式时间（Polynomial time）。
当 $\alpha = 1$ 时：$L_n[1, c] = \exp(c \ln n) = n^c$，表示相对于位长的指数时间（Exponential time）。
当 $0 < \alpha < 1$ 时：介于多项式时间和指数时间之间，称为次指数时间（Sub-exponential time）。

过去整数分解算法的进化史，同时也是这个 $\alpha$ 值逐渐减小的历史。

连分数法（CFRAC）与多重多项式二次筛选法（MPQS）：属于 $\alpha = 1/2$ 的类别，计算复杂度约为 $L_n[1/2, 1]$。
普通数域筛选法（GNFS）：实现了 $\alpha = 1/3$，在目前已知的经典算法中，它拥有最快的 $L_n[1/3, (64/9)^{1/3}]$ 计算复杂度。

3. GNFS（普通数域筛选法）算法全貌与数学结构

GNFS拥有非常复杂且高级的数学基础。其基本思想是费马小定理和二次筛选法（QS）的延伸，即寻找满足同余式 $X^2 \equiv Y^2 \pmod n$ 且 $X \not\equiv \pm Y \pmod n$ 的非平凡组合 $(X, Y)$，从而推导出 $n$ 的因子 $\gcd(X-Y, n)$。

然而，GNFS的精髓在于，它不仅仅在有理数域 $\mathbb{Q}$ 中进行计算，而是同时在称为代数数域（Algebraic Number Field）的扩域 $\mathbb{Q}(\alpha)$ 和有理数域中寻找“光滑数（Smooth numbers）”，并通过同态映射构建同余关系。

GNFS的过程大致分为5个阶段。

graph TD A["素数分解问题 (输入 n)"] --> B["1. 多项式选择 (Polynomial Selection)"] B --> C["2. 筛选处理 (Sieving Phase)"] C --> D["3. 过滤处理 (Filtering Phase)"] D --> E["4. 线性代数 (Linear Algebra Phase)"] E --> F["5. 平方根 (Square Root Phase)"] F --> G["输出素因子 p, q"]

3.1 阶段1：多项式选择 (Polynomial Selection)

GNFS的成功在很大程度上取决于如何选择合适的多项式。目标是找到具有公共根 $m$ 的两个不可约多项式 $f_1(x)$（有理侧）和 $f_2(x)$（代数侧）。也就是说，满足： $f_1(m) \equiv f_2(m) \equiv 0 \pmod n$

通常，有理侧的多项式选择一次方程 $f_1(x) = x - m$，而代数侧的多项式 $f_2(x)$ 选择一个次数为 $d$（通常为5或6）的首一多项式。最经典的方法是Base-$m$ 方法。选择一个接近 $n$ 的 $1/(d+1)$ 次方的整数 $m = \lfloor n^{1/(d+1)} \rfloor$，并将 $n$ 展开为 $m$ 进制形式： $n = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$ 由此可以得到多项式 $f_2(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_0$。显然 $f_2(m) = n \equiv 0 \pmod n$。

但是在现代实现中，使用的是 Kleinjung算法。这是一种在避免多项式系数过大（优化偏度，Skewness）的同时，优化代数性质（Murphy’s $E$ value 或 $\alpha$-value），寻找能在筛选阶段更容易生成光滑数的多项式的算法。仅仅是这一步骤就会投入大量的计算资源。

3.2 阶段2：筛选处理 (Sieving Phase)

多项式确定后，算法进入计算负载最高的“筛选（Sieving）”阶段。在这里，我们需要寻找数据对 $(a, b)$。这个数据对必须是互素的，并且要求以下两个值同时为“光滑（Smooth）”：

有理侧的范数: $F_1(a, b) = b \cdot f_1(a/b) = a - bm$
代数侧的范数: $F_2(a, b) = b^d \cdot f_2(a/b)$

“光滑”意味着该数只能被指定的上限（Sieve bound）以下的素数分解。我们会准备一个有理侧的素数基（Factor base）和一个代数侧的素数基，并在巨大的搜索空间内，像埃拉托斯特尼筛法一样高效地找出光滑数。目前的主流方法被称为格筛选（Lattice Sieving）。通过固定某个特定的素数 $q$，仅对使有理侧和代数侧同时为 $q$ 的倍数的子格上的 $(a, b)$ 对进行筛选，从而实现了极高的效率。

3.3 阶段3：过滤处理 (Filtering Phase)

在筛选阶段找到的光滑关系式（Relations）数量将高达数亿甚至数十亿。但其中也包含了大量无用的信息。过滤的目的是在构建巨大的稀疏矩阵（Sparse Matrix）的同时，尽可能地缩小其维度。

具体进行如下操作：

Singleton removal（单例移除）: 删除包含只出现过一次的素因子的关系式。
Clique removal / Merging（团移除/合并）: 将包含出现两次以上素因子的关系式相互相乘，消去变量，将其压缩为密度更高但维度更小的方程组。

通过这一过程，数十亿行的矩阵被压缩为数千万行级别的巨大稀疏矩阵 $\mathbf{A}$（元素为域 $\mathbb{F}_2$ 上的0和1）。

3.4 阶段4：线性代数 (Linear Algebra Phase)

在这一步中，我们需要找到方程 $\mathbf{A} \mathbf{x} \equiv \mathbf{0} \pmod 2$ 的非平凡解向量 $\mathbf{x}$。也就是求解该巨大稀疏矩阵的左零空间（Left Nullspace）的问题。

由于矩阵规模过大，使用常规的高斯消元法（$O(N^3)$）根本无法进行计算。因此，这里使用了属于克雷洛夫子空间法（Krylov subspace method）的一种迭代法。历史上曾使用Block Lanczos方法（块兰佐斯法），而在现代的分布式计算环境中，能够大幅减少通信开销的**Block Wiedemann方法（块维德曼法）**成为了主流。

Block Wiedemann方法通过计算矩阵 $\mathbf{A}$ 与向量序列的最小多项式，并使用Berlekamp-Massey算法构造零空间的基。这一步极难实现并行化，需要超级计算机或大规模集群的紧耦合通信网络，是GNFS中最大的瓶颈之一。

3.5 阶段5：平方根 (Square Root Phase)

利用线性代数求得的解，我们可以在有理侧和代数侧分别构造出“完全平方”的乘积。在有理侧，$\prod (a-bm)$ 会成为某个整数 $X$ 的平方 $X^2$；在代数侧，对应的理想（Ideal）的乘积在代数数域上成为完全平方 $\gamma^2$。在代数数域上计算出这个 $\gamma$，并通过映射到有理整数环的同态映射 $\phi: \alpha \mapsto m \pmod n$，我们可以得到同余式： $X^2 \equiv \phi(\gamma)^2 \equiv Y^2 \pmod n$

计算代数数域上的平方根时，使用了**Montgomery方法（Montgomery’s Method）**等复杂算法，这需要代数数论的深厚知识。最终，通过计算 $\gcd(X-Y, n)$，如果能得到非平凡的因子，因数分解即告完成。

4. 是否存在超越GNFS的经典算法？

迄今为止，对于一般整数的因数分解，尚未发现渐进复杂度低于 $L_n[1/3, c]$ 的经典算法。不过，为了突破理论与实践的局限，存在一些尝试与衍生算法。

4.1 多重数域筛选法 (MNFS: Multiple Number Field Sieve)

作为对GNFS的扩展，D. Coppersmith提出了多重数域筛选法（MNFS）。GNFS使用了两个多项式（有理侧和代数侧），而MNFS则对一个有理侧多项式同时使用多个不同的代数侧多项式。

$$ f_1(x), f_{2,1}(x), f_{2,2}(x), \dots, f_{2,V}(x) $$

通过利用多个代数数域，可以在每次筛选步骤中极大地提高“在任一代数数域中变光滑”的概率。Coppersmith通过这种方法成功地稍微减小了计算复杂度 $L_n[1/3, c]$ 中的常数 $c$。具体而言，GNFS的常数为 $c = (64/9)^{1/3} \approx 1.923$，而通过优化MNFS，理论上可以将其计算复杂度缩减至 $c \approx 1.902$ 左右。然而，在实际应用中，管理多个数域带来的开销很大，因此尚未在实际规模的RSA模数上取得决定性的突破。

4.2 $L_n[1/4]$ 级别的算法可能存在吗？

关于整数分解经典算法的极限，数学家们长年探讨的一个课题是：“是否存在指数 $\alpha = 1/4$ 的算法？” 目前的GNFS及其衍生算法强烈受限于基于筛选“寻找光滑数”的框架，在这个范式内，人们普遍认为 $\alpha = 1/3$ 就是极限。从使用Dickman函数（Dickman function）分析光滑整数分布概率的结果来看，结合目前的代数数域构造方法与筛选，无论怎么优化都不可能突破 $O(L_n[1/3])$ 的壁垒。

如果真的存在 $L_n[1/4]$ 或经典的纯多项式时间算法，那它必然依赖于与GNFS这种“基于光滑数”的方法截然不同、且目前人类难以想象的全新数学结构（例如，类似于针对椭圆曲线密码学的Schoof算法那样更高阶的代数几何方法等）。然而，目前还没有出现这种迹象。

5. 量子计算机的突破：Shor算法

虽然经典计算机面临着 $L_n[1/3]$ 的壁垒，但通过彻底改变计算模型本身而粉碎这一壁垒的，正是Peter Shor于1994年发表的Shor算法（Shor’s Algorithm）。

5.1 量子多项式时间的冲击

Shor算法将素数分解问题归约为“求阶问题（Order Finding Problem）”。即对于某个整数 $a$，寻找函数 $f(x) = a^x \pmod n$ 的周期（阶） $r$ 的问题。在经典计算机上找到这个周期需要指数级的时间，但在量子计算机上使用量子相位估计（QPE: Quantum Phase Estimation）和量子傅里叶变换（QFT: Quantum Fourier Transform），可以对所有状态的叠加态（Superposition）进行并行评估，从而以很高的概率提取出周期 $r$。

从计算复杂度的角度来看，Shor算法的执行时间属于量子多项式时间，具体如下：

$$ O((\log n)^3) $$

考虑到近年来优化的电路实现，据说可以将其缩减至 $O((\log n)^2 \log \log n)$。

graph LR A["经典算法 (GNFS)"] -->|极限| B["次指数时间 L_n[1/3]"] C["量子算法 (Shor)"] -->|突破| D["多项式时间 O((log n)^3)"] B --> E["RSA密码的继续使用 (增加密钥长度)"] D --> F["RSA密码的彻底崩溃"]

5.2 经典次指数时间 vs 量子多项式时间

这两个复杂度类别之间的差距，在现实世界的密码安全中具有决定性的意义。

例如，考虑分解RSA-2048（2048位的合数）的情况。

GNFS (经典): 将 $n \approx 2^{2048}$ 代入 $L_n[1/3, 1.923]$，大约需要 $2^{112}$ 次运算。这是一个即使集合目前地球上所有计算资源，也需要超过宇宙寿命时间的天文学计算量。
Shor’s Algorithm (量子): 对于 $O((\log n)^3)$ 的算法，仅需大约 $2048^3 \approx 8.5 \times 10^9$ 次逻辑门操作。这意味着如果存在合适的硬件（具备数百万物理量子比特和纠错能力的通用量子计算机），只需数小时到数天即可完成计算。

从“指数 $\alpha=1/3$”的次指数时间向“多项式时间”的范式转移，使得传统密码学中通过延长密钥长度来保证安全性的策略完全失效。

6. 总结：下一代展望

关于“是否存在超越GNFS的经典算法？”这一问题，目前科学界的共识如下：

实际的改进仍在继续，但不会有渐进意义上的飞跃: 虽然对优化多项式选择、并行化Block Wiedemann方法以及MNFS等尝试仍在继续（试图改善GNFS的常数项 $c$），但人们认为发现 $\alpha = 1/3$ 以下的经典算法的可能性微乎其微。
在经典计算机上，RSA的安全性依然非常坚固: GNFS的计算量依然是极其庞大的，RSA-2048和RSA-4096在面对经典计算机的攻击时，未来几十年内仍将保持安全。
真正的威胁是量子算法: 跨越计算复杂度壁垒的是基于量子力学原理的Shor算法。这也迫使世界开始向抗量子计算机密码学（PQC: Post-Quantum Cryptography）过渡。转向即使是量子计算机也难以破解（无法在多项式时间内求解）的全新数学问题，如格密码（Lattice-based cryptography）和基于哈希的密码（Hash-based cryptography），已成为当前密码学的最前沿。

普通数域筛选法（GNFS）是人类挑战经典数学和算法设计极限所达到的“最高境界”之一。理解GNFS深邃的数学结构，不仅是为了学习密码破译的历史，更是一段触及计算复杂性理论和代数数论之美的知识探索之旅。在量子计算机真正实现实用化之前，GNFS无疑将继续捍卫其作为最强整数分解算法的王座。

在Python中模拟秀尔算法

Fri, 11 Sep 2026 08:00:00 +0900

1. 引言：量子计算机带来的密码危机

现代互联网社会的大部分安全性都依赖于公钥密码体制（尤其是RSA加密）。当我们在网上购物发送信用卡信息，或交换高度机密的数据时，这些通信内容都受到RSA加密的坚固保护。

RSA加密安全性的基础依赖于一个数学事实：“使用经典计算机（我们日常使用的PC或超级计算机）对巨大的整数进行质因数分解是极其困难的”。然而，彼得·秀尔（Peter Shor）在1994年发表的“秀尔算法（Shor’s Algorithm）”从根本上颠覆了这一前提。在数学上已经证明，如果在大型量子计算机上运行秀尔算法，可以在短短几分钟到几个小时内解开经典计算机需要花费超过宇宙年龄的时间才能完成的质因数分解。

在本文中，我们将极其详细地讲解秀尔算法如何高速进行质因数分解，从其数学原理到使用Python和量子计算框架Qiskit的具体模拟实现。

2. 计算复杂度的剧烈变化：从指数级到多项式时间

为什么质因数分解如此困难？即使使用被称为经典计算机中最好的质因数分解算法的“普通数域筛选法（General Number Field Sieve, GNFS）”，其时间复杂度也是次指数级的。

在经典方法中，对位数为 $N$ 的合数进行质因数分解所需的时间复杂度如下：

$$ O\left(\exp\left( c (\log N)^{1/3} (\log \log N)^{2/3} \right)\right) $$

因此，只要增加密钥长度（例如增加到2048位或4096位），在经典计算机上的破解就会耗费数千年、数万年这种不切实际的时间。

但是，如果在量子计算机上使用秀尔算法，计算复杂度将针对输入的位数 $\log N$ 剧烈降低到多项式时间。

$$ O((\log N)^3) $$

这意味着，如果将位数翻倍，经典计算机的计算时间会呈天文数字般增长，而在量子计算机上，计算时间最多只会增加约8倍。这种从指数级时间到多项式时间的计算复杂度类的降低（被包含在BQP类中），正是秀尔算法的真正厉害之处。

graph TD A["输入大小(位数) N增加"] --> B{"算法选择"} B -->|经典: 普通数域筛选法| C["次指数级增长 O(exp(...))"] B -->|量子: 秀尔算法| D["多项式时间 O((log N)^3)"] C --> E["数千年〜数十亿年 (无法破解)"] D --> F["几分钟〜几小时 (现实时间内破解)"]

3. 算法全貌与数学背景

秀尔算法实际上并非完全在量子计算机上运行。它是通过经典计算机的前处理与后处理，以及量子计算机的核心部分（周期寻找算法）协同工作而构成的。

算法的整体流程如下：

graph TD A["输入: 想要进行质因数分解的合数 N"] --> B["选择随机数 a 使得 a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Yes" --> D["输出平凡因子 gcd(a, N) 并结束"] C -- "No" --> E["使用量子算法寻找 f(x) = a^x mod N 的周期 r"] E --> F{"r 是偶数且 a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Yes" --> G["计算因子 p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["输出: p, q"]

从质因数分解归约到周期寻找问题

秀尔的天才之处在于将“质因数分解问题”转换为了“周期寻找问题（Order Finding Problem）”。

考虑整数 $N$（想要进行质因数分解的数）和一个互质的整数 $a$（$1 < a < N$）。我们定义如下的模指数函数：

$$ f(x) = a^x \bmod N $$

这个函数具有某个周期 $r$。也就是说，对于任意的 $x$，都满足 $f(x+r) = f(x)$。特别是在 $x=0$ 时：

$$ a^r \equiv 1 \pmod N $$

满足这个条件的最小正整数 $r$ 被称为“$a$ 模 $N$ 的阶（Order）”。如果能找到这个周期 $r$，就可以通过以下方式导出质因数。

对公式进行变形：

$$ a^r - 1 \equiv 0 \pmod N $$

如果 $r$ 是偶数，就可以使用平方差公式进行因式分解：

$$ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $$

这意味着 $N$ 与 $(a^{r/2} - 1)$ 或 $(a^{r/2} + 1)$ 之一有公约数（但必须满足条件 $a^{r/2} \not\equiv -1 \pmod N$）。因此，使用欧几里得算法计算：

$$ p = \gcd(a^{r/2} - 1, N) $$ $$ q = \gcd(a^{r/2} + 1, N) $$

就可以找到 $N$ 的非平凡质因数 $p, q$。这个计算（计算最大公约数或生成随机数）在经典计算机上可以非常快速地完成。问题的焦点就集中在如何高速寻找周期 $r$ 上。在经典计算机上，寻找这个周期 $r$ 本身就需要指数级的时间。这里就轮到量子计算机出场了。

4. 量子算法部分：周期寻找的机制

使用量子计算机寻找周期 $r$ 的子程序由以下4个步骤组成：

graph LR subgraph "量子状态演化" S1["|0⟩|0⟩ (初始化)"] --> S2["H门: 叠加态 Σ|x⟩|0⟩"] S2 --> S3["神谕 U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: 通过干涉提取周期"] S4 --> S5["测量: 获取近似值 y"] end

步骤1：量子寄存器的初始化与叠加

首先，准备两个量子寄存器。第1个寄存器用于输入状态，第2个寄存器用于存储函数的计算结果。初始状态全为 $|0\rangle$。

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

对第1个寄存器的所有量子比特应用阿达马门（Hadamard Gate），创造出所有可能输入 $x$（从 $0$ 到 $Q-1$，$Q=2^n$）的等概率叠加态。

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |0\rangle_2 $$

由此，量子计算机将在一次运算中同时保持所有 $Q$ 个输入的状态。这是量子并行性的强大源泉。

步骤2：应用神谕函数（模幂运算）

接下来，使用量子运算电路 $U_f$ 计算函数 $f(x) = a^x \bmod N$，并将其结果存储到第2寄存器中。

$$ |\psi_2\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle_1 |a^x \bmod N\rangle_2 $$

此时，第1寄存器和第2寄存器处于**量子纠缠（Entanglement）**状态。如果（假设）观测第2寄存器并得到了一个特定的值 $k = a^{x_0} \bmod N$，那么第1寄存器的状态将坍缩为给出该值 $k$ 的 $x$ 的叠加态。由于函数的周期是 $r$，剩余的状态将是以 $r$ 为间隔的值，即 $x_0, x_0+r, x_0+2r, \dots$。

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

但是，我们想知道的并不是 $x_0$，而是周期 $r$ 本身。从这个状态直接观测 $r$ 是不可能的。因此，我们使用量子傅里叶变换。

步骤3：通过量子傅里叶变换（QFT）产生相位干涉

对第1寄存器应用量子傅里叶变换（Quantum Fourier Transform, QFT）。QFT是经典离散傅里叶变换的量子版本，它转换状态向量的振幅。QFT对基态 $|x\rangle$ 的作用定义如下：

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

这里，$\omega = e^{2\pi i / Q}$。

应用QFT后，状态的振幅会产生干涉。省略数学细节，对于具有周期 $r$ 的状态应用QFT时，只有当 $y$ 非常接近 $Q/r$ 的整数倍时，波才会发生相长干涉（Constructive Interference）。对于其他状态，由于相消干涉（Destructive Interference），概率振幅会相互抵消并趋向于零。

步骤4：测量与连分数展开

最后测量第1寄存器。通过测量得到的值 $y$，以很高的概率满足以下条件：

$$ y \approx c \frac{Q}{r} \implies \frac{y}{Q} \approx \frac{c}{r} $$

（$c$ 是 $0 \le c < r$ 的未知整数）

对得到的有理数 $y/Q$ 应用经典算法连分数展开（Continued Fraction Expansion），计算出近似分数 $c/r$，然后从分母中提取出周期 $r$。

5. 使用Python和Qiskit的模拟实现

仅凭理论很难有切实的感受，让我们实际使用Python和IBM的量子计算框架Qiskit来模拟秀尔算法吧。

在这里，我们将实现最经典著名的例子：“使用 $a=7$ 对 $N=15$ 进行质因数分解” 的场景。

运行环境准备

请预先安装Qiskit。

1

pip install qiskit qiskit-aer numpy

Python实现代码全貌

以下代码是专为 $N=15, a=7$ 编写的秀尔算法实现示例。由于在当前的模拟器中构建通用的模幂电路计算成本过高，因此我们将特定 $a=7$ 情况下的门操作硬编码了。

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. 构建逆量子傅里叶变换 (QFT†) 的函数
def qft_dagger(n):
 """生成n量子比特的逆量子傅里叶变换电路"""
 qc = QuantumCircuit(n)
 # 用于反转顺序的SWAP门
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # 应用受控相位门和H门
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. 构建 7^x mod 15 的受控模幂运算的函数
def c_amod15(a, power):
 """为特定的a和幂生成受控U门 (N=15专用)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # a=7 时 7^x mod 15 的硬编码逻辑
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. 主量子电路构建
def shor_circuit(a, n_count):
 # n_count: 控制寄存器的比特数
 # 目标寄存器为了表示 0〜15，需要 4比特
 qc = QuantumCircuit(n_count + 4, n_count)

 # 初始化第1寄存器（控制寄存器）（生成叠加态）
 for q in range(n_count):
 qc.h(q)

 # 将第2寄存器（目标寄存器）初始化为 |1> (0001)
 qc.x(3 + n_count)

 # 应用受控模幂运算（神谕）
 for q in range(n_count):
 # 应用 2^q 次方的运算
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # 对第1寄存器应用逆量子傅里叶变换
 qc.append(qft_dagger(n_count), range(n_count))

 # 测量第1寄存器
 qc.measure(range(n_count), range(n_count))
 return qc

# --- 执行部分 ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # 控制寄存器使用8个量子比特 (Q=256)

 print(f"搜索设置: N={N}, a={a}, 控制量子比特数={n_count}")

 # 生成电路
 qc = shor_circuit(a, n_count)

 # 在模拟器上运行
 sim = AerSimulator()
 # 在最新的Qiskit中推荐使用transpile
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\n测量结果(比特串: 观测次数):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count}次")

 # 经典后处理: 通过连分数展开确定周期r
 print("\n--- 周期计算与质因数分解 ---")
 phases = []
 for output in counts:
 # 将比特串转换为十进制数
 decimal = int(output, 2)
 # 相位 = 测量值 / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # 通过连分数展开获取近似分数。分母上限为 N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"观测值: {decimal:3d} | 相位: {phase:.4f} | 连分数: {frac} | 估计周期 r = {r}")

 # 确认周期 r 是否为偶数并能带来有效结果
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => 成功！ {N} 的质因数是 {guess1} 和 {guess2}。")
 else:
 print(f" => 仅得到平凡因子。重试。")
 else:
 print(f" => 周期为奇数，失败。")

代码解析与执行结果分析

运行上述代码，作为控制寄存器的测量结果，将以极高的概率获得特定的峰值（观测值）。在 n_count=8（$Q=256$）的情况下，如果是理想的量子计算机（或模拟器），观测值如 0, 64, 128, 192 等出现的概率会非常大。

将它们除以 $Q=256$，相位 $y/Q$ 分别为 $0.0$, $0.25$, $0.5$, $0.75$。对这些相位进行连分数展开：

$0.25 \to 1/4$ （估计周期 $r=4$）
$0.50 \to 1/2$ （估计周期 $r=2$）
$0.75 \to 3/4$ （估计周期 $r=4$）

使用这里得到的周期 $r=4$，计算质因数。因为 $a=7, r=4$， $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

精彩地，成功完成了 $15 = 3 \times 5$ 的质因数分解。

[!TIP] 如果观测值为 $y=128$（相位 $0.5$），分母将变为 $2$，从而得到其约数而不是真实周期 $r=4$。在这种情况下，可以通过多次运行算法，或者检查所得到的 $r$ 的倍数来找到真实周期。

6. 走向实用化的课题与 NISQ 时代的局限

虽然在模拟器上可以轻松地对 $N=15$ 进行质因数分解，但要对现实社会中使用的 RSA-2048（617位的十进制数）进行质因数分解，现实的量子计算机还面临许多障碍。

我们现在所处的时代被称为NISQ（Noisy Intermediate-Scale Quantum：含噪声中等规模量子）时代。量子比特对外部环境的噪声极其敏感，在计算过程中会发生“退相干”导致状态破坏。

为了准确运行像秀尔算法这样深（门数量多）的电路，必须使用纠正噪声的量子纠错（Quantum Error Correction）。为了创造一个没有噪声的“逻辑量子比特”，需要使用表面码（Surface Code）等编码数千个“物理量子比特”。

据估计，为了破解2048位的RSA加密，需要数千个完美的逻辑量子比特，而要实现这一点，需要搭载数百万到数千万个物理量子比特的容错量子计算机。即使是当前最先进的量子处理器，也只有几百到几千个物理量子比特的规模，因此全世界的密码不会立即被破解。

[!WARNING] 然而，存在一种称为“Store Now, Decrypt Later（现在存储，以后解密）”的威胁模型。攻击者可能会将现在加密的机密通信以加密数据的形式大量保存下来，并在10到20年后强大的量子计算机完成的瞬间，采取将它们全部解密的策略。

7. 向抗量子计算密码（PQC）过渡

为了应对这样的“Q-Day（量子计算机破解密码之日）”的到来，以美国国家标准与技术研究院（NIST）为首，全世界的密码学家都在推动**抗量子计算密码（Post-Quantum Cryptography, PQC）**的制定。

PQC基于新的数学问题（如格问题、多变量多项式问题、基于哈希函数等），在数学上被认为即使使用秀尔算法（或使用格罗弗算法）也无法高效求解。已经有诸如“CRYSTALS-Kyber”和“CRYSTALS-Dilithium”等算法被选为标准规范，并正逐步引入Apple的iMessage和各种Web浏览器的通信协议中。

对于管理IT基础设施的工程师来说，将系统从现有的RSA或椭圆曲线加密向PQC过渡，并建立“密码敏捷性（Crypto-Agility：能够快速切换加密方式的设计）”，将是未来的重要使命。

8. 结语

在本文中，我们从秀尔算法的理论数学背景开始，讲解了使用量子傅里叶变换提取周期的机制，以及使用Python和Qiskit的具体模拟代码，以1万字规模的篇幅进行了极其详细的解说。

量子力学这个微观世界的物理定律，竟然能从根本上颠覆作为宏观信息科学基础的计算复杂性理论和密码学理论，这一事实是科学史上最激动人心的范式转换之一。我们不能将目光从不断发展演进的量子计算技术与应对它的新密码技术的攻防战中移开。

请务必在您自己的环境中运行这次介绍的Python代码，亲身体验量子态的叠加与干涉所产生的“计算魔法”。

参考文献

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/

【图解PQC】抗量子密码学主要算法比较

Fri, 11 Sep 2026 07:00:00 +0900

1. 引言：量子计算机带来的“密码危机”

在现代互联网社会中，为了保护通信的机密性和数据的完整性，公钥密码技术作为基础设施是不可或缺的。目前广泛使用的RSA加密和椭圆曲线加密（ECC），分别依赖于“大整数素数分解的困难性”和“椭圆曲线上离散对数问题的困难性”等数学壁垒来保证安全性。在经典计算机（包括超级计算机在内的我们目前使用的计算机）上，解开这些数学问题被证明需要比宇宙年龄还要长的时间，这一直是其安全性的依据。

然而，这一坚固的前提正随着量子计算机的理论与实用化进展而面临被彻底颠覆的危险。1994年，密码学家彼得·秀尔（Peter Shor）发表了“Shor算法”，理论上证明了在具备足够性能的容错通用量子计算机（CRQC: Cryptographically Relevant Quantum Computer）上运行该算法，能够在“多项式时间”内破解素数分解问题和离散对数问题。这意味着目前使用的所有公钥密码都将被使其无效化。

认为“真正的量子计算机还需要数十年才能完成，所以没有问题”是非常危险的。因为被称为**Store Now, Decrypt Later (SNDL：现在存储，稍后解密)**的攻击手法已经成为现实的威胁。这是一种恶意国家或黑客组织将当前加密的通信数据（如TLS流量等）大量存储起来，等到将来强大的量子计算机可用时，瞬间将其全部解密的攻击。国家机密、基础设施信息、需要长期保护的医疗数据等，已经暴露在这种威胁之下。

此外，针对对称密钥加密（如AES）和哈希函数（如SHA-256），1996年发现的Grover算法也同样存在。它能够将暴力破解（穷举攻击）的计算量减少到原来的平方根。也就是说，AES-128的安全级别实际上减半到了2的64次方，因此在量子时代，建议使用AES-256和SHA-384等更长的密钥和哈希长度。

为了应对这场前所未有的密码危机，基于即便使用量子计算机也难以破解的新数学问题的**抗量子密码学（Post-Quantum Cryptography: PQC）**应运而生。本文将基于美国国家标准与技术研究院（NIST）主导推进的PQC标准化进程的结果，从数学背景、机制到架构比较，极其详尽地解说主要的PQC算法。

2. NIST的PQC标准化项目全貌与历史

密码技术的迁移，包括协议的重新设计、系统的更新、硬件的更换等，需要数年至数十年的时间。因此，全世界的密码学家们很早就开始了PQC的研究。其中发挥核心作用的是美国的NIST（国家标准与技术研究院）。NIST在2016年公开招募了PQC的标准化流程，接受来自全世界密码学社区的全新密码算法提案。

标准化的对象主要分为以下两个类别：

公钥密码 / 密钥封装机制 (KEM: Key Encapsulation Mechanism): 在TLS连接等场景中，为了加密通信路径，安全共享（分发）对称密钥的机制。
数字签名 (Digital Signatures): 在软件更新或电子证书中，证明数据未被篡改且发送者身份真实（真实性）的机制。

经过大约6年非常激烈的评估、分析与密码破解竞争（Round 1〜Round 3），部分算法还进行了Round 4的追加评估。最终结果是，2024年以下算法作为正式的联邦信息处理标准（FIPS）发布，并确立为未来世界的标准。

FIPS 203 (ML-KEM): 基于CRYSTALS-Kyber的KEM
FIPS 204 (ML-DSA): 基于CRYSTALS-Dilithium的数字签名
FIPS 205 (SLH-DSA): 基于SPHINCS+的无状态基于哈希的签名
（未来计划制定）FN-DSA: 基于FALCON的数字签名

这些被选定的算法所依赖的数学“困难性问题”各不相同，确保了即使某个算法将来被发现存在致命漏洞，整个系统也不会崩溃的多样性（Crypto Agility）。在标准化流程中，基于性能方面的考虑，格密码学（Lattice-based cryptography）成为了主力，而基于哈希的密码和基于编码的密码则作为强大的备份被采用。

3. PQC主要数学方法的分类

PQC算法根据其安全性依据的数学问题，主要分为以下五大类。本文将特别深入探讨前三类。

格密码学 (Lattice-based Cryptography): 基于多维格空间中的最短向量问题（SVP）、最近向量问题（CVP）及其衍生出的LWE问题。它是NIST标准化的核心，Kyber、Dilithium、FALCON均属于此类。处理速度、公钥大小和密文大小的平衡最出色，适合通用场景。
基于哈希的密码学 (Hash-based Cryptography): 仅依赖于密码学哈希函数（如SHA-2、SHAKE等）的“抗碰撞性”和“单向性”作为安全性依据。只能应用于数字签名（如SPHINCS+），但其安全性证明最为坚固，对未知的数学攻击具有极高的抵抗力。
基于编码的密码学 (Code-based Cryptography): 基于纠错码理论，依赖于伴随式解码问题（Syndrome Decoding Problem）的困难性。代表是20世纪70年代提出的Classic McEliece，拥有悠久的历史和已被验证的安全性，但缺点是公钥尺寸极大，达到兆字节级别。
多变量多项式密码学 (Multivariate Polynomial Cryptography): 基于求解有限域上多变量非线性二次方程组（MQ问题）的困难性。主要作为数字签名提出（如Rainbow等），但在NIST最后一轮评估期间，被发现只需一台普通电脑运行几天即可破解的强大攻击手段，导致许多算法退出了标准化。
基于同源的密码学 (Isogeny-based Cryptography): 基于椭圆曲线同源（Isogeny）图上的路径搜索问题。密钥尺寸非常小，曾被寄予厚望成为ECC的正统继任者，但最终候选者“SIKE”在2022年被利用经典数学（如Castryck-Decru攻击）在一台普通PC上仅耗时数小时就被完全破解，这场戏剧性的落幕象征着PQC设计的艰难与可怕。

4. 格密码学的深渊：LWE问题与Module-LWE的数学基础

目前最被看好并成为标准化核心的正是格密码学。其安全性的根基在于LWE问题 (Learning with Errors: 带错学习问题)。2005年由Oded Regev提出，这一划时代的成就让他获得了哥德尔奖。不理解LWE问题，就无法谈论现代PQC。

4.1. 什么是LWE问题 (Learning with Errors)

首先，我们来考虑一个简单的线性方程组。假设在某个模 $q$ （模 $q$）下，有一个已知的随机矩阵 $A$，一个未知的秘密向量 $\vec{s}$，并给出了它们的乘积 $\vec{b}$。

$$ \vec{b} = A\vec{s} \pmod q $$

此时，从公开信息 $A$ 和 $\vec{b}$ 求解未知的 $\vec{s}$ 是非常简单的。利用经典算法“高斯消元法”，可以在多项式时间内轻松计算出 $\vec{s}$。

但是，如果在等式中加入“微小的故意误差（噪声）”，问题的难度就会呈指数级飙升。这就是LWE问题。

准备一个未知的秘密向量 $\vec{s} \in \mathbb{Z}_q^n$ 和一个随机选择的矩阵 $A \in \mathbb{Z}_q^{m \times n}$。接着，准备一个按照正态分布或二项分布等选择的“元素值足够小”的误差向量 $\vec{e} \in \mathbb{Z}_q^m$，按如下方式计算 $\vec{b}$：

$$ \vec{b} = A\vec{s} + \vec{e} \pmod q $$

Search LWE问题就是“从公开信息 $(A, \vec{b})$ 中求出秘密信息 $\vec{s}$”的问题。由于存在这个误差 $\vec{e}$，如果尝试使用高斯消元法等代数解法，在方程的加减过程中，误差 $\vec{e}$ 会像滚雪球一样被放大，最终变得与随机值无法区分从而宣告失败。

LWE问题的伟大之处在于，存在一个强大的理论证明（规约）：除非存在能够解决格上“最坏情况复杂度问题（Worst-case hardness）”——如GapSVP（判定最短向量问题）或SIVP（最短独立向量问题）——的量子算法，否则LWE问题在平均情况（Average-case）下也是无法求解的。也就是说，即使是随机生成的加密密钥，也能保证其具有由理论上限支撑的坚固安全性。

4.2. Ring-LWE与Module-LWE带来的效率飞跃

普通的LWE问题（Standard LWE）安全性依据非常明确，但矩阵 $A$ 的尺寸会变得非常大，导致密钥大小达到兆字节级别，并不实用。于是有人提出了利用多项式环（Polynomial Rings）赋予代数结构的方法。

Ring-LWE问题中，不使用简单的向量或矩阵，而是使用某个多项式环 $R_q$ 的元素（多项式）。NIST标准中通常使用的是如下的分圆多项式环：

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

这里，$n$ 是 2 的幂（例如：256），$q$ 是一个适当的素数。在这个环上，使用元素 $a, s, e \in R_q$ 计算 $b = a \cdot s + e \pmod q$。因为一个多项式 $a$ 拥有 $n$ 个系数，所以可以大幅压缩数据，并且通过使用一种称为NTT (Number Theoretic Transform: 数论变换) 的快速傅里叶变换（FFT）的有限域版本，可以以 $O(n \log n)$ 的计算复杂度超高速地进行多项式乘法。

但是，Ring-LWE 存在一种担忧：“起因于环的特殊代数结构，可能存在未知的漏洞”。此外，在更改安全级别（如相当于AES-128, 192, 256等）时，必须改变多项式的次数 $n$ 本身，伴随而来的是必须重写包括NTT算法在内的整个实现，这在工程上是个难题。

因此，被标准化的算法Kyber和Dilithium采用了Module-LWE (M-LWE) 问题。Module-LWE 是位于无结构的Standard LWE和结构性过强的Ring-LWE之间的折中方案，它使用以多项式环 $R_q$ 的元素为成分的 $k \times k$ 矩阵（模块）。

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

Module-LWE 的最大优势在于，保持多项式的次数 $n$（NIST标准中 $n=256$）固定不变，仅通过改变矩阵的维度 $k$，就可以轻松实现安全级别的扩展。例如，Kyber按如下方式调整维度 $k$：

Kyber512 (Level 1): $k = 2$ （相当于AES-128）
Kyber768 (Level 3): $k = 3$ （相当于AES-192）
Kyber1024 (Level 5): $k = 4$ （相当于AES-256）

这使得底层的NTT代码和多项式运算硬件电路能够在所有安全级别下实现100%的代码复用，极大地提高了实现的安全性与效率。

5. CRYSTALS-Kyber (ML-KEM)：下一代密钥封装机制

被正式标准化为 FIPS 203 (ML-KEM) 的 CRYSTALS-Kyber，是基于前述Module-LWE问题的密钥封装机制（KEM）。未来，它将成为TLS 1.3、SSH等协议中安全共享会话密钥的事实上的全球标准。

5.1. KEM (Key Encapsulation Mechanism) 的架构

在PQC时代，不再像RSA那样采用“客户端生成对称密钥，用服务器公钥加密后发送”的直接方法，而是将KEM这种封装框架作为标准。

sequenceDiagram participant Client as "客户端 (Alice)" participant Server as "服务器 (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "生成私钥 (sk) 与公钥 (pk)" Client->>Server: "发送公钥 (pk)" Note over Server: "ML-KEM Encaps()" Server->>Server: "生成随机对称密钥 (K)" Server->>Server: "用pk封装K，创建密文 (c)" Server->>Client: "发送密文 (c)" Note over Client: "ML-KEM Decaps()" Client->>Client: "使用私钥 (sk) 解密密文 (c)" Client->>Client: "解开封装，取出对称密钥 (K)" Note over Client, Server: "利用共享的对称密钥 (K)，开始基于AES等的加密通信"

5.2. Kyber的内部算法机制与藤崎-冈本变换

Kyber的设计非常优雅。首先，它构建了一个仅对CPA（选择明文攻击）安全的公钥加密方案（Kyber.CPAPKE），然后应用一种被称为藤崎-冈本变换 (Fujisaki-Okamoto Transform) 的极强密码学方法，将其升级为对CCA（适应性选择密文攻击）也安全的完美KEM。

CPAPKE核心的加密和解密机制如下：

密钥生成 (Key Generation):
- 从随机种子值在NTT域上生成矩阵 $A \in R_q^{k \times k}$。模数 $q$ 使用 $3329$。
- 从中心二项分布（CBD）中采样具有小系数的秘密向量 $\vec{s}$ 和误差向量 $\vec{e}$。
- 计算 $\vec{t} = A\vec{s} + \vec{e}$。公钥为 $(A, \vec{t})$，私钥为 $\vec{s}$。（实际上 $A$ 以种子值的形式公开，以节省带宽）。
加密 (Encryption):
- 将希望共享的32字节消息（对称密钥材料）$m$ 编码为多项式。
- 生成新的随机向量 $\vec{r}$ 以及微小误差 $\vec{e_1}, e_2$。
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- 密文即为 $(\vec{u}, v)$。
解密 (Decryption):
- 接收方计算 $v - \vec{s}^T\vec{u}$。
- 将该式展开如下： $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- 代入 $\vec{t} = A\vec{s} + \vec{e}$ 后，主项 $\vec{s}^TA^T\vec{r}$ 相互抵消。
- 剩下的部分为 $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$。
- 括号内的项是“微小误差的乘积和求和”，因此整体依然是一个足够小的值（噪声）。于是，通过阈值判定每个系数是接近 $0$ 还是接近 $q/2$，即可完全无误差地还原原消息 $m$ 的每一位（0 或 1）。

Kyber最大的优势在于其压倒性的处理速度和适中的密钥大小。在Kyber768的情况下，公钥尺寸为1,184字节，密文尺寸为1,088字节，虽然相比于RSA-3072（密钥约384字节）要大，但可以无需进行数据包分割地容纳在现代互联网通信的MTU（最大传输单元）内，对网络延迟几乎没有负面影响。

6. CRYSTALS-Dilithium (ML-DSA)：基于格的通用数字签名

在数字签名的标准化过程中，同样是基于格密码学方法，拥有不同设计理念的算法相互竞争。其中，作为通用数字签名被选定为 FIPS 204 (ML-DSA) 的是 CRYSTALS-Dilithium。

6.1. 带有中止的Fiat-Shamir范式 (Fiat-Shamir with Aborts)

与Kyber一样，Dilithium也是一种基于Module-LWE（以及Module-SIS问题）的数字签名方案。其设计基础采用了一个极其重要的范式——“带有中止的Fiat-Shamir变换 (Fiat-Shamir with Aborts)”。

Fiat-Shamir变换本身是将交互式零知识证明协议转换为非交互式数字签名的一种标准方法。证明方（签名者）生成承诺 $y$，计算 $w = Ay$ 并通过哈希函数处理，获得随机挑战 $c$，随后计算响应 $z = y + cs$。

然而，在格密码学中如果简单应用这一方法，响应 $z$ 的分布会依赖于私钥 $s$ 的值而发生扭曲，导致观察到大量签名的攻击者可以一点点地泄露私钥 $s$ 的信息，这是一个致命的问题（侧信道数学泄露）。

Dilithium的设计团队（Lyubashevsky等人）引入了“拒绝采样 (Rejection Sampling)”方法。即如果签名计算结果 $z$ 的系数未能落入预设的安全阈值范围内，就废弃（Abort）整个签名过程，利用新的随机数 $y$ 从头开始计算。

通过这种方法，最终输出的签名 $z$ 成为完全均匀的分布，不再依赖于任何私钥信息，在数学上完美地防范了信息泄露。

6.2. Dilithium的优势与易实现性

Dilithium设计上的巨大优势在于，在签名生成过程中完全不使用复杂的“高斯分布采样”和“浮点运算”。仅需使用均匀分布采样、简单的整数模运算、NTT以及哈希函数（SHAKE）即可实现，因此无论是在嵌入式微控制器还是在云端服务器上，都能轻易地实现安全且恒定时间（Constant-time）的代码。这使得它对针对物理侧信道的定时攻击等具有极强的抵抗力。

7. FALCON (FN-DSA)：极致紧凑的格签名

NIST选择了**FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU)**作为具备与Dilithium不同特性的另一款基于格的签名标准化候选方案（目前正作为FN-DSA起草草案）。

7.1. NTRU格与高斯采样

FALCON最大的特点在于它不使用LWE问题，而是使用自1996年起就存在的历史悠久的NTRU (N-th degree Truncated polynomial Ring Units) 格。此外，它还采用了基于GPV (Gentry-Peikert-Vaikuntanathan) 框架的“哈希与签名 (Hash-and-Sign)”范式。

在Hash-and-Sign中，将消息的哈希值作为空间内的一个目标点，找到距离该目标点最近的格上的点（最近向量问题的近似解）作为签名。这要求使用作为私钥的“优质的短基”，按照离散高斯分布对点进行采样。

FALCON利用被称为“快速傅里叶正交化 (Fast Fourier Orthogonalization: FFO)”的技术，使得这种繁重的计算实现了极其显著的加速。

7.2. FALCON的优缺点

FALCON压倒性的优势在于其签名尺寸和公钥尺寸极小（非常紧凑）。相较于Dilithium3的签名尺寸约为3,309字节，FALCON-512的签名尺寸仅约666字节。公钥尺寸也非常小，为897字节，在通信带宽受限严重的环境、物联网（IoT）设备或特定网络协议中，它是无可替代的救星。

然而，它也存在一个重大缺陷。签名生成时必须进行涉及复杂**浮点运算（64位IEEE 754）**的离散高斯采样，因此要实现防止时间泄露的恒定时间实现（Constant-time implementation）极其困难，代码也会变得十分庞大。因此，相对于通用用途（Dilithium），FALCON被定位为面向特定用途的强大特化型算法。

graph LR A["数字签名的要求"] --> B{"最优先的约束是什么？"} B -->|"实现简单、通用性、易于恒定时间实现"| C["Dilithium (ML-DSA)"] B -->|"通信带宽最小化、数据尺寸的紧凑性"| D["FALCON (FN-DSA)"] C --> E["通用TLS证书、软件数字签名"] D --> F["限制封包大小的协议、特殊环境"]

8. SPHINCS+ (SLH-DSA)：拥有最强安全性的哈希签名

为了防范“未来某位天才数学家取得突破从而破解格密码学安全性”这一最坏情况（万一之事），NIST制定了与格密码学截然不同路径的标准——FIPS 205 (SLH-DSA)，即SPHINCS+。

SPHINCS+ 属于基于哈希的签名。其安全性的依据仅依赖于唯一一点：“所使用的密码学哈希函数（如SHA-2或SHAKE256等）具有抗碰撞性和单向性”。由于它不依赖于LWE或素数分解等具有特定代数结构的数学问题，因此未来无论出现多么强大的量子算法，只需单纯延长哈希函数的输出长度即可应对，夸耀着其极其坚固的安全性（最保守的安全级别）。

8.1. 利用WOTS+与FORS实现的无状态架构

基于哈希的签名历史悠久，可以追溯到20世纪70年代的Lamport签名和Winternitz一次性签名（WOTS）。这些是“只能安全签名一次”的用后即弃密钥。为了能多次使用，开发出了结合默克尔树（Merkle Tree）将无数次一次性密钥统一由一个根哈希来管理的XMSS（eXtended Merkle Signature Scheme）和LMS等算法。

但是，XMSS和LMS存在一个叫做“有状态（Stateful）”的严重缺陷。每次签名都必须在非易失性内存中严格记录“使用了第几个一次性密钥”的索引状态，如果因为虚拟机快照恢复等原因导致状态回溯，同一个一次性密钥被使用两次，私钥就会立刻泄露导致系统崩溃。

SPHINCS+则解决了这种状态管理的繁琐，是“无状态（Stateless）”的基于哈希的签名。其核心技术由以下部分组合而成：

WOTS+ (Winternitz One-Time Signature Plus): 基本的一次性签名。
FORS (Forest of Random Subsets): 少次签名（Few-Time Signature）技术。即使重复使用该密钥数次也能保持安全。
Hyper-Tree (巨大树结构): 将默克尔树多层叠加而成的庞大结构。

SPHINCS+在进行签名时，不再管理状态，而是利用伪随机数从Hyper-Tree底部的海量FORS密钥中随机挑选一个进行签名。由于树叶的数量属于天文数字量级，偶然两次选中同一个密钥的概率（碰撞）小到可以忽略不计，从而实现了无状态化。

SPHINCS+唯一也是最大的弱点在于，签名尺寸非常庞大。根据参数不同，签名尺寸可达17千字节至49千字节，签名生成速度也远慢于格密码学。因此，相比于日常网络浏览，它更适合被用于软件更新签名或根证书颁发机构（CA）证书等不需频繁签名，且强烈要求长期绝对安全的场景。

9. 基于编码的密码学：Classic McEliece这个古老而优秀的巨人

在NIST标准化进程中，作为Round 4的最终候选仍在继续评估的一个重要方案是，基于编码的密码学中的Classic McEliece。

1978年由Robert McEliece提出的这一算法，是公钥密码学历史中与RSA并肩最古老的算法之一。它利用了被称为“Goppa码（哥帕码）”的代数几何码，在消息中故意加入错误（噪声向量）进行加密，只有拥有作为私钥的Goppa码奇偶校验矩阵的人，才能利用其强大的纠错能力消除错误，从而解密出原始消息。这基于“伴随式解码问题 (Syndrome Decoding Problem)”。

$$ \vec{c} = \vec{m} G + \vec{e} $$

（$G$ 是公开的被置换过的生成矩阵，$\vec{e}$ 是汉明重量为 $t$ 的错误向量）

Classic McEliece令人惊叹之处在于，它提出已逾40年，经历了全世界密码学界猛烈的破解研究，却从未被发现存在根本性的漏洞，展示了压倒性的实绩。在PQC中，它是最具“时间证明之坚固安全性”的算法。

此外，它的密文尺寸非常小（仅有约100至200字节）。然而，它存在一个致命的缺点：公钥的尺寸达到了兆字节（MB）级别。即便是最低的安全级别（相当于AES-128），公钥也有约250KB，高安全级别下更是超过1MB。

正因如此，它完全无法适用于诸如TLS握手等每次通信都需要在网络上传输公钥的场景。不过，在预共享VPN密钥交换、将公钥硬编码至固件、或者是卫星通信等可以提前将公钥部署到系统中的特殊用例中，因其强大的安全性，它仍作为一个极具希望的选项被持续探讨。

10. 各PQC算法的性能比较与权衡

对于前面解说的各主要算法，在一般安全级别（相当于NIST Level 2〜3、AES-128〜192）下的性能特征，总结于下表。

算法 (标准名)	类别	数学基础	公钥尺寸	私钥尺寸	密文/签名尺寸	处理速度倾向	主要特征与用途
Kyber768 (ML-KEM)	KEM	Module-LWE	1,184 Bytes	2,400 Bytes	1,088 Bytes	非常快	密钥尺寸与速度平衡最佳。TLS 1.3等通用KEM标准。
Dilithium3 (ML-DSA)	签名	Module-LWE	1,952 Bytes	4,032 Bytes	3,309 Bytes	生成与验证均快	实现简单。通用数字签名标准。
FALCON-512 (FN-DSA)	签名	NTRU格	897 Bytes	1,281 Bytes	666 Bytes	签名生成偏慢，验证超快	签名尺寸极小。但需要浮点运算。适合嵌入式与IoT。
SPHINCS+ (SLH-DSA)	签名	哈希函数	32 Bytes	64 Bytes	约 17,000 Bytes	生成非常慢	几乎没有数学崩溃的风险。用于根证书等高安全用途。
Classic McEliece	KEM	Goppa码	约 1.04 MB	13,568 Bytes	188 Bytes	封装很快	40年安全性证明。公钥巨大。适合可硬编码环境。

权衡的理解

在PQC的世界里，不存在“尺寸小、速度快、数学保证完美”的魔法般的单一算法。

互联网标准 (Kyber / Dilithium): 性能平衡最佳，最适合作为当前RSA/ECC的直接替换（Drop-in replacement）。
极致的保守性 (SPHINCS+) : 即使牺牲数据大小和处理速度，也希望对未来的数学突破有一份绝对保险时的选择。
面向特殊环境 (FALCON / Classic McEliece): 通信带宽极其狭窄，或是可以提前分发公钥等，根据环境限制而选择的特化型武器。

11. 面向实际应用的挑战与“混合加密”这一现实解

随着NIST标准化的完成和FIPS规范的正式发布，全世界IT基础设施向PQC的迁移（PQC Migration）已经正式拉开帷幕。谷歌的Chrome浏览器、苹果的iMessage（PQ3协议）、Cloudflare等网络提供商，已经开始在协议中实现对PQC的支持，并投入实际运营。

但是，突然完全切换到新密码算法伴随着非常高的风险。假设几年后有一位天才数学家发现了针对Kyber等格密码学的致命攻击手法（甚至连经典计算机也能利用的数学缺陷），那么依赖该算法的所有系统将会瞬间裸奔。

为了减轻这种不确定性风险，一个务实且被推荐的策略是“混合加密 (Hybrid Cryptography)”。

混合加密中，同时使用拥有多年实际验证的现行经典加密（如X25519等椭圆曲线加密）与新的PQC（如Kyber768）来进行密钥交换。各自的算法分别生成对称密钥的成分，最后使用安全的密钥派生函数（KDF）将两个成分混合，生成最终的主密钥。

graph TD A["客户端"] -->|① 发送 X25519公钥 + Kyber公钥| B["服务器"] B -->|② 返回 X25519共享密钥 + Kyber封装密文| A A --> C{"主密钥的派生 (KDF)"} B --> C C -->|输入: (X25519对称密钥) || (Kyber对称密钥)| D["安全的通信密钥 (AES-256 / ChaCha20)"] D -->|"同时抵抗量子威胁＆传统经典漏洞"| E["安全的混合加密通信 (TLS 1.3)"]

如此一来，就实现了坚固的双重安全保障：“万一量子计算机实现并破解了ECC，Kyber能保护通信”；反之，“万一Kyber被发现了未知的数学缺陷，ECC依然能保护通信”。作为典型代表，IETF正在推进标准化的 X25519MLKEM768 (原 X25519Kyber768) 草案，正是目前Web浏览器与最先进的服务器间通信所采用的混合方式。

此外，在系统设计中，构建一种“不过度依赖特定密码算法，当算法崩溃时能迅速切换到另一算法（如从Kyber切换至McEliece，从Dilithium切换至SPHINCS+）的架构”的理念，即 Crypto Agility（密码敏捷性），将成为未来系统开发中的必备要求。

12. 结语：密码技术的新地平线

量子计算机这项人类梦寐以求的科技，讽刺地成为了击破我们长年信赖的“素数分解”和“离散对数问题”等数学防线的最大威胁。然而，全世界的密码学家们并未屈服，他们开拓了诸如格理论、哈希函数树、纠错码等更为复杂且深邃的多维数学领域，筑起了抗量子密码学（PQC）这座新的防御堡垒。

NIST完成了 FIPS 203 (ML-KEM)、FIPS 204 (ML-DSA)、FIPS 205 (SLH-DSA) 的标准化并不是终点。这仅仅是未来将持续数十年的PQC迁移这场宏大旅程的第一步。对于软件工程师和系统架构师来说，如何将这些新算法带来的“密钥尺寸增大”和“计算成本变化”最优地融入并适应到网络协议和系统中，将是未来重大的技术挑战。

量子计算机与密码学的较量，是人类数学探索与技术进化交锋最激烈的激动人心的领域。希望通过本文，您能对PQC背后的优美数学理论，以及塑造网络安全未来的各算法令人惊叹的机制，有更深刻的理解。

References:

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard

量子计算机实用的日子：2026年的现状

Fri, 11 Sep 2026 06:00:00 +0900

1. 引言：2026年，量子计算机发展到了什么程度

截至2026年，量子计算已经完成了从昔日“理论上的梦想”到“工程上的现实”的决定性转变。随着几年前还是主流的**NISQ（Noisy Intermediate-Scale Quantum，含噪声中等规模量子）**设备的局限性变得明显，世界各地的研究机构和科技巨头纷纷转向实现“容错量子计算（FTQC: Fault-Tolerant Quantum Computing）”。

本文将结合2026年的最新突破，深入探讨量子计算机的现状。特别是，将详细讲解量子纠错（表面码）、物理量子比特与逻辑量子比特的区别、拓扑量子计算的进展，以及超导和离子阱方式的最前沿。

2. 量子态基础与保真度（Fidelity）

量子计算机的基本单位是量子比特（Qubit），与经典比特（0或1）不同，它可以处于0和1的叠加态（Superposition）。单个量子比特的状态可以表示为希尔伯特空间上的向量，如下所示：

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

这里，$\alpha$ 和 $\beta$ 是复数概率幅，并满足以下归一化条件：

$$ |\alpha|^2 + |\beta|^2 = 1 $$

在衡量量子计算性能时，一个极其重要的指标是保真度（Fidelity）。理想量子态 $|\psi\rangle$ 与因噪声退化而变成混合态的实际密度矩阵 $\rho$ 之间的保真度 $F$ 定义如下：

$$ F(\rho, |\psi\rangle) = \langle \psi | \rho | \psi \rangle $$

到2026年，双量子比特门（例如：CNOT门和CZ门）的保真度在超导方式下已经能够稳定突破**99.99%**的壁垒（即所谓的“4个9”）。这一数值大幅超过了表面码纠错的阈值（约99%），是迈向实用化的最大突破之一。

3. NISQ时代的局限与向FTQC的范式转变

2010年代后半期到2020年代前半期是NISQ（Noisy Intermediate-Scale Quantum）时代，即拥有几十到几百个量子比特且不具备纠错能力的设备。然而，NISQ存在明显的局限性。

随着电路深度（Depth）的增加，错误会呈指数级积累，导致无法获得有意义的计算结果。电路深度 $D$ 下的整体成功概率 $P_{success}$ 随单门保真度 $f$ 和门数量 $N$ 衰减如下：

$$ P_{success} \approx f^N $$

如果 $f = 0.99$ 并应用1000个门，那么 $0.99^{1000} \approx 4.3 \times 10^{-5}$，结果将几乎完全被随机噪声淹没。因此，在2026年，相较于直接扩展NISQ算法（如VQE或QAOA等），资源更多地集中在生成**逻辑量子比特（Logical Qubit）**上。

4. 量子纠错与逻辑量子比特：表面码的最前沿

量子纠错（QEC: Quantum Error Correction）是一种通过编码多个“物理量子比特”来创建一个“逻辑量子比特”，从而检测并纠正错误的技术。目前最被看好的是表面码（Surface Code）。

4.1 表面码（Surface Code）的结构

在表面码中，量子比特被排列成二维网格状。数据量子比特（保存实际信息）和测量量子比特（用于综合征测量）像棋盘格一样交错排列。

graph TD A["数据量子比特 (D1)"] --- B["测量量子比特 (M1)"] B --- C["数据量子比特 (D2)"] C --- D["测量量子比特 (M2)"] D --- E["数据量子比特 (D3)"] B --- F["数据量子比特 (D4)"] D --- G["数据量子比特 (D5)"] style A fill:#e1f5fe,stroke:#039be5 style C fill:#e1f5fe,stroke:#039be5 style E fill:#e1f5fe,stroke:#039be5 style F fill:#e1f5fe,stroke:#039be5 style G fill:#e1f5fe,stroke:#039be5 style B fill:#fff3e0,stroke:#fb8c00 style D fill:#fff3e0,stroke:#fb8c00

使用稳定子算符 $S_x$ 和 $S_z$ 不断监控比特翻转（X错误）和相位翻转（Z错误）。

$$ S_x = \prod_{i \in \text{star}} X_i, \quad S_z = \prod_{j \in \text{plaquette}} Z_j $$

2026年的重大进展是完全突破了“盈亏平衡点（Break-even point）”。也就是说，通过纠错消除的噪声大于执行纠错所需的额外电路引起的噪声，逻辑量子比特的寿命开始比物理量子比特的寿命高出好几个数量级。

4.2 量子纠错循环

纠错作为一个持续的反馈回路运行。

sequenceDiagram participant D as "数据量子比特" participant M as "辅助/测量量子比特" participant C as "经典控制器" loop "综合征提取周期 (约 1 微秒)" D->>M: "纠缠 (CNOT/CZ)" M->>C: "测量状态 (综合征)" C->>C: "解码综合征 (例如最小权重完美匹配)" C-->>D: "应用泡利纠正 (如果需要)" end

目前，利用FPGA或专用ASIC在纳秒级别执行这种经典解码处理（综合征分析）的技术已经成熟，实时纠错已进入实用阶段。

5. 硬件架构的演进（2026年版）

2026年的量子硬件主要在“超导方式”、“离子阱方式”和“拓扑方式”这三个方向上演进。

5.1 超导量子比特的集成化

超导方式是IBM和Google主导的领域，主要使用基于约瑟夫森结的Transmon量子比特。到2026年，实现了在单芯片上集成数千到一万个物理量子比特的超大型芯片。

值得一提的是**模块间量子通信（Quantum Interconnects）**的确立。利用微波光子实现芯片间的量子隐形传态已达到商业应用水平，从而能够避开单一稀释制冷机尺寸的限制。

5.2 离子阱的二维扩展与光互连

在离子阱方式（由Quantinuum和IonQ等主导）中，使用悬浮在真空中的离子的内部能态作为量子比特。与超导方式相比，其优势在于T1/T2相干时间极长，并且支持全连接（All-to-All Connectivity）。

2026年的突破在于QCCD（Quantum Charge Coupled Device）架构的二维化，以及使用光子互连在多阱之间生成高速纠缠。这使得离子阱曾存在的“门操作速度慢”和“可扩展性”等弱点得到了极大的改善。

5.3 拓扑量子计算：任意子的控制

长期以来被认为是理论存在的拓扑量子计算在2026年终于进入了实验验证阶段。由Microsoft等公司推动的这种方式，使用被称为“马约拉纳零模（Majorana Zero Modes）”的非阿贝尔任意子（Non-Abelian Anyons）。

通过交换任意子粒子位置的“编织（Braiding）”操作来执行量子门。

$$ |\psi_{final}\rangle = B_{ij} |\psi_{initial}\rangle $$

这里 $B_{ij}$ 是编织算符。拓扑方式的信息存储不依赖于粒子的局域状态，而是依赖于整体“结”的拓扑结构，因此它本质上对环境噪声具有免疫力（硬件级别的容错能力）。2026年世界上首次确认了高保真度拓扑逻辑量子比特的生成，作为通向FTQC的强大捷径而备受瞩目。

6. 面向实用化的路线图与展望

要让量子计算机在“化学计算”、“材料科学”、“金融建模”等领域真正发挥出压倒经典计算机（超级计算机）的量子霸权（Quantum Advantage，也称量子优势），需要数千个逻辑量子比特。

gantt title "量子计算路线图 (2026年修订版)" dateFormat YYYY axisFormat %Y section "NISQ 时代" "含噪声量子比特 (<1000)" :done, 2018, 2024 section "早期 FTQC" "盈亏平衡点演示" :done, 2024, 2026 "数百个逻辑量子比特" :active, 2026, 2028 section "全面 FTQC" "1000+ 逻辑量子比特 (商业应用)" : 2028, 2030 "通用容错量子计算机" : 2030, 2035

6.1 当前面临的挑战与未来

截至2026年，最大的挑战在于维持极低温的巨大低温恒温器（稀释制冷机）的冷却能力，以及连接室温控制设备与极低温量子芯片的布线（I/O瓶颈）。针对这一点，能够在极低温环境下运行的CMOS（Cryo-CMOS）控制芯片的开发正在全速推进。

结论

2026年将在量子计算机的历史上被记载为“逻辑量子比特扩展元年”。通过纠错算法的验证、硬件的模块化以及拓扑方法的快速进展，“实用化的日子”已不再是遥远的未来，而是可以预见为未来几年内的具体里程碑。对于量子算法开发者和企业而言，现在正是开始全面投资于量子原生问题解决方案的绝佳时机。

本文基于截至2026年最新的量子计算研究论文及行业动态撰写。