Elementare Kryptographie - Mathematik

Werbung
Universität Paderborn
Fakultät für Elektrotechnik, Informatik und Mathematik
Institut für Mathematik
Elementare Kryptographie
Kai Gehrs
[email protected]
Paderborn, 19. November 2007
Inhaltsverzeichnis
1
2
3
Grundlagen: (Computer)Algebra
1.1 Addition und Multiplikation . . . . . . . . . . . . . . . .
1.2 “Repeated Squaring” (Effizientes Potenzieren) . . . . . . .
1.3 Division mit Rest . . . . . . . . . . . . . . . . . . . . . .
1.4 Der Euklidische Algorithmus . . . . . . . . . . . . . . . .
1.5 Berechnung modularer Inverser . . . . . . . . . . . . . . .
1.6 Der Chinesische Restsatz . . . . . . . . . . . . . . . . . .
1.7 Die Eulersche ϕ-Funktion . . . . . . . . . . . . . . . . .
1.7.1 Die durchschnittliche Ordnung von ϕ(n) . . . . .
1.8 Kettenbrüche . . . . . . . . . . . . . . . . . . . . . . . .
1.9 Einige gruppentheoretische Resultate . . . . . . . . . . . .
1.9.1 Der Satz von Lagrange . . . . . . . . . . . . . . .
1.9.2 Der Satz von Euler und der kleine Satz von Fermat
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Grundlagen aus der Zahlentheorie
2.1 Finden von Primzahlen und Primzahltest . . . . . . . . . . . . .
2.2 Faktorisierung ganzer Zahlen . . . . . . . . . . . . . . . . . . .
2.2.1 Die Pollard ρ-Methode zur Faktorisierung ganzer Zahlen
2.2.2 Dixon’s Zufallsquadrate . . . . . . . . . . . . . . . . .
Diskrete Logarithmen
3.1 Grundlegende Definitionen . . . . . . . . . . . . . . .
3.2 Der “Baby-Schritt-Riesen-Schritt” Algorithmus . . . .
3.3 Der Geburtstagsangriff auf den diskreten Logarithmus .
3.4 Die Pollard ρ-Methode . . . . . . . . . . . . . . . . .
3.5 Der “Chinese-Remaindering” Algorithmus . . . . . . .
3.6 Der Algorithmus von Pohlig & Hellman . . . . . . . .
3.7 Zusammenfassung . . . . . . . . . . . . . . . . . . .
3.8 Index-Kalkül für den diskreten Logarithmus in Z×
. .
p
3.9 Arithmetische Schaltkreise . . . . . . . . . . . . . . .
3.9.1 (Deterministische) arithmetische Schaltkreise .
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
3
3
4
5
5
9
12
14
15
21
24
24
25
.
.
.
.
27
27
31
31
34
.
.
.
.
.
.
.
.
.
.
37
37
38
39
39
43
45
46
47
49
49
3.9.2
4
5
6
7
Probabilistische arthmetische Schaltkreise . . . . . . . . . . . . . . .
Einige Kryptosysteme
4.1 Vorbemerkungen . . . . . . . . . . . . . . . . . . . . . .
4.1.1 Symmetrische und Asymmetrische Kryptosysteme
4.1.2 Alice, Bob und Eve . . . . . . . . . . . . . . . . .
4.1.3 “Block Ciphers” und “Stream Ciphers” . . . . . .
4.2 Rijndael . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2.1 Algebraische Grundlagen . . . . . . . . . . . . . .
4.2.2 Einiges zur Spezifikation . . . . . . . . . . . . . .
4.2.3 Verschlüsselung von Nachrichten mit Rijndael . .
4.3 Das RSA-Verfahren . . . . . . . . . . . . . . . . . . . . .
4.3.1 Der Angriff von Wiener auf RSA . . . . . . . . .
4.4 Diffie und Hellman Schlüsselaustauschverfahren . . . . .
4.4.1 “Woman-in-the-Middle” Angriff . . . . . . . . . .
4.5 Das Kryptosystem von El’Gamal . . . . . . . . . . . . . .
4.6 “Secret Sharing” . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
52
54
54
54
55
55
56
57
58
58
61
62
63
64
65
66
Unterschriften (Signaturen)
5.1 Zum Konzept von Unterschriftenverfahren . . . . . . . . . . . . . . . . . . .
5.2 Das Unterschriftenverfahren von ElGamal . . . . . . . . . . . . . . . . . . .
5.3 Fälschungssicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Die Angriffe von Mitchell auf ElGamal Unterschriften . . . . . . . .
5.3.2 Zur unvorsichtigen Benutzung des Unterschriftenverfahrens von ElGamal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.4 Schnorr Unterschriften . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
68
68
69
70
70
Hash-Funktionen
6.1 Eine spezielle Hash-Funktion . . . . . . . . .
6.2 Hashing von Blocknachrichten . . . . . . . .
6.2.1 Kryptosysteme und Hash-Funktionen
6.3 Zeitstempel . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
74
75
76
77
77
Identifikation und Authentifikation
7.1 Das Identifikationsverfahren von Schnorr
7.2 Das Identifikationsverfahren von Okamoto
7.3 Ein RSA-basiertes Identifikationsschema .
7.4 Ein sicheres Schlüsselaustauschverfahren
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
78
79
80
81
82
Literaturverzeichnis
.
.
.
.
.
.
.
.
71
71
84
2
Kapitel 1
Grundlagen aus Algebra und
Computeralgebra
In diesem Kapitel werden die grundlegenden theoretischen Hilfsmittel aus der Computeralgebra diskutiert, die nötig sind, um die Korrektheit des RSA Verfahrens 4.1 beweisen zu können.
Ferner werden wir Algorithmen zitieren und ihre Laufzeiten analysieren, um begründen zu
können, dass die vorgestellten Kryptosysteme für ihre berechtigten Benutzer effizient verwendet werden können. Laufzeiten werden wie üblich in der O-Notation angegeben:
Definition 1.1. Seien f , g : Z → R Funktionen mit f (n), g(n) ≥ 0 für alle n 0. Dann gilt
g ∈ O( f ), falls g(n) ≤ c · f (n) für alle n ≥ N mit N ∈ N und c ∈ R.
Damit bedeutet g ∈ O( f ) im wesentlichen nichts anderes, als dass g bis auf Multiplikation
mit einer Konstanten c ∈ R “höchstens so schnell wächst” wie f .
1.1
Addition und Multiplikation
Wir werden uns in der Regel auf die Addition und Multiplikation von ganzen Zahlen oder
Polynomen über einem kommutativen Ring beschränken. Zur Addition zweier Polynome
i
f , g ∈ R[x] mit f = ∑ni=0 ai · xi und g = ∑m
i=0 bi · x über einem kommutativen Ring R mit
Einselement werden O(max{m, n}) Operationen in R benötigt. Für die Multiplikation von
f und g benötigen wir mittels bloßem Ausmultiplizieren der Summendarstellungen O(m · n)
Ringoperationen in R.
i
Jede ganze Zahl x ∈ Z können wir in Binärdarstellung in der Form x = ∑n−1
i=0 xi · 2 mit xi ∈
{0, 1} für i = 0, . . . , n − 1 schreiben. Die Zahl n heißt dann die Binärlänge von x.
Lemma 1.2. Addition zweier n-Bit Zahlen x, y ∈ Z ist mit O(n) Bit-Operationen durchführbar.
n−1
i
i
Beweis. Wir schreiben x = ∑n−1
i=0 xi · 2 sowie y = ∑i=0 yi · 2 mit xi , yi ∈ {0, 1} für alle i =
0, . . . , n − 1. Addition von x und y wird komponentenweise auf den Bits durchgeführt. Daraus
folgt die Behauptung.
3
4
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
Lemma 1.3. Multiplikation zweier n-Bit Zahlen x, y ∈ Z ist mit O(n2 ) Bit-Operationen
durchführbar.
n−1
i
i
Beweis. Wir schreiben x = ∑n−1
i=0 xi · 2 sowie y = ∑i=0 yi · 2 mit xi , yi ∈ {0, 1} für alle i =
0, . . . , n − 1. Analog zur Multiplikation von Polynomen benötigt man O(n · n) = O(n2 ) BitOperationen.
Bemerkung 1.4. Es sind schnellere Methoden zur Multiplikation zweier n-Bit Zahlen bekannt. So benötigt z.B. ein Algorithmus, der auf Schönhage und Strassen zurückgeht, nur
O(n log n log log n) Bit-Operationen.
1.2
“Repeated Squaring” (Effizientes Potenzieren)
In einer Reihe kryptographischer Verfahren ist es von essentieller Wichtigkeit, dass man effizient auch große Potenzen von Gruppenelementen berechnen kann. Das in diesem Abschnitt
kurz vorgestellte Verfahren kann universell in einer beliebigen Gruppe G verwendet werden,
um xk für ein Element x ∈ G und k ∈ N zu berechnen. Aus diesem Grund geben wir den
Algorithmus zur Berechnung solcher Potenzen auch zunächst in sehr allgemeiner Form an.
Algorithmus 1.5. (“Repeated Squaring”) Sei G eine Gruppe, x ∈ G und k ∈ N. Ferner sei
i
k = ∑n−1
i=0 ki · 2 die Binärdarstellung der Zahl k mit kn−1 = 1.
(1) Setze y := x.
(2) Für i = n − 2, . . . , 0 berechne:
y := y2
Ist ki = 1, so berechne zusätzlich y := y · x.
(3) Gebe y = xk aus.
Anstatt eines Korrektheitsbeweises, bei dem man die Gültigkeit einer entsprechend geschickt
gewählten Invariante nachweist, betrachten wir ein kleines Beispiel:
Beispiel 1.6. Sei G eine Gruppe und x ∈ G. Wir wollen x20 mit Hilfe von Algorithmus 1.5
berechnen. Es ist k4 k3 k2 k1 k0 = 10100 die Binärdarstellung der Zahl 20. Zuerst setzen wir y :=
x. Wegen k3 = 0 setzen wir y := y2 = x2 und verzichten auf eine zusätzliche Multiplikation
mit x. Im nächsten Schritt ist k2 = 1 zu betrachten. Wir berechnen also zuerst y := y2 = x4 und
dann zusätzlich y := y · x = x5 . Wegen k1 = k0 = 0 sind die nächsten beiden auszuführenden
Schritte y := y2 = x10 und zuletzt ist der Wert von y ein weiteres Mal zu quadrieren: y := y2 =
x20 .
In der Notation von 1.5 erhalten wir für die Laufzeit des Algorithmus:
Korollar 1.7. Algorithmus 1.5 berechnet in Schritt (2) O(n)-mal das Quadrat des Elementes
y und O(n)-mal das Produkt von y mit x. Insgesamt ergibt sich damit eine Laufzeit von O(n ·
MG ), wobei MG die Laufzeit für eine Multiplikation zweier Elemente in G beschreibt.
1.3. DIVISION MIT REST
1.3
5
Division mit Rest
Sowohl im Ring der ganzen Zahlen als auch im Polynomring über einem Körper können wir
stets Division mit Rest durchführen. Division mit Rest ist essentieller Bestandteil des Euklidischen Algorithmus und von modularer Arithmetik. Es soll an dieser Stelle weniger auf
algorithmische Details eingegangen werden. Als Beispiel betrachten wir hier nur die Division mit Rest für Polynome über einem Körper. Auf ähnliche, aber ein wenig kompliziertere
Weise, lassen sich auch Algorithmen zur Division mit Rest von ganzen Zahlen angeben, die
auf ihren Binärdarstellungen operieren.
i
Algorithmus 1.8. (Division mit Rest) Seien f = ∑ni=0 ai · xi und g = ∑m
i=0 bi · x Polynome
aus F[x], F ein Körper.
(1) Setze r := f .
(2) Für i = n − m, . . . , 0 wiederhole:
Wenn deg r = m + i, so setze qi :=
lc(r)
bm
und r := r − qi · xi · g.
Andernfalls setze qi := 0.
i
(3) Gebe q = ∑n−m
i=0 qi · x aus.
Dann gilt f = q · g + r mit deg r < deg g.
Algorithmus 1.8 benötigt im wesentlichen (n−m+1)·(2m) Additionen und Multiplikationen
in F. Damit folgt:
Lemma 1.9. Division mit Rest eines Polynoms f vom Grad n durch ein Polynom g vom Grad
m mit n > m benötigt O(n2 ) Operationen im zugrundeliegenden Koeffizientenring.
Ähnliche Resultate lassen sich auch für ganze Zahlen angeben. Ohne Beweis geben wir an:
Lemma 1.10. Sind a, b ∈ Z mit Binärlängen n bzw. m, so ist Division mit Rest a = q · b + r
mit q, r ∈ Z und 0 ≤ r < |b| mit O(m · (n − m)) Bit-Operationen durchführbar, wobei n − m
im wesentlichen die Binärlänge des Quotienten q beschreibt.
1.4
Der Euklidische Algorithmus
Zur Erinnerung stellen wir diesem Abschnitt die folgenden beiden elementaren Definitionen
voran:
Definition 1.11. Sei R ein Ring. Dann heißt a ein Teiler von b, a | b, falls es ein r ∈ R gibt
mit b = r · a.
Definition 1.12. Sei R ein euklidischer Ring (d.h. ein Ring, in dem man zwei Elemente per
Division mit Rest durcheinander dividieren kann).
6
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
(i) Dann heißt d ∈ R ein größter gemeinsamer Teiler von a, b ∈ R, d = ggT(a, b), falls d | a
und d | b und für alle s ∈ R mit s | a und s | b stets s | d folgt.
(ii) Ein Element k ∈ R heißt kleinstes gemeinsames Vielfaches von a und b, k = kgV(a, b),
falls a | k und b | k und für alle l ∈ R mit a | l und b | l stets k | l folgt.
Für R = Z sprechen wir häufig von “dem” größten gemeinsamen Teiler und meinen damit den
eindeutig bestimmten positiven größten gemeinsamen Teiler zweier ganzer Zahlen. Gleiches
gilt für das kleinste gemeinsame Vielfache zweier ganzer Zahlen. Im folgenden Lemma fassen
wir ohne Beweis einige der wesentlichen Eigenschaften des größten gemeinsamen Teilers
ganzer Zahlen zusammen:
Lemma 1.13. Seien a, b, c ∈ Z. Dann gilt:
(i) ggT(a, b) = |a| genau dann, wenn a | b.
(ii) ggT(a, a) = ggT(a, 0) = |a| und ggT(a, 1) = 1.
(iii) Kommutativität: ggT(a, b) = ggT(b, a).
(iv) Assoziativität: ggT(a, ggT(b, c)) = ggT(ggT(a, b), c).
(v) Distributivität: ggT(c · a, c · b) = |c| · ggT(a, b).
(vi) Gilt |a| = |b|, so folgt stets ggT(a, c) = ggT(b, c).
(vii) Ist g = ggT(a, b), g > 0, so existieren s,t ∈ Z mit g = s · a + t · b.
Die Darstellung Lemma 1.13 (vii) liefert der Erweiterte Euklidische Algorithmus, der in einem beliebigen euklidischen Ring durchgeführt werden kann. Wir geben ihn der Einfachheit
halber nur für ganze Zahlen an. Die hier vorgestellte Version kann aber leicht in eine Version
für Polynome “umgeschrieben” werden, wenn man die entsprechenden Ungleichungen als
Ungleichungen über den Grad der betrachteten Polynome interpretiert.
Vorab aber noch ein kleines Lemma, das uns beim Beweis der Korrektheit des Algorithmus
sehr nützlich sein wird:
Lemma 1.14. Seien a, b ∈ Z. Dann gilt: ggT(a, b) = ggT(a mod b, b).
Beweis. Division mit Rest liefert a = q · b + (a mod b). Es gilt: ggT(a, b) teilt sowohl
a als auch b, also auch a mod b = a − q · b und damit ggT(a mod b, b). Umgekehrt teilt
ggT(a mod b, b) sowohl a mod b als auch b und damit auch a = q · b + (a mod b). Wir erhalten
also ggT(a, b) | ggT(a mod b, b) und ggT(a mod b, b) | ggT(a, b). Daraus folgt die Behauptung.
Algorithmus 1.15. (Erweiterter Euklidischer Algorithmus (EEA)) Seien a, b ∈ Z mit
|a| ≥ |b|.
1.4. DER EUKLIDISCHE ALGORITHMUS
7
(1) Setze r0 := a, r1 := b, s0 := 1, s1 := 0, t0 := 0, t1 := 1 und i := 1.
(2) Wiederhole den folgenden Schritt, bis rl+1 = 0 gilt für ein l ∈ N0 :
Berechne qi := ri−1 div ri als ganzzahligen Quotienten von ri−1 und ri .
ri+1 := ri−1 − qi · ri (d.h. ri+1 = ri−1 mod ri )
si+1 := si−1 − qi · si
ti+1 := ti−1 − qi · ti
i := i + 1
(3) Gebe rl , sl und tl aus.
Dann ist rl ein größter gemeinsamer Teiler von a und b und es gilt rl = sl · a + tl · b.
Beweis. (Korrektheit) Der Erweiterte Euklidische Algorithmus 1.15 terminiert, denn es gilt
für ri mit i ≥ 2 die Ungleichung 0 ≤ ri = ri−2 mod ri−1 < ri−1 ≤ a. Damit bilden die Reste
ri eine streng monoton fallende Folge ganzer Zahlen, die nach unten durch 0 beschränkt ist,
d.h. der Algorithmus muss terminieren. Wir zeigen nun, dass für alle i gilt:
si · a + ti · b = ri .
Für i = 0 und i = 1 ist die Behauptung klar per Definition von r0 , r1 , s0 , s1 ,t0 ,t1 . Sei nun i ≥ 2.
Dann folgt per Induktion:
si · a + ti · b = (si−2 − qi−1 · si−1 ) · a + (ti−2 − qi−1 · ti−1 ) · b
= (si−2 · a + ti−2 · b) − (qi−1 · si−1 · a + qi−1 · ti−1 · b)
= ri−2 − qi−1 · (si−1 · a + ti−1 · b)
= ri−2 − qi−1 · ri−1
= ri
Damit folgt für i = l mit sl · a + tl · b = rl die behauptete Darstellung. Es bleibt zu zeigen,
dass rl in der Tat ein größter gemeinsamer Teiler von a und b ist. Mit Lemma 1.14 und
a = (a div b) · b + (a mod b) = q1 · b + r2 folgt ggT(a, b) = ggT(a mod b, b) = ggT(r2 , b) =
ggT(r2 , r1 ). Wegen ri+1 = ri−1 mod ri folgt ggT(ri−1 , ri ) = ggT(ri−1 mod ri , ri ) = ggT(ri+1 , ri ).
Wegen rl+1 = 0 und rl = ggT(rl+1 , rl ) folgt per Rekursion rl = ggT(r2 , r1 ) = ggT(a, b).
Wir betrachten ein Beispiel:
Beispiel 1.16. Seien a = 126 und b = 35. zunächst definieren wir r0 := 126, r1 := 35, s0 := 1,
8
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
s1 := 0, t0 := 0 und t1 := 1. Dann folgen wir der Vorschrift aus 1.15:
i=1
q1 = r0 div r1 = 126 div 35 = 3
r2 = r0 − q1 · r1 = 126 − 3 · 35 = 21
s2 = s0 − q1 · s1 = 1 − 3 · 0 = 1
t2 = t0 − q1 · t1 = 0 − 3 · 1 = −3
i=2
q2 = r1 div r2 = 35 div 21 = 1
r3 = r1 − q2 · r2 = 35 − 1 · 21 = 14
s3 = s1 − q2 · s2 = 0 − 1 · 1 = −1
t3 = t1 − q2 · t2 = 1 − 1 · (−3) = 4
i=3
q3 = r2 div r3 = 21 div 16 = 1
r4 = r2 − q3 · r3 = 21 − 1 · 14 = 7
s4 = s2 − q3 · s3 = 1 − 1 · (−1) = 2
t4 = t2 − q3 · t3 = −3 − 1 · 4 = −7
i=4
q4 = r3 div r4 = 14 div 7 = 2
r5 = r3 − q4 · r4 = 14 − 2 · 7 = 0
Damit folgt: ggT(126, 35) = r4 = 7 und 7 = 2 · 126 + (−7) · 35.
Nun wollen wir uns überlegen, welche Kosten der Erweiterte Euklidische Algorithmus für
zwei ganze Zahlen a und b beansprucht.
Theorem 1.17. Der Erweiterte Euklidische Algorithmus 1.15 für zwei Zahlen a, b ∈ Z mit
|a| ≥ |b| und n := blog2 |a|c + 1 benötigt O(n) Wiederholungen von Schritt (2) und insgesamt
eine Laufzeit von O(n2 ) Bit-Operationen.
Beweis. Im folgenden setzen wir o.E. a, b ≥ 0 voraus. Es sei l die Anzahl der Schritte, die
der Erweiterte Euklidische Algorithmus bei Eingabe a und b benötigt, bis er sl ,tl , rl ausgibt
mit rl = ggT(a, b) und rl = sl · a + tl · b. Dann erhalten wir in der Notation von 1.15
ri−1 = qi · ri + ri+1 ≥ ri + ri+1 > 2 · ri+1 ,
da die Folge der Reste eine streng monoton fallende Folge nichtnegativer ganzer Zahlen bildet. Also folgt
l−1
l−1
∏ ri−1 > 2l−2 · ∏ ri+1 .
i=2
i=2
1.5. BERECHNUNG MODULARER INVERSER
9
Mit Hilfe dieser Abschätzung gewinnen wir aber eine Abschätzung für die Anzahl l der vom
Erweiterten Euklidischen Algorithmus benötigten Schritte:
2l−2 <
r12
r1 · r2
∏l−1
i=2 ri−1
=
<
=⇒ 2l < 2 · r12
r
·
r
2
r
l−1
l
∏l−1
i=2 i+1
Anwendung von log2 auf die letzte Ungleichung liefert l < log2 (2·r12 ) = 1+2·log2 r1 . Wegen
r1 = b ≤ a ergibt sich das zentrale Resultat l ≤ 1 + 2 · log2 a und somit l ∈ O(log2 a) = O(n).
Den wesentlichen Aufwand in 1.15 machen die Multiplikationen in Schritt (2) aus. Der Aufwand zur Berechnung von ri+1 = ri−1 − qi · ri ist also im wesentlichen durch log2 qi · log2 ri
gegeben. Der Gesamtaufwand zur Berechnung aller solcher Werte beläuft sich damit im wesentlichen auf
l
l
∑ log2 qi · log2 ri ≤ ∑ log2 qi · log2 a
i=1
i=1
l
= log2 a · ∑ log2 qi
i=1
l
= log2 a · log2 ∏ qi
i=1
∈ log2 a · O(log2 a)
∈ O((log2 a)2 ) = O(n2 )
b
a
und |ti | ≤ ri−1
. Es folgt |si | ≤ a und |ti | ≤ a falls
Man kann zeigen, dass stets gilt |si | ≤ ri−1
a > 0 mit a > b. Da für die Werte si und ti also ähnliche Abschätzungen gelten ergibt sich
damit eine Gesamtlaufzeit von O(n2 ), denn wir können uns in der obigen Abschätzung für ri
einfach si oder auch ti denken.
Analoge Betrachtungen liefern im Fall des Erweiterten Euklidischen Algorithmus für Polynome:
Theorem 1.18. Seien F ein Körper und f , g ∈ F[x] Polynome mit deg f = n, deg g = m sowie
n ≥ m. Dann benötigt der Erweiterte Euklidische Algorithmus bei Eingabe f und g O(n2 )
Additionen und Multiplikationen in F.
Beweis. Siehe [8], Seite 38, Theorem 2.21.
1.5
Berechnung modularer Inverser
Restklassenringe ganzer Zahlen sind für uns die algebraische Struktur, in der wir später in
kryptographischen Verfahren rechnen wollen. Grundlegend ist die folgende Definition.
10
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
Bemerkung und Definition 1.19. Sei N ∈ N, N ≥ 2. Auf dem Ring der ganzen Zahlen Z
definieren wir die Relation ∼N vermöge
a ∼N b :⇐⇒ N | a − b.
Die Relation ∼N ist eine Äquivalenzrelation, so dass wir die Äquivalenzklassen nach ∼N
betrachten können. Die Klasse von a ∈ Z modulo N definieren wir als
a mod N := [a]N := {b ∈ Z | b ∼N a}.
Als Repräsentanten für a mod N wählen wir immer die kleinste nicht-negative ganze Zahl z
mit 0 ≤ z ≤ N −1 aus der Menge {b ∈ Z : N | (b−a)}. Die Menge der Äquivalenzklassen nach
der Äquivalenzrelation ∼N bezeichnen wir mit ZN . Wir definieren für a1 mod N, a2 mod N ∈
ZN eine Addition und eine Multiplikation wie folgt:
a1 mod N + a2 mod N = (a1 + a2 ) mod N,
a1 mod N · a2 mod N = (a1 · a2 ) mod N.
Mit der so definierten Addition und Multiplikation wird ZN zu einem kommutativen Ring
mit Nullelement 0 mod N und Einselement 1 mod N, der als Restklassenring von Z modulo N
bezeichnet wird. ZN hat N Elemente. Ein bezüglich der Multiplikation invertierbares Element
a mod N bezeichnen wir als Einheit modulo N. Die Menge aller Einheiten von ZN wird mit
Z×
N bezeichnet.
Beispiel 1.20. Sei N = 6. Dann besteht ZN = Z6 aus den Restklassen 0 mod 6, 1 mod 6,
2 mod 6, 3 mod 6, 4 mod 6 und 5 mod 6. Es gilt:
2 mod 6 + 3 mod 6 = (2 + 3) mod 6 = 5 mod 6,
4 mod 6 + 5 mod 6 = (4 + 5) mod 6 = 9 mod 6 = 3 mod 6,
2 mod 6 · 2 mod 6 = (2 · 2) mod 6 = 4 mod 6,
2 mod 6 · 3 mod 6 = (2 · 3) mod 6 = 6 mod 6 = 0 mod 6,
5 mod 6 · 5 mod 6 = (5 · 5) mod 6 = 25 mod 6 = 1 mod 6.
Wir wollen uns nun ein wenig genauer mit dem Ring ZN = {k mod N | k ∈ {0, . . . , N − 1}} für
ein N ∈ N beschäftigen. Unter anderem im Rahmen des RSA Verfahrens 4.1 sind wir an den
Einheiten Z×
N modulo einer Zahl N interessiert. Es gilt:
Lemma 1.21. Für N ∈ N gilt Z×
N = {k mod N | ggT(k, N) = 1}. Mit anderen Worten erhalten
wir:
k ist invertierbar modulo N genau dann, wenn ggT(k, N) = 1.
1.5. BERECHNUNG MODULARER INVERSER
11
×
Beweis. Es sei r ∈ Z×
N . Dann gibt es ein l ∈ ZN mit r · l ≡ 1 mod N, d.h. r · l = m · N + 1 für
ein m ∈ N. Folglich ist r · l − m · N = 1 und ggT(r, N) | 1. Es folgt ggT(r, N) = 1. Umgekehrt
liefert für r mod N ∈ {k mod N | ggT(k, N) = 1} der Erweiterte Euklidische Algorithmus 1.15
die Darstellung 1 = s · r + t · N mit s,t ∈ Z. Reduktion modulo N liefert s mod N als Inverses
von r mod N.
Bevor wir den Algorithmus explizit angeben, betrachten wir noch ein kleines Beispiel:
Beispiel 1.22. Gesucht sei das modulare Inverse von 23 mod 110. Der Erweiterte Euklidische
Algorithmus 1.15 liefert uns die Darstellung
1 = −43 · 23 + 9 · 110.
Reduktion modulo 110 liefert also
1 mod 110 ≡ (−43 mod 110) · (23 mod 110) + (9 mod 110) · (110 mod 110)
{z
}
|
=0 mod 110
≡ (−43 mod 110) · (23 mod 110)
≡ (67 mod 110) · (23 mod 110),
also gilt (23 mod 110)−1 ≡ (67 mod 110).
Der Beweis des obigen Lemmas ist konstruktiv und liefert uns unmittelbar den folgenden Algorithmus zur Berechnung modularer Inverser. In Wirklichkeit ist der folgende Algorithmus
ein wenig allgemeiner formuliert. Als Eingabe werden k, N ∈ N erwartet. Ausgabe ist dann
entweder das modulare Inverse von k modulo N, falls k invertierbar modulo N ist, oder “k ist
nicht invertierbar modulo N”.
Algorithmus 1.23. (Berechnung des modularen Inversen) Sei N ∈ N und k ∈ ZN .
(1) Berechne mit Hilfe des Erweiterten Euklidischen Algorithmus 1.15 die Darstellung
g = ggT(k, N) = s · k + t · N.
(2) Ist g = 1, so gebe s mod N aus. Andernfalls gebe “k ist nicht invertierbar modulo N”
aus.
Die Korrektheit des Algorithmus folgt aus Lemma 1.21. Setzen wir k ≤ N voraus, so folgt
nach Theorem 1.17, dass das modulare Inverse von k mod N mit O(n2 ) Bit-Operationen berechnet werden kann, wobei n = blog2 Nc + 1. Damit erhalten wir die folgenden Laufzeiten
für modulare Arithmetik:
Korollar 1.24. Sei N ∈ N und n := blog2 Nc + 1 die Bit-Länge der Zahl N. Die Summe zweier Elemente aus ZN läßt sich mit O(n) Bit-Operationen berechnen. Für die Multiplikation
zweier Elemente (nach der klassischen Methode) erhalten wir eine Laufzeit von O(n2 ) Bit2
Operationen. Berechnung des Inversen eines Elementes aus Z×
N ist mit O(n ) Bit-Operationen
durchführbar. Ferner hat Algorithmus 1.5 zum effizienten Potenzieren eine Laufzeit von O(n3 )
(wenn man zur Multiplikation die klassische Methode verwendet und voraussetzt, dass der
Exponent ≤ N ist).
12
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
Beweis. Die Aussagen über die Laufzeit von Multiplikation und Division sind klar. Nicht
so offensichtlich ist die Tatsache, dass die Summe zweier Elemente k mod N und l mod N
tatsächlich nur lineare Laufzeit benötigt, denn wir berechnen zunächst k + l (was sicherlich
nur Zeit O(n) benötigt) und müssen anschließend k + l unter Umständen modulo N reduzieren. Zur Reduktion von k + l modulo N müssen wir aber nicht wirklich Division mit Rest
ausführen, denn es gilt k + l < 2 · N. Ist also k + l > N, so wählen wir schlicht k + l − N
als Repräsentanten von k + l mod N. Dies erfordert nur eine weitere Addition. Die Aussage
über die Laufzeit von Algorithmus 1.5 zum effizienten Potenzieren ergibt sich wie folgt: Zur
Berechnung von xk mod N können wir (wie wir später sehen werden) ohne Einschränkung
0 ≤ k ≤ N voraussetzen. Damit hat k höchstens eine so große Binärlänge wie die Zahl N
selbst. Algorithmus 1.5 führt nun O(log2 k) = O(log2 N) = O(n) Schleifendurchläufe durch.
In jedem Schleifendurchlauf werden entweder eine oder zwei Multiplikationen ausgeführt,
die jeweils nach der klassischen Methode eine Laufzeit von O(n2 ) haben. Insgesamt ergibt
sich damit die behauptete Laufzeit.
Als weitere Folgerung aus den bisherigen Ergebnissen erhalten wir:
Korollar 1.25. Der Ring ZN ist ein Körper genau dann, wenn N eine Primzahl ist.
Später widmen wir uns auch der Frage, wie groß die Wahrscheinlichkeit ist, dass zwei zufällig
gewählte Zahlen k, l ∈R {0, . . . , N} teilerfremd sind. Es gilt im wesentlichen:
6
ln N
#{1 ≤ x, y ≤ N | ggT(x, y) = 1}
ln N
∈ 2 +O
≈ 0.6079271016 + O
N2
π
N
N
Wir kommen auf diese Aussage in Abschnitt 1.7.1 auf Seite 15 zurück.
1.6
Der Chinesische Restsatz
Wir betrachten wieder den Ring ZN . Ist N = pe11 · . . . · per r die Zerlegung von N in paarweise teilerfremde Primpotenzen, so ist es unser Ziel zu beweisen, dass ZN isomorph zu
Z pe1 × . . . × Z per r ist. Eine solche Zerlegung von ZN ist nützlich, da man Berechnungen mo1
dulo N auf Berechnungen modulo der teilerfremden Primpotenzen von N reduzieren kann. In
Wirklichkeit gilt der Chinesische Restsatz sogar allgemeiner. Man muss nur verlangen, dass
N in paarweise teilerfremde Faktoren zerfällt und kann entsprechende Berechnungen dann
auf Berechnungen modulo dieser paarweise teilerfemden Faktoren reduzieren. Bevor wir den
Chinesischen Restsatz jedoch beweisen können, zunächst ein vorbereitendes Lemma:
Lemma 1.26. Seien m, n ∈ N mit n > m. Gilt m | n, so ist die Abbildung f : Zn → Zm ,
k mod n 7→ k mod m ein Ringhomomorphismus.
Beweis. Es gelte m | n. Dann folgt unmittelbar f (0 mod n) = 0 mod m und f (1 mod n) =
1 mod m. Wir müssen zeigen, dass für a, b ∈ {0, . . . , n − 1} die Bedingungen f (a + b) =
f (a) + f (b) und f (a · b) = f (a) · f (b) gelten. Wir zeigen nur die erste Gleichung. Die
1.6. DER CHINESISCHE RESTSATZ
13
zweite folgt ganz analog. Es gilt f (a + b) = ((a + b) mod n) mod m und f (a) + f (b) =
(a mod m + b mod m) mod m. Setze r := (a + b) mod n, s := a mod m und t := b mod m. Dann
müssen wir zeigen, dass gilt: r ≡ s + t mod m. Schreibe a + b = q1 · n + r, a = q2 · m + s und
b = q3 ·m+t. Dann gilt: r −s−t = a+b−q1 ·n−a+q2 ·m−b+q3 ·m = −q1 ·n+(q2 +q3 )·m.
Wegen m | n und m | m folgt m | r − s − t, also r ≡ s + t mod m.
Theorem 1.27. (Chinesischer Restsatz) Sei N ∈ N und N = q1 · . . . · qr die Zerlegung in
paarweise teilerfremde Faktoren q1 , . . . , qr . Dann gilt: ZN ∼
= Zq1 × . . . × Zqr . Mit anderen
Worten: Zu a1 , . . . , ar ∈ Z existiert stets ein x ∈ Z mit x ≡ ai mod qi für i = 1, . . . , r und jedes
solche x ist modulo N eindeutig bestimmt.
Beweis. Mit Hilfe von Lemma 1.26 folgt, dass x mod N 7→ (x mod q1 , . . . , x mod qr ) ein Homomorphismus ist (“komponentenweise” Anwendung von 1.26 liefert hier die Behauptung).
Dass diese Abbildung tatsächlich ein Isomorphismus ist, folgt, wenn wir die Behauptung
über die Kongruenzen des Theorems nachweisen. Setze zunächst li := ∏ j6=i q j . Dann gilt li
mod q j = 0 für alle j 6= i und li ist invertierbar modulo qi , da q1 , . . . , qr als paarweise teilerfremd vorausgesetzt sind. Sei ki := li−1 mod qi . Dann folgt ki · li = 0 mod q j für alle j 6= i und
ki · li = 1 mod qi . Setze nun x := ∑ri=1 ai · ki · li . Dann folgt x mod q j = ∑ri=1 ai · ki · li mod q j =
a j · k j · l j mod q j = a j mod q j . Damit erfüllt also der gewählte Wert x die gewünschten Kongruenzen. Zur Eindeutigkeit modulo N sei x0 mit x0 ≡ ai mod qi für i = 1, . . . , r. Dann gilt
x ≡ x0 mod qi für i = 1, . . . , r. Mit anderen Worten: qi | x − x0 für i = 1, . . . , r. Da q1 , . . . , qr
paarweise teilerfremd sind, folgt N | x − x0 , also die Behauptung.
Der Beweis des Chinesischen Restsatzes liefert den folgenden effizienten Algorithmus.
Algorithmus 1.28. (“Chinese Remaindering”) Seien q1 , . . . , qr ∈ N paarweise teilerfremd
und a1 , . . . , ar ∈ Z. Dann können wir wie folgt eine Lösung der Gleichungen x ≡ ai mod qi für
i = 1, . . . , r bestimmen:
(1) Berechne li := ∏ j6=i q j für i = 1, . . . , r.
(2) Berechne ki := li−1 mod qi für i = 1, . . . , r.
(3) Gebe x = ∑ri=1 ai · ki · li mod ∏rj=1 q j aus.
Die Korrektheit des Algorithmus folgt sofort aus dem Beweis des Chinesischen Restsatzes
1.27. Für die Laufzeit des Algorithmus erhalten wir:
Korollar 1.29. In der Notation von 1.28 sei N = q1 · . . . · qr und n = blog2 Nc + 1 die
Binärlänge der Zahl N. Dann kann x mit O(r · n2 ) Bit-Operationen berechnet werden.
Beweis. Die Berechnung des Wertes l1 = ∏ j6=1 q j = q2 · q3 · . . . · qr benötigt im wesentlichen
Zeit log2 N · ∑ri=3 log2 qi = log2 N ·log2 ∏ri=3 qi ∈ O(log2 N ·log2 N) = O(n2 ) Operationen. Die
Berechnung der Werte l2 , . . . , lr benötigt dann nur noch jeweils ein weitere Multiplikation und
eine Division. Damit beläuft sich der Gesamtaufwand für Schritt (1) auf O(r · n2 ). Die Berechnung von ki als Inverses von li modulo qi benötigt nach Korollar 1.24 etwa (log2 qi )2
14
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
Bit-Operationen. Die Berechnung aller Inverser ki für i = 1, . . . , r benötigt daher im wesentlichen Laufzeit ∑ri=1 (log2 qi )2 ≤ (∑ri=1 log2 qi )2 = (log2 ∏ri=1 qi )2 = (log2 N)2 ∈ O(n2 ). Analoge Schlüsse zeigen, dass auch die Berechnungen in Schritt (3) diese Laufzeit nicht überschreiten, weshalb sich insgesamt die Behauptung ergibt.
Eine nützliche Folgerung aus dem Chinesischen Restsatz 1.27 ist die folgende:
Korollar 1.30. Sei N ∈ N und N = q1 · . . . · qr die Zerlegung in paarweise teilerfremde Fak×
∼ ×
toren q1 , . . . , qr . Dann gilt auch Z×
N = Zq1 × . . . × Zqr .
Die Behauptung folgt mit der Beobachtung, dass eine Zahl x genau dann teilerfremd zu N =
q1 · . . . · qr ist, wenn sie zu jedem der paarweise teilerfremden Faktoren q1 , . . . , qr teilerfremd
ist.
1.7
Die Eulersche ϕ-Funktion und einige ihrer Eigenschaften
Wir wollen in diesem Abschnitt die Eulersche ϕ-Funktion einführen und einige der Eigenschaften dieser Funktion beweisen, die für uns im kryptographischen Anwednungskontext
von Nutzen sein werden.
Definition 1.31. Sei N ∈ N. Dann ist die Eulersche ϕ-Funktion definiert durch
ϕ(N) := #{1 ≤ x ≤ N | ggT(x, N) = 1}.
Lemma 1.32. Für jede Primzahl p ∈ N gilt: ϕ(p) = p − 1.
Beweis. Es gilt {1 ≤ x ≤ p | ggT(x, p) = 1} = {1, . . . , p − 1}. Dies zeigt die Behauptung.
Lemma 1.33. Sei p ∈ N eine Primzahl und e ∈ N. Dann gilt: ϕ(pe ) = (p − 1) · pe−1 .
Beweis. In der Menge {1, . . . , pe } sind genau pe−1 Zahlen Vielfache von p. Folglich gilt
ϕ(pe ) = pe − pe−1 = (p − 1) · pe−1 .
Satz 1.34. Sei N = pe11 · . . . · per r die Zerlegung von N in paarweise teilerfremde Primpotenzen.
Dann gilt:
ϕ(N) = (p1 − 1) · pe11 −1 · . . . · (pr − 1) · per r −1
Beweis. Nach Lemma 1.33 gilt: ϕ(pei i ) = (pi − 1) · pei i −1 für 1 ≤ i ≤ r. Da die zu N teilerfremden Elemente aus {1, . . . , N} gerade den invertierbaren Elementen modulo N entspre×
∼ ×
chen, liefert uns der Chinesische Restsatz wegen Z×
N = Z pe1 × . . . × Z per r die Behauptung,
ei
×
r
r
denn ϕ(N) = #Z×
N = ∏i=1 #Z pei = ∏i=1 ϕ(pi ).
1
i
Wir erhalten nun auch eine Formel für die Wahrscheinlichkeit, dass eine zufällig aus
{1, . . . , N} gewählte Zahl teilerfremd zu N (d.h. modulo N invertierbar):
1.7. DIE EULERSCHE ϕ-FUNKTION
15
Satz 1.35. Sei N ∈ N. Dann gilt für x ∈R {1, . . . , N}:
P(ggT(x, N) = 1) =
∏
p|N
p prim
1
1−
.
p
Beweis. Sei N = ∏ri=1 pei i die Zerlegung von N in paarweise teilerfremde Primpotenzen.
Dann gilt nach Satz 1.34 gerade ϕ(N) = ∏ri=1 (pi − 1) · piei −1 . Es folgt:
ϕ(N)
N
e −1
∏ri=1 (pi − 1) · pi i
=
e
∏ri=1 pi i
P(ggT(x, N) = 1) =
r
= ∏(pi − 1) · p−1
i
i=1
r = ∏ 1−
i=1
1
pi
also die Behauptung.
Satz 1.35 gibt einen exakten Wert für die Wahrscheinlichkeit an, dass ein zufällig gewähltes
x mod N ein Element von Z×
N ist. Ist N also eine Zahl mit großen Primteilern p, so sind die
Faktoren 1 − 1p sehr nah bei dem Wert 1. Die Chance durch zufällige Wahl eines Elementes
x mod N eine Einheit zu erhalten, ist also sehr groß. Der folgende Satz findet sich z.B. in [10]
und macht eine stärkere Aussage:
Satz 1.36. (Durchschnittliche Ordnung von ϕ(n)) Die durchschnittliche Größenordnung
von ϕ(n) für ein n ∈ N ist 6·n
. Die Wahrscheinlichkeit, dass zwei zufällig gewählte Zahlen
π2
≤ n teilerfremd sind, ist damit näherungsweise π62 .
Der folgende Abschnitt ist dem Beweis dieses Resultates gewidmet.
1.7.1
Die durchschnittliche Ordnung von ϕ(n)
Ziel dieses Abschnitts soll der Beweis der Aussage
1
n
n
ϕ(k)
∑ k
k=1
=
6
+O
π2
log n
n
(1.7.1)
sein. Daraus folgt dann die Aussage von Satz 1.36.
Diese Aussage ist u.a. im Kontext des RSA-Verfahrens von Bedeutung, denn sie liefert eine Abschätzung für die Wahrscheinlichkeit, dass man durch zufällige Wahl aus der Menge
{1, 2, . . . , n − 1} eine Einheit modulo n, also ein Element von Z×
n , findet. Für großes n besagt
2
(1.7.1), dass diese Wahrscheinlichkeit π6 ≈ 60.79% beträgt.
Man kann also guten Gewissens zum Auffinden von Einheiten modulo n wie folgt vorgehen:
16
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
Algorithmus 1.37. (Finden von Einheiten in Zn ) Gegeben n ∈ N.
(1) Wähle e ∈ {1, 2, . . . , n − 1} zufällig.
(2) Wende den Euklidischen Algorithmus zur Berechnung von g := ggT(e, n) an.
– Ist g = 1, so gebe e aus.
– Ist g > 1, so gehe zurück zu Schritt (1).
Mit e ist im letzten Schritt des Algorithmus eine Einheit modulo n gefunden. Der zufälligen
Wahl in Schritt (1) liegt also erwartungsgemäß eine Trefferwahrscheinlichkeit von etwa 60%
zugrunde, d.h. der Algorithmus liefert erwartungsgemäß bereits nach 2 Durchläufen ein Ergebnis. Da der Euklidische Algorithmus effizient ist (Laufzeit im wesentlichen O(log2 n)),
kann auch Schritt (2) bedenkenlos mehrfach hintereinander ausgeführt werden.
Zum Beweis von (1.7.1) sind einige Vorbereitungen zu treffen. Einen Eindruck von den zu
erbringen Vorleistungen erhalten wir, wenn wir die rechte Seite von (1.7.1) wie folgt “verkomplifizieren”:
6
+O
π2
log n
n
=
1
1
∑∞
n=1 2
| {z n }
log n
n
log n
.
n
+O
Euler’s
Basel Problem
=
1
+O
ζ (2)
| {z }
Riemann’sche
ζ -Funktion
Es gibt also Zusammehänge zwischen (1.7.1), der Riemann’schen ζ -Funktion sowie Euler’s
Basel Problem.
Wir beginnen mit den grundlegenden Definitionen, die im Rahmen des Bweises vom (1.7.1)
von Relevanz sind.
Definition 1.38. (Möbius Funktion, Riemannsche ζ -Funktion) Es seien n ∈ N und s ∈ R,
s > 1.
(i) Die Möbius Funktion µ


