Die Vigenère-Verschlüsselung in C#

Ich empfehle den Artikel Caesar Chiffre/Verschlüsselung in C# zu lesen bevor man sich auf die Vigenère Verschlüsselung stürzt. Dort stellen wir fest, dass eine Cäsar-Verschlüsselung leicht dechiffriert werden kann, beispielsweise durch einfaches Raten oder ausprobieren. Auch die Frequenzanalyse macht die Cäsar-Verschlüsselung anfällig. Das ist genau der Mangel den Blaise de Vigenère (1523-1596) mit seiner Verschlüsselung verbessert hat. Dieses Verfahren galt fast 300 Jahre lang als unknackbar.

Um einen verschlüsselten Text vor Frequenzanalyse zu schützen, hat Vigenère den numerischen Schlüssel der Cäsar-Verschlüsselung durch einen Schlüssel in Textform ersetzt. Somit wird nicht eine einzelne Zahl als Schlüssel verwendet sondern immer der jeweilige Stellenwert des Buchstaben im Schlüssel. Nehmen wir als Beispiel:

K=‘MYKEY‘

T=‘GEHEIMNIS‘

alphabet2

Dabei ist K der Schlüssel und T der Klartext. Da der Schlüssel Kürzer ist als der Text müssen wir ihn erweitern. Daraus ergibt sich folgende Konstellation:

example1

So ist 12 der Schlüssel der zum Buchstaben M gehört, während das G im Klartext der Zahl 6 entspricht. Und nun wird nichts anderes gemacht als die Definition der Cäsar-Verschlüsselung anzuwenden. Wenn G dem Geheimtext entspricht, so ist

G = (T + K)mod26 = (‚G‘ + ‘M’)mod26 = (6 + 12)mod26 = 18mod26 = 18 = ’S’

G = (T + K)mod26 = (‚E‘ + ‘Y’)mod26 = (4 + 24)mod26 = 28mod26 = 2 = ’C’

G = (T + K)mod26 = (‚H‘ + ‘K’)mod26 = (7 + 10)mod26 = 17mod26 = 17 = ’R’

G = (T + K)mod26 = (‚E‘ + ‘E’)mod26 = (4 + 4)mod26 = 8mod26 = 8 = ’I’

G = (T + K)mod26 = (‚I‘ + ‘Y’)mod26 = (8 + 24)mod26 = 32mod26 = 6 = ’G’

G = (T + K)mod26 = (‚M‘ + ‘M’)mod26 = (12 + 12)mod26 = 24mod26 = 24 = ’Y’

G = (T + K)mod26 = (‚N‘ + ‘Y’)mod26 = (13 + 24)mod26 = mod26 = 11 = ’L’

G = (T + K)mod26 = (‚I‘ + ‘K’)mod26 = (8 + 10)mod26 = 18mod26 = 17 = ’S’

G = (T + K)mod26 = (‚S‘ + ‘E’)mod26 = (18 + 4)mod26 = 22mod26 = 21 = ’W’

Somit lautet der Verschlüsselte Text G=‘SCRIGYLSW. Anschaulich lässt sich das Verfahren im Vigenère-Quadrat darstellen. Daran können wir die Buchstaben des Geheimtextes direkt ablesen. Nehmen wir den ersten Buchstaben aus dem obigen Beispiel, mit T = ‚G‘ und K=‘M‘.

Das Vigenère-Quadrat (Bildquelle)

Das Vigenère-Quadrat (Bildquelle)

An dieser Stelle haben wir schon eine Liste an Anforderungen für eine Implementierung der Verschlüsselungsmethode. Die Funktionsweise unserer Methode soll wie folgt aussehen:

UML

Unsere Verschlüsselungsmethode bekommt den Klartext T und den Schlüsseltext K als Parameter. Innerhalb der Verschlüsselung rufen wir die Methode AdjustKey() auf. Diese Methode erweitert unseren Schlüssel so lange bis die Länge des Schlüssels nicht mehr kleiner als die des Klartexts ist (siehe Beispiel oben).

//Bekommt den Klartext und den Schlüssel als Parameter.
        public static string AdjustKeyLength(string text,string keystring)
        {
            StringBuilder key = new StringBuilder(keystring);

            //Solange der Schlüsseltext kürzer als der Klartext ist, wird er erweiter.
            while(text.Length > key.Length)
            {
                key.Append(keystring);
            }

            //Gibt den angepassten Schlüsseltext zurück.
            return key.ToString();
        }

