OpenSSL – Kryptologie in C - Institut für Mathematik - Hu

Transcription

Vorlesungsmitschrift
OpenSSL – Kryptologie in C
Dozent: Dr. Ernst-Günter Giessmann
Peter Haider, Ulf Hermann, Mathias Jeschke, Jens Kleine & Henryk Plötz
(haider|uhermann|jeschke|jkleine|ploetz)@informatik.hu-berlin.de
WS 2004/2005 und SS 2005
8. Juli 2009 (Revision: 1.93 )
Humboldt-Universität zu Berlin
Institut für Informatik
1
Inhaltsverzeichnis
1
Einführung
1.1
1.2
1.3
1.4
1.5
1.6
Verschlüsselung . . . . . . . . . . .
Beispiel: rot13 . . . . . . . . . . . .
Block-Chiffre . . . . . . . . . . . .
Strom-Chiffre . . . . . . . . . . . .
Angriffstypen . . . . . . . . . . . .
1.5.1 Differentielle Kryptoanalysis
Base64 . . . . . . . . . . . . . . . .
5
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6
6
7
8
8
9
10
2
OpenSSL
10
3
Symmetrische Verschlüsselungsverfahren
12
3.1
3.2
3.3
3.4
3.5
3.6
2
Feistel-Chiffren . . . . . . . . . . . . . . . . .
DES - Data Encryption Standard . . . . . . . .
3.2.1 Schlüsselauswahl . . . . . . . . . . . .
3.2.2 Funktionsweise . . . . . . . . . . . . .
3.2.3 Schwachstellen und Unsinnigkeiten . .
3.2.4 spezielle Optionen bei openssl . . . . .
3.2.5 DES:ECB - Electronic Code Book . . .
3.2.6 DES:CBC - Cipher Block Chaining . .
3.2.7 DES:OFB - Output Feed Back . . . . .
3.2.8 DES:CFB - Cipher Feed Back . . . . .
3.2.9 CTR Mode, CCM . . . . . . . . . . .
3.2.10 TEA-Algorithmus . . . . . . . . . . .
3.2.11 DES-X . . . . . . . . . . . . . . . . .
IDEA: International Data Encryption Algorithm
3.3.1 Schlüsselauswahl . . . . . . . . . . . .
3.3.2 Funktionsweise . . . . . . . . . . . . .
3.3.3 Pseudocode-multiplikation . . . . . . .
3.3.4 Schwachstellen . . . . . . . . . . . . .
Blowfish . . . . . . . . . . . . . . . . . . . . .
3.4.1 Initialisierung . . . . . . . . . . . . . .
3.4.2 Verschlüsselung . . . . . . . . . . . . .
AES: Advanced Encryption Standard . . . . . .
3.5.1 Wiederholung-Byteoperation . . . . . .
3.5.2 Überblick . . . . . . . . . . . . . . . .
3.5.3 mathematische Grundlagen . . . . . . .
RC4: Ron’s Cipher 4 . . . . . . . . . . . . . .
3.6.1 Geschichte . . . . . . . . . . . . . . .
3.6.2 Beschreibung . . . . . . . . . . . . . .
3.6.3 Der Pseudo-Zufalls-Algorithmus . . . .
3.6.4 Der Schlüsselerzeugungs-Algorithmus .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
12
14
15
16
17
18
20
21
23
24
25
26
28
28
29
29
30
31
31
33
34
35
35
35
38
39
40
41
41
42
3.7
3.8
3.9
4
3.6.5 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.6.6 Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.6.7 Fluhrer, Mantin und Shamir Angriff . . . . . . . . . . . . . . . . . . .
RC5: Ron’s Cipher 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.7.1 Verschlüsselung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
3.7.2 Schlüsselexpansion . . . . . . . . . . . . . . . . . . . . . . . . . . . .
GOST 28147-89: Gosudarstvennyi Standard Soyuza SSR, nicht in OpenSSL . .
Fazit:Wie könnte bei einen Symmetrischen Algorithmus die Sicherheit erhöhen??
43
43
44
44
44
45
45
47
Asymmetrische Verschlüsselungsverfahren
47
4.1
47
48
48
49
49
49
51
54
54
55
56
56
56
57
58
58
59
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
4.12
4.13
4.14
4.15
4.16
Einführung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.1.1 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Geschichte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Einige Theoretische Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . .
4.3.1 Kleiner Fermat (oder kleiner Fermat’scher Satz) . . . . . . . . . . . . .
4.3.2 Euklidischer Algorithmus . . . . . . . . . . . . . . . . . . . . . . . .
4.3.3 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
RSA: Rivest, Shamir, Adleman . . . . . . . . . . . . . . . . . . . . . . . . . .
4.4.1 Funktionsweise des RSA-Verfahrens . . . . . . . . . . . . . . . . . . .
4.4.2 Beweis der Funktionsweise . . . . . . . . . . . . . . . . . . . . . . . .
Schwächen von RSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Fuktionen in OpenSSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6.1 genrsa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6.2 rsa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6.3 rsautl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6.4 PKCS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6.5 OAEP - Optimal Asymmetric Encryption Padding . . . . . . . . . . .
4.6.6 Wie erkennt man an Ciphertexten den Verschlüsselungsalgorithmus- DER
/ ASN1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.6.7 Umgehen mit den Schlüsselkomponenten . . . . . . . . . . . . . . . .
Miller-Rabin Test . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Diffie-Hellman-Schlüsselaustausch . . . . . . . . . . . . . . . . . . . . . . . .
ElGamal-Cryptosystem . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Wiederholung DH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.10.1 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
was anderes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Elliptische Kurven . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Elliptische Kurven Nachtrag . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rucksack-Verschlüsseln . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.14.1 Beispiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Merkle Puzzle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Rabin-Verfahren und Wurzelziehen . . . . . . . . . . . . . . . . . . . . . . . .
4.16.1 Schlüsselgenerierung . . . . . . . . . . . . . . . . . . . . . . . . . . .
4.16.2 Kongruenzbedingung . . . . . . . . . . . . . . . . . . . . . . . . . . .
60
61
62
64
66
66
67
67
67
70
71
71
71
72
72
73
3
4.16.3 Verschlüsselung . . . . . . . . . . . . . . . . .
4.16.4 Entschlüsselung . . . . . . . . . . . . . . . .
4.17 Angriffe auf asymmetrische Verschlüsselungsverfahren
4.17.1 1. Angriff: Common modulus attack . . . . . .
4.17.2 2. Angriff: kleiner geheimer Exponent d . . . .
4.17.3 3. Angriff: Faktorisieren . . . . . . . . . . . .
4.17.4 Echt schlechte RSA-Schlüssel . . . . . . . . .
4.17.5 Schnelles Faktorisieren bei Fehler im System .
4.17.6 Angriff mit gewähltem Chiffretext . . . . . . .
5
5.2
5.3
5.4
5.5
5.6
5.7
5.8
6.2
6.3
4
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Integritätsschutz und Hashfunktionen . . . . . . . . . . . . . . . . . . . . .
5.1.1 Schlüssellose Hashfunktion (Prüfsummen ohne Schlüssel) . . . . . .
5.1.2 Demonstration Fälschung . . . . . . . . . . . . . . . . . . . . . . .
Unterschied MD5 und SHA . . . . . . . . . . . . . . . . . . . . . . . . . . .
Secure Hash Standard, SHA-2 . . . . . . . . . . . . . . . . . . . . . . . . .
5.3.1 Problem bei MD5 und SHA-0 . . . . . . . . . . . . . . . . . . . . .
5.3.2 MACs (Message Authentication Codes) (Prüfsummen mit Schlüsseln)
Whirlpool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Digitale Signaturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.1 RSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.2 Eigenschaften eines asymmetrischen Verschlüsselungsverfahren . . .
5.6.3 RSASSA-PSS-Padding . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.4 DSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.6.5 ECDSA - DSA mit Elliptischen Kurven . . . . . . . . . . . . . . . .
Widerrufen von Zertifikaten . . . . . . . . . . . . . . . . . . . . . . . . . .
Was es noch so gibt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.8.1 blinde Signaturen . . . . . . . . . . . . . . . . . . . . . . . . . . . .
5.8.2 anonyme Signaturen . . . . . . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
6.0.3 X509 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.0.4 Erweiterungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.0.5 Erzeugung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.0.6 Gültigkeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Praktische Ausschlachtung von kryptografischen Algorithmen mit S/MIME und
PKCS#7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
PKCS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
6.2.1 PKCS#7: 1.5 November 93 RFC 3852 . . . . . . . . . . . . . . . . . .
CMS(Cryptographic Message Syntax) . . . . . . . . . . . . . . . . . . . . . .
Wichtige Neuerungen bei den Versionsänderungen
73
74
74
75
75
75
75
76
76
77
Zertifikate
6.1
7
.
.
.
.
.
.
.
.
.
Signaturmechanismen
5.1
6
.
.
.
.
.
.
.
.
.
77
80
83
84
85
86
87
89
89
91
92
93
95
97
99
103
105
105
105
105
107
108
111
112
114
115
115
116
119
8
OpenSSL hintergehen
8.1
8.2
8.3
8.4
9
120
die eine Primzahl ganz klein erzeugen . . . . . . . . . . . . . . . .
beide Primzahlen nah beieinander . . . . . . . . . . . . . . . . . .
Vorschrift des BSI . . . . . . . . . . . . . . . . . . . . . . . . . . .
Programmierung: Zufallszahlenerzeugung und andere nette features
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
Zusammenfassung
121
10 Mathematische Techniken
10.1 Multiplikatives Inverses . . . . . . . . . . . . . . . . . . . .
10.1.1 Behauptung . . . . . . . . . . . . . . . . . . . . . .
10.1.2 Beweis . . . . . . . . . . . . . . . . . . . . . . . .
10.2 Kleiner Fermatscher Satz . . . . . . . . . . . . . . . . . . .
10.2.1 Behauptung . . . . . . . . . . . . . . . . . . . . . .
10.2.2 Beweis . . . . . . . . . . . . . . . . . . . . . . . .
10.2.3 Verallgemeinerung . . . . . . . . . . . . . . . . . .
10.2.4 Praktische Anwendung auf Primzahlen . . . . . . .
10.3 Chinesischer Restklassensatz . . . . . . . . . . . . . . . . .
10.3.1 Behauptung . . . . . . . . . . . . . . . . . . . . . .
10.3.2 Beweis . . . . . . . . . . . . . . . . . . . . . . . .
10.4 Square and multiply . . . . . . . . . . . . . . . . . . . . . .
10.5 Montgomery Reduktion (Moduloberechnung ohne Division)
10.6 Nochwas? . . . . . . . . . . . . . . . . . . . . . . . . . . .
120
120
120
121
122
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
122
123
123
123
123
123
124
125
125
126
126
127
127
131
1 Einführung
Literaturempfehlungen:
• Alfred J. Menezes, Paul C. van Oorschot, Scott A. Vanstone - Handbook of Applied Cryptography. CRC Press, 1996. ISBN 0849385237. http://www.cacr.math.uwaterloo.ca/hac/
• John Viega, Matt Messier, Pravier Chandra - Network Security with OpenSSL. O’Reilly,
2002. ISBN 059600270X.
• Michael Welschenbach - Kryptographie in C und C++. Springer, 2001. ISBN 3540420614.
• Bruce Schneier - Applied Cryptography. Wiley, 2nd rev, 1996. ISBN 3540420614.
Prüfung: 24. 08. 2009
In der Vorlesung wird öfters der ’Magma Calculator’ verwendet. Dabei handelt es sich um die
Online-Version eines Computer Algebra Systems (http://magma.maths.usyd.edu.au/calc/). Im
folgenden werden Berechnungen die mit Magma durchgeführt wurden mit ’Magma:’ gekennzeichnet.
5
Kryptographie ist einer der beiden Bestandteile der Kryptologie, der andere ist Kryptoanalyse.
Kryptographie: Entwurf von Sicherheitsalgorythmen, die Daten vor Mitlesen und Verändern
schützen
Kryptoanalyse: Aktives Analysieren von kryptographischen Verfahren
1.1 Verschlüsselung
Verschlüsselung benötigt Menge von Schlüsseln
E
N
-
Algorithmus
(z.B. DES)
-
c
6
K
N Menge der Nachrichten
K Menge der Schlüssel
c Verschlüsselte Nachricht
∀n ∈ N, k ∈ K: c = E(n, k) eindeutig
∃ Algorithmus D (decrypt) mit: aus c = E(n, k) folgt ∃k0 ∈ K mit n = D(c, k0 )
1.2 Beispiel: rot13
N = Alphabet
n∈N
c = n + 13 mod 26
Dies ist kein Verschlüsselungsalgorithmus, da es nur einen Schlüssel gibt!
c = n + k mod 26
Dies ist ein Verschlüsselungsalgorithmus, da es eine Menge von Schlüsseln gibt!
c = E(n, k) = n + k
n = D(c, k) = c − k
E(n, 13) = D(n, 13)
6
Variante der Betrachtung: k0 = 26 − k ⇒ D(c, k0 ) = E(c, k0 )
Verschlüsseln = Entschlüsseln = Vorteil: nur ein Algorithmus
Berechnung:
k → k0 (vernünftig im allgemeinen Sinne)
E · D = IdC
D · E = IdN
Man unterscheidet bei Verschlüsselungsverfahren:
symmetrisch: k ⇔ k0 kennt man einen Schlüssel, kennt man beide
asymmetrisch: k ⇒ k0 oder k ⇐ k0 aus dem einen Schlüssel kann man den
anderen nicht erfahren
1.3 Block-Chiffre
Ausdehnung der Verschlüsselung von Alphabet auf Zeichenketten mi . Die Originalnachricht
wird in Blöcke zerlegt, die gleich verschlüsselt werden. Zum Beispiel:
m = (m1 , m2 , m3 , ...)
k = (k1 , k2 , k3 , ...)
ci = mi ⊕ ki
Aus der Wikipedia (unter GNU Free Documentation License):
Symmetrische Verschlüsselungsalgorithmen sind oft Blockverschlüsselungsalgorithmen (auch
Blockchiffre). Bevor sie Daten verschlüsseln, werden diese zunächst in Blöcke unterteilt, deren Größe durch den Algorithmus vorgegeben ist. Die Verschlüsselungsroutinen setzen jedoch
ganze Blöcke voraus, somit muss meistens der letzte Block mit Zufallsdaten aufgefüllt werden
(bei einer Blockgröße von 128 Bit werden die verschlüsselten Daten somit 0 bis 127 Bit größer
als der Klartext).
Die Blöcke werden anschließend nacheinander verschlüsselt. Dabei ist es durchaus üblich, dass
das Ergebnis der Verschlüsselung eines Blocks bei der Verschlüsselung des nächsten Blocks
als Eingangswert mitverwendet wird.
Wichtige Parameter einer Blockchiffre sind somit die Blocklänge (auch Blockgröße) und die
Schlüssellänge.
7
1.4 Strom-Chiffre
Eine Strom-Chiffre ver- bzw. entschlüsselt Nachrichten Bit für Bit bzw. Zeichen für Zeichen.
Dies steht im Gegensatz zu Block-Chiffren, wo Nachrichten immer in gleich großen Blöcken
verarbeitet werden.
Strom-Chiffren sind symmetrische Verschlüsselungsalgorithmen, die sehr schnell arbeiten.
Zur Generierung eines Geheimtextes wird zunächst ein Schlüsselstrom erzeugt. Dieser
Schlüsselstrom ist eine Folge von Zeichen die nur mit Kenntnis des geheimen Schlüssels erzeugt werden kann (in der Regel eine Pseudozufallsfolge). Danach wird jedes Zeichen des
Schlüsselstroms mit einem Zeichen des Klartextes verknüpft. Die Verknüpfungsoperation ist
XOR. Um Geheimtexte wieder zu entschlüsseln, wird der Geheimtext mit dem Schlüsselstrom
verknüpft.
Beispiele für Strom-Chiffren sind die XOR-Verschlüsselung oder die Entwicklung von
Ronald L. Rivest namens RC4.
1.5 Angriffstypen
m Nachricht
c verschlüsselte Nachricht
k Schlüssel
Kommunikation zwischen Alice und Bob mit Angreifer Eve. Vorraussetzung: Eve kennt das
Verfahren
1. Chiffre ist bekannt
(ciphertext only / Chiffre allein Angriff)
m, k gesucht
2. (mi , ci )-Paare sind bekannt, ci = E(k, mi )
(known plain text / bekannter Klartext Angriff)
gesucht k und weitere mi
3. wählbarer Klartext / chosen plaintext
(z.B. Eve hat Encoder in die Hände bekommen)
4. wählbarer Chiffretext / chosen ciphertext
(z.B. Eve hat Decoder in die Hände bekommen)
Generelle Schutzmechanismen zum sicherer machen:
8
1. Klartextbits breit auf Chiffre verteilen und Schlüsselbits überall einbringen, um die Sicherheit zu erhöhen, bzw. einen anderen Algorithmus verwenden um dies zu erreichen.
2. Algorithmus skalieren: Länge des Schlüssels, mehr Runden.
3. Schwachen zusätzlichen Schutz bietet doppeltes verschlüsseln, zum Beispiel:
Algorithmus hat 64-Bit Sicherheit (Brute Force Angriff: Aufwand von 264 ), doppelt verschlüsselt hat er 65-Bit Sicherheit, wegen:
meet in the middle Angriff“: Ist known plain text attack: m ist der Klartext, k der Schlüssel
”
für den ersten Algorithmus, n der daraus resultierende “Zwischentext”, l der Schlüssel für
den zweiten Algorithmus und c die endgültige verschlüsselte Nachricht. Der Angreiferin
ist ein m und das dazu gehörige c bekannt. Sie erzeugt sich nun alle Werte, die k annehmen kann und alle Werte die l annehmen kann und berechnet zu jedem ki sowie zu
jedem li ein ni als E(ki , m) bzw. D(li , c). Damit muss sie 2 ∗ 264 Paare von Schlüsseln
und “Zwischentexten” erzeugen und speichern. In der Menge der ni gibt es nun (da beide
Verschlüsselungen eindeutig sind) genau zwei - eines als Entschlüsselung von c, eines als
Verschlüsselung von m -, die übereinstimmen. Deren Schlüssel sind diejenigen, die auch
bei der Erzeugung von c verwendet wurden. Das Auffinden dieses Paares kann durch geschickte Speicherung der ni , ki und li zum Beispiel in einer Hashtabelle in logarithmischer
Zeit bewerkstelligt werden.
Daher: Sicherheit des Algorithmus ist mindestens so stark wie jeder einzelne Algorithmus,
aber möglicherweise nicht viel besser.
4. Dreifach verschlüsseln und Kombination von Algorithmen:
Der Meet-in-the-middle attack schlägt hier fehl, da der Speicher- und Rechenaufwand
nun quadratisch mit dem Werteraum der Schlüssel wächst. Bei der Verwendung eines
schwachen Algorithmus, der anderweitig gebrochen werden kann wird die Kombination
jedoch wieder anfällig für meet-in-the-middle.
5. Block-Chiffre + Strom-Chiffre kombinieren:
Strom-Chiffre sehr langer Schlüssel c = p ⊕ k, k zufällig gewählt (möglichst echter physikalischer Zufall), zwei Folgen C, K → in Block-Chiffre → Blockweise: C2 = E(S 1 , K),
C1 = E(S 2 , C)
Eine Strom-Chiffre und zwei Block-Chiffren: Brechen dieser Kombination = Aufwand
addiert sich, aber doppelte Ausgabelänge.
1.5.1 Differentielle Kryptoanalysis
man wähle Klartexte P1 , P2 mit ganz bestimmten Unterschied P1 ⊕ P2 = D. Bei der Verschlüsselung ergibt sich dann für die Chiffretexte C1 , C2 mit bestimmten D0 = C1 ⊕ C2 das in
einen bestimmetn Zusammenhang zu D steht.
Bleiben die Schlüssel immer gleich, so kann man sich langsam mit D1 , . . . , Dn an den Klartext
ranprobieren. (?)
9
1.6 Base64
Base64 [...] beschreibt ein Verfahren zur Kodierung von 8-Bit-Binärdaten (z. B. ausführbare
Programme, ZIP-Dateien), in eine Zeichenfolge, die nur aus wenigen Codepage-unabhängigen
ASCII-Zeichen besteht. Im Zusammenhang mit OpenPGP wird noch eine Prüfsumme (CRC24) angehängt und es als Radix-64 bezeichnet.
Es findet im Internet-Standard MIME (Multipurpose Internet Mail Extensions) Anwendung und wird damit hauptsächlich zum Versenden von E-Mail-Anhängen verwendet. Nötig
ist dies, um den problemlosen Transport von beliebigen Binärdaten zu gewährleisten, da SMTP
in seiner ursprünglichen Fassung nur für den Versand von 7-Bit ASCII-Zeichen ausgelegt war.
Zur Kodierung werden die Zeichen A-Z, a-z, 0-9, + und /, verwendet, sowie = am Ende.
Da diese Zeichen auch in EBCDIC vorkommen (wenn auch an anderen Code-Positionen), ist
damit auch ein Datenaustausch zwischen nicht-ASCII-Plattformen möglich.
Zur Kodierung werden jeweils drei Byte des Bytestroms (=24 bit) in vier 6-bit-Blöcke
aufgeteilt. Jeder dieser 6-bit-Blöcke bildet eine Zahl zwischen 0 und 63. Diese Zahlen werden
an Hand der nachfolgenden Umsetzungstabelle in “druckbare ASCII-Zeichen” umgewandelt
und ausgegeben. Nach jeweils 76 ausgegebenen Zeichen wird spätestens ein Zeilenumbruch
eingefügt, welcher jedoch ansonsten für die Kodierung nicht von Belang ist.
Falls die Gesamtanzahl der Eingabebytes nicht durch drei teilbar ist, wird der zu kodierende Text am Ende mit Füllbytes aufgefüllt. Um dem Dekodierer mitzuteilen, wie viele Füllbytes
angefügt wurden, werden die 6-Bit-Blöcke, die vollständig aus Füllbytes entstanden sind, mit
’=’ kodiert. Somit können am Ende einer Base64-kodierten Datei 0, 1 oder 2 ’=’-Zeichen
auftreten.
Die angesprochene Transitionstabelle ist eine alphabetisch bzw numerisch aufsteigende Anordnung zuerst der Großbuchstaben, dann der Kleinbuchstaben, schließlich der Ziffern und am Ende
der beiden Zeichen ’+’ und ’/’ in dieser Reihenfolge.
2 OpenSSL
Optionen für openssl ciphername oder openssl enc -ciphername:
OPTIONS
-in filename
the input filename, standard input by default.
-out filename
the output filename, standard output by default.
10
-pass arg
the password source.
-salt
use a salt in the key derivation routines.
-nosalt
don’t use a salt in the key derivation routines.
-e
encrypt the input data: this is the default.
-d
decrypt the input data.
-a
base64 process the data. This means that if encryption is
taking place the data is base64 encoded after encryption.
If decryption is set then the input data is base64 decoded
before being decrypted.
-A
if the -a option is set then base64 process the data on
one line.
-k password
the password to derive the key from. This is for
compatibility with previous versions of OpenSSL. Superseded
by the -pass argument.
-kfile filename
read the password to derive the key from the first line
of filename. This is for compatibility with previous
versions of OpenSSL. Superseded by the -pass argument.
-S salt
the actual salt to use: this must be represented as a
string comprised only of hex digits.
-K key
the actual key to use: this must be represented as a string
comprised only of hex digits. If only the key is specified,
the IV must additionally specified using the -iv option.
11
When both a key and a password are specified, the key given
with the -K option will be used and the IV generated from
the password will be taken. It probably does not make much
sense to specify both key and password.
-iv IV
the actual IV to use: this must be represented as a string
comprised only of hex digits. When only the key is specified
using the -K option, the IV must explicitly be defined. When
a password is being specified using one of the other options,
the IV is generated from this password.
-p
print out the key and IV used.
-P
print out the key and IV used then immediately exit: don’t
do any encryption or decryption.
-bufsize number
set the buffer size for I/O
-nopad
disable standard block padding
-debug
3 Symmetrische Verschlüsselungsverfahren
3.1 Feistel-Chiffren
Feistel-Chiffre (auch als Feistelnetzwerk bezeichnet) ist eine Block-Chiffre. Ein Mitarbeiter
von IBM, Horst Feistel, gilt als der Erfinder dieser Chiffre. Er arbeitete mit anderen am sog.
Projekt Lucifer“, dessen Ziel es war, eine effiziente Verschlüsselungstechnologie zu entwi”
ckeln. Die Feistel-Chiffre war später dann die Grundlage für den DES-Algorithmus.
Viele moderne symmetrische Verschlüsselungsalgorithmen basieren auf Feistelnetzwerken. Dies rührt u.a. auch daher, dass die Struktur von sehr vielen Kryptografen analysiert und
für gut befunden wurde.
12
Wie es der Name Block-Chiffre“ schon nahe legt, wird der Klartext zuerst in einzelne
”
Blöcke zerlegt. Die Größe dieser Blöcke kann frei gewählt werden, üblich sind oftmals Vielfache von 64 Bit.
Jeder dieser Blöcke wird danach in zwei gleichgroße Hälften (L0 und R0 ) geteilt und in
mehreren Runden mit verschiedenen Schlüsseln verschlüsselt. Nach den Runden werden die
Hälften wieder zusammen gesetzt.
Innerhalb der i-ten Runde (i ist die Nummer der aktuellen Runde und reicht von 1 bis n)
wird folgende Formel angewendet:
Li = Ri−1
Ri = Li−1 ⊕ f (Ri−1 , Ki )
Dabei bildet f die sog. Runden- oder Transformationsfunktion und Ki ist der jeweilige Rundenschlüssel. Der verschlüsselte Text am Ende der Runden ist die Zusammenführung von (Ln , Rn ).
Feistelnetzwerke ermöglichen eine Entschlüsselung, ohne dass die Umkehrfunktion von f
benötigt wird. Will man einen Geheimtext dechiffrieren, wendet man die obige Formel leicht
modifiziert an:
Ri−1 = Li
Li−1 = Ri ⊕ f (Ri−1 , Ki )
13
(Quelle: http://en.wikipedia.org/wiki/Image:Feistel.png)
3.2 DES - Data Encryption Standard
DES ist eine 64 Bit Block-Chiffre mit einer festgelegten Schlüssellänge von 56 Bit. Die Funktionsweise entspricht einem 16-Runden Feistel-Netzwerk. DES ist der erste VerschlüsselungsAlgorithmus der weite Verbreitung fand und dessen Spezifikation öffentlich zugänglich ist. Er
wurde in den 70er Jahren entwickelt und ist im amerikanischen Standard FIPS 46-2 beschrieben.
14
3.2.1 Schlüsselauswahl
Zunächst steht nominal ein 64-Bit Schlüssel zur Verfügung. Von diesem ist jedoch je ein Bit pro
Byte als Paritätsbit deklariert, so dass 56 Bit effektives Schlüsselmaterial übrigbleiben. Diese 56
Bit werden in 2 mal 28 Bit aufgeteilt, die in jeder der 16 Runden um 1 oder 2 Bit rotiert werden,
insgesamt um 28 Bit, so dass am Ende wieder das Original vorliegt. Aus der Konkatenation der
beiden Hälften wird in jeder Runde ein 48-Bit Rundenschlüssel ausgewählt.
(Quelle: http://en.wikipedia.org/wiki/Image:DES-key-schedule.png)
15
3.2.2 Funktionsweise
Die so gewonnenen Rundenschlüssel ki werden für die Runden der Feistelchiffre genutzt: E(k1 , k2 , ..., k16 , m) =
c
E(k16 , k15 , ..., k1 , c) = m
D(k1 , k2 , ..., k16 , c) = E(k16 , k15 , ..., k1 , c) = m
Jeder 64 Bit Eingabe-Block wird in zwei 32 Bit Blöcke (L und R) aufgeteilt und weiterverarbeitet. L und R werden in jeder Runde durch eine festgelegte Permutation E auf 48 Bit ausgedehnt,
anschließend mit dem Rundenschlüssel verknüpft, mittels einer weiteren, rundenspezifischen,
Permutation S wieder auf 32 Bit komprimiert und dann schließlich noch einer weiteren festgelegten Permutation P unterzogen:
Li = Ri−1
Ri = Li−1 ⊕ f (Ri−1 , Ki ), wobei: f (Ri−1 , Ki ) = P(S (E(Ri−1 ) ⊕ Ki ))
rechts: Feistelstruktur (Quelle: http://en.wikipedia.org/wiki/Image:DES-main-network.png)
links: F Funktion (Quelle: http://en.wikipedia.org/wiki/Image:DES-f-function.png)
16
(Quelle: http://de.wikipedia.org/wiki/Bild:DES_resize.png)
3.2.3 Schwachstellen und Unsinnigkeiten
• Die Anfängliche Permutation der Klartexteingabe sollte Softwareimplementation erschweren. Per Hardware ist diese sehr einfach, universell verwendbare Rechner hatten in den
70er Jahren jedoch noch Probleme mit so etwas.
• Das Paritätsbit ist eine Schwachstelle, da es - soweit es gesetzt ist - ein Durchmustern des
Speichers nach dem Schlüssel erlaubt. Gesucht wird dann nach dem relativ ungewöhnlichen Auftreten von 8 nahe bei einander liegenden Byte, bei denen je das letzte Bit die
Parität angibt.
17
• Mit heutigen Rechnern ist es möglich einen 56-Bit Schlüssel mittels brute force zu knacken.
Die Länge des Schlüssels ist bei DES aber auf diesen Wert festgelegt.
• Es wird vermutet, dass die “magischen” S-Permutationen, über deren Qualität nichts bewiesen ist, eine Hintertür darstellen, da die NSA hierbei ihre Finger im Spiel hatte. Es
konnte jedoch nie bewiesen werden.
3.2.4 spezielle Optionen bei openssl
• Option -nopad: Schaltet Auffüllung der letzten Bits zu Block von 64 Bits aus. Auch wenn
die Nachricht genau in 64 Bit Blöcken einteilbar ist, wird ein 64 Bit Padding Block angehängt.
Der Block besteht aus x mal der Zahl x. So lässt er sich beim Entschlüsseln wieder entfernen.
• Option -nosalt: Schaltet die Voranstellung des salt-Werts aus.
Der salt-Wert verlängert die Nachricht um insgesamt 16 Bytes: Salted__ gefolgt von 8
Bytes salt-Wert.
Aus Passwort und salt-Wert wird der Key für die eigentliche Verschlüsselung erzeugt. Damit wird verhindert, dass Schlüssel wegen Mehrfachverwendung von Passwörtern leichter zu brechen sind. Gleiche Passwörter beim Aufruf der Verschlüsselung mit OpenSSL
führen durch den zufälligen salt-Wert zu verschiedenen Keys bei der Verschlüsselung.
• Neben des gibt es auch des-ede und des-ede3. Diese bieten einen gewissen Schutz
gegen Bruteforce-Angriffe:
TDES (Triple DES), DES3, DES-EDE (Encrypt, Decrypt, Encrypt) mit effektiv 168 Bit
E3DES (k1 , k2 , k3 , m) = EDES (k3 , DDES (k2 , EDES (k1 , m)))
In OpenSSL arbeitet des-ede mit zwei Schlüsseln:
E(K1 ), D(K2 ), E(K1 )
Um in OpenSSL 3 Schlüssel angeben zu können, muss man des-ede3 verwenden. Verwendet man bei des-ede zweimal oder bei des-ede3 dreimal den selben Schlüssel,
erhält man eine einfache DES-Verschlüsselung. So kann man Abwärtskompatibilität erreichen.
• In OpenSSL können DES Verschlüsselungen mit folgenden Befehlen aufgerufen werden:
–
–
–
–
–
–
18
-des
-des-cbc
-des-cfb
-des-ecb
-des-ede
-des-ede-cbc
–
–
–
–
–
–
–
–
–
–
-des-ede-cfb
-des-ede-ofb
-des-ede3
-des-ede3-cbc
-des-ede3-cfb
-des-ede3-ofb
-des-ofb
-des3
-desx
-desx-cbc
OpenSSL des-ecb -salt für den Schlüsseleintrag aus Passphrase
passphrase = 123450 +0 S alt − Wert → K
 

. . .



 
 64
. . .
12345 → 
2 Möglichkeiten



. . . 

s
Damit man keine Tabelle generieren kann, die aus den schwachen Schlüssel besteht, denn für
12345 gibt es 264 Möglichkeiten aufgrund des salts:
(P, C12345 )
(P, C1234 )
..
.
P- (Klartext) bekannt
S- (Saltwert) bekannt
C- (Chiffretext) unbekannt
welcher Schlüssel wurde verwendet ?

1 




12 

→ K


123 



1234
s1
s2
s3
c1
c1
c1
c12
c12
c12
c123 c123 c123
c1234 c1234 c1234
Dazu kommt aber später noch mehr.
19
3.2.5 DES:ECB - Electronic Code Book
Die Eingabe wird in Blöcke aufgeteilt und jeder Block für sich verschlüsselt. Dieses Verfahren
ist potentiell unsicher, weil in der Abfolge der Blöcke eine Struktur enthalten ist, die der Algorithmus nicht verbirgt. Ein Fehler beim Ver- oder Entschlüsseln eines Blockes führt allerdings
auch nur zu einem einzigen verlorenen Block.
To do: Initialisierungsvektor?!
(Quelle: http://en.wikipedia.org/wiki/Image:Ecb_encryption.png)
(Quelle: http://en.wikipedia.org/wiki/Image:Ecb_decryption.png)
Bem:
Reicht für einen Block, dann wird auch kein Initialisierungsvektor benötigt.
20
Man kann für den Initialisierungsvektor auch einen vorher vereinbarten Wert (z.B. Unix Sekunden) wählen.
Die 64-bit Klartextblöcke werden nacheinander und getrennt voneinander kontextfrei verschlüsselt. Dies ist die einfachste Anwendungsmöglichkeit eines Block-Chiffre.
3.2.6 DES:CBC - Cipher Block Chaining
Vor der Verschlüsselung eines Klartextblockes wird der bereits verschlüsselte vorhergehende
Block hinzuaddiert. Auf den ersten Klartextblock, der ja keinen Vorgänger besitzt, wird statt
dessen ein Initialisierungsvektor, der geheim gehalten werden muss, addiert. Dadurch entsteht
eine Verkettung (engl. chain) der Blöcke. Trotz dieser Verkettung ist die CBC-Verschlüsselung
selbstkorrigierend“: Fehler/Manipulationen in einem Block wirken sich bei der Entschlüsse”
lung nur auf den fehlerhaften/manipulierten und den nächsten Block aus.
Man kann relativ einfach beliebige Blöcke des Geheimtextes einzeln entschlüsseln, da zusätzlich zum Schlüssel nur der vorhergehende (verschlüsselte) Block benötigt wird.
Fehler im c breiten sich nicht aus beim Entschlüsseln. Ein Initialisierungsvektor IV für ersten
Block wird benötigt.
• Klartext ⊕ Cipher und dann Encryption
• Vorteil: Muster im Klartext werden zerstört
• Nachteil: Fehler im Ciphertext eines Blocks verändern Bits an genau der Stelle im folgenden Block (aber nur in diesem, spätere Blöcke sind nicht betroffen), so kann gezielt eine
Stelle im Block angegriffen werden (siehe Skizze)
To do: Skizze zur Fehlerausbreitung erläutern
21
m1
IV
m∗2
m∗3
/⊕
⊕
⊕
⊕
D
D
D
DES DES DES DES
c1
c2
c3
E
...
c4
Vergleich DES:ECB und DES:CBC
Zum Vergleich bietet es sich, an ein Bild (Abbildung 1) mit DES im ECB- und im CBC-Modus
zu verschlüsseln: Deutlich zu erkennen ist, dass die Struktur im ECB-Modus (Abbildung 2)
erhalten bleibt, während sie bei CBC (Abbildung 3) vollkommen zerstört wird.
Abbildung 1: Bild im Klartext (24 Bit RGB mit 182 × 183 Pixeln)
Abbildung 2: Bild aus Abbildung 1 ECB-verschlüsselt
22
Abbildung 3: Bild aus Abbildung 1 CBC-verschlüsselt
3.2.7 DES:OFB - Output Feed Back
In diesem Modus werden die Klartextblöcke nicht direkt mit DES verschlüsselt, sondern DES
erzeugt einen pseudozufälligen Bitstrom, der dann ohne Übertrag (vgl. XOR) auf den Klartext
addiert wird. Dazu muss DES mit einem kontinuierlichen Eingabestrom gefüttert werden. Als
Eingabe von DES dient hier ein Schieberegister, dass zunächst mit einem Initialisierungsvektor
geladen wird. Anschließend wird immer ein Teil der Ausgabe von DES in dieses Register
hineingeschoben und so als Eingabe wiederverwendet (daher output feedback).
• Output der Encrpytion als Input für Encryption erzeugt Pseudozufallsstrom ⊕ Klartext
• Vorteil: Beliebige Blockgrößen möglich, wie Stromchiffre verwendbar
• Nachteil: Durchsatz verringert sich auf neue Blockgröße pro erzeugtem Block, kann aber
vorberechnet werden
• Vorteil: Ein Bit Fehler führt zu nur einem invertierten Bit nach der Entschlüsselung
• Nachteil: Keine Selbstsynchronisierung möglich, wenn Bits komplett verloren gehen
23
(Quelle: http://de.wikipedia.org/wiki/Bild:Ofb_encryption.png)
(Quelle: http://de.wikipedia.org/wiki/Bild:Ofb_decryption.png)
3.2.8 DES:CFB - Cipher Feed Back
Identisch mit OFB, aber statt die Ausgabe des DES wieder als Eingabe zu verwenden, wird
der Kryptotextstrom als Eingabe wiederverwendet.
• Cipher als Input für Encryption erzeugt Pseudozufallsstrom ⊕ Klartext
24
• Vorteil: Beliebige Blockgrößen möglich, wie Stromchiffre verwendbar
• Nachteil: Durchsatz verringert sich auf neue Blockgröße pro erzeugtem Block
(Quelle: http://de.wikipedia.org/wiki/Bild:Cfb_encryption.png)
(Quelle: http://de.wikipedia.org/wiki/Bild:Cfb_decryption.png)
3.2.9 CTR Mode, CCM
Dieser Modus spielt für DES keine Rolle. Ist auch nicht in OpenSSL implementiert. Aber diese Betriebsart ist für 128 Bit Verschlüsselungen ist zum Beispiel vom BSI als sicher eingestuft
worden. ’Die Betriebsart der Zukunft.’
Wird zum Beispiel für W-LAN Verschlüsselung verwendet.
25
Eingabe sind Klartext mit einen Zähler
ctr0
ctr1
ctr2
ctr3
→
→
→
→
Block
Block
Block
Block
..
.
→
→
→
→
⊕T
⊕p1
⊕p2
⊕p3
→
→
→
→
c0
c1
c2
c3
ctrn → Block → ⊕pn → cn
Standardisiert als ’SP 800-38c’.
(N, A, P) mit N Zufallswerten, A Assoziierte Daten, P Klartext produziert Blöcke B0 , B1 , . . . , Br
http://csrc.nist.gov/publications/nistpubs/800-38C/SP800-38C_updated-July20_
2007.pdf
To do: algorithmus überarbeiten / übersetzen
1. Apply the formatting function to (N, A, P) to produce the blocks B0 , B1 , . . . , Br .
2. Set Y0 = CIPHK (B0 ).
3. For i = 1 to r, do Yi = CIPHK (Bi ⊕ Yi−1 ).
4. Set T = MS BT len (Yr ).
5. Apply the counter generation function to generate the counter blocks Ctr0 , Ctr1 , . . . , Ctrm ,
where m = dPlen/128e .
6. For j = 0 to m, do S j = CIPHK (Ctr j ).
7. Set S = S 1 ||S 2 ||. . . ||S m .
8. Return C = P ⊕ MS BPlen (S ) || T ⊕ MS BT len(S 0) .
T stellt einen Prüfwert dar.
3.2.10 TEA-Algorithmus
To do: überarbeiten
26
Nicht in OpenSSL implementiert. Universitärer Algorithmus.
(Quelle: http://de.wikipedia.org/wiki/Bild:TEA_InfoBox_Diagram.png)
Man sieht die Feistel Idee, allerdings die grünen Quadrate sind Additionen modulo 64 Bit.
To do: erläutern, Pfeilspitzen
Es gibt ein Extended TEA, struktur recht ähnlich, aber beim Algorithmus an der Stelle...
Byte:
0i
...
...
28 − 1
|
...
...
28
b · k = (b · k mod (28 + 1)) mod 28 Es gibt auch eine Inverse:
b · K → c → c · k0 = b
geht nur bei 22 + 1, 24 + 1, 28 + 1, 216 + 1
27
3.2.11 DES-X
In OpenSSL: desx K, K1 , K2
EncK (m ⊕ K2 ) ⊕ K1 = DES − X(m)
c1 ⊕ c2 = EncK (m1 ⊕ K2 ) ⊕ EncK (m2 ⊕ K2 )
Ist unsymetrisch. Hat sich nicht so ganz durchgesetzt...
3.3 IDEA: International Data Encryption Algorithm
IDEA gilt als sehr sicher, ist schneller als DES bei Hardwareimplementation, tauchte zuerst als
PES auf. Unterschied PES und IPES ist die untere XOR-Vertauschung (siehe Wikipedia Skizze), die es im PES nicht gab. War nur zur privaten Nutzung frei, ansonsten patentiert, weshalb
er nicht so verbreitet war. IDEA verschlüsselt 64-Bit Eingabe-Blöcke in 64-Bit Ausgabe-Blöcke
und verwendet dabei einen 128-Bit Schlüssel. Der Algorithmus basiert im wesentlichen auf 8
identischen Runden, die den Runden einer Feistel-Chiffre ähnlich sind und einer abschließenden
Transformation der Ausgabe. In jeder Runde werden 6 16-Bit Subschlüssel, in der AusgabenTransformation weitere 4 davon verwendet. Sämtliche Subschlüssel werden aus dem Originalschlüssel berechnet. Die 64 Bit Eingabe jeder Runde werden dabei als 4 16-Bit-Blöcke verarbeitet. Der Algorithmus benutzt verschiedene algebraische Operationen:
• Polynomaddition mod 2: XOR (blau-verbraucht wenig Strom)
• Addition mod 216 : ADD (grün-verbraucht wenig Strom, etwas Zeit - Überlauf wird
ignoriert)
• Multiplikation mod |{z}
216 +1: MULT (rot-viel Strom)
prim
Der IDEA-Algorithmus (International Data Encryption Algorithm) wurde 1990 als ein Gemeinschaftsprojekt zwischen der ETH Zürich von James L. Massey und Xueija Lai, und der
Ascom Systec AG entwickelt. IDEA ist ein symmetrischer Algorithmus und gehört zu den
Blockchiffren. Der Algorithmus benutzt einen 128-Bit langen Schlüssel (DES nur 64 Bit, davon sind 8 Bits für den Paritäts-Check vorgesehen, so dass die eigentliche Schlüssellänge nur
56 Bits beträgt).
Bei der Verschlüsselung wird der Klartext in 64 Bit große Blöcke unterteilt und der
Schlüssel in Teilstücke zu je 16 Bit zerlegt. Die Verschlüsselung geschieht durch Kombina-
28
tion der logischen Operation XOR, der Addition modulo 216 und der Multiplikation modulo
216 +1. Die Kombination dieser drei Operationen aus unterschiedlichen algebraischen Gruppen
soll ein hohes Maß an Sicherheit gewährleisten.
Das Verfahren ist dazu optimiert, Angriffen durch differentielle Kryptoanalyse zu widerstehen.
Es gibt bei IDEA leider eine ganze Reihe von schwachen Schlüsseln, die sich in zwei
Klassen einteilen lassen. Die erste Klasse umfasst 232 schwache Schlüssel. Sie sind insofern
schwach, als man sie mit gewähltem Klartext nachweisen kann. Danach ist ein Brute Force
Angriff selbst für Privatpersonen mit älteren PCs machbar. Die zweite Klasse umfasst sogar
265 schwache Schlüssel. Bei diesen Schlüsseln kann man mit nur 20 gewählten Klartexten
72 Bit des Schlüssels ermitteln. Die restlichen 56 Bit muss man mit Brute Force ermitteln.
Allerdings liegt die Wahrscheinlichkeit dafür einen schwachen Schlüssel zu erwischen bei eins
zu 263 oder eins zu 9 Trillionen.
Weil die Ascom Systec AG an der Entwicklung des Algorithmus beteiligt war, hält sie
die Patente für IDEA. In Europa verfällt der Patentschutz am 16.05.2011. In den USA wird
der Algorithmus bereits ein Jahr früher kostenlos nutzbar sein. Da das Patent in der Schweiz
erteilt wurde, greift das Patent auch in Deutschland, unabhängig davon, dass in Deutschland
Softwarepatente nicht legal sind.
Der Algorithmus beruht wesentlich darauf, dass 216 + 1 eine Primzahl ist. Deshalb lässt sich
IDEA nicht auf andere Blockläengen adaptieren.
3.3.1 Schlüsselauswahl
Aus den 128 Bit des ursprünglichen Schlüssels werden in insgesamt 52 16-Bit Teilschlüssel erzeugt. Dabei werden aus dem aktuellen Schlüsselwert (initial der ursprüngliche 128-Bit Schlüssel)
8 der Teilschlüssel durch aufteilen gewonnen. Dann wird der aktuelle Schlüssel subsequent um
25 Bit nach links rotiert und so je ein neuer aktueller Schlüssel erzeugt, der wieder zu Teilschlüsseln aufgeteilt wird - solange bis alle Teilschlüssel belegt sind. Es werden 6 · 16-Bit in
einer Runde verbraucht, in 8 Runden also 48 Teilschlüssel. Hinzu kommen 4 Teilschlüssel die
nach der letzten Runde für weitere Operation verwendet werden. Insgesamt werden also 52
Teilschlüssel mit je 16-Bit aus 128-Bit Rohschlüssel erzeugt und auch verbraucht. → 832-Bit
Schlüsselmaterial
3.3.2 Funktionsweise
In jeder Runde r finden folgende Transformationen statt:
1. X1 = X1 MULT K1r , X4 = X4 MULT K4r , X2 = X2 ADD K2r , X3 = X3 ADD K3r
2. t0 = K5r MULT (X1 XOR X3 ), t1 = K6r MULT (t0 ADD (X2 XOR X4 )), t2 = t0 ADD t1
29
3. X1 = X1 XOR t1 , X4 = X4 XOR t2 , a = X2 XOR t2 , X2 = X3 XOR t1 , X3 = a
Dabei sind X1 bis Xi die 16-Bit Blöcke die aus der 64 Bit Eingabe gewonnen wurden, Kir ist der
Teilschlüssel mit der Nummer r · 6 + i. Die abschließende Transformation ergibt sich wie folgt:
Y1 = X1 MULT K19 , Y4 = X4 MULT K49 , Y2 = X3 ADD K29 , Y3 = X2 ADD K39
Dabei sind die Yi 4 16-Bit Wörter, die die Ausgabe darstellen.
(Quelle: http://de.wikipedia.org/wiki/Bild:International_Data_Encryption_Algorithm_InfoBox_Diagram.png)
• In OpenSSL können IDEA Verschlüsselungen mit folgenden Befehlen aufgerufen werden:
–
–
–
–
–
-idea
-idea-cbc
-idea-cfb
-idea-ecb
-idea-ofb
3.3.3 Pseudocode-multiplikation
To do: als Pseudocode machen?
30
if(a==0){return ((216 +1)-b) mod 216 }
if(a==0){return ((216 + 1)-a) mod 216 }
if(a · b) mod 216 > (a · b) div 216 { return (a · b) mod 216 − (a · b) div 216 }
if(a · b) mod 216 ≤ (a · b) div 216 { return (216 + 1) + (a · b) mod 216 − (a · b) div 216 }
wenn a==0 ⇒ a = 216 ≡ −1 mod 216
3.3.4 Schwachstellen
Bei schlechter implementation können die XOR-Berechnungen am Stromverbrauch erkannt
werden. Es können Rückschlüsse auf bestimmte Werte (insbesondere Null) gemacht werden.
Nach 218 Testrechnungen kann der Klartext bestimmt werden.
Solche Angriffe nennt man Seiten Kanal Atacken, in diesem Fall ist der Stromverbrauch der
Seitenkanal (Zeitverbrauch spielt beim Idea keine Rolle).
Bei guter Implementation gilt aber der Algorithmus als sicher.
To do: Skizze Stromverbrauch?
3.4 Blowfish
Blowfish ist eine sehr schnelle 64-Bit, 16-Runden Block-Chiffre, die 1993 von Bruce Schneier
erfunden wurde. Die Länge der Schlüssel ist variabel zwischen 32 und 448 Bit. Als Teilschlüssel
werden aus dem Ausgangsschlüssel eine P-Box mit 18 mal 32 Bit und 4 S-Boxen mit 256 mal
32 Bit generiert: (P1 , ..., P18 ), (S 1 , ..., S 4 )
Blowfisch Algorithmus von Bruc Schreier ist völlig Patentfrei, dies hat sehr zu seiner Verbreitung beigetragen.
31
F
14 weitere Runden
F
(Quelle: http://de.wikipedia.org/wiki/Bild:Blowfish_structure_(de).svg)
P1 , . . . , P18 die XOR auf den Klartext kommen.
Schlüssel:
-P1 , . . . , P1 8 und
-S-Boxen
32
(Quelle: http://en.wikipedia.org/wiki/Image:BlowfishFFunction.svg)
S ist 256 32 Bit Werte
⇒ 4 · 256 · 32 Werte ⇒ kann man sich nicht merken, also wird P1 , . . . , P1 8, S 1 , . . . , S 4 werden
als Hexadezimalwerte von π gewählt.
(K)n ⊕ (P1 , . . . , P1 8)
Der so initialisierte Algorithmus wird auf den Klartext 0, . . . , 0 angewendet. Das Ergebnis ersetzt
| {z }
64
(P1 , P2 ).
. . . Der so initialisierte Algorithmus wird auf den Klartext 0, . . . , 0 angewendet. Das Ergebnis
| {z }
64
ersetzt (Pi , Pi+1 ). . . . Der so initialisierte Algorithmus wird auf den Klartext 0, . . . , 0 angewendet.
| {z }
Das Ergebnis ersetzt (S 1 , S 2 ). . . .
64
Auf kosten eines sehr aufwendigen Schlüsselmanagment wird ein schneller Algorithmus erreicht. Für Prozessoren mit wenig Speicher unpraktisch.
3.4.1 Initialisierung
Teilschlüsselmanagement: Sehr viele Teilschlüssel werden aus wenig Schlüsselmaterial generiert.
1. P und S werden mit einer Hexadezimal-Expansion von Pi initialisiert.
2. Der Schlüssel, als Sequenz von 32-Bit-Werten wird mittels XOR auf die P-Box addiert,
wobei er eventuell “wiederholt” wird, um die ganze Länge der Box abzudecken: P1 ⊕ K1 ,
P2 ⊕ K2 , ..., P18 ⊕ K18
3. Sowohl die P-Box als auch die S-Boxen werden verschlüsselt:
33
• Verschlüssle mit Blowfish den Nullstring → 64-Bit Ausgabe = 2 * 32-Bit = neue
P1 , P2
• Verschlüssle mit Blowfish (Pi , Pi+1 ), die Ausgabe verwende als (Pi+2 , Pi+3 ). Wiederhole diesen Schritt für i von 1 bis zum Ende der P-Box.
• Anschließend: S 1,0 , S 1,1 → S 1,2 , S 1,3 , .... Im gleichen Verfahren wie bei der P-Box
werden die S-Boxen verschlüsselt.
Insgesamt ist so ein langer Vorlauf nötig bevor die eigentliche Verschlüsselung der Daten beginnt.
3.4.2 Verschlüsselung
In jeder Runde r (insgesamt 16 Runden) wird folgendes Verfahren angewendet:
1. Der 64-Bit Eingabeblock wird in zwei 32-Bit-Hälften L und R zerlegt.
2. L = L ⊕ Pr , R = R ⊕ f (L).
f (L) ist dabei folgendermaßen charakterisiert: Zunächst wird das Argument L als Konkatenation von 4 8-Bit Vektoren a, b, c und d aufgefasst, die als natürliche Zahlen zwischen
0 und 255 verwendet werden.
f (a, b, c, d) := ((S 1,a + S 2,b
mod 232 ⊕ S 3,c ) + S 4,d
mod 232
3. L und R werden vertauscht, konkateniert und als Eingabe für die nächste Runde verwendet.
Nach der letzten Runde wird noch R = R ⊕ P17 und L = L ⊕ P18 durchgeführt.
Blowfish ist ein sehr schneller und nicht patentierter Algorithmus, der besonders auf 32Bit-Prozessoren eine exzellente Performance bietet. Ein weiterer Vorteil ist seine variable
Schlüssellänge von 32 bis zu 448 Bit. Die Blockgröße beträgt 64 Bit.
• In OpenSSL können Blowfish Verschlüsselungen mit folgenden Befehlen aufgerufen werden:
–
–
–
–
–
–
34
-bf
-bf-cbc
-bf-cfb
-bf-ecb
-bf-ofb
-blowfish
3.5 AES: Advanced Encryption Standard
3.5.1 Wiederholung-Byteoperation
Wir hatten folgende Byteoperationen kennengelernt:
• Multiplikation mod 256 bzw. mod 257 ohne 0
• Addition mod 256
• XOR-Addition (⊕)
Die Operationen werden in der dementsprechenden Basisdarstellung modulo 256 durchgeführt.
3.5.2 Überblick
AES wurde im Standard FIPS 197 festgeschrieben.
AES ist, eine Block-Chiffre, dessen Blocklänge und Schlüssellänge unabhängig voneinander
die Werte 128, 192 oder 256 Bit erhalten kann. Jeder Block wird zunächst in eine zweidimensionale Tabelle mit vier Zeilen geschrieben, dessen Zellen ein Byte groß sind. Die Anzahl der
Spalten variiert somit je nach Blockgröße von 4 (128 Bit) bis 8 (256 Bit). Zum Beispiel für 16
Byte werden die Bytes wie folgt eingetragen:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Jeder Block wird nun nacheinander bestimmten Transformationen unterzogen. Aber anstatt
jeden Block einmal mit dem Schlüssel zu verschlüsseln, wendet AES verschiedene Teile des
Schlüssels nacheinander auf den Klartext-Block an. Die Anzahl dieser Runden (r) variiert
und ist von Schlüssellänge (k) und Blockgröße (b) abhängig: Je nach Blocklänge b und
Schlüssellänge k wird die Anzahl der Runden bestimmt (10, 12 oder 14)
r
k=128
k=192
k=256
b=128
10
12
14
b=192
12
12
14
b=256
14
14
14
S-Boxen:
Eine Substitutionsbox (S-Box) dient als Basis für eine monoalphabetische Verschlüsselung.
35
Sie ist meist als Array implementiert und gibt an, welches Byte wie getauscht wird. Die
S-Box in AES basiert auf einem mathematischen Zusammenhang und ist somit fest im
Algorithmus implementiert. Doch dies ist kein Schwachpunkt, da die S-Box lediglich zur Vermischung der Bytes in Kombination mit weiteren Operationen und dem Schlüssel genutzt wird.
Ablauf:
• Schlüsselexpansion (nach Fips-197 S.23 Kapitel 5.2)
Der Schlüssel ’key’ wird auf den Anfang des expandierten Schlüssels ’w’ übernommen
(i < Nk). Danach berechnet sich w[i] wie folgt:



w[i − 1]
i mod Nk , 0




w[i] = 
(1)
S ubWord(RotWord(w[i − 1])) ⊕ Rcon i mod Nk = 0




S ubWord(w[i − 1])
Nk > 6i (mod N)k = 4
w[i] = w[i] ⊕ w[i − Nk]
Der zugehörige Quelltext (Fips-197 entnommen):
KeyExpansion(byte key[4*Nk], word w[Nb*(Nr+1)], Nk)
begin
word temp
i = 0
while (i < Nk)
w[i] = word(key[4*i], key[4*i+1], key[4*i+2], key[4*i+3])
i = i+1
end while
i = Nk
while (i < Nb * (Nr+1)]
temp = w[i-1]
if (i mod Nk = 0)
temp = SubWord(RotWord(temp)) xor Rcon[i/Nk]
else if (Nk > 6 and i mod Nk = 4)
temp = SubWord(temp)
end if
w[i] = w[i-Nk] xor temp
i = i + 1
end while
end
36
(2)
Für Beispiele siehe Fips-197 Appendix A.1 ...
• Vorrunde
– KeyAddition (XOR-des Rundenschlüssels)
• Verschlüsselungsrunden
– Substitution - Jedes Byte b wird ersetzt durch b0 = b1 wie bei Polynommultiplikation. Weiter wird jedes Byte als ein 8-dimensionaler Vektor aufgefasst und folgende
Operation angewendet:

1

  1
b1  1
b  
 2  1
 ..  = 
 .  1
  0

b8
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
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 b1  c1 
    
1 b2  c2 
· + 
0  ...   ... 
    
0 b8  c8 

0

0
– ShiftRow - Erste Zeil wird nicht verschoben, die zweite Zeil um eins, die dritte
Zeile um zwei, die vierte um drei. (siehe Wikipedia)
 
b1 
b 
– MixColumn - Zu jeder Spalten  2  des Blocks wird folgende Polynommultiplikab3 
b4
tion durchgeführt
(b1 x3 + b2 x3 + b3 x + b4 ) · (03X 3 + 04X 2 + 01X + 02)
mod (X 4 + 1)
und die Koeffizienten in gleicher Weise wieder in die jeweilige Spalte eingetragen.
Wobei (X 4 + 1) das Inverse (0BX 3 + 0DX 2 + 09X + DE) hat.
– KeyAddition
• Schlussrunde
– Substitution
– ShiftRow
– KeyAddition
Für die Entschlüsselung gehe die oben angegebene Reihenfolge rückwärts durch. Beachte
dabei, dass ShiftRow und Subst vertauschbar sind. Bei ShiftRow wird in umgekehrter Weise
verschoben. Ebenso sind KeyAdd und MultColumn vertauschbar, wenn der Rundenschlüssel
modifiziert wird. (B(X) ∗ (S (X) ⊕ K(X)) = S (X) ∗ B(X) ⊕ B(X) ∗ K(X) also ist der modifiziert
Schlüssel B(X) ∗ K(X)). Die Entschlüsselung entspricht also der Verschlüsselung mit modifizierten Schlüsseln.
37
3.5.3 mathematische Grundlagen
Speziell der Schritt Mix-Column beinhaltet einige interessante mathematische Überlegungen. Er
soll zu einer möglichst effektiven Vermischung der 32 Bit in jeder Spalte führen, die die Suche
von dem unverschlüsselten Text ähnlichen Mustern im verschlüsselten Text erschwert. Dabei
werden arithmetische Operationen aus zwei algebraischen Gruppen angewandt:
1. Die Gruppe der Bytes F28 : Jedes Byte b7 b6 ...b0 wird als ein Polynom b7 · X 7 + b6 · X 6 +
...b0 · X 0 angesehen. Diese Polynome können addiert und multipliziert werden. Damit
dabei der Werteraum des Byte nicht verlassen wird, finden diese Operationen modulo
m(X) = X 8 + X 4 + X 3 + X + 1 statt. m ist dabei irreduzibel, es gilt also ggT (b(X), m(X)) = 1
für jedes Byte b. Somit ist F 2 [X]/m(X) ein Körper und die Multiplikation ist abgeschlossen. Es gilt für jedes Paar von Bytes b, c eindeutig: b · c = d → d/c = b. Multiplikationen
können also eindeutig rückgängig gemacht werden, so dass eine Entschlüsselung möglich
ist.
Bei Zahlen die größer als m(X) sind werden also durch die modulo Operation die Koeffizienten von x4 , x3 , x1 , x0 verändert.
Beispiel in Magma:
Q := IntegerRing(2);
P<x> := PolynomialRing(Q);
f:=xˆ7+1;
g:=xˆ3+xˆ2+x+1;
f*g;
f*g mod(xˆ8 +xˆ4+xˆ3+x+1);
IsPrime(xˆ8 +xˆ4+xˆ3+x+1);
Ausgabe:
xˆ10 + xˆ9 + xˆ8 + xˆ7 + xˆ3 + xˆ2 + x + 1
xˆ7 + xˆ6 + xˆ3 + xˆ2 + x
true
4 : Die 4 Bytes einer Spalte w w w w werden wieder als Po2. Die Gruppe der Wörter F256
3 2 1 0
lynom aufgefasst: w3 · X 3 + w2 · X 2 + w1 · X + w0 . Diese können wieder multipliziert
und addiert werden, wobei die arithmetischen Operationen auf den jeweiligen Bytes in F28
4 werden modulo M(X) = X 4 + 1 ausgeführt. M(X) ist
stattfinden. Die Operationen in F256
zwar nicht irreduzibel, aber da der Algorithmus nur eine beschränkte Gruppe von Operanden verwendet, bleiben auch hier alle Operationen invertierbar.
4 ) nun jede Spalte mit c(X) = 3 · X 3 + X 2 + X + 2. Die so
Mix-Column multipliziert (in F256
beschriebene lineare Funktion erreicht beweisbar eine große Diffusion der Eingabe.
38
• In OpenSSL können AES Verschlüsselungen mit folgenden Befehlen aufgerufen werden:
–
–
–
–
–
–
–
–
–
–
–
–
–
–
–
-aes-128-cbc
-aes-128-cfb
-aes-128-ecb
-aes-128-ofb
-aes-192-cbc
-aes-192-cfb
-aes-192-ecb
-aes-192-ofb
-aes-256-cbc
-aes-256-cfb
-aes-256-ecb
-aes-256-ofb
-aes128
-aes192
-aes256
3.6 RC4: Ron’s Cipher 4
Geheimes Chiffreverfahren mit Strom-Chiffre von Ron Rivest, 1987 Entstehungsjahr, 1994 im
Netz aufgetaucht, 1999 tauchte im Internet ein Draft ARCFOUR (ARC4) auf, der die gleichen
Ergebnisse lieferte
Byte orientiert zwei Bytes m, k dann wird berechnet:
m⊕k =c
Der Algorithmus basiert auf S-Boxen (Permutationen)
——
Skizze Seite 2b ganz oben ???
PRG (Pseudo Random Generator)
——
weitere Skizze???
Initialisierung: K = L Bytes als Schlüssel s[i] = i (identische Permutation)
L = 1...255 für RC4 mit 40-Bit: L = 5, mit 64-Bit: L = 8, mit 128-Bit: L = 16
j = 0 für i = 0...255 → j = ( j + s[i] + K[ j mod L]) mod 256
Problem: K-Masterkey → salted key, Initialwert (frei, bekannt), HashInitial (K) = Kaktuell → RC4
39
Anfangsstücke von PRG RC4 sind nicht richtig zufällig“, verraten viel über Kaktuell
”
Regel für RC4: Die ersten 256-Byte wegschmeißen
RC4 (Ron’s Cipher 4) ist ein für Software optimierter Stromchiffrierer, welcher zur Verschlüsselung von Daten eingesetzt wird. Er wurde 1987 von Ronald L. Rivest für RSA Data
Security Inc. (heute RSA Security) entwickelt.
Der Algorithmus war sieben Jahre lang geheim (“security by obscurity”), bis 1994 der
Quellcode anonym veröffentlicht wurde.
RC4 hat, im Gegensatz zu DES, eine variable Schlüssellänge. Die Schlüssellänge kann bis
zu 2048 Bit betragen. RC4 verschlüsselt immer ein Byte auf einmal.
Er besteht aus einer so genannten S-Box, die sich während der Verschlüsselung fortlaufend ändert. Diese wird durch ein Passwort initialisiert, das für jede Verschlüsselung einmalig
sein muss. Jedes Klartextzeichen wird XOR mit einem bestimmten, vom Paßwort abhängigen, Zeichen aus der S-BOX verknüpft. Theoretisch sind somit ca. 2 hoch 1700 verschiedene
Zustände möglich.
Der Algorithmus ist sehr kompakt und fünf- bis zehnmal schneller als der weitverbreitete DES. Deshalb findet der RC4 Algorithmus in einigen Echtzeit-Systemen Anwendung, wie
beispielsweise Mobilfunk (Cellular Digital Packet Data), SSH (Secure Shell), WLAN (Wireless LAN) oder den Dateiverschlüsselungs-Programmen SecurePC und Cryptext. Die Verarbeitungsgeschwindigkeit des DES ist jedoch selbst in kleinsten Mikrokontrollern meist ausreichend. Der Schlüssel beim DES und anderen Blockchiffren wie dem AES (CBC-Mode) kann
im Gegensatz zum RC4 auch mehrfach verwendet werden. Vergleichbare Stromchiffren wie
SEAL sind vergleichbar schnell und gelten als sicher.
übersetzt aus dem Englischen, nach http://en.wikipedia.org/wiki/RC4
RC4 (oder ARCFOUR) ist die am weitesten verbreitete Stromchiffre und wird in vielen bekannten Protokollen, beispielsweise SSL oder WEP, verwendet. Trotzdem entspricht RC4 nicht
mehr dem heutigen Sicherheitsstandard und manche Verwendungsweisen von RC4 führen zu
sehr unsicheren Kryptosystemen (z.B. WEP). Daher wird es nicht für die Verwendung in neuen
Systemen empfohlen. Allerdings gibt es auch RC4-basierte Systeme die sicher genug für den
praktischen Gebrauch sind.
3.6.1 Geschichte
RC4 wurde 1987 von Ron Rivest von RSA Security erfunden. Offiziell bedeutet die Abkürzung
40
“Rivest Cipher 4”, alternativ wird sie aber als “Ron’s Code” verstanden (s. auch die anderen
RC?-Algorithmen). Zunächst war RC4 ein Betriebsgeheimnis, jedoch wurde im September
1994 eine Beschreibung anonym auf der “Cypherpunks” Mailingiste gepostet. Es wurde bald
in die sci.crypt newsgroup weitergepostet und von dort auf viele Internet-Seiten verbreitet.
Nachdem der Algorithmus nun bekannt ist, ist er kein Betriebsgeheimnis mehr. Der Name
“RC4” unterliegt jedoch weiterhin dem Markenschutz. Zur Zeit sieht es so aus, als seien “inoffizielle” Implementationen zwar legal, können aber nicht den Namen “RC4” verwenden. Um
dieses Problem zu umgehen wird RC4 oft als “ARCFOUR” bezeichnet. RC4 wird inzwischen
in einigen weit verbreiteten Verschlüsselungsprotokollen und Standards, unter anderem WEP
und WPA für WLAN Karten und SSL, verwendet.
3.6.2 Beschreibung
RC4 generiert einen pseudo-zufälligen Bitstrom (einen “Schlüsselstrom”), der bei der Verschlüsselung mit dem Klartext mittels XOR verknüpft wird. Die Entschlüsselung funktioniert
genauso. Um den Schlüsselstrom zu generieren benutzt die Chiffre einen internen Zustand, der
aus zwei Teilen besteht:
1. eine Permutation aller 256 möglichen Bytes (wird im Folgenden als S bezeichnet)
2. zwei 8-Bit Index-Zeiger (mit i und j bezeichnet)
Die Permutation wird mit einem Schlüssel von variabler Länge, üblicherweise zwischen 40
und 256 Bit, initialisiert, wobei der Schlüsselerzeugungs-Algorithmus verwendet wird. Anschließend wird der Bit Strom durch den Pseudo-Zufalls-Algorithmus generiert.
3.6.3 Der Pseudo-Zufalls-Algorithmus
In jeder Iteration wird der Zustand verändert und ein Byte des Schlüsselstroms ausgegeben.
Dabei wird i inkrementiert, der Wert von S an der Stelle i auf j addiert, S [i] und S [ j] vertauscht
und der Wert von S an der Stelle S [i]+S [ j] mod 256 ausgegeben. Jeder Wert von S wird dabei
mindestens einmal alle 256 Iterationen vertauscht. In Pseudocode lässt sich der Algorithmus
folgendermaßen darstellen:
i := 0
j := 0
41
while GeneratingOutput:
i := (i + 1) mod 256
j := (j + S[i]) mod 256
swap (S[i], S[j])
output (S[(S[i] + S[j]) mod 256])
(Wobei i öffentlich ist und j geheim ist)
j
i
0
1
2
S[i]+S[j]
i
j
253 254 255
S
S[i]
K
S[j]
S[i]+S[j]
(Quelle: http://de.wikipedia.org/wiki/Bild:RC4.svg)
3.6.4 Der Schlüsselerzeugungs-Algorithmus
Der Schlüsselerzeugungs-Algorithmus wird benutzt, um die Permutation in S zu initialisieren.
l wird als die Zahl der Bytes des Schlüssels definiert und kann zwischen 1 und 255 liegen,
üblicherweise liegt l zwischen 5 und 32, so dass eine Schlüssellänge von 40 bis 128 Bit zustande kommt. Zunächst wird S mit der Identitätspermutation initialisiert. Anschließend wird
S in 256 Iterationen mit einem Algorithmus, der dem Pseudo-Zufalls-Algorithmus ähnelt aber
zusätzlich die Schlüsselbits hineinmischt, weiterverarbeitet. Der folgende Pseudocode drückt
dies aus:
for i from 0 to 255
S[i] := i
j: = 0
for i from 0 to 255
42
j := (j + S[i] + key[i mod l]) mod 256
swap(S[i],S[j])
3.6.5 Implementation
Viele Stromchiffren basieren auf “linear feedback shift registers” und sind damit sehr effizient
in Hardware aber weniger effizient in Software implementierbar. RC4 hat dieses Manko nicht
und kommt zudem ausschließlich mit 8-Bit Operationen aus. Damit ist RC4 ideal für SoftwareImplementationen.
3.6.6 Sicherheit
RC4 verfehlt die üblichen Standards für sichere Chiffren an mehreren Stellen und wird somit
nicht zur Verwendung in neuen Anwendungen empfohlen. Der von RC4 generierte Schlüsselstrom tendiert dazu, bestimmte Sequenzen von Bytes häufiger zu enthalten als andere und
ist somit nicht wirklich zufällig. Der beste Angriff, der auf diesem Sachverhalt beruht, wurde von Fluhrer und McGrew entdeckt und kann aus einem Gigabyte verschlüsseltem Text
den Schlüsselstrom berechnen. Zudem verwendet RC4 keine “nonce”, einen für jeden Klartext neu generierten Zusatzschlüssel. Eine solche “nonce” wird im allgemeinen als zentrales
Sicherheitskriterium betrachtet, da so gewährleistet ist, dass eine zweimal nacheinander verschlüsselte Nachricht zwei verschiedene verschlüesselte Texte erzeugt. Natürlich kann eine
solche “nonce” im Nachhinein aufgesetzt werden indem als RC4-Schlüssel nicht der eigentliche Benutzerschlüssel sondern beispielsweise ein Hashwert des Schlüssels mit einer nonce verwendet wird. Die einfachere Methode, den Schlüssel nur mit der nonce zu konkatenieren, die
von einigen Anwendungen genutzt wird, führt aufgrund des schwachen SchlüsselerzeugungsAlgorithmus wieder zu neuen Problemen.
To do: anmerkungen zu k=1-Angriffsmöglichkeiten
43
3.6.7 Fluhrer, Mantin und Shamir Angriff
2001 wurde eine erstaunliche Entdeckung gemacht: Die statistische Verteilung der ersten paar
Bytes des Schlüsselstroms ist über alle RC4-Schlüssel stark nicht-zufällig und enthält Informationen über den Schlüssel selbst. Falls die nonce lediglich mit dem Schlüssel konkateniert
wurde (oder gar keine nonce verwendet wurde) kann der Schlüssel durch die Analyse einer
großen Zahl verschlüsselter Nachrichten herausgefunden werden. Mit Hilfe dieses Sachverhaltes und einiger damit zusammenhängender Effekte wurde dann die WEP-Verschlüsselung
(“wireless equivalent privacy”), die in 802.11 WLAN-Netzen verwendet wird, gebrochen. Dies
führte zu einer Suche nach einem Ersatz für WEP und letztlich zu den Bemühungen um 802.11i
sowie zu WPA.
Der geschilderte Angriff kann natürlich umgangen werden, wenn die ersten (ca. 256) Bytes des
Schlüsselstroms verworfen werden.
• In OpenSSL können RC4 Verschlüsselungen mit folgenden Befehlen aufgerufen werden:
– -rc4
– -rc4-40
3.7 RC5: Ron’s Cipher 5
Die zentrale Neuerung des RC5-Algorithmus sind datenabhängige Rotationen, bei denen ein
Zwischenergebnis um eine Zahl von Bytes rotiert wird, die weder fest vorgegeben noch vom
Schlüssel bestimmt, sondern aus einem Teil des Klartextes berechnet ist. Diese Operation wird
folgendermaßen notiert: a <<< b bedeutet, dass a um b Bits nach links rotiert wird. Ein weiterer
interessanter Aspekt ist die universelle Parametrisierbarkeit des Algorithmus: Sowohl die Länge
der Wörter w als auch die Zahl der Runden r und die Länge des Schlüssels b sind wählbar, so
dass der Algorithmus offen ist für zukünftige Bedürfnisse; die weitere Operation + wird nun als
Addition modulo 2w definiert. In openssl ist RC5 mit den Parameters w = 32, r = 12, b = 16 implementiert. Sämtliche Algorithmen gehen im folgenden von einer little-endian Byte-Anordnung
aus. Der Algorithmus besteht aus einem Verschlüsselungs- und einem Schlüsselexpansions-Teil:
Gegeben ein auf t = 2(r + 1) Wörter expandierter Schlüssel S und ein aus zwei Wörtern A und
B bestehender Eingabeblock, gibt folgender Pseudocode den Verschlüsselungs-Algorithmus an:
44
A = A + S[0]
b = B + S[1]
for i = 1 to r do:
A = ((A XOR B) <<< B) + S[2i]
B = ((B XOR A) <<< A) + S[2i + 1]
Die Entschlüsselung läuft dementsprechend folgendermaßen ab:
for i
B
A
A = A
B = B
=
=
=
-
r downto 1 do:
((B - S[2i + 1]) >>> A) XOR A
((A - S[2i]) >>> B) XOR B
S[0]
S[1]
3.7.2 Schlüsselexpansion
Zunächst wird S mit einer Kombination aus e und ϕ (dem goldenen Schnitt) initialisiert und der
Schlüssel in ein Array L kopiert, das wortweise indiziert wird. Anschließend wird mit folgendem
Algorithmus der Schlüssel in S hinein gemischt:
i = j = 0
A = B = 0
do 3 * max(t, 8b/w) times:
A = S[i] = (S[i] + A + B) <<< 3
B = L[j] = (L[j] + A + B) <<< (A + B)
i = (i+1) mod t
j = (j+1) mod (8b/w)
3.8 GOST 28147-89: Gosudarstvennyi Standard Soyuza SSR, nicht in
OpenSSL
GOST ist das russische Normungsinstitut, vergleichbar mit DIN oder ANSI.
(siehe auch: http://en.wikipedia.org/wiki/GOST_(block_cipher))
Gost-Chiffre ist eine relativ simple Feistel-Chiffre auf 64 Bit mit 32 Runden, 256 Bit Schlüssellänge
und 8 S-Boxen von zusammen 512 Bit, die - da sie geheim gehalten werden können - als
Schlüsselerweiterung gelten können. Die Rundenfunktion besteht aus der Addition eines 32Bit-Substrings des Schlüssels, der Anwendung der S-Boxen (parallel, da jede S-Box 4 Bit als
Ein- und Ausgabe hat) und einer 11-Bit-Rotation. Die Sicherheit des Algorithmus beruht auf
45
der Verwendung sehr langer Schlüssel, geheimer S-Boxen und der gegenüber DES verdoppelten
Rundenzahl. In jeder einzelnen Runde wird jedoch ein geringerer Durchmischungseffekt erreicht
als bei DES-Runden.
Geheimer Algorithmus, S-Boxen auch geheim
(Quelle: http://en.wikipedia.org/wiki/Image:GOSTDiagram.png)
46
Feistel Chiffre
Addition, Substitution, Rotation
Die S-Boxen sind Gruppenschlüssel, die extra zugewiesen werden.
16 4 Bit Werte werden Permutiert. 32 Runden.
Schlüsselmaterial 32 die 256 Bit werden jeweils in 8 32 Bit Unterschlüssel eingeteilt, wobei die
Schlüssel wie folgt verwendet werden:
1234567123456712345677654321
(Dann einmal S-Box, einmal rotieren und dann Feistelschritt)
Die Sicherheit steckt in den 32 Runden. Der Algorithmus wurde bisher nicht geknackt.
3.9 Fazit:Wie könnte bei einen Symmetrischen Algorithmus die Sicherheit
erhöhen??
(Das wäre z.B. für eine Interessante Frage für eine Klausur)
• komplexes Schlüsselmanagment
• viele Runden
• komplexe vermischung pro Runde (AES)
4 Asymmetrische Verschlüsselungsverfahren
4.1 Einführung
Alice,Bob, Chris, Dave, Eve...
Alice
kA
Enck1 (M) = C
−→
Bob
kA
M = Deck2
Verschlüsselungsverfahren kA , kB , Enc, Dec
Aus kA kann kB nicht bestimmt werden, dann kann kA sogar öffentlich sein. Ziel ist es, dass je-
47
der verschlüsseln kann, aber nur einer kann (in realistischer Zeit) entschlüsseln. Solche Verfahren mit öffentlichen Schlüssel werden auch asymmetrisch genannt. Mit großen Aufwand kann
natürlich der Schlüssel immer noch bestimmt werden: Man wählt einen Text m0 Verschlüsselt
ihn (Enck (m0 ) = c0 ) und probiert dann solange alle k durch, bis man Deck (c0 ) = m0 erhält
Das kB kann aber immer bestimmt werden:
for k_B =00000... to FFFF...
M_0 C_0 sind gegeben
Dec_{k_B}(C_0) ?= M_0
Wichtig ist nur das dies nicht in ’vernünftiger’ Zeit gemacht werden kann.
To do: text sortieren
Klartext −→ E(K) Chiffretext
Klartext D(K 0 ) ←− Chiffretext
E(K, p) = c und zu jedem K∃K 0 mit D(K 0 , c) = p und K wird öffentlich gemacht
Die Berechnung von K 0 aus K ist schwer, Bruteforce ist nicht ausgeschlossen, die Bestimmung
von K aus K 0 ist leicht
leicht:
EnckA , DeckB , (kA , kB )−Erzeugung
schwer:
aus kA allein kB erzeugen
4.1.1 Beispiel
Bob möchte von Alice verschlüsselte Nachrichten lesen. Bob überlegt sich ein asymmetrisches
Verfahren, wählt K 0 , berechnet K und veröffentlicht K.
Alice nimmt K, berechnet E(K, p) = c und sendet c an Bob.
Bob berechnet aus c mit K 0 das ursprüngliche p.
4.2 Geschichte
Whitfield, Diffie New Directions in Cryptographie. Idee wurde auch schon mal von Ralf Merkel
veröffentlich, Britische Geheimdienst hatt vorher die Idee auch schon mal...
48
Asymmetrische Verfahren sind ein relativ neues Gebiet der Kryptografie. Eine wichtige Vorarbeit für die asymmetrischen Verfahren sind die Arbeiten von Whitfield Diffie, Martin Hellman
und Ralph Merkle zum geheimen Schlüsselaustausch Anfang der 1970er Jahre. Im Sommer
1975 veröffentlichten Diffie und Hellman eine Idee zur asymmetrischen Verschlüsselung, ohne jedoch ein genaues Verfahren zu kennen.
Anfang der 1970er Jahre wurden von Ellis, Cocks und Williamson ein dem späteren Verfahren von Diffie-Hellman ähnliches asymmetrisches Verfahren entwickelt, welches aber in
seiner wirtschaftlichen Bedeutung nicht erkannt und aus Geheimhaltungsgründen nicht (wissenschaftlich) publiziert und auch nicht zum Patent angemeldet wurde. Alle drei waren Mitarbeiter des englischen Government Communications Headquarters.
Der Durchbruch gelang Ronald L. Rivest, Adi Shamir und Leonard M. Adleman, die 1977
das RSA-Verfahren entwickelten. Es gilt bis heute als sicheres Verfahren und hat außerdem den
großen Vorteil, in beiden Richtungen eingesetzt werden zu können.
4.3 Einige Theoretische Grundlagen
4.3.1 Kleiner Fermat (oder kleiner Fermat’scher Satz)
Für beliebige Primzahlen p gilt:
n(p−1) = 1 mod p für alle n ∈ Z
To do: Wikipedia verlinken
4.3.2 Euklidischer Algorithmus
To do: ergänzen..., Erweiterter Euklidischer Algorithmus, fehlerhaft?!
Beschreibung durch Pseudocode:
Im Folgenden wird der moderne Euklidische Algorithmus sowohl in einer rekursiven, als
auch einer iterativen Variante beschrieben. Dabei sind a und b jeweils die beiden Zahlen deren
größter gemeinsamer Teiler berechnet werden soll.
Rekursive Variante:
49
EUCLID(a,b)
1 wenn b = 0
2
dann return a
3
sonst return EUCLID(b, a mod b)
Iterative Variante:
EUCLID(a,b)
1 solange b != 0
2
r = a mod b
3
a = b
4
b = r
5 return a
Funktionsweise:
In jedem Schritt des Algorithmus wird eine Division mit Rest ausgeführt. ri−1 = qi+1 ·
ri + ri+1
0 ≤ ri+1 < ri Die Division mit Rest hat die Eigenschaft, dass ggT(ri−1 , ri ) =
ggT(ri , ri+1 ) gilt.
Im letzten Schritt des Algorithmus rn−1 = qn+1 · rn + 0 ist rn+1 = 0 und es gilt deshalb
ggT(rn−1 , rn ) = ggT(rn , 0) = rn
Da im ersten Schritt ri−1 = a und ri = b war, ist ggT(a, b) = rn
(Quelle: http://de.wikipedia.org/wiki/Euklidischer_Algorithmus)
(Denn es gilt ggT(a, b) = ggT(b, r))
...
Man kann diese Rekursion in folgende Abfolge von Schritten für den erweiterten euklidischen Algorithmus fassen: Erhalte ”a” und ”b” als Eingabe.
Setze ”k=0”, r0 = a, r1 = b, s0 = 1 und s1 = 0.
Wiederhole:
Erhöhe ”k” um eins.
Bestimme den ganzzahligen Quotienten qk = rk−1 div rk .
Setze rk+1 = rk−1 − qk · rk und sk+1 = sk−1 − qk · sk .
bis rk+1 = 0 gilt.
Gib den Rest rk = ggT(a, b) und die Zahl sk mit ggT(a, b) ≡ sk · a (mod b) zurück.
Jeder Schritt enthält implizit auch einen Multiplikator tk = (rk − sk · a) div b, wobei diese
Division keinen Rest lässt. Die Folge (tk )k kann auch explizit bestimmt werden, es gelten t0 =
0, t1 = 1 und :tk−1 ≡ qk ·tk +tk+1 . Nach dem letzten Schritt ergibt sich nun ggT(a, b) = sk ·a+tk ·b
Der Übersicht halber werden beim händischen Rechnen auch noch die Hilfsfolgen (ak =
rk−1 )k und (bk = rk )k sowie (uk = sk−1 )k sowie (vk = tk−1 )k mitgeführt.
...
50
Zur Berechnung des Inversen modulo einer Restklasse benötigt man die tk aber nicht und kann
sie ignorieren.
...
Rekursive Variante
Für den erweiterten euklidischen Algorithmus existiert auch eine rekursive Variante, die
durch den folgenden Pseudocode gegeben ist:
a,b: zwei Zahlen für die der erweiterte euklidische Algorithmus durchgeführt wird
”extended euclid”(a,b)
1 ”’wenn”’ b = 0
2 ”’dann return”’ (a,1,0)
3 (d’,s’,t’) ← ”extended euclid”(b, a mod b)
4 (d,s,t) ← (d’,t’,s’ - floor(a/b)t’)
5 ”’return”’ (d,s,t)
..
(Quelle: http://de.wikipedia.org/wiki/Erweiterter_euklidischer_Algorithmus)
Wenn n mod m teilerfremd sind, dann existiert so ein Exponent f so dass
nf ≡ 1
mod m
ist.
Wenn m = m1 · m2 ein Produkt von zwei verschiedenen Primzahlen ist, dann ist für alle n die zu
m teilerfremd sind:
n(m1 −1)·(m2 −1) ≡ 1 mod m
Denn es ist nm1 −1 ≡ 1 mod m1 und nm2 −1 ≡ 1 mod m2 . Dann ist n(m1 −1)·(m2 −1) − 1 durch m1
und m2 teilbar. Denn nach dem Chinesischen Restsatz gilt n(m1 −1)·(m2 −1) ≡ 1 mod m1 · m2 und
wenn eine Zahl durch m1 · m2 teilbar ist, so auch durch m1 und m2 .
4.3.3 Beispiel
In Magma:
p:=17; q:=23;
m:=(p-1)*(q-1);
e:=19;
F:=IntegerRing(m);
51
d:=(F!e)ˆ(-1);
d:=IntegerRing()!d;
19*315 div 16;
19*315 -374 *16;
n:=p*q;
K:=IntegerRing(n);
N:=100;
C:=(K!N)ˆ(e); //Verschlüsseln
C;
Cˆd;
10019 ≡ 349 mod 349
349352 ≡ 100 mod 391
10019·315 = 100 mod 17
10019·315 = 100 mod 23
10019·315 ≡ 100374·16+1 mod 17 ≡ 100 · (10016 )374 mod 17
| {z }
=1
To do: Analog von Mathias kopieren
To do: Wiederholung einsortieren...
Wiederholung:
Nachricht n
ne ≡ c( mod m)
Chiffre c
cd ≡ (ne )d = nd·e = n1+k(p−1)(q−1) = n · (n(p−1)(q−1) )k ≡ n · 1k = n mod m
| {z }
=1
−→
−→
n d, m c e, m n
52
aus (e, m) kann man (d, m) nicht leicht bestimmen, weil man die Zerlegung m = p · q nicht kennt.
Wer p, q kennt, kann aus den einen den anderen Schlüssel berechnen. Wer d,e kennt kann p,q
bestimmen.
Verschlüsselung kann jeder ausführen: öffentlicher Schlüssel (e, m) Entschlüsselung bleibt dem
vorbehalten der das geheime d (oder auch p,q) kennt.
schnelles Potenzieren
Ist die Berechung von ne , ck ausreichend schnell?
m 1000 Bit p,q-150 Dezimalstellen
ne hat sehr sehr viele Dezimalstellen
Deshalb berechnet man erst modulo und potenziert dann mit e:
(n mod m)e (c mod m)d
Beispiele
n19 = |
n · n{z
· . . . · }n oder man rechnet:
19 Multiplikationen
n, n2 , n4 , n8 , n16 4 Quadrierungen
n16 · n2 · n = n1 9
so auch bei n1025 = n, n2 , . . . , n1024 , n · n1024 wo nur 11 Multiplikationen gebraucht werden.
Pseudocode:
n,e,x=1;
repeat {
if (e = 1 mod 2)x = x · n(0 mod m0 );
n = n2 (0 mod m0 );
e = ediv2;
} until e==1;
k = (n0 )0 · x0
x = k = ne
53
4.4 RSA: Rivest, Shamir, Adleman
Bei dem Versuch die Idee der Asymmetrischen Kryptografie zu wiederlegen wurde RSA entwickelt:
RSA beruht auf der Schwierigkeit n = p · q in seine Primfaktoren zu zerlegen. Verschlüsseln und
Entschlüsseln ist Potenzieren modulo n:
D ◦ E = id
p = (pe )d
mod n
p = pe·d
mod n
e·d =1
mod (p − 1) · (q − 1)
E(e, n) ist öffentlich und D(d, n) geheim. Die Bestimmung von e, d, n aus p, q ist leicht. Genauer:
Die Bestimmung von e aus (d, n) ist leicht, die Bestimmung von d aus (e, n) ist schwer, weil
Faktorisierung n = p · q (vermutlich) schwierig ist, ist Bestimmung von d aus (e, n) auch schwer.
Wer p und q aus n berechnen kann, kann auch d bestimmen (Euklid).
Wer e und d kennt kann p und q bestimmen. (dazu waren Erläuterungen in der Vorlesung)
4.4.1 Funktionsweise des RSA-Verfahrens
(nach www.cryptool.de/downloads/CrypToolScript 1 3 04 de.pdf)
Man kann die Einzelschritte zur Durchführung des RSA-Verfahren folgendermaßen beschreiben. Schritt 1 bis 3 sind die Schlüsselerzeugung, Schritt 4 ist die Verschlüsselung, 5 die Entschlüsselung:
1. Wähle zufällig 2 verschiedene Primzahlen p und q und berechne n = p · q. Der Wert n
wird als RSA-Modul bezeichnet.
2. Wähle zufällig e ∈ {2, ..., n − 1}, so dass gilt: e ist teilerfremd zu J(n) = (p − 1) · (q − 1).
Zum Beispiel kann man e so wählen, dass gilt: max(p, q) < e < J(n) − 1. Danach kann
man p und q “wegwerfen”.
3. Wähle d ∈ {1, ..., n − 1} mit e · d = 1 mod J(n), d.h. d ist die multiplikative Inverse zu e
modulo J(n). Danach kann man J(n) “wegwerfen”.
• (n, e) ist der öffentliche Schlüssel P.
• (n, d) ist der geheime Schlüssel S (es ist nur d geheim zu halten).
4. Verschlüsselung des Klartextes (bzw. seiner Blöcke) M ∈ 1, ..., n − 1:
C = E((n, e); M) := M e
54
mod n
5. Entschlüsselung des Chiffretextes (bzw. seiner Blöcke) C ∈ 1, ..., n − 1:
M = D((n, d); C) := C d
mod n
4.4.2 Beweis der Funktionsweise
(nach www.cryptool.de/downloads/CrypToolScript 1 3 04 de.pdf)
Für Schlüsselpaare (n, e) und (n, d), die die in den Schritten 1 bis 3 des RSA-Verfahrens festgelegten Eigenschaften besitzen, muss für alle M < n gelten: M ≡ (M e )d mod n wobei (M e )d =
M e·d . Das heißt, der oben angegebene Dechiffrieralgorithmus arbeitet korrekt. Wir zeigen das in
3 Schritten.
1. Im ersten Schritt zeigen wir: M e·d ≡ M mod p. Dies ergibt sich aus den Voraussetzungen
und dem Satz von Fermat. Da n = p · q und J(p · q) = (p − 1) · (q − 1) und da e und
d so gewählt sind, dass e · d ≡ 1 mod J(n), gibt es eine ganze Zahl k, so dass gilt:
e · d = 1 + k · (p − 1) · (q − 1)
M e·d ≡ M 1+k·J(n) ≡ M · M k·J(n) ≡ M · M k·(p−1)·(q−1)
≡ M · (M p−1 )k·(q−1)
mod p
mod p
(aufgrund des kleinen Fermat : M p−1 ≡ 1 mod p)
≡ M · (1)k·(q−1)
≡M
mod p
mod p
Die Voraussetzung für die Anwendung des kleinen Fermat war, dass M und p teilerfremd
sind. Da das im allgemeinen nicht gilt, müssen wir noch betrachten, was ist, wenn M und
p nicht teilerfremd sind: da p eine Primzahl ist, muss dann notwendigerweise p ein Teiler
von M sein. Das heißt aber:
M ≡ 0 mod p
Wenn p die Zahl M teilt, so teilt p erst recht M e·d . Also ist auch:
M e·d ≡ 0
mod p
Da p sowohl M als auch M e·d teilt, teilt es auch ihre Differenz: (M e·d − M) ≡ 0 mod p.
Und damit gilt auch in diesem Spezialfall unsere zu beweisende Behauptung.
2. Völlig analog beweist man: M e·d ≡ M mod q.
3. Nun führen wir die Behauptungen der ersten beiden Schritte zusammen für n = p · q,
um zu zeigen: M e·d ≡ M mod n für alle M < n. Nach den ersten beiden Schritten gilt
(M e·d − M) ≡ 0 mod p und (M e·d − M) ≡ 0 mod q, also teilen p und q jeweils dieselbe
Zahl z = (M e·d − M). Da p und q verschiedenen Primzahlen sind, muss dann auch ihr
Produkt diese Zahl z teilen. Also gilt:
(M e·d − M) ≡ 0
mod p · q
55
oder
M e·d ≡ M
mod p · q
oder
M e·d ≡ M
mod n
4.5 Schwächen von RSA
• Wenn N Nachrichten aus einer kleinen Menge gewählt werden, ist RSA unsicher:
for N 0 do (N 0 )e = C 1 if C 1 = C then N = N 0
• Wenn N und e zu klein sind ist RSA unsicher, dass heißt wenn N e als Zahl kleiner als n
√
ist so das nich modulo gekürzt wird, so kann man einfach e c
• Angriff mit frei gewählten Chiffretext, angenommen man hat Zugriff auf die Verschlüsselungsmaschine so dass man mit selber vorgebenen C 0 , N 0 berechnen kann (C 0 −→ N 0 )
Re = S mod n S d = R mod n C 0 = S · C
(C 0 )d = S d · C d = |{z}
R · N mod n
N’
N0
·
R−1
= N mod n
N1 −→ C1
N2 −→ C2
⇒ N1 · N2 −→ C1 · C2
• Jeder Benutzer braucht ein eigenes n, dass heißt man muss für jeden Benutzer die entsprechenden Primzahlen suchen, allerdings ist dies aufwendig.
• RSA ist extrem langsam im Vergleich zu symmetrischen Verfahren openssl speed rsa
bzw. speed aes-256
4.6 Fuktionen in OpenSSL
4.6.1 genrsa
genrsa erzeugt Schlüsselpaare für RSA.
Schlüssellänge num_bits frei wählbar, wobei es einen Bug bei kleinen Werten gibt (weniger als
60 Bit), so kurze Schlüssel aber auch nicht verwendet werden sollten.
Optionen:
usage: genrsa [args] [numbits]
-out file: output the key to file
-passout arg: output file pass phrase source
56
-f4: use F4 (0x10001) for the E value
-3: use 3 for the E value
-des: encrypt the generated key with DES in cbc mode
-des3: encrypt the generated key with DES in ede cbc mode (168 bit key)
-idea: encrypt the generated key with IDEA in cbc mode
-aes128, -aes192, -aes256: encrypt PEM output with cbc aes
-engine e: use engine e, possibly a hardware device.
-rand file;file;...: load the file (or the files in the
directory) into the random number generator
4.6.2 rsa
rsa gibt den public-key zu gegebenen private-key aus. Außerdem auch weitere Informationen
wie verwendeter Modulus. Mit rsa kann auch ein gegebener key neu verschlüsselt abgespeichert
werden.
rsa [options] <infile >outfile
where options are
-in arg: input file
-out arg: output file
-pubin: expect a public key in input file
-pubout: output a public key
-passin arg: input file pass phrase source
-passout arg: output file pass phrase source
-text: print the key in text
-noout: don’t print key out
-modulus: print the RSA key modulus
-check: verify key consistency
-des: encrypt PEM output with cbc des
-des3: encrypt PEM output with ede cbc des using 168 bit key
-idea: encrypt PEM output with cbc idea
-aes128, -aes192, -aes256: encrypt PEM output with cbc aes
-inform arg: input format - one of DER NET PEM
-outform arg: output format - one of DER NET PEM
57
-sgckey: Use IIS SGC key format
4.6.3 rsautl
Mit rsautl können Dateien ver- oder entschlüsselt und signiert oder verifiziert werden.
Usage: rsautl [options]
where options are
-in file: input file
-out file: output file
-inkey file: input key
-pubin: input is an RSA public
-certin: input is a certificate carrying an RSA public key
-sign: sign with private key
-verify: verify with public key
-encrypt: encrypt with public key
-decrypt: decrypt with private key
-hexdump: hex dump output
-pkcs: use PKCS#1 v1.5 padding (default)
-oaep: use PKCS#1 OAEP
-ssl: use SSL v2 padding
-raw: use no padding
-keyform arg: private key format - default PEM
-passin arg: pass phrase source
4.6.4 PKCS
später noch ausführlicher hier nur kurz die Verwendung bei RSA:
Padding beginnt mit 0002 endet mit 00 und dann kommt der Chiffretext.
58
4.6.5 OAEP - Optimal Asymmetric Encryption Padding
Normalerweise wird mit RSA nur ein Schlüssel für eine symmetrische Verschlüsselung verschlüsselt, da RSA, verglichen mit symmetrischen Algorithmen sehr langsam ist.
Bemerkung:
Vergleichen mit speed rsa und speed aes (siehe History 21.01.2009)
Ist die so festgelegte Länge des Klartextes erheblich kleiner als die des RSA-Schlüssels, so ist ein
Auffüllen der restlichen Bits nötig. Die implizite Methode (beim Betrachten des Klartextes als
Zahl), einfach 0en einzusetzen empfiehlt sich nicht, da die Zusatzinformation, die ein Angreifer
so über den Klartext bekommt, das Decodieren des geheimen Schlüssels vereinfacht.
Beim Padding soll diese Gefahr verringert werden. Per default wird bei openssl PKCS benutzt.
Allerdings ist die Verwendung von OAEP besser. Beim OAEP, ist im Gegensatz zum PKCS
die Länge des Klartextes nicht mehr sichtbar (man kann nur noch dass beginnende 00 Byte
erkennen), Choosen Plaintext Attacke ist nicht mehr möglich.
Dabei wird essenziell die zu verschlüsselnde Nachricht mit einem Hashwert eines Zufalls-Strings
per xor verknüpft und so randomisiert. Eine Modifikation des benutzten Hashwerts wird dann
mit der Nachricht konkateniert und steht beim Entschlüsseln wieder zur Verfügung.
1. Label hash, Label =
2. PS erzeugen (alles Nullen 128-1-h-h-1-—m—)
3. DB =
4. Seed wählen, Länge h (irgendwas seed = Hash(irgendwas))
5. DBmaske = MGF(seed, —DB—)
6. mDB = DB ⊕ GBmask
7. seedmaske = MGF(mDB, —seed—)
8. mseed = seed ⊕ seedmaske
9. EM =
10. RSA-Verschlüsselung C ≡ EMe mod n
MGF: Hash Eingabe x Länge l
tc = Hash(x k c)
—c— = 4 Byte
MGF(x, l) := t0 k t1 k t2 k t3 . . . ,
|MGF(. . . , l)| = l
59
Rückgängig:
1. Entschlüsseln
2. Zerlegen: 00, mseed, mDB
3. seedmaske = MGF(mDB, —mseed—)
4. seed = mseed ⊕ seedmaske
5. DBmaske = MGF(seed, —mDB—)
6. DB = mDB ⊕ DBmaske
7. Padding abtrennen
PKCS#1 v1.5
Die für den Modul verwendeten Primzahlen müssen die ersten beiden Bits gesetzt haben, das
garantiert nach Multiplikation der Primzahlen, dass das Produkt im oberen Byte das obere Bit
gesetzt hat und somit die feste voranstehende 0 überdeckt.
4.6.6 Wie erkennt man an Ciphertexten den Verschlüsselungsalgorithmus- DER /
ASN1
Standards, damit man (z.B. RSA) verschlüsselte Texte erkennt.
DER- distingushed Encoding Rules
ASN1- Abstract Syntax Notation
openssl asn1parse -genstr "INTEGER:4711" -out int.asn1 openssl asn1parse -in int.asn
Integer werden in ASN1 als ’|{z}
02 länge Daten’ kodiert. Integers brauchen 1 Byte mehr ’Daten’
T ag
damit Das Vorzeichen 00 enthalten ist. Integer ist immer mit Vorzeichen.
Tag für andere Typen:
Bool: 01
Int: 02
Octet String: 04
Bitstring: 03 ’länge’ ’ungenutzte bits am Ende’ ’Byte des Bitstring’ [evt. ungenutzte Bits]
Text: PRINTABLESTRING
60
utf8: UTF8String
Text mit @ Zeichen (emailadresse): IA5STRING
Datum/Zeit: UTC
mit Jahrhundert: GENTIME
nüscht (der leere Typ): NULL
Mengentypen: seq, set
Mann kann auch eigene Typen generierend "EXPLICIT:AF oder so.
4.6.7 Umgehen mit den Schlüsselkomponenten
Ein vollständiger RSA-Schlüssel besteht aus einem Modul (modulus) n = p · q, öffentlichem
Exponent e, privatem Exponent d, Primzahl 1 p, Primzahl 2 q (häufig p > q), Exponent 1 d p ,
Exponent 2 dq , Koeffizient qi und kann so ausgegeben und gespeichert werden.
Bei der Version für ’arme’ werden nur n, öffentlicher Exponent e und geheimer Exponent d
angegeben.
c ≡ me
m ≡ c
d
mod n
(3)
mod n
(4)
Vorteil der vollständigen Version: Geschwindigkeitserhöhung bei der Entschlüsselung in Schritt
(4).
d p ≡ d mod (p − 1)
dq ≡ d mod (q − 1)
qi · q ≡ 1 mod q
d = k · (p − 1) + d p
m ≡ cd mod (p · q) berechnen:
m1 ≡ cd p mod p 500 Operationen mit 21 langem Modul
m2 ≡ cdq mod q 500 Operationen mit 12 langem Modul
Insgesamt: 1000 Operationen mit 14 der Länge
a p−1 ≡ 1 mod p wenn (a, p) = 1/teilerfremd1
1
kleiner Fermatscher Satz
61
m1 ≡ cd mod p
m2 ≡ cd mod q
h ≡ (m1 −m2 )·qi mod p (darauf achten dass das −m2 mod p ausgerechnet wird, nicht mod q)
m = m2 + h · q
1. m < n
2. m ≡ cd mod p, da m2 + h · q ≡ m2 + (m1 − m2 ) · qi · q mod p ≡ m2 + m1 − m2 ≡ m1 , also
≡ cd mod p
m ≡ cd mod q, da m2 + h · q ≡ m2 mod q, also ≡ cd mod q
x ≡ y mod p und x ≡ y mod q, dann folgt x ≡ y mod p · q
Euklidischer Algorithmus: (p, q)-teilerfremd, dann p · u + q · v = 1 ... Chinesischer Restsatz
4.7 Miller-Rabin Test
Heute: openssl dhparam, und: was Verblüffendes so dass man es nur mit der Phantasie eines
Informatikers oder Mathematikers verstehen kann. (Literatur Menezes, Oorschot, Handbook of
Applied Cryptography)
Primzahlen: Feststellen ob eine Zahl eine Primzahl ist durch Testen von Divisionen . . . wird bei
großen Zahlen sehr lang.
p · q = n ausrechnen geht schnell. Umkehrung n =?·? ist möglicherweise schwer.
14
Über 22 + 1 weiss man dass es keine Primzahl ist2 , kennt aber keinen der Faktoren. Kriterium:
keine Primzahl“ lässt sich auf folgende Art manchmal feststellen:
”
Wenn (a, n) = 1 so ist an−1 ≡ 1 mod n
FermatTest: Wenn für (a, n) = 1
an−1 . 1 mod n so kann n keine Primzahl sein.
Primzahlen
Test
Wenn für eine Zahl a mit (a, n) = 1 der Fermat-Test nicht bestanden wird, nennt man a einen
Zeugen für Nichtprimalität.
2
Vierzehnte Fermatsche Zahl
62
Zeugen gibt es sehr viele, nicht realistisch alle zu befragen“. Ausserdem gibt es Zahlen die
”
keine Zeugen haben, aber keine Primzahl sind.
Aus diophantischen Gleichungen folgt: Es gibt ein Polynom mit ganzzahligen Koeffizienten f (n)
mit der Eigenschaft: Wenn f (n) > 0 ⇔ n ist Primzahl
Aber das Polynom hat 26 Koeffizienten. Für Mathematiker ist das Problem erledigt, da das Polynom existiert, für Informatiker ist es das nicht wirklich, da die Berechnung übermäßig komplex
ist.
Die Nicht-Primzahlen ohne Zeugen heissen Carmichael-Zahlen. Haben die Eigenschaft ∀p(p|n ⇒
p − 1|n − 1) ⇒ Carmichael.
Zum Beispiel 561 hat Teiler 3, 11, 17. Der Test liefert: 2|560, 10|560, 16|560
Erweitern: (n Primzahl) Wenn (a, n) = 1 und an−1 ≡ 1 mod n und 2|n − 1 (an−1 ≡ 1 mod n,
n−1
a 2 ≡ ?)
Wenn x2 ≡ 1 mod n, was ist x mod n.
n|x − 1
n|x2 − 1 = (x − 1)(x + 1) entweder n|x + 1 oder
FermatTest+ : Wenn für (a, n) = 1 an−1 . 1 mod n oder falls an−1 ≡ 1 mod n und a
n−1
und a 2 . −1, so kann n keine Primzahl sein.
... und 4|n − 1
∗, −1, 1
a
n−1
4
,a
n−1
2
,a
n−1
1
n−1
2
. +1
mod n. Diese Folge ist entweder 1, 1, 1 oder −1, 1, 1 oder
n−1
n−1
Wenn (a, n) = 1 und 2k |n − 1 (k maximal), dann ist die Folge a 2k , a 2k−1 , . . ., a
1, . . . , 1 oder ∗, −1, 1, . . . , 1 (∗ steht für beliebige Folge).
n−1
2
, an−1 entweder
Probieren: n = 81 n − 1 = 80 durch 2er-Potenzen teilen, kommt irgendwas mit 5 hinten raus.
Als Zeugen nehmen wir mal 2. Ausrechnen 25 , 210 , 220 , 240 , 280 und schauen ob diese Folge
modulo 81 einen der beiden Typen hat. 32 . 1 mod 81, . . .
n−1
n−1
FermatTest∗ (= Miller-Rabin-Test): Wenn für (a, n) = 1, 2k |n − 1 teilt und die Folge a 2k , a 2k−1 ,
n−1
. . ., a 2 , an−1 modulo n nicht 1, . . . , 1 und nicht ∗, −1, 1, . . . , 1 dann ist a ein Zeuge für Nichtprimalität
Für Miller-Rabin-Test gibt es keine zeugenlosen zusammengesetzten Zahlen, es gibt unter den
zu n teilerfremenden Zahlen mindestens 25% Zeugen3 . (Menezes/Oorschot, Kapitel 4, Fact 4.25,
Fact 4.48, Tabelle 4.3)
Die für Informatiker interessante Frage ist die Frage: Wenn man eine Wahrscheinlichkeit kleiner
2−80 für eine fehlerhaft durch Miller-Rabin nicht erkannte zusammengesetzte Zahl haben will,
3
Anmerkung später:
3
4
sind Zeugen,
1
4
sind Lügner
63
muss man für n (512 Bit) 6 Tests machen. Je größer die Zahlen werden, desto weniger Tests
muss man machen. Für 1024 3 Tests, für 2048 2 Tests . . . Vorausgesetzt ist immer noch ein Test
auf kleine Faktoren. Dabei prüft man ob (n, pi ) = 1 für pi < B, wobei pi kleine Primzahlen sind.
Das B wählt man so, dass dieser Test nicht länger dauert als ein Miller-Rabin-Test.
Wie wählt man Primzahlkandidaten? Generiere Zahl mit Zufallszahlengenerator, schaue ob die
durch 2 oder so teilbar ist, wähle dann die nächste Zahl . . .
openssl dhparam -dsaparams -text -noout 2048 schnell
openssl dhparam -text -noout 2048 langsam
Safe Prime:
p−1
2
p−1
2
hat einen großen Primzahlfaktor. q dann getestet ob 2(k · (q + 1)) Primzahl ist.
ist Primzahl.
Wofür braucht man die Primzahlen? Natürlich für RSA und jetzt neu:
4.8 Diffie-Hellman-Schlüsselaustausch
Alice und Bob haben gemeinsame öffentliche Informationen, tauschen öffentliche Informationen
aus, und verfügen danach beide über einen gemeinsamen privaten Schlüssel.
g = 2 (öffentlich bekannt (Generator)), Primzahl p (öffentlich bekannt)
Ergänzungen g, g2 , g3 , . . . , g p−1 mod p (g Generator, dann alle verschieden)
g^x mod p
x
y
g^y mod p
Bob
Alice
Eve
64
Bob wählt zufällig 1 < x < p − 1 und ruft Alice g x mod p zu. Alice wählt zufälig 1 < y < p − 1
und ruft gy mod p zu.
Bob berechnet (gy ) x mod p und Alice berechnet (g x )y mod p. Beide erhalten g x·y mod p. Angreifer Eve kennt nur g x mod p, gy mod p, fehlt g x·y mod p.
Wenn Eve das diskrete Logarithmusproblem lösen könnte, also zu g x mod p und g mod p
das x ausrechnen könnte, dann wäre g x·y mod p leicht zu berechnen. Die besten Algorithmen
für das diskrete Logarithmusproblem mod p sind subexponentiell im größten Primfaktor von
p − 1.
Falls (p − 1) viele kleine Primfaktoren pi hat, ist das diskrete logarithmus Problem leicht, denn
dann löst man das Problem nicht a mod (p − 1) sonder jeweils a mod pi und setzt0 dass ganze
dann mit dem Chinesischen Restsatz zusammen.
0
Sucht p so dass p−1
2 auch eine Primzahl ist, dazu wird zuerst eine Primzahl p gesucht und dann
0
geguckt ob 2p + 1 auch Prim ist.
Openssl:
Variante: DH (DSAparam) (-dsaparam)
p-Primzahl 1536
g-’Generator’ nicht von (p − 1) sondern von der Restklasse h
160 Bit g, g2 , g3 , . . . , gh alle verschieden mit h=160 Bit
Dann sollen x,y so gewählt werden, dass 1 < x, y < h = 160 Bit.
Ein weiteres asymmetrisches Cryptosystem kann man darauf aufbauen: Alle kennen g und p,
jeder generiert sich x (privater Schlüssel) und g x mod p wird veröffentlicht.
Alice will Bob etwas verschlüsselt schicken:
Sie generiert ein k, berechnet aus k und Bobs veröffentlichtem g x : a = (g x )k mod p und aus
dem allgemein bekanntem g: gk mod p.
M sei die Nachricht ( mod p), die Alice verschicken will. Sie berechnet a · M mod p und
sendet an Bob das Paar (gk mod p, a · M mod p).
Bob berechnet (gk ) x mod p = a und dividiert a·M
mod p und erhält somit M.
a
Der Schlüssel a darf nicht zweimal verwendet werden.
Man nennt (gk , a) zeitweiliger bzw. ephemeraler Diffie Hellmann Schlüssel.
Nachteil: die Nachrichtenlänge wird verdoppelt.
65
Das Verfahren ist unsicher, wenn Alice die Zahl x schlecht wählt: x = 1, 2, 1, 2, 1, 2, 1 = x1 , x2 , . . .
4.9 ElGamal-Cryptosystem
(siehe auch TR 3111 vom BSI auf Seite 21)
Auf Diffie-Hellmann aufbauend:
Alice öffentlicher Schlüssel ga , (p, g)
Bob
öffentlicher Schlüssel gb , (p, g)
privat a
privat b
Alice will an Bob schicken:
1. Zufallszahl k generieren
2. Berechne mit Bobs Parametern gk mod p
3. Berechne mit Bobs Parametern (gb )k mod p (DH-Schlüssel)
4. Berechne m · (gb )k mod p
5. Sende gk , m · (gb )k mod p
Bob empfängt (x, y):
1. Berechne xb mod p (DH-Schlüssel)
2. y · (xb )−1 mod p = m mod p
Alice baut also einen temporären DH-Schlüsselteil4 zu Bobs Parametern und sendet diesen und
die damit verschlüsselte Nachricht m.
Nachteil: Nachricht wird durch den Ephemeralschlüssel doppelt so lang.
4.10 Wiederholung DH
Generator g
Primzahl p
ga mod p Restklassen mod p = Körper(·, inverses)
Dass p Primzahl ist, ist eigentlich Zufall.
Erzeugendes Element G
Operation auf Elementen +
a · G = G + G + G + ... + G a-mal
Es muss schwer sein aus G und B = a · G gegeben das a zu bestimmen.
G muss eine Ordnung n haben: n · G = 0 (Neutrales Element der Operation +)
4
Auch Ephemeralschlüssel genannt
66
4.10.1 Beispiel
Alice, Bob G, +, n
Alice: denkt a, denkt a · G
Bob: denkt b, denkt b · G
Beide tauschen a · G und b · G aus und berechnen a · b · G
a · G ist leicht zu berechnen: double and add
a = a0 + a1 · 2 + ... + ak · 2k
a · G = a0 · G + a1 · 2 · G + ... + ak · 2k · G
(k − 1)-mal ·2“ und (k − 1)-mal +“
”
”
4.11 was anderes
Nimmt man nun G große Gruppe mit n Elemente und der Addition +
g-Generator
g, 2g, 3g, . . . , |{z}
nG
Nullelement
Alice: wählt 1 < x < n, bestimmt x · g
Bob: wählt 1 < y < n, bestimmt y · g
Dann wieder K = (ab) · g = K
To do: ergänzen
Problem des Diskreten Logarithmus in G gegeben ist G, g Generator ist 0 , c = a · g in G,
gesucht alogG c-diskreter Logarithmus in G.
Diese Variante funktioniert also mit allen ’Komplizierten Gruppen’, das führt zu dem nächsten
Thema:
4.12 Elliptische Kurven
Wo gibt es so etwas schon? Elliptische Kurven! Sind nicht weit verbreitet, weil sie dem Management schwer zu erklären sind.
67
In der Zahlentheorie ist eine elliptische Kurve eine singularitätenfreie algebraische Kurve der
Ordnung 3 in der projektiven Ebene.
Von besonderem Interesse z.B. für die Faktorisierung natürlicher Zahlen sind aufgrund
ihrer einfachen Struktur elliptische Kurven der Form cy2 = x3 + ax + b mit c , 0 und 4a3 +
27b2 , 0. Einige moderne Verschlüsselungsverfahren basieren auf solchen Kurven. Der Name
leitet sich historisch davon ab, dass diese Kurven durch elliptische Integrale parametrisiert
werden können.
Elliptische Kurven über endlichen Körpern werden in der Kryptografie eingesetzt. Dazu
wird ausgenutzt, dass eine Gerade (lineare Funktion), die zwei Schnittpunkte P und Q mit einer Elliptischen Kurve hat, diese auch in einem 3. Punkt schneidet. Der Punkt, der aus dem
letzteren durch Verkehren des Vorzeichens der Y-Koordinate (wenn die Kurve die oben angegebene Form hat) entsteht, wird P + Q genannt. Man kann zeigen, dass diese Punktaddition
(P und Q werden addiert, das Ergebnis ist der Punkt P + Q) sowohl kommutativ als auch assoziativ ist. Ergänzt man die Elliptische Kurve um einen weiteren Punkt 0 (genannt Punkt im
Unendlichen), so bildet sie zusammen mit der (etwas erweiterten) Punktaddition eine abelsche
algebraische Gruppe.
Sei nun P ein Punkt der Elliptischen Kurve. Der Punkt P + P wird mit 2P bezeichnet,
entsprechend definiert man kP = P + ... + P als k-fache Addition des Punktes P. Ist P nicht
der 0-Punkt und ist die Ordnung der Elliptischen Kurve prim, so kann auf diese Weise jeder
Punkt der Kurve erreicht werden (d.h. zu jedem Punkt Q auf der Kurve existiert eine natürliche
Zahl k mit Q = kP). Die Aufgabe, aus gegebenen Punkten P, Q diesen Wert k zu ermitteln,
wird als Diskretes Logarithmus-Problem der Elliptischen Kurven (kurz ECDLP) bezeichnet.
Es wird angenommen, dass das ECDLP (bei geeigneter Kurvenwahl) schwer ist, d.h. nicht
effizient gelöst werden kann. Damit bieten sich Elliptische Kurven an, um auf ihnen asymmetrische Kryptosysteme zu realisieren (etwa einen Diffie-Hellman-Schlüsselaustausch oder ein
Elgamal-Kryptosystem).
y2 = x3 + a · x + b Skizze der Kurven S2
Zu S2: Punkte auf der Kurve kann man addieren
Die Rechenregeln gehen auch in einem Körper mod p
Beispiel: y2 ≡ x3 + a · x + b mod p Skizze S3
Es gibt immer Punkte, mit denen man rechnen kann. Punkte sind geeignet, die Addition funktioniert auch und hat die Anzahl N der Punkte einen großen Primzahlteiler, dann haben wir auch
Kryptosystem mit G, +, n. Wenn großer Primzahlteiler exisitert:
1. N hat großen Primzahlteiler n
2. Wählen zufällig einen Punkt G als Generator
Daraus erhält man DH und El Gamal
Zuerst eingeführt durch Victor Miller und Neal Koblitz um 1980 herum. Damals war N schwer
68
bestimmbar. Inzwischen gibt es bekannte Algorithmen (Schoof-Algorithmus).
Diskretes Logarithmusproblem ist für elliptische Kurven wirklich exponentiell (bis jetzt): Ein
Bit mehr verdoppelt den Rechenaufwand! (192-Bit/-256 Bit bewegt sich in Größenordnungen
RSA 2000-4000-Bit)
Ergänzung:
1.Bei der Erforschung von Eliptischen Kurver stellte sich zuerst die Frag wie groß ist eigentlich
√
die Ordnung n der Gruppe? Man wusste n ∼ p und man wusste sogar: n − p + 1 − p < n <
√
−p + 1 + p
2. Schnelle Algorithmen zur Berchnung der Ordnung
3. ECDLP ist schwer wenn n einen großen Primfaktor hat.
To do: sortieren
Ergänzung:
man hat p, a, b, G, n, h
K = {y2 = x3 + ax + b}
−1
p ist für die Punktaddition (Formeln siehe en.wikipedia.org wobei λ = (yQ − yP ) · (xa − x p )
| {z }
mit GGT
mod p)
Anmerkung zum Wikipedia Artikel: binary Case bedeutet: man die Eliptischen Kurven auch in
Körper mit 2k betrachten, allerdings vieler solcher Fälle patentiert
G = Generatorpunkt mit G, 2G, 3G, . . . , nG alle verschieden. n kleinste Zahl so dass alle verschieden.
nG = 0
bei der DSA-Parameter Form nimmt man weniger G’s
Der nächste Parameter ist der cofactor h, welches den Unterschied zwischen n und der Anzahl
der Produkte auf der Kurve angibt.
Trick beim testen ob alle iG verschieden sind: man guckt ob n eine Primzahl ist und ob nG = 0
ist, wenn ja ist dies das erste mal, sonst wäre n ja keine Primzahl. Also sind alle vorherigen iG
69
verschieden.
Kurven finden, besser Bestimmung der Punktanzahl, ist schwer.
Früher gab es kleine cofactoren h < 16.
openssl ecparama -list_curves sind schon vorher erzeugt, kann openssl nicht selber.
openssl ecparam -name secp160k1 -text -noout da die Kurve festgelegt ist gibt es nur
ein object zurück.
openss ecparam -name secp160k1 -text -param_enc explicit -noout
openss ecparam -name secp160k1 -text -param_enc explicit -noout -conv_form compresse
komprimiert gibt nur die x-Koordinate aus.
Bei der komprimierten Form kann mit der Kurve die andere eindeutig bestimmen?!? (oder so)
Darstellung als komprimierte Punkt ist auch wieder patentiert.
4.13 Elliptische Kurven Nachtrag
GF(p) (Galois-Field) sind Kurven mod p mit p Primzahl, erfüllen Gleichungen der Form y2 =
x3 + a · x + b
GF(2k ) Körper mit 256 Elementen = 28
In OpenSSL nur elliptische Kurven mod p, patentfrei
Kofaktor finden: Wir haben Punktgruppe G, es gibt einen Generatorpunkt g?
n·G = 0
n ist die Ordnung
cofactor
order = Anzahl der Punkte
| {z } ∗ |{z}
klein
primzahl
(cofactor soll klein sein, order Primzahl) Anstelle Punkt auf der elliptischen Kurve als (x, y) (x, y
mod p) abzuspeichern, Trick:
Wenn√es ein Punkt ist, gibt es zu x zwei y, die quadratische Gleichung y2 = x3 + a · x + b erfüllen:
y1 = √
x3 + ax + b mod p
y2 = − x3 + ax + b mod p
eine der beiden Zahlen hat als letztes Bit immer 1, die andere eine 0, man nimmt daher nur noch
(x, LSB(y)) (x und kleinstes Bit von y)
70
4.14 Rucksack-Verschlüsseln
Kryptosystem das sich bei OpenSSL zu recht nicht findet. Hat den Anschein, als würde es auf
einem NP-vollständigen Problem beruhen. Problem ist NP-vollständig, weil es ein allgemeines
Rucksackproblem ist.
Sieht aber nur so aus, ist aber nur polynomial, weil es ein Transformiertes eines leichten Rucksackproblems ist.
Gegeben: W Fassungsvermögen des Rucksacks, w1 , w2 , ..., wk kleine Gewichte
P
Gesucht: W = ei wi mit ei ∈ 0, 1
Rucksack-Verschlüsseln von Merkle/Hellmann: Rucksack mit schnell wachsenden Gewichten
ist leicht zu berechnen
P
d.h. wi > j<i e j w j nächstes Gewicht ist immer schwerer
4.14.1 Beispiel
Rucksack: W = 51 = 31 + 15 + 3 + 2, w0i s: 2, 3, 7, 15, 31
Grundidee: Aus dem schnellen Rucksack einen langsamen machen:
P
M > wi , k mit (M, k) = 1, k · 2, k · 3, ..., k · 31 mod M
M = 61 ist Modul, k = 17 ist privater Schlüssel, m = (1, 1, 0, 1, 1) ist unverschlüsselte Nachricht,
31, 51, 58, 11, 39 ist öffentlicher Schlüssel, 34 + 51 + 11 + 39 = 135 = 13 → c ist verschlüsselte
Nachricht
Empfänger rechnet aus dem erhaltenen Gewicht (135) das richtige Gewicht wieder raus: 135·k−1
mod 61 = 51 und kann das Problem mit den schnellen Gewichten lösen.
Zum Brechen:
Man transformiert 34, 51, 58, 11, 39 in eine Folge, die schnell wachsend ist, z.B. 1, 3, 5, 11, 29,
d.h. das transformierte System kann auf mehrere Probleme zurückgeführt werden, man braucht
nur eine passende Rücktransformation finden, Adi Shamir hat dafür einen polynomiellen Algorithmus angegeben.
4.15 Merkle Puzzle
Man generiert sich 1.000.000 Nachrichten: Das ist Nachricht ni für den Schlüssel k j“, ni zufälli”
ge 20-Bit Zahl, k j 128-Bit Schlüssel
Verschlüsselungsverfahren DES, diese 1.000.000 werden mit 20-Bit Schlüsseln verschlüsselt
Alice schickt die 1.000.000 Nachrichten an Bob als öffentlichen Schlüssel
Bob will Alice eine Nachricht schicken: Er sucht eine der Nachrichten aus dem öffentlichen
71
Schlüssel aus und macht eine Brute-Force Attacke auf diese Nachricht. Er findet ni und ki .
Bob verschlüsselt mit dem ki seine Nachricht und sendet ni im Klartext mit.
Alice und Bob haben linearen Aufwand, Eve quadratischen.
Von everything2.com:
Alice and Bob agree on a symmetric algorithm.
Alice generates a large number (over a million, at least) of messages of the form, “This is my
index, X, and my puzzle is Y.” Each of the messages is encrypted with a 20-bit key.
Assume there are 220 (about a million) messages, it takes 220 operations to get the key, and a
computer can perform 220 operations per second. Bob takes 1 second to recover the key to a
message. Eve takes 12 days.
Now make that 230 (about a billion) messages. Bob still only takes a second to get the key, and
it will take Eve 34 years.
Public Key Idee hier schon vorhanden
4.16 Rabin-Verfahren und Wurzelziehen
Das Rabin-Kryptosystem ist innerhalb der Kryptologie ein asymmetrisches Kryptosystem, das
auf einem Faktorisierungsproblem beruht und mit RSA verwandt ist. Es lässt sich prinzipiell
auch zur Signatur verwenden. In der Praxis findet das Verfahren allerdings wegen bestimmter
Angriffsmöglichkeiten kaum Anwendung.
4.16.1 Schlüsselgenerierung
Seien p und q zwei möglichst große Primzahlen, für die eine bestimmte Kongruenzbedingung
gelten muss. Der öffentliche Schlüssel n wird durch Multiplikation der beiden Zahlen erzeugt,
also n = p · q. Der geheime Schlüssel ist das Paar (p, q). Anders ausgedrückt: Wer nur n kennt,
kann ver- aber nicht entschlüsseln, wer dagegen p und q kennt, kann damit auch entschlüsseln.
Zum Erzeugen des öffentlichen Schlüssels müssen die Zahlen p und q bekannt sein: Der öffentliche Schlüssel lässt sich nur genau aus den beiden Primzahlen erzeugen.
Wären p und q keine Primzahlen, so ließe sich das Verfahren übrigens nicht anwenden.
Seien beispielhaft p = 7, q = 11 (in der praktischen Anwendung handelt es sich um sehr viel
größere Zahlen, um die Entschlüsselung durch Dritte so schwierig wie möglich zu machen).
Daraus ergibt sich der öffentliche Schlüssel n = p · q = 77.
72
4.16.2 Kongruenzbedingung
q−1 Für p und q muss die Kongruenzbedingung: p−1
=
(p
−
1)
und
= (q − 1)
p
q
n−1
n−1
(wobei für: n = (n − 1) 2 ≡ (n − 1) mod n = (n − 1) gilt.)
oder einfacher ausgedrückt:
p ≡ q ≡ 3 mod 4
gelten.
Allgemein gilt nämlich für die Primzahl r mit r ≡ 3 mod 4 und die Zahl a mit a ≡
b2 mod r:
√
(r+1)
a 4 ≡ a mod r
Diese Eigenschaft dient dazu, später die Entschlüsselung zu erleichtern.
Wegen 7 ≡ 11 ≡ 3 mod 4 ist die Kongruenzbedingung für das Beispiel erfüllt.
n = p · q Produkt von Primzahlen
m soll verschlüsselt werden: c ≡ m2 mod n (einfach Quadrieren, weil Wurzelziehen schwer ist,
wenn der Modul ein Produkt von 2 Primzahlen (p · q) ist, weil wer Wurzel ziehen kann, kann
auch Faktorisieren (n)
Begründung: Es gibt 2 Lösungen c = x2 ≡ y2 mod n. Wie findet man nun die Faktoren von n?
n teilt x2 − y2 = (x − y)(x + y) und x > y und (x − y) < n und n hat nur 2 Primfaktoren, daher:
x − y = p und x + y = q Wurzelziehen ist leicht mod p, mod q Gesucht Wurzel c mod p:
q+1
p+1
x p = c 4 mod p und xq = c 4 mod q
x2p ≡ c
p+1
2
≡c
p−1
2
· c mod p
p−1
Weil c p−1 ≡ 1 mod p ist (nach kleiner Fermat) die Wurzel daraus c 2 ≡ ±1, wegen c ≡ m2
p−1
mod n gilt: (m2 ) 2 ≡ m p−1 ≡ 1(p) Stück fehlt, Ende des Wurzelziehens
Sei nun P = {0, ..., n − 1} der Klartextraum (er besteht also aus Zahlen) und m ∈ P der Klartext.
Nun lässt sich der Geheimtext c durch c = m2 mod n bestimmen. Dabei ist c der Quadratische
Rest von zu der Quadratzahl m2 zum Modulo der Schlüssel-Zahl n. Im praktischen Einsatz
bietet sich die Verwendung von Blockchiffre an.
In unserem Beispiel sei P = {0, ..., 76} der Klartextraum, m = 20 der Klartext. Der Geheimtext ist hierbei nun c = m2 mod n = 15.
73
Dabei muss man beachten, dass für genau vier verschiedene m das c den Wert 15 aufweist,
nämlich für m ∈ {13, 20, 57, 64}. Ähnliches gilt für die meisten c.
4.16.4 Entschlüsselung
Seien allgemein c und r bekannt, gesucht wird m ∈ {0, ..., n − 1} mit m2 ≡ c mod r. Für
zusammengesetzte r (beispielsweise unsere n) existiert kein effizientes Verfahren zur Bestimmung von m. Ansonsten, wenn also r ∈ P (in unserem Fall p und q), dann lässt sich jedoch der
chinesische Restsatz ausnutzen.
In unserem Fall sind nun die Quadratwurzeln
√
m p = c mod p
und
√
mq = c mod q
gesucht.
Wegen obiger Kongruenzbedingung gilt:
(p+1)
mod p
mp = c 4
und
(q+1)
mq = c 4 mod q.
In unserem Beispiel ergeben sich m p = 1 und mq = 9.
Mit dem erweiterten euklidischen Algorithmus werden nun y p und yq , mit y p · p+yq ·q = 1,
bestimmt. In unserem Beispiel erhalten wir y p = −3 und yq = 2.
Nun werden unter Ausnutzung des chinesischen Restsatzes die vier Quadratwurzeln +r,
−r, +s und −s von c + nZ ∈ Z/nZ berechnet (Z/nZ steht hierbei wie üblich für die Menge der
Restklassen modulo n; die vier Quadratwurzeln liegen in der Menge {0, ..., n − 1}):
r = (y p · p · mq + yq · q · m p ) mod n
−r =
n−r
s = (y p · p · mq − yq · q · m p ) mod n
−s =
n−s
Eine dieser Quadratwurzeln mod n ist wieder der anfängliche Klartext m. Im Beispiel
gilt m ∈ {64, 20, 13, 57}.
4.17 Angriffe auf asymmetrische Verschlüsselungsverfahren
Fall: RSA
74
4.17.1 1. Angriff: Common modulus attack
Idee: Gleicher Modul für verschiedene Leute, hätte den Vorteil, dass man sich nur die kleinen
öffentlichen Exponenten e1 und e2 merken muss, nicht mehr die großen Module, hat aber Nachteil: (e1 , e2 ) = 1 teilerfremd: u·e1 +v·e2 = 1 (mit erweitertem Euklid) Sendet man eine Nachricht
m an zwei Alices, berechnet also c1 = me1 mod n und c2 = me2 mod n, dann kann man mit
den Chiffren c1 und c2 auch ausrechnen: cu1 · cv2 = me1 u · me2 u = me1 u+e2 v = m mod n Nachricht
erhalten!
4.17.2 2. Angriff: kleiner geheimer Exponent d
Wenn |d| < |m|
3 , dann ist Faktorisieren möglich, Sicherheitsrisiko, geheimer Exponent muss immer möglichst groß sein, aus großem öffentlichen Exponenten |e| kann man erfahren, dass der
geheime Exponent klein ist
4.17.3 3. Angriff: Faktorisieren
∆
Wenn p ungefähr so groß wie q, also p − q = ∆ klein ist, dann ist ( p+q
2 + 2 ) (ungefähr Wurzel n
∆
+ was kleines = p) ·( p+q
2 − 2 ) = p · q Man weiß, dass die eine Zahl über Wurzel n liegt und die
andere Zahl unter Wurzel n (Wurzel n + klein = p, Wurzel n - klein = q)
4.17.4 Echt schlechte RSA-Schlüssel
n = 3·q (1024 Bit) und öffentlichen Exponenten bei TCTrustCenter abgegeben. Damit kann man
zeigen, dass PGP als Signaturverfahren schlecht ist. Schlüssel schlecht gewählt, dadurch kann
jeder die Kommunikation mitlesen, da n sehr leicht zu Faktorisieren, die Leute, sie könnten
der Person mit dem schlechten Schlüssel vertrauenswürdige Nachrichten schicken und laufen
in die Falle, dass ihre Nachrichten nun öffentlich sind; Anderer Fall: Bewußt solche Schlüssel
vergeben, um Nachrichten in einem kompletten Netzwerk lesen zu können
n = Primzahl, e · d ≡ 1 mod (n − 1)
Mit n als Primzahl geht normale Entschlüsselung nicht.
n, p, q, e, d p , dq , qi , d
c ≡ me mod n
m1 ≡ cd p mod p
m2 ≡ cdq mod q
d p ≡ d mod (p − 1)
75
dq ≡ d mod (q − 1)
m = m2 + (m1 − m2 ) · qi ·q
| {z }
mod p
m ≡ cd mod q und m ≡ cd mod p ⇒ cd
Bundesamt für Informationssicherheit sagt zur Verwendung von RSA: p, q müssen unabhängig
voneinander zufällig erzeugt werden und 0, 5 < | log2 p − log2 q| < 30
4.17.5 Schnelles Faktorisieren bei Fehler im System
DFA - Differential Fault Attack: System, das entschlüsselt, aber sich an einer Stelle verrechnet
m01 ist Rechenfehler, statt wirkliches m bekommt man ein m0 = m2 + (m01 − m2 )qi ∗ q
bildet man nun m − m0 , 0 aber durch q teilbar, d.h. bringt man das System dazu einen Fehler
zu machen und hat man die Originalnachricht: GGT (m − m0 , n) = q schon hat man den Modul faktorisiert, hat funktioniert, viele Chipkarten verrechneten sich unter Streß. Es reicht, das
m0 zu kennen, m kann unbekannt bleiben, denn man rechnet (m0 e − c, n) = q, es reicht eine
entschlüsselte Nachricht zu haben
Anderer Angriff auf Chipkarten:
DPA - Differential Power Analysis: Stromverlauf ansehen, Differenzen bilden und sequentiell
analysieren
Angriff auf El Gamal Systeme:
geheimer Schlüssel a, öffentlich g, p, ga , Verschlüsselte Nachricht: zufälliges k: (gk , m·gak )= c 1.
Angriff: k gleich für verschiedene Nachrichten oder k1 , k2 in Abhängigkeit oder k, k + 1, k + 2, . . .
für verschiedene Nachrichten oder a · k + b
4.17.6 Angriff mit gewähltem Chiffretext
Normalerweise bei RSA: m −→ c = me mod n
c0 vorgegeben führt zu Klartext m0 = (c0 )d mod n
Anforderung: Beliebiger Chiffretext außer c0 = c wählbar, zu dem man dann den Klartext erhält
Problem bei RSA:
1. r (zufällig gewählt) → re mod n = s
2. c0 = s · c mod n
Verschlüsselungsmaschine liefert dann: (c0 )d = sd · cd = (re )d · m = r · m mod n = m0
76
3. Letzter Schritt: m = m0 = r−1 mod n
Das geht nur theoretisch, in der Praxis geht das nicht, weil: Angreifer kann das r nicht steuern,
r · m wird aber von der Verschlüsselungsmaschine verworfen, weil es bei zufälligem r kein
korrektes Padding hat.
Schwäche des RSA: Multiplikationseigenschaft
m1 → c1 und m2 → c2 (m1 , m2 gültige Klartexte)
m1 · m2 → c1 · c2
m1 · m2 nicht als gültiger Klartext zugelassen
5 Signaturmechanismen
Wie erstellt man signierte Daten und versucht ein Äquivalent zu dem zu schaffen, was man im
täglichen Leben durch Unterschriften schafft.
Eigenschaften einer Signatur sollen nachgebildet werden: Man weiß, von wem ein Dokument
kommt, sie ist an eine Person gebunden und kann von niemanden sonst nachgemacht werden und
vom Inhaber nicht abgestritten werden. Nachträgliche Änderungen an unterschriebenen Dokumenten sollen nicht mehr möglich sein (gibt es so im echten Leben nicht).
5.1 Integritätsschutz und Hashfunktionen
To do: neu Hashfunktionen Definition, einsortieren
Hashfunktion: Beliebige Daten werden auf Binärfolgen konstanter Länge abgebildet
Def.: Eine Hashfunktion H ist eine Abbildung 0, 1∗ → 0, 1k auf Hashwerte der Länge k.
SHA-256 (SHA- Secure Hash Algorithmen) - Hashwerte der Länge 256 Bit
1. Es gibt Kollisionen:
d1 , d2 H(d1 ) = H(d2 )
2k Hashwerte aber potentiell abzählbar viele Daten.
Wunsch:
Man soll diese Kollisionen nicht finden können und am besten es gibt sie nicht. Hashfunktionen
dienen zum unterscheiden von Daten.
77
H(d1 ) , H(d2 ) dann ist d1 , d2
Dementsprechend groß muss das k sein, so dass genügend viele Werte unterscheiden kann.
Anforderungen an Hashfunktionen:
Wunsch Kollisionsresitent (schwer Kollisionen zu konstruieren): man kann nicht zwei Dokumente mit dem gleichen Hashwert konstruieren.
Wunsch Zweites Urbild resistent (schwer zweites Urbild zu konstruieren): man kann zu einem
Dokument nicht ein zweites mit dem gleichen Hashwert bestimmen.
Kollisionen entstehen zum Beispiel in Hörerkreisen: 23 Hörer(innen),
dann haben mit mehr als 50% Wahrscheinlichkeit zwei am gleichen Tag Geburtstag.
Geburtstagsparadoxon
H : Hörer → Datum h 7→ Geburtstag(h)
h1 , h2 , H(h1 ) = H(h2 )
Bestimme die Wahrscheinlichkeit, dass keine zwei am gleichen Tag Geburtstag haben.
1−g=
365·. . . ·(365−n+1)
(365n )
wobei n die Anzahl der Hörer ist. (Für n = 23 ungefähr 50%)
√
365 20
√
g #Hashwerte
Bei 2128 Hashwerte muss man mit Kollisionen rechnen ( Bsp: 30% bei 19 Personen 19 √
365)
k
Merke: Das Geburtsatgs Paradox beschert uns Kolisionen bei 2 2 Hashwerten.
To do: ende Neu
Hashfunktionen: Schon bekannt aus dem ersten Semester (Hashtabellen).
Allgemeine Eigenschaften:
1. Komprimieren beliebig lange Werte auf n-bit Werte
2. Einfach (und schnell) berechenbar
Werte:
78
Fingerabdruck / Prüfwert, Hashwert
h(x) (Hashfunktion) mit x1 , x2 aber h(x1 ) = h(x2 ). x1 und x2 ist Kollision
Wahrscheinlichkeit für Kollision für zufällig gewählte Werte sollte 21n sein (Anforderung an
Hashfunktion)
Kollisionen:
Wir verlangen, dass die Variabilität in der Eingabe sich auch in den Prüfwerten widerspiegelt,
sprich: Wenn die Eingabewerte gleichverteilt sind, sind es auch die Ausgabewerte.
To do: 20090422
To do: einsortieren
Kollisionen ’vermeiden’ durch Größe: 160 Bit Prüfwerte (280 für Kollision (2100 — AES 128 —
bzw. 2112 2128 als Kollisionsschranken)
Zusätzlich Voraussetzungen für die Prüffunktion:
1. Kollisionsresistenz: Es muss schwer sein zwei Nachrichten m1 , m2 zu finden, so dass
H(m1 ) = H(m2 )
(Es ist schwer Zwillinge zu konstruieren.)
2. Zwillingsresistenz: Es muss schwer sein (also kryptografisch Aufwendig) zu einer Nachricht m1 eine Nachricht m2 zu konstruieren, so dass H(m1 )FH(m2 ) ist.
(Wenn man eine Bruder hat, dann ist es schwer eine zwillings Schwester dazu zu konstruieren.)
(aufwendiger als erstens)
3. Urbildresistenz: Es muss schwer sein zu einem beliebigen Prüfwert h eine Nachricht zu
konstruieren, so dass H(m) = h ist.
4. Die Prüfwerte müssen ’zufällig’ aussehen. Die Ausgabe von H genügt Anforderungen an
einen Zufallszahlengenerator (gewisse statistische Unauffälligkeit), also pseudozufällig.
Eigentlich müsste man noch mehr Fordern, nämlich dass man keine zwei Nachrichten findet die
sehr ähnliche Hashwerte haben und dass man zu einer gegeben Nachricht keine Nachricht mit
einem ähnlichen Hashwert findet...
Beispiel
H gute Prüffunktion



|m| , n fix, so
H(m) = 

|m| = n so ist
H 0 (m) = 0||H(m)(H(m) rangehangen...)
H 0 (m) = 1||m( rangehangen...)
h ist die Länge der Prüfwerte von H
79
H 0 ist kollisionsresistent wenn es H ist, aber nicht urbildresistent
To do: sortieren
openssl 0.9.7d (2004) Prüfwertstandardverfahren ist MD5
Hashfunktion enthält eine ’Kompressionsfunktion’ m1
To do: Bild-siehe Blatt - 20090422
K(s, m) = s0
K(s, m) = K(s, m2 )
K(s1 , m1 ) = K(s2 , m2 )
s1 und s2 als Ergebnisse einer Prüfwertberechnung darstellen.
K(s1 , m11 ) = s1 K(s01 , m21 ) = s2
K(s1 , m12 ) = s K(s2 , m22 ) = s
der rechte Teil war 2004 schon bekannt, es musste nur noch die linke seite gelöst werden.
5.1.1 Schlüssellose Hashfunktion (Prüfsummen ohne Schlüssel)
h : x −→ h(x)
Ausschließlich Prüfwert. Gute Auswahl garantiert, dass man mit h(x) feststellen kann, ob x
verändert wurde.
x0 ist verändertes Dokument/Daten
Berechnung des Prüfwerts liefert h(x0 ) = h0 , h(x) bei guter Hashfunktion. Veränderung kann
also festgestellt werden.
80
Zusätzlich verlangte Eigenschaften
1. Kollisionsresistenz: Es ist schwer, Kollisionen zu erzeugen. D.h. es ist schwer x1 , x2 mit
h(x1 ) = h(x2 ) zu finden.
Heute üblich: n = 80 oder n = 100
280 oder 2100 in ∼ 280 Schritten. Definitiv: 256 ist
nicht schwer, 264 ist nicht mehr so schwer.
2. Zwillingsresistenz / Zweites-Urbild-Resistenz / second preimage resistance: Es ist schwer,
einen Zwilling zu erzeugen: ist x1 mit h(x1 ) vorgegeben, so ist es schwer, einen Zwilling
x2 zu erzeugen mit h(x1 ) = h(x2 ).
(Anmerkung: Finger weg von Binärcode für x1 , x2 .)
3. Einwegeigenschaft / Urbild-Resistenz: Es ist schwer, zu vorgegebenem h(x) ein Urbild x
zu berechnen.
h1 (x) ist eine gute Hashfunktion mit den schicken Eigenschaften 1, 2, 3. (n + 1 Bitlänge)
(
h2 (x) =
1kx
0 k h1 (x)
wenn x die Länge n hat
sonst
h2 (x) ist kollisionsresistent (Zwillingsresistenz) (wenn h1 so ist). h2 ist aber nicht urbildresistent. 1 k x hat als Urbild x.
2 ist die wichtigere Eigenschaft, man kann notfalls noch ohne 1 auskommen. Zum Beispiel
letztes Jahr: MD5 - Hashfunktion x1 , x2 waren konstruiert h(x1 ) = h(x2 )
x1 ⊕ x2 = 0 . . . 010 . . . 010 . . . 010 . . . 01 (1 jeweils im msb). Immer noch ein gewisser Schutz, da
zum Beispiel keine Kollision auf -Kleinbuchstaben oder 64 möglich.
Schlüssellose Hashfunktionen sollten alle 3 Eigenschaften haben.
Fast-Kollision:
x1 ; x2
partielle Urbilder:
h(x1 ) ⊕ h(x2 ) hat wenig 1-Bits. Manchmal zu vermeiden.
Gegeben h(x), dann ist es schwer x bis auf wenige Bits zu bestimmen.
SHA-1: theoretische Schwelle 280 , praktisch 269 (16.02.2005), 263 (19.08.2005)
23 Personen, die Wahrscheinlichkeit dafür dass 2 am gleichen Tag
im Jahr Geburtstag haben ist größer als 21 .
Geburtstagsparadoxon:
h(x) =dd-mm,
Mit k Personen x1 , . . . , xk lassen sich k2 Geburtstagspaare bilden. Mit n Tagen h1 , . . . , hn im Jahr
lassen sich n2 Geburtstagspaare bilden, davon sind n gute ( (h, h0 ) mit h = h0 )
81
mit k2 Paaren in n2 Paaren suchen und einen von n treffen.
Hashfunktion hat 160 Bit Ausgabe, wir brauchen nach Geburtstagsparadoxon 280 Personen um
mit hoher Wahrscheinlichkeit den gleichen Geburtstag h mit 160 Bit zu erhalten.
Allgemeines Konstruktionsprinzip:
x wird auf eine bestimmte Blocklänge erweitert (pad-
ding)
1. Nullpadding (auffüllen mit Nullbits, falls erforderlich)
2. 1-Nullpadding (eine 1 und dann mit Nullbits bis zur Blocklänge)
3. 1-Null-Längenpadding (eine 1 und Nullbits (falls erforderlich) und die Länge (msb first,
64 Bit oder 128 Bit)). Am besten geeignet, da bei 1 oder 2 automatisch Kollisionen entstehen: x (mind. 1 bit kürzer als die Blocklänge) und x k 0.
x → b1 , . . . , bk Blöcke der Länge 512 Bit.
Häufig Verlauf in 3 Phasen, in openssl:
init,
update,
final
1. Initialisierung der Hashfunktion: Innerer Zustand aus 32-Bit-Wörtern: H1 , H2 , H3 , H4 , H5
initialisiert (mit Primzahlen, π, was-auch-immer)
2. Update: A, B, C, D, E aus H1 , . . . , H5 . Runden mit Transformationen mit Eingabe bi , 48|60|120 . . .,
H1 = H1 ⊕ A, H2 = H2 ⊕ B, . . .
3. Finalisierung: Ggbf. Padding; 1 oder 2 mal das Update.
4. Ausgabe: H1 , H2 , . . . H5
Einfaches Beispiel:
82
So lässt sich aus einem Kryptoalgorithmus ein Hashalgorithmus konstruieren. In der Praxis werden andere Konstruktionen (Quirlfunktionen) verwendet: MD5, SHA-1, SHA-2 (224, 256, 384,
512), Whirlpool. ISO-????
In OpenSSL: MD2, MDC2, MD4, MD5, RIPEMD-128, RIPEMD-160, SHA-0, SHA-1. Alle
gebrochen, ausser RIPEMD-160 und SHA-1 (evt. MD2), d.h. es sind m1 und m2 bekannt mit
MD5(m1 ) =MD5(m2 ) und m1 , m2
5.1.2 Demonstration Fälschung
Ist die Hashfunktion ’schwach’ kann man Kollisionen sogar konstruieren.
Beispiel für MD5, MD4 ist seit 10 Jahren schwach, SHA-1 wird schwach
Zwei Postscript-Dateien mit unterschiedlichem Inhalt aber gleichem MD5-Hash. Prinzip: Datei
1:
...Header...
if x1 == x2 then strangestring = "T1" else strangestring = "T2" end
...Rest...
echo strangestring
Quelltext: (B)(B)eq [tot] [Def] ifelse
| {z }
Bedingung
83
Datei 2:
...Header...
if x2 == x2 then strangestring = "T1" else strangestring = "T2" end
...Rest...
echo strangestring
(A)(B)eq [Def] [tot]
| {z }
Bedingung
x1 und x2 unterscheiden sich nur sehr wenig, und ...Header... if x1 und
...Header... if x2 sind je ein Nachrichtenblock mit dem gleichen Hashwert.
Sieht aus wie zweites Urbild-Angriff, sind aber in der Tat zwei böse Zwillinge.
Quelle: www.cits.rub.de/MD5Collisions
Fazit: Dokumente sind nicht mehr unterscheidbar.
Kollision besteht aus zwei Dokumenten d1 , d2 mit dem Hashwert.
Bei MD5 kann man zwei ’Dokumente’ (Präfixe bis A,B) konstruieren, die den gleichen Hashwert haben.
Man kann aber zu einem Dokument d0 (dem Original) noch nicht ein zweites d00 konstruieren,
so dass d0 , d00 eine Kollision bilden.
Beispiel: Ein SSL-Server-Zertifikat war (MD5) ununterscheidbar von einen SSL-Zertifizierungsstellen
Zertifikat, womit man so viele (evt. ’böse’) SSL-Server-Zertifikate erstellen wie man wollte.
MD5 ist nicht kollisionsresistent.
MD5 ist noch 2 Urbild resistent.
5.2 Unterschied MD5 und SHA
MD5 128bit Länge (Kollision 264 )
SHA-224 224bit Länge (Kollision 2112 )
SHA-256 256bit Länge (Kollision 2128 )
84
?mehr rotation? lokale Unterschiede habe größere globale Unterschiede zur Folge bei SHA ??
5.3 Secure Hash Standard, SHA-2
FIPS 180-2, US-Standard, Nachfolger von FIPS 180 SHA-0 und SHA-1 sind die SHA-2-Algorithmen
(noch nicht in OpenSSL): SHA-224, SHA-256, SHA-384, SHA-512. SHA-224 bzw. SHA-384
|
{z
} |
{z
}
32 Bit
64 Bit
ist ungefähr‘ die linke Seite von SHA-256 bzw. SHA-512.
’
Basisfunktionen:
ch
(x&y)|(∼ x&z)
Auswahlfunktion
par x ∧ y ∧ z
Paritätsfunktion
maj (x&y)|(x&z)|(y&z) Mehrheit
Ausserdem: Addition modulo Wortlänge, rot left und shift left.
Message M1 , M2 , . . . , MN padding
1. padding.length auf 512/1024 Bit.
512
32
= 16 =
1024
64
2. Messageblock (16 Stück) wird erweitert:
W , W , W2 , . . . , W15 , . . . W79
| 0 1 {z
}
Messageblock
Wt = rot(Wt−3 ) + rot(Wt−8 ) + rot(Wt−14 ) + rot(Wt−16 ) für t = 16, . . . , 79
rot(x) = rotl7 (x) + rotl18 (x) + shl3 (x)
3. 8 temporäre Variable a, b, c, d, e, f, g, h mit Breite gleich Wortlänge (32 oder 64 Bit) beschreiben einen inneren Zustand der Funktion
SHA-Maschine bekommt initialen Zustand H0 , . . . , H7 : Die ersten 32 Bit der gebrochenen
Anteile der Quadratwurzeln der i. Primzahl. Für SHA-256 und SHA-512: i = 1, . . . , 8; für
SHA-384 und SHA-224: i = 9, . . . , 16
85
Am Anfang jeder Runde: a = H0 , b = H1 , c = H2 , . . .
Jedes Wi erzeugt einen Schritt (kleine Zustandsänderung)
T 1 = h + rot(e) + ch(e, f, g) + Kt + Wt
T 2 = rot(a) + maj(a, b, c)
h = g, g = f, f = e, e = d + T 1 , d = c, c = b, b = a, a = T 1 + T 2
K0 , . . . , K80 Schrittkonstanten. Bruchteile der dritten Wurzeln der ersten 80 Primzahlen.
80 Schritte in einer Runde
4. XOR-Operationen H0 , H1 , . . . , H7 −→ H0 ⊕ a, H1 ⊕ b, . . . , H7 ⊕ h
Hi beschreiben den inneren Zustand nach Runde. Hi am Anfang initialisiert
5. Ausgabe ist H0 , . . . , H7 am Ende.
To do: wäre auch interessant für die Prüfung
Es wird eine neuer SHA-3 gesucht, Voraussetzungen:
1. Nachrichtenexpansion muss komplexer werden
2. Nachrichtenblöcke müssen positionsabhängig werden (Skein tweakable
3. innerer Zustand muss größer werden (2x Hashlänge)
5.3.1 Problem bei MD5 und SHA-0
Innerer Zustand zwischen einzelnen Schritten hat Bits, die die folgenden Bits
mehr oder weniger beeinflussen. Damit sinkt die Komplexität beim Brechen. Besondere Bits
führen zur Reduktion der Anzahl der Gleichungen und erlauben eine schnelle Konstruktion von
speziellen Zwillingen. m1 , m2 mit MD5(m1 ) =MD5(m2 ) m1 ⊕ m2 = viele Nullen
Beispiel 1:
Parallel hashen: Kontostand -200,73“ und Kontostand +700,...“. Ab -2 bzw +7 entstehen un”
”
terschiedliche innere Zustände. Nachkommastellen bei dem zweiten String anpassen um die
Unterschiede auszugleichen.
86
Aktuelle Angriffe erzeugen keinen zweiten Zwilling, sondern ’nur’ falsche Zwillinge. Zu einem
guten gibt es keinen schlechten Zwilling.
Es gibt zwei Zertifikate mit unterschiedlichen Inhalten und gleichem MD5-Hash.
Das sind dann aber 2 schlechte Zertifikate. MD5 ist also nicht kollisionsresistent, aber momentan
zwillingsresistent.
Beispiel 2:
SHA-1 hat momentan eine Komplexität von 263 anstelle von 280 für Kollisionen.
m, H(m) (H(m) aus vertrauenswürdiger Quelle) ⇒ m kann nicht unbemerkt verändert werden.
Manipulation Detection Codes (). Das ist keine Prüfung des Ursprungs. Um zu prüfen, ob m
aus einer bestimmten Quelle stammt benutzt man MACs.
5.3.2 MACs (Message Authentication Codes) (Prüfsummen mit Schlüsseln)
Sei k ein geheimer Schlüssel den nur Alice und Bob kennen. m ist die Nachricht. Berechne
Hk (m) = h keyed Hash. Die Hash-Prüfwerte sind also Schlüsselabhängig.
(m, h) mit h aus vertrauenswürdiger Quelle:
• Veränderungen sind erkennbar
• Nur mit Kenntnis von k kann man h berechnen, also nur mit dem Schlüssel kann man den
Prüfwert fälschen.
Empfänger der k kennt kann n auf Integrität prüfen. Um sich vor Angreifern zu schützen muss
für eine Prüfung der Prüfwert geschützt werden.
?
Hk (m0 ) = h
(m1 , h1 )
→ (m, h) muss verhindert sein
(m2 , h2 )
87
Standardisiertes Verfahren für Keyed hash auf der Basis von MDCs: RFC 2104, in OpenSSL zu
finden: HMAC).
H(k ⊕ äußeres Padding k H(k ⊕ inneres Padding k m))
|
{z
}
512- oder 1024-Bit-Blöcke
k linksbündig, aufgefüllt mit Nullen, inneres Padding = 0x36, 0x36 . . ., äußeres Padding = 0x5c,
0x5c, . . . . Längenpadding am Ende des inneren H.
Berechnen Sie mit OpenSSL und dgst -c oder -hex den Hashwert der leeren Datei.
henryk@gleam henryk $ openssl dgst -c -hex -md5 /dev/null
MD5(/dev/null)= d4:1d:8c:d9:8f:00:b2:04:e9:80:09:98:ec:f8:42:7e
henryk@gleam henryk $ openssl dgst -c -hex -sha1 /dev/null
SHA1(/dev/null)=
da:39:a3:ee:5e:6b:4b:0d:32:55:bf:ef:95:60:18:90:af:d8:07:09
openssl dgst -sha256 -hmac 1234567890 /dev/null
HMAC-SHA256(/dev/null)= ba92e0bfa35d8a018831f3675f0b4314c8468d4d96e6981b85ba3390
HMAC
To do: vervollständigen?
Mac mit Hashfunktion, K- Schlüssel, H-Hashfunktion
0x5656...56
z }| {
K ⊕{z
iPad
H(K ⊕ oPad, H(|
}, n))
Bitlänge H
K, n1 → Mac(n1 , K) = m1
K, n0 = n1 ||längenpadding ||n2
(K, n0 ) → HInitialisiert mit m1 (n2 ) = m2
ISO-10118-3:2004
88
5.4 Whirlpool
Basis für eine Hashfunktion, ausgehend von einer einzigen Verschlüsselungsfunktion.
WHIRLPOOL ist eine kryptografische Hash-Funktion, die von Vincent Rijmen und Paulo S.
L. M. Barreto entworfen wurde. Sie wurde nach der Whirlpool-Galaxie im Sternbild der Jagdhunde benannt.
Whirlpool funktioniert mit Daten von weniger als 2256 Bit Länge und gibt einen HashWert von 512 Bit aus.
Die Autoren haben erklärt, dass Whirlpool nicht patentiert ist und es nie sein wird. Whirlpool darf kostenlos zu jedem Zweck verwendet werden. Die Referenz-Implementation ist gemeinfrei.
The WHIRLPOOL algorithm has undergone two revisions since its original 2000 specification. In the first revision in 2001, the s-box was changed from a randomly generated one with
good cryptographic properties to one which has better cryptographic properties and is easier to
implement in hardware. In the second revision (2003), the diffusion matrix was changed.
People incorporating WHIRLPOOL will most likely use the most recent revision of
WHIRLPOOL; while there are no known security weaknesses in earlier versions of WHIRLPOOL, the most recent revision has better hardware implementation efficiency characteristics,
and is also likely to be more secure.
m i-1
AES-Variante
E
H i-1
+
Hi
5.5 Zusammenfassung
To do: oben einsortieren?
89
Manipulation Detection Codes MDCs:
Hashfunktionen: MD5/SHA-1/SHA-2
Allgemeines Konstruktionsprinzip aus Längenpadding und Iterationen
• MACs/Keyed Hash: HMAC mit Hashfunktion aufgebaut aus prefix und suffix
• CBC-MAC: Nachrichtenblöcke m0 , m1 , ..., mk
m1
m0
+
mk
...
+
K
c1
c2
c k+1
MAC
Risiko: Weil keine Längeninformationen dabei sind, ist es anfällig gegen Einsetzen und
Austauschen. Wird gerne Verwendet bei Anwendungen, die feste Längen haben, z.B.
Chipkarten.
CBC-MAC-verbessert:
...
DES
K1
K2
K3
←− CBC-DES3-MAC
Benutzt z.B. beim digitalen Tachograph.
Es gibt zwei Grundlegende technische Mechanismen: Ohne Schlüssel und mit Schlüssel. Nur mit
Schlüssel lässt sich später der richtige MAC-Wert ausrechnen und bestimmen, dass die Nachricht
nicht verändert wurde und vom richtigen Absender kommt.
90
5.6 Digitale Signaturen
To do: einsortieren
Definition:
s ist die Signatur zu einer Nachricht n mit einem Signaturverfahren S und einem Verifikationsverfahren V
S :N×
D
|{z}
→ {s}
Signaturschlüssel
V:N×
E
|{z}
×{s} → {ja, nein }
Verifikationsschlüssel
V(n, e, S (n, d)) = 1
V(n, e, S (n0 , d)) = 0 =( n, e0 , S (n, d)) = 0
RSA:
S (n, d) =?
V(n, s, e) = {E(e, s)eqH(n)}
openssl dgst -sign key.rsa -hex null.txt
openssl -sign key.rsa -sha256 -out null.sig null.txt
openssl rsautl -in null.sig -encrypt -inkey key.rsa -raw -hexdump
in Beta: openssl sha256 -hex null.txt
Anstatt der Symmetrischen Verschlüsselung wie bei MAC, kann man auch asymetrische Verfahren verwenden.
1. h mit Namen (0,D) in ASN1 Struktur 0001 FF . . . FF 00 (ASN1-Struktur)
2. Padding
3. ’Entschlüsseln’
4. ’Verschlüsseln’
5. ASN1 Struktur Hash OID Wert rausziehen
91
6. vergleichen { 0, 1 }
openssl hatte in den früheren Versionen einen Fehler in der Signaturprüfung:
langer RSA Schlüssel
exponent e klein (3)
lange Signatur S
S3 = h
wenn h sehr lang ist konnte man folgendes machen:
h= (0001FF00ASN1 ’müll’)
man konnte den ’Müll’ so verändern das h = s3 (also so lange veränder bis h dritte Wurzel von
s ist)
Es wurde nicht überprüft ob am Ende der ASN1-Struktur auch das Ende der Daten ist.
siehe Webseite RSA Zertifikate mit Exponenten 3
To do: alt:
Digitale Signaturen schützen die Integrität und die Authentizität. Wir betrachten hier welche, die
auf asymmetrischen Verfahren basieren. Symmetrische gibt es, werden aber in der Praxis nicht
benutzt. Es gibt 2 Typen:
1. RSA
2. DSA
5.6.1 RSA
m = p · q (2048 Bit)
Exponent e klein (64 Bit)
Exponent d groß mit e · d ≡ 1 mod (p − 1)(q − 1)
x → c = xe mod m (öffentlich)
cd ≡ x mod m (geheim)
xed ≡ x
92
Man rechnet zuerst x → s = xd mod m: Das kann nur derjenige, der über den privaten Schlüssel
d verfügt. Aus s rechnet man se mod m = (xd )e mod m ≡ xe·e mod m = x. Bei RSA können
wir die Rolle vom privaten und öffentlichen Algorithmus vertauschen, so dass folgt: Nur wer d
kennt, kann zu x ein s erstellen, so dass se ≡ x mod m ist.
Anwendung dafür: Digitale Signatur. Wir haben Nachricht M und erstellen daraus einen Prüfwert
H(M) mit einer Hashfunktion und rechnen
H(M) = x −→ s = xd
mod m
Dann ist (M, s) das digital signierte Dokument M (und s die Signatur).
To do: einsortieren neu:
Signatur mit Anhang (with appendix) (m, sig)-Signierte Nachricht
Ver(v, m, sig)
Signatur mit Nachrichtrückgewinnung (with (partial) message recovery) (m1 , m02 ) = m0 , so dass
m02 ein Teil der Nachricht m = m1 ||m2 enthält.
Ver(v, m1 , m02 ) (partial recovery)
Ver(v, −, m0 ) (complete recovery)
In RSA:
PKCS#1 ver. 1.5. Signatur mit Appendix
PKCS#1 ver 2.1 (noch nicht in OpenSSL)
To do: ende einsortieren
?
Prüfung: (M, s) → H(M) = x. Ist se mod m = x. Nur wer das d hat, kann das Paar (M, s)
erstellen und ist damit Inhaber des Dokuments.
5.6.2 Eigenschaften eines asymmetrischen Verschlüsselungsverfahren
Alice kennt den öffentlichen Schlüssel von Bob. Bob kennt seinen geheimen Schlüssel.
93
Alice1,2,3,...
öffB
Bob
gehB
EöffB (m) = c
→
DgehB (c) = m
Alice
gehA
→
MS geh
Bob1,2,3,...
öffA
%
→
&
(m, s)
A
(
Vöffa (m, s) =
0, ungültig
1, gültig
Mehrere Alices können an Bob schreiben. Entschlüsselung mit dem geheimen Schlüssel von
Bob. Hier wird eine Nachricht, so verschlüsselt, dass man die Nachricht aus c zurückgewinnen
kann.
Alice sendet an alle Bobs. Hier wird ein Paar erzeugt, dass in einen Verifikationsalgorithmus
gestopft werden kann, der dann ja oder nein sagt.
Es ist Zufall, dass man mit RSA sowohl einen Verschlüsselungsalgorithmus, als auch einen
Signaturalgorithmus erstellen kann! Mit anderen geht das nicht!
Hätte man nicht die Urbildresistenz der Hashfunktion könnte man ein s nehmen und dazu ausrechnen se mod m = x, jetzt könnte man zu dem x ein Urbild M ausrechnen und bekäme ein
Paar (M, s), dass gültig signiert ist. Dazu kommen in Wahrheit noch Padding und Objekt Identifier, der angibt, womit signiert wurde und Parameter.
30 = SEQUENCE
06 = OID
2B 0E 03 02 1A = SHA1
2A 86 48 86 F7 0D 01 01 01 = rsaEncryption
05 = NULL, Bezeichner für die leere Menge, hier bedeutet es: keine Parameter
04 = OCTET STRING
02 = INTEGER
03 = BIT STRING
Schema: Tag, Length, Value
Das ganze lässt sich mit openssl asn1parse erfahren (asn1 = Abstract Syntax Notation 1).
Schlüssel immer: SEQUENCE, SEQUENCE, OBJECT, PARAMETER, BIT STRING bzw. Sequence aus OID und Bitstring. Das erste Byte in einem Bitstring gehört nicht zum Bitstring dazu,
sondern gibt die Nummer der von hinten ungenutzten Bits an.
OID-Liste: http://www.alvestrand.no.
h
M −→ H −→ 00 01 FF . . . FF 00 b
SHA-1
Padding
c b
Identifier
H
c Padding nach PKCS#1 v1.5
Oktetstring
ASN.1: Objektidentifier für SHA-1 (1.3.14.3.2) wird als 2B 0E 03 02 1A codiert.
94
x.y.a.b.c.d
↓
bx · 40 + yc babcdc
1 Byte
(Dot-Notation)
Byte (Oktett)
1.2.840.113549.1.2.7 als Übungsaufgabe.
5.6.3 RSASSA-PSS-Padding
SSA Signature Scheme with Appendix
PSS Probabilistic Signature Scheme
RFC 3447 (siehe figure 2)
M
l(M) <= 2^(64)-1 bei SHA-1
h
0000 ...
01
salt
8 zero
salt
20 Byte
+
00
MGF
h
maskiertes seed
Bits
zu 0
setzen
soviele, dass die Eingabe
kleiner als der Modul wird
20 Byte
BC
1024
Eingabe für die Signatur
To do: start einfügen
MGF-Maskengenerierungsfunktion (beruht auf der Hash-funktion)
95
Nullung
MGF ⇒ DBmask, dann DB ⊕ DBmask −−−−−−→ maskedDB
Nullung-Nullung der oberen Bits, so dass maskedDB kleiner als Modul ist
Signieren: (EMSA-PSS)+(RSA-Verschlüsselung)
Verifikation: (RSA Op)
1. RSA-Operation
2. EM
Prüfung ob BC am Ende
H abspalten und mit MGF DBmask erzeugen
XOR mit Rest von EM
DB0 =
0000
|{z}
00...01 Salt
Nullungsfehler
Hash
?
00 Label mhash Salt −−−−→ H 0 = H
Jede Eingabe in die RSA-Operation ist pseudo zufällig. (Jede Eingabe hat einen neuen Signaturwert)
Angenommen man wendet die RSA-Operation direkt auf m an:
m0 -Signatur m0 = md mod n
m1 , m2
m1 → m01 mod n = m01
m2 → m02 mod n = m02
Verifikation
(m1 , m2 ) mod n → (m1 · m2 )d = md1 ṁd2 = m01 · m02 mod n
(’Man kann mit zwei Signaturen eine andere erzeugen?!’)
96
To do: ansehen
Unsicher, zeitaufwendig, kann leicht gebrochen werden.
m → m0 = md mod n
re = r0 mod n
chosen message m · r0 → (m · r0 )d mod n = md · red mod n = m0 · r mod n
(m0 · r) · r−1 mod m = m0
(sieht nach Zufallszahlen aus, aber die kann man auf eine vorher gewählte Nachricht zurückrechnen...)
To do: ende einfügen
Nachricht M mit |M| < 264 − 1 wird mit Hashfunktion h gehasht. Davor kommen 8 Zerobyte,
danach ein Saltwert (Saltwert wird benötigt für die Auswertung der Signatur und wird versteckt
in der Signatur). Auf das Gesamte wird die Hashfunktion h erneut angewendet.
Verstecken des Saltwerts: --0000 (→ eventuell leer) 01 salt-- ⊕ mit einer Maske gebildet
aus dem Hashwert und einer Maskengenerierungsfunktion.
An den Anfang der Eingabe für die RSA-Signatur werden 0-Bits so gesetzt, dass die Eingabe
für die RSA-Signatur kleiner als der Modul ist. Wenn m volle Bytelänge hat, wird das oberste
Bit gleich 0 gesetzt (RSA-Signatur: ()d mod m mit m = p · q). An das Ende der Eingabe für die
RSA-Signatur wird BC angehängt.
Durch den Saltwert wird das Ergebnis zufällig und schwer vorhersagbar. Wird leider nicht oft
verwendet, da die Maskengenerierungsfunktion Chipkarten teuer machen würde.
Es existiert eine DIN Variante zum v1.5 PKCS1: DIN-RN-Padding:
00 02 Zufallsbytes(ohne 00) 00 Identifikator Oktettstring
5.6.4 DSA
Vergleich ElGamal und elliptische Kurven:
K-elliptische Kurve y2 = x3 + ax + b mod p
97
p-Primzahl (, 2, , 3)
Punkte auf der Kurve bilden eine Gruppe E(k)
P + Q = R, k · G ∈ E(k)
G ein Punkt (Generator) mit großer Ordnung n
1 · G, 2G, 3G, ..., |{z}
n ·G = 0
sehr groß
n ist eine Primzahl und G, 2G, ..., nG = 0 ist die gesamte Gruppe E(k).
Signaturschlüssel t-zufällig aus 1, ..., n − 1, Verifikationsschlüssel ist P = t · G
Standard FIPS 186-3 → finde den Fehler
To do: ende einfügen
p, g Generator, g p−1 ≡ 1 mod p, g
p−1
x
. 1 mod p
Geheimer Schlüssel x,
öffentlicher Schlüssel y = g x mod p.
k (gk , m · yk ) = c
Parallel bei elliptischen Kurven: G geheim: x, öffentlich: Y = x · G
(k · G, m · k · Y)
DSA, auch bekannt als DSS: FIPS-186.
Primzahl p (hat z.B. 1024 Bit, im Standard variabel), so gewählt, dass p − 1 einen Primteiler der
Länge 160 Bit enthält. q|p − 1 mit |q| = 160 Bit
Ausserdem: Es gibt einen Generator g mit der Eigenschaft gq ≡ 1 mod p. Das findet man,
indem man einen h Generator in mod p auswählt und g = h
p−1
q
, h p−1 ≡ 1 mod p ausrechnet.
x geheimer Signaturschlüssel mit 160 Bit, g x mod p ist der öffentliche Schlüssel.
Signaturerstellung: Nachricht M. Hashwert h(M) = H ausrechnen. Generiere Zufallszahl k mit
160 Bit (k ∈ 1, ..., n − 1) und berechne
To do: neu
k · G = (x, y) r = x mod n
98
s = h−1 · (h + tr) mod n
(r, s) ist die Signatur
To do: ende neu
r = (gk mod p) mod q und s = (k−1 (H + x · r) mod p) mod q. r und s sind Exponenten für
mod p, werden aber nochmal mod q genommen um Platz zu sparen. (r, s) wird die Signatur
werden. (s . 0 mod q, r . 0 mod q)
Signaturverifikation: Berechne w = s−1 mod q
u1 = H · w mod q
u1 = H · w + i · q
u2 = r · w mod q
Berechne
gu1 · yu2
−1
≡ gH·s · g x·r·s
−1
−1
−1
≡ gH·k(H+x·r) · g x·rk(H+x·r)
≡ gH·k·(H+x·r)
−1 +x·r·k(H+x·r)−1
−1
≡ gk·(H+x·r)·(H+x·r)
≡ gk
mod p
?
Prüfe also ob (gu1 · yu2 mod p) mod q ≡ r
Die Signatur zu M ist (r, s) mit r und s haben 160 Bit, so dass man 320 Bit Signatur hat (kleiner
als die 1024 Bit Signatur von RSA).
Um den geheimen Schlüssel zu bestimmen, muss man den diskreten Logarithmus mod q berechnen und das gilt als schwer.
5.6.5 ECDSA - DSA mit Elliptischen Kurven
K - elliptische Kurve mit Punkten mod p
G - Generatorpunkt, G hat Ordnung q [q · G = 0], q Primzahl
x - Restklasse mod q, Y = x · G
r = [(k · G)1 ] mod q (→ 1. Koordinate mod q), s = k−1 (h + x · r) mod q; [u1 · G + u2 · Y]1
?
mod q ≡ r
700 Bit für alle Parameter
99
To do: neu
ECDS
DSA
Generator
G
gq = 1 mod p
g
dA = [1, q − 1]
zufällig
Signatur
PA = dA · G auf E
pA = gdA mod p
k ∈ [1, q − 1]
r = x mod q
r = (gk mod p) mod q
s = k−1 · (h + dA · r) mod q
h ist genauso lang wie q (gleiche Bitlänge)
h sind die linken Bits von H(n)
(Bem.: RSA ist bei Elipt. Kurven nicht einsetzbar, deshalb ist DSA eine gute alternative.)
link: draft-lochter-pkx-brainpool-ecc-03 - eine art RFC zu Brainpool
openssl ecparam -name brainpoolP256r1 -param_enc explicit -noout
n
o
E = (x, y) y2 = x3 + Ax + B mod p
Dann ist G = 04x....... (in einer Prüfung wäre interessant zu wissen, was das führende Byte
bedeutet und welche Varianten es gibt)
openssl ecparam -name brainpoolP256r1 -genkey
-param_enc explicit -noout > ec.key
(pub - öffentlicher Punkt)
openssl dgst -sha256 -sign ec.key ec.key > ec.sig
xxd -p ec.sig
openssl asn1parse -i -in ec.sig -inform DER
Man erhält die beiden Integers r und s.
(Bem: bei Eliptischen Kurven ist die Bitlänge kürzer, da Algorithmen höhere komplexität als so
100
haben)
(Hausaufgabe: erzeuge zwei Kurven (512Bit - Brainpool bzw. 521 NIST) mit anderen Hashfunktionen (md,ripemd, whirlpool...); Signatur (r,s); )
(Bem.: siehe Wikipedia El. C. DSA: r=0 Abfrage, weil sonst dA keine Rolle spielt, s= 0 Abfrage,
weil man sonst mit −z = r · dA mod q den geheimen dA ausrechnen kann)
[Spickzettel zur HA:
h-linke Bits des Hashwertes
n1 = h · s−1 mod q
n2 = r · s−1 mod q
V = n1 · G + n2 PA = (x, y) r = x mod q
v = gn1 · pn12 mod p
r = v mod q?
(r → 0, 1 jeweils)
h · s−1 · G + rs−1 PA = h(k(k + dA r)−1 · G + r(k(h + dA r)−1 )dAG = (hk + rkdA )(h + dA r)−1G = V
= k (h + rdA ) · (h + dA r)−1 G
|
{z
}
=1
= k·G
]
Magma:
p:=StringToInteger(’....’,16);
a:=StringToInteger(’....’,16);
b:=StringToInteger(’....’,16);
IntegerRing(p);
E:=EllipticCurve([K!a,K!b]);
G:=E![K!StringToInteger(’...1.Hälfte Generator..’,16),
101
K!StringToInteger(’..2.Hälfte Generator..’,16)];
Jetzt kann man rechnen:
q*G eq E!0;
true
——–
q*G;
(0:1:0)
———
Kq:=IntegerRing(q);
dA:=1+Random(q-2);
PA:=dA*G; \#Prüfung ob ungleich Null fehlt noch
h:=K!12121212121212121212121212121;
k:=1+Random(q-2);\#+1,damit keine Null rauskommt
X:=k*G;
x:=X[1];
r:=(IntegerRing()!x) mod q;
s:= (Kq!k)ˆ(-1) * ((Kq!h)+ r *dA)
r,s;
\#Verifikation:
u1:=h*(Kq!s)ˆ(-1);
u2:=r*(Kq!s)ˆ(-1);
102
Y:=(IntegerRing() !u1)*G+( IntegerRing() !u2) *PA;
Y;
((IntegerRing() !Y[1]) mod q) eq r;
=⇒ siehe Verzeichnis
Prüfen ob Openssl gut gerechnet hat.
OpenSSL:
wie erzeugt man den öffentlichen Schlüssel openssl ec -in ec.key -pubout
openssl ec -in ec.pub -pubin -text -noout
-pverify
To do: neu-ende
To do: neu-20090617
Bem.: Attributes muss die leere Menge sein und darf nicht weggelassen werden.
SHA1 nur noch zur Unterscheidung benutzen.
5.7 Widerrufen von Zertifikaten
siehe rfc5280 S.53
Erste Sperrliste:
Ist eine Liste in der die Nummern der gesperrten Zertifikate stehen.
Beispiel CA erstellen
perl ˜/opt/openssl-1.0.0-beta2/apps/CA.pl -newca
...
103
Zertifikat für den Nutzer erstellen:
perl ˜/opt/openssl-1.0.0-beta2/apps/CA.pl -newreq
...
Signieren:
perl ˜/opt/openssl-1.0.0-beta2/apps/CA.pl -xsign > ay.pem
...
Man kann noch weitere Zertifikate erstellen, allerdings wird dann der pem Key gelöscht. Man
kann dann feststellen, dass die Seriennummer nur um eins erhöht wird. Man kann auch openssl ca -gencrl
benutzen und dabei die Seriennummer selber angeben.
openssl crl -text -in crl1.pem -noout
Zertifiziert wird nur der Teil zwischen Certificate Rev List bis No Revok. Cert. Da dieser Teil
sehr klein ist, ist es recht schwer Kollisionen mit SHA1 dafür zu konstruieren.
Dann gibt es noch Informationen wann es die nächsten Updates gibt (Last Update, Next Update
(optional?)). Alte Sperrlisten bleiben aber Gültig, die neuen gelten nur zusätzlich.
Zertifikat ungültig machen:
openssl ca -gencrl -out cr13.pem -revoke demoCA/certs/F8C...85.pem -crl_reason keyCo
aktualisieren:
openssl ca -gencrl -out cl4.pem -crlhours 12
Nun nachsehen mit:
openssl crl -text -in crl4.pem -noout
To do: neu-ende
104
5.8 Was es noch so gibt
5.8.1 blinde Signaturen
Gut für anonymes digitales Geld. Normalfall: Bank kriegt digitalen Scheck, belastet das Konto
und schickt einen von ihr signierten Scheck zurück. Problem: Wenn derjenige der den Scheck
später einlösen will zur Bank geht kann diese den Scheck zum Aussteller zurückverfolgen.
Mit anonymen Signaturen: Aussteller erzeugt viele (zum Beispiel 1000) unterschiedliche Schecks,
mit je einer Zufallszahl und dem gleichen Betrag, aber ohne Name, Kontonummer, etc. Diese
1000 sendet er verschlüsselt an die Bank. Die Bank sucht sich zufällig (das ist wichtig) 999
davon aus und fordert für diese den Schlüssel an. Die Bank entschlüsselt diese Schecks und
überprüft ob überall der gleiche Betrag drinsteht. Wenn ja, dann ist davon auszugehen dass auch
der auf den gleichen Betrag läuft. Das Konto wird entsprechend belastet und der Scheck wird
blind (also ohne hineinzusehen) signiert und dem Aussteller zurückgeschickt. Der packt den
Scheck aus (wobei die Signatur gültig bleibt) und hat jetzt einen von der Bank signierten digitalen Geldschein den die Bank nicht mehr zurückverfolgen kann.
5.8.2 anonyme Signaturen
Beispiel: Elektronische Wahlen, wo man nicht möchte, dass man weiß, wer es unterschrieben
hat.
6 Zertifikate
To do: neu-20090520
m → Signatur und Verifikation
m0 → Signatur und Verifikation
Vertrauen in den öffentlichen Schlüssel
Schützen den Schlüssel durch Prüfwert, den Prüfwert Schützen wir durch eine Signatur. Vertrauen eines Schlüssel überträgt sich an einen anderen. Das ganze scheint sich im Kreis zu drehen.
Aber es handelt sich um einen Graph. (Der Graph muss nicht transitiv sein - A vertraut B,
B vertraut C aber A vertraut nicht unbedingt C.) Z.b. Baum mit Wurzel (PKI), dann gibt es
105
vertrauens-Normen, die den Ebenen eines Baumes entsprechen. Die andere Variante ist das PGP
Web of Trust, bei dem der Baum ungeordneter ist und eine Art Vertrauensbereiche hat.
Dass eine Zertifizierungsstruktur funktioniert, braucht es klare Regeln für den Umgang mit Zertifikate.
Standards:
ANSI X509
X500
openssl internet Profil
RFC 5280 (alt: 3280, 2459)
Definition:
Zertifikat bindet (durch Signatur) einen öffentlichen Schlüssel an einen Namen
(Subjekt).
(siehe rfc5280 S.16 - Certificate::= SEQUENCE ... und TBSCertificate...) (in TBSCert... erscheint ’signature’ recht früh damit schon mit dem Hash-Algorithmus begonnen werden kann,
aber warum steht in Certificate dann nochmal signature? -Bessere Ordnung?)
Zertifikat bei CA-cert runterladen und dann mit openssl ansehen:
openssl x509 -in class3.crt -text -noout
openssl asn1parse -i -in class3.crt
Zur ausgabe des ersten (siehe auch rfc5280):
Version: es gibt momentan 3 Versionen
Serial Number: ist ein Integer, kann so groß sein, das man nicht mehr in den Hash-Block mehr
kommt (bis 20 Byte geht)
Bundesnetzagentur.de 15549.pdf sagen dass Serien Nummern mindesten 20 Bit Entropie enthalten sollen, damit SHA-1 bis 2010 benutzt werden kann. (’Qualifizierte Signatur’)
To do: siehe 6.0.6 Gültigkeit
validity: Wird oft als Gültigkeitszeitraum übersetzt, was aber nicht ganz richtig ist, da nur angegeben wird, wann das Zertifikat nicht gültig ist. Besser wäre ’nicht Gewährleistungszeitraum’.
106
Die validity gibt (nach dem Standard) den Zeitraum an, in der die CA gewährleistet, aussagen
über den Zustand des Zertifikats zu geben. (Gültig ODER nicht Gültig - deshalb muss das Zertifikat also nicht unbedingt gültig sein)
To do: neu-ende
To do: neu-20090527
Bemerkung: In der Objects.txt findet die Object-Identifier die OpenSSL kennt.
To do: neu-20090527-ende
Signatur: Anwendung eines Schlüssels. Ob der Signaturersteller eine bestimmte Person ist, ist
damit nicht klar. Immer gleichzeitig Authentizität des Schlüssels prüfen.
Dazu gibt es zwei Möglichkeiten:
1. Anarchie = Web of Trust (Beispiel: PGP)
2. Vertrauenswürdige dritte Instanz: Certification Authority, CA bzw. ZDA (Zertifizierungsdiensteanbieter). Stellt ein Zertifikat aus, das ist ein elektronisches Dokument, welches
eine Identität einem Schlüssel zuordnet.
Zertifikat: (Name, Schlüssel, . . .) und Signatur
Problem: Im Zertifikat steht Name, Schlüssel usw. und daran hängt eine Signatur. Gegeben Nutzer Alice mit Zertifikat, darüber gibt es die CA1, die ihre Signatur zertifiziert CA1 hat selber ein
Zertifikat mit einem Namen, Schlüssel usw. und daran hängt wieder eine Signatur. Das Problem
verschiebt sich immer weiter nach oben. Man bekommt eine Zertifikatshierarchie und benötigt
einen aufgeblähten Riesenbaum mit einer Weltwurzel. Im täglichen Leben haben sich 3-stufige
Zertifikatshierarchien bewärt. Root signiert seine eigene Signatur. Vertrauen in Authentizität der
Nutzerschlüssel ist für alle Nutzer gleich. Es bestimmt sich ausschließlich durch die Authentizität des Schlüssels des Root CA. Das Vertrauen in die Root CA verteilt sich auf die Nutzer.
6.0.3 X509
X509, mittlerweile bei ISO. RFC 3280: X509 Certificate and Certificate Revocation List (CRL)
Profile. Abschnitt 4.
Version: X509v3. Version 1 enhält keine Erweiterungen.
Serial Number: In der Regel 20 Byte, muss immer eindeutig sein.
107
Signaturverfahren: für das Zertifikat, muss am Anfang (im ersten Block) stehen damit das Hashen schon begonnen werden kann.
Herausgeber: Name(eindeutig): C=Country, O=Organisation, CN=Common Name, SN=Surname,
...
Validity: Gültigkeitszeitraum, der Zeitraum indem die CA Gültigkeitsinformationen über das
Zertifikat bereitstellen will/wird/muss
Inhaber: Name (eindeutig im Bereich der CA) zur Person, also stabile Daten: Seriennummer,
Versicherungsnummer, etc.
Schlüsselinformationen
Erweiterungen
Darunter die Signatur
In RFC 3280 steht, dass nach dem 31. Dezember 2003 alle Zertifikate UTF-8 kodiert sein
müssen.
6.0.4 Erweiterungen
Man kann bei Erweiterungen festlegen ob diese Critical oder nicht sind. Critical ist sowas wie
eine Vorschrift, nicht Critical ist sowas wie eine Information. Kritische Erweiterungen müssen
immer ausgewertet werden, wenn ein Programm sie nicht versteht darf es das Zertifikat nicht
verarbeiten.
To do: neu
Per default auf false, ist außerdem optionales Argument. Wenn nicht critical dann ist es nur eine
Information. Also critical muss man lesen und verstehen, nicht critical sollte man lesen, wenn
man sie versteht sollte man sich daran halten.
To do: neu ende
Basic Constraints
To do: neu
Sagt ob es Zertifizierungsinstanz ist, oder eine Endnutzer Instanz ist und in welcher Ebene es
sich befindet.
To do: Diagramm basteln
108
Ein interessantes Beispiel (goya.crt) findet man bei der Rechnerbetriebsgruppe.
To do: neu-ende
CA Siginalisiert ob es ein CA-Zertifikat ist (TRUE) oder nicht (FALSE). D.h. ob das Zertifikat
berechtigt ist, weitere Unterzertifikate auszustellen.
To do: neu
Per default false, es müsste also nicht jedesmal CA: FALSE angegeben werden.
To do: neu-ende
PATHLEN Beschränkt die Pfadlänge. Pathlen=0 heisst dass das Zertifikat zwar Nutzerzertifika-
te ausstellen kann, aber keine weiteren CA-Zertifikate. Ist immer als Critical markiert.
Subject Key Identifier und Authority Key Identifier
Nicht kritisch. Beschreiben die verwendeten Schlüssel über Hash-Werte, zum Beispiel SHA-1 über den Schlüssel.
Kritisch (sollte kritisch sein, z.b. bei GOYA nicht). Ist ein Bitstring der die Verwendung des Schlüssels angibt. Für eine CA also zum Beispiel nur KeyCertSign. NonRepudiation ist eigentlich für die Dokumentsignatur (content commitment). DigitalSignature ist für
Authentisierung oder allgemeine Signaturmechanismen. Die beiden möglichst exklusiv setzen.
Key Usage
To do: neu
Nicht bei Endnutzerzertifikaten nötig.
To do: siehe rfc5280 - KeyUsage -HA lesen
Merkmale :
(0) DigitaleSignatur zur Authentifizierung (hat keine Auswirkungen auf spätere Zeiträume?)
(werden zu dem aktuellen Zeitpunkt geprüft)
(1) (ab X.509v4) Inhaltsbindung[contentCommitment] (z.b. Nichtabstreitbarkeit ?) (jetzt noch
[nonRepudiation]) (werden zu dem Zeitpunkt zu dem sie erstellt worden sind geprüft)
(0) und (1) sind Endnutzerinformationen
nur ent-/verschlüsseln, Schlüssel zum verschlüsseln von Zertifikaten geignet
109
keyCertSign==TRUE - wenn man nur Zertifikate damit signieren möchte (brauch man bei CA
Zertifikaten, eigentlich sollte nur eines der Bits gesetzt sein) ansonsten sollte digitalSignature
gesetzt werden
Key usage z.B. A0=10100000 (Erste und dritte gesetzt) oder z.B. 88=10001000 (erstes und
fünftes gesetzt).
authority information
Nicht kritisch. Feld in dem Daten des Herausgebers abgerufen werden
können.
Benutzt das OCSP-Online Certificate Status Protocol. (gibt eine URI an wo man die Informationen erhalten kann - später mehr)
X509v3 Certificate Policies
ASN1 Strucktur siehe rfc5280 S. 33.
System von Regeln für die Ausgabe von Zertifikaten, sowie den Betrieb der Zertifizierungstelle.
Nutzer kann sich über die Hirarchie der CA informieren (wichtig für den Vertrauensaufbau).
CPS - Certificate Policy Statement und dann zwei möglichkeiten cPSuri (uri wo die Information
zu finden ist) oder userNotice (Freitext).
Bsp. http://nasaca.nasa.gov/nasacp.html, dort findet man eine CPS.
Wenn der Regelsatz dem CA Zertifikat zugeordnet ist (Bindung z.B. durch Root), ist es besser
als wenn es nur dem EndNutzer Zertifikat zugordnet ist (Bindung nur durch die darüberliegende
CA).
Kurzinformationen mit der man einen Schlüssel identifizieren kann.
Für Endnutzer ist der Authority Key Identifier ein Bezeichner mit dem das zugöhrige CAZertifikat zu finden ist. Kann enthalten:
Authority Key Identifier
KeyIdentifier - Schlüssel ID
GeneralNames - Herausgeber Seriennummer
CertificateSerialNumber
Subject Key Identifier - SKI Schlüssel ID, hilft bei der Unterscheidung, sollte eine möglichst
eindeutige Nummer sein, da aber nicht genau festgelegt wird ist die SKI nicht für Überprüfungen
geeignet.
110
IP Adresse, URI, Email Adresse (hat das ’at’ Zeichen, welches
in kein Datentyp passt, weshalb sie hierher (oder in den Issuer Alt Name) gehört, soll als
rfc8224Name gespeichert werden (da dieser nicht groß klein sensitiv ist))
Subject Alternative Name
To do: neu-ende
6.0.5 Erzeugung
To do: neu
Bei OpenSSL gibt es zwei möglichkeiten, mit Perl Script
perl ˜/opt/openssl/apps/CA.pl -newca
openssl x509 -text -nout -in cacert.pem
openssl req -text -nout -in careq.pem
Diese Requests folgen dem Standard PKCS 10 - rfc2986.
openssl ans1parse -in careq.pem ?
Attributes: [0] - Contextabhängiges Tag (nur an diesem Ort gültig) Codiert als A0, denn Contextabhängige tags fangen mit 10... an, im Gegensatz zu Universaltags die mit 00... anfangen
(Beispiel für Contextabhängige Tags siehe auch bei AuhtorityKeyIdentifier)
Im Request ist Set of Atritbute NICHT optional (aber kann leer sein)
To do: neu-ende
Wie kommen wir eigentlich zu Zertifikaten? Zertifikate kommen von einer CA, also muss man
zuerst ein CA-Zertifikat erstellen.
Request: Ich möchte ein Zertifikat haben. PKCS#10/RFC2986
openssl req
openssl req -new -x509 erzeugt gleich ein Zertifikat
openssl req -new -newkey rsa:1500 -days 40 -out user.req ein neuer Schlüssel und
ein Request. Der Request enthält die Informationen des Antragsstellers, den öffentlichen Schlüssel,
ein Challenge-Passwort (von der CA festgelegt) und eine Signatur über diese Daten.
111
openssl x509 -req -CA .. -CAkey .. -out .. -days 40
-in user.req -CAcreateserial -out user.x509
-extensions usr_cert -extfile ....openssl.cnf wichtig, um v3-Zertifikate zu erzeugen
6.0.6 Gültigkeit
Der Gültigkeitszeitraum‘ (Validity) im Zertifikat ist der Zeitraum über den sich die ausstellende
’
Instanz verpflichtet etwas über die Gültigkeit des Zertifikats auszusagen.
CRL Certificate Revocation List
OCSP Online Certificate Status Protocol
Sperrlistenformat auch in RFC 3280 Abschnitt 5 als X.509-Variante festgelegt.
OCSP version 1, RFC 2560
To do: neu
Man kann dass conf bearbeiten.
Übungsaufgabe ein Zertifikatsrequest mit eigen Daten erstellen und zu zertifizieren.
To do: einsortieren:
Die CA schmeißt eventuell Daten des Request raus.
To do: neu-ende
To do: neu-20090624
Sperrlisten
Version
Signatur
112
Enthalten:
Herausgeber
Last/Next Update
Sperrlisten Nummer (sollte monoton wachsen)
Liste der gesperten Zertifikate(jeder Eintrag enthält ein Integer, eine Zeit und evt. CRLEntryExtension(CRLReasonCode siehe rfc5280 5.3.1))
Bemerkungen:
Sperrlisten sind im DER-Format ( ..openssl... -inform DER)
(Erweiterungen enthalten immer OID Octet-String)
Zu CRLEntryExtension: CRLReason Code (6) (certificateHold-schwebend gesperrt) und (8)
(removeFromCRL-kann/wurde wieder entsperrt werden) sind besonders und sind eher nur für
Authosierung sinnvoll.
Sperrlisten nehmen in der Praxis erhebliche größen ein
CRLEntryExtension wird von der Bundesnetzagentur nicht benutzt.
RFC5280 5.3.2: sperrdatum (revocation date) darf nicht vor dem Zeitraum der vorherigen CRL
liegen, sonst ist es in der vorherigen Liste Gültig... ??? (ansehen)
Aufbau des Pfad zum Vertrauensanker (RFC 5280 S.72): Das beschriebene Prüfverfahren ist
nicht normativ vorgeschrieben, es reicht wenn die Funktion gleich ist
http://www.bundesnetzagentur.de/media/archive/1343.pps
Kettenmodel benutzt den Erstellungszeitpunkt (nicht Gewährleistungs-Beginn) (Folie3) ...
http://www.bundesnetzagentur.de/enid/85f55115e236d80fc18329992037142d,0/FAQ/
Antwortss4_wp.html
To do: neu-ende
To do: 20090701-fehlt
113
6.1 Praktische Ausschlachtung von kryptografischen Algorithmen mit
S/MIME und PKCS#7
Root-Zertifikat erzeugen:
openssl genrsa 1200 > cakey.pem
openssl req -x509 -new -key cakey.pem -config ./openssl.cnf > ca.cert (selbstsigniertes neues root Zertifikat mit eigenem Config Script)
Root-Zertifikat anschauen:
openssl x509 -in ca.cert -text -noout
Nutzer der eigenen CA erstellen:
openssl req -new -config ./openssl.cnf -out user.cert Erstellt mehrere Dateien,
auch privkey.pem
Zertifikat erstellen:
openssl x509 -req -in user.req -CA ca.cert -CAkey cakey.pem -CAcreateserial\
-out user.cert -extfile ./openssl.cnf -extensions usr_cert (Zertifikat für user
mit Extenstions Version 3 statt Version 1)
Senden einer signierten Nachricht (Nachricht in Neu.txt):
openssl smime -sign -signer user.cert -in Neu.txt -inkey privkey.pem \
-out neu.smime -text
Erzeugt Datei neu.smime mit Nachricht und Signature, -text erzeugt den Eintrag für den Content Type vor der Originalnachricht in neu.smime
Umwandeln der S/MIME Nachricht in PKCS7 Nachricht:
openssl smime -pk7out -in neu.smime -out neu.pk7
Das gesamte (ohne Inhalt der Nachricht, eigentlich nur die Signatur) S/MIME Dokument wird
in eine PKCS7 Struktur eingebunden
Anschauen mit:
openssl asn1parse -i -in neu.pk7
Zertifikate ausgeben mit:
openssl smime pkcs7 -in neu.pk7 -print_certs -noout
Zertifikate anschauen mit:
openssl smime pkcs7 -in neu.pk7 -print_certs -noout -txt
Verifizieren:
openssl smime -verify -in neu.smime -CAfile ca.cert
Verschlüsseln:
114
openssl smime -encrypt -in Neu.txt -out neu.smime -text user.cer
Nachricht ohne Signatur verschlüsselt
Entschlüsseln:
openssl smime -decrypt -in neu.smime -text -recip user.cer \
-inkey privkey.pem
Für die Einbindung in Browser:
openssl pkcs12 -export -name Annie -inkey privkey.pem \
-in user.cert -out user.p12
Um auch das CA Zertifikat mit einzubinden:
openssl pkcs12 -export -name Annie -inkey privkey.pem \
-in user.cert -out user.p12 [-certfile ca.cert -CAfile ca.cert -chain]
Private Schlüssel auspacken: openssl pkcs8
6.2 PKCS
PKCS Public Key Cryptography Standards
1 RSA
3 Diffie-Hellman
5 Cryptography mit Passworten
6 Zertifikate
7 Cryptographic Message Syntax
8 private Schlüssel
9 Attributtypen
10 Zertifikatsrequest
11 Cryptographic Token
12 Personal Information Exchange
13 Elliptische Kurven
15 Chipkarten, Token: Formate
6.2.1 PKCS#7: 1.5 November 93 RFC 3852
To do: neu-20090708
CMS
Email (SMIME)
115
XML Signaturen XMLDSIG; XMLENC
Dokument → signiertes Dokument
openssl genpkey -algorithm rsa -pkeyopt rsa_keygen_bits:300 — openssl -chek -text zu kleine Werte (¡256) für den Schlüssel werden nicht akzeptiert (Wert ist immer noch etwas
klein). Aber die Ausgabe ist nicht ganz korrekt.
openssl genpkey -algorithm rsa -pkeyopt rsa_keygen_pubexp:1
ist leider möglich
6.3 CMS(Cryptographic Message Syntax)
rfc3852
SignedData:
• Version
• Hash Algorithmus
• gekapselter Inhalt
• Certifikat Liste
• Widerrufungsliste (Sperrinformationen)
• ...
• Signer Infos (Signaturen, davon kann es mehrere geben, elektronische Signatur nach dem
Signaturgesetz, Signer Info enthält selber noch einmal einen Signaturblock - der als Digitale Signatur aufgefasst werden kann)
–
–
–
–
–
–
Version
Id
Attributes
Algo
sig Value
...
• Signer Id
• Signed Attributes (z.B. Zeit, Ort, Message Digest) Die Signatur dieses Blockes wird erstellt, indem der Hash Wert (nur des Blockes) signiert wird. Wenn es signed Attributes
gibt, sind also außerdem Hash Wert des Dokuments und Inhaltstyp(Contenttype) im Signed Attributes enthalten und erst dann wird der Signed Attributes Block signiert. Es wird
jeweils er Hash-Algorithmus verwendet der oben genannt wird.
116
Außerdem Signing Certificate
• ...
Frage ist wo wird der Wert Signiert, der sagt welcher Hash-Algorithmus verwendet wird? Wenn
nicht könnte man eventuell den Algorithmus austauschen?
Man könnte den Hash-Algorithmus als SignedAttribute einfügen.
To do: neu-ende
CMS (Cryptographic Message Syntax) Beschreibung des Formates mit dem man Krypto-
nachrichten erstellen kann
Kryptographische Nachricht Struktur, vorne Bezeichner, hinten Daten. Daten = irgendwas,
spannend: Welche Typen gibt es eigentlich.
Signed-data Content-Type Was jetzt kommt sind signierte Daten Liste der unterstuetzen Has-
hfunktion, dann gekapselter Inhalt, dann eine Liste von Zertifikaten (optional), optional
Sperrlisten, dann Signaturbloecke (SignerInfo)
SignedData ::= SEQUENCE {
Versionsnummer,
Liste der unterstützten Hashfunktionen,
Ursprüngliche Nachricht selbst,
Liste von Zertifikaten Optional,
Sperrlisten Optional,
Signer Infos
}
SignedInfo ::= SEQUENCE {
Versionsnummer,
Signer Identifier (Wer der Signierer eigentlich gewesen sein soll),
Hashfunktionen, die bei der Signatur verwendet wird,
Signierte Attribute,
Verwendete Signaturalgorithmus,
Signaturwert,
Unsignierte Attribute
}
SignerInfo ::= SEQUENCE {
Versionsnummer,
Signer Identifier (Wer der Signierer eigentlich gewesen sein soll),
Bezeichner des Hashalgorithmus mit dem die endgültige Signatur erstellt wird
Signierte Attribute Optional,
117
Signatur Algorithmus,
Signature SignatureValue,
Unsigned Attributes Optional
}
SignerIdentifier ::= SEQUENCE {
issuerAndSerialNumber,
subjectKeyIdentifier (Eindeutiger Hinweis, wer der Aussteller ist)
}
SignerInfo Signaturblock, der eine Datenstruktur fuer eine Signatur bereitstellt. Steht drin: Ver-
sionsnummer, SignerIdentifier, verwendeter Hash-Algorithmus, dann signierte Attribute,
verwendeter Signaturalgorithmus, Signaturwert, unsignierte Attribute
SignerIdentifier Aussteller und Seriennummer, oder Schluesselidentifier (subjectKeyIdenti-
fier)
Signierte Attribute Sammlung von Attributen die signiert sind. Was dabei sein sollte: erstes
Attribut Content-Type, wenn die signierten Daten nicht nur Rohdaten sind, sondern gekapselte Daten eine s bestimmten Typs. Ein weiteres nuetzliches Attribut: Message-Digest.
Dann Signing-Time.
Content-Type Object-Identifier, der einen bestimmten Typ impliziert
Message-Digest Hash der aus den Daten ausgerechnet wird. Als Octet-String
Signing-Time Zeit von der behauptet wird dass die Signatur zu dieser Zeit geleistet wurde.
Signatur Es werden die signierten Attribute signiert, dort ist auch der Hash des Dokuments
als messageDigest enthalten. Wenn keine signedAttributes existieren wird das Dokument
direkt gehasht.
Weitere sinnvolle signierte Attribute:
Commitment-Type Was bedeutet die Signatur? zum Beispiel virtuelle Poststelle, Eingangs-
stempel; Auslieferung, Einschreiben, Urheberschaft, gelesen, ... Zeitstempel (spezielle
Signatur eines authentischen Zeitservers) ist eine Information, dass das Dokument vorher existiert hat.
Signing Certificate Beschreibt, mit welchem Schluessel zu welchem Zertifikat ist unterschrie-
ben worden/welches Zertifikat moechte der Signierer zur Ueberpruefung verwendet haben. Austausch des Zertifikats fuehrt zu anderer Urheberschaft, ist ein realer Angriff.
Verhindert die Urheberschaft auszutauschen. (rfc2634 S. 46) Folge mit: Zertifikats Hash,
IssuerSerial(Herausgeber und Seriennummer) (leider ist da SHA1 als Algorithmus festgelegt)
in rfc5035:
Folge mit Hash-Algorithmus (optional, default ist aber SHA256), Zertifikat Hash, Issuer
Serial (Nun Hash als Octet String)
Da der Wert des Hash Algorithmus optional ist, ist diese Variante rückwärtskompatibel.
118
Signing Location Ort an dem die Signatur geleistet wurde.
Weitere nuetzliche unsignierte Attribute:
Zeitstempel ist eine Information, wann die Signatur existiert hat. Hash über die Signatur, Time,
Server, davon Signatur.
not after Information für die Signatur
Countersignature Zweite Signatur (Gegenzeichnung). Signaturblock über eine andere Signa-
tur.
(Mitsignatur, Bestätigung eines signierten Dokuments, wichtiges Feld für Mehrfachsignaturen)
Hashwert des signature Feldes, (3. Hash Wert), nicht alle in einander gekappselt, sonder
ansammlung von Signaturen
Archiv Zeitstempel neuer Hash-Algorithmus, signiert Dokument, alle Signaturen, alle Attri-
bute (signiert, unsigniert)
Damit kann mann folgendes machen:
2009
2001
Dokb
RS A512
S HA1
S HA256
S HA512
/ S ignatur
^c
/ t1
Y
, t2T
, at1
2010
at2
at3
Für XML: XML-DSIC, XML-ENC
7 Wichtige Neuerungen bei den Versionsänderungen
• Von 0.9.8 zu 0.9.9: Verbesserungen bei den Extensions von Certificate Revocation Lists
• Von 0.9.7h zu 0.9.8: UTF8-Support für das ca-Kommando
• SHA1 ist nun default-Hash-Algorithmus, statt MD5
• Patentierte Algorithmen RC5 und MD2 müssen beim Kompilieren extra angegeben werden
• Neue FIPS 180-2 Algorithmen, SHA-224/-256/-384/-512 wurden implementiert
119
• Neuer Parameter -selfsign für das ca-Kommando
• IPv6 Support bei den Zertifikatserweiterungen
• Ausweitung der Eliptischen Kurven Bibliothek
8 OpenSSL hintergehen
8.1 die eine Primzahl ganz klein erzeugen
• Öffnen einer Datei in genrsa: crypto/rsa/rsa\_gen.c
• Ändern den Teil “/* generate p and q */” so daß die eine Primzahl 10bit lang ist(
bitsp=10 )
• Wir erzeugen einen neuen rsa key: openssl genrsa -out rsaweak.pem 2048
und erstellen hierdurch eine Primzahl mit 10 bit, die andere zufällig (also so in etwa
2038bit)
• Wir schauen uns den key an: openssl rsa -in rsaweak.pem -text -noout
und sehen: die eine Primzahl ist 35879, die andere hat 2046 bit Länge. Das kann man
lecker faktorisieren.
• Öffnen crypto/bn/bn\_prime.h: die Zahl kommt durch den kleinen Primzahltest durch:
dieser geht nur bis ca. 17000
8.2 beide Primzahlen nah beieinander
• Und wieder in rsa\_gen.c (Zeile 136 in der do-while-Schleife hinter degenerate):
• BN\_copy(rsa->q, rsa->p); // wir setzen q gleich p
BA\_add\_word(rsa->q, 20); // wir addieren 20 auf q
for(i=1; !BN\_is\_prime\_ex(rsa->q, 5, ctx, NULL); i++)
BN\_add\_word(rsa->q, 2);
// wir erhoehen q bis zur naechsten Primzahl
• hierdurch erzeugen wir zwei Primzahlen, die sich enorm ähnlich sind (wieder mit obigen
Kommandos) Der Angreifer kennt in diesem Fall den Exponenten, damit ist das Verfahren
völlig unsicher.
8.3 Vorschrift des BSI
√
0.1 ≤ |log10 p − log10 q|, also p √
>10 2 ∗ q.
Das kann man aber mit q =10 2 ∗ p im Quellcode umgehen.
120
8.4 Programmierung: Zufallszahlenerzeugung und andere nette features
Die “callback” Funktion gibt den Fortschritt bei Suche nach p und q als Punkt (Fermat Primzahlentest) und Plus (Miller-Rabin-Test) aus.
Datentyp/Struktur zum Speichern der auftretenden großen Zahlen Binärfeld: BIGNUM
p ist unsigned char*
p = BN\_bn2hex((RSA *)pub\_rsa)->n); // Zum Ausgeben eines BIGNUMs
((pub\_rsa)->n).d[...] // einzelne Teile im Datenblock eines BIGNUMs editieren
Zufallszahlen findet man in crypto/rand/\{rand.h, rand\_lib.c, rand.c\}
Diese beiden Kombinationen vor entsprechenden Programmen: i2d oder d2i: intern to data, data
to intern
pub\_rsa = d2i\_RSAPublickey(NULL, \&str, len) (l\"ange von str)\\ Transformiert Binärdaten Zeichenkette in interne public Key Datenstruktur mit ASN.1
S(buf) gibt Speicherplatz frei, überschreibt ihn vorher noch einmal mit Zufallsbytes.
9 Zusammenfassung
• Symmetrische Verschlüsselungsverfahren
– DES
* 64 Bit Blockchiffre
* 16 Runden Feistelnetzwerk mit 48 Bit Rundenschlüsseln
* 56 Bit Schlüssellänge plus 8 Paritätsbits
* XOR, Transformationsfunktion mit S-Boxen
– IDEA
* 8 Runden Feistelnetzwerk mit je 6 · 16 Bit Rundenschlüsseln
* 128 Bit Schlüssellänge
16
16
* XOR, ADD modulo 2 , MULT modulo 2 + 1
– Blowfish
* 16 Runden Feistelnetzwerk
* 32-448 Bit Schlüssellänge
* XOR, Transformationsfunktion mit XOR, CONCAT und viel Schlüsselmaterial
– AES
121
* 128, 192, 256 Bit Blockchiffre
* 10, 12, 14 Runden Feistelnetzwerk
* 128, 192, 256 Bit Schlüssellänge
* Substitution, ShiftRow, MixColumn, KeyAddition
– RC4
* Stromchiffre
* 10, 12, 14 Runden Feistelnetzwerk
* variabele Schlüssellänge bis 2048 Bit
– RC5
* wählbare Blockchiffre (openssl 32 Bit)
* wählbare Runden Feistelnetzwerk (openssl 12)
* wählbare Schlüssellänge (openssl 128 Bit)
– GOST
*
*
*
*
64 Bit Blockchiffre
32 Runden Feistelnetzwerk
256 Bit Schlüssellänge
ADD, ROT, 8 S-Boxen
• Asymmetrische Verschlüsselungsverfahren
– RSA (Verschlüsseln und Signieren)
– Diffie-Hellmann Schlüsselaustausch
– ElGamal Crypto-System (basierend auf DH)
– Rucksackverschlüsseln (gebrochen)
– Merkle Puzzle (viele Nachrichten)
– Rabin Verfahren
erster Teil: mit OpenSSL spielen, zweiter Teil: Konzepte; eine Woche vor der
Prüfung evt. fragen was dran kommen wird; Prüfungstermine: 20.07.2005 oder 04.10.2005
oder nach Vereinbarung
Zur Prüfung
10 Mathematische Techniken
10.1 Multiplikatives Inverses
(nach www.tzi.de/˜hs/Lehre/U9 mathD1.pdf)
122
10.1.1 Behauptung
Seien a, b ∈ Z zwei teilerfremde ganze Zahlen, d.h. ggT (a, b) = 1. Dann existiert ein a0 ∈ Z mit
a0 · a ≡ 1 mod b.
10.1.2 Beweis
Betrachte die Menge {ak mod b|k ∈ N, k ≥ 1}. Da ggT (a, b) = 1 gilt, folgt, dass ggT (ak , b) = 1
für alle k ∈ N mit k ≥ 1. Denn da a teilerfremd zu b ist, so gilt dies auch für alle Potenzen
von a. Daher ist die betrachtete Menge eine Untermenge der endlichen Menge {x mod b|x ∈
Z, ggT (x, b) = 1} und daher selbst endlich. Also kann existiert k1 , k2 mit ak1 ≡ ak2 mod b.
Nehmen wir an, k1 < k2 und setzen n := k2 − k1 , dann gilt ak1 · an = ak2 ≡ ak1 mod b.
Daher folgern wir an ≡ 1 mod b, d. h. an−1 · a ≡ 1 mod b. Also setzen wir a0 := an−1 und die
Behauptung ist erfüllt.
10.2 Kleiner Fermatscher Satz
10.2.1 Behauptung
Der kleine fermatsche Satz, kurz der kleine Fermat, ist ein Lehrsatz in der Zahlentheorie. Er
macht eine Aussage über die Eigenschaften von Primzahlen und wurde aufgestellt im 17. Jahrhundert von Pierre de Fermat. Dieser Satz beschreibt eine allgemein gültige Kongruenz:
a p ≡ a mod p
wobei a eine ganze Zahl und p eine Primzahl ist (die weitere Symbolik wird im Artikel Kongruenz beschrieben). Falls a kein Vielfaches von p ist, kann man das Resultat in die häufig
benutzte Form
a p−1 ≡ 1 mod p
bringen.
10.2.2 Beweis
Der Beweis beruht auf der Tatsache, dass, wenn zwei Zahlen a und b zueinander inkongruent
(modulo einer festen Zahl n) sind, auch die beiden Produkte x · a und x · b inkongruent modulo
n sind für x > 0 und ggT (x, n) = 1.
Denn:
123
sei a , b mod n, n eine Primzahl, a, b natürliche Zahlen. Angenommen:
a·x≡b·x
mod n
für eine natürliche Zahl x mit ggT (x, n) = 1. Dann gibt es eine natürliche Zahl k, so dass:
a·x−b·x=k·n
x · (a − b) = k · n
x = n · (k/(a − b))
Da n eine Primzahl und x eine natürliche Zahl ist, ist k/(a − b) entweder eine natürliche Zahl,
−1/n oder 1/n. Die letzten beiden Fälle widersprechen der Annahme, dass a , b mod n, der
erste Fall widerspricht der Annahme, dass ggT (x, n) = 1. Damit ist die Annahme falsch und es
gilt für x, so dass ggT (x, n) = 1:
a · x , b · x mod n
Im folgenden betrachtet man zum einen die Menge A aller Reste mod p - also alle natürlichen
Zahlen kleiner als p, und zum anderen die Menge B, die diese Reste multipliziert mit a enthält.
Zwei beliebige Zahlen aus A sind zueinander inkongruent modulo p. Aus dem oberen Satz
folgt, dass damit auch zwei beliebige Zahlen aus B zueinander inkongruent sind. Dadurch
ergibt sich, dass das Produkt über alle Zahlen aus A kongruent zum Produkt aller Zahlen aus B
ist:
1 · 2 · 3 · · · · · (p − 1) ≡ (1 · a) · (2 · a) · · · · · ((p − 1) · a) mod p
also
W ≡ W · a p−1
mod p
wobei W das Produkt 1·2·3·...·(p−1) ist. Da es in Restklassenkörpern stets ein multiplikatives
Inverses gibt, kann man diese W dividieren und man erhält:
a p−1 ≡ 1
mod p
10.2.3 Verallgemeinerung
Man kann den kleinen fermatschen Satz zum Satz von Euler verallgemeinern: Für zwei teilerfremde Zahlen n und a gilt:
aϕ(n) ≡ 1 mod n
wobei ϕ(n) die Eulersche Phi-Funktion bezeichnet. Diese hat als Ergebnis die Anzahl der Zahlen zwischen 1 und n−1 welche teilerfremd zu n sind. Ist n eine Primzahl, so ist ϕ(n) = n−1, so
dass man Fermats kleinen Satz als Spezialfall erhält. Mit Hilfe des kleinen fermatschen Satzes
entwickelte Fermat den fermatschen Primzahltest.
124
10.2.4 Praktische Anwendung auf Primzahlen
(p - a, a < p, a , 0)
Wenn gilt a p−1 . 1 mod p ist, dann kann p keine Primzahl sein. (Umkehrung muss nicht
gelten!) Wenn man mit a beiweisen kann das p keine Primzahl sein kann, dann nennen wir a
Kanditat. (Es gibt aber sogenannte Carmichaelzahlen die kein Kandidat ist.?)
To do: nacharbeiten Carmichaelzahlen
Wenn (p − 1) gerade ist p−1
2 = k eine Ganzzahl.
Ist a2k ≡ 1 mod p
(ak )2 ≡ p
(ak − 1)(ak + 1) ≡ 0 mod p
Also wenn p eine Primzahl ist, dann ist entweder ak ≡ 1 mod p oder ak ≡ 1 mod p
Daraus folgt wenn ak . 1 mod p und ak . −1 mod p dann ist p keine Primzahl.
k
k
Somit gilt auch, wenn k gerade ist und a 2 . 1 und a 2 . −1 dann ist p keine Primzahl.
Betrachten p − 1 = 2t · r (r ungerade). Sei a < p und p - a
2
t
In ar , a2r , a2 ·r , . . . , a2 ·r = a p−1 (Reste mod p)
Wenn die Folge nicht mit 1 endet ist p keine Primzahl. Wenn vor der ersten 1 in der Folge
keine 1 steht ist p keine Primzahl.
Wir nennen a einen Zeugen, wenn man mit a beweisen kann, das p keine Primzahl ist.
Jede Zahl p die keine Primzahl ist hat mindestens 34 aller Zahlen a (mit ggT(a, p) = 1) als
Zeugen. (Jeder Kandidat ist ein Zeuge)
Damit ergibt sich der Rabin-Miller-Test: Wähle zufällig ein a < p und teste ob a ein Zeuge
ist. Mit hoher (beliebig genauer) Wahrscheinlichkeit ist p Primzahl.
Bei großen Zahlen werden die Zeugen mehr.
openssl genrsa -out key.rsa 800
Generating RSA private key, 800 bit long modulus
....+++++++
.......................................+++++++
e is 65537 (0x10001)
Generiert den Schlüssel und speichert in ’key.rsa’. Punkte Bedeutet keine kleine Primzahl
Rabin-Miller Test schlägt fehl. Plus ist ein erfolgreicher Rabin Miller Test bei größeren Zahlen
brauch man weniger Tests, da es mehr Zeugen gibt
[...]
10.3 Chinesischer Restklassensatz
(nach www.tzi.de/˜hs/Lehre/U9 mathD1.pdf)
125
10.3.1 Behauptung
Seien m1 , m2 , ..., mr paarweise teilerfremde ganze Zahlen, d. h. ggT (mi , m j ) = 1 für alle i , j,
(i, j ∈ {1, 2, ..., r}), und sei M = m1 · m2 ... · mr . Dann existiert für jede Liste a1 , ..., ar mit 0 ≤ ai <
mi für 1 ≤ i ≤ r genau ein x ∈ Z mit 0 ≤ x < M, welches effizient berechnet werden kann und
für das gilt:
x ≡ a1
mod m1
x ≡ a2
mod m2
...
x ≡ ar
mod mr
Bemerkung: Es ist leicht einzusehen, dass jedes x0 ∈ Z mit x0 = x + k · M für ein k ∈ Z, d. h.
x0 ≡ x mod M, genau dasselbe Gleichungssystem löst wie x. Der Beweis wird zeigen, dass für
ein gegebenes x nur x0 von dieser Form dasselbe Gleichungssystem lösen können.
10.3.2 Beweis
Zunächst beweisen wir die Existenz und setzen dazu Mi := M/mi , daher gilt ggT (Mi , mi ) = 1.
Aus diesem Grund existiert auch ein multiplikatives Inverses Ni ∈ Z mit Mi · Ni ≡ 1 mod mi
(vgl. multiplikative Inverse). Zu beachten ist jedoch, dass für alle j ∈ {1, ..., r} mit i , j stets
Mi · Ni ≡ 0 mod m j gilt. Nun definieren wir x via:
x≡
r
X
ai · Mi · Ni
mod M
i=1
Für jedes i existiert ein v ∈ Z, so dass x sich folgendermaßen darstellen lässt:
x = Mi · Ni · ai + v · mi
Dies gilt, da jedes M j mit j , i mi als Faktor enthält. Offensich erfüllt x also die obigen Gleichungen. x ist das einzige mit 0 ≤ x < M, welches für die gegebene Liste a1 , a2 , ..., ar alle
Gleichungen löst, denn falls x0 und x00 zwei verschiedene Lösungen sind, so gilt x0 − x00 ≡ 0
mod mi für alle i ∈ 1, ..., r d. h. x0 − x00 ist ein Vielfaches aller mi und damit auch von M, da nach
Voraussetzung ggT (mi , m j ) = 1 fur alle i, j ∈ {1, ..., r} mit i , j erfüllt ist. Somit folgt x0 ≡ x00
mod M, d. h. 0 ≤ x0 , x00 < M kann nicht auftreten, und der Beweis ist abgeschlossen.
126
10.4 Square and multiply
Der folgende rekursive Algorithmus berechnet xn für natürliche Zahlen x und n, indem sukzessive der Exponent reduziert wird:
• Falls n = 1: xn = x
• Sonst, falls n gerade: xn = (x2 )n/2
• Sonst: xn = x · (x2 )(n−1)/2
Damit kann xn in O(ln(n)) Rechenschritten (quadrieren und multiplizieren) berechnet werden,
indem in jedem Schritt des Algorithmus der Exponent halbiert wird und höchstens vier Berechnungen ausgeführt werden.
10.5 Montgomery Reduktion (Moduloberechnung ohne Division)
Heute was ganz verrücktes: Modulo-Multiplikation ohne Division
Problem bei RSA und anderen Algorithmen:
m Modul gegeben und g Zahl gegeben und man rechnet aus: ga mod m
Aufwand der Berechnung mit Square and Multiply: Größe des Exponenten in Bits Multiplikationen + gleichviele Modulooperationen
Berechnung von x · y mod m = x · y − (x · y div m) ∗ m
Division aufwendig! Daher Methode dies ohne Division bzw. mit einer schmerzfreien Division
durch eine Zweierpotenz zu tun. Dafür Kosten von Hin- und Rücktransformationen.
Hier Skizze 1
x → X = x · r mod m
y → Y = y · r mod m
X ∗ Y = X · Y · r−1 = x · y · r mod m
Wir berechnen t0 ≡ −m−1 mod r (Preprocessing)
1. x −→ X = x · r mod m
2. y −→ Y = y · r mod m
3. X ∗ Y = X · Y · r−1 mod m
= x · r · y · r · r−1 = x · y · r mod m
Zur Bestimmung von X ∗ Y: t1
t2
t3
t3
= X·Y
echte Multiplikation
= t1 · t0 mod r
Multiplikation unten
= (t1 + t2 · m) div r Multiplikation oben
= X ∗ Y oder (t3 − m) = X ∗ Y
127
1. t3 ist durch r teilbar
2. t3 ≡ X · Y · r−1 mod m
3. 0 ≤ t3 ≤ 2m
Zu 1: t1 + t2 · m≡ t1 + t1 · t0 · m
≡ t1 + t1 · m · (−m)−1
≡ t1 − t1 ≡ 0
Zu 2:
(t1 +t2 ·m)
r
mod r
mod r
mod r
= t3 mod m
(t1 · t2 · m) · r−1 mod m≡ t1 · r−1 + t2 · r−1 · m
≡ X · Y · r−1 mod m
Beispiel: 5 ∗ 3 =
t1 = 15
t2 = 15 · 23 mod r = 45
t3 = 15 + 45 · 13 = 6
Zu 3:
t1
t2 · m
t1 + t2 · m
t3
≤
<
<
<
(m − 1)2
r·m
2·r·m
2·m
t3 ≡ X · Y · r−1 mod m
x ∗ r2 = X = x · r mod m
X ∗ 1 = x mod m
Beispiel: m = 13, r = 100, t0 = 23
r mod m r = 9 mod 13
r2 = 3 mod 13
Ziel: 6 · 5 mod 13
6∗3=2
5∗3=6
128
2 ∗ 6 =. . .
t1 =
t2 =
t3 = x
x
x∗1=
Wenn eine Division länger als 1, 5 Multiplikationen dauert, dann lohnt sich das Verfahren. Der
Erfinder heisst übrigens Peter L. Montgomery. (Montgomery Reduktion) www.mi.informatik.unifrankfurt.de/teaching/ws0001/krypto algo/montgomery.pdf
Montgomery-Multiplikation
To do: siehe Mathematischer Anhang...zusammenfügen
Die Reduktion modulo m erfordert eine Division, aber Divisionen sind ’teuer’...
Dies kann man aber wie folgt vereinfachen:
Um die Division zu vermeiden, ’transformiert’ man die Zahlen:
Sei gesucht das Produkt x · y mod m
x −→ X y −→ Y
x · y −→ X ∗ Y
R = (zweierPotenz) > m und die Division durch R muss einfach sein.
X = x · R mod m
X ∗ Y = X · Y · R−1 mod m (wobei die modulo Reduktion nun nicht mehr jedes mal ausgeführt
werden muss, sonder nur am Anfang und am Ende der ’Transformation’)
1. Berechne m0 = −m−1 mod R
(−m, R) = 1 ⇒ XGCD : m0 · m = −1 mod R
2. t = X · Y (echte Multiplikation)
3. t1 = t · m0 mod R (echte Multiplikation und oben abschneiden, also eine leichtere modulo
Reduktion da R eine zweier Potenz ist) (dabei gilt t2 < m2 + R · m)
4. t2 = t + t1 · m (echte Multiplikation und eine Addition) (dabei gilt t3 <
(m+R)·R
R
= 2m)
5. t3 = t2 divR (also ’unten abschneiden’)
6. Wenn t3 > m dann t3 = t3 − m
129
Nun ist t3 = X ∗ Y. Dafür muss t3 < m sein oder in Schritt 6 t3 < 2m sein.
Wir mussten also prüfen:
1. t3 < m
2. Division in 5. ’geht auf’:
t2 ist durch r teilbar
t2 mod R ≡ (t + t1 · m) ≡ t + (t · m0 ) · m mod R ≡ t + t(−1) mod R ≡ 0 mod R.
3. t3 = X ∗ Y?
t3 · R mod m ≡
t2
R
· R mod m ≡ t2 ≡ t + t1 · m ≡ t mod m ≡ X · Y mod m
Wir haben also den folgenden Aufwand:
1. ’Transformation’
2. ’Rechnung’
3. Zurück ’transformieren’
x ∗ R2 = x · R2 · R−1 mod m = x · R = X mod m
X ∗ 1 = X · 1 · R−1 ≡ x · R · R−1 ≡ x mod m
Man benötigt also zwei zusätzliche Operationen zur transformation. Dafür kommt die Operation
’*’ ohne Divisionen aus.
Beispiel
m = 17
R = 100
7 · 11 mod 17
x
∗
↓
X
=
(x · R) mod m ∗ (y · R)
m1 = −m−1 mod 100
suche also ein m1 mit m1 · 17 = −1 mod 100:
m1 = 47
130
y
↓
Y
=
mod m
mod m
To do: Bsp Magma Quelltext siehe Homepage
Bem dazu: Wenn R groß genug ist, kann man die Subtraktion von m weglassen
Mathematischer Hintergrund
∼
(Zm , +, ·) −→ (Zm , +, ∗) Was ist das Einselement und das
Inverse?
10.6 Nochwas?
vielleicht ...
zur Prüfung: Zwei Teile (ein theoretischer, ein praktischer). Ein openssl-Kommando das in der
VL nicht behandelt wurde, wird drankommen (zum Beispiel speed, ca, etc.). Theoretischer Teil:
1. symmetrische Verfahren (was sind symmetrische Verfahren, wodurch charakterisiert)
2. Integritätsschutz (wie kann man Integritätsschutz gewährleisten)
3. asymmetrische verfahren (siehe 1.)
4. Signatur (was sind Signaturen, wofür verwendet man sie, was ist ˜konzept, was ist sicher,
was ist unsicher)
5. Vertrauensstruktur (zum Beispiel PGP)
6. Client-Server-Authentisierung (SSL-Protokoll, Kerberos)
7. Sicherheitsparameter (wo sind die, welchen Einfluß auf die Sicherheit haben sie)
8. X.509 (elektronische Identität)
9. RFC-Security (3280, 3279, 3446, ...)
Mathematische Verfahren:
1. Square and Multiply, Double and Add
2. Euklidischer Algorithmus
3. RSA, DH
4. DSA
5. AES
6. das eine oder andere symmetrische Verfahren, Strom-/Blockchiffre
7. Elliptische Kurven eher nicht, reicht zu wissen dass man mit Addition in EK das gleiche
erreichen kann wie mit Multiplikation im Restklassenkörper
8. kleiner Fermat eher nicht
131
9. Montgomery-Multiplikation vielleicht auch nicht, sollte aber bekannt sein
Für MD5-, AES-, etc. Grundfunktionen reicht evt. wissen wo man nachschauen muss.
Dann nachweisen, dass man mit Openssl spielen kann:
1. Verschlüsseln mit DES/3DES/BF/AES . . .
2. Prüfsummenberechnung
3. Konfigurationsfile
4. RSA-Verschlüsselung
5. 0.9.8 – 0.9.7 (dynamisch)
6. Zertifikat
7. DSA-Verschlüsselung
8. Passwörter (passwd) und Salt
9. E-Mail-Nachricht erstellen und sichern (S/MIME-Anwendung)
Zum Punkt: Ich möchte eine 1 haben, was muss ich dafür tun? Was haben sie ausserhalb der
Vorlesung schonmal gelesen, ... Was fehlte ihnen an der Vorlesung, was fanden sie doof?
132

OpenSSL – Kryptologie in C - Institut für Mathematik - Hu

Transcription

Similar documents

Angriffe und Verteidigungsstrategien für vertrauliche Kommunikation

Steganographie und Multimedia-Forensik

Geometrie_des_Giseh-Plateau

Kryptologie - Prof. Dr. Andreas de Vries

1. Veranstaltung Folien

Projektarbeit ” Transmission Control Protocol“

mameox binary

Modulbeschreibung - Ruhr