Algorithmische Kryptographie

Skript zur Vorlesung

Algorithmische Kryptographie

an der RWTH Aachen

PD Dr. Walter Unger Lehrstuhl Informatik 1

2. Februar 2016

Inhaltsverzeichnis

1 Symmetrische Verfahren 4

1.1 Data Encryption Standard . . . 6

1.1.1 Schl¨usselverarbeitung . . . 7

1.1.2 Datenfluss . . . 7

1.1.3 Die Funktionf . . . 9

1.1.4 Zusammenfassung und Entschl¨usselung . . . 10

1.2 International Data Encryption Algorithm . . . 11

1.2.1 Entschl¨usselung . . . 13

1.3 Advanced Encryption Standard . . . 14

2 Grundlagen der Public-Key-Systeme 18 2.1 Grundmuster . . . 19

2.2 Rucksackverfahren . . . 20

2.2.1 Mathematischer Hintergrund . . . 21

2.2.2 Ver- und Entschl¨usselung . . . 21

2.2.3 Sicherheitsaspekte . . . 23

2.3 RSA . . . 24

2.3.1 Mathematischer Hintergrund . . . 24

2.3.2 RSA System . . . 25

2.4 Rabin . . . 28

2.4.1 Mathematischer Hintergrund . . . 28

2.4.2 System von Rabin . . . 35

3 Sicherheitsaspekte und Hilfsfunktionen 37 3.1 Hashfunktionen . . . 37

3.2 Sicherheitsaspekte von RSA . . . 39

3.2.1 OAEP (optimal asymmetric encryption padding) . . . 40

3.2.2 Weitere Angriffe . . . 41

3.2.3 Sicherheitsaspekte . . . 42

3.3 Bit-Sicherheit . . . 44

3.3.1 Notationen und Algorithmus . . . 44

3.4 Bestimmung von Primzahlen . . . 47

3.4.1 Solovay-Strassen . . . 48

3.4.2 Miller-Rabin . . . 49

3.4.3 Deterministischer Primzahltest . . . 50

4 Weitere Public-Key-Systeme 51 4.1 ElGamal . . . 51

4.2 Elliptische Kurven . . . 53

4.3 Quantenkryptographie . . . 59

Vorwort

Das Skript wurde f¨ur die Vorlesung Algorithmische Kryptographie an der RWTH Aachen er- stellt und basiert auf den Folien aus dem Wintersemester 2015/2016. Wenn Kapitel mit dem Symbol markiert sind, hilft der jeweils dazu geh¨orige Foliensatz von http://algo.rwth- aachen.de/Lehre/WS1516/VAK.php durch animierte Bilder f¨ur das Verst¨andnis.

Sollten inhaltliche oder sprachliche Fehler auffallen kann durch eine E-Mail mit ei- nem Korrekturvorschlag an fuchs@cs.rwth-aachen.de eine verbesserte Version zu Stande kommen, sodass das Skript ¨uber Zeit betrachtet hoffentlich gegen ein Optimum konvergiert.

Kapitel 1

Symmetrische Verfahren

Die Anf¨ange der Kryptographie liegen weit in der Vergangenheit und k¨onnen nicht klar bestimmt werden. Es wird vermutet, dass die Kryptographie zusammen mit der Schrift ent- stand. Es bestand die Notwendigkeit, den Inhalt einer Nachricht nur wenigen Eingeweihten zug¨anglich zu machen. Bereits die ¨Agypter nutzten 1900 v. Chr. un¨ubliche Hieroglyphen zur Verschl¨usslung von Nachrichten.

Die Atbash-Methode wurde 600 v. Chr. f¨ur das Hebr¨aische Alphabet entwickelt. Das Verfahren permutiert die Buchstaben des verwendeten Alphabetes auf festgelegte Art. Jeder Buchstabexin einem Alphabet mitnBuchstaben wird folgendermaßen abgebildet:

x7→n−1−xmitx∈ {0, . . . , n−1}

Die bekannte Caesar-Verschl¨usselung, welche ger¨uchteweise von Caesar verwendet wurde, basiert auch auf der Idee die Buchstaben des Alphabets zu permutieren. Zur Ver- und Entschl¨usselung wird ein Schl¨usselk ben¨otigt, der die Permutation der Buchstaben bestimmt. Jeder Buchstabexin einem Alphabet mitnBuchstaben wird bei der Verwendung des Schl¨usselsk folgendermaßen abgebildet:

x7→x+k modnmitx∈ {0, . . . , n−1}

Im Verlauf der Geschichte sind viele kryptographische Verfahren entstanden. Ange- trieben durch den ersten Weltkrieg und den technologischen Fortschritt entstanden ab 1900 viele Verfahren. Eines der bekanntesten Verfahren aus dieser Zeit ist die ber¨uhmte Enigma Verschl¨usselung. Mit der Entwicklung des Internets und den neuen technologi- schen M¨oglichkeiten ab den 1970er Jahren entstanden viele der noch heute verwendeten Verfahren. Die Abbildung 1.1 zeigt Zeitleisten, die die bekanntesten Verfahren in einen zeitlichen Kontext einordnen.

un¨ub.H.gly.

Steg.gr. Skytale

Atbash Caesar Alkindus

Phelippes Vigenere Jefferson

-2000 -1500 -1000 -500 0 500 1000 1500

Kasiski Playfair Babbage

Enigma Hill

M-209 One-Time Pad

1850 1900 1950

ElGamal Rabin

KS RSA PkS

AES IDEA

DES

1950 1960 1970 1980 1990 2000

Abbildung 1.1: Zeitstrahl der Verfahren in einen zeitlichen Kontext einordnet.

Das Ziel eines kryptographischen Verfahrens ist esKlartextzu verschl¨usseln, sodass die enthaltende Information langfristig gesch¨utzt ist. Die Entschl¨usselung ohne einen Schl¨ussel muss sehr schwierig sein, um Sicherheit zu gew¨ahren. Um eine praktikable Anwendung zu erm¨oglichen, sollte die Umwandlung von Klartext inGeheimtexteffizient sein. Zudem sollte das Verfahren m¨oglichst einfach sein, um eine fehlerfreie Implementation zu gew¨ahrleisten.

Da die Sicherheit bei einem Verschl¨usselungsverfahren meist auf einem nicht effizient l¨osbaren mathematischen Problem basiert, sollte das Verfahren m¨oglichst wenig geheim und am besten - bis auf einen geheimen Schl¨ussel - ¨offentlich einsehbar sein.

Wenn bei einem kryptographischen Verfahren zur Ver- und Entschl¨usselung nur ein Schl¨ussel verwendet wird oder sich das Schl¨usselpaar effizient aus einem Schl¨ussel berech- nen l¨asst, dann spricht man von einem symmetrischen Verfahren. In Abbildung 1.2 ist die allgemeine Funktionsweise solcher Verfahren zu erkennen.

