Kryptographie 001

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

199 downloads 1387 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¨at 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¨osung 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¨orpern . . . . . . 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¨atsbasiertes 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¨ochte 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¨ochte ihr nun aber nicht einfach die Nummer schicken, da er f¨ urchtet, dass ein unbefugter Dritter die E-Mail lesen k¨onnte. Nun gibt es nat¨ urlich verschiedene M¨oglichkeiten. Wir nehmen an, dass beide ein Verschl¨ usselungssystem verwenden m¨ochten. 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¨onnte 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¨achst beschreiben. Ein unbefugter Dritter, der ihre E-Mails lesen kann, w¨ urde dann auch die Beschreibung des Systems erfahren und w¨are 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¨alt. Nun angenommen, Bob und Alice h¨atten vorausschauend vor dem Urlaub bereits ein geheimes Schl¨ usselwort {0, . . . , 9}8 vereinbart. Dann k¨onnen 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¨allig gew¨ahlt wurden, k¨onnen 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¨angig 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¨achlich perfekt sicher ist, falls das Schl¨ usselwort y1 . . . y8 nur einmal verwendet wird. Lemma 1.0.3. Sei y1 . . . y8 eine zuf¨allig gew¨ahlte Zahl besteht aus 8 Dezimalstellen, z.B. jedes yi wurde gleichverteilt aus der Menge {0, . . . , 9} gew¨ahlt. 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¨allig gew¨ahlt 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¨onnen 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¨onnen 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¨aßt, die man sich nicht ohne den

4

Geheimtext erschließen k¨onnte. 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¨at 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¨aftigen, 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¨orper, 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¨onnen dies auf zwei verschiedene Weisen tun. Die erste M¨oglichkeit besteht darin αk in Z zu berechnen und das Ergebnis modulo p zu reduzieren. Dies ist klar die schlechteste M¨oglichkeit, und wir werden gleich sehen, dass es viel besser geht. In diesem Fall sind die Zwischenergebnis sehr große ganze Zahlen. Die n¨achste M¨oglichkeit besteht darin, zun¨achst α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¨ankt 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¨aren Entwicklung k = km . . . k1 (km ist hierbei das h¨ochstwertigste 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¨ochstens 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¨otigt h¨ochstens 2blog kc Operationen wobei log den Logarithmus zur Basis 2 bezeichnet. Beweis: Es m¨ ussen dann am meisten Operationen (im Verh¨altnis zu log k) durchgef¨ uhrt werden, wenn die Bin¨ardarstellung der Zahl k aus lauter Einsen besteht. Wir sehen leicht, dass wir dann genau blog kc Verdoppelungen und blog kc Additionen ben¨otigen. Wir betrachten nun das folgende Problem: Definition 1.0.5. Sei α ein Erzeuger von F∗p und sei β ein zuf¨alliges 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¨osen. Wir berechnen einfach α, α2 , α3 , . . . bis wir ein k mit αk = β gefunden haben. Dieser Ansatz ben¨otigt 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¨osen, die schneller als der naive Ansatz sind. Wir werden diese sp¨ater kennenlernen. F¨ ur F∗p hat der beste bekannte Algorithmus eine subexponentielle Laufzeit, genauer k¨onnen 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¨osen. √ Es gibt Gruppen, f¨ ur die der beste Algorithmus O( p) ben¨otigt, 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¨ost werden kann, d.h. es gibt keine Algorithmus, der zum L¨osen 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¨onnen 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¨ater in der Vorlesung klar wird). Heutzutage sollte p mindestens 1024 Bit haben, d.h. p ∼ 21024 . Wir werden sp¨ater auch Algorithmen kennenlernen, die große Primzahlen effizient erzeugen. Betrachte F∗p und sei a ein Erzeuger von F∗p . Alice und Bob k¨onnen 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¨ahlt 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¨onnen diese Zahl nun zur Ver- und Entschl¨ usselung verwenden. Warum ist dieses System sicher? Celine kennt weder ka noch kb aber wir k¨onnen 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¨osen, auch das Computational Diffie-Hellmann Problem l¨osen. Es ist aber nicht bekannt, ob diese beiden Probleme ¨aquivalent sind, d.h. ob es zur L¨osung des diskreten Logarithmusproblem vielleicht ausreicht, ein bestimmtes Computational Diffie-Hellmann Problem zu l¨osen. 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¨achst einmal ist das Diffie-Hellmann Schl¨ usselaustauschverfahren nicht mehr perfekt sicher. Ein Angreifer mit unendlicher Rechenkapazit¨at kann das diskrete Logarithmusproblem mit dem naiven Ansatz l¨osen und das System brechen. Dann gibt es ein weiteres Problem. Alice und Bob erhalten zun¨achst 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¨ahlt selbst eine geheime Zahl kc . Sie sendet nun an Bob eine Nachricht mi akc . Dabei f¨alscht 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¨achst 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¨onnen alle leicht gebrochen werden, sind also unsicher und werden in der Praxis nicht eingesetzt. Bei einem symmetrischen Verschl¨ usselungsverfahren teilen Sender und Empf¨anger einen gemeinsamen, geheimen Schl¨ ussel. Wir werden sp¨ater 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¨oglichkeiten: Wir k¨onnen 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¨ogliche 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¨ahlt eine Nachricht seiner Wahl und l¨aß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¨ahlt einen Geheimtext seiner Wahl und l¨aß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¨achsten Angriff, der Ciphertext only Attacke, gebrochen werden kann. Betrachte dazu bei ersterem einfaches Durchprobieren und bei letzterem die Buchstabenh¨aufigkeiten. 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¨onnen. 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¨onnen 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¨alften gleicher L¨ange 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¨are 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¨ange 64. Der Nachrichtentext hat hier eine L¨ange von 64 Bits, der Schl¨ ussel K eine L¨ange von 64 Bits (von den 64 Schl¨ usselbits sind aber nur 56 frei w¨ahlbar). Der Geheimtext hat ebenfalls 64 Bits. Davon sind aber nur 56 frei w¨ahlbar. 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¨ange 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¨achste 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¨are Wort b1 b6 die bin¨are Darstellung von einer Zeile in Sj an. Die restlichen 4 Bits b2 . . . b5 geben die bin¨are Darstellung einer Spalte von Sj an. Ausgabe ist Cj = Sj (Bj ) f¨ ur 1 ≤ j ≤ 8. 4. Der Bitstring C = C1 . . . C8 der L¨ange 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¨ardarstellung 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¨ahlbar, 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¨ange 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¨arer Linksshift um vi Stellen aus Ci−1 Di ← zirkul¨arer 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¨ange fest vorgegeben ist. So hat sich ergeben, dass einfaches DES (Schl¨ ussell¨ange 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¨angen 128 Bits, 192 Bits, 256 Bits. Beachte, dass 128 Bits nach heutigem Stand sicher sind (In ein paar Jahren kann sich dies aber ¨andern).

14

2.3

AES

Die Anzahl der Runden N ist von der gew¨ahlten Schl¨ ussell¨ange abh¨angig: 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¨anken wir uns auf Schl¨ ussell¨ange 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¨orpers F28 aufgefasst. Betrachte das Polynom f (x) = x8 + x4 + x3 + x + 1 ∈ F2 [x]. Dieses ist irreduzibel, also definiert es einen K¨orper 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¨onnen Bytes multipliziert und addiert werden und falls b nicht der Nullvektor ist, k¨onnen 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¨alt 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¨arzahl 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¨age 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¨arts durch. 2.4

Angriffe auf symmetrische Kryptosysteme

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 ¨offentlich 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¨onnen. 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¨onnen wir den XOR-Output von Sj berechnen. Es stellt sich heraus, dass die Ausgaben nicht gleichverteilt sind (siehe Tabelle). Diese Diskrepanz k¨onnen 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

Angriffe auf symmetrische Kryptosysteme

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¨angt 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¨ange 6, Cj ist ein Bitstring der L¨ange 4 wie oben beschrieben. Setze testj (Ej , Ej∗ , Cj ) := {Ej ⊕ Bj : Bj ∈ INj (Ej0 , Cj )} mit Ej0 = Ej ⊕ Ej∗ .

2.4

19

Angriffe auf symmetrische Kryptosysteme

Dann enth¨alt testj (Ej , Ej∗ , Cj ) den Schl¨ usselstring Jj . Die Menge testj (Ej , Ej∗ , Cj ) enth¨alt dann genau Nj (Ej0 , Cj ) Bitstrings. ˜ ∗ , C˜j haben, m¨ Falls wir ein zweites Triple E˜j , E ussen die m¨ogliche 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¨onnen 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¨origen Geheimtexten L0 R 0 L0∗ R∗0

L3 R 3

L3∗ R∗3 . Diese w¨ahlen wir sp¨ater 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¨ahlen 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¨onnen wir nun die Schnitte der Mengen test1 , . . . , test8 bestimmen. Wir finden so 48 Bits des Schl¨ usselstrings. Die restlichen k¨onnen 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¨onnen 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¨ange ` kann Nachrichten der L¨ange ` verschl¨ usseln. In der Regel ist unser Nachrichtentext jedoch viel l¨anger. Um l¨angere Nachrichten zu verschl¨ usseln, m¨ ussen wir definieren, wie der Blockchiffre angewendet wird. Daf¨ ur gibt es mehrere M¨oglichkeiten:

21

¨ Ubungsaufgaben

2.6

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

. . .xi ↓↓ . . .yi

Vorteile: Ver¨anderung von xj , ¨andert nur yj . Nachteile: gleiche Textteile werden gleich verschl¨ usselt, ung¨ unstig, falls Text wenig Ver¨anderung enth¨alt • 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¨ocke ver¨andert. • 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¨anderung von xj ¨andert 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¨aren Rechtsshift der L¨ange 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¨orper 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¨oglich 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¨ochte, 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]

vec[2] vec[6] vec[10] vec[14] vec[18] vec[22] vec[26] vec[30]

vec[3] vec[7] vec[11] vec[15] vec[19] vec[23] vec[27] vec[31]

vec[4] vec[8] vec[12] vec[16] vec[20] vec[24] vec[28] vec[32]

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

