Symmetrische Verschlüsselung

Lernziele:

Das Ver- und Entschlüsseln von Nachrichten wird schon seit der Antike betrieben. Folgende Übersicht zeigt eine mögliche Einteilung der bestehenden Verschlüsselungs-Verfahren:

Auf dieser Seite betrachten wir ein kleine Auswahl von symmetrischen Verschlüsselungsverfahren:

• Von den klassischen Substitutionsverfahren betrachten wir die Caesar-Verschlüsselung als Beispiel einer monoalphabetischen Substituion und
• die Vigenère-Chiffre als Beispiel einer polyalphabetischen Substitution.
• Ausserdem betrachten wir die XOR-Verschlüsselung als Beispiel einer modernen symmetrischen Verschlüsselung. Modern ist sie insofern, als sie mit Einsen und Nullen operiert und damit auf sämtliche Daten in digitaler Form anwendbar ist.

• Bei der symmetrischen Verschlüsselung können Daten mit demselben Schlüssel (z.B. eine Zahl, ein Wort etc.) verschlüsselt und später wieder entschlüsselt werden. Deshalb heisst sie „symmetrisch“: der Schlüssel funktioniert in beide Richtungen. Das ist gut, wenn es eine Möglichkeit gibt, den Schlüssel sicher auszutauschen.
• Bei der Kommunikation im Internet ist das schwierig: Bevor ich eine sichere Verbindung zu einem Server aufbauen kann, müsste ich diesem Server meinen Schlüssel geben – aber eben auf einem sicheren Weg. Ich könnte ihn vielleicht per Post schicken – aber das ist natürlich nicht praktikabel. Deshalb wird hier die asymmetrische Verschlüsselung verwendet. Dabei wird für die Verschlüsselung ein anderer Schlüssel verwendet als für die Entschlüsselung: Angenommen, mein Schlüssel A verschlüsselt meine Daten aber nur Schlüssel B entschlüsselt sie. Dann könnte ich Schlüssel A vervielfachen und allen zur Verfügung stellen, die mir auf sicherem Weg eine Nachricht senden wollen. Sie können die Nachrichten mit A verschlüsseln – und nur ich kann die verschlüsselten Nachrichten entschlüsseln, denn nur ich habe Schlüssel B.

Folgende Begriffe solltest du kennen:

• Kryptologie: Wissenschaft / Lehre der Ver- und Entschlüsselung (altgr. kryptós = verborgen).
• Klartext – cleartext, plaintext
• Chiffrat – Geheimtext, ciphertext, verschlüsselter Text
• Schlüssel – key: Zum Beispiel ein Text oder ein Wert, mit dem der Klartext in das Chiffrat und das Chirffat wieder in den Klartext gewandelt werden kann. Der Schlüssel alleine reicht noch nicht aus, um einen verschlüsselten Text zu entschlüsseln: Es braucht auch das richtige Verfahren.
• Verschlüsselungsverfahren, auch Chiffre: Wandelt den Klartext in das Chiffrat und umgekehrt.
• Schlüsselraum: Anzahl möglicher Schlüssel bei einem Verschlüsselungsverfahren:
  • Angabe in Binärstellen: 4-Bit: 16 mögliche Schlüssel; 10 Bit: 1024 mögliche Schlüssel.
  • Der Schlüsselraum für die Caesar-Verschlüsselung ist 25, also knapp 5 Bit.
• Geheimalphabet: Ordnet die Klartextbuchstaben den Geheimtextbuchstaben zu – gibt es so nur bei der monoalphabetischen Substitution.

Die Caesar-Verschlüsselung ist eine sehr einfache Form der monoalphabetischen Substitution. Bei der Substitution werden Buchstaben durch andere Buchstaben ersetzt (lat. substituere = „ersetzen“). Monoalphabetisch ist sie deshalb, weil sie nur ein (mono) Geheim-Alphabet benutzt. Bei der Caesar-Verschlüsselung ergibt sich das Geheimalphabet durch Verschiebung. Ist der Schlüssel 3, so wird jeder Buschstabe um 3 Stellen verschoben: Was im Geheim-Alphabet ein D ist, ist im richtigen Alphabet ein A usw.:

Der Name der Caesar-Verschlüsselung geht auf den römischen Feldherrn Gaius Julius Caesar zurück, der diese Methode zur Verschlüsselung vertaulicher Botschaften benutzte. Sicher ist die Methode heute keineswegs: Am Geheimtext lässt sich anhand von Mustern leicht erkennen, dass es sich um ein Substitutions-Verfahren mit Verschiebung des Alphabets handelt. Und es sind nur 25 verschiedene Schlüssel (Verschiebewerte) möglich. So geht es sehr schnell, diese durchzuprobieren und auf den richtigen Schlüssel zu kommen.

Programmiere einen Verschlüsselsungs-Algorithmus mit python! Nutze einen der folgenden Editoren:

• WebTigerPython
• Bottom Editor

Wenn du keine Idee hast, wie das gehen könnte: Lies folgende Schritte genau durch und überlege für jede Code-Zeile, ob du sie verstehst.

Wir importieren die Klasse string für Elemente und Funkionen zu Zeichenketten (Texten). Die Klasse string enthält zum Beispiel die feste Zeichenkette ascii_uppercase:

import string print(string.ascii_uppercase)

Die Funktion find() gibt den Index (= die Position) eines bestimmten Buchstabens innerhalb einer Zeichenkette zurück. Wenn sie den gesuchten Buchstaben nicht findet, gibt sie den Wert -1 zurück.

import string print(string.ascii_uppercase) print(string.ascii_uppercase.find('C'))

Einen einzelnen Buchstaben können wir nun wie folgt „verschlüsseln“, also um x Stellen im Alphabet verschieben:

1. Index herausfinden (Position dieses Buchstabens im Alphabet, von 0 bis 25).
2. Index um Verschiebungswert (Schlüssel) erhöhen.
3. Buchstaben ersetzen durch jenen unter neuem Index.

import string key = 5 # Um so viel wird verschoben letter = "A" print(letter) index = string.ascii_uppercase.find(letter) # 1. index = index + key # 2. letter = string.ascii_uppercase[index] # 3. print(letter)

Um nun eine Zeichenkette (ein Wort oder einen Text) zu verschlüsseln, führen wir die Befehle aus Schritt 3 für jeden Buchstaben der Zeichenkette aus. Dazu verwenden wir eine for-Schleife:

import string key = 5 # Um so viel wird verschoben plainText = "Veni vidi vici" cipherText = "" for letter in plainText.upper(): # für jeden Buchstaben in plainText... index = string.ascii_uppercase.find(letter) index = (index + key) % 26 letter = string.ascii_uppercase[index] cipherText = cipherText + letter print(cipherText)

Beachte Folgendes:

• Die Funktion upper() macht aus jedem Buchstaben in plainText einen Grossbuchstaben. Dadurch enthält die Variable letter immer einen Grossbuchstaben – egal, ob der Buchstabe in plainText gross oder klein war. Das ist wichtig, denn in der Zeichenkette ascii_uppercase befinden sich nur Grossbuchstaben und die Funktion find() würde darin nichts finden, wenn letter einen Kleinbuchstaben enthielte.
• Damit index nicht grösser als 25 wird, wird die Addition index + key mit dem Modulo-Operator ergänzt: x modulo 26 (x % 26) gibt den Rest der Division x / 26 zurück: Für alle Werte grösser 26 gibt diese Operation also an, um wieviel grösser der Wert ist. Für index = 22 (Buchstabe 'W') und key = 5 ergäbe sich der Rest 1. Der neue Buchstabe wäre dann 'B' ('A' ist an Position 0).
• In der letzten Zeile in der for-Schleife wird jeweils der neue Buchstabe zu der Zeichenkette cipherText hinzugefügt.

Das Programm in Schritt 4 gibt ein Chiffrat ohne Leerschläge aus: Anstelle eines Leerschlags wird jeweils ein 'E' ausgegeben. Das macht Sinn: Wenn find() ein Zeichen nicht findet, gibt es den Wert -1 zurück. -1 + 5 (Verschiebungswert) ergibt 4 – das ist die Position des Buchstabens E.

1. Überlege, welches Chiffrat sich mit anderem Schlüssel (Verschiebungswert) ergäbe. Ändere den Schlüssel entsprechend und überprüfe deine Überlegung.
2. Verbessere das Programm so, dass Leerschläge nicht verschoben werden, sodass das Chiffrat an den gleichen Stellen Leerschläge enthält wie der Klartext. Dein Programm soll erst den Klartext, dann das Chiffrat ausgeben.

1. Ergänze die Funktion caesar(plainText, key), sodass sie den verschlüsselten Text (Chiffrat) zurückgibt:
2. Nutze die Funktion caesar(), um das Chiffrat wieder zu etnschlüsseln…

import string def caesar(clearText, key): # deine Funktion pass klartext = "Veni vidi vici" geheimtext = caesar(klartext, 7) print(geheimtext)

Wenn alles funktioniert: Speichere deinen Code! (Link kopieren und ablegen.)

import string
 
def caesar(clearText, key):
    alphabet = string.ascii_uppercase
    ciphertext = ""
    for letter in clearText.upper():
        if letter in alphabet:
            index =  alphabet.find(letter)
            index = (index + key) % 26
            letter = alphabet[index]
        ciphertext = ciphertext + letter
    return ciphertext
 
klartext = "Veni vidi vici"
geheimtext = caesar(klartext, 7)
print(geheimtext)
print(caesar(geheimtext, -7))

