def enc_dec_btn_clicked_event(self):
if (self.cipher_slcbox.currentText() == "Vigenere"):
vig = Vigenere()
plaintext = self.get_text_from_textarea(self.text_input_txtarea)
key = self.get_text_from_textbox(self.key_txtbox)
result = ""
if (self.flag == "enc"):
result = vig.safe_cipher(vig.decode26, key, plaintext)[1]
else:
result = vig.safe_cipher(vig.encode26, key, plaintext)[1]
self.text_result_txtarea.setPlainText(str(result))
elif (self.cipher_slcbox.currentText() == "Ceaser"):
ces = Ceaser()
plaintext = self.get_text_from_textarea(self.text_input_txtarea)
key = self.get_text_from_textbox(self.key_txtbox)
if (self.flag == "enc"):
result = ces.encode(plaintext, int(key))
else:
result = ces.decode(plaintext, int(key))
self.text_result_txtarea.setPlainText(result)
elif (self.cipher_slcbox.currentText() == "MD5"):
self.text_result_txtarea.setPlainText(
"Working on it,We'll entegrate it\n")
elif (self.cipher_slcbox.currentText() == "SHA1"):
self.text_result_txtarea.setPlainText(
"Working on it,We'll entegrate it\n")
def convert():
"""Handle requests for /compare via POST"""
if request.method == "GET":
return render_template("index.html")
key = request.form.get("key")
if not request.files["file"]:
abort(400, "Missing file")
if not request.form.get("key"):
abort(400, "Missing key")
if not key.isalpha():
abort(400, "Invalid key")
try:
file = request.files["file"].read().decode("utf-8")
except Exception:
abort(400, "invalid file")
if not request.form.get("algorithm"):
abort(400, "missing algorithm type")
elif request.form.get("algorithm") == "encrypt":
conversion = Vigenere().cipher_vigenere(file, key)
elif request.form.get("algorithm") == "decrypt":
conversion = Vigenere().decrypt_vigenere(file, key)
# Read files
return render_template("convert.html", convert=conversion)
def test_viginere_encrypt():
plaintext = ciphertexts['plaintext']
desired_ciphertext = ciphertexts['Viginere']
cipher = Vigenere('classicalcipher')
encrypted_text = cipher.encrypt(plaintext)
print(encrypted_text)
assert encrypted_text == desired_ciphertext
def __init__(self, plugboard={" ": " "}, rotors=None, rotor_settings=None):
self.base_alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
if type(plugboard) is not dict:
self.plugboard = {" ": " "}
else:
self.plugboard = plugboard
self.reflector = 'EJMZALYXVBWFCRQUONTSPIKHGD'
if rotors is None or type(rotors) is not list:
self.rotors = [
list(rotor) for rotor in Rotors.CommericialEnigmaRotors
]
else:
self.rotors = rotors
if rotor_settings is None or type(rotor_settings) is not list:
self.rotor_settings = [0 for i in range(3)]
self.vigenere = ['A', 'A', 'A', 'A', 'A', 'A']
self.matrix_crypt = np.array([[1, 2, 0], [-1, 1, 3], [1, -1, -4]])
else:
self.rotor_settings = rotor_settings[9:12]
self.vigenere = rotor_settings[3:6] + rotor_settings[15:18]
self.matrix_crypt = [
[self.base_alphabet.index(i) for i in rotor_settings[0:3]],
[self.base_alphabet.index(i) for i in rotor_settings[6:9]],
[self.base_alphabet.index(i) for i in rotor_settings[12:15]]
]
if bool(self.rotor_settings) and all(
isinstance(elem, str) for elem in self.rotor_settings):
temp = []
for index in range(len(self.rotor_settings)):
temp.append(self.rotors[index].index(
self.rotor_settings[index]))
self.rotor_settings = temp
else:
raise ValueError("Rotor settings should be letters.")
if len(self.rotors) != len(self.rotor_settings[0:3]):
raise ValueError(
"Number of rotor settings should be equal to the number of rotors."
)
self.rotor_pointers = self.rotor_settings
self.vig = Vigenere(
[self.base_alphabet.index(i) for i in self.vigenere])
def code(args: argparse.Namespace) -> None:
if not hasattr(args, 'code'):
print("Enter something to do: encode, decode, train, hack")
sys.exit()
if args.code in ('encode', 'decode'):
text = fileread(args.input_file)
cipher = Cipher()
if args.cipher == 'caesar':
try:
key_int = int(args.key)
except ValueError:
print("Key for caesar should be integer")
sys.exit()
cipher = Caesar()
cipher.key = key_int
elif args.cipher == 'vigenere':
cipher = Vigenere()
cipher.key = args.key
elif args.cipher == 'vernam':
cipher = Vernam()
cipher.key = args.key
else:
print("No such cipher type")
sys.exit()
if args.code == 'encode':
textprint(args.output_file, cipher.encode(text))
else:
textprint(args.output_file, cipher.decode(text))
elif args.code == 'train':
FreqAnalysis(args.model_file).train(fileread(args.text_file))
elif args.code == 'hack':
text = fileread(args.input_file)
textprint(args.output_file, FreqAnalysis(args.model_file).hack(text))
def key(self, text, enc):
output = ""
with open(text, "r+b") as f:
with open(enc, "r+b") as f1:
while 1:
read_data = f.read(1)
read_enc = f1.read(1)
if not read_data:
break
output += chr((ord(read_enc) - ord(read_data) + 256) % 256)
r = re.compile(r"(.+?)\1+")
print r.findall(output)
vigenere = Vigenere()
test = vigenere.decipher(enc, r.findall(output)[0])
def breakOpenDic(self,enc): key = "" words = 0 word_list = [] for a in brown.words(fileids=['cc17','ca16']): word_list.append(str(a)) for a in word_list: vigenere = Vigenere() file = vigenere.decipher(enc,a) n = self.compare(file) if n > words: key = a words = n print key
def breakOpen(self,enc): lower_a = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'] upper_a = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z'] num = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9'] all = [] all = lower_a + upper_a + num words = 0 key = "" for r in range(1, 5): for s in itertools.product(all, repeat = r): vigenere = Vigenere() file = vigenere.decipher(enc,''.join(s)) n = self.compare(file) if n > words: key = ''.join(s) words = n print key
def load_system(self, algorithm_name):
"""
Load the proper class containing requested algorithms.
"""
from vigenere import Vigenere
from permutation import Permutation
if algorithm_name == "vigenere":
algorithm = Vigenere()
elif algorithm_name == "permutation":
algorithm = Permutation()
else:
raise RuntimeError("Chosen algorithm does not exist.")
return algorithm
def main():
if len(sys.argv) < 2:
menu.algoritmos()
exit()
if sys.argv[1] == "-cc":
if valido.cesar(sys.argv) == False:
menu.cesar()
else:
if sys.argv[2] == "-c" or sys.argv[2] == "-d":
ti = time()
Cesar(sys.argv)
tf = time()
te = tf - ti
print("El tiempo de ejecucion fue: ", te)
menu.mensaje()
if sys.argv[1] == "-vg":
if valido.vigenere(sys.argv) == False:
menu.vigenere()
else:
if sys.argv[2] == "-c" or sys.argv[2] == "-d":
ti = time()
Vigenere(sys.argv)
tf = time()
te = tf - ti
print("El tiempo de ejecucion fue: ", te)
menu.mensaje()
if sys.argv[1] == "-ad":
if valido.adfgvx(sys.argv) == False:
menu.adfgvx()
else:
if sys.argv[2] == "-c" or sys.argv[2] == "-d":
ti = time()
Adfgvx(sys.argv)
tf = time()
te = tf - ti
print("El tiempo de ejecucion fue: ", te)
menu.mensaje()
def symmetric_cipher(self):
"""Selects a symmetric-key chiper.
:return: an object of one of the symmetric-key encryption classes or None
"""
_cipher = None
if self.algorithm == AlgEnum.CAESAR.name:
_cipher = Caesar()
if self.algorithm == AlgEnum.VIGENERE.name:
_cipher = Vigenere()
if self.algorithm == AlgEnum.AES.name:
_cipher = AES()
if self.algorithm == AlgEnum.DES.name:
_cipher = DES()
if self.algorithm == AlgEnum.MAGMA.name:
_cipher = Magma()
if self.algorithm == AlgEnum.KUZNECHIK.name:
_cipher = Kuznechik()
if self.algorithm == AlgEnum.RSA.name:
_cipher = Kuznechik()
return _cipher
# Solution for 2nd Deloitte programming challenge thing.
# This script must be run from the same directory containing vigenere.py.
# This script ignores numbers in the ciphertext and treats all letters as lowercase when decoding.
# The hint tells us to use the previous challenge's solution, which is 141, to find a keyword also from the previous challenge.
# When doing this, it seems we have to include a lone hyphen as a word.
# Excluding the hyphen, "what" is the 141st word.
# Including the hyphen, "tactic" is the 141st word (and turns out to be the word we want).
# Also, the last letter of the ciphertext was incorrectly capitalised; the solution requires it to be lowercase. However, I've left it as it was here since it doesn't affect the code's output.
from vigenere import Vigenere
page_text = r"In Forensic Technology complex problem solving is a large part of our day-to-day work. Paying homage to our fondness of brain-teasers, we're launching a monthly Forensic Technology Challenge - a new series of logical, analytical and coding problems that put into practice the STEM, finance and technology skills essential to our work. Every month we'll post a new challenge created by the Forensic Technology team, focusing on one of these skills. You can solve these problems in any way that you want. We're looking forward to seeing the different ways that you approach them! Without further ado, here is the first challenge straight from the Forensic Technology hive-mind: Of the first 2016 prime numbers, which ones have digits that sum to 13? Our solution involved creating a Python script to do all of the heavy-lifting, but this is only one tactic. What was your method? We'll be posting how we solved this next month, along with Challenge #2. Don't forget to look out for our bonus question next week! If you are someone who enjoys problem-solving, logical thinking and technology, check out our Forensic Technology graduate professional roles to see if they are the right fit. What's the answer? Here's what you've been waiting for, the solutions to the first #4TechChallenge posted last month as well as the answer to the bonus question. So without further ado here is the Python script we used to generate the list of primes and subsequently find how many had their digits sum to a specified total."
previous_solution = 141
page_text = page_text.split()
#page_text.remove('-') # I originally removed the lone hyphen
keyword = page_text[previous_solution-1].lower()
print "Keyword =", keyword
ciphertext = 'rowmcdxN5xCAPQPGpI'
cipher = Vigenere()
plaintext = cipher.decode(ciphertext,keyword)
print "Decoded text (lowercase and excluding numbers):", plaintext
class Enigma:
"""
A modified Enigma machine incorporating different cryptography algorithms.
"""
def __init__(self, plugboard={" ": " "}, rotors=None, rotor_settings=None):
self.base_alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
if type(plugboard) is not dict:
self.plugboard = {" ": " "}
else:
self.plugboard = plugboard
self.reflector = 'EJMZALYXVBWFCRQUONTSPIKHGD'
if rotors is None or type(rotors) is not list:
self.rotors = [
list(rotor) for rotor in Rotors.CommericialEnigmaRotors
]
else:
self.rotors = rotors
if rotor_settings is None or type(rotor_settings) is not list:
self.rotor_settings = [0 for i in range(3)]
self.vigenere = ['A', 'A', 'A', 'A', 'A', 'A']
self.matrix_crypt = np.array([[1, 2, 0], [-1, 1, 3], [1, -1, -4]])
else:
self.rotor_settings = rotor_settings[9:12]
self.vigenere = rotor_settings[3:6] + rotor_settings[15:18]
self.matrix_crypt = [
[self.base_alphabet.index(i) for i in rotor_settings[0:3]],
[self.base_alphabet.index(i) for i in rotor_settings[6:9]],
[self.base_alphabet.index(i) for i in rotor_settings[12:15]]
]
if bool(self.rotor_settings) and all(
isinstance(elem, str) for elem in self.rotor_settings):
temp = []
for index in range(len(self.rotor_settings)):
temp.append(self.rotors[index].index(
self.rotor_settings[index]))
self.rotor_settings = temp
else:
raise ValueError("Rotor settings should be letters.")
if len(self.rotors) != len(self.rotor_settings[0:3]):
raise ValueError(
"Number of rotor settings should be equal to the number of rotors."
)
self.rotor_pointers = self.rotor_settings
self.vig = Vigenere(
[self.base_alphabet.index(i) for i in self.vigenere])
@property
def settings(self):
"""
Returns the settings of the rotors.
"""
ret = []
for index in range(len(self.rotor_settings)):
ret.append(self.rotors[index][self.rotor_settings[index]])
return ret
@property
def rotor_pointer_settings(self):
ret = []
for index in range(len(self.rotor_settings)):
ret.append(self.rotors[index][self.rotor_pointers[index]])
return ret
def set_plugboard_wiring(self, wirings):
"""
Returns the plugboard wirings.
"""
if type(wirings) is not dict:
self.plugboard = {" ": " "}
else:
self.plugboard = wirings
def set_rotor_settings(self, new_settings):
"""
Sets the settings for all algorithms.
"""
if new_settings is None or type(new_settings) is not list:
self.rotor_settings = [0 for i in range(len(self.rotors))]
else:
self.rotor_settings = new_settings[9:12]
try:
if bool(self.rotor_settings) and all(
isinstance(elem, str) for elem in self.rotor_settings):
temp = []
for index in range(len(self.rotor_settings)):
temp.append(self.rotors[index].index(
self.rotor_settings[index]))
self.rotor_settings = temp
else:
raise ValueError("Rotor settings should be letters.")
except ValueError:
print("Wrong key format, try again.")
return
self.rotor_pointers = self.rotor_settings
self.vigenere = new_settings[3:6] + new_settings[15:18]
self.matrix_crypt = [
[self.base_alphabet.index(i) for i in new_settings[0:3]],
[self.base_alphabet.index(i) for i in new_settings[6:9]],
[self.base_alphabet.index(i) for i in new_settings[12:15]]
]
def inbound_rotor_map(self, rotor_setting):
"""
Shifts the inbound rotors based on the settings of the rotors.
"""
shift = list(self.base_alphabet)
for _ in range(rotor_setting):
shift.insert(0, shift[-1])
shift.pop(-1)
return shift
def outbound_rotor_map(self, rotor_setting):
"""
Shifts the outbound rotors back to place based on the settings of the rotors.
"""
shift = list(self.base_alphabet)
for _ in range(rotor_setting):
shift.append(shift[0])
shift.pop(0)
return shift
def inbound_rotor(self, letter):
"""
Inbound input rotor function from right to left.
Note: di pa dynamic.
Base case: 3 rotors
"""
# First Rotor Logic
temp = self.inbound_rotor_map(
self.rotor_pointers[0])[self.base_alphabet.index(letter)]
# Second Rotor Logic
temp = self.inbound_rotor_map(
self.rotor_pointers[1])[self.base_alphabet.index(temp)]
#Third Rotor Logic
temp = self.inbound_rotor_map(
self.rotor_pointers[2])[self.base_alphabet.index(temp)]
return temp
def outbound_rotor(self, letter):
"""
Outbound input rotor function from left to right.
"""
# Third Rotor
temp = self.outbound_rotor_map(
self.rotor_pointers[2])[self.base_alphabet.index(letter)]
# Second Rotor
temp = self.outbound_rotor_map(
self.rotor_pointers[1])[self.base_alphabet.index(temp)]
# First Rotor
temp = self.outbound_rotor_map(
self.rotor_pointers[0])[self.base_alphabet.index(temp)]
return temp
def turn_rotors(self):
"""
Turns the rotors every input.
"""
#Turn rotor 1
self.rotor_pointers[0] += 1
# Turn rotor 2 if rotor 1 got a full revolution
if self.rotor_pointers[0] % 26 == 0:
self.rotor_pointers[1] += 1
self.rotor_pointers[0] = 0
# Turn rotor 3 if rotor 2 got full revolution and rotor 1 does not revolve fully
if self.rotor_pointers[1] % 26 == 0 and self.rotor_pointers[
0] % 26 != 0 and self.rotor_pointers[1] >= 25:
self.rotor_pointers[2] += 1
self.rotor_pointers[1] = 1
def plugboard_operation(self, letter):
"""
Plugboard that swaps two letters.
"""
if letter in self.plugboard:
return self.plugboard[letter]
else:
return letter
def reflector_operation(self, letter):
"""
Reflects the letters to its own mapping.
"""
return self.reflector[self.base_alphabet.index(letter)]
def encrypt_text(self, text: str):
"""
Encrypts a plaintext.
"""
text = text.upper().replace(" ", "")
encrypted_text = ""
for letter in text:
temp = self.plugboard_operation(letter)
temp = self.inbound_rotor(letter)
temp = self.reflector_operation(temp)
temp = self.outbound_rotor(temp)
self.turn_rotors()
temp = self.plugboard_operation(temp)
encrypted_text += temp
encrypted_text = self.vig.encrypt(encrypted_text)
processed = Crypto.convert(encrypted_text)
encrypted_text = Crypto.encode(processed, Matrix(self.matrix_crypt))
to_text = ""
for code_group in encrypted_text:
for code in code_group:
to_text += f"{code} "
return to_text
def decrypt_text(self, text):
"""
Decrypts a plaintext.
"""
text = [int(x) for x in text.split(' ')]
processed = [text[i:i + 3] for i in range(0, len(text), 3)]
if len(processed[len(processed) - 1]) == 2:
processed[len(processed) - 1].append(0)
elif len(processed[len(processed) - 1]) == 1:
processed[len(processed) - 1].append(0)
processed[len(processed) - 1].append(0)
decoder = Matrix(self.matrix_crypt)
decoded = Crypto.decode(processed, decoder)
decoded_message = ""
for code_group in decoded:
for code in code_group:
decoded_message += f"{int(code)} "
decoded_message = decoded_message[0:len(decoded_message) - 1]
message = [int(x) for x in decoded_message.split(' ')]
converted = ""
for number in message:
for key, value in match.items():
if value == number:
converted += key
text = converted.upper().replace(" ", "")
text = self.vig.decrypt(text)
decrypted_text = ""
for letter in text:
temp = self.plugboard_operation(letter)
temp = self.inbound_rotor(letter)
temp = self.reflector_operation(temp)
temp = self.outbound_rotor(temp)
self.turn_rotors()
temp = self.plugboard_operation(temp)
decrypted_text += temp
return decrypted_text
if FLAGS.cipher not in ciphers:
raise NotImplementedError(
'only {} ciphers are implemented'.format(ciphers))
CRACK_MODE = FLAGS.cipher not in ciphers[:3]
print("Crack mode: {}".format(CRACK_MODE))
if CRACK_MODE:
from crack_train_utils import *
else:
from train_utils import *
##### make cipher dataloader #####
data = None
if FLAGS.cipher == ciphers[0]:
from vigenere import Vigenere
data = Vigenere(FLAGS.A, tsteps=FLAGS.tsteps, key_len=FLAGS.key_len)
elif FLAGS.cipher == ciphers[1]:
from autokey import Autokey
data = Autokey(FLAGS.A, tsteps=FLAGS.tsteps, key_len=FLAGS.key_len)
elif FLAGS.cipher == ciphers[2]:
print(
"Note: you must run this in Python 2 because Python 3 does not have the crypto_enigma module yet."
)
from enigma import Enigma
data = Enigma(FLAGS.A, tsteps=FLAGS.tsteps,
key_len=FLAGS.key_len) # only supports keylengths of 3
elif FLAGS.cipher == ciphers[3]:
from crack_vigenere import CrackVigenere
data = CrackVigenere(FLAGS.A, tsteps=FLAGS.tsteps, key_len=FLAGS.key_len)
elif FLAGS.cipher == ciphers[4]:
from crack_autokey import CrackAutokey
def test_long():
vig_long = Vigenere(alphabet, long)
ciphered = vig_long.cipher(message)
assert ciphered == "IFWYVWWUOEYWNCIGBPI"
assert vig_long.decipher(ciphered) == message
from vigenere import Vigenere
import cProfile
a = Vigenere('Once the length of the key is known, the ciphertext can be rewritten into that many columns, with each column corresponding to a single letter of the key. Each column consists of plaintext that has been encrypted by a single Caesar cipher; the Caesar key (shift) is just the letter of the Vigenere key that was used for that column. Using methods similar to those used to break the Caesar cipher, the letters in the ciphertext can be discovered.', 'cipher')
print Vigenere(a.encipher(), 'cipher').decipher()
#cProfile.run('a.decipher()')
def crack_vigenere(ctext,
LANG=[ascii_lowercase, ascii_uppercase],
ALPHABET=len(ascii_lowercase)):
# crack Vigenere using quadgrams statistics
trigram, quadgram = ngram('ngrams/english_trigrams.txt'), ngram(
'ngrams/english_quadgrams.txt')
# preserve text with punctuation
ctext_copy = ctext[::]
# leave only letters in ctext
ctext = re.sub(r'[^a-z]', '', ctext.lower())
# keep a list of the N best possible keys yet, discard anything else
class nbest:
def __init__(self, N=100):
self.store = []
self.N = N
# add item to store, sort store descending, keep N best items (keys)
def add(self, item):
self.store.append(item)
self.store.sort(reverse=True)
self.store = self.store[:self.N]
# this is needed to support indexing for nbest object (look to
# rec[k][1])
def __getitem__(self, k):
return self.store[k]
items = [] # a list for final key-decoded text pairs
for k_len in range(3,
11): # we will be testing keys of lenght from 3 to 10
rec = nbest()
# first, calculate scores of every possible trigram + a's (as a key)
# and add N best scores to rec
for i in permutations(LANG[0], 3):
key = ''.join(i) + 'a' * (k_len - len(i))
plaintext = Vigenere(key).vigenere_decode(ctext, LANG, ALPHABET)
score = 0
for j in range(0, len(ctext), k_len):
score += trigram.score(plaintext[j:j + 3])
rec.add((score, ''.join(i)))
next_rec = nbest()
# next, calculate score for every possible key of k_len
for i in range(0, k_len - 3):
for k in range(rec.N):
for c in LANG[0]:
key = rec[k][1] + c
fullkey = key + 'a' * (k_len - len(key))
plaintext = Vigenere(fullkey).vigenere_decode(
ctext, LANG, ALPHABET)
score = 0
for j in range(0, len(ctext), k_len):
score += quadgram.score(plaintext[j:j + len(key)])
next_rec.add((score, key))
rec = next_rec
next_rec = nbest()
bestkey = rec[0][1]
plaintext = Vigenere(bestkey).vigenere_decode(ctext, LANG, ALPHABET)
bestscore = quadgram.score(plaintext)
# check if there is better score than bestscore. this is needed because
# keys in rec were tested with a's (f.e. pytaaa). Now they have to be
# used without a's
for i in range(rec.N):
plaintext = Vigenere(rec[i][1]).vigenere_decode(
ctext, LANG, ALPHABET)
score = quadgram.score(plaintext)
if score > bestscore:
bestkey = rec[i][1]
bestscore = score
plaintext = Vigenere(bestkey).vigenere_decode(ctext_copy, LANG,
ALPHABET)
print(bestscore, 'Vigenere, k_len', k_len, ':"' + bestkey + '",',
plaintext)
items.append((bestkey.upper() + ": " + plaintext))
return items
from vigenere import Vigenere
from bruteforce import getKeyLength
vg = Vigenere("Clef")
print (getKeyLength(vg.chiffre("Votre message ici, de preference long et avec des mots se repetant souvent")))
from rsa import Rsa
from vigenere import Vigenere
import time
import binascii
while True:
msg = input('Mensagem a ser cifrada: ')
key = input('Chave: ')
cipher = Vigenere()
rsa = Rsa()
start = time.time()
cipherText = cipher.encrypt(msg.upper(), key)
keyPublic = rsa.createPublicKey()
keyPrivate = rsa.createPrivateKey()
encryptedText = rsa.encript(cipherText.encode(), keyPublic)
decodedText = rsa.decript(encryptedText, keyPrivate.upper())
originalText = cipher.decrypt(decodedText.decode(), key)
finish = time.time()
print('Texto encriptado em Vigenere:', cipherText)
print('\nTexto encriptado em RSA:', binascii.hexlify(encryptedText))
print('\nTexto decriptado em RSA:' + decodedText.decode())
print('\nTexto decriptado em Vigenere: ' + originalText)
print('\nTempo de Duração: ' + str(finish - start))
outra = input('\nQuer testar outra frase?\n1-Para sim')
if outra != '1':
break
def main():
"""
DO NOT change this file
"""
INPUT_FILE = "FDREconomics.txt"
DECRYPT_FILE = "FDREconomicsDecrypt.txt"
ENCRYPT_FILE = "FDREconomicsEncrypt.txt"
DECRYPT_COMPRESS_FILE = "FDREconomicsDecryptComp.txt"
VIGENERE_KEY = "Give PEACE a chance!!"
print("(1) Read in original file from " + INPUT_FILE)
print(" Print the original file:")
print()
file_str = open(INPUT_FILE, 'r').read()
print(file_str)
print()
print("(2) Encrypt original file using key: " + VIGENERE_KEY)
print()
vig = Vigenere(VIGENERE_KEY)
en_file_str = vig.encrypt(file_str)
print("(3) Write out the encrypted file to " + ENCRYPT_FILE)
print()
codecs.open(ENCRYPT_FILE, 'w', encoding='utf8').write(en_file_str)
print("(4) Read in encrypted original file from " + ENCRYPT_FILE)
print(" Decrypt encrypted file using key")
print(" Print out decrypted file:")
print()
en_file_str = codecs.open(ENCRYPT_FILE, 'r', encoding='utf8').read()
message = vig.decrypt(en_file_str)
print(message)
print()
print("(5) Write out the decrypted file to " + DECRYPT_FILE)
print()
open(DECRYPT_FILE, 'w').write(message)
print("(6) Compress the original file and save in string")
print()
huff = Huffman()
binary_str = huff.compress(file_str)
print("(7) Decompress compressed file from the string")
print(" Print out decompressed file")
print()
message = huff.decompress(binary_str)
print(message)
print()
print("(8) Encrypt original file using key")
print()
vig = Vigenere(VIGENERE_KEY)
en_file_str = vig.encrypt(file_str)
print("(9) Compress the encrypted file and save in string")
print()
huff = Huffman()
binary_str = huff.compress(en_file_str)
print("(10) Decompress compressed encrypted file from the string")
print()
message = huff.decompress(binary_str)
print("(11) Decrypt decompressed encrypted file using key")
print(" Print out decrypted decompressed encrypted file")
print()
file_str = vig.decrypt(message)
print(file_str)
print()
print("(12) Write out the decrypted decompressed file to " +
DECRYPT_COMPRESS_FILE)
open(DECRYPT_COMPRESS_FILE, 'w').write(file_str)
text = file_data
if args['CIPHER'] == 'SUBSTITUTION':
substitution = Substitution()
if args['SHOULD_ENCRYPT']:
key = args['ENCRYPTION_KEY']
encrypted = substitution.encrypt(text, key)
print(encrypted)
elif args['SHOULD_DECRYPT']:
decrypted = substitution.decrypt(text)
print(decrypted)
elif args['CIPHER'] == 'VIGENERE':
vigenere = Vigenere()
if args['SHOULD_ENCRYPT']:
key = args['ENCRYPTION_KEY']
encrypted = vigenere.encrypt(text, key)
print(encrypted)
elif args['SHOULD_DECRYPT']:
key_length = args['VIGENERE_KEY_LENGTH']
decrypted = vigenere.decrypt(text, key_length)
print(decrypted)
elif args['CIPHER'] == 'CAESAR':
caesar = Caesar()
if args['SHOULD_ENCRYPT']:
# from FrameLSB import ConstructBitsArray, FrameLSB, FrameUnLSB, BitsToInt, BitsToString
# from VideoLSB import VideoLSB, VideoUnLSB
import utils
# from constants import Mode
import sys
import FileReader as fr
from vigenere import Vigenere
# extractor = FrameExtractor(
# "awoo.mp4", "temp")
# extractor.load()
# extractor.extract()
raw_data = fr.ByteArrayToIntArray(fr.ReadFileAsByteArray("test_file.txt"))
vig = Vigenere()
vig.input_key("awoo")
vig.set_auto(False)
vig.set_full(False)
vig.set_extended(True)
encrypted = vig.encrypt(''.join([chr(i) for i in raw_data]))
encrypted = bytes(encrypted)
print("BYTE ARRAY : ", encrypted)
vig2 = Vigenere()
vig2.input_key("awoo")
vig2.set_auto(False)
vig2.set_full(False)
vig2.set_extended(True)
decrypted = vig.decrypt(''.join([chr(i) for i in encrypted]))
print(bytes(decrypted))
def test_extra_points():
vig_random = Vigenere(alphabet)
ciphered = vig_random.cipher(message)
assert vig_random.decipher(ciphered) == message
assert len(vig_random.password) >= 4
# -*- coding: utf-8 -*-
from vigenere import Vigenere
import sys
versao = sys.version_info[0]
if versao == 2:
leitura = raw_input
elif versao == 3:
leitura = input
txt_in = leitura(
'Texto a ser cifrado: zfumkwkhgmeftxmgonhgmgtbibzfpmmyjhbshgbyfhxwmauduiozcgoznedifmbiefvw '
)
password = leitura('Senha: ')
cifra = Vigenere()
txt_cifrado = cifra.encrypt(txt_in, password)
print
print('Texto cifrado: {0}'.format(txt_cifrado))
print(' Texto plano: {0}'.format(cifra.decrypt(txt_cifrado, password)))
# Solution for 2nd Deloitte programming challenge thing.
# This script must be run from the same directory containing vigenere.py.
# This script ignores numbers in the ciphertext and treats all letters as lowercase when decoding.
# The hint tells us to use the previous challenge's solution, which is 141, to find a keyword also from the previous challenge.
# When doing this, it seems we have to include a lone hyphen as a word.
# Excluding the hyphen, "what" is the 141st word.
# Including the hyphen, "tactic" is the 141st word (and turns out to be the word we want).
# Also, the last letter of the ciphertext was incorrectly capitalised; the solution requires it to be lowercase. However, I've left it as it was here since it doesn't affect the code's output.
from vigenere import Vigenere
page_text = r"In Forensic Technology complex problem solving is a large part of our day-to-day work. Paying homage to our fondness of brain-teasers, we're launching a monthly Forensic Technology Challenge - a new series of logical, analytical and coding problems that put into practice the STEM, finance and technology skills essential to our work. Every month we'll post a new challenge created by the Forensic Technology team, focusing on one of these skills. You can solve these problems in any way that you want. We're looking forward to seeing the different ways that you approach them! Without further ado, here is the first challenge straight from the Forensic Technology hive-mind: Of the first 2016 prime numbers, which ones have digits that sum to 13? Our solution involved creating a Python script to do all of the heavy-lifting, but this is only one tactic. What was your method? We'll be posting how we solved this next month, along with Challenge #2. Don't forget to look out for our bonus question next week! If you are someone who enjoys problem-solving, logical thinking and technology, check out our Forensic Technology graduate professional roles to see if they are the right fit. What's the answer? Here's what you've been waiting for, the solutions to the first #4TechChallenge posted last month as well as the answer to the bonus question. So without further ado here is the Python script we used to generate the list of primes and subsequently find how many had their digits sum to a specified total."
previous_solution = 141
page_text = page_text.split()
#page_text.remove('-') # I originally removed the lone hyphen
keyword = page_text[previous_solution - 1].lower()
print "Keyword =", keyword
ciphertext = 'rowmcdxN5xCAPQPGpI'
cipher = Vigenere()
plaintext = cipher.decode(ciphertext, keyword)
print "Decoded text (lowercase and excluding numbers):", plaintext
from config import * import random import json import ujson import uuid import hashlib import datetime from Crypto.PublicKey import RSA from asymmetric import * from vigenere import Vigenere db = DatabaseManager(DATABASES) v = Vigenere(SHIFT_BLOCK, ALPHABET) app = Flask(__name__) app.secret_key = SECRET_KEY csrf = CSRFProtect(app) app.config['STATIC_PATH'] = CANDIDATES_IMAGE_DIRECTORY app.config['JWT_TOKEN_LOCATION'] = ['cookies', 'query_string'] app.config['JWT_QUERY_STRING_NAME'] = 'token' app.config['JWT_ACCESS_COOKIE_PATH'] = '/api/' app.config['JWT_REFRESH_COOKIE_PATH'] = '/token/refresh' app.config['JWT_COOKIE_CSRF_PROTECT'] = True app.config['JWT_SECRET_KEY'] = SECRET_KEY jwt = JWTManager(app)
def index():
if request.method == 'POST':
# set language
if request.form.get("lang") == 'english':
LANG, ALPHABET = [ascii_lowercase,
ascii_uppercase], len(ascii_lowercase)
elif request.form.get("lang") == 'lithuanian':
LANG, ALPHABET = lt_lang, lt_alphabet
# get plaintext
plaintext = request.form.get('plaintext')
# BREAK (WITHOUT KNOWING CYPHER TYPE)
if request.form.get("enc_dec") == ("Break"):
try:
broken = crack_cipher(plaintext, LANG, ALPHABET)
if len(broken) == 2:
key, text = str(broken[0]) + ", Caesar", broken[1]
return render_template("index.html",
cyptext=key,
title="KEY, CYPHER: ",
footnote="DECRYPTED TEXT: ",
cyptext2=text)
elif broken == "This text is most likely encoded in Vigenere. The program can break lithuanian text encoded only in Caesar's":
return render_template("index.html",
cyptext2=broken.upper())
else:
return render_template(
"index.html",
broken=broken,
title="POSSIBLE KEYS AND DECRYPTED TEXT USING THEM:")
except (ValueError, IndexError):
return apology("please provide text in chosen language")
# CAESAR
if request.form.get("cypher") == 'caesar':
# set key. If key is not a number, return apology
try:
key = int(request.form.get("shift"))
except BaseException:
return apology("must provide valid shift size")
# check if user uses encryption or decryption
if request.form.get("enc_dec") == 'Encrypt':
try:
ctext = Caesar(key).caesar_encode(plaintext, LANG,
ALPHABET)
return render_template("index.html",
cyptext=ctext,
title="ENCRYPTED TEXT:")
except ValueError:
return apology("please provide text in chosen language")
elif request.form.get("enc_dec") == 'Decrypt':
try:
ctext = Caesar(key).caesar_decode(plaintext, LANG,
ALPHABET)
return render_template("index.html",
cyptext=ctext,
title="DECRYPTED TEXT:")
except ValueError:
return apology("please provide text in chosen language")
# VIGENERE
elif request.form.get("cypher") == 'vigenere':
key = request.form.get("key")
if key is None or key.isalpha() == False:
return apology("must provide valid key")
if request.form.get("enc_dec") == 'Encrypt':
try:
ctext = Vigenere(key).vigenere_encode(
plaintext, LANG, ALPHABET)
return render_template("index.html",
cyptext=ctext,
title="ENCRYPTED TEXT:")
except ValueError:
return apology("please provide text in chosen language")
elif request.form.get("enc_dec") == 'Decrypt':
try:
ctext = Vigenere(key).vigenere_decode(
plaintext, LANG, ALPHABET)
return render_template("index.html",
cyptext=ctext,
title="DECRYPTED TEXT:")
except ValueError:
return apology("please provide text in chosen language")
else: # == if request.method == 'GET'
return render_template("index.html")
def main():
"""
"""
INPUT_FILE = "FDREconomics.txt"
DECRYPT_FILE = "FDREconomicsDecrypt.txt"
ENCRYPT_FILE = "FDREconomicsEncrypt.txt"
COMPRESS_DAT_FILE = "FDREconomicsComp.dat"
ENCRYPT_COMPRESS_DAT_FILE = "FDREconomicsEncryptComp.dat"
DECRYPT_COMPRESS_FILE = "FDREconomicsDecryptComp.txt"
VIGENERE_KEY = "I love the USA!!"
print("(1) Read in original file: Using " + INPUT_FILE)
print(" Print the original file:")
print()
file_str = open(INPUT_FILE, 'r').read()
print(file_str)
print()
print("(2) Encrypt original file using key: '{}'".format(VIGENERE_KEY))
print()
vig = Vigenere(VIGENERE_KEY)
en_file_str = vig.encrypt(file_str)
print("(3) Write out the encrypted file without compression")
print(" Encrypted original file: Using " + ENCRYPT_FILE)
print()
open(ENCRYPT_FILE, 'w').write(en_file_str)
print("(4) Read in encrypted original file: " + ENCRYPT_FILE)
print(" Decrypt encrypted file using key")
print(" Print out decrypted file:")
print()
en_file_str = open(ENCRYPT_FILE, 'r').read()
message = vig.decrypt(en_file_str)
print(message)
print()
print("(5) Write out the decrypted file")
print(" Decrypted file: Using " + DECRYPT_FILE)
print()
open(DECRYPT_FILE, 'w').write(message)
print("(6) Compress the original file without encryption")
print(" Write out the file compressed without encryption")
print(" Compressed original file: Using " + COMPRESS_DAT_FILE)
print()
huff = Huffman()
binary_str = huff.compress(file_str)
if BITARRAY_EXISTS:
write_bin_file(COMPRESS_DAT_FILE, binary_str)
print("(7) Read in compressed original file without encryption")
print(" Decompress compressed file")
print(" Print out decompressed file")
print()
if BITARRAY_EXISTS:
binary_str = read_bin_file(COMPRESS_DAT_FILE)
message = huff.decompress(binary_str)
print(message)
print()
print("(8) Encrypt original file using key")
print()
vig = Vigenere(VIGENERE_KEY)
en_file_str = vig.encrypt(file_str)
print("(9) Compress the encrypted file")
print(" Write out the compressed encrypted file")
print(" Compressed encrypted file: Using " + ENCRYPT_COMPRESS_DAT_FILE)
print()
huff = Huffman()
binary_str = huff.compress(en_file_str)
if BITARRAY_EXISTS:
write_bin_file(ENCRYPT_COMPRESS_DAT_FILE, binary_str)
print("(10) Decompress compressed encrypted file")
print(" Read in compressed encrypted file")
print(" Compressed encrypted file: Using " + ENCRYPT_COMPRESS_DAT_FILE)
print()
if BITARRAY_EXISTS:
binary_str = read_bin_file(ENCRYPT_COMPRESS_DAT_FILE)
message = huff.decompress(binary_str)
print()
print("(11) Decrypt decompressed file using key")
print(" Print out decrypted decompressed file")
print()
file_str = vig.decrypt(message)
print(file_str)
print()
print("(12) Write out the decrypted decompressed file")
print(" Decrypted decompressed file: Using " + DECRYPT_COMPRESS_FILE)
open(DECRYPT_COMPRESS_FILE, 'w').write(file_str)
def test_semi_long():
vig_semi_long = Vigenere(alphabet, semi_long)
ciphered = vig_semi_long.cipher(message)
assert ciphered == "IFWYVWWUXMQFTXIORHF"
assert vig_semi_long.decipher(ciphered) == message
}
# le plus cité
most_quoted = reverse_occurrences[max(reverse_occurrences.keys())]
print(f"key {i} - most-quoted {most_quoted}")
# for char in sorted(reverse_occurrences):
# print(f"quoted {char} times: {reverse_occurrences[char]}")
# admettant que ça correspond au 'e'
return chr(ord('a') + ((ord(most_quoted) - ord('e')) % 26))
return "".join(i_th(i) for i in range(key_length))
# enigme call_me_al
enigme1 = (
5,
"Cwmjfvz. Ie ifbqolwm zvvd rtbzmisifo unn zoasrldbhoe fb loe tqmgcfbnn gsmeeifa : 'oajt' ms 'Nfom'. Be hvq loeuzd qlf td Zvo Xxtypv dsk uzds gswbhv ec Yee ec Saf: «Uzdnkf zzyfoa boewmqgvob zu dpgdu, dbqr c'vtb ke mjld mveqzn hvq eazu uzrtimq lv dpzr. C'Fbqe upvme ufa oojtqaicjbds,t'fas prs td nfo-msrv rc'nn cfa ttzmqre. (Cbw-Ssvv «Bzo-kp-shnx» Dms ecpod dl wqce df nnuioqs l'fdkzszpv ce ifvcrv iwlmrhm z ue em lej jlnlvt mm mrupdmruqpuvt : Rnhe Iwqtfo Knnnbg, brvbbdui fvsrv bcsrvt lt «Jvv ld lr Wqd» ek emr «Nfnjqej em Boexix», sls tdshvmks a'bq dcijb loe nmlozsm ce UFI , puz dwmskscht «Kpcr lvt vnmssmr, pvuqss vu oqaeea» z prsbhr uf t'dnjfualv wqce. Tfbse dfzuezmtd dv «amqocpohe» r bcrsz girczom tn vuccirob ce Tpvvap : vv beiuihn Upvzlu Lvtty , bcsels ld TvY ms dv mi aismm « Shv Bzs ow Dwlplumq Pipoqadnqmg » . C'iclols «odeb» em Jnlup le gbzzik smkemfz zujtq aivo lt nfo-adnjf yte uf t'gudpcq Zvo lt vvomqe Dbqsrv Min-Tjfc, dt xbodoet yte tfzsazoa cej bcselsa bikfa nnk bcrsz jvrpzsm ke SENK Gljln Vro Znsjvu, zuo dwsej emr Mfobx Ppupnn.Dfzbi gpcq vfuzd akummtzpv z cvubd prsmmtyfad clmbtrvmtd, ue qmt lfoote gpcq ue ftngv ec uiuf !"
)
from vigenere import Vigenere
if __name__ == '__main__':
for length, encoded in (enigme1, ):
encoded = encoded.lower()
print(f"encoded = {encoded}\nlength = {length}")
key = break_vigenere(encoded, length)
print(f" key -> {key}")
codec = Vigenere(key, continuous=False)
print(f" decoded -> {codec.decode(encoded)}")
def test_short():
vig_short = Vigenere(alphabet, short)
ciphered = vig_short.cipher(message)
assert ciphered == "TSMWTSNFBEFLPJWUENG"
assert vig_short.decipher(ciphered) == message
def main():
symbols = string.ascii_lowercase
# first argument is the cipher
cipher = sys.argv[1]
# second arugment is the key
key = sys.argv[2]
# 3rd argument is the encrypt/Decrypt
mode = sys.argv[3]
# 4th argument is the input text
input_txt = sys.argv[4]
# 5th arugment is the output text
output_txt = sys.argv[5]
plainText = ''
cipherText = ''
text = open(input_txt)
if mode == 'encrypt':
plainText = text.read()
if mode == 'decrypt':
cipherText = text.read()
if cipher == 'caesar' or cipher == 'Caesar':
caesar = Caesar(key, symbols)
if mode == 'encrypt':
cipherText = open(output_txt, 'w')
cipherText.write(caesar.encrypt(plainText))
cipherText.close()
if mode == 'decrypt':
plainText = open(output_txt, 'w')
plainText.write(caesar.decrypt(cipherText))
plainText.close()
if cipher == 'playfair' or cipher == 'Playfair':
playfair = Playfair(key)
if mode == 'encrypt':
cipherText = open(output_txt, 'w')
cipherText.write(playfair.encrypt(plainText))
cipherText.close()
if mode == 'decrypt':
plainText = open(output_txt, 'w')
plainText.write(playfair.decrypt(cipherText))
plainText.close()
if cipher == 'vigenere' or cipher == 'Vigenere':
vigenere = Vigenere(key, symbols)
if mode == 'encrypt':
cipherText = open(output_txt, 'w')
cipherText.write(vigenere.encrypt(plainText))
cipherText.close()
if mode == 'decrypt':
plainText = open(output_txt, 'w')
plainText.write(vigenere.decrypt(cipherText))
plainText.close()
if cipher == 'transposition' or cipher == 'Transposition':
transposition = Transposition(key)
if mode == 'encrypt':
cipherText = open(output_txt, 'w')
cipherText.write(transposition.encrypt(plainText))
cipherText.close()
if mode == 'decrypt':
plainText = open(output_txt, 'w')
plainText.write(transposition.decrypt(cipherText))
plainText.close()
if cipher == 'railfence' or cipher == 'Railfence':
rail = RailFence(key)
if mode == 'encrypt':
cipherText = open(output_txt, 'w')
cipherText.write(rail.encrypt(plainText))
cipherText.close()
if mode == 'decrypt':
plainText = open(output_txt, 'w')
plainText.write(rail.decrypt(cipherText))
plainText.close()
caesar.decipher(from_file,int(key)) else: print "Option doesn't exist." elif algorithm == "t": transposition = Transposition() if option == "c": transposition.cipher(from_file,int(key)) elif option == "d": transposition.decipher(from_file,int(key)) else: print "Option doesn't exist." elif algorithm == "v": vigenere = Vigenere() if option == "c": vigenere.cipher(from_file,key) elif option == "d": vigenere.decipher(from_file,key) else: print "Option doesn't exist." elif algorithm == "s": substitution = Substitution() if option == "c": substitution.cipher(from_file,key) elif option == "d": substitution.decipher(from_file,key)
n = affn.get()
if n == '' or n == ' ':
n = 256
else:
n = int(n)
original = affObj.decryptText(econtent, int(a), int(b), n)
new_file = open(file.name[:-4] + ".txt", "w")
new_file.write(original)
fstatB["text"] = "SAVED!"
file.close()
new_file.close()
#AQUÍ MI MAIN
file = None
vigObj = Vigenere()
affObj = Affine()
#CREAMOS LA VENTANA Y ASIGNAMOS UN TAMAÑO
window = tk.Tk()
window.title("PRACTICA 1")
frame = tk.Frame(master=window, width=510, height=420, bg="black")
#CREAMOS EL SALUDO
greeting = tk.Label(text="WELCOME!",
foreground="crimson",
background="black",
width=35,
height=4,
font=("Courier", 16))
greeting.place(x=10, y=0)
#CREAMOS UN LABEL DE INSTRUCCIONES
