[Entretien de codage] Implémentation de la machine cryptographique Enigma (Python)

introduction

J'ai essayé d'implémenter la machine de cryptage Enigma que Jun Sakai a présentée sur Youtube. La raison de ce codage cette fois-ci est que je voulais me référer à la syntaxe des gens de la Silicon Valley et pratiqué une implémentation objective.

Le YouTube de Sakai est [ici](https://www.google.com/url?sa=t&rct=j&q=1esrc=s&source=web&cd=1cad=rja&uact=8&ved=2ahUKEwj45vTKnZPrAhVU_GEKHbb5C90QwqsAhVU_GEKHbb5C90QwqsBMAF&BMAF6BAp .com% 2Fwatch% 3Fv% 3Dv1rUoMZRjoQ & usg = AOvVaw2IjXcPc1wjhqag1_kef6Ul). En outre, il était intéressant que M. Nakata d'Oriraji ait expliqué Enigma à l'Université Youtube [ici](https://www.google.com/url?sa=t&rct=j&q=1esrc=s&source=web&cd=1cad = rja & uact = 8 & ved = 2ahUKEwiZs_uPnpPrAhVaPHAKHVqUCE0QwqsBMAB6BAgIEAQ & url = https% 3A% 2F% 2Fwww.youtube.com% 2Fwatch% 3Fv% 3D4zIXv1w3d80 & usg = Av0

Conclusion

La méthode de codage était très utile et c'était très amusant à faire pendant mon temps libre. Je l'ai fait cette fois, mais ce n'était pas suffisant de le publier sur Github, et c'était un gaspillage de ne pas le poster, alors je l'ai posté comme un article de Qiita. Le code que j'ai implémenté en premier par moi-même était un peu sale, alors veuillez vous y référer si vous le souhaitez car je mettrai le code que j'ai implémenté ci-dessous en regardant la vidéo de M. Sakai.

organisation des fichiers

La structure des fichiers est la suivante. Définissez le modèle objectivement dans enigma.py et construisez le modèle dans main.py.

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

Enigma.py Créez quatre classes: PlugBoard, Rotate, Reflector et Enigma. Pour plus de détails sur chacun, je pense que vous devriez vous référer au Youtube ou au Wiki de M. Sakai.

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


'''