#!/usr/bin/env python3 """Idempotent local PKI/secrets bootstrap. Operator material never enters containers.""" import json import os import secrets import subprocess from pathlib import Path ROOT = Path(__file__).resolve().parents[1] PRIVATE = ROOT / "secrets" OPERATOR = ROOT / "operator-private" ROLES = ( "api", "worker", "dispatcher", "lb", "postgres", "storage", "broker", "cache", "collector", "prometheus", "loki", "tempo", "grafana", "openbao", "operator", ) def write(path, text, mode=0o644): if not path.exists(): path.write_text(text) path.chmod(mode) def run(*args): subprocess.run( ["openssl", *args], check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL ) def certificate(name, replace=False): dest = PRIVATE / "pki" / name dest.mkdir(parents=True, exist_ok=True) dest.chmod(0o755) if (dest / "cert.pem").exists() and not replace: valid = subprocess.run( ["openssl", "x509", "-in", str(dest / "cert.pem"), "-checkend", "3600", "-noout"], capture_output=True, ) if valid.returncode == 0: return key, csr = dest / "key.pem", OPERATOR / (name + ".csr") run("genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-256", "-out", str(key)) run("req", "-new", "-key", str(key), "-subj", f"/CN={name}", "-out", str(csr)) ext = OPERATOR / (name + ".ext") names = f"DNS:{name}" if name in { "lb", "api", "postgres", "broker", "cache", "collector", "prometheus", "loki", "tempo", "openbao", "grafana", "storage", }: names += ",DNS:localhost,IP:127.0.0.1" ext.write_text( f"subjectAltName={names}\nbasicConstraints=critical,CA:FALSE\nkeyUsage=critical,digitalSignature,keyEncipherment\nextendedKeyUsage=serverAuth,clientAuth\n" ) run( "x509", "-req", "-in", str(csr), "-CA", str(OPERATOR / "ca.pem"), "-CAkey", str(OPERATOR / "ca-key.pem"), "-set_serial", str(secrets.randbits(127) or 1), "-days", "2", "-extfile", str(ext), "-out", str(dest / "cert.pem"), ) key.chmod(0o644) (dest / "combined.pem").write_text((dest / "cert.pem").read_text() + key.read_text()) (dest / "combined.pem").chmod(0o644) def write_roles(): # Generated first-init SQL must follow rotated password files as well as a # fresh bootstrap. Existing DB roles are changed only by operator rotation. statements = [ f"CREATE ROLE {role} LOGIN PASSWORD '{(PRIVATE / (role + '_db_password')).read_text().strip()}';" for role in ("api", "worker", "dispatcher") ] (PRIVATE / "db_roles.sql").write_text("\n".join(statements)) (PRIVATE / "db_roles.sql").chmod(0o644) def main(): os.umask(0o077) for folder in (PRIVATE, OPERATOR): folder.mkdir(exist_ok=True) folder.chmod(0o700) if not (OPERATOR / "ca-key.pem").exists(): run( "genpkey", "-algorithm", "EC", "-pkeyopt", "ec_paramgen_curve:P-256", "-out", str(OPERATOR / "ca-key.pem"), ) run( "req", "-x509", "-new", "-key", str(OPERATOR / "ca-key.pem"), "-subj", "/CN=MTUSI Lab7 local CA", "-days", "365", "-addext", "basicConstraints=critical,CA:TRUE", "-addext", "keyUsage=critical,keyCertSign,cRLSign", "-out", str(OPERATOR / "ca.pem"), ) (PRIVATE / "ca.pem").write_text((OPERATOR / "ca.pem").read_text()) (PRIVATE / "ca.pem").chmod(0o644) (PRIVATE / "pki").mkdir(exist_ok=True) (PRIVATE / "pki").chmod(0o755) for name in ROLES: certificate(name) write(PRIVATE / "revoked.json", "[]") for name in ( "postgres_password", "api_db_password", "worker_db_password", "dispatcher_db_password", "cache_password", "cache_worker_password", "cache_dispatcher_password", "broker_worker_password", "broker_dispatcher_password", "broker_admin_password", "grafana_password", ): write(PRIVATE / name, secrets.token_urlsafe(32)) for role in ("api", "worker", "admin", "study_wide"): write(PRIVATE / (role + "_s3_access"), role + "-" + secrets.token_hex(12)) write(PRIVATE / (role + "_s3_secret"), secrets.token_urlsafe(32)) def value(name): return (PRIVATE / name).read_text().strip() identities = [] for role in ("api", "worker", "admin", "study_wide"): identities.append( { "name": role, "credentials": [ { "accessKey": value(role + "_s3_access"), "secretKey": value(role + "_s3_secret"), } ], "actions": ["Admin", "Read", "Write", "List"] if role == "admin" else ( ["Read:security-study", "Write:security-study", "List:security-study"] if role == "study_wide" else ["Read:messenger", "Write:messenger", "List:messenger"] ), } ) (PRIVATE / "s3_config").write_text(json.dumps({"identities": identities})) (PRIVATE / "s3_config").chmod(0o644) write( PRIVATE / "cache_config", 'bind 127.0.0.1\nport 6379\nprotected-mode yes\nsave ""\nmaxmemory 64mb\nmaxmemory-policy allkeys-lru\nuser default off\nuser api on >' + value("cache_password") + " ~user:v1:* +get +setex +ping +hello +client|setinfo\nuser worker on >" + value("cache_worker_password") + " +ping +hello +client|setinfo\nuser dispatcher on >" + value("cache_dispatcher_password") + " +ping +hello +client|setinfo\n", ) write( PRIVATE / "broker_config", 'bind 127.0.0.1\nport 6379\nprotected-mode yes\nappendonly yes\nappendfsync always\nsave ""\ndir /data\nmaxmemory 128mb\nmaxmemory-policy noeviction\nuser default off\nuser operator on >' + value("broker_admin_password") + " ~* &* +@all\nuser dispatcher on >" + value("broker_dispatcher_password") + " ~attachment-jobs:v1 +xadd +ping +hello +client|setinfo\nuser worker on >" + value("broker_worker_password") + " ~attachment-jobs:v1 +xgroup|create +xreadgroup +xautoclaim +xack +xdel +ping +hello +client|setinfo\n", ) pg = "postgresql://{role}:{password}@postgres:5432/messenger?sslmode=verify-full&sslrootcert=/run/tls/ca.pem" values = {} for role in ("api", "worker", "dispatcher"): values[role] = { "DATABASE_URL": pg.format(role=role, password=value(role + "_db_password")), "CACHE_URL": "rediss://" + role + ":" + value("cache_password" if role == "api" else "cache_" + role + "_password") + "@cache:6380/0?ssl_cert_reqs=required&ssl_check_hostname=True&ssl_ca_certs=/run/tls/ca.pem&ssl_certfile=/run/tls/identity/cert.pem&ssl_keyfile=/run/tls/identity/key.pem", } if role in {"worker", "dispatcher"}: values[role]["BROKER_URL"] = ( "rediss://" + role + ":" + value("broker_" + role + "_password") + "@broker:6380/0?ssl_cert_reqs=required&ssl_check_hostname=True&ssl_ca_certs=/run/tls/ca.pem&ssl_certfile=/run/tls/identity/cert.pem&ssl_keyfile=/run/tls/identity/key.pem" ) if role in {"api", "worker"}: values[role].update( S3_ACCESS_KEY=value(role + "_s3_access"), S3_SECRET_KEY=value(role + "_s3_secret") ) write(PRIVATE / "bao_seed.json", json.dumps(values)) write( PRIVATE / "admin_database_url", pg.format(role="messenger", password=value("postgres_password")), ) write(PRIVATE / "admin_s3_access_key", value("admin_s3_access")) write(PRIVATE / "admin_s3_secret_key", value("admin_s3_secret")) write_roles() gateways = { "api": {"port": 9443, "upstream": 8080, "allowed": ["lb"]}, "broker": { "port": 6380, "upstream": 6379, "allowed": ["worker", "dispatcher", "operator"], }, "cache": { "port": 6380, "upstream": 6379, "allowed": ["api", "worker", "dispatcher", "operator"], }, "storage": { "port": 8443, "upstream": 8333, "allowed": ["api", "worker", "operator"], "http": True, "s3": True, }, "collector": [ { "port": 4318, "upstream": 14318, "allowed": ["api", "worker", "dispatcher", "operator"], }, {"port": 9464, "upstream": 19464, "allowed": ["prometheus", "operator"]}, {"port": 8888, "upstream": 18888, "allowed": ["prometheus", "operator"]}, ], "prometheus": { "http": True, "backend": "prometheus", "port": 9443, "upstream": 9090, "allowed": ["grafana", "operator"], }, "loki": { "http": True, "backend": "loki", "port": 9443, "upstream": 3100, "allowed": ["collector", "grafana", "operator"], }, "tempo": [ { "port": 9443, "upstream": 3200, "allowed": ["grafana", "operator"], "http": True, "backend": "tempo", }, {"port": 44318, "upstream": 4318, "allowed": ["collector", "operator"]}, ], } for role, configs in gateways.items(): for item in configs if isinstance(configs, list) else [configs]: item.update( cert="/run/tls/identity/cert.pem", key="/run/tls/identity/key.pem", ca="/run/tls/ca.pem", ) (PRIVATE / (role + "_gateway.json")).write_text(json.dumps(configs)) (PRIVATE / (role + "_gateway.json")).chmod(0o644) provisioning = PRIVATE / "grafana-provisioning" / "datasources" provisioning.mkdir(parents=True, exist_ok=True) provisioning.parent.chmod(0o755) provisioning.chmod(0o755) datasources = [] for name in ("prometheus", "loki", "tempo"): item = { "name": name.title(), "uid": name, "type": name, "access": "proxy", "url": f"https://{name}:9443", "editable": False, "jsonData": {"tlsAuth": True, "tlsAuthWithCACert": True, "serverName": name}, "secureJsonData": { "tlsCACert": (PRIVATE / "ca.pem").read_text(), "tlsClientCert": (PRIVATE / "pki/grafana/cert.pem").read_text(), "tlsClientKey": (PRIVATE / "pki/grafana/key.pem").read_text(), }, } if name == "prometheus": item["isDefault"] = True if name == "loki": item["jsonData"]["derivedFields"] = [ { "datasourceUid": "tempo", "matcherRegex": '"trace_id": "([a-f0-9]{32})"', "name": "TraceID", "url": "$${__value.raw}", } ] datasources.append(item) (provisioning / "datasources.yaml").write_text( json.dumps({"apiVersion": 1, "datasources": datasources}) ) (provisioning / "datasources.yaml").chmod(0o644) if not (ROOT / ".env").exists(): (ROOT / ".env").write_text("PUBLIC_PORT=8447\nSESSION_TTL_SECONDS=3600\n") print("Local PKI and scoped credential material ready; operator CA stays outside containers.") if __name__ == "__main__": main()