6. Sichere Schlüsselübergabe mit RSA

Transkript

1 6. Sichere Schlüsselübergabe mit RSA Alice, Bob und Eve Die im letzten Kapitel erstellte Transnigma genügt bei einer Schlüssellänge von 64 Zeichen auch den allerhöchsten Sicherheitsansprüchen. Wenn es dann in einigen Jahren Rechner gibt, die zum Entschlüsseln nur noch einige Tage benötigen, dann wird die Schlüssellänge einfach auf 128 erhöht. Danach ist das Verfahren für einige Jahre wieder sicher. Wenn keine wirklich prinzipiell anderen Computer wie die heutigen gebaut werden, dann wird es eine Schlüssellänge N geben, die in absehbarer Zeit nicht verlängert werden muss. Erst etwas völlig Neues, wie etwa ein Quanten-Computer, kann dann dafür sorgen, dass man das Verfahren überdacht werden muss. Warum dann ein Kapitel 7, wenn das erlernte Verfahren angeblich so perfekt ist? Eine Bank, wie die Deutsche Bank, hat einige Hunderttausend Kunden. Mit jedem dieser Kunden muss sie Informationen über öffentliche Kanäle austauschen. Homebanking, um ein Beispiel zu nennen, läuft über das Internet und nicht, wie das nebenstehende Bild glauben machen will, durch Abgabe und Inempfangnahme von Bargeld bei der Bank. Wie soll hier die Schlüsselübergabe funktionieren? Muss jeder Kunde zur Bank laufen, um dort seine persönlichen Schlüssel in Empfang zu nehmen? Die Methode wäre sehr sicher. Ist das durchführbar? Die Online-Bank IngDiBa beispielsweise hat ihren Sitz in Frankfurt. Ein Kunde, der in Hamburg wohnt darf dann mehrmals im Jahr nach Frankfurt reisen... Wenn das zu anstrengen ist, dann könnte die Schlüssel ja auch über Telephon oder Briefpost verteilen. Aber: Ist das sicher? Damit ist das Ziel dieses Kapitels klar: Wir benötigen eine Methode, bei der eine Schlüsselübergabe sicher und bequem abläuft. Das roblem ist ein aradox, über das die Menschen schon sehr lange beschäftigt: Wenn zwei Menschen (Alice und Bob) sich ein Geheimnis mitteilen wollen, müssen sie sich zuvor bereits ein Geheimnis (den Schlüssel) mitgeteilt haben. Ist dies denn ohne persönlichen Kontakt möglich? Zwei Jahrtausende galt das aradox als unauflösbsar. Anfang letzten Jahrhunderts wurden sogar einige Beweise veröffentlicht, die auf vielen Seiten sorgfältig darlegten, dass ein derartiger Austausch unmöglich ist. Ist es wirklich unmöglich? 89

2 Ein Gedankenexperiment: Alice und Bob wollen ohne vorherigen persönlichen Kontakt geheime Informationen austauschen. Das roblem ist die neugierige Briefträgerin Eve. Sie öffnet mitunter die zuzustellenden Briefe und liest sie, um auf dem Laufenden zu sein. Daher besorgt sich Alice eine Kiste, die man mit zwei Vorhängeschlössern verschließen kann. Alice und Bob kaufen je ein Schloss. Den Schlüssel dazu geben sie nicht aus der Hand. Alice steckt den geheimen Brief in die Kiste und schließt mit ihrem Schloss (A) ab. Dann schickt sie die Kiste an Bob. Die Briefträgerin Eve ist verärgert, denkt sich aber, dass auch Bob die Kiste nicht öffnen kann. Das ist richtig. Daher befestigt nun Bob seinerseits sein Schloss (B) an der Kiste, schließt ab und übergibt die Kiste wieder Eve, die sie mit grimmigem Blick an Alice ausliefert. Die wiederum löst nun ihr eigenes Schloss und schickt sie an Bob zurück. Und Bob braucht nun nur seinen Schlüssel nehmen, um an den Brief zu kommen... Umständlich, - aber es funktioniert! Und schon glaubt man, nun endlich auch eine Lösung, die ohne die Kisten mit den Schlössern auskommt, gefunden zu haben. Es ist ja nicht schwer, die gedanklichen Schlösser durch Verschlüsselungen und die Schlüssel mit Schlüsselwörtern zu identifizieren. Aufgabe 1: Verschlüssele folgenden Text mit der Transnigma: Leider zu früh gefreut. Verwende dazu einen nur Dir bekannten Schlüssel. Das Ergebnis übergibst Du Deinem Nachbarn. Der verschlüsselt den Text ebenfalls wieder mit einem nur ihm bekannten Schlüssel und gibt ihn dann zurück. Den Text lädst Du in die Transnigma und drückst auf alles entschlüsseln. Das Ergebnis gibst Du wieder Deinem Nachbarn, der es dann mit seinem Schlüssel zu entschlüsseln versucht. Klappt das? Wenn nein: Warum nicht? Hier ein möglicher Ablauf: LEIDERZUFRUEHGEFREUT IROXVNLCMNDHETETCOZC ERNNTIVSKOSKZFHGCZA GENXLTEUXMIVJOYACADR FLJVEKGAMZEGELKKXZR Originaltext von Alice mit dem Schlüssel ABCD verschlüsselt von Bob mit dem Schlüssel EFGH verschlüsselt von Alice entschlüsselt von Bob entschlüsselt. Es klappt also nicht! Schade! Es wäre so einfach gewesen... 90

3 Kein Grund, die Flinte ins Korn zu werfen. Woran liegt es denn, dass am Schluss nicht der Originaltext rauskommt? Wir erinnern uns: Wenn man einen Geheimtext beispielsweise mit zwei verschiedenen Transpositionen verschlüsselt hatte, mussten, um an den Klartext zu kommen, die beiden Entschlüsselung in genau umgekehrter Reihenfolge ablaufen. War die erste Transposition mit Faktor 5 durchgeführt und die zweite mit Faktor 7, dann musste zuerst die Transposition mit Faktor 7 rückgängig gemacht werden und dann die mit Faktor 5. Und genau das geht, wie man leicht einsieht, in dem Kisten- Modell leider nicht. Aufgabe 2: Wie Aufgabe 1, aber als Verschlüsselung dient uns hier eine monoalphabitische Methode, wie zum Beispiel CaesarKomfortSuper Ist das die Rettung? (Damit kein Missverständnis entsteht: Es gibt sehr wohl monoalphabetische Verschlüsselungen, die eine Umkehrung der Entschlüsselungs-Reihenfolge nicht zulassen!) Die Kisten-Idee für eine sichere Schlüsselübergabe ist zwar mit den obigen Verfahren nicht realsierbar, - muss sie deswegen überhaupt nicht umsetzbar sein? Bei der Konstruktion der Software-Engima wurde eine Funktion (enigma) benutzt, die aus den Buchstaben des Schlüssels eine unendliche Folge von weiteren Buchstaben errechnete. Dies geschah in derartig komplexen Rechnungen, dass ohne Kenntnis der Funktion, eine Rekonstruktion des Gesamtschlüssels aus den Buchstaben des Schlüssels nicht oder nur sehr schwer möglich ist. Trotzdem liegt hier eine Schwäche des Systems: Woher kann man wissen, dass die geheimgehaltene Funktion nicht eines Tages verraten wird? Besser wäre also eine Funktion, von der man weiß, was sie tut, und die dennoch keinen Rückschluss vom Ergebnis auf die eingegebene Zahl zuließe. Eine Art Einwegfunktion. Die meisten Funktionen, die wir aus der Schule kennen, taugen dafür nicht. Die Funktion mal zwei kann sehr leicht durch geteilt durch zwei wieder rückgängig gemacht werden. Selbst bei der Quadratfunktion kann mit Hilfe eines Taschenrechners durch Wurzel ziehen die ursprüngliche Zahl wieder erhalten werden. Hellmann Die Amerikaner W.Diffie und M.Hellman (Jahrgang 1944 und 1945) verwandten ihre ganze Energie auf die Suche einer derartigen Funktion. Diffie 91

