Algorithmische Kryptographie - Lehrstuhl Informatik 1 - RWTH

Skript zur Vorlesung
Algorithmische Kryptographie
an der RWTH Aachen
PD Dr. Walter Unger
Lehrstuhl Informatik 1
2. Februar 2016
Inhaltsverzeichnis
1
2
3
Symmetrische Verfahren
1.1 Data Encryption Standard . . . . . . . . . . . .
1.1.1 Schlüsselverarbeitung . . . . . . . . .
1.1.2 Datenfluss . . . . . . . . . . . . . . . .
1.1.3 Die Funktion f . . . . . . . . . . . . .
1.1.4 Zusammenfassung und Entschlüsselung
1.2 International Data Encryption Algorithm . . . .
1.2.1 Entschlüsselung . . . . . . . . . . . .
1.3 Advanced Encryption Standard . . . . . . . . .
Grundlagen der Public-Key-Systeme
2.1 Grundmuster . . . . . . . . . . . .
2.2 Rucksackverfahren . . . . . . . . .
2.2.1 Mathematischer Hintergrund
2.2.2 Ver- und Entschlüsselung . .
2.2.3 Sicherheitsaspekte . . . . .
2.3 RSA . . . . . . . . . . . . . . . . .
2.3.1 Mathematischer Hintergrund
2.3.2 RSA System . . . . . . . .
2.4 Rabin . . . . . . . . . . . . . . . .
2.4.1 Mathematischer Hintergrund
2.4.2 System von Rabin . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
4
6
7
7
9
10
11
13
14
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
18
19
20
21
21
23
24
24
25
28
28
35
Sicherheitsaspekte und Hilfsfunktionen
3.1 Hashfunktionen . . . . . . . . . . . . . . . . . . . . . .
3.2 Sicherheitsaspekte von RSA . . . . . . . . . . . . . . .
3.2.1 OAEP (optimal asymmetric encryption padding)
3.2.2 Weitere Angriffe . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
37
37
39
40
41
1
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
42
44
44
47
48
49
50
Weitere Public-Key-Systeme
4.1 ElGamal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.2 Elliptische Kurven . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.3 Quantenkryptographie . . . . . . . . . . . . . . . . . . . . . . . . . . .
51
51
53
59
3.3
3.4
4
3.2.3 Sicherheitsaspekte . . . . . .
Bit-Sicherheit . . . . . . . . . . . . .
3.3.1 Notationen und Algorithmus .
Bestimmung von Primzahlen . . . . .
3.4.1 Solovay-Strassen . . . . . . .
3.4.2 Miller-Rabin . . . . . . . . .
3.4.3 Deterministischer Primzahltest
2
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Vorwort
Das Skript wurde für die Vorlesung Algorithmische Kryptographie an der RWTH Aachen erstellt und basiert auf den Folien aus dem Wintersemester 2015/2016. Wenn Kapitel mit dem
Symbol
markiert sind, hilft der jeweils dazu gehörige Foliensatz von http://algo.rwthaachen.de/Lehre/WS1516/VAK.php durch animierte Bilder für das Verständnis.
Sollten inhaltliche oder sprachliche Fehler auffallen kann durch eine E-Mail mit einem Korrekturvorschlag an [email protected] eine verbesserte Version zu Stande
kommen, sodass das Skript über Zeit betrachtet hoffentlich gegen ein Optimum konvergiert.
3
Kapitel 1
Symmetrische Verfahren
Die Anfänge der Kryptographie liegen weit in der Vergangenheit und können nicht klar
bestimmt werden. Es wird vermutet, dass die Kryptographie zusammen mit der Schrift entstand. Es bestand die Notwendigkeit, den Inhalt einer Nachricht nur wenigen Eingeweihten
zugänglich zu machen. Bereits die Ägypter nutzten 1900 v. Chr. unübliche Hieroglyphen
zur Verschlüsslung von Nachrichten.
Die Atbash-Methode wurde 600 v. Chr. für das Hebräische Alphabet entwickelt. Das
Verfahren permutiert die Buchstaben des verwendeten Alphabetes auf festgelegte Art. Jeder
Buchstabe x in einem Alphabet mit n Buchstaben wird folgendermaßen abgebildet:
x 7→ n − 1 − x mit x ∈ {0, . . . , n − 1}
Die bekannte Caesar-Verschlüsselung, welche gerüchteweise von Caesar verwendet
wurde, basiert auch auf der Idee die Buchstaben des Alphabets zu permutieren. Zur Verund Entschlüsselung wird ein Schlüssel k benötigt, der die Permutation der Buchstaben
bestimmt. Jeder Buchstabe x in einem Alphabet mit n Buchstaben wird bei der Verwendung
des Schlüssels k folgendermaßen abgebildet:
x 7→ x + k mod n mit x ∈ {0, . . . , n − 1}
Im Verlauf der Geschichte sind viele kryptographische Verfahren entstanden. Angetrieben durch den ersten Weltkrieg und den technologischen Fortschritt entstanden ab
1900 viele Verfahren. Eines der bekanntesten Verfahren aus dieser Zeit ist die berühmte
Enigma Verschlüsselung. Mit der Entwicklung des Internets und den neuen technologischen Möglichkeiten ab den 1970er Jahren entstanden viele der noch heute verwendeten
Verfahren. Die Abbildung 1.1 zeigt Zeitleisten, die die bekanntesten Verfahren in einen
zeitlichen Kontext einordnen.
4
Steg.gr.
unüb.H.gly.
Skytale
Caesar
Atbash
-2000
-1500
-1000
Phelippes
-500
0
500
1000
Playfair
Enigma
Babbage
Hill
Jefferson
1500
M-209
One-Time Pad
Kasiski
1850
Vigenere
Alkindus
1900
1950
Rabin
KS
RSA
PkS
ElGamal
DES
1950
1960
1970
1980
IDEA
AES
1990
2000
Abbildung 1.1: Zeitstrahl der Verfahren in einen zeitlichen Kontext einordnet.
Das Ziel eines kryptographischen Verfahrens ist es Klartext zu verschlüsseln, sodass die
enthaltende Information langfristig geschützt ist. Die Entschlüsselung ohne einen Schlüssel
muss sehr schwierig sein, um Sicherheit zu gewähren. Um eine praktikable Anwendung zu
ermöglichen, sollte die Umwandlung von Klartext in Geheimtext effizient sein. Zudem sollte
das Verfahren möglichst einfach sein, um eine fehlerfreie Implementation zu gewährleisten.
Da die Sicherheit bei einem Verschlüsselungsverfahren meist auf einem nicht effizient
lösbaren mathematischen Problem basiert, sollte das Verfahren möglichst wenig geheim
und am besten - bis auf einen geheimen Schlüssel - öffentlich einsehbar sein.
Wenn bei einem kryptographischen Verfahren zur Ver- und Entschlüsselung nur ein
Schlüssel verwendet wird oder sich das Schlüsselpaar effizient aus einem Schlüssel berechnen lässt, dann spricht man von einem symmetrischen Verfahren. In Abbildung 1.2 ist die
allgemeine Funktionsweise solcher Verfahren zu erkennen.
Im Nachfolgenden wird die Verschlüsselung einer Nachricht w als das Anwenden einer
Funktion E(w) = c aufgefasst. Die Funktion D ist analog als Umkehrfunktion von E
definiert und beschreibt somit die Entschlüsselung einer Nachricht c, sodass D(c) = w gilt.
Definition 1.1 Ein Verschlüsselungsverfahren heißt symmetrisch, falls man aus E[D] (und
Schlüssel k) direkt auf D[E] schließen kann.
5
Empfänger
Sender
k
sicher
sicher
Kennt: E, D, k, w
Kennt: E, D, k, c, w
Sendet: E, D, k, c
Bestimmt: w = Dk (c)
E, D, c
unsicher
unsicher
Bestimmt: c = Ek (w)
Lauscher
Kennt: E, D, c
Empfänger: E, D, k
Sender: E, D, k, w
Bestimmt: c = Ek (w)
c
Bestimmt: w = Dk (c)
Abbildung 1.2: Funktionsweise von symmetrischen Verfahren.
Da die Informationen nur durch den Schlüssel geschützt sind und niemals durch das
Verfahren, spielt die Wahl des Schlüssels eine entschiedene Rolle. Zudem müssen alle
Kommunikationsteilnehmer den Schlüssel über einen sicheren, nicht abhörbaren Kanal
erhalten. Dies kann dazu führen, dass die Verwaltung der verschiedenen Schlüssel sehr
aufwendig wird.
1.1
Data Encryption Standard
Das DES-Verfahren (Data Encryption Standard) wurde 1978 vom amerikanischen NBS
(National Bureau of Standards) veröffentlicht und war damit das erste öffentlich bekanntgegebene Kryptoverfahren überhaupt. Da es die Ver- und Entschlüsselung schnell ermöglicht
und relativ sicher war, wurde es der erste kryptographische Standard. Da jeder Schlüssel
des ursprünglichen DES-Verfahrens immer eine Länge von 56 Bit hat und das Verfahren
relativ kompliziert ist, sollte das Verfahren heutzutage nur noch in abgewandelter Form
(Triple-DES, Multi-DES, DESX, . . . ) verwendet werden. Das Verfahren teilt die Nachricht
in Blöcke der Länge 64 Bit, die unabhängig voneinander verschlüsselt werden. Die Abbildung 1.6 zeigt die Funktionsweise des Verfahrens, welche im Folgenden Stück für Stück
erläutert wird.
64
EkDES : Z64
Bitabbildung, mit k ∈ Z56
2 → Z2
2
6
1.1.1
Schlüsselverarbeitung
Zur Sicherheit wird der Schlüssel der Länge 56 Bits
mit Parity-Bits auf den Positionen 8, 16, . . . , 64
übertragen. Der Schlüssel wird somit künstlich auf
64 Bits vergrößert.
Die echten Einträge im Schlüssel (ohne Parity-Bits)
werden permutiert und in zwei Blöcke C0 und D0
aufgeteilt. Die resultierenden Blöcke der Länge 28
Bits sind in Abbildung 1.3 zu sehen.
Aus den Blöcken Ci−1 und Di−1 werden für 1 6
i 6 16 die Blöcke Ci und Di durch zyklische
Links-Shifts bestimmt. D.h. Der Block C1 hat an
erster Stelle das Bit stehen, das im ursprünglichen
Schlüssel an Position 49 stand und an letzter Stelle
das Bit, das im ursprünglichen Schlüssel an Position 57 stand.
Aus den Ci und Di wird durch Selektion und Permutation nach Tabelle 1.1 ein Ki bestimmt.
14
3
23
16
41
30
44
46
17
28
19
7
52
40
49
42
11
15
12
27
31
51
39
50
24
6
4
20
37
45
56
36
1
21
26
13
47
33
34
29
5
10
8
2
55
48
53
32
C0 :
D0 :
57
49
41
33
25
17
9
1
58
50
42
34
26
18
10
2
59
51
43
35
27
19
11
3
60
52
44
36
63
55
47
39
31
23
15
7
62
54
46
38
30
22
14
6
61
53
45
37
29
21
13
5
28
20
12
4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
Schlüssel
Tabelle 1.1: Permutationstabelle der Ci und Di .
Abbildung 1.3: Schlüsselaufteilung
Somit steht zum Beispiel das erste Bit in Ci an fünfter Stelle in Ki . Das erste Bit in
Di befindet sich an vorletzter Stelle in Ki . Jedes Ki hat eine Länge von 48 Bits, da die Bits
an Position 9, 18, 22, 25, 35, 38, 43 und 54 nicht selektiert werden.
1.1.2
Datenfluss
Die 64 Bits der Eingabe w werden nach der Tabelle 1.2 permutiert. D.h. dass nach der
Permutation das Bit, das in w an Position 2 stand, sich nun an Position 8 befindet. Der
permutierte Block wird anschließend in zwei Hälften L0 und R0 mit jeweils 32 Bits
7
geteilt. Die obere Hälfte der Tabelle 1.2 wird zu L0 und die untere Hälfte wird R0 . Die
resultierenden R0 und L0 sind links in Abbildung 1.4 zu sehen.
58
60
62
64
57
59
61
63
50
52
54
56
49
51
53
55
42
44
46
48
41
43
45
47
34
36
38
40
33
35
37
39
26
28
30
32
25
27
29
31
18
20
22
24
17
19
21
23
10
12
14
16
9
11
13
15
2
4
6
8
1
3
5
7
Tabelle 1.2: Permutationstabelle der Eingabe
Die Blöcke Ri−1 werden für 1 6 i 6 16 zu den Blöcken Li und die Blöcke Ri entstehen
aus einer bitweisen XOR Operation des Blocks Li−1 , wie in Abbildung 1.4 gezeigt ist,
mit dem Ergebnis einer Funktion f , die im nächsten Abschnitt näher erläutert wird. Die
Funktion f hat als Eingabe den Block Ri−1 und den block Ki , der im vorherigen Abschnitt
näher erläutert wurde.
Für die spätere Entschlüsselung ist es wichtig, dass der Block Ri−1 immer identisch zu
dem Block Li ist. Wie die Blöcke gehandhabt werden ist in Abbildung 1.4 zu sehen.
Xor
57 49 41 33 25 17
9
1
59 51 43 35 27 19 11
3
61 53 45 37 29 21 13
5
R0 : 63 55 47 39 31 23 15
7
58 50 42 34 26 18 10
2
60 52 44 36 28 20 12
4
62 54 46 38 30 22 14
6
L0 : 64 56 48 40 32 24 16
8
Xor
R1 :
R2 :
L1 :
L2 :
Abbildung 1.4: Verarbeitung der permutierten und aufgeteilten Eingabe.
Am Ende der Verschlüsselung werden die Blöcke L16 und R16 vertauscht und nach der
Tabelle 1.3 permutiert. Somit ist das achte Bit in R16 nach der Permutation das erste Bit der
Ausgabe. Das erste Bit von L16 ist in der Ausgabe an Position 58.
8
58
60
62
64
57
59
61
63
50
52
54
56
49
51
53
55
42
44
46
48
41
43
45
47
34
36
38
40
33
35
37
39
26
28
30
32
25
27
29
31
18
20
22
24
17
19
21
23
10
12
14
16
9
11
13
15
2
4
6
8
1
3
5
7
Tabelle 1.3: Letzte Permutationstabelle der Eingabe
1.1.3
Die Funktion f
Die Funktion f verbindet die aus dem Schlüssel gewonnen Blöcke Ki mit jeweils einem
Ri−1 . Bevor die beiden Blöcke durch eine bitweise XOR Operation verbunden werden,
wird der Block Ri−1 nach der Tabelle 1.4 permutiert und vergrößert, wie in Abbildung
1.5 dargestellt. Einige der 32 Bits von Ri−1 werden doppelt verwendet um eine Länge
von 48 Bit zu erreichen. Somit steht zum Beispiel an zweiter und letzter Stelle nach der
Permutation das erste Bit des Blocks Ri−1 .
32
4
8
12
16
20
24
28
1
5
9
13
17
21
25
29
2
6
10
14
18
22
26
30
3
7
11
15
19
23
27
31
4
8
12
16
20
24
28
32
5
9
13
17
21
25
29
1
Tabelle 1.4: Permutationstabelle der Ri−1 .
Anschließend wird das Resultat aus der bitweisen XOR Operation des Blocks Ki
mit dem permutierten und vergrößerten Ri−1 in 8 Blöcke B1 , . . . B8 der Größe 6 Bit
aufgeteilt. Jeder Block Bi = (a1 , . . . , a6 ) wird durch einen Eintrag in einer Tabelle Si
auf 4 Bit reduziert. Die integer Repräsentation der binär Zahlen xi = int(a1 a6 ) und
yi = int(a2 a3 a4 a5 ) bestimmen dabei über den Eintrag in einer Tabelle Si , die Zahlen
zwischen 0 und 15 enthält. Die Zahl in Zeile xi und Spalte yi wird in eine Binärzahl der
Länge 4 Bit umgerechnet und anschließend werden die Ergebnisse, wie in Abbildung 1.5
zu sehen ist, zu einem Block der Länge 32 Bit zusammengesetzt. Auf diesen Block, der aus
Ki und Ri−1 durch verschiedenen Operationen entstanden ist, wird anschließend mit Li−1
eine bitweise XOR Operation angewendet. Das Resultat wird der neue Block Ri .
9
Xor
32
4
8
12
16
20
24
28
1
5
9
13
17
21
25
29
2
6
10
14
18
22
26
30
3
7
11
15
19
23
27
31
4
8
12
16
20
24
28
32
5
9
13
17
21
25
29
1
1
9
17
25
2
10
18
26
3
11
19
27
4
12
20
28
5
13
21
29
6
14
22
30
S1
S3
S5
S7
S8
1
9
17
25
7
15
23
31
8
16
24
32
2
10
18
26
3
11
19
27
4
12
20
28
16
1
2
19
7
15
8
13
20
23
24
30
21
26
14
6
29
5
32
22
5
13
21
29
6
14
22
30
7
15
23
31
12
18
27
11
28
31
3
4
17
10
9
25
S6
S4
S2
8
16
24
32
Abbildung 1.5: Arbeitsweise der Funktion f .
1.1.4
Zusammenfassung und Entschlüsselung
In Abbildung 1.6 ist das Zusammenspiel der Eingabeverarbeitung, Schlüsselverarbeitung
und der Funktion f zu sehen. Da der Klartext mit einem Teilschlüssel Ki in den Blöcken
Ri und Li verschlüsselt wird, muss zur Entschlüsselung das Verschlüsselungsverfahren
in umgekehrter Reihenfolge angewandt werden. Daher folgt aus der Verschlüsselung
Li := Ri−1 und Ri := Li−1 ⊕ f (Ri−1 , Ki ) die folgende Entschlüsselung Ri−1 := Li und
Li−1 := Ri ⊕ f (Li , Ki ).
10
D0 :
lsf 1 lsf 1
lsf 1 lsf 1
C0 :
C1 :
D1 :
C2 :
D2 :
K1 :
K16 :
Schlüssel
Xor
Xor
Eingabe
Xor
Xor
R0 :
R1 :
R2 :
L0 :
L1 :
L2 :
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Ausgabe
L16 :
R16 :
Abbildung 1.6: Funktionsweise von DES.
1.2
International Data Encryption Algorithm
Das Verschlüsselungsverfahren IDEA (International Data Encryption Algorithm) teilt für
die Verschlüsselung den Klartext m in Blöcke der Länge 64 Bit, die dann mit Hilfe eines
Schlüssels k der Länge 128 Bit verschlüsselt werden. Intern teilt der VerschlüsselungsAlgorithmus die 64 Bit in vier Blocks i11 , i12 , i13 , i14 der Größe 16 Bit und verarbeitet diese
mit Teilschlüsseln der gleichen Länge in insgesamt 9 Runden zu einem Geheimtext.
Dabei verwenden die ersten i 6 8 Runden jeweils 6 Teilschlüssel z1i bis z6i . Für die
ersten 8 Teilschlüssel z11 bis z61 , z12 und z22 wird der Schlüssel k in 8 gleichgroße zyklische
Teile geteilt. Für die nächsten 8 Teilschlüssel wird jedes Bit in k um 25 Positionen nach links
geschoben und das Verfahren erneut verwendet. Da die neunte Runde nur 4 Teilschlüssel
benötigt, wiederholt sich die Methode solange bis 52 Teilschlüssel generiert wurden.
Die Idee bei der Verschlüsselung mit IDEA ist das Mischen von drei Operationen, die
keine algebraischen Gemeinsamkeiten haben. Dabei werden die Operationen ⊕ (bitweises XOR), + (Addition modulo 216 ) und (Multiplikation modulo 216 + 1 (0 ≡ 216 ))
verwendet.
In der ersten Runde werden die Blöcke i1 bis i4 mit den ersten sechs Teilschlüsseln
1
z1 bis z61 verarbeitet. Mit welchen Operationen und Teilschlüsseln die Eingabe verarbeitet
11
wird ist in Abbildung 1.7 gezeigt. Dabei stellen die roten Knoten das bitweise XOR, die
grünen die Addition und die blauen die Multiplikation dar. Die Ausgabe der ersten Runde
wird dann als Eingabe i21 bis i24 für die zweite Runde verwendet und mit den nächsten sechs
Teilschlüsseln z12 bis z62 auf gleiche Art und Weise verarbeitet. Dieses Verfahren wiederholt
sich bis die achte Runde abgeschlossen ist und man i81 bis i84 als Eingabe für die letzte
Runde erhält.
z1i
z2i
+
z3i
z4i
+
⊕
Runde i
⊕
z5i
+
+
z6i
⊕
⊕
⊕
⊕
Abbildung 1.7: Funktionsweise der Runden i 6 8.
In der letzten Runde werden die vier Eingabe Blöcke mit jeweils einem Schlüssel zi9
verrechnet. In der Abbildung 1.8 ist zu sehen, dass i81 mit z19 und i84 mit z49 multipliziert
wird und die Blöcke ihre Position beibehalten. Die Eingabe i83 wird mit z29 addiert und als
zweiter Block ausgegeben. Der dritter Block des Geheimtexts entspricht dem Ergebnis der
Addition von i82 mit z39 .
z19
z29
z39
+
+
z49
Abbildung 1.8: Funktionsweise der Runden 9.
12
1.2.1
Entschlüsselung
Für die Entschlüsselung wird das gleiche Verfahren mit veränderten Teilschlüsseln verwendet. Da die Schlüssel Z1i und Z4i bei der Verschlüsselung immer zur Multiplikation
verwendet werden, muss für die Entschlüsselung das multiplikativ Inverse der Schlüssels
gebildet werden. Die Schlüssel Z2i und Z3i werden bei der Verschlüsselung zur Addition
verwendet. Daher müssen bei der Entschlüsselung diese Schlüssel durch ihr additiv Inverses
ersetzt werden. In der Tabelle 1.5 ist das Verhältnis zwischen den Teilschlüsseln und deren
Reihenfolge für die Ver- und Entschlüsselung dargestellt.
1.
2.
3.
4.
5.
6.
7.
8.
9.
Z11
Z12
Z13
Z14
Z15
Z16
Z17
Z18
Z19
Verschlüsseln
Z31 Z41 Z51
Z32 Z42 Z52
Z33 Z43 Z53
Z34 Z44 Z54
Z35 Z45 Z55
Z36 Z46 Z56
Z37 Z47 Z57
Z38 Z48 Z58
Z39 Z49
Z21
Z22
Z23
Z24
Z25
Z26
Z27
Z28
Z29
Z61
Z62
Z63
Z64
Z65
Z66
Z67
Z68
−1
Z19
−1
Z18
−1
Z17
−1
Z16
−1
Z15
−1
Z14
−1
Z13
−1
Z12
−1
Z11
Entschlüsseln
−1
−Z39 Z49
−1
−Z28 Z48
−1
−Z27 Z47
−1
−Z26 Z46
−1
−Z25 Z45
−1
−Z24 Z44
−1
−Z23 Z43
−1
−Z22 Z42
−1
−Z31 Z41
−Z29
−Z38
−Z37
−Z36
−Z35
−Z34
−Z33
−Z32
−Z21
Z58
Z57
Z56
Z55
Z54
Z53
Z52
Z51
Z68
Z67
Z66
Z65
Z64
Z63
Z62
Z61
Tabelle 1.5: Teilschlüssel für die Ent- und Verschlüsselung.
In Abbildung 1.9 sind die letzten beiden Schritte der Verschlüsselung mit Zwischenergebnissen a, a0 , b, b0 , c, c0 , d und d0 zu sehen. In einer Runde i 6 8 gilt, dass der erste Block
des Ergebnisses a = a0 ⊕ fr (a0 ⊕ c0 , b0 ⊕ d0 )und der letzte Block c = c0 ⊕ fr (a0 ⊕ c0 , b0 ⊕ d0 )
ist.
Da wir ein bitweises XOR verwenden, wissen wir auch, dass a0 = a ⊕ fr (. . .) und
c0 = c ⊕ fr (. . .) gilt. Des weiteren muss auch a ⊕ a0 = fr (. . .) = c ⊕ c0 gelten.
Diese Gleichung führt zu dem Ergebnis a ⊕ c = a0 ⊕ c0 . Analog kann man zeigen, dass
b ⊕ d = b0 ⊕ d0 gilt.
Diese Resultate können nun die Eingabe der Funktion fr ersetzen. Somit gilt für die
Entschlüsselung
a0 = a ⊕ fr (a ⊕ c, b ⊕ d) .
13
z18
+
z28
z38
+
z48
⊕
⊕
Runde 8
a0
b0
z58
c0
d0
+
f
z68
+
⊕
fr
⊕
⊕
a
z19
m
⊕
c
b
z29
z39
+
n
+
d
z49
o
p
Abbildung 1.9: Verschlüsselung mit Zwischenergebnissen.
Somit kann das gleiche Verfahren, das zur Verschlüsselung genutzt wurde, mit veränderten Teilschlüsseln zur Entschlüsselung genutzt werden
1.3
Advanced Encryption Standard
Das Verschlüsselungverfahren AES (Advanced Encryption Standard) wurde als Nachfolger für DES
RundenNb
entwickelt. AES ist eine Einschränkung des Rijndael- anzahl Nr 4 5 6 7 8
Algorithmus, da die Blockgröße Nb ·32 fest 128 Bit ist
4
10 11 12 13 14
5
11 11 12 13 14
und die Wahl der Schlüssellänge Nk · 32 auf 128, 192
6
12 12 12 13 14
oder 256 Bit beschränkt ist. In der Tabelle 1.6 ist die Nk
7
13 13 13 13 14
Anzahl der für die Verschlüsselung notwendigen Run8
14 14 14 14 14
den angegeben, die beim Rijndael-Algorithmus von
Nk und Nb abhängen. AES hat somit 10, 12 oder 14 Tabelle 1.6: Rundenanzahl des
Runden in denen eine Nachricht verschlüsselt wird. Rijndael-Algorithmus.
Die Eingabe p0 , p1 , . . . p4·Nb −1 wird in eine Tabelle mit 32 Spalten und Nb Zeilen umgewandelt, wobei |pi | aus einem Byte besteht. Somit
14
steht in der ersten Spalte p0 , p1 , p2 und p3 , die zusammen eine Länge von 4 Byte = 32 Bit
haben.
Der Schlüssel k0 , k1 , . . ., k4·Nk −1 wird in eine Tabelle mit 32 · Nk Spalten und Nb Zeilen
umgewandelt, wobei |ki | aus einem Byte besteht. Somit stehen die ersten ki mit i < 2 · Nk
in der ersten Spalte. In Abbildung 1.10 ist die Aufteilung des Schlüssels und der Eingabe
für Nk = 6 und Nb = 4 zu sehen.
k0,0 k1,0 k2,0 k3,0 k4,0 k5,0
p0,0 p1,0 p2,0 p3,0
a0,0 a1,0 a2,0 a3,0
c0,0 c1,0 c2,0 c3,0
k0,1 k1,1 k2,1 k3,1 k4,1 k5,1
p0,1 p1,1 p2,1 p3,1
a0,1 a1,1 a2,1 a3,1
c0,1 c1,1 c2,1 c3,1
k0,2 k1,2 k2,2 k3,2 k4,2 k5,2
p0,2 p1,2 p2,2 p3,2
a0,2 a1,2 a2,2 a3,2
c0,2 c1,2 c2,2 c3,2
k0,3 k1,3 k2,3 k3,3 k4,3 k5,3
p0,3 p1,3 p2,3 p3,3
a0,3 a1,3 a2,3 a3,3
c0,3 c1,3 c2,3 c3,3
Abbildung 1.10: Konzept der AES Verschlüsselung mit Nk = 6.
Der Rijndael-Algorithmus verarbeitet die Eingabe in einen so genannten State, der in
mehreren Runden verändert wird bis am Ende der Geheimtext c0 , c1 , . . ., c4·Nb −1 resultiert.
Der Algorithmus 1 hat fünf unterschiedliche Arbeitsschritte, die im folgenden näher erklärt
werden.
Algorithm 1 Rijindale(State, CipherKey)
1: KeyExpansion(CipherKey,ExpandedKey);
2: AddRoundKey(State,ExpandedKey[0]);
3: for i := 1; i < Nr ; i + + do
4:
SubBytes(State);
5:
ShiftRows(State);
6:
MixColumns(State);
7:
AddRoundKey(State,ExpandedKey[i]);
8: end for
9: SubBytes(State);
10: ShiftRows(State);
11: AddRoundKey(State,ExpandedKey[Nr ]);
Die Operation SubBytes(State) verändert jedes Byte in State folgendermaßen: SRD (ai ) =
g(ai ) f (ai ). Die Teil-Funktion g betrachtet das Byte ai als Polynom über F2 und rechnet
8
4
3
g(ai ) := a−1
i mod m(x) = x + x + x + x + 1 .
15
Die Teil-Funktion f interpretiert jedes Byte als Vektor und macht folgende Berechnungen:






