Kryptographie 001

Kryptographie ANNEGRET WENG Vorlesung am Fachbereich Mathematik der Johannes Gutenberg Universität Mainz Mainz, den 2...

198 downloads 1292 Views 618KB Size Report

This content was uploaded by our users and we assume good faith they have the permission to share this book. If you own the copyright to this book and it is wrongfully on our website, we offer a simple DMCA procedure to remove your content from our site. Start by pressing the button below!
Report copyright / DMCA form

DOWNLOAD PDF

Kryptographie

ANNEGRET WENG

Vorlesung am Fachbereich Mathematik der Johannes Gutenberg Universität Mainz Mainz, den 28. Juli 2004

i

INHALTSVERZEICHNIS

Inhaltsverzeichnis 1 Ein Beispiel 2 Symmetrische Verschlu ¨sselungsverfahren 2.1 Einf¨ uhrung . . . . . . . . . . . . . . . . . . . . . 2.2 DES . . . . . . . . . . . . . . . . . . . . . . . . . 2.2.1 Der DES-Algorithmus . . . . . . . . . . . 2.2.2 Berechnung der Rundenschl¨ ussel f¨ ur DES . 2.3 AES . . . . . . . . . . . . . . . . . . . . . . . . . 2.3.1 Darstellung der Bytes als Elemente in F28 2.3.2 subbytes(a7 a6 . . . a0 ) . . . . . . . . . . . . 2.3.3 shiftrows . . . . . . . . . . . . . . . . . . . 2.3.4 mixcolumns . . . . . . . . . . . . . . . . . 2.3.5 Die Berechnung der Schl¨ ussel . . . . . . . 2.3.6 Entschl¨ usselung . . . . . . . . . . . . . . . 2.4 Angriffe auf symmetrische Kryptosysteme . . . . 2.5 Modes of Operations . . . . . . . . . . . . . . . . ¨ 2.6 Ubungsaufgaben . . . . . . . . . . . . . . . . . . 2.7 Appendix . . . . . . . . . . . . . . . . . . . . . .

2 . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

3 Public Key Kryptographie - Asymmetrische Verschlu ¨sselung 3.1 Probabilistische Algorithmen . . . . . . . . . . . . . . . . . . . . 3.2 Einwegfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . 3.3 Definition eines Public Key Systems . . . . . . . . . . . . . . . . 3.4 Sicherheitsbeweise . . . . . . . . . . . . . . . . . . . . . . . . . . 3.4.1 Polynomielle Ununterscheidbarkeit . . . . . . . . . . . . 3.4.2 Semantische Sicherheit . . . . . . . . . . . . . . . . . . . 3.5 Turingsche Reduktion . . . . . . . . . . . . . . . . . . . . . . . . ¨ 3.6 Ubungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.6.1 Mathematische Grundlagen . . . . . . . . . . . . . . . . 3.6.2 Sicherheit . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . .

4 Mathematische Grundlagen 4.1 Chinesischer Restsatz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2 Primzahltests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.2.1 Primzahltest von Miller-Rabin . . . . . . . . . . . . . . . . . . . . 4.2.2 Ein deterministischer Primzahltest unter der Riemannschen Vermutung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3 Der AKS-Primzahltest . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.1 Die Grundidee . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.2 Der Algorithmus . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.3 Zur Laufzeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4.3.4 Weitere Primzahltests . . . . . . . . . . . . . . . . . . . . . . . . ¨ 4.4 Ubungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . .

8 8 10 11 12 13 14 15 15 15 16 17 17 20 21 23

. . . . . . . . . .

26 27 28 30 30 31 31 33 35 35 38

39 . 39 . 39 . 39 . . . . . . .

41 43 43 43 46 47 47

ii

INHALTSVERZEICHNIS

5 RSA 5.1 Das RSA-Verschl¨ usselungssystem . . . . . . . . . . . . . . . . . . . 5.1.1 Verschl¨ usselung . . . . . . . . . . . . . . . . . . . . . . . . . 5.1.2 Entschl¨ usselung . . . . . . . . . . . . . . . . . . . . . . . . . 5.2 Die RSA-Signatur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.3 RSA-Entschl¨ usselung unter Verwendung des chinesischen Restsatzes 5.4 Angriffe auf RSA . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.5 Die Wiener-Attacke . . . . . . . . . . . . . . . . . . . . . . . . . . . 5.6 Textbook-RSA ist unsicher . . . . . . . . . . . . . . . . . . . . . . . 5.7 Optimal Asymmetric Encryption Padding . . . . . . . . . . . . . . ¨ 5.8 Ubungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 Das diskrete Logarithmusproblem 6.1 Algorithmen zur Lösung des diskreten Logarithmusproblems 6.1.1 Der Algorithmus von Shanks . . . . . . . . . . . . . . 6.1.2 Das Geburtstagsparadoxon . . . . . . . . . . . . . . . 6.1.3 Die ρ-Methode von Pollard . . . . . . . . . . . . . . 6.1.4 Der Algorithmus von Pohlig-Hellmann . . . . . . . . 6.2 Das generische Modell . . . . . . . . . . . . . . . . . . . . . 6.3 Ein DL-basiertes Kryptosystem . . . . . . . . . . . . . . . . ¨ 6.4 Ubung - Die Index-Calculus-Methode . . . . . . . . . . . . . 7 Elliptische Kurven 7.1 Definitionen und Grundlagen . . . . . . . . . . . . . 7.2 Elliptische Kurven u ¨ber endlichen Körpern . . . . . . 7.3 Das DL-Problem auf einer elliptischen Kurve . . . . . 7.4 ECDSA . . . . . . . . . . . . . . . . . . . . . . . . . 7.5 Paarungsbasierte Kryptographie . . . . . . . . . . . . 7.5.1 Die Weil-Paarung . . . . . . . . . . . . . . . . 7.5.2 Tripartiter Schl¨ usselaustausch in einer Runde 7.5.3 Ein identiätsbasiertes Kryptosystem . . . . . . 7.6 Die Diffie-Hellmann Probleme . . . . . . . . . . . . . ¨ 7.7 Ubungsaufgaben . . . . . . . . . . . . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

. . . . . . . .

. . . . . . . . . .

. . . . . . . . . .

49 49 49 49 49 49 50 51 54 54 58

. . . . . . . .

60 60 60 61 62 63 63 65 66

. . . . . . . . . .

69 69 71 72 75 76 76 78 79 80 80

8 Zeroknowledge 82 8.0.1 Der Fiat-Shamir Algorithmus . . . . . . . . . . . . . . . . . . . . . 83 8.0.2 DL-Identifikation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84 9 Zufallsgeneratoren 85 9.1 Definitionen und Grundlagen . . . . . . . . . . . . . . . . . . . . . . . . . 85 9.2 Der Blum-Blum-Shup Generator . . . . . . . . . . . . . . . . . . . . . . . . 87

1

INHALTSVERZEICHNIS

10 Implementierungsfehler 10.1 Bleichenbachers Attacke gegen PKCS#1 . . . . . . 10.1.1 Das Format des Eingabetextes . . . . . . . . 10.1.2 Der Angriff . . . . . . . . . . . . . . . . . . 10.1.3 Analyse . . . . . . . . . . . . . . . . . . . . 10.2 Nguyens Angriff auf OpenPGP . . . . . . . . . . . 10.2.1 Die Implementierung der El-Gamal Signatur 10.2.2 Ein wenig Gittertheorie . . . . . . . . . . . . 10.2.3 Der Angriff . . . . . . . . . . . . . . . . . . 10.2.4 Rucksack-Probleme . . . . . . . . . . . . . . 11 Literatur

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

. . . . . . . . .

89 89 89 90 92 94 94 95 98 100 104

2

1

Ein Beispiel

Wir beginnen mit einem Einf¨ uhrungsbeispiel. Angenommen Alice möchte an Bob u ¨ ber einen unsicheren Kanal eine vertrauliche Nachricht senden. Wir gehen davon aus, dass die Nachricht von einer dritten Person abgefangen werden kann. Eine typische Situation: Alice ist ohne ihren Freund Bob in den Urlaub gefahren. Nun stellt sie fest, dass sie die Pin von ihrer EC-Karte vergessen hat. Sie erinnert sich, dass in ihrem Schreibtisch zu Hause eine Notiz mit der Nummer liegt. Also schreibt sie eine E-Mail an Bob und bittet ihn, ihr die Pin-Nummer zu senden. Bob möchte ihr nun aber nicht einfach die Nummer schicken, da er f¨ urchtet, dass ein unbefugter Dritter die E-Mail lesen könnte. Nun gibt es nat¨ urlich verschiedene Möglichkeiten. Wir nehmen an, dass beide ein Verschl¨ usselungssystem verwenden möchten. Definition 1.0.1. Ein Verschlu ¨ sselungssystem ist ein 5-Tupel (P, C, K, E, D) bestehend aus einer Nachricht P , einer Menge von Geheimtexten C, einer Menge von Schl¨ usseln K und einer Menge von Verschl¨ usselungs - und Entschl¨ usselungsfunktionen E und D. F¨ ur jedes K ∈ K soll eine Verschl¨ usselungsfunktion eK : P → C und eine Entschl¨ usselungsfunktion dK : C → P mit dK (eK (m)) = m f¨ ur alle m ∈ P existieren. Ein einfaches Beispiel f¨ ur ein Verschl¨ usselungsverfahren kennen wir noch aus der Grundschule. Bob könnte einfach alle Ziffern um eine Ziffer verschieben. Aus einer 9 wird dann eine 0. Dies ist in der Tat ein Kryptosystem. Nehmen wir an, dass wir damit Pin-Nummern bestehend aus 8 Dezimalstellen verschl¨ usseln wollen. Dann ist P = C = {0, . . . , 9}, und K = {k} besteht nur aus einem Schl¨ ussel. Die Verschl¨ usselungsfunktion ist durch e(m) = m + 1 mod 10 und die Entschl¨ usselungsfunktion durch d(m) = m − 1 mod 10 gegeben. Hierbei bezeichne x mod 10 immer den kleinsten nicht-negativen Rest von x modulo 10. Da Alice nicht weiss, welche Methode Bob zur Verschl¨ usselung verwendet, muss Bob ihr das System zunächst beschreiben. Ein unbefugter Dritter, der ihre E-Mails lesen kann, w¨ urde dann auch die Beschreibung des Systems erfahren und wäre ebenfalls in der Lage, Alices Pin-Nummber zu entschl¨ usseln. Dies ist also kein sicheres Verschl¨ usselungssystem. Wenn wir die Sicherheit von Kryptosystemen betrachten, gehen wir allgemein davon aus, dass der Verschl¨ usselungsalgorithmus jedem bekannt ist. Die Sicherheit des Systems sollte also nicht darauf beruhen, dass man den Algorithmus geheimhält. Nun angenommen, Bob und Alice hätten vorausschauend vor dem Urlaub bereits ein geheimes Schl¨ usselwort {0, . . . , 9}8 vereinbart. Dann können sie wie folgt vorgehen: Sei x1 . . . x8 , xi ∈ {0, . . . , 9} die Pin-Nummer und y1 . . . y8 das Schl¨ usselwort. Bob berechnet z1 . . . z8 mit zi = xi + yi mod 10. Er sendet zi zu Alice. Alice kann nun xi durch die Vorschrift x0i = zi − yi entschl¨ usseln. Falls x0i < 0 dann xi = x0i + 10, sonst xi = x0i . Der Feind, nennen wir sie von nun an Celine, hat nun eine schweren Stand. Da sie das Schl¨ usselwort yi nicht kennt, wird sie nicht in der Lage sein, xi zu entschl¨ usseln. In der

3

Tat, falls die yi zufällig gewählt wurden, können wir leicht sehen, dass f¨ ur Celine jede Pin-Nummer xi gleich wahrscheinlich ist. Definition 1.0.2. Ein Verschl¨ usselungssystem heißt perfekt sicher, wenn die Ereignisse, dass ein bestimmter Geheimtext auftritt und dass ein bestimmter Nachrichtentext vorliegt, unabhängig sind. Formaler, Ws[m = x|c = z] = Ws[m = x] f¨ ur alle x ∈ P , z ∈ C. Das oben beschriebene System heißt auch One-Time Pad. Wir werden nun beweisen, dass es tatsächlich perfekt sicher ist, falls das Schl¨ usselwort y1 . . . y8 nur einmal verwendet wird. Lemma 1.0.3. Sei y1 . . . y8 eine zufällig gewählte Zahl besteht aus 8 Dezimalstellen, z.B. jedes yi wurde gleichverteilt aus der Menge {0, . . . , 9} gewählt. Falls Bob das Schl¨ usselwort y1 . . . y8 nun zur Verschl¨ usselung einer einzigen Pin-Nummer beestehend aus 8 Dezimalstellen verwendet, dann ist das System perfekt sicher. Falls er das gleiche Schl¨ usselwort ein zweites Mal einsetzt, erf¨ ullt das System nicht die Anforderungen der perfekten Sicherheit. Beweis: Die Nachricht x = x1 . . . x8 kann jede Zahl bestehend aus 8 Dezimalstellen sein. Somit gilt Ws[m = x] = 1018 . Da der Schl¨ ussel K zufällig gewählt wird, gilt f¨ ur ein y ∈ {0, . . . , 9}8 , dass Ws[K = y] =

1 . 108

Angenommen z1 . . . z8 ist der Geheimtext einer solchen Pin-Nummer. Dann gilt 1 Ws[m = x|c = z] = Ws[K = z − x] = 8 = Ws[m = x]. 10 Somit ist das System perfekt sicher. Wir zeigen nun, dass das System nicht mehr perfekt sicher ist, falls das gleiche Schl¨ ussel0 0 0 wort ein zweites Mal eingesetzt wird. Seien x = x1 . . . x8 und x = x1 . . . x8 zwei 8-stellige Dezimalzahlen. Wir können diese zusammen als 16-stelligen Nachrichtentext auffassen. Wir haben dann Ws[m = xx0 ] = 10116 . Angenommen z1 . . . z8 z10 . . . z80 ist der Geheimtext. Dann gilt Ws[m = xx0 |c = zz 0 ] = Ws[y = z − x] =

1 1 6= 16 = Ws[m = xx0 ]. 8 10 10

Somit ist dieses System nicht perfekt sicher. In der Tat können wir aus dem Geheimtext einige Informationen erlangen. Angenommen es gilt z1 6= z10 , dann folgt x1 6= x01 . Dies ist genau der entscheidende Punkt bei der Definition von perfekter Sicherheit: Perfekte Sicherheit garantiert, dass das System keinerlei Informationen u ¨ber den Nachrichtentext zuläßt, die man sich nicht ohne den

4

Geheimtext erschließen könnte. Der Geheimtext hilft uns nicht, irgendwelche Informationen u unglichen Nachrichtentext abzuleiten. Bei Kenntnis des Geheimtextes ¨ber den urspr¨ ist jeder Nachrichtentext immer noch genau so wahrscheinlich oder unwahrscheinlich wie zuvor. Perfekte Sicherheit impliziert, dass auch ein Angreifer mit unendlicher Rechenkapazität das System nicht berechen kann. Nun haben Alice und Bob also einen absolut sicheren Weg gefunden, um die Pin-Nummer auszutauschen. Es ist aber nicht schwierig, den Hauptnachtteil dieses Systems zu finden. Sie mussten lange vorher ein Schl¨ usselwort austauschen. Was machen sie nun, wenn sie vergessen hatten, sich auf ein geheimes Schl¨ usselwort zu einigen oder wenn Alice das Schl¨ usselwort vergessen hat, so wie sie ihre Pin-Nummber vergaß? F¨ ur den Rest dieses Abschnittes werden wir uns mit einem Verfahren beschäftigen, dass es Alice und Bob erlaubt, sich u usselwort ¨ber einen unsicheren Kanal auf ein geheimes Schl¨ zu einigen. Das Verfahren wird Schl¨ usselaustausch von Diffie-Hellmann genannt. Dazu m¨ ussen wir jetzt erst einmal etwas Mathematik betreiben. Sei Fp eine endlicher Primkörper, d.h. die Menge aller Restklassen modulo einer Primzahl p. Wir stellen jede Restklasse durch ihre kleinste positive Zahl da, d.h. Fp = {0, . . . , p−1}. Nun betrachte die multiplikative Gruppe F∗p = Fp − {0}. Diese Gruppe ist zyklisch von Ordnung p − 1. Sei α ein erzeugendes Element. (Beispiel: Die Gruppe F∗p f¨ ur p = 103 wird von α = 7 erzeugt.) Wir wollen nun αk mod p f¨ ur k ∈ N berechnen. Wir können dies auf zwei verschiedene Weisen tun. Die erste Möglichkeit besteht darin αk in Z zu berechnen und das Ergebnis modulo p zu reduzieren. Dies ist klar die schlechteste Möglichkeit, und wir werden gleich sehen, dass es viel besser geht. In diesem Fall sind die Zwischenergebnis sehr große ganze Zahlen. Die nächste Möglichkeit besteht darin, zunächst α2 = α2 mod p und dann α3 = α · α2 mod p usw. zu berechnen. Dies hat den großen Vorteil, dass alle auftretenden Zahlen durch p2 beschränkt sind. So m¨ ussen wir unsere Berechnungen nur mit relativ kleinen Zahlen durchf¨ uhren. m Aber es geht noch besser: Um α2 zu berechnen, brauchen wir nur m−1 Multiplikationen, denn ... 2 2 2m α mod p = α2 mod p (mit m − 1 Klammern) wobei wir nach jeder Quadratur modulo p reduzieren. Wenn wir nun αk mod p berechnen wollen, schreiben wir die Zahl k in einer binären Entwicklung k = km . . . k1 (km ist hierbei das höchstwertigste Bit). Wir berechnen dann die Zahlen α1 = α, α2 = α2 , α3 = α4 , . . . , αm = α2

m−1

5

durch m − 1 Quadraturen und

αk =

Y

αi

i:ki =1

mit höchstens m − 1 Multiplikationen. Der komplette Algorithmus ist wie folgt gegeben: square-and-multiply(x,c,n) //berechnet xc mod n z:=1; Pm−1 i c := i=0 ci 2 ; for i=m-1 to 0 do z := z 2 mod n if ci = 1 z := z · x mod n; end if; end for; return z; Wir fassen unsere Beobachtung in folgendem Lemma zusammen. Lemma 1.0.4. Sei α ein Element in F∗p und k eine nat¨ urliche Zahl. Die Berechnung k von α benötigt höchstens 2blog kc Operationen wobei log den Logarithmus zur Basis 2 bezeichnet. Beweis: Es m¨ ussen dann am meisten Operationen (im Verhältnis zu log k) durchgef¨ uhrt werden, wenn die Binärdarstellung der Zahl k aus lauter Einsen besteht. Wir sehen leicht, dass wir dann genau blog kc Verdoppelungen und blog kc Additionen benötigen. Wir betrachten nun das folgende Problem: Definition 1.0.5. Sei α ein Erzeuger von F∗p und sei β ein zufälliges Element in F∗p . Das diskrete Logarithmusproblem in F∗p ist das Problem: Gegeben α, β ∈ F∗p finde k mit αk = β in F∗p . Nat¨ urlich gibt es einen naiven Ansatz, dieses Problem zu lösen. Wir berechnen einfach α, α2 , α3 , . . . bis wir ein k mit αk = β gefunden haben. Dieser Ansatz benötigt O(k) Schritte. Auf der anderen Seite brauchen wir nur O(log k) Schritte, um einen Instanz des diskreten Logarithmusproblems zu erzeugen. (Eine Instanz des diskreten Logarithmusproblems erzeugen wir, indem wir f¨ ur ein Element α ∈ F∗p und eine ganze Zahl k das Element αk berechnen.) Bemerkung 1.0.6. Es gibt Algorithmen, um das diskrete Logarithmusproblem zu lösen, die schneller als der naive Ansatz sind. Wir werden diese später kennenlernen. F¨ ur F∗p hat der beste bekannte Algorithmus eine subexponentielle Laufzeit, genauer können wir das diskrete Logarithmus in 1

2

e(log p) 3 (log log p) 3 (c+o(1)) f¨ ur eine Konstante c > 0 Operationen lösen. √ Es gibt Gruppen, f¨ ur die der beste Algorithmus O( p) benötigt, z.B. elliptische Kurven

6

(siehe Kapitel 7). Zur O-Notation: f, g : N → R, f ∈ O(g), falls es eine Konstante c ∈ R+ und ein n ∈ N gibt mit f (n) ≤ c · g(n). Die meisten Leute glauben, dass das diskrete Logarithmusproblem in F∗p nicht effizient gelöst werden kann, d.h. es gibt keine Algorithmus, der zum Lösen in etwa soviel Schritte braucht, wie es kostet, eine Instanz des Problems zu erzeugen. Aber es gibt keinen Beweis f¨ ur diese Aussage. Es ist somit nicht ausgeschlossen, dass jemand einen effizienteren Algorithmus finden kann. Wir können nun das Diffie-Hellmann Schlu ¨sselaustausch-Verfahren beschreiben: Sei p eine große Primzahl so dass p − 1 einen großen Primfaktor besitzt (dies ist eine technische Bedingung, die später in der Vorlesung klar wird). Heutzutage sollte p mindestens 1024 Bit haben, d.h. p ∼ 21024 . Wir werden später auch Algorithmen kennenlernen, die große Primzahlen effizient erzeugen. Betrachte F∗p und sei a ein Erzeuger von F∗p . Alice und Bob können nun auf folgende Weise ein Geheimnis vereinbaren: Alice denkt sich ein ka ∈ Z (Denken ist nun wirklich sicher!) und berechnet ga = aka auf ihrem eigenen Laptop, zu dem niemand sonst Zutritt hat. Bob wählt kb ∈ Z und berechnet gb = akb . Nun sendet Alice ga zu Bob und Bob sendet gb zu Alice. Alice berechnet nun ha = gbka unter Verwendung ihrer Geheimzahl ka und Bob berechnet hb = gakb . Siehe da, wir haben ha = gbka = gakb = hb , so beide erhalten das gleiche Element in F∗p . Sie können diese Zahl nun zur Ver- und Entschl¨ usselung verwenden. Warum ist dieses System sicher? Celine kennt weder ka noch kb aber wir können davon ausgehen, dass sie F∗p , den Erzeuger a und die Zahlen ga und gb abgefangen hat. Sie muss nun also aus a, ga = aka und gb = akb das Geheimnis aka kb berechnen. Diese Problem heißt Computational Diffie-Hellmann Problem. Offensichtlich kann Celine, wenn sie in der Lage ist das diskrete Logarithmusproblem zu lösen, auch das Computational Diffie-Hellmann Problem lösen. Es ist aber nicht bekannt, ob diese beiden Probleme äquivalent sind, d.h. ob es zur Lösung des diskreten Logarithmusproblem vielleicht ausreicht, ein bestimmtes Computational Diffie-Hellmann Problem zu lösen. Auch hier, glauben die meisten Leute, dass das Computational Diffie-Hellmann Problem in F∗p schwer und somit das Diffie-Hellmann Schl¨ usselaustauschverfahren sicher ist. Nat¨ urlich ist unser Protokoll nun nicht mehr perfekt sicher. Zunächst einmal ist das Diffie-Hellmann Schl¨ usselaustauschverfahren nicht mehr perfekt sicher. Ein Angreifer mit unendlicher Rechenkapazität kann das diskrete Logarithmusproblem mit dem naiven Ansatz lösen und das System brechen. Dann gibt es ein weiteres Problem. Alice und Bob erhalten zunächst eine geheime Zahl, die aber in {0, . . . , p − 1} liegt. Um damit nun ihre Pin-Nummer zu verschl¨ usseln, m¨ ussen sie diese Zahl auf eine 8-stellige Dezimalzahl abbilden. Solch eine Abbildung von der urich einige Eigenschaften Menge F∗p in die Menge der 8-stelligen Dezimalzahlen muss nat¨

7

besitzen, damit das System immer noch sicher ist. Man kann sich leicht Abbildungen u ¨berlegen, so dass das gesamte System total unsicher wird. Schließlich noch ein echter Angriff auf das oben beschriebene System. Celine wählt selbst eine geheime Zahl kc . Sie sendet nun an Bob eine Nachricht mi akc . Dabei fälscht sie den Absender, so dass Bob glaubt, dass die Nachricht von Alice stammt. Er schickt u ¨ber den unsicheren Kanal akb und die mit akc kb verschl¨ usselte Pin-Nummer. Alice kann damit nichts anfangen, aber Celine kann nun die Pin-Nummer ermitteln. Auch gegen solche aktiven Angriffe m¨ ussen wir uns wappnen.

8

2

Symmetrische Verschlu ¨ sselungsverfahren

Wir gehen nun zunächst auf symmetrische Verschl¨ usselungsverfahren ein. Diese waren auch in der historischen Entwicklung lange vor den asymmetrischen Verfahren bekannt. Gegeben¨ uber den asymmetrischen (Public-Key) Verfahren sind die symmetrischen Verfahren wesentlich schneller. Heute werden vielfach hybride Kryptosysteme eingesetzt, d.h. der Schl¨ usselaustausch wird mit einem asymmetrischen Verfahren, die Verschl¨ usselung mit einem symmetrischen Verfahren realisiert. 2.1

Einfu ¨hrung

Zu Anfang listen wir ein paar einfache symmetrische Verschl¨ usselungsverfahren auf. Diese können alle leicht gebrochen werden, sind also unsicher und werden in der Praxis nicht eingesetzt. Bei einem symmetrischen Verschl¨ usselungsverfahren teilen Sender und Empfänger einen gemeinsamen, geheimen Schl¨ ussel. Wir werden später im Gegensatz dazu asymmetrische Verfahren kennenlernen. Beispiel 2.1.1. 1. Shift Cipher, P = C = K = Z/26Z. Wir stellen eine Restklasse modulo 26 immer durch ihren kleinsten positiven Rest dar. Dabei wird eine durch 26 teilbare Zahl durch 0 dargestellt. F¨ ur alle K ∈ K gilt eK (x) = (x + K) mod 26 und dK (y) = (y − K) mod 26 mit x, y ∈ Z/26Z. Der Fall K = 3 ist auch unter dem Namen Caesar-Chiffre bekannt. 2. Substitutions-Cipher, P = C = Z/26Z, K Menge der Permutationen von {1, 2, . . . , 26}. F¨ ur alle π ∈ K gibt es eine Verschl¨ usselungsfunktion eπ (x) = π(x)

und dπ (y) = π −1 (y). Dabei ist π −1 die zu π inverse Permutation. Ein solches Verschl¨ usselungsverfahren wurde beim Findling im FAZ-Magazin eingesetzt. 3. Affines Cipher, P = C = Z/26Z, K = {(a, b) ∈ Z/26Z × Z/26Z : ggT(a, 26) = 1}. F¨ ur K = (a, b) ∈ K setze eK (x) = (ax + b)

und

dK (x) = a−1 (y − b)

mod 26

mod 26.