Im Nachfolgenden wird die Verschl¨usselung einer Nachrichtwals das Anwenden einer Funktion E(w) = caufgefasst. Die Funktion D ist analog als Umkehrfunktion vonE definiert und beschreibt somit die Entschl¨usselung einer Nachrichtc, sodassD(c) =wgilt.

Definition 1.1 Ein Verschl¨usselungsverfahren heißtsymmetrisch, falls man ausE[D](und Schl¨usselk) direkt aufD[E]schließen kann.

sicher sicher

unsicher unsicher

Sender Empf¨anger

Lauscher Kennt:E, D, k, w

E, D, c k

Sendet:E, D, k, c Bestimmt:c=E_k(w)

Kennt:E, D, k, c, w Bestimmt:w=D_k(c)

Kennt:E, D, c

Sender:E, D, k, w Empf¨anger:E, D, k Bestimmt:c=E_k(w)

c

Bestimmt:w=D_k(c)

Abbildung 1.2: Funktionsweise von symmetrischen Verfahren.

Da die Informationen nur durch den Schl¨ussel gesch¨utzt sind und niemals durch das Verfahren, spielt die Wahl des Schl¨ussels eine entschiedene Rolle. Zudem m¨ussen alle Kommunikationsteilnehmer den Schl¨ussel ¨uber einen sicheren, nicht abh¨orbaren Kanal erhalten. Dies kann dazu f¨uhren, dass die Verwaltung der verschiedenen Schl¨ussel sehr aufwendig wird.

1.1 Data Encryption Standard

Das DES-Verfahren (Data Encryption Standard) wurde 1978 vom amerikanischen NBS (National Bureau of Standards) ver¨offentlicht und war damit das erste ¨offentlich bekanntge- gebene Kryptoverfahren ¨uberhaupt. Da es die Ver- und Entschl¨usselung schnell erm¨oglicht und relativ sicher war, wurde es der erste kryptographische Standard. Da jeder Schl¨ussel des urspr¨unglichen DES-Verfahrens immer eine L¨ange von56Bit hat und das Verfahren relativ kompliziert ist, sollte das Verfahren heutzutage nur noch in abgewandelter Form (Triple-DES, Multi-DES, DESX, . . . ) verwendet werden. Das Verfahren teilt die Nachricht in Bl¨ocke der L¨ange64Bit, die unabh¨angig voneinander verschl¨usselt werden. Die Abbil- dung 1.6 zeigt die Funktionsweise des Verfahrens, welche im Folgenden St¨uck f¨ur St¨uck erl¨autert wird.

E_k^DES :Z⁶⁴2 →Z⁶⁴2 Bitabbildung, mitk ∈Z⁵⁶2

1.1.1 Schl ¨usselverarbeitung

Zur Sicherheit wird der Schl¨ussel der L¨ange56Bits mit Parity-Bits auf den Positionen 8,16, . . . ,64

¨ubertragen. Der Schl¨ussel wird somit k¨unstlich auf 64Bits vergr¨oßert.

Die echten Eintr¨age im Schl¨ussel (ohne Parity-Bits) werden permutiert und in zwei Bl¨ockeC₀undD₀ aufgeteilt. Die resultierenden Bl¨ocke der L¨ange28 Bits sind in Abbildung 1.3 zu sehen.

Aus den Bl¨ocken Ci−1 undDi−1 werden f¨ur1 6 i 6 16 die Bl¨ocke C_i und D_i durch zyklische Links-Shifts bestimmt. D.h. Der BlockC₁ hat an erster Stelle das Bit stehen, das im urspr¨unglichen Schl¨ussel an Position49stand und an letzter Stelle das Bit, das im urspr¨unglichen Schl¨ussel an Positi- on57stand.

Aus denC_iundD_iwird durch Selektion und Per- mutation nach Tabelle 1.1 einK_i bestimmt.

14 17 11 24 1 5

3 28 15 6 21 10

23 19 12 4 26 8

16 7 27 20 13 2

41 52 31 37 47 55

30 40 51 45 33 48

44 49 39 56 34 53

46 42 50 36 29 32

Tabelle 1.1: Permutationstabelle derCiundDi.

1 9 17 25 33 41 49 57

2 10 18 26 34 42 50 58

3 11 19 27 35 43 51 59

4 12 20 28 36 44 52 60

5 13 21 29 37 45 53 61

6 14 22 30 38 46 54 62

7 15 23 31 39 47 55 63

8 16 24 32 40 48 56 64 Schl¨ussel

D0: C₀:

57 49 41 33 25 17 9

1 58 50 42 34 26 18

10 2 59 51 43 35 27

19 11 3 60 52 44 36

63 55 47 39 31 23 15

7 62 54 46 38 30 22

14 6 61 53 45 37 29

21 13 5 28 20 12 4

Abbildung 1.3: Schl¨usselaufteilung Somit steht zum Beispiel das erste Bit in Ci an f¨unfter Stelle in Ki. Das erste Bit in D_i befindet sich an vorletzter Stelle inK_i. JedesK_i hat eine L¨ange von48Bits, da die Bits an Position9,18,22,25,35,38,43und54nicht selektiert werden.

1.1.2 Datenfluss

Die 64Bits der Eingabew werden nach der Tabelle 1.2 permutiert. D.h. dass nach der Permutation das Bit, das inw an Position2stand, sich nun an Position 8befindet. Der permutierte Block wird anschließend in zwei H¨alften L₀ und R₀ mit jeweils 32 Bits

geteilt. Die obere H¨alfte der Tabelle 1.2 wird zuL₀ und die untere H¨alfte wirdR₀. Die resultierendenR₀ undL₀ sind links in Abbildung 1.4 zu sehen.

58 50 42 34 26 18 10 2

60 52 44 36 28 20 12 4

62 54 46 38 30 22 14 6

64 56 48 40 32 24 16 8

57 49 41 33 25 17 9 1

59 51 43 35 27 19 11 3

61 53 45 37 29 21 13 5

63 55 47 39 31 23 15 7

Tabelle 1.2: Permutationstabelle der Eingabe

Die Bl¨ockeRi−1 werden f¨ur16i616zu den Bl¨ockenL_iund die Bl¨ockeR_ientstehen aus einer bitweisen XOR Operation des BlocksLi−1, wie in Abbildung 1.4 gezeigt ist, mit dem Ergebnis einer Funktionf, die im n¨achsten Abschnitt n¨aher erl¨autert wird. Die Funktionf hat als Eingabe den BlockRi−1und den blockK_i, der im vorherigen Abschnitt n¨aher erl¨autert wurde.

F¨ur die sp¨atere Entschl¨usselung ist es wichtig, dass der BlockR_i−1immer identisch zu dem BlockL_i ist. Wie die Bl¨ocke gehandhabt werden ist in Abbildung 1.4 zu sehen.

R0:

L₀:

58 50 42 34 26 18 10 2 60 52 44 36 28 20 12 4 62 54 46 38 30 22 14 6 64 56 48 40 32 24 16 8 57 49 41 33 25 17 9 1 59 51 43 35 27 19 11 3 61 53 45 37 29 21 13 5

