def __init__(self): """ sets the initial machine with reflector, default rotors and default plugboard. """ self.__reflector = Reflector() self.plugboard = Plugboard() self.rotors = Rotors()
def __init__(self): # Create all rotors used in a M3 Enigma machine self.r1 = Rotor(1, [letter for letter in "EKMFLGDQVZNTOWYHXUSPAIBRCJ"], ["Q"]) self.r2 = Rotor(2, [letter for letter in "AJDKSIRUXBLHWTMCQGZNPYFVOE"], ["E"]) self.r3 = Rotor(3, [letter for letter in "BDFHJLCPRTXVZNYEIWGAKMUSQO"], ["V"]) # Store rotors in number mapped dictionary self.r_table = {1: self.r1, 2: self.r2, 3: self.r3} # plugboard self.plugboard = [] # Initialize rotor sockets self.sockets = {1: self.r1, 2: self.r2, 3: self.r3} # Create reflectors self.reflectors_available = { "UKW-B": Reflector("UKW-B", [letter for letter in "YRUHQSLDPXNGOKMIEBFZCWVJAT"]), "UKW-C": Reflector("UKW-C", [letter for letter in "FVPJIAOYEDRZXWGCTKUQSBNMHL"]) } self.reflector = self.reflectors_available["UKW-B"] self.alphabet_map = [letter for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
def testReflect(self): reflector = Reflector(1,1,'A') position = reflector.reflect(8) reflection = string.ascii_uppercase[position] assert(reflection == 'P') position = reflector.reflect(string.ascii_uppercase.index('M')) reflection = string.ascii_uppercase[position] assert(reflection == 'O') print('Reflect passed')
def main(): UPPER_STRING = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" testAlphabet = Alphabet(UPPER_STRING) permutation1 = Permutation( "(AELTPHQXRU) (BKNW) (CMOY) (DFG) (IV) (JZ) (S)", testAlphabet) permutation2 = Permutation( "(FIXVYOMW) (CDKLHUP) (ESZ) (BJ) (GR) (NT) (A) (Q)", testAlphabet) permutation3 = Permutation("(ABDHPEJT) (CFLVMZOYQIRWUKXSG) (N)", testAlphabet) permutation4 = Permutation("(AEPLIYWCOXMRFZBSTGJQNH) (DV) (KU)", testAlphabet) permutation5 = Permutation( "(AE) (BN) (CK) (DQ) (FU) (GY) (HW) (IJ) (LO) (MP) (RX) (SZ) (TV)", testAlphabet) rotor1 = Rotor("I", permutation1, "TG") rotor2 = Rotor("II", permutation2, "A") rotor3 = Rotor("III", permutation3, "B") rotor4 = Rotor("IV", permutation4, "XO") reflector = Reflector("A", permutation5) rotors = [reflector, rotor4, rotor3, rotor2, rotor1] machine = Machine(testAlphabet, 5, 6, rotors) machine.insertRotors(["A", "IV", "III", "II", "I"]) machine.setRotors("AAAA") message = input("What to convert:") print(machine.convertMsg(message))
def __init__(self, *configs): self.plugboard = Plugboard(configs[-1]) self.rotors = [] # initially no rotors for rotor_path in configs[:-1]: self.rotors.append(Rotor(rotor_path)) self.reflector = Reflector(13)
def __init__(self): # Create all rotors used in a M3 Enigma machine self.r1 = Rotor("I", [letter for letter in "EKMFLGDQVZNTOWYHXUSPAIBRCJ"], ["Q"]) self.r2 = Rotor("II", [letter for letter in "AJDKSIRUXBLHWTMCQGZNPYFVOE"], ["E"]) self.r3 = Rotor("III", [letter for letter in "BDFHJLCPRTXVZNYEIWGAKMUSQO"], ["V"]) self.r4 = Rotor("IV", [letter for letter in "ESOVPZJAYQUIRHXLNFTGKDCMWB"], ["J"]) self.r5 = Rotor("V", [letter for letter in "VZBRGITYUPSDNHLXAWMJQOFECK"], ["Z"]) # Store rotors in number mapped dictionary self.r_table = { 1: self.r1, 2: self.r2, 3: self.r3, 4: self.r4, 5: self.r5 } # plugboard self.plugboard = [] # Initialize rotor sockets self.sockets = {1: self.r1, 2: self.r2, 3: self.r3} # Create reflectors self.reflectors_available = { "UKW-B": Reflector("UKW-B", [letter for letter in "YRUHQSLDPXNGOKMIEBFZCWVJAT"]), "UKW-C": Reflector("UKW-C", [letter for letter in "FVPJIAOYEDRZXWGCTKUQSBNMHL"]) } self.reflector = self.reflectors_available["UKW-B"] self.a = [letter for letter in "ABCDEFGHIJKLMNOPQRSTUVWXYZ"]
def __init__(self, encryptors=[]): # Encryptors must be a list, everything in that list # must be either a stator or a rotor and stators # must be before rotors if type(encryptors) != list: raise TypeError("Encryptors must be a list") else: found_rotors = False for e in encryptors: if isinstance(e, Rotor): found_rotors = True elif isinstance(e, Stator): if found_rotors: raise ValueError("Stators must come before Rotors") else: raise TypeError("All encryptors must be Stators or Rotors") self.encryptors = encryptors self.reflector = Reflector()
class TypeX: def __init__(self, encryptors=[]): # Encryptors must be a list, everything in that list # must be either a stator or a rotor and stators # must be before rotors if type(encryptors) != list: raise TypeError("Encryptors must be a list") else: found_rotors = False for e in encryptors: if isinstance(e, Rotor): found_rotors = True elif isinstance(e, Stator): if found_rotors: raise ValueError("Stators must come before Rotors") else: raise TypeError("All encryptors must be Stators or Rotors") self.encryptors = encryptors self.reflector = Reflector() def __clean(self, string): clean_list = [] for char in string: if char.upper() in Encryptor.ALPHABET: clean_list.append(char.upper()) elif char == ' ': clean_list.append('X') return ''.join(clean_list) def __step(self): for e in self.encryptors: if not e.step(): break def encrypt(self, string): # Clean up the input string and # encrypt it encrypted_chars = [] for char in self.__clean(string): # Before encrypting each letter, step the rotors self.__step() for e in self.encryptors: char = e.encrypt_character(char) char = self.reflector.encrypt_character(char) for e in reversed(self.encryptors): char = e.reverse_encrypt_character(char) encrypted_chars.append(char) return ''.join(encrypted_chars)
class EnigmaMachine(Encoder): def __init__(self, *configs): self.plugboard = Plugboard(configs[-1]) self.rotors = [] # initially no rotors for rotor_path in configs[:-1]: self.rotors.append(Rotor(rotor_path)) self.reflector = Reflector(13) def encode(self, input): input = ord(input) - ord('A') # A -> 0, ..., Z -> 25 output = self.plugboard.encode(input) output = self.pass_rotors('encode', output) output = self.reflector.encode(output) output = self.pass_rotors('decode', output) output = self.plugboard.decode(output) if len(self.rotors) > 0: # check for rotors self.rotate_rotors(0) # rotate necessary rotors return chr(output + ord('A')) def encode_message(self, message): encoded_message = '' for letter in message: if letter == ' ': encoded_message += ' ' else: encoded_message += self.encode(letter) return encoded_message def decode(self, output): return self.encode(output) # reciprocal cipher def rotate_rotors(self, rotor_i): if self.rotors[rotor_i].rotate(): rotor_i += 1 if rotor_i < len(self.rotors): self.rotate_rotors(rotor_i) def pass_rotors(self, transformer, input): direc = -1 if transformer == 'decode' else 1 for rotor_num, rotor in enumerate(self.rotors[::direc]): # get output of current rotor if transformer == 'encode': input = rotor.encode(input) else: # decode input = rotor.decode(input) return input
def main(): f = input("Введите имя файла: ") try: file = open(f, "rb") except IndexError: print("Wrong file") return rotors = [] for _ in range(ROTORS_COUNT): rotors.append(Rotor()) enigma = Enigma(rotors, Reflector()) print(enigma) enc_file_name = "enc_" + f dec_file_name = "dec_" + f enc_file = open(enc_file_name, "wb") print("Start encrypting '{0}' ...".format(f)) while True: buf = file.read(MAX_LEN) if (not len(buf)): file.close() enc_file.close() print("Encrypting done. Results saved in file: '{0}'".format( enc_file_name)) break else: enc_str = enigma.encryptStr(buf) enc_file.write(enc_str) enc_file = open(enc_file_name, "rb") dec_file = open(dec_file_name, "wb") enigma.reset() print("Start decrypting '{0}' ...".format(enc_file_name)) while True: buf = enc_file.read(MAX_LEN) if (not len(buf)): enc_file.close() dec_file.close() print("Decrypting done. Results saved in file: '{0}'".format( dec_file_name)) break else: dec_str = enigma.encryptStr(buf) dec_file.write(dec_str)
def main(): try: file = open(sys.argv[1], "rb") except IndexError: print("Set file as argv[1]") return rotors = [] for _ in range(ROTORS_COUNT): rotors.append(Rotor()) enigma = Enigma(rotors, Reflector()) print("!!!!!!!!!") print(enigma) print("!!!!!!!!!") print("!!!!!!!!!") print() print() enc_file_name = "enc_" + sys.argv[1] dec_file_name = "dec_" + sys.argv[1] enc_file = open(enc_file_name, "wb") while True: # считывается MAX_LEN символов из файла buf = file.read(MAX_LEN) if(not len(buf)): file.close() enc_file.close() break else: enc_str = enigma.encryptStr(buf) enc_file.write(enc_str) enc_file = open(enc_file_name, "rb") dec_file = open(dec_file_name, "wb") enigma.reset() while True: buf = enc_file.read(MAX_LEN) if(not len(buf)): enc_file.close() dec_file.close() break else: dec_str = enigma.encryptStr(buf) dec_file.write(dec_str)
class Enigma(object): '''Object to handle Enigma encryption. Based on Enigma Machine''' def __init__(self, offset1, offset2, offset3): self.rot1 = Rotor(offset1, rotor_num=1) self.rot2 = Rotor(offset2, rotor_num=2) self.rot3 = Rotor(offset3, rotor_num=3) self.reflector = Reflector(ALPHABET) self.plugboard = Plugboard(ALPHABET, PLUGBOARD_LIST) #TODO: Do this better def set_rotors(self, offset1, offset2, offset3): '''Set the values of the rotors''' self.rot1.offset = offset1 self.rot2.offset = offset2 self.rot3.offset = offset3 #TODO: Implement this correctly def increment_rotors(self): '''Increment the rotors according to the Enigma algorithm''' self.rot1.increment() if self.rot1.offset == 3: self.rot2.increment() if self.rot2.offset == 2: self.rot3.increment() def encipher(self, msg): '''Encipher the message according to the Enigma algorithm''' output = '' for val in msg: val = self.plugboard.encipher(val) self.increment_rotors() val = self.rot1.encipher(val) val = self.rot2.encipher(val) val = self.rot3.encipher(val) val = self.reflector.encipher(val) val = self.rot3.decipher(val) val = self.rot2.decipher(val) val = self.rot1.decipher(val) val = self.plugboard.encipher(val) output = output + val return output
def test_if_encryptors_are_valid(self): self.assertTrue( isinstance( TypeX(encryptors=[ Stator(wiring='ABCDEFOPQGHIJKLMNRSTXYZUVW', initial_position=3), Rotor(wiring='QWERTYUIOPASDFGHJKLZXCVBNM', initial_position=4, notchings=[0, 5, 12, 16, 25]) ]), TypeX)) with self.assertRaises(TypeError): TypeX(encryptors='a flamingo wrapped in tinsel') # Pass in encryptors that include a non-Encryptor with self.assertRaises(TypeError): TypeX(encryptors=[ Stator(wiring='ABCDEFOPQGHIJKLMNRSTXYZUVW', initial_position=3), 'flamingo' ]) # Pass in encryptors that include a Reflector with self.assertRaises(TypeError): TypeX(encryptors=[ Stator(wiring='ABCDEFOPQGHIJKLMNRSTXYZUVW', initial_position=3), Reflector() ]) # Pass in encryptors that are out of order with self.assertRaises(ValueError): TypeX(encryptors=[ Rotor(wiring='QWERTYUIOPASDFGHJKLZXCVBNM', initial_position=4, notchings=[0, 5, 12, 16, 25]), Stator(wiring='ABCDEFOPQGHIJKLMNRSTXYZUVW', initial_position=3) ])
e = self.reflector.reflect(e) e = self.left_rotor.convert_backward(e) e = self.middle_rotor.convert_backward(e) e = self.right_rotor.convert_backward(e) e = self.plugboard.convert(e) self.right_rotor.increment_position() encrypted += e return encrypted if __name__ == "__main__": r_right = Rotor(3, 0) r_middle = Rotor(2, 0) r_left = Rotor(1, 0) reflector = Reflector("A") plugboard = Plugboard("AZ BP CH DN EM FS GW JY KT LQ") input_text = "HELLOWORLD" print "Input:", input_text e = Enigma(reflector, r_left, r_middle, r_right, plugboard) encrypted = e.encrypt(input_text) print "Encrypted:", encrypted r_left.set_position(0) r_middle.set_position(0) r_right.set_position(0) decrypted = e.encrypt(encrypted)
class Enigma: """ this class is the main class of the enigma machine simulator. it will encrypt and decrypt messages. """ def __init__(self): """ sets the initial machine with reflector, default rotors and default plugboard. """ self.__reflector = Reflector() self.plugboard = Plugboard() self.rotors = Rotors() def decrypt_encrypt_text(self, text): """ encrypts or decrypts a whole text :param text: :return: """ text_after_enigma = "" for i in text: letter_after_enigma, encryption_str = self.encrypt_letter(i) text_after_enigma += letter_after_enigma return text_after_enigma def encrypt_letter(self, letter): """ encrypts a given letter :param letter: :return: encrypted letter and encryption string which explains the stages of the encryption. used in the simulator when showing the encryption stages. """ encryption_str = "the letter to encrypt: " + letter + "\n" letter = letter.upper() encryption_str += "letters on rotors: " + str( self.rotors.letter_on_rotors()) + "\n" encryption_str += "letter before plugboard = " + letter + "\n" letter_after_plugboard = self.plugboard.return_encrypted_letter(letter) encryption_str += "letter after plugboard = " + letter_after_plugboard + "\n" letter_before_reflector, cipher_txt = self.rotors.\ cipher_letter_plugboard_to_reflector(letter_after_plugboard) encryption_str += cipher_txt encryption_str += "letter before reflector = " + letter_before_reflector + "\n" letter_after_reflector = self.__reflector.get_encrypted_letter( letter_before_reflector) encryption_str += "letter after reflector = " + letter_after_reflector + "\n" letter_before_plugboard, decipher_txt = self.rotors.cipher_letter_reflector_to_plugboard( letter_after_reflector) encryption_str += decipher_txt encryption_str += "letter before plugboard = " + letter_before_plugboard + "\n" letter_encrypted = self.plugboard.return_encrypted_letter( letter_before_plugboard) encryption_str += "letter encrypted = " + letter_encrypted self.rotors.move_rotors_after_cipher() return letter_encrypted, encryption_str def set_random_settings(self): """ this function sets the enigma to a random settings. :return: """ # setting random rotors rotors_numbers = random.sample([1, 2, 3, 4, 5], 3) rotors_letters = random.sample([chr(i) for i in range(65, 91)], 3) self.rotors.set_rotors(rotors_numbers[0], rotors_numbers[1], rotors_numbers[2], rotors_letters[0], rotors_letters[1], rotors_letters[2]) # setting random plugboard num_pairs = random.randint(0, 10) plugboard_letters = random.sample([chr(i) for i in range(65, 91)], num_pairs * 2) for i in plugboard_letters: self.plugboard.add_letter(i)
class testReflector(unittest.TestCase): def setUp(self): self.reflector = Reflector() # To test for mistypes def test_getMapping(self): self.assertEqual(self.reflector.getMapping("A"),"E") self.assertEqual(self.reflector.getMapping("B"),"J") self.assertEqual(self.reflector.getMapping("C"),"M") self.assertEqual(self.reflector.getMapping("D"),"Z") self.assertEqual(self.reflector.getMapping("E"),"A") self.assertEqual(self.reflector.getMapping("F"),"L") self.assertEqual(self.reflector.getMapping("G"),"Y") self.assertEqual(self.reflector.getMapping("H"),"X") self.assertEqual(self.reflector.getMapping("I"),"V") self.assertEqual(self.reflector.getMapping("J"),"B") self.assertEqual(self.reflector.getMapping("k"),"W") self.assertEqual(self.reflector.getMapping("L"),"F") self.assertEqual(self.reflector.getMapping("M"),"C") self.assertEqual(self.reflector.getMapping("N"),"R") self.assertEqual(self.reflector.getMapping("O"),"Q") self.assertEqual(self.reflector.getMapping("P"),"U") self.assertEqual(self.reflector.getMapping("Q"),"O") self.assertEqual(self.reflector.getMapping("R"),"N") self.assertEqual(self.reflector.getMapping("s"),"T") self.assertEqual(self.reflector.getMapping("t"),"S") self.assertEqual(self.reflector.getMapping("U"),"P") self.assertEqual(self.reflector.getMapping("v"),"I") self.assertEqual(self.reflector.getMapping("W"),"K") self.assertEqual(self.reflector.getMapping("X"),"H") self.assertEqual(self.reflector.getMapping("y"),"G") self.assertEqual(self.reflector.getMapping("z"),"D")
def setUp(self): self.reflector = Reflector()
def __init__(self, offset1, offset2, offset3): self.rot1 = Rotor(offset1, rotor_num=1) self.rot2 = Rotor(offset2, rotor_num=2) self.rot3 = Rotor(offset3, rotor_num=3) self.reflector = Reflector(ALPHABET) self.plugboard = Plugboard(ALPHABET, PLUGBOARD_LIST)
class M3(EnigmaMachine): def __init__(self,setting): self.rotorLeft = Rotor(int(setting[0])-1,1,'A') self.rotorMiddle = Rotor(int(setting[1])-1,1,'A') self.rotorRight = Rotor(int(setting[2])-1,1,'A') self.reflector = Reflector(int(setting[3]),1,'A') def numberOfSettableWheels(self): """ returns the number of rotors+reflectors in the machine whose position can be set by the operator. for example for the m3 this will be 3, for the m4 it will be 5. this will be the length of the string returned by the set/get indicator methods.""" return len(self.getCurrentIndicators()) def setIndicators (self,setting): """ set the orientation of the rotors (and settable reflectors) to the specified characters. the characters correspond to the rotors (and settable reflector) in the same order as the walzenlage string. for any valid setting: m.getCurrentIndicators(m.setIndicators(setting)).equals(setting)""" self.rotorLeft.setOrientation(setting[0]) self.rotorMiddle.setOrientation(setting[1]) self.rotorRight.setOrientation(setting[2]) def getCurrentIndicators (self): """ refers to the current orientation of the rotors (and settable reflectors) ie what are the letters you can currently read thru the windows? the output characters should be in the same order as the walzenlage string""" indicators = '' indicators += self.rotorLeft.getOrientation() indicators += self.rotorMiddle.getOrientation() indicators += self.rotorRight.getOrientation() return indicators def encipher (self,plaintext): ciphertext = '' plaintext = plaintext.upper() for alphabet in plaintext: self.rotateRotors() #print(self.getCurrentIndicators()) #print("Alphabet:",alphabet) position = string.ascii_uppercase.index(alphabet) position = self.rotorRight.encode(position) #print(position) position = self.rotorMiddle.encode(position) #print(string.ascii_uppercase[position]) position = self.rotorLeft.encode(position) #print(string.ascii_uppercase[position]) position = self.reflector.reflect(position) #print(string.ascii_uppercase[position]) position = self.rotorLeft.decode(position) #print(string.ascii_uppercase[position]) position = self.rotorMiddle.decode(position) #print(string.ascii_uppercase[position]) position = self.rotorRight.decode(position) #print(string.ascii_uppercase[position]) cipherAlphabet = string.ascii_uppercase[position] ciphertext += cipherAlphabet return ciphertext def rotateRotors(self): """ rotates the rotors based on conditions""" if self.rotorRight.getOrientation() == self.rotorRight.getNotch(): if self.rotorMiddle.getOrientation() == self.rotorMiddle.getNotch(): self.rotorLeft.rotate() self.rotorMiddle.rotate() elif self.rotorMiddle.getOrientation() == self.rotorMiddle.getNotch(): self.rotorMiddle.rotate() self.rotorLeft.rotate() #elif self.rotorLeft.getOrientation() == self.rotorLeft.getNotch(): #self.rotorLeft.rotate() self.rotorRight.rotate()
def __init__(self,setting): self.rotorLeft = Rotor(int(setting[0])-1,1,'A') self.rotorMiddle = Rotor(int(setting[1])-1,1,'A') self.rotorRight = Rotor(int(setting[2])-1,1,'A') self.reflector = Reflector(int(setting[3]),1,'A')
M3A1 = Rotor(M3A_1) M3A2 = Rotor(M3A_2) MVEN11 = Rotor(EN1_1) MVEN12 = Rotor(EN1_2) MVEN13 = Rotor(EN1_3) MVM3A1 = Rotor(M3A_1) MVM3A2 = Rotor(M3A_2) D_MVEN11 = Rotor(EN1_1) D_MVEN12 = Rotor(EN1_2) D_MVEN13 = Rotor(EN1_3) D_MVM3A1 = Rotor(M3A_1) D_MVM3A2 = Rotor(M3A_2) rf = Reflector(R) def main(): choice = int( raw_input( "Enter 1 for \"1930 Enigma I,\" 2 for \"1938 M3 Army,\" or 3 for Mohamed/Vincent Rotor: " )) encode_decode = int(raw_input("Encipher (1) or decipher (2)? ")) cipherText = raw_input("What would you like to encipher? ") if choice == 1: machine = Machine([EN11, EN12, EN13], rf) print machine.encipher(cipherText) elif choice == 2: machine = Machine([EN11, EN12, EN13, M3A1, M3A2], rf) print machine.encipher(cipherText)