"""SSH host configuration is pinned, private, and switched only after test.""" from __future__ import annotations import base64 import hashlib import itertools import json import shlex import shutil import stat import struct import subprocess from dataclasses import replace from pathlib import Path from urllib.parse import parse_qs, urlsplit import pytest from virsh_panel.remote_host import ( HOST_CAPABILITY_SCHEMA_VERSION, WG_FABRIC_INTERFACE, WG_FABRIC_OWNERSHIP_MARKER, _CAPABILITY_MARKER, _CAPABILITY_PROBE_COMMAND, HostProfile, RemoteHostError, RemoteHostManager, parse_host_capabilities, ) from virsh_panel.ssh_agent import SSHAgentError def host_key(seed: bytes) -> str: blob = ( struct.pack("!I", len(b"ssh-ed25519")) + b"ssh-ed25519" + struct.pack("!I", 32) + seed * 32 ) return "ssh-ed25519 " + base64.b64encode(blob).decode("ascii") PRIVATE_KEY = "-----BEGIN OPENSSH PRIVATE KEY-----\nZmFrZQ==\n-----END OPENSSH PRIVATE KEY-----\n" CAPABILITY_OUTPUT = f"""{_CAPABILITY_MARKER} __VCAP_OS_BEGIN__ ID=almalinux NAME="AlmaLinux" VERSION_ID="10.0" __VCAP_OS_END__ __VCAP_KERNEL_BEGIN__ 6.12.0-alma __VCAP_KERNEL_END__ __VCAP_TOOL__wg=/usr/bin/wg __VCAP_TOOL__wg_quick=/usr/bin/wg-quick __VCAP_TOOL__ip=/usr/sbin/ip __VCAP_TOOL__nft=/usr/sbin/nft __VCAP_TOOL__nmcli=/usr/bin/nmcli __VCAP_TOOL__networkctl= __VCAP_TOOL__ifup= __VCAP_TOOL__ifdown= __VCAP_TOOL__ifquery= __VCAP_TOOL__ifreload= __VCAP_TOOL__flock=/usr/bin/flock __VCAP_TOOL__systemctl=/usr/bin/systemctl __VCAP_TOOL__modinfo=/usr/sbin/modinfo __VCAP_TOOL__dnf=/usr/bin/dnf __VCAP_TOOL__apt_get= __VCAP_MODULE__wireguard=loaded __VCAP_MODULE_FILE_BEGIN__ __VCAP_MODULE_FILE_END__ __VCAP_FABRIC_OWNER_BEGIN__ __VCAP_FABRIC_OWNER_END__ __VCAP_LEGACY_FIREWALL__manifest=absent __VCAP_LEGACY_FIREWALL__fabric_transaction=absent __VCAP_LEGACY_FIREWALL__emergency_owner=absent __VCAP_LEGACY_FIREWALL__vpc_transaction=absent __VCAP_LEGACY_FIREWALL__vpc_snapshot=absent __VCAP_LEGACY_FIREWALL__fabric_desired_state=absent __VCAP_LEGACY_FIREWALL__vpc_state=absent __VCAP_NFT_PERSISTENCE__main=ready __VCAP_SYSCTL__ip_forward=1 __VCAP_SYSCTL__rp_filter=2 __VCAP_SYSCTL__rp_filter_default=2 __VCAP_RPF__br0=2 __VCAP_SERVICE__network_manager=active __VCAP_SERVICE__networkd=inactive __VCAP_SERVICE__networking=inactive __VCAP_SERVICE__firewall=inactive __VCAP_SERVICE__nftables=active __VCAP_SERVICE_ENABLED__network_manager=enabled __VCAP_SERVICE_ENABLED__networkd=disabled __VCAP_SERVICE_ENABLED__networking=disabled __VCAP_SERVICE_ENABLED__firewall=masked __VCAP_SERVICE_ENABLED__nftables=enabled __VCAP_SERVICE_LOAD__firewall=masked __VCAP_SERVICE_LOAD__nftables=loaded __VCAP_FILE__interfaces=absent __VCAP_FILE__interfaces_d=absent __VCAP_FILE__networkmanager_profiles=absent __VCAP_FILE__networkd_configs=absent __VCAP_IP_BEGIN__links [{{"ifname":"br0"}}] __VCAP_IP_END__links=0 __VCAP_IP_BEGIN__addresses [{{"ifname":"br0","addr_info":[{{"family":"inet","local":"203.0.113.10"}}]}},{{"ifname":"eth1","addr_info":[{{"family":"inet","local":"10.20.30.40"}}]}}] __VCAP_IP_END__addresses=0 __VCAP_IP_BEGIN__bridges [{{"ifname":"br0"}}] __VCAP_IP_END__bridges=0 __VCAP_IP_BEGIN__wireguard [] __VCAP_IP_END__wireguard=0 __VCAP_NFT_BEGIN__ {{"nftables":[{{"table":{{"family":"inet","name":"filter"}}}}]}} __VCAP_NFT_END__0 __VCAP_END__ """ def test_capability_probe_command_is_parseable_by_posix_sh(): result = subprocess.run( ["/bin/sh", "-n", "-c", _CAPABILITY_PROBE_COMMAND], capture_output=True, text=True, check=False, ) assert result.returncode == 0, result.stderr assert "probe_ip_json addresses -j -4 address show up scope global" in ( _CAPABILITY_PROBE_COMMAND) assert "systemctl show -p LoadState --value" in _CAPABILITY_PROBE_COMMAND assert "probe_service firewall firewalld" in _CAPABILITY_PROBE_COMMAND assert "probe_service_enabled firewall firewalld" in _CAPABILITY_PROBE_COMMAND assert "probe_service_load firewall firewalld" in _CAPABILITY_PROBE_COMMAND assert "firewall-cmd" not in _CAPABILITY_PROBE_COMMAND assert "FirewallBackend" not in _CAPABILITY_PROBE_COMMAND assert "NftablesTableOwner" not in _CAPABILITY_PROBE_COMMAND assert '"$capability_nft_path" -j list tables' in _CAPABILITY_PROBE_COMMAND assert "probe_legacy_firewall_path manifest /etc/virt-cloud/nftables.conf" in ( _CAPABILITY_PROBE_COMMAND ) assert "probe_legacy_firewall_path fabric_transaction " in ( _CAPABILITY_PROBE_COMMAND ) assert "probe_legacy_firewall_path emergency_owner " in ( _CAPABILITY_PROBE_COMMAND ) for marker in ( "vpc_transaction", "vpc_snapshot", "fabric_desired_state", "vpc_state", ): assert f"__VCAP_LEGACY_FIREWALL__{marker}=" in _CAPABILITY_PROBE_COMMAND assert "__VCAP_NFT_PERSISTENCE__main=" in _CAPABILITY_PROBE_COMMAND def test_capability_probe_executes_the_discovered_ip_binary(): assert ( "probe_binary ip /usr/sbin/ip /usr/bin/ip /sbin/ip /bin/ip" in _CAPABILITY_PROBE_COMMAND ) assert 'ip) capability_ip_path="$path" ;;' in _CAPABILITY_PROBE_COMMAND assert '"$capability_ip_path" "$@"' in _CAPABILITY_PROBE_COMMAND def test_capability_probe_executes_discovered_nft_and_modinfo_paths(tmp_path): nft_calls = tmp_path / "nft.calls" nft = tmp_path / "nft" nft.write_text( "#!/bin/sh\n" f'printf "%s\\n" "$*" >> "{nft_calls}"\n' "printf '%s\\n' '{\"nftables\":[]}'\n", encoding="utf-8", ) nft.chmod(0o700) modinfo_calls = tmp_path / "modinfo.calls" modinfo = tmp_path / "modinfo" modinfo.write_text( "#!/bin/sh\n" f'printf "%s\\n" "$*" >> "{modinfo_calls}"\n' "printf '%s\\n' /lib/modules/test/wireguard.ko\n", encoding="utf-8", ) modinfo.chmod(0o700) command = _CAPABILITY_PROBE_COMMAND.replace( "probe_binary nft /usr/sbin/nft /usr/bin/nft /sbin/nft /bin/nft", f"probe_binary nft {nft}", ).replace( "probe_binary modinfo /usr/sbin/modinfo /usr/bin/modinfo " "/sbin/modinfo /bin/modinfo", f"probe_binary modinfo {modinfo}", ) result = subprocess.run( shlex.split(command), capture_output=True, text=True, check=False, timeout=15, ) assert result.returncode == 0, result.stderr assert f"__VCAP_TOOL__nft={nft}" in result.stdout assert f"__VCAP_TOOL__modinfo={modinfo}" in result.stdout assert ( "__VCAP_MODULE_FILE_BEGIN__\n/lib/modules/test/wireguard.ko\n" "__VCAP_MODULE_FILE_END__" ) in result.stdout assert ( '__VCAP_NFT_BEGIN__\n{"nftables":[]}\n__VCAP_NFT_END__0' in result.stdout ) assert nft_calls.read_text(encoding="utf-8") == "-j list tables\n" assert modinfo_calls.read_text(encoding="utf-8") == ( "-F filename wireguard\n") def test_capability_probe_command_executes_the_complete_wrapped_script(): argv = shlex.split(_CAPABILITY_PROBE_COMMAND) assert argv[:2] == ["/bin/sh", "-c"] assert len(argv) == 3 assert "__VCAP_END__" in argv[2] assert "'" not in argv[2] result = subprocess.run( argv, capture_output=True, text=True, check=False, timeout=15, ) assert result.returncode == 0, result.stderr assert result.stdout.startswith(f"{_CAPABILITY_MARKER}\n") assert result.stdout.rstrip().endswith("__VCAP_END__") class Runner: def __init__(self) -> None: self.key = host_key(b"a") self.ssh_exit = 0 self.encrypted = False self.public_key_type = "ssh-ed25519" self.capability_exit = 0 self.capability_output = CAPABILITY_OUTPUT self.commands: list[list[str]] = [] def __call__(self, argv, **kwargs): self.commands.append(argv) assert kwargs["timeout"] <= 22 assert kwargs["capture_output"] is True assert kwargs["check"] is False if argv[0] == "ssh-keyscan": return subprocess.CompletedProcess(argv, 0, f"[host.example]:2222 {self.key}\n", "") if argv[0] == "ssh-keygen": if self.encrypted: return subprocess.CompletedProcess(argv, 255, "", "passphrase required") return subprocess.CompletedProcess(argv, 0, f"{self.public_key_type} fake-public-key\n", "") if argv[0] == "ssh": if _CAPABILITY_MARKER in argv[-1]: return subprocess.CompletedProcess( argv, self.capability_exit, self.capability_output, "private remote diagnostic", ) return subprocess.CompletedProcess(argv, self.ssh_exit, "", "permission denied") raise AssertionError(argv) def make_manager(tmp_path: Path, runner: Runner) -> RemoteHostManager: return RemoteHostManager( tmp_path / "service-home", ssh_user_config_path=tmp_path / "service-home" / ".ssh" / "config", runner=runner, ) def make_profile( scanned: dict, *, key: str = PRIVATE_KEY, host: str = "host.example", passphrase: str = "", storage_pool: str = "images", iso_pool: str = "iso", rescue_iso_pool: str = "", default_network: str = "default", region: str = "", fabric_endpoint_ip: str = "", ) -> HostProfile: return HostProfile( host=host, port=2222, private_key=key, host_key=scanned["known_hosts_line"], private_key_passphrase=passphrase, storage_pool=storage_pool, iso_pool=iso_pool, rescue_iso_pool=rescue_iso_pool, default_network=default_network, region=region, fabric_endpoint_ip=fabric_endpoint_ip, ) def test_region_survives_host_save_and_legacy_metadata_defaults_empty(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile(scanned, region="中国香港"), scanned["fingerprint"]) manager.test(staged) assert manager.commit(staged)["region"] == "中国香港" profile_path = staged.path / "profile.json" legacy = json.loads(profile_path.read_text(encoding="utf-8")) legacy.pop("region") profile_path.write_text(json.dumps(legacy), encoding="utf-8") assert manager.current()["region"] == "" def test_fabric_endpoint_survives_save_and_legacy_metadata_defaults_empty(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile( scanned, fabric_endpoint_ip="10.20.30.40"), scanned["fingerprint"]) manager.test(staged) assert manager.commit(staged)["fabric_endpoint_ip"] == "10.20.30.40" profile_path = staged.path / "profile.json" legacy = json.loads(profile_path.read_text(encoding="utf-8")) legacy.pop("fabric_endpoint_ip") profile_path.write_text(json.dumps(legacy), encoding="utf-8") assert manager.current()["fabric_endpoint_ip"] == "" @pytest.mark.parametrize("endpoint", [ "host.example", " 10.0.0.1", "0.0.0.1", "127.0.0.1", "169.254.1.1", "224.0.0.1", "255.255.255.255", ]) def test_fabric_endpoint_rejects_unsafe_or_nonliteral_addresses( tmp_path, endpoint, ): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) with pytest.raises(RemoteHostError) as error: manager.stage(make_profile( scanned, fabric_endpoint_ip=endpoint), scanned["fingerprint"]) assert error.value.error_code == "host_fabric_endpoint_invalid" def test_fabric_endpoint_must_be_present_in_fresh_local_address_inventory(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile( scanned, fabric_endpoint_ip="10.20.30.41"), scanned["fingerprint"]) with pytest.raises(RemoteHostError) as error: manager.test(staged) assert error.value.error_code == "host_fabric_endpoint_not_local" assert staged.tested is False def test_public_pool_survives_host_save_and_legacy_metadata_defaults_empty(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) profile = replace( make_profile(scanned), public_pool_cidr="1.2.3.0/24", public_gateway="1.2.3.1", public_dns_servers=["1.1.1.1", "8.8.8.8"], public_reserved_ips=["1.2.3.10", "1.2.3.10"], ) staged = manager.stage(profile, scanned["fingerprint"]) assert staged.metadata["public_reserved_ips"] == ["1.2.3.10"] manager.test(staged) current = manager.commit(staged) assert current["public_pool_cidr"] == "1.2.3.0/24" assert current["public_gateway"] == "1.2.3.1" assert current["public_dns_servers"] == ["1.1.1.1", "8.8.8.8"] assert current["public_reserved_ips"] == ["1.2.3.10"] metadata_path = staged.path / "profile.json" legacy = json.loads(metadata_path.read_text(encoding="utf-8")) for key in ("public_pool_cidr", "public_gateway", "public_dns_servers", "public_reserved_ips"): legacy.pop(key) metadata_path.write_text(json.dumps(legacy), encoding="utf-8") assert manager.current()["public_pool_cidr"] == "" assert manager.current()["public_dns_servers"] == [] assert manager.current()["public_reserved_ips"] == [] def test_provider_28_gateway_cidr_is_saved_as_canonical_network(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) profile = replace( make_profile(scanned), public_pool_cidr="123.123.123.113/28", public_gateway="123.123.123.113", public_dns_servers=["1.1.1.1"], public_vm_prefix=24, ) staged = manager.stage(profile, scanned["fingerprint"]) assert staged.metadata["public_pool_cidr"] == "123.123.123.112/28" assert staged.metadata["public_vm_prefix"] == 24 manager.test(staged) assert manager.commit(staged)["public_pool_cidr"] == "123.123.123.112/28" assert manager.current()["public_vm_prefix"] == 24 class FakeAgent: sequence = itertools.count() def __init__(self, generation: Path, _key_path: Path, passphrase: str) -> None: if passphrase != "open-sesame": raise SSHAgentError("bad passphrase") self.socket_path = generation / f"agent-{next(self.sequence)}.sock" self.public_key = host_key(b"b") self.alive = True def close(self) -> None: self.alive = False def test_scan_returns_fingerprint_without_trusting_key(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) digest = hashlib.sha256(base64.b64decode(runner.key.split()[1])).digest() assert scanned == { "host": "host.example", "port": 2222, "key_type": "ssh-ed25519", "fingerprint": "SHA256:" + base64.b64encode(digest).decode("ascii").rstrip("="), "host_key": runner.key, "known_hosts_line": "vp-managed " + runner.key, } assert manager.current() is None assert not manager.ssh_user_config_path.exists() assert runner.commands[0] == [ "ssh-keyscan", "-T", "8", "-p", "2222", "-t", "ed25519", "host.example", ] def test_encrypted_key_is_memory_only_and_requires_unlock_after_restart(tmp_path): runner = Runner() runner.encrypted = True data_dir = tmp_path / "panel-data" manager = RemoteHostManager(data_dir, runner=runner, agent_factory=FakeAgent) scanned = manager.scan("host.example", 2222) staged = manager.stage( make_profile(scanned, passphrase="open-sesame"), scanned["fingerprint"], ) config = (staged.path / "config").read_text(encoding="ascii") assert f'IdentityFile "{staged.path / "identity.pub"}"' in config assert f'IdentityAgent "{manager._agents[staged.path].socket_path}"' in config assert all( b"open-sesame" not in path.read_bytes() for path in staged.path.iterdir() if path.is_file() ) manager.test(staged) manager.commit(staged) assert manager.current()["private_key_encrypted"] is True assert manager.current()["key_locked"] is False manager.close() assert manager.current()["key_locked"] is True restarted = RemoteHostManager(data_dir, runner=runner, agent_factory=FakeAgent) assert restarted.current()["key_locked"] is True original_config = (staged.path / "config").read_text(encoding="ascii") with pytest.raises(RemoteHostError, match="口令错误"): restarted.unlock_current("wrong") assert restarted.current()["key_locked"] is True assert (staged.path / "config").read_text(encoding="ascii") == original_config unlocked = restarted.unlock_current("open-sesame") assert unlocked["key_locked"] is False assert str(restarted._agents[staged.path].socket_path) in ( staged.path / "config" ).read_text(encoding="ascii") restarted.close() def test_encrypted_key_needs_passphrase_and_rejects_wrong_one(tmp_path): runner = Runner() runner.encrypted = True manager = RemoteHostManager(tmp_path / "panel-data", runner=runner, agent_factory=FakeAgent) scanned = manager.scan("host.example", 2222) with pytest.raises(RemoteHostError, match="填写私钥口令") as missing: manager.stage(make_profile(scanned), scanned["fingerprint"]) assert missing.value.error_code == "host_private_key_passphrase_required" with pytest.raises(RemoteHostError, match="口令错误") as wrong: manager.stage(make_profile(scanned, passphrase="wrong"), scanned["fingerprint"]) assert wrong.value.error_code == "host_private_key_invalid" assert not list((manager.data_dir / "generations").iterdir()) def test_invalid_private_key_has_stable_code_without_echoing_key(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) secret = "private-key-material-must-not-leak" with pytest.raises(RemoteHostError) as rejected: manager.stage( make_profile(scanned, key=secret), scanned["fingerprint"], ) assert rejected.value.error_code == "host_private_key_format_invalid" assert secret not in str(rejected.value) def test_existing_host_directories_are_accepted_as_pool_selectors(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage( make_profile(scanned, storage_pool="/home/kvm", iso_pool="/home/iso"), scanned["fingerprint"], ) assert staged.metadata["storage_pool"] == "/home/kvm" assert staged.metadata["iso_pool"] == "/home/iso" manager.abort(staged) def test_rescue_iso_pool_survives_host_save_and_legacy_defaults_unconfigured(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage( make_profile(scanned, iso_pool="/home/iso", rescue_iso_pool="/home/rescue-iso"), scanned["fingerprint"], ) assert staged.metadata["rescue_iso_pool"] == "/home/rescue-iso" manager.test(staged) assert manager.commit(staged)["rescue_iso_pool"] == "/home/rescue-iso" profile_path = staged.path / "profile.json" legacy = json.loads(profile_path.read_text(encoding="utf-8")) legacy.pop("rescue_iso_pool") profile_path.write_text(json.dumps(legacy), encoding="utf-8") assert manager.current()["rescue_iso_pool"] == "" @pytest.mark.parametrize( "rescue_selector,iso_selector", [ ("iso", "iso"), ("/home/iso", "/home/iso"), ], ) def test_rescue_pool_cannot_equal_install_iso_pool( tmp_path, rescue_selector, iso_selector, ): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) with pytest.raises(RemoteHostError, match="不能与安装 ISO 池相同"): manager.stage( make_profile(scanned, iso_pool=iso_selector, rescue_iso_pool=rescue_selector), scanned["fingerprint"], ) @pytest.mark.parametrize("selector", ["/", "/home/../iso", "/home//iso", "/home/iso/", None]) def test_rejects_invalid_rescue_pool_selector(tmp_path, selector): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) with pytest.raises(RemoteHostError, match="救援 ISO 池"): manager.stage( make_profile(scanned, rescue_iso_pool=selector), scanned["fingerprint"], ) def test_explicit_host_bridge_selector_is_accepted(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage( make_profile(scanned, default_network="bridge:br0"), scanned["fingerprint"], ) assert staged.metadata["default_network"] == "bridge:br0" manager.abort(staged) @pytest.mark.parametrize( "selector", ["bridge:", "bridge:br/0", "bridge:br 0", "bridge:-br0", "bridge:" + "a" * 16], ) def test_invalid_host_bridge_selector_is_rejected(tmp_path, selector): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) with pytest.raises(RemoteHostError, match="网桥名称格式无效"): manager.stage(make_profile(scanned, default_network=selector), scanned["fingerprint"]) def test_unencrypted_ecdsa_private_key_does_not_require_passphrase(tmp_path): runner = Runner() runner.public_key_type = "ecdsa-sha2-nistp256" manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile(scanned), scanned["fingerprint"]) assert staged.metadata["private_key_encrypted"] is False assert "IdentityAgent none" in (staged.path / "config").read_text() manager.abort(staged) @pytest.mark.parametrize("bad_path", ["/", "/home/../kvm", "/home//kvm", "/home/kvm/"]) def test_rejects_unsafe_pool_paths(tmp_path, bad_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) with pytest.raises(RemoteHostError, match="磁盘池"): manager.stage(make_profile(scanned, storage_pool=bad_path), scanned["fingerprint"]) def test_stage_test_commit_writes_private_pinned_ssh_config(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) stage = manager.stage(make_profile(scanned), scanned["fingerprint"]) assert stage.tested is False assert manager.current() is None for name in ("id_private", "known_hosts", "config", "profile.json"): path = stage.path / name assert stat.S_IMODE(path.stat().st_mode) == 0o600 assert stat.S_IMODE(stage.path.stat().st_mode) == 0o700 config = (stage.path / "config").read_text() assert "Host vp-managed\n" in config assert "HostName host.example\n" in config assert "Port 2222\n" in config assert "User root\n" in config assert "HostKeyAlias vp-managed\n" in config assert "StrictHostKeyChecking yes\n" in config assert "BatchMode yes\n" in config assert "IdentitiesOnly yes\n" in config assert "PasswordAuthentication no\n" in config assert "HostKeyAlgorithms ssh-ed25519\n" in config assert "ServerAliveInterval 15\n" in config assert "ServerAliveCountMax 2\n" in config assert (stage.path / "known_hosts").read_text() == scanned["known_hosts_line"] + "\n" assert (stage.path / "id_private").read_text() == PRIVATE_KEY wrapper = stage.path / "ssh-wrapper" assert stat.S_IMODE(wrapper.stat().st_mode) == 0o700 assert parse_qs(urlsplit(stage.libvirt_uri).query)["command"] == [str(wrapper)] tested = manager.test(stage) assert tested["ok"] is True assert tested["ssh"] == "connected" assert tested["libvirt"] == "available" assert tested["capabilities"]["schema_version"] == HOST_CAPABILITY_SCHEMA_VERSION assert tested["capabilities"]["vpc_ready"] is True assert tested["capabilities"]["os"]["package_tool"] == "dnf" assert tested["capabilities"]["os"]["package_tool_available"] is True assert tested["capabilities"]["wireguard"]["deployment_mode"] == "networkmanager_nmcli" assert tested["capabilities"]["nftables"]["service_active"] is True assert tested["capabilities"]["nftables"]["service_persistent"] is True assert tested["capabilities"]["network"]["firewall_manager_evidence"] == { "firewalld_active": False, "firewalld_enabled": False, "firewalld_load_state": "masked", "legacy_firewalld_table_present": False, "legacy_manifest_state": "absent", "fabric_transaction_state": "absent", "emergency_owner_state": "absent", "vpc_transaction_state": "absent", "vpc_snapshot_state": "absent", "fabric_desired_state": "absent", "vpc_state": "absent", "nftables_active": True, "nftables_enabled": True, "nftables_load_state": "loaded", } assert tested["capabilities"]["network"]["local_ipv4_addresses"] == [ "10.20.30.40", "203.0.113.10", ] assert tested["capabilities"]["network"]["local_ipv4_interfaces"] == { "10.20.30.40": ["eth1"], "203.0.113.10": ["br0"], } assert tested["capabilities"]["network"]["rp_filter_default"] == 2 assert tested["capabilities"]["network"]["rp_filter_interfaces"]["br0"] == 2 assert tested["capabilities"]["network_roles"]["private"]["host_interface"] == WG_FABRIC_INTERFACE assert runner.commands[-1][0:4] == ["ssh", "-F", stage.ssh_config_file, "-T"] current = manager.commit(stage) assert current["host"] == "host.example" assert current["port"] == 2222 assert current["fingerprint"] == scanned["fingerprint"] assert current["private_key_configured"] is True assert current["libvirt_uri"].startswith( "qemu+ssh://root@vp-managed/system?no_tty=1&command=" ) assert parse_qs(urlsplit(current["libvirt_uri"]).query)["command"] == [str(wrapper)] assert manager.libvirt_uri == current["libvirt_uri"] assert current["ssh_target"] == "vp-managed" assert "private_key" not in current assert PRIVATE_KEY not in repr(current) assert manager.ssh_user_config_path.is_symlink() assert manager.ssh_user_config_path.resolve() == stage.path / "config" assert stat.S_IMODE(manager.ssh_user_config_path.parent.stat().st_mode) == 0o700 def test_capability_snapshot_is_persisted_only_after_commit(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile(scanned), scanned["fingerprint"]) tested = manager.test(staged) assert tested["capabilities"]["os"]["id"] == "almalinux" profile_before = json.loads((staged.path / "profile.json").read_text()) assert "capabilities" not in profile_before current = manager.commit(staged) assert current["capabilities"]["vpc_ready"] is True profile_after = json.loads((staged.path / "profile.json").read_text()) assert profile_after["capabilities"]["wireguard"]["interface"] == WG_FABRIC_INTERFACE def test_current_capabilities_are_reprobed_through_pinned_generation(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage( make_profile(scanned, default_network="bridge:br0"), scanned["fingerprint"], ) manager.test(staged) current = manager.commit(staged) profile_path = staged.path / "profile.json" persisted_before = profile_path.read_bytes() runner.capability_output = CAPABILITY_OUTPUT.replace( "__VCAP_SERVICE_ENABLED__nftables=enabled", "__VCAP_SERVICE_ENABLED__nftables=disabled", ) capabilities = manager.reprobe_current_capabilities() assert capabilities["probe_valid"] is True assert capabilities["network_roles"]["public"]["selector"] == "bridge:br0" assert capabilities["nftables"]["service_active"] is True assert capabilities["nftables"]["service_persistent"] is False assert capabilities["nftables"]["ready"] is True assert capabilities["vpc_ready"] is True assert "nftables_service_not_enabled" not in capabilities["reasons"] assert profile_path.read_bytes() == persisted_before assert current["capabilities"]["vpc_ready"] is True assert runner.commands[-1][0:4] == [ "ssh", "-F", str(staged.path / "config"), "-T", ] assert runner.commands[-1][-1] == _CAPABILITY_PROBE_COMMAND def test_current_fabric_endpoint_requires_fresh_local_address_evidence(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile( scanned, fabric_endpoint_ip="10.20.30.40"), scanned["fingerprint"]) manager.test(staged) manager.commit(staged) runner.capability_output = CAPABILITY_OUTPUT.replace( '"local":"10.20.30.40"', '"local":"10.20.30.41"') with pytest.raises(RemoteHostError) as error: manager.reprobe_current_snapshot() assert error.value.error_code == "host_fabric_endpoint_not_local" def test_current_capability_reprobe_requires_configured_host(tmp_path): manager = make_manager(tmp_path, Runner()) with pytest.raises(RemoteHostError) as error: manager.reprobe_current_capabilities() assert error.value.status == 409 assert error.value.error_code == "host_not_configured" def test_current_capability_reprobe_hides_remote_failure_output(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile(scanned), scanned["fingerprint"]) manager.test(staged) manager.commit(staged) runner.capability_exit = 255 with pytest.raises(RemoteHostError) as error: manager.reprobe_current_capabilities() assert error.value.status == 502 assert error.value.error_code == "host_capability_probe_failed" assert "private remote diagnostic" not in str(error.value) def test_current_capability_reprobe_rejects_invalid_protocol(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile(scanned), scanned["fingerprint"]) manager.test(staged) manager.commit(staged) runner.capability_output = CAPABILITY_OUTPUT.replace("__VCAP_END__", "") with pytest.raises(RemoteHostError) as error: manager.reprobe_current_capabilities() assert error.value.status == 502 assert error.value.error_code == "host_capability_probe_invalid" def test_capability_probe_rejects_missing_private_plane_evidence(): output = CAPABILITY_OUTPUT.replace( "__VCAP_TOOL__wg=/usr/bin/wg", "__VCAP_TOOL__wg=", ).replace( "__VCAP_SERVICE__nftables=active", "__VCAP_SERVICE__nftables=inactive", ).replace( "__VCAP_SYSCTL__ip_forward=1", "__VCAP_SYSCTL__ip_forward=0", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["probe_valid"] is True assert capabilities["private_ready"] is False assert capabilities["vpc_ready"] is False assert "wireguard_tool_missing" in capabilities["reasons"] assert capabilities["nftables"]["ready"] is True assert "nftables_service_not_active" not in capabilities["reasons"] assert "ipv4_forwarding_disabled_or_unknown" in capabilities["reasons"] assert capabilities["network_roles"]["private"]["separate_from_public"] is True assert capabilities["network_roles"]["public"]["cloud_init_key"] == "public0" assert capabilities["network_roles"]["public"]["guest_alias"] == "ua-public0" assert capabilities["network_roles"]["private"]["cloud_init_key"] == "private0" assert capabilities["network_roles"]["private"]["guest_alias"] == "ua-private0" def test_capability_probe_rejects_firewalld_enabled_for_next_boot(): output = CAPABILITY_OUTPUT.replace( "__VCAP_SERVICE_ENABLED__firewall=masked", "__VCAP_SERVICE_ENABLED__firewall=enabled", ).replace( "__VCAP_SERVICE_LOAD__firewall=masked", "__VCAP_SERVICE_LOAD__firewall=loaded", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["network"]["firewall_manager"] == "conflict" assert capabilities["nftables"]["ready"] is False assert capabilities["vpc_ready"] is False assert "firewall_manager_conflict" in capabilities["reasons"] assert "firewalld_unsupported_requires_maintenance" in capabilities["reasons"] assert "firewall_owner_not_nftables" in capabilities["reasons"] def firewalld_capability_output( *, firewalld_active="active", firewalld_enabled="enabled", firewalld_load="loaded", nft_active="inactive", nft_enabled="masked", nft_load="masked", live_table=False, ): replacements = ( ("__VCAP_SERVICE__firewall=inactive", f"__VCAP_SERVICE__firewall={firewalld_active}"), ("__VCAP_SERVICE__nftables=active", f"__VCAP_SERVICE__nftables={nft_active}"), ("__VCAP_SERVICE_ENABLED__firewall=masked", f"__VCAP_SERVICE_ENABLED__firewall={firewalld_enabled}"), ("__VCAP_SERVICE_LOAD__firewall=masked", f"__VCAP_SERVICE_LOAD__firewall={firewalld_load}"), ("__VCAP_SERVICE_ENABLED__nftables=enabled", f"__VCAP_SERVICE_ENABLED__nftables={nft_enabled}"), ("__VCAP_SERVICE_LOAD__nftables=loaded", f"__VCAP_SERVICE_LOAD__nftables={nft_load}"), ) output = CAPABILITY_OUTPUT for old, new in replacements: output = output.replace(old, new) if live_table: output = output.replace( '{"nftables":[{"table":{"family":"inet","name":"filter"}}]}', '{"nftables":[{"table":{"family":"inet","name":"filter"}},' '{"table":{"family":"inet","name":"firewalld"}}]}', ) return output def test_capability_probe_rejects_runtime_only_firewalld_enablement(): capabilities = parse_host_capabilities(firewalld_capability_output( firewalld_enabled="enabled-runtime", ), public_network="bridge:br0") assert capabilities["network"]["firewall_manager"] == "firewalld" assert capabilities["network"]["firewall_mode"] == "unsupported" assert capabilities["vpc_ready"] is False assert "firewalld_unsupported_requires_maintenance" in capabilities["reasons"] @pytest.mark.parametrize(("active", "enabled", "load"), ( ("active", "enabled-runtime", "loaded"), ("inactive", "disabled", "loaded"), ("inactive", "masked", "masked"), ("unknown", "unknown", "not-found"), )) def test_capability_probe_accepts_native_nft_independent_of_stock_service( active, enabled, load, ): output = CAPABILITY_OUTPUT.replace( "__VCAP_SERVICE__nftables=active", f"__VCAP_SERVICE__nftables={active}", ).replace( "__VCAP_SERVICE_ENABLED__nftables=enabled", f"__VCAP_SERVICE_ENABLED__nftables={enabled}", ).replace( "__VCAP_SERVICE_LOAD__nftables=loaded", f"__VCAP_SERVICE_LOAD__nftables={load}", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["network"]["firewall_manager"] == "nftables" assert capabilities["network"]["firewall_mode"] == "native_nftables" assert capabilities["nftables"]["service"] == active assert capabilities["nftables"]["service_enabled"] == enabled assert capabilities["network"]["firewall_manager_evidence"][ "nftables_load_state" ] == load assert capabilities["nftables"]["ready"] is True assert capabilities["vpc_ready"] is True assert "nftables_service_not_active" not in capabilities["reasons"] assert "nftables_service_not_enabled" not in capabilities["reasons"] @pytest.mark.parametrize(("output", "reason"), ( ( CAPABILITY_OUTPUT.replace( "__VCAP_TOOL__nft=/usr/sbin/nft", "__VCAP_TOOL__nft="), "nftables_tool_missing", ), ( CAPABILITY_OUTPUT.replace("__VCAP_NFT_END__0", "__VCAP_NFT_END__1"), "nftables_probe_failed", ), )) def test_capability_probe_still_requires_direct_nft_access(output, reason): capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["network"]["firewall_mode"] == "unsupported" assert capabilities["nftables"]["ready"] is False assert capabilities["vpc_ready"] is False assert reason in capabilities["reasons"] @pytest.mark.parametrize("state", ("missing", "unsafe", "conflict")) def test_capability_probe_requires_one_safe_nft_main_config(state): output = CAPABILITY_OUTPUT.replace( "__VCAP_NFT_PERSISTENCE__main=ready", f"__VCAP_NFT_PERSISTENCE__main={state}", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["probe_valid"] is True assert capabilities["nftables"]["persistence_main_state"] == state assert capabilities["nftables"]["ready"] is False assert capabilities["vpc_ready"] is False assert "nftables_persistence_not_ready" in capabilities["reasons"] @pytest.mark.parametrize("replacement", ( "", "__VCAP_NFT_PERSISTENCE__main=ready\n" "__VCAP_NFT_PERSISTENCE__main=ready", "__VCAP_NFT_PERSISTENCE__main=unknown", )) def test_capability_probe_rejects_invalid_nft_persistence_evidence(replacement): capabilities = parse_host_capabilities( CAPABILITY_OUTPUT.replace( "__VCAP_NFT_PERSISTENCE__main=ready", replacement), public_network="bridge:br0", ) assert capabilities["probe_valid"] is False assert capabilities["nftables"]["ready"] is False assert capabilities["vpc_ready"] is False assert "nftables_persistence_evidence_invalid" in capabilities["reasons"] def test_capability_probe_rejects_an_active_competing_nftables_service(): capabilities = parse_host_capabilities(firewalld_capability_output( nft_active="active", ), public_network="bridge:br0") assert capabilities["network"]["firewall_manager"] == "conflict" assert capabilities["network"]["firewall_mode"] == "unsupported" assert capabilities["nftables"]["ready"] is False assert "firewall_manager_conflict" in capabilities["reasons"] assert "firewalld_unsupported_requires_maintenance" in capabilities["reasons"] def test_capability_probe_accepts_native_owner_when_firewalld_is_not_found(): output = CAPABILITY_OUTPUT.replace( "__VCAP_SERVICE__firewall=inactive", "__VCAP_SERVICE__firewall=unknown", ).replace( "__VCAP_SERVICE_ENABLED__firewall=masked", "__VCAP_SERVICE_ENABLED__firewall=unknown", ).replace( "__VCAP_SERVICE_LOAD__firewall=masked", "__VCAP_SERVICE_LOAD__firewall=not-found", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["network"]["firewall_mode"] == "native_nftables" assert capabilities["nftables"]["ready"] is True assert capabilities["vpc_ready"] is True def test_capability_probe_rejects_inactive_but_unmasked_firewalld_competitor(): native = CAPABILITY_OUTPUT.replace( "__VCAP_SERVICE_ENABLED__firewall=masked", "__VCAP_SERVICE_ENABLED__firewall=disabled", ).replace( "__VCAP_SERVICE_LOAD__firewall=masked", "__VCAP_SERVICE_LOAD__firewall=loaded", ).replace( "__VCAP_SERVICE__nftables=active", "__VCAP_SERVICE__nftables=inactive", ).replace( "__VCAP_SERVICE_ENABLED__nftables=enabled", "__VCAP_SERVICE_ENABLED__nftables=disabled", ) native_capabilities = parse_host_capabilities( native, public_network="bridge:br0") assert native_capabilities["network"]["firewall_mode"] == "unsupported" assert "firewalld_unsupported_requires_maintenance" in ( native_capabilities["reasons"]) @pytest.mark.parametrize(("family", "table"), ( ("inet", "firewalld"), ("inet", "virt_cloud_fabric_emergency"), ("bridge", "virt_cloud_fabric_emergency"), )) def test_capability_probe_rejects_live_legacy_firewall_table(family, table): output = CAPABILITY_OUTPUT.replace( '{"nftables":[{"table":{"family":"inet","name":"filter"}}]}', '{"nftables":[{"table":{"family":"inet","name":"filter"}},' f'{{"table":{{"family":"{family}","name":"{table}"}}}}]}}', ) capabilities = parse_host_capabilities( output, public_network="bridge:br0", ) assert capabilities["network"]["firewall_manager"] == "nftables" assert capabilities["network"]["firewall_mode"] == "unsupported" assert capabilities["network"]["firewall_manager_evidence"][ "legacy_firewalld_table_present"] is True assert capabilities["nftables"]["ready"] is False assert capabilities["vpc_ready"] is False assert "legacy_firewalld_state_requires_cleanup" in capabilities["reasons"] @pytest.mark.parametrize(("marker", "reason"), ( ("manifest", "legacy_firewalld_state_requires_cleanup"), ("vpc_snapshot", "legacy_firewalld_state_requires_cleanup"), ("fabric_desired_state", "legacy_firewalld_state_requires_cleanup"), ("vpc_state", "legacy_firewalld_state_requires_cleanup"), ("emergency_owner", "legacy_firewalld_state_requires_cleanup"), ("fabric_transaction", "firewall_transaction_requires_recovery_or_cleanup"), ("vpc_transaction", "firewall_transaction_requires_recovery_or_cleanup"), )) def test_capability_probe_rejects_legacy_firewall_artifact(marker, reason): output = CAPABILITY_OUTPUT.replace( f"__VCAP_LEGACY_FIREWALL__{marker}=absent", f"__VCAP_LEGACY_FIREWALL__{marker}=present", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["probe_valid"] is True assert capabilities["vpc_ready"] is False assert capabilities["network"]["firewall_mode"] == "unsupported" evidence_key = { "manifest": "legacy_manifest_state", "fabric_transaction": "fabric_transaction_state", "emergency_owner": "emergency_owner_state", "vpc_transaction": "vpc_transaction_state", "vpc_snapshot": "vpc_snapshot_state", }.get(marker, marker) assert capabilities["network"]["firewall_manager_evidence"][ evidence_key ] == "present" assert reason in capabilities["reasons"] @pytest.mark.parametrize("failure", ("missing", "duplicate", "unknown")) @pytest.mark.parametrize("marker", ( "manifest", "fabric_transaction", "emergency_owner", "vpc_transaction", "vpc_snapshot", "fabric_desired_state", "vpc_state", )) def test_capability_probe_fails_closed_on_invalid_legacy_firewall_evidence( marker, failure, ): line = f"__VCAP_LEGACY_FIREWALL__{marker}=absent" if failure == "missing": replacement = "" elif failure == "duplicate": replacement = line + "\n" + line else: replacement = f"__VCAP_LEGACY_FIREWALL__{marker}=unknown" capabilities = parse_host_capabilities( CAPABILITY_OUTPUT.replace(line, replacement), public_network="bridge:br0", ) assert capabilities["probe_valid"] is False assert capabilities["vpc_ready"] is False assert "legacy_firewall_evidence_invalid" in capabilities["reasons"] def test_capability_probe_rejects_preexisting_fabric_interface(): output = CAPABILITY_OUTPUT.replace( '[{"ifname":"br0"}]', '[{"ifname":"br0"},{"ifname":"wg-fabric0"}]', 1, ).replace( "__VCAP_IP_BEGIN__wireguard\n[]", '__VCAP_IP_BEGIN__wireguard\n[{"ifname":"wg-fabric0"}]', ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["vpc_ready"] is False assert "wireguard_fabric_interface_conflict" in capabilities["reasons"] def test_capability_probe_rejects_reserved_name_used_by_non_wireguard_link(): output = CAPABILITY_OUTPUT.replace( '[{"ifname":"br0"}]', '[{"ifname":"br0"},{"ifname":"wg-fabric0"}]', 1, ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["vpc_ready"] is False assert capabilities["wireguard"]["interface_name_reserved"] is True assert capabilities["wireguard"]["interface_is_wireguard"] is False assert "wireguard_fabric_interface_conflict" in capabilities["reasons"] def test_capability_probe_accepts_panel_owned_fabric_interface(): output = CAPABILITY_OUTPUT.replace( '[{"ifname":"br0"}]', '[{"ifname":"br0"},{"ifname":"wg-fabric0"}]', 1, ).replace( "__VCAP_IP_BEGIN__wireguard\n[]", '__VCAP_IP_BEGIN__wireguard\n[{"ifname":"wg-fabric0"}]', ).replace( "__VCAP_FABRIC_OWNER_BEGIN__\n__VCAP_FABRIC_OWNER_END__", "__VCAP_FABRIC_OWNER_BEGIN__\n" + WG_FABRIC_OWNERSHIP_MARKER + "\n__VCAP_FABRIC_OWNER_END__", ).replace( "__VCAP_RPF__br0=2", "__VCAP_RPF__br0=2\n__VCAP_RPF__wg-fabric0=2", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["vpc_ready"] is True assert capabilities["wireguard"]["owned_by_panel"] is True def test_capability_probe_accepts_almalinux_strict_underlay_for_auto_config(): output = CAPABILITY_OUTPUT.replace( "__VCAP_SYSCTL__rp_filter=2", "__VCAP_SYSCTL__rp_filter=0", ).replace( "__VCAP_SYSCTL__rp_filter_default=2", "__VCAP_SYSCTL__rp_filter_default=1", ).replace( "__VCAP_RPF__br0=2", "__VCAP_RPF__br0=1", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["vpc_ready"] is True assert "rp_filter_not_compatible" not in capabilities["reasons"] network = capabilities["network"] assert network["rp_filter"] == 0 assert network["rp_filter_default"] == 1 assert network["rp_filter_default_effective"] == 1 assert network["fabric_rp_filter_raw"] is None assert network["fabric_rp_filter_effective"] is None def test_capability_probe_accepts_debian_loose_rp_filter_defaults(): output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace( 'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"', ).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace( "__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=", ).replace( "__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get", ).replace( "__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup", ).replace( "__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown", ).replace( "__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery", ).replace( "__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive", ).replace( "__VCAP_SERVICE_ENABLED__network_manager=enabled", "__VCAP_SERVICE_ENABLED__network_manager=disabled", ).replace( "__VCAP_SERVICE_ENABLED__networking=disabled", "__VCAP_SERVICE_ENABLED__networking=enabled", ).replace( "__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present", ).replace( "__VCAP_SYSCTL__rp_filter=2", "__VCAP_SYSCTL__rp_filter=0", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["os"]["id"] == "debian" assert capabilities["vpc_ready"] is True assert "rp_filter_not_compatible" not in capabilities["reasons"] network = capabilities["network"] assert network["rp_filter"] == 0 assert network["rp_filter_default"] == 2 assert network["rp_filter_default_effective"] == 2 @pytest.mark.parametrize( ("all_value", "interface_value", "expected_effective"), [ (0, 0, 0), (0, 1, 1), (0, 2, 2), (1, 0, 1), (1, 1, 1), (1, 2, 2), (2, 0, 2), (2, 1, 2), (2, 2, 2), ], ) def test_capability_probe_reports_kernel_rp_filter_max_semantics( all_value, interface_value, expected_effective, ): output = CAPABILITY_OUTPUT.replace( "__VCAP_SYSCTL__rp_filter=2", f"__VCAP_SYSCTL__rp_filter={all_value}", ).replace( "__VCAP_SYSCTL__rp_filter_default=2", f"__VCAP_SYSCTL__rp_filter_default={interface_value}", ).replace( '[{"ifname":"br0"}]', '[{"ifname":"br0"},{"ifname":"wg-fabric0"}]', 1, ).replace( "__VCAP_IP_BEGIN__wireguard\n[]", '__VCAP_IP_BEGIN__wireguard\n[{"ifname":"wg-fabric0"}]', ).replace( "__VCAP_FABRIC_OWNER_BEGIN__\n__VCAP_FABRIC_OWNER_END__", "__VCAP_FABRIC_OWNER_BEGIN__\n" + WG_FABRIC_OWNERSHIP_MARKER + "\n__VCAP_FABRIC_OWNER_END__", ).replace( "__VCAP_RPF__br0=2", "__VCAP_RPF__br0=2\n" f"__VCAP_RPF__wg-fabric0={interface_value}", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["vpc_ready"] is True assert "rp_filter_not_compatible" not in capabilities["reasons"] network = capabilities["network"] assert network["rp_filter_default_effective"] == expected_effective assert network["fabric_rp_filter_raw"] == interface_value assert network["fabric_rp_filter_effective"] == expected_effective @pytest.mark.parametrize( "mutation", [ ("__VCAP_SYSCTL__rp_filter=2", ""), ("__VCAP_SYSCTL__rp_filter=2", "__VCAP_SYSCTL__rp_filter=invalid"), ("__VCAP_SYSCTL__rp_filter=2", "__VCAP_SYSCTL__rp_filter=3"), ("__VCAP_SYSCTL__rp_filter_default=2", ""), ( "__VCAP_SYSCTL__rp_filter_default=2", "__VCAP_SYSCTL__rp_filter_default=invalid", ), ("__VCAP_SYSCTL__rp_filter_default=2", "__VCAP_SYSCTL__rp_filter_default=3"), ], ) def test_capability_probe_rejects_missing_or_invalid_required_rp_filter( mutation, ): old, new = mutation capabilities = parse_host_capabilities( CAPABILITY_OUTPUT.replace(old, new), public_network="bridge:br0", ) assert capabilities["private_ready"] is False assert capabilities["vpc_ready"] is False assert "rp_filter_not_compatible" in capabilities["reasons"] @pytest.mark.parametrize("fabric_value", [None, "invalid", "3"]) def test_capability_probe_requires_valid_rp_filter_for_existing_fabric( fabric_value, ): output = CAPABILITY_OUTPUT.replace( '[{"ifname":"br0"}]', '[{"ifname":"br0"},{"ifname":"wg-fabric0"}]', 1, ).replace( "__VCAP_IP_BEGIN__wireguard\n[]", '__VCAP_IP_BEGIN__wireguard\n[{"ifname":"wg-fabric0"}]', ).replace( "__VCAP_FABRIC_OWNER_BEGIN__\n__VCAP_FABRIC_OWNER_END__", "__VCAP_FABRIC_OWNER_BEGIN__\n" + WG_FABRIC_OWNERSHIP_MARKER + "\n__VCAP_FABRIC_OWNER_END__", ) if fabric_value is not None: output = output.replace( "__VCAP_RPF__br0=2", "__VCAP_RPF__br0=2\n" f"__VCAP_RPF__wg-fabric0={fabric_value}", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["private_ready"] is False assert "rp_filter_not_compatible" in capabilities["reasons"] def test_capability_probe_ignores_guest_vnet_rp_filter_values(): output = CAPABILITY_OUTPUT.replace( "__VCAP_RPF__br0=2", "__VCAP_RPF__br0=2\n" "__VCAP_RPF__vnet1=1\n" "__VCAP_RPF__vnet3=3\n" "__VCAP_RPF__vnet10=invalid", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["vpc_ready"] is True assert "rp_filter_not_compatible" not in capabilities["reasons"] @pytest.mark.parametrize("underlay_value", [None, "invalid", "3"]) def test_capability_probe_does_not_guess_endpoint_from_public_bridge_selector( underlay_value, ): output = CAPABILITY_OUTPUT if underlay_value is None: output = output.replace("__VCAP_RPF__br0=2", "") else: output = output.replace( "__VCAP_RPF__br0=2", f"__VCAP_RPF__br0={underlay_value}", ) capabilities = parse_host_capabilities( output, public_network="bridge:br0", ) assert capabilities["network_roles"]["public"]["verified"] is True assert capabilities["private_ready"] is True assert capabilities["vpc_ready"] is True assert "rp_filter_not_compatible" not in capabilities["reasons"] def test_capability_probe_fails_closed_when_protocol_section_is_missing(): capabilities = parse_host_capabilities( CAPABILITY_OUTPUT.replace("__VCAP_NFT_BEGIN__\n", ""), public_network="bridge:br0", ) assert capabilities["probe_valid"] is False assert capabilities["vpc_ready"] is False assert "capability_probe_invalid" in capabilities["reasons"] def test_capability_probe_fails_closed_on_malformed_ip_json(): capabilities = parse_host_capabilities( CAPABILITY_OUTPUT.replace( '[{"ifname":"br0"}]', '[{"ifname":42}]', 1, ), public_network="default", ) assert capabilities["network"]["ip_probe_valid"] is False assert capabilities["vpc_ready"] is False assert "iproute2_probe_failed" in capabilities["reasons"] def test_capability_probe_accepts_debian_wireguard_placeholders_when_unloaded(): output = CAPABILITY_OUTPUT.replace( "__VCAP_MODULE__wireguard=loaded", "__VCAP_MODULE__wireguard=not_loaded", ).replace( "__VCAP_IP_BEGIN__wireguard\n[]", "__VCAP_IP_BEGIN__wireguard\n[{}, {}, {}]", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["network"]["ip_probe_valid"] is True assert capabilities["network"]["wireguard_interfaces"] == [] assert "iproute2_probe_failed" not in capabilities["reasons"] def test_capability_probe_rejects_wireguard_placeholders_when_loaded(): output = CAPABILITY_OUTPUT.replace( "__VCAP_IP_BEGIN__wireguard\n[]", "__VCAP_IP_BEGIN__wireguard\n[{}]", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["network"]["ip_probe_valid"] is False assert "iproute2_probe_failed" in capabilities["reasons"] def test_capability_probe_rejects_nonempty_malformed_wireguard_record(): output = CAPABILITY_OUTPUT.replace( "__VCAP_MODULE__wireguard=loaded", "__VCAP_MODULE__wireguard=not_loaded", ).replace( "__VCAP_IP_BEGIN__wireguard\n[]", '__VCAP_IP_BEGIN__wireguard\n[{}, {"ifindex":1}]', ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["network"]["ip_probe_valid"] is False assert "iproute2_probe_failed" in capabilities["reasons"] @pytest.mark.parametrize("section", ["links", "addresses", "bridges"]) def test_capability_probe_rejects_empty_placeholders_outside_wireguard(section): begin = f"__VCAP_IP_BEGIN__{section}\n" section_start = CAPABILITY_OUTPUT.index(begin) + len(begin) section_end = CAPABILITY_OUTPUT.index( f"__VCAP_IP_END__{section}=", section_start) output = ( CAPABILITY_OUTPUT[:section_start] + "[{}]\n" + CAPABILITY_OUTPUT[section_end:] ).replace( "__VCAP_MODULE__wireguard=loaded", "__VCAP_MODULE__wireguard=not_loaded", ) capabilities = parse_host_capabilities(output, public_network="bridge:br0") assert capabilities["network"]["ip_probe_valid"] is False assert "iproute2_probe_failed" in capabilities["reasons"] def test_capability_probe_rejects_debian_networkd_policy(): output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace( 'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"', ).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace( "__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=", ).replace( "__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get", ).replace( "__VCAP_TOOL__networkctl=", "__VCAP_TOOL__networkctl=/usr/bin/networkctl", ).replace( "__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive", ).replace( "__VCAP_SERVICE__networkd=inactive", "__VCAP_SERVICE__networkd=active", ).replace( "__VCAP_SERVICE_ENABLED__network_manager=enabled", "__VCAP_SERVICE_ENABLED__network_manager=disabled", ).replace( "__VCAP_SERVICE_ENABLED__networkd=disabled", "__VCAP_SERVICE_ENABLED__networkd=enabled", ) capabilities = parse_host_capabilities(output) assert capabilities["os"]["id"] == "debian" assert capabilities["os"]["name"] == "Debian GNU/Linux" assert capabilities["os"]["version_id"] == "13" assert capabilities["os"]["family"] == "debian" assert capabilities["os"]["package_manager"] == "apt" assert capabilities["os"]["package_tool"] == "apt_get" assert capabilities["os"]["package_tool_available"] is True assert capabilities["os"]["supported"] is True assert capabilities["network"]["network_manager"] == "systemd_networkd" assert capabilities["network"]["network_manager_expected"] == "ifupdown" assert capabilities["wireguard"]["deployment_mode"] == "unsupported" assert capabilities["vpc_ready"] is False assert "systemd_networkd_not_supported" in capabilities["reasons"] def test_capability_probe_supports_debian_ifupdown_contract(): output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace( 'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"', ).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace( "__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=", ).replace( "__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get", ).replace( "__VCAP_TOOL__networkctl=", "__VCAP_TOOL__networkctl=", ).replace( "__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup", ).replace( "__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown", ).replace( "__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery", ).replace( "__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive", ).replace( "__VCAP_SERVICE_ENABLED__network_manager=enabled", "__VCAP_SERVICE_ENABLED__network_manager=disabled", ).replace( "__VCAP_SERVICE_ENABLED__networking=disabled", "__VCAP_SERVICE_ENABLED__networking=enabled", ).replace( "__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present", ) capabilities = parse_host_capabilities(output) assert capabilities["network"]["network_manager"] == "ifupdown" assert capabilities["network"]["network_manager_expected"] == "ifupdown" assert capabilities["network"]["ifupdown"]["configured"] is True assert capabilities["network"]["ifupdown"]["service_enabled"] is True assert capabilities["network"]["deployment_mode"] == "ifupdown" assert capabilities["wireguard"]["deployment_mode"] == "ifupdown" assert capabilities["vpc_ready"] is True def test_capability_probe_ignores_static_networkd_when_ifupdown_owns_debian(): output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace( 'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"', ).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace( "__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=", ).replace( "__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get", ).replace( "__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup", ).replace( "__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown", ).replace( "__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery", ).replace( "__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive", ).replace( "__VCAP_SERVICE_ENABLED__network_manager=enabled", "__VCAP_SERVICE_ENABLED__network_manager=disabled", ).replace( "__VCAP_SERVICE_ENABLED__networkd=disabled", "__VCAP_SERVICE_ENABLED__networkd=static", ).replace( "__VCAP_SERVICE_ENABLED__networking=disabled", "__VCAP_SERVICE_ENABLED__networking=enabled", ).replace( "__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present", ) capabilities = parse_host_capabilities(output) assert capabilities["network"]["network_manager"] == "ifupdown" assert capabilities["network"]["network_manager_supported"] is True assert capabilities["vpc_ready"] is True def test_capability_probe_rejects_ifupdown_without_required_tools(): output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace( 'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"', ).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace( "__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=", ).replace( "__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get", ).replace( "__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive", ).replace( "__VCAP_SERVICE_ENABLED__network_manager=enabled", "__VCAP_SERVICE_ENABLED__network_manager=disabled", ).replace( "__VCAP_SERVICE_ENABLED__networking=disabled", "__VCAP_SERVICE_ENABLED__networking=enabled", ).replace( "__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present", ) capabilities = parse_host_capabilities(output) assert capabilities["network"]["network_manager"] == "ifupdown" assert capabilities["vpc_ready"] is False assert "ifupdown_tools_missing" in capabilities["reasons"] def test_capability_probe_rejects_mixed_network_managers(): output = CAPABILITY_OUTPUT.replace( "__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup", ).replace( "__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown", ).replace( "__VCAP_SERVICE_ENABLED__networking=disabled", "__VCAP_SERVICE_ENABLED__networking=enabled", ).replace( "__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present", ) capabilities = parse_host_capabilities(output) assert capabilities["network"]["network_manager"] == "conflict" assert capabilities["network"]["network_manager_supported"] is False assert capabilities["vpc_ready"] is False assert "network_manager_conflict" in capabilities["reasons"] def test_capability_probe_rejects_enabled_networkd_with_ifupdown(): output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace( 'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"', ).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace( "__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=", ).replace( "__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get", ).replace( "__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup", ).replace( "__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown", ).replace( "__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery", ).replace( "__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive", ).replace( "__VCAP_SERVICE_ENABLED__network_manager=enabled", "__VCAP_SERVICE_ENABLED__network_manager=disabled", ).replace( "__VCAP_SERVICE_ENABLED__networkd=disabled", "__VCAP_SERVICE_ENABLED__networkd=enabled", ).replace( "__VCAP_SERVICE_ENABLED__networking=disabled", "__VCAP_SERVICE_ENABLED__networking=enabled", ).replace( "__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present", ) capabilities = parse_host_capabilities(output) assert capabilities["network"]["network_manager"] == "conflict" assert capabilities["vpc_ready"] is False assert "network_manager_conflict" in capabilities["reasons"] def test_capability_probe_rejects_persistent_networkd_config_with_ifupdown(): output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace( 'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"', ).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace( "__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=", ).replace( "__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get", ).replace( "__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup", ).replace( "__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown", ).replace( "__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery", ).replace( "__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive", ).replace( "__VCAP_SERVICE_ENABLED__network_manager=enabled", "__VCAP_SERVICE_ENABLED__network_manager=disabled", ).replace( "__VCAP_SERVICE_ENABLED__networking=disabled", "__VCAP_SERVICE_ENABLED__networking=enabled", ).replace( "__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present", ).replace( "__VCAP_FILE__networkd_configs=absent", "__VCAP_FILE__networkd_configs=present", ) capabilities = parse_host_capabilities(output) assert capabilities["network"]["network_manager"] == "conflict" assert capabilities["network"]["network_manager_supported"] is False assert capabilities["vpc_ready"] is False assert capabilities["network"]["network_manager_evidence"][ "systemd_networkd_configured"] is True assert "network_manager_conflict" in capabilities["reasons"] def test_capability_probe_rejects_networkmanager_profile_with_debian_ifupdown(): output = CAPABILITY_OUTPUT.replace("ID=almalinux", "ID=debian").replace( 'NAME="AlmaLinux"', 'NAME="Debian GNU/Linux"', ).replace('VERSION_ID="10.0"', 'VERSION_ID="13"').replace( "__VCAP_TOOL__nmcli=/usr/bin/nmcli", "__VCAP_TOOL__nmcli=", ).replace( "__VCAP_TOOL__apt_get=", "__VCAP_TOOL__apt_get=/usr/bin/apt-get", ).replace( "__VCAP_TOOL__ifup=", "__VCAP_TOOL__ifup=/usr/sbin/ifup", ).replace( "__VCAP_TOOL__ifdown=", "__VCAP_TOOL__ifdown=/usr/sbin/ifdown", ).replace( "__VCAP_TOOL__ifquery=", "__VCAP_TOOL__ifquery=/usr/sbin/ifquery", ).replace( "__VCAP_SERVICE__network_manager=active", "__VCAP_SERVICE__network_manager=inactive", ).replace( "__VCAP_SERVICE_ENABLED__network_manager=enabled", "__VCAP_SERVICE_ENABLED__network_manager=disabled", ).replace( "__VCAP_SERVICE_ENABLED__networking=disabled", "__VCAP_SERVICE_ENABLED__networking=enabled", ).replace( "__VCAP_FILE__interfaces=absent", "__VCAP_FILE__interfaces=present", ).replace( "__VCAP_FILE__networkmanager_profiles=absent", "__VCAP_FILE__networkmanager_profiles=present", ) capabilities = parse_host_capabilities(output) assert capabilities["network"]["network_manager"] == "conflict" assert capabilities["network"]["network_manager_supported"] is False assert capabilities["vpc_ready"] is False assert capabilities["network"]["network_manager_evidence"][ "networkmanager_configured"] is True assert "network_manager_conflict" in capabilities["reasons"] def test_capability_probe_rejects_nonpersistent_networkmanager(): output = CAPABILITY_OUTPUT.replace( "__VCAP_SERVICE_ENABLED__network_manager=enabled", "__VCAP_SERVICE_ENABLED__network_manager=disabled", ) capabilities = parse_host_capabilities(output) assert capabilities["network"]["network_manager"] == "networkmanager" assert capabilities["wireguard"]["deployment_mode"] == "unsupported" assert capabilities["vpc_ready"] is False assert "networkmanager_service_not_enabled" in capabilities["reasons"] def test_rejects_unconfirmed_or_changed_host_key(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) with pytest.raises(RemoteHostError, match="确认"): manager.stage(make_profile(scanned), "") runner.key = host_key(b"b") with pytest.raises(RemoteHostError) as error: manager.stage(make_profile(scanned), scanned["fingerprint"]) assert error.value.status == 409 assert manager.current() is None def test_failed_test_preserves_old_connection_and_key_can_be_reused(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) first_scan = manager.scan("host.example", 2222) first = manager.stage(make_profile(first_scan), first_scan["fingerprint"]) manager.test(first) manager.commit(first) first_config = manager.ssh_user_config_path.resolve() next_scan = manager.scan("other.example", 2222) second = manager.stage( make_profile(next_scan, key="", host="other.example"), next_scan["fingerprint"], ) assert (second.path / "id_private").read_text() == PRIVATE_KEY runner.ssh_exit = 255 with pytest.raises(RemoteHostError) as error: manager.test(second) assert error.value.status == 502 with pytest.raises(RemoteHostError, match="测试"): manager.commit(second) assert manager.ssh_user_config_path.resolve() == first_config assert manager.current()["host"] == "host.example" manager.abort(second) assert not second.path.exists() def test_first_connection_needs_key_and_does_not_replace_existing_config(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) with pytest.raises(RemoteHostError, match="首次") as missing: manager.stage(make_profile(scanned, key=""), scanned["fingerprint"]) assert missing.value.error_code == "host_private_key_required" manager.ssh_user_config_path.parent.mkdir(mode=0o700, parents=True) manager.ssh_user_config_path.write_text("Host unrelated\n") staged = manager.stage(make_profile(scanned), scanned["fingerprint"]) manager.test(staged) with pytest.raises(RemoteHostError, match="已有其他 SSH 配置"): manager.commit(staged) assert manager.ssh_user_config_path.read_text() == "Host unrelated\n" assert manager.current() is None @pytest.mark.skipif(shutil.which("ssh") is None, reason="OpenSSH client unavailable") def test_openssh_reads_staged_nondefault_port_and_root_identity(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile(scanned), scanned["fingerprint"]) result = subprocess.run( ["ssh", "-G", "-F", staged.ssh_config_file, "vp-managed"], check=True, capture_output=True, text=True, timeout=8, ) options = dict(line.split(" ", 1) for line in result.stdout.splitlines() if " " in line) assert options["hostname"] == "host.example" assert options["port"] == "2222" assert options["user"] == "root" assert options["hostkeyalias"] == "vp-managed" assert options["stricthostkeychecking"] == "true" assert options["identityfile"] == str(staged.path / "id_private") assert options["userknownhostsfile"] == str(staged.path / "known_hosts") def test_staged_wrapper_passes_config_to_ssh_without_shell(tmp_path): runner = Runner() manager = RemoteHostManager( tmp_path / "service-home", ssh_binary="/bin/echo", runner=runner ) scanned = manager.scan("host.example", 2222) staged = manager.stage(make_profile(scanned), scanned["fingerprint"]) result = subprocess.run( [str(staged.path / "ssh-wrapper"), "-T", "root@vp-managed"], check=True, capture_output=True, text=True, timeout=8, ) assert result.stdout.strip() == f"-F {staged.ssh_config_file} -T root@vp-managed" def test_only_retired_generations_are_pruned(tmp_path): runner = Runner() manager = make_manager(tmp_path, runner) scanned = manager.scan("host.example", 2222) first = manager.stage(make_profile(scanned), scanned["fingerprint"]) manager.test(first) manager.commit(first) second = manager.stage(make_profile(scanned, key=""), scanned["fingerprint"]) # An uncommitted generation must not be deleted by background cleanup. assert manager.cleanup_inactive(grace_seconds=0) == 0 assert second.path.is_dir() manager.test(second) manager.commit(second) assert manager.cleanup_inactive(grace_seconds=60) == 0 assert first.path.is_dir() assert manager.cleanup_inactive(grace_seconds=0) == 1 assert not first.path.exists() assert second.path.is_dir() assert manager.current()["ssh_config_file"] == second.ssh_config_file def test_symlinked_parent_keeps_active_generation(tmp_path): # A lexical/canonical path mismatch must not classify the active # generation as retired. actual_parent = tmp_path / "private" / "virsh-panel" actual_parent.mkdir(parents=True) public_parent = tmp_path / "public-parent" public_parent.symlink_to(actual_parent, target_is_directory=True) runner = Runner() manager = RemoteHostManager(public_parent / "state", runner=runner) assert manager.data_dir == actual_parent / "state" scanned = manager.scan("host.example", 2222) first = manager.stage(make_profile(scanned), scanned["fingerprint"]) manager.test(first) manager.commit(first) assert manager.current()["ssh_config_file"] == first.ssh_config_file assert manager.cleanup_inactive(grace_seconds=0) == 0 assert first.path.is_dir() restarted = RemoteHostManager(public_parent / "state", runner=runner) assert restarted.current()["ssh_config_file"] == first.ssh_config_file assert restarted.cleanup_inactive(grace_seconds=0) == 0 assert first.path.is_dir() second = restarted.stage(make_profile(scanned, key=""), scanned["fingerprint"]) restarted.test(second) restarted.commit(second) assert restarted.cleanup_inactive(grace_seconds=0) == 1 assert not first.path.exists() assert second.path.is_dir() assert restarted.current()["ssh_config_file"] == second.ssh_config_file def test_rejects_symlink_as_final_data_directory(tmp_path): actual = tmp_path / "actual" actual.mkdir() alias = tmp_path / "alias" alias.symlink_to(actual, target_is_directory=True) with pytest.raises(RemoteHostError, match="符号链接"): RemoteHostManager(alias, runner=Runner()) @pytest.mark.parametrize("host,port", [ ("-oProxyCommand=bad", 22), ("host.example\nUser attacker", 22), ("example.com", 0), ("example.com", 65536), ("example.com", True), ]) def test_rejects_host_and_port_injection(tmp_path, host, port): runner = Runner() manager = make_manager(tmp_path, runner) with pytest.raises(RemoteHostError): manager.scan(host, port) assert runner.commands == []