[Coding Interview] Implementierung der Enigma-Kryptografiemaschine (Python)

Einführung

Ich habe versucht, die Enigma-Verschlüsselungsmaschine zu implementieren, die Jun Sakai auf Youtube eingeführt hat. Der Grund für diese Codierung ist diesmal, dass ich mich auf die Syntax der Menschen im Silicon Valley beziehen und die objektive Implementierung üben wollte.

Sakais Youtube ist [hier](https://www.google.com/url?sa=t&rct=j&q=1esrc=s&source=web&cd=1cad=rja&uact=8&ved=2ahUKEwj45vTKnZPrAhVU_GEKHbb5C90Qwqs .com% 2Fwatch% 3Fv% 3Dv1rUoMZRjoQ & usg = AOvVaw2IjXcPc1wjhqag1_kef6Ul). Es war auch interessant, dass Herr Nakata von Oriraji an der Youtube University [hier] über Enigma erklärte (https://www.google.com/url?sa=t&rct=j&q½esrc=s&source=web&cd=1cad) = rja & uact = 8 & ved = 2ahUKEwiZs_uPnpPrAhVaPHAKHVqUCE0QwqsBMAB6BAgIEAQ & url = https% 3A% 2F% 2Fwww.youtube.com% 2Fwatch% 3Fv% 3D4zIXv1w3d80 & usg = Av

Fazit

Die Codierungsmethode war sehr hilfreich und hat in meiner Freizeit viel Spaß gemacht. Diesmal habe ich es tatsächlich geschafft, aber es war nicht genug, es auf Github zu veröffentlichen, und es war eine Verschwendung, es nicht zu veröffentlichen, also habe ich es als Artikel auf Qiita veröffentlicht. Der Code, den ich zuerst selbst implementiert habe, war etwas schmutzig. Wenn Sie möchten, lesen Sie ihn bitte, da ich den Code veröffentlichen werde, den ich beim Ansehen von Mr. Sakais Video implementiert habe.

Dateiorganisation

Die Dateistruktur ist wie folgt. Definieren Sie das Modell objektiv in enigma.py und erstellen Sie das Modell in main.py.

 egnima
    ├── enigma.py
    └── main.py

Enigma.py Erstellen Sie vier Klassen: PlugBoard, Rotate, Reflector und Enigma. Für Details von jedem denke ich, dass Sie sich auf Mr. Sakais Youtube oder Wiki beziehen sollten.

enigma.py

import string 

ALPHABET = string.ascii_uppercase


class PlugBoard(object):

    def __init__(self, map_alphabet):
        self.alphabet = ALPHABET
        self.forward_map = {}
        self.backward_map = {}
        self.mapping(map_alphabet)

    def mapping(self, map_alphabet):
        self.forward_map = dict(zip(self.alphabet, map_alphabet))
        self.backward_map = {v: k for k , v in self.forward_map.items()}

    def forward(self, index_num):
        char = self.alphabet[index_num]
        char = self.forward_map[char]
        return self.alphabet.index(char)

    def backward(self, index_num):
        char = self.alphabet[index_num]
        char = self.backward_map[char]
        return self.alphabet.index(char)


class Rotor(PlugBoard):

    def __init__(self, map_alphabet, offset=0):
        super().__init__(map_alphabet)
        self.offset = offset
        self.rotations = 0

    def rotate(self, offset=None):
        if offset is None:
            offset = self.offset
        self.alphabet = self.alphabet[offset:] + self.alphabet[:offset]
        self.rotations += offset
        return self.rotations

    def reset(self):
        self.rotationations = 0 
        self.alphabet = ALPHABET


class Reflector(object):

    def __init__(self, map_alphabet):
        self.map = dict(zip(ALPHABET, map_alphabet))
        for x, y in self.map.items():
            if x != self.map[y]:
                raise ValueError(x, y)


    def reflect(self, index_num):
        reflected_char = self.map[ALPHABET[index_num]]
        return ALPHABET.index(reflected_char)


class Enigam(object):

    def __init__(self, plug_board, rotors, reflector):
        self.plug_board = plug_board
        self.rotors = rotors
        self.reflector = reflector

    def encrypt(self, text):
        return ''.join([self.go_through(c) for c in list(text)])

    def decrypt(self, text):
        for rotor in self.rotors:
            rotor.reset()
        return ''.join([self.go_through(c) for c in list(text)])

    def go_through(self, char):
        char = char.upper()
        if char not in ALPHABET:
            return char

        index_num = ALPHABET.index(char)
        index_num = self.plug_board.forward(index_num)

        for rotor in self.rotors:
            index_num = rotor.forward(index_num)

        index_num = self.reflector.reflect(index_num)

        for rotor in reversed(self.rotors):
            index_num = rotor.backward(index_num)

        index_num = self.plug_board.backward(index_num)
        char = ALPHABET[index_num]

        for rotor in reversed(self.rotors):
            if rotor.rotate() % len(ALPHABET) != 0:
                break

        return char

main.py

main.py

import random
from enigma import PlugBoard, ALPHABET, Rotor, Reflector, Enigam

if __name__ == '__main__':
    # outputs : XYGBWNSCMQFJLHEVRIZODAPUTK
    get_random_alphabet = lambda : ''.join(
            random.sample(ALPHABET, len(ALPHABET)))

    p = PlugBoard(get_random_alphabet())
    r1 = Rotor(get_random_alphabet(), 3)
    r2 = Rotor(get_random_alphabet(), 2)
    r3 = Rotor(get_random_alphabet(), 1)

    # reflected alphabets list for the Rflection
    r = list(ALPHABET)
    indexes = [i for i in range(len(ALPHABET))]
    for _ in range(int(len(indexes)/2)):
        x = indexes.pop(random.randint(0, len(indexes)-1))
        y = indexes.pop(random.randint(0, len(indexes)-1))
        r[x], r[y] = r[y], r[x]

    reflector = Reflector(''.join(r))

    # Define Enigam
    machine = Enigam(
    p, [r1, r2, r3], reflector)
    text = 'PYTHON'
    encrypted = machine.encrypt(text)
    decrypted = machine.decrypt(encrypted)

    print(f'      Text     :  {text}')      #       Text     :  PYTHON
    print(f'Encrypted text : {encrypted}')  # Encrypted text : TDZXZS
    print(f'Decrypted text : {decrypted}')  # Decrypted text : PYTH


'''