350 lines
12 KiB
Python
350 lines
12 KiB
Python
#!/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()
|