GNFS on kenji.blog

【Komplette Anatomie】Den stärksten Kryptographie-Knack-Algorithmus „GNFS“ in C++ implementieren und verstehen

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

【Komplette Anatomie】Den stärksten Kryptographie-Knack-Algorithmus „GNFS“ in C++ implementieren und verstehen

Die “RSA-Verschlüsselung”, die das heutige Internet grundlegend stützt. Ihre Robustheit beruht auf der mathematischen Überzeugung, dass “es für heutige Computer praktisch unmöglich ist, gigantische zusammengesetzte Zahlen in Primfaktoren zu zerlegen”.

Aber die Menschheit hat nie aufgegeben. Gegenwärtig gibt es für klassische Computer (normale Computer, keine Quantencomputer) den ** stärksten und fortschrittlichsten Algorithmus der Menschheit ** zur Durchführung riesiger Primfaktorzerlegungen. Das ist das ** “General Number Field Sieve (GNFS, Allgemeines Zahlkörpersieb)” **.

In diesem Artikel werden wir den gesamten Quellcode einer streng modellierten Implementierung der hochmodernen Berechnungslogik von GNFS in C++ (unter Verwendung von boost::multiprecision für Multipräzisions-Ganzzahlen aus der Boost-Bibliothek) veröffentlichen und die Tiefen der “algebraischen Zahlentheorie”, die dahinter steckt, gründlich erklären.

Bitte genießen Sie das Mysterium der Mathematik und die rohe Kraft der Informatik, die es bezwingt, zusammen mit dem Quellcode.

1. GNFS State-of-the-Art Logik-Framework (Gesamter Quellcode)

Zunächst zeigen wir das vollständige Bild der GNFS-C++-Implementierung, die wir diesmal erläutern. Das eigentliche Zahlkörpersieb (wie CADO-NFS) ist ein riesiges verteiltes System, das in die Hunderttausende von Zeilen geht, aber dieser Code extrahiert die ** “5 wesentlichen Pipelines (Phasen)” ** , die GNFS ausmachen, entwirft sie als Klassen und modelliert sie in einer Minimalkonfiguration, ohne die mathematische Bedeutung zu verlieren.

 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>

// Multipräzisions-Ganzzahlen von Boost.Multiprecision verwenden
using namespace boost::multiprecision;

// ============================================================================
// [SOTA GNFS] General Number Field Sieve (Allgemeines Zahlkörpersieb) State-of-the-Art Logik-Framework
//
// Dieser Code ist eine strikte Modellierung der 5 Pipelines des hochmodernen GNFS,
// wie es in CADO-NFS usw. verwendet wird, als C++ (Boost) Klassendesign.
// ============================================================================

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 Algorithmus)
// ============================================================================
class PolynomialSelector {
public:
 int degree;
 std::vector<cpp_int> f; // Polynom der algebraischen Seite f(x)
 std::vector<cpp_int> g; // Polynom der rationalen Seite g(x) = x - m
 cpp_int m;

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

 // Generierung des Initialpolynoms basierend auf der base-m Entwicklung (tatsächlich wird eine fortgeschrittenere Gitterbasisreduktion LLL verwendet)
 void select(const cpp_int& N) {
 std::cout << "[Phase 1] Polynomial Selection (Degree " << degree << ") starting..." << std::endl;
 // Einfache base-m Entwicklung (Grad d)
 // m = N^(1/d)
 cpp_int N_copy = N;
 m = 1;
 // Einfache Näherung für m (Näherung ohne Verwendung von Boost-Funktionen)
 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 (Gittersieb)
// ============================================================================
// Aktuelle GNFS verwenden anstelle des Line Sieve (Liniensieb) das Special-q Lattice Sieving
// (Spezielles q-Gittersieb) von Franke, Kleinjung et al. als De-facto-Standard.
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;
 // (Ausgelassen) In Wirklichkeit werden Primzahlen generiert und mit Legendre-Symbolen etc. gefiltert
 }

 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 std::cout << "[Phase 2] Special-q Lattice Sieving active..." << std::endl;
 std::vector<Relation> relations;
 // Mock-Implementierung: Das tatsächliche Gittersieb scannt blockweise Hunderte von GB an Speicherraum,
 // ordnet (a, b) Paare Gittern pro spezieller Primzahl q (a = i*q + j*...) zu
 // und führt ein Sieben mit maximaler Cache-Effizienz aus.

 // Füge zu Demonstrationszwecken eine Dummy-Relation hinzu
 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 (Singularitäten bereinigen und Cliquen zusammenführen)
// ============================================================================
class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 std::cout << "[Phase 3] Filtering Relations..." << std::endl;
 // 1. Singleton removal (Löschen von Relationen mit Primzahlen, die nur einmal vorkommen)
 // 2. Clique merging (Zusammenführen von Relationen, um spärliche Matrizen dicht zu machen)
 // In der Praxis werden hunderte Millionen von Zeilen mit Union-Find-Algorithmen usw. auf einige Millionen komprimiert.
 std::cout << "[Phase 3] Matrix size reduced optimally." << std::endl;
 }
};

// ============================================================================
// Phase 4: Linear Algebra over GF(2) (Block Wiedemann Methode)
// ============================================================================
class LinearAlgebraGF2 {
public:
 // In neueren Supercomputer-Umgebungen wird die für verteiltes Rechnen besser geeignete
 // Block Wiedemann Methode (Coppersmith-Implementierung) anstelle der Block Lanczos Methode als State-of-the-Art eingesetzt.
 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;
 // Iteriert das Produkt von spärlichen Matrizen (Sparse Matrix) und Vektoren,
 // und findet mehrere Lösungsvektoren (Kerne), für die M * x = 0 mod 2 gilt.

 std::vector<std::vector<int>> dependencies; // Liste der Abhängigkeiten
 // Dummy-Daten
 dependencies.push_back({0});

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

// ============================================================================
// Phase 5: Algebraic Square Root (Algebraische Quadratwurzel)
// ============================================================================
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. Berechnung der Quadratwurzel V der rationalen Seite (einfache Ganzzahlarithmetik)
 cpp_int V = 1;
 // V = sqrt( prod(a - bm) ) mod N

 // 2. Berechnung der Quadratwurzel gamma der algebraischen Seite (Montgomery's Methode etc.)
 // Findet das Element gamma des riesigen algebraischen Körpers O_K und bildet es mit dem Homomorphismus phi auf die reale Welt ab
 // Y = phi(gamma) mod N
 cpp_int Y = 1;

 // Es wird vorausgesetzt, dass in Phase 2 und 4 Folgen von quadratischen Resten (Quadratic Characters) hinzugefügt wurden,
 // um die Hindernisse (Obstructions) der Idealklassengruppe und der Einheitengruppe zu umgehen.

 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;

 // Die gigantische zusammengesetzte Zahl N, die wir in Primfaktoren zerlegen wollen, z. B. RSA-270
 cpp_int N("233108530344407544527637656910680524145619812480305449042948611968495918245135782867888369318577116418213919268572658314913060672626911354027609793166341626693946596196427744273886601876896313468704059066746903123910748277606548649151920812699309766587514735456594993207");

 // Der Grad des Polynoms (bei mehr als 130 Stellen wird normalerweise Grad 5 bis 6 gewählt)
 int degree = 6;

 // Initialisierung der Pipeline
 PolynomialSelector poly_select(degree);
 LatticeSieve sieve(10000000, 20000000); // Tatsächliche Schranken (Bounds) liegen bei Dutzenden bis Hunderten von Millionen
 Filter filter;
 LinearAlgebraGF2 linalg;
 AlgebraicSquareRoot sqrt_step;

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

 // 1. Polynom-Selektion
 poly_select.select(N);

 // 2. Sieb-Verarbeitung (Sieving)
 sieve.generate_factor_bases();
 std::vector<Relation> relations = sieve.sieve(poly_select);

 // 3. Filterung (Matrixkompression)
 filter.reduce_matrix(relations);

 // 4. Lineare Algebra (Nullraum-Suche über GF(2))
 std::vector<std::vector<int>> dependencies = linalg.solve_nullspace(relations);

 // 5. Berechnung der algebraischen Quadratwurzel und 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;
}

Nun, wie durchbricht dieser Code die kryptographischen Mauern? Wir werden für jede der 5 Phasen die detaillierten Algorithmen und die fortgeschrittene Mathematik verdaulich erklären.

