Praktikum Internet-Technologie von Prof. Jürgen Plate

Praktikum Internet-Technologie (Server-Client)

Vigenère-Verschlüsselung

Die Vigenère-Verschlüsselung wurde vom französischen Kryptographen Blaise de Vigenère (1523 - 1596) entwickelt. Das Grundprinzip folgt der Cäsar-Verschlüsselung (Verschiebe-Chiffre), jedoch mit wechselnden Schlüsseln. Die Vigenère-Chiffre galt lange Zeit als sicher und wurde erst um 1850 geknackt. Siehe auch Wikipedia.

Als Schlüssel wird z. B. ein Text oder eine Buchstabenkombination gewählt. Im folgenden Beispiel wird "MATRIX" als Schlüssel verwendet. Der Klartext wird nun um n-1 Stellen verschoben, wobei n vom jeweiligen Buchstaben des Schlüssels abhängt. Der erste Buchstabe des Schlüssels, 'M' befindet sich an der 13. Stelle im Alphabet. Damit wird der erste Buchstabe aus dem Klartext um 13-1 Stellen, also um 12 Stellen nach rechts verschoben. Der zweite Buchstabe des Klartextes wird mit Hilfe des zweiten Buchstabens des Schlüssels verschoben usw. Dabei wird der Schlüssel so oft hintereinander geschrieben, bis diese Kette genauso lang ist wie der Klartext. Dazu ein Beispiel:

Klartext = GEHEIMER TEXT

Schlüssel = MATRIX

• Es werden nur Buchstaben ('A' - 'Z', 'a' - 'z') verschlüsselt, andere Zeichen bleiben unverschlüsselt.
• Der Schlüssel wird unter den Klartext gesetzt und so oft wiederholt, bis er der Länge des Klartextes entspricht.
• Jetzt wird zur Codierung des Buchstabens 'G' (an der 7. Stelle des Alphabets) der Buchstabe 'M' (an der 13. Stelle des Alphabets) des Schlüssels verwendet. Damit ergibt sich als Codebuchstabe 'S', denn 'G' wird um 13 - 1 = 12 Stellen verschoben → 7 + 12 = 19 → die 19. Stelle im Alphabet ist der Buchstabe 'S'.
• Danach wird 'E'(5.) um 'A'(1.) - 1 = 0 Stellen verschoben: → 'E'.
• Nun wird 'H'(8.) um T(20.) - 1 = 19 Stellen verschoben → 27. Stelle. Da das Alphabet nur 26 Buchstaben hat, liegt 27 ausserhalb des erlaubten Bereichs von 26 Buchstaben. Deshalb wird die Verschlüsselung Modulo 26 ausgeführt und damit ergibt sich 27 mod 26 = 1 → 'A'.

Wenn man im Beispiel oben die Ordnungszahlen darunter schreibt, wird das Verfahren schnell deutlich:

Klartext    G   E   H   E   I   M   E   R       T   E   X   T
            7   5   8   5   9  13   5  18      20   5  24  20

Schlüssel   M   A   T   R   I   X   M   A       T   R   I   X
           13   1  20  18   9  24  13   1      20  18   9  24

Code        S   E   A   V   Q   J   Q   R       M   V   F   Q
           19   5   1  22  20  10  17  18      13  22   6  17  

Das folgende C-Programm realisiert die Verschlüsselung und auch die Entschlüsselung, die eine Umkehrung des Verschlüsselungsalgorithmus darstellt. Da bei der Entschlüsselung eventuell negative Werte auftreten, kann hier die Modulo-Funktion nicht eingesetzt werden.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#define SMAX 100          /* maximale Schluessellaenge */
#define ALPHA 96          /* Alphabetlaenge */

int keylen;               /* Laenge des Schluesselwortes */
char key[SMAX];           /* Schluesselwort in Form von Offsets */

char secret[] = "MATRIX"; /* Codeschluessel */
char buffer[10000];       /* Textpuffer, Groesse passend waehlen */

/*
 * Verschluesseln des Textes im buffer
 * Es werden nur Zeichen im Bereich von 0x32 bis 0x128
 * verschluesselt. Andere Zeichen werden einfach
 * unveraendert durchgereicht.
 * Der buffer enthaelt nach Ende der Funktion den
 * codierten Text --> der urspruenglieche Inhalt
 * wird ueberschrieben.
 */
void encode(char *key, char *buffer)
  {
  int c;
  int n = 0;
  int j = 0;
  while (buffer[j] != 0 )
    {
    if (' ' <= buffer[j] && buffer[j] <= 128)
      {
      c = (buffer[j] - ' ' + key[n]) % ALPHA;
      buffer[j] = c + ' ';
      n = (n + 1) % keylen;
      }
    j++;
    }
  }

/*
 * Entschluesseln des Textes im buffer
 * Es werden nur Zeichen im Bereich von 0x32 bis 0x128
 * entschluesselt. Andere Zeichen werden einfach
 * unveraendert durchgereicht.
 * Der buffer enthaelt nach Ende der Funktion den
 * decodierten Text --> der urspruenglieche Inhalt
 * wird ueberschrieben.
 */
void decode(char *key, char *buffer)
  {
  int c;
  int n = 0;
  int j = 0;
  while (buffer[j] != 0 )
    {
    if (' ' <= buffer[j] && buffer[j] <= 128)
      {
      c = (buffer[j] - ' ' - key[n]);
      if (c < 0) c = c + ALPHA;
      buffer[j] = c + ' ';
      n = (n + 1) % keylen;
      }
    j++;
    }
  }

/* key erzeugen:
 * In key werden die Offsets gespeichert: 'a' --> 0, 'b' --> 1 usw.
 * Es wird nicht zwischen Gross- und Kleinbuchstaben unterschieden.
 * nicht-alphabetische Zeichen werden ignoriert (--> 0).
 * Da das key-array Nullen enthaelt, muss dessen Laenge getrennt
 * in der Variable keylen gespeichert werden.
 */
void mkkey(char *secret, char *key, int *keylen)
  {
  int len = 0;
  while (secret[len] != '\0')
    {
    if (isupper(secret[len])) key[len] = secret[len] - 'A';
    else if (islower(secret[len])) key[len] = secret[len] - 'a';
    else key[len] = 0;
    len++;
    }
  *keylen = len;
  }


int main (int argc, char **argv)
  {

  mkkey(secret, key, &keylen);

  strcpy(buffer, argv[1]);
  encode(key, buffer);
  printf("%s\n",buffer);
  decode(key, buffer);
  printf("%s\n",buffer);

  return 0;
  }