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}")