63 55 47 39 31 23 15 7 R1:

L₁:

Xor

R2:

L₂:

Xor

Abbildung 1.4: Verarbeitung der permutierten und aufgeteilten Eingabe.

Am Ende der Verschl¨usselung werden die Bl¨ockeL₁₆undR₁₆vertauscht und nach der Tabelle 1.3 permutiert. Somit ist das achte Bit inR₁₆nach der Permutation das erste Bit der Ausgabe. Das erste Bit vonL₁₆ist in der Ausgabe an Position58.

58 50 42 34 26 18 10 2

60 52 44 36 28 20 12 4

62 54 46 38 30 22 14 6

64 56 48 40 32 24 16 8

57 49 41 33 25 17 9 1

59 51 43 35 27 19 11 3

61 53 45 37 29 21 13 5

63 55 47 39 31 23 15 7

Tabelle 1.3: Letzte Permutationstabelle der Eingabe

1.1.3 Die Funktion f

Die Funktionf verbindet die aus dem Schl¨ussel gewonnen Bl¨ockeK_imit jeweils einem Ri−1. Bevor die beiden Bl¨ocke durch eine bitweiseXOR Operation verbunden werden, wird der BlockRi−1 nach der Tabelle 1.4 permutiert und vergr¨oßert, wie in Abbildung 1.5 dargestellt. Einige der 32 Bits von Ri−1 werden doppelt verwendet um eine L¨ange von48Bit zu erreichen. Somit steht zum Beispiel an zweiter und letzter Stelle nach der Permutation das erste Bit des BlocksRi−1.

32 1 2 3 4 5

4 5 6 7 8 9

8 9 10 11 12 13

12 13 14 15 16 17

16 17 18 19 20 21

20 21 22 23 24 25

24 25 26 27 28 29

28 29 30 31 32 1

Tabelle 1.4: Permutationstabelle derRi−1.

Anschließend wird das Resultat aus der bitweisen XOR Operation des Blocks K_i mit dem permutierten und vergr¨oßerten R_i−1 in 8 Bl¨ocke B₁, . . . B₈ der Gr¨oße 6 Bit aufgeteilt. Jeder BlockB_i = (a₁, . . . , a₆) wird durch einen Eintrag in einer Tabelle S_i auf 4 Bit reduziert. Die integer Repr¨asentation der bin¨ar Zahlen x_i = int(a₁a₆) und y_i = int(a₂a₃a₄a₅) bestimmen dabei ¨uber den Eintrag in einer TabelleS_i, die Zahlen zwischen0und 15 enth¨alt. Die Zahl in Zeilex_iund Spaltey_i wird in eine Bin¨arzahl der L¨ange4Bit umgerechnet und anschließend werden die Ergebnisse, wie in Abbildung 1.5 zu sehen ist, zu einem Block der L¨ange32Bit zusammengesetzt. Auf diesen Block, der aus K_iundRi−1 durch verschiedenen Operationen entstanden ist, wird anschließend mitLi−1

eine bitweise XOR Operation angewendet. Das Resultat wird der neue BlockR_i.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 32 1 2 3 4 5

4 5 6 7 8 9 8 9 10 11 12 13 12 13 14 15 16 17 16 17 18 19 20 21 20 21 22 23 24 25 24 25 26 27 28 29 28 29 30 31 32 1

Xor

S₁ S₃ S₅ S₇ S₈ S₆ S₄ S₂

16

16

7

7 20

20 21

21 29

29 12

12 28

28 17

17 1

1

15

15

23

23 26

26 5

5 18

18 31

31 10

10 2

2

8

8

24

24 14

14

32

32 27

27 3

3 9

9 19

19

13

13

30

30 6

6 22

22 11

11 4

4 25

25

Abbildung 1.5: Arbeitsweise der Funktionf.

1.1.4 Zusammenfassung und Entschl ¨usselung

In Abbildung 1.6 ist das Zusammenspiel der Eingabeverarbeitung, Schl¨usselverarbeitung und der Funktionf zu sehen. Da der Klartext mit einem Teilschl¨usselK_i in den Bl¨ocken R_i und L_i verschl¨usselt wird, muss zur Entschl¨usselung das Verschl¨usselungsverfahren in umgekehrter Reihenfolge angewandt werden. Daher folgt aus der Verschl¨usselung L_i :=Ri−1 undR_i :=Li−1⊕f(Ri−1, K_i)die folgende Entschl¨usselungRi−1 :=L_i und Li−1 :=R_i⊕f(L_i, K_i).

Schl¨ussel D₀: C₀:

lsf1lsf1

C₁:

D₁: lsf1lsf1

C₂: D₂:

K1: K16:

Eingabe

R₀: L₀:

R₁: L₁:

Xor

Xor Xor

R₂: L₂:

Xor

L₁₆: R₁₆:

Ausgabe

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

Abbildung 1.6: Funktionsweise von DES.

1.2 International Data Encryption Algorithm

Das Verschl¨usselungsverfahren IDEA (International Data Encryption Algorithm) teilt f¨ur die Verschl¨usselung den Klartextmin Bl¨ocke der L¨ange64Bit, die dann mit Hilfe eines Schl¨ussels k der L¨ange128 Bit verschl¨usselt werden. Intern teilt der Verschl¨usselungs- Algorithmus die64Bit in vier Blocksi¹₁, i¹₂, i¹₃, i¹₄ der Gr¨oße16Bit und verarbeitet diese mit Teilschl¨usseln der gleichen L¨ange in insgesamt9Runden zu einem Geheimtext.

Dabei verwenden die ersteni 6 8Runden jeweils6Teilschl¨ussel z₁ⁱ bis z₆ⁱ. F¨ur die ersten8Teilschl¨usselz₁¹bisz₆¹,z₁²undz₂²wird der Schl¨usselkin8gleichgroße zyklische Teile geteilt. F¨ur die n¨achsten8Teilschl¨ussel wird jedes Bit inkum25Positionen nach links geschoben und das Verfahren erneut verwendet. Da die neunte Runde nur4Teilschl¨ussel ben¨otigt, wiederholt sich die Methode solange bis52Teilschl¨ussel generiert wurden.

Die Idee bei der Verschl¨usselung mit IDEA ist das Mischen von drei Operationen, die keine algebraischen Gemeinsamkeiten haben. Dabei werden die Operationen⊕(bitwei- ses XOR), +(Addition modulo2¹⁶) und (Multiplikation modulo 2¹⁶+ 1 (0 ≡ 2¹⁶)) verwendet.

In der ersten Runde werden die Bl¨ocke i₁ bisi₄ mit den ersten sechs Teilschl¨usseln z₁¹bisz₆¹verarbeitet. Mit welchen Operationen und Teilschl¨usseln die Eingabe verarbeitet