Die Expansionsfunktion erh¨alt als Eingabe einen Bitstring der L¨ange 32, A = (a1 , . . . , a32 ), und gibt einen Bitstring der L¨ange 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 ¨offentlichen Schl¨ ussel. Der ¨offentliche Schl¨ ussel ist allgemein bekannt; er kann z.B. auf einer Internetseite ver¨offentlicht werden. Der private Schl¨ ussel, der aus dem ¨offentlichen Schl¨ ussel und den Systemparametern berechnet wird, ist nur dem Empf¨anger (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 ¨offenen l¨asst. Offnen l¨asst 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¨asst 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 ¨offentliche (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 ¨offentliche 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¨origen privaten Schl¨ ussel d bestimmen m¨ ussen. Falls wir n faktorisieren k¨onnen, k¨onnen 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¨onnen 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¨atstheorie 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¨osen kann. Dieses sind nun sicher Probleme, die effizient gel¨ost werden k¨onnen. 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¨alt. Diese Anzahl der Zufallsbits soll ebenfalls polynomiell in der Eingabegr¨oße beschr¨ankt 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¨atzlich 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¨ohnlich x ∈ M . Die Bezeichnung x ∈R M verwenden wir nun, um zu beschreiben, dass x zuf¨allig, gleichverteilt aus M gew¨ahlt wird. Beispiel 3.1.1. Sei n ∈ N, n = p · q, p, q prim, gegeben. Angenommen, wir wollen einen Teiler finden. Dann k¨onnen wir folgenden Algorithmus verwenden: W¨ahle 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¨ange ben¨otigt, aber im Allgemeinen ist die Anzahl der Runden nicht durch ein Polynom in der Eingabel¨ange (hier: log n) beschr¨ankt. 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¨assigbare Funktion vA existiert, so dass f¨ ur hinreichend große Eingaben die Wahrscheinlichkeit, dass A erfolgreich terminiert, durch vA beschr¨ankt 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¨angt.

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¨ange 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¨alt Asymptotik. Es wird nichts u ¨ ber die Schwierigkeit der Invertierbarkeit f¨ ur Eingaben beschr¨ankter L¨ange 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¨assigbare 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¨achstes betrachten wir Einwegfunktionen, die eine zus¨atzliche 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¨asst 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¨ange zugeschnitten sein. Sie sind im Allgemeinen viel flexibler als symmetrische Verfahren. Mit der gleichen Einwegfunktion lassen sich Nachrichten unterschiedlicher L¨ange verschl¨ usseln. Wir m¨ ussen deshalb auch unsere Definition etwas flexibler gestalten. Angenommen wir haben eine Familie P = {Pn |n ∈ N} von Nachrichtenr¨aume Pn . Die Nachrichten in Pn sind alle in {0, 1}n . Wir nehmen an, dass die Wahrscheinlichkeitsverteilung auf diesen R¨aumen die Gleichverteilung ist. Dies bedeutet, falls x ∈ Pn fest und wir w¨ahlen ein y ∈ Pn aus, dann gilt: Ws(x = y) = |P1n | . Dies ist nur zur Vereinfachung, wir k¨onnten 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¨ahlt, 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¨angig 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¨ahlen wir einmal auf, was wir intuitiv von einem Kryptosystem erwarten: • privater Schl¨ ussel nicht aus dem ¨offentlichen Schl¨ ussel berechenbar • mit hoher Wahrscheinlichkeit soll es nicht m¨oglich 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¨andige Zerst¨orung: Schl¨ ussel wird gefunden! 2. partielle Zerst¨orung: der Angriff ist f¨ ur Geheimtexte mit einer bestimmten Wahrscheinlichkeit erfolgreich; man erh¨alt 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¨alligen 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¨assigbare 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¨ange n haben wir Ws(A(ekp , m0 , m1 , c) = i|ekp ← C(1n ), i ∈R {0, 1}; c ← ekp (mi )) <

1 + v(n). 2

Bemerkung 3.4.2. Die Schreibweise c ← ekp (m) deutet schon darauf hin, dass die Verschl¨ usselung nicht mehr deterministisch sein muss. Vielmehr kann ein deterministischer Verschl¨ usselungsalgorithmus sogar gar nicht polynomiell ununterscheidbar sein. Gegeben f , m0 , m1 , c ∈ {f (m1 ), f (m0 )} k¨onnen wir c = f (m0 ) oder c = f (m1 ) einfach durch Auswertung von f entscheiden. Dies motiviert auch die Definition in Abschnitt 3.3. 3.4.2

Semantische Sicherheit

Es sei Pn Menge der m¨oglichen Nachrichtentexte der L¨ange n. Betrachte die Funktion h : Pn → {0, 1}∗ . Der Wert h(m) ist Information u ¨ber m (z.B. h(m) = 1 falls “e”∈ m und 0 sonst). Spiel 1: Ich sage dem Angreifer, dass ich m ∈ Pn w¨ahle, |m| = n, und bitte ihn h(m) zu erraten. ur m ∈ Pn und bitte ihn, h(m) zu erraten. Spiel 2: Ich verrate dem Angreifer α ∈ E(m) f¨ Semantische Sicherheit ist gegeben, wenn die Erfolgswahrscheinlichkeit des Angreifers f¨ ur

32

3.4

Sicherheitsbeweise

beide Spiele gleich ist. Wir geben noch die formale Definition. Beachte: Wir nehmen wieder an, dass wir auf dem Raum der Nachrichten eine Gleichverteilung haben. Wir k¨onnen die Definition aber f¨ ur andere Verteilungen anpassen. Definition 3.4.3. Eine Familie H = {h : Pn → Σ∗ } heißt polynomiell verifizierbar, falls es ein k gibt, so dass f¨ ur alle x ∈ Pn und h ∈ H gilt, dass |h(x)| < nk . Außerdem verlangen wir, dass eine Familie von Algorithmen {An }n∈N gibt, so daß f¨ ur alle x ∈ Pn gilt: An (x, h(x)) = 1 und An (x, y) = 0, falls y 6= h(x). Definition 3.4.4. Sei C ein Public-Key Kryptosystem. Es sei P = {Pn }n∈N ein Nachrichtenraum, und wir nehmen an, dass die Wahrscheinlichkeitsverteilung auf jedem einzelnen Pn die Gleichverteilung ist. Sei H = {h : Pn → Σ∗ } eine Familie polynomiell verifizierbarer Funktionen. Setze |m ∈ h−1 (v)| , pPn := max∗ v∈Σ |Pn |

Dann heißt C semantisch sicher, falls es eine vernachl¨assigbare Funktion v gibt, so dass f¨ ur alle m¨oglichen P, alle Familien {hn }n∈N , alle probabilistischen polynomiellen Familien von Algorithmen {An }n∈N und f¨ ur n hinreichend groß gilt: Ws(An (ekp , c) = hn (m)|m ∈R Pn , E ← C(1n ), c ← ekp (m)) < pPn + v(n).

Die Wahrscheinlichkeit pPn gibt gerade die Erfolgswahrscheinlichkeit f¨ ur das Spiel A an. Hier kennen wir nicht mehr als den Nachrichtenraum und dessen Wahrscheinlichkeitsverteilung. Falls nun f¨ ur fast alle Nachrichten h(m) = 1 gilt, k¨onnen wir nat¨ urlich tippen, dass auch f¨ ur unsere spezielle Nachricht m0 h(m0 ) = 1 gilt. Wir sehen an der Definition, dass wir auch hier wieder einen Unterschied zulassen. Die Wahrscheinlichkeiten m¨ ussen also nicht unbedingt gleich sein. Die Differenz sollte jedoch eine vernachl¨assigbare Funktion sein. Diese Definition l¨asst sich auch f¨ ur beliebige Wahrscheinlichkeitsverteilungen auf Pn formulieren. Hier ist dann die Definition von pPn etwas komplizierter. Satz 3.4.5. Eine PKC C ist ununterscheidbar sicher genau dann, wenn es semantisch sicher ist. Beweis: Wir m¨ ussen zwei Richtungen zeigen. Zun¨achst nehmen wir an, dass C nicht ununterscheidbar ist. Angenommen, es gibt also einen Algorithmus A, der zwei Nachrichten m1 , m2 der L¨ange n unterscheiden kann. Dann nehmen wir an, daß Pn der Nachrichtenraum ist, der nur aus diesen zwei Nachrichten besteht. Dann k¨onnen wir die Funktion h : Pn → Σ∗ mit h(m0 ) = 0 und h(m1 ) = 1 mit Hilfe des Algorithmus A berechnen. Somit ist das System auch nicht semantisch sicher. F¨ ur die andere Richtung nehmen wir an, dass C nicht semantisch sicher ist, d.h. es existiert ein Algorithmus A und eine Funktion h : Pn → Σ∗ , bei welcher der Algorithmus bei usselung c von m den Wert Eingabe der Verschl¨ usselungsfunktion ekp und einer Verschl¨ h(m) berechnet.

3.5

Turingsche Reduktion

33

Betrachte nun den folgenden Algorithmus B, der als Eingabe ekp , m0 , m1 und ekp (mi ) f¨ ur ein i erh¨alt und i berechnen soll: 1. Sei β := A(ekp , c). 2. Falls β = h(m0 ), aber β 6= h(m1 ), gebe 0 zur¨ uck. 3. Falls β = h(m1 ), aber β 6= h(m0 ), gebe 1 zur¨ uck. 4. Sonst w¨ahle i zuf¨allig gleichverteilt aus {0, 1}. Wir nehmen o.B.d.A. an, dass i = 0 ist. Sei p˜ die Wahrscheinlichkeit, dass f¨ ur ein zuf¨alliges Element m aus Pn h(m) = β (bei |h−1 (β)| Gleichverteilung ist dies einfach |Pn | ). Dann gilt auch Ws(β = h(m1 )) ≤ p˜. Da das ur ein k. System allerdings nicht semantisch sicher ist, folgt Ws(β = h(m0 )) ≥ p˜ + n1k f¨ Wir k¨onnen nun die Erfolgswahrscheinlichkeit q f¨ ur den Algorithmus B berechnen: q = Ws(β = h(m0 ) ∧ β 6= h(m1 )) 1 + (Ws(β = h(m0 ) = h(m1 )) + Ws(β 6∈ {h(m0 ), h(m1 )})) 2 1 = (Ws(β = h(m0 ) ∧ β 6= h(m1 )) + Ws(β 6= h(m0 ) ∧ β 6= h(m1 ))) 2 1 + (Ws(β = h(m0 )) + Ws(β 6= h(m1 ))) 2 1 = (Ws(β = h(m0 )) + 1 − Ws(β = h(m1 ))) 2 1 1 = + (Ws(β = h(m0 )) + Ws(β = h(m1 ))) 2 2 1 1 1 1 ≥ (˜ p + k − p˜) = + c . 2 n 2 2n Daraus folgt, dass das System auch nicht polynomiell ununterscheidbar ist. Beispiel 3.4.6. Viele Verschl¨ usselungsssysteme sind in ihrer urspr¨ unglichen Form nicht x semantisch sicher. Sei n das Jacobi-Symbol von x u ur die Definition und Re¨ber n (f¨ ¨ chenregeln, siehe die Ubungsaufgaben 3.6). So gilt f¨ ur RSA z.B. y x e x = = n n n da ggT(e, ϕ(n)) = 1, also e ungerade. Somit erf¨ahrt man das Jacobi-Symbol des Nachrichtentextes. 3.5

Turingsche Reduktion

Die Reduktion von einem Problem A auf ein Problem B (die auch im Beweis von Satz 3.4.5 auftritt) ist ein wichtiges Werkzeug, um die Sicherheit eines Systems zu beweisen. Definition 3.5.1. Es seien A, B zwei Probleme. Eine (Turingsche) Reduktion von A nach B ist ein Algorithmus AlgA mit folgenden Eigenschaften:

34

3.5

Turingsche Reduktion

1. AlgA nimmt an, dass es einen beliebigen Algorithmus AlgB gibt, der das Problem B l¨ost. 2. AlgA kann AlgB mit Eingaben aufrufen und dessen Ausgaben verwenden. Er weiss aber nichts ¨ uber die Berechnungen, die AlgB ausf¨ uhrt. AlgB kann man also als Black Box bzw. Orakel auffassen. 3. AlgA ist ein randomisierter polynomieller Algorithmus. 4. AlgA l¨ost A korrekt, d.h. wenn A eine Ausgabe liefert, ist diese richtig. Nach dieser Definition ist AlgA also ein Las-Vegas Algorithmus. Der Algorithmus liefert stets das richtige Ergebnis in erwartet polynomieller Zeit. TR Falls es eine Reduktion von A nach B gibt, schreiben wir A ⇒ B. Zwei Probleme heißen TR TR (Turing) ¨ aquivalent, falls A ⇒ B und B ⇒ A. Beispiel 3.5.2. Sei n = p · q, p, q prim. Es gilt: Faktorisierung und Berechnung von Quadratwurzeln modulo n sind ¨aquivalent. Nehmen wir an, dass AlgB Quadratwurzeln modulo n l¨ost. Betrachte den folgenden Algorithmus AlgA : 1. W¨ahle r ∈ (Z/nZ)∗ und berechne y = r 2 mod n. 2. Frage AlgB nach einer Quadratwurzel von y mod n. AlgB gibt x zur¨ uck. 3. Falls x ≡ ±r mod n, wiederhole den Algorithmus. Sonst p = gcd(x + r, n); q := n/p und Ausgabe “n = p × q”.

m

Die Wahrscheinlichkeit, dass AlgA nach m Runden terminiert, ist 1 − 12 . Es gilt auch die R¨ uckrichtung. Dazu betrachten wir einen Algorithmus zur Berechnung von Quadratwurzeln modulo p. Satz 3.5.3. Es sei p eine Primzahl und a ∈ (Z/pZ)∗ ein quadratischer Rest, d.h. ap = 1. Dann kann ein b ∈ (Z/pZ)∗ mit b2 = a mod p in erwartet polynomieller Zeit berechnet werden. Beweis: Betrachte folgenden Algorithmus: Eingabe: p und a Ausgabe: b 1. Schreibe p − 1 = 2r d mit d ungerade. 2. W¨ahle u ∈ (Z/pZ)∗ zuf¨allig bis up = −1.

3. Setze e := 0. F¨ ur i = 2 bis r p−1 Falls (au−e ) 2i 6≡ 1 mod p, dann e := 2i−1 + e. sonst e:=e; e

4. h := au−e mod p; b := u 2 h

d+1 2

mod p; Ausgabe b.

3.6

35

¨ Ubungen

Wir k¨onnen b berechnen, da e gerade ist. Zur Laufzeit: F¨ ur den ersten Schritt ben¨otigen wir O(log p) Operationen, f¨ ur den zweiten Schritt O((log p)2 ) Operationen, f¨ ur den dritten O((log p)4 ) und f¨ ur den vierten Schritt O((log p)2 ) Operationen. Nun zur Korrektheit: Wir sehen b2 ≡ a

mod p ⇔ (au−e )

p−1 2r

= (au−e )d ≡ 1 mod p.

Es seien e1 = 0, e2 , . . . , er die Werte, die e im Algorithmus oben annimmmt. Wir zeigen nun durch Induktion p−1 (au−ei ) 2i ≡ 1 mod p f¨ ur i = 1, 2, . . . , r. Daraus folgt die Korrektheit des Algorithmus. F¨ ur i = 1 gilt p−1 p−1 (aue1 ) 2 = a 2 ≡ 1 mod p, da a quadratischer Rest ist. Nehmen wir nun an, dass

p−1

(au−ei−1 ) 2i−1 ≡ 1 mod p

gilt. Dann folgt

(au−ei−1 )

p−1 2i

p−1 2i

≡ ±1

mod p.

1. Fall: (au−ei−1 ) ≡ 1 mod p; in diesem Fall wird der Wert von e nicht ge¨andert, also gilt die Aussage auch f¨ ur ei = ei−1 . p−1 −ei−1 2i ≡ −1 mod p; dann gilt ei = ei−1 + 2i−1 . Also erhalten wir 2. Fall: (au ) (au−ei−1 )

p−1 2i

≡ (au−ei−1 −2

i−1

)

p−1 2i

≡ (au−ei−1 )

p−1 2i

u−

p−1 2

≡1

mod p,

da u quadratischer Nichtrest modulo p ist (vergl. 3.6, Aufgabe 2). 3.6 3.6.1

¨ Ubungen Mathematische Grundlagen

Eine Zahl a heißt quadratischer Rest modulo p, falls a 6≡ 0 mod p und ein x ∈ Z/pZ existiert mit x2 ≡ a mod p. 1. Sei n ∈ N und (Z/nZ)∗ , die Menge der in Z/nZ invertierbaren Elemente. (a) Zeige, m ∈ (Z/nZ)∗ genau dann, wenn (m, n) = 1. (b) Zeige: (Z/pZ)∗ ist zyklisch der Ordnung p − 1. (c) Sei n = p · q mit p, q prim und p 6= q. Zeige

(Z/pZ)∗ × (Z/qZ)∗ ' (Z/pqZ)∗

und

(Z/pe Z)∗ ' (Z/pZ)∗ × Z/pe−1 Z ∗

∗

(d) F¨ ur welches n ist (Z/nZ) zyklisch, falls n nicht prim?

.

36

3.6

¨ Ubungen

(e) Sei ϕ(n) = #{m ∈ (Z/nZ)∗ }. Gebe eine Formel f¨ ur ϕ(n) an.

2. Sei p 6= 2 prim. F¨ ur a ∈ Z definieren wir das Legendre-Symbol durch   0 a ≡ 0 mod p, a 1 a quadratischer Rest modulo p, =  p −1 a kein quadratischer Rest (quadratischer Nichtrest) modulo p. Zeige:

p−1 a mod p. ≡a 2 p Leite daraus einen effizienten Algorithmus zur Berechnung des Legendre-Symbols her.

3. Beweise das Kriterium von Gauss: Sei S = {1, 2, . . . , p−1 } und −S = {−1, −2, . . . , − p−1 }. Weiter sei µ die Anzahl 2 2 der Repr¨asentanten aus −S, welche zu einem Vielfachen a, 2a, 3a, . . ., p−1 mod p a kongruent sind. Dann gilt a = (−1)µ . p Hinweis: } so definiert, dass der absolut kleinste Rest `a mod p ≡ Es sei m` ∈ {0, 1, . . . , p−1 2 ±m` f¨ ur p 6= `. (a) Zeige m` 6= mk f¨ ur 1 ≤ ` 6= k ≤ (b) Folgere daraus, dass {1, 2, . . . , und

p−1 . 2

p−1 } = {m1 , m2 , . . . , m p−1 } 2 2

p−1 p−1 p−1 µ !a 2 ≡ (−1) ! 2 2

Dann ergibt sich die Behauptung.

4. Beweise das quadratische Reziprozit¨atsgesetz: Seien p 6= q zwei ungerade Primzahlen. Dann gilt p−1 q−1 q p = (−1) 2 2 . q p Hinweis: (a) Sei T = {1, 2, . . . , q−1 }. Betrachte das Produkt 2 Y ζ pa − ζ −pa ζ a − ζ −a a∈T

mod p.

3.6

37

¨ Ubungen

und zeige, dass jeder Faktor im Nenner bis auf das Vorzeichen genau einmal im Z¨ahler vorkommt. Verwende die vorherige Aufgabe, um zu zeigen, dass diese Produkt gleich p q ist. (b) Zeige die Identit¨at Y xp − x−p = (η b x − η −b x−1 ) b

mod p

f¨ ur x ∈ C . Multipliziere daf¨ ur beide Seiten mit xp und betrachte die Nullstellen. (c) Folgere Y ζ pa − ζ −pa = (η b ζ a − η −b ζ −a ). (1) ζ a − ζ −a 06≡b mod p ∗

(d) Zeige nun

Y p = [(ζ 2a + ζ −2a ) − (η 2b + ζ −2b )] q a∈T,b∈S

und folgere das Reziprozit¨atsgesetz.

5. Sei n eine ungerade ganze Zahl mit der Primfaktorzerlegung n= Sei a ∈ Z. Das Jacobi-Symbol

a n

k Y

pei i .

i=1

ist definiert durch k ei a Y a = . n pi i=1

Beweise die folgenden Eigenschaften:

(a) Falls n > 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¨osungen modulo n, falls pai = 1 f¨ ur alle i ∈ {1, . . . , `} und keine L¨osung 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-¨aquivalent 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¨oß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¨ochstens (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¨onnen wir annehmen, dass a2 d ≡ −1 mod n f¨ ur ein r ∈ {0, 1, . . . , s − 1} (denn wir k¨onnen −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¨oß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¨ahle a zuf¨allig 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¨achlich zusammengesetzt. Falls der Algorithmus prim ausgibt, ist dies mit Wahrscheinlichkeit ≥ 43 richtig. Wenn wir den Test k mal wiederholen, k¨onnen wir diese Wahrscheinlichkeit auf 1−

1k 4

erh¨ohen. 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¨angige 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¨age sind, 2 betr¨agt. Unterhalb einer Schranke x w¨ urden wir also etwa f¨ ur die H¨alfte aller Primzahlen q ≤ x erwarten, dass ( dq ) = −1 gilt. Leider scheinen ¨ Beweise f¨ ur solche heuristischen Uberlegungen zur Zeit unm¨oglich. 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¨ahlen 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¨onnen 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¨achst 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¨onnen leicht pr¨ ufen, dass N keine Potenz einer Primzahl ist. Also k¨onnen wir nehmen, dass zwei verschiedene Primteiler p, q von N existieren. Desweiteren k¨onnen 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¨ahlen 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¨at (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¨ochste 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¨aß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

Der AKS-Primzahltest

2. Finde das kleinste r, so dass die Ordnung or (n) von n modulo r gr¨oß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¨oß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

Der AKS-Primzahltest

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¨amtlichen 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¨achst, dass die Restklassenabbildung π : Z[X] → Z[X]/(p, h(X)) alle Polynome in Q vom Grad < t injektiv in G abbildet. Es folgt n¨amlich 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¨asst sich aber auch so interpretieren, dass das Polynom P (Y ) = f (Y ) − g(Y ) im K¨orper 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

Der AKS-Primzahltest

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¨achste 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¨at 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¨achlich 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¨atzung 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¨otigt wird. Dann betr¨agt die asymptotische ˜ ((log n)10.5 ). Laufzeit des AKS-Algorithmus O

˜ Es l¨aßt sich leicht zeigen, dass die O-Notation bis auf Potenzen des iterierten Loga˜ ((log n)10.5 ) = rithmus die richtige Gr¨oß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¨at (4) u ¨berpr¨ dert O(log n) Multiplikationen von Polynomen vom Grad r mit Koeffizienten der Gr¨oß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¨ater auch noch kennenlernen werden. Der andere Test verwendet Gauß- oder Jacobisummen. Wer mehr dar¨ uber lesen m¨ochte, 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¨onnen 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¨achst, dass sich genau s+`−2 s Polynome vom Grad s f¨ ur s < t konstruieren lassen. Folgere dann die Behauptung durch Vollst¨andige 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 (¨offentlicher 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 ¨offentlichen 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 ¨offentlich, d geheimer Schl¨ ussel. Der Absender signiert die Nachricht durch md mod n. Der Empf¨anger pr¨ uft die Signatur ?

m = (md )e

mod n.

Signaturverfahren stellen sich, dass der angeblich Absender auch tats¨achlich 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¨osen. 5.3

RSA-Entschlu ¨sselung unter Verwendung des chinesischen Restsatzes

Mithilfe des chinesischen Restsatzes k¨onnen 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¨onnen wir die L¨osung nur einfach mit dem chinesischen Restsatz zusammensetzen. Wir betrachten die Komplexit¨at dieses Verfahrens und der naiven Methode. Der euklidische Algorithmus von `-Bit Zahl ben¨otigt 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¨ahlt 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¨onnen 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¨onnen wir ed − 1 bilden. Sei s so gew¨ahlt, 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¨ahlen wir also zuf¨allige 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¨alfte 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¨oglich nach dem chinesischen Restsatz). Wir unterscheiden zwei F¨alle: 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¨oglichkeiten (x, y) zu w¨ahlen. haben p−1 2

5.5

51

Die Wiener-Attacke

2. ord q (g k ) = ord p (g k ). Dann w¨ahle 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

<

Die Wiener-Attacke

Definition 5.5.1. Unter einem endlichen Kettenbruch versteht man einen Ausdruck der Form 1 . q1 + q2 + q3 + 1 1 ...+ q1 n

Notation: [q1 , . . . , qn ] Falls ab ∈ Q, (a, b) = 1 mit bruchs.

a b

= [q1 . . . qm ] dann nennen wir

a b

den Wert des Ketten-

Bemerkung 5.5.2. F¨ ur eine Zahl q ∈ Q k¨onnen wir eine Darstellung als Kettenbruch angeben; die qi erhalten wir aus dem Euklidischen Algorithmus. Beispiel 5.5.3. 34 99 34 = 0 × 99 + 34 99 = 2 × 34 + 31 34 = 1 × 31 + 3 31 = 10 × 3 + 1 3=3×1 q=

Dann gilt 34/99 = 0 +

1 2+

1

1+

.

1 1 10+ 3

Die N¨ ahrungsbru ur ¨che eines Kettenbruchs sind die Werte des Kettenbruchs [q1 . . . qj ] f¨ 1 ≤ j ≤ m. Es gilt der folgende Satz: Satz 5.5.4. Sei ggT(a, b) = ggT(c, d) = 1 und a c 1 | − | < 2. b d 2d Dann ist c/d eine der N¨ahrungsbr¨ uche in der Kettenbruchentwicklung von a/b.

52

5.5

Die Wiener-Attacke

¨ F¨ ur den Beweis bemerken wir zun¨achst (Beweis, siehe Ubungsaufgaben): Lemma 5.5.5. 1. Sind pm /qm und pm+1 /qm+1 zwei aufeinanderfolgende N¨ahrungsbr¨ uche f¨ ur θ, so gilt θqm − pm und θqm+1 − pm+1 haben unterschiedliche Vorzeichen. 2. Es gilt qm pm+1 − qm+1 pm = ±1.

Beweis: (von Satz 5.5.4) Also eigentlich: Sei θ eine beliebige irrationale Zahl. Wenn es eine rationale Zahl ab , b ≥ 1 mit |θ − ab | < 2b12 gibt, dann ist ab ein N¨aherungsbruch in der Kettenbruchentwicklung von θ. O.B.d.A., ggT(a, b) = 1 (sonst rechte Seite sogar gr¨oßer). uche von θ. Angenommen ab ist nicht darunter. Es gilt q0 = [θ]. Es seien pqnn die N¨aherungsbr¨ Dann gibt es ein m mit qm ≤ b < qm+1 . Beh.: |θb − a| < |θqm − pm | ist nicht m¨oglich. Angenommen |θb − a| < |θqm − pm |. Betrachte das lineare Gleichungssystem: qm x + qm+1 y = b pm x + pm+1 y = a.

(5)

Nun gilt qm pm+1 − qm+1 pm = ±1 (Lemma 5.5.5). Also ist die Determinante gleich ±1 und die Matrix in Z invertierbar. Daher existiert eine ganzzahlige L¨osung x, y. Es gilt x 6= 0 und y 6= 0: Dann falls x = 0, dann b = yqm+1 . Daraus folgt y > 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| <

1 , 2b

5.5

53

Die Wiener-Attacke

dies ist a¨quivalent zu |θ − Da

a b

6=

pm , qm

pm 1 |< . qm 2bqm

folgt |bpm − aqm | pm a 1 ≤ =| − | bqm |bqm | qm b a pm | + |θ − | ≤ |θ − qm b 1 1 ≤ + , 2bqm 2b2

also qm > 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 =| |<| | nd nd √ 3t 3t n |= √ . <| dn d n 1

Da t < d, 3t < 3d < n 4 , gilt e 1 t 3t 1 | − |< √ < . 1 < n d 3d2 d n dn 4 Somit ist t/d eine gute Approximation zu b/n. Nach Satz 5.5.4 ist t/d eine N¨ahrungsbruch in der Kettenbruchentwicklung von e/n. Wir kennen e/n, k¨onnen also mit der Kettenbruchentwicklung von e/n auch t/d leicht berechnen (siehe n¨achstes Beispiel).

54

5.6

Textbook-RSA ist unsicher

Beispiel 5.5.7. Betrachte folgendes (kleines) Beispiel: Es sei n = 50393643546789 und e = 97778702466283. Wir berechnen die Kettenbruchentwicklung von ne : [0, 5, 6, 2, 12625, 1, 4, 2, 1, 1 . . .] und betrachten die N¨aherungsbr¨ uche. F¨ ur den N¨aherungsbruch. Wir erhalten (q1 /q2 ) = 13 [0, 5, 6, 2] = 67 . Berechne q2 · e − 1 67 · e − 1 = ϕ(n) = q1 13 und l¨ose x2 − (n − ϕ(n) + 1)x + n. Wir erhalten so die quadratische Gleichung

x2 − 45822870x + 503936435456789. Diese l¨aßt sich tats¨achlich faktorisieren, q = 18329141 und p = 27493729. 5.6

Textbook-RSA ist unsicher

Betrachte den folgenden Angriff. Sei M ein Sitzungsschl¨ ussel der L¨ange m (m Bits), der mit RSA verschl¨ usselt wird. Dann m 2 zeigen wir, dass wir dieses Problem mit 2 Opoerationen (statt vollst¨andige Suche = 2m Operationen) l¨osen k¨onnen. Setze M = M1 M2 mit M1 ≤ 2m1 und M2 ≤ 2m2 . Es gibt experimentelle Ergebnisse, die 18 von dieser Form mit m1 , zeigen, dass eine zuf¨allige Zahl M mit Wahrscheinlichkeit 100 m m2 ' 2 ist. Wir haben c = M e = (M1 M2 )e mod n, also c = M1e mod n. M2e ur M2 ≤ 2m2 und speichern die jeweiligen Wir berechnen nun alle m¨oglichen Werte Mc e f¨ 2 Hashwerte (z.B. die 2 max(m1 , m2 ) kleinsten Bits von Mc e ) in einer Tabelle. Anschließend 2 berechnen wir M1e mod n f¨ ur alle M1 ≤ 2m1 und vergleichen den Hashwert jeweils mit der Tabelle. Der Speicheraufwand hierf¨ ur ist O(2m1 +1 max(m1 , m2 )), die Anzahl der modularen Expom m1 m2 nentiationen 2 + 2 ' 2 2 . Ein 40 Bit Sitzungsschl¨ ussel kann in etwa einer halben Stunde auf einem gew¨ohnlichen PC berechnet werden. 5.7

Optimal Asymmetric Encryption Padding

Wie wir gesehen haben, ist RSA in der Textbook-Version nicht sicher. Wir werden nun ein gegebenes Public-Key Kryptosystem in ein Protokoll umwandeln, f¨ ur das wir zeigen k¨onnen, das es semantisch sicher ist, und zwar unter der Voraussetzung, dass die zugrundeliegende Einwegfunktion wirklich eine Einwegfunktion ist. Wir erinnern noch einmal an das Problem der Geheimtext-Ununterscheidbarkeit:

5.7

Optimal Asymmetric Encryption Padding

55

Gegeben eine Verschl¨ usselungsfunktion f : P → C, zwei Nachrichten x1 , x2 ∈ X und y = f (xi ) mit i ∈ {1, 2}. Ist i = 1? Eine deterministische Verschl¨ usselungsfunktion f wird niemals die Eigenschaft besitzen, dass wir zwei Geheimtext nicht unterscheiden k¨onnen, denn wir k¨onenn das Problem durch Auswertung f (xi ) f¨ ur x = 1, 2 und Vergleich l¨osen. Somit muss f randomisiert sein. Sei f eine Trapdoor Einwegfunktion mit Inversem f −1 (f −1 ist die Entschl¨ usselungsfunktion!). Betrachte das folgende System. Sei F eine Familie von Trapdoor Einwegfunktionen f : {0, 1}n → {0, 1}n , G : {0, 1}n → {0, 1}m ein Zufallsorakel. Ein Zufallsorakel ist eine Funktion G, zu der wir nur Zugang durch ein Orakel haben. D.h. wir k¨onnen sie wie ein Orakel nach dem Wert G(x) f¨ ur x ∈ {0, 1}n befragen. Wir erhalten aber keine sonstigen Informationen u ¨ ber G. Um Informationen u ur eine Menge {x1 , . . . , xt } zu erhalten, m¨ ussen wir ¨ber {G(x1 ), . . . , G(xt )} f¨ das Orakel mit x1 , . . . , xt befragen. Wir wissen nicht, wie die Operationen in G aussehen, von G(x2 ) f¨ ur x2 k¨onnen wir nur Information u ¨ ber G(x1 ) erhalten, falls x1 = x2 . Definiere den Schl¨ ussel K = {(f, f −1 , G) : f ∈ F }. Sei x ∈ {0, 1}m eine Nachricht. Wir definieren eine Verschl¨ usselungsfunktion durch eK (x) = (y1 , y2 ) = (f (r), G(r) ⊕ x) f¨ ur K = (f, f −1 , G) ∈ K) und dK (y1 , y2 ) = G(f −1 (y1 )) ⊕ y2 . Die Funktionen f und G sind ¨offentlich, f −1 ist der private Schl¨ ussel (oder vielmehr die Information, die notwendig ist, um f effektiv zu invertieren). Intuition: Gegeben (f (r), G(r) ⊕ x). Um irgendwelche Information u ¨ ber x zu erhalten, brauchen wir G(r), aber daf¨ ur r, da G Zufallsorakel. Die Funktion f ist aber nicht invertierbar, da Einwegfunktion. Wir wollen nun zeigen, dass dieses System semantisch sicher ist. Daf¨ ur f¨ uhren wir einen Widerspruchsbeweis, d.h. wir nehmen an, dass ein Algorithmus UNTERSCHEIDE existiert der mit Wahrscheinlichkeit mindestens 21 + 1/nk f¨ ur k ∈ N konstant entscheidet, ob x1 oder x2 der Nachrichtentext ist, der zu y geh¨ort. Wir zeigen, dass die Funktion f mit positiver Wahrscheinlichkeit invertiert werden kann, also keine Einwegfunktion ist. Wir reduzieren das Problem, f zu invertieren, auf das Problem DISTINGUISH. Wir zeigen, dass f erfolgreich invertiert werden kann, falls UNTERSCHEIDE erfolgreich ist. Wir machen folgende Annahmen: 1. G ist ein Zufallsorakel, d.h. wenn wir irgendwelche Informationen u ¨ber G(r) erhalten wollen, m¨ ussen wir G in r auswerten. 2. Unter Verwendung des Algorithmus UNTERSCHEIDE konstruieren wir einen Algorithmus INVERT der zuf¨allig gew¨ahlte Elemente y mit Wahrscheinlichkeit gr¨o¨ser gleich > 0 invertiert.

56

5.7

Optimal Asymmetric Encryption Padding

3. Der Algorithmus INVERT ersetzt das Zufallsorakel durch eine spezielle Funktion SIM ZUFALL, deren Ausgaben alle zuf¨allige Zahlen sind. Die Funktion UNTERSCHEIDE kann SIM ZUFALL nicht von einem echten Orakel unterscheiden. Wir beschreiben INVERT: • INVERT soll y invertieren, d.h. ein r mit f (r) = y finden. Der Algorithmus konstruiert zun¨achst einen Geheimtext mit y1 = y und y2 ∈ {0, 1}m zuf¨allig. • Gegeben x1 , x2 , soll UNTERSCHEIDE nun entscheiden, ob (y1 , y2 ) eine Verschl¨ usselung x1 oder x2 ist. (Ist (y1 , y2 ) eine Verschl¨ usselung von x1 oder x2 ?) UNTERSCHEIDE hat dabei Zugang zu einer Funktion SIM ZUFALL, die das Zufallsorakel simuliert. Diese wurde von INVERT so konstruiert, dass (y1 , y2 ) tats¨achlich ein Geheimtext von x1 oder x2 ist. Die Funktion UNTERSCHEIDE kann SIM ZUFALL jedoch nicht von einem echten Orakel unterscheiden. ur die UNTERSCHEIDE es bisher 1. SIM ZUFALL hat Liste alle Eingaben (Liste 1), f¨ befragt hat und eine Liste (Liste 2) der zugeh¨origen Ausgaben. 2. Falls eine Eingabe r, f (r) = y, erf¨ ullt, dann setze SIM ZUFALL(r) so dass (y1 , y2 ) eine zul¨assige Verschl¨ usselung von x1 oder x2 (zuf¨allig gew¨ahlt) ist. Dazu w¨ahlt SIM ZUFALL xi zuf¨allig aus {x1 , x2 } und setzt SIM ZU F ALL(r) = y2 ⊕ xi . 3. Falls r bereits Eingabe war, ist SIM ZUFALL(r) schon definiert. 4. Sonst w¨ahle SIM ZUFALL(r) zuf¨allig. Bemerkung 5.7.1. SIM ZUFALL gibt vollst¨andige zuf¨allige Ausgaben zur¨ uck. Falls −1 r 6= f (y) ist seine Wahl sowieso zuf¨allig. Falls f (r) = y und (y, y2 ) Verschl¨ usselung von x1 oder x2 , dann SIM ZUFALL(r) = y2 ⊕ x2 oder y2 ⊕ x1 . Da aber y2 zuf¨allig ist, ist dieser Wert auch zuf¨allig f¨ ur r = f −1 (y). UNTERSCHEIDE kann SIM ZUFALL als nicht von Zufallsorakel unterscheiden. Die einzige Manipulation, die INVERT vorgenommen hat, dient dazu, dass (y1 , y2 ) eine zul¨assige Verschl¨ usselung von x1 oder x2 ist. Davon geht die Funktion UNTERSCHEIDE aber sowieso aus. (Ein echtes Orakel bei Eingabe von r = f −1 (y) soll was tun? Es soll (f (r), G(r) ⊕ x) ausgeben!) Somit ist die Erfolgswahrscheinlichkeit f¨ ur UNTERSCHEIDE unter Verwendung der Funk1 1 tion SIM ZUFALL auch ≥ 2 + nk . Angenommen UNTERSCHEIDE gibt eine Ausgabe (1 oder 2) zur¨ uck. Der Algorithmus INVERT pr¨ uft, ob es in Liste 1 ein Element r gibt mir f (r) = y. Falls ja, gilt r = f −1 (y) und INVERT ist erfolgriech. Wir berechnen nun die Erfolgswahrscheinlichkeit von INVERT. Es ist klar, dass 1 Ws(UNTERSCHEIDE erfolgreich|f −1 (y) 6∈ LISTE 1) = , 2 −1 da der Wert SIM ZUFALL(f (y)) v¨ollig zuf¨allig ist. Da Ws(UNTERSCHEIDE erfolgreich|f −1 (y) ∈ Liste 1) ≤ 1

5.7

57

Optimal Asymmetric Encryption Padding

folgt: 1 1 + k ≤ Ws(UNTERSCHEIDE erfolgreich) 2 n 1 ≤ W S(f −1 (y) ∈ LISTE 1) + W s(f −1 (y) 6∈ Liste 1) 2 1 ≤ W s(f −1 (y) ∈ Liste 1) + . 2 Somit

1 , nk aber das ist die Wahrscheinlichkeit, dass das Inverse berechnet wird. W s(f −1 (y) ∈ Liste 1) ≥

Wir betrachten nun die Komplexit¨at: Angenommen t1 ist die Anzahl der n¨otigen Operationen von UNTERSCHEIDE und t2 die Anzahl der n¨otigen Operationen f¨ ur die Berechnung von f . Weiter sei q die Anzahl der Orakelaufrufe von UNTERSCHEIDE. Dann ergibt sich eine Laufzeit von t1 + q 2 + qt2 Operationen (denn die Funktion SIM ZUFALL muss h¨ochstens q Elemente in der Liste 1 u ufen und braucht muß f(r) berechnen). ¨berpr¨ Wir beschreiben nun die standardisierte Variante, den Algorithmus Optimal Assymmetric Encryption Padding (OAEP). F¨ ur zwei Worte x1 , x2 bezeichne x1 ||x2 die Konkatenation, d.h. das Wort, das entsteht, wenn man die beiden W¨orter hintereinander schreibt. Es seien m, n positive Zahlen m < n, n0 = n − m und F Familie von Trapdoor Einwegfunktionen mit f : {0, 1}n → {0, 1}n f¨ ur alle f ∈ F . m n0 Weiter seien G : {0, 1} → {0, 1} und H : {0, 1}m → {0, 1}n0 zwei Zufallsfunktionen. Wir setzen P = {0, 1}m , C = {0, 1}n und K = {(f, f −1 , G, H) : f ∈ F }.

Die Funktionen f, G, H sind o¨ffentlich, f −1 ist der private Schl¨ ussel. m −1 n0 F¨ ur x ∈ {0, 1} , K = (f, f , G, H) ∈ K, r ∈ {0, 1} zuf¨allig, setze eK (x) = f (y1 ||y2 ) mit und

y1 = x ⊕ G(r), y1 ∈ {0, 1}m y2 = r ⊕ H(x ⊕ G(r)), y2 ∈ {0, 1}n0 .

Wir entschl¨ usseln, indem wir erst

f −1 (y) = y1 ||y2

mit y1 ∈ {0, 1}m , y2 ∈ {0, 1}n0 bilden. Setze dann r = y2 ⊕ H(y1 ) und dK (y) = G(r) ⊕ y1 .

58

5.8

5.8

¨ Ubungen

¨ Ubungen

1. Zeige: Sei Cj = [q1 , . . . , qj ] ein Kettenbruch mit Wert (Cj ) = cj /dj . Dann gelten folgende Rekursionsformeln  1 j=0  q1 j=1 cj =  qj cj−1 − cj−2 j ≥ 2. und

dj = 2. Beweise Lemma 5.5.5.

 

0 j=0 1 j=1  qj dj−1 + dj−2 j ≥ 2

3. Seien (n, p, q) Paramter eines RSA Kryptosystems mit q > 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 ¨offentliche 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¨ogliche Nachrichten eingrenzen? (b) Wie effizient ist das Verfahren? (c) Zeigen Sie, dass die Sicherheit des Verfahrens zur Faktorisierung ¨aquivalent ist. (d) Eigentlich kann Alice m nur bis auf 4 Nachrichten eingrenzen. Welche M¨oglichkeiten 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¨angt 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¨angt, 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ˆe ≡ m mod p, aber xˆe 6≡ m mod q, also ggT(N, xˆe − 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¨allen 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¨allen wird deshalb G zyklisch gew¨ahlt. Wir m¨ochten Gruppen betrachten, in denen das diskrete Logarithmusproblem schwer zu l¨osen ist. Betrachte dazu folgende “Definition”: Das diskrete Logarithmusproblem in einer Gruppe (G, ∗) ist schwer, falls es keinen effizienten L¨osungsalgorithmus 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¨ankung 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¨otig. 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¨onnen den diskreten Logarithmus konstruieren. p Die Laufzeit ist durch O(m) = O( |G|) gegeben. Den ben¨otigte 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¨onnen 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¨achst 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¨atzen. 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¨onnen 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¨alligen 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¨onnen. Das p Geburtstagsparadoxon soll dazu f¨ uhren, dass wir fr¨ uher als erwartet, n¨amlich 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¨oglich. 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¨osungen, die wir dann alle durchprobieren k¨onnen. √ Nach dem Geburtstagsparadoxon sind f¨ ur diesen Algorithmus im Schnitt O(| G|) Schritte n¨otig. 6.1.4

Der Algorithmus von Pohlig-Hellmann

Wir zeigen nun, dass die Schwierigkeit des DL-Problems in der Gruppe G nur vom gr¨oßten Primfaktor p der Gruppenordnung n abh¨angt. Betrachte zun¨achst 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¨osung. 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¨osung zu (7) ist, dann gilt k 0 ≡ k mod q f¨ ur jede L¨osung von (6). Um eine L¨osung f¨ ur (6) modulo q zu finden, m¨ ussen wir also nur ein DL-Problem der Ordnung q l¨osen. Analog k¨onnen wir den diskreten Logarithmus modulo p berechnen und erhalten dann mit dem chinesischen Restsatz die gew¨ unschte L¨osung modulo n. Nun nehmen wir |G| = pe f¨ ur ein e an. Dann k¨onnen 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¨angt nicht von der Gruppenordnung selbst, sondern vom gr¨oßten Primfaktor der Gruppenordnung ab. 6.2

Das generische Modell

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

64

6.2

Das generische Modell

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¨onnen 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¨aufiger aufrufen k¨onnen, k¨onnen wir auch annehmen, dass es uns bei Eingabe von n, m ∈ Z, σ(i), σ(j) die Ausgabe σ(ni+mj) liefert. So k¨onnen wir von uns aus gar keine zus¨atzlichen Elemente in der Gruppe G erzeugen. Um zus¨atzliche 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¨orpers oder auch elliptische Kurven, die wir sp¨ater 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¨ost. Der Algorithmus GENLOG w¨ahlt w¨ahrend 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¨ahlt 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¨ahlt 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¨at 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¨oß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¨at 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¨onnte 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¨osen des diskre√ ten Logarithmusproblems O( p) Operationen in G ben¨otigt, wobei p der gr¨oß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¨ossen k¨onnen, 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¨ahlt eine Primzahl p und ein primitives Element g mit < g >= F∗p . Sie w¨ahlt außerdem ihren geheimen Schl¨ ussel a ∈ {0, . . . , p − 2}. Sie setzt dann A = g a mod p und ver¨offentlicht (p, g, A), den ¨offenlichen Schl¨ ussel. Verschlu usselung einer Nachricht m ∈ {0, . . . , p − 1} w¨ahlt Bob ¨sselung: Zur Verschl¨

66

6.4

¨ Ubung - Die Index-Calculus-Methode

eine zuf¨allige 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¨osen k¨onnen. Sei dann (B, c) die verschl¨ usselte Nachricht. Der Angreifer kennt A = g a b und B = g . Da er das CDH l¨osen 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¨onnen wir gegeben g a , g b das Element g ab nicht von einem zuf¨alligen 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

¨ Ubung - Die Index-Calculus-Methode

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

6.4

67

¨ Ubung - Die Index-Calculus-Methode

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¨andig 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¨ater.) Im zweiten Schritt w¨ahlen wir zuf¨allige 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¨aren, wie wir das diskrete Logarithmusproblem f¨ ur die Elemente der Faktorbasis l¨osen, d.h. wie wir die x(q) bestimmen. Idee: W¨ahle zuf¨allige 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

¨ Ubung - Die Index-Calculus-Methode

Aufgabe 4: Vervollst¨andige 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¨onnen wir ein lineares Gleichungssystem modulo p − 1 l¨osen, 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¨oß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¨atzungen u ¨ber die Anzahl von Bglatten Zahlen ein. Aufgabe 8: Warum sind solche Absch¨atzungen 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¨achst ein beliebiger K¨orper. Definition 7.1.1. Eine elliptische Kurve u ¨ber dem K¨orper κ ist eine nicht-singul¨are 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¨are Kurve vom Geschlecht 1.” oder “Eine elliptische Kurve ist eine Abelsche Variet¨at der Dimension 1.” 2. Falls char κ 6= 2, 3, k¨onnen 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¨orper. 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¨onnen die Kurve auch als projektive Kurve auffassen. Dazu schreiben wir (z.B. in char κ 6= 2, 3) zun¨achst 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 ¨aquivalent, 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¨arer 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¨atzlich ∂F ∂F ∂F (P ) = (P ) = (P ) = 0 ∂x ∂y ∂z gilt. Wir k¨onnen leicht nachpr¨ ufen, dass z.B. im Fall char κ 6= 2, 3 durch die Bedin3 2 gung ∆ = 4a − 27b 6= 0 singul¨are Punkte ausgeschlossen werden. Ein singul¨arer Punkt (x0 , y0 ) in einer K¨orpererweiterung λ von κ w¨are ein Punkte in E(λ) mit 2y0 = 0 und 3x20 + a = 0. 6. F¨ ur κ = R k¨onnen wir die Kurve auch zeichnen (siehe weiter unten).

70

7.1

Definitionen und Grundlagen

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¨aten gez¨ahlt). Dies folgt aus dem Lemma von B´ezout, siehe [9], Lemma 3.37. Falls die elliptische Kurve u ¨ber einem K¨orper κ definiert ist und zwei Schnittpunkte in einer K¨orpererweiterung κ ⊂ λ 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¨at ist relativ schwierig zu zeigen (gutes Beispiel f¨ ur eine Gruppe, bei der die Assoziativit¨at 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¨ahlen. 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¨at drei). 2. Die Addition l¨aß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¨osungen 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¨onenn wir jetzt f¨ ur κ, λ beliebige K¨orper einsetzen, z.B. auch einen endlichen K¨orper, bei dem ja Geraden keine geometrische Interpretation besitzen. 7.2

Elliptische Kurven u orpern ¨ber endlichen K¨

Sei nun κ = Fq ein endlicher K¨orper. Beispiel 7.2.1. Sei κ = F5 der endliche Primk¨orper 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¨orper ist endlich. Es gilt offenbar #E(Fq ) ≤ 2q + 1. Da nicht jedes Element quadratischer Rest ist, erwarten wir etwa ∼ q Punkte. Tats¨achlich gilt folgender Satz.

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

Definition 7.2.4. Eine elliptische Kurve ¨ uber einem endlichen K¨orper 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¨orper ist genau dann gew¨ohnlich, wenn sie p + 1 Punkte hat. 7.3

Das DL-Problem auf einer elliptischen Kurve

Unter dem Problem des diskreten Logarithmus auf der elliptischen Kurve versteht man die folgende Fragestellung: Gegeben eine u ¨ber einem endlichen K¨orper Fq definierte Kurve und zwei Punkte P, Q aus der Punktegruppe E(Fqk ) u ¨ber einer K¨orpererweiterung 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¨asst 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¨asst sich mit dem squareand-multiply-Algorithmus aus dem ersten Kapitel leicht berechnen. • F¨ √ur vorsichtig gew¨ahlte Kurven hat der beste bekannte Algorithmus Komplexit¨at `, wobei ` der gr¨oß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¨aßt sich in O(log q) elliptischen Operationen (d.h. Punktadditionen oder -verdopplungen) berechnen. Der Punkt P 0 aus 2) l¨aßt sich in probabilistisch polynomialer Zeit in log q finden. Falls die Ordnung der Kurve prim ist, k¨onnen wir ihn sogar direkt angeben.

7.3

Das DL-Problem auf einer elliptischen Kurve

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¨at: β = Φ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¨orper reduziert. Da es f¨ ur das diskrete ∗ Logarithmusproblem in Fq subexponentieller Algorithmen gibt, k¨onnen 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¨onnen 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¨osen m¨ Logarithmusproblem in Fqk . Damit das diskrete Logarithmusproblem nicht effizient in einen endlichen K¨orper reduziert werden kann, fordern wir also, dass der gr¨oßte Primfaktor p˜ der Gruppenordnung keine der Zahlen q k −1 mit k ≤ (log q)2 teilt. Damit sind alle supersingul¨aren Kurven f¨ ur kryptographische Anwendung uninteressant, da hier k ≤ 6 gilt. F¨ ur eine zuf¨allig gew¨ahltes Paar (p, E) mit p eine Primzahl und E eine elliptische Kurve u ¨ber Fp mit #E(Fp ) = l sch¨atzen 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¨allig gew¨ahlte gew¨ohnliche 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¨onnen wir das Logarithmusproblem nach Qp liften. Diese Liftung ist sehr effizient m¨oglich, 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¨asst sich dann auf eine DL-Problem in der additiven Gruppe Fp reduzieren, das trivial mit dem euklidischen Algorithmus l¨osbar ist. Diese Kurven sind also sehr, sehr unsicher. Bei der Wahl einer u ussen wir ¨ber einem großen Primk¨orper Fp definierten Kurve m¨ deshalb darauf achten, dass #E(Fp ) 6= p ist. 3. Weil-Restriktion [8] Einige spezielle Kurven u ¨ ber K¨orpern Fpn mit einer zusammengesetzten Zahl n sind ebenfalls unsicher (also w¨ahle n = 1 oder p klein und n groß und prim).

74

7.3

Das DL-Problem auf einer elliptischen Kurve

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¨orper Fq = Fp definiert sein oder u ¨ber einem K¨orper 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¨ar sein. 4. Falls wir eine u ¨ber einem großen Primk¨orper Fp definierte Kurve w¨ahlen, 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¨oglich, u ¨ ber einem endlichen K¨orper Fq definierte Kurven zuf¨allig zu w¨ahlen und dann die Punkte zu z¨ahlen, da daf¨ ur Algorithmen existierten, die polynomiell in log q laufen. Der erste Algorithmus zum Punktez¨ahlen von Schoof hatte eine Laufzeit in (log q)8 und war somit v¨ollig 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¨ahlen. 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¨ahlalgorithmus n¨otig ist. F¨ ur mehr Details u ¨ ber Angriffe und Punktez¨ahlen 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 (¨offentlich): 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. ¨offentlicher Schl¨ Signaturerzeugung: 1. A(lice) w¨ahlt 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¨alt 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¨alt 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¨alschen.

7.5

Paarungsbasierte Kryptographie

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 ¨ahnlichen Eigenschaften. Wir f¨ uhren zun¨achst etwas Theorie ein. Sei K ein K¨orper. 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¨orper 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¨orper 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¨at) 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¨atsgesetz) 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

Paarungsbasierte Kryptographie

α hat Ordnung n. Nun k¨onnen 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¨otigen wir zun¨achst folgendes Lemma: Lemma 7.5.7. Die Gleichung x2 + 1 = 0 hat in Fp mit p ≡ 3 mod 4 keine L¨osung. 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¨osung.

78

7.5

Paarungsbasierte Kryptographie

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¨osung 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¨onnen. Wir sehen unschwer, dass wir durch Iteration erreichen k¨onnen, 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¨onnen wir dies um eine Runde reduzieren, d.h. drei Leute k¨onnen in einer Runde einen gemeinsamen Schl¨ ussel vereinbaren. Dazu vereinbaren Alice, Bob und David zun¨achst 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¨ahlen, dass es von der Form 4` − 1 ist, wobei ` ein grosser Primfaktor ist, um sich gegen Pohlig-Hellmann zu wappnen. Dann w¨ahlt jeder einen geheimen Schl¨ ussel: Alice w¨ahlt 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¨offentlichen 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¨orper F∗p schwer ist. Dies erreicht man, indem man die Primzahl ` sehr gross w¨ahlt.

7.5

79

Paarungsbasierte Kryptographie

7.5.3

Ein identi¨ atsbasiertes Kryptosystem

Die Idee bei identit¨atsbasierten Kryptosystemen besteht darin, dass sich der ¨offentliche Schl¨ ussel direkt aus Daten (etwa der email-Adresse) des Benutzers berechnen l¨aßt. Eine zentrale Autorit¨at (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 ¨offentliche Schl¨ ussel f¨ ur Bob tats¨achlich Bob geh¨ort 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 ¨offentlichen Schl¨ ussel, den geheimen Schl¨ ussel berechnen (siehe Kapitel 5). Wir stellen nun das System vor: Das Schl¨ usselcenter f¨ uhrt zun¨achst folgende Operationen durch (Initialisierung des Systems): 1. W¨ahle p = 4` − 1 mit ` prim. 2. Setze y 2 = x3 + 1

E: u ¨ ber Fp .

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

Q = sP.

6. Ver¨offentliche 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¨ahlt r ∈ F∗` zuf¨allig. 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¨achlich 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¨onnen wir das DDH Problem l¨osen, falls wir CDH l¨osen k¨onnen. 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¨osen des CDH bekannt. Das DDH Problem k¨onnen wir aber leicht l¨osen. 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¨orper 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¨at.

(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¨at (die Kenntnis eines Geheimnis), ohne von sich (von dem Geheimnis) etwas preiszugeben. Wir betrachten zun¨achst eine nicht-mathematische Realisierung.

x

linker Raum

rechter Raum

Vorraum Wir haben ein Geb¨aude bestehend aus einem Vorraum und zwei weiteren R¨aumen (linker und rechter Raum) gegeben. Die beiden oberen R¨aume sind durch eine Geheimt¨ ur (x) miteinander verbunden, die sich nur durch ein geheimes Schl¨ usselwort ¨offnen l¨asst. 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¨alt Bob bei diesem Protokoll keine Information? Offensichtlich w¨are 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¨onnen wir nicht beweisen, dass Bob keinerlei Informationen erh¨alt. F¨ ur obiges Protokoll k¨onnen 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¨allig die T¨ ur w¨ahlt, die Bob ihr sp¨ater 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¨ahlt Alice zwei grosse Primzahlen p und q und bildet n = pq. Die Zahl n ist dann ein ¨offentlicher Parameter, p und q sind geheim. Nun w¨ahlt Alice s und bildet v = s2 mod n. Die Zahl s ist ihr privater, v der zugeh¨orige ussel. ¨offentliche Schl¨ Alice soll nun Bob u ¨berzeugen, dass sie s kennt. Dazu betrachten wir folgendes Protokoll: 1. Alice w¨ahlt r ∈ (Z/nZ)∗ , bildet x := r 2 mod n und sendet x an Bob. 2. Bob w¨ahlt 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¨at b ∈ {0, 1}. 2 −b Dann schickt sie erst x˜ = r v mod n, dann y˜ = r (ganz unabh¨angig davon, was Bob macht!). Falls sie b richtig geraten hat, dann k¨onnen 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¨onnte 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¨onnen. Dies ist aber offensichtlich. Celine r¨at einfach das Bit b. Falls sie richtig r¨at, akzeptiert Bob ihre Antwort und die entsprechende Szene bleibt im Kasten. Falls sie falsch r¨at, 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 ¨offentlich) mit v = α−s , d.h. − s = logα v. Das Protokoll sieht nun wir folgt aus: 1. Alice w¨ahlt r ∈ Z/qZ und sendet x := αr mod p an Bob. 2. Bob w¨ahlt 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¨at 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¨alligen String einen l¨angeren String, der m¨oglichst zuf¨allig 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¨allige Zahlen liefert. 9.1

Definitionen und Grundlagen

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¨ahlt 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) )| <

1 . nk

2. Ein Zufallsgenerator (Gn )n∈N ist (nach rechts) unvorhersagbar, falls f¨ ur alle probabilistischen, polynomiellen Algorithmen A und alle k > 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¨achst 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

Definitionen und Grundlagen

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¨aß Uh(n) gew¨ahlt wurde. Nach der Dreiecksungleichung existiert ein i mit |pi − pi+1 | ≥

1 n−k ≥ k0 h(n) n

f¨ ur eine von k abh¨angige 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¨alt als Eingabe x1 . . . xi , diesen String f¨ ullt er zun¨achst mit zuf¨alligen Bits auf einen String x1 . . . xi ri+1 . . . rh(n) der L¨ange 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¨allig. 9.2

Der Blum-Blum-Shup Generator

Zur Erzeugung des Blum-Blum-Shup Zufallsgenerators w¨ahlt 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¨atsannahme: 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¨onnen, k¨onnen wir die quadratische Residuosit¨atsannahme l¨osen. Ein anderer Algorithmus ist nicht bekannt. Satz 9.2.1. Unter der quadratischen Residuosit¨atsannahme 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

Der Blum-Blum-Shup Generator

modulo n ist. Der Algorithmus A0 erh¨alt 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¨alt, 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¨ankt 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¨onnen 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¨achst mit dem Standard PKCS#1 besch¨aftigen. Dieser arbeitet also mit einer RSA-Verschl¨ usselung, d.h. wir haben ¨offentliche Schl¨ ussel n und e und geheime Schl¨ ussel p, q und d mit ed ≡ 1 mod ϕ(n). Zudem sei k die Bytel¨ange 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¨achst h¨ochstens k − 11 Bytes besitzen. Sagen wir, der Datenblock habe |D| Bytes. Dann wird ein zuf¨alliger String (padding string) von k − 3 − |D| von 0 verschiedenen Bytes erzeugt. Bemerke, dass die L¨ange dieses String stets ≥ 8 ist. Schliesslich h¨angen wir diesem String die Bytes 00 und 02 an, dann kommt der zuf¨allig 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¨anger erh¨alt nun c und versucht daraus, die Nachricht zu gewinnen. Er entschl¨ usselt c und erh¨alt 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¨ohnliche chosen-ciphertextAttacke, bei der der Angreifer immer gleich den ganzen Nachrichtentext erh¨alt. Wir k¨onnen 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¨achst 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¨ahlt 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¨amlich 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¨arer 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¨anken kann, dass er m schliesslich findet. Betrachte dazu folgenden Algorithmus. Die Variable Mi enth¨alt 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¨alt der Angreifer den Geheimtext c =: c0 , der zu dem Nachrichtentext m geh¨ort. Wir nehmen an, dass m bereits P KCS#1-konform ist. Wir setzen M0 = {[2B, 3B − 1]} und i := 1.

10.1

91

Bleichenbachers Attacke gegen PKCS#1

2. (Suche f¨ ur PKCS#1-konforme Nachrichten) (a) Falls i = 1, dann w¨ahle 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¨ahle si > si−1 so dass csei mod n PKCS#1-konform ist. (c) Angenommen Mi−1 f¨ ur i > 1 enth¨alt nur ein Intervall [a, b]. Dann w¨ahle 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¨ange 1 enth¨alt, 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¨alt oder l¨angere Intervalle), dann gehe zu Schritt 2. Bemerkung 10.1.2. (Erkl¨arung 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¨onnen wir annehmen, dass Mi aus einem einzigen Intervall [a, b] besteht (weil wir ja u ¨ber alle m¨oglichen 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

Bleichenbachers Attacke gegen PKCS#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¨ange durch B beschr¨ankt 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¨allen wird si−1 die L¨ange 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¨assiges r finden.

10.1.3

Analyse

¨ Die Analyse beruht auf heuristischen Uberlegungen. Die Praxis zeigt, dass diese gerechtfertigt sind. 1. Wir betrachten zun¨achst die Wahrscheinlichkeit Ws(P ), das ein zuf¨allig gew¨ahlter 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¨ahlt, dass die Bitl¨ange von n ein Vielfaches von 8 ist, also wir k¨onnen Ws(A) ∼ 216

10.1

93

Bleichenbachers Attacke gegen PKCS#1

setzen. Die Wahrscheinlichkeit, dass die n¨achsten 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¨achstes analysieren wir die Anzahl der Intervall wi in Mi nach dem i-ten Schritt. F¨ ur jedes si erhalten wir zun¨achst h¨ochstens si B n verschiedene Werte f¨ ur r. Insbesondere wir M1 ungef¨ahr s1nB Intervalle enthalten. Die Anzahl der Intervalle wi k¨onnen wir wie folgt absch¨atzen: wi ∼ #{Anzahl der m¨oglichen Werte f¨ ur r} · Ws(Intervall der L¨ange

B si

in [2B, 3B − 1] f¨allt in eines von wi−1 Intervallen der L¨ange

Falls ein Intervall der L¨ange sBi in [2B, 3B − 1] in eines von wi−1 Intervallen der L¨ange B f¨allt, dann muss der Anfangs oder Endpunkt schon in einem der Intervalle der si−1 L¨ange wi−1 liegen, und wir k¨onnen dies durch 1 1 + wi−1 si si−1 absch¨atzen. Insgesamt ergibt sich wi ≤ 1 + 2

i−1

i B . si n

3. Betrachte nun w2 : Da s2 ungef¨ahr 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¨ange 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¨ange in etwa halbiert wird, ben¨otigen wir also in etwa O(log n) Schritte, um die Nachricht auf ein Intervall der L¨ange 1 einzugrenzen. Das System l¨aßt sich also einfach brechen. Der Algorithmus des Angreifers ist polynomiell in der Eingabel¨ange log n. Bleichenbacher gibt hierf¨ ur noch eine genauere Absch¨atzung. 10.2

Nguyens Angriff auf OpenPGP

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¨auft 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¨offentlicht p, g und A auf ihrer Internetseite. F¨ ur eine Signatur berechnet sie B = g k mod p f¨ ur ein zuf¨alliges 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¨onnen 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¨achst eine Primzahl p gew¨ahlt, f¨ ur die die Faktorisierung von (p − 1) vollst¨andig bekannt ist, d.h. Y p−1=2 pi

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

10.2

95

Nguyens Angriff auf OpenPGP

Ein Erzeuger von F∗p wird wie folgt berechnet: Wir starten mit g = 3. Falls g = 3 die Gruppe F∗p erzeugt, w¨ahlen wir g = 3. Ansonsten erh¨ohen 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¨allig modulo p − 1 gew¨ahlt. 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¨ahlt: Zun¨achst wird eine zuf¨allige Zahl k mit ≤ 3qbit /2 Bits ausgew¨ahlt. Falls diese Zahl nicht koprim zu p − 1 ist, dann wird sie solange erh¨oht, bis die Bedingung (k, p − 1) = 1 erf¨ ullt ist. Die Bitl¨ange 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¨aufig 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¨oglichen Z-Linearkombinationen einer feste gew¨ahlten 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¨orige Gitter. Der Rang oder Dimension des Gitters ist n. Das Gitter heißt vollst¨andig, falls n = m.

96

10.2

Nguyens Angriff auf OpenPGP

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¨onnen 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¨asentantensystem f¨ ur Rm /L.

Satz 10.2.4. Sei L vollst¨andig. 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¨orpers, 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¨oglichsten ” sch¨onen “ Basis ist nat¨ urlich. Doch was bedeutet hier sch¨on “? ” Die Basis bestehend aus Einheitsvektoren zeichnet sich dadurch aus, daß die Basisvektoren sehr kurz sind. Wir m¨ochten 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¨angige   Vektoren c1 , . . . ci ∈ Λ λi = λi (L) := inf r > 0| .   mit ||cj || ≤ r f¨ ur j = 1, 2, . . . , i

10.2

97

Nguyens Angriff auf OpenPGP

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¨ochten 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 α ˜n 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¨onnen das Minimalpolynom also suchen, indem wir kurze Vektoren in L bestimmen.

Die Ungleichung von Minkowski gibt eine Absch¨atzung 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¨onnen 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

Nguyens Angriff auf OpenPGP

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¨aheste Gittervektor. 1 Dann angenommen, v 0 w¨are 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¨ahesten Gittervektors einfach zu l¨osen. Generell liefert der LLL-Algorithmus nur den k¨ urzesten Gittervektor bis auf eine von der Dimension abh¨angige 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¨alt L zwei linear unabh¨angige 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¨ort zu L. Weiter geh¨ort 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

Nguyens Angriff auf OpenPGP

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 << det(L) 2 .

p−1 Da det(L) = ggT(B,b,p−1) und B, b zuf¨allig, gilt det(L) ' p, also 1

||w − v|| << det(L) 2 . Mit großer Wahrscheinlichkeit ist v also der n¨aheste Gittervektor zu w in L. Dies kann sogar bewiesen werden, falls a und b uniform modulo p − 1 gew¨ahlt wurde (siehe Nguyen). Damit ergibt sich folgender Angriff: Input: Die o¨ffentlichen Parameter und eine Signatur (B, b) von m Output: Der private Schl¨ ussel a 1. Berechne eine Basis von L mit Lemma 10.2.8. 2. Berechne (a0 , k 0 ) mit

bk 0 + Ba0 ≡ m

mod (p − 1)

unter Verwendung des erweiterten euklidischen Algorithmus. 3. Berechne

w = (k 0 − 23qbit/2−1 , a0 − 23qbit/2−1 ).

4. Berechne den n¨ahesten Gittervektor v zu w. 5. Gebe x0 minus die zweite Koordinate von v aus. Alternativ k¨onnen wir auch das Gitter betrachten, das durch die Spaltenvektoren der folgenden Matrix erzeugt wird, wobei K eine große Konstante ist:   (p − 1)K  −mK  23qbit/2     bK 1 BK 1

100

10.2

Nguyens Angriff auf OpenPGP

Das Gitter enth¨alt einen kurzen Vektor (0, 23qbit/2 , k, a). Wir bestimmen also einen kurzen Vektor und hoffen, dass a der Absolutbetrag der letzten Koordinate ist. Phong Nguyen hat den Angriff implementiert, und er ist auch in der Praxis erfolgreich. 10.2.4

Rucksack-Probleme

1978 haben Merkle und Hellmann ein Kryptosystem vorgeschlagen, das auf dem sogenannten Rucksackproblem beruht. Es stellte f¨ ur kurze Zeit eine ernsthafte Alternative zu RSA dar, bis es Anfang der 80er mittels Gitterreduktion gebrochen wurde. Definition 10.2.9. Das Rucksackproblem ist das folgende Problem: Gegeben {a1 , . . . , an } positive ganze Zahlen und s=

n X

xi a i ,

i=1

bestimme xi ∈ {0, 1}, falls solche xi existieren. Das Rucksackproblem ist NP-vollst¨andig, aber in der Praxis kann es meist gel¨ost werden. Alle bisher vorgeschlagenen Kryptosysteme, die auf dem Rucksackproblem beruhen, wurden mit der Zeit gebrochen. Wir setzen nun immer voraus, dass eine L¨osung (e1 , . . . en ) ∈ {0, 1}n existiert. Statt dem Rucksackproblem k¨onnen wir auch das folgende Problem (das inverse Problem) betrachten: Gegeben {a1 , . . . , an } und s ∈ N, finde e{0, 1}n mit n X i=1

ei a i =

n X i=1

ai − s =: s

falls ein solcher Vektor e existiert. Offensichtlich lieftert jede L¨osung diese Problems auch eine L¨osung des Rucksackproblems √ durch ei =: 1−ei f¨ ur i = 1, 2, . . . , n. Der L¨osungsvektor e hat dabei L¨ange h¨ochstens n/2. Wir ordnen einem Rucksackproblem jetzt eine Dichte zu. Definition 10.2.10. Gegeben ein Rucksackproblem mit {a1 , . . . , an }, definiere die Dichte durch n d := . log(maxi=1,2,...,n ai ) F¨ ur d >> 1 erwarten wir viele m¨ogliche L¨osungen; wir werden zeigen, dass Rucksackproblem mit geringer Dichte einfach zu l¨osen sind.

10.2

101

Nguyens Angriff auf OpenPGP

Betrachte dazu das Gitter L, das von Matrix aufgespannt wird:  1 0  0 1   ...   0 0 0 0

den Spaltenvektoren (b1 , . . . , bn+1 ) der folgenden  0 Ka1 0 Ka2   ... ...  . ... 1 Kan  . . . 1Ks ... ...

√ Dabei ist K eine Konstante; wir w¨ahlen K > 21 n. Der L¨osung e des Rucksackproblems ordnen wir den Gittervektor ! n X e˜ := ei bi − bn+1 = (e1 , e2 , . . . , en , 0) i

zu.

Satz 10.2.11. Sei M > 0 beliebig. Die Rucksackaufgabe wird f¨ ur hinreichend große n f¨ ur n fast alle {a1 , . . . , an } ∈ [1, M ] mit Dichte d < 0.6463 durch zweifache Ausf¨ uhrung von A effizient gel¨ost. P Beweis: Sei t := ni=1 ai . Solange ein ai mit ai > min(s, t−s) existiert, entfernen wir dieses ai aus der Liste undP vermindern die Dimension um 1, aktualisieren s und P t. Ein ai > t − s muss Summand in ni=1 ei ai sein. Ein ai mit ai > s ist Summand in ni=1 (1 − ei )ai . Wir reduzieren so das Problem. Wenn wir das reduzierte Problem gel¨ost haben, haben wir auch das urspr¨ ungliche Problem gel¨ost. F¨ ur die reduzierte Aufgabe gilt 1 1 t≤s≤t− t n n

(9)

denn alle kleiner und gr¨oßeren ai wurden entfernt. Indem wir, falls Pn notwendig, auf das inverse Problem u ¨ bergehen, k¨onnen wir o.B.d.A. annehmen, dass i=1 ei ≤ n1 gilt.

Der Algorithmus A liefert nun einen k¨ urzesten Gittervektor x. Wir sch¨atzen die Wahrscheinlichkeit ab, dass x˜ 6= e˜ ist. F¨ ur den Vektor x˜ gilt: 1√ n, 2 x˜ ∈ L und x˜ 6∈ {0, ±˜ e}. ||˜ x|| ≤ ||˜ e|| ≤

Falls K >

q

1 n 2

folgt, dass xn+1 = 0 ist. Setze x = (x1 , . . . , xn ) und definiere n

y :=

1X xi a i . 2 i=1

(10)

102

10.2

Dann gilt |y| ≤ n

q

1 n: 2

|y| = und wegen t =

Pn

i=1

Nguyens Angriff auf OpenPGP

Aus der Cauchy-Schwarz-Ungleichung und a ∈ Nn folgt n

||x|| · ||a|| ||x|| · ||a||1 ||x|| X | < x, a > | ≤ ≤ ≤ ai s s s s i=1 ai ergibt sich mit (9) und (10) und xn+1 r t · ||x|| 1 ≤n n. |y| ≤ s 2

Sei P (n) die Wahrscheinlichkeit, dass ein x˜ mit (10) existiert, wobei die Wahrscheinlichkeit u ¨ ber alle Vektoren (a1 , . . . , an ) zuf¨allig aus [1, M ]n gebildet wird. Wir zeigen limn→∞ P (n) = 0, falls d < 0.6463. Es ist P (n) = Ws(∃˜ x 6= ±e ∈ L, ∃y ∈ Z : ||˜ x|| ≤ ||˜ e||, ≤ Ws(

n X i=1

|y| ≤ n

r

r

1 n, 2

n X

ai xi = ys)

i=1

1 n, (x, 0) 6= {0, ±˜ e}) 2 r r 1 1 n n n}| · |{y ∈ Z : ||x|| ≤ n n}|. ·|{x ∈ Z : ||x|| ≤ 2 2

= ai xi = ys, x ∈ Zn , y fest, ||x|| ≤ ||˜ e||, |y| ≤ n

Wir sch¨atzen nun die drei Faktoren auf der rechten Seite nacheinander ab: 1. Betrachte zun¨achst Ws(

n X i=1

= ai xi = ys, x ∈ Z , y fest, ||x|| ≤ ||˜ e||, |y| ≤ n n

r

1 n, (x, 0) 6= {0, ±˜ e}). 2

Es seien x ∈ Zn und y ∈ Z beliebig, aber festP mit den angegebenen Eigenschaften. Setze zi := xi − yei f¨ ur i = 1, 2, . . . , n. Wegen ni=1 ei ai = s gilt n X i=1

ai xi = ys ⇔

n X

ai zi = 0.

i=1

Der Vektor z = (z1 , . . . , zn ) ist fest. Es gilt z 6= 0, da sonst aus x = y˜ e mit x ∈ {0, ±˜ e} folgt |y| ≥ 2 und ||x|| ≥ 2||˜ e||. P Sei zj 6= 0 f¨ ur ein festes j. F¨ ur fest gew¨ahlte ai mit i 6= j ist die Gleichung ni=1 ai zi = 0 f¨ ur h¨ochstens ein aj ∈ [1, M ] erf¨ ullt. Es folgt: F aktor1 ≤ Ws(

n X i=1

ai zi = 0) ≤

1 . M

10.2

103

Nguyens Angriff auf OpenPGP

2. Lagarias und Odlyszko (LaOd85) haben gezeigt, dass f¨ ur hinreichend grosse n gilt r 1 n} ≤ 2c0 n {x ∈ Zn : ||x|| ≤ 2 mit c0 = 1.54725.

3. Es gilt

Somit ergibt sich

r ! r 1 1 n} ≤ 1 + 2 n n {y ∈ Z : |y| ≤ n 2 2 P (n) ≤ 2

Wegen

1 d

c0 n

/M

1 + 2n

r

! 1 n . 2

> 1.547269 > c0 und aus der Definition der Dicht folgt n

M ≥ max ≥ 2 d , i=1,...,n

also limn→∞ P (n) = 0. Bemerkung 10.2.12. Wir k¨onnen das Ergebnis aus dem vorherigen Satz noch verbessern, wenn wir ein anderes Gitter betrachten. In diesem Fall funktioniert der Angriff f¨ ur d < 0.98408. Betrachte dazu das Gitter, das von den Spaltenvektoren (b1 , . . . , bn+1 ) der folgenden Matrix aufgespannt wird: 1 0 . . . 0 Ka1 . √ Dabei ist K eine Konstante; wir w¨ahlen K > 21 n. Der L¨osung e des Rucksackproblems ordnen wir den Gittervektor ! n X 1 1 1 e˜ := ei bi − bn+1 = (e1 − , e2 − , . . . , en − , 0) 2 2 2 i zu. Da ei ∈ {0, 1}, folgt ||˜ e|| =

1√ n. 2

Der L¨osungsvektor ist also noch k¨ urzer als zuvor.

104

11

Literatur

1. J. Buchmann, Einf¨ uhrung in die Kryptographie, zweite Auflage 2. D. Stinson, Cryptography, Theory and Practice 3. S. Singh, 4. R. Kippenhahn, Verschl¨ usselte Botschaften

LITERATUR

1

Literatur [1] E. Bach, Analytic methods in the analysis and design of number-theoretic algorithms, A 1984 ACM Distinguished Dissertation, The MIT Press, (1985) [2] R. Balasubramanian and N. Koblitz, The improbability that an elliptic curve has subexponential discrete log problem under the Menezes-Okamoto-Vanstone Algorithm, Journal of Cryptology, 141-145, (1998) [3] D. BleichenbacherChosen Ciphertext attacks agains protocols based on the RSA Encryption Standard PKCS#1, Crypto 1998, LNCS 1440, (1998) [4] J. Buchmann, Einf¨ uhrung in die Kryptographie, 3rd edition, Springer, (2004) [5] H. Cohen, A Course in Computational Algebraic Number Theory, Springer, (1996) [6] M.J. Coster, A.Joux, B.A. LaMaccia, A.M. Odlyzko, C.-P. Schnorr and J. Stern, Improved low-denisty subset sum algorithms, Comput. Complexity, 2:111128, (1992) [7] G. Frey, M. M¨ uller, H.-G. R¨ uck,The Tate Pairing and the Discrete Logarithm Applied to Elliptic Curve Cryptosystems, IEEE Trans. Inform. Theory 45(5),17171718, (1999) [8] Gaudry, P. and Hess, F. and Smart, N., Constructive and destructive facets of Weil descent on elliptic curves, J.Cryptology, 15, 19–46, (2002) [9] F. Kirwan, Complex algebraic curves , Cambridge University Press, (1992) [10] J.C. Lagarias, A. M. Odlyzko, Solving low-density subset sum problems, Journal of Association for Computing Machinery, January 1985, (1985) [11] A. Menezes, T. Okamoto, S. Vanstone, Reducing eliptic curve logarithms to logarithms in a finite field, IEEE Transactions on Information Theory 39, 1639-1646, (1993) [12] M. Nair, On Chebyshev-type inequalities for primes, Amer. Math. Monthly 89, 126129, (1982) [13] P. Nguyen,Can we trust cryptographic software? Cryptographic flaws in GNU Privacy Guard v.1.2.4, Eurocrypt 2004, LNCS 3027 (2004) [14] , Satoh, T. and Araki, K., Fermat quotients and the polynomial time discrete log algorithm for anomalous elliptic curves, Commentarii Mathematici, 47, 1, 81-92, (1998) [15] , Semaev, I., Evaluation of discrete logarithms in a group of p-torsion points of an elliptic curve in characteristic p, Mathematics of Computation, 67, 353-356, (1998) [16] , Silverman, J., Elliptic curves, Springer, (1986)

2

LITERATUR

[17] , Smart, N., The discrete logarithms problem on elliptic curves of trace one, Journal of Cryptology, 12, 193-196, (1999) [18] , I.F. Blake, G. Seroussi, N. Smart, Elliptic curves in cryptography, London Mathematical Society Lecture Note Series,Cambridge University Press, Cambridge, (2000). [19] D. R. Stinson, Cryptography - Theory and Practice, Chapman & Hall/CRC, 2nd edition, (2002) [20] , Washington, L., Elliptic curves, Number Theory and Cryptography, Chapman & Hall/CRC, (2003)