Криптография на Python: безопасное шифрование данных – практическое руководство

pip install cryptography

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa

# Генерация приватного ключа RSA
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
backend=default_backend()
)

from cryptography.fernet import Fernet

# Генерация ключа
key = Fernet.generate_key()
f = Fernet(key)

# Шифрование
message = b"секретное сообщение"
encrypted = f.encrypt(message)

# Дешифрование
decrypted = f.decrypt(encrypted)

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os

# Генерируем ключ
key = AESGCM.generate_key(bit_length=256)

# Создаем экземпляр шифра
aesgcm = AESGCM(key)

# Генерируем случайный вектор инициализации (nonce)
nonce = os.urandom(12)

# Данные для шифрования
data = b"Секретная информация"
associated_data = b"Дополнительные аутентифицированные данные"

# Шифрование
encrypted = aesgcm.encrypt(nonce, data, associated_data)

# Дешифрование
decrypted = aesgcm.decrypt(nonce, encrypted, associated_data)
print(decrypted.decode('utf-8')) # "Секретная информация"

from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes

# Генерация ключевой пары
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
backend=default_backend()
)
public_key = private_key.public_key()

# Шифрование данных
message = b"Секретное сообщение"
encrypted = public_key.encrypt(
message,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)

# Дешифрование
decrypted = private_key.decrypt(
encrypted,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)
print(decrypted.decode('utf-8')) # "Секретное сообщение"

import os
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes

# Генерируем RSA ключи
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
backend=default_backend()
)
public_key = private_key.public_key()

# Функция гибридного шифрования
def hybrid_encrypt(message, public_key):
# Генерируем симметричный ключ и IV
symmetric_key = os.urandom(32) # 256 бит для AES
iv = os.urandom(16)

# Шифруем сообщение с помощью AES
cipher = Cipher(algorithms.AES(symmetric_key), modes.CBC(iv), backend=default_backend())
encryptor = cipher.encryptor()

# Добавляем padding к сообщению
padded_message = message + b' ' * (16 – len(message) % 16)
encrypted_message = encryptor.update(padded_message) + encryptor.finalize()

# Шифруем симметричный ключ с помощью RSA
encrypted_key = public_key.encrypt(
symmetric_key,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)

# Возвращаем все необходимые компоненты
return {
'encrypted_message': encrypted_message,
'encrypted_key': encrypted_key,
'iv': iv
}

# Функция гибридного дешифрования
def hybrid_decrypt(encrypted_package, private_key):
# Извлекаем компоненты
encrypted_message = encrypted_package['encrypted_message']
encrypted_key = encrypted_package['encrypted_key']
iv = encrypted_package['iv']

# Дешифруем симметричный ключ
symmetric_key = private_key.decrypt(
encrypted_key,
padding.OAEP(
mgf=padding.MGF1(algorithm=hashes.SHA256()),
algorithm=hashes.SHA256(),
label=None
)
)

# Дешифруем сообщение
cipher = Cipher(algorithms.AES(symmetric_key), modes.CBC(iv), backend=default_backend())
decryptor = cipher.decryptor()
decrypted_message = decryptor.update(encrypted_message) + decryptor.finalize()

# Удаляем padding
return decrypted_message.rstrip()

# Пример использования
message = b"Строго конфиденциальная информация"
encrypted_package = hybrid_encrypt(message, public_key)
decrypted_message = hybrid_decrypt(encrypted_package, private_key)
print(decrypted_message.decode('utf-8'))

import hashlib

# Создаем строку для хеширования
data = "Проверка целостности этого сообщения"

# MD5 (не рекомендуется для безопасных приложений)
md5_hash = hashlib.md5(data.encode()).hexdigest()
print(f"MD5: {md5_hash}")

# SHA-256 (рекомендуется для большинства применений)
sha256_hash = hashlib.sha256(data.encode()).hexdigest()
print(f"SHA-256: {sha256_hash}")

# SHA-512 (для повышенной безопасности)
sha512_hash = hashlib.sha512(data.encode()).hexdigest()
print(f"SHA-512: {sha512_hash}")

