Java Schnellstart – Coding Challenge 2
Du bist in einem öffentlichen WLAN eingewählt, aber möchtest nur ungern sensible Daten (wie bspw. WhatsApp-Nachrichten oder Bankdaten) übermitteln. Die Angst, dass ein unbefugter Dritter mitliest ist immer da. Das Abfangen von sensiblen Daten ist nicht nur Ursprung vieler Hollywood-Filme, sondern ebenso ein häufig praktizierter Angriff in der realen Welt. Diese Attacke ist auch als Man-In-The-Middle bekannt.
Genau hier startet deine nächste Coding Challenge:
Bob möchte an Alice eine Nachricht senden. Dummerweise befindet sich ein böser Hacker genau in der Mitte der Kommunikation (Man-In-The-Middle). Er kann daher sämtliche Nachrichten von Bob und Alice mitlesen. 
Wir brauchen eine Verschlüsselung.
Um dieses Problem zu beheben werden wir unsere Text-Nachricht verschlüsseln. Das ist eine sehr vereinfachte Lösung, jedoch ist ein einfacher Schutz besser als kein Schutz.
Wir werden den sogenannten Caesar-Algorithmus in sehr grundlegender Form implementieren. In der Kriegsführung der letzten Jahrhunderte musste man, um Nachrichten zu senden, seine Botschaften so unkenntlich wie möglich machen. Falls der Nachrichtenbote geschnappt wurde, konnte der Feind die Informationen nicht auslesen. Julius Caesar hat dabei die Zeichen im Alphabet um eine bestimmte Anzahl verschoben. Diese Anzahl ist unser "Schlüssel" zum Verschlüsseln und Entschlüsseln der Nachricht.
Ein Beispiel: Ist unser Schlüssel die Nummer 2, so wird:
- aus jedem A in unserem Text ein C.
- Aus jedem D wird ein F und
- aus einer beliebigen Zahl bspw. 3 wird eine 5.
Bevor wir unseren kompletten Text verschlüsseln, tasten wir uns langsam voran. Wir verschlüsseln einzelne Zeichen genauer gesagt verschieben diese.
In der letzten Lektion hast du erfahren, dass jeder Buchstabe von einem char als Zahl abgespeichert wird. Diese Zuordnung ist der sogenannte Unicode-Standard. Das ist wie eine Art Tabelle, wo jedem Zeichen eine Zahl zugeordnet ist. Möchten wir also ein Zeichen um 2 nach rechts verschieben, müssen wir unser char in eine Zahl z.B. int umwandeln sowie +2 addieren und die Zahl wieder zurück in ein char "casten".
1. Deine erste Aufgabe - Nachrichten verschlüsseln:
Dein Code wird in den unten stehenden Code-Editor für Aufgabe 1 geschrieben. Im Code-Editor findest du bereits unsere Standard Main-Klasse sowie die main Methode. Ebenso habe ich dir in Zeile 4 eine Variable namens "nachricht", mit dem Wert "a" erstellt. Das "a" ist die Nachricht, die verschlüsselt werden soll.
1.1 Erste Aufgabe - Methode definieren:
Definiere eine Methode mit dem Namen "verschluesselung". Diese Methode soll folgende zwei Parameter entgegennehmen können:
- char zeichen
- int schluessel
[lp_spoiler title="Lösung zu 1.1 anzeigen" class="da"]
Eine mögliche Lösung:
class Main {
public static void main(String[] args) {
char nachricht = 'a';
}
public static char verschluesselung(char zeichen, int schluessel)
{
// Methodenkörper kommt hier rein
}
}
[/lp_spoiler]
1.2 Zweite Aufgabe - Methodenkörper für die Verschlüsselung
Sobald du die erste Aufgabe erledigt hast, kannst du mit dem Programmieren des Methodenkörpers starten. Deine Aufgabe liegt darin, die Verschlüsselung der nachricht zu bauen.
- Zunächst musst du den an die Methode übergebenen Parameter "zeichen" vom Datentyp char in int umwandeln. Speichere den neuen Wert in der Variable "zahl".
- Addiere nun den übergebenen Schlüssel "schluessel" mit der Variable "zahl". Speichere das Ergebnis in der Variable "zahl".
- An dieser Stelle hast du die Nachricht erfolgreich mit dem Caesar-Algorithmus codiert. Jetzt musst du die Zahl "zahl" (Datentyp: int) wieder in einen Buchstaben (Datentyp "char") umwandeln. Speichere den umgewandelten Char-Wert in der Variable verschluesseltesZeichen.
- Benutze nun den "return"-Befehl, um die Geheimnachricht (verschluesseltesZeichen), wieder in die Main-Methode zurückzugeben.
[lp_spoiler title="Lösung zu 1.2 anzeigen" class="da"]
Eine mögliche Lösung:
class Main {
public static void main(String[] args) {
char nachricht = 'a';
}
public static char verschluesselung(char zeichen, int schluessel)
{
// Wandelt die Nachricht "char" in eine Zahl "int" um
int zahl = (int)zeichen;
// Verschiebe Stelle um den angegebenen Schlüssel
zahl = zahl + schluessel;
// Wandelt die neue Zahl wieder in ein Zeichen um
char verschluesseltesZeichen = (char)zahl;
// Gibt das verschlüsselte Zeichen an die Main-Methode zurück
return verschluesseltesZeichen;
}
}
[/lp_spoiler]
1.3 Dritte Aufgabe - Die Verschlüsselung mit prinln testen:
Im letzten Schritt wollen wir die Verschlüsselung testen. Wenn du die Variable verschluesseltesZeichen mit dem return-Statement zurückgegeben hast, können wir nun in der Main-Methode auf den Rückgabewert zugreifen.
1. Erstelle in Zeile 6 (unter der "nachricht" Variable) einen Methodenaufruf der in Aufgabe 1.1 erstellten Methode "verschluesselung". Da die Methode zwei Parameter benötigt, geben wir ihr folgende Werte mit:
- nachricht (steht für das zu übergebende Zeichen)
- 2 (steht für den zu übergebenden Schlüssel)
2. Speichere den Methodenaufruf in der Variable "verschluesselt" (Datentyp: char).
Alles erledigt?
3. Rufe als Letztes den println-Befehl mit dem Wert "verschluesselt" auf. Wenn du alles richtig gemacht hast, wurde deine Nachricht mit dem Buchstaben "a" nun in den Buchstaben "c" umgewandelt/verschlüsselt.
Code-Editor für Aufgabe 1:
[lp_spoiler title="Gesamte Lösung zu Aufgabe 1 anzeigen" class="da"]
Eine mögliche Lösung:
class Main {
public static void main(String[] args) {
char nachricht = 'a';
char verschluesselt = verschluesselung(nachricht, 2);
System.out.println(verschluesselt); // Ausgabe c
}
public static char verschluesselung(char zeichen, int schluessel)
{
// Wandelt die Nachricht "char" in eine Zahl "int" um
int zahl = (int)zeichen;
// Verschiebe Stelle um den angegebenen Schlüssel
zahl = zahl + schluessel;
// Wandelt die neue Zahl wieder in ein Zeichen um
char verschluesseltesZeichen = (char)zahl;
// Gibt das verschlüsselte Zeichen an die Main-Methode zurück
return verschluesseltesZeichen;
}
}
[/lp_spoiler]
Im Grunde haben wir die wichtigsten Grundlagen des zweiten Moduls in der oben stehenden Aufgabe bereits wiederholt und gefestigt. Wenn du Lust hast, kannst du jedoch noch eine weitere Übung machen, um die Nachricht wieder zu entschlüsseln.
2. Freiwillige Zusatzaufgabe: Nachricht wieder Entschlüsseln
Damit Alice die Nachricht auch lesen kann, benötigen wir eine weitere Methode, welche unser verschlüsseltes Zeichen wieder entschlüsseln kann. Dafür müssen wir dasselbe wie beim Verschlüsseln machen. Nur, dass wir diesmal das Zeichen nach links verschieben und nicht nach rechts.
Deine Aufgabe: Implementiere eine Entschlüsselungsmethode, welche einen Schlüssel und ein verschlüsseltes Zeichen als Parameter entgegennimmt. Das entschlüsselte Zeichen soll dann zurückgeliefert werden.
Code-Editor für Aufgabe 2:
[lp_spoiler title="Lösung für Aufgabe 2 anzeigen" class="da"]
Eine von vielen möglichen Lösungen sieht so aus:
class Main {
public static void main(String[] args) {
char zeichen = 'a';
char verschlüsselt = verschlüsselung(zeichen, 2);
char entschlüsselt = entschlüsselung(verschlüsselt, 2);
System.out.println(verschlüsselt); // Ausgabe c
System.out.println(entschlüsselt); // Ausgabe a
}
public static char verschlüsselung(char zeichen, int schlüssel)
{
// Bekomme Zahl von Zeichen
int zahl = (int)zeichen;
// Verschiebe Stelle um den angegebenen Schlüssel
zahl = zahl + schlüssel;
// Wandel neue Zahl in ein Zeichen um
char verschlüsseltesZeichen = (char)zahl;
return verschlüsseltesZeichen;
}
public static char entschlüsselung(char zeichen, int schlüssel)
{
// Bekomme Zahl von Zeichen
int zahl = (int)zeichen;
// Verschiebe Stelle um den angegebenen Schlüssel
zahl = zahl - schlüssel;
// Wandel neue Zahl in ein Zeichen um
char verschlüsseltesZeichen = (char)zahl;
return verschlüsseltesZeichen;
}
}
[/lp_spoiler]
Fazit
Verschlüsselung spielt in der modernen Kommunikationstechnik eine große Rolle. Natürlich sollte dir bewusst sein, dass der Caesar-Algorithmus in der Praxis kaum angewandt wird, weil man ihn sehr leicht knacken kann. Man muss einfach nur verschiedene Schlüssel durchlaufen und schauen, wann der Text Sinn ergibt. Dennoch ist etwas Sicherheit besser als keine.
Im nächsten Modul lernst du, neben If-Entscheidungen und Schleifen, viele weitere nützliche Werkzeuge der Programmierung kennen. Damit kannst du diesen einfachen Verschlüsselungsalgorithmus noch effektiver und sicherer nachbauen. Sei gespannt. Wir sehen uns in Modul 3.