01.09.2013 Aufrufe

Teil 3: Grundlagen der Kryptographie 2

Teil 3: Grundlagen der Kryptographie 2

Teil 3: Grundlagen der Kryptographie 2

MEHR ANZEIGEN
WENIGER ANZEIGEN

Erfolgreiche ePaper selbst erstellen

Machen Sie aus Ihren PDF Publikationen ein blätterbares Flipbook mit unserer einzigartigen Google optimierten e-Paper Software.

Vorlesung Informationssicherheit<br />

Thema 3: <strong>Grundlagen</strong> <strong>der</strong> <strong>Kryptographie</strong><br />

Robert Baumgartl<br />

25. 03. 2013<br />

1 / 99


Motivation<br />

“We ’ve got a five-tier level of defense,” Jabba<br />

explained. “A primary Bastion Host, two sets of packet<br />

filters for FTP and X-eleven, a tunnel block, and finally<br />

a PEM-based authorization window right off the Truffle<br />

project. The outside shield that’s disappearing<br />

represents the exposed host. It’s practically gone.<br />

Within the hour, all five shields will follow. After that,<br />

the world pours in. Every byte of NSA data becomes<br />

public domain.” 1<br />

Damit Sie obiges verstehen, gibt es die Veranstaltung<br />

Informationssicherheit!<br />

1 „Jabba“ erklärt die Sicherheitsarchitektur <strong>der</strong> NSA. In: Dan Brown: Digital Fortress, 1998<br />

2 / 99


Zufallszahlen<br />

Wozu?<br />

◮ (Monte-Carlo-)Simulation, Statistik<br />

◮ randomisierte Algorithmen<br />

◮ Spiele<br />

◮ Kryptografie<br />

Zufallszahlen – durch einen echten zufälligen Prozess<br />

generiert (Rauschen, atomare Zerfallsprozesse, . . . )<br />

Pseudozufallszahlen – Folgen von Zahlen, die wie<br />

Zufallszahlen aussehen (, aber durch einen deterministischen<br />

Prozess generiert werden)<br />

3 / 99


Güte von Zufallszahlen<br />

Anfor<strong>der</strong>ungen:<br />

1. Gleichverteilung<br />

2. lange bzw. keine Periode<br />

3. Unabhängigkeit<br />

4. effizient ermittelbar<br />

Kryptografisch sichere Zufallszahlen dürfen zusätzlich nicht<br />

vorhersehbar sein.<br />

Prüfung <strong>der</strong> Güte erfolgt mittels Tests, z.B.:<br />

wahrscheinlichkeitstheoretisch empirisch<br />

2 sprich: „Tschih-Quadrat-Test“<br />

χ 2 -Test 2 Gleichverteilungstest<br />

Kolmogorov-Smirnov-Test Serientest<br />

4 / 99


χ 2 -Test<br />

Beispiel 3 : 2 gekoppelte Würfel<br />

Augen s 2 3 4 5 6 7 8 9 10 11 12<br />

Wkt. ps<br />

1<br />

36<br />

2<br />

36<br />

3<br />

36<br />

4<br />

36<br />

5<br />

36<br />

6<br />

36<br />

5<br />

36<br />

Experiment mit n = 144 Würfen<br />

gezählt Ys 2 4 10 12 22 29 21 15 14 9 6<br />

erwartet (nps) 4 8 12 16 20 24 20 16 12 8 4<br />

◮ Maß für die „Abweichung“ <strong>der</strong> Würfelwerte vom „richtigen“<br />

Verhalten:<br />

4<br />

36<br />

3<br />

36<br />

2<br />

36<br />

V = (Y2 − np2) 2 + (Y3 − np3) 2 + · · · + (Y12 − np12) 2<br />

◮ unausgewogen, da (z. B.) Fehler in Y7 aufgrund p7 > p2 viel<br />

stärker gewichtet als Fehler in Y2<br />

3 D. E. Knuth: The Art of Computer Programming. Vol. 2, 1998, S. 42ff<br />

1<br />

36<br />

5 / 99


χ 2 -Test, fortgesetzt<br />

Beispiel: 2 gekoppelte Würfel und Verallgemeinerung<br />

◮ Normierung mit erwarteter Anzahl:<br />

Allgemein gilt:<br />

V = (Y2 − np2) 2<br />

+<br />

np2<br />

(Y3 − np3) 2<br />

+ · · · +<br />

np3<br />

(Y12 − np12) 2<br />

np12<br />

V =<br />

k (Ys − nps) 2<br />

s=1<br />

nps<br />

= 1<br />

n<br />

k<br />

2 Ys s=1<br />

ps<br />

<br />

− n<br />

V wird nun in <strong>der</strong> Tabelle <strong>der</strong> Quantile <strong>der</strong> χ 2 -Verteilung aufgesucht:<br />

◮ Freiheitsgrade ν („nü“) = k − 1 (Anzahl Kategorien - 1)<br />

◮ Tabelleneintrag x in Zeile ν: „V ist kleiner o<strong>der</strong> gleich x mit<br />

Wahrscheinlichkeit p.“<br />

6 / 99


χ 2 -Test, fortgesetzt<br />

Tabelle <strong>der</strong> Quantile <strong>der</strong> χ 2 -Verteilung<br />

Freiheits- p<br />

grade 1% 5% 25% 50% 75% 95% 99%<br />

ν = 1 0.00 0.00 0.11 0.45 1.32 3.84 6.63<br />

ν = 2 0.02 0.10 0.58 1.39 2.77 5.99 9.21<br />

ν = 3 0.11 0.35 1.21 2.37 4.11 7.81 11.34<br />

ν = 4 0.30 0.71 1.92 3.36 5.39 9.49 13.28<br />

ν = 5 0.55 1.15 2.68 4.35 6.63 11.07 15.09<br />

ν = 6 0.87 1.64 3.46 5.35 7.84 12.59 16.81<br />

ν = 7 1.24 2.17 4.26 6.35 9.04 14.07 18.48<br />

ν = 8 1.65 2.73 5.07 7.34 10.22 15.51 20.09<br />

ν = 9 2.09 3.33 5.90 8.34 11.39 16.92 21.67<br />

ν = 10 2.56 3.94 6.74 9.34 12.55 18.31 23.21<br />

ν = 11 3.05 2.82 7.54 10.34 13.70 19.68 24.73<br />

ν = 12 3.57 5.23 8.44 11.34 14.85 21.03 26.22<br />

Für das Beispiel gilt V ≈ 7.15, ν = 10 . Abzulesen: V ≤ 9.34 mit 50%iger Wkt., V ≤ 6.74 mit 25%iger Wkt.<br />

Fazit: V = 7.15 tritt in rund einem Drittel aller Fälle auf; Würfel sind o.k.!<br />

7 / 99


Lineare Kongruenzgeneratoren<br />

Berechnung einer Zufallsfolge mittels<br />

zi+1 = (azi + b) mod m<br />

(m prim, Initialisierungswert z0 mit 0 < z0 < m; a, b Parameter)<br />

Beispiel: a = 6, b = 0, m = 13, z0 = 2<br />

i 0 1 2 3 4 5 6 7 8 9 10 11 12 . . .<br />

z i 2 12 7 3 5 4 11 1 6 10 8 9 2 . . .<br />

◮ generiert volle Periode (auch für m = 2 31 − 1, a = 16807 u. a.)<br />

◮ keine volle Periode z. B. für m = 13, a = 5, z0 = 1<br />

◮ effiziente Berechnung, gutes statistisches Verhalten<br />

◮ ungeeignet für kryptografische Zwecke, da vorhersehbar<br />

(vgl. James Reeds: “Cracking” a Random Number Generator.<br />

Cryptologia Vol. 1, No. 1, 1977, S. 20–26)<br />

8 / 99


Linear rückgekoppelte Schieberegister<br />

Prinzip<br />

Rückkopplungsfunktion<br />

bn bn−1 ... b3 b2 b1 Zufallsbit<br />

Abbildung: Rückgekoppeltes Schieberegister mit n Bit Länge<br />

Arbeitsweise:<br />

◮ Ausgabe des Bits b1 als neues Zufallsbit<br />

◮ gleichzeitig Verknüpfung <strong>der</strong> Bits bi miteinan<strong>der</strong> (z. B.<br />

mittels ⊕) in Rückkopplungsfunktion<br />

◮ Ergebnis <strong>der</strong> Verknüpfung wird bn, alle an<strong>der</strong>en Bits eine<br />

Stelle nach rechts<br />

9 / 99


Linear rückgekoppeltes Schieberegister<br />

Beispiel<br />

b4<br />

XOR<br />

b3 b2 b1<br />

ZB<br />

◮ sog. linear feedback shift register<br />

(LFSR)<br />

◮ n = 4 Bit; Init: z0 = 1111<br />

◮ hier: maximale Periode (2 n − 1)<br />

◮ Ergebnis darf nie 0 sein<br />

i b ZB<br />

0 1111 -<br />

1 0111 1<br />

2 1011 1<br />

3 0101 1<br />

4 1010 1<br />

5 1101 0<br />

6 0110 1<br />

7 0011 0<br />

8 1001 1<br />

9 0100 1<br />

10 0010 0<br />

11 0001 0<br />

12 1000 1<br />

13 1100 0<br />

14 1110 0<br />

15 1111 0<br />

usw.<br />

10 / 99


Einwegfunktionen<br />

. . . sind ein wichtiger Baustein kryptografischer Verfahren<br />

◮ Bestimmung von f (x) aus x leicht (vorwärts)<br />

◮ Bestimmung von x aus gegebenem f (x) extrem schwer,<br />

d. h. nur mit allen zur Verfügung stehenden Rechnern <strong>der</strong><br />

Welt in hun<strong>der</strong>ten von Jahren<br />

Beispiele:<br />

