Mathematics on kenji.blog

Grundlagen und Implementierung der Verschlüsselung mit dem kleinen Satz von Fermat

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

1. Einführung: Das Geheimnis der Mathematik hinter der modernen Kryptographie

In der modernen digitalen Gesellschaft, insbesondere bei der Kommunikation über das Internet, ist “Verschlüsselung” zu einer unverzichtbaren Basistechnologie geworden. Dass wir Websites über HTTPS sicher in einem Webbrowser durchsuchen, Finanztransaktionen im Online-Banking durchführen und privat in Messaging-Apps kommunizieren können, liegt daran, dass kryptographische Protokolle, die durch fortgeschrittene mathematische Theorien gestützt werden, im Hintergrund arbeiten. Eine besonders wichtige Rolle spielt dabei die “Public-Key-Kryptographie”, deren prominentester Vertreter die RSA-Verschlüsselung ist.

Die Sicherheit und Gültigkeit vieler kryptographischer Algorithmen, einschließlich RSA, hängt stark von einem sehr schönen und mächtigen Satz ab, der im 17. Jahrhundert vom französischen Mathematiker Pierre de Fermat entdeckt wurde. Das ist der kleine Satz von Fermat. Darüber hinaus spielt der Satz von Leonhard Euler, der diesen verallgemeinert, eine entscheidende Rolle in der Kryptographietheorie.

In diesem Artikel werden wir von Grund auf ausführlich erklären, wie die Entdeckung der reinen Mathematik, der kleine Satz von Fermat, in der modernen, praktischen Kryptographie, insbesondere beim “Primzahltest” und bei der “RSA-Verschlüsselung”, Anwendung findet. Dies ist ein sehr detaillierter technischer Leitfaden, der mathematische Beweise, Ver- und Entschlüsselungsmechanismen sowie spezifische Algorithmus-Implementierungen in C++ und Python abdeckt.

2. Grundlagen der Kongruenzen und der modularen Arithmetik

Um den kleinen Satz von Fermat zu verstehen, müssen wir uns zunächst mit dem mathematischen Konzept der “modularen Arithmetik (Kongruenz)” vertraut machen. Die modulare Arithmetik ist ein Rechensystem, das sich auf den “Rest” nach der Division durch eine bestimmte feste Zahl (Modul genannt) konzentriert. Da es sich um eine Berechnung wie beim Zifferblatt einer Uhr (die in 12 Stunden einen Umlauf macht) handelt, wird sie auch “Uhrenarithmetik” genannt.

Wenn die Reste der Division der ganzen Zahlen $a$ und $b$ durch eine positive ganze Zahl $n$ gleich sind, wird dies mathematisch wie folgt beschrieben:

$$ a \equiv b \pmod n $$

Dies liest sich als “$a$ und $b$ sind kongruent modulo $n$”. Zum Beispiel ist der Rest von 17 geteilt durch 5 gleich 2, und der Rest von 12 geteilt durch 5 ist ebenfalls 2. Daher können wir schreiben:

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

In der modularen Arithmetik gelten die üblichen vier Grundrechenarten (Addition, Subtraktion, Multiplikation) wie gewohnt:

Addition: Wenn $a \equiv b \pmod n$ und $c \equiv d \pmod n$, dann $a + c \equiv b + d \pmod n$
Subtraktion: Wenn $a \equiv b \pmod n$ und $c \equiv d \pmod n$, dann $a - c \equiv b - d \pmod n$
Multiplikation: Wenn $a \equiv b \pmod n$ und $c \equiv d \pmod n$, dann $a \times c \equiv b \times d \pmod n$
Potenzieren: Wenn $a \equiv b \pmod n$, dann $a^k \equiv b^k \pmod n$ für jede natürliche Zahl $k$

Bei der Division ist jedoch Vorsicht geboten. Im Allgemeinen bedeutet $a \times c \equiv b \times c \pmod n$ nicht, dass wir beide Seiten durch $c$ teilen und $a \equiv b \pmod n$ erhalten können. Dies gilt nur, wenn $c$ und $n$ teilerfremd sind (ihr größter gemeinsamer Teiler ist 1). Dieses Konzept des “modularen Inversen” ist extrem wichtig bei der Schlüsselgenerierung der RSA-Verschlüsselung, die später beschrieben wird.

3. Mathematischer Hintergrund und Beweis des kleinen Satzes von Fermat

Nachdem wir nun die Grundlagen der modularen Arithmetik behandelt haben, kommen wir zum Hauptthema: dem kleinen Satz von Fermat.

3.1 Definition des Satzes

Der kleine Satz von Fermat wird wie folgt formuliert:

Kleiner Satz von Fermat (Fermat’s Little Theorem) Sei $p$ eine Primzahl und $a$ eine beliebige ganze Zahl, die kein Vielfaches von $p$ ist (d.h. $a$ und $p$ sind teilerfremd). Dann gilt die folgende Kongruenz:
$$ a^{p-1} \equiv 1 \pmod p $$

Es ist auch üblich, die Bedingung “$a$ ist kein Vielfaches von $p$” zu entfernen und es so auszudrücken, dass es für alle ganzen Zahlen $a$ gilt. In diesem Fall multiplizieren wir beide Seiten mit $a$ und erhalten:

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

3.2 Bestätigung durch konkrete Beispiele

Lassen Sie uns anhand konkreter Zahlen prüfen, ob der Satz wirklich gilt. Sei die Primzahl $p = 5$. Dann ist $p-1 = 4$. Wir wählen als $a$ ganze Zahlen, die keine Vielfachen von $p$ sind.

Für $a = 2$: $2^{5-1} = 2^4 = 16$. $16 \div 5 = 3$ Rest $1$. Also $16 \equiv 1 \pmod 5$. (Gültig)
Für $a = 3$: $3^{5-1} = 3^4 = 81$. $81 \div 5 = 16$ Rest $1$. Also $81 \equiv 1 \pmod 5$. (Gültig)
Für $a = 4$: $4^{5-1} = 4^4 = 256$. $256 \div 5 = 51$ Rest $1$. Also $256 \equiv 1 \pmod 5$. (Gültig)

Wie Sie sehen können, egal welches $a$ Sie wählen (solange es kein Vielfaches von 5 ist), ist der Rest immer 1, wenn Sie es zur 4. Potenz erheben und durch 5 teilen. Es scheint wie Magie, aber es stammt von den wunderbaren Eigenschaften der Primzahlen ab.

3.3 Mathematischer Beweis des Satzes

Warum ist das so? Hier stellen wir einen eleganten Beweis mit Hilfe der Menge der Restklassen vor.

Betrachten wir die Menge $S = \{1, 2, 3, \dots, p-1\}$. Dies sind Repräsentanten der ganzen Zahlen, deren Rest bei Division durch $p$ von $1$ bis $p-1$ reicht. Betrachten wir nun eine neue Menge $T$, in der jedes Element mit einer zu $p$ teilerfremden ganzen Zahl $a$ multipliziert wird.

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

Betrachten wir den Rest jedes Elements dieser Menge $T$ bei der Division durch $p$. Erstaunlicherweise stimmen diese Reste – obwohl ihre Reihenfolge vertauscht sein mag – genau mit der Menge der Elemente der ursprünglichen Menge $S$ überein. Weil:

Kein Element von $T$ ein Vielfaches von $p$ wird (da weder $a$ noch die ursprünglichen Elemente Vielfache von $p$ sind).
Es in $T$ keine zwei verschiedenen Elemente gibt, die modulo $p$ kongruent sind. Wenn $ia \equiv ja \pmod p$ ($i \neq j$) wäre, könnten wir durch $a$ teilen, da $a$ und $p$ teilerfremd sind, und bekämen $i \equiv j \pmod p$, was ein Widerspruch ist.

Daher ist das Produkt aller Elemente von $S$ kongruent zum Produkt aller Elemente von $T$ modulo $p$.

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

Wenn wir die linke Seite umstellen, haben wir $p-1$ mal $a$, also:

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

Da $(p-1)!$ teilerfremd zu $p$ ist, können wir beide Seiten durch $(p-1)!$ teilen und erhalten schließlich den folgenden Satz:

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

Dies ist der Beweis für den kleinen Satz von Fermat.

4. Eulersche Phi-Funktion und der Satz von Euler

Der kleine Satz von Fermat ist ein Satz über “Primzahlen $p$”, aber Leonhard Euler verallgemeinerte ihn für “beliebige positive ganze Zahlen $n$”. Diese Erweiterung ist entscheidend, um die RSA-Verschlüsselung zu verstehen.

4.1 Die Eulersche Phi-Funktion $\phi(n)$

Die Eulersche Phi-Funktion (oder Eulersche Totientenfunktion) $\phi(n)$ ist eine Funktion, die die “Anzahl der ganzen Zahlen von $1$ bis $n$, die teilerfremd zu $n$ sind”, angibt.

Für eine Primzahl $p$ sind alle ganzen Zahlen von $1$ bis $p-1$ teilerfremd zu $p$, also ist $\phi(p) = p - 1$.
Für zwei verschiedene Primzahlen $p$ und $q$ und deren Produkt $n = p \times q$ kann $\phi(n)$ mit einer sehr einfachen Formel berechnet werden: $$ \phi(p \times q) = \phi(p) \times \phi(q) = (p - 1)(q - 1) $$

Diese Eigenschaft ist die Kernlogik bei der Schlüsselgenerierung für die RSA-Verschlüsselung.

4.2 Der Satz von Euler

Euler verallgemeinerte den kleinen Satz von Fermat wie folgt:

Satz von Euler (Euler’s Theorem) Für eine positive ganze Zahl $n$ und eine zu ihr teilerfremde ganze Zahl $a$ gilt:
$$ a^{\phi(n)} \equiv 1 \pmod n $$

Wenn $n$ eine Primzahl $p$ ist, dann ist $\phi(p) = p - 1$, also ist dies genau der kleine Satz von Fermat ($a^{p-1} \equiv 1 \pmod p$). Der kleine Satz von Fermat ist also nur ein Spezialfall des Satzes von Euler.

5. Riesige Primzahlen finden: Der Fermat-Primzahltest

In der Kryptographie (wie bei der RSA-Verschlüsselung und dem Diffie-Hellman-Schlüsselaustausch) ist es notwendig, schnell “riesige Primzahlen” mit hunderten von Ziffern zu finden. Um jedoch zu testen, ob eine riesige Zahl $N$ prim ist, würde die Methode der “Probedivision”, bei der man versucht, durch alle Zahlen von $2$ bis $\sqrt{N}$ zu teilen, etwa so lange dauern wie das Alter des Universums.

Hier kommt der Fermat-Primzahltest (Fermat Primality Test) ins Spiel, ein “probabilistischer Primzahltest”, der den kleinen Satz von Fermat umkehrt.

5.1 Was ist ein probabilistischer Primzahltest?

Nach dem kleinen Satz von Fermat gilt, wenn $p$ eine Primzahl ist, für jedes $a$ ($1 < a < p$) immer $a^{p-1} \equiv 1 \pmod p$. Wenn wir die Kontraposition davon nehmen, können wir sagen: “Wenn es ein $a$ gibt, für das $a^{p-1} \not\equiv 1 \pmod p$ ist, dann ist $p$ absolut keine Primzahl (es ist eine zusammengesetzte Zahl)”.

Wenn wir also testen wollen, ob $N$ prim ist, wählen wir zufällig einige $a$ und berechnen $a^{N-1} \pmod N$, um zu sehen, ob das Ergebnis $1$ ist. Wenn wir auch nur einmal ein anderes Ergebnis als $1$ erhalten, ist mit Sicherheit bestätigt, dass $N$ eine zusammengesetzte Zahl ist. Wenn das Ergebnis nach vielen Versuchen immer $1$ ist, können wir mit hoher Wahrscheinlichkeit schlussfolgern, dass $N$ “wahrscheinlich eine Primzahl ist”.

5.2 Erklärung des Algorithmus und Flussdiagramm

Der Algorithmus für den Fermat-Test ist wie folgt:

flowchart TD Start["Start"] --> Input["Zahl p zum Testen und Anzahl der Tests k eingeben"] Input --> LoopStart["Schleife von i = 0 bis k-1"] LoopStart --> Condition{"i < k ?"} Condition -- "Ja" --> RandomA["Wähle zufällige ganze Zahl a im Bereich 1 < a < p-1"] RandomA --> Calc["Berechne modulares Potenzieren a^(p-1) mod p"] Calc --> CheckPrime{"Ist das Ergebnis 1?"} CheckPrime -- "Nein" --> ReturnComposite["p ist eine zusammengesetzte Zahl (bestätigt)"] CheckPrime -- "Ja" --> Increment["Erhöhe i"] Increment --> Condition Condition -- "Nein" --> ReturnPrime["p ist wahrscheinlich eine Primzahl (probabilistisch)"] ReturnComposite --> End["Ende"] ReturnPrime --> End

5.3 Die Falle der Carmichael-Zahlen (Pseudoprimzahlen)

Der Fermat-Test ist sehr schnell, hat aber einen großen Fehler. Es gibt teuflische Zahlen, die zusammengesetzt sind, aber dennoch $a^{N-1} \equiv 1 \pmod N$ für alle $a$ erfüllen. Diese werden Carmichael-Zahlen (Carmichael numbers) genannt. Die kleinste Carmichael-Zahl ist $561$ ($3 \times 11 \times 17$).

Aufgrund der Existenz von Carmichael-Zahlen kann ein reiner Fermat-Test allein keinen absoluten Primzahltest garantieren. Daher verwenden reale Verschlüsselungssysteme (wie OpenSSL) standardmäßig den Miller-Rabin-Primzahltest, der eine Verbesserung des Fermat-Tests darstellt. Der Miller-Rabin-Test kann Carmichael-Zahlen erkennen, wodurch die Wahrscheinlichkeit eines falschen Ergebnisses praktisch auf Null reduziert wird.

5.4 Schnelles modulares Potenzieren (Binäre Exponentiation)

Im Primzahltestalgorithmus müssen wir $a^{N-1} \pmod N$ berechnen. Wenn $N$ riesig ist, hat $a^{N-1}$ eine astronomische Anzahl von Ziffern und passt nicht in den Speicher des Computers. Die Lösung dafür ist die binäre Exponentiation (Exponentiation by Squaring) oder das modulare Potenzieren. Durch das Modulo (mod N) bei jedem Schritt der Berechnung wird der Wert immer kleiner als $N$ gehalten, und die Berechnung wird sehr schnell möglich (Zeitkomplexität $O(\log N)$).

6. Implementierung von Primzahltest und modularem Potenzieren

Lassen Sie uns nun den Fermat-Primzahltest und die binäre Exponentiation in C++ und Python implementieren.

6.1 Implementierung in C++

In C++ laufen Standard-Ganzzahltypen leicht über, daher ist eine Big-Integer-Bibliothek (wie GMP) erforderlich, um riesige Zahlen zu handhaben. Aber hier zeigen wir eine Implementierung innerhalb des Bereichs von 64-Bit-Ganzzahlen (unsigned long long), um den Algorithmus zu verstehen.

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


#include <iostream>
#include <random>

using namespace std;

// Schnelles modulares Potenzieren (a^b mod m) - Binäre Exponentiation
unsigned long long power_mod(unsigned long long a, unsigned long long b, unsigned long long m) {
 unsigned long long result = 1;
 a = a % m;
 while (b > 0) {
 // Wenn das niedrigstwertige Bit von b 1 ist, multipliziere das Ergebnis mit a
 if (b % 2 == 1) {
 result = (__int128)result * a % m; // 128-Bit-Erweiterung zur Vermeidung von Überlauf
 }
 // a quadrieren
 a = (__int128)a * a % m;
 // b nach rechts verschieben (halbieren)
 b /= 2;
 }
 return result;
}

// Fermat-Primzahltest
bool fermat_is_prime(unsigned long long p, int iterations = 5) {
 if (p <= 1) return false;
 if (p <= 3) return true;
 if (p % 2 == 0) return false;

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

 for (int i = 0; i < iterations; ++i) {
 unsigned long long a = dis(gen);
 // Wenn a^(p-1) mod p nicht 1 ist, ist es eine zusammengesetzte Zahl
 if (power_mod(a, p - 1, p) != 1) {
 return false;
 }
 }
 return true; // Wahrscheinlich prim
}

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

6.2 Implementierung in Python

Der Standard-Ganzzahltyp von Python unterstützt beliebig große Zahlen, sodass Sie sich keine Sorgen über einen Überlauf machen müssen. Darüber hinaus verwendet die in Python integrierte Funktion pow(a, b, m) intern die binäre Exponentiation und ist sehr schnell.

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


import random

def fermat_is_prime(p, iterations=5):
 """
 Probabilistischer Primzahltest unter Verwendung des Fermat-Primzahltests
 """
 if p <= 1:
 return False
 if p <= 3:
 return True
 if p % 2 == 0:
 return False

 for _ in range(iterations):
 # Wähle eine zufällige Zahl a zwischen 2 und p-2
 a = random.randint(2, p - 2)
 # Berechne a^(p-1) mod p. Das integrierte pow ist schnell.
 if pow(a, p - 1, p) != 1:
 return False # Bestätigt zusammengesetzt

 return True # Wahrscheinlich prim

# Test
number_to_test = 104729
if fermat_is_prime(number_to_test, 10):
 print(f"{number_to_test} ist wahrscheinlich prim.")
else:
 print(f"{number_to_test} ist zusammengesetzt.")

7. Anwendung auf die RSA-Verschlüsselung: Wo Fermat und Euler zusammenkommen

Die großartigste Anwendung des kleinen Satzes von Fermat (und des Satzes von Euler) ist die RSA-Verschlüsselung, die 1977 von Rivest, Shamir und Adleman entwickelt wurde. Die RSA-Verschlüsselung ist ein revolutionäres “Public-Key-Kryptographie”-System, das es ermöglicht, den Schlüssel zur Verschlüsselung (öffentlicher Schlüssel) der ganzen Welt zugänglich zu machen, während nur der Empfänger den Schlüssel zur Entschlüsselung (privater Schlüssel) kennt.

Diese Asymmetrie beruht auf der rechnerischen Sicherheit der Tatsache, dass “es extrem schwierig ist, eine riesige zusammengesetzte Zahl in ihre Primfaktoren zu zerlegen”.

7.1 Wie die RSA-Verschlüsselung funktioniert (Schlüsselgenerierung, Verschlüsselung, Entschlüsselung)

Lassen Sie uns den gesamten Kommunikationsfluss der RSA-Verschlüsselung anhand eines Mermaid-Sequenzdiagramms untersuchen.

sequenceDiagram participant Alice["Alice (Empfänger)"] participant Bob["Bob (Sender)"] Alice->>Alice: "Generiere riesige Primzahlen p, q" Alice->>Alice: "Berechne N = p * q, φ(N) = (p-1)(q-1)" Alice->>Alice: "Berechne öffentlichen Schlüssel e und privaten Schlüssel d (e*d ≡ 1 mod φ(N))" Alice->>Bob: "Sende öffentlichen Schlüssel (N, e)" Note over Bob: "Bereite Klartext M vor (M < N)" Bob->>Bob: "Berechne Geheimtext C = M^e mod N" Bob->>Alice: "Sende Geheimtext C" Alice->>Alice: "Entschlüssele durch Berechnen des Klartextes M = C^d mod N"

Im Folgenden erklären wir die mathematischen Schritte im Detail.

Schritt 1: Schlüsselgenerierung (Arbeit der Empfängerin Alice)

Generiere zufällig zwei riesige Primzahlen $p$ und $q$ (hier wird der zuvor erwähnte Primzahltest verwendet).
Berechne ihr Produkt $N = p \times q$. Dieses $N$ wird veröffentlicht.
Berechne $\phi(N) = (p-1)(q-1)$ unter Verwendung der Eulerschen Phi-Funktion.
Wähle eine ganze Zahl $e$ (öffentlicher Exponent), die teilerfremd zu $\phi(N)$ ist (oft wird $e = 65537$ verwendet).
Berechne das modulare Inverse $d$ (privater Exponent) von $e$. Finde also $d$ so, dass Folgendes gilt: $$ e \cdot d \equiv 1 \pmod{\phi(N)} $$ Für diese Berechnung wird der erweiterte euklidische Algorithmus verwendet.

Der öffentliche Schlüssel ist somit $(N, e)$ und der private Schlüssel ist $(N, d)$. ($p, q$ und $\phi(N)$ sollten sofort vernichtet oder streng geheim gehalten werden).

Schritt 2: Verschlüsselung (Arbeit des Senders Bob)

Nehmen wir an, Bob möchte die Nachricht $M$ an Alice senden ($M$ ist eine numerische Darstellung von Zeichen, und $0 \le M < N$). Bob verwendet Alices öffentlichen Schlüssel $(N, e)$, um die folgende Berechnung durchzuführen und den Geheimtext $C$ zu erstellen:

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

Dieser $C$ wird über das Netzwerk an Alice gesendet.

Schritt 3: Entschlüsselung (Arbeit der Empfängerin Alice)

Nach Erhalt des Geheimtextes $C$ führt Alice die folgende Berechnung unter Verwendung des privaten Schlüssels $d$ durch, den nur sie kennt:

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

Erstaunlicherweise stimmt das Ergebnis dieser Berechnung $M'$ perfekt mit der ursprünglichen Nachricht $M$ überein.

7.2 Warum kann es entschlüsselt werden? (Mathematischer Beweis)

Hier zeigen der kleine Satz von Fermat (und der Satz von Euler) ihren wahren Wert. Warum kehrt $C^d \pmod N$ zu $M$ zurück?

Lassen Sie uns die Entschlüsselungsformel erweitern. Da $C \equiv M^e \pmod N$, haben wir:

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

Im Schritt der Schlüsselgenerierung haben wir $d$ so gewählt, dass $e \cdot d \equiv 1 \pmod{\phi(N)}$. Das bedeutet, es gibt eine ganze Zahl $k$, sodass wir schreiben können:

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

Setzen wir dies in die obige Gleichung ein:

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

Hier kommt der Satz von Euler ($M^{\phi(N)} \equiv 1 \pmod N$) ins Spiel. (Streng genommen müssen $M$ und $N$ teilerfremd sein, aber in RSA ist die Wahrscheinlichkeit, dass $M$ und $N$ nicht teilerfremd sind, astronomisch gering, und mithilfe des Chinesischen Restsatzes kann bewiesen werden, dass es auch gilt, wenn sie nicht teilerfremd sind).

Wenden wir den Satz von Euler an, da $M^{\phi(N)} \equiv 1$ ist:

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

Hervorragend, $M$ wurde wiederhergestellt! Die Eigenschaften von Zahlen, die von Fermat und Euler vor Hunderten von Jahren entdeckt wurden, garantieren perfekt die Vertraulichkeit der modernen digitalen Kommunikation.

8. Spielzeug-Implementierung der RSA-Verschlüsselung (Python)

Da es schwer ist, ein Gefühl nur für die Theorie zu bekommen, verwenden wir Python, um den Prozess der RSA-Schlüsselgenerierung, Verschlüsselung und Entschlüsselung tatsächlich zu implementieren. Dies ist eine “Spielzeug-Implementierung” für Bildungszwecke, aber die verwendete Mathematik ist genau dieselbe wie bei der echten.

Wir fügen auch den “erweiterten euklidischen Algorithmus” hinzu, um das modulare Inverse $d$ zu finden.

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


import random

# Größten gemeinsamen Teiler finden
def gcd(a, b):
 while b != 0:
 a, b = b, a % b
 return a