1
µ(n) := (−1)r


0
ist definiert durch
falls n = 1,
falls n quadratfrei mit r verschiedenen Primfaktoren ist,
falls n nicht quadratfrei ist.
(ii) Die Riemannsche ζ -Funktion ist für s ∈ R, s > 1 definiert durch
∞
ζ (s) :=
1
∑ ns .
n=1
1.7. DIE EULERSCHE ϕ-FUNKTION
17
Zwischen der Möbius-Funktion und der Riemann’schen ζ -Funktion gibt es folgenden — für
uns später relevanten — Zusammenhang:
Lemma 1.39. (Darstellungen für ζ (s) und
1
)
ζ (s)
Sei s ∈ R, s > 1. Dann gilt:
(i) Bezeichnet pk für jedes k ∈ N die k-te Primzahl, so gilt:
∞
1
,
1
k=1 1 − ps
ζ (s) = ∏
k
(ii) Einen Zusammenhang zwischen Möbius-Funktion und der Riemann’schen ζ -Funktion
liefert:
∞
1
µ(n)
=∑ s .
ζ (s) n=1 n
Beweis. (i) Mit Hilfe geometrischer Reihenentwicklung gilt:
∞
1
∏ 1− 1
k=1
psk
1
1
1
···
1
1
1 − ps 1 − ps 1 − p1s
1
2
3
k ! ∞ k ! ∞ k !
∞ 1
1
1
=
···
∑ ps
∑ ps
∑ ps
1
2
3
k=0
k=0
k=0
1
1
1
1
1
1
=
1 + s + 2s + 3s + · · ·
1 + s + 2s + 3s + · · · · · ·
p1 p1
p2 p2
p1
p2
1
1
1
= 1+ ∑ s + ∑ s s + ∑
s · ps · ps + . . .
p
p
·
p
p
j
j
k
i>0 i
j>i>0 i
k> j>i>0 i
=
= 1+
∞
1
1
1
1
+
+
+
.
.
.
=
= ζ (s).
∑
s
s
s
s
2
3
4
n=1 n
(ii) Wir verwenden direkt die unter (i) bewiesene Darstellung für ζ (s). Dies liefert:
∞ 1
1
(i)
= ∏ 1− s
ζ (s)
pl
l=1
1
1
1
1
1
= 1−
+ +... +
+...+ s s + s s +... −...
ps1 ps2
ps1 · ps2
p1 · p3 p2 · p3
1
1
1
= 1− ∑ s + ∑ s s − ∑
s
s
s +...
i>0 pi
j>i>0 pi · p j
k> j>i>0 pi · p j · pk
µ(pi · p j )
µ(pi · p j · pk )
µ(pi )
s + ∑
s · ps + ∑
s
s
s +...
p
p
i
i
j
i>0
j>i>0
k> j>i>0 pi · p j · pk
= 1+ ∑
∞
=
µ(n)
.
s
n=1 n
∑
18
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
Ferner benötigen wir das folgende als Basel Problem bekanntes und erstmals von Leonard
Euler gelöste Resultat:
1
Lemma 1.40. (Basel Problem) Der Grenzwert limm→∞ ∑m
n=1 n2 existiert und es gilt
1
∑∞
n=1 n2 =
π2
6 .
Mit anderen Worten: ζ (2) =
π2
6 .
Auf einen strikt formalen Beweis verzichten wir und geben stattdessen die intuitve Herleitung
des Resultats an so wie sie schon von Euler durchgeführt wurde:
Beweis. Die Taylorentwicklung der Sinus-Funktion liefert
x2 x4 x6
sin(x)
= 1− + − +··· .
x
3! 5! 7!
Alle Nullstellen von sin(x)
x sind gegeben durch x = l · π für l = ±1, ±2, ±3, . . .. Schreiben wir
sin(x)
also formal x als Produkt von Linearfaktoren wie im endlichen Fall bei Polynomen üblich,
so erhalten wir
sin(x)
x
x
x
x
1+
2−
2+
···
=
1−
x
π
π
π
π
x2
x2
=
1− 2
1− 2 ···
π
4π
Die Koeffizienten von x2 sind also gegeben durch
−
1
1
1
1 ∞ 1
−
−
−
·
·
·
=
−
∑ n2 .
π2 4 π2 9 π2
π 2 n=1
Der Koeffizient von x2 in der Taylorreihentwicklung von
1
π2
∑∞
n=1 n2 = 6 .
sin(x)
x
ist − 3!1 . Gleichsetzen ergibt
Mit den oben zusammengefassten Definitionen und Resultaten können wir nun den folgenden
Satz beweisen:
Satz 1.41. (Durchschnittliche Ordnung von ϕ(n)) Die durchschnittliche Ordnung von ϕ(n)
ist gegeben durch
6
1 n ϕ(k)
log n
∑ k = π2 + O n .
n k=1
Beweis. Der Beweis wird in 4 Schritten geführt.
Schritt 1. Zeige, dass gilt:
n
ϕ(k)
∑ k
k=1
n
=
µ(k) j n k
.
∑
k
k=1 k
(1.7.2)
1.7. DIE EULERSCHE ϕ-FUNKTION
19
Beweis per Induktion. Für n = 1 gilt
ϕ(1)
µ(1)
=1=
b1c.
1
1
Für den Induktionsschritt gelte (1.7.2). Wir zeigen:
j k
n
ϕ(n + 1)
n+1
µ(k)
n
µ(n + 1)
= ∑
−
+
,
n+1
k
k
n+1
k=1 k
(1.7.3)
wobei die Induktionsvoraussetzung (1.7.2) bereits in die rechte Seite eingegangen ist.
Wegen
j k (
1 falls k | (n + 1),
n+1
n
−
=
k
k
0 sonst,
folgt, dass die rechte Seite von (1.7.3) gegeben ist durch
∑
k|(n+1)
k<n+1
µ(k)
µ(k) µ(n + 1)
+
= ∑
.
k
n+1
k
k|(n+1)
Es bleibt also zu zeigen, dass
µ(k) ϕ(n + 1)
=
.
k
n+1
k|(n+1)
∑
Sei dazu n + 1 = pe11 · . . . · per r mit paarweise verschiedenen Primzahlen p1 , . . . , pr und
e1 , . . . , er ∈ N die Faktorisierung von n + 1. Dann gilt:
ϕ(n + 1)
n+1
(p1 − 1) · pe11 −1 · . . . · (pr − 1) · per r −1
pe11 · . . . · per r
r
1
= ∏ 1−
pl
l=1
1
1
1
1
1
+ +... +
+...+
+
+... −...
= 1−
p1 p2
p1 · p2
p1 · p3 p2 · p3
1
1
1
− ∑
= 1− ∑ + ∑
+...
i>0 pi
j>i>0 pi · p j
k> j>i>0 pi · p j · pk
=
=
µ(k)
.
k
k|(n+1)
∑
Dies zeigt (1.7.2).
Schritt 2. Untere und obere Schranken für
1
n
∑nk=1
ϕ(k)
k
finden. Wegen
n
n
n
−1 ≤ b c ≤
k
k
k
20
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
folgt mit Hilfe von (1.7.2) gerade
1
n
n
µ(k) n
1
−
1
≤
∑ k k
n
k=1
Damit ist eine obere Schranke für
1
n
n
ϕ(k)
1
∑ k ≤n
k=1
∑nk=1
ϕ(k)
k
n
µ(k) n
.
k
k=1 k
∑
gegeben durch
n
µ(k)
.
2
k=1 k
Un :=
∑
Es gilt weiter
1
n
n
µ(k) n
−1
=
k
k=1 k
∑
n
µ(k) 1
−
2
n
k=1 k
∑
= Un −
1
n
n
µ(k)
k=1 k
∑
n
µ(k)
k=1 k
∑
1 n 1
∑k
n k=1
1
> Un − (log(n) + 1),
n
> Un −
wobei im letzten Schritt die Abschätzung
n
1
∑k<
k=1
Z n
1
1
x
dx = ln n <
log n
< log n + 1
log e
verwendet wurde. Damit ist
1
Ln := Un − (log(n) + 1)
n
eine untere Schranke für
1
n
∑nk=1
ϕ(k)
k .
Wir haben also gezeigt:
1 n ϕ(k)
log n
∑ k = Un + O n .
n k=1
Schritt 3. Der Grenzwert limn→∞ Un existiert. Diese Aussage folgt mit Hilfe der Dreiecksungleichung aus
n
n µ(k) 1
|Un | ≤ ∑ 2 ≤ ∑ 2 ,
k
k
k=1
k=1
1
da insbesondere die Konvergenz von ∑∞
k=1 k2 nach Lemma 1.40 sichergestellt ist. Damit
∞ µ(k) 1
ist ∑∞
k=1 k2 konvergente Majorante zu ∑k=1 k2 und aus absoluter Konvergenz folgt
Konvergenz.
1.8. KETTENBRÜCHE
21
Schritt 4. Zeige, dass Un von der Ordnung
lim Un =
n→∞
µ(k)
2
k≥1 k
∑
π2
6
ist. Es gilt:
Lemma 1.39 (ii)
=
1
ζ (2)
Lemma 1.40
=
6
.
π2
Damit ist das Theorem bewiesen.
1.8
Kettenbrüche
Ein bekannter Angriff auf das RSA-Verfahren, wenn der private Schlüssel sehr klein gewählt
wird, basiert auf der sogenannten Kettenbruchentwicklung einer rationalen Zahl. Die Grundlagen zum Verständnis des “Angriffs von Wiener” sollen hier bereitgestellt werden. Die hier
gewählte Darstellung der Theorie ist [2] entnommen (siehe Kapitel 2).
Definition 1.42. Ein Kettenbruch ist ein Ausdruck der Form
1
[a0 , a1 , . . . , an ] = a0 +
1
a1 +
a2 +
1
..
. an−1 +
1
an
mit a0 ∈ Q und a1 , . . . , an ∈ Q \ {0}.
Das folgende Lemma faßt einige offensichtliche Rechenregeln für Kettenbrüche zusammen:
Lemma 1.43. Seien a0 ∈ Q und a1 , . . . , an ∈ Q\{0}. Dann gelten die folgenden Rechenregeln
für Kettenbrüche:
(i) [a0 , a1 , . . . , an−1 , an ] = [a0 , a1 , . . . , an−1 , an − 1, 1]
(ii) [a0 , a1 , . . . , an−1 , an ] = [a0 , a1 , . . . , an−1 + a1n ]
(iii) [a0 , a1 , . . . , an−1 , an ] = a0 +
1
[a1 , . . . , an−1 , an ]
Im folgenden werden wir nur Kettenbrüche betrachten, für die ai ∈ N gilt für alle i = 0, . . . , n.
Auch wenn Lemma 1.43 (i) besagt, dass verschiedene Kettenbrüche die gleiche Zahl darstellen können, so ist diese eine Mehrdeutigkeit auch die einzige Möglichkeit zwei verschiedene
Kettenbrüche für ein- und dieselbe rationale Zahl anzugeben vorausgesetzt alle ai sind natürliche Zahlen. Im folgenden wird diese Mehrdeutigkeit ignoriert.
Die im folgenden Satz über die Existenz einer Kettenbruchentwicklung für rationale Zahlen vorgenommene Einschränkung auf positive rationale Zahlen, ist keine wirkliche Einschränkung. Man muss nur a0 ∈ Z erlauben und es lassen sich auch negative rationale Zahlen
22
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
als Kettenbrüche darstellen (soll die Kettenbruchentwicklung von −q für eine positive rationale Zahl q berechnet werden, so betrachte −dqe + (dqe − q), setze a0 := −dqe und bestimme
die Kettenbruchentwicklung der positiven rationalen Zahl dqe − q).
m0
Satz 1.44. Jede positive rationale Zahl m
besitzt eine Kettenbruchentwicklung, d.h. es gibt
1
0
Elemente a0 , . . . , an ∈ N mit [a0 , . . . , an ] = m
m1 .
Der Beweis ist konstruktiv und liefert uns zugleich einen Algorithmus zur Berechnung der
Kettenbruchentwicklung einer positiven rationalen Zahl mit Hilfe des Euklidischen Algorithmus 1.15. Wir benötigen in diesem Fall allerdings nicht einmal die Werte si und ti die in 1.15
automatisch mitberechnet werden. Sie müssen für die Korrektheit des folgenden Algorithmus
nicht mitberechnet werden.
Algorithmus 1.45. (Kettenbruchentwicklung einer rationalen Zahl) Sei
rationale Zahl.
m0
m1
eine positive
(1) Wende den Euklidischen Algorithmus 1.15 auf die Eingabe a = m0 und b = m1 an.
(2) In der Notation von 1.15 wähle a0 , . . . , an als Folge der auftretenden (nichtnegativen
ganzzahligen) Quotienten q1 , . . . , qn , qn+1 .
(3) Gebe [a0 , . . . , an ] aus.
Beweis. (Korrektheit) Der Euklidische Algorithmus liefert uns mit ai := qi+1 die Darstellungen
m0 = a0 · m1 + m2
0 < m2 < m1 , a0 ≥ 0
m1 = a1 · m2 + m3
..
..
.
.
0 < m3 < m2 , a1 > 0
..
.
mi−1 = ai−1 · mi + mi+1
..
..
.
.
0 < mi+1 < mi , ai−1 > 0
..
.
mn = an · mn+1
an > 0
Wir führen den Korrektheitsbeweis per Induktion über n (Anzahl der vom Euklidischen Algorithmus benötigten Schritte). Ist n = 1, so gilt m0 = a0 · m1 + m2 und m1 = a1 · m2 . Damit
erhalten wir
m0 − m2
1
1
m0 − m2 m2 m0
+ m1 =
+
=
,
a0 + =
a1
m1
m1
m1 m1
m2
also die Behauptung. Wegen m0 = a0 · m1 + m2 folgt
m0
m2
1
1
= a0 +
= a0 + m1 = a0 +
= [a0 , a1 , . . . , an ],
m1
m1
[a1 , . . . , an ]
m2
wobei wir bei der letzten Identität die Induktionsvoraussetzung auf
m1
m2
anwenden konnten.
1.8. KETTENBRÜCHE
23
Mit Hilfe der Laufzeitabschätzung für den Erweiterten Euklidischen Algorithmus in Theorem
1.17 folgt sofort:
0
Korollar 1.46. Ist m
m1 eine positive rationale Zahl, so berechnet Algorithmus 1.45 mit eim0
, wobei n das
nem Aufwand von O(n2 ) Bit-Operationen die Kettenbruchentwicklung von m
1
Maximum der Binärlängen von m0 und m1 ist.
Definition 1.47. Sei [a0 , . . . , an ] die Kettenbruchentwicklung der positiven rationalen Zahl
pl
m0
m1 . Dann heißen die rationalen Zahlen ql = [a0 , . . . , al ], l = 0, . . . , n die Konvergenten der
0
Kettenbruchentwicklung von m
m1 .
Für die Konvergenten der Kettenbruchentwicklung einer positiven rationalen Zahl können wir
die folgenden Rekursionsformeln angeben, die ihre Berechnung effizient möglich machen:
Lemma 1.48. Für die Konvergenten
0
lung von m
m1 gelten:
pl
ql
= [a0 , . . . , al ], l = 0, . . . , n einer Kettenbruchentwick-
p0 = a0
q0 = 1
p1 = 1 + a1 · p0
q1 = a1
pl = pl−2 + al · pl−1
ql = ql−2 + al · ql−1 ,
l ≥ 2.
Beweis. Wir führen den Beweis per Induktion nach l. Für l = 0 und l = 1 rechnen wir die
Formeln explizit nach. Für l = 0 erhalten wir qp00 = [a0 ] = a0 , also p0 = a0 und q0 = 1. Für
l = 1 gilt qp11 = [a0 , a1 ] = a0 + a11 = a1 ·aa01+1 , also p1 = a1 · a0 + 1 = a1 · p0 + 1 sowie q1 = a1 .
1
l+1
= [a0 , . . . , al , al+1 ] = [a0 , . . . , al + al+1
]. Nach InduktionsvorNach Lemma 1.43 (ii) gilt qpl+1
aussetzung erhalten wir
1
a
+
l
al+1 · pl−1 + pl−2
1
a0 , . . . , al +
= .
al+1
a + 1 ·q +q
l
al+1
l−1
l−2
Damit folgt dann:
pl+1
1
= [a0 , . . . , al , al+1 ] = a0 , . . . , al +
ql+1
al+1
=pl
z
1
al + al+1 · pl−1 + pl−2 a · (a · p }|+ p {) + p
l+1
l
l−1
l−2
l−1
= =
1
a
·
(a
·
q
+
q
)
+
q
l+1
l−1
al + al+1 · ql−1 + ql−2
| l l−1
{z l−2}
=ql
=
al+1 · pl + pl−1
al+1 · ql + ql−1
Das folgende Lemma geben wir ohne Beweis an:
24
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
Lemma 1.49. Werden die natürlichen Zahlen pl und ql wie in Lemma 1.48 berechnet, so sind
sie teilerfremd.
Auf dem folgenden Theorem beruht der “Angriff von Wiener” auf RSA für kleine private
Schlüssel. Wir geben ihn hier ohne Beweis an. Ein Beweis findet sich in [6], Lemma 5.7.6,
Seite 275.
Theorem 1.50. Sind
m0
m1
und
p
q
rationale Zahlen mit
m0 p − < 1 ,
m1 q 2 · q2
so ist
1.9
p
q
eine Konvergente der Kettenbruchentwicklung von
m0
m1 .
Einige gruppentheoretische Resultate
Wir wollen in diesem Abschnitt die für uns wichtigsten gruppentheoretischen Resultate zusammenfassen. Zur Erinnerung:
Definition 1.51. Die Anzahl der Elemente einer Gruppe G bezeichnen wir stets mit #G und
nennen #G die Ordnung von G. G heißt eine endliche Gruppe, wenn #G < ∞. Sie heißt zyklisch, wenn es ein z ∈ G mit G = hzi. Dabei bezeichnet hzi die Menge {z j | j ∈ Z} aller
Potenzen von z mit ganzzahligen Exponenten.
Für ein beliebiges x ∈ G ist hxi zumindest stets immer eine Untergruppe von G. Diese Untergruppe ist dann im Sinne der obigen Definition eine zyklische Untergruppe von G. Die
Ordnung eines Elementes x ∈ G, geschrieben ord(x), ist die Ordnung der von x erzeugten
zyklischen Untergruppe hxi von G.
1.9.1
Der Satz von Lagrange
Der Satz von Lagrange macht eine wichtige Aussage über die möglichen Ordnungen von
Untergruppen einer gegebenen endlichen Gruppe.
Theorem 1.52. (Satz von Lagrange) Sei G eine endliche Gruppe. Dann gilt:
(i) Die Ordnung jeder Untergruppe H von G teilt die Ordnung von G, d.h. #H | #G.
(ii) Für jedes Element x ∈ G gilt: x#G = 1.
Dabei bezeichnet 1 in (ii) das neutrale Element bezüglich der Verknüpfung auf G.
Beweis. (i) Betrachte die Nebenklassen xH := {x · y | y ∈ H} ⊆ G von H für ein beliebiges
x ∈ G. Es gilt #(xH) = #H, denn die Abbildung ψ : H → xH, ψ(y) := x · y ist bijektiv, denn ψ
ist sicherlich surjektiv (per Definition von xH) und aus ψ(y) = ψ(z) folgt x·y = x·z, also y = z
1.9. EINIGE GRUPPENTHEORETISCHE RESULTATE
25
und damit die Injektivität von ψ. Sind außerdem x1 , x2 ∈ G, so gilt entweder x1 H = x2 H oder
x1 H ∩x2 H = ∅. Gilt nämlich x1 ·y = x2 ·z ∈ x1 H ∩x2 H, so folgt wegen x1 = x2 ·(z·y−1 ) gerade
x1 ∈ x2 H. Aus x1 ∈ x2 H folgt für jedes x ∈ H gerade x1 · x = x2 · (z · y−1 · x) ∈ x2 H. Dies zeigt
x1 H ⊆ x2 H. Aus Symmetriegründen folgt daraus aber bereits x1 H = x2 H. Insgesamt bilden
damit die Nebenklassen xH eine Partition von G, denn ein Element x ∈ G ist stets in der
Nebenklasse xH enthalten (da H als Untergruppe von G insbesondere das neutrale Element
1 von G enthalten muss) und G läßt sich damit als disjunkte Vereinigung der Nebenklassen
schreiben. Gibt es k solcher verschiedener Nebenklassen, so folgt: #G = k · #H.
(ii) Betrachte H := hxi. Wegen x ∈ H und x ∈ xH folgt nach Teil (i) bereits H = xH. Wir
erhalten also wegen ∏y∈H y = ∏y∈xH y gerade
x#H · ∏ y =
y∈H
∏ x·y = ∏ y
y∈H
=⇒
x#H = 1
y∈H
und da #G ein Vielfaches von #H ist, folgt daraus die Behauptung.
Korollar 1.53. Sei G eine Gruppe und x ∈ G mit hxi ist endlich. Dann gilt:
(i) {i ∈ Z | xi = 1} ist das von ord(x) in Z erzeugte Hauptideal.
(ii) ord(x) = min{i > 0 | xi = 1}
(iii) ord(x) | #G
Beweis. Sei k der kleinste positive Wert mit xk = 1. Ein solches k existiert, da hxi endlich ist.
Sei i ∈ Z. Schreibe i = q · k + r mit 0 ≤ r < k. Dann gilt: xi = xq·k+r = (xk )q · xr = xr . Dies zeigt
hxi ⊆ {1, x, x2 , . . . , xk−1 }. Die umgekehrte Inklusion ist klar, d.h. hxi = {1, x, x2 , . . . , xk−1 }.
Alle Elemente 1, x, x2 , . . . , xk−1 sind verschieden, da aus xi = x j mit i > j sofort xi− j = 1 und
damit ein Widerspruch zur Minimalität von k folgt. Insgesamt erhalten wir also ord(x) =
#hxi = k. Für alle i ∈ Z folgt damit
xi = 1 ⇐⇒ x(i div k)·k+i mod k = 1 ⇐⇒ xi mod k = 1 ⇐⇒ i mod k = 0 ⇐⇒ k | i.
Daraus folgen (i) und (ii). Teil (iii) folgt aus dem Satz von Lagrange 1.52.
1.9.2
Der Satz von Euler und der kleine Satz von Fermat
Wir erinnern uns, dass für N ∈ N der Wert der Eulerschen ϕ-Funktion an der Stelle N gerade die Anzahl der zu N teilerfremden Zahlen aus {1, . . . , N} ist. Die in ZN bezüglich der
Multiplikation invertierbaren Elemente sind genau durch diejenigen Restklassen gegeben, deren Repräsentanten teilerfremd zu N sind. Folglich besteht die Gruppe Z×
N aus genau ϕ(N)
Elementen. Mit anderen Worten:
Lemma 1.54. Für N ∈ N gilt: #Z×
N = ϕ(N).
26
KAPITEL 1. GRUNDLAGEN: (COMPUTER)ALGEBRA
Unmittelbar aus diesem Resultat und dem Satz von Lagrange 1.52 folgt das nächste Theorem,
das auf Leonard Euler zurückgeht:
ϕ(N) = 1.
Theorem 1.55. (Satz von Euler) Für jedes x ∈ Z×
N gilt x
Beweis. Die Behautpung folgt sofort aus #Z×
N = ϕ(N) und dem Satz von Lagrange 1.52 (ii).
Aus dem Satz von Euler wiederum ergibt sich unmittelbar das nächste Resultat:
Theorem 1.56. (Kleiner Satz von Fermat) Sei p eine Primzahl. Dann gilt für alle x ∈
Z p \ {0}: x p−1 = 1.
Beweis. Es ist ϕ(p) = p − 1 nach 1.32. Da p prim ist, gilt Z×
p = Z p \ {0}. Nach dem Satz
ϕ(p)
p−1
von Euler 1.55 erhalten wir daher für alle x 6= 0: 1 = x
=x .
Fassen wir die Resultate von 1.52, 1.55 und 1.56 zusammen, so erhalten wir:
Satz 1.57. Sei G eine endliche Gruppe und x ∈ G. Dann gilt:
(i) ord(x) teilt #G und für jedes Vielfache m von #G gilt xm = 1.
(ii) Sei N ∈ N und x ∈ Z×
N . Dann ist ord(x) ein Teiler von ϕ(N) und für jedes Vielfache m
von ϕ(N) gilt xm = 1.
(iii) Sei p eine Primzahl und x ∈ Z×
p . Dann ist ord(x) ein Teiler von p − 1 und für jedes
m
Vielfache m von p−1 gilt x = 1. Ferner gilt in dieser Situation xm+1 = x. Insbesondere
folgt also x p = x für alle x ∈ Z p .
Äußerst nützlich ist das folgende Korollar, dass es erlaubt von einem Gruppenelement die
Ordnung zu bestimmen:
Korollar 1.58. Sei G eine endliche Gruppe und x ∈ G. Ist n ∈ N mit xn = 1, so gilt ord(x) = n
n
genau dann, wenn x p 6= 1 für alle Primteiler p von n.
n
Beweis. Ist ord(x) = n, so folgt x p 6= 1, da ord(x) nach Korollar 1.53 (ii) die minimale
n
positive Zahl i ist mit xi = 1 und 1 < np < n = ord(x). Umgekehrt gelte xn = 1 und x p 6= 1
für alle Primteiler p von n. Wegen xn = 1 folgt ord(x) | n, also gibt es ein k ∈ N mit n =
k · ord(x). Angenommen k wäre echt größer 1. Dann besitzt k einen Primteiler p, der zugleich
n
k
k
ein Primteiler von n ist und x p = (xord(x) ) p = 1 p = 1. Widerspruch!
Korollar 1.59. Sei G eine Gruppe und x ∈ G sowie a ∈ N. Dann gilt: ord(xa ) =
ord(x)
ggT(ord(x),a) .
Beweis. Es gilt: (xa )ord(x)/ ggT(ord(x),a) = (xord(x) )a/ ggT(ord(x),a) = 1a/ ggT(ord(x),a) = 1. Seien
s,t ∈ Z mit s · a + t · ord(x) = g = ggT(ord(x), a). Sei p ein Primteiler von ord(x)
g . Setze y :=
a
(ord(x)/g)/p
s
s·a/g
ord(x)/p
(g−t·ord(x))/g
(x )
. Wäre y = 1, so folgte aber 1 = y = (x
)
= (x
)ord(x)/p =
2
xord(x)/p · x−t·ord(x) /g·p = xord(x)/p · (xord(x) )−t·ord(x)/g·p = xord(x)/p , was im Widerspruch zur
Aussage des obigen Korollars steht.
Kapitel 2
Grundlagen aus der Zahlentheorie
In diesem Kapitel wollen wir die Grundlagen aus der Zahlentheorie erarbeiten, die im Anwendungskontext elementarer Kryptographie von Interesse sind. Wie auch schon im Kapitel
“Grundlagen aus Algebra und Computeralgebra” werden wir uns auch hier immer wieder für
Algorithmen bzw. ihre Komplexität interessieren. Die wesentlichen hier betrachteten Algorithmen sind einerseits Algorithmen zum Auffinden von Primzahlen und andererseits Algorithmen zur Faktorisierung ganzer Zahlen.
2.1
Finden von Primzahlen und Primzahltest
Folgendes grundlegendes Problem wollen wir uns stellen: Finde einen Algorithmus, der bei
Eingabe eines Intervalls [B, 2 · B − 1] eine Primzahl aus diesem Intervall liefert. Wir werden
keinen deterministischen Algorithmus angeben, sondern lediglich ein Verfahren, das im wesentlichen einfach zufällig eine Zahl aus dem Intervall [B, 2 · B − 1] wählt und anschließend
prüft, ob die gewählte Zahl prim ist. Zunächst müssen wir sicherstellen, dass es “genügend”
Primzahlen in [B, 2 · B − 1] für B 0 gibt. Die notwendige Aussage, die wir benötigen, liefert
der sogenannte Primzahlsatz:
Theorem 2.1. (Primzahlsatz) Sei x ∈ N und es bezeichne π(x) die Anzahl aller Primzahlen
in [0, x]. Dann gilt:
x
π(x) ≈
ln x
bzw. genauer
x
1
x
3
· 1+
≤ π(x) ≤
· 1+
ln x
2 · ln x
ln x
2 · ln x
für x ≥ 59.
Der Primzahlsatz garantiert uns für hinreichend großes B die Existenz von mindestens
vielen Primzahlen im Intervall [B, 2 · B − 1] (siehe [8], Seite 64).
27
B
2·ln B
28
KAPITEL 2. GRUNDLAGEN AUS DER ZAHLENTHEORIE
Wir haben oben bereits erwähnt, dass der Algorithmus zum Auffinden von Primzahlen von
einer zufällig gewählten Zahl testen soll, ob sie prim ist. Ein möglicher Primzahltest ist der
Fermat-Test:
Algorithmus 2.2. (Fermat-Test) Sei M ∈ Z und t ∈ N ein “Konfidenzparameter” (t ist im
wesentlichen nichts anderes als die Anzahl der Runden, die der Algorithmus durchführt).
(1) Setze i := 1.
(2) Solange i ≤ t und die Berechnung nicht abgebrochen wurde, wiederhole die folgenden
Schritte:
(i) Wähle a ∈R ZM \ {0}.
(ii) Berechne g := ggT(a, M). Falls g 6= 1, so breche die Berechnung ab und gebe “M
ist zusammengesetzt” aus.
(iii) Berechne k := aM−1 mod M. Falls k 6≡ 1 mod M, so breche die Berechnung ab und
gebe “M ist zusammengesetzt” aus. Setze i := i + 1.
(3) Gebe “M ist wahrscheinlich prim” aus.
Beweis. (Korrektheit) Ist M prim, so ist jedes a ∈ ZM , a 6= 0 teilerfremd zu M. Ferner gilt
dann stets aM−1 ≡ 1 mod M, denn dies ist gerade die Aussage von Fermat’s Kleinem Satz
1.56. Damit wird der Algorithmus bei Eingabe eine Primzahl stets die Ausgabe “M ist wahrscheinlich prim” liefern.
Wir wollen uns nun über die Situationen Gedanken machen, in denen Algorithmus 2.2 versagt. Dann waren alle Zahlen a teilerfremd zu M und es galt stets aM−1 ≡ 1 mod M.
Definition 2.3. Ist M eine zusammengesetzte Zahl und a ∈ ZM mit aM−1 ≡ 1 mod M, so
heißt a ein Fermat-Lügner (a erfüllt Fermat’s Kleinen Satz 1.56, aber M ist nicht prim). Gilt
dagegen aM−1 6≡ 1 mod M, so heißt a ein Fermat-Zeuge.
Lemma 2.4. Sei M eine zusammengesetzte Zahl und a ∈ Z×
M ein Fermat-Zeuge. Dann besteht
höchstens die Hälfte aller Elemente von Z×
aus
Fermat-Lügnern.
M
Beweis. Die Menge der Fermat-Lügner ist eine Untergruppe von Z×
M . Als Untergruppe muss
ihre Ordnung die Ordnung von Z×
teilen.
Gibt
es
mindestens
einen
Fermat-Zeugen, so kann
M
×
die Anzahl der Fermat-Lügner nicht gleicher der Ordnung von ZM , und damit nur halb so
groß, sein.
Es gilt also: Die Wahrscheinlichkeit dafür, dass eine Zahl M zusammengesetzt ist unter der
Voraussetzung, dass Algorithmus 2.2 die Ausgabe “M ist wahrscheinlich prim” liefert, ist, sofern es für M mindestens einen Fermat-Zeugen gibt, höchstens 12 . Im allgemeinen beläuft sich
die bedingte Wahrscheinlichkeit für einen allgemeinen Wert von t auf höchstens 2−t . Somit ist
die Wahrscheinlichkeit dafür, dass eine Zahl M tatsächlich prim ist unter der Voraussetzung,
dass Algorithmus 2.2 die Ausgabe “M ist wahrscheinlich prim” liefert, mindestens 1 − 2−t .
2.1. FINDEN VON PRIMZAHLEN UND PRIMZAHLTEST
29
Zahlen M, für die es keinen Fermat-Zeugen gibt, heißen Carmichaelzahlen. Es gibt unendlich viele solcher Carmichaelzahlen. Die kleinste Carmichaelzahl ist 561. Würde man also
Algorithmus 2.2 mit Eingabe M = 561 starten, so würde die Ausgabe unabhängig von der
Anzahl der durchgeführten Runden t stets “M ist wahrscheinlich prim” lauten. Zugleich gibt
es aber Modifikationen des Fermat-Tests, die dieses Dilemma beseitigen. Ein möglicher Ersatz für den Fermat-Test ist der sogenannte Miller-Rabin Test. Er basiert auf einer etwas allgemeineren Version des Kleinen Satzes von Fermat 1.56: Sei n eine positive, ungerade ganze
Zahl. Definiere s := max{r ∈ N0 | 2r ist ein Teiler von n − 1} und schreibe n − 1 = d · 2s ,
ggT(d, 2) = 1. Dann ist auch d wieder eine ungerade Zahl und es gilt:
Theorem 2.5. Ist n eine Primzahl und ist a ∈ Z teilerfremd zu n, so gilt ad ≡ 1 mod n oder es
r
gibt es ein r ∈ {0, . . . , s − 1} mit a2 ·d ≡ −1 mod n.
Beweis. Sei a teilerfremd zu n, n eine Primzahl. Es gilt in der Notation von oben #Z×
n =
s
d
d
n − 1 = 2 · d. Betrachte nun a mod n. Gilt ord(a) | d, so folgt a ≡ 1 mod n. Anderenfalls ist
l−1
ord(ad ) eine Zweierpotenz, d.h. ord(ad ) = 2l für ein l ∈ {1, . . . , s}. Es folgt: ord(a2 ·d ) =
d
l
ord(a )
= 22l−1 = 2. Nun können wir den folgenden Hilfssatz verwenden:
ggT(ord(ad ),2l−1 )
Hilfssatz. Ist Fq ein endlicher Körper, so gibt es für jeden Teiler d von
×
q − 1 = #F×
q genau ϕ(d) Elemente in Fq der Ordnung d.
Übertragen auf unsere Situation erhalten wir: Da n prim ist, ist Zn ein endlicher Körper.
Folglich gibt es in Z×
n wegen 2 | n − 1 genau ϕ(2) ≡ 1 Elemente der Ordnung 2. Das Element
−1 mod n = n − 1 mod n hat Ordnung 2, denn (n − 1)2 ≡ n2 − 2 · n + 1 ≡ 1 mod n. Folglich gilt:
l−1
a2 ·d ≡ −1 mod n, was die Behauptung zeigt.
Die Negation der Aussage des Theorem liefert uns einen möglichen Primzahltest: Wenn wer
der ad ≡ 1 mod n noch a2 ·d ≡ −1 mod n für alle r ∈ {0, . . . , s − 1}, so ist n zusammengesetzt.
Eine Zahl a, die keine dieser Bedingungen erfüllt, heißt ein Zeuge für n. Es gilt das folgende Theorem, dass wir ohne Beweis angeben und dass eine Abschätzung für die Anzahl der
Zeugen für n in der Menge {1, . . . , n − 1} liefert:
Theorem 2.6. Sei n ≥ 3 eine ungerade zusammengesetzte Zahl. Dann gibt es höchstens
Zahlen in {1, . . . , n − 1}, die keine Zeugen für n sind.
n−1
4
Damit ist die Wahrscheinlichkeit bei zufälliger Wahl aus {1, . . . , n − 1} ein a zu finden, dass
kein Zeuge für die zusammengesetzte Zahl n ist, höchstens 41 . Der Miller-Rabin Test geht
dann ähnlich wie der Fermat-Test 2.2 vor: Auch er erhält neben einer auf Primheit zu testenden Zahl n einen Konfidenzparameter t als Eingabe. Dann wird der folgende Primzahltest
t-mal durchgeführt: Zunächst wird getestet, ob n ungerade ist. Ist dieses nicht der Fall, so ist
n zusammengesetzt. Dann werden d, s bestimmt, mit n − 1 = d · 2s und ggT(d, s) = 1. Nun
r
werden die Bedingungen ad ≡ 1 mod n und a2 ·d ≡ −1 mod n für alle r ∈ {0, . . . , s − 1} überprüft. Sind alle Bedingungen verletzt, so lautet die Ausgabe “n ist eine zusammengesetzte
30
KAPITEL 2. GRUNDLAGEN AUS DER ZAHLENTHEORIE
Zahl”. Ist stets mindestens eine der Bedingungen erfüllt, so lautet die Ausgabe “n ist wahrscheinlich prim”. Der Miller-Rabin Test ist in der Lage, die Zusammengesetztheit einer jeden
zusammengesetzten Zahl zu beweisen, d.h. es gibt kein Äquivalent zu den Carmichaelzahlen,
die den Fermat-Test überlisten, für den Miller-Rabin Test. In jedem Fall erhalten wir:
Theorem 2.7. Es gibt einen probabilistischen Primzahltest mit den folgenden beiden Eigenschaften: Wenn er die Ausgabe “M ist zusammengesetzt” liefert, so ist M eine zusammengesetzte Zahl. Wenn er “M ist wahrscheinlich prim” ausgibt, so ist M mit Wahrscheinlichkeit
≥ 1 − 2−t in der Tat eine Primzahl.
Das Theorem garantiert uns also die Existenz eines Primzahltests, der die gleiche Erfolgswahrscheinlichkeit hat wie der Fermat-Test in dem Fall, dass es für die Zahl M mindestens
einen Fermat-Zeugen gibt.
Algorithmus 2.8. (Auffinden einer Primzahl) Seien B ≥ 2 und t ∈ N ein Konfidenzparameter.
(1) Wähle M ∈R [B, 2 · B − 1], M ungerade.
(2) Rufe einen geeigneten Primzahltest mit Eingabe M und t auf.
(3) Falls der Primzahltest M als “wahrscheinlich prim” identifiziert, so gebe M aus, sonst
gehe zurück zu Schritt (1).
Theorem 2.9. Die Ausgabe von Algorithmus 2.8 ist mit Wahrscheinlichkeit mindestens 1 −
2−t+1 · ln B eine Primzahl. Die erwartete Laufzeit von Algorithmus 2.8 ist O(t · (log2 B)4 ).
Die behauptete Wahrscheinlichkeit ergibt sich nach einigen Abschätzungen (siehe [8], Seite
64). Setzt man voraus, dass der verwendete Algorithmus eine Laufzeit hat, die mit der
Laufzeit des Fermat-Tests 2.2 vergleichbar ist, so ergibt sich die zweite Behauptung: Schritt
(2)(ii) benötigt Laufzeit O((log2 M)2 ) (Laufzeit des Euklidischen Algorithmus). Schritt
(2)(iii) kann mittels “Repeated Squaring” in Zeit O((log2 M)3 ) durchgeführt werden. Weil
die Wahrscheinlichkeit durch zufällige Wahl eine Primzahl zu finden näherungsweise durch
B/(2·ln B)
= 2·ln1 B gegeben ist, erwarten wir etwa O(log2 B) Wiederholungen der Schritte (2)
B
und (3) von 2.8. Damit ergibt sich eine Gesamtlaufzeit von O((t · (log2 B)3 ) · log2 B). Dies
zeigt die Behauptung.
Ein interessanter und wichtiger Satz, der uns im folgenden auch immer wieder begegnen wird,
ist der folgende, der auf Dirichlet zurückgeht, und eine Aussage über Primzahlen in gewissen
arithmetischen Progressionen macht:
Satz 2.10. (Dirichlet) Sind a, b ∈ Z mit a > 0 und ggT(a, b) = 1, so gibt es unendlich viele
Primzahlen der Form a · n + b, n ∈ N.
2.2. FAKTORISIERUNG GANZER ZAHLEN
31
Wir werden den Satz in der Regel für den Spezialfall a = q für eine Primzahl q und b =
1 verwenden. Dann sind die Voraussetzungen des Satzes erfüllt und er garantiert uns die
Existenz unendlich vieler Primzahlen der Form q · n + 1. Die Existenz solcher Primzahlen ist
wichtig, da wir auf diese Weise ein p finden können, derart dass die Ordnung von Z×
p in von
uns “steuerbare” Primfaktoren zerfällt. Der Satz und weitere ähnliche Sätze über Primzahlen
in arithmetischen Progressionen können in [10] nachgelesen werden.
In manchen Algorithmen ist es nicht nur wichtig eine Primzahl zu finden, sondern z.B. alle
Primzahlen p1 , . . . , ph bis zu einer vorgegebenen oberen Grenze B ≥ 2 zu bestimmen. Ein
möglicher Algorithmus, der diese Aufgabe bewältigt, ist das Sieb des Erathostenes:
Algorithmus 2.11. (Sieb des Erathostenes) Sei B ≥ 2 gegeben.
(1) Erstelle eine B-elementige Liste L mit L[i] := i für i = 1, . . . , B.
(2) Finde noch nicht markierte Werte L[i] 6= 0 mit i > 1 minimal. Markiere L[i]. Falls kein
solches existiert, so gehe zu Schritt (4).
(3) Setze L[k · i] := 0 für alle k ≥ 2 mit k · i ≤ B.
(4) Gebe alle j mit L[ j] 6= 0 aus.
Die Korrektheit des Algorithmus ist klar. Seine Laufzeit ergibt sich im wesentlichen zu:
∑
p≤B
p prim
B
= B·
p
∑
p≤B
p prim
1
∈ O(B · log2 (log2 B)).
p
Bei der Laufzeitanalyse haben wir – nicht ganz korrekter Weise – den Aufwand für das Setzen
der Listeneinträge auf den Wert Null nicht mitberechnet. Er macht etwa einen Faktor log2 B
aus.
2.2
Faktorisierung ganzer Zahlen
In diesem Abschnitt werden wir im wesentlichen zwei Algorithmen zur Faktorisierung ganzer
Zahlen besprechen: Pollard’s ρ-Methode und Dixon’s Zufallsquadrate.
2.2.1
Die Pollard ρ-Methode zur Faktorisierung ganzer Zahlen
Gegeben sei eine Zahl N ∈ N, die weder eine Primzahl, noch eine reine Primpotenz sei. Wir
betrachten eine Funktion f : ZN → ZN und einen “Startwert” x0 ∈ ZN . Dann berechnen wir
die Sequenz der (xi )i∈N mit xi := f (xi−1 ). Wir nehmen an, dass f Werte liefert, die (xi )i∈N wie
eine zufällige Sequenz erscheinen lassen. Sind nun p und q verschiedene Primfaktoren von
N, so sagt uns der Chinesische Restsatz 1.27, dass eine modulo N zufällig verteilte Sequenz
(xi )i∈N auch modulo p und modulo q zufällig verteilt ist. Betrachten wir nun die Sequenz
32
KAPITEL 2. GRUNDLAGEN AUS DER ZAHLENTHEORIE
(xi )i∈N modulo p, so erhalten wir nach spätestens p-Schritten (und in Wirklichkeit erwartungsgemäß um einiges schneller) eine “Kollision”, d.h. wir finden k, l mit xk ≡ xk+l mod p.
Da aber (xi )i∈N modulo N, p und q zufällig verteilt ist, ist es recht unwahrscheinlich, dass
zu den gleichen Indizes k, l auch eine Kollision modulo q auftritt. Es gilt also mit hoher
Wahrscheinlichkeit xk 6≡ xk+l mod q und damit auch xk 6≡ xk+l mod N. Letzteres bedeutet aber
gerade, dass ggT(xk − xk+l , N) nichttrivial ist, womit wir einen Teiler von N gefunden hätten.
Es stellen sich zwei Probleme: Als erstes müssen wir die erwartete Laufzeit bis zum Auftauchen einer Kollision abschätzen. Als zweites müssen wir uns überlegen, wie wir den erhöhten
Speicherbedarf des obigen Algorithmus minimieren können, denn wir möchten natürlich nach
Möglichkeit nicht alle Werte (xi )i∈N speichern müssen, bis schließlich eine Kollision auftritt.
Proposition 2.12. (Das “Geburtstagsproblem”) In einer Urne befinden sich p gleichartige
√
Kugeln mit den Nummern 1, . . . , p. Dann muss man erwartungsgemäß O( p) Ziehungen mit
Zurücklegen durchführen, bis das erste Mal eine Kollision auftritt (d.h. bis das erste Mal eine
Kugel gezogen wird, die schon bei einem der vorhergehenden Züge zum Vorschein gekommen
war).
Beweis. Es sei s die Zufallsgröße, die die Anzahl der benötigten Ziehungen bis zur ersten
Kollision beschreibt. Gesucht ist der Erwartungswert E (s). Es gilt:
∞
E (s) =
∑
∞
j · P(s = j) =
j=1
∞
=
∑ j · (P(s ≥ j) − P(s ≥ j + 1))
j=1
∞
∑ j · P(s ≥ j) − ∑ j · P(s ≥ j + 1)
j=1
j=1
∞
∞
= P(s ≥ 1) + ∑ j · P(s ≥ j) − ∑ ( j − 1) · P(s ≥ j)
j=2
∞
= P(s ≥ 1) + ∑ P(s ≥ j) =
j=2
j=2
∞
∑ P(s ≥ j)
j=1
Die Wahrscheinlichkeit in den ersten j − 1 Ziehungen keine Kollision zu erhalten lässt sich
wie folgt berechnen und weiter abschätzen:
p · (p − 1) · (p − 2) · . . . · (p − j + 2)
p j−1
p − (i − 1)
i−1
= ∏
= ∏ 1−
p
p
1≤i< j
1≤i< j
P(s ≥ j) =
≤
∏
2 /(2·p)
e−(i−1)/p = e−( j−2)·( j−1)/(2·p) ≤ e−( j−2)
,
1≤i< j
wobei wir 1 − x ≤ e−x benutzt haben. Damit ergibt sich für den Erwartungswert die
2.2. FAKTORISIERUNG GANZER ZAHLEN
33
Abschätzung:
E (s) ≤
∞
2 /(2·p)
∑ e−( j−2)
j=1
∞
≤ 1 + ∑ e− j
2 /(2·p)
≤ 2+
j=0
Z ∞
e−x
2 /(2·p)
dx
0
r
√
Z ∞
p
p
π
π·p
−x2
e dx = 2 + 2 · p ·
= 2+
≤ 2+ 2· p·
2
2
0
√
∈ O( p)
Damit haben wir das erste der beiden Probleme gelöst: Ist p der kleinste Primfaktor der
√
Zahl N, so können wir nach O( p)-Schritten mit einer Kollision rechnen. Ein möglicher
Ansatz, die Zahl N zu faktorisieren, könnte also darin bestehen, die Werte (xi )i∈N zufällig zu
wählen und auf eine Kollision “zu warten”. Die Laufzeit dieses Algorithmus entspricht dann
im wesentlichen der Anzahl der zu erwartenden “Züge” bis zur ersten Kollision.
Nun zum zweiten Problem: Anstatt alle Werte xi für i ≥ 1 mit xi = f (xi−1 ) bis zur ersten
Kollision zu speichern, benutzen wir den sogenannten Zykel-Trick von Floyd:
Algorithmus 2.13. (Floyd’s Zykel Trick) Sei x0 ∈ {0, . . . , p − 1} und f : {0, . . . , p − 1} →
{0, . . . , p − 1} eine Funktion.
(1) Setze i := 0 und y0 := x0 .
(2) Wiederhole die folgenden Berechnungen bis xi = yi für i > 0 gilt:
Setze i := i + 1, xi := f (xi−1 ) und yi := f ( f (yi−1 )).
(3) Gebe i aus.
Das folgende Lemma zeigt uns, dass eine Kollision nach Floyd’s Methode hinreichend schnell
auftritt:
Lemma 2.14. Es sei k der kleinste Wert, für den eine Kollision auftritt, d.h. xk = xk+l . Dann
findet Algorithmus 2.13 nach höchstens (k + l)-Schritten eine Kollision.
Beweis. Es gilt yi = xi genau dann, wenn x2·i = xi genau dann, wenn l (dies ist die Länge des
Zykels) ein Teiler von 2·i−i = i. Der kleinste Wert von i, für den diese Teilbarkeitsbedingung
erfüllt ist, ist i = k + (−k mod l) < k + l gilt. Letzteres sieht man wie folgt: Es ist k = (k div l) ·
l + (k mod l), also −k mod l = (k div l) · l − k und damit i = k + (k div l) · l − k = (k div l) · l.
Nun zu unserem eigentlichen Ziel, dem Faktorisierungsalgorithmus von Pollard:
Algorithmus 2.15. (Pollard’s ρ-Methode) Sei N ∈ N keine Primzahl.
(1) Wähle x0 ∈R {0, . . . , N − 1} und setze y0 := x0 sowie i := 0.
(2) Wiederhole die folgenden Schritte:
34
KAPITEL 2. GRUNDLAGEN AUS DER ZAHLENTHEORIE
2 + 1 mod N, y := (y2 + 1)2 + 1 mod N.
(i) Setze i := i + 1, xi := xi−1
i
i−1
(ii) Berechne g := ggT(xi − yi , N). Falls 1 < g < N, so gebe g aus. Falls g = N, so
breche das Verfahren ab.
Als Laufzeit für den Algorithmus erhalten wir
Theorem 2.16. In der Notation von Algorithmus 2.15 hat Pollard’s ρ-Methode eine Laufzeit
√
von O( p·(log2 N)2 ) Bit-Operationen, wobei p der kleinste Primteiler der Zahl N sei. Wegen
√
p < N = N 1/2 läßt sich die Laufzeit auch ausschließlich in Abhängigkeit von N angeben.
Die Laufzeit ist dann O(N 1/4 · (log2 N)2 ).
Beweis. Die Behauptung folgt sofort mit den Laufzeitabschätzungen für Floyd’s Zykel Trick,
der Laufzeit für den Erweiterten Euklidischen Algorithmus 1.17 sowie dem Aufwand für mo√
dulare Multiplikationen. Beachte, dass wir nach O( p) Schritten mit einer Kollision rechnen
√
können, d.h. der Zykel, in den die berechneten Werte eintreten, kann höchstens Länge O( p)
√
haben. Damit liefert Floyd’s Zykel Trick erwartungsgemäß nach 2 · p Schritten eine Kolli√
sion, also in erwarteter Zeit O( p).
2.2.2
Dixon’s Zufallsquadrate
Der in diesem Abschnitt diskutierte Algorithmus von Dixon basiert auf der folgenden Idee:
Für eine gegebene, zusammengesetzte, zu faktorisierende Zahl N, versucht man Werte x, y ∈
ZN zu finden mit x2 ≡ y2 mod N. Wegen x2 − y2 ≡ (x − y) · (x + y) ≡ 0 mod N folgt dann
N | (x − y) · (x + y). Wenn nun N nicht gerade ein Teiler von x − y oder x + y selbst ist, so sind
ggT(x − y, N) und ggT(x + y, N) nichttrivial und man kann auf diese Weise einen Teiler der
Zahl N finden. Es stellt sich jedoch das Problem, wie man solche Werte x, y überhaupt finden
kann.
Bemerkung 2.17. (Ein Exkurs über B-Zahlen) Seien B, N > 0 gegeben und sei {p1 , . . . , ph }
die Menge aller Primzahlen ≤ B. Dann nennen wir {p1 , . . . , ph } eine B-Faktor-Basis. Eine
Zahl b ∈ {0, . . . , N − 1} heißt B-glatt, falls ihre Primfaktoren sämtlich in {p1 , . . . , ph } enthalten sind. Sie heißt eine B-Zahl, falls b2 mod N gerade B-glatt ist. Es gilt der folgende wichtige
Satz:
Satz (Canfield, Erdös, Pomerance) Es sei ψ(N, B) die Anzahl der B-glatten
Zahlen ≤ N. Dann gilt:
ψ(N, B) = N · u−u·(1+o(1)) ,
wobei u :=
ln N
ln B
(siehe [6], Theorem 10.2.1, Seite 481).
Damit erhalten wir die folgende wichtige Abschätzung:
P(“b ∈R {1, . . . , N} ist B-glatt”) ≈
N · u−u
= u−u ,
N
u :=
ln N
.
ln B
2.2. FAKTORISIERUNG GANZER ZAHLEN
35
Bevor wir zum Algorithmus von Dixon kommen noch eine weitere kleine Vorbereitung:
Proposition 2.18. Tritt ein Ereignis in einem Zufallsexperiment mit Wahrscheinlichkeit p ein
und lässt sich das Experiment unabhängiger Weise wiederholen, so tritt es erwartungsgemäß
nach 1p Wiederholungen des Experimentes zum ersten Mal auf.
Beweis. Wir haben es mit einem diskreten “Warte-Zeit-Phänomen” zu tun und können das
betrachtete Ereignis aus hypergeometrisch verteilt voraussetzen. Der gesuchte Erwartungswert E := E (“Ereignis tritt zum ersten Mal ein”) berechnet sich dann zu E = ∑∞
k=1 k · p · (1 −
p)k−1 . Für |x| < 1 gilt
∞
1
= ∑ xk
1 − x k=0
und somit
∞
1
=
k · xk−1
∑
(1 − x)2 k=1
per Differenziation nach x. Wenden wir diese Identitäten auf unsere Situation an (x = 1 − p),
1
k−1 = p ·
so folgt E = p · ∑∞
= 1p .
k=1 k · (1 − p)
(1−(1−p))2
Algorithmus 2.19. (Dixon’s Zufallsquadrate) Seien N, B > 0 gegeben.
(1) Berechne (z.B. mit dem Sieb des Erathostenes 2.11) alle Primzahlen p1 , . . . , ph aus
{0, . . . , B}.
(2) Setze A := ∅ und wiederhole die folgenden Schritte bis #A = h + 1.
(i) Wähle b ∈R {0, . . . , N − 2}. Falls g := ggT(b, N) > 1, so gebe g aus.
(ii) Setze a := b2 mod N und faktorisiere a über der Faktorbasis {p1 , . . . , ph }. Falls a
nicht B-glatt ist, verwerfe a und gehe zurück zu (i).
(iii) Ist a = pα1 1 · . . . · pαh h , so setze α := (α1 , . . . , αh ) und A := A ∪ {(b, α)}.
(3) Sei A = {(b1 , α (1) ), . . . , (bh+1 , α (h+1) )}. Dann gilt:
α
(1)
α
(1)
b21 ≡ p1 1 · . . . · ph h mod N
..
.
α
(h+1)
b2h+1 ≡ p1 1
α
(h+1)
· . . . · ph h
mod N
Löse nun das lineare Gleichungssystem
 (1)
 
(h+1)  
(2)
. . . α1
α1
α1
x1
 ..
  ..  
..
..
 .
· .  = 
.
.
(1)
(2)
(h+1)
xh+1
α
α
... α
h
h
h

0
.. 
. 
0
über Z2 . Sei (x1 , . . . , xh+1 ) eine nichttriviale Lösung des obigen Gleichungssystems (beachte, dass es eine solche nach Wahl der Koeffizientenmatrix geben muss, denn diese
36
KAPITEL 2. GRUNDLAGEN AUS DER ZAHLENTHEORIE
hat höchstens Rang h). Sind dann xi1 , . . . , xik die von Null verschiedenen Komponenten
des Vektors (x1 , . . . , xh+1 ), so gilt α (i1 ) + . . . + α (ik ) ≡ 0 mod 2. Setze x := bi1 · . . . · bik
γ
γ
und y := p11 · . . . · phh , wobei γ = 21 · (α (i1 ) + . . . + α (ik ) ).
α
(i j )
α
(i j )
(4) Wegen b2i j ≡ p1 1 · . . . · ph h mod N gilt nun x2 ≡ y2 mod N. Gebe ggT(x + y, N) und
ggT(x − y, N) aus.
Um eine akzeptable Abschätzung für die Laufzeit zu √
erhalten, muss B geschickt gewählt
werden. Bei geschickter
Wahl von B, d.h. für B ≈ exp( ln N · ln ln N) erhält man eine Lauf√
zeit von O(exp(3 · ln N · ln ln N)). Diese Abschätzung erhält man im wesentlichen aus den
folgenden Überlegungen: Algorithmus 2.19 benötigt etwa
• B · log2 log2 B Operationen zur Berechnung der Faktorbasis mit dem Sieb des Erasthostenes in Schritt (1).
• ein Durchlauf von Schritt (2) benötigt
◦ höchstens h · (log2 a)3 ≤ B · (log2 N)3 Operationen um a entweder über der Faktorbasis zu faktorisieren oder festzustellen, dass sich a über der Faktorbasis nicht
faktorisieren lässt (Die Laufzeit ergibt sich, wenn man schlicht eine Primzahl
nach der anderen durchgeht und per Division mit Rest feststellt, ob die betrachtete Primzahl ein Teiler der gewählten Zahl ist. Die Zahl a kann höchstens log2 a
verschiedene Primfaktoren haben und wir müssen höchstens h ≤ B Zahlen ausprobieren. Für jede Division mit Rest veranschlagen wir (log2 a)2 Operationen).
◦ Die Wahrscheinlichkeit, dass a in der Tat B-glatt ist, beläuft sich auf etwa u−u mit
N
u
u = ln
ln B . Damit müssen wir Schritt (2) erwartungsgemäß u -mal wiederholen, bis
wir eine B-Zahl gefunden haben.
◦ Um h + 1 ≤ B solcher Zahlen zu finden, müssen wir also etwa B Wiederholungen
von Schritt (2) einkalkulieren.
Damit beläuft sich die Gesamtlaufzeit für Schritt (2) auf etwa B · (log2 N)3 · uu · B erwartete Operationen.
• Weitere (h + 1)3 ≤ B3 Operationen zur Lösung des Gleichungssystems in Schritt (3).
Alle weiteren Operation verbuchen wir unter dem Motto “Peanuts”, d.h. diese fallen nicht
wirklich ins Gewicht und wirken sich nicht dramatisch auf die tatsächliche erwartete Laufzeit
des Algorithmus aus. Insgesamt erhalten wir also im wesentlichen eine erwartete Laufzeit
von B · log2 log2 B + B · (log2 N)3 · uu · B + B3 Operationen. Bedenkt man, dass uu durchaus
in N wächst, so überlegt man sich, dass die Laufzeit genau dann optimal ist, wenn man B
ungefähr so wählt, dass B · (log2 N)3 · uu · B und B3 im wesentlichen
gleich groß sind. Dies
√
führt dann auf die oben angegebene Wahl
√ von B als ≈ exp( ln N · ln ln N) und liefert dann
die behauptete Laufzeit von O(exp(3 · ln N · ln ln N)).
Kapitel 3
Diskrete Logarithmen
In diesem Kapitel wollen wir uns mit diskreten Logarithmen und ihrer Bedeutung in der
Kryptographie auseinandersetzen. Wir werden einige Verfahren diskutieren, wie man diskrete Logarithmen von Elementen einer zyklischen (Unter-)Gruppe berechnen kann und ihre
Laufzeit analysieren.
3.1
Grundlegende Definitionen
Wir betrachten stets eine zyklische Gruppe G = hgi mit erzeugendem Element g ∈ G. Im allgemeinen muss man sich nicht von vorneherein auf zyklische Gruppen einschränken, sondern
kann ganz beliebige Gruppen wie z.B. elliptische Kurven betrachten und dann die Berechnungen in einer geeigneten zyklischen Untergruppe der betreffenden Gruppe ausführen.
Definition 3.1. Sei x ∈ G = hgi und #G = d. Dann heißt die eindeutig bestimmte Zahl k ∈
{0, . . . , d − 1} mit x = gk der diskrete Logarithmus von x in Basis g. Wir schreiben k = dlogg x.
Gilt x = gk und ist d = #G, so ist für jedes i ∈ Z auch k + i · d ein diskreter Logarithmus von x
in Basis g, denn gk+i·d = gk · (gd )i = gk · 1i = gk = x. Verlangen wir jedoch k ∈ {0, . . . , d − 1}
wie in der obigen Definition, so können wir von dem diskreten Logarithmus sprechen: Sind
k, l ∈ {0, . . . , d −1} mit gk = x = gl , so folgt gk−l = 1, also d | k −l. Wegen k, l ∈ {0, . . . , d −1}
folgt |k − l| < d, also wegen d | k − l bereits |k − l| = 0, d.h. k = l.
Das diskrete Logarithmus Problem besteht nun darin, zu einem gegeben x ∈ G dasjenige
k ∈ {0, . . . , d − 1} zu finden, für das x = gk gilt. Beim allgemeinen diskreten Logarithmus
Problem setzt man nicht zusätzlich voraus, dass x ∈ hgi, d.h. bei der allgemeinen Version
des Problems ist zusätzlich zu entscheiden, ob das gegebene Element überhaupt ein Element
der betrachteten zyklischen Gruppe ist (was die Angelegenheit zusätzlich verkompliziert).
Wir werden uns hier fast ausschließlich mit der spezielleren Variante beschäftigen, bei der
wir davon ausgehen können, dass ein gegebenes Element bereits in der zugrundeliegenden
37
38
KAPITEL 3. DISKRETE LOGARITHMEN
zyklischen Gruppe enthalten ist.
Das diskrete Logarithmus Problem wird als “schwer zu lösen” angesehen. Was genau mit dem
Adjektiv “schwer” gemeint ist, werden wir sehen, wenn wir die Komplexität von Algorithmen
zur Berechnung des diskreten Logarithmus untersuchen. Ist n := blog2 dc + 1 die Binärlänge
der Gruppenordnung, so gilt d ≈ 2n . Die Gruppe G hat also 2n Elemente. Damit liefert der
naive Ansatz über ausprobieren aller möglichen Exponenten für g bis man schließlich den
n
Wert x erhält den diskreten Logathmus von x in Basis g nach erwartungsgemäß 22 = 2n−1
Schritten, was für großes n einen völlig utopischen Rechenaufwand bedeutet.
3.2
Der “Baby-Schritt-Riesen-Schritt” Algorithmus
Sei wieder G = hgi eine zyklische Gruppe der Ordnung d. Der folgende Algorithmus berechnet den diskreten Logarithmus eines Elementes x ∈ G.
Algorithmus 3.2. (Der “Baby-Schritt-Riesen-Schritt” Algorithmus) Sei x ∈ G.
√
(1) Setze m := d de.
(2) “Baby-Schritte”: Berechne und speichere x, x · g, x · g2 , . . . , x · gm−1 .
(3) “Riesen-Schritte”: Berechne gm , g2·m , g3·m , . . . bis ein gi·m gefunden wird mit gi·m =
x · g j.
(4) Gebe (i · m − j) mod d aus.
Beweis. (Korrektheit) Wir müssen zunächst zeigen, dass es in der Tat überhaupt zu einer
Kollision kommt. Im Falle einer Kollision liefert der Algorithmus sicherlich den diskreten
Logarithmus von x in Basis g. Es gelte x = ga für a ∈ {0, . . . , d − 1}, d = #G, d.h. a = dlogg x.
Division mit Rest liefert a = b · m + c für ein c mit 0 ≤ c ≤ m − 1. Für j = m − c und i = b + 1
gilt i · m − j = (b + 1) · m − (m − c) = b · m + c. Ist c = 0, so folgt a = b · m und x = ga = gb·m .
Das Element gb·m wird aber vom Algorithmus berechnet und löst eine Kollision mit x aus.
Ist c > 0, so folgt j = m − c ≤ m − 1. Folglich wird x · g j bei den Baby-Schritten berechnet
und löst eine Kollision mit dem Element gi·m für i = b + 1 aus, das bei den Riesen-Schritten
in jedem Fall berechnet wird. Damit erhalten wir stets die gewünschte Kollision, was die
Korrektheit des Algorithmus beweist.
Theorem 3.3. Sei G = hgi und d = #G. Dann
√ berechnet Algorithmus 3.2 den diskreten Logarithmus in einer erwarteten Anzahl von O( d) Gruppenoperationen.
a
d
Beweis. In der Notation des obigen Beweises erhalten wir: b = a−c
m ≤ m < m ≤ m. Die
Baby-Schritte benötigen m−1 Gruppenoperationen. Bis zu einer Kollision werden nun wegen
i = b + 1 höchstens m Riesen-Schritt Berechnungen ausgeführt.
√ Dies liefert einen Gesamtaufwand von O(m) Gruppenoperationen, woraus wegen m = d de die Behauptung folgt.
3.3. DER GEBURTSTAGSANGRIFF AUF DEN DISKRETEN LOGARITHMUS
39
Bemerkung 3.4. Das Speichern aller in den Baby-Schritten berechneten Werte macht Algorithmus 3.2 zu einem sehr speicherintensiven Verfahren. Wir werden in einem der nächsten
Abschnitte ein Verfahren mit ähnlicher Laufzeit aber konstantem Speicherplatz (unabhängig
von der Gruppenordnung) kennenlernen.
3.3
Der Geburtstagsangriff auf den diskreten Logarithmus
Der folgende Algorithmus ist im wesentlichen eine probabilistische Alternative zum BabySchritt-Riesen-Schritt Algorithmus 3.2:
Algorithmus 3.5. (Geburtstagsangriff auf DLP) Sei wieder G = hgi, d = #G und x ∈ G.
(1) Setze X := ∅, Y := ∅.
(2) Wiederhole den folgenden Schritt solange, bis eine Kollision zwischen X und Y auftaucht:
Wähle i ∈R {0, . . . , d − 1} und setze X := X ∪ {x · gi } sowie Y := Y ∪ {gi }.
(3) Gilt x · gi = g j , so gebe ( j − i) mod d aus.
Beweis. (Korrektheit) Da G endlich ist, muss nach endlich vielen Schritten eine Kollision
auftreten. Im Falle einer solchen Kollision ist ( j −i) mod d der gesuchte diskrete Logarithmus.
√
Theorem 3.6. Algorithmus 3.5 berechnet mit einer erwarteten Anzahl von O( d) Gruppenoperationen den diskreten Logarithmus, d = #G.
√
Beweis. Wegen 2.12 können wir nach O( d) Durchführungen von Schritt (2) mit der ersten
Kollision rechnen. Dies zeigt die Behauptung.
3.4
Die Pollard ρ-Methode für den diskreten Logarithmus
Auch Pollard’s ρ-Methode zur Berechnung des diskreten Logarithmus basiert darauf, explizit
Kollision zu produzieren und mit ihrer Hilfe den diskreten Logarithmus zu berechnen. Ziel ist
es, den enormen Speicherbedarf der Algorithmen 3.2 und 3.5 auf ein konstantes Minimum zu
beschränken. Wie in den vorherigen Abschnitten sei wieder G = hgi eine zyklische Gruppe
der Ordnung d.
Bemerkung 3.7. Sei x ∈ G mit ga = x. Unser Ziel ist es a = dlogg x zu berechnen. Wir betrachten eine zufällige Folge von Elementen b0 , b1 , b2 , . . . ∈R {0, 1, 2} und wählen u0 , v0 ∈R
40
KAPITEL 3. DISKRETE LOGARITHMEN
Zd . Dann setzen wir y0 := gu0 · xv0 und berechnen yk+1 für k ≥ 0 über die folgende Iterationsvorschrift


g · yk falls bk = 0
yk+1 := y2k
falls bk = 1


x · yk falls bk = 2
bis wir eine Kollision yi = y j mit i 6= j gefunden haben. Die Exponenten von x und g in yk
können wir in Form von Polynomen speichern. Dazu setzen wir τ0 := u0 + v0 · t und


τk + 1 falls bk = 0
τk+1 := 2 · τk
falls bk = 1


τk + t falls bk = 2
Dann gilt τk = vk ·t + uk und yk = gτk (a) für alle k, denn yk = guk · xvk = guk · (ga )vk = guk +a·vk =
gτk (a) . Im Fall der Kollision yi = y j für i 6= j erhalten wir
gui +a·vi = gui · xvi = yi = y j = gu j · xv j = gu j +a·v j =⇒ ui + a · vi ≡ u j + a · v j mod d
Gilt also ggT(vi − v j , d) = 1, so können wir vi − v j modulo d invertieren und erhalten
a = (u j − ui ) · (vi − v j )−1 mod d.
Wir müssen uns nun die Frage stellen, wie wahrscheinlich der Fall ist, dass wir vi − v j in
der obigen Situation modulo d tatsächlich invertieren können, und wie wir verfahren, wenn
vi − v j eben nicht invertierbar ist.
Bemerkung 3.8. Wir möchten eine Gleichung der Form
m1 − m2 ≡ k · (b1 − b2 ) mod d
nach k auflösen. Falls 1 = e := ggT(b1 − b2 , d) gilt, so können wir wie oben bereits schlicht
mit dem Inversen von b1 − b2 multiplizieren. Gilt jedoch e > 1, so verfahren wir wie folgt:
Weil e ein Teiler von b1 − b2 ist, ist auch m1 − m2 durch e teilbar und wir können ersatzweise
die Gleichung
b1 − b2
d
m1 − m2
≡ k·
mod
e
e
e
2
betrachten. Wegen e = ggT(b1 −b2 , d) sind b1 −b
und de teilerfremd, so dass wir
e
d
0
e invertieren können. Dies liefert uns k mit
m1 − m2
b1 − b2 −1
d
0
k ≡
·
mod .
e
e
e
Es gilt also k ≡ k0 mod de , d.h. k − k0 = i · de für ein i ∈ Z und folglich
k ≡ k0 + i ·
d
mod d
e
b1 −b2
e
modulo
3.4. DIE POLLARD ρ-METHODE
41
für ein i mit 0 ≤ i ≤ e − 1. Eine Möglichkeit den richtigen Wert für k herauszufinden ist nun,
alle möglichen Werte von i auszuprobieren und zu vergleichen, ob sich das gewünschte Ergebnis ergibt. Für kleine Werte von e ist dieses Verfahren durchaus praktikabel. Insbesondere
in dem Spezialfall, dass die Gruppenordnung d eine Primzahl ist, kann e nur die Werte 1 oder
d annehmen.
Bemerkung 3.9. Die Wahrscheinlichkeit, dass eine zufällige Zahl aus {1, . . . , d − 1} teilerfremd zu d ist, berechnet sich exakterweise zu ∏ p|d (1 − 1p ) nach Satz 1.35. Hat d
p prim
nur sehr große Primfaktoren, so ist die Wahrscheinlichkeit dafür, durch zufällige Wahl aus
{1, . . . , d − 1} ein zu d teilerfremdes Element zu erhalten, relativ groß. Diese etwas schwammige Aussage soll jedoch nur an die Intuition appellieren. Genauer gilt:
Satz. Die Anzahl der zu d teilerfremden Zahlen ist ϕ(d), wobei ϕ die Eulersche
ϕ-Funktion bezeichnet. Es gilt
ϕ(d) ≈
6
· d ≈ 0.6079271019 · d
π2
und damit ist die Wahrscheinlichkeit durch zufällige Wahl aus {1, . . . , d − 1}
eine zu d teilerfremde Zahl zu erhalten näherungsweise 61%.
Eine Wahrscheinlichkeit deutlich größer als 50% soll uns genügen. Die Aussage dieses Satzes
entspricht der Aussage von Satz 1.36.
Bemerkung 3.10. Zurück zur algorithmischen Idee zur Bestimmung des diskreten Logarithmus, die wir in der ersten Bemerkung dieses Abschnitts skizziert hatten. Auch wenn die Sequenz der (yi )i∈N keinesfalls zufällig ist, so zeigt jedoch die Praxis, dass sie sich wie “zufällig
verhält”. Wir werden sie im folgenden wie eine Sequenz von
√ Zufallszahlen behandeln. Der
Satz über das Geburtstagsproblem sagt uns, dass wir nach O( d) Schritten, d = #G, mit einer
Kollision rechnen können. Die bisherige algorithmische Idee verlangt allerdings noch immer
das Speichern aller Werte bi , i = 0, 1, 2, . . ., mit deren Hilfe sich dann die entsprechenden
Polynome τi berechnen lassen und mit deren Hilfe dann wiederum der diskrete Logarithmus
ermittelt werden kann. Als erste Verbesserung werden wir Floyd’s Zykel Trick 2.13 in den
Algorithmus einfügen. Dann partitionieren wir G in drei ungefähr gleich große Teilmengen
S0 , S1 und S2 und ändern die Iterationsvorschriften wie folgt ab:




g · yk falls yk ∈ S0
τk + 1 falls yk ∈ S0
2
yk+1 := yk
τk+1 := 2 · τk
falls yk ∈ S1
falls yk ∈ S1




x · yk falls yk ∈ S2
τk + t falls yk ∈ S2
Nun muss die Sequenz der bi nicht mehr gespeichert werden, denn wir haben die zufällige
Wahl durch eine deterministische ersetzt, die in der Praxis ebenso gute Resultate liefert, wie
eine zufällige Wahl.
Nun kommen wir endlich zu dem eigentlichen Algorithmus:
42
KAPITEL 3. DISKRETE LOGARITHMEN
Algorithmus 3.11. (Die Pollard ρ-Methode für DLP) Sei G = hgi, d = #G und x ∈ G.
Ferner sei G = S0 ] S1 ] S2 eine Partition von G mit |S0 | ≈ |S1 | ≈ |S2 |.
(1) Wähle u0 , v0 ∈R Zd und setze x0 := gu0 · xv0 , y0 := gu0 · xv0 , τ0 := u0 + t · v0 , σ0 :=
u0 + t · v0 , k := 0.
(2) Wiederhole die folgenden Schritte, bis eine Kollision xk = yk , k > 0, auftritt:
(i) Berechne


