密码学 on kenji.blog

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

Sat, 05 Sep 2026 13:04:59 +0900

【完全解剖】使用C++实现并理解最强密码破解算法「GNFS」

支撑现代互联网根基的「RSA加密」。其坚固性依赖于一种数学信念：“以目前的计算机，想要对巨大的合数进行素数分解实际上是不可能的”。

然而，人类从未放弃。如今，在经典计算机（非量子计算机）上，存在着一种用于进行巨大素数分解的 **人类最强、最尖端的算法 **。那就是 「一般数域筛选法（GNFS：General Number Field Sieve）」。

本文将完全公开使用C++（使用了Boost库的多精度整数 boost::multiprecision）严格建模这一GNFS最尖端计算逻辑的实现代码，并彻底解说其背后的「代数数论」深渊。

请务必结合源代码，尽情领略数学的神秘以及将其征服的计算机科学的暴力美学。

1. GNFS 最尖端逻辑框架（完整源代码）

首先，展示本次要解说的GNFS C++实现的整体面貌。实际的数域筛选法（如CADO-NFS等）是长达数十万行的超大型分布式系统，而本代码提取了构成GNFS的 「5个必备流水线（阶段）」 进行类设计，并在不丢失数学意义的前提下以最小结构进行了建模。

 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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227


#include <iostream>
#include <vector>
#include <cmath>
#include <map>
#include <set>
#include <chrono>
#include <boost/multiprecision/cpp_int.hpp>

// 使用Boost.Multiprecision的多精度整数
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (一般数域筛选法) 最尖端逻辑框架
//
// 本代码将CADO-NFS等使用的最尖端GNFS的5个流水线
// 严格建模为C++ (Boost) 的类设计。
// ============================================================================

struct Relation {
 int64_t a;
 int64_t b;
 std::vector<uint32_t> rational_primes;
 std::vector<uint32_t> algebraic_primes;
};

// ============================================================================
// Phase 1: Polynomial Selection (KleinJung算法)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // 代数侧多项式 f(x)
 std::vector<cpp_int> g; // 有理侧多项式 g(x) = x - m
 cpp_int m;

 PolynomialSelector(int d) : degree(d) {}

 // 基于 base-m 展开生成初始多项式 (实际使用更高级的格基规约 LLL)
 void select(const cpp_int& N) {
 std::cout << "[Phase 1] Polynomial Selection (Degree " << degree << ") starting..." << std::endl;
 // 简单的 base-m 展开 (d次)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // 简单的m估算 (不使用Boost函数的近似)
 cpp_int low = 1, high = N;
 while (low <= high) {
 cpp_int mid = low + (high - low) / 2;
 cpp_int p = 1;
 for(int i=0; i<degree; ++i) p *= mid;
 if (p <= N) { m = mid; low = mid + 1; }
 else { high = mid - 1; }
 }

 f.resize(degree + 1);
 cpp_int temp = N;
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }

 g = {-m, 1}; // g(x) = x - m

 std::cout << " -> m = " << m << std::endl;
 std::cout << " -> f(x) = ";
 for(int i = degree; i >= 0; --i) {
 std::cout << f[i] << "x^" << i << (i > 0 ? " + " : "");
 }
 std::cout << "\n[Phase 1] Complete." << std::endl;
 }
};

// ============================================================================
// Phase 2: Lattice Sieving (格筛选法)
// ============================================================================
// 近年的GNFS中，相较于线筛选 (Line Sieve)，Franke-Kleinjung等人的
// 特殊q格筛选 (Special-q Lattice Sieving) 是事实上的标准。
class LatticeSieve {
 uint32_t rational_bound;
 uint32_t algebraic_bound;
 std::vector<uint32_t> rational_fb;
 std::vector<uint32_t> algebraic_fb;

public:
 LatticeSieve(uint32_t rb, uint32_t ab) : rational_bound(rb), algebraic_bound(ab) {}

