RSA on kenji.blog

Wird der Quantencomputer wirklich die RSA-Verschlüsselung knacken? ~ Shors Algorithmus und der aktuelle Stand ~

Sat, 05 Sep 2026 22:09:21 +0900

Einleitung: Die Schnittstelle von Kryptographie und Quantencomputern

In der modernen Internetgesellschaft ist die “Public-Key-Kryptographie” die Grundlage für den Schutz des Kommunikationsgeheimnisses. Ein prominentes Beispiel ist die “RSA-Verschlüsselung”, die 1977 von Ron Rivest, Adi Shamir und Leonard Adleman entwickelt wurde. Von Online-Shopping-Zahlungen, die wir täglich nutzen, über das Surfen auf Websites (HTTPS) bis hin zum Senden und Empfangen von E-Mails fungiert die RSA-Verschlüsselung als Herzstück der Internet-Infrastruktur.

Jedoch wurde darauf hingewiesen, dass die Sicherheit durch das Aufkommen von “Quantencomputern” grundlegend untergraben werden könnte. In den Medien finden sich manchmal aufsehenerregende Schlagzeilen wie “Wenn der Quantencomputer fertiggestellt ist, werden alle Passwörter und Verschlüsselungen der Welt in Sekunden geknackt”. Ist das wirklich wahr?

In diesem Artikel werden wir tief in die Mechanismen der GNFS (General Number Field Sieve), einer klassischen kryptoanalytischen Methode, und des “Shor-Algorithmus (Shor’s Algorithm)”, des ultimativen kryptoanalytischen Algorithmus unter Verwendung eines Quantencomputers, eintauchen. Wir werden fortgeschrittene Konzepte wie die Quanten-Fouriertransformation und das Finden von Perioden leicht verständlich erklären und den aktuellen Stand der Quantenhardware in der derzeitigen NISQ-Ära (Noisy Intermediate-Scale Quantum) sowie die tatsächlichen Hürden zur Knackung von RSA-2048 detailliert untersuchen.

Die Grundlage der RSA-Verschlüsselung: Die Schwierigkeit der Primfaktorzerlegung

Die Sicherheit der RSA-Verschlüsselung beruht auf einer extrem einfachen Asymmetrie in der Mathematik. Es ist die Tatsache, dass “es einfach ist, zwei riesige Primzahlen miteinander zu multiplizieren, aber extrem schwierig ist, die ursprünglichen zwei Primzahlen aus dem Ergebnis dieser Multiplikation (zusammengesetzte Zahl) zu finden (Primfaktorzerlegung)”.

Angenommen, wir haben zwei Primzahlen $ p = 61 $ und $ q = 53 $. Diese Multiplikation $ N = p \times q = 3233 $ ist in einem Augenblick berechnet. Wenn uns jedoch nur die Zahl “3233” gegeben wird und wir lösen sollen: “Welche Primzahlen wurden hier multipliziert?”, explodiert die Rechenkomplexität, je größer die Zahlen werden.

Beim derzeit dominierenden RSA-2048 wird eine riesige zusammengesetzte Zahl $ N $ mit einer Schlüssellänge von 2048 Bits verwendet, was etwa 617 Dezimalstellen entspricht. Wenn dieses $ N $ in Primfaktoren zerlegt werden kann, gilt die Verschlüsselung als geknackt.

Die Herausforderung durch klassische Computer: GNFS (General Number Field Sieve)

Um das Problem der Primfaktorzerlegung zu lösen, haben Mathematiker und Kryptographen über viele Jahre verschiedene Algorithmen entwickelt. Unter ihnen gilt die ** General Number Field Sieve (GNFS) ** als die derzeit schnellste Methode für klassische Computer.

GNFS ist eine Methode zur Primfaktorzerlegung einer riesigen Zahl $ N $, indem die Berechnungen im Ring der ganzen Zahlen auf einen abstrakteren algebraischen Zahlkörper (Number Field) erweitert und analysiert werden. Der grobe Ablauf ist wie folgt:

