247 lines
16 KiB
Python
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()
|