Assignment Chef icon Assignment Chef
All German tutorials

Programming lesson

Hill-Chiffre in Python: Schritt-für-Schritt-Tutorial zur CIS3360 Aufgabe 1

Lerne, wie du die Hill-Chiffre in Python implementierst – perfekt für die CIS3360 Programmieraufgabe 1. Mit Beispielen, Code und aktuellen Bezügen zur Kryptographie in Apps und Spielen.

Hill-Chiffre Python CIS3360 Aufgabe 1 Hill-Chiffre Implementierung Kryptographie Python Tutorial Hill-Chiffre Programmierung Python Verschlüsselung Hill-Chiffre Beispiel CIS3360 Hausaufgabe Hill-Chiffre Code Kryptographie in Apps Matrixverschlüsselung Python Hill-Chiffre Erklärung Python Kryptographie Projekt Lineare Algebra Kryptographie Hill-Chiffre Schritt für Schritt

Einführung in die Hill-Chiffre

Die Hill-Chiffre ist ein klassisches Verschlüsselungsverfahren aus der linearen Algebra, das heutzutage in vielen Bereichen wie Kryptographie in Apps, Spielen und AI-Sicherheit eine Rolle spielt. In diesem Tutorial lernst du, wie du eine Hill-Chiffre in Python implementierst – genau wie es die CIS3360 Aufgabe 1 verlangt. Wir gehen Schritt für Schritt vor, von der Eingabe der Schlüsselmatrix bis zur Ausgabe des Chiffretextes.

Was ist die Hill-Chiffre?

Die Hill-Chiffre verschlüsselt einen Klartext, indem sie Buchstaben in Zahlen umwandelt (a=0, b=1, …, z=25) und dann mit einer invertierbaren Matrix multipliziert. Die Matrixgröße kann von 2×2 bis 9×9 reichen – genau wie in deiner Hausaufgabe. Stell dir vor, du erstellst ein Spiel-Ranking und möchtest die Punktzahlen verschlüsseln: Die Hill-Chiffre wäre eine schnelle Methode, um Daten in einer App zu schützen.

Voraussetzungen und Setup

Du brauchst Python 3 und Grundkenntnisse in Python-Programmierung. Dein Programm muss pa01.py heißen und über die Kommandozeile mit zwei Parametern aufgerufen werden: der Schlüsseldatei und der Klartextdatei. So wie es in der CIS3360 Aufgabenstellung steht.

Beispiel für die Schlüsseldatei (k1.txt)

2
2 4
3 5

Beispiel für die Klartextdatei (p1.txt)

Not only is the Universe stranger than we think, it is stranger than we can think. Werner Heisenberg

Schritt 1: Einlesen der Schlüsselmatrix

Zuerst liest du die erste Zeile der Schlüsseldatei, die die Größe n enthält. Dann liest du die nächsten n Zeilen ein und speicherst die Zahlen in einer Liste von Listen (Matrix). Achte darauf, dass n zwischen 2 und 9 liegt. Hier ein Codeausschnitt:

def read_key(filename):
    with open(filename, 'r') as f:
        n = int(f.readline().strip())
        matrix = []
        for _ in range(n):
            row = list(map(int, f.readline().strip().split()))
            matrix.append(row)
    return n, matrix

Schritt 2: Verarbeitung des Klartextes

Der Klartext enthält nur Buchstaben (a-z, A-Z). Du musst alle anderen Zeichen entfernen und in Kleinbuchstaben umwandeln. Falls die Länge des Textes kein Vielfaches von n ist, füllst du mit 'x' auf. Das ist wichtig für die Blockverschlüsselung.

def process_plaintext(filename, n):
    with open(filename, 'r') as f:
        text = f.read()
    letters = [c.lower() for c in text if c.isalpha()]
    while len(letters) % n != 0:
        letters.append('x')
    return ''.join(letters)

Schritt 3: Verschlüsselung mit der Hill-Chiffre

Jetzt kommt der Kern: Du teilst den Klartext in Blöcke der Länge n, wandelst jeden Block in einen Vektor um (a=0, …, z=25), multiplizierst mit der Schlüsselmatrix (modulo 26) und wandelst zurück in Buchstaben. Hier ein Beispiel für n=2:

def hill_encrypt(plaintext, key_matrix, n):
    ciphertext = []
    for i in range(0, len(plaintext), n):
        block = plaintext[i:i+n]
        vec = [ord(c) - ord('a') for c in block]
        result = [0]*n
        for row in range(n):
            total = 0
            for col in range(n):
                total += key_matrix[row][col] * vec[col]
            result[row] = total % 26
        ciphertext.extend(chr(r + ord('a')) for r in result)
    return ''.join(ciphertext)

Schritt 4: Ausgabe formatieren

Die Ausgabe muss genau so aussehen wie in der Aufgabenstellung: zuerst die Schlüsselmatrix, dann der verarbeitete Klartext (maximal 80 Zeichen pro Zeile), dann der Chiffretext. Verwende print() mit Zeilenumbrüchen. Hier ein Beispiel für die Ausgabe:

Key matrix:
2 4
3 5
Plaintext:
notonlyistheuniversestrangerthanwethinkitisstrangerthanwecanthinkwernerheisenber
gx
Ciphertext:
efqxsqciitepovwzytawitizyrytooaniiooqlassteocmancmgqovktqwanooqlekytqhkioaawesyt
ad

Vollständiges Beispielprogramm

Hier ist der zusammenhängende Code für pa01.py:

import sys

def read_key(filename):
    with open(filename, 'r') as f:
        n = int(f.readline().strip())
        matrix = []
        for _ in range(n):
            row = list(map(int, f.readline().strip().split()))
            matrix.append(row)
    return n, matrix

def process_plaintext(filename, n):
    with open(filename, 'r') as f:
        text = f.read()
    letters = [c.lower() for c in text if c.isalpha()]
    while len(letters) % n != 0:
        letters.append('x')
    return ''.join(letters)

def hill_encrypt(plaintext, key, n):
    cipher = []
    for i in range(0, len(plaintext), n):
        block = plaintext[i:i+n]
        vec = [ord(c)-97 for c in block]
        res = [0]*n
        for r in range(n):
            s = 0
            for c in range(n):
                s += key[r][c] * vec[c]
            res[r] = s % 26
        cipher.extend(chr(r+97) for r in res)
    return ''.join(cipher)

def main():
    if len(sys.argv) != 3:
        print("Usage: python3 pa01.py kX.txt pX.txt")
        sys.exit(1)
    key_file = sys.argv[1]
    plain_file = sys.argv[2]
    n, key = read_key(key_file)
    plain = process_plaintext(plain_file, n)
    cipher = hill_encrypt(plain, key, n)
    # Ausgabe
    print("Key matrix:")
    for row in key:
        print(' '.join(map(str, row)))
    print()
    print("Plaintext:")
    # 80 Zeichen pro Zeile
    for i in range(0, len(plain), 80):
        print(plain[i:i+80])
    print()
    print("Ciphertext:")
    for i in range(0, len(cipher), 80):
        print(cipher[i:i+80])

if __name__ == "__main__":
    main()

Trendbezug: Warum ist das heute relevant?

Die Hill-Chiffre ist nicht nur eine Uni-Aufgabe, sondern auch die Grundlage für moderne Verschlüsselung in Apps wie WhatsApp oder Signal. In der KI-Ära werden Matrixoperationen für Machine Learning und Datensicherheit genutzt. Sogar in Spielen wie Call of Duty oder Fortnite werden ähnliche Algorithmen verwendet, um Spielerdaten zu schützen. Mit diesem Wissen bist du bestens gerüstet für Kryptographie-Projekte im Studium und Beruf.

Häufige Fehler und Tipps

  • Modulare Inverse: Die Hill-Chiffre benötigt eine invertierbare Matrix. Stelle sicher, dass die Determinante modulo 26 teilerfremd zu 26 ist. Für die Entschlüsselung bräuchtest du die inverse Matrix – aber in dieser Aufgabe wird nur verschlüsselt.
  • Padding: Vergiss nicht, den Klartext mit 'x' aufzufüllen, falls nötig.
  • Groß-/Kleinschreibung: Alle Buchstaben müssen in Kleinbuchstaben umgewandelt werden.

Fazit

Mit diesem Tutorial hast du eine voll funktionsfähige Hill-Chiffre in Python implementiert, die genau den Anforderungen der CIS3360 Aufgabe 1 entspricht. Du kannst das Programm jetzt testen und für deine Abgabe verwenden. Viel Erfolg!