GNFS on kenji.blog

【完全解剖】最強の暗号解読アルゴリズム「GNFS」をC++で実装して理解する

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

【完全解剖】最強の暗号解読アルゴリズム「GNFS」をC++で実装して理解する

現代のインターネットを根底から支えている「RSA暗号」。その堅牢性は「巨大な合成数を素因数分解することは、現在のコンピュータでは事実上不可能である」という数学的信念に依存しています。

しかし、人類は決して諦めていません。現在、古典コンピュータ（量子コンピュータではない通常のコンピュータ）において、巨大な素因数分解を行うための 人類最強・最先端のアルゴリズム が存在します。それが 「一般数体篩法（GNFS：General Number Field Sieve）」 です。

本記事では、このGNFSの最先端の計算ロジックを、C++（Boostライブラリの多倍長整数 boost::multiprecision を使用）で厳密にモデル化した実装コードを全公開し、その裏側にある「代数的整数論」の深淵を徹底的に解説します。

数学の神秘と、それをねじ伏せるコンピュータサイエンスの力技を、ぜひソースコードとともに堪能してください。

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*...) にマッピングし、
 // キャッシュ効率を極限まで高めたシーブ(篩)を実行する。

 // デモ用にダミーのリレーションを1つ追加
 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 (疎な行列を密にするためのリレーション結合)
 // 実際にはUnion-Findアルゴリズムなどで数億行の行列を数百万行まで圧縮する。
 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's method 等)
 // 巨大な代数体 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;

 // RSA-270等、素因数分解したい巨大な合成数 N
 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.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は、「現実の整数の世界」と「多項式の代数体の世界」という 2つの世界 を作り出し、計算を分散させるという天才的なアプローチをとります。

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の最初のステップは、2つの世界を橋渡しするための「魔法の多項式」を作ることです。巨大な数 $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 ごとの格子にマッピングし、
 // キャッシュ効率を極限まで高めたシーブ(篩)を実行する。
 // ...
 }
};

2つの世界を用意したら、次はその両方の世界で「滑らかな数（小さな素数だけで構成される数）」を探すステップに入ります。整数ペア $(a, b)$ を無数に生成し、以下の2つの値を計算します。

有理側の値 ： $a - bm$
代数側のノルム ： $b^d f(a/b)$

GNFSの目的は、この 「有理側と代数側の値が、両方とも小さな素因数のみで完全に分解できるペア（Relation：リレーション）」 を数千万〜数億個集めることです。

初期のGNFSでは、$(a, b)$ を $xy$ 平面上に並べて端から順に素数で割っていく「直線篩（Line Sieve）」が使われていました。しかし、これではメモリのあちこちへアクセスするためキャッシュミスが多発し、非常に遅いという弱点がありました。

そこで、現在の最先端コードでは 「特殊 $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$ が、数億個のリレーションの中で「たった1回」しか登場しなかったとします。私たちが目指すのは「すべての素数の指数を偶数（2の倍数）にすること」ですから、1回しか登場しない素数は絶対に偶数にできません。したがって、その素数を含むリレーションは「使い道がないゴミ」として即座に削除（パージ）されます。これが連鎖的に起こることで、数億行あったデータがどんどん削られていきます。
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（ブロック・ヴィーデマン）法」 が採用されています。これは、行列 $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$」を手に入れました。これにより、有理側と代数側、それぞれの世界で「2乗」を構築することができます。

有理側は単なる整数の掛け算なので、平方根 $V$ を計算するのは容易です。

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

しかし、本当の地獄は「代数側」にあります。 代数体の世界 $\mathbb{Z}[\alpha]$ では、素因数分解の一意性が成り立たないため、イデアルを用いて計算を行ってきました。行列計算で保証されたのは 「イデアルの2乗」になることだけであり、「要素の2乗（$\gamma^2$）」になることは保証されていない のです。

ここには「イデアル類群の障害」と「単数群の障害」という、代数的整数論における強烈な壁が立ち塞がります。 GNFSでは、この壁を打ち破るために 「平方剰余指標（Quadratic Characters）」 という魔法を使います。 Phase 4の行列に、あらかじめ数十個の特別な素イデアルに対する平方剰余（ルジャンドル記号）の列をこっそり追加しておくのです。これにより、見つかった集合 $S$ は、圧倒的な確率で障害をスルーし、無事に「真の要素の2乗 $\gamma^2$」を形成してくれます。