In der Methode EncryptTextEng() Iterieren wir jetzt durch den Klartext und erstellen dabei den verschlüsselten Text. Dabei benutzen wir genau wie im obigen Beispiel den Modulo zur Berechnung der verschlüsselten Buchstaben.

//Bekommt den Klartext und Schlüssel als Parameter.
        public static string EncryptTextEng(string plainText, string keyText)
        {
            StringBuilder encryption = new StringBuilder();

            //damit uns der die Berechnung der Chiffre leichter fällt schreiben      wir alle Buchstaben groß
            //und entfernen alle whitespaces
            plainText = plainText.ToUpper();
            plainText = plainText.Replace(" ","");
            keyText = keyText.ToUpper();
            keyText = keyText.Replace(" ", "");

            //Definiere Alphabet
            char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();

            //Passe Schlüssellänge an.
            string key = AdjustKeyLength(plainText,keyText);

            //Berechne jeden einzelnen Buchstaben im Text
            for (int i = 0; i < plainText.Length;i++)
            {
                encryption.Append(alphabet[HelperClass.Modulo(Array.IndexOf(alphabet,plainText[i]) + Array.IndexOf(alphabet,key[i]),26)]);
            }

            //Der Verschlüsselte Text als Rückgabe.
            return encryption.ToString();
        }

Nicht im Diagramm ist die Entschlüsselungsmethode, DecryptTextEng() hat nur zwei Dinge die wir in EncryptTextEng() ändern müssen. Zuerst Mal bekommt diese Methode nicht den Klartext sondern den verschlüsselten Text als Parameter. Außerdem rechnen wir an dieser Stelle nicht

G = (T + K)mod26

Sondern entschlüsseln mit

G = (T – K)mod26

//Verschlüsselter Text als Parameter und nicht Klartext
        public static string DecryptTextEng(string chiffre, string keyText)
        {

            //damit uns der die Berechnung der Chiffre leichter fällt schreiben    wir alle Buchstaben groß 
            //und entfernen alle whitespaces
            chiffre = chiffre.ToUpper();
            chiffre = chiffre.Replace(" ","");
            keyText = keyText.ToUpper();
            keyText = keyText.Replace(" ", "");

            StringBuilder encryption = new StringBuilder();
            char[] alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray();
            string key = AdjustKeyLength(chiffre, keyText);

            for (int i = 0; i < chiffre.Length; i++)
            {
                //(T - K)mod26 anstatt (T + K)mod26
                encryption.Append(alphabet[HelperClass.Modulo(Array.IndexOf(alphabet, chiffre[i]) - Array.IndexOf(alphabet, key[i]), 26)]);
            }

            return encryption.ToString();
        }

Zum Schluss möchte ich noch zwei Dinge anmerken. Zum einen ist die Methode AdjustKey() nicht optimal. Da der Schlüssel immer wieder einfach angehängt wird, könnte die Methode einen unnötig langen Schlüsseltext produzieren. Dies ist vor allem bei sehr langen Schlüsseln ein Problem.

Außerdem ist die Vigenère Verschlüsselung, bei allen ihren Vorteilen gegenüber der Cäsar Verschlüsselung, auch nicht hundert prozentig resistent gegen die Frequenzanalyse.

Advertisements
Dieser Beitrag wurde unter .NET, Algorithmen, Beispiel, Beispiel, c#, Chiffre, Kryptologie, Mathematik, Modulo, Modulo, Programmierung, verschlüsselung abgelegt und mit , , , , , , , , , , , , , , , , , , , verschlagwortet. Setze ein Lesezeichen auf den Permalink.

2 Antworten zu Die Vigenère-Verschlüsselung in C#

  1. Pingback: Einführung in das Binärsystem am Beispiel der XOR Verschlüsselung in C# | RealityBites

  2. Pingback: Die Playfair Verschlüsselung in C# | RealityBites

Kommentar verfassen

Trage deine Daten unten ein oder klicke ein Icon um dich einzuloggen:

WordPress.com-Logo

Du kommentierst mit Deinem WordPress.com-Konto. Abmelden / Ändern )

Twitter-Bild

Du kommentierst mit Deinem Twitter-Konto. Abmelden / Ändern )

Facebook-Foto

Du kommentierst mit Deinem Facebook-Konto. Abmelden / Ändern )

Google+ Foto

Du kommentierst mit Deinem Google+-Konto. Abmelden / Ändern )

Verbinde mit %s