Math on kenji.blog

【Für Anfänger】 Die mathematische Struktur des Transformer-Modells entschlüsseln

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

Einführung: Warum die Mathematik des Transformers lernen?

Es ist keine Übertreibung zu sagen, dass die Architektur des „Transformers“ die Geschichte der modernen natürlichen Sprachverarbeitung (NLP) und der gesamten KI neu geschrieben hat. Dieses Modell, das erstmals 2017 in dem Paper „Attention Is All You Need“ von Google-Forschern vorgestellt wurde, fungiert als Herzstück der Large Language Models (LLM), die derzeit die Welt dominieren, wie etwa die GPT-Serie von OpenAI (die Basistechnologie von ChatGPT), BERT von Google und Claude von Anthropic.

Während man oft qualitative Erklärungen zur Funktionsweise des Transformers findet, wie etwa „den Kontext mithilfe des Attention-Mechanismus (Aufmerksamkeitsmechanismus) verstehen“, gibt es überraschenderweise nur wenige tiefgehende Erklärungen der dahinterliegenden mathematischen Struktur für Anfänger. Um wirklich zu verstehen, wie die KI „Wörter“ als „mathematische Formeln“ verarbeitet und erstaunlich natürliche Texte generiert, ist es unerlässlich, ihre mathematischen Mechanismen zu entschlüsseln.

In diesem Artikel werden wir die mathematischen Strukturen der Kernkomponenten des Transformers, wie den „Self-Attention-Mechanismus“, das „Query-Key-Value (Q/K/V)-Modell“, die „Normalisierung durch die Softmax-Funktion“ und das „Positional Encoding“, für Leser mit Grundkenntnissen in Mathematik und Programmierung (auf dem Niveau von Matrizen und Ableitungen aus der Oberstufe) gründlich und verständlich erläutern.

Sie könnten von der Aneinanderreihung mathematischer Formeln überwältigt sein, aber jede einzelne Berechnung hat eine klare „Bedeutung“. Wenn Sie diesen Artikel zu Ende gelesen haben, sollten Sie verstehen können, dass der Transformer nicht einfach eine magische Blackbox ist, sondern ein präzise entworfenes Kristall aus Mathematik und Statistik.

1. Die Grenzen herkömmlicher Methoden und die Innovation des Transformers

Bevor der Transformer aufkam, waren Recurrent Neural Networks (RNN) und ihre Derivate wie LSTM (Long Short-Term Memory) der Mainstream in der natürlichen Sprachverarbeitung. RNNs wurden entwickelt, um Zeitreihendaten zu verarbeiten, und lesen Texte Wort für Wort von Anfang an nacheinander ein.

RNNs hatten jedoch zwei fatale Schwachstellen:

Schwierigkeiten beim Erlernen langfristiger Abhängigkeiten: Wenn Sätze länger werden, verblasst die Information der zuerst eingegebenen Wörter, bis sie das Ende erreichen (Problem des verschwindenden Gradienten).
Paralleles Rechnen ist unmöglich: Da die Wörter nacheinander verarbeitet werden müssen, sind groß angelegte parallele Berechnungen mithilfe von GPUs schwierig, und das Training nimmt enorm viel Zeit in Anspruch.

Der Transformer löste einen Paradigmenwechsel aus, indem er die RNN-Struktur komplett verwarf und den Kontext ausschließlich mithilfe von „Attention“ erfasste. Dadurch gibt es unabhängig von der Sequenzlänge keinen Informationsverlust, und Berechnungen können parallelisiert werden, um die Leistung von GPUs maximal auszuschöpfen.

2. Die Gesamtarchitektur des Transformers

Lassen Sie uns zunächst einen Überblick über die Gesamtarchitektur des Transformers verschaffen. Der Transformer besteht grob aus zwei Blöcken: dem „Encoder“ und dem „Decoder“. Am Beispiel einer Übersetzungsaufgabe wandelt der Encoder die Eingabesprache (z.B. Englisch) in eine mathematische Vektordarstellung um, und der Decoder generiert basierend auf dieser Vektordarstellung die Ausgabesprache (z.B. Japanisch).

Das folgende Diagramm zeigt vereinfacht die interne Struktur des Encoder-Blocks.