◮ Suche einer Telefonnummer zu gegebenem Namen im<br />

Telefonbuch ist einfach<br />

◮ Suche eines Namens zu gegebener Telefonnummer im<br />

Telefonbuch ist schwierig<br />

◮ Multiplikation zweier (großer) Primzahlen ist einfach<br />

◮ Zerlegung des Produktes in zwei Primzahlfaktoren ist<br />

extrem aufwändig (→ Faktorisierungsverfahren)<br />

11 / 99


Einwegfunktionen, contd.<br />

Es gibt<br />

◮ keinen Beweis für die Existenz von und<br />

◮ keine systematischen Konstruktionsverfahren für<br />

Einwegfunktionen.<br />

Einwegfunktion mit Hintertür:<br />

◮ mit Kenntnis eines Zusatzschlüssels wird die Ermittlung<br />

von x aus f (x) einfach.<br />

12 / 99


Einweg-Hashfunktionen<br />

. . . sind Einwegfunktionen, die zu gegebenen Daten variabler<br />

Länge einen Funktionswert konstanter, meist kurzer Länge (→<br />

„Fingerabdruck“, kryptografischer Hash, Message Digest)<br />

ermitteln.<br />

◮ Hash H(m) zu gegebenen Daten m ist leicht zu ermitteln<br />

(effizient zu berechnen).<br />

◮ Zu vorgegebenem Hash eine passende Eingabe zu<br />

konstruieren ist hingegen (extrem) schwer<br />

(m = H −1 (H(m))).<br />

◮ Än<strong>der</strong>ung eines Bits in <strong>der</strong> Eingabe sollte im Mittel die<br />

Hälfte <strong>der</strong> Bits in <strong>der</strong> Ausgabe än<strong>der</strong>n.<br />

Anwendung:<br />

◮ Integritätssicherung von Dateien<br />

◮ Digitales Signieren<br />

◮ Authentifizierung<br />

13 / 99


Kryptografische Hashverfahren<br />

Beispiele<br />

Hashlänge Blockgröße<br />

Verfahren Jahr gebrochen? [Bit] [Bit]<br />

MD2 1988 4 128 128<br />

MD4 1990 128 512<br />

MD5 1991 5 128 512<br />

SHA-1 1995 Schwächen 160 512<br />

SHA-256 2004 - 256 512<br />

SHA-512 2004 - 512 1024<br />

Es ist ebenfalls möglich, Blockchiffren als kryptografische<br />

Hashes einzusetzen.<br />

4 Knudsen, Mathiassen: Preimage and Collision Attacks on MD2, 2005<br />

5 Praktikumsaufgabe<br />

14 / 99


Angriffe gegen Hashfunktionen<br />

Kollisionen<br />

◮ Kollision: Für zwei Nachrichten m1 und m2 wird ein- und<br />

<strong>der</strong>selbe Hash erzeugt, also H(m1) = H(m2)<br />

◮ in <strong>der</strong> Softwaretechnik z. B. durch Überlauflisten<br />

behandelt, unkritisch<br />

◮ bei kryptografischen Hashes gefährlich; erste Stufe zum<br />

„Brechen“ des Hashverfahrens<br />

◮ Kollisionsfreiheit ist unmöglich (unendlich viele<br />

verschiedene Nachrichten werden auf 2 Hashlänge<br />

verschiedene Hashwerte abgebildet)<br />

◮ stattdessen: Kollisionsresistenz gefor<strong>der</strong>t<br />

15 / 99


Angriffe gegen Hashfunktionen<br />

Kollisionsresistenz<br />

Schwache Kollisionsresistenz<br />

◮ Zu einer Nachricht m und <strong>der</strong>en gegebenen Hashwert<br />

H(m) ist es praktisch unmöglich, eine zweite Nachricht m ′<br />

zu finden, die den gleichen Hashwert H(m ′ ) = H(m) hat.<br />

Starke Kollisionsresistenz<br />

◮ Es ist praktisch unmöglich, zwei Nachrichten m und m ′ zu<br />

finden, die den gleichen Hashwert H(m) = H(m ′ ) zu<br />

finden.<br />

16 / 99


Angriffe gegen Hashfunktionen<br />

Brute-Force-Angriff gegen schwache Kollisionsresistenz<br />

gegeben: Nachricht m mit Hashwert H(m)<br />

gesucht: Nachricht m ′ mit H(m ′ ) = H(m)<br />

1: START<br />

2: zufällige Generierung m ′<br />

3: Ermittlung H(m ′ )<br />

4: if H(m ′ ) = H(m) then<br />

5: STOP {Kollision gefunden}<br />

6: else<br />

7: GOTO 2<br />

8: end if<br />

◮ bei einer Hashlänge von n Bit ist die Wkt. einer Kollision<br />

bei je<strong>der</strong> Iteration 2 −n im Mittel 2 n Iterationen bis zur<br />

Kollision nötig<br />

17 / 99


Angriffe gegen Hashfunktionen<br />

Brute-Force-Angriff gegen schwache Kollisionsresistenz<br />

Start<br />

zufällige Auswahl m ′<br />

Berechnung H(m ′ )<br />

H(m ′ ) =<br />

H(m) ?<br />

Kollision gefunden<br />

Stop<br />

yes<br />

18 / 99


Angriffe gegen Hashfunktionen<br />

Geburtstagsangriff<br />

Geburtstagsparadoxon:<br />

Wie viele Personen müssen sich in einem Raum befinden,<br />

damit die Wahrscheinlichkeit, dass jemand mit mir am<br />

gleichen Tag Geburtstag hat (6. September) größer ist als<br />

50%?<br />

◮ 253<br />

Wieviele Personen müssen sich in einem Raum befinden,<br />

damit die Wkt., dass zwei von Ihnen am gleichen Tag<br />

Geburtstag haben, größer ist als 50%?<br />

◮ 23<br />

19 / 99


Angriffe gegen Hashfunktionen<br />

Geburtstagsangriff<br />

Geburtstagsparadoxon:<br />

Wie viele Personen müssen sich in einem Raum befinden,<br />

damit die Wahrscheinlichkeit, dass jemand mit mir am<br />

gleichen Tag Geburtstag hat (6. September) größer ist als<br />

50%?<br />

◮ 253<br />

Wieviele Personen müssen sich in einem Raum befinden,<br />

damit die Wkt., dass zwei von Ihnen am gleichen Tag<br />

Geburtstag haben, größer ist als 50%?<br />

◮ 23<br />

20 / 99


Angriffe gegen Hashfunktionen<br />

Geburtstagsangriff<br />

Geburtstagsparadoxon:<br />

Wie viele Personen müssen sich in einem Raum befinden,<br />

damit die Wahrscheinlichkeit, dass jemand mit mir am<br />

gleichen Tag Geburtstag hat (6. September) größer ist als<br />

50%?<br />

◮ 253<br />

Wieviele Personen müssen sich in einem Raum befinden,<br />

damit die Wkt., dass zwei von Ihnen am gleichen Tag<br />

Geburtstag haben, größer ist als 50%?<br />

◮ 23<br />

21 / 99


Geburtstagsparadoxon<br />

Beweisskizze<br />

◮ Wkt., dass man an einem bestimmten Tag im Jahr<br />

Geburtstag hat: 1<br />

365<br />

◮ Wkt., dass man an einem bestimmten Tag im Jahr nicht<br />

Geburtstag hat: 364<br />

365<br />

◮ Wkt., dass man an zwei bestimmten Tagen im Jahr nicht<br />

Geburtstag hat: 363<br />

365<br />

Voraussetzung: Geburtstage in <strong>der</strong> Gruppe sind unabhängig<br />

und gleichverteilt<br />

◮ Eine Gruppe von zwei Personen enthält mit<br />

Wahrscheinlichkeit 364<br />

365 keine zwei Personen mit dem<br />

gleichen Geburtstag, da die zweite Person genau an<br />

einem Tag keinen Geburtstag haben kann.<br />

22 / 99


Geburtstagsparadoxon<br />

Beweisskizze, Fortsetzung<br />

◮ Eine Gruppe von drei Personen enthält mit<br />

Wahrscheinlichkeit 364 363<br />

365 · 365 keine zwei Personen mit dem<br />

gleichen Geburtstag, da die dritte Person (und nur diese)<br />

an zwei Tagen keinen Geburtstag haben darf.<br />

◮ Eine Gruppe von n Personen enthält mit Wkt.<br />

364 363 366−n<br />

365 · 365 · · · · · 365 keine 2 Personen gleichen<br />

Geburtstags.<br />

◮ Eine Gruppe von n Personen enthält mit Wkt.<br />

pn = 1 − 364 363 366−n<br />

365 · 365 · · · · · 365 2 Personen gleichen<br />

Geburtstags.<br />

p23 ≈ 0, 5072<br />

In einer Gruppe von (mindestens) 23 Personen ist die<br />

Wahrscheinlichkeit, dass 2 Personen am gleichen Tag<br />

Geburtstag haben, größer als 50%.<br />

23 / 99


Angriffe gegen Hashfunktionen<br />

Zurück zum Planet...Geburtstagsangriff<br />

◮ Der Angreifer möchte zwei Nachrichten M und M ′ finden,<br />

so dass gilt: H(M) = H(M ′ ).<br />

◮ Er kann dann M dem Kommunikationspartner zeigen, den<br />

(gemeinsamen) Hash H(M) signieren lassen und dann M<br />

durch M ′ ersetzen<br />

Aus dem Geburtstagsparadoxon folgt:<br />

◮ Es ist sehr schwer, zu einer gegebenen Nachricht mit<br />

Hash einen zweiten Hash zu finden, <strong>der</strong> mit ihrem eigenen<br />

Hashwert kollidiert.<br />

◮ Es ist leichter, eine Kollision zu erzeugen, wenn beide<br />

