Teil 1

Kryptographie 

Kriterien zur Einteilung von Kryptosystemen 

– Anwendungsfall: 

• Konzelation 

• Authentikation 

• Hashfunktionen 

• Pseudozufallszahlengeneratoren 

– Schlüsselbeziehung Sender–Empfänger 

• Symmetrische Systeme 

• Asymmetrische Systeme 

– Alphabet, auf dem die Chiffre operiert 

• Blockchiffre: Operiert auf Blöcken von Zeichen 

• Stromchiffren: Operiert auf einzelnen Zeichen 

– Längentreue 

– Sicherheit 

• (informations) theoretisch sicher 

• kryptographisch stark (beweisbar) 

– gegen aktive Angriffe 

– gegen passive Angriffe 

• wohluntersucht 

– Mathematik 

– Chaos 

• geheimgehaltene

Angriffsarten und Sicherheitskriterien 

Was kennt der Angreifer, was kann er wählen oder verändern? 

– 

ciphertext-only attack 

– 

known 

[adaptively] chosen 

} – { plaintext 

ciphertext } attack 

• adaptively: Der Angreifer kann in Abhängigkeit vorheriger 

gewählter Nachrichten neue Nachrichten wählen 

• not adaptively: Der Angreifer muß alle Nachrichten zu Beginn 

wählen, kann also nicht abhängig vom Verschlüsselungsergebnis, 

weitere Nachrichten wählen. 

Was wird durch den Angriff erreicht? 

(Brechen = Fälschen | Entschlüsseln) 

– Vollständiges Brechen: Finden des Schlüssels 

– Universelles Brechen: Finden eines zum Schlüssel äquivalenten 

Verfahrens 

– Nachrichtenbezogenes Brechen: Brechen für einzelne 

Nachrichten, ohne den Schlüssel selbst in Erfahrung zu bringen. 

• selektives Brechen: für eine vom Angreifer bestimmte Nachricht 

(z.B. einen abgefangenen Schlüsseltext) 

• existenzielles Brechen: für irgendeine Nachricht 

Aufwand/Kosten: 

– Einmalige Kosten, jeder Schlüssel effizient knackbar 

– Jeder Angriff verursacht Kosten beim Angreifer

Kryptographie 

Systematisierung und Beispiele 

symmetrische 

Konzelationssysteme 

DES, Triple DES, IDEA, 

(Pseudo)-One-time-pad 

Authentikationssysteme 

Symmetrische 

Authentikationscodes 

asymmetrische RSA, McEliece, ElGamal 

RSA, GMR, DSS, ElGamal 

Sicherheit 

Sicherheit 

Systemtyp 

Konzelation 

Authentikation 

sym. asym. sym. asym. 

sym. 

Konzelationssystem 

⊃ 

asym. 


sym. 

Authentikationssystem 

⊃ 

digitales 

Signatursystem 

∩ 

informationstheoretisch 

kryptographisch 

stark 

gegen … 

∩ 

aktiver 

Angriff 

∩ 

passiver 

Angriff 

Chaos 

Vernam-Chiffre 

(one-time pad) 

wohluntersucht 

Mathematik 

Pseudo-onetime-pad 

mit 

s 

2 

-mod-n- 

Generator 

DES 

? 

System mit 

s 

2 

-mod-n- 

Generator 

RSA 

Authentikationscodes 

DES 

GMR 

RSA 

? 

kann es nicht geben zur Zeit nicht bekannt wird von bekanntem System majorisiert

Symmetrische Kryptographie 

Symmetrisches Konzelationssystem 

Zufallszahl 

k 

Schlüsselgenerierung 

geheimer 

Schlüssel 

k 

Klartext 

x 

Schlüsseltext 

k(x) 

Verschlüsselung 

Entschlüsselung 

Klartext 

x 

Symmetrisches Authentikationssystem 

Zufallszahl 

k 

geheimer 

Schlüssel 


k 

Klartext 

x 

Codieren 


x, k(x) 

MAC 

message 

authentication 

code 

Test: 

MAC = k(x) 

Klartext und 

Testergebnis 

x, k(x) 

„ok“ oder „falsch“

Asymmetrische Kryptographie 

Asymmetrisches Konzelationssystem 

Zufallszahl 

c 

Chiffrierschlüssel, 

öffentlich bekannt 

d 

Dechiffrierschlüssel, 

geheimgehalten 

Klartext 

x 


c(x) 



Klartext 

x 

Digitales Signatursystem 

Zufallszahl 

Text mit Signatur 

und Testergebnis 

x, Sig(x), Testen 

„ok“ oder „falsch“ 

t 

Schlüssel zum Testen 

der Signatur, 

öffentlich bekannt 

Text mit 

Signatur 

x, Sig(x) 



s 

Signieren 

Schlüssel zum 

Signieren, 

geheimgehalten 

Text 

x

Schlüsselverteilung bei symmetrischem Kryptosystem 

Schlüsselverteilzentrale 

für X 

verschlüsselter 

geheimer Schlüssel 

k 

k 

für Y 

verschlüsselter 

geheimer Schlüssel 


Teilnehmerin X 

Teilnehmer Y 

Dezentralisierung ist möglich 

Schlüsselverteilzentralen 

A B C 

k AX (k 1 ) k BX (k 2 ) k CX (k 3 ) k AY (k 1 ) k BY (k 2 ) k CY (k 3 ) 

Schlüssel k = k 1 + k 2 + k 3 

Teilnehmerin X 

k(Nachrichten) 

Teilnehmer Y

Schlüsselverteilung bei asymmetrischem Kryptosystem 

Asymmetrische Konzelation 

Öffentliches Schlüsselregister R 

- - 

1. 

A läßt öffentlichen 

Chiffrierschlüssel c A 

(ggf. anonym) 

eintragen 

2. 

B bittet R 

um c A 

3. 

B erhält c A , beglaubigt 

durch Signatur 

von R 

Teilnehmerin A 

4. 

c A (Nachricht an A) 

Teilnehmer B 


Öffentliches Schlüsselregister R 

- - 

1. 

A läßt öffentlichen 

Testschlüssel t A 

(ggf. anonym) 

eintragen 

2. 

B bittet R 

um t A 

3. 

B erhält t A , beglaubigt 

durch Signatur 

von R 

Teilnehmerin A 

4. 

Nachricht von A, s A (Nachricht von A) 

Teilnehmer B


Erzeugung einer Zufallszahl z für die Schlüsselgenerierung: 

z 1 

gfjjbz 

⊕ z 2 

⊕ z 3 

… 

⊕ z n 

z 

gen 

XOR aus 

z 1 , 

einer im Gerät erzeugten, 

z 2 , 

z 3 , 

einer vom Hersteller gelieferten, 

einer vom Benutzer gelieferten, 

…, 

z n , 

einer aus Zeitabständen errechneten 

Zufallszahl

Hybride Kryptosysteme 

