def run(params): function, infile, outfile, key = parser(params) if(function==0): return help() else: cypher = Caesar(key,infile,outfile) # initialize object cypher.encode() if(function==1) else cypher.decode()
class Affine(Cipher): """Implements cipher via the affine method""" def __init__(self, key, alphabet_size): super().__init__("Affine", alphabet_size, key) mkey, ckey = key self.multiplication = Multiplication(mkey, alphabet_size) self.caesar = Caesar(ckey, alphabet_size) def encode(self, message): caesared = self.caesar.encode(message) multiplied = self.multiplication.encode(caesared) return multiplied def decode(self, encrypted): multiplied = self.multiplication.decode(encrypted) caesared = self.caesar.decode(multiplied) return caesared def candidate_keys(self): caesar_candidates = self.caesar.candidate_keys() multiplication_candidates = self.multiplication.candidate_keys() return product(multiplication_candidates, caesar_candidates) @staticmethod def generate_key(alphabet_size): return Multiplication.generate_key(alphabet_size), Caesar.generate_key( alphabet_size)
class Affine: """ Affine cipher """ def __init__(self): self.caesar = Caesar() self.multiplication = Multiplication() def generate_keys(self): """ Generates encryption and decryption key """ multiplication_encrypt, multiplication_decrypt = self.multiplication.generate_keys( ) caesar_encrypt, caesar_decrypt = self.caesar.generate_keys() encryption_key = (multiplication_encrypt, caesar_encrypt) # (48, 90) decryption_key = (multiplication_decrypt, caesar_decrypt) # (2, 5) return encryption_key, decryption_key def encode(self, message, key): """ Encode message with given key """ multiplication_key = key[0] caesar_key = key[1] # Encode with Multiplication then Caesar partially_encoded = self.multiplication.encode(message, multiplication_key) encoded_message = self.caesar.encode(partially_encoded, caesar_key) return encoded_message def decode(self, encoded_message, decryption_keys): """ Decode the encoded message with the decryption key """ multiplication_key = decryption_keys[0] caesar_key = decryption_keys[1] # Decode with Caesar then Multiplication partially_decoded = self.caesar.decode(encoded_message, caesar_key) decoded_message = self.multiplication.decode(partially_decoded, multiplication_key) return decoded_message
class Hacker(Receiver): '''Hacker class''' def __init__(self, cipher): self.cipher = cipher def english_words(self): '''List of the txt file''' file = open('english_words.txt') return file.read().splitlines() def brute_force(self, cipher, crypt_key): '''Brute force method''' words = self.english_words() for key in cipher.possible_keys(): if isinstance(cipher, Affine): for key_two in cipher.possible_keys(): self.set_key([key, key_two]) if self.operate_cipher(cipher, crypt_key) in words: return self.operate_cipher(cipher, crypt_key) else: self.set_key(key) if words.__contains__(self.operate_cipher(cipher, crypt_key)): return self.operate_cipher(cipher, crypt_key) return "None of the possible keys could decrypt the encrypted word" c = Caesar() h = Hacker(c) print(h.brute_force(c, c.encode("hello", c.generate_keys())))
def encode(self, plain_text, senders_key): caesar = Caesar() multiplicative = Multiplicative() multiplicative_cyphered = multiplicative.encode(plain_text, senders_key[0]) double_cyphered = caesar.encode(multiplicative_cyphered, senders_key[1]) return double_cyphered