Files
mtusi2026lab7/secretstore.py
T

276 lines
14 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
"""Секреты процесса из OpenBao (lab7).
Как процесс получает свои учётные данные (ни одного постоянного «секрета для получения секретов»):
1. Оператор выпустил сервису leaf-сертификат учебного CA (scripts/pki.py), CN = identity сервиса
(api, worker, dispatcher, janitor, migrate, s3-init). Ключ смонтирован только в этот сервис, живёт
LEAF_DAYS (30 суток), отзывается через CRL, меняется без пересборки образа.
2. Вход: POST /v1/auth/cert/login {"name": BAO_ROLE} по mTLS этим сертификатом. OpenBao проверяет
цепочку до CA, CN == роль, CRL и выдаёт токен с policy только на путь messenger/data/<роль>,
TTL 15 мин (renewable), максимум 1 ч.
3. Чтение KV v2: GET /v1/messenger/data/<роль> -> {"db_password": ..., ...}. Значения живут только в памяти.
4. Фоновый поток раз в SECRETS_REFRESH_SECONDS: продлевает токен (renew-self), при отказе/исчерпании
max TTL входит заново сертификатом; перечитывает KV — новая версия (ротация оператором) сразу
используется для НОВЫХ соединений (пароль БД/Redis берётся при каждом подключении).
Отказ OpenBao (остановлен, sealed, сеть):
- при старте процесс ждёт до SECRETS_STARTUP_TIMEOUT_SECONDS и завершается с ошибкой (fail closed:
без секретов не стартуем, compose перезапустит контейнер, LB не пускает трафик на неготовую реплику);
- уже работающий процесс продолжает с последними прочитанными значениями (уже открытые соединения
и новые подключения с теми же паролями), пишет event=secrets.refresh_failed и метрику возраста
секретов. Ограничение: после ротации секрета оператором такой процесс подхватит новое значение только
когда OpenBao снова доступен — поэтому старое значение оператор отзывает ПОСЛЕ подтверждения (rotate).
Значения секретов и токен не логируются и не попадают в атрибуты телеметрии.
"""
import json
import logging
import os
import ssl
import threading
import time
import urllib.error
import urllib.request
import settings
log = logging.getLogger("messenger.secrets")
class SecretsUnavailable(RuntimeError):
"""OpenBao недоступен/sealed или отказал в доступе; текст без значений секретов."""
def _context() -> ssl.SSLContext:
context = ssl.create_default_context(cafile=settings.TLS_CA_FILE)
context.minimum_version = ssl.TLSVersion.TLSv1_2
if settings.TLS_CERT_FILE:
context.load_cert_chain(settings.TLS_CERT_FILE, settings.TLS_KEY_FILE)
return context
class Client:
"""Минимальный HTTP-клиент OpenBao (stdlib): TLS с проверкой CA и имени сервера, client cert."""
def __init__(self, address: str, role: str, timeout: float = 5):
self.address = address.rstrip("/")
self.role = role
self.timeout = timeout
self.token = None
self.token_expires = 0.0 # monotonic
self.token_max_expires = 0.0 # monotonic: после этого renew бесполезен, нужен новый вход
self.ttl = 0
def request(self, method: str, path: str, body: dict | None = None, token: str | None = None) -> dict:
data = json.dumps(body).encode("utf-8") if body is not None else None
request = urllib.request.Request(self.address + path, data=data, method=method)
request.add_header("Content-Type", "application/json")
if token:
request.add_header("X-Vault-Token", token) # заголовок, совместимый с OpenBao и Vault API
try:
# Только этот контекст: без системного прокси (OpenBao во внутренней сети).
opener = urllib.request.build_opener(urllib.request.ProxyHandler({}),
urllib.request.HTTPSHandler(context=_context()))
with opener.open(request, timeout=self.timeout) as reply:
raw = reply.read()
except urllib.error.HTTPError as exc:
# 503 — sealed/standby, 403 — нет прав/неверная identity, 400 — неверный сертификат/роль
raise SecretsUnavailable(f"OpenBao {method} {path.split('?')[0]} -> HTTP {exc.code}") from None
except (urllib.error.URLError, OSError, ssl.SSLError) as exc:
reason = getattr(exc, "reason", exc)
raise SecretsUnavailable(f"OpenBao unreachable: {type(reason).__name__}") from None
return json.loads(raw) if raw else {}
def login(self) -> None:
reply = self.request("POST", "/v1/auth/cert/login", {"name": self.role})
auth = reply["auth"]
self.token = auth["client_token"]
self.ttl = int(auth.get("lease_duration") or 0)
now = time.monotonic()
self.token_expires = now + self.ttl
# Максимальный TTL роли в ответе входа не приходит; renew вернёт lease меньше запрошенного,
# когда упрёмся в max — тогда входим заново (см. renew()).
self.token_max_expires = now + 24 * 3600
def renew(self) -> None:
reply = self.request("POST", "/v1/auth/token/renew-self", {}, token=self.token)
auth = reply["auth"]
granted = int(auth.get("lease_duration") or 0)
now = time.monotonic()
self.token_expires = now + granted
if granted < self.ttl * 0.9:
# Упёрлись в token_max_ttl: дальше только новый вход по сертификату.
self.token_max_expires = self.token_expires
def read(self, path: str) -> tuple[dict, int]:
reply = self.request("GET", f"/v1/{settings.BAO_KV_MOUNT}/data/{path}", token=self.token)
data = reply.get("data") or {}
return dict(data.get("data") or {}), int((data.get("metadata") or {}).get("version") or 0)
class SecretStore:
def __init__(self):
self._lock = threading.Lock()
self._values: dict[str, dict] = {}
self._versions: dict[str, int] = {}
self._paths: list[str] = []
self._listeners = []
self._client: Client | None = None
self._thread: threading.Thread | None = None
self._stop = threading.Event()
self.last_success = 0.0 # monotonic
self.last_error: str | None = None
self.logins = 0
self.renewals = 0
# ---------- публичный интерфейс ----------
def start(self, paths: list[str] | None = None) -> None:
"""Первый вход и чтение (с ожиданием). Без секретов процесс не стартует."""
if self._client is not None:
return
if not settings.BAO_ADDR:
raise SecretsUnavailable("BAO_ADDR is not set")
self._paths = paths or [settings.BAO_ROLE]
self._client = Client(settings.BAO_ADDR, settings.BAO_ROLE)
deadline = time.monotonic() + settings.SECRETS_STARTUP_TIMEOUT_SECONDS
delay = 1.0
while True:
try:
self._refresh(first=True)
break
except (SecretsUnavailable, KeyError, ValueError) as exc:
self.last_error = str(exc)
if time.monotonic() > deadline:
log.error("Secrets are unavailable, giving up: %s", exc,
extra={"event": "secrets.unavailable", "error.type": type(exc).__name__})
raise SecretsUnavailable(str(exc)) from None
log.warning("Waiting for OpenBao: %s", exc, extra={"event": "secrets.waiting"})
time.sleep(delay)
delay = min(delay * 2, 5)
self._thread = threading.Thread(target=self._loop, name="secrets-refresh", daemon=True)
self._thread.start()
def get(self, key: str, path: str | None = None) -> str:
with self._lock:
values = self._values.get(path or settings.BAO_ROLE)
if values is None:
raise SecretsUnavailable("secrets are not loaded yet")
value = values.get(key)
if value is None:
raise SecretsUnavailable(f"secret key {key!r} is missing in {path or settings.BAO_ROLE}")
return value
def version(self, path: str | None = None) -> int:
with self._lock:
return self._versions.get(path or settings.BAO_ROLE, 0)
def on_change(self, callback) -> None:
"""callback(path) после того, как прочитана новая версия секрета (ротация)."""
self._listeners.append(callback)
def age_seconds(self) -> float:
return time.monotonic() - self.last_success if self.last_success else -1.0
def status(self) -> dict:
"""Состояние без значений: для логов, метрик и отладки."""
client = self._client
return {"paths": list(self._paths), "versions": dict(self._versions),
"age_seconds": round(self.age_seconds(), 1), "logins": self.logins, "renewals": self.renewals,
"token_ttl_left": round(client.token_expires - time.monotonic(), 1) if client and client.token else None,
"last_error": self.last_error}
def stop(self) -> None:
self._stop.set()
# ---------- внутреннее ----------
def _ensure_token(self, first: bool) -> None:
client = self._client
now = time.monotonic()
if client.token is None or first or now >= client.token_expires - 5:
client.login()
self.logins += 1
log.info("OpenBao login as %s, token ttl %s s", client.role, client.ttl,
extra={"event": "secrets.login", "bao.role": client.role})
return
if now >= client.token_max_expires - 5:
client.login()
self.logins += 1
log.info("OpenBao token reached max TTL, logged in again", extra={"event": "secrets.relogin"})
return
# Продлеваем, когда прошла треть TTL.
if client.token_expires - now < client.ttl * 2 / 3:
try:
client.renew()
self.renewals += 1
log.info("OpenBao token renewed", extra={"event": "secrets.renewed"})
except SecretsUnavailable:
client.login()
self.logins += 1
# Отдельное событие: так выглядит отзыв токена (revoke), если renew наступил раньше чтения KV.
log.warning("OpenBao token renew failed, logged in again", extra={"event": "secrets.renew_failed"})
def _refresh(self, first: bool = False) -> None:
self._ensure_token(first)
changed = []
for path in self._paths:
values, version = self._client.read(path)
with self._lock:
if self._versions.get(path) != version:
changed.append(path)
self._values[path] = values
self._versions[path] = version
self.last_success = time.monotonic()
self.last_error = None
for path in changed:
if not first:
log.info("Secret %s changed to version %s", path, self._versions[path],
extra={"event": "secrets.rotated", "bao.path": path})
for callback in self._listeners:
try:
callback(path)
except Exception: # noqa: BLE001 — обработчик не должен ронять обновление
log.exception("secret change listener failed", extra={"event": "secrets.listener_failed"})
def _loop(self) -> None:
while not self._stop.wait(settings.SECRETS_REFRESH_SECONDS):
try:
self._refresh()
except (SecretsUnavailable, KeyError, ValueError) as exc:
self.last_error = str(exc)
if self._client is not None:
self._client.token = None # следующая попытка — новый вход
log.warning("Secrets refresh failed, keeping cached values (age %.0f s): %s",
self.age_seconds(), exc,
extra={"event": "secrets.refresh_failed", "error.type": type(exc).__name__})
store = SecretStore()
def install_metrics(meter) -> None:
"""Возраст последнего успешного чтения секретов: растёт, если OpenBao недоступен/sealed."""
from opentelemetry.metrics import Observation
def observe(_options):
age = store.age_seconds()
return [Observation(age, {"bao.role": settings.BAO_ROLE})] if age >= 0 else []
meter.create_observable_gauge("messenger.secrets.age", [observe], unit="s",
description="Seconds since secrets were last read from OpenBao")
def write_instance_file() -> None:
"""Alias реплики в файл (tmpfs): scripts/stop_one.py находит контейнер по X-Instance-Id."""
path = settings.INSTANCE_ID_FILE
if path:
try:
with open(path, "w", encoding="ascii") as file:
file.write(settings.INSTANCE_ID + "\n")
except OSError:
pass
if os.environ.get("SECRETSTORE_SELFTEST"): # pragma: no cover - ручная отладка
store.start()
print(json.dumps(store.status()))