Kryptologie: Die Algorithmen

[ home \| anleitungen \| recherchen \| hilfe \| sitemap \| index \| suchen ]
Der Recherchekompass

home » recherchen » kryptologie » anhang » algorithmen

eigenentwicklung »

Verschlüsselte Botschaften
Kryptologische Algorithmen

[cäsar] [vigenère] [aRC4] [RSA] [notation] [verweise]

Die auf dieser Seite aufgeführten Algorithmen sind als Programmierhilfe gedacht und können bei Bedarf kopiert und angepasst werden, vorbehaltlich eventueller Rechte von Dritten. Eine Gewährleistung für die Korrektheit der beschriebenen Algorithmen wird nicht gegeben, auch wenn die Algorithmen getestet und gefundene Fehler nach besten Wissen beseitigt wurden. Durch Testen kann die Korrektheit eines Programms nicht nachgewiesen werden, höchsten seine Fehlerhaftigkeit.

Also: Alles ist "AS IS" und Gewährleistungen und Garantien gibt es für gar nichts.
Im Übrigen siehe den Haftungsausschluss (»).

Cäsar-Chiffre

Beim Cäsar-Chiffre handelt es sich um eine monoalphabetische Substitution. Dabei wird jedem Buchstaben eines Textes ein eindeutiger anderer Buchstabe zugeordnet. Diese Zuordnung basiert auf der zyklischen Rotation des Alphabets um eine feste Anzahl von Zeichen, dabei folgt auf z wieder a. Die Anzahl der verschobenen Zeichen ist dann der Schlüssel, mit dem ver- bzw. entschlüsselt wird.

1: var alphabet = "abcdefghijklmnopqrstuvwxyz"; 2: var alphaLen = alphabet.length; 3: 4: function cesar_encrypt (key, text) { 5: var i, n = 0; 6: var chiffre = ""; 7: 8: key = key % alphaLen; 9: text = text.toLowerCase(); 10: for (i=0; i < text.length; i++) { 11: n = alphabet.indexOf(text.charAt(i)); 12: if (n >= 0) 13: chiffre = chiffre + alphabet.charAt((n+key) % alphaLen); 14: else 15: chiffre = chiffre + text.charAt(i); 16: } 17: return chiffre; 18: }

Tabelle: JavaScript zur Codierung der Cäsar-Chiffre. [notation] (Beispiel »)

Zur Verschlüsselung erwartet die Routine einen ganzzahligen Schlüssel und den zu verschlüsselnden Text. Nachdem sichergestellt wurde, dass der Schlüssel eine gültige Verschiebung erzeugt und der Text auf das Alphabet abgebildet werden kann (Zeile 9), wird der Text Zeichen für Zeichen verschlüsselt (Zeilen 10 bis 16). Dabei werden Zeichen die nicht im Alphabet vorkommen von diesen Algorithmus 1 zu 1 in die Chiffre übernommen (Zeile 15).[1]

Der einzelne Buchstabe wird verschlüsselt, indem zunächst seine Ordnungszahl (Position im Alphabet) ermittelt wird, diese um "key" Zeichen erhöht wird und mittels der Modulus-Operation wieder auf das Alphabet abgebildet wird. Es ist klar, dass dieses Verfahren auch auf das interne Alphabet von JavaScript abgebildet werden kann, allerdings entstehen dann auch nicht druckbare Zeichen im Chiffretext, die zunächst als Steuerzeichen interpretiert werden, wodurch die korrekte Entschlüsselung verhindert werden kann.

19: function cesar_decrypt (key, chiffre) { 20: var i, n = 0; 21: var text = ""; 22: 23: key = key % alphaLen; 24: chiffre = chiffre.toLowerCase(); 25: for (i=0; i < chiffre.length; i++) { 26: n = alphabet.indexOf(text.charAt(i)); 27: if (n >= 0) 28: text = text + alphabet.charAt((alphaLen+(n-key)) % alphaLen); 29: else 30: text = text + text.charAt(i); 31: } 32: return text; 33: }

