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 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):
"""
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("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 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)
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 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)
])
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)
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)
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)
