This commit is contained in:
@@ -0,0 +1,130 @@
|
||||
#!/usr/bin/env python3
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import ssl
|
||||
from typing import Optional
|
||||
import urllib.error
|
||||
import urllib.request
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
SECRET_DIR = ROOT / "secrets"
|
||||
ROLE_DIR = SECRET_DIR / "openbao"
|
||||
SERVICES = {
|
||||
"api": ("DATABASE_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
|
||||
"worker": ("DATABASE_URL", "BROKER_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
|
||||
"publisher": ("DATABASE_URL", "BROKER_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
|
||||
"migrate": ("DATABASE_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
|
||||
"reconciler": ("DATABASE_URL", "S3_ACCESS_KEY_ID", "S3_SECRET_ACCESS_KEY"),
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description="Provision scoped OpenBao AppRoles for this local lab.")
|
||||
parser.add_argument("--root-token-file", required=True, help="Operator-only file outside version control")
|
||||
parser.add_argument("--ca-file", default=str(SECRET_DIR / "pki" / "ca.crt"))
|
||||
parser.add_argument("--address", default="https://localhost:8200")
|
||||
args = parser.parse_args()
|
||||
root_token = Path(args.root_token_file).read_text(encoding="utf-8").strip()
|
||||
if not root_token:
|
||||
raise SystemExit("Root token file is empty.")
|
||||
ROLE_DIR.mkdir(mode=0o700, parents=True, exist_ok=True)
|
||||
context = ssl.create_default_context(cafile=args.ca_file)
|
||||
|
||||
def request(method: str, path: str, payload: Optional[dict] = None) -> dict:
|
||||
headers = {"X-Vault-Token": root_token, "Content-Type": "application/json"}
|
||||
body = json.dumps(payload).encode("utf-8") if payload is not None else None
|
||||
req = urllib.request.Request(
|
||||
args.address.rstrip("/") + "/v1/" + path,
|
||||
data=body,
|
||||
headers=headers,
|
||||
method=method,
|
||||
)
|
||||
try:
|
||||
with urllib.request.urlopen(req, context=context, timeout=8) as response:
|
||||
content = response.read(1024 * 1024)
|
||||
return json.loads(content) if content else {}
|
||||
except urllib.error.HTTPError as exc:
|
||||
raise RuntimeError(f"OpenBao API request failed with HTTP {exc.code}") from None
|
||||
except (urllib.error.URLError, TimeoutError, OSError, ValueError) as exc:
|
||||
raise RuntimeError(f"OpenBao API request failed ({type(exc).__name__})") from None
|
||||
|
||||
mounts = request("GET", "sys/mounts")
|
||||
if "secret/" not in mounts.get("data", {}):
|
||||
request("POST", "sys/mounts/secret", {"type": "kv", "options": {"version": "2"}})
|
||||
auth = request("GET", "sys/auth")
|
||||
if "approle/" not in auth.get("data", {}):
|
||||
request("POST", "sys/auth/approle", {"type": "approle"})
|
||||
|
||||
local_values = {
|
||||
"DATABASE_URL": (SECRET_DIR / "database_url").read_text(encoding="utf-8").strip(),
|
||||
"WORKER_DATABASE_URL": (SECRET_DIR / "worker_database_url").read_text(encoding="utf-8").strip(),
|
||||
"BROKER_URL": "",
|
||||
"S3_ACCESS_KEY_ID": (SECRET_DIR / "s3_access_key_id").read_text(encoding="utf-8").strip(),
|
||||
"S3_SECRET_ACCESS_KEY": (SECRET_DIR / "s3_secret_access_key").read_text(encoding="utf-8").strip(),
|
||||
}
|
||||
service_s3_files = {
|
||||
"api": ("s3_access_key_id", "s3_secret_access_key"),
|
||||
**{
|
||||
service: (f"{service}_s3_access_key_id", f"{service}_s3_secret_access_key")
|
||||
for service in ("worker", "publisher", "migrate", "reconciler")
|
||||
},
|
||||
}
|
||||
|
||||
for service, keys in SERVICES.items():
|
||||
if service in ("worker", "publisher"):
|
||||
local_values["BROKER_URL"] = (
|
||||
SECRET_DIR / f"broker_{service}_url"
|
||||
).read_text(encoding="utf-8").strip()
|
||||
policy_name = f"messenger-{service}"
|
||||
policy = (
|
||||
f'path "secret/data/messenger/{service}" {{\n'
|
||||
' capabilities = ["read"]\n'
|
||||
'}\n'
|
||||
)
|
||||
request("PUT", f"sys/policies/acl/{policy_name}", {"policy": policy})
|
||||
request(
|
||||
"POST",
|
||||
f"auth/approle/role/{service}",
|
||||
{
|
||||
"token_policies": [policy_name],
|
||||
"token_ttl": "15m",
|
||||
"token_max_ttl": "1h",
|
||||
"secret_id_ttl": "24h",
|
||||
"secret_id_num_uses": 0,
|
||||
},
|
||||
)
|
||||
service_values = dict(local_values)
|
||||
access_key_file, secret_key_file = service_s3_files[service]
|
||||
service_values["S3_ACCESS_KEY_ID"] = (
|
||||
SECRET_DIR / access_key_file
|
||||
).read_text(encoding="utf-8").strip()
|
||||
service_values["S3_SECRET_ACCESS_KEY"] = (
|
||||
SECRET_DIR / secret_key_file
|
||||
).read_text(encoding="utf-8").strip()
|
||||
if service == "worker":
|
||||
service_values["DATABASE_URL"] = local_values["WORKER_DATABASE_URL"]
|
||||
request(
|
||||
"POST",
|
||||
f"secret/data/messenger/{service}",
|
||||
{"data": {key: service_values[key] for key in keys}},
|
||||
)
|
||||
role = request("GET", f"auth/approle/role/{service}/role-id")
|
||||
role_id = role.get("data", {}).get("role_id")
|
||||
secret = request("POST", f"auth/approle/role/{service}/secret-id", {})
|
||||
secret_id = secret.get("data", {}).get("secret_id")
|
||||
if not role_id or not secret_id:
|
||||
raise RuntimeError(f"OpenBao did not return credentials for the {service} role")
|
||||
for suffix, value in (("role_id", role_id), ("secret_id", secret_id)):
|
||||
path = ROLE_DIR / f"{service}_{suffix}"
|
||||
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
|
||||
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
|
||||
output.write(value + "\n")
|
||||
|
||||
print("OpenBao policies, scoped AppRoles and service credentials provisioned; values were not printed.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,201 @@
|
||||
#!/usr/bin/env python3
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
PKI_DIR = ROOT / "secrets" / "pki"
|
||||
|
||||
|
||||
def openssl(*args: str) -> None:
|
||||
subprocess.run(
|
||||
["openssl", *args],
|
||||
check=True,
|
||||
stdout=subprocess.DEVNULL,
|
||||
stderr=subprocess.DEVNULL,
|
||||
)
|
||||
|
||||
|
||||
def create_leaf(
|
||||
work: Path,
|
||||
name: str,
|
||||
subject: str,
|
||||
sans: str,
|
||||
extended_usage: str,
|
||||
ca_key: Path,
|
||||
ca_cert: Path,
|
||||
) -> tuple[Path, Path]:
|
||||
key = PKI_DIR / f"{name}.key"
|
||||
cert = PKI_DIR / f"{name}.crt"
|
||||
request = work / f"{name}.csr"
|
||||
extensions = work / f"{name}.ext"
|
||||
openssl(
|
||||
"req",
|
||||
"-new",
|
||||
"-newkey",
|
||||
"rsa:2048",
|
||||
"-nodes",
|
||||
"-keyout",
|
||||
str(key),
|
||||
"-out",
|
||||
str(request),
|
||||
"-subj",
|
||||
subject,
|
||||
)
|
||||
extensions.write_text(
|
||||
"basicConstraints=critical,CA:FALSE\n"
|
||||
"keyUsage=critical,digitalSignature,keyEncipherment\n"
|
||||
f"extendedKeyUsage={extended_usage}\n"
|
||||
f"subjectAltName={sans}\n",
|
||||
encoding="ascii",
|
||||
)
|
||||
openssl(
|
||||
"x509",
|
||||
"-req",
|
||||
"-in",
|
||||
str(request),
|
||||
"-CA",
|
||||
str(ca_cert),
|
||||
"-CAkey",
|
||||
str(ca_key),
|
||||
"-CAcreateserial",
|
||||
"-out",
|
||||
str(cert),
|
||||
"-days",
|
||||
"397",
|
||||
"-sha256",
|
||||
"-extfile",
|
||||
str(extensions),
|
||||
)
|
||||
os.chmod(key, 0o600)
|
||||
os.chmod(cert, 0o644)
|
||||
return cert, key
|
||||
|
||||
|
||||
def bundle(cert: Path, key: Path, output: Path) -> None:
|
||||
output.write_bytes(cert.read_bytes() + key.read_bytes())
|
||||
os.chmod(output, 0o600)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
if PKI_DIR.exists():
|
||||
raise SystemExit("PKI files already exist; rotate them with an explicit rollover procedure.")
|
||||
if not shutil.which("openssl"):
|
||||
raise SystemExit("OpenSSL is required to generate local certificates.")
|
||||
|
||||
PKI_DIR.mkdir(mode=0o700, parents=True)
|
||||
ca_key = PKI_DIR / "ca.key"
|
||||
ca_cert = PKI_DIR / "ca.crt"
|
||||
openssl(
|
||||
"req",
|
||||
"-x509",
|
||||
"-newkey",
|
||||
"rsa:3072",
|
||||
"-nodes",
|
||||
"-keyout",
|
||||
str(ca_key),
|
||||
"-out",
|
||||
str(ca_cert),
|
||||
"-days",
|
||||
"3650",
|
||||
"-sha256",
|
||||
"-subj",
|
||||
"/CN=mtusi2026lab7-local-ca",
|
||||
"-addext",
|
||||
"basicConstraints=critical,CA:TRUE",
|
||||
"-addext",
|
||||
"keyUsage=critical,keyCertSign,cRLSign",
|
||||
)
|
||||
os.chmod(ca_key, 0o600)
|
||||
os.chmod(ca_cert, 0o644)
|
||||
|
||||
with tempfile.TemporaryDirectory(prefix="lab7-pki-") as directory:
|
||||
work = Path(directory)
|
||||
foreign_ca_key = PKI_DIR / "foreign-ca.key"
|
||||
foreign_ca_cert = PKI_DIR / "foreign-ca.crt"
|
||||
openssl(
|
||||
"req",
|
||||
"-x509",
|
||||
"-newkey",
|
||||
"rsa:2048",
|
||||
"-nodes",
|
||||
"-keyout",
|
||||
str(foreign_ca_key),
|
||||
"-out",
|
||||
str(foreign_ca_cert),
|
||||
"-days",
|
||||
"365",
|
||||
"-sha256",
|
||||
"-subj",
|
||||
"/CN=mtusi2026lab7-untrusted-ca",
|
||||
"-addext",
|
||||
"basicConstraints=critical,CA:TRUE",
|
||||
"-addext",
|
||||
"keyUsage=critical,keyCertSign,cRLSign",
|
||||
)
|
||||
os.chmod(foreign_ca_key, 0o600)
|
||||
os.chmod(foreign_ca_cert, 0o644)
|
||||
ingress_cert, ingress_key = create_leaf(
|
||||
work,
|
||||
"ingress",
|
||||
"/CN=localhost",
|
||||
"DNS:localhost,IP:127.0.0.1",
|
||||
"serverAuth",
|
||||
ca_key,
|
||||
ca_cert,
|
||||
)
|
||||
create_leaf(
|
||||
work,
|
||||
"api",
|
||||
"/CN=api",
|
||||
"DNS:api,IP:127.0.0.1",
|
||||
"serverAuth",
|
||||
ca_key,
|
||||
ca_cert,
|
||||
)
|
||||
client_cert, client_key = create_leaf(
|
||||
work,
|
||||
"lb-client",
|
||||
"/CN=lab7-load-balancer",
|
||||
"URI:spiffe://mtusi2026lab7/load-balancer",
|
||||
"clientAuth",
|
||||
ca_key,
|
||||
ca_cert,
|
||||
)
|
||||
create_leaf(
|
||||
work,
|
||||
"wrong-client",
|
||||
"/CN=lab7-untrusted-service",
|
||||
"URI:spiffe://mtusi2026lab7/other-service",
|
||||
"clientAuth",
|
||||
ca_key,
|
||||
ca_cert,
|
||||
)
|
||||
create_leaf(
|
||||
work,
|
||||
"foreign-client",
|
||||
"/CN=lab7-foreign-service",
|
||||
"URI:spiffe://mtusi2026lab7/load-balancer",
|
||||
"clientAuth",
|
||||
foreign_ca_key,
|
||||
foreign_ca_cert,
|
||||
)
|
||||
create_leaf(
|
||||
work,
|
||||
"openbao",
|
||||
"/CN=openbao",
|
||||
"DNS:openbao,DNS:localhost,IP:127.0.0.1",
|
||||
"serverAuth",
|
||||
ca_key,
|
||||
ca_cert,
|
||||
)
|
||||
bundle(ingress_cert, ingress_key, PKI_DIR / "ingress.pem")
|
||||
bundle(client_cert, client_key, PKI_DIR / "lb-client.pem")
|
||||
print("Local CA and leaf certificates created under secrets/pki with private permissions.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,254 @@
|
||||
#!/usr/bin/env python3
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import secrets
|
||||
from pathlib import Path
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
SECRET_DIR = ROOT / "secrets"
|
||||
|
||||
|
||||
def main():
|
||||
SECRET_DIR.mkdir(mode=0o700, exist_ok=True)
|
||||
os.chmod(SECRET_DIR, 0o700)
|
||||
names = (
|
||||
"postgres_password",
|
||||
"database_url",
|
||||
"worker_db_password",
|
||||
"worker_database_url",
|
||||
"s3_access_key_id",
|
||||
"s3_secret_access_key",
|
||||
"worker_s3_access_key_id",
|
||||
"worker_s3_secret_access_key",
|
||||
"publisher_s3_access_key_id",
|
||||
"publisher_s3_secret_access_key",
|
||||
"migrate_s3_access_key_id",
|
||||
"migrate_s3_secret_access_key",
|
||||
"reconciler_s3_access_key_id",
|
||||
"reconciler_s3_secret_access_key",
|
||||
"s3_admin_access_key_id",
|
||||
"s3_admin_secret_access_key",
|
||||
"rabbitmq_password",
|
||||
"rabbitmq.conf",
|
||||
"rabbitmq_definitions.json",
|
||||
"broker_url",
|
||||
"broker_worker_url",
|
||||
"broker_publisher_url",
|
||||
"s3.json",
|
||||
"s3_iam.json",
|
||||
"grafana_admin_password",
|
||||
)
|
||||
existing = [name for name in names if (SECRET_DIR / name).exists()]
|
||||
if existing:
|
||||
raise SystemExit(
|
||||
"Secret files already exist; refusing to rotate credentials without a migration: "
|
||||
+ ", ".join(existing)
|
||||
)
|
||||
|
||||
db_password = secrets.token_hex(24)
|
||||
worker_db_password = secrets.token_urlsafe(32)
|
||||
broker_password = secrets.token_urlsafe(32)
|
||||
worker_broker_password = secrets.token_urlsafe(32)
|
||||
publisher_broker_password = secrets.token_urlsafe(32)
|
||||
values = {
|
||||
"postgres_password": db_password,
|
||||
"database_url": (
|
||||
f"postgresql://messenger:{db_password}@postgres:5432/messenger"
|
||||
"?sslmode=verify-full&sslrootcert=/run/secrets/ca_crt"
|
||||
),
|
||||
"worker_db_password": worker_db_password,
|
||||
"worker_database_url": (
|
||||
f"postgresql://messenger_worker:{worker_db_password}@postgres:5432/messenger"
|
||||
"?sslmode=verify-full&sslrootcert=/run/secrets/ca_crt"
|
||||
),
|
||||
"s3_access_key_id": "mngr" + secrets.token_hex(8),
|
||||
"s3_secret_access_key": secrets.token_urlsafe(40),
|
||||
"worker_s3_access_key_id": "wrk" + secrets.token_hex(8),
|
||||
"worker_s3_secret_access_key": secrets.token_urlsafe(40),
|
||||
"publisher_s3_access_key_id": "pub" + secrets.token_hex(8),
|
||||
"publisher_s3_secret_access_key": secrets.token_urlsafe(40),
|
||||
"migrate_s3_access_key_id": "mig" + secrets.token_hex(8),
|
||||
"migrate_s3_secret_access_key": secrets.token_urlsafe(40),
|
||||
"reconciler_s3_access_key_id": "rec" + secrets.token_hex(8),
|
||||
"reconciler_s3_secret_access_key": secrets.token_urlsafe(40),
|
||||
"s3_admin_access_key_id": "admin" + secrets.token_hex(7),
|
||||
"s3_admin_secret_access_key": secrets.token_urlsafe(40),
|
||||
"rabbitmq_password": broker_password,
|
||||
"broker_url": f"amqps://worker:{worker_broker_password}@rabbitmq:5671/%2f",
|
||||
"broker_worker_url": f"amqps://worker:{worker_broker_password}@rabbitmq:5671/%2f",
|
||||
"broker_publisher_url": f"amqps://publisher:{publisher_broker_password}@rabbitmq:5671/%2f",
|
||||
"grafana_admin_password": secrets.token_urlsafe(32),
|
||||
}
|
||||
for name, value in values.items():
|
||||
if name.startswith("broker_") and name != "broker_url":
|
||||
descriptor = os.open(SECRET_DIR / name, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
||||
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
|
||||
output.write(value + "\n")
|
||||
continue
|
||||
path = SECRET_DIR / name
|
||||
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
||||
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
|
||||
output.write(value + "\n")
|
||||
descriptor = os.open(
|
||||
SECRET_DIR / "rabbitmq.conf",
|
||||
os.O_WRONLY | os.O_CREAT | os.O_EXCL,
|
||||
0o600,
|
||||
)
|
||||
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
|
||||
output.write("default_user = messenger\n")
|
||||
output.write(f"default_pass = {broker_password}\n")
|
||||
output.write("listeners.tcp = none\n")
|
||||
output.write("listeners.ssl.default = 5671\n")
|
||||
output.write("ssl_options.cacertfile = /run/secrets/ca_crt\n")
|
||||
output.write("ssl_options.certfile = /run/secrets/rabbitmq_tls_cert\n")
|
||||
output.write("ssl_options.keyfile = /run/secrets/rabbitmq_tls_key\n")
|
||||
output.write("ssl_options.verify = verify_peer\n")
|
||||
output.write("ssl_options.fail_if_no_peer_cert = true\n")
|
||||
output.write("ssl_options.versions.1 = tlsv1.2\n")
|
||||
output.write("definitions.import_backend = local_filesystem\n")
|
||||
output.write("definitions.local.path = /run/secrets/rabbitmq_definitions.json\n")
|
||||
definitions = {
|
||||
"users": [],
|
||||
"vhosts": [{"name": "/"}],
|
||||
"permissions": [],
|
||||
"queues": [
|
||||
{
|
||||
"name": "attachments.process.dead",
|
||||
"vhost": "/",
|
||||
"durable": True,
|
||||
"auto_delete": False,
|
||||
"arguments": {"x-queue-type": "quorum", "x-quorum-initial-group-size": 1},
|
||||
},
|
||||
{
|
||||
"name": "attachments.process.v1",
|
||||
"vhost": "/",
|
||||
"durable": True,
|
||||
"auto_delete": False,
|
||||
"arguments": {
|
||||
"x-queue-type": "quorum",
|
||||
"x-quorum-initial-group-size": 1,
|
||||
"x-dead-letter-exchange": "",
|
||||
"x-dead-letter-routing-key": "attachments.process.dead",
|
||||
},
|
||||
},
|
||||
],
|
||||
}
|
||||
for username, password, configure, write, read in (
|
||||
("worker", worker_broker_password, r"^$", r"^$", r"^attachments\.process\.v1$"),
|
||||
("publisher", publisher_broker_password, r"^$", r"^amq\.default$", r"^$"),
|
||||
):
|
||||
salt = secrets.token_bytes(4)
|
||||
password_hash = __import__("hashlib").sha256(salt + password.encode("utf-8")).digest()
|
||||
definitions["users"].append({
|
||||
"name": username,
|
||||
"password_hash": __import__("base64").b64encode(salt + password_hash).decode("ascii"),
|
||||
"hashing_algorithm": "rabbit_password_hashing_sha256",
|
||||
"tags": "",
|
||||
})
|
||||
definitions["permissions"].append({
|
||||
"user": username,
|
||||
"vhost": "/",
|
||||
"configure": configure,
|
||||
"write": write,
|
||||
"read": read,
|
||||
})
|
||||
descriptor = os.open(
|
||||
SECRET_DIR / "rabbitmq_definitions.json",
|
||||
os.O_WRONLY | os.O_CREAT | os.O_EXCL,
|
||||
0o600,
|
||||
)
|
||||
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
|
||||
json.dump(definitions, output, separators=(",", ":"))
|
||||
output.write("\n")
|
||||
os.chmod(SECRET_DIR / "rabbitmq_definitions.json", 0o644)
|
||||
s3_config = {
|
||||
"identities": [
|
||||
{
|
||||
"name": "bootstrap-admin",
|
||||
"credentials": [
|
||||
{
|
||||
"accessKey": values["s3_admin_access_key_id"],
|
||||
"secretKey": values["s3_admin_secret_access_key"],
|
||||
}
|
||||
],
|
||||
"actions": ["Admin"],
|
||||
},
|
||||
{
|
||||
"name": "messenger-api",
|
||||
"credentials": [
|
||||
{
|
||||
"accessKey": values["s3_access_key_id"],
|
||||
"secretKey": values["s3_secret_access_key"],
|
||||
}
|
||||
],
|
||||
"actions": [
|
||||
"Read:messenger-attachments",
|
||||
"List:messenger-attachments",
|
||||
"Read:messenger-variants",
|
||||
"Write:messenger-staging",
|
||||
],
|
||||
},
|
||||
{
|
||||
"name": "messenger-worker",
|
||||
"credentials": [{
|
||||
"accessKey": values["worker_s3_access_key_id"],
|
||||
"secretKey": values["worker_s3_secret_access_key"],
|
||||
}],
|
||||
"actions": [
|
||||
"Read:messenger-staging",
|
||||
"Write:messenger-staging",
|
||||
"Write:messenger-attachments",
|
||||
"Write:messenger-variants",
|
||||
],
|
||||
},
|
||||
*[
|
||||
{
|
||||
"name": f"messenger-{service}",
|
||||
"credentials": [{
|
||||
"accessKey": values[f"{service}_s3_access_key_id"],
|
||||
"secretKey": values[f"{service}_s3_secret_access_key"],
|
||||
}],
|
||||
"actions": [],
|
||||
}
|
||||
for service in ("publisher", "migrate")
|
||||
],
|
||||
{
|
||||
"name": "messenger-reconciler",
|
||||
"credentials": [{
|
||||
"accessKey": values["reconciler_s3_access_key_id"],
|
||||
"secretKey": values["reconciler_s3_secret_access_key"],
|
||||
}],
|
||||
"actions": [
|
||||
f"{action}:{bucket}"
|
||||
for bucket in ("messenger-staging", "messenger-attachments", "messenger-variants")
|
||||
for action in ("Read", "Write", "List")
|
||||
],
|
||||
},
|
||||
]
|
||||
}
|
||||
descriptor = os.open(SECRET_DIR / "s3.json", os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
||||
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
|
||||
json.dump(s3_config, output, separators=(",", ":"))
|
||||
output.write("\n")
|
||||
iam_config = {
|
||||
"sts": {"signingKey": "base64-" + base64.urlsafe_b64encode(secrets.token_bytes(32)).decode("ascii")},
|
||||
"defaultEffect": "Deny",
|
||||
}
|
||||
descriptor = os.open(SECRET_DIR / "s3_iam.json", os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
||||
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
|
||||
json.dump(iam_config, output, separators=(",", ":"))
|
||||
output.write("\n")
|
||||
role_dir = SECRET_DIR / "openbao"
|
||||
role_dir.mkdir(mode=0o700, exist_ok=True)
|
||||
for service in ("api", "worker", "publisher", "migrate", "reconciler"):
|
||||
for suffix in ("role_id", "secret_id"):
|
||||
path = role_dir / f"{service}_{suffix}"
|
||||
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
|
||||
os.close(descriptor)
|
||||
print("Local secrets generated with owner-only permissions; values were not printed.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,92 @@
|
||||
#!/usr/bin/env python3
|
||||
import argparse
|
||||
import os
|
||||
from pathlib import Path
|
||||
import shutil
|
||||
import subprocess
|
||||
import tempfile
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
PKI_DIR = ROOT / "secrets" / "pki"
|
||||
SERVICES = {
|
||||
"rabbitmq": ("DNS:rabbitmq", "serverAuth"),
|
||||
"s3": ("DNS:s3", "serverAuth"),
|
||||
"postgres": ("DNS:postgres", "serverAuth"),
|
||||
"otel-collector": ("DNS:otel-collector", "serverAuth"),
|
||||
"tempo": ("DNS:tempo", "serverAuth"),
|
||||
"loki": ("DNS:loki", "serverAuth"),
|
||||
"prometheus": ("DNS:prometheus", "serverAuth"),
|
||||
"collector-prometheus-client": ("URI:spiffe://mtusi2026lab7/collector", "clientAuth"),
|
||||
"otel-api-client": ("URI:spiffe://mtusi2026lab7/api", "clientAuth"),
|
||||
"otel-worker-client": ("URI:spiffe://mtusi2026lab7/worker", "clientAuth"),
|
||||
"otel-publisher-client": ("URI:spiffe://mtusi2026lab7/publisher", "clientAuth"),
|
||||
"rabbitmq-api-client": ("URI:spiffe://mtusi2026lab7/api", "clientAuth"),
|
||||
"rabbitmq-worker-client": ("URI:spiffe://mtusi2026lab7/worker", "clientAuth"),
|
||||
"rabbitmq-publisher-client": ("URI:spiffe://mtusi2026lab7/publisher", "clientAuth"),
|
||||
"s3-api-client": ("URI:spiffe://mtusi2026lab7/api", "clientAuth"),
|
||||
"s3-worker-client": ("URI:spiffe://mtusi2026lab7/worker", "clientAuth"),
|
||||
"s3-publisher-client": ("URI:spiffe://mtusi2026lab7/publisher", "clientAuth"),
|
||||
"s3-migrate-client": ("URI:spiffe://mtusi2026lab7/migrate", "clientAuth"),
|
||||
"s3-reconciler-client": ("URI:spiffe://mtusi2026lab7/reconciler", "clientAuth"),
|
||||
"s3-bootstrap-client": ("URI:spiffe://mtusi2026lab7/s3-bootstrap", "clientAuth"),
|
||||
"s3-healthcheck-client": ("URI:spiffe://mtusi2026lab7/s3-healthcheck", "clientAuth"),
|
||||
}
|
||||
|
||||
|
||||
def openssl(*args: str) -> None:
|
||||
subprocess.run(
|
||||
["openssl", *args],
|
||||
check=True,
|
||||
stdout=subprocess.DEVNULL,
|
||||
stderr=subprocess.DEVNULL,
|
||||
)
|
||||
|
||||
|
||||
def main() -> None:
|
||||
parser = argparse.ArgumentParser(description="Issue local short-lived mTLS service identities.")
|
||||
parser.add_argument("--days", type=int, default=30)
|
||||
args = parser.parse_args()
|
||||
if not 1 <= args.days <= 90:
|
||||
parser.error("service certificate lifetime must be between 1 and 90 days")
|
||||
if not (PKI_DIR / "ca.key").is_file() or not (PKI_DIR / "ca.crt").is_file():
|
||||
raise SystemExit("Create the local CA first with scripts/bootstrap-pki.py.")
|
||||
if not shutil.which("openssl"):
|
||||
raise SystemExit("OpenSSL is required to issue service certificates.")
|
||||
missing = {
|
||||
name: identity for name, identity in SERVICES.items()
|
||||
if not (PKI_DIR / f"{name}.crt").exists()
|
||||
}
|
||||
if not missing:
|
||||
raise SystemExit("All service certificates already exist; rotate them explicitly.")
|
||||
|
||||
with tempfile.TemporaryDirectory(prefix="lab7-service-pki-") as directory:
|
||||
work = Path(directory)
|
||||
for name, (san, usage) in missing.items():
|
||||
key = PKI_DIR / f"{name}.key"
|
||||
cert = PKI_DIR / f"{name}.crt"
|
||||
csr = work / f"{name}.csr"
|
||||
extension = work / f"{name}.ext"
|
||||
openssl(
|
||||
"req", "-new", "-newkey", "rsa:2048", "-nodes",
|
||||
"-keyout", str(key), "-out", str(csr), "-subj", f"/CN={name}",
|
||||
)
|
||||
extension.write_text(
|
||||
"basicConstraints=critical,CA:FALSE\n"
|
||||
"keyUsage=critical,digitalSignature,keyEncipherment\n"
|
||||
f"extendedKeyUsage={usage}\n"
|
||||
f"subjectAltName={san}\n",
|
||||
encoding="ascii",
|
||||
)
|
||||
openssl(
|
||||
"x509", "-req", "-in", str(csr), "-CA", str(PKI_DIR / "ca.crt"),
|
||||
"-CAkey", str(PKI_DIR / "ca.key"), "-CAcreateserial", "-out", str(cert),
|
||||
"-days", str(args.days), "-sha256", "-extfile", str(extension),
|
||||
)
|
||||
os.chmod(key, 0o600)
|
||||
os.chmod(cert, 0o644)
|
||||
print(f"Issued {len(missing)} service certificates with {args.days}-day validity.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,228 @@
|
||||
#!/usr/bin/env python3
|
||||
import base64
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
from pathlib import Path
|
||||
import secrets
|
||||
from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit
|
||||
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
SECRET_DIR = ROOT / "secrets"
|
||||
|
||||
|
||||
def read(name: str) -> str:
|
||||
return (SECRET_DIR / name).read_text(encoding="utf-8").strip()
|
||||
|
||||
|
||||
def write(name: str, content: str, replace: bool = False) -> None:
|
||||
path = SECRET_DIR / name
|
||||
flags = os.O_WRONLY | os.O_CREAT | (os.O_TRUNC if replace else os.O_EXCL)
|
||||
descriptor = os.open(path, flags, 0o600)
|
||||
with os.fdopen(descriptor, "w", encoding="utf-8") as output:
|
||||
output.write(content)
|
||||
if not content.endswith("\n"):
|
||||
output.write("\n")
|
||||
|
||||
|
||||
def rabbit_user(name: str, password: str) -> dict:
|
||||
salt = secrets.token_bytes(4)
|
||||
digest = hashlib.sha256(salt + password.encode("utf-8")).digest()
|
||||
return {
|
||||
"name": name,
|
||||
"password_hash": base64.b64encode(salt + digest).decode("ascii"),
|
||||
"hashing_algorithm": "rabbit_password_hashing_sha256",
|
||||
"tags": "",
|
||||
}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
os.chmod(SECRET_DIR, 0o700)
|
||||
db_parts = urlsplit(read("database_url"))
|
||||
query = dict(parse_qsl(db_parts.query, keep_blank_values=True))
|
||||
query.update({"sslmode": "verify-full", "sslrootcert": "/run/secrets/ca_crt"})
|
||||
write(
|
||||
"database_url",
|
||||
urlunsplit((db_parts.scheme, db_parts.netloc, db_parts.path, urlencode(query), "")),
|
||||
replace=True,
|
||||
)
|
||||
worker_password_path = SECRET_DIR / "worker_db_password"
|
||||
if not worker_password_path.exists():
|
||||
write("worker_db_password", secrets.token_urlsafe(32))
|
||||
worker_password = read("worker_db_password")
|
||||
write(
|
||||
"worker_database_url",
|
||||
urlunsplit(
|
||||
(
|
||||
db_parts.scheme,
|
||||
f"messenger_worker:{worker_password}@{db_parts.hostname}:{db_parts.port}",
|
||||
db_parts.path,
|
||||
urlencode(query),
|
||||
"",
|
||||
)
|
||||
),
|
||||
replace=(SECRET_DIR / "worker_database_url").exists(),
|
||||
)
|
||||
|
||||
service_s3_credentials = {}
|
||||
for service in ("worker", "publisher", "migrate", "reconciler"):
|
||||
access_key_file = f"{service}_s3_access_key_id"
|
||||
secret_key_file = f"{service}_s3_secret_access_key"
|
||||
if not (SECRET_DIR / access_key_file).exists():
|
||||
write(access_key_file, service[:3] + secrets.token_hex(8))
|
||||
if not (SECRET_DIR / secret_key_file).exists():
|
||||
write(secret_key_file, secrets.token_urlsafe(40))
|
||||
service_s3_credentials[service] = (
|
||||
read(access_key_file),
|
||||
read(secret_key_file),
|
||||
)
|
||||
|
||||
credentials = {}
|
||||
users = []
|
||||
permissions = []
|
||||
for service, configure, write_access, read_access in (
|
||||
("worker", r"^$", r"^$", r"^attachments\.process\.v1$"),
|
||||
("publisher", r"^$", r"^amq\.default$", r"^$"),
|
||||
):
|
||||
password_file = f"rabbitmq_{service}_password"
|
||||
password_path = SECRET_DIR / password_file
|
||||
password = password_path.read_text(encoding="utf-8").strip() if password_path.exists() else secrets.token_urlsafe(32)
|
||||
if not password_path.exists():
|
||||
write(password_file, password)
|
||||
credentials[service] = password
|
||||
users.append(rabbit_user(service, password))
|
||||
permissions.append({
|
||||
"user": service,
|
||||
"vhost": "/",
|
||||
"configure": configure,
|
||||
"write": write_access,
|
||||
"read": read_access,
|
||||
})
|
||||
write(
|
||||
f"broker_{service}_url",
|
||||
f"amqps://{service}:{password}@rabbitmq:5671/%2f",
|
||||
replace=(SECRET_DIR / f"broker_{service}_url").exists(),
|
||||
)
|
||||
|
||||
definitions = {
|
||||
"users": users,
|
||||
"vhosts": [{"name": "/"}],
|
||||
"permissions": permissions,
|
||||
"queues": [
|
||||
{
|
||||
"name": "attachments.process.dead",
|
||||
"vhost": "/",
|
||||
"durable": True,
|
||||
"auto_delete": False,
|
||||
"arguments": {"x-queue-type": "quorum", "x-quorum-initial-group-size": 1},
|
||||
},
|
||||
{
|
||||
"name": "attachments.process.v1",
|
||||
"vhost": "/",
|
||||
"durable": True,
|
||||
"auto_delete": False,
|
||||
"arguments": {
|
||||
"x-queue-type": "quorum",
|
||||
"x-quorum-initial-group-size": 1,
|
||||
"x-dead-letter-exchange": "",
|
||||
"x-dead-letter-routing-key": "attachments.process.dead",
|
||||
},
|
||||
},
|
||||
],
|
||||
}
|
||||
definitions_path = SECRET_DIR / "rabbitmq_definitions.json"
|
||||
if definitions_path.exists():
|
||||
definitions_path.unlink()
|
||||
write("rabbitmq_definitions.json", json.dumps(definitions, separators=(",", ":")))
|
||||
os.chmod(definitions_path, 0o644)
|
||||
|
||||
config = (
|
||||
"default_user = messenger\n"
|
||||
f"default_pass = {read('rabbitmq_password')}\n"
|
||||
"listeners.tcp = none\n"
|
||||
"listeners.ssl.default = 5671\n"
|
||||
"ssl_options.cacertfile = /run/secrets/ca_crt\n"
|
||||
"ssl_options.certfile = /run/secrets/rabbitmq_tls_cert\n"
|
||||
"ssl_options.keyfile = /run/secrets/rabbitmq_tls_key\n"
|
||||
"ssl_options.verify = verify_peer\n"
|
||||
"ssl_options.fail_if_no_peer_cert = true\n"
|
||||
"ssl_options.versions.1 = tlsv1.2\n"
|
||||
"definitions.import_backend = local_filesystem\n"
|
||||
"definitions.local.path = /run/secrets/rabbitmq_definitions\n"
|
||||
)
|
||||
write("rabbitmq.conf", config, replace=True)
|
||||
identities = [
|
||||
{
|
||||
"name": "bootstrap-admin",
|
||||
"credentials": [{
|
||||
"accessKey": read("s3_admin_access_key_id"),
|
||||
"secretKey": read("s3_admin_secret_access_key"),
|
||||
}],
|
||||
"actions": ["Admin"],
|
||||
},
|
||||
{
|
||||
"name": "messenger-api",
|
||||
"credentials": [{
|
||||
"accessKey": read("s3_access_key_id"),
|
||||
"secretKey": read("s3_secret_access_key"),
|
||||
}],
|
||||
"actions": [
|
||||
"Read:messenger-attachments",
|
||||
"List:messenger-attachments",
|
||||
"Read:messenger-variants",
|
||||
"Write:messenger-staging",
|
||||
],
|
||||
},
|
||||
{
|
||||
"name": "messenger-worker",
|
||||
"credentials": [{
|
||||
"accessKey": service_s3_credentials["worker"][0],
|
||||
"secretKey": service_s3_credentials["worker"][1],
|
||||
}],
|
||||
"actions": [
|
||||
"Read:messenger-staging",
|
||||
"Write:messenger-staging",
|
||||
"Write:messenger-attachments",
|
||||
"Write:messenger-variants",
|
||||
],
|
||||
},
|
||||
*[
|
||||
{
|
||||
"name": f"messenger-{service}",
|
||||
"credentials": [{
|
||||
"accessKey": service_s3_credentials[service][0],
|
||||
"secretKey": service_s3_credentials[service][1],
|
||||
}],
|
||||
"actions": [],
|
||||
}
|
||||
for service in ("publisher", "migrate")
|
||||
],
|
||||
{
|
||||
"name": "messenger-reconciler",
|
||||
"credentials": [{
|
||||
"accessKey": service_s3_credentials["reconciler"][0],
|
||||
"secretKey": service_s3_credentials["reconciler"][1],
|
||||
}],
|
||||
"actions": [
|
||||
f"{action}:{bucket}"
|
||||
for bucket in ("messenger-staging", "messenger-attachments", "messenger-variants")
|
||||
for action in ("Read", "Write", "List")
|
||||
],
|
||||
},
|
||||
]
|
||||
write("s3.json", json.dumps({"identities": identities}, separators=(",", ":")), replace=True)
|
||||
iam_config_path = SECRET_DIR / "s3_iam.json"
|
||||
if not iam_config_path.exists():
|
||||
iam_config = {
|
||||
"sts": {
|
||||
"signingKey": "base64-" + base64.urlsafe_b64encode(secrets.token_bytes(32)).decode("ascii")
|
||||
},
|
||||
"defaultEffect": "Deny",
|
||||
}
|
||||
write("s3_iam.json", json.dumps(iam_config, separators=(",", ":")))
|
||||
print("TLS endpoints and service-scoped broker credentials prepared locally; values were not printed.")
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Executable
+33
@@ -0,0 +1,33 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
cd "$(dirname "$0")/.."
|
||||
|
||||
interval=${RECONCILE_INTERVAL_SECONDS:-900}
|
||||
grace=${RECONCILE_GRACE_SECONDS:-3600}
|
||||
|
||||
case "$interval" in
|
||||
''|*[!0-9]*)
|
||||
echo "RECONCILE_INTERVAL_SECONDS must be an integer" >&2
|
||||
exit 2
|
||||
;;
|
||||
esac
|
||||
case "$grace" in
|
||||
''|*[!0-9]*)
|
||||
echo "RECONCILE_GRACE_SECONDS must be an integer" >&2
|
||||
exit 2
|
||||
;;
|
||||
esac
|
||||
if [ "$interval" -lt 60 ]; then
|
||||
echo "RECONCILE_INTERVAL_SECONDS must be at least 60" >&2
|
||||
exit 2
|
||||
fi
|
||||
if [ "$grace" -lt 60 ]; then
|
||||
echo "RECONCILE_GRACE_SECONDS must be at least 60" >&2
|
||||
exit 2
|
||||
fi
|
||||
|
||||
while :
|
||||
do
|
||||
python3 src/reconcile.py --grace-seconds "$grace" --apply
|
||||
sleep "$interval"
|
||||
done
|
||||
Executable
+28
@@ -0,0 +1,28 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
docker compose --env-file .env restart postgres rabbitmq s3-core s3
|
||||
|
||||
for service in postgres rabbitmq s3-core s3; do
|
||||
ready=0
|
||||
attempt=0
|
||||
while [ "$attempt" -lt 90 ]; do
|
||||
ready=1
|
||||
containers=$(docker compose --env-file .env ps -q "$service")
|
||||
[ -n "$containers" ] || ready=0
|
||||
for container in $containers; do
|
||||
status=$(docker inspect --format '{{if .State.Health}}{{.State.Health.Status}}{{else}}running{{end}}' "$container")
|
||||
[ "$status" = healthy ] || ready=0
|
||||
done
|
||||
[ "$ready" -eq 1 ] && break
|
||||
attempt=$((attempt + 1))
|
||||
sleep 1
|
||||
done
|
||||
[ "$ready" -eq 1 ] || {
|
||||
printf 'Service %s did not become healthy after restart.\n' "$service" >&2
|
||||
exit 1
|
||||
}
|
||||
done
|
||||
|
||||
docker compose --env-file .env restart api publisher worker reconciler
|
||||
printf '%s\n' 'Restarted API and application stores without changing volumes.'
|
||||
Executable
+20
@@ -0,0 +1,20 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
|
||||
|
||||
matches=0
|
||||
target_container=
|
||||
for container in $(docker compose --env-file .env ps -q api); do
|
||||
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$container")
|
||||
if [ "$hostname" = "$TARGET_INSTANCE_ID" ]; then
|
||||
matches=$((matches + 1))
|
||||
target_container=$container
|
||||
fi
|
||||
done
|
||||
|
||||
if [ "$matches" -ne 1 ]; then
|
||||
printf '%s\n' 'Could not resolve TARGET_INSTANCE_ID to exactly one API container.' >&2
|
||||
exit 1
|
||||
fi
|
||||
|
||||
docker stop --time 2 "$target_container" >/dev/null
|
||||
Reference in New Issue
Block a user