Kryptologie
Die Verschlüsselungsstärke hängt direkt von der Schlüsselgröße ab. Die DES-56-Bit-Schlüssellänge ist in Anbetracht der Rechenleistung moderner Computer viel zu klein. Deshalb hat das National Institute of Standards and Technology (NIST) im Jahr 1997 eine Initiative angekündigt, um einen Nachfolger für DES zu wählen. Als Ersatz für DES wurde dann im Jahr 2001 der Advanced Encryption Standard (AES) bestimmt.
Der Data Encryption Standard (FIPS 46-3) wurde offiziell im Mai 2005 zurückgenommen, obwohl eine Variante von DES – der Triple DES (3DES) – bis 2030 für sensible Informationen der US-Regierung genehmigt ist. 3DES führt drei Iterationen des DES-Algorithmus aus. Wenn die Keying-Option Nummer eins gewählt wird, wird jedes Mal ein anderer Schlüssel verwendet, um die Schlüssellänge auf 168 Bit zu erhöhen. Doch aufgrund der Wahrscheinlichkeit eines Meet-in-the-Middle-Angriffs ist die effektive Sicherheit nur 112 Bit. 3DES-Verschlüsselung ist außerdem langsamer als normales DES.
Obwohl der Data Encryption Standard das Ende seiner Lebensdauer erreicht hat, ist sein Nutzen nicht zu unterschätzen. Er hat wichtige kryptographische Aspekte initiiert, deren Studium angestoßen und die Entwicklung neuer Verschlüsselungsalgorithmen gefördert. Bis DES war Kryptographie eine dunkle Kunst, die beschränkt war auf die Geheimdienste von Militär und Regierung. Der offene Charakter von DES sprach Wissenschaftler, Mathematiker und alle an, die Interesse an Sicherheitsfragen hatten.
Es soll die 8-Bit-Klartextfolge 1 0 1 1 0 0 1 1 mit dem vereinfachten DES chiffriert werden. Arbeiten Sie die Teilaufgaben arbeitsteilig in Ihrer Partnergruppe ab und dokumentieren Sie jeden Zwischenschritt.
Wählen Sie einen beliebigen, jeweils unterschiedlichen 8-Bit-Schlüssel. Jede Person in der Gruppe verschlüsselt anschließend mit ihrem eigenen Schlüssel.
Teilen Sie Ihre 8-Bit-Folge in zwei Hälften L0 und R0 auf. Wenden Sie dann die Verschlüsselungsfunktion auf R0 an:
- Permutieren Sie R0 mit der Permutation
(2, 3, 1, 4). Dies ergibt R0p. - Verschlüsseln Sie R0p mit XOR unter Verwendung der Zeichen an den Positionen 2, 4, 6 und 8 Ihres Schlüssels.
Die Permutation gibt an, an welche neue Position jedes Zeichen von seiner alten Position wandert. Das Zeichen an alter Position 1 wandert an neue Position 2, das Zeichen an alter Position 2 an neue Position 3, usw.
Schreiben Sie sich eine kleine Tabelle: Alte Position (1–4), Zeichen, neue Position (laut Permutation). Sortieren Sie anschließend nach der neuen Position, um R0p abzulesen.
Beim XOR gilt: gleiche Bits ergeben 0, unterschiedliche Bits ergeben 1. Schreiben Sie R0p und die vier Schlüsselzeichen (Position 2, 4, 6, 8) untereinander und verrechnen Sie Stelle für Stelle.
Verschlüsseln Sie das Ergebnis aus b) mit XOR und der linken Hälfte L0 der Klartextfolge. Das Ergebnis ist die rechte Hälfte R1 für den zweiten Durchgang.
Die neue linke Hälfte L1 ist die ursprüngliche rechte Hälfte R0 der Ausgangsbitfolge – hier ist also keine Berechnung nötig, nur die Übernahme des Werts.
Wiederholen Sie die Schritte b) bis d) mit L1 und R1. Wählen Sie diesmal während der Verschlüsselungsfunktion die Zeichen an den Positionen 1, 3, 5 und 7 Ihres Schlüssels (ungerade Positionen).
Die Permutation (2, 3, 1, 4) wird erneut auf R1 angewendet – nur der Teilschlüssel ändert sich (jetzt Position 1, 3, 5, 7 statt 2, 4, 6, 8).
Nach Runde 2 erhalten Sie L2 und R2. Der Geheimtext ist die Aneinanderreihung L2R2 (8 Bit).
Tauschen Sie Ihr Ergebnis zusammen mit Ihrem gewählten Schlüssel mit Ihrem Nachbarn. Entschlüsseln Sie anschließend den Geheimtext der anderen Person mithilfe der grafischen Darstellung des DES (siehe Abbildung oben) – führen Sie die Runden in umgekehrter Reihenfolge durch.
Da XOR selbstinvers ist (zweimal mit demselben Wert XOR-verschlüsselt ergibt wieder den Ausgangswert), lässt sich jede Runde durch erneutes Anwenden derselben Operationen in umgekehrter Reihenfolge rückgängig machen.
Starten Sie mit L2 und R2 des Geheimtextes. Da L2 = R1, kennen Sie sofort R1. Verschlüsseln Sie R1 wie in b)/e) (Permutation + XOR mit dem Runde-2-Teilschlüssel) und verrechnen Sie das Ergebnis per XOR mit R2 – das ergibt L1 = R0. Anschließend wiederholen Sie das Vorgehen für Runde 1, um L0 zu erhalten.
(Zusatz) Wiederholen Sie die Aufgabe mit einer selbst gewählten Klartextfolge, einem selbst gewählten Schlüssel und selbst gewählten Permutationen.
🎉 Alle Teilaufgaben bearbeitet!
Vergleichen Sie Ihr Vorgehen mit dem folgenden durchgerechneten Beispiel (Schlüssel 11010001).
Ausgangswerte: Klartext 1 0 1 1 0 0 1 1 → L0 = 1011, R0 = 0011. Schlüssel: 11010001 → Runde-1-Teilschlüssel 1101 (Position 2,4,6,8), Runde-2-Teilschlüssel 1000 (Position 1,3,5,7).
Runde 1
| Schritt | Rechnung | Ergebnis |
|---|---|---|
| Permutation (2,3,1,4) auf R0 | 0011 → R0p | 1001 |
| XOR mit Teilschlüssel 1101 | 1001 ⊕ 1101 | 0100 |
| XOR mit L0 = 1011 | 0100 ⊕ 1011 | R1 = 1111 |
| L1 = R0 | – | L1 = 0011 |
Runde 2
| Schritt | Rechnung | Ergebnis |
|---|---|---|
| Permutation (2,3,1,4) auf R1 | 1111 → R1p | 1111 |
| XOR mit Teilschlüssel 1000 | 1111 ⊕ 1000 | 0111 |
| XOR mit L1 = 0011 | 0111 ⊕ 0011 | R2 = 0100 |
| L2 = R1 | – | L2 = 1111 |
Geheimtext (L2 R2): 1111 0100
⚠ Da jede Gruppe einen anderen Schlüssel gewählt hat, wird Ihr Ergebnis von diesem Beispiel abweichen – das Rechenschema bleibt aber identisch. Nutzen Sie diese Musterlösung, um Ihre eigene Rechnung Schritt für Schritt zu überprüfen.
Erinnern Sie sich an den Ablauf des DES (siehe Abbildung oben). Verschaffen Sie sich zunächst gemeinsam einen Überblick zu den notwendigen Operationen, die zur algorithmischen Umsetzung des Verschlüsselns notwendig sind. Sie benötigen hierfür das Grundgerüst des Programms CryptoClass.
Diskutieren Sie gemeinsam, welche Bausteine (Operationen) für die Umsetzung des vereinfachten DES notwendig sind: eine XOR-Operation, eine Permutations-Erzeugung, eine Anwendung der Permutation sowie eine Operation, die eine komplette Runde durchführt.
CryptoClass erhalten Sie über den von Ihrer Lehrkraft bereitgestellten Link.Wählen Sie nun Ihr Anforderungsniveau für die weitere Bearbeitung aus:
Sie betrachten nur die reduzierte Variante von DES mit einer Klartext- und Schlüssellänge von 8 Bit. Bearbeiten Sie die folgenden Teilprobleme in beliebiger Reihenfolge.
Vervollständigen Sie im Programm CryptoClass die Operation xor(String s, String k), welche eine Zeichenkette s mit dem Schlüssel k XOR-verschlüsselt und das Ergebnis als Zeichenkette zurückgibt.
Erläutern Sie auch, weshalb es keine Operation zum Entschlüsseln geben muss.
Vervollständigen Sie im Programm CryptoClass die Operation permutationErstellen(int k), welche eine zufällige Permutation der Länge k erzeugt und als Ganzzahlreihung zurückgibt.
Vervollständigen Sie im Programm CryptoClass die Operation permutationVer(String s, int[] p), welche eine übergebene Zeichenkette s mit einer als Ganzzahlreihung übergebenen Permutation p und der passenden Periode verschlüsselt und das Ergebnis als Zeichenkette zurückgibt. Sie können davon ausgehen, dass die Länge von s ein Vielfaches der Länge von p ist.
Implementieren Sie im Programm CryptoClass eine Operation desVer(String s, String k, int[] p), welche eine übergebene Zeichenkette s mit dem Schlüssel k und der Permutation p eine Runde nach dem DES verschlüsselt. Integrieren Sie eine übersichtliche Konsolenausgabe, um die einzelnen Schritte zu verfolgen. Nutzen Sie hierfür die Operationen permutationVer und xor.
XOR ist selbstinvers: a ⊕ b ⊕ b = a. Ruft man
xor also einfach ein zweites Mal mit demselben Schlüssel auf, erhält man wieder den Ausgangstext – eine eigene Entschlüsselungsmethode ist daher überflüssig.Erzeugen Sie eine Liste mit den Zahlen 1 bis k und mischen Sie sie zufällig (z. B. mit
Collections.shuffle in Java oder einem eigenen Fisher-Yates-Algorithmus).🎉 Alle Teilprobleme bearbeitet!
Warum keine Entschlüsselungs-Operation nötig ist: Da XOR selbstinvers ist, entschlüsselt derselbe Aufruf von xor(geheimtext, schluessel) den Text wieder – Ver- und Entschlüsselung nutzen also dieselbe Methode.
public class CryptoClass {
// XOR-Verschlüsselung zweier gleich langer Bitfolgen
public String xor(String s, String k) {
StringBuilder ergebnis = new StringBuilder();
for (int i = 0; i < s.length(); i++) {
char bitS = s.charAt(i);
char bitK = k.charAt(i % k.length());
ergebnis.append(bitS == bitK ? '0' : '1');
}
return ergebnis.toString();
}
// Erzeugt eine zufällige Permutation der Länge k (Werte 1..k)
public int[] permutationErstellen(int k) {
int[] p = new int[k];
for (int i = 0; i < k; i++) p[i] = i + 1;
Random zufall = new Random();
for (int i = k - 1; i > 0; i--) { // Fisher-Yates-Shuffle
int j = zufall.nextInt(i + 1);
int tausch = p[i]; p[i] = p[j]; p[j] = tausch;
}
return p;
}
// Wendet Permutation p blockweise auf s an (alte Position i -> neue Position p[i])
public String permutationVer(String s, int[] p) {
int periode = p.length;
char[] ergebnis = new char[s.length()];
for (int block = 0; block < s.length() / periode; block++) {
for (int i = 0; i < periode; i++) {
int altePos = block * periode + i;
int neuePos = block * periode + (p[i] - 1);
ergebnis[neuePos] = s.charAt(altePos);
}
}
return new String(ergebnis);
}
// Eine DES-Runde: Permutation + XOR
public String desVer(String s, String k, int[] p) {
System.out.println("Eingabe: " + s);
String permutiert = permutationVer(s, p);
System.out.println("Nach Permutation: " + permutiert);
String verschluesselt = xor(permutiert, k);
System.out.println("Nach XOR (Schlüssel " + k + "): " + verschluesselt);
return verschluesselt;
}
}Sie können selbst entscheiden, ob Sie die reduzierte Variante von DES mit 8 Bit oder die Variante mit 64 Bit Klartext- und Schlüssellänge umsetzen. Zusätzlich zur Verschlüsselung soll auch die Entschlüsselung implementiert werden.
Entwerfen und implementieren Sie die Operationen xor(String s, String k), permutationErstellen(int k), permutationVer(String s, int[] p) sowie desVer(String s, String k, int[] p) in beliebiger Reihenfolge (Beschreibung siehe Grundkurs-Tab). Erläutern Sie zusätzlich, weshalb es keine Operation zum Entschlüsseln für xor geben muss.
Implementieren Sie im Programm CryptoClass eine Operation permutationEnt(String s, int[] p), welche eine übergebene Zeichenkette s mit einer Permutation p und der passenden Periode entschlüsselt und das Ergebnis als Zeichenkette zurückgibt.
Bei der Verschlüsselung gilt: altePos i → neue Position p[i]. Bei der Entschlüsselung ist die neue Position (= Position im Geheimtext) bekannt, die alte Position wird gesucht. Sie müssen also für jede Position im Geheimtext das passende i mit p[i] = Position finden.
Sie können
permutationVer nahezu unverändert wiederverwenden, wenn Sie statt p die inverse Permutation p⁻¹ übergeben. Berechnen Sie dazu vor dem Aufruf einmalig p⁻¹ mit p⁻¹[p[i]-1] = i+1.Implementieren Sie im Programm CryptoClass eine Operation desEnt(String s, String k, int[] p), welche eine übergebene Zeichenkette s mit dem Schlüssel k und der Permutation p eine Runde nach dem DES entschlüsselt. Integrieren Sie auch hier eine übersichtliche Konsolenausgabe. Nutzen Sie permutationEnt und xor.
🎉 Alle Teilprobleme bearbeitet!
Teil b) ist identisch zur Musterlösung im Grundkurs-Tab (xor, permutationErstellen, permutationVer, desVer). Ergänzend die Teile c) und d):
// Kehrt die Permutation p blockweise um (Entschlüsselung der Transposition)
public String permutationEnt(String s, int[] p) {
int periode = p.length;
char[] ergebnis = new char[s.length()];
for (int block = 0; block < s.length() / periode; block++) {
for (int i = 0; i < periode; i++) {
int altePos = block * periode + i;
int neuePos = block * periode + (p[i] - 1);
// Umkehrung: Zeichen von neuePos zurück an altePos
ergebnis[altePos] = s.charAt(neuePos);
}
}
return new String(ergebnis);
}
// Eine DES-Runde entschlüsseln: erst XOR rückgängig machen, dann Permutation umkehren
public String desEnt(String s, String k, int[] p) {
System.out.println("Geheimtext: " + s);
String entschluesselt = xor(s, k); // XOR ist selbstinvers
System.out.println("Nach XOR (Schlüssel " + k + "): " + entschluesselt);
String klartext = permutationEnt(entschluesselt, p);
System.out.println("Nach inverser Permutation: " + klartext);
return klartext;
}Da beim vereinfachten DES pro Runde zuerst permutiert und dann XOR-verschlüsselt wird, müssen beim Entschlüsseln die Operationen in umgekehrter Reihenfolge rückgängig gemacht werden: zuerst XOR (selbstinvers), dann die inverse Permutation.
eA – optional. Ein Blockverschlüsselungsverfahren mit mehreren Verschlüsselungsrunden funktioniert wie folgt:
- Ein 256-Bit-Schlüssel
keywird zufällig erzeugt und in eine linke und eine rechte Teilhälfte aufgeteilt (key1undkey2). Für alle ungeraden Runden (1, 3, 5, …) wirdkey1, für alle geraden Runden (2, 4, 6, …) wirdkey2genutzt. - Der Klartext
ktbesteht aus 256 Bit und wird zu Beginn jeder Runde in eine linke und rechte Teilhälfte aufgeteilt (ktLundktR). - In jeder Runde wird das Ergebnis der vorherigen Runde als neuer Klartext genutzt.
Ablauf einer Verschlüsselungsrunde:
- Klartext und Schlüssel in 2 gleich große Blöcke aufteilen.
- Rechte Klartexthälfte mit dem entsprechenden Schlüssel XOR-verschlüsseln.
- Ergebnis aus Schritt 2 um eine Position nach rechts rotieren (das erste Zeichen wird das zweite usw., das letzte Zeichen wird das erste).
- Ergebnis aus Schritt 3 mit der linken Klartexthälfte XOR-verschlüsseln.
- Ergebnis nach einer Runde neu zusammensetzen.