Tabelle: JavaScript zur Decodierung der Cäsar-Chiffre. [notation] (Beispiel »)

Die Entschlüsselung verläuft analog zu Verschlüsselung, nur das der Schlüssel diesmal abgezogen statt addiert wird. Da es hierbei zu negativen Zahlen kommen kann, die einen verfälschten Modulus ergeben, wird zunächst die Länge des Alphabetes addiert. Zeichen, die nicht im Alphabet vorkommen werden auch jetzt wieder 1 zu 1 übernommen (Zeile 15).

Diese Form der Umsetzung ist nur eine von viele, zum Beispiel kann vorab ein verschobenes Alphabet erzeugt werden, dann kann die Position eines Zeichens im Klartextalphabet direkt zur Ermittlung des Chiffrezeichen verwendet werden. Auch können direkt die Ordnungszahlen verwendet werden, die durch JavaScript-Funktionen ermittelt werden. Leider ist es mit JavaScript nicht möglich das mathematische Verfahren umzusetzen, da die Addition auf Buchstaben zu Zeichenketten führt.

[seitenanfang] [verweise]

Vigenère-Chiffre

Diese Chiffre wurde von Blaise de Vigenère (1523-1596) entwickelt. Statt einem werden 26 Alphabete verwendet, bei denen jedes Alphabet durch eine zyklische Rotation um 1 zum Vorhergehenden erzeugt wird. Als Schlüssel verwendet man ein Codewort, welches bestimmt, mit welchem der Alphabete ein einzelnes Zeichen verschlüsselt wird. Mathematisch wird, ein kurzes Wort, z.B. ZEBRA, wiederholt aneinander gehängt. Durch Addition der Buchstaben mit dem Klartext entsteht dann der Geheimtext. Bei der Entschlüsselung wird entsprechend mit der Subtraktion gearbeitet.

1: var alphabet = "abcdefghijklmnopqrstuvwxyz"; 2: var alphaLen = alphabet.length; 3: 4: function vigenere_encrypt (key, text) { 5: var i, j = 0; 6: var zp, kp = 0; 7: var chiffre = ""; 8: 9: if (key != "") { 10: key = key.toLowerCase(); 11: text = text.toLowerCase(); 12: for (i=0; i < text.length; i++) { 13: zp = alphabet.indexOf(text.charAt(i)); 14: if (zp >= 0) { 15: kp = alphabet.indexOf(key.charAt(j)); 16: chiffre = chiffre + alphabet.charAt((zp+kp) % alphaLen); 17: j = (j+1) % key.length; 20: } else 21: chiffre = chiffre + text.charAt(i); 22: } 23: } 24: return chiffre; 25: }

Tabelle: JavaScript zur Decodierung der Vigenère-Chiffre. [2] [notation] (Beispiel »)

Der Vigenère-Chiffre entspricht einem Cäsar-Chiffre, bei dem allerdings für jedes zu verschlüsselnde Zeichen eine neues, verschobenes Alphabet benutzt wird. Als Schlüssel dient ein Codewort, so dass das erste Zeichen mit der Verschiebung die durch das erste Zeichen des Schlüssels gegeben ist verschlüsselt wird. Das Zweite mit dem Zweiten und so weiter. Nach dem letzten Zeichen des Codewortes wird wieder mit dem ersten begonnen (Zeile 17).

Die eigentliche Verschlüsselung läuft ab wie beim Cäsar-Code, der Wert der jeweiligen Verschiebung wird in jedem Durchlauf erneut bestimmt (Zeile 15). Während bei "Cäsar" ein Nullwert für den Schlüssel keine Effekt ausübt, würde hier der Leerstring zu Fehlern im Ablauf führen, daher wird in diesem Fall die Chiffre leer zurückgegeben.

