def vigenere(text: str, key: str, mode: str) -> str:
"""Encrypts or decrypts a given text using the Vigenère cipher.
The function processes a string of uppercase alphabetic characters
using a provided key for encryption or decryption.
Args:
text: The string to be encrypted or decrypted. It should only contain
uppercase alphabetic characters (A-Z).
key: The key for the cipher. It should also only contain
uppercase alphabetic characters (A-Z).
mode: The operation to perform, must be 'encrypt' or 'decrypt'.
Returns:
The resulting ciphertext or plaintext.
Raises:
ValueError: If the mode is not 'encrypt' or 'decrypt'.
"""
# Ensure the mode is valid before proceeding.
if mode not in ['encrypt', 'decrypt']:
raise ValueError("Mode must be 'encrypt' or 'decrypt'")
key_length = len(key)
if mode == 'encrypt':
cipher = ''
# Iterate through each character of the input text.
for i, char in enumerate(text):
# Convert the current text character and the corresponding key
# character to a number (0-25).
# The key character is determined using modulo to cycle through
# the key.
char_num = ord(char) - ord('A')
key_num = ord(key[i % key_length]) - ord('A')
# Calculate the new character's number using the Vigenère encryption formula.
# The modulo operator ensures the result stays within the range 0-25.
cipher_num = (char_num + key_num) % 26
# Convert the resulting number back to an uppercase character and append it.
cipher += chr(cipher_num + ord('A'))
return cipher
else: # mode == 'decrypt'
plain = ''
# Iterate through each character of the input text.
for i, char in enumerate(text):
# Convert the current text character and the corresponding key
# character to a number (0-25).
char_num = ord(char) - ord('A')
key_num = ord(key[i % key_length]) - ord('A')
# Calculate the new character's number using the Vigenère
# decryption formula.
# The modulo operator handles negative results, ensuring the
# result is correct.
plain_num = (char_num - key_num) % 26
# Convert the resulting number back to an uppercase
# character and append it.
plain += chr(plain_num + ord('A'))
return plain10 Vigenère Chiffre Implementierung in Python
TippNotebook interaktiv ausführen
In diesem Notebook wird eine mögliche Implementierung der Vigenère Chiffre in Python vorgestellt.
Die Funktion vigenere() wird im Folgenden detailliert erklärt.
Die Signatur der Funktion
zeigt, dass die Funktion drei Parameter erwartet: * text: Der zu verschlüsselnde oder zu entschlüsselnde Text als String. * key: Der Schlüssel zur Verschlüsselung oder Entschlüsselung als String. * mode: Der Modus, der angibt, ob der Text verschlüsselt oder entschlüsselt werden soll. Mögliche Werte sind 'encrypt' für Verschlüsselung und 'decrypt' für Entschlüsselung (dies ist allerdings nicht direkt aus der Signatur ersichtlich).
Anschliessend an die Signatur folgt ein ausführlicher Docstring, der die Funktion und ihre Parameter beschreibt. Dieser ist - obwohl in Englisch abgefasst - aus sich selber heraus verständlich.
Der Docstring wird gefolgt durch die Prüfung, ob zulässige Werte für den mode-Parameter übergeben wurden. Ist dies nicht der Fall, wird eine ValueError-Exception ausgelöst.
Um diese Prüfung durchzuführen, werden die zulässigen Werte in einer Liste zur Verfügung gestellt. Geprüft wird dann, ob der mode zugewiesene Wert in der Liste enthalten ist. Falls dies nicht der Fall ist, wird eine Fehlermeldung ausgegeben und die Ausführung der Funktion abgebrochen.
Sofern der mode-Parameter einen zulässigen Wert enthält, beginnt die eigentliche Funktionslogik zu spielen.
Als erstes wird die Länge des Schlüssels in
der Variablen key_length zugewiesen. Diese Information wird weiter unten benötigt, um in einer besonderen Art von Schlaufe über den Text des Schlüssels zu iterieren.
Nach dieser Zuweisung teilt sich die Funktion in die Zweige Ver- bzw. Entschlüsselung.
Zuerst wird die Verschlüsselung - eingeleitet mit if mode == 'encrypt': - betrachtet.
Innerhalb dieses Blocks wird als erstes ein leerer String cipher initialisiert, der später die verschlüsselten Zeichen aufnehmen wird.
Anschliessend wird mit einer for-Schlaufe über den zu verschlüsselnden Text iteriert.
In dieser Schlaufe wird die Funktion enumerate() verwendet. Diese Funktion liefert ein Tupel aus Index und dem jeweiligen Element der Struktur, über die iteriert wird. Die Werte des Tupels werden den Variablen i und char zugewiesen.
Die Variabeln i und char werden innerhalb der Schlaufe verwendet, um die einzelnen Zeichen des Textes in eine Zahl umzuwandeln.
Die Funktion ord() wandelt einen Buchstaben in die entsprechende Zahl aus der ASCII-Tabelle um. Damit die Zahlen im Bereich von 0 bis 25 liegen, wird der ASCII-Wert des Buchstabens ‘A’ abgezogen. Der Buchstabe ‘A’ wird verwendet, da die zu verschlüsselnden Zeichen in Grossbuchstaben vorgegeben sind.
Da der Schlüssel kürzer als der zu verschlüsselnde Text sein kann, wird mit i % key_length über den Schlüssel iteriert. Der Modulo-Operator % sorgt dafür, dass der Index Wert des verwendeten Index immer zwischen 0 und der Länge des Schlüssels key_length bleibt. Dadurch wird sichergestellt, dass der Schlüssel wieder von vorne begonnen wird, sobald das Ende des Schlüssels erreicht ist. Anschliessend wird mit den einzelnen Buchstaben des Schlüssels genauso verfahren wie mit den Buchstaben des Textes.
Nachdem die Buchstaben des Textes sowie des Schlüssels in Zahlen umgewandelt wurden, wird die eigentliche Verschlüsselung gemäss der Formel \(C_i = (P_i + K_i)\ mod\ 26\) durchgeführt.
Die Zahlenwerte des verschlüsselten Textes werden anschliessend wieder in Buchstaben umgewandelt und an den String cipher angehängt. Dazu wird die Funktion chr() verwendet, die eine Zahl in den entsprechenden Buchstaben der ASCII-Tabelle umwandelt. Da die Zahlenwerte im Bereich von 0 bis 25 liegen, wird der ASCII-Wert des Buchstabens ‘A’ addiert.
Der unter cipher abgelegte String wird am Ende des Blocks zurückgegeben.
Im zweiten Block wird die Entschlüsselung - eingeleitet mit else: - durchgeführt. Der Prozess ist dem der Verschlüsselung sehr ähnlich, jedoch wird hier die umgekehrte Formel (\(P_i = (C_i - K_i + 26)\ mod\
26\)) verwendet.
Alles andere entspricht dem Vorgehen bei der Verschlüsselung.