g · xk falls xk ∈ S0
xk+1 := xk2
falls xk ∈ S1 ,


x · xk falls xk ∈ S2


τk + 1 falls xk ∈ S0
τk+1 := 2 · τk
falls xk ∈ S1


τk + t falls xk ∈ S2
(ii) Berechne


g · yk falls yk ∈ S0
tmp
yk+1 := y2k
falls yk ∈ S1 ,


x · yk falls yk ∈ S2


σk + 1 falls yk ∈ S0
tmp
σk+1 := 2 · σk
falls yk ∈ S1


σk + t falls yk ∈ S2
und
 tmp

g · yk+1
2
yk+1 := (ytmp
k+1 )

 tmp
x · yk+1
 tmp

σk+1 + 1
tmp
σk+1 := 2 · σk+1

 tmp
σk+1 + t
tmp
falls yk+1 ∈ S0
tmp
falls yk+1 ∈ S1 ,
tmp
falls yk+1 ∈ S2
tmp
falls yk+1 ∈ S0
tmp
falls yk+1 ∈ S1
tmp
falls yk+1 ∈ S2
(iii) Setze k := k + 1.
(3) Gilt xk = guk · xvk = gsk · xtk = yk und ggT(vk − tk , d) = 1, so gebe (sk − uk ) · (vk −
tk )−1 mod d aus. Anderenfalls gebe FAIL zurück.
Die Polynome können während der Berechnung ruhig modulo d reduziert werden, um die
Koeffizienten möglichst klein zu halten. Insgesamt erhalten wir also:
3.5. DER “CHINESE-REMAINDERING” ALGORITHMUS
43
Theorem 3.12. Die Pollard ρ-Methode
für den diskreten Logarithmus 3.11 berechnet mit ei√
ner erwarteten Anzahl von O( d) Gruppenoperationen, d = #G, und konstantem Speicherbedarf den diskreten Logarithmus.
Beweis. Folgt aus dem Satz über die erwartete Anzahl von Wahlen bis zur ersten Kollision
unter der Annahme, dass sich die Sequenzen der xi und yi wie zufällig verhalten.
3.5
Der “Chinese-Remaindering” Algorithmus
Sei G = hgi eine zyklische Gruppe der Ordnung d und d = q1 · . . . · qr die Faktorisierung von
d in paarweise teilerfremde Zahlen q1 , . . . , qr . Wir wollen in diesem Abschnitt ein Verfahren kennenlernen, wie man mit Hilfe des Chinesischen Restsatzes 1.27 die Berechung von
diskreten Logarithmen in G auf die Berechnung von diskreten Logarithmen in zyklischen
Untergruppen der Ordnung q1 , . . . , qr reduzieren kann. Zunächst benötigen wir einige theoretische Hilfsmittel:
Definition 3.13. Sei G = hgi und e ∈ N. Dann setzen wir πe (G) := {xe | x ∈ G}.
Offensichtlich ist πe (G) stets eine Untergruppe von G. Sind e und d = #G teilerfremd, so
gilt stets πe (G) = G, denn als Untergruppe von G folgt einerseits #πe (G) ≤ d. Andererseits
enthält πe (G) jedoch ein Element der Ordnung d, denn ist x ein erzeugendes Element von
ord(x)
G, so gilt ord(x) = d und es folgt ord(xe ) = ggT(ord(x),e)
= d. Somit folgt #πe (G) ≥ d, also
πe (G) = G. Sind e und d jedoch nicht teilerfremd, so erhalten wir die folgenden interessanten
Resultate:
Lemma 3.14. In der Notation von oben erhalten wir für einen Teiler e von d gerade πe (G) =
d
{x ∈ G | x e = 1}.
d
Beweis. Sei x ∈ πe (G). Dann gilt x = x0e für ein x0 ∈ G und x e = x0d = 1. Somit folgt πe (G) ⊆
d
H := {x ∈ G | x e = 1}. Bleibt zu zeigen H ⊆ πe (G). Die Elemente von H sind gerade gegeben
d
durch 1 = g0 , ge , g2·e , . . . , g( e −1)·e und diese sind paarweise verschieden, da ord(g) = d. Wäre
nämlich gi = g j für i, j ∈ {e, 2 · e, . . . ( de − 1) · e}, i < j, so folgt g j−i = 1 und j − i < ( de − 1) ·
d
e = d − e. Widerspruch! Da alle Elemente 1 = g0 , ge , g2·e , . . . , g( e −1)·e insbesondere in πe (G)
enthalten sind, folgt H ⊆ πe (G) und damit die Behauptung.
Der folgende Satz liefert uns die theoretische Grundlage für den Algorithmus zur Berechnung
des diskreten Logarithmus in zyklischen Untergruppen von G kleinerer Ordnung:
Satz 3.15. Sei G = hgi eine zyklische Gruppe der Ordnung d und d = q1 · . . . · qr die Faktorisierung von d in paarweise teilerfremde Zahlen q1 , . . . , qr . Seien x ∈ G und
Si := {xd/qi | x ∈ G}
Dann gilt:
Ti := {x ∈ G | xqi = 1}.
44
KAPITEL 3. DISKRETE LOGARITHMEN
(i) Si = Ti , #Si = qi und Si wird von gd/qi erzeugt für i = 1, . . . , r.
(ii) G ∼
= S1 × S2 × . . . × Sr vermöge y 7→ (yd/q1 , . . . , yd/qr ).
(iii) Es gilt a = dlogg x genau dann, wenn ai = dloggd/qi xd/qi mit a ≡ ai mod qi für i = 1, . . . , r.
Beweis. Die Behauptung folgt im wesentlichen aus dem vorhergehenden Lemma und dem
Chinesischen Restsatz 1.27, da die Abbildung Zd → G, i 7→ gi ein Gruppenisomorphismus ist
und Zd ∼
= S1 × . . . × Sr .
= Zd ∼
= Zq1 × . . . × Zqr ∼
= Zq1 × . . . × Zqr . Es gilt dann nämlich G ∼
Algorithmus 3.16. (“Chinese Remaindering” für DLP) Sei G = hgi eine zyklische Gruppe
der Ordnung d sowie d = q1 ·. . .·qr die Faktorisierung von d in paarweise teilerfremde Zahlen
q1 , . . . , qr und x ∈ G.
(1) Wiederhole die folgenden Schritte für i = 1, . . . , r:
d
d
(i) Berechne gi := g qi und xi := x qi mit Hilfe von “Reapeted Squaring” 1.5.
(ii) Berechne ai = dloggi xi in Si = {xd/qi | x ∈ G}.
(2) Berechne mit Hilfe des Chinesischen Restsatz Algorithmus 1.28 a ∈ {0, . . . , d − 1} mit
a ≡ ai mod qi für i = 1, . . . , r und gebe a aus.
Beweis. (Korrektheit) Die Korrektheit folgt unmittelbar aus dem vorhergehenden Theorem.
Theorem 3.17. Sei G = hgi, d := #G und n = blog2 dc + 1 die Binärlänge der Gruppenordnung von G. Algorithmus 3.16 berechnet den diskreten Logarithmus in G mit folgendem
Aufwand:
n
(i) Faktorisierung von d, d.h. O(2 4 · n2 ) Operationen, wenn wir Pollard’s ρ-Methode 2.15
zur Faktorisierung verwenden.
(ii) Berechnung je eines diskreten Logarithmus in den Untergruppen S1 , . . . , Sr . Wegen
#Si = qi ergibt sich bei Verwendung von Pollard’s ρ-Methode für DLP 3.11 eine Lauf√
zeit von O( qi ) für jede solche Berechnung.
(iii) “Repeated Squaring”, d.h. im wesentlichen Aufwand O(n3 ).
Beweis. Die Behauptungen über die Laufzeit ergeben sich aus den Laufzeit-Angaben für die
verwendeten (Teil-)Algorithmen.
3.6. DER ALGORITHMUS VON POHLIG & HELLMAN
3.6
45
Der Algorithmus von Pohlig & Hellman
In diesem Abschnitt werden wir einen Algorithmus kennenlernen, mit dem wir die Berechnung von diskreten Logarithmen in zyklischen Gruppen der Ordnung pe , p prim, e ≥ 2, auf
die Berechnung von diskreten Logarithmen in Gruppen der Ordnung p reduzieren können.
Bemerkung 3.18. Sei G = hgi eine zyklische Gruppe der Ordnung d = pe für eine Primzahl
p und e ≥ 2 sowie x ∈ G mit x = ga . Wir stellen uns vor, wir kennen den Wert von a bereits
und berechnen die p-adische Darstellung von a, die wegen a < pe durch a = ae−1 · pe−1 +
ae−2 · pe−2 + . . . + a1 · p + a0 mit a0 , . . . , ae−1 ∈ {0, . . . , p − 1} gegeben ist. Potenzieren wir
nun x = ga mit pe−1 , so erhalten wir
e−1
xp
2·e−2 +a
2·e−3 +...+a ·pe +a ·pe−1
0
e−2 ·p
1
e−1
= gae−1 ·p
= (ga ) p
e−1
Setzen wir g0 := g p
e−1
, so erhalten wir a0 = dlogg0 x p
e−1
= ga0 ·p
.
. Diesen Verfahren können wir nun
e−2
und berechnen x1p
e−1
e−2
fortsetzen: Wir setzen x1
= ga1 ·p . Dann gilt a1 = dlogg0 x1p
usw. Auf diese Weise können wir sukzessive die Werte a0 , . . . , ae−1 berechnen und erhalten
somit a = dlogg x.
:= x · g−a0
Algorithmus 3.19. (Pohlig & Hellman Algorithmus für DLP) Sei G = hgi eine zyklische
Gruppe der Ordnung d = pe für eine Primzahl p und e ≥ 2 sowie x ∈ G.
2
e−1
(1) Berechne g p , g p , . . . , g p
e−1
gp .
mit “Repeated Squaring” 1.5 und setze y−1 := 1 ∈ G, g0 :=
(2) Wiederhole die folgenden Schritte für i = 0, . . . , e − 1:
e−i−1
(i) Berechne xi := (x · yi−1 ) p
.
(ii) Berechne ai = dlogg0 xi mit Hilfe des Algorithmus von Pollard 3.11.
i
(iii) Berechne yi = yi−1 · g−ai ·p .
(3) Gebe a = ae−1 · pe−1 + ae−2 · pe−2 + . . . + a1 · p + a0 aus.
Beweis. (Korrektheit) Die Korrektheit sollte nach der vorhergehenden Bemerkung klar sein.
Theorem 3.20. Sei G = hgi eine zyklische Gruppe der Ordnung d = pe für eine Primzahl
p und e ≥ 2. Sei ferner n = blog2 pc + 1 die Binärlänge der Primzahl p. Algorithmus 3.19
berechnet den diskreten Logarithmus in G mit folgenden Aufwand:
(i) O(e · (e · n)3 ) Operationen für Schritt (1).
√
(ii) O(e · p) für die Berechnung der diskreten Logarithmen.
(iii) Weitere O(e · (e · n)3 ) Operationen für die Berechnung der Potenzen.
46
KAPITEL 3. DISKRETE LOGARITHMEN
Beweis. In Schritt (1) werden e Potenzen berechnet. Wegen n ≈ log2 p folgt log2 pe = e ·
log2 p = e · n. Setzt man voraus, dass alle Gruppenelemente eine Codierungslänge ≤ e · n
haben, so liefert die Abschätzung der Laufzeit des Repeated Squarings zusammen mit der
klassischen Methode zur Multiplikation die behauptete Laufzeit O(e · (e · n)3 ) für Schritt (1).
Analog folgt die Laufzeit unter (iii). Die unter (ii) behauptete Laufzeit folgt sofort aus der
Laufzeitangabe des Algorithmus von Pollard zur Berechnung des diskreten Logarithmus.
3.7
Zusammenfassung
Die vorhergehenden Abschnitte liefern uns: Ist G eine zyklische Gruppe der Ordnung d und
ist d eine Primzahl, so lassen sich diskrete Logarithmen mit Hilfe des Pollard ρ-Algorithmus
3.11 in G berechnen. Ist dagegen d keine Primzahl, so erlaubt es die Faktorisierung von d,
die Berechnung des diskreten Logarithmus von G in entsprechende Berechnungen diskreter
Logarithmen in Untergruppen von G zu verlagern. Ist d = pe11 · . . . · per r die Primfaktorzerlegung von d, so können wir die Berechnung des diskreten Logarithmus eines Elementes in
G effizient zunächst mit Hilfe des “Chinese Remaindering” Algorithmus 3.16 auf die Berechnung diskreter Logarithmen in zyklischen Untergruppen der Ordnung pe11 , . . . , per r von G
reduzieren. Die diskreten Logarithmen in diesen kleineren Gruppen können dann zusätzlich
noch mit Hilfe des Algorithmus von Pohlig-Hellman 3.19 auf die Berechnung der diskreten
Logarithmen in zyklischen Untergruppen der Ordnung p1 , . . . , pr von G reduziert werden.
Hat also d sehr viele kleine Primfaktoren, so können wir d nicht nur effizient faktorisieren
(auch bei der Laufzeit des Faktorisierungsalgorithmus von Pollard ist der wesentliche Anteil durch die Wurzel aus dem kleinsten Primteiler der zu faktorisierenden Zahl gegeben),
sondern wir können auch den diskreten Logarithmus innerhalb einer zyklischen Gruppe der
Ordnung d recht effizient berechnen. Insgesamt erhalten wir also den folgenden Algorithmus
zur Berechnung diskreter Logarithmen in zyklischen Gruppen:
Algorithmus 3.21. (Berechnung des diskreten Logarithmus) Sei G = hgi eine zyklische
Gruppe der Ordnung d und x ∈ G.
(1) Faktorisiere d, d.h. berechne paarweise teilerfremde Primpotenzen pe11 , . . . , per r mit d =
pe11 · . . . · per r .
(2) Wiederhole die folgenden Schritte für i = 1, . . . , r:
(i) Setze qi := pei i .
(ii) Berechne xi := xd/qi und gi := gd/qi .
(iii) Nun ist xi ein Element der von gi erzeugten zyklischen Gruppe der Ordnung qi =
pei i . Berechne nun ai = dloggi xi mit Hilfe des Algorithmus von Pohlig & Hellman
3.19 (der wiederum seinerseits des Algorithmus von Pollard 3.11 verwendet).
(3) Berechne mit Hilfe des “Chinese Remaindering” Algorithmus 3.16 aus a1 , . . . , ar den
diskreten Logarithmus von x in Basis g.
3.8. INDEX-KALKÜL FÜR DEN DISKRETEN LOGARITHMUS IN Z×
P
47
√
Algorithmus 3.21 benötigt O(n · p + n2 ) Gruppenoperationen zur Berechnung des diskreten Logarithmus, wobei n := blog2 #Gc + 1 die Binärlänge der Gruppenordnung ist und p
der größte Primteiler von #G. Die Laufzeitabschätzung ergibt sich im wesentlichen aus der
Tatsache, dass wir wegen d = pe11 · . . . · per r genau e1 + . . . + er ≤ blog2 dc + 1 = n diskrete
Logarithmen in den entsprechenden zyklischen Untergruppen von G mit Primzahlordnung
über den Algorithmus von Pollard berechnen müssen. Jede solche Berechnung benötigt wenn
√
p der größte Primteiler von d ist erwartungsgemäß O( p) Gruppenoperation. Damit ergibt
√
sich der Anteil von O(n · p) Gruppenoperationen.
3.8
Index-Kalkül für den diskreten Logarithmus in Z×
p
In diesem Abschnitt lernen wir einen “alternativen” Algorithmus zur Bestimmung des diskreten Logarithmus kennen: den Index-Kalkül. Wir werden sehen, dass dieser Algorithmus
weniger “generisch” ist als diejenigen Algorithmen, die wir bisher kennengelernt haben. Jedoch kann Index-Kalkül auch nicht in einer beliebigen zyklischen Gruppe angewandt werden.
Wir werden ihn hier am Beispiel der zyklischen Gruppe Z×
p kennenlernen. Wir verzichten in
diesem Abschnitt auf eine formelle Beschreibung des Algorithmus und formulieren die wesentlichen algorithmischen Ideen innerhalb der folgenden Bemerkung:
Bemerkung 3.22. Wie schon bei Dixon’s Zufallsquadraten betrachten wir eine Faktorbasis
{p1 , . . . , ph } von Primzahlen kleiner-gleich einer vorgegebenen Zahl B. Sei G := Z×
p = hzi
und x ∈ G. In einem ersten, von x unabhängigen Schritt, wählen wir zufällige Exponenten
e ∈ {0, . . . , p − 2} und prüfen, ob ze mod p sich über der Faktorbasis {p1 , . . . , ph } faktorisieren
lässt. Ist dies nicht der Fall, so verwerfen wir ze . Anderenfalls erhalten wir
ze ≡ pα1 1 · . . . · pαh h
mod p
⇐⇒
e ≡ α1 · dlogz p1 + . . . + αh · dlogz ph
mod p − 1.
Von diesen “Relationen” sammeln wir so viele, dass wir das entsprechende Gleichungssystem modulo p − 1 in den Unbestimmten dlogz p1 , . . . , dlogz ph eindeutig lösen können.
Dafür genügen in der Regel ein wenig mehr als h solcher Relationen, z.B. h + 10. Wir
wollen das zu lösende Gleichungssystem im folgenden mit A · x ≡ b mod p − 1 bezeichnen. Wir müssen die Koeffizientenmatrix A für das Gleichungssystems aus h Gleichungen
in den Unbestimmten dlogz p1 , . . . , dlogz ph aufbauen derart, dass das Gleichungssystem eine
eindeutig bestimmte Lösung besitzt. Wir wählen dazu jeweils h der berechneten Gleichungen in dlogz p1 , . . . , dlogz ph aus und prüfen, ob det A invertierbar modulo p − 1 ist, d.h. ob
ggT(det A, p − 1) = 1. Ist letztere Bedingung erfüllt, so besitzt A · x ≡ b mod p − 1 eine eindeutig bestimmte Lösung x, deren Komponenten dann gerade die Werte für dlogz p1 , . . . , dlogz ph
liefern. Ist nun ein passendes (h × h)-Gleichungssystem der Form A · x ≡ b mod p − 1 gefunden, so versuchen wir die Lösung schlicht mit Gauß-Elimination zu berechnen. Dann
gibt es zwei Möglichkeiten: Entweder, wir können alle erforderlichen Divisionen modulo p − 1 durchführen und das Gleichungssystem erfolgreich lösen, oder wir stoßen auf ein
Element a mod p − 1, dass wir invertieren müssten, es aber nicht können, da es nicht teilerfremd zu p − 1 ist. Dann berechnen wir d := ggT(a, p − 1) und schreiben p − 1 in der Form
48
KAPITEL 3. DISKRETE LOGARITHMEN
p − 1 = m · d k , wobei wir o.E. ggT(m, d) = 1 annehmen wollen (sind m und d nicht teilerfremd aber d 6 |m, so haben wir wiederum einen echten d 0 Teiler von d und m gefunden, der
sich durch sukzessive Division in beiden Faktoren abseparieren lässt, so dass wir letztendlich
eine Darstellung von p − 1 der Form m0 · d1n1 · . . . · dmnm mit paarweise teilerfremden Faktoren
erhalten). Dann betrachten wir das Gleichungssystem einmal modulo m und einmal modulo
d k und versuchen zu jedem dieser Teilsysteme wieder eine Lösung über Gauß-Elimination zu
finden. Gelingt dieser Ansatz, so können wir anschließend aus den Lösungen für die Teilsysteme wegen ggT(m, d) = 1 mit Hilfe des Chinesischen Restsatzes 1.27 die Lösung modulo
p − 1 berechnen. Wir diskutieren nun zunächst den Fall, dass d k eine Primpotenz ist, d.h. wie
wir die Lösung des Gleichungssystems A · x ≡ b mod pei für eine Primpotenz pei mit pei | p − 1
berechnen können. Dazu geht man für j = 1, . . . , e − 1 wie folgt vor: Man berechnet zunächst
eine Lösung x0 von A · x ≡ b mod pij , d.h. A · x0 = b + pij · y0 für einen ganzzahligen Vektor
y0 über Gauß-Elimination (beachte, dass dies im Fall j = 1 möglich ist, da pi prim ist – für
j > 1 können wir, wie wir unten sehen werden, diese Lösung als bereits gegeben ansehen).
Dann berechnet man eine Lösung x1 von A · x ≡ y0 mod pi , d.h. A · x1 = y0 + pi · y1 (dies ist
immer möglich, da pi prim ist). Dann gilt A · (x0 − pij · x1 ) = b + pij · y0 − pij · y0 − pij+1 · y1 =
b − pij+1 · y1 , d.h. A · (x0 − pij · x1 ) ≡ b mod pij+1 . Starten wir also mit j = 1, so finden wir
auf die beschriebene Weise die Lösung modulo pij+1 = p2i . Iteration des Verfahrens liefert
schließlich die gesuchte Lösung modulo pei .
Ist d k keine Primpotenz, so gehen wir ganz analog vor. Der störende Eintrag a mod p − 1,
den wir zuvor wegen ggT(a, p − 1) = d nicht invertieren konnten, verschwindet modulo d, so
dass wir uns einfach ein neues Pivot-Element bei der Elimination suchen (ein solches muss es
geben, da die Matrix A wegen ggT(det A, p − 1) = 1 und d | p − 1 insbesondere auch modulo
d invertierbar sein muss). Generell lässt sich zeigen, dass man ein (h × h)-Gleichungssystem
über ZN für N ≥ 2 mit O(h3 · (log2 N)3 ) Bit-Operationen lösen kann.
Sind schließlich die Werte für dlogz p1 , . . . , dlogz ph bekannt, so berechnet man dlogz x für
ein beliebiges x wie folgt: Man wählt wiederum zufällige Exponenten e ∈ {0, . . . , p − 2} bis
β
x · ze mod p sich über der Faktorbasis {p1 , . . . , ph } faktorisieren lässt. Ist x · ze ≡ p1 1 · . . . ·
β
ph h mod p, so folgt dlogz x = −e + β1 · dlogz p1 + . . . + βh · dlogz ph .
Die
p Laufzeit des Algorithmus beläuft sich bei geschickter Wahl von B auf O(exp((1 + o(1)) ·
log2 p · log2 log2 p)) Bitoperationen. Beachte, dass die Laufzeit des Algorithmus von Pol√
lard 3.11 zur Berechnung des diskreten Logarithmus in Z×
p durch O( p) Gruppenoperationen gegeben ist. Da es sich bei den Gruppenoperationen im wesentlichen um Multiplikatio√
nen handelt, ergibt sich ein Aufwand von etwa O( p · (log2 p)2 ) Bitoperationen (sofern man
die klassische Methode zur Multiplikation zugrundelegt). Wegen #Z×
p = p − 1 können wir
nur dann wirklich von den Algorithmen “Chinese Remaindering” 3.16 und Pohlig & Hellman 3.19 profitieren, wenn p − 1 nur sehr viele kleine Primfaktoren besitzt. Wählt man nun
z.B. p − 1 mit p − 1 = 2 · q für eine Primzahl q, so können wir im wesentlichen nur den Algorithmus von Pollard 3.11 verwenden, so dass sich in der Tat wegen q ≈ 2p ∈ O(p) eine
√
√
2
Laufzeit von etwa O( p) Gruppenoperationen, d.h. in Z×
p etwa O( p · (log2 p) ) Bitoperap
tionen, ergibt. Die Funktion exp( log2 p · log2 log2 p)) wächst jedoch deutlich langsamer als
3.9. ARITHMETISCHE SCHALTKREISE
49
√
p · (log2 p)2 , weshalb der Index-Kalkül im Spezialfall Z×
p eine deutlich effizientere Methode zur Berechnung des diskreten Logarithmus ist als die generischen Algorithmen, die wir in
den vorhergehenden Abschnitten kennengelernt haben.
3.9
Arithmetische Schaltkreise
In diesem Abschnitt wollen wir zeigen, dass die Laufzeit von Algorithmus 3.21 im Fall einer allgemeinen zyklischen Gruppe G = hgi, in der wir keinen Index-Kalkül 3.22 anwenden
können, im wesentlichen optimal ist.
3.9.1
(Deterministische) arithmetische Schaltkreise
Wir verwenden wieder die übliche Notation: G = hgi bezeichnet eine zyklische Gruppe der
Ordnung d und p den größten Primteiler von d (er bestimmt im wesentlichen die benötigte
Anzahl von Gruppenoperationen der generischen Algorithmen zur Berechnung des diskreten
Logarithmus in G).
Der Baby-Schritt-Riesen-Schritt Algorithmus 3.2 berechnet den diskreten Logarithmus, indem er eine Sequenz (yi )i∈N von Gruppenelementen berechnet, bis eine Kollision auftritt (und
berechnet mit deren Hilfe dann den diskreten Logarithmus). Alle in diesem Algorithmus ausgeführten Rechenschritte lassen sich in der Form yk := yi · y±1
j für i, j < k schreiben, wobei
man in der Regel y−2 := 1, y−1 := g und y0 := x setzt und x dasjenige Gruppenelement ist,
dessen diskreter Logarithmus zu bestimmen ist. Eine Formalisierung dieses auf elementaren
Gruppenoperationen (Multiplikation und Inversion in G) beruhenden Algorithmen-Modells
ist der (deterministische) arithmetische Schaltkreis:
Definition 3.23. Ein (deterministischer) arithmetischer Schaltkreis ist eine endliche Sequenz
C = (I1 , . . . , Il ) von Instruktionen Ik = (i, j, ε) mit −2 ≤ i, j < k und ε ∈ {−1, 1}. Wir nennen
l die Länge des Schaltkreises. Für eine zyklische Gruppe G = hgi und x ∈ G ist die Spur von
C bei Eingabe (g, x) gegeben durch eine Sequenz von Elementen z−2 , z−1 , z0 , z1 , . . . , zl ∈ G,
wobei z−2 := 1, z−1 := g, z0 := x und zk := zi · zεj für k ≥ 1 und Ik = (i, j, ε). Die SpurExponenten sind eine Sequenz linearer Polynome τ−2 , τ−1 , τ0 , τ1 , . . . , τl ∈ Z[t] mit τ−2 := 0,
τ−1 := 1, τ0 := t und τk := τi + ε · τ j . Wir sagen, dass C erfolgreich ist, wenn eine Kollision
zi = z j bei Eingabe (g, x) auftritt.
Mit den Bezeichnungen der obigen Definition gilt: Ist x = ga und τk = c ·t + b, so gilt zk (x) =
gb · xc = gb · ga·c = gc·a+b = gτk (a) . Die Polynome τ j sind uns schon bei dem Algorithmus von
Pollard 3.11 für den diskreten Logarithmus begegnet. Dort hatten wir auch diskutiert, dass
manche Kollisionen nicht hilfreich sind und sich mit ihrer Hilfe der diskrete Logarithmus
u.U. nicht berechnen lässt. Diese trivialen Kollisionen wollen wir ausschließen.
Angenommen, der arithmetische Schaltkreis C produziert bei Eingabe (g, x = ga ) die Kollision zi (x) = z j (x). Dann gilt für die Spur-Exponenten τi (a) ≡ τ j (a) mod d, d = #G. Gilt nun
aber unabhängig von x generell immer τi ≡ τ j mod d mit τi = c1 ·t +c0 , τ j = d1 ·t +d0 , so folgt
50
KAPITEL 3. DISKRETE LOGARITHMEN
(c1 − d1 ) · t + (c0 − d0 ) ≡ 0 mod d. Wenn d aber das lineare Polynom (c1 − d1 ) · t + (c0 − d0 )
teilt, so muss es jeden Koeffizienten teilen, insbesondere also c1 − d1 . Wenn wir den diskreten Logarithmus mit Hilfe einer Kollision berechnen wollen (so wie wir es im Algorithmus
von Pollard 3.11 tun), so müssen wir c1 − d1 modulo d invertieren können. Ist jedoch d ein
Teiler von c1 − d1 , so kann das Vorgehen nicht zum Erfolg führen: Wir können den diskreten
Logarithmus nicht berechnen. Gleiches gilt, falls q ein beliebiger Teiler der Gruppenordnung
d ist: Denn erhalten wir auch in diesem Fall τi ≡ τ j mod q, so ist q ein Teiler von c1 − d1 .
Folglich sind c1 − d1 und d nicht teilerfremd, weshalb sich c1 − d1 auch in diesem Fall nicht
modulo d invertieren lässt und wir den diskreten Logarithmus auf die beschriebene Weise
nicht berechnen können. Wir fassen die Beobachtungen zu einer Definition zusammen:
Definition 3.24. Sei C ein arithmetischer Schaltkreis der Länge l, G = hgi, q ein beliebiger
Teiler der Gruppenordnung d = #G und i, j ≤ l. Wir sagen, dass das Paar (i, j) den Teiler q
respektiert, wenn τi − τ j 6≡ 0 mod q gilt. Tritt bei Eingabe (g, x) eine Kollision yi = y j auf, so
sagen wir dass diese q respektiert, wenn (i, j) q respektiert.
Erhalten wir also eine Kollision zi (x) = z j (x) bei Eingabe (g, x), die q respektiert, so folgt
zi (x) = gτi (a) = gτ j (a) = z j (x), aber τi − τ j 6≡ 0 mod q, so dass wir zumindest eine Chance
haben, a über Inversion modulo d zu berechnen. Es gilt stets für q1 | q2 | d: Falls (i, j) q1
respektiert, so respektiert (i, j) auch q2 .
Bevor wir endlich zu interessanten theoretischen Resultaten kommen, noch eine weitere Definition:
Definition 3.25. Sei C ein arithmetischer Schaltkreis der Länge l, G = hgi, q ein beliebiger
Teiler der Gruppenordnung d = #G. Die Erfolgsrate von C über G, die q respektiert, ist
gegeben durch
σC ,q :=
1
· #{x ∈ G | bei Eingabe x tritt eine Kollision auf, die q respektiert}.
d
Es gilt stets 0 ≤ σC ,q ≤ 1 und für q1 | q2 | d folgt σC ,q1 ≤ σC ,q2 .
Beispiel 3.26. Der Baby-Schritt-Riesen-Schritt Algorithmus 3.2 hat die Erfolgsrate σC ,d = 1,
denn er findet immer eine (nichttriviale) Kollision, mit deren Hilfe sich der diskrete Logarithmus berechnen lässt.
Lemma 3.27. Sei d ≥ 2 und pe eine Primpotenz mit pe | d sowie τ = c1 · t + c0 ∈ Z[t] mit
τ 6≡ 0 mod pe . Dann gilt:
#{a ∈ Zd | τ(a) ≡ 0 mod pe } ≤
d.h. das Polynom hat höchstens
d
p
d
,
p
Nullstellen in Zd .
Beweis. Sei a ∈ Zd . Wir unterscheiden zwei Fälle: τ 6≡ mod p und τ ≡ 0 mod p.
3.9. ARITHMETISCHE SCHALTKREISE
51
τ 6≡ 0 mod p: Es gelte τ(a) ≡ 0 mod pe . Dann gilt insbesondere τ(a) ≡ 0 mod p und, da τ
nicht das Nullpolynom modulo p und Z p ein Körper ist, ist dies die einzige Nullstelle
modulo p. Jede Nullstelle von τ in Zd wird also vermöge der Restklassenabbildung
Zd → Z p ,
k mod d 7→ k mod p,
auf die eine Nullstelle modulo p abgebildet. In Zd gibt es
d
p
viele solcher Elemente.
τ ≡ 0 mod p: Sei i ∈ N der größte Exponent mit τ ≡ 0 mod pi . Da τ modulo pe nicht das
Nullpolynom ist, finden wir c00 , c01 ∈ Zd/pi von denen mindestens ein Element modulo
pe−i nicht verschwindet mit
τ = pi · (c01 · t + c00 ).
Würden c00 , c01 modulo pe−i verschwinden, so wäre τ ≡ 0 mod pe im Widerspruch zu
unserer Voraussetzung.
Gilt c01 ≡ 0 mod p, so gibt es kein a ∈ Zd mit τ(a) ≡ 0 mod pi+1 und damit insbesondere auch keine Nullstelle modulo pe (jede Nullstelle modulo pe führt insbesondere auf die Existenz einer Nullstelle modulo pi+1 ).
Nehmen wir nämlich an, es gäbe a ∈ Zd mit τ(a) ≡ 0 mod pi+1 , so folgte pi+1 |
pi · (c01 · a + c00 ). Wegen p | c00 folgt daraus pi+1 | pi · c01 · a und pi+1 | pi · (c01 · a + c00 ),
also p | c00 . Es folgt p | c00 und p | c01 . Damit erhalten wir aber pi+1 | pi · (c01 ·t + c00 ),
also τ ≡ 0 mod pi+1 , was der Maximalität von i widerspricht.
Gilt c01 6≡ 0 mod p, so gibt es modulo p genau eine Nullstelle, nämlich −c00 · c−1
1 ,
da Z p ein Körper ist. Damit ergibt sich das gleiche Ergebnis wie im zuvor behandelten Fall.
Damit ist das Lemma bewiesen.
Das folgende Theorem werden wir nur teilweise beweisen, da der vollständige Beweis eher
technischer Natur ist. Es zeigt uns die gewünschten unteren Laufzeitschranken für generische
Algorithmen zur Berechnung des diskreten Logarithmus:
Theorem 3.28. Sei G = hgi eine zyklische Gruppe der Ordnung d und q := pe eine Primpotenz mit q|d. Sei ferner C ein arithmetischer Schaltkreis über G der Länge l und σC ,q seine
Erfolgsrate über G, die q respektiert. Dann gilt:
p
(i) l ≥ 2 · σC ,q · p − 3
(ii) Ist n := blog2 dc + 1 die Binärlänge der Gruppenordnung von G und σC ,d = 1, so gilt
für d ≥ 3: l ≥ 2n − 2.
(iii) Aus (i) und (ii) erhalten wir: Ist p der größte Primteiler von d, e die Vielfachheit von
p in d, d.h. pe |d aber pe+1 6 |d, so hat jeder arithmetische Schaltkreis C über G mit
√
σC ,pe = 1 eine Länge l ≥ max{ 2 · p − 3, n/2 − 2}.
52
KAPITEL 3. DISKRETE LOGARITHMEN
Beweis. Zur Vorgehensweise: Wir zeigen eine obere Schranke für σC ,d in Termen von l und
p. Dies liefert dann die gewünschte untere Schranke für l in Termen von σC ,d und p.
Bei Eingabe eines Elementes x ∈ G produziert C eine Kollision der yi (x) = y j (x) mit −2 ≤ i <
j ≤ l. Es gibt (l+2)·(l+3)
Paare (i, j) mit −2 ≤ i < j ≤ l. Jedes dieser Paare führt nach obigem
2
Lemma zu maximal d/p Kollisionen, die q = pe respektieren. Damit ist die Gesamtzahl der
Kollisionen nach oben beschränkt durch (l+2)·(l+3)
· dp und damit
2
σC ,q ≤
(l + 2) · (l + 3)
,
2· p
also
(l + 3)2 ≥ (l + 2) · (l + 3) ≥ 2 · σC ,q · p,
woraus die Behautpung unter (i) folgt.
Sind wir jedoch genau, so müssen zugeben, dass auch der Algorithmus von Pollard 3.11 nicht
in das Algorithmen-Modell des arithmetischen Schaltkreises passt, denn es werden Zufallswahlen im Algorithmus gemacht. Die zufällige Wahl von Werten ist im Modell des (deterministischen) arithmetischen Schaltkreises nicht vorgesehen. Wir werden im nächsten Abschnitt
sehen, dass wir ruhig zufällige Wahlen in unserem Rechenmodell zulassen können: Die untere Schranke für die generischen Algorithmen zur Berechnung des diskreten Logarithmus
bleibt weiterhin gültig.
3.9.2
Probabilistische arthmetische Schaltkreise
Wir werden nun eine weitere Operation innerhalb eines Schalkreises erlauben: Unsere Schaltkreise dürfen von nun an auch einen Bit-Sring der Form b = (b1 , . . . , br ) ∈ {0, 1}r benutzen,
b
um Rechenoperationen der Form yk := yi j für ein i < k und 1 ≤ j ≤ r auszuführen. Dieser
Rechenschritt erlaubt im wesentlichen die Simulation der Wahl eines zufälligen Exponenten
e für ein Gruppenelement x ∈ G zur Berechnung von xe (durch geschickte Kombination solcher Rechenschritte lassen sich derartige Zufallselemente berechnen). Für die entsprechenden
Spur-Exponenten gilt dann τk = b j · τi .
Definition 3.29. Ein probabilistischer arithmetischer Schaltkreis ist ein Paar der Form C =
(Cr , u), wobei u eine Wahrscheinlichkeitsverteilung auf {0, 1}r ist und Cr ein arithmetischer
b
Schaltkreis ist, in dem zusätzlich die Operation yk := yi j für ein i < k und 1 ≤ j ≤ r erlaubt
ist. Die Länge von C ist die Anzahl der ausgeführten Gruppenoperationen. Operationen der
b
Form yk := yi j (also die zufälligen Operationen) werden dabei nicht mitgezählt. Ist b ∈ {0, 1}r
gegeben, so erhalten wir einen (festen) arithmetischen Schaltkreis C (b) der Länge l, indem
b
wir für alle Operationen yk = yi j den speziellen Wert b j ∈ {0, 1} einsetzen. Für einen Teiler
q von d = #G, G = hgi eine zyklische Gruppe, ist die Erfolgsrate von C , die q respektiert,
gegeben durch
σC ,q := ∑ u(b) · σC (b),q ,
b∈{0,1}r
3.9. ARITHMETISCHE SCHALTKREISE
53
d.h. σC ,q ist die durchschnittliche Erfolgsrate von C (b).
Mit dieser neuen Bezeichnungsweise erhalten wir:
Theorem 3.30. Sei G = hgi eine zyklische Gruppe der Ordnung d, q := pe eine Primpotenz
mit q | d, d = #G. Sei ferner C ein probabilistischer arithmetischerp
Schaltkreis über G der
Länge l und σC ,q seine Erfolgsrate, die q respektiert. Dann gilt: l ≥ 2 · σC ,q · p − 3.
Kapitel 4
Einige Kryptosysteme
4.1
Vorbemerkungen
In diesem Kapitel werden einige der bekanntesten Kryptosysteme vorgestellt, darunter: Rijndael, RSA, das sogenannte Diffie-Hellman-Schlüsselaustauschverfahren und das darauf beruhende Kryptosystem von ElGamal.
4.1.1
Symmetrische und Asymmetrische Kryptosysteme
Man unterscheidet grob sogenannte symmetrische und asymmetrische Kryptosysteme. Symmetrische Kryptosysteme zeichnen sich dadurch aus, dass Sender und Empfänger den gleichen privaten (d.h. geheimen) Schlüssel benutzen, um Nachrichten zu ver- bzw. zu entschlüsseln. Im Gegensatz dazu benötigt in sogenannten asymmetrischen Kryptosystemen
(oder auch Public Key Kryptosystemen) nur der Empfänger einen geheimen Schlüssel.
Ein offensichtlicher Nachteil symmetrischer Kryptosysteme ist damit die Tatsache, dass sich
die Parteien, die miteinander kommunizieren möchten, auf einen gemeinsamen (geheimen)
Schlüssel zum Ver- und Entschlüsseln von Nachrichten einigen müssen. Es muss eine sichere Möglichkeit gefunden werden, einen solchen Schlüssel auszutauschen. Einer der Vorteile
symmetrischer Kryptosysteme ist dagegen i.a. ihre hohe Effizienz. So kann z.B. das symmetrische Kryptosystem Rijndael (siehe Seite 56) effizient in Hardware implementiert werden
(und wurde von seinen Erfindern auch unter diesem Aspekt entwickelt). Ein weiterer Vorteil von symmetrischen Kryptosystemen ist die Tatsache, dass sich der Empfänger einer verschlüsselten Nachricht, wenn er diese mit seinem geheimen Schlüssel entschlüsseln konnte,
über die Identität des Absenders weitestgehend im Klaren sein kann (es sei denn, der geheime
Schlüssel ist unbemerkt in die Hände böswilliger Dritter gelangt, die ihn nun dazu verwenden,
Falschmeldungen oder Fehlinformationen etc. an den Empfänger zu senden).
Bei asymmetrischen Kryptosystemen, in denen jede beliebige Person mit einem öffentlichen
Schlüssel Nachrichten an den Empfänger verschlüsseln und an ihn versenden kann, ist der
Aspekt der Authentifizierung des Absenders in der Regel nicht gegeben. Ein Beispiel für ein
54
4.1. VORBEMERKUNGEN
55
solches asymmetrisches Kryptosystem, in dem eine zusätzliche Authentifizierung notwendig
wird, ist das RSA-Verfahren (siehe Seite 61).
Sowohl symmetrische als auch asymmetrische Kryptosysteme werden in der Praxis verwendet. Häufig geht man so vor, dass man ein asymmetrisches Kryptosystem dazu verwendet,
einen gemeinsamen geheimen Schlüssel für ein symmetrisches Kryptosystem sicher unter
den kommuzierenden Parteien auszutauschen. Anschließend wird dann die Kommunikation
über (effizientere) symmetrische Kryptosysteme geführt.
4.1.2
Alice, Bob und Eve
Sender und Empfänger werden traditioneller Weise stets mit den Namen Alice und Bob versehen. Alice und Bob kommunizieren über einen offenen Kanal (z.B. das Internet) und Bob
möchte Alice eine Nachricht übersenden derart, dass eine dritte, böswillige Person Eve, die
den Kanal abhört, die Nachricht nicht verstehen kann. Die bezeichnende Vorgehensweise ist
dann die folgende: Bob möchte Alice eine Nachricht x schicken. Dazu benutzt Bob eine Verschlüsselungsfunktion encK (Encryption), mit deren Hilfe er ein y := encK (x) erzeugt. K bezeichne dabei den Schlüssel, den Bob zum Verschlüsseln der Nachricht benutzt. Dann schickt
Bob y an Alice und (vorausgesetzt die Nachricht y wird bei der bloßen Übermittlung nicht
verfälscht) Alice kann dann mit Hilfe einer Funktion decS (Decryption) aus y den Klartext
x = decS (y) berechnen, wobei S ihren privaten Schlüssel zum Entschlüsseln von Nachrichten
bezeichnet. Schematisch ergibt sich also der folgende Ablauf:
Bob sendet y
Bob berechnet y = encK (x) −−−−−−→ Alice berechnet x = decS (y)
Eve hört mit
Folgende Voraussetzungen sollte man vernünftigerweise verlangen:
1. Bob kann die Nachricht effizient (d.h. in polynomieller Zeit in der Codierungslänge der
Eingabe für seine Verschlüsselungsfunktion decK ) verschlüsseln
2. Eve kann den Wert von y = encK (x) zwar abhören, sollte jedoch nicht in der Lage sein,
ohne Kenntnis der Funktion decS (die von Alice geheim gehalten werden muss – genauer gesagt muss Alice ihren privaten Schlüssel S geheim halten) x aus y in polynomieller
Zeit berechnen zu können
3. Alice kann mit Hilfe von decS effizient aus y den Wert x berechnen
Was genau unter effizient zu verstehen ist, was es bedeutet, dass Eve die Nachricht nicht in
polynomieller Zeit entschlüsseln können sollte und vieles mehr wird später genauer formalisiert werden.
4.1.3
“Block Ciphers” und “Stream Ciphers”
Neben dem großen Unterschied “symmetrische versus asymmetrische Kryptosysteme” unterscheidet man zwischen sogenannten Block Ciphers und Stream Ciphers. Wir werden im folgenden nur Block Ciphers betrachten, d.h. wir gehen davon aus, dass eine zu verschlüsselnde
56
KAPITEL 4. EINIGE KRYPTOSYSTEME
Nachricht x bereits in Blöcke x = x1 , x2 , . . . , xi−1 , xi , xi+1 , . . . , xl einer festen Länge n unterteilt wurde und beschäftigen uns nur damit, wie man einen festen Block xi der Länge n verschlüsseln kann. Als Stream Ciphers werden Kryptosysteme bezeichnet, die sozusagen “on
the fly” und ohne Kenntnis der Länge der zu verschlüsselnden Nachricht den Datenstrom verarbeiten. Bei Block Ciphers gibt es verschiedene Möglichkeiten, die verschlüsselten Daten
zu erzeugen:
Electronic Codebook (ECB): Die Nachricht
x = x1 , x2 , . . . , xi−1 , xi , xi+1 , . . . , xl
wird schlicht blockweise verschlüsselt:
encK (x) = encK (x1 ), . . . , encK (xi−1 ), encK (xi ), encK (xi+1 ), . . . , encK (xl )
Diese Vorgehensweise ist gefährlich, wenn standardisierte Datenformate übertragen
werden und Eve z.B. den Block mit den für sie relevanten Informationen explizit ausmachen und angreifen kann.
Cipher Block Chaining (CBC): Es wird ein Startblock z0 der Länge n vorgewählt und
der i-te Block wird vermöge der Vorschrift
zi := encK (xi ⊕ zi−1 )
verschlüsselt. Hier ist die Gefahr der Fehlerfortpflanzung jedoch gegeben ebenso wie
bei den folgenden beiden Methoden.
Output Feedback (OFB): Es wird ein Startblock x0 der Länge n vorgewählt und der
i-te Block wird vermöge der Vorschrift
zi := xi−1 ⊕ encK (xi )
verschlüsselt.
Auto-Key (AU): Man verwendet den Klartext selbst als Schlüssel, d.h.
z1 := encK (x1 ) und
zi := encxi−1 (xi )
für alle i ≥ 2.
4.2
Rijndael
Das Kryptosystem Rijndael ist nach seinen Erfindern Vincent Rijmen und Joan Daemen benannt bzw. sein Name ist eine Fusion aus den Namen der beiden Erfinder. Es wurde im Oktober 2000 zum sogenannten Advanced Encryption Standard erklärt. Rijndael ist ein symmetrisches Kryptosystem, d.h. Ver- und Entschlüsselung von Nachrichten wird mit dem gleichen
Schlüssel erledigt. Mit anderen Worten im Rahmen unseres Modells: Wir haben encK = decS
mit K = S und K = S wird sowohl von Alice als auch von Bob geheimgehalten. Um die
eigentliche Verschlüsselungsroutine beschreiben zu können, bedarf es einiger algebraischer
Vorbereitungen.
4.2. RIJNDAEL
4.2.1
57
Algebraische Grundlagen
Der Klartext, den es mit Rijndael zu verschlüsseln gilt, wird zunächst in Vierer-Blöcke
[a00 , a10 , a20 , a30 ], [a01 , a11 , a21 , a31 ], . . . unterteilt, wobei jedes der ai j ein 8-Bit Byte der Form
(i j)
(i j)
ai j = (b7 , . . . , b0 ) ∈ {0, 1}8 codiert. Um die Notation nicht unnötig zu verkomplizieren,
schreiben wir im folgenden einzelne Bytes in der Form a = (a7 , . . . , a0 ), b = (b7 , . . . , b0 ) ∈
{0, 1}8 . Die grundlegenden Operationen, die auf solchen Bytes durchgeführt werden, sind
Addition und Multiplikation.
Die Addition zweier Bytes beschränkt sich auf das komponentenweise exklusive Oder “xor”.
Zur Multiplikation zweier solcher Elemente werden diese als Polynome über dem Körper
F28 = F256 = F2 [x]/(m) für das irreduzible Polynom m := x8 + x4 + x3 + x + 1 ∈ F2 [x] vom
Grad 8 interpretiert: Das Byte a = (a7 , . . . , a0 ) repräsentiert das Polynom a7 x7 + . . . + a1 x +
a0 ∈ F2 [x].
Zur Multiplikation zweier Bytes a und b multipliziert man schlicht die durch a und b beschriebenen Polynome in F2 [x] und erhält auf diese Weise ein Polynom vom Grad höchstens
14, welches sich dann mit Hilfe von Division mit Rest durch das irreduzible Polynom m vom
Grad 8 auf ein Polynom in F2 [x]/(m) reduzieren lässt. Letzteres Polynom kann dann wieder
problemlos als Element von {0, 1}8 aufgefasst werden. Das multiplikative Inverse eines Bytes a erhält man, indem man das zu a gehörige Polynom in F256 invertiert. Hierzu verwendet
man den Erweiterten Euklidischen Algorithmus. Zusätzlich wird die Inversenbildung auf alle
Elemente von F256 fortgesetzt, indem man schlicht das Inverse des 0-Bytes als das 0-Byte
selbst definiert.
Neben dem Körper mit 256 Elementen betrachtet man als weitere algebraische Struktur den
Ring R := F2 [x]/(x8 + 1). R ist kein Körper, da (x + 1)8 = x8 + 1 in F2 [x] und damit x8 + 1
kein irreduzibles Polynom über F2 [x] ist. Ein Byte a wird wieder als Polynom der Form
a7 x7 + . . . + a1 x + a0 mod x8 + 1 ∈ R aufgefasst. Multiplikation und Addition von Polynomen
in R sind in der üblichen Weise definiert (nur dass eben nicht jedes Element ein multiplikatives
Inverses besitzt, sondern nur diejenigen Elemente von R, deren Repräsentanten teilerfremd
zu x8 + 1 sind). R zeichnet sich jedoch dadurch aus, dass die Multiplikation zweier Elemente
a, b ∈ R sehr effizient durchgeführt werden kann. Man berechnet das Produkt von a und b
interpretiert als Polynome in F2 [x] und reduziert das Ergebnis wie üblich modulo x8 + 1.
Die Reduktion modulo x8 + 1 ist denkbar einfach: Es gilt xi = xq·8+r = (x8 )q · xr mit q ∈ N,
0 ≤ r < 8 und damit xi − xr = xr · ((x8 )q − 1) = xr · (x8 + 1)q in F2 [x]. Wir erhalten also:
xi ≡ xi mod 8 mod x8 + 1. Schreibt man nun das Produkt zweier Polynome a · b = c in der Form
c = c1 · x8 + c0 , wobei c0 , c1 Polynome vom Grad höchstens 7 sind, so beschränkt sich die
Reduktion modulo x8 + 1 auf die Addition der beiden Polynome c0 und c1 .
In Rijndael beschränken sich Multiplikationen im wesentlichen auf Multiplikationen mit fest
vorgegebenen Polynomen, die dann so gewählt werden, dass sie sowohl in F256 als auch
in R invertierbar sind (andernfalls wäre die Entschlüsselung einer Botschaft anschließend
u.U. problematisch).
Zu Beginn hatten wir bemerkt, dass der zu verschlüsselnde Klartext zunächst in eine Folge
von Blöcken der Form [a00 , a10 , a20 , a30 ], [a01 , a11 , a21 , a31 ], . . . unterteilt wird. Desweiteren
58
KAPITEL 4. EINIGE KRYPTOSYSTEME
haben wir mit dem Körper F256 und dem Ring R diejenigen algebraischen Strukturen kennen(i j)
(i j)
gelernt, in denen in Rijndael Operationen auf 8-Bit Bytes der Form ai j = (b7 , . . . , b0 ) ∈
{0, 1}8 realisiert werden. Neben der Tatsache, dass man einzelne Bytes als Polynome interpretiert, werden auch die oben angedeuteten “4er-Blöcke” der Form [a0 j , a1 j , a2 j , a3 j ], j ∈ N
als Polynome a3 j y3 + a2 j y2 + a1 j y + a0 j ∈ S := F256 [y]/(y4 + 1) aufgefasst. Multiplikation
und Addition von Polynomen in S sind wiederum wie üblich definiert und wir erhalten wieder yi ≡ yi mod 4 mod y4 + 1, was die Multiplikation wie schon im Fall des Rings R denkbar
einfach macht.
4.2.2
Einiges zur Spezifikation
Bevor wir zu einigen Details der Verschlüsselung von Nachrichten mit Rijndael kommen noch
einige Bemerkungen zur Spezifikation: Der zu verschlüsselnde Klartext wird – wie oben bereits erwähnt – in Teilstücke der Form [a00 , a10 , a20 , a30 ], [a01 , a11 , a21 , a31 ], . . . zerlegt. Diese
Teilstücke werden nun in Blöcken der Form


