Files
mtusi2026lab7/src/messenger/secrets_provider.py
T

83 lines
3.0 KiB
Python

"""Certificate login with short-lived, path-scoped OpenBao tokens."""
import json
import os
import ssl
import time
from threading import Event, Thread
from urllib.request import Request, urlopen
def load_service_secrets(role):
address = os.getenv("BAO_ADDR", "https://openbao:8200").rstrip("/")
if not address.startswith("https://"):
raise ValueError("OpenBao requires HTTPS")
context = ssl.create_default_context(cafile="/run/tls/trust/ca.crt")
context.load_cert_chain("/run/tls/client/service.crt", "/run/tls/client/service.key")
def call(path, *, data=None, token=None):
headers = {"Content-Type": "application/json"}
if token:
headers["X-Vault-Token"] = token
request = Request(
f"{address}/v1/{path}",
data=json.dumps(data).encode() if data is not None else None,
headers=headers,
)
with urlopen(request, context=context, timeout=3) as response:
body = response.read(32768)
return json.loads(body) if body else {}
token = None
try:
token = call("auth/cert/login", data={"name": role})["auth"]["client_token"]
return call(f"services/data/{role}", token=token)["data"]["data"]
except OSError, ValueError, KeyError:
raise RuntimeError("Scoped service credentials are unavailable") from None
finally:
if token:
try:
call("auth/token/revoke-self", data={}, token=token)
except OSError:
pass # Its finite TTL still applies if the operator sealed the service.
class ServiceLease:
"""Reauthenticate periodically. Stop work after a bounded outage or a secret change."""
def __init__(self, settings):
self.role = os.getenv("BAO_ROLE")
self.settings = settings
self.grace = int(os.getenv("BAO_CREDENTIAL_GRACE", "30"))
self.interval = int(os.getenv("BAO_REFRESH_INTERVAL", "5"))
if not 2 <= self.interval < self.grace <= 120:
raise ValueError("Invalid OpenBao refresh or grace interval")
self.deadline = time.monotonic() + self.grace
self.stop = Event()
self.thread = Thread(target=self.refresh, name="openbao-refresh", daemon=True)
def __enter__(self):
if self.role:
self.thread.start()
return self
def __exit__(self, *exc):
if self.role:
self.stop.set()
self.thread.join(timeout=4)
def valid(self):
return not self.role or time.monotonic() < self.deadline
def refresh(self):
while not self.stop.wait(self.interval):
try:
values = load_service_secrets(self.role)
except RuntimeError:
continue
if any(getattr(self.settings, key) != value for key, value in values.items()):
# This process still holds the old pools. The operator recreates it after rotation.
self.deadline = 0
continue
self.deadline = time.monotonic() + self.grace