Реализация ассиметричного алгоритма шифроваия.

import random
import math
# import rsa
 
 
# Проверка числа на простоту
def isPrime(n):
    if n % 2 == 0:
        return n == 2
    
    j = 3
    while j * j <= n:
        if n % j == 0:
            return False
            
        j += 2
        
    return True
 
 
# Ищем все простые числа в определенном диапазоне
def arr_prime_number(start_prime, end_prime):
    
    if start_prime % 2 == 0:
        start_prime += 1
        
    arr_prime = []
    
    for elem in range(start_prime, end_prime, 2):
        if isPrime(elem):
            arr_prime.append(elem)
            
    return arr_prime
 
 
# Генерируем открытый и закрытый ключи
def generate_keys():
    
    # Установим диапазон поиска простых чисел равным 1 000
    # В действительности простые числа должны быть очень большими,
    # чтобы их было сложно взломать.
    arr_prime = arr_prime_number(5_000, 6_000)
    len_arr_prime = len(arr_prime)
    
    # Выбираем два любых простых числа
    p = arr_prime[random.randint(0, len_arr_prime - 1)]
    q = arr_prime[random.randint(0, len_arr_prime - 1)]
    
    # Вычисляем модуль чисел
    n = p * q
    
    # Вычисляем функцию Эйлера
    a_f = (p - 1) * (q - 1)
    
    # Генерируем простые числа меньшие функции Эйлера
    # Т.к. a_f - может быть достаточно большим, 
    # то не будем генерировать много чисел
    arr_prime = arr_prime_number(a_f - 500, a_f - 1)
    
    # Выбираем первое простое число, меньшее функции Эйлера,
    # которое является взаимно простым с ней.
    # Оно будет первой частью (экспонентой) открытого ключа.
    for e in arr_prime:
        if math.gcd(e, a_f) == 1:
            break
    else:
        raise "Недостаточный диапазон для поиска экспоненты открытого ключа"
    
    # Выбираем первое число, которое при умножении
    # на экспоненту по модулю a_f даст в результате 1.
    # Первая составляющая закрытого (секретного) ключа. 
    for d in range(a_f):
        if (e * d) % a_f == 1:
            break
    else:
        raise "Недостаточный диапазон для поиска закрытого ключа"
                
    return ((e, n), (d, n))
 
 
# Функция поиска остатка от деления 
# при возведении числа в большую степень.
# Модульная арифметика.
def modpower(x, n, m):
    if n == 0: 
        return 1 % m
        
    u = modpower(x, int(n / 2), m)
    u = (u * u) % m
    if (n % 2 == 1):
        u = (u * x) % m
    return u
 
 
def encrypt_message(open_key, message):
    # Зашифруем сообщение с помощью открытого ключа
    p_o = open_key[0]
    m_o = open_key[1]
    
    # Переводим все буквы в числовые коды "Юникода".
    # Сделаем обманку. Добавим дополнительный символ
    # в начало сообщения. 
    # Число можно сформировать рандомно.
    # Перемешиваем числа.
    code_m = [98]
    for i in message:
        code_m.append((ord(i) + code_m[-1]) % m_o)
    
    # Шифруем сообщение
    message_code = []
    for i in code_m:
        message_code.append(modpower(i, p_o, m_o))
        
    message = list(map(hex, message_code))
        
    return message
    
    
def decrypt_message(close_key, message):
    # Расшифруем сообщение с помощью закрытого ключа
    p_c = close_key[0]
    m_c = close_key[1]
    
    message_code = [int(i, 16) for i in message]
    
    # Расшифровываем числа
    code_m = []
    for i in message_code:
        code_m.append(modpower(i, p_c, m_c))
    
    # Делаем операцию обратную перемешиванию.
    # Получаем их истинные числовые коды.
    message_code = []
    for i in range(1, len(code_m)):
        message_code.append(chr((code_m[i] - code_m[i - 1]) % m_c))
        
    return "".join(message_code)
    
    
def message_keyboard(open_key, close_key):
    message_code = input("Введите сообщение, которое надо закодировать: ")
    
    message_code = encrypt_message(open_key, message_code)
        
    print("Зашифрованное сообщение:")
    print(message_code)
    print()
    
    message_code = decrypt_message(close_key, message_code)
        
    print("Расшифрованное сообщение: ")
    print(message_code)
    
    
def message_file(open_key, close_key):
    with open("file1.txt", "rt", encoding = "utf-8") as file_read, open("file2.txt", "wt", encoding = "utf-8") as file_write:
        for line in file_read:
            message_code = encrypt_message(open_key, line)
            file_write.write(" ".join(message_code) + "\n")
    
    print()
    print("Зашифрованный текст находится в файле file2.txt")
    
    print()
    print("Расшифрованный текст файла file2.txt: ")
            
    with open("file2.txt", "rt", encoding = "utf-8") as file_read:
        for line in file_read:
            message_code = line.split()
            message = decrypt_message(close_key, message_code)
            print(message)
            
    
def main_not_rsa():
    # генерируем открытый и закрытый ключ.
    # Ключом open_key шифруем сообщения.
    # Ключом close_key расшифровываем.
    open_key, close_key = generate_keys()
    
    message_keyboard(open_key, close_key)
    
    message_file(open_key, close_key)
    
 
def main_rsa():
    # Пример с интернета с использованием библиотеки rsa,
    # основаных на очень больших простых числах.
    # Требуется установка через pip в виртуальное окружение.
    
    # Генерируем открытый и закрытый ключ.
    open_key, close_key = rsa.newkeys(512)
 
    # RSA работает только с байтами
    message = 'hello!'.encode('utf-8')
 
    # Шифруем сообщение публичным ключом
    crypto = rsa.encrypt(message, open_key)
 
    # Расшифровываем сообщение секретным ключом
    message = rsa.decrypt(crypto, close_key)
    print(message.decode('utf-8'))
    
    
if __name__ == "__main__":
    # main_rsa()
    main_not_rsa()