2. Das ultimative Ziel von GNFS: $X^2 \equiv Y^2 \pmod N$

Das Ziel von GNFS, wie auch den meisten modernen Algorithmen zur gigantischen Primfaktorzerlegung, ist es, ein nicht-triviales Paar $(X, Y)$ zu finden, das die folgende Kongruenz erfüllt:

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

Diese Gleichung bedeutet, dass “die Reste von $X^2$ und $Y^2$, wenn man sie durch $N$ teilt, gleich sind”. Umgeformt ergibt das: $X^2 - Y^2 \equiv 0 \pmod N$ Das heißt, $(X-Y)(X+Y)$ ist ein Vielfaches von $N$.

Wenn $X \not\equiv \pm Y \pmod N$ (eine nicht-triviale Lösung) gilt, gibt es zwischen $(X-Y)$ und $N$ einen “gemeinsamen Teiler größer als 1 und kleiner als $N$”. Wenn wir hier den Euklidischen Algorithmus anwenden, um ** $\gcd(X-Y, N)$ ** zu berechnen, finden wir die Primfaktoren von $N$ sehr leicht.

Jedoch ist die Suche nach diesen $X$ und $Y$ wie die Suche nach der Nadel im Heuhaufen. Daher wählt GNFS den genialen Ansatz, ** “zwei Welten” ** zu erschaffen – die “Welt der realen ganzen Zahlen” und die “Welt der algebraischen Zahlkörper von Polynomen” – und die Berechnungen aufzuteilen.

3. Phase 1: Polynom-Selektion (Polynomial Selection)

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


class PolynomialSelector {
 // ...
 void select(const cpp_int& N) {
 // Berechnung von m = N^(1/d) und base-m Entwicklung
 // ...
 for (int i = 0; i <= degree; ++i) {
 f[i] = temp % m;
 temp /= m;
 }
 g = {-m, 1}; // g(x) = x - m
 }
};

Der erste Schritt von GNFS ist die Schaffung eines “magischen Polynoms”, um die beiden Welten zu überbrücken. Für eine riesige Zahl $N$ wählen wir eine ganze Zahl $m$. Normalerweise wählt man $m \approx N^{1/d}$ (im Code wird ein Polynom $d=6$. Grades angenommen).

Dann entwickeln wir $N$ im $m$-adischen System (Basis $m$) und verwenden die Koeffizienten, um das Polynom $f(x)$ zu konstruieren.

$$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$$

Dieses Polynom $f(x)$ hat eine äußerst wichtige Eigenschaft: ** “Wenn man $m$ für die Variable $x$ einsetzt, ergibt es genau $N$ ($f(m) = N$)” **. Mit anderen Worten, $f(m) \equiv 0 \pmod N$. Das Polynom der rationalen Seite ist definiert als $g(x) = x - m$.

Dadurch werden die ** “Welt des algebraischen Zahlkörpers $\mathbb{Z}[\alpha]$” **, die durch die Wurzel $\alpha$ von $f(x)=0$ beherrscht wird, und die gewöhnliche ** “Welt der rationalen Zahlen (ganzen Zahlen) $\mathbb{Z}$” ** durch einen Ringhomomorphismus $x \to m$ fest miteinander verbunden.

In hochmodernen Implementierungen wie CADO-NFS werden Algorithmen wie der KleinJung-Algorithmus oder die LLL-Gitterbasisreduktion verwendet, um monatelang nach dem “absolut besten Polynom $f(x)$” zu suchen, bei dem die Koeffizienten nicht extrem groß werden und in nachfolgenden Schritten leicht Primzahlen auftreten (Smoothness/Glattigkeit begünstigt wird).

4. Phase 2: Spezielles $q$-Gittersieb (Special-q Lattice Sieving)

1
2
3
4
5
6
7
8
9


class LatticeSieve {
 // ...
 std::vector<Relation> sieve(const PolynomialSelector& poly) {
 // ...
 // Ordnet (a, b) Paare Gittern pro spezieller Primzahl q zu
 // und führt ein Sieben mit maximaler Cache-Effizienz aus.
 // ...
 }
};

Nachdem die beiden Welten vorbereitet sind, betreten wir den nächsten Schritt: die Suche nach “glatten Zahlen” (Zahlen, die nur aus kleinen Primfaktoren bestehen) in beiden Welten. Wir generieren unzählige ganzzahlige Paare $(a, b)$ und berechnen die folgenden zwei Werte:

** Wert auf der rationalen Seite ** : $a - bm$
** Norm auf der algebraischen Seite ** : $b^d f(a/b)$

Das Ziel von GNFS ist es, zig bis hunderte Millionen ** “Paare (Relationen), bei denen die Werte sowohl der rationalen als auch der algebraischen Seite vollständig in kleine Primfaktoren zerlegt werden können” **, zu sammeln.

In frühen GNFS-Versionen wurde das “Liniensieb (Line Sieve)” verwendet, bei dem die $(a, b)$ auf der $xy$-Ebene aufgereiht und der Reihe nach durch Primzahlen geteilt wurden. Da dies jedoch auf den Speicher überall verstreut zugriff, traten häufig Cache-Misses auf, was es sehr langsam machte.

Deshalb verwenden moderne High-End-Codes die Methode des ** “Speziellen $q$-Gittersiebs (Special-q Lattice Sieve)” **. Man fixiert eine relativ große Primzahl $q$ und berücksichtigt nur Paare $(a, b)$, für die “der algebraische Wert definitiv durch $q$ teilbar ist”. Da die Paare $(a, b)$, die diese Bedingung erfüllen, ein “Gitter (Lattice)” auf der Ebene bilden, ist die Sprungweite der Speicheradressen bei der Berechnung konstant, was perfekt in die L1/L2-Caches der CPUs passt. Die Einführung dieses Gittersiebs hat die Rechengeschwindigkeit von GNFS dramatisch erhöht.

5. Phase 3: Filterung (Filtering)

1
2
3
4
5
6
7


class Filter {
public:
 void reduce_matrix(std::vector<Relation>& relations) {
 // 1. Singleton removal (Löschen von Relationen mit Primzahlen, die nur einmal vorkommen)
 // 2. Clique merging (Zusammenführen von Relationen, um spärliche Matrizen dicht zu machen)
 }
};

Computer weltweit haben in Phase 2 über Monate hinweg Hunderte Millionen von Relationen gesammelt. Wenn wir diese jedoch direkt in den nächsten “Schritt zum Lösen von Gleichungssystemen (Matrixberechnung)” werfen, würde selbst der Speicher eines Supercomputers überlaufen.

Daher wird ein extrem starker Matrixkompressionsprozess namens ** Filtering (Filterung) ** durchgeführt.

** Singleton removal (Singularitäten bereinigen) ** Angenommen, eine riesige Primzahl $p$ tritt in Hunderten Millionen Relationen “nur ein einziges Mal” auf. Da es unser Ziel ist, “die Exponenten aller Primzahlen gerade (ein Vielfaches von 2) zu machen”, kann eine Primzahl, die nur einmal auftritt, niemals einen geraden Exponenten erreichen. Daher werden Relationen, die diese Primzahl enthalten, sofort als “nutzloser Müll” gelöscht (bereinigt). Da dies kettenreaktionsartig passiert, werden die Hunderte Millionen Datenzeilen rasant reduziert.
** Clique merging (Cliquen zusammenführen) ** Darüber hinaus werden durch die Kombination (Addition) von Relationen, die bestimmte Primzahlen teilen, die Anzahl der Zeilen reduziert und die spärliche (luftige) Matrix dichter gemacht (es wird ein Ansatz ähnlich der Cliquensuche in der Graphentheorie verwendet).

Durch diese Optimierung wird die gigantische dünnbesetzte Matrix auf eine rechenbare Größe dramatisch komprimiert.

6. Phase 4: Lineare Algebra über GF(2) (Block Wiedemann Methode)

1
2
3
4
5
6
7


class LinearAlgebraGF2 {
public:
 std::vector<std::vector<int>> solve_nullspace(const std::vector<Relation>& relations) {
 // Iteriert das Produkt von spärlichen Matrizen (Sparse Matrix) und Vektoren,
 // und findet mehrere Lösungsvektoren (Kerne), für die M * x = 0 mod 2 gilt.
 }
};

