167 lines
5.9 KiB
Python
167 lines
5.9 KiB
Python
#!/usr/bin/env python3
|
|
"""Операторский init/unseal OpenBao + AppRole/policies. Tokens/shares не печатаются."""
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import ssl
|
|
import sys
|
|
import time
|
|
import urllib.error
|
|
import urllib.request
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
SECRET_DIR = ROOT / "secrets"
|
|
BAO_DIR = SECRET_DIR / "openbao"
|
|
CA = ROOT / "certs" / "ca.crt"
|
|
ADDR = os.environ.get("BAO_ADDR", "https://127.0.0.1:8200").rstrip("/")
|
|
|
|
|
|
def ctx() -> ssl.SSLContext:
|
|
context = ssl.create_default_context(cafile=str(CA))
|
|
context.minimum_version = ssl.TLSVersion.TLSv1_2
|
|
# cert SAN is openbao; operator talks via 127.0.0.1 publish
|
|
context.check_hostname = False
|
|
return context
|
|
|
|
|
|
def call(method: str, path: str, body=None, token: str | None = None) -> dict:
|
|
data = None
|
|
headers = {"Accept": "application/json"}
|
|
if body is not None:
|
|
data = json.dumps(body).encode("utf-8")
|
|
headers["Content-Type"] = "application/json"
|
|
if token:
|
|
headers["X-Vault-Token"] = token
|
|
req = urllib.request.Request(ADDR + path, data=data, headers=headers, method=method)
|
|
try:
|
|
with urllib.request.urlopen(req, context=ctx(), timeout=10) as response:
|
|
raw = response.read().decode("utf-8")
|
|
except urllib.error.HTTPError as exc:
|
|
raw = exc.read().decode("utf-8")
|
|
if exc.code >= 400:
|
|
raise RuntimeError(f"{method} {path} -> {exc.code}: {raw[:200]}") from exc
|
|
return json.loads(raw) if raw else {}
|
|
return json.loads(raw) if raw else {}
|
|
|
|
|
|
def write_secret(path: Path, value: str) -> None:
|
|
path.parent.mkdir(parents=True, exist_ok=True)
|
|
path.write_text(value.strip() + "\n", encoding="utf-8")
|
|
|
|
|
|
def wait_up() -> None:
|
|
for _ in range(60):
|
|
try:
|
|
call("GET", "/v1/sys/health?sealedcode=200&uninitcode=200&standbycode=200")
|
|
return
|
|
except Exception:
|
|
time.sleep(2)
|
|
raise RuntimeError("openbao not reachable")
|
|
|
|
|
|
def main() -> int:
|
|
wait_up()
|
|
BAO_DIR.mkdir(parents=True, exist_ok=True)
|
|
root_file = BAO_DIR / "root_token"
|
|
unseal_file = BAO_DIR / "unseal_key"
|
|
|
|
status = call("GET", "/v1/sys/seal-status")
|
|
if not status.get("initialized"):
|
|
result = call("PUT", "/v1/sys/init", {"secret_shares": 1, "secret_threshold": 1})
|
|
keys = result.get("keys_base64") or result.get("keys")
|
|
root = result.get("root_token")
|
|
if not keys or not root:
|
|
raise RuntimeError("init failed")
|
|
write_secret(unseal_file, keys[0])
|
|
write_secret(root_file, root)
|
|
print("OpenBao initialized (keys stored under secrets/openbao/, not printed)")
|
|
else:
|
|
if not root_file.exists() or not unseal_file.exists():
|
|
print("OpenBao already initialized but local operator keys missing", file=sys.stderr)
|
|
return 2
|
|
print("OpenBao already initialized")
|
|
|
|
root = root_file.read_text(encoding="utf-8").strip()
|
|
unseal = unseal_file.read_text(encoding="utf-8").strip()
|
|
status = call("GET", "/v1/sys/seal-status")
|
|
if status.get("sealed"):
|
|
call("PUT", "/v1/sys/unseal", {"key": unseal})
|
|
print("OpenBao unsealed")
|
|
else:
|
|
print("OpenBao already unsealed")
|
|
|
|
# Enable secrets/auth (ignore already-exists)
|
|
try:
|
|
call("POST", "/v1/sys/mounts/secret", {"type": "kv", "options": {"version": "2"}}, token=root)
|
|
except RuntimeError as exc:
|
|
if "already in use" not in str(exc).lower() and "existing mount" not in str(exc).lower():
|
|
# Vault returns 400 if exists
|
|
if "400" not in str(exc):
|
|
raise
|
|
try:
|
|
call("POST", "/v1/sys/auth/approle", {"type": "approle"}, token=root)
|
|
except RuntimeError as exc:
|
|
if "path is already in use" not in str(exc).lower() and "400" not in str(exc):
|
|
raise
|
|
|
|
api_policy = (ROOT / "infra/openbao/policies/api.hcl").read_text(encoding="utf-8")
|
|
worker_policy = (ROOT / "infra/openbao/policies/worker.hcl").read_text(encoding="utf-8")
|
|
call("PUT", "/v1/sys/policies/acl/messenger-api", {"policy": api_policy}, token=root)
|
|
call("PUT", "/v1/sys/policies/acl/messenger-worker", {"policy": worker_policy}, token=root)
|
|
|
|
call(
|
|
"POST",
|
|
"/v1/auth/approle/role/messenger-api",
|
|
{
|
|
"token_policies": ["messenger-api"],
|
|
"token_ttl": "5m",
|
|
"token_max_ttl": "15m",
|
|
"secret_id_ttl": "720h",
|
|
},
|
|
token=root,
|
|
)
|
|
call(
|
|
"POST",
|
|
"/v1/auth/approle/role/messenger-worker",
|
|
{
|
|
"token_policies": ["messenger-worker"],
|
|
"token_ttl": "5m",
|
|
"token_max_ttl": "15m",
|
|
"secret_id_ttl": "720h",
|
|
},
|
|
token=root,
|
|
)
|
|
|
|
call(
|
|
"POST",
|
|
"/v1/secret/data/messenger/api",
|
|
{"data": {"purpose": "api-runtime", "note": "scoped-lab7"}},
|
|
token=root,
|
|
)
|
|
call(
|
|
"POST",
|
|
"/v1/secret/data/messenger/worker",
|
|
{"data": {"purpose": "worker-runtime", "note": "scoped-lab7"}},
|
|
token=root,
|
|
)
|
|
|
|
api_role = call("GET", "/v1/auth/approle/role/messenger-api/role-id", token=root)["data"]["role_id"]
|
|
worker_role = call("GET", "/v1/auth/approle/role/messenger-worker/role-id", token=root)["data"]["role_id"]
|
|
api_secret = call("POST", "/v1/auth/approle/role/messenger-api/secret-id", {}, token=root)["data"]["secret_id"]
|
|
worker_secret = call("POST", "/v1/auth/approle/role/messenger-worker/secret-id", {}, token=root)["data"][
|
|
"secret_id"
|
|
]
|
|
|
|
write_secret(SECRET_DIR / "bao_api_role_id", api_role)
|
|
write_secret(SECRET_DIR / "bao_api_secret_id", api_secret)
|
|
write_secret(SECRET_DIR / "bao_worker_role_id", worker_role)
|
|
write_secret(SECRET_DIR / "bao_worker_secret_id", worker_secret)
|
|
print("AppRole credentials written to secrets/bao_*; recreate api/worker to pick them up")
|
|
return 0
|
|
|
|
|
|
if __name__ == "__main__":
|
|
raise SystemExit(main())
|