4. Vignere Cipher, P = C = K = (Z/26Z)m . Sei K = (k1 , . . . , km ) ∈ K, dann setze eK (x1 , . . . , xm ) = (x1 + k1 , x2 + k2 , . . . , xm + km )

und dK (y1 , . . . , ym ) = (y1 − k1 , y2 − k2 , . . . , ym − km ). Alle Operationen sind hier Operationen in Z/26Z.

2.1

9

Einf¨ uhrung

5. Hill-Cipher, P = C = (Z/26Z)m , m ≥ 2 und K = {invertierbare m × m − Matrizen in Z/26Z} Die Verschl¨ usselungsfunktion ist durch eK (x) = Kx, K ∈ K gegeben und die Entschl¨ usselungsfunktion durch dK (y) = K −1 y definiert. 6. Permutationscipher, m ∈ N, P = C = (Z/26Z)m , K = {1, . . . , m}, K Menge der Permutationen von 1, . . . , m. Die Verschl¨ usselungsfunktion ist gegeben durch eπ (x1 , . . . , xm ) = (xπ(1) , . . . , xπ(m) ) die Entschl¨ usselungsfunktion durch dπ (y1 , . . . , ym ) = (yπ−1 (1), . . . , yπ−1 (m)). Wenn der Nachrichtentext sehr lange ist, wird er oft st¨ uckweise verschl¨ usselt. Gegeben eine Nachricht x = x1 . . . xm mit |xi | = n und ein symmetrisches Schl¨ usselverfahren (P, C, K, E, D), f¨ ur das f¨ ur alle p ∈ P , |p| = n gilt. Wir haben zwei Möglichkeiten: Wir können y = eK (x1 )eK (x2 ) . . . setzen (Blockchiffre) oder wir setzen einen KeystreamErzeuger ein, der gegeben K ∈ K einen unendlich langen String K1 K2 . . . erzeugt, den Schl¨ usselstring. Beispiel 2.1.2. P = C = K = Z/26Z, z1 = K, zi = xi−1 f¨ ur alle i ≥ 2. F¨ ur 0 ≤ z ≤ 25 setze ez (x) = x + z mod 26 und dz (y) = y − z

mod 26

f¨ ur alle x, y. Dieses System ist nat¨ urlich auch unsicher, da es nur 26 mögliche Schl¨ ussel gibt. Es seien S1 = (P, P, K1 , E1 , D1 ) und S2 = (P, P, K2 , E2 , D2 ). Das Produkt von S1 × S2 ist gegeben durch (P, P, K1 × K2 , E, D)

mit

e(K1 ,K2 ) (x) = eK2 (eK1 (x)) und d(K1 ,K2 ) (y) = dK1 (dK2 (y)) f¨ ur alle (K1 , K2 ) ∈ K1 × K2 . Wir wollen nun verschiedenen Angriffstypen definieren.

10

2.2

DES

Ciphertext only attack: Gegeben den Geheimtext, finde den geheimen Schl¨ ussel oder die urspr¨ ungliche Nachricht. Known plaintext attack: Gegeben die Nachricht und einen passenden Geheimtext, bestimme den geheimen Schl¨ ussel oder entschl¨ ussele eine weitere Nachricht, die mit dem geheimen Schl¨ ussel verschl¨ usselt wurde. Chosen plaintext attack: Der Angreifer wählt eine Nachricht seiner Wahl und läßt sich diese Nachricht verschl¨ usseln. Er versucht dann, eine andere Nachricht zu entschl¨ usseln oder den geheimen Schl¨ ussel zu ermitteln. Chose ciphertext attack: Der Angreifer wählt einen Geheimtext seiner Wahl und läßt diesen entschl¨ usseln. Er versucht dann, eine andere Nachricht zu entschl¨ usseln oder den geheimen Schl¨ ussel zu ermitteln. Man sieht leicht, dass z.B. der Shift-Cipher oder der Substitutions-Cipher schon mit dem schwächsten Angriff, der Ciphertext only Attacke, gebrochen werden kann. Betrachte dazu bei ersterem einfaches Durchprobieren und bei letzterem die Buchstabenhäufigkeiten. 2.2

DES

Ab nun seien P, C ⊂ {0, 1}∗ . Die bisherigen Systeme waren alle unsicher. Wir werden nun ein modernes symmetrisches Verschl¨ usselungsverfahren kennenlernen, und zwar DES (Data-Encryption-Standard, 1975). Dieses Kryptosystem war lange Zeit im Einsatz und wird auch heute in einer modifizierten Variante (Triple-DES) verwendet. Die Form, die wir hier der Einfachheit halber vorstellen, wird nicht mehr eingesetzt, weil die Schl¨ ussel zu kurz sind und mit Brute-Force ermittelt werden können. DES ist ein iterierter Feistel-Cipher. Definition 2.2.1. (Iterierter Cipher) Hier gibt es mehrere Runden N . Gegeben sei K ∈ K. Wir erzeugen eine Sequenz K 1 . . . K N von Rundenschl¨ usseln. Sei w 0 = x und ∗ ∗ sei g eine Funktion g : {0, 1} × K → {0, 1} . Dann setzen wir w r = g(w r−1 , K r ) f¨ ur N r = 1, . . . , N . Der Geheimtext ist y = w . Die Funktion g muss dabei im zweiten Argument injektiv sein, d.h. es gibt eine Funktion g −1 mit g −1 (g(w r−1 , K r ), K r ) = w r−1 . Dann können wir y wie folgt entschl¨ usseln wN ← y

w N −1 ← g −1 (w N , K N ) ... x ← w0. F¨ ur einen Feistel-Cipher wird jedes Wort w i wird in zwei Hälften gleicher Länge geteilt w i = Li R i .

2.2

11

DES

Die Funktion g ist von der Form g(Li−1 , Ri−1 , K i ) = (Li , Ri ) mit Li = Ri−1 Ri = Li−1 ⊕ f (Ri−1 , K i ) wobei ⊕ die binäre Addition bezeichnet. Die Invertierung erfolgt dann wie folgt Li−1 = Ri ⊕ f (Li , K i ) Ri−1 = Li

wobei ⊕ das XOR bezeichnet (d.h. 0 ⊕ 0 = 1 ⊕ 1 = 0, 0 ⊕ 1 = 1 ⊕ 0 = 1). Das symmetrische Verschl¨ usselungsverfahren DES ist ein 16-Runden Feistel-Cipher mit Blocklänge 64. Der Nachrichtentext hat hier eine Länge von 64 Bits, der Schl¨ ussel K eine Länge von 64 Bits (von den 64 Schl¨ usselbits sind aber nur 56 frei wählbar). Der Geheimtext hat ebenfalls 64 Bits. Davon sind aber nur 56 frei wählbar. 2.2.1

Der DES-Algorithmus

Wir beschreiben grob das Schema von DES. Am Anfang und Ende wird eine Permutation IP (initial permutation) auf den Nachrichten- bzw. Ausgabetext angewendet. Eingabe: x Ausgabe: y IP (x) = L0 R0 Dann folgen die 16 Runden. y = IP −1 (R16 L16 ). Jeder String Li , Ri hat 32 Bits. Aus K werden 16 Rundenschl¨ ussel (K 1 , K 2 , . . . , K 16 ) berechnet; jeder hat eine Länge von 48 Bits. Jedes K i ist eine permutierte Auswahl von Bits aus K. Dabei wird die Funktion f (Li , K i ) ∈ {0, 1}32 , Li ∈ {0, 1}32 , K i ∈ {0, 1}48 , wie folgt berechnet: 1. Li wird durch eine Expansionsfunktion E auf 48 Bits erweitert. (Der Wert E(Li ) besteht aus den permutierten Bits von E; einige 16 Bits tauchen dabei zweimal auf.) 2. Berechne E(A) ⊕ K i = B und schreibe B als B1 . . . B8 wobei Bi aus genau 6 Bits besteht. 3. Der nächste Schritt verwendet 8 sogenannte S-Boxen. Jede S-Box ist eine Funktion Sj : {0, 1}6 → {0, 1}4 .

12

2.2

DES

Dabei wird die S-Box Sj auf Bj wie folgt angewendet: Sei B j = b 1 b2 b3 b4 b5 b6 . Dann gibt das binäre Wort b1 b6 die binäre Darstellung von einer Zeile in Sj an. Die restlichen 4 Bits b2 . . . b5 geben die binäre Darstellung einer Spalte von Sj an. Ausgabe ist Cj = Sj (Bj ) f¨ ur 1 ≤ j ≤ 8. 4. Der Bitstring C = C1 . . . C8 der Länge 32 wird mit der Permutation P permutiert; wir erhalten die Ausgabe f (Li , K i ) := P (C). Beispiel 2.2.2. Beispiel f¨ ur die Anwendung einer S-Box: Die S-Box S1 ist wie folgt gegeben:

0 1 2 3

1 2 3 14 4 13 0 15 7 4 1 14 15 12 8

4 5 6 7 1 2 15 11 4 14 2 13 8 13 6 2 2 4 9 1

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

14 15 16 9 0 7 5 3 8 10 5 0 0 6 13

Betrachte die Eingabe 100101. Das erste und letzte Bit zusammen ergeben das Wort 11. Dies definiert die Zeile der S-Box (hier also die Zeile mit der Nummer 3). Die vier mittleren Bits bilden das Wort 0010, also die Zahl 2. Wir muessen somit den dritten Eintrag in der vierten Zeile nehmen. Dies ist 8 und 8 hat die Binärdarstellung 1000. Wir erhalten S1 (100101) = 1000. 2.2.2

Berechnung der Rundenschl¨ ussel f¨ ur DES

Ein DES-Schl¨ ussel besteht aus 64 Bits. Davon sind aber nur 56 frei wählbar, denn es gilt K = {(b1 , . . . , b64 ) ∈ {0, 1}

64

:

8 X i=1

b8k+1 ≡ 1 mod 2, 0 ≤ k ≤ 7}.

Die ersten 7 Bits eines Bytes legen also das achte Bit fest! Es sei der Schl¨ ussel K ∈ {0, 1}64 gegeben. Daraus werden K i , 1 ≤ i ≤ 16 der Länge 48 erzeugt. Setze 1 i ∈ {1, 2, 9, 16} vi = 2 sonst und P C1 : {0, 1}64 → {0, 1}28 × {0, 1}28 , P C2 : {0, 1}28 × {0, 1}28 → {0, 1}48 . Durch folgende Schritte erhalten wir dann die Rundenschl¨ ussel.

2.3

13

AES

1. Setze (C0 , D0 ) = P C1 (K). 2. 1 ≤ i ≤ 16: Ci ← zirkulärer Linksshift um vi Stellen aus Ci−1 Di ← zirkulärer Linksshift um vi Stellen aus Di−1 . K i = P C2 (Ci , Di ). Dabei sind die Funktionen P C1 und P C2 wie folgt gegeben:

57 1 10 19 63 7 14 21

49 58 2 11 55 62 6 13

41 50 59 3 47 54 61 5

P C1 33 42 51 60 39 46 53 28

25 34 43 52 31 38 45 20

17 26 35 44 23 30 37 12

9 18 27 36 15 22 29 4

und

14 3 23 16 41 30 44 46

17 28 19 7 52 40 49 42

P C2 11 24 15 6 12 4 27 20 31 37 51 45 39 56 50 36

1 21 26 13 47 33 34 29

5 10 8 2 55 48 53 32

Sei K = k1 k2 . . . k64 , dann ist C = k57 k49 . . . k36 und D = k63 k55 . . . k4 . Der Wert von P C2 (b1 . . . b56 ) ist durch b14 b17 . . . b32 gegeben. 2.3

AES

Einer der Hauptnachteile des DES-Verfahrens ist die Tatsache, dass die Schl¨ ussellänge fest vorgegeben ist. So hat sich ergeben, dass einfaches DES (Schl¨ ussellänge 56) nicht mehr sicher ist. Daraus beschloß man nach Alternativen zu suchen. 1997 wurde ein internationaler Wettbewerb ausgeschrieben, um ein System zu finden, das dann den Namen AES (Advanced Encryption Standard) tragen sollte. Wir werden den Sieger dieses Wettbewerbs, das Verschl¨ usselungssystem Rijndael, in diesem Abschnitt vorstellen. Dieser wurde 2001 als Verschl¨ usselungsstandard eingef¨ uhrt. Er ber¨ ucksichtigt die Blocklängen 128 Bits, 192 Bits, 256 Bits. Beachte, dass 128 Bits nach heutigem Stand sicher sind (In ein paar Jahren kann sich dies aber ändern).

14

2.3

AES

Die Anzahl der Runden N ist von der gewählten Schl¨ ussellänge abhängig: Wir haben N = 10 f¨ ur 128, N = 12 f¨ ur 192 und N = 14 f¨ ur 256. Wir beschreiben wieder kurz das Schema des Algorithmus: Eingabe: x Ausgabe: y 1. x → x ⊕ Roundkey 2. F¨ uhre N −1 Runden durch. Jede der Runde besteht aus den Funktionen subbytes, shiftrows, mixcolumns, addroundkey. 3. In der N ten Runden f¨ uhren wir die Funktionen subbytes, shiftrows,addroundkey durch. 4. Ausgabe y. Bei unserer weiteren Beschreibung beschränken wir uns auf Schl¨ ussellänge 128, also 10 Runden. Der Nachrichtentext hat stets 128 Bits, also 16 Bytes x0 , . . . x15 . Wir stellen ihn durch eine 4 × 4 Matrix   x0 x4 x8 x12  x1 x5 x9 x13   (si,j )0≤i,j≤3 =   x2 x6 x10 x14  x3 x7 x11 x15 dar.

2.3.1

Darstellung der Bytes als Elemente in F28

Jedes xi ist ein Byte, d.h. es wird durch 8 Bits (b7 b6 . . . b0 ) dargestellt. Im AES Algorithmus werden diese xi mehrfach als Elemente des Körpers F28 aufgefasst. Betrachte das Polynom f (x) = x8 + x4 + x3 + x + 1 ∈ F2 [x]. Dieses ist irreduzibel, also definiert es einen Körper vom Grad 8 u ¨ber F2 . Sei α ein Nullstelle. Dann erhalten wir F28 ' F2 (α). Einem Byte b = (b7 b6 . . . b0 ) ordnen wir nun das Element 7 X bi α i i=0

zu. Somit können Bytes multipliziert und addiert werden und falls b nicht der Nullvektor ist, können wir sie auch invertieren. Um eine Fallunterscheidung zu umgehen, setzen wir 0−1 := 0. Wir beschreiben noch kurz die Teilfunktionen.

2.3

15

AES

2.3.2

subbytes(a7 a6 . . . a0 )

Diese Funktion transformiert die einzelnen Bytes, d.h. sie erhält als Eingabe xi = (b7 b6 . . . b0 ). Sei z das Element 7 X bi α i ∈ F 28 . i=0

Setze z := z −1 . F¨ uhre nun folgende Operationen aus:

(b7 b6 . . . b0 ) := field to binary(z); (c7 c6 . . . c0 ) := (01100011); (Die Funktion field to binary wandelt ein Element in F28 wieder in eine Binärzahl um.) Zum Schluss durchlaufen wir noch eine Schleife: for i = 0 to 7 ai := (bi + bi+4 + bi+5 + bi+6 + bi+7 + ci )

mod 2

end for; Die Ausgabe von subbytes ist nun (b7 b6 b5 b4 b3 b2 b1 b0 ).

2.3.3

shiftrows

Diese Funktion permutiert die Einträge in der  s00  s11 (sij )0≤i,j≤3 =   s22 s33 2.3.4

Matrix (sij )0≤i,j≤3 wie folgt:  s01 s02 s03 s12 s13 s10  . s23 s20 s21  s30 s31 s32

mixcolumns

Die Routine mixcolumns operiert auf den vier Spalten des Eingabeelementes. Schreibe die Spalten in der Form   t0  t1     t2  ∈ F 2 8 t3 und multipliziere mit



 α α+1 1 1  1 α α+1 1    ∈ M4,4 (F28 )  1 1 α α+1  α+1 1 1 α

16

2.3

von links.

AES

 u0  u1   So erhalten wir einen Vektor   u2 , der die transformierte Spalten der Ausgabenmatrix u3 darstellt.

2.3.5



Die Berechnung der Schl¨ ussel

Wir beschreiben noch wie wir aus K mit 128 Bits 11 Rundenschl¨ ussel und einen weiteren Schl¨ ussel (den 0-ten Rundenschl¨ ussel) erhalten . Jeder Rundenschl¨ ussel besteht aus 16 Bytes. Aus K wird ein erweiterter Schl¨ ussel berechnet, der aus 44 Worten von je 4 Bytes besteht w[0], . . . , w[43]. F¨ ur die 0te Runde wird w[0], . . . , w[3], f¨ ur die erste Runde w[4] . . . w[7] verwendet usw. Der folgende Algorithmus beschreibt die Erzeugung der w[i] aus K. Dabei sei der 128Bit-Schl¨ ussel K in 16 Worte key[1], . . . , key[16] aufgeteilt (16 · 8 = 128). Setze Rcon[1] := 01000000 Rcon[2] := 02000000 Rcon[3] := 04000000 Rcon[4] := 08000000 Rcon[5] := 10000000 Rcon[6] := 20000000 Rcon[7] := 40000000 Rcon[8] := 80000000 Rcon[9] := 1B000000 Rcon[10] := 36000000. F¨ ur i = 0 bis 3 berechne w[i] := (key[4i], key[4i + 1], key[4i + 2], key[4i + 3]) . F¨ ur i = 4 bis 43 setze temp:=w[i-1]; falls i ≡ 0 mod 4 temp:=Subword(Rotword(temp)⊕Rcon[i/4]); w[i] := w[i − 4] ⊕ temp; Ausgabe (w[0], . . . , w[43]) Rotword(B0 , B1 , B2 , B3 ) = (B1 , B2 , B3 , B0 ) Subword(B0 , B1 , B2 , B3 ) = (B00 , B10 , B20 , B30 ) Bi0 =Subbytes(Bi )

2.4

Angriffe auf symmetrische Kryptosysteme

2.3.6

17

Entschl¨ usselung

Die Geheimtexte werden nun durch eine Funktion entschl¨ usselt, bei der die einzelnen Verschl¨ usselunsfunktionen wie z.B. shiftrows, mixcolumns invertiert werden. Wir laufen dann alle Runden r¨ uckwärts durch. 2.4


Die beiden wichtigsten Angriffe auf iterierte symmetrische Kryptosysteme (wie DES und AES) sind die lineare und differentielle Kryptoanalyse. Beide funktionieren f¨ ur Triple-DES (eine Variante von DES) bzw. AES nicht. Wenn man aber z.B. die Rundenanzahl f¨ ur DES hinunterschraubt, dann kann man mit differentieller Kryptoanalyse den Schl¨ ussel berechnen. Wir werden also nun die Idee von differentieller Kryptoanalyse an einem 3-Runden DES demonstrieren. Wir ignorieren die Permutation am Anfang und Ende, da diese öffentlich bekannt ist. Sei also L0 R0 der Nachrichtentext und Ln Rn der Geheimtext in einem n-Runden DES. Differentielle Kryptoanalyse vergleicht das XOR zweier S-Box Eingaben mit dem XOR zweier S-Box Ausgaben. (Daher auch die Bezeichung “differentiell”, da wir XOR als Differenz betrachten können. XOR ist an den Stellen von 0 verschieden, an denen sich zwei Werte unterscheiden.) Definition 2.4.1. Sei Sj eine bestimmte S-Box (1 ≤ j ≤ 8). Es sei Sj (Bj ) die Ausgabe der S-Box Sj bei Eingabe von Bj . Dann heißt Bj ⊕ Bj∗ der XOR-Eingabewert bzw. Sj und Sj (Bj ) ⊕ Sj (Bj∗ ) der XOR-Ausgabewert. F¨ ur jedes Bj0 setze δ(Bj0 ) := {(Bj , Bj ⊕ Bj0 ) : Bj ∈ (Z/2Z)6 }.

F¨ ur jedes Paar δ(Bj0 ) können wir den XOR-Output von Sj berechnen. Es stellt sich heraus, dass die Ausgaben nicht gleichverteilt sind (siehe Tabelle). Diese Diskrepanz können wir unter gewissen Voraussetzungen ausnutzen, um Informationen u ussel zu erhalten. ¨ber den Schl¨ F¨ ur 1 ≤ j ≤ 8 setze INj (Bj0 , Cj0 ) = Bj ∈ (Z/2Z)6 : Sj (Bj ) ⊕ Sj (Bj ⊕ Bj0 ) = Cj0 und

Nj (Bj0 , Cj0 ) = |INj (Bj0 , Cj0 )|. Angenommen wir haben zwei Nachrichtentexte x1 und x2 . Die Eingabe einer S-Box in Runde i zu x1 sind festvorgegebene Bits von B = E ⊕ J = E(Ri−1 ) ⊕ K i . Analog erhalten wir B ∗ f¨ ur x2 . Dann gilt B ⊕ B∗ = E ⊕ J ⊕ E ∗ ⊕ J = E ⊕ E ∗.

18

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

2.4

S(Bj ) ⊕ S(Bj0 ) #{Bj : S1 (Bj ) ⊕ S1 (Bj ⊕ Bj0 ) = C} 2 4 4 6 2 0 4 6 2 0 6 8 4 6 4 6

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


S(Bj ) ⊕ S(Bj ⊕ Bj0 ) #{Bj : S2 (Bj ) ⊕ S2 (Bj ⊕ Bj0 ) = C} 2 0 4 0 8 6 6 0 0 2 0 6 4 8 2 14

Tabelle 1: Verteilung f¨ ur Bj = (0, 1, 0, 0, 1, 1); zum Vergleich: #{Bj : S(Bj ) ⊕ S(Bj0 ) = C} = 4 f¨ ur alle S = Si und alle C ∈ {1, . . . , 16}

Somit hängt der XOR-Eingabewert nicht von den Schl¨ usselbits ab (der XOR-Ausgabewert jedoch schon!). Sei B = B 1 B2 . . . B8 E = E 1 E2 . . . E8 J = J1 J2 . . . J8 (Schl¨ usselbits von K i ) und analog B ∗ , E ∗ . Angenommen wir kennen Ej , Ej∗ f¨ ur ein j, 1 ≤ j ≤ 8, und die Ausgabe Cj = Sj (Bj ) ⊕ Sj (Bj∗ ). Dann gilt Ej ⊕ Jj ∈ INj (Ej0 , Cj )

mit Ej0 = Ej ⊕ Ej∗ . (denn S(Ej ⊕ Jj ) ⊕ Sj (Ej ⊕ Jj ⊕ Ej ⊕ Ej∗ ) = S(Ej ⊕ Jj ) ⊕ Sj (Jj ⊕ Ej∗ ) = Cj ). Nat¨ urlich kennen wir nicht Bj , Bj∗ , denn dann w¨ urden wir bereits den Schl¨ ussel kennen! Definition 2.4.2. Angenommen Ej , Ej∗ sind Bitstrings der Länge 6, Cj ist ein Bitstring der Länge 4 wie oben beschrieben. Setze testj (Ej , Ej∗ , Cj ) := {Ej ⊕ Bj : Bj ∈ INj (Ej0 , Cj )} mit Ej0 = Ej ⊕ Ej∗ .

2.4

19


