Unterschiede
Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.
| Beide Seiten, vorherige Überarbeitung Vorherige Überarbeitung Nächste Überarbeitung | Vorherige Überarbeitung | ||
| gf_informatik:umgang_inet_sca:verschluesselung [2024-03-10 12:49] – sca | gf_informatik:umgang_inet_sca:verschluesselung [2024-03-10 18:41] (aktuell) – gelöscht sca | ||
|---|---|---|---|
| Zeile 1: | Zeile 1: | ||
| - | ====== - Verschlüsselung ====== | ||
| - | Slides: {{ : | ||
| - | |||
| - | |||
| - | |||
| - | ++++Lernziele| | ||
| - | |||
| - | Prüfungsrelevant ist alles, was in den Lektionen und Übungen behandelt wurde. Die Lernziele unten dienen als Gradmesser und sind nicht unbedingt komplett. | ||
| - | |||
| - | **Inhaltliche Lernziele: | ||
| - | * Erkläre die Funktionsweisen der drei **klassischen Verschlüsselungsmethoden**: | ||
| - | * **Caesar**-Verschlüsselungsmethode | ||
| - | * allgemeine **monoalphabetische** Verschlüsselungsmethode | ||
| - | * **Vigenère** Verschlüsselungsmethode | ||
| - | * **Implementiere** die ersten beiden Verschlüsselungsmethoden in Python (entschlüsseln und verschlüsseln). | ||
| - | * **Verschlüssle/ | ||
| - | * Analysiere die **Sicherheit** dieser Verschlüsselungsmethoden. Vergleiche sie untereinander. | ||
| - | * Entscheide, ob eine gegebene Verschlüsselungsmethode monoalphabetisch ist oder nicht.\\ \\ | ||
| - | * Erkläre das Grundprinzip einer **Häufigkeitsanalyse**. Erkläre, wann diese (keinen) Sinn machen. | ||
| - | * Erkläre, was der Kasiski-Test ist, und wie man eine mit Vigenère verschlüsselte Nachricht knacken kann. | ||
| - | * **Implementiere** in Python eine Häufigkeitsanalyse für einen langen String. | ||
| - | * Erkläre Grundidee und Notwendigkeit von **Zeichencodierungen / Zeichentabelle**. | ||
| - | * Beschreibe die wichtigsten Eigenschaften der ASCII-Zeichentabelle. | ||
| - | * Wandle ohne Hilfsmittel um: Grossbuchstaben <-> Zahl | ||
| - | * Erkläre was **Unicode** ist, was die Idee dahinter ist und ... | ||
| - | * ... wie Unicode-Zeichen als Binärzahlen gespeichert werden. | ||
| - | * Vergleiche ASCII mit Unicode. | ||
| - | * Erkläre, was ein **präfixfreier Code** ist und mache (Gegen)Beispiele.\\ \\ | ||
| - | * Erkläre den **XOR-Logikoperator** anhand seiner Wahrheitstabelle. Mache konkrete Real-Life Beispiele dazu. | ||
| - | * Erkläre die **XOR-**Verschlüsselungsmethode: | ||
| - | * Wie funktioniert sie? | ||
| - | * Wo kommt sie zum Einsatz? | ||
| - | * Warum wählt man dazu genau XOR? | ||
| - | * Was sind ihre Schwächen? Wie kann man sie umgehen?\\ \\ | ||
| - | * Erkläre, was **AES** bedeutet und wie es dazu kam. | ||
| - | * Erkläre die beiden Versionen von AES (ECB und CBC) und in groben Zügen deren Funktionsweisen. Verwende dazu die zugehörigen Fachbegriffe. | ||
| - | * Analysiere dessen Sicherheit. | ||
| - | * Entschlüssle/ | ||
| - | * Erkläre, was das **Hexadezimalsystem** ist, und wie dessen Zahlen aussehen. | ||
| - | * Wandle um: Binärsystem <-> Hexadezimalsystem\\ \\ | ||
| - | * Einfache **Programme** schreiben, die ähnliche Skills verlangen wie die Codes zum aktuellen Thema. | ||
| - | |||
| - | |||
| - | **Wichtigste Programmierskills: | ||
| - | * Verstehen, was Funktionen sind und wie man sie programmiert. Begriffe wie ' | ||
| - | * Durch Elemente von Listen und Strings iterieren können. | ||
| - | * Die Grundbefehle für Listen und Strings kennen wie: | ||
| - | * Element an bestimmter Position auslesen, ändern | ||
| - | * Position von Element ermitteln | ||
| - | * Unterschied zwischen Element und Index/ | ||
| - | * Umrechnungen: | ||
| - | * ASCII <-> Zahl | ||
| - | * Dezimalzahl, | ||
| - | |||
| - | ++++ | ||
| - | ===== - Caesar-Verschlüsselung ===== | ||
| - | |||
| - | Bei der **Caesar-Verschlüsselung** werden alle Buchstaben um eine Anzahl Stellen verrückt: | ||
| - | |||
| - | {{ : | ||
| - | |||
| - | Der römische Feldherr Gaius Julius Caesar soll diese Art der Verschlüsselung für militärische Kommunikation verwendet haben. Um von Hand eine solche Nachricht zu entziffern, kann man eine Chiffrierscheibe verwenden: | ||
| - | |||
| - | {{ : | ||
| - | |||
| - | ==== Aufgaben A ==== | ||
| - | |||
| - | === Aufgabe A1 === | ||
| - | |||
| - | Schreibe eine Funktion `encryption_caesar(cleartext, | ||
| - | |||
| - | Hier ein paar Tipps: | ||
| - | * Arbeite nur mit Grossbuchstaben. Wandle den Klartext mit `upper()` in Grossbuchstaben um. | ||
| - | * Wir brauchen eine Liste oder einen String, der alle Zeichen beinhaltet. Wähle dazu eine beiden Möglichkeiten unten (siehe Code-Beispiel unten) - je nach dem, ob du lieber mit Listen oder Strings arbeitest. | ||
| - | * Zeichen, die nicht in der Liste vorkommen (Kleinbuchstaben, | ||
| - | * Verwende Modulo-Operator `%`. Damit kannst du verhindern, dass du auf Element von Liste/ | ||
| - | * Die Liste resp. der String, der alle relevanten Buchstaben beinhaltet wird hier `ALPHABET` genannt. Es ist eine Python-Konvention, | ||
| - | * Theorie zu [[gf_informatik: | ||
| - | |||
| - | <code python> | ||
| - | # Option 1: Liste | ||
| - | ALPHABET = [' | ||
| - | ALPHABET.index(' | ||
| - | ALPHABET[12] # Symbol an angegebener Position | ||
| - | |||
| - | # Option 2: String | ||
| - | ALPHABET = " | ||
| - | ALPHABET.index(' | ||
| - | ALPHABET.find(' | ||
| - | ALPHABET[12] # Symbol an angegebener Position | ||
| - | # beachte: Für Strings kann man index oder find verwenden. Unterschied: | ||
| - | </ | ||
| - | |||
| - | ++++Tipps| | ||
| - | Versuche, die Aufgabe möglichst ohne diese Schritt-für-Schritt Tipps zu lösen. | ||
| - | |||
| - | 1. Erstelle einen leeren String für das verschlüsselte Wort, nenne diesen z.B. `cipher` oder `ciphertext` | ||
| - | 1. Gehe Liste/ | ||
| - | 1. Finde heraus, an welcher Stelle in der Liste/im String dieses vorkommt | ||
| - | 1. Addiere die Zahl $n$ hinzu. | ||
| - | 1. Stelle sicher, dass diese Zahl nicht zu gross ist. Stichwort: Modulo-Operator | ||
| - | 1. Finde das Symbol an dieser Stelle ... | ||
| - | 1. ... und füge es dem verschlüsselten Wort hinzu. | ||
| - | 1. Gebe dieses zurück. | ||
| - | 1. Passe Code so an, dass Symbole, die *nicht* in Liste/ | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | === Aufgabe A2 === | ||
| - | |||
| - | == a) == | ||
| - | |||
| - | Die folgende Nachricht ist mit der Caesar-Verschlüsslung verschlüsselt, | ||
| - | |||
| - | Was bedeutet die Nachricht? | ||
| - | |||
| - | == b) == | ||
| - | |||
| - | Nutze deinen Code, um die folgende Nachricht zu knacken: " | ||
| - | |||
| - | ++++Tipp| | ||
| - | Probiere alle möglichen Verschiebungen aus. Am einfachsten geht dies mit einer ...! | ||
| - | ++++ | ||
| - | |||
| - | |||
| - | === Zusatzaufgabe === | ||
| - | |||
| - | Die Caesar-Verschlüsselung ist nicht sehr sicher. Überlege dir selbst (ohne googlen oder im Wiki weiter unten nachzusehen) eine besser Verschlüsslungsmethode. Bespreche deine Idee mit deiner Lehrperson und setze diese in einem Code um. | ||
| - | |||
| - | |||
| - | ===== - Weiter einfache Verschlüsselungsverfahren ===== | ||
| - | |||
| - | Die Caesar-Verschlüsselung von oben ist ein sehr unsicheres Verfahren. Eine damit verschlüsselte Nachricht kann mit einem Computer innerhalb eines Sekundenbruchteils geknackt werden. Gewissermassen eine Weiterentwicklung von diesem Verfahren ist die **Vigenère-Verschlüsslung** (Details in den Aufgaben). | ||
| - | |||
| - | ==== Aufgaben B ==== | ||
| - | |||
| - | === Aufgabe B1 === | ||
| - | |||
| - | In der Caesar-Verschlüsselung wird jeder Buchstabe um eine bestimmte Anzahl Stellen verschoben. Auch in der Vigenère-Verschlüsselung werden die Buchstaben verschoben. Allerdings nicht um eine feste Anzahl Stellen, sondern mithilfe eines **Schlüsselworts**. | ||
| - | |||
| - | 1. Stelle eine **Vermutung** auf, wie die Vigenère-Verschlüsselung funktionieren könnte (Erklärung am Ende der Aufgabe). | ||
| - | 1. Verschlüssle *von Hand* das Wort " | ||
| - | 1. Analysiere die **Sicherheit** dieser Verschlüsselungsmethode: | ||
| - | 1. Wie geht man vor, um eine so verschlüsselte Nachricht zu entschlüsseln? | ||
| - | 1. Unter welchen Bedingungen ist sie (praktisch nicht) entschlüsselbar? | ||
| - | |||
| - | ++++Vigenère-Verschlüsselung| | ||
| - | Jeder Buchstabe im Passwort steht für eine Verschiebung. Beispiel: Klartext " | ||
| - | ^ Klartext ^ Verschiebung ^ Geheimtext ^ | ||
| - | | I | 1 (A) | J | | ||
| - | | N | 2 (B) | P | | ||
| - | | F | 5 (E) | K | | ||
| - | | O | 4 (D) | S | | ||
| - | | R | 1 (A) | S | | ||
| - | | M | 2 (B) | O | | ||
| - | | A | 5 (E) | F | | ||
| - | | T | 4 (D) | X | | ||
| - | | I | 1 (A) | J | | ||
| - | | K | 2 (B) | M | | ||
| - | ++++ | ||
| - | |||
| - | === Aufgabe B2: Programmieraufgaben === | ||
| - | |||
| - | Wähle aus den folgenden Aufgaben: | ||
| - | |||
| - | 1. MittelImplementiere die **Vigenère-Verschlüsslung** in der Funktion `encryption_vigenere(cleartext, | ||
| - | 1. Geheimschriften sind auch eine Art der Verschlüsselung. Schreibe ein Programm, welches eine Klartext-Nachricht ins **Morse-Alphabet** übersetzt und umgekehrt: `cleartext_to_morsecode(cleartext)` und `morsecode_to_cleartext(morsecode)`. Die zu Nachrichten `cleartext` und `morsecode` sollen jeweils als String (und nicht Liste) der Funktion übergeben werden. Es kann aber durchaus Sinn machen, den String *in* der Funktion drin in eine Liste umzuwandeln (siehe falls nötig Tipps unten). (Schwierigkeitsgrad: | ||
| - | |||
| - | ++++Morse-Alphabet und Tipps| | ||
| - | <code python> | ||
| - | ALPHABET = [' | ||
| - | MORSE = [' | ||
| - | </ | ||
| - | |||
| - | Tipps: | ||
| - | |||
| - | * Um die einzelnen Morse-Symbole unterscheiden zu können, kann man z.B. immer einen Leerschlag nach einem Morse-Symbol einfügen. | ||
| - | * Für die Umkehrung Morsecode zu Klartext kann man dann den Morsecode z.B. in eine Liste umwandeln: `morsecode.split(" | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | Zusatzaufgaben: | ||
| - | |||
| - | * Stelle das Morse-Nachrichten schön mit TigerJython dar. | ||
| - | * Wie oben, einfach für das **Freimaurer-Alphabet**: | ||
| - | |||
| - | ===== - Monoalphabetische Verschlüsslung ===== | ||
| - | |||
| - | Die Vigenere-Verschlüsselung ist gewissermassen eine Weiterentwicklung der Caesar-Verschlüsslung. Eine alternative mögliche Weiterentwicklung der Caesar-Verschlüsselung erhält man, wenn man das Alphabet nicht nur um eine fest Anzahl stellen verschiebt, sondern das gesamte Alphabet *durchmischt*. Aus " | ||
| - | " | ||
| - | |||
| - | |||
| - | ==== Aufgaben C ==== | ||
| - | |||
| - | === Aufgabe C1 === | ||
| - | |||
| - | 1. Ist die Caesar-Verschlüsselung auch eine monoalphabetische Verschlüsselung? | ||
| - | 1. Wie viele Möglichkeiten gibt es, eine Nachricht mit der Caesar-Verschlüsselung zu verschlüsseln? | ||
| - | 1. Wie viele Möglichkeiten gibt es für die monoalphabtische Verschlüsselung? | ||
| - | 1. Wie schätzt du die Sicherheit der monoalphabtischen Verschlüsselung ein? Welche Möglichkeiten gibt es, um eine damit verschlüsselte Nachricht zu entziffern? | ||
| - | 1. Eine mit der Caesar-Methode verschlüsselte Nachricht kann man problemlos mit Brute-Force entschlüsseln (alle Möglichkeiten ausprobieren). Funktioniert dies bei der monoalphabetische Verschlüsselung auch? Gibt es bessere Möglichkeiten, | ||
| - | |||
| - | === Aufgabe C2 === | ||
| - | |||
| - | Die Nachricht " | ||
| - | |||
| - | ++++Tipps| | ||
| - | |||
| - | 1. Gehe Buchstaben um Buchstaben durch die Nachricht. | ||
| - | 1. Ermittle die Position von diesem Buchstaben im durchmischten Alphabet (Schlüssel). | ||
| - | 1. Dieser Buchstabe gehört zum Buchstaben im normalen Alphabet an dieser Stelle. | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | === Aufgabe C3 === | ||
| - | |||
| - | Ist die verschlüsselte Nachricht lange genug, kann man eine **Häufigkeitsanalyse** durchführen. In der deutschen Sprache kommt der Buchstabe " | ||
| - | |||
| - | Wähle eine der beiden Optionen: | ||
| - | |||
| - | === Option 1: Häufigkeitsanalyse von einzelnem String (einfach) === | ||
| - | |||
| - | Schreibe eine Funktion, die eine Linie Text einliest und eine Häufigkeitsanalyse durchführt. Das Alphabet soll nur aus den $26$ Standardbuchstaben Bestehen. Alle Buchstaben sollen in Kleinbuchstaben umgewandet werden. Umlaute wie Ä, | ||
| - | |||
| - | Wende deine Funktion auf den folgenden Ausschnitt von Goethe' | ||
| - | |||
| - | ++++Text Faust| | ||
| - | <code python> | ||
| - | faust = 'Habe nun, ach! Philosophie, | ||
| - | </ | ||
| - | ++++ | ||
| - | |||
| - | ++++Tipps| | ||
| - | Für jeden Buchstaben musst du irgendwo dessen Anzahl speichern. Eine Möglichkeit ist, eine Liste mit Zahlen zu verwenden. Die erste Zahl steht für die Anzahl " | ||
| - | ++++ | ||
| - | |||
| - | ++++Lösungen| | ||
| - | |||
| - | * a: $4.81\%$ | ||
| - | * b: $1.97\%$ | ||
| - | * c: $4.27\%$ | ||
| - | * d: $5.02\%$ | ||
| - | * e: $16.43\%$ | ||
| - | * f: $1.48\%$ | ||
| - | * g: $2.33\%$ | ||
| - | * h: $6.53\%$ | ||
| - | * i: $8.47\%$ | ||
| - | * j: $0.1\%$ | ||
| - | * k: $1.33\%$ | ||
| - | * l: $3.99\%$ | ||
| - | * m: $3.84\%$ | ||
| - | * n: $9.19\%$ | ||
| - | * o: $2.15\%$ | ||
| - | * p: $0.64\%$ | ||
| - | * q: $0.1\%$ | ||
| - | * r: $6.6\%$ | ||
| - | * s: $6.78\%$ | ||
| - | * t: $5.32\%$ | ||
| - | * u: $5.19\%$ | ||
| - | * v: $0.54\%$ | ||
| - | * w: $1.84\%$ | ||
| - | * x: $0.0\%$ | ||
| - | * y: $0.0\%$ | ||
| - | * z: $1.07\%$ | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | |||
| - | |||
| - | === Option 2: Häufigkeitsanalyse von ganzem Buch (anspruchsvoll) === | ||
| - | |||
| - | Wie in Option 1, nur soll anstelle eines einzelnen Strings ein ganzes Buch eingelesen und analysiert werden. Auf [[https:// | ||
| - | |||
| - | <code python> | ||
| - | import urllib2 | ||
| - | |||
| - | data = urllib2.urlopen(< | ||
| - | line_first = ... # erste Zeile des Texts | ||
| - | line_last | ||
| - | for line in data: | ||
| - | line = line.replace(' | ||
| - | if line_first <= count <= line_last: | ||
| - | print(line) # Achtung: keine gute Idee, wenn File sehr viele Zeilen beinhaltet! Baue z.B. Counter ein, damit nach z.B. 100 Ausgaben abbricht | ||
| - | </ | ||
| - | Beachte, dass du noch die erste und letzte Zeilennummer im Buch angeben musst: Der Text am Anfang und Ende des Files gehört nicht zum Buch und soll ignoriert werden. | ||
| - | |||
| - | Kontrolle: am häufigsten vorkommen sollte $E$ (gut $15\%$), gefolgt von $N$ (ca. $10\%$) und $S$. Die letzten Ränge machen typischerweise $Y$, $Q$ und $X$ unter sich aus. | ||
| - | === Aufgabe C4 (optional) === | ||
| - | |||
| - | Versuche, mithilfe einer Häufigkeitsanalyse den Text (in deutscher Sprache, nur Kleinbuchstaben) unten möglichst fest zu entschlüsseln. Aus welchem Buch ist dieser? | ||
| - | |||
| - | Die Buchstaben in der folgenden Liste ist entsprechend ihrer typischen Häufigkeit in der deutschen Sprache geordnet: | ||
| - | <code python> | ||
| - | [' | ||
| - | </ | ||
| - | |||
| - | ++++Verschlüsselter Text| | ||
| - | rx jlw rxn wjxnzvc qr zqtjnbvxivt ljrrvx 4 isxvl nbyzm wsxsjo, tslm jlw tsx lyxrsz mj nvql, nvhx nbyzm nytsx. lqvrslw isxv sjo wqv qwvv tvuyrrvl, nqv uyllbvl nqkh ql vqlv rvxuijxwqtv jlw tvhvqrlqngyzzv tvnkhqkhbv gvxnbxqkuvl, | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | === Aufgabe C5 (optional) === | ||
| - | |||
| - | Die **Autokey-**Verschlüsselungsmethode ist eine Weiterentwicklung der Vigenere-Verschlüsslung. Anstelle das Schlüsselwort wie bei der Vigenere-Methode wiederholt zu verwenden, wird an den Schlüssel entweder der Klartext oder der bereits verschlüsselte Text angehängt. Somit werden Wiederholungen vermieden, was diese Verschlüsselungsmethode viel sicherer macht. Implementiere die Autokey-Verschlüsselungsmethode. | ||
| - | |||
| - | Erklärung und Beispiele: [[https:// | ||
| - | |||
| - | ===== - Vigenère-Game ===== | ||
| - | |||
| - | Nutze den Code unten, um Nachrichten zu verschlüsseln und entschlüsseln: | ||
| - | |||
| - | ++++Code| | ||
| - | <code python> | ||
| - | ALPHABET = [' | ||
| - | ################################### | ||
| - | |||
| - | key = " | ||
| - | |||
| - | ################################### | ||
| - | |||
| - | def encryption_vigenere(cleartext, | ||
| - | cleartext = cleartext.replace(' | ||
| - | cleartext = upper(cleartext) | ||
| - | password = upper(password) | ||
| - | ciphertext = "" | ||
| - | for i in range(len(cleartext)): | ||
| - | c = cleartext[i] | ||
| - | if c in ALPHABET: | ||
| - | k = ALPHABET.index(c) | ||
| - | n = ALPHABET.index(password[i%len(password)]) + 1 | ||
| - | k = (k + n) % len(ALPHABET) | ||
| - | ciphertext += ALPHABET[k] | ||
| - | else: | ||
| - | ciphertext += c | ||
| - | return ciphertext | ||
| - | |||
| - | def decryption_vigenere(cipher, | ||
| - | password = password.replace(' | ||
| - | password = upper(password) | ||
| - | pw_inv = "" | ||
| - | for c in password: | ||
| - | i = - ALPHABET.index(c) - 2 | ||
| - | i = i % len(ALPHABET) | ||
| - | pw_inv += ALPHABET[i] | ||
| - | return encryption_vigenere(cipher, | ||
| - | |||
| - | ################################### | ||
| - | |||
| - | print(encryption_vigenere(" | ||
| - | print(decryption_vigenere(" | ||
| - | </ | ||
| - | ++++ | ||
| - | |||
| - | ===== - Zeichencodierung ===== | ||
| - | |||
| - | Theorie zu Zeichencodierung, | ||
| - | |||
| - | Siehe Slides {{ : | ||
| - | |||
| - | ==== Aufgaben D ==== | ||
| - | |||
| - | === Aufgabe D1 === | ||
| - | |||
| - | Beantworte mithilfe von Python. | ||
| - | |||
| - | 1. Welches ist das 42. Zeichen in ASCII? | ||
| - | 1. An welcher Position in der ASCII-Zeichentabelle steht die Zahl 7? | ||
| - | 1. Welches Wort verbirgt sich hinter "82 111 109 97 110 115 104 111 114 110"? | ||
| - | |||
| - | === Aufgabe D2 === | ||
| - | |||
| - | Wie viele Symbole kann man mit Unicode (1 bis 4 Bytes) darstellen? | ||
| - | |||
| - | *Tipp:* Siehe Tabelle in Slides. | ||
| - | |||
| - | === Aufgabe D3 === | ||
| - | |||
| - | Studiere das Video und beantworte die Fragen unten: | ||
| - | |||
| - | {{youtube> | ||
| - | |||
| - | Fragen: | ||
| - | |||
| - | 1. Welches Problem hat das Aufkommen des Internets im Bezug auf die Kodierung von Zeichen mit sich gebracht? Wie hat man es gelöst? | ||
| - | 1. ASCII verwendet 7 Bit pro Zeichen. Man könnte jedes Unicode-Zeichen mit vier Bytes darstellen, was aber sehr ineffizient wäre. Wie umgeht man dies? | ||
| - | 1. Warum darf in einem mit Unicode dargestellten Text kein `0000 0000`-Byte vorkommen? Wie wird dies verhindert? | ||
| - | 1. Wie werden die Buchstaben ' | ||
| - | 1. Das wievielte Zeichen der Unicode-Zeichentabelle wird durch die Binärzahl " | ||
| - | |||
| - | |||
| - | |||
| - | === Aufgabe D4 (optional, einfache-mittlere Programmierübung) === | ||
| - | |||
| - | Unicode-Zeichen werden in 1-4 Byte-Binärzahlen gespeichert. Schreibe eine Funktion `unicode_symbol_number(b)`, | ||
| - | |||
| - | Einfache Variante: nur für 1-Byte Zahlen | ||
| - | |||
| - | Beispiele: | ||
| - | |||
| - | * " | ||
| - | * " | ||
| - | |||
| - | Tipp: Um eine Binärzahl ins Dezimalsystem umzuwandeln kannst du entweder eine eigene Funktion schreiben (btw: hast du bereits einmal programmiert) oder `int(" | ||
| - | |||
| - | ===== - XOR-Verschlüsselung ===== | ||
| - | |||
| - | Aus dem letzten Kapitel wissen wir, wie wir mithilfe von Zeichentabellen Zeichen in Binärzahlen umwandeln können. Doch wie können wir nun auf der Ebene von Binärzahlen eine Nachricht verschlüsseln? | ||
| - | |||
| - | Eine einfache Operation auf Bits ist die **XOR (_eXclusive OR_) Operation**. Wie der Name andeutet, werden bei der XOR-Operation zwei Bits so verknüpft, dass das Resultat genau dann $1$ ist, wenn der eine oder der andere der Operanden $1$ ist, aber nicht beide. Die folgende Wahrheitstabelle zeigt, wie je ein Bit des Plaintext ($p$) mit einem Bit des Key ($k$) zum Ciphertext ($c$) verknüpft werden. | ||
| - | |||
| - | **Verschlüsselung: | ||
| - | |||
| - | ^ $p$ ^ $k$ ^ $c = p \, | ||
| - | |0|0|0| | ||
| - | |0|1|1| | ||
| - | |1|0|1| | ||
| - | |1|1|0| | ||
| - | |||
| - | **Entschlüsselung: | ||
| - | |||
| - | ^ $c$ ^ $k$ ^ $p = c \, | ||
| - | |0|0|0| | ||
| - | |0|1|1| | ||
| - | |1|0|1| | ||
| - | |1|1|0| | ||
| - | |||
| - | Die Entschlüsselung funktioniert gleich wie die Verschlüsselung, | ||
| - | |||
| - | Da wir mir Binärzahlen arbeiten, können wir nun nicht nur Text sondern **beliebige Informationen verschlüsseln**, | ||
| - | |||
| - | |||
| - | ==== Aufgaben E ==== | ||
| - | |||
| - | === Aufgabe E1 === | ||
| - | |||
| - | 1. Verschlüssle den Binärcode `01101000 01100001 01101100` mit diesem Schlüssel `01010011 01110101 01100111` von Hand. | ||
| - | 1. Schreibe nun einen Code der dieses macht. Falls du Hilfe brauchst, siehe Tipps unten. | ||
| - | |||
| - | |||
| - | ++++Tipps| | ||
| - | |||
| - | 1. Entferne die Leerschläge in einem String `s` mit `s = s.replace(' | ||
| - | 1. Erstelle einen leeren String, dem du Stelle um Stelle die verschlüsselte Nachricht hinzufügst. | ||
| - | 1. Gehe die Positionen des Binärcodes durch. An jeder Stelle bestimmst du den XOR-Wert mit der zugehörigen Ziffer im Schlüssel. Füge das Resultat dem String für die verschlüsselte Nachricht hinzu. | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | |||
| - | === Aufgabe E2 === | ||
| - | |||
| - | Ziel dieser Aufgabe ist, deinen Code aus der letzten Aufgabe zu verallgemeinern und eine Funktion für die XOR-Verschlüsselung zu schreiben. | ||
| - | |||
| - | Schreibe eine Funktion `encryption_xor_binary(plaintext_bin, | ||
| - | |||
| - | ++++Tipps| | ||
| - | |||
| - | 1. Vieles kannst du vom Code der letzten Aufgabe übernehmen. | ||
| - | 1. Eine ' | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | === Aufgabe E3 (optional) === | ||
| - | |||
| - | 1. Schreibe eine Funktion `encryption_xor(plaintext, | ||
| - | 1. Schreibe eine Funktion `decryption_xor(ciphertext_bin, | ||
| - | 1. Teste deine Funktionen mithilfe des folgenden Codes: | ||
| - | |||
| - | <code python> | ||
| - | # deine Funktionen oben | ||
| - | |||
| - | msg = "Kanti Romanshorn, die innovative Schule im Grünen." | ||
| - | key = " | ||
| - | cipher_bin = encryption_xor(msg, | ||
| - | decripted = decryption_xor(cipher_bin, | ||
| - | print(decripted) # muss ausgeben: "Kanti Romanshorn, die innovative Schule im Grünen." | ||
| - | </ | ||
| - | |||
| - | **Tipps:** | ||
| - | |||
| - | * Verwende von Anfang an **sinnvolle Variablennamen**, | ||
| - | * Einen Binärstring `b` kannst du wie folgt in eine Dezimalzahl umwandeln: `int(b,2)` | ||
| - | * Eine Dezimalzahl `d` kannst du wie folgt in eine Binärzahl umwandeln: `bin(d)` | ||
| - | * Beachte, dass damit umgewandelte Binärzahlen das Präxif `0b` haben, welches entfernt werden sollte. | ||
| - | * Beachte weiter, dass die resultierende Binärzahl 7 oder 8 Bits haben kann, was zu Problemen führen kann. Tipp: Stelle sicher, dass jede Binärzahl 8 Bits hat. Hänge also wenn nötig noch Nullen an. | ||
| - | |||
| - | === Aufgabe E4 (optional) === | ||
| - | |||
| - | Entschlüssle das folgende Bild mit einem *eigenen Code*. Der verwendete Schlüsselt findest du unten. | ||
| - | |||
| - | Klicke auf das Bild und lade es dann herunter. | ||
| - | {{ : | ||
| - | |||
| - | ++++Schlüssel| | ||
| - | <code python> | ||
| - | key = " | ||
| - | </ | ||
| - | ++++ | ||
| - | |||
| - | ++++Tipps| | ||
| - | |||
| - | 1. Arbeite nicht mit TigerJython sondern mit ' | ||
| - | 1. Arbeite mit der cv2 Library (`pip install pip install opencv-python`) | ||
| - | 1. Jedes Pixel besteht aus drei Bytes (je eines für Rot, Grün, Blau). | ||
| - | 1. Wandle diese Bytes in 8-Bit Binärzahlen um (wichtig: mit 0 auffüllen, damit immer 8 Bit) ... | ||
| - | 1. ... und hänge sie aneinander. | ||
| - | 1. Diesen langen Binärstring kannst du nun entschlüsseln. | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | ===== - Advanced Encryption System (AES) ===== | ||
| - | |||
| - | Advanced Encryption System (AES) ist ein symmetrisches Verschlüsselungsverfahren, | ||
| - | |||
| - | Spannendes Video zu Verschlüsselung, | ||
| - | |||
| - | {{youtube> | ||
| - | |||
| - | |||
| - | ==== Aufgaben F ==== | ||
| - | |||
| - | === Aufgabe F1 === | ||
| - | |||
| - | Die folgende Nachricht wurde mit AES-128 CBC verschlüsselt und im Hexadezimalsystem (mehr dazu in Aufgabe unten) dargestellt: | ||
| - | |||
| - | < | ||
| - | |||
| - | Die verwendeten Schlüssel sind: | ||
| - | * Key: `33 06 1c 1e fc 66 07 b6 b5 21 58 e2 34 75 0d ed` | ||
| - | * Initialization Vector: `d1 f7 37 76 68 27 24 47 cb 60 2b bf 60 f6 87 64` | ||
| - | |||
| - | Entschlüssle die verschlüsselten Nachricht mithilfe eines Online-Tools (z.B. [[https:// | ||
| - | |||
| - | ++++AES mit Python| | ||
| - | <code python> | ||
| - | """ | ||
| - | Installation: | ||
| - | |||
| - | Tipp: Verwende den AES.MODE_CBC Modus | ||
| - | """ | ||
| - | from Crypto.Cipher import AES | ||
| - | ... | ||
| - | </ | ||
| - | ++++ | ||
| - | |||
| - | === Aufgabe F2 === | ||
| - | |||
| - | 1. Was ist der Unterschied zwischen symmetrischen und asymmetrischen Verschlüsselungsverfahren? | ||
| - | 1. Wie unterscheiden sich Block- und Key-Längen bei AES-128 und AES-256? | ||
| - | 1. Wie unterscheiden sich ECB und CBC? | ||
| - | 1. Schreibe eine kurze Zusammenfassung von AES in eigenen Worten. | ||
| - | |||
| - | |||
| - | |||
| - | |||
| - | === Aufgabe F3 === | ||
| - | |||
| - | In der Aufgabe oben hast du viele Zahlen im **Hexadezimalsystem** angetroffen. Studiere nun die Theorie dazu: | ||
| - | |||
| - | Der Computer arbeitet bekanntlich im Binärsystem. In diesem werden aber selbst kürzeste Nachrichten sehr lange. | ||
| - | |||
| - | Beispiel: Wandelt man das Wort " | ||
| - | < | ||
| - | 01010010 01001111 01001101 01000001 01001110 01010011 01001000 01001111 01010010 01001110 | ||
| - | </ | ||
| - | Anstelle betrachtet man gerne die zugehörigen Darstellung im **Hexadezimalsystem** (Zahlensystem mit Basis $16$, Nennwerte $0, | ||
| - | |||
| - | Betrachten wir dazu das zweite Byte von oben: `01001111`. Die ersten vier Bits `0100` stehen für die Dezimalzahl $4$, was im Hexadezimalsystem ebenfalls $4$ ist. Die zweiten vier Bits `1111` stehen für $15$, im Hexadezimalsystem ist das `F`. Somit gilt: $$01001111_2 = 4F_{16}$$ | ||
| - | |||
| - | Jetzt können wir die Binärdarstellung von " | ||
| - | < | ||
| - | 52 4f 4d 41 4e 53 48 4f 52 4e | ||
| - | </ | ||
| - | |||
| - | Aufgaben: | ||
| - | |||
| - | 1. Wandle die Binärzahl `01000001 01000011 01000100 01000011` von Hand ins Hexadezimalsystem um. | ||
| - | 1. Der Binärcode der letzten Teilaufgabe ist der ASCII-Code von welchem Wort (nur Grossbuchstaben)? | ||
| - | 1. Wandlie die Hexzahl `4b 53 52` von Hand ins Binärsystem um. Welchem Wort entspricht dies? | ||
| - | |||
| - | |||
| - | === Aufgabe F4 === | ||
| - | |||
| - | 1. Schreibe einen Code (einfach!), der dir einen 16 Byte (128 Bit) langen Zufallsstring mit Hexadezimalzahlen erstellt in der Form `e9 50 33 f9 99 81 a1 b8 6c 47 82 3d 84 59 9a bc`. Tipp: Mit `hex(132)[2: | ||
| - | 1. Erstelle mit deinem Code von 1. einen Zufälligen 128 bit Schlüssel (Key) und einen 128 bit Initialization Vector (IV). | ||
| - | 1. Verschlüssele mit diesen auf [[https:// | ||
| - | 1. Entschlüssele die Nachricht, die du von deiner Sitznachbar: | ||
| - | |||
| - | === Aufgabe F5 (einfache Programmieraufgaben, | ||
| - | |||
| - | Programmiere folgende Funktionen: | ||
| - | * `bin_to_hex(binary)`: | ||
| - | * `hex_to_bin(hexa)`: | ||
| - | * `string_to_bin(text)`: | ||
| - | * `string_to_hex(text)`: | ||
| - | |||
| - | ===== - Weitere Aufgaben ===== | ||
| - | |||
| - | Für alle Aufgaben zu den klassischen Verschlüsselungsmethoden verwenden wir ausschliesslich das Alphabet " | ||
| - | |||
| - | === Aufgabe W1 === | ||
| - | |||
| - | Verschlüssle " | ||
| - | |||
| - | === Aufgabe W2 === | ||
| - | |||
| - | Entschlüssle die Nachricht " | ||
| - | |||
| - | < | ||
| - | ABCDEFGHIJKLMNOPQRSTUVWXYZ # Alphabet | ||
| - | SOGVNPKWEFLMUJDHZRAIYTBXCQ # Schlüssel | ||
| - | </ | ||
| - | |||
| - | === Aufgabe W3 === | ||
| - | |||
| - | Das wievielte Zeichen der Unicode-Tabelle wird gespeichert in der Zahl `11011001 10110111`? | ||
| - | |||
| - | === Aufgabe W4 === | ||
| - | |||
| - | Wandle ohne Hilfsmittel um: | ||
| - | |||
| - | 1. Hex `18 9b b7 e3` -> Dez | ||
| - | 1. Welches Wort steckt dahinter? `01101000 01100001 01101100 01101100 01101111` | ||
| - | 1. Vergleiche die beiden ASCII-Zeichen: | ||
| - | 1. `01001000 01000001 01001100 01001100 01001111` | ||
| - | 1. `01101000 01100001 01101100 01101100 01101111` | ||
| - | |||
| - | |||
| - | ===== Lösungen ===== | ||
| - | |||
| - | <nodisp 2> | ||
| - | |||
| - | ++++Lösungen A| | ||
| - | |||
| - | === Aufgabe A1 === | ||
| - | |||
| - | <code python> | ||
| - | ### Code funktioniert für ALPHABET als String oder Liste | ||
| - | ALPHABET = " | ||
| - | #ALPHABET = [' | ||
| - | |||
| - | def encryption_caesar(cleartext, | ||
| - | cleartext = cleartext.upper() # wandle Klartext in Grossbuchstaben um | ||
| - | cipher = "" | ||
| - | for c in cleartext: # alle Buchstaben des Klartextes durchgehen | ||
| - | if c in ALPHABET: # überprüft, | ||
| - | index = ALPHABET.index(c) + n # finde Index vom neuen Buchstaben, wende hier Caesar-Verschiebung an | ||
| - | index = index % len(ALPHABET) # stelle sicher, dass Index nicht ausserhalb liegt | ||
| - | cipher = cipher + ALPHABET[index] # füge neuen Buchstaben hinzu | ||
| - | else: # falls nicht vorkommt, füge Buchstaben unverschlüsselt hinzu | ||
| - | cipher = cipher + c | ||
| - | return cipher | ||
| - | |||
| - | print(encryption_caesar(" | ||
| - | </ | ||
| - | |||
| - | Um Code zu überprüfen, | ||
| - | <code python> | ||
| - | cipher = encryption_caesar(" | ||
| - | print(encryption_caesar(cipher, | ||
| - | </ | ||
| - | |||
| - | === Aufgabe A2 === | ||
| - | |||
| - | == a) == | ||
| - | |||
| - | " | ||
| - | |||
| - | == b) == | ||
| - | |||
| - | <code python> | ||
| - | cipher = " | ||
| - | for i in range(len(ALPHABET)): | ||
| - | print(encryption_caesar(cipher, | ||
| - | |||
| - | # KANTI ROMANSHORN, DIE INNOVATIVE SCHULE IM GRUENEN. | ||
| - | </ | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | ++++Lösungen B| | ||
| - | |||
| - | === Aufgabe B1 === | ||
| - | |||
| - | | ||
| - | 1. TGXZKELMAV | ||
| - | | ||
| - | |||
| - | === Aufgabe B2 === | ||
| - | |||
| - | **Option 1:** | ||
| - | |||
| - | <code python> | ||
| - | ALPHABET = [' | ||
| - | |||
| - | def encryption_vigenere(cleartext, | ||
| - | cleartext = upper(cleartext) | ||
| - | password = upper(password) | ||
| - | ciphertext = "" | ||
| - | for i in range(len(cleartext)): | ||
| - | c = cleartext[i] # symbol | ||
| - | if c in ALPHABET: | ||
| - | k = ALPHABET.index(c) | ||
| - | n = ALPHABET.index(password[i%len(password)]) + 1 | ||
| - | k = (k + n) % len(ALPHABET) | ||
| - | ciphertext += ALPHABET[k] | ||
| - | else: | ||
| - | ciphertext += c | ||
| - | return ciphertext | ||
| - | |||
| - | print(encryption_vigenere(" | ||
| - | </ | ||
| - | |||
| - | **Option 2:** | ||
| - | <code python> | ||
| - | ALPHABET = [' | ||
| - | MORSE = [' | ||
| - | |||
| - | def cleartext_to_morsecode(cleartext): | ||
| - | cleartext = upper(cleartext) | ||
| - | morsecode = "" | ||
| - | for c in cleartext: | ||
| - | if c in ALPHABET: | ||
| - | i = ALPHABET.index(c) | ||
| - | morsecode = morsecode + MORSE[i] + " " | ||
| - | return morsecode | ||
| - | |||
| - | |||
| - | def morsecode_to_cleartext(morsecode): | ||
| - | morsecode = morsecode.split(" | ||
| - | cleartext = "" | ||
| - | for m in morsecode: | ||
| - | if m in MORSE: | ||
| - | i = MORSE.index(m) | ||
| - | cleartext = cleartext + ALPHABET[i] | ||
| - | return cleartext | ||
| - | | ||
| - | |||
| - | print(cleartext_to_morsecode(" | ||
| - | print(morsecode_to_cleartext(" | ||
| - | </ | ||
| - | |||
| - | Da die beiden Funktionen fast identisch sind, kann man diese gewissermassen ' | ||
| - | <code python> | ||
| - | ALPHABET = [' | ||
| - | MORSE = [' | ||
| - | |||
| - | def translate(message, | ||
| - | """ | ||
| - | translation = "" | ||
| - | for c in message: | ||
| - | if c in alphabet_1: | ||
| - | i = alphabet_1.index(c) | ||
| - | translation = translation + alphabet_2[i] + " " | ||
| - | return translation | ||
| - | | ||
| - | def cleartext_to_morsecode(cleartext): | ||
| - | return translate(upper(cleartext), | ||
| - | |||
| - | def morsecode_to_cleartext(morsecode): | ||
| - | return translate(morsecode.split(" | ||
| - | |||
| - | print(cleartext_to_morsecode(" | ||
| - | print(morsecode_to_cleartext(" | ||
| - | </ | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | |||
| - | ++++Lösungen C| | ||
| - | === Aufgabe C1 === | ||
| - | |||
| - | 1. Ja, ist ein Sonderfall davon | ||
| - | 1. $26$ | ||
| - | 1. $26! = 403291461126605635584000000$, | ||
| - | 1. Scheint auf den ersten Blick extrem sicher, ist sie aber nicht (siehe nächster Punkt). | ||
| - | 1. Brute Force nicht zielführend, | ||
| - | |||
| - | |||
| - | === Aufgabe C2 === | ||
| - | |||
| - | PIZZAISTDASBESTEESSENDERWELT | ||
| - | |||
| - | === Aufgabe C3 === | ||
| - | |||
| - | == Option 1: Version 1 == | ||
| - | |||
| - | <code python> | ||
| - | def find_relative_frequency_single_line(line, | ||
| - | alph_cnt = [0 for i in range(len(ALPHABET))] | ||
| - | line = lower(line) | ||
| - | line = line.replace(' | ||
| - | line = line.replace(' | ||
| - | line = line.replace(' | ||
| - | line = line.replace(' | ||
| - | for c in line: | ||
| - | if c in alphabet: | ||
| - | i = alphabet.index(c) | ||
| - | alph_cnt[i] = alph_cnt[i] + 1 | ||
| - | return alph_cnt | ||
| - | |||
| - | def display_relative_frequency(alphabet, | ||
| - | for i in range(len(alphabet)): | ||
| - | print(alphabet[i] + ": " + str(round(alph_cnt[i]/ | ||
| - | |||
| - | ALPHABET = [' | ||
| - | faust = 'Habe nun, ach! Philosophie, | ||
| - | count = find_relative_frequency_single_line(faust, | ||
| - | display_relative_frequency(ALPHABET, | ||
| - | </ | ||
| - | |||
| - | == Option 1: Version 2 == | ||
| - | |||
| - | <code python> | ||
| - | def replace_chars(line): | ||
| - | line = lower(line) | ||
| - | line = line.replace(' | ||
| - | line = line.replace(' | ||
| - | line = line.replace(' | ||
| - | line = line.replace(' | ||
| - | # line = line.replace(' | ||
| - | # line = line.replace(',','' | ||
| - | # line = line.replace(' | ||
| - | return line | ||
| - | |||
| - | def char_count_single_line(line, | ||
| - | alph_cnt = [0 for i in range(len(ALPHABET))] | ||
| - | line = replace_chars(line) | ||
| - | for c in line: | ||
| - | if c in alphabet: | ||
| - | i = alphabet.index(c) | ||
| - | alph_cnt[i] = alph_cnt[i] + 1 | ||
| - | return alph_cnt | ||
| - | |||
| - | def char_count_single_line_dict(line): | ||
| - | alph_cnt = {} | ||
| - | line = replace_chars(line) | ||
| - | for c in line: | ||
| - | if c.isalpha(): | ||
| - | if c in alph_cnt: alph_cnt[c] += 1 # falls Eintrag nicht existiert in dict, erstelle diesen | ||
| - | else: alph_cnt[c] = 1 | ||
| - | return alph_cnt | ||
| - | |||
| - | def display_relative_frequency_list(alphabet, | ||
| - | for i in range(len(alphabet)): | ||
| - | print(alphabet[i] + ": " + str(round(alph_cnt[i]/ | ||
| - | |||
| - | def display_relative_frequency_dict(alph_cnt): | ||
| - | for key, value in alph_cnt.items(): | ||
| - | print(key + ": " + str(round(value/ | ||
| - | |||
| - | ### | ||
| - | faust = 'Habe nun, ach! Philosophie, | ||
| - | ### MIT LISTEN | ||
| - | ALPHABET = [' | ||
| - | count = char_count_single_line(faust, | ||
| - | display_relative_frequency_list(ALPHABET, | ||
| - | print() | ||
| - | ### MIT DICT | ||
| - | count = char_count_single_line_dict(faust) | ||
| - | display_relative_frequency_dict(count) | ||
| - | </ | ||
| - | |||
| - | == Option 2 == | ||
| - | |||
| - | <code python> | ||
| - | import urllib2 | ||
| - | |||
| - | def replace_umlaute(line): | ||
| - | line = line.replace(' | ||
| - | line = line.replace(' | ||
| - | line = line.replace(' | ||
| - | line = line.replace(' | ||
| - | return line | ||
| - | |||
| - | def find_relative_frequency(alphabet, | ||
| - | count = 0 | ||
| - | alph_cnt = [0 for i in range(len(ALPHABET))] | ||
| - | for line in data: | ||
| - | line = line.replace(' | ||
| - | if line_start <= count <= line_end: | ||
| - | if verbose: | ||
| - | if count == line_start: print(" | ||
| - | elif count == line_end: print(" | ||
| - | for c in replace_umlaute(line): | ||
| - | if c.isalpha(): | ||
| - | c = lower(c) | ||
| - | try: | ||
| - | i = ALPHABET.index(c) | ||
| - | alph_cnt[i] = alph_cnt[i] + 1 | ||
| - | except: | ||
| - | print(" | ||
| - | count = count + 1 | ||
| - | return alph_cnt | ||
| - | |||
| - | def display_relative_frequency(alphabet, | ||
| - | for i in range(len(alphabet)): | ||
| - | print(alphabet[i] + ": " + str(round(alph_cnt[i]/ | ||
| - | |||
| - | ALPHABET = [' | ||
| - | |||
| - | alph_cnt = find_relative_frequency(ALPHABET, | ||
| - | display_relative_frequency(ALPHABET, | ||
| - | </ | ||
| - | |||
| - | === Aufgabe C4 === | ||
| - | |||
| - | Erste Paragraphen vom ersten Band von Harry Potter. | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | ++++Lösungen D| | ||
| - | |||
| - | === Aufgabe D1 === | ||
| - | |||
| - | 1. `*` | ||
| - | 1. 55 | ||
| - | 1. " | ||
| - | |||
| - | === Aufgabe D2 === | ||
| - | |||
| - | Anzahl Zeichen mit x-Bytes: | ||
| - | |||
| - | 1. $128$ | ||
| - | 1. $2048$ | ||
| - | 1. $65536$ | ||
| - | 1. $2097152$ | ||
| - | |||
| - | Total also: $2164864$ | ||
| - | |||
| - | === Aufgabe D3 === | ||
| - | |||
| - | Alle Fragen werden im Video beantwortet ausser diejenige wo man selbst rechnen muss. Antwort: $350$ | ||
| - | |||
| - | === Aufgabe D4 === | ||
| - | |||
| - | <code python> | ||
| - | def unicode_symbol_number(b): | ||
| - | b = b.replace(' | ||
| - | if len(b) == 8: | ||
| - | return int(b[1: | ||
| - | elif len(b) == 16: | ||
| - | byte_1 = b[:8] | ||
| - | byte_2 = b[8:16] | ||
| - | return int(byte_1[3: | ||
| - | elif len(b) == 24: | ||
| - | byte_1 = b[:8] | ||
| - | byte_2 = b[8:16] | ||
| - | return int(byte_1[4: | ||
| - | elif len(b) == 32: | ||
| - | byte_1 = b[:8] | ||
| - | byte_2 = b[8:16] | ||
| - | byte_3 = b[16:24] | ||
| - | byte_4 = b[24:32] | ||
| - | return int(byte_1[5: | ||
| - | else: | ||
| - | raise Exception | ||
| - | |||
| - | print(unicode_symbol_number(" | ||
| - | print(unicode_symbol_number(" | ||
| - | print(unicode_symbol_number(" | ||
| - | </ | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | ++++Lösungen E| | ||
| - | |||
| - | ==== Aufgabe E1 ==== | ||
| - | |||
| - | `00111011 00010100 00001011` | ||
| - | |||
| - | ==== Aufgabe E2 ==== | ||
| - | |||
| - | <code python> | ||
| - | def insert_blanks(b, | ||
| - | for i in reversed(range(len(b)// | ||
| - | i = i + 1 | ||
| - | b = b[:i*n] + " " + b[i*n:] | ||
| - | if b[-1] == " ": | ||
| - | b = b[:-1] | ||
| - | return b | ||
| - | | ||
| - | def encryption_xor_binary(plaintext, | ||
| - | plaintext = plaintext.replace(' | ||
| - | key = key.replace(' | ||
| - | cipher = "" | ||
| - | # key verlaengern | ||
| - | while len(key) < len(plaintext): | ||
| - | key = key + key | ||
| - | # xor | ||
| - | for i in range(len(key)): | ||
| - | a = int(plaintext[i]) | ||
| - | b = int(key[i]) | ||
| - | cipher = cipher + str(a^b) | ||
| - | # immer nach 8 Stellen Leerschlag einfuegen (optional) | ||
| - | if blanks: | ||
| - | cipher = insert_blanks(cipher, | ||
| - | return cipher | ||
| - | | ||
| - | print(encryption_xor_binary(" | ||
| - | </ | ||
| - | |||
| - | === Aufgabe E3 === | ||
| - | |||
| - | <code python> | ||
| - | def insert_blanks(b, | ||
| - | for i in reversed(range(len(b)// | ||
| - | i = i + 1 | ||
| - | b = b[:i*n] + " " + b[i*n:] | ||
| - | if b[-1] == " ": | ||
| - | b = b[:-1] | ||
| - | return b | ||
| - | | ||
| - | def encryption_xor_binary(plaintext_binary, | ||
| - | plaintext_binary = plaintext_binary.replace(' | ||
| - | key_binary = key_binary.replace(' | ||
| - | cipher_binary = "" | ||
| - | # key verlaengern | ||
| - | while len(key_binary) < len(plaintext_binary): | ||
| - | key_binary = key_binary + key_binary | ||
| - | # xor | ||
| - | for i in range(len(plaintext_binary)): | ||
| - | a = int(plaintext_binary[i]) | ||
| - | b = int(key_binary[i]) | ||
| - | cipher_binary = cipher_binary + str(a^b) | ||
| - | # immer nach 8 Stellen Leerschlag einfuegen (optional) | ||
| - | if blanks: | ||
| - | cipher_binary = insert_blanks(cipher_binary, | ||
| - | return cipher_binary | ||
| - | |||
| - | def text_to_binary(text): | ||
| - | binary = "" | ||
| - | for c in text: | ||
| - | # buchstaben in 8bit Binaerzahl umwandeln | ||
| - | b = bin(ord(c))[2: | ||
| - | while len(b) < 8: # stellt sicher, dass 8 Stellen hat | ||
| - | b = ' | ||
| - | # und hinzufuegen | ||
| - | binary += " " + b | ||
| - | return binary[1:] | ||
| - | |||
| - | def binary_to_text(binary): | ||
| - | binary = binary.split() | ||
| - | text = "" | ||
| - | for c in binary: | ||
| - | text += chr(int(c, | ||
| - | return text | ||
| - | | ||
| - | def encryption_xor(plaintext, | ||
| - | plaintext_binary = text_to_binary(plaintext) | ||
| - | key_binary = text_to_binary(key) | ||
| - | return encryption_xor_binary(plaintext_binary, | ||
| - | |||
| - | def decryption_xor(ciphertext_binary, | ||
| - | key_binary = text_to_binary(key) | ||
| - | decripted = encryption_xor_binary(ciphertext_binary, | ||
| - | return binary_to_text(decripted) | ||
| - | |||
| - | msg = "Kanti Romanshorn, die innovative Schule im Grünen." | ||
| - | key = " | ||
| - | cipher_bin = encryption_xor(msg, | ||
| - | decripted = decryption_xor(cipher_bin, | ||
| - | print(cipher_bin) | ||
| - | print(decripted) | ||
| - | </ | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | ++++Lösungen F| | ||
| - | |||
| - | === Aufgabe F1 === | ||
| - | |||
| - | keine Lösung notwendig | ||
| - | |||
| - | === Aufgabe F2 === | ||
| - | |||
| - | 1. `41 43 44 43` | ||
| - | 2. " | ||
| - | 3. " | ||
| - | |||
| - | === Aufgabe F3 === | ||
| - | |||
| - | keine Lösung | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | ++++Aufgaben W| | ||
| - | |||
| - | === Aufgabe W1 === | ||
| - | |||
| - | EFSVWOVU | ||
| - | |||
| - | === Aufgabe W2 === | ||
| - | |||
| - | BALDSINDFERIENJUHEE | ||
| - | |||
| - | === Aufgabe W3 === | ||
| - | |||
| - | 1655 | ||
| - | |||
| - | === Aufgabe W4 === | ||
| - | |||
| - | | ||
| - | 1. " | ||
| - | 1. Gleicher Inhalt einfach einmal Grossbuchstsaben (`010.....`) und einmal Kleinbuchstaben (`011.....`) | ||
| - | |||
| - | ++++ | ||
| - | |||
| - | </ | ||
sca