a00 a01 a02 · · ·
 a10 a11 a12 · · · 


 a20 a21 a22 · · · 
a30 a31 a32 · · ·
“verarbeitet”, wobei die Spalten eines Blocks der obigen Form gerade aus den bereits im
vorherigen Abschnitt betrachten Teilstücken von jeweils 4 × 8-Bit-Bytes bestehen. Rijndael
erlaubt dabei, dass die obigen Blöcke 4, 6 oder 8 Spalten (die sogenannten Blocklänge) enthalten. Zu jedem solchen Block wird ein entsprechender Schlüssel


k00 k01 k02 · · ·
 k10 k11 k12 · · · 


 k20 k21 k22 · · · 
k30 k31 k32 · · ·
gleicher Gestalt erzeugt (für Details zur zugelassenen Wahl von Blocklängen verweisen wir
auf [7] oder [8]). Im folgenden wollen wir als eine der möglichen zugelassenen Blocklängen
den Wert 4 zugrundelegen, d.h. wir haben es mit Blöcken der Form


a00 a01 a02 a03
 a10 a11 a12 a13 


 a20 a21 a22 a23 
a30 a31 a32 a33
zu tun.
4.2.3
Verschlüsselung von Nachrichten mit Rijndael
Die Verschlüsselung eines Klartextes mit Rijndael erstreckt sich über mehrere Runden (für
Details zu empfohlenen Anzahlen von Runden verweisen wir auf [7] oder [8]). Jede Runde
4.2. RIJNDAEL
59
besteht aus vier grundlegenden Operationen, die nacheinander in der folgenden Reihenfolge
abgearbeitet werden:
1. ByteSub (nichtlineare Operation auf einzelnen Bytes)
2. ShiftRow (zyklischer Shift der Zeilen eines Blocks)
3. MixColumn (Operation auf den Spalten eines Blocks)
4. AddRoundKey (Addition des Rundenschlüssels mittels exklusivem Oder)
Zu 1. Die Operation ByteSub wird auf einzelnen 8-Bit-Bytes a = (a7 , . . . , a0 ) ∈ {0, 1}8
durchgeführt:
a :=a−1
in F256
a :=t1 · a
in R für ein invertierbares Polynom t1 vom Grad ≤ 7
a :=a + t0
in F2 [x] für ein Polynom t0 vom Grad ≤ 7
Die letzten beiden Operationen können als affine lineare Transformation interpretiert
werden, wenn man die Koeffizientenvektoren der betrachteten Bytes zugrundelegt: Die
Operation a := t1 · a + t0 wird in der Form c := A · a + b für eine 8 × 8 Matrix A und
einen 8 × 1 Vektor b über F2 implementiert. ByteSub überführt insgesamt Blöcke der
Form