Die Operation rundenVer(int[] kt, int[] key, int n) ist als Struktogramm gegeben; xor(int[] a, int[] b) führt die XOR-Verschlüsselung zweier Reihungen durch, rotiere(int[] a) führt die in Schritt 3 beschriebene Rotation durch.
Analysieren Sie die Funktionsweise der Operation rundenVer. Gehen Sie hierbei auch auf die Anweisungen „gib kt zurück" und „gib rundenVer(gt, key, n-1) zurück" ein.

rundenVer ruft sich innerhalb der eigenen Definition selbst wieder auf (mit n-1 statt n) – das ist eine rekursive Funktion.Was passiert, wenn
n = 0 ist? In diesem Fall wird direkt kt zurückgegeben, ohne eine weitere Runde durchzuführen – das ist der Abbruch der Rekursion (Basisfall). Ohne diesen Fall würde sich die Funktion unendlich oft selbst aufrufen.Ist
n > 0, wird zunächst eine Runde durchgeführt (Ergebnis gt) und anschließend rundenVer(gt, key, n-1) aufgerufen – also dieselbe Funktion mit dem Ergebnis der aktuellen Runde als neuem Klartext und einer Runde weniger. Nach genau n Aufrufen ist n = 0 erreicht und die Rekursion endet.Implementieren Sie ein Programm Runden256, in dem eine Ganzzahlreihung kt der Größe 256 und eine zweite Ganzzahlreihung key der Größe 256 mit zufälligen Werten (0 oder 1) erstellt werden.
Implementieren Sie im Programm Runden256 die Operationen xor(int[] a, int[] b), rotiere(int[] a) und rundenVer(int[] kt, int[] key, int n). Testen Sie Ihre Ergebnisse anschließend.
Nutzen Sie
Arrays.copyOfRange(...), um kt und key jeweils in eine linke und eine rechte Hälfte (128 Elemente) aufzuteilen.Prüfen Sie mit
n % 2, ob die aktuelle Runde ungerade oder gerade ist, um zu entscheiden, ob key1 oder key2 verwendet wird. Achten Sie darauf, ob Ihre Rundenzählung aufsteigend oder absteigend erfolgt.Bei der Rotation um eine Position nach rechts wandert jedes Element eine Position weiter, das letzte Element an den Anfang:
ergebnis[(i+1) % laenge] = a[i].🎉 Alle Teilaufgaben bearbeitet!
Aufgabe 5a – Analyse der Rekursion
rundenVer ist eine rekursive Operation, die eine Verschlüsselungsrunde durchführt und sich danach mit dem Rundenergebnis gt und einem um 1 verringerten Rundenzähler n-1 selbst erneut aufruft. Die Anweisung „gib kt zurück" ist der Basisfall der Rekursion: Sobald n = 0 erreicht ist (also alle gewünschten Runden durchlaufen wurden), wird keine weitere Runde mehr ausgeführt, sondern direkt das aktuelle Ergebnis zurückgegeben. Ohne diesen Fall würde sich die Funktion unendlich oft aufrufen. Die Anweisung „gib rundenVer(gt, key, n-1) zurück" ist der rekursive Fall: Sie sorgt dafür, dass nach Durchführung einer Runde automatisch die nächste Runde mit dem neuen Klartext gt und einem Rundenzähler gestartet wird, der jedes Mal um 1 sinkt – nach genau n Aufrufen ist der Basisfall erreicht.
Aufgabe 5b & c – Beispielimplementierung (Java)
import java.util.Arrays;
import java.util.Random;
public class Runden256 {
public static void main(String[] args) {
Random zufall = new Random();
int[] kt = erzeugeZufallsfolge(256, zufall);
int[] key = erzeugeZufallsfolge(256, zufall);
int[] geheimtext = rundenVer(kt, key, 4); // z.B. 4 Runden testen
System.out.println("Geheimtext: " + Arrays.toString(geheimtext));
}
private static int[] erzeugeZufallsfolge(int laenge, Random zufall) {
int[] folge = new int[laenge];
for (int i = 0; i < laenge; i++) folge[i] = zufall.nextInt(2); // 0 oder 1
return folge;
}
// XOR zweier gleich langer Ganzzahlreihungen (bitweise)
public static int[] xor(int[] a, int[] b) {
int[] ergebnis = new int[a.length];
for (int i = 0; i < a.length; i++) {
ergebnis[i] = (a[i] == b[i]) ? 0 : 1;
}
return ergebnis;
}
// Rotiert die Reihung um eine Position nach rechts
public static int[] rotiere(int[] a) {
int[] ergebnis = new int[a.length];
for (int i = 0; i < a.length; i++) {
ergebnis[(i + 1) % a.length] = a[i];
}
return ergebnis;
}
// Rekursive Rundenfunktion
public static int[] rundenVer(int[] kt, int[] key, int n) {
if (n == 0) {
return kt; // Basisfall
}
int haelfte = kt.length / 2;
int[] ktL = Arrays.copyOfRange(kt, 0, haelfte);
int[] ktR = Arrays.copyOfRange(kt, haelfte, kt.length);
int[] keyL = Arrays.copyOfRange(key, 0, haelfte);
int[] keyR = Arrays.copyOfRange(key, haelfte, key.length);
// ungerade Runden (n ungerade, absteigend gezählt) -> keyL, sonst keyR
int[] rundenSchluessel = (n % 2 != 0) ? keyL : keyR;
int[] xorErgebnis = xor(ktR, rundenSchluessel);
int[] rotiert = rotiere(xorErgebnis);
int[] neueRechte = xor(rotiert, ktL);
int[] gt = new int[kt.length];
System.arraycopy(ktR, 0, gt, 0, haelfte); // neue linke Hälfte = alte rechte Hälfte
System.arraycopy(neueRechte, 0, gt, haelfte, haelfte);
return rundenVer(gt, key, n - 1); // rekursiver Fall
}
}⚠ Hinweis: Ob key1 (linke Hälfte) für ungerade oder gerade Runden verwendet wird, hängt davon ab, ob Ihre Rundenzählung n aufsteigend oder absteigend gezählt wird – passen Sie die Bedingung n % 2 ggf. an Ihre eigene Zählweise an.
Asymmetrische Verfahren
Probleme mit dem Schlüsseltausch
Stellen Sie sich vor, Alice und Bob möchten ein sehr sicheres Verschlüsselungsverfahren nutzen, um sich geheime Nachrichten zu schreiben.

