Пример #1
0
    def test_codifica_frase(self):
        rotor1 = enigma.Rotor(abecedario, rotor_types['I'][0], rotor_types['I'][1])
        rotor2 = enigma.Rotor(abecedario, rotor_types['I'][0], rotor_types['I'][1])
        rotor3 = enigma.Rotor(abecedario, rotor_types['I'][0], rotor_types['I'][1])
        reflector = enigma.Reflector(UKW)

        maquina = enigma.Enigma([rotor1, rotor2, rotor3], reflector=reflector, ini='ZAA')
        
        self.assertEqual(maquina.codifica("HOLA"), "LCHD")
        self.assertEqual(maquina.ini, "DAA")
Пример #2
0
    def test_creaEnigmaErrores(self):
        with self.assertRaises(AttributeError) as e:
            rotor = enigma.Rotor(abecedario, rotor_types['I'][0]+'Ñ', rotor_types['I'][1])

        rotor = enigma.Rotor(abecedario, rotor_types['I'][0], rotor_types['I'][1])
        rotor.ini = 'K'
        reflector = enigma.Reflector(conf=['ABC', 'CBA'])

        with self.assertRaises(AttributeError):
            maquina = enigma.Enigma(rotores=[rotor], reflector=reflector)
Пример #3
0
 def test_codificaOK_con_pos_ini(self):
     rotor = enigma.Rotor("ABCDEFG", "CFAGBDE")
     rotor.pos_ini = "C"
     self.assertEqual(rotor.pos_ini, "C")
     self.assertEqual(rotor._pos_ini, 2)
     self.assertEqual(rotor.codifica(0), 5)
     self.assertEqual(rotor.decodifica(4), 2)
Пример #4
0
    def test_creaEnigmaOk(self):
        rotor = enigma.Rotor(abecedario, rotor_types['I'][0], rotor_types['I'][1])
        rotor.ini = 'K'
        reflector = enigma.Reflector(conf=UKW)
        maquina = enigma.Enigma(rotores=[rotor], reflector=reflector)

        self.assertEqual(maquina.ini, "A")
        self.assertEqual(rotor.pos_ini, "A")
Пример #5
0
    def test_cambia_ini(self):
        rotor = enigma.Rotor(abecedario, rotor_types['I'][0], rotor_types['I'][1])
        rotor.ini = 'K'
        reflector = enigma.Reflector(conf=UKW)
        maquina = enigma.Enigma(rotores=[rotor], reflector=reflector, ini="C")

        self.assertEqual(maquina.ini, "C")
        self.assertEqual(maquina.rotores[0].pos_ini, "C")

        maquina.ini = "T"
        self.assertEqual(maquina.ini, "T")
        self.assertEqual(maquina.rotores[0].pos_ini, "T")