Nachricht variabel sind!<br />

◮ Die Anzahl zu prüfen<strong>der</strong> Hashes reduziert sich um die<br />

Wurzel!<br />

24 / 99


Geburtstagsangriff<br />

Beispiel und Fazit<br />

◮ Gegeben sei eine kryptografisch sichere Hashfunktion.<br />

◮ (hypothetische) Hashlänge 64 Bit (k = 64)<br />

◮ Brute-Force-Angriff eines gegebenen Hashes erfor<strong>der</strong>t das<br />

Prüfen von 2 64 Hashwerten (≈ 1.892 · 10 19 )<br />

◮ Rechner, <strong>der</strong> in <strong>der</strong> Sekunde 1.000.000 Hashes generiert,<br />

benötigt dafür etwa 600.000 Jahre<br />

◮ Ein Geburtstagsangriff auf diese Hashfunktion erfor<strong>der</strong>t<br />

das Prüfen von 2 k/2 = 2 32 Hashes<br />

◮ Obiger Rechner benötigt dafür etwa 71 Minuten 6 !<br />

Fazit: Ist ein Geburtstagsangriff auf die Hashfunktion zu<br />

erwarten, so muss die Länge des generierten Hashes im<br />

Vergleich zum ausschließlich drohenden Brute-Force-Angriff<br />

verdoppelt werden.<br />

6 Ein analoger Angriff auf SHA-1 benötigt 2.79 Urknallperioden (á 13.75 Mrd. Jahre)<br />

25 / 99


Hashing en Detail: MD5<br />

Idee: Kompression<br />

Init<br />

◮ (mehrfache) Iteration einer sog. Kompressionsfunktion<br />

◮ Eingabe: Daten fester Länge<br />

◮ Resultat: Daten fester Länge (kürzer als Eingabe)<br />

◮ Beispiel: Kompression bei MD5: Eingabe H (128 Bit), B<br />

(512 Bit), Resultat 128 Bit<br />

Nachricht M<br />

512 512 ... 512<br />

Pad<br />

128<br />

H0<br />

128<br />

C C ... 128 128<br />

C C<br />

H1<br />

Abbildung: Merkle-Damgård-Verfahren<br />

128<br />

Hn = h(M)<br />

26 / 99


Merkle-Damgård-Schema<br />

1. M wird aufgefüllt (Padding) mit<br />

◮ 1 Bit mit Wert 1,<br />

◮ variable Anzahl 0-Bits,<br />

◮ 64 Bit, in denen die Länge von M (in Bits) kodiert ist,<br />

so dass die Länge <strong>der</strong> resultierenden Nachricht M ′ ein<br />

Vielfaches von 512 Bit beträgt<br />

Pad =<br />

1 0 0 ... 0 Länge (64 Bit)<br />

Abbildung: Padding im Merkle-Damgård-Verfahren<br />

2. M ′ wird in 512 Bit lange Blöcke B1, B2, . . . Bn aufgeteilt<br />

3. H0 = IV (Initial Value)<br />

4. Hi = C(Hi−1, Bi) ∀i = 1, . . . , n<br />

5. Hn = H(M), <strong>der</strong> gesuchte Hashwert von M.<br />

27 / 99


Merkle-Damgård-Schema<br />

Anmerkungen:<br />

◮ maximale Länge <strong>der</strong> Nachricht 2 64 Bit=2048 PiB<br />

(PebiByte)<br />

◮ lineare Komplexität des Verfahrens<br />

◮ die meisten kryptografischen Hashverfahren nutzen diese<br />

Technik (unterscheiden sich in C)<br />

Satz (Merkle/Damgård, 1989): Wenn die Kompressionsfunktion<br />

C keine Kollisionen verursacht, dann auch nicht das nach<br />

obigem Verfahren konstruierte Hashverfahren.<br />

28 / 99


„Message Digest“ MD5<br />

◮ Ronald Rivest, 1991<br />

◮ beschrieben im RFC 1321<br />

◮ nutzt das Merkle-Damgård-Schema<br />

◮ sehr populär (Zertifikate, Integritätsprüfungen, . . . )<br />

◮ Linux: Kommando md5sum<br />

◮ seit 2004 sind Kollisionen publiziert → unsicher<br />

Ablauf:<br />

◮ relativ komplexe Kompressionsfunktion<br />

◮ für jeden <strong>der</strong> Blöcke Bi werden 4 Iterationen („Runden“)<br />

ausgeführt<br />

◮ jede Runde besteht aus 16 Operationen<br />

29 / 99


Eine Operation in MD5<br />

modulare Addition +<br />

N<br />

j-ter <strong>Teil</strong>block von Bi<br />

(32 Bit)<br />

Konstante<br />

32 Bit<br />

Linksrotation<br />

A B C D<br />

+<br />

+<br />

«s<br />

+<br />

Hi, 128 Bit<br />

16mal<br />

A B C D<br />

30 / 99


Nichtlineare Funktionen N<br />

F(X, Y , Z ) = (X ∧ Y ) ∨ ((¬X) ∧ Z )<br />

G(X, Y , Z ) = (X ∧ Z ) ∨ (Y ∧ (¬Z ))<br />

H(X, Y , Z ) = X ⊕ Y ⊕ Z<br />

I(X, Y , Z ) = Y ⊕ (X ∨ (¬Z ))<br />

◮ in je<strong>der</strong> Runde wird eine an<strong>der</strong>e Funktion genutzt<br />

31 / 99


Message Authentication Code (MAC)<br />

◮ Einweg-Hashfunktion mit (zusätzlichem) geheimem<br />

Schlüssel<br />

◮ Hash hängt von Eingabedaten und Schlüssel ab<br />

◮ → Authentizitätsprüfung nur mit Schlüssel möglich<br />

◮ typisch mittels Blockchiffre implementiert<br />

HMAC muss hier noch eingefügt werden! (kommt später)<br />

32 / 99


Signaturen (Unterschriften)<br />

. . . dienen dem Beweis <strong>der</strong> Echtheit, <strong>der</strong> Urheberschaft o<strong>der</strong><br />

dem Einverständnis mit dem Inhalt eines Dokumentes.<br />

Eigenschaften:<br />

◮ authentisch - überzeugt den Empfänger, dass <strong>der</strong><br />

Unterzeichner willentlich unterschrieben hat<br />

◮ fälschungssicher - beweist, dass <strong>der</strong> Unterzeichner (und<br />

kein an<strong>der</strong>er) das Dokument unterzeichnete<br />

◮ nicht wie<strong>der</strong>verwendbar - kann in kein an<strong>der</strong>es Dokument<br />

„übertragen“ werden<br />

◮ Unterschriebenes Dokument kann nicht mehr verän<strong>der</strong>t<br />

werden.<br />

◮ nicht rücknehmbar - Unterzeichner kann Unterschrift nicht<br />

leugnen.<br />

33 / 99


Digitale Signaturen<br />

Verschlüsselung von Dokumenten weist viele dieser<br />

Anfor<strong>der</strong>ungen auf → Nutzung kryptografischer Techniken zur<br />

Signierung digitaler Dokumente<br />

Verschiedene Verfahren:<br />

◮ symmetrische Verschlüsselung und Vermittlung<br />

◮ mittels Public-Key-<strong>Kryptographie</strong><br />

◮ mittels Public-Key-<strong>Kryptographie</strong> und Einweg-Hashfunktion<br />

34 / 99


Signieren mit symmetrischen Kryptosystemen und<br />

Vermittler<br />

Voraussetzungen:<br />

◮ Vermittler (Trent), dem vertraut wird<br />

◮ Schlüssel KA für Komm. Alice ↔ Trent und KB für Bob ↔<br />

Trent<br />

Protokoll:<br />

1. Alice verschlüsselt M an Bob mit KA und schickt sie an<br />

Trent.<br />

2. Trent entschlüsselt M mittels KA.<br />

3. Trent verschlüsselt M zusammen mit einer Nachricht, dass<br />

M von Alice stammt, mit KB<br />

4. Trent sendet C = KB(M) an Bob.<br />

5. Bob entschlüsselt C mit KB. Er kann M lesen und ist<br />

sicher, dass diese von Alice stammt.<br />

35 / 99


Signieren mit Public-Key-<strong>Kryptographie</strong><br />

1. Alice verschlüsselt M mit ihrem privaten (!) Schlüssel DK A<br />

(unterzeichnet): C = DK A (M)<br />

2. Alice schickt Chiffrat C an Bob<br />

3. Bob entschlüsselt C mit Alice’ öffentlichen Schlüssel EK A ,<br />

was die Echtheit von M beweist<br />

Vorteil im Vergleich zum symmetrischen Verfahren:<br />

◮ kein Vermittler erfor<strong>der</strong>lich<br />

◮ auch nicht im Streitfall<br />

Probleme:<br />

◮ Sicherung <strong>der</strong> Authentizität des öffentlichen Schlüssels<br />

von Alice EK A<br />

◮ Zeitbedarf bei langen Dokumenten<br />

36 / 99


Signieren mit Public-Key-<strong>Kryptographie</strong> und<br />

Einweg-Hashfunktion<br />

Idee: Signierung eines Einweg-Hashes über das Dokument<br />

anstatt des Dokumentes selbst (→ effizient).<br />

Protokoll:<br />

1. Alice berechnet den Einweg-Hash W1 zum<br />

entsprechenden Dokument M: W1 = H(M).<br />

2. Alice verschlüsselt W1 mit ihrem privaten Schlüssel DK A :<br />

C = DK A (W1) = DK A (H(M)) (Signatur).<br />

3. Alice sendet C und M an Bob.<br />

4. Bob ermittelt den Einweg-Hash W2 zum empfangenen<br />

Dokument M.<br />

5. Bob entschlüsselt W1 = EK A (C) mit Alice’ öffentlichem<br />

