171 lines
8.4 KiB
Python
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)
|