Das rsa verfahren
This presentation is the property of its rightful owner.
Sponsored Links
1 / 97

Das RSA-Verfahren PowerPoint PPT Presentation


  • 79 Views
  • Uploaded on
  • Presentation posted in: General

Das RSA-Verfahren. Klaus Becker 2014. Das RSA-Verfahren. An: [email protected] Von: [email protected] Hallo Bob!. Teil 1. Experimente mit CrypTool. Experimente mit CrypTool.

Download Presentation

Das RSA-Verfahren

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Das rsa verfahren

Das RSA-Verfahren

Klaus Becker

2014


Das rsa verfahren1

Das RSA-Verfahren

An: [email protected]

Von: [email protected]

Hallo Bob!


Teil 1

Teil 1

Experimente mit CrypTool


Experimente mit cryptool

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.


Experimente mit cryptool1

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.


Experimente mit cryptool2

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 in der Abbildung (beachte das Leerzeichen im Alphabet).


Experimente mit cryptool3

Experimente mit CrypTool

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


Vorbemerkung

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.


Teil 2

Teil 2

Verschlüsselung mit modularer Addition


Vorbemerkung1

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

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: D

Quelltext:

Geheimtext:

SALVEASTERIX

VDOYHDVWHULA


Caesar verfahren mit zahlen

Caesar-Verfahren mit Zahlen

Codierung:

Umwandlung von Zeichen in Zahlen

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

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

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

Verschlüsselung:

Verarbeitung von Zahlen

