99
Das RSA-Verfahren Klaus Becker 2010

Das RSA-Verfahren

  • Upload
    sibley

  • View
    89

  • Download
    0

Embed Size (px)

DESCRIPTION

Das RSA-Verfahren. Klaus Becker 2010. Lehrplan - Leistungsfach. Ziel ist es, das RSA-Verfahren als eines der klassischen asymmetrischen Verschlüsselungs-verfahren genauer zu untersuchen, um die Funktionsweise dieses Verfahrens zu verstehen. - PowerPoint PPT Presentation

Citation preview

Page 1: Das RSA-Verfahren

Das RSA-Verfahren

Klaus Becker

2010

Page 2: Das RSA-Verfahren

2 Lehrplan - Leistungsfach

Ziel ist es, das RSA-Verfahren als eines der klassischen asymmetrischen Verschlüsselungs-verfahren genauer zu untersuchen, um die Funktionsweise dieses Verfahrens zu verstehen.

Die Vorgehensweise folgt einem Vorschlag von Witten und Schulz, der in den folgenden Artikeln beschrieben wird:

H. Witten, R.-H. Schulz: RSA & Co. in der Schule, Teil1. LOG IN 140 S. 45 ff.H. Witten, R.-H. Schulz: RSA & Co. in der Schule, Teil2. LOG IN 143 S. 50 ff.

Lehrplan für das Leistungsfach

Page 3: Das RSA-Verfahren

3 Teil 1

Experimente mit CrypTool

Page 4: Das RSA-Verfahren

4 Experimente mit CrypTool

Einen ersten Eindruck vom RSA-Verfahren kann man sich mit dem Software-Werkzeug CrypTool verschaffen. Dieses Werkzeug macht die wichtigsten Schritte des RSA-Verfahrens transparent.

Experimente mit CrypTool lassen direkt erkennen, dass das RSA-Verfahren auf Berechnungen mit Zahlen beruht.

Die Experimente führen aber noch nicht dazu, dass man versteht, warum gerade dieses Verfahren heutzutage benutzt wird. Hierzu sind vertiefende Untersuchungen erforderlich.

Page 5: Das RSA-Verfahren

5 Experimente mit CrypTool

Mit den Menüpunkten [Einzelverfahren][RSA-Kryptosystem][RSA-Demo...] kommst du in Bereich, in dem das RSA-Verfahren durchgespielt werden kann.

Gib zunächst zwei verschiedene Primzahlen in die dafür vorgesehenen Felder ein. Mit [Parameter aktualisieren] werden dann die beiden Schlüssel erzeugt.

Page 6: Das RSA-Verfahren

6 Experimente mit CrypTool

Wähle jetzt [Optionen für Alphabet und Zahlensystem...] und lege die vom Programm vorgesehenen Optionen fest. Am besten übernimmst du zunächst die Einstellungen der folgenden Abbildung (beachte das Leerzeichen im Alphabet).

Page 7: Das RSA-Verfahren

7 Experimente mit CrypTool

Jetzt kannst du Texte (mit Zeichen aus dem voreingestellten Alphabet) verschlüsseln und die Verschlüsselung auch wieder entschlüsseln.

Page 8: Das RSA-Verfahren

8 Aufgabe

Probiere die oben beschriebenen Schritte selbst einmal aus. Variiere auch die möglichen Vorgaben (z.B. eingegebene Primzahlen) und Einstellungsmöglichkeiten (z.B. Alphabetoptionen).

Page 9: Das RSA-Verfahren

9 Teil 2

Modulares Rechnen

Page 10: Das RSA-Verfahren

10 Vorbemerkung

Das RSA-Verfahren basiert auf modularem Rechnen. Um die Details des RSA-Verfahren zu verstehen, muss man modulares Rechnen beherrschen und einige zahlentheoretische Zusammenhänge kennen.

Im Unterricht kann man die mathematischen Grundlagen vorab erarbeiten, oder beim Erarbeiten des RSA-Verfahres - je nach Bedarf - immer wieder zu den mathematischen Betrachtungen zurückkommen.

Page 11: Das RSA-Verfahren

11 Uhrenaddition

Modulare Addition kennt man aus dem täglichen Leben.

Aufgabe:

Ergänze die in der Tabelle fehlenden Angaben zur Uhrzeit (Moskauer Zeit).

Wie rechnet man mit Uhrzeiten? Wie kann man z.B. direkt aus 17 und 149 zum Ergebnis 22 gelangen?

Page 12: Das RSA-Verfahren

12 Modulare Gleichheit

Verallgemeinerte Uhrzeiten

Bei Beginn der Reise in Moskau ist es 17 Uhr. Nach 149 Stunden wird das Ziel Wladiwostok erreicht. Es ist jetzt (17+149) Uhr bzw. 166 Uhr. Das entspricht - auch im fernen Sibirien - 22 Uhr. Man kann diese Uhrzeit leicht rechnerisch ermitteln indem man den Rest bei der Division durch 24 ermittelt:

166 % 24 = 22

Uhrzeiten werden eigentlich nur mit den Zahlen 0, 1, ..., 23 angegeben. Im Alltag lässt man auch manchmal die Zahl 24 zu. 24 Uhr ist dasselbe wie 0 Uhr. Die 24 ist - bei Uhrzeitangaben - also gleich zu behandeln wie die 0.

31 Uhr und 55 Uhr (als verallgemeinerte Uhrzeiten) würden für dieselben Uhrzeiten stehen, weil der zyklisch sich drehende und immer wieder bei 0 neu beginnende Uhrzeiger dieselbe Stelle anzeigen würde. Rechnerisch zeigt sich das, indem beide Zahlen 31 und 55 denselben Rest bei der Division durch 24 hinterlassen.

Def.: Vorgegeben sei eine natürliche Zahl n. Zwei natürliche Zahlen a und b heißen gleich modulo n bzw. kongruent modulo n genau dann, wenn sie beide den gleichen Rest bei der Division durch n erzeugen.

Beispiel: 31 und 55 sind gleich modulo 24, denn es gilt:

[31]%24 = 7 = [55]%24

Page 13: Das RSA-Verfahren

13 Modulare Gleichheit

Zählen modulo vorgegebener Primzahlenn: 0 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

[n]%3: 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0 1 2 0

[n]%5: 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 0 1 2

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

Satz (über modulare Gleichheit bzgl. Primzahlen):

p und q seien zwei vorgegebene verschiedene Primzahlen. Wenn zwei natürliche Zahlen a und b sowohl gleich modulo p als auch gleich modulo q sind, dann sind sie auch gleich modulo p*q.

Anders formuliert:

Aus [a]%p = [b]%p und [a]%q = [b]%q folgt [a]%(p*q) = [b]%(p*q).

Page 14: Das RSA-Verfahren

14 Modulare Addition

Aufgabe:

(a) Führe die Rechnung für weitere Städte durch.

(b) Darf man für EKATERINBURG auch so rechen:

[17 + 26]%24 = [17]%24 + [26]%24 = ...

(c) Geht das auch für NOVOSIBIRSK? Was müsste man hier noch tun?

[17 + 46]%24 = [17]%24 + [46]%24 = ...

Page 15: Das RSA-Verfahren

15 Modulare Addition

Vorgegeben sei eine natürliche Zahl n. Zwei natürliche Zahlen a und b werden modulo n addiert, indem man sie addiert und anschließend von der Summe den Rest bei der Division durch n berechnet. Das Ergebnis ist also [a+b]%n. Beachte, dass das Ergebnis bei der Addition modulo n immer eine Zahl kleiner als n ist.

Rechengesetz (Modulare Gleichheit bei der Addition):

Aus [a1]%n = [b1]%n und [a2]%n = [b2]%n folgt [a1+a2]%n = [b1+b2]%n.

Das erste Rechengesetz besagt, dass Zahlen, die modulo n gleich sind, auch zu gleichen Additionsergebnissen modulo n führen.

Rechengesetz (Addition und iterierte Modulberechnung):

[a+b]%n = [[a]%n + [b]%n]%n

Das zweite Rechengesetz erlaubt es, bei der Addition modulo n zuerst die Summanden zu verkleinern und dann erst die Addition durchzuführen.

Aufgabe:

Erstelle selbst eine Verknüpfungstafel für die Addition modulo n = 5.

Page 16: Das RSA-Verfahren

16 Modulare Multiplikation

Vorgegeben sei eine natürliche Zahl n. Zwei natürliche Zahlen a und b werden modulo n multipliziert, indem man sie multipliziert und anschließend vom Produkt den Rest bei der Division durch n berechnet. Das Ergebnis ist also [a*b]%n. Beachte, dass das Ergebnis bei der Multiplikation modulo n immer eine Zahl kleiner als n ist.

Rechengesetz (Modulare Gleichheit bei der Addition):

Aus [a1]%n = [b1]%n und [a2]%n = [b2]%n folgt [a1+a2]%n = [b1+b2]%n.

Das erste Rechengesetz besagt, dass Zahlen, die modulo n gleich sind, auch zu gleichen Additionsergebnissen modulo n führen.

Rechengesetz (Addition und iterierte Modulberechnung):

[a+b]%n = [[a]%n + [b]%n]%n

Das zweite Rechengesetz erlaubt es, bei der Addition modulo n zuerst die Summanden zu verkleinern und dann erst die Addition durchzuführen.

Aufgabe:

Erstelle selbst eine Verknüpfungstafel für die Multiplikation modulo n = 8.

Page 17: Das RSA-Verfahren

17 Aufgaben