 void generate_factor_bases() {
 std::cout << "[Phase 2] Generating Factor Bases (Rational Bound: " << rational_bound << ", Algebraic Bound: " << algebraic_bound << ")" << std::endl;
 // (省略) 实际上会进行素数生成以及利用勒让德符号等进行过滤
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Phase 2] Special-q Lattice Sieving active..." << std::endl;
 std::vector<Relation> relations;
 // 模拟实现: 实际的格筛选会以块为单位扫描数百GB的内存空间
 // 将 (a, b) 的对映射到每个特殊素数 q 的格子 (a = i*q + j*...) 上，
 // 执行将缓存效率提升到极限的筛选。

 // 为演示添加一个虚拟关系
 Relation r; r.a = 17; r.b = 3;
 r.rational_primes = {2, 5};
 r.algebraic_primes = {3, 7};
 relations.push_back(r);

 std::cout << "[Phase 2] Found " << relations.size() << " relations." << std::endl;
 return relations;
 }
};

// ============================================================================
// Phase 3: Filtering (奇异点清除与团合并)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Phase 3] Filtering Relations..." << std::endl;
 // 1. Singleton removal (删除仅出现1次的素数所对应的关系)
 // 2. Clique merging (合并关系以使稀疏矩阵变稠密)
 // 实际上会使用并查集等算法将数亿行的矩阵压缩到数百万行。
 std::cout << "[Phase 3] Matrix size reduced optimally." << std::endl;
 }
};

// ============================================================================
// Phase 4: Linear Algebra over GF(2) (Block Wiedemann 法)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // 在近年的超算环境中，比起 Block Lanczos 法，更适合分布式计算的
 // Block Wiedemann 法 (Coppersmith实现) 被作为最尖端技术使用。
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 std::cout << "[Phase 4] Block Wiedemann algorithm over GF(2) starting..." << std::endl;
 // 迭代进行稀疏矩阵与向量的乘积运算，
 // 找到多个满足 M * x = 0 mod 2 的解向量(零空间)。

 std::vector<std::vector<int>> dependencies; // 依赖关系列表
 // 虚拟数据
 dependencies.push_back({0});

 std::cout << "[Phase 4] Found " << dependencies.size() << " linear dependencies (perfect squares)." << std::endl;
 return dependencies;
 }
};

// ============================================================================
// Phase 5: Algebraic Square Root (代数平方根)
// ============================================================================
class AlgebraicSquareRoot {
public:
 void compute_and_factor(const std::vector<Relation>& relations, const std::vector<int>& dep, const cpp_int& N) {
 std::cout << "[Phase 5] Algebraic Square Root computation..." << std::endl;

 // 1. 有理侧平方根 V 的计算 (简单的整数运算)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. 代数侧平方根 gamma 的计算 (Montgomery法等)
 // 求出巨大代数域 O_K 的元素 gamma，并通过同态映射 phi 映射到现实世界
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // 为了回避理想类群与单位群的障碍(Obstruction)，
 // 前提是在Phase 2和4中添加了二次剩余特征(Quadratic Characters)的列。

 std::cout << " -> Homomorphism map phi applied." << std::endl;
 std::cout << "[Phase 5] Calculating GCD(V - Y, N)..." << std::endl;

 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)

 if (factor > 1 && factor < N) {
 std::cout << "\n================================================================" << std::endl;
 std::cout << "[SUCCESS] Non-trivial factor found: " << factor << std::endl;
 std::cout << " Other factor: " << N / factor << std::endl;
 std::cout << "================================================================" << std::endl;
 } else {
 std::cout << "[FAILURE] Trivial solution. Trying next dependency..." << std::endl;
 }
 }
};