** Auswahl des Polynoms ** : Finden eines Polynoms $ f(x) $ mit geeignetem Grad und Koeffizienten, das $ N $ als Wurzel hat.
** Datensammlung (Sieben) ** : Suche nach einer großen Anzahl von Zahlenpaaren über den rationalen Zahlen und dem algebraischen Zahlkörper, die sich in kleine Primzahlen (glatte Zahlen, Smooth numbers) zerlegen lassen. Dieser Prozess wird als “Sieben” bezeichnet und ist der zeitaufwändigste Teil.
** Matrixerstellung und -reduktion ** : Erstellung einer riesigen dünnbesetzten Matrix (eine Matrix, deren Elemente meist 0 sind) basierend auf den gesammelten Beziehungen und Lösung unter Verwendung linearer algebraischer Methoden (wie dem Block-Lanczos-Verfahren).
** Berechnung der Quadratwurzel ** : Schließlich Berechnung der Quadratwurzel über dem algebraischen Zahlkörper, um den Faktor (Primfaktor) von $ N $ abzuleiten.

Die Rechenkomplexität von GNFS wird asymptotisch mit $ O(\exp((\sqrt[3]{\frac{64}{9}} + o(1)) (\log N)^{\frac{1}{3}} (\log \log N)^{\frac{2}{3}})) $ bewertet. Dies wird als “subexponentielle” (Sub-exponential) Zeitkomplexität bezeichnet. Sie ist schneller als exponentielle Zeit, aber wesentlich langsamer als polynomiale Zeit (Polynomial time).

Tatsächlich gelang es einem internationalen Forschungsteam im Jahr 2020, RSA-250 (eine zusammengesetzte Zahl mit 829 Bits und 250 Stellen) mithilfe von GNFS erfolgreich zu faktorisieren. Für diese Berechnung wurden weltweit Rechenressourcen gebündelt und eine enorme Rechenzeit von etwa 2700 CPU-Kern-Jahren aufgewendet. Bei 2048 Bits würde die erforderliche Rechenmenge jedoch Billionen Mal länger dauern als das Alter des Universums, und es ist unmöglich, dies mit klassischen Methoden in realistischer Zeit zu knacken, egal wie viele aktuelle Supercomputer parallel betrieben werden.

Der Trumpf des Quantencomputers: Shors Algorithmus

Hier kommt der 1994 von Peter Shor vorgestellte “Shor-Algorithmus” ins Spiel. Dieser Algorithmus war bahnbrechend, da er das Problem der Primfaktorzerlegung auf einem Quantencomputer in ** polynomialer Zeit ** ( $ O((\log N)^3) $ ) lösen kann. Der Unterschied zwischen subexponentieller Zeit und polynomialer Zeit ist entscheidend, und theoretisch bedeutet dies, dass die RSA-Verschlüsselung mit einem Quantencomputer vollständig gebrochen wird.

Gesamtablauf von Shors Algorithmus

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


graph TD
 A[Eingabe der zu faktorisierenden Zahl N] --> B[Zufällige ganze Zahl a wählen]
 B --> C{Größter gemeinsamer Teiler<br>von a und N}
 C -->|Größer als 1| D[Glücklicherweise Primfaktor gefunden!]
 C -->|1 teilerfremd| E[Einsatz des Quantencomputers]
 E --> F[Finde die Periode r der Funktion f_x = a^x mod N<br>mit der Quanten-Fouriertransformation]
 F --> G{Ist die Periode r gerade und<br>a^r/2 ≢ -1 mod N}
 G -->|Ja| H[Berechne gcd_a^r/2 ± 1, N]
 H --> I((Primfaktorzerlegung erfolgreich!))
 G -->|Nein| B

