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/agent/hypervisor/feature_helpers_test.go

222 lines
8.5 KiB
Go

package hypervisor
import (
"bytes"
"encoding/binary"
"encoding/json"
"net/http"
"net/netip"
"strings"
"testing"
"time"
"git.luoli.live/root/virt/agent/cloudinit"
)
func managedSeedForTest(t *testing.T) []byte {
t.Helper()
image, err := cloudinit.BuildISO(cloudinit.Request{
UUID: "123e4567-e89b-42d3-a456-426614174000", Name: "vm-test",
Hostname: "old.example.com", RootPassword: "StrongPassword!123",
StartupScript: "#!/bin/bash\necho once\n",
Network: cloudinit.Network{MAC: "52:54:00:12:34:56", PublicCIDR: "8.8.8.10/24", Gateway: "8.8.8.1", DNSServers: []string{"1.1.1.1"}, InterfaceKey: "public0"},
})
if err != nil {
t.Fatal(err)
}
return image
}
func TestMutateSeedSettingsPreservesStartupAndHashesNewPassword(t *testing.T) {
seed := managedSeedForTest(t)
originalFiles, err := readSeedISO(seed)
if err != nil {
t.Fatal(err)
}
var originalMetadata map[string]any
if err := json.Unmarshal(bytes.TrimSpace(originalFiles.MetaData), &originalMetadata); err != nil {
t.Fatal(err)
}
hostname := "new.example.com"
password := "AnotherStrong!456"
updated, resultHostname, err := mutateSeedSettings(seed, SettingsRequest{Hostname: &hostname, RootPassword: &password}, "operation-settings")
if err != nil {
t.Fatal(err)
}
if resultHostname != hostname || bytes.Contains(updated, []byte(password)) {
t.Fatalf("hostname=%q plaintext=%v", resultHostname, bytes.Contains(updated, []byte(password)))
}
files, err := readSeedISO(updated)
if err != nil {
t.Fatal(err)
}
if !bytes.Contains(files.UserData, []byte("echo once")) {
t.Fatal("settings update removed the immutable startup payload")
}
var metadata map[string]any
if err := json.Unmarshal(bytes.TrimSpace(files.MetaData), &metadata); err != nil {
t.Fatal(err)
}
if metadata["local-hostname"] != hostname {
t.Fatalf("local-hostname = %#v", metadata["local-hostname"])
}
instanceID, _ := metadata["instance-id"].(string)
if !strings.HasPrefix(instanceID, "virt-cloud-settings-") || instanceID == originalMetadata["instance-id"] {
t.Fatalf("settings instance-id was not rotated: old=%#v new=%#v", originalMetadata["instance-id"], instanceID)
}
if metadata["virt-cloud-network-policy"] != "boot-v1" {
t.Fatalf("network policy marker = %#v", metadata["virt-cloud-network-policy"])
}
if metadata["virt-cloud-settings-operation"] != "operation-settings" {
t.Fatalf("settings operation marker = %#v", metadata["virt-cloud-settings-operation"])
}
if !bytes.Equal(files.NetworkConfig, originalFiles.NetworkConfig) {
t.Fatal("settings update changed network-config")
}
}
func TestMutateSeedNetworkChangesOnlyAddressIntent(t *testing.T) {
updated, mac, err := mutateSeedNetwork(managedSeedForTest(t), "9.9.9.10/24", "9.9.9.1", []string{"1.1.1.1", "8.8.8.8"}, "operation-network")
if err != nil {
t.Fatal(err)
}
parsedMAC, cidr, gateway, dns, err := seedNetwork(updated)
if err != nil {
t.Fatal(err)
}
if mac != "52:54:00:12:34:56" || parsedMAC != mac || cidr != "9.9.9.10/24" || gateway != "9.9.9.1" || strings.Join(dns, ",") != "1.1.1.1,8.8.8.8" {
t.Fatalf("network = mac=%q parsed=%q cidr=%q gateway=%q dns=%v", mac, parsedMAC, cidr, gateway, dns)
}
files, err := readSeedISO(updated)
if err != nil {
t.Fatal(err)
}
var metadata map[string]any
if err := json.Unmarshal(bytes.TrimSpace(files.MetaData), &metadata); err != nil {
t.Fatal(err)
}
if metadata["virt-cloud-network-operation"] != "operation-network" {
t.Fatalf("network operation marker = %#v", metadata["virt-cloud-network-operation"])
}
}
func TestFirewallPolicyDigestAndXMLAreDeterministic(t *testing.T) {
policy := FirewallPolicy{Revision: 7, DefaultIn: "drop", DefaultOut: "accept", Rules: []FirewallRule{{Direction: "ingress", Action: "accept", Protocol: "tcp", CIDR: "8.8.8.0/24", PortFrom: 22, PortTo: 22}}}
validated, err := validateFirewallPolicy(policy)
if err != nil {
t.Fatal(err)
}
if len(validated.PolicyDigest) != 64 {
t.Fatalf("digest=%q", validated.PolicyDigest)
}
document, err := buildUserFirewallXML(`<filter name="virt-test" chain="root"><filterref filter="clean-traffic"/><rule action="accept" direction="inout" priority="900"><all/></rule></filter>`, validated)
if err != nil {
t.Fatal(err)
}
for _, expected := range []string{`comment="virt-user:0"`, `comment="virt-default:in"`, `comment="virt-default:out"`} {
if !strings.Contains(document, expected) {
t.Fatalf("firewall XML missing %s: %s", expected, document)
}
}
validated.PolicyDigest = strings.Repeat("0", 64)
if _, err := validateFirewallPolicy(validated); err == nil {
t.Fatal("mismatched firewall digest was accepted")
}
}
func TestRemoteImportAddressPolicyBlocksLocalNetworks(t *testing.T) {
for _, raw := range []string{
"127.0.0.1", "10.0.0.1", "169.254.1.1", "100.64.0.1",
"192.0.2.1", "198.18.0.1", "198.51.100.1", "203.0.113.1",
"240.0.0.1", "::1", "fc00::1", "64:ff9b::1", "100::1",
"2001:2::1", "2001:db8::1", "2002::1",
} {
if remoteAddressAllowed(netip.MustParseAddr(raw)) {
t.Fatalf("private address %s was allowed", raw)
}
}
if !remoteAddressAllowed(netip.MustParseAddr("8.8.8.8")) {
t.Fatal("public address was rejected")
}
client := remoteHTTPClient(true)
transport, ok := client.Transport.(*http.Transport)
if !ok || !transport.DisableCompression || transport.TLSHandshakeTimeout != 15*time.Second ||
transport.ResponseHeaderTimeout != 30*time.Second || transport.ExpectContinueTimeout != time.Second {
t.Fatal("remote import client transport bounds are incomplete")
}
client.CloseIdleConnections()
if _, err := validateRemoteSource("http://example.com/image.iso"); err == nil {
t.Fatal("plain HTTP source URL was accepted")
}
}
func TestValidateQCOW2HeaderAcceptsBoundedStandaloneV3Image(t *testing.T) {
header := make([]byte, qcow2HeaderBytes)
copy(header[:4], []byte{'Q', 'F', 'I', 0xfb})
binary.BigEndian.PutUint32(header[4:8], 3)
binary.BigEndian.PutUint32(header[20:24], 16)
binary.BigEndian.PutUint64(header[24:32], 40<<30)
binary.BigEndian.PutUint32(header[36:40], 5)
binary.BigEndian.PutUint64(header[40:48], 1<<16)
binary.BigEndian.PutUint64(header[48:56], 2<<16)
binary.BigEndian.PutUint32(header[56:60], 1)
binary.BigEndian.PutUint32(header[96:100], 4)
binary.BigEndian.PutUint32(header[100:104], qcow2HeaderBytes)
virtualSize, err := validateQCOW2Header(header)
if err != nil || virtualSize != 40<<30 {
t.Fatalf("valid QCOW2 header = size %d error %v", virtualSize, err)
}
withBacking := append([]byte(nil), header...)
binary.BigEndian.PutUint64(withBacking[8:16], 1<<16)
binary.BigEndian.PutUint32(withBacking[16:20], 12)
if _, err := validateQCOW2Header(withBacking); err == nil {
t.Fatal("QCOW2 backing file was accepted")
}
badMagic := append([]byte(nil), header...)
copy(badMagic[:4], "NOPE")
if _, err := validateQCOW2Header(badMagic); err == nil {
t.Fatal("non-QCOW2 image was accepted")
}
unsupported := append([]byte(nil), header...)
binary.BigEndian.PutUint64(unsupported[72:80], 1)
if _, err := validateQCOW2Header(unsupported); err == nil {
t.Fatal("QCOW2 incompatible feature was accepted")
}
}
func TestWireResultsExcludeAgentLocalPathsAndConsoleTargets(t *testing.T) {
localRoot := "/var/lib/libvirt/images/private-root.qcow2"
localLoader := "/usr/share/edk2/ovmf/OVMF_CODE.fd"
localNVRAM := "/var/lib/libvirt/qemu/nvram/private_VARS.fd"
payload := struct {
VM VMMetadata `json:"vm"`
Firmware Firmware `json:"firmware_definition"`
Console ConsoleSession `json:"console"`
Snapshot SnapshotMutationResult `json:"snapshot"`
}{
VM: VMMetadata{
UUID: "123e4567-e89b-42d3-a456-426614174000", Name: "vm-test",
Machine: "q35", Firmware: "uefi", Disks: []Disk{{Path: localRoot, Device: "disk", Format: "qcow2"}},
},
Firmware: Firmware{Mode: "uefi", Loader: localLoader, NVRAMTemplate: localLoader + ".vars", NVRAMPath: localNVRAM},
Console: ConsoleSession{Protocol: "vnc", Address: "127.0.0.1:5900"},
Snapshot: SnapshotMutationResult{SnapshotKey: "0123456789abcdef0123456789abcdef", Restored: true, ActiveVolumeName: "vrestore-private.qcow2"},
}
encoded, err := json.Marshal(payload)
if err != nil {
t.Fatal(err)
}
wire := string(encoded)
for _, forbidden := range []string{localRoot, localLoader, localNVRAM, "127.0.0.1:5900", "vrestore-private.qcow2", `"path"`, `"loader"`, `"nvram_template"`, `"nvram_path"`, `"address"`, `"active_volume_name"`} {
if strings.Contains(wire, forbidden) {
t.Fatalf("wire result leaked %q: %s", forbidden, wire)
}
}
if !strings.Contains(wire, `"device":"disk"`) || !strings.Contains(wire, `"protocol":"vnc"`) {
t.Fatalf("safe public fields were omitted: %s", wire)
}
}