// ============================================================================
// Main Execution Pipeline
// ============================================================================
int main() {
 std::cout << "================================================================" << std::endl;
 std::cout << " [SOTA GNFS] General Number Field Sieve Engine (Boost C++) " << std::endl;
 std::cout << "================================================================" << std::endl;

 // 想要进行素数分解的巨大合数 N (如 RSA-270 等)
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // 多项式的次数 (超过130位时通常选择 5次～6次)
 int degree = 6;

 // 初始化流水线
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // 实际的界限在数千万到数亿
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

 auto start_time = std::chrono::high_resolution_clock::now();

 // 1. 多项式选择
 poly_select.select(N);

 // 2. 筛选 (Sieve) 处理
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. 过滤 (矩阵压缩)
 filter.reduce_matrix(relations);

 // 4. 线性代数 (GF(2)上的零空间搜索)
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. 代数平方根的计算与GCD
 for (const auto& dep : dependencies) {
 sqrt_step.compute_and_factor(relations, dep, N);
 }

 auto end_time = std::chrono::high_resolution_clock::now();
 std::chrono::duration<double> elapsed = end_time - start_time;
 std::cout << "\n[System] SOTA GNFS Pipeline completed in " << elapsed.count() << " seconds." << std::endl;

 return 0;
}

那么，这段代码究竟是如何突破加密壁垒的呢？接下来，我们将按5个阶段，将其严密的算法与高深的数学揉碎了进行解说。

2. GNFS的最终目的： $X^2 \equiv Y^2 \pmod N$

不仅是GNFS，现代巨大的素因数分解算法几乎都在追求一个共同的目标：找到满足以下同余式的非平凡对 $(X, Y)$。

$$X^2 \equiv Y^2 \pmod N$$

这个式子意味着，“$X^2$ 和 $Y^2$ 除以 $N$ 的余数相等”。将其变形可得， $X^2 - Y^2 \equiv 0 \pmod N$ 也就是说，$(X-Y)(X+Y)$ 是 $N$ 的倍数。

如果 $X \not\equiv \pm Y \pmod N$（非平凡解），那么在 $(X-Y)$ 和 $N$ 之间就存在一个“大于1且小于 $N$ 的公约数”。此时，使用辗转相除法计算 $\gcd(X-Y, N)$，就可以轻而易举地求出 $N$ 的素因子。

然而，要找到这样的 $X$ 和 $Y$ 无异于大海捞针。因此GNFS采取了一种天才般的方法，即创造出“现实的整数世界”和“多项式的代数域世界” 这两个世界，并将计算分散开来。

3. Phase 1: 多项式选择（Polynomial Selection）

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


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // m = N^(1/d) 的计算与 base-m 展开
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

GNFS的第一步，是构建连接两个世界的“魔法多项式”。对于巨大的数 $N$，我们选取一个整数 $m$。通常选取 $m \approx N^{1/d}$（代码中假设为 $d=6$ 次多项式）。

然后，将 $N$ 展开为 $m$ 进制，利用其系数构建多项式 $f(x)$。

$$N = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$$ $$f(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_1 x + c_0$$

这个多项式 $f(x)$ 具有一个极其重要的性质：“当变量 $x$ 代入 $m$ 时，结果正好是 $N$（$f(m) = N$）”。换句话说，$f(m) \equiv 0 \pmod N$。有理侧的多项式定义为 $g(x) = x - m$。

这样，由 $f(x)=0$ 的根 $\alpha$ 所支配的 “代数域世界 $\mathbb{Z}[\alpha]$”，与普通的 “有理数（整数）世界 $\mathbb{Z}$”，通过 $x \to m$ 的“环同态映射（Homomorphism）”被紧密地连接在了一起。

在最尖端的CADO-NFS等实现中，会花费数月时间，利用KleinJung算法或LLL格基规约算法，去搜索一个多项式系数不会极大，并且在后续步骤中更容易出现素数（更容易平滑）的“最合适的多项式 $f(x)$”。

4. Phase 2: 特殊 $q$ 格筛选法（Special-q Lattice Sieving）

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // 将 (a, b) 的对映射到每个特殊素数 q 的格子中，
 // 执行将缓存效率提升到极限的筛选。
 // ...
 }
};

准备好两个世界后，下一步就是在这两个世界中寻找“平滑数（仅由小素数组成的数）”。生成无数个整数对 $(a, b)$，并计算以下两个值：