26: function vigenere_decrypt (key, chiffre) { 27: var i, j = 0; 28: var zp, kp = 0; 29: var text = ""; 30: 31: if (key != "") { 32: key = key.toLowerCase(); 33: chiffre = chiffre.toLowerCase(); 34: for (i=0; i < chiffre.length; i++) { 35: zp = alphabet.indexOf(chiffre.charAt(i)); 36: if (zp >= 0) { 37: kp = alphabet.indexOf(key.charAt(j)); 38: text = text + alphabet.charAt((alphaLen+(zp-kp)) % alphaLen); 39: j = (j+1) % key.length; 40: } else 41: text = text + text.charAt(i); 42: } 43: } 44: return text; 45: }

Tabelle: JavaScript zur Decodierung der Vigenère-Chiffre. [2] [notation] (Beispiel »)

Wie schon beim Cäsar-Chiffre ist auch bei Vigenère die Dekodierung analog zur Codierung, außer dass der Schlüssel jetzt subtrahiert und nicht addiert wird (Zeile 38). Auch hier lässt sich die mathematische Vorgehensweise nicht in JavaScript umsetzen.

[seitenanfang] [verweise]

Apparantly RC4™

Bei Ron's Code oder der Rivest Cipher No. 4 handelt es sich um ein Verfahren zur Stromchiffrierung. Es wurde bereits 1987 von Ronald L. Rivest für RSA Data Security Inc. (heute RSA Security Inc.) entwickelt und lange Jahre geheimgehalten. Im September 1994 veröffentlichte eine anonyme Person einen Algorithmus, der zu RC4 identische Ergebnisse erzeugte und daher "apparantly RC4" ist, in einer Mailing-Liste. Dieser Quelltext verbreitete sich schnell wurde ausgiebig diskutiert und analysiert.

Im Gegensatz zu DES ist die Schlüssellänge variabel und kann bis zu 2048 Bit (256 Zeichen) betragen, wobei bereits 128 Bit als sicher gelten. Es wird immer ein Byte (ein Zeichen) auf einmal verschlüsselt. Der Algorithmus ist sowohl einfach wie auch sicher und kann besonders einfach und effizient programmiert werden.

Mit der Veröffentlichung ist der Algorithmus nun kein Firmengeheimnis mehr und ließe sich rechtlich gesehen frei verwenden. Allerdings muss sich jeder der RC4 in seine kommerzielle Software einbaut, ohne es zu lizenzieren, auf einen Rechtsstreit mit RSA einrichten. (Dabei dürfte RSA diesen Prozess wahrscheinlich verlieren.) Die hier dargestellte Umsetzung in JavaScript basiert auf Informationen aus dem Internet. Es ist daher nicht sicher, ob es sich wirklich um den Algorithmus der RSA handelt.

1: var RC4_sbox = new Array (256); 2: 3: function RC4_crypt (key, text) { 4: var i, j, k = 0; 5: var temp = 0; 6: var t = 0; 7: var rtext = ""; 8: 9: for (j = 0; j < 256; j++) 10: RC4_sbox[j] = j; 11: j = 0; 12: for (i=0; i < 256; i++) { 13: j = (j + RC4_sbox[i] + key.charCodeAt(i % key.length)) % 256; 14: temp = RC4_sbox[i]; 15: RC4_sbox[i] = RC4_sbox[j]; 16: RC4_sbox[j] = temp; 17: } 18: 19: for (k=0; k < text.length; k++) { 20: i = (i + 1) % 256; 21: j = (j + RC4_sbox[i]) % 256; 22: temp = RC4_sbox[i]; 23: RC4_sbox[i] = RC4_sbox[j]; 24: RC4_sbox[j] = temp; 25: t = (RC4_sbox[i] + RC4_sbox[j]) % 256; 26: rtext = retxt 27: + String.fromCharCode(text.charCodeAt(k) ^ RC4_sbox[t]); 28: } 29: return rtext; 30: }

Tabelle: JavaScript zur Codierung der "apparantly" Rivest Cipher No. 4 (RC4™). [3] [notation] (Beispiel »)

Der Algorithmus besticht durch seine Einfachheit, insbesondere weil er unverändert sowohl zur Ver- wie auch zu Entschlüsselung genutzt werden kann. Die Ver- bzw. Entschlüsselung läuft in drei Schritten ab:

In den Zeilen 9 bis 17 wird zunächst eine S-Box initialisiert. Dazu wird ein Array gefüllt (9 und 10) und die Inhalte der Felder unter zu Hilfenahme des Schlüssels untereinander vertauscht (12 bis 17).
Dann wird für jeden Buchstaben des Eingabetextes ein Zufallsbyte aus der S-Box ermittelt, wobei die Felder des Array jedes Mal erneut vertauscht werden. (20 bis 25),
Schließlich werden das ermittelte Zufallsbyte und das Textzeichen durch xor miteinander verknüpft (Zeilen 26 und 27).

Trotz seiner Einfachheit wurden bisher keine Schwächen im Algorithmus entgedeckt. Da die Verschlüsselung in keiner Form vom zu verschlüsselnden Text abhängig ist, ist der Algorithmus für Klar- oder Geheimtextangriffe anfällig. Es ist daher zu empfehlen einen Schlüssel nicht zu oft zu verwenden.

Der hier dargestellte Algorithmus kränkelt in der Umsetzung mit JavaScript, weil bei der Verschlüsselung auch Werte ermittelt werden können, die als nicht druckbare Zeichen bekannt sind und zur Steuerung der Verarbeitung von Zeichenketten benutzt werden. Zur Darstellung im Browser (Internet Explorer unter Windows), werden insbesondere beim Aufinden eines "Carriage-Return"- oder "Line-Feed"-Zeichens das jeweils andere Zeichen hinzugefügt. Bei der Dekodierung werden daher mehr - und andere - Zeichen übergeben und die Entschlüsselung schlägt fehl. Diese Zeichen könnten unterdrückt werden (Zeile 26 und 27), was aber zu unterschiedlichen Algorithmen für die Ver- und Entschlüsselung führt. Um die daraus entstehenden Probleme zu umgehen werden die Steuer- und Sonderzeichen des erzeugten Chiffretext vor der Darstellung mittels der JavaScript-Funktion escape() ersetzt, was bei der Entschlüsselung durch unescape() zurückgesetzt wird. Der Chiffretxt wird dadurch leider erheblich länger.

[seitenanfang] [verweise]

RSA: Rivest-Shamir-Adleman

Dieses Verfahren wohl verbreitetste Public-Key-Verfahren wurde 1977/78 am MIT entwickelt. Den Namen erhielt es nach seinen Entwicklern Ron Rivest, Adi Shamir und Len Adleman. RSA war bis zum Jahr 2000 in den USA patentiert. Die Sicherheit von RSA basiert auf dem Problem, eine große ganze Zahl in ihre Primfaktoren zu zerlegen. Daher darf die Schlüssellänge, d.h. die beteiligten Primzahlen, auch nicht zu klein gewählt werden. Sicherheit fängt bei 2048 Bit an, das entspricht einem Schlüsselwort von 256 ASCII-Zeichen.

Schlüsselerzeugung

Der Trick besteht darin, zwei Exponenten zu finden, so dass eine Zahl mit dem Ersten exponiert einen Wert ergibt, der exponiert mit dem Zweiten wieder die ursprüngliche Zahl ergibt. Dies ist möglich, wenn in beiden Fällen der erhaltene Wert der selben Modulus-Operation unterzogen wird. Der Modulus hierfür ergibt sich aus dem Produkt zweier Primzahlen (Zeile 6).

Die Euler-Funktion liefert zu einer gegebenen natürlichen Zahl, deren Primfaktoren bekannt sind, die Anzahl der kleineren, teilerfremden natürlichen Zahlen. Diese Anzahl ist für den Modulus (die Primfaktoren sind ja bekannt): Phi = (p-1)*(q-1) (Zeile 4). Das Phi bringt ein wenig mathematische Magie in die Sache, die aber von allen Mathematikprofessoren bestätigt wird, denn es ist:

a ^(d*e) mod m = a ^{(d*e) mod Phi} mod m