Bevor die beiden Nachrichten versenden können, müssen sie sich auf einen gemeinsamen Schlüssel einigen. Dafür müssen sich die beiden entweder treffen oder den Schlüssel über die Post oder einen digitalen Kommunikationsweg austauschen. Letzteres ist heutzutage eher wahrscheinlich. Wenn nun die neugierige Eve erfahren hat, dass die beiden geheime Nachrichten austauschen, möchte sie unbedingt erfahren, welche Geheimnisse die beiden wohl zu bereden haben. Wie kann Eve dabei vorgehen?
Alice schickt nun eine verschlüsselte Nachricht an Bob und Eve hat die Möglichkeit, diese Nachricht abzufangen.

Da die Nachricht verschlüsselt und die Verschlüsselung sehr sicher ist, nützt ihr dieser Schritt nichts. Das Problem ist aber, dass Eve offenbar die Möglichkeit hat, Nachrichten abzufangen und auch weiterzuleiten. Wenn sie das mit der verschlüsselten Nachricht kann, kann sie sicher auch den Austausch des Schlüssels abfangen und weiterleiten. In der analogen Welt könnte Eve einfach die Briefe mit dem Schlüssel und der verschlüsselten Nachricht abfangen. Somit könnte sie jede Nachricht entschlüsseln, lesen und unbemerkt weiterleiten.
Bei allen symmetrischen Verschlüsselungsverfahren muss ein gemeinsamer Schlüssel ausgetauscht werden. Egal wie sicher das eigentliche Verschlüsselungsverfahren ist, stellt dieser Schlüsseltausch immer einen Angriffspunkt und damit eine Schwachstelle dar. Diese Schwachstelle existiert, da beide Kommunikationspartner den gleichen Schlüssel benötigen.
Ein Verfahren ist nur so lange sicher, wie der Schlüssel geheim gehalten werden kann. Sie können davon ausgehen, dass bei Massenkommunikation, wie im Internet oder in Messenger-Diensten, das Verschlüsselungsverfahren selbst nicht geheim ist. Demnach müssen angreifende Personen oder Maschinen immer nur den Schlüssel „finden“. Je mehr mögliche Schlüssel infrage kommen, desto schwieriger ist dies. Ein möglichst großer Schlüsselraum erhöht also die Sicherheit enorm.
Stellen Sie sich folgende Situation vor: Karl Kunde sitzt sonntags vor dem PC, um zu shoppen. Er entdeckt den Online-Shop von Vera Verkäuferin, bei dem er gerne einige Dinge erwerben möchte. Für die Bezahlung möchte er seine Kreditkarte nutzen, die Vera auch akzeptiert. Selbstverständlich sollen die notwendigen Daten ausschließlich an Vera gehen und niemandem sonst, vor allem nicht Spike Spitzbube, der sehr gerne die Kreditkarteninformationen von Karl in die Hände bekäme. Sie können davon ausgehen, dass Vera und Karl sich aufgrund räumlicher Distanz nicht treffen können.