graph TD A["Eingabe-Tokens"] --> B["Eingabe-Embedding"] B --> C["Positional Encoding"] C --> D["Multi-Head Self-Attention"] D --> E["Add & Layer Normalization"] E --> F["Feed-Forward-Netzwerk"] F --> G["Add & Layer Normalization"] G --> H["Ausgabe an nächste Schicht"] C -.->|"Residual Connection"| E E -.->|"Residual Connection"| G

Von hier an werden wir die mathematischen Operationen in den einzelnen Komponenten Schritt für Schritt betrachten.

3. Vektorisierung von Wörtern und Positionskodierung (Positional Encoding)

Computer können Text nicht so verstehen, wie er ist. Der eingegebene Text wird zunächst in Einheiten namens „Tokens“ unterteilt, die jeweils in einen Vektor fester Länge umgewandelt werden. Das ist das Input Embedding.

3.1 Die Mathematik des Input Embeddings

Sei $V$ die Größe des Vokabulars und $d_{model}$ die Anzahl der Dimensionen des Embedding-Vektors (im ursprünglichen Paper war $d_{model} = 512$). Jedes Wort $w_i$ wird mithilfe der Embedding-Matrix $W_E \in \mathbb{R}^{V \times d_{model}}$ in einen Vektor $x_i \in \mathbb{R}^{d_{model}}$ umgewandelt.

$$ x_i = W_E \cdot \text{one\_hot}(w_i) $$

Dadurch wird der gesamte Satz als Matrix $X \in \mathbb{R}^{N \times d_{model}}$ dargestellt (wobei $N$ die Länge des Satzes ist).

3.2 Die Notwendigkeit und Formel des Positional Encodings

Der Transformer verarbeitet Wörter nicht nacheinander wie ein RNN, sondern alle Wörter gleichzeitig und parallel. Dies ist hinsichtlich der Berechnungsgeschwindigkeit ein großer Vorteil, verursacht aber gleichzeitig das Problem, dass die wichtige Information der „Reihenfolge der Wörter (Wortstellung)“ verloren geht. Zum Beispiel sind die eingegebenen Wortmengen für „Ein Hund beißt einen Mann“ und „Ein Mann beißt einen Hund“ identisch, aber die Bedeutung ist völlig unterschiedlich.

Um dem Modell diese Information über die Wortstellung zur Verfügung zu stellen, wurde das Positional Encoding entwickelt. Das Positional Encoding $PE$ für die $i$-te Dimension eines Wortes an der Position $pos$ wird mithilfe der folgenden trigonometrischen Funktionen berechnet.

$$ PE_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$ $$ PE_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right) $$

Hierbei ist $pos$ die Position des Wortes ($0, 1, 2, \dots, N-1$) und $i$ der Index der Dimension des Vektors ($0, 1, \dots, d_{model}/2 - 1$).

Warum Sinus und Kosinus verwendet werden

Auf den ersten Blick sieht es nach einer sehr komplexen und seltsamen Formel aus, aber es gibt einen tiefen mathematischen Grund dafür. Durch die Verwendung trigonometrischer Funktionen kann das Modell nicht nur „absolute Positionen“, sondern auch die Differenz „relativer Positionen“ leicht erlernen.

Erinnern Sie sich an die Additionstheoreme für trigonometrische Funktionen aus der Schulmathematik.

$$ \sin(\alpha + \beta) = \sin\alpha \cos\beta + \cos\alpha \sin\beta $$ $$ \cos(\alpha + \beta) = \cos\alpha \cos\beta - \sin\alpha \sin\beta $$

Das Positional Encoding für eine Position $pos + k$, die um einen Offset $k$ von einer Position $pos$ entfernt ist, kann als Linearkombination des Positional Encodings der Position $pos$ dargestellt werden. Das bedeutet, es kann mithilfe einer Matrix $M_k$ wie folgt geschrieben werden:

$$ PE_{pos+k} = M_k \cdot PE_{pos} $$

Dadurch kann der Attention-Mechanismus durch die Berechnung von Skalarprodukten leicht erkennen, „wie weit“ Wörter voneinander entfernt sind (relative Distanz). Zudem hat es den Vorteil, dass durch die Kombination mehrerer Sinus- und Kosinuswellen unterschiedlicher Wellenlängen selbst für noch so lange Sätze ein eindeutiger Positionsvektor generiert werden kann.