1. Nutze deine Funktion caesar für ein Programm, das alle möglichen Caesar-Schlüssel durchprobiert. Dein:e Nachbar:in gibt dir dann einen caesar-verschlüsselten Text ohne Angabe des Schlüssels und du musst den Klartext herausfinden.
2. Verbessere deine Funktion caesar, sodass sie Klein- und Grossbuchstaben unterscheidet: caesar(„Veni vidi vici“, 5) soll „ajsn Anin Anhn“ zurückgeben – und die Entschlüsselung mit -5 soll dann wieder „Veni vidi vici“ ergeben.

Eine zufällige monoalphabetische Substitution ist weniger leicht zu knacken als beispielsweise eine Substituion gemäss der Caesar-Methode. Hier wird für jeden Buchstaben eine andere (wenn möglich zufällige) Verschiebung festgelegt. So wird jedem Buchstaben ein anderer zugewiesen. Etwa so:

Wieder entsteht zwar nur ein Geheimalphabet, dieses zu knacken ist aber schwieriger als bei der Caesar-Methode, denn hier gibt es weit mehr mögliche Kombinationen:
“Der erste Buchstabe „A“ kann an eine von 26 möglichen Alphabetpositionen platziert werden. Für den zweiten Buchstaben „B“ gibt es dann noch 25 mögliche Plätze zur Auswahl, für den dritten 24, und so weiter. Insgesamt berechnen sich so 26·25·24·23···4·3·2·1 […] Möglichkeiten zur Verwürfelung des Alphabets. Das sind ungefähr 4·10²⁶ Fälle und entspricht etwa 88 bit.” (wikipedia.org/wiki/Monoalphabetische_Substitution)

Ist die zufällige monoalphabetische Substitution damit sicher? Nein, denn dank der Häufigkeitsanalyse ist auch ein Geheimtext, der nach dieser Methode verschlüsselt wurde, leicht zu knacken:

Die Häufigkeitsanalsye macht sich zu nutzen, dass die Buchstaben in einer Sprache in einer bestimmten Häufigkeit vorkommen, für einen Text in deutscher Sprache ist die Häufigkeit der einzelnen Buchstaben wie folgt:

Um nun einen Geheimtext zu entschlüsseln, könntest du wie folgt vorgehen:

1. Du zählst, wie oft jeder Buchstabe im Geheimtext vorkommt und ordnest die Buchstaben des Geheimtexts nach Häufigkeit.
2. Vorausgesetzt du weisst, dass der Klartext in deutscher Sprache verfasst ist, kannst du nun annehmen, dass der häufgiste Buchstaben im Geheimtext wohl einem 'E' im Klartext entspricht, der zweithäufigste einem 'N' usw.

Die Häufigkeiten der Geheimtext-Buchstaben stimmt nicht immer überein mit der Standard-Häufigkeit des entsprechenden Klartext-Buchstabens. Je kürzer der Text, desto eher kann sie abweichen. Klar: Im Text „Anna“ zum Beispiel kommt das 'E' überhaupt nicht vor und hat damit die Häufigkeit 0.

Du kannst diese Entschlüsselungsmethode hier ausprobieren:

• Wähle oben links unter Message Sample Message (easy) für die Caesar-Substitution und Sample Message (hard) für die zufällige monoalphabetishe Substitution. Bei letzterer kannst du die Buchstaben erst nach Häufigkeit ordnen und dann einzeln herumschieben.

Die Vigenère-Chiffre funktioniert ähnlich wie die Caesar-Verschlüsselung; es wird aber nicht jeder Buchstabe um eine feste Anzahl Stellen verschoben. Der Verschiebungswert ändert sich fortlaufend, abhängig von einem Schlüsselwort. Anders als bei der monoalphabetischen Subsitution wird hier also nicht jedem Klartext-Buchstaben ein Geheimtext-Buchstabe zugeordnet. Stattdessen hängt der Geheimtext-Buchstabe von der Kombination aus Schlüsselwort- und Klartextbuchstabe ab. Dadurch entsteht nicht ein Geheimalphabet, sondern mehrere: Je nach Kombination, können für den Klartext-Buchstaben 'A' verschiedene Geheimtextbuchstaben entstehen.

Für den Text »Als Anna abends ass, ass Anna abends Ananas« mit dem Schlüsselwort FISCHERSFRITZ geht die Vigenère-Verschlüsselung wie folgt:

Beachte:

• Das Schlüsselwort wird ständig wiederholt (sofern es, wie üblich, kürzer ist als der Klartext).
• Unter jeder Textzeile ist die Position der jeweiligen Buchstaben im Alphabet angegeben:
  • Die Modulo-Addition von Position K und Position S ergibt Position G (G = (K+S) % 26)
• Das Muster im Klartext ist, anders als bei der Caesar-Verschlüsselung, im Geheimtext nicht mehr erkennbar.

