"""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)