有理侧的值 ： $a - bm$
代数侧的范数 ： $b^d f(a/b)$

GNFS的目的是收集几千万到几亿个 “有理侧和代数侧的值都能被小素因子完全分解的整数对（Relation：关系）”。

在早期的GNFS中，使用“线筛选（Line Sieve）”，即把 $(a, b)$ 排列在 $xy$ 平面上，从头开始依次用素数去除。然而，这种做法会导致在内存各处跳跃访问，引发频繁的缓存未命中，速度非常慢。

因此，在当前的尖端代码中使用了 “特殊 $q$ 格筛选（Special-q Lattice Sieve）” 技术。固定一个适度大的素数 $q$，只把那些“代数侧的值必然能被 $q$ 整除的 $(a, b)$ 对”作为计算对象。满足这个条件的 $(a, b)$ 在平面上形成了一个“格子（Lattice）”，使得计算内存地址的跳跃幅度固定，完美契合CPU的L1/L2缓存。通过引入格筛选，GNFS的计算速度得到了戏剧性的提升。

5. Phase 3: 过滤（Filtering）

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (删除仅出现1次的素数所对应的关系)
 // 2. Clique merging (合并关系以使稀疏矩阵变稠密)
 }
};

Phase 2中全球计算机花费数月收集到的数亿个关系。但是，如果直接将这些关系丢给下一个“解方程组步骤（矩阵计算）”，超级计算机的内存也会被撑爆。

因此，需要进行称为 Filtering（过滤） 的矩阵超压缩过程。

Singleton removal（奇异点清除） 假设一个巨大的素数 $p$ 在数亿个关系中“仅仅出现了一次”。因为我们的目标是“让所有素数的指数都变为偶数（2的倍数）”，所以只出现一次的素数是绝对无法变成偶数的。因此，包含该素数的关系会被视为“无用的垃圾”立即删除（清除）。由于这会引起连锁反应，原本数亿行的数据会迅速减少。
Clique merging（团合并） 进一步地，将共享特定素数的关系互相相乘（相加），从而在减少行数的同时，把稀疏（空洞多）的矩阵压缩成更稠密的状态（使用类似图论中的团搜索技术）。

通过这种优化，巨大的稀疏矩阵被戏剧性地压缩到了可以计算的规模。

6. Phase 4: GF(2) 上的线性代数（Block Wiedemann法）

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // 迭代进行稀疏矩阵与向量的乘积运算，
 // 找到多个满足 M * x = 0 mod 2 的解向量(零空间)。
 }
};

终于到了拼图的核心。将收集到的关系相乘，寻找 “所有素因子的指数都变成偶数次方的组合”。

这在数学上等同于，用一个元素为各素数指数的“偶数/奇数（即0或1）”的巨大矩阵 $M$，和一个表示使用哪些关系的向量 $x$，求解满足 $M \cdot x \equiv 0 \pmod 2$ 的解向量 $x$（零空间、核）。

我们需要解开数百万行 × 数百万列这种惊人规模矩阵的联立方程式。如果使用普通的高斯消元法，计算复杂度将达到 $O(N^3)$，即使到宇宙终结也算不完。

因此，最尖端的实现采用了 “Block Wiedemann（分块维德曼）法”。这是一种Krylov子空间法，利用矩阵 $M$ “非常稀疏（几乎全是0）”的特点，通过迭代进行矩阵与向量的乘法运算来推导出解。与传统的Block Lanczos法不同，Block Wiedemann法可以将计算过程完全分割给多个集群，因此在现代的分布式云计算或超级计算机的并行计算中能发挥压倒性的威力。

7. Phase 5: 代数平方根（Algebraic Square Root）与密码的崩溃

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. 有理侧平方根 V 的计算
 cpp_int V = 1;

 // 2. 代数侧平方根 gamma 的计算
 cpp_int Y = 1;

 // ...
 cpp_int factor = gcd(V - Y, N); // GCD(X-Y, N)
 }
};

