Caesar-Verschlüsselung

Das wohl bekannteste Verschlüsselungsverfahren geht auf Julius Caesar zurück. Er verschob die Buchstaben des Alphabets einfach um eine feste Anzahl von Buchstaben. Jedem Klartextbuchstaben wird damit ein verschobener Geheimtextbuchstabe zugeordnet. Bei der Entschlüsselung geschieht die Verschiebung dann in entgegengesetzter Richtung.

Einfache Umsetzung

Die folgende Umsetzung greift den Gedanken auf und ordnet im Rahmen einer switch-Anweisung die Buchstaben einander zu. Bei der zugehörigen Entschlüsselungsmethode würde die Anordnung entgegengesetzt erfolgen.

public String verschluesseleEinfach(String klartext) {

      String ergebnis = "";

      for (int i=0; i<klartext.length(); i++) {

       switch (klartext.charAt(i)) {        
         case 'A': { ergebnis = ergebnis + 'D'; break; }
         case 'B': { ergebnis = ergebnis + 'E'; break; }
         case 'C': { ergebnis = ergebnis + 'F'; break; }
         case 'D': { ergebnis = ergebnis + 'G'; break; }
         case 'E': { ergebnis = ergebnis + 'H'; break; }
         case 'F': { ergebnis = ergebnis + 'I'; break; }
         case 'G': { ergebnis = ergebnis + 'J'; break; }
         case 'H': { ergebnis = ergebnis + 'K'; break; }
         case 'I': { ergebnis = ergebnis + 'L'; break; }
         case 'J': { ergebnis = ergebnis + 'M'; break; }
         case 'K': { ergebnis = ergebnis + 'N'; break; }
         case 'L': { ergebnis = ergebnis + 'O'; break; }
         case 'M': { ergebnis = ergebnis + 'P'; break; }
         case 'N': { ergebnis = ergebnis + 'Q'; break; }
         case 'O': { ergebnis = ergebnis + 'R'; break; }
         case 'P': { ergebnis = ergebnis + 'S'; break; }
         case 'Q': { ergebnis = ergebnis + 'T'; break; }
         case 'R': { ergebnis = ergebnis + 'U'; break; }
         case 'S': { ergebnis = ergebnis + 'V'; break; }
         case 'T': { ergebnis = ergebnis + 'W'; break; }
         case 'U': { ergebnis = ergebnis + 'X'; break; }
         case 'V': { ergebnis = ergebnis + 'Y'; break; }
         case 'W': { ergebnis = ergebnis + 'Z'; break; }
         case 'X': { ergebnis = ergebnis + 'A'; break; }
         case 'Y': { ergebnis = ergebnis + 'B'; break; }
         case 'Z': { ergebnis = ergebnis + 'C'; break; }
         default:  { ergebnis = ergebnis + klartext.charAt(i); }    
       }          

      }

 }

Geschickte Umsetzung

Ein geschickterer Ansatz macht sich die ASCII-Tabelle zunutze. Er durchläuft den Klartext Buchstabe für Buchstabe. Für jeden Buchstaben wird die Nummer in der ASCII-Tabelle ermittelt und dieser Nummer der Schlüssel (d.h. die Anzahl der zu verschiebenden Stellen) hinzuaddiert. Anschließend wird die so ermittelte Nummer wieder in einen Buchstaben zurückverwandelt.

Dabei kann es passieren, dass das Alphabet verlassen wird (Z entspricht 90 am Ende des Alphabets). In diesem Fall geht es durch Subtraktion von 26 wieder im Alphabet von vorn los.

Elegant ist die Idee, die Entschlüsselung durch einen Schlüssel als negative Zahl zu realisieren. Dazu muss zusätzlich mit überprüft werden, ob das Alphabet nach vorn (A entspricht 65 am Anfang des Alphabets) verlassen wird.

public String verschluessele(String zeichenkette, int schluessel) {

    String ergebnis = "";

    for (int i=0; i<zeichenkette.length(); i++) {

        int zahl = (int) zeichenkette.charAt(i);

        zahl = zahl + schluessel;
        if (zahl>90) { zahl = zahl - 26; }
        if (zahl<65) { zahl = zahl + 26; }

        char zeichen = (char) zahl;
        ergebnis = ergebnis + zeichen;
    }

    return ergebnis;

}

public String entschluessele(String zeichenkette, int schluessel) {
    return verschluessele(zeichenkette, -schluessel);
}

results matching ""

    No results matching ""