# BLAKE2 (современная, быстрая и безопасная хеш-функция)
blake2_hash = hashlib.blake2b(data.encode()).hexdigest()
print(f"BLAKE2b: {blake2_hash}")

def calculate_file_hash(filename, algorithm='sha256'):
"""Вычисляет хеш файла с использованием указанного алгоритма"""
hash_obj = hashlib.new(algorithm)

with open(filename, 'rb') as file:
# Читаем файл блоками для экономии памяти
chunk = file.read(4096)
while chunk:
hash_obj.update(chunk)
chunk = file.read(4096)

return hash_obj.hexdigest()

# Пример использования
file_hash = calculate_file_hash('important_document.pdf')
print(f"Хеш файла (SHA-256): {file_hash}")

# Проверка целостности
expected_hash = "1a2b3c4d5e6f7g8h9i0j..."
if file_hash == expected_hash:
print("Файл не был изменен")
else:
print("Внимание! Файл был изменен или поврежден")

import hashlib
import os
import base64

def hash_password(password):
"""Безопасное хеширование пароля с солью"""
# Генерируем случайную соль
salt = os.urandom(32)

# Применяем PBKDF2 с 100,000 итерациями
key = hashlib.pbkdf2_hmac(
'sha256',
password.encode('utf-8'),
salt,
100000
)

# Объединяем соль и ключ для хранения
storage = salt + key

# Возвращаем в удобном для хранения формате
return base64.b64encode(storage).decode('utf-8')

def verify_password(stored_password, provided_password):
"""Проверка пароля"""
# Декодируем из base64
storage = base64.b64decode(stored_password.encode('utf-8'))

# Извлекаем соль (первые 32 байта)
salt = storage[:32]

# Извлекаем оригинальный ключ
original_key = storage[32:]

# Хешируем предоставленный пароль с той же солью
key = hashlib.pbkdf2_hmac(
'sha256',
provided_password.encode('utf-8'),
salt,
100000
)

# Сравниваем ключи
return key == original_key

# Пример использования
password = "мой_сложный_пароль123!"
stored_hash = hash_password(password)
print(f"Хеш для хранения: {stored_hash}")

# Проверка правильного пароля
is_correct = verify_password(stored_hash, password)
print(f"Пароль верный: {is_correct}") # True

# Проверка неправильного пароля
is_correct = verify_password(stored_hash, "неверный_пароль")
print(f"Пароль верный: {is_correct}") # False

import hmac
import hashlib

def create_hmac(key, message):
"""Создает HMAC для сообщения с использованием ключа"""
return hmac.new(
key.encode('utf-8'),
message.encode('utf-8'),
hashlib.sha256
).hexdigest()

def verify_hmac(key, message, hmac_digest):
"""Проверяет HMAC сообщения"""
calculated_digest = create_hmac(key, message)
# Используем постоянное время сравнения для предотвращения timing-атак
return hmac.compare_digest(calculated_digest, hmac_digest)

# Пример использования
secret_key = "мой_секретный_ключ"
message = "Это сообщение должно быть защищено от изменений"

# Создание HMAC
message_hmac = create_hmac(secret_key, message)
print(f"HMAC: {message_hmac}")

# Проверка правильного сообщения
is_authentic = verify_hmac(secret_key, message, message_hmac)
print(f"Сообщение подлинное: {is_authentic}") # True

# Проверка измененного сообщения
tampered_message = "Это сообщение было изменено"
is_authentic = verify_hmac(secret_key, tampered_message, message_hmac)
print(f"Сообщение подлинное: {is_authentic}") # False

from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend
from cryptography.exceptions import InvalidSignature

# Генерация ключевой пары
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
backend=default_backend()
)
public_key = private_key.public_key()

def sign_message(message, private_key):
"""Создает цифровую подпись для сообщения"""
signature = private_key.sign(
message.encode('utf-8'),
padding.PSS(
mgf=padding.MGF1(hashes.SHA256()),
salt_length=padding.PSS.MAX_LENGTH
),
hashes.SHA256()
)
return signature