Dann enthält testj (Ej , Ej∗ , Cj ) den Schl¨ usselstring Jj . Die Menge testj (Ej , Ej∗ , Cj ) enthält dann genau Nj (Ej0 , Cj ) Bitstrings. ˜ ∗ , C˜j haben, m¨ Falls wir ein zweites Triple E˜j , E ussen die mögliche Werte f¨ ur Jj im Schnitt j ˜ ∗ , C˜j ) testj (Ej , Ej∗ , Cj ) ∩ testj (E˜j , E j liegen. Sind viele solche Tripel gegeben, können wir Jj schnell ermitteln. Wir verwenden dies nun f¨ ur einen Angriff auf DES mit n = 3. Wir starten mit einem Paar von Nachrichtentexten und den zugehörigen Geheimtexten L0 R 0 L0∗ R∗0

L3 R 3

L3∗ R∗3 . Diese wählen wir später noch geeignet. Es gilt R3 = L2 ⊕ f (R2 , K 3 ) = R1 ⊕ f (R2 , K 3 ) = L0 ⊕ f (R0 , K 1 ) ⊕ f (R2 , K 3 ) (denn R1 = L2 und L0 ⊕ f (R0 , K 1 ) = R1 ) und R∗3 = L0∗ ⊕ f (R∗0 , K 1 ) ⊕ f (R∗2 , K 3 ). Somit gilt R˜3 = R3 ⊕ R∗3 = L0 ⊕ L0∗ ⊕ f (R0 , K 1 ) ⊕ f (R∗0 , K 1 ) ⊕ f (R2 , K 3 ) ⊕ f (R∗2 , K 3 ). Wir wählen nun R0 = R∗0 . Dann ergibt sich

R˜3 = L˜0 ⊕ f (R2 , K 3 ) ⊕ f (R∗2 , K 3 ).

Wir kennen R˜3 und L˜0 und wir haben

R˜3 ⊕ L˜0 = f (R2 , K 3 ) ⊕ f (R∗2 , K 3 ). Weiter gilt f (R2 , K 3 ) = P (C) und f (R∗2 , K 3 ) = P (C∗ ) mit C, C∗ sind die Ausgaben aus den 8 S-Boxen und P ist eine bekannte Permutation. Wir haben somit C 0 = C ⊕ C∗ = P −1 (R˜3 ⊕ L˜0 )

¨ (siehe Ubungsaufgabe 2.6, Nr. 3). Nun kennen wir auch E = E(L3 ) = E(R2 ) und E∗ = E(L3∗ ) = E(R∗2 ). Betrachte nun das Tripel E, E∗ und C 0 = P −1 (R˜3 ⊕ L˜0 ) (alle drei Daten sind uns bekannt). Dann liegen die 48 Bits des Schl¨ usselstrings in den entsprechenden

20

2.5

Modes of Operations

Mengen test1 , . . . , test8 . Falls wir mehrere solche Tripel gegeben haben, können wir nun die Schnitte der Mengen test1 , . . . , test8 bestimmen. Wir finden so 48 Bits des Schl¨ usselstrings. Die restlichen können wir durch einfaches Durchprobieren ermitteln. Beispiel: Betrachte L0 := [1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1] : R0 := [1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0] : L0∗ := [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0] : R∗0 := R0 :

L3 := [0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0] : R3 := [0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1] : L3∗ := [1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1] : R∗3 := [0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0].

Wir nehmen der Einfachheit halber an, dass P =id. Somit ist das Tripel (E, E∗ , C 0 ) gegeben durch E :=

[0, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0] E∗ := [1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1] C 0 := [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0]. Wir können nun sukzessive test1 , . . . , test8 berechnen. So erhalten wir z.B. test1 = {[0, 1, 0, 1, 1, 0], [1, 0, 0, 0, 1, 1]} und test2 ={[0,0,1,0,1,1],[0,0,0,1,0,1],[0,1,1,1,1,1],[0,1,0,0,0,1],[1,0,1,0,1,0],[1,1,1,1,1,0]}.

2.5

Modes of Operations

Ein Blockchiffre der Länge ` kann Nachrichten der Länge ` verschl¨ usseln. In der Regel ist unser Nachrichtentext jedoch viel länger. Um längere Nachrichten zu verschl¨ usseln, m¨ ussen wir definieren, wie der Blockchiffre angewendet wird. Daf¨ ur gibt es mehrere Möglichkeiten:

21

¨ Ubungsaufgaben

2.6

• ECG-mode (electronic code book mode) x1 x2 ↓↓ y1 y2

. . .xi ↓↓ . . .yi

Vorteile: Veränderung von xj , ändert nur yj . Nachteile: gleiche Textteile werden gleich verschl¨ usselt, ung¨ unstig, falls Text wenig Veränderung enthält • CBC-mode (cipher block chaining mode) y0 := IV ; (initial value) yi := eK (yi−1 ⊕ xi ); ¨ Vorteile: gut f¨ ur Authentikation, da Anderung von yi auch alle anderen Blöcke verändert. • OFB (output feedback mode) Aus dem Schl¨ ussel wird ein Schl¨ usselstrom erzeugt. z0 := IV ; zi = eK (zi−1 ); yi = xi ⊕ z i . Vorteile: Veränderung von xj ändert nur yj . Gut falls gemeinsamer Kanal nicht vertrauensw¨ urdig - Satelliten¨ ubermittelung, • CFB (cipher feedback mode) y0 := IV ; zi = eK (yi−1 ); yi = xi ⊕ z i . Vorteile: gut f¨ ur Authentikation (siehe oben). 2.6

¨ Ubungsaufgaben

1. Betrachte den multiplikativen Cipher gegeben durch P = C = Z/26Z mit K = {a ∈ Z/26Z : ggT(a, 26) = 1}. F¨ ur alle a ∈ K setze ea (x) = ax

mod 26

und da (y) = a−1 y

mod 26.

Berechne die Produkt-Chiffren M × S und S × M f¨ ur S den Shift Cipher!

22

2.6

¨ Ubungsaufgaben

2. Es gibt genau 4 DES-Schl¨ ussel, f¨ ur die alle Teilschl¨ ussel gleich sind. Welche sind das? 1 2 16 (Hinweis: Falls K = K = . . . = K , dann sind alle Bits in C1 und D1 gleich, denn C16 und D16 gehen aus C1 und D1 durch zirkulären Rechtsshift der Länge 1 hervor.) Gibt es auch solche Schl¨ ussel f¨ ur AES? 3. Gegeben a, b ∈ {0, 1}. Dann ist a ⊕ b (a XOR b) die Addition in F2 . Erstelle eine Wahrheitstafel f¨ ur XOR. Zwei beliebige Strings in {0, 1} werden wir folgt addiert: a 1 . . . a n ⊕ b 1 . . . bn = c 1 . . . cn mit ci = ai ⊕ bi . Zeige, falls P eine Permutation von {1, . . . , n}, dann gilt P (a) ⊕ P (b) = P (a ⊕ b). 4. Gegeben R = (Z/26Z)∗ . Bestimme die Anzahl der multiplikativen Einheiten in R und berechne 5−1 in R. 5. Konstruiere den Körper mit 128 Elementen, bestimme ein primitives Element α und berechne α−1 . 6. Entschl¨ ussele folgende Nachrichten! (a) nubswrpdfkwvsdvv (b) gtgehgldqetovcxezddethmgitqhulukfqviuzfcpmdqzphuezdozugvbclmgehuxhmbcq 7. Sei x das bitweise Komplement von x. Sei EK eine DES-Verschl¨ usselungsfunktion. Zeige: EK (P ) = C falls EK (P ) = C. 8. In vielen Textb¨ uchern findet sich folgende Beschreibung f¨ ur die Funktion mixcolumn: Sei sj = (s0,j , s1,j , s2,j , s3,j ) eine Spalte der Eingabematrix. Betrachte dazu das Polynom s(x) = s0,j + s1,j x + s2,j x2 + s3,j x3 ∈ F28 [x] und das Polynom a(x) = (α + 1)x3 + x2 + x + α mit F2 (α) = F28 . Dann werde die Ausgabe von mixcolumn durch tj = (t0,j , t1,j , t2,j , t3,j ) gegeben, wobei t0,j + t1,j x + t2,j x2 + t3,j x3 ≡ s(x) · a(x)

mod x4 + 1.

Zeige, daß diese Beschreibung mit der Beschreibung in Abschnitt 2.3.4 u ¨bereinstimmt.

2.7

23

Appendix

9. F¨ ur Progammierfreaks: Zeige, dass bei einem 3-Runden DES folgende Konfiguration nicht möglich ist: L0 := [1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1] : R0 := [1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0] : L02 := [1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0] : R02 := R0 : L3 := [0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0] : R3 := [0, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1] : L32 := [0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1] : R32 := [0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0] :

Tipp: Zeige test1 = ∅. 2.7

Appendix

Einige weitere Informationen zu DES (falls jemand die letzte Aufgabe bearbeiten möchte, oder das Beispiel zur differentiellen Kryptoanalyse nachvollziehen will): Die Expansionsfunktion E vec[32] vec[4] vec[8] vec[12] vec[16] vec[20] vec[24] vec[28]

vec[1] vec[5] vec[9] vec[13] vec[17] vec[21] vec[25] vec[29]





Die Expansionsfunktion erhält als Eingabe einen Bitstring der Länge 32, A = (a1 , . . . , a32 ), und gibt einen Bitstring der Länge 48 zur¨ uck: E(A) = (a32 , a1 , a2 , . . . , a1 ). Die S-Box S1 : 14 4 13 1 2 15 11 8 3 10 6 12 5 9 0 7 0 15 7 4 14 2 13 1 10 6 12 11 9 5 3 8 4 1 14 8 13 6 2 11 15 12 9 7 3 10 5 0 15 12 8 2 4 9 1 7 5 11 3 14 10 0 6 13

24

2.7

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

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

Die S-Box S3 : 10 0 9 14 6 3 15 5 1 13 12 7 11 4 2 8 13 7 0 9 3 4 6 10 2 8 5 14 12 11 15 1 13 6 4 9 8 15 3 0 11 1 2 12 5 10 14 7 1 10 13 0 6 9 8 7 4 15 14 3 11 5 2 12 Die S-Box S4 : 7 13 14 3 0 6 9 10 1 2 13 8 11 5 6 15 0 3 4 7 10 6 9 0 12 11 7 13 15 1 3 15 0 6 10 1 13 8 9 4

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

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

0 14 9 9 8 6 3 0 14 4 5 3

Die S-Box S6 : 12 1 10 15 10 15 4 2 9 14 15 5 4 3 2 12

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

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

Appendix

2.7

25

Appendix

Die S-Box S8 : 13 2 8 1 15 13 7 11 4 2 1 14

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

26

3

Public Key Kryptographie - Asymmetrische Verschlu ¨ sselung

Der Nachteil der symmetrischen Verfahren ist offenkundig: Schl¨ ussel m¨ ussen u ¨ ber einen sicheren Kanal ausgetauscht werden. Die Existenz eines solchen Kanals ist nicht immer realistisch. Die Public-Key-Kryptographie (asymmetrische Verfahren) beruht nun auf folgender Idee: Verwende zwei unterschiedliche Schl¨ ussel, einen geheimen (privaten) und einen öffentlichen Schl¨ ussel. Der öffentliche Schl¨ ussel ist allgemein bekannt; er kann z.B. auf einer Internetseite veröffentlicht werden. Der private Schl¨ ussel, der aus dem öffentlichen Schl¨ ussel und den Systemparametern berechnet wird, ist nur dem Empfänger (bei Verschl¨ usselungssystemen) oder dem Absender (bei Signaturverfahren) der Nachricht bekannt. Beispiel 3.0.1 (Eine nicht-mathematische Realisierung). Betrachte eine Schachtel, ¨ die sich nach einfachem Zudr¨ ucken ohne Schl¨ ussel nicht mehr öffenen lässt. Offnen lässt sie sich nur durch einen Schl¨ ussel, den Alice besitzt. Bob legt nun eine Nachricht in die Schachtel, dr¨ uckt den Deckel zu und sendet die Schachtel an Alice. Mit Mathematik lässt sich diese Idee auch eleganter realisieren. Der Schl¨ ussel besteht hier nun immer aus einem Schl¨ usselpaar K = (ks , kp ), ks der geheime (secret) Schl¨ ussel und kp der öffentliche (public) Schl¨ ussel. Es soll weiter gelten: F¨ ur jedes K = (ks , kp ) existieren eine Verschl¨ usselungsfunktion ekp und eine Entschl¨ usselungsfunktion dks mit dks (ekp (x)) = x. Dies wird mathematisch durch sogenannte Einwegfunktionen realisiert. Dies sind Funktionen, die sich leicht ausf¨ uhren, aber schwer invertieren lassen. Beispiel 3.0.2 (Die RSA-Einwegfunktion). Es sei n = p · q mit p und q große Primzahlen. Setze ϕ(n) = (p − 1)(q − 1) und betrachte die Funktion f : (Z/nZ)∗ → (Z/nZ)∗ f (x) ≡ xe mod n, (e, ϕ(n)) = 1. Behauptung: Dann existiert ein d mit x = f (x)d mod n. Beweis: Es gilt (Z/nZ)∗ ' (Z/pZ)∗ × (Z/qZ)∗

¨ (siehe Ubungsaufgaben 3.6, Nr. 1). Somit haben wir | (Z/nZ)∗ | = (p − 1)(q − 1). F¨ ur alle x ∈ (Z/nZ)∗ gilt

xϕ(n) ≡ 1 mod n.

3.1

Probabilistische Algorithmen

27

Falls nun (e, ϕ(n)) = 1, dann existiert ein d mit ed ≡ 1 mod ϕ(n), bzw. ed = 1 + kϕ(n) (nach dem euklidischen Algorithmus). Es folgt (xe )d = xed = x1+kϕ(n) ≡ x mod n. Wir erhalten ein Public Key Kryptosystem (das RSA-Kryptosystem, benannt nach seinen Erfindern Rivest, Shamir und Adleman): Der öffentliche Schl¨ ussel besteht aus dem Paar (n, e), der private Schl¨ ussel ist e. Sei x eine e Nachricht. Dann verschl¨ usseln wir diese, indem wir y := x mod n bilden. Der Besitzer des geheimen Schl¨ ussels kann dann durch x := y d mod n die Nachricht entschl¨ usseln. Alle anderen stehen vor dem Problem, dass sie f¨ ur e den zugehörigen privaten Schl¨ ussel d bestimmen m¨ ussen. Falls wir n faktorisieren können, können wir auch ϕ(n) berechnen und dann mit dem euklidischen Algorithmus auch d. Wenn wir also in der Lage sind, große Zahlen effizient zu faktorisieren, ist die oben angegebene Funktion keine Einwegfunktion und das System gebrochen. Die Umkehrung ist offen. Es gibt aber Teilresultate (siehe Kapitel 5). Bemerkung 3.0.3. 1. Public Key Kryptosysteme bieten keine absolute/perfekte Sicherheit, denn wir können dK (x) bestimmen, indem wir f¨ ur alle x testen, ob y = ekp (x). 2. Public Key Kryptosysteme sind langsam. Deshalb werden in der Praxis oft hybride Verschl¨ usselungssysteme eingesetzt. Dies bedeutet, dass die Schl¨ ussel mit einem Public Key Verfahren ausgetauscht werden. Danach erfolgt die Verschl¨ usselung mit einem symmetrischen System. Ein Beispiel daf¨ ur ist das heute vielfach eingesetzte PGP, pretty good privacy. Bevor wir Beispiele betrachten, m¨ ussen wir einige Konzepte einf¨ uhren. 3.1

Probabilistische Algorithmen

In der Komplexitätstheorie betrachtet man die Klasse P , die von einer deterministischen Turingmaschine in polynomieller Zeit erkannt werden. Grob gesprochen sind dies die Probleme, die man mit einem deterministischen Algorithmus in polynomieller Zeit lösen kann. Dieses sind nun sicher Probleme, die effizient gelöst werden können. Allerdings reicht uns diese Definition nicht aus. Unter einem effizienten Algorithmus werden wir nun auch Probleme verstehen, die von einer probabilistischen Turingmaschine in polynomieller Zeit erkannt werden. In anderen Worten: Dies sind Probleme, f¨ ur die es einen polynomialzeit Algorithmus gibt, der zu seiner Eingabe auch noch Zufallsbits erhält. Diese Anzahl der Zufallsbits soll ebenfalls polynomiell in der Eingabegröße beschränkt sein. Weiter liefert eine solcher Algorithmus nicht unbedingt immer das richtige Ergebnis. Wir fordern nur, dass er mit Wahrscheinlichkeit ≥ 23 das richtige Ergebnis liefert. Ein solcher Algorithmus heißt dann probabilistisch polynomieller Algorithmus oder auch Monte Carlo Algorithmus.

28

3.2

Einwegfunktionen

Zusätzlich betrachten wir auch Las Vegas Algorithmen. Dies sind ebenfalls probabilistische Algorithmen, d.h. sie verwenden Zufallsbits. Ein solcher Algorithmus liefert immer die richtige Ausgabe, hat aber nur erwartet polynomielle Laufzeit. Dies bedeutet, dass ein Polynom p existiert, so dass f¨ ur alle Eingaben x gilt: E(Laufzeit) =

∞ X t=1

t · W s(A braucht t Schritte) ≤ p(|x|).

Ein Las Vegas Algorithmus kann in einen Monte Carlo Algorithmus transformiert werden. Die Umkehrung ist nicht bekannt. Insbesondere ist nat¨ urlich jeder polynomielle Algorithmus ein probabilistisch polynomieller Algorithmus. Er ist ein probabilistisch polynomieller Algorithmus, der keine Zufallsbits verwendet und immer das richtige Ergebnis liefert. Notation: Sei M eine endliche Menge. Falls x in M enthalten ist, schreiben wir gewöhnlich x ∈ M . Die Bezeichnung x ∈R M verwenden wir nun, um zu beschreiben, dass x zufällig, gleichverteilt aus M gewählt wird. Beispiel 3.1.1. Sei n ∈ N, n = p · q, p, q prim, gegeben. Angenommen, wir wollen einen Teiler finden. Dann können wir folgenden Algorithmus verwenden: Wähle ein a ∈R Z/Z. Teste, ob d := ggT(a, N ) > 1. Falls ja, gebe den Teiler d aus. Sonst starte den Algorithmus erneut. Diese Algorithmus ist probabilistisch. Er ist aber nicht polynomiell, da er keine polynomielle Laufzeit hat. In jeder Runde werden nur polynomiell viele Zufallsbits in der Eingabelänge benötigt, aber im Allgemeinen ist die Anzahl der Runden nicht durch ein Polynom in der Eingabelänge (hier: log n) beschränkt. 3.2

Einwegfunktionen

Wir wollen den Begriff der Einwegfunktion formal definieren. Definition 3.2.1. Eine Funktion v heißt vernachl¨ assigbar, falls sie schneller gegen 0 geht als jedes Polynom, d.h. f¨ ur alle k ≥ 0 existiert ein nk mit v(n) < n−k

f¨ ur alle n ≥ nk .

Definition 3.2.2. Eine Funktion f : {0, 1}∗ → {0, 1}∗ heißt Einwegfunktion, falls

1. ein probabilistischer polynomieller Algorithmus existiert, der bei Eingabe von x den Wert f (x) ausgibt,

2. f¨ ur alle probabilistischen polynomiellen Algorithmen A eine vernachlässigbare Funktion vA existiert, so dass f¨ ur hinreichend große Eingaben die Wahrscheinlichkeit, dass A erfolgreich terminiert, durch vA beschränkt ist, d.h. f¨ ur hinreichend großes k gilt Ws(f (z) = y|x ∈R {0, 1}n ; f (x) → y; A(1n , y) → z) ≤ vA (n). Bemerkung 3.2.3. 1. Wir verwenden nun die Pfeilschreibeweise anstatt y := f (x). Dies soll andeuten, dass die Ausgabe von den Zufallsbits von A abhängt.

3.2

29

Einwegfunktionen

2. Der Angreifer kann f invertieren, aber nur mit einer verschwindend kleinen Wahrscheinlichkeit. Der Angreifer A kann den Nachrichtentext zum Beispiel einfach erfolgreich raten. 3. Die Ausgabe von f ist polynomiell in n bestimmt, da f ein polynomieller Algorithmus ist. 4. Die Länge von x (d.h. 1n ) ist Eingabe von A, damit A |x| Operationen ausf¨ uhren kann. Dies verhindert, dass f Einwegfunktion ist, nur weil |y| = |f (x)| viel kleiner als |x| ist. Eine Funktion soll nicht deshalb Einwegfunktion sein, weil die Element im Bild klein sind. 5. Die Definition enthält Asymptotik. Es wird nichts u ¨ ber die Schwierigkeit der Invertierbarkeit f¨ ur Eingaben beschränkter Länge ausgesagt. Dies spielt in der Praxis jedoch gerade die entscheidende Rolle. 6. Es ist nicht bekannt, ob Einwegfunktionen existieren. Definition 3.2.4. Sei I eine Menge von Indizes. F¨ ur i ∈ I gibt es endliche Menge Di und Ri . Eine Familie von Einwegfunktionen ist eine Menge F von probabilistischen polynomiellen Funktionen {fi : Di → Ri }i∈I mit Folgenden Bedingungen (alle Algorithmen seien im folgenden probablistische polynomielle Algorithmen): 1. Es gibt einen Algorithmus S1 , der bei Eingabe 1n eine Ausgabe i ∈ {0, 1}n ∩ I liefert. 2. Es gibt einen Algorithmus S2 , der bei Eingabe i ∈ I ein x ∈ Di liefert. 3. Es gibt einen Algorithmus A1 mit A1 : I × Di → Ri ; A1 (i, x) := fi (x). 4. F¨ ur jeden Algorithmus A gibt es eine vernachlässigbare Funktion vA so dass f¨ ur alle n hinreichend groß W s(fi (z) = y|S1 (1n ) → i ∈ I; S2 (i) → x ∈ Di ; f i(x) → y; A(i, y) → z) ≤ vA (n). Beispiel 3.2.5. Betrachte wieder das obige Beispiel. Setze INVERT MOD N := {IN Vx,n (b) = xb

mod n; IN Vx,n : (Z/nZ)∗ → (Z/nZ)∗ }.

Dies ist genau dann eine Familie von Einwegfunktionen, wenn die in Beispiel 3.0.2 betrachtete Funktion eine Einwegfunktion ist. Allgemein gilt: Eine Familie von Einwegfunktionen existiert genau dann, wenn Einweg¨ funktionen existieren (siehe Ubungsaufgaben 3.6). Als nächstes betrachten wir Einwegfunktionen, die eine zusätzliche Eigenschaft, die Trapdoor-Eigenschaft, besitzen. F¨ ur eine solche Funktion existiert eine geheime Zusatzinformation, die es erlaubt, die Funktion effizient zu invertieren. Genauer:

30

3.3

Definition eines Public Key Systems

Definition 3.2.6. Eine Trapdoor-Funktion ist eine Einwegfunktion f : {0, 1}∗ → {0, 1}∗ so dass ein Polynom p und ein probabilistischer Algorithmus I existiert, so dass es f¨ ur alle n ein tn ∈ {0, 1}∗ gibt mit |tn | ≤ p(n) und f¨ ur alle x ∈ {0, 1}n , I(f (x), tn ) = z so dass f (z) = f (x). Diese Definition lässt sich wieder auf Familien von Trapdoorfunktionen erweitern. Beispiel 3.2.7. Betrachte wieder die Funktion aus dem Beispiel 3.0.2. Dann ist ϕ(n) eine Trapdoor-Funktion. 3.3

Definition eines Public Key Systems

Wir m¨ ussen nun unsere Definition von Verschl¨ usselungssysstem noch einmal u ¨berarbeiten. Public Key Systeme m¨ ussen nicht unbedingt auf eine bestimmte Schl¨ ussellänge zugeschnitten sein. Sie sind im Allgemeinen viel flexibler als symmetrische Verfahren. Mit der gleichen Einwegfunktion lassen sich Nachrichten unterschiedlicher Länge verschl¨ usseln. Wir m¨ ussen deshalb auch unsere Definition etwas flexibler gestalten. Angenommen wir haben eine Familie P = {Pn |n ∈ N} von Nachrichtenräume Pn . Die Nachrichten in Pn sind alle in {0, 1}n . Wir nehmen an, dass die Wahrscheinlichkeitsverteilung auf diesen Räumen die Gleichverteilung ist. Dies bedeutet, falls x ∈ Pn fest und wir wählen ein y ∈ Pn aus, dann gilt: Ws(x = y) = |P1n | . Dies ist nur zur Vereinfachung, wir könnten auch jede beliebige andere Wahrscheinlichkeitsverteilung annehmen. Definition 3.3.1. Ein Public Key Kryptosystem f¨ ur P ist ein probabilistischer polynon mieller Algorithmus C, der bei Eingabe von 1 zwei polynomielle Algorithmen ekp : Pn → ur ein ` ∈ N auswählt, so dass {0, 1}` und dks : {0, 1}` → Pn f¨ • ekp ist probablistisch, dks deterministisch und • f¨ ur alle m ∈ Pn gilt, dass der Geheimtext wird stets richtig entschl¨ usselt, unabhängig ur alle m ∈ Pn von den Zufallsbits von C und ekp . Dies bedeutet, f¨ Ws(dks (c) = m|(ekp , dks ) ← C(1n ); c ← ekp (m)) = 1. 3.4

Sicherheitsbeweise

Einwegfunktionen werden in Kryptosysteme eingebettet. Es kann dann aber sein, dass das System leichter zu brechen ist, als die Einwegfunktion invertiert werden kann. Wir m¨ ussen also bei einem Kryptosystem wirklich beweisen, dass es auf der Schwierigkeit der Invertierung basiert. Zählen wir einmal auf, was wir intuitiv von einem Kryptosystem erwarten: • privater Schl¨ ussel nicht aus dem öffentlichen Schl¨ ussel berechenbar • mit hoher Wahrscheinlichkeit soll es nicht möglich sein, verschl¨ usselte Nachrichten zu entschl¨ usseln • keine n¨ utzliche Info kann aus der verschl¨ usselten Nachricht gewonnen werden

3.4

31

Sicherheitsbeweise

• Angreifer soll auch keine anderen Infos erhalten, z.B. dass mehrmals die gleiche Nachricht versandt wurde. Wir unterscheiden folgende Angriffe: 1. vollständige Zerstörung: Schl¨ ussel wird gefunden! 2. partielle Zerstörung: der Angriff ist f¨ ur Geheimtexte mit einer bestimmten Wahrscheinlichkeit erfolgreich; man erhält Information u ¨ ber Geheimtexte oder Nachrichtentexte. 3. Unterscheidbarkeit: Mit Wahrscheinlichkeit 21 + , > 0 kann der Angreifer Geheimtexte zweier unterschiedlicher Nachrichten unterscheiden bzw. einen Geheimtext von einem zufälligen Text unterscheiden. Wir geben nun zwei Definitionen von Sicherheit. 3.4.1

Polynomielle Ununterscheidbarkeit

In Worten: Ein System ist polynomiell ununterscheidbar, falls kein Angreifer zwei Nachrichten finden kann, deren Verschl¨ usselung er unterscheiden kann. Obwohl der Angreifer weiss, dass c Verschl¨ usselung von einer der beiden Nachrichten m0 , m1 ist! Definition 3.4.1. Ein PKC ist polynomiell ununterscheidbar, falls es eine vernachlässigbare Funktion v(n) gibt, so dass f¨ ur jeden probablistischen polynomiellen Algorithmus A, der vier Eingaben nimmt und 0 oder 1 ausgibt und f¨ ur jedes n hinreichend groß gilt: F¨ ur alle m0 , m1 ∈ Pn der Länge n haben wir Ws(A(ekp , m0 , m1 , c) = i|ekp ← C(1n ), i ∈R {0, 1}; c ← ekp (mi ))
0 ungerade, m1 ≡ m2 mod n, dann gilt m m 2 1 = . n n

(b) Falls n > 0 ungerade,

(c) Es gilt m = 2k t, t ungerade,

2 1 n ≡ ±1 mod 8 = −1 n ≡ ±3 mod 8. n m m m m 1 2 1 2 = , n n n m n

k 2 t = . n n

38

3.6

¨ Ubungen

(d) m, n > 0 ungerade, m n

(e) Bestimme

=

n −( m ) m ≡ n ≡ 3 mod 4 n (m) sonst.

7411 9283

unter Verwendung der soeben bewiesenen Regeln. (f) Zeige, dass Jacobisymbol kann in O((log n)2 ) Schritten berechnet werden. (g) Sei n > 1 ungerade und ` Y n= pei i i=1

und (a, n) = 1. Dann hat die Gleichung y 2 ≡ a mod n in y 2` Lösungen modulo n, falls pai = 1 f¨ ur alle i ∈ {1, . . . , `} und keine Lösung sonst. (Wichtig f¨ ur Miller-Rabin!)

3.6.2

Sicherheit

1. Zeige: Eine Familie von Einwegfunktionen existiert genau dann, wenn Einwegfunktionen existieren. 2. Betrachte das folgende Problem B: Gegeben y = eK (x) (RSA-Verschl¨ usselung!), entscheide ob 0 ≤ x < n2 oder n2 < x ≤ n − 1. Gebe eine Turing-Reduktion RSAEntschl¨ usselung RSAattack ⇒ B an, d.h. finde einen Algorithmus AlgA , der RSA bricht, wenn er ein Orakel f¨ ur B aufrufen kann. 3. Betrachte das folgende Problem C: Gegeben y = eK (x) (RSA-Verschl¨ usselung!), entscheide ob x gerade oder ungerade, d.h. ob das kleinste Bit von x gleich 0 oder 1 ist. Zeige C(y) = B(y × eK (2−1 )) mod n und

B(y) = C(y × eK (2))

mod n

und folgere daraus, dass C und B Turing-äquivalent sind.

39

4 4.1

Mathematische Grundlagen Chinesischer Restsatz

Seien m1 , . . . mr paarweise verschiedene teilerfremde nat¨ urliche Zahlen (d.h. ggT(mi , mj ) = 1 f¨ ur i 6= j) und seien a , . . . , a ganze Zahlen. Dann gibt es ein a ∈ Z, eindeutig bestimmt 1 r Qr modulo M = i=1 mi , so dass a ≡ ai mod mi f¨ ur alle i. Beweis: Wir zeigen zuerst die Existenz. Q Setze Mi := j6=i mj . Dann gilt ggT (mi , Mi ) = 1. Also gibt es ein yi mit yi Mi ≡ 1 mod mi . P Nun setze a = rj=1 aj yj Mj . Dann gilt X aj yj Mj ≡ ai + 0 mod mi , a = a i y i Mi + j6=i

