forked from mtusi2026/mtusi2026lab7
261 lines
8.3 KiB
Python
261 lines
8.3 KiB
Python
import argparse
|
|
import json
|
|
import os
|
|
import secrets
|
|
import ssl
|
|
import subprocess
|
|
import time
|
|
import urllib.error
|
|
import urllib.request
|
|
from pathlib import Path
|
|
|
|
ROOT = Path(__file__).resolve().parents[1]
|
|
OPERATOR = Path(
|
|
os.environ.get("LAB7_OPERATOR_DIR", str(Path.home() / ".local/share/mtusi2026lab7/operator"))
|
|
)
|
|
ROLES = ("api", "worker", "relay", "migrate", "reconciler")
|
|
|
|
|
|
def secret(name):
|
|
return (ROOT / "secrets" / name).read_text().strip()
|
|
|
|
|
|
def call(path, data=None, token=None, method=None):
|
|
ctx = ssl.create_default_context(cafile=str(ROOT / "secrets/pki/operator/ca.crt"))
|
|
ctx.load_cert_chain(
|
|
ROOT / "secrets/pki/operator/tls.crt", ROOT / "secrets/pki/operator/tls.key"
|
|
)
|
|
headers = {"Content-Type": "application/json"}
|
|
if token:
|
|
headers["X-Vault-Token"] = token
|
|
req = urllib.request.Request(
|
|
os.environ.get("BAO_OPERATOR_URL", "https://localhost:28200") + "/v1/" + path,
|
|
data=json.dumps(data).encode() if data is not None else None,
|
|
headers=headers,
|
|
method=method,
|
|
)
|
|
with urllib.request.urlopen(req, context=ctx, timeout=10) as response:
|
|
raw = response.read()
|
|
return json.loads(raw) if raw else {}
|
|
|
|
|
|
def operator_token():
|
|
return json.loads((OPERATOR / "init.json").read_text())["root_token"]
|
|
|
|
|
|
def unseal():
|
|
data = json.loads((OPERATOR / "init.json").read_text())
|
|
for key in data["keys_base64"][:2]:
|
|
call("sys/unseal", {"key": key})
|
|
print("OpenBao unsealed by operator; shares not displayed.")
|
|
|
|
|
|
def ensure():
|
|
deadline = time.monotonic() + 60
|
|
while True:
|
|
try:
|
|
initialized = call("sys/init")["initialized"]
|
|
break
|
|
except OSError:
|
|
if time.monotonic() >= deadline:
|
|
raise
|
|
time.sleep(1)
|
|
if not initialized:
|
|
initialize()
|
|
elif call("sys/seal-status")["sealed"]:
|
|
raise SystemExit("OpenBao sealed: operator must run make security-unseal.")
|
|
|
|
|
|
def initialize():
|
|
if not call("sys/init")["initialized"]:
|
|
data = call("sys/init", {"secret_shares": 3, "secret_threshold": 2})
|
|
path = OPERATOR / "init.json"
|
|
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
|
with os.fdopen(fd, "w") as file:
|
|
json.dump(data, file)
|
|
unseal()
|
|
token = operator_token()
|
|
for path, payload in [
|
|
("sys/mounts/secret", {"type": "kv", "options": {"version": "2"}}),
|
|
("sys/auth/cert", {"type": "cert"}),
|
|
("sys/audit/file", {"type": "file", "options": {"file_path": "/bao/data/audit.json"}}),
|
|
]:
|
|
try:
|
|
call(path, payload, token)
|
|
except urllib.error.HTTPError as error:
|
|
if error.code != 400:
|
|
raise
|
|
for role in ROLES:
|
|
configure(role)
|
|
|
|
|
|
def configuration(role):
|
|
dbrole = "messenger" if role == "migrate" else "messenger_" + role
|
|
password = secret("postgres_password" if role == "migrate" else "db_" + role)
|
|
data = {"DATABASE_URL": f"postgresql://{dbrole}:{password}@postgres:5432/messenger"}
|
|
if role == "api":
|
|
data.update(
|
|
CACHE_URL="redis://api:" + secret("valkey_password") + "@127.0.0.1:6379/0",
|
|
CURSOR_SECRET=secret("cursor_secret"),
|
|
)
|
|
if role != "migrate":
|
|
keyrole = {"worker": "worker_", "relay": "relay_", "reconciler": "reconciler_"}.get(
|
|
role, ""
|
|
)
|
|
data.update(
|
|
S3_ACCESS_KEY_ID=secret("s3_" + keyrole + "access_key_id"),
|
|
S3_SECRET_ACCESS_KEY=secret("s3_" + keyrole + "secret_access_key"),
|
|
)
|
|
if role in ["worker", "relay"]:
|
|
brokerrole = "worker" if role == "worker" else "api"
|
|
data["BROKER_URL"] = (
|
|
"amqp://messenger-"
|
|
+ brokerrole
|
|
+ ":"
|
|
+ secret("rabbitmq_" + brokerrole + "_password")
|
|
+ "@127.0.0.1:5672/messenger"
|
|
)
|
|
return data
|
|
|
|
|
|
def configure(role):
|
|
token = operator_token()
|
|
policy = f'path "secret/data/{role}" {{ capabilities = ["read"] }}\n'
|
|
(ROOT / f"infra/openbao/{role}.hcl").write_text(policy)
|
|
call("sys/policies/acl/" + role, {"policy": policy}, token)
|
|
call(
|
|
"auth/cert/certs/" + role,
|
|
{
|
|
"certificate": (ROOT / f"secrets/pki/{role}/tls.crt").read_text(),
|
|
"allowed_common_names": [role],
|
|
"token_policies": [role],
|
|
"token_no_default_policy": True,
|
|
"token_ttl": 60,
|
|
"token_max_ttl": 300,
|
|
},
|
|
token,
|
|
)
|
|
call("secret/data/" + role, {"data": configuration(role)}, token)
|
|
|
|
|
|
def passwords():
|
|
for suffix in ["access_key_id", "secret_access_key"]:
|
|
path = ROOT / "secrets" / ("s3_relay_" + suffix)
|
|
if not path.exists():
|
|
path.write_text("relay" + secrets.token_hex(16))
|
|
path.chmod(0o644)
|
|
for role in ROLES:
|
|
if role == "migrate":
|
|
continue
|
|
path = ROOT / "secrets" / ("db_" + role)
|
|
if not path.exists():
|
|
path.write_text(secrets.token_hex(24))
|
|
path.chmod(0o600)
|
|
(ROOT / "secrets/valkey.conf").write_text(
|
|
"user default off\nuser api on >"
|
|
+ secret("valkey_password")
|
|
+ " ~session:* ~revoked:* +ping +get +set +del +exists +ttl +pttl +expire +pexpire"
|
|
" +eval +evalsha +script|load\n"
|
|
)
|
|
(ROOT / "secrets/valkey.conf").chmod(0o644)
|
|
|
|
|
|
def sql(text):
|
|
subprocess.run(
|
|
[
|
|
"docker",
|
|
"compose",
|
|
"exec",
|
|
"-T",
|
|
"postgres",
|
|
"psql",
|
|
"-U",
|
|
"messenger",
|
|
"-d",
|
|
"messenger",
|
|
"-v",
|
|
"ON_ERROR_STOP=1",
|
|
"-q",
|
|
],
|
|
input=text.encode(),
|
|
check=True,
|
|
stdout=subprocess.DEVNULL,
|
|
)
|
|
|
|
|
|
def rotate_worker(password):
|
|
if len(password) != 48 or any(char not in "0123456789abcdef" for char in password):
|
|
raise ValueError("Expected generated 24-byte hex password")
|
|
statement = f"ALTER ROLE messenger_worker PASSWORD '{password}'"
|
|
sql(statement)
|
|
sql(
|
|
"SELECT pg_terminate_backend(pid) FROM pg_stat_activity "
|
|
"WHERE usename='messenger_worker' AND pid <> pg_backend_pid();"
|
|
)
|
|
|
|
|
|
def roles():
|
|
for role in ROLES:
|
|
if role == "migrate":
|
|
continue
|
|
name = "messenger_" + role
|
|
sql(
|
|
"DO $$ BEGIN IF NOT EXISTS (SELECT FROM pg_roles WHERE rolname='"
|
|
+ name
|
|
+ "') THEN CREATE ROLE "
|
|
+ name
|
|
+ " LOGIN NOSUPERUSER NOCREATEDB NOCREATEROLE NOINHERIT NOREPLICATION;"
|
|
" END IF; END $$; ALTER ROLE "
|
|
+ name
|
|
+ " PASSWORD '"
|
|
+ secret("db_" + role)
|
|
+ "'; GRANT CONNECT ON DATABASE messenger TO "
|
|
+ name
|
|
+ "; GRANT USAGE ON SCHEMA public TO "
|
|
+ name
|
|
+ ";"
|
|
)
|
|
sql(
|
|
"REVOKE CREATE ON SCHEMA public FROM PUBLIC;"
|
|
" REVOKE ALL ON ALL TABLES IN SCHEMA public FROM PUBLIC;"
|
|
" GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO messenger_api;"
|
|
)
|
|
for role in ["worker", "relay"]:
|
|
sql(
|
|
"GRANT SELECT, INSERT, UPDATE, DELETE ON attachments, "
|
|
"attachment_variants, jobs, outbox, "
|
|
"job_events TO messenger_" + role + ";"
|
|
)
|
|
sql(
|
|
"GRANT SELECT ON ALL TABLES IN SCHEMA public TO messenger_reconciler;"
|
|
" GRANT UPDATE, DELETE ON attachments TO messenger_reconciler;"
|
|
)
|
|
print("Scoped database roles applied.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser()
|
|
parser.add_argument(
|
|
"action",
|
|
choices=["init", "unseal", "configure", "passwords", "roles", "seal", "revoke", "ensure"],
|
|
)
|
|
parser.add_argument("--role", choices=ROLES, default="worker")
|
|
args = parser.parse_args()
|
|
os.chdir(ROOT)
|
|
if args.action == "ensure":
|
|
ensure()
|
|
elif args.action == "init":
|
|
initialize()
|
|
elif args.action == "unseal":
|
|
unseal()
|
|
elif args.action == "configure":
|
|
configure(args.role)
|
|
elif args.action == "passwords":
|
|
passwords()
|
|
elif args.action == "roles":
|
|
roles()
|
|
elif args.action == "seal":
|
|
call("sys/seal", {}, operator_token())
|
|
elif args.action == "revoke":
|
|
call("auth/cert/certs/" + args.role, token=operator_token(), method="DELETE")
|