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/tests/test_remote_host.py

511 lines
20 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 (
HostProfile,
RemoteHostError,
RemoteHostManager,
)
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"
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.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":
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",
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,
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="填写私钥口令"):
manager.stage(make_profile(scanned), scanned["fingerprint"])
with pytest.raises(RemoteHostError, match="口令错误"):
manager.stage(make_profile(scanned, passphrase="wrong"), scanned["fingerprint"])
assert not list((manager.data_dir / "generations").iterdir())
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_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)]
assert manager.test(stage) == {"ok": True, "ssh": "connected", "libvirt": "available"}
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_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="首次"):
manager.stage(make_profile(scanned, key=""), scanned["fingerprint"])
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 == []