Bilder von einer KI erstellt

Erläutern Sie, warum ein symmetrisches Verschlüsselungsverfahren für die Kommunikation von Vera und Karl nicht geeignet ist.
Denken Sie an den Abschnitt „Probleme mit dem Schlüsseltausch“ oben: Welches grundlegende Problem haben Alice und Bob, bevor sie überhaupt verschlüsselt kommunizieren können?
Übertragen Sie das Problem auf die Situation: Wie müssten Karl und Vera einen gemeinsamen Schlüssel vereinbaren, wenn sie sich nicht treffen können? Welche Rolle könnte Spike dabei einnehmen?
Karl und Vera haben ein neues, besonderes Verfahren entwickelt. Dieses Verfahren kann man sich wie ein Schloss vorstellen. Doch dieses Schloss hat eine Besonderheit: Es besitzt zwei Schlüssellöcher.


Das Neue ist hier, dass sowohl Karl als auch Vera einen eigenen, privaten Schlüssel für das Schloss besitzen.

Der gelbe Schlüssel ist Karls privater Schlüssel und der grüne Veras. Wenn nun eine Nachricht verschlüsselt werden soll, muss das Schloss an diese Nachricht gehängt und geschlossen werden. Wenn die Nachricht wieder gelesen werden soll, muss das Schloss an der Nachricht geöffnet werden.
Situation: Karl möchte eine verschlüsselte Nachricht an Vera schicken