$\gamma$ を求める作業（代数的平方根）は、Montgomery法などの非常に複雑なアルゴリズムを用いて計算されます。

そしてついに、代数側の平方根 $\gamma$ を、環準同型写像 $\phi$ によって現実の世界にワープ（$x$ に $m$ を代入）させ、$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$ を見つけることです。これを達成するために、数学者たちは 「現実の整数の世界」 と 「代数体の世界」 の間に橋を架けました。その橋こそが「準同型写像」です。

第1段階：世界を繋ぐ「準同型写像（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）と準同型写像の構築

ここで、2つの数学的な「環（足し算と掛け算が定義された世界）」を用意します。

世界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$ の 「2乗（$\gamma^2$）」 を作ることができれば、それを $\phi$ で「世界B（余りの世界）」にワープさせても、 見事に2乗の形 $\phi(\gamma)^2$ が保たれる ということです。

第2段階：素因数分解の崩壊と「イデアル（Ideal）」の誕生

私たちは世界A（$\mathbb{Z}[\alpha]$）の中で、適当な要素 $(a - b\alpha)$ をたくさん集め、それらを掛け合わせて「完全な2乗（平方元）」を作りたいと考えます。普通なら、集めた $(a - b\alpha)$ をそれぞれ「素因数分解」して、素数の指数がすべて偶数になるように組み合わせ（行列で解く）れば2乗が作れます。

しかし、ここで代数学の絶望的な壁が立ちはだかります。 $\mathbb{Z}[\alpha]$ のような代数体の世界では、中学で習う 「素因数分解の一意性（どんな数も素数の掛け算でただ1通りに表せる）」が崩壊してしまう のです。

（例：ある代数体の世界では、$6 = 2 \times 3$ であり、同時に $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$ となってしまい、どちらが本当の素数か分からなくなります）

素因数分解が1通りに定まらなければ、「素数の個数を数えて偶数個にする」というパズル（篩法）が原理的に実行できません。

クンマーとデデキントの救済：「イデアル」

この崩壊を救ったのが、19世紀の数学者が生み出した 「イデアル（Ideal：理想数）」 という概念です。要素そのものではなく、その要素が生成する「倍数の集合（イデアル）」を考えることで、再び素因数分解を可能にしたのです。

代数体の整数環 $\mathcal{O}_K$（$\mathbb{Z}[\alpha]$ を含むより完全な環）において、要素は一意に素因数分解できなくても、 「イデアルは必ず『素イデアル（$\mathfrak{p}$）』の積としてただ1通りに素因数分解できる」 ことが証明されています。

したがってGNFSでは、要素 $(a - b\alpha)$ そのものを分解するのではなく、それが生成する 単項イデアル $\langle a - b\alpha \rangle$ を素イデアル分解 します。

第3段階：ノルム（Norm）と2つの篩（Sieve）

では、イデアル $\langle a - b\alpha \rangle$ がどんな素イデアルに分解されるか、どうやって知るのでしょうか？ここで 「ノルム（Norm）」 という関数を使います。ノルムとは、代数体の複雑な要素を「普通の現実の整数 $\mathbb{Z}$」に変換する関数です。

要素 $(a - b\alpha)$ のノルムは、$b^d f(a/b)$ という簡単な多項式の計算で求まります（$d$ は $f(x)$ の次数）。

代数的な定理により、 「あるイデアルのノルムが小さな素数で完全に分解できる（滑らかである）ならば、その元のイデアルも小さな素イデアルで完全に分解できる」 ことが分かっています。

そこでGNFSは、大量の整数のペア $(a, b)$ に対して、次の2つを同時に計算し、両方が「滑らかな数」になるペアだけを収集します。

有理篩（Rational Sieve）： $a - bm$ （現実の世界の値）
代数篩（Algebraic Sieve）： $b^d f(a/b)$ （代数体の世界でのノルム）

両方が滑らかなペア $(a, b)$ を数千万個集め、イデアルの素因数分解データ（素イデアルが何個含まれているか）を巨大な行列（GF(2)上の線形代数）として解き、「掛け合わせると全ての素イデアルの指数が偶数になる」ようなペアの集合 $S$ を見つけます。

第4段階：立ちはだかる2つの「障害」とイデアル類群

行列計算により、集合 $S$ に属する $(a - b\alpha)$ のイデアルをすべて掛け合わせると、あるイデアル $I$ の2乗になることが分かりました。

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