1. Zwei 2er-Gruppen zusammen: Einigt euch auf ein einfaches Schlüsselwort (3 bis 6 Buchstaben).
2. Jede 2er-Gruppe für sich: Schreibt eine kurze Nachricht (2 bis 3 Wörter) auf ein Papier und verschlüsselt sie nach der Vigenère-Chiffre mit dem vereinbarten Schlüsselwort.
   1. Schreibt M I T _ V I E L _ A B S T A N D und notiert zu jedem Buchstaben die Alphabet-Position.
   2. Die Tabelle unten hilft dabei.
   3. Teilt euch auf: A liest Buchstaben/Zahlen vor, B schaut in der Tabelle und antwortet mit entsprechenden Zahlen/Buchstaben.
3. Sendet die verschlüsselte Nachricht in elektronsischer Form der anderen Gruppe (z.B via Teams). Später können wir sie automatisch entschlüsseln.

Ist die Vigenère-Verschlüsselung sicher? Das hängt von der Länge und Zufälligkeit des Schlüsselwortes ab: kurze, einfach zu merkende Schlüsselwörter wie etwa “geheim” sind relativ unsicher; längere und zufälligere wie “wpfuVNaubLdshkYs” sind sicherer.

Als nicht-knackbar gilt das one-time-pad (OTP), eine Einmalverschlüsselung, bei der das Schlüsselwort mindestens so lange wie der Klartext selbst und die eben nur ein einziges mal verwendet wird.

Auch das Vigenère-Verfahren (mit wiederholt verwendeten Schlüsselwörtern) gilt angesichts heutiger Entschlüsselungsmethoden als unsicher.

Die Funktion vigenere(message, key_word) soll wie folgt funktionieren:

• Der Funktion übergibt man die Nachricht (Klartext) und das Schlüsselwort.
• Die Funktion gibt den verschlüsselten Text zurück.
• Leerschläge sollen nicht verschlüsselt werden.

1. Folgend siehst du die Funktion caesar. Was musst du anpassen und ergänzen, damit sie zur Vigenère-Funktion wird und obige Anforderungen erfüllt? Notiere deine Änderungen als # Kommentare im Code. Vergleiche anschliessend mit der Lösung.

import string def caesar(clearText, key): alphabet = string.ascii_uppercase ciphertext = "" for letter in clearText.upper(): if letter in alphabet: index = alphabet.find(letter) index = (index + key) % 26 letter = alphabet[index] ciphertext = ciphertext + letter return ciphertext

import string
 
def caesar(clearText, key):  # 1. Namen ändern, 2. key: Wort statt Zahl
    alphabet = string.ascii_uppercase 
    ciphertext = ""
    # Hier eine Variable (z.B. key_index) ergänzen (zählt durch Schlüsselwort).
    for letter in clearText.upper():
        if letter in alphabet:
            index =  alphabet.find(letter) 
            # Hier Verschiebewert (z.B. shift) aufgrund des aktuellen Schlüsselwort-Zeichens herausfinden, dann key_index erhöhen.
            index = (index + key) % 26 # Anstelle von key muss der Verschiebewert stehen
            letter = alphabet[index]
        ciphertext = ciphertext + letter
    return ciphertext

Diese Aufgabe gibt es in drei Schwierigkeitsstufen:

Schreibe die Funktion vigenere(message, key_word). Teste deine Funktion mit folgendem Code:

keyWord = "FischersFritz"
cipherText = vigenere("Als Anna abends ass, ass Anna abends Ananas", keyWord)
print(cipherText)

Prüfe, ob dein Programm Folgendes ausgibt. Falls nicht, musst du noch Änderungen vornehmen.

>>> FTK CURR SGVVWR FAK, CZW RFSR IUDSLK CUEESX

Lese die Tipps, falls du nicht weiterkommst.

Tipps:

Ein Teil der Funktion steht schon.

1. Gehe den Code Zeile für Zeile durch. Wenn etwas unklar ist, fragst du die Lehrperson.
2. Ergänze den fehlenden Code. Beachte die Überlegungen aus Aufgabe 4. Lese die Tipps oben, falls du nicht weiterkommst.

import string def vigenere(message, key_word): alphabet = string.ascii_uppercase ciphertext = "" key_index = 0 for letter in message.upper(): if letter in alphabet: index = alphabet.find(letter) shift_letter = key_word[key_index].upper() # dein Code... # ... # ... ciphertext = ciphertext + letter return ciphertext keyWord = "FischersFritz" cipherText = vigenere("Als Anna abends ass, ass Anna abends Ananas", keyWord) print(cipherText)

Wenn alles funktioniert: Speichere deinen Code! (Link kopieren und ablegen.)

import string
 