Schlüssel<br />

6. Bob prüft, ob W1 = W2 gilt. Wenn ja, dann ist die<br />

Unterschrift von Alice unter M gültig.<br />

37 / 99


Vorteile des Signierens mit Public-Key-<strong>Kryptographie</strong><br />

und Einweg-Hashfunktion<br />

1. großer Geschwindigkeitsgewinn bei gleicher Sicherheit<br />

(Voraussetzung: sichere Hashfunktion)<br />

2. Unterschrift und Dokument können getrennt gespeichert<br />

werden.<br />

3. Möglichkeit, das Dokument selbst (noch) geheim zu<br />

halten; Offenlegung erst bei Prüfung <strong>der</strong> Unterschrift nötig<br />

→ urheberrechtliches Schützen<br />

38 / 99


Nutzung von Zeitstempeln<br />

◮ Wenn signiertes Dokument nur einmal genutzt werden darf<br />

(Scheck, Gutschein, . . . ) muss Mehrfachverwendung<br />

unterbunden werden<br />

◮ Lösung: Datum und Zeit <strong>der</strong> Unterschrift an Dokument<br />

anhängen, gemeinsam unterschreiben<br />

39 / 99


Nutzung von Zeitstempeln<br />

◮ Wenn signiertes Dokument nur einmal genutzt werden darf<br />

(Scheck, Gutschein, . . . ) muss Mehrfachverwendung<br />

unterbunden werden<br />

◮ Lösung: Datum und Zeit <strong>der</strong> Unterschrift an Dokument<br />

anhängen, gemeinsam unterschreiben<br />

40 / 99


Mehrfachsignatur<br />

Problem: Alice und Bob wollen beide ein- und dasselbe<br />

Dokument signieren (z. B. einen Vertrag)<br />

Möglichkeiten:<br />

a) Alice und Bob unterschreiben verschiedene Kopien des<br />

Dokuments (unhandlich)<br />

b) Erst unterzeichnet Alice, dann unterzeichnet Bob das von<br />

Alice unterzeichnete Dokument. (→ Signaturprüfung von<br />

Alice muss immer erst Signaturprüfung von Bob<br />

vorangehen - unelegant)<br />

c) Alice und Bob unterschreiben separat den Hashwert des<br />

Dokuments (→ Unterschriften einzeln prüfbar)<br />

41 / 99


Digitale Signaturen mit Verschlüsselung<br />

Kombination von Signierung und Verschlüsselung:<br />

1. Alice unterschreibt ihre Nachricht M mit ihrem privaten<br />

Schlüssel: SA(M) mit SA = DK A<br />

2. Alice verschlüsselt die unterzeichnete Nachricht mit Bobs<br />

öffentlichem Schlüssel: C = EK B (SA(M))<br />

3. Alice schickt C an Bob<br />

4. Bob entschlüsselt C mit seinem privaten Schlüssel<br />

DK B : DK B (EK B (SA(M)))<br />

5. Bob prüft die Gültigkeit mit Alice’ öffentlichen Schlüssel<br />

und erhält die Klartextnachricht:<br />

VA(DK B (EK B (SA(M)))) = M mit VA = EK A<br />

42 / 99


Anmerkungen<br />

Günstig, vor <strong>der</strong> Verschlüsselung zu signieren:<br />

◮ Unterschrift kann nicht durch einen Gegner entfernt<br />

werden.<br />

◮ Man sieht, was man unterschreibt!<br />

◮ Keine kryptanalytischen Angriffe möglich.<br />

Es können für Signierung und Verschlüsselung<br />

unterschiedliche Schlüsselpaare verwendet werden.<br />

43 / 99


Erneutes Senden als Empfangsbestätigung<br />

1. Alice unterschreibt M mit ihrem privaten Schlüssel,<br />

verschlüsselt anschließend mit Bobs öffentlichem<br />

Schlüssel und sendet das Chiffrat an Bob:<br />

C = EK B (SA(M))<br />

2. Bob entschlüsselt mit seinem privaten Schlüssel, überprüft<br />

Alice’ Signatur mit <strong>der</strong>en öffentlichen Schlüssel und stellt<br />

M damit wie<strong>der</strong> her: VA(DK B (EK B (SA(M)))) = M.<br />

3. Bob unterschreibt seinerseits M mit seinem privaten<br />

Schlüssel SB, chiffriert anschließend mit Alice’ öffentlichen<br />

Schlüssel und schickt die Nachricht als<br />

Empfangsbestätigung zurück: C2 = EK A (SB(M))<br />

4. Alice entschlüsselt mit Ihrem privaten Schlüssel und prüft<br />

wie<strong>der</strong>um Bobs Signatur mit seinem öffentlichen<br />

Schlüssel. Stimmt die entschlüsselte mit <strong>der</strong><br />

ursprünglichen Nachricht überein, weiß sie, dass Bob die<br />

Nachricht erhalten hat.<br />

44 / 99


Erneutes Senden als Empfangsbestätigung<br />

Rücksendeangriff<br />

Protokoll ist unsicher, wenn für Verschlüsselung und Signierung<br />

<strong>der</strong> gleiche Algorithmus eingesetzt wird (Vx = Ex, Sx = Dx)!<br />

1. Alice signiert und verschlüsselt (wie gehabt):<br />

C = EK B (DK A (M))<br />

2. Mallory zeichnet C auf, sendet sie (etwas später) an Bob<br />

und behauptet, C sei von ihm.<br />

3. Bob dechiffriert die Nachricht mit seinem Schlüssel und<br />

versucht anschließend, mit Mallorys öffentlichem Schlüssel<br />

die (von Alice stammende) Unterschrift zu prüfen.<br />

EK M (DK B (EK B (DK A (M)))) = EK M (DK A (M))<br />

45 / 99


Erneutes Senden als Empfangsbestätigung<br />

Rücksendeangriff und dessen Abwehr<br />

4. Obwohl die Unterschrift nicht verifiziert werden kann,<br />

schickt Bob (automatisiert?) gemäß dem Protokoll eine<br />

Empfangsbestätigung an Mallory<br />

5. Mallory muß nun:<br />

Lehre:<br />

EK M (DK B (EK M (DK A (M))))<br />

◮ mit seinem privaten Schlüssel entschlüsseln<br />

◮ mit Bobs öffentlichem Schlüssel entschlüsseln<br />

◮ erneut mit seinem privaten Schlüssel entschlüsseln<br />

◮ mit Alice’ öffentlichem Schlüssel entschlüsseln<br />

. . . und schon kann er M lesen!<br />

Verschiedene Schlüssel o<strong>der</strong> verschiedene Algorithmen für<br />

Signierung und Verschlüsselung einsetzen! Nicht automatisch<br />

bestätigen und signieren!<br />

46 / 99


Protokolle zum Schlüsselaustausch<br />

Überblick<br />

◮ Austausch mittels symmetrischer Kryptografie<br />

◮ Austausch mittels Public-Key-Krypografie<br />

◮ Beispiel: Diffie-Hellman-Protokoll<br />

47 / 99


Schlüsselaustausch mit symmetrischer Kryptografie<br />

Voraussetzungen: Vertrauenswürdige Instanz (Key Distribution<br />

Center - KDC, aka Trent), sowohl Alice als auch Bob besitzen<br />

Schlüssel zur Kommunikation mit Trent<br />

Protokoll:<br />

◮ Alice bittet Trent um Generierung eines Sitzungsschlüssels<br />

zur Kommunikation mit Bob<br />

◮ Trent generiert zufälligen Sitzungsschlüssel, generiert 2<br />

Kopien, verschlüsselt eine mit Alice’ und eine mit Bobs<br />

Schlüssel<br />

◮ Trent schickt beide (verschlüsselte) Kopien an Alice<br />

◮ Alice dechiffriert ihre Kopie des Sitzungsschlüssels<br />

◮ Alice schickt Bob dessen (verschlüsselte) Kopie<br />

◮ Bob dechiffriert seine Kopie des Sitzungsschlüssels<br />

◮ Alice und Bob kommunizieren mittels des<br />

Sitzungsschlüssels<br />

48 / 99


Schlüsselaustausch mittels Public-Key-Kryptografie<br />

. . . wie bereits unter „hybride Kryptosysteme“ diskutiert:<br />

1. Alice bezieht Bobs öffentlichen Schlüssel aus dem KDC<br />

2. Alice generiert einen zufälligen Sitzungsschlüssel und<br />

verschlüsselt diesen mit Bobs öffentlichem Schlüssel<br />

3. Alice sendet das Chiffrat an Bob<br />

4. Bob dechiffriert die empfangene Nachricht mit seinem<br />

privaten Schlüssel<br />

5. Beide kommunizieren mit Hilfe des Sitzungsschlüssels<br />

49 / 99


Man-in-the-Middle-Attack<br />

Ablauf<br />

1. Alice sendet Bob ihren öffentlichen Schlüssel<br />

2. Mallory fängt diesen Schlüssel ab und schickt stattdessen<br />

seinen eigenen öffentlichen Schlüssel an Bob<br />

3. Bob sendet seinen öffentlichen Schlüssel an Alice<br />

4. Mallory fängt auch diesen ab und schickt stattdessen<br />

seinen öffentlichen Schlüssel an Alice<br />

5. Sendet Alice eine mit Bobs 7 öffentlichem Schlüssel<br />

verschlüsselte Nachricht an Bob, fängt Mallory diese ab<br />

und<br />

◮ entschlüsselt sie mit seinem privaten Schlüssel,<br />

◮ liest sie,<br />

◮ chiffriert sie mit Bobs öffentlichem Schlüssel und<br />

◮ schickt sie weiter an Bob.<br />

◮ Analog geht Mallory in <strong>der</strong> Rückrichtung (Bob → Alice) vor<br />