da Mj f¨ ur i 6= j durch mi teilbar ist. Nun zur Eindeutigkeit: Sei a0 eine andere Zahl mit a0 ≡ ai mod mi . Dann gilt a ≡ a0 mod mi f¨ ur alle i, also mi | (a − a0 ) f¨ ur alle i. Da die mi teilerfremd, folgt dann auch m | (a − a0 ), also a ≡ a0 mod m (eindeutige Primfaktorzerlegung!). 4.2 4.2.1

Primzahltests Primzahltest von Miller-Rabin

Sei n ungerade, 2s die größte Potenz von 2, die n − 1 teilt, und d = (n − 1)/2s . Satz 4.2.1. Sei n prim mit (a, n) = 1. Dann gilt ad ≡ 1 mod n oder a2

rd

f¨ ur ein r mit 0 ≤ r ≤ s − 1.

≡ −1

mod n

Beweis: Nach Fermat an−1 ≡ 1 mod n, d.h. a2

sd

≡1

mod n.

Nehme sukzessive Quadratwurzeln. Die Quadratwurzeln aus 1 modulo n sind ±1. Also s−1 s−1 gilt entweder a2 d ≡ 1 mod n oder a2 d ≡ −1 mod n usw. bis ad . Sei n eine zusammengesetzte Zahl. Dann heißt a ein Zeuge f¨ ur n, falls a eine der Gleichung aus Satz 4.2.1 erf¨ ullt. Satz 4.2.2. Ist n 6= 9 eine ungerade zusammengesetzte Zahl. Dann gibt es höchstens (n − 1)/4 zu n teilerfremde Zahlen in {0, 1, . . . , n − 1}, die Zeugen f¨ ur n sind.

40

4.2

Primzahltests

Beweis: Sei a ∈ (Z/nZ)∗ eine Zahl, f¨ ur die einer der Ungleichungen aus dem vorherigen r Satz erf¨ ullt sind. O.B.d.A. können wir annehmen, dass a2 d ≡ −1 mod n f¨ ur ein r ∈ {0, 1, . . . , s − 1} (denn wir können −a statt a nehmen und es gilt (−1)d ≡ −1, da d ungerade, also falls ad ≡ 1 mod n, dann (−a)d ≡ −1 mod n). k Sei k der größte Wert von r f¨ ur den es ein a ∈ (Z/nZ)∗ mit a2 d ≡ −1 mod n gibt. Setze m := 2k d. Definiere folgende Untergruppen von (Z/nZ)∗ (sei pe(p) die maximale Potenz von p die n teilt): • J := {[a] ∈ (Z/nZ)∗ : an−1 ≡ 1 mod n} • K := [a] ∈ (Z/nZ)∗ : am ≡ ±1 mod pe(p) f¨ ur alle p | n • L := {[a] ∈ (Z/nZ)∗ : am ≡ ±1 mod n}

• M := {[a] ∈ (Z/nZ)∗ : am ≡ 1 mod n} Es gilt M ⊂ L ⊂ K ⊂ J ⊂ (Z/nZ)∗ . Jedes [a], das eine der Kongruenzen erf¨ ullt, liegt in L. Wir zeigen nun [(Z/nZ)∗ : L] ≥ 4. Der Index [K : M ] ist eine 2er Potenz, da das Quadrat von [a] ∈ K in M liegt f¨ ur alle [a] ∈ K. Der Index von L in K ist daher auch eine 2er Potenz, z.B. 2j . F¨ ur j ≥ 2 sind wir fertig. F¨ ur j = 1: In diesem Fall hat n zwei Primteiler (dann am ≡ 1 mod pe(p) , am ≡ −1 ¨ mod q e(q) , siehe auch Ubungsaufgabe 5 aus dem vorherigen Kapitel). Die Gruppe J ist ¨ eine echte Untergruppe von (Z/nZ)∗ , da n keine Carmichael-Zahl ist (siehe Ubungsaufgabe 2 in diesem Kapitel). Daraus folgt, dass der Index von L in (Z/nZ)∗ mindestens 4 ist. F¨ ur j = 0: In diesem Fall ist n Primzahlpotenz. Wir haben (Z/pe Z)∗ ' Z/(p − 1)Z × Z/pe−1 Z. Falls a ∈ J liegt, dann hat a eine Ordnung die p − 1 teilt, denn es gilt ggT((p − 1)pe−1 , pe−1 − 1) = (p − 1). Daraus folgt: J ist eine Untergruppe vom Index pe−1 . Es gilt stets pe−1 ≥ 4 außer f¨ ur p = 3 und e = 2 (also n = 9). Dieser Satz f¨ uhrt auf einen Test, der pr¨ uft, ob eine Zahl zusammengesetzt ist. Eingabe: N Ausgabe: “zusammengesetzt” oder “prim” 1. Wähle a zufällig aus Z/nZ. 2. Teste, ob eine der Gleichungen aus Satz 4.2.1 erf¨ ullt ist. 3. Falls nicht, gebe “zusammengesetzt” aus, sonst “prim”.

4.2

41

Primzahltests

p 3 5 7 11 13

d 7 23 71 311 479

2 (log d) 7.5731 19.6626 36.3409 65.8904 76.1798

2

p 17 19 23 29 31

d 1559 5711 10559 18191 31391

2

2 (log d) 108.0979 149.6502 171.6706 192.4205 214.4221

Tabelle 2: Kleine d, f¨ ur die die kleinste Primzahl p mit

p d

= −1 relativ groß ist.

Falls der Algorithmus “zusammengesetzt” ausgibt, ist die Zahl tatsächlich zusammengesetzt. Falls der Algorithmus prim ausgibt, ist dies mit Wahrscheinlichkeit ≥ 43 richtig. Wenn wir den Test k mal wiederholen, können wir diese Wahrscheinlichkeit auf 1−

1k 4

erhöhen. 4.2.2

Ein deterministischer Primzahltest unter der Riemannschen Vermutung

Der Primzahltest von Miller-Rabin hat auch eine deterministische Variante, der Primzahltest von Miller, der aber nur unter der Erweiterten Riemannschen Vermutung gilt. Genauer basiert der Algorithmus auf folgender unbewiesener Annahme:  Sei d > 1 eine nat¨ urliche Zahl. Dann gibt es eine von d  unabhängige Konstante c > 0, so dass eine Primzahl (∗)  q < c(log d)2 mit Jacobisymbol ( dq ) = −1 existiert.

In die Sprache der algebraischen Zahlentheorie u ¨bertragen, bedeutet dies, dass ein Prim√ ideal (q) ⊂ Z mit q ∈ Z und 2 ≤ q < c(log d)2 existiert, das im Ganzheitsring von Q( d) prim bleibt, also tr¨ age ist. ˇ Nach dem Dichtesatz von Cebotarev ist bekannt, dass die Dichte der rationalen Prim√ 1 zahlen, die in Q( d) träge sind, 2 beträgt. Unterhalb einer Schranke x w¨ urden wir also etwa f¨ ur die Hälfte aller Primzahlen q ≤ x erwarten, dass ( dq ) = −1 gilt. Leider scheinen ¨ Beweise f¨ ur solche heuristischen Uberlegungen zur Zeit unmöglich. Allerdings kann man die Aussage (∗) unter Annahme einer erweiterten Riemannschen Vermutung beweisen. Unter der Annahme der erweiterten Riemannschen Vermutung hat Eric Bach [1] gezeigt, dass man c = 2C = 2 wählen kann. Um ein Gef¨ uhl f¨ ur die Vermutung (∗) zu bekommen, geben wir ur eine in Tabelle 1 f¨ p q ur alle PrimPrimzahl p den kleinsten Wert d an, so dass d = −1, aber d =+1, f¨ zahlen q < p. Anders interpretiert, ist die kleinste Primzahl p mit pd = −1 f¨ ur die hier angegebenen Zahlen d relativ groß. Unter Annahme der erweiterten Riemannschen Vermutung können wir (∗) mit c = 2 benutzen und erhalten damit folgenden Primzahltest: Eingabe: Eine ganze Zahl N > 4, N ungerade

42

4.2

Primzahltests

Ausgabe: PRIM oder ZUSAMMENGESETZT 1. Schreibe N − 1 = 2t u mit t, u ∈ N, 2 - u. 2. Falls f¨ ur alle Primzahlen a < 2(log N )2 gilt entweder au ≡ 1

mod N oder a2

ju

≡ −1

mod N

(2)

f¨ ur ein j ∈ Z, 0 ≤ j < t, Ausgabe PRIM. Sonst Ausgabe ZUSAMMENGESETZT. Um die Idee dieses Algorithmus zu verstehen, betrachten wir zunächst den Fall, dass N eine Primzahl ist. Mit dem kleinen Satz von Fermat gilt t

aN −1 ≡ a2 u ≡ 1 Somit gibt es entweder ein j mit a2 besteht ein primes N den Test.

ju

mod N.

= −1 mod N , oder es gilt au ≡ 1 mod N . Also

F¨ ur die R¨ uckrichtung nimmt man an, dass N den Test besteht, aber nicht prim Wir können leicht pr¨ ufen, dass N keine Potenz einer Primzahl ist. Also können wir nehmen, dass zwei verschiedene Primteiler p, q von N existieren. Desweiteren können annehmen, dass p − 1 duch eine mindestens so hohe Zweierpotenz wie q − 1 teilbar d.h. v2 (p − 1) ≥ v2 (q − 1),

ist. anwir ist,

wobei v2 (n) der Exponent der Primzahl 2 in der Primfaktorzerlegung von n sei. Falls v2 (p − 1) = v2 (q − 1), so setzen wir d = pq, andernfalls wählen wir d = p. Nun sei a eine Primzahl, die (∗) mit c = 2 gen¨ ugt, also a < 2(log d)2 und ad = −1. Setze b := au . Da u gerade, db = ad = −1, also insbesondere b 6≡ 1 mod d. Somit gilt in jedem Fall nicht au ≡ 1 mod n (denn sonst d | n). j Damit muss eine der Kongruenzen b2 ≡ −1 mod n gelten. Also existiert ein j mit j j b2 ≡ −1 mod p und b2 ≡ −1 mod q. Wir haben dann ordp b = ordq b = 2j+1 . Wir machen nun eine Fallunterscheidung: 1. d = p, v2 (p − 1) > v2 (q − 1) 2j+1 = ordq b teilt q − 1. Da v2 (p − 1) > v2 (q − 1), gilt 2j+1 | Also p−1 b d = = b 2 = 1, −1 = b p denn ordp (b) = 1. Widerspruch! 2. d = pq, v2 (p − 1) > v2 (q − 1)

b b b (−1) = = d p q

p−1 . 2

4.3

43

Der AKS-Primzahltest

o.B.d.A.

b p

Dann folgt b gilt auch 2 4.3 4.3.1

= −1,

q−1 2

j+1

b q

= 1.

≡ 1 modq,also 2j+1 = ordq (b) | p−1 | p−1 , also pb = b 2 ≡ 1 mod p. 2

q−1 . 2

Da aber v2 (p − 1) = v2 (q − 1),

Der AKS-Primzahltest Die Grundidee

Seit Sommer 2002 gibt es nun einen Primzahltest, dessen Laufzeit ohne unbewiesene Annahmen polynomiell ist. Dieser Algorithmus wurde von M. Agrawal, N. Kayal und N. Saxena am Indian Institute of Technology in Kanpur entwickelt und ist auch unter der Abk¨ urzung AKS bekannt. Die Idee dieses Testes basiert auf folgender Verallgemeinerung des kleinen Fermatschen Satzes: Sei n eine ganze Zahl. Dann ist n genau dann prim, wenn (X + 1)n = X n + 1

in

(Z/nZ) [X].

(3)

Achtung! Die Gleichung (3) ist als Polynomgleichung in (Z/nZ) [X] zu verstehen, d.h. X ist eine Variable. So gilt f¨ ur die Carmichael-Zahl n = 561 zwar (a + 1)n = an + 1 mod n f¨ ur a ∈ (Z/nZ)∗ , das Polynom (X +1)561 mod 561 aber hat zahlreiche von 0 verschiedene Koeffizienten. Wir bemerken zum Beweis von (3): Falls n prim ist, so folgt die Identität (3) aus den Rechengesetzen in Charakteristik n. Falls hingegen n einen echten Primteiler p besitzt, so u ¨berzeugt man sich leicht, dass auf der linken Seite zum Beispiel der Koeffizient von xp nicht verschwindet, da der Binomialkoeffizient ( np ) nicht durch pe teilbar ist, wobei pe die höchste Potenz von p ist, die n teilt. Das soeben beschriebene Kriterium ist nat¨ urlich nicht effizient, da auf der linken Seite der Gleichung (3) n + 1 Koeffizienten zu berechnen sind. Die Idee von AKS besteht nun darin, statt der Gleichung (3) mehrere Kongruenzen (X + a)n ≡ X n + a

mod (X r − 1, n)

f¨ ur verschiedene a ∈ Z/nZ und kleines r ∈ N zu betrachten. F¨ ur dieser Kongruenzen läßt sich die Gleichheit viel schneller verifizieren, da wir nur mit Polynomen vom Grad ≤ 2r rechnen. Wir bezeichnen die Ordnung einer Zahl n in (Z/rZ)∗ mit or (n). 4.3.2

Der Algorithmus

Wir beschreiben nun den AKS-Algorithmus. Eingabe: Eine ganze Zahl n > 1 Ausgabe: n PRIM oder ZUSAMMENGESETZT 1. Teste, ob n keine Primzahlpotenz.

44

4.3


2. Finde das kleinste r, so dass die Ordnung or (n) von n modulo r größer als 4 log2 n ist. 3. Teste, dass n keine Primteiler ≤ r hat. 4. Falls n ≤ r, return PRIM. 5. Teste (X + b)n = X n + b in Z[X]/(X r − 1, n) p f¨ ur alle b ∈ {1, . . . , b2 ϕ(r) log nc}.

(4)

6. Falls n alle Tests u ¨ bersteht, Ausgabe PRIM, sonst Ausgabe ZUSAMMENGESETZT.

Es ist leicht nachzupr¨ ufen, dass der Algorithmus f¨ ur eine Primzahl n PRIM zur¨ uckgibt. Die eigentliche Schwierigkeit besteht darin zu zeigen, dass eine zusammengesetzte Zahl auch als zusammengesetzt erkannt wird. Satz 4.3.1. Sei n eine zusammengesetzte Zahl, die keine Primzahlpotenz ist. Es sei r die 2 kleinste Zahl, so dass die Ordnung von n modulo r größer als 4 logp n ist. Weiter habe n keine Primteiler kleiner gleich r. Dann existiert ein b ∈ {1, . . . , b2 ϕ(r) log nc}, f¨ ur das die Gleichung (4) nicht erf¨ ullt ist. Angenommen, n besitzt einen echten Primteiler p, aber der Algorithmus gibt PRIM zur¨ uck. In diesem Fall u ¨ bersteht n insbesondere alle Tests in Schritt 5. Es gilt somit (X + b)n = X n + b mod (X r − 1, n) p f¨ ur alle b mit, 1 ≤ b ≤ `, wobei ` = b2 ϕ(r) log nc. Daraus folgt insbesondere auch (X + b)n = X n + b

mod (X r − 1, p)

(X + b)p = X p + b

mod (X r − 1, p)

und f¨ ur alle b mit 1 ≤ b ≤ `. Sei f (X) ein Polynom. Wir nennen eine nat¨ urliche Zahl m introspektiv bez¨ uglich f (X), falls f (X)m = f (X m ) mod (X r − 1, p). Offensichtlich sind n und p nach obigem, also f¨ ur die Polynome X + b mit 1 ≤ b ≤ `, introspektiv. Lemma 4.3.2. i) Zu einem gegebenen Polynom f (X) sind die introspektiven Zahlen bez¨ uglich f (X) unter Multiplikation abgeschlossen. ii) Zu einer gegebenen Zahl m ist die Menge der Polynome, f¨ ur die m introspektiv ist, unter Multiplikation abgeschlossen.

4.3

45


Beweis: Einfach nachrechnen. Wir zeigen beispielhaft (i). Seien m1 und m2 introspektiv f¨ ur f (X). Dann gilt f (X)m1 m2 = (f (X)m1 )m2 ≡ f (X m1 )m2 mod (X r − 1, p), da f (X) introspektiv bez¨ uglich r, m1 m2 r ≡ f ((X ) ) mod (X − 1, p), da f (Y ) mit hier Y = X m1 introspektiv bez¨ ugl. s m1 m2 r ≡ f (X ) mod (X − 1, p).

