Files
mtusi2026lab7/tlsutil.py
T

171 lines
8.4 KiB
Python

"""TLS/mTLS процессов приложения (lab7).
Клиенты (PostgreSQL, Redis, S3, RabbitMQ, OpenBao, Collector) — client_context(): TLS 1.2+, проверка
цепочки до учебного CA И имени сервера (check_hostname), свой leaf-сертификат для mTLS. Отключить проверку
сертификата настройкой нельзя: такой ветки в коде нет.
Сервер API — только mTLS (server_context + MTLSProtocol):
1. OpenSSL при рукопожатии: сертификат клиента обязателен (CERT_REQUIRED), цепочка до нашего CA,
срок действия. Нет сертификата / чужой CA / истёк -> рукопожатие не завершается.
2. После рукопожатия, ДО чтения запроса (connection_made): identity клиента = Subject CN должна быть
в API_ALLOWED_CLIENTS (по умолчанию только "lb") и серийный номер не в CRL. Иначе соединение
сбрасывается (abort), запрос в приложение не попадает. Так сертификат worker/intruder, подписанный
тем же CA, не делает его балансировщиком.
3. CRL перечитывается при изменении файла (раз в CRL_RELOAD_SECONDS), подпись CRL проверяется ключом CA.
После обновления уже открытые соединения с отозванными сертификатами закрываются — отзыв действует
и на keep-alive соединения, а не только на новые.
TLS session tickets выключены (OP_NO_TICKET): возобновление сессии не обходит проверку; к тому же
при возобновлении getpeercert() возвращает исходный сертификат, и шаг 2 выполняется для каждого соединения.
"""
import logging
import os
import ssl
import threading
import time
import weakref
from cryptography import x509
from cryptography.x509.oid import NameOID
from uvicorn.protocols.http.h11_impl import H11Protocol
import settings
log = logging.getLogger("messenger.tls")
def client_context(cert: bool = True) -> ssl.SSLContext:
context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH, cafile=settings.TLS_CA_FILE)
context.minimum_version = ssl.TLSVersion.TLSv1_2
context.check_hostname = True
context.verify_mode = ssl.CERT_REQUIRED
if cert and settings.TLS_CERT_FILE:
context.load_cert_chain(settings.TLS_CERT_FILE, settings.TLS_KEY_FILE)
return context
def server_context() -> ssl.SSLContext:
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.minimum_version = ssl.TLSVersion.TLSv1_2
context.load_cert_chain(settings.TLS_CERT_FILE, settings.TLS_KEY_FILE)
context.load_verify_locations(cafile=settings.TLS_CA_FILE)
context.verify_mode = ssl.CERT_REQUIRED
context.options |= ssl.OP_NO_TICKET
return context
def identity_of(cert: x509.Certificate) -> str | None:
names = cert.subject.get_attributes_for_oid(NameOID.COMMON_NAME)
return names[0].value if names else None
class PeerPolicy:
"""Allowlist identity + CRL. Потокобезопасна, CRL перечитывается фоново."""
def __init__(self, allowed: frozenset, crl_file: str, ca_file: str):
self.allowed = allowed
self.crl_file = crl_file
self.ca_public_key = x509.load_pem_x509_certificate(open(ca_file, "rb").read()).public_key()
self.revoked: frozenset = frozenset()
self.crl_mtime = None
self.crl_next_update = None
self.connections: "weakref.WeakSet[MTLSProtocol]" = weakref.WeakSet()
self.load_crl()
def load_crl(self) -> bool:
"""True, если CRL изменился и применён."""
try:
mtime = os.stat(self.crl_file).st_mtime_ns
except OSError:
if self.crl_mtime is None:
log.warning("CRL file is missing, only allowlist is enforced", extra={"event": "tls.crl_missing"})
self.crl_mtime = 0
return False
if mtime == self.crl_mtime:
return False
try:
crl = x509.load_pem_x509_crl(open(self.crl_file, "rb").read())
if not crl.is_signature_valid(self.ca_public_key):
raise ValueError("CRL signature is not valid for our CA")
except (OSError, ValueError) as exc:
log.error("CRL rejected, keeping the previous one: %s", exc, extra={"event": "tls.crl_invalid"})
self.crl_mtime = mtime
return False
self.revoked = frozenset(entry.serial_number for entry in crl)
self.crl_mtime = mtime
self.crl_next_update = crl.next_update_utc
log.info("CRL loaded: %d revoked", len(self.revoked), extra={"event": "tls.crl_loaded",
"tls.crl.revoked": len(self.revoked)})
return True
def check(self, der: bytes | None) -> tuple[bool, str, str | None, int | None]:
if not der:
return False, "no_client_certificate", None, None
cert = x509.load_der_x509_certificate(der)
identity = identity_of(cert)
if cert.serial_number in self.revoked:
return False, "revoked", identity, cert.serial_number
if identity not in self.allowed:
return False, "identity_not_allowed", identity, cert.serial_number
return True, "ok", identity, cert.serial_number
def sweep(self) -> int:
"""Закрыть открытые соединения, чей сертификат теперь в CRL."""
closed = 0
for protocol in list(self.connections):
if protocol.peer_serial in self.revoked and protocol.transport is not None:
protocol.transport.abort()
closed += 1
if closed:
log.warning("Closed %d connection(s) with revoked client certificates", closed,
extra={"event": "tls.revoked_connections_closed", "tls.closed": closed})
return closed
def watch(self) -> None:
def loop():
while True:
time.sleep(settings.CRL_RELOAD_SECONDS)
try:
if self.load_crl():
self.sweep()
except Exception: # noqa: BLE001 — фоновый поток не должен умирать
log.exception("CRL reload failed", extra={"event": "tls.crl_reload_failed"})
threading.Thread(target=loop, name="crl-watch", daemon=True).start()
policy: PeerPolicy | None = None
REJECTED = {"count": 0}
def init_policy() -> PeerPolicy:
global policy
policy = PeerPolicy(settings.API_ALLOWED_CLIENTS, settings.TLS_CRL_FILE, settings.TLS_CA_FILE)
policy.watch()
return policy
class MTLSProtocol(H11Protocol):
"""HTTP/1.1 uvicorn + авторизация identity клиента на уровне соединения."""
peer_serial = None
peer_identity = None
def connection_made(self, transport) -> None:
super().connection_made(transport)
ssl_object = transport.get_extra_info("ssl_object")
if ssl_object is None or policy is None:
# Сюда попадает только незашифрованное соединение: в режиме API_TLS=1 его не бывает.
log.error("Non-TLS connection on the mTLS listener", extra={"event": "tls.plaintext_rejected"})
transport.abort()
return
allowed, reason, identity, serial = policy.check(ssl_object.getpeercert(binary_form=True))
if not allowed:
REJECTED["count"] += 1
client = self.client[0] if self.client else "?"
log.warning("mTLS client rejected: %s (identity=%s)", reason, identity,
extra={"event": "tls.client_rejected", "tls.reject_reason": reason,
"tls.client.identity": identity or "", "client.address": client})
transport.abort()
return
self.peer_identity, self.peer_serial = identity, serial
policy.connections.add(self)