4 7 mod mod mod und mod mod zu mod mod HBS Kryptologie Die größte Hoffnung setzten sie auf die modulo -Funktionen. Wie wir weiter oben schon gesehen haben, wird mit z.b. 36 mod 5 der Rest bei der Division von 36 durch 5 bezeichnet, also 36 mod 5 = 1 mod 5 Dass dies tatsächlich eine Einwegfunktion ist wird klar, wenn man feststellt, dass 41 mod 5 ebenfalls 1 ergibt. Man kann daher nicht vom Ergebnis 1 auf die ursprüngliche Zahl 41 schließen. Leider kann das niemand, - auch der berechtigte Empfänger nicht. Es muss daher einen Weg geben, der es diesem Empfänger erlaubt, durch eine Zusatzinformation, die nur ihm nützt, die richtige Ursprungszahl zu finden. x Die Lösung ist eine Funktion, wie 17 mod 11. Weshalb und wie das funktioniert wollen wir im Folgenden darlegen. Eine Einwegfunktion x Die folgende Tabelle zeigt, weshalb das Ergebnis von 17 mod 11 nur sehr schwer auf das zugrunde liegende x schließen lässt: x x x Der besseren Verständlichkeit wegen sind die Zahlen sehr klein gewählt worden. x Ganz anders sähe es aus, wenn man etwa als Einwegfunktion verwenden würde. Von welchem x kommt das Ergebnis ? Dazu würde man auch mit Taschenrechner Stunden oder Tage brauchen. Wenn man weiß, dass das Ergebnis x = 2332 ist, dann kann man sich vorstellen, dass auch ein Computer einige Zeit braucht, bis er bei 2332 in der Tabelle angekommen ist. Aber auch die letzt genannten Zahlen sind noch immer nicht besonders groß. Was, wenn erst bei x = die gesuchte Zahl liegt? Das ist auch von Super-Rechnern in absehbarer Zeit nicht zu schaffen. Auf der anderen Seite ist es für heutige Computer recht einfach, A M zu x errechnen. Bleiben wir bei dem Beispiel Man erkennt sofort, 2332 dass man natürlich nicht zuerst 731 danach den Rest bezüglich bestimmen kann. Wieviele Stellen hat denn 731 ungefähr? x (Antwort: 4664.) Zum Glück kann man, sobald 731 groß zu werden droht, mit dem Rest bezüglich weiterrechnen. Man benötigt einen Algorithmus, der dem Computer sagt, wie er vorzugehen hat. Wir werden später darauf zurückkommen. x Halten wir fest: Mit A M hat man eine Einwegfunktion erhalten. A M kann man auch bei großen Zahlen relativ leicht errechnen, aber aus dem Ergebnis x von A M kann man nur sehr schwer oder überhaupt nicht auf x schließen. Diffie und Hellman hatten 1976 (genau vor 30 Jahren!) die zündende Idee, wie man mit einer solchen Funktion die oben erwähnte Kiste mit den beiden Schlössern simulieren kann: x x 92

5 mod HBS Kryptologie Im Tauschverzeichnis findet man eine exe-datei namens Einwegfunktion. Kopiere die Datei in Dein Homeverzeichnis und starte sie durch Doppelklick: Zuerst soll mit dem rogramm die Idee, die Diffie und Hellman hatten, erläutert werden. Danach werden wir uns den Quelltext etwas genauer ansehen, um den oben erwähnten Algorithmus kennenzulernen, mit dessen Hilfe man auch bei großen x Zahlen A M errechnen kann. Ganz oben ist die Einwegfunktion angegeben. Sie ist öffentlich und wir gehen davon aus, dass sie Eve bekannt ist. Alice und Bob haben einen privaten Schlüssel namens A und B Mit der Einwegfunktion und ihrem privaten Schlüssel berechnen sie α und β. Dann setzten sie sich ans Telephon und geben sich ihre Resultate an. Wir gehen davon aus, dass Eva das Telephon abhört und so auch die Ergebnisse α und β kennt. Aufgabe 3: Spiele die Situation mit selbst gewählten Zahle durch. Was fällt auf, wenn man bei Alice und Bob auf Schlüssel berechnen drückt? Ist das immer so? Wenn man davon ausgeht, dass die Zahlen sehr groß sind: Kann Eve durch die öffentlichen und abgehörten Informationen auch auf den Schlüssel kommen? Weshalb nicht? Teste mit kleinen Zahlen per Hand, dass Alice und Bob das selbe Ergebnis bekommen. 93

