Vorlesungsbegleitende Folien zur LV Kryptologie, WS

Prof. Dr. Karl–Udo Jahn, HTWK Leipzig
Vorlesungsbegleitende Folien zur LV Kryptologie, WS 2009/2010
Inhaltsverzeichnis
Einleitung mit Beispielen, Literaturempfehlungen
1. Grundbegriffe
1.1 Kryptographie – Kryptoanalyse
1.2 Kryptosysteme
1.3 Beispiel (Verschiebechiffre)
1.4 generelle Methoden der Kryptoanalyse
1.5 kryptographische Protokolle
1.6 Angriffe auf kryptographische Protokolle
2. klassische symmetrische Kryptosysteme
2.1 monoalphabetische und polyalphabetische Chiffrierungen
2.1.1
2.1.2
2.1.3
2.1.4
Substitutionschiffren
affine Chiffren (Tauschchiffren)
polyalphabetisches Chiffrieren anhand einer mengenwertigen Abbildung
Vigenére–Chiffre
Kasiski– und Friedman–Test, langes Schlüsselwort
2.1.5 Hill–Chiffre
2.2 das one–time Pad; perfekte Sicherheit
2.2.1 one–time–pad
2.2.2 perfekte Sicherheit; Entropie
2.3 Block– und Stromchiffrierungen
2.3.1 Stromchiffrierung
2.3.2 Erzeugung eines Schlüsselstromes für Stromchiffrierungen
2.3.2.1 lineare Rekursion
2.3.2.2 lineares rückgekoppeltes Schieberegister (LFSR)
2.3.2.3 weitere Anwendungen von LFSR’s
2.3.2.4 RSA–Generator
2.3.2.5 diskreter Logarithmus–Generator
2.3.2.6 RC4
2.3.3 Blockchiffrierungen
2.3.3.1 ECB–Modus; Padding
2.3.3.2 CBC–Modus; MAC und HMAC; Geburtstagsparadoxon
2.3.3.3 CFB–Modus
2.3.3.4 OFB–Modus
2.3.3.5 CTR–Modus
3. DES, IDEA und AES
3.1 DES
1
3.1.1
3.1.2
3.1.3
3.1.4
3.1.5
3.1.6
Vorgeschichte
Grobstruktur von DES
eine Runde der DES–Verschlüsselung; Feistel–Chiffre
Wirkungsweise der Funktion f
Berechnung der Rundenschlüssel
Bemerkungen zu DES
3.2 IDEA
3.2.1 Allgemeines
3.2.2 Struktur
3.2.3 Entschlüsselung
3.3 AES
3.3.1
3.3.2
3.3.3
3.3.4
3.3.5
3.3.6
Vorgeschichte
Grobstruktur
Schlüsselexpansion
ByteSub–Transformation
ShiftRow–Transformation
MixColumn–Transformation
3.4 weitere oft verwendete symmetrische kryptographische Algorithmen
4. asymmetrische Kryptosysteme
4.1 Grundlegendes
4.2 der RSA–Algorithmus
4.2.1 Schlüsselerzeugung
4.2.2 RSA–Kryptosystem
4.2.3 praktischer Einsatz
4.3 Faktorisierung ganzer Zahlen
4.3.1 effiziente Faktorisierung einer Potenz
4.3.2 versuchsweise Division
4.3.3 Pollard’s rho–Faktorisierungs–Algorithmus
4.4 das ElGamal–Verfahren
4.4.1
4.4.2
4.4.3
4.4.4
Erzeugung eines primitiven Elementes α ∈ Z∗p
Algorithmus
Bemerkungen
kleines Beispiel
4.5 elliptische Kurven
4.5.1
4.5.2
4.5.3
4.5.4
das elliptische–Kurve diskrete–Logarithmus–Problem (ECDLP)
additive Gruppe der Punkte auf der elliptischen Kurve
ECDLP über Fp
das ElGamal–Verfahren über elliptischen Kurven
4.6 Diffie–Hellman–Schlüsselaustausch
4.7 modulare Quadratwurzeln und das Rabin–Verfahren
4.7.1 quadratische Reste und modulare Quadratwurzeln
4.7.2 Legendre– und Jacobi–Symbol
2
4.7.3 Rabin–Verfahren für spezielle Primzahlen p, q
4.7.4 Bemerkungen
4.7.5 kleines Beispiel
5. digitale Signaturen
5.1 Grundsätzliches
5.2 Signaturschemata
5.3 Beispiele für Signaturschemata
5.3.1
5.3.2
5.3.3
5.3.4
5.3.5
RSA–Signatur–Schema
Signatur–Schema nach ElGamal
Digital Signature Standard (DSS); Digital Signature Algorithm (DSA)
blinde Signaturen
Beispiel: Signieren elektronischer Rechnungen; Signaturserver
6. kryptographische Hash–Funktionen
6.1 Forderungen an kryptographische Hash–Funktionen
6.2 Merkle’s Methode zur Konstruktion von Hash–Funktionen
6.3 RIPEMD–160
7. Schlüsselmanagement in public–key– und in secret–key–Systemen
7.1 Schlüsselmanagement durch eine öffentliche Datei
7.2 Zertifizierung der öffentlichen Schlüssel durch eine trusted third party (TTP);
Zertifikate, PKI
7.3 Schlüsselmanagement in symmetrischen Verfahren; Kerberos
7.4 shared secret keys
8. Authentifizierung und Identifizierung von Personen
8.1 Paßwortmechanismen
8.2 Fiat–Shamir–Protokoll
8.2.1
8.2.2
8.2.3
8.2.4
8.2.5
Allgemeines, zero–knowledge–Verfahren
das Protokoll
Anwendungen
Modifikation
Beispiel
8.3 Authentifizierung nach Schnorr
8.3.1
8.3.2
8.3.3
8.3.4
8.3.5
Aufgaben einer TTP bzw. TA
Authentifizierungsprotokoll
Bemerkungen
Beispiel
Ist die Authentifizierung sicher?
(Änderungen und Ergänzungen vorbehalten)
3
Literatur:
Beutelspacher, A. : Kryptologie. Vieweg 2005
Beutelspacher, A., Neumann, H. B. und Th. Schwarzpaul : Kryptographie in Theorie
und Praxis. Vieweg 2005
Beutelspacher, A., Schwenk, J. und K.-D. Wolfenstetter : Moderne Verfahren der
Kryptographie. Vieweg 2006
Buchmann, J. A. : Einführung in die Kryptographie. Springer 2003
Datensicherheit , Grundlagen unter Windows. RRZN, Universität Hannover 2006
Delfs, H. and H. Knebl : Introduction to Cryptography. Springer 2007
Eckert, C. : IT–Sicherheit. Oldenbourg–Verlag 2008
Ertel, W. : Angewandte Kryptographie. Fachbuchverlag Leipzig 2007
Ferguson, N. and B. Schneier : Practical Cryptography. Wiley 2003
Forster, O. : Algorithmische Zahlentheorie. Vieweg 1996
Hankerson, D., Menezes, A. and S. Vanstone : Guide to Elliptic Curve Cryptography.
Springer 2004
Hook, D. : Beginning Cryptography with Java. Wiley 2005
Knudsen, J. : Java Cryptography. 250 pp., OREILLY 1998
Menezes, A. J., van Oorschot, P. C. and S. A. Vanstone : Handbook of applied cryptography. CRC Press 2001
Packschies, L. : Praktische Kryptographie unter Linux. open source Press 2004
Schäfer, G. : Netzsicherheit. Algorithmische Grundlagen und Protokolle. dpunkt-Verlag 2003
Schmeh, K. : Kryptografie. Verfahren, Protokolle, Infrastrukturen. dpunkt.verlag 2007
Schneier, B. : Angewandte Kryptographie. Pearson Studium 2006
Schneier, B. : Secrets and Lies. IT-Sicherheit in einer vernetzten Welt. dpunkt-Verlag 2004
Schroeder, M. R. : Number Theory in Science and Communication. Springer 2005
Schwenk, J. : Sicherheit und Kryptographie im Internet. Von sicherer e-mail bis zur IPVerschlüsselung. Vieweg-Verlag 2002
Stinson, D. R. : Cryptography: Theory and Practice. CRC Press 2006
van Tilborg, C. A. : Encyclopedia of Cryptography and Security. Springer 2005
Weiss, J. : Java Cryptography Extensions. Elsevier Inc. 2004
(siehe auch Inhalt des Verzeichnisses N:\Krypto im PC–Pool)
4
Zahlentheoretisches Grundwissen zur Kryptologie
Teilbarkeit, größter gemeinsamer Teiler, Primzahlen, Kongruenz modulo m
1. Bezeichnungen:
N := {0, 1, 2, · · ·} Menge der natürlichen Zahlen
Z := {· · · , −2, −1, 0, 1, 2, · · ·} Menge der ganzen Zahlen
2. a ∈ Z heißt ein T eiler von b ∈ Z (symbolisch: a | b) genau dann, wenn es
ein c ∈ Z gibt mit a ∗ c = b
formal:
a | b :←→ ∃c(c ∈ Z ∧ a ∗ c = b)
3. d ∈ N heißt der größte gemeinsame Teiler von a, b ∈ Z
(d = ggt(a, b) bzw. d = gcd(a, b)) genau dann, wenn gilt:
d | a ∧ d | b ∧ ∀t(t ∈ Z ∧ t | a ∧ t | b −→ t | d)
(bis auf den Fall gcd(0, 0) = 0 kann man äquivalent dazu auch definieren:
gcd(a, b) ist die größte positive ganze Zahl, die sowohl a als auch b teilt)
es gilt beispielsweise: gcd(a, a) =| a |, gcd(a, b) = gcd(b, a), gcd(a, b) =
gcd(a − b, b)
gcd(a, b) kann mit Hilfe des Euklidischen Algorithmus’ berechnet werden.
Weiterhin gilt: Ist g = gcd(a, b), so gibt es ganze Zahlen s, t mit g =
s ∗ a + t ∗ b.
s und t können mit Hilfe des erweiterten Euklidischen Algorithmus’
berechnet werden.
4. a, b ∈ Z heißen genau dann zueinander teilerfremd bzw. zueinander
relativ prim, wenn gcd(a, b) = 1 ist
5. Primzahlbegriff
eine Zahl p heißt genau dann eine Primzahl, wenn p ∈ N und p ≥ 2 ist
und wenn p nur 1 und p als Teiler hat
Um festzustellen, ob n ≥ 2 eine Primzahl ist oder nicht, brauchen nur alle
√
Primzahlen p mit 2 ≤ p ≤ n daraufhin untersucht zu werden, ob sie
Teiler von n sind oder nicht.
5
6. Satz von der eindeutigen Primfaktorzerlegung
Jede natürliche Zahl n ≥ 2 lässt sich bis auf die Reihenfolge der Faktoren
auf genau eine Weise als Produkt von Primzahlpotenzen mit positiven
Exponenten notieren:
n = pe11 ∗ pe22 ∗ · · · ∗ pekk
wobei p1, p2, · · · , pk paarweise verschiedene Primzahlen sind
7. Anzahl der Primzahlen
Es gibt unendlich viele Primzahlen.
Möge π(x) die Anzahl der Primzahlen, die kleiner oder gleich x sind, bezeichnen. Dann gilt:
limx→∞
π(x)
x/ln(x)
=1
x ≥ 17 → π(x) >
x
ln(x)
x > 1 → π(x) < 1.25506 ∗
x
ln(x)
Die Chance, dass eine aus dem Intervall [2,n] zufällig ausgewählte natürliche Zahl eine Primzahl ist, beträgt also ca. 1/ ln(n).
Beispiele: π(101) = 4, π(102) = 25, π(103) = 168, π(106) =
78 498, π(109) = 50 847 534, π(1012) = 37 607 912 018, π(1015) =
29 844 570 422 669, π(1018) = 24 739 954 287 740 860
Anzahl der Primzahlen mit einer Länge bis zu 512 Bit: ≈ 10151
Wenn ein Festplattenlaufwerk mit 1 Gramm Masse eine Kapazität von 1
GByte hätte, so wäre zum Abspeichern aller Primzahlen mit 512 Bit ein
Laufwerk nötig, das soviel Masse hätte, dass es zu einem schwarzen Loch
kollabieren würde. (B. Schneier)
8. Satz von der Division mit Rest:
Zu zwei beliebigen ganzen Zahlen a, b mit b ≥ 1 gibt es genau zwei ganze
Zahlen q und r, so dass gilt:
a=q∗b+r
∧
0≤r<b
Bezeichnung für den Fall a ≥ 0: r = a mod b, q = a div b bzw. q = a ÷ b.
(Die Operationen div und mod werden oft folgendermaßen für beliebige
ganze Zahlen a, b mit b 6= 0 definiert:
a div b := ⌊|a|/|b|⌋ ∗ sgn(a ∗ b)
(dabei ist sgn : R → {−1, 0, 1} mit sgn(x) := −1 für negative x,
sgn(x) := 0 für x = 0, und sgn(x) := 1 für positive x)
a mod b := a − b ∗ (a div b)
)
6
9. Es sei m ∈ N, m 6= 0; zwei natürliche Zahlen r und s heißen genau dann
kongruent modulo m (symbolisch: r ≡ s mod m), wenn (r mod m) =
(s mod m) ist, d.h., wenn r und s bei Division durch m den gleichen Rest
haben.
Verallgemeinerung auf ganze Zahlen a, b, m:
a ≡ b mod m :↔ a − b ist durch m teilbar
Für jedes m ∈ Z ist die Kongruenz modulo m eine Äquivalenzrelation in
Z.
Modulare Arithmetik
1. für jedes n ∈ N mit n ≥ 1 sei
Zn := {0, 1, 2, · · · , n − 1}
Addition, Subtraktion, Multiplikation in Zn :
für beliebige a, b ∈ Zn sei
a ⊕ b := (a + b) mod n
a ⊖ b := (a − b) mod n
a ⊗ b := (a × b) mod n
Dann sind (Zn, ⊕) eine kommutative Gruppe und (Zn , ⊕, ⊗) ein kommutativer Ring mit Einselement. Genau dann, wenn n eine Primzahl ist, ist
(Zn , ⊕, ⊗) sogar ein Körper.
(Anstelle von ⊕, ⊖ bzw. ⊗ wird, wenn keine Verwechslungen zu befürchten
sind, auch einfach wieder +, - bzw. × (oder *) geschrieben.)
2. es sei Z∗n := {m ∈ Zn | 1 ≤ m ∧ gcd(m, n) = 1}
Dann ist (Z∗n , ⊗) eine kommutative Gruppe. Die Anzahl der Elemente
von Z∗n wird mit ϕ(n) (manchmal auch φ(n)) bezeichnet (Eulersche ϕ–
Funktion).
Zu jedem a ∈ Z∗n wird das bzgl. der modularen Multiplikation inverse Element b mit a−1 mod n bezeichnet: b = a−1 mod n.
(Es ist also a ∗ b ≡ 1 mod n).
Hinweis: Berechne b = a−1 mod n mit Hilfe des erweiterten Euklidischen
Algorithmus’.
3. Es sei a, b ∈ Zn mit a ≥ 1, gcd(a, n) = 1. Dann existiert zu f : Zn → Zn
mit f (x) := (a ∗ x + b) mod n die Umkehrfunktion f −1, und es ist f −1(x) =
(a−1 ∗ x − a−1 ∗ b) mod n.
7
4. Eigenschaften der Eulerschen ϕ–Funktion:
Falls n eine Primzahl ist, so ist ϕ(n) = n − 1.
Falls m und n zwei zueinander relativ prime natürliche Zahlen sind,
so ist ϕ(m ∗ n) = ϕ(n) ∗ ϕ(m).
Falls n = pe11 ∗ pe22 ∗ · · · ∗ pekk die Primfaktorzerlegung von n ist, so ist
ϕ(n) = n ∗ (1 −
1
1
1
) ∗ (1 − ) ∗ · · · ∗ (1 − )
p1
p2
pk
Für alle nat. Zahlen n ≥ 5 ist
ϕ(n) >
.
n
6 ∗ ln(ln(n))
5. es sei n ∈ Z, n ≥ 2; dann gilt:
falls a ∈ Z∗n ist so ist aϕ(n) ≡ 1 mod n (Satz von Euler)
(gilt auch für beliebige a ∈ N mit a ≥ 1 und gcd(a, n) = 1)
falls n ein Produkt von paarweise verschiedenen Primzahlen und r ≡
s mod ϕ(n) ist, so ist ar ≡ as mod n für alle ganzen Zahlen a
6. speziell gilt für Primzahlen p:
falls gcd(a, p) = 1 ist, so ist ap−1 ≡ 1 mod p (kleiner Satz von Fer-
mat)
falls r ≡ s mod (p − 1) ist, so ist ar ≡ as mod p für alle ganzen Zahlen
a; speziell ist ap ≡ a mod p
stets ist (a + b)p ≡ (ap + bp ) mod p
Falls also gcd(a, n) = 1 und nicht an−1 ≡ 1 mod n ist, so kann n keine
Primzahl sein (a ist ein Zeuge (witness) dafür, dass n keine Primzahl
ist).
8
7. Rechenregeln für die modulare Arithmetik
(a + b) mod n = ((a mod n) + (b mod n)) mod n
(a − b) mod n = ((a mod n) − (b mod n)) mod n
(a ∗ b) mod n = ((a mod n) ∗ (b mod n)) mod n
(a ∗ (b + c)) mod n = (((a ∗ b) mod n) + ((a ∗ c) mod n)) mod n
Bei einem Modul n der Länge k Bit können also Addition, Subtraktion,
Multiplikation und Potenzierung so implementiert werden, dass kein Zwischenergebnis länger als 2k Bit wird:
Soll beispielsweise der Wert des Termes (a ∗ b + c) mod n bestimmt werden,
so kann man ihn folgendermaßen klammern:
((((a mod n) ∗ (b mod n)) mod n) + (c mod n)) mod n
so dass zunächst jede Konstante modulo n reduziert und unmittelbar nach
jeder arithmetischen Operation eine Reduktion modulo n durchgeführt
wird.
Modulare Potenzierungen werden effizient mit dem Algorithmus squareand-multiply ausgeführt oder es wird der kleine Satz von Fermat benutzt.
Der folgende Algorithmus (square–and–multiply) berechnet effizient
xn mod m für ganze Zahlen x 6= 0 und natürliche Zahlen m > 1, n:
x, n , m
z:=1
while n>0
while n ist gerade
n := n div 2
x := x * x mod m
n := n−1
z := z * x mod m
z
Die Anzahl der durchzuführenden Multiplikationen ist jeweils nach oben
beschränkt durch 2 ∗ ⌊log2 (n)⌋ + 1.
9
8. lineare Kongruenzen
die lineare Kongruenz a ∗ x ≡ b mod n ist genau dann lösbar, wenn
gcd(a, n)|b ist; es gibt dann genau gcd(a, n)–viele Lösungen in Zn
es sei gcd(a, n)|b und d := gcd(a, n); dann können alle Lösungen x von
a ∗ x ≡ b mod n mit x ∈ Zn auf folgende Weise bestimmt werden:
bestimme die eindeutige Lösung x0 ∈ Zn von
berechne x1 := x0 + 1 ∗
x0 + (d − 1) ∗
n
d
mod n
n
d
a
d
∗x≡
b
d
mod
n
d
mod n, x2 := x0 + 2 ∗ nd mod n, · · · , xd−1 :=
dann sind x0, x1, · · · , xd−1 alle Lösungen von a ∗ x ≡ b mod n, die in Zn
liegen
9. Chinesischer Restsatz (Chinese Remainder Theorem)
Es seien m1 , · · · , mr positive natürliche Zahlen, die paarweise relativ prim
zueinander sind. Sind dann a1 , · · · , ar beliebige ganze Zahlen, so gibt es
modulo m := m1 ∗ · · · ∗ mr genau eine natürliche Zahl x (0 ≤ x < m), so
dass die folgenden Kongruenzen alle erfüllt sind:
x ≡ a1 mod m1 , · · ·, x ≡ ar mod mr
Berechnung von x:
Sei Mi := m/mi für alle i mit 1 ≤ i ≤ r. Berechne (z. B. mit Hilfe des
erweiterten euklidischen Algorithmus) die modularen Inversen yi von Mi
modulo mi , also yi := Mi−1 mod mi (mi und Mi sind für alle i relativ prim
zueinander). Dann ist x ≡ (a1 ∗ y1 ∗ M1 + · · · + ar ∗ yr ∗ Mr ) mod m.
Ist speziell r = 2 und sind u1 und u2 ganze Zahlen mit 1 = u1 ∗m1 +u2 ∗m2 ,
dann ist x ≡ (a1 ∗ u2 ∗ m2 + a2 ∗ u1 ∗ m1 ) mod m
10. quadratische Reste, modulare Quadratwurzeln
Zur modularen Quadrierung invers ist das Bestimmen der modularen
Quadratwurzel.
Es sei n ∈ N, n > 1. Dann heißt ein a ∈ Z∗n ein quadratischer Rest
modulo n, fall es ein b ∈ Z∗n gibt mit b2 ≡ a mod n. Weiterhin heißt b
dann eine Quadratwurzel von a modulo n.
Beispiel: n := 55; dann hat 34 ∈ Z∗n die modularen Quadratwurzeln 12, 23,
32 und 43.
Wenn n eine Primzahl ist, so hat a ∈ Z∗n entweder keine oder genau zwei
Quadratwurzeln modulo n.
Wenn n das Produkt zweier Primzahlen ist, so hat a ∈ Z∗n entweder keine
oder genau vier Quadratwurzeln modulo n. Das Berechnen der Quadratwurzeln ist dann genau so schwierig wie das Faktorisieren von n.
10
11. primitives bzw. erzeugendes Element
Es sei a ∈ Z∗n , n > 1;
a heißt ein primitives bzw. erzeugendes Element der Gruppe
(Z∗n , ⊗) oder einfach von Z∗n , falls die Potenzen a0 mod n, a1 mod n,
· · ·, aϕ(n)−1 mod n alle Elemente von Z∗n ergeben.
Falls Z∗n ein primitives Element hat, so ist also (Z∗n , ⊗) eine zyklische
Gruppe.
Z∗n hat genau dann ein primitives Element, wenn n = 2, n = 4, n = pk
oder n = 2 ∗ pk ist für eine ungerade Primzahl p und k ≥ 1.
a ∈ Z∗n ist genau dann ein primitives Element, wenn aϕ(n)/p 6≡ 1 mod n
ist für jeden Primteiler p von ϕ(n).
12. diskrete Logarithmen
Zur modularen Potenzierung invers ist die Berechnung des diskreten Logarithmus einer Zahl b zur Basis a, hier nur betrachtet modulo einer Primzahl
p:
es sei p eine Primzahl, a ∈ Z∗p ein primitives Element und b ∈ Z∗p .
Dann heißt die eindeutig bestimmte Zahl x mit 0 ≤ x ≤ p − 2, für die
ax ≡ b mod p ist, der diskrete Logarithmus von b zur Basis a modulo p.
Schreibweise: x = loga b mod p
Beispiel: 6 = log3 15 mod 17;
3x ≡ 7 mod 13 ist nicht (ganzzahlig) lösbar, denn stets ist 3x ∈
{1, 3, 9} mod 13; (es ist 3 kein primitives Element von Z∗13).
Die Komplexität der Berechnung diskreter Logarithmen modulo p ist im
Wesentlichen genauso groß wie die der Faktorisierung einer ganzen Zahl,
die etwa genauso lang ist wie p und das Produkt zweier annähernd gleich
langer Primzahlen ist.
13. Pseudozufallgeneratoren auf der Basis linearer Kongruenzen
Es seien a, b, m natürliche Zahlen mit m > 0. Dann wird durch das
Iterationsverfahren
x0 ∈ N
(x0 < m als Anfangswert vorgegeben)
xi+1 := (a ∗ xi + b) mod m (i = 0, 1, 2, · · ·)
eine Folge von Zufallszahlen mit einer Periodenlänge von maximal m erzeugt. Es gilt beispielsweise: Falls m eine Zweierpotenz, a ≡ 1 mod 4 und
gcd(b, m) = 1 ist, so ist die Periodenlänge gleich m (s. dazu z.B. Schroeder,
M.R.: Number Theory in Science and Communication. Springer–Verlag
2005 bzw. Forster, O.: Algorithmische Zahlentheorie. Vieweg–Verlag 1996).
11
14. Konvertierungen natürlicher Zahlen in Byte–Strings und umgekehrt
In PKCS#1 v.2.1 (Public Key Cryptography Standard version 2.1) werden
dazu die beiden Algorithmen I2OSP (Integer–to–Octet–String primitive)
sowie OS2IP (Octet–String–to–Integer primitive) vorgeschlagen.
I2OSP(x, xLen) mit den Inputs x (nat. Zahl) und xLen (beabsichtigte
Länge des resultierenden Byte– (Octet–)Strings) sowie dem Output X (zugehöriger Byte–String der Länge xLen):
(a) if x ≥ 256xLen then output ”integer too large” and stop
(b) write the integer x in its unique xLen–digit representation in base 256:
x = xxLen−1 ∗ 256xLen−1 + xxLen−2 ∗ 256xLen−2 + · · · + x1 ∗ 256 + x0
mit 0 ≤ xi < 256 (dabei können einige führende Ziffern Null sein)
(c) let the octet Xi have the integer value xxLen−i for 1 ≤ i ≤ xLen; output
the octet string X := X1 · · · XxLen
Für Zwecke der Konvertierung zu und von natürlichen Zahlen wird das
erste Octet als das am meisten signifikante betrachtet.
OS2IP(X) mit dem Input X als Byte–String und dem Output x als natürliche Zahl:
(a) let X1 X2 · · · XxLen be the octets of X from first to last, and let xxLen−i
be the integer value of the octet Xi for 1 ≤ i ≤ xLen
(b) let x := xxLen−1 ∗ 256xLen−1 + xxLen−2 ∗ 256xLen−2 + · · · + x1 ∗ 256 + x0
(c) output x
15. einige physikalische Beispiele großer Zahlen (Schneier, B.: Angewandte
Kryptographie. Pearson Studium 2006, S. 21)
Alter der Erde: 109 (230) Jahre
Anzahl der Atome in der Erde: 1051 (2170)
Anzahl der Atome in der Sonne: 1057 (2190)
Größe des Universums: 1084 (2280) cm3
Außer den meisten im Literaturverzeichnis enthaltenen Büchern kann man z.B.
auch in einigen im Verzeichnis N:\Krypto enthaltenen Arbeiten Ausführungen
zum zahlentheoretischen Grundwissen finden.
12
Tools bzw. Software, die insbesondere in den Übungen
verwendet werden:
Cryptool siehe www.cryptool.de
Aribas siehe www.mathematik.uni-muenchen.de/∼forster
gpg4win (GnuPG for Windows); siehe www.gpg4win.de
JCE Java Cryptography Extension (in jdk1.6.0 <version> enthalten)
Bouncy Castle Cryptography Provider ; siehe www.bouncycastle.org
(Installationsdateien dazu befinden sich in N:\Krypto im PC–Pool.)
13
Public Key Cryptography Standards (PKCS):
”The Public-Key Cryptography Standards are specifications produced by RSA
Laboratories in cooperation with secure systems developers worldwide for the
purpose of accelerating the deployment of public-key cryptography. First published in 1991 as a result of meetings with a small group of early adopters
of public-key technology, the PKCS documents have become widely referenced
and implemented. Contributions from the PKCS series have become part of many formal and de facto standards, including ANSI X9 documents, PKIX, SET,
S/MIME, and SSL. Note: PKCS #2 and PKCS #4 have been incorporated into
PKCS #1.”
siehe http://www.rsa.com/rsalabs/ (kopiert am 23. September 2007)
PKCS #1: RSA Cryptography Standard
Spezifikation zur Implementierung des RSA–Algorithmus sowohl zur Datenverschlüsselung als auch zur Erzeugung einer digitalen Signatur; es wird
u.a. festgelegt, wie eine Folge von Bytes als natürliche Zahl zu interpretieren ist, wie der Ablauf des Algorithmus inklusive Fehlermeldungen zu sein
hat und wie öffentlicher und privater Schlüssel formatiert werden sollen;
außerdem enthält die Spezifikation verschiedene OIDs (Object Identifier)
(OIDs sind eindeutige Kennungen von Objekten bzw. Verfahren, die in allen Standards einheitlich verwendet werden sollten; manchmal wird auch
eine URL anstelle meiner OID verwendet);
eine ausführlichere Beschreibung befindet sich z.B. in dem Buch von K.
Schmeh
PKCS #3: Diffie-Hellman Key Agreement Standard
(die ursprünglich vorhanden gewesenen Standards PKCS #2 und #4 sind
in PKCS #1 eingeflossen)
beschreibt Implementierung der Diffie–Hellman–Schlüsselvereinbarung,
mit deren Hilfe zwei Parteien einen geheimen Schlüssel vereinbaren können, den nur sie kennen; es werden die Datenformate und die Methoden
für die Darstellung der Schlüssel beschrieben
PKCS #5: Password–Based Cryptography Standard (PBE)
beschreibt eine Methode zur Generierung eines Schlüssels aus einem Passwort; diese Methode wurde von der IETF übernommen und als RFC2898
veröffentlicht
PKCS #6: Extended Certificate Syntax Standard
ein Extended Certificate ist ein X.509–digitales–Zertifikat, das von einer
CA (Certificate Authority) signiert wurde und zusätzliche Informationen
wie z.B. eine e–mail–Adresse enthält; dieser Standard wurde jedoch durch
die dritte Version des X.509–Formats (X.509v3) überflüssig
14
PKCS #7: Cryptographic Message Syntax Standard
beschreibt Format für verschlüsselte oder signierte Nachrichten; wird auch
als Cryptographic Message Syntax (CMS) bezeichnet; z.B. ist das in
S/MIME verwendete Format für verschlüsselte und signierte e–mails aus
PKCS#7 abgeleitet und in RFC3852 festgeschrieben
PKCS #8: Private–Key Information Syntax Standard
beschreibt ein Format für das verschlüsselte Ablegen eines Schlüssels, insbesondere des privaten Schlüssels asymmetrischer Verfahren (kann aber
auch für Schlüssel symmetrischer Verfahren verwendet werden); enthält
neben dem Schlüssel noch weitere Angaben, z.B. die OID des Algorithmus, für den der Schlüssel verwendet werden kann
PKCS #9: Selected Attribute Types
beschreibt genauer bestimmte Attibut–Typen, die in PKCS #6, PKCS #7
und PKCS #8 verwendet werden
PKCS #10: Certification Request Syntax Standard
beschreibt Syntax für die Anforderung eines digitalen Zertifikates; die Anforderung wird an eine CA gesendet, die bei Einhaltung des Standards diese
Anforderung auch versteht; zusätzlich ist festgelegt, wie eine CA sich zu
verhalten hat, damit sie zweifelsfrei die Identität des Zertifikat–Anforderers
feststellen kann
PKCS #11: Cryptographic Token Interface Standard
beschreibt ein Programmier–Interface mit Namen Cryptoki (”crypto key”)
zum Umgang mit kryptographischen Operationen unter Benutzung von
Hardware Tokens, Smartcards und USB–Smartkeys; beschreibt so auch
Smartcard–Support für SSL– und S/MIME–Transaktionen
PKCS #12: Personal Information Exchange Syntax Standard
legt ein Format fest für das Speichern und Transportieren beispielsweise
von privaten Schlüsseln und Zertifikaten
PKCS #13: Elliptic Curve Cryptography Standard
beschreibt verschiedene Verfahren der elliptische–Kurven–Kryptografie
PKCS #14: Pseudo–Random Number Generation Standard
beschreibt verschiedene Methoden zur Erzeugung von Pseudozufallszahlen,
es hat sich aber noch kein Standard etabliert
PKCS #15: Cryptographic Token Information Format Standard
beschreibt Standards, mit deren Hilfe es möglich werden soll, dass jedes
Token mit jeder Software verwendet werden kann und damit die Tokens
austauschbar sind
15
Standardisierungen und Standardisierungsgremien:
IEEE (Institute of Electrical and Electronics Engineers) veröffentlicht
IEEE–Standards, z.B. IEEE P1363 (Public–Key–Verfahren), IEEE 802.11 (WLAN) und IEEE802.1x
(Authentifizierung in Rechnernetzen)
http://www.ieee.org
NIST (National Institute of Standards and Technology) gehört zum US–Handelsministerium; z.B. die Verfahren DES, DSA und die SHA–Familie stammen von dort
http://www.nist.gov
IETF (Internet Engineering Task Force) hat zahlreiche Krypto–Standards herausgegeben; jeweils zuständige Arbeitsgruppen entwickeln zunächst Internet Drafts (Standardisierungsvorschläge); diese müssen von der IESG (Internet Engineering Steering
Group) befürwortet werden und werden dadurch zu einem RFC (Request for Comment), allerdings zunächst als Proposed Standard; nach Bestehen von Tests wird daraus
ein Draft Standard und schließlich ein offizieller Standard; die RFC’s werden mit Nummern versehen, z.B. behandeln RFC2246 das TLS–Protokoll und RFC1521 die Base64–
Codierung
http://www.ietf.org
http://www.ietf.org/rfc.html
ANSI (American National Standards Institute) definiert Standards für verschiedene
Bereiche, z.B. ANSI X9.17: ANSI-Standard zum Austausch geheimer Schluessel mit dem
DES-Algorithmus
http://www.ansi.org
BSI (Bundesamt für Sicherheit in der Informationstechnik) evaluiert und legt fest geeignete Sicherheitstechnik zum Einsatz in Bundesbehörden; legt fest, welche Krypto- und
Hashverfahren dem deutschen Signaturgesetz gerecht werden und wie die Evaluationsund Zertifizierungsverfahren für SigG-konforme CA’s aussehen
http://www.bsi.de
FIPS (Federal Information Processing Standard) vom NIST herausgegebene Standards, denen die Computersysteme der US-Regierung genügen sollen
http://www.itl.nist.gov/fipspubs
ISO (International Organization for Standardization) Internationale Organisation, die
zahlreiche Netzstandards (ISO-Protokolle) herausgibt
http://www.iso.org
NSA (National Security Agency) amerikanische Behörde, die sich intensiv mit Kryptologie und der weltweiten Überwachung und nachrichtendienstlichen Gewinnung von Daten
beschäftigt; verfügt über extrem leistungsstarke Rechner
http://www.nsa.gov
PKCS (Public Key Cryptography Standards) von RSA herausgegebene Standards, die
beschreiben, wie public–key–Kryptographie zuverlässig, sicher und kompatibel eingesetzt
wird
http://www.rsa.com/rsalabs/
Bundesnetzagentur betreibt die Wurzel–CA des deutschen Signaturgesetzes
http://www.bundesnetzagentur.de
16
ein paar weitere Links (aktuell am 23. September 2009):
http://www.cacr.math.uwaterloo.ca/hac/
(Menezes u.a.: Handbook of Applied Cryptography)
http://people.csail.mit.edu/rivest/crypto-security.html
(Pointer auf andere Web-Seiten zu Kryptography und Security)
http://www.ietf.org/html.charters/smime-charter.html
(S/MIME mail security)
http://www.ietf.org/html.charters/pkix-charter.html
(IETF Public-Key Infrastructure X.509)
http://www.pki-page.org/
(PKI-Page mit vielen krypt. Links)
http://www.openssl.org/
(OpenSSL)
http://www.gnupg.org/
(GNU Privacy Guard)
http://www.heise.de/security/
(aktuelle Meldungen zu Sicherheitslücken)
http://www.bouncycastle.org/
(BouncyCastle JCE-Provider)
http://www.rsa.com/
(RSA Homepage)
http://primes.utm.edu/
(Primzahlenseiten)
http://www.cdc.informatik.tu-darmstadt.de/TI/LiDIA/Welcome.html
(C++ Klassen-Bibliothek für Arithmetik beliebiger Genauigkeit)
Die beiden letzten Folien, aber mit aktiven Links, befinden sich in der Datei
standards links.pdf.
17
Ein kleines vereinfachtes Beispiel für eine verschlüsselte Verbindung
(SSL; secure sockets layer):
Öffnen von www.sparkasse-leipzig.de mit einem Browser, z.B. Firefox:
rechts unten erscheint geschlossenes Schloss, und aus ”http” wird ”https”:
die Verbindung zwischen Browser und Sparkasse ist verschlüsselt;
Anklicken des Schlosses: genauere Information über verwendete Algorithmen und Zertifikate, als Beispiel wird hier der allgemeine Teil des Zertifikates wiedergegeben:
18
zuerst, nachdem der Browser dem Server der Sparkasse mitgeteilt hat, dass
er mit ihm kommunizieren möchte, sendet der Server u.a. seinen öffentlichen RSA–Schlüssel, der von VeriSign in einem Zertifikat mit Hilfe des geheimen Schlüssels von VeriSign digital signiert ist, an den Browser zurück;
der Browser kennt den zugehörigen öffentlichen Schlüssel von VeriSign und
kann damit die Echtheit des Zertifikats überprüfen
der Browser erzeugt einen Schlüssel (session key), mit dessen Hilfe die
Kommunikation mittels RC4 mit 128 Bit Schlüssellänge verschlüsselt wird;
diesen Schlüssel sendet er an den Server der Sparkasse, und zwar RSA–
verschlüsselt mit dem öffentlichen Schlüssel der Sparkasse; die Sparkasse
entschlüsselt den session key mit ihrem geheimen RSA–Schlüssel. Öffentlicher Schlüssel der Sparkasse:
19
Überprüfen der Korrektheit des öffentlichen Schlüssels von VeriSign am
Beispiel von Firefox:
Extras → Einstellungen → Erweitert → Zertifikate anzeigen → Zertifizierungsstellen → VeriSign Class 3 Public Primary Certificate (Builtin Object
Token) → Ansicht
man erhält den MD5– und SHA1–Fingerabdruck (kryptographischer Hashwert) des Zertifikates von VeriSign (VeriSign hat seinen öffentlichen
Schlüssel selbst signiert) und kann sich bei VeriSign erkundigen, ob er
korrekt ist
20
man kann also überprüfen, ob man mit der Sparkasse verbunden ist (vor-
ausgesetzt, VeriSign hat keine Fehler gemacht);
Wie weiß die Sparkasse, mit wem sie verbunden ist?
Entweder man hat sich selbst ein Zertifikat besorgt, das die Sparkasse überprüfen kann, oder man muss sich beispielsweise über ein Passwort und eine
PIN authentifizieren
Zertifikate
Zertifikate sind im Internet das Äquivalent zu amtlichen Dokumenten. Sie enthalten u.a.
Angaben zum Aussteller (”ausstellende Behörde”)
Angaben zum Inhaber (pers. Daten, e–mail–Adresse, Internet–Adresse, öf-
fentl. Schlüssel)
Angaben zur Gültigkeitsdauer
Angaben zum verwendeten Hash– und Signaturalgorithmus
alle diese Daten werden mit einer digitalen Signatur (unter Benutzung des
eben erwähnten Signaturalgorithmus’) der ausstellenden Behörde versehen
Standard für Zertifikate: ITU–Standard X.509 (ISO/IEC 9594-8 von 1997)
Versionsnummer (X.509v...)
Seriennummer des Zertifikates
Signatur– und Hashalgorithmus
Aussteller
Gütigkeitsdauer
Inhaber
öffentlicher Schlüssel des Inhabers
zusätzliche Angaben
Signatur des Ausstellers
Von besonderer Bedeutung sind die Certificate Revocation Lists (CRL’s), das
sind Datenbanken, in denen Zertifikate als nicht mehr gültig ausgewiesen werden (weil z.B. der private Schlüssel des Inhabers kompromittiert worden ist),
und deren Inhalte sich jeden Moment ändern können. Bevor man ein Zertifikat
benutzt, sollte man sich erst vergewissern, dass es noch gültig ist.
21
Spezifikation für OpenPGP (Auszug aus RFC 2440)
Auch beispielsweise in PGP kommen auf ähnliche Weise symmetrische und
asymmetrische Verschlüsselungsverfahren zur Anwendung.
General functions
OpenPGP provides data integrity services for messages and data files by
using these core technologies:
– digital signatures
– encryption
– compression
– radix-64 conversion
In addition, OpenPGP provides key management and certificate services,
but many of these are beyond the scope of this document.
Confidentiality via Encryption
OpenPGP uses two encryption methods to provide confidentiality: symmetric key encryption and public key encryption. With public key encryption,
the object is encrypted using a symmetric encryption algorithm. Each symmetric key is used only once. A new ”session key” is generated as a random
number for each message. Since it is used only once, the session key is
bound to the message and transmitted with it. To protect the key, it is
encrypted with the receiver’s public key. The sequence is as follows:
– The sender creates a message.
– The sending OpenPGP generates a random number to be used as a
session key for this message only.
– The session key is encrypted using each recipient’s public key. These
”encrypted session keys” start the message.
– The sending OpenPGP encrypts the message using the session key,
which forms the remainder of the message. Note that the message is
also usually compressed.
– The receiving OpenPGP decrypts the session key using the recipient’s
private key.
– The receiving OpenPGP decrypts the message using the session key.
If the message was compressed, it will be decompressed.
22
With symmetric key encryption, an object may be encrypted with a symmetric key derived from a passphrase (or other shared secret), or a two–
stage mechanism similar to the public key method described above in which
a session key is itself encrypted with a symmetric algorithm keyed from a
shared secret.
Both digital signature and confidentiality services may be applied to the
same message. First, a signature is generated for the message and attached to the message. Then, the message plus signature is encrypted using
a symmetric session key. Finally, the session key is encrypted using public
key encryption and prefixed to the encrypted block.
Authentication via Digital signature
The digital signature uses a hash code or message digest algorithm, and a
public key signature algorithm. The sequence is as follows:
– The sender creates a message.
– The sending software generates a hash code of the message.
– The sending software generates a signature from the hash code using
the sender’s private key.
– The binary signature is attached to the message.
– The receiving software keeps a copy of the message signature.
– The receiving software generates a new hash code for the received
message and verifies it using the message’s signature. If the verification
is successful, the message is accepted as authentic.
Compression
OpenPGP implementations MAY compress the message after applying the
signature but before encryption.
Conversion to Radix–64
OpenPGP’s underlying native representation for encrypted messages, signature certificates, and keys is a stream of arbitrary octets. Some systems
only permit the use of blocks consisting of seven-bit, printable text. For
transporting OpenPGP’s native raw binary octets through channels that
are not safe to raw binary data, a printable encoding of these binary octets
is needed. OpenPGP provides the service of converting the raw 8-bit binary octet stream to a stream of printable ASCII characters, called Radix-64
encoding or ASCII Armor.
Implementations SHOULD provide Radix-64 conversions.
23
Note that many applications, particularly messaging applications, will
want more advanced features as described in the OpenPGP-MIME document, RFC 2015. An application that implements OpenPGP for messaging
SHOULD implement OpenPGP-MIME.
Signature-Only Applications
OpenPGP is designed for applications that use both encryption and signatures, but there are a number of problems that are solved by a signatureonly implementation. Although this specification requires both encryption
and signatures, it is reasonable for there to be subset implementations that
are non-comformant only in that they omit encryption.
Beispielsweise verwendet PGP 7.03 die folgenden kryptographischen Algorithmen:
für die Verschlüsselung des Textes:
AES, CAST, IDEA, TripleDES, Twofish
zur Signaturerzeugung:
RSA, DSS
als Hash–Funktionen:
MD5, SHA–1
(vor der Signierung eines Textes wird ein Hashwert des Textes gebildet,
der in Wirklichkeit signiert wird)
als (verlustfreie) Kompressionsfunktion:
LZS (RFC 2395)
(der Text kann vor dem Verschlüsseln komprimiert werden; dann wird anstelle des ursprünglichen Textes der komprimierte Text verschlüsselt)
für den Schlüsselaustausch:
Diffie–Hellman
siehe z. B. auch
http://www.thunderbird-mail.de/wiki/Mailverschlüsselung mit GnuPG / PGP
http://www.thunderbird-mail.de/wiki/Mailverschlüsselung mit S/MIME
24
Kryptologie
Kryptographie
Kryptoanalyse
Kryptographie
Geheimhaltung, Vertraulichkeit (privacy, confidentiality) durch Chiffrieren
(Verschlüsseln, encryption), Dechiffrieren (Entschlüsseln, decryption)
Authentikation, Authentifizierung, Authentizität (authentication)
Teilnehmerauthentikation: Nachweis meiner Identität einem Rechner oder
einer Person gegenüber (Zertifikat, PIN, Ausweis, Passwort, Unterschrift,
biometrisches Merkmal, spezifisches Wissen, · · ·).
Nachrichtenauthentikation: Ursprung einer Nachricht zweifelsfrei belegen
(digitale Unterschrift, MAC,· · ·).
Nachrichten–Integrität (data integrity)
Erkennen, ob eine Nachricht unbefugt verändert wurde (Hashwert, kryptographische Prüfsumme, digitaler Zeitstempel, · · ·).
Verbindlichkeit (commitment)
Der Absender einer Nachricht soll später nicht leugnen können, dass die
Nachricht von ihm stammt.
Anonymität (anonymity)
Sich Hilfe holen oder sich beraten lassen, ohne sich erkennen zu geben.
elektronisches Geld (electronic money, electronic cash)
Steganographie
Verstecken von Informationen in Bildern
Copyright
digitale Wasserzeichen
25
Kryptoanalyse
Versuch, aus der verschlüsselten Nachricht (cipher text) ohne a priori
Kenntnis eines Schlüssels (key’s) die ursprüngliche Nachricht (message,
plain text, Klartext) wiederherzustellen =⇒ Angriff, Attacke
Wie sicher ist eine Verschlüsselung?
Welche Angriffsmöglichkeiten gibt es?
Es wird davon ausgegangen, dass das Übermitteln von Nachrichten
abgehört werden kann.
Es wird weiterhin davon ausgegangen, dass die Verschlüsselungsalgorithmen allgemein bekannt sind, so dass die Sicherheit eines Verfahrens davon abhängt, ob der richtige Schlüssel gefunden werden kann.
Nachrichtenübermittlung mit Verschlüsselung:
Alice sendet an Bob eine verschlüsselte Nachricht
Schlüssel 1
Alice
Klartext
Chiffretext (Geheimtext)
Verschlüsselung
Mr. X
man in the middle
eavesdropper
mallory
Schlüssel 2
Chiffretext
Entschlüsselung
26
Klartext
Bob
Kryptosystem
P:
Menge von Klartexten (plain texts, messages)
C:
Menge von Chiffretexten (cipher texts, Geheimtexte)
K1 :
Menge von Schlüsseln zum Verschlüsseln von Klartexten
K2 :
Menge von Schlüsseln zum Entschlüsseln von Geheimtexten
K: Menge von Paaren (k1, k2) mit k1 ∈ K1 , k2 ∈ K2 , so dass f (k1, k2) = true
ist für eine boolesche Funktion f
(wenn k1 zum Verschlüsseln benutzt worden ist, so muss k2 zum Entschlüsseln
benutzt werden)
E := {Ek1 | k1 ∈ K1 }: Familie von Chiffrieralgorithmen
D := {Dk2 | k2 ∈ K2 }: Familie von Dechiffrieralgorithmen
Für jedes m ∈ P und jedes Paar (k1, k2) ∈ K muss gelten:
Dk2 (Ek1 (m)) = m
27
symmetrische Kryptosysteme (secret key cryptosystems)
k1 und k2 sind geheim (und oft gleich)
Alice sendet an Bob eine verschlüsselte Nachricht
eavesdropper
key source
k
secure channel
k
encryption
E (m) = c
k
decryption
c
unsecure channel
D (c) = m
k
m
m
m
plaintext m
Alice
Bob
k: gemeinsamer geheimer Schlüssel (secret key)
m: Klartext, Nachricht, message, plaintext
c: Geheimtext, Chiffretext, ciphertext
(Alice und Bob können denselben Tresor öffnen, der zur Hinterlegung und damit
Übermittlung der Nachrichten dient.)
28
asymmetrische Kryptosysteme (public key crypto systems)
Alice sendet an Bob eine verschlüsselte Nachricht, wobei zur Verschlüsselung
Bob’s öffentlicher Schlüssel benutzt wird
Mr. X
e
key source
unsicherer Kanal
d
encryption
Ee (m) = c
decryption
c
unsicherer Kanal
D (c) = m
d
m
m
m
plaintext m
Alice
Bob
k1 bzw. hier e: öffentlicher Schlüssel (public key) von Bob
k2 bzw. hier d: nicht öffentlicher Schlüssel (private key) von Bob
m: Klartext (plaintext)
c: Geheimtext (ciphertext)
(Alice wirft eine Nachricht in Bob’s Briefkasten, den nur dieser öffnen kann.)
29
asymmetrische Kryptosysteme zur Erzeugung einer digitalen Unterschrift
Alice sendet an Bob eine Nachricht, die von ihr digital signiert ist
eavesdropper
key source
e
d
ds = Ed (md)
md = De (ds)
ds
md
ja
md
md = md1 ?
nein
md1
accept
md = h(m)
md1 = h(m)
accept
m
plaintext m
do not
m
m
m
Bob
Alice
k1 bzw. hier d: private key von Alice
k2 bzw. hier e: public key von Alice
m: Klartext (plaintext)
h: kryptographische Hash–Funktion
md: Hashwert (hash value, message digest, finger print)
ds: digitale Signatur (digitale Unterschrift, digital signature)
(Nur Alice hat den Schlüssel zu einem gläsernen Tresor, in den sie Nachrichten
hineinlegen kann.)
30
generelle Attacken
Ciphertext–Only–Attacke:
Mr. X kennt ein relativ großes Stück Ciphertext oder mehrere Ciphertexte, die
mit demselben Verfahren verschlüsselt wurden.
Er versucht, einen oder mehrere Klartexte oder gar den Schlüssel zu bestimmen.
Known–Plaintext–Attacke:
Mr. X kennt ein oder mehrere Paare von zusammengehörenden Klar– und Geheimtexten.
Er versucht, den verwendeten Schlüssel zu berechnen oder einen Algorithmus
zu finden, mit dem weitere Chiffretexte, die mit demselben Schlüssel erhalten
wurden, entschlüsselt werden können.
Chosen–Plaintext–Attacke:
Mr. X kennt wie eben ein oder mehrere Paare von zusammengehörenden Klar–
und Geheimtexten. Zusätzlich hatte Mr. X die Möglichkeit, ausgewählte Klartexte verschlüsseln zu lassen.
Er versucht dann wieder, den verwendeten Schlüssel zu berechnen oder einen
Algorithmus zu finden, mit dem weitere Chiffretexte, die mit demselben Schlüssel erhalten wurden, entschlüsselt werden können.
Chosen–Ciphertext–Attacke:
Mr. X hat zeitweisen Zugriff zum Dechiffrieralgorithmus, kann sich also für einige Chiffre–Texte die zugehörigen Klartexte berechnen.
Ziel ist, den Schlüssel zu bestimmen.
(Die schwierigste der obigen Attacken ist i. a. aufgrund ihrer schwachen Voraussetzungen die Ciphertext–Only–Attacke.)
31
kryptographisches Protokoll
Ein kryptographisches Protokoll dient wie jedes Protokoll einer bestimmten
Aufgabe und besteht aus einer Folge von Aktionen, an denen zwei oder mehr
Parteien beteiligt sind. Keine Aktion kann vor Abschluss der vorherigen ausgeführt werden. Weiterhin gilt:
1. Alle, die am Protokoll teilnehmen, müssen das gesamte Protokoll im voraus
kennen.
2. Alle Teilnehmer müssen sich an die vereinbarten Regeln halten.
3. Jede Aktion muss eindeutig festgelegt sein.
4. Das Protokoll muss vollständig sein: Jeder denkbaren Situation ist eine
bestimmte Aktion zugeordnet.
Die Aktionen können z.B. sein:
Ver– und Entschlüsseln von Nachrichten
Senden einer Nachricht an einen Teilnehmer
Nachricht mit digitaler Unterschrift versehen
Authentifizierung eines Teilnehmers
···
32
Angriffe auf kryptographische Protokolle
Replay–Angriffe (replay–attacks)
Mallory fängt eine chiffrierte Nachricht von Alice an Bob ab und sendet
diese weitere Male an Bob. Falls die Nachricht eine Anweisung an Bob
enthält (z.B. einen bestimmten Gegenstand zu kaufen), so führt Bob diese
Anweisung wiederholt aus.
Der Angriff läuft ins Leere, wenn Alice ihre Nachricht vor dem Verschlüsseln mit einem Zeitstempel (time stamp) versehen hat.
Spoofing–Angriffe
Wenn Mallory das Protokoll kennt, mit dessen Hilfe Alice an Bob eine
Nachricht sendet, so kann er sich leicht Bob gegenüber als Alice ausgeben:
Er braucht nur die entsprechende IP–Adresse im Protokoll zu ändern.
Durch Maßnahmen zur Authentifizierung wird ein solcher Angriff unmöglich.
Man–in–the–middle–Angriffe
Mallory fängt die Kommunikation zwischen Alice und Bob ab und gibt
sich Alice gegenüber als Bob und Bob gegenüber als Alice aus.
Vermeidung eines solchen Angriffs z.B. durch Verwendung von PKI (public key infrastructure) und digitalen Zertifikaten sowie anderen Methoden
zur Authentifizierung (Name/Passwort, one–time–Passwörter (RFC 1938),
z.B. TAN’s (transaction numbers), Frage–und–Antwort (challenge–and–
response) wie z.B. bei der Authentifizierung eines Handys in Mobilfunknetzen), gegenseitige Authentifizierung und Schlüsselaustausch mit Hilfe
einer dritten vertrauenswürdigen Partei (TTP, trusted third party) wie
z.B. im Kerberos–Protokoll (s.u.)
Hijacking
Kann als Kombination von Spoofing– und Man–in–the–middle–Attacken
aufgefasst werden: Zusätzlich zum Man–in–the–middle–Angriff blockiert
Mallory die Kommunikation zwischen Alice und Bob ab einem bestimmten
Zeitpunkt und kommuniziert etwa nur noch mit Bob.
Denial–of–Service–Angriffe (DoS)
Mallory versucht, eine Kommunikation zwischen Alice und Bob zu verhindern, indem er Nachrichten blockiert, Nachrichten fälscht oder abgefangene
(und manchmal gefälschte) Nachrichten in großer Anzahl immer wieder an
Bob sendet, damit dieser zumindest zeitweise nicht die Nachrichten von
Alice lesen kann.
33
Substitutions–Chiffre (am Beispiel Z26 )
P:
Menge aller Texte über Z26 := {0, 1, · · · , 25}
C:
Menge aller Texte über Z26 := {0, 1, · · · , 25}
K := {(P, P −1 ) | P und P −1 sind zueinander inverse Permutationen
über Z26}
EP (x) := P (x) für x ∈ Z26
DP −1 (x) := P −1 (x) für x ∈ Z26
Affine Chiffre (Tauschchiffre) (am Beispiel Z26 ):
P:
Menge aller Texte über Z26 := {0, 1, · · · , 25}
C:
Menge aller Texte über Z26 := {0, 1, · · · , 25}
K1 , K2 := {(a, b) | a, b ∈ Z26
∧
gcd(a, 26) = 1}
K := {((a, b), (c, d)) | (a, b) ∈ K1 ∧ c = a−1 (mod 26)
∧ d = a−1 ∗ b (mod 26)}
E(a,b) (x) := a ∗ x + b
(mod 26)
D(c,d) (y) := c ∗ y − d (mod 26)
mit c = a−1
(mod 26), d = a−1 ∗ b
(mod 26)
34
Relative Häufigkeiten der Buchstaben in (genügend langen) deutschen bzw.
englischen Texten (in Prozent)
Buchstabe
a
b
c
d
e
f
g
h
i
j
k
l
m
deutsch
6.51
1.89
3.06
5.08
17.4
1.66
3.01
4.76
7.55
0.27
1.21
3.44
2.53
englisch
8.2
1.5
2.8
4.3
12.7
2.2
2.0
6.1
7.0
0.2
0.8
4.0
2.4
Buchstabe
n
o
p
q
r
s
t
u
v
w
x
y
z
deutsch
9.78
2.51
0.79
0.02
7.00
7.27
6.15
4.35
0.67
1.89
0.03
0.04
1.13
englisch
6.7
7.5
1.9
0.1
6.0
6.3
9.1
2.8
1.0
2.3
0.1
2.0
0.1
Daraus ergeben sich folgende relative Häufigkeiten für Buchstabengruppen in
deutschen Texten:
Gruppe
e, n
i, s, r, a, t
d, h, u, l, c, g, m, o, b, w, f, k, z
p, v, j, y, x, q
Anteil in Prozent
27.18
34.48
36.52
1.82
Relative Häufigkeiten von Bigrammen in (genügend langen) deutschen Texten
(in Prozent):
Buchstabenpaar
en
er
ch
te
de
Häufigkeit
3.88
3.75
2.75
2.26
2.00
Buchstabenpaar
nd
ei
ie
in
es
35
Häufigkeit
1.99
1.88
1.79
1.67
1.52
Polyalphabetisches Chiffrieren mit mengenwertigen Abbildungen f
am Beispiel der Alphabete Z26 und {00, 01, · · · , 98, 99}
P:
Menge aller Texte über Z26 := {0, 1, · · · , 25}
C:
Menge aller Texte über {00, 01, · · · , 98, 99}
K1 , K2 := {f | f : Z26 −→ ℘({00, · · · , 99}) ∧
f (α) 6= ∅
∧
(α 6= β → f (α) ∩ f (β) = ∅)}
Ef (x) := beliebiges Element aus f (x)
Df (y) := f −1(y)
(allgemein: ersetze Z26 durch ein Alphabet A und {00, · · · , 99} durch ein Alphabet B mit card(A) ≤ card(B))
Vigenére–Chiffre (am Beispiel Z26):
m:
Schlüsselwortlänge
P:
Menge aller Texte der Länge m über Z26
C:
Menge aller Texte der Länge m über Z26
K1 , K2 := Menge aller Texte der Länge m über Z26;
für jedes k1 ∈ K1 , k1 := (κ1, · · · , κm ), sei k1 = k2 und
Ek1 (β1, · · · , βm ) := (β1 + κ1 , · · · , βm + κm ) (mod 26)
Dk1 (γ1, · · · , γm) := (γ1 − κ1 , · · · , γm − κm ) (mod 26)
36
Kasiski– und Friedman–Test
Kasiski–Test (bestimmt ein Vielfaches der Schlüsselwortlänge):
1. suche im Ciphertext Paare von (möglichst langen) gleichen Zeichenketten
und bestimme die jeweiligen Abstände ihrer ersten Zeichen
2. bestimme den größten gemeinsamen Teiler aller dieser Abstände; dieser
ist ein Vielfaches der Schlüsselwortlänge, es sei denn, unter den Paaren
gleicher Zeichenketten ist ein solches, das zufällig nicht durch Chiffrieren
zweier gleicher Klartext–Zeichenketten entstanden ist
Friedman–Test (bestimmt die Größenordnung der Schlüsselwortlänge):
1. Es sei n1 die Anzahl der a’s, · · ·, n26 die Anzahl der z’s in einem deutschen
Klartext mit n Zeichen. Dann gibt der Friedman’sche Koinzidenzindex
I mit
P26
ni ∗ (ni − 1)
I = i=1
n ∗ (n − 1)
ungefähr die Wahrscheinlichkeit dafür an, dass zwei willkürlich aus dem
Text herausgegriffene Buchstaben gleich sind
2. Nach der Tabelle über die relativen Häufigkeiten p1 , · · · , p26 der Buchstaben
in deutschen Texten mit großer Länge n ist
26
X
i=1
p2i = 0.0762
Also mit 7.62–prozentiger Wahrscheinlichkeit sind zwei willkürlich aus dem
Text herausgegriffene Buchstaben gleich.
3. Falls in einem Text alle 26 Buchstaben gleichoft vorkommen würden (pi =
1/26 für alle i, 1 ≤ i ≤ 26), so wäre
26
X
i=1
p2i = 26 ∗
1
1
=
≈ 0.0385
262
26
(kleiner kann I nicht werden).
37
4. Annahme: Das Schlüsselwort besteht aus s paarweise verschiedenen Buchstaben. Man denke sich dann den Ciphertext, der aus n Zeichen besteht,
fortlaufend in s Spalten geschrieben.
Anzahl der Möglichkeiten, ein Paar aus einer Spalte zu wählen:
n
n ∗ (n − s)
n ∗ ( − 1)/2 =
s
2s
Anzahl der Möglichkeiten, ein Paar aus verschiedenen Spalten zu wählen:
n
n2 ∗ (s − 1)
n ∗ (n − )/2 =
s
2s
5. Also gilt für die erwartete Anzahl A von Paaren gleicher Buchstaben
n ∗ (n − s)
n2 ∗ (s − 1)
A≈
∗ 0.0762 +
∗ 0.0385
2s
2s
Die Wahrscheinlichkeit dafür, dass ein Paar willkürlich herausgegriffener
Buchstaben gleich ist, hat also ungefähr den Wert
A
≈I
n ∗ (n − 1)/2
Daraus ergibt sich für s
s≈
0.0377 ∗ n
(n − 1) ∗ I − 0.0385 ∗ n + 0.0762
Bestimmung des Schlüsselwortes:
Da die s Spalten jede für sich durch eine Verschiebechiffre erzeugt wurden,
reicht es aus, etwa jeweils den Buchstaben zu finden, der durch Chiffrieren von
e entstanden ist.
38
Hill–Chiffre (am Beispiel Z26)
m ∈ N, m ≥ 1 vorgegeben;
P:
Menge aller Texte der Länge m über Z26
C:
Menge aller Texte der Länge m über Z26
K := {(A, A−1) | A und A−1 sind modulo 26 zueinander inverse
(m, m)–Matrizen über Z26 }



EA (x1, · · · xm) := A ∗ 

x1
..
.
xm








DA−1 (y1, · · · , ym ) := A−1 ∗ 

für (x1, · · · , xm) ∈ (Z26)m
y1
..
.
ym





für (y1, · · · , ym) ∈ (Z26)m
(falls Klar– bzw. Geheimtext länger sind als m, so werden sie in Blöcke der
Länge m zerlegt; evtl. Auffüllen (padding) des letzten Blockes)
Spezialfall: Falls A (und damit auch A−1) eine Permutationsmatrix ist, so spricht
man auch von einer Permutationschiffre.
39
One–time Pad
n ≥ 1:
Länge des Plaintextes (hier als Bitfolge)
P := (Z2 )n
C := (Z2 )n
K1 , K2 := (Z2 )n
K := {(k, k) | k = (κ1 , · · · , κn ) ∈ (Z2 )n}
Ek (x) := (x1 + κ1 , · · · , xn + κn ) (mod 2)
Dk (y) := (y1 + κ1 , · · · , yn + κn ) (mod 2)
Für jede Verschlüsselung wird ein neuer, zufälliger Schlüssel k generiert und
benutzt.
Perfekte Sicherheit:
Ein Kryptosystem (P, C, K, E, D) heißt perfekt sicher, falls P (x | y) = P (x) gilt
für alle x ∈ P, y ∈ C.
Also: Jeder abgefangene noch so lange Geheimtext bringt keine neuen Erkenntnisse über den möglichen Klartext.
Es gilt für jedes Kryptosystem Γ = (P, C, K, E, D):
Es sei card(K) = card(P) = card(C);
dann liefert Γ perfekte Sicherheit ⇐⇒
jeder Schlüssel wird mit der gleichen Wahrscheinlichkeit 1/card(K) benutzt, und für jedes x ∈ P und jedes y ∈ C gibt es genau ein k ∈ K mit
Ek (x) = y
Γ perfekt sicher
=⇒ jedes x ∈ P kann mit geeignetem k ∈ K auf jedes
y ∈ C abgebildet werden
Γ perfekt sicher
=⇒
card(K) ≥ card(C) ≥ card(P)
40
Entropie als Maß für den Grad der Zufälligkeit
Es seien X eine diskrete Zufallsvariable, W (X) die Menge aller ihrer möglichen
Werte, und für ein beliebiges ξ ∈ W (X) sei P (X = ξ) die Wahrscheinlichkeit
dafür, dass X den Wert ξ annimmt (in der Praxis wird P (X = ξ) meist durch
die relative Häufigkeit des Wertes ξ ersetzt). Dann ist die Entropie H(X) von
X wie folgt definiert:
H(X) := −
X
ξ∈W (X)
P (X = ξ) ∗ log2 (P (X = ξ)) [Bit]
Beispiele:
Modelliert X zufällige Würfe einer nicht gezinkten Münze, so ist W (X) =
{W appen, Zahl}, jedes der beiden Ereignisse hat die Wahrscheinlichkeit
0.5, und die Entropie von X ist 1 Bit.
Modelliert X zufällige Würfe eines nicht gezinkten Würfels, so ist W (X) =
{1, 2, 3, 4, 5, 6}, jedes der sechs Ereignisse hat die Wahrscheinlichkeit 1/6,
und die Entropie von X ist − log2(1/6) ≈ 2.586 Bit.
Modelliert X ein zufälliges Grauwertbild mit 128 × 128 Pixeln, wobei jedes
Pixel völlig unabhänging von den anderen völlig zufällig einen der Werte
von 0 bis 255 annehmen kann, so kann X also 256128∗128 paarweise verschiedene Werte, alle mit der Wahrscheinlichkeit 1/256128∗128, annehmen.
Die Entropie von X ist damit − log2(1/256128∗128) = − log2 (2−8∗128∗128) =
8*128*128 = 131072 Bit.
Modelliert dagegen X die in einem Grauwertbild vorkommenden Grauwer-
te der einzelnen Pixel, so muss man die relativen Häufigkeiten der vorhandenen Grauwerte bestimmen und dann nach obiger Formel die Entropie
berechnen. Sind überhaupt nur die Grauwerte von 0 bis 255 möglich, so
kann die Entropie maximal den Wert 8 Bit haben (wenn nämlich alle Grauwerte gleich oft vorkommen).
Die Entropie eines Buchstabens in einer völlig zufälligen Zeichenkette, in
der überhaupt nur 26 paarweise verschiedene Zeichen vorkommen können,
ist log2 (26) ≈ 4.7 Bit.
Die Entropie eines beliebigen Zeichens in einem natürlichen deutschen oder
englischen Text liegt zwischen 1 Bit und 1.5 Bit (benutze Folie 35).
41
Es gilt:
Je mehr man über die Werte eines Zufallsstromes von n Bit weiß, d.h., je
weniger zufällig der Bitstrom eigentlich ist, umso geringer ist seine Entropie
(im Grenzfall 0 Bit, falls man weiß, dass alle Bit gleich sind; im anderen
Grenzfall n, falls jedes einzelne Bit völlig zufällig ist).
Je größer die Entropie ist, umso unsicherer ist man beim Erraten eines
Wertes.
Die Entropie ist gleichzeitig die durchschnittliche Anzahl von Bit, die man
benötigt, um die möglichen Werte darzustellen, falls man einen idealen
Komprimierungsalgorithmus zur Verfügung hat.
Mittlere Codewortlänge ml:
ml :=
X
ξ∈W (X)
P (X = ξ) ∗ lξ
wobei lξ die Länge des Codewortes (das sich durch Anwendung des Komprimierungsalgorithmus’ ergibt) zur Darstellung von ξ ist.
42
Stromchiffrierung
hier: Beschränkung auf Z2 als Alphabet
P := Menge aller Texte über Z2
C := Menge aller Texte über Z2
K1 , K2 := Menge aller Texte über Z2
K := {(k, k) | k = (κ1 , · · · , κn ) ∈ K1 }
für jedes p ∈ P, p = (p1, · · · , pn), und jedes k ∈ K1 mit gleicher Länge,
k = (κ1, · · · , κn ), sei
Ek (p) := (p1 + κ1 , · · · , pn + κn ) (mod 2)
für jedes c ∈ C mit Ek (p) = c ist dann Dk (c) = p, wenn
Dk (c) := (c1 + κ1 , · · · , cn + κn ) (mod 2)
gesetzt wird.
Zur Erzeugung eines Schlüssels (”Schlüsselstromes”) k wird meist ein Zufallszahlengenerator (key stream generator) verwendet, der seinerseits von einem
Schlüssel (⇒ Initialisierung) sowie evtl. von den bis zu einem Zeitpunkt gerade
betrachteten Klartextzeichen abhängen kann.
Bei nur einmaliger Benutzung ein und desselben Schlüssels hat man wieder das
one–time pad.
43
Vorteil:
Falls einmal ein Bit fehlerhaft übermittelt wird, so wird auch nur diese eine Bit fehlerhaft
entschlüsselt (also keine ”Langzeitwirkung”).
Nachteile:
Falls ein Bit überhaupt nicht ankommt, so entsteht ab dort beim Entschlüsseln nicht mehr
der gewünschte Klartext. Eine erneute Synchronisation ist notwendig.
Falls ein und derselbe Schlüsselstrom mehrfach verwendet wird:
1. Wenn Mr. X einen Chiffretext und den dazugehörigen Klartext besitzt, so erhält er
durch xor–Verknüpfung der beiden den Schlüsselstrom und könnte weitere Chiffretexte dechiffrieren (known–plaintext–Attacke erfolgreich).
2. Wenn Mr. X zwei verschiedene Chiffretexte besitzt, die mit dem gleichen Schlüsselstrom chiffriert wurden, so erhält er durch deren xor–Verknüpfung gleichzeitig die
xor–Verknüpfung der zugehörigen Klartexte. Daraus können aber u.U. relativ leicht
(s. nächste Folie) die Klartexte und der zugehörige Schlüsselstrom erhalten werden
(ciphertext–only–Attacke erfolgreich).
3. Angriff durch Einfügen:
Klartext:
Schlüsselstrom:
Chiffretext:
p1 p2 p3 · · ·
k1 k2 k3 · · ·
c1 c2 c3 · · ·
Wenn es Mr. X schafft, einen Klartextbuchstaben p′ in den Klartext einzufügen, etwa
unmittelbar hinter p2 , und weiterhin der veränderte Klartext wieder mit dem ursprünglichen Schlüsselstrom chiffriert wird, so kann er aus den beiden Chiffretexten
den Klartext ab der Einfügeposition erhalten (chosen–plaintext–Attacke erfolgreich):
Klartext:
Schlüsselstrom:
Chiffretext:
p1 p2 p′ p3 · · ·
k1 k2 k3 k4 · · ·
c1 c2 c′3 c′4 · · ·
Mr. X kennt p′ (und die Chiffretexte) und kann damit sukzessive berechnen:
k3 = p′ + c′3
k4 = p3 + c′4
k5 = p4 + c′5
p 3 = k 3 + c3
p 4 = k 4 + c4
p 5 = k 5 + c5
usw. (alle Berechnungen modulo 2).
Auch wenn Mr. X die Einfügestelle nicht genau kennt, so kann er sie durch Vergleichen von c1 c2 c3 c4 · · · mit c1 c2 c′3 c′4 · · · finden.
44
Beispiel zur xor–Verschlüsselung
Bild 3 ist durch xor–Verknüpfung von Bild 1 mit dem Zufallsbild 2 und Bild 5
durch xor–Verknüpfung von Bild 4 ebenfalls mit dem Zufallsbild 2 entstanden.
Werden jetzt die Geheimtexte Bild 3 und Bild 5 xor-verknüpft, so entsteht Bild
6, aus dem die Inhalte von Bild 1 und Bild 4 (das sind hier die Klartexte)
rekonstruiert werden können. Durch xor–Verknüpfung von Bild 1 mit Bild 3
würde man dann den Schlüssel Bild 2 erhalten.
Bild 1
Bild 2
Bild 3
Bild 4
Bild 5
Bild 6
45
Zufallszahlengeneratoren
Die Sicherheit einer Stromchiffre wie beispielsweise die des one–time–pads
und vieler anderer kryptographischer Algorithmen, die Zufallszahlen benötigen, hängt wesentlich davon ab, dass ein Angreifer diese Werte weder erraten noch berechnen kann. Die Quelle der Zufallszahlen muss also mindestens eine möglichst hohe Entropie haben. Darüber hinaus verlangt man von
einem Pseudo–Zufallszahlen–Generator (PRNG) noch die beiden folgenden
Eigenschaften, um ihn einen kryptographisch sicheren Pseudo–Zufallszahlen–
Generator (CSPRNG) nennen zu können:
Er sollte den nächste–Bit–Test erfüllen: Angenommen, man kennt be-
reits die ersten k Bits des erzeugten Schlüsselstromes, so soll es nicht in
polynomialer Zeit möglich sein, mit einer Wahrscheinlichkeit größer als 0.5
das nächste Bit (das (k + 1)–te Bit) zu berechnen (egal, wie groß k ∈ N
ist).
Er sollte den nicht–Zurückverfolgbarkeits–Test erfüllen: Falls jemand
den augenblicklichen Zustand des Generators kennt oder korrekt erraten
hat, so sollte es ihm nicht möglich sein, davon ausgehend den bis dahin
erzeugten Bitstrom zu rekapitulieren.
Neben den auf den folgenden Folien und im Abschnitt zu den zahlentheoretischen Grundbegriffen vorgestellten PRNG’s gibt es weitere zum Teil standardisierte Algorithmen wie den ANSI–Standard X9.17, wo mit Hilfe von Triple–DES
(s. u.) eine zufällige Bitfolge erzeugt wird. Auch können die Zufallsbits verschiedener Generatoren gemischt und darauf kryptographische Hash–Funktionen angewendet werden, um sichere Zufallsbits zu erhalten.
Schließlich werden in Menezes et.al., Kapitel 5, weitere Algorithmen vorgestellt
(z. B. der FIPS–186–Generator) sowie Methoden zur Nachbearbeitung zufällig
erzeugter Bitfolgen, um deren statistische Eigenschaften zu verbessern. Zur Beurteilung der Zufälligkeit der erzeugten Bits kann der Statistik–Test FIPS–140-1
herangezogen werden.
46
Erzeugung eines Schlüsselstromes durch lineare Rekursion bzw. mit
Hilfe von linearen rückgekoppelten Schieberegistern (LFSR)
lineare Rekursion vom Grad m
zi+m :=
m−1
X
j=0
cj ∗ zi+j
(mod 2),
(i ≥ 0)
wobei c0 , · · · , cm−1 ∈ Z2 vordefinierte Konstanten sind;
k := (z0 , · · · , zm−1) ist der Schlüssel, durch ihn erfolgt die Initialisierung
Die obige lineare Rekursion entspricht dem folgenden m–stufigen linearen
rückgekoppelten Schieberegister, das im Anfangszustand gegeben ist:
+
* cm-1
z
m-1
+
+
* c m-2
*c 1
z
m-2
z
1
*c 0
z
0
(s. auch: Menezes et al.: chapter 5, pseudorandom bits and sequences)
47
Funktelefone mit GSM–Standard (Group Special Mobile), z.B. D1,
D2 und e–plus
handy
sprechen
digitalisieren
komprimieren
verschlüsseln
114 Bit lange
Datenpakete
Funk
Basisstation
dechiffrieren
Basisstation
Glasfaser
chiffrieren
handy
dechiffrieren
zusammensetzen
Analog- bzw. Digitaltelefon
hören
hören
Nachrichtenübermittlung mit Verschlüsselung zwischen Handy und Basisstation, wobei die Verschlüsselung mit dem A5–Algorithmus (Stromchiffre) erfolgt.
48
A5/1–Algorithmus
3 LFSR’s mit 19, 22 bzw. 23 Bit Länge, also insgesamt 64 Bit Schlüssellänge
für die Initialisierung
XOR–Verknüpfung im ersten LFSR: 13, 16, 17, 18
XOR–Verknüpfung im zweiten LFSR: 20, 21
XOR–Verknüpfung im dritten LFSR: 7, 20, 21, 22
(s. z. B. Schmeh, S. 249)
Ausgabe: XOR–Verknüpfung der drei LFSR’s
0
18
+
0
21
+
+
0
22
+
: clocking tap
Jedes Register wird abhängig von seinem mittleren Bit (clocking tap) getaktet:
Wenn es in den drei clocking taps mehr Einsen als Nullen gibt, dann werden
diejenigen LFSR’s weitergeschaltet, die in ihren clocking taps eine Eins haben.
Wenn es dagegen in den drei clocking taps mehr Nullen als Einsen gibt, dann
werden diejenigen LFSR’s weitergeschaltet, die in ihren clocking taps eine Null
haben. Damit werden in jedem Takt immer mindestens zwei LFSR’s weitergeschaltet.
Mit dem erzeugten Bitstrom werden die Nachrichten xor–ver– bzw. entschlüsselt.
49
GSM–Standard
in jedem Funktelefon ist SIM–Karte, die Chip enthält
im Chip: Seriennummer, geheime Zahl Z (in jedem Chip andere), Algo-
rithmen A3 und A8 (nicht spezifiziert; A3 für Authentifizierung, A8 für
Schlüsselübergabe; jeder Netzbetreiber hält diese Algorithmen geheim)
auch Netzbetreiber hat Z in seinem Computer
Vorgehensweise: Teilnehmer will anrufen =⇒ Chip sendet seine Serien-
nummer (damit ist Teilnehmer bekannt) =⇒ Computer sucht zugehörige
Geheimzahl Z und sendet eine Zufallszahl RAND als Antwort =⇒ Chip
berechnet aus RAND und Z mit Hilfe von A3 eine 32–Bit–Antwort RES
=⇒ RES wird an Basisstation gesendet =⇒ Basisstation hat selbst RES’
berechnet und vergleicht =⇒ falls RES = RES’, so Anruf zulässig, d.h.,
Netz wird nicht unbefugt von anderen benutzt
zusätzlich: Chip und Rechner der Basisstation berechnen jeder für sich
mittels A8 den 64–Bit–Sitzungsschlüssel K (der also nicht gefunkt zu werden braucht), mit dem jede Seite für sich mit Hilfe von A5 chiffriert und
dechiffriert
Ausland: A3 und A8 i.a. anders; ausländisches Netz erkennt, dass Handy
nicht angemeldet ist, und lässt sich im voraus RAND, RES und K zur
Authentifizierung und Chiffrierung senden (Verträge der Netzanbieter untereinander)
50
Vergleich GSM mit UMTS
GSM
UMTS
64–Bit–Schlüssel, effektiv nur 54–
128–Bit–Schlüssel
Bit–Schlüssel
Verschlüsselung nur bis zur Basissta- Verschlüsselung reicht tiefer
ins Netz hinein
tion
geheimgehaltene Algorithmen
Algorithmen sind offengelegt
Sicherheit basiert auf Geheimzahl in
ebenso
SIM–Karte
Authentifizierung über Tripletts (drei Benutzung von Quintetts
(fünf 128–Bit-Zahlen)
64–Bit–Zahlen)
pro Verbindungsaufnahme ein Tri- zusätzlich ”lokale Authentiplett erforderlich
fizierung”
nur das Handy muss sich gegenüber gegenseitige Authentifizierung von
Basisstation und Handy
der Basisstation authentifizieren
Integritätsprüfung mit dem
keine Identitätsprüfung des Datenintegrity key, replay und
stromes, aktive Angriffe (replay, man
man in the middle schwierig
in the middle) möglich
bis unmöglich
(Quelle: Computerzeitung vom 01.02.2001)
51
RSA–public–key–Verfahren zur Erzeugung eines Schlüsselstromes
z1 z2 · · · zt
gegeben:
p, q: zwei verschiedene große Primzahlen mit je m/2 Bit in Dualdarstellung; eine
natürliche Zahl t als Länge des zu erzeugenden Schlüsselstromes
n := p ∗ q
e eine Zufallszahl mit gcd(e, Φ(n)) = 1
(es ist dann Φ(n) = (p − 1) ∗ (q − 1)); n und e sind öffentlich, p, q und Φ(n)
sind geheim;
Schlüssel k ∈ Z∗n , k habe m Bits (oder auch einfach nur 1 ≤ k ≤ n − 1)
Iteration:
k1 := k,
ki+1 := kie mod n
(1 ≤ i ≤ t − 1);
Schlüsselstrom:
zj := kj mod 2
(1 ≤ j ≤ t)
Bemerkungen:
Wenn auf irgendeine Art und Weise von Mr. X ein zi bestimmt werden
konnte, so kann er auf dieser Basis nicht ki erhalten; selbst wenn er sich
irgendwie ein ki besorgt hat mit i > 1, so ist es für große Primzahlen p, q
(beispielsweise je mindestens 512 Bit lang) praktisch unmöglich, ki−1 und
damit letztlich k zu berechnen:
Denn um ki−1 aus ki berechnen zu können, muss man dasjenige d ∈ Z∗n
kennen, so dass
e ∗ d = 1 mod Φ(n), also (se )d = s mod n
für beliebiges s ∈ Z∗n
ist. φ(n) und damit d zu bestimmen (wenn man p und q nicht kennt) ist
aber genau so schwierig, wie n zu faktorisieren.
Damit es mit den bis jetzt bekannten Faktorisierungsalgorithmen praktisch
unmöglich ist, n zu faktorisieren bzw. Φ(n) zu berechnen, sollten p und q
zusätzlich die folgenden Eigenschaften haben:
Die Differenz | p − q | sollte möglichst groß sein.
p und q sollten starke Primzahlen sein, d.h., es sollte weiterhin gelten:
p − 1 hat einen großen Primfaktor, bezeichnet mit r;
p + 1 hat einen großen Primfaktor
und
r − 1 hat einen großen Primfaktor
52
MILLER–RABIN–Algorithmus zum Testen einer Zahl n auf
Primzahleigenschaft
gegeben:
eine ungerade natürliche Zahl n und eine natürliche Zahl t ≥ 1 als Sicherheitsparameter
gesucht:
Eine Antwort auf die Frage: ”Ist n eine Primzahl?”
Algorithmus:
bestimme diejenigen natürlichen Zahlen r und s, so dass gilt:
n − 1 = 2s ∗ r und r ungerade
for i:=1 to t do
1. wähle eine Zufallszahl a mit 2 ≤ a ≤ n − 1
2. y := ar mod n
3. if y 6= 1 and y 6= n − 1 then
begin j := 1;
while j ≤ s − 1 and y 6= n − 1 do
begin
y := y 2 mod n;
if y = 1 then return(’nein’);
j := j + 1;
end;
if y 6= n − 1 then return(’nein’);
end;
return(’ja’)
Bemerkungen:
Für jede ungerade zusammengesetzte Zahl n ist die Wahrscheinlichkeit dafür, dass obiger
MILLER–RABIN–Algorithmus das Resultat ’ja’ liefert, kleiner als (1/4)t . Oft ist diese
Wahrscheinlichkeit sogar viel kleiner als (1/4)t .
Dies beruht auf folgendem Fakt: Falls n eine zusammengesetzte ungerade Zahl ungleich
9 ist, so ist die Anzahl aller Zahlen a mit 2 ≤ a ≤ n − 1, die im MILLER–RABIN–
Algorithmus ein Resultat ’ja’ zur Folge hätten, kleiner gleich Φ(n)/4.
Der MILLER–RABIN–Algorithmus beruht auf dem kleinen Satz von FERMAT und darauf, dass die Zahl 1 modulo einer Primzahl n nur sich selbst und n-1 als Quadratwurzeln
hat. Modulo einer zusammengesetzten Zahl n hat die Zahl 1 stets weitere Quadratwurzeln
modulo n.
Falls der MILLER–RABIN–Algorithmus als Resultat ’nein’ liefert, so ist n garantiert
zusammengesetzt.
Falls n eine Primzahl ist, so liefert der MILLER–RABIN–Algorithmus garantiert den
Wert ’ja’.
53
Erzeugung einer starken Primzahl p (Algorithmus von GORDON)
erzeuge zwei große zufällige Primzahlen s und t mit ungefähr glei-
cher Bitlänge (Test auf Primzahleigenschaft etwa mit MILLER–RABIN–
Algorithmus)
wähle eine natürliche Zahl i0 ; finde die erste Primzahl r = 2it + 1, wobei i
nacheinander die Werte i0 , i0 + 1, i0 + 2, · · · durchläuft (Test auf Primzahleigenschaft wieder mit MILLER–RABIN–Algorithmus)
berechne p0 := (2sr−2 mod r)s − 1
wähle eine natürliche Zahl j0 ; finde die erste Primzahl p := p0 +2jrs, wobei
j nacheinander die Werte j0 , j0 + 1, j0 + 2, · · · durchläuft
p ist eine starke Primzahl
denn es gilt dann für die Primzahl p:
p + 1 = (2 ∗ sr−2 mod r) ∗ s − 1 + 2jrs + 1 = s ∗ (· · ·),
womit p + 1 den großen Primfaktor s hat;
seien λ und s′ diejenigen ganzen Zahlen, für die gilt:
s = λ ∗ r + s′ und 0 ≤ s′ < r;
dann gilt:
p − 1 = (2 ∗ (λ ∗ r + s′ )r−2 mod r) ∗ (λ ∗ r + s′ ) + 2jrs − 2 =
(2 ∗ (s′ )r−2 mod r) ∗ (λ ∗ r + s′ ) + 2jrs − 2 =
(2 ∗ (s′ )−1 mod r) ∗ (λ ∗ r + s′ ) + 2jrs − 2 =
(2 ∗ (s′ )−1 mod r) ∗ (λ ∗ r + s′ mod r) + 2jrs − 2 =
(2 ∗ (s′ )−1 mod r) ∗ λ ∗ r + 2 + 2jrs − 2 =
r ∗ (· · ·),
womit p − 1 den großen Primfaktor r hat
(es wurde unterwegs der kleine Satz von Fermat angewandt);
r − 1 = 2it hat den großen Primfaktor t
54
Diskretes–Logarithmus–Verfahren zur Erzeugung eines
Schlüsselstromes z0 z1 z2 · · ·
gegeben:
Primzahl p
primitives Element a mod p
Schlüssel k (k ∈ Z∗p )
Iteration:
k0 := k,
ki+1 := aki mod p
Schlüsselstrom:

 1,
f alls kj > p/2
zj := 
0,
f alls kj < p/2
(i ≥ 0);
(j ≥ 0)
Bemerkung:
Wenn Mr. X ein oder mehrere zi kennt, so kann er daraus nicht ki bestimmen.
Selbst wenn er sich ein ki ”besorgt” hat mit i > 0, so ist es für große Primzahlen
p doch praktisch unmöglich, ki−1 und damit letztlich k zu berechnen:
Denn um ki−1 aus ki berechnen zu können, muss loga (ki) mod p bestimmt werden.
Das RSA–public–key–Verfahren und eine Modifikation davon, der Blum–Blum–
Shub–Generator (siehe Projektaufgaben), liefern kryptographisch sichere Folgen
von Zufallsbits unter der Voraussetzung, dass die Faktorisierung von n praktisch unmöglich ist.
Analog liefert das diskrete–Logarithmus–Verfahren zur Erzeugung eines Schlüsselstromes eine solche Folge, falls das Lösen des diskrete–Logarithmus–Problems
in Z∗p praktisch unmöglich ist. Natürlich dürfen zusätzlich die Schlüssel nicht
erraten werden können.
55
Erzeugung eines Schlüsselstromes durch RC4 (Ron Rivest 1987)
es werden eine S–BOX (substitution box) S, hier eine Permutation
(S0 , S1, · · · , S255) der Menge {0, 1, · · · , 255}, sowie ein Schlüssel K variabler Länge verwendet
Initialisierung der S–Box:
setze S0 := 0, S1 := 1, · · ·, S255 := 255;
fülle ein Byte–Array (K0, K1 , · · · , K255) derart, dass der Schlüssel K immer
wieder hintereinandergeschrieben wird, bis alle 256 Bytes überdeckt sind
j := 0;
for i := 0 to 255 do
j := (j + Si + Ki ) mod 256;
vertausche Si mit Sj ;
Erzeugung von Zufallsbytes B:
i := 0; j := 0;
repeat
i := (i + 1) mod 256;
j := (j + Si) mod 256;
vertausche Si mit Sj ;
t := (Si + Sj ) mod 256;
B := St ;
until genügend viele Bytes B erzeugt sind
Der durch Hintereinandersetzen der Bytes B erzeugte Schlüsselstrom wird dann
mit dem Klartext xor–verknüpft.
Die Anzahl der möglichen internen Zustände ist definiert über die augenblicklichen Werte von i und j sowie von den Si.
RC4 ist ein besonders schneller und weit verbreiteter Algorithmus. Er wird
z. B. in Webbrowsern (SSL–Protokoll) und bei der Absicherung von Wireless LANs benutzt (WEP–, WPA– und WPA2–Protokolle). Allerdings gibt
es auch bekanntgewordene Angriffsmöglichkeiten, siehe dazu den Artikel
rc4 schwaechen.pdf.
56
Blockchiffrierungen im ECB–Modus
Gleiche Klartextblöcke werden (bei gleichem Schlüssel) stets in gleiche Chiffretextblöcke überführt, egal an welcher Stelle im Klartext sie sich befinden.
Verschlüsseln:
P
i
E
k
C
i
(i = 1, 2, ...)
Entschlüsseln:
C
i
D
P
i
k
k: Schlüssel;
Pi bzw. Ci mit i ≥ 1: Klar– bzw. Chiffretextblöcke mit je m Bit
Vorteile:
jeder Block kann unabhängig von jedem anderen verschlüsselt bzw. ent-
schlüsselt werden =⇒ gut für Datenbankeinsatz und Parallelisierung
ein Bitfehler bei der Übertragung bleibt auf den entsprechenden Block
beschränkt
Nachteile:
gleiche Bitfolgen (z.B. Kopf– und Fußzeilen) können zum Knacken des
Codes benutzt werden
geht bei Übertragung ein Bit verloren, so ab da keine korrekte Dechiffrie-
rung möglich (es sei denn, z. B. Blockanfang– und Blockendekennzeichen
sind vorhanden)
letzter Klartextblock zu kurz: Auffüllen (padding)
Angriffsmöglichkeiten: durch block replay
57
Blockchiffrierungen im CBC–Modus
Das Ergebnis der Verschlüsselung früherer Blöcke fließt in die Verschlüsselung
des aktuellen Blockes mit ein.
Verschlüsseln:
P
1
IV
P2
...
+
+
Ek
Ek
C
1
C
Entschlüsseln:
C1
2
C2
Dk
Dk
+
+
P
1
P
2
IV
Ci := Ek (Pi ⊕ Ci−1),
. . .
. . .
. . .
...
. . .
Pi := Ci−1 ⊕ Dk (Ci)
k: Schlüssel;
Pi bzw. Ci mit i ≥ 1: Klar– bzw. Chiffretextblöcke mit je m Bit
C0 := IV: Initialisierungsvektor mit m Bit (Zeitstempel oder Zufallsbits oder
nonce–generated; nonce: number used only once)
Eigenschaften:
letzter Block muss aufgefüllt werden
ein 1–Bit–Fehler (oder auch ein größerer Fehler) in Pi beeinflusst Ci und
die folgenden Ciphertextblöcke; jedoch beim Dechiffrieren wird Pi bis auf
diesen Fehler wieder hergestellt
ein Fehler in Ci wirkt sich nur auf Pi und Pi+1 aus; also keine Fehlerfort-
pflanzung
ein Synchronisationsfehler kann ab seinem Auftreten alles verfälschen
es können immer nur ganze Blöcke verschlüsselt werden
58
aufgrund des Geburtstagsparadoxons sind nach 2m/2 Blöcken identische
Blöcke zu erwarten, womit ein Angriff möglich wäre; jedoch: m=64
2m/2 Blöcke entsprechen 34 GByte
=⇒
geeignet zur Herstellung eines MAC (Message Authentication Code)
Geburtstagsparadoxon (Grundlage für den Geburtstagsangriff, birthday
attack):
Die Wahrscheinlichkeit dafür, dass in einem Raum mit genau 23 Leuten mindestens 2 davon am gleichen Tag Geburtstag haben, ist
1−
365∗364∗···∗343
36523
≈ 0.507 (das ist überraschend groß).
Verallgemeinerung: Ein Jahr habe m Tage. In einem Raum mögen sich genau n
Leute befinden. Dann ist die Wahrscheinlichkeit dafür, dass mindestens 2 davon
am gleichen Tag Geburtstag haben, gleich
1−
1−
Qn−1 m−i
m∗(m−1)∗···∗(m−n+1)
=
1
−
n
i=1 m
m
n(n−1)
Qn−1 − i
m = 1 − e− 2m
i=1 e
=1−
Qn−1
i=1 (1
− mi ) ≈
anderes Modell:
Der Wertebereich einer Hash–Funktion h habe m Elemente (z.B. MD5: 2128;
SHA1, RIPEMD160: 2160). Es werde von n zufällig aus dem Definitionsbereich
von h ausgewählten Elementen (das sind Zeichenketten) deren jeweiliger Hash–
Wert berechnet. Dann kann aus der obigen Formel n so bestimmt werden, dass
mit mindestens der Wahrscheinlichkeit 0.5 eine Kollision auftritt:
√
n(n−1)
setze 0.5 ≈ e− 2m ; Auflösung nach n ergibt n ≈ 1.17 ∗ m
Hashfunktion mit m = 2128 Hashwerten:
Nach ca. 264 zufälligen Hashwert–Berechnungen tritt mit der Wahrscheinlichkeit
0.5 eine Kollision auf.
59
MAC (message authentication code) und HMAC (hashed message
authentication code)
MAC:
kryptographische Prüfsumme, in die neben dem Text m auch noch ein
Schlüssel k eingeht; somit kann ein MAC (im Gegensatz zu einem Hashwert) nur von den Schlüsselinhabern berechnet und auch nur von diesen
verifiziert werden
wird daher verwendet für Überprüfung der Integrität (Unversehrtheit) des
Textes (”data integrity”) und zur Überprüfung der Herkunft des Textes
(”data origin authentication”)
HMAC:
MAC, der unter Benutzung einer kryptographischen Hashfunktion h
berechnet wird, meist nach der Vorschrift
HMAC(k, m) := h((k ⊕ a)||h((k ⊕ b)||m))
mit spezifischen Konstanten a, b
Beispiele:
HmacMD5 (siehe RFC 2104); basiert auf der kryptographischen Hashfunktion MD5 (RFC 1321); erzeugt message digest der Länge 16 Byte
HmacSHA1 (RFC 2104); basiert auf SHA1 (NIST FIPS 180-1); erzeugt
message digest der Länge 20 Byte
beide Algorithmen werden weitgehend in der Internetsicherheit eingesetzt,
z.B. in TLS (Transport Layer Security)
60
Blockchiffrierungen im CFB–Modus
Verschlüsselung in kleineren Einheiten (r Bit) als Blockgröße (m Bit) möglich,
wobei im Extremfall r=1 sein kann.
Spezialfall r=m
Verschlüsselung:
P
1
IV
Ek
+
P
2
Ek
C1
+
. . .
Ek
. . .
C2
. . .
C2
. . .
Entschlüsselung:
C1
IV
D
k
+
D
k
P
1
C0 := IV;
P
2
Ci := Pi ⊕ Ek (Ci−1),
Pi := Ci ⊕ Dk (Ci−1)
+
mit Ek = Dk und i ≥ 1
61
D
k
. . .
. . .
Blockchiffrierungen im OFB–Modus
ähnlich zu CFB; nützlich, um Fehlerfortpflanzungen zu vermeiden
Verschlüsseln und Entschlüsseln mit r = m ; O o := IV
P
1
m
Oo
m
E
k
m
+
m
m
C
1
E
k
. . .
O
1
. . .
C
1
m
Oo
m
D
k
m
+
m
D
k
. . .
m
P
1
. . .
Ci := Pi ⊕ Ek (Oi−1) ;
Pi := Ci ⊕ Dk (Oi−1)
für i ≥ 1; es ist hier Ek = Dk
62
Blockchiffrierungen im CTR–Modus
(Counter–Modus;
s. http://csrc.nist.gov/publications/nistpubs/800–38a/sp800-38a.pdf)
wie im OFB–Modus wird ein genügend langer Schlüsselstrom erzeugt, mit dem
die Klartextblöcke verschlüsselt werden; kann sowohl als Block– als auch als
Stromchiffre interpretiert werden;
Algorithmus:
Ki := Ek (N once||i)
Ci := Pi ⊕ Ki
mit i= 1, 2, · · ·
bemerkenswert einfache Methode zur Schlüsselstromerzeugung
Entschlüsselung wie Verschlüsselung, damit geringer Implementierungsauf-
wand
sehr einfach beliebig parallelisierbar
typische Unterteilung eines 128–Bit–Blockes N once||i:
48–Bit–message–Nummer gefolgt von 16 zusätzlichen Bits für die Nonce
gefolgt von 64 Bits für den Zähler i
(damit können 248 verschiedene Nachrichten mit demselben Schlüssel verschlüsselt werden, und jede Nachricht darf höchstens 268 Bytes lang sein)
63
Vorgeschichte von DES
bis Anfang der 70er Jahre: kryptogr. Forschung im nichtmilitärischen Be-
reich ziemlich planlos
kommerzielle Nutzer konnten vorhandene Algorithmen bzw. Geräte nicht
einschätzen
NBS (National Bureau of Standards; jetzt NIST (National Institute of
Standards and Technology)): Ausschreibung am 15.5.73 für einen standardisierten kryptographischen Algorithmus; er sollte erfüllen:
1. hoher Grad an Sicherheit
2. vollständige Spezifikation und leicht nachzuvollziehen
3. Sicherheit des Alg. soll nur vom gewählten Schlüssel abhängen (nicht
von der Geheimhaltung des Alg.)
4. Alg. soll für alle Anwender zur Verfügung stehen
5. Alg. soll an verschiedene Anwendungen angepasst werden können
6. kostengünstige hardwaremäßige Umsetzung
7. effiziente Benutzung
8. Alg. muss validiert werden können
9. Exportfähigkeit
DES wurde am 17.3.75 durch NBS veröffentlicht
am 23.11.76 als Bundesstandard anerkannt und zur Verwendung für alle
nicht geheimen Regierungsvorgänge freigegeben (Data Encryption Standard)
Richtlinien zum Gebrauch wurden herausgegeben (z.B. für Verschlüsselung
von Passwörtern)
1981: ANSI (American National Standards Institute) erkannte DES als
Standard für privaten Sektor an (ANSI X3.92)
DES war alle 5 Jahre zu zertifizieren, zuletzt 1993 und 1998
64
Grobstruktur von DES
Klartext
64
Schlüssel
IP
64
64
Chiffrierung
48
Rundenschlüssel
64
IP
-1
64
Chiffretext
IP : Anfangspermutation
IP −1 : inverse Anfangspermutation
Chiffrierung geschieht in 16 Runden
65
48
Auswahl
Eine Runde der DES–Verschlüsselung (Feistel–Chiffre)
L
i-1
R
i-1
32
32
f
48
K
i
32
32
+
32
L
i
R
i
IP(Klartext) := L0 R0 , L0 und R0 mit je 32 Bit
Li := Ri−1
Ri := Li−1 ⊕ f (Ri−1, Ki)
Ki : Bitfolgen mit je 48 Bit, berechnet aus dem Schlüssel K, 1 ≤ i ≤ 16
Chiffretext := IP−1(R16L16)
Grundprinzip der Feistelchiffre: Zum Ver– und Entschlüsseln wird dieselbe
Funktion f verwendet. Es kann f beliebig kompliziert und braucht nicht invertierbar zu sein (s. Praktikum).
66
Wirkungsweise der in DES verwendeten Funktion f
K
R
32
E
48
48
E(R)
48
+
48
B1
B2
B3
B4
B5
B6
B7
B8
6
S1
S2
S3
S4
S5
S6
S7
S8
4
C1
C2
C3
C4
C5
32
P
32
f(R,K)
67
C6
C7
C8
Auswahltabelle der Funktion E:
32
4
8
12
16
20
24
28
1
5
9
13
17
21
25
29
2
6
10
14
18
22
26
30
3
7
11
15
19
23
27
31
4
8
12
16
20
24
28
32
5
9
13
17
21
25
29
1
Permutation P:
16
29
1
5
2
32
19
22
7
12
15
18
8
27
13
11
20
28
23
31
24
3
30
4
21
17
26
10
14
9
6
25
Substitutionsbox S1:
14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7
0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8
4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0
15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13
68
Berechnung der Rundenschlüssel K1 bis K16
K
64
PC1
56
C0
28
LS1
28
D0
28
LS1
28
C1
D1
LS2
LS2
LS16
LS16
C16
D16
56
56
PC2
PC2
48
48
K
1
K
16
Dechiffrieren eines mit DES chiffrierten Klartextes:
Auf den Chiffretext wird derselbe Algorithmus mit demselben Schlüssel K angewendet, wobei jedoch die Rundenschlüssel in der Reihenfolge K16, K15 , · · · ,
K1 verwendet werden.
Nachteil von DES: relativ kurze Schlüssellänge.
69
Auswahltabelle der Funktion PC1:
57
1
10
19
63
7
14
21
49
58
2
11
55
62
6
13
41
50
59
3
47
54
61
5
33
42
51
60
39
46
53
28
25
34
43
52
31
38
45
20
17
26
35
44
23
30
37
12
9
18
27
36
15
22
29
4
Auswahltabelle der Funktion PC2:
14
3
23
16
41
30
44
46
17
28
19
7
52
40
49
42
11
15
12
27
31
51
39
50
24
6
4
20
37
45
56
36
1
21
26
13
47
33
34
29
5
10
8
2
55
48
53
32
Nummern und Reihenfolge der Bits aus K in K1:
10
3
22
61
51
35
28
21
34
26
39
38
60
25
54
63
49 17 33 57 2 9 19 42
44 58 59 1 36 27 18 41
37 4 47 30 5 53 23 29
15 20 45 14 13 62 55 31
70
4 bekannte schwache Schlüssel in hexadezimaler Notation:
01 01 01 01
01 01 01 01
FE FE FE FE
FE FE FE FE
1F 1F 1F 1F
0E 0E 0E 0E
E0 E0 E0 E0
F1 F1 F1 F1
(Zweimal hintereinander mit demselben Schlüssel verschlüsselt ergibt wieder
den Klartext.)
3 bekannte Paare von ”halbschwachen” Schlüsseln (Auswahl):
01 FE 01 FE
01 FE 01 FE
FE 01 FE 01
FE 01 FE 01
1F E0 1F E0
0E F1 0E F1
E0 1F E0 1F
F1 0E F1 0E
01 E0 01 E0
01 F1 01 F1
E0 01 E0 01
F1 01 F1 01
(Wird der Klartext mit dem ersten Schlüssel verschlüsselt und anschließend der
Ciphertext mit dem zweiten, so erhält man wieder den Klartext.)
71
IDEA
”International Data Encryption Algorithm”; patentrechtlich geschützt (in
Europa bis zum 16.11.2011, in den USA bis 25.5.2010), darf allerdings
für nichtkommerzielle Zwecke verwendet werden, wenn die Software einen
bestimmten Copyright–Vermerk enthält;
blockorientierter Algorithmus, der 1990 in Zürich entwickelt wurde; 128
Bit Schlüssellänge;
wird als sehr sicher eingeschätzt (obwohl zur Zeit noch Angriffsmöglichkei-
ten gesucht werden) und z.B. in PGP verwendet;
arbeitet mit Klartextblöcken der Länge 64 Bit;
der gleiche Algorithmus wird, allerdings mit unterschiedlichen Teilschlüs-
seln, sowohl zum Ver– als auch zum Entschlüsseln verwendet;
benutzt wie DES zum Verschlüsseln Konfusion und Diffusion, indem un-
terschiedliche algebraische Operationen gemischt angewendet werden (xor,
Addition modulo 216, Multiplikation modulo 216+1 von Teilblöcken der
Länge 16 Bit);
arbeitet in 8 Runden
Brute–force–Angriff: Angenommen, ein Computer könnte 2.000.000.000 IDEA–
Verschlüsselungen pro Sekunde bei einem brute–force–Angriff berechnen, so
würde er zum Durchprobieren aller 2128 Schlüssel
1
2 ∗ 109 sek
3.4 ∗ 1038
2128
Jahre ≈ 5.3 ∗ 1021Jahre
sek ≈
16
7
6.4
∗
10
∗ 3.2 ∗ 10 Jahr
benötigen.
72
Struktur von IDEA
X1
16
(1)
Z1
X2
16
16
(1)
Z2
X3
16
(1)
Z3
16
X4
16
16
(1)
Z4
16
(1)
eine
Z
5
16
(1)
Runde
Z
16 6
sieben
weitere
Runden
(9)
(9)
Z1
(9)
Z2
Y1
Ausgabetransformation
Y2
(9)
Z3
Z4
Y3
Xi : Klartextblöcke
Yi : Chiffretextblöcke
(r)
Zi : Schlüsselteilblock
⊕: bitweise xor–Verknüpfung von 16–Bit–langen Teilblöcken
+ : Addition von 16–Bit–Zahlen modulo 216
⊙: Multiplikation von 16–Bit–Zahlen modulo 216 + 1; der
Teilblock Null soll 216 entsprechen
73
Y4
(r)
Erzeugung der Teilschlüssel Zi
es werden insgesamt 52 Teilschlüssel je der Länge 16 Bit benötigt (je 6 in
jeder der 8 Runden und einmalig 4 für die Ausgabetransformation)
aus dem 128 Bit langen Schlüssel werden 8 Teilschlüssel je der Länge 16
Bit herausgenommen (6 für die 1. Runde und 2 für die 2. Runde)
der Schlüssel wird dann zyklisch um 25 Bit nach links verschoben und wie-
der in 8 Teilschlüssel zerlegt; die ersten 4 werden in der 2. Runde benutzt,
die letzten 4 in der 3. Runde
dann wird der Schlüssel wieder um 25 Bit nach links verschoben usw.
Entschlüsselung:
Läuft fast genauso ab wie die Verschlüsselung. Der einzige Unterschied besteht
darin, dass sich die Reihenfolge der Teilschlüssel umdreht und diese dann noch
modifiziert werden:
Der jeweilige Dechiffrierschlüssel ist entweder die additive Inverse (modulo 216)
oder multiplikative Inverse (modulo 216 + 1) des Chiffrierschlüssels (es ist 216 +
1 eine Primzahl). Dabei stellt in IDEA der Teilschlüssel, der nur aus Nullen
besteht, bezüglich der Multiplikation modulo 216 + 1 die Zahl 216 = −1 dar, so
dass hier die multiplikative Inverse von Null wieder Null ist.
Sind
(i)
(i)
(i)
(i)
(i)
(i)
Z1 , Z2 , Z3 , Z4 , Z5 , Z6
die Teilschlüssel der Runden 1 bis 8 (1 ≤ i ≤ 8) und
(9)
(9)
(9)
(9)
Z1 , Z2 , Z3 , Z4
die der Ausgabetransformation,
so sind
(9)
(9)
(9)
(8)
(9)
(8)
(Z1 )−1, -Z2 , -Z3 , (Z4 )−1, Z5 , Z6
die Teilschlüssel der 1. Dechiffrierungsrunde,
(10−i) −1
(Z1
(10−i)
) , -Z3
(10−i)
, -Z2
(10−i) −1
, (Z4
(9−i)
) , Z5
(9−i)
, Z6
die Teilschlüssel der Dechiffrierungsrunden 2 bis 8 (2 ≤ i ≤ 8) und
(1)
(1)
(1)
(1)
(Z1 )−1, -Z2 , -Z3 , (Z4 )−1
die Teilschlüssel der Ausgabetransformation der Dechiffrierung.
74
Vorgeschichte von AES
1997 veröffentlicht das NIST folgende Kriterien für einen neuen Standard
AES als Nachfolger von DES:
– AES soll eine symmetrische Blockchiffre sein mit Blockgröße 128 Bit
und Schlüssellängen von 128, 192 und 256 Bit
– AES soll sicher sein gegen alle bekannten Angriffe, die Sicherheit soll
mathematisch begründet werden können
– AES soll einfach zu verstehen und effizient sowohl hardware– als auch
softwareseitig zu implementieren sein
– nach Möglichkeit soll AES auch weitere Blockgrößen und Schlüssellängen unterstützen
im August 1998 gibt das NIST die ersten 15 Kandidaten für AES bekannt
April 1999: die Kandidaten für das Finale werden bekanntgegegen
April 2000: 3. AES Candidate Conference mit öffentlichen Diskussionen
der folgenden 5 Algorithmen:
1. Mars von IBM
2. RC6 von RSA Laboratories
3. Rijndael der belgischen Krypto–Experten
Joan Daemen (* 1965) und Vincent Rijmen (* 1970)
4. Serpent von einem Entwicklerteam aus England, Israel und Norwegen
5. Twofish von Counterpane (Bruce Schneier)
2.10.2000: Bekanntgabe des Gewinners; es ist Rijndael
Juni 2001: AES wird offiziell zum Federal Information Processing Standard
(FIPS)
AES erlaubt sowohl Block– als auch Schlüssellängen von 128, 192 und 256
Bit
75
Grobstruktur von AES
Klartextblock (128 Bit)
Schlüssel (192 Bit)
Schlüsselexpansion
+
K0
S0
Runde 1
+
K1
S1
Runde 2
+
K2
+
K11
S11
Runde 12
+
K12
Chiffretextblock (128 Bit)
76
Eine Runde der AES–Verschlüsselung (in der letzten Runde fehlt
MixColumn)
ByteSub
ShiftRow
MixColumn
Die Runden sind schlüsselunabhängig.
Anzahl der Runden in Abhängigkeit von Blockgröße b und Schlüssellänge k:
k=128
k=192
k=256
b=128 b=192 b=256
10
12
14
12
12
14
14
14
14
77
ByteSub–Transformation:
stellt nichtlineare S–Box von AES dar
jedes Byte des Zustands wird zunächst ersetzt durch seine multiplikative
Inverse in GF(28) modulo des irreduziblen Polynoms m(x) := x8 + x4 +
x3 + x + 1 (hex.: 11Bh), wobei als Inverse von 00h wieder 00h genommen
wird
die resultierenden Bytes x7 x6 · · · x0 werden anschließend noch der folgen-
den affinen Transformation unterworfen:
for i:=0 to 7 do
yi := (xi + xi+4 + xi+5 + xi+6 + xi+7 + ci ) mod 2;
dabei werden die Indexoperationen modulo 8 ausgeführt, und es wird
c7 c6 · · · c0 := 01100011 gesetzt
das Ergebnis dieser beiden hintereinander ausgeführten Transformationen
ist in einer Tabelle abgelegt
Beispiel: aus dem Byte ABh wird so das Byte 62h
die Umkehrung von ByteSub erfolgt durch Anwendung der inversen affinen
Transformation gefolgt von der Berechnung der multiplikativen Inversen in
GF(28)
ShiftRow–Transformation:
die einzelnen Zustände S0 , S1 , · · · werden byteweise jeweils in einer Matrix
abgelegt:








a00
a10
a20
a30
a01
a11
a21
a31
a02
a12
a22
a32
a03
a13
a23
a33








die Zeilen 1 bis 3 werden dann zyklisch nach rechts verschoben, Zeile 0
wird nicht geändert; dabei wird Zeile i (1 ≤ i ≤ 3) um ci Bytes abhängig
von der Blockgröße b verschoben:
c1
c2
c3
b=128 b=192 b=256
1
1
1
2
2
3
3
3
4
zum Dechiffrieren erhält man die inverse Transformation durch Ausführen
der entsprechenden zyklischen Verschiebungen nach links
78
MixColumn–Transformation:
jede Spalte








a0i
a1i
a2i
a3i








der jeweiligen Zustandsmatrix wird anhand der Matrixmultiplikation








02
01
01
03
03
02
01
01
01
03
02
01
01
01
03
02









∗







a0i
a1i
a2i
a3i








verändert; dabei sind die Matrixelemente Bytes in hexadezimaler Notation
bei der Multiplikation werden die Bytes der Matrix und die Bytes des
Zustandsvektors als Elemente von GF(28) aufgefasst und nach den dort
geltenden Regeln verknüpft
andere Interpretation dieser Multiplikation:
jede Spalte der Matrix und auch die Spalte der Zustandsmatrix können je
als Polynome vom Grad ≤ 3 mit Bytes als Koeffizienten aufgefasst werden,
z.B. steht dann AB 00 D2 3F h für das Polynom ABx3 + D2x + 3F mit
hexadezimalen Koeffizienten; damit sind die Koeffizienten dieses Polynoms
selbst Polynome, nämlich Elemente aus GF(28); Addition und Multiplikation erfolgen entsprechend, wobei bei der Multiplikation ein Polynom vom
Grad ≤ 6 entsteht; dieses wird sofort modulo x4 + 1 reduziert; man kann
zeigen, dass die Multiplikation
(a3 x3 + a2 x2 + a1 x1 + a0 ) ∗ (b3x3 + b2 x2 + b1x1 + b0) mod (x4 + 1)
= (c3x3 + c2 x2 + c1 x1 + c0 ) auch ausgeführt werden kann als Matrixmultiplikation

 



b
a
a
a
a
c
3
2
1   0 
 0
 0 





  b1 
 a
 c1 
a0 a3 a2 

∗
 = 1


 



 a2 a1 a0 a3   b2 
 c2 

 



b3
a3 a2 a1 a0
c3
wobei die einzelnen Additionen und Multiplikationen wie in GF(28) ausgeführt werden
auch die MixColumn–Transformation ist invertierbar
79
Einige weitere oft verwendete symmetrische kryptographische Algorithmen
Triple–DES
Der DES–Algorithmus wird dreimal hintereinander mit zwei verschiedenen
Schlüsseln angewendet, und zwar nach dem Schema
C := Ek1 (Dk2 (Ek1 (P ))).
Der Schlüsselraum hat damit die Größe 2112.
(Dagegen wäre ein zweifaches DES nach dem Schema C := Ek2 (Ek1 (P )) nicht resistent gegenüber einem known–plaintext–Angriff: Berechne nur für alle Schlüssel k1 die Zwischenwerte Ek1 (P ) und für alle Schlüssel k2 die Werte Dk2 (C)
und vergleiche die Ergebnisse. Sind sie gleich, so ist ein Schlüsselpaar gefunden.
Dieser Angriff kostet nur doppelt so viel Zeit wie bei DES.)
Triple–DES wird gegenwärtig z.B. von US–amerikanischen Finanzbehörden verwendet.
RC2, RC4, RC5, RC6
”Rivest’s Code”; Ron Rivest; geschütztes Eigentum der Fa. RSA Data Security,
die auch Programme vertreibt, die diese Algorithmen benutzen; Schlüssellänge
von 1 bis 1024 Bit; RC2 ist blockorientiert ähnlich DES, während RC4 stromorientiert ist (s. Folie 56). RC5 und RC6 erlauben verschiedene Blockgrößen,
Rundenanzahlen und Schlüssellängen.
Blowfish (”Kugelfisch”) und Twofish
Beide Algorithmen stammen (im Wesentlichen) von Bruce Schneier. Es sind
Feistel–Chiffren mit 64– bzw. 128–Bit Blocklängen und 16 Runden. Blowfish
ist sehr weit verbreitet und wird zu Dateiverschlüsselungen und in e–mail–
Verschlüsselungsprogrammen eingesetzt. Twofish ist im AES–Wettbewerb nur
knapp unterlegen gewesen und kann auch als Alternative zu AES verwendet
werden. Es werden in Twofish auch Multiplikationen im Körper GF (28) verwendet.
Serpent (Ross Anderson, Eli Biham und Lars Knudsen)
Nahm auch am AES–Wettbewerb teil und kam neben Rijndael und Twofish
unter die besten drei Algorithmen. Es ist eine SP–Chiffre (in jeder Runde werden eine Substitition und eine Permutation durchgeführt, die durch Substitutionsboxen bzw. lineare Transformationen, angewendet auf Teilblöcke, realisiert
werden) mit 32 Runden. Serpent gilt als sehr sicher, ist jedoch im Vergleich zu
Rijndael und Twofish langsamer.
80
RSA–Verfahren
p, q große Primzahlen mit p 6= q, n := p ∗ q
e Zufallszahl mit 1 < e < n und gcd(e, ϕ(n)) = 1
d modulare Inverse von e modulo ϕ(n), d.h., e ∗ d = 1 mod ϕ(n)
P := Zn
C := Zn
K := {(n, p, q, e, d) | p, q, n, e, d wie oben}
(n, e öffentlich, p, q, d, ϕ(n) geheim)
für jedes k = (n, p, q, e, d) ∈ K sei
Ek (x) := xe mod n (Verschlüsselung)
Dk (y) := y d mod n (Entschlüsselung)
Bemerkungen:
s. auch den Artikel Kaliski.pdf von Burt Kaliski, chief scientist von RSA–
Laboratories (Laufwerk N)
weit verbreitet: PGP, SSL und damit Bestandteil von Webbrowsern, SSH,
S/MIME (s. auch die entsprechenden RFC’s, einige davon in Laufwerk N)
der Klartext muss ggf. so in Blöcke unterteilt werden, dass deren zahlen-
mäßige Darstellung kleiner als n ist
kann als Blockchiffre nur im ECB– und im CBC–Modus implementiert
werden
ist wesentlich langsamer als beispielsweise DES, IDEA oder AES und sollte
daher nur auf relativ kurze Klartexte oder zur Verschlüsselung von Schlüsseln symmetrischer Verfahren verwendet werden; auch zur Verschlüsselung
von Hash–Werten umfangreicher Klartexte sehr gut geeignet
oft benutzte e’s, damit Chiffrierung schnell geht:
e = 3 oder e = 5
e = 216 + 1 = 65537 (Potenzierung schnell mit Hilfe von
square and multiply ausführbar)
(weder p − 1 noch q − 1 dürfen durch e teilbar sein)
81
p und q sollten je mind. 1024 Bit Länge haben, damit Chiffrierung für die
ca. nächsten 20 Jahre sicher ist (noch besser: je 2048 Bit); außerdem sollten
sie starke Primzahlen sein
wenn man RSA auch zur Erzeugung einer digitalen Unterschrift benutzt
(s. unten) und dabei dasselbe n verwenden möchte, so sollten p − 1 und
q − 1 beide weder durch 3 noch durch 5 teilbar sein; dann können aus
Aufwandsgründen zum Verschlüsseln e = 5 als öffentlicher Exponent und
zum Verifizieren der digitalen Unterschrift e = 3 als öffentlicher Exponent
verwendet werden (für beide Zwecke denselben öffentlichen Exponenten zu
verwenden ist angreifbar)
wenn auch nur eine einzige der 4 Komponenten des geheimen Schlüssels
bekannt wird, ist die Chiffre wertlos, da dann der Exponent d für das
Entschlüsseln (bzw. für das Erzeugen der digitalen Unterschrift) leicht berechnet werden kann
die Sicherheit von RSA basiert auf einer Einweg–Falltür–Funktion (one–
way trapdoor function): es ist einfach, xe mod n zu berechnen, aber ohne
Kenntnis von p, q oder ϕ(n) (jede dieser Größen hat die Funktion einer
Falltür) und natürlich auch von d kann x nicht wieder erhalten werden
wenn x so klein ist, dass xe < n ist, also dass bei der Berechnung des
Ciphertextes keine modularen Reduktionen auftreten, so kann x bereits
durch Berechnen der gewöhnlichen e–ten Wurzel wieder bestimmt werden;
um dies zu verhindern und weitere mögliche Angriffe zu erschweren, sind
Standards zur Implementierung von RSA eingeführt worden, z. B. PKCS
#1
eine besonders empfehlenswerte Variante der Implementierung (s. auch Fer-
guson/Schneier: Practical Cryptography):
– Alice wählt eine genügend große Zufallszahl r ∈ Zn
– sie berechnet dann z := re mod n und K := h(r) mit einer bestimmten
kryptographischen Hashfunktion h
– sie verschlüsselt den Klartext x mit einer symmetrischen Chiffre mittels
des Schlüssels K, also y := EK (x), und sendet sowohl z als auch y an
Bob
– Bob berechnet r mit seinem privaten Schlüssel d, dann K und schließlich x = DK (y)
82
einfache Faktorisierungsalgorithmen
√
bekannt: Genau dann, wenn keine Primzahl p mit p ≤ n ein Teiler von n ist,
ist n Primzahl, besitzt also keine nichttrivialen Teiler. Die Umsetzung dieses
Sachverhaltes führt aber bei großen n zu einem nicht akzeptierbaren Rechenaufwand.
ein trial–and–error–Verfahren:
Wenn x 6= y und x2 = y 2 mod n ist, so ist (x2 −y 2 ) = (x−y)∗(x+y) = 0 mod n,
so dass x2 − y 2 durch n teilbar ist. Überprüfe nun, ob gcd(x − y, n) oder
gcd(x + y, n) verschieden von 1 und von n ist. Falls ja (was in ca. 50% der
Fälle auftritt), so ist ein nichttrivialer Teiler von n gefunden.
Beispiel: n := 25651; wähle eine Zufallszahl z zwischen 1 und n, etwa z := 283;
dann gilt:
2832 mod n = 3136 = 26 ∗ 72 = (23 ∗ 7)2 mod n = 562 mod n; es ist
gcd(283 − 56, n) = 227, womit ein nichttrivialer Teiler bzw. Faktor von n gefunden ist.
eine andere Variante, Zahlen x 6= y mit x2 = y 2 mod n zu finden:
Wähle drei Zahlen 1 < a, b, c < n derart, dass für a2 mod n, b2 mod n und
c2 mod n leicht deren Primfaktorzerlegung gefunden werden kann und hoffentlich jeder Primfaktor insgesamt geradzahligoft–Mal vorkommt. Dann ist
(a ∗ b ∗ c)2 = (Produkt der Primfaktorzerlegungen)2 mod n.
Beispiel: n := 15770708441, a := 8340934156, b := 12044942944, c :=
2773700011;
dann ist a2 = 3 ∗ 7 mod n, b2 = 2 ∗ 7 ∗ 13 mod n und c2 = 2 ∗ 3 ∗ 13 mod n,
so dass ((a ∗ b ∗ c) mod n)2 = ((2 ∗ 3 ∗ 7 ∗ 13) mod n)2 mod n, also 95034357852 =
5462 mod n ist;
wegen gcd(9503435785 − 546, n) = 115759 ist mit 115759 ein Teiler von n gefunden.
83
Pollard’s ρ–Faktorisierungsalgorithmus
gegeben: eine natürliche Zahl n, die keine Primzahlpotenz ist;
gesucht: ein nichttrivialer Faktor d von n
a := random(n); b := random(n);
for i := 1, 2, · · · do
begin
a := a2 + 1 mod n;
b := b2 + 1 mod n;
b := b2 + 1 mod n;
d := gcd(a − b, n);
if 1 < d < n then return(d);
if d = n then exit; {kein Faktor gefunden}
end
weitere Faktorisierungsalgorithmen:
Pollard’s (p-1)–Algorithmus, quadratisches–Sieb–Algorithmus, Faktorisierung
mit elliptischen Kurven
Die 129-stellige Zahl (RSA–129)
1143 81625 75788 88676 69235 77997 61466 12010 21829 67212 42362
56256 18429 35706 93524 57338 97830 59712 35639 58705 05898 90751
47599 29002 68795 43541
ist das Produkt der beiden Primzahlen
3490 52951 08476 50949 14784 96199 03898 13341 77646 38493 38784
39908 20577
und
32769 13299 32667 09549 96198 81908 34461 41317 76429 67992 94253
97982 88533
Die Faktorisierung wurde 1994 gefunden, nachdem sie 17 Jahre vorher von
RIVEST als Problem formuliert wurde.
RSA–640:
31074182404900437213507500358885679300373460228427275457201619488232
064405180815045563468296717232867824379162728380334154710731085019195
48529007337724822783525742386454014691736602477652346609
wurde am 2. November 2005 faktorisiert; Preisgeld: 20000$
Zu anderen Herausforderungen bzgl. der Faktorisierung großer Zahlen, die mit
hohen Preisgeldern verbunden waren, siehe
http://www.rsasecurity.com/rsalabs/challenges/ (wird nicht mehr weiter
betrieben).
84
Erzeugung eines primitiven Elementes von Z∗p
Es sei p eine Primzahl. Dann gilt (z. T. schon bekannt aufgrund der Folien zu
den zahlentheoretischen Grundbegriffen):
1. α ist ein primitives Element von Z∗p
Z∗p = {αi mod p | 0 ≤ i ≤ p − 2}
⇐⇒
2. Z∗p hat genau ϕ(p − 1) primitive Elemente
(ist n = pe11 ∗ pe22 ∗ · · · ∗ pekk die Primfaktorzerlegung von n, so ist ϕ(n) =
n ∗ (1 − p11 ) ∗ (1 − p12 ) ∗ · · · ∗ (1 − p1k ))
3. sei α ein primitives Element von Z∗p und β = αi mod p; dann gilt:
β ist ein primitives Element von Z∗p ⇐⇒
gcd(i, p − 1) = 1
4. α ∈ Z∗p ist primitives Element ⇐⇒
α(p−1)/q 6= 1 mod p für jeden Primteiler q von p − 1
Damit kann ein primitives Element α ∈ Z∗p aufgrund von 4. wie folgt berechnet
werden, falls p − 1 = pe11 ∗ pe22 ∗ · · · ∗ pekk mit paarweise verschiedenen Primzahlen
p1 , p2, · · · , pk ist:
1. wähle eine Zufallszahl α ∈ Z∗p
2. for i := 1 to k do
begin β := α(p−1)/pi mod p;
if β = 1 then goto 1.
end
3. return(α)
Konstruiere also p möglichst so, dass die Primteiler von p − 1 von vornherein
bekannt sind (s. z.B. log stream.ari).
85
ElGamal–Verfahren
p große Primzahl, so dass das diskrete Log.–Problem in Z∗p praktisch unlösbar
ist (z.B. sollte (p − 1)/2 selbst Primzahl sein oder zumindest einen großen Primfaktor besitzen)
α ∈ Z∗p primitives Element
1≤a≤p−2
P := Z∗p
C := Z∗p × Z∗p
K := {(p, α, a, β) | β := αa mod p},
wobei p, α, β öffentlich, a geheim
für k = (p, α, a, β) und eine Zufallszahl λ, 1 ≤ λ ≤ p − 2 und x ∈ P sei
Ek (x) := (y1, y2 )
mit y1 := αλ mod p, y2 := x ∗ β λ mod p
für (y1, y2) ∈ Z∗p × Z∗p sei
Dk (y1, y2) := y2 ∗ (y1a )−1 mod p
86
Bemerkungen
Bestandteil beispielsweise von GnuPG
Klartext vor der Verschlüsselung in Blöcke zerlegen, deren zahlenmäßige
Darstellung ≤ p-1 ist (falls p z.B. L Bit hat, so könnten die Klartextblöcke
je L-1 Bit haben)
λ sollte geheim bleiben, kann auch sofort nach Benutzung bei der Ver-
schlüsselung wieder vergessen werden
Patent auf ElGamal und Diffie–Hellman (s.u.) lief am 29.4.1997 aus
der Ciphertext ist doppelt so lang wie der Klartext
für längere Zeit andauernde Sicherheit sollte p mindestens 1024 Bit lang
sein
sollte nur zum Chiffrieren kurzer Nachrichten (z.B. von Schlüsseln) ver-
wendet werden
Achtung! Wenn man den diskreten Logarithmus bzgl. irgendeines primiti-
ven Elementes α ∈ Z∗p als Basis berechnen kann, so auch bzgl. jedes anderen
primitiven Elementes aus Z∗p
87
Die Potenzen 3i mod 17 für 0 ≤ i ≤ 16:
3 i mod 17
16
*
*
*
*
*
11
*
*
*
*
*
6
*
*
*
*
*
1*
*
1
6
11
16
i
Die Logarithmen log3 (i) mod 17 für 1 ≤ i ≤ 16:
log 3 (i) mod 17
16
*
*
*
*
11
*
*
*
*
*
6
*
*
*
*
*
1
*
*
1
6
11
88
16
i
baby–step–giant–step–Algorithmus zur Berechnung des diskreten Logarithmus modulo einer Primzahl p
gegeben: eine Primzahl p, ein primitives Element a ∈ Z∗p sowie ein b ∈ Z∗p
gesucht: dasjenige x mit 0 ≤ x ≤ p − 2 und ax = b mod p
Algorithmus:
√
m := ⌈ p − 1⌉;
{m2 ≥ p − 1}
berechne zweispaltige Tabelle mit den Einträgen (j, aj mod p) für 0 ≤ j < m;
sortiere diese Tabelle monoton wachsend nach den zweiten Einträgen;
c := b; d := a−m mod p;
for i := 0 to m − 1 do
begin if (c = aj mod p) {binäre Suche in der 2. Spalte}
then return(x := i ∗ m + j);
c := c ∗ d mod p;
end;
Begründung:
x ist eine der Zahlen 0, 1, · · · , p − 2 (oder 1, 2, · · · , p − 1, denn a0 = ap−1 =
1 mod p);
da i und j unabhängig voneinander alle natürlichen Zahlen von 0 bis m − 1
durchlaufen, gilt
0 ≤ i ∗ m + j ≤ (m − 1) ∗ m + (m − 1) = m2 − m + m − 1 = m2 − 1;
da weiterhin p − 1 ≤ m2 ist, also p − 2 ≤ m2 − 1, durchlaufen die Zahlen i ∗ m+j
auf jeden Fall alle Werte von 0 bis p − 2.
c durchläuft die Werte b, b ∗ a−m , b ∗ a−2m , · · · , b ∗ a−(m−1)m ;
falls dann b ∗ a−im = aj mod p ist (0 ≤ i, j ≤ m − 1), so ist ai∗m+j = b.
89
Kryptographie auf elliptischen Kurven
Hier wird die praktische Unlösbarkeit des diskreten–Logarithmus–Problems in
der (additiven) Gruppe der Punkte auf einer elliptischen Kurve (elliptic curve
discrete logarithm problem (ECDLP)) zugrundegelegt.
ECDLP:
Gegeben seien eine elliptische Kurve E über einem endlichen Körper F , ein
Punkt P ∈ E(F ) und ein Punkt Q ∈< P > (< P >: die durch P erzeugte
zyklische Untergruppe der Gruppe aller Kurvenpunkte).
Gesucht ist die kleinste natürliche Zahl n, so dass Q = (P + P + · · · + P ) (n
Summanden P ) bzw. Q = n ∗ P ist. Diese Zahl n heißt der diskrete Logarithmus
von Q zur Basis P (modulo (E,F)) und wird mit logP Q mod (E, F ) bezeichnet.
Beispiel (siehe das Buch von Hankerson/Menezes/Vanstone, S. 13):
Es sei F7 := (Z7 , +, ∗), wobei die arithmetischen Operationen natürlich modulo
7 auszuführen sind. Die die elliptische Kurve E definierende Gleichung sei
y 2 = x3 + 2 ∗ x + 4
so dass E aus genau folgenden Punkten besteht:
E = {(x, y) ∈ Z7 × Z7 | y 2 = x3 + 2 ∗ x + 4 mod 7} ∪ {∞}
(der ”unendlich ferne Punkt” ∞ wird stets zu den ”eigentlichen”Kurvenpunkten
hinzugenommen und spielt die Rolle des neutralen Elementes der additiven
Gruppe der Kurvenpunkte; es ist der einzige Punkt im Unendlichen, der die
projektive Form der Kurvengleichung erfüllt). Es ergibt sich, dass
E = {∞, (0, 2), (0, 5), (1, 0), (2, 3), (2, 4), (3, 3), (3, 4), (6, 1), (6, 6)}
ist.
Die Kurve als reelle Kurve über dem Intervall [-1.5,2.5]:
5
4
3
2
1
0
−1
−2
−3
−4
−5
−1.5
−1
−0.5
0
0.5
90
1
1.5
2
2.5
Die Kurve über dem Körper F7 :
6
2
1
1
2
6
Definition einer Addition für Punkte der obigen Kurve:
1. Nullelement: P + ∞ := ∞ + P := P für alle P ∈ E
2. inverses Element: ist P = (x, y), so sei −P := (x, −y); außerdem sei −∞ :=
∞
3. Addition: Seien P, Q ∈ E mit P := (x1, y1), Q := (x2, y2) und P 6= Q,
P 6= −Q. Dann sei P + Q = (x3, y3 ) mit
x3 := (
y2 − y1
y2 − y1 2
) − x1 − x2 und y3 := (
)(x1 − x3) − y1
x2 − x1
x2 − x1
4. Punktdopplung: Es sei P ∈ E mit P := (x1, y1) und P 6= −P . Dann sei
2P = (x3, y3), wobei
x3 := (
3x21 + 2 2
3x2 + 2
) − 2x1 und y3 := ( 1
)(x1 − x3) − y1
2y1
2y1
Zum Beispiel findet man in fips186-2.pdf die folgende elliptische Kurve P − 256,
definiert durch y 2 = x3 − 3x + b mod p mit
p = 115 79208 92103 56248 76269 74469 49407 57353 00861 43415 29031 41955
33631 30886 70978 53951 = 2256 − 2224 + 2192 + 296 − 1,
b = 5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e
27d2604b (hexadezimal),
Basispunkt P = (x, y):
x = 6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945
d898c296 und
y = 4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5
Ordnung n des Basispunktes:
n = 115 79208 92103 56248 76269 74469 49407 57352 99969 55224 13576 03424
22259 06106 85120 44369,
91
elliptische–Kurve diskretes–Logarithmus–Problem über Fp
Vorgegeben seien eine (große) Primzahl p, eine elliptische Kurve E über dem
Körper Fp und ein Basispunkt P ∈ E mit Primzahlordnung n, so dass die
durch P erzeugte zyklische Untergruppe < P > von E(Fp) genau die paarweise
verschiedenen Elemente ∞, P, 2P, · · · , (n − 1)P hat. Die Parameter p, P, n und
die Gleichung der elliptische Kurve E sind alle öffentlich.
Als privater Schlüssel d wird eine nat. Zahl aus dem Intervall [1, n − 1] zufällig
ausgewählt. Dann wird der Kurvenpunkt Q := dP berechnet, wobei Q der öffentliche Schlüssel ist.
ECDLP: Bestimme d bei gegebenem Q (wobei auch die übrigen öffentlichen
Parameter bekannt sind).
ElGamal–Verschlüsselung auf elliptischen Kurven:
p große Primzahl, E, P, n wie oben
P := E (Klartexte müssen also durch Punkte in E dargestellt werden)
C := E × E
K := {(Q, d) | Q := d ∗ P },
wobei Q öffentlich, d geheim
für k = (Q, d), eine Zufallszahl λ, 1 ≤ λ ≤ n − 1 und x ∈ P sei
Ek (x) := (y1, y2 ) (Verschlüsselung)
mit y1 := λ ∗ P , y2 := x + λ ∗ Q
für (y1, y2) ∈ E × E sei
Dk (y1, y2) := y2 − d ∗ y1 (Entschlüsselung)
Auch für andere Verfahren der public–key–Kryptographie, deren Sicherheit
auf der praktischen Unlösbarkeit des diskreten–Logarithmus–Problems beruht
(DSA, DH (s. u.)), gibt es analoge Verfahren auf der Basis elliptischer Kurven.
Neben den Körpern GF (p) = Fp (p: Primzahl > 2) gibt es auch die endlichen Körper GF (2m ) = F2m der binären m–Tupel modulo eines irreduziblen
binären Polynoms vom Grad m (siehe die ByteSub–Transformation von AES),
die zusammen mit entsprechenden Polynomen dritten Grades eine weitere Art
elliptischer Kurven festlegen, für die das EC–diskrete–Logarithmus–Problem
praktisch unlösbar ist.
92
Diffie–Hellman–Schlüsselvereinbarung
1. Alice und Bob vereinbaren eine Primzahl p sowie ein primitives Element α
von Z∗p ;
p und α sind öffentlich (das diskrete–Logarithmus–Problem sollte modulo
p schwer zu lösen sein, beispielsweise sollte auch (p − 1)/2 eine Primzahl
sein)
2. Alice: wählt zufällig ein a, 0 ≤ a ≤ p − 2, berechnet αa mod p und sendet
diese Zahl an Bob (a ist geheim)
3. Bob: wählt zufällig ein b, 0 ≤ b ≤ p − 2, berechnet αb mod p und sendet
diese Zahl an Alice (b ist geheim)
4. Alice: berechnet (αb)a mod p
5. Bob: berechnet (αa)b mod p
Damit haben Alice und Bob beide den gleichen Schlüssel (αb )a mod p
(= (αa )b mod p).
es sollte p = 2∗q +1 sein für eine Primzahl q; dann hat Z∗p nur die folgenden
Untergruppen: die triviale Untergruppe, die nur die Zahl 1 enthält, die
Untergruppe der Ordnung 2, bestehend aus 1 und p-1, die Untergruppe der
Ordnung q (diese enthält genau die Quadrate modulo p) sowie die gesamte
Gruppe selbst; ob eine Zahl aus Z∗p ein Quadrat modulo p ist oder nicht,
kann effizient mit Hilfe des Legendre–Symbols (s.u.) festgestellt werden;
(wenn a gerade und α ein primitives Element und somit kein Quadrat
modulo p ist, so ist αa mod p ein Quadrat modulo p, so dass Mallory in
diesem Fall zwar das letzte Bit von a, aber nicht das gesamte a bestimmen
kann)
Empfehlungen zur Größe von p: 2048 Bits, um bis ca. 2022 sicher zu sein,
4096 Bits, um bis ca. 2050 sicher zu sein (s. Lenstra/Verheul, Selecting
Cryptographic Key Sizes. J. Cryptology 14(4), 255–293 (2001))
man–in–the–middle–Angriff ist möglich, deshalb gegenseitige Authentifi-
zierung empfehlenswert
auch wenn αa mod p bzw. αb mod p von Mallory abgehört werden, so kann
dieser daraus weder a noch b und somit auch nicht den vereinbarten Schlüssel erzeugen
93
modulare Quadratwurzeln und quadratische Reste
Es sei n ∈ N und a, b ∈ Z∗n ; dann heißt b eine Quadratwurzel von a modulo n
√
(b = a mod n) :←→ b2 = b ∗ b = a mod n;
a heißt quadratischer Rest modulo n
a mod n
:←→
es gibt ein c ∈ Z∗n mit c2 =
√
Berechnung von y mod n, falls y ein quadratischer Rest modulo n
ist und falls n = p ∗ q für zwei verschiedene Primzahlen p, q mit p, q =
3 mod 4 ist:
berechne mit dem erweiterten Euklidischen Algorithmus zwei ganze Zahlen
a, b mit a ∗ p + b ∗ q = 1
(dann ist a = p−1 mod q und b = q −1 mod p)
r := y (p+1)/4 mod p
s := y (q+1)/4 mod q
t := (a ∗ p ∗ s + b ∗ q ∗ r) mod n
u := (a ∗ p ∗ s − b ∗ q ∗ r) mod n
die 4 Wurzeln von y mod n sind dann t mod n, n − t mod n, u mod n und
n − u mod n
(Ohne Kenntnis von p und q ist das Berechnen von
wie das Faktorisieren von n.)
√
y mod n genau so schwierig
Bei obiger Wurzelberechnung wurde der Chinesische Restsatz benutzt.
94
Legendre–Symbol
(Adrien Marie Legendre, 1752–1833)
Seien p eine ungerade Primzahl und a eine ganze Zahl;
dann ist das Legendre–Symbol ( ap ) von a bzgl. p definiert durch





a
( ) := 

p


0 , falls p | a
1 , falls a ein quadratischer Rest mod p und ¬(p | a)
−1 , falls a kein quadratischer Rest mod p und ¬(p | a)
Eigenschaften:
( ap ) = a(p−1)/2 mod p
a
b
( a∗b
p ) = (p) ∗ (p)
a = b mod p
=⇒
( ap ) = ( pb )
( pq ) ∗ ( pq ) = (−1)(p−1)∗(q−1)/4 (p, q ungerade Primzahlen, p 6= q)
(Quadratisches Reziprozitätsgesetz, erstmals von C. F. Gauß bewiesen)
95
Jacobi–Symbol
(Carl Gustav Jacob Jacobi, 1804–1851)
(Verallgemeinerung des Legendre–Symbols)
Sei n ∈ N und n ≥ 3 ungerade mit Primfaktorzerlegung n = pe11 ∗ · · · ∗ pekk und
sei a ∈ Z; dann ist das Jacobi–Symbol ( na ) von a bzgl. n definiert durch
a
a
a
( ) := ( )e1 ∗ · · · ∗ ( )ek
n
p1
pk
(rechts stehen Potenzen von Legendre-Symbolen)
Eigenschaften:
n Primzahl =⇒ Jacobi–Symbol = Legendre–Symbol
( na ) = 0, 1 oder -1
( na ) = 0
⇐⇒
gcd(a, n) 6= 1
2
) = ( na ) ∗ ( nb ) (damit: a ∈ Z∗n ⇒ ( an ) = 1)
( a∗b
n
a
( m∗n
) = ( ma ) ∗ ( na )
a = b mod n
( n2 ) = (−1)(n
a = 2e ∗ a1
e
=⇒
2
( na ) = ( nb )
−1)/8
∧
a1 ungerade
=⇒
a1
( na ) = ( 2n ) ∗ ( an1 ) = ( n2 )e ∗ ( n mod
) ∗ (−1)(a1−1)(n−1)/4
a1
96
Benutzung der beiden zuletzt genannten Eigenschaften, um den Wert des
Jacobi–Symbols rekursiv zu berechnen
Jacobi(a,n):
input: ungerade natürliche Zahl n ≥ 3, natürliche Zahl a, 0 ≤ a < n
output: Jacobi–Symbol ( na ) (bzw. Legendre–Symbol, falls n Primzahl)
if a = 0 then return(0);
if a = 1 then return(1);
bestimme e und a1 , so dass a = 2e ∗ a1 und a1 ungerade;
2
if a1 = 1 then return((−1)e∗(n −1)/8 );
if e gerade then
s := 1
else
if (n = 1 mod 8 or n = 7 mod 8) then
s := 1
else /* n = 3 mod 8 oder n = 5 mod 8 */
s := −1
if (n = 3 mod 4 and a1 = 3 mod 4) then s := −s;
n1 := n mod a1
return(s∗ Jacobi(a1, n1 ))
97
Rabin–Verfahren für spezielle Primzahlen p, q
p 6= q Primzahlen, p, q = 3 mod 4, n := p ∗ q
(n: öffentlich, p, q: geheim)
P := Zn
C := {y ∈ Zn | y quadratischer Rest modulo n }
K := {(p, q, n)}
EK (x) := x2 mod n
DK (y) :=
√
y mod n
Bemerkungen:
p und q sollten so groß wie beim RSA–Algorithmus gewählt werden
Verschlüsselung ist sehr schnell, Entschlüsselung hat ungefähr denselben
Aufwand wie beim RSA–Verfahren
chosen–ciphertext–Attacke:
man in the middle wählt Zufallszahl m ∈ Zn und berechnet c := m2 mod
n; er sendet c an Bob (der p und q kennt), damit dieser c dechiffriert;
Bob erhält einen Klartext x, den man in the middle abfängt; da Bob den
”wahren Klartext” m nicht kennt, ist x eine der vier möglichen Wurzeln
aus c modulo n; falls dabei x 6= m mod n und x 6= −m mod n ist, so kann
man in the middle mit gcd(m − x, n) einen Primfaktor von n berechnen
Welche der vier Wurzeln ist der gesuchte Klartext?
oft daran zu erkennen, dass drei der berechneten Wurzeln ”keinen Sinn”
ergeben;
besser: vor der Verschlüsselung bestimmte Merkmale in den Klartext einbauen, etwa die letzten 64 Bit nochmal wiederholen; dann hat zusätzlich
auch eine chosen–ciphertext–Attacke keine Chance auf Erfolg
98
digitale Signaturen (elektronische Unterschriften)
sollen wesentliche Eigenschaften von handschriftlichen Unterschriften haben
Echtheitseigenschaft
Das Dokument stammt wirklich vom Unterschreibenden (enger Zusammenhang zwischen Dokument und Unterschrift dadurch, dass beide auf
demselben Blatt Papier stehen).
Identitätseigenschaft
Die Unterschrift ist persönlich, d.h., sie kann jeweils nur von einem einzigen
Menschen ausgestellt werden und ist somit schwierig zu fälschen.
Abschlusseigenschaft
Sie signalisiert die Vollendung einer Erklärung dadurch, dass sie am Ende
steht.
Warneigenschft
Warnung des Unterzeichnenden bei handschriftlicher Unterschrift vor
Übereilung.
Verifikationseigenschaft
Jeder Empfänger einer unterschriebenen Erklärung kann Unterschrift verifizieren durch Vergleich.
Bis auf die Warneigenschaft lassen sich alle Eigenschaften auf kryptographische
Protokolle übertragen.
Da ein digital signiertes Dokument leicht kopiert werden kann, sollte es stets
weitere Informationen wie etwa einen Zeitstempel enthalten.
Oberste Behörde zur Wahrung des Signaturgesetzes, der Signaturverordnung
und zur Spezifizierung von Einsatzbedingungen von Signaturanwendungskomponenten ist die
Bundesnetzagentur
(www.bundesnetzagentur.de).
Die drei eben genannten Dokumente befinden sich als Sign Gesetz.pdf,
Sign Verordnung.pdf und Einsatz Sign.pdf auch im Laufwerk N.
99
allgemeines Signatur–Schema (P, A, K, h)
P := endliche Menge von möglichen Texten (die zu signieren sind)
A := endliche Menge von möglichen Signaturen
K := endliche Menge von möglichen Schlüsseln
(jeder Schlüssel k ∈ K hat einen öffentlichen Teil kpublic und einen geheimen Teil
kprivate )
h: eine kryptographische Hashfunktion;
für jedes k ∈ K, jedes m ∈ P und jedes A ∈ A sei
sigkprivate (h(m)) ∈ A die Signatur von m
verkpublic (h(m), A) ∈ {true, f alse},


wobei verkpublic (x, y) := 
true , falls y = sigkprivate (x)
f alse , falls y =
6 sigkprivate (x)
Ablauf des Protokolls (siehe auch Folie 30):
Alice: signiert den Hashwert h(m) einer Nachricht m an Bob mit ihrem
privaten Schlüssel kprivate und sendet die Nachricht m zusammen mit
der Unterschrift sigkprivate (h(m)) an Bob;
Bob: bildet ebenfalls h(m) und überprüft mit Hilfe des öffentlichen
Schlüssels kpublic von Alice, ob
verkpublic (h(m), sigkprivate (h(m))) = true
ist oder nicht
100
RSA–Signatur–Schema
p, q große Primzahlen mit je mindestens 1024 Bit, p 6= q, n := p ∗ q;
P := Zn
A := Zn
K := {(n, e, d) | 1 < e, d < n
∧
(d, p, q, ϕ(n) geheim, n, e öffentlich)
e ∗ d = 1 mod ϕ(n)}
für jedes k := (n, e, d) ∈ K sei
sigk (x) := xd mod n
verk (x, y) := true :⇐⇒ x = y e mod n
(Genau dann, wenn y = sigk (x) ist, ist verk (x, y) = true.)
Da x ∈ Zn , also x < n, vorausgesetzt ist, erübrigt sich hier die sonst der Signierung vorausgehende Anwendung einer Hash–Funktion h auf eine Nachricht m,
um dadurch x zu erhalten.
In PKCS#1 sind Methoden zur Maskierung des Hash–Wertes vorgeschrieben,
damit folgender Angriff von Mallory unmöglich gemacht wird:
Mallory nimmt den public key e von Alice, eine Nachricht m und
bestimmt x := h(m). Dann versucht er ein y zu finden, so dass
verk (x, y) = true ist. Wenn ihm das gelingt, kann er Bob glaubhaft
machen, dass y die Unterschrift von Alice unter m ist, dass also Alice
die Nachricht unterschrieben hat.
101
Signatur–Schema nach ElGamal
p: große Primzahl, so dass das diskrete Log.–Problem in Z∗p praktisch unlösbar
ist (z.B. sollten (p − 1)/2 selbst Primzahl sein oder zumindest einen großen
Primfaktor besitzen und p möglichst 1024 Bit Länge haben)
α ∈ Z∗p primitives Element
P := Z∗p
A := Z∗p × Zp−1
K := {(p, α, a, β) | β := αa mod p},
wobei p, α, β öffentlich, a geheim
für k := (p, α, a, β) ∈ K und eine geheime Zufallszahl λ ∈ Z∗p−1 sei
sigk (x, λ) := (γ, δ)
mit γ := αλ mod p, δ := (x − a ∗ γ) ∗ λ−1 mod (p − 1);
für x, γ ∈ Z∗p , δ ∈ Zp−1 sei
verk (x, γ, δ) := true
:⇐⇒
β γ ∗ γ δ = αx mod p
102
Digital Signature Standard DSS
(Modifikation des ElGamal–Signaturschemas)
p: mind. 1024–Bit–Primzahl (empfohlen 2001 vom NIST), so dass das diskrete
Log.–Problem in Z∗p praktisch unlösbar ist
q:
160–Bit–Primzahl mit q|(p − 1)
α ∈ Z∗p mit der Ordnung q (dann ist αq = 1 mod p)
P := Z∗q
A := Zq × Z∗q
K := {(p, q, α, a, β) | β := αa mod p},
wobei p, q, α, β öffentlich, a geheim, 0 ≤ a ≤ q − 1
für k := (p, q, α, a, β) ∈ K, x ∈ Z∗q und eine geheime Zufallszahl λ ∈ Z∗q sei
sigk (x, λ) := (γ, δ)
mit γ := (αλ mod p) mod q, δ := (SHA–1(x) + a ∗ γ) ∗ λ−1 mod q
(falls zufällig δ = 0 sein sollte, so muss die Berechnung mit einem neuen λ
wiederholt werden);
für x, δ ∈ Z∗q , γ ∈ Zq sei
e1 :=SHA–1(x) ∗ δ −1 mod q, e2 := γ ∗ δ −1 mod q
verk (x, γ, δ) := true :⇐⇒ (αe1 ∗ β e2 mod p) mod q = γ
Bemerkungen:
(p−1)/q
Ist α0 ein primitives Element von Z∗p , so kann α := α0
mod p gewählt
werden.
Es ist β q = 1 mod p und γ q = 1 mod p.
Signieren mit ElGamal würde auf eine Signatur mit 1024–Bit Länge führen.
Jetzt wird ein 160–Bit–Wert (der z.B. nach vorheriger Anwendung der Hash–
Funktion SHA–1 auf den zu signierenden Text erhalten worden ist) signiert,
und die Signatur ist nur 320 Bit lang.
103
blinde digitale Signaturen
Alice will von Bob ein Dokument m blind signieren lassen (um z.B. Anonymität
des Bezahlens mit Bargeld zu wahren).
Sie verpackt (d.h. verschlüsselt) es, lässt das verpackte Dokument von Bob signieren (Unterschrift auf einen Briefumschlag, in dem sich das Dokument und
Kohlepapier befinden) und packt das Dokument wieder aus (d.h. entschlüsselt
es), und zwar so, dass die Unterschrift erhalten bleibt.
Ein Protokoll, das dieses leistet, bei dem also Signieren und Verschlüsseln vertauschbar sind, ist das folgende:
Zunächst seien (n, e) bzw. d Bob’s öffentlicher bzw. privater RSA–Schlüssel.
Alice kennt den öffentlichen Schlüssel von Bob.
Alice wählt eine Zufallszahl k < n mit gcd(k, n) = 1; sie berechnet
damit t := (m ∗ k e ) mod n (m wird verpackt) und sendet t an Bob;
Bob berechnet mit seinem privaten Schlüssel d den Wert u := td mod
n (er signiert das verpackte m); dann sendet er u zurück an Alice;
Alice bestimmt (u ∗ k −1) mod n und erhält dadurch md mod n, also
das von Bob signierte Dokument m.
Es ist nämlich
(u ∗ k −1 ) mod n = (td ∗ k −1) mod n = ((m ∗ k e )d ∗ k −1) mod n =
(md ∗ k ∗ k −1 ) mod n = md mod n
104
Kryptographische Hash–Funktionen h
Eine beliebig lange Nachricht m wird auf einen Wert h(m) vorgegebener Bitlänge (message digest, finger print) komprimiert.
Forderungen an h:
1. h muss schwach kollisionsfrei bzgl. m sein:
es muss praktisch unmöglich sein, zu einer vorgegebenen Nachricht m eine
Nachricht m′ zu finden, so dass m′ 6= m und h(m) = h(m′ ) ist
2. h muss stark kollisionsfrei (kollisionsfrei schlechthin) sein:
es ist praktisch unmöglich, Nachrichten m 6= m′ zu konstruieren mit
h(m) = h(m′ )
3. h muss eine Einwegfunktion sein:
falls ein z ∈ W b(h) gegeben ist, so ist es praktisch unmöglich, eine Nachricht m zu finden, so dass z = h(m) ist
4. h(m) sollte ”einfach” und ”schnell” berechenbar sein
starke Kollisionsfreiheit: h muss sogar einem Geburtstagsangriff standhalten,
√
also k := 1.17 ∗ n muss genügend groß sein (n: Anzahl der möglichen Funktionswerte von h), weil nach k Versuchen mit der Wahrscheinlichkeit 0.5 mit
einer Kollision zu rechnen ist (es treten mit der Wahrscheinlichkeit 0.5 zwei
Zeichenketten mit gleichem Hashwert auf).
schwache Kollisionsfreiheit: Jetzt ist ein Hashwert y vorgegeben. Damit nun
durch zufälliges Erzeugen von k Zeichenketten m1 , · · · , mk darunter eine solche
ist, die mit mindestens der Wahrscheinlichkeit 0.5 diesen Hashwert hat, muss
k
jetzt 1 − n−1
≥ 0.5 sein.
n
Denn es ist
P (h(m1 ) = y ∨ h(m2 ) = y ∨ · · · ∨ h(mk ) = y)
=
1−(
Für n = 365 heißt dies, dass k ≥ 253 sein muss.
Hash–Funktionen mit Schlüssel (keyed hash functions):
MAC’s (siehe oben)
105
n−1 k
)
n
Merkle’s Methode zur Konstruktion von Hash–Funktionen
Input: kollisionsfreie Kompressionsfunktion f , die (n + r)–Bit–Inputs in n–Bit–
Outputs transformiert
Output: kollisionsfreie Hash–Funktion h, die n–Bit–Hash–Werte erzeugt
1. unterteile einen Input x mit b Bits in Blöcke x1, · · · , xt mit je r Bits Länge,
wobei der letzte Block evtl. mit Nullen aufzufüllen ist
2. hänge einen letzten Block xt+1 an, um die eigentliche Länge b abzuspeichern
(vorausgesetzt, dass b < 2r )
3. sei 0j die Zeichenkette aus j Nullen; berechne
H0 := 0n,
Hi := f (Hi−1kxi) für 1 ≤ i ≤ t + 1
4. setze h(x) := Ht+1 = f (Ht kxt+1)
Verkettung von Hash–Funktionen
Sind h1 und h2 Hash–Funktionen, von denen mindestens eine kollisionsfrei ist,
so ist auch h mit
h(x) := h1 (x)kh2(x)
eine kollisionsfreie Hash–Funktion (die allerdings einen längeren Output erzeugt).
Beispiele von zur Zeit häufig benutzten Hash-Funktionen:
MD5, RIPEMD–128 (beide Funktionen erzeugen Hashwerte mit einer Bitlänge
von 128)
SHA–1, RIPEMD–160 (beide Funktionen erzeugen Hashwerte mit einer Länge
von 160 Bits)
SHA–224, SHA–256, SHA–384, SHA–512 (im Jahr 2000 veröffentlicht [FIPS–
180]; die Zahlen geben die Längen der Hashwerte an)
106
Ein Pseudocode für RIPEMD-160
RIPEMD-160 is an iterative hash function that operates on 32-bit words. The
round function takes as input a 5-word chaining variable and a 16-word message
block and maps this to a new chaining variable. All operations are defined on 32bit words. Padding is identical to that of MD4. First we define all the constants
and functions.
RIPEMD-160: definitions
nonlinear functions at bit level:
f (j, x, y, z) = x ⊕ y ⊕ z
f (j, x, y, z) = (x ∧ y) ∨ (¬x ∧ z)
f (j, x, y, z) = (x ∨ ¬y) ⊕ z
f (j, x, y, z) = (x ∧ z) ∨ (y ∧ ¬z)
f (j, x, y, z) = x ⊕ (y ∨ ¬z)
(0 ≤ j ≤ 15)
(16 ≤ j ≤ 31)
(32 ≤ j ≤ 47)
(48 ≤ j ≤ 63)
(64 ≤ j ≤ 79)
added constants (hexadecimal):
K(j) = 00000000
K(j) = 5A827999
K(j) = 6ED9EBA1
K(j) = 8F 1BBCDC
K(j) = A953F D4E
K ′(j) = 50A28BE6
K ′(j) = 5C4DD124
K ′(j) = 6D703EF 3
K ′(j) = 7A6D76E9
K ′(j) = 00000000
selection of message word:
(0 ≤ j ≤ 15)
(16 ≤ j ≤ 31)
(32 ≤ j ≤ 47)
(48 ≤ j ≤ 63)
(64 ≤ j ≤ 79)
(0 ≤ j ≤ 15)
(16 ≤ j ≤ 31)
(32 ≤ j ≤ 47)
(48 ≤ j ≤ 63)
(64 ≤ j ≤ 79)
√
⌊230 ∗ √2⌋
⌊230 ∗ √3⌋
⌊230 ∗ √5⌋
⌊230 ∗ √7⌋
3
2⌋
⌊230 ∗ √
3
30
⌊2 ∗ √3⌋
3
5⌋
⌊230 ∗ √
3
30
⌊2 ∗ 7⌋
r(j) = j (0 ≤ j ≤ 15)
r(16..31) = 7, 4, 13, 1, 10, 6, 15, 3, 12, 0, 9, 5, 2, 14, 11, 8
r(32..47) = 3, 10, 14, 4, 9, 15, 8, 1, 2, 7, 0, 6, 13, 11, 5, 12
r(48..63) = 1, 9, 11, 10, 0, 8, 12, 4, 13, 3, 7, 15, 14, 5, 6, 2
r(64..79) = 4, 0, 5, 9, 7, 12, 2, 10, 14, 1, 3, 8, 11, 6, 15, 13
r′ (0..15) = 5, 14, 7, 0, 9, 2, 11, 4, 13, 6, 15, 8, 1, 10, 3, 12
r′ (16..31) = 6, 11, 3, 7, 0, 13, 5, 10, 14, 15, 8, 12, 4, 9, 1, 2
r′ (32..47) = 15, 5, 1, 3, 7, 14, 6, 9, 11, 8, 12, 2, 10, 0, 4, 13
r′ (48..63) = 8, 6, 4, 1, 3, 11, 15, 0, 5, 12, 2, 13, 9, 7, 10, 14
r′ (64..79) = 12, 15, 10, 4, 1, 5, 8, 7, 6, 2, 13, 14, 0, 3, 9, 11
107
Fortsetzung des Pseudocodes für RIPEMD-160
amount for rotate left (rol):
s(0..15) = 11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8
s(16..31) = 7, 6, 8, 13, 11, 9, 7, 15, 7, 12, 15, 9, 11, 7, 13, 12
s(32..47) = 11, 13, 6, 7, 14, 9, 13, 15, 14, 8, 13, 6, 5, 12, 7, 5
s(48..63) = 11, 12, 14, 15, 14, 15, 9, 8, 9, 14, 5, 6, 8, 6, 5, 12
s(64..79) = 9, 15, 5, 11, 6, 8, 13, 12, 5, 12, 13, 14, 11, 8, 5, 6
s′ (0..15) = 8, 9, 9, 11, 13, 15, 15, 5, 7, 7, 8, 11, 14, 14, 12, 6
s′ (16..31) = 9, 13, 15, 7, 12, 8, 9, 11, 7, 7, 12, 7, 6, 15, 13, 11
s′ (32..47) = 9, 7, 15, 11, 8, 6, 6, 14, 12, 13, 5, 14, 13, 13, 7, 5
s′ (48..63) = 15, 5, 8, 11, 14, 14, 6, 14, 6, 9, 12, 9, 12, 5, 15, 8
s′ (64..79) = 8, 5, 12, 9, 12, 5, 14, 6, 8, 13, 6, 5, 15, 13, 11, 11
initial value (hexadecimal):
h0 = 67452301 ; h1 = EF CDAB89 ; h2 = 98BADCF E;
h3 = 10325476 ; h4 = C3D2E1F 0
It is assumed that the message after padding consists of t 16-word blocks that
will be denoted with Xi [j], with 0 ≤ i ≤ t − 1 and 0 ≤ j ≤ 15. The symbol rols
denotes cyclic left shift (rotate) over s positions. The pseudo-code for RIPEMD–
160 is then given below:
RIPEMD–160: pseudo-code
for i := 0 to t - 1 {
A := h0 ; B := h1 ; C := h2 ; D = h3 ; E = h4 ;
A′ := h0 ; B ′ := h1 ; C ′ := h2 ; D′ = h3 ; E ′ = h4 ;
for j := 0 to 79 {
T := rols(j) (A + f (j, B, C, D) + Xi [r(j)] + K(j) mod 232)
+E mod 232;
A := E ; E := D ; D := rol10 (C) ; C := B ; B := T ;
T := rols′ (j) (A′ + f (79 − j, B ′ , C ′, D′ ) + Xi[r′ (j)] + K ′(j) mod 232)
+E ′ mod 232;
A := E ; E := D ; D := rol10 (C) ; C := B ; B := T ; }
T := (h1 + C + D′ ) mod 232 ; h1 := (h2 + D + E ′) mod 232 ;
h2 := (h3 + E + A′ ) mod 232; h3 := (h4 + A + B ′ ) mod 232;
h4 := h0 + B + C ′) mod 232 ; h0 := T ;
}
108
Testwerte für die Hashfunktionen MD5, SHA–1 und RIPEMD–160
Werte der Hash-Funktionen MD5, SHA–1 und RIPEMD–160 für die vier Zeichenketten
””, ”a”, ”abc” und ”abcdefghijklmnopqrstuvwxyz”
in dieser Reihenfolge:
MD5:
d41d8cd98f00b204e9800998ecf8427e
0cc175b9c0f1b6a831c399e269772661
900150983cd24fb0d6963f7d28e17f72
c3fcd3d76192e4007dfb496cca67e13b
SHA–1:
da39a3ee5e6b4b0d3255bfef95601890afd80709
86f7e437faa5a7fce15d1ddcb9eaeaea377667b8
a9993e364706816aba3e25717850c26c9cd0d89d
32d10c7b8cf96570ca04ce37f2a19d84240d3a89
RIPEMD–160:
9c1185a5c5e9fc54612808977ee8f548b2258d31
0bdc9d2d256b3ee9daae347be6f4dc835a467ffe
8eb208f7e05d987a9b044a8e98c6b087f15a0bfc
f71c27109c692c1b56bbdceb5b9d2865b3708dbc
1 million times ”a”:
52783243c1697bdbe16d37f97f68f08325dc1528
109
Schlüsselmanagement durch eine öffentliche Datei
Schlüsselmanagement enthält zunächst
Initialisierung der System–Nutzer
Erzeugung, Verteilung und Installation des Schlüsselmaterials
Steuerung der Nutzung des Schlüsselmaterials
Erneuerung, Widerruf und Zerstörung von Schlüsselmaterial
Speicherung, Backup und Archvierung von Schlüsselmaterial
öffentliche Datei
B1
priv. Schl. d
1
c := Ee (m)
3
B2
B : e1
1
e3
B2 : e
2
B : e3
3
c
priv. Schl. d2
B3
priv. Schl. d3
m = Dd (c)
3
B1 will an B3 eine verschlüsselte Nachricht senden;
B1 besorgt sich deshalb den öffentlichen Schlüssel e3 von B3 ;
mit Hilfe von e3 wird die Nachricht verschlüsselt und der Ciphertext c an B3
gesandt;
B3 kann mit Hilfe seines privaten Schlüssels d3 den Ciphertext dechiffrieren
110
Schlüsselmanagement mit Zertifizierung der öffentlichen Schlüssel
B1 will an B3 eine Nachricht m senden, und zwar verschlüsselt mit B3 ’s öffentlichem Schlüssel e3 . Dazu lädt B1 sich den öffentlichen Schlüssel von B3 samt
Signatur von einem Key Server und überprüft die Echtheit dieses Schlüssels.
B
1
Verifikation
ver((B , e ) , s )
3 3 3
Verschlüsselung
c := E e (m)
3
öffentliche Datei
B : e , s
1
1 1
e
3
B : e , s
2
2 2
s
3
B : e , s
3
3 3
c
B
3
d
3
m := Dd (c)
3
si : Signatur des öffentlichen Schlüssels ei von Bi, erzeugt mit Hilfe des privaten
Teils des Signaturschlüssels des Servers
ver((Bi, si ), ei): Verifizieren der Echtheit der Signatur si mit Hilfe des öffentlichen Teils des Signaturschlüssels des Servers
Ein Key Server wird manchmal auch, vor allem im Zusammenhang mit Kerberos
(s.u.), als Key Distribution Center (KDC) bezeichnet.
111
Public–Key–Infrastrukturen (PKI)
Zertifikate (s. Folie 21) werden in der Regel in eine hierarchische Struktur
(PKI) eingebettet.
Die Wurzelinstanz (root) erzeugt dabei ein spezielles Zertifikat, indem sie
mit ihrem privaten Schlüssel ihren öffentlichen Schlüssel selbst signiert.
Große Zertifizierer, wie z.B. VeriSign, lassen ihre Wurzelzertifikate in Webbrowser und e–mail–clients integrieren.
Mit dem privaten Schlüssel der Wurzelinstanz werden alle Zertifikate der
zweiten Ebene, der CA’s (Certification Authorities), signiert. Diese wiederum signieren mit ihren privaten Schlüsseln die Zertifikate der Nutzer.
Eine CA ist für die Feststellung von Identitäten und die Generierung von
digitalen Zertifikaten zuständig.
Je nach Rang der Identitätsprüfung (von pers. Erscheinen in der Behörde
bis ohne strenge Prüfung der Personalien) bei Vergabe eines Zertifikates
werden diese in Klassen unterteilt. Höchste Klasse: 4.
Zertifizierungsdiensteanbieter sowie Prüf– und Bestätigungsstellen für Zer-
tifikate findet man unter
www.bundesnetzagentur.de
Die Bundesnetzagentur ist die für elektronische Signaturen zuständige Behörde gemäß Paragraph 3 des Signaturgesetzes (s. auch Folie 99).
112
Kerberos
Gegenseitige Authentifizierung von Alice und Bob und Schlüsselvereinbarung mit Hilfe eines zentralen Servers S ohne Benutzung von public–key–
Kryptographie; ist komplexerer Natur und wird oft im Internet–Bereich angewendet. Der zentrale Server spielt die Rolle einer vertrauenswürdigen dritten
Instanz (Trusted Third Party, TTP). Vorausgesetzt wird dabei, dass A und B
jeweils einen geheimen (symmetrischen) Schlüssel KAS und KBS mit S besitzen.
A teilt S mit, dass sie vertraulich und authentisch mit B kommunizieren
möchte.
S antwortet darauf mit einem Datensatz, der mit dem gemeinsamen sym-
metrischen Schlüssel KAS von A und S verschlüsselt ist. Dieser Datensatz
enthält einen Zeitstempel TS , eine Gültigkeitsdauer L, den mit B zu verwendenden Schlüssel KAB , die Bestätigung, dass S den Namen von B richtig
verstanden hat und eine verschlüsselten Datensatz für B.
A extrahiert den verschlüsselten Datensatz für B und verschlüsselt ihrer-
seits mit dem neuen Schlüssel KAB ihren eigenen Namen und einen Zeitstempel TA und sendet beides an B.
B entschlüsselt den Datensatz von S und dann mit dem neuen Schlüssel
die Nachricht von A. Er antwortet mit einem leicht geänderten Wert TA +1
von TA an A.
Nach diesen vier Schritten besitzen A und B einen gemeinsamen Schlüssel KAB ,
und sie haben sich gegenseitig durch Austausch der Nachrichten eKAB (A, TA)
und eKAB (TA + 1) authentifiziert.
S
1. A : B
2. e
(T , L, K , B, e
(T , L, K , A))
KAS S
AB
K
S
AB
BS
A
3. e (T , L, K , A), e (A, T )
KBS S
AB
KAB A
4. e (T +1)
K A
AB
113
B
Shared secret keys
Mehrere Parteien teilen sich einen symmetrischen Schlüssel in der Weise, dass
jeweils eine bestimmte Mindest–Anzahl davon, eventuell abhängig von einem
Rang, notwendig ist, damit aus deren Teilschlüsseln der eigentliche Schlüssel
erzeugt werden kann (ein Tresor hat n Schlösser, die alle entsperrt sein müssen,
damit sich der Tresor öffnen lässt).
Beispiele:
Aus je drei Teilschlüsseln soll der Schlüssel bestimmbar sein:
Es wird ein (geheimes) Polynom y = a ∗ x2 + b ∗ x + s zweiten Grades festgelegt, wobei s, nämlich die y–Koordinate des Schnittpunktes des
Polynoms mit der y–Achse, der Schlüssel ist. Alle Teilschlüsselinhaber bekommen paarweise verschiedene Punkte (xi, yi) des Polynoms zugeordnet.
Da aus drei Punkten das Polynom rekonstruiert werden kann, kann aus je
drei (aber nicht aus weniger) Punkten (den Teilschlüsseln) der Schlüssel s
bestimmt werden.
Je zwei Direktoren, je drei Vizedirektoren oder je ein Direktor zusammen
mit zwei Vizedirektoren sollen den Schlüssel s erzeugen können:
Es wird eine (geheime) Ebenengleichung a∗x+b∗y +c∗z = 1 festgelegt mit
c 6= 0, so dass die Ebene genau einen Schnittpunkt (0, 0, 1/c) mit der z–
Achse hat. Als Schlüssel wird s := 1/c verwendet. Außerdem wird eine (geheime) Gerade festgelegt, die in der obigen Ebene liegt und die auch durch
den Punkt (0, 0, 1/c) geht. Die Direktoren erhalten als Schlüssel paarweise
verschiedene Punkte auf der Geraden als ihre Teilschlüssel zugewiesen, und
die Vizedirektoren paarweise verschiedene Punkte der Ebene, wobei keiner
dieser Punkte auf der Geraden liegen darf. Außerdem dürfen je drei Vizedirektorenpunkte nicht auf einer Geraden liegen, weil sonst der Schlüssel
nicht berechenbar wäre (oder diese Gerade verläuft durch (0, 0, 1/c)).
114
Einmal–Passworte
OTP (one time password), siehe auch RFC 1760 bzw. RFC 2289;
Anwenden, wenn z. B. Kerberos oder SSH nicht etabliert sind;
zur Erzeugung spielen Einwegfunktionen eine große Rolle
Beispiel: S/Key–Verfahren
Authentifizierungsprogramm, um Password–Sniffer–Angriffe in Client–Server–
artigen kommunizierenden Systemen wirkungslos zu machen.
Initialisierung
Ausgangspunkt ist geheimes Passwort s, das vorab zwischen Benutzer und
seinem Arbeitsplatzrechner, dem Client, vereinbart wurde. Der Server benötigt s nicht und muss s auch nicht verwalten!
1. Clientrechner berechnet
pi := hashi (s||k) für i = 1, · · · , n
wobei k ein seed ist.
Zur Authentifikation des Clients gegenüber dem Server werden ausschließlich diese Einmal–Passwörter pi verwendet.
2. Client sendet pn zusammen mit k an Server. Das Seed ist eindeutig für
den Benutzer auf dem entsprechenden Server und dient dazu, dass ein
Benutzer das gleiche (geheime) Passwort s für verschiedene Rechner
verwenden kann. (Seed hat ähnliche Bedeutung wie Salt beim Unix–
Login, siehe unten.)
S/Key–Authentifikation
Nach der i–ten Authentifikation hat der Server für einen Nutzer dessen
Namen zusammen mit dessen pj , j und k gespeichert, wobei j := n − i ist.
Wenn der Client sich erneut authentifizieren will, so folgende Schritte:
1. er sendet seinen Namen an den Server
2. dieser sendet j − 1 und k zurück
3. Client sendet pj−1 an Server; dieser berechnet p′j := hash(pj−1 ) und
überprüft, ob pj = p′j ist; genau dann, wenn das so ist, hat der Client sich authentifiziert, und der Server speichert für eine zukünftige
Authentifizierung dieses Nutzers die Werte pj−1 und j − 1 ab
(Es ist pj = hashj (s||k) = hash(hashj−1 (s||k)) = hash(pj−1 )).)
115
Einmal–Passwörter auf der Basis von Hardware–Tokens
Beispiel: RSA–Secure–ID–Token zur Authentifizierung eines Nutzers gegenüber
einem RSA–ACE–Server (ACE: Access Control and Encryption)
zwei–Faktor–Authentifizierung mit Hilfe einer PIN und mit Hilfe des To-
kens (also nicht wie eben mit Hilfe eines challenge–response–Protokolls)
Nutzer besitzt auf Server eine Kennung, die verknüpft ist mit der Serien-
nummer seines Tokens sowie mit einem auf dem Token gespeicherten seed;
dieses seed wird als symmetrischer Schlüssel eingesetzt
der Server und das Token besitzen eine zeitsynchrone Uhr; das Token er-
zeugt im 30– oder 60–Sekunden–Takt ein neues Passwort, den sogen. Tokencode, der auf dem Display des Tokens angezeigt wird
dieses Einmal–Passwort wird erzeugt unter Rückgriff auf die Sereinnummer
des Tokens, auf das Seed und auf eine keyed Hash–Funktion (oft AES)
sowohl Token als auch Server generieren synchron das gleiche Einmal–
Passwort, so dass der Nutzer sich mit seiner Kennung, seiner PIN und
seinem Einmal–Passwort gegenüber dem Server authentifizieren kann
Passwort–Sitter
Java–Applikation bzw. Java–Applet, das ein zum Login notwendiges Passwort
bei Bedarf generiert. Lediglich auf der Client–Seite muss das Applet installiert
werden, und das Passwort wird mittels copy–and–paste in das Anmeldefenster
übertragen. Man benötigt als Nutzer nur ein Master–Passwort, und für jeden
Account kann mit Hilfe eines spezifischen seed dafür ein starkes Passwort deterministisch mit Hilfe von AES erzeugt werden. Das Passwort bleibt jeweils
lediglich 60 Sekunden verfügbar (siehe auch www.passwordsitter.de/).
116
Authentifikation in UNIX
zugrunde liegen ein benutzergewähltes Passwort und ein Salt
das Salt ist eine 12–Bit–Zahl, die Werte von 0 bis 4095 annehmen kann; es
wird spezifisch für jeden Nutzer beim erstmaligen Einrichten der Kennung
bzw. bei jedem Passwortwechsel unter Einbeziehung der aktuellen Uhrzeit
und der Prozessidentifikation von der Datei /bin/passwd erzeugt und nutzerspezifisch als Klartext durch zwei Zeichen in /etc/passwd eingetragen
mit dem Passwort wird (natürlich auch mit dem jeweiligen Nutzer ver-
knüpft) mit Hilfe von crypt(3), einer Variante des DES–Algorithmus, ein
64–Bit–Block aus lauter Nullen mehrfach iteriert verschlüsselt; die 64–Bit–
Ausgabe wird anschließend in 11 Zeichen transformiert und nutzerspezifisch auch in /etc/passwd eingetragen (das Passwort wird also nicht im
Klartext abgespeichert)
das Salt beeinflusst die Verschlüsselung, in dem eine von 4096 verschiede-
nen Verschlüsselungsvarianten ausgewählt wird; diese Varianten ergeben
sich durch Veränderungen der Expansionsabbildung E des DES (E erweitert einen 32–Bit Block auf einen 48–Bit Block, siehe Folie 67 und folgende);
hat ein Nutzer das gleiche Passwort auf verschiedenen Unix–Systemen, so
werden aufgrund unterschiedlicher Salts unterschiedliche Hashwerte in den
/etc/passwd–Dateien stehen; das Salt erschwert auch einen Angriff mit
gewählten Klartexten
Authentifikation:
der Nutzer gibt seine Kennung und sein Passwort ein; aus der Datei
/etc/passwd wird sein Salt ausgelesen, und damit und mit seinem Passwort
wie oben beschrieben der 64–Nullen–Block iteriert verschlüsselt; stimmt
das Ergebnis mit dem entsprechenden Eintrag in /etc/passwd überein, so
hat sich der Nutzer authentifiziert
117
Fiat–Shamir–Protokoll
Alice wählt zwei Primzahlen p 6= q und bildet n := p ∗ q (n ist öffentlich, p, q
sind geheim).
Alice wählt weiterhin eine nat. Zahl s ∈ Z∗n (die ihr ”individuelles” Geheimnis
bleibt) und berechnet v := s2 mod n.
v ist öffentlich und kann zum Verifizieren dafür benutzt werden, dass Alice das
Geheimnis s kennt.
(Es können auch von einem Trust–Center Werte s und v für jeden Teilnehmer
berechnet werden.)
Alice kann jetzt auf folgende Weise Bob davon überzeugen, dass sie das
Geheimnis s kennt, ohne dass sie dieses irgendjemandem verrät und ohne dass
jemand aus ihrem Verhalten das Geheimnis rekonstruieren kann (Beispiel für
ein zero–knowledge–Protokoll):
1. Alice wählt Zufallszahl r ∈ Z∗n ;
dann berechnet sie x := r2 mod n und sendet x an Bob
2. Bob wählt ein zufälliges Bit b und sendet dieses an Alice (challenge)
3. Alice bildet y := r ∗ sb mod n und sendet y an Bob (response)
4. Bob überprüft, ob y 2 = x ∗ v b mod n gilt
Wenn Alice das Geheimnis s wirklich kennt, so kann sie Bob auch davon überzeugen, da gilt:
y 2 = (r ∗ sb )2 = r2 ∗ s2b = r2 ∗ v b = x ∗ v b mod n
118
Verallgemeinerung des Fiat–Shamir–Protokolls
n wie oben Produkt zweier großer Primzahlen p 6= q, allerdings jetzt
p, q = 3 mod 4; nat. Zahlen k, t werden als Sicherheitsparameter gewählt
Jede Partei A, die sich später gegenüber anderen authentifizieren will, macht
folgendes:
1. Auswahl von k zufälligen ganzen Zahlen s1 , · · · , sk mit 1 ≤ si ≤ n − 1 und
Auswahl von k zufälligen Bits b1 , · · · , bk ; dabei muss ggt(si, n)=1 sein
2. A berechnet vi := (−1)bi ∗ (s2i )−1 mod n für 1 ≤ i ≤ k
3. A identifiziert sich durch nicht–kryptografische Mittel gegenüber TTP, die
dann A’s öffentlichen Schlüssel (v1, · · · , vk , n) registriert; nur A kennt seinen
privaten Schlüssel (s1, · · · , sk ) (und n).
Bob akzeptiert Alice’s Identität, falls das folgende Protokoll t–mal erfolgreich
verläuft:
1. Alice wählt Zufallszahl r ∈ Z∗n und Zufallsbit b;
dann berechnet sie x := (−1)b ∗ r2 mod n und sendet x an Bob
2. Bob wählt zufälligen Bitvektor (e1, · · · , ek ) und sendet diesen an Alice
(challenge)
3. Alice bildet y := r ∗
4. Bob berechnet z :=
z 6= 0
Qk
ej
j=1 sj mod n und
Q
e
y 2 ∗ kj=1 vj j mod n
119
sendet y an Bob (response)
und verifiziert, dass z = ±x und
TTP bzw. TA wählen folgende Parameter bzw. Verfahren und Funktionen aus
(Vorbereitungen zur Authentifizierung nach Schnorr)
TA (Trusted Authority) wählt große Primzahl p (p ≥ 2512), so dass das
diskrete Logarithmus–Problem in Z∗p praktisch unlösbar ist
q sei ein großer Primfaktor von p − 1 (q > 2140)
α ∈ Z∗p habe die Ordnung q (α ist die
Elementes von
Z∗p )
p−1
q –te
Potenz eines primitiven
t ∈ N (Sicherheitsparameter) wird so gewählt, dass q > 2t (z.B. t = 40)
TA stellt weiterhin ein sicheres Signaturschema zur Verfügung mit einem
geheimen Signierungsalgorithmus sigT A und einem öffentlichen Verifikationsalgorithmus verT A
eine kryptografische Hash–Funktion wird festgelegt (damit wird vor dem
Signieren der Nachricht deren Hashwert berechnet)
p, q, α, verT A und die Hash–Funktion sind öffentlich
Ausgabe eines Zertifikates an Alice durch die TA
TA stellt Alice’s Identität fest durch konventionelle Methoden (Pass etc.)
und legt eine Zeichenkette ID(Alice) fest, die Alice’s Identifizierungs–
Information enthält
Alice wählt einen zufälligen Exponent a mit 0 ≤ a ≤ q − 1, der geheim
bleibt; dann berechnet sie
v := α−a mod p
und übergibt v an die TA
TA erzeugt eine Signatur
s := sigT A (ID(Alice), v) ;
das Zertifikat
C(Alice) := (ID(Alice), v, s)
wird an Alice übergeben und kann veröffentlicht werden
120
Authentifizierungsprotokoll nach Schnorr
1. Alice wählt Zufallszahl k mit 0 ≤ k ≤ q − 1 und berechnet γ := αk mod p;
sie sendet dann C(Alice) und γ an Bob
2. Bob verifiziert, dass verT A(ID(Alice), v, s) = true und wählt Zufallszahl r
mit 1 ≤ r ≤ 2t ;
er sendet dann r an Alice (challenge)
3. Alice berechnet y := k + a ∗ r mod q und sendet y an Bob (response)
4. Bob verifiziert, dass γ = αy ∗ v r mod p ist
121