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)