Kombiniere: 

– von asymmetrischen: einfache Schlüsselverteilung 

– von symmetrischen: Effizienz (Faktor 100-1000, Software und Hardware) 

– asymmetrisches System nur zum Schlüsselaustausch 

Konzelation 

A 

besorge c B 

wähle k 

N 

c B (k), k(N) 

B 

Entschlüssle k mit d B 

Entschlüssle N mit k 

– Noch effizienter: Teil von N in 1. Block auffüllen: 

c B (k, N'), k(N'') mit N=N'+N'' 

– Wenn auch B k benutzen soll: s A (k) dazulegen 

Authentikation (k geheim und authentisiert) 

A 

besorge c B 

wähle k 

N 

N, k(n), c B (k, s A (k)) 

B 

Besorge t A 

Entschlüssle k, s A (k) mit d B 

Teste k mit t A 

Teste N mit k 

– Nachrichtenintegrität ohne Verbindlichkeit/Zurechenbarkeit

Umsetzung von Sicherheitsfunktionen in Gateways 

Motivation 

– A und B haben nicht kompatible (Sicherheits)-Systeme; Sicht des 

Empfängers: kein Test von Signatur/MAC möglich, keine 

Entschlüsselung möglich 

– Performance bei B nicht, um selbst zu prüfen / entschlüsseln 

–> Verwendung eines Proxys zur Umsetzung 

Digitale Signatur 

– GW testet Signatur stellvertretend für B; B vertraut GW; 

m wird GW nicht notwendigerweise bekannt 

GW 

testet 

Signatur 

sigA(m) 

ok / n.ok 

A 

m, sigA(m) 

B 

Vertraulichkeit 

– nur unbefriedigend möglich, da geheime Information zum Entschlüsseln 

nötig, jedoch: Verteilung erhöht wieder Vertraulichkeit 

kA1(m1) 

GW1 

kB1(m1) 

A 

kA3(m3) 

kA2(m2) 

GW2 

GW3 

kB2(m2) 

kB3(m3) 

B 

m = m1 + m2 + m3

Konkrete Systeme 

Symmetrische Systeme 

– One-Time-Pad (Vernam-Chiffre) 

– Symmetrische Authentikationscodes 

– DES (Data Encryption Standard) 

– IDEA (International Data Encryption Algorithm) 

– AES (Advanced Encryption Standard) 

Praktischer Einsatz 

– Betriebsarten von Blockchiffren 

Asymmetrische Systeme 

– Diffie-Hellmann-Key-Exchange 

– El Gamal Kryptosystem 

– RSA zur Konzelation und Signatur 

– Blinde Signaturen mit RSA 

– Kryptosysteme auf Basis elliptischer Kurven

One-Time-Pad (mod 2) 

X ⊕ K = S 

0 

0 

1 

1 

0 

1 

0 

1 

0 

1 

1 

0 

– Bits von K sind zufällig und unabhängig 

– Jedes Schlüsselbit darf nur einmal verwendet 

werden 

– Schlüssel genauso lang wie Klartext 

Angreifer sieht S: K kann sein: dann ist X gewesen: 

0 

1 

0 

0 

1 

1 

0 

1 

– Der Angreifer kann alle 4 Varianten durchrechnen, erhält dadurch aber 

keine zusätzliche Information über den Klartext. 

– Die Wahrscheinlichkeit, ein Kartextbit richtig zu raten, verändert sich 

durch die Beobachtung des Schlüsseltextes nicht, sondern bleibt 

const = 0,5.

One-Time-Pad (mod 2) 

01 

10 

Zufallszahlen 

K 

K 

X 

00 

11 

S 

01 

00 

11 

Sender 

Angriffsbereich 

Empfänger 

»Hinter jedem Schlüsseltext kann sich jeder Klartext verbergen« 

– Informationstheoretisch sichere Konzelation: Egal, was der 

Angreifer a priori an Information über den Klartext hat, er gewinnt durch die 

Beobachtung des Schlüsseltextes keine Information hinzu. 

∀ s ∈ S ∃ const ∈ IN ∀ x ∈ X : | { k ∈ K | k(x)=s } | = const (1) 

Für alle Schlüsseltexte s existiert eine konstante Anzahl von Schlüsseln k, die jeweils 

alle Klartexte x derart verschlüsseln, daß aus x jeder Schlüsseltext entstehen kann. 

IN = {1, 2, 3, …}

Symmetrische Authentikationscodes 

k 

x, MAC 

H,0 H,1 T,0 T,1 

00 

01 

10 

11 

H 

H 

– 

– 

– 

– 

H 

H 

T 

– 

T 

– 

– 

T 

– 

T 

oder 

x 

k 

00 

01 

10 

11 

H 

0 

0 

1 

1 

T 

0 

1 

0 

1 

MAC 

H :="0" 

T :="1" 

Zufallszahlen 

00; 01 

K 

K 

X 

H; T H,0; T,1 

Angriff 1: Angreifer will T senden 

(blind) – erwischt richtigen MAC mit Wkt = 0,5 

Angriff 2: Angreifer will H,0 in T ändern 

(sehend) – weiß: k ∈ {00,01} 

– wenn k = 00 war, muß er T,0 senden 

– wenn k = 01 war, muß er T,1 senden 

– Wkt. ist immernoch 0,5

Symmetrische Authentikationscodes 

k 

x, MAC 

H,0 H,1 T,0 T,1 

00 

01 

10 

11 

H 

H 

– 

– 

– 

– 

H 

H 

T 

– 

T 

– 

– 

T 

– 

T 

oder 

x 

k 

00 

01 

10 

11 

H 

0 

0 

1 

1 

T 

0 

1 

0 

1 

MAC 

H :="0" 

T :="1" 

Angreifer sieht: 

H,0 

H,1 

K kann sein: 

00 

01 

10 

11 

Angreifer will x 

fälschen und such 

passenden MAC 

T,0 

T,1 

Wkt., daß Angreifer 

den richtigen MAC 

führ das Bit wählt, ist 

0,5 (d.h. „Raten“) 

T,0 

10 

00 

H,0 

T,1 

01 

11 

H,1 

informationstheoretisch sicher

DES (Data Encryption Standard) 

– 1977 vom National Bureau of Standards 

(NBS) der USA standardisiert 

– Blockchiffre: operiert auf Blöcken von 

jeweils 64 Bit 

– Feistel-Chiffre: interierte Anwendung 

eines Verschlüsselungsschemas aus 

Permutationen, Substitutionen und 

Expansionen 

– n Runden 

– Schema ist selbstinvers 

– Funktion F kann Einwegfunktion sein 

– Gütekriterien: Höchstmaß an 

• Vollständigkeit 

• Avalanche 

• Nichtlinearität 

• Korrelationsimmunität 

L 

L 

L 

M 

R 

0 0 

F 

R 

1 1 

R 

n-1 n-1 

F 

K 1 

K n 

– weitere Kriterien 

L 

n 

R 

n 

• gute Implementierbarkeit 

• Längentreue 

C 

• Schnelligkeit

Feistel-Prinzip 


L 

R 

0 0 

F 

K 1 

L 1 = R 0 (1) 

R 1 = f(R 0 ) ⊕ L 0 (2) 

L 

L' 

R 

1 1 


R' 

1 1 

L' 1 = R 1 (3) 

R' 1 = L 1 (4) 

F 

K 1 

L' 0 = R' 1 (5) 

R' 0 = f(R' 1 ) ⊕ L' 1 (6) 