Endlich der Kern des Puzzles. Wir multiplizieren die gesammelten Relationen miteinander, um nach einer ** “Kombination zu suchen, bei der die Exponenten aller Primfaktoren gerade Zahlen werden” **.

Mathematisch gesehen geht es darum, eine riesige Matrix $M$, deren Elemente die Exponenten der Primzahlen (“gerade oder ungerade”, also 0 oder 1) sind, und einen Vektor $x$, der angibt, welche Relationen verwendet werden, zu verwenden, um Lösungsvektoren $x$ (Nullraum / Kern) zu finden, für die gilt: ** $M \cdot x \equiv 0 \pmod 2$ **

Wir müssen ein Gleichungssystem mit einer Matrix von enormer Größe, Millionen von Zeilen × Millionen von Spalten, lösen. Mit der üblichen Gaußschen Elimination wäre die Komplexität $O(N^3)$ und die Berechnung würde nicht enden, bevor das Universum sein Ende findet.

Daher wird in hochmodernen Implementierungen die ** “Block Wiedemann Methode” ** verwendet. Dies ist eine Art Krylov-Unterraum-Methode, die die Tatsache nutzt, dass die Matrix $M$ “sehr spärlich (meistens 0)” ist, und durch wiederholte Multiplikationen von Matrix und Vektoren eine Lösung ableitet. Im Gegensatz zur älteren Block-Lanczos-Methode kann die Block-Wiedemann-Methode den Berechnungsprozess vollständig auf mehrere Cluster aufteilen, wodurch sie bei parallelen Berechnungen im modernen verteilten Cloud-Computing oder auf Supercomputern eine überwältigende Leistung erbringt.

7. Phase 5: Algebraische Quadratwurzel (Algebraic Square Root) und der Zusammenbruch der Kryptographie

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


