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

681 lines
23 KiB
Go

package hypervisor
import (
"bytes"
"encoding/base64"
"encoding/binary"
"encoding/json"
"net/http"
"net/netip"
"strings"
"testing"
"time"
"git.luoli.live/root/virt/agent/cloudinit"
)
func validSSHKeyForTest() string {
keyBlob := make([]byte, 4+len("ssh-ed25519")+4+32)
binary.BigEndian.PutUint32(keyBlob[:4], uint32(len("ssh-ed25519")))
copy(keyBlob[4:], "ssh-ed25519")
offset := 4 + len("ssh-ed25519")
binary.BigEndian.PutUint32(keyBlob[offset:offset+4], 32)
for index := offset + 4; index < len(keyBlob); index++ {
keyBlob[index] = byte(index)
}
return "ssh-ed25519 " + base64.StdEncoding.EncodeToString(keyBlob) + " user@test"
}
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 backupRestoreSeedForTest(t *testing.T) []byte {
t.Helper()
image, err := cloudinit.BuildISO(cloudinit.Request{
UUID: "123e4567-e89b-42d3-a456-426614174001", Name: "vm-restored",
Hostname: "vm-restored.example.com", PreserveGuestCredentials: true,
Network: cloudinit.Network{
MAC: "52:54:00:12:34:57", PublicCIDR: "8.8.8.11/24",
Gateway: "8.8.8.1", DNSServers: []string{"1.1.1.1"},
InterfaceKey: "public0",
},
})
if err != nil {
t.Fatal(err)
}
return image
}
func TestBackupRestoreSeedAllowsExplicitFutureSettings(t *testing.T) {
hostname := "after-restore.example.com"
password := "ExplicitReset!456"
sshKey := validSSHKeyForTest()
tests := []struct {
name string
request SettingsRequest
}{
{name: "hostname", request: SettingsRequest{Hostname: &hostname}},
{name: "root password", request: SettingsRequest{RootPassword: &password}},
{name: "SSH public key", request: SettingsRequest{SSHPublicKey: &sshKey}},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if _, _, err := mutateSeedSettings(
backupRestoreSeedForTest(t), test.request,
"operation-restore-settings",
); err != nil {
t.Fatalf("backup-restored instance setting failed: %v", err)
}
})
}
}
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 TestSanitizeSeedForDiskAuthoritativeRecoveryKeepsOnlyNetworkIntent(t *testing.T) {
original := managedSeedForTest(t)
originalFiles, err := readSeedISO(original)
if err != nil {
t.Fatal(err)
}
sanitized, err := sanitizeSeedForDiskAuthoritativeRecovery(
original, "operation-recover-backup",
)
if err != nil {
t.Fatal(err)
}
files, err := readSeedISO(sanitized)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(files.NetworkConfig, originalFiles.NetworkConfig) {
t.Fatal("backup recovery changed the current network-config")
}
var userData map[string]any
if err := json.Unmarshal(bytes.TrimPrefix(
files.UserData, []byte("#cloud-config\n")), &userData); err != nil {
t.Fatal(err)
}
for _, forbidden := range []string{
"users", "chpasswd", "ssh_pwauth", "disable_root",
"write_files", "runcmd",
} {
if _, exists := userData[forbidden]; exists {
t.Fatalf("disk-authoritative recovery seed contains %q: %#v", forbidden, userData)
}
}
if userData["preserve_hostname"] != true {
t.Fatalf("preserve_hostname = %#v", userData["preserve_hostname"])
}
if bytes.Contains(files.UserData, []byte("echo once")) ||
bytes.Contains(files.UserData, []byte("hashed_passwd")) {
t.Fatalf("recovery seed retained guest identity or startup payload: %s", files.UserData)
}
var originalMetadata, metadata map[string]any
if err := json.Unmarshal(bytes.TrimSpace(originalFiles.MetaData), &originalMetadata); err != nil {
t.Fatal(err)
}
if err := json.Unmarshal(bytes.TrimSpace(files.MetaData), &metadata); err != nil {
t.Fatal(err)
}
if metadata["instance-id"] != originalMetadata["instance-id"] {
t.Fatalf("instance-id changed: old=%#v new=%#v",
originalMetadata["instance-id"], metadata["instance-id"])
}
if _, exists := metadata["local-hostname"]; exists {
t.Fatalf("recovery seed retained local-hostname: %#v", metadata)
}
if metadata["virt-cloud-backup-recovery-operation"] !=
"operation-recover-backup" {
t.Fatalf("backup recovery marker = %#v",
metadata["virt-cloud-backup-recovery-operation"])
}
}
func TestDiskAuthoritativeRecoveryPreservesCurrentVPCNetworkIntent(t *testing.T) {
port := validVPCPortMetadata()
attached, err := mutateSeedVPCPort(
managedSeedForTest(t), port, "operation-vpc-before-recovery", true,
)
if err != nil {
t.Fatal(err)
}
recovered, err := sanitizeSeedForDiskAuthoritativeRecovery(
attached, "operation-recover-vpc-backup",
)
if err != nil {
t.Fatal(err)
}
private, err := seedVPCPort(recovered)
if err != nil {
t.Fatal(err)
}
want := seedVPCNetwork{
MAC: port.MAC, PrivateIP: port.PrivateIP,
CIDR: port.CIDR, Gateway: port.Gateway,
}
if private == nil || *private != want {
t.Fatalf("recovered VPC network = %#v, want %#v", private, want)
}
publicMAC, publicCIDR, gateway, dns, err := seedNetwork(recovered)
if err != nil {
t.Fatal(err)
}
if publicMAC != "52:54:00:12:34:56" || publicCIDR != "8.8.8.10/24" ||
gateway != "8.8.8.1" || strings.Join(dns, ",") != "1.1.1.1" {
t.Fatalf("recovery changed public network: %q %q %q %v",
publicMAC, publicCIDR, gateway, dns)
}
}
func TestDiskAuthoritativeRecoverySeedAllowsExplicitFutureSettings(t *testing.T) {
sanitized, err := sanitizeSeedForDiskAuthoritativeRecovery(
managedSeedForTest(t), "operation-recover-backup",
)
if err != nil {
t.Fatal(err)
}
hostname := "after-recovery.example.com"
hostnameOnly, resultHostname, err := mutateSeedSettings(
sanitized, SettingsRequest{Hostname: &hostname}, "operation-hostname",
)
if err != nil {
t.Fatal(err)
}
if resultHostname != hostname {
t.Fatalf("hostname = %q", resultHostname)
}
hostnameFiles, err := readSeedISO(hostnameOnly)
if err != nil {
t.Fatal(err)
}
var hostnameData map[string]any
if err := json.Unmarshal(bytes.TrimPrefix(
hostnameFiles.UserData, []byte("#cloud-config\n")), &hostnameData); err != nil {
t.Fatal(err)
}
for _, forbidden := range []string{"users", "chpasswd", "ssh_pwauth"} {
if _, exists := hostnameData[forbidden]; exists {
t.Fatalf("hostname-only update injected %q: %#v", forbidden, hostnameData)
}
}
password := "ExplicitReset!456"
passwordReset, _, err := mutateSeedSettings(
sanitized, SettingsRequest{RootPassword: &password}, "operation-password",
)
if err != nil {
t.Fatal(err)
}
if bytes.Contains(passwordReset, []byte(password)) {
t.Fatal("explicit password reset stored the plaintext password")
}
passwordFiles, err := readSeedISO(passwordReset)
if err != nil {
t.Fatal(err)
}
var passwordData map[string]any
if err := json.Unmarshal(bytes.TrimPrefix(
passwordFiles.UserData, []byte("#cloud-config\n")), &passwordData); err != nil {
t.Fatal(err)
}
users, ok := passwordData["users"].([]any)
if !ok || len(users) != 1 || passwordData["chpasswd"] == nil {
t.Fatalf("explicit password reset did not create managed credentials: %#v", passwordData)
}
passwordAfterHostname, _, err := mutateSeedSettings(
hostnameOnly, SettingsRequest{RootPassword: &password},
"operation-password-after-hostname",
)
if err != nil {
t.Fatal(err)
}
passwordAfterHostnameFiles, err := readSeedISO(passwordAfterHostname)
if err != nil {
t.Fatal(err)
}
var passwordAfterHostnameData, passwordAfterHostnameMetadata map[string]any
if err := json.Unmarshal(bytes.TrimPrefix(
passwordAfterHostnameFiles.UserData, []byte("#cloud-config\n")),
&passwordAfterHostnameData); err != nil {
t.Fatal(err)
}
if err := json.Unmarshal(bytes.TrimSpace(
passwordAfterHostnameFiles.MetaData), &passwordAfterHostnameMetadata); err != nil {
t.Fatal(err)
}
if passwordAfterHostnameData["preserve_hostname"] != false {
t.Fatalf("password-only update did not retain the explicit hostname: %#v",
passwordAfterHostnameData)
}
if passwordAfterHostnameMetadata["local-hostname"] != hostname {
t.Fatalf("password-only update lost the explicit hostname: %#v",
passwordAfterHostnameMetadata)
}
hostnameAfterPassword, _, err := mutateSeedSettings(
passwordReset, SettingsRequest{Hostname: &hostname},
"operation-hostname-after-password",
)
if err != nil {
t.Fatal(err)
}
hostnameAfterPasswordFiles, err := readSeedISO(hostnameAfterPassword)
if err != nil {
t.Fatal(err)
}
var hostnameAfterPasswordData map[string]any
if err := json.Unmarshal(bytes.TrimPrefix(
hostnameAfterPasswordFiles.UserData, []byte("#cloud-config\n")),
&hostnameAfterPasswordData); err != nil {
t.Fatal(err)
}
users, ok = hostnameAfterPasswordData["users"].([]any)
if !ok || len(users) != 1 || hostnameAfterPasswordData["chpasswd"] == nil ||
hostnameAfterPasswordData["ssh_pwauth"] != true {
t.Fatalf("hostname-only update lost the explicit password intent: %#v",
hostnameAfterPasswordData)
}
}
func TestDiskAuthoritativeRecoverySSHKeyDoesNotChangePasswordState(t *testing.T) {
sanitized, err := sanitizeSeedForDiskAuthoritativeRecovery(
managedSeedForTest(t), "operation-recover-backup",
)
if err != nil {
t.Fatal(err)
}
key := validSSHKeyForTest()
updated, _, err := mutateSeedSettings(
sanitized, SettingsRequest{SSHPublicKey: &key}, "operation-ssh-key",
)
if err != nil {
t.Fatal(err)
}
files, err := readSeedISO(updated)
if err != nil {
t.Fatal(err)
}
var userData map[string]any
if err := json.Unmarshal(bytes.TrimPrefix(
files.UserData, []byte("#cloud-config\n")), &userData); err != nil {
t.Fatal(err)
}
for _, forbidden := range []string{
"users", "chpasswd", "ssh_pwauth", "disable_root",
} {
if _, exists := userData[forbidden]; exists {
t.Fatalf("SSH-key-only update changed password state through %q: %#v",
forbidden, userData)
}
}
if bytes.Contains(files.UserData, []byte("lock_passwd")) ||
bytes.Contains(files.UserData, []byte("hashed_passwd")) {
t.Fatalf("SSH-key-only update included password state: %s", files.UserData)
}
writeFiles, ok := userData["write_files"].([]any)
if !ok || len(writeFiles) != 1 {
t.Fatalf("SSH-key-only update write_files = %#v", userData["write_files"])
}
entry, ok := writeFiles[0].(map[string]any)
if !ok || entry["path"] != diskSSHAuthorizedKeysPath ||
entry["content"] != key+"\n" || entry["permissions"] != "0600" {
t.Fatalf("SSH-key-only update file = %#v", writeFiles[0])
}
if !bytes.Equal(files.NetworkConfig,
mustReadSeedFiles(t, sanitized).NetworkConfig) {
t.Fatal("SSH-key-only update changed network-config")
}
hostname := "after-key.example.com"
hostnameOnly, _, err := mutateSeedSettings(
updated, SettingsRequest{Hostname: &hostname}, "operation-hostname-after-key",
)
if err != nil {
t.Fatal(err)
}
hostnameFiles := mustReadSeedFiles(t, hostnameOnly)
if !bytes.Contains(hostnameFiles.UserData, []byte(diskSSHAuthorizedKeysPath)) ||
!bytes.Contains(hostnameFiles.UserData, []byte(key)) {
t.Fatalf("later hostname update lost the explicit SSH key intent: %s",
hostnameFiles.UserData)
}
}
func mustReadSeedFiles(t *testing.T, contents []byte) seedFiles {
t.Helper()
files, err := readSeedISO(contents)
if err != nil {
t.Fatal(err)
}
return files
}
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 TestMutateSeedVPCPortPreservesPublicNetworkAndBindsMarker(t *testing.T) {
original := managedSeedForTest(t)
port := validVPCPortMetadata()
attached, err := mutateSeedVPCPort(original, port, "operation-vpc-port-attach", true)
if err != nil {
t.Fatal(err)
}
publicMAC, publicCIDR, gateway, dns, err := seedNetwork(attached)
if err != nil {
t.Fatal(err)
}
if publicMAC != "52:54:00:12:34:56" || publicCIDR != "8.8.8.10/24" ||
gateway != "8.8.8.1" || strings.Join(dns, ",") != "1.1.1.1" {
t.Fatalf("public network changed: mac=%q cidr=%q gateway=%q dns=%v",
publicMAC, publicCIDR, gateway, dns)
}
private, err := seedVPCPort(attached)
if err != nil {
t.Fatal(err)
}
want := seedVPCNetwork{
MAC: port.MAC, PrivateIP: port.PrivateIP,
CIDR: port.CIDR, Gateway: port.Gateway,
}
if private == nil || *private != want {
t.Fatalf("private network = %#v, want %#v", private, want)
}
files := mustReadSeedFiles(t, attached)
var metadata map[string]any
if err := json.Unmarshal(bytes.TrimSpace(files.MetaData), &metadata); err != nil {
t.Fatal(err)
}
if metadata[vpcPortOperationMarker] != "operation-vpc-port-attach" {
t.Fatalf("VPC operation marker = %#v", metadata[vpcPortOperationMarker])
}
preserved, err := preservedVPCCloudInitNetwork(
attached, func() *domainVPCPortMetadataXML {
value := domainVPCPortFromPublic(port)
return &value
}(),
)
if err != nil {
t.Fatal(err)
}
if preserved == nil || preserved.MAC != port.MAC ||
preserved.PrivateIP != port.PrivateIP || preserved.CIDR != port.CIDR ||
preserved.Gateway != port.Gateway || preserved.InterfaceKey != seedVPCInterfaceKey {
t.Fatalf("preserved VPC network = %#v", preserved)
}
detached, err := mutateSeedVPCPort(attached, port, "operation-vpc-port-detach", false)
if err != nil {
t.Fatal(err)
}
if private, err := seedVPCPort(detached); err != nil || private != nil {
t.Fatalf("detached VPC network = %#v err=%v", private, err)
}
}
func TestRepairSeedVPCPortConvergesOnlyTheSameManagedIdentity(t *testing.T) {
port := validVPCPortMetadata()
original := managedSeedForTest(t)
attached, err := repairSeedVPCPort(
original, port, "operation-vpc-repair-attach", true,
)
if err != nil {
t.Fatal(err)
}
repaired, err := repairSeedVPCPort(
attached, port, "operation-vpc-repair-rebind", true,
)
if err != nil {
t.Fatal(err)
}
private, err := seedVPCPort(repaired)
want := seedVPCNetwork{
MAC: port.MAC, PrivateIP: port.PrivateIP,
CIDR: port.CIDR, Gateway: port.Gateway,
}
if err != nil || private == nil || *private != want {
t.Fatalf("repaired private network = %#v err=%v", private, err)
}
changed := port
changed.PrivateIP = "10.60.0.10"
if _, err := repairSeedVPCPort(
repaired, changed, "operation-vpc-repair-changed", true,
); err == nil {
t.Fatal("repair adopted a different VPC identity")
}
detached, err := repairSeedVPCPort(
repaired, port, "operation-vpc-repair-detach", false,
)
if err != nil {
t.Fatal(err)
}
if detached, err = repairSeedVPCPort(
detached, port, "operation-vpc-repair-detach-again", false,
); err != nil {
t.Fatalf("repair could not converge an already absent seed port: %v", err)
}
if private, err := seedVPCPort(detached); err != nil || private != nil {
t.Fatalf("repair detach left private network = %#v err=%v", private, err)
}
}
func TestPreservedVPCCloudInitNetworkRejectsCrossLayerMismatch(t *testing.T) {
port := validVPCPortMetadata()
attached, err := mutateSeedVPCPort(
managedSeedForTest(t), port, "operation-vpc-port-mismatch", true,
)
if err != nil {
t.Fatal(err)
}
if _, err := preservedVPCCloudInitNetwork(attached, nil); err == nil {
t.Fatal("seed-only VPC interface was accepted")
}
metadata := domainVPCPortFromPublic(port)
metadata.PrivateIP = "10.60.0.10"
if _, err := preservedVPCCloudInitNetwork(attached, &metadata); err == nil {
t.Fatal("mismatched seed and domain VPC identities were accepted")
}
}
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)
}
}