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.

273 lines
9.6 KiB
Go

package main
import (
"bytes"
"context"
"encoding/json"
"errors"
"io"
"strings"
"testing"
"time"
"git.luoli.live/root/virt/agent/objecttransfer"
)
type fakeCopier struct {
result objecttransfer.UploadResult
err error
calls int
downloadResult objecttransfer.DownloadResult
downloadErr error
downloadCalls int
}
func (f *fakeCopier) Download(context.Context, string, int64, string,
io.Writer) (objecttransfer.DownloadResult, error) {
f.downloadCalls++
return f.downloadResult, f.downloadErr
}
func (f *fakeCopier) CopyObject(context.Context, objecttransfer.CopySource,
objecttransfer.MultipartPlan) (objecttransfer.UploadResult, error) {
f.calls++
return f.result, f.err
}
func validRequest(now time.Time) replicaRequest {
return replicaRequest{
Protocol: protocolName,
OperationID: "0123456789abcdef0123456789abcdef",
DeadlineAt: now.Add(time.Hour).Unix(),
Source: objecttransfer.CopySource{
GetURL: "https://source.example.test/object?signature=source-secret",
SizeBytes: objecttransfer.MinPartSizeBytes,
SHA256: strings.Repeat("a", 64),
},
Destination: objecttransfer.MultipartPlan{
PartSizeBytes: objecttransfer.MinPartSizeBytes,
PartURLs: []string{
"https://target.example.test/object?partNumber=1&signature=part-secret",
},
CompleteURL: "https://target.example.test/object?complete=1&signature=complete-secret",
AbortURL: "https://target.example.test/object?abort=1&signature=abort-secret",
VerifyURL: "https://target.example.test/object?signature=verify-secret",
MaximumSizeBytes: objecttransfer.MinPartSizeBytes,
},
}
}
func encodeRequest(t *testing.T, request replicaRequest) *bytes.Reader {
t.Helper()
encoded, err := json.Marshal(request)
if err != nil {
t.Fatal(err)
}
return bytes.NewReader(encoded)
}
func validVerifyRequest(now time.Time) verifyRequest {
return verifyRequest{
Protocol: verifyProtocolName, OperationID: "fedcba9876543210fedcba9876543210",
DeadlineAt: now.Add(time.Hour).Unix(),
GetURL: "https://target.example.test/object?versionId=exact&signature=verify-secret",
SizeBytes: objecttransfer.MinPartSizeBytes,
SHA256: strings.Repeat("b", 64),
}
}
func TestRunReturnsBoundedSuccessReceipt(t *testing.T) {
now := time.Unix(1_800_000_000, 0).UTC()
copier := &fakeCopier{result: objecttransfer.UploadResult{
SizeBytes: objecttransfer.MinPartSizeBytes,
SHA256: strings.Repeat("a", 64), ETag: `"final"`,
VersionID: "version-1",
}}
receipt := run(encodeRequest(t, validRequest(now)),
func() time.Time { return now }, copier)
if copier.calls != 1 || receipt.Outcome != "succeeded" ||
receipt.EffectResolution != "applied" ||
receipt.OperationID != "0123456789abcdef0123456789abcdef" ||
receipt.ErrorCode != "" || receipt.VersionID != "version-1" {
t.Fatalf("unexpected success receipt: %#v calls=%d", receipt, copier.calls)
}
encoded, _ := json.Marshal(receipt)
if len(encoded) > 4096 || bytes.Contains(encoded, []byte("signature=")) {
t.Fatalf("receipt is unbounded or leaks a capability: %s", encoded)
}
}
func TestRunKeepsVersionlessSuccessExplicit(t *testing.T) {
now := time.Unix(1_800_000_000, 0).UTC()
copier := &fakeCopier{result: objecttransfer.UploadResult{
SizeBytes: objecttransfer.MinPartSizeBytes,
SHA256: strings.Repeat("a", 64), ETag: `"final"`,
}}
receipt := run(encodeRequest(t, validRequest(now)),
func() time.Time { return now }, copier)
encoded, err := json.Marshal(receipt)
if err != nil {
t.Fatal(err)
}
if receipt.Outcome != "succeeded" || receipt.VersionID != "" ||
!bytes.Contains(encoded, []byte(`"version_id":""`)) {
t.Fatalf("versionless identity was omitted: %s", encoded)
}
}
func TestRunPreservesUnknownEffectWithoutCapabilityLeak(t *testing.T) {
now := time.Unix(1_800_000_000, 0).UTC()
copier := &fakeCopier{err: &objecttransfer.Error{
Code: "upload_complete_uncertain", Message: "safe message",
Ambiguous: true,
}}
receipt := run(encodeRequest(t, validRequest(now)),
func() time.Time { return now }, copier)
if receipt.Outcome != "failed" || receipt.EffectResolution != "unknown" ||
receipt.ErrorCode != "upload_complete_uncertain" || copier.calls != 1 {
t.Fatalf("unexpected unknown receipt: %#v calls=%d", receipt, copier.calls)
}
encoded, _ := json.Marshal(receipt)
for _, secret := range []string{
"source-secret", "part-secret", "complete-secret", "abort-secret",
} {
if bytes.Contains(encoded, []byte(secret)) {
t.Fatalf("receipt leaked %s", secret)
}
}
}
func TestRunRejectsInvalidEnvelopeBeforeCopy(t *testing.T) {
now := time.Unix(1_800_000_000, 0).UTC()
tests := map[string][]byte{
"unknown field": []byte(`{"protocol":"object-replica-v1","operation_id":"0123456789abcdef0123456789abcdef","unexpected":true}`),
"two documents": append(mustJSON(t, validRequest(now)), []byte(` {}`)...),
"oversized": bytes.Repeat([]byte("x"), int(maxRequestBytes+1)),
}
for name, input := range tests {
t.Run(name, func(t *testing.T) {
copier := &fakeCopier{}
receipt := run(bytes.NewReader(input), func() time.Time { return now }, copier)
if receipt.Outcome != "failed" ||
receipt.EffectResolution != "not_applied" || copier.calls != 0 {
t.Fatalf("unexpected invalid-envelope receipt: %#v", receipt)
}
})
}
}
func TestRunRejectsDeadlineAndPlanBeforeCopy(t *testing.T) {
now := time.Unix(1_800_000_000, 0).UTC()
tests := map[string]replicaRequest{}
expired := validRequest(now)
expired.DeadlineAt = now.Unix()
tests["expired"] = expired
tooLong := validRequest(now)
tooLong.DeadlineAt = now.Add(maxDeadline + time.Second).Unix()
tests["too long"] = tooLong
plainHTTP := validRequest(now)
plainHTTP.Source.GetURL = "http://source.example.test/object"
tests["plain http"] = plainHTTP
crossOriginDestination := validRequest(now)
crossOriginDestination.Destination.AbortURL =
"https://other.example.test/object?abort=1"
tests["mixed destination origins"] = crossOriginDestination
for name, request := range tests {
t.Run(name, func(t *testing.T) {
copier := &fakeCopier{}
receipt := run(encodeRequest(t, request),
func() time.Time { return now }, copier)
if receipt.Outcome != "failed" ||
receipt.EffectResolution != "not_applied" || copier.calls != 0 {
t.Fatalf("unexpected preflight receipt: %#v", receipt)
}
})
}
}
func TestTransferCodeDoesNotExposeUnknownErrors(t *testing.T) {
if value := transferCode(errors.New("https://secret.example/?token=1"),
"replica_copy_unknown"); value != "replica_copy_unknown" {
t.Fatalf("unexpected fallback code: %q", value)
}
}
func TestRunVerifyReturnsExactReadEvidence(t *testing.T) {
now := time.Unix(1_800_000_000, 0).UTC()
worker := &fakeCopier{downloadResult: objecttransfer.DownloadResult{
SizeBytes: objecttransfer.MinPartSizeBytes,
SHA256: strings.Repeat("b", 64), ETag: `"verified"`,
VersionID: "version-exact",
}}
receipt := run(bytes.NewReader(mustJSON(t, validVerifyRequest(now))),
func() time.Time { return now }, worker)
if worker.calls != 0 || worker.downloadCalls != 1 ||
receipt.Protocol != verifyProtocolName || receipt.Outcome != "succeeded" ||
receipt.EffectResolution != "applied" ||
receipt.OperationID != "fedcba9876543210fedcba9876543210" ||
receipt.SizeBytes != objecttransfer.MinPartSizeBytes ||
receipt.VersionID != "version-exact" {
t.Fatalf("unexpected verify receipt: %#v", receipt)
}
encoded, _ := json.Marshal(receipt)
if bytes.Contains(encoded, []byte("verify-secret")) || len(encoded) > 4096 {
t.Fatalf("verify receipt leaked capability or grew unbounded: %s", encoded)
}
}
func TestRunVerifyKeepsUnreachableObjectUnknown(t *testing.T) {
now := time.Unix(1_800_000_000, 0).UTC()
worker := &fakeCopier{downloadErr: &objecttransfer.Error{
Code: "object_download_failed", Message: "safe", Ambiguous: false,
}}
receipt := run(bytes.NewReader(mustJSON(t, validVerifyRequest(now))),
func() time.Time { return now }, worker)
if receipt.Outcome != "failed" || receipt.EffectResolution != "unknown" ||
receipt.ErrorCode != "object_download_failed" ||
worker.downloadCalls != 1 || worker.calls != 0 {
t.Fatalf("unreachable exact object was misclassified: %#v", receipt)
}
}
func TestRunVerifyTreatsConflictingObjectAsNotApplied(t *testing.T) {
now := time.Unix(1_800_000_000, 0).UTC()
for _, code := range []string{"object_size_mismatch", "object_sha256_mismatch"} {
t.Run(code, func(t *testing.T) {
worker := &fakeCopier{downloadErr: &objecttransfer.Error{
Code: code, Message: "safe", Ambiguous: false,
}}
receipt := run(bytes.NewReader(mustJSON(t, validVerifyRequest(now))),
func() time.Time { return now }, worker)
if receipt.Outcome != "failed" ||
receipt.EffectResolution != "not_applied" ||
receipt.ErrorCode != code || worker.downloadCalls != 1 {
t.Fatalf("conflicting exact object was misclassified: %#v", receipt)
}
})
}
}
func TestRunVerifyRejectsCredentialsAndCopyFields(t *testing.T) {
now := time.Unix(1_800_000_000, 0).UTC()
request := validVerifyRequest(now)
payload := mustJSON(t, request)
payload = bytes.TrimSuffix(payload, []byte("}"))
payload = append(payload, []byte(`,"access_key":"must-not-be-accepted"}`)...)
worker := &fakeCopier{}
receipt := run(bytes.NewReader(payload), func() time.Time { return now }, worker)
if receipt.Outcome != "failed" || receipt.EffectResolution != "not_applied" ||
receipt.ErrorCode != "invalid_replica_verify_request" ||
worker.downloadCalls != 0 || worker.calls != 0 {
t.Fatalf("credential-bearing verify request was accepted: %#v", receipt)
}
}
func mustJSON(t *testing.T, value any) []byte {
t.Helper()
encoded, err := json.Marshal(value)
if err != nil {
t.Fatal(err)
}
return encoded
}