Die endgültige Eingabematrix $X_{input}$ ergibt sich aus der Addition der Wort-Embedding-Vektoren und dieses Positional Encodings.

$$ X_{input} = X + PE $$

4. Die tiefgründige Mathematik der Self-Attention (Selbstaufmerksamkeitsmechanismus)

Nun dringen wir zur wichtigsten Komponente des Transformers vor: der Self-Attention (Selbstaufmerksamkeitsmechanismus). Das Ziel der Self-Attention ist es, „die Relevanz aller Wörter in einem Satz untereinander zu berechnen und den Vektor jedes Wortes zu einer reichhaltigeren Darstellung zu aktualisieren, die den Kontext berücksichtigt“.

Hierbei wird die Analogie eines „Suchsystems“ verwendet.

Query (Q): Suchanfrage. „Nach welchen Informationen suche ich gerade?“
Key (K): Schlüssel (Schlagwort). „Welche Informationen habe ich?“
Value (V): Wert (Inhalt). „Welche Informationen biete ich tatsächlich an?“

4.1 Generierung der Matrizen $Q, K, V$

Wir berechnen Query $Q$, Key $K$ und Value $V$, indem wir die Eingabematrix $X \in \mathbb{R}^{N \times d_{model}}$ (zur Vereinfachung ignorieren wir hier die Batch-Größe) mit den lernbaren Gewichtsmatrizen $W^Q, W^K, W^V \in \mathbb{R}^{d_{model} \times d_k}$ multiplizieren. (Normalerweise gilt $d_k = d_v = d_{model} / h$)

$$ Q = X W^Q $$ $$ K = X W^K $$ $$ V = X W^V $$

Hier sind $Q, K, V$ alle Matrizen der Form $\mathbb{R}^{N \times d_k}$.

4.2 Berechnung der Attention-Scores (Skalarprodukt)

Um zu messen, wie stark das Query jedes Wortes mit den Keys aller anderen Wörter in Beziehung steht, berechnen wir das Skalarprodukt der Vektoren. Als Matrixoperation geschrieben, sieht das wie folgt aus:

$$ \text{Scores} = Q K^T $$

Jedes Element $s_{ij}$ der aus dieser Berechnung resultierenden Matrix $\text{Scores} \in \mathbb{R}^{N \times N}$ repräsentiert das Skalarprodukt zwischen dem Query des $i$-ten Wortes und dem Key des $j$-ten Wortes, d. h. die „Stärke der Relevanz“.

4.3 Skalierung (Scale)

Die Score-Berechnung durch das Skalarprodukt hat ein Problem. Wenn die Dimension der Vektoren $d_k$ groß wird, werden die Werte des Skalarprodukts extrem groß oder extrem klein.

Lassen Sie uns dies mathematisch beweisen. Nehmen wir an, dass jedes Element des Queries $q \sim \mathcal{N}(0, 1)$ und jedes Element des Keys $k \sim \mathcal{N}(0, 1)$ einer unabhängigen Standardnormalverteilung folgt. Wir bestimmen den Mittelwert und die Varianz des Skalarprodukts $q \cdot k = \sum_{i=1}^{d_k} q_i k_i$. Mittelwert: Da $\mathbb{E}[q_i k_i] = \mathbb{E}[q_i] \mathbb{E}[k_i] = 0 \times 0 = 0$, ist auch der Mittelwert der Summe $0$. Varianz: Die Varianz von $q_i k_i$ ist aufgrund der Unabhängigkeit $\text{Var}(q_i k_i) = \mathbb{E}[(q_i k_i)^2] - (\mathbb{E}[q_i k_i])^2 = 1 \times 1 - 0 = 1$. Daher entspricht die Gesamtvarianz des Skalarprodukts der Dimensionsanzahl $d_k$.

$$ \text{Var}(q \cdot k) = d_k $$

Wenn die Varianz groß wird, tritt bei der anschließend angewendeten Softmax-Funktion das „Problem des verschwindenden Gradienten“ auf, bei dem die Gradienten für alle Werte außer dem Maximum extrem klein werden, wodurch das Training stagniert. Um dies zu verhindern, teilen wir die Scores durch $\sqrt{d_k}$ (Skalierung), um die Varianz stets bei $1$ zu halten.

