Das RSAVerfahren Klaus Becker 2018 2 Das RSAVerfahren

Das RSA-Verfahren Klaus Becker 2018

2 Das RSA-Verfahren An: b@ob. de Von: a@lice. de Hallo Bob!

3 Teil 1 Experimente mit Cryp. Tool

4 Experimente mit Cryp. Tool Einen ersten Eindruck vom RSA-Verfahren kann man sich mit dem Software-Werkzeug Cryp. Tool verschaffen. Mit den Menüpunkten [Einzelverfahren][RSA-Kryptosystem][RSADemo. . . ] kommst du in Bereich, in dem das RSA-Verfahren durchgespielt werden kann.

5 Experimente mit Cryp. Tool Gib zunächst zwei verschiedene Primzahlen in die dafür vorgesehenen Felder ein. Mit [Parameter aktualisieren] werden dann die beiden Schlüssel erzeugt. Zusätzlich gibt es eine Warnung, dass etwas mit der Zeichencodierung noch nicht stimmt.

6 Experimente mit Cryp. Tool 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 in der Abbildung (beachte das Leerzeichen im Alphabet).

7 Experimente mit Cryp. Tool Jetzt kannst du Texte (mit Zeichen aus dem voreingestellten Alphabet) verschlüsseln und die Verschlüsselung auch wieder entschlüsseln. Aufgabe Probiere das selbst mit verschiedenen Parametern und Eingaben aus.

8 Experimente mit Cryp. Tool Jetzt kannst du Texte (mit Zeichen aus dem voreingestellten Alphabet) verschlüsseln und die Verschlüsselung auch wieder entschlüsseln. Aufgabe Probiere das selbst mit verschiedenen Parametern und Eingaben aus.

9 Erkenntnisse Experimente mit Cryp. Tool lassen direkt erkennen, dass das RSAVerfahren auf Berechnungen mit Zahlen beruht. Die Experimente führen aber noch nicht dazu, dass man versteht, wie man rechnet und warum man so rechnet. Hierzu sind vertiefende Untersuchungen erforderlich.

10 Vorbemerkung Das RSA-Verfahren basiert auf modularem Rechnen. Um die Details des RSA-Verfahrens zu verstehen, muss man modulares Rechnen verstehen und einige zahlentheoretische Zusammenhänge kennen. Im Unterricht kann man die mathematischen Grundlagen vorab erarbeiten, oder – wie hier – bei der Entwicklung des RSA-Verfahres je nach Bedarf bereitstellen.

11 Teil 2 Verschlüsselung mit modularer Addition

12 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 schrittweise zu den zahlenbasierten Verfahren gelangen können.

Den Anfang macht Caesar 13 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 A B C Quelltext: SALVEASTERIX Schlüssel: D Geheimtext: VDOYHDVWHULA

14 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 → 00 B → 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 + 23) % 26 = 00 (21 + 23) % 26 = 18. . . (00 + 23) % 26 = 23 03, 21, 22, 07, 20, 11, 00 A → 00 B → 01. . . Z → 25 00, 18, 19, 04, 17, 08, 23 03, 21, 22, 07, 20, 11, 00 00, 18, 19, 04, 17, 08, 23 A, S, T, E, R, I, X

15 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 + 18) % 27 = 14 (10 + 18) % 27 = 01. . . (22 + 18) % 27 = 13 23, 10, 12, 17, …, 00, 24, 22 ' ' → 00 'A' → 01. . . 'Z' → 26 23, 10, 12, 17, …, 00, 24, 22 14, 01, 03, 08, 00, 18, 15, 13 N, A, C, H, , R, O, M

