forked from mtusi2026/mtusi2026lab7
383 lines
19 KiB
Python
383 lines
19 KiB
Python
#!/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())
|