Als Konsequenz erhalten wir, dass alle Zahlen in I = {ni pj |i, j ≥ 0} bez¨ uglich sämtlichen Polynomen in ( ` ) Y Q= (X + b)eb : eb ≥ 0 b=1

introspektiv sind. Sei nun G die multiplikative Gruppe der Reste von I mod r, d.h. G = {i mod r : i ∈ I} und setze t := #G. Sei ferner Φr (X) das r-te Kreisteilungspolynom und h(X) ∈ Fp [X] einer der irreduziblen Faktoren von Φr (X) mod p vom Grad or (p). Beachte, dass stets Φr (X)|X r − 1. Und schließlich sei G die Untergruppe von F = Fp [X]/(h(X)), die von X + 1, . . . , X + ` erzeugt wird. Die Gruppe G ist somit das Bild von Q in F . Lemma 4.3.3. Es gilt #G ≥

t+`−2 t−1

1 √ ≥ n2 t . 2

Beweis: F¨ ur den Beweis zeigen wir zunächst, dass die Restklassenabbildung π : Z[X] → Z[X]/(p, h(X)) alle Polynome in Q vom Grad < t injektiv in G abbildet. Es folgt nämlich aus f (X) = g(X) mod (p, h(X)), dass f (X m ) = g(X m )

mod (p, h(X))

f¨ ur alle m ∈ I.

Dies lässt sich aber auch so interpretieren, dass das Polynom P (Y ) = f (Y ) − g(Y ) im Körper F mindestens t Nullstellen hat (denn X m = X n in F genau dann, wenn m − n ≡ 0 mod r), im Widerspruch zu deg P (Y ) < t. Wir haben mindestens ` − 1 Polynome vom Grad 1 in G (denn im Falle h(X) = X +a t+l−2 reduziert sich die Anzahl um 1). Aus diesen lassen sich mindestens t−1 verschiedene ¨ Polynome vom Grad < t zusammenf¨ ugen (siehe Ubungsaufgaben). Die letzte Ungleichung

46

4.3

erhalten wir durch


t+`−2 t−1+`−1 |G| ≥ ≥ t−1 t−1 ! √ √ ` − 1 + b2 t log nc √ da t > 2 t log n, da t > 4(log n)2 ≥ b2 t log nc ! √ p √ 2b2 t log nc − 1 √ ≥ da ` = b2 ϕ(r) log nc ≥ b2 t log nc b2 t log nc √ f¨ ur m ≥ 3 ≥ 2b2 t log nc da 2m ≤ 2m−1 m 1 √ ≥ n2 t . 2

Das nächste Lemma liefert nun den erforderlichen Widerspruch: √

Lemma 4.3.4. Ist n keine p-Potenz, dann gilt #G < 21 n2 t . Beweis: Falls n keine p-Potenz ist, so hat die Menge n √ o i j ˆ I = n p : 0 ≤ i, j ≤ b tc

mehr als t verschiedene Elemente. Da t = #G, gibt es also m1 , m2 , m1 > m2 mit X m1 ≡ X m2

mod (X r − 1).

Aus der Introspektivität folgt f¨ ur alle f (X) ∈ Q f (X)m1 ≡ f (X)m2

mod (X r − 1, p),

also die gew¨ unschte Gleichung in F . Somit hat das Polynom P 0 (Y ) = Y m1 − Y m2 mindestens #G verschiedene Nullstellen in F . Es folgt #G ≤ deg(P 0 (Y )) = m1 ≤ (np)b

√ tc

1 √ < n2 t , 2

was zu zeigen war. Dies schließt auch den Beweis von Satz 4.3.1 ab. 4.3.3

Zur Laufzeit

Wir verwenden hier den folgenden Satz ohne Beweis. Satz 4.3.5. [12] Sei kgV(m) das kleinste gemeinsame Vielfache der ersten m Zahlen. Dann gilt kgV(m) ≥ 2m .

4.4

47

¨ Ubungen

Tatsächlich existiert ein r ≤ d16(log n)5 e mit or (n) > 4(log n)2 . Es seien r1 , . . . , rt alle Zahlen mit ori (n) ≤ 4(log n)2 . Dann teilt kgV(r1 , . . . , rt ) das Produkt b4(log n)2 c

Y i=1

5

(ni − 1) ≤ 216(log n) .

Da aber f¨ ur das kleinste gemeinsame Vielfache kgV(m) der ersten m Zahlen, die Abschätzung kgV(m) ≥ 2m gilt, muss es eine Zahl r ≤ d16(log n)5 e mit or (n) > 4(log n)2 geben. ˜ Satz 4.3.6. Sei O(m) die Laufzeit, die f¨ ur eine Addition, eine Multiplikation oder eine Division zwischen zwei Zahlen mit je m Bits benötigt wird. Dann beträgt die asymptotische ˜ ((log n)10.5 ). Laufzeit des AKS-Algorithmus O

˜ Es läßt sich leicht zeigen, dass die O-Notation bis auf Potenzen des iterierten Loga˜ ((log n)10.5 ) = rithmus die richtige Größenordnung wiedergibt, also in unserem Fall O O ((log n)10.5 (log log n)c ) mit einer nichtnegativen Konstante c gilt. Beweis: Man p sieht leicht, dass Schritt 5 die Laufzeit des Algorithmus dominiert. Hier uft werden. Jede Gleichung erformuss f¨ ur 2 ϕ(r) log(n) Zahlen die Identität (4) u ¨berpr¨ dert O(log n) Multiplikationen von Polynomen vom Grad r mit Koeffizienten der Größe ˜ (r(log n)2 ) Schritten verifiziert werden. Insgesamt ergibt sich eine O(log n), kann also in O Laufzeit von p ˜ r ϕ(r)(log n)3 = O ˜ r 32 (log n)3 = O ˜ (log n)10.5 O Operationen. Das beweist den Satz. 4.3.4

Weitere Primzahltests

In der Praxis kommen noch zwei weitere Primzahltests zum Einsatz. Der eine verwendet elliptische Kurven, die wir später auch noch kennenlernen werden. Der andere Test verwendet Gauß- oder Jacobisummen. Wer mehr dar¨ uber lesen möchte, dem empfehle ich z.B. das Buch von Cohen, Computational algebraic number theory [5]. 4.4

¨ Ubungen

1. Es seien m1 = 11, m2 = 13, m3 = 17, a1 = 2, a2 = 5, a3 = 7. Bestimme M ∈ {0, . . . , m1 m2 m3 − 1} mit ai ≡ M mod mi . 2. Sei n eine ungerade zusammengesetzte Zahl. Die Zahl n heisst Carmichael-Zahl, falls an−1 ≡ 1 mod n f¨ ur alle a ∈ (Z/nZ)∗ . (a) Angenommen f¨ ur alle Primteiler p von n gilt p−1 teilt n−1 und p ist quadratfrei. Zeige, dass dann an−1 ≡ 1 mod n f¨ ur alle a ∈ (Z/nZ)∗ .

(b) Angenommen, es gelte

an−1 ≡ 1

mod n

48

4.4

¨ Ubungen

f¨ ur alle a ∈ (Z/nZ)∗ . Zeige dann dass p | n auch p−1 | n−1 gelten muss. (Tipp: Wir können annehmen dass a mod p die Gruppe (Z/pZ)∗ erzeugt.) (c) Sei n Carmichael-Zahl. Zeige, dass dann kein p existiert mit p2 - n (also n quadratfrei). (d) Gebe nun unter Verwendung von a, b, c eine Charakterisierung aller CarmichaelZahlen an. Zeige, dass eine Carmichaelzahl mindestens 3 Primfaktoren haben muss. 3. Im Beweis von Satz 4.3.3 brauchen wir, dass sich aus ` Polynomen vom Grad 1 t+`−2 t−1 verschiedene Polynome vom Grad < t zusammensetzen lassen. Beweise diese Aussage. (Hinweis: Zeige zunächst, dass sich genau s+`−2 s Polynome vom Grad s f¨ ur s < t konstruieren lassen. Folgere dann die Behauptung durch Vollständige Induktion.) 4. Wann tritt der Fall auf, dass das Polynom h(x) im Beweis von Satz 4.3.1 Grad eins hat? Was muss dann f¨ ur den Primteiler p von n gelten?

49

5 5.1

RSA Das RSA-Verschlu ¨sselungssystem

Sei n ∈ N gegeben (öffentlicher Schl¨ ussel). Im allgemeinen ist n von der Form p · q mit p und q große Primzahlen. Sei m mit 1 < m < n die Nachricht. 5.1.1

Verschl¨ usselung

Zur Verschl¨ usselung verwendet der Absender den öffentlichen Schl¨ ussel e und sendet c = me

mod n

mit (e, ϕ(n)) = 1. 5.1.2

Entschl¨ usselung

Zur Entschl¨ usselung bildet der Angreifer mithilfe seines privaten Schl¨ ussels d mit ed ≡ 1 mod ϕ(n) (me )d ≡ m mod ϕ(n). Die Zahl n heißt RSA-Modul. 5.2

Die RSA-Signatur

Sei m gegeben, n, e öffentlich, d geheimer Schl¨ ussel. Der Absender signiert die Nachricht durch md mod n. Der Empfänger pr¨ uft die Signatur ?

m = (md )e

mod n.

Signaturverfahren stellen sich, dass der angeblich Absender auch tatsächlich die Nachricht geschickt hat. Ein Fremder, der die Nachricht als seine eigene ausgeben will, muss das RSA-Problem, das auch dem Verschl¨ usselungssystem zugrundeliegt, lösen. 5.3

RSA-Entschlu ¨sselung unter Verwendung des chinesischen Restsatzes

Mithilfe des chinesischen Restsatzes können wir die Entschl¨ usselung etwas beschleunigen. Wir wollen x = md mod n berechnen. Sei dp ≡ d mod p − 1 dq ≡ d mod q − 1. Berechne xp = mdp −1

mod p

xq = mdq −1

mod q.

50

5.4

Angriffe auf RSA

Da x ≡ xp mod n und x = xq mod n können wir die Lösung nur einfach mit dem chinesischen Restsatz zusammensetzen. Wir betrachten die Komplexität dieses Verfahrens und der naiven Methode. Der euklidische Algorithmus von `-Bit Zahl benötigt c`2 Operationen. Eine modulare Exponentiation mod ` kostet somit c`3 f¨ ur eine Konstante c. Angenommen n − 1 habe 2`-Bits. Dann haben p und q etwa `-Bits. Also ergeben sich f¨ ur den modulare Ansatz mit chinesischem Restsatz 2(c`3 ) Operationen und f¨ ur den ohne 3 chinesischen Restsatz c(2`) Operationen. Somit ist die Methode mit chinesischem Restsatz 4mal so schnell. 5.4

Angriffe auf RSA

Bemerkung 5.4.1. 1. In der Regel wählt man n = p·q mit p, q zwei große Primzahlen, in der Regel p, q ' 2512 . 2. Falls n und ϕ(n) bekannt, dann können wir n faktorisieren, denn p2 − (n − ϕ(n) + 1)p + n = 0 (ϕ(n) = (p − 1)(q − 1)). Satz 5.4.2. Falls der geheime Entschl¨ usselungsexponent d bekannt ist, dann gibt es einen Monte-Carlo Algorithmus, der n mit Wahrscheinlichkeit 21 faktorisiert (es existiert eine randomisierte Reduktion). Beweis: Wenn wir d und e kennen, können wir ed − 1 bilden. Sei s so gewählt, dass 2s ||ed − 1 und setze k = (ed − 1)/2s . Dann gilt f¨ ur alle zu n teilerfremden Zahlen a, dass ord (Z/nZ)∗ (ak ) eine 2er-Potenz ist. Angenommen a sei eine Zahl so dass ord p (ak ) 6= ord q (ak ). o.B.d.A. ord p (ak ) > ord q (ak ) =: 2t . t t t Dann gilt a2 k ≡ 1 mod q, aber a2 k 6≡ 1 mod p und somit ggT(a2 k − 1, n) = q. Um n zu faktorisieren, wählen wir also zufällige Element a ∈ Z/nZ. Wir testen, ob a ∈ (Z/nZ)∗ (wenn nicht erhalten wir gleich einen Teiler von n). t Dann berechnen wir ggT(a2 k − 1, n). Wir zeigen nun, das f¨ ur die Hälfte aller a ∈ (Z/nZ)∗ der Algorithmus erfolgreich terminiert. Sei g ∈ (Z/nZ)∗ , so dass ord p (g) = p − 1 und ord q (g) = q − 1 (möglich nach dem chinesischen Restsatz). Wir unterscheiden zwei Fälle: 1. ord q (g k ) 6= ord p (g k ) o.B.d.A: ord p (g k ) > ord q (g k ) Sei x eine ungerade Zahl in {0, . . . , p − 1} und y ∈ {0, 1, . . . , q − 2}. Dann betrachte a ∈ (Z/nZ)∗ mit a ≡ g x mod p und a ≡ g y mod q.

Da x ungerade, gilt ord p (g k ) = ord p (ak ); ausserdem ord p (ak ) > ord q (ak ). Wir (q − 1) Möglichkeiten (x, y) zu wählen. haben p−1 2

5.5

51

Die Wiener-Attacke

2. ord q (g k ) = ord p (g k ). Dann wähle x ungerade und y gerade und setze a ≡ gx

mod p und a ≡ g y

mod q.

Wieder gilt: ord p (ak ) = ord p (g k ), aber nun ord q (ak ) = 21 ord q (g k ). Paare mit ord p > ord q und analog (p−1)(q−1) Paare mit ord Es gibt also (p−1)(q−1) 4 4 ord q .

5.5

p

0 und b ≥ qm+1 . Falls y = 0, dann a = xpm und b = xqm . Es folgt |θb − a| = |θxqm − xpm | = |x||θqm − pm | ≥ |θqm − pm |. Widerspruch! Weiter besitzen x und y verschiedene Vorzeichen: Ist y < 0, dann folgt aus xqm = b − yqm+1 , dass x > 0. Falls y > 0, dann folgt aus b < qm+1 , dass b < yqm+1 . Somit ist xqm negativ, also x < 0. Wegen Lemma 5.5.5 haben θqm − pm und θqm+1 − pm+1 verschiedene Vorzeichen. Somit haben die Summanden in x(θqm − pm ) + y(θqm+1 − pm+1 ) dasselbe Vorzeichen. Wir erhalten nun aus dem Gleichungssystem 5 θb − a = x(θqm − pm ) + y(θqm+1 − pm+1 ). Da beide Summanden auf der rechten Seite das gleiche Vorzeichen haben, folgt |θb − a| = |x(θqm − pm ) + y(θqm+1 − pm+1 )| = |x(θqm − pm )| + |y(θqm+1 − pm+1 )| > |x(θqm − pm )| = |x||(θqm − pm )| ≥ |θqm − pm |. Widerspruch! Somit gilt |θqm − pm | ≤ |θb − a|
b. Widerspruch!! Satz 5.5.6. Sei (n, e, d) mit n = p · q eine RSA-System mit geheimen Schl¨ ussel d. Angenommen, es gilt 1 3d < n 4 und q < p < 2q. Dann gibt es einen Algorithmus, der n faktorisiert. Beweis: Sei ed ≡ 1 mod ϕ(n). Daraus folgt ed − tϕ(n) = 1 f¨ ur ein t < d. Daraus ergibt sich e 1 t ϕ(n) − d = dϕ(n) . Weiter gilt

√ 0 < n − ϕ(n) = p + q − 1 < 2q + q − 1 < 3q < 3 n

(die letzte Ungleichung folgt aus n > q 2 ). Somit folgt e − t = | ed − nt | n d nd √ 1 + t(ϕ(n) − n) 1 − t3 n =| | p. (a) Angenommen q − p = 2d > 0, n = pq. Zeige n + d2 ist ein Quadrat! (b) Sei n = p · q und n + d2 ein Quadrat f¨ ur eine kleines positive Zahl d. Wie kann diese Info verwendet werden, um n zu faktorisieren? (c) Faktorisiere n = 233570635089091. 4. Wiener Angriff f¨ ur n = 557792853050617 und e = 452333117365623 (d = 439) 5. Die Rabin-Verschl¨ usselung ist ein weiteres Kryptosystem, das auf der Schwierigkeit der Faktorisierung basiert. Es seien p, q Primzahlen (privat), p ≡ q ≡ 3 mod 4, n = p·q der öffentliche Schl¨ ussel. Bob verschl¨ usselt eine Nachricht m f¨ ur Alice, indem er c = m2

mod n

berechnet. (a) Alice kennt p und q. Wie kann sie die Nachricht entschl¨ usseln bzw. auf 4 mögliche Nachrichten eingrenzen? (b) Wie effizient ist das Verfahren? (c) Zeigen Sie, dass die Sicherheit des Verfahrens zur Faktorisierung äquivalent ist. (d) Eigentlich kann Alice m nur bis auf 4 Nachrichten eingrenzen. Welche Möglichkeiten gibt es das Verfahren zu modifizieren, so dass die Nachricht eindeutig wird? (e) Das Verfahren ist unsicher in Bezug auf eine chosen ciphertext Attacke. Zeigen Sie das! 6. Es seien e der o¨ffentliche Schl¨ ussel, e = 3. Es seien n1 , n2 und n3 verschiedene RSA-Moduli. Angenommen es werde 3mal die gleiche Nachricht m verschickt. Ein Angreifer fängt ci = me mod ni ab. Wie kann er m finden, ohne die Zahlen ni zu faktorisieren? Verallgemeinerung?

5.8

59

¨ Ubungen

7. Es seien A, B zwei Benutzen, die den gleichen RSA-Modul n verwenden mit o¨ffentlichen Schl¨ usseln eA und eB . (a) B kann jede Nachricht von A entschl¨ usseln und umgekehrt. Begr¨ undung! (b) Alice schickt an A und B eine Nachricht yA = xeA mod n bzw. yB = xeB mod n. Wie kann ein Angreifer, der yA und yB abfängt, die Nachricht gewinnen? 8. Ein Nachrichtentext heisst Fixtext, falls eK (x) = x. Wir nehmen an, dass (x, n) = 1. Zeige, dass es f¨ ur RSA ggT(e − 1, p − 1) × ggT(e − 1, q − 1) Fixtexte gibt! 9. Zeige, RSA ist unsicher gegen eine chosen ciphertext Attacke. Gegeben y gebe yˆ an, so dass man beim Wissen von xˆ = dK (ˆ y ) auf x = dK (y) schliessen kann. 10. Zeige, falls Bob eine Nachricht wie folgt verschl¨ usselt, kann jeder die Nachricht entschl¨ usseln: A↔0 B↔1 usw. Bsp? 11. (Random Faults, ref.) RSA-Signatur mit CRS Sei N = p·q. Angenommen, der Computer macht Fehler, d.h. er berechnet xp korrekt, aber xq nicht. Sei xˆ die fehlerhafte Signatur. Dann gilt xê ≡ m mod p, aber xê 6≡ m mod q, also ggT(N, xê − m) f¨ uhrt auf nicht-trivialen Faktor von N . Die Signatur wird auch als fehlerhaft erkannt!!

60

6

Das diskrete Logarithmusproblem

Es sei (G, ∗) eine beliebige, kommutative endliche Gruppe. Dann betrachte das folgende Problem: Gegeben g, h ∈ G, ord(g) = n, finde eine Zahl k, 0 ≤ k ≤ n − 1 mit g ∗g ∗···∗g = h

(k − Faktoren).

Diese Zahl k heißt der diskrete Logarithmus von h zu Basis g. Notation: k := log g h. Wir schreiben auch g k := g ∗ · · · ∗ g (obwohl in einige Fällen die Gruppenoperation auch additiv geschrieben wird). Beispiel 6.0.1. (Aus der Einf¨ uhrungskapitel): G = F∗p Bemerkung 6.0.2.

1. Die Gruppe G sollte endlich sein.

2. Es spielt nur < g > eine Rolle, in vielen Fällen wird deshalb G zyklisch gewählt. Wir möchten Gruppen betrachten, in denen das diskrete Logarithmusproblem schwer zu lösen ist. Betrachte dazu folgende “Definition”: Das diskrete Logarithmusproblem in einer Gruppe (G, ∗) ist schwer, falls es keinen effizienten Lösungsalgorithmus gibt. Diese “Definition” ist sehr vage, wir werden das jetzt konkretisieren. Beispiel 6.0.3. Das DL-Problem in (Fp , +) ist nicht schwer. Es gilt: a=k·b

mod p ⇒ k = ab−1

mod p.

Die Zahl k kann mit dem euklidischen Algorithmus gefunden werden. 6.1 6.1.1

Algorithmen zur L¨ osung des diskreten Logarithmusproblems Der Algorithmus von Shanks

Ohne Beschränkung der Allgemeinheit, sei G zyklisch der Ordnung n mit erzeugendem Element g. √ Setze m := d ne und schreibe k = k1 + k2 · m, 0 ≤ k1 , k2 ≤ m, ki ∈ N. Wir suchen k mit g k = h. Nun gilt g k = h ⇔ g k1 +k2 ·m = h ⇔ g k1 = h(g −1 )k2 m oder

(g m )k2 = hg −k1 .

√ Idee: Berechne hg −i f¨ ur 1 ≤ i ≤ b nc = m. Dazu sind ≤ m Operationen nötig. Speichere alle Ergebnisse in einer Tabelle, sortiere die Tabelle.

6.1

Algorithmen zur L¨ osung des diskreten Logarithmusproblems

61

Berechne g˜ := (g m ) und dann g˜k2 f¨ ur 1 ≤ k2 ≤ m. Bestimme den Index i von g˜k2 in der Tabelle. Dann gilt (g m )k2 = hg −i und wir können den diskreten Logarithmus konstruieren. p Die Laufzeit ist durch O(m) = O( |G|) gegeben. Den benötigte Speicherplatz liegt auch bei O(m). Bemerkung 6.1.1. Im Allgemeinen speichert man nicht das Element hg −i selbst ab, sondern nur einen Hashwert. Man vergleicht dann den Hashwert von g˜k2 mit den Hashwerten in der Tabelle. Diese werden auch noch geschickt sortiert. Das spart Speicherplatz und beschleunigt die Suche nach dem richtigen Element. Wenn wir einfach jedes Element mit jedem vergleichen w¨ urden, w¨ urden wir doch wieder |G| Schritte brauchen. 6.1.2

Das Geburtstagsparadoxon

Frage: Wieviele Leute m¨ ussen in einem Raum sein, damit mit Wahrscheinlichkeit ≥ mindestens zwei Leute am gleichen Tag Geburtstag haben?

1 2

Wir wollen dieses Problem etwas allgemeiner angehen. Deshalb nehmen wir an, dass die Anzahl der Geburtstage eine Unbestimmte n ist (wir können dies im konkreten Fall nat¨ urlich durch n = 365 ersetzen). Sei k die Anzahl der Personen im Raum. Weiter sei p die Wahrscheinlichkeit, dass mindestens zwei Leute am gleichen Tag Geburtstag haben. Wir werden aber zunächst die Gegenwahrscheinlichkeit, dass alle an unterschiedlichen Tagen Geburtstag haben, berechnen. Sei dazu Yt das Ereignis, dass die ersten t Personen von den k Personen im Raum an unterschiedlichen Tagen Geburtstag haben. Dann gilt offensichtlich 1 Ws(Y2 ) = 1 − n und 2 1 1 Ws(Y3 ) = Ws(Y3 |Y2 ) · Ws(Y2 ) = Ws(Y3 |Y2 ) · (1 − ) = (1 − )(1 − ). n n n Induktiv u ¨berlegen wir uns, dass nun k−2 k−1 Y k−1 Y i i Ws(Yk ) = Ws(Yk |Yk−1 ) · Ws(Yk−1 ) = (1 − ) (1 − ) = (1 − ) n n n i=1 i=1

gilt. Das Produkt 1−p=q =

k−1 Y i (1 − ) n i=1

wollen wir nun abschätzen. Es gilt 1 + x ≤ ex (folgt aus der Exponentialreihe).

62

6.1

Algorithmen zur L¨ osung des diskreten Logarithmusproblems

Somit ergibt sich q=

k−1 Y i=1

k−1

(1 −

Y i Pk−1 i )≤ e− n = e− i=1 i/n = e−k(k−1)/(2n) . n i=1

Falls k ≥ (1 +

√

1 + 8n ln 2/2)

(hier bezeichne ln den nat¨ urlichen Logarithmus), gilt g ≤ 21 . In diesem Fall ist 1 p=1−q ≥ . 2 In unserem Geburtstagsbeispiel können wir n = 365 und k = 23 setzen. Wir erhalten so, dass in einem Raum mit mindestens 23 Personen, mit Wahrscheinlichkeit ≥ 12 , 2 Personen am gleichen Tag Geburtstag haben. 6.1.3

Die ρ-Methode von Pollard

Idee: Berechne eine Sequenz x1 , x2 , . . . von zufälligen Elementen in G unter Verwendung einer Funktion f , d.h. starte mit x1 ∈R G und setze f (xi ) = xi+1 . Falls wir xi , xj mit xi = xj f¨ ur i < j erhalten, hoffen wir logg h berechnen zu können. Das p Geburtstagsparadoxon soll dazu f¨ uhren, dass wir fr¨ uher als erwartet, nämlich in O( |G|) Schritten, auf eine solche Kollision treffen. Um Speicherplatz zu sparen, werden wir nicht alle Elemente, sondern nur jedes m-te Element betrachten. Da aus f (xi ) = f (xj ) auch f (xi+r ) = f (xj+r ) folgt, ist dies möglich. Wir geben eine geeignete Zufallsfunktion an. Dazu teilen wir G in drei Mengen G = S1 ∪ S 2 ∪ S 3 . Es gilt f :< α > ×Z/nZ × Z/nZ →< α > ×Z/nZ × Z/nZ mit  a, b + 1) x ∈ S1  (hx, 2 (x , 2a, 2b) x ∈ S2 f (x, a, b) =  (gx, a + 1, b) x ∈ S3 Jedes Tripel (x, a, b) erf¨ ullt x = g a hb . Definiere nun eine Zufallsfolge durch (xi , ai , bi ) =

(1, 0, 0) i=0 f (xi−1 , ai−1 , bi−1 ) i ≥ 1.

Wir vergleichen die Tripel (x2i , a2i , b2i ) und (xi , ai , bi ). Angenommen xi = x2i . Dann folgt αa2i β b2i = αai β bi , also αa2i +cb2i = αai +cbi . Daraus ergibt sich a2i + cb2i ≡ ai + cbi mod n, wobei n = |G|. Falls ggT(b2i − bi , n) = 1, dann folgt c = (ai − a2i )(b2i − bi )−1 .

6.2

63

Das generische Modell

Ansonsten, falls ggT(b2i − bi , n) > 1, hat die Gleichung c(b2i − bi ) ≡ a2i − ai

mod n

eventuell mehrere Lösungen, die wir dann alle durchprobieren können. √ Nach dem Geburtstagsparadoxon sind f¨ ur diesen Algorithmus im Schnitt O(| G|) Schritte nötig. 6.1.4

Der Algorithmus von Pohlig-Hellmann

Wir zeigen nun, dass die Schwierigkeit des DL-Problems in der Gruppe G nur vom größten Primfaktor p der Gruppenordnung n abhängt. Betrachte zunächst den Fall, dass |G| zwei unterschiedliche Primfaktoren hat, |G| = n = p · q. Es sei das DL-Problem gx = h (6) in G gegeben. Sei x = k eine Lösung. Potenziere die Gleichung mit p. Wir erhalten also (g p )x = h.

(7)

Dies ist nun ein DL-Problem in einer Untergruppe der Ordnung q. Falls k 0 eine Lösung zu (7) ist, dann gilt k 0 ≡ k mod q f¨ ur jede Lösung von (6). Um eine Lösung f¨ ur (6) modulo q zu finden, m¨ ussen wir also nur ein DL-Problem der Ordnung q lösen. Analog können wir den diskreten Logarithmus modulo p berechnen und erhalten dann mit dem chinesischen Restsatz die gew¨ unschte Lösung modulo n. Nun nehmen wir |G| = pe f¨ ur ein e an. Dann können wir schreiben k = k0 + k1 p + k2 p2 + . . . + ke−1 pe−1 . Es gilt (g p

e−1

) k0 = h p

e −1

.

So finden wir also k0 , denn k0 ≡ k mod p. Berechne nun gneu := g p und hneu := hg −k0 . 0

Dann gilt (gneu )k = hneu mit k 0 so dass k = k0 + pk 0 . Setze dieses Verfahren nun fort und berechne nacheinander alle ki und somit k. Fazit: Die Schwierigkeit des diskreten Logarithmusproblems hängt nicht von der Gruppenordnung selbst, sondern vom größten Primfaktor der Gruppenordnung ab. 6.2


Wir zeigen nun, dass wir eine abstrakte p Gruppe konstruieren können, in der der beste Algorithmus f¨ ur das DL-Problem O( |G|) Schritte benötigt. Dies ist die sogenannte generische Gruppe. Somit besteht zumindest theoretisch die Möglichkeit, dass es eine Gruppe gibt, in der das DL-Problem wirklich schwierig ist.

64

6.2


Die generische Gruppe ist wie folgt gegeben: Eine Kodierungsfunktion auf (Z/pZ)+ ist eine injektive Abbildung σ : Z/pZ → {0, 1}n f¨ ur ein n > 0. Die Gruppe G ist nun durch die Menge σ(Z/pZ) gegeben. Es gilt σ(i) + σ(j) = σ(i + j). Allerdings kennen wir weder die Abbildung σ noch f¨ ur ein b ∈ σ(Z/pZ) sein Urbild a. Deshalb können wir selbst keine Additionen in G durchf¨ uhren. Daf¨ ur steht uns allerdings ein Orakel zur Seite, das bei Eingabe von σ(i), σ(j) das Element σ(i+j) ausgibt. Da wir das Orakel auch häufiger aufrufen können, können wir auch annehmen, dass es uns bei Eingabe von n, m ∈ Z, σ(i), σ(j) die Ausgabe σ(ni+mj) liefert. So können wir von uns aus gar keine zusätzlichen Elemente in der Gruppe G erzeugen. Um zusätzliche Elemente von G zu erhalten, m¨ ussen wir immer das Orakel befragen. In der Tat erscheint diese Definition sehr k¨ unstlich: alle bekannten Gruppen (wie etwa die multiplikativen Gruppe eines endlichen Körpers oder auch elliptische Kurven, die wir später noch kennenlernen) sind nicht generisch. Sei nun ein DL-Problem in G gegeben, o.B.d.A. sei g = σ(1) = σ1 und h = σ(r) = σ2 f¨ ur ein r. Wir sollen nun r bestimmen. Sei GENLOG ein beliebiger Algorithmus, der das diskrete Logarithmusproblem in G löst. Der Algorithmus GENLOG wählt während seiner Ausf¨ uhrung Paare (ci , di ) ∈ Z/pZ × Z/pZ, i ≥ 3, aus und ruft dann das Orakel auf, um σ(ci + di a) f¨ ur i = 3, . . . m zu erhalten. Wir nehmen an, dass die Paare (ci , di ) alle verschieden sind (denn durch Wahl eines Paares, das schon vorher einmal erzeugt wurde, lernt der Algorithmus GENLOG nichts Neues). Der Algorithmus kann nun nach dem (i − 2)-ten Aufruf nur drei Dinge tun: Er kann die kodierten Elemente in {σ1 , . . . , σi } auf Gleichheit u ufen, er wählt ein neues Paar ¨berpr¨ (ci+1 , di+1 ) und bittet das Orakel um σi+1 (dies ist einer Gruppenoperation gleichzusetzen), und/oder er gibt den diskreten Logarithmus a aus. Falls zwei Elemente σj und σj 0 gleich sind, dann gilt

a = (cj − c0j )(dj − d0j )−1

mod p

(denn dj 6= d0j , weil alle Paare unterschiedlich gewählt wurden). In diesem Fall kann der Algorithmus GENLOG mit dem Ergebnis a erfolgreich terminieren. Der Algorithmus GENLOG kann den Wert von a genau dann im i-ten Schritt durch eine Kollision berechnen, falls

a ∈ Quoti =

(cj − c0j ) 0 0 : j 6= j , j, j ≤ i . dj − d0j

Falls a 6∈ Quoti , dann ist die Wahrscheinlichkeit, dass a irgendeinen festen Wert in 1 Z/pZ\Quoti gen¨ ugt, genau p−Q mit Qi = |Quoti |. i

6.3

65

Ein DL-basiertes Kryptosystem

Somit gilt nach m Schritten Ws[Algorithmus terminiert erfolgreich mit a] = Ws[a ∈ Quotm ] + Ws[a 6∈ Quotm ] · Ws[ALG rät richtig] 1 #|Quotm | p − |Quotm | + = p p p − |Quoti | m +1 #|Quotm | + 1 ≤ 2 . = p p Der Algorithmus GENLOG berechnet den diskreten Logarithmus, falls die Wahrscheinlichkeit Ws[Algorithmus terminiert erfolgreich mit a] größer als 1 ist, also m +1 2 1≤ p Dies ist gleichbedeutend mit m(m + 1) + 1, 2 √ also m = Ω( p). Dies ist eine untere Schranke f¨ ur die Komplexität eines DL-Algorithmus in einer generischen Gruppe. p≤

Der Satz impliziert nicht, dass es irgendeine Kodierungsfunktion σ gibt f¨ ur das das diskrete Logarithmusproblem schwierig ist, d.h. f¨ ur jede spezielle Kodierung könnte es einen effizienteren Algorithmus geben! Wir machen nun die folgende Definition: Definition 6.2.1. Eine Gruppe (G, ∗) besitzt ein schweres DL-Problem, falls ihre Gruppenordnung prim oder fast prim ist und der beste Algorithmus zum Lösen des diskre√ ten Logarithmusproblems O( p) Operationen in G benötigt, wobei p der größte Primfaktor von |G| ist. 6.3

Ein DL-basiertes Kryptosystem

Wir betrachten nun das Verschl¨ usselungsverfahren von El-Gamal. Die Schwierigkeit des El-Gamal-Systems beruht auf dem Computational Diffie-Hellmann Problem (CDH-Problem), das wir lössen können, falls das diskrete Logarithmusproblem leicht ist. Die Umkehrung ist zwar nicht bekannt, aber wir kennen auch keine Gruppen, in denen das CDH-Problem leicht, das DL-Problem aber schwierig ist. Alice wählt eine Primzahl p und ein primitives Element g mit < g >= F∗p . Sie wählt außerdem ihren geheimen Schl¨ ussel a ∈ {0, . . . , p − 2}. Sie setzt dann A = g a mod p und veröffentlicht (p, g, A), den öffenlichen Schl¨ ussel. Verschlu usselung einer Nachricht m ∈ {0, . . . , p − 1} wählt Bob ¨sselung: Zur Verschl¨

66

6.4

¨ Ubung - Die Index-Calculus-Methode

eine zufällige Zahl b ∈ {1, . . . , p − 2} und berechnet B = gb

mod p

und c = Ab m

mod p.

Er sendet (B, c). Entschlu usselt nun wie folgt. Es gilt ¨sselung: Alice entsch¨ c = Ab m ≡ g ab m = (g b )a m

mod p.

Sie berechnet (g b )−a = B p−1−a mod p und m = c(B −a ) mod p. Bemerkung 6.3.1. 1. Die Entschl¨ usselung kostet eine, die Verschl¨ usselung sogar zwei modulare Exponentiationen. Das System ist somit langsamer als RSA. Aber Bob kann Ab mod p, B = g b mod p vorher berechnen. Dann braucht die Verschl¨ usselung nur eine modulare Multiplikation, und dies ist sehr schnell. ¨ 2. (Aquivalenz zum Computational Diffie-Hellman Problem) Wir nehmen an, dass wir das Computational Diffie-Hellman Problem (CDH) lösen können. Sei dann (B, c) die verschl¨ usselte Nachricht. Der Angreifer kennt A = g a b und B = g . Da er das CDH lösen kann, kann er g ab und somit m = cg −ab berechnen. Nehmen wir nun an, dass der Angreifer El-Gamal brechen kann, und zwar f¨ ur jede Nachricht m. Es seien A = g a und B = g b gegeben und (B, c) eine Verschl¨ usselung. Der Angreifen kann nun m = cg −ab berechnen un dann auch g ab = cm−1 . 3. El-Gamal ist randomisiert, d.h. gleiche Nachrichten werden gleich verschl¨ usselt. Unter der Annahme, dass das Decision Diffie-Hellmann Problem schwierig ist, ist das System semantisch sicher. Definition 6.3.2. Das Decision Diffie-Hellmann Problem ist das folgende Problem: Gegeben g a , g b und g c , entscheide ob c = ab. Denn falls das Decision Diffie-Hellmann Problem schwierig ist, dann können wir gegeben g a , g b das Element g ab nicht von einem zufälligen Gruppenelement unterscheiden. Das gilt dann aber auch f¨ ur m · g ab . Also kann der Angreifer bei gegebenem Geheimtext keine Information u ¨ ber den Nachrichtentext gewinnen. 6.4


¨ Diese Ubung dient dazu, den Index-Calculus-Angriff auf das diskrete Logarithmusproblem ur sollte in der multiplikativen Gruppe F∗p eines endlichen Primkörpers zu verstehen. Daf¨ ¨ man sich den Text gut durchlesen und die kleinen Ubungsaufgaben bearbeiten.

6.4

67


Sei p eine Primzahl und g eine Primitivwurzel, d.h. < g >= F∗p . Weiter haben wir h ∈ F∗p gegeben. Wir wollen ein x ∈ {1, . . . , p − 1} finden, dass die Gleichung gx ≡ h

mod p

erf¨ ullt. Sei F (B) die Menge aller Primzahlen kleiner gleich B, d.h. F (B) = {q ∈ P : q ≤ B} wobei P die Menge der Primzahlen bezeichnet. Solch eine Menge nennt man Faktorbasis. Eine ganze Zahl b heißt B-glatt, falls sie nur Primteiler ≤ B hat. Sie kann dann u ¨ ber der Faktorbasis vollständig faktorisiert werden. Augabe 1: Bestimme alle Zahlen ≤ 100, die nicht 6-glatt sind. Aufgabe 2: Welches ist die kleinste Zahl B, so dass 910 B-glatt ist. Der Index-Calculus-Angriff besteht aus zwei Schritten. Im ersten Schritt bestimmen wir f¨ ur alle Elemente q ∈ F (B) den diskreten Logarithmus bez¨ uglich g, d.h. wir finden x(q) mit g x(q) ≡ q

mod p.

(Es ist jetzt noch nicht klar, wie das funktioniert. Das kommt erst später.) Im zweiten Schritt wählen wir zufällige y, bis wir ein y gefunden haben, so dass hg y B-glatt ist, d.h. hg y =

Y

q e(q)

mod p

q∈F (B)

f¨ ur irgendwelche Exponenten e(q) ≥ 0. Aufgabe 3: Zeige: Dann gilt f¨ ur den diskreten Logarithmus logg h 

x=

X

q∈F (B)



x(q)e(q) − y 

mod (p − 1).

Nun m¨ ussen wir noch erklären, wie wir das diskrete Logarithmusproblem f¨ ur die Elemente der Faktorbasis lösen, d.h. wie wir die x(q) bestimmen. Idee: Wähle zufällige Element g s aus Fp∗ und versuche diese u ¨ ber der Faktorbasis zu faktorisieren. Wir betrachten das Beispiel p = 5387. Hier ist 2 ein primitives Element. Sei h = 2909. Weiter setzen wir B = 11, d.h. F (B) ist die Menge aller Primzahlen ≤ 11.

68

6.4


Aufgabe 4: Vervollständige folgende Rechnung: 22 · 5 = 20 = 21067

mod p

= 4032 = 23721

mod p

4409

mod p

= 3024 = 2 = 343 = 2

1619

mod p

= 108 = 2

2072

mod p

= 675 = 2

4200

mod p

= 3850 = 24806

mod p.

Falls wir gen¨ ugen Relationen gefunden haben, können wir ein lineares Gleichungssystem modulo p − 1 lösen, um x(q) zu bestimmen. So folgt hier z.B. aus der vierten Gleichung sofort, dass x(7) = 2335 ist. Aufgabe 5: Bestimme die diskreten Logarithmen x(2), x(3), x(5), x(7) und x(11). F¨ ur den zweiten Schritt des Algorithmus m¨ ussen wir ein y finden, so dass hg y B-glatt ist. 145 In unserem Fall gilt h · 2 ≡ 35 mod p. Aufgabe 6: Bestimme den diskreten Logarithmus von h zu Basis g = 2. Der Index-Calculus Angriff hat eine subexponentielle Laufzeit. Genauer betrachten wir folgende Funktion u 1−u Ln [u, v] = ev(ln n) (ln ln n) . Aufgabe 7: Begr¨ unde: Ein Algorithmus mit Laufzeit Ln [0, v] ist polynomiell, ein Algorithmus mit Laufzeit Ln [1, v] exponentiell in der Eingabegröße. Der Index-Calculus-Angriff liegt dazwischen, d.h. seine Laufzeit ist Lp [ 21 , c + o(1)] f¨ ur eine Konstante c. Im Beweis der Laufzeit gehen Abschätzungen u ¨ber die Anzahl von Bglatten Zahlen ein. Aufgabe 8: Warum sind solche Abschätzungen f¨ ur die Laufzeit des Algorithmus wichtig? In welchen Schritten spielen sie eine Rolle? Wie wirken sie sich auf die Wahl der Faktorbasis aus?

69

7

Elliptische Kurven

7.1

Definitionen und Grundlagen

Es sei κ zunächst ein beliebiger Körper. Definition 7.1.1. Eine elliptische Kurve u ¨ber dem Körper κ ist eine nicht-singuläre Kurve gegeben durch die affine Gleichung der Form y 2 + a1 xy + a3 y = x3 + a2 x2 + a4 x + a6 ,

ai ∈ κ

. Bemerkung 7.1.2. 1. Alternative Definitionen: “Eine elliptische Kurve ist eine nichtsinguläre Kurve vom Geschlecht 1.” oder “Eine elliptische Kurve ist eine Abelsche Varietät der Dimension 1.” 2. Falls char κ 6= 2, 3, können wir die Gleichung der Kurve auf eine einfachere Form bringen: y 2 = x3 + ax + b, a, b ∈ κ mit ∆ = 4a3 − 27b2 6= 0.

3. Sei λ/κ ein Erweiterungkörper. Die Menge der affinen λ-rationalen Punkte E(λ) auf E wird durch die Menge {(x0 , y0 ) ∈ λ2 : y02 + a1 x0 y0 + a3 y0 = x30 + a2 x20 + a4 x0 + a6 } ∪ {∞} beschrieben. 4. Wir können die Kurve auch als projektive Kurve auffassen. Dazu schreiben wir (z.B. in char κ 6= 2, 3) zunächst das homogene Polynom f¨ ur die Kurve auf: y 2 z = x3 + axz 2 + bz 3 , a, b ∈ κ. Zwei Punkte [x0 , y0 , z0 ] und [x1 , y1 , z1 ] sind äquivalent, falls ein λ in κ existiert mit λ[x0 , y0 , z0 ] = [x1 , y1 , z1 ]. Die affinen Punkte erhalten wir, in dem wir z0 = 1 setzen. Dazu kommt ein weiterer Punkt f¨ ur z0 = 0 (der unendlich ferne Punkte ∞). 5. Ein singulärer Punkt einer projektiven Kurven F (x, y, z) = 0 ist ein Punkt P = [x0 , y0 , z0 ], der die Kurvengleichung erf¨ ullt und f¨ ur den zusätzlich ∂F ∂F ∂F (P ) = (P ) = (P ) = 0 ∂x ∂y ∂z gilt. Wir können leicht nachpr¨ ufen, dass z.B. im Fall char κ 6= 2, 3 durch die Bedin3 2 gung ∆ = 4a − 27b 6= 0 singuläre Punkte ausgeschlossen werden. Ein singulärer Punkt (x0 , y0 ) in einer Körpererweiterung λ von κ wäre ein Punkte in E(λ) mit 2y0 = 0 und 3x20 + a = 0. 6. F¨ ur κ = R können wir die Kurve auch zeichnen (siehe weiter unten).

70

7.1


Abbildung 1: Elliptische Kurve

Bemerkung 7.1.3. Die Menge der λ-rationalen Punkte vereinigt mit dem unendlich fernen Punkt ∞ auf E bildet eine abelsche Gruppe. Beobachtung: Falls λ algebraisch abgeschlossen, trifft eine Gerade die elliptische Kurve immer in drei Punkten (mit Multiplizitäten gezählt). Dies folgt aus dem Lemma von Bézout, siehe [9], Lemma 3.37. Falls die elliptische Kurve u ¨ber einem Körper κ definiert ist und zwei Schnittpunkte in einer Körpererweiterung κ ⊂ λ liegen, dann liegt auch der dritte Schnittpunkt in λ.

1. Geometrisches Gruppengesetz: P , Q ∈ E(λ), P 6= Q. (a) Verbinde P und Q durch eine Gerade. Sei R der Schnittpunkt der Geraden mit E. (b) Setze P + Q:=Spiegelung von R an der x-Achse. Falls P, Q ∈ E(λ), dann gilt P 6= Q ∈ E(λ). Assoziativität ist relativ schwierig zu zeigen (gutes Beispiel f¨ ur eine Gruppe, bei der die Assoziativität nicht-trivial ist!). Neutrales Element: Der unendlich ferne Punkt.

7.2

Elliptische Kurven u orpern ¨ ber endlichen K¨

71

Inverses Element: Der an der x-Achse gespiegelte Punkt. Falls P = Q, dann m¨ ussen wir im ersten Schritt die Tangente von P an E wählen. Die Punkte der Ordnung zwei auf E sind die Punkte, deren x-Koordinate gleich 0 sind. Die Punkte der Ordnung drei auf E sind die Wendepunkte der Kurve (hier schneidet die Tangente mit Multiplizität drei). 2. Die Addition läßt sich durch Formeln beschreiben. Sei P1 = (x1 , y1 ), P2 = (x2 , y2 ), Pi 6= ∞ und P1 + P2 6= ∞. Dann gilt P3 = (x3 , y3 ) mit x3 = λ 2 − x 1 − x 2 y3 = λ(x1 − x3 ) − y1 ( y −y 2 1 P 6= Q x2 −x1 λ= 3x21 +a P =Q 2y1 Beweisskizze: Gegeben P1 , P2 , bilde Gerade y = mx + c durch die beiden Punkte. Substituiere in y 2 = x3 + ax + b die Variable y durch mx + c. Wir erhalten so eine kubische Gleichung in x, von der wir zwei Lösungen kennen. Polyomdivision durch (x − x1 )(x − x2 ) liefert x3 und schließlich wegen y3 = mx3 + c auch y3 . 3. Durch die Beschreibung der Addition mittles Formeln könenn wir jetzt f¨ ur κ, λ beliebige Körper einsetzen, z.B. auch einen endlichen Körper, bei dem ja Geraden keine geometrische Interpretation besitzen. 7.2

Elliptische Kurven u orpern ¨ber endlichen K¨

Sei nun κ = Fq ein endlicher Körper. Beispiel 7.2.1. Sei κ = F5 der endliche Primkörper mit 5 Elemente. Setze E : y 2 = x3 + 1. Dann gilt E(F5 ) = {∞, (0, 1), (0, 4), (2, 2), (2, 3), (4, 0)}.

Bemerkung 7.2.2. Es gibt nur endliche viele Tupel (x0 , y0 ), die der Gleichung der elliptischen Kurve gen¨ ugen, d.h. die Punktegruppe u ¨ber einem endlichen Körper ist endlich. Es gilt offenbar #E(Fq ) ≤ 2q + 1. Da nicht jedes Element quadratischer Rest ist, erwarten wir etwa ∼ q Punkte. Tatsächlich gilt folgender Satz.

Satz 7.2.3 (Hasse-Weil). Sei Fq ein Körper mit q Elementen und sei E/Fq eine elliptische Kurve. Dann gilt √ |#E(Fq ) − q − 1| ≤ 2 q. Elliptische Kurven u ¨ ber endliche Körper zerfallen in zwei Klassen.

Definition 7.2.4. Eine elliptische Kurve ¨ uber einem endlichen Körper Fq der Charakteristik p heißt supersingul¨ ar, falls #E = q + 1 − t mit p | t. Sonst heißt die elliptische Kurve gew¨ ohnlich.

72

7.3

Das DL-Problem auf einer elliptischen Kurve

Eine elliptische Kurve u ¨ ber einem Primkörper ist genau dann gewöhnlich, wenn sie p + 1 Punkte hat. 7.3


Unter dem Problem des diskreten Logarithmus auf der elliptischen Kurve versteht man die folgende Fragestellung: Gegeben eine u ¨ber einem endlichen Körper Fq definierte Kurve und zwei Punkte P, Q aus der Punktegruppe E(Fqk ) u ¨ber einer Körpererweiterung Fqk , finde ein r ∈ Z, so dass rP = Q, falls ein solches r existiert. Bemerkung 7.3.1. • Die Zahl r muss nicht existieren, z.B. ist die Gruppe E(Fqk ) nicht unbedingt zyklisch. Die Existenz von r lässt sich aber (mit der Weil-Paarung leicht u ufen. ¨ berpr¨ In der Praxis existiert r stets. • Eine Instanz (E, P, Q) des diskrete Logarithmusproblems lässt sich mit dem squareand-multiply-Algorithmus aus dem ersten Kapitel leicht berechnen. • F¨ √ur vorsichtig gewählte Kurven hat der beste bekannte Algorithmus Komplexität `, wobei ` der größte Primfaktor der Gruppenordnung ist (vergl. Kapitel 6). Die bekannten Ausnahmen: 1. Frey-Ru ¨ck-Reduktion (Tate-Paarung, [7]), MOV-Reduktion (Weil-Paarung, [11]): Sei E(Fq )n die Gruppe der u ¨ber Fq rationalen Punkte auf E, deren Ordnung die Zahl n teilt. Dieser Angriff ist erfolgeich, falls n | q − 1. Falls die Gruppe der n-ten Einheitswurzeln µn in F∗q liegt, also n | q − 1, dann gibt es eine Abbildung Φn von Tupeln (P, Q) mit P ∈ E(Fq )n und Q ∈ E(Fq ) in die Gruppe der n-ten Einheitswurzeln µn . Diese hat folgende Eigenschaften: (a) Sie ist Z-linear in beiden Komponenten, d.h. Φn (P + P 0 , Q) = Φn (P, Q)Φn (P 0 , Q) und Φn (P, Q + Q0 ) = Φn (P, Q)Φn (P, Q0 ). (b) Zu einer zyklische Untergruppe von E(Fq ) der Ordnung n existiert ein Punkt P 0 in E(Fq ) mit {Φn (P, P 0 ); P ∈ E(Fq )n } = µn . (c) Die Paarung Φn läßt sich in O(log q) elliptischen Operationen (d.h. Punktadditionen oder -verdopplungen) berechnen. Der Punkt P 0 aus 2) läßt sich in probabilistisch polynomialer Zeit in log q finden. Falls die Ordnung der Kurve prim ist, können wir ihn sogar direkt angeben.

7.3


73

Sei nun (E(Fq ), P, Q) eine Instanz eines diskreten Logarithmusproblems mit ord P = n und Q = rP f¨ ur ein noch unbekanntes r ∈ Z/nZ. Nun sei P 0 ein Punkte auf E(Fq ), so dass α = Φn (P, P 0 ) eine primitive n-te Einheitswurzel ist. (Diesen Punkt gibt es nach 2). Wir setzen β = Φn (Q, P 0 ), und wir haben aufgrund der Z-Linearität: β = Φn (Q, P 0 ) = Φn (rP, P 0 ) = Φn (P, P 0 )r = αr . Somit haben wir das Problem des diskreten Logarithmus auf der elliptische Kurve auf ein Problem in dem darunterliegenden Körper reduziert. Da es f¨ ur das diskrete ∗ Logarithmusproblem in Fq subexponentieller Algorithmen gibt, können wir dann den diskreten Logarithmus auf der elliptischen Kurve in subexponentieller Zeit berechnen. Unter einem subexponentiellen Algorithmus versteht man einen Algorithmus mit einer Laufzeit L(α, c) mit α < 1 (vergleiche Abschnitt 6.4). Falls n - q − 1, aber n | q k − 1 f¨ ur kleines k, dann können wir die Punktegruppe E(Fqk ) der elliptischen Kurve betrachten. Wir definieren dann die Paarung auf Tupeln (P, Q) mit P ∈ E(Fqk )n und Q ∈ E(Fqk ). Dann reduzieren wir das diskrete Logarithmusproblem auf E(Fq ) mit der Abbildung Φn auf das diskrete Logarithmusproblem in F∗qk . Beachte, dass wir dann ein diskretes Logarithmusproblem in einer ussen. Dies ist einfacher als ein allgemeines diskretes Untergruppe von Fqk lösen m¨ Logarithmusproblem in Fqk . Damit das diskrete Logarithmusproblem nicht effizient in einen endlichen Körper reduziert werden kann, fordern wir also, dass der größte Primfaktor p˜ der Gruppenordnung keine der Zahlen q k −1 mit k ≤ (log q)2 teilt. Damit sind alle supersingulären Kurven f¨ ur kryptographische Anwendung uninteressant, da hier k ≤ 6 gilt. F¨ ur eine zufällig gewähltes Paar (p, E) mit p eine Primzahl und E eine elliptische Kurve u ¨ber Fp mit #E(Fp ) = l schätzen N. Koblitz und R.Balasubramanian ( [2]) die Wahrscheinlichkeit f¨ ur l | pk − 1 f¨ ur ein k ≤ (log p)2 ab. F¨ ur eine zufällig gewählte gewöhnliche Kurve ist die Wahrscheinlichkeit f¨ ur ein kleines k verschwindend gering. 2. Reine anomale Kurven( [14, 17, 15]): Falls #E(Fp ) = p gilt, gibt es sogar Algorithmen, die den diskreten Logarithmus in der Punktegruppe E(Fp ) in linearer Zeit in log p berechnen. Bei Kurven, f¨ ur die #E(Fp ) = p gilt, können wir das Logarithmusproblem nach Qp liften. Diese Liftung ist sehr effizient möglich, da es gen¨ ugt alle auftetenden Zahlen, insbesondere die Koordinaten der Punkte P und Q, bis zu einer Genauigkeit mod p2 zu berechnen. Das diskrete Logarithmusproblem lässt sich dann auf eine DL-Problem in der additiven Gruppe Fp reduzieren, das trivial mit dem euklidischen Algorithmus lösbar ist. Diese Kurven sind also sehr, sehr unsicher. Bei der Wahl einer u ussen wir ¨ber einem großen Primkörper Fp definierten Kurve m¨ deshalb darauf achten, dass #E(Fp ) 6= p ist. 3. Weil-Restriktion [8] Einige spezielle Kurven u ¨ ber Körpern Fpn mit einer zusammengesetzten Zahl n sind ebenfalls unsicher (also wähle n = 1 oder p klein und n groß und prim).

74

7.3


Bemerkung 7.3.2. Wir fassen die Anforderungen an die Gruppenordnung der elliptischen Kurve zusammen: 1. Die Gruppenordnung soll durch eine große Primzahl ` geteilt werden, die die Laufzeit aller Algorithmen f¨ ur das Logarithmusproblem in √beliebigen Gruppen sprengt, da diese Algorithmen alle in etwa eine Laufzeit von ` haben. Die Primzahl ` sollte also mindestens 160 Bits haben. 2. Die Kurve sollte entweder u ¨ ber einem gro¨sen Primkörper Fq = Fp definiert sein oder u ¨ber einem Körper Fq = Fpn mit sehr kleiner Charakteristik (z.B. p = 2) und n groß und prim. 3. F¨ ur die Primzahl ` aus 1. sollte ` - q k − 1 f¨ ur alle k ≤ (log q)2 gelten. Insbesondere sollte die Kurve nicht supersingulär sein. 4. Falls wir eine u ¨ber einem großen Primkörper Fp definierte Kurve wählen, fordern wir, dass p 6= #E(Fp ) gilt. betreiben. Um zu u ufen, ob eine elliptische Kurve den gestellten Anforderungen gen¨ ugt, m¨ ussen ¨berpr¨ wir ihre Gruppenordnung kennen. Es ist prinzipiell möglich, u ¨ ber einem endlichen Körper Fq definierte Kurven zufällig zu wählen und dann die Punkte zu zählen, da daf¨ ur Algorithmen existierten, die polynomiell in log q laufen. Der erste Algorithmus zum Punktezählen von Schoof hatte eine Laufzeit in (log q)8 und war somit völlig unpraktikabel. Mittlerweile gibt es aber neue Ideen und Verbesserungen, und der Algorithmus ist sehr schnell in der Praxis. Noch schneller kann man auf Kurven kleiner Charakteristik die Punkte zählen. Eine Alternative besteht darin, eine elliptische Kurve mit gew¨ unschter Gruppenordnung zu konstuieren oder spezielle Kurven zu nehmen, bei denen die Punkteanzahl auf der Hand liegt und kein Zählalgorithmus nötig ist. F¨ ur mehr Details u ¨ ber Angriffe und Punktezählen auf elliptischen Kurven siehe z.B. [18].

7.4

75

ECDSA

7.4

ECDSA

Wir beschreiben nun eine Variante des Signaturalgorithmus DSA f¨ ur elliptische Kurven (ECDSA). Hierbei steht ECDSA f¨ ur Elliptic Curve Digital Signature Algorithm. Dieser Algorithmus ist bereits als IEEE-Standard eingef¨ uhrt worden. ECDSA: Parameter (öffentlich): Kurve E(Fp ), Punkt P ∈ E(Fp ), privater Schl¨ ussel: eine ganze Zahl x im Intervall [2 . . . ` − 2], ussel: der Punkt Q mit xP = Q. öffentlicher Schl¨ Signaturerzeugung: 1. A(lice) wählt k ∈R [2..` − 2]. 2. A berechnet kP = (x1 , y1 ) und r = x1 mod `. 1 Falls r = 0, dann geht sie zu Schritt 1 zur¨ uck, da sonst die Signatur s, die in Schritt 3 berechnet wird, den privaten Schl¨ ussel x nicht enthalten w¨ urde. 3. A berechnet k −1 mod ` und den Hashwert H(m) der Nachricht m. Dann bildet sie s = k −1 (H(m) + xr) mod `. 4. Falls s = 0, beginnt sie wieder bei Schritt 1. Sonst sendet A die Nachricht m mit der Signatur (r, s) an B(ob). Signaturverifikation: 1. B pr¨ uft, ob r, x ∈ [1..` − 1].

2. B berechnet w = s−1 mod ` und den Hashwert H(m). Dann bildet er u1 = H(m)w mod ` und u2 = rw mod `. 3. B ermittelt u1 P + u2 Q = (x0 , y0 ). 4. Er akzeptiert genau dann, wenn x0 mod ` = r ist. Zur Korrektheit: Wir nehmen an, dass Alice die Signaturerzeugung korrekt ausgef¨ uhrt hat. Dann berechnet Bob im dritten Schritt u1 P + u2 Q = (H(m)w

mod `)P + (rw

mod `)Q = (x0 , y0 ).

Nun gilt aber xP = Q. Also erhält Bob (H(m)w mod `)P + (rw mod `)xP = ((H(m)w + rwx) mod `)P da P Ordnung ` hat = (w(H(m) + rx) mod `)P = kP. Deshalb muß x0 = r mod ` gelten. Falls ein beliebiger Benutzer C den diskreten Logarithmus berechnen kann, erhält er aus 1 Mit

”

mod `“ bezeichnen wir hier und auch sp¨ ater der kleinste positive Rest von ` modulo m.

76

7.5

Paarungsbasierte Kryptographie

P und Q den geheimen Schl¨ ussel x und kann damit Signaturen von A fälschen.

7.5


Wenn elliptische Kurven heute in der Kryptographie zum Einsatz kommen, dann meist in tradionellen DL-basierten Kryptosystemen, so wie z.B. im letzten Abschnitt beschrieben. Wir betrachten nun noch eine weitere Anwendung von elliptischen Kurven, die sogenannte paarungsbasierte Kryptographie. 7.5.1

Die Weil-Paarung

Unter Angriffen haben wir bereits die Tate-Paarung eingef¨ uhrt. Die Weil-Paarung ist auch eine Paarung mit ganz ähnlichen Eigenschaften. Wir f¨ uhren zunächst etwas Theorie ein. Sei K ein Körper. Die Gruppe der n-ten Einheitswurzeln in K bezeichnen wir mit µn (K), die Gruppe der n-ten Einheitswurzeln u ¨ber dem algebraischen Abschluss K einfach mit µn . Lemma 7.5.1. Sei E eine elliptische Kurve ¨ uber einem Körper K und sei n eine nat¨ urliche Zahl, (n, charK) = 1. Dann gilt E[n] ' Z/nZ × Z/nZ. F¨ ur einen Beweis siehe [16]. Satz 7.5.2. Sei E eine elliptische Kurve ¨ uber einem endlichen Körper Fq . Angenommen, es gilt E[n] ⊂ E(Fq ). Dann gibt es eine Paarung (die Weil-Paarung) en : E[n] × E[n] → µn mit folgenden Eigenschaften: 1. (Bilinearität) en ist bilinear, 2. en ist nicht-entartet (d.h. falls P ein Punkte der Ordnung n, dann gibt es einen Punkt Q ∈ E[n] mit en (P, Q) ist primitive Einheitswurzel), 3. en (P, P ) = 1 f¨ ur alle P ∈ E[n],

4. (Reziprozitätsgesetz) en (P, Q) = en (Q, P )−1 ,

5. (Galois-Eigenschaft) en (σP, σQ) = σ(en (P, Q)) f¨ ur alle Automorphismen σ ∈ Aut(Fq , Fq ). Einen Beweis hierf¨ ur findet man ebenfalls in [16], Kapitel 3. Korollar 7.5.3. Falls P , Q eine Basis von E[n] ist, dann ist en (P, Q) eine primitive n-te Einheitswurzel. Beweis: Angenommen es gelte en (P, Q) = ζ mit ζ d = 1 und d | n. Dann folgt en (P, dQ) = 1. Da die Weil-Paarung nicht entartet ist, gibt es aber einen Punkt R mit en (P, R) = α und

7.5

77


α hat Ordnung n. Nun können wir R in der Form aP + bQ schreiben. Also gilt en (P, R) = en (P, aP + bQ) = en (P, P )a en (P, Q)b = en (P, Q)b . Da en (P, Q) eine d-te Einheitswurzel, folgt daraus d = n. Korollar 7.5.4. Aus E[n] ⊂ E(Fq ), folgt n | q − 1. Beweis: Sei σ ein Automorphismus in Aut(Fq , Fq ) und P , Q eine Basis von E[n]. Nach Voraussetzung gilt P , Q in E(Fq ). Da P , Q eine Basis bilden, ist α = en (P, Q) eine primitive n-te Einheitswurzel. Wir zeigen nun, dass σ(α) = α ist: α = en (P, Q) = en (σ(P ), σ(Q)) = σ(en (P, Q)) = σ(α). (dabei haben wir die Galois-Eigenschaft der Weil-Paarung verwendet). Dann folgt aus dem Hauptsatz der Galoistheorie, dass α ∈ F∗q liegt. Da α aber eine primitive n-te Einheitswurzel ist, ergibt sich dann auch µn ∈ F∗q . Nun gilt aber µn ∈ F∗q genau dann, wenn n die Gruppenordnung von F∗q , also q−1 teilt. Korollar 7.5.5. Es gilt stets E(Fq ) ' Z/n1 Z × Z/n2 Z mit n2 | n1 und n2 | q − 1. Beweis: Nach dem Hauptsatz u ¨ber endliche abelsche Gruppen gilt E(Fq ) ' Z/n1 Z × . . . × Z/nt Z mit nt | nt−1 | . . . | n1 . Nun gilt stets E[n] ' Z/nZ × Z/nZ. Daraus folgt t ≤ 2, also E(Fq ) ' Z/n1 × Z/n2 Z. Falls n2 6= 1, dann gilt E[n2 ] ⊂ E(Fq ), also nach dem letzten Satz µn2 ⊂ Fq , also n2 | q − 1. Beispiel 7.5.6. F¨ ur das Beispiel benötigen wir zunächst folgendes Lemma: Lemma 7.5.7. Die Gleichung x2 + 1 = 0 hat in Fp mit p ≡ 3 mod 4 keine Lösung. Beweis: Falls p ≡ 3 mod 4, dann gilt p−1 −1 ≡ (−1) 2 ≡ −1 p

mod p,

also ist −1 keine Quadratwurzel modulo p und die Gleichung x2 + 1 hat modulo p keine Lösung.

78

7.5


Betrachte E : y 2 = x3 + x u ¨ber Fp mit p ≡ 3 mod 4. ¨ Es gilt #E(Fp ) = p + 1 (siehe Ubungsaufgaben). Nun folgt aus Korollar 7.5.5, dass E(Fp ) ' Z/n1 × Z/n2 Z

mit n2 | p − 1 und n2 | n1 , also n2 | 2. Die 2-Torsionspunkte u ¨ber Fp von y 2 = x3 +x sind die Punkte mit y = 0 und der unendlich ferne Punkt. Nun hat die Gleichung x3 + x = x(x2 + 1) aber f¨ ur Fp nur die Lösung x = 0. Also liegt nicht die volle 2-Torsionsgruppe in E(Fp ), und E(Fp ) ist zyklisch. Betrachte nun i : (x, y) → (−x, ιy) 2 2 mit ι ∈ Fp , ι = −1. Sei P ∈ E(Fp ), dann folgt iP ∈ E(Fp2 ) − E(Fp ). Dann gilt iP 6∈< P >, denn mit P ∈ E(Fp ) ist auch jedes Vielfache in E(Fp ). Wir haben < P, iP >= E[p + 1]

und en (P, iP ) ist eine primitive p + 1-te Einheitswurzel. 7.5.2

Tripartiter Schl¨ usselaustausch in einer Runde

Im ersten Kapitel haben wir den Schl¨ usselaustausch von Diffie-Hellmann kennengelernt, mit dem zwei Leute einen Schl¨ ussel austauschen können. Wir sehen unschwer, dass wir durch Iteration erreichen können, dass n Leute in n − 1 Runden einen Schl¨ ussel austauschen. F¨ ur 3 Leute braucht man mit dem Diffie-Hellmann Verfahren also 2 Runden. Mithilfe der Weil-Paarung können wir dies um eine Runde reduzieren, d.h. drei Leute können in einer Runde einen gemeinsamen Schl¨ ussel vereinbaren. Dazu vereinbaren Alice, Bob und David zunächst Parameter ihres Systems, und zwar eine elliptische Kurve E wie in Beispiel 7.5.6 und einen Punkte P ∈ E(Fp ) der Ordnung p + 1. Sie werden p dabei so wählen, dass es von der Form 4` − 1 ist, wobei ` ein grosser Primfaktor ist, um sich gegen Pohlig-Hellmann zu wappnen. Dann wählt jeder einen geheimen Schl¨ ussel: Alice wählt eine Zahl kA , Bob kB und David kD . Sie bilden die Punkte QA = kA · P , QB = kB · P und QD = kD · P auf der Kurve und veröffentlichen diese auf ihren Internetseiten. Nun ist jeder von ihnen in der Lage, das Element ep+1 (P, i(P ))kA kB kD in F∗p zu bilden. Alice zum Beispiel berechnet dazu ep+1 (QD , i(QB ))kA . Ein Angreifer (Celine) kennt P , QA , QB und QD , ep+1 (P, i(P )) = α und auch αkA , αkB , αkC , αkA kB , αkA kC ,αkB kC . Dies hilft ihm aber nicht weiter, wenn das Computational DiffieHellmann Problem auf der elliptische Kurve E und im Körper F∗p schwer ist. Dies erreicht man, indem man die Primzahl ` sehr gross wählt.

7.5

79


7.5.3

Ein identi¨ atsbasiertes Kryptosystem

Die Idee bei identitätsbasierten Kryptosystemen besteht darin, dass sich der öffentliche Schl¨ ussel direkt aus Daten (etwa der email-Adresse) des Benutzers berechnen läßt. Eine zentrale Autorität (Schl¨ usselcenter) ordnet jedem Benutzer einen privaten Schl¨ ussel zu. Gegen Vorlage entsprechender Unterlagen wird dieser an den Benutzer weitergereicht. So kann nun jeder sicher sein, dass der öffentliche Schl¨ ussel f¨ ur Bob tatsächlich Bob gehört und nicht Celine. RSA ist f¨ ur so ein Verfahren eher ungeeignet, da nicht zwei Benutzer die gleichen Systemparameter verwenden d¨ urfen. Denn wenn beide mit dem gleichen RSA-Modul n arbeiten, kann jeder mit seinem geheimen Schl¨ ussel die Zahl n faktorisieren, und so zu einem anderen öffentlichen Schl¨ ussel, den geheimen Schl¨ ussel berechnen (siehe Kapitel 5). Wir stellen nun das System vor: Das Schl¨ usselcenter f¨ uhrt zunächst folgende Operationen durch (Initialisierung des Systems): 1. Wähle p = 4` − 1 mit ` prim. 2. Setze y 2 = x3 + 1

E: u ¨ ber Fp .

3. Wähle einen Punkt der Ordnung ` auf der Kurve. 4. Wähle kryptographische Hashfunktionen H1 , H2 H1 : {0, 1}∗ → E(Fp )[`] H2 : µ` ∈ F∗p2 → {0, 1}n wobei n die Länge der Nachricht ist, die später verschl¨ usselt wird. 5. Wähle s ∈ F∗` und berechne

Q = sP.

6. Veröffentliche p, H1 , H2 , n, P und Q (s ist der private Schl¨ ussel.) Der Benutzer Bob hat sich mit seiner ID (z.B. seiner email-Adresse ausgewiesen). Das Schl¨ usselcenter berechnet nun 1. QID = H1 (ID) 2. DID = sQID und sendet DID an Bob. Alice sendet nun eine Nachricht M an Bob. Dazu f¨ uhrt sie folgende Schritte durch: 1. ID = bob@t − online.de, QID = H1 (ID). 2. Sie wählt r ∈ F∗` zufällig. 3. Sie berechnet gID = e˜(QID , Q).

80

7.6

Die Diffie-Hellmann Probleme

4. Sie verschl¨ usselt und sendet c an Bob.

r c = (rP, M ⊕ H2 (gID ))

Bob entschl¨ usselt die Nachricht nun wie folgt: 1. Mit DID berechnet er hID = e˜(DID , u). 2. Er berechnet m = v ⊕ H2 (hID ). Es gilt tatsächlich m = M , denn r e˜(DID , u) = e˜(sQID , rP ) = e˜(QID , P )sr = e˜(QID , Q)r = gID .

Somit ergibt sich r r r m = v ⊕ H2 (hID ) = v ⊕ H2 (˜ e(DID , u)) = v ⊕ H2 (gID ) = (M ⊕ H2 (gID )) ⊕ H2 (gID ) = M.

7.6

Die Diffie-Hellmann Probleme

Im ersten Kapitel haben wir das Computational Diffie-Hellmann Problem kennengelernt, und in Bemerkung 6.3.1 sind wir auf das Decision Diffie-Hellmann Problem eingegangen. Offensichtlich können wir das DDH Problem lösen, falls wir CDH lösen können. Gibt es Gruppen, in denen das CDH Problem (zumindest nach heutigem Stand) schwierig, das DDH Problem aber einfach ist? Die Antwort lautet: ja. Wir betrachten dazu wieder die Kurve aus Beispiel 7.5.6. Falls p = 4` − 1 mit einer grossen Primzahl ` (etwa ` 1024 Bits), ist kein effizienter Algorithmus zum Lösen des CDH bekannt. Das DDH Problem können wir aber leicht lösen. Es seien Punkte P (der Ordnung `), Qa = aP , Qb = bP und Qc = cP gegeben. Gilt dann c = ab? Wir berechnen dazu α = e` (P, i(Qc )) und β = e` (aP, i(bP )). Falls c = ab, dann gilt α = β, da α = e` (P, i(Qc )) = e` (P, i(P ))c = e` (P, i(P ))ab = e` (aP, i(bP )) = β. 7.7

¨ Ubungsaufgaben

1. Zeige, dass der Frobenius-Endomorphismus auf der elliptischen Kurve ein Gruppenhomomorphismus ist. 2. Gegeben eine elliptische Kurve der Form y 2 = x3 − x u ¨ber Fp mit p ≡ 3 mod 4. Zeige #E(Fp ) = p + 1. 3. Gegeben eine elliptische Kurve der Form y 2 = x3 − 1 u ¨ ber Fp mit p ≡ 2 mod 3. Zeige #E(Fp ) = p + 1.

7.7

81

¨ Ubungsaufgaben

4. Bestimme die Punkte auf E/F5 gegeben durch y 2 = x3 + x. 5. Ein Endomorphismus einer elliptischen Kurve ist eine Abbildung ϕ : E → E mit ϕ(∞) = ∞. Betrachte die Kurve E : y 2 = x3 − x. Angenommen Fp ist ein Primkörper mit p ≡ 1 mod 4.

(a) Zeige Z[i] = Z + iZ ⊆ End(E). In der Tat gilt sogar die Gleichheit. (b) Sei π der Frobeniusendomorphismus auf E, π : (x, y) → (xp , y p). Dies ist ein Endomorphismus. Berechne die Zahl a + bi mit π = a + bi f¨ ur die Kurve E und p = 5 und p = 13. (c) Zeige, der Frobenius wirkt auf den Fp -rationalen Punkten wie die Identität.

(d) F¨ ur einen Endomorphismus α ∈ End(E) mit p - αα (α bezeichnet das komplex konjugierte von α) gilt # ker(α) = N (α) (einen Beweis hierf¨ ur findet man z.B. in Silverman, Elliptic Curves). Zeige #E(Fp ) = (1 − π)(1 − π). (e) Es ist bekannt, dass ππ = p gilt. Verwende dies, um die Anzahl der Punkte #E(Fp ) f¨ ur p = 5 und p = 13 zu berechnen.

6. Progammiere die Addition auf der elliptischen Kurve u ¨ber Fp , p 6= 2, 3. Die Kurve 2 3 sei durch y = x + ax + b gegeben.

82

8

Zeroknowledge

Idee: Alice beweist ihr Identität (die Kenntnis eines Geheimnis), ohne von sich (von dem Geheimnis) etwas preiszugeben. Wir betrachten zunächst eine nicht-mathematische Realisierung.

x

linker Raum

rechter Raum

Vorraum Wir haben ein Gebäude bestehend aus einem Vorraum und zwei weiteren Räumen (linker und rechter Raum) gegeben. Die beiden oberen Räume sind durch eine Geheimt¨ ur (x) miteinander verbunden, die sich nur durch ein geheimes Schl¨ usselwort öffnen lässt. Alice beweist nun Bob die Kenntnis dieses Schl¨ usselwortes, ohne Information dar¨ uber preiszugeben. Daf¨ ur f¨ uhren sie folgendes Protokoll durch: 1. Alice betritt den Vorraum und tritt dann entweder in den linken oder rechten Raum. Sie verschließt die T¨ ur. 2. Bob betritt den Vorraum, ruft “links” oder “rechts”. 3. Alice tritt nun aus dem Raum heraus, den Bob ihr zugerufen hat. Der ganze Vorgang wird t-mal wiederholt. Bob ist zufrieden, falls Alice jedesmal aus der richtigen T¨ ur heraustritt. Falls Alice das Schl¨ usselwort kennt, kann sie auf jede Forderung von Bob angemessen reagieren. Falls sie das Schl¨ usselwort nicht kennt, kann sie nur mit Wahrscheinlichkeit t 1 2 betr¨ ugen. Warum erhält Bob bei diesem Protokoll keine Information? Offensichtlich wäre es viel effizienter, wenn beide den Vorraum gleichzeitig betreten, Alice durch die linke T¨ ur hineingeht und aus der rechten T¨ ur herauskommt. Aber dann können wir nicht beweisen, dass Bob keinerlei Informationen erhält. F¨ ur obiges Protokoll können wir das aber sehr leicht beweisen. Bob kann alles, was er sieht, selbst simulieren. Er stellt Celine ein, die das Schl¨ usselwort nicht kennt und f¨ uhrt

83

das Protokoll mit Celine durch. Dabei zeichnet er alles mit einer Kamera auf. Falls Celine zufällig die T¨ ur wählt, die Bob ihr später zuruft, kann sie auch ohne Kenntnis des Schl¨ usselwortes richtig reagieren. Bob stellt nun einen Film her. Falls Celine aus der falschen T¨ ur herauskommt, schneidet er einfach die Szene heraus. Wenn Bob alles selbst simulieren kann (ohne Kenntnis des Schl¨ usselwortes), dann lernt er auch sonst nichts u ¨ber das Schl¨ usselwort. Wir betrachten nun zwei mathematische Realisierungen. 8.0.1

Der Fiat-Shamir Algorithmus

Die Sicherheit des Fiat-Shamir Algorithmus beruht auf der Schwierigkeit der Faktorisierung bzw. der Berechnung von Quadratwurzeln modulo n. Zur Schl¨ usselerzeugung wählt Alice zwei grosse Primzahlen p und q und bildet n = pq. Die Zahl n ist dann ein öffentlicher Parameter, p und q sind geheim. Nun wählt Alice s und bildet v = s2 mod n. Die Zahl s ist ihr privater, v der zugehörige ussel. öffentliche Schl¨ Alice soll nun Bob u ¨berzeugen, dass sie s kennt. Dazu betrachten wir folgendes Protokoll: 1. Alice wählt r ∈ (Z/nZ)∗ , bildet x := r 2 mod n und sendet x an Bob. 2. Bob wählt b ∈ {0, 1} und sendet b an Alice. 3. Falls b = 0, dann sendet Alice y := r an Bob; sonst sendet sie y := rs mod n an Bob. 4. Bob pr¨ uft ob y 2 = xv b mod n. Falls ja, akzeptiert er. Korrektheit: Wenn Alice den geheimen Schl¨ ussel s kennt, dann berechnet sie y 2 ≡ (rsb )2 ≡ r 2 s2b ≡ r 2 v b ≡ xv b

mod n.

Eine Angreiferin Celine kann mit Erfolgswahrscheinlichkeit 21 betr¨ ugen: Sie rät b ∈ {0, 1}. 2 −b Dann schickt sie erst x˜ = r v mod n, dann y˜ = r (ganz unabhängig davon, was Bob macht!). Falls sie b richtig geraten hat, dann können wir leicht u ufen, dass ¨ berpr¨ y˜2 = x˜v

mod n,

d.h. Bob akzeptiert. Auf der anderen Seite kann Celine aber auch nicht erfolgreicher sein, wenn sie nicht weiss, welche Wahl Bob trifft. Könnte sie beide Fragen (b = 0 und b = 1) richtig beantworten, dann kann sie aus y0 f¨ ur b = 0 und y1 f¨ ur b = 1 auch eine Quadratwurzel von v berechnen. Quadratwurzelziehen modulo n ist aber schwer, falls n hinreichend gross. Nun u ufen wir noch die Zeroknowledge-Eigenschaft. Dazu m¨ ussen wir zeigen, ¨berpr¨ dass wir das Protokoll simulieren können. Dies ist aber offensichtlich. Celine rät einfach das Bit b. Falls sie richtig rät, akzeptiert Bob ihre Antwort und die entsprechende Szene bleibt im Kasten. Falls sie falsch rät, wird die Szene herausgeschnitten.

84 8.0.2

DL-Identifikation

Nun betrachten wir noch ein Zeroknowledge-Protokoll, das auf dem DL-Problem beruht. Die Parameter des Systems sind zwei Primzahlen p und q mit q | p − 1 und p ≥ 21024 , q ≥ 2160 . Sei α ein Element in F∗p mit Ordnung q. Ein Schl¨ usselpaar ist ein Tupel (s, v) (s geheim, v öffentlich) mit v = α−s , d.h. − s = logα v. Das Protokoll sieht nun wir folgt aus: 1. Alice wählt r ∈ Z/qZ und sendet x := αr mod p an Bob. 2. Bob wählt b ∈ {0, 1} und sendet b an Alice.

3. Alice sendet y := r + sb ∈ Z/qZ.

4. Bob pr¨ uft, ob x = αy v b in Z/pZ.

Korrektheit: Es gilt αy v b = αr+sb v b = αr αsb v b = αr αsb (α−s )b = αr = x. Celine kann mit Erfolgswahrscheinlichkeit 12 das richtige Ergebnis ausgeben. Dazu rät sie erst b ∈ {0, 1}, sendet dann x˜ := v b αr und y˜ := r. Falls A richtig geraten hat, dann gilt αy˜v b = x˜ und Bob akzeptiert. Falls Celine y0 und y1 kennt, kann sie den diskreten Logarithmus berechnen. Somit kann sie nur eine der Anfragen b = 0 oder b = 1 richtig beantworten. Offensichtlich hat auch dieses Protokoll die Zeroknowledge-Eigenschaft.

85

9

Zufallsgeneratoren

Zufallsgeneratoren erzeugen aus einem kurzen zufälligen String einen längeren String, der möglichst zufällig ist. F¨ ur kryptographische Protokolle sind gute Zufallsgeneratoren sehr wichtig. Hier wird zum Beispiel der kurze Eingabestring als Saat f¨ ur den Zufallsgenerator verwendet, der dann zufällige Zahlen liefert. 9.1


Definition 9.1.1. Ein Zufallsgenerator vom Typ h ist eine Familie (Gn )n∈N von Funktionen Gn : {0, 1}n → {0, 1}h(n) , h(n) = no(1) , h(n) > n, die sich in polynomieller Zeit auswerten lassen.

Bemerkung 9.1.2. Sei Un die Gleichverteilung auf {0, 1}n. Wir schreiben x ∈D {0, 1}n , falls x bez¨ uglich der Verteilung D aus {0, 1}n gewählt wird.

Definition 9.1.3. 1. Der Zufallsgenerator (Gn )n∈N vom Typ h ist perfekt, wenn Gn (Un ) und (Uh(n) ) polynomiell nicht unterscheidbar sind, d.h. f¨ ur alle probabilistisch polynomiellen Algorithmen A und alle k > 0 gibt es ein n0 , so dass f¨ ur alle n ≥ n0 |Ws(A(t) = 1|t ∈ Gn (Un )) − Ws(A(t) = 1|t ∈ Uh(n) )|
0 ein n0 existiert, so dass f¨ ur alle n ≥ n0 und alle p < n gilt 1 1 |Ws(A(t1 , t2 , . . . , tp ) = tp+1 |t ∈ Gn (Un )) − | < k . 2 n Analog definierten wir Zufallsgeneratoren, die nach links vorhersagbar sind.

Satz 9.1.4. Ein Zufallsgenerator ist genau dann perfekt, wenn er nach rechts unvorhersagbar ist. Beweis: Wir nehmen zunächst an, dass der Zufallsgenerator nach rechts vorhersagbar ist, d.h. dass es einen Algorithmus A gibt, der bei Eingabe von x1 , . . . , xi den Wert xi+1 mit Wahrscheinlichkeit ≥ 12 + n−k vorhersagen kann. Sei t ∈ {0, 1}h(n) gegeben. Definiere einen Algorithmus A0 durch 1 falls A den Wert ti+1 bei Eingabe von t1 , . . . , ti richtig vorhersagt, 0 A = 0 sonst. Dann gilt |W s(A0 (t) = 1)|t ∈ Gn (Un )) − Ws(A0 (t) = 1|t ∈ Uh(n) )| 1 = |W s(A0 (t) = 1)|t ∈ Gn (Un )) − | 2 1 1 = |W s(A(t1 , . . . , ti ) = ti+1 ) − | ≥ k 2 n

86

9.1


f¨ ur ein k. Also ist Gn (Un ) polynomiell von Uh(n) unterscheidbar. Nun betrachten wir die andere Richtung. Wir nehmen also an, dass es einen Algorithmus A, ein k > 0 und endliche viele n ∈ N gibt, so dass |Ws(A(t) = 1|t ∈ UGn (Un ) ) − Ws(A(t) = 1|t ∈ Uh(n) )| ≥

1 . nk

Betrachte die Folge x1 . . . xh(n) r1 . . . rh(n) mit x1 . . . xh(n) ∈Gn (Un ) {0, 1}h(n) und r1 . . . rh(n) ∈U (hn ) {0, 1}h(n) . Sei pi = Ws(A(x1 . . . xi ri+1 . . . rh(n) ) = 1). Es gilt |ph(n) − p0 | ≥

1 , nk

da f¨ ur i = h(n) die Folge in Gn (Un ) liegt und f¨ ur i = 0 die Folge gemäß Uh(n) gewählt wurde. Nach der Dreiecksungleichung existiert ein i mit |pi − pi+1 | ≥

1 n−k ≥ k0 h(n) n

f¨ ur eine von k abhängige Zahl k 0 . Es gelte o.B.d.A. pi+1 > pi . Wir konstruieren nun einen Algorithmus A0 zur Vorhersage von xi+1 . Der Algorithmus erhält als Eingabe x1 . . . xi , diesen String f¨ ullt er zunächst mit zufälligen Bits auf einen String x1 . . . xi ri+1 . . . rh(n) der Länge h(n) auf. Es sei ri+1 , falls A(x1 , . . . , xi , ri+1 , . . . , rh(n) ) = 1 0 A (x1 , . . . , xi ) = ri+1 sonst. wobei ri+1 gerade das Komplement von ri+1 bezeichne. Es gilt Ws(A0 (x1 , . . . , xi ) = xi+1 |xi+1 = ri+1 ) = Ws(A(x1 , . . . xi+1 ri+1 . . . rh(n) ) = 1) = pi+1 . Setze p˜ := Ws(A0 (x1 , . . . , xi ) = xi+1 |xi+1 6= ri+1 ) = Ws(A(x1 . . . xi xi+1 ri+2 . . . rh(n) ) = 0. Wir haben 1 Ws(A(x1 . . . xi ri+1 . . . rh(n) ) = 1|ri+1 = xi+1 ) 2 1 1 = xi+1 = (pi+1 − (1 − p˜)) = (pi+1 + 1 − p˜). 2 2

pi = Ws(A(x1 . . . xi ri+1 . . . rh(n) ) = 1) = +Ws(A(x1 . . . xi ri+1 . . . rh(n) = 1)|ri+1

9.2

87

Der Blum-Blum-Shup Generator

Somit folgt p˜ = 1 + pi+1 − 2pi . Die Erfolgswahrscheinlichkeit f¨ ur eine richtige Vorhersage ist also Ws(A0 (x1 . . . xi ) = xi+1 ) 1 = (Ws(A0 (x1 . . . xi ) = ri+1 |xi+1 = ri+1 ) + Ws(A0 (x1 . . . xi ) = ri+1 |xi+1 = ri+1 )) 2 1 1 1 = (pi+1 + p˜) = (pi+1 + 1 + pi+1 − 2pi ) = + pi+1 − pi . 2 2 2 Somit hat der Algorithmus A0 bei der Vorhersage des (i + 1)-ten Bits einen Vorteil von ≥ n1k0 . Aus diesem Satz folgt offensichtlich Korollar 9.1.5. Ein Zufallsgenerator ist genau dann nach rechts vorhersagbar, wenn er nach links vorhersagbar ist. Beweis: Denn mit x = x1 . . . xh(n) ist auch xr = xh(n) . . . x1 pseudozufällig. 9.2


Zur Erzeugung des Blum-Blum-Shup Zufallsgenerators wählt man zwei grosse Primzahlen p und q mit p, q ≡ 3 mod 4 und bildet n = p · q. Der Zufallsgenerator wird mit der Zahl n und einem quadratischen Rest x1 = x modulo n initialisiert. Dann berechnen wir xi+1 = x2i

mod n

f¨ ur i = 1, . . . , h(n) − 1. Ausgabe ist [xi ]n mod 2 f¨ ur i = 1, . . . , h(n), wobei [xi ]n den kleinsten positiven Rest von xi modulo n bezeichnet. Die quadratische Residuositätsannahme: Gegeben ein z mit Jacobi-Symbol nz = 1, so gibt keinen probabilistischen polynomiellen Algorithmus, der mit Erfolgwahrscheinlichkeit ≥ 12 + n1k f¨ ur ein k entscheidet, ob z quadratischer Rest modulo n ist. Falls wir n faktorisieren können, können wir die quadratische Residuositätsannahme lösen. Ein anderer Algorithmus ist nicht bekannt. Satz 9.2.1. Unter der quadratischen Residuositätsannahme ist der Zufallsgenerator nach links unvorhersagbar. Beweis: Sei bi := [xi ]n

mod 2,

d.h. bi ist das i-te Ausgabebit. Angenommen es gibt einen Algorithmus, der mit Vorteilswahrscheinlichkeit n1k bei Eingabe von bi+1 , . . . , bh(n) das i-te Bit ausgibt. Wir konstruieren nun einen Algorithmus A0 , der dann mit der gleichen Vorteilswahrscheinlichkeit entscheidet, ob z quadratischer Rest

88

9.2


modulo n ist. Der Algorithmus A0 erhält als Eingabe ein z mit Jacobi-Symbol nz = 1. Entweder ist z quadratischer Rest oder −z. Er bildet nun die Folge bi+1 . . . bh(n) mit bi+1 = [z 2 ]n mod 2 usw. Dann berechnet er A(bi+1 . . . bh(n) , n) ⊕ [z]n

mod 2.

Falls er das Ergebnis 1 erhält, gibt er aus, dass z ein quadratischer Rest ist. Sonst liefert er, dass z kein quadratischer Rest modulo n ist. (Bemerke: Es gibt vier Quadratwurzeln zu einer Quadratzahl a ∈ (Z/nZ)∗ , aber nur zwei davon haben u ¨berhaupt ein positives Jacobi-Symbol.)

89

10

Implementierungsfehler

Gute Kryptographie beschränkt sich nicht auf ein paar mathematische Grundlagen. Selbst wenn die besten Mathematiker u ¨ber die Sicherheit von z.B. Systemen mit elliptischen Kurven nachdenken, so kann eine schlechte Implementierung eines Systems schnell dazuf¨ uhren, dass man den geheimen Schl¨ ussel in Sekunden berechnen oder die Nachricht mit hoher Wahrscheinlichkeit entschl¨ usseln kann. Kryptographie in der Praxis ist also wirklich anspruchsvoll, denn Fehler können sich leicht einschleichen! Wir geben hier zwei prominente Beispiele, die auf der Crypto 1998 und der Eurocrypt 2004 vorgestellt wurden. 10.1 10.1.1

Bleichenbachers Attacke gegen PKCS#1 Das Format des Eingabetextes

Der Angriff von Bleichenbacher richtet sich gegen eine spezielle standardisierte Variante PKCS#1 der RSA-Verschl¨ usselung. Um seine Idee zu verstehen, m¨ ussen wir uns erst zunächst mit dem Standard PKCS#1 beschäftigen. Dieser arbeitet also mit einer RSA-Verschl¨ usselung, d.h. wir haben öffentliche Schl¨ ussel n und e und geheime Schl¨ ussel p, q und d mit ed ≡ 1 mod ϕ(n). Zudem sei k die Bytelänge von n, also 28(k−1) ≤ n < 28k . Eine Nachricht, d.h. ein zu verschl¨ usselnder Datenblock ist nun in der Regel viel k¨ urzer als k Bytes. Er wird nun in folgende Struktur eingebettet: 00 02

padding string

00

data block .

Das bedeutet, der Datenblock, d.h. die Nachricht, sollte zunächst höchstens k − 11 Bytes besitzen. Sagen wir, der Datenblock habe |D| Bytes. Dann wird ein zufälliger String (padding string) von k − 3 − |D| von 0 verschiedenen Bytes erzeugt. Bemerke, dass die Länge dieses String stets ≥ 8 ist. Schliesslich hängen wir diesem String die Bytes 00 und 02 an, dann kommt der zufällig String, dann ein Nullbytes und schließlich die Nachricht (der Datenblock). So erhalten wir eine Zahl x mit k Bytes. Der Verschl¨ usselungstext ist c ≡ xe mod n. Der Empfänger erhält nun c und versucht daraus, die Nachricht zu gewinnen. Er entschl¨ usselt c und erhält so x. Die ersten 10 Bytes von x sind f¨ ur ihn nicht interessant. Er sucht ab dem 11. Byte f¨ ur ein Byte, das identisch 0 ist. Dann nimmt er an, dass die folgenden Bytes den Nachrichtentext enthalten. Wir halten folgende Definition fest: Definition 10.1.1. Ein Datensatz x = x1 ||x2 || . . . ||xk

90

10.1

Bleichenbachers Attacke gegen PKCS#1

bestehend aus k Bytes heisst P KCS#1-konform, falls folgende Bedingungen erf¨ ullt sind: • x1 = 00, • x2 = 02, • x3 , . . . , x10 sind von 0 verschieden, • mindestens ein Byte von x11 bis xk ist identisch 0.

Der Angriff von Bleichenbacher ist eine adaptiv-chosen-ciphertext Attacke. Genauer: der Angreifer hat Zugang zu einem Orakel. Bei Eingabe eines Geheimtextes gibt dieses Orakel allerdings nur aus, ob der entsprechende entschl¨ usselte Text P KCS#1-konform ist. Der Angreifer kann bei der Auswahl seiner Nachrichten ber¨ ucksichtigen, was das Orakel bisher zur¨ uckgegeben hat (adaptiv!). Eine solche Attacke ist wesentlich realisistischer als eine gewöhnliche chosen-ciphertextAttacke, bei der der Angreifer immer gleich den ganzen Nachrichtentext erhält. Wir können uns z.B. vorstellen, dass der Angreifer seine Geheimtexte an einen Server schickt, der diese abweist, falls sie nicht P KCS#1-konform sind. 10.1.2

Der Angriff

Wir skizzieren zunächst die wesentliche Idee, geben dann die Details und die Analyse des Algorithmus. Angenommen, der Angreifer habe ein c gegeben und sucht m ≡ cd mod n. Der Angreifer wählt nun ganze Zahlen s und bildet c0 ≡ cse

mod n

und sendet c0 an das Orakel. Falls das Orakel akzeptiert, weiss er, dass c0 PKCS#1konform ist. In diesem Fall, kennt er die beiden ersten Bytes von ms nämlich 00 und 02. Setze B = 28(k−2) . Dann impliziert PKCS#1-konform, dass 2B ≤ ms mod n < 3B ist, denn eine Zahl mit 4ärer Entwicklung 0002x so dass x (k − 2) Bytes hat, liegt im Intervall [2B, 3B). Wir werden sehen, dass der Angreifer nach hinreichend vielen Orakel aufrufen, dass Intervall f¨ ur m immer weiter einschränken kann, dass er m schliesslich findet. Betrachte dazu folgenden Algorithmus. Die Variable Mi enthält hierbei eine Menge von Intervallen, die nach dem i-ten erfolgreich gefundenen si erzeugt werden mit m ∈ I f¨ ur ein I ∈ Mi . 1. Im ersten Schritt erhält der Angreifer den Geheimtext c =: c0 , der zu dem Nachrichtentext m gehört. Wir nehmen an, dass m bereits P KCS#1-konform ist. Wir setzen M0 = {[2B, 3B − 1]} und i := 1.

10.1

91


2. (Suche f¨ ur PKCS#1-konforme Nachrichten) (a) Falls i = 1, dann wähle die kleinste positive Zahl s1 ≥ n/(3B), so dass c(s1 )e mod n PKCS#1-konform ist. (b) Falls i > 1 und die Anzahl der Intervalle in Mi−1 ist mindestens zwei, dann wähle si > si−1 so dass csei mod n PKCS#1-konform ist. (c) Angenommen Mi−1 f¨ ur i > 1 enthält nur ein Intervall [a, b]. Dann wähle kleine ganze Zahlen ri , si mit bsi−1 − B ri ≥ 2 n und 3B + ri n 2B + ri n ≤ si < b a e bis csi mod n PKCS#1-konform ist. 3. (Verkleinerung der Intervalle) Nachdem si gefunden wurde, berechnen wir Mi : 3B − 1 + rn 2B + rn Mi ← ∪(a,b,r) max(a, ), min(b, ) si si f¨ ur all [a, b] ∈ Mi−1 und bsi − 2B asi − 3B + 1 ≤r≤ . n n 4. Falls Mi nur noch ein Intervall der Länge 1 enthält, also M = [a, a], dann ist m := a der gew¨ unschte Nachrichtentext, also m = cd mod n. Falls nicht (also falls Mi mehrere Intervall enthält oder längere Intervalle), dann gehe zu Schritt 2. Bemerkung 10.1.2. (Erklärung des Algorithmus) 1. Wir starten mit s1 ≥ n/3B, da f¨ ur alle kleiner Wert ms1 nicht PKCS#1-konform ist. Denn falls s1 ∈ [2, . . . , n/3B) liegt, dann gilt ms1 < 3B · n/3B = n und ms1 ≥ 2m ≥ 4B,

also liegt ms1 im Intervall [4B, n), also ausserhalb [2B, 3B). 2. (Zur Intervallschachtelung im dritten Schritt) Um den dritten Schritt zu verstehen, nehmen wir an, können wir annehmen, dass Mi aus einem einzigen Intervall [a, b] besteht (weil wir ja u ¨ber alle möglichen Intervalle [a, b] die Vereinigung bilden). Falls nun si akzeptiert wird, gilt m ∈ [a, b] und msi mod n ∈ [2B, 3B − 1]. Es folgt asi ≤ msi = v + r · n

92

10.1


und bsi ≥ msi = v + r · n

mit v ∈ [2B, 3B − 1]. F¨ ur die Zahl r gilt somit

asi − (3B − 1) bsi − 2B ≤r≤ . n n Sei nun f¨ ur ein festes r. Dann liegt m in

also

msi = v + rn, also msi ∈ [2B + rn, 3B − 1 + rn] 2B + rn 3B − 1 + rn , [a, b] ∩ , si si

2B + rn 3B − 1 + rn m ∈ max(a, ), min(b, ) . si si

3. Nun betrachten wir Schritt 2c). Angenommen Mi = [a, b]. Angenommen wir haben ein Paar (ri , si ) gefunden, so dass msi PKCS#1-konform ist. F¨ ur ein neues Intervall gilt, dass die Intervalllänge durch B beschränkt ist. Angenommen ri ist das einzige r mit si asi − 3B + 1 bsi − 2B ≤r≤ . n n Wir erhalten

Bb Bb 1 B B ≤ ≤ ≤ . si 2B + ri n 2bsi−1 2 si−1

B unter Verwendung der Ungleichungen in Schritt 2c). In den meisten Fällen wird si−1 die Länge des Intervalls Mi−1 sein, also halbieren sich die Intervalle im Schritt 2c). Wir sehen leicht, dass - wenn wir einmal in Schritt 2c) angekommen sind - stets nur ein zulässiges r finden.

10.1.3

Analyse

¨ Die Analyse beruht auf heuristischen Uberlegungen. Die Praxis zeigt, dass diese gerechtfertigt sind. 1. Wir betrachten zunächst die Wahrscheinlichkeit Ws(P ), das ein zufällig gewählter Text P KCS#1-konform ist. Sei Ws(A) = Bn die Wahrscheinlichkeit, dass die ersten beiden Bytes von der Form 00 und 02 sind. Da 216 B > n > 28 B, folgt 2−16 < Ws(A) < 2−8 . In der Regel wird der RSA-Modul n so gewählt, dass die Bitlänge von n ein Vielfaches von 8 ist, also wir können Ws(A) ∼ 216

10.1

93


setzen. Die Wahrscheinlichkeit, dass die nächsten 8 Bytes von 0 verschieden sind und danach mindestens ein Byte identisch 0 auftritt, ist 8 k−10 ! 255 255 Ws(P |A) = 1− . 256 256 Wir erhalten f¨ ur n ≥ 2512 , also k ≥ 64, 8 54 ! 8 255 255 255 , 1− < 0.18 < Ws(P |A) < 0.97 < 256 256 256 also

0.18 · 2−16 < Ws(P ) < 0.97 · 2−8 .

Wir nehmen an, dass wir im Schnitt Ws1(P ) Orakelaufrufe f¨ ur Schritt 2a) und 2b) brauchen. 2. Als nächstes analysieren wir die Anzahl der Intervall wi in Mi nach dem i-ten Schritt. F¨ ur jedes si erhalten wir zunächst höchstens si B n verschiedene Werte f¨ ur r. Insbesondere wir M1 ungefähr s1nB Intervalle enthalten. Die Anzahl der Intervalle wi können wir wie folgt abschätzen: wi ∼ #{Anzahl der möglichen Werte f¨ ur r} · Ws(Intervall der Länge