$$ \text{Scaled Scores} = \frac{Q K^T}{\sqrt{d_k}} $$

4.4 Umwandlung in Wahrscheinlichkeiten durch die Softmax-Funktion

Um die erhaltenen Scores in eine Wahrscheinlichkeitsverteilung (Gewichte) umzuwandeln, deren Summe $1$ ergibt, wird die Softmax-Funktion zeilenweise angewendet.

$$ a_{ij} = \text{softmax}(s_i)_j = \frac{\exp(s_{ij} / \sqrt{d_k})}{\sum_{m=1}^N \exp(s_{im} / \sqrt{d_k})} $$

Die Matrix $A \in \mathbb{R}^{N \times N}$ wird als Attention-Weight-Matrix (Aufmerksamkeitsgewichtsmatrix) bezeichnet. Wenn wir uns jede Zeile $i$ dieser Matrix ansehen, wird durch einen Wert zwischen 0 und 1 ausgedrückt: „Wie viel Aufmerksamkeit (Attention) sollte man anderen Wörtern $j$ schenken, um das Wort $i$ zu verstehen?“.

4.5 Gewichtete Summe der Values

Schließlich berechnen wir mithilfe der erhaltenen Attention-Weight-Matrix $A$ die gewichtete Summe der Value-Matrix $V$.

$$ \text{Output} = A V = \text{softmax}\left(\frac{Q K^T}{\sqrt{d_k}}\right) V $$

Die durch diese Operation ausgegebene Matrix $Z \in \mathbb{R}^{N \times d_v}$ ist eine Sammlung von „Vektordarstellungen der Wörter, die unter Berücksichtigung des Kontextes aktualisiert wurden“. Dies ist das vollständige Bild der im Paper definierten Scaled Dot-Product Attention.

5. Multi-Head Attention

Mit nur einer einzigen Attention-Berechnung (Single-Head) besteht die Möglichkeit, dass der Kontext nur aus einer Perspektive (z. B. „grammatikalische Beziehungen“) erfasst wird. Um die vielfältigen semantischen und syntaktischen Beziehungen der Sprache („Subjekt und Prädikat“, „Pronomen und ihr Bezugswort“ usw.) gleichzeitig zu erfassen, wurde die Multi-Head Attention eingeführt.

Die Generierung von $Q, K, V$ und die Attention-Berechnung von vorhin werden $h$-mal parallel durchgeführt ($h$ ist die Anzahl der Heads; im ursprünglichen Paper war $h=8$).

$$ \text{head}_i = \text{Attention}(X W_i^Q, X W_i^K, X W_i^V) $$

Hierbei sind $W_i^Q, W_i^K, W_i^V \in \mathbb{R}^{d_{model} \times d_k}$ die lernbaren Gewichtsmatrizen speziell für den $i$-ten Head.

Die von jedem Head ausgegebenen Ergebnisse $\text{head}_i \in \mathbb{R}^{N \times d_v}$ werden horizontal verkettet (Concatenate).

$$ \text{Concat}(\text{head}_1, \dots, \text{head}_h) \in \mathbb{R}^{N \times (h \cdot d_v)} $$

Normalerweise wird $h \cdot d_v = d_{model}$ so gewählt, dass die Dimension nach der Verkettung wieder auf das Eingangsmaß $d_{model}$ zurückkehrt. Schließlich wird diese Matrix mit der Gewichtsmatrix $W^O \in \mathbb{R}^{d_{model} \times d_{model}}$ multipliziert, um die endgültige Ausgabe zu erhalten.

$$ \text{MultiHead}(Q, K, V) = \text{Concat}(\text{head}_1, \dots, \text{head}_h) W^O $$

graph TD X["Eingabe X"] --> Q1["Q1"] X --> K1["K1"] X --> V1["V1"] Q1 & K1 & V1 --> H1["Head 1"] X --> Q2["Q2"] X --> K2["K2"] X --> V2["V2"] Q2 & K2 & V2 --> H2["Head 2"] X --> QN["..."] X --> KN["..."] X --> VN["..."] QN & KN & VN --> HN["Head h"] H1 & H2 & HN --> C["Verketten"] C --> WO["Mit WO multiplizieren"] WO --> OUT["Multi-Head Ausgabe"]