Shors Algorithmus löst das Problem der Primfaktorzerlegung nicht direkt, sondern verwendet zahlentheoretische Theoreme, um es in ein anderes Problem namens “Period Finding Problem” umzuwandeln, und löst es durch Ausnutzung der Eigenschaften von Quantencomputern mit hoher Geschwindigkeit.

Schritt 1: Reduktion der Primfaktorzerlegung auf das Periodenfindungsproblem (Klassische Verarbeitung)

Der erste Schritt des Algorithmus wird auf einem klassischen Computer durchgeführt. Für die zu faktorisierende Zahl $ N $ wählen wir eine zufällige ganze Zahl $ a $ ( $ 1 < a < N $ ), die teilerfremd zu $ N $ ist (der größte gemeinsame Teiler ist 1). Wenn durch Zufall der größte gemeinsame Teiler nicht 1 ist, ist der gefundene gemeinsame Teiler ein Primfaktor von $ N $ und die Entschlüsselung ist abgeschlossen, aber die Wahrscheinlichkeit ist extrem gering.

Als nächstes betrachten wir die Folge der folgenden modularen Gleichungen: $ f(x) = a^x \pmod N $

Wenn wir $ x = 1, 2, 3, \dots $ in diese Funktion $ f(x) $ einsetzen, scheinen die Werte zufällig zu sein, aber da wir innerhalb eines endlichen Bereichs rechnen, kehrt sie an einem bestimmten Punkt immer zum ursprünglichen Wert zurück und wiederholt dieselbe Zahlenfolge. Wir nennen diese Wiederholungsperiode $ r $. Das bedeutet, wir suchen die kleinste positive ganze Zahl $ r $, sodass $ a^r \equiv 1 \pmod N $ gilt. Das ist das “Periodenfindungsproblem”.

Wenn diese Periode $ r $ gefunden wird und $ r $ eine gerade Zahl ist, haben wir $ a^r - 1 \equiv 0 \pmod N $ und wir können die Faktorisierungsformel verwenden, um es wie folgt umzuwandeln: $ (a^{r/2} - 1)(a^{r/2} + 1) \equiv 0 \pmod N $ Von hier aus können wir den euklidischen Algorithmus verwenden, um den größten gemeinsamen Teiler von $ N $ und $ a^{r/2} \pm 1 $ zu berechnen, was uns mit extrem hoher Wahrscheinlichkeit die Primfaktoren von $ N $ liefert.

Um die Periode $ r $ auf einem klassischen Computer zu finden, sind letztlich exponentiell viele Schritte erforderlich und können nicht beschleunigt werden. Ein Quantencomputer kann diese Periode $ r $ jedoch im Bruchteil einer Sekunde (in polynomialer Zeit) finden.

Schritt 2: Vorbereitung des Quantenzustands und Superposition

Ab hier kommt der Quantencomputer ins Spiel. Quantencomputer verwenden “Qubits”, die die Zustände “0” und “1” gleichzeitig annehmen können. Bei Shors Algorithmus bereiten wir zwei Register vor: ein Register zum Speichern der Eingabe (das erste Register) und ein Register zum Speichern des Berechnungsergebnisses (das zweite Register).

Zuerst wird eine Quantengatteroperation, das sogenannte Hadamard-Gatter (Hadamard gate), auf alle Qubits im ersten Register angewendet. Dadurch gelangt das erste Register in einen ** gleichmäßigen Überlagerungszustand ** (Superposition) aller möglichen $ x $-Werte (von $ 0 $ bis $ 2^n-1 $ , wobei $ n $ eine ausreichend große Anzahl von Bits ist).

Das bedeutet, dass im Quantencomputer unzählige Eingabewerte $ x=0, 1, 2, 3, \dots $ gleichzeitig und parallel existieren.

Schritt 3: Modulare Exponentiation auf dem Quantencomputer (Quantum Modular Exponentiation)