B si

in [2B, 3B − 1] fällt in eines von wi−1 Intervallen der Länge

Falls ein Intervall der Länge sBi in [2B, 3B − 1] in eines von wi−1 Intervallen der Länge B fällt, dann muss der Anfangs oder Endpunkt schon in einem der Intervalle der si−1 Länge wi−1 liegen, und wir können dies durch 1 1 + wi−1 si si−1 abschätzen. Insgesamt ergibt sich wi ≤ 1 + 2

i−1

i B . si n

3. Betrachte nun w2 : Da s2 ungefähr von der 2/Ws(P ) ist, ergibt sich f¨ ur w2 : w2 ≤ 1 + 2(B/n)2 /Ws(P ) < 2B/(0.18n) < 1/20. Somit gilt fast immer w2 = 1 und der Schritt 2b) wird nur ein einziges Mal durchgef¨ uhrt.

B ). si−1

94

10.2

Nguyens Angriff auf OpenPGP

4. Wir analysieren nun Schritt 2c). Wie aussichtsreich ist es nun aber ein Paar (ri , si ) mit den angegebenen Bedingungen zu finden? i n 3B−1+ri n , ] ist gegeben durch Die Länge des Intervalls [ 2B+r b a 3B − 1 + ri n 2B + ri n B−1 1B −1 3B − 1 + ri n 2B + ri n − ≥ − ≥ ≥ . a b m m m 3 B Somit finden wir etwa f¨ ur jedes dritte ri auch ein passendes si . 5. Die beiden Schritte 2a) und 2b) werden (meist) nur einmal ausgef¨ uhrt. Da in 2c) in jedem Schritt die Intervalllänge in etwa halbiert wird, benötigen wir also in etwa O(log n) Schritte, um die Nachricht auf ein Intervall der Länge 1 einzugrenzen. Das System läßt sich also einfach brechen. Der Algorithmus des Angreifers ist polynomiell in der Eingabelänge log n. Bleichenbacher gibt hierf¨ ur noch eine genauere Abschätzung. 10.2


