def setUp(self):
self.enigma = Enigma(Plugboard('VZBRGITYUPSDNHLXAWMJQOFECK'),
Reflector('JPGVOUMFYQBENHZRDKASXLICTW'),
Settings("ABC"))
self.enigma2 = Enigma(Plugboard('VZBRGITYUPSDNHLXAWMJQOFECK'),
Reflector('JPGVOUMFYQBENHZRDKASXLICTW'),
Settings("WGF"))
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, rotor_selection, rotor_settings, plugs, ring_positions,
reflector):
"""
Rotor_selection: Which rotors are in use and which order.
List would look like this: [4, 2, 5]
rotor_settings: list of starting positions for left, middle,
and right rotor. i.e index 0 is for left rotor, 1 for middle,
and 2 for right rotor.
List would look like this: [1, 6, 16]
plugs: List of enabled plugboard settings.
List would look like this: [
"QH",
"EN",
"RM",
"TL",
"YS",
"UI",
"OK",
"PC",
"DV",
"FG"
]
"""
# Wiring for rotors I to V
self.rotor_settings_strings = [
"EKMFLGDQVZNTOWYHXUSPAIBRCJ", "AJDKSIRUXBLHWTMCQGZNPYFVOE",
"BDFHJLCPRTXVZNYEIWGAKMUSQO", "ESOVPZJAYQUIRHXLNFTGKDCMWB",
"VZBRGITYUPSDNHLXAWMJQOFECK"
]
self.rotor_settings = rotor_settings
self.rotor_selection = rotor_selection
self.ring_positions = ring_positions
self.rotor_list = self.setup_rotors(self.rotor_selection,
self.rotor_settings)
self.plugboard = Plugboard(plugs)
self.reflector = reflector
def create_machinery(self):
"""
Adds in turn each part of the machine as specified in the user settings.
"""
# Add plugboard with respective pluglead pairs
self.board = Plugboard(self.settings)
# Add housing
self.add("Housing")
# Add rotors. Rotors are 'inserted' in reverse order from right to left
for i in range(len(self.settings['rotors'].split(' ')) - 1, -1, -1):
rotor_name = self.settings['rotors'].split(' ')[i]
ring_setting = self.settings['ring_settings'].split(' ')[i]
initial_position = self.settings['initial_positions'].split(' ')[i]
self.add(rotor_name, ring_setting, initial_position)
# Add reflector
self.add(self.settings['reflector'])
def __init__(self, nmrRotors, initCharRotors, cables):
self.list_of_rotors = []
reflector_indexes = "IXUHFEZDAOMTKQJWNSRLCYPBVG"
#rotors_orders = ["EKMFLGDQVZNTOWYHXUSPAIBRCJ", "AJDKSIRUXBLHWTMCQGZNPYFVOE", "BDFHJLCPRTXVZNYEIWGAKMUSQO"]
rotors_orders = [
"EKMFLGDQVZNTOWYHXUSPAIBRCJ", "AJDKSIRUXBLHWTMCQGZNPYFVOE",
"BDFHJLCPRTXVZNYEIWGAKMUSQO", "RMSLNIXCYPTZAHJOUFDBQGWKVE",
"ZIHFQEMASYPOWDBKVXCNLRTUGJ"
]
# "RMSLNIXCYPTZAHJOUFDBQGWKVE", "ZIHFQEMASYPOWDBKVXCNLRTUGJ"
# imaginemos nmrRotor = [2,1] y charRotor = ['C','G']
for index, (nmrRotor,
charRotor) in enumerate(zip(nmrRotors, initCharRotors)):
self.list_of_rotors.append(
Rotor(charRotor, rotors_orders[nmrRotor - 1]))
self.plugboard = Plugboard(cables)
self.reflector = Rotor('A', reflector_indexes)
def __init__(self,
rotors='I II III',
ring_settings=None,
reflector='B',
plugboard_settings=None):
if isinstance(rotors, str):
rotors = rotors.split()
num_rotors = len(rotors)
if num_rotors not in (3, 4):
raise EnigmaError("invalid rotors list size")
if ring_settings is None:
ring_settings = [0] * num_rotors
elif isinstance(ring_settings, str):
strings = ring_settings.split()
ring_settings = []
for s in strings:
if s.isalpha():
ring_settings.append(ord(s.upper()) - ord('A'))
elif s.isdigit():
ring_settings.append(int(s) - 1)
else:
raise EnigmaError('invalid ring setting: %s' % s)
if num_rotors != len(ring_settings):
raise EnigmaError("# of rotors doesn't match # of ring settings")
rotor_list = [
create_rotor(r[0], r[1]) for r in zip(rotors, ring_settings)
]
self.rotors = rotor_list
self.rotor_count = len(rotors)
self.reflector = create_reflector(reflector)
self.plugboard = Plugboard(plugboard_settings)
def __init__(self, reflector, *rotors):
self._rotor_chain = RotorChain(reflector, *rotors)
self.plugboard = Plugboard()
self.__alpha_string_validator = Validator(
TypeValidator(str), LengthValidator(1, lambda x, y: x >= y),
AlphaValidator())
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)
r3 = Rotor('my rotor1', 'CEADFB', ring_setting=0) #, stepping='A')
r2 = Rotor('my rotor2', 'CADFEB', ring_setting=0) #, stepping='A')
r1 = Rotor('my rotor3', 'ADFBCE', ring_setting=0) #, stepping='A')
# zweite Version / rotiert
# 1 3 2 <- chaotisch
# 2 3 1 <- weniger chaotisch
r1 = Rotor('my rotor1', 'CEADFB', ring_setting=0) #, stepping='A')
r3 = Rotor('my rotor2', 'CADFEB', ring_setting=0) #, stepping='A')
r2 = Rotor('my rotor3', 'ADFBCE', ring_setting=0) #, stepping='A')
#reflector = Rotor('my reflector', 'FVPJIAOYEDRZXWGCTKUQSBNMHL')
reflector = Rotor('my reflector', 'CFAEDB')
#pb = Plugboard.from_key_sheet('AF CD EB')
pb = Plugboard()
machine = EnigmaMachine([r1, r2, r3], reflector, pb)
#machine = EnigmaMachine([r1], reflector, pb)
def mapper(text):
mapping = 'ENIGMA'
new_text = ""
for s in text:
new_text += mapping[ord(s) - ord('A')] + " "
return new_text
def test_female(msg):
female = []
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)
print "Decrypted:", decrypted
def setUp(self):
self.alph = Plugboard("ABCDEF")
* *
* ENIGMA MACHINE *
* *
-**********************-
AUTHORS: | ID:
-------- | -----
MATAN DAVIDIAN | 205509219
TOM DAMRI | 205770068
Tomer Leon | 312203003
Alex Kreinis | 312623218
DATE : 15.11.19
"""
e = Enigma()
p = Plugboard()
p.initials()
fast_configure = int(
input("FOR FAST CONFIGURE PRESS 0 FOR COSTUME CONFIGURE PRESS 1: "))
if fast_configure == 1:
configure = int(
input(
"Enter 1 to configure plug board, 0 to use the default plug board: "
))
if configure:
count = 0
match = input(
"Enter pairs - less than 10 pairs (for example: AB CD FK): "
).split()
for m in match:
if count > 10:
settings = Settings(ask_for_key())
user = User(ask_for_text())
print("Do you want set Enigma yourself? [yes/no]")
a = input()
while a.upper() not in ["YES", "NO"]:
print("You have to answer yes or no!")
a = input()
if a.upper() == "YES":
print(
"Be careful! If you make a mistake, you will have to start from the beginning!"
)
print("Provide your Plugboard set.")
connect = input()
Plugboard(connect).check_len_alphabet()
Plugboard(connect).repeat_alphabet()
print("Provide your first Rotor set.")
characteristic1 = input()
Rotor(characteristic1).check_len_alphabet()
Rotor(characteristic1).repeat_alphabet()
print("Provide your secound Rotor set.")
characteristic2 = input()
Rotor(characteristic2).check_len_alphabet()
Rotor(characteristic2).repeat_alphabet()
print("Provide your third Rotor set.")
characteristic3 = input()
Rotor(characteristic3).check_len_alphabet()
Rotor(characteristic3).repeat_alphabet()
print("Provide your Reflector set.")
reflect = input()
from enigma import Enigma
from plugboard import Plugboard
from reflector import Reflector
from rotor import Rotor
e1 = Enigma(rotors=[
Rotor(position=24, type="II"),
Rotor(position=13, type="I"),
Rotor(position=22, type="III")
],
plugboard=Plugboard([
('A', 'M'),
('F', 'I'),
('N', 'V'),
('P', 'S'),
('T', 'U'),
('W', 'Z'),
]),
reflector=Reflector("A")
)
e2 = Enigma(rotors=[
Rotor(position=24, type="II"),
Rotor(position=13, type="I"),
Rotor(position=22, type="III")
],
plugboard=Plugboard([
('A', 'M'),
('F', 'I'),
('N', 'V'),
('P', 'S'),
def test_nothingMapped():
plugboard = Plugboard()
for element in Alphabet.set:
assert plugboard[element] == element
def test_a_mapped_to_b(given, expected):
plugboard = Plugboard()
plugboard["A"] = "B"
