Какие есть группы шифровальщиков?

Группы криптографических алгоритмов шифрования

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

1. По типу ключей: асимметричное vs симметричное

Симметричное шифрование (Secret Key Cryptography)

Один и тот же ключ используется для шифрования и расшифрования:

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
import os

# Fernet (симметричное)
key = Fernet.generate_key()
cipher = Fernet(key)

plaintext = b"Secret message"
ciphertext = cipher.encrypt(plaintext)
decrypted = cipher.decrypt(ciphertext)

print(f"Зашифрован: {ciphertext}")
print(f"Расшифрован: {decrypted}")

# AES (симметричное) - промышленный стандарт
key = os.urandom(32)  # 256 бит
iv = os.urandom(16)   # инициализационный вектор

cipher = Cipher(
    algorithms.AES(key),
    modes.CBC(iv)  # режим сцепления блоков
)
encryptor = cipher.encryptor()
plaintext = b"Secret message"
ciphertext = encryptor.update(plaintext) + encryptor.finalize()

Примеры симметричных алгоритмов:

• AES (Advanced Encryption Standard) - стандарт НИСТ
• DES (Data Encryption Standard) - устаревший
• 3DES (Triple DES) - используется в банках
• ChaCha20 - современный, быстрый
• Twofish, Serpent - альтернативы

Плюсы:

• ✓ Быстро
• ✓ Надёжно проверено
• ✓ Мало вычислений

Минусы:

• ✗ Проблема распределения ключей
• ✗ Нужно передать ключ безопасно
• ✗ Каждой паре нужен свой ключ (n² для n участников)

Асимметричное шифрование (Public Key Cryptography)

Два разных ключа: публичный для шифрования, приватный для расшифрования:

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
)
public_key = private_key.public_key()