f (~a) = 





1
0
0
0
1
1
1
1
1
1
0
0
0
1
1
1
1
1
1
0
0
0
1
1
1
1
1
1
0
0
0
1
1
1
1
1
1
0
0
0
0
1
1
1
1
1
0
0
0
0
1
1
1
1
1
0
0
0
0
1
1
1
1
1


 
 
 
 
 
×
 
 
 
 
 
a7
a6
a5
a4
a3
a2
a1
a0


 
 
 
 
 
⊕
 
 
 
 
 
0
1
1
0
0
0
1
1












Die Operation ShiftRows(State) verschiebt die 32 Bit in Zeile i ∈ {0, 1, 2, 3} um Ci Positionen
zyklisch nach links. Die Ci hängen von Nb ab, wobei das Nb bei AES auf 4 festgesetzt ist, wodurch
jedes Ci die Zeile i um genau i Positionen zyklisch nach links verschiebt.
Die Operation MixColumns(State) betrachtet jede Zeile ai ai+1 ai+2 ai+3 der Länge 4 Byte als
Polynom Ai in F2 . Sämtliche Rechnungen werden wie Berechnungen mit Polynomen modulo x4 + 1
durchgeführt. Somit erhält man:


 


b0
02 03 01 01
A0
 01 02 03 01   A1 
 b1 


 


 b2  ←−  01 01 02 03  ×  A2 
