alphabet = "abcdefghijklmnopqrstuvwxyz"
numbers = "0123456789"
abc_len = len(alphabet)
def sort(list, pool):
i = 0
while i < len(pool):
list.append(pool[i])
i += 1
return list
def delspace(list, pool):
new_list = []
list_len = len(list)
i = 0
while i < list_len:
try:
pool.index(list[i])
except:
pass
else:
new_list.append(list[i])
i += 1
return new_list
def retkey(string, pool):
new_string = ""
string_len = len(string)
i = 0
while i < string_len:
try:
pool.index(string[i])
except:
pass
else:
new_string = new_string + string[i]
i += 1
return new_string
invalid = "Invalid choice.\n"
enc_dec_m = "Do you want to encode or decode?\n1) Encode\n2) Decode\n"
enc_dec = input(enc_dec_m)
while (enc_dec != "1") and (enc_dec != "2"):
print(invalid)
enc_dec = input(enc_dec_m)
method_m = "What method do you want to use?\n1) Vigenère\n2) Beaufort\n3) Gronsfeld (Bronckhorst)\n"
method = input(method_m)
while (method != "1") and (method != "2") and (method != "3"):
print(invalid)
method = input(method_m)
if method == "1":
if enc_dec == "1":
print("You have chosen to encode plaintext to Vigenère ciphertext, (non A-z characters will be ignored).\n")
vig_enc_plaintext = input("Enter the plaintext:\n").lower()
vig_enc_plaintext_list = []
vig_enc_plaintext_list = sort(vig_enc_plaintext_list, vig_enc_plaintext)
vig_enc_plaintext_list = delspace(vig_enc_plaintext_list, alphabet)
vig_enc_plaintext_list_len = len(vig_enc_plaintext_list)
vig_enc_plaintext = retkey(vig_enc_plaintext, alphabet)
vig_enc_key_list_len = 0
while vig_enc_key_list_len == 0:
vig_enc_key = input("\nEnter the desired key:\n").lower()
vig_enc_key_list = []
vig_enc_key_list = sort(vig_enc_key_list, vig_enc_key)
vig_enc_key_list = delspace(vig_enc_key_list, alphabet)
vig_enc_key_list_len = len(vig_enc_key_list)
if vig_enc_key_list_len == 0:
print("Invalid input.")
vig_enc_key = retkey(vig_enc_key, alphabet)
while vig_enc_plaintext_list_len > vig_enc_key_list_len:
vig_enc_key_list.extend(vig_enc_key_list)
vig_enc_key_list_len = len(vig_enc_key_list)
vig_enc_ciphertext = []
i = 0
while i < vig_enc_plaintext_list_len:
vig_enc_plaintext_list_letter = 0
vig_enc_key_list_letter = 0
check_letter = True
try:
alphabet.index(vig_enc_plaintext_list[i])
except:
check_letter = False
else:
vig_enc_plaintext_list_letter = alphabet.index(vig_enc_plaintext_list[i])
try:
alphabet.index(vig_enc_key_list[i])
except:
check_letter = False
else:
vig_enc_key_list_letter = alphabet.index(vig_enc_key_list[i])
if check_letter == False:
vig_enc_ciphertext.append("?")
else:
vig_enc_cipher_letter_index = vig_enc_plaintext_list_letter + vig_enc_key_list_letter
if vig_enc_cipher_letter_index >= 26:
vig_enc_cipher_letter_index -= 26
vig_enc_ciphertext.append(alphabet[vig_enc_cipher_letter_index])
i += 1
i = 0
print(f"\n[Vigenère encoding]\n\n>>> Plaintext:\n{vig_enc_plaintext}\n\n>>> Key:\n{vig_enc_key}\n\n>>> Output:")
print(*vig_enc_ciphertext, sep="")
else:
print("You have chosen to decode Vigenère ciphertext to plaintext, (non A-z characters will be ignored).\n")
vig_dec_ciphertext = input("Enter the Vigenère ciphertext:\n").lower()
vig_dec_ciphertext_list = []
vig_dec_ciphertext_list = sort(vig_dec_ciphertext_list, vig_dec_ciphertext)
vig_dec_ciphertext_list = delspace(vig_dec_ciphertext_list, alphabet)
vig_dec_ciphertext_list_len = len(vig_dec_ciphertext_list)
vig_dec_ciphertext = retkey(vig_dec_ciphertext, alphabet)
vig_dec_key_list_len = 0
while vig_dec_key_list_len == 0:
vig_dec_key = input("\nEnter the known key:\n").lower()
vig_dec_key_list = []
vig_dec_key_list = sort(vig_dec_key_list, vig_dec_key)
vig_dec_key_list = delspace(vig_dec_key_list, alphabet)
vig_dec_key_list_len = len(vig_dec_key_list)
if vig_dec_key_list_len == 0:
print("Invalid input.")
vig_dec_key = retkey(vig_dec_key, alphabet)
while vig_dec_ciphertext_list_len > vig_dec_key_list_len:
vig_dec_key_list.extend(vig_dec_key_list)
vig_dec_key_list_len = len(vig_dec_key_list)
vig_dec_plaintext = []
i = 0
while i < vig_dec_ciphertext_list_len:
vig_dec_ciphertext_list_letter = alphabet.index(vig_dec_ciphertext_list[i])
vig_dec_key_list_letter = alphabet.index(vig_dec_key_list[i])
vig_dec_plain_letter_index = vig_dec_ciphertext_list_letter - vig_dec_key_list_letter
if vig_dec_plain_letter_index < 0:
vig_dec_plain_letter_index += 26
vig_dec_plaintext.append(alphabet[vig_dec_plain_letter_index])
i += 1
i = 0
print(f"\n[Vigenère decoding]\n\n>>> Cipher:\n{vig_dec_ciphertext}\n\n>>> Key:\n{vig_dec_key}\n\n>>> Output:")
print(*vig_dec_plaintext, sep="")
elif method == "2":
if enc_dec == "1":
print("You have chosen to encode plaintext to Beaufort ciphertext, (non A-z characters will be ignored).\n")
bea_enc_plaintext = input("Enter the plaintext:\n").lower()
bea_enc_plaintext_list = []
bea_enc_plaintext_list = sort(bea_enc_plaintext_list, bea_enc_plaintext)
bea_enc_plaintext_list = delspace(bea_enc_plaintext_list, alphabet)
bea_enc_plaintext_list_len = len(bea_enc_plaintext_list)
bea_enc_plaintext = retkey(bea_enc_plaintext, alphabet)
bea_enc_key_list_len = 0
while bea_enc_key_list_len == 0:
bea_enc_key = input("\nEnter the desired key:\n").lower()
bea_enc_key_list = []
bea_enc_key_list = sort(bea_enc_key_list, bea_enc_key)
bea_enc_key_list = delspace(bea_enc_key_list, alphabet)
bea_enc_key_list_len = len(bea_enc_key_list)
if bea_enc_key_list_len == 0:
print("Invalid input.")
bea_enc_key = retkey(bea_enc_key, alphabet)
while bea_enc_plaintext_list_len > bea_enc_key_list_len:
bea_enc_key_list.extend(bea_enc_key_list)
bea_enc_key_list_len = len(bea_enc_key_list)
bea_enc_ciphertext = []
i = 0
while i < bea_enc_plaintext_list_len:
bea_enc_plaintext_list_letter = alphabet.index(bea_enc_plaintext_list[i])
bea_enc_key_list_letter = alphabet.index(bea_enc_key_list[i])
bea_enc_cipher_letter_index = bea_enc_key_list_letter - bea_enc_plaintext_list_letter
if bea_enc_cipher_letter_index < 0:
bea_enc_cipher_letter_index += 26
bea_enc_ciphertext.append(alphabet[bea_enc_cipher_letter_index])
i += 1
i = 0
print(f"\n[Beaufort encoding]\n\n>>> Plaintext:\n{bea_enc_plaintext}\n\n>>> Key:\n{bea_enc_key}\n\n>>> Output:")
print(*bea_enc_ciphertext, sep="")
else:
print("You have chosen to decode Beaufort ciphertext to plaintext, (non A-z characters will be ignored).\n")
bea_dec_ciphertext = input("Enter the Beaufort ciphertext:\n").lower()
bea_dec_ciphertext_list = []
bea_dec_ciphertext_list = sort(bea_dec_ciphertext_list, bea_dec_ciphertext)
bea_dec_ciphertext_list = delspace(bea_dec_ciphertext_list, alphabet)
bea_dec_ciphertext_list_len = len(bea_dec_ciphertext_list)
bea_dec_ciphertext = retkey(bea_dec_ciphertext, alphabet)
bea_dec_key_list_len = 0
while bea_dec_key_list_len == 0:
bea_dec_key = input("\nEnter the known key:\n").lower()
bea_dec_key_list = []
bea_dec_key_list = sort(bea_dec_key_list, bea_dec_key)
bea_dec_key_list = delspace(bea_dec_key_list, alphabet)
bea_dec_key_list_len = len(bea_dec_key_list)
if bea_dec_key_list_len == 0:
print("Invalid input.")
bea_dec_key = retkey(bea_dec_key, alphabet)
while bea_dec_ciphertext_list_len > bea_dec_key_list_len:
bea_dec_key_list.extend(bea_dec_key_list)
bea_dec_key_list_len = len(bea_dec_key_list)
bea_dec_plaintext = []
i = 0
while i < bea_dec_ciphertext_list_len:
bea_dec_ciphertext_list_letter = alphabet.index(bea_dec_ciphertext_list[i])
bea_dec_key_list_letter = alphabet.index(bea_dec_key_list[i])
bea_dec_plain_letter_index = bea_dec_key_list_letter - bea_dec_ciphertext_list_letter
if bea_dec_plain_letter_index < 0:
bea_dec_plain_letter_index += 26
bea_dec_plaintext.append(alphabet[bea_dec_plain_letter_index])
i += 1
i = 0
print(f"\n[Beaufort decoding]\n\n>>> Cipher:\n{bea_dec_ciphertext}\n\n>>> Key:\n{bea_dec_key}\n\n>>> Output:")
print(*bea_dec_plaintext, sep="")
elif method == "3":
if enc_dec == "1":
print("You have chosen to encode plaintext to Gronsfeld ciphertext, (non A-z characters will be ignored for plaintext).\n")
gro_enc_plaintext = input("Enter the plaintext:\n").lower()
gro_enc_plaintext_list = []
gro_enc_plaintext_list = sort(gro_enc_plaintext_list, gro_enc_plaintext)
gro_enc_plaintext_list = delspace(gro_enc_plaintext_list, alphabet)
gro_enc_plaintext_list_len = len(gro_enc_plaintext_list)
gro_enc_plaintext = retkey(gro_enc_plaintext, alphabet)
while True:
try:
gro_enc_key = input("Enter the Gronsfeld key (digits):\n")
gro_enc_key_len = len(gro_enc_key)
i = 0
while i < gro_enc_key_len:
numbers.index(gro_enc_key[i])
i += 1
i = 0
except:
print("You have not entered digits, try again.\n")
else:
break
gro_enc_key_list = []
gro_enc_key_list = sort(gro_enc_key_list, gro_enc_key)
gro_enc_key_list = delspace(gro_enc_key_list, numbers)
gro_enc_key_list_len = len(gro_enc_key_list)
while gro_enc_plaintext_list_len > gro_enc_key_list_len:
gro_enc_key_list.extend(gro_enc_key_list)
gro_enc_key_list_len = len(gro_enc_key_list)
gro_enc_ciphertext = []
i = 0
while i < gro_enc_plaintext_list_len:
gro_enc_plaintext_list_letter = alphabet.index(gro_enc_plaintext_list[i])
gro_enc_key_list_letter = int(gro_enc_key_list[i])
gro_enc_cipher_letter_index = gro_enc_plaintext_list_letter + gro_enc_key_list_letter
if gro_enc_cipher_letter_index >= 26:
gro_enc_cipher_letter_index -= 26
gro_enc_ciphertext.append(alphabet[gro_enc_cipher_letter_index])
i += 1
i = 0
print(f"\n[Gronsfeld encoding]\n\n>>> Plaintext:\n{gro_enc_plaintext}\n\n>>> Key:\n{gro_enc_key}\n\n>>> Output:")
print(*gro_enc_ciphertext, sep="")
else:
print("You have chosen to decode Gronsfeld ciphertext to plaintext, (non A-z characters will be ignored for ciphertext).\n")
gro_dec_ciphertext = input("Enter the Gronsfeld ciphertext:\n").lower()
gro_dec_ciphertext_list = []
gro_dec_ciphertext_list = sort(gro_dec_ciphertext_list, gro_dec_ciphertext)
gro_dec_ciphertext_list = delspace(gro_dec_ciphertext_list, alphabet)
gro_dec_ciphertext_list_len = len(gro_dec_ciphertext_list)
gro_dec_ciphertext = retkey(gro_dec_ciphertext, alphabet)
while True:
try:
gro_dec_key = input("Enter the Gronsfeld key (digits):\n")
gro_dec_key_len = len(gro_dec_key)
i = 0
while i < gro_dec_key_len:
numbers.index(gro_dec_key[i])
i += 1
i = 0
except:
print("You have not entered digits, try again.\n")
else:
break
gro_dec_key_list = []
gro_dec_key_list = sort(gro_dec_key_list, gro_dec_key)
gro_dec_key_list = delspace(gro_dec_key_list, numbers)
gro_dec_key_list_len = len(gro_dec_key_list)
while gro_dec_ciphertext_list_len > gro_dec_key_list_len:
gro_dec_key_list.extend(gro_dec_key_list)
gro_dec_key_list_len = len(gro_dec_key_list)
gro_dec_plaintext = []
i = 0
while i < gro_dec_ciphertext_list_len:
gro_dec_ciphertext_list_letter = alphabet.index(gro_dec_ciphertext_list[i])
gro_dec_key_list_letter = int(gro_dec_key_list[i])
gro_dec_plain_letter_index = gro_dec_ciphertext_list_letter - gro_dec_key_list_letter
if gro_dec_plain_letter_index < 0:
gro_dec_plain_letter_index += 26
gro_dec_plaintext.append(alphabet[gro_dec_plain_letter_index])
i += 1
i = 0
print(f"\n[Gronsfeld decoding]\n\n>>> Cipher:\n{gro_dec_ciphertext}\n\n>>> Key:\n{gro_dec_key}\n\n>>> Output:")
print(*gro_dec_plaintext, sep="")
input()