Beschreiben Sie den Ablauf des Verfahrens, wenn Vera eine Nachricht an Karl schicken möchte.
Überlegen Sie zunächst, welcher der beiden Schlüssel (gelb oder grün) zu Karl gehört und welcher zu Vera. Wer soll die Nachricht am Ende lesen können?
Beachten Sie, dass das Schloss zwei getrennte Schritte kennt: das Anhängen/Schließen (Verschlüsseln) und das Öffnen (Entschlüsseln) mit einem bestimmten Schlüssel. Beschreiben Sie beide Schritte einzeln.
Der neugierige Spike hat nun die Möglichkeit, den verschlüsselten Brief abzufangen. Untersuchen Sie, welche der am Kryptosystem beteiligten Komponenten (Schloss, Veras Schlüssel, Karls Schlüssel) öffentlich bekannt sein bzw. ausgetauscht werden dürfen und welche nicht.
Gehen Sie den Ablauf aus a) noch einmal durch: Welche der drei Komponenten wird beim Versenden der Nachricht überhaupt über den unsicheren Kanal transportiert?
Überlegen Sie für jede Komponente einzeln: Könnte Spike allein mit dieser Komponente (ohne die anderen beiden) die Nachricht entschlüsseln?
Karl und Vera müssen das gemeinsame Schloss vorher austauschen. Das soll zwar auf einem möglichst sicheren Kanal geschehen, aber der clevere Spike kann das Schloss abfangen. Entscheiden Sie, ob Spike mit dem Schloss etwas anfangen kann.
Kann man ein Schloss ohne einen passenden Schlüssel öffnen? Kann man es aber verschließen?
Überlegen Sie, ob Spike mit dem bloßen Besitz des Schlosses bereits abgefangene oder zukünftige Nachrichten lesen könnte.
Nun ändern wir die Situation: Karl und Vera haben einen eigenen Schlüssel, wie vorher auch, aber nun jeweils ein eigenes Schloss. Wir gehen davon aus, dass beide Schlösser nur durch den jeweiligen (eigenen) Schlüssel geöffnet werden können. Das Verschließen eines Schlosses kann durch jede Person vorgenommen werden.

