diff --git a/lab_3/asymmetrical.py b/lab_3/asymmetrical.py new file mode 100644 index 00000000..ed13444c --- /dev/null +++ b/lab_3/asymmetrical.py @@ -0,0 +1,67 @@ +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 с SHA256 для надежности. + :param public_key: публичный ключ + :param data: данные для шифрования + :return: зашифрованные данные + """ + 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 приватным ключом + :param private_key: приватный ключ + :param encrypted_data: зашифрованные данные + :return: расшифрованные данные + """ + + 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/config.json b/lab_3/config.json new file mode 100644 index 00000000..ba0a6bee --- /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 00000000..dbc9ebd6 --- /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 00000000..1b084a85 Binary files /dev/null and b/lab_3/encrypted.bin differ diff --git a/lab_3/file_processing.py b/lab_3/file_processing.py new file mode 100644 index 00000000..97d6d3f5 --- /dev/null +++ b/lab_3/file_processing.py @@ -0,0 +1,123 @@ +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): + """ + читает файл + :param filename: путь к файлу + :return: содержимое файла + """ + 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): + """ + записывает данные в файл + :param filename: путь к файлу + :param 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): + """ + загружает конфигурацию + :param config_path: путь к конфигурации + :return: загруженная конфигурация + """ + 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): + """ + сохраняет публичный ключ + :param key: публичный ключ + :param 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): + """ + сохраняет приватный ключ + :param key: приватный ключ + :param 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): + """ + Загружает публичный ключ + :param filename: путь к файлу + :return: публичный ключ + """ + 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): + """ + Загружает приватный ключ + :param filename: путь к файлу + :return: приватный ключ + """ + 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/generate_keys.py b/lab_3/generate_keys.py new file mode 100644 index 00000000..575f6baf --- /dev/null +++ b/lab_3/generate_keys.py @@ -0,0 +1,53 @@ +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 ключей + :param key_size: размер ключа + :return: пара ключей + """ + 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 шифрованием + :param public_key: публичный ключ + :param aes_key: ключ для защиты + :return: зашифрованный ключ + """ + + encrypted_key = RSACrypto.rsa_encrypt(public_key, aes_key) + print("AES ключ защищен") + + return encrypted_key + diff --git a/lab_3/input.txt b/lab_3/input.txt new file mode 100644 index 00000000..dbc9ebd6 --- /dev/null +++ b/lab_3/input.txt @@ -0,0 +1 @@ +В современном мире, где ежесекундно передаются терабайты конфиденциальных данных, шифрование стало фундаментом информационной безопасности. От переписки в мессенджерах до банковских транзакций — криптографические алгоритмы работают как невидимые защитники, превращая информацию в недоступный для злоумышленников код. Современные методы шифрования делятся на два основных типа. Симметричное шифрование, представленное алгоритмами AES-256 и ChaCha20, использует единый ключ для кодирования и расшифровки данных. Оно исключительно быстрое и эффективное, поэтому применяется для защиты жестких дисков, VPN-соединений и потокового видео. Асимметричное шифрование (RSA, ECC) работает с парой ключей — публичным и приватным, решая проблему безопасного обмена ключами через ненадежные каналы связи. Именно эта технология лежит в основе HTTPS-соединений, цифровых подписей и блокчейн-систем. Особую важность сегодня приобретает гибридное шифрование, сочетающее преимущества обоих подходов. В таких системах асимметричные алгоритмы защищают передачу симметричных ключей, которые затем шифруют основной поток данных. Эта технология защищает корпоративную переписку, облачные хранилища и государственные коммуникации. С развитием квантовых вычислений криптографы уже работают над алгоритмами постквантового шифрования, способными противостоять принципиально новым угрозам. Шифрование продолжает эволюционировать, оставаясь на передовой борьбы за конфиденциальность в цифровом мире. \ No newline at end of file diff --git a/lab_3/iv.bin b/lab_3/iv.bin new file mode 100644 index 00000000..ed070138 --- /dev/null +++ b/lab_3/iv.bin @@ -0,0 +1 @@ +:~mV] \ No newline at end of file diff --git a/lab_3/main.py b/lab_3/main.py new file mode 100644 index 00000000..0a64146b --- /dev/null +++ b/lab_3/main.py @@ -0,0 +1,115 @@ +import argparse + +from generate_keys import KeyManager +from file_processing import FileManager +from asymmetrical import RSACrypto +from symmetrical import AESCrypto + + +class CryptoSystem: + """Главная система гибридного шифрования""" + + def __init__(self, config_path): + self.config = FileManager.load_config(config_path) + + + def generate_keys(self): + """Генерирует все необходимые ключи""" + print("\n" + "=" * 50) + print("ЗАПУСК ГЕНЕРАЦИИ КЛЮЧЕЙ") + print("=" * 50) + + public_key, private_key = KeyManager.generate_key_pair() + + aes_key, iv = KeyManager.generate_aes_key() + + encrypted_aes_key = KeyManager.protect_aes_key(public_key, aes_key) + + FileManager.save_public_key(public_key, self.config['public_key_file']) + FileManager.save_private_key(private_key, self.config['private_key_file']) + FileManager.write_file(self.config['encrypted_key_file'], encrypted_aes_key) + FileManager.write_file(self.config['iv_file'], iv) + + print("Все ключи успешно созданы и сохранены!") + + + def encrypt_file(self): + """Шифрует файл""" + print("\n" + "=" * 50) + print("ЗАПУСК ШИФРОВАНИЯ") + print("=" * 50) + + private_key = FileManager.load_private_key(self.config['private_key_file']) + encrypted_aes_key = FileManager.read_file(self.config['encrypted_key_file']) + iv = FileManager.read_file(self.config['iv_file']) + + print("Восстанавливаем AES ключ...") + aes_key = RSACrypto.rsa_decrypt(private_key, encrypted_aes_key) + + print("Читаем данные для шифрования...") + plaintext = FileManager.read_file(self.config['source_file']) + + print("Шифруем данные AES...") + ciphertext, _ = AESCrypto.encrypt_data(plaintext, aes_key, iv) + + FileManager.write_file(self.config['encrypted_file'], ciphertext) + + print("Файл успешно зашифрован!") + + + def decrypt_file(self): + """Расшифровывает файл""" + print("\n" + "=" * 50) + print("ЗАПУСК ДЕШИФРОВАНИЯ") + print("=" * 50) + + private_key = FileManager.load_private_key(self.config['private_key_file']) + encrypted_aes_key = FileManager.read_file(self.config['encrypted_key_file']) + iv = FileManager.read_file(self.config['iv_file']) + + print("Восстанавливаем AES ключ...") + aes_key = RSACrypto.rsa_decrypt(private_key, encrypted_aes_key) + + print("Читаем зашифрованные данные...") + ciphertext = FileManager.read_file(self.config['encrypted_file']) + + print("Дешифруем данные AES...") + plaintext = AESCrypto.decrypt_data(ciphertext, aes_key, iv) + + FileManager.write_file(self.config['decrypted_file'], plaintext) + + print("Файл успешно расшифрован!") + + +def main(): + + parser = argparse.ArgumentParser(description="Система гибридного шифрования") + + group = parser.add_mutually_exclusive_group(required=True) + group.add_argument('-gen', action='store_true', help='Генерация ключей') + group.add_argument('-enc', action='store_true', help='Шифрование файла') + group.add_argument('-dec', action='store_true', help='Дешифрование файла') + + parser.add_argument('-c', '--config', required=True, help='Путь к конфигурации') + + args = parser.parse_args() + + try: + system = CryptoSystem(args.config) + + if args.gen: + system.generate_keys() + elif args.enc: + system.encrypt_file() + elif args.dec: + system.decrypt_file() + + except Exception as e: + print(f"\nКритическая ошибка: {e}") + return 1 + + return 0 + + +if __name__ == "__main__": + exit(main()) \ No newline at end of file diff --git a/lab_3/private.pem b/lab_3/private.pem new file mode 100644 index 00000000..0c4e5ab7 --- /dev/null +++ b/lab_3/private.pem @@ -0,0 +1,27 @@ +-----BEGIN RSA PRIVATE KEY----- +MIIEpAIBAAKCAQEAvCUTFURLvvI8sgKUADchqMkqTBPRBAdXJLJ7neQ4QPjASPMY +kGgq/LlviLSJJanttFZ1vz5vpWVgIkQ0YqMepmhgO/8Gwzo1lsK1HbtTVCdHVqeh +FOf+MR6EDqXQgTY7ZNLvwx3K/tz+sPAh/7deNL65uIphbsLdSBbNM9N04LoSRt1k +xvo+o2M3ogkZvBJ/QRKpqZnFI+7sb4xkUxIQIXD4HbDS7/+ccoXPeRCvhFK7uU6J +Q4Va9r1fCPXQxbFhKUTDfvHPAxqekfZWpkKf9YnodPIrd3LmzmiBI2MUHBQGjLYB +oUaAEENRwLuDV4eoFy+ge0/j1byIkFxscuUGkQIDAQABAoIBAAl2sfGJaGf35k6r +64bhPwuu5rZB7usNdXgulCI6hwvZl050D+G/o53ns/ED57whwoemK7ENcm823LGM +jbgCbXnAWUrbRptOU8C8FYEj2YqrmR6GOweCrdoJp2nXNFgzgqRNKes+FeZg9lyv +D3692fq8NzpNl54LJjdIklTPh5sAGs5L9NxlCDd88Y4ShaG/memCuxS9wH3oyEjT +MSKpK2a4a7w/OXiRi6nvy4rbAAZzJxjEl8YS+HA2XVV6ZskGZGvojpDWb4cs7KiE +/ii6w7Wqd+7bJH9eqZvCPE6gLleL58aV+DCVygOClVSpxwKc22ucTW/3mzW/x3/D +LyxQ7PMCgYEA9mDlxnnIVXOLgbXTyYpOL9mZTLgKaGUF3hP6VKpFwEJxDUOsLI50 +HqOza2MylCDGDuRpb4u2ZG3UmGKwbEFlJ6F9vg528AEphjNdUwS5t2717IjH39yp +EsP9rxT7ixu8KSHQc9rN+mpUdg5yIFtqLNNSIy7VApuufXUi/kDaEfcCgYEAw34A +Yal//MtDTXiloT+cV7R2BEKb9rDBW5SSzU/bGd5Qh6tPVxG/+GSC1PMmsBG5DZmM +pQYRoa3Z3K2DiZqwNrYaKAFj0S0BxAmC8gYvh02aHIOD2LVftcyJLgOmUwLjANSS +Atc1L07U+LivYIwQlnKs/PyQ/6Qi/ea2lN6DibcCgYBAwlNjCduYalh+7ZYPYWUP +urhKrA1AR111c/bWjjLrSAuDGwiEZaUr8IdWcKp4uOyWOX9lLGnyl9PLghUxPzch +ZZcxf4fPqd6KQbIEAjf2eRn25DT1KIDgR9fET1WWyOF6RkMOULLXYV918HIbAywz +QBBU4xhmKRmCLGnYPp+THQKBgQCRuNbn9cVl1s5wbUJplFUiO27Ndil0FgXMEk/r +o18bRVCaEOSvbpe+vI2Z1zY7gLqEnLTuPjveXQ1NJjoq1JgN8GhG8eJKBlaOnthx +OJMtNHdwUchyPaD+j1yiZC4TKs+zysCcRXdrsEOos2JngYDL5Od2HX6oUN2UjeoD +xmoeuQKBgQC4jZhVs6/8kwex9+jTXvITDQdqZ138+DZeXgrjSXYY/sN1BoMCXj9+ +kmSbrb/diAg6SxfMWCLE+SvBiHCn2rr/Wj2/+YMFRZKwes24XWfGMYVzivNndmzc +EiHKfrtXJnS+ZOXzJm+1nfheBgaWOhC3TLe6oK7QrnMm8ekSAosOFQ== +-----END RSA PRIVATE KEY----- diff --git a/lab_3/public.pem b/lab_3/public.pem new file mode 100644 index 00000000..09763d16 --- /dev/null +++ b/lab_3/public.pem @@ -0,0 +1,9 @@ +-----BEGIN PUBLIC KEY----- +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvCUTFURLvvI8sgKUADch +qMkqTBPRBAdXJLJ7neQ4QPjASPMYkGgq/LlviLSJJanttFZ1vz5vpWVgIkQ0YqMe +pmhgO/8Gwzo1lsK1HbtTVCdHVqehFOf+MR6EDqXQgTY7ZNLvwx3K/tz+sPAh/7de +NL65uIphbsLdSBbNM9N04LoSRt1kxvo+o2M3ogkZvBJ/QRKpqZnFI+7sb4xkUxIQ +IXD4HbDS7/+ccoXPeRCvhFK7uU6JQ4Va9r1fCPXQxbFhKUTDfvHPAxqekfZWpkKf +9YnodPIrd3LmzmiBI2MUHBQGjLYBoUaAEENRwLuDV4eoFy+ge0/j1byIkFxscuUG +kQIDAQAB +-----END PUBLIC KEY----- diff --git a/lab_3/symmetric.bin b/lab_3/symmetric.bin new file mode 100644 index 00000000..a95e708e --- /dev/null +++ b/lab_3/symmetric.bin @@ -0,0 +1 @@ +j, O: l~#rYie_k32e^s>RA:4^$\MPQEaL⳪ Z; tuple: + """ + Шифрует данные AES-256 в режиме CBC + :param data: данные для шифрования + :param key: ключ для щифрования + :param iv: вектор инициализации + :return: зашифрованные данные + """ + 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 + :param ciphertext: зашифрованные данные + :param key: ключ для расшифровки + :param iv: вектор инициализации + :return: расшифрованные данные + """ + 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