◮ We<strong>der</strong> Alice noch Bob können diesen Angriff entdecken<br />

7 d. h. , Mallorys<br />

50 / 99


Das Interlock-Protokoll (Rivest/Shamir, 1984)<br />

. . . erschwert o<strong>der</strong> vereitelt den Man-in-the-Middle-Attack<br />

1. Alice sendet Bob ihren öffentlichen Schlüssel KA.<br />

2. Bob sendet Alice seinen öffentlichen Schlüssel KB.<br />

3. Alice chiffriert ihre Nachricht M1 mit KB und schickt die<br />

Hälfte <strong>der</strong> verschlüsselten Nachricht an Bob.<br />

4. Bob chiffriert seine Nachricht M2 mit KA und schickt die<br />

Hälfte <strong>der</strong> verschlüsselten Nachricht an Alice.<br />

5. Alice schickt die zweite Hälfte an Bob.<br />

6. Bob fügt beide Hälften zusammen und dechiffriert. Danach<br />

schickt er Alice seine zweite Hälfte.<br />

7. Alice setzt Bobs zweite Nachricht zusammen und<br />

dechriffriert.<br />

51 / 99


Analyse des Interlock-Protokolls<br />

◮ Mallory kann nicht dechiffrieren, weil er nur eine halbe<br />

Nachricht hat<br />

◮ er muss aber mit seinem privaten Schlüssel dechiffrieren,<br />

um anschließend mit Bobs öffentlichem Schlüssel zu<br />

chiffrieren<br />

◮ er muss eine an<strong>der</strong>e Nachricht erfinden, und die Hälfte<br />

davon an Bob schicken (und zurück an Alice)<br />

Wenn Alice und Bob ihre Nachrichten vorher absprechen 8 ,<br />

können sie mit dem Interlock-Protokoll die Authentizität ihrer<br />

jeweiligen öffentlichen Schlüssel prüfen und Mallory entlarven.<br />

8 Dafür ist aber ein sicherer Kanal notwendig.<br />

52 / 99


Schlüsselaustausch mit digitaler Signatur<br />

Idee:<br />

◮ Trent signiert die öffentlichen Schlüssel von Bob und Alice<br />

◮ Beim Schlüsselerhalt prüfen Alice und Bob Trents Signatur<br />

◮ → Mallory kann nicht mehr in <strong>der</strong>en jeweilige Rolle<br />

schlüpfen!<br />

53 / 99


Authentifizierung (o<strong>der</strong> Authentifikation)<br />

2 Rollen:<br />

◮ Partei, die Identität nachweisen will (Beweisen<strong>der</strong>,<br />

„Prover“)<br />

◮ Partei, die Identität prüfen will (Verifizieren<strong>der</strong>, „Verifier“)<br />

Unterscheidung von<br />

◮ einseitiger Authentifikation (z. B. gegenüber Rechner) und<br />

◮ gegenseitiger Authentifikation.<br />

Nutzung von<br />

◮ charakteristischen Eigenschaften<br />

◮ Besitz<br />

◮ Wissen<br />

54 / 99


Authentifizierung mittels Passwort<br />

naive Implementierung<br />

Alice<br />

Anmerkungen:<br />

{A, P}<br />

◮ Passwort muss erzeugt/vergeben werden<br />

◮ Identität A muss mit übermittelt werden<br />

P0<br />

gespeichertes<br />

Passwort<br />

P = P0 Zugang gewährt<br />

◮ Abspeicherung des Passwortes P0 im Klartext<br />

55 / 99


Authentifizierung mittels Passwort<br />

Nutzung einer kryptografischen Hashfunktion<br />

Alice<br />

Anmerkungen:<br />

{A, P}<br />

h(P0)<br />

gespeicherter<br />

Passworthash<br />

h(P) = h(P0) Zugang gewährt<br />

◮ Passwort nicht mehr im Klartext abgelegt → kann nicht<br />

gestohlen werden!<br />

◮ Problem: schlechte Passworte<br />

56 / 99


Mögliche Angriffe auf den Vorgang <strong>der</strong><br />

Authentifizierung<br />

◮ Ausspähen des Passwortes<br />

◮ Social Engineering<br />

◮ Erraten des Passwortes<br />

◮ Wörterbuchangriff<br />

◮ Brute Force<br />

57 / 99


Social Engineering<br />

„Hallo, ich bin <strong>der</strong> freundliche Mann vom<br />

Rechenzentrum. Ich möchte die Virensoftware auf<br />

Ihrem Rechner aktualisieren und benötige dazu Ihr<br />

Nutzerkennzeichen und Passwort.“<br />

Verwandte Themen:<br />

◮ „Dumpster Diving“ – Auswertung von Papierkörben,<br />

Abfallbehältern<br />

◮ „Tailgating“ – einer berechtigten Person in sensitive<br />

Bereiche folgen<br />

◮ „Shoul<strong>der</strong> Surfing“ – Ablesen/Abfilmen von Passworten bei<br />

<strong>der</strong> Eingabe<br />

Johnny Long: No Tech Hacking: A Guide to Social Engineering,<br />

Dumpster Diving and Shoul<strong>der</strong> Surfing. Syngress, 2008<br />

58 / 99


Erraten des Passwortes<br />

Ein legendärer Einbruch im Lawrence Berkeley National<br />

Laboratory, Kalifornien:<br />

LBL> telnet elxsi<br />

Elxsi at LBL<br />

login: root<br />

password: root<br />

incorrect passwort, try again<br />

login: guest<br />

password: guest<br />

incorrect passwort, try again<br />

login: uucp<br />

password: uucp<br />

WELCOME TO THE ELXSI COMPUTER AT LBL<br />

(Clifford Stoll: Kuckucksei. Fischer, 1991)<br />

◮ bei gut gewarteten Systemen heute nahezu aussichtslos<br />

59 / 99


Automatisiertes Erraten des Passwortes<br />

Linux-PC, Authentifizierungs-Logfile /var/log/auth.log, Ausschnitt<br />

Apr 5 14:44:35 idir sshd[14612]: Failed password for invalid user admin from 93.99.106.4 port 40799 ssh2<br />

Apr 5 14:44:39 idir sshd[14620]: Failed password for root from 93.99.106.4 port 42116 ssh2<br />

Apr 5 14:44:43 idir sshd[14630]: Failed password for root from 93.99.106.4 port 43885 ssh2<br />

Apr 5 14:44:44 idir sshd[14640]: Invalid user test from 93.99.106.4<br />

Apr 5 14:44:46 idir sshd[14640]: Failed password for invalid user test from 93.99.106.4 port 45676 ssh2<br />

Apr 5 14:44:47 idir sshd[14648]: Invalid user test from 93.99.106.4<br />

Apr 5 14:44:49 idir sshd[14648]: Failed password for invalid user test from 93.99.106.4 port 47395 ssh2<br />

Apr 5 14:44:51 idir sshd[14656]: Invalid user webmaster from 93.99.106.4<br />

Apr 5 14:44:53 idir sshd[14656]: Failed password for invalid user webmaster from 93.99.106.4 port 48814 ssh2<br />

Apr 5 14:44:54 idir sshd[14666]: Invalid user user from 93.99.106.4<br />

Apr 5 14:44:56 idir sshd[14666]: Failed password for invalid user user from 93.99.106.4 port 50581 ssh2<br />

Apr 5 14:44:58 idir sshd[14674]: Invalid user username from 93.99.106.4<br />

Apr 5 14:45:00 idir sshd[14674]: Failed password for invalid user username from 93.99.106.4 port 51972 ssh2<br />

Apr 5 14:45:01 idir sshd[14684]: Invalid user username from 93.99.106.4<br />

Apr 5 14:45:03 idir sshd[14684]: Failed password for invalid user username from 93.99.106.4 port 53530 ssh2<br />

Apr 5 14:45:05 idir sshd[14692]: Invalid user user from 93.99.106.4<br />

Apr 5 14:45:07 idir sshd[14692]: Failed password for invalid user user from 93.99.106.4 port 55065 ssh2<br />

Apr 5 14:45:10 idir sshd[14702]: Failed password for root from 93.99.106.4 port 56829 ssh2<br />

Apr 5 14:45:11 idir sshd[14710]: Invalid user admin from 93.99.106.4<br />

Apr 5 14:45:13 idir sshd[14710]: Failed password for invalid user admin from 93.99.106.4 port 60192 ssh2<br />

Apr 5 14:45:15 idir sshd[14718]: Invalid user test from 93.99.106.4<br />

Apr 5 14:45:17 idir sshd[14718]: Failed password for invalid user test from 93.99.106.4 port 33440 ssh2<br />

Apr 5 14:45:21 idir sshd[14728]: Failed password for root from 93.99.106.4 port 35208 ssh2<br />

Apr 5 14:45:24 idir sshd[14736]: Failed password for root from 93.99.106.4 port 36679 ssh2<br />

Apr 5 14:45:27 idir sshd[14746]: Failed password for root from 93.99.106.4 port 38334 ssh2<br />

Apr 5 14:45:31 idir sshd[14754]: Failed password for root from 93.99.106.4 port 39667 ssh2<br />

Apr 5 14:45:32 idir sshd[14762]: Invalid user danny from 93.99.106.4<br />

Apr 5 14:45:34 idir sshd[14762]: Failed password for invalid user danny from 93.99.106.4 port 41516 ssh2<br />

Apr 5 14:45:35 idir sshd[14770]: Invalid user sharon from 93.99.106.4<br />

Apr 5 14:45:37 idir sshd[14770]: Failed password for invalid user sharon from 93.99.106.4 port 42957 ssh2<br />

Apr 5 14:45:39 idir sshd[14780]: Invalid user aron from 93.99.106.4<br />

60 / 99


Wörterbuchangriff (Dictionary Attack)<br />

Idee:<br />