Erläutern Sie, weshalb Karl und Vera vorher ihre jeweiligen Schlösser geöffnet austauschen oder an irgendeinem öffentlich zugänglichen Ort deponieren müssen, wenn die beiden verschlüsselte Nachrichten austauschen wollen.
Untersuchen Sie, welchen Nutzen Spike das Abfangen
- der Schlösser,
- einer verschlüsselten Nachricht,
- beider oben genannten Teile
bringen würde.
Überlegen Sie: Wenn Vera an Karl schreiben möchte, mit wessen Schloss muss sie die Nachricht verschließen, damit nur Karl sie öffnen kann?
Ein Schloss kann von jeder Person verschlossen werden – es muss also nicht geheim sein. Was würde passieren, wenn das Schloss stattdessen geheim gehalten würde?
Prüfen Sie für jeden der drei Fälle separat: Was kann Spike mit den abgefangenen Informationen tun, wenn er (1) nur das Schloss, (2) nur die verschlüsselte Nachricht oder (3) beides besitzt? Kommt er in irgendeinem Fall an den Klartext?
Erläutern Sie, was die Verfahren in dieser Aufgabe von allen bisher betrachteten Verschlüsselungsverfahren unterscheidet und worin genau der Mehrwert an Sicherheit liegt. Geben Sie auch ganz deutlich an, welche Komponenten eines solchen Kryptosystems öffentlich, also bekannt, und welche privat, also geheim, sein müssen. Gehen Sie dabei auch darauf ein, weshalb bestimmte Komponenten gerade öffentlich sein müssen.
Erinnern Sie sich an das Kernproblem symmetrischer Verfahren aus dem Einführungsabschnitt: Was mussten Alice und Bob dort zwingend austauschen, was hier nicht mehr nötig ist?
Überlegen Sie: Damit Vera überhaupt eine Nachricht an Karl verschlüsseln kann, muss sie etwas von Karl kennen. Muss dieses „etwas“ also zwangsläufig öffentlich zugänglich sein?
Die privaten Schlüssel sind geheim, während die öffentlichen Schlüssel für jede Person zugänglich sind bzw. auch sein müssen.





