class AlgebraicSquareRoot {
public:
 void compute_and_factor(...) {
 // 1. Berechnung der Quadratwurzel V der rationalen Seite
 cpp_int V = 1;

 // 2. Berechnung der Quadratwurzel gamma der algebraischen Seite
 cpp_int Y = 1;

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

Durch die Matrixberechnung in Phase 4 haben wir “eine Menge von Relationen $S$, die, miteinander multipliziert, für alle Primfaktoren gerade Exponenten ergeben”, erhalten. Damit können wir in beiden Welten, der rationalen und der algebraischen, ein “Quadrat” konstruieren.

Auf der rationalen Seite ist es nur eine Multiplikation von ganzen Zahlen, daher ist die Berechnung der Quadratwurzel $V$ einfach.

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

** Aber die wahre Hölle liegt auf der “algebraischen Seite”. ** In der Welt des algebraischen Zahlkörpers $\mathbb{Z}[\alpha]$ gilt die Eindeutigkeit der Primfaktorzerlegung nicht, weshalb wir Ideale für die Berechnung verwendet haben. Die Matrixberechnung hat nur garantiert, dass es ** “das Quadrat eines Ideals” ** wird, aber ** nicht, dass es “das Quadrat eines Elements ($\gamma^2$)” wird **.

Hier stellen sich uns immense Hürden aus der algebraischen Zahlentheorie in den Weg: das “Hindernis der Idealklassengruppe” und das “Hindernis der Einheitengruppe”. Um diese Hürden zu überwinden, nutzt GNFS die Magie der ** “Quadratischen Reste (Quadratic Characters)” **. Man fügt der Matrix aus Phase 4 vorab heimlich Spalten mit quadratischen Resten (Legendre-Symbolen) für einige Dutzend spezielle Primideale hinzu. Dadurch überspringt die gefundene Menge $S$ mit überwältigender Wahrscheinlichkeit die Hindernisse und bildet erfolgreich das “Quadrat eines echten Elements $\gamma^2$”.

Der Prozess zur Ermittlung von $\gamma$ (die algebraische Quadratwurzel) verwendet hochkomplexe Algorithmen wie die Montgomery-Methode.

Und schließlich wird die algebraische Quadratwurzel $\gamma$ durch den Ringhomomorphismus $\phi$ in die reale Welt teleportiert ($m$ für $x$ einsetzen), um $Y$ zu erhalten. Wenn wir das rationale $V$ einfach $X$ nennen, ist die ultimative Gleichung endlich komplett.

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

Jetzt müssen wir nur noch $\gcd(X-Y, N)$ berechnen. Sobald dieser 0,001-Sekunden-Prozess durchläuft und die nicht-trivialen Faktoren auf dem Bildschirm gedruckt werden, bricht die so unbezwingbar scheinende RSA-Verschlüsselung vollständig zusammen.

Fazit

GNFS ist nicht nur eine Programmiertechnik. Es ist die Kristallisation der menschlichen Intelligenz, die den “Abgrund der reinen Mathematik” wie abstrakte Algebra, Ringtheorie und Idealklassengruppen mit der “extremen Ingenieurskunst” wie der verteilten Architektur von Supercomputern und der Cache-Optimierung bezwungen hat.

Die Chats oder Kreditkarteninformationen, die wir jeden Tag beiläufig senden, werden durch einen solchen astronomischen mathematischen Schlagabtausch geschützt.

Ich hoffe, Sie konnten durch dieses C++-Framework die “Romantik von Mathematik und Computern”, die hinter modernsten kryptoanalytischen Algorithmen steckt, spüren.

Die wahre mathematische Struktur des allgemeinen Zahlkörpersiebs (GNFS)

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

Die wahre mathematische Struktur des allgemeinen Zahlkörpersiebs (GNFS)

Das ultimative Ziel des GNFS ist es, $X, Y$ so zu finden, dass $X^2 \equiv Y^2 \pmod N$ gilt. Um dies zu erreichen, bauten Mathematiker eine Brücke zwischen der “Welt der reellen ganzen Zahlen” und der “Welt der algebraischen Zahlkörper” . Diese Brücke ist der sogenannte “Homomorphismus”.

Phase 1: Die Welten mit “Homomorphismus” verbinden

1. Auswahl des Polynoms und Definition der Wurzeln

Für eine riesige zusammengesetzte Zahl $N$ wählen wir eine ganze Zahl $m$ und ein Polynom $f(x)$ so, dass $f(m) \equiv 0 \pmod N$ gilt. (Beispiel: Wir entwickeln $N$ zur Basis $m$ und bilden $f(x)$ aus den Koeffizienten. Dabei nehmen wir an, dass $f(x)$ über dem Körper der rationalen Zahlen $\mathbb{Q}$ irreduzibel ist (nicht weiter faktorisiert werden kann)).

Als Nächstes definieren wir eine der “komplexen Wurzeln” der Gleichung $f(x) = 0$ als $\alpha$. Natürlich ist $f(\alpha) = 0$. $\alpha$ ist keine ganze Zahl, sondern eine komplexe Zahl, die Wurzeln und imaginäre Zahlen enthält (eine algebraische Zahl).

2. Konstruktion von Ringen und Homomorphismus

Hier bereiten wir zwei mathematische “Ringe” vor (Welten, in denen Addition und Multiplikation definiert sind).

Welt A: $\mathbb{Z}[\alpha]$ (Der Ring der algebraischen ganzen Zahlen, der $\alpha$ enthält) Eine Zahlenwelt in der Form $a + b\alpha + c\alpha^2 + \dots$.
Welt B: $\mathbb{Z}/N\mathbb{Z}$ (Der Ring der Reste modulo $N$) Eine Kongruenzwelt (Modulo), die nur aus den ganzen Zahlen von $0$ bis $N-1$ besteht.

Hier definieren wir eine Abbildung $\phi$ von Welt A nach Welt B wie folgt: $$\phi : \mathbb{Z}[\alpha] \to \mathbb{Z}/N\mathbb{Z}$$ $$\phi(\alpha) = m \pmod N$$

Diese Abbildung $\phi$ ist eine magische Operation, die exakt die Variable $\alpha$ in Welt A durch die ganze Zahl $m$ in Welt B ersetzt. Dieses $\phi$ besitzt eine extrem mächtige Eigenschaft, die “Ringhomomorphismus” genannt wird. Homomorphismus ist die Eigenschaft, “in eine andere Welt zu teleportieren, ohne die Struktur von Addition und Multiplikation zu zerstören” . Das heißt, die folgenden Gleichungen sind gültig:

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

Was bedeutet das? Wenn wir das “Quadrat ($\gamma^2$)” eines komplexen Elements $\gamma$ in “Welt A (der Welt von $\alpha$)” erzeugen und es mithilfe von $\phi$ nach “Welt B (der Restewelt)” teleportieren können, bleibt die quadratische Form $\phi(\gamma)^2$ perfekt erhalten .

Phase 2: Der Zusammenbruch der Primfaktorzerlegung und die Geburt der “Ideale”

In Welt A ($\mathbb{Z}[\alpha]$) wollen wir viele geeignete Elemente $(a - b\alpha)$ sammeln und sie multiplizieren, um ein “perfektes Quadrat (Quadratelement)” zu erzeugen. Normalerweise würden wir jedes gesammelte $(a - b\alpha)$ in Primfaktoren zerlegen und sie so kombinieren, dass die Exponenten der Primzahlen alle gerade sind (durch Lösen mit Matrizen), um ein Quadrat zu bilden.

Jedoch stellt sich hier die verzweifelte Mauer der Algebra in den Weg. In algebraischen Welten wie $\mathbb{Z}[\alpha]$ bricht die “Eindeutigkeit der Primfaktorzerlegung (jede Zahl kann eindeutig als Produkt von Primzahlen ausgedrückt werden)”, die in der Schule gelehrt wird, zusammen .

(Beispiel: In einer bestimmten algebraischen Welt ist $6 = 2 \times 3$, aber gleichzeitig auch $6 = (1+\sqrt{-5}) \times (1-\sqrt{-5})$, und wir wissen nicht mehr, welche die wahren Primzahlen sind)

Wenn die Faktorzerlegung nicht eindeutig ist, ist das Rätsel “Primzahlen zählen, um sie gerade zu machen” (die Siebmethode) im Prinzip unmöglich auszuführen.

Die Rettung durch Kummer und Dedekind: “Ideale”

Was diesen Zusammenbruch rettete, war das Konzept des “Ideals (Ideal: ideale Zahl)” , das von Mathematikern des 19. Jahrhunderts geschaffen wurde. Indem man nicht an das Element selbst dachte, sondern an die “Menge der Vielfachen (Ideal)”, die von diesem Element erzeugt wird, wurde die Primfaktorzerlegung wieder möglich.

Im Ganzheitsring eines algebraischen Zahlkörpers $\mathcal{O}_K$ (ein vollständigerer Ring, der $\mathbb{Z}[\alpha]$ enthält) ist bewiesen, dass selbst wenn ein Element nicht eindeutig faktorisiert werden kann, “ein Ideal immer eindeutig als Produkt von ‘Primidealen ($\mathfrak{p}$)’ faktorisiert werden kann” .

Daher faktorisieren wir im GNFS nicht das Element $(a - b\alpha)$ selbst, sondern das von ihm erzeugte Hauptideal $\langle a - b\alpha \rangle$ in Primideale .

Phase 3: Die Norm und die zwei Siebe

Woher wissen wir also, in welche Primideale das Ideal $\langle a - b\alpha \rangle$ zerfällt? Hier verwenden wir eine Funktion namens “Norm” . Die Norm ist eine Funktion, die komplexe Elemente algebraischer Körper in “normale reelle ganze Zahlen $\mathbb{Z}$” umwandelt.

Die Norm des Elements $(a - b\alpha)$ wird durch eine einfache Polynomrechnung $b^d f(a/b)$ gefunden ($d$ ist der Grad von $f(x)$).

Durch einen algebraischen Satz wissen wir: “Wenn die Norm eines bestimmten Ideals vollständig in kleine Primzahlen zerlegt werden kann (glatt ist), dann kann das ursprüngliche Ideal auch vollständig in kleine Primideale zerlegt werden” .

Daher berechnet GNFS für eine große Anzahl von Ganzzahlpaaren $(a, b)$ gleichzeitig die folgenden zwei Werte und sammelt nur die Paare, bei denen beide zu “glatten Zahlen (smooth numbers)” werden:

Rationales Sieb (Rational Sieve) : $a - bm$ (der Wert in der realen Welt)
Algebraisches Sieb (Algebraic Sieve) : $b^d f(a/b)$ (die Norm in der algebraischen Welt)

Indem wir zig Millionen Paare $(a, b)$ sammeln, bei denen beide glatt sind, lösen wir die Daten der Primidealzerlegung (wie viele Primideale enthalten sind) als riesige Matrix (lineare Algebra über GF(2)), um eine Menge $S$ von Paaren zu finden, sodass “beim Multiplizieren die Exponenten aller Primideale gerade werden”.

Phase 4: Die zwei “Hindernisse” und die Idealklassengruppe

Aus der Matrixberechnung haben wir herausgefunden, dass das Multiplizieren aller Ideale von $(a - b\alpha)$, die zur Menge $S$ gehören, zum Quadrat eines bestimmten Ideals $I$ führt.

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

Es ist jedoch noch nicht vorbei. Die tiefste und schwierigste mathematische Mauer des GNFS befindet sich hier.

Was wir am Ende wollen, ist nicht das “Quadrat eines Ideals”, sondern das “Quadrat eines Elements ($\gamma^2$)” , das wir in die Abbildung $\phi$ einsetzen können. Nur weil es zum Quadrat eines Ideals wurde, heißt das nicht zwangsläufig, dass das Element selbst ein Quadrat ist. Hier gibt es zwei starke mathematische Hindernisse (Obstructions) .

Hindernis ①: Die Barriere der Idealklassengruppe (Ideal Class Group)

Das Ideal $I$ ist nicht immer ein “Ideal, das von einem einzigen Element erzeugt wird (Hauptideal)”. Es ist unmöglich, ein spezifisches Element $\gamma$ aus einem Ideal zu extrahieren, das kein Hauptideal ist.

Hier kommt das Konzept der “Idealklassengruppe (Class Group, $Cl_K$)” ins Spiel. Die Idealklassengruppe ist eine Gruppe, die misst, “wie viele Ideale in dieser algebraischen Welt existieren, die keine Hauptideale sind (wie sehr die Eindeutigkeit der Primfaktorzerlegung gebrochen ist)”. Selbst wenn $\prod \langle a - b\alpha \rangle$ zu $I^2$ wird, kann es nicht auf das Quadrat eines Elements zurückgeführt werden, wenn $I$ nicht das Identitätselement (Hauptideal) in der Idealklassengruppe ist.

Hindernis ②: Die Barriere der Einheitengruppe (Unit Group)

Angenommen, durch Glück wäre $I$ das Hauptideal $\langle \gamma \rangle$. Dann hätten wir $\prod \langle a - b\alpha \rangle = \langle \gamma^2 \rangle$. Man könnte denken: “Großartig, das Element ist auch ein Quadrat!”, aber das ist ein großer Irrtum.

Dass Ideale (Mengen von Vielfachen) gleich sind, bedeutet nicht, dass die Elemente perfekt gleich sind. Es wird immer eine Abweichung durch eine “Einheit (Unit: eine Zahl, deren Kehrwert ebenfalls eine ganze Zahl ist. Wie 1 oder -1)” geben. Mit anderen Worten, die eigentliche Elementgleichung sieht so aus:

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

($u$ ist ein Element der Einheitengruppe $U_K$)

Wenn diese Einheit $u$ nicht selbst das Quadrat von etwas ist, kann die linke Seite niemals ein “perfektes Quadrat eines Elements” werden.

Phase 5: Adlemans Magie “Quadratische Charaktere” (Quadratic Characters)

Das Hindernis der Idealklassengruppe und das Hindernis der Einheitengruppe. Wie können wir diese beiden überwinden? Hier kommt die brillante Methode der “Quadratischen Charaktere (Quadratic Characters)” ins Spiel, die von dem Kryptographen Leonard Adleman (das “A” von RSA) und anderen eingeführt wurde.

Um festzustellen, “ob ein bestimmtes Element ein perfektes Quadrat im algebraischen Körper ist”, verwenden wir die Zahlkörper-Version des Legendre-Symbols (quadratischer Rest). In dieser riesigen Matrix (dem Rätsel, um die Primidealzählungen gerade zu machen), fügen wir heimlich ein paar Dutzend zusätzliche Bedingungen (Spalten) hinzu, die besagen: “Die quadratischen Charaktere für einige spezielle Primideale $\mathfrak{q}$ müssen ebenfalls alle $1$ (gerade) sein” .

Wenn wir eine Menge $S$ finden, die durch die Matrixberechnung sogar diese zusätzliche Bedingungen erfüllt, garantieren tiefe Sätze aus der algebraischen Zahlentheorie, dass “sowohl das Hindernis der Idealklassengruppe als auch das Hindernis der Einheitengruppe mit überwältigender Wahrscheinlichkeit natürlich verschwinden werden” .

Damit erhalten wir endlich die wahre Gleichung.

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

Letzte Phase: Die Verschmelzung der Welten und der Zusammenbruch der Kryptographie

Endlich sind alle Puzzleteile an ihrem Platz.

[Elemente in der Welt der algebraischen Körper (Welt A)] $\gamma^2 = \prod (a - b\alpha)$ (Wir verwenden einen Quadratwurzel-Algorithmus, um $\gamma$ zu finden)

[Elemente in der realen Welt (Welt der rationalen Zahlen)] $V^2 = \prod (a - bm)$ (Da dies eine einfache Ganzzahlmultiplikation ist, $V$ normal gefunden werden kann)

Nun ist es Zeit für die magische Brücke, die wir zu Beginn gebaut haben, den Homomorphismus $\phi$ . Wir teleportieren das Element $\gamma$ aus Welt A nach Welt B (die Welt der Reste von $N$) mithilfe von $\phi$ (die Abbildung, bei der wir $\alpha$ durch $m$ ersetzen).

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

Andererseits bringen wir das in der realen Welt gebaute $V$ direkt in die Restewelt und nennen es $X$.

$$X = V \pmod N$$

Aufgrund der “strukturerhaltenden” Eigenschaft des Homomorphismus bleibt die quadratische Beziehung, die in Welt A galt, in Welt B (der Welt modulo $N$) perfekt erhalten. Da die ursprünglichen Paare $(a, b)$ außerdem in Entsprechung in den Formen $a - b\alpha$ und $a - bm$ erzeugt wurden, kollidieren diese $X$ und $Y$ in der Welt modulo $N$ und erzeugen die folgende absolute Gleichung:

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

Alles, was bleibt, ist zu beten, dass diese $X$ und $Y$ keine trivialen Lösungen ($X \equiv \pm Y$) sind, und $\gcd(X - Y, N)$ zu berechnen.

Wenn es sich um eine nicht-triviale Lösung handelt, durchläuft der Euklidische Algorithmus sie in 0,001 Sekunden, und die geheimen Primzahlen $p$ und $q$, die das Herzstück der RSA-Kryptographie bilden, werden auf dem Ausgabebildschirm gedruckt.

Dies ist das vollständige Bild des “Allgemeinen Zahlkörpersiebs (GNFS)” , der Essenz der modernen Mathematik.

Was ist das "General Number Field Sieve (GNFS)", die stärkste Mathematik der Menschheit, die die Internetverschlüsselung knackt?

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

Was ist das “General Number Field Sieve (GNFS)”, die stärkste Mathematik der Menschheit, die die Internetverschlüsselung knackt?

Das Internet, das wir jeden Tag nutzen. LINE-Nachrichten, YouTube, Einkaufen auf Amazon – die gesamte Kommunikation wird durch “Verschlüsselung” geschützt. Derzeit ist der weltweit am häufigsten verwendete Vertreter die “RSA-Verschlüsselung”.

Der Schlüssel zur Verteidigung der RSA-Verschlüsselung ist sehr einfach. Er nutzt die mathematische Eigenschaft, dass ** “die Primfaktorzerlegung gigantischer Zahlen selbst von Computern nicht gelöst werden kann” ** . Bei “15” wissen wir zum Beispiel sofort, dass es “3 × 5” ist, aber sobald es eine “270-stellige Zahl” wird, würde es Hunderte von Millionen Jahren dauern, selbst wenn man alle Supercomputer der Welt zusammennimmt, um sie zu lösen.

Doch die Mathematiker sind nicht stumm geblieben. Um diese undurchdringliche Verschlüsselung zu knacken, hat die Menschheit einen fast magischen Algorithmus (Berechnungsverfahren) namens ** “General Number Field Sieve (GNFS)” ** erschaffen.

In diesem Artikel werden wir ohne Fachjargon und nur mit dem Wissen der ** Mittelstufenmathematik (Primfaktorzerlegung, algebraische Ausdrücke, größter gemeinsamer Teiler) ** Schritt für Schritt erklären, wie dieser “stärkste Algorithmus der Menschheit” die Verschlüsselung knackt!

Kapitel 1: Das Ziel der Entschlüsselung ist eine “Formel der 9. Klasse”

Der größte Spezialtrick, um der gigantischen Primfaktorzerlegung zu begegnen. Es ist diese Formel, die man in der 9. Klasse lernt:

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

Sie denken vielleicht: “Ernsthaft, eine so grundlegende Formel kann Verschlüsselung knacken?”. Dies ist jedoch der Hauptschlüssel, der alles offenbart.

Das größte Ziel beim Knacken der Verschlüsselung ist es, für eine riesige Zahl $N$, ** “Zahlen ($X$ und $Y$) zu finden, bei denen der Rest bei der Division von $X^2$ und $Y^2$ durch $N$ derselbe ist” ** .

Warum knackt “derselbe Rest” die Verschlüsselung?

Angenommen, zwei Zahlen, $X^2$ und $Y^2$, haben “denselben Rest, wenn sie durch $N$ geteilt werden”. Denselben Rest zu haben bedeutet, dass es eine Regel nach der ** die Subtraktion “$X^2 - Y^2$” immer genau durch $N$ teilbar ist (ein Vielfaches von $N$ sein wird) ** .

Nehmen wir hier an, dass die gigantische Zahl $N$, die für die Verschlüsselung verwendet wird, aus der Multiplikation zweier geheimer Primzahlen ($p$ und $q$) besteht ($N = p \times q$).

Wenn wir $X^2 - Y^2$ faktorisieren, erhalten wir ** $(X - Y)(X + Y)$ ** . Die Tatsache, dass dies ein Vielfaches von $N$ ist, bedeutet, dass irgendwo in dieser Multiplikation die geheimen Primzahlen $p$ und $q$ verborgen sind.

Hier geschieht ein Wunder. Es besteht eine mathematische Wahrscheinlichkeit von ** 50% (der Hälfte) ** , dass die beiden Primzahlen $p$ und $q$ sich in verschiedene Räume trennen: ** “$p$ geht in den Raum von $(X - Y)$” und “$q$ geht in den Raum von $(X + Y)$” ** .

Wenn nur die Primzahl $p$ den Raum von $(X - Y)$ betreten hat, berechnen wir den ** “größten gemeinsamen Teiler (das größte gemeinsame Teil)” ** von $(X - Y)$ und $N$.

Inhalt von $(X - Y)$ = $p \times$ irgendeine Zahl
Inhalt von $N$ = $p \times q$ Das einzige gemeinsame Teil ist ** “$p$” ** !

Mit anderen Worten, in dem Moment, in dem der größte gemeinsame Teiler berechnet wird, wird die verborgene Primzahl $p$ enthüllt und die Verschlüsselung ist vollständig entschlüsselt. (*Der größte gemeinsame Teiler kann sogar auf einem Smartphone sofort mit dem “Euklidischen Algorithmus” berechnet werden).

** 【Kleine Kolumne: Warum das Quadrat? Funktionieren Kubik oder das Doppelte nicht?】 **

Bei “$2X - 2Y$” wird es zu $2(X - Y)$ und es gibt nur einen Raum, sodass Sie die Primzahlen nicht trennen können. Bei “$X^3 - Y^3$” wird die Größe der Räume unausgewogen und die Berechnung wird unnötig schwer. Um die Primzahlen in zwei zu trennen, ist das “Quadrat”, das sich wunderbar in zwei Räume aufteilt, am kostengünstigsten.

Kapitel 2: Wie findet man X und Y? “Das Primzahlkarten-Sammelpuzzle”

Das Ziel ist klar. Doch selbst wenn wir blind nach “$X^2$ und $Y^2$ mit demselben Rest” suchen würden, würde das Ende des Universums eintreten, bevor wir sie finden. Also ließen sich Mathematiker eine geniale Methode namens ** “Primzahlkarten-Sammelpuzzle” ** einfallen.

Schritt 1: Nur Goldstaub (glatte Zahlen) mit einem Sieb sammeln

Bereiten Sie zunächst eine geeignete Zahl $Z$ vor, quadrieren Sie sie und berechnen Sie den Rest $W$, wenn sie durch $N$ geteilt wird. (Die Restwelt von $Z^2 = W$)

Faktorisieren Sie den erhaltenen Rest $W$ in Primzahlen. Hier gilt: Nur wenn ** “ein $W$, das nur aus kleinen Primzahlen wie 2, 3, 5, 7 usw. besteht” ** , erscheint, behalten Sie diese Gleichung als “Gewinnerkarte” und werfen Sie sie weg, wenn große Primzahlen beigemischt sind. Es ist wie das Wegwerfen großer Steine mit einem Sieb in einem Fluss, um nur Goldstaub zu sammeln.

Schritt 2: Das Puzzle, um alles “gerade” zu machen

Nehmen wir zum Beispiel an, die folgenden 3 Goldstaubkarten wurden gesammelt.

Karte A: $Z_1^2 = 2^3 \times 3^1$
Karte B: $Z_2^2 = 2^1 \times 5^1$
Karte C: $Z_3^2 = 3^1 \times 5^1$

Lassen Sie uns alle multiplizieren. Die rechte Seite wird zu $(2^3 \times 3^1) \times (2^1 \times 5^1) \times (3^1 \times 5^1)$, Und wenn man alles ordnet, wird es zu ** “$2^4 \times 3^2 \times 5^2$” ** .

Überraschenderweise wurde die Anzahl der Primzahlen zu “4, 2, 2”, ** allesamt eine gerade Zahl ** ! Dass alle gerade sind, bedeutet, dass wenn man die Gesamtmenge halbiert, es “das Quadrat von etwas” sein wird. Mit anderen Worten, $(2^2 \times 3^1 \times 5^1)^2 = (60)^2$.

Die linke Seite ist $(Z_1 \times Z_2 \times Z_3)^2$, also sind wir endlich am Ziel: ** $X = (Z_1 \times Z_2 \times Z_3)$ ** ** $Y = 60$ ** Das lang ersehnte Paar von “$X^2 = Y^2$” ist komplett!

Für Computer ist das Puzzle, zu berechnen, ob die Anzahl der Primzahlen “gerade oder ungerade (0 oder 1)” ist, etwas, worin sie sehr gut sind, sodass mit dieser Methode $X$ und $Y$ mit hoher Geschwindigkeit gefunden werden können.

Kapitel 3: Die Mauer der Verzweiflung

Jetzt kann jeder Code geknackt werden! …oder das dachten wir zumindest, aber ein großes Problem tritt auf. Wenn die Verschlüsselungszahl $N$ bis zu “100 Stellen” umfasst, kann diese Methode (Quadratisches Sieb genannt) sie lösen, aber wenn $N$ zu “200 oder 300 Stellen” wird, wird das in der Mitte der Berechnung auftretende $W$ viel zu groß.

Wenn die Zahlen zu groß werden, tauchen “Zahlen, die nur aus kleinen Primzahlen (Goldstaub) bestehen”, einfach nicht mehr auf. Es wird schwieriger, als eine Kontaktlinse in der Wüste zu suchen, und die zum Lösen des Puzzles benötigten Karten sammeln sich gar nicht erst an.

Hier tritt schließlich die ultimative Waffe der Menschheit, das ** “General Number Field Sieve (GNFS)” ** , auf den Plan.

Kapitel 4: Die stärkste Idee der Menschheit, “Zwei Welten” zu erschaffen

Die geniale Idee des GNFS ist: ** “Die Zahlen werden gigantisch, weil wir nur in der realen Welt rechnen. Lassen Sie uns also eine ‘Hinterwelt’ mit Polynomen (Buchstabenformeln) erschaffen, um das Gewicht der Berechnung in zwei Hälften zu teilen.” **

Die Magie der Buchstabenformeln

GNFS wandelt die riesige Zahl $N$ unter Verwendung einer Basiszahl $m$ in einen Buchstabenausdruck um. Wenn zum Beispiel $N=100$ ist, mit $m=4$, dann ist $100 = 4^3 + 2(4^2) + 4$. Mit dem Buchstaben $x$ machen wir daraus eine Formel (die Hinterwelt): ** $f(x) = x^3 + 2x^2 + x$ ** .

Das Interessante an dieser Formel ist, dass sie die Eigenschaft hat, ** “wenn Sie $x$ durch $m$ ersetzen (4 im obigen Beispiel), können Sie immer zur realen Zahl $N$ zurückkehren” ** .

Gleichzeitig in 2 Welten nach Goldstaub suchen

GNFS erzeugt viele Paare von zufälligen Ganzzahlen $(a, b)$ und führt gleichzeitig die folgenden zwei Berechnungen durch:

** Reale Welt ** : $a - b \times m$
** Buchstabenwelt ** : Der Wert von $a - b \times x$, berechnet nach den Regeln der Polynome

Durch die Aufteilung des Problems in zwei Welten verringert sich die Größe (das Gewicht) der verarbeiteten Zahlen drastisch. Es ist, als würde man einen riesigen Felsen in zwei handliche Steine spalten.

Dann trennen und sammeln Sie mit einem Sieb nur die Wunderpaare $(a, b)$, bei denen ** “sowohl in der realen Welt als auch in der Buchstabenwelt beide ’nur aus kleinen Primzahlen (Goldstaub) bestehen’” ** . Daher der Name “Zahlkörpersieb” (Number Field Sieve).

Der Moment, in dem die Verschlüsselung endlich geknackt wird

Sobald Dutzende Millionen von “Goldstaubkarten” aus beiden Welten gesammelt wurden, verwendet der Supercomputer gigantische Matrixberechnungen, um “eine Kombination zu finden, bei der die Anzahl der Primzahlen alle gerade ist”, genau wie wir es in Kapitel 2 getan haben.

Sobald die Kombination gefunden ist:

Sei die Quadratzahl in der realen Welt ** $X^2$ **
Sei die in der Buchstabenwelt erstellte Quadratformel ** $Y(x)^2$ **

Ersetzen Sie schließlich das $x$ in der Buchstabenformel $Y(x)$ durch $m$, springen Sie in die reale Welt zurück und verbinden Sie sie. Dann ist, wie durch mathematische Magie, die Bedingung erfüllt, dass ** “die Reste von $X^2$ und $Y^2$ gleich sind” ** !

Der Rest besteht, wie in Kapitel 1, lediglich darin, den größten gemeinsamen Teiler von $X - Y$ und $N$ zu berechnen, und die uneinnehmbare RSA-Verschlüsselung wird zusammenbrechen und die geheimen Primzahlen offenbaren.

Fazit: Die Mathematik endet nie

Sie denken vielleicht: “Großartig, mit GNFS kann jede Verschlüsselung geknackt werden!”. Doch auch die RSA-Verschlüsselung hat nicht aufgegeben. Was im heutigen Internet verwendet wird, ist eine monströs gigantische Zahl namens “RSA-2048 (ca. 617 Stellen)”.

Obwohl GNFS der stärkste Algorithmus der Menschheit ist, sagt man, dass selbst das Lösen von 270 Stellen (RSA-270) Tausende oder Zehntausende von Jahren dauern würde, selbst wenn man Computer auf der ganzen Welt miteinander verbindet. Vorerst sind unsere LINE- und Bankdaten sicher.

Aber was wäre, wenn eine ** “Magie, um $X$ und $Y$ für jede riesige Zahl sofort zu finden” ** , auftauchen würde? Tatsächlich kommt der ** “Quantencomputer (Shor-Algorithmus)” ** , der sich derzeit in der Entwicklung befindet, dem am nächsten. Unter Ausnutzung der Wellennatur der Quantenmechanik wurde mathematisch bewiesen, dass es möglich ist, das mühsame Kartensammelpuzzle zu umgehen und die Antwort auf einen Schlag zu finden.

Ein endloser Kampf des Verstandes zwischen denen, die Verschlüsselung erschaffen (Verteidigung), und denen, die Algorithmen entwickeln, um sie zu knacken (Angriff). Macht das Wissen, dass die in der Mittelstufe erlernte “Primfaktorzerlegung” und “algebraische Ausdrücke” tatsächlich die Waffen sind, die an vorderster Front der globalen Sicherheit kämpfen, den Mathematikunterricht nicht ein wenig interessanter?

Derjenige, der den stärksten Algorithmus der Zukunft entdeckt, könnten Sie sein, der diesen Artikel liest!

(※Dieser Artikel ist eine konzeptionelle Adaption der mathematischen Faszination des Codeknackens für Schüler. Das eigentliche GNFS wird streng mit Hilfe der fortgeschrittenen Universitätsmathematik, wie Idealklassengruppen algebraischer Zahlkörper und Homomorphismen, berechnet)

【Vollständiges Verständnis durch Formeln】 Warum das stärkste klassische Verfahren GNFS von Quantenalgorithmen besiegt wird: Der Paradigmenwechsel der Primfaktorzerlegung

Mon, 01 Jan 0001 00:00:00 +0000

In der heutigen Internetgesellschaft wird die Informationssicherheit durch Public-Key-Kryptographie wie das RSA-Kryptosystem geschützt. Die Grundlage der Sicherheit des RSA-Kryptosystems beruht auf der Tatsache, dass „die Primfaktorzerlegung riesiger zusammengesetzter Zahlen rechnerisch extrem schwierig ist“ .

In diesem Artikel entschlüsseln wir den mathematischen Mechanismus des „Zahlkörpersiebs“ (General Number Field Sieve, GNFS), dem stärksten Algorithmus zur Primfaktorzerlegung für klassische Computer. Zugleich werden wir durch Formeln und Konzeptdiagramme detailliert ergründen, warum er durch den von Peter Shor entdeckten „Shor-Algorithmus“ vollständig besiegt wird und welchen Paradigmenwechsel dies darstellt.

1. Der Ansatz zur Primfaktorzerlegung in der klassischen Berechnung: Eine Entwicklung aus Fermats Faktorisierungsmethode

Das Problem der Primfaktorzerlegung besteht darin, für eine gegebene zusammengesetzte Zahl $N$ die Primzahlen $p, q$ zu finden, sodass $N = p \times q$ gilt.

Die grundlegende Idee läuft darauf hinaus, nicht-triviale Werte $x, y$ zu finden, die die folgende Kongruenz erfüllen:

$$ x^2 \equiv y^2 \pmod N $$

Durch Umformen erhalten wir:

$$ x^2 - y^2 \equiv 0 \pmod N $$ $$ (x - y)(x + y) \equiv 0 \pmod N $$

Wenn hier $x \not\equiv \pm y \pmod N$ gilt, können wir durch die Berechnung von $\gcd(x-y, N)$ oder $\gcd(x+y, N)$ einen nicht-trivialen Faktor von $N$ erhalten. Diese Tatsache bildet die Grundlage moderner Primfaktorzerlegungsalgorithmen wie dem GNFS.

2. Der stärkste klassische Algorithmus: Die Tiefen des „Zahlkörpersiebs“ (GNFS)

Das „GNFS“ ist der derzeit schnellste bekannte Algorithmus zur Primfaktorzerlegung für klassische Computer. Seine Zeitkomplexität erfordert eine subexponentielle (Sub-exponential) Zeit.

Die Zeitkomplexität von GNFS

Wenn die Anzahl der Ziffern der Zahl $N$ als $b = \log_2 N$ definiert ist, wird die Zeitkomplexität von GNFS wie folgt ausgedrückt:

$$ O\left( \exp \left( \left(\frac{64}{9} b\right)^{1/3} (\log b)^{2/3} \right) \right) $$

Wie aus dieser Formel ersichtlich ist, handelt es sich bei der Komplexität nicht um polynomielle Zeit, sondern um eine „subexponentielle Zeit“ , die nur geringfügig langsamer als exponentiell ist. Dennoch steigt die Berechnungszeit mit zunehmender Ziffernzahl astronomisch an.

Der mathematische Mechanismus von GNFS

GNFS besteht im Wesentlichen aus vier Schritten:

Polynomauswahl (Polynomial Selection)
Sieben (Sieving)
Matrixreduktion (Matrix Reduction)
Quadratwurzelberechnung (Square Root)

2.1. Polynomauswahl und algebraische Zahlkörper

Zunächst werden irreduzible Polynome $f(x)$ und $g(x)$ mit ganzzahligen Koeffizienten ausgewählt. Diese werden so festgelegt, dass sie modulo $N$ eine gemeinsame Wurzel $m$ haben. Das heißt:

$$ f(m) \equiv 0 \pmod N $$ $$ g(m) \equiv 0 \pmod N $$

Normalerweise wird $g(x)$ als lineares Polynom $g(x) = x - m$ gewählt. Setzt man die Wurzel von $f(x)$ als $\alpha$, so wird ein „algebraischer Zahlkörper“ (Number Field) namens $\mathbb{Q}(\alpha)$ konstruiert. Die Operationen im Ring von $\mathbb{Q}(\alpha)$ und die Operationen im normalen Ring der ganzen Zahlen $\mathbb{Z}$ werden über den Homomorphismus $\phi: \alpha \mapsto m$ verglichen.

2.2. Sieben (Sieving)

Als Nächstes wird massenhaft nach Paaren teilerfremder ganzer Zahlen $(a, b)$ gesucht. Das Ziel ist es, Paare zu finden, bei denen die folgenden zwei Werte jeweils „B-smooth“ sind (d. h. sie bestehen nur aus relativ kleinen Primfaktoren):

$a - bm$ (Wert über dem Ring der ganzen Zahlen)
$b^d f(a/b)$ (Entspricht der Norm $N(a - b\alpha)$ über dem algebraischen Zahlkörper)

Hierbei wird eine schnelle Suchmethode namens „Sieb“ (Sieve) angewendet. Dadurch werden $(a, b)$-Paare, die die Bedingungen erfüllen, effizient aus einer riesigen Menge von Kandidaten extrahiert.

2.3. Matrixreduktion (Linear Algebra over GF(2))

Aus den gesammelten $(a, b)$-Paaren werden Exponentenvektoren konstruiert, und der linke Nullraum einer riesigen, spärlich besetzten Matrix über $\mathbb{F}_2$ (einem Körper, der nur aus den Elementen 0 und 1 besteht) wird berechnet.

Man sucht als Lösung einen Vektor $v$, sodass die Relationen $ \prod (a_i - b_i m) $ und $ \prod (a_i - b_i \alpha) $ jeweils ein Quadrat werden. Dies ist nichts anderes als das Lösen eines linearen Gleichungssystems der Form:

$$ M \mathbf{x} \equiv \mathbf{0} \pmod 2 $$

Hierbei werden fortgeschrittene numerische Algorithmen wie das Block-Lanczos-Verfahren (Block Lanczos Algorithm) oder das Block-Wiedemann-Verfahren (Block Wiedemann Algorithm) eingesetzt.

2.4. Quadratwurzelberechnung

Schließlich wird sowohl im algebraischen Zahlkörper als auch im Ring der ganzen Zahlen die Quadratwurzel gezogen, um die Beziehung $x^2 \equiv y^2 \pmod N$ abzuleiten. Dann berechnet man $\gcd(x-y, N)$, um den Faktor zu erhalten.

3. Der Durchbruch durch Quantencomputing: Der „Shor-Algorithmus“

Während GNFS subexponentielle Zeit benötigt, kann der 1994 von Peter Shor veröffentlichte „Shor-Algorithmus“ dieses Problem mithilfe eines Quantencomputers in „polynomieller Zeit“ lösen.

Die Zeitkomplexität des Shor-Algorithmus

Wenn die Anzahl der Qubits $O(\log N)$ ist, ergibt sich die Zeitkomplexität wie folgt:

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

Das bedeutet, dass es keine exponentielle Explosion relativ zur Anzahl der Bits gibt. Selbst bei gigantischen zusammengesetzten Zahlen, deren Berechnungszeit in der „klassischen Berechnung“ das Alter des Universums übersteigen würde, liefert die „Quantenberechnung“ das erstaunliche Ergebnis, dass sie in wenigen Stunden bis Tagen entschlüsselt werden können.

Das Gesamtbild des Shor-Algorithmus: Reduktion auf das Problem der Periodenfindung

Der Shor-Algorithmus reduziert das Problem der Primfaktorzerlegung geschickt auf das „Problem der Periodenfindung“ .

Wähle eine zufällige ganze Zahl $a$, die teilerfremd zu $N$ ist ($1 < a < N$).
Definiere die Funktion $f(x) = a^x \bmod N$.
Finde die Periode $r$ von $f(x)$, d. h. die kleinste positive ganze Zahl $r$, sodass $a^r \equiv 1 \pmod N$ gilt.
Wenn $r$ gerade ist, überprüfe, ob $a^{r/2} \not\equiv -1 \pmod N$ gilt, und berechne $\gcd(a^{r/2} \pm 1, N)$, um einen Primfaktor zu erhalten.

Das Finden der Periode $r$ in Schritt 3 ist genau der Flaschenhals, der in klassischen Computern exponentielle Zeit erfordert. Ein Quantencomputer löst dies jedoch durch die Anwendung von „Quantensuperposition“ und der „Quanten-Fourier-Transformation“ (QFT) in einem Augenblick.

4. Quanten-Fourier-Transformation (QFT) und Periodenextraktion

Betrachten wir den Kern des Shor-Algorithmus, die Manipulation von Quantenzuständen, anhand von Formeln genauer.

4.1. Erzeugung der Quantensuperposition

Zunächst werden zwei Quantenregister vorbereitet. Register 1 hält den Überlagerungszustand der Eingabe $x$, und Register 2 hält das Berechnungsergebnis der Funktion $f(x)$. Auf den Anfangszustand $|0\rangle |0\rangle$ wird die Hadamard-Transformation (Hadamard Transform) angewendet, um eine Superposition aller möglichen Werte für $x$ zu erzeugen.

$$ |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |0\rangle $$

(Hier ist $Q$ eine Zweierpotenz, die $N^2 \le Q < 2N^2$ erfüllt)

Als Nächstes wird mithilfe eines Quantenorakels $U_f$ der Wert $f(x) = a^x \bmod N$ berechnet und in Register 2 gespeichert.

$$ |\psi_2\rangle = U_f |\psi_1\rangle = \frac{1}{\sqrt{Q}} \sum_{x=0}^{Q-1} |x\rangle |a^x \bmod N\rangle $$

Nehmen wir an, wir würden hier Register 2 messen (die mathematische Struktur bleibt gleich, auch wenn wir nicht tatsächlich messen). Wenn ein bestimmter Wert $y = a^{x_0} \bmod N$ beobachtet wird, kollabiert der Zustand von Register 1 in eine Überlagerung aller $x$, für die $f(x) = y$ gilt. Wenn die Periode $r$ ist, sind solche Werte für $x$ gegeben durch $x_0, x_0 + r, x_0 + 2r, \dots$.

$$ |\psi_3\rangle = \frac{1}{\sqrt{M}} \sum_{k=0}^{M-1} |x_0 + kr\rangle $$

(Hierbei ist $M \approx Q/r$ die Anzahl der Terme)

Dieser Zustand beinhaltet die Information über die Periode $r$, aber eine direkte Messung würde nur ein zufälliges $x_0 + kr$ liefern, und die Periode $r$ bliebe unbekannt. Hier kommt die QFT ins Spiel.

4.2. Anwendung der Quanten-Fourier-Transformation (Quantum Fourier Transform)

Die QFT ist eine Operation, die eine diskrete Fourier-Transformation auf die Amplituden von Quantenzuständen durchführt. Die Wirkung der QFT auf den Zustand $|x\rangle$ ist wie folgt definiert:

$$ \text{QFT} |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} e^{2\pi i \frac{xy}{Q}} |y\rangle $$

Wenn man dies auf $|\psi_3\rangle$ anwendet, tritt Phaseninterferenz (Quanteninterferenz) auf.

$$ |\psi_4\rangle = \text{QFT} |\psi_3\rangle = \frac{1}{\sqrt{MQ}} \sum_{y=0}^{Q-1} \sum_{k=0}^{M-1} e^{2\pi i \frac{(x_0 + kr)y}{Q}} |y\rangle $$

Wenn man die Summe in dieser Formel erweitert,

$$ \sum_{k=0}^{M-1} e^{2\pi i \frac{kry}{Q}} $$

erscheint dieser Teil. Diese Summe einer geometrischen Reihe verstärkt sich nur dann gegenseitig (Constructive Interference), wenn $ry/Q$ nahe an einer ganzen Zahl liegt; andernfalls hebt sie sich auf (Destructive Interference).

Folglich ist der Zustand $|y\rangle$, der mit hoher Wahrscheinlichkeit gemessen wird, eine ganze Zahl $y$, die folgende Bedingung erfüllt:

$$ \frac{y}{Q} \approx \frac{c}{r} $$

($c$ ist hierbei irgendeine ganze Zahl).

4.3. Bestimmung der Periode durch Kettenbruchentwicklung

Nachdem man durch Messung $y$ erhalten hat, führt man mithilfe eines klassischen Computers eine „Kettenbruchentwicklung“ (Continued Fraction Expansion) von $y/Q$ durch. Dadurch kann man den Näherungsbruch $c/r$ von $y/Q$ berechnen und aus dem Nenner die Kandidaten für die Periode $r$ hocheffizient extrahieren.

5. Vergleich konzeptioneller Modelle und der Paradigmenwechsel

Um den Unterschied zwischen GNFS und dem Shor-Algorithmus intuitiv zu verstehen, zeigen wir im Folgenden ein Konzeptdiagramm in der Mermaid-Syntax.

Konzeptdiagramm des Shor-Algorithmus durch Quantenschaltkreise

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


graph TD
 A[Anfangszustand: 0...0] --> B[Superposition aller Zustände durch Hadamard-Transformation]
 B --> C[Modulare Exponentiation a^x mod N]
 C -->|Quantenverschränkung| D[Kollaps in einen Zustand mit Periodizität]
 D --> E[Quanten-Fourier-Transformation QFT]
 E -->|Wahrscheinlichkeitsverstärkung durch Interferenz| F[Messung: y erhalten]
 F --> G[Klassische Verarbeitung: Kettenbruchentwicklung]
 G --> H[Entdeckung der Periode r]
 H --> I[Berechnung der Primfaktoren von N]