# Erweiterter euklidischer Algorithmus (findet x, y für ax + by = gcd(a,b))
# Verwendet, um d für e*d ≡ 1 (mod φ(N)) zu finden
def extended_gcd(a, b):
 if a == 0:
 return (b, 0, 1)
 else:
 g, y, x = extended_gcd(b % a, a)
 return (g, x - (b // a) * y, y)

def mod_inverse(e, phi):
 g, x, y = extended_gcd(e, phi)
 if g != 1:
 raise Exception('Inverses existiert nicht')
 else:
 return x % phi

# Primzahl-Generierungsfunktion (Vereinfachte Version: generiert kleine Primzahlen)
def generate_prime(bits):
 while True:
 p = random.getrandbits(bits)
 # Einfacher Test anstelle des zuvor erwähnten Fermat-Tests
 if p > 1 and pow(2, p-1, p) == 1 and pow(3, p-1, p) == 1:
 return p

# RSA-Schlüsselgenerierung
def generate_keypair(bits=16):
 p = generate_prime(bits)
 q = generate_prime(bits)
 # Stellen Sie sicher, dass p und q nicht gleich sind
 while p == q:
 q = generate_prime(bits)

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

 # Für e werden oft Primzahlen wie 65537 verwendet, aber hier wird es zufällig gewählt
 e = random.randrange(1, phi)
 g = gcd(e, phi)
 while g != 1:
 e = random.randrange(1, phi)
 g = gcd(e, phi)

 # Berechnung des privaten Schlüssels d
 d = mod_inverse(e, phi)

 # Öffentlicher Schlüssel (e, n), Privater Schlüssel (d, n)
 return ((e, n), (d, n))

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

def decrypt(sk, ciphertext):
 d, n = sk
 # Berechne cipher^d mod n und konvertiere zurück in Zeichen
 plain = [chr(pow(char, d, n)) for char in ciphertext]
 return ''.join(plain)

# Ausführungsbeispiel
if __name__ == '__main__':
 print("--- RSA-Verschlüsselung Spielzeug-Implementierung ---")
 public_key, private_key = generate_keypair(bits=12) # Verwendet 12-Bit-Primzahlen

 print(f"Öffentlicher Schlüssel (e, n): {public_key}")
 print(f"Privater Schlüssel (d, n): {private_key}")

 message = "Hello Math!"
 print(f"\nUrsprüngliche Nachricht: {message}")

 # Verschlüsselung
 encrypted_msg = encrypt(public_key, message)
 print(f"Geheimtext: {encrypted_msg}")

 # Entschlüsselung
 decrypted_msg = decrypt(private_key, encrypted_msg)
 print(f"Entschlüsselte Nachricht: {decrypted_msg}")

Wenn Sie diesen Code ausführen, können Sie sehen, wie ein Array von Zeichen in ein Array unvertrauter Zahlen (Geheimtext) umgewandelt wird, welches durch den privaten Schlüssel wunderschön in den ursprünglichen String wiederhergestellt wird.

9. Fazit: Die Kreuzung von mathematischer Schönheit und Praktikabilität

Als Pierre de Fermat im 17. Jahrhundert diesen “kleinen Satz” entdeckte, dachte niemand, dass er für irgendetwas nützlich sein würde. Fermat selbst betrieb zahlentheoretische Forschung aus reiner mathematischer Neugier.

Etwa 300 Jahre später, in den 1970er Jahren, an den Anfängen von Computernetzwerken, feierte der Satz von Fermat jedoch ein dramatisches Comeback als unverzichtbare Verschlüsselungstechnologie zur Etablierung sicherer Kommunikationsprotokolle. Die Primzahltesttechnologie, die auf dem kleinen Satz von Fermat basiert, und die RSA-Verschlüsselung, die auf dem Satz von Euler basiert, stützen buchstäblich die moderne Internet-Infrastruktur.

Die LINE-Nachrichten, die wir jeden Tag beiläufig senden, und unsere Einkäufe bei Amazon tanzen alle auf dieser einfachen und schönen Formel $a^{p-1} \equiv 1 \pmod p$. Egal wie abstrakt Mathematik ist, der kleine Satz von Fermat lehrt uns, dass immer die Zeit kommen wird, in der sie für die Menschheit nützlich sein wird.

Beim Erlernen von Programmierung und Kryptographietheorie wird das Verständnis der zugrunde liegenden mathematischen Strukturen eine starke Waffe sein, um das Verhalten von Bibliotheken, die als Blackboxes bereitgestellt werden, tiefgreifend zu verstehen und sicherere Systeme zu entwerfen.

Die Riemannsche Vermutung und die Verteilung der Primzahlen: Die tiefe Verbindung zur modernen Kryptographie

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

1. Einleitung: Das Geheimnis des Universums der Primzahlen und die Riemannsche Vermutung

“Primzahlen” (Prime Numbers) sind natürliche Zahlen, die nur durch 1 und sich selbst teilbar sind, und werden auch als die “Atome” der Mathematik bezeichnet. Die Folge 2, 3, 5, 7, 11, 13… scheint auf den ersten Blick unordentlich und zufällig aufzutreten. Seit der antike griechische Mathematiker Euklid bewiesen hat, dass “es unendlich viele Primzahlen gibt”, haben unzählige Mathematiker versucht, die verborgenen Gesetzmäßigkeiten in dieser Anordnung von Primzahlen zu entschlüsseln.

Am nächsten an dieses Rätsel der Primzahlen kam die 1859 von dem deutschen Mathematiker Bernhard Riemann aufgestellte “Riemannsche Vermutung” (Riemann Hypothesis) heran. Die Riemannsche Vermutung ist eines der wichtigsten und ungelösten Probleme der modernen Mathematik und als eines der Millennium-Probleme des Clay Mathematics Institute mit einem Preisgeld von einer Million Dollar dotiert.

Auf den ersten Blick mag ein Problem der reinen Mathematik über die Verteilung von Primzahlen nichts mit unserem Alltag zu tun haben. Die Sicherheit des Internets, das die Infrastruktur der modernen Gesellschaft stützt, insbesondere moderne Verschlüsselungstechnologien wie die RSA-Kryptographie und die Elliptische-Kurven-Kryptographie (ECC), hängt jedoch stark von den Eigenschaften riesiger Primzahlen ab.

In diesem Artikel begeben wir uns auf eine mathematische Reise von der Verteilung der Primzahlen über den Primzahlsatz und die Riemannsche Zeta-Funktion bis hin zum Kern der Riemannschen Vermutung. Wir werden extrem detailliert und tiefgreifend erklären, wie all dies mit der modernen Kryptographie verbunden ist und was mit der Welt passieren würde, wenn die Riemannsche Vermutung bewiesen werden sollte.

2. Der Primzahlsatz und die Verteilung der Primzahlen: Die Entdeckung von Gauss

Um zu verstehen, wie Primzahlen verteilt sind, betrachteten Mathematiker die Primzahlzählfunktion (Prime-counting function) $\pi(x)$, die angibt, “wie viele Primzahlen kleiner oder gleich einer bestimmten Zahl $x$ existieren”.

Zum Beispiel:

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

Der 15-jährige geniale Mathematiker Carl Friedrich Gauss berechnete umfangreiche Primzahltabellen und fand heraus, dass die Häufigkeit des Auftretens von Primzahlen umgekehrt proportional zum natürlichen Logarithmus $\ln x$ abnimmt. Das heißt, er vermutete, dass die Wahrscheinlichkeit, eine Primzahl in der Nähe einer bestimmten Zahl $x$ zu finden, etwa $\frac{1}{\ln x}$ beträgt.

Dies wird mit Hilfe eines Integrals als Integrallogarithmus (Logarithmic integral) $\text{Li}(x)$ ausgedrückt:

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

Die Vermutung von Gauss wurde später 1896 von Jacques Hadamard und Charles-Jean de La Vallée Poussin unabhängig voneinander bewiesen und als Primzahlsatz (Prime Number Theorem, PNT) etabliert.

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

Oder näherungsweise wie folgt ausgedrückt:

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

Durch diesen Satz wurde klar, dass Primzahlen makroskopisch betrachtet eine sehr glatte und vorhersehbare Verteilung aufweisen. Mikroskopisch betrachtet gibt es jedoch immer einen “Fehler” oder eine “Schwankung” zwischen $\pi(x)$ und $\text{Li}(x)$. Die wahre Natur dieser Schwankung ist das größte Rätsel, das die Riemannsche Vermutung zu lösen versucht.

3. Die Riemannsche Zeta-Funktion und das Euler-Produkt

Die stärkste Waffe bei der Analyse der Verteilung von Primzahlen ist die Riemannsche Zeta-Funktion (Riemann Zeta Function). Ursprünglich war es eine unendliche Reihe, die von Leonhard Euler für reelle Zahlen $s > 1$ definiert wurde.

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

Eine der größten Errungenschaften Eulers war der Beweis, dass diese unendliche Reihe als unendliches Produkt über alle Primzahlen $p$ dargestellt werden kann. Dies ist das Euler-Produkt (Euler Product Formula).

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

Ein intuitives Verständnis des Beweises ist, dass wenn man jeden Term auf der rechten Seite als geometrische Reihe entwickelt und diese miteinander multipliziert, aufgrund des Fundamentalsatzes der Arithmetik (jede natürliche Zahl kann eindeutig als Produkt von Primzahlen dargestellt werden) die Summe der Kehrwerte der natürlichen Zahlen auf der linken Seite vollständig rekonstruiert wird.

Diese einzige Formel wurde zur Brücke zwischen der Analysis (unendliche Reihen, stetige Funktionen) und der Zahlentheorie (Primzahlen, diskrete Zahlen). Die Untersuchung der Zeta-Funktion ist gleichbedeutend mit der Untersuchung der Verteilung der Primzahlen.

4. Analytische Fortsetzung und die Erweiterung auf die komplexe Zahlenebene

Riemanns Genialität lag darin, dass er die Variable $s$ von $\zeta(s)$, die Euler nur für reelle Zahlen betrachtete, auf komplexe Zahlen $s = \sigma + it$ ($\sigma$ ist der Realteil, $t$ ist der Imaginärteil) erweiterte.

Die ursprüngliche unendliche Reihe konvergiert nur für $\sigma > 1$, aber Riemann nutzte eine Methode namens “analytische Fortsetzung (Analytic Continuation)”, um die Definition so zu erweitern, dass $\zeta(s)$ auf der gesamten komplexen Zahlenebene, mit Ausnahme des Pols bei $s = 1$, sinnvoll ist.

Er leitete außerdem eine wunderschöne Funktionalgleichung (Functional equation) ab, die die Zeta-Funktion erfüllt.

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

Hierbei ist $\Gamma(x)$ die Gamma-Funktion. Durch diese Gleichung können wir die Eigenschaften der linken Halbebene aus den Eigenschaften der rechten Halbebene ableiten.

Nullstellen (Zeros of the Zeta Function)

Komplexe Zahlen $s$, für die der Wert der Zeta-Funktion 0 wird, nennt man “Nullstellen”. Aus der Funktionalgleichung ergibt sich, dass für negative gerade Zahlen $s$ ($-2, -4, -6, \dots$) $\sin(\pi s / 2)$ zu 0 wird, also $\zeta(s) = 0$. Diese werden triviale Nullstellen (Trivial zeros) genannt.

Was jedoch für die Verteilung der Primzahlen wichtig ist, sind die anderen Nullstellen, nämlich die nicht-trivialen Nullstellen (Non-trivial zeros), die im “kritischen Streifen (Critical strip)” von $0 \le \sigma \le 1$ liegen.

5. Der Kern der Riemannschen Vermutung und die explizite Formel

Riemann berechnete eine kleine Anzahl von Nullstellen und stellte eine erstaunliche Vermutung auf. Dies ist die Riemannsche Vermutung.

Riemannsche Vermutung (Riemann Hypothesis) Alle nicht-trivialen Nullstellen der Riemannschen Zeta-Funktion $\zeta(s)$ liegen auf der Geraden, deren Realteil $1/2$ ist ($\text{Re}(s) = 1/2$).

Diese Gerade, deren Realteil 1/2 ist, wird als “kritische Gerade (Critical line)” bezeichnet.

graph TD A["Riemannsche Zeta-Funktion ζ(s)"] --> B["Erweiterung auf die komplexe Ebene durch analytische Fortsetzung"] B --> C["Triviale Nullstellen (s = -2, -4, -6 ...)"] B --> D["Nicht-triviale Nullstellen (0 <= Re(s) <= 1)"] D --> E["Riemannsche Vermutung"] E --> F["Alle nicht-trivialen Nullstellen liegen auf Re(s) = 1/2"] F --> G["Zum Beweis des Grenzwerts des Fehlerterms in der Primzahlverteilung"]

Warum ist die Riemannsche Vermutung so wichtig? Weil die Nullstellen der Zeta-Funktion die Verteilung der Primzahlen vollständig bestimmen.

Riemann und der spätere Mathematiker von Mangoldt leiteten eine “explizite Formel (Explicit formula)” ab, die die Verteilung der Primzahlen genau beschreibt. Unter Verwendung der Tschebyschow-Funktion $\psi(x)$ lässt sie sich wie folgt ausdrücken:

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

Hierbei ist $\rho$ die Summe über alle nicht-trivialen Nullstellen der Zeta-Funktion. Der Hauptterm ist $x$ (der dem Primzahlsatz entspricht), und durch Addition und Subtraktion von wellenartigen Termen, die von den Nullstellen $\rho$ abhängen, wird die genaue treppenförmige Verteilung der Primzahlen wiederhergestellt. Man kann sagen, dass die nicht-trivialen Nullstellen die “Frequenzen (Wellen)” der Primzahlverteilung darstellen.

Wenn die Riemannsche Vermutung wahr ist und der Realteil aller nicht-trivialen Nullstellen $\rho$ genau $1/2$ beträgt, dann wird der Fehlerterm des Primzahlsatzes theoretisch auf den kleinstmöglichen Bereich beschränkt sein.

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

Das bedeutet: Wenn die Riemannsche Vermutung wahr ist, wird bewiesen sein, dass Primzahlen auf die “regelmäßigste und schönste” Weise verteilt sind, die wir uns vorstellen können.

6. Die untrennbare Beziehung zwischen der modernen Kryptographie und Primzahlen

Bisher befanden wir uns in der Welt der tiefgründigen reinen Mathematik, aber diese Eigenschaften von Primzahlen stützen die moderne digitale Gesellschaft grundlegend. Der repräsentativste Vertreter dafür ist die Public-Key-Kryptographie wie die RSA-Kryptographie.

Die Sicherheit jeglicher Kommunikation, von Kreditkartenzahlungen im Internet über das Senden von Passwörtern bis hin zu digitalen Signaturen der Blockchain, hängt von “Primzahlen” ab.

Funktionsweise der RSA-Kryptographie

Die Sicherheit der RSA-Kryptographie beruht auf der mathematischen Tatsache, dass “die Primfaktorzerlegung großer zusammengesetzter Zahlen sehr schwierig ist” (Primfaktorzerlegungsproblem).

Schlüsselerzeugung (Key generation): Zwei riesige Primzahlen $p$ und $q$ (z.B. jeweils 2048 Bit) werden zufällig ausgewählt. Sie werden miteinander multipliziert, um $N = p \times q$ zu berechnen. Dieses $N$ wird Teil des öffentlichen Schlüssels. Unter Verwendung der Eulerschen Phi-Funktion $\phi(N) = (p-1)(q-1)$ wird der private Schlüssel $d$ generiert.
$$ e \times d \equiv 1 \pmod{\phi(N)} $$
Verschlüsselung und Entschlüsselung: Der Klartext $M$ wird mit dem öffentlichen Schlüssel $e, N$ in einen Geheimtext $C$ umgewandelt.
$$ C \equiv M^e \pmod{N} $$
Nur derjenige mit dem privaten Schlüssel $d$ kann ihn entschlüsseln.
$$ M \equiv C^d \pmod{N} $$

graph LR A["Klartext (Plaintext)"] --> B["Verschlüsselung mit öffentlichem Schlüssel (e, N)"] B --> C["Geheimtext (Ciphertext)"] C --> D["Entschlüsselung mit privatem Schlüssel (d)"] D --> E["Ursprünglicher Klartext"] F["Angreifer (Attacker)"] -- "Versucht die Primfaktorzerlegung von N" --> C F -.-> G["Ohne p und q ist d unberechenbar"]

Um die RSA-Kryptographie zu brechen, müssen aus dem riesigen $N$ die ursprünglichen Primzahlen $p$ und $q$ gefunden werden (Primfaktorzerlegung). Es wird geschätzt, dass selbst mit Supercomputern und der Verwendung derzeit gängiger Algorithmen (wie dem Zahlkörpersieb: GNFS) die Primfaktorzerlegung von Zahlen mit hunderten von Ziffern weitaus länger dauern würde als das Alter des Universums.

7. Die Auswirkungen der Riemannschen Vermutung auf die Kryptographie

Wie kreuzen sich also die “Riemannsche Vermutung”, der Gipfel der reinen Mathematik, und die “Kryptographie”?

7.1. Primzahlengenerierungsalgorithmen (Primzahltest) und die Erweiterte Riemannsche Vermutung (GRH)

Um die RSA-Kryptographie zu betreiben, müssen zuerst die riesigen Primzahlen $p$ und $q$ generiert werden. Es ist jedoch nicht einfach, zuverlässig und schnell zu bestimmen, “ob eine bestimmte Zahl eine Primzahl ist”.

Gegenwärtig wird in der Praxis der Miller-Rabin-Primzahltest (Miller-Rabin primality test), ein probabilistischer Algorithmus, verwendet. Dieser Algorithmus ist schnell, birgt jedoch das Risiko von “Pseudoprimzahlen”, d.h., dass eine zusammengesetzte Zahl mit extrem geringer Wahrscheinlichkeit fälschlicherweise als Primzahl identifiziert wird.

Wenn wir jedoch annehmen, dass die “Erweiterte Riemannsche Vermutung” (Generalized Riemann Hypothesis, GRH), die die Riemannsche Vermutung auf die Dirichletschen L-Funktionen erweitert, wahr ist, ändert sich die Situation dramatisch. Wenn GRH wahr ist, wird eine obere Schranke für die Anzahl der Tests im Miller-Rabin-Verfahren mathematisch garantiert, und der probabilistische Algorithmus wird zu einem “deterministischen Polynomialzeitalgorithmus” sublimiert (dies war eine wichtige Tatsache, die bereits vor der Entdeckung des AKS-Primzahltests bekannt war).

Das heißt, die Riemannsche Vermutung (und ihre Erweiterung) spielt die Rolle einer direkten Garantie für die Generierung der Grundlage der Kryptographie: “Können riesige Primzahlen mit absoluter Zuverlässigkeit und hoher Geschwindigkeit generiert werden?”.

7.2. Beziehung zu Primfaktorzerlegungsalgorithmen

Bei der Bewertung der Komplexität von Algorithmen zur Entschlüsselung (wie dem Zahlkörpersieb) ist das Wissen über die Verteilung von Primzahlen ebenfalls unerlässlich. Viele Primfaktorzerlegungsalgorithmen basieren auf der Verteilung “glatter Zahlen (Smooth numbers: Zahlen, die nur kleine Primfaktoren haben)”.

Um genau beurteilen zu können, wie oft glatte Zahlen auftreten, ist ein tiefes Verständnis der Primzahlverteilung erforderlich, und auch hier kommen Techniken der analytischen Zahlentheorie zum Einsatz, die direkt mit der Zeta-Funktion und der Riemannschen Vermutung verbunden sind. Wenn die Riemannsche Vermutung bewiesen ist und der Fehler in der Primzahlverteilung vollständig bestimmt ist, wird es möglich sein, die Leistungsgrenzen von Primfaktorzerlegungsalgorithmen genauer zu bestimmen.

8. Wenn die Riemannsche Vermutung bewiesen wird, wird die Kryptographie gebrochen?

Wie eine urbane Legende wird oft erzählt: “Wenn die Riemannsche Vermutung gelöst ist, wird die RSA-Kryptographie in einem Augenblick zusammenbrechen”, aber das ist mathematisch inkorrekt.

Der Beweis der Riemannschen Vermutung selbst wird nicht sofort einen magischen Algorithmus hervorbringen, der die Primfaktorzerlegung drastisch beschleunigt. Die Riemannsche Vermutung ist nur ein Theorem über die “makroskopische Regelmäßigkeit der Verteilung” von Primzahlen und sagt uns nicht direkt, durch welche Primzahlen eine bestimmte Zahl $N$ teilbar ist (lokale Eigenschaften).

Die Auswirkungen sind jedoch nicht null. Es ist extrem wahrscheinlich, dass während des Prozesses des Beweises der Riemannschen Vermutung “neue mathematische Werkzeuge” oder “unbekannte Analysemethoden” entdeckt werden. Die Geschichte zeigt, dass bei Beweisen wie dem Großen Fermatschen Satz oder der Poincaré-Vermutung neue Theorien entwickelt wurden, die die gesamte Mathematik maßgeblich vorangebracht haben.

Sollten unbekannte Methoden der algebraischen Geometrie oder der nichtkommutativen Geometrie etabliert werden, die die Eigenschaften der Nullstellen der Riemannschen Zeta-Funktion vollständig manipulieren können, lässt sich nicht leugnen, dass dies zur Entdeckung eines bahnbrechenden Algorithmus zur Primfaktorzerlegung führen könnte (z.B. ein klassischer Algorithmus, der die Komplexität auf Polynomzeit reduziert). In diesem Sinne können Kryptographen ihre Augen niemals von den Entwicklungen rund um die Riemannsche Vermutung abwenden.

Quantencomputer und Shors Algorithmus

Eine direktere und realistischere Bedrohung für die Kryptographie ist nicht der Beweis der Riemannschen Vermutung, sondern Quantencomputer. Der 1994 von Peter Shor veröffentlichte “Shor-Algorithmus” bewies, dass ein Quantencomputer mit ausreichender Leistung die Primfaktorzerlegung in Polynomzeit lösen kann. Dies würde die RSA-Kryptographie und die Elliptische-Kurven-Kryptographie grundlegend brechen.

Derzeit wird weltweit der Übergang zur “Post-Quanten-Kryptographie (Post-Quantum Cryptography, PQC)” (wie gitterbasierte Kryptographie) vorangetrieben, die selbst von Quantencomputern nicht geknackt werden kann. Die von Primzahlen abhängige Kryptographie könnte in gewissem Sinne ihr goldenes Zeitalter beenden, aber der mathematische Wert der Primzahlen selbst wird niemals verloren gehen.

9. Fazit: Die Kreuzung von mathematischer Abstraktion und der realen Gesellschaft

graph TD A["Erforschung der reinen Mathematik"] --> B["Aufklärung der Riemannschen Vermutung"] B --> C["Vollständiges Verständnis der Primzahlverteilung"] C --> D["Sprunghafte Entwicklung der Zahlentheorie und algebraischen Geometrie"] D -.-> E["Möglichkeit neuer Primfaktorzerlegungsalgorithmen"] E -.-> F["Aktualisierung der Sicherheitsbewertung von Kryptographie"] A --> G["Angewandte Mathematik / Informatik"] G --> H["Effizienzsteigerung bei Primzahltests und Schlüsselgenerierung"] H --> F

Die unersättliche Suche nach Primzahlen, die in der griechischen Antike begann, wurde von dem Genie Riemann in eine wunderschöne Sinfonie (die Nullstellen der Zeta-Funktion) auf der komplexen Ebene sublimiert. Erstaunlicherweise wird dieser reine Kristall der Mathematik Jahrhunderte später als der stärkste Schild zum Schutz der Sicherheit der Internetgesellschaft angewendet.

Die Riemannsche Vermutung ist eine Existenz, die gleichzeitig die “abstrakte Schönheit” der Mathematik und ihre “erstaunliche Anwendbarkeit in der physischen Welt und der realen Gesellschaft” symbolisiert.

Wenn dieser riesige mathematische Berg, dessen Gipfel noch niemand erreicht hat, eines Tages bezwungen wird, werden wir die Wahrheit des Universums der Primzahlen vollständig verstehen und eine neue Perspektive auf die Grundlagen der Informationsgesellschaft gewinnen. Das Studium der Kryptographie ist auch eine Reise, die die Geschichte der menschlichen Weisheit nachzeichnet.

Schneller Primzahltest-Algorithmus in C++ implementiert (Miller-Rabin-Methode usw.)

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

Einleitung: Warum brauchen wir schnelle Primzahltests?

In der Informatik, der Kryptographie und im Bereich der kompetitiven Programmierung ist die schnelle und genaue Bestimmung, “ob eine gegebene Zahl prim ist”, eine sehr wichtige und grundlegende Aufgabe. Zum Beispiel beruht die Sicherheit von Public-Key-Kryptosystemen wie RSA, die die Grundlage der heutigen Internetsicherheit bilden, auf der Erzeugung riesiger Primzahlen und der Schwierigkeit ihrer Multiplikation (bzw. der Schwierigkeit der Primfaktorzerlegung). Daher ist es keine Übertreibung zu sagen, dass die Technologie zur sofortigen Identifizierung riesiger Primzahlen das Rückgrat unserer digitalen Gesellschaft bildet.

Auch beim kompetitiven Programmieren (wie AtCoder oder Codeforces) sind Primzahltests ein häufiges Thema. Wenn für riesige Eingaben mit Beschränkungen wie $N \le 10^{18}$ Zehntausende von Primzahltests in weniger als 1 Sekunde durchgeführt werden müssen, werden traditionelle, naive Algorithmen das Zeitlimit (Time Limit Exceeded: TLE) niemals einhalten.

In diesem Artikel werden wir von naiven Primzahltests über den “Fermat-Test”, einen probabilistischen Algorithmus, bis hin zum “Miller-Rabin-Primzahltest”, einem Hochgeschwindigkeitsalgorithmus auf praktisch höchstem Niveau, der die Schwächen des Fermat-Tests überwindet, alles ausführlich erklären – vom mathematischen Hintergrund bis hin zu einer hochgradig optimierten Implementierung in C++. Insbesondere für 64-Bit-Ganzzahlen ($N < 2^{64}$) werden wir nicht nur auf probabilistische Tests eingehen, sondern auch “100% sichere Primzahltests (deterministische Tests)” detailliert beschreiben und einen C++-Quellcode bereitstellen, der direkt in der Praxis verwendet werden kann.

1. Grundlagen der Primzahltests und Probedivision (Trial Division)

Eine Primzahl (Prime number) ist eine natürliche Zahl größer als 1, die außer 1 und sich selbst keine positiven Teiler hat. Folgt man strikt der Definition einer Primzahl, kann man feststellen, ob eine ganze Zahl $N$ eine Primzahl ist, indem man $N$ durch alle ganzen Zahlen von $2$ bis $N-1$ dividiert. Wenn sie durch keine dieser Zahlen teilbar ist, ist sie prim, andernfalls ist sie eine zusammengesetzte Zahl (keine Primzahl).

Diese Methode hat jedoch eine Zeitkomplexität von $O(N)$. Wenn $N$ eine riesige Zahl wie $10^{18}$ ist, würde selbst ein moderner Computer enorm viel Zeit für die Berechnung benötigen.

Optimierung der Probedivision: Suche bis $\sqrt{N}$

Wenn eine zusammengesetzte Zahl $N$ als $a \times b = N$ (mit $a \le b$) dargestellt wird, gilt immer $a \le \sqrt{N}$. Daher ist es nicht notwendig, die Schleife für den Primzahltest bis $N-1$ laufen zu lassen; es reicht aus, bis $\sqrt{N}$ zu prüfen.

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


#include <iostream>

// Primzahltest durch Probedivision (O(sqrt(N)))
bool is_prime_trial_division(long long n) {
 if (n <= 1) return false;
 if (n == 2 || n == 3) return true;
 if (n % 2 == 0) return false;

 // Nur ungerade Zahlen ab 3 prüfen
 for (long long i = 3; i * i <= n; i += 2) {
 if (n % i == 0) return false;
 }
 return true;
}

Die Zeitkomplexität dieses Algorithmus beträgt $O(\sqrt{N})$. Für $N \le 10^{12}$ kann die Berechnung im Bruchteil einer Sekunde durchgeführt werden. Bei $N \approx 10^{18}$ beträgt die Anzahl der Schleifendurchläufe jedoch etwa $10^9$, was selbst in C++ Hunderte von Millisekunden bis zu mehreren Sekunden dauert und somit für mehrfache Tests ungeeignet ist.

2. Fermat-Test: Der Beginn der probabilistischen Primzahltests

Um die Grenzen der Probedivision zu überwinden, wurden “probabilistische Algorithmen (Probabilistic Algorithm)” entwickelt, die zahlentheoretische Theoreme nutzen. Ein typisches Beispiel ist der “Fermat-Primzahltest (Fermat Primality Test)”, der den kleinen Fermatschen Satz anwendet.

Kleiner Fermatscher Satz (Fermat’s Little Theorem)

Dieser von Pierre de Fermat entdeckte Satz besagt Folgendes:

Für jede Primzahl $p$ und jede beliebige ganze Zahl $a$, die teilerfremd zu $p$ ist (kein Vielfaches von $p$), gilt die folgende Kongruenz:
$$ a^{p-1} \equiv 1 \pmod p $$

Die Kontraposition dieses Satzes besagt: “Wenn für eine ganze Zahl $N$ und eine zu $N$ teilerfremde ganze Zahl $a$ gilt $a^{N-1} \not\equiv 1 \pmod N$, dann ist $N$ definitiv eine zusammengesetzte Zahl.” Der Fermat-Test nutzt diese Eigenschaft, indem er für die zu testende Zahl $N$ eine zufällige Basis (base) $a$ wählt und überprüft, ob $a^{N-1} \pmod N$ den Wert $1$ ergibt.

Schnelle modulare Exponentiation (Binäre Exponentiation)

Um den Fermat-Test durchzuführen, müssen wir die riesige Potenz $a^{N-1} \pmod N$ schnell berechnen. Hierfür wird die “Binäre Exponentiation (Modular Exponentiation / Binary Exponentiation)” verwendet. Die Zeitkomplexität beträgt $O(\log N)$ und ist damit extrem schnell.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


// Berechnung von a^b mod m mittels binärer Exponentiation
long long mod_pow(long long a, long long b, long long m) {
 long long res = 1;
 a %= m;
 while (b > 0) {
 if (b & 1) res = (__int128_t)res * a % m;
 a = (__int128_t)a * a % m;
 b >>= 1;
 }
 return res;
}

Hier verwenden wir zur Vermeidung von Überläufen __int128_t (eine 128-Bit-Ganzzahl), eine Erweiterung von GCC/Clang, um Zwischenprodukte zu speichern.

Pseudoprimzahlen und Carmichael-Zahlen (Carmichael Numbers)

Der Fermat-Test ist sehr mächtig, hat jedoch eine fatale Schwäche. Es gibt Zahlen $N$, die zusammengesetzt sind, für die aber dennoch $a^{N-1} \equiv 1 \pmod N$ für alle $a$ (die zu $N$ teilerfremd sind) gilt.

Solche Zahlen werden “absolute Pseudoprimzahlen” oder “Carmichael-Zahlen” genannt. Die kleinste Carmichael-Zahl ist $561 = 3 \times 11 \times 17$. Aufgrund der Existenz von Carmichael-Zahlen kann der Fermat-Test allein keine 100%ige Sicherheit (deterministischer Test) bieten. Egal wie viele verschiedene $a$ man probiert, Zahlen wie $561$ werden immer so tun, als wären sie Primzahlen.

3. Miller-Rabin-Primzahltest (Miller-Rabin Primality Test)

Die Schwäche des Fermat-Tests (die Existenz von Carmichael-Zahlen) wurde von Gary L. Miller und Michael O. Rabin mit dem “Miller-Rabin-Primzahltest” brillant überwunden. Heute wird er am häufigsten als praktischer, schneller Primzahltest-Algorithmus in internen Bibliotheken verschiedener Programmiersprachen und bei der Schlüsselgenerierung in Kryptosystemen verwendet.

Mathematisches Prinzip

Der Miller-Rabin-Algorithmus nutzt zusätzlich zum kleinen Fermatschen Satz die Eigenschaft, dass “in einem Restklassenkörper modulo einer Primzahl ($\mathbb{Z}/p\mathbb{Z}$) die einzigen Lösungen von $x^2 \equiv 1 \pmod p$ die Werte $x \equiv 1$ oder $x \equiv -1$ sind” (bei einer zusammengesetzten Zahl als Modul können auch andere nicht-triviale Quadratwurzeln existieren).

Zieht man $1$ von einer zu testenden ungeraden Zahl $N$ ab, ist $N-1$ immer gerade. Daher teilen wir $N-1$ so oft wie möglich durch $2$ und schreiben es in der folgenden Form:

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

(Wobei $d$ ungerade ist und $s \ge 1$)

Für eine beliebige Basis $a$ ($1 < a < N-1$) prüfen wir gemäß dem kleinen Fermatschen Satz, ob $a^{N-1} \equiv 1 \pmod N$ gilt, führen diese Berechnung jedoch schrittweise durch. Konkret wiederholen wir die Quadrierung in der Reihenfolge $a^d, a^{d \cdot 2}, a^{d \cdot 4}, \ldots, a^{d \cdot 2^s}$.

Die Bedingung dafür, dass der Miller-Rabin-Test $N$ als “prim (oder mit hoher Wahrscheinlichkeit prim)” einstuft, ist, dass eine der folgenden Aussagen wahr ist:

$a^d \equiv 1 \pmod N$
Es gibt ein $r$ ($0 \le r < s$), für das gilt: $a^{d \cdot 2^r} \equiv -1 \pmod N$.
- In C++ Modulo-Arithmetik wird $-1 \pmod N$ als $N-1$ dargestellt.

Wenn $N$ eine Primzahl ist, ist diese Bedingung für jedes beliebige $a$ immer erfüllt. Umgekehrt ist mathematisch bewiesen, dass, wenn $N$ eine zusammengesetzte Zahl ist und ein zufälliges $a$ gewählt wird, die Wahrscheinlichkeit, dass diese Bedingung erfüllt ist (die Wahrscheinlichkeit, getäuscht zu werden), höchstens $\frac{1}{4}$ beträgt. Führt man $k$ unabhängige Tests durch, sinkt die Wahrscheinlichkeit eines falschen Ergebnisses auf höchstens $\left(\frac{1}{4}\right)^k$, was für die Praxis als null betrachtet werden kann. Es gibt keine “absolut täuschenden” Zahlen wie Carmichael-Zahlen mehr.

Ablauf des Miller-Rabin-Algorithmus (Mermaid-Flussdiagramm)

Das folgende Diagramm zeigt den logischen Ablauf eines einzelnen Miller-Rabin-Primzahltests (für eine Basis $a$).

graph TD Start["Teststart (Eingabe: N, a)"] --> CalcDS["Berechne ungerades d und s für N-1 = d * 2^s"] CalcDS --> CalcX["Berechne x = a^d mod N"] CalcX --> CheckX1{"x == 1 oder x == N-1 ?"} CheckX1 -- "Yes" --> ReturnTrue["Möglicherweise prim (Probably Prime)"] CheckX1 -- "No" --> LoopStart["Schleifenstart von r = 1 bis s-1"] LoopStart --> LoopCondition{"r < s ?"} LoopCondition -- "No" --> ReturnFalse["Definitiv zusammengesetzt (Composite)"] LoopCondition -- "Yes" --> SquareX["Berechne x = (x * x) mod N"] SquareX --> CheckXMinus1{"x == N - 1 ?"} CheckXMinus1 -- "Yes" --> ReturnTrue CheckXMinus1 -- "No" --> CheckXOne{"x == 1 ?"} CheckXOne -- "Yes" --> ReturnFalse CheckXOne -- "No" --> LoopNext["Erhöhe r um 1 und weiter"] LoopNext --> LoopCondition

4. Deterministischer Test für 64-Bit-Ganzzahlen

Der Miller-Rabin-Primzahltest ist ursprünglich ein “probabilistischer” Algorithmus, aber wenn die Obergrenze von $N$ feststeht, kann man “100% deterministisch” auf eine Primzahl testen, indem man bestimmte Mengen von $a$ (Basen) ausprobiert. Dies wird als Deterministischer Miller-Rabin-Test (Deterministic Miller-Rabin Test) bezeichnet.

Durch Forschungen von Jim Sinclair und anderen wurde herausgefunden, dass für alle ganzen Zahlen $N < 2^{64}$ (ca. $1.8 \times 10^{19}$) ein vollständig deterministischer Test möglich ist, indem man die folgenden $7$ Primzahlen als Basis $a$ wählt und testet.

Liste der zu testenden Basen $a$: {2, 325, 9375, 28178, 450775, 9780504, 1795265022}

Alternativ kann man eine andere bekannte Menge von $12$ Primzahlen verwenden, um Zahlen bis $N < 2^{64}$ perfekt zu testen. {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37}

Um die Einfachheit und Zuverlässigkeit des Algorithmus zu erhöhen, werden wir diesmal die Methode mit den $12$ Primzahlen (oder die optimierteren $7$ Basen) übernehmen. Bei der C++-Implementierung optimieren wir den Prozess, indem wir die Anzahl der Tests basierend auf Größenbereichen durch Verzweigungen minimieren.

5. Hochgradig optimierte Implementierung in C++ (Highly Optimized C++ Implementation)

Nun fassen wir die mathematische Theorie und den Entwurf des Algorithmus zusammen und präsentieren den Implementierungscode für eine der stärksten Miller-Rabin-Primzahltest-Funktionen im modernen C++.

Punkte zur Implementierung

Vermeidung von Überläufen bei der 64-Bit-Ganzzahl-Multiplikation: Wenn $N \approx 10^{18}$, kann $x \times x$ bei der Modulo-Multiplikation bis zu $10^{36}$ erreichen und den Maximalwert einer regulären 64-Bit-Ganzzahl (uint64_t oder long long) von $1.8 \times 10^{19}$ leicht überlaufen lassen. Um dieses Problem zu lösen, verwenden wir __int128_t (oder unsigned __int128), einen Erweiterungstyp von GCC und Clang, führen die Berechnung mit 128-Bit-Genauigkeit durch und wenden dann Modulo an. So sind schnelle modulare Multiplikationen ohne komplexe Algorithmen möglich.
Auswahl deterministischer Basen: Ist der Wert von $N$ klein, optimieren wir dies, sodass nur wenige Basen getestet werden müssen.

Vollständiger C++ Quellcode

Hier ist der fertige, praxistaugliche Quellcode. Dieser Code kann für Umgebungen wie kompetitives Programmieren direkt kopiert und verwendet werden.

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


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

using namespace std;

// Schnelle Berechnung von (a * b) mod m mit 128-Bit-Ganzzahlen
inline uint64_t mod_mul(uint64_t a, uint64_t b, uint64_t m) {
 return (uint64_t)((unsigned __int128)a * b % m);
}

// Berechnung von (base^exp) mod m mittels binärer Exponentiation
uint64_t mod_pow(uint64_t base, uint64_t exp, uint64_t m) {
 uint64_t res = 1;
 base %= m;
 while (exp > 0) {
 if (exp & 1) res = mod_mul(res, base, m);
 base = mod_mul(base, base, m);
 exp >>= 1;
 }
 return res;
}

// Deterministischer Miller-Rabin-Primzahltest für 64-Bit-Ganzzahlen
bool is_prime_miller_rabin(uint64_t n) {
 // Vorabprüfung von Randwerten und kleinen Primzahlen
 if (n < 2) return false;
 if (n == 2 || n == 3 || n == 5 || n == 7) return true;
 if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0 || n % 7 == 0) return false;

 // Zerlegung in die Form n-1 = d * 2^s
 uint64_t d = n - 1;
 int s = 0;
 while ((d & 1) == 0) {
 d >>= 1;
 s++;
 }

 // Liste der für den Test verwendeten Basen (bases)
 // Optimierung zur Minimierung der Anzahl der zu testenden Basen je nach Größe von N
 vector<uint64_t> bases;
 if (n < 4759123141ULL) {
 bases = {2, 7, 61};
 } else if (n < 1122004669633ULL) {
 bases = {2, 13, 23, 1662803};
 } else {
 // 7 Basen, die für alle Zahlen N < 2^64 deterministisch sind
 bases = {2, 325, 9375, 28178, 450775, 9780504, 1795265022};
 }

 // Test für jede Basis durchführen
 for (uint64_t a : bases) {
 a %= n;
 if (a == 0) continue; // Ist a ein Vielfaches von n, ist der Test nicht anwendbar, aber n keine Primzahl

 uint64_t x = mod_pow(a, d, n);
 if (x == 1 || x == n - 1) continue; // Erste Bedingung erfüllt, zur nächsten Basis

 bool composite = true;
 // Schleife s-1 mal ausführen (x = x^2 mod n)
 for (int r = 1; r < s; r++) {
 x = mod_mul(x, x, n);
 if (x == n - 1) {
 composite = false; // Zweite Bedingung erfüllt, möglicherweise prim
 break;
 }
 }

 // Wenn keine Bedingung erfüllt ist, ist sie definitiv zusammengesetzt
 if (composite) return false;
 }

 // Wenn alle Basen die Bedingungen erfüllen, ist die Zahl definitiv eine Primzahl
 return true;
}

int main() {
 // Testbeispiele
 vector<uint64_t> test_cases = {
 1000000007, // Bekannte Primzahl
 998244353, // Bekannte Primzahl
 1000000000000000003, // Primzahl im Bereich von 10^18
 1000000000000000007, // Zusammengesetzte Zahl (10^18 + 7)
 561, // Carmichael-Zahl (zusammengesetzt)
 18446744073709551557ULL // Eine der größten Primzahlen nahe 2^64
 };

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

 return 0;
}

6. Zeitkomplexität des Algorithmus und Leistungsbewertung

Lassen Sie uns die Leistung des implementierten Algorithmus analysieren.

Zeitkomplexität (Time Complexity)

Probedivision: $O(\sqrt{N})$
Fermat-Test: Exponentiation $O(\log N) \times k$ (wobei $k$ die Anzahl der Versuche ist)
Miller-Rabin-Test: Exponentiation und Schleife $O(\log N) \times k$

In einer 64-Bit-Umgebung ($N \le 2^{64}$) prüft die oben beschriebene deterministische Miller-Rabin-Methode maximal $7$ Basen. Daher kann $k \le 7$ als Konstante betrachtet werden, und die gesamte Zeitkomplexität ist streng genommen $O(\log N)$. Selbst im größten Fall ($N \approx 10^{19}$) passt die Anzahl der Ausführungsschritte in höchstens $7 \times 64 = 448$ elementare Operationen, und die Ausführungszeit beträgt wenige Mikrosekunden ($10^{-6}$ Sekunden) oder weniger. Im Vergleich zur Zeitkomplexität der Probedivision von $O(\sqrt{N})$ (Schleifendurchläufe $\approx 4 \times 10^9$) wurde eine Beschleunigung um das Millionenfache erreicht.

Weitere Optimierung: Montgomery-Multiplikation (Montgomery Multiplication)

Die Implementierung in diesem Artikel verwendet den 128-Bit-Erweiterungstyp __int128_t für die Division (Modulo-Operation %). Selbst auf modernen CPUs ist die Ganzzahldivision (DIV-Befehl) ein teurer Befehl, der dutzende von Zyklen erfordert, weit mehr als Addition oder Multiplikation.

Bibliotheksersteller und wettbewerbsorientierte Programmierer, die nach extremer Optimierung streben, verwenden oft eine Technik namens Montgomery-Multiplikation (Montgomery Multiplication). Die Montgomery-Multiplikation ist ein verblüffender Algorithmus, der Zahlen in einen speziellen “Montgomery-Raum” abbildet und so hochgradig kostspielige Modulo-Operationen (Division) durch “nur Bitverschiebungen und Multiplikationen” ersetzt. Durch die Integration dieser Technik in die modulare Multiplikation des Miller-Rabin-Tests kann die Ausführungsgeschwindigkeit weiter verdoppelt oder verdreifacht werden. Da dies ein sehr tiefes Thema ist, werde ich es in einem separaten Artikel ausführlich behandeln.

7. Zusammenfassung

In diesem Artikel haben wir von den Grundlagen der Primzahltests bis hin zu fortgeschrittenen Themen alles behandelt. Fassen wir die wichtigsten Punkte zusammen:

Die Probedivision ist zuverlässig, hat aber eine Zeitkomplexität von $O(\sqrt{N})$, was sie für $N > 10^{12}$ unpraktisch macht.
Der Fermat-Test ist mit $O(\log N)$ sehr schnell, hat aber die fatale Schwäche, von absoluten Pseudoprimzahlen wie Carmichael-Zahlen getäuscht zu werden.
Der Miller-Rabin-Primzahltest ist ein praktischer, extrem starker Algorithmus, der die Schwäche des Fermat-Tests beseitigt.
Bei der C++ Implementierung kann man den Erweiterungstyp __int128_t nutzen, um Überläufe bei der Multiplikation von 64-Bit-Ganzzahlen sicher zu handhaben.
Im Bereich der 64-Bit-Ganzzahlen ($N < 2^{64}$) können Primzahltests deterministisch (100% genau) durchgeführt werden, anstatt nur probabilistisch, indem $7$ oder $12$ spezifische Primzahlen als Basis gewählt werden.

Schnelle Primzahltests sind eine unverzichtbare Technologie beim Rechnen mit riesigen Zahlen. Der hier vorgestellte C++-Quellcode für den Miller-Rabin-Test ist robust und kann direkt in der Praxis eingesetzt werden. Bitte probieren Sie ihn in Ihren eigenen Projekten oder bei Algorithmen-Wettbewerben aus!

graph LR TrialDivision["Probedivision (O(√N))"] --> Fermat["Fermat-Test (O(log N), hat Schwächen)"] Fermat --> MillerRabin["Miller-Rabin-Test (O(log N), deterministisch möglich)"] MillerRabin --> Montgomery["+ Montgomery-Multiplikation (Schneller um einen konstanten Faktor)"] style MillerRabin fill:#f9f,stroke:#333,stroke-width:2px

Die Welt der Algorithmen, in der sich Programmierung und Mathematik kreuzen, ist unglaublich schön und tiefgründig. Ich hoffe, dieser Artikel hilft Ihnen beim weiteren Lernen.

Reference:

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

【Mathematik-Erklärung】Wie RSA-Verschlüsselung funktioniert, verständlich für Schüler erklärt

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

Eine der Technologien, die die Sicherheit der Internetgesellschaft grundlegend unterstützt, ist die „RSA-Verschlüsselung“. Viele der Kommunikationen, die wir jeden Tag beiläufig nutzen, wie Kreditkartenzahlungen beim Online-Shopping, der Austausch mit Freunden auf sozialen Netzwerken und das Senden und Empfangen vertraulicher Unternehmensinformationen, werden durch diese RSA-Verschlüsselung und ihre Nachfolgetechnologien geschützt.

Wenn man jedoch das Wort „Verschlüsselung“ hört, stellt man sich vielleicht komplexe Chiffriermaschinen wie in Spionagefilmen vor oder extrem fortgeschrittene Mathematik, die nur einige wenige Genies verstehen können. Es stimmt zwar, dass die moderne Kryptographie auf fortgeschrittener Mathematik basiert, aber die grundlegende Funktionsweise der RSA-Verschlüsselung kann mit dem Wissen aus der Schulmathematik (Eigenschaften von ganzen Zahlen, Primzahlen, Kongruenzen usw.) gut verstanden werden.

In diesem Artikel erklären wir ausgehend vom Wissen der Schulmathematik Schritt für Schritt, nach welchen mathematischen Prinzipien die RSA-Verschlüsselung funktioniert und warum sie so schwer zu knacken ist. Wir werden es anhand konkreter Beispiele sorgfältig erklären, so dass auch diejenigen es verstehen können, die in Mathematik vielleicht nicht so stark sind.

1. Symmetrische Verschlüsselung und asymmetrische Verschlüsselung (Public-Key-Verschlüsselung)

Bevor wir uns mit den mathematischen Mechanismen der RSA-Verschlüsselung befassen, lassen Sie uns zunächst die Grundkonzepte der Kryptographie klären. Verschlüsselungsverfahren lassen sich grob in zwei Arten unterteilen: die „symmetrische Verschlüsselung“ und die „asymmetrische Verschlüsselung“ (Public-Key-Kryptographie).

1.1 Die Grenzen der symmetrischen Verschlüsselung

Viele der seit langem verwendeten Verschlüsselungen sind sogenannte „symmetrische Verschlüsselungsverfahren“. Bei dieser Methode wird für die „Verschlüsselung“ (die Umwandlung einer Nachricht in einen geheimen Geheimtext) und die „Entschlüsselung“ (die Wiederherstellung der ursprünglichen Nachricht aus dem Geheimtext) derselbe Schlüssel verwendet.

Nehmen wir zum Beispiel an, Alice möchte Bob einen geheimen Brief schicken. Alice legt den Brief in eine Kiste und verschließt diese mit einem Vorhängeschloss (dem symmetrischen Schlüssel). Damit Bob diese Kiste öffnen kann, muss er denselben Schlüssel besitzen, den auch Alice benutzt hat.

Dieses System hat ein großes Problem: das „Schlüsselaustauschproblem“. Wenn Alice und Bob, die weit voneinander entfernt sind, zum ersten Mal kommunizieren, wie können sie dann einen Schlüssel teilen, ohne abgehört zu werden? Wenn der Schlüssel auf dem Postweg von einem Dritten gestohlen wird, ist die gesamte nachfolgende verschlüsselte Kommunikation für diesen einsehbar.

1.2 Die bahnbrechende Erfindung der „asymmetrischen Verschlüsselung“

Um dieses Schlüsselaustauschproblem zu lösen, wurde die „asymmetrische Verschlüsselung“ erfunden. Die RSA-Verschlüsselung ist eine Form davon.

Bei der asymmetrischen Verschlüsselung werden zwei unterschiedliche Schlüssel verwendet: ein „Schlüssel zum Verschlüsseln (öffentlicher Schlüssel)“ und ein „Schlüssel zum Entschlüsseln (privater Schlüssel)“.

Der Empfänger Bob erstellt ein Paar aus „öffentlichem Schlüssel“ und „privatem Schlüssel“.
Bob veröffentlicht den „öffentlichen Schlüssel“ für die ganze Welt (es spielt keine Rolle, wer ihn bekommt).
Die Senderin Alice verschlüsselt ihre Nachricht mit Bobs „öffentlichem Schlüssel“ und sendet sie ab.
Die verschlüsselte Nachricht kann nur mit dem „privaten Schlüssel“, den nur Bob besitzt, entschlüsselt werden.

Um dies mit einem Vorhängeschloss zu vergleichen: Bob stellt viele „offene Vorhängeschlösser (öffentliche Schlüssel)“ her und verteilt sie in der ganzen Welt. Alice legt eine Nachricht für Bob in eine Kiste und verschließt sie mit einem gefundenen Vorhängeschloss von Bob. Sobald das Vorhängeschloss geschlossen ist, kann es nur noch mit dem „Generalschlüssel (privater Schlüssel)“ geöffnet werden, den Bob besitzt. Selbst wenn jemand unterwegs die Kiste stiehlt, kann er sie ohne den Generalschlüssel nicht öffnen.

graph TD A["Alice (Senderin)"] --> B["Klartext (Nachricht)"] B --> C["Verschlüsselungsprozess"] D["Bobs öffentlicher Schlüssel (für jeden zugänglich)"] --> C C --> E["Versand über das Internet: Geheimtext"] E --> F["Entschlüsselungsprozess"] G["Bobs privater Schlüssel (nur Bob hat ihn)"] --> F F --> H["Wiederhergestellter Klartext (Nachricht)"] H --> I["Bob (Empfänger)"]

Um dieses revolutionäre System zu realisieren, ist eine Art „Einwegfunktion (ein mathematisches Einbahnstraßen-Rätsel)“ erforderlich, die es erlaubt, „mit dem öffentlichen Schlüssel leicht zu verschlüsseln, aber ohne den privaten Schlüssel absolut nicht zu entschlüsseln“. Als Bestandteil dieses Rätsels richtete man die Aufmerksamkeit auf etwas, das wir gut kennen: „Primzahlen“.

2. Mathematische Grundlagen der RSA-Verschlüsselung Teil 1: Primzahlen und Primfaktorzerlegung

Die Sicherheit der RSA-Verschlüsselung basiert auf der mathematischen Tatsache, dass „die Primfaktorzerlegung riesiger Zahlen extrem schwierig ist“.

2.1 Was sind Primzahlen?

Eine Primzahl ist „eine natürliche Zahl größer als 1, die nur durch 1 und durch sich selbst teilbar ist“. Beispiel: $2, 3, 5, 7, 11, 13, 17, 19, 23...$

Primzahlen sind wie die „Atome“ aller ganzen Zahlen. Jede natürliche Zahl kann in eine Multiplikation von Primzahlen zerlegt werden. Dies nennt man Primfaktorzerlegung. Dass sich eine Zahl, abgesehen von der Reihenfolge der Faktoren, auf genau eine Weise in Primfaktoren zerlegen lässt (wie z. B. $60 = 2^2 \times 3 \times 5$), ist als der „Fundamentalsatz der Arithmetik“ bekannt.

2.2 Die Schwierigkeit der Primfaktorzerlegung (Einwegfunktion)

Wichtig ist hier die Asymmetrie: „Multiplizieren ist einfach, aber die Primfaktorzerlegung ist schwierig.“

Versuchen Sie beispielsweise, die Multiplikation der folgenden zwei Primzahlen im Kopf zu berechnen: $11 \times 13 = ?$ Das ist einfach. Die Antwort ist $143$.

Aber wie steht es mit der nächsten Zahl? Bitte zerlegen Sie $323$ in ihre Primfaktoren. Wie sieht es aus? Das dürfte ein wenig Zeit in Anspruch nehmen. (Die Antwort ist $17 \times 19$).

Wenn die Zahlen klein sind, kann ein Mensch sie irgendwie noch berechnen, aber wenn die Zahlen größer werden, wird die Berechnung selbst für Computer explosiv schwierig. Die derzeit vorherrschende RSA-Verschlüsselung verwendet eine Zahl $N = p \times q$, die das Produkt aus zwei unfassbar riesigen Primzahlen $p$ und $q$ von 2048 Bit (etwa 600 Dezimalstellen) ist.

Wenn zwei riesige Primzahlen $p$ und $q$ gegeben sind, ist die Berechnung von $N$ für einen Computer eine Sache von Millisekunden. Wenn man jedoch nur $N$ hat und die ursprünglichen $p$ und $q$ finden möchte, würde dies so lange dauern, dass selbst der derzeit schnellste Supercomputer das Problem in Billionen von Jahren nicht lösen könnte.

Diese „Asymmetrie der Berechnung (in eine Richtung einfach, in die andere extrem schwer)“ bildet die Grundlage für die Beziehung zwischen dem öffentlichen und dem privaten Schlüssel.

3. Mathematische Grundlagen der RSA-Verschlüsselung Teil 2: Kongruenzen (Modulo-Arithmetik)

Die Berechnungen bei der RSA-Verschlüsselung erfolgen nicht wie bei der gewöhnlichen Addition oder Multiplikation, bei der die Zahlen unendlich groß werden, sondern in einer Welt der „Reste“, die entstehen, wenn man durch eine bestimmte Zahl teilt. Dies wird als Kongruenz (Modulo-Arithmetik) bezeichnet.

3.1 Die Mathematik der Uhr

Die Modulo-Arithmetik wird oft mit der „Mathematik der Uhr“ verglichen. Angenommen, es ist jetzt 10 Uhr, wie spät ist es in 5 Stunden? $10 + 5 = 15$ Uhr, aber auf einer normalen 12-Stunden-Uhr würden wir „3 Uhr“ sagen. Das liegt daran, dass der Rest von 15 geteilt durch 12 gleich 3 ist.

In der Welt der Mathematik wird dies wie folgt geschrieben:

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

Man liest dies als: „15 und 3 sind kongruent modulo 12 (sie haben denselben Rest, wenn man sie durch 12 teilt).“

3.2 Grundlegende Eigenschaften von Kongruenzen

Kongruenzen haben sehr nützliche Eigenschaften, die denen einer Gleichung ($=$) sehr ähnlich sind. Sei das Modul (die Zahl, durch die geteilt wird) $N$. Wenn $a \equiv b \pmod N$ und $c \equiv d \pmod N$, dann gilt Folgendes:

Addition: $a + c \equiv b + d \pmod N$
Subtraktion: $a - c \equiv b - d \pmod N$
Multiplikation: $a \times c \equiv b \times d \pmod N$
Potenzieren: $a^k \equiv b^k \pmod N$ (wobei $k$ eine natürliche Zahl ist)

Besonders wichtig ist die Eigenschaft des „Potenzierens“. Das bedeutet: „Die Potenz eines Restes ist kongruent zum Rest der Potenz.“ Angenommen, wir wollen den Rest ermitteln, wenn $7^{100}$ durch $5$ geteilt wird. Es wäre mühsam, $7$ ernsthaft 100 Mal mit sich selbst zu multiplizieren und dann durch $5$ zu teilen. Wenn wir jedoch die Eigenschaften von Kongruenzen nutzen, wissen wir, dass $7 \equiv 2 \pmod 5$ ist, also gilt $7^{100} \equiv 2^{100} \pmod 5$. Dadurch lässt sich die Berechnung drastisch vereinfachen. Da in der Welt der Kryptographie mit sehr großen Potenzen gerechnet wird, ist diese Eigenschaft unverzichtbar.

4. Mathematische Grundlagen der RSA-Verschlüsselung Teil 3: Eulersche Phi-Funktion und der Satz von Euler

Hier beginnt nun die magische Mathematik, die den Kern der RSA-Verschlüsselung ausmacht. Hier kommt der „Satz von Euler“ ins Spiel, der eine Verallgemeinerung des „kleinen fermatschen Satzes“ ist.

4.1 Die Eulersche Totient-Funktion $\phi(N)$

Die Eulersche Totient-Funktion (auch $\phi$-Funktion genannt) gibt für eine natürliche Zahl $N$ „die Anzahl der natürlichen Zahlen von 1 bis $N$, die teilerfremd zu $N$ sind (deren größter gemeinsamer Teiler 1 ist)“, zurück.

Schauen wir uns einige Beispiele an.

$\phi(5)$: Unter 1, 2, 3, 4 und 5 sind 1, 2, 3 und 4 teilerfremd zu 5 (also 4 Zahlen). Daher ist $\phi(5) = 4$.
$\phi(6)$: Unter 1, 2, 3, 4, 5 und 6 sind 1 und 5 teilerfremd zu 6 (also 2 Zahlen). Daher ist $\phi(6) = 2$.

[Spezielle Eigenschaft bei Primzahlen] Wenn $p$ eine Primzahl ist, sind alle Zahlen von 1 bis $p-1$ teilerfremd zu $p$. Daher gilt:

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

[Spezielle Eigenschaft beim Produkt von Primzahlen] Für zwei verschiedene Primzahlen $p$ und $q$ und $N = p \times q$ kann $\phi(N)$ einfach durch folgende Berechnung ermittelt werden:

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

Diese Eigenschaft fungiert als „geheime Hintertür (Trapdoor)“ der RSA-Verschlüsselung. Wer $p$ und $q$ kennt (der Ersteller des Schlüssels), kann $\phi(N)$ augenblicklich berechnen, aber ein Dritter, der nur $N$ kennt, kann $\phi(N)$ nicht bestimmen, ohne $N$ vorher in seine Primfaktoren zu zerlegen.

4.2 Der Satz von Euler

Leonhard Euler bewies mit Hilfe dieser Funktion $\phi(N)$ den folgenden schönen Satz.

Der Satz von Euler: Wenn eine ganze Zahl $a$ und $N$ teilerfremd sind, gilt die folgende Kongruenz:

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

Das ist die bemerkenswerte Eigenschaft, dass „wenn man eine bestimmte Zahl $a$ insgesamt $\phi(N)$ Mal mit sich selbst multipliziert und durch $N$ teilt, der Rest immer $1$ ist“. (Wenn $N$ eine Primzahl $p$ ist, ergibt sich $a^{p-1} \equiv 1 \pmod p$, was als der kleine fermatsche Satz bekannt ist).

Lassen Sie uns diesen Satz von Euler umformen. Wir multiplizieren beide Seiten noch einmal mit $a$.

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

Darüber hinaus ergibt $a^{k \cdot \phi(N)}$ für eine beliebige ganze Zahl $k$ ebenfalls $1^k = 1$, sodass die folgende Gleichung gilt:

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

Genau diese Gleichung ist das Grundprinzip, das die Magie der RSA-Verschlüsselung – „nach dem Verschlüsseln und Entschlüsseln erhält man wieder das Original“ – möglich macht.

5. Der Algorithmus der RSA-Verschlüsselung: Schritte zur Schlüsselerzeugung, Verschlüsselung und Entschlüsselung

Da wir nun über das Grundlagenwissen verfügen, schauen wir uns endlich die konkreten Schritte der RSA-Verschlüsselung an. Die RSA-Verschlüsselung ist grob in drei Phasen unterteilt: „1. Schlüsselerzeugung“, „2. Verschlüsselung“ und „3. Entschlüsselung“.

flowchart TD A1["1. Wähle Primzahlen p, q"] --> A2["Berechne N = p × q"] A1 --> A3["Berechne φ(N) = (p-1)(q-1)"] A3 --> A4["Wähle ein e, das zu φ(N) teilerfremd ist"] A3 --> A5["Berechne d, sodass e × d ≡ 1 (mod φ(N))"] A2 --> A6["Öffentlicher Schlüssel (N, e)"] A4 --> A6 A5 --> A7["Privater Schlüssel d"] B1["2. Klartext-Nachricht M"] --> B2["Berechne C ≡ M^e (mod N)"] A6 -.-> B2 B2 --> B3["Sende Geheimtext C"] B3 --> C1["3. Empfangener Geheimtext C"] C1 --> C2["Berechne M ≡ C^d (mod N)"] A7 -.-> C2 C2 --> C3["Erhalte ursprüngliche Klartext-Nachricht M"]

5.1 Schlüsselerzeugung (Key Generation)

Bob, der Empfänger, generiert für sich selbst einen „öffentlichen Schlüssel“ und einen „privaten Schlüssel“.

Wahl der Primzahlen: Es werden zwei große Primzahlen $p$ und $q$ zufällig gewählt.
Berechnung des Moduls $N$: Es wird $N = p \times q$ berechnet. Dieses $N$ wird veröffentlicht.
Berechnung von $\phi(N)$: Die Eulersche Funktion $\phi(N) = (p - 1)(q - 1)$ wird berechnet. Diese Zahl ist Bobs Geheimnis.
Wahl des öffentlichen Schlüssels $e$: Es wird eine ganze Zahl $e$ gewählt, für die $1 < e < \phi(N)$ gilt und die teilerfremd zu $\phi(N)$ ist.
Berechnung des privaten Schlüssels $d$: Es wird eine ganze Zahl $d$ gefunden, die folgende Bedingung erfüllt: $$ e \times d \equiv 1 \pmod{\phi(N)} $$ Das bedeutet: „Eine Zahl $d$, bei der $e \times d$ geteilt durch $\phi(N)$ einen Rest von $1$ ergibt.“

Damit sind die Schlüssel vorbereitet.

Öffentlicher Schlüssel: Das Paar $(N, e)$. Es wird für die ganze Welt veröffentlicht.
Privater Schlüssel: $d$. Er wird absolut niemandem verraten.

5.2 Verschlüsselung (Encryption)

Angenommen, Alice möchte Bob eine geheime Nachricht $M$ senden. ($M$ ist ein in Zahlen umgewandelter Text, wobei $0 \le M < N$ gilt). Alice berechnet mithilfe von Bobs öffentlichem Schlüssel $(N, e)$ Folgendes:

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

Sie berechnet „den Rest $C$, der entsteht, wenn man die Nachricht $M$ mit $e$ potenziert und durch $N$ teilt“. Dieses $C$ ist der Geheimtext.

5.3 Entschlüsselung (Decryption)

Bob empfängt den Geheimtext $C$. Bob rechnet mit seinem privaten Schlüssel $d$ wie folgt:

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

Wenn man „den Rest berechnet, der entsteht, wenn der Geheimtext $C$ mit $d$ potenziert und durch $N$ geteilt wird“, wird erstaunlicherweise die ursprüngliche Nachricht $M$ wiederhergestellt!

6. Warum erhält man durch Entschlüsselung das Original zurück? (Mathematischer Beweis)

Vielleicht fragen Sie sich: „Wie kann es sein, dass $C$ hoch $d$ uns einfach unser ursprüngliches $M$ zurückgibt?“ Hier kommt nun der zuvor erwähnte „Satz von Euler“ ins Spiel.

Setzen wir die Formel für die Verschlüsselung, $C = M^e$, in die Berechnungsformel für die Entschlüsselung, $C^d \pmod N$, ein.

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

Erinnern wir uns nun an Schritt 5 der Schlüsselerzeugung. Als Bob $d$ generierte, wählte er es so, dass $e \times d \equiv 1 \pmod{\phi(N)}$ gilt. Das bedeutet, dass „$ed$ ein Vielfaches von $\phi(N)$ plus $1$ ist“. Mit einer ganzen Zahl $k$ lässt sich dies wie folgt schreiben:

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

Wir setzen dies in den Exponenten ein und zerlegen ihn mithilfe der Potenzgesetze.

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

Wenn wir hier annehmen, dass die Nachricht $M$ und $N$ teilerfremd sind, gilt nach dem Satz von Euler $M^{\phi(N)} \equiv 1 \pmod N$.

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

Folglich ergibt sich auf wunderbare Weise diese Gleichung:

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

Da Alice $d$ nicht kennt und auch ein Abhörer $d$ nicht kennt, ist Bob mit seinem $d$ der Einzige, der $M$ aus $C$ extrahieren kann.

7. Ein konkretes Beispiel: RSA mit kleinen Primzahlen per Hand ausprobieren

Lassen Sie uns tatsächlich eine verschlüsselte Kommunikation von Alice an Bob unter Verwendung kleiner Zahlen (Primzahlen) durchführen.

[Bobs Schlüsselerzeugungsphase]

Er wählt zwei Primzahlen: $p=11$, $q=13$.
Er berechnet $N = 11 \times 13 = 143$.
Er berechnet $\phi(N) = (11 - 1) \times (13 - 1) = 10 \times 12 = 120$.
Er wählt einen öffentlichen Schlüssel $e$, der teilerfremd zu $\phi(N)=120$ ist. Hier wählen wir $e=7$.
Er ermittelt den privaten Schlüssel $d$. Er sucht ein $d$, für das $7 \times d \equiv 1 \pmod{120}$ gilt. In der Gleichung $7d = 120k + 1$ ergibt sich für $k=6$ die Zahl $721$, und $721 \div 7 = 103$. Daher ist $d = 103$.

Öffentlicher Schlüssel: $(N=143, e=7)$
Privater Schlüssel: $d=103$

[Alices Verschlüsselungsphase] Nehmen wir an, sie möchte die Nachricht $M = 9$ senden. Formel: $C \equiv 9^7 \pmod{143}$ $9^7 = 4.782.969$. Teilt man dies durch 143, erhält man $33447$ mit dem Rest $48$. Der Geheimtext $C$ ist also $48$.

[Bobs Entschlüsselungsphase] Bob empfängt den Geheimtext $C = 48$ und entschlüsselt ihn mit dem privaten Schlüssel $d = 103$. Formel: $M \equiv 48^{103} \pmod{143}$ Wenn man (48 ** 103) % 143 in einen Computer eingibt, ist das großartige Ergebnis tatsächlich „9“! Er hat die ursprüngliche Nachricht sicher erhalten.

8. Wie man den privaten Schlüssel $d$ findet: Der erweiterte euklidische Algorithmus

Im per Hand berechneten Beispiel haben wir $k$ durch Ausprobieren gesucht, um $d=103$ zu finden, aber wenn die Zahlen Hunderte von Ziffern haben, ist diese Methode unmöglich. In echten Programmen wird ein Algorithmus namens „erweiterter euklidischer Algorithmus“ verwendet.

Die Lösung von $7d \equiv 1 \pmod{120}$ ist gleichbedeutend mit dem Finden der ganzen Zahlen $d$ und $y$, die $7d + 120y = 1$ erfüllen. Durch die Rückwärtsrechnung des euklidischen Algorithmus lässt sich dies maschinell ermitteln.

$120 \div 7 = 17$ Rest $1$
Durch Umformen ergibt sich: $1 = 120 - 17 \times 7$
Das heißt: $-17 \times 7 \equiv 1 \pmod{120}$

$-17$ bedeutet in der Welt von Modulo $120$ dasselbe wie $120 - 17 = 103$. So lässt sich $d = 103$ augenblicklich ermitteln. Diese Methode erlaubt sehr schnelle Berechnungen, egal wie riesig die Zahlen sind.

9. Ein weiteres Gesicht der RSA-Verschlüsselung: Digitale Signaturen

Das Tolle an der RSA-Verschlüsselung ist, dass sie auch als „digitale Signatur“ verwendet werden kann, indem man die Rollen des öffentlichen und privaten Schlüssels vertauscht.

Während bei der Verschlüsselung das Prinzip „Verschlüsseln mit dem öffentlichen Schlüssel $\Rightarrow$ Entschlüsseln mit dem privaten Schlüssel“ galt, ist der Ablauf bei der digitalen Signatur „Verschlüsseln mit dem privaten Schlüssel $\Rightarrow$ Entschlüsseln mit dem öffentlichen Schlüssel“.

flowchart TD A1["1. Alice erstellt Signatur mit privatem Schlüssel"] --> A2["S ≡ M^d (mod N)"] A2 --> A3["Sende Nachricht M und Signatur S"] A3 --> B1["2. Bob verifiziert Signatur mit öffentlichem Schlüssel"] B1 --> B2["Berechne M' ≡ S^e (mod N)"] B2 --> B3["Prüfe, ob M' und M übereinstimmen"]

Alice wandelt die Nachricht mit ihrem eigenen privaten Schlüssel $d$ um (das ist die Signatur $S$) und sendet sie an Bob. Bob führt mit Alices öffentlichem Schlüssel $e$ die Verifizierungsberechnung durch. Wenn das Ergebnis der Berechnung mit der ursprünglichen Nachricht übereinstimmt, beweist dies gleichzeitig, dass „die Daten nur mit Alices privatem Schlüssel erstellt werden konnten“ und dass „die Nachricht unterwegs nicht manipuliert wurde“.

10. Die RSA-Verschlüsselung durch Programmierung erfahren

Potenzberechnungen, die per Hand extrem mühsam sind, lassen sich in Python sehr einfach implementieren. Im Folgenden finden Sie einen Python-Code, mit dem Sie die Kernlogik der RSA-Verschlüsselung erleben können.

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


def gcd(a, b):
 """Den größten gemeinsamen Teiler finden"""
 while b != 0:
 a, b = b, a % b
 return a

def mod_inverse(e, phi):
 """Den privaten Schlüssel d finden (nutzt die eingebaute Funktion ab Python 3.8)"""
 return pow(e, -1, phi)

# 1. Schlüsselerzeugung
p, q = 11, 13
N = p * q
phi = (p - 1) * (q - 1)
e = 7
d = mod_inverse(e, phi)

print(f"Öffentlicher Schlüssel: (N={N}, e={e}), Privater Schlüssel: d={d}")

# 2. Verschlüsselung
message = 9
ciphertext = pow(message, e, N)
print(f"Geheimtext: {ciphertext}")

# 3. Entschlüsselung
decrypted_message = pow(ciphertext, d, N)
print(f"Entschlüsselte Nachricht: {decrypted_message}")

Die Python-Funktion pow(base, exp, mod) verwendet intern einen schnellen Algorithmus, der sich „binäre Exponentiation (Square-and-Multiply)“ nennt. Dadurch wird die Berechnung auch bei Zahlen mit Hunderten von Ziffern in einem Augenblick abgeschlossen.

11. Zusammenfassung und zukünftige Kryptographietechnologien

Basierend auf dem Wissen der Schulmathematik haben wir die Funktionsweise der RSA-Verschlüsselung aufgedeckt.

Die Schwierigkeit der Primfaktorzerlegung: $p \times q = N$ ist einfach, aber es ist sehr schwer, $p$ und $q$ aus $N$ zu finden.
Kongruenzen und der Satz von Euler: Das Gesetz $a^{\phi(N)} \equiv 1 \pmod N$ vervollständigt die magische Trapdoor, bei der man „durch Potenzieren mit einer bestimmten Zahl zum Ursprung zurückkehrt“.
Öffentlicher und privater Schlüssel: Jeder kann verschlüsseln, aber nur der rechtmäßige Empfänger kann entschlüsseln.

Das $N$ der heute verwendeten RSA-Verschlüsselung hat mehr als 600 Ziffern. Selbst wenn alle Supercomputer der Welt zusammenarbeiten würden, würde die Primfaktorzerlegung länger dauern als das Alter des Universums. Wenn jedoch in Zukunft die derzeit in Entwicklung befindlichen „Quantencomputer“ in die Praxis umgesetzt werden, besteht die Möglichkeit, dass diese Primfaktorzerlegung durch den „Shor-Algorithmus“ augenblicklich geknackt wird. Aus diesem Grund wird derzeit weltweit mit Hochdruck an der Entwicklung der „Post-Quanten-Kryptographie“ gearbeitet, die selbst von Quantencomputern nicht entschlüsselt werden kann.

Fortgeschrittene Mathematik, die oft als „nutzlos“ abgetan wird, schützt in Wirklichkeit unseren Alltag grundlegend. Die RSA-Verschlüsselung ist das beste Lehrmaterial, um uns diese Tiefe und Schönheit der Mathematik zu zeigen. Ich hoffe, dass Sie durch diesen Artikel ein wenig von der Faszination für Kryptographie und Mathematik spüren konnten.

Was ist die vollständig homomorphe Verschlüsselung (FHE)? Der Schlüssel zur Sicherheit der nächsten Generation

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

Während Cloud-Computing und KI-Technologien als Grundlage unserer Gesellschaft fest etabliert sind, ist der Kompromiss zwischen “Datenschutz” und “Datennutzung” zu einer der wichtigsten Herausforderungen geworden. Es gibt eine wachsende Nachfrage danach, dass KI hochsensible Daten wie medizinische Daten, Finanzinformationen und persönliche biometrische Daten in der Cloud analysiert. Dennoch zögern viele Unternehmen aus Sicherheitsbedenken, Daten nach außen zu senden.

Herkömmliche Verschlüsselungstechnologien (wie AES und RSA) eignen sich hervorragend zum Schutz von gespeicherten Daten (Data at Rest) oder Daten, die über ein Netzwerk übertragen werden (Data in Transit). Wenn der Server jedoch Verarbeitungen (Berechnungen) wie Suchen oder maschinelles Lernen an den Daten durchführt (Data in Use), müssen die Daten zuerst entschlüsselt und wieder in Klartext umgewandelt werden. Wenn der Server in diesem Moment der Entschlüsselung gehackt wird oder ein böswilliger interner Administrator die Daten einsieht, führt dies direkt zu einem Informationsleck.

Die vollständig homomorphe Verschlüsselung (Fully Homomorphic Encryption: FHE) ist eine Traumtechnologie, die diese fundamentale Schwäche der “Entschlüsselung während der Verarbeitung” überwindet. Mit FHE ist es möglich, Berechnungen an Daten durchzuführen, während sie verschlüsselt bleiben, ohne sie jemals zu entschlüsseln, und nur das verschlüsselte Ergebnis an den Client zurückzusenden.

In diesem Artikel werden wir FHE, den Schlüssel zur Sicherheit der nächsten Generation, detailliert untersuchen – von seinen Konzepten und seiner Geschichte über den bahnbrechenden Durchbruch von Craig Gentry, die mathematischen Grundlagen (wie Ring-LWE), die größte Herausforderung des “Rauschens” und deren Lösung (Bootstrapping) bis hin zu den neuesten Implementierungsbibliotheken.

1. Was ist homomorphe Verschlüsselung? Grundkonzepte

“Homomorph” ist ein Begriff aus der Algebra, der sich auf die Eigenschaft bezieht, dass zwischen Mengen mit einer bestimmten Struktur Abbildungen vorgenommen werden können, während die Struktur der Operationen erhalten bleibt. In der Kryptographie bedeutet die “homomorphe” Eigenschaft, dass Operationen im Klartextraum den Operationen im Geheimtextraum entsprechen.

Ausgedrückt in einer einfachen Formel: Sei $E(\cdot)$ die Verschlüsselungsfunktion und $D(\cdot)$ die Entschlüsselungsfunktion für die Klartexte $m_1$ und $m_2$. Wenn wir die Operation auf dem Klartext (wie Addition oder Multiplikation) als $\circ$ und die Operation auf dem Geheimtext als $\diamond$ bezeichnen, gilt die folgende Beziehung:

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

Das bedeutet, wenn wir das Ergebnis einer Operation $\diamond$ auf die Geheimtexte $E(m_1)$ und $E(m_2)$ entschlüsseln, stimmt es mit dem Ergebnis der Operation $\circ$ auf die ursprünglichen Klartexte überein.

Datenfluss im Cloud Computing

Die Architektur der Cloud-Verarbeitung mit FHE unterscheidet sich völlig von herkömmlichen Methoden. Das folgende Diagramm zeigt den Ablauf einer sicheren Datenverarbeitung unter Verwendung von FHE.

Der Server empfängt die verschlüsselten Daten $E(x)$, aber da er den privaten Schlüssel nicht besitzt, kann er unmöglich den Inhalt der Daten kennen. Durch Ausnutzung der Eigenschaften von FHE kann er jedoch eine Funktion $f$ (zum Beispiel ein maschinelles Lern-Inferenzmodell) auf den Geheimtext anwenden und $E(f(x))$ erzeugen. Der Client empfängt dies und entschlüsselt es mit seinem eigenen privaten Schlüssel, um das gewünschte Ergebnis $y = f(x)$ zu erhalten.

2. Die Evolutionsgeschichte der homomorphen Verschlüsselung: PHE, SHE, FHE

Die homomorphe Verschlüsselung hat ihre aktuelle “vollständige” Form nicht auf einmal erreicht. Sie wird je nach Art und Anzahl der durchführbaren Operationen grob in drei Phasen eingeteilt.

Partially Homomorphic Encryption (PHE: Partiell homomorphe Verschlüsselung)

PHE ist ein Verschlüsselungsschema, das es erlaubt, entweder Addition oder Multiplikation unbegrenzt durchzuführen. Tatsächlich existieren Verschlüsselungen mit dieser Eigenschaft schon seit langer Zeit.

RSA-Verschlüsselung (Homomorphismus bezüglich Multiplikation) Die RSA-Verschlüsselung hatte unbeabsichtigt eine multiplikative homomorphe Eigenschaft. Seien $m_1, m_2$ Klartexte und $(e, N)$ der öffentliche Schlüssel: $$ E(m_1) = m_1^e \pmod N $$ $$ E(m_2) = m_2^e \pmod N $$ Wenn wir diese multiplizieren: $$ E(m_1) \times E(m_2) = (m_1 \cdot m_2)^e \pmod N = E(m_1 \times m_2) $$ Auf diese Weise entspricht die Multiplikation von Geheimtexten der Multiplikation von Klartexten.
Paillier-Verschlüsselung (Homomorphismus bezüglich Addition) Die 1999 erfundene Paillier-Verschlüsselung besitzt eine additive homomorphe Eigenschaft. Sie wird in der Praxis für elektronische Wahlen (Zählen von verschlüsselten Stimmen und Entschlüsseln nur des Endergebnisses) verwendet.

Somewhat Homomorphic Encryption (SHE: Etwas homomorphe Verschlüsselung)

Dieses Schema kann sowohl Addition als auch Multiplikation ausführen, aber es gibt eine Grenze für die Anzahl der Operationen (die Tiefe der Schaltung), die durchgeführt werden können. Aufgrund der Ansammlung von “Rauschen”, das später erläutert wird, wird die Entschlüsselung nach einer bestimmten Anzahl von Multiplikationen unmöglich. Die BGN (Boneh-Goh-Nissim)-Verschlüsselung von 2005 ist ein solches Beispiel, aber sie hatte Einschränkungen bei der Durchführung komplexer praktischer Berechnungen (wie Deep Learning).

Fully Homomorphic Encryption (FHE: Vollständig homomorphe Verschlüsselung)

Ein Verschlüsselungsschema, das sowohl Addition als auch Multiplikation unbegrenzt oft ausführen kann. Ähnlich der Turing-Vollständigkeit in der Informationstheorie bedeutet dies: Wenn Addition (entspricht XOR) und Multiplikation (entspricht AND) unendlich oft kombiniert werden können, kann theoretisch jede berechenbare Funktion oder jeder Algorithmus in einem verschlüsselten Zustand ausgeführt werden.

FHE wurde lange Zeit als der “Heilige Gral der Kryptographie” bezeichnet und man hielt es sogar für unmöglich, dies zu erreichen. Im Jahr 2009 schlug Craig Gentry, der damals Doktorand an der Stanford University war, jedoch das erste FHE-Schema vor, das ideale Gitter (Ideal Lattices) nutzte und die Welt schockierte.

3. Mathematische Grundlagen von FHE: Das LWE-Problem und Ring-LWE

Viele der heutigen Mainstream-FHE-Schemata basieren auf dem LWE (Learning With Errors)-Problem, einer mathematischen Herausforderung der “gitterbasierten Kryptographie” (Lattice-based Cryptography), die auch als Post-Quanten-Kryptographie (Post-Quantum Cryptography) bekannt ist.

Intuitives Verständnis des LWE-Problems

Das Lösen von linearen Gleichungssystemen ist mit Methoden wie der Gaußschen Elimination einfach.

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

Was passiert jedoch, wenn wir den Ergebnissen dieser Gleichungen einen sehr kleinen “zufälligen Fehler (Rauschen)” $e$ hinzufügen?

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

Nur durch Hinzufügen dieses Fehlers $e$ verwandelt sich das Problem, den geheimen Variablenvektor $\vec{s}$ zu finden, in ein NP-schweres Problem, das selbst mit aktuellen Supercomputern oder Quantencomputern schwer zu knacken ist. Dies ist das LWE-Problem.

Das Ring-LWE-Problem (RLWE)

Das Standard-LWE-Problem beinhaltet Matrixoperationen, was zu dem Problem führt, dass die Schlüsselgrößen sehr groß sind (manchmal in der Größenordnung von Gigabyte) und die Berechnungseffizienz gering ist. Um dies zu lösen, wurde das Ring-LWE (RLWE)-Problem eingeführt, welches Operationen über Polynomringen verwendet.

In RLWE gehören die Elemente zum Polynomring $R_q = \mathbb{Z}_q[x] / (x^N + 1)$ (wobei $N$ eine Zweierpotenz und $q$ eine Primzahl als Modul ist). Wenn der private Schlüssel ein Polynom $s(x)$, $a(x)$ ein zufälliges Polynom und $e(x)$ ein kleines Rauschpolynom ist, ist der öffentliche Schlüssel das folgende Paar:

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

Während der Verschlüsselung werden die Eigenschaften dieser Polynome genutzt, um den Klartext $m(x)$ zu kodieren und den Geheimtext zu erzeugen.

4. Das größte Hindernis “Rauschen” und Gentrys Bootstrapping

Das wichtigste Konzept für das Verständnis von FHE ist das “Rauschmanagement”.

In LWE/RLWE-basierter Kryptographie wird absichtlich ein kleines “Rauschen (Fehler)” eingeschlossen, um die Sicherheit zu gewährleisten. Der Prozess der Entschlüsselung des Geheimtextes $c$ eines Klartextes $m$ wird grob durch die folgende Formel ausgedrückt:

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

Bei der Entschlüsselung wird dieses noise durch Prozesse wie Rundung entfernt, um den richtigen Klartext $m$ zu erhalten. Wenn Sie jedoch homomorphe Operationen (insbesondere Multiplikation) zwischen Geheimtexten durchführen, wird dieses Rauschen dramatisch verstärkt.

Homomorphe Addition: Rauschen nimmt additiv zu ($e_1 + e_2$). Dies ist eine relativ langsame Zunahme.
Mathematischer Ausdruck der homomorphen Eigenschaft für homomorphe Addition: $$ E(m_1) \oplus E(m_2) = E(m_1 + m_2) $$
Homomorphe Multiplikation: Rauschen explodiert multiplikativ (weil es Ausdrücke wie $e_1 \times e_2$ enthält). Nach nur wenigen Multiplikationen überschreitet das Rauschen den Schwellenwert $q/2$, was eine korrekte Rundung unmöglich macht und die Entschlüsselung fehlschlägt.
Mathematischer Ausdruck der homomorphen Eigenschaft für homomorphe Multiplikation: $$ E(m_1) \otimes E(m_2) = E(m_1 \times m_2) $$

Aus diesem Grund war FHE lange Zeit nicht realisierbar und blieb auf SHE (mit einer begrenzten Anzahl von Operationen) beschränkt.

Die Magie des Bootstrapping

Craig Gentrys genialer Beitrag war die Erfindung einer Rauschreduzierungstechnik namens “Bootstrapping”. Dies war ein Paradigmenwechsel in der Kryptographie.

Intuitiv ist es die Operation: “Bevor der Geheimtext mit Rauschen bedeckt und zerstört wird, ’entschlüsseln’ wir ihn im verschlüsselten Zustand, bereinigen ihn und legen ihn in einen neuen Geheimtext.”

Angenommen, wir haben einen Geheimtext $C_{noisy}$ mit hohem Rauschen.
Der Client übergibt im Voraus an den Server seinen privaten Schlüssel $sk$, der “mit dem öffentlichen Schlüssel verschlüsselt” ist, nämlich $E_{pk}(sk)$ (dies wird als Bootstrapping-Schlüssel bezeichnet).
Der Server führt homomorph eine Entschlüsselungsschaltung (Decryption Circuit) auf $C_{noisy}$ aus.
Insbesondere führt er eine “Entschlüsselung innerhalb des verschlüsselten Raums” durch, indem er $E_{pk}(sk)$ auf $E_{pk}(C_{noisy})$ anwendet.
Da diese Entschlüsselungsschaltung selbst eine homomorphe Operation ist, erzeugt sie neues Rauschen, aber das Rauschen des ausgegebenen neuen Geheimtextes $C_{fresh}$ wird auf ein bestimmtes “festes Niveau” zurückgesetzt.

graph LR A["Geheimtext mit hohem Rauschen C_noisy"] --> B["Homomorphe Entschlüsselungsschaltung (Eval_Dec)"] C["Verschlüsselter privater Schlüssel E(sk)"] --> B B --> D["Geheimtext mit geringem Rauschen C_fresh"] style B fill:#ffeeba,stroke:#ffc107

Durch die regelmäßige Ausführung dieses Bootstrappings während der Berechnung ist es theoretisch möglich, eine Schaltung unendlicher Tiefe zu berechnen (Erreichen von FHE). Die frühe Methode von Gentry hatte jedoch einen so hohen Rechenaufwand, dass ein einziger Bootstrapping-Prozess zig Minuten bis Stunden in Anspruch nahm.

5. FHE-Generationen und die Evolution der wichtigsten Schemata

Um FHE in die Praxis umzusetzen, haben Kryptographen auf der ganzen Welt darum gewetteifert, die Algorithmen zu verbessern. Gegenwärtig wird FHE hauptsächlich in vier Generationen/Familien eingeteilt.

Zweite Generation: Exakte Berechnung von Ganzzahlen (BGV, BFV)

Die BGV (Brakerski-Gentry-Vaikuntanathan) und BFV (Brakerski/Fan-Vercauteren) Schemata tauchten in den Jahren 2011-2012 auf. Diese basieren auf RLWE und eignen sich gut für modulare Arithmetik (exakte Berechnungen) mit ganzen Zahlen. Sie unterstützen Batching-Technologien wie SIMD (Single Instruction, Multiple Data), die es ermöglichen, Tausende von Datensteckplätzen in einen einzigen riesigen Polynom-Geheimtext zu packen und sie alle auf einmal parallel zu berechnen.

Dritte Generation: Beschleunigung des Bootstrapping (GSW, FHEW, TFHE)

Das GSW (Gentry-Sahai-Waters) Schema von 2013 vereinfachte die Struktur von FHE. Dies wurde weiterentwickelt zu einem der heutigen Mainstream-Schemata, TFHE (Fast Fully Homomorphic Encryption over the Torus). Das Besondere an TFHE ist, dass sein Bootstrapping extrem schnell (im Millisekundenbereich) ist. Es ist stark bei Operationen auf Gatterebene (Logikschaltungen wie AND, XOR) und hat eine relativ kleine Geheimtextgröße, wodurch es sich zur schnellen Auswertung beliebiger Logikschaltungen eignet.

Vierte Generation: Spezialisierung auf Näherungsberechnungen und maschinelles Lernen (CKKS)

Das 2017 von Cheon et al. vorgeschlagene CKKS (Cheon-Kim-Kim-Song) Schema ist die definitive Technologie für den Schutz der Privatsphäre in der heutigen KI und beim maschinellen Lernen. Während sich bisherige FHE auf “exakte Ganzzahlberechnungen” konzentrierten, unterstützt CKKS “Näherungsberechnungen von Fließkommazahlen” im verschlüsselten Zustand. Es zeigt eine überwältigende Leistung bei Berechnungen mit reellen Zahlen, bei denen kleine Fehler toleriert werden, wie z.B. das Training und die Inferenz von neuronalen Netzen.

Die folgende Tabelle fasst zusammen, wie Sie ein Schema basierend auf Ihrem Zweck auswählen.

Schema-Name	Bevorzugter Datentyp	Empfohlene Anwendungsfälle	Merkmale
BFV / BGV	Ganzzahlen (Integer)	Genaue statistische Berechnungen, Aggregation von Finanzdaten, DB-Suche	Hoher Durchsatz durch SIMD-Batching
CKKS	Reelle Zahlen (Real/Complex)	Maschinelles Lernen (DNN, logistische Regression), Signalverarbeitung	Beschleunigung durch Näherungsberechnungen, Reskalierung
TFHE	Boolesche Werte (Boolean)	Beliebige Logikschaltungen, String-Suche, Auswertung nichtlinearer Funktionen	Ultraschnelles Bootstrapping (Millisekundenbereich)

6. Praxis: FHE-Bibliotheken und konzeptioneller Code

Heutzutage gibt es viele Open-Source-Bibliotheken, mit denen man FHE nutzen kann, ohne fundierte Kenntnisse der Kryptographie zu besitzen.

Microsoft SEAL (Simple Encrypted Arithmetic Library): Eine C++-Bibliothek, die BFV, BGV und CKKS unterstützt. Einer der Industriestandards. Die Python-Anbindung TenSEAL ist bei KI-Ingenieuren sehr beliebt.
Zama (Concrete): Ein Framework basierend auf TFHE. Es kann in Rust/Python geschrieben werden und bietet die Funktion (Concrete ML), bestehende PyTorch-Modelle zu kompilieren und auf FHE auszuführen.
OpenFHE: Der Nachfolger von PALISADE, eine umfassende C++-Bibliothek, die alle gängigen Schemata unterstützt.

Beispiel für FHE-Programmierung in Python (TenSEAL)

Hier ist ein konzeptionelles Python-Codebeispiel unter Verwendung des CKKS-Schemas, das Vektoren aus reellen Zahlen addiert und multipliziert, während sie verschlüsselt bleiben.

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


import tenseal as ts

# 1. Kontext-Setup (inklusive Schlüsselerzeugung)
# Verwendung des CKKS-Schemas, Polynomgrad auf 8192 gesetzt
context = ts.context(
 ts.SCHEME_TYPE.CKKS,
 poly_modulus_degree=8192,
 coeff_mod_bit_sizes=[60, 40, 40, 60]
)
context.generate_galois_keys()
context.global_scale = 2**40 # Skalierungsfaktor für reelle Zahlen

# 2. Client-Seite: Daten verschlüsseln
vector1 = [1.5, 2.5, 3.5]
vector2 = [2.0, 3.0, 4.0]

# Klartext-Vektoren in Geheimtexte umwandeln (wird normalerweise auf der Client-Seite ausgeführt)
enc_v1 = ts.ckks_vector(context, vector1)
enc_v2 = ts.ckks_vector(context, vector2)

# 3. Server-Seite: Operationen in verschlüsseltem Zustand (Schutz von Data in Use)
# Der Server kennt den Klartext nicht, kann aber Addition und Multiplikation ausführen
enc_add = enc_v1 + enc_v2
enc_mul = enc_v1 * enc_v2

# 4. Client-Seite: Ergebnisse entschlüsseln
# Nur der Client mit dem privaten Schlüssel kann das Ergebnis sehen
res_add = enc_add.decrypt()
res_mul = enc_mul.decrypt()

print(f"Entschlüsseltes Additionsergebnis: {res_add}")
# Beispielausgabe: [3.5000001, 5.5000001, 7.5000002] (enthält aufgrund der Näherungsberechnung einen winzigen Fehler)

print(f"Entschlüsseltes Multiplikationsergebnis: {res_mul}")
# Beispielausgabe: [3.0000002, 7.5000005, 14.0000003]

Wie aus dem obigen Code ersichtlich ist, können Sie Berechnungen zwischen Geheimtexten intuitiv schreiben, indem Sie Standard-Python-Operatoren wie in enc_v1 + enc_v2 überladen. Auf der Serverseite werden Vektoroperationen abgeschlossen, ohne den Inhalt der Vektoren zu kennen.

7. Herausforderungen von FHE: Leistung und Hardware-Beschleunigung

Während FHE theoretisch perfekte Sicherheit bietet, ist die größte Herausforderung bei seiner praktischen Anwendung der “Leistungs-Overhead”.

Rechenaufwand: Im Vergleich zu Berechnungen mit Klartexten sind Berechnungen mit Geheimtexten auf CPUs Tausende bis Zehntausende Male langsamer. Polynommultiplikation und Bootstrapping erfordern massive Mengen an FFT- (Fast Fourier Transform) oder NTT- (Number Theoretic Transform) Berechnungen.
Datenexpansion (Ciphertext Expansion): Ein paar Byte Klartext können im verschlüsselten Zustand zu mehreren Megabyte werden. Dies übt großen Druck auf die Speicherbandbreite und die Netzwerkbandbreite aus.

Ansätze für Hardware-Lösungen

Um diesen Overhead zu überwinden, treibt man weltweit die Entwicklung von FHE-spezifischen Hardware-Beschleunigern (ASIC, FPGA, GPU-Unterstützung) voran.

GPU-Beschleunigung: Die Bemühungen schreiten voran, um NTT-Berechnungen und Bootstrapping mit leistungsstarken GPUs wie denen von NVIDIA zu parallelisieren, was eine zigfache Beschleunigung gegenüber Softwareimplementierungen meldet (z. B. 100x.ai, Zamas TFHE-rs CUDA-Backend).
DARPA DPRIVE-Projekt: Die US-amerikanische Defense Advanced Research Projects Agency (DARPA) fördert “DPRIVE (Data Protection in Virtual Environments)”, ein Projekt zur Entwicklung dedizierter Hardware, um die Berechnungsgeschwindigkeit von FHE auf ein Niveau anzuheben, das dem der Klartextverarbeitung entspricht (innerhalb des 10-fachen Overheads). Unternehmen wie Intel, Microsoft und Intellectual Ventures sind daran beteiligt.
Aufkommen der FPU (FHE Processing Unit): Start-ups wie Cornami und Optalysys haben mit der Entwicklung von FHE-spezifischen Chips begonnen, die optisches Computing oder spezielle Siliziumarchitekturen nutzen.

In naher Zukunft wird es möglicherweise eine Zeit geben, in der “FPUs” standardmäßig in Servern und Cloud-Infrastrukturen installiert sind, ähnlich wie NPUs (Neural Processing Units) in der KI.

8. Erwartete Anwendungsfälle

Da FHE mittlerweile praktische Geschwindigkeiten erreicht, werden bahnbrechende Innovationen in den folgenden Bereichen erwartet.

Schutz der Privatsphäre in der medizinischen und genomischen Analyse: Indem die von mehreren Krankenhäusern gehaltenen Patientenakten und DNA-Daten mit FHE verschlüsselt und von der Cloud-KI trainiert werden, können hochpräzise Krebsdiagnosemodelle und die Entwicklung neuer Medikamente durchgeführt werden, ohne gegen Datenschutzgesetze (wie HIPAA oder DSGVO) zu verstoßen.
Betrugserkennung und Anti-Geldwäsche (AML) für Finanzinstitute: Konkurrierende Banken können gegenseitig ihre Daten in verschlüsselter Form abgleichen, um riesige illegale Überweisungsnetzwerke zu erkennen (Cross-Bank-Analyse), ohne Kundenkontoinformationen oder Transaktionshistorien preiszugeben.
Sichere KI-Inferenz-API (MaaS: Model as a Service): Benutzer verschlüsseln ihre eigene Stimme, Gesichtsbilder oder Prompts und senden sie an einen KI-Dienst (z.B. ein LLM wie ChatGPT). Der KI-Anbieter generiert Antworten, ohne die Eingabe des Benutzers jemals zu kennen, und gibt sie als Geheimtext zurück. Dies beseitigt vollständig die Sorge, dass “die KI persönliche Informationen lernt oder einsehen kann”.

9. Fazit: Die Zukunft der Kryptographie geht hin zu “unsichtbaren Berechnungen”

Genauso wie die Erfindung der Public-Key-Kryptographie (RSA) in den 1970er Jahren die sichere Kommunikation (wie HTTPS) über das Internet ermöglichte, ist die Erfindung von FHE durch Craig Gentry einer der wichtigsten Meilensteine in der Geschichte der Kryptographie.

Heute verlässt die vollständig homomorphe Verschlüsselung (FHE) die Forschungslabors und tritt in ein Stadium ein, in dem Microsoft, IBM, Intel, Google und viele Start-ups um die Kommerzialisierung wetteifern. Herausforderungen hinsichtlich der Rechenkosten und der Datengröße bestehen weiterhin, aber durch die Verfeinerung von Algorithmen und die Entwicklung von Hardware-Beschleunigern wird die Leistung in einem Tempo verbessert, das das Mooresche Gesetz übertrifft.

In wenigen Jahren wird es nichts Besonderes mehr sein, “zu rechnen, während die Daten verschlüsselt bleiben”, sondern es wird eine Standard-Best-Practice für den Datenschutz bei Cloud-Diensten werden. FHE ist der Schlüssel zur Sicherheit der nächsten Generation und realisiert die ultimative Balance zwischen Datenschutz und Datennutzung in unserer datengesteuerten Gesellschaft.

Mathematische Grundlagen der Elliptischen-Kurven-Kryptographie (ECC) und ihre Implementierung in C++

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

Mathematische Grundlagen der Elliptischen-Kurven-Kryptographie (ECC) und ihre Implementierung in C++

In der modernen Kryptographie spielt die Elliptische-Kurven-Kryptographie (Elliptic Curve Cryptography: ECC) eine äußerst wichtige Rolle. Von unserer täglichen Internetkommunikation (HTTPS/TLS) über die Secure Enclaves von Smartphones, Serverauthentifizierung via SSH, passwortlose Authentifizierung wie FIDO bis hin zu Krypto-Assets wie Bitcoin und Ethereum – man kann ohne Übertreibung sagen, dass die Vertrauensbasis unserer modernen digitalen Gesellschaft durch ECC gestützt wird.

In diesem Artikel werden wir ausführlich erläutern, wie diese elliptische Kurven-Kryptographie funktioniert. Wir beginnen mit der schönen, aber komplexen mathematischen Theorie dahinter (algebraische Geometrie über endlichen Körpern), gehen dann zur tatsächlichen Implementierung in C++ über und behandeln schließlich sichere Codierungstechniken zur Verhinderung von Seitenkanalangriffen (Timing-Angriffen) – alles in einem überwältigenden Detailreichtum.

1. Warum Elliptische-Kurven-Kryptographie? (Vergleich mit RSA)

Lange Zeit war RSA das Synonym für Public-Key-Kryptographie. Die Sicherheit von RSA basiert auf der “Schwierigkeit der Primfaktorzerlegung riesiger zusammengesetzter Zahlen”. Mit der steigenden Rechenleistung von Computern wurde es jedoch notwendig, die Schlüssellänge von RSA (die Bitlänge des Moduls) kontinuierlich zu erhöhen, um die Sicherheit aufrechtzuerhalten. Heutzutage wird eine Schlüssellänge von mindestens 2048 Bit empfohlen, für noch mehr Sicherheit sogar 3072 oder 4096 Bit.

Im Gegensatz dazu basiert die Elliptische-Kurven-Kryptographie (ECC) auf einer anderen mathematischen Schwierigkeit: dem “Diskreten Logarithmusproblem auf elliptischen Kurven (ECDLP)”. Bis heute wurde kein effizienter Algorithmus (wie z. B. ein Subexponentialzeit-Algorithmus) zur Lösung des ECDLP gefunden, und selbst die effizientesten bekannten Angriffsmethoden benötigen exponentielle Zeit.

Aufgrund dieser Eigenschaft hat ECC den entscheidenden Vorteil, dass es mit sehr kurzen Schlüssellängen die gleiche Sicherheitsstärke wie RSA erreichen kann.

Sicherheitsstärke (Bit)	RSA-Schlüssellänge (Bit)	ECC-Schlüssellänge (Bit)	Längenverhältnis
80	1024	160	1:6
112	2048	224	1:9
128	3072	256	1:12
192	7680	384	1:20
256	15360	512	1:30

Wie die obige Tabelle zeigt, benötigt RSA für eine Sicherheitsstärke von 128 Bit (die aktuelle Standardstärke) einen 3072-Bit-Schlüssel, während ECC mit nur 256 Bit auskommt. Dies ermöglicht eine Reduzierung des Rechenaufwands, einen geringeren Speicherverbrauch und die Einsparung von Netzwerkbandbreite. Dadurch ist ECC besonders in ressourcenbeschränkten Umgebungen wie IoT-Geräten und Smartcards überlegen.

2. Mathematische Vorbereitung: Gruppentheorie und endliche Körper

Um die Elliptische-Kurven-Kryptographie wirklich zu verstehen, ist es notwendig, die grundlegenden Konzepte der abstrakten Algebra (Gruppen- und Körpertheorie) zu beherrschen. Hier fassen wir das Vorwissen zur Konstruktion von ECC kurz zusammen.

2.1. Gruppen (Group) und abelsche Gruppen

Eine Gruppe (Group) ist ein Paar $(G, +)$, bestehend aus einer Menge $G$ und einer binären Operation auf dieser Menge (hier als Addition $+$ bezeichnet), das die folgenden vier Axiome erfüllt:

Abgeschlossenheit (Closure): Für beliebige $a, b \in G$ gilt $a + b \in G$.
Assoziativgesetz (Associativity): Für beliebige $a, b, c \in G$ gilt $(a + b) + c = a + (b + c)$.
Existenz eines neutralen Elements (Identity element): Es existiert ein Element $e \in G$, sodass für jedes $a \in G$ gilt: $a + e = e + a = a$. Bei additiven Gruppen wird dieses neutrale Element meist als $0$ oder $\mathcal{O}$ geschrieben.
Existenz inverser Elemente (Inverse element): Zu jedem $a \in G$ existiert ein Element $b \in G$, sodass $a + b = b + a = e$. Dieses $b$ wird als $-a$ bezeichnet.

Eine Gruppe, in der die Reihenfolge der Operanden das Ergebnis nicht verändert, d. h. die folgende Bedingung erfüllt ist, wird als abelsche Gruppe (kommutative Gruppe) bezeichnet:

Kommutativgesetz (Commutativity): Für beliebige $a, b \in G$ gilt $a + b = b + a$.

Die Menge der Punkte auf einer elliptischen Kurve bildet eine solche abelsche Gruppe, wenn wir eine spezifische Additionsregel definieren.

2.2. Endliche Körper (Finite Field)

In der Kryptographietheorie verwenden wir keine Körper mit kontinuierlichen und unendlich vielen Elementen wie die reellen oder komplexen Zahlen, sondern endliche Körper (Finite Fields) oder Galois-Körper (Galois Fields), deren Elementanzahl endlich ist.

Der grundlegendste endliche Körper ist der Primkörper $\mathbb{F}_p$ unter Verwendung einer Primzahl $p$. Dies ist die Menge der ganzen Zahlen $\{0, 1, 2, \dots, p-1\}$ versehen mit den vier Grundrechenarten (Addition, Subtraktion, Multiplikation, Division) modulo $p$ (dem Rest bei Division durch $p$).

Addition: $(a + b) \pmod p$
Subtraktion: $(a - b) \pmod p$
Multiplikation: $(a \times b) \pmod p$
Division: $a \times b^{-1} \pmod p$ (wobei $b^{-1}$ das multiplikative Inverse von $b$ modulo $p$ ist)

Die Berechnung des multiplikativen Inversen (Modular Multiplicative Inverse) ist in der kryptographischen Implementierung extrem wichtig. Um ein $b^{-1}$ zu finden, das $b \times b^{-1} \equiv 1 \pmod p$ erfüllt, werden hauptsächlich die folgenden zwei Algorithmen verwendet:

Erweiterter euklidischer Algorithmus (Extended Euclidean Algorithm): Er ist schnell, aber je nach Implementierung ist die Ausführungszeit vom Eingabewert abhängig, was das Risiko von Timing-Angriffen birgt.
Kleiner fermatscher Satz (Fermat’s Little Theorem): Wenn $p$ eine Primzahl ist und $b \neq 0$, gilt $b^{p-1} \equiv 1 \pmod p$. Teilt man beide Seiten durch $b$, erhält man $b^{p-2} \equiv b^{-1} \pmod p$. Das heißt, durch Berechnung von $b$ hoch $p-2$ erhält man das Inverse. Da modulare Potenzierung leicht in konstanter Zeit (Constant-Time) implementiert werden kann, wird dies bei kryptographischen Implementierungen bevorzugt.

3. Die Gleichung und Geometrie der elliptischen Kurve

3.1. Die Weierstraß-Normalform

Eine elliptische Kurve (Elliptic Curve) ist im Allgemeinen eine ebene Kurve, die durch die folgende Gleichung definiert wird, bekannt als Weierstraß-Normalform (Weierstrass normal form):

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

Hierbei sind $a$ und $b$ Konstanten. Als Bedingung dafür, dass die Kurve keine Singularitäten (Selbstüberschneidungen oder Spitzen) aufweist (d. h. eine glatte Kurve ist), darf die folgende Diskriminante (Discriminant) $\Delta$ nicht null sein:

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

Da Kurven mit Singularitäten die kryptographische Sicherheit beeinträchtigen, werden immer Koeffizienten $a, b$ gewählt, die diese Bedingung erfüllen.

3.2. Der Punkt im Unendlichen (Point at Infinity)

Um die elliptische Kurve mathematisch zu einer vollständigen Gruppe zu machen, führen wir neben den Punkten auf der Ebene einen virtuellen Punkt ein, den “Punkt im Unendlichen” (Point at Infinity). Dieser wird mit $\mathcal{O}$ bezeichnet.

Der Punkt im Unendlichen $\mathcal{O}$ ist definiert als der Punkt, an dem sich alle vertikalen Linien in der unendlichen Ferne schneiden. In der Gruppentheorie fungiert dieser Punkt im Unendlichen $\mathcal{O}$ als neutrales Element (die Null) der Addition.

Das heißt, für jeden beliebigen Punkt $P$ auf der Kurve gilt:

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

Zudem ist das Inverse $-P$ eines Punktes $P = (x, y)$ definiert als der an der x-Achse gespiegelte Punkt $(x, -y)$. Daher gilt:

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

4. Gruppenoperationen auf elliptischen Kurven (Punktaddition und -verdopplung)

Die Grundlage der Elliptischen-Kurven-Kryptographie ist die “Addition” von Punkten auf der Kurve. Diese unterscheidet sich von der gewöhnlichen Addition von Ganzzahlen und wird basierend auf geometrischen Operationen definiert.

4.1. Geometrische Addition (Tangent and Chord Method)

Das Verfahren, um zwei verschiedene Punkte $P$ und $Q$ auf der Kurve zu addieren, um einen neuen Punkt $R$ ($R = P + Q$) zu finden, ist wie folgt:

Ziehe eine Gerade (Sekante) durch den Punkt $P$ und den Punkt $Q$.
Diese Gerade schneidet die elliptische Kurve garantiert in einem dritten Punkt (nennen wir ihn $-R$). (※ Gemäß den Sätzen der algebraischen Geometrie)
Der Punkt, den man erhält, wenn man den Schnittpunkt $-R$ an der x-Achse spiegelt (also das Vorzeichen der y-Koordinate umkehrt), ist der gesuchte Punkt $R$.

graph TD Step1["Ziehe eine Gerade durch P(x1, y1) und Q(x2, y2)"] --> Step2["Finde den dritten Schnittpunkt -R mit der Kurve"] Step2 --> Step3["Spiegele -R an der x-Achse, um R(x3, y3) zu erhalten"] Step3 -.-> Result["Dies ist R = P + Q"]

4.2. Punktverdopplung (Point Doubling)

Wenn man denselben Punkt $P$ zu sich selbst addiert ($P + P = 2P$), kann man keine Gerade durch zwei Punkte ziehen. In diesem Fall zieht man die Tangente an die Kurve im Punkt $P$.

Ziehe die Tangente an die Kurve im Punkt $P$.
Diese Tangente schneidet die Kurve in einem weiteren Punkt $-R$.
Der an der x-Achse gespiegelte Schnittpunkt ist der gesuchte Punkt $R = 2P$.

4.3. Algebraische Berechnungsformeln

Wir übersetzen die geometrischen Operationen in algebraische Formeln, die von einem Computer berechnet werden können. Alle Operationen werden über dem endlichen Körper $\mathbb{F}_p$ (modulo $p$) durchgeführt.

Seien die Punkte $P = (x_1, y_1)$ und $Q = (x_2, y_2)$. Zudem sei der berechnete Ergebnispunkt $R = P + Q = (x_3, y_3)$.

Die Steigung der Geraden nennen wir $\lambda$ (Lambda).

[Fall 1: Wenn $P \neq Q$ (Punktaddition)] Die Steigung $\lambda$ ist die Änderungsrate zwischen den beiden Punkten.

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

Mit diesem $\lambda$ können $x_3, y_3$ wie folgt berechnet werden:

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

[Fall 2: Wenn $P = Q$ (Punktverdopplung)] Die Steigung $\lambda$ ist die Steigung der Tangente, die durch Ableitung ermittelt wird. (Wir leiten $y^2 = x^3 + ax + b$ implizit ab)

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

Daher gilt:

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

Die Formeln für $x_3, y_3$ haben die gleiche Form wie bei der Addition, aber da $x_2 = x_1$, ergibt sich:

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

[!IMPORTANT] Diese Formeln enthalten Divisionen (Berechnung des modularen Inversen) wie $(x_2 - x_1)^{-1}$ und $(2y_1)^{-1}$. Da die Berechnung des modularen Inversen sehr rechenintensiv ist, werden in tatsächlichen Implementierungen allgemein projektive Koordinatensysteme wie die “Jacobi-Koordinaten (Jacobian Coordinates)” verwendet, die die Division verzögern.

5. Skalarmultiplikation und das Diskrete Logarithmusproblem (ECDLP)

Die rechenintensivste Operation in der Elliptischen-Kurven-Kryptographie, die gleichzeitig den Kern der Sicherheit bildet, ist die Skalarmultiplikation (Scalar Multiplication).

5.1. Was ist Skalarmultiplikation?

Die Operation, einen Punkt $P$ $k$-mal zu addieren, wird als Skalarmultiplikation bezeichnet und als $kP$ geschrieben.

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

Hierbei ist $k$ eine sehr große Ganzzahl (zum Beispiel eine 256-Bit-Ganzzahl).

5.2. Diskretes Logarithmusproblem auf elliptischen Kurven (ECDLP)

Die Sicherheit der Elliptischen-Kurven-Kryptographie beruht auf der Schwierigkeit des folgenden Problems:

Diskretes Logarithmusproblem auf elliptischen Kurven (Elliptic Curve Discrete Logarithm Problem: ECDLP) Gegeben sei ein bekannter Punkt $P$ (Basispunkt) und ein berechneter Punkt $Q$. Finde den Skalar $k$, der $Q = kP$ erfüllt.

Es ist mit dem unten beschriebenen Algorithmus einfach (in polynomieller Zeit machbar), $Q$ aus $k$ und $P$ zu berechnen (Vorwärtsrichtung), aber es ist praktisch unmöglich, $k$ aus $P$ und $Q$ zurückzurechnen (Rückwärtsrichtung), da es außer Brute-Force-Suchen keine effiziente Lösungsmethode gibt (Einwegfunktion). In kryptographischen Protokollen entspricht $k$ dem “privaten Schlüssel” und $Q$ dem “öffentlichen Schlüssel”.

5.3. Double-and-Add-Algorithmus

Wenn $k$ eine riesige Zahl ist (z. B. $2^{256}$), würde die naive Addition von $P$ um $k$-mal das Ende der Lebensdauer des Universums überdauern. Daher wird die Double-and-Add-Methode (binäre Methode) verwendet, um die Skalarmultiplikation schnell durchzuführen.

Dies ist die elliptische Kurvenversion der “binären Exponentiation”, mit der die Potenzierung von Ganzzahlen schnell berechnet wird. Der Skalar $k$ wird binär dargestellt und vom höchstwertigen Bit an verarbeitet.

Initialisiere den Punkt $R$, der das Ergebnis hält, mit $\mathcal{O}$.
Wiederhole für jedes Bit von $k$, vom höchstwertigen bis zum niederwertigsten:
- Verdopple $R$ (Point Doubling: $R = 2R$)
- Wenn das aktuelle Bit 1 ist, addiere $P$ zu $R$ (Point Addition: $R = R + P$)

Durch diesen Algorithmus wird der Rechenaufwand drastisch von $O(k)$ auf $O(\log_2 k)$ reduziert, was die Berechnung in realistischer Zeit (im Millisekundenbereich) ermöglicht.

6. Elliptic Curve Diffie-Hellman (ECDH) Schlüsselaustausch

Hier erklären wir den Mechanismus des ECDH (Elliptic Curve Diffie-Hellman) Schlüsselaustauschprotokolls, welches das repräsentativste Anwendungsbeispiel für ECC ist. ECDH ist ein Mechanismus, mit dem Alice und Bob sicher einen gemeinsamen geheimen Schlüssel (Sitzungsschlüssel) über einen abhörbaren Kommunikationskanal generieren und austauschen können (dies ist der Kern des TLS-Handshakes).

[Vorab-Parameter (Domain Parameters)] Beide Parteien haben sich im Voraus auf die zu verwendende elliptische Kurve $E$, die Primzahl $p$ und den Basispunkt $G$ geeinigt. (Beispiele sind NIST P-256 oder secp256k1)

sequenceDiagram participant Alice as "Alice" participant Bob as "Bob" Note over Alice,Bob: "Öffentliche Parameter: Kurve E, Basispunkt G, Primzahl p" Alice->>Alice: "Generiere privaten Schlüssel d_A (zufällige Ganzzahl)" Alice->>Alice: "Berechne öffentlichen Schlüssel Q_A = d_A * G" Bob->>Bob: "Generiere privaten Schlüssel d_B (zufällige Ganzzahl)" Bob->>Bob: "Berechne öffentlichen Schlüssel Q_B = d_B * G" Alice->>Bob: "Sende öffentlichen Schlüssel Q_A (Klartext)" Bob->>Alice: "Sende öffentlichen Schlüssel Q_B (Klartext)" Alice->>Alice: "Berechne gemeinsames Geheimnis S = d_A * Q_B" Bob->>Bob: "Berechne gemeinsames Geheimnis S = d_B * Q_A" Note over Alice,Bob: "S = d_A * (d_B * G) = d_B * (d_A * G) = (d_A * d_B) * G" Note over Alice,Bob: "Die berechneten Ergebnisse S von beiden stimmen exakt überein!"

Ein Lauscher (Eve) kann $G$, $Q_A$ und $Q_B$, die über den Kommunikationsweg fließen, abfangen, aber aufgrund der Schwierigkeit des ECDLP kann er Alices privaten Schlüssel $d_A$ nicht aus $Q_A = d_A \cdot G$ ermitteln. Außerdem ergibt die Multiplikation von $Q_A$ und $Q_B$ nicht den gemeinsamen Schlüssel $S$, sodass der Lauscher $S$ nicht berechnen kann.

7. Fallstricke bei der Implementierung: Seitenkanalangriffe und Gegenmaßnahmen

Selbst ein theoretisch perfekter kryptographischer Algorithmus kann im Prozess seiner Implementierung als Programm Schwachstellen aufweisen. Das sind die sogenannten “Seitenkanalangriffe” (Side-Channel Attacks).

7.1. Timing-Angriffe (Timing Attack)

Schauen wir uns den zuvor erwähnten Double-and-Add-Algorithmus noch einmal an.

1
2
3
4
5
6
7
8


// Pseudocode eines anfälligen Double-and-Add
Point R = Point::Infinity;
for (int i = 255; i >= 0; i--) {
 R = PointDoubling(R); // Wird immer ausgeführt
 if (bit(k, i) == 1) {
 R = PointAddition(R, P); // Wird nur ausgeführt, wenn das Bit 1 ist!
 }
}

Diese Implementierung hat einen fatalen Fehler. Da Point Addition ausgeführt wird, wenn das Bit 1 ist, ist die Berechnungszeit geringfügig länger, als wenn das Bit 0 ist. Darüber hinaus ändern sich auch die Sprungvorhersage (Branch Prediction) des Prozessors und das Verhalten des Cache-Speichers. Indem ein Angreifer diesen winzigen Unterschied in der Berechnungszeit (oder dem Stromverbrauch) tausendfach statistisch beobachtet, kann er die Bitfolge des privaten Schlüssels $k$ Bit für Bit vollständig rekonstruieren. Das ist ein Timing-Angriff.

7.2. Constant-Time-Implementierung: Montgomery Ladder

Um Timing-Angriffe zu verhindern, muss man einen Algorithmus wählen, bei dem die Abfolge der ausgeführten Befehle und die Berechnungszeit unabhängig vom Bitwert des privaten Schlüssels immer konstant (Constant-Time) sind.

Das typischste Beispiel dafür ist die Montgomery Ladder (Montgomery-Leiter).

graph TD Start["Initialisierung: R0 = O, R1 = P"] --> LoopStart["Für jedes Bit i (vom höchstwertigen)"] LoopStart --> Cond{"Wert von k_i?"} Cond -->|0| Branch0["R1 = R0 + R1
R0 = 2 * R0"] Cond -->|1| Branch1["R0 = R0 + R1
R1 = 2 * R1"] Branch0 --> LoopEnd["Zum nächsten Bit"] Branch1 --> LoopEnd LoopEnd --> LoopStart LoopStart -.->|"Alle Bits abgeschlossen"| End["Ende: R0 ist das Ergebnis (kP)"]

Das Schöne an der Montgomery Ladder ist, dass unabhängig davon, ob das Bit 0 oder 1 ist, “immer genau eine Point Addition und eine Point Doubling” ausgeführt werden. Dadurch wird die Datenabhängigkeit der Berechnungszeit vollständig eliminiert.

Wenn jedoch die Verzweigung (if (k_i == 0)) selbst vorhanden ist, bleibt das Risiko bestehen, dass die Ausführungszeit durch Compileroptimierungen oder die Sprungvorhersage der CPU schwankt. Aus diesem Grund werden in tatsächlichen Constant-Time-Implementierungen bedingte Verzweigungen (if-Anweisungen) vermieden und stattdessen bedingtes Vertauschen (Conditional Swap) mit bitweisen Operationen verwendet.

8. Implementierung der Elliptischen-Kurven-Kryptographie in C++

Von nun an werden wir die Theorie in C++-Code umsetzen. Praktische Krypto-Bibliotheken (wie OpenSSL oder libsodium) verwenden hochentwickelte Assembler-Optimierungen und Jacobi-Koordinaten, aber um das mathematische Verständnis zu vertiefen, zeigen wir hier das Gerüst einer leicht verständlichen Constant-Time-Implementierung mit affinen Koordinaten.

Wir gehen davon aus, dass wir boost::multiprecision::cpp_int für die Berechnungen mit großen Zahlen verwenden.

8.1. Modulo-Arithmetik und Inversen

Zunächst definieren wir Hilfsfunktionen für Operationen auf endlichen Körpern. Wir implementieren die Inversen-Berechnung mit dem kleinen fermatschen Satz.

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


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

using namespace boost::multiprecision;

// Beispiel: Parameter und Primzahl p für secp256k1
const cpp_int p("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
const cpp_int a = 0;
const cpp_int b = 7;

// Modulo-Operation, die einen positiven Rest zurückgibt
cpp_int mod(cpp_int x, cpp_int m) {
 cpp_int r = x % m;
 return r < 0 ? r + m : r;
}

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

// Modulares Inverses mit dem kleinen fermatschen Satz
cpp_int modInverse(cpp_int n, cpp_int m) {
 // Annahme, dass m eine Primzahl ist: n^(m-2) ≡ n^(-1) mod m
 return powerMod(n, m - 2, m);
}

8.2. Darstellung von Punkten und Gruppenoperationen (Addition/Verdopplung)

Wir definieren eine Point-Struktur, die den Punkt im Unendlichen durch ein Flag verwaltet, und implementieren die Additionsformeln.

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


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

 // Erzeugung des Punktes im Unendlichen
 Point() : x(0), y(0), isInfinity(true) {}

 // Erzeugung eines normalen Punktes
 Point(cpp_int x, cpp_int y) : x(x), y(y), isInfinity(false) {}
};

// Punktaddition auf der elliptischen Kurve (R = P + Q)
Point pointAdd(const Point& P, const Point& Q) {
 if (P.isInfinity) return Q;
 if (Q.isInfinity) return P;

 if (P.x == Q.x && mod(P.y + Q.y, p) == 0) {
 return Point(); // P + (-P) = Punkt im Unendlichen
 }

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

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

 return Point(x3, y3);
}

8.3. Implementierung des Constant-Time Conditional Swap

Wenn der Inhalt von Variablen basierend auf dem Bitwert des privaten Schlüssels vertauscht wird, erfolgt das Vertauschen ausschließlich durch Bitoperationen (Maskierung) ohne die Verwendung von if-Anweisungen. Dadurch wird der Ausführungspfad völlig konstant.

[!TIP] In der Praxis sind Klassen für Ganzzahlen mit mehrfacher Genauigkeit, die dynamisch allokiert werden (wie cpp_int), nicht für Constant-Time-Verarbeitung geeignet. Das liegt daran, dass durch Speicherzuweisung und sich ändernde Array-Größen Timing-Informationen durchsickern. In praktischen Bibliotheken werden stattdessen feste Längen (z. B. ein Array mit 4 Elementen von uint64_t) verwendet, und Maskierungsoperationen auf Bitebene implementiert. Das Folgende ist ein konzeptionelles Beispiel.

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


// Konzeptioneller Constant-Time Swap (ausgehend von Ganzzahlen fester Länge)
// Wenn das Bit 1 ist, tausche P1 und P2; wenn es 0 ist, nicht.
void cswap(Point& P1, Point& P2, uint8_t bit) {
 // bit ist 0 oder 1. Die Maske ist alle Bits 1 (0xFF..), wenn bit=1, und alle Bits 0, wenn bit=0.
 // (Hier wird zur Erklärung angenommen, dass w jedes Wort der BigInt-Klasse fester Länge ist)
 /*
 uint64_t mask = 0 - (uint64_t)bit;
 for (int i = 0; i < NUM_WORDS; i++) {
 uint64_t dummy = mask & (P1.x.words[i] ^ P2.x.words[i]);
 P1.x.words[i] ^= dummy;
 P2.x.words[i] ^= dummy;
 // Die y-Koordinate und das isInfinity-Flag werden auf ähnliche Weise verarbeitet
 }
 */

 // ※ Ein vollständiger Constant-Time-Swap mit boost::multiprecision ist schwierig,
 // daher beschränken wir uns hier auf die Simulation durch Verzweigung zum Verständnis der Logik.
 if (bit == 1) {
 std::swap(P1, P2);
 }
}

8.4. Skalarmultiplikation durch Montgomery Ladder

Wir kombinieren das zuvor beschriebene pointAdd und cswap, um eine sichere Skalarmultiplikation zu implementieren.

 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


// Skalarmultiplikation k * P (Montgomery Ladder Methode)
Point scalarMultiply(const Point& P, cpp_int k) {
 Point R0 = Point(); // Punkt im Unendlichen
 Point R1 = P;

 // Hole die Bitlänge von k (256 Bit für secp256k1)
 int numBits = 256;

 for (int i = numBits - 1; i >= 0; i--) {
 // Hole den Wert des i-ten Bits (0 oder 1)
 uint8_t bit = static_cast<uint8_t>(bit_test(k, i) ? 1 : 0);

 // Wenn bit == 1, tausche R0 und R1
 cswap(R0, R1, bit);

 // Führe immer die gleichen Operationen aus (Point Addition und Point Doubling)
 R1 = pointAdd(R0, R1);
 R0 = pointAdd(R0, R0);

 // Wenn bit == 1 war, tausche erneut, um den Zustand wiederherzustellen
 cswap(R0, R1, bit);
 }

 return R0;
}

Durch diese Implementierungslogik wird – unabhängig davon, ob jedes Bit des Skalars $k$ eine 0 oder 1 ist – der in jeder Schleifeniteration ausgeführte Ablauf (cswap $\to$ pointAdd $\to$ pointAdd $\to$ cswap) völlig identisch. Dies verhindert effektiv das Durchsickern von Geheiminformationen durch Timing- oder Cache-Zugriffsmusterunterschiede.

9. Zusammenfassung

Die Elliptische-Kurven-Kryptographie (ECC) mag auf den ersten Blick seltsam erscheinen: “Warum wird aus einer geometrischen Operation wie dem Ziehen einer Gerade und dem Spiegeln eines Schnittpunkts eine Kryptographie?” Wenn man diese Operationen jedoch auf die diskrete Welt endlicher Körper abbildet, entsteht als Produkt der wundersamen Verschmelzung von Mathematik und Kryptographie eine hervorragende Einwegfunktion (das Diskrete Logarithmusproblem).

Dieser Artikel hat die folgenden wichtigen Punkte behandelt:

Vorteile gegenüber RSA: Es bietet starke Sicherheit mit sehr kurzen Schlüssellängen und ist ideal für das moderne Mobile- und IoT-Zeitalter.
Grundlagen der Gruppentheorie und endlicher Körper: Die inneren mathematischen Strukturen, die das Fundament von ECC bilden.
Formeln für Addition und Verdopplung: Wie algebraische Gruppenoperationen mit der Weierstraß-Gleichung implementiert werden.
Bedrohung durch Seitenkanalangriffe: Wie bedingte Verzweigungen, die von den Bits eines privaten Schlüssels abhängen, fatale Schwachstellen schaffen.
Constant-Time-Implementierung: C++-Codierungstechniken, die Montgomery Ladder und Conditional Swap verwenden, um das Verhalten auf Hardwareebene zu homogenisieren und Angriffe zu verhindern.

In einer Produktionsumgebung eine eigene Krypto-Bibliothek zu schreiben, birgt ein extrem hohes Sicherheitsrisiko und wird daher nicht empfohlen (“Don’t roll your own crypto”). Die tiefgreifende Kenntnis der intern ablaufenden Algorithmen und mathematischen Hintergründe wird jedoch zu einer unschätzbaren und mächtigen Waffe für Ingenieure, die sicherere und leistungsfähigere Systeme entwerfen und betreiben wollen.

Im nächsten Artikel werden wir noch tiefer auf den ECDSA (Elliptic Curve Digital Signature Algorithm), einen digitalen Signaturalgorithmus auf Basis elliptischer Kurven, sowie auf die in Bitcoin verwendeten Schnorr-Signaturen eingehen.

Gibt es einen Algorithmus, der das GNFS (Allgemeines Zahlkörpersieb) übertrifft?

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

1. Einführung: Primfaktorzerlegung und die Grundlage der modernen Kryptographie

Die Sicherheit der Internetkommunikation in der modernen Gesellschaft hängt stark von der Sicherheit der RSA-Kryptographie ab, einem Public-Key-Kryptosystem. Die Sicherheit des RSA-Verfahrens basiert auf der mathematischen Annahme, dass es schwierig ist, riesige zusammengesetzte Zahlen in ihre Primfaktoren zu zerlegen. Wenn ein extrem effizienter Algorithmus zur Primfaktorzerlegung entdeckt würde, würde die Kommunikationsinfrastruktur der ganzen Welt von Grund auf zusammenbrechen.

Derzeit ist das Allgemeine Zahlkörpersieb (GNFS: General Number Field Sieve) der schnellste und stärkste Algorithmus zur Primfaktorzerlegung riesiger ganzen Zahlen auf klassischen Computern. Das GNFS entstand als Erweiterung des Speziellen Zahlkörpersiebs (SNFS), das Ende der 1980er Jahre vorgeschlagen wurde. Bis heute hat es Rekorde bei der Faktorisierung riesiger zusammengesetzter Zahlen wie RSA-768 und RSA-250 aufgestellt.

Kryptographen und Mathematiker stellen sich jedoch stets folgende Fragen: “Gibt es einen klassischen Algorithmus, der das GNFS übertrifft?”, “Wo liegen die Grenzen klassischer Computer?” und “Wie werden Quantencomputer diese Situation überwinden?”.

In diesem Artikel analysieren wir gründlich die tiefgründige mathematische Struktur hinter dem GNFS und führen detaillierte technische Analysen der Polynomauswahl, des Siebprozesses und des linearen Algebraschritts mithilfe der Block-Wiedemann-Methode durch. Darüber hinaus betrachten wir GNFS-Erweiterungsmethoden, wie die Coppersmith-Modifikation, und vergleichen sowie erklären wir die entscheidenden Unterschiede zwischen klassischen Algorithmen in subexponentieller Zeit (Sub-exponential time) und Quantenalgorithmen in polynomieller Zeit aus einer mathematischen Perspektive.

2. Asymptotische Komplexität und L-Notation (L-notation)

Bei der Bewertung der Komplexität von Faktorisierungsalgorithmen wird anstelle der Standard-Polynomzeit-Notation (wie $O(n^k)$) die L-Notation (L-notation) verwendet, um die subexponentielle Zeit relativ zur Anzahl der Stellen der Eingabe $n$ auszudrücken. Die L-Notation ist wie folgt definiert:

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

Hierbei ist $n$ die zu faktorisierende ganze Zahl und $\ln n$ der natürliche Logarithmus, der proportional zur Bitlänge von $n$ ist.

Wenn $\alpha = 0$: $L_n[0, c] = \exp(c \ln \ln n) = (\ln n)^c$, was die Polynomzeit (Polynomial time) bezogen auf die Bitlänge darstellt.
Wenn $\alpha = 1$: $L_n[1, c] = \exp(c \ln n) = n^c$, was die Exponentialzeit (Exponential time) bezogen auf die Bitlänge darstellt.
Wenn $0 < \alpha < 1$: Es handelt sich um eine subexponentielle Zeit (Sub-exponential time), die zwischen der Polynomzeit und der Exponentialzeit liegt.

Die Geschichte der Entwicklung vergangener Faktorisierungsalgorithmen war auch eine Geschichte der allmählichen Verringerung dieses $\alpha$-Wertes.

Kettenbruchmethode (CFRAC) und Quadratisches Sieb mit mehreren Polynomen (MPQS): Sie gehören zur Klasse $\alpha = 1/2$ und haben eine Komplexität von etwa $L_n[1/2, 1]$.
Allgemeines Zahlkörpersieb (GNFS): Es erreicht $\alpha = 1/3$ und rühmt sich der Komplexität von $L_n[1/3, (64/9)^{1/3}]$, womit es der schnellste bekannte klassische Algorithmus ist.

3. Der gesamte GNFS-Algorithmus und seine mathematische Struktur

Das GNFS besitzt eine äußerst komplexe und fortschrittliche mathematische Grundlage. Die grundlegende Idee ist eine Erweiterung des kleinen Fermatschen Satzes und des Quadratischen Siebs (QS): Durch das Finden eines nicht-trivialen Paares $(X, Y)$, das die Kongruenz $X^2 \equiv Y^2 \pmod n$ und $X \not\equiv \pm Y \pmod n$ erfüllt, leitet man den Faktor $\gcd(X-Y, n)$ von $n$ ab.

Der Kern des GNFS liegt jedoch darin, dies nicht nur im Körper der rationalen Zahlen $\mathbb{Q}$ zu tun, sondern gleichzeitig “glatte Zahlen (Smooth numbers)” in einem Erweiterungskörper $\mathbb{Q}(\alpha)$, der als algebraischer Zahlkörper (Algebraic Number Field) bezeichnet wird, und im Körper der rationalen Zahlen zu suchen und durch einen Homomorphismus eine Kongruenzbeziehung herzustellen.

Der GNFS-Prozess ist grob in fünf Phasen unterteilt.

graph TD A["Faktorisierungsproblem (Eingabe n)"] --> B["1. Polynomauswahl (Polynomial Selection)"] B --> C["2. Siebphase (Sieving Phase)"] C --> D["3. Filterphase (Filtering Phase)"] D --> E["4. Lineare Algebra Phase (Linear Algebra Phase)"] E --> F["5. Quadratwurzel Phase (Square Root Phase)"] F --> G["Ausgabe der Primfaktoren p, q"]

3.1 Phase 1: Polynomauswahl (Polynomial Selection)

Der Erfolg des GNFS hängt stark von der Auswahl geeigneter Polynome ab. Das Ziel ist es, zwei irreduzible Polynome, $f_1(x)$ (rationale Seite) und $f_2(x)$ (algebraische Seite), zu finden, die eine gemeinsame Wurzel $m$ haben. Das heißt, sie erfüllen: $f_1(m) \equiv f_2(m) \equiv 0 \pmod n$

Normalerweise wird für die rationale Seite ein lineares Polynom $f_1(x) = x - m$ gewählt, und für das Polynom der algebraischen Seite $f_2(x)$ wird ein normiertes Polynom vom Grad $d$ (typischerweise 5 oder 6) gewählt. Der klassischste Ansatz ist die Base-$m$-Methode. Man wählt eine ganze Zahl $m = \lfloor n^{1/(d+1)} \rfloor$, die nahe an der $1/(d+1)$-ten Potenz von $n$ liegt, und entwickelt $n$ im $m$-adischen System. $n = c_d m^d + c_{d-1} m^{d-1} + \dots + c_1 m + c_0$ Dadurch erhält man das Polynom $f_2(x) = c_d x^d + c_{d-1} x^{d-1} + \dots + c_0$. Offensichtlich gilt $f_2(m) = n \equiv 0 \pmod n$.

In modernen Implementierungen wird jedoch der Kleinjung-Algorithmus verwendet. Dieser optimiert algebraische Eigenschaften (wie Murphys $E$-Wert und $\alpha$-Wert), während er verhindert, dass die Koeffizienten der Polynome extrem groß werden (Optimierung der Skewness), und sucht nach Polynomen, die bei der Siebverarbeitung leicht glatte Zahlen erzeugen. Allein in diesen Schritt werden enorme Rechenressourcen investiert.

3.2 Phase 2: Siebphase (Sieving Phase)

Sobald die Polynome bestimmt sind, tritt der Algorithmus in die “Sieb”-Phase (Sieving) ein, die den höchsten Rechenaufwand aufweist. Hier suchen wir nach Paaren $(a, b)$. Dieses Paar ist teilerfremd, und es wird gefordert, dass die folgenden zwei Werte gleichzeitig “glatt” (Smooth) sind:

Norm auf der rationalen Seite: $F_1(a, b) = b \cdot f_1(a/b) = a - bm$
Norm auf der algebraischen Seite: $F_2(a, b) = b^d \cdot f_2(a/b)$

“Glatt” bedeutet, dass die Zahl nur in Primfaktoren zerlegbar ist, die unter einer angegebenen Schranke (Sieve bound) liegen. Man bereitet eine Primzahlenbasis (Factor base) für die rationale Seite und eine Primzahlenbasis für die algebraische Seite vor und findet glatte Zahlen effizient in einem riesigen Suchraum, ähnlich wie beim Sieb des Eratosthenes. Heutzutage ist eine Methode namens Gittersieb (Lattice Sieving) der Mainstream. Indem eine bestimmte Primzahl $q$ fixiert wird und nur $(a, b)$-Paare auf einem Teilgitter gesiebt werden, bei denen sowohl die rationale als auch die algebraische Seite ein Vielfaches von $q$ sind, wird eine extrem hohe Effizienz erreicht.

3.3 Phase 3: Filterphase (Filtering Phase)

Die Anzahl der glatten Relationen (Gleichungen), die bei der Siebverarbeitung gefunden werden, geht in die Hunderte von Millionen oder Milliarden. Diese enthalten jedoch auch viele nutzlose Informationen. Das Ziel der Filterung ist es, eine riesige dünnbesetzte Matrix (Sparse Matrix) zu konstruieren und gleichzeitig deren Dimension so gering wie möglich zu halten.

Konkret werden die folgenden Operationen durchgeführt:

Singleton removal: Entfernen von Relationen, die einen Primfaktor enthalten, der nur einmal vorkommt.
Clique removal / Merging: Multiplizieren von Relationen, die Primfaktoren haben, die zweimal oder öfter vorkommen, um Variablen zu eliminieren und sie auf ein Gleichungssystem mit höherer Dichte, aber kleinerer Dimension zu reduzieren.

Dadurch wird eine Matrix mit Milliarden von Zeilen zu einer riesigen dünnbesetzten Matrix $\mathbf{A}$ (mit Elementen 0 und 1 über dem Körper $\mathbb{F}_2$) auf dem Niveau von zig Millionen Zeilen komprimiert.

3.4 Phase 4: Lineare Algebra Phase (Linear Algebra Phase)

Hier finden wir einen nicht-trivialen Lösungsvektor $\mathbf{x}$ der Gleichung $\mathbf{A} \mathbf{x} \equiv \mathbf{0} \pmod 2$. Das bedeutet, es handelt sich um das Problem, den linken Nullraum (Left Nullspace) einer riesigen dünnbesetzten Matrix zu finden.

Da die Größe der Matrix extrem groß ist, ist sie mit der normalen Gaußschen Elimination ($O(N^3)$) unmöglich zu berechnen. Daher wird eine iterative Methode verwendet, die eine Art von Krylov-Unterraum-Verfahren ist. Historisch gesehen wurde die Block-Lanczos-Methode (Block Lanczos) verwendet, aber in der heutigen verteilten Computerumgebung ist der Block-Wiedemann-Algorithmus (Block Wiedemann Algorithm), der den Kommunikations-Overhead drastisch reduzieren kann, der Mainstream.

Die Block-Wiedemann-Methode berechnet das Minimalpolynom aus der Matrix $\mathbf{A}$ und Vektorfolgen und konstruiert die Basis des Nullraums mithilfe des Berlekamp-Massey-Algorithmus. Dieser Schritt ist sehr schwer zu parallelisieren und erfordert stark gekoppelte Kommunikationsnetzwerke von Supercomputern oder großen Clustern, was ihn zu einem der größten Engpässe des GNFS macht.

3.5 Phase 5: Quadratwurzel Phase (Square Root Phase)

Aus der Lösung der linearen Algebra werden Produkte konstruiert, die auf der rationalen bzw. der algebraischen Seite zu “vollständigen Quadraten” werden. Auf der rationalen Seite wird $\prod (a-bm)$ zum Quadrat $X^2$ einer ganzen Zahl $X$, und auf der algebraischen Seite wird das Produkt der entsprechenden Ideale zu einem vollständigen Quadrat $\gamma^2$ über dem algebraischen Zahlkörper. Indem man dieses $\gamma$ über dem algebraischen Zahlkörper berechnet und den Homomorphismus zum Ring der rationalen ganzen Zahlen $\phi: \alpha \mapsto m \pmod n$ anwendet, erhält man die Kongruenz: $X^2 \equiv \phi(\gamma)^2 \equiv Y^2 \pmod n$

Für die Berechnung der Quadratwurzel über dem algebraischen Zahlkörper werden komplexe Algorithmen wie die Montgomery-Methode (Montgomery’s Method) verwendet, was tiefe Kenntnisse der algebraischen Zahlentheorie erfordert. Schließlich wird $\gcd(X-Y, n)$ berechnet, und wenn ein nicht-trivialer Faktor erhalten wird, ist die Primfaktorzerlegung abgeschlossen.

4. Gibt es einen klassischen Algorithmus, der das GNFS übertrifft?

Bisher wurde für die Primfaktorzerlegung allgemeiner ganzer Zahlen kein klassischer Algorithmus entdeckt, dessen asymptotische Komplexität unter $L_n[1/3, c]$ fällt. Es gibt jedoch einige Versuche und abgeleitete Algorithmen, um theoretische und praktische Grenzen zu durchbrechen.

4.1 Vielfaches Zahlkörpersieb (MNFS: Multiple Number Field Sieve)

Als Ansatz zur Erweiterung des GNFS gibt es das Vielfache Zahlkörpersieb (MNFS) von D. Coppersmith. Während das GNFS zwei Polynome (rationale und algebraische Seite) verwendet, verwendet das MNFS gleichzeitig mehrere verschiedene algebraische Polynome für ein einzelnes Polynom auf der rationalen Seite.

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

Durch die Verwendung mehrerer algebraischer Körper kann die Wahrscheinlichkeit, dass die Zahl in jedem Siebschritt “in einem der algebraischen Körper glatt wird”, drastisch erhöht werden. Mit diesem Ansatz ist es Coppersmith gelungen, die Konstante $c$ in der Komplexität $L_n[1/3, c]$ leicht zu reduzieren. Konkret wurde theoretisch gezeigt, dass, während die Konstante des GNFS $c = (64/9)^{1/3} \approx 1,923$ ist, die Optimierung des MNFS den Rechenaufwand auf etwa $c \approx 1,902$ reduzieren kann. In der Praxis ist jedoch der Overhead durch die Verwaltung mehrerer Körper groß, und es hat nicht zu einem entscheidenden Durchbruch bei RSA-Modulen in praktischer Größe geführt.

4.2 Sind Algorithmen der Klasse $L_n[1/4]$ möglich?

Ein Thema, das unter Mathematikern seit vielen Jahren hinsichtlich der Grenzen klassischer Algorithmen zur Primfaktorzerlegung diskutiert wird, ist die Frage: “Gibt es einen Algorithmus mit dem Exponenten $\alpha = 1/4$?”. Das derzeitige GNFS und seine Ableitungen sind stark an den Rahmen der “Suche nach Glätte” durch Sieben gebunden, und es wird weithin angenommen, dass $\alpha = 1/3$ die Grenze innerhalb dieses Paradigmas ist. Auch aus der Analyse der Verteilungswahrscheinlichkeit glatter ganzer Zahlen unter Verwendung der Dickman-Funktion (Dickman function) geht man davon aus, dass die Wand von $O(L_n[1/3])$ mit der aktuellen Kombination aus algebraischer Körperkonstruktion und Sieben durch keine Optimierung überwunden werden kann.

Sollte es $L_n[1/4]$ oder gar einen klassischen Polynomzeitalgorithmus geben, müsste dieser auf einer völlig neuen mathematischen Struktur beruhen, die derzeit niemand vorhersehen kann und die sich vom “glattheitsbasierten” Ansatz wie dem GNFS völlig unterscheidet (zum Beispiel ein fortgeschrittenerer algebraisch-geometrischer Ansatz wie der Schoof-Algorithmus für elliptische Kurvenkryptographie). Derzeit gibt es jedoch keine derartigen Anzeichen.

5. Durchbruch durch Quantencomputer: Shors Algorithmus

Während klassische Computer an der $L_n[1/3]$-Wand stehen, zerschmetterte der 1994 von Peter Shor vorgestellte Shor-Algorithmus (Shor’s Algorithm) diese Wand, indem er das Berechnungsmodell grundlegend veränderte.

5.1 Der Schock der quantenmechanischen Polynomzeit

Shors Algorithmus reduziert das Faktorisierungsproblem auf ein “Ordnungsfindungsproblem (Order Finding Problem)”. Es geht darum, die Periode (Ordnung) $r$ der Funktion $f(x) = a^x \pmod n$ für eine bestimmte ganze Zahl $a$ zu finden. Während ein klassischer Computer exponentielle Zeit benötigt, um diese Periode zu finden, können durch die Verwendung der Quanten-Phasenschätzung (QPE: Quantum Phase Estimation) und der Quanten-Fourier-Transformation (QFT: Quantum Fourier Transform) auf einem Quantencomputer alle Zustände in Überlagerung (Superposition) parallel bewertet und die Periode $r$ mit hoher Wahrscheinlichkeit extrahiert werden.

In Bezug auf die Komplexität ist die Ausführungszeit von Shors Algorithmus eine quantenmechanische Polynomzeit, konkret:

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

Unter Berücksichtigung kürzlich optimierter Schaltungsimplementierungen kann dies auf $O((\log n)^2 \log \log n)$ reduziert werden.

graph LR A["Klassischer Algorithmus (GNFS)"] -->|Grenze| B["Subexponentielle Zeit L_n[1/3]"] C["Quantenalgorithmus (Shor)"] -->|Durchbruch| D["Polynomzeit O((log n)^3)"] B --> E["Fortgesetzte Nutzung von RSA (Längere Schlüssel)"] D --> F["Vollständiger Zusammenbruch von RSA"]

5.2 Klassische subexponentielle Zeit vs Quantenmechanische Polynomzeit

Der Unterschied zwischen diesen beiden Komplexitätsklassen hat entscheidende Auswirkungen auf die reale kryptographische Sicherheit.

Betrachten wir beispielsweise den Fall der Faktorisierung von RSA-2048 (eine zusammengesetzte Zahl mit 2048 Bit).

GNFS (Klassisch): Setzt man $n \approx 2^{2048}$ in $L_n[1/3, 1.923]$ ein, so benötigt man etwa $2^{112}$ Operationen. Dies ist eine astronomische Rechenmenge, die länger als die Lebensdauer des Universums dauern würde, selbst wenn man alle aktuellen Rechenressourcen der Erde bündeln würde.
Shor-Algorithmus (Quanten): Bei einem $O((\log n)^3)$-Algorithmus sind nur etwa $2048^3 \approx 8,5 \times 10^9$ logische Gatteroperationen erforderlich. Dies bedeutet, dass die Berechnung in nur wenigen Stunden bis Tagen abgeschlossen sein könnte, sofern die entsprechende Hardware (ein universeller Quantencomputer mit Millionen von physischen Qubits und Fehlerkorrekturfähigkeiten) vorhanden ist.

Der Paradigmenwechsel von einer subexponentiellen Funktion mit einem “Exponenten $\alpha=1/3$” zur “Polynomzeit” macht die traditionelle kryptographische Strategie, die Sicherheit durch Erhöhung der Schlüssellänge zu gewährleisten, völlig wirkungslos.

6. Zusammenfassung: Ausblick auf die nächste Generation

Der aktuelle Konsens der wissenschaftlichen Gemeinschaft zur Frage “Gibt es einen klassischen Algorithmus, der das GNFS übertrifft?” lautet wie folgt:

Praktische Verbesserungen werden fortgesetzt, aber es gibt keinen asymptotischen Sprung: Versuche, den konstanten Term $c$ des GNFS zu verbessern, wie MNFS, Optimierung der Polynomauswahl und Parallelisierung der Block-Wiedemann-Methode, werden fortgesetzt. Es gilt jedoch als äußerst unwahrscheinlich, dass ein klassischer Algorithmus entdeckt wird, der $\alpha = 1/3$ unterschreitet.
Die Sicherheit von RSA auf klassischen Computern bleibt stark: Der Rechenaufwand für das GNFS bleibt enorm, und RSA-2048 und RSA-4096 werden auf Jahrzehnte hinaus sicher gegen Angriffe klassischer Computer bleiben.
Die wahre Bedrohung ist der Quantenalgorithmus: Die Wand der Berechnungskomplexität wurde durch Shors Algorithmus überwunden, der auf den Prinzipien der Quantenmechanik beruht. Infolgedessen ist die Welt gezwungen, auf Post-Quanten-Kryptographie (PQC: Post-Quantum Cryptography) umzusteigen. Der Übergang zu neuen mathematischen Problemen wie gitterbasierter Kryptographie und Hash-basierter Kryptographie, die auch für Quantencomputer als schwer zu knacken (nicht in Polynomzeit lösbar) gelten, ist die aktuelle Spitze der Kryptographie.

Das Allgemeine Zahlkörpersieb (GNFS) ist einer der “höchsten Punkte”, den die Menschheit erreicht hat, indem sie die Grenzen der klassischen Mathematik und des Algorithmus-Designs herausgefordert hat. Das Verständnis der tiefgreifenden mathematischen Struktur des GNFS ist nicht nur das Erlernen der Geschichte der Kryptoanalyse, sondern auch eine intellektuelle Reise, um die Schönheit der Berechnungskomplexitätstheorie und der algebraischen Zahlentheorie zu erfahren. Bis zu dem Tag, an dem Quantencomputer in die Praxis umgesetzt werden, wird das GNFS seinen Thron als stärkster Algorithmus zur Primfaktorzerlegung behalten.

Schors Algorithmus mit Python simuliert

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

1. Einführung: Die kryptographische Krise durch Quantencomputer

Ein Großteil der Sicherheit in der modernen Internetgesellschaft hängt von Public-Key-Kryptographie (insbesondere RSA-Verschlüsselung) ab. Wenn wir beim Online-Shopping Kreditkarteninformationen senden oder hochsensible Daten austauschen, wird der Inhalt dieser Kommunikation stark durch RSA-Kryptographie geschützt.

Die Sicherheit der RSA-Verschlüsselung beruht auf der mathematischen Tatsache, dass “die Primfaktorzerlegung riesiger ganzer Zahlen für klassische Computer (die PCs und Supercomputer, die wir normalerweise verwenden) extrem schwierig ist”. Der 1994 von Peter Shor vorgestellte “Shor-Algorithmus (Shor’s Algorithm)” stellte diese Prämisse jedoch grundlegend in Frage. Es wurde mathematisch bewiesen, dass der Shor-Algorithmus, wenn er auf einem großen Quantencomputer ausgeführt wird, die Primfaktorzerlegung, für die klassische Computer länger als das Alter des Universums benötigen würden, in nur wenigen Minuten bis Stunden lösen kann.

In diesem Artikel werden wir ausführlich im Detail erklären, wie dieser Shor-Algorithmus eine schnelle Primfaktorzerlegung durchführt, von seinem mathematischen Mechanismus bis hin zu einer konkreten Simulationsimplementierung mit Python und dem Quanten-Computing-Framework Qiskit.

2. Dramatische Änderung der Komplexität: Von exponentieller zu polynomieller Zeit

Warum ist die Primfaktorzerlegung so schwierig? Selbst mit dem “Zahlkörpersieb (General Number Field Sieve, GNFS)”, das als bester Primfaktorzerlegungsalgorithmus für klassische Computer bekannt ist, ist die zeitliche Komplexität subexponentiell.

Die Zeitkomplexität zur Primfaktorzerlegung einer zusammengesetzten Zahl mit $N$ Ziffern bei Verwendung klassischer Methoden ist wie folgt:

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

Daher würde allein durch die Verlängerung der Schlüssellänge (z. B. auf 2048 Bit oder 4096 Bit) die Entschlüsselung auf einem klassischen Computer eine unrealistische Zeit wie Jahrtausende oder Zehntausende von Jahren in Anspruch nehmen.

Wenn jedoch der Shor-Algorithmus auf einem Quantencomputer verwendet wird, reduziert sich die zeitliche Komplexität dramatisch auf polynomielle Zeit in Bezug auf die Anzahl der Eingabebits $\log N$.

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

Dies bedeutet, dass sich bei einer Verdoppelung der Bitzahl die Rechenzeit für einen klassischen Computer astronomisch erhöht, während sie für einen Quantencomputer höchstens um das Achtfache steigt. Diese Reduzierung der Komplexitätsklasse von exponentieller auf polynomielle Zeit (Aufnahme in die BQP-Klasse) ist die wahre Genialität von Shors Algorithmus.

graph TD A["Erhöhung der Eingabegröße (Anzahl der Bits) N"] --> B{"Wahl des Algorithmus"} B -->|Klassisch: Zahlkörpersieb| C["Subexponentielle Erhöhung O(exp(...))"] B -->|Quanten: Shors Algorithmus| D["Polynomielle Zeit O((log N)^3)"] C --> E["Jahrtausende bis Milliarden von Jahren (unentschlüsselbar)"] D --> F["Wenige Minuten bis Stunden (Entschlüsselung in realistischer Zeit)"]

3. Gesamtbild des Algorithmus und mathematischer Hintergrund

Beim Shor-Algorithmus wird nicht alles auf einem Quantencomputer ausgeführt. Er basiert auf der Zusammenarbeit zwischen Vorverarbeitung/Nachbearbeitung durch klassische Computer und dem Kernteil (Periodenfindungsalgorithmus) durch Quantencomputer.

Der Gesamtablauf des Algorithmus ist wie folgt:

graph TD A["Eingabe: Zusammengesetzte Zahl N, die faktorisiert werden soll"] --> B["Wähle Zufallszahl a, sodass a < N"] B --> C{"gcd(a, N) > 1 ?"} C -- "Yes" --> D["Gibt den trivialen Faktor gcd(a, N) aus und beendet"] C -- "No" --> E["Finde Periode r von f(x) = a^x mod N mit Quantenalgorithmus"] E --> F{"Ist r gerade und a^(r/2) ≢ -1 mod N ?"} F -- "No" --> B F -- "Yes" --> G["Berechne Faktoren p = gcd(a^(r/2) - 1, N), q = gcd(a^(r/2) + 1, N)"] G --> H["Ausgabe: p, q"]

Reduktion der Primfaktorzerlegung auf das Periodenfindungsproblem

Shors geniale Idee bestand darin, das “Primfaktorzerlegungsproblem” in das “Periodenfindungsproblem (Order Finding Problem)” umzuwandeln.

Betrachten wir die ganze Zahl $N$ (die zu faktorisierende Zahl) und eine teilerfremde ganze Zahl $a$ ($1 < a < N$). Wir definieren die folgende modulare Exponentialfunktion:

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

Diese Funktion hat eine bestimmte Periode $r$. Das heißt, für jedes $x$ gilt $f(x+r) = f(x)$. Insbesondere wenn $x=0$, nennt man die kleinste positive ganze Zahl $r$, die

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

erfüllt, die “Ordnung von $a$ modulo $N$ (Order)”. Wenn wir diese Periode $r$ finden können, können wir die Primfaktoren wie folgt ableiten.

Wenn wir die Formel umstellen, erhalten wir:

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

Wenn $r$ gerade ist, kann dies mit der binomischen Formel (Differenz von Quadraten) faktorisiert werden.

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

Dies bedeutet, dass $N$ einen gemeinsamen Teiler mit entweder $(a^{r/2} - 1)$ oder $(a^{r/2} + 1)$ hat (unter der Bedingung, dass $a^{r/2} \not\equiv -1 \pmod N$). Durch Anwendung des euklidischen Algorithmus zur Berechnung von

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

können wir die nichttrivialen Primfaktoren $p, q$ von $N$ finden. Diese Berechnungen (Berechnung des größten gemeinsamen Teilers und Generierung von Zufallszahlen) können von klassischen Computern sehr schnell durchgeführt werden. Das Problem beschränkt sich also auf die Frage, wie man die Periode $r$ schnell finden kann. Auf klassischen Computern erfordert das Finden dieser Periode $r$ selbst exponentielle Zeit. Hier kommt der Quantencomputer ins Spiel.

4. Quantenalgorithmus-Teil: Wie die Periodenfindung funktioniert

Die Subroutine zum Finden der Periode $r$ mithilfe eines Quantencomputers besteht aus den folgenden 4 Schritten:

graph LR subgraph "Übergänge der Quantenzustände" S1["|0⟩|0⟩ (Initialisierung)"] --> S2["H-Gate: Superposition Σ|x⟩|0⟩"] S2 --> S3["Orakel U: Σ|x⟩|a^x mod N⟩"] S3 --> S4["QFT: Periodenextraktion durch Interferenz"] S4 --> S5["Messung: Erhalt des Näherungswertes y"] end

Schritt 1: Initialisierung und Superposition der Quantenregister

Zunächst bereiten wir zwei Quantenregister vor. Das erste Register dient zur Eingabe des Zustands und das zweite zur Speicherung der Ergebnisse der Funktionsberechnung. Der Anfangszustand ist überall $|0\rangle$.

$$ |\psi_0\rangle = |0\rangle_1 |0\rangle_2 $$

Wir wenden ein Hadamard-Gatter (Hadamard Gate) auf alle Qubits im ersten Register an, um einen Zustand gleicher Wahrscheinlichkeits-Superposition für alle möglichen Eingaben $x$ (von $0$ bis $Q-1$, mit $Q=2^n$) zu erzeugen.

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

Dadurch kann der Quantencomputer mit einer einzigen Operation Zustände für alle $Q$ Eingaben gleichzeitig speichern. Dies ist die mächtige Quelle der Quantenparallelität.

Schritt 2: Anwendung der Orakelfunktion (Modulare Exponentiation)

Als Nächstes verwenden wir die Quantenschaltung $U_f$, um die Funktion $f(x) = a^x \bmod N$ zu berechnen und das Ergebnis im zweiten Register zu speichern.

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

Zu diesem Zeitpunkt befinden sich das erste und zweite Register in einem Zustand der Quantenverschränkung (Entanglement). Wenn wir (hypothetisch) das zweite Register beobachten und einen bestimmten Wert $k = a^{x_0} \bmod N$ erhalten, kollabiert der Zustand des ersten Registers in eine Superposition derjenigen $x$, die diesen Wert $k$ ergeben. Da die Funktion die Periode $r$ hat, sind die verbleibenden Zustände im Abstand $r$, wie $x_0, x_0+r, x_0+2r, \dots$.

$$ |\psi_3\rangle = \sqrt{\frac{r}{Q}} \sum_{j=0}^{M-1} |x_0 + j r\rangle_1 |k\rangle_2 $$

Wir wollen jedoch nicht $x_0$ wissen, sondern die Periode $r$ selbst. Es ist unmöglich, $r$ direkt aus diesem Zustand zu beobachten. Daher verwenden wir die Quanten-Fouriertransformation.

Schritt 3: Phaseninterferenz durch Quanten-Fouriertransformation (QFT)

Wir wenden die Quanten-Fouriertransformation (Quantum Fourier Transform, QFT) auf das erste Register an. Die QFT ist die Quantenversion der klassischen diskreten Fouriertransformation und transformiert die Amplituden von Zustandsvektoren. Die Wirkung der QFT auf den Basiszustand $|x\rangle$ ist wie folgt definiert:

$$ QFT |x\rangle = \frac{1}{\sqrt{Q}} \sum_{y=0}^{Q-1} \omega^{xy} |y\rangle $$

Wobei $\omega = e^{2\pi i / Q}$.

Wenn die QFT angewendet wird, interferieren die Amplituden der Zustände. Ohne auf mathematische Details einzugehen: Wenn QFT auf einen Zustand mit Periode $r$ angewendet wird, verursachen die Wellen nur dann eine konstruktive Interferenz (Constructive Interference), wenn $y$ extrem nahe an einem ganzzahligen Vielfachen von $Q/r$ liegt. Für andere Zustände heben sich die Wahrscheinlichkeitsamplituden aufgrund von destruktiver Interferenz (Destructive Interference) gegenseitig auf und nähern sich Null.

Schritt 4: Messung und Kettenbruchentwicklung

Schließlich messen wir das erste Register. Der durch die Messung erhaltene Wert $y$ erfüllt mit hoher Wahrscheinlichkeit folgende Bedingung:

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

($c$ ist eine unbekannte ganze Zahl mit $0 \le c < r$)

Durch Anwendung der Kettenbruchentwicklung (Continued Fraction Expansion), einem klassischen Algorithmus, auf die erhaltene rationale Zahl $y/Q$ berechnen wir den Näherungsbruch $c/r$ und extrahieren die Periode $r$ aus dem Nenner.

5. Simulationsimplementierung mit Python und Qiskit

Da Theorie allein schwer greifbar ist, simulieren wir Shors Algorithmus tatsächlich mit Python und Qiskit, dem Quanten-Computing-Framework von IBM.

Hier implementieren wir das klassischste und bekannteste Beispiel-Szenario: “Faktorisierung von $N=15$ unter Verwendung von $a=7$”.

Vorbereitung der Ausführungsumgebung

Bitte installieren Sie Qiskit im Voraus.

1

pip install qiskit qiskit-aer numpy

Übersicht über den Python-Implementierungscode

Der folgende Code ist ein Implementierungsbeispiel von Shors Algorithmus, der auf $N=15, a=7$ spezialisiert ist. Da der Aufbau einer universellen modularen Exponentiationsschaltung auf aktuellen Simulatoren zu rechenintensiv ist, sind die Gatteroperationen für den spezifischen Fall von $a=7$ hartcodiert.

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123


import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
import math

# 1. Funktion zum Aufbau der inversen Quanten-Fouriertransformation (QFT†)
def qft_dagger(n):
 """Generiert eine inverse Quanten-Fouriertransformationsschaltung für n Qubits"""
 qc = QuantumCircuit(n)
 # SWAP-Gatter zur Umkehrung der Reihenfolge
 for qubit in range(n//2):
 qc.swap(qubit, n-qubit-1)
 # Anwendung von kontrollierten Phasengattern und H-Gattern
 for j in range(n):
 for m in range(j):
 qc.cp(-np.pi/float(2**(j-m)), m, j)
 qc.h(j)
 qc.name = "QFT_dagger"
 return qc

# 2. Funktion zum Aufbau der kontrollierten modularen Exponentiation für 7^x mod 15
def c_amod15(a, power):
 """Generiert ein kontrolliertes U-Gatter für ein spezifisches a und eine Potenz (nur für N=15)"""
 U = QuantumCircuit(4)
 for _ in range(power):
 # Hartcodierte Logik für 7^x mod 15, wenn a=7
 if a in [2,13]:
 U.swap(2,3)
 U.swap(1,2)
 U.swap(0,1)
 if a in [7,8]:
 U.swap(0,1)
 U.swap(1,2)
 U.swap(2,3)
 if a in [4, 11]:
 U.swap(1,3)
 U.swap(0,2)
 if a in [7,11,13]:
 for q in range(4):
 U.x(q)
 U = U.to_gate()
 U.name = f"{a}^{power} mod 15"
 c_U = U.control()
 return c_U

# 3. Aufbau der Haupt-Quantenschaltung
def shor_circuit(a, n_count):
 # n_count: Anzahl der Bits im Kontrollregister
 # Das Zielregister hat 4 Bits, um 0 bis 15 darzustellen
 qc = QuantumCircuit(n_count + 4, n_count)

 # Initialisierung des 1. Registers (Kontrollregister) (Erzeugung der Superposition)
 for q in range(n_count):
 qc.h(q)

 # Initialisierung des 2. Registers (Zielregister) auf |1> (0001)
 qc.x(3 + n_count)

 # Anwendung der kontrollierten modularen Exponentiation (Orakel)
 for q in range(n_count):
 # Anwendung der 2^q-ten Potenz-Operation
 qc.append(c_amod15(a, 2**q),
 [q] + [i+n_count for i in range(4)])

 # Anwendung der inversen Quanten-Fouriertransformation auf das 1. Register
 qc.append(qft_dagger(n_count), range(n_count))

 # Messung des 1. Registers
 qc.measure(range(n_count), range(n_count))
 return qc

# --- Ausführungsbereich ---
if __name__ == "__main__":
 N = 15
 a = 7
 n_count = 8 # Verwendung von 8 Qubits für das Kontrollregister (Q=256)

 print(f"Sucheinstellungen: N={N}, a={a}, Anzahl Kontroll-Qubits={n_count}")

 # Generierung der Schaltung
 qc = shor_circuit(a, n_count)

 # Ausführung im Simulator
 sim = AerSimulator()
 # In der neuesten Version von Qiskit wird transpile empfohlen
 from qiskit import transpile
 compiled_circuit = transpile(qc, sim)
 job = sim.run(compiled_circuit, shots=1024)
 result = job.result()
 counts = result.get_counts()

 print("\nMessergebnis (Bitfolge: Anzahl der Beobachtungen):")
 for bitstring, count in counts.items():
 print(f" {bitstring}: {count} Mal")

 # Klassische Nachbearbeitung: Identifizierung der Periode r durch Kettenbruchentwicklung
 print("\n--- Berechnung der Periode und Primfaktorzerlegung ---")
 phases = []
 for output in counts:
 # Umwandlung der Bitfolge in eine Dezimalzahl
 decimal = int(output, 2)
 # Phase = Messwert / 2^n_count
 phase = decimal / (2**n_count)
 phases.append(phase)

 # Erhalt des Näherungsbruchs durch Kettenbruchentwicklung. Die Obergrenze des Nenners ist N=15
 frac = Fraction(phase).limit_denominator(15)
 r = frac.denominator

 print(f"Beobachteter Wert: {decimal:3d} | Phase: {phase:.4f} | Kettenbruch: {frac} | Geschätzte Periode r = {r}")

 # Überprüfen, ob Periode r gerade ist und ein gültiges Ergebnis liefert
 if r % 2 == 0:
 guess1 = math.gcd(a**(r//2) - 1, N)
 guess2 = math.gcd(a**(r//2) + 1, N)
 if guess1 not in [1, N] or guess2 not in [1, N]:
 print(f" => Erfolgreich! Die Primfaktoren von {N} sind {guess1} und {guess2}.")
 else:
 print(f" => Nur triviale Faktoren. Noch einmal versuchen.")
 else:
 print(f" => Fehlgeschlagen, da die Periode ungerade ist.")

Code-Erklärung und Analyse der Ausführungsergebnisse

Wenn Sie den obigen Code ausführen, erhalten Sie mit hoher Wahrscheinlichkeit bestimmte Peaks (Beobachtungswerte) als Messergebnis des Kontrollregisters. Für n_count=8 ($Q=256$) treten bei einem idealen Quantencomputer (oder Simulator) Werte wie 0, 64, 128, 192 mit überwältigender Wahrscheinlichkeit auf.

Teilt man diese durch $Q=256$, erhält man die Phasen $y/Q$ als $0.0$, $0.25$, $0.5$, bzw. $0.75$. Wendet man auf diese Phasen die Kettenbruchentwicklung an:

$0.25 \to 1/4$ (Geschätzte Periode $r=4$)
$0.50 \to 1/2$ (Geschätzte Periode $r=2$)
$0.75 \to 3/4$ (Geschätzte Periode $r=4$)

Mit der hier erhaltenen Periode $r=4$ berechnen wir die Primfaktoren. Da $a=7, r=4$, gilt: $p = \gcd(7^2 - 1, 15) = \gcd(48, 15) = 3$ $q = \gcd(7^2 + 1, 15) = \gcd(50, 15) = 5$

Wir haben erfolgreich die Primfaktorzerlegung $15 = 3 \times 5$ durchgeführt.

[!TIP] Wenn der Messwert $y=128$ (Phase $0.5$) erhalten wird, ist der Nenner $2$, und wir erhalten einen Teiler anstelle der wahren Periode $r=4$. In solchen Fällen können wir die wahre Periode finden, indem wir den Algorithmus mehrmals ausführen oder Vielfache der erhaltenen $r$ untersuchen.

6. Herausforderungen für die praktische Anwendung und die Grenzen der NISQ-Ära

Obwohl es einfach war, $N=15$ auf einem Simulator zu faktorisieren, gibt es für reale Quantencomputer noch viele Hürden, um RSA-2048 (eine 617-stellige Dezimalzahl), wie es in der realen Welt verwendet wird, zu faktorisieren.

Die Ära, in der wir derzeit leben, wird als NISQ-Ära (Noisy Intermediate-Scale Quantum: verrauschtes, mittelgroßes Quanten-Computing) bezeichnet. Qubits sind extrem anfällig für Umgebungsrauschen und unterliegen während der Berechnungen der “Dekohärenz”, wodurch ihre Zustände zerstört werden.

Um tiefe Schaltungen (mit vielen Gattern) wie Shors Algorithmus fehlerfrei auszuführen, ist eine Quantenfehlerkorrektur (Quantum Error Correction) unerlässlich, um das Rauschen zu korrigieren. Um ein rauschfreies “logisches Qubit” zu erzeugen, müssen Tausende von “physischen Qubits” mit Verfahren wie dem Surface Code codiert werden.

Um eine 2048-Bit-RSA-Verschlüsselung zu knacken, werden Tausende von perfekten logischen Qubits benötigt. Schätzungen zufolge ist dafür ein fehlertoleranter Quantencomputer mit Millionen bis zig Millionen physischen Qubits erforderlich. Da selbst die modernsten heutigen Quantenprozessoren nur über einige Hundert bis Tausend physische Qubits verfügen, werden die Verschlüsselungen der Welt nicht unmittelbar morgen geknackt.

[!WARNING] Es gibt jedoch ein Bedrohungsmodell namens “Store Now, Decrypt Later (Jetzt speichern, später entschlüsseln)”. Angreifer könnten große Mengen der aktuell verschlüsselten vertraulichen Kommunikation in verschlüsselter Form speichern und die Strategie verfolgen, alles zu entschlüsseln, sobald in 10 bis 20 Jahren ein leistungsstarker Quantencomputer gebaut ist.

7. Übergang zur Post-Quanten-Kryptographie (PQC)

In Vorbereitung auf die Ankunft eines solchen “Q-Day (der Tag, an dem Quantencomputer Verschlüsselungen knacken)” standardisieren Kryptographen weltweit, allen voran das amerikanische National Institute of Standards and Technology (NIST), die Post-Quanten-Kryptographie (Post-Quantum Cryptography, PQC).

PQC basiert auf neuen mathematischen Problemen (Gitterprobleme, multivariate Polynome, hashbasiert usw.), von denen mathematisch angenommen wird, dass sie selbst mit Shors Algorithmus (oder Grovers Algorithmus) nicht effizient lösbar sind. Algorithmen wie “CRYSTALS-Kyber” und “CRYSTALS-Dilithium” wurden bereits als Standard ausgewählt und schrittweise in Apples iMessage und verschiedene Webbrowser-Kommunikationsprotokolle eingeführt.

Für Ingenieure, die IT-Infrastrukturen verwalten, wird der Einbau von “Crypto-Agility (Krypto-Agilität: das Design zum schnellen Wechseln von Verschlüsselungsmethoden)” von bestehenden RSA- oder elliptischen Kurven zu PQC eine wichtige zukünftige Aufgabe sein.

8. Fazit

In diesem Artikel haben wir eine umfassende Erklärung im Umfang von etwa 10.000 Zeichen geliefert, beginnend mit dem theoretischen mathematischen Hintergrund des Shor-Algorithmus, über den Mechanismus der Periodenextraktion mittels der Quanten-Fouriertransformation, bis hin zu spezifischem Simulationscode mit Python und Qiskit.

Die Tatsache, dass die physikalischen Gesetze der mikroskopischen Welt der Quantenmechanik die Grundlagen der Komplexitätstheorie und der Kryptographietheorie, die die Grundlagen der makroskopischen Informationswissenschaft bilden, komplett umstürzen können, ist einer der aufregendsten Paradigmenwechsel in der Geschichte der Wissenschaft. Es bleibt spannend, die anhaltende technologische Entwicklung der Quantencomputer und die Abwehrschlacht durch neue Verschlüsselungstechnologien weiter zu beobachten.

Wir ermutigen Sie, den hier vorgestellten Python-Code in Ihrer eigenen Umgebung auszuführen und die “Magie der Berechnung” zu erleben, die durch die Superposition und Interferenz von Quantenzuständen entsteht.

Referenzen

Shor, P. W. (1994). “Algorithms for quantum computation: discrete logarithms and factoring”. Proceedings 35th Annual Symposium on Foundations of Computer Science.
Nielsen, M. A., & Chuang, I. L. (2010). “Quantum Computation and Quantum Information”. Cambridge University Press.
Qiskit Documentation: https://qiskit.org/documentation/

【Grafik PQC】Vergleich der wichtigsten Algorithmen für die Post-Quanten-Kryptographie

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

1. Einleitung: Die “Krise der Kryptographie” durch Quantencomputer

In der modernen Internetgesellschaft ist die Public-Key-Kryptographie eine unverzichtbare Infrastruktur zum Schutz der Vertraulichkeit von Kommunikation und der Datenintegrität. Die derzeit weit verbreiteten RSA- und Elliptische-Kurven-Kryptographie (ECC) stützen sich für ihre Sicherheit auf mathematische Hürden, nämlich die “Schwierigkeit der Primfaktorzerlegung riesiger zusammengesetzter Zahlen” und die “Schwierigkeit des diskreten Logarithmusproblems auf elliptischen Kurven”. Es wurde bewiesen, dass klassische Computer (die Computer, die wir heute benutzen, einschließlich Supercomputern) länger als das Alter des Universums bräuchten, um diese mathematischen Probleme zu lösen, was die Grundlage für ihre Sicherheit darstellte.

Diese robuste Annahme wird jedoch durch Fortschritte in der Theorie und praktischen Anwendung von Quantencomputern grundlegend auf den Kopf gestellt. Der “Shor-Algorithmus”, der 1994 von dem Kryptographen Peter Shor vorgestellt wurde, bewies theoretisch, dass sowohl das Primfaktorzerlegungsproblem als auch das Problem des diskreten Logarithmus in “polynomieller Zeit” entschlüsselt werden können, wenn er auf einem ausreichend leistungsfähigen, fehlertoleranten universellen Quantencomputer (CRQC: Cryptographically Relevant Quantum Computer) ausgeführt wird. Das bedeutet, dass alle derzeit verwendeten Public-Key-Kryptographien unwirksam werden.

graph TD A["Großer Quantencomputer (CRQC)"] -->|Ausführung| B["Shor-Algorithmus"] B -->|Entschlüsselung in polynomieller Zeit| C["Primfaktorzerlegungsproblem (RSA)"] B -->|Entschlüsselung in polynomieller Zeit| D["Diskretes Logarithmusproblem (ECC / ECDSA)"] C --> E["Abhören verschlüsselter Kommunikation, Datenmanipulation, Spoofing"] D --> E F["Store Now, Decrypt Later (SNDL)"] --> E

Es ist sehr gefährlich zu denken: “Die vollständige Fertigstellung von Quantencomputern liegt noch Jahrzehnte in der Zukunft, also ist es kein Problem”. Denn eine Angriffsmethode namens Store Now, Decrypt Later (SNDL) stellt bereits eine reale Bedrohung dar. Bei diesem Angriff speichern böswillige Staaten oder Hackerorganisationen große Mengen der derzeit verschlüsselten Kommunikationsdaten (wie TLS-Traffic) und entschlüsseln sie alle in dem Moment, in dem in Zukunft ein leistungsstarker Quantencomputer verfügbar wird. Staatsgeheimnisse, Infrastrukturinformationen und medizinische Daten, die über lange Zeiträume geschützt werden müssen, sind dieser Bedrohung bereits ausgesetzt.

Für symmetrische Schlüsselkryptographie (wie AES) und Hash-Funktionen (wie SHA-256) existiert zudem der 1996 entdeckte Grover-Algorithmus. Dieser reduziert den Rechenaufwand für Brute-Force-Angriffe auf die Quadratwurzel. Mit anderen Worten, das Sicherheitsniveau von AES-128 wird effektiv auf 2 hoch 64 halbiert. Im Quantenzeitalter wird daher die Verwendung längerer Schlüssel und Hash-Längen wie AES-256 und SHA-384 empfohlen.

Um dieser beispiellosen Kryptographie-Krise zu begegnen, wurde die Post-Quanten-Kryptographie (Post-Quantum Cryptography: PQC) entwickelt, die auf neuen mathematischen Problemen basiert, welche auch mit Quantencomputern schwer zu lösen sind. Basierend auf den Ergebnissen des vom National Institute of Standards and Technology (NIST) der USA geleiteten PQC-Standardisierungsprozesses erläutert dieser Artikel detailliert die wichtigsten PQC-Algorithmen, von ihren mathematischen Hintergründen über ihre Mechanismen bis hin zu Architekturvergleichen.

2. Der PQC-Standardisierungsprozess von NIST: Gesamtbild und Geschichte

Der Übergang zu neuen Kryptographietechnologien, der die Neugestaltung von Protokollen, Systemaktualisierungen und den Austausch von Hardware umfasst, dauert Jahre bis Jahrzehnte. Daher haben Kryptographen auf der ganzen Welt frühzeitig die Erforschung von PQC vorangetrieben. Eine zentrale Rolle hat dabei das US-amerikanische NIST (National Institute of Standards and Technology) gespielt. Im Jahr 2016 rief NIST den PQC-Standardisierungsprozess aus und nahm Vorschläge für völlig neue kryptographische Algorithmen aus der weltweiten Kryptographie-Community entgegen.

Gegenstand der Standardisierung waren die folgenden zwei Hauptkategorien:

Public-Key-Kryptographie / Schlüsselkapselungsmechanismen (KEM: Key Encapsulation Mechanism): Ein Mechanismus zum sicheren Teilen (Verteilen) von symmetrischen Schlüsseln für die Verschlüsselung von Kommunikationskanälen, z. B. in TLS-Verbindungen.
Digitale Signaturen (Digital Signatures): Ein Mechanismus für Software-Updates und digitale Zertifikate, um zu beweisen, dass Daten nicht manipuliert wurden und kein Spoofing des Absenders vorliegt (Authentizität).

Nach etwa sechs Jahren intensiver Evaluation, Analyse und kryptanalytischem Wettbewerb (Runde 1 bis Runde 3) sowie einer zusätzlichen Evaluierung (Runde 4) für einige Algorithmen, wurden im Jahr 2024 die folgenden Algorithmen offiziell als Federal Information Processing Standards (FIPS) veröffentlicht und somit als künftige weltweite Standards festgelegt:

FIPS 203 (ML-KEM): KEM basierend auf CRYSTALS-Kyber
FIPS 204 (ML-DSA): Digitale Signatur basierend auf CRYSTALS-Dilithium
FIPS 205 (SLH-DSA): Zustandlose Hash-basierte Signatur basierend auf SPHINCS+
(In zukünftiger Planung) FN-DSA: Digitale Signatur basierend auf FALCON

Die ausgewählten Algorithmen stützen sich auf jeweils unterschiedliche mathematische “Schwierigkeitsprobleme”, sodass eine Vielfalt (Crypto Agility) gewährleistet ist. Sollte in Zukunft eine fatale Schwachstelle in einem Algorithmus entdeckt werden, wird so verhindert, dass das gesamte System zusammenbricht. Im Standardisierungsprozess nahm die gitterbasierte Kryptographie (Lattice-based cryptography) aufgrund ihrer Leistung die Hauptrolle ein, jedoch wurden hashbasierte und codebasierte Kryptographien als starke Backups übernommen.

3. Klassifizierung der wichtigsten mathematischen Ansätze in PQC

PQC-Algorithmen lassen sich nach den mathematischen Problemen, die ihre Sicherheit begründen, in die folgenden fünf Hauptkategorien einteilen. In diesem Artikel gehen wir speziell auf die ersten drei näher ein.

Gitterbasierte Kryptographie (Lattice-based Cryptography): Basiert auf dem Problem des kürzesten Vektors (Shortest Vector Problem, SVP), dem Problem des nächsten Vektors (Closest Vector Problem, CVP) in mehrdimensionalen Gitterräumen sowie dem davon abgeleiteten LWE-Problem. Dies ist das Herzstück der NIST-Standardisierung; Kyber, Dilithium und FALCON gehören dazu. Es bietet die beste Balance aus Verarbeitungsgeschwindigkeit, Public-Key-Größe und Chiffretextgröße und eignet sich daher für allgemeine Anwendungen.
Hash-basierte Kryptographie (Hash-based Cryptography): Stützt sich für ihre Sicherheit ausschließlich auf die “Kollisionsresistenz” und die “Einweg-Eigenschaft” von kryptographischen Hash-Funktionen (wie SHA-2 und SHAKE). Sie ist nur auf digitale Signaturen (wie SPHINCS+) anwendbar, bietet jedoch die stärksten Sicherheitsbeweise und zeichnet sich durch extrem hohe Resistenz gegen unbekannte mathematische Angriffe aus.
Code-basierte Kryptographie (Code-based Cryptography): Basiert auf der Theorie der Fehlerkorrekturcodes und stützt sich auf die Schwierigkeit des Syndrom-Decodierungsproblems (Syndrome Decoding Problem). Ein typisches Beispiel ist das in den 1970er Jahren vorgeschlagene Classic McEliece, das eine lange Geschichte und bewährte Sicherheit aufweist, aber den Nachteil extrem großer Public-Key-Größen im Megabyte-Bereich hat.
Multivariate polynomische Kryptographie (Multivariate Polynomial Cryptography): Basiert auf der Schwierigkeit, Lösungen für Systeme von multivariaten quadratischen Gleichungen über endlichen Körpern zu finden (MQ-Problem). Sie wurde hauptsächlich für digitale Signaturen (wie Rainbow) vorgeschlagen, jedoch wurde während der finalen NIST-Runde eine leistungsstarke Angriffsmethode entdeckt, die es ermöglichte, sie auf einem einzigen PC in wenigen Tagen zu knacken, weshalb viele dieser Algorithmen aus der Standardisierung herausfielen.
Isogenie-basierte Kryptographie (Isogeny-based Cryptography): Basiert auf dem Problem der Wegfindung auf Isogenie-Graphen elliptischer Kurven. Sie hatte sehr kleine Schlüsselgrößen und galt als legitimer Nachfolger von ECC. Der finale Kandidat “SIKE” wurde jedoch 2022 mithilfe klassischer Mathematik (z.B. Castryck-Decru-Angriff) auf einem normalen PC in nur wenigen Stunden vollständig geknackt, was ein dramatisches Ende darstellte und die Schwierigkeit und Gefahr des PQC-Designs symbolisiert.

4. Die Tiefen der Gitterkryptographie: LWE-Problem und die mathematischen Grundlagen von Module-LWE

Die Gitterkryptographie, die derzeit als vielversprechendster Ansatz gilt und im Zentrum der Standardisierung steht. Die Grundlage ihrer Sicherheit ist das LWE-Problem (Learning with Errors: Lernen mit Fehlern). Es wurde 2005 von Oded Regev vorgestellt, eine bahnbrechende Leistung, für die er den Gödel-Preis erhielt. Ohne das Verständnis des LWE-Problems kann man die moderne PQC nicht diskutieren.

4.1. Was ist das LWE-Problem (Learning with Errors)?

Betrachten wir zunächst ein einfaches lineares Gleichungssystem. Angenommen, es gibt unter einem Modul $q$ eine bekannte zufällige Matrix $A$ und einen unbekannten geheimen Vektor $\vec{s}$, und ihr Produkt $\vec{b}$ sei gegeben.

$$ \vec{b} = A\vec{s} \pmod q $$

In diesem Fall ist es einfach, das unbekannte $\vec{s}$ aus den öffentlichen Informationen $A$ und $\vec{b}$ zu ermitteln. Mit dem klassischen “Gaußschen Eliminationsverfahren” kann $\vec{s}$ leicht in polynomieller Zeit berechnet werden.

Wenn wir dieser Gleichung jedoch einen “kleinen absichtlichen Fehler (Rauschen)” hinzufügen, steigt der Schwierigkeitsgrad des Problems dramatisch an. Das ist das LWE-Problem.

Wir bereiten einen unbekannten geheimen Vektor $\vec{s} \in \mathbb{Z}_q^n$ und eine zufällig gewählte Matrix $A \in \mathbb{Z}_q^{m \times n}$ vor. Darüber hinaus bereiten wir einen Fehlervektor $\vec{e} \in \mathbb{Z}_q^m$ vor, dessen Werte nach einer Normal- oder Binomialverteilung ausgewählt wurden und “ausreichend klein” sind, und berechnen $\vec{b}$ wie folgt:

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

Das Search-LWE-Problem besteht darin, “die geheimen Informationen $\vec{s}$ aus den öffentlichen Informationen $(A, \vec{b})$ zu ermitteln”. Durch die Anwesenheit dieses Fehlers $\vec{e}$ werden algebraische Lösungsmethoden wie die Gaußsche Elimination scheitern, da der Fehler $\vec{e}$ durch die Addition und Subtraktion von Gleichungen schneeballartig anwächst, bis er schließlich von zufälligen Werten nicht mehr zu unterscheiden ist.

Das Großartige am LWE-Problem ist, dass es einen starken theoretischen Beweis (Reduktion) gibt: Sofern kein Quantenalgorithmus existiert, der “Worst-Case-Probleme auf Gittern” wie GapSVP (Entscheidungsproblem des kürzesten Vektors) oder SIVP (Problem der kürzesten unabhängigen Vektoren) lösen kann, kann das LWE-Problem auch im Durchschnittsfall (Average-case) nicht gelöst werden. Das bedeutet, dass selbst zufällig generierte kryptographische Schlüssel eine robuste, durch theoretische Obergrenzen untermauerte Sicherheit garantieren.

4.2. Dramatische Effizienzsteigerung durch Ring-LWE und Module-LWE

Das gewöhnliche LWE-Problem (Standard-LWE) hat eine sehr klare Sicherheitsbasis, ist jedoch unpraktisch, da die Größe der Matrix $A$ extrem anwächst und Schlüsselgrößen im Megabyte-Bereich entstehen. Daher wurde ein Ansatz vorgeschlagen, Polynomringe (Polynomial Rings) zu nutzen, um eine algebraische Struktur einzuführen.

Beim Ring-LWE-Problem werden anstelle einfacher Vektoren oder Matrizen Elemente (Polynome) eines bestimmten Polynomrings $R_q$ verwendet. Die in den NIST-Standards am häufigsten verwendeten sind Kreisteilungs-Polynomringe wie:

$$ R_q = \mathbb{Z}_q[X]/(X^n + 1) $$

Hier ist $n$ eine Potenz von 2 (z. B. 256) und $q$ eine geeignete Primzahl. Auf diesem Ring werden Elemente $a, s, e \in R_q$ verwendet, um $b = a \cdot s + e \pmod q$ zu berechnen. Da ein einziges Polynom $a$ über $n$ Koeffizienten verfügt, können Daten erheblich komprimiert werden. Darüber hinaus ermöglicht die Verwendung der NTT (Number Theoretic Transform: Zahlentheoretische Transformation), einer Endliche-Körper-Version der schnellen Fourier-Transformation (FFT), extrem schnelle Polynommultiplikationen in $O(n \log n)$ Rechenschritten.

Bei Ring-LWE bestand jedoch die Sorge, dass “aufgrund der speziellen algebraischen Ringstruktur unbekannte Schwachstellen existieren könnten”. Ein weiteres technisches Problem war, dass bei der Änderung des Sicherheitsniveaus (z.B. äquivalent zu AES-128, 192, 256) der Polynomgrad $n$ selbst geändert werden musste, wodurch die gesamte Implementierung, wie etwa der NTT-Algorithmus, umgeschrieben werden musste.

Deshalb haben die standardisierten Algorithmen Kyber und Dilithium das Module-LWE (M-LWE) Problem übernommen. Module-LWE ist ein Kompromiss, der genau in der Mitte zwischen dem strukturlosen Standard-LWE und dem zu stark strukturierten Ring-LWE liegt, indem es $k \times k$ Matrizen (Module) verwendet, deren Komponenten Elemente des Polynomrings $R_q$ sind:

$$ \vec{b} = A\vec{s} + \vec{e} \pmod{R_q} \quad (A \in R_q^{k \times k}, \vec{s}, \vec{e} \in R_q^k) $$

Der größte Vorteil von Module-LWE ist, dass das Sicherheitsniveau leicht skaliert werden kann, indem lediglich die Matrixdimension $k$ geändert wird, während der Polynomgrad $n$ ($n=256$ in den NIST-Standards) konstant bleibt. Zum Beispiel wird bei Kyber die Dimension $k$ wie folgt angepasst:

Kyber512 (Level 1): $k = 2$ (entspricht AES-128)
Kyber768 (Level 3): $k = 3$ (entspricht AES-192)
Kyber1024 (Level 5): $k = 4$ (entspricht AES-256)

Dies machte es möglich, den zugrunde liegenden NTT-Code und Hardware-Schaltungen für Polynomoperationen über alle Sicherheitsstufen hinweg zu 100% wiederzuverwenden, was die Sicherheit und Effizienz der Implementierung drastisch verbesserte.

5. CRYSTALS-Kyber (ML-KEM): Der Schlüsselkapselungsmechanismus der nächsten Generation

CRYSTALS-Kyber, offiziell als FIPS 203 (ML-KEM) standardisiert, ist ein Schlüsselkapselungsmechanismus (KEM), der auf dem oben erwähnten Module-LWE-Problem basiert. Er wird de facto der künftige weltweite Standard für das sichere Teilen von Sitzungsschlüsseln in Protokollen wie TLS 1.3 und SSH sein.

5.1. Architektur des KEM (Key Encapsulation Mechanism)

In der PQC-Ära wird anstelle des direkten Ansatzes von RSA, bei dem “der Client einen symmetrischen Schlüssel erstellt, ihn mit dem öffentlichen Schlüssel des Servers verschlüsselt und sendet”, das Kapselungs-Framework KEM zum Standard.

sequenceDiagram participant Client as "Client (Alice)" participant Server as "Server (Bob)" Note over Client: "ML-KEM KeyGen()" Client->>Client: "Erzeugt privaten (sk) und öffentlichen Schlüssel (pk)" Client->>Server: "Sendet öffentlichen Schlüssel (pk)" Note over Server: "ML-KEM Encaps()" Server->>Server: "Erzeugt zufälligen symmetrischen Schlüssel (K)" Server->>Server: "Kapselt K mit pk, erstellt Chiffretext (c)" Server->>Client: "Sendet Chiffretext (c)" Note over Client: "ML-KEM Decaps()" Client->>Client: "Entschlüsselt Chiffretext (c) mit privatem Schlüssel (sk)" Client->>Client: "Entkapselt und extrahiert den symmetrischen Schlüssel (K)" Note over Client, Server: "Start der verschlüsselten Kommunikation (z. B. AES) mit dem geteilten Schlüssel (K)"

5.2. Der interne Algorithmus von Kyber und die Fujisaki-Okamoto-Transformation

Das Design von Kyber ist sehr raffiniert. Zunächst wird ein Public-Key-Kryptosystem (Kyber.CPAPKE) konstruiert, das nur gegen CPA (Chosen-Plaintext Attacks) sicher ist. Durch die Anwendung einer kryptographisch sehr mächtigen Methode namens Fujisaki-Okamoto-Transformation (Fujisaki-Okamoto Transform) wird dieses System zu einem vollständigen KEM aufgerüstet, das auch gegen CCA (Adaptive Chosen-Ciphertext Attacks) sicher ist.

Der zentrale Verschlüsselungs- und Entschlüsselungsmechanismus von CPAPKE funktioniert wie folgt:

Schlüsselerzeugung (Key Generation):
- Eine Matrix $A \in R_q^{k \times k}$ im NTT-Bereich wird aus einem zufälligen Seed generiert. Der Modul $q$ ist $3329$.
- Der geheime Vektor $\vec{s}$ und der Fehlervektor $\vec{e}$ mit kleinen Koeffizienten werden aus einer zentrierten Binomialverteilung (CBD) abgetastet.
- Es wird $\vec{t} = A\vec{s} + \vec{e}$ berechnet. Der öffentliche Schlüssel ist $(A, \vec{t})$, der private Schlüssel ist $\vec{s}$. (In der Praxis wird $A$ als Seed veröffentlicht, um Bandbreite zu sparen).
Verschlüsselung (Encryption):
- Die zu teilende 32-Byte-Nachricht (Schlüsselmaterial) $m$ wird in ein Polynom kodiert.
- Ein neuer zufälliger Vektor $\vec{r}$ und kleine Fehler $\vec{e_1}, e_2$ werden generiert.
- $\vec{u} = A^T\vec{r} + \vec{e_1}$
- $v = \vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m$
- Der Chiffretext ist $(\vec{u}, v)$.
Entschlüsselung (Decryption):
- Der Empfänger berechnet $v - \vec{s}^T\vec{u}$.
- Wenn wir diese Gleichung ausklappen, erhalten wir: $v - \vec{s}^T\vec{u} = (\vec{t}^T\vec{r} + e_2 + \lfloor q/2 \rceil \cdot m) - \vec{s}^T(A^T\vec{r} + \vec{e_1})$
- Setzen wir hier $\vec{t} = A\vec{s} + \vec{e}$ ein, heben sich die Hauptterme $\vec{s}^TA^T\vec{r}$ auf.
- Übrig bleibt $\lfloor q/2 \rceil \cdot m + (\vec{e}^T\vec{r} + e_2 - \vec{s}^T\vec{e_1})$.
- Da die Terme in den Klammern “Produkte und Summen kleiner Fehler” sind, bleibt das Ganze ein ausreichend kleiner Wert (Rauschen). Daher kann durch Schwellenwertbestimmung, ob jeder Koeffizient näher an $0$ oder $q/2$ liegt, das Bit der ursprünglichen Nachricht $m$ (0 oder 1) völlig fehlerfrei wiederhergestellt werden.

Die größte Stärke von Kyber liegt in seiner enormen Verarbeitungsgeschwindigkeit und der moderaten Schlüsselgröße. Bei Kyber768 beträgt die Public-Key-Größe 1.184 Bytes und die Chiffretextgröße 1.088 Bytes. Auch wenn dies im Vergleich zu RSA-3072 (Schlüsselgröße ca. 384 Bytes) größer ist, passt es ohne Paketfragmentierung in die MTU (Maximum Transmission Unit) moderner Internetkommunikation und hat kaum negative Auswirkungen auf die Netzwerklatenz.

6. CRYSTALS-Dilithium (ML-DSA): Gitterbasierte universelle digitale Signatur

Bei der Standardisierung digitaler Signaturen konkurrierten Algorithmen mit unterschiedlichen Designphilosophien innerhalb desselben gitterbasierten Ansatzes. Unter diesen wurde CRYSTALS-Dilithium als universelle digitale Signatur FIPS 204 (ML-DSA) ausgewählt.

6.1. Das “Fiat-Shamir with Aborts”-Paradigma

Dilithium ist, wie Kyber, ein digitales Signaturschema, das auf Module-LWE (und dem Module-SIS-Problem) basiert. Die Grundlage seines Designs ist das extrem wichtige Paradigma der “Fiat-Shamir-Transformation mit Abbrüchen (Fiat-Shamir with Aborts)”.

Die Fiat-Shamir-Transformation an sich ist eine Standardmethode zur Umwandlung interaktiver Zero-Knowledge-Beweisprotokolle in nicht-interaktive digitale Signaturen. Der Beweiser (Signierende) erzeugt ein Commitment $y$, berechnet $w = Ay$ und leitet es durch eine Hash-Funktion, um eine zufällige Challenge $c$ zu erhalten, und berechnet die Antwort $z = y + cs$.

Wenn dies jedoch einfach in der Gitterkryptographie angewendet wird, verzerrt sich die Verteilung der Antwort $z$ abhängig vom Wert des privaten Schlüssels $s$. Dies führte zu dem fatalen Problem, dass ein Angreifer, der viele Signaturen beobachtet, nach und nach Informationen über den privaten Schlüssel $s$ erlangen konnte (ein mathematisches Leck, das Seitenkanalangriffen ähnelt).

Das Dilithium-Designteam (Lyubashevsky et al.) führte eine Methode namens “Rejection Sampling (Verwerfungsmethode)” ein. Dabei wird der gesamte Signaturprozess abgebrochen (Abort), wenn die Koeffizienten des berechneten Ergebnisses $z$ nicht in einen voreingestellten sicheren Schwellenwertbereich fallen, und die Berechnung mit einer neuen Zufallszahl $y$ von vorn begonnen.

Dadurch folgt die letztendlich ausgegebene Signatur $z$ einer vollkommen gleichmäßigen Verteilung, die völlig unabhängig vom privaten Schlüssel ist, wodurch Informationslecks mathematisch vollständig verhindert werden konnten.

6.2. Vorteile von Dilithium und einfache Implementierung

Ein großer Designvorteil von Dilithium besteht darin, dass es im Signaturerzeugungsprozess überhaupt kein komplexes “Sampling aus Gauß-Verteilungen” oder “Fließkommaoperationen” verwendet. Da es nur mit Sampling aus einer Gleichverteilung, einfachen ganzzahligen Modulo-Operationen, NTT und Hash-Funktionen (SHAKE) implementiert werden kann, ist es in einer Vielzahl von Umgebungen – vom eingebetteten Mikrocontroller bis zum Cloud-Server – einfach sicher und in konstanter Zeit (Constant-time) zu implementieren. Dies macht es sehr widerstandsfähig gegen physische Seitenkanalangriffe wie Timing-Angriffe.

7. FALCON (FN-DSA): Die ultimativ kompakte Gittersignatur

Das NIST hat als eine weitere gitterbasierte Signatur mit anderen Eigenschaften als Dilithium FALCON (Fast-Fourier Lattice-based Compact Signatures over NTRU) als Standardisierungskandidaten ausgewählt (derzeit als FN-DSA im Entwurfsstadium).

7.1. NTRU-Gitter und Gauß-Sampling

Das Hauptmerkmal von FALCON ist, dass es nicht das LWE-Problem, sondern das seit 1996 existierende und historische NTRU-Gitter (N-th degree Truncated polynomial Ring Units) verwendet. Darüber hinaus nutzt es das “Hash-and-Sign”-Paradigma, das auf dem GPV-Framework (Gentry-Peikert-Vaikuntanathan) basiert.

Bei Hash-and-Sign wird der Hash-Wert der Nachricht als Zielpunkt im Raum betrachtet und der diesem Punkt am nächsten liegende Gitterpunkt (eine ungefähre Lösung des Problems des nächsten Vektors) als Signatur gefunden. Hierfür müssen Punkte nach einer diskreten Gauß-Verteilung abgetastet werden, wofür die “kurze Basis guter Qualität”, der private Schlüssel, verwendet wird.

FALCON beschleunigt diese rechenintensive Aufgabe drastisch durch eine Technik namens “Fast Fourier Orthogonalization (FFO)”.

7.2. Vor- und Nachteile von FALCON

Der überwältigende Vorteil von FALCON ist, dass seine Signaturgröße und Public-Key-Größe extrem klein (kompakt) sind. Während die Signaturgröße von Dilithium3 etwa 3.309 Bytes beträgt, liegt sie bei FALCON-512 bei nur ca. 666 Bytes. Auch der öffentliche Schlüssel ist mit 897 Bytes sehr klein, was es zum Retter in Umgebungen mit extrem eingeschränkter Bandbreite, für IoT-Geräte oder bestimmte Netzwerkprotokolle macht.

Allerdings gibt es einen gravierenden Nachteil. Da die Signaturerzeugung zwangsläufig komplexes diskretes Gauß-Sampling mit Fließkommaoperationen (64-Bit IEEE 754) erfordert, ist eine Constant-Time-Implementierung zur Vermeidung von Timing-Leaks äußerst schwierig, und der Code bläht sich auf. Aus diesem Grund positioniert sich FALCON im Gegensatz zur allgemeinen Nutzung (Dilithium) als leistungsstarker, spezialisierter Algorithmus für spezifische Anwendungen.

graph LR A["Anforderungen an digitale Signaturen"] --> B{"Was ist die oberste Priorität?"} B -->|"Einfachheit der Implementierung, Vielseitigkeit, leichte Constant-Time-Implementierung"| C["Dilithium (ML-DSA)"] B -->|"Minimierung der Bandbreite, kompakte Datengröße"| D["FALCON (FN-DSA)"] C --> E["Allgemeine TLS-Zertifikate, elektronische Signaturen für Software"] D --> F["Protokolle mit strengen Paketgrößenlimits, spezielle Umgebungen"]

8. SPHINCS+ (SLH-DSA): Hash-basierte Signatur mit der stärksten Sicherheit

Für den Worst-Case, dass die Sicherheit der Gitterkryptographie in Zukunft durch den Durchbruch eines genialen Mathematikers gebrochen wird, hat NIST FIPS 205 (SLH-DSA), sprich SPHINCS+, als Standard mit einem völlig anderen Ansatz als die Gitterkryptographie festgelegt.

SPHINCS+ wird als hash-basierte Signatur klassifiziert. Die Basis seiner Sicherheit stützt sich nur auf einen einzigen Punkt: “Die verwendete kryptographische Hash-Funktion (wie SHA-2 oder SHAKE256) muss kollisionsresistent und eine Einwegfunktion sein”. Da es nicht von mathematischen Problemen mit spezifischen algebraischen Strukturen wie LWE oder Primfaktorzerlegung abhängt, bietet es eine extrem robuste Sicherheit (die konservativste Sicherheit). Egal, wie mächtige Quantenalgorithmen in Zukunft erscheinen mögen, es kann abgewehrt werden, indem man einfach die Ausgabelänge der Hash-Funktion erhöht.

8.1. Zustandslose Architektur mit WOTS+ und FORS

Die Geschichte der hash-basierten Signaturen reicht weit in die 1970er Jahre zu Lamport-Signaturen und Winternitz-Einmal-Signaturen (WOTS) zurück. Dabei handelte es sich um Wegwerfschlüssel, mit denen “nur einmal sicher signiert” werden konnte. Um diese mehrfach verwendbar zu machen, wurden Algorithmen wie XMSS (eXtended Merkle Signature Scheme) oder LMS entwickelt, die einen Merkle-Baum kombinieren, um unzählige Einmalschlüssel mit einem einzigen Root-Hash zu verwalten.

XMSS und LMS wiesen jedoch den großen Nachteil auf, dass sie “zustandsbehaftet (stateful)” waren. Bei jeder Signatur musste der Index-Status (“der wievielte Einmalschlüssel wurde verwendet”) strikt im nichtflüchtigen Speicher mitgeschrieben werden. Wenn der Zustand z. B. durch das Wiederherstellen eines VM-Snapshots zurückgesetzt wird und derselbe Einmalschlüssel ein zweites Mal verwendet wird, ist der private Schlüssel sofort kompromittiert und das System bricht zusammen.

SPHINCS+ ist eine “zustandslose (stateless)” hash-basierte Signatur, die dieses lästige Zustandsmanagement gelöst hat. Seine Kerntechnologie besteht aus folgender Kombination:

WOTS+ (Winternitz One-Time Signature Plus): Eine grundlegende Einmal-Signatur.
FORS (Forest of Random Subsets): Eine Few-Time-Signature-Technologie. Sie gewährleistet die Sicherheit, auch wenn derselbe Schlüssel ein paar Mal wiederverwendet wird.
Hyper-Tree (Riesige Baumstruktur): Eine gigantische Struktur, bei der Merkle-Bäume mehrschichtig übereinandergelegt werden.

Bei der Signierung mit SPHINCS+ wird, anstatt Zustände zu verwalten, mittels Pseudozufallszahlen zufällig einer der unzähligen FORS-Schlüssel an der Basis des Hyper-Trees ausgewählt. Da die Anzahl der Blätter am Baum astronomisch hoch ist, wird die Wahrscheinlichkeit (Kollision), denselben Schlüssel zufällig zweimal zu wählen, verschwindend gering, was letztlich zur Zustandslosigkeit führt.

Die einzige und größte Schwäche von SPHINCS+ ist die extrem große Signaturgröße. Je nach Parametern erreicht die Signaturgröße 17 bis 49 Kilobytes, und die Signaturerzeugung ist im Vergleich zur Gitterkryptographie überwältigend langsam. Daher wird sie eher nicht für das alltägliche Webbrowsing eingesetzt, sondern für Anwendungen wie Software-Update-Signaturen oder Root-Zertifikate (CA), bei denen nicht häufig signiert wird, aber langfristige absolute Sicherheit zwingend erforderlich ist.

9. Code-basierte Kryptographie: Der gute alte Riese Classic McEliece

Ein wichtiger Ansatz, der als Finalist in Runde 4 des NIST-Standardisierungsprozesses weiterhin evaluiert wird, ist Classic McEliece, das auf code-basierter Kryptographie beruht.

Dieser Algorithmus wurde 1978 von Robert McEliece vorgeschlagen und ist neben RSA einer der ältesten in der Geschichte der Public-Key-Kryptographie. Er verwendet algebraisch-geometrische Codes, sogenannte “Goppa-Codes”. Dabei wird eine Nachricht durch absichtliches Hinzufügen von Fehlern (Rauschvektoren) verschlüsselt. Nur wer die Paritätsprüfmatrix des Goppa-Codes als privaten Schlüssel besitzt, kann die starke Fehlerkorrekturfähigkeit nutzen, um die Fehler zu entfernen und die ursprüngliche Nachricht zu entschlüsseln. Dies basiert auf dem “Syndrom-Decodierungsproblem (Syndrome Decoding Problem)”.

$$ \vec{c} = \vec{m} G + \vec{e} $$

(Wobei $G$ die verschlüsselte Generatormatrix als öffentlicher Schlüssel und $\vec{e}$ der Fehlervektor vom Gewicht $t$ ist)

Das Erstaunliche an Classic McEliece ist seine überwältigende Erfolgsbilanz: Obwohl es seit seinem Entwurf vor über 40 Jahren intensiver kryptanalytischer Forschung von Kryptographen auf der ganzen Welt ausgesetzt war, wurde nie eine grundlegende Schwachstelle entdeckt. Unter allen PQC-Ansätzen besitzt es die “durch die Zeit am besten bewiesene, robuste Sicherheit”.

Darüber hinaus hat es den Vorteil, dass die Chiffretextgröße sehr klein ist (nur etwa 100 bis 200 Bytes). Es hat jedoch den fatalen Nachteil, dass die Public-Key-Größe in den Megabyte-Bereich (MB) reicht. Selbst auf der niedrigsten Sicherheitsstufe (entsprechend AES-128) ist der öffentliche Schlüssel ca. 250 KB groß, auf höheren Stufen übersteigt er 1 MB.

Aus diesem Grund eignet es sich überhaupt nicht für Anwendungsfälle wie den TLS-Handshake, bei denen der öffentliche Schlüssel bei jeder Kommunikation über das Netzwerk gesendet wird. In speziellen Anwendungsfällen jedoch, bei denen der öffentliche Schlüssel im Voraus im System platziert werden kann, wie etwa beim Schlüsselaustausch für VPNs, bei in Firmware hartkodierten öffentlichen Schlüsseln oder bei Satellitenkommunikation, wird er aufgrund seiner starken Sicherheit weiterhin als äußerst vielversprechende Option betrachtet.

10. Leistungsvergleich und Kompromisse der einzelnen PQC-Algorithmen

Die Leistungsmerkmale der bisher diskutierten Hauptalgorithmen bei gängigen Sicherheitsniveaus (NIST Level 2 bis 3, entsprechend AES-128 bis 192) sind in der folgenden Tabelle zusammengefasst.

Algorithmus (Standardname)	Kategorie	Mathematische Grundlage	Public-Key-Größe	Private-Key-Größe	Chiffretext-/Signaturgröße	Verarbeitungsgeschwindigkeit	Hauptmerkmale und Anwendungen
Kyber768 (ML-KEM)	KEM	Module-LWE	1.184 Bytes	2.400 Bytes	1.088 Bytes	Sehr schnell	Beste Balance aus Schlüsselgröße und Geschwindigkeit. Universeller KEM-Standard für z. B. TLS 1.3.
Dilithium3 (ML-DSA)	Signatur	Module-LWE	1.952 Bytes	4.032 Bytes	3.309 Bytes	Erzeugung & Verifizierung schnell	Einfache Implementierung. Universeller Standard für digitale Signaturen.
FALCON-512 (FN-DSA)	Signatur	NTRU-Gitter	897 Bytes	1.281 Bytes	666 Bytes	Erzeugung eher langsam, Verifizierung ultraschnell	Minimale Signaturgröße. Erfordert jedoch Fließkommaoperationen. Für Embedded & IoT.
SPHINCS+ (SLH-DSA)	Signatur	Hash-Funktion	32 Bytes	64 Bytes	ca. 17.000 Bytes	Erzeugung sehr langsam	Mathematisches Ausfallrisiko fast null. Hochsicherheitsanwendungen wie Root-Zertifikate.
Classic McEliece	KEM	Goppa-Code	ca. 1,04 MB	13.568 Bytes	188 Bytes	Kapselung ist schnell	40 Jahre bewiesene Sicherheit. Riesiger öffentlicher Schlüssel. Für Umgebungen mit Hartkodierung.

Kompromisse verstehen

In der Welt der PQC gibt es keinen einzigen magischen Algorithmus mit den Eigenschaften “kleine Größe, hohe Geschwindigkeit und perfekte mathematische Garantie”.

Internet-Standards (Kyber / Dilithium): Bieten die beste Leistungsbalance und eignen sich am besten als Drop-In-Ersatz für heutiges RSA/ECC.
Ultimativer Konservativismus (SPHINCS+): Wird gewählt, wenn man auf Kosten von Datengröße und Verarbeitungsgeschwindigkeit eine absolute Versicherung gegen zukünftige mathematische Durchbrüche haben möchte.
Für spezielle Umgebungen (FALCON / Classic McEliece): Spezialwaffen, die je nach Umgebungsbeschränkungen ausgewählt werden, z. B. bei extrem geringer Bandbreite oder der Möglichkeit der Vorabverteilung.

11. Herausforderungen bei der praktischen Anwendung und die praktische Lösung der “hybriden Kryptographie”

Mit dem Abschluss der NIST-Standardisierung und der offiziellen Veröffentlichung der FIPS-Standards hat die PQC-Migration (PQC Migration) der IT-Infrastruktur weltweit ernsthaft begonnen. Googles Chrome-Browser, Apples iMessage (PQ3-Protokoll) und Netzwerkanbieter wie Cloudflare haben die PQC-Unterstützung bereits in ihre Protokolle implementiert und mit dem praktischen Einsatz begonnen.

Ein abrupter und vollständiger Wechsel zu neuen kryptographischen Algorithmen ist jedoch mit sehr hohen Risiken verbunden. Angenommen, ein brillanter Mathematiker entdeckt in einigen Jahren eine fatale Angriffsmethode auf Gitterkryptographien wie Kyber (einen mathematischen Fehler, der auch mit klassischen Computern gelöst werden könnte), dann würde das gesamte davon abhängige System in einem Augenblick schutzlos sein.

Der realistische und empfohlene Ansatz, um dieses Unsicherheitsrisiko zu mindern, ist die “hybride Kryptographie (Hybrid Cryptography)”.

In der hybriden Kryptographie werden sowohl bestehende klassische Kryptographien mit jahrelanger Erfolgsgeschichte (z.B. elliptische Kurven wie X25519) als auch neue PQC (z.B. Kyber768) gleichzeitig für den Schlüsselaustausch verwendet. Jeder Algorithmus generiert unabhängig voneinander symmetrische Schlüsselkomponenten. Schließlich werden beide Komponenten mithilfe einer sicheren Schlüsselableitungsfunktion (Key Derivation Function, KDF) gemischt, um das endgültige Master-Secret zu generieren.

graph TD A["Client"] -->|① Sendet öffentlichen Schlüssel von X25519 + öffentlichen Schlüssel von Kyber| B["Server"] B -->|② Antwortet mit geteiltem Schlüssel von X25519 + gekapseltem Chiffretext von Kyber| A A --> C{"Ableitung des Master-Secrets (KDF)"} B --> C C -->|Eingabe: (X25519 gemeinsamer Schlüssel) || (Kyber gemeinsamer Schlüssel)| D["Sicherer Kommunikationsschlüssel (AES-256 / ChaCha20)"] D -->|"Widerstandsfähig gegen Quantenbedrohungen UND klassische Schwachstellen"| E["Sichere hybride verschlüsselte Kommunikation (TLS 1.3)"]

Dadurch entsteht eine robuste zweischichtige Sicherheit: “Selbst wenn Quantencomputer realisiert und ECC geknackt werden, schützt Kyber die Kommunikation”, und umgekehrt “Sollte ein unbekannter mathematischer Fehler in Kyber gefunden werden, schützt ECC die Kommunikation”. Ein prominentes Beispiel ist der IETF-Standardisierungsentwurf X25519MLKEM768 (früher X25519Kyber768). Die heutige Kommunikation zwischen Webbrowsern und modernsten Servern nutzt genau diese hybride Methode.

Darüber hinaus wird im Systemdesign das Konzept der Crypto Agility (Kryptographische Agilität) zu einer zwingenden Anforderung für die zukünftige Systementwicklung. Dies bedeutet, eine Architektur aufzubauen, “die nicht übermäßig von einem bestimmten kryptographischen Algorithmus abhängt und schnell auf einen anderen Algorithmus umstellen kann (z.B. von Kyber auf McEliece, von Dilithium auf SPHINCS+), sollte ein Algorithmus scheitern”.

12. Fazit: Ein neuer Horizont der Kryptographie

Die Menschheitstraum-Technologie des Quantencomputers ist ironischerweise zur größten Bedrohung geworden, um unsere lange als vertrauenswürdig erachteten mathematischen Verteidigungslinien wie “Primfaktorzerlegung” und das “diskrete Logarithmusproblem” zu durchbrechen. Dennoch haben Kryptographen auf der ganzen Welt nicht aufgegeben. Stattdessen haben sie komplexere und tiefgründigere mehrdimensionale mathematische Gebiete wie Gittertheorie, Hash-Funktions-Bäume und Fehlerkorrekturcodes erschlossen, um mit der Post-Quanten-Kryptographie (PQC) ein neues Bollwerk zu errichten.

Der Abschluss der NIST-Standardisierung mit FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) und FIPS 205 (SLH-DSA) ist nicht das Ziel. Es ist nur der erste Schritt einer epischen PQC-Migration, die noch Jahrzehnte dauern wird. Für Softwareentwickler und Systemarchitekten wird es die große technische Herausforderung der Zukunft sein, herauszufinden, wie man die “Zunahme der Schlüsselgrößen” und “Veränderungen bei den Berechnungskosten”, die diese neuen Algorithmen mit sich bringen, optimal an Netzwerkprotokolle und Systeme anpasst.

Der Kampf zwischen Quantencomputern und Kryptographie ist ein spannendes Feld, in dem die menschliche Erforschung der Mathematik und die technologische Evolution am intensivsten aufeinandertreffen. Ich hoffe, dieser Artikel hat Ihnen ein tieferes Verständnis der wunderschönen mathematischen Theorie hinter der PQC sowie der erstaunlichen Mechanismen der einzelnen Algorithmen, die die Zukunft der Cybersicherheit prägen werden, vermittelt.

References:

NIST Post-Quantum Cryptography Standardization Program
FIPS 203: Module-Lattice-Based Key-Encapsulation Mechanism Standard
FIPS 204: Module-Lattice-Based Digital Signature Standard
FIPS 205: Stateless Hash-Based Digital Signature Standard

Der Tag, an dem Quantencomputer praktisch werden: Der aktuelle Stand im Jahr 2026

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

1. Einführung: Wie weit sind Quantencomputer im Jahr 2026 gekommen?

Im Jahr 2026 hat das Quantencomputing einen entscheidenden Wandel vom einstigen „theoretischen Traum“ zur „ingenieurstechnischen Realität“ vollzogen. Da die Grenzen der bis vor wenigen Jahren noch vorherrschenden NISQ (Noisy Intermediate-Scale Quantum)-Geräte deutlich wurden, haben Forschungseinrichtungen und Tech-Giganten weltweit das Ruder in Richtung der Realisierung des „fehlertoleranten Quantencomputings (FTQC: Fault-Tolerant Quantum Computing)“ herumgerissen.

In diesem Artikel werden wir den aktuellen Stand von Quantencomputern eingehend beleuchten und dabei die neuesten Durchbrüche des Jahres 2026 miteinbeziehen. Insbesondere werden wir die Quantenfehlerkorrektur (Oberflächencode), den Unterschied zwischen physischen und logischen Qubits, Fortschritte beim topologischen Quantencomputing sowie die neuesten Entwicklungen bei supraleitenden und Ionenfallen-Ansätzen im Detail erläutern.

2. Grundlagen von Quantenzuständen und Fidelität (Fidelity)

Das Qubit, die grundlegende Einheit eines Quantencomputers, kann sich im Gegensatz zu einem klassischen Bit (0 oder 1) in einem Überlagerungszustand (Superposition) von 0 und 1 befinden. Der Zustand eines einzelnen Qubits wird als Vektor in einem Hilbertraum wie folgt dargestellt:

$$ |\psi\rangle = \alpha|0\rangle + \beta|1\rangle $$

Hierbei sind $\alpha$ und $\beta$ komplexe Wahrscheinlichkeitsamplituden, die die folgende Normalisierungsbedingung erfüllen:

$$ |\alpha|^2 + |\beta|^2 = 1 $$

Eine extrem wichtige Kennzahl zur Messung der Leistung von Quantenberechnungen ist die Fidelität (Fidelity). Die Fidelität $F$ zwischen einem idealen Quantenzustand $|\psi\rangle$ und einer durch Rauschen degradierten, zu einem gemischten Zustand gewordenen tatsächlichen Dichtematrix $\rho$ ist wie folgt definiert:

$$ F(\rho, |\psi\rangle) = \langle \psi | \rho | \psi \rangle $$

Heutzutage, im Jahr 2026, hat die Fidelität von 2-Qubit-Gattern (z. B. CNOT- oder CZ-Gattern) bei supraleitenden Systemen stabil die Hürde von 99,99 % (die sogenannten „vier Neunen“) überschritten. Dies liegt deutlich über dem Schwellenwert für die Fehlerkorrektur mit Oberflächencodes (ca. 99 %) und ist einer der größten Durchbrüche auf dem Weg zur praktischen Anwendung.

3. Die Grenzen der NISQ-Ära und der Paradigmenwechsel zu FTQC

Von den späten 2010er bis in die frühen 2020er Jahre hinein war die Ära von NISQ (Noisy Intermediate-Scale Quantum), also von Geräten mit zehn bis hunderten von Qubits ohne Fehlerkorrektur. NISQ hatte jedoch klare Grenzen.

Mit zunehmender Schaltkreistiefe (Depth) häufen sich Fehler exponentiell an, was es unmöglich macht, aussagekräftige Berechnungsergebnisse zu erzielen. Die Gesamterfolgswahrscheinlichkeit $P_{success}$ bei einer Schaltkreistiefe $D$ nimmt in Bezug auf die Fidelität eines einzelnen Gatters $f$ und die Anzahl der Gatter $N$ wie folgt ab:

$$ P_{success} \approx f^N $$

Wenn man 1000 Gatter mit $f = 0,99$ anwendet, ergibt sich $0,99^{1000} \approx 4,3 \times 10^{-5}$, und das Ergebnis geht fast vollständig in zufälligem Rauschen unter. Daher konzentrieren sich die Ressourcen im Jahr 2026 weniger auf die direkte Skalierung von NISQ-Algorithmen (wie VQE oder QAOA), sondern auf die Erzeugung von logischen Qubits (Logical Qubits).

4. Quantenfehlerkorrektur und logische Qubits: Die vorderste Front des Oberflächencodes

Die Quantenfehlerkorrektur (QEC: Quantum Error Correction) ist eine Technologie, bei der mehrere „physische Qubits“ kodiert werden, um ein einzelnes „logisches Qubit“ zu erzeugen und Fehler zu erkennen und zu korrigieren. Derzeit gilt der Oberflächencode (Surface Code) als am vielversprechendsten.

4.1 Struktur des Oberflächencodes (Surface Code)

Beim Oberflächencode werden die Qubits in einem zweidimensionalen Gitter angeordnet. Daten-Qubits (die die eigentlichen Informationen speichern) und Mess-Qubits (für die Syndrommessung) sind schachbrettartig angeordnet.

graph TD A["Daten-Qubit (D1)"] --- B["Mess-Qubit (M1)"] B --- C["Daten-Qubit (D2)"] C --- D["Mess-Qubit (M2)"] D --- E["Daten-Qubit (D3)"] B --- F["Daten-Qubit (D4)"] D --- G["Daten-Qubit (D5)"] style A fill:#e1f5fe,stroke:#039be5 style C fill:#e1f5fe,stroke:#039be5 style E fill:#e1f5fe,stroke:#039be5 style F fill:#e1f5fe,stroke:#039be5 style G fill:#e1f5fe,stroke:#039be5 style B fill:#fff3e0,stroke:#fb8c00 style D fill:#fff3e0,stroke:#fb8c00

Mithilfe der Stabilisator-Operatoren $S_x$ und $S_z$ werden Bitflips (X-Fehler) und Phasenflips (Z-Fehler) kontinuierlich überwacht.

$$ S_x = \prod_{i \in \text{star}} X_i, \quad S_z = \prod_{j \in \text{plaquette}} Z_j $$

Ein entscheidender Fortschritt im Jahr 2026 war das vollständige Durchbrechen des „Break-Even-Punkts (Break-even point)“. Das bedeutet, dass das durch die Fehlerkorrektur beseitigte Rauschen größer wurde als das zusätzliche Rauschen, das durch die für die Fehlerkorrektur erforderlichen Schaltkreise entsteht, sodass die Lebensdauer von logischen Qubits die von physischen Qubits um viele Größenordnungen übertrifft.

4.2 Der Zyklus der Quantenfehlerkorrektur

Die Fehlerkorrektur fungiert als kontinuierliche Feedbackschleife.

sequenceDiagram participant D as "Daten-Qubits" participant M as "Ancilla-/Mess-Qubits" participant C as "Klassischer Controller" loop "Syndrom-Extraktionszyklus (ca. 1 Mikrosekunde)" D->>M: "Verschränken (CNOT/CZ)" M->>C: "Zustand messen (Syndrom)" C->>C: "Syndrom decodieren (z. B. Minimum Weight Perfect Matching)" C-->>D: "Pauli-Korrektur anwenden (falls erforderlich)" end

Mittlerweile hat sich die Technologie etabliert, diesen klassischen Dekodierungsprozess (Syndromanalyse) mit FPGAs oder dedizierten ASICs im Nanosekundenbereich durchzuführen, wodurch die Fehlerkorrektur in Echtzeit das Stadium der praktischen Anwendung erreicht hat.

5. Die Evolution der Hardware-Architektur (Ausgabe 2026)

Die Quantenhardware im Jahr 2026 entwickelt sich hauptsächlich entlang dreier Achsen: „Supraleitender Ansatz“, „Ionenfallen-Ansatz“ und „Topologischer Ansatz“.

5.1 Integration von supraleitenden Qubits

Der supraleitende Ansatz ist ein Bereich, der von IBM und Google angeführt wird, wobei Transmon-Qubits (Transmon) mit Josephson-Kontakten vorherrschen. Im Jahr 2026 wurden Mega-Chips realisiert, die Tausende bis Zehntausende von physischen Qubits auf einem einzigen Chip integrieren.

Besonders hervorzuheben ist die Etablierung von quantenmechanischen Verbindungen zwischen Modulen (Quantum Interconnects). Die Quantenteleportation zwischen Chips mithilfe von Mikrowellenphotonen wurde auf kommerziellem Niveau implementiert, wodurch die Größenbeschränkungen eines einzelnen Mischkryostaten (Verdünnungskühlschranks) umgangen werden können.

5.2 Zweidimensionale Skalierung von Ionenfallen und optische Interconnects

Beim Ionenfallen-Ansatz (vorangetrieben unter anderem von Quantinuum und IonQ) werden die internen Energiezustände von im Vakuum schwebenden Ionen als Qubits genutzt. Im Vergleich zum supraleitenden Ansatz haben sie den Vorteil extrem langer T1/T2-Kohärenzzeiten und ermöglichen eine All-to-All-Konnektivität (All-to-All Connectivity).

Der Durchbruch des Jahres 2026 ist die zweidimensionale Ausrichtung der QCCD-Architektur (Quantum Charge Coupled Device) und die Hochgeschwindigkeits-Verschränkungserzeugung zwischen mehreren Fallen mithilfe von photonischen Interconnects. Dadurch wurden die Schwächen der Ionenfallen, nämlich „langsame Gatter-Geschwindigkeit“ und „mangelnde Skalierbarkeit“, dramatisch verbessert.

5.3 Topologisches Quantencomputing: Kontrolle von Anyonen

Das topologische Quantencomputing, das lange Zeit als rein theoretisch galt, hat im Jahr 2026 endlich die Phase der experimentellen Demonstration erreicht. Dieser Ansatz, der unter anderem von Microsoft vorangetrieben wird, nutzt nicht-abelsche Anyonen (Non-Abelian Anyons), die als „Majorana-Nullmoden (Majorana Zero Modes)“ bezeichnet werden.

Quantengatter werden durch eine Operation namens „Braiding (Flechten)“ ausgeführt, bei der die Positionen der Anyon-Teilchen vertauscht werden.

$$ |\psi_{final}\rangle = B_{ij} |\psi_{initial}\rangle $$

Hierbei ist $B_{ij}$ der Braiding-Operator. Da beim topologischen Ansatz die Speicherung von Informationen nicht vom lokalen Zustand der Teilchen abhängt, sondern von der Topologie der gesamten „Knoten“, ist er von Natur aus widerstandsfähig gegen Umgebungsrauschen (Fehlertoleranz auf Hardware-Ebene). Im Jahr 2026 wurde weltweit zum ersten Mal die Erzeugung topologischer logischer Qubits mit hoher Fidelität bestätigt, was große Aufmerksamkeit als starke Abkürzung zu FTQC erregte.

6. Roadmap und Ausblick auf die praktische Anwendung

Damit Quantencomputer ihre Quantenüberlegenheit (Quantum Advantage), mit der sie klassische Computer (Supercomputer) in Bereichen wie „chemische Berechnungen“, „Materialwissenschaften“ und „Finanzmodellierung“ übertreffen, wirklich entfalten können, sind Tausende von logischen Qubits erforderlich.

gantt title "Quantencomputing-Roadmap (Überarbeitet 2026)" dateFormat YYYY axisFormat %Y section "NISQ-Ära" "Verrauschte Qubits (<1000)" :done, 2018, 2024 section "Frühes FTQC" "Demonstration des Break-Even-Punkts" :done, 2024, 2026 "Hunderte von logischen Qubits" :active, 2026, 2028 section "Vollwertiges FTQC" "1000+ logische Qubits (Komm. Anwendung)" : 2028, 2030 "Universeller fehlertoleranter Quantencomputer" : 2030, 2035

6.1 Aktuelle Herausforderungen und die Zukunft

Die größte Herausforderung im Jahr 2026 ist die Kühlkapazität der riesigen Kryostate (Verdünnungskühlschränke) zur Aufrechterhaltung der extrem niedrigen Temperaturen sowie die Verkabelung (I/O-Flaschenhals), die die Steuergeräte bei Raumtemperatur mit den Quantenchips bei tiefen Temperaturen verbindet. Um dem zu begegnen, schreitet die Entwicklung von CMOS-Controller-Chips (Cryo-CMOS), die in kryogenen Umgebungen funktionieren, rasant voran.

Fazit

Das Jahr 2026 wird in die Geschichte der Quantencomputer als „das erste Jahr der Skalierung logischer Qubits“ eingehen. Dank der Demonstration von Fehlerkorrekturalgorithmen, der Modularisierung der Hardware und der rasanten Fortschritte beim topologischen Ansatz ist der „Tag der praktischen Anwendung“ keine ferne Zukunft mehr, sondern kann als konkreter Meilenstein für die nächsten Jahre angesehen werden. Für Entwickler von Quantenalgorithmen und Unternehmen ist jetzt genau der richtige Zeitpunkt, um ernsthaft in quantennative Problemlösungen zu investieren.

Dieser Artikel basiert auf den neuesten Forschungsarbeiten und Branchentrends im Bereich des Quantencomputings mit Stand 2026.