Какие методы шифрования используются в HTTPS?

Методы шифрования в HTTPS

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

1. TLS/SSL Протокол

HTTPS построен на основе TLS (Transport Layer Security) и его предшественника SSL (Secure Sockets Layer). Это транспортный уровень, который обеспечивает защиту данных.

import ssl
import socket

# Создание защищённого сокета
context = ssl.create_default_context()
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    with context.wrap_socket(sock, server_hostname="example.com") as ssock:
        ssock.connect(("example.com", 443))
        # Защищённое соединение установлено

2. Асимметричное шифрование (RSA)

RSA используется при установлении соединения для обмена ключами и аутентификации.

Как это работает:

• Сервер имеет публичный ключ (в сертификате) и приватный ключ (на сервере)
• Клиент получает публичный ключ сервера
• Клиент зашифровывает данные публичным ключом, сервер расшифровывает приватным
• Сервер может зашифровывать приватным ключом для подписи (клиент проверяет публичным)

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

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

# Шифруем данные с публичным ключом
message = b"Secret message"
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
    )
)

3. Симметричное шифрование (AES)

AES (Advanced Encryption Standard) используется для шифрования основного трафика после установки соединения.

Почему AES?

• Быстрее чем RSA
• Симметричное — один ключ для шифрования и расшифровки
• Стандарт — все поддерживают

from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import os

# Генерируем случайный ключ (256-бит = 32 байта)
key = os.urandom(32)  # AES-256
iv = os.urandom(16)   # Initialization Vector

# Создаём шифр
cipher = Cipher(
    algorithms.AES(key),
    modes.CBC(iv),
    backend=default_backend()
)

# Шифруем
encryptor = cipher.encryptor()
plaintext = b"This is a secret message that needs encryption"
encrypted = encryptor.update(plaintext) + encryptor.finalize()

print(f"Encrypted: {encrypted.hex()}")

# Расшифровываем
decipher = Cipher(
    algorithms.AES(key),
    modes.CBC(iv),
    backend=default_backend()
)
decryptor = decipher.decryptor()
decrypted = decryptor.update(encrypted) + decryptor.finalize()
print(f"Decrypted: {decrypted.decode()}")

4. TLS Handshake (Трёхэтапное рукопожатие)

Процесс установления защищённого соединения:

Этап 1: ClientHello

• Клиент отправляет список поддерживаемых шифров и версий TLS
• Сервер выбирает наиболее безопасный вариант

Этап 2: ServerHello + Certificate

• Сервер отправляет сертификат с публичным ключом
• Сервер выбирает шифр и версию TLS

Этап 3: Key Exchange + Finished

• Клиент генерирует session key (симметричный ключ)
• Клиент зашифровывает его публичным ключом сервера
• Сервер расшифровывает с приватным ключом
• Оба имеют одинаковый session key для дальнейшей коммуникации

Клиент                          Сервер
  |                               |
  |-------- ClientHello --------> |
  |                               |
  | <------ ServerHello -------- |
  | <------ Certificate -------- |
  | <------ ServerKeyExchange -- |
  | <------ ServerHelloDone ---- |
  |                               |
  |-------- ClientKeyExchange --> |
  |-------- ChangeCipherSpec --> |
  |-------- Finished ----------> |
  |                               |
  | <------ ChangeCipherSpec ---- |
  | <------ Finished --------- |
  |                               |
[Защищённое соединение установлено]

5. Хеширование (SHA)

SHA (Secure Hash Algorithm) используется для проверки целостности данных.

from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.backends import default_backend

# SHA-256 используется по умолчанию
digest = hashes.Hash(hashes.SHA256(), backend=default_backend())
digest.update(b"some data")
digest.update(b" and more data")
hash_value = digest.finalize()

print(f"SHA-256: {hash_value.hex()}")

# SHA-384, SHA-512 для большей безопасности
for hash_algo in [hashes.SHA256(), hashes.SHA384(), hashes.SHA512()]:
    digest = hashes.Hash(hash_algo, backend=default_backend())
    digest.update(b"test")
    print(f"{hash_algo.name}: {digest.finalize().hex()}")

6. ECDHE (Elliptic Curve Diffie-Hellman Ephemeral)

Современный метод обмена ключами, более безопасный и быстрый чем RSA.

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

# Генерируем эфемерный ключ на эллиптической кривой
private_key = ec.generate_private_key(
    ec.SECP256R1(), default_backend()  # P-256 кривая
)
public_key = private_key.public_key()

# ECDHE обеспечивает forward secrecy:
# Даже если приватный ключ сервера скомпрометирован,
# старые сессии останутся защищёнными

7. Порядок работы методов в HTTPS

8. Практический пример: HTTPS запрос

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.ssl_ import create_urllib3_context

# Проверяем TLS версию
response = requests.get("https://example.com")
print(f"Status: {response.status_code}")

# Проверяем сертификат сервера
import ssl
import socket

ssl_context = ssl.create_default_context()
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
    with ssl_context.wrap_socket(sock, server_hostname="example.com") as ssock:
        ssock.connect(("example.com", 443))
        cert = ssock.getpeercert()
        print(f"Certificate: {cert}")
        print(f"Cipher: {ssock.cipher()}")
        print(f"TLS Version: {ssock.version()}")

9. Уровни безопасности TLS

TLS 1.0 ❌ Deprecated TLS 1.1 ⚠️ Устаревший TLS 1.2 ✅ Минимум для production TLS 1.3 ✅✅ Рекомендуется (самый быстрый и безопасный)

# Конфигурируем минимальную версию TLS
context = ssl.create_default_context()
context.minimum_version = ssl.TLSVersion.TLSv1_2
context.maximum_version = ssl.TLSVersion.TLSv1_3

10. Современный стек HTTPS

1. TLS 1.3 — протокол
2. ECDHE — обмен ключами
3. AES-256-GCM — шифрование данных
4. SHA-256 — хеширование
5. Forward Secrecy — защита от скомпрометированных ключей

Вывод

HTTPS использует комбинацию методов:

• RSA/ECDHE для безопасного обмена ключами (асимметричное)
• AES для быстрого шифрования данных (симметричное)
• SHA для проверки целостности
• Сертификаты для аутентификации сервера

Всё это работает вместе для создания защищённого канала между клиентом и сервером.