a00 a01 a02 a03
c00 c01 c02 c03
 a10 a11 a12 a13 



 in Blöcke der Form  c10 c11 c12 c13 
 a20 a21 a22 a23 
 c20 c21 c22 c23 
a30 a31 a32 a33
c30 c31 c32 c33
wobei die Operationen selbst auf jedes einzelne Byte ai j angewandt werden und dieses
in das entsprechende Byte ci j überführen. Damit ist ByteSub eine hochgradig nichtlineare Operation auf den jeweils zu betrachtenden Blöcken dar.
Zu 2. Die Operation ShiftRow shiftet die Zeilen eines jeden Blocks (man stelle sich vor,
dass zuvor auf den angegebenen Block die Operation ByteSub angewandt wurde)


a00 a01 a02 a03
 a10 a11 a12 a13 


 a20 a21 a22 a23 
a30 a31 a32 a33
zyklisch. Die erste Zeile wird nicht verschoben, für die zweite, dritte und vierte Zeile
werden spezielle Werte s2 , s3 , s4 empfohlen (siehe [7]). Im Fall s2 = 1, s3 = 2 und s4 = 3
ergibt sich der Block


a00 a01 a02 a03
 a13 a10 a11 a12 


 a22 a23 a20 a21 
a31 a32 a33 a30
60
KAPITEL 4. EINIGE KRYPTOSYSTEME
Damit bewirkt die Operation ShiftRow bei einer hohen Anzahl von insgesamt durchgeführten Runden eine hohe Permutation der Komponenten eines Blockes, die durch
die anschließende Anwendung der Operation MixColumn noch weiter verstärkt wird.
Zu 3. Die Operation MixColumn wird nun auf den Spalten eines Blocks (auf den zuvor die
Operationen ByteSub und ShiftRow angewandt wurden)