6. Feed-Forward Neural Network (FFN)

Die Ausgabe der Multi-Head Attention wird anschließend in das Position-wise Feed-Forward Network (FFN) eingespeist. Dies ist ein zweischichtiges, vollständig verbundenes neuronales Netzwerk, das „für jede Position (jedes Wort) in der Sequenz unabhängig“ angewendet wird.

Als mathematische Formel ausgedrückt, sieht das so aus:

$$ \text{FFN}(x) = \max(0, x W_1 + b_1) W_2 + b_2 $$

Hierbei repräsentiert $\max(0, z)$ die ReLU-Aktivierungsfunktion (Rectified Linear Unit) (in neueren Modellen werden oft auch GELU oder SwiGLU verwendet).

Die Rolle dieses Netzwerks ist äußerst wichtig. Während der Attention-Mechanismus „Beziehungen zwischen Wörtern (räumliche und sequentielle Beziehungen)“ erlernt, ist das FFN für die „nichtlineare Feature-Transformation jedes einzelnen Wortvektors“ verantwortlich. Typischerweise wird die Dimension durch die Gewichte der ersten Schicht $W_1$ vorübergehend stark erweitert (z. B. vervierfacht von $d_{model}=512$ auf $d_{ff}=2048$), um komplexe Berechnungen im Merkmalsraum durchzuführen, und dann durch die Gewichte der zweiten Schicht $W_2$ wieder auf die ursprüngliche Dimension reduziert. Durch diese „Erweiterung und Reduktion der Dimensionen“ wird die Ausdruckskraft des Modells dramatisch erhöht.

7. Residual Connection und Layer Normalization

Im Deep Learning tritt bei tiefer werdenden Netzwerkschichten das Problem auf, dass Gradienten während des Trainings verschwinden oder explodieren, was ein erfolgreiches Training verhindert. Um dies zu verhindern, sind um jede Subschicht (Attention und FFN) des Transformers eine Residual Connection (Restverbindung) und eine Layer Normalization (Schichtnormalisierung) angeordnet.

Als Formel geschrieben, wird die Ausgabe der Subschicht wie folgt verarbeitet:

$$ \text{Output} = \text{LayerNorm}(x + \text{Sublayer}(x)) $$

7.1 Residual Connection ($x + \text{Sublayer}(x)$)

Die Eingabe $x$ wird direkt zur Ausgabe der Subschicht addiert. Dadurch wird der Gradient bei der Backpropagation direkt durch einen Shortcut in flachere Schichten weitergeleitet, wodurch das Training selbst bei tiefen Schichten stabil bleibt.

7.2 Die Mathematik der Layer Normalization

Layer Normalization ist eine Technik, die den Mittelwert und die Varianz entlang der Dimension der Merkmale berechnet und die Daten normalisiert. Bei einer Eingabe mit der Batch-Größe $B$, der Sequenzlänge $N$ und der Dimensionsanzahl $d_{model}$ wird die Normalisierung für einen einzelnen Wortvektor $x \in \mathbb{R}^{d_{model}}$ durchgeführt.

Wir berechnen den Mittelwert $\mu$ und die Varianz $\sigma^2$.

$$ \mu = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} x_i $$ $$ \sigma^2 = \frac{1}{d_{model}} \sum_{i=1}^{d_{model}} (x_i - \mu)^2 $$

Dann erhalten wir die normalisierte Ausgabe $\hat{x}$.

$$ \text{LN}(x) = \frac{x - \mu}{\sqrt{\sigma^2 + \epsilon}} \odot \gamma + \beta $$

($\epsilon$ ist eine winzige Konstante zur Vermeidung einer Division durch null. $\gamma, \beta$ sind lernbare Skalierungs- und Verschiebungsparameter.)

Der Grund für die Verwendung der schichtweisen Normalisierung (Layer Normalization) anstelle der Normalisierung in Batch-Richtung (Batch Normalization) liegt darin, dass bei der Verarbeitung von sequenziellen Daten mit variabler Länge, wie z.B. Sätzen, die Statistiken zwischen den Batches tendenziell instabil werden. Dank der Layer Normalization ermöglicht der Transformer ein stabiles Training unabhängig von der Batch-Größe.

8. Decoderspezifische Strukturen: Masked Attention und Cross-Attention