def vigenere(message, key_word):
    alphabet = string.ascii_uppercase
    ciphertext = ""
    key_index = 0
    for letter in message.upper():
        if letter in alphabet:
            index = alphabet.find(letter)
            shift_letter = key_word[key_index].upper()
            key_index = (key_index + 1) % len(key_word)
            shift = alphabet.find(shift_letter)
            letter = alphabet[(index+shift)%26]
        ciphertext = ciphertext + letter
    return ciphertext

Erweitere die Funktion um ein drittes Argument namens encrypt: vigenere(message, key_word, encrypt).

• Wenn encrypt = 1 ist, soll die Funktion verschlüsseln, wenn encrypt = -1 ist, soll sie entschlüsseln.
• Hierzu könnte encrypt einfach als Faktor verwendet werden, dann bräuchte es keine if-Abfrage.

import string
 
def vigenere(message, key_word, encrypt):
    alphabet = string.ascii_uppercase
    ciphertext = ""
    key_index = 0
    for letter in message.upper():
        if letter in alphabet:
            index = alphabet.find(letter)
            shift_letter = key_word[key_index].upper()
            key_index = (key_index + 1) % len(key_word)
            shift = alphabet.find(shift_letter)
            letter = alphabet[(index+shift*encrypt)%26]
        ciphertext = ciphertext + letter
    return ciphertext

Teste deine (erweiterte) Vigenere-Funktion mit folgendem Code:

keyWord = "FischersFritz"
cipherText = vigenere("Als Anna abends ass, ass Anna abends Ananas", keyWord, 1)
print(cipherText)
print(vigenere(cipherText, keyWord, -1))

Prüfe, ob dein Programm Folgendes ausgibt. Falls nicht, musst du noch Änderungen vornehmen.

>>> FTK CURR SGVVWR FAK, CZW RFSR IUDSLK CUEESX
>>> ALS ANNA ABENDS ASS, ASS ANNA ABENDS ANANAS

In Aufgabe 3 habt ihr Nachrichten von Hand verschlüsselt und euch gegenseitig gesendet. Entschlüsselt jetzt diese Nachricht mit euerer Vigenère-Funktion. Mit dem vereinbarten Schlüsselwort könnt ihr nun beliebig Nachrichten austauschen, die niemand ohne Schlüsselwort lesen kann.

Dieser Abschnitt behandelt hauptsächlich die XOR-Verschlüsselung. Sie ist eines der einfachsten Beispiele moderner symmetrischer Verschlüsselungs-Verfahren. Moderne Verfahren verschlüsseln nicht gedruckte oder handgeschriebene Texte, sondern digitale Daten (Texte, Bilder, Audio-Dateien, Videos, Code). Eine Verschlüsselung über die Alphabet-Nummerierung macht wenig Sinn, denn:

• Jedes digitale Zeichen ist bereits eine Nummer; jedes Schrift- oder Codezeichen, jedes Pixel eines Bildes kommt durch eine Folge von Einsen und Nullen zustande.
  • Der Buchstabe ‘A’ entspricht in der ASCII-Codierung der Binärzahl 100’0001
  • Ein Pixel dieser Farbe entspricht in 8-Bit-RGB-Codierung der Binärzahl 1110’1101 0001’1100 0010’0100

Also kann die moderne Verschlüsselung bei den Einsen und Nullen ansetzen.

Der American Standard Code for Information Interchange wurde bereits 1963 veröffentlicht und dient, wie es der Name sagt, dem Austausch von Informationen. Die Idee ist klar: Wenn man schon in der Lage ist, Einsen und Nullen über Kupferleitungen hin- und her zu schicken, wäre es noch praktisch, auf diese Weise auch Information, also Text, auszutauschen. Dazu muss man sich einigen, welche Binährzahl welchem Text-Zeichen entspricht. Genau das macht der ASCII-Code:

In obenstehender Tabelle kann für jedes Zeichen die entsprechende Binärzahl (von links nach rechts) gelesen werden, indem man erst die Zahlenfolge der Spalte, dann jene der Zeile liest:

• Für den Buchstaben A ergibt sich die Binärzahl 100’0001 (Dezimal: 65)
• Für den Buchstaben Z ergibt sich die Binärzahl 101’1010 (Dezimal: 90)

Der alte ASCII-Code weist nur 7 Bit auf, kann also maximal 128 Zeichen speichern. Er wurde mittlerweile vom UniCode-Standard abgelöst, damit auch Schriftzeichen anderer Sprachen Platz haben. Die Gross- und Kleinbuchstaben von A…Z haben auch im UniCode dieselben Nummern wie im ASCII-Code. So gesehen ist der ASCII-Code immer noch gültig.

Verwende obige ASCII-Tabelle und dein Wissen zu Zahlensystemen (Umwandlungen binär-dezimal):

1. Welche Dezimalzahlen stehen für die Kleinbuchstaben b, g und q?
2. Welche Buchstaben entsprechen den Dezimalzahlen 70, 99 und 117?