Die von Phil Zimmermann Anfang der 90er Jahre entwickelte Software Pretty Good Privacy (PGP) ist weit verbreitet. Als Gegenst¨ uck dazu gibt es eine Open Source Software, GNU Privacy Guard. Phong Nguyen hat die Version GNU Privacy Guard v1.2.3 einmal genauer betrachtet und dabei schwerwiegende Implementierungsfehler in der Implementierung der El-Gamal Signatur entdeckt. 10.2.1

Die Implementierung der El-Gamal Signatur

In Kapitel 6 haben wir bereits die El-Gamal Verschl¨ usselung kennengelernt. Die Signatur läuft analog. In der Gruppe F∗p sei der Erzeuger g gegeben. Es sei a der geheime Schl¨ ussel. Alice berechnet g a := A mod p und veröffentlicht p, g und A auf ihrer Internetseite. F¨ ur eine Signatur berechnet sie B = g k mod p f¨ ur ein zufälliges k mit (k, p − 1) = 1 und b = (m − Ba)k −1 mod p − 1. Sie sendet mit der Nachricht m die Signatur (B, b). Bob pr¨ uft nun die Signatur, in dem er die Gleichheit AB B b ≡ g m mod p verifiziert. Falls das Signaturverfahren so implementiert ist, können wir u ¨brigens leicht eine zweite g¨ ultige Signatur berechnen. Dann mit (B, b) ist auch (B, b + u(p − 1)) f¨ ur beliebiges u ∈ Z eine g¨ ultige Signatur. Bei der Schl¨ usselerzeugung des in GNU Privacy Guard v1.2.3 implementierten El-Gamal Verfahrens wird zuächst eine Primzahl p gewählt, f¨ ur die die Faktorisierung von (p − 1) vollständig bekannt ist, d.h. Y p−1=2 pi