16 Caesar-Variation: beliebige Modulzahl Codierung: Umwandlung von Zeichen in Zahlen Verschlüsselung: Verarbeitung von Zahlen (e, n) = (18, 30) Entschlüsselung: Verarbeitung von Zahlen (d, n) = (12, 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, 05, 19 (04 + 18) % 30 = 22 (01 + 18) % 30 = 19. . . (19 + 18) % 30 = 07 04, 01, 00, 09, 19, 20, 05, 19 (22 + 12) % 30 = 04 (19 + 12) % 30 = 01. . . (07 + 12) % 30 = 19 22, 19, 18, 27, …, 08, 18, 23, 07 ' ' → 00 'A' → 01. . . 'Z' → 26 22, 19, 18, 27, …, 08, 18, 23, 07 04, 01, 00, 09, 19, 20, 00, 05, 19 D, A, , I, S, T, , E, S

17 Caesar-Variation: Zeichenblöcke Codierung: Umwandlung von Zeichen in Zahlen Verschlüsselung: Verarbeitung von Zahlen (e, n) = (112233, 321321) Entschlüsselung: Verarbeitung von Zahlen (d, n) = (209088, 321321) Decodierung: Umwandlung von Zahlen in Zeichen ' ' → 00 'A' → 01. . . 'Z' → 26 HAL, LO 080112, 121500 (80112 + 112233) % 321321 = 192345 (121500 + 112233) % 321321 = 233733 080112, 121500 (192345 + 209088) % 321321 = 080112 (233733 + 209088) % 321321 = 121500 192345, … ' ' → 00 'A' → 01. . . 'Z' → 26 192345, … 080112, 121500 HAL, LO

Verfahren mit modularer Addition 18 Schlüsselerzeugung: A(lice) öffentl. Schlüssel von B(ob) (e, n) Wähle n größer als die maximale Codezahl. Wähle e mit e <n. Bestimme d mit e+d=n. B(ob) privat. Schlüssel von B(ob) (d, n) "HALLO. . . " Codierung f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [x+e]%n f*(y, (d, n)) y 0, y 1, y 2, . . . Geheimtext Verschlüsselungsfunktion Codierung = [y+d]%n x 0, x 1, x 2, . . . Klartext Entschlüsselungsfunktion 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 '

19 Verfahren mit modularer Addition Schlüsselerzeugung: A(lice) öffentl. Schlüssel von B(ob) (e, n) Wähle n größer als die maximale Codezahl. Wähle e mit e <n. B(ob) privat. Schlüssel von B(ob) (d, n) Bestimme d mit e+d=n. "HALLO. . . " Codierung f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [x+e]%n f*(y, (d, n)) Die Codierung ordnet jeder Texteinheit eine natürliche Zahl zu. Die Zuordnung muss eindeutig sein, so dass eine Decodierung möglich ist. Codierung des Alphabets: ' ' -> 00 'A' -> 01. . . 'Z' -> 26 = y 0, y 1, y 2, . . . x 0, x 1, x 2, . . . [y+d]%n Geheimtext Klartext Entschlüsselungsfunktion Verschlüsselungsfunktion Schritt 2: Wahl der Codierung von Zeichenblöcken (Basissystem): Codierung von Zeichenblöcken (badisch): ' ' ' -> 0000 ' -> 000 ' A' -> 0001 ' A' -> 001 ' B' -> 0002 ' B' -> 002 . . . ' Z' -> 0026 ' Z' -> 026 'A ' -> 0100 'A ' -> 027 'AA' -> 0101 'AA' -> 028 . . . 'ZZ' -> 2626 'ZZ' -> 728

20 Verfahren mit modularer Addition Schlüsselerzeugung: A(lice) öffentl. Schlüssel von B(ob) (e, n) Wähle n größer als die maximale Codezahl. Wähle e mit e <n. Bestimme d mit e+d=n. B(ob) privat. Schlüssel von B(ob) (d, n) "HALLO. . . " Codierung f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [x+e]%n f*(y, (d, n)) y 0, y 1, y 2, . . . Geheimtext Verschlüsselungsfunktion Codierung = [y+d]%n x 0, x 1, x 2, . . . Klartext Entschlüsselungsfunktion 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=n 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.

Verfahren mit modularer Addition 21 Schlüsselerzeugung: A(lice) öffentl. Schlüssel von B(ob) (e, n) Wähle n größer als die maximale Codezahl. Wähle e mit e <n. Bestimme d mit e+d=n. B(ob) privat. Schlüssel von B(ob) (d, n) "HALLO. . . " Codierung f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [x+e]%n Verschlüsselungsfunktion f*(y, (d, n)) y 0, y 1, y 2, . . . Geheimtext Codierung = [y+d]%n x 0, x 1, x 2, . . . Klartext Entschlüsselungsfunktion Schritt 5: Verschlüsselung codierter Texte Zur Verschlüsselung eine Codezahl x benötigt man den öffentlichen Schlüssel (e, n). 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

22 Übung Benutze unsere Standardcodierung mit Blocklänge 2. Erzeuge zunächst einen öffentlichen Schlüssel (wie z. B. (567, 2911)) und gib ihn deinem Nachbarn. Achte darauf, dass die Modulzahl groß genug ist. Dein Nachbar soll jetzt mit diesem Schlüssel eine selbst gewählte (nicht zu lange) Nachricht mit dem oben beschriebenen Verfahren mit modularer Addition verschlüsseln und sie an dich weitergeben. Entschlüssele diese Nachricht.

Durchführung mit Python 23 Aufgabe: Eine Implementierung nutzen Lade die Datei chiffriersystem. Modulares. Addieren. py (siehe inf-schule) herunter. Diese Datei enthält eine ganze Reihe von Funktionen, die Teilaufgaben beim Verfahren mit modularer Addition übernehmen. Analysiere zunächst, was die einzelnen Funktionen leisten. Das geht am einfachsten, indem du die integrierten Testfälle betrachtest. def codierung. Zeichen(zeichen, abc): """ >>> codierung. Zeichen('A', ' ABCDEFGHIJKLMNOPQRSTUVWXYZ') 1 """ return abc. index(zeichen) def decodierung. Zahl(zahl, abc): """ >>> decodierung. Zahl(1, ' ABCDEFGHIJKLMNOPQRSTUVWXYZ') 'A' """ return abc[zahl]. . .

24 Durchführung mit Python Aufgabe : Eine Implementierung nutzen Mit den Funktionen kannst du jetzt das Verfahren mit modularer Addition durchspielen. Führe selbst weitere Tests durch. from chiffriersystem. Modulare. Addition import * # Vorgaben abc = ' ABCDEFGHIJKLMNOPQRSTUVWXYZ' block = 2 oeffentlicher. Schluessel = (2102, 3000) privater. Schluessel = (898, 3000) # Verarbeitung quelltext = 'COSINUS' quellcode = codierung(quelltext, block, abc) geheimcode = verschluesselung(quellcode, oeffentlicher. Schluessel) entschluesseltercode = verschluesselung(geheimcode, privater. Schluessel) entschluesseltertext = decodierung(entschluesseltercode, block, abc) # Ausgaben print('Quelltext: ') print(quelltext) print('Quellcode: ') print(quellcode) print('Geheimcode: ') print(geheimcode) print('entschlüsselter Code: ') print(entschluesseltercode) print('entschlüsselter Text: ') print(entschluesseltertext)

Korrektheit 25 Schlüsselerzeugung: A(lice) öffentl. Schlüssel von B(ob) (e, n) B(ob) Wähle n größer als die maximale Codezahl. privat. Schlüssel von B(ob) Wähle e mit e <n. (d, n) Bestimme d mit e+d=n. "HALLO. . . " Codierung f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [x+e]%n f*(y, (d, n)) Codierung = y 0, y 1, y 2, . . . [y+d]%n Geheimtext x 0, x 1, x 2, . . . Klartext Entschlüsselungsfunktion Verschlüsselungsfunktion 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]%n = x […+d]%n x […+e]%n

Sicherheit 26 Schlüsselerzeugung: A(lice) öffentl. Schlüssel von B(ob) (e, n) Wähle n größer als die maximale Codezahl. Wähle e mit e <n. Bestimme d mit e+d=n. B(ob) privat. Schlüssel von B(ob) (d, n) "HALLO. . . " Codierung f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [x+e]%n Verschlüsselungsfunktion f*(y, (d, n)) y 0, y 1, y 2, . . . Geheimtext Codierung = [y+d]%n x 0, x 1, x 2, . . . Klartext Entschlüsselungsfunktion Sicherheit: Das additive Chiffrierverfahren ist nicht sicher, da man aus dem öffentlichen Schlüssel sofort den privaten Schlüssel bestimmen kann.

27 Teil 3 Exkurs - Modulares Rechnen

28 Uhrenaddition Modulare Addition kennt man aus dem täglichen Leben. Aufgabe: Ergänze die in der Tabelle fehlenden Angaben zur Uhrzeit (in MOZ / Moskauer Zeit). Wie rechnet man mit Uhrzeiten? Wie kann man z. B. direkt aus 17 und 149 zum Ergebnis 22 gelangen?

29 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

30 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 =. . .

31 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. Aufgabe: Erstelle selbst eine Verknüpfungstafel für die Addition modulo n = 5. Rechengesetz (Modulare Gleichheit bei der Addition): Aus [a 1]%n = [b 1]%n und [a 2]%n = [b 2]%n folgt [a 1+a 2]%n = [b 1+b 2]%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.

32 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. Aufgabe: Erstelle selbst eine Verknüpfungstafel für die Multiplikation modulo n = 8. Rechengesetz (Modulare Gleichheit bei der Multiplikation): Aus [a 1]%n = [b 1]%n und [a 2]%n = [b 2]%n folgt [a 1*a 2]%n = [b 1*b 2]%n. Das erste Rechengesetz besagt, dass Zahlen, die modulo n gleich sind, auch zu gleichen Multiplikationsergebnissen modulo n führen. Rechengesetz (Multiplikation und iterierte Modulberechnung): [a*b]%n = [[a]%n * [b]%n]%n Das zweite Rechengesetz erlaubt es, bei der Multiplikation modulo n zuerst die Faktoren zu verkleinern und dann erst die Multiplikation durchzuführen.

33 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. Was stellst du fest? (c) Welche Vorteile ergeben sich bei großen Zahlen, wenn man [a x]%n wie folgt berechnet: [(. . . ([([a]%n)*a]%n). . . )*a]%n ? Rechengesetz (Modulare Gleichheit bei der Potenzbildung): Aus [a]%n = [b]%n folgt [ak]%n = [bk]%n. Das erste Rechengesetz besagt, dass Zahlen, die modulo n gleich sind, auch zu gleichen Potenzierungsergebnissen modulo n führen. Rechengesetz (Potenzbildung und iterierte Potenzbildung): [ak]%n = [[a%n]k]%n = [(. . . ([([a]%n)*a]%n). . . )*a]%n Das zweite Rechengesetz erlaubt es, bei der Potenzbildung modulo n zuerst die Basis zu verkleinern und dann erst die Multiplikation durchzuführen.