XOR steht für Exclusive OR, also „Exklusives ODER“, und ist eine logische Verknüpfung. Logische Verknüpfungen finden wir auch in unserer Sprache:

• Das ODER im Satz: „Ich ziehe eine Jacke an, wenn es windet oder wenn es regnet“ ist ein normales ODER. Das Resultat (Jacke an) ist wahr, wenn die erste Bedingung (es windet) wahr ist oder dann, wenn die zweite Bedingung wahr ist (es regnet) – aber auch dann, wenn beide Bedingungen wahr sind und es sowohl windet als auch regnet.
• Das ODER im Satz: „Willst du kurze oder lange Hosen anziehen?“ hingegen ist ein exklusives³⁾ ODER. Entweder kurze oder der lange Hosen – nicht beides.

Wenn wir 0 als falsch und 1 als wahr ansehen, ergeben sich für ODER und für XOR folgende Wahrheitstabellen:

1. Notiere anhand der ASCII-Tabelle die Binärzahlen der Buchstaben A und t untereinander,
2. ermittle das Resultat ihrer XOR-Verknüpfung und
3. notiere das dem Resultat entsprechende ASCII-Zeichen.

'A':  100'0001
't':  111'0100
--------------
res:  011'0101 = Zeichen '5'

Mit XOR können wir Kombinationen von Nullen und Einsen verschlüsseln. Wir können sagen:
Geheimtext = Klartext XOR Schlüsselwort.

Folgend wird der erste Buchstabe des Klartexts mit dem ersten Buchstaben des Schlüsselworts „verxort“ (=mit dem XOR-Operator verrechnet):

• Klartext: Aschenputtel, erster Buchstabe A hat ASCII-Code 100’0001 (= 65),
• Schlüsselwort: Wolf, erster Buchstabe W hat ASCII-Code 101’0111 (= 87):

Die XOR-Operation ergibt 001’0110 (= 22). Dieser Zahl entspricht im ASCII-Code kein Buchstabe, sondern ein Steuerzeichen. Wenn es als Text angezeigt wird, sieht es vielleicht so aus: ‘<‘. Die Verschlüsselung geht auch rückwärts: ‘<‘ XOR ‘W’ = ‘A’ Mit dieser Verschlüsselungsmethode können alle Binärzahlen und damit Daten in digitaler Form (Text, Videos, Fotos, etc.) verschlüsselt werden!

Gegeben ist folgender Geheimtext: 7 42 32 60. Die ASCII-Codes sind hier als Dezimalzahlen angegeben. Das Schlüsselwort heisst WOLF.

1. Schreibe die Dezimalzahlen als 7-stellige Binärzahlen nebeneinander auf ein Blatt Papier. Wenn möglich ohne Taschenrechner.
2. Schreibe unter die vier Binärzahlen die ASCII-Codes für die vier Buchstaben des Schlüsselworts. Dazu benutzt du die ASCII-Tabelle.
3. Führe die XOR-Operation Bit-für-Bit für jedes Binärzahl-Paar durch. So erhältst du die Binärzahlen des Klartexts.
4. Mit der ASCII-Tabelle kannst du nun die Binärzahlen in Buchstaben wandeln und erhälst den Klartext.

Lösung:

Schreibe eine Funktion crypt_xor(message_in, key_word):

• Der Funktion übergibt man die Nachricht und das Schlüsselwort.
• Die Funktion gibt den ver- bzw. entschlüsselten Text zurück.
• Auch Satzzeichen und Leerschläge werden verschlüsselt.

Du kannst von der Vigenère-Funktion ausgehen, welche ebenfalls ein Schlüsselwort benutzt, das stets wiederholt wird. Überlege erst, welche Code-Zeilen du von der Vigenère-Funktion, die ja das Alphabet benutzt, nicht mehr brauchst. Beachte Folgendes:

• Die Funktion ord() gibt den ASCII-Code eines Zeichens zurück: ord('A') gibt 65 zurück.
• Die Funktion chr() gibt das Zeichen eines ASCII-Codes zurück: chr(65) gibt 'A' zurück.
• Der XOR-Operator in python ist ein ^ (auf deiner Tastatur rechts neben dem Fragezeichen):

Teste deine Funktion mit folgendem Code:

key = "WOLF"
cipher = crypt_xor("Nur ein garstiges Aschenputtel ist noch da. Das sitzt unten in der Asche, dem kann der Pantoffel nicht passen!", key)
print(cipher)
print(crypt_xor(cipher, key))

Prüfe, ob dein Programm funktioniert: Die erste Ausgabezeile kann von der untenstehenden abweichen, die zweite aber sollte den Klartext 1:1 wiedergeben.

>>>:>f2&"f0.>5#&+#$o
>>> 54')(':822#l/$;l(8,$f3.bf.?f$&8<#o9(#*"f>!l"2=l$,$#{o(#:o''9!l"2=l6!8)1))*w!%%?;l66<?#9n
>>> Nur ein garstiges Aschenputtel ist noch da. Das sitzt unten in der Asche, dem kann der Pantoffel nicht passen!