◮ Offline-Generierung einer Liste aus Einträgen mit<br />

◮ potentielles Passwort<br />

◮ potentielles Passwort, verschlüsselt<br />

◮ alle möglichen Worte, Namen, Bezeichner usw. mittels <strong>der</strong><br />

Einwegfunktion des Betriebssystems verschlüsseln<br />

◮ Diebstahl <strong>der</strong> Passwortdatei<br />

◮ Vergleich <strong>der</strong> verschlüsselten Wortliste mit den Hashes<br />

aus <strong>der</strong> Passwortdatei<br />

◮ Bei Übereinstimmung ist das unverschlüsselte Passwort<br />

<strong>der</strong> entsprechende Eintrag aus <strong>der</strong> Wortliste<br />

→ Werkzeug john (Praktikum)<br />

61 / 99


Erschwerung des Wörterbuchangriffes mittels Salz<br />

◮ Passwort wird vor Verschlüsselung mit einer Zufallszahl<br />

konkateniert (dem Salz)<br />

◮ Salz wird mit in <strong>der</strong> (geheimen) Passwortdatei gespeichert<br />

◮ bei genügend großer Anzahl möglicher Hash-Werte wird<br />

ein Wörterbuchangriff unmöglich<br />

◮ Mallory müßte zu jedem Wort alle möglichen Salz-Werte<br />

durchprobieren<br />

62 / 99


Weitere Gegenmaßnahmen gegen Wörterbuchangriff<br />

◮ möglichst keine Hinweise auf Länge des PW (’*’ u. ä.) in<br />

<strong>der</strong> Eingabemaske<br />

◮ möglichst kein Hinweis, ob NKZ gültig<br />

◮ Verzögerung nach jedem erfolglosen Anmeldeversuch<br />

◮ periodisches Erneuern <strong>der</strong> Passworte:<br />

+ gecrackte PW werden automatisch ausgetauscht<br />

− Nutzer müssen periodisch neue PW lernen<br />

63 / 99


Anfor<strong>der</strong>ungen an gute Passworte<br />

◮ möglichst lang<br />

◮ gesamten Zeichenvorrat nutzen (sonst resultiert eine<br />

signifikante Verkleinerung des Schlüsselraums →<br />

Brute-Force-Angriff vereinfacht)<br />

◮ keine Namen, Worte (auch nicht rückwärts)<br />

◮ regelmäßig wechseln<br />

◮ computergenerierte Passworte: geringe Akzeptanz<br />

(werden aufgeschrieben) → Standard FIPS PUB 181<br />

(http://www.itl.nist.gov/fipspubs/fip181.htm)<br />

◮ proaktive PW-Checker prüfen gewähltes PW auf<br />

Mindestanfor<strong>der</strong>ungen<br />

64 / 99


Dauer von Brute-Force-Angriffen<br />

in Abhängigkeit vom Schlüsselraum<br />

4 Byte 5 Byte 6 Byte 7 Byte 8 Byte<br />

Kleinbuchstaben (26) 0.5 s 12 s 5 min 2.2 h 2.4 d<br />

Kleinbuchst.+Ziffern (36) 1.7 s 1 min 36 min 22 h 33 d<br />

alphanum. Zeichen (62) 15 s 15 min 16 h 41 d 6.9 a<br />

druckbare Zeichen (95) 1.4 min 2.1 h 8.5 d 2.2 a 210 a<br />

ASCII-Zeichen (128) 4.5 min 9.5 h 51 d 18 a 2300 a<br />

8-Bit-Zeichen (256) 1.2 h 13 d 8.9 a 2300 a 580.000 a<br />

Tabelle: vgl. Bruce Schneier: Angewandte <strong>Kryptographie</strong>, Pearson,<br />

2006, S.201<br />

◮ zugrundegelegt wurde eine Geschwindigkeit von<br />

1.000.000 Schlüsselberechnungen pro Sekunde<br />

65 / 99


Welche Knackgeschwindigkeit ist realistisch?<br />

Stefan Arbeiter, Matthias Deeg: Bunte Rechenknechte. In: c’t 06/2009, S. 204ff<br />

◮ abhängig vom gewählten Verschlüsselungsverfahren<br />

◮ System 1 - 4 Prozessoren á 6 Cores (Intel Dunnington) @<br />

2.5 GHz (HP-PC, ca. 18.000 US-$)<br />

◮ ermittelt ca. 1.2 Milliarden NTLM-Hashes pro Sekunde<br />

◮ System 2 - Intel Core 2 Quad, Nvidia GeForce GTX 280<br />

(„Gamer-PC“, ca. 800 EUR)<br />

◮ CPU ca. 200 Millionen Hashes/s<br />

◮ GPU ca. 720 Millionen Hashes/s (CUDA 9 nutzen<strong>der</strong><br />

◮<br />

Passwortknacker)<br />

<br />

0.9 Milliarden NTLM-Hashes pro Sekunde<br />

9 Compute Unified Device Architecture, eine API zur Nutzung <strong>der</strong> Sha<strong>der</strong>-Prozessoren aktueller Grafikkarten für<br />

wissenschaftliche Berechnungen<br />

66 / 99


Professionelle Knack-Hardware<br />

a) „Deep Crack“<br />

◮ 1998, 250.000 US-$, EFF 10<br />

◮ 1536 Kryptoprozessoren<br />

◮ 88 Milliarden DES-Schlüssel pro Sekunde<br />

b) COPACOBANA<br />

◮ 2006, 10.000 US-$, Unis Bochum und Kiel<br />

◮ 120 XILINX Spartan3-1000 FPGA<br />

◮ 65 Milliarden DES-Schlüssel pro Sekunde<br />

c) distributed.net<br />

◮ verteiltes Rechnen; Nutzbarmachung von idle-Time auf<br />

Internet-Hosts<br />

d) es ist davon auszugehen, dass Geheimdiensten weit<br />

teurere Systeme zur Verfügung stehen<br />

10 Electronic Frontier Foundation, eine Nichtregierungsorganisation <strong>der</strong> Vereinigten Staaten<br />

67 / 99


Exkurs: “Forgot your Password?”<br />

◮ viele (webbasierte) Dienste erfor<strong>der</strong>n Authentifizierung<br />

(Webmail, . . . )<br />

◮ im Falle eines verlorenen Passwortes wird eine<br />

‘persönliche’ Frage vereinbart, <strong>der</strong>en korrekte<br />

Beantwortung das Passwort zurücksetzt o<strong>der</strong> dem<br />

Eigentümer per Mail zustellt<br />

◮ Beispiele:<br />

◮ “What is your mother’s maiden name?”<br />

◮ “What is your dog’s name?”<br />

◮ Diese Informationen sind insbeson<strong>der</strong>e bei Prominenten<br />

bzw. Netizens leicht recherchierbar!<br />

Literatur: Herbert H. Thompson: How I Stole Someone’s<br />

Identity. Scientific American, August, 2008<br />

http://www.sciam.com/article.cfm?id=anatomy-of-a-social-hack<br />

68 / 99


Exkurs: “Forgot your Password?”<br />

Beispiel: Sarah Palin<br />

◮ Yahoo-Account von Vizepräsidentschaftskandidatin Sarah<br />

Palin<br />

◮ Passwort wurde durch Unbekannte zurückgesetzt<br />

(09/2008)<br />

◮ ‘Sicherheits’fragen:<br />

◮ ZIP code<br />

◮ date of birth<br />

◮ “Where did you meet your husband?” → auf <strong>der</strong> Webseite<br />

steht, dass sie ihren Mann seit Highschool-Zeiten kennt<br />

und welche Highschool sie besuchte<br />

◮ Recherche dauerte ca. 45 Minuten<br />

Quelle: http://www.itworld.com/security/55185/sarah-palingoes-way-paris-hilton<br />

69 / 99


Rätsel<br />

Welche <strong>der</strong> folgenden Fragen taugen nicht für das Rücksetzen<br />

eines Passwortes? Können sie die folgenden Fragen für eine<br />

fremde Person (z. B. mich) mit wenig Aufwand recherchieren?<br />

Welche Ansätze für Recherchen gibt es?<br />

1. What is my mother’s maiden name?<br />

2. What was the brand of my first car?<br />

3. What is the name of my best friend?<br />

4. In which city did I grow up?<br />

5. What was the lastname of my kin<strong>der</strong>garden teacher?<br />

6. What is my favourite movie?<br />

7. What is my dog’s name?<br />

70 / 99


Challenge-Response-Verfahren<br />

o<strong>der</strong>: „Wer über die Brücke des Todes will gehen, <strong>der</strong> muß drei mal Rede und Antwort stehen. Dann darf er die an<strong>der</strong>e Seite<br />

sehen.“<br />

= Authentifizierung auf <strong>der</strong> Basis gemeinsamen Wissens<br />

1. Server stellt eine Aufgabe (Challenge))<br />

2. Nutzer (bzw. ein Stellvertreterprozeß) löst die Aufgabe<br />

(antwortet; Response)<br />

3. Lösung korrekt → Login erlaubt<br />

Beispiel: Kopierschutz in alten Computerspielen.<br />

◮ Zu Beginn Frage, etwa: “Was steht im Handbuch auf<br />

S.412, dritte Zeile, 2. Wort?”<br />

◮ richtiger Begriff → Spiel startet<br />

◮ falscher Begriff → Abbruch<br />

71 / 99


Challenge-Response zur Authentifizierung<br />

Ablauf:<br />

1. Alice schickt Bob (dem Host) ihr Nutzerkennzeichen<br />

2. Bob sendet eine Zufallszahl („Nonce“ - (random) number,<br />

used once) an Alice ≡ Challenge<br />

3. Alice verschlüsselt die Nonce mit ihrem Passwort und<br />

schickt das Chiffrat an Bob ≡ Response<br />