L' 

R' 

0 0 

Nachweis, daß Feistel-Chiffren selbstinvers sind 

L' 0 = R' 1 = L 1 = R o mit (5), (4), (1) 

R' 0 = f(R' 1 ) ⊕ L' 1 

R' 0 = f(R' 1 ) ⊕ R 1 

R' 0 = f(R' 1 ) ⊕ f(R 0 ) ⊕ L 0 

R' 0 = f(L 1 ) ⊕ f(R 0 ) ⊕ L 0 

R' 0 = f(R 0 ) ⊕ f(R 0 ) ⊕ L 0 

R' 0 = L 0 

mit (3) folgt 

mit (2) folgt 

mit (4) folgt 

mit (1) folgt 

mit (1) folgt


Feistel-Chiffre 

– Blockbreite 64 Bit 

– n = 16 Runden 

– Teilschlüssel K 1…16 (jeweils 48 Bit) werden aus einem 56-Bit Schlüssel 

gewonnen 

– Vor der ersten und nach der letzen Runde durchläuft der Datenblock 

eine Permutation IP bzw. IP-1, die kryptographisch irrelevant ist. 

Funktion F(K i , R i-1 ) 

– Expansionsabbildung von 32 auf 48 Bit 

– 8 S-Boxen, jede S-Box: 6-Bit-Input, 4-Bit-Output 

– 32-Bit-Permutation 

Teilschlüsselgenerierung 

– Permuted Choice 1 (Schlüsselpermutation) 

– Zyklische Schiebeoperationen auf Registern C und D in Abh. der Runde 

– Permuted Choice 2 (Schlüsselauswahl 48 aus 56 Bit)

DES (Data Encryption Standard)


S-Boxen 

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 

S1: 0: 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7 

1: 0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8 

2 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0 

3 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13 

S2: 0: 15 1 8 14 6 11 3 4 9 7 2 13 12 0 5 10 

1: 3 13 4 7 15 2 8 14 12 0 1 10 6 9 11 5 

2: 0 14 7 11 10 4 13 1 5 8 12 6 9 3 2 15 

3: 13 8 10 1 3 15 4 2 11 6 7 12 0 5 14 9 

S3: 0: 10 0 9 14 6 3 15 5 1 13 12 7 11 4 2 8 

1: 13 7 0 9 3 4 6 10 2 8 5 14 12 11 15 1 

2: 13 6 4 9 8 15 3 0 11 1 2 12 5 10 14 7 

3: 1 10 13 0 6 9 8 7 4 15 14 3 11 5 2 12 

S4: 0: 7 13 14 3 0 6 9 10 1 2 8 5 11 12 4 15 

1: 13 8 11 5 6 15 0 3 4 7 2 12 1 10 14 9 

2: 10 6 9 0 12 11 7 13 15 1 3 14 5 2 8 4 

3: 3 15 0 6 10 1 13 8 9 4 5 11 12 7 2 14 

S5: 0: 2 12 4 1 7 10 11 6 8 5 3 15 13 0 14 9 

1: 14 11 2 12 4 7 13 1 5 0 15 10 3 9 8 6 

2: 4 2 1 11 10 13 7 8 15 9 12 5 6 3 0 14 

3: 11 8 12 7 1 14 2 13 6 15 0 9 10 4 5 3 

S6: 0: 12 1 10 15 9 2 6 8 0 13 3 4 14 7 5 11 

1: 10 15 4 2 7 12 9 5 6 1 13 14 0 11 3 8 

2: 9 14 15 5 2 8 12 3 7 0 4 10 1 13 11 6 

3: 4 3 2 12 9 5 15 10 11 14 1 7 6 0 8 13 

S7: 0: 4 11 2 14 15 0 8 13 3 12 9 7 5 10 6 1 

1: 13 0 11 7 4 9 1 10 14 3 5 12 2 15 8 6 

2: 1 4 11 13 12 3 7 14 10 15 6 8 0 5 9 2 

3: 6 11 13 8 1 4 10 7 9 5 0 15 14 2 3 12 

S8: 0: 13 2 8 4 6 15 11 1 10 9 3 14 5 0 12 7 

1: 1 15 13 8 10 3 7 4 12 5 6 11 0 14 9 2 

2: 7 11 4 1 9 12 14 2 0 6 10 13 15 3 5 8 

3: 2 1 14 7 4 10 8 13 15 12 9 0 3 5 6 11


Inputpermutation IP 

58 50 42 34 26 18 10 2 60 52 44 36 28 20 12 4 

62 54 46 38 30 22 14 6 64 56 48 40 32 24 16 8 

57 49 41 33 25 17 9 1 59 51 43 35 27 19 11 3 

61 53 45 37 29 21 13 5 63 55 47 39 31 23 15 7 

Outputpermutation IP-1 

40 8 48 16 56 24 64 32 39 7 47 15 55 23 63 31 

38 6 46 14 54 22 62 30 37 5 45 13 53 21 61 29 

36 4 44 12 52 20 60 28 35 3 43 11 51 19 59 27 

34 2 42 10 50 18 58 26 33 1 41 9 49 17 57 25 

Expansionsabbildung E 

32 1 2 3 4 5 4 5 6 7 8 9 

8 9 10 11 12 13 12 13 14 15 16 17 

16 17 18 19 20 21 20 21 22 23 24 25 

24 25 26 27 28 29 28 29 30 31 32 1 

Permutationsabbildung P 

16 7 20 21 29 12 28 17 1 15 23 26 5 18 31 10 

2 8 24 14 32 27 3 9 19 13 30 6 22 11 4 25 

Schlüsselpermutation (Permuted Choice 1, PC1) 

57 49 41 33 25 17 9 1 

58 50 42 34 26 18 10 2 

59 51 43 35 27 19 11 3 

60 52 44 36 

63 55 47 39 31 23 15 7 

62 54 46 38 30 22 14 6 

61 53 45 37 29 21 13 5 

28 20 12 4 

Schlüsselauswahl (Permuted Choice 2, PC2) 

14 17 11 24 1 5 3 28 15 6 21 10 

23 19 12 4 26 8 16 7 27 20 13 2 

41 52 31 37 47 55 30 40 51 45 33 48 

44 49 39 56 34 53 46 42 50 36 29 32 

