forked from mtusi2026/mtusi2026lab7
276 lines
14 KiB
Python
276 lines
14 KiB
Python
"""Секреты процесса из 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()))
|