Aufgaben 34 Bestätige die Rechengesetze für modulare Addition und Multiplikation anhand von Beispielen. Du kannst Python als Taschenrechner benutzen. >>> >>> >>> 2 >>> 5 >>>. . . n = 14 a 1 = 16 b 1 = 19 a 2 = 44 b 2 = 75 a 1%n a 2%n b 1%n b 2%n (a 1+b 1)%n (a 1%n+b 1%n)%n

35 Teil 4 Verschlüsselung mit modularer Multiplikation

36 Vorbemerkung Statt modularer Addition verwenden wir jetzt modulare Multiplikation als Grundlage eines Verschlüsselungsverfahres. Dieses Verfahen kann ebenfalls als Vorstufe zum RSA-Verfahren angesehen werden.

statt Addition jetzt Multiplikation 37 A(lice) B(ob) öffentl. Schlüssel von B(ob) privat. Schlüssel von B(ob) (e, n) (d, n) "HALLO. . . " Codierung f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [x+e]%n f*(y, (d, n)) y 0, y 1, y 2, . . . Geheimtext Codierung = x 0, x 1, x 2, . . . [y+d]%n Klartext Entschlüsselungsfunktion Verschlüsselungsfunktion A(lice) B(ob) öffentl. Schlüssel von B(ob) privat. Schlüssel von B(ob) (e, n) (d, n) "HALLO. . . " Codierung f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [x*e]%n Verschlüsselungsfunktion f*(y, (d, n)) y 0, y 1, y 2, . . . Geheimtext Codierung = [y*d]%n Entschlüsselungsfunktion x 0, x 1, x 2, . . . Klartext

38 Codierung: Umwandlung von Zeichen in Zahlen Verschlüsselung: Verarbeitung von Zahlen (e, n) = (7, 30) Entschlüsselung: Verarbeitung von Zahlen (d, n) = (23, 30) Codierung: Umwandlung von Zeichen in Zahlen 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 + 23) % 30 = 14 (16 + 23) % 30 = 09. . . (26 + 23) % 30 = 19 21, 16, 01, 07, 19, 22, 26 ' ' → 00 'A' → 01. . . 'Z' → 26 14, 09, 24, 00, 12, 15, 19 21, 16, 01, 07, 19, 22, 26 14, 09, 24, 00, 12, 15, 19 N, I, X, , L, O, S

39 . . . jetzt Multiplikation! Codierung: Umwandlung von Zeichen in Zahlen Verschlüsselung: Verarbeitung von Zahlen (e, n) = (7, 30) Entschlüsselung: Verarbeitung von Zahlen (d, n) = (…, 30) Codierung: Umwandlung von Zeichen in Zahlen ' ' → 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 * d) % 30 = 14 (03 * d) % 30 = 09. . . (13 * d) % 30 = 19 08, 03, 18, 00, 24, 15, 13 ' ' → 00 'A' → 01. . . 'Z' → 26 14, 09, 24, 00, 12, 15, 19 08, 03, 18, 00, 24, 15, 13 14, 09, 24, 00, 12, 15, 19 N, I, X, , L, O, S

40 . . . benutze Multiplikation! Aufgabe: (a) Ermittle (durch Ausprobieren) die Zahl d, mit der man die Entschlüsselung hier völlig analog zur Verschlüsselung durchführen kann. (b) Welcher Zusammenhang besteht zwischen der Zahl e zum Verschlüsseln (hier 7), der Zahl d (hier. . . ) zum Entschlüsseln und der Modulzahl n (hier 30)? Verschlüsselung: Verarbeitung von Zahlen (d, n) = (…, 30) Codierung: Umwandlung von Zeichen in Zahlen (08 * d) % 30 = 14 (03 * d) % 30 = 09. . . (13 * d) % 30 = 19 08, 03, 18, 00, 24, 15, 13 ' ' → 00 'A' → 01. . . 'Z' → 26 14, 09, 24, 00, 12, 15, 19 N, I, X, , L, O, S

