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

578 lines
22 KiB
Python

"""Cloud-init public networking and NoCloud seed behavior."""
from __future__ import annotations
import importlib.util
import json
import uuid
import pytest
from virsh_panel.cloud_init import (
ROOT_PASSWORD_ALPHABET, ROOT_PASSWORD_DIGITS, ROOT_PASSWORD_LENGTH,
ROOT_PASSWORD_LOWERCASE, ROOT_PASSWORD_SYMBOLS, ROOT_PASSWORD_UPPERCASE,
_build_seed_iso, _enable_network_updates, build_seed_iso,
generate_root_password,
hash_root_password,
read_seed_network, replace_seed_network, replace_seed_settings,
validate_cloud_network, validate_guest_hostname, validate_private_network,
_parse_network_config,
)
PUBLIC_KEY = (
"ssh-ed25519 "
"AAAAC3NzaC1lZDI1NTE5AAAAIF7mFh4aYz3lRzNqjoFQasAQLpm7BdSULhe1iWuvj3y5 "
"panel-test"
)
GUEST_PASSWORD = "A-strong-guest-password-2026"
def _user_data(seed: bytes) -> dict:
"""Read the single-line JSON cloud-config embedded in the generated ISO."""
prefix = b"#cloud-config\n"
start = seed.index(prefix) + len(prefix)
return json.loads(seed[start:seed.index(b"\n", start)])
def _meta_data(seed: bytes) -> dict:
"""Read the single-line JSON meta-data embedded in the generated ISO."""
prefix = b'{"instance-id":'
start = seed.index(prefix)
return json.loads(seed[start:seed.index(b"\n", start)])
def _network_data(seed: bytes) -> dict:
"""Read the single-line JSON network-config embedded in the ISO."""
prefix = b'{"version": 2, "ethernets":'
start = seed.index(prefix)
return json.loads(seed[start:seed.index(b"\n", start)])
@pytest.mark.parametrize(
("address", "gateway"),
[
("8.8.8.18/24", "8.8.8.1"),
("8.8.8.18/28", "8.8.8.17"),
("123.123.123.114/24", "123.123.123.113"),
],
)
def test_public_network_accepts_24_and_28(address, gateway):
validated = validate_cloud_network(
address, gateway, ["1.1.1.1", "8.8.8.8"], PUBLIC_KEY,
)
assert validated == {
"public_ip_cidr": address,
"gateway": gateway,
"dns_servers": ["1.1.1.1", "8.8.8.8"],
"guest_ssh_public_key": PUBLIC_KEY,
}
def test_cloud_login_accepts_key_and_root_password_together():
network = ("8.8.8.18/24", "8.8.8.1", ["1.1.1.1"])
password_hash = hash_root_password(GUEST_PASSWORD)
assert password_hash.startswith("$6$")
assert GUEST_PASSWORD not in password_hash
assert hash_root_password(GUEST_PASSWORD) != password_hash
validated = validate_cloud_network(
*network, "", root_password_hash=password_hash,
)
assert validated["root_password_hash"] == password_hash
assert not validated["guest_ssh_public_key"]
together = validate_cloud_network(
*network, PUBLIC_KEY, root_password_hash=password_hash,
)
assert together["guest_ssh_public_key"] == PUBLIC_KEY
assert together["root_password_hash"] == password_hash
with pytest.raises(ValueError):
validate_cloud_network(*network, "", root_password_hash=None)
with pytest.raises(ValueError):
validate_cloud_network(*network, "", root_password_hash=GUEST_PASSWORD)
@pytest.mark.parametrize("invalid", [
"Short1!", "alllowercase12!", "ALLUPPERCASE12!", "NoSymbolPassword12",
"NoDigitsLong!Aa", "A-lowercase password12!", "A-lowercase\npassword12!",
"A-lowercase-password-1" + "x" * 110, "ValidAscii1!含中文",
])
def test_manual_root_password_requires_ascii_and_all_character_classes(invalid):
with pytest.raises(ValueError, match="初始 root 密码"):
hash_root_password(invalid)
@pytest.mark.parametrize("value", [
"node-1", "node.example.com", "A-Node.Example",
])
def test_guest_hostname_is_canonical_and_bounded(value):
assert validate_guest_hostname(value) == value.lower()
@pytest.mark.parametrize("value", [
"", ".node", "node.", "node..example", "-node", "node-",
"node_name", "node with spaces", "节点", "a" * 64,
])
def test_guest_hostname_rejects_unsafe_values(value):
with pytest.raises(ValueError):
validate_guest_hostname(value)
def test_generated_root_password_always_meets_policy():
assert ROOT_PASSWORD_ALPHABET == (
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
"0123456789!@#$%*-_=+?"
)
samples = set()
for _ in range(50):
password = generate_root_password()
samples.add(password)
assert len(password) == ROOT_PASSWORD_LENGTH
assert set(password) <= set(ROOT_PASSWORD_ALPHABET)
assert any(char in ROOT_PASSWORD_UPPERCASE for char in password)
assert any(char in ROOT_PASSWORD_LOWERCASE for char in password)
assert any(char in ROOT_PASSWORD_DIGITS for char in password)
assert any(char in ROOT_PASSWORD_SYMBOLS for char in password)
assert len(samples) == 50
assert len({password[:4] for password in samples}) > 1
assert hash_root_password(password).startswith("$6$")
def test_generated_root_password_rejects_whole_noncompliant_candidate(monkeypatch):
# First candidate is 32 uppercase A characters and must be discarded.
# The second one is a known compliant candidate with no post-processing.
indexes = iter([0] * 32 + [0, 26, 52, 62] * 8)
bounds = []
def deterministic_randbelow(bound):
bounds.append(bound)
return next(indexes)
monkeypatch.setattr("virsh_panel.cloud_init.secrets.randbelow",
deterministic_randbelow)
assert generate_root_password() == "Aa0!" * 8
assert bounds == [len(ROOT_PASSWORD_ALPHABET)] * 64
@pytest.mark.parametrize(
("address", "gateway"),
[
("192.168.1.18/24", "192.168.1.1"),
("10.0.0.18/24", "10.0.0.1"),
("172.16.0.18/24", "172.16.0.1"),
("127.0.0.18/24", "127.0.0.1"),
("169.254.0.18/24", "169.254.0.1"),
("224.0.0.18/24", "224.0.0.1"),
("2001:4860:4860::8888/64", "2001:4860:4860::1"),
("8.8.8.0/24", "8.8.8.1"),
("8.8.8.255/24", "8.8.8.1"),
("8.8.8.18/28", "8.8.8.1"),
("8.8.8.18", "8.8.8.1"),
],
)
def test_public_network_rejects_nonpublic_or_unroutable_pairs(address, gateway):
with pytest.raises(ValueError):
validate_cloud_network(address, gateway, ["1.1.1.1"], PUBLIC_KEY)
@pytest.mark.parametrize(
("dns", "key"),
[
(["not-an-ip"], PUBLIC_KEY),
(["192.168.1.1"], PUBLIC_KEY),
([], PUBLIC_KEY),
(["1.1.1.1"], "not-an-ssh-key"),
(["1.1.1.1"], PUBLIC_KEY + "\nruncmd: [evil]"),
],
)
def test_public_network_rejects_bad_dns_and_ssh_key(dns, key):
with pytest.raises(ValueError):
validate_cloud_network("8.8.8.18/24", "8.8.8.1", dns, key)
def test_private_network_is_an_explicit_static_role_without_a_default_route():
assert validate_private_network("10.24.3.7/32") == {
"private_ip_cidr": "10.24.3.7/32",
}
config = {
"version": 2,
"ethernets": {
"public0": {
"match": {"macaddress": "52:54:00:12:34:56"},
"dhcp4": False,
"dhcp6": False,
"addresses": ["8.8.8.18/28"],
"routes": [{"to": "0.0.0.0/0", "via": "8.8.8.17"}],
"nameservers": {"addresses": ["1.1.1.1"]},
},
"private0": {
"match": {"macaddress": "52:54:00:12:34:57"},
"dhcp4": False,
"dhcp6": False,
"accept-ra": False,
"addresses": ["10.24.3.7/32"],
},
},
}
parsed = _parse_network_config(config)
assert parsed["roles"] == ["public0", "private0"]
assert parsed["private_ip_cidr"] == "10.24.3.7/32"
with pytest.raises(ValueError, match="无默认路由"):
_parse_network_config({
**config,
"ethernets": {
**config["ethernets"],
"private0": {
**config["ethernets"]["private0"],
"routes": [{"to": "0.0.0.0/0", "via": "10.24.3.1"}],
},
},
})
@pytest.mark.parametrize("value", [
"10.24.3.7/31", "127.0.0.1/32", "169.254.1.1/32",
"192.0.2.1/32", "2001:db8::1/128",
])
def test_private_network_rejects_non_rfc1918_guest_endpoints(value):
with pytest.raises(ValueError):
validate_private_network(value)
@pytest.mark.skipif(importlib.util.find_spec("pycdlib") is None,
reason="pycdlib is not installed")
def test_seed_iso_can_add_private_role_without_public_route_or_dns():
validated = validate_cloud_network(
"8.8.8.18/28", "8.8.8.17", ["1.1.1.1"], PUBLIC_KEY,
)
seed = build_seed_iso(
str(uuid.uuid4()), "multi-nic-vm", "52:54:00:12:34:56", validated,
private_mac="52:54:00:12:34:57",
private_network={"private_ip_cidr": "10.24.3.7/32"},
)
network = _network_data(seed)
assert set(network["ethernets"]) == {"public0", "private0"}
assert network["ethernets"]["private0"] == {
"match": {"macaddress": "52:54:00:12:34:57"},
"dhcp4": False,
"dhcp6": False,
"accept-ra": False,
"addresses": ["10.24.3.7/32"],
}
assert read_seed_network(seed) == {
"public_ip_cidr": "8.8.8.18/28",
"gateway": "8.8.8.17",
"dns_servers": ["1.1.1.1"],
"mac": "52:54:00:12:34:56",
"private_ip_cidr": "10.24.3.7/32",
"private_mac": "52:54:00:12:34:57",
"roles": ["public0", "private0"],
}
@pytest.mark.skipif(importlib.util.find_spec("pycdlib") is None,
reason="pycdlib is not installed")
def test_seed_iso_has_nocloud_files_and_mac_specific_static_network():
vm_uuid = str(uuid.uuid4())
mac = "52:54:00:12:34:56"
validated = validate_cloud_network(
"8.8.8.18/28", "8.8.8.17", ["1.1.1.1"], PUBLIC_KEY,
)
seed = build_seed_iso(vm_uuid, "cloud-vm", mac, validated)
assert isinstance(seed, bytes)
assert seed[32769:32774] == b"CD001" # ISO-9660 primary volume descriptor
assert b"CIDATA" in seed
for marker in (
b"user-data", b"meta-data", b"network-config", b"8.8.8.18/28",
b"8.8.8.17", b"1.1.1.1", mac.encode(), PUBLIC_KEY.encode(),
):
assert marker in seed
assert b'"routes": [{"to": "0.0.0.0/0", "via": "8.8.8.17"}]' in seed
assert b'"to": "default"' not in seed
assert b'"renderer": "networkd"' not in seed
assert b'"set-name"' not in seed
assert b"IPv6AcceptRA=no" not in seed
assert b"systemd-machine-id-setup" not in seed
user_data = _user_data(seed)
metadata = _meta_data(seed)
assert user_data["disable_root"] is False
assert user_data["ssh_pwauth"] is False
assert user_data["updates"] == {"network": {"when": ["boot"]}}
assert metadata["virt-cloud-network-policy"] == "boot-v1"
assert user_data["users"][0]["name"] == "root"
assert user_data["users"][0]["ssh_authorized_keys"] == [PUBLIC_KEY]
assert "hashed_passwd" not in user_data["users"][0]
assert "passwd" not in user_data["users"][0]
sshd_dropin = user_data["write_files"][0]
assert sshd_dropin["path"] == "/etc/ssh/sshd_config.d/00-virsh-panel-root.conf"
assert "PermitRootLogin prohibit-password" in sshd_dropin["content"]
assert "PasswordAuthentication no" in sshd_dropin["content"]
assert "runcmd" not in user_data
assert "bootcmd" not in user_data
assert "dsmode" not in metadata
assert all(
item["path"] != "/etc/systemd/network/05-virt-cloud-public.network"
for item in user_data["write_files"]
)
assert b"almalinux" not in seed
assert read_seed_network(seed) == {
"public_ip_cidr": "8.8.8.18/28",
"gateway": "8.8.8.17",
"dns_servers": ["1.1.1.1"],
"mac": mac,
}
def test_enable_network_updates_upgrades_legacy_panel_user_data():
legacy = b'#cloud-config\n{"users": [{"name": "root"}]}\n'
upgraded = _enable_network_updates(legacy)
assert upgraded.startswith(b"#cloud-config\n")
payload = json.loads(upgraded.split(b"\n", 1)[1])
assert payload["users"] == [{"name": "root"}]
assert payload["updates"] == {"network": {"when": ["boot"]}}
assert _enable_network_updates(upgraded) == upgraded
@pytest.mark.skipif(importlib.util.find_spec("pycdlib") is None,
reason="pycdlib is not installed")
def test_debian12_network_fix_uses_standard_nocloud_network_config():
mac = "52:54:00:12:34:56"
validated = validate_cloud_network(
"8.8.8.18/28", "8.8.8.17", ["1.1.1.1", "8.8.8.8"], PUBLIC_KEY,
)
seed = build_seed_iso(
str(uuid.uuid4()), "debian-12-vm", mac, validated,
debian12_network_fix=True,
)
user_data = _user_data(seed)
metadata = _meta_data(seed)
network_data = _network_data(seed)
assert network_data == {
"version": 2,
"ethernets": {
"public0": {
"match": {"macaddress": mac},
"dhcp4": False,
"dhcp6": False,
"addresses": ["8.8.8.18/28"],
"routes": [{"to": "0.0.0.0/0", "via": "8.8.8.17"}],
"nameservers": {"addresses": ["1.1.1.1", "8.8.8.8"]},
"accept-ra": False,
},
},
"renderer": "networkd",
}
assert metadata["dsmode"] == "local"
bootcmd = user_data["bootcmd"]
assert bootcmd[0][:2] == ["/bin/sh", "-ec"]
queue_networkd = bootcmd[0][2]
assert queue_networkd.splitlines() == [
"systemd-machine-id-setup",
"netplan generate",
"systemctl unmask systemd-networkd.service",
"systemctl enable systemd-networkd.service",
"systemctl start --no-block systemd-networkd.service",
]
assert "ip address" not in queue_networkd
assert "ip route" not in queue_networkd
assert "restart" not in json.dumps(bootcmd)
assert "--now" not in json.dumps(bootcmd)
assert "runcmd" not in user_data
assert b'"set-name"' not in seed
assert b"enp1s0" not in seed
assert all(
not item["path"].startswith("/etc/systemd/network/")
for item in user_data["write_files"]
)
assert read_seed_network(seed) == {
"public_ip_cidr": "8.8.8.18/28",
"gateway": "8.8.8.17",
"dns_servers": ["1.1.1.1", "8.8.8.8"],
"mac": mac,
}
@pytest.mark.parametrize("invalid", [None, 0, 1, "networkd"])
def test_seed_rejects_invalid_debian12_network_fix_option(invalid):
validated = validate_cloud_network(
"8.8.8.18/28", "8.8.8.17", ["1.1.1.1"], PUBLIC_KEY,
)
with pytest.raises(ValueError, match="Debian 12 网络修复选项"):
build_seed_iso(
str(uuid.uuid4()), "cloud-vm", "52:54:00:12:34:56", validated,
debian12_network_fix=invalid,
)
@pytest.mark.skipif(importlib.util.find_spec("pycdlib") is None,
reason="pycdlib is not installed")
def test_read_seed_network_rejects_invalid_iso_without_exposing_credentials():
with pytest.raises(ValueError):
read_seed_network(b"not an ISO")
with pytest.raises(ValueError):
read_seed_network(b"x" * (1024 * 1024 + 1))
@pytest.mark.skipif(importlib.util.find_spec("pycdlib") is None,
reason="pycdlib is not installed")
def test_password_seed_sets_root_hash_and_enables_ssh_password_login():
password_hash = hash_root_password(GUEST_PASSWORD)
validated = validate_cloud_network(
"8.8.8.18/28", "8.8.8.17", ["1.1.1.1"], "",
root_password_hash=password_hash,
)
seed = build_seed_iso(
str(uuid.uuid4()), "password-vm", "52:54:00:12:34:56", validated,
)
user_data = _user_data(seed)
assert user_data["disable_root"] is False
assert user_data["ssh_pwauth"] is True
assert user_data["users"][0]["name"] == "root"
assert user_data["users"][0]["lock_passwd"] is False
assert user_data["users"][0]["hashed_passwd"] == password_hash
assert "ssh_authorized_keys" not in user_data["users"][0]
assert user_data["chpasswd"] == {
"expire": False,
"users": [{"name": "root", "password": password_hash, "type": "hash"}],
}
sshd_dropin = user_data["write_files"][0]
assert sshd_dropin["path"] == "/etc/ssh/sshd_config.d/00-virsh-panel-root.conf"
assert "PermitRootLogin yes" in sshd_dropin["content"]
assert "PasswordAuthentication yes" in sshd_dropin["content"]
assert GUEST_PASSWORD.encode() not in seed
@pytest.mark.skipif(importlib.util.find_spec("pycdlib") is None,
reason="pycdlib is not installed")
def test_seed_allows_root_password_and_ssh_key_together():
password_hash = hash_root_password(GUEST_PASSWORD)
validated = validate_cloud_network(
"8.8.8.18/28", "8.8.8.17", ["1.1.1.1"], PUBLIC_KEY,
root_password_hash=password_hash,
)
seed = build_seed_iso(
str(uuid.uuid4()), "both-vm", "52:54:00:12:34:56", validated,
)
user_data = _user_data(seed)
root = user_data["users"][0]
assert root["name"] == "root"
assert root["lock_passwd"] is False
assert root["ssh_authorized_keys"] == [PUBLIC_KEY]
assert root["hashed_passwd"] == password_hash
assert user_data["ssh_pwauth"] is True
assert user_data["chpasswd"]["users"][0]["password"] == password_hash
assert "PermitRootLogin yes" in user_data["write_files"][0]["content"]
assert "PasswordAuthentication yes" in user_data["write_files"][0]["content"]
assert GUEST_PASSWORD.encode() not in seed
@pytest.mark.skipif(importlib.util.find_spec("pycdlib") is None,
reason="pycdlib is not installed")
def test_replace_seed_network_preserves_user_data_and_metadata():
password_hash = hash_root_password(GUEST_PASSWORD)
validated = validate_cloud_network(
"8.8.8.18/28", "8.8.8.17", ["1.1.1.1"], PUBLIC_KEY,
root_password_hash=password_hash,
)
seed = build_seed_iso(
str(uuid.uuid4()), "network-change-vm", "52:54:00:12:34:56", validated,
)
import pycdlib
from io import BytesIO
def file_bytes(image: bytes, path: str) -> bytes:
iso = pycdlib.PyCdlib()
iso.open_fp(BytesIO(image))
output = BytesIO()
iso.get_file_from_iso_fp(output, rr_path=path)
iso.close()
return output.getvalue()
user_data = file_bytes(seed, "/user-data")
metadata = file_bytes(seed, "/meta-data")
original_metadata = json.loads(metadata)
changed = replace_seed_network(
seed, "8.8.8.19/28", "8.8.8.17", ["8.8.8.8"],
)
assert file_bytes(changed, "/user-data") == user_data
changed_metadata = json.loads(file_bytes(changed, "/meta-data"))
assert changed_metadata["instance-id"] == original_metadata["instance-id"]
assert changed_metadata["local-hostname"] == original_metadata["local-hostname"]
assert changed_metadata["virt-cloud-network-policy"] == "boot-v1"
assert read_seed_network(changed) == {
"public_ip_cidr": "8.8.8.19/28",
"gateway": "8.8.8.17",
"dns_servers": ["8.8.8.8"],
"mac": "52:54:00:12:34:56",
}
# A seed created before the network-refresh policy has no marker and must
# rotate its NoCloud generation once so cloud-init reloads the new files.
legacy_user_data = b'#cloud-config\n{"users": [{"name": "root"}]}\n'
legacy_metadata = json.dumps({
"instance-id": original_metadata["instance-id"],
"local-hostname": original_metadata["local-hostname"],
}).encode("ascii") + b"\n"
legacy_network = file_bytes(seed, "/network-config")
legacy_seed = _build_seed_iso((
("/USERDATA.;1", "user-data", "/user-data", legacy_user_data),
("/METADATA.;1", "meta-data", "/meta-data", legacy_metadata),
("/NETWORK.;1", "network-config", "/network-config", legacy_network),
))
migrated = replace_seed_network(
legacy_seed, "8.8.8.19/28", "8.8.8.17", ["8.8.8.8"],
)
migrated_metadata = json.loads(file_bytes(migrated, "/meta-data"))
assert migrated_metadata["instance-id"] != original_metadata["instance-id"]
assert migrated_metadata["instance-id"].startswith("virt-cloud-network-")
migrated_user_data = file_bytes(migrated, "/user-data")
assert json.loads(migrated_user_data.split(b"\n", 1)[1])["updates"] == {
"network": {"when": ["boot"]}
}
@pytest.mark.skipif(importlib.util.find_spec("pycdlib") is None,
reason="pycdlib is not installed")
def test_replace_seed_network_rejects_non_panel_seed():
with pytest.raises(ValueError, match="无法读取原 cloud-init 配置盘"):
replace_seed_network(
b"not-an-iso", "8.8.8.19/28", "8.8.8.17", ["8.8.8.8"],
)
@pytest.mark.skipif(importlib.util.find_spec("pycdlib") is None,
reason="pycdlib is not installed")
def test_replace_seed_settings_rotates_generation_without_exposing_password():
password_hash = hash_root_password(GUEST_PASSWORD)
validated = validate_cloud_network(
"8.8.8.18/28", "8.8.8.17", ["1.1.1.1"], PUBLIC_KEY,
root_password_hash=password_hash,
)
seed = build_seed_iso(
str(uuid.uuid4()), "settings-vm", "52:54:00:12:34:56", validated,
)
changed = replace_seed_settings(
seed, hostname="Node.Example", root_password_hash=hash_root_password(
"Another-strong-password-2026!"
), ssh_public_key=PUBLIC_KEY,
)
user_data = _user_data(changed)
root = user_data["users"][0]
assert root["ssh_authorized_keys"] == [PUBLIC_KEY]
assert root["lock_passwd"] is False
assert root["hashed_passwd"].startswith("$6$")
assert GUEST_PASSWORD.encode() not in changed
assert b"Another-strong-password-2026!" not in changed
assert user_data["ssh_pwauth"] is True
assert user_data["chpasswd"]["users"][0]["type"] == "hash"
assert _meta_data(changed)["local-hostname"] == "node.example"
assert _meta_data(changed)["instance-id"].startswith("virt-cloud-settings-")
assert read_seed_network(changed) == read_seed_network(seed)