affine-cipher 0.1.0__py3-none-any.whl

affine_cipher/__init__.py

@@ -0,0 +1,2 @@
+def main() -> None:
+    print("Hello from affine-cipher!")

affine_cipher/case.py

@@ -0,0 +1,5 @@
+def restore_char_case(original: str, transformed: str) -> str:
+    if original.islower():
+        return transformed.lower()
+    else:
+        return transformed

affine_cipher/cli.py

@@ -0,0 +1,37 @@
+import argparse
+
+from affine_cipher.decrypt import run_decrypt
+from affine_cipher.encrypt import run_encrypt
+
+
+def main() -> None:
+
+    parser = argparse.ArgumentParser(prog="affine-cipher")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    encrypt_parser = subparsers.add_parser("encrypt")
+    decrypt_parser = subparsers.add_parser("decrypt")
+
+    for p in [encrypt_parser]:
+        p.add_argument("-a", type=int, required=True)
+        p.add_argument("-b", type=int, required=True)
+
+    for p in [decrypt_parser]:
+        p.add_argument("-a", type=int, required=False)
+        p.add_argument("-b", type=int, required=False)
+        p.add_argument("--brute-force", action="store_true")
+
+    args = parser.parse_args()
+
+    try:
+        if args.command == "encrypt":
+            run_encrypt(args.a, args.b)
+        elif args.command == "decrypt":
+            if (args.a is None) != (args.b is None):
+                parser.error("-a and -b must be given together")
+            if (args.a is not None) and (args.b is not None) and (args.brute_force):
+                parser.error(
+                    "-a and -b and --brute-force cannot all be selected together. Choose either -a and -b or --brute-force."  # noqa: E501
+                )
+            run_decrypt(args.a, args.b, args.brute_force)
+    except ValueError as e:
+        parser.error(str(e))

affine_cipher/decrypt.py

@@ -0,0 +1,97 @@
+import string
+
+from colorama import Fore, init
+
+from affine_cipher.case import restore_char_case
+from affine_cipher.key_validation import validate_affine_key
+
+
+# Function to get the Euclidean Algorithm
+def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
+    """
+    extended Euclidean Algorithm to find the greatest common divisor and
+    coefficients x, y such that ax + by = gcd(a, b)
+    """
+    if a == 0:
+        return (b, 0, 1)
+    else:
+        g, x, y = extended_gcd(b % a, a)
+        return (g, y - (b // a) * x, x)
+
+
+# function to get the modular inverse
+def modular_inverse(a: int, m: int) -> int:
+    """
+    Compute the modular multiplicative inverse of a modulo m.
+    Raises an exception if the modular inverse does not exist.
+    """
+    g, x, y = extended_gcd(a, m)
+    if g != 1:
+        raise ValueError("Modular inverse does not exist!")
+    else:
+        return x % m
+
+
+# Function to decrypt our message
+def affine_decrypt(ciphertext: str, a: int, b: int) -> str:
+    """
+    Decrypt a message with the Affine Cipher using the given key components a and b.
+    """
+    alphabet = string.ascii_uppercase
+    m = len(alphabet)
+    validate_affine_key(a, m)
+    plaintext = ""
+    # Compute the multiplicative inverse of a
+    a_inv = modular_inverse(a, m)
+    # Iterate through each character in the ciphertext
+    for char in ciphertext:
+        # Check if the character is in the alphabet
+        if char.upper() in alphabet:
+            # If it's an alphabet letter, decrypt it
+            # Find the index of the character in the alphabet
+            c = alphabet.index(char.upper())
+            # Apply the decryption formula: a_inv * (c - b) mod m
+            p = (a_inv * (c - b)) % m
+            transformed = alphabet[p]
+            # Append the decrypted character to the plaintext
+            plaintext += restore_char_case(char, transformed)
+        else:
+            # If the character is not in the alphabet, keep it unchanged
+            plaintext += char
+    # Return the decrypted plaintext
+    return plaintext
+
+
+# Function to perform brute-force attack
+def affine_brute_force(ciphertext: str) -> None:
+    """
+    Brute-force attack to find possible keys for an Affine Cipher and print
+    potential decryptions for manual inspection.
+    """
+    alphabet = string.ascii_uppercase
+    m = len(alphabet)
+    # Iterate through possible values for a
+    for a in range(1, m):
+        # Ensure a and m are coprime
+        if extended_gcd(a, m)[0] == 1:
+            # Iterate through possible values for b
+            for b in range(0, m):
+                # Decrypt using the current key
+                decrypted_text = affine_decrypt(ciphertext, a, b)
+                # Print potential decryption for manual inspection
+                print(f"Key a={a}, b={b}: {decrypted_text}")
+
+
+def run_decrypt(a: int | None, b: int | None, brute_force: bool) -> None:
+    # Initialize Colorama
+    init()
+
+    ciphertext = input(f"{Fore.GREEN}[?] Enter message to decrypt: ")
+    if a is not None and b is not None:
+        decrypted_text = affine_decrypt(ciphertext, a, b)
+        print(f"{Fore.GREEN}[+] Decrypted Text: {decrypted_text} ")
+    elif a is None and b is None and not brute_force:
+        raise ValueError("Please either supply a key or --brute-force.")
+    else:
+        # Perform a brute-force attack to find a potential decrypted message.
+        affine_brute_force(ciphertext)

affine_cipher/encrypt.py

@@ -0,0 +1,48 @@
+import string
+
+from colorama import Fore, init
+
+from affine_cipher.case import restore_char_case
+from affine_cipher.key_validation import validate_affine_key
+
+
+def affine_encryption(plaintext: str, a: int, b: int) -> str:
+    # Define the uppercase alphabet.
+    alphabet = string.ascii_uppercase
+    # Get the length of the alphabet
+    m = len(alphabet)
+    validate_affine_key(a, m)
+    # Initialize an empty string to store the ciphertext.
+    ciphertext = ""
+    # Iterate through each character in the plaintext.
+    for char in plaintext:
+        # Check if the character is in the alphabet.
+        if char.upper() in alphabet:
+            # If it's an alphabet letter, encrypt it.
+            # Find the index of the character in the alphabet.
+            p = alphabet.index(char.upper())
+            # Apply the encryption formula: (a * p + b) mod m.
+            c = (a * p + b) % m
+            # Append the encrypted character to the ciphertext.
+            transformed = alphabet[c]
+            ciphertext += restore_char_case(char, transformed)
+        else:
+            # If the character is not in the alphabet, keep it unchanged.
+            ciphertext += char
+    # Return the encrypted ciphertext.
+    return ciphertext
+
+
+def run_encrypt(a: int, b: int) -> None:
+
+    # Initialize Colorama
+    init()
+
+    # Define the plaintext and key components
+    plaintext = input(f"{Fore.GREEN}[?] Enter text to encrypt: ")
+
+    # Call the affine_crypt function with the specified parameters
+    encrypted_text = affine_encryption(plaintext, a, b)
+    # Print the original plaintext, the key components, and the encrypted text
+    print(f"{Fore.MAGENTA}[+] Plaintext: {plaintext}")
+    print(f"{Fore.GREEN}[+] Encrypted Text: {encrypted_text} ")

affine_cipher/key_validation.py

@@ -0,0 +1,9 @@
+import math
+
+
+def validate_affine_key(a: int, m: int) -> None:
+    if math.gcd(a, m) != 1:
+        compute_valid_key = ", ".join(
+            str(i) for i in range(1, m) if math.gcd(i, m) == 1
+        )
+        raise ValueError(f"This key is invalid. Try again. {compute_valid_key}")