From a775a658549aec79aef3c0762188c162cced80e9 Mon Sep 17 00:00:00 2001 From: vicki Date: Mon, 16 Nov 2026 11:21:09 -0500 Subject: [PATCH] rename --configure to import --from-tails --- files/securedrop-submission-key.py | 2 +- securedrop_manage/main.py | 33 ++++--- .../{configure.py => tails_import.py} | 0 tests/test_securedrop_manage.py | 88 +++++++++++-------- ...=> test_securedrop_manage_tails_import.py} | 28 +++--- 5 files changed, 90 insertions(+), 61 deletions(-) rename securedrop_manage/{configure.py => tails_import.py} (100%) rename tests/{test_securedrop_manage_configure.py => test_securedrop_manage_tails_import.py} (90%) diff --git a/files/securedrop-submission-key.py b/files/securedrop-submission-key.py index 25b48a8bb..87c4c6527 100644 --- a/files/securedrop-submission-key.py +++ b/files/securedrop-submission-key.py @@ -15,8 +15,8 @@ from qubesadmin.exc import QubesException from qubesadmin.vm import QubesVM -from securedrop_manage.configure import get_submission_key_fingerprint from securedrop_manage.products import get_installed_product +from securedrop_manage.tails_import import get_submission_key_fingerprint # XDG_CONFIG_HOME is not set in 4.3 Qubes - set it manually DOM0_CONFIG_DIR = Path.home() / ".config/securedrop-manage" diff --git a/securedrop_manage/main.py b/securedrop_manage/main.py index 5d76af665..e2f40a540 100644 --- a/securedrop_manage/main.py +++ b/securedrop_manage/main.py @@ -30,8 +30,8 @@ SUBMISSION_KEY_FILENAME, ManageException, ) -from securedrop_manage.configure import import_admin_config, import_journalist_config from securedrop_manage.products import Product, get_installed_product +from securedrop_manage.tails_import import import_admin_config, import_journalist_config from securedrop_manage.validate import AdminConfigValidator, validate_config # The max concurrency reduction (4->2) was required to avoid "did not return clean data" @@ -56,7 +56,7 @@ class Command(Enum): APPLY = "apply" VALIDATE = "validate" UNINSTALL = "uninstall" - CONFIGURE = "configure" + IMPORT = "import" def rewrite_legacy_args(argv: list[str]) -> list[str]: @@ -64,20 +64,25 @@ def rewrite_legacy_args(argv: list[str]) -> list[str]: Rewrite the legacy flag-style invocation (e.g. `--apply --target all`) into the subcommand form (`apply --target all`), for backwards compatibility. """ - legacy = ("--apply", "--validate", "--configure", "--uninstall") + legacy = { + "--apply": ["apply"], + "--validate": ["validate"], + "--configure": ["import", "--from-tails"], + "--uninstall": ["uninstall"], + } flags = [arg for arg in argv if arg in legacy] if not flags: return argv if len(flags) > 1: sys.exit(f"error: only one of {', '.join(flags)} may be specified") flag = flags[0] - command = flag[2:] + command = legacy[flag] print( - f"Warning: {flag} is deprecated, use `securedrop-manage {command}` instead", + f"Warning: {flag} is deprecated, use `securedrop-manage {' '.join(command)}` instead", file=sys.stderr, ) rest = [arg for arg in argv if arg != flag] - return [command, *rest] + return [*command, *rest] def parse_args(prog: str | None = None, argv: list[str] | None = None) -> argparse.Namespace: @@ -133,10 +138,18 @@ def parse_args(prog: str | None = None, argv: list[str] | None = None) -> argpar action="store_true", help="Don't prompt for confirmation, proceed immediately", ) - subparsers.add_parser( - Command.CONFIGURE.value, + import_parser = subparsers.add_parser( + Command.IMPORT.value, parents=[target_parser], - help="Configure SecureDrop Workstation", + help="Import credentials and configuration when migrating workstations", + ) + import_source = import_parser.add_mutually_exclusive_group(required=True) + import_source.add_argument( + "--from-tails", + dest="source", + action="store_const", + const="tails", + help="Import from legacy Tails Workstation", ) args = parser.parse_args(argv) args.command = Command(args.command) @@ -640,7 +653,7 @@ def main() -> None: # noqa: PLR0912 sys.exit(0) refresh_salt() perform_uninstall(args.product) - elif args.command is Command.CONFIGURE: + elif args.command is Command.IMPORT: if args.product.contains_journalist: print( "Preparing to import SecureDrop Workstation configuration...\n\n" diff --git a/securedrop_manage/configure.py b/securedrop_manage/tails_import.py similarity index 100% rename from securedrop_manage/configure.py rename to securedrop_manage/tails_import.py diff --git a/tests/test_securedrop_manage.py b/tests/test_securedrop_manage.py index 80b7da237..3e4205d38 100644 --- a/tests/test_securedrop_manage.py +++ b/tests/test_securedrop_manage.py @@ -9,8 +9,8 @@ from qubesadmin.app import VMCollection from qubesadmin.tests.mock_app import MockQube, QubesTestWrapper -from securedrop_manage import configure from securedrop_manage import main as manage +from securedrop_manage import tails_import from tests.base import SD_TAG from tests.markers import needs_journalist @@ -378,7 +378,7 @@ def fake_qubes(tmp_path: Path, mocker: Any, monkeypatch: pytest.MonkeyPatch) -> ) qvm_run.chmod(0o755) # shipped in sd-admin by securedrop-admin-qubes; record how it's called - set_site_specific = bin_dir / configure.SET_SITE_SPECIFIC + set_site_specific = bin_dir / tails_import.SET_SITE_SPECIFIC set_site_specific_log = tmp_path / "set-site-specific.log" set_site_specific.write_text(f'#!/bin/sh\necho "$@" >> "{set_site_specific_log}"\n') set_site_specific.chmod(0o755) @@ -394,12 +394,15 @@ def fake_qubes(tmp_path: Path, mocker: Any, monkeypatch: pytest.MonkeyPatch) -> (usb_ssh / "id_rsa").write_text("private\n") (usb_ssh / "id_rsa.pub").write_text("public\n") sd_admin.parent.mkdir(parents=True) - mocker.patch.object(configure, "TAILS_ADMIN_CONFIG_PATH", usb) - mocker.patch.object(configure, "TAILS_SSH_PATH", usb_ssh) - mocker.patch.object(configure, "SD_ADMIN_CONFIG_PATH", str(sd_admin)) - mocker.patch.object(configure, "SD_ADMIN_SSH_PATH", str(sd_admin_ssh)) - mocker.patch.object(configure, "SD_ADMIN_STAGING_PATH", str(staging)) - mocker.patch.object(configure, "Qubes").return_value.domains = [configure.SD_ADMIN_VM, "vault"] + mocker.patch.object(tails_import, "TAILS_ADMIN_CONFIG_PATH", usb) + mocker.patch.object(tails_import, "TAILS_SSH_PATH", usb_ssh) + mocker.patch.object(tails_import, "SD_ADMIN_CONFIG_PATH", str(sd_admin)) + mocker.patch.object(tails_import, "SD_ADMIN_SSH_PATH", str(sd_admin_ssh)) + mocker.patch.object(tails_import, "SD_ADMIN_STAGING_PATH", str(staging)) + mocker.patch.object(tails_import, "Qubes").return_value.domains = [ + tails_import.SD_ADMIN_VM, + "vault", + ] return { "usb": usb, "usb_ssh": usb_ssh, @@ -413,22 +416,22 @@ def fake_qubes(tmp_path: Path, mocker: Any, monkeypatch: pytest.MonkeyPatch) -> def _start_vault_is_skipped(mocker: Any) -> None: # qvm-start vault is fire-and-forget; don't try to run it - real_popen = configure.subprocess.Popen + real_popen = tails_import.subprocess.Popen def popen(args: list[str], **kwargs: Any) -> Any: if args[0] == "qvm-start": return mocker.Mock() return real_popen(args, **kwargs) - mocker.patch.object(configure.subprocess, "Popen", side_effect=popen) + mocker.patch.object(tails_import.subprocess, "Popen", side_effect=popen) -class TestConfigureAdmin: +class TestImportFromTailsAdmin: @pytest.fixture(autouse=True) def _admin_installed(self, mocker: Any, monkeypatch: pytest.MonkeyPatch) -> None: mocker.patch.object(manage.os, "geteuid", return_value=1000) mocker.patch.object(manage, "get_installed_product", return_value=manage.Product.ADMIN) - monkeypatch.setattr("sys.argv", ["securedrop-manage", "configure"]) + monkeypatch.setattr("sys.argv", ["securedrop-manage", "import", "--from-tails"]) def test_validates_before_import(self, mocker: Any) -> None: calls = mocker.Mock() @@ -462,7 +465,7 @@ def test_copies_config_into_sd_admin(self, fake_qubes: dict[str, Path], mocker: (usb / "app-journalist.auth_private").chmod(0o644) mocker.patch("builtins.input", return_value="y") - configure.import_admin_config() + tails_import.import_admin_config() sd_admin = fake_qubes["sd_admin"] assert sorted(p.name for p in sd_admin.iterdir()) == [ @@ -487,7 +490,7 @@ def test_copies_only_files(self, fake_qubes: dict[str, Path]) -> None: (fake_qubes["usb"] / "site-specific").write_text("app_hostname: app\n") (fake_qubes["usb"] / "subdir").mkdir() - assert configure.copy_admin_config() == ["site-specific"] + assert tails_import.copy_admin_config() == ["site-specific"] def test_replaces_leftover_staging(self, fake_qubes: dict[str, Path]) -> None: (fake_qubes["usb"] / "site-specific").write_text("app_hostname: app\n") @@ -495,7 +498,7 @@ def test_replaces_leftover_staging(self, fake_qubes: dict[str, Path]) -> None: leftover.mkdir(parents=True) (leftover / "stale").write_text("stale\n") - assert configure.copy_admin_config() == ["site-specific"] + assert tails_import.copy_admin_config() == ["site-specific"] def test_removes_staging_on_exception(self, fake_qubes: dict[str, Path], mocker: Any) -> None: (fake_qubes["usb"] / "site-specific").write_text("app_hostname: app\n") @@ -504,10 +507,10 @@ def pipe_file(source: str, destination: str) -> None: assert fake_qubes["staging"].exists() raise KeyboardInterrupt - mocker.patch.object(configure, "_pipe_admin_file", side_effect=pipe_file) + mocker.patch.object(tails_import, "_pipe_admin_file", side_effect=pipe_file) with pytest.raises(KeyboardInterrupt): - configure.copy_admin_config() + tails_import.copy_admin_config() assert not fake_qubes["staging"].exists() def test_rejects_missing_ssh_keys(self, fake_qubes: dict[str, Path], mocker: Any) -> None: @@ -515,16 +518,16 @@ def test_rejects_missing_ssh_keys(self, fake_qubes: dict[str, Path], mocker: Any (fake_qubes["usb"] / "site-specific").write_text("app_hostname: app\n") (fake_qubes["usb_ssh"] / "id_rsa").unlink() mocker.patch("builtins.input", return_value="y") - copy = mocker.patch.object(configure, "copy_admin_config") + copy = mocker.patch.object(tails_import, "copy_admin_config") with pytest.raises(manage.ManageException, match="No SSH keys"): - configure.import_admin_config() + tails_import.import_admin_config() copy.assert_not_called() def test_sets_config_path(self, fake_qubes: dict[str, Path]) -> None: (fake_qubes["usb"] / "site-specific").write_text("app_hostname: app\n") - configure.copy_admin_config() + tails_import.copy_admin_config() staged_site_specific = fake_qubes["staging"] / "config/site-specific" assert fake_qubes["set_site_specific_log"].read_text() == ( @@ -538,25 +541,25 @@ def test_skips_config_path_without_set_site_specific( # older securedrop-admin-qubes without the script fake_qubes["set_site_specific"].unlink() - assert configure.copy_admin_config() == ["site-specific"] + assert tails_import.copy_admin_config() == ["site-specific"] assert (fake_qubes["sd_admin"] / "site-specific").read_text() == "app_hostname: app\n" assert not fake_qubes["set_site_specific_log"].exists() assert "not updating config_path" in capsys.readouterr().out def test_requires_sd_admin(self, fake_qubes: dict[str, Path], mocker: Any) -> None: - mocker.patch.object(configure, "Qubes").return_value.domains = ["vault"] + mocker.patch.object(tails_import, "Qubes").return_value.domains = ["vault"] with pytest.raises(manage.ManageException, match="does not exist"): - configure.import_admin_config() + tails_import.import_admin_config() def test_rejects_journalist_usb(self, fake_qubes: dict[str, Path], mocker: Any) -> None: _start_vault_is_skipped(mocker) (fake_qubes["usb"] / "app-journalist.auth_private").write_text("abc\n") mocker.patch("builtins.input", return_value="y") - copy = mocker.patch.object(configure, "copy_admin_config") + copy = mocker.patch.object(tails_import, "copy_admin_config") with pytest.raises(manage.ManageException, match="Journalist Workstation USB"): - configure.import_admin_config() + tails_import.import_admin_config() copy.assert_not_called() def test_rejects_locked_usb(self, fake_qubes: dict[str, Path], mocker: Any) -> None: @@ -565,7 +568,7 @@ def test_rejects_locked_usb(self, fake_qubes: dict[str, Path], mocker: Any) -> N mocker.patch("builtins.input", return_value="y") with pytest.raises(manage.ManageException, match="No securedrop-admin configuration"): - configure.import_admin_config() + tails_import.import_admin_config() def test_keeps_existing_config_unless_confirmed( self, fake_qubes: dict[str, Path], mocker: Any @@ -573,9 +576,9 @@ def test_keeps_existing_config_unless_confirmed( fake_qubes["sd_admin"].mkdir() (fake_qubes["sd_admin"] / "site-specific").write_text("existing\n") mocker.patch("builtins.input", return_value="n") - copy = mocker.patch.object(configure, "copy_admin_config") + copy = mocker.patch.object(tails_import, "copy_admin_config") - configure.import_admin_config() + tails_import.import_admin_config() copy.assert_not_called() assert (fake_qubes["sd_admin"] / "site-specific").read_text() == "existing\n" @@ -586,9 +589,9 @@ def test_keeps_existing_ssh_key_unless_confirmed( fake_qubes["sd_admin_ssh"].mkdir() (fake_qubes["sd_admin_ssh"] / "id_rsa").write_text("existing\n") mocker.patch("builtins.input", return_value="n") - copy = mocker.patch.object(configure, "copy_admin_config") + copy = mocker.patch.object(tails_import, "copy_admin_config") - configure.import_admin_config() + tails_import.import_admin_config() copy.assert_not_called() @@ -602,7 +605,7 @@ def test_failed_transfer_leaves_existing_config( (fake_qubes["usb_ssh"] / "id_rsa.pub").unlink() with pytest.raises(manage.ManageException, match="Error copying"): - configure.copy_admin_config() + tails_import.copy_admin_config() assert (fake_qubes["sd_admin"] / "site-specific").read_text() == "existing\n" assert not fake_qubes["sd_admin_ssh"].exists() @@ -613,10 +616,10 @@ def test_failed_listing_leaves_existing_config( ) -> None: fake_qubes["sd_admin"].mkdir() (fake_qubes["sd_admin"] / "site-specific").write_text("existing\n") - mocker.patch.object(configure, "TAILS_ADMIN_CONFIG_PATH", fake_qubes["usb"] / "missing") + mocker.patch.object(tails_import, "TAILS_ADMIN_CONFIG_PATH", fake_qubes["usb"] / "missing") with pytest.raises(manage.ManageException, match="Error listing"): - configure.copy_admin_config() + tails_import.copy_admin_config() assert (fake_qubes["sd_admin"] / "site-specific").read_text() == "existing\n" assert not fake_qubes["staging"].exists() @@ -629,7 +632,7 @@ def test_failed_install_leaves_existing_config(self, fake_qubes: dict[str, Path] fake_qubes["set_site_specific"].write_text("#!/bin/sh\nexit 1\n") with pytest.raises(manage.ManageException, match="Error installing"): - configure.copy_admin_config() + tails_import.copy_admin_config() assert (fake_qubes["sd_admin"] / "site-specific").read_text() == "existing\n" assert not fake_qubes["sd_admin_ssh"].exists() @@ -644,7 +647,8 @@ def test_failed_install_leaves_existing_config(self, fake_qubes: dict[str, Path] (["--apply"], ["apply"]), (["--apply", "--target", "admin"], ["apply", "--target", "admin"]), (["--target", "admin", "--validate"], ["validate", "--target", "admin"]), - (["--configure"], ["configure"]), + (["--configure"], ["import", "--from-tails"]), + (["--configure", "--target", "admin"], ["import", "--from-tails", "--target", "admin"]), (["--uninstall", "--force"], ["uninstall", "--force"]), ( ["--force", "--uninstall", "--target", "all"], @@ -677,7 +681,7 @@ def test_rewrite_legacy_args_multiple(argv: list[str]) -> None: [ (["--apply"], manage.Command.APPLY, None), (["--validate"], manage.Command.VALIDATE, None), - (["--configure"], manage.Command.CONFIGURE, None), + (["--configure"], manage.Command.IMPORT, None), (["--uninstall"], manage.Command.UNINSTALL, False), (["--uninstall", "--force"], manage.Command.UNINSTALL, True), (["uninstall", "--force"], manage.Command.UNINSTALL, True), @@ -693,6 +697,13 @@ def test_parse_args_legacy( assert getattr(args, "force", None) is force +def test_parse_args_import_from_tails(mocker: Any) -> None: + mocker.patch.object(manage, "get_installed_product", return_value=manage.Product.JOURNALIST) + args = manage.parse_args("securedrop-manage", ["import", "--from-tails"]) + assert args.command is manage.Command.IMPORT + assert args.source == "tails" + + @pytest.mark.parametrize( ("argv0", "command"), [ @@ -717,8 +728,13 @@ def test_parse_args_legacy_argv0( # --force is only valid for uninstall ("securedrop-manage", ["apply", "--force"]), ("sdw-admin", ["--apply", "--force"]), + # import requires a source + ("securedrop-manage", ["import"]), + # the old subcommand name is gone + ("securedrop-manage", ["configure"]), # legacy flags are only accepted via sdw-admin ("securedrop-manage", ["--apply"]), + ("securedrop-manage", ["--configure"]), ("securedrop-manage", ["--uninstall", "--force"]), ], ) diff --git a/tests/test_securedrop_manage_configure.py b/tests/test_securedrop_manage_tails_import.py similarity index 90% rename from tests/test_securedrop_manage_configure.py rename to tests/test_securedrop_manage_tails_import.py index e12880a3d..29a2f2325 100644 --- a/tests/test_securedrop_manage_configure.py +++ b/tests/test_securedrop_manage_tails_import.py @@ -1,5 +1,5 @@ """ -Integration tests for "securedrop-manage configure" +Integration tests for "securedrop-manage import --from-tails" """ import json @@ -9,7 +9,7 @@ import pytest -from securedrop_manage import configure +from securedrop_manage import tails_import from securedrop_manage.products import Product from securedrop_manage.validate import validate_config from tests.markers import needs_journalist @@ -34,12 +34,12 @@ def vault_run(command: str, stdin: bytes | None = None) -> str: class FakeTailsDrive: """ - Stand-in for the Tails USB drives that "securedrop-manage configure" reads from. + Stand-in for the Tails USB drives that "securedrop-manage import --from-tails" reads from. """ def __init__(self, submission_key: bytes) -> None: - self.mountpoint: Path = configure.TAILS_PATH - self.gnupg_path: Path = configure.TAILS_GNUPG_PATH + self.mountpoint: Path = tails_import.TAILS_PATH + self.gnupg_path: Path = tails_import.TAILS_GNUPG_PATH self.submission_key = submission_key def insert_secure_viewing_station(self) -> None: @@ -66,7 +66,7 @@ def eject(self) -> None: @pytest.fixture def tails_drive(proj_root: Path) -> Iterator[FakeTailsDrive]: # Never touch an actually-mounted Tails drive: ejecting deletes its contents - mountpoint: Path = configure.TAILS_PATH + mountpoint: Path = tails_import.TAILS_PATH if vault_run(f"test -e {mountpoint} && echo present || echo absent").strip() == "present": pytest.fail(f"{mountpoint} already exists in vault; refusing to overwrite it") @@ -86,7 +86,7 @@ def ji_config_path(request: pytest.FixtureRequest) -> Path: fixture indirectly to test the legacy (git) location instead. """ attribute = getattr(request, "param", "TAILS_PKG_JOURNALIST_INTERFACE_CONFIG") - path: Path = getattr(configure, attribute) + path: Path = getattr(tails_import, attribute) return path @@ -95,7 +95,7 @@ def config_path(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Path: """Redirect the dom0 config directory, so tests don't clobber the real one""" config_path = tmp_path / "securedrop-manage" config_path.mkdir() - monkeypatch.setattr(configure, "CONFIG_PATH", config_path) + monkeypatch.setattr(tails_import, "CONFIG_PATH", config_path) return config_path @@ -127,7 +127,7 @@ def submission_key_fingerprint(key_file: Path) -> str: gpg_output = subprocess.check_output( ["gpg", "--show-keys", "--with-fingerprint", "--with-colon", key_file], text=True ) - fingerprints = configure.extract_secret_key_fingerprints(gpg_output) + fingerprints = tails_import.extract_secret_key_fingerprints(gpg_output) assert len(fingerprints) == 1 return fingerprints[0] @@ -162,7 +162,7 @@ def swap_in_workstation_drive() -> str: ] ) - configure.import_journalist_config() + tails_import.import_journalist_config() # The submission key was fetched off the Secure Viewing Station drive imported_key = config_path / "sd-journalist.sec" @@ -180,8 +180,8 @@ def swap_in_workstation_drive() -> str: }, "environment": "prod", "vmsizes": { - "sd_app": configure.DEFAULT_SD_APP_GB, - "sd_log": configure.DEFAULT_SD_LOG_GB, + "sd_app": tails_import.DEFAULT_SD_APP_GB, + "sd_log": tails_import.DEFAULT_SD_LOG_GB, }, } @@ -205,7 +205,7 @@ def test_import_config_keeps_existing_submission_key( answer_prompts(["y", "y"]) - configure.import_journalist_config() + tails_import.import_journalist_config() assert existing_key.read_bytes() == (proj_root / "sd-journalist.sec").read_bytes() config = json.loads((config_path / "config.json").read_text()) @@ -225,6 +225,6 @@ def test_import_config_aborts_without_confirmation( answer_prompts(["n"]) - configure.import_journalist_config() + tails_import.import_journalist_config() assert list(config_path.iterdir()) == []