Bestätige die Rechengesetze für modulare Addition und Multiplikation anhand von Beispielen. Du kannst Python als Taschenrechner benutzen.

>>> n = 14>>> a1 = 16>>> b1 = 19>>> a2 = 44>>> b2 = 75>>> a1%n2>>> a2%n2>>> b1%n5>>> b2%n5>>> (a1+b1)%n...

Page 18: Das RSA-Verfahren

18 Modulares Inverses

Def.: Zwei natürliche Zahlen a und b heißen modular invers zueinander bezüglich n genau dann, wenn gilt: [a*b]%n = 1. Beispiel: [2*3]%5 = 1.

Die beiden Zahlen 2 und 3 sind also modular invers zueinander bzgl. 5. Die Zahl 2 ist das modulare Inverse von 3 bzgl. des Moduls 5. Ebenso ist 3 das modulare Inverse von 2 bzgl. des Moduls 5.

Aufgabe:

(a) Betrachte den Fall n = 5 (siehe Verknüpfungstafel oben). Bestimme zu a = 1, 2, 3, 4 jeweils das modulare Inverse bzgl. n.

(b) Betrachte den Fall n = 8 (siehe Folie 16). Für welche der Zahlen a = 1, 2, ..., 7 kann man das modulare Inverse bzgl. n bestimmen?

(c) Betrachte den Fall n = 15. Hast du bereits eine Vermutung, für welche der Zahlen a = 1, 2, ..., 14 man das modulare Inverse bzgl. n bestimmen kann?

Page 19: Das RSA-Verfahren

19 Existenz des modularen Inversen

Satz (über die Existenz des modularen Inversen):

Gegeben sei eine natürliche Zahl n. Das modulare Inverse zu einer Zahl a ungleich Null existiert genau dann, wenn a und n keinen gemeinsamen Teiler größer als 1 haben - d.h., wenn ggT(a, n) = 1 gilt.

Page 20: Das RSA-Verfahren

20

Berechnung des modularen Inversen

Entwickle eine Python-Funktion modInv(a, n), die das modulare Inverse von a bzgl. n zurückgibt, sofern dieses Inverse existiert. Wenn keine solche Zahl existiert, soll der Wert -1 zurückgegeben werden.

Tipp: Man kann der Reihe nach alle in Frage kommenden Zahlen durchprobieren.

Page 21: Das RSA-Verfahren

21 Modulare Potenz

Vorgegeben sei eine natürliche Zahl n. Eine natürliche Zahl a wird mit einer natürlichen Zahl x modulo n potenziert, indem man sie mit x potenziert und anschließend von der Potenz den Rest bei der Division durch n berechnet. Das Ergebnis ist also [ax]%n. Beachte, dass das Ergebnis bei der Potenzbildung modulo n immer eine Zahl kleiner als n ist. Aufgabe:

(a) Berechne [34]%5.

(b) Berechne [64]%5. Berechne auch [([([([6]%5)*6]%5)*6]%5)*6]%5. Was stellst du fest?

(c) Welche Vorteile ergeben sich bei großen Zahlen, wenn man [ax]%n wie folgt berechnet: [(...([([a]%n)*a]%n)...)*a]%n ?

Aufgabe:

Berechne [a(p-1)]%p für verschiedene natürliche Zahlen a und verschiedene Primzahlen p. Für welche Zahlen erhält man als Ergebnis 1? Du kannst hierzu ein einfaches Python-Programm schreiben, das die Berechnungen für verschiedene Primzahlen p und natürliche Zahlen a übernimmt.

Page 22: Das RSA-Verfahren

22 Kleiner Fermatscher Satz

Satz (Kleiner Fermatscher Satz):

Sei p eine Primzahl und a eine natürliche Zahl, die kein Vielfaches von p ist. Dann gilt

[a(p-1)]%p = 1

Gegeben sei eine Primzahl p und eine natürliche Zahl, die kein Vielfaches von p ist (z.B. p=5 und a = 12).

Wenn man [1*a]%p, [2*a]%p, [3*a]%p, ..., [(p-1)*a]%p berechnet, so erhält man als Ergebnisse die Zahlen 1, 2, 3, ..., p-1 - allerdings in anderer Reihenfolge.

Hieraus lässt sich mit einigen Rechengesetzen folgender Zusammenhang herleiten:

[(1*a)*(2*a)*(3*a)*...*((p-1)*a)]%p = [1*2*3*...*(p-1)]%p

Umgeformt erhält man:

[1*2*3*...*(p-1)*a(p-1)]%p = [1*2*3*...*(p-1)]%p

Hieraus kann man mit einigen zusätzlichen Überlegungen schließen:

[a(p-1)]%p = 1

Page 23: Das RSA-Verfahren

23 Teil 3

Verschlüsseln mit modularer Addition

Page 24: Das RSA-Verfahren

24 Vorbemerkung

Als Vorstufe zum RSA-Verfahren betrachten wir hier ein Verfahren, das auf modularer Addition beruht und bereits viele Ähnlichkeiten zum RSA-Verfahren aufweist.

Der Vorteil dieser Vorgehensweise besteht darin, dass wir an das sehr einfache Caesar-Verfahren anknüpfen können und durch Verallgemeinerung dieses Verfahrens zu den zahlenbasierten Verfahren gelangen.

Page 25: Das RSA-Verfahren

25 Den Anfang macht Caesar

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

D E F G H I J K L M N O P Q R S T U V W X Y Z A B C

Schlüssel: DQuelltext:

SALVEASTERIX

Geheimtext:VDOYHDVWHULA

Page 26: Das RSA-Verfahren

26 Caesar-Verfahren mit Zahlen

Codierung:

Umwandlung von Zeichen in Zahlen

Verschlüsselung:

Verarbeitung von Zahlen

Entschlüsselung:

Verarbeitung von Zahlen

Decodierung:

Umwandlung von Zahlen in Zeichen

A → 00B → 01...Z → 25

A,S,T,E,R,I,X

00,18,19,04,17,08,23

(00 + 3) % 26 = 03(18 + 3) % 26 = 21...(23 + 3) % 26 = 00

00,18,19,04,17,08,23

03,21,22,07,20,11,00

(03 + 23) % 26 = 00(21 + 23) % 26 = 18...(00 + 23) % 26 = 23

03,21,22,07,20,11,00

00,18,19,04,17,08,23

A → 00B → 01...Z → 25

00,18,19,04,17,08,23

D,V,W,H,U,L,A

Page 27: Das RSA-Verfahren

27

Caesar-Variation: zusätzliche Zeichen

Codierung:

Umwandlung von Zeichen in Zahlen

Verschlüsselung:

Verarbeitung von Zahlen

Entschlüsselung:

Verarbeitung von Zahlen

Decodierung:

Umwandlung von Zahlen in Zeichen

' ' → 00 'A' → 01...'Z' → 26

N,A,C,H, ,R,O,M

14,01,03,08,00,18,15,13

(14 + 9) % 27 = 23(01 + 9) % 27 = 10...(13 + 9) % 27 = 22

14,01,03,08,00,18,15,13

23,10,12,17,09,00,24,22

(23 + 18) % 27 = 14(10 + 18) % 27 = 01...(22 + 18) % 27 = 13

23,10,12,17,09,00,24,22

14,01,03,08,00,18,15,13

' ' → 00 'A' → 01...'Z' → 26

14,01,03,08,00,18,15,13

N,A,C,H, ,R,O,M

Page 28: Das RSA-Verfahren

28

Caesar-Variation: verallgeinerte Addition

Codierung:

Umwandlung von Zeichen in Zahlen

Verschlüsselung:

Verarbeitung von Zahlen(e, m) = (9, 30) Entschlüsselung:

Verarbeitung von Zahlen(d, m) = (21, 30)Decodierung:

Umwandlung von Zahlen in Zeichen

' ' → 00 'A' → 01...'Z' → 26

D,A, ,I,S,T, ,E,S

04,01,00,09,19,20,00,05,19

(04 + 18) % 30 = 22(01 + 18) % 30 = 19...(19 + 18) % 30 = 07

04,01,00,09,19,20,00,05,19

22,19,18,27,07,08,18,23,07

(22 + 12) % 30 = 04(19 + 12) % 30 = 01...(07 + 12) % 30 = 19

22,19,18,27,07,08,18,23,07

04,01,00,09,19,20,00,05,19

' ' → 00 'A' → 01...'Z' → 26

04,01,00,09,19,20,00,05,19

D,A, ,I,S,T, ,E,S

Page 29: Das RSA-Verfahren

29

Caesar-Variation: größere Blocklänge

Codierung:

Umwandlung von Zeichen in Zahlen

Verschlüsselung:

Verarbeitung von Zahlen(e, m) = (112233, 321321)

Entschlüsselung:

Verarbeitung von Zahlen(d, m) = (209088, 321321)

Decodierung:

Umwandlung von Zahlen in Zeichen

' ' → 00 'A' → 01...'Z' → 26

HAL,LO

80112, 121500

(80112 + 112233) % 321321 = 192345 (80112 + 112233) % 321321 = 233733

80112, 121500

192345, 233733

(192345 + 209088) % 321321 = 192345

(233733 + 209088) % 321321 = 121500

192345, 233733

80112, 121500

' ' → 00 'A' → 01...'Z' → 26

80112, 121500

HAL,LO

Page 30: Das RSA-Verfahren

30 Verfahren mit modularer Addition

Schritt 1: Wahl der Blocklänge und Zerlegung des Textes

