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/peermigration/peermigration_test.go

327 lines
11 KiB
Go

package peermigration
import (
"context"
"crypto/sha256"
"crypto/tls"
"crypto/x509"
"encoding/hex"
"encoding/json"
"errors"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
)
func TestPeerMigrationHandlerKeepsPathsAndTicketsPrivate(t *testing.T) {
store, manifest, ticket, contents := peerMigrationFixture(t)
handler, err := NewHandler(store)
if err != nil {
t.Fatalf("new handler: %v", err)
}
manifestPath := "/v3/peer-migrations/" + manifest.MigrationID + "/manifest"
for _, request := range []*http.Request{
httptest.NewRequest(http.MethodGet, manifestPath, nil),
httptest.NewRequest(http.MethodGet, manifestPath+"?ticket="+ticket, nil),
} {
response := httptest.NewRecorder()
handler.ServeHTTP(response, request)
if response.Code != http.StatusNotFound {
t.Fatalf("unauthorized request status=%d, want 404", response.Code)
}
}
request := httptest.NewRequest(http.MethodGet, manifestPath, nil)
request.Header.Set("Authorization", "Bearer "+ticket)
response := httptest.NewRecorder()
handler.ServeHTTP(response, request)
if response.Code != http.StatusOK {
t.Fatalf("manifest status=%d body=%s", response.Code, response.Body.String())
}
var envelope struct {
Manifest
Digest string `json:"digest"`
}
if err := json.Unmarshal(response.Body.Bytes(), &envelope); err != nil {
t.Fatalf("decode public manifest: %v", err)
}
if envelope.Artifacts[0].Path != "" || strings.Contains(response.Body.String(), filepath.Dir(manifest.Artifacts[0].Path)) {
t.Fatalf("public manifest leaked a host path: %s", response.Body.String())
}
artifactPath := "/v3/peer-migrations/" + manifest.MigrationID +
"/artifacts/" + manifest.Artifacts[0].ID
request = httptest.NewRequest(http.MethodGet, artifactPath, nil)
request.Header.Set("Authorization", "Bearer "+ticket)
request.Header.Set("Range", "bytes=2-5")
response = httptest.NewRecorder()
handler.ServeHTTP(response, request)
if response.Code != http.StatusPartialContent || response.Body.String() != string(contents[2:6]) ||
response.Header().Get("Content-Range") != "bytes 2-5/"+strconv.FormatInt(int64(len(contents)), 10) {
t.Fatalf("range response status=%d range=%q body=%q", response.Code,
response.Header().Get("Content-Range"), response.Body.String())
}
}
func TestPeerMigrationClientResumesAndVerifiesArtifact(t *testing.T) {
store, stored, ticket, contents := peerMigrationFixture(t)
handler, err := NewHandler(store)
if err != nil {
t.Fatalf("new handler: %v", err)
}
client, err := NewClient(store, strings.Repeat("1", 64))
if err != nil {
t.Fatalf("new client: %v", err)
}
defer client.CloseIdleConnections()
client.chunkSize = 4
client.http.Transport = roundTripperFunc(func(request *http.Request) (*http.Response, error) {
response := httptest.NewRecorder()
handler.ServeHTTP(response, request)
result := response.Result()
if length, parseErr := strconv.ParseInt(result.Header.Get("Content-Length"), 10, 64); parseErr == nil {
result.ContentLength = length
}
return result, nil
})
public := stored.Public()
digest, err := public.Digest()
if err != nil {
t.Fatalf("manifest digest: %v", err)
}
fetched, selected, err := client.FetchManifest(context.Background(), []string{"https://192.0.2.10:9443"},
stored.MigrationID, ticket, digest)
if err != nil {
t.Fatalf("fetch manifest: %v", err)
}
if selected != "https://192.0.2.10:9443" {
t.Fatalf("selected endpoint = %q", selected)
}
directory, err := store.TargetSessionDir(stored.MigrationID)
if err != nil {
t.Fatalf("target directory: %v", err)
}
partial := filepath.Join(directory, stored.Artifacts[0].ID+".partial")
if err := os.WriteFile(partial, contents[:3], 0600); err != nil {
t.Fatalf("seed partial: %v", err)
}
paths, err := client.Download(context.Background(), selected, ticket, fetched)
if err != nil {
t.Fatalf("resume download: %v", err)
}
ready, err := os.ReadFile(paths[stored.Artifacts[0].ID])
if err != nil || string(ready) != string(contents) {
t.Fatalf("ready artifact=%q err=%v", ready, err)
}
}
func TestAutomaticPeerIdentityPersistsAndPinsTLS(t *testing.T) {
root := t.TempDir()
identity, err := LoadOrCreateIdentity(root, "42")
if err != nil {
t.Fatalf("create identity: %v", err)
}
reloaded, err := LoadOrCreateIdentity(root, "42")
if err != nil || reloaded.Fingerprint() != identity.Fingerprint() {
t.Fatalf("reload identity fingerprint=%q err=%v", reloaded.Fingerprint(), err)
}
info, err := os.Stat(filepath.Join(root, identityFileName))
if err != nil {
t.Fatalf("stat identity: %v", err)
}
if info.Mode().Perm() != 0600 {
t.Fatalf("identity mode=%v err=%v", info.Mode().Perm(), err)
}
for name, testCase := range map[string]struct {
fingerprint string
success bool
}{
"matching pin": {identity.Fingerprint(), true},
"wrong pin": {strings.Repeat("0", 64), false},
} {
t.Run(name, func(t *testing.T) {
clientTLS, err := PinnedClientTLSConfig(testCase.fingerprint)
if err != nil {
t.Fatalf("client TLS: %v", err)
}
verifyErr := clientTLS.VerifyConnection(tls.ConnectionState{
Version: tls.VersionTLS13, PeerCertificates: []*x509.Certificate{identity.certificate.Leaf},
})
if (verifyErr == nil) != testCase.success {
t.Fatalf("verify success=%v want=%v err=%v", verifyErr == nil, testCase.success, verifyErr)
}
})
}
}
func TestPeerEndpointsRequireLiteralIPAndExplicitPort(t *testing.T) {
for _, endpoint := range []string{
"https://192.0.2.10:9443",
"https://10.0.0.10:9443",
"https://[2001:db8::10]:9443",
} {
if err := ValidateEndpoint(endpoint); err != nil {
t.Fatalf("valid endpoint %q rejected: %v", endpoint, err)
}
}
for _, endpoint := range []string{
"https://host.example.com:9443",
"https://192.0.2.10",
"http://192.0.2.10:9443",
} {
if err := ValidateEndpoint(endpoint); err == nil {
t.Fatalf("invalid endpoint %q accepted", endpoint)
}
}
}
type roundTripperFunc func(*http.Request) (*http.Response, error)
func (f roundTripperFunc) RoundTrip(request *http.Request) (*http.Response, error) {
return f(request)
}
func TestPeerMigrationStoreRejectsExternalPathsAndPersistsPathFreeReceipt(t *testing.T) {
store, stored, _, _ := peerMigrationFixture(t)
targetDirectory, err := store.TargetSessionDir(stored.MigrationID)
if err != nil || !strings.Contains(targetDirectory,
string(filepath.Separator)+"staging"+string(filepath.Separator)) ||
strings.Contains(targetDirectory,
string(filepath.Separator)+"state"+string(filepath.Separator)) {
t.Fatalf("target staging directory is not isolated from metadata: path=%q err=%v", targetDirectory, err)
}
external := stored
external.MigrationID = strings.Repeat("d", 32)
external.Artifacts = append([]Artifact(nil), stored.Artifacts...)
external.Artifacts[0].Path = filepath.Join(t.TempDir(), "outside.qcow2")
if err := store.SaveSource(external); err == nil {
t.Fatal("source manifest accepted an artifact outside configured storage roots")
}
digest, err := stored.Public().Digest()
if err != nil {
t.Fatalf("manifest digest: %v", err)
}
receipt := TargetReceipt{
Version: ProtocolVersion, MigrationID: stored.MigrationID,
ManifestDigest: digest, SourceUUID: stored.SourceUUID,
TargetUUID: "22222222-2222-4222-8222-222222222222",
ExpiresAt: stored.ExpiresAt, Artifacts: stored.Public().Artifacts,
StagedPoweredOff: true, CreatedAt: time.Now().Unix(),
}
if err := store.SaveTargetReceipt(receipt); err != nil {
t.Fatalf("save target receipt: %v", err)
}
loaded, err := store.LoadTargetReceipt(stored.MigrationID)
if err != nil || loaded.Artifacts[0].Path != "" {
t.Fatalf("load path-free target receipt: %+v err=%v", loaded, err)
}
if err := store.RemoveTarget(stored.MigrationID); err != nil {
t.Fatalf("remove target staging: %v", err)
}
if _, err := store.LoadTargetReceipt(stored.MigrationID); err != nil {
t.Fatalf("staging cleanup removed reconciliation receipt: %v", err)
}
if err := store.RemoveTargetReceipt(stored.MigrationID); err != nil {
t.Fatalf("remove target receipt: %v", err)
}
if _, err := store.LoadTargetReceipt(stored.MigrationID); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("target receipt still exists after explicit cleanup: %v", err)
}
}
func TestPeerMigrationStoreRejectsStagingOutsideStorageRoots(t *testing.T) {
root := t.TempDir()
storage := filepath.Join(root, "storage")
if _, err := NewStore(filepath.Join(root, "state"), []string{storage},
filepath.Join(root, "outside")); err == nil {
t.Fatal("staging outside storage roots was accepted")
}
}
func TestPeerMigrationStorePrunesOnlyExpiredWellShapedTargetSessions(t *testing.T) {
root := t.TempDir()
storage := filepath.Join(root, "storage")
state := filepath.Join(root, "state")
staging := filepath.Join(storage, "staging")
store, err := NewStore(state, []string{storage}, staging)
if err != nil {
t.Fatalf("new store: %v", err)
}
migrationID := strings.Repeat("e", 32)
session, err := store.TargetSessionDir(migrationID)
if err != nil {
t.Fatalf("create target session: %v", err)
}
partial := filepath.Join(session, strings.Repeat("f", 32)+".partial")
if err := os.WriteFile(partial, []byte("partial"), 0600); err != nil {
t.Fatalf("write partial: %v", err)
}
stale := time.Now().Add(-staleTargetSessionAge - time.Hour)
if err := os.Chtimes(partial, stale, stale); err != nil {
t.Fatalf("age partial: %v", err)
}
if err := os.Chtimes(session, stale, stale); err != nil {
t.Fatalf("age session: %v", err)
}
if _, err := NewStore(state, []string{storage}, staging); err != nil {
t.Fatalf("reopen store: %v", err)
}
if _, err := os.Stat(session); !errors.Is(err, os.ErrNotExist) {
t.Fatalf("expired target session was not removed: %v", err)
}
}
func peerMigrationFixture(t *testing.T) (*Store, StoredManifest, string, []byte) {
t.Helper()
root := t.TempDir()
storage := filepath.Join(root, "storage")
state := filepath.Join(root, "state")
if err := os.MkdirAll(storage, 0700); err != nil {
t.Fatalf("create storage: %v", err)
}
contents := []byte("peer-migration-v3-artifact")
artifactPath := filepath.Join(storage, "system.qcow2")
if err := os.WriteFile(artifactPath, contents, 0600); err != nil {
t.Fatalf("write artifact: %v", err)
}
digest := sha256.Sum256(contents)
ticket := strings.Repeat("a", 64)
ticketDigest, err := TicketDigest(ticket)
if err != nil {
t.Fatalf("ticket digest: %v", err)
}
stored := StoredManifest{
Manifest: Manifest{
Version: ProtocolVersion,
MigrationID: strings.Repeat("b", 32),
SourceUUID: "11111111-1111-4111-8111-111111111111",
ExpiresAt: time.Now().Add(time.Hour).Unix(),
Artifacts: []Artifact{{
ID: strings.Repeat("c", 32), Role: "root", Consistency: "crash",
SizeBytes: int64(len(contents)), VirtualSizeBytes: uint64(len(contents)),
SHA256: hex.EncodeToString(digest[:]), CreatedAt: time.Now().Unix(),
Path: artifactPath,
}},
},
TicketSHA256: ticketDigest,
}
store, err := NewStore(state, []string{storage}, filepath.Join(storage, "staging"))
if err != nil {
t.Fatalf("new store: %v", err)
}
if err := store.SaveSource(stored); err != nil {
t.Fatalf("save source: %v", err)
}
return store, stored, ticket, contents
}