通过Phase 4的矩阵计算，我们得到了“一旦相乘，所有素因子都会变为偶数次方的关系集合 $S$”。借此，我们能够在有理侧和代数侧各自的世界中构建出“平方”。

有理侧只是简单的整数乘法，计算平方根 $V$ 很容易。

$$V^2 = \prod_{S} (a - bm)$$

然而，真正的地狱在于“代数侧”。 在代数域的世界 $\mathbb{Z}[\alpha]$ 中，素因子分解的唯一性不成立，因此我们一直使用理想（Ideal）进行计算。矩阵计算所保证的仅仅是 “成为了理想的平方”，而并未保证“成为元素的平方（$\gamma^2$）”。

在此，代数数论中两堵坚固的高墙——“理想类群的障碍”与“单位群的障碍”——拦住了去路。在GNFS中，为了打破这堵墙，使用了 “二次剩余特征（Quadratic Characters）” 这种魔法。即在Phase 4的矩阵中，事先悄悄加入了针对数十个特定素理想的二次剩余（勒让德符号）列。这样一来，找到的集合 $S$ 就能以压倒性的概率绕过障碍，顺利形成“真正的元素平方 $\gamma^2$”。

求 $\gamma$ 的过程（代数平方根）使用了如Montgomery法等极其复杂的算法。

最后，通过环同态映射 $\phi$（将 $x$ 替换为 $m$），把代数侧的平方根 $\gamma$ 传送回现实世界，得到 $Y$。只要将有理侧的 $V$ 直接作为 $X$，我们一直追求的绝对等式便终于完成了。

$$X^2 \equiv Y^2 \pmod N$$

剩下的就只是计算 $\gcd(X-Y, N)$ 了。经过0.001秒的短暂运算，当非平凡因子打印在屏幕上的那一刻，曾被认为坚不可摧的RSA加密便彻底崩溃了。

结语

GNFS绝非仅仅是编程技巧。它是将抽象代数、环论、理想类群等“纯数学的深渊”，用超级计算机的分布式架构和缓存优化等“极限工程学”加以征服后的人类智慧结晶。

我们平日里漫不经心发送的聊天信息或信用卡数据，正是被建立在这种天文级别的数学攻防之上的系统所保护着。

希望通过这个C++框架，能让您感受到最尖端密码破解算法背后蕴藏的“数学与计算机的浪漫”。

一般数域筛法（GNFS）的真正数学结构

Sat, 05 Sep 2026 02:26:13 +0900

一般数域筛法（GNFS）的真正数学结构

GNFS的最终目标是找到满足 $X^2 \equiv Y^2 \pmod N$ 的 $X, Y$。为了实现这一目标，数学家们在 “现实的整数世界” 与 “代数数域的世界” 之间架起了一座桥梁。这座桥梁就是“同态映射”。

第一阶段：连接世界的“同态映射（Homomorphism）”

1. 多项式的选择与根的定义

对于巨大的合数 $N$，选择一个整数 $m$ 和多项式 $f(x)$，使得 $f(m) \equiv 0 \pmod N$。（例如：将 $N$ 展开为 $m$ 进制数，由其系数构造 $f(x)$。此时假设 $f(x)$ 在有理数域 $\mathbb{Q}$ 上是不可约的（即无法再进行因式分解））。

接着，将方程式 $f(x) = 0$ 在“复数范围内的根”之一设为 $\alpha$。显然，$f(\alpha) = 0$。$\alpha$ 不是整数，而是包含根号或虚数等复杂的数（代数数）。

2. 环（Ring）与同态映射的构建

在这里，准备两个数学上的“环（定义了加法和乘法的世界）”。

世界A： $\mathbb{Z}[\alpha]$ （包含 $\alpha$ 的代数整数环）这是一个由形如 $a + b\alpha + c\alpha^2 + \dots$ 的数构成的世界。
世界B： $\mathbb{Z}/N\mathbb{Z}$ （模 $N$ 剩余环）这是一个仅由 $0$ 到 $N-1$ 的整数构成的同余（模）世界。

此时，定义一个从世界A到世界B的映射 $\phi$： $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