def crypt_xor(message_in, key_word):
    message_out = ""
    key_count = 0
    for letter in message_in:
        code_message_in = ord(letter)
        code_key = ord(key_word[key_count])
        code_message_out = code_message_in ^ code_key
        letter = chr(code_message_out)
        message_out = message_out + letter
        key_count = (key_count + 1) % len(key_word)
    return message_out

def crypt_xor(message_in, key_word):
    message_out = ""
    key_count = 0
    for letter in message_in:
        letter = chr(ord(letter) ^ ord(key_word[key_count]))
        message_out = message_out + letter
        key_count = (key_count + 1) % len(key_word)
    return message_out

Du erinnerst dich: Hexadezimalzahlen bestehen aus den Ziffern 0 bis 9 und zusätzlich aus den Buchstaben A bis F. Das heisst:

• Mit einer Stelle können 16 Werte (0…F) dargestellt werden.
• Im Binärsystem brauchst du für 16 Werte vier Bits.
• Also reicht eine Hex-Stelle für vier Bits.
• Also reichen zwei Hex-Stellen für 1 Byte (8 Bits)

Löse folgende Aufaben – wenn nötig mihilfe der Theorie zum Hexadezimalzahlen:

1. Wandle einen der Farbwerte aus obigem Bild in Binärwerte um. Du hast dann drei 8-Bit-Binärzahlen. Je einen für Rot, Blau und Grün.
2. Wandle die drei Binärzahlen in Dezimalzahlen um.
3. Stelle diese drei Dezimalzahlen im RGB-Farbmixer ein und prüfe, ob die Farbe stimmt.

2D1A2E = 0010'1101  0001'1010  0010'1110 = 45 26 46
ADE3F9 = 1010'1101  1110'0011  1111'1001 = 173 227 249
6495ED = 0110'0100  1001'0101  1110'1101 = 100 149 237
3671F4 = 0011'0110  0111'0001  1111'0100 = 54 113 244

Nachdem du obige Aufgabe gelöst hast, ist klar: Jedes Pixel des obigen Bildes besteht aus drei 8-Bit-Binärzahlen. Wenn wir diese Zahlen im Hexadezimalsystem notieren, sparen wir Platz: Statt 24 Stellen benötigen wir bloss 6 Stellen pro Pixel. Obiges Bild besteht aus folgenden RGB-Werten:

img_1 = [
    ['2D1A2E', '2D1A2E', '2D1A2E', 'ADE3F9', 'ADE3F9', '2D1A2E', '2D1A2E', '2D1A2E'], 
    ['2D1A2E', '2D1A2E', 'ADE3F9', 'ADE3F9', 'ADE3F9', 'ADE3F9', '2D1A2E', '2D1A2E'], 
    ['2D1A2E', 'ADE3F9', 'ADE3F9', 'ADE3F9', 'ADE3F9', 'ADE3F9', 'ADE3F9', '2D1A2E'],
    ['2D1A2E', 'ADE3F9', '2D1A2E', 'ADE3F9', 'ADE3F9', '2D1A2E', 'ADE3F9', '2D1A2E'], 
    ['2D1A2E', '6495ED', '6495ED', '6495ED', '6495ED', '6495ED', '6495ED', '2D1A2E'], 
    ['2D1A2E', '2D1A2E', '6495ED', '2D1A2E', '2D1A2E', '6495ED', '2D1A2E', '2D1A2E'], 
    ['2D1A2E', '3671F4', '2D1A2E', '3671F4', '3671F4', '2D1A2E', '3671F4', '2D1A2E'], 
    ['3671F4', '2D1A2E', '3671F4', '2D1A2E', '2D1A2E', '3671F4', '2D1A2E', '3671F4']
]

Jeder 6-stellige RGB-Hex-Wert seht für 24 Einsen oder Nullen. Wir können die XOR-Operation also auch bei Bildern vornehmen.

Nehmen wir einen einfachen Schlüssel, zum Beispiel:

• 0x123456 (0x gibt an, dass es sich um einen Hex-Wert handelt)

Unser Schlüssel ist gleich lang wie der RGB-Wert eines einzelnen Pixels (3 Bytes oder 24 Bits). Wir wollen nun jedes Pixel des obigen Bildes mit dem Schlüssel xoren ⁴⁾:

1. Berechne die resultierende Farbe für den ersten Pixel.
2. Wie sieht das verschlüsselte Bild wohl aus? Ist das Motiv (Tintenfisch) noch erkennbar? Überlege erst und vergleiche dann mit der Lösung.

Lösung Farbe erstes Pixel:

2D1A2E = 0010'1101  0001'1010  0010'1110
123456 = 0001'0010  0011'0100  0101'0110
RESULT = 0011'1111  0010'1110  0111'1000 = 0x3F2E78 = R63 G46 B120