wird ist in Abbildung 1.7 gezeigt. Dabei stellen die roten Knoten das bitweise XOR, die gr¨unen die Addition und die blauen die Multiplikation dar. Die Ausgabe der ersten Runde wird dann als Eingabei²₁ bisi²₄ f¨ur die zweite Runde verwendet und mit den n¨achsten sechs Teilschl¨usselnz₁² bisz₆²auf gleiche Art und Weise verarbeitet. Dieses Verfahren wiederholt sich bis die achte Runde abgeschlossen ist und mani⁸₁ bis i⁸₄ als Eingabe f¨ur die letzte Runde erh¨alt.

zⁱ1 + zⁱ2 zⁱ3 + zⁱ4

⊕

⊕

z₅ⁱ +

Rundei

+ zⁱ₆

⊕ ⊕

⊕ ⊕

Abbildung 1.7: Funktionsweise der Rundeni68.

In der letzten Runde werden die vier Eingabe Bl¨ocke mit jeweils einem Schl¨usselz_i⁹ verrechnet. In der Abbildung 1.8 ist zu sehen, dassi⁸₁ mitz⁹₁ undi⁸₄ mit z⁹₄ multipliziert wird und die Bl¨ocke ihre Position beibehalten. Die Eingabei⁸₃ wird mitz₂⁹addiert und als zweiter Block ausgegeben. Der dritter Block des Geheimtexts entspricht dem Ergebnis der Addition voni⁸₂ mitz₃⁹.

z⁹₁ z₂⁹ + z⁹₃ + z⁹₄

Abbildung 1.8: Funktionsweise der Runden9.

1.2.1 Entschl ¨usselung

F¨ur die Entschl¨usselung wird das gleiche Verfahren mit ver¨anderten Teilschl¨usseln ver- wendet. Da die Schl¨usselZ₁ⁱ und Z₄ⁱ bei der Verschl¨usselung immer zur Multiplikation verwendet werden, muss f¨ur die Entschl¨usselung das multiplikativ Inverse der Schl¨ussels gebildet werden. Die Schl¨usselZ₂ⁱ undZ₃ⁱ werden bei der Verschl¨usselung zur Addition verwendet. Daher m¨ussen bei der Entschl¨usselung diese Schl¨ussel durch ihr additiv Inverses ersetzt werden. In der Tabelle 1.5 ist das Verh¨altnis zwischen den Teilschl¨usseln und deren Reihenfolge f¨ur die Ver- und Entschl¨usselung dargestellt.

Verschl¨usseln Entschl¨usseln

1. Z₁¹ Z₂¹ Z₃¹ Z₄¹ Z₅¹ Z₆¹ Z₁⁹⁻¹ −Z₂⁹ −Z₃⁹ Z₄⁹⁻¹ Z₅⁸ Z₆⁸ 2. Z₁² Z₂² Z₃² Z₄² Z₅² Z₆² Z₁⁸⁻¹ −Z₃⁸ −Z₂⁸ Z₄⁸⁻¹ Z₅⁷ Z₆⁷ 3. Z₁³ Z₂³ Z₃³ Z₄³ Z₅³ Z₆³ Z₁⁷⁻¹ −Z₃⁷ −Z₂⁷ Z₄⁷⁻¹ Z₅⁶ Z₆⁶ 4. Z₁⁴ Z₂⁴ Z₃⁴ Z₄⁴ Z₅⁴ Z₆⁴ Z₁⁶⁻¹ −Z₃⁶ −Z₂⁶ Z₄⁶⁻¹ Z₅⁵ Z₆⁵ 5. Z₁⁵ Z₂⁵ Z₃⁵ Z₄⁵ Z₅⁵ Z₆⁵ Z₁⁵⁻¹ −Z₃⁵ −Z₂⁵ Z₄⁵⁻¹ Z₅⁴ Z₆⁴ 6. Z₁⁶ Z₂⁶ Z₃⁶ Z₄⁶ Z₅⁶ Z₆⁶ Z₁⁴⁻¹ −Z₃⁴ −Z₂⁴ Z₄⁴⁻¹ Z₅³ Z₆³ 7. Z₁⁷ Z₂⁷ Z₃⁷ Z₄⁷ Z₅⁷ Z₆⁷ Z₁³⁻¹ −Z₃³ −Z₂³ Z₄³⁻¹ Z₅² Z₆² 8. Z₁⁸ Z₂⁸ Z₃⁸ Z₄⁸ Z₅⁸ Z₆⁸ Z₁²⁻¹ −Z₃² −Z₂² Z₄²⁻¹ Z₅¹ Z₆¹ 9. Z₁⁹ Z₂⁹ Z₃⁹ Z₄⁹ Z₁¹⁻¹ −Z₂¹ −Z₃¹ Z₄¹⁻¹

Tabelle 1.5: Teilschl¨ussel f¨ur die Ent- und Verschl¨usselung.

In Abbildung 1.9 sind die letzten beiden Schritte der Verschl¨usselung mit Zwischener- gebnissena,a⁰,b,b⁰,c,c⁰,dundd⁰zu sehen. In einer Rundei68gilt, dass der erste Block des Ergebnissesa=a⁰⊕f_r(a⁰⊕c⁰, b⁰⊕d⁰)und der letzte Blockc=c⁰⊕f_r(a⁰⊕c⁰, b⁰⊕d⁰) ist.

Da wir ein bitweises XOR verwenden, wissen wir auch, dass a⁰ = a⊕f_r(. . .) und c⁰ =c⊕f_r(. . .)gilt. Des weiteren muss aucha⊕a⁰ =f_r(. . .) =c⊕c⁰gelten.

Diese Gleichung f¨uhrt zu dem Ergebnisa⊕c=a⁰⊕c⁰. Analog kann man zeigen, dass b⊕d=b⁰⊕d⁰gilt.

Diese Resultate k¨onnen nun die Eingabe der Funktionf_r ersetzen. Somit gilt f¨ur die Entschl¨usselung

a⁰ =a⊕f_r(a⊕c, b⊕d).

f

fr

z1⁸ + z⁸2 z3⁸ + z⁸4

⊕

⊕

z⁸5 +

Runde8

+ z₆⁸

⊕ ⊕

⊕ ⊕

z₁⁹ z⁹₂ + z₃⁹ + z₄⁹

m n o p

a b c d

a⁰ b⁰ c⁰ d⁰

Abbildung 1.9: Verschl¨usselung mit Zwischenergebnissen.

Somit kann das gleiche Verfahren, das zur Verschl¨usselung genutzt wurde, mit ver¨ander- ten Teilschl¨usseln zur Entschl¨usselung genutzt werden

1.3 Advanced Encryption Standard

Runden- N_b

anzahlNr 4 5 6 7 8

4 10 11 12 13 14

5 11 11 12 13 14

N_k 6 12 12 12 13 14

7 13 13 13 13 14

8 14 14 14 14 14

Tabelle 1.6: Rundenanzahl des Rijndael-Algorithmus.

