Klassen zur monoalphabetischen Verschlüsselung

Das Ziel besteht in der Entwicklung eines Klassendiagramms für die Umsetzung monoalphabetischer Verschlüsselungsverfahren und der Implementierung der notwendigen Methoden. Die Programmierung einer Benutzungsoberfläche erfolgt erst in einem nächsten Schritt.

Prinzip der monoalphabetischen Verschlüsselung

In der monoalphabetischen Verschlüsselung wird jedes Zeichen eines Klartextalphabetes kta durch genau ein Zeichen eines Geheimtextalphabetes gta ersetzt.

Es gibt verschiedene Verfahren, z. B. ROT13, Cäsar, monoalphabetische Codierung mit Schlüsselwort, Play-Fair, ...

Diese Verfahren unterscheiden sich nur in der Bestimmung des gta aus einem vorgegebenen Schlüssel.

Für die Umsetzung in einem Klassendiagramm ergeben sich aus dieser Beschreibung folgende Schlußfolgerungen:

1. Die Klasse MonoAlpha ist eine abstrakte Klasse. Von ihr selbst werden keine Objekte erzeugt, sondern nur abgeleitet.
2. Die Klasse MonoAlpha ist ein Container für die Attribute kta und gta.
3. Die Klasse MonoAlpha ist ein Container für die Methoden enCrypt und deCrypt.
4. Die Klassen ROT13, Caesar, ... sind von MonoAlpha abgeleitet.
5. In den Konstruktoren der abgeleiteten Klassen erfolgt die Bestimmung des gta aus einem Parameter key.

Die Umsetzung dieser Vorgaben kann aufgrund der geringen Komplexität per Hand in BlueJ erfolgen. Einfacher ist jedoch die Verwendung eines UML-Tools (z. B. Jumli). Darin lassen sich Klassendiagramme mit Hilfe von Assistenten sehr schnell erstellen und in die entsprechende Programmiersprache übersetzen.

Für das gegebene Beispiel sehen das Klassendiagramm und der Quelltext wie folgt aus:

Klassendiagramm und Umsetzung in Java

public abstract class MonoAlphaCode
{
       
    protected String gta;
 
    protected String kta;
 
    public String deCrypt( String zeile )
    {

    }
 
    public String enCrypt( String zeile )
    {

    } 
}


public class ROT13 extends MonoAlphaCode
{
	public ROT13()
	{
	}
}

public class Caesar extends MonoAlphaCode
{
	publicaeCäsar( String key )
	{
	}
}

Umsetzung der Methoden

In der Methode enCrypt muss für jedes Zeichen der als Parameter übergebenden Zeile überprüft werden, ob es im Klartextalphabet vokommt. Falls dies der Fall ist, kann es im Geheimtext durch das entsprechende Zeichen des Geheimtextalphabetes ersetzt werden. Andernfalls wird es unverschlüselt an den Gehimtext angehängt.

public String enCrypt( String zeile )
{
   String gt = "";
   zeile = zeile.toUpperCase();
   while (zeile.length() > 0)
   {
       int pos = kta.indexOf(zeile.substring(0,1));
       if (pos >= 0)
       {
           gt = gt + gta.substring(pos,pos+1);
       }
       else
       {
           gt = gt + zeile.substring(0,1);
       }
       zeile = zeile.substring(1, zeile.length());
   }
   return gt;
}

Noch kann die Klasse MonoAlphaCode nicht genutzt werden. Es fehlt noch mindestens eine der abgeleiteten Klassen, da in ihrem Konstruktor die Attribute kta und gta erst initialisiert werden. Am einfachsten ist die Implementierung der Klasse ROT 13.

public class ROT13 extends MonoAlphaCode
{
  public ROT13()
  {
     kta = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     gta = "NOPQRSTUVWXYZABCDEFGHIJKLM";
  }
}

Jetzt können erste Experimente zur Ver- und Entschlüsselung mit Objekten der Klasse ROT13 durchgeführt werden.

Die Implementierung der Klasse Caesar erfordert die Lösung des folgenden Problems: Aus dem als Parameter key an den Konstruktor übergebenen Wert muss die Verschiebung des gta berechnet werden:

1. Suche die Position pos von key im kta.
2. Falls key nicht im kta enthalten ist, setze pos auf den Standardwert 3.
3. Bestimme gta, in dem zunächst alle Zeichen ab der Position pos aus kta in gta geschrieben werden und anschließend die ersten Zeichen von 0 bis pos-1.

public class Caesar extends MonoAlphaCode
{
  public caesar( String key )
  {
     key = key.toUpperCase();
     kta = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     gta = "";
     int pos = kta.indexOf(key);
     if (pos < 0) 
     {
         pos = 3;
     }
     gta = kta.substring(pos, kta.length()) + kta.substring(0,pos);
  }
}

Im letzen Schritt soll das Modell um eine Klasse MitKeyWort erweitert werden. Hier wird an den Konstruktor ein komplettes Schlüsselwort key übergeben. Die Buchstaben werden in der Reihenfolge ihres erstmaligen Auftretens in key in das gta übernommen. Anschließend werden alle Zeichen aus kta, die noch nicht in gta übernommen wurden, in umgekehrter Reihenfolge an gta angehängt.

Zum Beispiel liefert das Schlüsselwort "HALLO" das Geheimtextalphabet "HALOZYXWVUTSRQPNMKJIGFEDCB".