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.
1894 lines
74 KiB
Python
1894 lines
74 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 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", "bridges"])
|
|
def test_capability_probe_rejects_empty_link_placeholders(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 == []
|