Пример #6
0
def test_RotorWiring(rotor_n, rings, pos, fwd_in, rev_in, fwd_out, rev_out):
    rotor = enigma.Rotor(rotor_n, rings, pos)
    if rotor.produceLetterOutput(
            fwd_in) == fwd_out and rotor.produceReverseOutput(
                rev_in) == rev_out:
        print('Test for rotor PASS')
    else:
        print('Test for rotor FAIL')
        print('## CORRECT OUTPUT\n' + fwd_out + '\n' + rev_out +
              '\n## ACTUAL OUTPUT')
        print(rotor.produceLetterOutput(fwd_in))
        print(rotor.produceReverseOutput(fwd_out))
    def test_rotor(self):
        rotor = enigma.Rotor(n_positions=10, seed=42)

        rotor.set_position(9)
        carryover = rotor.rotate_return_carryover(1)
        self.assertEqual(rotor.position, 0)
        self.assertEqual(carryover, 1)

        rotor.position = 6
        in_ = 7
        out = rotor.get_permuted_output_forward(in_)
        self.assertEqual(rotor.get_permuted_output_backward(out), in_)

        rotor.rotate_return_carryover(1)
        out2 = rotor.get_permuted_output_forward(in_)
        self.assertNotEqual(out, out2)
    def setup_enigma_and_msg(self, len_msg, n_rotors, n_plugs):
        self.charset = string.ascii_lowercase
        self.n_chars = len(self.charset)

        self.reflector = enigma.Swapper(n_positions=self.n_chars)
        self.reflector.assign_random_swaps(n_swaps=self.n_chars // 2, seed=3)

        rotor_seeds = list(range(n_rotors))
        self.rotors = [
            enigma.Rotor(n_positions=self.n_chars, seed=seed) for seed in rotor_seeds
        ]
        self.rotor_positions = n_rotors * [15]

        self.plugboard = enigma.Swapper(n_positions=self.n_chars)
        self.plugboard.assign_random_swaps(n_swaps=n_plugs, seed=41)

        message = (
            "The Enigma machine is a cipher device developed and used in the early- to mid-20th century to protect"
            " commercial, diplomatic, and military communication. It was employed extensively by Nazi Germany during "
            "World War II, in all branches of the German military. The Germans believed, erroneously, that use of the"
            " Enigma machine enabled them to communicate securely and thus enjoy a huge advantage in World War II. "
            "The Enigma machine was considered to be so secure that even the most top-secret messages were enciphered"
            " on its electrical circuits. Enigma has an electromechanical rotor mechanism that scrambles the 26 letters "
            "of the alphabet. In typical use, one person enters text on the Enigma's keyboard and another person writes"
            " down which of 26 lights above the keyboard lights up at each key press. If plain text is entered, the "
            "lit-up letters are the encoded ciphertext. Entering ciphertext transforms it back into readable plaintext. "
            "The rotor mechanism changes the electrical connections between the keys and the lights with each keypress. "
            "The security of the system depends on a set of machine settings that were generally changed daily during the "
            "war, based on secret key lists distributed in advance, and on other settings that were changed for "
            "each message. The receiving station has to know and use the exact settings employed by the transmitting "
            "station to successfully decrypt a message."
        )
        message = message.lower()
        self.message_full = "".join(c for c in message if c.islower())

        encoder = enigma.Enigma(
            self.rotors, self.plugboard, self.reflector, charset=self.charset
        )
        encoder.set_rotor_positions(self.rotor_positions)
        self.message = self.message_full[:len_msg]
        self.encrypted_message = encoder.encode_message(self.message)

        # reset all rotors so MC does not start with a good value
        encoder.set_rotor_positions(n_rotors * [0])
    def test_encrypt_decrypt(self):
        plugboard = enigma.Swapper(n_positions=self.n_chars)
        plugboard.assign_random_swaps(n_swaps=10, seed=41)
        rotor_seeds = [21, 32, 34]
        rotors = [
            enigma.Rotor(n_positions=self.n_chars, seed=seed) for seed in rotor_seeds
        ]
        reflector = enigma.Swapper(n_positions=self.n_chars)
        reflector.assign_random_swaps(n_swaps=self.n_chars // 2, seed=3)

        encoder = enigma.Enigma(rotors, plugboard, reflector, charset=self.charset)
        rotor_positions = [3, 4, 7]

        encoder.set_rotor_positions(rotor_positions)
        encoded_message = encoder.encode_message(self.test_message)
        self.assertNotEqual(encoded_message, self.test_message)

        encoder.set_rotor_positions(rotor_positions)
        decoded_message = encoder.encode_message(encoded_message)
        self.assertEqual(decoded_message, self.test_message)
Пример #10
0
 def test_codificaOK(self):
     rotor = enigma.Rotor("ABCDEFG", "CFAGBDE")
     self.assertEqual(rotor.codifica(0), 2)
     self.assertEqual(rotor.decodifica(4), 1)
Пример #11
0
 def test_construyeOK(self):
     rotor = enigma.Rotor("ABCDEFG", "CFAGBDE")
     self.assertEqual(rotor.abecedario, "ABCDEFG")
     self.assertEqual(rotor.cortocircuito, "CFAGBDE")
     self.assertEqual(rotor.pos_ini, "A") 
Пример #12
0
import enigma

machine = enigma.Enigma(enigma.Plugboard.STATIC_WIRING,
                        enigma.Rotor(1, 'A', 'A'), enigma.Rotor(2, 'A', 'A'),
                        enigma.Rotor(3, 'A', 'A'),
                        enigma.Reflector('REFLECTOR_B'))


def test_RotorWiring(rotor_n, rings, pos, fwd_in, rev_in, fwd_out, rev_out):
    rotor = enigma.Rotor(rotor_n, rings, pos)
    if rotor.produceLetterOutput(
            fwd_in) == fwd_out and rotor.produceReverseOutput(
                rev_in) == rev_out:
        print('Test for rotor PASS')
    else:
        print('Test for rotor FAIL')
        print('## CORRECT OUTPUT\n' + fwd_out + '\n' + rev_out +
              '\n## ACTUAL OUTPUT')
        print(rotor.produceLetterOutput(fwd_in))
        print(rotor.produceReverseOutput(fwd_out))


def test_letterToPosition(rotor, letter, good_out):
    t = machine.letterToPosition(rotor, letter)
    if t == good_out:
        print('Test for letterToPosition PASS')
    else:
        print('Test for letterToPosition FAIL')
        print('## CORRECT OUTPUT\n' + str(good_out) + '\n## ACTUAL OUTPUT')
        print(t)
 def test_codifica(self):
     rotor = enigma.Rotor()
     self.assertEqual(rotor.conexion(0, ["ABCD", "CABD"]), 1)
     self.assertEqual(rotor.conexion_decodifica(2, ["ABCD", "CABD"]), 1)
 def test_construye(self):
     rotor = enigma.Rotor()
     c = []
     self.assertEqual(
         rotor.crea_rotor(c),
         ['LQRWNZÑEPBXJVKFYHUMAOCDSTGI', 'VPZIDBNCGTHÑQJLORUAEKFSXYMW'])
import time
import string
import random
import tqdm

import enigma

n_messages = 3000
chars_per_message = 256
charset = string.ascii_uppercase
n_chars = len(charset)

plugboard = enigma.Swapper(n_positions=n_chars, n_swaps=10, seed=41)
rotor_seeds = [21, 32, 34]
rotors = [enigma.Rotor(n_positions=n_chars, seed=seed) for seed in rotor_seeds]
reflector = enigma.Swapper(n_positions=n_chars, n_swaps=n_chars // 2, seed=3)

encoder = enigma.Enigma(rotors, plugboard, reflector, charset=charset)
rotor_positions = [3, 4, 7]

messages = [
    "".join(random.choices(charset, k=chars_per_message))
    for _ in range(n_messages)
]
tick = time.time()
for message in tqdm.tqdm(messages):
    encoder.set_rotor_positions(rotor_positions)
    encoded_message = encoder.encode_message(message)
tock = time.time()

avg_time = (tock - tick) / n_messages