 style A fill:#f9f,stroke:#333,stroke-width:2px
 style E fill:#bbf,stroke:#333,stroke-width:2px
 style I fill:#bfb,stroke:#333,stroke-width:2px

Das Wesen des Paradigmenwechsels

GNFS verfolgt den Ansatz, „in einem mathematischen Raum (algebraischen Zahlkörper) nach Relationen zu suchen“ . Da dieser Suchraum jedoch exponentiell mit der Anzahl der Ziffern wächst, wird die Entschlüsselung mit der Rechenleistung klassischer Computer (selbst bei Parallelisierung) faktisch unmöglich, wenn die Schlüssellänge 2048 Bit überschreitet.

Auf der anderen Seite nutzt der Shor-Algorithmus die „Welleneigenschaften durch Quanteninterferenz“ . Alle Berechnungswege in der Superposition werden gleichzeitig ausgewertet. Durch die QFT werden unnötige Antworten aufgehoben (destruktive Interferenz), und nur die Wahrscheinlichkeitsamplitude der korrekten Periode wird verstärkt (konstruktive Interferenz). Anstatt den Raum zu durchsuchen, wird so der völlig andere Ansatz realisiert, „die richtige Antwort selbst hervortreten zu lassen“ .

6. Zusammenfassung

In diesem Artikel haben wir das „GNFS“ , den Höhepunkt der klassischen Grenzen, und den „Shor-Algorithmus“ , der die Kraft des Quantencomputings demonstriert, hinsichtlich ihrer mathematischen Hintergründe und algorithmischen Strukturen tiefgehend verglichen.

Während GNFS durch mathematische Tricks wie die Polynomauswahl und riesige Matrixberechnungen die Zeitkomplexität auf subexponentielle Zeit reduzierte, gelang dem Shor-Algorithmus ein sofortiger Durchbruch in die polynomielle Zeit. Er verschmolz die Grundprinzipien der Quantenmechanik – Superposition und Interferenz – mit mathematischen Werkzeugen (QFT).

Derzeit gibt es keine fehlertoleranten Quantencomputer (FTQC), die den Shor-Algorithmus in einem praktischen Maßstab (Tausende von Qubits) ausführen können. Das bloße Vorhandensein dieses mathematischen und theoretischen Paradigmenwechsels ist jedoch der Hauptgrund, warum der Übergang zur Post-Quanten-Kryptographie (PQC: Post-Quantum Cryptography) derzeit weltweit dringend vorangetrieben wird.