Das Verschl¨usselungverfahren AES (Advanced En- cryption Standard) wurde als Nachfolger f¨ur DES entwickelt. AES ist eine Einschr¨ankung des Rijndael- Algorithmus, da die Blockgr¨oßeN_b·32fest128Bit ist und die Wahl der Schl¨ussell¨angeN_k·32auf128,192 oder256Bit beschr¨ankt ist. In der Tabelle 1.6 ist die Anzahl der f¨ur die Verschl¨usselung notwendigen Run- den angegeben, die beim Rijndael-Algorithmus von N_kundN_babh¨angen. AES hat somit10,12oder14 Runden in denen eine Nachricht verschl¨usselt wird.

Die Eingabep₀,p₁, . . .p4·N_b−1wird in eine Tabel-

le mit 32 Spalten undN_b Zeilen umgewandelt, wobei|p_i|aus einem Byte besteht. Somit

steht in der ersten Spaltep₀,p₁,p₂undp₃, die zusammen eine L¨ange von4Byte= 32Bit haben.

Der Schl¨usselk₀,k₁,. . .,k_4·Nk−1wird in eine Tabelle mit32·N_kSpalten undN_bZeilen umgewandelt, wobei|k_i|aus einem Byte besteht. Somit stehen die erstenk_imiti <2·N_k in der ersten Spalte. In Abbildung 1.10 ist die Aufteilung des Schl¨ussels und der Eingabe f¨urN_k = 6undN_b = 4zu sehen.

k0,0

k0,1

k_0,2 k_0,3

k1,0

k1,1

k_1,2 k_1,3

k2,0

k2,1

k_2,2 k_2,3

k3,0

k3,1

k_3,2 k_3,3

k4,0

k4,1

k_4,2 k_4,3

k5,0

k5,1

k_5,2 k_5,3

p_0,0 p_0,1 p_0,2 p_0,3

p_1,0 p_1,1 p_1,2 p_1,3

p_2,0 p_2,1 p_2,2 p_2,3

p_3,0 p_3,1 p_3,2 p_3,3

c_0,0 c_0,1 c_0,2 c_0,3

c_1,0 c_1,1 c_1,2 c_1,3

c_2,0 c_2,1 c_2,2 c_2,3

c_3,0 c_3,1 c_3,2 c_3,3 a_0,0

a_0,1 a_0,2 a_0,3

a_1,0 a_1,1 a_1,2 a_1,3

a_2,0 a_2,1 a_2,2 a_2,3

a_3,0 a_3,1 a_3,2 a_3,3

Abbildung 1.10: Konzept der AES Verschl¨usselung mitN_k= 6.

Der Rijndael-Algorithmus verarbeitet die Eingabe in einen so genannten State, der in mehreren Runden ver¨andert wird bis am Ende der Geheimtextc₀,c₁,. . .,c4·N_b−1 resultiert.

Der Algorithmus 1 hat f¨unf unterschiedliche Arbeitsschritte, die im folgenden n¨aher erkl¨art werden.

Algorithm 1Rijindale(State, CipherKey)

1: KeyExpansion(CipherKey,ExpandedKey);

2: AddRoundKey(State,ExpandedKey[0]);

3: fori:= 1;i < N_r;i+ +do

4: SubBytes(State);

5: ShiftRows(State);

6: MixColumns(State);

7: AddRoundKey(State,ExpandedKey[i]);

8: end for

9: SubBytes(State);

10: ShiftRows(State);

11: AddRoundKey(State,ExpandedKey[N_r]);

Die OperationSubBytes(State)ver¨andert jedes Byte in State folgendermaßen:S_RD(a_i) = g(a_i)f(a_i). Die Teil-Funktiongbetrachtet das Bytea_i als Polynom ¨uberF₂und rechnet

g(a_i) := a⁻¹_i modm(x) =x⁸+x⁴+x³+x+ 1.

Die Teil-Funktionf interpretiert jedes Byte als Vektor und macht folgende Berechnungen:

f(~a) =

























1 1 1 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 1 1 1 1 1 0 0 0 0 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0 0 0 1

























×























 a₇ a₆ a5

a₄ a₃ a2

a₁ a₀

























⊕























 0 1 1 0 0 0 1 1

























Die OperationShiftRows(State)verschiebt die 32 Bit in Zeilei∈ {0,1,2,3}umCiPositionen zyklisch nach links. DieCih¨angen vonN_bab, wobei dasN_bbei AES auf4festgesetzt ist, wodurch jedesC_idie Zeileium genauiPositionen zyklisch nach links verschiebt.

Die OperationMixColumns(State)betrachtet jede Zeilea_ia_i+1a_i+2a_i+3der L¨ange4Byte als PolynomAiinF2. S¨amtliche Rechnungen werden wie Berechnungen mit Polynomen modulox⁴+ 1 durchgef¨uhrt. Somit erh¨alt man:







 b0

b₁ b₂ b3









←−









02 03 01 01 01 02 03 01 01 01 02 03 03 01 01 02









×







 A0

A₁ A₂ A3









Jedes Ergebnisbiwird wieder in eine Zeileaiai+1ai+2ai+3des States geteilt.

Die OperationAddRoundKey(State,ExpandedKey[i])bildet die bitweise symmetrische Diffe- renz zwischen dem State und Teilschl¨ussel (XOR).

Algorithm 2KeyExpansion(CipherKey,ExpandedKey)fallsN_k 66

1: W[i][j]←K[i][j]f¨ur06i <4,06j < N_k

2: forj :=N_k;j < N_b(N_r+ 1);j+ +do

3: ifj modN_k == 0then

4: W[0][j] =W[0][j−N_k]⊕S_RD(W[1][j−1])⊕RC[j/N_k]

5: W[i][j] =W[i][j−N_k]⊕S_RD(W[(i+ 1) mod 4][j−1])

6: f¨ur06i <4

7: else

8: W[i][j] =W[i][j−N_k]⊕W[i][j −1]f¨ur06i <4

9: end if

10: end for

Mit Hilfe der OperationKeyExpansion(CipherKey,ExpandedKey)wird aus dem Schl¨ussel der Gr¨oße4·N_kByte f¨ur jede derNr+ 1Runden ein Teilschl¨ussel der Gr¨oße4·N_bByte bestimmt.

Im folgenden Algorithmus beschreibt der Array EintragK[i][j]das Bit des Schl¨ussels an Position ki+4·j,S_RDsind S-Boxen undRC[j]wird folgendermaßen berechnet:

Jedes Byte wird wieder als Polynom ¨uberF2betrachtet und modulom(x) =x⁸+x⁴+x³+x+1 verrechnet. Daraus ergibt sich f¨ur RC[1] = x⁰ = (01), RC[2] = x¹ = (02) und RC[j] = x·RC[j−1]f¨urj >2.

Der Algorithmus 2 wird im FallNk 6 6verwendet und bei l¨angeren Schl¨usseln wird eine leichte Abwandlung, die in Algorithmus 3 zu sehen ist, verwendet.

Algorithm 3KeyExpansion(CipherKey,ExpandedKey)fallsN_k >6

1: W[i][j]←K[i][j]f¨ur06i <4,06j < N_k