Das heißt, wenn man d und e so wählt, dass (d*e) mod Phi = 1, dann kann jede Zahl die mit e exponiert wurde durch erneutes exponieren mit d wieder zurückgewonnen werden und umgekehrt.

1: var m, e, d; 2: 3: function RSA_keys (P, Q) { 4: var Phi = (P-1)*(Q-1); 5: 6: m = P * Q; 7: e = PublicKey (Phi); 8: d = SecretKey (e, Phi); 9: } 10: function PublicKey (Phi) { 11: var akT = 0; 12: var e = 2; 13: 14: while (akT != 1) { 15: e = e + 1; 16: akT = ggT(e, Phi); 17: } 18: return e; 19: } 20: 21: function ggT (a, b) { 22: var x = a; 23: var y = b; 24: 25: while (x < y || x > y) 26: if (x-y < 0) 27: x = x + a; 28: else y = y + b; 29: 30: return (a*b/x); 31: } 32: function SecretKey (e, Phi) { 33: var i = 0; 34: 35: do { 36: i = i + 1; 37: } while ((i*Phi + 1)%e != 0); 38: 39: return (i*Phi + 1)/e; 40: }

Tabelle: JavaScript für die Schlüsselerzeugung des RSA-Chiffre. [notation] (Beispiel »)

Der öffentliche Schlüssel wird erzeugt, in dem eine Zahl e gesucht wird, deren größter gemeinsamer Teiler (ggT) mit Phi gleich 1 ist, d.h. e ist relativ prim zu Phi. Der hier verwendete Algorithmus tut dies, in dem e sukzessive erhöht und jedes Mal der ggT überprüft wird, bis dieser gleich 1 ist (14-17). Es wird somit auch gleichzeitig das kleinste e gefunden. Die benutzte Funktion ggT (21-31) berechnet zunächst das kleinste gemeinsame Vielfache (kgV), um dann aus der Umkehrung den größten gemeinsamen Teiler zu ermitteln.

Um den privaten Schlüssel zu erzeugen, gilt es nun eine Zahl zu finden, die mit e multipliziert genau um eins größer ist als Phi, bzw. ein Vielfaches von Phi. ( d * e = i*Phi + 1 <=> d = (i*Phi + 1) / e ) In den Zeilen 35 bis 37 wird zunächst der Faktor i ermittelt, so dass die Division durch e eine ganze Zahl ergibt, und d wird entsprechend der Formel berechnet und als Exponent für den privaten Schlüssel zurückgegeben.

Das Ganze funktioniert nur dann, wenn der Modulus aus Primzahlen gebildet wird; ansonsten lassen sich e und d nicht eindeutig bestimmen, was zu Laufzeitfehlern und Speicherüberläufen führt. Im Prinzip ist es egal, ob (e, m) oder (d, m) zum öffentlichen Schlüssel gemacht wird, wichtig ist dass der jeweils andere geheimgehalten wird. Es erscheint aber sinnvoll, (e, M) zum öffentlichen Schlüssel zu machen, weil es der kleinere Wert ist.

Ver- und Entschlüsselung

Die Ver- und Entschlüsselung gestaltet sich einfach, da die gleiche Funktion für beides genutzt werden kann. Da aber nur Zahlen verschlüsselt werden ist es notwendig vor der Verschlüsselung aus dem Text Blöcke zu bilden, die dann als Zahlen zu interpretieren sind und nach der Entschlüsselung müssen die Zahlen wieder in lesbaren Text umgewandelt werden. Problematisch wird die Ver- und Entschlüsselung durch die großen Zahlen, die bei der Exponention entstehen können, hierdurch kann der eine oder andere Rechner schon mal abstürzen.