这个映射 $\phi$ 是一种魔法操作，它能将世界A中的变量 $\alpha$ 原封不动地替换为世界B中的整数 $m$。这个 $\phi$ 具有极强的性质，被称为 “环同态映射（Ring Homomorphism）”。同态的含义是，“在不破坏加法和乘法结构的前提下，使其跃迁到另一个世界” 的性质。也就是说，以下公式成立：

$\phi(X \times Y) = \phi(X) \times \phi(Y)$
$\phi(X^2) = \phi(X)^2$

这意味着什么呢？如果我们在“世界A（$\alpha$的世界）”中，能够构造出某个复杂元素 $\gamma$ 的 “平方（$\gamma^2$）”，那么即使通过 $\phi$ 将其跃迁到“世界B（余数的世界）”，** 也能完美保持平方的形式 $\phi(\gamma)^2$**。

第二阶段：质因数分解的崩溃与“理想（Ideal）”的诞生

在世界A（$\mathbb{Z}[\alpha]$）中，我们希望收集大量合适的元素 $(a - b\alpha)$，并将它们相乘，从而制造出一个“完全平方（平方元）”。通常情况下，只需将收集到的每个 $(a - b\alpha)$ 分别进行“质因数分解”，然后组合起来（通过矩阵求解）使得所有质数的指数都为偶数，就能构造出平方。

然而，此时代数学的一堵令人绝望的墙壁挡在了面前。 在像 $\mathbb{Z}[\alpha]$ 这样的代数数域世界中，我们在中学学到的 “质因数分解的唯一性（任何数都能且仅能以一种方式表示为质数的乘积）”崩溃了。

（例如：在某个代数数域世界中，$6 = 2 \times 3$，同时 $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$，这就让人无法分辨到底哪个才是真正的质数）

如果质因数分解无法唯一确定，那么“统计质数个数使其成对（偶数个）”的拼图游戏（筛法）在原理上就无法执行。

库默尔与戴德金的拯救：“理想”

拯救这一崩溃局面的，是19世纪数学家所创造的 “理想（Ideal：理想数）” 概念。通过考虑该元素所生成的“倍数集合（理想）”而不是元素本身，再次使质因数分解成为可能。

在代数数域的整数环 $\mathcal{O}_K$（包含 $\mathbb{Z}[\alpha]$ 的更完备的环）中，即使元素本身无法进行唯一的质因数分解，数学上已经证明了 “理想一定能唯一地分解为‘素理想（$\mathfrak{p}$）’的乘积”。

因此，在GNFS中，不是去分解元素 $(a - b\alpha)$ 本身，而是将其生成的 主理想 $\langle a - b\alpha \rangle$ 进行素理想分解。

第三阶段：范数（Norm）与双筛法（Sieve）

那么，如何知道理想 $\langle a - b\alpha \rangle$ 会分解成哪些素理想呢？这里使用了 “范数（Norm）” 函数。范数是一个将代数数域中的复杂元素转换为“普通现实整数 $\mathbb{Z}$”的函数。

元素 $(a - b\alpha)$ 的范数可以通过计算一个简单的多项式 $b^d f(a/b)$ 求得（$d$ 为 $f(x)$ 的次数）。

根据代数定理，“如果某个理想的范数能够被小质数完全分解（即是平滑的），那么它原本的理想也能被小的素理想完全分解”。

因此，GNFS针对数千万对整数对 $(a, b)$，同时计算以下两个值，并只收集那些两个值都是“平滑数”的配对。

有理筛（Rational Sieve）： $a - bm$ （现实世界的值）
代数筛（Algebraic Sieve）： $b^d f(a/b)$ （代数数域世界中的范数）

收集数千万个两者皆平滑的配对 $(a, b)$，将其理想的质因数分解数据（包含多少个素理想）构建为巨大的矩阵（GF(2)上的线性代数）进行求解，从而找到一个配对集合 $S$，使得“将它们相乘后，所有素理想的指数均为偶数”。

