def test_encrypt(self):
key = "mykey"
self.assertEqual("mzmhC", vigenere.encrypt("abcde", key))
self.assertEqual("zGmsJmQ", vigenere.encrypt("nicolas", key))
self.assertEqual("z,sgM@", vigenere.encrypt("n,ico@", key))
key = "aNotherkEY"
self.assertEqual("IfGHTiJwSyqhwB",
vigenere.encrypt("IssoMesmoAquii", key))
def test_vigenere():
assert encrypt('aaaa', 'abcd') == 'abcd', encrypt('aaaa', 'abcd')
assert encrypt('abcd', 'bb') == 'bcde', encrypt('abcd', 'bb')
assert encrypt('abcd', 'cd') == 'ceeg', encrypt('abcd', 'cd')
assert encrypt('The crow flies at midnight!',
'boom') == 'Uvs osck rmwse bh auebwsih!', encrypt(
'The crow flies at midnight!', 'boom')
assert encrypt('Please encrypt my sentence.',
'testing') == 'Ipwtar kggjrxg sr wwgbrtvi.', encrypt(
'Please encrypt my sentence.', 'testing')
def process_vigenere(mode, input_text, key, output_type, output_file):
if mode == "encrypt":
print("Plaintext:\n----------------------------")
print (input_text.decode('utf-8'))
ciphertext = vigenere.encrypt(input_text.decode('utf-8'), key.upper())
if output_type == "a":
processed_ciphertext = ciphertext
elif output_type == "b":
processed_ciphertext = re.sub('\W', '', ciphertext)
elif output_type == "c":
ciphertext = re.sub('\W', '', ciphertext).upper()
processed_ciphertext = ' '.join(ciphertext[i:i+5] for i in range(0,len(ciphertext),5))
else:
print ("Invalid output option")
sys.exit(2)
print ("Ciphertext:\n----------------------------")
print (processed_ciphertext)
open(output_file, 'w').write(processed_ciphertext)
elif mode == "decrypt":
print ("Ciphertext:\n----------------------------")
print (input_data.decode('utf-8'))
ciphertext = re.sub('\W', '', input_text).upper()
plaintext = vigenere.decrypt(ciphertext, key.upper())
print ("Plaintext:\n----------------------------")
print (plaintext)
open(output_file, 'w').write(plaintext)
def test_encrypt_decrypt(self):
for _ in range(1000):
random_key = vigenere.random_key(key_size=100)
plain_text = self.random_text(size=1000)
cipher = vigenere.encrypt(plain_text, random_key)
self.assertEqual(vigenere.decrypt(cipher, random_key), plain_text,
"Decrypted cipher not equal to the plain-text")
def test_vigenere_encrypt_word(self):
self.assertEqual(vigenere.encrypt("Hello", "a"), "Hello")
self.assertEqual(vigenere.encrypt("Hello", "b"), "Ifmmp")
self.assertEqual(vigenere.encrypt("Hello", "xxyybbddii"), "Ebjjp")
self.assertEqual(vigenere.encrypt("!", ""), "!") # it will skip rot, and run
self.assertEqual(vigenere.encrypt(" ", ""), " ") # it will skip rot, and run
self.assertEqual(vigenere.encrypt("@", ""), "@") # it will skip rot, and run
self.assertEqual(vigenere.encrypt("!", " "), "!") # it will skip rot, and run
self.assertEqual(vigenere.encrypt("%", "whatever"), "%") # it will skip rot, and run
def test_vigenere_encrypt_sentence(self):
self.assertEqual(vigenere.encrypt("Hello LaunchCode", "a"), "Hello LaunchCode")
self.assertEqual(vigenere.encrypt("Hello", "b"), "Ifmmp")
self.assertEqual(vigenere.encrypt("Hello", "xxyybbddii"), "Ebjjp")
self.assertEqual(vigenere.encrypt("!", ""), "!")
self.assertEqual(vigenere.encrypt(" ", ""), " ")
self.assertEqual(vigenere.encrypt("@", ""), "@")
self.assertEqual(vigenere.encrypt("!", " "), "!") # it will skip key, and should run
self.assertEqual(vigenere.encrypt("%", "whatever"), "%")
def encrypt(cypher, msg, key):
crypt = ''
if cypher == "caesar":
crypt = caesar.encrypt(msg, int(key))
elif cypher == "vigenere":
crypt = vigenere.encrypt(msg, key)
else:
print 'cypher not found'
return 0
return crypt
def prompt_cycle(response):
if response == "e":
message = input("Please enter an alphanumeric message to encrypt: ")
key = input("Please enter a key: ")
print("Your encrypted messages is: " + vigenere.encrypt(message, key))
print("")
else:
message = input("Please enter an alphanumeric message to decrypt: ")
key = input("Please enter a key: ")
print("Your decrypted message is: " + vigenere.decrypt(message, key))
print("")
def main():
"""Plot relative frequency graph for Caesar, Vigenere, Hill & Playfair ciphers"""
#Values
inputfile = sys.argv[1]
caesar_key = 3
vigenere_key = 'Vigenere'
hill_key = hill.npmatrix([[6, 24, 1], [13, 16, 10], [20, 17, 15]])
playfair_key = 'Playfair key'
#Plaintext
plaintext = open(inputfile, 'r').read().upper()
freq_plain = Counter(plaintext)
e_count = freq_plain['E']
freq_plain = sorted([freq_plain[c] for c in letters], reverse=True)
freq_plain = [i / float(e_count) for i in freq_plain]
#Caesar
caesar_text = caesar.encrypt(plaintext, caesar_key)
freq_caesar = Counter(caesar_text)
freq_caesar = sorted([freq_caesar[c] for c in letters], reverse=True)
freq_caesar = [i / float(e_count) for i in freq_caesar]
#Vigenere
vigenere_text = vigenere.encrypt(plaintext, vigenere_key)
freq_vigenere = Counter(vigenere_text)
freq_vigenere = sorted([freq_vigenere[c] for c in letters], reverse=True)
freq_vigenere = [i / float(e_count) for i in freq_vigenere]
#Hill
hill_text = hill.encrypt(plaintext, hill_key)
freq_hill = Counter(hill_text)
freq_hill = sorted([freq_hill[c] for c in letters], reverse=True)
freq_hill = [i / float(e_count) for i in freq_hill]
#Playfair
playfair_text = playfair.encrypt(plaintext, playfair_key)
freq_playfair = Counter(playfair_text)
freq_playfair = sorted([freq_playfair[c] for c in letters], reverse=True)
freq_playfair = [i / float(e_count) for i in freq_playfair]
#Plotting linegraphs
line_chart = pygal.Line(config=CustomConfig2,
style=RedBlueStyle,
y_title='Relative frequency')
line_chart.title = 'Relative frequency for various ciphers'
line_chart.add('Plaintext', freq_plain)
line_chart.add('Caesar', freq_caesar)
line_chart.add('Vigenere', freq_vigenere)
line_chart.add('Hill', freq_hill)
line_chart.add('Playfair', freq_playfair)
line_chart.render_in_browser()
print Counter(plaintext)
def vigenere_encrypt(msg, key, label):
if msg == "" or key == "":
print("one of the following [message/key] is empty")
messagebox.showinfo('Error',
'one of the following [message/key] is empty')
return
else:
for char in key:
if char.isdigit():
print("invalid key - containing digits")
messagebox.showinfo('Error', 'invalid key - containing digits')
return
label.delete(0, END)
label.insert(0, vigenere.encrypt(msg, key))
def main():
"""Plot relative frequency graph for Caesar, Vigenere, Hill & Playfair ciphers"""
#Values
inputfile = sys.argv[1]
caesar_key = 3
vigenere_key = 'Vigenere'
hill_key = hill.npmatrix([[6,24,1],[13,16,10],[20,17,15]])
playfair_key = 'Playfair key'
#Plaintext
plaintext = open(inputfile, 'r').read().upper()
freq_plain = Counter(plaintext)
e_count = freq_plain['E']
freq_plain = sorted([freq_plain[c] for c in letters], reverse=True)
freq_plain = [i/float(e_count) for i in freq_plain]
#Caesar
caesar_text = caesar.encrypt(plaintext, caesar_key)
freq_caesar = Counter(caesar_text)
freq_caesar = sorted([freq_caesar[c] for c in letters], reverse=True)
freq_caesar = [i/float(e_count) for i in freq_caesar]
#Vigenere
vigenere_text = vigenere.encrypt(plaintext, vigenere_key)
freq_vigenere = Counter(vigenere_text)
freq_vigenere = sorted([freq_vigenere[c] for c in letters], reverse=True)
freq_vigenere = [i/float(e_count) for i in freq_vigenere]
#Hill
hill_text = hill.encrypt(plaintext, hill_key)
freq_hill = Counter(hill_text)
freq_hill = sorted([freq_hill[c] for c in letters], reverse=True)
freq_hill = [i/float(e_count) for i in freq_hill]
#Playfair
playfair_text = playfair.encrypt(plaintext, playfair_key)
freq_playfair = Counter(playfair_text)
freq_playfair = sorted([freq_playfair[c] for c in letters], reverse=True)
freq_playfair = [i/float(e_count) for i in freq_playfair]
#Plotting linegraphs
line_chart = pygal.Line(config=CustomConfig2, style=RedBlueStyle, y_title='Relative frequency')
line_chart.title = 'Relative frequency for various ciphers'
line_chart.add('Plaintext', freq_plain)
line_chart.add('Caesar', freq_caesar)
line_chart.add('Vigenere', freq_vigenere)
line_chart.add('Hill', freq_hill)
line_chart.add('Playfair', freq_playfair)
line_chart.render_in_browser()
print Counter(plaintext)
def insert_message(audio_file,
message_file,
stego_file,
encrypted=False,
randomized=False,
key=None):
message = read_message_bytes(message_file)
extension = get_message_extension(message_file)
if encrypted:
message = bytearray(encrypt(str(message), key))
# get extraction flag and length for extension and message
flag = decide_flag(encrypted, randomized)
extension_length = len(extension)
message_length = len(message)
# convert to array of bits
flag_bits = int_to_bits(flag) # 8 bits
extension_length_bits = int_to_bits(extension_length) # 8 bits
extension_bits = bytes_to_bits(extension)
message_length_bits = int_to_bits(message_length)
message_length_flag = int_to_bits(int(len(message_length_bits) /
8)) # 8 bits
message_bits = bytes_to_bits(message)
# assemble arrays of bits to payload
header = flag_bits + extension_length_bits + \
extension_bits + message_length_flag + message_length_bits
payload = header + message_bits
if (len(payload) < get_audio_capacity(audio_file)):
audio_bytes = read_audio_bytes(audio_file)
audio_params = get_audio_params(audio_file)
if randomized:
random.seed(create_seed(key))
initial_index = len(header)
indexes = range(0, len(header)) + random.sample(
range(initial_index, len(audio_bytes)), len(message_bits))
else:
indexes = range(0, len(payload))
audio_bytes = put_message(audio_bytes, payload, indexes)
write_audio_bytes(stego_file, audio_bytes, audio_params)
return audio_bytes
else:
print('Not enough capacity')
return False
def accept_quest_register_webhook():
from vigenere import encrypt
uid = request.form['uid']
token = request.form['token']
with open('settings/key.txt', encoding='utf8') as file:
key = file.read()
tokenkey = encrypt(token, key)[::-1]
try:
client.connect(uid, token).send('post', 'api/v3/user/webhook', queued=False, data={
'url': f"http://eratech.ch/habitica/acceptquest/{tokenkey}",
'label': 'automatic quest acceptance - just delete this entry if you want to stop',
'type': 'questActivity',
'options': {
'questInvited': True
}
})
return 'webhook added'
except Exceptions.NotAuthorized as ex:
return str(ex)
def Vigenere():
msg = ''
output = ''
set1 = 'opt1'
set2 = 'opt4'
key = 'key'
if request.method == 'POST':
task = request.form.get('task')
msg = request.form.get('original-text')
set1 = request.form.get('set1')
set2 = request.form.get('set2')
key = request.form.get('key')
key = ''.join([i for i in key if i.isupper() or i.islower()])
if task == 'encrypt':
output = vigenere.encrypt(msg,key)
if set1 == 'opt1':
pass
elif set1 == 'opt2':
output = removeAllSpecialCharactersExcludingSpaces(output)
elif set1 == 'opt3':
output = removeAllSpecialCharactersIncludingSpaces(output)
elif task == 'decrypt':
output = vigenere.decrypt(msg,key)
if set1 == 'opt1':
pass
elif set1 == 'opt2' :
output = removeAllSpecialCharactersExcludingSpaces(output)
elif set1 == 'opt3':
output = removeAllSpecialCharactersIncludingSpaces(output)
if set2 == 'opt4':
pass
elif set2 == 'opt5':
output = output.upper()
elif set2 == 'opt6':
output = output.lower()
return render_template('vigenere.html', title='Vigenère Cipher', msg=msg, output=output, set1=set1, set2=set2, key=key)
# helper method to increment the key
def _increment_brute_force_key(key, key_length, position):
# increment current position
key[position] += 1
# if that position is now out of the range of letters
# set it back to 0 and increment the next cell over
if key[position] > 25:
key[position] = 0
_increment_brute_force_key(key, key_length, position - 1)
# quick validation method
if __name__ == "__main__":
secret_message = string_tools.string_to_num_list(
"WEAREDISCOVEREDSAVEYOURSELF", 'A')
secret_key = string_tools.string_to_num_list("ZZZZZ", 'A')
cipher_text = encrypt(secret_message, secret_key)
brute_thread = (brute_force(cipher_text, 5, secret_message))
start_time = time()
brute_thread.start()
brute_thread.join()
end_time = time() - start_time
print(end_time)
def test_vigenere_encrypt_char(self):
# self.assertEqual(vigenere.encrypt("a", ""), "") ERROR
# self.assertEqual(vigenere.encrypt("a", " "), "") ERROR
self.assertEqual(vigenere.encrypt("a", "a"), "a")
self.assertEqual(vigenere.encrypt("a", "aababa"), "a")
def load_message(self):
# (1) get stego info (frame, pixel, encrypt, LSB size)
# stego mode info (4 bits) : [frame, pixel, encrypt, LSB size]
# frame => 0 : sequential, 1 : shuffle
# pixel => 0 : sequential, 1 : shuffle
# encrypt => 0 : not encrypted, 1 : encrypted
# LSB size => 0 : 1 bit, 1 : 2 bits
# (2) get format (how many bytes needed to store + length of message in binary) and length of message (how many bytes needed to store + length of message in binary)
# format : (1 + m) bytes, length of message : (1 + n) bytes
# (3) get string of bit from message file content and save to self.message
# (4) append (1) and (2) and save to self.additional_message
# open file
with open(self.message_path, mode='rb') as file:
file_content = file.read()
# encrypt message
if self.is_message_encrypted:
file_content = vigenere.encrypt(file_content, self.key)
# read as 8 bits per character
content = ''
for c in file_content:
content += format(ord(c), '08b')
# get length of message & byte size
message_len = len(file_content)
message_len_bytes_needed = int(log(message_len, 256)) + 1
message_len_as_bit = ("{0:0" + str(message_len_bytes_needed * 8) +
"b}").format(message_len)
# get format message file
format_file = self.message_path.split('.')[-1]
format_file_bytes_needed = len(format_file)
format_file_as_bit = ''
for c in format_file:
format_file_as_bit += format(ord(c), '08b')
# get stego info
stego_info = ''
if self.frame_store_mode == SHUFFLE:
stego_info += '1'
else:
stego_info += '0'
if self.pixel_store_mode == SHUFFLE:
stego_info += '1'
else:
stego_info += '0'
if self.is_message_encrypted:
stego_info += '1'
else:
stego_info += '0'
if self.lsb_bit_size == 2:
stego_info += '1'
else:
stego_info += '0'
# self.message contains bits (0 or 1) string of message content
self.message = content
# self.additional_message contains bits (0 or 1) string of stego info, format & message length representation
self.additional_message = stego_info + format(
format_file_bytes_needed, '08b') + format(
message_len_bytes_needed,
'08b') + format_file_as_bit + message_len_as_bit
input_file = argv[1]
input_file = open(input_file, "r")
secret_message = input_file.read(400)
secret_message_sanitized = sanitization.sanitize(secret_message,
legal_characters, "")
secret_key = argv[2]
secret_key_sanitized = sanitization.sanitize(secret_key, legal_characters,
"")
secret_message_sanitized = string_tools.string_to_num_list(
secret_message_sanitized, 'A')
secret_key_sanitized = string_tools.string_to_num_list(
secret_key_sanitized, 'A')
cipher_text = encrypt(secret_message_sanitized, secret_key_sanitized)
# determine fitness of correct solution
# letter_counter = {}
# bigram_counter = {}
# letter_counter[secret_message_sanitized[0]] = 1
# for i in range(1, len(secret_message_sanitized)):
# letter_count = letter_counter.get(secret_message_sanitized[i])
# if letter_count == None:
# letter_counter[secret_message_sanitized[i]] = 1
# else:
# letter_counter[secret_message_sanitized[i]] = letter_count + 1
# bigram_count = bigram_counter.get(
from vigenere import generate_key
from vigenere import encrypt
from vigenere import decrypt
if __name__ == '__main__':
t = 'ATTACK SILICON VALLEY'
k = generate_key(t, 'HELLO')
e = encrypt(t, k)
print(e)
d = decrypt(e, k)
print(d)
def test_encryption_none():
key = ''
plaintext = 'example'
expected = None
assert encrypt(plaintext, key) == expected
def chi_squared_test(plaintext: str) -> float:
"""
TODO:
- Counts the total number of letters in the plaintext
- Keeps a counter on how many times each letter is occuring and uses it along with the total count, and the actual frequencies to calculate
the chi value from the given equation in the question
"""
# TODO: Replace this with your implementation
counter = 0
for i in plaintext:
counter += 1
chi = 0
for keyss in ACTUAL_FREQUENCY:
char_counter = 0
for i in plaintext:
if(i == keyss):
char_counter += 1
chi += (((char_counter/counter) - ACTUAL_FREQUENCY.get(keyss)) ** 2) / ACTUAL_FREQUENCY.get(keyss)
return chi
if __name__ == "__main__":
from test import KEYS, TESTS
for plaintext in TESTS:
for key in KEYS:
ciphertext = vigenere.encrypt(plaintext, key)
assert key == freq_analysis(ciphertext, len(key))
print(freq_analysis(ciphertext, len(key)))
def test_encryption_1():
key = 'snake'
plaintext = 'meet me at elephant lake '
expected = 'FSFERXOUPQXDILSMZBVJ'
assert encrypt(plaintext, key) == expected
#! /usr/bin/env python3
import socket
from vigenere import encrypt
s = socket.socket()
host = socket.gethostname()
port = 8080
s.bind((host, port))
s.listen(1)
print(host)
print("En attente de connection ... ")
conn, addr = s.accept()
print(addr, "est connecte au serveur")
with open('message.txt', 'r') as file:
message = file.read()
encrypted_message = encrypt(message, 'key')
with open('message_encrypte.txt', 'w') as file:
file.write(encrypted_message)
file = open('message_encrypte.txt', 'rb')
file_data = file.read(1024)
conn.send(file_data)
print("Le fichier a ete envoye avec success!")
from vigenere import letter_to_index, index_to_letter, vigenere_decrypt, vigenere_encrypt, encrypt, decrypt
print(encrypt("This is cool!!", "baconbaconbacon"))
secret_key = argv[2]
secret_key_sanitized = sanitization.sanitize(
secret_key, legal_characters, "")
if not (secret_message == secret_message_sanitized) or not (secret_key == secret_key_sanitized):
print("Alert: \tYour message and/or key have been modified\n"
+ "\tAll lowercase values have been converted to UPPERCASE\n"
+ "\tand all non alphabetic characters have been removed including spaces and newlines\n")
secret_message_sanitized = string_tools.string_to_num_list(
secret_message_sanitized, 'A')
secret_key_sanitized = string_tools.string_to_num_list(
secret_key_sanitized, 'A')
cipher_text = vigenere.encrypt(
secret_message_sanitized, secret_key_sanitized)
keylengths = ci_keylength(cipher_text, 1, 9)
# print("\nStarting PSO and Brute force threads on key length(s): " + str(keylengths))
# print("and cipher text\n" + str(cipher_text) + "\n")
pso_thread = []
brute_thread = []
for i, keylength in enumerate(keylengths):
pso_thread.append(pso(cipher_text, len(secret_key_sanitized),
200, 200, 26, 1, 10, 1, 2.05, 2.05, queue.Queue()))
brute_thread.append(brute_force(
cipher_text, keylength, secret_message_sanitized))
def main():
answer = input(
'Would you like to perform a cipher operation? Enter y/n.\n')
while answer.lower() == 'y':
print('1.) Caesar Cipher')
print('2.) Transposition Cipher')
print('3.) Classic Vigenere Cipher')
print('4.) Modified Vigenere Cipher')
print('5.) View Modified Vigenere Keys')
print('0.) Exit')
cipherChoice = input('Enter an option 0-5.\n')
while not ((cipherChoice).isdigit() and int(cipherChoice) >= 0
and int(cipherChoice) <= 5):
cipherChoice = str(
input('\nInvalid entry. Enter an integer from 0-5.\n'))
print('Your choice was', cipherChoice)
cipherChoice = int(cipherChoice)
if cipherChoice != 0 and cipherChoice != 5:
mode = input('Would you like to encrypt or decrypt? Enter e/d.\n')
while not (mode.lower() == 'e' or mode.lower() == 'd'):
mode = input(
'Invalid entry. Enter e to encrypt or d to decrypt.\n')
if cipherChoice == 1:
print('Caesar Cipher:')
n = input('Enter the shift value n:\n')
while not n.isdigit():
n = input('Enter a valid integer.\n')
n = int(n)
if mode == 'd':
ciphertext = input('Enter the ciphertext.\n')
plaintext = (caesar.decrypt(n, ciphertext))
print('Ciphertext:\n', ciphertext)
print('Plaintext:\n', plaintext)
elif mode == 'e':
plaintext = input('Enter the plaintext.\n')
ciphertext = (caesar.encrypt(n, plaintext))
print('Plaintext:\n', plaintext)
print('Ciphertext:\n', ciphertext)
elif cipherChoice == 2:
print('Transposition Cipher:')
key = input('Enter an integer key\n')
while not key.isdigit():
key = input('Key must be an integer.\n')
key = int(key)
if mode == 'd':
ciphertext = input('Enter the ciphertext.\n')
plaintext = trans.decrypt(key, ciphertext)
print('Ciphertext:\n', ciphertext)
print('Plaintext:\n', plaintext)
elif mode == 'e':
plaintext = input('Enter the plaintext.\n')
ciphertext = trans.encrypt(key, plaintext)
print('Plaintext:\n', plaintext)
print('Ciphertext:\n', ciphertext)
elif cipherChoice == 3:
print('Classic Vigenere Cipher:')
key = input('Enter a key:\n')
if mode == 'd':
ciphertext = input('Enter the ciphertext.\n')
plaintext = vig.decrypt(ciphertext, key)
print('Ciphertext:\n', ciphertext)
print('Plaintext:\n', plaintext)
elif mode == 'e':
plaintext = input('Enter the plaintext.\n')
ciphertext = vig.encrypt(plaintext, key)
print('Plaintext:\n', plaintext)
print('Ciphertext:\n', ciphertext)
elif cipherChoice == 4:
print('Modified Vigenere Cipher:')
seed = input('Enter a positive seed value:\n')
while not seed.isdigit():
seed = input('Error, seed value must be a positive integer.\n')
while int(seed) <= 0:
print(
'Error, seed value must be positive. Exiting to main menu.'
)
break
seed = int(seed)
key = input('Enter a key:\n')
if mode == 'd':
ciphertext = input('Enter the ciphertext.\n')
plaintext = mvig.decrypt(ciphertext, key, seed)
print('Ciphertext:\n', ciphertext)
print('Plaintext:\n', plaintext)
elif mode == 'e':
plaintext = input('Enter the plaintext.\n')
ciphertext = mvig.encrypt(plaintext, key, seed)
print('Plaintext:\n', plaintext)
print('Ciphertext:\n', ciphertext)
elif cipherChoice == 5:
print('Modified Vigenere Keys:')
seed = input('Enter a positive seed value:\n')
while not seed.isdigit():
seed = input('Error, seed value must be a positive integer.\n')
while int(seed) <= 0:
print(
'Error, seed value must be positive. Exiting to main menu.'
)
break
seed = int(seed)
key = input('Enter a key:\n')
message = input('Enter a message:\n')
print('Entered key:', key)
key = mvig.getNewKey(seed, key, len(message))
print('Used key:', key)
elif cipherChoice == 0:
print('Exiting now.')
exit()
def encrypt(key, plaintext): if len(key) < len(plaintext): return "The key needs to be longer, son." else: return vigenere.encrypt(key, plaintext)
def encrypt_txt():
key = request.form['key']
text = request.form['text']
template = jinja_env.get_template('form2.html')
encipher = encrypt(text, key)
return template.render(enciphered=encipher)
def test_encryption_2():
key = 'abc'
plaintext = 'cbacbacba'
expected = 'DDDDDDDDD'
assert encrypt(plaintext, key) == expected
import change
import sezar
import vigenere
print("######################")
print("------Cyrpter1.0------")
print("######################")
def test(number, cipher, key):
i = 0
print("Decrypting the code process is getting started...")
solve = vigenere.decrypt(key, sezar.decrypt(cipher))
while i <= len(number):
if i == len(number):
print("Mission complated")
break
elif i < len(number) and number[i] == solve[i]:
i += 1
else:
print("Mission failed")
break
text = input("Enter the text:")
number = change.mNumber(text)
key = input("Enter the key:")
nKey = change.mNumber(key)
cipher = sezar.encrypt(vigenere.encrypt(nKey, number))
test(number, cipher, nKey)
caesar.probabilisticCrack(C)
print("\n")
print("=================================")
print("=========VIGENERE CYPER==========")
print("=================================")
print()
M = "the entire message for the vigenere cypher"
K = 'vige'
print("Key:", K)
print("Message:", M)
print("Length:", len(M), "\n")
C = vigenere.encrypt(M, K, True)
print("Encrypted:", C)
m = vigenere.decrypt(C, K, True)
print("Decrypted:", m, end=" ")
if M == m:
print("[success]\n")
else:
print("[fail]\n")
exit()
# note this version of cracking does not allow for non alpha characters
print("Cracking '", C, "' by finding repeated blocks of text...\n", sep="")
vigenere.crack(C)
def encrypt(s: str, k: int) -> str:
_check_key(k)
return vigenere.encrypt(s, chr(k + vigenere.ORD_BASE_SMALL_A))
import caesar
import vigenere
print('1.1. ', caesar.encrypt('PREMIER EXEMPLE', 'Y'))
print('1.2. ', caesar.decrypt('MZMV CV DFULCV UV TIPGKF', 'R'))
print('1.3. ', caesar.decrypt('KNS IZ UWJRNJW JCT'))
print('2.1. ', vigenere.encrypt('CAMARCHE', 'ROI'))
print(
'2.2. ',
vigenere.decrypt(
'XATBGYQBJTQVMUUEEZDDWEYEQELIPVGRWTWVROFMVVXEKRILJSGGTVFILYEFZDWEMTUEMQEUUSHTVLPAFLPRZUAMFIGNW',
'MASTER'))
