Files
mtusi2026lab7/scripts/bao.py
T
2026-11-08 00:33:25 +03:00

253 lines
11 KiB
Python

"""OpenBao operator tool for the lab7 stand (Python standard library only).
Runs in the short-lived "ops" container (make bao-init / bao-unseal / bao-bootstrap / ...).
It is the ONLY place that reads the operator material in secrets/operator/:
unseal-key-1..3 Shamir shares (threshold 2). In real life: three different people/places.
root-token initial root token (used only by these operator commands)
The files are created with mode 600, never mounted into services, never printed.
Commands:
status initialized / sealed / version (no token needed)
init operator init (3 shares, threshold 2); refuses to run twice
unseal submit shares until unsealed (needed after every OpenBao restart)
seal seal OpenBao (incident drill: sealed OpenBao)
bootstrap idempotent: kv-v2 at secret/, cert auth, audit device, policies,
cert roles for api/worker, application secrets from secrets/*
rotate-db new password for DB role messenger_api: ALTER ROLE + new KV version
revoke-tokens revoke every token issued by the cert auth method (forces re-login)
token-ttl ROLE TTL change token TTL of a cert role (e.g. expiry drill: api 30s)
Plain ASCII on purpose (scripts/check_contract.py reads scripts/*.py with the default encoding).
"""
import json
import os
import secrets as rnd
import ssl
import sys
import time
import urllib.error
import urllib.request
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
SECRETS = Path(os.environ.get("SECRETS_DIR", ROOT / "secrets"))
OPERATOR = SECRETS / "operator"
POLICIES = Path(os.environ.get("BAO_POLICY_DIR", ROOT / "infra" / "openbao" / "policies"))
ADDR = os.environ.get("BAO_ADDR", "https://openbao:8200").rstrip("/")
CACERT = os.environ.get("BAO_CACERT", str(SECRETS / "tls" / "ca" / "ca.crt"))
SHARES, THRESHOLD = 3, 2
# role -> (certificate CN, policy, secret path). One policy per service, nothing shared.
ROLES = {"messenger-api": ("api", "messenger-api", "messenger/api"),
"messenger-worker": ("worker", "messenger-worker", "messenger/worker")}
TOKEN_TTL, TOKEN_MAX_TTL = os.environ.get("BAO_TOKEN_TTL", "15m"), os.environ.get("BAO_TOKEN_MAX_TTL", "1h")
CTX = ssl.create_default_context(cafile=CACERT) # server certificate and hostname are verified
class BaoError(Exception):
def __init__(self, status, errors):
super().__init__(f"HTTP {status}: {'; '.join(errors) or 'no details'}")
self.status = status
def call(method, path, body=None, token=None, ok=(200, 204)):
data = None if body is None else json.dumps(body).encode()
request = urllib.request.Request(ADDR + "/v1/" + path.lstrip("/"), data=data, method=method)
request.add_header("Content-Type", "application/json")
if token:
request.add_header("X-Vault-Token", token)
try:
with urllib.request.urlopen(request, context=CTX, timeout=10) as response:
raw = response.read()
status = response.status
except urllib.error.HTTPError as exc:
raw, status = exc.read(), exc.code
payload = json.loads(raw) if raw.strip() else {}
if status not in ok:
# Error bodies of OpenBao contain no secret values; tokens are never echoed.
raise BaoError(status, payload.get("errors", []))
return payload
def secret_file(name: str) -> str:
return (SECRETS / name).read_text(encoding="utf-8").strip()
def write_private(path: Path, value: str):
path.parent.mkdir(parents=True, exist_ok=True)
os.chmod(path.parent, 0o700)
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
with os.fdopen(fd, "w") as fh:
fh.write(value)
def root_token() -> str:
path = OPERATOR / "root-token"
if not path.exists():
sys.exit("secrets/operator/root-token not found: run make bao-init first")
return path.read_text().strip()
def cmd_status(_args):
health = call("GET", "sys/seal-status")
print(f"initialized={health['initialized']} sealed={health['sealed']} "
f"progress={health.get('progress', 0)}/{health.get('t', 0)} version={health.get('version')} "
f"storage={health.get('storage_type')}")
return 0 if not health["sealed"] else 2
def cmd_init(_args):
if call("GET", "sys/init")["initialized"]:
print("OpenBao already initialized: nothing to do (shares and root token stay with the operator)")
return 0
result = call("PUT", "sys/init", {"secret_shares": SHARES, "secret_threshold": THRESHOLD})
for number, share in enumerate(result["keys_base64"], start=1):
write_private(OPERATOR / f"unseal-key-{number}", share)
write_private(OPERATOR / "root-token", result["root_token"])
print(f"initialized: {SHARES} unseal shares (threshold {THRESHOLD}) and root token saved to secrets/operator/ "
"(mode 600, not printed). Keep the shares apart: in production every share goes to a different person.")
return 0
def cmd_unseal(_args):
status = call("GET", "sys/seal-status")
if not status["initialized"]:
sys.exit("not initialized: run make bao-init")
if not status["sealed"]:
print("already unsealed")
return 0
keys = sorted(OPERATOR.glob("unseal-key-*"))
if len(keys) < THRESHOLD:
sys.exit(f"need {THRESHOLD} shares in secrets/operator/unseal-key-N")
for path in keys[:THRESHOLD]:
status = call("PUT", "sys/unseal", {"key": path.read_text().strip()})
print(f"sealed={status['sealed']} (used {THRESHOLD} of {len(keys)} shares)")
return 0 if not status["sealed"] else 1
def cmd_seal(_args):
call("PUT", "sys/seal", token=root_token())
print("sealed: services keep their cached secrets, new logins and reads fail until make bao-unseal")
return 0
def cmd_bootstrap(_args):
token = root_token()
if "secret/" not in call("GET", "sys/mounts", token=token)["data"]:
call("POST", "sys/mounts/secret", {"type": "kv", "options": {"version": "2"}}, token=token)
print("enabled kv-v2 at secret/")
if "cert/" not in call("GET", "sys/auth", token=token)["data"]:
call("POST", "sys/auth/cert", {"type": "cert"}, token=token)
print("enabled cert auth at auth/cert/")
# Audit device is declared in infra/openbao/bao.hcl: OpenBao 2.4 refuses to enable it via the API.
ca_pem = Path(CACERT).read_text()
for role, (common_name, policy, secret_path) in ROLES.items():
call("PUT", f"sys/policies/acl/{policy}",
{"policy": (POLICIES / f"{policy}.hcl").read_text(encoding="utf-8")}, token=token)
call("POST", f"auth/cert/certs/{role}", {
"display_name": role,
"certificate": ca_pem, # trust anchor: our CA only
"allowed_common_names": [common_name], # and only this identity
"token_policies": [policy],
"token_ttl": TOKEN_TTL, "token_max_ttl": TOKEN_MAX_TTL,
"token_no_default_policy": False, # default policy = lookup-self / renew-self only
}, token=token)
put_kv(token, "messenger/api", {
"db_password": secret_file("db_api_password"),
"s3_access_key_id": secret_file("s3_api_access_key_id"),
"s3_secret_access_key": secret_file("s3_api_secret_access_key"),
"cache_password": secret_file("valkey_api_password"),
})
put_kv(token, "messenger/worker", {
"db_password": secret_file("db_worker_password"),
"s3_access_key_id": secret_file("s3_worker_access_key_id"),
"s3_secret_access_key": secret_file("s3_worker_secret_access_key"),
})
print(f"policies messenger-api, messenger-worker; cert roles (CN api / worker, token ttl {TOKEN_TTL}, "
f"max {TOKEN_MAX_TTL}); secrets secret/messenger/api and secret/messenger/worker written (values not printed)")
return 0
def put_kv(token, path, data):
current = None
try:
current = call("GET", f"secret/data/{path}", token=token)["data"]["data"]
except BaoError as exc:
if exc.status != 404:
raise
if current != data:
call("POST", f"secret/data/{path}", {"data": data}, token=token)
def cmd_rotate_db(_args):
"""Rotate the password of DB role messenger_api without rebuilding images or restarting the API.
Order: 1) ALTER ROLE in PostgreSQL, 2) new KV version in OpenBao, 3) the operator copy.
Between 1) and the next API refresh (BAO_REFRESH_SECONDS) NEW DB connections of the API fail
and are retried; connections that are already open keep working (PostgreSQL checks the password
only at login). The API drains its pool when it sees the new value, so every connection after
that is a new login with the new password.
"""
import psycopg # available in the application image the ops container runs from
from psycopg import sql
token = root_token()
new = rnd.token_hex(24)
owner = secret_file("postgres_password")
with psycopg.connect(host=os.environ.get("DB_HOST", "postgres"), port=int(os.environ.get("DB_PORT", "5432")),
dbname="messenger", user="messenger", password=owner,
sslmode="verify-full", sslrootcert=CACERT, connect_timeout=5, autocommit=True) as conn:
conn.execute(sql.SQL("ALTER ROLE messenger_api PASSWORD {}").format(sql.Literal(new)))
data = call("GET", "secret/data/messenger/api", token=token)["data"]["data"]
data["db_password"] = new
result = call("POST", "secret/data/messenger/api", {"data": data}, token=token)
(SECRETS / "db_api_password").write_text(new)
print(f"rotated DB password of messenger_api: PostgreSQL updated, KV secret/messenger/api now version "
f"{result['data']['version']} (value not printed)")
return 0
def cmd_revoke_tokens(_args):
call("PUT", "sys/leases/revoke-prefix/auth/cert/login", token=root_token())
print("revoked all tokens issued by auth/cert: services must log in again with their certificates")
return 0
def cmd_token_ttl(args):
if len(args) != 2 or args[0] not in ("api", "worker"):
sys.exit("usage: token-ttl api|worker TTL (e.g. 30s, 15m)")
role = f"messenger-{args[0]}"
token = root_token()
current = call("GET", f"auth/cert/certs/{role}", token=token)["data"]
max_ttl = args[1] if args[1].endswith("s") else TOKEN_MAX_TTL
call("POST", f"auth/cert/certs/{role}", {
"display_name": role, "certificate": current["certificate"],
"allowed_common_names": current["allowed_common_names"], "token_policies": current["token_policies"],
"token_ttl": args[1], "token_max_ttl": max_ttl}, token=token)
print(f"{role}: token_ttl={args[1]} token_max_ttl={max_ttl} (applies to NEW logins)")
return 0
COMMANDS = {"status": cmd_status, "init": cmd_init, "unseal": cmd_unseal, "seal": cmd_seal,
"bootstrap": cmd_bootstrap, "rotate-db": cmd_rotate_db, "revoke-tokens": cmd_revoke_tokens,
"token-ttl": cmd_token_ttl}
def main():
if len(sys.argv) < 2 or sys.argv[1] not in COMMANDS:
sys.exit("usage: bao.py " + "|".join(COMMANDS))
deadline = time.monotonic() + 60
while True: # OpenBao may still be starting after docker compose up
try:
return COMMANDS[sys.argv[1]](sys.argv[2:])
except (urllib.error.URLError, ConnectionError, TimeoutError) as exc:
if time.monotonic() > deadline:
sys.exit(f"OpenBao at {ADDR} is not reachable: {getattr(exc, 'reason', exc)}")
time.sleep(2)
except BaoError as exc:
sys.exit(f"OpenBao refused: {exc}")
if __name__ == "__main__":
sys.exit(main())