#!/usr/bin/env python3 """Create local synthetic credentials for the stand in ./secrets (ignored by Git). python scripts/init_secrets.py Idempotent: existing files are kept, so re-running never changes passwords of a database that already has data. Prints only file names, never values. Delete ./secrets together with the volumes (`docker compose down -v`) to start over. """ from __future__ import annotations import base64 import hashlib import json import os import secrets import sys from pathlib import Path ROOT = Path(__file__).resolve().parents[1] SECRETS = ROOT / "secrets" def write(name: str, value: str) -> None: path = SECRETS / name if path.exists(): print(f"keep secrets/{name}") return path.write_text(value + "\n", encoding="utf-8", newline="\n") # Readable by the container users (postgres, valkey, seaweedfs, rabbitmq, app uid 10001) # through the compose bind mount. Local synthetic lab credentials only. os.chmod(path, 0o644) print(f"created secrets/{name}") def read(name: str) -> str: return (SECRETS / name).read_text(encoding="utf-8").strip() def rabbit_hash(password: str) -> str: """RabbitMQ `rabbit_password_hashing_sha256`: base64(salt + sha256(salt + password)), 4-byte salt. The broker stores and compares only this hash; the plain password is in the client's URL.""" salt = secrets.token_bytes(4) return base64.b64encode(salt + hashlib.sha256(salt + password.encode("utf-8")).digest()).decode("ascii") def main() -> int: SECRETS.mkdir(exist_ok=True) write("postgres_password", secrets.token_urlsafe(24)) # [A-Za-z0-9_-]: safe inside URLs write("valkey_password", secrets.token_urlsafe(24)) write("database_url", f"postgresql://messenger:{read('postgres_password')}@postgres:5432/messenger") write("cache_url", f"redis://:{read('valkey_password')}@valkey:6379/0") # S3 key pairs (SeaweedFS identities, infra/seaweedfs/start.sh): admin = bucket bootstrap only; # api = Write staging + Read final; worker = Read/Write both; auditor = Read + List (no Write). for who in ("admin", "api", "worker", "auditor"): write(f"s3_{who}_access_key_id", "AK" + secrets.token_hex(9).upper()) write(f"s3_{who}_secret_access_key", secrets.token_hex(20)) # Lab 5: RabbitMQ users. relay may only publish to the jobs exchange, worker may only consume # the jobs queue; neither may declare/delete anything (configure "^$"). write("rabbitmq_relay_password", secrets.token_urlsafe(24)) write("rabbitmq_worker_password", secrets.token_urlsafe(24)) users = { "users": [{"name": who, "password_hash": rabbit_hash(read(f"rabbitmq_{who}_password")), "hashing_algorithm": "rabbit_password_hashing_sha256", "tags": []} for who in ("relay", "worker")], "permissions": [ {"user": "relay", "vhost": "/", "configure": "^$", "write": "^messenger\\.jobs$", "read": "^$"}, {"user": "worker", "vhost": "/", "configure": "^$", "write": "^$", "read": "^messenger\\.attachment-jobs$"}, ], } write("rabbitmq_users.json", json.dumps(users, indent=1)) for who in ("relay", "worker"): # AMQP heartbeat 10 s: a frozen client loses its connection after ~2 missed heartbeats, and # the broker returns its unacked messages to the queue for the other consumers. write(f"broker_url_{who}", f"amqp://{who}:{read(f'rabbitmq_{who}_password')}@broker:5672/?heartbeat=10") return 0 if __name__ == "__main__": sys.exit(main())