第四阶段：两道“障碍”的阻挡与理想类群

通过矩阵计算，我们发现将集合 $S$ 中所有的 $(a - b\alpha)$ 理想相乘，会得到某个理想 $I$ 的平方。

$$\prod_{S} \langle a - b\alpha \rangle = I^2$$

然而，这还没有结束。GNFS中最深奥、最困难的数学壁垒就在这里。

我们最终想要的，不是“理想的平方”，而是可以代入映射 $\phi$ 中的 “元素的平方（$\gamma^2$）”。理想成了平方，并不意味着元素本身也是平方。这里存在着 两大极其棘手的数学障碍（Obstruction）。

障碍①：理想类群（Ideal Class Group）的壁垒

理想 $I$ 未必是“由单个元素生成的主理想”。我们不可能从一个非主理想的理想中，提取出具体的元素 $\gamma$。

在这里，“理想类群（Class Group, $Cl_K$）” 的概念登场了。理想类群是一个衡量“在该代数数域世界中，存在多少个非主理想的理想（质因数分解的唯一性被破坏到了什么程度）”的群。即使 $\prod \langle a - b\alpha \rangle$ 变成了 $I^2$，如果 $I$ 在理想类群中不是单位元（主理想），就无法将其拉回到元素的平方。

障碍②：单位群（Unit Group）的壁垒

假设我们运气很好，$I$ 恰好是主理想 $\langle \gamma \rangle$。那么，$\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$。你可能会想：“太好了，元素也是平方了！”，但这大错特错。

理想（倍数的集合）相等，并不意味着元素完全相等。它们之间必然会产生 “单位（Unit：其倒数也是整数的数。如 1 或 -1 等）” 的偏差。也就是说，实际元素的等式如下所示：

$$\prod_{S} (a - b\alpha) = u \cdot \gamma^2$$

（$u$ 为单位群 $U_K$ 的元素）

如果这个单位 $u$ 本身不是某个数的平方（平方元），那么等式左边绝对无法成为“完全的元素平方”。

第五阶段：阿德曼的魔法“二次剩余特征（Quadratic Characters）”

理想类群的障碍与单位群的障碍。如何跨越这两个障碍呢？这时，密码学家伦纳德·阿德曼（RSA中的"A"）等人引入的天才手法 “二次剩余特征（Quadratic Characters）” 发挥了作用。

为了判断“某个元素在代数数域中是否完全是平方？”，我们使用了勒让德符号（二次剩余）的代数数域版本。在之前的巨大矩阵（为了让素理想个数变为偶数而拼凑的矩阵）中，悄悄增加几十个额外的条件（列），要求“对于几个特定的素理想 $\mathfrak{q}$，其二次剩余特征也都必须为 $1$（偶数）”。

当通过矩阵计算找到连这些附加条件也能满足的集合 $S$ 时，代数数论的深层定理保证了：“理想类群的障碍和单位群的障碍，都将以压倒性的概率自然消灭”。

由此，我们终于得到了真正的等式：

$$\prod_{S} (a - b\alpha) = \gamma^2$$

最终阶段：世界的融合与密码的崩溃

至此，拼图的所有碎片都已集齐。

【代数数域世界（世界A）的元素】 $\gamma^2 = \prod (a - b\alpha)$ （使用平方根算法求出 $\gamma$）

【现实世界（有理数世界）的元素】 $V^2 = \prod (a - bm)$ （这里只是简单的整数乘法，可以直接求出平方根 $V$）

现在，最开始建造的魔法桥梁——同态映射 $\phi$ 终于要登场了。将世界A的元素 $\gamma$，通过 $\phi$（将 $\alpha$ 替换为 $m$ 的映射），跃迁到世界B（模 $N$ 余数的世界）。

$$Y = \phi(\gamma) \pmod N$$

另一方面，将现实世界中求出的 $V$，直接带入余数世界作为 $X$。

$$X = V \pmod N$$