2: forj :=Nk;j < Nb(Nr+ 1);j+ +do

3: ifj modN_k == 0then

4: W[0][j] =W[0][j−N_k]⊕S_RD(W[1][j−1])⊕RC[j/N_k]

5: W[i][j] =W[i][j−Nk]⊕SRD(W[(i+ 1) mod 4][j−1])

6: f¨ur06i <4

7: else if j modN_k == 4 then

8: W[i][j] =W[i][j−Nk]⊕SRD(W[i][j−1])

9: f¨ur06i <4

10: else

11: W[i][j] =W[i][j−Nk]⊕W[i][j −1]f¨ur06i <4

12: end if

13: end for

Mit dem erweiterten Schl¨ussel k¨onnen die Teil-Schl¨ussel berechnet werden, die in den einzelnen Runden verwendet werden. Die einzelnen Schl¨ussel werden folgendermaßen gebildet:

ExpandedKey[i] =W[·][N_b·i]◦W[·][N_b·i+ 1]◦. . .◦W[·][N_b·(i+ 1)−1] (06i6N_r).

F¨ur die Entschl¨usselung kann das gleiche Verfahren in umgedrehter Reihenfolge verwendet werden, wobei einige Operationen mit ihren jeweiligen Umkehroperationen ersetzt werden m¨ussen.

Kapitel 2

Grundlagen der Public-Key-Systeme

Bei der Verwendung einer symmetrischen Verschl¨usselung kann ein Lauscher aus der Verschl¨usse- lung die Entschl¨usselung bestimmen. Des weiteren muss der Schl¨ussel ¨uber einen sicheren Kanal

¨ubermittelt werden und symmetrischen Verfahren bieten nicht die M¨oglichkeit von Unterschriften.

Um diese Probleme zu l¨osen entstanden Public-Key-Systeme. In diesen Systemen ver¨offentlicht ein Empf¨anger einen ¨offentlichen Schl¨ussely, mit dem Nachrichten an ihn verschl¨usselt werden k¨onnen. Der Empf¨anger h¨alt seinen privaten Schl¨usselx, der nicht effizient aus dem Verfahren und dem ¨offentlichen Schl¨ussel berechnet werden kann, geheim. Somit kann jeder den ¨offentli- chen Schl¨ussel verwenden um Nachrichten so zu verschl¨usseln, dass sie nur durch den privaten Schl¨ussel des Empf¨angers wieder entschl¨usselt werden k¨onnen. In diesem System ist der Sender einer Nachricht in der gleichen Situation wie ein Lauscher, da das Verschl¨usselungsverfahren und der ¨offentliche Schl¨ussel allen bekannt sind.

Um ein Public-Key-Systeme zu entwickeln muss eine FunktionD_y zur Verschl¨usselung ge- funden werden, die nach bisherigem Kenntnisstand nicht effizient ausE_xbestimmt werden kann.

Eine Funktion, die diese Voraussetzung erf¨ullt, nennt man One-Way-Funktion. Es wurde bisher noch nicht bewiesen, dass eine One-Way-Funktion existiert. Allerdings gibt es Kandidaten f¨ur diese Funktionen, die zum Beispiel auf folgenden Problemen basieren:

• N P-schwere Probleme (z.B. SAT, Rucksack)

• Faktorisierung

• diskrete Wurzel

• diskreter Logarithmus

• diskreter Logarithmus ¨uber elliptische Kurven

• Polynomringe

• fehlertolerante Codes

• Homomorphismen

• endliche Automaten

2.1 Grundmuster

Public-Key-Systeme k¨onnen verwendet werden um Nachrichten sicher zu ¨ubertragen, Unterschriften zu erzeugen und verschließbare K¨asten zu erstellen. Die Protokolle f¨ur diese drei Anwendungen arbeiten meist nach einem Grundmuster. In Abbildung 2.1 ist das Grundmuster f¨ur die ¨Ubertragung einer Nachrichtwzu sehen. Da ein Angreifer des Protokolls in der gleichen Situation wie der SenderAist, kann er versuchen alle m¨oglichen Nachrichtm⁰inEy^pkseinzusetzen bis das richtige m⁰ gefunden wurde, so dassEy^pks(m⁰) = cgilt. Wenn der Nachrichtenraum f¨urwgroß ist, wird dieser Angriff nicht rentabel.

A: D^pks, E^pks, y, w B:D^pks, E^pks,x, y, D^pks_x , E_y^pks c=E_y^pks(w) c

w=D_x^pks(c)

Abbildung 2.1: Grundmuster bei der ¨Ubertragung einer Nachricht.

Eine Signatursentspricht einer Unterschrift unter einer Nachrichtmund dient der Authen- tifizierung. In Abbildung 2.2 kannAdurch sein pers¨onliches Geheimnisxverifizieren, dass die Nachrichtmvon ihm ist. Ein Angreifer k¨onnte durch die Kenntnis vons,m,yundD^pksversuchen alle m¨oglichenx⁰auszuprobieren biss=D^pks_x0 (m)gefunden wurde. Wenn der Schl¨usselraum f¨urx groß ist, wird dieser Angriff nicht rentabel.

A:D^pks, E^pks,x, y, m B:E^pks, y Bestimmts=D^pks_x (m) m, s

Testetm=^? E_y^pks(s)

Abbildung 2.2: Grundmuster f¨ur die Unterschrift unter einer Nachricht.

Um eine Information zu hinterlegen und sie erst sp¨ater unver¨andert preiszugeben werden verschließbare K¨asten verwendet. In Abbildung 2.3 hinterlegtAdie Nachrichtmals verschlossener Kastens.AundBk¨onnen den hinterlegten Kasten nicht mehr ver¨andern. Erst wenn das Geheimnis xgesendet wurde kannB den Kastensentschl¨usseln und den Inhalt kontrollieren.

A:D^pks, E^pks,x, y, m B:E^pks, D^pks, y s=E^pks_y (m) s Speicherts

x, m

Testetm=^? D^pks_x (s)

Abbildung 2.3: Grundmuster f¨ur verschließbare K¨asten.

2.2 Rucksackverfahren

Das Rucksackproblem, das in Definition 2.1 formal beschrieben ist, ist ein bekanntesN P-schweres Problem und kann daher f¨ur die Erstellung eines Public-Key-System verwendet werden. Das Problem ist inO(2^k)Schritten durch sukzessives Testen jeder TeilmengeI l¨osbar.

Definition 2.1 (Rucksackproblem (knapsack problem, KS))

Eingabe:r₁, r₂, . . . , r_k, s∈N, Frage:∃I ⊂ {1,2, . . . , k}:P

i∈Iri =s Ausgabe:I ⊂ {1,2, . . . , k}:P

i∈Iri=s

Um ein Public-Key-System zu erstellen, w¨ahlt man ein leichtes TeilproblemKS_LvonKS und ver¨andert dieses zuKSS, das schwer aussehen soll. Als ¨offentlicher Schl¨ussel dientKSSzusammen mit einer Beschreibung wie die Verschl¨usselung funktioniert. Das private Geheimnis ist die leichte InstanzKS_Lzusammen mit der Methode wieKS_Sberechnet wurde bzw. wie es zur¨uck gerechnet werden kann.