Die bisher erläuterten Strukturen gehören zum Encoder. Beim Decoder-Block, der Sätze generiert, weicht die Struktur leicht ab.

8.1 Masked Multi-Head Attention

Die Rolle des Decoders ist es, „das nächste Wort aus vergangenen Wörtern vorherzusagen“. Daher wäre es beim Training Schummeln, wenn er „zukünftige Wörter“ sehen würde. Die mathematische Operation, um dies zu verhindern, ist das Masking (Maskierung).

Zur Score-Matrix $Q K^T$ wird eine Maskenmatrix $M$ addiert, die im oberen Dreiecksteil (was den zukünftigen Informationen entspricht) sehr kleine Werte nahe $-\infty$ setzt.

$$ M_{ij} = \begin{cases} 0 & (i \le j) \\ -\infty & (i > j) \end{cases} $$ $$ \text{Masked Attention}(Q, K, V) = \text{softmax}\left(\frac{Q K^T + M}{\sqrt{d_k}}\right) V $$

Bei der Berechnung der Softmax-Funktion wird $\exp(-\infty) = 0$, sodass das Attention-Weight für zukünftige Wörter komplett $0$ wird. Dadurch wird eine autoregressive Generierung unter Beibehaltung der Kausalität ermöglicht.

8.2 Encoder-Decoder Cross-Attention

Die zweite Subschicht des Decoders ist die Cross-Attention, die auf die Ausgabe des Encoders verweist. Hierbei wird $Q$ aus der vorherigen Decoder-Schicht generiert, während $K$ und $V$ aus der Ausgabe der letzten Encoder-Schicht generiert werden.

$$ Q_{decoder} = X_{dec} W^Q $$ $$ K_{encoder} = X_{enc} W^K $$ $$ V_{encoder} = X_{enc} W^V $$

Durch diese Berechnung kann das Modell bei Übersetzungsaufgaben lernen, „mit welchem Teil des ursprünglichen fremdsprachigen Satzes das aktuell zu übersetzende Wort stark zusammenhängt“.

9. Rechenaufwand und die Mathematik der Optimierung in der Moderne

Der Transformer ist ein großartiges Modell, hat aber aufgrund seiner mathematischen Struktur auch „Schwachstellen“. Achten Sie auf den Rechenaufwand der Self-Attention. Bei der Berechnung der Score-Matrix $Q K^T$ wird eine $(N \times d_k)$-Matrix mit einer $(d_k \times N)$-Matrix multipliziert, sodass der Rechenaufwand $O(N^2 \cdot d_{model})$ beträgt.

Das bedeutet, dass Rechenaufwand und Speicherverbrauch quadratisch zur Sequenzlänge $N$ ansteigen. Bei kurzen Texten ist das kein Problem, aber wenn man versucht, einen extrem langen Kontext wie ein ganzes Buch in ein LLM einzuspeisen, erreicht $N$ Zehn- bis Hunderttausende, und bei herkömmlichen Attention-Berechnungen wäre der GPU-Speicher sofort erschöpft.

Um diesen Fluch der $O(N^2)$-Komplexität zu brechen, wurden in den letzten Jahren verschiedene Optimierungen aus mathematischen und hardwaretechnischen Ansätzen vorgeschlagen. Ein Paradebeispiel dafür ist FlashAttention. FlashAttention ist ein Algorithmus, der die Attention-Berechnung in Kacheln unterteilt (Tiling), um den Datentransfer (Speicherzugriff) zwischen den Speicherhierarchien der GPU (SRAM und HBM) zu minimieren. Obwohl es mathematisch exakt das gleiche Ergebnis wie die Standard-Attention liefert (Exact Attention), erreicht es durch Optimierung auf Hardware-Ebene eine dramatische Beschleunigung und Speicherreduzierung, was die Realisierung von Modellen mit langem Kontext wie GPT-4 ermöglicht hat.

Darüber hinaus wird intensiv an Sparse Attention, Linear Attention und Ähnlichem geforscht, die den Rechenaufwand auf $O(N \log N)$ oder $O(N)$ annähern.

10. Vorstellungen zur Implementierung (Pseudocode im PyTorch-Stil)

