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/domaincreatevalidate/validate_test.go

320 lines
11 KiB
Go

package domaincreatevalidate
import (
"bytes"
"context"
"encoding/json"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"g.luoli.live/root/virt/agent/internal/domaincreateplan"
"g.luoli.live/root/virt/agent/internal/domainpreflight"
"g.luoli.live/root/virt/agent/internal/startup"
)
const (
validateDomainUUID = "00000000-0000-4000-8000-000000001101"
validateArtifactUUID = "00000000-0000-4000-8000-000000001102"
)
func validPayload(t *testing.T, root string) domaincreateplan.JournalPayload {
t.Helper()
readonly := true
secureBoot := false
request := domaincreateplan.Request{
Domain: domainpreflight.Request{
UUID: validateDomainUUID,
Firmware: domainpreflight.FirmwareEFI,
Architecture: domainpreflight.ArchitectureX86,
Machine: domainpreflight.MachineQ35,
OSType: domainpreflight.OSTypeHVM,
Loader: domainpreflight.LoaderPolicy{Type: domainpreflight.LoaderPFlash, Readonly: &readonly, SecureBoot: &secureBoot},
},
Seed: domaincreateplan.SeedRequest{
ArtifactID: validateArtifactUUID,
InstanceID: "instance-validate-1101",
Hostname: "vm-validate-1101",
NetworkConfig: `{"version":2,"ethernets":{}}`,
StartupScript: "#!/bin/sh\necho validate-secret\n",
},
}
payload, err := domaincreateplan.PrepareJournal(request)
if err != nil {
t.Fatal(err)
}
files, err := startup.BuildCreateSeed(request.Seed.InstanceID, request.Seed.Hostname, request.Seed.NetworkConfig, request.Seed.StartupScript)
if err != nil {
t.Fatal(err)
}
if _, err := startup.WriteSeedDirectory(filepath.Join(root, request.Seed.ArtifactID), files); err != nil {
t.Fatal(err)
}
return payload
}
func TestValidateTable(t *testing.T) {
tests := []struct {
name string
prepare func(t *testing.T, root string, payload domaincreateplan.JournalPayload)
wantErr error
wantCode string
definitive bool
wantSuccess bool
}{
{
name: "valid immutable seed",
wantSuccess: true,
},
{
name: "missing seed is definitive",
prepare: func(t *testing.T, root string, payload domaincreateplan.JournalPayload) {
t.Helper()
// The payload is intentionally left without a published artifact.
},
wantErr: ErrSeedArtifactRejected,
wantCode: codePrefix + "seed_artifact_rejected",
definitive: true,
},
{
name: "tampered seed is definitive",
prepare: func(t *testing.T, root string, payload domaincreateplan.JournalPayload) {
t.Helper()
path := filepath.Join(root, payload.SeedArtifactID, startup.UserDataFilename)
if err := os.WriteFile(path, []byte("tampered\n"), 0o600); err != nil {
t.Fatal(err)
}
},
wantErr: ErrSeedArtifactRejected,
wantCode: codePrefix + "seed_artifact_rejected",
definitive: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
root := t.TempDir()
var payload domaincreateplan.JournalPayload
if tt.name == "missing seed is definitive" {
// Build the journal without publishing the artifact.
readonly := true
secureBoot := false
request := domaincreateplan.Request{
Domain: domainpreflight.Request{
UUID: validateDomainUUID,
Firmware: domainpreflight.FirmwareEFI,
Architecture: domainpreflight.ArchitectureX86,
Machine: domainpreflight.MachineQ35,
OSType: domainpreflight.OSTypeHVM,
Loader: domainpreflight.LoaderPolicy{Type: domainpreflight.LoaderPFlash, Readonly: &readonly, SecureBoot: &secureBoot},
},
Seed: domaincreateplan.SeedRequest{
ArtifactID: validateArtifactUUID,
InstanceID: "instance-validate-1101",
Hostname: "vm-validate-1101",
NetworkConfig: `{"version":2,"ethernets":{}}`,
StartupScript: "#!/bin/sh\necho validate-secret\n",
},
}
var err error
payload, err = domaincreateplan.PrepareJournal(request)
if err != nil {
t.Fatal(err)
}
} else {
payload = validPayload(t, root)
}
if tt.prepare != nil {
tt.prepare(t, root, payload)
}
result, err := Validate(context.Background(), root, payload)
if tt.wantSuccess {
if err != nil {
t.Fatal(err)
}
if result.CommitBoundary != CommitBoundarySeedVerified || !result.LoaderPending {
t.Fatalf("result boundary/loader = %q/%v", result.CommitBoundary, result.LoaderPending)
}
if result.PlanHash != payload.PlanHash || result.DomainXMLHash != payload.DomainXMLHash ||
!result.StartupScriptPresent || result.StartupScriptSHA256 != payload.StartupScriptSHA256 {
t.Fatalf("result identity changed: %+v", result)
}
return
}
if err == nil || !errors.Is(err, tt.wantErr) || IsDefinitive(err) != tt.definitive || Code(err) != tt.wantCode {
t.Fatalf("Validate() error=%v code=%q definitive=%v; want %v/%q/%v", err, Code(err), IsDefinitive(err), tt.wantErr, tt.wantCode, tt.definitive)
}
})
}
}
func TestValidateRejectsPolicyAndPlanMutation(t *testing.T) {
root := t.TempDir()
payload := validPayload(t, root)
t.Run("secure boot policy", func(t *testing.T) {
mutated := payload
secureBoot := true
mutated.Domain.Loader.SecureBoot = &secureBoot
_, err := Validate(context.Background(), root, mutated)
if err == nil || !errors.Is(err, ErrInvalidJournal) || !IsDefinitive(err) {
t.Fatalf("policy mutation error=%v", err)
}
})
t.Run("plan hash", func(t *testing.T) {
mutated := payload
mutated.PlanHash = strings.Repeat("b", 64)
_, err := Validate(context.Background(), root, mutated)
if err == nil || !errors.Is(err, ErrInvalidJournal) || !IsDefinitive(err) {
t.Fatalf("plan mutation error=%v", err)
}
})
t.Run("first boot presence", func(t *testing.T) {
mutated := payload
mutated.StartupScriptPresent = !mutated.StartupScriptPresent
_, err := Validate(context.Background(), root, mutated)
if err == nil || !errors.Is(err, ErrInvalidJournal) || !IsDefinitive(err) {
t.Fatalf("first_boot_present mutation error=%v", err)
}
})
}
func TestValidateRejectsStartupScriptPresenceMismatch(t *testing.T) {
readonly := true
secureBoot := false
base := domaincreateplan.Request{
Domain: domainpreflight.Request{
UUID: validateDomainUUID,
Firmware: domainpreflight.FirmwareEFI,
Architecture: domainpreflight.ArchitectureX86,
Machine: domainpreflight.MachineQ35,
OSType: domainpreflight.OSTypeHVM,
Loader: domainpreflight.LoaderPolicy{Type: domainpreflight.LoaderPFlash, Readonly: &readonly, SecureBoot: &secureBoot},
},
Seed: domaincreateplan.SeedRequest{
ArtifactID: validateArtifactUUID,
InstanceID: "instance-validate-1101",
Hostname: "vm-validate-1101",
NetworkConfig: `{"version":2,"ethernets":{}}`,
},
}
withScript := base
withScript.Seed.StartupScript = "echo mismatch\n"
withoutScript, err := domaincreateplan.PrepareJournal(base)
if err != nil {
t.Fatal(err)
}
withScriptPayload, err := domaincreateplan.PrepareJournal(withScript)
if err != nil {
t.Fatal(err)
}
t.Run("script artifact cannot satisfy no-script plan", func(t *testing.T) {
root := t.TempDir()
files, err := startup.BuildCreateSeed(withScript.Seed.InstanceID, withScript.Seed.Hostname, withScript.Seed.NetworkConfig, withScript.Seed.StartupScript)
if err != nil {
t.Fatal(err)
}
if _, err := startup.WriteSeedDirectory(filepath.Join(root, validateArtifactUUID), files); err != nil {
t.Fatal(err)
}
_, err = Validate(context.Background(), root, withoutScript)
if err == nil || !errors.Is(err, ErrSeedArtifactRejected) || !IsDefinitive(err) {
t.Fatalf("script artifact accepted by no-script plan: %v", err)
}
})
t.Run("no-script artifact cannot satisfy script plan", func(t *testing.T) {
root := t.TempDir()
files, err := startup.BuildCreateSeed(base.Seed.InstanceID, base.Seed.Hostname, base.Seed.NetworkConfig, "")
if err != nil {
t.Fatal(err)
}
if _, err := startup.WriteSeedDirectory(filepath.Join(root, validateArtifactUUID), files); err != nil {
t.Fatal(err)
}
_, err = Validate(context.Background(), root, withScriptPayload)
if err == nil || !errors.Is(err, ErrSeedArtifactRejected) || !IsDefinitive(err) {
t.Fatalf("no-script artifact accepted by script plan: %v", err)
}
})
}
func TestValidateResultContainsNoJournalRawContent(t *testing.T) {
root := t.TempDir()
payload := validPayload(t, root)
result, err := Validate(context.Background(), root, payload)
if err != nil {
t.Fatal(err)
}
encoded, err := json.Marshal(result)
if err != nil {
t.Fatal(err)
}
for _, forbidden := range []string{
"validate-secret",
`{"version":2,"ethernets":{}}`,
startup.ScriptPath,
root,
startup.UserDataFilename,
startup.NetworkConfigFilename,
} {
if bytes.Contains(encoded, []byte(forbidden)) {
t.Fatalf("validation result contains forbidden content %q: %s", forbidden, encoded)
}
}
}
func TestValidateCancellationIsTransient(t *testing.T) {
root := t.TempDir()
payload := validPayload(t, root)
ctx, cancel := context.WithCancel(context.Background())
cancel()
_, err := Validate(ctx, root, payload)
if err == nil || !errors.Is(err, ErrCanceled) || IsDefinitive(err) || Code(err) != codePrefix+"canceled" {
t.Fatalf("cancellation error=%v code=%q definitive=%v", err, Code(err), IsDefinitive(err))
}
}
func TestValidateTranslatesSeedMediaBoundaryErrors(t *testing.T) {
fixtureRoot := t.TempDir()
payload := validPayload(t, fixtureRoot)
t.Run("invalid root keeps legacy definitive code", func(t *testing.T) {
_, err := Validate(context.Background(), "relative-artifacts", payload)
if err == nil || Code(err) != codePrefix+"artifact_root_invalid" || !IsDefinitive(err) || !errors.Is(err, ErrArtifactUnavailable) {
t.Fatalf("invalid root error=%v code=%q definitive=%v", err, Code(err), IsDefinitive(err))
}
})
t.Run("unavailable root remains uncertain", func(t *testing.T) {
root := filepath.Join(t.TempDir(), "artifact-root-file")
if err := os.WriteFile(root, []byte("not a directory"), 0o600); err != nil {
t.Fatal(err)
}
_, err := Validate(context.Background(), root, payload)
if err == nil || Code(err) != codePrefix+"artifact_unavailable" || IsDefinitive(err) || !errors.Is(err, ErrArtifactUnavailable) {
t.Fatalf("unavailable root error=%v code=%q definitive=%v", err, Code(err), IsDefinitive(err))
}
})
t.Run("identity mismatch retains manifest mismatch code", func(t *testing.T) {
root := t.TempDir()
files, err := startup.BuildCreateSeed(payload.InstanceID, payload.Hostname, "", "echo a different immutable seed\n")
if err != nil {
t.Fatal(err)
}
if _, err := startup.WriteSeedDirectory(filepath.Join(root, payload.SeedArtifactID), files); err != nil {
t.Fatal(err)
}
_, err = Validate(context.Background(), root, payload)
if err == nil || Code(err) != codePrefix+"seed_manifest_mismatch" || !IsDefinitive(err) || !errors.Is(err, ErrSeedArtifactRejected) {
t.Fatalf("identity mismatch error=%v code=%q definitive=%v", err, Code(err), IsDefinitive(err))
}
})
}