Anzahl der Shifts bei der Chiffrierung bzw. Deciffrierung 

Rundennummer: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 

Links-Shifts: 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1 (Ver) 

Rechts-Shifts: 0 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1 (Ent)

Eigenschaften des DES 

– Der DES ist vollständig: Jedes Output-Bit hängt von jedem Input-Bit ab. 

– Der DES ist derart komplex, daß keinerlei analytische Abhängigkeit 

zwischen Input und Output oder Schlüssel und Output feststellbar ist. 

– Der DES ist invariant gegenüber Komplementbildung, d.h. 

DES(K, M) = DES(K, M) 

– Vier der 2 56 Schlüssel sind schwach, d.h. DES(K, DES(K, M)) = M. 

Externer SchlŸssel C-Register D-Register 

01 01 01 01 01 01 01 01 0000000 0000000 

1F 1F 1F 1F 0E 0E 0E 0E 0000000 FFFFFFF 

E0 E0 E0 E0 F1 F1 F1 F1 FFFFFFF 0000000 

FE FE FE FE FE FE FE FE FFFFFFF FFFFFFF 

Kritikpunkte 

– Designkriterien wurden nicht offengelegt (inzwischen bekannt) 

– wirksame Schlüssellänge heute viel zu gering (56 Bit) 

– nur ineffizient in Software implementierbar (wg. Permutationen) 

3-DES (Triple-DES) 

– Verbesserung der Sicherheit durch 3-fache Anwendung 

S = DES(K1, DES(K2, DES(K1, M)))

IDEA — International Data Encryption Algorithm 

Symmetrische Blockchiffre 

M ∈ {0,1} 64 , K ∈ {0,1} 128 

Operationen 

bitweise Addition mod 2 

. 

Addition mod 2 16 

Multiplikation mod 2 16 + 1 (0 wird durch 2 16 dargestellt) 

– M wird in vier 16-Bit-Operanden m 1 … m 4 .zerlegt. 

– Es werden i=1…8 Runden durchlaufen. 

– Aus K werden sechs 16-Bit-Operanden k i,1 … k i,6 .erzeugt. 

Teilschlüsselgenerierung 

– K → k 1,1 … k 1,6 , k 2,1 , k 2,2 (K wird in 8 Teile zerlegt.) 

– shiftLeft(K, 25) → k 2,3 … k 2,6 , k 3,1 … k 3,4 

– shiftLeft(K, 25) → k 3,5 , k 3,6 , k 4,1 … k 4,6 

– u.s.w 

Nach jeder Erzeugung zyklische Linksverschiebung von K um 25 Bitstellen.


m 1 

m 2 

m 3 

m 4 

k i,1 

. + 

k i,2 k i,3 + . k i,4 

+ 

selbstinvers 

+ 

. + 

k i,5 

k i,6 

+ 

. 

+ 

+ 

+ 

+ 

k 9,1 . + k 9,2 k 9,3 + . k 9,4 

c 1 

c 2 c 3 

c 4 

+ 

. 

+ 

Addition mod2 16 Multiplikation mod(2 16 +1) 

XOR



– kj sei Teilschlüssel zum Verschlüsseln in Runde j 

– dj sei Teilschlüssel zum Entschlüsseln in Runde j 

– r max sei Rundenzahl (hier r max = 8) 

– z = r max +2 

d j,1 = (k z-j,1 ) -1 mod 2 16 +1 mit 1 ≤ j ≤ r max +1 

d j,4 = (k z-j,4 ) -1 mod 2 16 +1 mit 1 ≤ j ≤ r max +1 

d j,2 = (k z-j,2 ) -1 mod 2 16 mit j = 1, j = r max +1 

d j,2 = (k z-j,3 ) -1 mod 2 16 mit 1 < j < r max +1 

d j,3 = (k z-j,3 ) -1 mod 2 16 mit j = 1, j = r max +1 

d j,3 = (k z-j,2 ) -1 mod 2 16 mit 1 < j < r max +1 

d j,5 = (k z-(j+1),5 ) mit 1 ≤ j ≤ r max +1 

d j,6 = (k z-(j+1),6 ) mit 1 ≤ j ≤ r max +1 

Eigenschaften 

– sehr gut in Hard- und Software implementierbar 

– sehr effizient 

– für kommerzielle Anwendungen fallen Lizenzgebühren an

Advanced Encryption Algorithm (AES) 

– Januar 1997 vom National Institute of Standards and Technology (NIST) 

als Nachfolger für DES initiiert 

– Kriterien: 

• symmetrische Blockchiffre mit einer Blockgröße von 128 Bit 

und variabler Schlüssellänge von 128, 192 und 256 Bit. 

• AES soll für mindestens 30 Jahre Sicherheit bieten. 

• Weder Algorithmus noch Implementierung dürfen patentiert 

sein. 

• Spezifikation: http://csrc.nist.gov/encryption/aes/ 

– August 1998 wurden 15 Kandidaten der Öffentlichkeit zur Begutachtung 

vorgelegt. 

– August 1999 wurden die 5 Finalisten vorgestellt: 

• MARS – IBM 

• RC6 – RSA Labs 

• Rijndael – Joan Daemen (Proton World Intl.), Vincent Rijmen 

(Katholieke Universiteit Leuven, Belgien) 

• Serpent – Ross Anderson (Univ of Cambridge), Eli Biham (Technion), 

Lars Knudsen (UC San Diego) 

• Twofish – Bruce Schneider, John Kelsey, Niels Ferguson 

(Counterpane Internet Security), Doug Whiting (Hi/fn, Inc.), David 

Wagner (UC Berkeley), Chris Hall (Princeton Univ.) 

– Oktober 2000: Rijndael wird ausgewählt. 

– Begründung: 

• Beste Kombination von Sicherheit, Leistungsfähigkeit, 

Effizienz und Implementierbarkeit sowohl in Software als auch 

in Hardware.

Rijndael (AES) 

– sprich: "Rein-dahl" 

http://www.esat.kuleuven.ac.be/~rijmen/rijndael/ 

– keine Feistel-Chiffre, arbeitet aber in Runden 

– Rundentransformation besteht aus drei invertierbaren Transformationen 

– variable Blocklänge und variable Schlüssellänge, jeweils unabhängig 

wählbar aus {128 Bit, 192 Bit, 256 Bit}. 

– Blockbreite {Nachrichtenblock, Schlüssel} in Bit = {Nb, Nk} · 8 Bit · 4 rows 

– Beispiel: Nb = 6 und Nk = 4 

State 

Cipher Key 

a 0,0 a 0,1 a 0,2 a 0,3 a 0,4 a 0,5 k 0,0 k 0,1 k 0,2 k 0,3 

a 1,0 a 1,1 a 1,2 a 1,3 a 1,4 a 1,5 k 1,0 k 1,1 k 1,2 k 1,3 