Als Nächstes berechnen wir $ f(x) = a^x \pmod N $, wobei der Überlagerungszustand des ersten Registers als Eingabe dient, und speichern das Ergebnis im zweiten Register. Da diese Berechnung als unitäre Transformation in einem Quantenschaltkreis ausgeführt wird, wird die Berechnung von $ f(x) $ für alle $ x $ “simultan und parallel” (Quantenparallelität) ausgeführt, während die Überlagerung beibehalten wird.

Zu diesem Zeitpunkt ist der Raum des gesamten Quantensystems eine gewaltige Superposition der Zustände: $ |x, a^x \bmod N\rangle $

Wenn wir jedoch einfach das zweite Register messen (beobachten), wird nur ein zufälliger Wert von $ a^x \bmod N $ probabilistisch ausgewählt, und in Verbindung damit ist auch der Wert $ x $ im ersten Register auf einen festgelegt. Das ist dasselbe wie eine einmalige Berechnung auf einem klassischen Computer, und wir können die Periode $ r $ nicht finden.

Nach den Regeln der Quantenmechanik können wir nicht direkt in den Überlagerungszustand schauen. Wie können wir also die globale Information extrahieren, die die “Periode” des Ganzen ist?

Schritt 4: Quanten-Fouriertransformation (QFT: Quantum Fourier Transform)

Der geniale Durchbruch des Shor-Algorithmus zur Überwindung dieser Barriere ist die Anwendung der ** Quanten-Fouriertransformation (QFT) ** auf das erste Register.

Bevor wir eine Messung vornehmen, analysieren wir die Welleneigenschaften der Funktion $ f(x) $. Angenommen, wir beobachten das zweite Register. Angenommen, wir erhalten einen Wert $ y $. Dann kollabiert der Zustand des ersten Registers in “die Superposition aller $ x $, für die $ a^x \pmod N = y $ gilt”. Diese Werte von $ x $ werden ein diskret angeordneter Zustand (eine Art kammartige Wahrscheinlichkeitsamplitudenverteilung) in Intervallen der Periode $ r $ sein, wie $ x_0, x_0 + r, x_0 + 2r, x_0 + 3r, \dots $.

Wir wenden die Quanten-Fouriertransformation (QFT) auf diesen Zustand an. So wie die klassische diskrete Fouriertransformation ein Signal im Zeitbereich in den Frequenzbereich umwandelt, bewirkt die QFT eine Interferenz der Wahrscheinlichkeitsamplituden von Quantenzuständen.

Wenn die QFT angewendet wird, heben sich aufgrund des Quanteninterferenzeffekts die Wahrscheinlichkeiten falscher Antworten, die nicht mit der Periode $ r $ in Resonanz stehen (phasenverschoben sind), gegenseitig auf und nähern sich null (destruktive Interferenz), und nur die Wahrscheinlichkeit der richtigen Antwort, die Informationen über die Periode $ r $ enthält, wird verstärkt (konstruktive Interferenz).

Schritt 5: Messung und Kettenbruchentwicklung (Klassische Nachbearbeitung)

Wenn wir das erste Register nach Anwendung der QFT messen, erhalten wir mit sehr hoher Wahrscheinlichkeit eine ganze Zahl $ c $, die nahe der Form $ c \approx \frac{j \cdot 2^n}{r} $ liegt (wobei $ j $ eine unbekannte ganze Zahl und $ 2^n $ die Größe des Registers ist).

Wir geben dieses Messergebnis $ c $ an den klassischen Computer zurück und bilden einen Bruch $ \frac{c}{2^n} \approx \frac{j}{r} $. Und durch die Berechnung von Näherungswerten mit einer mathematischen Methode namens “Kettenbruchentwicklung (Continued fraction expansion)” können wir die Periode $ r $, die im Nenner steht, wunderbar aufdecken.

Wenn $ r $ bekannt ist, können die Primfaktoren von $ N $ mithilfe der Formel aus Schritt 1 berechnet werden, und die RSA-Verschlüsselung wird vollständig geknackt.