a00 a01 a02 a03
 a10 a11 a12 a13 


 a20 a21 a22 a23 
a30 a31 a32 a33
durchführt. Technisch wird MixColumn realisiert, indem jede Spalte als entsprechendes Polynom a3 j y3 + a2 j y2 + a1 j y + a0 j ∈ S = F256 [y]/(y4 + 1) aufgefasst wird und
mit einem in S invertierbaren Polynom c multipliziert wird. Auch diese Operation
kann mit Hilfe einer speziellen Matrixmultiplikation realisiert werden. Zusammen mit
ShiftRow bewirkt MixColumn eine “wilde” Permutation der Blöcke auf Zeilen und
Spalten.
Zu 4. Im Rahmen der Operation AddRoundKey wird nun zu jedem Block ein Schlüsselblock
(der sogenannte Rundenschlüssel) gleichen Formats mit Hilfe des exklusiven Oders auf
allen Komponenten addiert:


a00 ⊕ k00 a01 ⊕ k01 a02 ⊕ k02 a03 ⊕ k03
 a10 ⊕ k10 a11 ⊕ k11 a12 ⊕ k12 a13 ⊕ k13 


 a20 ⊕ k20 a21 ⊕ k21 a22 ⊕ k22 a23 ⊕ k23 
a30 ⊕ k30 a31 ⊕ k31 a32 ⊕ k32 a33 ⊕ k33
Damit ist die Operation AddRoundKey zu sich selbst invers. Die Rundenschlüssel werden aus dem privaten Schlüssel generiert, der von den Benutzern des Systems geheim
gehalten wird. Der geheime Schlüssel S besteht aus einem Block der Form


s00 s01 s02 s03
 s10 s11 s12 s13 

S=
 s20 s21 s22 s23 
