Files

247 lines
16 KiB
Python

import base64
import contextlib
import hashlib
import importlib.util
import io
import json
import os
from pathlib import Path
import shutil
import subprocess
import tempfile
from types import SimpleNamespace
import unittest
from unittest.mock import patch
import uuid
from test_deploy import configuration, deploy, DIRECTORY
SPEC = importlib.util.spec_from_file_location("admin_credentials", DIRECTORY / "admin_credentials.py")
maintenance = importlib.util.module_from_spec(SPEC)
SPEC.loader.exec_module(maintenance)
class CredentialMaintenanceTests(unittest.TestCase):
def test_password_format_matches_java_parameters(self):
for password in ("x", "Test42!", "a'b\\c$#\"", "\u6d4b\u8bd5A1!"):
with self.subTest(password=password):
encoded = maintenance.password_hash(password, "local-test-pepper")
name, iterations, salt, key = encoded.split("$")
self.assertEqual((name, iterations), ("pbkdf2", "210000"))
salt = base64.urlsafe_b64decode(salt + "==")
self.assertEqual(len(salt), 16)
actual = base64.urlsafe_b64decode(key + "=")
self.assertEqual(len(actual), 32)
expected = hashlib.pbkdf2_hmac("sha256", (password + "local-test-pepper").encode(), salt, 210000, 32)
self.assertEqual(expected, actual)
self.assertNotEqual(encoded, maintenance.password_hash(password, "local-test-pepper"))
def test_no_password_minimum_but_rejects_blank_and_control_characters(self):
self.assertIn('ADMIN_PASSWORD="x"', maintenance.updated_environment("OTHER=value\n", "Owner", "x"))
for password in ("", " ", "bad\nline", "bad\x00null", "admin123"):
with self.subTest(password=password), self.assertRaises(maintenance.MaintenanceError):
maintenance.updated_environment("OTHER=value\n", "Owner", password)
def test_database_target_guard_and_no_password_in_argv(self):
api = configuration()["services"]["moyi-api"]["environment"]
env = maintenance.postgres_environment(api, "moyi_control")
self.assertEqual(env["PGDATABASE"], "moyi_control")
with patch.object(maintenance, "run", return_value="ok") as runner:
maintenance.query_database("psql", env, "SELECT 1;")
args, kwargs = runner.call_args
self.assertNotIn(api["SPRING_DATASOURCE_PASSWORD"], " ".join(args[0]))
self.assertEqual(kwargs["env"]["PGPASSWORD"], api["SPRING_DATASOURCE_PASSWORD"])
with self.assertRaisesRegex(maintenance.MaintenanceError, "target"):
maintenance.postgres_environment(api, "other_app")
api["SPRING_DATASOURCE_URL"] += "?sslmode=verify-full&sslrootcert=%2Fopt%2Fmoyi%2Fca.pem"
env = maintenance.postgres_environment(api, "moyi_control")
self.assertEqual(env["PGSSLMODE"], "verify-full")
self.assertEqual(env["PGSSLROOTCERT"], "/opt/moyi/ca.pem")
api["SPRING_DATASOURCE_URL"] += "&unknown=unsafe"
with self.assertRaisesRegex(maintenance.MaintenanceError, "Unsupported"):
maintenance.postgres_environment(api, "moyi_control")
def test_secret_tool_errors_are_not_echoed_and_stdin_is_not_inherited(self):
with patch.object(maintenance.subprocess, "run", return_value=SimpleNamespace(returncode=1, stdout="secret", stderr="secret")) as runner:
with self.assertRaises(maintenance.MaintenanceError) as error:
maintenance.run(["docker", "compose"])
self.assertNotIn("secret", str(error.exception))
self.assertEqual(runner.call_args.kwargs["stdin"], subprocess.DEVNULL)
def test_owner_check_and_recovery_after_commit(self):
owner = {"id": str(uuid.uuid4()), "account": "adimin", "status": "active"}
for rows in ([], [owner, owner], [{**owner, "status": "disabled"}], [{**owner, "account": "other"}]):
with patch.object(maintenance, "query_database", return_value=json.dumps(rows)):
with self.assertRaises(maintenance.MaintenanceError):
maintenance.read_owner("psql", {}, "adimin", "NewOwner")
for account in ("adimin", "newowner"):
with patch.object(maintenance, "query_database", side_effect=[json.dumps([{**owner, "account": account}]), "0"]):
self.assertEqual(maintenance.read_owner("psql", {}, "adimin", "NewOwner")["id"], owner["id"])
with patch.object(maintenance, "query_database", side_effect=[json.dumps([owner]), "1"]):
with self.assertRaisesRegex(maintenance.MaintenanceError, "already used"):
maintenance.read_owner("psql", {}, "adimin", "NewOwner")
def test_config_change_guard_preserves_other_settings(self):
before = configuration()
after = json.loads(json.dumps(before))
after["services"]["moyi-api"]["environment"].update(ADMIN_ACCOUNT="Owner", ADMIN_PASSWORD="x")
maintenance.validate_staged_config(before, after, "Owner", "x")
after["services"]["moyi-api"]["environment"]["AUTH_PASSWORD_PEPPER"] = "changed"
with self.assertRaises(maintenance.MaintenanceError):
maintenance.validate_staged_config(before, after, "Owner", "x")
def test_environment_install_is_atomic(self):
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / ".env.cloud"
path.write_bytes(b"before")
with patch.object(maintenance.os, "replace", side_effect=OSError("test")):
with self.assertRaises(OSError):
maintenance.install_environment(path, b"after")
self.assertEqual(path.read_bytes(), b"before")
maintenance.install_environment(path, b"after")
self.assertEqual(path.read_bytes(), b"after")
@unittest.skipUnless(shutil.which("docker"), "Docker CLI required")
def test_real_compose_password_quoting_preserves_every_other_setting(self):
text = (DIRECTORY / ".env.cloud.example").read_text(encoding="utf-8")
for old, new in {"CHANGE_ME_RDS_HOST": "rds.internal", "CHANGE_ME_RDS_PASSWORD": "test-db",
"CHANGE_ME_TAIR_HOST": "redis.internal", "CHANGE_ME_TAIR_PASSWORD": "test-cache",
"GENERATE_AUTH_PEPPER": "p" * 64, "GENERATE_CREDENTIAL_KEY": "k" * 64,
"GENERATE_ADMIN_PASSWORD": "test-admin"}.items():
text = text.replace(old, new)
with tempfile.TemporaryDirectory() as directory:
path = Path(directory) / ".env.cloud"
maintenance.write_private(path, text.encode())
before = deploy.load_config(path, "https")
for password in ("x", "Test42!", "a'b\\c$#\"", "end\\", "$$literal${HOME}", "\u6d4b\u8bd5A1!", " spaced "):
with self.subTest(password=password):
path.write_text(maintenance.updated_environment(text, "TestOwner", password), encoding="utf-8")
after = deploy.load_config(path, "https")
maintenance.validate_staged_config(before, after, "TestOwner", password)
@unittest.skipUnless(os.environ.get("MOYI_CREDENTIAL_TEST_PG_BIN"), "Isolated local PostgreSQL required")
class CredentialDatabaseTests(unittest.TestCase):
def setUp(self):
self.psql = str(Path(os.environ["MOYI_CREDENTIAL_TEST_PG_BIN"]) / "psql.exe")
self.name = "moyi_credentials_test_" + uuid.uuid4().hex
self.env = {key: value for key, value in os.environ.items() if not key.startswith("PG")}
self.env.update(PGHOST="127.0.0.1", PGPORT="55439", PGUSER="moyi_role_test", PGDATABASE="moyi_role_test")
maintenance.query_database(self.psql, self.env, 'CREATE DATABASE "' + self.name + '";')
self.env["PGDATABASE"] = self.name
repo = DIRECTORY.parents[1]
migrations = repo / "control-plane-java/src/main/resources/db/migration"
maintenance.query_database(self.psql, self.env, (migrations / "V1__auth.sql").read_text() + (migrations / "V9__admin_roles.sql").read_text())
self.owner = {"id": str(uuid.uuid4()), "account": "oldowner", "status": "active"}
self.other = str(uuid.uuid4())
self.session = str(uuid.uuid4())
self.other_session = str(uuid.uuid4())
maintenance.query_database(self.psql, self.env, f"""
INSERT INTO public.users (id, account, account_kind, password_hash, display_name, role) VALUES
('{self.owner['id']}', 'oldowner', 'username', 'old-hash', 'Original name', 'super_admin'),
('{self.other}', 'ordinary', 'username', 'other-hash', 'Other name', 'user');
INSERT INTO public.auth_sessions (id, token_hash, user_id, expires_at) VALUES
('{self.session}', 'owner-token', '{self.owner['id']}', now() + interval '1 day'),
('{self.other_session}', 'other-token', '{self.other}', now() + interval '1 day');
INSERT INTO public.invitation_codes (id, code_hash, code_prefix, label, created_by) VALUES
('{uuid.uuid4()}', 'invite-hash', 'invite', 'Owner relation', '{self.owner['id']}');
""")
def tearDown(self):
self.env["PGDATABASE"] = "moyi_role_test"
maintenance.query_database(self.psql, self.env, 'DROP DATABASE "' + self.name + '";')
def query(self, sql):
return maintenance.query_database(self.psql, self.env, sql)
def test_reset_preserves_identity_relations_other_users_and_revokes_owner_sessions(self):
encoded = maintenance.password_hash("Test42!", "local-test-pepper")
self.assertEqual(self.query(maintenance.reset_sql(self.name, self.owner, "NewOwner", encoded)), "OWNER_RESET_COMMITTED")
data = json.loads(self.query("SELECT row_to_json(u) FROM public.users u WHERE role = 'super_admin'"))
self.assertEqual(data["id"], self.owner["id"])
self.assertEqual(data["account"], "newowner")
self.assertEqual(data["password_hash"], encoded)
self.assertEqual(data["display_name"], "Original name")
self.assertEqual(self.query("SELECT count(*) FROM public.users"), "2")
self.assertEqual(self.query("SELECT created_by FROM public.invitation_codes"), self.owner["id"])
self.assertEqual(self.query(f"SELECT revoked_at IS NOT NULL FROM public.auth_sessions WHERE id = '{self.session}'"), "t")
self.assertEqual(self.query(f"SELECT revoked_at IS NULL FROM public.auth_sessions WHERE id = '{self.other_session}'"), "t")
self.assertEqual(self.query(f"SELECT password_hash FROM public.users WHERE id = '{self.other}'"), "other-hash")
details = self.query("SELECT details FROM public.auth_audit_log WHERE event_type = 'user.credentials_reset'")
self.assertNotIn("password", details)
self.assertNotIn(encoded, details)
self.assertIn("newowner", details)
current = maintenance.read_owner(self.psql, self.env, "oldowner", "NewOwner")
self.assertEqual(self.query(maintenance.reset_sql(self.name, current, "NewOwner", encoded)), "OWNER_RESET_COMMITTED")
def test_conflict_wrong_database_and_owner_drift_leave_everything_unchanged(self):
for database, owner, account in ((self.name, self.owner, "ordinary"), ("wrong_database", self.owner, "NewOwner"),
(self.name, {**self.owner, "account": "changed"}, "NewOwner")):
with self.subTest(database=database, account=account):
with self.assertRaises(maintenance.MaintenanceError):
self.query(maintenance.reset_sql(database, owner, account, "new-hash"))
self.assertEqual(self.query("SELECT account FROM public.users WHERE role = 'super_admin'"), "oldowner")
self.assertEqual(self.query("SELECT count(*) FROM public.auth_audit_log"), "0")
self.assertEqual(self.query("SELECT count(*) FROM public.auth_sessions WHERE revoked_at IS NOT NULL"), "0")
def test_audit_failure_rolls_back_password_and_session_changes(self):
self.query("ALTER TABLE public.auth_audit_log ADD CONSTRAINT test_reject_audit CHECK (event_type <> 'user.credentials_reset')")
with self.assertRaises(maintenance.MaintenanceError):
self.query(maintenance.reset_sql(self.name, self.owner, "NewOwner", "new-hash"))
self.assertEqual(self.query("SELECT password_hash FROM public.users WHERE role = 'super_admin'"), "old-hash")
self.assertEqual(self.query("SELECT count(*) FROM public.auth_sessions WHERE revoked_at IS NOT NULL"), "0")
@unittest.skipUnless(shutil.which("docker"), "Docker CLI required for config parsing only")
def test_real_backup_and_recovery_when_env_install_fails_after_commit(self):
text = (DIRECTORY / ".env.cloud.example").read_text(encoding="utf-8")
for old, new in {"jdbc:postgresql://CHANGE_ME_RDS_HOST:5432/moyi_control": "jdbc:postgresql://127.0.0.1:55439/" + self.name,
"MOYI_DB_USERNAME=moyi_app": "MOYI_DB_USERNAME=moyi_role_test", "CHANGE_ME_RDS_PASSWORD": "test-only",
"CHANGE_ME_TAIR_HOST": "redis.internal", "CHANGE_ME_TAIR_PASSWORD": "test-cache",
"GENERATE_AUTH_PEPPER": "p" * 64, "GENERATE_CREDENTIAL_KEY": "k" * 64,
"GENERATE_ADMIN_PASSWORD": "test-admin", "ADMIN_ACCOUNT=adimin": "ADMIN_ACCOUNT=oldowner"}.items():
text = text.replace(old, new)
pg_dump = str(Path(self.psql).with_name("pg_dump.exe"))
real_run = maintenance.run
docker_calls = []
def run_command(command, **kwargs):
if command[0] == "docker":
docker_calls.append(command)
return ""
return real_run(command, **kwargs)
with tempfile.TemporaryDirectory() as temporary:
path = Path(temporary) / ".env.cloud"
backups = Path(temporary) / "backups"
maintenance.write_private(path, text.encode())
cfg = deploy.load_config(path, "https")
with patch.object(maintenance, "check_container", return_value=("test-container", ["docker", "compose"])), \
patch.object(maintenance, "run", side_effect=run_command), patch.object(deploy, "smoke") as smoke, \
contextlib.redirect_stdout(io.StringIO()):
with patch.object(maintenance, "install_environment", side_effect=OSError("injected failure")):
with self.assertRaises(OSError):
maintenance.apply_change(deploy, cfg, path, "https", "NewOwner", "x", self.name,
self.psql, pg_dump, backups)
self.assertEqual(path.read_bytes(), text.encode())
self.assertEqual(self.query("SELECT account FROM public.users WHERE role = 'super_admin'"), "newowner")
self.assertFalse(any(call[1] == "start" or "up" in call for call in docker_calls))
smoke.assert_not_called()
backup = next(backups.glob("owner-reset-*"))
pg_restore = str(Path(self.psql).with_name("pg_restore.exe"))
listing = real_run([pg_restore, "--list", str(backup / "moyi_control.dump")])
self.assertIn("TABLE DATA public users", listing)
real_run([pg_restore, "--file=" + os.devnull, str(backup / "moyi_control.dump")])
maintenance.apply_change(deploy, cfg, path, "https", "NewOwner", "x", self.name,
self.psql, pg_dump, backups)
smoke.assert_called_once()
self.assertTrue(smoke.call_args.kwargs["login"])
final = deploy.load_config(path, "https")
maintenance.validate_staged_config(cfg, final, "NewOwner", "x")
self.assertEqual(self.query("SELECT count(*) FROM public.users WHERE role = 'super_admin'"), "1")
self.assertEqual(self.query("SELECT id FROM public.users WHERE role = 'super_admin'"), self.owner["id"])
self.assertTrue(any("--force-recreate" in call and "--no-build" in call for call in docker_calls))
if __name__ == "__main__":
unittest.main()