From 1cbf25e297b4d95ed5e94134d31240f2c9545ea7 Mon Sep 17 00:00:00 2001 From: Yaroslav Date: Mon, 22 Sep 2025 19:38:56 +0400 Subject: [PATCH 1/5] =?UTF-8?q?=D0=BD=D0=B0=D1=87=D0=B0=D0=BB=D0=BE?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lab_3/asymmetrical.py | 59 +++++++++++++++++++++++++++ lab_3/file_processing.py | 88 ++++++++++++++++++++++++++++++++++++++++ lab_3/input.txt | 1 + 3 files changed, 148 insertions(+) create mode 100644 lab_3/asymmetrical.py create mode 100644 lab_3/file_processing.py create mode 100644 lab_3/input.txt diff --git a/lab_3/asymmetrical.py b/lab_3/asymmetrical.py new file mode 100644 index 000000000..5432557ed --- /dev/null +++ b/lab_3/asymmetrical.py @@ -0,0 +1,59 @@ +from cryptography.hazmat.primitives import hashes +from cryptography.hazmat.primitives.asymmetric import padding +from typing import Any + + +class RSACrypto: + """Обработчик RSA шифрования для защиты ключей""" + + @staticmethod + def rsa_encrypt(public_key: Any, data: bytes) -> bytes: + """ + Шифрует данные RSA публичным ключом + Использует OAEP padding для надежности + """ + try: + print("Начинаем RSA шифрование...") + + encrypted = public_key.encrypt( + data, + padding.OAEP( + mgf=padding.MGF1(algorithm=hashes.SHA256()), + algorithm=hashes.SHA256(), + label=None + ) + ) + + print("RSA шифрование завершено") + return encrypted + + except ValueError as e: + print(f"Слишком много данных для RSA: {e}") + raise + except Exception as e: + print(f"Ошибка RSA шифрования: {e}") + raise + + @staticmethod + def rsa_decrypt(private_key: Any, encrypted_data: bytes) -> bytes: + """ + Расшифровывает данные RSA приватным ключом + """ + try: + print("Начинаем RSA дешифрование...") + + decrypted = private_key.decrypt( + encrypted_data, + padding.OAEP( + mgf=padding.MGF1(algorithm=hashes.SHA256()), + algorithm=hashes.SHA256(), + label=None + ) + ) + + print("RSA дешифрование завершено") + return decrypted + + except Exception as e: + print(f"Ошибка RSA дешифрования: {e}") + raise \ No newline at end of file diff --git a/lab_3/file_processing.py b/lab_3/file_processing.py new file mode 100644 index 000000000..f19d6b984 --- /dev/null +++ b/lab_3/file_processing.py @@ -0,0 +1,88 @@ +import json +from cryptography.hazmat.primitives import serialization +from cryptography.hazmat.primitives.serialization import load_pem_public_key, load_pem_private_key + + +class FileManager: + """Управление файловыми операциями""" + + @staticmethod + def read_file(filename): + """Читает файл""" + try: + with open(filename, 'rb') as f: + return f.read() + except FileNotFoundError: + print(f"Файл не найден: {filename}") + raise + except Exception as e: + print(f"Ошибка чтения файла: {e}") + raise + + @staticmethod + def write_file(filename, data): + """Записывает данные в файл""" + try: + with open(filename, 'wb') as f: + f.write(data) + print(f"Данные сохранены в: {filename}") + except Exception as e: + print(f"Ошибка записи файла: {e}") + raise + + @staticmethod + def load_config(config_path): + """Загружает конфигурацию""" + try: + with open(config_path, 'r', encoding='utf-8') as f: + return json.load(f) + except Exception as e: + print(f"Ошибка загрузки конфигурации: {e}") + raise + + @staticmethod + def save_public_key(key, filename): + """Сохраняет публичный ключ""" + try: + pem_data = key.public_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PublicFormat.SubjectPublicKeyInfo + ) + FileManager.write_file(filename, pem_data) + except Exception as e: + print(f"Ошибка сохранения публичного ключа: {e}") + raise + + @staticmethod + def save_private_key(key, filename): + """Сохраняет приватный ключ""" + try: + pem_data = key.private_bytes( + encoding=serialization.Encoding.PEM, + format=serialization.PrivateFormat.TraditionalOpenSSL, + encryption_algorithm=serialization.NoEncryption() + ) + FileManager.write_file(filename, pem_data) + except Exception as e: + print(f"Ошибка сохранения приватного ключа: {e}") + raise + + @staticmethod + def load_public_key(filename): + """Загружает публичный ключ""" + try: + key_data = FileManager.read_file(filename) + return load_pem_public_key(key_data) + except Exception as e: + print(f"Ошибка загрузки публичного ключа: {e}") + raise + + @staticmethod + def load_private_key(filename): + """Загружает приватный ключ""" + try: + key_data = FileManager.read_file(filename) + return load_pem_private_key(key_data, password=None) + except Exception as e: + print(f"Ошибка загрузки приватного ключа: {e}") + raise \ No newline at end of file diff --git a/lab_3/input.txt b/lab_3/input.txt new file mode 100644 index 000000000..dbc9ebd62 --- /dev/null +++ b/lab_3/input.txt @@ -0,0 +1 @@ +В современном мире, где ежесекундно передаются терабайты конфиденциальных данных, шифрование стало фундаментом информационной безопасности. От переписки в мессенджерах до банковских транзакций — криптографические алгоритмы работают как невидимые защитники, превращая информацию в недоступный для злоумышленников код. Современные методы шифрования делятся на два основных типа. Симметричное шифрование, представленное алгоритмами AES-256 и ChaCha20, использует единый ключ для кодирования и расшифровки данных. Оно исключительно быстрое и эффективное, поэтому применяется для защиты жестких дисков, VPN-соединений и потокового видео. Асимметричное шифрование (RSA, ECC) работает с парой ключей — публичным и приватным, решая проблему безопасного обмена ключами через ненадежные каналы связи. Именно эта технология лежит в основе HTTPS-соединений, цифровых подписей и блокчейн-систем. Особую важность сегодня приобретает гибридное шифрование, сочетающее преимущества обоих подходов. В таких системах асимметричные алгоритмы защищают передачу симметричных ключей, которые затем шифруют основной поток данных. Эта технология защищает корпоративную переписку, облачные хранилища и государственные коммуникации. С развитием квантовых вычислений криптографы уже работают над алгоритмами постквантового шифрования, способными противостоять принципиально новым угрозам. Шифрование продолжает эволюционировать, оставаясь на передовой борьбы за конфиденциальность в цифровом мире. \ No newline at end of file From 8fc147194d802e39fe13c6d4f778a99a262fb04b Mon Sep 17 00:00:00 2001 From: Yaroslav Date: Mon, 22 Sep 2025 19:50:55 +0400 Subject: [PATCH 2/5] =?UTF-8?q?AES=20=D1=88=D0=B8=D1=84=D1=80=D0=BE=D0=B2?= =?UTF-8?q?=D0=B0=D0=BD=D0=B8=D0=B5?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lab_3/generate_keys.py | 42 +++++++++++++++++++++++ lab_3/symmetrical.py | 77 ++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 119 insertions(+) create mode 100644 lab_3/generate_keys.py create mode 100644 lab_3/symmetrical.py diff --git a/lab_3/generate_keys.py b/lab_3/generate_keys.py new file mode 100644 index 000000000..f6bb9c371 --- /dev/null +++ b/lab_3/generate_keys.py @@ -0,0 +1,42 @@ +from cryptography.hazmat.primitives.asymmetric import rsa +from asymmetrical import RSACrypto +from symmetrical import AESCrypto + + +class KeyManager: + """Управление генерацией и защитой ключей""" + + @staticmethod + def generate_key_pair(key_size=2048): + """Создает пару RSA ключей""" + print("Генерируем RSA ключи...") + + private_key = rsa.generate_private_key( + public_exponent=65537, + key_size=key_size + ) + public_key = private_key.public_key() + + print(f"RSA-{key_size} ключи созданы") + return public_key, private_key + + @staticmethod + def generate_aes_key(): + """Создает AES ключ и IV""" + print("Генерируем AES ключ...") + + aes_key = AESCrypto.create_aes_key(32) # AES-256 + iv = AESCrypto.create_iv() + + print("AES ключ и IV созданы") + return aes_key, iv + + @staticmethod + def protect_aes_key(public_key, aes_key): + """Защищает AES ключ RSA шифрованием""" + + encrypted_key = RSACrypto.rsa_encrypt(public_key, aes_key) + print("AES ключ защищен") + + return encrypted_key + diff --git a/lab_3/symmetrical.py b/lab_3/symmetrical.py new file mode 100644 index 000000000..0c4b83466 --- /dev/null +++ b/lab_3/symmetrical.py @@ -0,0 +1,77 @@ +import os +from cryptography.hazmat.backends import default_backend +from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes +from cryptography.hazmat.primitives import padding + + +class AESCrypto: + """AES шифрование с CBC режимом для данных""" + + @staticmethod + def create_iv(): + """Создает случайный вектор инициализации""" + return os.urandom(16) + + @staticmethod + def create_aes_key(key_size=32): + """Генерирует AES ключ нужного размера""" + if key_size not in [16, 24, 32]: + raise ValueError("Допустимые размеры ключа: 16, 24, 32 байта") + return os.urandom(key_size) + + @staticmethod + def encrypt_data(data: bytes, key: bytes, iv: bytes = None) -> tuple: + """ + Шифрует данные AES-256 в режиме CBC + Возвращает (шифротекст, iv) + """ + try: + if iv is None: + iv = AESCrypto.create_iv() + + if len(key) not in [16, 24, 32]: + raise ValueError("Неверный размер AES ключа") + + cipher = Cipher( + algorithms.AES(key), + modes.CBC(iv), + backend=default_backend() + ) + + padder = padding.PKCS7(128).padder() + padded_data = padder.update(data) + padder.finalize() + + encryptor = cipher.encryptor() + ciphertext = encryptor.update(padded_data) + encryptor.finalize() + + print("AES шифрование успешно") + return ciphertext, iv + + except Exception as e: + print(f"Ошибка AES шифрования: {e}") + raise + + @staticmethod + def decrypt_data(ciphertext: bytes, key: bytes, iv: bytes) -> bytes: + """ + Расшифровывает данные AES + """ + try: + cipher = Cipher( + algorithms.AES(key), + modes.CBC(iv), + backend=default_backend() + ) + + decryptor = cipher.decryptor() + padded_data = decryptor.update(ciphertext) + decryptor.finalize() + + unpadder = padding.PKCS7(128).unpadder() + plaintext = unpadder.update(padded_data) + unpadder.finalize() + + print("AES дешифрование успешно") + return plaintext + + except Exception as e: + print(f"Ошибка AES дешифрования: {e}") + raise \ No newline at end of file From e729930ee649f5a3c39bdb08d59033bc2be19ce6 Mon Sep 17 00:00:00 2001 From: Yaroslav Date: Mon, 22 Sep 2025 20:10:58 +0400 Subject: [PATCH 3/5] =?UTF-8?q?=D0=BE=D1=81=D0=BD=D0=BE=D0=B2=D0=BD=D0=B0?= =?UTF-8?q?=D1=8F=20=D1=87=D0=B0=D1=81=D1=82=D1=8C?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lab_3/config.json | 9 ++++ lab_3/decrypted.txt | 1 + lab_3/encrypted.bin | Bin 0 -> 2720 bytes lab_3/iv.bin | 1 + lab_3/main.py | 111 ++++++++++++++++++++++++++++++++++++++++++++ lab_3/private.pem | 27 +++++++++++ lab_3/public.pem | 9 ++++ lab_3/symmetric.bin | 1 + 8 files changed, 159 insertions(+) create mode 100644 lab_3/config.json create mode 100644 lab_3/decrypted.txt create mode 100644 lab_3/encrypted.bin create mode 100644 lab_3/iv.bin create mode 100644 lab_3/main.py create mode 100644 lab_3/private.pem create mode 100644 lab_3/public.pem create mode 100644 lab_3/symmetric.bin diff --git a/lab_3/config.json b/lab_3/config.json new file mode 100644 index 000000000..ba0a6beec --- /dev/null +++ b/lab_3/config.json @@ -0,0 +1,9 @@ +{ + "source_file": "input.txt", + "encrypted_file": "encrypted.bin", + "decrypted_file": "decrypted.txt", + "encrypted_key_file": "symmetric.bin", + "public_key_file": "public.pem", + "private_key_file": "private.pem", + "iv_file": "iv.bin" +} \ No newline at end of file diff --git a/lab_3/decrypted.txt b/lab_3/decrypted.txt new file mode 100644 index 000000000..dbc9ebd62 --- /dev/null +++ b/lab_3/decrypted.txt @@ -0,0 +1 @@ +В современном мире, где ежесекундно передаются терабайты конфиденциальных данных, шифрование стало фундаментом информационной безопасности. От переписки в мессенджерах до банковских транзакций — криптографические алгоритмы работают как невидимые защитники, превращая информацию в недоступный для злоумышленников код. Современные методы шифрования делятся на два основных типа. Симметричное шифрование, представленное алгоритмами AES-256 и ChaCha20, использует единый ключ для кодирования и расшифровки данных. Оно исключительно быстрое и эффективное, поэтому применяется для защиты жестких дисков, VPN-соединений и потокового видео. Асимметричное шифрование (RSA, ECC) работает с парой ключей — публичным и приватным, решая проблему безопасного обмена ключами через ненадежные каналы связи. Именно эта технология лежит в основе HTTPS-соединений, цифровых подписей и блокчейн-систем. Особую важность сегодня приобретает гибридное шифрование, сочетающее преимущества обоих подходов. В таких системах асимметричные алгоритмы защищают передачу симметричных ключей, которые затем шифруют основной поток данных. Эта технология защищает корпоративную переписку, облачные хранилища и государственные коммуникации. С развитием квантовых вычислений криптографы уже работают над алгоритмами постквантового шифрования, способными противостоять принципиально новым угрозам. Шифрование продолжает эволюционировать, оставаясь на передовой борьбы за конфиденциальность в цифровом мире. \ No newline at end of file diff --git a/lab_3/encrypted.bin b/lab_3/encrypted.bin new file mode 100644 index 0000000000000000000000000000000000000000..1b084a85ec5aafe699b98089e2003cb4f6888cd3 GIT binary patch literal 2720 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:4^$\MPQEaL⳪ Z; Date: Tue, 23 Sep 2025 20:40:39 +0400 Subject: [PATCH 4/5] PEP8 --- lab_3/asymmetrical.py | 1 + lab_3/file_processing.py | 7 +++++++ lab_3/generate_keys.py | 2 ++ lab_3/main.py | 4 ++++ lab_3/symmetrical.py | 4 ++++ 5 files changed, 18 insertions(+) diff --git a/lab_3/asymmetrical.py b/lab_3/asymmetrical.py index 5432557ed..624f0c5c8 100644 --- a/lab_3/asymmetrical.py +++ b/lab_3/asymmetrical.py @@ -34,6 +34,7 @@ def rsa_encrypt(public_key: Any, data: bytes) -> bytes: print(f"Ошибка RSA шифрования: {e}") raise + @staticmethod def rsa_decrypt(private_key: Any, encrypted_data: bytes) -> bytes: """ diff --git a/lab_3/file_processing.py b/lab_3/file_processing.py index f19d6b984..bd70f59a3 100644 --- a/lab_3/file_processing.py +++ b/lab_3/file_processing.py @@ -1,4 +1,5 @@ import json + from cryptography.hazmat.primitives import serialization from cryptography.hazmat.primitives.serialization import load_pem_public_key, load_pem_private_key @@ -19,6 +20,7 @@ def read_file(filename): print(f"Ошибка чтения файла: {e}") raise + @staticmethod def write_file(filename, data): """Записывает данные в файл""" @@ -30,6 +32,7 @@ def write_file(filename, data): print(f"Ошибка записи файла: {e}") raise + @staticmethod def load_config(config_path): """Загружает конфигурацию""" @@ -40,6 +43,7 @@ def load_config(config_path): print(f"Ошибка загрузки конфигурации: {e}") raise + @staticmethod def save_public_key(key, filename): """Сохраняет публичный ключ""" @@ -53,6 +57,7 @@ def save_public_key(key, filename): print(f"Ошибка сохранения публичного ключа: {e}") raise + @staticmethod def save_private_key(key, filename): """Сохраняет приватный ключ""" @@ -67,6 +72,7 @@ def save_private_key(key, filename): print(f"Ошибка сохранения приватного ключа: {e}") raise + @staticmethod def load_public_key(filename): """Загружает публичный ключ""" @@ -77,6 +83,7 @@ def load_public_key(filename): print(f"Ошибка загрузки публичного ключа: {e}") raise + @staticmethod def load_private_key(filename): """Загружает приватный ключ""" diff --git a/lab_3/generate_keys.py b/lab_3/generate_keys.py index f6bb9c371..e8802bca8 100644 --- a/lab_3/generate_keys.py +++ b/lab_3/generate_keys.py @@ -20,6 +20,7 @@ def generate_key_pair(key_size=2048): print(f"RSA-{key_size} ключи созданы") return public_key, private_key + @staticmethod def generate_aes_key(): """Создает AES ключ и IV""" @@ -31,6 +32,7 @@ def generate_aes_key(): print("AES ключ и IV созданы") return aes_key, iv + @staticmethod def protect_aes_key(public_key, aes_key): """Защищает AES ключ RSA шифрованием""" diff --git a/lab_3/main.py b/lab_3/main.py index 1a5bd713c..0a64146b8 100644 --- a/lab_3/main.py +++ b/lab_3/main.py @@ -1,4 +1,5 @@ import argparse + from generate_keys import KeyManager from file_processing import FileManager from asymmetrical import RSACrypto @@ -11,6 +12,7 @@ class CryptoSystem: def __init__(self, config_path): self.config = FileManager.load_config(config_path) + def generate_keys(self): """Генерирует все необходимые ключи""" print("\n" + "=" * 50) @@ -30,6 +32,7 @@ def generate_keys(self): print("Все ключи успешно созданы и сохранены!") + def encrypt_file(self): """Шифрует файл""" print("\n" + "=" * 50) @@ -53,6 +56,7 @@ def encrypt_file(self): print("Файл успешно зашифрован!") + def decrypt_file(self): """Расшифровывает файл""" print("\n" + "=" * 50) diff --git a/lab_3/symmetrical.py b/lab_3/symmetrical.py index 0c4b83466..12b4d989c 100644 --- a/lab_3/symmetrical.py +++ b/lab_3/symmetrical.py @@ -1,4 +1,5 @@ import os + from cryptography.hazmat.backends import default_backend from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes from cryptography.hazmat.primitives import padding @@ -12,6 +13,7 @@ def create_iv(): """Создает случайный вектор инициализации""" return os.urandom(16) + @staticmethod def create_aes_key(key_size=32): """Генерирует AES ключ нужного размера""" @@ -19,6 +21,7 @@ def create_aes_key(key_size=32): raise ValueError("Допустимые размеры ключа: 16, 24, 32 байта") return os.urandom(key_size) + @staticmethod def encrypt_data(data: bytes, key: bytes, iv: bytes = None) -> tuple: """ @@ -51,6 +54,7 @@ def encrypt_data(data: bytes, key: bytes, iv: bytes = None) -> tuple: print(f"Ошибка AES шифрования: {e}") raise + @staticmethod def decrypt_data(ciphertext: bytes, key: bytes, iv: bytes) -> bytes: """ From 6daaca844a9c906d898e9a98671ec8d854793936 Mon Sep 17 00:00:00 2001 From: Yaroslav Date: Thu, 25 Sep 2025 21:14:46 +0400 Subject: [PATCH 5/5] =?UTF-8?q?=D0=B4=D0=BE=D0=BA=D1=81=D1=82=D1=80=D0=B8?= =?UTF-8?q?=D0=BD=D0=B3=D0=B8?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- lab_3/asymmetrical.py | 13 ++++++++++--- lab_3/file_processing.py | 42 +++++++++++++++++++++++++++++++++------- lab_3/generate_keys.py | 13 +++++++++++-- lab_3/symmetrical.py | 15 ++++++++++++-- 4 files changed, 69 insertions(+), 14 deletions(-) diff --git a/lab_3/asymmetrical.py b/lab_3/asymmetrical.py index 624f0c5c8..ed13444c0 100644 --- a/lab_3/asymmetrical.py +++ b/lab_3/asymmetrical.py @@ -9,8 +9,11 @@ class RSACrypto: @staticmethod def rsa_encrypt(public_key: Any, data: bytes) -> bytes: """ - Шифрует данные RSA публичным ключом - Использует OAEP padding для надежности + Шифрует данные RSA публичным ключом. + Использует OAEP padding с SHA256 для надежности. + :param public_key: публичный ключ + :param data: данные для шифрования + :return: зашифрованные данные """ try: print("Начинаем RSA шифрование...") @@ -38,8 +41,12 @@ def rsa_encrypt(public_key: Any, data: bytes) -> bytes: @staticmethod def rsa_decrypt(private_key: Any, encrypted_data: bytes) -> bytes: """ - Расшифровывает данные RSA приватным ключом + Расшифровывает данные RSA приватным ключом + :param private_key: приватный ключ + :param encrypted_data: зашифрованные данные + :return: расшифрованные данные """ + try: print("Начинаем RSA дешифрование...") diff --git a/lab_3/file_processing.py b/lab_3/file_processing.py index bd70f59a3..97d6d3f5d 100644 --- a/lab_3/file_processing.py +++ b/lab_3/file_processing.py @@ -9,7 +9,11 @@ class FileManager: @staticmethod def read_file(filename): - """Читает файл""" + """ + читает файл + :param filename: путь к файлу + :return: содержимое файла + """ try: with open(filename, 'rb') as f: return f.read() @@ -23,7 +27,11 @@ def read_file(filename): @staticmethod def write_file(filename, data): - """Записывает данные в файл""" + """ + записывает данные в файл + :param filename: путь к файлу + :param data: данные для записи + """ try: with open(filename, 'wb') as f: f.write(data) @@ -35,7 +43,11 @@ def write_file(filename, data): @staticmethod def load_config(config_path): - """Загружает конфигурацию""" + """ + загружает конфигурацию + :param config_path: путь к конфигурации + :return: загруженная конфигурация + """ try: with open(config_path, 'r', encoding='utf-8') as f: return json.load(f) @@ -46,7 +58,11 @@ def load_config(config_path): @staticmethod def save_public_key(key, filename): - """Сохраняет публичный ключ""" + """ + сохраняет публичный ключ + :param key: публичный ключ + :param filename: путь к файлу + """ try: pem_data = key.public_bytes( encoding=serialization.Encoding.PEM, @@ -60,7 +76,11 @@ def save_public_key(key, filename): @staticmethod def save_private_key(key, filename): - """Сохраняет приватный ключ""" + """ + сохраняет приватный ключ + :param key: приватный ключ + :param filename: путь к файлу + """ try: pem_data = key.private_bytes( encoding=serialization.Encoding.PEM, @@ -75,7 +95,11 @@ def save_private_key(key, filename): @staticmethod def load_public_key(filename): - """Загружает публичный ключ""" + """ + Загружает публичный ключ + :param filename: путь к файлу + :return: публичный ключ + """ try: key_data = FileManager.read_file(filename) return load_pem_public_key(key_data) @@ -86,7 +110,11 @@ def load_public_key(filename): @staticmethod def load_private_key(filename): - """Загружает приватный ключ""" + """ + Загружает приватный ключ + :param filename: путь к файлу + :return: приватный ключ + """ try: key_data = FileManager.read_file(filename) return load_pem_private_key(key_data, password=None) diff --git a/lab_3/generate_keys.py b/lab_3/generate_keys.py index e8802bca8..575f6baf4 100644 --- a/lab_3/generate_keys.py +++ b/lab_3/generate_keys.py @@ -8,7 +8,11 @@ class KeyManager: @staticmethod def generate_key_pair(key_size=2048): - """Создает пару RSA ключей""" + """ + Создает пару RSA ключей + :param key_size: размер ключа + :return: пара ключей + """ print("Генерируем RSA ключи...") private_key = rsa.generate_private_key( @@ -35,7 +39,12 @@ def generate_aes_key(): @staticmethod def protect_aes_key(public_key, aes_key): - """Защищает AES ключ RSA шифрованием""" + """ + Защищает AES ключ RSA шифрованием + :param public_key: публичный ключ + :param aes_key: ключ для защиты + :return: зашифрованный ключ + """ encrypted_key = RSACrypto.rsa_encrypt(public_key, aes_key) print("AES ключ защищен") diff --git a/lab_3/symmetrical.py b/lab_3/symmetrical.py index 12b4d989c..b772f6d4f 100644 --- a/lab_3/symmetrical.py +++ b/lab_3/symmetrical.py @@ -16,7 +16,11 @@ def create_iv(): @staticmethod def create_aes_key(key_size=32): - """Генерирует AES ключ нужного размера""" + """ + Генерирует AES ключ нужного размера + :param key_size: размер ключа + :return: ключ + """ if key_size not in [16, 24, 32]: raise ValueError("Допустимые размеры ключа: 16, 24, 32 байта") return os.urandom(key_size) @@ -26,7 +30,10 @@ def create_aes_key(key_size=32): def encrypt_data(data: bytes, key: bytes, iv: bytes = None) -> tuple: """ Шифрует данные AES-256 в режиме CBC - Возвращает (шифротекст, iv) + :param data: данные для шифрования + :param key: ключ для щифрования + :param iv: вектор инициализации + :return: зашифрованные данные """ try: if iv is None: @@ -59,6 +66,10 @@ def encrypt_data(data: bytes, key: bytes, iv: bytes = None) -> tuple: def decrypt_data(ciphertext: bytes, key: bytes, iv: bytes) -> bytes: """ Расшифровывает данные AES + :param ciphertext: зашифрованные данные + :param key: ключ для расшифровки + :param iv: вектор инициализации + :return: расшифрованные данные """ try: cipher = Cipher(