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.
222 lines
8.5 KiB
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)
|
|
}
|
|
}
|