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/internal/hypervisor/capabilities_xml_test.go

207 lines
8.0 KiB
Go

package hypervisor
import (
"errors"
"strings"
"testing"
)
const domCapabilitiesWithBothLoaders = `<?xml version="1.0"?>
<domainCapabilities>
<path>/usr/bin/qemu-system-x86_64</path>
<domain>kvm</domain>
<machine maxCpus="255">pc-q35-10.0</machine>
<machine maxCpus="255">pc-i440fx-10.0</machine>
<arch>x86_64</arch>
<os supported="yes">
<enum name="firmware"><value>bios</value><value>efi</value></enum>
<loader supported="yes"><value>/usr/share/OVMF/OVMF_CODE.fd</value></loader>
<loader supported="yes" secure="yes"><value>/usr/share/OVMF/OVMF_CODE.secboot.fd</value></loader>
</os>
</domainCapabilities>`
func TestParseCapabilitySnapshotXMLUsesNonSecureLoader(t *testing.T) {
snapshot, err := ParseCapabilitySnapshotXML([]byte(domCapabilitiesWithBothLoaders))
if err != nil {
t.Fatalf("ParseCapabilitySnapshotXML() error = %v", err)
}
if !snapshot.UEFI || !snapshot.Q35 || !snapshot.SecureBootDisabled || !snapshot.SecureBootCapable {
t.Fatalf("unexpected capability snapshot: %+v", snapshot)
}
if snapshot.Architecture != "x86_64" {
t.Fatalf("snapshot architecture = %q", snapshot.Architecture)
}
}
func TestParseDomainCapabilitiesXMLClassifiesLoaderSecurity(t *testing.T) {
caps, err := ParseDomainCapabilitiesXML([]byte(domCapabilitiesWithBothLoaders))
if err != nil {
t.Fatalf("ParseDomainCapabilitiesXML() error = %v", err)
}
if len(caps.Loaders) != 2 {
t.Fatalf("got %d loaders, want 2: %+v", len(caps.Loaders), caps.Loaders)
}
if caps.Loaders[0].Secure != "no" || caps.Loaders[1].Secure != "yes" {
t.Fatalf("loader security classification = %+v", caps.Loaders)
}
if err := caps.ValidatePolicy(); err != nil {
t.Fatalf("ValidatePolicy() error = %v", err)
}
if !caps.SupportsMachine("q35") || !caps.SupportsMachine("pc-q35-10.0") || caps.SupportsMachine("pc-q35-9.0") {
t.Fatalf("machine capability matching is not exact enough: %+v", caps.Machines)
}
paths := caps.NonSecureLoaderPaths()
if len(paths) != 1 || !strings.Contains(paths[0], "OVMF_CODE.fd") || strings.Contains(paths[0], "secboot") {
t.Fatalf("non-secure loader paths = %+v", paths)
}
}
func TestPreferredNonSecureLoaderPathPrefersPlainOVMF(t *testing.T) {
caps, err := ParseDomainCapabilitiesXML([]byte(domCapabilitiesWithBothLoaders))
if err != nil {
t.Fatal(err)
}
path, err := caps.PreferredNonSecureLoaderPath()
if err != nil {
t.Fatal(err)
}
if path != "/usr/share/OVMF/OVMF_CODE.fd" {
t.Fatalf("preferred loader = %q, want ordinary OVMF path", path)
}
}
func TestSupportsMachineDoesNotInventVersion(t *testing.T) {
caps, err := ParseDomainCapabilitiesXML([]byte(domCapabilitiesWithBothLoaders))
if err != nil {
t.Fatal(err)
}
if !caps.SupportsMachine("q35") || !caps.SupportsMachine("pc-q35-10.0") {
t.Fatal("advertised Q35 machines were rejected")
}
if caps.SupportsMachine("pc-q35-99.0") {
t.Fatal("unadvertised versioned Q35 machine was accepted")
}
}
func TestParseDomainCapabilitiesXMLReadsSecureEnumUnderLoader(t *testing.T) {
input := `
<domainCapabilities>
<machine>pc-q35-10.0</machine>
<arch name="x86_64"/>
<os supported="yes">
<enum name="firmware"><value>efi</value></enum>
<loader supported="yes">
<value>/usr/share/OVMF/OVMF_CODE_4M.fd</value>
<value>/usr/share/OVMF/OVMF_CODE_4M.secboot.fd</value>
<enum name="secure"><value>yes</value><value>no</value></enum>
</loader>
</os>
</domainCapabilities>
`
caps, err := ParseDomainCapabilitiesXML([]byte(input))
if err != nil {
t.Fatalf("ParseDomainCapabilitiesXML() error = %v", err)
}
if len(caps.Loaders) != 2 || caps.Loaders[0].Secure != "no" || caps.Loaders[1].Secure != "yes" {
t.Fatalf("unexpected loader classification: %+v", caps.Loaders)
}
if err := caps.ValidatePolicy(); err != nil {
t.Fatalf("ValidatePolicy() error = %v", err)
}
}
func TestParseCapabilitySnapshotXMLRejectsSecureOnlyHost(t *testing.T) {
input := strings.Replace(domCapabilitiesWithBothLoaders,
`<loader supported="yes"><value>/usr/share/OVMF/OVMF_CODE.fd</value></loader>`,
`<loader supported="yes" secure="yes"><value>/usr/share/OVMF/OVMF_CODE.secboot.fd</value></loader>`, 1)
if _, err := ParseCapabilitySnapshotXML([]byte(input)); !errors.Is(err, ErrNoNonSecureLoader) {
t.Fatalf("error = %v, want ErrNoNonSecureLoader", err)
}
}
func TestParseDomainCapabilitiesXMLRejectsAmbiguousOrConflictingLoader(t *testing.T) {
tests := map[string]string{
"unknown secure attribute": strings.Replace(domCapabilitiesWithBothLoaders, `secure="yes"`, `secure="maybe"`, 1),
"secure no secboot path": strings.Replace(domCapabilitiesWithBothLoaders, `secure="yes"`, `secure="no"`, 1),
"unsupported loader": strings.Replace(domCapabilitiesWithBothLoaders, `supported="yes" secure="yes"`, `supported="no" secure="maybe"`, 1),
}
for name, input := range tests {
t.Run(name, func(t *testing.T) {
_, err := ParseDomainCapabilitiesXML([]byte(input))
if name == "unsupported loader" {
// Unsupported descriptors are ignored, so the ordinary loader
// still provides a valid no-secboot policy.
if err != nil {
t.Fatalf("unsupported loader should be ignored, got %v", err)
}
return
}
if err == nil {
t.Fatal("expected parser to reject loader policy")
}
if name == "unknown secure attribute" && !errors.Is(err, ErrInvalidCapabilitiesXML) {
t.Fatalf("error = %v, want ErrInvalidCapabilitiesXML", err)
}
if name == "secure no secboot path" && !errors.Is(err, ErrCapabilityPolicy) {
t.Fatalf("error = %v, want ErrCapabilityPolicy", err)
}
})
}
}
func TestParseDomainCapabilitiesXMLRejectsMissingHostProof(t *testing.T) {
tests := map[string]string{
"wrong root": `<capabilities><arch>x86_64</arch></capabilities>`,
"wrong architecture": strings.Replace(domCapabilitiesWithBothLoaders, `<arch>x86_64</arch>`, `<arch>aarch64</arch>`, 1),
"no efi": strings.Replace(domCapabilitiesWithBothLoaders, `<value>efi</value>`, `<value>pflash</value>`, 1),
"no q35": strings.Replace(domCapabilitiesWithBothLoaders, `<machine maxCpus="255">pc-q35-10.0</machine>`, `<machine maxCpus="255">pc-i440fx-10.0</machine>`, 1),
"os unsupported": strings.Replace(domCapabilitiesWithBothLoaders, `<os supported="yes">`, `<os supported="no">`, 1),
}
for name, input := range tests {
t.Run(name, func(t *testing.T) {
_, err := ParseCapabilitySnapshotXML([]byte(input))
if err == nil {
t.Fatal("expected capability parse/policy failure")
}
})
}
}
func TestDomainCapabilitiesRejectsEmptyVersionedQ35Machine(t *testing.T) {
input := strings.Replace(domCapabilitiesWithBothLoaders,
`pc-q35-10.0`, `pc-q35-`, 1)
caps, err := ParseDomainCapabilitiesXML([]byte(input))
if err != nil {
t.Fatal(err)
}
if err := caps.ValidatePolicy(); !errors.Is(err, ErrCapabilityPolicy) {
t.Fatalf("ValidatePolicy() error = %v, want ErrCapabilityPolicy", err)
}
}
func TestParseDomainCapabilitiesXMLRejectsTrailingAndOversizedInput(t *testing.T) {
if _, err := ParseDomainCapabilitiesXML([]byte(domCapabilitiesWithBothLoaders + "\n \n")); err != nil {
t.Fatalf("trailing whitespace should be accepted: %v", err)
}
if _, err := ParseDomainCapabilitiesXML([]byte(domCapabilitiesWithBothLoaders + `<extra/>`)); !errors.Is(err, ErrInvalidCapabilitiesXML) {
t.Fatalf("trailing XML error = %v, want ErrInvalidCapabilitiesXML", err)
}
oversized := strings.Repeat("x", maxDomainCapabilitiesXMLBytes+1)
if _, err := ParseDomainCapabilitiesXML([]byte(oversized)); !errors.Is(err, ErrInvalidCapabilitiesXML) {
t.Fatalf("oversized XML error = %v, want ErrInvalidCapabilitiesXML", err)
}
}
func TestParseDomainCapabilitiesXMLInfersSecureMarker(t *testing.T) {
input := strings.Replace(domCapabilitiesWithBothLoaders,
`<loader supported="yes"><value>/usr/share/OVMF/OVMF_CODE.fd</value></loader>`,
`<loader supported="yes"><value>/usr/share/OVMF/OVMF_CODE.secboot.fd</value></loader>`, 1)
caps, err := ParseDomainCapabilitiesXML([]byte(input))
if err != nil {
t.Fatal(err)
}
if caps.Loaders[0].Secure != "yes" {
t.Fatalf("secboot path was not classified as secure: %+v", caps.Loaders[0])
}
}