Files
mtusi2026lab7-fork/scripts/bao.py

383 lines
19 KiB
Python
Raw Permalink 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.
#!/usr/bin/env python3
"""lab7: операции оператора над OpenBao. Python 3.9+, только стандартная библиотека.
python scripts/bao.py init # operator init (3 shares, порог 2) -> operator-only/openbao-init.json, затем unseal
python scripts/bao.py unseal # unseal после КАЖДОГО рестарта контейнера openbao (ручное действие оператора)
python scripts/bao.py configure # kv-v2, AppRole, политики, роли; секреты приложения из secrets/ -> KV
python scripts/bao.py issue-secret-ids [api|worker ...] # новый SecretID в secrets/bao/, старый отзывается
python scripts/bao.py revoke-role api # отозвать identity: все SecretID и токены роли (агент теряет доступ)
python scripts/bao.py policy-test # allow/deny политик реальными токенами AppRole (отрицательные проверки)
python scripts/bao.py seal # запечатать (демонстрация sealed-поведения)
python scripts/bao.py status
Модель доверия (bootstrap):
* root token и unseal shares создаются один раз командой init и хранятся только в
operator-only/openbao-init.json (0600, .gitignore, .dockerignore). В учебном стенде все
shares у одного оператора; в реальной эксплуатации — у разных людей, root token
отзывается после настройки и создаётся заново `bao operator generate-root`.
* Приложение не получает ни root token, ни unseal keys, ни SecretID: SecretID читает
только OpenBao Agent своей роли (secrets/bao/<role>_secret_id), SecretID живёт 7 дней и
принимается только из сети secrets (secret_id_bound_cidrs), токен агента — 15 мин (max 1 ч).
* Значения секретов не печатаются. Токен/ключ передаются в `docker exec` через
переменную окружения процесса (-e NAME без значения), а не через argv хоста.
Переменные: COMPOSE_PROJECT_NAME (messenger-lab7), BAO_LOCAL=1 — выполнять `bao` локально
(для проверки скрипта без Docker; BAO_ADDR/BAO_CACERT берутся из окружения).
"""
import json
import os
import secrets as pysecrets
import subprocess
import sys
import time
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
def _dotenv(name, default):
"""Значение из окружения, затем из .env (как у docker compose), затем по умолчанию."""
if os.environ.get(name):
return os.environ[name]
env = Path(os.environ.get("ENV_FILE", str(ROOT / ".env")))
if env.is_file():
for line in env.read_text(encoding="utf-8").splitlines():
if line.strip().startswith(name + "="):
return line.split("=", 1)[1].strip().strip('"').strip("'")
return default
OPERATOR = Path(os.environ.get("OPERATOR_DIR", str(ROOT / "operator-only")))
SECRETS = Path(os.environ.get("SECRETS_DIR", str(ROOT / "secrets")))
INIT_FILE = OPERATOR / "openbao-init.json"
PROJECT = _dotenv("COMPOSE_PROJECT_NAME", "messenger-lab7")
LOCAL = os.environ.get("BAO_LOCAL") == "1"
SECRETS_CIDR = _dotenv("BAO_SECRETS_CIDR", _dotenv("BAO_SECRETS_SUBNET", "172.30.250.0/24"))
ROLES = {
"api": {"policy": "messenger-api", "kv": "messenger/api"},
"worker": {"policy": "messenger-worker", "kv": "messenger/worker"},
}
POLICY_DIR = ROOT / "infra" / "openbao" / "policies"
def say(msg):
print(msg, flush=True)
def container_id(service="openbao"):
out = subprocess.run(["docker", "compose", "-p", PROJECT, "ps", "-q", service],
cwd=ROOT, capture_output=True, text=True, check=False).stdout.split()
if not out:
raise SystemExit("service %s is not running (docker compose up -d %s)" % (service, service))
return out[0]
def bao(*args, token=None, stdin=None, env_extra=None, check=True, shell=None, service="openbao"):
"""Выполнить `bao ...` в контейнере `service` (по умолчанию openbao) или локально.
Секреты — через env процесса docker exec, не argv. Токены AppRole привязаны к подсети
сети secrets (token_bound_cidrs), поэтому команды С ТОКЕНОМ РОЛИ выполняются из контейнера
агента этой роли (service="bao-agent-<role>"), а не из openbao (там источник 127.0.0.1).
"""
env = dict(os.environ)
names = []
if token:
env["BAO_TOKEN"] = token
names.append("BAO_TOKEN")
for k, v in (env_extra or {}).items():
env[k] = v
names.append(k)
if LOCAL:
cmd = ["sh", "-c", shell] if shell else ["/opt/bin/bao" if Path("/opt/bin/bao").exists() else "bao"] + list(args)
else:
cmd = ["docker", "exec", "-i"]
for n in names:
cmd += ["-e", n] # значение берётся из окружения этого процесса, в argv его нет
addr = "https://127.0.0.1:8200" if service == "openbao" else "https://openbao:8200"
cmd += ["-e", "BAO_ADDR=" + addr, "-e", "BAO_CACERT=/run/secrets/ca_crt",
"-e", "BAO_TLS_SERVER_NAME=openbao", container_id(service)]
cmd += ["sh", "-c", shell] if shell else ["bao"] + list(args)
res = subprocess.run(cmd, input=stdin, capture_output=True, text=True, env=env, cwd=ROOT)
if check and res.returncode != 0:
# stderr OpenBao не содержит значений секретов; обрезаем на всякий случай.
raise SystemExit("bao %s failed (%d): %s" % (args[:3] if args else "sh", res.returncode, res.stderr.strip()[-300:]))
return res
def status():
res = bao("status", "-format=json", check=False)
if res.returncode not in (0, 2):
raise SystemExit("OpenBao is not reachable: %s" % res.stderr.strip()[-200:])
return json.loads(res.stdout)
def root_token():
if not INIT_FILE.exists():
raise SystemExit("no %s: run `python scripts/bao.py init` first" % INIT_FILE)
return json.loads(INIT_FILE.read_text(encoding="utf-8"))["root_token"]
def write_private(path: Path, value: str):
path.parent.mkdir(parents=True, exist_ok=True)
# Запись «на месте» (тот же inode): bind-mount файла в работающем контейнере видит новое значение.
with open(path, "w", encoding="utf-8", newline="\n") as fh:
fh.write(value + "\n")
try:
os.chmod(path, 0o600 if path.is_relative_to(OPERATOR) else 0o644)
except (OSError, AttributeError):
pass
def read_secret(name):
return (SECRETS / name).read_text(encoding="utf-8").strip()
# ---------------------------------------------------------------- commands
def cmd_wait(_args, timeout=60):
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
try:
return status()
except SystemExit:
time.sleep(1)
raise SystemExit("OpenBao did not start within %ss" % timeout)
def cmd_init(args):
st = cmd_wait(args)
if st.get("initialized"):
say("OpenBao already initialized (keys: %s)" % ("present" if INIT_FILE.exists() else "MISSING"))
else:
res = bao("operator", "init", "-key-shares=3", "-key-threshold=2", "-format=json")
OPERATOR.mkdir(parents=True, exist_ok=True)
try:
os.chmod(OPERATOR, 0o700)
except OSError:
pass
data = json.loads(res.stdout)
write_private(INIT_FILE, json.dumps({"root_token": data["root_token"],
"unseal_keys_b64": data["unseal_keys_b64"],
"threshold": 2}, indent=2))
shown = INIT_FILE.relative_to(ROOT) if INIT_FILE.is_relative_to(ROOT) else INIT_FILE
say("initialized: 3 unseal shares (threshold 2) and root token saved to %s (operator only)" % shown)
cmd_unseal(args)
def cmd_unseal(_args):
st = cmd_wait(_args)
if not st.get("sealed"):
say("OpenBao is unsealed")
return
keys = json.loads(INIT_FILE.read_text(encoding="utf-8"))["unseal_keys_b64"]
for key in keys[:2]:
bao(shell='bao operator unseal "$BAO_UNSEAL_KEY" >/dev/null', env_extra={"BAO_UNSEAL_KEY": key})
st = status()
say("unsealed=%s" % (not st["sealed"]))
if st["sealed"]:
raise SystemExit(1)
def cmd_seal(_args):
bao("operator", "seal", token=root_token())
say("OpenBao sealed: agents keep already rendered files; new auth/renew fail until `bao.py unseal`")
def _enabled(kind, token):
data = json.loads(bao(kind, "list", "-format=json", token=token).stdout)
return set(data)
def cmd_configure(_args):
token = root_token()
if "kv/" not in _enabled("secrets", token):
bao("secrets", "enable", "-path=kv", "kv-v2", token=token)
if "approle/" not in _enabled("auth", token):
bao("auth", "enable", "approle", token=token)
for role, spec in ROLES.items():
policy = (POLICY_DIR / (spec["policy"] + ".hcl")).read_text(encoding="utf-8")
bao("policy", "write", spec["policy"], "-", token=token, stdin=policy)
bao("write", "auth/approle/role/" + spec["policy"],
"token_policies=" + spec["policy"], "token_ttl=15m", "token_max_ttl=1h", "token_type=service",
"secret_id_ttl=168h", "secret_id_num_uses=0",
"secret_id_bound_cidrs=" + SECRETS_CIDR, "token_bound_cidrs=" + SECRETS_CIDR,
"token_no_default_policy=false", token=token)
role_id = json.loads(bao("read", "-format=json", "auth/approle/role/%s/role-id" % spec["policy"],
token=token).stdout)["data"]["role_id"]
write_private(SECRETS / "bao" / (role + "_role_id"), role_id)
put_app_secrets(token)
# SecretID выпускаются заново при каждом configure: старые файлы могли остаться от
# предыдущего (удалённого) хранилища OpenBao и там недействительны. После configure
# перезапустите агентов: docker compose restart bao-agent-api bao-agent-worker
cmd_issue_secret_ids(type("A", (), {"roles": list(ROLES)})())
say("configured: kv-v2, approle, policies messenger-api/messenger-worker, secrets written to KV")
def put_app_secrets(token):
api = {
"db_password": read_secret("db_api_password"),
"cache_password": read_secret("cache_api_password"),
"broker_password": read_secret("broker_api_password"),
"s3_access_key_id": read_secret("s3_access_key_id"),
"s3_secret_access_key": read_secret("s3_secret_access_key"),
}
worker = {
"db_password": read_secret("db_worker_password"),
"broker_password": read_secret("broker_worker_password"),
"s3_access_key_id": read_secret("s3_worker_access_key_id"),
"s3_secret_access_key": read_secret("s3_worker_secret_access_key"),
}
bao("kv", "put", "-mount=kv", "messenger/api", "-", token=token, stdin=json.dumps(api))
bao("kv", "put", "-mount=kv", "messenger/worker", "-", token=token, stdin=json.dumps(worker))
def _accessors_file():
return OPERATOR / "approle-accessors.json"
def cmd_issue_secret_ids(args):
token = root_token()
accessors = json.loads(_accessors_file().read_text()) if _accessors_file().exists() else {}
for role in args.roles:
spec = ROLES[role]
res = json.loads(bao("write", "-f", "-format=json", "auth/approle/role/%s/secret-id" % spec["policy"],
token=token).stdout)["data"]
write_private(SECRETS / "bao" / (role + "_secret_id"), res["secret_id"])
old = accessors.get(role)
accessors[role] = res["secret_id_accessor"]
if old:
# Старый SecretID больше не нужен: отзываем, чтобы утёкшая копия была бесполезна.
bao("write", "auth/approle/role/%s/secret-id-accessor/destroy" % spec["policy"],
"secret_id_accessor=" + old, token=token, check=False)
say("issued new SecretID for %s (ttl 168h, bound to %s)%s"
% (role, SECRETS_CIDR, "; previous SecretID destroyed" if old else ""))
OPERATOR.mkdir(parents=True, exist_ok=True)
write_private(_accessors_file(), json.dumps(accessors, indent=2))
def cmd_revoke_role(args):
"""Отзыв identity роли: все её SecretID и все выданные ей токены."""
token = root_token()
for role in args.roles:
spec = ROLES[role]
listed = bao("list", "-format=json", "auth/approle/role/%s/secret-id" % spec["policy"],
token=token, check=False)
n_ids = 0
if listed.returncode == 0 and listed.stdout.strip():
for acc in json.loads(listed.stdout):
bao("write", "auth/approle/role/%s/secret-id-accessor/destroy" % spec["policy"],
"secret_id_accessor=" + acc, token=token)
n_ids += 1
n_tokens = 0
accs = bao("list", "-format=json", "auth/token/accessors", token=token, check=False)
for acc in (json.loads(accs.stdout) if accs.returncode == 0 and accs.stdout.strip() else []):
info = bao("token", "lookup", "-format=json", "-accessor", acc, token=token, check=False)
if info.returncode != 0:
continue
meta = (json.loads(info.stdout)["data"].get("meta") or {})
if meta.get("role_name") == spec["policy"]:
bao("token", "revoke", "-accessor", acc, token=token)
n_tokens += 1
say("revoked identity %s: %d SecretID, %d token(s); agent can no longer authenticate"
% (role, n_ids, n_tokens))
def _login(role):
role_id = (SECRETS / "bao" / (role + "_role_id")).read_text().strip()
secret_id = (SECRETS / "bao" / (role + "_secret_id")).read_text().strip()
res = bao(shell='bao write -format=json auth/approle/login role_id="$R" secret_id="$S"',
env_extra={"R": role_id, "S": secret_id}, check=False)
return res
def cmd_policy_test(_args):
"""Отрицательные проверки политик. Логин AppRole выполняется в контейнере АГЕНТА
(сеть secrets, адрес из secret_id_bound_cidrs); из контейнера openbao (127.0.0.1)
тот же SecretID отклоняется — это тоже проверка."""
results = []
def record(name, ok, detail=""):
results.append({"check": name, "ok": bool(ok), "detail": detail})
# 1. SecretID вне разрешённой сети не работает (openbao сам себе 127.0.0.1).
if not LOCAL:
res = _login("api")
record("approle login from outside secrets network is denied", res.returncode != 0,
"exit %d" % res.returncode)
for role, other in (("api", "worker"), ("worker", "api")):
tok = agent_token(role)
svc = "bao-agent-" + role # источник запросов — подсеть secrets (token_bound_cidrs)
if not tok:
record("%s: agent login" % role, False, LAST_LOGIN_ERROR.get(role, "no token"))
continue
own = bao("kv", "get", "-mount=kv", "-format=json", ROLES[role]["kv"], token=tok, check=False, service=svc)
record("%s reads own kv/%s" % (role, ROLES[role]["kv"]), own.returncode == 0)
foreign = bao("kv", "get", "-mount=kv", ROLES[other]["kv"], token=tok, check=False, service=svc)
record("%s cannot read kv/%s" % (role, ROLES[other]["kv"]), foreign.returncode != 0
and "permission denied" in foreign.stderr)
write = bao("kv", "put", "-mount=kv", ROLES[role]["kv"], "x=y", token=tok, check=False, service=svc)
record("%s cannot write own kv path" % role, write.returncode != 0 and "permission denied" in write.stderr)
pol = bao("policy", "write", "pwn", "-", token=tok, stdin='path "*" { capabilities = ["sudo"] }', check=False,
service=svc)
record("%s cannot write policies" % role, pol.returncode != 0 and "permission denied" in pol.stderr)
sid = bao("write", "-f", "auth/approle/role/%s/secret-id" % ROLES[role]["policy"], token=tok, check=False,
service=svc)
record("%s cannot mint SecretIDs" % role, sid.returncode != 0 and "permission denied" in sid.stderr)
look = json.loads(bao("token", "lookup", "-format=json", token=tok, service=svc).stdout)["data"]
record("%s token is short-lived (ttl<=15m) and not root" % role,
0 < look["ttl"] <= 900 and "root" not in look["policies"],
"ttl=%ss policies=%s" % (look["ttl"], look["policies"]))
ok = all(r["ok"] for r in results)
print(json.dumps({"ok": ok, "checks": results}, ensure_ascii=False, indent=2))
return 0 if ok else 1
def agent_token(role):
"""Получить токен роли ТАК ЖЕ, как агент: логин из контейнера агента (разрешённая сеть)."""
role_id = (SECRETS / "bao" / (role + "_role_id")).read_text().strip()
secret_id = (SECRETS / "bao" / (role + "_secret_id")).read_text().strip()
env = dict(os.environ, R=role_id, S=secret_id)
script = 'bao write -field=token auth/approle/login role_id="$R" secret_id="$S"'
if LOCAL:
cmd = ["sh", "-c", script.replace("bao ", "/opt/bin/bao ", 1)]
else:
cmd = ["docker", "exec", "-i", "-e", "R", "-e", "S", "-e", "BAO_ADDR=https://openbao:8200",
"-e", "BAO_CACERT=/run/secrets/ca_crt", container_id("bao-agent-" + role), "sh", "-c", script]
res = subprocess.run(cmd, capture_output=True, text=True, env=env, cwd=ROOT)
if res.returncode != 0:
LAST_LOGIN_ERROR[role] = " ".join((res.stderr or res.stdout).split())[-200:]
return None
return res.stdout.strip()
LAST_LOGIN_ERROR = {}
def cmd_status(_args):
st = status()
print(json.dumps({k: st.get(k) for k in ("initialized", "sealed", "t", "n", "progress", "version",
"storage_type")}, indent=2))
def main():
import argparse
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
sub = parser.add_subparsers(dest="cmd", required=True)
for name, fn in (("init", cmd_init), ("unseal", cmd_unseal), ("seal", cmd_seal), ("configure", cmd_configure),
("status", cmd_status), ("policy-test", cmd_policy_test), ("wait", cmd_wait)):
sub.add_parser(name).set_defaults(fn=fn)
for name, fn in (("issue-secret-ids", cmd_issue_secret_ids), ("revoke-role", cmd_revoke_role)):
p = sub.add_parser(name)
p.add_argument("roles", nargs="*", default=list(ROLES))
p.set_defaults(fn=fn)
args = parser.parse_args()
if getattr(args, "roles", None):
bad = [r for r in args.roles if r not in ROLES]
if bad:
raise SystemExit("unknown role(s): %s" % bad)
return args.fn(args) or 0
if __name__ == "__main__":
sys.exit(main())