Das Potenzial und die Herausforderungen aktueller Quantencomputer (NISQ)

Obwohl der Shor-Algorithmus theoretisch perfekt ist, lautet die Antwort auf die Frage “Wird die RSA-Verschlüsselung morgen gebrochen sein?” eindeutig “Nein”. Der Grund dafür liegt in den Grenzen der aktuellen Hardware-Technologie von Quantencomputern.

Die Ära des NISQ (Noisy Intermediate-Scale Quantum)

Wir befinden uns derzeit in der Ära, die als “NISQ” bezeichnet wird. NISQ-Geräte haben Dutzende bis Hunderte von physikalischen Qubits, sind aber extrem anfällig für Rauschen.

Qubits werden leicht durch die äußere Umgebung, wie z.B. Wärme und elektromagnetische Wellen, beeinflusst, was häufig zu “Dekohärenz” (Verlust der Quantenverschränkung), bei der der Quantenzustand zerstört wird, und zu “Gatterfehlern” während der Gatteroperationen führt. Wenn man versucht, sehr tiefe Quantenschaltungen (mit einer riesigen Anzahl von Rechenschritten) wie Shors Algorithmus auszuführen, summieren sich Fehler während der Berechnung und die endgültige Ausgabe wird zu reinem Rauschen ohne Bedeutung.

Physikalische Qubits und logische Qubits

Die “Quantenfehlerkorrektur (Quantum Error Correction)” ist unerlässlich, um dieses Fehlerproblem zu lösen. Fehlerkorrekturcodes werden auch in klassischen Computern verwendet, aber Quantenfehlerkorrektur ist sehr komplex aufgrund des “No-Cloning-Theorems”, das das Kopieren von Quantenzuständen verbietet.

Bei der Quantenfehlerkorrektur wird eine ideale “logische Qubit” ohne Fehler durch die Kombination vieler verrauschter “physikalischer Qubits” unter Verwendung von Technologien wie dem “Oberflächencode (Surface Code)” erzeugt.

Unter der Annahme der aktuellen Fehlerraten wird geschätzt, dass etwa 1.000 bis 10.000 physikalische Qubits erforderlich sind, um ein einziges logisches Qubit zu erzeugen. Dies wird als “Fehlerkorrektur-Overhead” bezeichnet.

Welche Ressourcen werden benötigt, um RSA-2048 zu brechen?

Wie viele Ressourcen werden also tatsächlich benötigt, um den Shor-Algorithmus zur Knackung von RSA-2048 auszuführen?

Laut bahnbrechenden Ressourcenschätzungen aus einem Papier von Craig Gidney (Google) und Martin Ekerå aus dem Jahr 2021 werden die folgenden Ressourcen benötigt, wenn man einen optimierten Shor-Algorithmus verwendet und eine Fehlerkorrektur mit Oberflächencodes durchführt:

** Anzahl der logischen Qubits ** : Etwa 4.096
** Anzahl der physikalischen Qubits ** : ** Etwa 20 Millionen ** (unter Annahme einer Fehlerrate von etwa $10^{-3}$)
** Rechenzeit ** : Etwa 8 Stunden (erfordert Millionen bis Milliarden von physikalischen Gatteroperationen)

Wie weit ist im Vergleich dazu der aktuelle Stand der Quantenhardware? Der Ende 2023 von IBM angekündigte supraleitende Quantenprozessor “Condor” hat 1.121 Qubits. Darüber hinaus haben bahnbrechende Forschungen zur Erzeugung logischer Qubits (wie die Erzeugung von 48 logischen Qubits unter Verwendung neutraler Atome durch die Harvard University und QuEra) das Licht der Welt erblickt, aber wir sind noch nicht an dem Punkt angelangt, an dem “rauschfreie, perfekte Berechnungen” kontinuierlich für lange Zeiträume ausgeführt werden können.