A3
b3
03 01 01 02
Jedes Ergebnis bi wird wieder in eine Zeile ai ai+1 ai+2 ai+3 des States geteilt.
Die Operation AddRoundKey(State,ExpandedKey[i]) bildet die bitweise symmetrische Differenz zwischen dem State und Teilschlüssel (XOR).
Algorithm 2 KeyExpansion(CipherKey,ExpandedKey) falls Nk 6 6
1: W [i][j] ← K[i][j] für 0 6 i < 4, 0 6 j < Nk
2: for j := Nk ; j < Nb (Nr + 1); j + + do
3:
if j mod Nk == 0 then
4:
W [0][j] = W [0][j − Nk ] ⊕ SRD (W [1][j − 1]) ⊕ RC[j/Nk ]
5:
W [i][j] = W [i][j − Nk ] ⊕ SRD (W [(i + 1) mod 4][j − 1])
6:
für 0 6 i < 4
7:
else
8:
W [i][j] = W [i][j − Nk ] ⊕ W [i][j − 1] für 0 6 i < 4
9:
end if
10: end for
Mit Hilfe der Operation KeyExpansion(CipherKey,ExpandedKey) wird aus dem Schlüssel der
Größe 4 · Nk Byte für jede der Nr + 1 Runden ein Teilschlüssel der Größe 4 · Nb Byte bestimmt.
16
Im folgenden Algorithmus beschreibt der Array Eintrag K[i][j] das Bit des Schlüssels an Position
ki+4·j , SRD sind S-Boxen und RC[j] wird folgendermaßen berechnet:
Jedes Byte wird wieder als Polynom über F2 betrachtet und modulo m(x) = x8 +x4 +x3 +x+1
verrechnet. Daraus ergibt sich für RC[1] = x0 = (01), RC[2] = x1 = (02) und RC[j] =
x · RC[j − 1] für j > 2.
Der Algorithmus 2 wird im Fall Nk 6 6 verwendet und bei längeren Schlüsseln wird eine
leichte Abwandlung, die in Algorithmus 3 zu sehen ist, verwendet.
Algorithm 3 KeyExpansion(CipherKey,ExpandedKey) falls Nk > 6
1: W [i][j] ← K[i][j] für 0 6 i < 4, 0 6 j < Nk
2: for j := Nk ; j < Nb (Nr + 1); j + + do
3:
if j mod Nk == 0 then
4:
W [0][j] = W [0][j − Nk ] ⊕ SRD (W [1][j − 1]) ⊕ RC[j/Nk ]
5:
W [i][j] = W [i][j − Nk ] ⊕ SRD (W [(i + 1) mod 4][j − 1])
6:
für 0 6 i < 4
7:
else if j mod Nk == 4 then
8:
W [i][j] = W [i][j − Nk ] ⊕ SRD (W [i][j − 1])
9:
für 0 6 i < 4
10:
else
11:
W [i][j] = W [i][j − Nk ] ⊕ W [i][j − 1] für 0 6 i < 4
12:
end if
13: end for
Mit dem erweiterten Schlüssel können die Teil-Schlüssel berechnet werden, die in den einzelnen
Runden verwendet werden. Die einzelnen Schlüssel werden folgendermaßen gebildet:
ExpandedKey[i] = W [·][Nb · i] ◦ W [·][Nb · i + 1] ◦ . . . ◦ W [·][Nb · (i + 1) − 1]
(0 6 i 6 Nr ).
Für die Entschlüsselung kann das gleiche Verfahren in umgedrehter Reihenfolge verwendet
werden, wobei einige Operationen mit ihren jeweiligen Umkehroperationen ersetzt werden müssen.
17
Kapitel 2
Grundlagen der Public-Key-Systeme
Bei der Verwendung einer symmetrischen Verschlüsselung kann ein Lauscher aus der Verschlüsselung die Entschlüsselung bestimmen. Des weiteren muss der Schlüssel über einen sicheren Kanal
übermittelt werden und symmetrischen Verfahren bieten nicht die Möglichkeit von Unterschriften.
Um diese Probleme zu lösen entstanden Public-Key-Systeme. In diesen Systemen veröffentlicht
ein Empfänger einen öffentlichen Schlüssel y, mit dem Nachrichten an ihn verschlüsselt werden
können. Der Empfänger hält seinen privaten Schlüssel x, der nicht effizient aus dem Verfahren
und dem öffentlichen Schlüssel berechnet werden kann, geheim. Somit kann jeder den öffentlichen Schlüssel verwenden um Nachrichten so zu verschlüsseln, dass sie nur durch den privaten
Schlüssel des Empfängers wieder entschlüsselt werden können. In diesem System ist der Sender
einer Nachricht in der gleichen Situation wie ein Lauscher, da das Verschlüsselungsverfahren und
der öffentliche Schlüssel allen bekannt sind.
Um ein Public-Key-Systeme zu entwickeln muss eine Funktion Dy zur Verschlüsselung gefunden werden, die nach bisherigem Kenntnisstand nicht effizient aus Ex bestimmt werden kann.
Eine Funktion, die diese Voraussetzung erfüllt, nennt man One-Way-Funktion. Es wurde bisher
noch nicht bewiesen, dass eine One-Way-Funktion existiert. Allerdings gibt es Kandidaten für diese
Funktionen, die zum Beispiel auf folgenden Problemen basieren:
• N P -schwere Probleme (z.B. SAT, Rucksack)
• Polynomringe
• Faktorisierung
• fehlertolerante Codes
• diskrete Wurzel
• Homomorphismen
• diskreter Logarithmus
• endliche Automaten
• diskreter Logarithmus über elliptische Kurven
18
2.1
Grundmuster
Public-Key-Systeme können verwendet werden um Nachrichten sicher zu übertragen, Unterschriften
zu erzeugen und verschließbare Kästen zu erstellen. Die Protokolle für diese drei Anwendungen
arbeiten meist nach einem Grundmuster. In Abbildung 2.1 ist das Grundmuster für die Übertragung
einer Nachricht w zu sehen. Da ein Angreifer des Protokolls in der gleichen Situation wie der
Sender A ist, kann er versuchen alle möglichen Nachricht m0 in Eypks einzusetzen bis das richtige
m0 gefunden wurde, so dass Eypks (m0 ) = c gilt. Wenn der Nachrichtenraum für w groß ist, wird
dieser Angriff nicht rentabel.
A: Dpks , E pks , y, w
c = Eypks (w)
B: Dpks , E pks , x, y, Dxpks , Eypks
c
w = Dxpks (c)
Abbildung 2.1: Grundmuster bei der Übertragung einer Nachricht.
Eine Signatur s entspricht einer Unterschrift unter einer Nachricht m und dient der Authentifizierung. In Abbildung 2.2 kann A durch sein persönliches Geheimnis x verifizieren, dass die
Nachricht m von ihm ist. Ein Angreifer könnte durch die Kenntnis von s, m, y und Dpks versuchen
alle möglichen x0 auszuprobieren bis s = Dxpks
0 (m) gefunden wurde. Wenn der Schlüsselraum für x
groß ist, wird dieser Angriff nicht rentabel.
A: Dpks , E pks , x, y, m
Bestimmt s = Dxpks (m)
m, s
B: E pks , y
?
Testet m = Eypks (s)
Abbildung 2.2: Grundmuster für die Unterschrift unter einer Nachricht.
Um eine Information zu hinterlegen und sie erst später unverändert preiszugeben werden
verschließbare Kästen verwendet. In Abbildung 2.3 hinterlegt A die Nachricht m als verschlossener
Kasten s. A und B können den hinterlegten Kasten nicht mehr verändern. Erst wenn das Geheimnis
x gesendet wurde kann B den Kasten s entschlüsseln und den Inhalt kontrollieren.
19
A: Dpks , E pks , x, y, m
s = Eypks (m)
s
x, m
B: E pks , Dpks , y
Speichert s
?
Testet m = Dxpks (s)
Abbildung 2.3: Grundmuster für verschließbare Kästen.
2.2
Rucksackverfahren
Das Rucksackproblem, das in Definition 2.1 formal beschrieben ist, ist ein bekanntes N P -schweres
Problem und kann daher für die Erstellung eines Public-Key-System verwendet werden. Das Problem
ist in O(2k ) Schritten durch sukzessives Testen jeder Teilmenge I lösbar.
Definition 2.1 (Rucksackproblem (knapsack problem, KS))
Eingabe: r1 , r2 , . . . , rk , s ∈ N,
P
Frage: ∃I ⊂ {1, 2, . . . , k} : i∈I ri = s
P
Ausgabe: I ⊂ {1, 2, . . . , k} : i∈I ri = s
Um ein Public-Key-System zu erstellen, wählt man ein leichtes Teilproblem KSL von KS und
verändert dieses zu KSS , das schwer aussehen soll. Als öffentlicher Schlüssel dient KSS zusammen
mit einer Beschreibung wie die Verschlüsselung funktioniert. Das private Geheimnis ist die leichte
Instanz KSL zusammen mit der Methode wie KSS berechnet wurde bzw. wie es zurück gerechnet
werden kann.
Um eine leichte Instanz des Rucksackproblems zu erstellen wird an den Vektor von Gewichten
R die Bedingung gestellt, dass er stark steigend ist. Diese Variation KSL kann schnell und eindeutig
gelöst werden indem man durch den Vektor R rückwärts iteriert und ein Element ri in die Lösung
nimmt, wenn es kleiner als s ist. Sobald ein Gewicht ri gewählt wurde, muss s angepasst werden.
Definition 2.2 Ein Vektor R = (r1P
, r2 , . . . , rk ) heißt stark steigend genau dann, wenn für alle
j ∈ {2, . . . , k} die Bedingung rj > 16i<j ri erfüllt ist.
Bevor die Erstellung der schweren Instanz KSS erklärt werden kann müssen zu erst die
mathematischen Grundlagen geschaffen werden.
20
2.2.1
Mathematischer Hintergrund
Eine Zahl a ist ein Teiler von einer Zahl b, wenn ein d existiert mit b = a · d, was auch durch a | b
dargestellt werden kann. Sollte a kein Teiler von b sein, so schreibt man a - b. Wenn eine Zahl d
Teiler von zwei Zahlen a und b ist und alle anderen Teiler c dieser Zahlen auch d teilen, dann ist
d der größte gemeinsame Teiler von a und b, und wir schreiben d = ggT(a, b). Wenn der größte
gemeinsame Teiler zweier Zahlen 1 ist, dann sind die Zahlen teilerfremd. Das kleinste gemeinsame
Vielfache zweier ganzer Zahlen a und b ist die kleinste natürliche Zahl m, die sowohl Vielfaches von
a als auch Vielfaches von b ist. Wenn m das kleinste gemeinsame Vielfache von a und b ist, dann
schreiben wir m = kgV(a, b).
Eine Zahl a ist kongruent zu b modulo m, wenn m | a − b gilt. Die Zahl m wird dann der Modul
genannt und wir schreiben a ≡ b (mod m). Der kleinste nicht-negative Rest von x modulo m ist
definiert als a ≡ x (mod m) mit a ∈ {0, 1, . . . , m − 1} und wird mit x (mod m) bezeichnet. Die
Relation ≡ (mod m) ist eine Äquivalenzrelation auf Z. Die Restklasse einer Zahl a modulo m ist
definiert als
[a]m = {a + km | k ∈ Z} für a ∈ {0, 1, . . . , m − 1} .
Aus der Definition des größten gemeinsamen Teilers kann man den Euklidischen Algorithmus zur
Berechnung des selbigen ableiten, der in Algorithmus 4 beschrieben ist. Nach der Definition wissen
wir, dass folgendes gilt:
d | a und d | b ⇔ d | a und d | b mod a
Der Algorithmus 4 kann leicht modifiziert werden um die Faktoren x und y mit ggT(a, b) = xa+yb
zu berechnen. Sollten a und b teilerfremd sein, gilt ggT(a, b) = 1 und es muss xa ≡ 1 (mod m)
gelten. Die Zahl x (mod m) wird dann multiplikativ Inverses von a genannt und vereinfacht als
a−1 (mod m) bezeichnet. Da die Berechnungen in einem Restklassenring Z/mZ stattfinden, wäre
die korrekte Schreibweise [a]−1
m . Wenn a und der Modul m teilerfremd sind, lässt sich mit dem
multiplikativ Inversen ein z = a−1 b (mod m) berechnen, sodass az ≡ b (mod m) gilt.
Algorithm 4 EUCLID(a,b)
1: if a == 0 then
2:
return(b)
3: else
4:
return(EUCLID(b mod a, a))
5: end if
2.2.2
Ver- und Entschlüsselung
Um die schwere Instanz des Rucksackproblems RSS zu bestimmen verwenden wir den stark
steigenden Vektor A = (a1 , . . . , an ) der leichten Instantz RSL . Man wählt einen Modul m, der
größer ist als das größte Element aus A, und sucht ein t mit ggT(m, t) = 1, sodass ein multiplikativ
21
Inverses u gefunden werden kann mit u·t ≡ 1 mod m. Der Vektor von Gewichten B = (b1 , . . . , bn )
für RSS entsteht durch modulare Multiplikation:
bi = t · ai
(mod m)
Wenn B aus A durch modulare Multiplikation entsteht, dann kann auch A aus B entstehen. Sollte
das m jedoch größer als die Summe aller ai sein, dann wird die modulare Multiplikation
Pn zu einer
starken modularen Multiplikation und die Aussage gilt nicht mehr. Somit sollte m > i=1 ai gelten
damit man nicht aus der schweren Instanz die leichte berechnen kann.
Um nun das Public-Key-System aufzubauen muss es neben dem m einen öffentlichen und
einen privaten Schlüssel geben. Der Vektor B wird als als öffentlicher Schlüssel verwendet und u
bildet zusammen mit dem stark steigendem Vektor A den privaten Schlüssel. Zum Verschlüsseln
einer Nachricht w ∈ {1, 0}n werden die Einträge bi in B aufsummiert, für die gilt, dass das Bit wi
(Position i in w) gleich 1 ist. Formal:
KS2
EB
(w) =
n
X
ai · wi = c
i=1
Zum Entschlüsseln muss die starke modulare Multiplikation rückgängig gemacht werden indem c
mit dem multiplikativ Inversen von t, dem privaten Teilschlüssel u, multipliziert wird. Anschließend
muss das Vielfache des Moduls m durch die Operation mod m entfernt werden und übrig bleibt
eine Summe s für die gilt:
X
∃I ⊂ {1, 2, . . . , n} :
ai = s
i∈I
Da der private Teilschlüssel A stark steigend ist, kann das Rucksackproblem gelöst und die richtigen
Indizes gefunden werden. Die Nachricht m kann nun über die Index Menge I rekonstruiert werden.
Das Bit mi ist 1, wenn i ∈ I ist und sonst 0.
Lemma 2.3 Sei A = (a1 , . . . , ak ) ein stark steigender Vektor und der Vektor B entsteht aus A
durch starke modulare Multiplikation mittels m und t. Sei weiter u das multiplikativ Inverse zu t
(d.h. u mod m = t−1 ), β beliebig und α = uβ mod m. Dann folgt:
1. Das Rucksackproblem (A, α) ist eindeutig lösbar in Linearzeit (d.h. keine oder eine Lösung,
falls Parameter frei wählbar).
2. Das Rucksackproblem (B, β) hat keine oder genau eine Lösung.
3. Wenn (B, β) eine Lösung hat, dann ist der Lösungsvektor gleich der eindeutigen Lösung von
(A, α).
Da die erste Folgerung unmittelbar einsichtig ist, gehen wir zum Beweis nur auf den 2. und 3. Teil
ein.
22
Beweis: Sei D eine Lösung von (B, β), sodass β = BD gilt. Das Rucksackproblem (A, α) hat die
gleiche Lösung D, da folgendes gilt:
α ≡ uβ = uBD ≡ u(tA)D ≡ AD
(mod m)
Da das m so gewählt wurde, dass starke modulare Multiplikation verwendet wird, gilt des weiteren
AD < m und α < m. Daher gilt auch α = AD.
2.2.3
Sicherheitsaspekte
Ein Angriffspunkt auf dieses Verfahren ist der kleine Zahlenraum für die ersten ai . Die Anzahl an
Bits, die einen Eintrag ai im Vektor A = (a1 , . . . , ak ) repräsentieren, kann durch d · k − 1 − k + i
berechnet werden, wobei d die maximale Wachstumsrate der ai beschreibt, d.h. d ist größtmöglich
und erfüllt ∀i : adi > ai−1 .
Enthält A z.B. k = 100 Einträge und ist stark steigend, muss d mindestens 2 sein. Dann hat der
Eintrag ai höchstens 200 − 1 − 100 + i = 99 + i viele Bits. Somit wird der Zahlenraum der kleinen
ai durch die Bedingung des stark steigenden Vektors sehr eingeschränkt.
Ein Angreifer kann versuchen die Menge aller gültigen A, m und u anhand dieser Einschränkung
für die ersten ai zu bestimmen, da es mindestens ein Paar u, m geben muss, dass durch Berechnung
von u · bi einen stark steigenden Vektor A erzeugt. Dabei muss nicht das ursprüngliche Paar u
und m gefunden werden. Es ist ausreichend ein u0 und m0 zu finden mit dem es möglich ist einen
stark steigenden Vektor A0 zu berechnen, der dann die gleiche Lösung wie der ursprüngliche Vektor
A hat. Wenn die berechneten Werte für die ersten ai gültig sind, dann kann versucht werden alle
bi in ai umzurechnen. Anschließend kann versucht werden den Geheimtext mit allen möglichen
berechneten A0 , m0 und u0 zu entschlüsseln.
Da der Wert eines ai mit bi , u0 und m0 berechnet werden kann, kann man die Berechnung als
Funktion fbi (u0 , m0 ) = u0 · bi (mod m)0 über die Unbekannten u0 und m0 darstellen. Da m0 der
u0
Modul ist und die Werte von u0 begrenzt, können die Unbekannten zu m
0 zusammen gefasst werden.
Somit erhält man die Funktion:
u0
ai
u0
fbi ( 0 ) = 0 · bi = 0
m
m
m
Dem Angreifer ist nur der öffentliche Schlüssel B = (b1 , . . . , bk ) bekannt. Als erstes wird
überprüft ob ein Minimum bp1 von fb1 nahe bei einem Minimum bq2 von fb2 liegt. Dafür wird
bestimmt ob es für 1 6 p 6 b1 − 1 und 1 6 q 6 b2 − 1 ein δ gibt mit:
−δ < b2 · p − b1 · q < δ
0
u
Wie viele der ersten bi verwendet werden um ein geeignetes m
0 zu finden und wie viele mögliche
Kandidaten für u0 und m0 gesucht werden liegt im Ermessen des Angreifers und ist unabhängig
vom Verfahren. Je mehr Funktionen fbi verwendet werden, q
desto mehr Ungleichungen müssen
berücksichtigt werden. Zusammen mit der Beschränkung δ <
23
b1
2
erhält man, wenn s Funktionen
berücksichtigt und maximal r Kandidaten bestimmt werden, eine Fehlerwahrscheinlichkeit von
( 2r )s−1 .
Die Minima pbii mit 1 6 pi 6 bi −1 für alle betrachteten bi werden der Größe nach sortiert, sodass
0
u
zwei benachbarte Werte xl und xl+1 ein Intervall, auf dem die Funktionen fbi (xl 6 m
0 6 xl+1 )
keine Sprünge haben, darstellt. Die Funktionen auf diesen Teilstücken haben die Form bi · v − cji ,
wobei cji Konstanten sind, die nicht von i oder j abhängen.
Die potenziellen Ergebnisse der Funktionen bi · v − cji müssen die Eigenschaft der starken
Steigung und der starken modularen Multiplikation erfüllen. Daher muss für eine Variable v
(=u
ˆ 0 /m0 ) mit xl 6 v 6 xl+1 folgendes gelten:
Pk
i=1 (bi v
Pi−1
l=1 (bl v
− ci j ) < 1
starke mod. Multiplikation
− cl j ) < bi v − ci j ,
26i6k
Wenn alle Ungleichungen aufgestellt und umgeformt sind, müssen die v, die aus einem Intervall
(xl , xl+1 ) gewählt werden können, gewisse Bedingungen einhalten, die von den Konstanten cji
abhängen. Somit ist das v nicht nur durch das Intervall, sondern auch durch die Ungleichungen so
stark eingeschränkt, dass alle übrig gebliebenen Möglichkeiten für v (=u
ˆ 0 /m0 ) berechnet werden
können. Nun ist es möglich mit jedem der verhältnismäßig geringen Anzahl übrig gebliebener
Kandidaten für u0 und m0 den Geheimtext zu Entschlüsseln.
2.3
RSA
Im Jahr 1977 entstand RSA als direkter Konkurrent zu DES. Die Grundidee des Algorithmus basiert
auf der Annahme, dass die Multiplikation von Primzahlen leicht ist und dass Faktorisieren ein
schweres Problem ist. Bis Heute erscheint das Verfahren relativ sicher, obwohl es bisher noch keinen
Beweis dafür gibt, dass das Faktorisieren wirklich schwer ist.
2.3.1
Mathematischer Hintergrund
Eine Zahl p > 1 ist eine Primzahl, wenn nur 1 und p Teiler von p sind. Jede Zahl n lässt sich als
Produkt von nicht trivialen Potenzen unterschiedlicher Primzahlen darstellen.
n = pe11 · pe22 · . . . · pekk
Bisher ist kein Algorithmus bekannt mit dem die Primfaktorzerlegung in effizienter Zeit berechnet
werden kann. Selbst wenn k = 2 und e1 = e2 = 1, also n = p1 · p2 gilt, können die Faktoren
nicht effizient berechnet werden. Wenn die Primfaktorzerlegung einer Zahl m bekannt ist, lässt sich
daraus die Eulersche ϕ-Funktion berechnen.
ϕ(m) := |{a ∈ Zm | ggT(a, m) = 1}|
24
Sollte m das Produkt zweier teilerfremden Zahlen a und b sein, so ist ϕ(m = a · b) = ϕ(a) · ϕ(b).
Wenn m sich als Potenz einer Primzahl p darstellen lässt, so gilt ϕ(m = pb ) = pb − pb−1 . Außerdem
gilt der Satz von Euler, der besagt, dass für zwei teilerfremde Zahlen m und a die Potenz aϕ(m) ≡ 1
(mod m) gilt. Falls der Modul eine Primzahl p ist und a kein vielfaches dieser, dann gilt nach dem
Satz von Fermat ap−1 ≡ 1 (mod p) und bp ≡ b (mod p) für jedes b.
Definition 2.4Q(Chinesischer Restsatz) Seien m1 , m2 , . . . , mn ∈ N paarweise teilerfremd, a1 , a2 , . . . , an ∈
Z und M := ni=1 mi . Dann existiert ein eindeutig bestimmtes x0 mit
x0 ≡ ai
(mod mi )
∀i ∈ {1, . . . , n} .
Für die Menge der gültigen Lösungen gilt
{x ∈ Z | x ≡ ai
(mod m)i für i = 1, 2, . . . , n} = {x ∈ Z | x ≡ x0
(mod M )} .
Mit O((log M )2 ) Bit-Operationen kann ein gültiges x0 berechnet werden. Für jedes mi kann ein
M
Mi = m
und mit Algorithmus 4 das jeweils zugehörige multiplikative Ni = Mi−1 (mod mi )
i
berechnet werden. Das Produkt der beiden
P ei = Ni · Mi wird mit ai Multipliziert und über alle i
aufsummiert. Somit ist die Lösung x0 = ni=1 ei ai (mod M ).
2.3.2
RSA System
Um das System aufzubauen müssen zwei große Primzahlen p und q gewählt werden. Das Produkt n = p · q wird Teil des öffentlichen Schlüssels und hilft nicht bei der Berechnung von
ϕ(n) = (p − 1) · (q − 1), welches geheim bleibt. Anschließend muss ein großes d > 1 mit
ggT(d, ϕ(n)) = 1 gewählt und das dazugehörige multiplikativ Inverse e mit e · d ≡ 1 (mod ϕ(n))
bestimmt werden. Veröffentlicht werden e und n um Nachrichten zu verschlüsseln, die nur durch
die Kenntnis von p, q und d wieder entschlüsselt werden können.
Entschlüsselung
Verschlüsselung
RSA : N → N
En,e
n
n
RSA : N → N
Dp,q,d
n
n
RSA (w) = w e mod n
En,e
RSA (c) = cd mod n
Dp,q,e
RSA (w) = w und ggT(w, n) =
Nach dem chinesischen Restklassensatz gibt es vier Zahlen w mit En,e
1. Wenn der größte gemeinsame Teiler größer als 1 ist, ergeben sich noch mehr Möglichkeiten für
gleiche Zahlen. Jedoch ist es dann auch Möglich p und q zu berechnen.
Lemma 2.5 Die Entschlüsselung von RSA ist eindeutig.
Seien w, c, d, e, ϕ(n), p und q wie in RSA gegeben. Um die Korrektheit zu beweisen muss
gezeigt werden, dass die Entschlüsselung w ≡ cd (mod n) gilt. Der öffentliche Schlüssel e ist
25
das multiplikativ Inverse zu d und daher muss ein j existieren für das e · d = jϕ(n) + 1 gilt. Der
nachfolgende Beweis unterscheidet die Teilbarkeit von w in vier Fällen.
Beweis:
• Fall p - w und q - w: Nach dem Satz von Euler gilt
⇒
wϕ(n) ≡ 1
(mod n)
wjϕ(n) ≡ 1
(mod n) .
Es muss ein j existieren mit e · d = jϕ(n) + 1. Somit können wir j · ϕ(n) durch e · d − 1
ersetzen und die Gleichung anschließend umstellen.
wed−1 ≡ 1
⇒
(mod n)
wed ≡ w
(mod n) .
• Fall p | w und q - w: Da q eine Primzahl ist und q - w gilt, können wir den Satz von Fermat
anwenden.
wq−1 ≡ 1 (mod q) .
Wenn wir den Exponenten mit j · (p − 1) erweitern, erhalten wir
wj(q−1)(p−1) ≡ 1
⇒
wjϕ(n) ≡ 1
(mod q)
(mod q) .
Mit e · d = jϕ(n) + 1 ist es wieder möglich j · ϕ(n) durch e · d − 1 zu ersetzen und die
Gleichung anschließend umzustellen. Des weiteren teilt p das w und daher gilt w = wed
(mod p). Daher ist es möglich das q in der Gleichung durch n zu ersetzen.
wed ≡ w
(mod n) .
• Fall p - w und q | w: Analog zu p | w und q - w.
• Fall p | w und q | w: Da beide Primzahlen Teiler von w sind und bei der Verschlüsselung
w < n gewählt wurde, gilt offensichtlich
wed ≡ w
(mod n) .
Da nach der Verschlüsselung c = we gilt, wissen wir nun, dass für alle Fälle cd = w (mod n) gilt.
Ähnlich zu den zwei unterschiedlich schweren Instanzen, die für das Public-Key-System mit
dem Rucksackproblem verwendet werden, wird auch das Problem der Faktorisierung in zwei
Instanzen verwendet. Wenn ϕ(n) bekannt ist kann n = p · q leicht faktorisiert werden, was die
26
Entschlüsselung von xe ≡ c mod n ermöglicht. Ohne die Kenntnis von ϕ(n) bleibt das Faktorisieren
und Entschlüsseln schwer.
Im Vergleich mit dem symmetrischen Verfahren DES ist RSA bei gleicher Schlüsselgröße
um den Faktor 1000 langsamer, bedingt durch die häufig auftretenden Potenz Berechnungen. Der
Algorithmus 5 bestimmt für ein x, r und n die Ausgabe s = xr (mod n) in O(log n).
Algorithm 5 Potenz(x,r,n)
1: x0 := x;
2: s := 1;
3: Sei aI , . . . , a0 die Binärdarstellung von r;
4: for j := 0; j 6 I; j + + do
5:
if aj == 1 then
6:
s := s · xj (mod n);
7:
end if
8:
xj+1 := xj · xj (mod n);
9: end for
10: return s;
Beim Aufbau eines Public-Key-Systems mit RSA dürfen die Primzahlen p und q nicht nahe
beieinander liegen und sollten zufällig gewählt werden. Zusätzlich sollte der ggT(p − 1, q − 1)
möglichst klein sein. Dies kann zum Beispiel durch die Wahl von sicheren Primzahlen, d.h. p−1
2 und
q−1
2 sind auch Primzahlen, geschehen. Damit e und d wirklich schwer zu berechnen sind, sollten für
diese Teilschlüssel große Zahlen gewählt werden.
In Abbildung 2.4 ist ein Protokoll zum generieren einer Unterschrift s zu einer Nachricht m
zu sehen. Jedoch ist es leicht eine Unterschrift aus dem Protokoll zu fälschen. Eine Möglichkeit
RSA (s) zu erstellen.
der Fälschung ist es zu einer gewählten Unterschrift s eine Nachricht m = En,e
Des weiteren ist es für jeden, der zwei Nachrichten (m1 , s1 ) und (m2 , s2 ) abgefangenen oder
−1
empfangenen hat, möglich die Unterschriften s1 · s2 oder s−1
1 für die Nachricht m1 · m2 bzw. m1
zu erstellen. In allen möglichen Fällen der Fälschung ist es jedoch unmöglich, dass der Fälscher die
unterschriebene Nachricht kontrollieren bzw. lesen kann und es ist daher sehr unwahrscheinlich,
dass die unterschriebenen Nachrichten aus einer natürlichen Sprache stammen (Sinn ergeben). Wenn
eine Hashfunktion im Protokoll korrekt verwendet wird, können die Angriffe verhindert werden.
27
A: m
?
RSA
(s)
Testet m = Ee,n
RSA
e, n und Ee,n
m, s
B: m
RSA
RSA
und Dd,n
Erzeugt Ee,n
RSA
Bestimmt s = Dd,n
(m)
Abbildung 2.4: Unterschrift mit RSA.
2.4
Rabin
Das System von Rabin wurde 1979 entwickelt und basiert auf zwei schweren Problemen. Zum
einen wird das Problem der Faktorisierung einer Zahl n, die das Produkt zweier Primzahlen p
und q ist, verwendet und zum anderen das Bestimmen der diskreten Quadratwurzel. Der nachfolgende mathematische Hintergrund erklärt ausgiebig das Problem der Bestimmung der diskreten
Quadratwurzel.
2.4.1
Mathematischer Hintergrund
Durch die Modulo Operation, die in Kryptographischen Verfahren sehr häufig verwendet wird, ist
der verwende Zahlenraum stark eingeschränkt. Sollte der Modul q eine Potenz einer Primzahl p
sein, also q = ph , finden alle Berechnungen im endlichen Körper F(q) statt.
Definition 2.6 Es sei K 6= ∅ eine Menge mit zwei Verknüpfungen (a, b) 7→ a + b : K × K → K
und (a, b) 7→ a · b : K × K → K. Dann heißt K = (K, +, ·) Körper, wenn gilt:
1. (K, +) ist Abelsche Gruppe (d.h. + ist assoziativ, kommutativ und das neutrales Element
bezüglich + ist 0K . Zudem besitzt jedes Element ein Inverses bezüglich +).
2. (K, ·) ist kommutatives Monoid (d.h. · ist assoziativ, kommutativ und das neutrales Element
bezüglich · ist 1K ).
3. Es gilt das folgende Distributivgesetz: Für alle a, b, c ∈ K ist a · (b + c) = a · b + a · c.
4. 1K 6= 0K .
5. Jedes Element außer 0K besitzt ein Inverses bezüglich ·.
Da die Einheitengruppe K ∗ eines Körpers K als K ∗ := K \ {0} definiert ist, wird die Einheitengruppe von F(q) mit F∗ (q) bezeichnet. In dieser Gruppe heißt ein Element Generator oder
erzeugendes Element, wenn es möglich ist durch Potenzierung jedes andere Element aus F∗ (q) zu
erhalten. Somit ist g ein Generator, wenn für jedes Element a ∈ F∗ (q) ein x ∈ Z existiert für das
g x = a gilt. In F∗ (q) gibt es genau ϕ(q − 1) viele verschiedene Generatoren. Die Zahl x wird auch
28
der diskrete Logarithmus von a zur Basis g genannt und lässt sich nicht effizient aus g, a und q
berechnen. Es ist bekannt, dass die Berechnung des diskreten Logarithmus so schwer ist wie die
Faktorisierung.
Die Ordnung r eines Elements a ∈ F∗ (q) ist definiert als minimale Anzahl an notwendigen
Potenzierungen von a um 1 zu erhalten. Formal ist die Ordnung definiert als ord(a) := min{r ∈
N | ar = 1} und ein Generator hat immer die Ordnung q − 1, da sonst nicht alle Elemente aus
F∗ (q) getroffen werden können.
Wenn ein x ∈ F∗ (q) existiert mit a = x2 , dann wird a quadratischer Rest modulo q genannt.
Wenn es kein x gibt, das mit sich selbst multipliziert a ergibt, wird a quadratischer Nichtrest
genannt. Die Hälfte der Elemente aus F∗ (q) sind quadratische Reste und die andere Hälfte sind
quadratische Nichtreste. Betrachtet man einen Generator g ∈ F∗ (q), der für i 6 q − 1 jedes Element
g i = a ∈ F∗ (q) trifft, dann sind genau die Zahlen a quadratische Reste, für die a = g i mit i gerade
q−1
2
gilt. Alle quadratischen
Reste x lassen sich als x = i (mod q) für 1 6 i 6 2 berechnen. Das
Legendre-Symbol
a
q
bestimmt ob a ein quadratischer Rest modulo q ist:


a
=

q
0, falls q | a
1, falls a quadratischer Rest modulo q
−1, falls a quadratischer Nichtrest modulo q
Allgemein lässt sich der Wert des Legendre-Symbols mit Theorem 2.7 berechnen.
Theorem 2.7 (Eulersches Kriterium) Sei a ∈ Z, q Primzahl, q > 2. Dann gilt:
a
≡ a(q−1)/2 (mod q).
q
In Theorem 2.8 sind die wichtigsten Rechenregeln für das Legendre-Symbol aufgeführt.
Theorem 2.8 (Legendre-Symbol Rechenregeln)
Seien p, q Primzahlen, p, q > 2. Seien a, b ∈ Z. Dann gilt:
29
1.
=1
2.
=
(−1)(p−1)/2
3.
=
a
b
p · p
4.
5.
6.
1
p
−1
p
ab
p
a
p
a2
p
2
p
=
b
p
=
1, falls p ≡ 1 (mod 4)
−1, falls p ≡ 3 (mod 4)
, falls a ≡ b (mod p))
= 1, falls p - a
=
2
(−1)(p −1)/8
=
1, falls p ≡ 1, 7 (mod 8)
−1, falls p ≡ 3, 5 (mod 8)
7. Quadratisches Reziprozitätsgesetz:
  − pq , falls p ≡ q ≡ 3 (mod 4)
(p−1) (q−1)
p
q
2
2
· q =
p = (−1)
p