# Шифрование публичным ключом
plaintext = b"Secret message"
ciphertext = public_key.encrypt(
    plaintext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

# Расшифрование приватным ключом
decrypted = private_key.decrypt(
    ciphertext,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)

Примеры асимметричных алгоритмов:

• RSA - стандарт, 2048+ бит
• ECC (Elliptic Curve Cryptography) - новый стандарт
• ECDSA - подпись на эллиптических кривых
• EdDSA - быстрая подпись

Плюсы:

• ✓ Публичный ключ можно передавать
• ✓ Масштабируется (не нужны n² ключей)
• ✓ Основа для цифровых подписей

Минусы:

• ✗ Медленно
• ✗ Длинные ключи (2048+ бит)
• ✗ Вычислительно сложно

2. По режиму работы

Поточное шифрование (Stream Cipher)

Шифрует данные потоком, бит за битом:

# ChaCha20 - поточное шифрование
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

key = os.urandom(32)
nonce = os.urandom(12)

cipher = Cipher(
    algorithms.ChaCha20(key, nonce),
    None
)
encryptor = cipher.encryptor()
ciphertext = encryptor.update(b"Secret") + encryptor.finalize()

Примеры:

• RC4 (устаревший)
• ChaCha20
• Salsa20

Блочное шифрование (Block Cipher)

Шифрует данные блоками фиксированного размера:

# AES - блочное шифрование (блоки по 128 бит)
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

key = os.urandom(32)
iv = os.urandom(16)

# ECB - простой режим (НЕ ИСПОЛЬЗУЙ!)
cipher = Cipher(
    algorithms.AES(key),
    modes.ECB()  # уязвимо!
)

# CBC - режим сцепления
cipher = Cipher(
    algorithms.AES(key),
    modes.CBC(iv)  # безопасный
)

# CTR - режим счётчика (лучший выбор)
cipher = Cipher(
    algorithms.AES(key),
    modes.CTR(os.urandom(16))
)

# GCM - режим с аутентификацией (идеально для HTTPS)
cipher = Cipher(
    algorithms.AES(key),
    modes.GCM(os.urandom(12))
)

3. По целям: шифрование vs аутентификация

Конфиденциальность (только шифрование)

# Просто шифруем
from cryptography.fernet import Fernet

key = Fernet.generate_key()
cipher = Fernet(key)
ciphertext = cipher.encrypt(b"Secret")
# Никто не знает, что внутри, но может подделать!

Аутентификация (подписи)

# HMAC - код аутентификации сообщения
import hmac
import hashlib

message = b"Hello"
key = b"secret_key"

# Создаём подпись
signature = hmac.new(key, message, hashlib.sha256).digest()

# Проверяем подпись
verify = hmac.compare_digest(
    signature,
    hmac.new(key, message, hashlib.sha256).digest()
)
print(f"Подпись верна: {verify}")  # True

# Цифровая подпись (асимметричная)
from cryptography.hazmat.primitives.asymmetric import rsa, padding
from cryptography.hazmat.primitives import hashes

private_key = rsa.generate_private_key(65537, 2048)
public_key = private_key.public_key()

# Подписываем приватным ключом
message = b"Important document"
signature = private_key.sign(
    message,
    padding.PSS(
        mgf=padding.MGF1(hashes.SHA256()),
        salt_length=padding.PSS.MAX_LENGTH
    ),
    hashes.SHA256()
)

# Проверяем публичным ключом
try:
    public_key.verify(signature, message, padding.PSS(...), hashes.SHA256())
    print("Подпись верна")
except:
    print("Подпись неверна")

AEAD (Authenticated Encryption with Associated Data)

# AES-GCM: одновременно шифрует и аутентифицирует
from cryptography.hazmat.primitives.ciphers.aead import AESGCM

key = os.urandom(32)
nonce = os.urandom(12)
cipher = AESGCM(key)

plaintext = b"Secret"
associated_data = b"user_id:123"  # не шифруется, но проверяется

ciphertext = cipher.encrypt(nonce, plaintext, associated_data)

# Расшифровка
try:
    plaintext = cipher.decrypt(nonce, ciphertext, associated_data)
    print("Данные верны и аутентичны")
except:
    print("Данные повреждены или подделаны")

4. По стойкости и современности

Криптографически стойкие (современные)

# ✓ ИСПОЛЬЗУЙ

# Симметричное
- AES-256 (с CBC, CTR, GCM)
- ChaCha20-Poly1305

# Асимметричное
- RSA-2048+ (только для подписей, не шифрования)
- ECC P-256, P-384, P-521
- EdDSA (Ed25519)

# Хеширование
- SHA-256, SHA-512
- BLAKE2
- Argon2 (для паролей)

Устаревшие (не используй)

# ✗ НЕ ИСПОЛЬЗУЙ

- DES (56 бит - взлом за часы)
- MD5 (коллизии найдены)
- SHA-1 (коллизии найдены)
- RC4 (множество уязвимостей)
- ECB режим (раскрывает паттерны)

5. Практический пример: весь цикл

import os
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2

class SecureStorage:
    @staticmethod
    def encrypt_password_based(password: str, plaintext: bytes) -> dict:
        """Шифрование на основе пароля"""
        # 1. Создаём ключ из пароля
        salt = os.urandom(16)
        kdf = PBKDF2(
            algorithm=hashes.SHA256(),
            length=32,
            salt=salt,
            iterations=100000
        )
        key = kdf.derive(password.encode())
        
        # 2. Шифруем с аутентификацией
        nonce = os.urandom(12)
        cipher = AESGCM(key)
        ciphertext = cipher.encrypt(nonce, plaintext, None)
        
        return {
            'ciphertext': ciphertext.hex(),
            'nonce': nonce.hex(),
            'salt': salt.hex()
        }
    
    @staticmethod
    def decrypt_password_based(password: str, encrypted: dict) -> bytes:
        """Расшифрование на основе пароля"""
        # 1. Восстанавливаем ключ
        kdf = PBKDF2(
            algorithm=hashes.SHA256(),
            length=32,
            salt=bytes.fromhex(encrypted['salt']),
            iterations=100000
        )
        key = kdf.derive(password.encode())
        
        # 2. Расшифровываем
        cipher = AESGCM(key)
        plaintext = cipher.decrypt(
            bytes.fromhex(encrypted['nonce']),
            bytes.fromhex(encrypted['ciphertext']),
            None
        )
        return plaintext

# Использование
encrypted = SecureStorage.encrypt_password_based(
    password="MyStrongPassword123",
    plaintext=b"Secret document"
)

print(f"Зашифровано: {encrypted}")

decrypted = SecureStorage.decrypt_password_based(
    password="MyStrongPassword123",
    encrypted=encrypted
)

print(f"Расшифровано: {decrypted}")  # b'Secret document'

Таблица сравнения

Вывод: В современных приложениях используйте AES-256-GCM для симметричного шифрования и EdDSA для подписей.