Die Skalierung von Tausenden physikalischen Qubits auf ** 20 Millionen ** praktikable physikalische Qubits (in einem System, das miteinander verbunden ist, bei kryogenen Temperaturen stabil arbeitet und Steuersignale bei ultrahohen Geschwindigkeiten verarbeitet) stellt eine gewaltige ingenieurtechnische Barriere dar (Verkabelungsprobleme, Grenzen der Kühlleistung und Aufblähen der Steuerelektronik). Viele Experten prognostizieren, dass es mindestens 10 bis 30 Jahre oder länger dauern wird, bis “fehlertolerante Quantencomputer (FTQC)” realisiert werden, die RSA-2048 knacken können.

Die schleichende Bedrohung durch “Store Now, Decrypt Later” und die Morgendämmerung der PQC

Es ist jedoch voreilig zu denken, dass “wir sicher sind, wenn es noch mehr als 10 Jahre dauert”. Derzeit gibt es Daten wie nationale Geheimnisse, medizinische Daten und langfristige Infrastrukturdesigns, deren Geheimhaltung für Jahrzehnte garantiert werden muss.

Die Besorgnis betrifft die Angriffsmethode ** “Store Now, Decrypt Later” ** . Böswillige Staaten oder Organisationen fangen alle mit aktueller RSA oder ECC (Elliptic Curve Cryptography) verschlüsselten Kommunikationsdaten ab und speichern sie. Wenn dann in 10 oder 20 Jahren leistungsstarke Quantencomputer fertiggestellt sind, nutzen sie den Shor-Algorithmus, um alle vergangenen Daten zu entschlüsseln und Geheimnisse zu lüften.

Um der Bedrohung durch diese zeitliche Verzögerung entgegenzuwirken, hat das NIST (National Institute of Standards and Technology) in den USA den Standardisierungsprozess für ** “Post-Quanten-Kryptographie (PQC)” ** rasch vorangetrieben.

PQC sind neue kryptographische Algorithmen, die auf mathematischen Problemen basieren, deren Entschlüsselung auch mit einem Quantencomputer schwierig ist (d. h. Shors Algorithmus kann nicht angewendet werden). Die Hauptansätze sind wie folgt:

** Gitterbasierte Kryptographie ** : Basiert auf dem LWE-Problem (Learning with Errors) usw. Der Mainstream in der NIST-Standardisierung (Kyber, Dilithium usw.).
** Codebasierte Kryptographie ** : Beruht auf der Schwierigkeit, Fehlerkorrekturcodes zu decodieren.
** Multivariate Kryptographie ** : Beruht auf der Schwierigkeit, Systeme von quadratischen Gleichungen mit mehreren Variablen zu lösen.
** Hash-basierte Signaturen ** : Digitale Signaturen, deren Sicherheit ausschließlich von Hash-Funktionen abhängt.

Bereits in großen Softwares und Plattformen wie Google Chrome und Apples iMessage haben PQC-Implementierungstests und Hybrid-Implementierungen begonnen.

Fazit

Quantencomputer wandeln sich von Träumereien der Science-Fiction zu echten ingenieurtechnischen Herausforderungen. Shors Algorithmus ist eine großartige intellektuelle Errungenschaft der Menschheit, die Mathematik und Quantenmechanik vereint, aber er birgt auch die “zerstörerische Kraft”, die Grundlagen unserer digitalen Gesellschaft zu erschüttern.

Die RSA-Verschlüsselung wird nicht schon morgen unbrauchbar sein. Angesichts der Entwicklung der Quantentechnologie und des Risikos von “Store Now, Decrypt Later” hat die gigantische Migration in der Geschichte der Kryptographie, der Übergang zu PQC, jedoch bereits begonnen. Wir sind heute Zeugen der vordersten Front eines Paradigmenwechsels in der Informationssicherheit.

【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)