しかし、まだ終わりません。GNFSにおける最も深く、最も困難な数学の壁がここにあります。

私たちが最後に欲しいのは、「イデアルの2乗」ではなく、写像 $\phi$ に代入するための 「要素の2乗（$\gamma^2$）」 です。イデアルの2乗になったからといって、要素自体が2乗になっているとは限らないのです。ここには 2つの強烈な数学的障害（Obstruction） が存在します。

障害①：イデアル類群（Ideal Class Group）の壁

イデアル $I$ は、必ずしも「1つの要素で生成されるイデアル（単項イデアル）」とは限りません。単項イデアルではないイデアルから、具体的な要素 $\gamma$ を取り出すことは不可能です。

ここで 「イデアル類群（Class Group, $Cl_K$）」 という概念が登場します。イデアル類群とは、「その代数体の世界に、単項イデアルではないイデアルがどれくらい存在するか（素因数分解の一意性がどれくらい壊れているか）」を測る群です。 $\prod \langle a - b\alpha \rangle$ が $I^2$ になったとしても、$I$ がイデアル類群において単位元（単項イデアル）でなければ、要素の2乗に引き戻すことができません。

障害②：単数群（Unit Group）の壁

仮に運良く $I$ が単項イデアル $\langle \gamma \rangle$ だったとしましょう。すると、$\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$ となります。「よし、要素も2乗だ！」と思うかもしれませんが、大間違いです。

イデアル（倍数の集合）が等しいということは、要素が完全に等しいことを意味しません。必ず 「単数（Unit：逆数も整数になるような数。1 や -1 など）」 のズレが生じます。つまり、実際の要素の等式は次のようになります。

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

（$u$ は単数群 $U_K$ の要素）

この単数 $u$ 自体が何かの2乗（平方元）でなければ、左辺は絶対に「完全な要素の2乗」にはなれません。

第5段階：アドレマンの魔法「平方剰余指標（Quadratic Characters）」

イデアル類群の障害と、単数群の障害。この2つをどうやって乗り越えるのか？ここで、暗号学者レナード・アドレマン（RSAの"A"）らが導入した天才的な手法 「平方剰余指標（Quadratic Characters）」 が登場します。

「ある要素が代数体の中で完全に2乗になっているか？」を判定するために、ルジャンドル記号（平方剰余）の代数体バージョンを使います。先ほどの巨大な行列（素イデアルの個数を偶数にするためのパズル）に、「いくつかの特別な素イデアル $\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で成り立っていた2乗の関係は、世界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）」の完全な姿 です。

インターネットの暗号を破る人類最強の数学「一般数体篩法（GNFS）」とは？

Sat, 05 Sep 2026 02:09:08 +0900

インターネットの暗号を破る人類最強の数学「一般数体篩法（GNFS）」とは？

私たちが毎日使っているインターネット。LINEのメッセージやYouTube、Amazonでの買い物など、すべての通信は「暗号」によって守られています。現在、世界中で最も使われている暗号の代表が「RSA暗号」です。

RSA暗号の守りの要（かなめ）は、非常にシンプルです。それは 「巨大な数の素因数分解は、コンピュータでも解けない」 という数学の性質を利用していること。たとえば、「15」なら「3 × 5」とすぐに分かりますが、これが「270桁の数字」になった瞬間、世界中のスーパーコンピュータを束ねても解くのに数億年かかってしまいます。

しかし、数学者たちも黙ってはいません。この鉄壁の暗号を打ち破るために、人類は 「一般数体篩法（GNFS：General Number Field Sieve）」 という、魔法のようなアルゴリズム（計算手順）を生み出しました。

この記事では、専門用語を一切使わず、 中学校で習う数学（素因数分解、文字式、最大公約数） の知識だけで、この「人類最強のアルゴリズム」が暗号を破るカラクリをステップごとに完全解説します！

第1章：暗号解読のゴールは「中学3年の公式」

巨大な素因数分解に立ち向かうための最大の必殺技。それは、中学3年生で習うこの公式です。

$X^2 - Y^2 = (X + Y)(X - Y)$

「えっ、こんな基礎的な公式で暗号が破れるの？」と思うかもしれません。しかし、これこそがすべてを解き明かすマスターキーなのです。

