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'))