You cannot select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
virt/engine/tests/test_remote_host.py

1150 lines
46 KiB
Python

"""SSH host configuration is pinned, private, and switched only after test."""
from __future__ import annotations
import base64
import hashlib
import itertools
import json
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_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=disabled
__VCAP_SERVICE_ENABLED__nftables=enabled
__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__bridges
[{{"ifname":"br0"}}]
__VCAP_IP_END__bridges=0
__VCAP_IP_BEGIN__wireguard
[]
__VCAP_IP_END__wireguard=0
__VCAP_NFT_BEGIN__
[{{"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
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 = "",
) -> 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,
)
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_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,
"nftables_active": True,
"nftables_enabled": True,
}
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["vpc_ready"] is False
assert "nftables_service_not_enabled" 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_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 "nftables_service_not_active" in capabilities["reasons"]
assert "ipv4_forwarding_disabled_or_unknown" in capabilities["reasons"]
assert capabilities["network_roles"]["private"]["separate_from_public"] is True
def test_capability_probe_rejects_firewalld_enabled_for_next_boot():
output = CAPABILITY_OUTPUT.replace(
"__VCAP_SERVICE_ENABLED__firewall=disabled",
"__VCAP_SERVICE_ENABLED__firewall=enabled",
)
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_owner_not_nftables" 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__",
)
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_requires_selected_bridge_rp_filter_evidence():
capabilities = parse_host_capabilities(
CAPABILITY_OUTPUT.replace("__VCAP_RPF__br0=2", ""),
public_network="bridge:br0",
)
assert capabilities["network_roles"]["public"]["verified"] is True
assert capabilities["private_ready"] is False
assert "rp_filter_not_compatible" 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_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 == []