Lösung verschlüsseltes Bild:

Da siehst: Der einfache Schlüssel verändert das Bild. Aber es bleibt weiterhin erkennbar.

1. Warum ist das so? Überlege (oder diksutiert zu zweit) und vergleiche anschliessend mit der Lösung.
2. Vergleiche mit der Vigenère-Verschlüsselung: Wie sähe dort ein so einfacher Schlüssel aus?

Lösung:

Nun verschlüsseln wir mit einem längeren Schlüssel. Wir nehmen nicht bloss einen sechsstelligen Hexwert, sondern fünf davon. Diese speichern wir in einer Liste:

key = [
    0x123456,
    0xABCDEF,
    0x654321,
    0xFEDCBA,
    0x777777
]

Folgender Code zeichnet erst das originale Bild, wartet dann kurz, verschlüsselt das Bild mit obigem Schlüssel und zeichnet dann das verschlüsselte Bild:

Turtle_Bild_XOR

1. Versuche, den Code zu verstehen:
   1. Einzeln: Verschaffe dir erste einen Überblick: Was hat es für Funktionen? Wo werden die Funktionen aufgerufen?
   2. Einzeln: Gehe jede Funktion Zeile für Zeile durch. Wenn du unsicher bist, was eine bestimmte Zeile macht, notiere einen #Kommentar hinter die Zeile (z.B. #? – oder noch besser eine konkrete Frage).
   3. Zu zweit: Tausch euch aus über euer Verständnis und eure Fragen. Wenn Fragen offen bleiben: Lehrperson fragen.
2. Ergänze den Code um weitere Zeilen, sodass er das verschlüsselte Bild 3 Sekunden lang anzeigt und es danach wieder entschlüsselt. Am Ende soll das entschlüsselte Bild angezeigt werden.

Erstelle (mithilfe von AI) einen Code, der Bilder mit höherer Auflösung (z.B. im Format png) mit XOR ver- und entschlüsseln kann. Teste mit verschiedenen Bildern.

1. Verschlüssle „XYLOPHON“ von Hand mit Caesar, in dem du um 7 Stellen nach hinten verschiebst.
2. Der Text „SOGAR SOLAR“ wurde mit Caesar -6 verschlüsselt:
   1. Welcher positive Schlüsselwert führt zur gleichen Verschiebung wie -6?
   2. Wie lautet der Originaltext?

Lösung:

Entschlüssle die Nachricht „OSMVAEJVPNRENJFYWNN“ von Hand. Sie wurde mit dem folgenden monoalphabetischen Verfahren verschlüsselt (Alphabet & Schlüssel):

ABCDEFGHIJKLMNOPQRSTUVWXYZ # Alphabet
SOGVNPKWEFLMUJDHZRAIYTBXCQ # Schlüssel

Tipp: Schreibe einen kurzen Code zum Entschlüsseln – das geht schneller und macht mehr Spass!

Lösung:

secret = "SOGVNPKWEFLMUJDHZRAIYTBXCQ"
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
message = "OSMVAEJVPNRENJFYWNN"
 
result = ""
for letter in message:
    index = secret.find(letter)
    result += alphabet[index]
print(result)

Entschlüssele folgenden nach Vigenère verschlüsselten Geheimtext mit dem Schlüsselwort TAUBE:

EIYCIK DYO WIANA MG DYS LTNX

Lösung:

Verändere folgende Vigènere-Funktion so, dass auch Abstände verschlüsselt werden (und korrekt wieder entschlüsselt werden): import string def vigenere(message, key_word, crypt): alphabet = string.ascii_uppercase ciphertext = "" key_index = 0 for letter in message.upper(): if letter in alphabet: index = alphabet.find(letter) shift_letter = key_word[key_index].upper() key_index = (key_index + 1) % len(key_word) shift = alphabet.find(shift_letter) letter = alphabet[(index+shift*crypt)%26] ciphertext = ciphertext + letter return ciphertext text = "Das Dschungelbuch" key = "Balu" cipher = (vigenere(text, key, 1)) print(cipher) print(vigenere(cipher, key, -1))

Lösung:

1. Wie lautet der Hexwert für das ASCII-Zeichen G?
2. Wie lautet der Dezimalwert für das ASCII-Zeichen f?
3. Welches Zeichen findet sich unter dem Hexwert 0x77?
4. Welches Zeichen findet sich unter dem Dezimalwert 61?

Lösung:

1. G: 100'0111 = 0x47
2. f: 110'0110 = 102
3. 0x77 = 111'0111 -> 'w'
4. 61 = 011'1101 --> '='

Entschlüssle den xor-verschlüsselten Text qxj mit dem Schlüssel !1+. Verwende die ASCII-Tabelle. Achte auf Gross-/Kleinschreibung.

Lösung: