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

446 lines
17 KiB
Python

"""SSH host configuration is pinned, private, and switched only after test."""
from __future__ import annotations
import base64
import hashlib
import itertools
import shutil
import stat
import struct
import subprocess
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",
) -> 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,
)
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 == []