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
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
|
|
}
|