(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

Entschlüsselung:

Verarbeitung von Zahlen

(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

Decodierung:

Umwandlung von Zahlen in Zeichen

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

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

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


Caesar variation zus tzliche zeichen

Caesar-Variation: zusätzliche Zeichen

Codierung:

Umwandlung von Zeichen in Zahlen

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

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

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

Verschlüsselung:

Verarbeitung von Zahlen

(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

Entschlüsselung:

Verarbeitung von Zahlen

(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

Decodierung:

Umwandlung von Zahlen in Zeichen

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

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

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


Caesar variation verallgeinerte addition

Caesar-Variation: verallgeinerte Addition

Codierung:

Umwandlung von Zeichen in Zahlen

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

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

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

Verschlüsselung:

Verarbeitung von Zahlen(e, n) = (18, 30)

(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

Entschlüsselung:

Verarbeitung von Zahlen(d, n) = (12, 30)

(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

Decodierung:

Umwandlung von Zahlen in Zeichen

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

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

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


Caesar variation zeichenbl cke

Caesar-Variation: Zeichenblöcke

Codierung:

Umwandlung von Zeichen in Zahlen

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

HAL,LO

80112, 121500

Verschlüsselung:

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

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

80112, 121500

192345, 233733

Entschlüsselung:

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

(192345 + 209088) % 321321 = 192345 (233733 + 209088) % 321321 = 121500

192345, 233733

80112, 121500

Decodierung:

Umwandlung von Zahlen in Zeichen

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

80112, 121500

HAL,LO


Verfahren mit modularer addition

Verfahren mit modularer Addition

Schlüsselerzeugung:

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

Wähle e mit e <n.

Bestimme d mit e+d=n.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(d, n)

"HALLO ..."

"HALLO ..."

Codierung

f(x, (e,n))

=

[x+e]%n

f*(y, (d,n))

=

[y+d]%n

Codierung

x0, x1, x2, ...

y0, y1, y2, ...

x0, x1, x2, ...

Klartext

Geheimtext

Klartext

Entschlüsselungsfunktion

Verschlü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 '


Verfahren mit modularer addition1

Verfahren mit modularer Addition

Schlüsselerzeugung:

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

Wähle e mit e <n.

Bestimme d mit e+d=n.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(d, n)

"HALLO ..."

"HALLO ..."

Codierung

f(x, (e,n))

=

[x+e]%n

f*(y, (d,n))

=

[y+d]%n

Codierung

x0, x1, x2, ...

y0, y1, y2, ...

x0, x1, x2, ...

Klartext

Geheimtext

Klartext

Entschlüsselungsfunktion

Verschlüsselungsfunktion

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:

' ' -> 0000

' A' -> 0001

' B' -> 0002

...

' Z' -> 0026

'A ' -> 0100

'AA' -> 0101

...

'ZZ' -> 2626

Codierung von Zeichenblöcken:

' ' -> 000

' A' -> 001

' B' -> 002

...

' Z' -> 026

'A ' -> 027

'AA' -> 028

...

'ZZ' -> 728

Codierung des Alphabets:

' ' -> 00

'A' -> 01

...

'Z' -> 26


Verfahren mit modularer addition2

Verfahren mit modularer Addition

Schlüsselerzeugung:

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

Wähle e mit e <n.

Bestimme d mit e+d=n.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(d, n)

"HALLO ..."

"HALLO ..."

Codierung

f(x, (e,n))

=

[x+e]%n

f*(y, (d,n))

=

[y+d]%n

Codierung

x0, x1, x2, ...

y0, y1, y2, ...

x0, x1, x2, ...

Klartext

Geheimtext

Klartext

Entschlüsselungsfunktion

Verschlü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=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.


Verfahren mit modularer addition3

Verfahren mit modularer Addition

Schlüsselerzeugung:

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

Wähle e mit e <n.

Bestimme d mit e+d=n.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(d, n)

"HALLO ..."

"HALLO ..."

Codierung

f(x, (e,n))

=

[x+e]%n

f*(y, (d,n))

=

[y+d]%n

Codierung

x0, x1, x2, ...

y0, y1, y2, ...

x0, x1, x2, ...

Klartext

Geheimtext

Klartext

Entschlüsselungsfunktion

Verschlüsselungsfunktion

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


Das rsa verfahren

Übung

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 (nicht zu lange) Nachricht mit dem oben beschriebenen Verfahren mit modularer Addition.

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.


Durchf hrung mit python

Durchführung mit Python

Aufgabe: Eine Implementierung nutzen

Lade die Datei chiffriersystemModularesAddieren.py (siehe inf-schule) herunter. Diese Datei enthält eine ganze Reihe von Funktionen, die Teilaufgaben beim Verfahren mit modularer Addition übernehmen. Mit den Funktionen kannst du jetzt interaktiv das Verfahren mit modularer Addition durchspielen. Führe selbst weitere Tests durch.

>>> abc = ' ABCDEFGHIJKLMNOPQRSTUVWXYZ'

>>> block = 2

>>> oeffentlicherSchluessel = (2102, 3000)

>>> privaterSchluessel = (898, 3000)

>>> quelltext = 'ASTERIX'

>>> quellcode = codierung(quelltext, block, abc)

>>> quellcode

[119, 2005, 1809, 2400]

>>> geheimcode = verschluesselung(quellcode, oeffentlicherSchluessel)

>>> geheimcode

[2221, 1107, 911, 1502]

>>> entschluesseltercode = verschluesselung(geheimcode, privaterSchluessel)

>>> entschluesseltercode

[119, 2005, 1809, 2400]

>>> entschluesseltertext = decodierung(entschluesseltercode, block, abc)

>>> entschluesseltertext

'ASTERIX'


Durchf hrung mit python1

Durchführung mit Python

Aufgabe : Eine Implementierung nutzen

Alternativ kann man auch ein kleines Testprogramm wie das folgende erstellen:

from chiffriersystemModulareAddition import *

# Vorgaben

abc = ' ABCDEFGHIJKLMNOPQRSTUVWXYZ'

block = 2

oeffentlicherSchluessel = (2102, 3000)

privaterSchluessel = (898, 3000)

# Verarbeitung

quelltext = 'COSINUS'

quellcode = codierung(quelltext, block, abc)

geheimcode = verschluesselung(quellcode, oeffentlicherSchluessel)

entschluesseltercode = verschluesselung(geheimcode, privaterSchluessel)

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

Korrektheit

Schlüsselerzeugung:

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

Wähle e mit e <n.

Bestimme d mit e+d=n.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(d, n)

"HALLO ..."

"HALLO ..."

Codierung

f(x, (e,n))

=

[x+e]%n

f*(y, (d,n))

=

[y+d]%n

Codierung

x0, x1, x2, ...

y0, y1, y2, ...

x0, x1, x2, ...

Klartext

Geheimtext

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 = x


Sicherheit

Sicherheit

Schlüsselerzeugung:

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

Wähle e mit e <n.

Bestimme d mit e+d=n.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(d, n)

"HALLO ..."

"HALLO ..."

Codierung

f(x, (e,n))

=

[x+e]%n

f*(y, (d,n))

=

[y+d]%n

Codierung

x0, x1, x2, ...

y0, y1, y2, ...

x0, x1, x2, ...

Klartext

Geheimtext

Klartext

Entschlüsselungsfunktion

Verschlüsselungsfunktion

Sicherheit:

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


Teil 3

Teil 3

Exkurs - Modulares Rechnen


Uhrenaddition

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?


Modulare gleichheit

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


Modulare addition

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


Modulare addition1

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


Modulare multiplikation

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


Modulare potenz

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 ?

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

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%n

2

>>> a2%n

2

>>> b1%n

5

>>> b2%n

5

>>> (a1+b1)%n

...


Teil 4

Teil 4

Verschlüsselung mit modularer Multiplikation


Vorbemerkung2

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.

Wir werden hier sehen, wie die Sicherheit eines Verfahrens davon abhängt, ob man über schnelle Algorithmen für bestimmte Problemstellungen verfügt.


Multiplikation statt addition

A(lice)

A(lice)

B(ob)

B(ob)

öffentl. Schlüssel von B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(e, n)

(d, n)

(d, n)

"HALLO ..."

"HALLO ..."

"HALLO ..."

"HALLO ..."

Codierung

Codierung

f(x, (e,n))

=

[x*e]%n

f(x, (e,n))

=

[x+e]%n

f*(y, (d,n))

=

[y*d]%n

f*(y, (d,n))

=

[y+d]%n

Codierung

Codierung

x0, x1, x2, ...

x0, x1, x2, ...

y0, y1, y2, ...

y0, y1, y2, ...

x0, x1, x2, ...

x0, x1, x2, ...

Klartext

Klartext

Geheimtext

Geheimtext

Klartext

Klartext

Entschlüsselungsfunktion

Entschlüsselungsfunktion

Verschlüsselungsfunktion

Verschlüsselungsfunktion

Multiplikation statt Addition


Statt addition

Statt Addition ...

Codierung:

Umwandlung von Zeichen in Zahlen

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

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

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

Verschlüsselung:

Verarbeitung von Zahlen(e, n) = (7, 30)

(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

Entschlüsselung:

Verarbeitung von Zahlen(d, n) = (23, 30)

(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

Codierung:

Umwandlung von Zeichen in Zahlen

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

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

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


Benutze multiplikation

... benutze Multiplikation!

Codierung:

Umwandlung von Zeichen in Zahlen

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

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

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

Verschlüsselung:

Verarbeitung von Zahlen(e, n) = (7, 30)

(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

Entschlüsselung:

Verarbeitung von Zahlen(d, n) = (…, 30)

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

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

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

Codierung:

Umwandlung von Zeichen in Zahlen

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

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

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


Benutze multiplikation1

... 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 (hier 7) zum Verschlüsseln, der Zahl d (hier ...) zum Entschlüsseln und der Modulzahl n (hier 30)?

Verschlüsselung:

Verarbeitung von Zahlen(d, n) = (…, 30)

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

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

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

Codierung:

Umwandlung von Zeichen in Zahlen

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

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

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


Modulares inverses

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. Bestimme zu a = 1, 2, 3, 4 jeweils das modulare Inverse bzgl. n.

(b) Betrachte den Fall n = 8. 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?


Existenz des modularen inversen

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.


Verfahren und seine korrektheit

Verfahren und seine Korrektheit

Schlüsselerzeugung:

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

Wähle e mit e <n.

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

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(d, n)

"HALLO ..."

"HALLO ..."

Codierung

f(x, (e,n))

=

[x*e]%n

f*(y, (d,n))

=

[y*d]%n

Codierung

x0, x1, x2, ...

y0, y1, y2, ...

x0, x1, x2, ...

Klartext

Geheimtext

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


Durchf hrung mit python2

Durchführung mit Python

Aufgabe: Eine Implementierung testen

Lade die Datei chiffriersystemModularesMultiplizieren.py (siehe inf-schule) herunter. Teste das Chiffriersystem mit selbst gewählten Beispielen. Dokumentiere die Ergebnisse.

from chiffriersystemModulareMultiplikation import *

# Vorgaben

abc = ' ABCDEFGHIJKLMNOPQRSTUVWXYZ'

block = 1

oeffentlicherSchluessel = (7, 30)

privaterSchluessel = (13, 30)

# Verarbeitung

quelltext = 'ASTERIX'

quellcode = codierung(quelltext, block, abc)

geheimcode = verschluesselung(quellcode, oeffentlicherSchluessel)

entschluesseltercode = verschluesselung(geheimcode, privaterSchluessel)

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)


Geheimcodes knacken

Geheimcodes knacken

Codierung:

Umwandlung von Zeichen in Zahlen

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

Verschlüsselung:

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

Entschlüsselung:

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

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

Decodierung:

Umwandlung von Zahlen in Zeichen

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


Geheimcodes knacken1

Geheimcodes knacken

Codierung:

Umwandlung von Zeichen in Zahlen

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

Verschlüsselung:

öffentlicher Schlüssel(e, n) = (781, 2828)

1893, 236, 1973, 1292, 1077, 2028, 2431

Entschlüsselung:

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

Decodierung:

Umwandlung von Zahlen in Zeichen

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


Bestimmung des modularen inversen

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


Bestimmung des modularen inversen1

Bestimmung des modularen Inversen

Aufgabe:

Teste den Baustein modInv 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.


Bestimmung des modularen inversen2

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

>>> modInvMitAusgaben(49, 1000010000100001000010000100001000010000100001000010000)

Anzahl der Versuche: 10000000

Anzahl der Versuche: 20000000

Anzahl der Versuche: 30000000

...

für 10 Millionen Überprüfungen benötigt man mehr als 1 Sekunde!


Bestimmung des modularen inversen3

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.

Verwendbarkeit:

Für größere Zahlen ist der naive Algorithmus zur Berechnung des modularen Inversen unbrauchbar. Für die gezeigten Zahlen benötigt ein Rechner länger, als das Universum alt ist.


Vielfachsummensatz

Vielfachsummensatz

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


Erweiterter euklidischer algorithmus

Erweiterter euklidischer Algorithmus

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

(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

Ergebnis:

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


Implementierung

Implementierung

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)

Aufgabe: Teste die Implementierung des erweiterten Euklidischen Algorithmus..


Bestimmung des modularen inversen4

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


Bestimmung des modularen inversen5

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


Aufgabe

Aufgabe

Beispiel 3:

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

Python liefert:

>>> erweiterterEuklidischerAlgorithmus( , )

Umformungen:

Ergebnis: b =


Bestimmung des modularen inversen6

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?


Sicherheit1

Schlüsselerzeugung:

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

Wähle e mit e <n.

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

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

pivat. Schlüssel von B(ob)

(e, n)

(?, n)

???

???

Codierung

f(x, (e,n))

=

[x*e]%n

f*(y, (d,n))

=

[y*d]%n

Codierung

???

y0, y1, y2, ...

???

Klartext

Geheimtext

Klartext

Entschlüsselungsfunktion

Verschlüsselungsfunktion

Mr(s) X

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 zu einer Zahl zu bestimmen.


Teil 5

Teil 5

Verschlüsselung mit modularer Potenz


Verschl sseln d modulares rechnen

Verschlüsseln d. modulares Rechnen

modulares Addieren

modulares Potenzieren

modulares Multiplizieren

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

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

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

x → [x + e]%n

x → [x * e]%n

x → [x ** e]%n

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

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

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

y → [y + d]%n

y → [y * d]%n

y → [z ** d]%n


Verschl sseln d modulares potenzieren

Verschlüsseln d. modulares Potenzieren

Codierung:

Umwandlung von Zeichen in Zahlen

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

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

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

Verschlüsselung:

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

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

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

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

Entschlüsselung:

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

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

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

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

Decodierung:

Umwandlung von Zahlen in Zeichen

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

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

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


Verschl sseln d modulares potenzieren1

Verschlüsseln d. modulares Potenzieren

Aufgabe:

Führe die erforderlichen Berechnungen selbst durch.

Verschlüsselung:

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

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

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

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

Entschlüsselung:

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

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

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

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

>>> 52 ** 37

3105444088679819357273546406651335246066988648897330641813635072

>>> 3105444088679819357273546406651335246066988648897330641813635072 % 77

24


Schwierigkeiten beim potenzieren

Schwierigkeiten beim Potenzieren

Aufgabe:

Führe das Verfahren mit modularer Potenz auch mit folgenden Daten durch. Welche Schwierigkeit tritt dabei auf?

(a)

Quelltext: ASTERIX

Codierung: wie oben

Blocklänge: 3

öffentlicher Schlüssel: (2008675, 2548873)

privater Schlüssel: (377911, 2548873)

(b)

Quelltext: ASTERIX

Codierung: wie oben

Blocklänge: 4

öffentlicher Schlüssel: (377911777, 1919016703)

privater Schlüssel: (626738065, 1919016703)


Schwierigkeiten beim potenzieren1

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

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

???


Schnelles potenzieren

Schnelles Potenzieren

So …

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

9

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

27

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

81

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

243

oder so?

43046721

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

9

·

9

·

9

·

9

·

9

·

9

·

9

·

9

81

·

81

·

81

·

81

6561

·

6561

43046721


Schnelles potenzieren1

Schnelles Potenzieren

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

9

·

9

·

9

·

9

·

9

·

9

·

3

81

·

81

·

81

·

3

6561

·

243

1594323

Darstellung in Tabellenform:


Schnelles modulares potenzieren

Schnelles modulares Potenzieren

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

·

3

%5

4

·

4

·

4

·

4

·

4

·

4

·

3

%5

1

·

1

·

1

·

3

%5

1

·

3

%5

3

Darstellung in Tabellenform:


Modulares potenzieren

Modulares Potenzieren

Bei modularen Potenzen kann man zuerst die Potenz berechnen und anschließend den modularen Rest.

[3 * 3 * 3 * 3 * 3 * 3]% 5 = [729]%5 = 4

Günstiger ist es, die Modulbildung aber nach jedem Rechenschritt durchzuführen.

[3 * 3 * 3 * 3 * 3 * 3]% 5 =

[[[[[3 * 3]%5 * 3]%5 * 3]%5 * 3]%5 * 3]%5 =

[[[[ 4 * 3]%5 * 3]%5 * 3]%5 * 3]%5 =

[[[ 2 * 3]%5 * 3]%5 * 3]%5 =

[[ 1 * 3]%5 * 3]%5 =

[ 3 * 3]%5 =

4


Schnelles modulares potenzieren1

Schnelles modulares Potenzieren


Schnelles modulares potenzieren2

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:

>>> modpot(11920, 2008675, 2548873)


Durchf hrung mit python3

Durchführung mit Python

Aufgabe:

Lade die Datei chiffriersystemModularePotenz.py (siehe inf-schule) herunter. Diese Datei enthält eine ganze Reihe von Funktionen zur Implementierung des RSA-Verfahrens.

Mit den Funktionen der Implementierung kannst du jetzt 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.


Durchf hrung mit cryptool

Durchführung mit CrypTool


Erzeugung der schl ssel

Erzeugung der Schlüssel

Beispiel:

p = 7; q = 11

n = 77

φ(n) = 60

z. B. e = 13

(13, 77)

d = 37

(37, 77)

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


Korrektheit des rsa verfahren

RSA-Schlüsselerzeugung:

Wähle zwei verschiedene Primzahlen p und q.

Berechne n = pq und (n) = (p-1)(q-1).

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

Bestimme d mit [cd]%(n) = 1.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(d, n)

"HALLO ..."

"HALLO ..."

Codierung

f(x, (e,n))

=

[xe]%n

f*(y, (d,n))

=

[yd]%n

Codierung

x0, x1, x2, ...

y0, y1, y2, ...

x0, x1, x2, ...

Klartext

Geheimtext

Klartext

RSA- Entschlüsselungsfunktion

RSA-Verschlüsselungsfunktion

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


Korrektheit des rsa verfahren1

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.

...

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


Korrektheit des rsa verfahren2

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


Sicherheit2

RSA-Schlüsselerzeugung:

Wähle zwei verschiedene Primzahlen p und q.

Berechne n = pq und (n) = (p-1)(q-1).

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

Bestimme d mit [cd]%(n) = 1.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(?, n)

???

???

Codierung

f(x, (e,n))

=

[xe]%n

f*(y, (d,n))

=

[yd]%n

Codierung

???

y0, y1, y2, ...

???

Klartext

Geheimtext

Klartext

RSA- Entschlüsselungsfunktion

RSA-Verschlüsselungsfunktion

Mr(s) X

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.


Geheimcodes knacken2

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, 59, 60, 0, 1, 31, 59, 0, 58, 1, 38, 38, 9, 60, 14

Entschlüsselung:

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

Decodierung:

Umwandlung von Zahlen in Zeichen

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


Geheimcodes knacken3

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 knacken4

Geheimcodes knacken

ö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


Angriff auf das rsa verfahren

RSA-Schlüsselerzeugung:

Wähle zwei verschiedene Primzahlen p und q.

Berechne n = pq und (n) = (p-1)(q-1).

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

Bestimme d mit [cd]%(n) = 1.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

privat. Schlüssel von B(ob)

(e, n)

(?, n)

???

???

Codierung

f(x, (e,n))

=

[xe]%n

f*(y, (d,n))

=

[yd]%n

Codierung

???

y0, y1, y2, ...

???

Klartext

Geheimtext

Klartext

RSA- Entschlüsselungsfunktion

RSA-Verschlüsselungsfunktion

Angriff auf das RSA-Verfahren

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 rsa verfahren

RSA-Schlüsselerzeugung:

Wähle zwei verschiedene Primzahlen p und q.

Berechne n = pq und (n) = (p-1)(q-1).

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

Bestimme d mit [cd]%(n) = 1.

A(lice)

B(ob)

öffentl. Schlüssel von B(ob)

pivat. Schlüssel von B(ob)

(e, n)

(?, n)

???

???

Codierung

f(x, (e,n))

=

[xe]%n

f*(y, (d,n))

=

[yd]%n

Codierung

???

y0, y1, y2, ...

???

Klartext

Geheimtext

Klartext

RSA- Entschlüsselungsfunktion

RSA-Verschlüsselungsfunktion

Sicherheit RSA-Verfahren

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.


Teil 6

Teil 6

Primzahlalgorithmen


Primzahltest

Primzahltest

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

>>> 2**2048

32317006071311007300714876688669951960444102669715484032130345427524655138867890893197201411522913463688717960921898019494119559150490921095088152386448283120630877367300996091750197750389652106796057638384067568276792218642619756161838094338476170470581645852036305042887575891541065808607552399123930385521914333389668342420684974786564569494856176035326322058077805659331026192708460314150258592864177116725943603718461857357598351152301645904403697613233287231227125684710820209725157101726931323469678542580656697935045997268352998638215525166389437335543602135433229604645318478604952148193555853611059596230656

>>> len(str(2**2048))

617

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 in der Regel nicht allzu viele Zahlen testen.


Primzahlen

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

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.


Ein einfaches testverfahren

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


Ein einfaches testverfahren1

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)


Laufzeitverhalten

Laufzeitverhalten

>>>

Primzahl: 11 Rechenzeit: 5.86666741164e-06

Primzahl: 101 Rechenzeit: 8.3809534452e-06

Primzahl: 1009 Rechenzeit: 1.50857162014e-05

Primzahl: 10007 Rechenzeit: 3.54793695847e-05

Primzahl: 100003 Rechenzeit: 0.000101968266917

Primzahl: 1000003 Rechenzeit: 0.000324342898329

Primzahl: 10000019 Rechenzeit: 0.00104817791088

Primzahl: 100000007 Rechenzeit: 0.00332500359683

Primzahl: 1000000007 Rechenzeit: 0.0105655886432

Primzahl: 10000000019 Rechenzeit: 0.0407208178693

Primzahl: 100000000003 Rechenzeit: 0.140259725747

Primzahl: 1000000000039 Rechenzeit: 0.447675891768

Primzahl: 10000000000037 Rechenzeit: 1.41919042783

Primzahl: 100000000000031 Rechenzeit: 4.55093566361

Primzahl: 1000000000000037 Rechenzeit: 14.3208156344

Primzahl: 10000000000000061 Rechenzeit: 45.2250185429

Primzahl: 100000000000000003 Rechenzeit: 144.197546336

...

Aufgabe:

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


Probabilistische testverfahren

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.


Miller rabin test

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 - 1

def 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


Laufzeitverhalten1

Laufzeitverhalten

>>>

Primzahl: 11 Rechenzeit: 0.000118730173807

Primzahl: 101 Rechenzeit: 0.000144990494602

Primzahl: 1009 Rechenzeit: 0.000217904789575

Primzahl: 10007 Rechenzeit: 0.000181866689761

Primzahl: 100003 Rechenzeit: 0.000280761940414

Primzahl: 1000003 Rechenzeit: 0.00031400638908

Primzahl: 10000019 Rechenzeit: 0.000371276237622

Primzahl: 100000007 Rechenzeit: 0.000415974655997

Primzahl: 1000000007 Rechenzeit: 0.000454527041845

Primzahl: 10000000019 Rechenzeit: 0.000569346104044

Primzahl: 100000000003 Rechenzeit: 0.000617117538682

Primzahl: 1000000000039 Rechenzeit: 0.000658184210563

Primzahl: 10000000000037 Rechenzeit: 0.000720482631172

Primzahl: 100000000000031 Rechenzeit: 0.000901511225589

Primzahl: 1000000000000037 Rechenzeit: 0.000982527108892

Primzahl: 10000000000000061 Rechenzeit: 0.00114316204993

Primzahl: 100000000000000003 Rechenzeit: 0.00111746045936

Primzahl: 1000000000000000003 Rechenzeit: 0.0011973588822

Primzahl: 10000000000000000051 Rechenzeit: 0.00138956208121

Primzahl: 100000000000000000039 Rechenzeit: 0.00151862876427

Primzahl: 1000000000000000000117 Rechenzeit: 0.00166445735422

Primzahl: 10000000000000000000009 Rechenzeit: 0.00163987322411

Primzahl: 100000000000000000000117 Rechenzeit: 0.0019804192991

Primzahl: 1000000000000000000000007 Rechenzeit: 0.0020670224847

Primzahl: 10000000000000000000000013 Rechenzeit: 0.00199578438042

Primzahl: 100000000000000000000000067 Rechenzeit: 0.00229358759284

Primzahl: 1000000000000000000000000103 Rechenzeit: 0.00245701618502

Primzahl: 10000000000000000000000000331 Rechenzeit: 0.00275649558813

Primzahl: 100000000000000000000000000319 Rechenzeit: 0.003038374989


Primfaktorzerlegung

Primfaktorzerlegung

260

2

*

2

*

5

*

13

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.


Aufgabe1

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.


Ein einfaches faktorisierungsverfahren

Ein einfaches Faktorisierungsverfahren

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

# Ü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]

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.


Laufzeitmessungen

Laufzeitmessungen

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()

testzahlen = [

11,

101,

1009,

10007,

100003,

1000003,

10000019,

100000007,

1000000007,

10000000019,

100000000003,

1000000000039,

10000000000037,

100000000000031,

1000000000000037,

10000000000000061,

100000000000000003,

1000000000000000003,

10000000000000000051,

100000000000000000039,

...]

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?


Zusammenh nge und prognosen

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

...


Fazit

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.


Lehrplan leistungsfach

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


Literaturhinweise

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


  • Login