def EnigmaTest():
enigma = Enigma("CAB", "BAC", "BCA")
print(enigma.encrypt('ABC') == 'AAA') # should ACB
print(enigma.decrypt('ACB') == 'CBA')
print(enigma.encrypt('CAB') == 'CCC')
print(enigma.decrypt('CAB') == 'AAA')
def main():
enigma1 = Enigma()
enigma2 = Enigma()
while True:
filename = input(
'Введите имя входного файла: '
)
outputname = input(
'Введите имя выходного файла: '
)
num = input(
'Какую энигму использовать?\n'
'1 - зашифровать\n'
'2 - дешифровать\n'
': '
)
file = open(filename, 'rb')
text = file.readlines()
output = open(outputname, 'wb')
file.close()
if num == '1':
for line in text:
output.write(bytes(enigma1.encrypt(code) for code in line))
elif num == '2':
for line in text:
output.write(bytes(enigma2.encrypt(code) for code in line))
output.close()
class SimpleMessageCipherTestCase(TestCase):
def setUp(self):
self.enigma = Enigma()
def test_enigma_encrypts_BC_as_JM(self):
self.assertEqual('JM', self.enigma.encrypt('BC'))
def test_enigma_encrypts_ABC_as_EJM(self):
self.assertEqual('EJM', self.enigma.encrypt('ABC'))
class TrivialLeftRotorBothWaysTestCase(TestCase):
def setUp(self):
self.enigma = Enigma(reflector='YRUHQSLDPXNGOKMIEBFZCWVJAT', rotor='ACDBFZQHIJKLMNOPGRSTUVWXYE')
def test_enigma_encrypts_G_as_Z(self):
self.assertEqual('Z', self.enigma.encrypt('G'))
def test_enigma_encrypts_alphabet_correctly(self):
self.assertEqual('YUHRSTZCPXNQOKMILDEFBWVJAG', self.enigma.encrypt('ABCDEFGHIJKLMNOPQRSTUVWXYZ'))
class TwoRotorsTestCase(TestCase):
def setUp(self):
self.enigma = Enigma(reflector='YRUHQSLDPXNGOKMIEBFZCWVJAT', rotor=['ACDBEFGHIJKLMNOPQRSTUVWXYZ', 'ACDBEFGHIJKLMNOPQRSTUVWXYZ'])
def test_enigma_encrypts_A_as_Y(self):
self.assertEqual('Y', self.enigma.encrypt('A'))
def test_enigma_encrypts_AB_as_YH(self):
self.assertEqual('YH', self.enigma.encrypt('AB'))
def test_enigma_encrypts_alphabet_correctly(self):
self.assertEqual('YHRUQSLBPXNGOKMIECFZDWVJAT', self.enigma.encrypt('ABCDEFGHIJKLMNOPQRSTUVWXYZ'))
class SingleLetterCipherTestCase(TestCase):
def setUp(self):
self.enigma = Enigma()
def test_enigma_encrypts_blank_as_blank(self):
self.assertEqual('', self.enigma.encrypt(''))
def test_enigma_encrypts_A_as_E(self):
self.assertEqual('E', self.enigma.encrypt('A'))
def test_enigma_encrypts_B_as_J(self):
self.assertEqual('J', self.enigma.encrypt('B'))
def test_enigma_encrypts_C_as_M(self):
self.assertEqual('M', self.enigma.encrypt('C'))
def main():
Config.readKeys()
enigma = Enigma(Config.setting('key1'), Config.setting('key2'),
Config.setting('key3'))
print('Enigma... Press Ctrl+D to stop')
print('Commands:\n encrypt <message>\n decrypt <message>')
try:
while True:
command = input('> ')
try:
spaceIndex = command.index(' ')
except:
print('Invalid command:')
print(
'Commands:\n encrypt <message>\n decrypt <message>')
continue
if command[:spaceIndex] == 'encrypt':
print(enigma.encrypt(command[spaceIndex + 1:]))
elif command[:spaceIndex] == 'decrypt':
print(enigma.decrypt(command[spaceIndex + 1:]))
else:
print('Invalid command')
print(
'Commands:\n encrypt <message>\n decrypt <message>')
except (EOFError, KeyboardInterrupt):
print() # Put the standard shell prompt on the next line
def test_same_characters_different_sequence(self, r1p: int, r2p: int,
r3p: int, repeated_char: str):
enigma = Enigma(r1_pos=r1p, r2_pos=r2p, r3_pos=r3p)
cipher_text = enigma.encrypt(repeated_char[0] * 26)
for test_char in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
self.assertNotEqual(cipher_text, test_char * 26)
self.assertEqual(repeated_char[0] * 26, enigma.decrypt(cipher_text))
class EnigmaTest(unittest.TestCase):
def setUp(self):
self.enigma1_rotorI = Rotor(list("ekmflgdqvzntowyhxuspaibrcj"),
turnover_notch=["q"])
self.enigma1_rotorII = Rotor(list("ajdksiruxblhwtmcqgznpyfvoe"),
turnover_notch=["e"])
self.enigma1_rotorIII = Rotor(list("bdfhjlcprtxvznyeiwgakmusqo"),
turnover_notch=["v"])
self.enigma1_wide_B_reflector = Reflector(
list("yruhqsldpxngokmiebfzcwvjat"))
self.my_enigma = Enigma(
self.enigma1_wide_B_reflector,
self.enigma1_rotorI,
self.enigma1_rotorII,
self.enigma1_rotorIII,
double_step=True,
)
def test_positions_getset(self):
""" Test set/get rotor positions """
for char1 in range(ord("a"), ord("z") + 1):
char1 = chr(char1)
for char2 in range(ord("a"), ord("z") + 1):
char2 = chr(char2)
for char3 in range(ord("a"), ord("z") + 1):
char3 = chr(char3)
self.my_enigma.set_position(char1 + char2 + char3)
self.assertEqual(
self.my_enigma.left_rotor.current_position(), char1)
self.assertEqual(
self.my_enigma.mid_rotor.current_position(), char2)
self.assertEqual(
self.my_enigma.right_rotor.current_position(), char3)
def test_encryption_decryption(self):
""" Test long_text.txt for mistakes in encryption/decryption """
with open("tests/test_lowercase.txt", "r") as f:
data = f.read()
self.my_enigma.set_position("AAA")
encrypted = self.my_enigma.encrypt(data)
self.my_enigma.set_position("AAA")
decrypted = self.my_enigma.encrypt(encrypted)
self.assertEqual(decrypted, data)
def EnigmaTest1():
enigma = Enigma("CAB", "BAC", "BCA")
messages = ['ABC', 'CAB', 'BCA']
for message in messages:
enigma.resetRotor()
encrypted_m = enigma.encrypt(message)
enigma.resetRotor()
print(enigma.decrypt(encrypted_m) == message)
class TrivialRotorBackwardsTestCase(TestCase):
def setUp(self):
self.enigma = Enigma(reflector='YRUHQSLDPXNGOKMIEBFZCWVJAT', rotor='ACDBEFGHIJKLMNOPQRSTUVWXYZ')
def test_enigma_encrypts_empty_string_as_empty_string(self):
self.assertEqual('', self.enigma.encrypt(''))
def test_enigma_encrypts_Y_as_A(self):
self.assertEqual('A', self.enigma.encrypt('Y'))
def test_enigma_encrypts_YR_as_AD(self):
self.assertEqual('AD', self.enigma.encrypt('YR'))
def test_enigma_encrypts_YRU_as_ADB(self):
self.assertEqual('ADB', self.enigma.encrypt('YRU'))
def test_enigma_encrypts_YRU_as_ADBC(self):
self.assertEqual('ADBC', self.enigma.encrypt('YRUH'))
class TrivialRotorTestCase(TestCase):
def setUp(self):
self.enigma = Enigma(reflector='YRUHQSLDPXNGOKMIEBFZCWVJAT', rotor='ACDBEFGHIJKLMNOPQRSTUVWXYZ')
def test_enigma_encrypts_empty_string_as_empty_string(self):
self.assertEqual('', self.enigma.encrypt(''))
def test_enigma_encrypts_A_as_Y(self):
self.assertEqual('Y', self.enigma.encrypt('A'))
def test_enigma_encrypts_AB_as_YU(self):
self.assertEqual('YU', self.enigma.encrypt('AB'))
def test_enigma_encrypts_ABC_as_YUH(self):
self.assertEqual('YUH', self.enigma.encrypt('ABC'))
def test_enigma_encrypts_ABCD_as_YUHR(self):
self.assertEqual('YUHR', self.enigma.encrypt('ABCD'))
def check_enigma(self,
plaintext: str,
r1p: int = 0,
r2p: int = 0,
r3p: int = 0):
enigma = Enigma(r1_pos=r1p, r2_pos=r2p, r3_pos=r3p)
cipher_text = enigma.encrypt(plaintext)
self.assertNotEqual(plaintext, cipher_text)
self.assertEqual(plaintext, enigma.decrypt(cipher_text))
def main():
if not argv[1] or not argv[2]:
print("1st arg - rotors number, 2nd - file name")
enigma = Enigma(int(argv[1]), BASE)
# save state here
state = enigma.get_state()
for i in range(len(state)):
state[i] = list(map(str, state[i]))
with open(ENIGMA_CONFIG, 'w') as file_state:
for lst in state:
file_state.write(" ".join(lst))
file_state.write("\n")
# files for results
file_name_encoded = "encoded_" + argv[2]
file_name_decoded = "decoded_" + argv[2]
# data to encrypt
data = read_from_bfile(argv[2])
if not data:
print("file is empty. nothing to encode")
return
# print("data to encrypt: ", data)
# encryption
result = enigma.encrypt(data)
write_to_bfile(file_name_encoded, result)
# print("encoded: ", result)
# decryption
# reset to initial state
config = read_config(int(argv[1]))
enigma.read_config(config, BASE)
data = read_from_bfile(file_name_encoded)
if not data:
print("file is empty. nothing to decode")
return
result = enigma.encrypt(data) #encrpt data again encrypt to descrypt
write_to_bfile(file_name_decoded, result)
def test_encrypting_message():
message = 'hello world'
key = '02715'
date = '040895'
enigma = Enigma()
outcome = enigma.encrypt(message, key, date)
expected = {'encryption': 'keder ohulw', 'key': '02715', 'date': '040895'}
assert outcome == expected
def test_encryption_with_special_chars():
message = '? : # * }'
key = '01020'
date = '010203'
enigma = Enigma()
outcome = enigma.encrypt(message, key, date)
expected = {'encryption': '?l:b#l*b}', 'key': '01020', 'date': '010203'}
assert expected == outcome
def test_encrypt_decrypt(self, r1p: int, r2p: int, r3p: int,
patch_key: str, rotor_selection: list,
reflector_selection: int, plaintext: str):
enigma = Enigma(r1_pos=r1p,
r2_pos=r2p,
r3_pos=r3p,
patch_key=patch_key,
rotor_selection=rotor_selection,
reflector_selection=reflector_selection)
cipher_text = enigma.encrypt(plaintext)
self.assertNotEqual(cipher_text, plaintext)
self.assertEqual(plaintext, enigma.decrypt(cipher_text))
def change_location():
try:
region = Repo.getRegion()
location = Enigma.encrypt(
request.args.get(
'region', region['countryName'] + "|" + region['countryCode']))
status = True if location != '|' else False
resp = make_response(jsonify({'status': status}))
resp.set_cookie('region', location)
return resp
except Exception as e:
return render('error', code=500, message=str(e))
class EnigmaTestCase(TestCase):
def setUp(self):
self.enigma = Enigma(reflector='ABCDEFGHIJKLMNOPQRSTUVWXYZ', rotor='ABCDEFGHIJKLMNOPQRSTUVWXYZ')
def test_enigma_stores_reflector_as_instance_variable(self):
enigma = Enigma(reflector='foo')
self.assertEqual('foo', enigma.reflector)
@patch('enigma.enigma.Enigma.reflect')
def test_enigma_reflector_used_during_encryption_when_present(self, mock_reflect):
self.enigma.encrypt('')
self.assertEqual(1, mock_reflect.call_count)
def test_enigma_stores_rotor_as_list_instance_variable(self):
enigma = Enigma(rotor='foo')
self.assertEqual(['foo'], enigma.rotor)
@patch('enigma.enigma.Enigma.rotate')
def test_enigma_rotor_used_during_encryption_when_present(self, mock_rotate):
self.enigma.encrypt('')
self.assertEqual(2, mock_rotate.call_count)
def detect_region():
region = request.cookies.get('region')
if region is None or Enigma.decrypt(request.cookies.get('region')) == '|':
reg = Repo.getLocation()
region = Enigma.encrypt('|'.join(
[reg.get('country_name'),
reg.get('country_code')]))
@after_this_request
def remember_region(response):
response.set_cookie('region', region)
g.region = region
def render(name, **kwargs):
location = Repo.getRegion()
integrity = Enigma.encrypt(request.remote_addr)
template = 'ajax/' + name if request.is_xhr else 'views/' + name
name = 'mobile/' + template if request.MOBILE is True else 'desktop/' + template
data = html_minify(
render_template(name + ".html", location=location, **kwargs))
if request.is_xhr:
for r in [
'<html>', '<head>', '</head>', '<body>', '</body>', '</html>'
]:
data = data.replace(r, '')
return data
def test_real_example(self):
plaintext = "DASOBERKOMMANDODERWEHRMAQTGIBTBEKANNTXAACHENXAACHENXISTGERETTETX" + \
"DURQGEBUENDELTENEINSATZDERHILFSKRAEFTEKONNTEDIEBEDROHUNGABGEWENDET" + \
"UNDDIERETTUNGDERSTADTGEGENXEINSXAQTXNULLXNULLXUHRSIQERGESTELLTWERDENX"
patch_key = 'DBNATLIHGVZFMCOUYRSEPJXWQK'
r1p = 16
r2p = 26
r3p = 8
enigma = Enigma(patch_key=patch_key,
rotor_selection=[0, 3, 2],
reflector_selection=1,
r1_pos=r1p,
r2_pos=r2p,
r3_pos=r3p)
cipher_text = enigma.encrypt(plaintext)
self.assertEqual(
'YTCBORYNCVSQAWDTMVVDMVVCLWSPNPVKLLWUIAVUVDAYUIWUTCZWMTDWUGBQZCJ' +
'ZBFJNBYQZVZPPTXDQJQQFMBXXFXPYEROURJPFNCUYDZOZMVGPEYJYKPHDLGKNOB' +
'TJGMMMEMVLOIWWOBTZNERYOJOWCDZLVEVVPYPHNSYNCQXKIAGOWVSEWPXPCMXPW' +
'APVYFHLYCK', cipher_text)
self.assertEqual(plaintext, enigma.decrypt(cipher_text))
class SingleLetterCipherTestCase(TestCase):
def setUp(self):
self.enigma = Enigma()
def test_enigma_encrypts_blank_as_blank(self):
self.assertEqual('', self.enigma.encrypt(''))
('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'),
('T', 'U'),
('W', 'Z'),
]),
reflector=Reflector("A")
)
input_string = "Hello"
print(f"Input: {input_string}")
encrypted_string = e1.encrypt(input_string)
print(f"Encrypted: {encrypted_string}")
answer_string = e2.decrypt(encrypted_string)
print(f"Answer: {answer_string}")