, sonst
q
Um das Legendre-Symbol zu erweitern und die Abhängigkeiten von Primzahlen zu verlieren,
verwenden wir das Jacobi-Symbol, das in Definition 2.9 erklärt wird, als Verallgemeinerung des
Legendre-Symbols.
Definition 2.9 (Jacobi-Symbol) Sei a ∈ Z und n ∈N ungerade und n = pe11 . . . pekk die Primfaktorzerlegung von n. Dann ist das Jacobi-Symbol na definiert als:
a
n
=
a
p1
e1
· ... ·
a
pk
ek
.
Wenn das Jacobi-Symbol na = 1 ist, bedeutet dies nicht, dass a quadratischer Rest modulo n
ist, da n nur als Produkt von Primzahlen und nicht als Primzahl definiert ist. Wenn zum Beispiel
n = 15 das Produkt zweier Primzahlen p = 3 und q = 5 ist, kann es sein, dass a = 2 quadratischer
Nichtrest modulo p und q ist, wodurch die Legendre Symbole den Wert −1 annehmen würden.
Nach der Definition ist der Wert des Jacobi-Symbols das Produkt der Legendre Symbole, was nach
unserem Beispiel (−1) · (−1) = 1 wäre. Die Rechenregeln aus Theorem 2.10 helfen mit dem
Jacobi-Symbol umzugehen.
Theorem 2.10 (Jacobi-Symbol Rechenregeln)
Seien m, n ∈ N ungerade. Seien a, b ∈ Z. Dann gilt:
30
1.
2.
3.
4.
5.
6.
7.
a
1
=1
b
ab
a
n = n · n
a
a
a
mn = m · n
a
b
n = n , falls a ≡ b (mod n)
1
n =1
1, falls n ≡ 1 (mod 4)
−1
(n−1)/2
= (−1)
=
n
−1, falls n ≡ 3 (mod 4)
1, falls n ≡ 1, 7 (mod 8)
2
(n2 −1)/8 =
=
(−1)
n
−1, falls n ≡ 3, 5 (mod 8)
8. Quadratisches Reziprozitätsgesetz:
(m−1) (n−1)
n
m
2
2
· m
n = (−1)
Um einen Algorithmus zu bestimmen, der den Wert na für a ∈ Z und n ∈ N ungerade berechnet,
hilft die Beobachtung, dass für a = 2e · n0 mit n0 ungerade folgendes gilt:
e 0 e 0 a
2 ·n
2
n
=
=
·
n
n
n
n
n
(n−1) (n0 −1)
n2 −1
2
= (−1)e· 8 · (−1) 2
·
0
n
2
0
n−1 n −1
n mod n0
e· n 8−1
2
2
= (−1)
· (−1)
·
n0
0
0
mit 0 < n mod n < n 6 a < n.
Der Jacobi Algorithmus, beschrieben in Algorithmus 6, berechnet den Wert von na ohne Faktorisierung von a oder n (außer dem Herausziehen von 2er-Potenzen) in O((log a) · (log n)) Schritten.
Somit ist es möglich effizient zu testen ob a quadratischer Rest modulo n ist, falls n eine Primzahl
ist. Obwohl sich effizient testen lässt ob eine Zahl eine Wurzel besitzt, lässt sie sich dennoch nicht
effizient berechnen.
Um die Funktionsweise des Algorithmus verständlicher zu gestalten, ist eine Beispielrechnung
für −2819
angegeben.
4177
−2819
−1
2819
2819
4177
1358
2
679
=
·
=
=
=
=
·
4177
4177
4177
4177
2819
2819
2819
2819
679
2819
103
679
61
103
= −
=+
=
=−
=−
=−
2819
679
679
103
103
61
42
2
21
61
19
21
2
= −
=−
=
=
=
=
61
61
61
21
21
19
19
= −1
31
Algorithm 6 Jacobi(a,n) mit 0 6 a < n und n ungerade
1: t := 1;
2: while a 6= 0 do
3:
while a mod 2 == 0 do
4:
a := a2
5:
if (n mod 8 = 3) or (n mod 8 = 5) then
6:
t := −t;
7:
end if
8:
interchange(a, n)
9:
if (a mod 4 == 3) or (n mod 4 == 3) then
10:
t := −t
11:
end if
12:
a := a mod n
13:
end while
14: end while
15: if n == 1 then
16:
return(t);
17: end if
18: return(0);
Sollte n keine Primzahl sein, ist es nicht mehr möglich effizient zu bestimmen ob a quadratischer
Rest modulo n ist. In vielen kryptographischen Verfahren ist es notwendig eine Quadratwurzel von
a modulo n zu bestimmen. Dabei ist nur bekannt, dass a quadratischer Rest modulo n ist.
∃x : x2 ≡ a (mod n)
Wenn n das Produkt aus zwei ungleichen Primzahlen p und q ist,können
wir
mit Satz 2.11 feststellen,
a
a
dass für einen quadratischen Rest a modulo n, die Symbole p und q den gleichen Wert haben
a
müssen. Für eine Hälfte der Zahlen a, die a < 0 < n und ggT(a,
n)
=
1
erfüllen,
ist
= 1 und
n
a
a
für die andere Hälfte n = −1. Die Menge der Zahlen, die n = 1 erfüllen, kann erneut in zwei
Hälften geteilt werden. Die Hälfte für die
a
a
=
= +1
p
q
gilt, sind quadratische Reste modulo n. Die andere Hälfte, also wenn
a
a
=
= −1
p
q
32
gilt, sind quadratische Nichtreste modulo n. Es ist nicht bekannt ob sich die Fälle unterscheiden
lassen ohne die Kenntnis der Faktorisierung von n = p · q. Es kann also nicht effizient bestimmt
werden ob eine Zahl a quadratischer Rest oder Nichtrest modulo n ist.
Satz 2.11 Sei a quadratischer Rest modulo n
⇔ a quadratischer Rest modulo p ∧ a quadratischer Rest modulo q.
a
n = +1
⇔ ap · aq = +1
⇔
a
p
=
a
q
= +1 ∨
a
p
=
a
q
= −1.
Das nachfolgende Beispiel in Tabelle 2.1 für n = 3 · 5 zeigt die Werte der Jacobi und Legendre
Symbole für die Zahlen a mit ggT(a, n) = 1 und verdeutlicht wie sich die Zahlen in die oben
genannten Hälften teilen.
a mit
a quadratischer
ggT(a, n) = 1
a
p
a
q
a
n
1
2
4
7
8
11
13
14
+
−
+
+
−
−
+
−
+
−
+
−
−
+
−
+
+
+
+
−
+
−
−
−
Rest mod n
+
−
+
−
−
−
−
−
Tabelle 2.1: Beispiel für Jacobi und Legendre Symbole.
Somit können die vorherigen Erkenntnisse zur nachstehenden Folgerung zusammen gefasst werden:
n = p · q, p, q prim, p, q > 2, p 6= q und a quadratischer Rest modulo n.
∃x :
x2 ≡ a (mod n)
⇒ p · q | (x2 − a)
⇒ p | (x2 − a) ∧ q | (x2 − a)
⇒ x2 ≡ a (mod p) ∧ x2 ≡ a (mod q)
⇒ a quadratischer Rest mod p und q
33
⇒ ∃y, z : (±y)2 ≡ a (mod p) ∧ (±z)2 ≡ a (mod q).
Wenn (±y)2 ≡ a (mod p), (±z)2 ≡ a (mod q) und x2 ≡ a (mod n) gilt, muss für x folgendes
gelten:
x ≡ ±y (mod p) ∧ x ≡ ±z (mod q)
Somit ist es möglich mit dem chinesischen Restsatz 4 unterschiedliche Quadratwurzeln von a
modulo n zu bestimmen. Die vier verschiedenen Quadratwurzeln ergeben sich daraus, dass der
chinesische Restsatz auf
x≡y
(mod p) ∧ x ≡ z
x≡y
(mod p) ∧ x ≡ −z
(mod q),
x ≡ −y
(mod p) ∧ x ≡ z
x ≡ −y
(mod p) ∧ x ≡ −z
(mod q),
(mod q) bzw.
(mod q)
angewandt werden kann. Die 4 unterschiedlichen Quadratwurzeln werden im folgenden mit ±u, ±w
bezeichnet, wobei u 6≡ ±w (mod n) gilt. Lemma 2.12 besagt, dass die Faktorisierung von n
möglich ist, sobald zwei unterschiedliche Quadratwurzeln der gleichen Zahl bekannt sind.
Lemma 2.12 Die Kenntnis zweier unterschiedlicher Quadratwurzeln u und w derselben Zahl a
modulo n erlaubt die Faktorisierung von n.
Beweis: Wenn w und u bekannt ist, kann das Produkt von (u + w)(u − w) betrachtet werden und
nach Verwendung der dritte binomische Formel stellt man fest, dass das Produkt äquivalent zu 0
modulo n ist.
(u + w)(u − w) = u2 − w2 ≡ a − a = 0 (mod n)
Somit muss n | (u + w) · (u − w) gelten, da (u + w)(u − w) = 0 (mod n) ist. Da w und
u unterschiedliche Quadratwurzeln sind, gilt u 6≡ ±w (mod n). Daher kann n kein Teiler der
einzelnen Faktoren (u + w) oder (u − w) sein. Somit gilt
n - (u + w) ∧ n - (u − w).
Daraus folgt, dass der größte gemeinsame Teiler von n und einem der Faktoren p oder q ist.
ggT(u + w, n) ∈ {p, q}
Da n, w und u bekannt sind, lässt sich mittels Euklidischem Algorithmus der größte gemeinsame
Teiler berechnen, wodurch n = p · q erfolgreich faktorisiert wird.
Ein weiteres Hilfsmittel für die Kryptographie ist in Lemma 2.13 beschrieben.
34
Lemma 2.13 Falls p ≡ q ≡ 3 (mod 4), so besitzen zwei unterschiedliche Quadratwurzeln u und
w derselben Zahl a modulo n verschiedene Jacobi-Symbole:
w
u
=−
.
n
n
Beweis: Da u und w unterschiedliche Quadratwurzeln der gleichen Zahl sind, gilt u2 ≡ a ≡ w2
(mod n). Die Gleichung gilt auch, wenn n durch p oder q ausgetauscht wird, da n das Produkt
dieser beiden Primzahlen ist.
u2 ≡ w2
(mod p) ∧ u2 ≡ w2
(mod q)
Wenn wir die Potenzierung entfernen sind die nachfolgenden vier Fälle möglich.
(i)
u≡w
(mod p) ∧
u≡w
(mod q)
oder
(ii)
u≡w
(mod p) ∧
u ≡ −w
(mod q)
oder
(iii)
u ≡ −w
(mod p)
∧
u≡w
(mod q)
oder
(iv)
u ≡ −w
(mod p)
∧
u ≡ −w
(mod q)
Da die Quadratwurzeln unterschiedlich sind, muss u 6≡ ±w (mod n) gelten, wodurch nur die Fälle
(ii) und (iii) betrachtet werden müssen. Aus der Grundvoraussetzung des Lemmas p ≡ q ≡ 3
(mod 4), folgt:
Falls u ≡ w (mod p) ∧ u ≡ −w (mod q) gilt:
u u u w −w w −1 w w
=
·
=
·
=
·
·
= (−1) ·
n
p
q
p
q
p
q
q
n
Falls u ≡ −w (mod p) ∧ u ≡ w (mod q) gilt:
u u u −w w −1 w w w
=
·
=
·
=
·
·
= (−1) ·
n
p
q
p
q
p
p
q
n
Somit ist bewiesen, dass zwei unterschiedliche Quadratwurzeln derselben Zahl verschiedene JacobiSymbole haben müssen.
2.4.2
System von Rabin
Um das System aufzubauen benötigt man zwei große Primzahlen p und q, mit p, q ≡ 3 (mod 4).
Um diese Zahlen zu finden, testet man Zahlen der Form 4k + 3 auf die Primzahleigenschaft. Das
Produkt der beiden Primzahlen n = p · q wird als öffentlicher Schlüssel preisgegeben.
35
Um eine Nachricht m verschlüsselt zu versenden, wird diese einfach quadriert und modulo n
gerechnet. Somit kann die Verschlüsselungsfunktion formal definiert werden als:
EnRabin : Zn → Zn
mit EnRabin (m) 7→ m2 mod n
Um eine Nachricht zu entschlüsseln, wird der Chinesische Restklassensatz verwendet. Nach
diesem gibt es eine Funktion ϕ : Zn → Zp × Zq mit c 7→ (c mod p, c mod q), mit der die
verschlüsselte Nachricht zerlegt werden kann. Je nachdem, ob c eines der p oder q teilt, ergeben
sich 2 oder 4 mögliche Quadratwurzeln, die bestimmt werden können. All diese sind mögliche
Kandidaten für die verschlüsselte Nachricht m.
Falls die Nachricht aus einer natürlichen Sprache ist, sollte die richtige Botschaft direkt erkennbar sein und es ist sogar möglich auf die Bedingung p, q ≡ 3 (mod 4) zu verzichten. Andernfalls
muss zusätzliche Information zurUnterscheidung der Wurzeln bei der Übertragung mitgesendet
n
werden. Wenn zum Beispiel m
n und m > 2 als Bit mitgesendet werden ist eine eindeutige
Entschlüsselung möglich. Alternativ kann auch der Nachrichten Raum halbiert werden um das
zusätzliche Bit zu vermeiden.
Das Kryptoverfahren ist so sicher, wie die Faktorisierung schwer ist. Sollte der Zugriff auf die
Rabin , ohne p oder q zu kennen, möglich sein, ist n faktorisierbar. Dazu
Entschlüsselungsfunktion Dp,q
wählt man eine Nachricht m und verschlüsselt diese zu c. Anschließend entschlüsselt man c und
erhält y. Wenn m 6≡ ±y (mod n) gilt, kann n faktorisiert werden, da nun zwei Quadratwurzeln m
und y bekannt sind.
Um eine Unterschrift mit dem System von Rabin zu erzeugen, wird eine Hashfunktion h :
M × {0, 1}k → Zn mit (m, x) 7→ h(m, x) verwendet. Das x wird zufällig gewählt, bis das
Ergebnis der Hashfunktion ein Quadrat in Zn ist. Da dem Erzeuger der Unterschrift n = p · q
bekannt ist, kann er die Wurzel y von h(m, x) bestimmen. Als Unterschrift kann nun (m, x, y)
versendet werden. Ein Empfänger dieser Nachricht überprüft ob h(m, x) ≡ y 2 (mod n) gilt. Sollte
dies der Fall sein, weiß der Empfänger, dass die Nachricht m vom Empfänger stammen muss, da
nur dieser in der Lage ist die Wurzel zu bestimmen.
36
Kapitel 3
Sicherheitsaspekte und Hilfsfunktionen
Nachdem die Grundlagen der public-key-Systeme erläutert wurden, sind nun noch einige Fragen
zu klären. Wie sicher ist RSA und worauf sollte man achten, wenn man ein RSA System aufbaut?
Des weiteren werden einige nützliche Werkzeuge der Kryptographie, wie Hashfunktionen oder
Primzahltests, erläutert.
3.1
Hashfunktionen
Eine Hashfunktion ist eine Funktion h : {0, 1}∗ → {0, 1}k mit: m 7→ h(m). Diese Funktionen
werden zum Beispiel beim Unterschreiben von Texten, zur Fehlererkennung oder Datenverwaltung
verwendet. Bei den Unterschriften wird statt einer Nachricht m dessen Hashwert h(m) unterschrieben. Eine Kollision bei einer Hashfunktion h tritt auf bei einem Paar (m, m0 ) falls h(m) = h(m0 ).
Daher sollten Angreifer nicht in der Lage sein zu einer Nachricht m eine zweite Nachricht m0 effizient erzeugen zu können, mit h(m) = h(m0 ) oder zwei Nachrichten m und m0 effizient erzeugen zu
können, mit h(m) = h(m0 ). Diese Eigenschaften werden in Definition 3.1 nochmals erläutert.
Definition 3.1
• Eine Hashfunktion h heißt Zweitnachricht sicher, falls man nicht zu m eine zweite Nachricht
m0 effizient erzeugen kann, mit h(m) = h(m0 ).
• Eine Hashfunktion h heißt kollisionssicher, falls man nicht zwei Nachrichten m und m0
effizient erzeugen kann, mit h(m) = h(m0 ).
Dank Lemma 3.2, ist es ausreichend beim Bestimmen einer Hashfunktion darauf zu achten,
dass sie kollisionssicher ist.
Lemma 3.2 Falls h kollisionssicher ist, dann ist h auch Zweitnachricht sicher.
37
Beweis: Um das Lemma zu beweisen, können wir annehmen, dass es einen effizienten Algorithmus
A gibt, der eine Zweitnachricht m0 erzeugt für eine gegebene Nachricht m.
Ein Algorithmus B kann mit Hilfe des Algorithmus A in effizienter Zeit zwei Nachrichten
m und m0 , mit h(m) = h(m0 ), erzeugen indem er eine beliebige Nachricht m bestimmt und
anschließend A aufruft. Der AlgorithmusA bestimmt dann m0 mit h(m) = h(m0 ) und somit kann
durch den Algorithmus B eine Kollision effizient bestimmt werden.
Um eine Hashfunktion zu bestimmen ist es ausreichend eine kollisionssichere Kompressionsfunktion zu entwickeln. Eine Kompressionsfunktion ist definiert als Funktion f : {0, 1}m → {0, 1}n
bei der die Zielmenge kleiner als die Definitionsmenge ist (also m > n). Um eine kollisionssichere
Kompressionsfunktion aufzubauen kann ein symmetrisches Verfahren Ek (m) mit k ∈ {0, 1}r und
m ∈ {0, 1}n verwendet werden.
Dafür benötigen wir eine Funktion g : {0, 1}n → {0, 1}r , die den Schlüssel für Ek bestimmt
und eine Funktion f : {0, 1}2n → {0, 1}n , die die erste Hälfte der Eingabe x als Eingabe für Ek
verwendet und die zweite Hälfte y mit Hilfe von g zu einem Schlüssel für Ek umwandelt und das
Resultat der Verschlüsselung noch mit y durch ein bitweises XOR verrechnet. Formal kann die
Funktion f durch f (x ◦ y) 7→ Eg(y) (x) ⊕ y beschrieben werden.
Mit Hilfe einer Kompressionsfunktion f : {0, 1}m → {0, 1}n kann durch Merkles-MetaMethode eine Hashfunktion h : {0, 1}∗ → {0, 1}n bestimmt werden. Dafür wird die Eingabe
x ∈ {0, 1}∗ für h mit |x| = k · r in k Teile x = x1 x2 . . . xk unterteilt, alle mit Länge r. Weiterhin
wird in xk+1 die Länge r kodiert und h0 := 0n definiert. Somit können zusammen mit den xi durch
rekursive Berechnungen hi := f (hi−1 ◦xi ) für 1 6 i 6 k+1 weitere hi bestimmt werden. Die finale
Hashfunktion h : {0, 1}∗ → {0, 1}k ist definiert als Endergebnis der rekursiven Berechnungen
x 7→ hk+1 und ist in Abbildung 3.1 veranschaulicht.
x1
x2
x3
x4
x5
x6
x7
h0
h1
h2
h3
h4
h5
h6
h7
Abbildung 3.1: Merkles-Meta-Methode.
Lemma 3.3 Falls f kollisionssicher ist, dann ist die Hashfunktion h, die mit Merkles-Meta-Methode
konstruiert wird, auch kollisionssicher.
Um Lemma 3.3 zu beweisen, geben wir einen Algorithmus an, der aus einer Kollision für die
Hashfunktion h eine Kollision für die Kompressionsfunktion f bestimmt.
38
Beweis: Sei x, x0 eine Kollision der Funktion h mit:
x = x1 x2 . . . xk+1
x0 = x01 x02 . . . x0k0 +1
h1 , h2 , . . . , hk+1
h01 , h02 , . . . , h0k0 +1
Angenommen die beiden Eingaben haben unterschiedliche Länge |x| =
6 |x0 |:
Nach der Konstruktion wissen wir, dass h(x) = f (hk ◦ xk+1 ) und h(x0 ) = f (h0k ◦ x0k0 +1 ) gilt,
wobei xk+1 und x0k0 +1 die kodierten Längen sind. Nach unserer Annahme gilt h(x) = h(x0 ). Da
x und x0 aber unterschiedliche Längen haben muss xk+1 6= x0k0 +1 gelten. Daraus folgt, dass auch
hk ◦ xk+1 6= h0k ◦ x0k0 +1 ist. Somit ist (hk ◦ xk+1 , h0k ◦ x0k0 +1 ) eine Kollision für f .
Wenn die beiden Eingaben gleiche Länge haben, also |x| = |x0 | muss auch k = k 0 gelten:
Die Kollision für f kann gefunden werden indem alle Zwischenergebnisse hi und h0i mit ihren
zugehörigen Nachfolgern hi+1 und h0i+1 betrachtet werden. Sollte es ein i geben für das hi 6= h0i
und hi+1 = h0i+1 gilt, ist (hi ◦ xi+1 , h0i ◦ x0i+1 ) eine Kollision für f , da hi ◦ xi+1 6= h0i ◦ x0i+1 und
f (hi ◦ xi+1 ) = hi+1 = h0i+1 = f (h0i ◦ x0i+1 ) gilt.
Wenn kein i gefunden werden kann für das die Bedingung erfüllt ist, gilt hi 6= h0i für alle i:
Da die beiden Eingaben ungleich sein müssen, gibt es ein i für das xi+1 6= x0i+1 gilt. Damit ist
analog zum vorherigen Fall (hi ◦ xi+1 , h0i ◦ x0i+1 ) eine Kollision für f , da hi ◦ xi+1 6= h0i ◦ x0i+1
und f (hi ◦ xi+1 ) = hi+1 = h0i+1 = f (h0i ◦ x0i+1 ) gilt.
Ein entscheidender Faktor für Hashfunktionen ist die Größe der Zielmenge n. Nach dem
Geburtstagsparadoxon ist die Wahrscheinlichkeit, dass k Hashwerte aus dem Wertebereich m = 2n
keine Kollision haben:
k−1
k−1
Y
1 Y
1
p = p(m, k) = k
(m − i) =
(1 − ).
m
m
i=0
i=1
Wegen 1 − x 6 e−x für x ∈ R gilt
p6
k−1
Y
−1
−1
em =em
Pk−1
i=1
i
=e
−k(k−1)
2m
i=1
√
Damit ist die Wahrscheinlichkeit einer Kollision 1 − p. Wenn k als k > 1/2( 1 + 8ln2 · m + 1)
gewählt wird ist die Wahrscheinlichkeit einer Kollision größer als 50%, da 1 − p > 1/2 gilt. Damit
√
ist k ≈ 1.18 m und es sind 2n/2 Werte zu wählen und zu vergleichen, um eine Kollision mit einer
Wahrscheinlichkeit von mehr als 50% zu finden. Heutzutage werden Hashfunktionen mit 160 Bits
empfohlen.
3.2
Sicherheitsaspekte von RSA
Bei der Verwendung von RSA ohne zusätzliche Sicherheitsverfahren sind folgende Fälle zu vermeiden:
39
a) Sollten zwei Personen die gleichen Primzahlen p und q, aber unterschiedliche e und d für ihr
RSA-System verwenden, ist ein Angriff möglich, wenn die gleiche Nachricht m an beide
versendet wird. Sollte ein Lauscher die öffentlichen Schlüssel e1 , e2 und n kennen, kann
überprüft werden ob ggT(e1 , e2 ) gilt. Sollte dies der Fall sein, dann kann durch die Kenntnis
der verschlüsselten Nachrichten c1 = me1 und c2 = me2 ein Angriff gestartet werden.
Sollte c1 6∈ Z∗n gelten, so kann n durch das Bestimmen von ggT(c1 , n) faktorisiert werden.
Andernfalls, also wenn c1 ∈ Z∗n gilt, kann die Nachricht m entschlüsselt werden, da durch
die Kenntnis von e1 , e2 und ggT(e1 , e2 ) ein r und s mit re1 + se2 = 1 bestimmt werden
kann. Mit diesen lässt sich m folgendermaßen bestimmen:
−r s
e1 r
e2 s
re1 +se2
(c−1
≡ m (mod n)
1 ) c2 = (m ) · (m ) = m
b) Sollten k Parteien die gleiche Nachricht m erhalten und ihr System mit unterschiedlichen
ni , aber gleichen ei = k aufgebaut sein, kann ein Lauscher durch mithören der Nachrichten
ci = mk mod ni die Nachricht m bestimmen. Durch Anwenden des Chinesischen Restklassensatz
(ϕ : Zn1 n2 n3 ...nk → Zn1 × Zn2 × Zn3 . . . × Znk ) erhält man mk . Da mk < n1 n2 n3 . . . nk
gilt, kann m eindeutig bestimmt werden.
RSA und D RSA
c) Wenn A die gleichen Verschlüsselungs- und Entschlüsselungsfunktionen Ee,n
d,p,q
sowohl zum Verschlüsseln als auch zum Unterschreiben verwendet, wird die Kommunikation
RSA (m) abgehört wird, kann ein Angreifer mit einer
unsicher. Wenn eine Nachricht c = Dd,p,q
∗
e
Zufallszahl r ∈ Zn ein x := c · r bestimmen und A bitten diese Nachricht zu unterschreiben.
RSA (x) (mod n) und kann m durch folgende Berechnung
Dann kennt der Angreifer xd ≡ Dd,p,q
ermitteln:
xd · r−1 ≡ (c · re )d · r−1 ≡ cd ≡ m (mod n)
Die drei oben genannten Angriffe lassen sich mittels OAEP verhindern.
3.2.1
OAEP (optimal asymmetric encryption padding)
Das optimal asymmetric encryption padding verhindert Angriffe, die die Gruppenstruktur eines Verschlüsselungsverfahren nutzen. Dabei arbeitet das Verfahren schnell, beinhaltet einen Zufallsanteil
und erfordert wenig zusätzliche Information, die übertragen werden muss.
Das Verfahren verwendet eine Verschlüsselungsfunktion f : D → D mit D ⊂ {0, 1}n , einen
Pseudo-Zufallsgenerator G : {0, 1}k → {0, 1}l und eine Hashfunktion h : {0, 1}l → {0, 1}k ,
wobei n = k + l gilt.
40
Entschlüsselung von c:
Verschlüsselung von m:
3.2.2
Wähle Zufallszahl r ∈ {0, 1}k .
Setze x0 := f −1 (c).
Bestimme x mit
x = (m ⊕ G(r)) ◦ (r ⊕ h(m ⊕ G(r))).
Bestimme a, b mit
x0 = a ◦ b und |a| = l sowie |b| = k.
Falls x 6∈ D wiederhole.
Bestimme r = h(a) ⊕ b.
Verschlüssele mit c := f (x).
Bestimme m = a ⊕ G(r).
Weitere Angriffe
Die Primzahlen p und q sollten beim Aufbau des Systems so gewählt werden, dass sie nicht nahe
beieinander liegen. Sollten die Zahlen nahe beieinander liegen ist ein Angriff möglich. Sei o.B.d.A.
√
p > q, wir definieren x = (p−q)
und y = (p+q)
nur wenig
> n wobei wir feststellen, dass (p+q)
2
2
2
√
größer als n ist. Mit x und y lässt sich das Produkt der Primzahlen folgendermaßen berechnen:
p−q 2
2
y 2 − x2 = ( p+q
2 ) −( 2 )
=
=
=
(p+q)2
4
−
(p−q)2
4
p2 +q 2 +2·p·q−(p2 +q 2 −2·p·q)
4
2·p·q−(−2·p·q)
4
= p·q =n
√
√
Ein Angreifer kann nun verschiedene Werte für y von d ne bis d ne+δ ausprobieren und versuchen
ob ein kleines x ∈ Z existiert für das y 2 − n = x2 gilt. Wenn ein gültiges Paar x, y gefunden wird,
kann man die Primzahlen durch p = x + y und q = x − y berechnen. Dieser Angriff ist effektiv, da
der Bereich der auszuprobierenden Schlüssel sehr klein ist und das Ziehen der Wurzel nur für kleine
Zahlen erfolgt.
Zusätzlich sollte der größte gemeinsame Teiler von p − 1 und q − 1 nicht groß sein. Andernfalls
ist das kleinste gemeinsame Vielfache der beiden Zahlen klein. Somit kann eins der e−1 (mod u)
zur Entschlüsselung verwendet werden, was den Suchraum stark einschränkt.
Außerdem sollte ϕ(n) nur kleine Primfaktoren haben, da ansonsten für alle Kandidaten v von
v+1
ϕ(n) getestet werden kann ob (v+1)
eine ganze Zahl ist. Anschließend kann geprüft werden ob c e
e
eine sinnvolle Nachricht ist.
Beim Aufbau des Systems ist es daher wünschenswert sichere Primzahlen zu wählen, was
q−1
bedeutet, dass p−1
2 und 2 auch Primzahlen sind. Es ist jedoch schwer sichere Primzahlen zu
generieren und es ist nicht geklärt ob es unendlich viele solcher Zahlen gibt.
41
3.2.3
Sicherheitsaspekte
Nach Lemma 3.4 kann ein Angreifer durch die Kenntnis von ϕ(n) auch die Primzahlen p und q
bestimmen und somit den privaten Schlüssel des Systems erlangen.
Lemma 3.4 Falls ϕ(n) berechnet werden kann, dann kann p, q bestimmt werden.
Beweis: Da ϕ(n) ein Produkt aus (p − 1) und (q − 1) ist, kann die man die Summe der beiden
Primzahlen folgendermaßen darstellen:
ϕ(n) = (p − 1)(q − 1) ⇒ p + q = n − ϕ(n) + 1
Wenn auf beide Seiten der Gleichung quadriert, mit −4n verrechnet und anschließend die Wurzel
gezogen wird, erhalten wir folgendes Ergebnis:
p
p
p
p
(p + q)2 − 4n = 2n + p2 + q 2 − 4n = p2 + q 2 − 2n = (p − q)2 = |p − q|
Somit haben wir eine Darstellung für p + q und |p − q|, die nur von ϕ(n) abhängt und können p
folgendermaßen bestimmen:
p
n − ϕ(n) + 1 + (n − ϕ(n) + 1)2 − 4n
=p
2
Nach Lemma 3.5 kann ein Angreifer mit der Kenntnis von d ein probabilistisches Verfahren
verwenden um die Primzahlen p und q zu bestimmen.
Lemma 3.5 Falls d berechnet werden kann, gibt es ein probabilistisches Verfahren, das p, q bestimmt.
Beweis: Dem Angreifer sind e, d und n bekannt und er möchte p und q bestimmen.
Dafür wählt er ein w mit 1 6 w 6 n. Sollte ggT(w, n) > 1 gelten, dann kann n mit dem
Algorithmus von Euklid faktorisiert werden. Sollte w 6≡ ±1 (mod n) und w2 ≡ 1 (mod n) gelten,
dann wird das Produkt (w + 1) · (w − 1) von n geteilt, jedoch teilt n nicht die einzelnen Faktoren.
Somit kann durch die Berechnung des ggT(w + 1, n) die Primzahl p oder q bestimmt werden.
Sollten diese beiden Fälle erfolglos sein, kann der Angreifer ein s > 1 und ein ungerades r
s
bestimmen für die ed − 1 = 2s r gilt. Da ed − 1 ein Vielfaches von ϕ(n) ist, gilt w2 r ≡ 1 (mod n).
0
s
Nun wird das kleinste s0 (0 6 s0 6 s) bestimmt, sodass w2 r ≡ 1 (mod n) gilt. Wenn ein
0
s −1
passendes s0 gefunden wurde und zusätzlich w2 r 6≡ −1 (mod n) gilt, dann kann der Angreifer
analog zum oben genannten zweiten Fall p oder q berechnen. Andernfalls gilt wr ≡ 1 (mod n)
t
oder w2 r ≡ −1 (mod n) für ein t, 0 6 t < s (d.h. t = s0 − 1) und der Algorithmus verwirft w, da
die Faktorisierung nicht möglich ist.
42
Dieser Versuch der Faktorisierung gelingt, wenn ein w nicht verworfen wird, was mit einer
Wahrscheinlichkeit von > 0.5 geschieht. Um dies zu zeigen, wird p − 1 = 2i a und q − 1 = 2j b mit
a, b ungerade und i 6 j definiert. Da 2s r ein Vielfaches von ϕ(n) ist, gilt, dass r ein Vielfaches von
ab ist. Falls nun t > i, dann ist 2t r ein Vielfaches von p − 1 und impliziert Folgendes:
tr
w2
≡1
(mod p)
⇒
tr
w2
6≡ −1
(mod p)
⇒
tr
w2
6≡ −1
(mod n)
Somit tritt der Fall t > i hier nicht auf und somit muss nur noch folgende Situation betrachtet
werden:
t
wr ≡ 1 (mod n) oder w2 r ≡ −1 (mod n) für ein t, 0 6 t < i
Um die Wahrscheinlichkeit zu bestimmen, mit der das Verfahren funktioniert, muss berechnet
werden für wie viele w die Bedingungen erfüllt werden. Für wr ≡ 1 (mod n) definieren wir einen
Generator g für F? (p) (d.h. g erzeugt 1, . . . , p), sodass w ≡ g u (mod p) gilt. Dann gilt wr ≡ 1
(mod p) genau dann, wenn ur = 0 (mod p) − 1 gilt. Die Anzahl der gültigen Lösungen ist dann
ggT(r, p − 1) = a, bzw. ggT(r, q − 1) = b. Damit hat wr ≡ 1 mod n genau a · b viele Lösungen.
t
Wenn wir nun w2 r 6≡ −1 mod n betrachten ist für die verschiedenen Fälle die Anzahl der
Lösungen:
w2
t+1 r
w
2t r
≡1
(mod p) Anzahl der Lösungen:
ggT(2t+1 r, p − 1) = 2t+1 a
≡1
(mod p) Anzahl der Lösungen:
ggT(2t r, p − 1) = 2t a
Beachte: t + 1 6 i
w
2t r
≡ −1
(mod p) Anzahl der Lösungen:
6 2t a
Beachte: t + 1 6 i 6 j
w
2t r
≡ −1
(mod n) Anzahl der Lösungen:
6 2t a · 2t b = 22t ab
Wenn wir die Anzahl der Lösungen zusammen fassen erhalten wir:
ab + ab
i−1
X
t=0
2
2t
= ab(1 +
i−1
X
t=0
4t ) = ab(1 +
4i − 1
)
3
2
2
2
2
= ab( 22i−1 + ) 6 ab( 2i+j−1 + )
3
3
3
3
1
i+j−1
i+j−1
= ab(2
+ (2 − 2
))
3
ϕ(n)
6 ab2i+j−1 =
2
Somit wird die Hälfte aller w’s verworfen und die Wahrscheinlichkeit, nach k Tests ein passendes w
gefunden zu haben ist 1 − 2−k .
43
3.3
Bit-Sicherheit
Angenommen es existiert ein Orakel H, das für eine mit RSA verschlüsselte Nachricht xe (mod n)
sagt ob x < n2 gilt, dann ist es möglich die Nachricht x durch Halbierungssuche unter Verwendung
von H zu bestimmen. Wir definieren das Orakel als Funktion H(e, n, xe mod n) = 1 ⇐⇒ x < n2 .
Mit einem Trick entschlüsselt der Algorithmus 7 die Nachricht x. Wenn das Orakel Anfragen
der Form xe ≡ xe (mod n), 2e xe ≡ (2x)e (mod n), 2ie xe ≡ (2i x)e (mod n) bekommt, wird
durch Binärsuche das Intervall, in dem x liegt, immer weiter eingeschränkt.
Algorithm 7 Entschlüsselung mit Orakel
1: Eingabe e, n, c = xe (mod n);
2: Setze a = 0 und b = n − 1;
3: while a < b do
4:
if H(e, n, c) = 1 then
c;
5:
b = b a+b
2
6:
else
e;
7:
a = d a+b
2
8:
end if
9:
c = (2e · c) mod n
10: end while
11: Nach y Iterationen hat das Orakel eine Folge a1 a2 . . . ay geliefert.
12: x ist im i-ten Intervall der Größe 2−y−1 n, mit i = bin(a1 . . . ay ).
Sollte das Orakel nicht angeben, dass sich die gesuchte Zahl x in der ersten Hälfte befindet,
sondern ob x eine gerade Zahl ist, kann x dennoch berechnet werden. Dabei muss x bitweise
bestimmt werden. Jedes mal, wenn x gerade ist, sollte trickreich durch 2 geteilt werden und
andernfalls müssen x − 1 und n − x durch 2 geteilt werden. Um eine unbekannte Zahl durch 2 zu
teilen, wählen wir k als das Inverse von 2e . Somit hat k die Form he ≡ k mod n mit 2e k ≡ 1 mod n.
Durch multiplizieren mit k können wir dann x halbieren:
kxe ≡ he · xe ≡ (h · x)e
(mod n)
Um erneut einen Algorithmus aus dieser Idee zu entwickeln, müssen zunächst noch einige Notationen eingeführt werden.
3.3.1
Notationen und Algorithmus
Die Anzahl an Bits, die benötigt werden um n darzustellen wird mit N benannt. Die Binärdarstellung
mit führender 1 einer Zahl x wird mit bin(x) bezeichnet. Wenn w die Binärdarstellung einer Zahl
ist, beschreiben wir die Zahlt mit int(w). Falls int(t) > int(u), dann berechnet Last(t − u) die
44
letzten |u| Bits von bin(int(t) − int(u)). Zum Beispiel ist Last(1011011 − 1010111) = 0000100
und Last(1011011 − 111) = 100.
Der Algorithmus macht eine Reihe von Anfragen r(i) an das Orakel, das jeweils mit ans(i) antwortet. Der Algorithmus bestimmt nach und nach die Folge t(i), die gegen die Lösung konvergiert.
Im ersten Schritt setzt der Algorithmus r(1) = xe mod n und ans(1) = Antwort des Orakels
auf r(1). Anschließend wird r(i) aus r(i − 1) und ans(i − 1) folgendermaßen berechnet:
r(i − 1)k mod n
falls ans(i − 1) = 0
r(i) =
(n − r(i − 1))k mod n falls ans(i − 1) = 1
Nach N Durchläufen sind alle ans(i) bekannt und der Algorithmus berechnet die t(i), wobei mit
t(N ) = ans(N ) begonnen wird. Die Berechnung der t(i − 1) ergibt sich aus t(i) und der Antwort
des Orakels ans(i − 1), und ist folgendermaßen definiert:

ans(i − 1) = 0
 t(i)0
Last(bin(n) − t(i)0) ans(i − 1) = 1 ∧ int(t(i)0) < n
t(i − 1) =

Last(t(i)0 − bin(n)) ans(i − 1) = 1 ∧ int(t(i)0) > n
In der Tabelle 3.1 sind beispielhaft alle Ergebnisse des Algorithmus mit der Eingabe n = 55,
e = 7, N = 6 und bin(n) = 110111, k = 52, xe = 49 gegeben. Zu Beginn werden für i = 1 bis 6
alle ans(i) bestimmt und anschließend werden von i = 6 bis 1 die t(i) konstruiert, wobei t(1) das
Ergebnis für x als Binärdarstellung ist. Es gilt: bin(000100) = 4 und 47 ≡ 49 mod n.
i
6
5
4
3
2
1
r(i)
9 · 52 ≡ 28
52 · 52 ≡ 9
54 · 52 ≡ 3
18 · 52 ≡ 1
49 · 52 ≡ 18
49
ans(i)
1
0
1
1
0
0
t(i)
1
10
Last(110111 − 100) = 011
Last(110111 − 0110) = 0001
00010
000100
Tabelle 3.1: Beispiel Ergebnis des Algorithmus
Nachdem sämtliche Notationen und die Funktionsweise des Algorithmus geklärt wurden, muss
noch die Korrektheit von Satz 3.6 bewiesen werden. Dafür müssen jedoch noch weitere Notationen
eingeführt werden. Wir definieren u(i) für 1 6 i 6 N als u(i)e ≡ r(i) (mod n) mit 0 < u(i) < n.
Diese u(i) existieren und können folgendermaßen konstruiert werden:
u(1) ≡ r(1) = xe mod n ⇒ u(1) = x
und
2e r(i) ≡ ±r(i − 1) mod n
45
Des weiteren benötigen wir v(i) = 0j bin(u(i)) mit j = N − |bin(u(i))|. Wobei gilt, dass j > 0,
da u(i) < n und außerdem gilt zusätzlich |v(i)| = N . Der Beweis zeigt induktiv für N > i > 1:
∃w(i) mit v(i) = w(i)t(i)
Satz 3.6 Es gilt: int(t(1)) = x.
Beweis:
Induktionsanfang: i = N :
Da |t(N )| = 1 ist, untersuchen wir das letzte Bit. Da das letzte Bit von v(N ) gleich dem letztem
Bit von bin(u(N )) ist, muss t(N ) = ans(N ) gelten.
Induktionsschritt: i → i − 1 für i > 2:
Wir unterscheiden zwischen den Fällen ans(i − 1) = 0 und ans(i − 1) = 1.
1.Fall: ans(i − 1) = 0:
Wenn das Orakel im Schritt i − 1 mit 0 antwortet, dann ist r(i) als (r(i − 1)k) (mod n)
definiert. Da k verwendet wird um eine Zahl durch 2 zu teilen, können wir beide Seiten der
Gleichung mit 2e multiplizieren um das k zu entfernen. Anschließend können wir das r(i)
durch u(i)e ersetzen und erhalten:
r(i − 1) ≡ 2e r(i) ≡ 2e u(i)e ≡ (2u(i))e
(mod n)
Daraus folgt, dass u(i − 1) ≡ 2(u(i)) (mod n) gelten muss. Dies gilt, wenn die Zahlen
identisch sind oder wenn u(i − 1) = 2u(i) − n ist. Sollte letzteres der Fall sein, dann
ist u(i − 1) ungerade. Wenn aber u(i − 1) ungerade ist, muss die Antwort des Orakels
ans(i − 1) = 1 sein. Dies ist ein Widerspruch zur Annahme.
Somit muss u(i − 1) = 2u(i) sein und wir wissen nach der Induktionsvoraussetzung, dass ein
w(i) existiert für das v(i) = w(i)t(i) gilt. Für v(i − 1) gilt nun, dass es gleich w(i − 1)t(i)0
ist, wobei t(i)0 = t(i − 1) und w(i) = 0w(i − 1) gilt. Somit gibt es auch ein w(i − 1) für
das v(i − 1) = w(i − 1)t(i − 1) gilt.
2.Fall: ans(i − 1) = 1:
Wir erhalten durch Berechnungen, die analog zu Fall 1 sind, folgendes:
r(i − 1) ≡ −2e r(i) ≡ −2e u(i)e ≡ (−2u(i))e
(mod n)
Aus der Rechnung und der Definition von u(i)e = r(i) ergibt sich, dass u(i − 1) = (−2u(i))
(mod n) gelten muss.
Sollte nun n > 2u(i) gelten, können wir das v(i − 1) folgendermaßen bestimmen:
v(i − 1) = w(i − 1)Last(bin(n) − t(i)0) = w(i − 1)t(i − 1)
46
Wenn andernfalls n < 2u(i) gelten sollte, dann gilt:
v(i − 1) = w(i − 1)Last(t(i)0 − bin(n)) = w(i − 1)t(i − 1)
Somit existiert auch für diesen Fall ein w(i − 1) für das v(i − 1) = w(i − 1)t(i − 1) gilt.
Am Ende der Induktion, also für i = 1, ist |t(1)| = N und man erhält v(1) = t(1), sowie w(1) = ε.
Für v(1) und t(1) gilt, dass es Binärdarstellungen von x sind.
i
6
5
4
3
2
1
r(i)
9 · 52 ≡ 28
52 · 52 ≡ 9
54 · 52 ≡ 3
18 · 52 ≡ 1
49 · 52 ≡ 18
49
ans(i)
1
0
1
1
0
0
t(i)
1
10
Last(110111 − 100) = 011
Last(110111 − 0110) = 0001
00010
000100
u(i)
7
14
27
1
2
4
v(i)
000111
001110
011011
000001
000010
000100
Tabelle 3.2: Beispiel Ergebnis des Algorithmus mit u(i) und v(i) aus dem Beweis.
3.4
Bestimmung von Primzahlen
Fast alle kryptohraphischen Verfahren benötigen große Primzahlen. Daher sind Verfahren zur
Bestimmung von zufälligen und großen Primzahlen notwendig. Das allgemeine Vorgehen ist, eine
zufällige große Zahl zu wählen und diese auf die Primzahl Eigenschaft zu testen. Sollte die Zahl
keine Primzahl sein, wiederholt man das Verfahren. Das Problem ist die geringe Wahrscheinlichkeit
eine Primzahl zu wählen. Zum Beispiel ist die Anzahl der 100-stelligen Primzahlen 10100 / ln 10100 −
1099 / ln 1099 und somit ist die Erfolgswahrscheinlichkeit des Verfahrens 0.00868. Ein weiteres
Problem ist es die zufällig gewählten, großen, ungeraden Zahlen auf die Primzahl Eigenschaft zu
testen.
Stochastische Verfahren erlauben es Zahlen effizient zu testen, jedoch existiert immer eine
Fehlerwahrscheinlichkeit. Die stochastischen Tests arbeiten nach dem gleichen Muster. Für eine
Zahl m, die ein Kandidat für eine Primzahl ist, wird eine Menge an Zahlen W gewählt, die als
Zeugen dienen. Wenn eine Zahl w ∈ W ein Teiler von m ist, bezeugt sie, dass m keine Primzahl
ist. Somit muss für alle Zahlen w ∈ W der größte gemeinsame Teiler ggT(w, m) = 1 sein. Da
dieser Test aber zu aufwendig wird, wenn W viele Elemente enthält, wird zusätzlich eine andere
Eigenschaft von Primzahlen genutzt.
Es wird erst getestet, dass ggT(w, m) = 1 gilt und anschließend ob auch wm−1 ≡ 1 (mod m)
stimmt. Sollte dies der Fall sein, ist w ein Zeuge dafür, dass m eine Primzahl ist. Wenn man k = |W |
Zahlen testet, ergibt sich die Wahrscheinlichkeit, dass m eine Primzahl ist aus Lemma 3.7 und ist
entweder 1 − 2−k oder 0 (wenn eine Zahl bezeugt, dass m keine Primzahl ist).
47
Lemma 3.7 Entweder alle oder höchstens die Hälfte aller Zahlen w mit 1 6 w < m und
ggT(w, m) = 1 sind Zeugen dafür, dass m Primzahl ist.
Beweis: Wir nehmen an, dass m keine Primzahl ist, da sonst offensichtlich alle Zahlen bezeugen,
dass m eine Primzahl ist, und es somit ein w gibt mit wm−1 6≡ 1 (mod m). Seien wi , 1 6 i 6 t alle
Zahlen, die bezeugen, dass m eine Primzahl ist, also gilt 1 6 wi < m und wim−1 ≡ 1 (mod m).
Angenommen wir haben einen Nichtzeugen und t verschiedene Zeugen. Dann können wir t viele
ui = wwi mod m bestimmen für die gilt, dass sie keine Zeugen sind, da um−1
≡ wm−1 wim−1 ≡
i
wm−1 (mod m) gilt. Somit existieren mindestens genau so viele Nichtzeugen wie Zeugen.
Das Problem ist, dass dieser stochastische Test auch für Carmichael-Zahl gültig ist, obwohl
Carmichael-Zahlen keine Primzahlen sind. Eine Zahl m ist eine Carmichael-Zahl, wenn sie keine
Primzahl ist und dennoch ∀w : ggT(w, m) = 1: wm−1 ≡ 1 (mod m) gilt. Des weiteren gilt für
diese Zahlen, dass wenn eine Zahl p ein Teiler von m ist, dann ist auch p − 1 ein Teiler von m − 1.
Es gibt unendlich viele Carmichael-Zahlen und sie lassen sich als Produkt von mindestens drei
verschiedenen Primzahlen bestimmen.
3.4.1
Solovay-Strassen
Der Solovay-Strassen-Test ist ein probabilistischer Test, der für eine ungerade Zahl m mit Wahrscheinlichkeit 12 feststellt ob m keine Primzahl ist. Dabei wird die Primzahl Eigenschaft aus Lemma
3.8 verwendet.
Lemma 3.8 Sei m eine ungerade Primzahl, dann gilt für alle w:
w
(m−1)/2
w
≡
(mod m).
m
Beweis: Wenn die Primzahl m das w teilt, gilt die Behauptung. Sonst folgt aus wm−1 ≡ 1 (mod m)
dass w(m−1)/2 ≡ ±1 (mod
eines Generators g von Z∗m darstellen
m) gilt. Wenn wir w als Potenz
w
i
(m−1)/2
ist w = g . Dann gilt: m = 1 ⇐⇒ i ist gerade ⇐⇒ w
≡ 1 (mod m).
(m−1)
w
Es wird eine zufällige Zahl w gewählt und getestet ob ggT(w, m) = 1 und w 2 ≡ m
(mod m) gilt. Sollte eine der beiden Gleichungen nicht gelten, dann ist m keine Primzahl. Mit
Lemma 3.9 ist es offensichtlich, dass nach k Tests ist die Wahrscheinlichkeit dafür, dass m eine
Primzahl ist 1 − 2−k .
Lemma 3.9 Höchstens die Hälfte aller Zahlen w mit 1 6 w < m und ggT(w, m) = 1 sind Zeugen
dafür, dass m Primzahl ist.
Beweis: Zuerst konstruieren wir einen Nichtzeugen w0 um später daraus für jeden Zeugen einen
Nichtzeugen zu bestimmen.
das Quadrat einer Primzahl p2 teilt m. Dann setzten
Angenommenen
0
(m−1)/2
wir w0 = 1 + m/p damit wm = 1 und w0
6≡ 1 (mod m) gilt.
48
Wenn m ein Produkt von verschiedenen Primzahlen ist, wobei p ein Faktor ist, dann wählen wir
einen quadratischen Nichtrest s ∈ QN Rp . Das w0 kann dann durch den Chinesischen Restklassen0
0
satz mit w
≡
s (mod p) und w ≡ 1 (mod m/p) bestimmt werden. Nun gilt für dieses gewählte
0
w0 , dass wm = −1 und w0 (m−1)/2 ≡ 1 (mod m/p) und w0 (m−1)/2 6≡ −1 (mod m) gilt.
Somit haben wir einen Nichtzeugen w0 und können nun für jeden Zeugen einen Nichtzeugen,
(m−1)/2
analog zu dem Beweis von Lemma 3.7, berechnen. Für t Zeugen wi
≡ wmi (mod m)
bestimmen wir ein ui = wwi (mod m) für 1 6 i 6 t.
(m−1)/2
für alle ui , dass der ggT(ui , m) = 1 ist und ui kein Zeuge ist,da w0 (m−1)/2 wi
6≡
0 Nun
gilt
wi
ui
w
(mod m) gilt. Somit kann man für jeden Zeugen einen Nichtzeugen berechnen
m
m ≡ m
und höchstens die Hälfte aller Zahlen mit ggT(w, m) = 1 sind Zeugen.
3.4.2
Miller-Rabin
Ein weiterer probabilistischer Primzahlentest ist der Miller-Rabin Test. Für eine ungerade Zahl m
wird ein s und r bestimmt, sodass m − 1 = 2s r gilt. Dann wird eine zufällige Zahl w bestimmt und
s0
geprüft ob ggT(w, m) = 1 und wr 6≡ 1 (mod m) und w2 6≡ −1 gelten. Sollte eine Bedingung
nicht erfüllt sein, dann ist m keine Primzahl.
Die Wahrscheinlichkeit des Verfahrens einen Nichtzeugen für eine Primzahl zu finden ist doppelt
so hoch, wie bei den vorherigen Verfahren. Somit ist nach k Tests die Wahrscheinlichkeit dafür, dass
m eine Primzahl ist: 1 − 4−k .
49
3.4.3
Deterministischer Primzahltest
Bis zum Jahr 2002 war es offen, wie schwer es ist eine Primzahl zu testen. Das Verfahren von
Agrawal, Kayal und Saxena verwendet auch Zeugen um die Primzahleigenschaft zu testen. Jedoch
kann man hier beweisen, dass eine polynomiale Anzahl von Zeugen ausreicht um die Primzahleigenschaft nachzuweisen. Der Algorithmus 8 hat eine Laufzeit von O(log 12 m). Mittlerweile gibt es
auch schnellere deterministische Primzahltests.
Algorithm 8 Primzahltest(m)
1: Falls m = ab für b > 1, dann ist m keine Primzahl.
2: r := 2
3: while r < m do
4:
Falls ggt(m, r) > 1, dann ist m keine Primzahl.
5:
if r Primzahl then
6:
Sei q der größte Primfaktor von r − 1
r−1
√
7:
Falls (q > 4 r log m) und (m q 6≡ 1 (mod r)) dann breche die Schleife ab
8:
end if
9:
r := r + 1e(a, n)
10: end while
11: for a := 1 bis 2r 1/2 log m do
12:
Falls (x − a)m 6≡ (xn − a) (mod xr − 1, n) dann ist m keine Primzahl.
13: end for
14: m ist eine Primzahl.
50
Kapitel 4
Weitere Public-Key-Systeme
Neben den bereits erläuterten Public-Key-Systemen, gibt es noch einige weitere moderne Verfahren,
die erklärt werden sollten. Das ElGamal-Verfahren ist bezüglich Effizienz und Sicherheit mit RSA
vergleichbar und bietet auf elliptischen Kurven eine schnelle und weiterverbreitete Methode, die
bei gleicher Sicherheit kürzere Schlüssellängen zulässt. Mit Quantenkryptographie ist es möglich
verschlüsselte Nachrichten durch Photonen, die kleinste Einheit des Lichts, zu senden.
4.1
ElGamal
Das ElGamal-Verschlüsselungsverfahren wurde 1985 entwickelt und basiert auf dem Problem des
diskreten Logarithmus. Um das System aufzubauen wird eine große Primzahl p benötigt, wobei
p − 1 einen großen Primfaktor haben muss. Solch eine Primzahl kann mit Hilfe einer weiteren
großen Primzahl q gefunden werden, indem Zahlen der Form 2kq + 1 auf die Primzahl-Eigenschaft
getestet werden.
Des Weiteren wird ein Generator g ∈ Z∗p benötigt. In Kapitel 2.4.1 wurden die notwendigen
mathematischen Grundlagen erklärt. Um zu testen, ob g ein gültiger Generator ist, ist die Darstellung
von p = 2kq + 1 notwendig. Das k sollte klein sein, damit es faktorisierbar ist. Denn für den
Generator g muss für alle Teiler z von p − 1 = 2kq folgendes gelten g (p−1)/z 6≡ 1 (mod p). Somit
ist es möglich schnell und einfach zu testen, ob g ein Generator ist.
Wenn die Primzahl p und der Generator g gefunden wurden, kann ein zufälliges x ∈ {2, . . . , p −
2} gewählt werden mit dem dann der öffentliche Teilschlüssel y := g x mod p berechnet werden
kann. Der komplette öffentliche Schlüssel ergibt sich dann als (p, g, y). Der geheime Schlüssel setzt
sich aus (p, g, x) zusammen, wobei x das Geheimnis ist.
Um eine Nachricht m zu verschlüsseln bestimmt man ein zufälliges k mit ggT(k, p − 1) = 1.
Dann wird a = g k mod p und b = m · y k mod p bestimmt und als verschlüsselte Nachricht
gesendet. Hierbei ist hervorzuheben, dass der Kryptotext die doppelte Größe im Vergleich zum
Plaintext hat und die Teilnachricht a nichts mit m zu tun hat, aber das zufällige k, das der Empfänger
nicht kennt, enthält.
51
Der Empfänger von (a, b) kann nun mit der Kenntnis von x die Nachricht m durch folgende
Berechnung entschlüsseln.
b/ax ≡ y k m/ax ≡ g kx m/ax ≡ m · g kx /g kx ≡ m (mod p)
In Abbildung 4.1 ist das Protokoll zusammengefasst.
A: x, y, g
B: m, y, g
Wähle p Primzahl mit
p − 1 hat großen Primfaktor
Wähle Generator g ∈ Z∗
p
Wähle x ∈ {2, . . . , p − 2}
Bestimme y = g x mod p
y, g
Wähle k mit ggT(k, p − 1) = 1
Bestimme a = g k mod p
m = b/ax mod p
a, b
Bestimme b = my k mod p
Abbildung 4.1: ElGamal Protokoll für Kommunikation.
Das ElGamal System ist bezüglich der Sicherheit als auch der Geschwindigkeit mit RSA
vergleichbar. Die Sicherheit beruht auf dem Diffie-Hellman-Problem, dass für zwei gegebene Zahlen
der Form g x und g k nach g xk oder g −xk fragt. Es ist bekannt, dass, falls man das Problem des
diskreten Logarithmus lösen kann, dann kann man auch das Diffie-Hellman-Problem lösen. Die
Rückrichtung ist jedoch noch offen.
Wie in Abbildung 4.2 zu sehen ist, kann man mit dem ElGamal-Verfahren auch Unterschriften
erzeugen. Dafür wird ein zufälliges k mit ggT(k, p − 1) = 1 gewählt. Anschließend wird r := g k
(mod p) und s := k −1 (m − rx) (mod p − 1) bestimmt. Die Unterschrift ergibt sich dann aus
(m, r, s). Wenn 1 6 r 6 p − 1 und g m ≡ y r rs (mod p) gelten, dann kennt der Absender das
Geheimnis x und die Unterschrift ist gültig.
Das bei einer korrekten Unterschrift g m mod p = y r rs mod p gilt, liegt an folgender Gleichung:
−1
y r rs ≡ (g x )r (g k )s ≡ g rx g kk (m−rx) ≡ g m (mod p) .
Das Unterschriftensystem mit ElGamal ist sicher, solange der diskrete Logarithmus nicht effizient
berechnet werden kann. Ein s zu bestimmen, wenn m und r bekannt sind, ist äquivalent dazu den
diskreten Logarithmus zu bestimmen.
Wenn das zufällig gewählte k zu einer Nachricht (m, r, s) bekannt ist, dann kann das Geheimnis x berechnet werden. Dazu wird rx ≡ (m − sk) (mod p − 1) bestimmt. Da mit hoher
52
Wahrscheinlichkeit der ggT(r, p − 1) = 1 ist, kann nun x bestimmt werden. Daher sollte ein guter
Zufallsgenerator verwendet werden, um k zu bestimmen.
A: m, y, g
B: m, x, y, g
Wähle p Primzahl mit
p − 1 hat großen Primfaktor
Wähle Generator g ∈ Z∗
p
Wähle: x ∈ {2, . . . , p − 2}
y, g
Bestimme: y = g x mod p
Wähle: k mit ggT(k, p − 1) = 1
Bestimme: r = g k mod p und
Teste, ob gilt: 1 6 r 6 p − 1
r, s, m
s = k−1 (m − rx) mod p − 1
?
(g m mod p) = (y r r s mod p)
Abbildung 4.2: ElGamal Protokoll für Unterschriften.
Des Weiteren muss für jede Nachricht ein neues k bestimmt werden, da ansonsten k und somit
auch wieder x bestimmt werden können. Wenn ein k für zwei verschiedene Nachrichten m1 und m2
gewählt wird, kann das k einfach durch k = (s1 − s2 )−1 (m1 − m2 ) mod p − 1 berechnet werden.
Wenn keine Hashfunktion für die Unterschrift verwendet wird, ist es möglich eine Unterschrift
zu fälschen. Dabei kann jedoch die Nachricht m, die unterschrieben werden soll nicht frei gewählt
werden. Ein Fälscher bestimmt b, c mit ggT(c, p − 1) = 1. Anschließend wird r := g b y c mod p,
s := −rc−1 mod p − 1 und m := −rbc−1 mod p − 1 berechnet damit die Unterschrift g m ≡ y r rs
(mod p) erfüllt. Dass die Gleichung für die gewählten Werte gilt ist in der nachfolgenden Berechnung zu erkennen:
yr rs ≡
≡
≡
≡
≡
4.2
b c
−1
y g y (g b y c )−rc
b c
−1
−1
y g y g −rbc y −rcc
b c
−1
b c
−1
y g y g −rbc y −(g y )cc
−1
g −rbc
gm
(mod
(mod
(mod
(mod
(mod
p)
p)
p)
p)
p)
Elliptische Kurven
Eine elliptische Kurve entspricht einer Gleichung mit zwei Unbekannten x und y. Die Wertepaare
(x, y), die die Gleichung erfüllen, sind Teil der Kurve. Somit kann eine elliptische Kurve als Polynom
53
f (x, y) über zwei Variablen dargestellt werden. Für jeden Term des Polynoms c · xm · y n mit c 6= 0
als Konstante ist der Grad als Summe n + m definiert. Der größte Grad der Terme ist dann der Grad
von f (x, y). In Definition 4.1 ist die Weierstrass-Form einer elliptischen Kurve definiert, die als
neutrales Element den Punkt ∞ besitzt. In Abbildung 4.3 ist die Elliptische Kurve aus Definition
4.1 in einem Koordinatensystem zu sehen.
Definition 4.1 (Elliptisch Kurve)
Eine elliptische Kurve ist der Graph E (bzw. Ea,b ) der Gleichung y 2 = x3 + a · x + b, mit
x, y, a, b ∈ R (bzw. Q, Z, Nm ). Weiterhin gehört zu E der Punkt ∞.
y
y 2 = x3 − 3x + 2
x
Abbildung 4.3: Elliptische Kurve aus Definition 4.1.
Wenn ein Polynom f (x, y) den Grad d hat, dann schneidet eine Grade der Form a · x + b · y + c = 0
das Polynom in höchstens d Punkten. Dies ist offensichtlich, wenn man die Gerade nach x auflöst
und in das Polynom einsetzt. Denn dann hat die Gleichung höchstens d viele Nullstellen für y.
54
Aus dieser Beobachtung möchte man eine Operation definieren, um eine elliptische Kurve als
mathematische Gruppe zu verwenden. Dazu wählt man f (x, y) mit Grad drei, damit durch zwei
gewählte Punkte P und Q eine Gerade bestimmt werden kann, die dann den dritten Punkt definiert.
Die Grade g(x, y) = 0 kann allgemein als a · x + b · y + c = 0 mit b 6= 0 definiert werden. Nachdem
zwei Punkte auf f (x, y) festgelegt wurden, ist die Gerade festgelegt und der dritte Punkt kann durch
f (x, (−a · x − c)/b) = 0 berechnet werden. Als Lösung kommen dabei drei x-Koordinaten in Frage,
wobei zwei zu den im Vorhinein gewählten Punkten gehören. Die zugehörige y-Koordinate für den
gesuchten dritten Punkt erhält man durch einsetzten in die Geradengleichung. In Abbildung 4.4 ist
ein Beispiel zu sehen, bei dem durch die zwei blauen Punkte eine Gerade bestimmt wurde, die die
elliptische Kurve in einem dritten, roten Punkt schneidet. Dieses Verfahren um den Punkt R aus
zwei Punkten P und Q bestimmen wird zukünftig mit P ⊕ Q = R bezeichnet.
y
y 2 = x3 − 3x + 2
x
Abbildung 4.4: Elliptische Kurve, auf der eine Gerade durch zwei Punkte bestimmt wurde,
um einen dritten zu berechnen.
55
Um nun eine Gruppe zu definieren, betrachten wir einen Punkt P = (x, y), der ein Element der
Gruppe ist, auf der elliptischen Kurve y 2 = x3 + a · x + b. Die Negation des Elements P ist als
−P = (x, −y) definiert. Bei der Addition von zwei Elementen unterscheiden wir einige Fälle. Wenn
ein Element P = (x, y) mit seinem Negativem Q = −P = (x, −y) addiert wird ist das Resultat
das neutrale Element der Gruppe, also gilt Q + P = ∞. Wenn Q 6= −P ist, wird das Ergebnis der
Addition als P + Q = −R definiert, mit R = P ⊕ Q aus der oben beschriebenen Methode. Die
Addition eines Elements mit dem neutralen Element ergibt wieder das Element. Daher gilt formal
ausgedrückt P + ∞ = ∞ + P = P und ∞ + ∞ = ∞ + ∞ = ∞. Wenn ein Element mit sich selbst
addiert wird P + P wird eine Tangente T am Punkt P bestimmt. Wenn die Tangente vertikal ist und
somit keinen Schnittpunkt mit der elliptischen Kurve besitzt, ist das Ergebnis das neutrale Element
∞. Wenn T jedoch einen weiteren Punkt R trifft, ist das Ergebniss der Addition P + P = −R. In
Abbildung 4.6 ist ein Beispiel für P + Q und Z + Z zu sehen. Dabei sind mit rot die Schnittpunkte
der Geraden beziehungsweise der Tangente markiert und mit grün die jeweiligen Negationen der
Schnittpunkte, welche den Ergebnissen der Additionen entsprechen. Für diese Definitionen wurden
die folgenden Aussagen gezeigt, die hier jedoch nicht bewiesen werden.
Theorem 4.2 Die oben definierte Operation auf y 2 = x3 + a · x + b ist eine Gruppe.
Theorem 4.3 Die Gruppe auf y 2 = x3 + a · x + b (mod p) hat N = p + 1 +
Elemente.
Pp−1
r=0 (
x3 +a·x+b
)
p
Theorem 4.4 (Hasse) Die Gruppe auf y 2 = x3 + a · x + b (mod p) hat N Elemente, mit p + 1 −
√
√
2 · p < N < p + 1 + 2 · p.
Der diskrete Logarithmus auf diesen Gruppen gilt als schwierig und dient wie bei ElGamal zur
Erstellung eines Public-Key-Verfahrens. Dafür wird ein Punkt P0 als Generator g verwendet und
die Potenzierung g x wird zur Rechnung xP0 . Um nun eine Nachricht M als Element der Gruppe
abzubilden, gibt es ein probabilistisches und ein deterministisches Verfahren.
Für das probabilistische Verfahren benötigt man eine Primzahl p, die elliptische Kurve E und
das N aus Theorem 4.3 und 4.4. Die Nachricht M mit 0 < M < p/2k wird nun als Punkt über die
x-Koordinate x = 2k · M + i mit 0 6 i < 2k bestimmt, sodass der Punkt der Form (x, y) ∈ E als
Darstellung von M dient. Um ein gültiges i zu finden, werden alle 0 6 i < 2k ausprobiert, bis ein
3
x = 2k · M + i gefunden wurde für das ( x +a·x+b
) = +1 erfüllt ist. Die Fehlerwahrscheinlichkeit
p
k
des Verfahrens beträgt 1/22 . Dadurch, dass wir die x-Koordinate durch x = 2k · M + i berechnen,
wird die eigentliche Nachricht um k Bits vergrößert wodurch man umgangssprachlich sagen könnte,
dass k Bits “verschwendet” werden.
Das deterministische Verfahren benötigt spezielle Gruppen, bei denen für die Primzahl p ≡ 3
(mod 4) gelten muss und die elliptische Kurve die Form y 2 = x3 + a · x (mod p) hat. Die Primzahl
muss die Eigenschaft erfüllen damit −1 ein quadratischer Nichtrest ist, das heißt, dass ( −1
p ) = −1
gilt. Wenn nun die Nachricht M verschlüsselt werden soll, muss 0 < M < p/2 gelten, was den
eigentlich möglichen Nachrichtenraum einschränkt. Umgangssprachlich könnte man sagen, dass
56
Abbildung 4.5: Elliptische Kurve mit einer eingezeichneten Gerade und einer Tangente zur
Bestimmung der Ergebnisse von P + Q und Z + Z.
dadurch ein Bit “verschwendet” wird. Bevor die M repräsentierende x-Koordinate bestimmt werden
kann, muss zunächst t = M 3 + aM (mod p) berechnet werden. Dann ist entweder t oder −t ein
quadratischer Rest. Falls ( pt ) = 1 gilt wird x = M als Koordinate gewählt. Andernfalls, also wenn
3
x +a·x
( −t
) = 1 ist und die zugehörige
p ) = 1 gilt, wird x = p − M berechnet. Damit gilt, dass (
p
y-Koordinate bestimmt werden kann. Um bei der späteren Entschlüsselung die beiden Fälle zu
unterscheiden und die richtige Nachricht M zu erhalten, kann M = min(x, p − x) berechnet
werden.
In Abbildung 4.6 ist der Aufbau und die Anwendung des Systems zusammen gefasst. Um das
System nun aufzubauen, wird eine Primzahl p bestimmt, eine elliptische Kurve E modulo p und
ein P0 auf E mit großer Ordnung. Ein Nutzer A bestimmt nun eine Zahl aA und veröffentlicht
das Ergebnis der Potenzierung, die auf elliptischen Kurven durch Multiplikation dargestellt wird,
von PA = aA P0 . Somit ist P0 der Generator, aA entspricht dem privaten Schlüssel und PA ist der
57
öffentliche Schlüssel.
Wenn B nun eine Nachricht M senden möchte, muss zunächst der repräsentierende Punkt P mit
einem der oben beschriebenen Verfahren bestimmt werden. Anschließend wird noch ein k bestimmt,
sodass 0 < k < p gilt. Die verschlüsselte Nachricht besteht wie bei ElGamal aus zwei Teilen
(kP0 , kPA + P ). Für die Entschlüsselung wird der private Schlüssel aA benötigt, da die Nachricht
durch die folgende Rechnung bestimmt werden kann:
kPA + P − aa (kP0 ) = (kaA )P0 + P − (kaA )P0 = P
Der Ansatz des Verfahrens ist analog zu dem Vorgehen der ElGamal Verschlüsselung. Der Hauptunterschied ist, dass die mathematische Gruppe auf der die Rechnungen stattfinden komplizierter
ist. Die Sicherheit des kryptographischen Verfahrens mit elliptischen Kurven ist daher mindestens
analog zu der Sicherheit des ElGamal Systems.
A: aA , PA , P0 , E
B: m, PA , P0 , E
Wähle p Primzahl
Wähle ell. Kurve E (mod p)
Wähle P0 ∈ E
Wähle aA ∈ {2 . . . p − 1}
PA := aA P0
P0 , E, PA
erzeuge P ∈ E aus m
Wähle k ∈ {1 . . . p − 1}
T1 = kP0
0
T = T2 − aA T1
T 1 , T2
T2 = kPA + P
T 0 = kPA + P − (aA k)P0
T 0 = (aA k)P0 + P − (aA k)P0
Bestimme m aus T 0
Abbildung 4.6: Protokoll für die Verschlüsselung mit elliptischen Kurven.
Sollte der diskrete Logarithmus auf der elliptischen Kurve E lösbar sein, kann man aus der
Teilnachricht kP0 das k bestimmen und dann zusammen mit dem öffentlichen Schlüssel kPA
bestimmen. Um den Punkt P , der die Nachricht M repräsentiert, zu bestimmen wird (kPA + P ) −
kPA = P gerechnet.
58
4.3
Quantenkryptographie
Aus der Physik ist bekannt, dass die kleinste Einheit des Lichts ein Photon ist. Es ist möglich
die Ausrichtung des Photons – die Richtung, in die die Lichtwelle ausgerichtet ist – mit einem
Polarisationsfilter zu messen. Bei einer solchen Messung kann aber immer nur auf eine Ausrichtung
getestet werden und das Photon ist danach nicht mehr vorhanden. Jedoch lassen sich Photonen in
jeder der beliebig vielen Ausrichtungen erzeugen, sodass nach einer Messung ein neues Photon
erstellt werden kann.
Um nun eine Datenübertragung mit Photonen zu realisieren, muss eine Darstellung für “1” und
“0” gefunden werden. Eine Möglichkeit wäre das Senden in einer bestimmten Ausrichtung als “1” zu
interpretieren und die dazu orthogonale Ausrichtung für die “0” zu verwenden. In dieser Darstellung
ist jedoch ein unerkanntes Lauschen möglich. Um dies zu verhindern sollten zwei verschiedene
Darstellungen verwendet werden. In Abbildung 4.7 ist auf der linken Seite die gewählte Ausrichtung
der Photonen zu sehen, wobei die “1” und die “0” jeweils zwei Darstellungen haben, und auf der
rechten Seite die gewählten Filter des Empfänger und das Ergebnis der Messungen.
Sende: 1
Sende: 0
Sende: 1
Sende: 0
Sende: 1
Sende: 0
Sende: 1
Sende: 0
Abbildung 4.7: Von links werden Photonen, die in vier Richtungen ausgerichtet werden,
nach rechts gesendet, wo nur die richtig gemessenen Photonen erhalten bleiben.
Um eine fehlerfreie Übertragung zu gewährleisten, müssen die Darstellungen bekannt sein.
Dann ist jedoch auch unerkanntes Lauschen möglich. Wenn die Darstellungen nicht bekannt sind,
tritt ungefähr bei der Hälfte der Übertragungen ein Fehler auf. In Abbildung 4.8 ist die Übertragung
mit zwei für den Empfänger unbekannten Darstellungen ohne Lauscher zu sehen. Wenn nun, wie
in Abbildung 4.9 zu sehen ist, ein Lauscher die Photonen vorher abfängt, macht er bei der Hälfte
einen Fehler. Um unerkannt zu lauschen, muss er die gemessenen Photonen reproduzieren, wobei
59
Sende: 1
Sende: 0
Sende: 1
Sende: 0
Sende: 1
Sende: 0
Sende: 1
Sende: 0
Abbildung 4.8: Die Messung wird Fehlerhaft, wenn die Ausrichtungen im Vorhinein nicht
bekannt sind.
bei der Hälfte geraten werden muss. Durch die Fehlerquote von 50%, die auch der eigentliche
Empfänger hat, sind nun ungefähr drei Viertel der Übertragungen fehlerhaft. Daher sollte die
Kommunikation abgebrochen werden, wenn die Fehlerquote zu hoch wird. Bei der Realisierung der
Quantenkryptographie gibt es jedoch technische Probleme. Das Erstellen und Auswerten ist langsam
und die dazu notwendige Technik sehr teuer. Zusätzlich können bei der Übertragung Photonen
verloren gehen, es können mehr als ein Photon gesendet werden, was zu Doppelmessungen führen
kann, und es können Fehlmessungen auftreten.
60
Sende: 1
Sende: 1
Sende: 0
Sende: 0
Sende: 1
Sende: 1
Sende: 0
Sende: 0
Sende: 1
Sende: 1
Sende: 0
Sende: 0
Sende: 1
Sende: 1
Sende: 0
Sende: 0
Abbildung 4.9: Die Photonen werden von einem Lauscher in der Mitte abgefangen und
müssen anschließend reproduziert und an den eigentlichen Empfänger gesendet werden.
Dabei ist die steigende Fehlerquote deutlich zu erkennen.
61