Allerdings kann diese Berechnung vereinfacht werden, wenn das Exponieren unter einem Modulus durchgeführt wird, anstatt erst zu exponieren und dann den Modulus zu bilden. Angenommen 299 ist unter dem Modulus 355 in die 153 Potenz setzen. Zunächst wird die Potenz aufgelöst und man erhält: 153 = 128 + 16 + 8 + 1 (binäre dekomposition). Daher ergibt sich: 299¹⁵³ = 299¹²⁸ * 299¹⁶ * 299⁸ * 299¹ . Eine Verdopplung der Potenz erreicht man einfach durchs quadrieren der Basis, angewandt unter einem Modulus sieht es - beispielsweise - aus wie folgt:

                 299 mod 355 = 299 <=> 299 = 299¹ mod 355
299² = 89401 => 89401 mod 355 = 296 <=> 296 = 299² mod 355
296² = 87616 => 87616 mod 355 = 286 <=> 286 = 299⁴ mod 355
286² = 81796 => 81796 mod 355 = 146 <=> 146 = 299⁸ mod 355
146² = 21316 => 21316 mod 355 =  16 <=>  16 = 299¹⁶ mod 355
 16² =   256 =>   256 mod 355 = 256 <=> 256 = 299³² mod 355
256² = 65536 => 65536 mod 355 = 216 <=> 216 = 299⁶⁴ mod 355
216² = 46656 => 46656 mod 355 = 151 <=> 151 = 299¹²⁸ mod 355

Für 153 werden nur die Werte für 1, 8, 16, 128 gebraucht, also 299¹⁵³ mod 355 = (151 * 16 * 146 * 299) mod 355 was schon viel einfacher aussieht. Nun berechnen wir noch das Produkt und erhalten:

151 * 16  =  2416 =>  2416 mod 355 = 286
286 * 146 = 41756 => 41756 mod 355 = 221
221 * 299 = 66079 => 66079 mod 355 =  49 <=> 299¹⁵³ mod 355 = 49.

Auf diese Weise können große Potenzen von großen Zahlen unter einem Modulus berechnen werden, ohne dass ein Computer abstürzt. Die Werte werden hierbei niemals größer als das Quadrat des Modulus. Die hier dargestellte Funktion setzt diese Form der Berechnung um.

1: function RSA_crypt (basis, exponent, modulus) { 2: var sum = 0; 3: var mask = 1; 4: var ergebnis = 1; 5: 6: while (sum < exponent) { 7: if ((exponent&mask) != 0) { 8: ergebnis = (ergebnis*basis) % modulus; 9: sum = sum + (exponent&mask); 10: } 11: basis = (basis*basis) % modulus; 12: mask = mask << 1; 13: } 14: return ergebnis; 15: }

Tabelle: JavaScript zum Exponieren unter einem Modulus. [notation] (Beispiel »)

Die Funktion berechnet innerhalb der Schleife (Zeilen 6 bis 13): ergebnis = basis^exponent mod modulus. In jedem Durchlauf der Schleife wird die nächste Verdopplung der Potenz durch quadrieren des Wertes von "basis" ermittelt (Zeile 11). Die Variable "mask" dient zur Bestimmung, ob eine 2er-Potenz Teil des Exponenten ist. Dies wird durch bitweises xor von "mask" mit dem Exponenten ermittelt. In Zeile 12 wird diese Maske um eine Stelle (2er-Potenz) weiter nach links verschoben, "mask" wird größer.

Ist eine 2er-Potenz Teil des Exponenten (Zeile 7), so wird bisher ermittelte Zwischenbetrag mit dem aktuellen Wert von "basis" multipliziert und der Modulus gebildet. Dieser Wert wird das neue Zwischenergebnis. Des weiteren wird im Hilfsfeld "sum" die bisher berechnete Potenz aufsummiert. Die Schleife wird solange wiederholt, bis "sum" den Wert des Exponenten erreicht hat (Zeile 6).

Auch die Initialisierung der Variablen hat bei dieser Funktion Bedeutung. So muss "ergebnis" mit 1 initialisiert sein, da anderenfalls die Funktion immer 0 ergeben würde (klar). Mit "mask" = 1 wird nur ein einzelnen Bit des Wertes auf 1 gesetzt, alle anderen Bits sind 0, dadurch kann genau ermittelt werden, ob eine Potenz Teil einer Zahl ist, denn die xor-Operation ist nur dann wahr, wenn an gleicher Stelle die Bits beider Zahlen "true" sind.