wobei pi Bitlänge mindestens qbit (p) hat. Der Zusammenhang zwischen p und qbit ist dabei durch folgende Tabelle (Wiener Tabelle) gegeben Bitlänge von p 512 768 1024 1280 1536 1792 2028 2304 qbit 119 145 165 183 198 212 225 237

10.2

95


Ein Erzeuger von F∗p wird wie folgt berechnet: Wir starten mit g = 3. Falls g = 3 die Gruppe F∗p erzeugt, wählen wir g = 3. Ansonsten erhöhen wir g so lange, bis ein Erzeuger gefunden wurde. Die Wahl des geheimen Schl¨ ussels a ist interessant. In der Beschreibung von GPG findet sich folgender Text: Select a random number which has these properties 0 < x < p − 1. This must be a very good random number because this is the secret part. Trotzdem wird k nicht zufällig modulo p − 1 gewählt. Vielmehr wird als private Schl¨ ussel eine Zahl mit 3qbit /2 Bits bestimmt. Dies ist aber sehr viel kleiner als p ≥ 4qbit (siehe Tabelle). Dazu findet man den folgenden Kommentar: I do not see a reason to have the privates key about the same size as the size of p. It should be sufficient to have one about the size of q or the later used k plus a large safety margin. Decryption will be much faster. Nat¨ urlich wird die Verschl¨ usselung (bzw. die Signatur) mit einem kleinen Schl¨ ussel viel schneller sein. Doch ist dies auch genauso sicher. Nguyen beantwortet diese Frage mit einem klaren “Nein”. Der Paramter k wird wie folgt gewählt: Zunächst wird eine zufällige Zahl k mit ≤ 3qbit /2 Bits ausgewählt. Falls diese Zahl nicht koprim zu p − 1 ist, dann wird sie solange erhöht, bis die Bedingung (k, p − 1) = 1 erf¨ ullt ist. Die Bitlänge von k wird somit etwa 3qbit /2 Bits betragen, also ebenfalls viel kleiner als p − 1 ≥ 4qbit sein. 10.2.2

Ein wenig Gittertheorie

Wir betrachten nun die Kongruenz bk + ax ≡ m

mod p − 1

√ mit k, x viel kleiner als p. Linear Kongruenzen mit kleinen Unbekannten treten bei der Analyse von Public-KeyKryptosystemen häufig auf. Die Standardtechnik ist hier Gitterreduktion. Deshalb werden wir kurz einige Grundlagen der Gittertheorie einf¨ uhren.

Definition 10.2.1. Ein Gitter im Rm ist die Menge der möglichen Z-Linearkombinationen einer feste gewählten Menge von n ≤ m Vektoren im Rm . Genauer sei eine Gitterbasis b1 , . . . , bn ∈ Rm gegeben. Dann ist n X bi Z i=1

das zugehörige Gitter. Der Rang oder Dimension des Gitters ist n. Das Gitter heißt vollständig, falls n = m.

96

10.2


Bemerkung 10.2.2. 1. Der Vektorraum Rm sei mit√dem euklidischen Skalarprodukt < ·, · >: Rm × Rm → R versehen. Die Norm ||x|| = < x, x > induziert eine Topologie auf Rm . Wir können nun zeigen, daß eine diskrete, additive Untergruppe U des Rm stets ein ¨ Gitter ist, d.h. es existiert eine Gitterbasis (siehe Ubungen). Weiter ist aber auch jedes Gitter eine diskrete, additive Untergruppe des Rm , da jedes Gitter vom Rank n zu Zn isomorph ist. Somit sind die Gitter im Rm gerade die diskrete, additiven Untergruppen des Rm . 2. Schreibweise: Wir stellen ein Gitter als m × n-Matrix [b1 , . . . , bn ] dar, deren Spaltenvektoren die Gitterbasisvektoren sind. Definition 10.2.3. gegeben durch

1. Die Determinante eines Gitters L erzeugt von b1 , . . . , bn ist 1

(det(< bi , bj >)1≤i,j≤n ) 2 . 2. Der Fundamentalbereich eines Gitters ist gegeben durch ) ( n X ti bi |0 ≤ t1 , t2 , . . . , tn < 1 . i=1

Der Fundamentalbereich ist ein Repräsentantensystem f¨ ur Rm /L.

Satz 10.2.4. Sei L vollständig. Das Volumen der Grundmasche ist gleich dem der Gitterdeterminante. Beweis: Es gilt det(L) = | det B| (Linear Algebra: Determinante ist die einzige alternierende n-fache Multilinearform, beschreibt Volumen des Körpers, der von den Vektoren aufgespannt wird!). 1

1

det(L) = | det(B)| = (det B T B) 2 = (det(< bi , bj >1≤i,j≤n ) 2 . Die Basis eines Gitters ist - wie wir festgestellt haben - nicht eindeutig festgelegt. Betrachte z.B. das zwei-dimensionale Gitter Z2 . Hier bilden die Einheitsvektoren eine 5 Basis, aber z.B. auch die Vektoren 4 und 43 . Die Frage nach einer möglichsten ” schönen “ Basis ist nat¨ urlich. Doch was bedeutet hier schön “? ” Die Basis bestehend aus Einheitsvektoren zeichnet sich dadurch aus, daß die Basisvektoren sehr kurz sind. Wir möchten als Gitterbasen mit kurzen Basisvektoren betrachten. Dazu f¨ uhren wir die sukzessiven Minima eines Gitters ein. Definition 10.2.5. Sei || · || die euklidische Norm. Zu einem Gitter L ⊆ Rm vom Rang n sind die sukzessiven Minima λ1 , . . . , λn bez¨ uglich || · || gegeben durch   ∃ilinear unabhängige   Vektoren c1 , . . . ci ∈ Λ λi = λi (L) := inf r > 0| .   mit ||cj || ≤ r f¨ ur j = 1, 2, . . . , i

10.2

97


Das erste sukzessive Minimum ist der k¨ urzeste von 0 verschiedene Vektor des Gitters. Die Frage nach kurzen Gitterbasen oder dem k¨ urzesten Vektor in einem Gitter hat viele Anwendungen. Beispiel 10.2.6. Eine algebraische Zahl vom Grad n ist eine Zahl α, die Nullstelle eines Polynoms g(x) = an xn + an−1 xn−1 + . . . + a0 mit Koeffizienten in Z ist. Angenommen, wir haben eine algebraische Zahl α vom Grad n u ¨ber Q durch eine FließkommaApproximation α ˜ ∈ R gegeben und möchten das Minimalpolynom ausrechnen. Betrachte das Gitter   1 0 ... ... 0 0  0 1 ... ... 0 0     . . . 0 0 L=    ... 0 1  M Mα ˜ Mα ˜2 . . . M α ˜ n−1 M α ñ mit M groß. Angenommen, α hat ein Minimalpolynom an αn + an−1 αn−1 + . . . + a0 = 0 mit kleinen Koeffizienten. Dann ist der Vektor (a0 , a1 , . . . , an−1 , an )t ein kurzer Vektor in L. Wir können das Minimalpolynom also suchen, indem wir kurze Vektoren in L bestimmen.

Die Ungleichung von Minkowski gibt eine Abschätzung f¨ ur den k¨ urzesten Gittervektor. Sei γn die Hermitsche Konstante. F¨ ur kleine Dimension ist diese genau bekannt. Allgemein gilt log(πn) 1.744n n + + o(1) ≤ γn ≤ (1 + o(1)). 2πe 2πe 2πe Satz 10.2.7 (Minkowskische Ungleichung). F¨ ur jedes Gitter L vom Rang n gilt n Y i=1

n

λi (L) ≤ (γn ) 2 det L.

Somit können wir den k¨ urzesten Vektor durch r 1 n det(L) n 2πe approximieren. Falls es in L einen Vektor v gibt, der viel kleiner als diese Schranke ist, so ist dieser Vektor mit großer Wahrscheinlichkeit ein k¨ urzester Gittervektor. Es gibt einen Algorithmus, die zu einem Gitter eine gute (kurze) Gitterbasis berechnen; dieser Algorithmus heisst LLL-Algorithmus (nach seinen Erfindern A.K. Lenstra, H.W. Lenstra und L. Lovacz). Ein anderes Problem ist das Problem des n¨ ahesten Gittervektors. Gegeben einen Vektor n w ∈ R , finde einen Vektor v in L, so dass ||v − w|| minimimal ist.

98

10.2


Auch hier gilt, wenn wir einen Vektor v ∈ L gefunden haben, so dass ||v − w|| viel klei1 ner als det(L) n ist, dann ist dies mit großer Wahrscheinlichkeit der näheste Gittervektor. 1 Dann angenommen, v 0 wäre ein weiterer Vektor mit ||v 0 − w|| sehr viel kleiner als det(L) n . 1 Dann gilt ||v 0 − v|| ist ebenfalls viel kleiner als det(L) n und mit großer Wahrscheinlichkeit 0. F¨ ur den Angriff von Nguyen betrachten wir nur Gitter mit einer sehr kleinen Dimension. Hier ist das Problem des k¨ urzesten bzw. nähesten Gittervektors einfach zu lösen. Generell liefert der LLL-Algorithmus nur den k¨ urzesten Gittervektor bis auf eine von der Dimension abhängige Konstante. F¨ ur grosse Dimension 10.2.3

Der Angriff

Lemma 10.2.8. Es sei (α, β) ∈ Z2 , n ∈ N, d = ggT(α, n) und e = ggT(α, β). Setze L = {(u, v) ∈ Z2 : αu + βv ≡ 0

mod n}

Dann gilt 1. L ist ein 2-dimensionales Gitter in Z2 , 2. det(L) = n/e, 3. es existiert ein u ∈ Z mit αu + (β/e)d ≡ 0 mod n, 4. (n/d, 0) und (u, d/e) formen eine Gitterbasis von L. Beweis: Nach Definition ist L eine Untergruppe von Z2 , also ein Gitter. Weiter enthält L zwei linear unabhängige Vektoren (n, 0) und (0, n), also ist L 2-dimensional. Betrachte die Funktion f : Z2 → Z/nZ gegeben durch (u, v) 7→ αu + βv

mod n.

Dann ist f ein Gruppenhomomorphismus zwischen Z2 und Z/nZ. Das Bild von f ist die Untergruppe von Z/nZ, die von ggT(α, β) aufgespannt wird. Also hat das Bild von f genau n/e Elemente. Das Gitter L ist der Kern von f . Der Index von L in Z2 ist n/e. Damit folgt die zweite Behauptung. Es gilt (α, n) = d teilt (β/e)d. Der Vektor (u, d/e) gehört zu L. Weiter gehört auch (n/d, 0) zu L und es gilt n/d u n 0 d/e = e = det(L).

Daraus folgt die Behauptung.

Wir betrachten nun das Gitter L = {(u, v) ∈ Z2 : bu + av ≡ 0 mod p − 1}.

10.2

99


Nach Lemma 1 kann eine Basis von L einfach gefunden werden. Berechne ein beliebiges Tupel (k 0 , a0 ) ∈ Z2 mit bk 0 + Ba0 ≡ 0 mod (p − 1).

(8)

Ein solches Tupel kann wie folgt gefunden werden: Stelle den kleinsten gemeinsamen Teiler von B, b und p−1 mit dem erweiterten euklidischen Algorithmus durch eine Linearkombination in B, b und p−1 dar. Der ggT muss m teilen, also existiert ein geeignetes Vielfaches der Koeffizienten, f¨ ur das wir die Gleichung (8) erhalten. Nun gilt v = (k 0 − k, a0 − a) ∈ L und dieser Vektor liegt sehr nahe bei w = (k 0 − 23·qbit/2−1 , a0 − 23·qbit/2−1 ).

Die Zahl k hat 3qbit/2 Bits und x genau 3qbit/2 Bits. Also ergibt sich 1

||w − v|| = 2(3qbit−1)/2

Kryptographie 001

Grundbegriffe der Kryptographie 001

Kryptographie I II 001

Kryptographie I 001

Kryptographie II 001.ps.gz

Informationstheorie Codierung und Kryptographie 001.ps.gz

Einfuehrung in die Kryptographie 001.ps.gz

kryptographie

Kryptographie

Visuelle Kryptographie

Moderne Kryptographie: Eine Einführung

Einführung in die Kryptographie

Codierungstheorie und Kryptographie

Kryptographie und IT-Sicherheit

Einführung in die Kryptographie

Einfuehrung in die Kryptographie

Algorithmentechnik 001

Compilertechnik 001

Laplacetransformation 001

Gruppentheorie 001

Makrooekonomik 001

Hydromechanik 001

Kontinuumsmechanik 001

Spieltheorie 001

Elektrodynamik 001

Lebensversicherungsmathematik 001

Statistics 001

Kombinatorik 001

Knotentheorie 001

Kategorientheorie 001

Quantenmechanik 001

Kryptographie 001

Grundbegriffe der Kryptographie 001

Kryptographie I II 001

Kryptographie I 001

Kryptographie II 001.ps.gz

Informationstheorie Codierung und Kryptographie 001.ps.gz

Einfuehrung in die Kryptographie 001.ps.gz

kryptographie

Kryptographie

Visuelle Kryptographie

Moderne Kryptographie: Eine Einführung

Einführung in die Kryptographie

Codierungstheorie und Kryptographie

Kryptographie und IT-Sicherheit

Einführung in die Kryptographie

Einfuehrung in die Kryptographie

Algorithmentechnik 001

Compilertechnik 001

Laplacetransformation 001

Gruppentheorie 001

Makrooekonomik 001

Hydromechanik 001

Kontinuumsmechanik 001

Spieltheorie 001

Elektrodynamik 001

Lebensversicherungsmathematik 001

Statistics 001

Kombinatorik 001

Knotentheorie 001

Kategorientheorie 001

Quantenmechanik 001

Recommend Documents