暗号を破るための最大の目標は、巨大な数 $N$ に対して、 「$X^2$ と $Y^2$ を $N$ で割った余りが同じになる数（$X$ と $Y$）」 を見つけることです。

なぜ「余りが同じ」だと暗号が解けるのか？

ある2つの数、$X^2$ と $Y^2$ の「$N$ で割った余りが同じ」だとします。余りが同じということは、 引き算をした「$X^2 - Y^2$」は、必ず $N$ でピッタリ割り切れる（$N$ の倍数になる） という法則があります。

ここで、暗号に使われる巨大な数 $N$ は、2つの秘密の素数（$p$ と $q$）の掛け算でできているとしましょう（$N = p \times q$）。

$X^2 - Y^2$ を因数分解すると $(X - Y)(X + Y)$ になります。これが $N$ の倍数であるということは、この掛け算のどこかに、秘密の素数 $p$ と $q$ が隠れているということです。

ここで奇跡が起きます。 2つの素数 $p$ と $q$ が、 「$p$ は $(X - Y)$ の部屋へ」「$q$ は $(X + Y)$ の部屋へ」 と、別々の部屋に分かれて入ってくれる確率が、数学的に 50%（2分の1） あるのです。

素数 $p$ だけが $(X - Y)$ の部屋に入った状態で、$(X - Y)$ と $N$ の 「最大公約数（共通する一番大きな部品）」 を計算してみましょう。

$(X - Y)$ の中身＝ $p \times$ 何かの数
$N$ の中身＝ $p \times q$ 共通している部品は 「$p$」 しかありませんよね！

つまり、最大公約数を計算した瞬間、隠れていた素数 $p$ がポロッとこぼれ落ち、暗号が完全に解読されてしまうのです。（※最大公約数は「ユークリッドの互除法」を使えば、スマホでも一瞬で計算できます）

【ちょっとコラム：なぜ2乗なの？3乗や2倍じゃダメ？】

「$2X - 2Y$」だと $2(X - Y)$ になり、部屋が1つしかないので素数を引き離せません。「$X^3 - Y^3$」だと部屋の大きさがアンバランスになり、計算がムダに重くなります。素数を2つに引き離すには、美しく2つの部屋に分かれる「2乗」が一番コスパが良いのです。

第2章：XとYをどう探す？「素数カード集めパズル」

ゴールは分かりました。しかし、「余りが同じになる $X^2$ と $Y^2$」を当てずっぽうで探しても、宇宙の寿命が終わるまで見つかりません。そこで、数学者たちは 「素数カード集めパズル」 という天才的な方法を思いつきました。

Step 1：砂金（滑らかな数）だけをザルで集める

まず、適当な数 $Z$ を用意し、2乗して $N$ で割った余り $W$ を計算します。（$Z^2 = W$ の余りの世界）

出てきた余り $W$ を素因数分解します。ここで、 「2, 3, 5, 7などの小さな素数だけでできている $W$」 が出たときだけ、その式を「アタリのカード」として残し、大きな素数が混ざっていたら捨てます。川で大きな石をザル（ふるい）で捨てて、砂金だけを集めるような作業です。

Step 2：全部「偶数個」にするパズル

たとえば、以下の3枚の砂金カードが集まったとします。

カードA： $Z_1^2 = 2^3 \times 3^1$
カードB： $Z_2^2 = 2^1 \times 5^1$
カードC： $Z_3^2 = 3^1 \times 5^1$

これを全部掛け合わせてみましょう。右側は $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$ となり、まとめて整理すると 「$2^4 \times 3^2 \times 5^2$」 になります。

なんと、素数の個数が「4個、2個、2個」と、 すべて偶数個 になりました！すべて偶数個ということは、全体を半分の個数にすれば「何かの2乗」になります。つまり、$(2^2 \times 3^1 \times 5^1)^2 = (60)^2$ です。

左側は $(Z_1 \times Z_2 \times Z_3)^2$ なので、これでついに、 $X = (Z_1 \times Z_2 \times Z_3)$ $Y = 60$ という、待ちに待った「$X^2 = Y^2$」のペアが完成したのです！

コンピュータにとって、素数の個数を「偶数か奇数か（0か1か）」で計算するパズルは非常に得意なので、この方法なら高速に $X$ と $Y$ を見つけることができます。

第3章：立ちはだかる絶望の壁