Die Blocklänge legt die Länge der Texteinheiten fest, die mit Zahlen codiert werden und anschließend verschlüsselt werden. Je größer die Blocklänge, desto mehr Zahlen benötigt man zur Codierung der Texteinheiten.

Bei einer Blocklänge 3 wird beispielweise der Text 'CAESAR' wie folgt in Texteinheiten zerlegt:

'CAE','SAR'

Bei einer Zerlegung eines Textes kann es vorkommen, dass eine Texteinheit übrig bleibt, die nicht mehr die gesamte Blocklänge hat. In diesem Fall füllen wir den Text mit zusätzlichen Zeichen (hier Leerzeichen) auf:

'HAL','LO '

Page 31: Das RSA-Verfahren

31 Verfahren mit modularer Addition

Schritt 2: Wahl der Codierung

Die Codierung ordnet jeder Texteinheit eine natürliche Zahl zu. Die Zuordnung muss eindeutig sein, so dass eine Decodierung möglich ist.

Codierung von Zeichenblöcken:

' ' -> 000

' A' -> 001

' B' -> 002

...

' Z' -> 026

'A ' -> 027

'AA' -> 028

...

'ZZ' -> 728

Codierung von Zeichenblöcken:

' ' -> 0000

' A' -> 0001

' B' -> 0002

...

' Z' -> 0026

'A ' -> 0100

'AA' -> 0101

...

'ZZ' -> 2626

Codierung des Alphabets:

' ' -> 00

'A' -> 01

...

'Z' -> 26

Page 32: Das RSA-Verfahren

32 Verfahren mit modularer Addition

Schritt 3: Wahl des Moduls und der Verschiebezahl

Die Modulzahl n ist eine beliebige natürliche Zahl. Sie muss nur so gewählt werden, dass sie größer als die größtmögliche Codezahl einer Texteinheit ist. Die zu wählende Größe hängt demnach von der Blocklänge und der gewählten Codierung ab.

Die Verschiebezahl e zum Verschlüsseln (e-ncrypt) ist eine beliebige natürliche Zahl, die kleiner als die Modulzahl n ist.

Beide zusammen - Verschiebezahl und Modul - werden zur Verschlüsselung benötigt. Das Zahlenpaar (e, n) bildet den Schlüssel zur Verschlüsselung eines Textes. Dieser Schlüssel wird auch öffentlicher Schlüssel genannt.

Schritt 4: Bestimmung des Gegenschlüssels

Die Verschiebezahl d zum Entschlüsseln (d-ecrypt) ergibt sich direkt aus e und n: Es muss e+d=m gelten. Also ist d = n - e.

Das Zahlenpaar (d, n) bildet den Schlüssel zur Entschlüsselung eines Textes. Dieser Schlüssel wird auch privater Schlüssel genannt.

Page 33: Das RSA-Verfahren

33 Verfahren mit modularer Addition

Schritt 5: Verschlüsselung codierter Texte

Zur Verschlüsselung eine Codezahl x benötigt man den öffentlichen Schlüssel (e, m). Die Verschlüsselung erfolgt hier durch modulare Addition:

x -> [x + e]%n

Schritt 6: Entschlüsselung codierter Texte

Zur Entschlüsselung eine Codezahl y benötigt man den privaten Schlüssel (d, n). Die Entschlüsselung erfolgt analog zur Verschlüsselung:

y -> [y + d]%n

Page 34: Das RSA-Verfahren

34 Aufgabe

Benutze unsere Standardcodierung mit Blocklänge 2. Wähle einen öffentlichen Schlüssel (wie z.B. (567, 2911)) und verschlüssele eine selbst gewählte Nachricht mit dem oben beschriebenen Verfahren mit modularer Addition (Version 3).

Gib die Nachricht an deinen Nachbarn weiter. Teile ihm auch den benutzten öffentlichen Schlüssel mit. Dein Nachbar soll jetzt die Nachricht wieder entschlüsseln.

Page 35: Das RSA-Verfahren

35 Korrektheit

Korrektheit:

Die Entschlüsselung macht die Verschlüsselung rückgängig:

x → [x + e]%n → [[x + e]%n + d]%n = [x + [e + d]%n]%n = [x]%n = x

Page 36: Das RSA-Verfahren

36 Prinzip von Kerckhoff

Vgl. A. Beutelspacher: Kryptologie. Vieweg 1996

Das Prinzip wurde erstmals formuliert im Buch "La cryptographie militaire" von Jean Guillaume Hubert Victor Francois Alexandre Auguste Kerckhoffs van Nieuwenhof (1835 bis 1903).

Die Sicherheit eines Kryptosystems darf nicht von der Geheimhaltung des Algorithmus abhängen. Die Sicherheit darf sich nur auf die Geheimhaltung des Schlüssels gründen.

Page 37: Das RSA-Verfahren

37 Sicherheit

Sicherheit:

Das additive Chiffrierverfahren ist nicht sicher, da man aus dem öffentlichen Schlüssel sofort den privaten Schlüssel bestimmen kann.

Page 38: Das RSA-Verfahren

38 Implementierung

Aufgabe 1: Eine Implementierung testen

Lade die Datei chiffriersystemModularesAddierenAufgabe1.txt (siehe inf-schule) herunter. Diese Datei enthält eine ganze Reihe von Funktionen, die Teilaufgaben beim Verfahren mit modularer Addition übernehmen. Teste alle Funktionen und beschreibe das Verhalten der Funktionen in Worten. Passende Funktionsaufrufe sind als Docstrings bereits angegeben.

Aufgabe 2: Eine Implementierung nutzen

Mit Funktionen der Implementierung aus Aufgabe 1 kannst jetzt interaktiv das Verfahren mit modularer Addition durchspielen. Führe selbst weitere Tests durch. Du kannst die Funktionsaufrufe auch in einem kleinen Testprogramm zusammenfassen.>>> block = 2>>> oeffentlicherSchluessel = (2102, 3000)>>> privaterSchluessel = (898, 3000)>>> quelltext = 'ASTERIX'>>> quellcode = codieren(quelltext, block)>>> quellcode[119, 2005, 1809, 2400]>>> geheimcode = verschluesseln(quellcode, oeffentlicherSchluessel)>>> geheimcode[2221, 1107, 911, 1502]>>> entschluesseltercode = verschluesseln(geheimcode, privaterSchluessel)>>> entschluesseltercode[119, 2005, 1809, 2400]>>> entschluesseltertext = decodieren(entschluesseltercode, block)>>> entschluesseltertext'ASTERIX'

Page 39: Das RSA-Verfahren

39 Implementierung

Aufgabe 3: Eine Implementierung abändern

Die Implementierung aus Aufgabe 1 benutzt zur Codierung das Aneinanderfügen von Codes bei Zeichenblöcken:

' ' -> 0000

' A' -> 0001

' B' -> 0002

...

' Z' -> 0026

'A ' -> 0100

'AA' -> 0101

...

'ZZ' -> 2626

Ändere die Implementierung so ab, dass der ASCII-Code zur Umwandlung von Zeichen in Zahlen benutzt wird. Bei Zeichenblöcken sollen die Codezahlen durch systematisches Durchzählen ermittelt werden. In CrypTool wird hierzu die Einstellung "b-adisch" gewählt. Experimentiere erst mit CrypTool und passe dann die Implementierung der Codierung geeignet an.

Page 40: Das RSA-Verfahren

40 Implementierung

Aufgabe 4: Eine Implementierung selbst entwickeln

Lade die Datei chiffriersystemModularesAddierenAufgabe4.txt (siehe inf-schule) herunter. Diese Datei enthält bereits eine ganze Reihe von Funktionsbeschreibungen, die Teilaufgaben beim Verfahren mit modularer Addition übernehmen können. Ergänze die Implementierung dieser Funktionen und teste die Funktionen wie in Aufgabe 2.

Page 41: Das RSA-Verfahren

41 Teil 3

Verschlüsseln mit modularer Multiplikation

Page 42: Das RSA-Verfahren

42 Vorbemerkung

Statt modularer Addition verwenden wir hier modulare Multiplikation als Grundlage eines Verschlüsselungsverfahres. Dieses Verfahen kann ebenfalls als Vorstufe zum RSA-Verfahren angesehen werden. Genau wie beim RSA-Verfahren hängt die Sicherheit des hier betrachteten Verfahrens davon ab, ob man über schnelle Algorithmen für bestimmte Problemstellungen verfügt.

Page 43: Das RSA-Verfahren

43 Multiplikation statt Addition

(e, n)

f(x, (e,n))

=

[x*e]%n

(d, n)

x0, x1, x2, ...

A(lice)

Klartext

f*(y, (d,n))

=

[y*d]%n

öffentl. Schlüssel von B(ob)

x0, x1, x2, ...

Klartext

y0, y1, y2, ...

Geheimtext

Verschlüsselungsfunktion Entschlüsselungsfunktion

"HALLO ..."

Codierung

"HALLO ..."

Codierung

B(ob)

pivat. Schlüssel von B(ob)

(e, n)

f(x, (e,n))

=

[x+e]%n

(d, n)

x0, x1, x2, ...

A(lice)

Klartext

f*(y, (d,n))

=

[y+d]%n

öffentl. Schlüssel von B(ob)

x0, x1, x2, ...

Klartext

y0, y1, y2, ...

Geheimtext

Verschlüsselungsfunktion Entschlüsselungsfunktion

"HALLO ..."

Codierung

"HALLO ..."

Codierung

B(ob)

pivat. Schlüssel von B(ob)