6 zuerst ) mod HBS Kryptologie Es ist nicht schwer, zu beweisen, dass gilt: x y (( a ) mod b) ) mod b = (( a y )mod b) x )mod b Sieht kompliziert aus, wenn man aber unsere konkreten Zahlen einsetzt, dann wirkt die Formel schon etwas freundlicher: 7 11 (( 17 ) mod 91) ) mod 91 = (( )mod 7 91) )mod 91 Der obige Satz besagt, dass die Reihenfolge, in der die Einwegfunktion angewandt wird, für das Ergebnis keine Rolle spielt. Und genau das haben wir bei obigem zwei- Schlösser-Vergleich gesucht. Weshalb nutzen Eve die abgehörten Ergebnisse nichts? Wer dies noch immer nicht so recht versteht, dem nützt vielleicht der von Simon Sing ( Geheime Botschaften ) stammende Vergleich: Alice, Bob und Eve haben alle einen Eimer gelber Farbe. Alice und Bob haben zusätzlich je eine weitere (Geheim-) Farbe, die nur sie selbst kennen. Beide rühren einen bestimmten Teil ihre Farbe zur gelben Farbe dazu und schicken sich die so gemischten Eimer. Alice hat dann den Eimer von Bob. Zu der Mischfarbe rührt sie den Rest ihre eigene Farbe dazu. Bob verfährt entsprechend. Die so erzeugt Mischfarbe (der gemeinsame Schlüssel ) ist bei beiden gleich. Eve kann unmöglich ebenfalls auf diese Mischfarbe kommen, da sie aus den abgefangenen Farbeimer die Geheimfarbe von Alice und Bob nicht extrahieren kann. Eine einmal zusammengerührte Farbe lässt sich eben nicht wieder in ihre Bestandteile zerlegen. Um in der Analogie zu bleiben: Farben zusammenrühren ist eine Einwegfunktion! Nun zu obigem rogramm: Im Tauschverzeichnis befindet sich der Torso des Quelltextes. Kopiere den Ordner Einwegfunktion_Huelle in das Homeverzeichnis und öffne dann die Datei project1.dpr mit Delphi. Wie man sieht ist die Oberfläche soweit in Ordnung und auch die Ereignisbehandlungs-Routinen, wie TForme1.Activate oder TForm1.Button3.Click sind fertig gestellt. Hierbei gibt es für uns nicht viel zu lernen, da sich das rogramm bis hier hin wie alle anderen, die wir vorher erstellt haben, programmieren lässt. Unter private wurde eine Funktion namens einweg deklariert: function einweg(m:int64; x:integer; modulo:integer):int64; Das scheint vernünftig zu sein, da man ja immer wieder Terme, wie (17 berechnen muss. Hier wäre m:= 17, x:= 9 und modulo:= Wie kann man den obigen Term möglichst einfach berechnen? Mit Sicherheit nicht 9 dadurch, dass man 17 ausrechnet! Der Einfachheit halber soll die Funktion einweg(17,9,11) da der Modulowert 11 im 9 Folgenden fest bleibt, als f(17 ) dargestellt werden. 94

7 Aufgabe 4: Überzeuge Dich, dass gilt: f ( 17 ) = f ( ) = f ( f ( 17 ) f ( 17 )) f (( 17 ) ) = f ( f ( 17 ) f ( 17 )) = f ( f ( 17 ) ) Damit wird der Algorithmus, mit dem man f(17 ) berechnen kann, klar: Wenn der Exponent von 17 ungerade ist, dann zerlege wie oben in Aufgabe 4.1 Wenn der Exponent von 17 gerade ist, dann zerlege wie oben in Aufgabe 4.2 Was man aus Aufgabe 4 noch erkennen kann ist, dass die Funktion f sich immer 9 1 wieder selbst aufruft, anders ausgedrückt: Beim Berechnen von f(17 ) wird f(17 ) und 8 1 f(17 ) aufgerufen. Der Vorgang wird solange durchgeführt, bis nur noch f(17 ) übrigbleibt. Man nennt ein solches Vorgehen Rekusion. Auch wenn man anfangs einige Mühe hat, den Vorgang zu durchschauen, so ist das rogrammieren der rekursiven Funktion einweg ausgesprochen einfach: 9 function TForm1.einweg(m:int64; x:integer; modulo:integer):int64; // rekursiv if x = 0 then result:= 1 else if odd(x) then result:= m*(einweg(m,x-1,modulo)) mod modulo // m^x=m*m^(x-1) else result:= (einweg(m*m mod modulo,x div 2,modulo)) mod modulo //m^x=(m*m)^2 Erläuterung: odd(x) hat den (boolschen) Wert true, falls x ungerade ist. Asymmetrische Schlüssel Auch wenn die oben beschriebene Methode zur sichern Schlüsselübergabe (ohne persönlichen Kontakt) ein Meilenstein in der Kryptologie darstellt, eine neue Methode zur Verschlüsselung selbst ist damit nicht beschrieben. Woran liegt das? Gehen wir das oben beschriebene Beispiel für Alice und Bob nochmals durch: Alice wählt eine zufällige Zahl, Bob wählt eine zufällige Zahl. Sie haben keinen Text vor sich, den sie verschlüsseln wollen. Sie wählen zufällige Zahlen und bekommten, nachdem sie Informationen ausgetauscht haben, abhörsicher eine zufällige Reihe 95

8 von Buchstaben, die allenfalls für einen Schlüssel einer anderen Verschlüsselungsmethode dienen. Auch der notwendige Kontakt in beide Richtungen ist alles andere als bequem. Ohne die Leistung von Hellman und Diffie schmälern zu wollen: Ein neues Verschlüsselungssystem haben sie nicht erfunden. Diffie muss gespürt haben, dass er ganz nahe an der Lösung war. Er forschte ein weiteres Jahr, ob sich ihr Verfahren nicht doch noch zu einem abhörsicheren Verschlüsselungssystem erweitern lassen würde. Dabei kam ihm der entscheidende Gedanke, dass ein vorheriger Kontakt (zum Austausch der abhörsicheren Informationen) nicht nötig ist, wenn die erson, der er eine Nachricht schicken will, einen Schlüssel veröffentlicht hat. Mit diesem ließe sich dann die Nachricht verschlüsseln. Allerdings sollte es sich auch hier um eine Einwegfunktion handeln. Mit anderen Worten: Nur der Empfänger ist in der Lage mit seinem persönlichen Schlüssel die Nachricht auch wieder zu entschlüsseln. In unserm Bild mit Kiste und Vorhängeschlössern würde das so aussehen: Man ermöglicht auf irgend eine Weise, dass jeder ganz leicht ein offenes Vorhängeschloss des Empfängers besorgen kann. Für den Absender ist es ganz leicht, das Vorhängeschloss einklicken zu lassen.ebenso leicht ist es für den Empfänger, die Kiste zu öffenen, da er als einziger den Schlüssel zu seinem Schloss hat. Der einzig Enttäuschte dabei ist der neugierige ostbote... Diffie war der Gedanke so wichtig, dass er ihn publizierte, - ohne die nötige Einwegfunktion präsentieren zu können. Ein taktischer Fehler, wie sich herausstellen sollte. Dennoch: Damit war die Idee der asymmetrischen Schlüssel geboren. Wie kann man sich die Realisierung des Verfahrens vorstellen? Hier eine Zusammenfassung der Anforderungen: Asymmetrische Verschlüsselungsverfahren verwenden zwei unterschiedliche Schlüssel K1 und K2, die folgenden Bedingungen genügen müssen: K1 wird (nur) zum Verschlüsseln eines Klartextes N verwendet; im folgenden wird der durch K1 erzeugte Chiffretext mit K1 [N] bezeichnet. K2 wird (nur) zum Entschlüsseln eines Chiffretextes K1 [N] verwendet; damit ist K2 [K1 [N]] = N. Trotz der ersten beiden Bedingungen kann K2 nicht aus K1 (bzw. nur mit sehr hohem Aufwand) hergeleitet werden. Im Bild: Bleibt die Frage offen: Wo soll man seinen öffentlichen Schlüssel ablegen? Heute gibt es sogenannte Trust-Center, bei denen man den Schlüssel hinterlegen kann. Von dort kann sie im rinzip jeder abfragen. Ist das denn sicher genug? Überlege, was passiert, wenn man vom Trust-Center einen falschen Schlüssel erhält! 96

9 Nachdem Diffie die Idee des asymmetrischen Schlüssels vorgestellt und als atent angemeldet hatte, begann die Suche nach einer tauglichen Einwegfunktion. (Kleine Ergänzung: Das atent ist inzwischen abgelaufen!) Man kann heute kaum mehr rekonstruieren, wie viele Wissenschaftler sich an der Suche beteiligt haben. Fest steht aber, dass es Ronald Rivest gelang, eine solche Funktion zu finden. Rivest war Informatiker und arbeitete im MIT-Labor für Informatik in Massachusetts.. (Shamir, Rivest, Adleman) Zusammen mit seinen Kollegen Adi Shamir hatten er ein Jahr lang alle erdenklichen Funktionen vorgeschlagen. Leonard Adleman, ein Mathematiker, war der Dritte im Bunde. Er hatte die Vorschläge seiner Kollegen auf mathematische Hieb-und Stichfestigkeit zu überprüfen. Dass die rimzahlen bei der gesuchten Einwegfunktion eine wichtige Rolle spielen würden, war wohl Allen klar. Im Jahr 1977 hatte Rivest die zündende Idee. Kollege Adelman konnte keinen Fehler finden und so wollte Rivest die Funktion unter den alphabetisch angeordneten Namen Adleman, Rivest und Shamir veröffentlichen. Sicherheitshalber fragte er seine Kollegen, ob sie mit der Veröffentlichung einverstanden wären. Adelman fand, über den Grund kann man nur spekulieren, dass sein Name nicht in der Autorenliste erscheinen sollte. War es falsche Bescheidenheit oder eher die Befürchtung, dass die Entdeckung unbedeutend sein könnte? Fest steht ledigliche, dass Rivest Adelman überredete, dass der Name Adelman wenigstens an letzter Stelle der Autorenliste erscheinen sollte: Rivest, Shamir, Adelman, kurz: RSA. Etwas Mathematik... Bevor die Idee von Rivest dargelegt und programmiert werden kann, müssen einige mathematische Voraussetzungen dargestellt werden. Beginnen wir beim dem noch 97

10 sehr einfachen roblem des ggt (größter gemeinsamer Teiler). Schon in Klasse 6 beschäftigen sich die Schüler mit der Frage: Was ist der ggt von 12 und 18? In Kurzschreibweise: ggt(18,12)=?? Richtig! ggt(18,12)= 6. Für die Berechnung des ggt zweier Zahlen a und b gibt es einen sehr einfachen Algorithmus: ggt(18,12) = ggt(12, 18 mod 12) = ggt(12,6) = ggt(6, 12 mod 6) = ggt(6,0) = 6 Aufgabe 5: Beweise, dass für alle natürlichen Zahlen a und b gilt: ggt(a,b) = ggt(b, a mod b). Die obige Behauptung heißt übrigens Euklidischer Algorithmus! (Lösung S.162) Siehe auch HTUhttp://de.wikipedia.org/wiki/Euklidischer_AlgorithmusUTH Danach ist eine (rekursives) Function in Delphi schnell geschrieben: function TForm1.ggT(a,b:int64):int64; if b= 0 then result:=a else result:= ggt(b,a mod b) Leider sind wir noch nicht am Ende, was die mathematischen Voraussetzungen für RSA angeht. Man benötigt für die Entschlüsselung mit dem privaten Schlüssel eine zur zum öffentlichen Schlüssel e inversen Schlüssel d, sodass gilt e*d=1 mod m. Man beachte: m ist nicht öffentlich und wird mit m = (p-1)*(q-1) berechnet. Mit dem erweiterten euklidischen Algorithmus findet man nicht nur den ggt zweier Zahlen a und b, man kann sogar zwei passende Zahlen u und v finden, sodass gilt: Erweiterter euklidischer Algorithmus: Ist x = ggt(a,b), dann gibt es zwei ganze Zahlen u und v, so dass gilt: u*a + v*w = x Für RSA ist nur der Fall x = 1 interessant. Ein Beispiel: ggt(44,35) = 1. Durch probieren findet man 4*44 + (-5)*35 = 1, also u = 4 und v =

11 Wenn die Zahlen größer werden, dann ist die robiermethode nicht sehr sinnvoll. Man benötigt daher, wie beim gewöhnlichen euklidischen Algorithmus ein Verfahren, das uns algorithmisch zum Ziel führt. Da das Verfahren am besten erkannbar wird, wenn man den Beweis notiert, werden wir genau dies jetzt tun: Beweis für den erweiterten euklidischen Algorithmus: Seien a B0B, b und 1 = ggt(a, b) = ggt(b, a mod b) mit der Darstellung 1 = u'b + v'(a mod b) Zwischenbehauptung: Es gibt u,v mit: 1 = ua + vb Setze u = v' und v = u' v'(a div b) dann gilt: 1 = ggt(a,b) = u'b + v'(a mod b) = u'b + v'(a (a div b) b) = u'b + v'a v'(a div b) b = v'a + (u' v'(a div b)) b = ua + vb (Die Operation div bezeichnet die ganzzahlige Division, z.b. 17 div 5 = 3). Jetzt wird klar, wie der Algorithmus aussehen muss. Auch das ist ein klarer Fall für eine rekursiv formulierte function: function TForm1.ggT_erw(a,b:int64; var u,v:int64):int64; var u0, v0: int64; if b= 0 then result:=a;u:=1; v:=0; end else result:= ggt_erw(b,a mod b,u0,v0); u:= v0; v:= u0-(a div b)*v0; Und noch etwas Zahlentheorie... Zunächst sei eine Funktion j(n) für eine natürliche Zahl n definiert als die Anzahl der zu n teilerfremden natürlichen Zahlen, die nicht größer als n sind. Dann gilt zum Beispiel j(14) = 6, da 1, 3, 5, 9, 11 und 13 keinen gemeinsamen Teiler mit 14 haben. 99

12 b b mod mod mod mod HBS Kryptologie Falls n eine rimzahl ist, ist j(n) = n-1 einfach zu berechnen, da alle natürlichen Zahlen kleiner n keinen gemeinsamen Teiler größer 1 mit n haben. Wenn n = pq mit p,q sind prim, dann ist j(n) = (p-1)(q-1) =: m. Ist n keine rimzahl und sind die rimfaktoren von n nicht bekannt, so kann j(n) für große n nur mit unzumutbarem Aufwand berechnet werden. Bereits im 18. Jahrhundert bewies der Schweizer Mathematiker Euler einen Satz, der erst durch das RSA-Verfahren eine praktische Anwendung gefunden hat. Dieser Satz besagt, dass für zwei teilerfremde natürliche Zahlen n und b gilt: j(n) m b mod n = 1, im Spezialfall n=pq also: b mod n =1 Wird diese Gleichung mit k potenziert und anschließend mit b multipliziert, so ergibt sich für b < n: km n = b Mit dem obigen erweiterten euklidischen Algorithmus gibt es für eine zufällig gewählte Zahl e mit ggt(e, m) = 1 eine Zahl d und eine Zahl v mit de + vm = ggt(e,m) = 1, also k m + 1 = e d (1) Auf diese Weise erhält man ergibt eine Formel, die als Verschlüsselungsalgorithmus angewandt werden kann: ed e d n = (b mod n) mod n = b Wird b als ein Teil der zu verschlüsselnden Nachricht, e und n als öffentliche und d als geheimer Schlüssel interpretiert, so ist c = b b = c e d n die Verschlüsselungsfunktion und n die Entschlüsselungsfunktion. Jetzt bleibt nur noch die Berechnung der Schlüssel n, e und d. Setzt sich, wie hier vorausgesetzt die Zahl n aus zwei verschiedenen zufälligen rimzahlen p und q zusammen (n = p q), so ist j(n) = ( p - 1 ) ( q - 1 ) = m sehr leicht zu berechnen, wenn p und q bekannt sind. Falls p und q nach der Schlüsselerzeugung nicht mehr bekannt sind, kann m nur noch mit großem Aufwand errechnet werden: Da n keine rimzahl ist, kann man entweder alle Zahlen kleiner n auf gemeinsame Teiler mit n prüfen (was bei genügend hohen Zahlen selbst für Großrechner zu aufwendig ist), oder man versucht n in seine Faktoren zu zerlegen, was bei geeigneter Wahl von p und q ebenfalls sehr aufwendig ist. Damit die ganze Rechnung etwas übersichtlicher wird, schreiben wir ein rogramm, das bei Vorgabe zweier rimzahlen p und q den öffentlichen Schlüssel n und den privaten Schlüssel m berechnet. Danach soll man eine Zahl e wählen können, für die gilt: ggt(e,m) =

13 Mit den vorhandenen Werten soll dann d berechnet werden, mit dessen Hilfe der Empfänger die Nachricht wieder entschlüsseln kann. Hier ein Ausschnitt aus dem Quelltext des rogramms: function TForm1.RSA_invers(e,m:int64):int64; var d,s: int64; ggt_erw(e,m,d,s); if d<0 then d:=d + m; result:= d; procedure TForm1.Button1Click(Sender: TObject); p:= strtoint64(edit1.text); q:= strtoint64(edit2.text); n:= p*q; m:=(p-1)*(q-1); edit3.text:= inttostr(n); edit4.text:= inttostr(m); label6.visible:=true; label6.caption:= 'n:= '+ inttostr(n); label7.visible:=true; label7.caption:= 'm:= '+ inttostr(m); label8.visible:=true; label9.visible:=true; edit5.visible:=true; button2.visible:=true; 101

14 procedure TForm1.Button2Click(Sender: TObject); e:= strtoint64(edit5.text); if ggt(e,m)=1 then label13.visible:= true ; label13.caption:='"e" ist in Ordnung!'; label11.visible:=true; label12.visible:=true; button3.visible:=true; label10.visible:=true; edit6.visible:=true; end else label13.visible:= true ; label13.caption:='bitte ein anderes "e" wählen!'; procedure TForm1.Button3Click(Sender: TObject); d:= RSA_invers(e,m); edit6.text:= inttostr(d); procedure TForm1.neueRechnung1Click(Sender: TObject); label6.visible:=false; label7.visible:=false; label8.visible:=false; label9.visible:=false; e:=0;d:=0;edit5.visible:=false;button2.visible:=false; label11.visible:=false; label12.visible:=false; label13.visible:=false; edit3.text:='';edit4.text:=''; button3.visible:=false; edit6.visible:=false; label10.visible:=false; edit1.setfocus; Aufgabe 6: Versuche mit Hilfe des Quelltextes den Ablauf und die Logik des rogramms zu verstehen und programmiere danach ein rogramm RSA invers, das die beschriebenen Funktionen hat. 102

15 Lösung Aufgabe 5: Man zeigt zunächst Hilfssatz: Seien a B0B, b. Dann gilt für alle d 1. d a d b d (a mod b) sowie 2. d b d (a mod b) d a Beweis: 1. Es sei a mod b = r. Dann ist a r durch b teilbar. Also ist a r auch durch d teilbar. Da a durch d teilbar ist, muss auch r durch d teilbar sein, also gilt d (a mod b). 2. Wiederum sei a mod b = r. Dann ist a r durch b und damit durch d teilbar. Da r durch d teilbar ist, muss auch a durch d teilbar sein, d.h. es gilt d a. Und nun zum Satz: Seien a B0B, b. Dann gilt ggt(a, b) = ggt(b, a mod b) Beweis: Es wird gezeigt, dass ggt(a, b) und ggt(b, a mod b) sich gegenseitig teilen und daher gleich sein müssen. Sei d = ggt(a, b). Dann gilt d a und d b und nach dem Hilfssatz d (a mod b) Nach Definition des ggt gilt d b d (a mod b) d ggt(b, a mod b) Sei nun umgekehrt d = ggt(b, a mod b). Dann gilt d b und d (a mod b) und nach dem Hilfssatz d a Nach Definition des ggt gilt d a d b d ggt(a, b) qed. 103

16 Verschlüsseln und Entschlüsseln mit RSA Nun sind alle Voraussetzungen geklärt und man kann endlich an der Umsetzung der Idee arbeiten. Gleich an dieser Stelle soll klargestellt werden, dass unser mit Delphi geschriebenes rogramm, keinesfalls heutigen Sicherheitsansprüchen genügen wird. Es soll lediglich die Idee, die hinter RSA steht, transparent machen. Woran liegt das? Wie wir schon mehrfach gesehen haben, kennt Delphi als größte Integerwerte int64. Und das sind, wie der Name schon sagt, eben genau 64 Bit. 64 Bit aber heißt maximal 18 Stellen für n. Eine 18-stellige Zahl, die aus zwei rimzahlen pq zusammengesetzt ist, zerlegt ein heutiger Computer in wenigen Sekunden! Damit man sich wirklich sicher fühlen kann, sollte n 512 Bit (ca. 154 Stellen) haben! Das bedeutet, dass die rimzahlen p und q knapp 80 Stellen haben müssen (n = pq). Es ist allerdings deutlich einfacher, bei einer solch großen Zahl p und q nachzuweisen, dass sie (sehr wahrscheinlich!) prim sind, als ihre Zerlegung zu finden. Natürlich bekommt man Delphi auch dazu, mit viel größeren Werten zu rechnen. Das ist dann allerdings etwas mehr Aufwand... Die Situtation: Alice will Bob eine Nachricht schicken und verwendet dessen öffentliche Schlüssel e und n. Eine Gefahr besteht darin, dass Alice einen Schlüssel bekommt, der ihr von Eve untergeschoben wurde. Da Eve dann natürlich auch den privaten Schlüssel hat, könnte sie die Nachricht abfangen. Um derartige robleme zu vermeiden, hat man die schon erwähnten Trust-Center eingerichtet. Frage: Wie könnten Bob und Alice ihre Schlüssel gefahrlos austauschen? 104

17 mod HBS Kryptologie Das Verschlüsselungsprogramm zu schreiben, ist nun nach all den Vorbereitungen nicht mehr schwer. Hier ein Teil des Quelltextes: function TForm1.InASCIIundVerschl(Zeile:string):string; var i,l,zahl1,zahl2,lm: word; Zweierblock: cardinal; HS,Mo:string; result:=''; HS:=''; L:=length(Zeile); Mo:=inttostr(n); // Anzahl der Dezimalstellen von n LM:=length(Mo); i:=1; while i<=l do Zahl1:=ord(Zeile[i]); Zahl2:=ord(Zeile[i+1]); Zweierblock:=Zahl2*256+Zahl1; Zweierblock:= einweg(zweierblock,e,n); str(zweierblock:lm,hs); // Anzahl der Zeichen von HS: LM result:=result+ HS; i:=i+2; L:=length(result); for i:=1 to L do if result[i]=' ' then result[i]:='0'; //die leeren Stellen werden mit 0 aufgefüllt. procedure TForm1.verschluesseln1Click(Sender: TObject); var I,J : Integer; Zeile: string; e:=strtoint64(edit2.text); n:=strtoint64(edit1.text); j:= Memo1.Lines.Count; for i:=0 to J-1 do Zeile:=Memo1.Lines[I]; Memo2.Lines[I]:=InASCIIundVerschl(Zeile); Aufgabe 7: Versuche den Quelltext nachzuvollziehen und schreibe danach das rogramm Verschlüsseln selbst. Einige Hinweise, um die Arbeit zu erleichtern: Wenn n zum Beispiel 12 Stellen hat, dann kann bei der Verschlüsselung der e Zahlenwert b n durchaus ebenfalls 12 Stellen haben. 105

18 b ist hier der Zahlenwert, der bei der Umwandlung zweier Buchstaben entsteht. Gewöhnlich wird für e aber selten ein großer Wert verwendet, da die Rechnung sonst unnötig aufwändig wird, die Sicherheit des Verfahrens aber von einem großen e nicht profitiert. Um nun bei großem n nicht dauernd unzählige Nullen an den Anfang stellen zu müssen, verwendet man nicht zwei Zeichen in einem Block, um b zu berechenen, sondern vielleicht 4, 8, 16, 32 oder gar 64 Zeichen. Und nun bekommt Bob die verschlüsselte Nachricht von Alice, die aus lauter Ziffern besteht. Zwar besitzt Bob den privaten Schlüssel m = (p-1)(q-1), er benötigt jedoch zum Entschlüsseln das oben beschriebene d. Wie er dieses d aus e und m bestimmt, haben wir weiter oben schon dargelegt. Interessanter ist der Befehl entschlüsseln. Wir wissen ja schon, dass wir die Zahlen in solche Blöcke einteilen müssen, die die gleiche Länge haben, wie n Ziffern besitzt. Im unten dargestellten Beispiel sind es zum Beispiel 6-er Blöcke. 106

19 mod HBS Kryptologie Dann ist wieder die Einwegfunktion dran: b = c n c ist der Zahlenblock und d übernimmt die Rolle von e. Und hier ist der Quelltext in Auszügen: function TForm1.EntschlUndInText(Zeile:string):string; var L,Zahl1,Zahl2,LM: word; Zweierblock:cardinal; HS,Mo:string; C1,C2: char; I,K:integer; L:=Length(Zeile); Mo:=inttostr(n);LM:=Length(Mo); result:=''; HS:=''; I:=-LM+1; While I<=L-LM do I:=I+LM; HS:=Copy(Zeile,I,LM); //LM-lange Teilstrings werden hier von Zeile auf HS kopiert Val(HS,Zweierblock,K); Zweierblock:=einweg(Zweierblock,d,n); Zahl2:=Zweierblock div 256; Zahl1:=Zweierblock mod 256; C1:=chr(Zahl1);C2:=chr(Zahl2); result:=result+c1+c2; {for L} procedure TForm1.dfrEntschlsselungberechnen1Click(Sender: TObject); e:= strtoint64(edit2.text); m:= (strtoint64(edit1.text)-1)*(strtoint64(edit3.text)-1); n:= strtoint64(edit1.text)*strtoint64(edit3.text); d:=rsa_invers(e,m); label4.caption:='d= '; edit3.text:=inttostr(d); procedure TForm1.entschlsseln1Click(Sender: TObject); var I,J : Integer; Zeile: string; j:= Memo1.Lines.Count; for i:=0 to J-1 do Zeile:=Memo1.Lines[I]; Memo2.Lines[I]:=EntschlUndInText(Zeile); d Um den Vorgang des Verschlüsselns und des Entschlüsselns mit RSA etwas transparenter zu machen, werden wir ein einfaches Beispiel mit kleinem Schlüssel e Schritt für Schritt von Hand durchrechnen. 107

20 mod mod mod mod HBS Kryptologie Mit dem rogramm RSA-invers errechnen wir für den Fall p = 257 und q = 263 die Schlüssel n und m. Dann wählen wir ein kleines e und lassen uns damit d errechnen: In Kapitel 4 (S.91) haben wir bereits die Umrechnung des Wortes Ball durchgeführt: Ba ll = Zunächst muss also e c = b n berechnet werden. Wir werden uns hier nur um die Buchstaben Ba kümmern. 3 c = mod = (Man rechnet zuerst mod = und multipliziert das Ergebnis mit und sehen uns das Ergebnis mod an.) Will man wieder entschlüsseln, so muss man d b = c n berechnen, also: b = Leider ist d hier schon so groß, dass man die Aufgabe dem Rechner übergeben muss. Und der erhält b = 24898!! Man mag hier kritisieren, dass für eine Rechnung per Hand, die rimzahlen p und q viel zu groß gewählt wurden. Leider ist dies jedoch nicht zu vermeiden, wenn man Blöcke aus zwei Buchstaben zusammenfassen will, denn man bekommt dann e 256*256 = Möglichkeiten. Eine Rechnung mit b 15 (p=3,q=5) kann aber nur 15 verschiedene Ergebnisse haben. Eine Möglichkeit wäre, nur Zeichen für Zeichen in ASCII zu verwandeln. Dann muss n nur größer als 256 sein (z.b.: p= 17 und q= 19). Im Moment ist das alles noch zu umständlich. Deshalb schreiben wir ein rogramm, dass rimzahlen p und q zufällig aussucht und den Benutzer (Bob) eine Zahl e aussuchen lässt und gleich noch prüft, ob die Bedingung ggt(e,m) = 1 erfüllt ist. Dann soll man zu Alice gehen können und ihr beim Verschlüsseln zusehen können. Zum Schluss bekommt im letzten Fenster Bob die verschlüsselte Nachricht und entschlüsselt den Text mit seinem privaten Schlüssel. Das ganz kann dann vielleicht so aussehen: 108

21 109

22 Wir benötigen also 3 Formulare und 3 Units. Unit1: (in den neuen Teilen) function TForm1.rimTest(zahl:int64): boolean ; var k: longword; k:=2; if zahl mod k = 0 then result:=false; exit; end else k:=3; while k*k <= zahl do if zahl mod k = 0 then result:=false; exit; end //ist t nichprim else k:=k+2; //of while result:=true; 110

23 function TForm1.ggT(a,b:int64):int64; if b= 0 then result:=a else result:= ggt(b,a mod b) function TForm1.ggT_erw(a,b:int64; var u,v:int64):int64; var u0, v0: int64; if b= 0 then result:=a;u:=1; v:=0; end else result:= ggt_erw(b,a mod b,u0,v0); u:= v0; v:= u0-(a div b)*v0; function TForm1.RSA_invers(e,m:int64):int64; var d,s: int64; ggt_erw(e,m,d,s); if d<0 then d:=d + m; result:= d; procedure TForm1.pwhlen1Click(Sender: TObject); var Test:boolean ; randomize; Test:=false; while Test=false do p:=random(100000); //mit größeren p und q wird im Folgenden der Test:=rimTest(p); //Bereich von int64 verlassen edit1.text:=inttostr(p); procedure TForm1.qwhlen1Click(Sender: TObject); var Test:boolean ; randomize; Test:=false; while Test=false do q:=random(100000); //s.o. Test:=rimTest(q); 111

24 edit2.text:=inttostr(q); edit3.visible:=true;edit4.visible:=true; label3.visible:=true;label4.visible:=true; n:=p*q; m:=(p-1)*(q-1) ; edit3.text:=inttostr(n); edit4.text:=inttostr(m); procedure TForm1.e1Click(Sender: TObject); e:=random(100000);//e ist Exponent und muss nicht groß sein.. while ggt(e,m)<>1 do e:=random(100000); end ; edit5.visible:=true;label5.visible:=true; edit5.text:=inttostr(e); label7.visible:= true;label8.visible:= true; procedure TForm1.dbe1Click(Sender: TObject); label6.visible:=true;label9.visible:=true; label10.visible:=true; label11.visible:=true; edit6.visible:=true; d:= RSA_invers(e,m); edit6.text:= inttostr(d); procedure TForm1.ZuAlice1Click(Sender: TObject); Form2.edit1.Text:=inttostr(n);//Bob sendet die öffentlichen Schlüssel "n" Form2.edit2.text:=inttostr(e);//und "e" an Alice (Form2) //Bei der Gelegenheit speichert Bob Form3.edit1.Text:= inttostr(d);//den errechnete geheime Schlüssel "d", Form3.edit2.Text:=inttostr(m);//den geheime Schlüssel "m" Form3.edit3.text:=inttostr(e);//den öffentl.schlüssel "e" und Form3.edit4.Text:=inttostr(n);//"n" auf seinem Computer. Form2.Show;//Hier kann man Alice bei der Verschlüsselung zuschauen

25 Unit 2: function TForm2.einweg(m:int64; e:int64; modulo:int64):int64; // rekursiv if e = 0 then result:= 1 else if odd(e) then result:= m*(einweg(m,e-1,modulo)) mod modulo // m^e=m*m^(e-1) else result:= (einweg(m*m mod modulo,e div 2,modulo)) mod modulo //m^e=(m*m)^2 function TForm2.InASCIIundVerschl(Zeile:string):string; var i,l,zahl1,zahl2,lm: word; Zweierblock:cardinal; HS,Mo:string; result:=''; HS:=''; L:=length(Zeile);Mo:=inttostr(n); LM:=length(Mo); i:=1; while i<=l do Zahl1:=ord(Zeile[i]); Zahl2:=ord(Zeile[i+1]); Zweierblock:=Zahl2*256+Zahl1; Zweierblock:= einweg(zweierblock,e,n); str(zweierblock:lm,hs); result:=result+ HS; i:=i+2; L:=length(result); for i:=1 to L do if result[i]=' ' then result[i]:='0'; procedure TForm2.verschluesseln1Click(Sender: TObject); var I,J : Integer; Zeile: string; e:=strtoint64(edit2.text); n:=strtoint64(edit1.text); j:= Memo1.Lines.Count; for i:=0 to J-1 do Zeile:=Memo1.Lines[I]; Memo2.Lines[I]:=InASCIIundVerschl(Zeile); Form3.Memo1.Lines[I]:=InASCIIundVerschl(Zeile); procedure TForm2.zuBob1Click(Sender: TObject); 113

26 Form3.show; //Hier kann man Bob beim Entschlüsseln beobachten..... procedure TForm2.ErstesFeldlschen1Click(Sender: TObject); var i,j:word; j:=0; while j<10 do for i:=0 to 500 do Memo1.Lines[I]:=''; j:=j+1; procedure TForm2.ZweitesFeldlschen1Click(Sender: TObject); var i,j:word; j:=0; while j<10 do for i:=0 to 500 do Memo2.Lines[I]:=''; j:=j+1; procedure TForm2.UnteresFeldhochkopieren1Click(Sender: TObject); Memo1.Text:= Memo2.Text; procedure TForm2.Beenden1Click(Sender: TObject); Form2.ZweitesFeldlschen1Click(Sender); close; 114

27 Unit 3: function TForm3.EntschlUndInText(Zeile:string):string; var L,Zahl1,Zahl2,LM: word; Zweierblock:cardinal; HS,Mo:string; C1,C2: char; I,K:integer; L:=Length(Zeile); d:=strtoint64(edit1.text); m:= strtoint64(edit2.text); e:=strtoint64(edit3.text); n:=strtoint64(edit4.text); Mo:=inttostr(n);LM:=Length(Mo); result:=''; HS:=''; I:=-LM+1; While I<=L-LM do I:=I+LM; HS:=Copy(Zeile,I,LM); Val(HS,Zweierblock,K); Zweierblock:=einweg(Zweierblock,d,n); Zahl2:=Zweierblock div 256; Zahl1:=Zweierblock mod 256; C1:=chr(Zahl1);C2:=chr(Zahl2); result:=result+c1+c2; {for L} function TForm3.ggT_erw(a,b:int64; var u,v:int64):int64; var u0, v0: int64; if b= 0 then result:=a;u:=1; v:=0; end else result:= ggt_erw(b,a mod b,u0,v0); u:= v0; v:= u0-(a div b)*v0; function TForm3.einweg(m:int64; e:int64; modulo:int64):int64; // rekursiv if e = 0 then result:= 1 else if odd(e) then result:= m*(einweg(m,e-1,modulo)) mod modulo // m^e=m*m^(e-1) else result:= (einweg(m*m mod modulo,e div 2,modulo)) mod modulo //m^e=(m*m)^2 procedure TForm3.entschlsseln1Click(Sender: TObject); var I,J : Integer; Zeile: string; 115

28 j:= Memo1.Lines.Count; for i:=0 to J-1 do Zeile:=Memo1.Lines[I]; Memo2.Lines[I]:=EntschlUndInText(Zeile);.. procedure TForm3.ErstesFeldlschen1Click(Sender: TObject); var i,j:word; j:=0; while j<10 do for i:=0 to 500 do Memo1.Lines[I]:=''; j:=j+1; procedure TForm3.ZweitesFeldlschen1Click(Sender: TObject); var i,j:word; j:=0; while j<10 do for i:=0 to 500 do Memo2.Lines[I]:=''; j:=j+1; procedure TForm3.UnteresFeldhochkopieren1Click(Sender: TObject); Memo1.Text:= Memo2.Text; procedure TForm3.Beenden1Click(Sender: TObject); Form3.ErstesFeldlschen1Click(Sender); Form3.ZweitesFeldlschen1Click(Sender); close; 116

29 Sehr lange Zahlen (Very long integer: VLInt) Bevor wir uns mit dem Wissen um Transnigma und RSA eine RSA-Transnigma basteln, wird es Zeit für eine ernüchternde Information: Selbst ein schwacher Rechner benötigt für die Zerlegung einer 18-stelligen Zahl n (und mehr können wir ja mit int64 nicht erreichen) in die zwei rimfaktoren p und q kaum mehr als eine halbe Stunde! Zwar ist mit den obigen Ausführungen das rinzip von RSA nun (hoffentlich!) klar. Auch wissen wir, wie man mit Delphi RSA Ver-und Entschlüsselungsprogramme schreibt. Was nützen uns jedoch diese Kenntnisse, wenn ein Angriff auf die Methode in wenigen Minuten zum Ziel führt? Konsequenz: Wir benötigen in Delphi lange Zahlen oder besser sehr lange Zahlen. Was Delphi nicht selbst bietet (mit Einschränkungen maximal 64 Bit, also 19 Dezimalstellen), muss mit den vorhanden Strukturen selbst programmiert werden. Sie kennen das von unzähligen functions und procedures, die Sie schon geschrieben haben. Eine erste Idee wäre, dem rozessor genauer auf die Register zu schauen. Wie haben die rozessoren die Erweiterung von 8 Bit auf 16 Bit und wie von 16 auf 32 Bit geschafft? Wie macht es Delphi mit der Erweiterung von Integer auf int64? Da wir diese Methode nicht wählen werden, ist es nicht sinnvoll, sehr viel Zeit auf eine mögliche Implementation in Delphi zu verwenden. Stellen Sie sich einfach vor, ein beliebiges Gerät kann mit 8 Bit-Zahlen rechnen. Für das Addieren heißt das konkret, dass etwa das Ergebnis = berechnet werden kann. Hat man nun zwei 16-Bit-Zahlen zu addieren, so geht man folgendermaßen vor: Teile die Zahl in zwei 8-Bit-Zahlen mit Namen Low und High. Addiere zunächst die beiden Low-Zahlen. Bei einem Übertrag von 1 addiere zu einer der High-Zahlen 1. Danach werden die High-Zahlen addiert. Fertig! Ein Beispiel: (dezimal: ) High Low High Low Aufgabe 8: Berechnen Sie nach der obigen Angaben das Ergebnis der 16-Bit Addition! Zur Erinnerung: Im Dualsystem ist 1 +1 = 10 (Ergebnis: ; dezimal: ) Zugegebenermaßen wird die Sache bei der Multiplikation etwas komplizierter. Wenn man sich aber an die Methode der schriftlichen Multiplikation erinnert, dann wird klar, das auch die 16-Bit-Multiplikation durch mehrfachen 8-Bit-Multiplikation und anschließender Addition (wie oben beschrieben) zu schaffen ist. 117

30 Schwierig scheint die Sache nun wirklich nicht zu sein. Weshalb suchen wir noch nach besseren Methoden? Gehen wir von int64-zahlen aus, so hätten wir danach 128-Bit-Zahlen. Das sind 38 Dezimalstellen. Nicht gerade beeindruckend! Aber auch 256-Bit genügen heutigen Anforderungen nicht mehr. Will man gar für die Zukunft gewappnet sein, so wären mindestens 1024 Bit (308 Dezimalstellen) das Maß aller Dinge. Man müsste das Verfahren daher mindestens vier Mal anwenden. So verliert eine anfangs gute Idee an Attraktivität. Die Geschwindigkeit bei einer solchen Vierfach-Schachtelung wird ebenfalls nicht berauschend sein. (Bemerkung am Rande: Die int64 Nutzung ist in Delphi übrigens nicht vollständig implementiert. Beispielsweise dürfen die Variablen einer for-schleife keine int64- Variablen sein.) Für die rogrammiersprachen C# und C++ findet man im Internet viele Ideen. (Beispielsweise: HTUhttp:// ) Neben dem oben beschriebenen Verfahren sind sogenannte ointer hoch im Kurs. Um zu verstehen, was ointer (Zeiger) sind, lesen Sie den kurzen Text in Wikipedia: HTUhttp://de.wikibooks.org/wiki/rogrammierkurs:_Delphi:_ointerUTH Vereinfacht formuliert sind ointer im rinzip Integer-Zahlen, die auf bestimmte Stellen im Speicher zeigen. Mit ihrer Hilfe ist es möglich, an den Inhalt der Stelle zu kommen, auf die gezeigt wird. In Delphi haben ointer für den rogrammierer eher eine untergeordnete Rolle, aber Objekte und Strings sind auch hier eigentlich nur ointer auf einen Bereich im Speicher. Hierbei wird der Zugriff allerdings von Delphi verwaltet. In anderen Sprachen, wie C# und C++, ist die Anwesenheit von ointern viel offensichtlicher. So ist es nicht verwunderlich, dass in diesen rogrammiersprachen viele Lösungen für VGInt im Internet kursieren, die auf der ointer-idee beruhen. Vielleicht haben Sie sich verwundert die Augen gerieben, als man Ihnen Strings als ointer verkauft hat. Viel eher würde Ihnen ein String als Array of Char einleuchten. Stimmt! Nur: Arrays sind auch nichts anderes als ointer... Bei String-Variablen handelt es sich tatsächlich nur um Zeiger auf die Stellen im Arbeitsspeicher. Der String kann somit (rein theoretisch) bis zu 2 GB groß werden, wobei sich der Speicherverbrauch automatisch der String-Länge anpasst. Enthält der String keine Zeichen, verbraucht er auch keinen Speicherplatz, abgesehen von 4 Byte für den Zeiger auf nil, also ins Leere. Keine Sorge, wir werden nicht zu C# wechseln. (Auch nicht zu Java, wo man sich über die Länge von Integervariable überhaupt keine Gedanken machen muss, denn diese können dort theoretisch- beliebig groß sein... ) Hilfe kommt von hier: HTUhttp:// Die hervoragenden Seiten stammen von Roland Mechling. Er behandelt das Thema im Rahmen der OO (objektorientierten rogrammierung) in Delphi. Seine Idee ist, TList (in Abwandlung: TVLInt) zu verwenden (bzw zu erzeugen). TList ist ein dynamischer Array von ointern. Mit ihm lassen sich mehrere ointer verwalten und sortieren. Mechling schreibt: 118

31 Der möglicherweise naheliegenden Versuchung, TVLInt gleich von TList abzuleiten, sollte man widerstehen, weil dann automatisch das gesamte Interface von TList in TVLInt veröffentlicht werden würde. Da wir uns jedoch stets um möglichst "kleine" Schnittstellen bemühen wollen, ist es sinnvoller, die Liste als "protected"-variable zu deklarieren und sie nur intern zu verwenden. Das allerdings ist auch nicht ganz trivial. Während nämlich eine normale Liste irgendwelche Objekte (also Nachfahren von TObject) speichert, wollen wir hier nur Integerwerte in der Liste ablegen, nämlich die einzelnen Stellen der Zahl. Zunächst werden wir uns auf die dezimale Darstellung beschränken, damit wir es beim Entwickeln etwas leichter haben. Jeder Listenplatz kann also einen der Werte {0, 1, 2,... 8, 9} enthalten. Recht hat er: Die Sache ist keinesfalls trivial. Es sei daher allen Interessierten dringend angeraten, sein Kapitel 4 (in OO) sorgfältig zu lesen und auch die Übungen zu machen. Denn wir werden die Unit mvlint für unsere rogramme mit sehr großen Zahlen benutzen. Wir wollen hier einen kleinen Teil (die Addition zweier VLI) seiner Unit etwas genauer betrachten: // AddAbs (protected) procedure TVLInt.AddAbs(S2: TVLInt); var carry, // Übertrag ssum, // Stellensumme gsz, // größere (der beiden) Stellenzahl(en) i : Integer; // Laufvariable carry := 0; If Self.DigitCount > S2.DigitCount then gsz := Self.DigitCount else gsz := S2.DigitCount; For i := 0 to gsz - 1 do ssum := Digit[i] + S2.Digit[i] + carry; Digit[i] := ssum Mod 10; carry := ssum Div 10; If carry > 0 then Digit[gsz] := carry;... // Add (public) procedure TVLInt.Add(S2: TVLInt); var u : TVLInt; If IsNegativ = S2.IsNegativ then // Gleiche Vorzeichen AddAbs(S2) else Case Self.AbsCompareWith(S2) of 1 : SubtrAbs(S2); 0 : FDigits.Count := 1; FDigits.Items[0] := Nil; // Verschiedene Vorzeichen 119

32 (ebenfalls HBS Kryptologie FIsNegativ := False; -1 : u := TVLInt.CreateCopyOf(S2); u.subtrabs(self); Self.Assign(u); u.free; Im Teil AddAbs (protected) wird die Summe des Betrages (zweier Repräsentanten von TVLInt ) berechnet. Also zum Beispiel abs(-4223) + abs(50998). Dies ist so zu verstehen, dass der aufrufende Repräsentant (ohne Vorzeichen) mit der Methode AddAbs den Repräsentanten SB2B ohne Vorzeichen) zu sich selbst dazu addiert. Die Anzahl der Dezimalstellen des größeren der beiden bestimmt gsz. Dann werden einfach die Summen der Dezimalstellen addiert und falls nötig ein Übertrag in carry abgelegt. Dieser Übertrag wird dann in der nächst höheren Dezimalstelle berücksichtigt. Im Teil Add (public) wird bei der Addition das Vorzeichen beachtet. Außerdem muss, falls neuer Speicherplatz erforderlich ist (u := TVLInt.CreateCopyOf(S2);), dieser auch wieder freigegeben werden (u.free;). Vielleicht ist Ihnen auch aufgefallen, dass der erste Summand nach der Anwendung der Methode Add nicht mehr vorhanden ist, da er durch das Ergebnis der Summe überschrieben wird. Weshalb ist AddAbs als protected erstellt worden? Zur Erinnerung: Ein protected-element ist wie ein private-element innerhalb der gleichen Unit verwendbar. Darüberhinaus haben alle abgeleiteten Klassen darauf Zugriff, unabhängig davon, in welcher Unit sie sich befinden. Mehr kann man eigentlich nicht verlangen. Zum Einen ist AddAbs gekapselt in der eigenen Unit, kann also von außen nicht verändert werden. Zum Anderen haben alle abgeleiteten Klassen darauf Zugriff, - egal in welcher Unit sie sich befinden. Dieser kleine Ausflug in die Unit mtvlint von Roland Mechling ist als Ansporn gedacht, auch die anderen Teile genauer nachzuvollziehen. Auch wenn Unit mvlint unverändert zum Aufpäppeln unserer bisherigen RSA- rogramme übernommen werden wird, ihre Verwendung wird sich in diesem Skript jedoch deutlich von der Methode, die bei Mechling in Kapitel 5 dargestellt wird, unterscheiden. Dafür gibt es einen einleuchtenden Grund: Unsere RSA-rogramme sind im Wesentlichen fertig und müssen lediglich mit anders formulierte Rechenoperationen für VLInt ausgestattet werden. Hat man bisher zum Beispiel geschrieben c:= a + b, so muss jetzt für das luszeichen etwas Anderes stehen. Versuchen Sie einmal, diese simple Addition in der Terminologie von mtvlint zu erstellen! Sie werden feststellen, dass das nicht gerade übersichtlich ist. Außerdem 120

33 muss man sich auch noch im die Speicherverwaltung kümmern und eventuell Kopien von den überschriebenen TVLInt erstellen. Schöner wäre da ein Term wie: c:= lus(a,b) oder für die Multiplikation c:=mult(a,b). Und genau das werden wir im nächsten rogramm Grosse Integer ausprobieren. Es sollen dort die wichtigen Rechenoperationen mit diesen VLInt durchgeführt werden. (Die benötigte Unit mtvlint, in der Repräsentanten von TVLInt erzeugt und mit Attributen und Methoden, wie Addition, Multiplikation etc angereichert wird, ist im Tauschverzeichnis abgelegt.) Rechnen mit TVLInt Hier ein Vorschlag für die Oberfläche: Im Deklarationsteil der neuen Unit benötigen wir zwei Repräsentanten von TVLInt: private v1, v2 : TVLInt; Die Unit soll später als Unit VLIrechnen in den Kryptologie-rogrammen dienen. Hier ein Beispiel für eine function für das Addieren: function TForm1.lus(z1,z2:string):string; v1.free; v1 := TVLInt.Create(z1); v2.free; v2 := TVLInt.Create(z2); v1.add(v2); result := v1.asstring; v1.free; v1 := TVLInt.Create(z1); Darauf sollten Sie achten: Als Varible werden nun Strings verwenden. Auch Strings sind nichts anderes als ointer. Durch die Methode AsString in Unit mtvlint ist die Verwandlung kein roblem. 121