Um eine leichte Instanz des Rucksackproblems zu erstellen wird an den Vektor von Gewichten Rdie Bedingung gestellt, dass er stark steigend ist. Diese VariationKS_Lkann schnell und eindeutig gel¨ost werden indem man durch den VektorRr¨uckw¨arts iteriert und ein Elementriin die L¨osung nimmt, wenn es kleiner alssist. Sobald ein Gewichtrigew¨ahlt wurde, musssangepasst werden.

Definition 2.2 Ein Vektor R = (r1, r2, . . . , rk)heißt stark steigendgenau dann, wenn f¨ur alle j∈ {2, . . . , k}die Bedingungrj >P

16i<jrierf¨ullt ist.

Bevor die Erstellung der schweren Instanz KSS erkl¨art werden kann m¨ussen zu erst die mathematischen Grundlagen geschaffen werden.

2.2.1 Mathematischer Hintergrund

Eine Zahlaist einTeilervon einer Zahlb, wenn eindexistiert mitb=a·d, was auch durcha|b dargestellt werden kann. Sollteakein Teiler vonbsein, so schreibt mana-b. Wenn eine Zahld Teiler von zwei Zahlenaundbist und alle anderen Teilercdieser Zahlen auchdteilen, dann ist ddergr¨oßte gemeinsame Teilervonaundb, und wir schreibend= ggT(a, b). Wenn der gr¨oßte gemeinsame Teiler zweier Zahlen1ist, dann sind die Zahlenteilerfremd. Daskleinste gemeinsame Vielfachezweier ganzer Zahlenaundbist die kleinste nat¨urliche Zahlm, die sowohl Vielfaches von aals auch Vielfaches vonbist. Wennmdaskleinste gemeinsame Vielfachevonaundbist, dann schreiben wirm= kgV(a, b).

Eine Zahlaist kongruent zubmodulom, wennm|a−bgilt. Die Zahlmwird dann derModul genannt und wir schreibena≡b (modm). Derkleinste nicht-negative Rest vonxmodulomist definiert alsa≡x (modm)mita∈ {0,1, . . . , m−1}und wird mitx (modm)bezeichnet. Die Relation≡ (modm)ist eine ¨Aquivalenzrelation aufZ. DieRestklasseeiner Zahlamodulomist definiert als

[a]m={a+km|k∈Z} f¨ura∈ {0,1, . . . , m−1}.

Aus der Definition des gr¨oßten gemeinsamen Teilers kann man denEuklidischen Algorithmuszur Berechnung des selbigen ableiten, der in Algorithmus 4 beschrieben ist. Nach der Definition wissen wir, dass folgendes gilt:

d|aundd|b⇔d|aundd|bmoda

Der Algorithmus 4 kann leicht modifiziert werden um die FaktorenxundymitggT(a, b) =xa+yb zu berechnen. Solltenaundbteilerfremd sein, giltggT(a, b) = 1und es mussxa≡1 (modm) gelten. Die Zahlx (modm)wird dannmultiplikativ Inversesvonagenannt und vereinfacht als a⁻¹ (modm)bezeichnet. Da die Berechnungen in einem RestklassenringZ/mZstattfinden, w¨are die korrekte Schreibweise[a]⁻¹_m . Wennaund der Modulmteilerfremd sind, l¨asst sich mit dem multiplikativ Inversen einz=a⁻¹b (modm)berechnen, sodassaz≡b (modm)gilt.

Algorithm 4EUCLID(a,b)

1: ifa== 0then

2: return(b)

3: else

4: return(EUCLID(b moda, a))

5: end if

2.2.2 Ver- und Entschl ¨usselung

Um die schwere Instanz des Rucksackproblems RS_S zu bestimmen verwenden wir den stark steigenden VektorA = (a₁, . . . , a_n)der leichten InstantzRS_L. Man w¨ahlt einen Modulm, der gr¨oßer ist als das gr¨oßte Element ausA, und sucht eintmitggT(m, t) = 1, sodass ein multiplikativ

Inversesugefunden werden kann mitu·t≡1 modm. Der Vektor von GewichtenB = (b₁, . . . , b_n) f¨urRS_S entsteht durchmodulare Multiplikation:

b_i =t·a_i (modm)

WennBausAdurch modulare Multiplikation entsteht, dann kann auchAausB entstehen. Sollte dasmjedoch gr¨oßer als die Summe allera_isein, dann wird die modulare Multiplikation zu einer starken modularen Multiplikationund die Aussage gilt nicht mehr. Somit solltem >Pn

i=1aigelten damit man nicht aus der schweren Instanz die leichte berechnen kann.

Um nun das Public-Key-System aufzubauen muss es neben demm einen ¨offentlichen und einen privaten Schl¨ussel geben. Der VektorBwird als als ¨offentlicher Schl¨ussel verwendet undu bildet zusammen mit dem stark steigendem VektorAden privaten Schl¨ussel. Zum Verschl¨usseln einer Nachrichtw∈ {1,0}ⁿwerden die Eintr¨ageb_iinB aufsummiert, f¨ur die gilt, dass das Bitw_i (Positioniinw) gleich1ist. Formal:

E_B^KS2(w) =

n

X

i=1

a_i·w_i =c

Zum Entschl¨usseln muss die starke modulare Multiplikation r¨uckg¨angig gemacht werden indemc mit dem multiplikativ Inversen vont, dem privaten Teilschl¨usselu, multipliziert wird. Anschließend muss das Vielfache des Modulsmdurch die Operation mod mentfernt werden und ¨ubrig bleibt eine Summesf¨ur die gilt:

∃I ⊂ {1,2, . . . , n}:X

i∈I

ai=s

Da der private Teilschl¨usselAstark steigend ist, kann das Rucksackproblem gel¨ost und die richtigen Indizes gefunden werden. Die Nachrichtmkann nun ¨uber die Index MengeI rekonstruiert werden.

Das Bitm_iist1, wenni∈I ist und sonst0.

Lemma 2.3 SeiA = (a1, . . . , a_k) ein stark steigender Vektor und der VektorB entsteht ausA durch starke modulare Multiplikation mittelsmundt. Sei weiterudas multiplikativ Inverse zut (d.h.umodm=t⁻¹),βbeliebig undα=uβmodm. Dann folgt:

1. Das Rucksackproblem(A, α)ist eindeutig l¨osbar in Linearzeit (d.h. keine oder eine L¨osung, falls Parameter frei w¨ahlbar).

2. Das Rucksackproblem(B, β)hat keine oder genau eine L¨osung.

3. Wenn(B, β)eine L¨osung hat, dann ist der L¨osungsvektor gleich der eindeutigen L¨osung von (A, α).

Da die erste Folgerung unmittelbar einsichtig ist, gehen wir zum Beweis nur auf den2.und3.Teil ein.