Page 44: Das RSA-Verfahren

44 Statt Addition ...

' ' → 00 'A' → 01...'Z' → 26

N,I,X, ,L,O,S

14,09,24,00,12,15,19

(14 + 7) % 30 = 21(09 + 7) % 30 = 16...(19 + 7) % 30 = 26

14,09,24,00,12,15,19

21,16,01,07,19,22,26

(21 + 23) % 30 = 14(16 + 23) % 30 = 09...(26 + 23) % 30 = 19

21,16,01,07,19,22,26

14,09,24,00,12,15,19

' ' → 00 'A' → 01...'Z' → 26

14,09,24,00,12,15,19

N,I,X, ,L,O,S

Codierung:

Umwandlung von Zeichen in Zahlen

Verschlüsselung:

Verarbeitung von Zahlen

Verschlüsselung:

Verarbeitung von Zahlen

Codierung:

Umwandlung von Zeichen in Zahlen

Page 45: Das RSA-Verfahren

45 ... benutze Multiplikation!

' ' → 00 'A' → 01...'Z' → 26

N,I,X, ,L,O,S

14,09,24,00,12,15,19

(14 * 7) % 30 = 08(09 * 7) % 30 = 03...(19 * 7) % 30 = 13

14,09,24,00,12,15,19

08,03,18,00,24,15,13

Codierung:

Umwandlung von Zeichen in Zahlen

Verschlüsselung:

Verarbeitung von Zahlen

(08 * x) % 30 = 14(03 * x) % 30 = 09...(13 * x) % 30 = 19

08,03,18,00,24,15,13

14,09,24,00,12,15,19

Verschlüsselung:

Verarbeitung von Zahlen

' ' → 00 'A' → 01...'Z' → 26

14,09,24,00,12,15,19

N,I,X, ,L,O,S

Codierung:

Umwandlung von Zeichen in Zahlen

Page 46: Das RSA-Verfahren

46 Verfahren und seine Korrektheit

Korrektheit:

Die Entschlüsselung macht die Verschlüsselung rückgängig:

x → [x * e]%n → [[x * e]%n * d]%n = [x * [e * d]%n]%n = [x * 1]%n = x

Es muss hierzu folgende Schlüsselbedingung erfüllt sein:

[e * d]%n = 1

d.h.: d ist modulares Inverses zu e bzgl. n.

(e, n)

f(x, (e,n))

=

[x*e]%n

(d, n)

x0, x1, x2, ...

A(lice)

Klartext

f*(y, (d,n))

=

[y*d]%n

öffentl. Schlüssel von B(ob)

x0, x1, x2, ...

Klartext

y0, y1, y2, ...

Geheimtext

Verschlüsselungsfunktion Entschlüsselungsfunktion

"HALLO ..."

Codierung

"HALLO ..."

Codierung

B(ob)

pivat. Schlüssel von B(ob)

Schlüsselerzeugung:

Wähle n größer als die maximale Codezahl.

Wähle e mit e <n.

Bestimme d mit [e*d]%n = 1.

Page 47: Das RSA-Verfahren

47 Implementierung

Aufgabe 1: Eine Implementierung testen

Lade die Datei chiffriersystemModularesMultiplizieren.txt (siehe inf-schule) herunter. Diese Datei enthält eine ganze Reihe von Funktionen zur Implementierung des Verfahrens mit modularer Multiplikation.

Teste die Implementierung, indem du das Verfahren mit modularer Multiplikation interaktiv durchspielst.

Aufgabe 2: Implementierungen analysieren

Vergleiche die Implementierungen zum Verfahren mit modularer Addition und zum Verfahren mit modularer Multiplikation. Die Implementierungen unterscheiden sich nur an einer Stelle. Welche Stelle ist das?

Page 48: Das RSA-Verfahren

48 Sicherheit

(e, n)

f(x, (e,n))

=

[x*e]%n

(?, n)

???

A(lice)

Klartext

f*(y, (d,n))

=

[y*d]%n

öffentl. Schlüssel von B(ob)

???

Klartext

y0, y1, y2, ...

Geheimtext

Verschlüsselungsfunktion Entschlüsselungsfunktion

???

Codierung

???

Codierung

B(ob)

pivat. Schlüssel von B(ob)

Mr(s) X

Schlüsselerzeugung:

Wähle n größer als die maximale Codezahl.

Wähle e mit e <n.

Bestimme d mit [e*d]%n = 1.

Sicherheit:Die Sicherheit des multiplikativen Chiffrierverfahrens hängt davon ab, ob man zur Zahl e aus dem öffentlichen Schlüssel das modulare Inverse d bzgl. n bestimmen kann.

Page 49: Das RSA-Verfahren

49 Aufgabe

Codierung:

Umwandlung von Zeichen in Zahlen

Verschlüsselung:

öffentlicher Schlüssel(e, m) = (16, 33)

Entschlüsselung:

privater Schlüssel(d, m) = (..., ...)

Decodierung:

Umwandlung von Zahlen in Zeichen

24, 12, 15, 29, 23, 12, 13

' ' → 00 'A' → 01...'Z' → 26

' ' → 00 'A' → 01...'Z' → 26

.,.,.,.,.,.,.

Page 50: Das RSA-Verfahren

50 Aufgabe

Codierung:

Umwandlung von Zeichen in Zahlen

Verschlüsselung:

öffentlicher Schlüssel(e, m) = (381, 800)

Entschlüsselung:

privater Schlüssel(d, m) = (..., ...)

Decodierung:

Umwandlung von Zahlen in Zeichen

030,235,314,316,305,253,368

' ' → 00 'A' → 01...'Z' → 26

' ' → 00 'A' → 01...'Z' → 26

..,..,..,..,..,..,..

Page 51: Das RSA-Verfahren

51

Bestimmung des modularen Inversen

Ein naiver Ansatz besteht darin, der Reihe nach alle Zahlen durchzuprobieren, bis man das gewünschte Ergebnis gefunden hat.

Beispiel: e = 16; n = 33

[16*1]%33 = 16; [16*2]%33 = 32; ...; [16*31]%33 = 1

Diesen naiven Ansatz kann man auch leicht implementieren:

def modInv(e, n): gefunden = False d = 1 while d <= n and not gefunden: if (e * d) % n == 1: gefunden = True else: d = d + 1 if d > n: d = -1 return d

Page 52: Das RSA-Verfahren

52

Bestimmung des modularen Inversen

Aufgabe:

Teste den Baustein modInv mit selbst mit selbst gewählten Beispielen. Überprüfe auch die Richtigkeit der Ergebnisse.

Aufgabe:

(a) Teste den Baustein mit großen Zahlen. Bestimme hierzu das modulare Inverse von a = 775517959261225265313877628572204089387832653836742449 bzgl. des Moduls n = 1000010000100001000010000100001000010000100001000010000.

(b) Bestimme zunächst mit dem Resultat aus (a) das modulare Inverse von b = 49 bzgl. des Moduls n = 1000010000100001000010000100001000010000100001000010000. Bestimme anschließend das gesuchte modulare Inverse mit dem vorgegebenen Baustein. Welches Problem tritt hier auf? Hast du eine Vermutung, warum das Problem auftritt.

Page 53: Das RSA-Verfahren

53

>>> modInvMitAusgaben(49, 1000010000100001000010000100001000010000100001000010000)Anzahl der Versuche: 10000000Anzahl der Versuche: 20000000Anzahl der Versuche: 30000000...

Bestimmung des modularen Inversen

def modInvMitAusgaben(e, n): gefunden = False d = 1 while d <= n and not gefunden: if d % 10000000 == 0: print("Anzahl der Versuche: ", d) if (e * d) % n == 1: gefunden = True else: d = d + 1 if d > n: d = -1 return d

für 10 Millionen Überprüfungen

benötigt man mehr als 1 Sekunde!

Page 54: Das RSA-Verfahren

54

Bestimmung des modularen Inversen

Beispiel:

d = 49n = 1000010000100001000010000100001000010000100001000010000modInv(d, n)

Um 10 000 000 (= 107) Zahlen durchzuprobieren, benötigt ein Rechner derzeit mehr als 1s.

Da das erwartete Ergebnis 775517959261225265313877628572204089387832653836742449 eine 54-stellige Zahl ist, wird der Rechner eine Zeit benötigen, die in der Größenordnung von 1047s liegt. Dies sind mehr als 1039 Jahre. Bedenkt man, dass das Universum ein Alter von etwa 1010 Jahre hat, dann zeigt sich, wie ungeeignet das naive Vorgehen ist. Für größere Zahlen ist der naive Algorithmus unbrauchbar. Für die gezeigten Zahlen benötigt ein Rechner länger, als das Universum alt ist.

Page 55: Das RSA-Verfahren

55 Vielfachsummensatz

Ein besseres Verfahren zur Bestimmung des modularen Inversen basiert auf folgendem Zusammenhang ("Vielfachsummensatz", "Lemma von Bézout", "Lemma von Bachet"):Für je zwei natürliche Zahlen a und b gibt es ganze Zahlen x und y mit ggT(a,b)=x*a+y*b.

Beispiele:

a = 3; b = 4: ggT(3, 4) = 1 = (-1)*3 + 1*4

a = 6; b = 9: ggT(6, 9) = 3 = (-1)*6 + 1 * 9

a = 41; b = 192: ggT(41, 192) = 1 = 89*41 + (-19)*192

Page 56: Das RSA-Verfahren

56

Erweiterter euklidischer Algorithmus