a 2,0 a 2,1 a 2,2 a 2,3 a 2,4 a 2,5 k 2,0 k 2,1 k 2,2 k 2,3 

a 3,0 a 3,1 a 3,2 a 3,3 a 3,4 a 3,5 k 3,0 k 3,1 k 3,2 k 3,3 

– Rundenzahl Nr ist eine Funktion von Nb und NK 

Nr Nb=4 Nb=6 Nb=8 

Nk=4 10 12 14 

Nk=6 12 12 14 

Nk=8 14 14 14


Cipher 

Rijndael(State,CipherKey) { 

KeyExpansion(CipherKey,ExpandedKey); 

AddRoundKey(State,ExpandedKey); 

For(i=1;i


ByteSub 

– operiert auf jedem Byte von State unabhängig (S-Box-Transformation) 

– 1. berechne das Multiplikative Inverse in GF(2 8 ) mit m(x) = x 8 +x 4 +x 3 +x+1 

– 2. berechne: 

y 

y 

y 

y 

y 

y 

y 

y 

0 

1 

2 

3 

4 

5 

6 

7 

1 0 0 0 1 1 1 1 

1 1 0 0 0 1 1 1 

1 1 1 0 0 0 1 1 

1 1 1 1 0 0 0 1 

1 1 1 1 1 0 0 0 

0 1 1 1 1 1 0 0 

0 0 1 1 1 1 1 0 

0 0 0 1 1 1 1 1 

x 

x 

x 

x 

x 

x 

x 

x 

= 

0 

1 

2 

3 

4 

5 

6 

7 

+ 

1 

1 

0 

0 

0 

1 

1 

0 

a 0,0 a 0,1 a 0,2 a 0,3 a 0,4 a 0,5 a 0,0 a 0,1 a 0,2 a 0,3 a 0,4 a 0,5 

a 1,0 a 1,1 a 1,2 a 1,3 a 1,4 a 1,5 a 1,0 a 1,1 a 1,2 a 1,3 a 1,4 a 1,5 

a 2,0 a 2,1 a 2,2 a 2,3 a 2,4 a 2,5 a 2,0 a 2,1 a 2,2 a 2,3 a 2,4 a 2,5 

a 3,0 a 3,1 a 3,2 a 3,3 a 3,4 a 3,5 a 3,0 a 3,1 a 3,2 a 3,3 a 3,4 a 3,5 

– ByteSub kann als Tabelle vorberechnet werden. 

– Umkehroperation: Inverse Tabelle und anschließend Berechnung des 

Multiplikatieven Inversen in GF(2 8 )


ShiftRow 

– Anzahl der zyklischen Linksshifts in Abhängigkeit von Nb 

row 0 row 1 row 2 row 3 

– Beispiel: Nb=6 

Nb=4 0 1 2 3 

Nb=6 0 1 2 3 

Nb=8 0 1 3 4 

row 0: no shift a 0,0 a 0,1 a 0,2 a 0,3 a 0,4 a 0,5 

row 1: 1 shift a 1,0 a 1,1 a 1,2 a 1,3 a 1,4 a 1,5 



– Resultat 

a 0,0 a 0,1 a 0,2 a 0,3 a 0,4 a 0,5 

a 1,1 a 1,2 a 1,3 a 1,4 a 1,5 a 1,0 

a 2,2 a 2,3 a 2,4 a 2,5 a 2,0 a 2,1 

a 3,3 a 3,4 a 3,5 a 3,0 a 3,1 a 3,2


MixColumn 

– operiert auf allen Spalten von State 

– Berechne 

b(x) = a(x) ⊗ c(x) mod x 4 +1 

mit c(x) = '03' x 3 + '01' x 2 + '01' x + 02 

– d.h. 

b 

b 

b 

b 

0 

1 

2 

3 

= 

02 03 01 01 

01 02 03 01 

01 01 02 03 

03 01 01 02 

a 

a 

a 

a 

0 

1 

2 

3 

a 0,0 a 0,1 a 0,2 a 0,3 a 0,4 a 0,5 b 0,0 b 0,1 b 0,2 b 0,3 b 0,4 b 0,5 

a 1,0 a 1,1 a 1,2 a 1,3 a 1,4 a 1,5 b 1,0 b 1,1 b 1,2 b 1,3 b 1,4 b 1,5 

a 2,0 a 2,1 a 2,2 a 2,3 a 2,4 a 2,5 b 2,0 b 2,1 b 2,2 b 2,3 b 2,4 b 2,5 

a 3,0 a 3,1 a 3,2 a 3,3 a 3,4 a 3,5 b 3,0 b 3,1 b 3,2 b 3,3 b 3,4 b 3,5 

– Inverse Operation: 

a(x) = b(x) ⊗ d(x) mod x 4 +1 

mit d(x) = '0B' x 3 + '0D' x 2 + '09' x + 0E, da 

( '03' x 3 + '01' x 2 + '01' x + 02 ) ⊗ d(x) = '01' (neutrales Element bzgl. Mult.) 

AddRoundKey 

– Länge von RoundKey entspricht Nb 

– Berechne bitweise XOR-Verknüpfung von State und RoundKey: 

State := State ⊕ RoundKey


KeyExpansion 

– für Nk6: 

KeyExpansion(byte Key[4*Nk] word W[Nb*(Nr+1)]) { 

for(i = 0; i < Nk; i++) 

W[i] = (key[4*i],key[4*i+1],key[4*i+2],key[4*i+3]); 

for(i = Nk; i < Nb * (Nr + 1); i++) { 

temp = W[i - 1]; 

if (i % Nk == 0) 

temp = ByteSub(RotByte(temp)) ^ Rcon[i / Nk]; 

else if (i % Nk == 4) 

temp = ByteSub(temp); 

W[i] = W[i - Nk] ^ temp; 

} 

}


– RotByte: zyklische Schiebeoperation 

– Rcon[i] = (RC[i], '00','00','00') 

RC[1] = 1 

RC[2] = x • (RC[i-1]) = x (i-1) 

RoundKey Selection 

– fortlaufende Auswahl 

– Beispiel für Nb = 6 und Nk = 4: 

W 0 W 1 W 2 W 3 W 4 W 5 W 6 W 7 W 8 W 9 W 10 W 11 W 12 W 13 W 14 … 

Round Key 0 Round Key 1 …

Betriebsarten von Blockchiffren 

Electronic Code Book (ECB) 

M 

E 

C 

-1 

E 

M 

K 

K 

Sender 

Empfänger 

C = E(K, M) M = E -1 (K, M) 

Cipher Block Chaining (CBC) 

M 

E 

C 

-1 

E 

M 

Sender 

K 

IV 

K 

Empfänger 

C 0 = IV 

C i = E(K, M i ⊕ C i-1 ) 

C 0 = IV 

M i = E -1 (K, C i ) ⊕ C i-1 )


CBC zur Authentikation 

E 

E 

K 

IV 

K 

letzter 

IV 

Block Vergleich ok? 

M 

Sender 

M 

Empfänger 

M 

PCBC (Plain Cipher Block Chaining) 

h 

h 

M 

E -1 

E 

C 

M 

Sender 

K 

K 

Empfänger 

h beliebige Funktion, z.B. Addition mod 2 Blocklänge 

– gleichzeitig Authentisierung und Verschlüsselung 

– letzter Block ist Redundanzblock für Authentikation


Output Feedback (OFB) 

E 

E 

K 

K 

M 

IV 

Sender 

C 

IV 

Empfänger 

M 

Cipher Feedback (CFB) 

E 

E 

K 

K 

M 

IV 

Sender 

C 

IV 

Empfänger 

M


Fehlerfortpflanzung 

Fehlerstelle 

ECB-Modus 

CBC-Modus 

PCBC-Modus 

OFB-Modus 

CFB-Modus


Modus Vorteile Nachteile 

ECB Direktzugriff möglich 

CBC 

OFB 

CFB 

keine Fehlerfortpflanzung bei 

additiven Fehlern 

gleiche Klartextblöcke liefern 

unterschiedliche Chiffretextblöcke 

Manipulationen sind erkennbar 

Kryptoanalyse erschwert 

gegenüber ECB-Modus 

keine Fehlerfortpflanzung bei 

additiven Fehlern 

Schlüsselstrom abhängig von 

Klartextstrom 

Kryptoanalyse erschwert 

gegenüber OFB-Modus 

Manipulationen sind erkennbar 

selbstsynchronisierender Modus 

Fehlerfortpflanzung in alle 

nachfolgenden Blöcke bei 

Synchronisationsfehlern 

gezieltes Einfügen und Entfernen von 

Blöcken möglich 

gleiche Klartextblöcke liefern gleiche 

Chiffretextblöcke 

Codebuchanalyse möglich 

kein Direktzugriff möglich 

Fehlerfortpflanzung in den Folgeblock 

bei additiven Fehlern 

anfällig gegen Synchronisationsfehler 

geringere Verschlüsselungsrate pro 

DES-Aufruf als ECB- und CBC-Modus 

(abh. von Bitbreite) 


unerkennbare Manipulationen sind u.U. 

möglich 

anfällig gegen Synchronisationsfehler 

geringere Verschlüsselungsrate pro 

DES-Aufruf als ECB-und CBC-Modus 

(abh. von Bitbreite) 


Fehlerfortpflanzung

Konstruktionen aus einer symmetrischen Blockchiffre 

Hashfunktion 

E 

letzter Block 

M (sonst: K) 

– Aus Sicherheitsgründen sollte die Schlüssellänge nicht wesentlich 

länger sein als die Blocklänge 

Pseudozufallszahlengenerator 

E 

seed (sonst: K) 

pseudo random number

Mathematische Grundlagen asymmetrischer Systeme 

Modulo-Rechnung 

– Grundlagen 

– Erweiterter Euklidscher Algorithmus 

Systeme auf der Basis des diskreten Logarithmus 

– primitive Wurzel 

– diskreter Logarithmus Problem 

Systeme auf der Basis der Faktorisierungsannahme 

– Faktorisierungsannahme 

– Primzahlzerlegung

Erweiterter Euklidscher Algorithmus 

Anwendung 

– zur Bestimmung von ggT(a,b) und 

– zur Ermittlung der multiplikativen Inversen der Zahl b im Restklassenring 

modulo a, d. h. zur Berechnung von b-1 aus der Beziehung 

Algorithmus 

b · b-1 ≡ 1 mod a. 

Seien a, b ∈ N +1, a > b 

Setze r -2 = a s -2 = 0 t -2 = 1 

r -1 = b s -1 = 1 t -1 = 0 

Berechne c k , r k , s k und t -k nach folgenden Beziehungen: 

c k = r k-2 DIV r k-1 

r k = r k-2 MOD r k-1 

s k = c k s k-1 + s k-2 

t k = c k t k-1 + t k-2 

Abbruchbedingung : r k = 0 

Es gilt: b · s k-1 – a · t k-1 = (-1)k · r k-1 

Ergebnisse: 

r k-1 = ggT(a,b) 

s k-1 · b = (-1)k mod a, falls ggT(a,b) = 1

Erweiterter Euklidscher Algorithmus 

c k = r k-2 DIV r k-1 r k = r k-2 MOD r k-1 s k = c k s k-1 + s k-2 t k = c k t k-1 + t k-2 

Beispiel 1 

Gegeben: a=10 b=4 

Gesucht: ggt(a,b) 

k c k r k s k t k 

-2 10 = a 0 1 

-1 4 = b 1 0 

0 2 2 = ggt 2 1 

1 2 0 (Abbruch) 

Beispiel 2 

Gegeben: p=53 q=61 n=p·q=3233 Φ(n)=(p-1)·(q-1)=3120 c=523 

Gesucht: c·c-1 = 1 mod Φ(n), d.h. Multiplikatives Inverses zu c mod Φ(n) 

k c k r k s k t k 

-2 3120 = a = Φ 0 1 

-1 523 = b = c 1 0 

0 5 505 5 1 

1 1 18 6 1 

2 28 1 = ggt 173 29 

3 18 0 (Abbruch) 

Es gilt: s k-1 · b = (-1) k mod a 

173 · 523 = (-1)3 mod 3120 

90479 = -1 mod 3120 

3119 = -1 mod 3120 

-1 = -1 mod 3120 

Da (-1)k = (-1) 3 = -1, muß noch mit -1 multipliziert werden. 

-s k-1 · b = -(-1) k mod a 

c = -s k-1 = -173 = -173 + a 

c = 2947

Eulersche-Φ-Funktion 

Definition Eulersche Φ-Funktion 

Für eine beliebige ganze Zahl n bildet die Menge Zn * der ganzen Zahlen 

modulo n, die zu n teilerfremd sind, eine multiplikative Gruppe 

Die Ordnung dieser Gruppe ist Φ(m). 

Beispiel: Φ(9) = 6 Z9 * = {1,2,4,5,7,8} 

Für den Sonderfall n = p ∈ P gilt 

Φ(p) = p-1. 

Satz von Euler 

Theorem von Lagrange 

Für ein beliebiges x mit (1 ≤ x < n), das zu n teilerfremd ist bzw. x ∈ Zn * , gilt 

x Φ(n) = 1 mod n. 

Wenn n das Produkt zweier Primzahlen n = p·q ist, gilt 

x Φ(p·q) = x (p-1)·(q-1) mod p·q. 

Mit Φ(p) = p-1folgt die 

Euler-Fermat-Identität 

x p-1 = 1 mod p 

(1 ≤ x ≤ p-1).

Primitive Wurzel 

Definition 

Eine beliebige ganze Zahl im Bereich 1 ≤ a < n heißt primitive Wurzel, 

wenn gilt 

Theorem 

ggT (a,n) = 1 und 

ad ≠ 1 mod n für alle d mit der Bedingung 1 ≤ d < Φ (n) 

Die ganze Zahl n hat genau dann eine primitive Wurzel, wenn n = 1, 2 oder 

4 ist oder die Form pk oder 2pk hat, wobei p eine ungerade Primzahl ist. 

Wenn n eine primitive Wurzel hat, dann hat n genau Φ(Φ(n)) primitive 

Wurzeln. 

Vermutung 

Jede ganze Zahl, die keine Quadratzahl ist, ist die primitive Wurzel einer 

Primzahl.

Diskreter Logarithmus 

Definition diskreter Logarithmus 

Sei p eine beliebige ganze Zahl, die eine primitive Wurzel a hat. Wenn für 

ein beliebiges c mit 0 ≤ c < Φ(p) 

b = a c mod p 

gilt, dann ist c der diskrete Logarithmus zur Basis a modulo p oder auch 

Problemstellung für den Angreifer 

– Öffentlich bekannt sind a, b, p. 

c = log a b mod p. 

– Geheim ist c. Erfährt ein Angreifer c, ist das System gebrochen. 

– Folglich möchte ein Angreifer c ermitteln. 

Beispiel 

– p = 3137; a = 577 öffentlich c = 1374 geheim 

– b = a c mod p = 858 öffentlich 

– c = log a b mod p = log 577 858 mod 3137 = ? (Angreifersicht)

Diskreter Logarithmus 

Algorithmen zur Berechnung des diskreten Logarithmus 

– Baby-Step, Giant-Step, Index-Calculus-Alg., Adleman-Alg. 

– Laufzeit zur Berechnung des diskreter Log. mod p mit p ∈ P 

e (1+o(1))(log p · log (log p))1/2 

– Rechenzeiten bei 10 8 Ops pro sek für versch. Größenordungen von p 

p Anzahl der Operationen benötigte Zeit in Jahren 

≈ 10 100 7,9 · 10 22 2,5 · 10 7 

≈ 10 200 1,8 · 10 34 5,7 · 10 19 

≈ 10 300 1,8 · 10 43 5,7 · 10 28 

≈ 10 400 9,5 · 10 50 4,8 · 10 36 

≈ 10 500 7,4 · 10 57 4,8 · 10 43 

Vergleich: Logarithmus 

log a b (a>0; a≠1; b>0) ist diejenige reele Zahl c, für die gilt a c =b. 

c = log a b wird z.B. gelöst mit log a b = log x b 

log x a 

Beispiel 1: Wieviel Bit benötigt man, um die Zahlen zwischen 0 und 255 

binär zu kodieren? 

log 2 256 = 

Beispiel 2: a = 577; b = 858; c = ? 

ln 256 

ln 2 

= 8 Bit. 

ln 858 

c = log a b = log 577 858 = 

ln 577 = 1,0624.

Faktorisierungsannahme 

– Seien p und q zwei große, unabhängig und zufällig gewählte 

Primzahlen. 

– p und q werden geheimgehalten. 

– | p | ≈ | q | ≈ 500…1500 Bit 

– Das Produkt n aus p und q wird veröffentlicht: 

n = p · q 

– Die öffentlich ausführbare Funktion (Verschlüsseln bzw. 

Signaturtest) kommt mit dem öffentlichen n aus. 

– Die private Funktion (Entschlüsseln bzw. Erzeugen einer 

Signatur) nutzt p und q. 

Annahme 

– Es ist zwar mit vernünftigem Aufwand möglich, Primzahlen p und q zu 

finden und diese zu multiplizieren. 

– Es ist aber nicht mit vernünftigem Aufwand möglich, die Primfaktoren 

von n zu finden. 

• Dass Faktorisierung schwer ist, ist bisher nicht bewiesen. 

• Annahme: Für jeden »schnellen« Faktorisierungsalgorithmus F(n) 

wird die Wahrscheinlichkeit, dass F(n) eine Zahl n=p·q tatsächlich 

faktorisieren kann, schnell kleiner, je größer die Länge |p| und |q| der 

Faktoren ist.

Diffie-Hellmann-Key-Exchange 

A will B Nachricht m schicken 

B 

Schlüsselgenerierung: 

p B ∈P und a primitive Wurzel von p B wählen 

x B mit 1 ≤ x B ≤ p B -1 wählen (geheim!) 

y B = a x B mod p B berechnen 

Veröffentl. in Schlüsselregister: 

Key 

Server: 

B : a, a p, B p, y, 

B y 

öffentlich 

B B B 

x B bleibt geheim! 

A 

liest Eintrag für B 

x A mit 1 ≤ x A ≤ p B -1 wählen 

y A = a x A mod p B berechnen 

Key Agreement: 

k AB = y 

x B A mod p B berechnen 

Verschlüsselung: 

c = E(k AB 

* , m ) 

c, y A 

über unsicheren Kanal 

B 

Key Agreement: 

k BA = y 

x A B mod p B berechnen 

Entschlüsselung: 

m = E -1 (k BA 

* , c)

Diffie-Hellmann-Key-Exchange 

Berechnung des Kommunikationsschlüssels 

k AB bzw. k BA erfolgt durch 

k AB = y 

x B A mod p B bei A und 

k BA = y 

x A B mod p B bei B. 

Nachweis 

k AB = y B 

x A = (a x B) x A = (a x A) x B = y A 

x B = k BA (mod p B ) 

Angreifer 

muß zum Brechen x A oder x B ermitteln, d.h. er muß 

x A = log a y A mod p B oder 

x B = log a y B 

mod p B 

berechnen. 

Sicherheit 

Verfahren ist sicher gegen einen passiven Angreifer. 

Verfahren ist unsicher gegen einen aktiven Angreifer (Maskerade).

Kryptosystem nach El Gamal 

basiert auf der Schwierigkeit der Berechnung des diskreten Log 


– wähle global: • p ∈ P öffentlich 

• a primitive Wurzel von p öffentlich 

– jeder Tln. wählt: • geheimen Schlüssel k i (k i < p-1) geheim 

k i relativ prim zu p-1, d.h. ggt(k i ,p-1)=1 

• berechnet –k i mod (p-1) geheim 

• y i = a -k i mod p (∗) öffentlich 


– A will Nachricht m (m < p) an B schicken 

– A besorgt sich p, a, y B 

– A wählt Zufallszahl z (z < p) 

– A berechnet c = y B 

z · m mod p 

– A sendet an B: a z mod p, c 

A 

m 

B 


– B berechnet m* = (a z ) kB · c mod p 

Nachweis, daß m* = m 

m* = (a z ) kB · y B 

z · m mod p 

= (a z ) kB · (a –k B) z · m mod p mit (∗) 

= a z·k B · a –z·k B · m mod p mit (a m ) n =a m·n 

= (a z ) k B –kB · m mod p mit a m +a n =a m+n 

m* = m

Kryptosystem nach El Gamal: Beispiel 


– Global öffentlich: 

• p = 3137 

• a = 577 

– Teilnehmer B: 

• k B = 1762 geheim 

• –k i mod (p-1) = -1762 mod 3136 = -1762 +3136 = 1374 geheim 

• y B 

= a -k B mod p = 577 1374 mod 3137 = 858 


– A will B vertraulich die Nachricht m = 2115 schicken. 

– A wählt z = 932 geheim 

– berechnet a z mod p = 577 932 mod 3137 = 1852 

z 

– berechnet y B mod p = 858 932 mod 3137 = 749 

z 

– berechnet c = y B · m mod p = 749 · 2115 mod 3137 = 3087 

– schickt a z = 1852 und c = 3087 an B 


– B berechnet (a z ) kB · c mod p = 1852 1762 · 3087 mod3137 = 2115

RSA-Verfahren (Rivest, Shamir, Adlemann, 1978) 


basiert auf der Faktorisierungsannahme 

– wähle unabh. und zufällig p, q ∈ P mit |p| ≈ |q| und p ≠ q 

– berechne n = p · q 

– wähle c mit 3 ≤ c < Φ(n) und ggt(c, Φ(n)) mit Φ(n) = (p-1)(q-1) 

– berechne d mittels p, q, c als multiplikatives Inverses von c mod Φ(n) 

c·d ≡ 1 mod Φ(n) 



öffentl. c, n d (hier meist t genannt), n 

geheim d, p, g c (hier meist s genannt), p, q 

Anwendung 

– A will Nachricht m (1 < m < n) an B schicken 

– A besorgt sich öffentliche Parameter von B: c bzw. t, sowie n 

Verschlüsselung: 

Signatur: 

naiv: c(m) := m c mod n sig s (m) := m s mod n 

sicher: c(m) := (z, m, h(z, m)) c mod n sig s (m) := (h(m)) s mod n 

A 

c(m) 

B 

A 

m, sig(m) 

B 

Entschlüsselung: 

Signaturtest: 

naiv: m* = (m c ) d mod n m* = (m s ) t mod n 

m* = ? m' → out(ok) 

sicher: 

z*, m*, y = c(m) d mod n 

y = ? h(z*, m*) → out(m) 

h(m)* = ((h(m)) s ) d mod n 

h(m)* = ? h(m') → out(ok) 

Sicherheit 

Ein Sicherheitsbeweis von RSA ist bisher nicht bekannt.

RSA-Verfahren: Angriffe 

Passiver Angriff auf naives Signatursystem 

– Angenommen, Angreifer kennt zwei Signaturen m 

s 

1 und m2 

s sowie die 

Nachichten m 1 und m 2 und kann eine dritte Signatur m 

s 

3 bilden: 

m 3 

s = m1 

s · m2 

s mod n 

m 3 = m 1 · m 2 mod n 

– Denn es gilt: m 1 

s · m2 

s = (m1 · m 2 ) s 

– RSA besitzt multiplikative Struktur, genauer: 

RSA ist Homomorphismus bezüglich der Multiplikation 

– m 3 ist vom Angreifer jedoch nicht beliebig wählbar. 

Aktiver Angriff auf naives Signatursystem 

– Angreifer kann m 3 wählen 

– Angriffe nach Davida (benötigt zwei Signaturen) und Moore (benötigt 

nur noch eine Signatur zur selektiven Fälschung) 

– Angriff wird «ausgenutzt» für blinde Signaturen (Chaum 1985) 

Verhinderung der Angriffe 

– Signatur eines Hashwertes h(m) der Nachricht m 

– h ist eine kollisionsfreie Hashfunktion 

– Finden einer Kollision, d.h. h(m) = h(m*) mit m ≠ m* ist ein schwieriges 

Problem

RSA-Verfahren: Angriffe 

Raten von Klartextblöcken 

– Angreifer kann wahrscheinliche Klartextblöcke raten, mit c 

verschlüsseln und mit abgefangenen Schlüsseltexten vergleichen. 

Verhinderung: 

deterministisches 

Kryptosystem 

Zufallszahl in Klartext 

hineinkodieren 

indeterministisches 

Kryptosystem 

Aktiver Angriff zum selektiven Brechen von RSA nach Judy Moore 

– Angreifer möchte Schlüsseltextblock S 3 entschlüsselt haben 

– wählt Zufallszahl r mit 1≤ r < n 

– berechnet multiplikatives Inverses mod n: r -1 

– berechnet S 2 := S 3 · r c mod n 

– läßt S 2 entschlüsseln, d.h. Angreifer erhält S 2 

d 

– er weiß S 2 

d ≡ (S 3 · r c ) d ≡ S 3 

d · r c·d ≡ S 3 

d · r mod n 

– berechnet S 3 

d ≡ S 2 

d · r -1 mod n 

Verhinderung des aktiven Angriffs 

– Hinzunahme eines Redundanzprädikates, z.B. einer Zufallszahl, so daß 

das Multiplizieren zweier Klartextblöcke keinen dritten Klartextblock mit 

passender Redundanz ergibt 

– vor Verschlüsselung Hashwert an Nachricht anhängen

Blinde Signatur mit RSA-Verfahren 

Algorithmus 

– Teilnehmer möchte Nachricht m signiert haben, ohne daß Signierer die 

Nachricht m selbst zur Kenntnis bekommt 

– wählt Zufallszahl r mit 1≤ r < n 

– berechnet multiplikatives Inverses mod n: r -1 

– «Blendet» die Nachricht m, d.h. berechnet m ~ := m · r t mod n 

– läßt m ~ signieren, d.h. erhält m ~ s 

– er weiß m ~ s ≡ (m · r 

t ) 

s ≡ m 

s · r 

t·s ≡ m 

s · r mod n 

– «Entblendet» die Nachricht, d.h. berechnet sig(m) ≡ m s · r -1 mod n 

Anwendung: Anonyme digitale Zahlungssysteme 

Signierer = Bank; Bank erfährt nichts über Zahlungsflüsse ähnl. Bargeld 

1. Kunde schickt «geblendete digitale Banknote» m ~ an Bank 

2. Bank belastet Konto des Kunden mit Gegenwert 

3. Bank signiert m ~ und schickt m ~ s zurück an Kunden 

4. Kunde «entblendet» Banknote und erhält sig(m) 

5. Kunde kauft bei Händler ein und bezahlt mit Banknote sig(m) 

6. Händler löst sig(m) bei Bank ein 

7. Bank prüft sig(m) auf Gültigkeit (korrekte Signatur und nicht bereits 

eingelöst) 

8. Bank schreibt Händler Gegenwert auf seinem Konto gut

Teil 1

Erfolgreiche ePaper selbst erstellen

Template löschen?

Als Template speichern?