これでどんな暗号も解ける！……と思いきや、大問題が発生します。暗号の数字 $N$ が「100桁」くらいまでならこの方法（二次篩法といいます）で解けるのですが、$N$ が「200桁、300桁」になると、計算の途中で出てくる $W$ がデカくなりすぎます。

数字がデカすぎると、「小さな素数だけでできている数（砂金）」がパッタリと出なくなってしまいます。砂漠でコンタクトレンズを探すよりも難しくなり、パズルを解くためのカードが全く集まらなくなってしまうのです。

ここでついに、人類の最終兵器 「一般数体篩法（GNFS）」 が登場します。

第4章：人類最強のアイディア「2つの世界」を作る

GNFSの天才的な発想は、 「現実の世界だけで計算するから数字がデカくなる。なら、多項式（文字式）を使った『裏の世界』を作って、計算の重さを2つに分散させよう」 というものです。

文字式の魔法

GNFSは、巨大な数 $N$ をベースとなる数 $m$ を使って、文字式に変換します。たとえば $N=100$ なら、$m=4$ として $100 = 4^3 + 2(4^2) + 4$。これを文字 $x$ を使って $f(x) = x^3 + 2x^2 + x$ という式（裏の世界）にします。

この式の面白いところは、 「文字 $x$ に $m$（上の例なら4）を代入すれば、いつでも現実の数 $N$ にワープして戻ってこれる」 という性質を持っていることです。

2つの世界で同時に砂金探し

GNFSは、適当な整数のペア $(a, b)$ をたくさん作り、次の2つの計算を同時に行います。

現実の世界： $a - b \times m$
文字式の世界： $a - b \times x$ を文字式のルールで計算した値

問題を2つの世界に分けたことで、扱う数字のサイズが劇的に小さく（軽く）なります。巨大な岩を2つに割って、扱いやすい石コロにしたイメージです。

そして、 「現実の世界でも、文字式の世界でも、両方とも『小さな素数だけでできている（砂金）』」 という奇跡のペア $(a, b)$ だけをザル（篩：ふるい）でより分けて集めます。これが「数体篩法」という名前の由来です。

ついに暗号が破れる瞬間

両方の世界から数千万枚の「砂金カード」が集まったら、スーパーコンピュータの巨大な行列計算を使って、第2章でやった「素数の個数が全部偶数になる組み合わせ」を見つけ出します。

組み合わせが見つかったら、

現実の世界でできた2乗の数を $X^2$
文字式の世界でできた2乗の式を $Y(x)^2$ とします。

最後に、文字式の $Y(x)$ の $x$ に $m$ を代入し、現実の世界にワープさせて合流させます。すると、数学の魔法のように 「$X^2$ と $Y^2$ の余りが同じになる」 という状態が厳密に完成するのです！

あとは第1章の通り、$X - Y$ と $N$ の最大公約数を計算すれば、難攻不落のRSA暗号は音を立てて崩れ去り、秘密の素数が姿を現します。

おわりに：数学は終わらない

「よし、GNFSを使えばどんな暗号も破れるんだな！」と思ったかもしれません。しかし、RSA暗号も負けていません。現在のインターネットで使われているのは「RSA-2048（約617桁）」というバケモノのような巨大数です。

GNFSがいかに人類最強のアルゴリズムとはいえ、270桁（RSA-270）を解くのにすら、世界中のコンピュータを繋いでも数千年、数万年かかると言われています。今のところ、私たちのLINEや銀行のデータは安全です。

しかし、もし 「どんな巨大な数でも一瞬で $X$ と $Y$ を見つける魔法」 が現れたらどうなるでしょうか？実は、それに最も近い存在が現在開発中の 「量子コンピュータ（ショアのアルゴリズム）」 です。量子力学の波の性質を使えば、面倒なカード集めパズルを無視して、一発で答えを引き当てることができると数学的に証明されています。

暗号を作る人（防御）と、暗号を破るアルゴリズムを作る人（攻撃）の果てしない知恵比べ。中学校で習う「素因数分解」や「文字式」が、実は世界のセキュリティの最前線でバチバチに戦っている武器だと知ると、少しだけ数学の授業が面白く見えてきませんか？

未来の最強アルゴリズムを発見するのは、この記事を読んでいるあなたかもしれません！

(※本記事は、暗号解読の数学的魅力を中学生向けに概念化したものです。実際のGNFSは、代数体のイデアル類群や準同型写像などの高度な大学数学を用いて厳密に計算されています)