(1) 884 = 2*320 + 244 → 244 = 884 - 2*320 = (1*884 + 0*320) - 2*(1*320 + 0*884) = 1*884 - 2*320

(2) 320 = 1*244 + 76→ 76 = 320 - 1*244 = (0*884 + 1*320) - 1*(1*884 - 2*320)) = 3*320 - 1*884

(3) 244 = 3*76 + 16 → 16 = 244 - 3*76 = (1*884 - 2*320) - 3*(3*320 - 1*884) = 4*884 - 11*320

(4) 76 = 4*16 + 12→ 12 = 76 - 4*16 = (3*320 - 1*884) - 4*(4*884 - 11*320) = 47*320 - 17*884

(5) 16 = 1*12 + 4→ 4 = 16 - 1*12 = (4*884 - 11*320) - 1*(47*320 - 17*884) = 21*884 - 58*320

(6) 12 = 3*4 + 0

Gegeben: a = 884; b = 320Gesucht: ggT(a, b) = x*a + y*b

Ergebnis:

ggT(884, 320) = 4 = 21*884 + (- 58)*320

Page 57: Das RSA-Verfahren

57 Aufgabe

Bestimme analog die Darstellung für a = 30 und b = 7.

Gegeben: a = 30; b = 7Gesucht: ggT(a, b) = x*a + y*b

Page 58: Das RSA-Verfahren

58 Aufgabe

Das Struktogramm zeigt, wie der erweiterte euklidische Algorithmus mit Variablen und Kontrollstrukturen beschrieben werden kann. Im Folgenden ist ein Ablaufprotokoll für die Eingaben a = 884 und b = 320 skizziert. Mache dir anhand dieses Ablaufprotokolls die Arbeitsweise des Algorithmus klar. Die unten gezeigten Berechnungsschritte sollten sich im Ablaufprotokoll widerspiegeln.

Bachet

Eingabe: a, b

aalt := a

amitte := b

xalt := 1

xmitte := 0

yalt := 0

ymitte := 1

SOLANGE amitte <> 0

q := aalt div amitte

aneu := aalt mod amitte

xneu := xalt - q*xmitte

yneu := yalt - q*ymitte

xalt := xmitte

xmitte := xneu

yalt := ymitte

ymitte := yneu

aalt := amitte

amitte := aneu

Ausgabe: aalt, xalt, yalt

(1) 884 = 2*320 + 244 → 244 = 884 - 2*320 = (1*884 + 0*320) - 2*(1*320 + 0*884) = 1*884 - 2*320

(2) 320 = 1*244 + 76→ 76 = 320 - 1*244 = (0*884 + 1*320) - 1*(1*884 - 2*320)) = 3*320 - 1*884

(3) 244 = 3*76 + 16 → 16 = 244 - 3*76 = (1*884 - 2*320) - 3*(3*320 - 1*884) = 4*884 - 11*320

(4) 76 = 4*16 + 12→ 12 = 76 - 4*16 = (3*320 - 1*884) - 4*(4*884 - 11*320) = 47*320 - 17*884

(5) 16 = 1*12 + 4→ 4 = 16 - 1*12 = (4*884 - 11*320) - 1*(47*320 - 17*884) = 21*884 - 58*320

(6) 12 = 3*4 + 0

Page 59: Das RSA-Verfahren

59

Erweiterter euklidischer Algorithmus

Geg.: a = 884; b = 320; Ges.: ggT(a, b) = x*a + y*b

aalt:884 = a:884 amitte:320 = b:320xalt:1 = 1xmitte:0 = 0yalt:0 = 0ymitte:1 = 1 {aalt:884 = xalt:1 * a: 884 + yalt:0 * b:320; amitte:320 = xmitte:0 * a:884 + ymitte:1 * b:320}

(1) 884 = 2*320 + 244 → 244 = 884 - 2*320 = (1*884 + 0*320) - 2*(1*320 + 0*884) = 1*884 - 2*320

q: 2 = aalt: 884 / amitte: 320 aneu:244 = aalt:884 % amitte:320xneu:1 = xalt:1 - xmitte:0 * q:2yneu:-2 = yalt:0 - ymitte:1 * q:2xalt:0 = xmitte:0xmitte:1 = xneu:1yalt:1 = ymitte:1ymitte:-2 = yneu:-2aalt:320 = amitte:320amitte:244 = aneu:244{aalt:320 = xalt:0 * a:884 + yalt:1 * b:320; amitte:244 = xmitte:1 * a:884 + ymitte:-2 * b:320}

Bachet

Eingabe: a, b

aalt := a

amitte := b

xalt := 1

xmitte := 0

yalt := 0

ymitte := 1

SOLANGE amitte <> 0

q := aalt div amitte

aneu := aalt mod amitte

xneu := xalt - q*xmitte

yneu := yalt - q*ymitte

xalt := xmitte

xmitte := xneu

yalt := ymitte

ymitte := yneu

aalt := amitte

amitte := aneu

Ausgabe: aalt, xalt, yalt

Page 60: Das RSA-Verfahren

60

Erweiterter euklidischer Algorithmus

{aalt:320 = xalt:0 * a:884 + yalt:1 * b:320; amitte:244 = xmitte:1 * a:884 + ymitte:-2 * b:320}

(2) 320 = 1*244 + 76 → 76 = 320 - 1*244 = (0*884 + 1*320) - 1*(1*884 - 2*320)) = 3*320 - 1*884

q: 1 = aalt: 320 / amitte: 244 aneu:76 = aalt:320 % amitte:244xneu:-1 = xalt:0 - xmitte:1 * q:1yneu:3 = yalt:1 - ymitte:-2 * q:1xalt:1 = xmitte:1xmitte:-1 = xneu:-1yalt:-2 = ymitte:-2ymitte:3 = yneu:3aalt:244 = amitte:244amitte:76 = aneu:76{aalt:244 = xalt:1 * a:884 + yalt:-2 * b:320; amitte:76 = xmitte:-1 * a:884 + ymitte:3 * b:320}

Bachet

Eingabe: a, b

aalt := a

amitte := b

xalt := 1

xmitte := 0

yalt := 0

ymitte := 1

SOLANGE amitte <> 0

q := aalt div amitte

aneu := aalt mod amitte

xneu := xalt - q*xmitte

yneu := yalt - q*ymitte

xalt := xmitte

xmitte := xneu

yalt := ymitte

ymitte := yneu

aalt := amitte

amitte := aneu

Ausgabe: aalt, xalt, yalt

Page 61: Das RSA-Verfahren

61 Aufgabe

Teste die Implementierung des erweiterten Euklidischen Algorithmus..

def erweiterterEuklidischerAlgorithmus(a, b): aalt = a amitte = b xalt = 1 xmitte = 0 yalt = 0 ymitte = 1 while amitte != 0: q = aalt // amitte aneu = aalt - q * amitte xneu = xalt - xmitte * q yneu = yalt - ymitte * q xalt = xmitte xmitte = xneu yalt = ymitte ymitte = yneu aalt = amitte amitte = aneu print(amitte, '=', xmitte, '*', a, '+', ymitte, '*', b) return (aalt, xalt, yalt)

Page 62: Das RSA-Verfahren

62

Bestimmung des modularen Inversen

Mit Hilfe der Ausgaben des erweiterten euklidischen Algorithmus lässt sich das modulare Inverse bestimmen:

Beispiel 1: Gesucht wird das modulare Inverse von a = 41 bzgl. m = 192.

Python liefert:

>>> erweiterterEuklidischerAlgorithmus(41, 192)(1, 89, -19)

Umformungen:

1 = 89*41 + (-19)*192

1 - (-19)*192 = 89*41

[1 - (-19)*192]% 192 = [89*41]%192

[1 + 19*192]% 192 = [89*41]%192

1 = [89*41]%192

Ergebnis: b = 89

Page 63: Das RSA-Verfahren

63

Bestimmung des modularen Inversen

Mit Hilfe der Ausgaben des erweiterten euklidischen Algorithmus lässt sich das modulare Inverse bestimmen:

Beispiel 2: Gesucht wird das modulare Inverse von a = 17 bzgl. m = 192 .

Python liefert:

>>> erweiterterEuklidischerAlgorithmus(17, 192)(1, -79, 7)

Umformungen:

1 = (-79)*17 + 7*192

1 - 7*192 = (-79)*17

1 - 7*192 + 192*17 = (-79+192)*17

1 + 10*192 = 113*17

[1 + 10*192]%192 = [113*17]%192

1 = [113*17]%192

Ergebnis: b = 113

Page 64: Das RSA-Verfahren

64 Aufgabe

Beispiel 3: Gesucht wird das modulare Inverse von a = 7 bzgl. m = 30.

Python liefert:

>>> erweiterterEuklidischerAlgorithmus( , )

Umformungen:

Ergebnis: b =

Page 65: Das RSA-Verfahren

65

Bestimmung des modularen Inversen

Mit Hilfe der Ausgaben des erweiterten euklidischen Algorithmus lässt sich das modulare Inverse bestimmen:

def modInv(a, m): (ggt, x, y) = erweiterterEuklidischerAlgorithmus(a, m) if ggt > 1: return -1 else: if x < 0: x = x + m return x

Teste die Implementierung insbesondere für große Zahlen:

d = 49m = 1000010000100001000010000100001000010000100001000010000modInv(d, m)

Welche Konsequenzen ergeben sich hieraus für die Sicherheit des Chiffrierverfahrens mit modularer Multiplikation?

Page 66: Das RSA-Verfahren