4. Bob verschlüsselt die Nonce ebenfalls mit Alice’ Passwort<br />

(d. h., Bob muss Alice’ Passwort kennen)<br />

5. ist das Chiffrat gleich <strong>der</strong> Antwort von Alice, so wird<br />

Zugang gewährt<br />

72 / 99


Beispiel: Authentifizierung in Windows<br />

◮ Authentifizierungsprotokoll NTLM - NT Lan Manager<br />

◮ zum großen <strong>Teil</strong> reverse-engineered<br />

◮ liegt mittlerweile offen<br />

Grobablauf:<br />

1. Client (Nutzer) schickt eine sog. Type-1-Nachricht an den<br />

Server, die verschiedene Parameter <strong>der</strong> Authentifizierung<br />

festlegt<br />

2. Server (Host) antworter mit einer Type-2-Nachricht, die<br />

u. a. eine 8 Byte lange Nonce enthält<br />

3. Client verschlüsselt die Nonce mit seinem Passwort als<br />

Schlüssel, schickt Chiffrat als Type-3-Nachricht an Server<br />

◮ konkretes Verfahren hängt von den zuvor ausgehandelten<br />

Parametern ab<br />

◮ es wird MD4, MD5 und DES eingesetzt<br />

Literatur: http://davenport.sourceforge.net/ntlm.html<br />

73 / 99


Sicherheit von NTLM<br />

Stellen Zeichenraum Dauer<br />

6 A-Za-z0-9 1 min<br />

6 A-Za-z0-9, 22 SZ 6 min<br />

8 A-Za-z0-9 2 d, 17 h<br />

8 A-Za-z0-9, 22 SZ 33 d<br />

8 A-Za-z0-9, alle SZ 82 d<br />

11 A-Za-z 270 a<br />

Tabelle: Maximale Dauer <strong>der</strong> Ermittlung von NTLM-Passworten<br />

mittels „Distributed Password Recovery“ (ElcomSoft)<br />

◮ 22 SZ = typische Son<strong>der</strong>zeichen, d.h.<br />

_@#$&+-=%*"~!?.,:;()<br />

◮ genutztes System: AMD Athlon X2 4850e, 2 Nvidia<br />

GeForce 9800 GTX<br />

Quelle: Stefan Arbeiter, Matthias Deeg: Bunte Rechenknechte.<br />

In: c’t 06/2009, S. 205<br />

74 / 99


Authentifizierung mit physischen Objekten<br />

◮ Schlüssel<br />

◮ Chipkarten<br />

◮ passiv – “Stored Value Cards”, z.B. Telefonkarten<br />

◮ aktiv – “Smart Cards”, ausgerüstet mit 8-Bit-CPU, Scratch<br />

RAM, ROM, EEPROM<br />

Smart<br />

Card<br />

2. Smart Card errechnet Antwort<br />

PC<br />

1. Challenge an Smart Card<br />

3. Response an Server<br />

Server<br />

Abbildung: Nutzung einer Smartcard zur Authentifizierung<br />

75 / 99


Smartcards<br />

◮ Smartcards können aktualisiert werden, z.B. bei Bruch des<br />

verwendeten Kryptografie-Verfahrens<br />

◮ Problem: Verlust, Diebstahl<br />

◮ Power Analysis Attack, um Key zu ermitteln<br />

76 / 99


Authentifizierung mittels biometrischer Merkmale<br />

Idee: Erkennung/Authentikation einer Person anhand<br />

individueller physischer Merkmale.<br />

◮ Gesichtsmerkmale (z. B. bei direkter<br />

Mensch-Mensch-Authentikation)<br />

◮ Fingerabdrücke (wahrscheinlich einzigartig innerhalb <strong>der</strong><br />

gesamten Bevölkerung)<br />

◮ Geometrie <strong>der</strong> Hand (Form, Länge, Dicke <strong>der</strong> Finger)<br />

◮ Blutgefäße <strong>der</strong> Retina (ebenfalls einzigartig)<br />

◮ Unterschrift<br />

◮ Sprache<br />

Probleme: False-Match, False-Nonmatch<br />

77 / 99


Authentifizierung mit Public-Key-Kryptografie<br />

Hauptnachteil bei Passwortauthentifizierung: Passwort wird<br />

u. U. unverschlüsselt übertragen (telnet, ftp, rlogin) →<br />

kann durch Eve abgehört werden.<br />

Alternative: Public-Key-Kryptografie<br />

1. Host sendet Alice einen Zufallsstring Z<br />

2. Alice chiffriert Z mit ihrem privaten Schlüssel und schickt<br />

das Chiffrat mit ihrem Namen an den Host<br />

3. Host ruft Alice’ öffentlichen Schlüssel aus seiner<br />

Datenbank und dechiffriert Nachricht<br />

4. Stimmt Dechiffrat mit ursprünglichen String Z überein, so<br />

erhält Alice Zugang zum System<br />

78 / 99


Schlüsselaustausch mittels Diffie-Hellman-Protokoll<br />

1. Bob und Alice einigen sich auf eine große Primzahl n und<br />

eine Zahl g.<br />

2. Alice wählt eine (große) zufällige Zahl x (Alice’ geheimer<br />

Schlüssel) und berechnet X = g x mod n (Alice’ öffentlicher<br />

Schlüssel).<br />

3. Alice sendet X an Bob.<br />

4. Bob wählt eine (große) zufällige Zahl y (Bobs geheimer<br />

Schlüssel) und berechnet Y = g y mod n (Bobs öffentlicher<br />

Schlüssel).<br />

5. Bob sendet Y an Alice.<br />

6. Alice berechnet<br />

k = Y x mod n = (g y mod n) x mod n = g xy mod n, den<br />

geheimen Sitzungsschlüssel.<br />

7. Bob berechnet<br />

k = X y mod n = (g x mod n) y mod n = g xy mod n.<br />

79 / 99


Anmerkungen zum Diffie-Hellman-Protokoll<br />

◮ g muss primitiv modulo n sein, d.h. es muss stets ein a<br />

geben, so dass g a ≡ b mod n ∀ 1 ≤ b < n.<br />

◮ Eve kann X und Y abfangen, es nützt ihr aber nichts, sie<br />

kann g xy mod n nicht aus g x mod n und g y mod n<br />

berechnen.<br />

Beispiel:<br />

Alice Bob<br />

g = 4, n = 11<br />

x = 3 y = 4<br />

X = 4 3 mod 11 = 9 Y = 4 4 mod 11 = 3<br />

X = 9 → B A ← Y = 3<br />

k = Y x mod n k = X y mod n<br />

= 3 3 mod 11 = 5 = 9 4 mod 11 = 5<br />

80 / 99


Authentifizierung und Schlüsselaustausch<br />

Überblick<br />

Ziel: Alice und Bob wollen sich gegenseitig authentifizieren und<br />

sicher miteinan<strong>der</strong> kommunizieren (→ Schlüsselaustausch)<br />

◮ Wide-Mouthed-Frog (Breitmaulfrosch)<br />

◮ Needham-Schroe<strong>der</strong>-Protokoll<br />

◮ Kerberos<br />

81 / 99


Wide-Mouthed-Frog<br />

◮ Voraussetzung: Alice und Bob benötigen geheimen<br />

Schlüssel zur Kommunikation mit Trent<br />

1. Alice konkateniert einen Zeitstempel TA, Bobs Namen und<br />

einen zufälligen Sitzungsschlüssel KAB und chiffriert alles<br />

mit dem Schlüssel KAT für Trent-Alice. Sie sendet ihren<br />

Namen und das Chiffrat an Trent:<br />

A, KAT (TA, B, KAB) → Trent<br />

2. Trent dechiffriert die Nachricht. Dann konkateniert er einen<br />

weiteren Zeitstempel TB, Alice’ Namen und den<br />

Sitzungsschlüssel KAB. Alles wird mit dem Schlüssel KBT<br />

für Trent-Bob chiffriert und an Bob geschickt:<br />

KBT (TB, A, KAB) → Bob<br />

82 / 99


Wide-Mouthed-Frog<br />

Anmerkungen<br />

◮ symmetrisches Verfahren<br />

◮ sehr simpel; nur zwei Nachrichten sind notwendig<br />

◮ Alice muss in <strong>der</strong> Lage sein, einen sehr guten<br />

Sitzungsschlüssel zu generieren (Zufallszahlen sind<br />

schwierig zu generieren!) – Bob vertraut Alice<br />

dahingehend<br />

◮ Zeitstempel verhin<strong>der</strong>n (bzw. erschweren) Replay-Attacke<br />

◮ erfor<strong>der</strong>t eng synchronisierte Uhren<br />

◮ zustandbehaftetes Protokoll: Was tut Trent, wenn Bob nicht<br />

antwortet?<br />

◮ Michael Burrows et al: A Logic of Authentication. DEC<br />

Systems Research Center, Report No. 39, 1989<br />

83 / 99


Needham-Schroe<strong>der</strong>-Protokoll (Achtung, kompliziert!)<br />

Voraussetzungen:<br />

◮ symmetrisch, Trent benötigt<br />

◮ Alice und Bob verfügen über geheime Schlüssel KAT<br />

bzw. KBT , um mit Trent zu kommunizieren.<br />

Ablauf:<br />

1. Alice generiert eine Zufallszahl RA und schickt diese mit<br />

ihrem und Bobs Namen an Trent:<br />

(A, B, RA) → Trent<br />

2. Trent generiert einen zufälligen Sitzungsschlüssel KAB für<br />

Alice und Bob.<br />

3. Trent chiffriert mit KBT eine Nachricht (für Bob), die KAB<br />

und Alice’ Namen enthält.<br />

KBT (KAB, A)<br />

84 / 99


Needham-Schroe<strong>der</strong>-Protokoll<br />

<strong>Teil</strong> 2<br />