s30 s31 s32 s33
Dieser Schlüssel ist frei wählbar, dagegen die Rundenschlüssel nicht: Sie werden
auf der Grundlage von S mit ähnlichen Operationen wie den in der Verschlüsselung verwendeten Operationen erzeugt. Für jedes si j ∈ F256 gibt es 256 verschiedene
Wahlmöglichkeiten. Damit beläuft sich die Anzahl der möglichen privaten Schlüssel
auf 25616 = 2128 .
In der letzten Runde wird die Operation MixColumn nicht durchgeführt. Rijndael gilt zum
jetzigen Zeitpunkt als resistent gegen alle derzeitig bekannten Angriffe.
4.3. DAS RSA-VERFAHREN
4.3
61
Das RSA-Verfahren
Das RSA-Kryptosystem ist nach seinen Erfindern R. L. Rivest, A. Shamir und L. M. Adleman benannt. Es handelt sich bei diesem Verfahren um ein asymmetrisches oder Public-KeyKryptosystem. Der Ablauf des RSA-Verfahrens wird wieder in unserem Model als Kommunikation zwischen Alice und Bob formuliert. Wenn Bob an Alice eine mit RSA verschlüsselte
Nachricht, die wir uns als natürliche Zahl vorstellen, schicken möchte gehen beide nach dem
folgenden Protokoll vor:
Protokoll 4.1. (Das RSA-Verfahren) Gegeben sei ein Sicherheitsparameter n ∈ N. Bevor
Alice und Bob miteinander kommunizieren können, trifft Alice die folgenden Vorbereitungen:
(1) Alice wählt zufällig zwei verschiedene Primzahlen p und q im Intervall [d2
n−1
2
n
e, b2 2 c].
(2) Sie berechnet N := p · q und ϕ(N) = (p − 1) · (q − 1).
(3) Dann wählt sie e ∈R {2, . . . , ϕ(N) − 2} mit ggT(e, ϕ(N)) = 1.
(4) Alice bestimmt d mit e · d ≡ 1 mod ϕ(N).
(5) Schließlich veröffentlicht sie K := (N, e) als ihren öffentlichen Schlüssel und hält das
Paar S := (N, d) geheim.
(6) Die Werte p, q und ϕ(N) löscht Alice.
Angenommen Bob möchte an Alice die Nachricht x mit x ∈ {0, . . . , N − 1} schicken:
(7) Bob berechnet y := xe mod N und schickt y an Alice.
Alice kann dann die Nachricht y wie folgt entschlüsseln:
(8) Alice berechnet x? := yd mod N.
Dann gilt x? = x.
Beweis. (Korrektheit) Wir müssen x? = x zeigen. Ist x ∈ Z×
N , so folgt die Behauptung unmittelbar aus dem Satz von Euler 1.55 und e · d ≡ 1 mod ϕ(N), denn ist e · d − 1 = k · ϕ(N) für
ein k ∈ N, so folgt: x? ≡ xe·d ≡ xe·d−1 · x ≡ (xϕ(N) )k · x ≡ 1 · x ≡ x mod N. Für ein allgemeines
x ∈ ZN gilt ebenso xe·d ≡ xe·d−1 · x ≡ xk·ϕ(N) · x ≡ xk·(p−1)·(q−1) · x mod N. Wir erhalten also
xe·d ≡ (x(p−1) )k·(q−1) · x ≡ x mod p und xe·d ≡ (x(q−1) )k·(p−1) · x ≡ x mod q, wobei die Identitäten für x ≡ 0 mod p und x ≡ 0 mod q trivialerweise richtig sind und für x 6≡ 0 mod p und
x 6≡ 0 mod q aus dem kleinen Satz von Fermat 1.56 folgen. Da p und q teilerfremd sind und
beide xe·d − x teilen, folgt auch N | xe·d − x, also xe·d − x ≡ 0 mod N und damit die Behauptung.
62
4.3.1
KAPITEL 4. EINIGE KRYPTOSYSTEME
Der Angriff von Wiener auf RSA
In Protokoll 4.1 zum RSA-Verfahren ist Alice in Schritt (3) so vorgegangen, dass sie zunächst
den öffentlichen Exponenten e ∈R {2, . . . , ϕ(N) − 2} gewählt und dann in Schritt (4) den
privaten Exponent d als modulares Inverses von e modulo ϕ(N) bestimmt hat. Bei einer
zufälligen Wahl von e auf diese Weise, werden sowohl e als auch d erwartungsgemäß sehr
große Zahlen sein.
Bob, der Nachrichten verschlüsseln und an Alice verschicken möchte, benutzt dann den
öffentlichen Schlüssel e, während Alice die empfangenen Nachrichten mit Hilfe von d entschlüsselt. Stellen wir uns vor, Alice wäre nichts weiter als eine personifizierte Smart-Card
mit sehr geringer Rechenkapazität. Dann könnte Alice auf die Idee kommen, zuerst ein sehr
kleines d zu wählen und dann den Wert von e entsprechend als modulares Inverses von d
modulo ϕ(N). Auf diese Weise hätte sich Bob mit einem potentiell sehr großen Exponenten e
zum Verschlüsseln einer Nachricht “abzuquälen” und Alice hätte mit einem kleinen Wert für
d nur vergleichsweise wenige Operationen zum Entschlüsseln einer Nachricht auszuführen.
1
Geht Alice jedoch auf die beschriebene Weise vor und wählt sie d < 13 N 4 , so werden wir
im folgenden zeigen, dass Eve mit Hilfe der im Abschnitt über Kettenbrüche (siehe Seite
21) erarbeiteten Theorie den privaten Schlüssel d von Alice in polynomieller Zeit berechnen
kann.
Lemma 4.2. Es sei N = p · q, wobei p, q Primzahlen seien mit q < p < 2 · q. Weiter seien
1
e, d ∈ Zϕ(N) mit e·d ≡ 1 mod ϕ(N) und k ∈ N mit e·d −1 = k ·ϕ(N). Schließlich sei d < 13 ·N 4 .
Dann gilt: Ne − dk < 2·d1 2 .
2
Beweis.
√ Es gilt N − ϕ(N) =
√ p · q − (p − 1) · (q − 1) = p + q −
√ 1. Es gilt q < p · q = N, also
q < N und p < 2 · q < 2 · N. Damit folgt: N − ϕ(N) < 3 · N. Nun gilt
=1
z
}|
{
e k e · d − k · N e · d − k · ϕ(N) −k · N + k · ϕ(N) − =
=
N d
N ·d
N ·d
√
1 − k · (N − ϕ(N)) 3 · k · N
3·k
=
= √
<
N ·d
N ·d
d· N
1
Wegen k · ϕ(N) = e · d − 1 < e · d und e < ϕ(N) folgt k < d, also k < 13 · N 4 . Wir erhalten:
1
e k
N4
1
− < √ =
1
N d
d· N
d ·N4
1
und wegen N 4 > 3 · d gerade
1
d ·N
womit die Behauptung bewiesen ist.
1
4
<
1
1
<
,
3 · d2 2 · d2
4.4. DIFFIE UND HELLMAN SCHLÜSSELAUSTAUSCHVERFAHREN
63
Wegen e · d − k · ϕ(N) = 1 folgt, dass ggT(k, d) = 1. Theorem 1.50 liefert nun in der Situation
des obigen Satzes, dass dk eine Konvergente der Kettenbruchentwicklung von Ne ist. Da die
Konvergenten sowohl effizient berechnet werden können und es nur O(log2 (N)) viele solcher
Konvergenten von Ne gibt (letzteres folgt aus der Tatsache, dass der Erweiterte Euklidische
Algorithmus 1.15 bei Eingabe e, N nach Theorem 1.17 nur O(log2 N) Wiederholungen von
Schritt (2) benötigt), kann Eve damit durch Ausprobieren aller Konvergenten in polynomieller Zeit den privaten Schlüssel d von Alice berechnen.
Eve kann sogar noch mehr als nur d zu berechnen: Sie kann die Zahl N in polynomieller Zeit
faktorisieren. Betrachte dazu das Polynom f (x) := x2 − (p + q) · x + p · q. Dieses Polynom
besitzt genau zwei Nullstellen, nämlich x1 = p und x2 = q. Mit Hilfe der aus der Schule
bekannten Formel findet sich eine geschlossene Darstellung dieser beiden Lösungen über
r
r
(p + q)2
(p + q)2
p+q
p+q
x1/2 =
±
− p·q =
±
−N
(∗)
2
4
2
4
Mit anderen Worten: Kennt Eve den Wert p+q, so kann sie in polynomieller Zeit die Nullstellen von f (x), d.h. p und q, berechnen und die Zahl N faktorisieren. Eine Darstellung für die
Summe p + q findet sie jedoch in der obigen Situation sehr leicht: Wegen e · d − 1 = k · ϕ(N)
kennt sie ϕ(N) = e·d−1
k . Wegen ϕ(N) = (p − 1) · (q − 1) = p · q − p − q + 1 = N − (p + q) + 1
erhält sie p + q = N − ϕ(N) + 1. Eve ist N − ϕ(N) + 1 in der Situation von oben sehr wohl
bekannt, weshalb sie durch Einsetzen des Wertes in (∗) die Primfaktoren p und q von N leicht
bestimmen kann.
4.4
Das Schlüsselaustauschverfahren von Diffie und Hellman
Um einen Schlüsselaustausch für ein symmetrisches Kryptosystem wie z.B. Rijndael (siehe
Seite 56) zu ermöglichen, kann man sich z.B. des hier diskutierten Protokolls von W. Diffie
und M. E. Hellman bedienen. Für die im folgenden ganz allgemein gehaltene endliche zyklische Gruppe G = hgi der Ordnung d = #G sind diverse “Kandidaten” denkbar: Die zyklische
multiplikative Gruppe Z×
p der Einheiten modulo einer Primzahl p, die zyklische multiplikative Gruppe eines beliebigen Körpers F×
q oder etwa zyklische Untergruppen elliptischer
Kurven.
Protokoll 4.3. (Das Schlüsselaustauschverfahren von Diffie & Hellman) Sei G = hgi ein
endliche zyklische Gruppe der Ordnung d = #G. Alice und Bob erhalten dann wie folgt einen
gemeinsamen Schlüssel:
(1) Alice wählt ein sA ∈R {2, . . . , d − 1} und sendet x := gsA an Bob.
(2) Bob wählt ebenfalls ein sB ∈R {2, . . . , d − 1} und sendet y := gsB an Alice.
(3) Bei Erhalt von y berechnet Alice den gemeinsamen Schlüssel KA := ysA .
64
KAPITEL 4. EINIGE KRYPTOSYSTEME
(4) Bei Erhalt von x berechnet Bob den gemeinsamen Schlüssel KB := xsB .
Dann teilen sich Alice und Bob den gemeinsamen geheimen Schlüssel KA = KB .
Beweis. (Korrektheit) Es gilt KA = ysA = (gsB )sA = gsA ·sB = (gsA )sB = xsB = KB .
Die Effizienz des Verfahrens ist offensichtlich: Potenzieren erledigen Alice und Bob mit Hilfe
von “Repeated Squaring” 1.5. Damit sind alle Operationen in polynomieller Zeit – und damit
hinreichend effizient – durchführbar.
Bemerkung 4.4. Angenommen Eve würde den Kanal, auf dem Alice und Bob Nachrichten
austauschen, abhören. Dann sind ihr neben der öffentlich bekannten Gruppe G = hgi auch die
Werte x = gsA und y = gsB bekannt. Für Eve genügt es offensichtlich einen der beiden Werte
sA oder sB ausfindig zu machen. Um aus x und g den Wert sA berechnen zu können, muss Eve
dlogg x = dlogg gsA = sA berechnen, d.h. sie muss den diskreten Logarithmus von x in Basis
g bestimmen. Kann Eve also das Diskrete Logarithmus Problem in G lösen, so kann sie das
Diffie-Hellman-Protokoll brechen.
Das Diffie-Hellman-Problem (DHP) 4.5. Eve kann das Diffie-Hellman-Problem lösen,
wenn sie bei Kenntnis von G = hgi mit d = #G, x = gsA und y = gsB mit sA , sB ∈ {2, . . . , d − 1}
das Element gsA ·sB berechnen kann.
Das diskrete Logarithmus Problem (DLP) 4.6. Eve kann das diskrete Logarithmus Problem lösen, wenn sie bei Kenntnis von G = hgi mit d = #G und x = gk für ein k ∈
{2, . . . , d − 1} den Wert k = dlogg x berechnen kann.
Die obige Bemerkung besagt also nun:
DHP ≤ p DLP
d.h. DHP lässt sich in Polynomialzeit auf DLP reduzieren (oder mit anderen Worten: Das
Problem DHP ist nicht schwerer als das Problem DLP). Beide Probleme werden jedoch in
der Regel als “gleich schwer” angesehen.
4.4.1
“Woman-in-the-Middle” Angriff
Wir stellen uns nun vor, dass Eve keinesfalls nur passiv den Nachrichtenaustausch zwischen
Alice und Bob abhört, sondern dass sie selbst aktiv wird. Angenommen, Alice und Bob wollen über das Diffie-Hellman-Protokoll 4.3 einen gemeinsamen geheimen Schlüssel für ein
symmetrisches Kryptosystem austauschen. Eve geht nun wie folgt vor:
• Gegenüber Alice gibt sich Eve als Bob aus. Auf diese Weise kann sie in der Notation
von 4.3 mit Alice den gemeinsamen Schlüssel gsA ·sE (sE bezeichne Eve’s gewählten
Exponenten) austauschen.
4.5. DAS KRYPTOSYSTEM VON EL’GAMAL
65
• Gegenüber Bob gibt sich Eve als Alice aus. Auf diese Weise kann sie in der Notation
von 4.3 mit Bob den gemeinsamen Schlüssel gsB ·sE (hier kann Eve statt sE natürlich
auch einen anderen zufällig gewählten Exponenten benutzen) austauschen.
Will nun Alice eine Nachricht an Bob senden, so fängt Eve die Nachricht ab. Sie entschlüsselt
sie mit Hilfe des geheimen Schlüssels gsA ·sE und gibt die Nachricht anschließend in unter
Umständen modifizierter oder verfälschter Form an Bob weiter, indem sie sie mit dem geheimen Schlüssel gsB ·sE verschlüsselt und an Bob weitergibt.
Eve’s gelungener Angriff gelangt jedoch unmittelbar ans Tageslicht, wenn es Alice gelingt,
eine Nachricht direkt an Bob zu versenden, ohne dass Eve sie abfangen konnte. In diesem
Fall wird Bob in der Regel nicht in der Lage sein, die von Alice erhaltene Nachricht korrekt
zu entschlüsseln. Die Übertragung offensichtlich sinnloser Daten seitens Alice an Bob sollte
ihn skeptisch machen. Eve ist also gezwungen, als eine Art “Übersetzer” zwischen Alice und
Bob “Synchronübersetzungen” durchzuführen.
Schützen können sich Alice und Bob unter anderem dadurch, dass sie vor Benutzung des
Schlüssels, auf den sie sich geeinigt zu haben glauben, überprüfen, ob sie auch wirklich beide
den gleichen Schlüssel erhalten haben. Sicherlich können sie ihn aber nicht frei über den Kanal kommunizieren. Ein Ausweg, der den Angriff “Woman-in-the-middle” unmöglich macht,
ist, wenn Alice und Bob in der Lage sind, sich gegenseitig zu authentifieren (siehe Abschnitt
über Identifikation und Authentifikation, Seite 82).
4.5
Das Kryptosystem von El’Gamal
Das von El’Gamal 1985 entwickelte Kryptosystem, das wir in diesem Abschnitt kennenlernen
werden, basiert im wesentlichen auf dem Schlüsselaustauschverfahren von Diffie & Hellman.
El’Gamal schlug eine Erweiterung des Protokolls vor, die es nicht nur ermöglicht, einen geheimen gemeinsamen Schlüssel auszutauschen, sondern zusätzlich auch Nachrichten zu verbzw. entschlüsseln:
Protokoll 4.7. (Das Kryptosystem von El’Gamal) Sei G eine zyklische Gruppe mit erzeugendem Element g, d.h. G = hgi, sowie d = #G.
(1) Alice wählt ein sA ∈R {2, . . . , d − 1} und sendet x := gsA an Bob.
(2) Bob wählt ebenfalls ein sT ∈R {2, . . . , d − 1} und berechnet y := gsT (temporärer
Schlüssel für einen Nachrichtenaustausch).
(3) Bob möchte Alice die Nachricht m ∈ G übersenden. Er berechnet m̃ := m · xsT und
sendet (m̃, y) an Alice.
(4) Bei Erhalt von (m̃, y) berechnet Alice ysA und m = m̃ · (ysA )−1 .
Beweis. (Korrektheit) Die Korrektheit folgt aus der Korrektheit des Schlüsselaustauschverfahrens von Diffie & Hellman.
66
KAPITEL 4. EINIGE KRYPTOSYSTEME
Zur Effizienz ist zu sagen, dass das Kryptosystem von El’Gamal im wesentlichen die gleiche
Laufzeit wie das Schlüsselaustauschverfahren von Diffie & Hellman hat. Dazu kommen eine
weitere Multiplikation für Bob zum Verschlüsseln und eine Multiplikation sowie eine Inversion für Alice. All diese Operation sind in einer entsprechend gewählten Gruppe (z.B. Z×
p)
hinreichend effizient durchführbar.
Wir werden nun zeigen, dass das Brechen von Protokoll 4.7 sich polynomiell auf das DiffieHellman-Problem (DHP) reduzieren lässt und umgekehrt:
Satz 4.8. Unter den obigen Voraussetzungen erhalten wir:
(i) Das Brechen von Protokoll 4.7 lässt sich polynomiell auf DHP reduzieren.
(ii) DHP lässt sich polynomiell auf das Berechen von Protokoll 4.7 reduzieren.
Beweis. Angenommen, wir können DHP in Polynomialzeit lösen. Dann können wir in der
Notation von Protokoll 4.7 aus der Kenntnis von x = gsA und y = gsT den Wert gsA ·sT = ysA
berechnen. Da die Inversion von ysA in Polynomialzeit durchführbar ist, können wir den Klartext m aus m̃ ebenso wie Alice berechnen und damit das Protkoll brechen.
Können wir umgekehrt bei Kenntnis von x = gsA , y = gsT und m̃ = m · xsT = m · gsA ·sT den Wert
m in Polynomialzeit ermitteln, so erhalten wir den gemeinsamen Schlüssel gsA ·sT von Alice
und Bob, indem wir schlicht m̃ mit dem Inversen von m multiplizieren. Damit haben wir aber
DHP gelöst.
4.6
“Secret Sharing”
Angenommen, n Personen {1, . . . , n} möchten ein Geheimnis s untereinander aufteilen derart,
dass sie nur alle gemeinsam das Geheimnis enthüllen können, aber keine echte Teilmenge der
Gruppe. Eine Möglichkeit, ein Geheimnis auf diese Weise auf n Personen “zu verteilen”, ist
die folgende: Wir fassen s als Element des Körpers Z p für eine große Primzahl p (z.B. 1024Bit) auf. Dann gehen wir wie folgt vor:
(1) Wir berechnen n Zufallswerte x1 , . . . , xn ∈R Z p mit xi 6= 0 und xi 6= x j für alle i 6= j (falls
zwei Werte übereinstimmen, verwerfen wir einen der beiden und wählen erneut – dieses
√
Verfahren führt rasch zum Ziel, denn eine Kollision ist erst nach O( p) Zufallswahlen
zu erwarten).
(2) Wir berechnen weitere n − 1 Zufallswerte a1 , . . . , an−1 ∈R Z p mit ai 6= 0.
(3) Wir berechnen für 1 ≤ i ≤ n die Funktionswerte yi := p(xi ) durch Einsetzen der Werte
xi in das Polynom p(x) := an−1 xn−1 + . . . + a1 x + s (s ist das zu “teilende” Geheimnis).
(4) Wir übergeben der i-ten Person das “Teilgeheimnis” (xi , yi ) für 1 ≤ i ≤ n.
4.6. “SECRET SHARING”
67
Mit Hilfe der üblichen Langrangeschen-Interpolationsformel können in der Tat alle n Personen zusammen das Polynom p(x) rekonstruieren:
n
x−xj
j6=i xi − x j
p(x) = ∑ yi · ∏
i=1
Finden sich nun z.B. die Personen 1, . . . , n − 1 zusammen, um gemeinsam ohne die n-te Person das Geheimnis zu lüften, so können sie dasjenige eindeutig bestimmte Interpolationspolynom q(x) mit q(xi ) = yi für i = 1, . . . , n − 1 bestimmen. Ferner erhalten sie damit eine
Darstellung für p(x) der Form p(x) = q(x) + r(x) · ∏n−1
i=1 (x − xi ). Wegen deg p(x) = n − 1 und
n−1
deg q(x) = n − 2 sowie deg ∏i=1 (x − xi ) = n − 1 können sie deg r(x) = 0, also r(x) = c ∈ Z p
folgern. Da aber jeder Wert in Z p gewählt werden kann, ohne dass die Bedingungen p(xi ) = yi
für i = 1, . . . , n − 1 verletzt werden, können sie keinerlei Rückschlüsse auf das tatsächliche
Geheimnis s ziehen. Trifft sich dagegen eine Koalition von noch weniger als n − 1 Teilnehmern, so wächst mit dem Grad des Polynoms r(x) in p(x) = q(x) + r(x) · ∏i (x − xi ) auch die
Anzahl der Freiheitsgrade für seine Koeffizienten. Die Chance, das Geheimnis zu enthüllen,
wird noch weitaus geringer.
Das beschriebene Verfahren kann so modifiziert werden, dass ein Geheimnis auf n Personen
verteilt wird, von denen dann eine Teilgruppe von genau k ≤ n Personen in der Lage ist, es
zu enthüllen: Statt das Polynom p(x) vom Grad n − 1 zu wählen, berechnet man ein Polynom
vom Grad k − 1 und verteilt die entsprechenden Argumente und Funktionswerte wie oben
beschrieben. Ein Polynom (k − 1)-ten Grades kann dann von k Personen mit Hilfe der Argumente und der Funktionswerte über die Lagrangesche Interpolationsformel bestimmt werden.
Kapitel 5
Unterschriften (Signaturen)
In diesem Kapitel wollen wir uns mit Unterschriftenverfahren in der Kryptographie beschäftigen. Wir werden Verfahren kennenlernen, die es ermöglichen, dass elektronische Dokumente
fälschungssicher unterschrieben werden können. Die Sicherheit beruht je nach Verfahren auf
der Schwierigkeit große Zahlen zu faktorisieren oder den diskreten Logarithmus eines Elementes einer zyklischen Gruppe zu bestimmen. Da die Unterschrift auf einem Dokument
fest an das Dokument und seinen Inhalt gebunden sein muss (anderenfalls könnte man eine
einmalige Unterschrift als Unterschrift für beliebige andere Dokumente mißbrauchen), wird
man in der Regel ein Unterschriftenverfahren auf den gesamten zu unterschreibenden Text
anwenden.
Auf diese Weise entstehen bei der Unterschrift “langer” Dokumente ebenfalls “lange” Unterschriften (oft sind die Unterschriften sogar länger als der zu unterschreibende Text). Um diesem Problem aus dem Weg zu gehen, kann man sogenannte “Hashing”-Verfahren verwenden,
mit denen sich zunächst das zu unterschreibende Dokument verkleinern lässt. Anschließend
wird dann die Unterschrift auf dem “gehashten” Dokument ausgeführt. Wie man Nachrichten
mit Hilfe von “Hashing” verkleinert, werden wir im nächsten Kapitel sehen.
Ein anderes Problem ist die Identifikation: Es muss sichergestellt werden, dass die Person,
die eine Unterschrift geleistet hat, auch tatsächlich eindeutig identifizierbar ist.
5.1
Zum Konzept von Unterschriftenverfahren
Von einem Unterschriftenverfahren erwarten wir die folgenden Eigenschaften:
1. Die Unterschrift auf einem Dokument muss fest an das Dokument angebunden sein.
2. Unterschriften zu vollziehen und zu verifizieren sollte “leicht” sein (d.h. effizient
durchführbar).
3. Es sollte “schwer” sein (d.h. man kennt keinen effizienten Algorithmus), Unterschriften
zu fälschen.
68
5.2. DAS UNTERSCHRIFTENVERFAHREN VON ELGAMAL
69
4. Derjenige, der eine Unterschrift leistet, sollte nicht in der Lage sein, anschließend seine
Unterschrift zu verleugnen.
Um eine Nachricht x zu unterschreiben, haben wir allgemein ein Schlüsselpaar (S, K), wobei
S geheim gehalten wird und zur Unterschrift von Nachrichten mit einer Funktion sigS verwendet wird. Der Schlüssel K wird benutzt, um Unterschriften mit Hilfe einer Funktion verK
zu verifizieren.
Allgemein kann man jedes Public-Key-Kryptosystem mit einer Verschlüsselungsfunktion
decK und einer Entschlüsselungsfunktion encS , wobei K öffentlich ist und S geheim gehalten
wird, als Unterschriftenverfahren “mißbrauchen”. Man “dreht” dazu die übliche, zur Kommunikation verwendete Vorgehensweise einfach um: Angenommen Alice soll die Nachricht
x unterschreiben. Dann verschlüsselt Alice die Nachricht x mit ihrem geheimen Schlüssel,
d.h. sie berechnet y := decS (x). Dann sendet sie (x, y) an Bob. Bob wendet nun die Funktion encK auf y an und erhält x? = encK (y). Stimmt x? mit dem Wert x überein, so akzeptiert
Bob die Unterschrift. Falls x? 6= x, so kann Bob davon ausgehen, dass Alice entweder keine
korrekte Unterschrift geleistet hat, oder jemand anders versucht hat, Alice’s Unterschrift zu
fälschen.
Für die beschriebene Vorgehensweise eignet sich z.B. das RSA-Verfahren 4.1. Symmetrische
Kryptosysteme wie Rijndael (siehe Seite 56 und folgende) eignen sich nicht als Unterschriftenverfahren, denn K = S, d.h. es gibt im eigentlichen Sinne keinen öffentlichen Schlüssel.
5.2
Das Unterschriftenverfahren von ElGamal
In diesem Abschnitt werden wir ein Unterschriftenverfahren kennenlernen, dass von ElGamal
entwickelt wurde.
Protokoll 5.1. (ElGamal Unterschriftenverfahren) Sei G = hgi eine zyklische Gruppe der
Ordnung d. Ferner sei eine Codierungsfunktion G → Zd , x 7→ x? gegeben, die die Elemente
von G auf Zahlen aus {0, . . . , d − 1} abbildet.
(1) Die zu unterschreibende Nachricht m ist Alice und Bob bekannt. Alice wählt einen
geheimen Schlüssel a ∈ Zd und veröffentlicht y := ga ∈ G.
k
(2) Alice wählt ein geheimes k ∈R Z×
d und berechnet x := g ∈ G. Dann berechnet sie
b := k−1 · (m − a · x? ) mod d und sendet sigg,a,k (m) := (x, b) an Bob.
?
(3) Bob berechnet gm und yx · xb . Bob akzeptiert die Unterschrift genau dann, wenn gilt:
?
gm = yx · xb .
Beweis. (Korrektheit) Angenommen, Alice und Bob gehen beide genau nach den Anwei?
?
?
−1
?
?
?
sungen des Protkolls vor. Dann gilt: yx · xb = yx · gk·b = yx · gk·(k ·(m−a·x ) = yx · gm−a·x =
?
?
?
?
yx · gm · g−a·x = yx · gm · y−x = gm , also die Korrektheit des Verfahren.
Die Effizienz des Verfahrens ist gewährleistet, denn Alice und Bob führen nur die üblichen Gruppenoperationen aus. Addition, Multiplikation und Inversion in Zd sind effizient
70
KAPITEL 5. UNTERSCHRIFTEN (SIGNATUREN)
durchführbar, d.h. die Laufzeit für die Operationen ist höchstens quadratisch in der Kodierungslänge der Elemente aus Zd , also logarithmisch in d. Potenzieren wird wie immer über
“Repeated-Squaring” 1.5 erledigt. Die zufällige Wahl von k ∈ Z×
d zeigt uns, dass es viele
mögliche Unterschriften auf m gibt, was sicherlich zur Fälschungssicherheit des Verfahrens
beiträgt. Die Fälschungssicherheit diskutieren wir im nächsten Abschnitt.
Ein deutlicher Nachteil des Verfahrens ist jedoch der folgende: Setzt man voraus, dass die
Elemente der Gruppe G = hgi mit d = #G die gleiche Codierungslänge haben wie die korrespondierenden Elemente von Zd , so ist die Unterschrift (x, b) auf der Nachricht m etwa
doppelt so lang wie die Nachricht m. Handelt es sich bei d um eine 1024-Bit-Zahl, so hat die
Unterschrift auf einer Nachricht der Länge 1024-Bit die Länge 2048-Bit. Dies ist aus Effizienzgründen wenig wünschenswert und es scheint auch nicht einsichtig, dass die Unterschrift
auf einer Nachricht eine derartige Länge haben muss. Wir werden im letzten Abschnitt dieses
Kapitels eine Modifikation des Verfahrens von ElGamal diskutieren, die auf Schnorr zurückgeht. Sie erlaubt es im wesentlichen unter Wahrung der Sicherheit des Verfahrens deutlich
kürzere Unterschriften zu erzeugen.
5.3
Fälschungssicherheit von ElGamal Unterschriften
In diesem Abschnitt wollen wir Angriffe auf das Unterschriftenverfahren von ElGamal 5.1
diskutieren. Nehmen wir an, Eve möchte eine Nachricht m unterschreiben (und sich dabei
Bob gegenüber als Alice ausgeben). Eve kennt a nicht. Wegen a = dlogg y und weil wir davon ausgehen können, dass der diskrete Logarithmus sehr schwer zu berechnen ist, ist der
Versuch, a zu berechnen und dadurch das System zu brechen, hoffnungslos. Eine andere
Möglichkeit für Eve besteht darin, den Wert x einfach selbst zu wählen. Dann muss sie jedoch
?
den passenden Wert b berechnen und es gilt b = dlogx (gm · y−x ). Sie stößt also wieder auf
das Problem, einen diskreten Logarithmus berechnen zu müssen. Eine weitere Möglichkeit
?
besteht für Eve darin, x und b vorzuwählen und dann m zu berechnen mit m = dlogg (yx · xb ).
In diesem Fall hat Eve allerdings keine Kontrolle über m und wird mit hoher Wahrscheinlichkeit eine völlig blödsinnige Nachricht unterschreiben. Will Eve eine ganz spezielle Nachricht
?
m unterschreiben, so muss sie stets x und b finden mit gm = yx · xb . Auf die letztere Gleichung
lässt sich keine bis dato bekannte Theorie anwenden, die etwas über die Komplexität des Problems aussagt. Man geht jedoch allgemein davon aus, dass auch dieses Problem “schwer” zu
lösen ist.
5.3.1
Die Angriffe von Mitchell auf ElGamal Unterschriften
Mitchel et al. fanden 1992 Möglichkeiten, ElGamal zu brechen. Wir werden zwei ihrer Angriffe hier kurz skizzieren und dann sehen, dass ElGamal als Unterschriftensystem durch
diese Angriffe jedoch nicht wirklich gefährdet ist.
Die erste Möglichkeit besteht für Eve darin, i, j mit 0 ≤ i, j < d und ggT( j, d) = 1 zu wählen
und dann x := gi · y j , b := −x? · j−1 mod d und m := −x? · i · j−1 mod d zu berechnen. Dann ist
5.4. SCHNORR UNTERSCHRIFTEN
71
?
?
?
−1
?
?
?
−1
(x, b) eine gültige Unterschrift auf m, denn yx · xb = yx · (gi · y j )−x · j = yx · y−x · g−x ·i· j =
?
−1
g−x ·i· j = gm .
Der Nachteil dieses Verfahrens besteht darin, dass man keinerlei Kontrolle über die Nachricht
m hat: Man kann sich m nicht wirklich aussuchen und dann eine gültige Unterschrift auf m
produzieren.
Mitchel schlug u.a. noch eine weitere Möglichkeit vor, gültige ElGamal-Unterschriften auf
Nachrichten zu erzeugen. Diese beruht auf der Tatsache, dass Eve eine Nachricht m sowie
eine gültige Unterschrift (x, b) auf m aufgeschnappt hat. Mit Hilfe der Werte m, x und b kann
Eve dann wieder geschickt andere Werte berechnen, die eine korrekte Unterschrift auf einer
Nachricht darstellen. Bei der Wahl der Werte geht Eve ähnlich wie in dem oben beschriebenen Verfahren vor. Jedoch sind die Formeln etwas komplizierter und auch aufwendiger zu
verifizieren, weshalb wir an dieser Stelle darauf verzichten, sie explizit anzugeben.
Wichtig ist, dass keiner der Angriffe es erlaubt, zu einer frei gewählten Nachricht m eine
gültige Unterschrift auf m zu erzeugen.
5.3.2
Zur unvorsichtigen Benutzung des Unterschriftenverfahrens von ElGamal
Zwei Dinge sind bei der Verwendung von Protokoll 5.1 von entscheidender Wichtigkeit: Die
zufällig gewählte Zahl k darf keinesfalls bekanntgegeben werden, denn es gilt a ≡ (m − k ·
b) · (x? )−1 (vorausgesetzt, x? ist invertierbar modulo d). Sobald Eve den Wert a kennt, kann
sie beliebige Nachrichten in Alice’s Namen unterschreiben, denn sie kann alle Schritte des
Protokolls 5.1 ebenso effizient ausführen, wie Alice selbst.
Der zweite große Fehler, der weniger fatal wirkt, als das Bekanntgeben des Wertes k, ist die
Tatsache, dass man den Wert k aus Bequemlichkeit zur Unterschrift zweier verschiedener
?
Nachrichten m1 und m2 verwenden könnte. Dann erhalten wir eine Kollision der Form yx =
gm1 · x−b1 = gm2 · x−b2 und es folgt wegen x = gk gerade m1 − m2 = k · (b1 − b2 ) mod d. Ist
b1 − b2 invertierbar modulo d, so kann Eve k (und damit auch a, s.o.) berechnen. Sind b1 − b2
und d nicht teilerfremd, so kann Eve immer noch versuchen, über Reduktion modulo dem
größten gemeinsamen Teiler t von b1 − b2 und d einen Wert k0 zu berechnen mit k ≡ k0 + i ·
d
t mod d mit 0 ≤ i < t und dann (falls t nicht zu groß ist), alle Werte von i durchprobieren, bis
sie dasjenige i mit k = k0 + i · dt gefunden hat. Diese Vorgehensweise haben wir in Bemerkung
3.8 bereits erörtert.
Ein weiterer Angriff auf Protokoll 5.1 besteht wieder in dem “Woman-in-the-middle”Angriff, den wir schon als Angriff auf das Diffie & Hellman Protokoll 4.3 auf Seite 64 diskutiert haben: Eve gibt sich gegenüber Alice als Bob und gegenüber Bob als Alice aus.
5.4
Schnorr Unterschriften
Smart Cards erledigen oft Aufgaben, in denen Unterschriften eine wichtige Rolle spielen. Da
sie nur sehr begrenzte Rechenkapazität haben, müssen Unterschriften möglichst kurz sein.
72
KAPITEL 5. UNTERSCHRIFTEN (SIGNATUREN)
Wir wollen in diesem Abschnitt eine Variante des Unterschriften-Protokolls 5.1 von ElGamal
kennenlernen, die deutlich kürzere Unterschriften erlaubt.
Schnorr’s Idee besteht nun im wesentlichen darin, die zyklische Gruppe Z×
p als “Rechenbereich” zu wählen, wobei p eine sehr große Primzahl (z.B. 1024-Bit) ist. Anstatt nun Protokoll
5.1 in Z×
p selbst auszuführen (was bei einer Nachricht der Länge 1024-Bit eine Unterschrift
der Länge 2048-Bit bedeuten würde), schlägt Schnorr vor, eine zyklische Untergruppe G von
Z×
p der Ordnung q zu wählen, wobei q ein Primteiler von p − 1 ist. Für q ist eine Primzahl
von 160-Bit denkbar, also viel kleiner als p selbst. In G wird dann das Unterschriftenverfahren von ElGamal 5.1 ausgeführt, was dazu führt, dass eine Unterschrift der Form (x, b) nur
noch 2 · 160 = 320-Bit groß ist.
Es stellen sich zwei grundsätzliche Probleme: Als erstes möchte man nichts von der Sicherheit von ElGamal einbüßen. Als zweites sollte die Konstruktion leicht durchführbar sein,
d.h. zu einer 160-Bit-Primzahl q sollte es leicht sein, eine 1024-Bit-Primzahl zu finden, mit
q | p−1, und es sollte außerdem leicht sein, ein erzeugendes Element g der Gruppe G angeben
zu können.
Zunächst zum zweiten Problem: Der Satz von Dirichlet 2.10 über Primzahlen in arithmetischen Progressionen garantiert uns die Existenz unendlich vieler solcher Primzahlen p. In der
Praxis wählt man zufällige Vielfache von q, addiert 1 und testet auf Primheit. Dieses Vorgehen führt in akzeptabler Zeit zum Erfolg. Haben nun q und p die gewünschten Eigenschaften,
so erhalten wir ein erzeugendes Element von G mit dem folgenden Trick: Wir wählen ein
p−1
q . Dann gilt gq = 1, also ord(g) | q. Da q aber
zufälliges Element y ∈ Z×
p und setzen g := y
eine Primzahl ist, kann nur ord(g) = q oder ord(g) = 1 gelten. Im Fall ord(g) = 1 folgt g = 1
und wir wählen einfach einen neuen zufälligen Wert y. Im Fall ord(g) = q haben wir das
gewünschte Element g mit G = hgi gefunden.
Nun zum ersten Problem: Wir hatten gesehen, dass die Sicherheit des Unterschriftenverfahrens von ElGamal im wesentlichen auf der Tatsache beruht, dass der diskrete Logarithmus
schwer zu berechnen ist. Führen wir nun Potokoll 5.1 in der Untergruppe G = hgi von Z×
p
aus, so haben wir zwei Möglichkeiten, den diskreten Logarithmus eines Elementes x ∈ G,
x = ga zu berechnen:
Die erste Möglichkeit besteht darin, das Element x in Z×
p zu betrachten und den diskreten
Logarithmus a dort mit Hilfe des Index-Kalküls 3.22 zu berechnen: Sei dazu x = ga in G,
a der gesuchte diskrete Logarithmus, sowie Z×
p = hzi. Dann berechnen wir mit Hilfe von
l
Index-Kalkül zunächst l mit g = z und k mit x = zk . Auf diese Weise erhalten wir zk =
x = ga = za·l , d.h. k ≡ a · l mod p − 1. Wegen x ∈ G und #G = q, ist a mod q der gesuchte
diskrete Logarithmus von x in Basis g, d.h. wir betrachten statt k ≡ a · l mod p − 1 schlicht
k ≡ a · l mod q, wobei wir in diesem Fall, da q prim ist, a über Inversion von l berechnen
können. Wir hatten gesehen, dass Index-Kalkül effizienter ist als die generischen Algorithmen
zur Berechnung des diskreten Logarithmus. Allerdings ist p eine 1024-Bit-Primzahl, weshalb
auch Index-Kalkül in diesem Fall nicht praktikabel ist.
Die zweite Möglichkeit besteht darin, dass wir x in G betrachten und versuchen, den diskreten
Logarithmus a von x in Basis g in G zu berechnen. In G haben wir jedoch keinen Index-Kalkül
5.4. SCHNORR UNTERSCHRIFTEN
73
zur Verfügung, um a zu berechnen (G ist sozusagen nicht speziell genug – man weiß bis dato nicht, wie man Index-Kalkül in einer Gruppe dieser Art anwenden könnte). Wir müssen
√
also auf die generischen Algorithmen zurückgreifen, deren Laufzeit erwartungsgemäß q
Gruppenoperationen beträgt (bedenke, dass q prim ist und die Laufzeit der generischen Algorithmen immer durch den größten Primteiler der Gruppenordnung, also in unserem Fall
durch q selbst, bestimmt ist). Da q eine Primzahl ist, können wir nicht von den Algorithmen “Chinese Remaindering” 3.16 und Pohlig-Hellman 3.19 profitieren und es bleibt uns nur
der generische Algorithmus von Pollard 3.11. Ist q eine 160-Bit-Primzahl, so ist auch dieser
Ansatz nicht praktikabel.
Das von Schnorr vorgeschlagene Verfahren bietet also die Sicherheit des ursprünglich von
ElGamal vorgeschlagenen Unterschriftenverfahrens, aber deutlich kürzere Unterschriften.
Im wesentlichen stimmt das Unterschriftenverfahren von Schnorr in der Tat mit dem von ElGamal vorgeschlagenen Unterschriftenverfahren überein. Da einige kleinere Modifikationen
dennoch nötig sind, geben wir das Unterschriftenverfahren im folgenden an. Das Protokoll
verwendet eine Hash-Funktion h : {0, 1}? → Zq . Wir werden Hash-Funktionen im nächsten
Abschnitt genauer besprechen. Für das Verständnis des Protokolls genügt es, sich h als eine
Funktion vorzustellen, für die es schwer ist, aus einem gegebenen Bild eines Elementes unter
h ein passendes Urbild zu berechnen.
Protokoll 5.2. (Schnorr-Unterschriftenverfahren) Sei G = hgi eine zyklische Untergruppe
von Z×
p , p prim, mit #G = q, wobei q eine Primzahl ist mit q | p − 1.
(1) Die zu unterschreibende Nachricht m ist Alice und Bob bekannt. Alice wählt einen
a
geheimen Exponenten a ∈R Z×
q und veröffentlicht y := g mod p.
(2) Zur Unterschrift auf m wählt Alice zunächst ein zufälliges k ∈R Z×
q und berechnet x :=
k
g mod p. Dann berechnet sie r := h(m, x) als “Hash-Wert” von m und x. Schließlich
berechnet sie b := k + a · r mod q und sendet (r, b) als Unterschrift auf m an Bob.
(3) Bob bestimmt v := gb · y−r mod p und prüft, ob r = h(m, v) gilt. Ist letztere Gleichung
erfüllt, so akzeptiert er Alice’s Unterschrift.
Beweis. (Korrektheit) Es gilt v ≡ gb · y−r ≡ gk+a·r · g−a·r ≡ gk ≡ x mod p. Damit folgt aus
x ≡ v mod p auch h(m, x) = h(m, v).
Kapitel 6
Hash-Funktionen
Dieses Kapitel beschäftigt sich mit Hash-Funktionen (oder auch “Hackfunktionen”) die dazu dienen sollen, lange Nachrichten in handlichere, kürzere zu überführen: Gegeben x und
eine Funktion h, so nennen wir h eine Hash-Funktion, wenn h(x) “hinreichend kleine Codierungslänge” besitzt. Diese etwas schwammige Definition werden wir noch formalisieren.
Eine Anforderung, die speziell die Kryptographie an Hash-Funktionen stellt, ist die Tatsache,
dass es schwer sein sollte, zu einem Hash-Wert z := h(x) den Wert x oder einen anderen gültigen Wert y zu finden mit h(y) = z. Vor allem im Zusammenhang von Unterschriftverfahren
spielen Hash-Funktionen eine wichtige Rolle: Stellen wir uns vor, Alice würde eine Unterschrift auf einer Nachricht m leisten, indem sie zunächst h(m) berechnet und dann z.B. auf
h(m) das Unterschriftenverfahren von ElGamal 5.1 anwendet. Könnte nun Eve leicht zu dem
Wert h(m) einen andere Nachricht x finden mit h(x) = h(m), so könnte sie x gegen m austauschen und hätte eine gültige Unterschrift von Alice auf einer ganz anderen Nachricht (nämlich
auf x).
Definition 6.1. Sei h : X → Z eine Abbildung zwischen den endlichen Mengen X und Z. Sind
x, y ∈ X, x 6= y, mit h(x) = h(y), so sagen wir, dass x und y kollidieren. Wir nennen h ein HashFunktion, falls #X > #Z. Die (Hash-)Funktion h heißt Kollisions-resistent, wenn es schwer
ist, für h eine Kollision zu finden. Sie heißt second-preimage-resistent, wenn es schwer ist, zu
gegebenem x ∈ X ein y ∈ X, y 6= x, zu finden mit h(x) = h(y). Sie heißt eine Einwegfunktion,
wenn es schwer ist, zu einem z ∈ h(X) ein x ∈ X zu finden mit h(x) = z.
Da Hash-Funktionen große Mengen auf kleinere Mengen abbilden sollen, ist es unausweichlich, dass Kollisionen auftreten. Es gilt:
Lemma 6.2. Sei h : X → Z eine Hash-Funktion. Ist h Kollisions-resistent, so ist h auch
second-preimage-resistent. Ist h second-preimage-resistent, so ist h eine Einwegfunktion.
Beweis. Es ist klar, dass wenn es generell schwer ist, Kollisionen für h zu finden, dass es dann
auch schwer ist, zu einem gegebenen x ∈ X ein y ∈ X zu finden mit h(x) = h(y). Dies zeigt die
erste Behauptung. Die zweite Behauptung beweisen wir durch Widerspruch: Angenommen,
74
6.1. EINE SPEZIELLE HASH-FUNKTION
75
es gibt einen probabilistischen Polynomialzeitalgorithmus A , der in Polynomialzeit zu einem
gegebenen z ∈ h(X) ein x ∈ X findet mit h(x) = z. Es bezeichne π(x) die Wahrscheinlichkeit,
dass A bei Eingabe h(x) den Wert x liefert. Ferner sei X(z) := {x ∈ X | h(x) = z}. Dann gilt
für jedes z ∈ Z: ∑x∈X(z) π(x) = 1, denn einen der Werte aus X(z) muss A bei Eingabe h(x) = z
liefern. Sei nun B derjenige probabilistische Polynomzeitalgorithmus, der bei Eingabe x ∈ X
schlicht A mit Eingabe h(x) aufruft. Falls A dann ein y 6= x mit h(x) = h(y) liefert, so gibt B
den Wert y und anderenfalls FAIL aus. Dann ist B ein probabilistischer Polynomialzeitalgorithmus, mit dessen Hilfe wir zu einem gegebenen x ∈ X ein y ∈ X mit x 6= y und h(x) = h(y)
finden können. Die Erfolgswahrscheinlichkeit von B ist für ein festes x ∈ X gegeben durch
1 − π(x) (nämlich die Wahrscheinlichkeit eben nicht den Wert x auszugeben). Da die Mengen
X(z), z ∈ Z eine Partition von X bilden, ergibt sich insgesamt seine Erfolgswahrscheinlichkeit
zu
1
1 P(“B ist erfolgreich”) =
· ∑ (1 − π(x)) =
· #X − ∑ ∑ π(x)
#X x∈X
#X
z∈Z x∈X(z)
= 1−
1
#Z
· ∑ 1 = 1−
,
#X z∈Z
#X
also kann h nicht second-preimage-resistent sein. Widerspruch!
Ein möglicher Weg, zu einem gegebenen Hash-Wert z ∈ Z einen Wert x ∈ X mit h(x) = z
zu finden, besteht darin, solange zufällige Werte x ∈ X zu wählen, bis h(x)√= z gilt. Das
Geburtstagproblem zeigt uns, dass wir davon ausgehen können, nach etwa #Z Schritten
einen passenden Wert x ∈ X zu finden. Daher darf #Z auch nicht zu klein sein. Für #Z ≈ 2160
ist ein Geburtstagsangriff undenkbar.
6.1
Eine spezielle Hash-Funktion
Wir wollen eine konkrete Hash-Funktion kennenlernen, deren Kollisionsresistenz auf der
Schwierigkeit der Berechnung des diskreten Logarithmus beruht. Sei G = hgi eine zyklische
Gruppe der Ordnung d = 2 · q für eine Primzahl q. Sei z ∈ G, z 6= g ein weiteres erzeugendes Element von G. Setze Q := {0, . . . , q − 1}. Dann ist die Funktion h mit h : Q × Q → G,
h(x, y) := gx · zy eine Hash-Funktion, denn gehen wir davon aus, dass die Elemente von G eine
Codierungslänge von höchstens log2 (2 · q) = 1 + log2 q haben, so werden Elemente (x, y) der
Länge 2 · log2 q auf Elemente der Länge ≈ log2 q abgebildet, d.h. ihre Codierungslänge wird
im wesentlichen halbiert. Es gilt nun:
Theorem 6.3. Ist es leicht für h eine Kollision zu finden, so ist es leicht dlogg z zu berechnen.
Beweis. Angenommen wir haben eine Kollision gx1 · zy1 = gx2 · zy2 mit (x1 , y1 ) 6= (x2 , y2 ) und
x1 , x2 , y1 , y2 ∈ Q = {0, . . . , q − 1}. Dann gilt gx1 −x2 = zy2 −y1 . Ist a = dlogg z, so gilt x1 − x2 ≡
a · (y2 − y1 ) mod d. Ist y2 − y1 invertierbar modulo d, so erhalten wir a = (y2 − y1 )−1 · (x1 −
x2 ). Ist t := ggT(y2 − y1 , d) > 1, so folgt t ∈ {2, q, 2 · q}. Für t = 2 können wir mit dem
76
KAPITEL 6. HASH-FUNKTIONEN
üblichen Verfahren aus Bemerkung 3.8 vermöge Reduktion der Gleichung für a modulo d2
ein a0 bestimmen mit a ≡ a0 + i · d2 mod d und i ∈ {0, 1}. Durch ausprobieren finden wir dann
leicht den korrekten Wert für a heraus. Wegen −(q−1) ≤ y2 −y1 ≤ q−1 folgt aus t ∈ {q, 2·q}
wegen t | y2 − y1 bereits y1 = y2 und somit gx1 = gx2 . Letzteres bedeutet aber x1 ≡ x2 mod d.
Wegen d | x1 − x2 gilt auch q | x1 − x2 , also nach dem gleichen Argument wie oben x1 = x2 .
Widerspruch zu (x1 , y1 ) 6= (x2 , y2 ).
Durch Umkehrung der Aussage erhalten wir:
Korollar 6.4. Wenn der diskrete Logarithmus in G schwer zu berechnen ist, so ist h
Kollisions-resistent.
Eine Möglichkeit für G ist Z×
p mit p = 2 · q + 1, wobei q eine Primzahl ist. Eine Primzahl der
Form p heißt eine Germainsche Primzahl (nach Sophie Germain). Leider ist nicht bekannt,
ob es unendlich viele solcher Primzahlen gibt.
6.2
Hashing von Blocknachrichten
t
Sei h : Zm
2 → Z2 eine Hash-Funktion, m ≥ t + 2. Wir wollen einen Algorithmus kennenlernen,
n
wie wir Nachrichten x einer Länge n > m hashen können. Setze k := d m−t−1
e. Dann können
wir die Nachricht x in k Blöcke der Länge m −t − 1 zerlegen, wobei der letzte Block am Ende
d = k · (m −t − 1) − n < m −t − 1 freie Stellen hat. Diesen füllen wir mit d Nullen auf, so dass
wir eine Zerlegung x = x1 x2 . . . xk von x erhalten, wobei jedes xi ein Block der Länge m −t − 1
ist. Dann fügen wir am Ende einen weiteren Block xk+1 an, der die Binärdarstellung der Zahl
d enthält. Wegen d < m − t − 1 und da xk+1 ebenfalls Länge m − t − 1 haben soll, ist dies
möglich. Auf diese Weise speichern wir also im letzten Block die Information, mit wie vielen
Nullen wir xk am Ende aufgefüllt haben. Das Hashing-Verfahren führen wir nun wie folgt
durch: Im ersten Schritt setzen wir g1 := 0t 0x1 . Dann hat g1 die Blocklänge m und wir können
h darauf anwenden. In allen folgenden Schritten berechnen wir stets gi+1 := h(gi )1xi+1 und
wenden h darauf an. Der letzte Block, den wir auf diese Weise erhalten, ist gk+1 = h(gk )1xk+1
und wir setzen h? (x) := h(gk+1 ). Es lässt sich nun zeigen, dass gilt:
Theorem 6.5. Ist h Kollisions-resistent, so auch h? , d.h. es ist nicht möglich in probabilistischer Polynomialzeit eine Kollision für h? zu finden.
Der Beweis wird per Widerspruch geführt: Man nimmt an, dass h? nicht Kollisions-resistent
ist und zeigt dann, dass man aus einer Kollision für h? stets eine Kollision für h konstruieren
kann. Der Beweis ist aber sehr technisch und wir geben ihn hier nicht an (siehe [8], Theorem
6.6, Seite 130).
Abschließend bemerken wir noch, dass wir die Funktion h auf einer Nachricht x der Länge n
n
genau 1 + d m−t−1
e-mal auswerten müssen, um h? (x) zu berechnen.
6.3. ZEITSTEMPEL
6.2.1
77
Kryptosysteme und Hash-Funktionen
Man kann auch Kryptosysteme, in denen die Länge der Nachrichten, die Länge der Verschlüsselungen und die Länge der Schlüssel übereinstimmen, zur Berechnung von HashWerten verwenden (z.B. Rijndael bietet sich als Kandidat für eine solche Vorgehensweise an, denn die Blocklängen von Klartext, verschlüsseltem Text und Schlüssel können alle
samt gleich gewählt werden). Eine Nachricht x wird dazu in Blöcke der Länge n unterteilt,
x = x1 x2 . . . xk mit xi ∈ Zn2 . Ist encK : Zn2 → Zn2 die Verschlüsselungsfunktion, so wählen wir
einen Startwert, z.B. g0 = 0n und eine Funktion f : Zn2 × Zn2 → Zn2 , z.B. gi := f (gi−1 , xi ) :=
encgi−1 (xi ) ⊕ xi . Dann berechnen wir wieder g1 := f (g0 , x1 ), g2 := f (g1 , x2 ) usw. bis hin zum
eigentlichen Hash-Wert f (gk−1 , xk ) = gk =: h(x).
Für die Funktion f oder den Startwert g0 sind durchaus auch andere Kandidaten denkbar. Ein
Bestandteil der Definition von f ist in der Regel immer durch die Verschlüsselungsfunktion
encK des jeweiligen Kryptosystems gegeben.
6.3
Zeitstempel
Angenommen, Eve gelangt auf irgendeine Weise an Alice’s geheimen Schlüssel (z.B. im Rahmen des ElGamal Unterschriftenverfahrens 5.1). Dann kann sie Alice’s Unterschriften auf beliebigen Dokumenten fälschen. Es kann daher passieren, dass alle bisher von Alice getätigten
Unterschriften als ungültig erklärt werden müssen. Eine andere Möglichkeit besteht darin,
dass Alice selbst ihren geheimen Schlüssel veröffentlichen könnte. Dann kann jeder Alice’s
Unterschriften fälschen und Alice selbst könnte von Unterschriften, die sie in der Vergangenheit geleistet hat, behaupten, sie hätte sie nicht selbst vollzogen. Um diesem Dilemma zu
entgehen, kann man sogenannte Zeitstempel einführen. Soll nun Alice eine Nachricht x mit
Hilfe der Funktion sigS unterschreiben, so kann sie verpflichtet werden, das Datum der Unterschrift in der Unterschrift selbst festzuhalten. Dazu wählt Alice eine speziell auf das jeweilige
Datum zugeschnittene Information pub, die niemand vorher wissen kann (z.B. tagesbezogene Wetterdaten, Zeitungsüberschriften von Tageszeitungen des Tages der Unterschrift etc.).
Dann berechnet sie z := h(x) und z0 := h(z, pub) und unterschreibt auf z0 , d.h. y := sigS (z0 ).
Dann veröffentlicht sie (z, pub, y) z.B. in der Tageszeitung des auf die Unterschrift folgenden
Tages.
Kapitel 7
Identifikations- und
Authentifikationsverfahren
Identifikations- und Authentifikationsverfahren spielen z.B. beim sogenannten “Remote Login” auf Computern über ein Netzwerk oder bei der Verwendung von Credit-Karten etc. eine
wichtige Rolle. In unserer Situation stellen wir uns vor, dass Alice sich gegenüber Bob eindeutig identifizieren möchte. Verwenden die beiden ein Identifikationsverfahren, so dass Bob
sicher sein kann, dass er tatsächlich mit Alice kommuniziert (und natürlich auch umgekehrt),
so können Alice und Bob anschließend beruhigt z.B. das Schlüsselaustauschverfahren von
Diffie & Hellman 4.3 verwenden, denn der “Woman-in-the-middle”-Angriff (siehe Seite 64)
sollte nun nicht mehr möglich sein. Wir stellen die folgenden wichtigen Anforderungen an
ein Identifikationsverfahren: Auch wenn Eve die Leitung zwischen Alice und Bob abhört,
so kann sie keine Informationen aus deren Kommunikation ableiten, die ihr helfen, sich gegenüber Bob als Alice auszugeben. Selbst Bob sollte nicht in der Lage sein, sich gegenüber
anderen als Alice auszugeben. Das grundlegende Schema für ein Identifikationsprotokoll ist
in der Regel das folgende:
1. Alice sendet Informationen an Bob.
2. Bob schickt Alice eine “Herausforderung”.
3. Alice reagiert auf die “Herausforderung”.
Bei der “Herausforderung” handelt es sich in der Regel um eine Aufgabe, die Bob Alice stellt
und die nur Alice (effizient) bewältigen kann. Kann Alice also wie von Bob gewünscht auf
die Herausforderung reagieren, so kann sich Bob sicher sein, dass er tatsächlich mit Alice
kommuniziert.
Ein mögliches Identifikationsverfahren ist das folgende, welches voraussetzt, dass Alice und
Bob sich zuvor über einen gemeinsamen geheimen Schlüssel K für ein symmetrisches Kryptosystem (z.B. Rijndael) geeinigt haben: Bob schickt Alice eine zufällig gewählte Nachricht
78
7.1. DAS IDENTIFIKATIONSVERFAHREN VON SCHNORR
79
x. Dann verschlüsselt Alice die Nachricht x zu y := encK (x) und sendet y an Bob. Bob überprüft dann, ob x = decK (y) gilt. Ist dies der Fall, so kann Bob davon ausgehen, dass er es mit
Alice zu tun hat.
7.1
Das Identifikationsverfahren von Schnorr
In diesem Abschnitt lernen wir ein Identifikationsverfahren kennen, das auf Schnorr zurückgeht. Neben Alice, Bob und Eve gibt es bei vielen Identifikationsverfahren noch die Instanz
der “Trusted Authority” (Vertrauenswürdige Instanz), die wir mit TA abkürzen wollen. Bevor
Alice sich gegenüber Bob identifizieren kann leistet die TA Vorarbeit für das generelle Setting
der Identifikation: Die TA benutzt einen Sicherheitsparameter t (t = 40 genügt in der Regel).
Dann wählt die TA eine zyklische Gruppe G = hα ? i und eine Primzahl q ≥ 2140 , so dass q die
d
Ordnung d von G teilt. Dann ist α := (α ? ) q ein Element der Ordnung q. Alle Berechnungen
werden nun im wesentlichen wieder in der von α erzeugten zyklischen Untergruppe von G
durchgeführt (ähnlich wie wir es schon bei dem Unterschriftenverfahren von Schnorr auf
Seite 71 gesehen haben). Die TA hat einen geheimen Unterschriftenalgorithmus sigTA und
einen öffentlichen Algorithmus verTA zur Verifikation von Unterschriften.
Kommunikation von Alice mit der TA: Bevor nun Alice an Bob herantritt, um sich ihm
gegenüber als Alice zu identifizieren, führt sie die folgenden Schritte aus: Sie wählt einen
zufälligen Exponent eA ∈ Zq und sendet βA := α eA und ID(A) (ihre persönlichen Identifikationsdaten) an die TA. Die TA berechnet s := sigTA (ID(A), βA ) und schickt Alice ihr persönliches Zertifikat C(A) := (ID(A), βA , s).
Nachdem Alice nun diese Schritte ausgeführt hat, kann sie sich mit dem folgenden Identifikationsschema gegenüber Bob identifizieren:
Schnorr’s Identifikationsprotokoll:
1. Alice wählt ein zufälliges k ∈R Zq und sendet C(A) und γ := α k an Bob.
2. Bob prüft, ob verTA ((ID(A), βA ), s) = TRUE und schickt Alice ein r mit 1 ≤ r ≤ 2t (t
der Sicherheitsparameter der TA) als Herausforderung.
3. Alice berechnet y := k + eA · r mod q und schickt y an Bob.
4. Bob prüft, ob γ · βAr = α y . Ist dies der Fall, so sieht er Alice als identifiziert an. Anderenfalls geht er davon aus, dass jemand anderes sich als Alice ausgibt.
Die Korrektheit ist leicht nachzurechnen: γ · βAr = α k · α eA ·r = α k+eA ·r = α y . Die Effizienz
des Verfahrens ist ebenfalls klar, denn alle Operationen sind in polynomieller Zeit in der
Codierungslänge der Eingaben durchführbar.
Als nächstes diskutieren wir die Sicherheit des Verfahrens: Eve hört die Kommunikation zwischen Alice und Bob ab. Sie kennt daher die Werte C(A), γ und r. Dabei ist die Reihenfolge
80
KAPITEL 7. IDENTIFIKATION UND AUTHENTIFIKATION
wichtig: Eve sieht zuerst γ und danach r. Könnte sie den Wert von r erraten bevor Bob r an
Alice schickt, so könnte sie einen “alten”, schon verwendeten Wert von y wählen und selbst
γ := α y · βA−r an Bob senden und Bob würde, nachdem er eben dieses r unwissender Weise
an Eve geschickt hat, Eve für Alice halten. Daher darf der Wert für t auch nicht zu klein sein,
denn sonst könnte Eve den Wert für r einfach zufällig wählen und hätte für kleines t eine
akzeptable Trefferwahrscheinlichkeit, den richtigen Wert für r zu erraten.
Der Wert k, den Alice wählt, hat die gleiche Funktion wie im Unterschriftenverfahren von
ElGamal 5.1: Er schützt den privaten Schlüssel eA von Alice. Da sie k aber nicht direkt an
Bob sendet, sondern lediglich γ = α k , so kann Eve k nur als diskreten Logarithmus von γ
in Basis α berechnen, was nach Voraussetzung in G schwer sein sollte. Ebenso kann Eve
den geheimen Schlüssel eA nicht aus βA = α eA berechnen. Das folgende Theorem macht eine
starke Aussage über die Sicherheit des Identifikationsprotokolls von Schnorr:
Theorem 7.1. Wenn Eve einen Wert γ kennt, für den sie sich für mindestens zwei Werte von
r gegenüber Bob als Alice ausgeben kann, so kann Eve Alice’s geheimen Schlüssel eA =
dlogα βA leicht berechnen.
Beweis. Angenommen, Eve kann sich für die Werte (r1 , y1 ) 6= (r2 , y2 ) mit r1 , r2 , y1 , y2 ∈
{0, . . . , q−1} als Alice ausgeben. Dann gilt γ ·βAr1 = α y1 und γ ·βAr2 = α y2 . Wäre r1 ≡ r2 mod q,
so folgte aus den beiden Gleichungen y1 ≡ y2 mod q. Widerspruch zu (r1 , y1 ) 6= (r2 , y2 ). Wegen
r1 6≡ r2 mod q und da q prim ist, ist folglich r1 − r2 invertierbar modulo q, d.h. wir erhalten aus
−1
βAr1 −r2 = α y1 −y2 durch Potenzieren mit (r1 − r2 )−1 mod q gerade βA = α (y1 −y2 )·(r1 −r2 ) , also
(y1 − y2 ) · (r1 − r2 )−1 = dlogα βA = eA .
7.2
Das Identifikationsverfahren von Okamoto
In diesem Abschnitt werden wir eine Modifikation des im vorherigen Abschnitt vorgestellten
Identifikationsverfahrens von Schnorr kennenlernen, das eine stärkere Aussage über seine
Sicherheit zulässt: Sogar wenn Eve und Alice zusammenarbeiten, können sie keinen
Schaden anrichten, es sei denn sie können den diskreten Logarithmus eines Elementes der
zugrundeliegenden Gruppe berechnen. Würde Alice ihren geheimen Schlüssel eA einfach
an Eve weitergeben, so ist die Aussage von Theorem 7.1 wertlos. Wir verwenden hier die
gleiche Notation wie schon im letzten Abschnitt abgesehen von einer Kleinigkeit: Die TA
verwendet statt eines erzeugenden Elementes α der zyklischen Untergruppe der Ordnung q
von G zwei erzeugende Elemente α1 und α2 .
Kommunikation von Alice mit der TA: Alice wählt zuerst zwei geheime Exponenten e1 ,e2 ∈ Zq und sendet ID(A) und βA := α1e1 · α2e2 an TA. Die TA berechnet
s := sigTA (ID(A), βA ) und sendet C(A) := (ID(A), βA , s) als Alice’s persönliches Zertifikat
zurück.
Okamoto’s Identifikationsprotokoll:
7.3. EIN RSA-BASIERTES IDENTIFIKATIONSSCHEMA
81
1. Alice wählt k1 , k2 ∈R Zq zufällig und sendet C(A) und γ = α1k1 · α2k2 an Bob.
2. Bob prüft, ob verTA ((ID(A), βA ), s) = TRUE und sendet ein zufälliges r mit 1 ≤ r ≤ 2t
(t wieder der Sicherheitsparameter der TA) an Alice.
3. Alice berechnet y1 := k1 + e1 · r mod q und y2 := k2 + e2 · r mod q und sendet y1 , y2 an
Bob.
4. Bob prüft, ob γ · βAr = α1y1 · α2y2 gilt. Falls die Gleichung erfüllt ist, so sieht er Alice
als identifiziert an. Anderenfalls geht er davon aus, dass jemand anderer sich als Alice
ausgeben will.
Die Korrektheit ist wieder leicht nachzurechnen: γ · βAr = α1k1 · α2k2 · (α1e1 · α2e2 )r = α1k1 +e1 ·r ·
α2k2 +e2 ·r = α1y1 · α2y2 .
Auch bei diesem Protokoll sind alle Operationen effizient durchführbar: Intuitiv gesprochen
führen wir das Identifikationsprotokoll von Schnorr lediglich “zweimal parallel” aus. Nun zur
Sicherheit des Protokolls:
Lemma 7.2. Wenn Eve einen Wert γ kennt, für den sie sich für mindestens zwei Werte von r
als Alice ausgeben kann, so kann sie b1 , b2 ∈ Zq berechnen mit βA = α1b1 · α2b2 .
0
y0
Beweis. Eve kennt y1 , y2 , y01 , y02 , r, r0 mit r 6= r0 und γ · βAr = α1y1 · α2y2 sowie γ · βAr = α1 1 ·
y0
0
y −y01
α2 2 . Es folgt also βAr−r = α1 1
y −y02
· α2 2
. Wegen r 6= r0 folgt r 6≡ r0 mod q und da q prim ist,
0
y −y0
y −y0
ist r − r0 invertierbar modulo q. Potenzieren der Gleichung βAr−r = α1 1 1 · α2 2 2 mit (r −
r0 )−1 mod q liefert mit b1 := (y1 − y01 ) · (r − r0 )−1 mod q und b2 := (y2 − y02 ) · (r − r0 )−1 mod q
die gewünschten Werte.
Theorem 7.3. Wenn Eve einen Wert γ kennt, für den sie sich für mindestens zwei Werte von
r als Alice ausgeben kann, so kann sie zusammen mit Alice dlogα2 α1 mit Wahrscheinlichkeit
1 − q1 leicht berechnen.
Beweis. Nach dem obigen Lemma kennt Eve Werte b1 , b2 ∈ Zq mit βA = α1b1 · α2b2 . Von
Alice erfährt sie die Werte e1 , e2 mit βA = α1e1 · α2e2 . Es folgt α1b1 −e1 = α2e2 −b2 . Gilt nun
(e1 , e2 ) 6= (b1 , b2 ), z.B. e1 6= b1 , so ist wieder b1 − e1 invertierbar modulo q und wir erhal(e −b )·(b −e )−1
ten α1 = α2 2 2 1 1 , also dlogα2 α1 = (e2 − b2 ) · (b1 − e1 )−1 mod q. Ohne Beweis geben
wir an, dass die Wahrscheinlichkeit für (e1 , e2 ) 6= (b1 , b2 ) gerade 1 − 1q ist, woraus dann die
Behauptung folgt.
7.3
Ein RSA-basiertes Identifikationsschema
Wir wollen das Identifikationsverfahren von Schnorr mit Hilfe von RSA realisieren. Die
TA wählt zwei verschiedene Primzahlen p, q, veröffentlicht N := p · q und wählt einen
82
KAPITEL 7. IDENTIFIKATION UND AUTHENTIFIKATION
öffentlichen Exponenten e, e prim. Den geheimen RSA-Exponenten d mit der Eigenschaft
e · d ≡ 1 mod ϕ(N) hält sie geheim.
e
Kommunikation von Alice mit der TA: Alice wählt βA ∈R Z×
N zufällig und schickt δA := βA
sowie ID(A) an die TA. Die TA berechnet wie üblich s := sigTA (ID(A), δA ) und sendet
C(A) = (ID(A), δA , s) an Alice zurück.
RSA-basiertes Schnorr Identifikationsprotokoll:
e
1. Alice wählt k ∈R Z×
N und sendet C(A) und γ := k an Bob.
2. Bob prüft, ob verTA ((ID(A), δA ), s) = TRUE und sendet ein zufälliges r mit 0 ≤ r < e
an Alice.
3. Alice berechnet y := k · βA−r und sendet y an Bob.
4. Bob prüft, ob γ = δAr · ye .
Die Korrektheit folgt sofort aus δAr · ye = βAe·r · ke · βA−e·r = ke = γ. Die Effizienz des Verfahrens
ist klar, da Exponentiation mit Hilfe von “Repeated Squearing” 1.5 und modulare Multiplikation bzw. Inversion effizient möglich sind. Für die Sicherheit des Verfahrens erhalten wir:
Theorem 7.4. Wenn Eve einen Wert für γ kennt, für den sie sich für mindestens zwei Werte
von r gegenüber Bob als Alice ausgeben kann, so kann sie βA berechnen, d.h. sie kann das
RSA-Verfahren der TA brechen.
Beweis. Angenommen Eve hat Werte y1 , y2 , r1 , r2 mit r1 6= r2 und γ = δAr1 · ye1 = δAr2 · ye2 .
O.B.d.A. setzen wir r1 > r2 voraus. Dann gilt δAr1 −r2 = ( yy12 )e . Wegen 0 < r1 − r2 < e und da e
nach Wahl prim ist, gilt ggT(r1 − r2 , e) = 1. Nun kann Eve t ≡ (r1 − r2 )−1 mod e berechnen.
Dann berechnet sie mit Hilfe von Division mit Rest f ∈ N mit (r1 − r2 ) · t = f · e + 1. Damit
(r −r )·t
erhält sie δAf ·e+1 = δA 1 2 = ( yy12 )e·t , also δA = ( yy21 )e·t · δA− f ·e . Potenzieren wir die Gleichung
mit Hilfe des geheimen Exponenten d der TA, so erhalten wir βA = βAe·d = δAd = ( yy21 )e·t·d ·
δA− f ·e·d = ( yy12 )t · δA− f , d.h. Eve kann auch ohne Kenntnis von d den Wert βA berechnen.
7.4
Ein sicheres Schlüsselaustauschverfahren
Wir hatten gesehen, dass das Schlüsselaustauschverfahren von Diffie & Hellman 4.3 nicht
sicher gegen einen “Woman-in-the-middle”-Angriff ist. In diesem Abschnitt werden wir eine
Modifikation bzw. Erweiterung von 4.3 kennenlernen, die einen solchen Angriff ausschließt.
Der “Woman-in-the-middle”-Angriff funktionierte dann und nur dann, wenn es Eve gelingt
sich gegenüber Bob als Alice und gegenüber Alice als Bob auszugeben und dann als “Übersetzer” zwischen beiden zu fungieren.
7.4. EIN SICHERES SCHLÜSSELAUSTAUSCHVERFAHREN
83
Sei nun wieder G = hαi eine zyklische Gruppe (bzw. eine zyklische Untergruppe einer
größeren zyklischen Gruppe) und eA sowie eB die geheimen Exponenten von Alice bzw. Bob,
βA := α eA , βB := α eB sowie C(A) = (ID(A), βA , sA ) und C(B) = (ID(B), βB , sB ) die von der
TA auf dem üblichen Wege erzeugten Zertifikate von Alice bzw. Bob. Dann können sich
Alice und Bob gemäß dem folgenden Protokoll auf einen gemeinsamen geheimen Schlüssel
K für ein symmetrisches Kryptosystem (z.B. für Rijndael) einigen:
Authentifiziertes Schlüsselaustauschverfahren:
1. Alice sendet βA := α eA an Bob.
2. Bob berechnet βB := α eB , K := βAeB sowie yB := sigB (βB , βA ), wobei sigB sein geheimes
Unterschriftenverfahren ist. Dann sendet er (C(B), βB , yB ) an Alice.
3. Alice berechnet K := βBeA , verifiziert mit Hilfe der öffentlichen Methode verB , dass
yB tatsächlich die Unterschrift von Bob auf (βB , βA ) ist. Dann überprüft sie mit Hilfe von verTA , dass das Zertifikat C(B) von Bob stammt. Schließlich berechnet sie
yA := sigA (βA , βB ) mit Hilfe ihres geheimen Unterschriftenverfahrens sigA und sendet
(C(A), yA ) an Bob.
4. Bob überprüft mit Hilfe von verA , ob yA Alice’s Unterschrift auf (βA , βB ) ist und überprüft C(A) mit Hilfe von verTA .
Sind alle Überprüfungen positiv verlaufen, so können Alice und Bob sich der Identität des
jeweiligen Gegenübers sicher sein und verfügen über den gemeinsamen Schlüssel K = α eA ·eB .
Eve sieht nämlich nun wiederum nur die Werte βA , βB , yA , yB . Sie kann selbst den Wert yA
nicht erzeugen, da sie sigA nicht kennt und sie kann yB nicht erzeugen, da sie sigB nicht kennt.
Gäbe sich Eve gegenüber Bob als Alice aus, so müsste sie eine Unterschrift yE auf (βA , βB )
leisten. Da Bob jedoch die an ihn gesandte Unterschrift yE mit Hilfe von verA überprüft, wird
er erkennen, dass yE nicht von Alice erstellt wurde.
Den gemeinsamen Schlüssel K kann sie ebenfalls nicht berechnen, da das Diffie & Hellman
Problem DHP als ebenso schwer wie DLP angesehen werden kann.
Literaturverzeichnis
[1] J. A. Buchmann, Introduction to Cryptography, Undergraduate Texts in Mathematics,
second edition, Springer-Verlag, 2001
[2] J. Blömer, Vorlesungen zum RSA-Verfahren, Universität Paderborn, 2002
[3] J. Blömer, Vorlesungen zu Algorithmen in der Zahlentheorie, Universität Paderborn, 2002
[4] S. Bosch, Algebra, Springer Lehrbuch, 3. Auflage, Springer-Verlag, 1999
[5] P. Bundschuh, Zahlentheorie, Springer Lehrbuch, 2. Auflage, Springer-Verlag, 1992
[6] H. Cohen, A Course in Computational Algebraic Number Theory, Graduate Texts in Mathematics 138, Springer-Verlag, 1993
[7] J. Daemen, V. Rijmen, AES Proposal: The Rijndael Block Cipher, Document version 2
vom 03.09.1999, erhältlich im Web
[8] J. von zur Gathen, Cryptography I, Skript zu den Vorlesungen zur Kryptographie, Universität Paderborn, Version vom März 2002
[9] J. von zur Gathen & J. Gerhard, Modern Computer Algebra, Cambridge University Press
1999
[10] G. Hardy, E. Wright, Zahlentheorie, R. Oldenbourg, München, 1958, Übersetzung ins
Deutsche des Orginaltitels An Introduction to the Theory of Numbers erschienen bei Cambridge University Press
[11] K. Ireland, M. Rosen, A Classical Introduction to Modern Number Theorie, Graduate
Texts in Mathematics 84, Second Edition, Springer-Verlag, 1990
[12] K.-H. Kiyek, F. Schwarz, Lineare Algebra, Teubner Studienbücher Mathematik,
B. G. Teubner, 1999
[13] N. Koblitz, A Course in Number Theory and Cryptograpy, Graduate Texts in Mathematics 114, Second Edition, Springer-Verlag, 1994
84
LITERATURVERZEICHNIS
85
[14] U. Krengel, Einführung in die Wahrscheinlichkeitstheorie und Statistik, Vieweg Studium
– Aufbaukurs Mathematik, 5. Auflage, Vieweg Verlag, 2000
[15] H. Kurzweil, B. Stellmacher, Theorie der endlichen Gruppen – Eine Einführung, Springer Lehrbuch, 1. Auflage, Springer-Verlag, 1998
[16] A. J. Menezes, P. C. van Oorschot, S. A. Vanstone, Handbook of Applied Cryptography,
CRC Press, Boca Raton, Florida, 1997
[17] G. Scheja, U. Storch, Lehrbuch der Algebra (Unter Einschluß der Linearen Algebra)
Teil 1, Mathematische Leitfäden, B. G. Teubner, 1994
[18] G. Scheja, U. Storch, Lehrbuch der Algebra Teil 2, Mathematische Leitfäden,
B. G. Teubner, 1994
[19] A. Weil, Basic Number Theory, Die Grundlehren der Mathematischen Wissenschaften
in Einzeldarstellungen Vol. 144, Springer-Verlag, 1973
Zugehörige Unterlagen
Herunterladen