66 Sicherheit

Sicherheit: Das "multiplikative" Chiffrierverfahren ist nicht sicher, da man aus dem öffentlichen Schlüssel mit Hilfe des erweiterten euklidischen Algorithmus den privaten Schlüssel recht schnell bestimmen kann.

Die "Unsicherheit" basiert hier also darauf, dass man ein schnelles Verfahren gefunden hat, um das modulare Inverse einer Zahl zu bestimmen.

Page 67: Das RSA-Verfahren

67 Teil 4

Verschlüsseln mit modularem Potenzieren

Page 68: Das RSA-Verfahren

68

Verschlüsseln d. modulares Rechnen

modulares Addieren

Verschlüsselung mit öffentl. Schlüssel (e, n)

x → [x * e]%n

y → [y * d]%n

modulares Multiplizieren

Entschlüsselung mit privat. Schlüssel (d, n)

Verschlüsselung mit öffentl. Schlüssel (e, n)

x → [x + e]%n

y → [y + d]%n

Entschlüsselung mit privat. Schlüssel (d, n)

Verschlüsselung mit öffentl. Schlüssel (e, n)

x → [x ** e]%n

y → [z ** d]%n

Entschlüsselung mit privat. Schlüssel (d, n)

modulares Potenzieren

Page 69: Das RSA-Verfahren

69

Verschlüsseln d. modulares Potenzieren

Verschlüsselung:

öffentlicher Schlüssel(e, m) = (13, 77)

Entschlüsselung:

privater Schlüssel(d, m) = (37, 77)

(01 ** 37) % 77 = 01(61 ** 37) % 77 = 19...(52 ** 37) % 77 = 24

01,61,...,...,...,...,52

01,19,20,05,18,09,24

' ' → 00 'A' → 01...'Z' → 26

01,19,20,05,18,09,24

A,S,T,E,R,I,X

' ' → 00 'A' → 01...'Z' → 26

A,S,T,E,R,I,X

01,19,20,05,18,09,24

(01 ** 13) % 77 = 01(19 ** 13) % 77 = 61...(24 ** 13) % 77 = 52

01,19,20,05,18,09,24

01,61,...,...,...,...,52

Codierung:

Umwandlung von Zeichen in Zahlen

Decodierung:

Umwandlung von Zahlen in Zeichen

Page 70: Das RSA-Verfahren

70 Implementierung

Beim Rechnen mit Potenzen erhält man große Zahlen:

>>> 52 ** 373105444088679819357273546406651335246066988648897330641813635072>>> 3105444088679819357273546406651335246066988648897330641813635072 % 7724

Zum schnellen modularen Potenzieren sollte man daher die folgende Funktion modpot benutzen.

def modpot(x, y, m): pot = 1 while y > 0: if y % 2 == 1: pot = (pot * x) % m y = y - 1 else: x = (x * x) % m y = y // 2 return pot

Page 71: Das RSA-Verfahren

71 Implementierung

Aufgabe:

(a) Ergänze geeignete Ausgabeanweisungen und versuche, auf diese Weise die Idee des Algorithmus zum schnellen modularen Potenzieren herauszufinden.

(b) Der Algorithmus zur modularen Potenzbildung ist eine geringfügige Erweiterung des Algorithmus zum schnellen Potenzieren. Was wird hier ergänzt? Warum führt das zu einem korrekten Ergebnis? Zur Klärung der Korrektheit musst du einen mathematischen Zusammenhang heranziehen.

def modpot(x, y, m): pot = 1 while y > 0: if y % 2 == 1: pot = (pot * x) % m y = y - 1 else: x = (x * x) % m y = y // 2 return pot

Page 72: Das RSA-Verfahren

72 Implementierung

Aufgabe:

Besorge dir eine Implementierung des Verfahrens mit modularer Multiplikation und ändere diese Implementierung in geeigneter Weise ab.

Du kannst dir alternativ hierzu auch die Datei chiffriersystemModularePotenz.txt (siehe inf-schule) herunter laden. Diese Datei enthält eine ganze Reihe von Funktionen zur Implementierung des RSA-Verfahrens.

Mit den Funktionen der Implementierung kannst jetzt interaktiv das RSA-Verfahren durchspielen. Probiere das mit selbst gewählten Daten aus.

Zur Kontrolle: Vergleiche die erzielten Ergebnisse mit denen, die CrypTool (mit passenden Einstellungen) liefert.

Page 73: Das RSA-Verfahren

73 Erzeugung der Schlüssel

Page 74: Das RSA-Verfahren

74 Erzeugung der Schlüssel

Vorbereitung:

Wähle zwei verschiedene Primzahlen p und q.

öffentlicher Schlüssel:

Berechne n = p*q.

Berechne φ(n) = (p-1)*(q-1).

Wähle eine Zahl e mit 1 < e < φ(n) , die teilerfremd zu φ(n) ist.

Der öffentliche Schlüssel ist (e, n).

("Vernichte p, q, φ(n).")

privater Schlüssel:

Berechne d so, dass [e*d]%φ(n) = 1 ist.

Der private Schlüssel ist (d, n).

Beispiel:

p = 7; q = 11

n = 77

φ(n) = 60

z. B. e = 13

(13, 77)

d = 37

(37, 77)

Page 75: Das RSA-Verfahren

75 Korrektheit des RSA-Verfahren

Korrektheit:

Die Entschlüsselung macht die Verschlüsselung rückgängig:

x → [xe]%n → [([xe]%n)d]%n = [x(e * d)]%n = [x]%n = x

Es muss hierzu folgende Schlüsseleigenschaft erfüllt sein:

[x(e * d)]%n = x für alle x < n

(e, n)

f(x, (e,n))

=

[xe]%n

(d, n)

x0, x1, x2, ...

A(lice)

Klartext

f*(y, (d,n))

=

[yd]%n

öffentl. Schlüssel von B(ob)

x0, x1, x2, ...

Klartext

y0, y1, y2, ...

Geheimtext

RSA-Verschlüsselungsfunktion

RSA- Entschlüsselungsfunktion

"HALLO ..."

Codierung

"HALLO ..."

Codierung

B(ob)

pivat. Schlüssel von B(ob)

RSA-Schlüsselerzeugung:

Wähle zwei verschiedene Primzahlen p und q.

Berechne n = pq und (n) = (p-1)(q-1).

Wähle e mit 1 < e < (n) und ggT(e,(n)) = 1.

Bestimme d mit [cd]%(n) = 1.

Page 76: Das RSA-Verfahren

76 Korrektheit des RSA-Verfahren

Beh.: [x(e * d)]%n = x für alle x < n

Begr.:

Schritt 1: Es gilt n = p*q mit zwei verschiedenen Primzahlen p und q. Wir zeigen:

[x(e*d)]%p = [x]%p und [x(e*d)]%q = [x]%q für alle Zahlen x < n

Es reicht, den Nachweise für eine der beiden Primzahlen p und q zu führen. Der Nachweis für die andere Primzahl verläuft dann völlig analog. Wir betrachten im Folgenden die Primzahl p.

Fall 1: p und x sind nicht teilerfremd.

Da p eine Primzahl ist, muss in diesem Fall p ein Teiler von x sein. Die Primzahl p muss dann auch ein Teiler der Potenz x(e*d) sein. Es folgt:

[x]%p = 0 und [x(e*d)]% p = 0

Also: [x(e*d)]%p = [x]%p

Fall 2: p und x sind teilerfremd.

Nach dem kleinen Fermatschen Satz git dann: [x(p-1)]%p = 1

Nach der Konstruktion der Schlüssel gilt: [e*d]%φ(n) = 1

Da φ(n) = (p-1)*(q-1), gibt es also eine Zahl a mit e*d = a*(p-1)*(q-1)+1.

...

Page 77: Das RSA-Verfahren

77 Korrektheit des RSA-Verfahren

... Jetzt können wir folgende Umformungen vornehmen:

[x(e*d)]%p =

[x(a*(p-1)*(q-1)+1)]%p =

[x(a*(p-1)*(q-1))*x]%p =

[x(a*(p-1)*(q-1))]%p * [x]%p =

[([x(p-1)]%p)(a*(q-1))]%p * [x]%p =

[1(a*(q-1))]%p * [x]%p =

1 * [x]%p =

[x]%p

Damit ist die Behauptung von Schritt 1 gezeigt.

Schritt 2:

Aus [x(e*d)]%p = [x]%p und [x(e*d)]%q = [x]%q

(für alle Zahlen x < n) können wir jetzt (mit dem Satz über modulare Gleichheit bzgl. Primzahlen) schließen:

[x(e*d)]%(p*q) = [x]%(p*q)

Wegen n = p*q und x < n gilt dann: [x(e*d)]%n = x

Page 78: Das RSA-Verfahren

78 Sicherheit

Sicherheit:Die Sicherheit des RSA-Verfahrens hängt davon ab, ob man aus dem öffentlichen Schlüssel (e, n) den privaten Schlüssel (d, n) (effizient) bestimmen kann.

(e, n)

f(x, (e,n))

=

[xe]%n

(?, n)

???

A(lice)

Klartext

f*(y, (d,n))

=

[yd]%n

???

Klartext

y0, y1, y2, ...

Geheimtext

RSA-Verschlüsselungsfunktion

RSA- Entschlüsselungsfunktion

???

Codierung

???

Codierung

RSA-Schlüsselerzeugung:

Wähle zwei verschiedene Primzahlen p und q.

Berechne n = pq und (n) = (p-1)(q-1).

