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.
320 lines
11 KiB
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))
|
|
}
|
|
})
|
|
}
|