Bevor ein Klartext verschlüsselt werden kann, müssen die Buchstaben in Zahlen umgewandelt und zu Blöcken zusammengefasst werden. Die Bitlänge des Blockes ist um 1 kleiner als die Bitlänge des Modulus. Ausgegangen wird hier von einem Alphabet mit bis zu 256 Zeichen, z.B. Latin-1, bei welchem ein Zeichen mit 8 Bit codiert wird. Die Bitfolge jedes Zeichens kann als Zahl interpretiert werden und ergibt so die Ordnungszahl innerhalb des Alphabetes. Diese Ordnungszahl ist die Basis für die weitere Verschlüsselung.

1: function RSA_encode (Klartext) { 2: var Chiffre = ""; 3: 4: while ((Klartext.length % Math.floor((BlkLen-1)/8)) != 0) 5: Klartext = Klartext + " "; 6: 7: for (i=0; i < Klartext.length; i++) { 8: tmp = Klartext.charCodeAt(i); 9: j = 1; 10: while (((j+1)*8) < BlkLen) { 11: tmp = tmp << 8; 12: tmp = tmp + Klartext.charCodeAt(i+j); 13: j++; 14: } 15: if (j > 0) i = i + (j-1); 16: Chiffre = Chiffre + " " + String(RSA_crypt(parseInt(tmp), e, m)); 17: } 18: return Chiffre; 19: }

Tabelle: JavaScript des "numerical encoding" für RSA. [notation] (Beispiel »)

Zur numerischen Kodierung eines Klartextes wird diese zunächst auf ein Vielfaches der Blocklänge gebracht (Zeilen 4 und 5) [4]. Ab Zeile 7 wird für jedes Klartextzeichen zunächst die Ordnungszahl bestimmt (Zeile 8). In den Zeilen 10 bis 15 wird der Block zur Verschlüsselung aufbereitet. Sofern die Blocklänge um 8 größer ist als der bisher zusammengestellte Block, dann wird ein weiteres Zeichen zum Block hinzugefügt. Dazu wird zunächst der bisherige Block um 8 Bit nach "links" verschoben, dadurch wird die Zahl um 2⁸ größer, und die Ordnungszahl des nächsten Zeichen wird addiert. Die entstandene Zahl repräsentiert in jeweils 8 Bit ein Zeichen des Klartextes. In Zeile 16 wird die "Blockzahl" mit RSA_crypt (siehe oben) verschlüsselt und dem Chiffretext angehängt.

1: function num_decode (Num) { 2: var temp = Num; 3: var result = ""; 4: 5: Num = Num >> 8; 6: if (Num > 0) 7: result = num_decode(Num); 8: return result + String.fromCharCode(temp & 255); 9: } 10: function RSA_decode (Geheimtext) { 11: var Chiffre = Geheimtext.split(" "); 12: var Klartext = ""; 13: 14: for (i=0; i < Chiffre.length; i++) 15: if (Chiffre[i] != "") { 16: Klarnum = RSA_crypt(parseInt(Chiffre[i]), d, m); 17: Klartext = Klartext + num_decode(Klarnum); 18: } 19: return Klartext; 20: }

Tabelle: JavaScript des "numerical decoding" für RSA. [notation] (Beispiel »)

Zur Dekodierung des aus Zahlenblöcken bestehenden Chiffretextes wird dieser mittels der Javascriptfunktion "split()" in die einzelnen Zahlen zerlegt (Zeile 11). Jede dieser Chiffrezahlen wird zunächst mit RSA_crypt in die Klartextzahl zurückgerechnet (Zeile 16). Die Rückwandlung in Buchstaben übernimmt die Funktion "num_decode" (Zeilen 1 bis 9), welche rekursiv die Klartextzahl in 8 Bit-Stücke zerlegt und hieraus die einzelnen Zeichen zurückgewinnt.