Wenn man die bisherigen mathematischen Strukturen in tatsächlichen Programmiercode (Python / PyTorch) überträgt, stellt man fest, dass sie überraschend einfach geschrieben werden können. Hier ist der Pseudocode für den Kernteil der Self-Attention.

 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


import torch
import torch.nn.functional as F
import math

def scaled_dot_product_attention(q, k, v, mask=None):
 # Form von q, k, v: [batch_size, num_heads, seq_length, d_k]
 d_k = q.size(-1)

 # 1. Score-Berechnung durch Skalarprodukt: Q * K^T
 # Die letzten beiden Dimensionen transponieren und Matrixprodukt berechnen
 scores = torch.matmul(q, k.transpose(-2, -1))

 # 2. Skalierung
 scores = scores / math.sqrt(d_k)

 # 3. Maskierung (im Falle von Masked Attention)
 if mask is not None:
 scores = scores.masked_fill(mask == 0, -1e9)

 # 4. Umwandlung in Wahrscheinlichkeiten durch Softmax
 attention_weights = F.softmax(scores, dim=-1)

 # 5. Multiplikation mit der Value-Matrix
 output = torch.matmul(attention_weights, v)

 return output, attention_weights

Man kann sehen, dass der mathematisch dargestellte Ausdruck $Q K^T / \sqrt{d_k}$ intuitiv als torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_k) implementiert wird. Es ist ein sehr faszinierender Aspekt des Deep Learning, dass mathematische Theorien mithilfe von stark optimierten Bibliotheken in wenigen Codezeilen realisiert werden können.

Fazit: Die Form der „Intelligenz“, wie sie aus mathematischen Formeln ersichtlich wird

In diesem Artikel haben wir die tiefgründigen mathematischen Strukturen des Transformer-Modells entschlüsselt.

Das Embedding, das Wörter in einen mehrdimensionalen Vektorraum abbildet, das Positional Encoding, das Positionsinformationen durch die Synthese von Dreieckswellen ausdrückt, und der Self-Attention-Mechanismus, der aus einer Analogie zur Informationsbeschaffung entstandene Matrizenmultiplikationen verwendet. Jede dieser Komponenten ist lediglich eine Ansammlung von grundlegender Mathematik wie linearer Algebra, Differenzial- und Integralrechnung sowie Wahrscheinlichkeitsrechnung und Statistik.

Wenn sich diese einfachen Matrixoperationen jedoch in unzähligen Schichten überlagern und Muster aus gigantischen Datensätzen durch Milliarden oder Hunderte von Milliarden an Parametern lernen, entsteht eine „Form von Intelligenz“, die unsere „Wörter“ zu verstehen, logische Schlüsse zu ziehen und manchmal kreative Ideen hervorzubringen scheint.

Wie der provokante Titel „Attention Is All You Need“ andeutet, liegt die Schönheit dieser Architektur, die komplexe rekurrente und konvolutionale Verarbeitungen verworfen und sich auf die reinrassige Berechnung von „Attention (Relevanz)“ spezialisiert hat, gerade in ihrer mathematischen Einfachheit.

In Zukunft könnten zwar neue Architekturen auftauchen, die den Transformer übertreffen (wie z. B. Mamba, ein State Space Model), aber der mathematische Rahmen des „Kontextverständnisses durch Attention“, den der Transformer geschaffen hat, wird für immer in der Geschichte der KI verankert bleiben.

Wenn Sie künftig die Gelegenheit haben, LLMs wie ChatGPT oder Claude zu nutzen, stellen Sie sich vor, wie im Hintergrund jede Sekunde Billionen von Matrixmultiplikationen von $Q K^T$ berechnet werden und die Softmax-Funktion Wahrscheinlichkeiten ausspuckt. Ihr Verständnis für die Technologie wird sich vertiefen, und die Welt der KI wird Ihnen noch faszinierender erscheinen.

Literaturverzeichnis

Vaswani, A., et al. (2017). “Attention Is All You Need.” Advances in Neural Information Processing Systems.
Alammar, J. (2018). “The Illustrated Transformer.”

Dieser Artikel wurde als Leitfaden für all jene verfasst, die die mathematischen Grundlagen der natürlichen Sprachverarbeitung und der KI erlernen möchten. Wenn Sie Fragen oder Diskussionsbedarf haben, lassen Sie es mich bitte in den Kommentaren wissen!

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.

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