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.
207 lines
8.0 KiB
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])
|
|
}
|
|
}
|