得益于同态映射“保持结构”的性质，在世界A中成立的平方关系，在世界B（模 $N$ 的世界）中也得到了完美的保存。此外，由于最初的配对 $(a, b)$ 是以 $a - b\alpha$ 和 $a - bm$ 的形式对应生成的，这个 $X$ 和 $Y$ 将在模 $N$ 的世界中发生碰撞，产生以下绝对的等式：

$$X^2 \equiv Y^2 \pmod N$$

接下来，只需祈祷这个 $X$ 和 $Y$ 不是平凡解（$X \equiv \pm Y$），然后计算： $\gcd(X - Y, N)$

如果是非平凡解，欧几里得辗转相除法将在 0.001 秒内跑完，RSA密码的心脏——秘密质数 $p$ 和 $q$ ——将被打印在输出屏幕上。

这就是汇集了现代数学精华的 “一般数域筛法（GNFS）”的完整面貌。

柯克霍夫原则

Wed, 16 Apr 2025 23:53:08 +0900

柯克霍夫原则

大家好！

今天想和大家聊一个有点意思，而且实际上非常重要的“柯克霍夫原则”。

啊，等等等等。
也许有人会想：“什么‘柯克霍夫原则’，根本没听说过，那么多片假名看着就头晕……”请放心。这篇文章正是为你准备的。

“安全的密码”到底是什么意思？

比如有人跟你说：“这个保险箱，只有知道秘密开法的人才能打开。”

乍一听，感觉超级安全吧。
但是，仔细想想，难道不会觉得有点不安吗？

“要是那个秘密暴露了，不就全完了吗？”

其实，这正是柯克霍夫原则登场的契机。

到底什么是“柯克霍夫原则”？

这个原则简单来说，就是：

“即使密码系统的机制暴露了，也应该是安全的。”

说得更明确一点，就是“安全性只能依赖于‘密钥’，密码本身的加密方法公开也没关系！”

反过来说，如果“只是把密码算法（机制）当作秘密，那么它的可靠性就会被认为很低”。

“只要机制保密就安全”——这种想法可能有点危险

我们经常会听到这样的说法：

“这个应用的代码谁也没给看过，所以安全性没问题。”

我能理解这种心情。
但这就像在说：“因为谁也没看过，所以就找不到坏处，肯定没问题吧。”

而实际上，“谁也没看过”这件事本身，有时就会成为一种风险。

但是，为什么这个原则那么重要？

因为，如果有人拿到了机制，并且能轻易破解，那么这个密码系统就彻底完蛋了。

打个比方，这就好比你家门锁的结构非常复杂，但实际上用百元店买的万能钥匙就能打开。

重要的不是“锁保密所以安全”，而是“就算把锁的结构全给你看，没有正确的钥匙你也打不开”。

“可是，这样不觉得可怕吗？”

很多人在这里会觉得：

“把机制全都暴露出来，不觉得可怕吗？”

我很理解。
因为大家都会想：“要是全让人看了，会不会被模仿、被恶意利用啊？”

但这正是柯克霍夫原则的核心所在。
“即使给人看也坚不可摧的强度”，才是真正的安全。

话虽如此，一开始还是需要点勇气的

如果站在开发者的角度想，“公开机制=弱点也会被看到”，这当然会让人心跳加速。

但是，请想一想。

能够坦诚地公开机制，并说“欢迎任何人来验证”的东西，结果反而会更受信任。

这和人际关系很像。

“在你展现了真实的自己后，还能和你愉快相处的人”，才是最让人安心的。

总而言之

柯克霍夫原则听起来可能有点理论化，但它的本质非常简单。

只不过是说 “我们要打造一个不管给谁看都不会被破坏的机制”。

比起表面的保密，更需要的是靠谱的设计。
比起不想给任何人看的代码，更需要的是公开也不觉得丢人的代码。

或许，在未来的时代，会越来越需要这种“强度”吧。

感谢你的阅读！

安全的话题虽然有点难，但其实它和“人际关系”、“日常生活中的安全感”也有相通的地方。
不用觉得有压力，只要慢慢了解，一定会发现其中的好处。