Files
moyi-model-intelligence-hub/infra/moyi/admin_credentials.py
T

285 lines
15 KiB
Python

#!/usr/bin/env python3
"""Reset the existing owner of a single-instance MOYI cloud deployment."""
import argparse
import base64
import copy
import getpass
import hashlib
import importlib.util
import json
import os
from pathlib import Path
import re
import secrets
import shutil
import subprocess
import sys
import tempfile
import urllib.parse
class MaintenanceError(Exception):
pass
def require(condition, message):
if not condition:
raise MaintenanceError(message)
def run(command, *, cwd=None, env=None, sql=None, timeout=240):
options = {"input": sql} if sql is not None else {"stdin": subprocess.DEVNULL}
result = subprocess.run(command, cwd=cwd, env=env, capture_output=True,
text=True, encoding="utf-8", timeout=timeout, **options)
# Database/Compose error messages can contain secrets or SQL; never echo them.
require(result.returncode == 0, Path(command[0]).name + " failed; output withheld to protect credentials.")
return result.stdout.strip()
def password_hash(password, pepper):
salt = secrets.token_bytes(16)
key = hashlib.pbkdf2_hmac("sha256", (password + pepper).encode("utf-8"), salt, 210000, 32)
encode = lambda value: base64.urlsafe_b64encode(value).decode("ascii").rstrip("=")
return "pbkdf2$210000$" + encode(salt) + "$" + encode(key)
def sql_literal(value):
# Hex also prevents dollar-quote delimiters from appearing inside a DO body.
return "convert_from(decode('" + str(value).encode("utf-8").hex() + "', 'hex'), 'UTF8')"
def updated_environment(original, account, password):
require(password.strip() and not any(ord(char) < 32 or ord(char) == 127 for char in password),
"Password must be nonblank and cannot contain control characters.")
require(password != "admin123", "The development default password is not allowed.")
# Replace the two owner settings in place before appending the effective
# values. Compose accepts later overrides, but duplicate assignments make
# the resulting dotenv file ambiguous and can silently mask a real secret.
# Do not parse or rewrite arbitrary existing dotenv values, which may be
# multiline/quoted.
lines = [line for line in original.splitlines() if not re.match(
r"^\s*(?:export\s+)?(?:ADMIN_ACCOUNT|ADMIN_PASSWORD)\s*=", line)]
original = "\n".join(lines)
values = {"ADMIN_ACCOUNT": account, "ADMIN_PASSWORD": password}
return original.rstrip("\r\n") + "\n\n# Owner credentials set by admin_credentials.py\n" + "".join(
key + "=" + json.dumps(value, ensure_ascii=False).replace("$", "$$") + "\n"
for key, value in values.items())
def validate_staged_config(before, after, account, password):
expected = copy.deepcopy(before)
expected["services"]["moyi-api"]["environment"].update(
ADMIN_ACCOUNT=account, ADMIN_PASSWORD=password)
require(after == expected, "Staged configuration differs unexpectedly. Check shell environment overrides; nothing was changed.")
def postgres_environment(api, expected_database):
url = str(api["SPRING_DATASOURCE_URL"])
require(url.startswith("jdbc:postgresql://"), "PostgreSQL JDBC URL required.")
target = urllib.parse.urlsplit(url[5:])
require(urllib.parse.unquote(target.path) == "/" + expected_database and target.hostname
and not target.username and not target.password, "Database target does not match --database.")
query = urllib.parse.parse_qs(target.query, keep_blank_values=True)
supported = {"sslmode": "PGSSLMODE", "sslrootcert": "PGSSLROOTCERT", "sslcert": "PGSSLCERT", "sslkey": "PGSSLKEY"}
require(all(key in supported and len(value) == 1 for key, value in query.items()),
"Unsupported JDBC parameters; review TLS settings before maintenance.")
env = {key: value for key, value in os.environ.items() if not key.startswith("PG")}
env.update(PGHOST=target.hostname, PGPORT=str(target.port or 5432), PGDATABASE=expected_database,
PGUSER=str(api["SPRING_DATASOURCE_USERNAME"]), PGPASSWORD=str(api["SPRING_DATASOURCE_PASSWORD"]),
PGCONNECT_TIMEOUT="10", PGAPPNAME="moyi-admin-maintenance", PGCLIENTENCODING="UTF8")
for key, value in query.items():
env[supported[key]] = value[0]
return env
def query_database(psql, env, sql):
return run([psql, "-X", "--no-password", "-qAt", "-v", "ON_ERROR_STOP=1", "-f", "-"], env=env, sql=sql)
def read_owner(psql, env, configured_account, new_account):
rows = json.loads(query_database(psql, env, """
SELECT COALESCE(json_agg(json_build_object('id', id, 'account', account, 'status', status)), '[]'::json)
FROM public.users WHERE role = 'super_admin';
"""))
require(len(rows) == 1 and rows[0]["status"] == "active", "Expected exactly one active super administrator.")
normalized = re.sub(r"[\s-]", "", configured_account.strip().lower())
# The second case permits retry after DB commit but before env installation.
require(rows[0]["account"] in (normalized, new_account.lower()),
"Existing owner differs from both configured and requested accounts; refusing to change it.")
occupied = query_database(psql, env, "SELECT count(*) FROM public.users WHERE account = "
+ sql_literal(new_account.lower()) + " AND id <> " + sql_literal(rows[0]["id"]) + "::uuid;")
require(occupied == "0", "Requested account is already used by another user; nothing changed.")
return rows[0]
def reset_sql(database, owner, account, encoded):
database, user_id, previous, account, encoded = map(sql_literal, (
database, owner["id"], owner["account"], account.lower(), encoded))
return f"""
BEGIN;
SET LOCAL standard_conforming_strings = on;
SET LOCAL lock_timeout = '10s';
SET LOCAL statement_timeout = '30s';
LOCK TABLE public.users IN SHARE ROW EXCLUSIVE MODE;
DO $moyi_reset$
BEGIN
IF current_database() <> {database} THEN
RAISE EXCEPTION 'Wrong database';
END IF;
IF (SELECT count(*) FROM public.users WHERE role = 'super_admin') <> 1
OR NOT EXISTS (SELECT 1 FROM public.users WHERE id = {user_id}::uuid
AND account = {previous} AND role = 'super_admin' AND status = 'active') THEN
RAISE EXCEPTION 'Owner changed; refusing reset';
END IF;
IF EXISTS (SELECT 1 FROM public.users WHERE account = {account} AND id <> {user_id}::uuid) THEN
RAISE EXCEPTION 'Account already exists';
END IF;
UPDATE public.users SET account = {account}, account_kind = 'username',
password_hash = {encoded}, updated_at = now() WHERE id = {user_id}::uuid;
UPDATE public.auth_sessions SET revoked_at = now()
WHERE user_id = {user_id}::uuid AND revoked_at IS NULL;
INSERT INTO public.auth_audit_log (actor_user_id, event_type, target_type, target_id, details)
VALUES ({user_id}::uuid, 'user.credentials_reset', 'user', {user_id},
json_build_object('fromAccount', {previous}, 'account', {account}, 'method', 'server_cli')::jsonb);
END;
$moyi_reset$;
COMMIT;
SELECT 'OWNER_RESET_COMMITTED';
"""
def write_private(path, data):
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
with os.fdopen(descriptor, "wb") as stream:
stream.write(data)
stream.flush()
os.fsync(stream.fileno())
def install_environment(env_file, content):
temporary = env_file.with_name(".env.owner-" + secrets.token_hex(8))
write_private(temporary, content)
os.replace(temporary, env_file)
if os.name != "nt":
descriptor = os.open(env_file.parent, os.O_RDONLY | os.O_DIRECTORY)
try:
os.fsync(descriptor)
finally:
os.close(descriptor)
def check_container(deploy, config, env_file, mode):
compose = deploy.compose_command(env_file, mode)
ids = run(compose + ["ps", "-a", "-q", "moyi-api"], cwd=deploy.HERE).splitlines()
require(len(ids) == 1, "Expected one existing API container in this Compose project.")
item = json.loads(run(["docker", "inspect", ids[0]]))[0]
labels = item["Config"]["Labels"]
require(Path(labels["com.docker.compose.project.working_dir"]).resolve() == deploy.HERE.resolve(),
"Container belongs to another release directory.")
require(item["Config"]["Image"] == config["services"]["moyi-api"]["image"],
"Running image differs from deployment configuration.")
actual = dict(value.split("=", 1) for value in item["Config"]["Env"] if "=" in value)
expected = config["services"]["moyi-api"]["environment"]
for key in ("SPRING_DATASOURCE_URL", "SPRING_DATASOURCE_USERNAME", "SPRING_DATASOURCE_PASSWORD",
"AUTH_PASSWORD_PEPPER", "CREDENTIAL_ENCRYPTION_KEY"):
require(actual.get(key) == expected.get(key), "Container/database or encryption settings differ; refusing reset.")
return ids[0], compose
def apply_change(deploy, config, env_file, mode, account, password, database, psql, pg_dump, backup_root):
api = config["services"]["moyi-api"]["environment"]
pg_env = postgres_environment(api, database)
owner = read_owner(psql, pg_env, api["ADMIN_ACCOUNT"], account)
container, compose = check_container(deploy, config, env_file, mode)
original = env_file.read_bytes()
content = updated_environment(original.decode("utf-8-sig"), account, password).encode("utf-8")
backup_root.mkdir(mode=0o700, parents=True, exist_ok=True)
backup = Path(tempfile.mkdtemp(prefix="owner-reset-", dir=backup_root))
write_private(backup / "env.cloud.before", original)
write_private(backup / "env.cloud.after", content)
staged = deploy.load_config(backup / "env.cloud.after", mode)
deploy.validate_config(staged, mode)
validate_staged_config(config, staged, account, password)
print("Private recovery directory: " + str(backup), flush=True)
print("Stopping API for backup and session revocation...", flush=True)
mutation_started = False
try:
run(["docker", "stop", "--time", "40", container])
require(env_file.read_bytes() == original, "Environment file changed concurrently; refusing reset.")
dump = backup / "moyi_control.dump"
run([pg_dump, "--no-password", "--format=custom", "--quote-all-identifiers", "--lock-wait-timeout=10000",
"--file=" + str(dump)], env=pg_env)
require(dump.stat().st_size > 0, "Database backup is empty.")
with dump.open("rb") as stream:
digest = hashlib.file_digest(stream, "sha256").hexdigest()
write_private(backup / "moyi_control.dump.sha256", (digest + " moyi_control.dump\n").encode("ascii"))
encoded = password_hash(password, api["AUTH_PASSWORD_PEPPER"])
mutation_started = True
result = query_database(psql, pg_env, reset_sql(database, owner, account, encoded))
require(result == "OWNER_RESET_COMMITTED", "Database outcome uncertain; keep API stopped and rerun this tool.")
install_environment(env_file, content)
run(compose + ["up", "-d", "--no-deps", "--no-build", "--pull", "never", "--force-recreate",
"--wait", "--wait-timeout", "180", "moyi-api"], cwd=deploy.HERE)
run(compose + ["exec", "-T", "frontend", "nginx", "-t"], cwd=deploy.HERE)
run(compose + ["exec", "-T", "frontend", "nginx", "-s", "reload"], cwd=deploy.HERE)
deploy.smoke(staged, mode, login=True)
except BaseException:
if not mutation_started:
run(["docker", "start", container])
print("Reset was not attempted; original API container restarted.", flush=True)
else:
print("Maintenance did not finish. Do not restore the old env or database blindly. "
"Rerun this tool with the same account/password to reconcile and verify. Recovery: " + str(backup), flush=True)
raise
print("SUPER_ADMIN_RESET_OK: " + account + "; existing user ID preserved; previous sessions revoked.")
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--deployment-dir", type=Path, required=True)
parser.add_argument("--account", required=True)
parser.add_argument("--database", default="moyi_control")
parser.add_argument("--mode", choices=("https", "tunnel"), default="https")
parser.add_argument("--backup-root", type=Path, default=Path("/opt/moyi/backups"))
parser.add_argument("--apply", action="store_true", help="Stop API, back up, reset owner and restart; password is prompted twice")
args = parser.parse_args()
require(re.fullmatch(r"[A-Za-z][A-Za-z0-9_]{0,79}", args.account), "Use an ASCII username starting with a letter.")
require(re.fullmatch(r"[a-z][a-z0-9_]+", args.database) and args.database not in ("postgres", "template0", "template1"),
"Use a dedicated application database.")
require(not args.apply or (os.name == "posix" and os.geteuid() == 0), "Apply must run as root on the Linux server.")
directory = args.deployment_dir.resolve()
spec = importlib.util.spec_from_file_location("moyi_deploy", directory / "deploy.py")
deploy = importlib.util.module_from_spec(spec)
spec.loader.exec_module(deploy)
env_file = directory / ".env.cloud"
psql, pg_dump = shutil.which("psql"), shutil.which("pg_dump")
require(psql and pg_dump, "Install postgresql-client first.")
if args.apply:
import fcntl
os.umask(0o077)
lock = open(directory / ".owner-maintenance.lock", "a")
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
config = deploy.preflight(env_file, args.mode)
api = config["services"]["moyi-api"]["environment"]
env = postgres_environment(api, args.database)
owner = read_owner(psql, env, api["ADMIN_ACCOUNT"], args.account)
check_container(deploy, config, env_file, args.mode)
print("Database: " + args.database + "; existing super administrator: " + owner["account"])
if not args.apply:
print("Read-only check passed. Add --apply to change credentials.")
return
require(sys.stdin.isatty(), "Run interactively in SSH, not through a heredoc or pipe.")
password = getpass.getpass("New super administrator password (hidden): ")
require(password == getpass.getpass("Repeat new password (hidden): "), "Passwords do not match; nothing changed.")
apply_change(deploy, config, env_file, args.mode, args.account, password, args.database,
psql, pg_dump, args.backup_root.resolve())
if __name__ == "__main__":
try:
main()
except (MaintenanceError, ValueError, OSError, subprocess.SubprocessError, KeyboardInterrupt) as error:
message = str(error) if isinstance(error, MaintenanceError) else type(error).__name__ + ": maintenance stopped; no secret output shown."
print("ERROR: " + message, file=sys.stderr)
sys.exit(1)