def verify_signature(message, signature, public_key):
"""Проверяет цифровую подпись"""
try:
public_key.verify(
signature,
message.encode('utf-8'),
padding.PSS(
mgf=padding.MGF1(hashes.SHA256()),
salt_length=padding.PSS.MAX_LENGTH
),
hashes.SHA256()
)
return True
except InvalidSignature:
return False

# Пример использования
message = "Важный документ, требующий подписи"

# Подписание сообщения
signature = sign_message(message, private_key)
print(f"Подпись создана, длина: {len(signature)} байт")

# Проверка подписи с корректным сообщением
is_valid = verify_signature(message, signature, public_key)
print(f"Подпись действительна: {is_valid}") # True

# Проверка подписи с измененным сообщением
tampered_message = "Измененный документ с поддельной подписью"
is_valid = verify_signature(tampered_message, signature, public_key)
print(f"Подпись действительна: {is_valid}") # False

from cryptography import x509
from cryptography.x509.oid import NameOID
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.backends import default_backend
import datetime

# Генерация самоподписанного сертификата
def generate_self_signed_cert(common_name):
# Генерация ключа
private_key = rsa.generate_private_key(
public_exponent=65537,
key_size=2048,
backend=default_backend()
)

# Создаем информацию о владельце сертификата
subject = issuer = x509.Name([
x509.NameAttribute(NameOID.COMMON_NAME, common_name),
x509.NameAttribute(NameOID.ORGANIZATION_NAME, "My Organization"),
x509.NameAttribute(NameOID.COUNTRY_NAME, "RU"),
])

# Создаем сертификат
cert = x509.CertificateBuilder().subject_name(
subject
).issuer_name(
issuer
).public_key(
private_key.public_key()
).serial_number(
x509.random_serial_number()
).not_valid_before(
datetime.datetime.utcnow()
).not_valid_after(
# Сертификат действителен 10 дней
datetime.datetime.utcnow() + datetime.timedelta(days=10)
).add_extension(
x509.SubjectAlternativeName([x509.DNSName(common_name)]),
critical=False,
).sign(private_key, hashes.SHA256(), default_backend())

return private_key, cert

# Сохранение ключа и сертификата
def save_key_and_cert(private_key, certificate, key_file, cert_file):
# Сохраняем приватный ключ
with open(key_file, "wb") as f:
f.write(private_key.private_bytes(
encoding=serialization.Encoding.PEM,
format=serialization.PrivateFormat.PKCS8,
encryption_algorithm=serialization.NoEncryption()
))

# Сохраняем сертификат
with open(cert_file, "wb") as f:
f.write(certificate.public_bytes(serialization.Encoding.PEM))

# Пример использования
key, cert = generate_self_signed_cert("example.com")
save_key_and_cert(key, cert, "private_key.pem", "certificate.pem")
print("Сертификат и ключ созданы и сохранены.")

def sign_file(filename, private_key):
"""Создает цифровую подпись для файла"""
with open(filename, 'rb') as f:
data = f.read()

# Подписываем файл
signature = private_key.sign(
data,
padding.PSS(
mgf=padding.MGF1(hashes.SHA256()),
salt_length=padding.PSS.MAX_LENGTH
),
hashes.SHA256()
)

# Сохраняем подпись в отдельный файл
signature_filename = filename + '.sig'
with open(signature_filename, 'wb') as f:
f.write(signature)

return signature_filename

def verify_file_signature(filename, signature_file, public_key):
"""Проверяет цифровую подпись файла"""
# Читаем файл
with open(filename, 'rb') as f:
data = f.read()

# Читаем подпись
with open(signature_file, 'rb') as f:
signature = f.read()

# Проверяем подпись
try:
public_key.verify(
signature,
data,
padding.PSS(
mgf=padding.MGF1(hashes.SHA256()),
salt_length=padding.PSS.MAX_LENGTH
),
hashes.SHA256()
)
return True
except InvalidSignature:
return False

# Пример использования
document_file = "important_document.pdf"
signature_file = sign_file(document_file, private_key)
print(f"Файл подписан, подпись сохранена в: {signature_file}")

# Проверка подписи
is_valid = verify_file_signature(document_file, signature_file, public_key)
print(f"Подпись действительна: {is_valid}")