def main():
for i in range(20):
# set random message to test
random.seed(42)
message = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' * random.randint(4, 40)
# convert message to a list and shuffle it
message = list(message)
random.shuffle(message)
message = ''.join(message)
print('Test #%s: "%s..."' % (i + 1, message[:50]))
# Check all possible keys for each message
for key in range(1, len(message)):
encrypted = Caesar.caesar_cipher(message, key)
decrypted = Caesar.caesar_cipher(encrypted, key, 'decrypt')
# encrypted and decrypted should match
if message != decrypted:
print('Mismatch with key %s and message %s. \n' %
(key, message))
print(decrypted)
sys.exit()
print('Transposition cipher is passed')
def test_sanity(self):
c = Caesar(3)
e = CaesarExploits()
self.assertTrue(c.encrypt("hello")=="khoor")
self.assertTrue(c.decrypt("khoor")=="hello")
self.assertTrue(e.known_plaintext("hello", "khoor") == 3)
self.assertTrue(e.chosen_plaintext(c)==3)
self.assertTrue(e.chosen_ciphertext(c)==3)
def main():
sentence = raw_input('Enter a sentence: ')
sentence = sentence.upper()
wordList = sentence.split()
print sentence
print wordList
for word in wordList:
print Caesar.encryptWord(word),
def task1():
encrypted_data = read('./text_files/t3_caesar_c_all.txt')
for key in range(256):
decrypted = Caesar.decrypt_data(encrypted_data[:25], key)
txt = ''.join(chr(ch) for ch in decrypted)
if isEnglish(txt):
break
decrypted_data = Caesar.decrypt_data(encrypted_data, key)
write('./text_files/task1_decrypted.txt', decrypted_data)
def task2():
encrypted_img_data = read('./imgs/c4_caesar_c_all.bmp')
for key in range(256):
decrypted = Caesar.decrypt_data(encrypted_img_data[:2], key)
if decrypted == [66, 77]:
print(f'Key is {key}')
break
decrypted_bmp = Caesar.decrypt_data(encrypted_img_data, key)
write('./imgs/task2_decrypted_bmp.BMP', decrypted_bmp)
def decrypt(self, event):
InvalidKey = ("Invalid key, re-enter key")
NotInt = ("Not an integer")
EncryptedText = self.Text.get()
Key = self.Key.get()
while True:
try:
Key = int(Key)
except ValueError:
self.useful_msg.set(NotInt)
return False
else:
if Key >= 1 and Key <= 25:
break
else:
self.useful_msg.set(InvalidKey)
return False
DecryptedText = Caesar.Decrypt(EncryptedText, Key)
self.Out.set(DecryptedText)
self.useful_msg.set("Decryption complete")
def main():
print()
cipher = None
# Determine which type of cipher
if cipher_name == 'PLF':
cipher = Playfair()
elif cipher_name == 'RTS':
cipher = RowTransposition()
elif cipher_name == 'RFC' or cipher_name == 'CES':
try:
shift_amt = int(key)
except ValueError:
print("ERR: Please enter a number as the key for a Caesar/Railfence cipher!\n")
return
cipher = Railfence() if cipher_name == 'RFC' else Caesar()
elif cipher_name == 'VIG':
cipher = Vigenere()
else:
print("ERR: Not a valid cipher type! Please use:")
print("\tPLF, RTS, RFC, VIG, or CES\n")
return
# Set the key
if not cipher.setKey(key):
print("ERR: Invalid key, try again.\n")
return
inFile = None
outFile = None
# Attempt to read in the text the user wants to encrypt/decrypt
try:
inFile = open(input_file, "r")
except FileNotFoundError:
print("ERR: '", input_file, "' cannot be opened! Try a valid file\n")
return
outFile = open(output_file, 'w')
# Perfrom the encryption/decryption
if method == "ENC":
plaintext = inFile.read()
ciphertext = cipher.encrypt(plaintext)
outFile.write(ciphertext)
print("Encryption was successfull!")
elif method == "DEC":
ciphertext = inFile.read()
plaintext = cipher.decrypt(ciphertext)
outFile.write(plaintext)
print("Decryption was successfull!")
else:
print("ERR: Incorrect method. Please enter 'ENC' or 'DEC'\n")
return
print("Thank you for using this program.\n")
def processArgs(args):
filename = args.file[0]
if args.encrypt:
file = open(filename, "r")
resultFileName = createResultFile(filename, '_encrypted')
resultFile = open(resultFileName, "w+")
ln = file.readlines()
for x in ln:
if args.caesar:
ret = Caesar.caesarCipherEncrypt(x)
resultFile.write(ret)
elif args.substitution:
ret = SimpleSubstitution.simpleSubEncrypt(x)
resultFile.write(ret)
elif args.poly:
ret = PolyAlpha.polyEncrypt(x)
resultFile.write(ret)
elif args.transposition:
ret = Transposition.transEncrypt(x)
resultFile.write(ret)
else:
ret = Caesar.caesarCipherEncrypt(x)
resultFile.write(ret)
elif args.decrypt:
file = open(filename, "r")
resultFileName = createResultFile(filename, '_decrypted')
resultFile = open(resultFileName, "w+")
ln = file.readlines()
for x in ln:
if args.caesar:
ret = Caesar.caesarCipherDecrypt(x)
resultFile.write(ret)
elif args.substitution:
ret = SimpleSubstitution.simpleSubDecrypt(x)
resultFile.write(ret)
elif args.poly:
ret = PolyAlpha.polyDecrypt(x)
resultFile.write(ret)
elif args.transposition:
ret = Transposition.transDecrypt(x)
resultFile.write(ret)
else:
ret = Caesar.caesarCipherDecrypt(x)
resultFile.write(ret)
def test_decrypt(self):
"""Tests decrypt function for Caesar cipher"""
self.assertEqual(
Caesar.decrypt(ALPHABET[10:] + ALPHABET[:10], 10), ALPHABET)
self.assertEqual(
Caesar.decrypt('KPUZEJOTYDINSXCHMRWBGLQVAF', 10, 5), ALPHABET)
with self.assertRaises(Caesar.CaesarError):
Caesar.decrypt(5, 5)
with self.assertRaises(Caesar.CaesarError):
Caesar.decrypt(ALPHABET, 1, 39)
with self.assertRaises(Caesar.CaesarError):
Caesar.decrypt(ALPHABET, 1, 20)
def main(argv):
if(len(sys.argv) != 2):
helps()
sys.exit(1)
options = str(sys.argv[1])
#encryption
if options == "-e":
setWindowTitle("CCrypter")
banner()
plaintext = raw_input(color.proc(" Enter messages : "))
key = raw_input(color.proc(" Enter key : "))
try:
Caesar.encrypt(str(plaintext), key)
except:
print(color.error(" Failed to encrypt ! "))
#decryption
if options == "-d":
setWindowTitle("CCrypter")
banner()
ciphertext = raw_input(color.proc(" Enter ciphertext : "))
key = raw_input(color.proc(" Enter key : "))
try:
Caesar.decrypt(str(ciphertext), key)
except:
print(color.error(" Failed to decrypt ! "))
if options == "-fe":
setWindowTitle("CCrypter")
banner()
file = raw_input(color.proc(" Enter file to encrypt : "))
key = raw_input(color.proc(" Enter key : "))
try:
print(color.proc(" Encrypting ..."))
Caesar.encryptFile(file, key)
except:
print(color.error(" Encrypting failed !"))
print ""
if options == "-fd":
setWindowTitle("CCrypter")
banner()
file = raw_input(color.proc(" Enter file to decrypt : "))
key = raw_input(color.proc(" Enter key : "))
try:
print(color.proc(" Decrypting ..."))
Caesar.decryptFile(file, key)
except:
print(color.error(" Decrypting failed !"))
print ""
if not options in ["-e","-d","-fe","-fd"]:
helps()
def list_all_cs(text):
"""
lists chi-squared statistic for all caesar shifts of the text, returns the user's choice of key to proceed with
:param text:
:return key:
"""
alphabet = 'abcdefghijklmnopqrstuvwxyz'
for i in range(0, 26):
decrypted = Caesar.decrypt(text, i)
print ('key %2s %s %10.4f' % (i, decrypted, chi_squared(decrypted)))
return alphabet[int(raw_input('key choice: '))]
def list_all_cs(text):
"""
lists chi-squared statistic for all caesar shifts of the text, returns the user's choice of key to proceed with
:param text:
:return key:
"""
alphabet = 'abcdefghijklmnopqrstuvwxyz'
for i in range(0, 26):
decrypted = Caesar.decrypt(text, i)
print('key %2s %s %10.4f' % (i, decrypted, chi_squared(decrypted)))
return alphabet[int(raw_input('key choice: '))]
def decrypt(text, seed):
"""Decrypts text using the One-Time Pad cipher
D(x) = Caesar.decrypt(x, random)
text : string
seed : hashable
"""
random.seed(seed)
return ''.join(Caesar.decrypt(letter, random.randint(0, 25))
for letter in utils.fix_text(text))
def decrypt(text, password):
"""Decrypts text using the Vigenere cipher
D(text[i]) = (text[i] - password[i]) % 26
text, password : string
"""
password = utils.fix_text(password)
length = len(password)
A = ord('A')
return ''.join([Caesar.decrypt(letter, ord(password[index % length])
- A) for index, letter in enumerate(utils.fix_text(text))])
def live_decrypt(pw):
dec_msg = ''
print 'Enter message to decrypt:'
i = 0
while True:
msg = str(raw_input())
if msg == 'exit()': break
msg_out = ''
for j in range(len(msg)):
msg_out += Caesar.decrypt(
ord(pw[i % len(pw)].lower()) - ord('a') + 1, msg[j])
i += 1
dec_msg += msg_out
print msg_out
return dec_msg
def __decrypt(message, key):
# Split message in half
B = message[:len(message) / 2]
C = message[len(message) / 2:]
Rail_Fence_key = Jordan_Harman_Algorithm_1.get_rail_key(key)
Caesar_key = Jordan_Harman_Algorithm_1.get_caesar_key(key)
Vigenere_key = Jordan_Harman_Algorithm_1.get_vigenere_key(key)
# Begin Rounds
for x in range(0, 8):
C = Caesar.decrypt(C, Caesar_key)
C = Rail_Fence.decrypt(C, Rail_Fence_key)
C = Vigenere.decrypt(C, Vigenere_key)
B, C = C, B
return B + C
def __encrypt(message, key):
# Split message in half
Ln = message[:len(message) / 2]
Rn = message[len(message) / 2:]
# Get keys
Rail_Fence_key = Jordan_Harman_Algorithm_1.get_rail_key(key)
Caesar_key = Jordan_Harman_Algorithm_1.get_caesar_key(key)
Vigenere_key = Jordan_Harman_Algorithm_1.get_vigenere_key(key)
# Begin Rounds
for x in range(0, 8):
Rn = Vigenere.encrypt(Rn, Vigenere_key)
Rn = Rail_Fence.encrypt(Rn, Rail_Fence_key)
Rn = Caesar.encrypt(Rn, Caesar_key)
Ln, Rn = Rn, Ln
return Ln + Rn
def crackVigenere(message):
messageNums = [] #Numerical characters, all lowercase
messageModified = '' #String, all lowercase
for c in message:
n = ord(c)
if 65<=n<=90:
messageNums.append(n+32)
elif 97<=n<=122:
messageNums.append(n)
for n in messageNums:
messageModified+=str(chr(n))
try:
keyLength = Kasiski.kasiski(messageModified,3,15)[0] #Most likely key length based on Kasiski Analysis of ciphertext
except IndexError:
print('Kasiski Analysis failed. Message might be too short, or key might be too short or too long')
return None
print('Guessed key length as: '+str(keyLength))
frequencyAnalyses = []
splitTexts = []
permutationSet = []
for i in range(keyLength):
l=[]
n=i
while n<len(messageNums):
l.append(messageNums[n])
n+=keyLength
splitTexts.append(l)
frequencyAnalyses.append(Caesar.frequencyAnalysis(l))
permutationSet.extend([0,1,2,3]) #Highest number defines how deep in frequency tree program will search.
p = permutations(permutationSet, keyLength)
perms = sorted(set(p))
for perm in perms:
key = ''
for j in range(keyLength):
key+=str(chr((frequencyAnalyses[j])[perm[j]]+97))
decodedString = str(EncodeDecode.decodeVigenere(messageModified, key))
validWords = DictionaryCheck.dictCheck(decodedString)
print('Guessed key as: ' + key+ '. There are ' + str(validWords) +' valid words as a part of the decoded message')
if(DictionaryCheck.dictCheck(decodedString)>0.28*len(decodedString)): #0.28, approximately
print('Number of valid words is greater than 0.28*message length. This key is likely correct!')
return decodedString
def decrypt(text, password):
"""Decrypts text using the Vigenere cipher
D(text[i]) = (text[i] - password[i]) % 26
text, password : string
"""
if type(text) is not str:
raise VigenereError('Can only decrypt strings.')
if type(password) is not str:
raise VigenereError('Password must be a string.')
password = utils.fix_text(password)
length = len(password)
A = ord('A')
return ''.join([Caesar.decrypt(letter, ord(password[index % length])
- A) for index, letter in enumerate(utils.fix_text(text))])
cipher = CipherInterface() assert arguments.cipher in valid_ciphers, "Cipher not recognized. Use --help for more info." # set cipher to specified cipher if(arguments.cipher == "PLF"): cipher = Playfair() elif(arguments.cipher == "RTS"): cipher = RowTransposition() elif(arguments.cipher == "RFC"): cipher = Railfence() elif(arguments.cipher == "VIG"): cipher = Vigenre() elif(arguments.cipher == "CES"): cipher = Caesar() elif(arguments.cipher == "HIL"): cipher = Hill() elif(arguments.cipher == "EGM"): cipher = Enigma() # Normalize and set the cipher key if arguments.cipher in ["VIG", "PLF", "EGM", "HIL"]: normalizedKey = "" for char in str(arguments.key).lower(): if 96 < ord(char) < 123: normalizedKey += char assert len(normalizedKey) > 0, "Zero length input key" elif arguments.cipher in ["RFC", "CES"]: normalizedKey = int(arguments.key) else:
#import all ciphers and converters
#they were all made as classes to not confuse the encrypt methods with each other
#import * for classes
from A1Z26 import *
from Caesar import *
from Combined import *
from MorseCode import *
from OneTimePad import *
from Vigenere import *
from Binary import *
from Hex import *
from Octal import *
#create instances of each class
a1 = A1()
caesar = Caesar()
comb = Combined()
morse = Morse()
otp = OneTimePad()
vig = Vigenere()
binary = Binary()
hexa = Hexa()
octal = Octal()
#in order to avoid long if statements, functions/methods added to lists
encFunc = [
vig.encrypt, otp.encrypt, caesar.encrypt, a1.encrypt, morse.encrypt,
comb.encrypt
]
decFunc = [
vig.decrypt, otp.decrypt, caesar.decrypt, a1.decrypt, morse.decrypt,
#!/usr/bin/env python import Caesar import Binary userinput = raw_input() print "user input: " + userinput encr = Caesar.rotate(userinput, 13) decr = Caesar.rotate(encr, 13) print Binary.shortdecode(userinput) print encr print decr
def main():
print("Would you like to encode or decode a message?")
first_choice = input("Encode/Decode: ").lower()
if first_choice == "encode":
print("You have chosen to Encode a message.")
print("Would you like to continue?")
encode_confirm_choice = input("Yes/No: ").lower()
if encode_confirm_choice == "yes":
print("You may choose between the following ciphers:")
print("1. Caesar Cipher (Easiest to decode)")
print(
"2. Stream Cipher (For Messages in Binary, almost impossible to decode without the key)"
)
print(
"3. Block Cipher (Almost impossible to decode without the key."
)
print("Which one would you like to use?")
encode_cipher_choice = int(input("1/2/3: "))
if encode_cipher_choice == 1:
print(
"You have selected to encode a message using the Caesar Cipher."
)
print("Is this correct?")
caesar_cipher_confirm_choice = input("Yes/No: ").lower()
if caesar_cipher_confirm_choice == "yes":
print("Great.")
Caesar.encode_caesar_cipher()
newmessage_ask()
elif caesar_cipher_confirm_choice == "no":
no_confirm()
else:
print("Invalid Input. Starting Over.")
main()
elif encode_confirm_choice == 3:
print(
"You have selected to encode a message with the Block Cipher."
)
print("Is this Correct?")
block_cipher_confirm_choice = input("Yes/No: ").lower()
if block_cipher_confirm_choice == "yes":
print("Great.")
Block.encode_block_cipher()
newmessage_ask()
elif block_cipher_confirm_choice == "no":
no_confirm()
else:
print("Invalid Input. Starting Over.")
main()
elif encode_cipher_choice == 2:
print(
"You have selected to encode a string of binary numbers using the Stream Cipher."
)
print("Would you like to continue?")
stream_cipher_confirm_choice = input("Yes/No: ").lower()
if stream_cipher_confirm_choice == "yes":
print("Great.")
Stream.encode_stream_cipher()
newmessage_ask()
elif stream_cipher_confirm_choice == "no":
no_confirm()
else:
print("Invalid Input. Starting Over.")
main()
elif encode_confirm_choice == "no":
no_confirm()
else:
print("Invalid Input. Starting Over.")
main()
elif first_choice == "decode":
print(
"Right now the only cipher we have support for decoding is the Caesar Cipher."
)
print("Would you like to continue?")
decode_confirm_choice = input("Yes/No: ")
if decode_confirm_choice == "yes":
print("Great.")
print("Enter the message you want to decode below.")
caesar_decode_message = input("Message: ")
DecodeCaesar.decode_caesar_cipher(caesar_decode_message)
newmessage_ask()
elif decode_confirm_choice == "no":
no_confirm()
else:
print("Invalid Input. Starting over.")
else:
print("Invalid Input. Starting Over.")
main()
def encrypt(pwd, msg):
enc_msg = ''
for letter in range(len(msg)):
enc_msg += Caesar.encrypt(
ord(pwd[letter % len(pwd)].lower()) - ord('a') + 1, msg[letter])
return enc_msg
def handle_input(cipher, key, in_file, out_file, mode):
# Standardize the cipher
the_cipher = cipher.lower()
# Try to open files specified
try:
input_file = open(in_file, "r")
output_file = open(out_file, "w")
text = input_file.read()
input_file.close()
except IOError:
# If there was an error opening the file, abort
print("Error opening file")
return
# Execute Caesar cipher
if the_cipher == "caesar":
CIPHER = Caesar.Caesar()
if CIPHER.set_key(key):
if mode == "e":
print("Using Caesar cipher to encrypt: {}".format(in_file))
encrypt = CIPHER.encrypt(text)
output_file.write(encrypt)
elif mode == "d":
print("Using Caesar cipher to decrypt: {}".format(out_file))
decrypt = CIPHER.decrpyt(text)
output_file.write(decrypt)
output_file.close()
else:
print("Key: \"{}\" is not a valid key.\n "
"No encryption will occur.".format(key))
# Execute Playfair cipher
elif the_cipher == "playfair":
CIPHER = Playfair.Playfair()
if CIPHER.set_key(key):
CIPHER.construct_key_matrix(key)
if mode == "e":
print("Using Playfair cipher to encrypt: {}".format(in_file))
encrypt = CIPHER.encrypt(text)
output_file.write(encrypt)
elif mode == "d":
print("Using Playfair cipher to decrypt: {}".format(out_file))
decrypt = CIPHER.decrpyt(text)
output_file.write(decrypt)
output_file.close()
else:
print("Key: \"{}\" is not a valid key.\n "
"No encryption will occur.".format(key))
# Execute Railfence cipher
elif the_cipher == "railfence":
CIPHER = Railfence.Railfence()
if CIPHER.set_key(key):
if mode == "e":
print("Using Railfence cipher to encrypt: {}".format(in_file))
encrypt = CIPHER.encrypt(text)
output_file.write(encrypt)
elif mode == "d":
print("Using Railfence cipher to decrypt: {}".format(out_file))
decrypt = CIPHER.decrpyt(text)
output_file.write(decrypt)
output_file.close()
else:
print("Key: \"{}\" is not a valid key.\n "
"No encryption will occur.".format(key))
# Execute Row Transposition cipher
elif the_cipher == "rowtransposition":
CIPHER = RowTransposition.RowTransposition()
if CIPHER.set_key(key):
if mode == "e":
print("Using Row Transposition cipher to encrypt: {}".format(
in_file))
encrypt = CIPHER.encrypt(text)
output_file.write(encrypt)
elif mode == "d":
print("Using Row Transposition cipher to decrypt: {}".format(
out_file))
decrypt = CIPHER.decrpyt(text)
output_file.write(decrypt)
output_file.close()
else:
print("Key: \"{}\" is not a valid key.\n "
"No encryption will occur.".format(key))
# Execute Vigenre cipher
elif the_cipher == "vigenre":
CIPHER = Vigenre.Vigenre()
if CIPHER.set_key(key):
CIPHER.build_rows()
if mode == "e":
print("Using Vigenre cipher to encrypt: {}".format(in_file))
encrypt = CIPHER.encrypt(text)
output_file.write(encrypt)
elif mode == "d":
print("Using Vigenre cipher to decrypt: {}".format(out_file))
decrypt = CIPHER.decrpyt(text)
output_file.write(decrypt)
output_file.close()
else:
print("Key: \"{}\" is not a valid key.\n "
"No encryption will occur.".format(key))
# User didn't enter a correct cipher
else:
print("Unknown cipher entered...")
import Caesar, Winder, My
print(Caesar.encode("dima", 3))
print(Caesar.decode("glpd", 3))
print('\n--------------\n')
print(Winder.encode('attackatdawn', 'lemon'))
print(Winder.decode('lxfopvefrnhr', 'lemon'))
print('\n--------------\n')
print(My.encode('myencode', 13))
print(My.decode('qdkbxzfk', 13))
print('\n--------------\n')
def caesar_menu():
while True:
print("-------Caesar密码-------")
print("请选择你要进行的操作：")
print("1.Caesar密码简介")
print("2.Caesar密码加密")
print("3.Caesar密码解密")
print("4.Caesar密码列举破解")
print("5.返回上一级")
crypto_operating = input("->")
if crypto_operating == '1':
Caesar.caesar_info()
elif crypto_operating == '2':
print("----------------------Caesar加密----------------------")
print("[Input]请输入您的明文：")
plain_text = input()
print("[Input]请输入您的密钥：(密钥应为数字)")
key = input()
if type(key) != int:
print("[ERROR]非法输入！")
continue
print("[Info]加密正在进行。。。")
try:
enc_text = Caesar.caesar_encrypt(plain_text, key)
print("[Success]加密成功！")
print("[Info]密文为：" + enc_text)
except BaseException as e:
print("[ERROR]加密失败！")
if EXE_MODE == 'DEBUG':
print(e)
pass
elif crypto_operating == '3':
print("----------------------Caesar解密----------------------")
print("[Input]请输入您的密文：")
enc_text = input()
print("[Input]请输入您的密钥：(密钥应为数字)")
key = input()
if type(key) != int:
print("[ERROR]非法输入！")
continue
print("[Info]解密正在进行。。。")
try:
plain_text = Caesar.caesar_decrypt(enc_text, key)
print("[Success]解密成功！")
print("[Info]明文为：" + plain_text)
except BaseException as e:
print("[ERROR]解密失败！")
if EXE_MODE == 'DEBUG':
print(e)
pass
elif crypto_operating == '4':
print("----------------------Caesar列举破解----------------------")
print("[Input]请输入您的密文：")
enc_text = input()
print("[Info]列举破解正在进行。。。")
try:
plain_text_possible = Caesar.caesar_attack(enc_text)
print("[Success]列举破解完成！")
for j in plain_text_possible:
print("[Info]可能的明文为：" + j)
except BaseException as e:
print("[ERROR]列举破解失败！")
if EXE_MODE == 'DEBUG':
print(e)
pass
elif crypto_operating == '5':
return
else:
print("[ERROR]选择出错！")
for key in range(len(LETTERS)):
translated = ''
for symbol in message:
if symbol in LETTERS:
num = LETTERS.find(symbol)
num = num - key
if num < 0:
num = num + len(LETTERS)
translated = translated + LETTERS[num]
else:
translated = translated + symbol
print('Hacking key #%s: %s' % (key, translated))
# Method 2 - Try decrypting 26 ways and see what looks like english text
print("\nMethod 2:")
lst_language = [
'am', 'era', 'my', 'liquor', 'jugs'
] # For a real routine you should provide a list of hundreds of words, frequent in your language.
lst_scores = list() # list of tuples of (score, key)
m2 = "" # message-2, a local clean copy of the message, only including letters and wide-spaces
for char in message:
if char.upper() in LETTERS or char == ' ':
m2 += char
for key in range(len(LETTERS)):
cleartext = Caesar.decrypt(m2, key)
score = sum([w in lst_language for w in cleartext.split(' ')])
if score > 0:
lst_scores.append((score, key))
best_key = sorted(lst_scores, reverse=True)[0][1]
print(f"most likely key: {best_key} -> {Caesar.decrypt(message, best_key)}")
else:
#Playfair Cipher
if str(sys.argv[1]) == 'PLF':
cipher_type = Playfair.Playfair()
#Row_Transposition Cipher
elif str(sys.argv[1]) == 'RTS':
cipher_type = Row_Transposition.Row_Transposition()
#RailFence Cipher
elif str(sys.argv[1]) == 'RFC':
cipher_type = RailFence.Railfence()
#Vigenere Cipher
elif str(sys.argv[1]) == 'VIG':
cipher_type = Vigenere.Vigenere()
#Caesar Cipher
elif str(sys.argv[1]) == 'CES':
cipher_type = Caesar.Caesar()
#Invalid Input
else:
print("Unrecognized cipher type, check your spelling and try again.")
exit()
#Setting key from inputfile
if cipher_type.setKey(sys.argv[2]):
inFile = open(str(sys.argv[4]), "r")
inputText = inFile.read()
if str(sys.argv[3]) == 'ENC':
outputText = cipher_type.encrypt(inputText)
elif str(sys.argv[3] == 'DEC'):
outputText = cipher_type.decrypt(inputText)
#Invalid user input
else:
print("Unrecognized coding type, did you want Encode or Decode?")
enable_events=True,
)
],
[
sg.Text("", size=(8, 1)),
sg.Button("encrypt", size=(10, 1), border_width=2, pad=(15, 15)),
sg.Button("decrypt", size=(10, 1), border_width=2, pad=(15, 15)),
sg.Button("attack", size=(10, 1), border_width=2, pad=(15, 15))
],
[
sg.Text("Ciphertext: ", size=(8, 1)),
sg.Multiline(key="-CIPHERTEXT-")
]]
window = sg.Window(title="Caesar Cipher Tool", layout=layout, margins=(30, 50))
crypto = Caesar.Caesar()
while True:
event, values = window.read()
if event == None or event == 'Exit':
logger.warning("EXIT...")
break
elif event == "encrypt":
plain = values["-PLAINTEXT-"]
cipher = crypto.encrypt(plain)
window["-CIPHERTEXT-"].update(cipher)
logger.info(f"ENCRYPT: {plain.strip()} -> {cipher.strip()}")
elif event == "decrypt":
def caesar(ciphertext, key):
result = Caesar.Caesar_Decrypt(ciphertext, key) if key else ciphertext
return result
import Caesar
print("Ingrese texto a cifrar: ")
text=input()
code=Caesar.encrypt(3, text)
print(code)
print(Caesar.encrypt(-3, code))
def CaesarShow(self):
plaintext = self.Input.get() or ''
Casercipher = Caesar.doCaesar(plaintext)
self.CaesarText.set(Casercipher)
def choose_cipher(cipher_name, key, option, input_file, output_file):
#Playfair
if cipher_name == "PLF":
if option == "ENC":
pass
elif option == "DEC":
pass
else:
print("Invalid option! Options are ENC/DEC")
#Row Transposition
elif cipher_name == "RTS":
rowtransposition = RowTransposition()
rowtransposition.setKey(key)
if option == "ENC":
plain_text = read_file(input_file)
cipher_text = rowtransposition.encrypt(plain_text)
write_file(output_file, cipher_text)
elif option == "DEC":
cipher_text = read_file(input_file)
plain_text = rowtransposition.decrypt(cipher_text)
write_file(output_file, plain_text)
else:
print("Invalid option! Options are ENC/DEC")
#Railfence
elif cipher_name == "RFC":
railfence = Railfence()
railfence.setKey(key)
if option == "ENC":
plain_text = read_file(input_file)
cipher_text = railfence.encrypt(plain_text)
write_file(output_file, cipher_text)
elif option == "DEC":
cipher_text = read_file(input_file)
plain_text = railfence.decrypt(cipher_text)
write_file(output_file, plain_text)
else:
print("Invalid option! Options are ENC/DEC")
#Vigenere
elif cipher_name == "VIG":
vigenere = Vigenere()
vigenere.setKey(key)
if option == "ENC":
plain_text = read_file(input_file)
cipher_text = vigenere.encrypt(plain_text)
write_file(output_file, cipher_text)
elif option == "DEC":
cipher_text = read_file(input_file)
plain_text = vigenere.decrypt(cipher_text)
write_file(output_file, plain_text)
else:
print("Invalid option! Options are ENC/DEC")
#Caesar
elif cipher_name == "CES":
caesar = Caesar()
caesar.setKey(int(key))
if option == "ENC":
plain_text = read_file(input_file)
cipher_text = caesar.encrypt(plain_text)
write_file(output_file, cipher_text)
elif option == "DEC":
cipher_text = read_file(input_file)
plain_text = caesar.decrypt(cipher_text)
write_file(output_file, plain_text)
else:
print("Invalid option! Options are ENC/DEC")
else:
print("Invalid cipher name chosen!")
def __init__(self):
self.book = Book()
self.caesar = Caesar()
self.rsa = RSA()