Beweis:SeiDeine L¨osung von(B, β), sodassβ=BDgilt. Das Rucksackproblem(A, α)hat die gleiche L¨osungD, da folgendes gilt:

α≡uβ=uBD≡u(tA)D≡AD (mod m)

Da dasmso gew¨ahlt wurde, dass starke modulare Multiplikation verwendet wird, gilt des weiteren

AD < mundα < m. Daher gilt auchα=AD.

2.2.3 Sicherheitsaspekte

Ein Angriffspunkt auf dieses Verfahren ist der kleine Zahlenraum f¨ur die erstenai. Die Anzahl an Bits, die einen Eintraga_iim VektorA= (a₁, . . . , a_k)repr¨asentieren, kann durchd·k−1−k+i berechnet werden, wobeiddie maximale Wachstumsrate deraibeschreibt, d.h.dist gr¨oßtm¨oglich und erf¨ullt∀i: ^a_dⁱ > ai−1.

Enth¨altAz.B.k= 100Eintr¨age und ist stark steigend, mussdmindestens2sein. Dann hat der Eintragaih¨ochstens200−1−100 +i= 99 +iviele Bits. Somit wird der Zahlenraum der kleinen ai durch die Bedingung des stark steigenden Vektors sehr eingeschr¨ankt.

Ein Angreifer kann versuchen die Menge aller g¨ultigenA,munduanhand dieser Einschr¨ankung f¨ur die erstenaizu bestimmen, da es mindestens ein Paaru,mgeben muss, dass durch Berechnung vonu·bi einen stark steigenden Vektor Aerzeugt. Dabei muss nicht das urspr¨ungliche Paaru undmgefunden werden. Es ist ausreichend einu⁰undm⁰ zu finden mit dem es m¨oglich ist einen stark steigenden VektorA⁰zu berechnen, der dann die gleiche L¨osung wie der urspr¨ungliche Vektor Ahat. Wenn die berechneten Werte f¨ur die erstenaig¨ultig sind, dann kann versucht werden alle b_iina_i umzurechnen. Anschließend kann versucht werden den Geheimtext mit allen m¨oglichen berechnetenA⁰,m⁰undu⁰zu entschl¨usseln.

Da der Wert einesaimitbi,u⁰undm⁰berechnet werden kann, kann man die Berechnung als Funktionf_bi(u⁰, m⁰) = u⁰ ·b_i (mod m)⁰ ¨uber die Unbekanntenu⁰ undm⁰ darstellen. Dam⁰der Modul ist und die Werte vonu⁰begrenzt, k¨onnen die Unbekannten zu _m^u00 zusammen gefasst werden.

Somit erh¨alt man die Funktion:

f_bi(u⁰ m⁰) = u⁰

m⁰ ·b_i= a_i m⁰

Dem Angreifer ist nur der ¨offentliche Schl¨ussel B = (b₁, . . . , b_k) bekannt. Als erstes wird

¨uberpr¨uft ob ein Minimum _b^p

1 von f_b1 nahe bei einem Minimum _b^q

2 vonf_b2 liegt. Daf¨ur wird bestimmt ob es f¨ur16p6b1−1und16q 6b2−1einδgibt mit:

−δ < b₂·p−b1·q < δ

Wie viele der erstenb_iverwendet werden um ein geeignetes _m^u00 zu finden und wie viele m¨ogliche Kandidaten f¨uru⁰ undm⁰gesucht werden liegt im Ermessen des Angreifers und ist unabh¨angig vom Verfahren. Je mehr Funktionenfbi verwendet werden, desto mehr Ungleichungen m¨ussen ber¨ucksichtigt werden. Zusammen mit der Beschr¨ankungδ <

qb1

2 erh¨alt man, wennsFunktionen

ber¨ucksichtigt und maximalr Kandidaten bestimmt werden, eine Fehlerwahrscheinlichkeit von (²_r)^s−1.

Die Minima^p_bⁱ

i mit16pi 6bi−1f¨ur alle betrachtetenbiwerden der Gr¨oße nach sortiert, sodass zwei benachbarte Wertex_l undx_l+1 ein Intervall, auf dem die Funktionenf_bi(x_l 6 _m^u00 6 x_l+1) keine Spr¨unge haben, darstellt. Die Funktionen auf diesen Teilst¨ucken haben die Formb_i·v−c^j_i, wobeic^j_i Konstanten sind, die nicht vonioderjabh¨angen.

Die potenziellen Ergebnisse der Funktionenbi ·v−c^j_i m¨ussen die Eigenschaft der starken Steigung und der starken modularen Multiplikation erf¨ullen. Daher muss f¨ur eine Variable v (=uˆ ⁰/m⁰) mitxl 6v6xl+1folgendes gelten:

Pk

i=1(b_iv−c_i^j)<1 starke mod. Multiplikation Pi−1

l=1(b_lv−c_l^j)< b_iv−c_i^j, 26i6k

Wenn alle Ungleichungen aufgestellt und umgeformt sind, m¨ussen diev, die aus einem Intervall (x_l, x_l+1) gew¨ahlt werden k¨onnen, gewisse Bedingungen einhalten, die von den Konstantenc^j_i abh¨angen. Somit ist dasvnicht nur durch das Intervall, sondern auch durch die Ungleichungen so stark eingeschr¨ankt, dass alle ¨ubrig gebliebenen M¨oglichkeiten f¨urv(=uˆ ⁰/m⁰) berechnet werden k¨onnen. Nun ist es m¨oglich mit jedem der verh¨altnism¨aßig geringen Anzahl ¨ubrig gebliebener Kandidaten f¨uru⁰undm⁰den Geheimtext zu Entschl¨usseln.

2.3 RSA

Im Jahr1977entstand RSA als direkter Konkurrent zu DES. Die Grundidee des Algorithmus basiert auf der Annahme, dass die Multiplikation von Primzahlen leicht ist und dass Faktorisieren ein schweres Problem ist. Bis Heute erscheint das Verfahren relativ sicher, obwohl es bisher noch keinen Beweis daf¨ur gibt, dass das Faktorisieren wirklich schwer ist.

2.3.1 Mathematischer Hintergrund

Eine Zahlp >1ist eine Primzahl, wenn nur1undpTeiler vonpsind. Jede Zahlnl¨asst sich als Produkt von nicht trivialen Potenzen unterschiedlicher Primzahlen darstellen.

n=p^e₁¹·p^e₂²·. . .·p^e_k^k

Bisher ist kein Algorithmus bekannt mit dem die Primfaktorzerlegung in effizienter Zeit berechnet werden kann. Selbst wennk = 2unde₁ = e₂ = 1, alson = p₁·p₂ gilt, k¨onnen die Faktoren nicht effizient berechnet werden. Wenn die Primfaktorzerlegung einer Zahlmbekannt ist, l¨asst sich daraus dieEulerscheϕ-Funktionberechnen.

ϕ(m) :=|{a∈Zm |ggT(a, m) = 1}|