Wähle e mit 1 < e < (n) und ggT(e,(n)) = 1.

Bestimme d mit [cd]%(n) = 1.

B(ob)

Mr(s) X

öffentl. Schlüssel von B(ob)

pivat. Schlüssel von B(ob)

Page 79: Das RSA-Verfahren

79 Aufgabe

Codierung:

Umwandlung von Zeichen in Zahlen

Verschlüsselung:

öffentlicher Schlüssel(e, m) = (19, 65)

Entschlüsselung:

privater Schlüssel(d, m) = (..., ...)

Decodierung:

Umwandlung von Zahlen in Zeichen

48, 9, 60, 38, 60, 0, 58, 47, 31, 60, 59, 59, 60, 0, 1, 31, 59, 0, 58, 1, 38, 38, 9, 60,

14

' ' → 00 'A' → 01...'Z' → 26

' ' → 00 'A' → 01...'Z' → 26

Page 80: Das RSA-Verfahren

80 Aufgabe

öffentlicher Schlüssel(e, m) = (1432765433173537777777, 1914269284601333234385791628203)

privater Schlüssel(d, m) = (..., ...)

Codierung:

Umwandlung von Zahlen in Zeichen

0703995545688427802027825362902, 0076119838972138298619729763565

' ' → 00 'A' → 01...'Z' → 26

Page 81: Das RSA-Verfahren

81

Beispiel (Aufgabe): n = 65 -> p = 5 und q = 13

Aus den beiden Primzahlen p und q kann Mr(s). X die Zahl φ(n) = (p-1) * (q-1) berechnen.

Beispiel (Aufgabe 1): p = 5 und q = 13 -> φ(n) = 48

Mr(s). X weiß zudem, dass die Zahl d modulares Inverses von e bzgl. φ(n) ist. Mit dem erweiterten euklidischen Algorithmus kann Mr(s). X diese Zahl d bestimmen.

Beispiel (Aufgabe 1): e = 19 und φ(n) = 48: [19*d]%48 = 1 -> d = 43

Mr(s). X kennt jetzt den privaten Schlüssel und kann den Geheimtext entschlüsseln.

Angriff auf das RSA-Verfahren

(e, n)

f(x, (e,n))

=

[xe]%n

(?, n)

???

A(lice)

Klartext

f*(y, (d,n))

=

[yd]%n

???

Klartext

y0, y1, y2, ...

Geheimtext

RSA-Verschlüsselungsfunktion

RSA- Entschlüsselungsfunktion

???

Codierung

???

Codierung

RSA-Schlüsselerzeugung:

Wähle zwei verschiedene Primzahlen p und q.

Berechne n = pq und (n) = (p-1)(q-1).

Wähle e mit 1 < e < (n) und ggT(e,(n)) = 1.

Bestimme d mit [cd]%(n) = 1.

B(ob)

öffentl. Schlüssel von B(ob)

pivat. Schlüssel von B(ob)

Page 82: Das RSA-Verfahren

82 Sicherheit RSA-Verfahren

(e, n)

f(x, (e,n))

=

[xe]%n

(?, n)

???

A(lice)

Klartext

f*(y, (d,n))

=

[yd]%n

???

Klartext

y0, y1, y2, ...

Geheimtext

RSA-Verschlüsselungsfunktion

RSA- Entschlüsselungsfunktion

???

Codierung

???

Codierung

RSA-Schlüsselerzeugung:

Wähle zwei verschiedene Primzahlen p und q.

Berechne n = pq und (n) = (p-1)(q-1).

Wähle e mit 1 < e < (n) und ggT(e,(n)) = 1.

Bestimme d mit [cd]%(n) = 1.

B(ob)

öffentl. Schlüssel von B(ob)

pivat. Schlüssel von B(ob)

Sicherheit:Die Sicherheit des RSA-Verfahrens hängt davon ab, ob man die Zahl n in vertretbarer Zeit in ihre Primfaktoren p und q zerlegen kann.

Bis heute gibt es keine schnellen Algorithmen, um eine Zahl in ihre Primfaktoren zu zerlegen. Das RSA-Verfahren ist bei groß gewählten Primzahlen recht sicher, da man aus dem öffentlichen Schlüssel den privaten Schlüssel bisher nicht in angemessener Zeit bestimmen kann.

Page 83: Das RSA-Verfahren

83 Teil 5

Primzahlalgorithmen

Page 84: Das RSA-Verfahren

84 Primzahltest

Zur Durchführung des RSA-Verfahrens benötigt man große Primzahlen. Man wählt heute Primzahlen, die mit mindestens 512 Bit dargestellt werden. Das sind Zahlen in der Größenordnung 2512, also Zahlen mit mehr als 150 Dezimalstellen.

Zur Bestimmung großer Primzahlen geht man wie folgt vor. Man erzeugt eine Zufallszahl im gewünschten Größenbereich und testet, ob es sich um eine Primzahl handelt. Hierzu benötigt man geeignete Primzahltests. Da es sehr viele Primzahlen im gewünschten Bereich gibt, muss man nicht in der Regel allzu viele Zahlen testen.

Page 85: Das RSA-Verfahren

85 Primzahlen

Primzahlen sind natürliche Zahlen, die nur durch 1 und sich selbst ohne Rest teilbar sind.

Beispiele: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, ...

Page 86: Das RSA-Verfahren

86 Primzahltest

Aufgabe:

Aus der Primzahleigenschaft ergibt sich direkt ein einfacher Algorithmus, mit dem man bei einer natürlichen Zahl n überprüfen kann, ob es sich um eine Primzahl handelt.

(a) Formuliere den Algorithmus in Struktogrammform.

(b) Implementiere und teste den Algorithmus.

(c) Entwickle Möglichkeiten zur Verbesserungen des einfachen Algorithmus.

Page 87: Das RSA-Verfahren

87 Ein einfaches Testverfahren

def primzahl(n): if n <= 2: if n < 2: prim = False else: prim = True else: if n % 2 == 0: faktorgefunden = True else: faktorgefunden = False t = 3 while t*t <= n and not faktorgefunden: if n % t == 0: faktorgefunden = True else: t = t + 2 prim = not faktorgefunden return prim

Page 88: Das RSA-Verfahren

88 Ein einfaches Testverfahren

primzahlen = [11,101,1009,10007,100003,1000003,10000019,100000007,1000000007,10000000019,100000000003,1000000000039,10000000000037,100000000000031,1000000000000037,10000000000000061,100000000000000003,1000000000000000003,10000000000000000051,100000000000000000039,1000000000000000000117,...]

def primzahl(n): ...

from time import *

for p in primzahlen: t1 = clock() ergebnis = primzahl(p) t2 = clock() t = t2 - t1 print("Primzahl: ", p, "Rechenzeit: ", t)

Page 89: Das RSA-Verfahren

89 Laufzeitverhalten

>>> Primzahl: 11 Rechenzeit: 5.86666741164e-06Primzahl: 101 Rechenzeit: 8.3809534452e-06Primzahl: 1009 Rechenzeit: 1.50857162014e-05Primzahl: 10007 Rechenzeit: 3.54793695847e-05Primzahl: 100003 Rechenzeit: 0.000101968266917Primzahl: 1000003 Rechenzeit: 0.000324342898329Primzahl: 10000019 Rechenzeit: 0.00104817791088Primzahl: 100000007 Rechenzeit: 0.00332500359683Primzahl: 1000000007 Rechenzeit: 0.0105655886432Primzahl: 10000000019 Rechenzeit: 0.0407208178693Primzahl: 100000000003 Rechenzeit: 0.140259725747Primzahl: 1000000000039 Rechenzeit: 0.447675891768Primzahl: 10000000000037 Rechenzeit: 1.41919042783Primzahl: 100000000000031 Rechenzeit: 4.55093566361Primzahl: 1000000000000037 Rechenzeit: 14.3208156344Primzahl: 10000000000000061 Rechenzeit: 45.2250185429Primzahl: 100000000000000003 Rechenzeit: 144.197546336...

Aufgabe:

Schätze ab, wie lange eine Überprüfung einer 150-stelligen Primzahl in etwa dauert.

Page 90: Das RSA-Verfahren

90 Probabilistische Testverfahren

In der Praxis benutzt man heute oft sogenannte probabilistische Testverfahren, da sie sehr effizient arbeiten. Probabilistischen Testverfahren funktionieren nach dem folgenden Prinzip: Bei Übergabe einer natürlichen Zahl n erhält man als Rückgabe entweder "n ist keine Primzahl" oder "n ist wahrscheinlich eine Primzahl". Diese Testverfahren liefern also keine absolute Gewissheit, wenn sie das Ergebnis "n ist wahrscheinlich eine Primzahl" produzieren. Die übergebene Zahl n kann mit einer bestimmten Wahrscheinlichkeit auch keine Primzahl sein. Allerdings ist diese Wahrscheinlichkeit sehr gering, so dass man die Unsicherheit oft in Kauf nimmt.

Eines dieser probabilistischer Testverfahren ist das Miller-Rabin-Verfahren, das im Folgenden getestet werden soll. Beachte, dass die Wiederholungszahl 20 (s.u.) die Fehlerwahrscheinlichkeit beeinflusst. Setzt man diese Wiederholungszahl auf einen größeren Wert, so nimmt die Fehlerwahrscheinlichkeit ab.

Page 91: Das RSA-Verfahren

91 Miller-Rabin-Test