41 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. Beispiel: [7*13]%30 = 1 Aufgabe: (a) Betrachte den Fall n = 5. Bestimme zu a = 1, 2, 3, 4 jeweils das modulare Inverse bzgl. n. (b) Betrachte den Fall n = 8. Bestimme zu a = 1, …, 7 jeweils das modulare Inverse bzgl. n. Klappt das immer? Für welche Zahlen gibt es ein modulares Inverses? (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? Bestimme diese Inversen.

42 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 gg. T(a, n) = 1 gilt.

43 Bestimmung des modularen Inversen Ein naheliegender Ansatz besteht darin, der Reihe nach alle Zahlen zu testen, 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 Aufgabe: Formuliere einen Algorithmus zur Bestimmung des modularen Inversen nach der beschriebenen Testmethode.

Bestimmung des modularen Inversen 44 def mod. Inv(e, n): """ >>> mod. Inv(16, 33) 31 >>> mod. Inv(16, 32) -1 """ … return … if __name__ == '__main__': from doctest import testmod(verbose=False) Aufgabe: Implementiere eine Funktion zur Bestimmung des modularen Inversen. Teste die Funktion mit selbst gewählten Beispielen. Nutze die Funktion mod. Inv, um z. B. das modulare Inverse von 781 bzg. 2828 zu bestimmen.

Verfahren und seine Korrektheit 45 Schlüsselerzeugung: A(lice) öffentl. Schlüssel von B(ob) (e, n) B(ob) Wähle n größer als die maximale Codezahl. privat. Schlüssel von B(ob) Wähle e mit e <n. (d, n) Bestimme d mit [e*d]%n = 1. "HALLO. . . " Codierung f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [x*e]%n f*(y, (d, n)) = y 0, y 1, y 2, . . . x 0, x 1, x 2, . . . [y*d]%n Geheimtext Verschlüsselungsfunktion Codierung Entschlüsselungsfunktion 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. Klartext

46 Durchführung mit Python Aufgabe: Eine Implementierung testen Erstelle die Datei chiffriersystem. Modulares. Multiplizieren. py selbst oder lade sie herunter (siehe inf-schule). Teste das Chiffriersystem mit selbst gewählten Beispielen. Dokumentiere die Ergebnisse. from chiffriersystem. Modulare. Multiplikation import * # Vorgaben abc = ' ABCDEFGHIJKLMNOPQRSTUVWXYZ' block = 1 oeffentlicher. Schluessel = (7, 30) privater. Schluessel = (13, 30) # Verarbeitung quelltext = 'ASTERIX' quellcode = codierung(quelltext, block, abc) geheimcode = verschluesselung(quellcode, oeffentlicher. Schluessel) entschluesseltercode = verschluesselung(geheimcode, privater. Schluessel) entschluesseltertext = decodierung(entschluesseltercode, block, abc) # Ausgaben print('Quelltext: ') print(quelltext) print('Quellcode: ') print(quellcode) print('Geheimcode: ') print(geheimcode) print('entschlüsselter Code: ') print(entschluesseltercode) print('entschlüsselter Text: ') print(entschluesseltertext)

47 Geheimcodes knacken Codierung: Alphabet: siehe rechts Blocklänge: 1 ' ' → 00 'A' → 01. . . 'Z' → 26 Verschlüsselung: öffentlicher Schlüssel (e, n) = (16, 33) Geheimcode: 24, 12, 15, 29, 23, 12, 13 Entschlüsselung: privater Schlüssel (d, n) = (. . . , . . . ) Klartext: …

48 Geheimcodes knacken Codierung: Alphabet: siehe rechts Blocklänge: 2 ' ' → 00 'A' → 01. . . 'Z' → 26 Verschlüsselung: öffentlicher Schlüssel (e, n) = (781, 2828) Geheimcode: 1893, 236, 1973, 1292, 1077, 2028, 2431 Entschlüsselung: privater Schlüssel (d, n) = (. . . , . . . ) Klartext: …

49 Geheimcodes knacken Codierung: Alphabet: siehe rechts Blocklänge: 20 ' ' → 00 'A' → 01. . . 'Z' → 26 Verschlüsselung: öffentlicher Schlüssel (e, n) = (207549245303773792454905681132283020943416981339624717, 100001000010000100001000010000) Geheimcode: 26415358493207577210000980001356758754797930366 0380000 Entschlüsselung: privater Schlüssel (d, n) = (. . . , . . . ) Klartext: …

50 Geheimcodes knacken Codierung: Alphabet: siehe rechts Blocklänge: 20 ' ' → 00 'A' → 01. . . 'Z' → 26 Verschlüsselung: öffentlicher Schlüssel (e, n) = (49, 100001000010000100001000010000) Geheimcode: 941368653820345490180020336509200000 Entschlüsselung: privater Schlüssel (d, n) = (. . . , . . . ) Klartext: …

51 Bestimmung des modularen Inversen Schwierigkeit: Bei großen Zahlen muss manchmal lange auf ein Ergebnis warten. def mod. Inv(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 >>> mod. Inv(49, 100001000010000100001000010000). . . Wie lange muss man hier wohl auf das Ergebnis warten?

52 Bestimmung des modularen Inversen def mod. Inv. Mit. Ausgaben(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 >>> mod. Inv. Mit. Ausgaben(49, 100001000010000100001000010000) Anzahl der Versuche: 10000000 für 10 Millionen Überprüfungen Anzahl der Versuche: 20000000 benötigt man ca. 1 Sekunde! Anzahl der Versuche: 30000000. . . Aufgabe: Erstelle eine „Hochrechnung“ für die Wartezeit.

53 Verwendbarkeit eines Algorithmus Verwendbarkeit: Für größere Zahlen ist der naive Algorithmus zur Berechnung des modularen Inversen unbrauchbar. Beispiel: d = 49 n = 100001000010000100001000010000 mod. Inv(d, n) Um 10 000 (= 107) Zahlen durchzuprobieren, benötigt ein Rechner derzeit mehr als 1 s. Da das erwartete Ergebnis 775517959261225265313877628572204089387832653836742449 eine 54 -stellige Zahl ist, wird der Rechner eine Zeit benötigen, die in der Größenordnung von 1047 s 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.

54 Gesucht: Ein besserer Algorithmus Ein besseres Verfahren zur Bestimmung des modularen Inversen basiert auf folgendem Zusammenhang ("Vielfachsummensatz", "Lemma von Bézout", "Lemma von Bachet"): Vielfachsummensatz: Für je zwei natürliche Zahlen a und b gibt es ganze Zahlen u und v mit gg. T(a, b)=u*a+v*b. Beispiele: a = 3; b = 4: gg. T(3, 4) = 1 = (-1)*3 + 1*4 a = 6; b = 9: gg. T(6, 9) = 3 = (-1)*6 + 1 * 9 a = 41; b = 192: gg. T(41, 192) = 1 = 89*41 + (-19)*192

55 Euklidischer Algorithmus Gegeben: a = 884; b = 320 Gesucht: gg. T(a, b) → x = 884; y = 320 (1) 884 = 2*320 + 244 → r = 244; x = 320; y = 244 (2) 320 = 1*244 + 76 → r = 76; x = 244; y = 76 (3) 244 = 3*76 + 16 → r = 16; x = 76; y = 16 (4) 76 = 4*16 + 12 → r = 12; x = 16; y = 12 (5) 16 = 1*12 + 4 → r = 4; x = 12; y = 4 (6) 12 = 3*4 + 0 → r = 0; x = 4; y = 0 Ergebnis: gg. T(884, 320) = 4 Gegeben: a = 65; b = 21 Gesucht: gg. T(a, b)

56 Erweiterter euklidischer Algorithmus Gegeben: a = 884; b = 320 Gesucht: gg. T(a, b) = u*a + v*b Gegeben: a = 65; b = 21 Gesucht: gg. T(a, b) = u*a + v*b (1) 884 = 2*320 + 244 → 244 = 884 - 2*320 = (1*884 + 0*320) - 2*(0*884 + 1*320) = 1*884 - 2*320 (2) 320 = 1*244 + 76 → 76 = 320 - 1*244 = (0*884 + 1*320) - 1*(1*884 - 2*320)) = (-1)*884 + 3*320 (3) 244 = 3*76 + 16 → 16 = 244 - 3*76 = (1*884 - 2*320) - 3*((-1)*884 + 3*320) = 4*884 - 11*320 (4) 76 = 4*16 + 12 → 12 = 76 - 4*16 = ((-1)*884 + 3*320) - 4*(4*884 - 11*320) = (-17)*884 + 47*320 (5) 16 = 1*12 + 4 → 4 = 16 - 1*12 = (4*884 - 11*320) - 1*((-17)*884 + 47*320) = 21*884 - 58*320 (6) 12 = 3*4 + 0 Ergebnis: gg. T(884, 320) = 4 = 21*884 + (- 58)*320

57 Implementierung def erweiterter. Euklidischer. Algorithmus(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 = xneu yalt = ymitte = yneu aalt = amitte = aneu print(amitte, '=', xmitte, '*', a, '+', ymitte, '*', b) return (aalt, xalt, yalt) Aufgabe: Teste die Implementierung des erweiterten Euklidischen Algorithmus.

58 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: >>> erweiterter. Euklidischer. Algorithmus(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

59 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: >>> erweiterter. Euklidischer. Algorithmus(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 = -79 + 192

60 Aufgabe Beispiel 3: Gesucht wird das modulare Inverse von a = 21 bzgl. m = 65. Python liefert: >>> erweiterter. Euklidischer. Algorithmus(… , … ) …

61 Bestimmung des modularen Inversen Mit Hilfe der Ausgaben des erweiterten euklidischen Algorithmus lässt sich das modulare Inverse bestimmen. def mod. Inv(a, m): (ggt, x, y) = erweiterter. Euklidischer. Algorithmus(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 = 49 m = 100001000010000100001000010000 mod. Inv(d, m) Welche Konsequenzen ergeben sich hieraus für die Sicherheit des Chiffrierverfahrens mit modularer Multiplikation?

Sicherheit 62 Schlüsselerzeugung: A(lice) öffentl. Schlüssel von B(ob) (e, n) Wähle n größer als die maximale Codezahl. Wähle e mit e <n. Bestimme d mit [e*d]%n = 1. B(ob) pivat. Schlüssel von B(ob) (? , n) ? ? ? Codierung ? ? ? Klartext f(x, (e, n)) = [x*e]%n f*(y, (d, n)) y 0, y 1, y 2, . . . Geheimtext Codierung = [y*d]%n ? ? ? Klartext Entschlüsselungsfunktion Verschlüsselungsfunktion Mr(s) X 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 zu einer Zahl zu bestimmen.

63 Teil 5 Verschlüsselung mit modularer Potenz

64 Verschlüsseln d. modulares Rechnen modulares Addieren Verschlüsselung mit öffentl. Schlüssel (e, n) x → [x + e]%n Entschlüsselung mit privat. Schlüssel (d, n) y → [y + d]%n modulares Multiplizieren Verschlüsselung mit öffentl. Schlüssel (e, n) x → [x * e]%n Entschlüsselung mit privat. Schlüssel (d, n) y → [y * d]%n modulares Potenzieren Verschlüsselung mit öffentl. Schlüssel (e, n) x → [x ** e]%n Entschlüsselung mit privat. Schlüssel (d, n) y → [z ** d]%n

65 Verschlüsseln d. modulares Potenzieren Codierung: Alphabet: siehe rechts Blocklänge: 1 Verschlüsselung: öffentlicher Schlüssel (e, n) = (13, 77) Entschlüsselung: privater Schlüssel (d, n) = (37, 77) Decodierung: Alphabet: siehe rechts Blocklänge: 1 ' ' → 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 ** 37) % 77 = 01 (61 ** 37) % 77 = 19. . . (52 ** 37) % 77 = 24 01, 61, . . . , 52 ' ' → 00 'A' → 01. . . 'Z' → 26 01, 61, . . . , 52 01, 19, 20, 05, 18, 09, 24 A, S, T, E, R, I, X

66 Verschlüsseln d. modulares Potenzieren Verschlüsselung: öffentlicher Schlüssel (e, n) = (13, 77) Entschlüsselung: privater Schlüssel (d, n) = (37, 77) (01 ** 13) % 77 = 01 (19 ** 13) % 77 = 61. . . (24 ** 13) % 77 = 52 01, 19, 20, 05, 18, 09, 24 (01 ** 37) % 77 = 01 (61 ** 37) % 77 = 19. . . (52 ** 37) % 77 = 24 01, 61, . . . , 52 Aufgabe: Führe die erforderlichen Berechnungen selbst durch, z. B. so: >>> (19 ** 13) % 77 61 >>> (61 ** 37) % 77 19 01, 61, . . . , 52 01, 19, 20, 05, 18, 09, 24

Übung 67 Codierung: Alphabet: siehe rechts Blocklänge: 3 Verschlüsselung: öffentlicher Schlüssel (e, n) = (2008675, 2548873) Entschlüsselung: privater Schlüssel (d, n) = (377911, 2548873) Decodierung: Alphabet: siehe rechts Blocklänge: 3 ' ' → 00 'A' → 01. . . 'Z' → 26 (011920 ** 2008675) % 2548873 = … … … AST, ERI, X 011920, 051809, 240000 … … … ' ' → 00 'A' → 01. . . 'Z' → 26 … …

Übung 68 Codierung: Alphabet: siehe rechts Blocklänge: 4 ' ' → 00 'A' → 01. . . 'Z' → 26 01192005, 18092400 Verschlüsselung: … 01192005, 18092400 öffentlicher Schlüssel (e, n) = (377911777, 1919016703) Entschlüsselung: … privater Schlüssel (d, n) = (626738065, 1919016703) Decodierung: ' Alphabet: siehe rechts Blocklänge: 4 ' → 00 'A' → 01. . . 'Z' → 26 ASTE, RIX … … …

69 Schwierigkeiten beim Potenzieren Beim Rechnen mit Potenzen erhält man große Zahlen: >>> 24 ** 13 876488338465357824 >>> 876488338465357824 % 77 52 >>> 52 ** 37 3105444088679819357273546406651335246066988648897330641813635072 >>> 3105444088679819357273546406651335246066988648897330641813635072 % 77 24

70 Schwierigkeiten beim Potenzieren Wenn die Ausgangszahlen jetzt ebenfalls groß sind, dann muss das Ausführsystem riesige Zahlen verwalten. Python liefert bei solch großen Zahlen erst einmal keine Ergebnisse. >>> 11920 ** 2008675 ? ? ? Aufgabe: Schätze ab, wie viele Stellen das Ergebnis hier hat.

71 Modulares Potenzieren Bei modularen Potenzen kann man zuerst die Potenz berechnen und anschließend den modularen Rest. [3 * 3 * 3 * 3]% 5 = [729]%5 = 4 Günstiger ist es, die Modulbildung nach jedem Rechenschritt durchzuführen. [3 * 3 * 3 * [[[[[3 * 3]%5 [[[[ 4 * 3]%5 [[[ 2 [[ [ 4 3]% 5 = * 3]%5 * 1 * 3 Aufgabe: Teste das mit selbst gewählten Zahlen. 3]%5 * * * 3]%5 3]%5 = = =

72 Modulares Potenzieren Teste die Funktion modpot. Überzeuge dich mit geeigneten Ausgaben, dass die zwischenzeitlich berechneten Zahlen „klein“ bleiben. def modpot(x, y, m): pot = 1 zaehler = 0 while zaehler < y: pot = (pot * x) % m zaehler = zaehler + 1 return pot Aufgabe: Teste modpot auch mit großen Zahlen. Welche Schwierigkeit entsteht hier? >>> modpot(11920, 2008675, 2548873) … >>> modpot(119205765, 200867879653986264455665434555, 34176532378676755674563433454224333323) …

Schnelles Potenzieren 73 So … 3 · 3 · 3 · 3 · 3 9 · 3 · 3 · 3 · 3 · 3 · 3 · 3 27 Aufgabe: Wie viele Produkte müssen berechnet werden? · 3 · 3 · 3 81 · 3 · 3 · 3 243 … oder so? 43046721 3 · 3 · 3 · 3 · 3 9 · 81 9 · · 6561 9 · 81 9 · · · 43046721 9 · 81 9 · · 6561 9 · 81 9 Aufgabe: Wie viele Produkte müssen berechnet werden?

Schnelles Potenzieren 74 3 · 3 · 3 · 3 9 · 81 9 · · 6561 9 · 81 9 · · · 1594323 Darstellung in Tabellenform: x y pot 3 13 1 3 12 1*3 = 3 9 6 81 3 81 2 6561 1 6561 0 3*81 = 243*6561 = 1594323 9 · 9 81 · 3 243

Schnelles modulares Potenzieren 75 3 · 3 · 3 · 3 %5 4 · 4 · 4 · 3 %5 1 · 1 · 3 %5 1 · %5 3 Darstellung in Tabellenform: x y pot 3 13 1 3 12 [1*3]%5 = 3 [3*3]%5 = 4 6 [4*4]%5 = 1 3 1 2 [1*1]%5 = 1 1 1 0 [3*1]%5 = 3 3

Schnelles modulares Potenzieren 76 x y pot 3 13 1 3 12 [1*3]%5 = 3 [3*3]%5 = 4 6 [4*4]%5 = 1 3 1 2 [1*1]%5 = 1 1 1 0 [3*1]%5 = 3

77 Schnelles modulares Potenzieren 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 Aufgabe: Teste die Funktion modpot. >>> modpot(11920, 2008675, 2548873) … >>> modpot(119205765, 200867879653986264455665434555, 34176532378676755674563433454224333323) …

78 Durchführung mit Python Aufgabe: Erstelle die Datei chiffriersystem. Modulares. Potenzieren. py selbst oder lade sie herunter (siehe inf-schule). Mit den Funktionen der Implementierung kannst du jetzt das RSA-Verfahren durchspielen. Probiere das mit selbst gewählten Daten aus. Dokumentiere die Ergebnisse. Zur Kontrolle: Vergleiche die erzielten Ergebnisse mit denen, die Cryp. Tool (mit passenden Einstellungen) liefert.

79 Erzeugung der Schlüssel Vorbereitung: Beispiel: Wähle zwei verschiedene Primzahlen p und q. p = 7; q = 11 öffentlicher Schlüssel: Berechne n = p*q. n = 77 Berechne φ(n) = (p-1)*(q-1). φ(n) = 60 Wähle eine Zahl e mit 1 < e < φ(n) , die teilerfremd zu φ(n) ist. z. B. e = 13 Der öffentliche Schlüssel ist (e, n). (13, 77) ("Vernichte p, q, φ(n). ") privater Schlüssel: Berechne d so, dass [e*d]%φ(n) = 1 ist. d = 37 Der private Schlüssel ist (d, n). (37, 77)

80 Erzeugung der Schlüssel Aufgabe: Erzeuge selbst mit dem Vefahren ein Schlüsselpaar. Überprüfe mit Cryp. Tool.

Korrektheit des RSA-Verfahren 81 RSA-Schlüsselerzeugung: Wähle zwei verschiedene Primzahlen p und q. A(lice) öffentl. Schlüssel von B(ob) (e, n) Berechne n = p q und (n) = (p-1) (q-1). Wähle e mit 1 < e < (n) und gg. T(e, (n)) = 1. B(ob) privat. Schlüssel von B(ob) (d, n) Bestimme d mit [c d]% (n) = 1. "HALLO. . . " Codierung "HALLO. . . " f(x, (e, n)) x 0, x 1, x 2, . . . = Klartext [xe]%n RSA-Verschlüsselungsfunktion f*(y, (d, n)) = y 0, y 1, y 2, . . . [yd]%n Geheimtext RSA- Entschlüsselungsfunktion 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 Codierung x 0, x 1, x 2, . . . Klartext

82 Korrektheit des RSA-Verfahrens 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: Satz (Kleiner Fermatscher Satz): (e*d) [x]%p = 0 und [x ]% p = 0 Sei p eine Primzahl und a eine natürliche Also: [x(e*d)]%p = [x]%p Zahl, die kein Vielfaches von p ist. Dann gilt: [a(p-1)]%p = 1 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. .

83 Korrektheit des RSA-Verfahrens . . . 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

84 Korrektheit des RSA-Verfahrens Die Korrektheit des Verfahrens mit modularer Potenz beruht auf Zusammenhängen aus der Zahlentheorie. x | # verschlüsseln [x**e]%n | # entschlüsseln [([x**e]%n)**d]%n | # elementare Rechengesetze [x**(e*d)]%n | x # Zahlentheorie

Sicherheit 85 RSA-Schlüsselerzeugung: Wähle zwei verschiedene Primzahlen p und q. A(lice) öffentl. Schlüssel von B(ob) (e, n) Berechne n = p q und (n) = (p-1) (q-1). Wähle e mit 1 < e < (n) und gg. T(e, (n)) = 1. B(ob) privat. Schlüssel von B(ob) (? , n) Bestimme d mit [c d]% (n) = 1. ? ? ? Codierung ? ? ? Klartext f(x, (e, n)) = [xe]%n ? ? ? f*(y, (d, n)) y 0, y 1, y 2, . . . Geheimtext Codierung = [yd]%n ? ? ? Klartext RSA- Entschlüsselungsfunktion RSA-Verschlüsselungsfunktion Mr(s) X 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.

86 Geheimcodes knacken Codierung: Umwandlung von Zeichen in Zahlen ' ' → 00 'A' → 01. . . 'Z' → 26 Verschlüsselung: öffentlicher Schlüssel (e, n) = (19, 65) 48, 9, 60, 38, 60, 0, 58, 47, 31, 60, 59, 60, 0, 1, 31, 59, 0, 58, 1, 38, 9, 60, 14 Entschlüsselung: privater Schlüssel (d, n) = (. . . , . . . ) Decodierung: Umwandlung von Zahlen in Zeichen ' ' → 00 'A' → 01. . . 'Z' → 26

87 Geheimcodes knacken Codierung: Umwandlung von Zeichen in Zahlen ' ' → 00 'A' → 01. . . 'Z' → 26 Verschlüsselung: öffentlicher Schlüssel (e, n) = (113, 6887) 6613, 5456, 1378, 2773, 1646, 5581, 4072 Entschlüsselung: privater Schlüssel (d, n) = (. . . , . . . ) Decodierung: Umwandlung von Zahlen in Zeichen ' ' → 00 'A' → 01. . . 'Z' → 26

Geheimcodes knacken 88 öffentlicher Schlüssel (e, n) = (1432765433173537777777, 1914269284601333234385791628203) privater Schlüssel (d, n) = (. . . , . . . ) Codierung: Umwandlung von Zahlen in Zeichen ' ' → 00 'A' → 01. . . 'Z' → 26 0703995545688427802027825362902, 0076119838972138298619729763565

89 Geheimcodes knacken Primzahlgenerator: https: //asecuritysite. com/encryption/random 3? val=16 Primfaktorzerlegung: http: //www. wolframalpha. com/widgets/view. jsp? id=eba 26 c 0 e 29 a 5 ba 4 ba 0345 d 4 b 9 c 216 ab 5

Angriff auf das RSA-Verfahren 90 RSA-Schlüsselerzeugung: Wähle zwei verschiedene Primzahlen p und q. A(lice) öffentl. Schlüssel von B(ob) (e, n) Berechne n = p q und (n) = (p-1) (q-1). Wähle e mit 1 < e < (n) und gg. T(e, (n)) = 1. B(ob) privat. Schlüssel von B(ob) (? , n) Bestimme d mit [c d]% (n) = 1. ? ? ? Codierung ? ? ? Klartext ? ? ? f(x, (e, n)) = [xe]%n f*(y, (d, n)) = y 0, y 1, y 2, . . . [yd]%n Geheimtext RSA-Verschlüsselungsfunktion Codierung ? ? ? Klartext RSA- Entschlüsselungsfunktion 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.

Sicherheit des RSA-Verfahrens 91 RSA-Schlüsselerzeugung: Wähle zwei verschiedene Primzahlen p und q. A(lice) öffentl. Schlüssel von B(ob) (e, n) Berechne n = p q und (n) = (p-1) (q-1). Wähle e mit 1 < e < (n) und gg. T(e, (n)) = 1. B(ob) pivat. Schlüssel von B(ob) (? , n) Bestimme d mit [c d]% (n) = 1. ? ? ? Codierung ? ? ? Klartext f(x, (e, n)) = [xe]%n RSA-Verschlüsselungsfunktion ? ? ? f*(y, (d, n)) y 0, y 1, y 2, . . . Geheimtext Codierung = [yd]%n ? ? ? Klartext RSA- Entschlüsselungsfunktion 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.

92 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.

93 Lehrplan - Leistungsfach Ziel ist es, das RSAVerfahren als eines der klassischen asymmetrischen Verschlüsselungsverfahren 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, Teil 1. LOG IN 140 S. 45 ff. H. Witten, R. -H. Schulz: RSA & Co. in der Schule, Teil 2. LOG IN 143 S. 50 ff. Lehrplan für das Leistungsfach

94 Teil 7 Exkurs: Gnu. PG-Schlüssel

95 Schlüsselerzeugung mit Gnu. PG C: >gpg --gen-key gpg (Gnu. PG) 1. 4. 10; Copyright (C) 2008 Free Software Foundation, Inc. This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Bitte wählen Sie, welche Art von Schlüssel Sie möchten: (1) RSA und RSA (voreingestellt) (2) DSA und Elgamal (3) DSA (nur unterschreiben/beglaubigen) (4) RSA (nur signieren/beglaubigen) Ihre Auswahl? 1 RSA Schlüssel können zwischen 1024 und 4096 Bits lang sein. Welche Schlüssellänge wünschen Sie? (2048) Die verlangte Schlüssellänge beträgt 2048 Bit …. +++++ gpg: Schlüssel 468 BA 4 E 2 ist als uneingeschränkt vertrauenswürdig gekennzeichnet Öffentlichen und geheimen Schlüssel erzeugt und signiert. …

96 Export des öffentlichen Schlüssels C: >gpg --armor --output bob_public_key. asc --export "Bob Happy" -----BEGIN PGP PUBLIC KEY BLOCK----Version: Gnu. PG v 2. 0. 22 (Ming. W 32) m. QENBFn 6 w. Oc. BCADHS 0 uk. FSGLtyp. Nx 3 m 6 Fu. Wi 179 EYnco. Emb. OKM 17 i 1 Yw. Jb. Va 4 RFk i. Hypz. LGj/Qwlwi. TWkt. T 4 atiroiie. FNm 6 c 0 FLDM 7 Ns. Yy. JZA+7 K 3 ik. GEKc. SKj. UINh. Q Ns 5 Uvaje. Yld/n. I 1/q. OJKy. E 78 UEI/E 9 l. GV 7 o. FP 4 D 1 vpy. Zgkhe. V 7 v. KUq 7 p. Ylb. BPVUr UPOy. DF 5 UWs 3 z 5 ZQiiasoqij 6+8 wt 6 Lj+BS 9 Ioy. Ctd. Qx. GDLE 5 X+Fx. N 7 gz 2 Fbin. ZSl y. C 6 Bwfzp. KMY++d. Ky 28 vs+E 0 Ym. Ct. Asp. MSj. NLGH 8 mome. IKfqnde. Ui. I 6 t. B 4 FRx. Zl 8 i. W AFx 8 Rxyz. STfl 27 k. V 653 d. Er. Tind. Zae 86 PAt 2 DABEBAAG 0 Hk. Jv. Yi. BIYXBwe. SAo. Li 4 u KSA 8 Ym 9 i. QGhhc. HB 5 Lm. Rl. Pok. BPw. QTAQIAKQUCWfr. A 5 w. Ib. Aw. UJACe. NAAc. LCQg. HAw. IB Bh. UIAgk. KCw. QWAg. MBAh 4 BAhe. AAAo. JEKUZ 1 x 9 Gi 6 Tiai 0 IAMKGhu. X 9 wi 3 an 5 qwf. Cmt Kwaybw 60 o. VKm. ZF 5 rg. FRJfn. Qgb 2 b. Cc 3 Np. SI 45 i/Cc 36 pn. FR/Tt. Ibm. Pgm 6 zhj. Sd. C 92 Qwqq. BBy. J/6 f/p. Xj. WU 2 F 6 k 2 Y 6 m. Eq. FXkk. Ps. T 5 Se. THHiqq. Kq. Pa 67 KCh. Os. RRQq. Bqw 5 u. N 7/8 Tvs. CKp. Mj+Hz. Ta. ULg. QG 7+2 w. F 4 mgy. Zv. Je. SOKa. Xxa. UCPEJ/KLVs. Tn. Kjpbq. DBm 4 g 5 I 3 I 2 m. CR+RT+r 8 o. Rb. SYv 45+wmti. Uy 6 Na 4 VJJe. NWpf. QNone. XP+nk. Zb. YURPb. Hk. HFFv. B Kw/O 7 XARium 8 qajr. Qr. Pntr. Jd 7 Tni. Iv 3 Cy. TS 4 v. JIi. Sn. Sjulp. Ovdzxg. I 6 Qs 1 Hly. VDS T 3 i 5 AQ 0 EWfr. A 5 w. EIAMx. Gr. QYMcy. Ju. N 0 Sz+2 Jul. Pcuq. Xb 9 Gd 7 DVkxoj. UIMBJN 5 Iv. OQ vy. T 30 f. Kymx 8 CIJxn 58 dl. XQh. L 1 y. Law. DV 9 t 88 wb. Fp. UWRSAYP 6 GTu. Db 7 Gk. Iq. G 3 xt 00 n n 4 k. Lxj. Fip. Un 8 Rq. Mtrnoj. Gg. ELXSp. Inkt+g. P 9 lf. QBlr. KGKr 4 p. TMJ 0 qam. KIl/LOj. Ey. Z u. Cj 7 T 4 S 2 Xi. CCWBu 8 NDl. Xwj. Hk 1 c. TWd. Q/f 8 Zm 2 ZZVv. Qls. BIKszg 9 GSY+a 4 px. POAKWM JHTQno. ZDjzz. QC 3 i. Fsr. Bkzcw. FS 3 Dbn 1 Tf. No. Y 9 n. Fh. Ke. I 3 Fb. Bum 4 Vb. TKws. HArtsfe 8 B Hp. B 7 y 1 w. Ori 3 Qhsqo. XNv 4 ER 9 q. Np. Rbu. SZN 5/b. Lb. Sk. AEQEAAYk. BJQQYAQIADw. UCWfr. A 5 w. Ib. DAUJACe. NAAAKCRCl. Gdcf. Rouk 4 t 2 c. CACASRW 5 Vn 8 aa 3 NDy. G 4 r. Ei. TBFr 98 bt. E 6 IYUw. Ei 30 k. POEo+r. Vwjrjfh 0 t. H 7 uk 0 o 1 u. Wm. MQWg. V 2 J 2 ai 18 QS 1/juc. Fka 8 y. U 75 vp. R b. Rg. WD 6 JBj 7 o 5 g. LNrvx. A 8/c. Qq/ZHRT/do. Dneevw. JDv. Ob. CZBl. PBx. ZCvei. Sx. WJa 4 G+a KPjt+CFJ/g. Wl. Iw. VLsldp. Ew. EV/XX 5 a 7 DN+wuxv. NVa. Fn. CU 2 w 33 g. VPLZF 6 YX 4 j. K 4 i. Oh Qb/9 w. UQYrgp. NDUOYWb 1 ZBB 5 FUIelt. AQRc/VRYt. P 48 PJbat 6 SBEg 59 Zb/OSKf 2 m. SJ 1 x 09 W 4 RPVj. O 5 FPSGEUr. Aeipk 3 QUd 3 p. IKy. Ej/8 tjr. GJ 52 h 3 YV 10 T 4 At. GG =d. F 2 J -----END PGP PUBLIC KEY BLOCK-----

97 Blick hinter die Kulissen C: >gpg --with-key-data --list-keys 0 x 468 BA 4 E 2 tru: : 1: 1509605607: 1512197298: 3: 1: 5 pub: u: 2048: 1: A 519 D 71 F 468 BA 4 E 2: 1509605607: 1512197607: : u: : : sc. ESC: pkd: 0: 2048: 00 C 74 B 4 BA 415218 BB 72 A 4 DC 779 BA 16 E 5 A 2 D 7 BF 446277281266 CE 28 CD 7 B 8 B 563025 B 55 AE 11164887 C A 9 CCB 1 A 3 FD 0 C 25 C 224 D 692 D 4 F 86 AD 8 ABA 2289 E 14 D 9 BA 73414 B 0 CCECDB 18 C 89640 FBB 2 B 78 A 418429 C 48 A 8 D 420 D 85 036 CE 54 BDA 8 DE 62577 F 9 C 8 D 7 FA 8 E 24 AC 84 EFC 50423 F 13 D 94657 BA 053 F 80 F 5 BE 9 C 9982485 E 57 BBCA 52 AEE 96256 C 1 3 D 552 B 50 F 3 B 20 C 5 E 545 ACDF 3 E 5942289 AB 28 AA 28 FAFBCC 2 DE 8 B 8 FE 052 F 48 A 320 AD 750 C 460 CB 1395 FE 17137 B 833 D 856 E 29 D 94 A 5 C 82 E 81 C 1 FCE 928 C 63 EF 9 D 2 B 2 DBCBECF 84 D 18982 B 40 B 293128 CD 2 C 61 FC 9 A 899 E 20 A 7 EA 9 DD 794888 EA D 078151 C 5997 C 896005 C 7 C 471 CB 34937 E 5 DBB 915 EB 9 DDD 12 B 4 E 29 DD 65 A 7 BCE 8 F 02 DD 83 : pkd: 1: 17: 010001: uid: u: : 1509605607: : AE 597 EF 00 F 11 C 73 ABF 897 B 7 E 94 E 60 C 7 A 8470 A 6 DC: : Bob Happy (. . . ) <bob@happy. de>: sub: u: 2048: 1: 4 D 3 A 6 B 2 FC 3 D 4614 A: 1509605607: 1512197607: : : e: pkd: 0: 2048: 00 CC 46 AD 060 C 73226 E 3744 B 3 FB 626 E 94 F 72 EA 976 FD 19 DEC 3564 C 688 D 420 C 04937922 F 390 BF 24 F 7 D 1 F 2 B 29 B 1 F 02209 C 67 E 7 C 7655 D 084 BD 722 DAC 0357 DB 7 CF 306 C 5 A 5459148060 FE 864 EE 0 DBEC 6908 A 86 DF 1 B 74 D 279 F 8 90 BC 63162 A 549 FC 46 A 32 DAE 7 A 231 A 010 B 5 D 2 A 489 E 4 B 7 E 80 FF 657 D 0065 ACA 18 AAF 8 A 53309 D 2 A 6 A 628897 F 2 CE 8 C 4 C 99 B 828 FB 4 F 84 B 65 E 2082581 BBC 343957 C 231 E 4 D 5 C 4 D 6750 FDFF 199 B 665956 F 425 B 0120 AB 3383 D 19263 E 6 B 8 A 713 C E 00 A 58 C 2474 D 09 E 86438 F 3 CD 00 B 7885 B 2 B 064 CDCC 054 B 70 DB 9 F 54 DF 36863 D 9 C 584 A 788 DC 56 C 1 BA 6 E 156 D 32 B 0 B 07 02 BB 6 C 7 DEF 011 E 907 BCB 5 C 0 EAE 2 DD 086 CAA 85 CDBF 8111 F 6 A 36945 BB 9264 DE 7 F 6 CB 6 D 29: pkd: 1: 17: 010001:

98 Blick hinter die Kulissen n_hex = '0 x 00 C 74 B 4 BA 415218 BB 72 A 4 DC 779 BA 16 E 5 A 2 D 7 BF 446277281266 CE 28 CD 7 B 8 B 563025 B 55 AE 11164887 CA 9 CCB 1 A 3 FD 0 C 25 C 224 D 692 D 4 F 86 AD 8 ABA 2289 E 14 D 9 BA 73414 B 0 CCECDB 18 C 89640 FBB 2 B 78 A 418429 C 48 A 8 D 420 D 85036 CE 54 B DA 8 DE 62577 F 9 C 8 D 7 FA 8 E 24 AC 84 EFC 50423 F 13 D 94657 BA 053 F 80 F 5 BE 9 C 9982485 E 57 BBCA 52 AEE 96256 C 13 D 552 B 50 F 3 B 20 C 5 E 545 ACDF 3 E 5942289 AB 28 AA 28 FAFBCC 2 DE 8 B 8 FE 052 F 48 A 320 AD 750 C 460 CB 1395 FE 17137 B 833 D 856 E 29 D 9 4 A 5 C 82 E 81 C 1 FCE 928 C 63 EF 9 D 2 B 2 DBCBECF 84 D 18982 B 40 B 293128 CD 2 C 61 FC 9 A 899 E 20 A 7 EA 9 DD 794888 EAD 078151 C 5997 C 896005 C 7 C 471 CB 34937 E 5 DBB 915 EB 9 DDD 12 B 4 E 29 DD 65 A 7 BCE 8 F 02 DD 83' e_hex = '0 x 010001' print('Anzahl der Bits von n: ', 4*len(str('C 74 B 4 BA 415218 BB 72 A 4 DC 779 BA 16 E 5 A 2 D 7 BF 446277281266 CE 28 CD 7 B 8 B 563025 B 55 AE 11164887 CA 9 CCB 1 A 3 FD 0 C 25 C 224 D 692 D 4 F 86 AD 8 ABA 2289 E 14 D 9 BA 73414 B 0 CCECDB 18 C 89640 FBB 2 B 78 A 418429 C 48 A 8 D 420 D 8503 6 CE 54 BDA 8 DE 62577 F 9 C 8 D 7 FA 8 E 24 AC 84 EFC 50423 F 13 D 94657 BA 053 F 80 F 5 BE 9 C 9982485 E 57 BBCA 52 AEE 96256 C 13 D 552 B 50 F 3 B 20 C 5 E 545 ACDF 3 E 5942289 AB 28 AA 28 FAFBCC 2 DE 8 B 8 FE 052 F 48 A 320 AD 750 C 460 CB 1395 FE 17137 B 833 D 85 6 E 29 D 94 A 5 C 82 E 81 C 1 FCE 928 C 63 EF 9 D 2 B 2 DBCBECF 84 D 18982 B 40 B 293128 CD 2 C 61 FC 9 A 899 E 20 A 7 EA 9 DD 794888 EAD 0 78151 C 5997 C 896005 C 7 C 471 CB 34937 E 5 DBB 915 EB 9 DDD 12 B 4 E 29 DD 65 A 7 BCE 8 F 02 DD 83'))) print('Anzahl der Bits von e: ', 4*len(str('0001'))+1) n = int(n_hex, 16) e = int(e_hex, 16) print('n: ', n) print('e: ', e) print('Anzahl der Stellen von n: ', len(str(n)))

99 Blick hinter die Kulissen >>> Anzahl der Bits von n: 2048 Anzahl der Bits von e: 17 n: 2515855226954965794597878025356967748391531928305235011937946216105655521338710968009355297 3517951003992450235775256277677325373225273258837036734087690231446261059410694231115444988 6951913762151849830612002470121318453597222472913671870222513172807394018108700997672384142 2282906841891045008805590773984676073475588010130404082468440024047634790862974535685690272 4574985350165811219496576352940501866716900384634264482720191911039401802924421065287498462 8640463034769393438599413949513408365763029116070955055893971409353052295672134466100277622 21767309667205564203315723005132500605798740467427093071316384013802883 e: 65537 Anzahl der Stellen von n: 617

100 Literaturhinweise Folgende Materialien wurden hier benutzt: H. Witten, R. -H. Schulz: RSA & Co. in der Schule, Teil 1. LOG IN 140 S. 45 ff H. Witten, R. -H. Schulz: RSA & Co. in der Schule, Teil 2. 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-Flash-de/player. html