4. Trent chiffriert RA, Bobs Namen, KAB und das eben<br />

generierte Chiffrat mit KAT und schickt dieses an Alice.<br />

KAT (RA, B, KAB, KBT (KAB, A)) → Alice<br />

5. Alice entschlüsselt die Nachricht, extrahiert KAB und prüft,<br />

ob RA <strong>der</strong> in Schritt 1 generierten Zufallszahl entspricht.<br />

6. Falls ja, so schickt sie die für Bob bestimmte Subnachricht<br />

an diesen<br />

KBT (KAB, A) → Bob<br />

7. Bob dechiffriert die Nachricht und extrahiert KAB. Dann<br />

generiert er eine zweite Zufallszahl RB, chiffriert diese mit<br />

KAB und schickt die Nachricht an Alice.<br />

KAB(RB) → Alice<br />

85 / 99


Needham-Schroe<strong>der</strong>-Protokoll<br />

<strong>Teil</strong> 3<br />

8. Alice dechriffriert die Nachricht mittels KAB. Sie generiert<br />

RB − 1, chiffriert diese Zahl mit KAB und sendet das<br />

Chiffrat an Bob:<br />

KAB(RB − 1) → Bob<br />

9. Bob dechiffriert diese Nachricht und prüft, dass RB − 1<br />

gesendet wurde.<br />

86 / 99


Needham-Schroe<strong>der</strong>-Protokoll<br />

Diskussion<br />

◮ Zufallszahlen (Nonces) RA, RB dienen <strong>der</strong> Verhin<strong>der</strong>ung<br />

von Replay-Angriffen: Mallory zeichnet Nachrichten auf<br />

und versucht damit (später) die Integrität des<br />

Datenverkehrs zu unterwan<strong>der</strong>n<br />

◮ Hier: Mallory könnte durch Aufzeichnung und Replay <strong>der</strong><br />

Nachrichten 4 und 6 die Kommunikationspartner zwingen,<br />

einen alten (kompromittierten) Schlüssel KAB<br />

weiterzuverwenden<br />

Resultat des Algorithmus<br />

◮ Generierung eines geeigneten Schlüssels durch Trent<br />

◮ Verteilung des Schlüssels zwischen Alice und Bob<br />

◮ Alice authentifiziert sich gegenüber Bob durch Nachricht 8<br />

87 / 99


Needham-Schroe<strong>der</strong>-Protokoll<br />

Schwäche: kompromittierter Schlüssel erlaubt Replay-Attacke<br />

◮ kein „Verfall“ alter Schlüssel (Managementproblem!)<br />

◮ Bob hat keine Möglichkeit zu testen, ob <strong>der</strong> Schlüssel KAB<br />

frisch generiert wurde<br />

◮ wenn Mallory in den Besitz irgendeines alten Schlüssels<br />

KAB kommt, kann er Nachricht 6 aufzeichnen und später<br />

wie<strong>der</strong> Bob vorspielen (Replay-Attacke)<br />

◮ Bob generiert die Nonce, verschlüsselt sie mit dem<br />

kompromittierten Key und schickt sie an Alice<br />

◮ Mallory fängt die Nachricht ab und kann sich fortan als<br />

Alice ausgeben.<br />

→ Needham-Schroe<strong>der</strong>-Protokoll nur noch von historischem<br />

Interesse<br />

88 / 99


Kerberos<br />

Überblick<br />

◮ Protokoll zur Authentifizierung in TCP/IP-basierten Netzen<br />

◮ Ziel: Einrichtung sicherer Kommunikationskanäle zwischen<br />

einem Client und beliebigen Servern in einem verteilten<br />

System<br />

◮ Weiterentwicklung des Needham-Schroe<strong>der</strong>-Protokolls<br />

◮ basierend auf symmetrischer Verschlüsselung<br />

◮ erfor<strong>der</strong>t vertrauenswürdige Instanz (Trent)<br />

◮ je<strong>der</strong> <strong>Teil</strong>nehmer besitzt geheimen Schlüssel zur<br />

Kommunikation mit Trent<br />

◮ Identitätsbeweis = Kenntnis des Schlüssels<br />

◮ Versionen 4 und 5 (RFC 4120)<br />

89 / 99


Wer ist Kerberos eigentlich?<br />

◮ auch Cerberus<br />

◮ ein-, drei- o<strong>der</strong> fünfzigköpfiger Hund, <strong>der</strong> den Hades, die<br />

Unterwelt in <strong>der</strong> griechischen Mythologie, bewacht<br />

„Auch den Kerberos sah ich, mit bissigen Zähnen bewaffnet<br />

Böse rollt er die Augen, den Schlund des Hades bewachend.<br />

Wagt es einer <strong>der</strong> Toten an ihm vorbei sich zu schleichen,<br />

So schlägt er die Zähne tief und schmerzhaft ins Fleisch <strong>der</strong> Entfliehenden<br />

Und schleppt sie zurück unter Qualen,<br />

Der böse, <strong>der</strong> bissige Wächter.“<br />

(Odyssee)<br />

90 / 99


Initiative: Mehr Bil<strong>der</strong> in <strong>der</strong> Vorlesung ...<br />

Abbildung: Kerberos, gezeichnet von Pearson Scott Foresman<br />

(Quelle: http://commons.wikimedia.org/wiki/File:Cerberus_(PSF).png)<br />

91 / 99


Von Needham-Schroe<strong>der</strong> zu Kerberos<br />

Basisprotokoll<br />

Idee: Aufnahme eines Zeitstempels, um Replay-Attacken<br />

effektiver zu bekämpfen.<br />

Ablauf:<br />

1. Alice sendet an Trent eine Nachricht mit ihrer und Bobs<br />

Identität:<br />

(A, B) → Trent<br />

2. Trent generiert einen Sitzungsschlüssel KAB.<br />

3. Trent generiert eine Nachricht mit Zeitstempel T ,<br />

Geltungsdauer L, KAB und Alice’ Identität und chiffriert<br />

diese mit Bobs Schlüssel KBT .<br />

KBT (T , L, KAB, A)<br />

92 / 99


Kerberos<br />

Basisprotokoll, contd.<br />

4. Trent generiert eine analoge Nachricht, jedoch mit Bobs<br />

Identität, die er mit Alice’ Schlüssel KAT chiffriert.<br />

KAT (T , L, KAB, B)<br />

5. Trent schickt beide Nachrichten an Alice.<br />

KBT (T , L, KAB, A), KAT (T , L, KAB, B) → Alice<br />

6. Alice generiert eine Nachricht mit ihrer Identität und dem<br />

Zeitstempel und verschlüsselt diese mit KAB.<br />

KAB(T , A)<br />

7. Alice schickt diese und Trents Nachricht an Bob.<br />

KAB(T , A), KBT (T , L, KAB, A) → Bob<br />

93 / 99


Kerberos<br />

Basisprotokoll, contd.<br />

8. Bob generiert eine Nachricht mit dem Zeitstempel + 1,<br />

chiffriert diese mit KAB und schickt sie an Alice.<br />

KAB(T + 1) → Alice<br />

Voraussetzung: Alice, Bob und Trent haben ausfallsichere<br />

synchronisierte Uhren!<br />

94 / 99


Tickets und Authentikatoren<br />

Kerberos unterscheidet zwei Formen <strong>der</strong> Legitimation:<br />

Ticket<br />

◮ durch Kerberos erzeugt<br />

◮ zur sicheren Übertragung <strong>der</strong> Identität eines<br />

dienstanfor<strong>der</strong>nden Clients c an einen Server s<br />

◮ mit geheimem Schlüssel Ks des Servers verschlüsselt<br />

◮ besitzt Geltungsdauer, innerhalb <strong>der</strong>er <strong>der</strong> Client Anfragen<br />

an den Server stellen kann<br />

Authentikator<br />

◮ zusätzliche Legitimation<br />

◮ durch Client erzeugt<br />

◮ wird dem Server gemeinsam mit Ticket präsentiert<br />

95 / 99


Struktur eines Tickets<br />

mit<br />

Tc,s = s, {c, a, v, Kc,s} Ks<br />

Symbol Bedeutung<br />

s Server<br />

c Client<br />

a IP-Adresse des Clients<br />

v Geltungsdauer des Tickets<br />

Kx,y<br />

Kx<br />

Sitzungsschlüssel für x und y<br />

geheimer Schlüssel von x<br />

{m}Kx Nachricht m, mit Kx verschlüsselt<br />

96 / 99


Struktur eines Authentikators<br />

mit<br />

Ac,s = {c, t, Schlüssel} Kc,s<br />

Symbol Bedeutung<br />

c Client<br />

t Zeitstempel<br />

Kx,y<br />

Sitzungsschlüssel für x und y<br />

Schlüssel weiterer (optionaler )Sitzungsschlüssel<br />

97 / 99


Kerberos<br />

Überblick Authentifizierungsschritte<br />

Authentication Server Ticket Granting Server<br />

Kerberos<br />

1: Anfor<strong>der</strong>ung TGT<br />

3: Anfor<strong>der</strong>ung<br />

Serverticket<br />

2: TGT<br />

Client<br />

TGS<br />

4: Serverticket<br />

5: Dienstanfor<strong>der</strong>ung<br />

Server<br />

98 / 99


Was haben wir gelernt?<br />

1. Kryptografische Hashes<br />

2. Signaturen<br />

3. Schlüsselaustauschprotokolle<br />

4. Authentifizierung<br />

5. Schlüsselaustausch und Authentifizierung<br />

6. einige Formen von Angriffen<br />

◮ Brute Force<br />

◮ Replay-Attacke<br />

◮ Man-in-the-Middle-Attack<br />

◮ Social Engineering<br />

◮ Wörterbuchangriff<br />

7. Authentifizierung und Schlüsselaustausch<br />

99 / 99

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!