Python-Encryption/decoder.py at main · Timour-Ilyas/Python-Encryption · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
import threading
import queue


class Decoder:
    def __init__(self):
        self.__decryption_options = ["Caesar", "Vigenere", "Symmetric"]
        self.__decryption_functions = [self.caesar, self.vigenere]

    def decipher(self, decryption_chosed: str, message: str, key):
        for i, option in enumerate(self.__decryption_options):
            if decryption_chosed == option:
                return self.__decryption_functions[i](message, key)
                # Understand why there is a warning here: Unexpected argument(s)

    def caesar(self, secret_message: str, key):
        que = queue.Queue()
        if len(secret_message) < 10:  # 1 thread
            return self.__caesar_decrypter(secret_message, key, que)

        splitted_secret_message = []
        threads_list = []
        message = ""
        if len(secret_message) < 25:  # 2 threads
            number_of_divisions = 2

        else:  # 3 threads
            number_of_divisions = 3

        division_sentinel = -(len(secret_message) // -number_of_divisions)
        for index in range(number_of_divisions):
            splitted_secret_message.append(secret_message[0:division_sentinel])
            secret_message = secret_message[division_sentinel:]
            threads_list.append(
                threading.Thread(target=self.__caesar_decrypter, args=(splitted_secret_message[index], key, que)))
            threads_list[index].start()

        for index in range(len(splitted_secret_message)):
            threads_list[index].join()
            message += que.get()

        return message

    @staticmethod
    def __caesar_decrypter(secret_message, key, que):
        message = ""
        for character in secret_message:
            if 'A' <= character <= 'Z':
                delta = ord(character) - ord('A') - int(key)
                delta = delta % 26
                message = message + chr(delta + ord('A'))
            elif 'a' <= character <= 'z':
                delta = ord(character) - ord('a') - int(key)
                delta = delta % 26
                message = message + chr(delta + ord('a'))
            elif character > chr(0):
                message += character

        que.put(message)
        return message

    def vigenere(self, secret_message: str, key):
        que = queue.Queue()
        if len(secret_message) < 10:  # 1 thread
            return self.__vigenere_decrypter(secret_message, key, que)

        splitted_message = []
        threads_list = []
        message = ""
        if len(secret_message) < 25:  # 2 threads
            number_of_divisions = 2

        else:  # 3 threads
            number_of_divisions = 3

        division_sentinel = -(len(secret_message) // -number_of_divisions)
        for index in range(number_of_divisions):
            splitted_message.append(secret_message[0:division_sentinel])
            secret_message = secret_message[division_sentinel:]
            threads_list.append(
                threading.Thread(target=self.__vigenere_decrypter, args=(splitted_message[index], key, que)))
            key = key[division_sentinel % len(key):] + key[0:division_sentinel % len(key)]
            threads_list[index].start()

        for index in range(len(splitted_message)):
            threads_list[index].join()
            message += que.get()

        return message

    @staticmethod
    def __vigenere_decrypter(secret_message, key, que):
        message = ""
        key = list(key)
        for i, character in enumerate(secret_message):
            if 'A' <= character <= 'Z':
                delta = ord(character) - ord('A') - (ord(key[i % len(key)]) - ord('A') + 1)
                delta = delta % 26
                message = message + chr(delta + ord('A'))
            elif 'a' <= character <= 'z':
                delta = ord(character) - ord('a') - (ord(key[i % len(key)]) - ord('a') + 1)
                delta = delta % 26
                message += chr(delta + ord('a'))
            elif character > chr(0):
                message += character

        que.put(message)
        return message

    def get_decryption_options(self, option: int = None):
        if option is not None:
            return self.__decryption_options[option]
        return self.__decryption_options