Auch wenn die hier verwendeten Zahlendarstellungen keine Blockgrößen von mehr als zwei Zeichen zulassen, da ansonsten die maximale Größe der Ganzahlen in JavaScript überschritten würde, so sind die Algorithmen so gestaltet, dass sie durchaus in der Lage sind größere Blocklängen zu verarbeiten. Sie tun dies dynamisch in Abhängigkeit vom jeweiligen Modulus.

[seitenanfang] [verweise]

Anmerkungen zur Notation:

Zur Beschreibung der Algorithmen wurde die Notation von JavaScript verwendet, so dass die Algorithmen wie hier beschrieben in eine HTML-Seite zu übernehmen sein sollten. In JavaScript muss die ganzzahlige Division mittels der Funktion Math.floor() aus der normalen Division gebildet werden. Die Ermittlung des jeweiligen Restes einer ganzzahligen Division (modulo) wird durch "%" ausgedrückt. Wertzuweisungen an eine Variable werden durch ein einfaches Gleichheitszeichen gekennzeichnet, bei Vergleichen wird das Gleichheitszeichen verdoppelt ("=="). Wichtige boolesche Operatoren sind:

*Logisch:*
	&&	UND	\|\|	ODER	!	NICHT
*Bitweise:*
	&	UND	\|	ODER	^	XOR
	<<	Links-Shift	>>	Rechts-Shift

Fußnoten:

[1]	Grundsätzlich kann der Cäsar-Chiffre auf jedem Alphabet aufsetzen, es ist aber wichtig, dass das verwendete Alphabet dem Empfänger einer Botschaft bekannt ist. Von daher kann auch das Alphabet ein Teil des Schlüssels sein. Der Algorithmus ist so gestaltet, dass das Alphabet um beliebige Zeichen erweitert werden kann, ohne dass die Funktion umgestaltet werden müsste.
[2]	Für den Vigenère-Chiffre gilt hinsichtlich des Alphabetes das Gleiche wie zum Cäsar-Code. [1]
[3]	RC4™ ist eine Marke der RSA Security Inc. Es kann weder die Richtigkeit des dargestellten Algorithmus gewährleistet werden, noch die Qualität der Umsetzung.
[4]	Das Erweitern des Klartextes auf ein Vielfaches der Blocklänge kann unterlassen werden, wenn die Bedingung der while-Schleife in Zeile 10 anders formuliert wird und vor dem Erreichen der Blocklänge die Schleife abgebrochen werden kann.

Verweise
	Die klassische Kryptologie Kryptologische Verfahren finden sich schon im Altertum und wurden vor allem vom Militär und von Diplomaten eingesetzt. Bekannte Verwender waren Julius Cäsar, aber auch das deutsche Militär des 2. Weltkrieges mit der Enigma. Die moderne Kryptologie Mit dem Einsatz von Computertechnik für die Kryptologie und dem Einsatz der Kryptologie in der Computertechnik beginnt die Ära der moderne Kryptologie. Einer der markantesten Punkt ist die Entwicklung der asymmetrischen Verfahren. Selbsterstellte Algorithmen Nachdem ich mich nun längere Zeit mit der Kryptologie beschäftigt habe, konnte ich es nicht lassen mich selbst an die Entwicklung eigener Algorithmen zu machen. Nur bekannt gemachte Verfahren können sicher werde: Hier sind sie. Kleines Kryptologieglossar Kurze Erläuterungen zu Begriffen und Themen die in dieser Ausarbeitung keinen Platz mehr gefunden haben, aber auch die wichtigsten Begriffe nochmals kurz erläutert, um nicht immer suchen zu müssen. ... nach draußen: Stefan Münz: SelfHTML (de.selfhtml.org) RC4 (Ron's Code 4) (home.t-online.de/home/poisoner/krypto/rc4.htm) (Ich bin nicht verantwortlich für Inhalte externer Internetseiten.)

eigenentwicklung »

[Seitenanfang]

geändert: 01.12.2010 by hgm