import random def miller_rabin_pass(a, n): d = n - 1 s = 0 while d % 2 == 0: d = d >> 1 s = s + 1 a_to_power = pow(a, d, n) if a_to_power == 1: return True for i in range(s-1): if a_to_power == n - 1: return True a_to_power = (a_to_power * a_to_power) % n return a_to_power == n - 1def miller_rabin_test(n): for repeat in range(20): a = 0 while a == 0: a = random.randrange(n) if not miller_rabin_pass(a, n): return False return True

Page 92: Das RSA-Verfahren

92 Laufzeitverhalten>>> Primzahl: 11 Rechenzeit: 0.000118730173807Primzahl: 101 Rechenzeit: 0.000144990494602Primzahl: 1009 Rechenzeit: 0.000217904789575Primzahl: 10007 Rechenzeit: 0.000181866689761Primzahl: 100003 Rechenzeit: 0.000280761940414Primzahl: 1000003 Rechenzeit: 0.00031400638908Primzahl: 10000019 Rechenzeit: 0.000371276237622Primzahl: 100000007 Rechenzeit: 0.000415974655997Primzahl: 1000000007 Rechenzeit: 0.000454527041845Primzahl: 10000000019 Rechenzeit: 0.000569346104044Primzahl: 100000000003 Rechenzeit: 0.000617117538682Primzahl: 1000000000039 Rechenzeit: 0.000658184210563Primzahl: 10000000000037 Rechenzeit: 0.000720482631172Primzahl: 100000000000031 Rechenzeit: 0.000901511225589Primzahl: 1000000000000037 Rechenzeit: 0.000982527108892Primzahl: 10000000000000061 Rechenzeit: 0.00114316204993Primzahl: 100000000000000003 Rechenzeit: 0.00111746045936Primzahl: 1000000000000000003 Rechenzeit: 0.0011973588822Primzahl: 10000000000000000051 Rechenzeit: 0.00138956208121Primzahl: 100000000000000000039 Rechenzeit: 0.00151862876427Primzahl: 1000000000000000000117 Rechenzeit: 0.00166445735422Primzahl: 10000000000000000000009 Rechenzeit: 0.00163987322411Primzahl: 100000000000000000000117 Rechenzeit: 0.0019804192991Primzahl: 1000000000000000000000007 Rechenzeit: 0.0020670224847Primzahl: 10000000000000000000000013 Rechenzeit: 0.00199578438042Primzahl: 100000000000000000000000067 Rechenzeit: 0.00229358759284Primzahl: 1000000000000000000000000103 Rechenzeit: 0.00245701618502Primzahl: 10000000000000000000000000331 Rechenzeit: 0.00275649558813Primzahl: 100000000000000000000000000319 Rechenzeit: 0.003038374989

Page 93: Das RSA-Verfahren

93 Primfaktorzerlegung

2 2 5* * 13*

260

Eine der wichtigsten Eigenschaften von Primzahlen ist, dass sie als Bausteine der natürlichen Zahlen angesehen werden können.

Satz: Jede natürliche Zahl lässt sich als Produkt von Primzahlen schreiben. Diese Darstellung ist bis auf die Reihenfolge der Faktoren eindeutig.

Beispiel: 260 = 2*2*5*13 = 22*5*13

Man nennt die Primzahlen, die in einer Produktdarstellung einer gegebenen Zahl vorkommen, auch Primfaktoren der Zahl.

Das Faktorisierungsproblem besteht darin, eine vorgegebene Zahl in ein Produkt aus Primfaktoren zu zerlegen.

Page 94: Das RSA-Verfahren

94 Aufgabe

(a) Bei kleineren Zahlen kann man eine Primfaktorzerlegung oft direkt angeben. Bestimme eine Primfaktorzerlegung von n = 48 und n = 100.

(b) Bei größeren Zahlen sollte man systematisch vorgehen, um die Primfaktoren zu bestimmen. Bestimme eine Primfaktorzerlegung von n = 221 und n = 585.

(c) Entwickle zunächst einen Algorithmus zur Primfaktorzerlegung. Beschreibe in einem ersten Schritt in Worten das Verfahren, das du zur Primfaktorzerlegung von Zahlen benutzt. Beschreibe das Verfahren anschließend mit einem Struktogramm. Entwickle dann ein Programm zur Primfaktordarstellung. Hinweis: In Python bietet es sich an, eine Funktion primfaktoren(n) zu erstellen, die die Liste der Primfaktoren zurückgibt.

Page 95: Das RSA-Verfahren

95

Ein einfaches Faktorisierungsverfahren

Aufgabe:Bestimme mit (einer geeigneten Implementierung) der Funktion primfaktoren(n) die Primfaktorzerlegung der beiden Zahlen 484639526894037745950720 und 565765434324543216797351. Was stellst du fest? Stelle eine Vermutung auf, warum es hier zu einem unterschiedlichen Laufzeitverhalten kommt.

# Übergabe: n = 51

# Initialisierung

faktoren = [] {faktoren -> []}

z = n {z -> 51}

# Probedivisionen

z % 2 -> 1

z % 3 -> 0

# Aktualisierung

p = z {p -> 3}

faktoren = faktoren + [p] {faktoren -> [3]}

z = z // p {z -> 17}

# Probedivisionen

z % 2 -> 1

z % 3 -> 2

z % 4 -> 1

z % 5 -> 2

# Aktualisierung

p = z {p -> 17}

faktoren = faktoren + [p] {faktoren -> [3, 17]}

z = z // p {z -> 1}

# Rückgabe: [3, 17]

ALGORITHMUS primfaktoren(n):

initialisiere die Liste faktoren: faktoren = []

initialisiere die Hilfsvariable z: z = n

SOLANGE z > 1:

bestimme den kleinsten Primfaktor p von z mit Probedivisionen

füge p in die Liste faktoren ein

z = z // p

Rückgabe: faktoren

Page 96: Das RSA-Verfahren

96 Laufzeitmessungen

Hinweis:Um Gesetzmäßigkeiten herauszufinden, sollte man systematisch vorgehen.

Aufgabe:Führe die Messungen durch. Kannst du anhand der Zahlen erste Zusammenhänge erkennen? Kannst du Prognosen erstellen, wie lange man wohl bis zum nächsten Ergebnis warten muss?

testzahlen = [

11,

101,

1009,

10007,

100003,

1000003,

10000019,

100000007,

1000000007,

10000000019,

100000000003,

1000000000039,

10000000000037,

100000000000031,

1000000000000037,

10000000000000061,

100000000000000003,

1000000000000000003,

10000000000000000051,

100000000000000000039,

...]

from faktorisierung import primfaktoren

from time import *

testzahlen = [...]

for z in testzahlen:

t1 = clock()

ergebnis = primfaktoren(z)

t2 = clock()

t = t2 - t1

print("Zahl: ", z)

print("Primfaktoren:", ergebnis)

print("Rechenzeit: ", t)

print()

Page 97: Das RSA-Verfahren

97 Zusammenhänge und Prognosen

Gesetzmäßigkeit:Wenn man die Anzahl der Stellen der Ausgangszahl um 2 erhöht, dann erhöht sich die Laufzeit um den Faktor 10. Jede zusätzliche Stelle bei der Ausgangszahl führt also dazu, dass die Laufzeit mit dem Faktor √10 multipliziert wird.

Es handelt sich hier um ein exponentielles Wachstumsverhalten, das man mathematisch mit einer Exponentialfunktion beschreiben kann: Wenn k die Anzahl der Stellen der Ausgangszahl angibt, dann erhält man eine Laufzeit vom Typ L(k) = c*(√10)k mit einer Konstanten c.

Prognose:Wenn die Zahl 100 Stellen haben soll, also 88 Stellen mehr als eine 12-stellige Zahl, so benötigt man nach der gefundenen Gesetzmäßigkeit 1044-mal so lange wie bei der 12-stelligen Zahl - also etwa 1044 Sekunden.

...

Zahl: 1000000000039

Primfaktoren: [1000000000039]

Rechenzeit: 0.906267137304

Zahl: 10000000000037

Primfaktoren: [10000000000037]

Rechenzeit: 2.88270213114

Zahl: 100000000000031

Primfaktoren: [100000000000031]

Rechenzeit: 9.1279123464

Zahl: 1000000000000037

Primfaktoren: [1000000000000037]

Rechenzeit: 28.5701070946

Zahl: 10000000000000061

Primfaktoren: [10000000000000061]

Rechenzeit: 91.2736900919

...

Page 98: Das RSA-Verfahren

98 Fazit

Algorithmen spielen bei der Entwicklung von Chiffriersystemen eine große Rolle.

Im Fall des RSA-Verfahrens benötigt man einerseits gute Algorithmen, um das Verfahren überhaupt effizient durchführen zu können (z. B. schnell ein modulares Inverses bestimmen; schnell eine modulare Potenz bestimmen).

Andererseits ist das Verfahren so angelegt, dass bestimmte Operation mit den bisher bekannten Algorithmen mit vertretbarem Rechenaufwand nicht durchgeführt werden können.

Page 99: Das RSA-Verfahren

99 Literaturhinweise

Folgende Materialien wurden hier benutzt:

H. Witten, R.-H. Schulz: RSA & Co. in der Schule, Teil1. LOG IN 140 S. 45 ff

H. Witten, R.-H. Schulz: RSA & Co. in der Schule, Teil2. LOG IN 143 S. 50 ff

K. Merkert: http://www.hsg-kl.de/faecher/inf/krypto/rsa/index.php

http://www.cryptool.org/download/RSA/RSA-Flash-de/player.html