Merge pull request #285 from renaesop/codex/s3-task-archives

feat: add encrypted S3 archive storage backend
This commit is contained in:
BaaRai
2026-11-19 14:23:12 +01:00
committed by GitHub
9 changed files with 1366 additions and 1 deletions
+1 -1
View File
@@ -71,7 +71,7 @@ jobs:
ARTEX_PG_DSN: postgres://artex:testpass@localhost:5432/artextest_race?sslmode=disable
run: >-
go test -race -p 1 ./agent ./cmd/artex ./config ./db ./evidence ./guard
go test -race -p 1 ./agent ./archivestore ./cmd/artex ./config ./db ./evidence ./guard
./intercept ./llmpool ./llmrec ./mcphttp ./notify ./server ./sidequestion
./traffic ./traffic/rewrite
+89
View File
@@ -0,0 +1,89 @@
package archivestore
import (
"strings"
"testing"
)
func TestArchiveStorageEnvironment(t *testing.T) {
for _, key := range []string{
"ARTEX_ARCHIVE_STORAGE", "ARTEX_ARCHIVE_S3_ENDPOINT", "ARTEX_ARCHIVE_S3_REGION",
"ARTEX_ARCHIVE_S3_BUCKET", "ARTEX_ARCHIVE_S3_PREFIX", "ARTEX_ARCHIVE_S3_ACCESS_KEY_ID",
"ARTEX_ARCHIVE_S3_SECRET_ACCESS_KEY", "ARTEX_ARCHIVE_S3_PATH_STYLE",
"ARTEX_ARCHIVE_S3_SESSION_TOKEN", "ARTEX_ARCHIVE_S3_SSE", "ARTEX_ARCHIVE_S3_KMS_KEY_ID",
} {
t.Setenv(key, "")
}
for _, backend := range []string{"", "local"} {
t.Setenv("ARTEX_ARCHIVE_STORAGE", backend)
if store, err := FromEnv(); err != nil || store != nil {
t.Fatalf("local default: %v %v", store, err)
}
}
for _, backend := range []string{"unknown", "s3"} {
t.Setenv("ARTEX_ARCHIVE_STORAGE", backend)
if _, err := FromEnv(); err == nil {
t.Fatalf("%q silently fell back to local", backend)
}
}
t.Setenv("ARTEX_ARCHIVE_S3_ENDPOINT", "http://127.0.0.1:9000")
t.Setenv("ARTEX_ARCHIVE_S3_BUCKET", "test-bucket")
t.Setenv("ARTEX_ARCHIVE_S3_ACCESS_KEY_ID", "test-key")
t.Setenv("ARTEX_ARCHIVE_S3_SECRET_ACCESS_KEY", "test-secret")
t.Setenv("ARTEX_ARCHIVE_S3_PATH_STYLE", "true")
store, err := FromEnv()
if err != nil {
t.Fatal(err)
}
if uri := store.URI(1, 2, "checksum"); uri != "s3://test-bucket/artex/tasks/task-1-2-checksum.tar.zst" {
t.Fatal("unexpected default object location", uri)
}
t.Setenv("ARTEX_ARCHIVE_S3_SECRET_ACCESS_KEY", "")
if _, err := FromEnv(); err == nil {
t.Fatal("missing credentials accepted")
}
}
func TestArchiveEndpointValidation(t *testing.T) {
config := Config{Bucket: "test", AccessKey: "test-key", SecretKey: "test-secret"}
for _, endpoint := range []string{"https://objects.example.test", "http://127.0.0.1:9000", "http://127.0.0.2:9000", "http://[::1]:9000", "http://localhost:9000"} {
config.Endpoint = endpoint
if _, err := New(config); err != nil {
t.Errorf("rejected %s: %v", endpoint, err)
}
}
for _, endpoint := range []string{"http://objects.example.test", "https://user:test-secret@objects.example.test", "https://objects.example.test/bucket", "https://objects.example.test?token=test-secret", "https://objects.example.test#fragment"} {
config.Endpoint = endpoint
if _, err := New(config); err == nil {
t.Error("accepted endpoint with non-loopback HTTP, credentials, path, query or fragment")
} else if strings.Contains(err.Error(), "test-secret") {
t.Fatal("configuration error disclosed a secret")
}
}
}
func TestArchiveEncryptionConfiguration(t *testing.T) {
c := Config{Endpoint: "https://objects.example.test", Bucket: "test", AccessKey: "test", SecretKey: "test"}
for _, mode := range []string{"none", "invalid"} {
c.SSE = mode
if _, err := New(c); err == nil {
t.Fatal("unencrypted/invalid mode accepted")
}
}
c.SSE = "AES256"
c.KMSKeyID = "alias/archive"
if _, err := New(c); err == nil {
t.Fatal("KMS key accepted with SSE-S3")
}
c.SSE = "aws:kms"
for _, key := range []string{"alias/archive", "bare-key-id", "arn:aws:kms:us-east-1:123456789012:alias/archive"} {
c.KMSKeyID = key
if _, err := New(c); err == nil {
t.Fatalf("accepted noncanonical KMS key %q", key)
}
}
c.KMSKeyID = "arn:aws:kms:us-east-1:123456789012:key/test-key"
if _, err := New(c); err != nil {
t.Fatal(err)
}
}
+132
View File
@@ -0,0 +1,132 @@
package archivestore
import (
"context"
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
func isolateAWSCredentials(t *testing.T) {
t.Helper()
for _, key := range []string{
"AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY", "AWS_SESSION_TOKEN", "AWS_PROFILE", "AWS_DEFAULT_PROFILE",
"AWS_ROLE_ARN", "AWS_ROLE_SESSION_NAME", "AWS_WEB_IDENTITY_TOKEN_FILE",
"AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", "AWS_CONTAINER_CREDENTIALS_FULL_URI",
"AWS_CONTAINER_AUTHORIZATION_TOKEN", "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE",
"AWS_EC2_METADATA_SERVICE_ENDPOINT", "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE",
} {
t.Setenv(key, "")
}
dir := t.TempDir()
t.Setenv("AWS_SHARED_CREDENTIALS_FILE", filepath.Join(dir, "credentials"))
t.Setenv("AWS_CONFIG_FILE", filepath.Join(dir, "config"))
t.Setenv("AWS_EC2_METADATA_DISABLED", "true")
}
func TestArchiveCredentialChain(t *testing.T) {
config := Config{Endpoint: "https://objects.example.test", Bucket: "test"}
for _, mode := range []string{"explicit-session", "environment", "shared-profile", "ecs", "imds"} {
t.Run(mode, func(t *testing.T) {
isolateAWSCredentials(t)
c := config
switch mode {
case "explicit-session":
t.Setenv("AWS_ACCESS_KEY_ID", "other-key")
t.Setenv("AWS_SECRET_ACCESS_KEY", "other-secret")
c.AccessKey, c.SecretKey, c.SessionToken = "fixture-key", "fixture-secret", "fixture-session"
case "environment":
t.Setenv("AWS_ACCESS_KEY_ID", "fixture-key")
t.Setenv("AWS_SECRET_ACCESS_KEY", "fixture-secret")
t.Setenv("AWS_SESSION_TOKEN", "fixture-session")
case "shared-profile":
t.Setenv("AWS_PROFILE", "archive")
data := `[archive]
aws_access_key_id=fixture-key
aws_secret_access_key=fixture-secret
aws_session_token=fixture-session
`
if err := os.WriteFile(os.Getenv("AWS_SHARED_CREDENTIALS_FILE"), []byte(data), 0600); err != nil {
t.Fatal(err)
}
case "ecs", "imds":
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if mode == "imds" {
switch r.URL.Path {
case "/latest/api/token":
if r.Method != "PUT" {
t.Error("IMDS did not use token request")
}
w.Header().Set("X-aws-ec2-metadata-token-ttl-seconds", "21600")
fmt.Fprint(w, "fixture-imds-token")
return
case "/latest/meta-data/iam/security-credentials/":
if r.Header.Get("X-aws-ec2-metadata-token") != "fixture-imds-token" {
t.Error("missing IMDSv2 token")
}
fmt.Fprint(w, "archive-role")
return
case "/latest/meta-data/iam/security-credentials/archive-role":
if r.Header.Get("X-aws-ec2-metadata-token") != "fixture-imds-token" {
t.Error("missing IMDSv2 token")
}
default:
t.Errorf("unexpected IMDS request %s", r.URL.Path)
w.WriteHeader(404)
return
}
} else if r.Header.Get("Authorization") != "fixture-container-token" {
t.Error("missing ECS authorization token")
}
_ = json.NewEncoder(w).Encode(map[string]any{
"Code": "Success", "AccessKeyId": "fixture-key", "SecretAccessKey": "fixture-secret",
"Token": "fixture-session", "Expiration": time.Now().Add(time.Hour).UTC().Format(time.RFC3339),
})
}))
defer srv.Close()
if mode == "imds" {
t.Setenv("AWS_EC2_METADATA_DISABLED", "false")
t.Setenv("AWS_EC2_METADATA_V1_DISABLED", "true")
t.Setenv("AWS_EC2_METADATA_SERVICE_ENDPOINT", srv.URL)
} else {
t.Setenv("AWS_CONTAINER_CREDENTIALS_FULL_URI", srv.URL+"/credentials")
t.Setenv("AWS_CONTAINER_AUTHORIZATION_TOKEN", "fixture-container-token")
}
}
store, err := New(c)
if err != nil {
t.Fatal(err)
}
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()
credentials, err := store.client.Options().Credentials.Retrieve(ctx)
if err != nil {
t.Fatal(err)
}
if credentials.AccessKeyID != "fixture-key" || credentials.SecretAccessKey != "fixture-secret" || credentials.SessionToken != "fixture-session" {
t.Fatal("wrong credential provider or session token")
}
if (mode == "imds" || mode == "ecs") && !credentials.CanExpire {
t.Fatal("role credentials must remain refreshable")
}
})
}
}
func TestArchiveIncompleteCredentialOverride(t *testing.T) {
isolateAWSCredentials(t)
t.Setenv("AWS_ACCESS_KEY_ID", "valid-ambient-key")
t.Setenv("AWS_SECRET_ACCESS_KEY", "valid-ambient-secret")
for _, c := range []Config{{AccessKey: "private-value"}, {SecretKey: "private-value"}, {SessionToken: "private-value"}} {
c.Endpoint, c.Bucket = "https://objects.example.test", "test"
if _, err := New(c); err == nil || strings.Contains(err.Error(), "private-value") {
t.Fatalf("partial override must fail without disclosing credentials: %v", err)
}
}
}
+372
View File
@@ -0,0 +1,372 @@
// Package archivestore stores immutable cold-task packages in S3-compatible storage.
package archivestore
import (
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"io"
"net"
"net/http"
"net/url"
"os"
"path"
"strings"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/aws/arn"
"github.com/aws/aws-sdk-go-v2/aws/retry"
awshttp "github.com/aws/aws-sdk-go-v2/aws/transport/http"
awsconfig "github.com/aws/aws-sdk-go-v2/config"
"github.com/aws/aws-sdk-go-v2/credentials"
"github.com/aws/aws-sdk-go-v2/feature/s3/manager"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/aws-sdk-go-v2/service/s3/types"
)
type Config struct {
Endpoint, Region, Bucket, Prefix, AccessKey, SecretKey string
PathStyle bool
SessionToken, SSE, KMSKeyID string
}
type Store struct {
client *s3.Client
bucket, prefix string
encryption types.ServerSideEncryption
kmsKeyID string
}
// FromEnv returns nil for the default local backend. A configured but invalid
// backend is an error, never a silent fallback to the machine's local disk.
func FromEnv() (*Store, error) {
switch os.Getenv("ARTEX_ARCHIVE_STORAGE") {
case "", "local":
return nil, nil
case "s3":
return New(Config{
Endpoint: os.Getenv("ARTEX_ARCHIVE_S3_ENDPOINT"), Region: os.Getenv("ARTEX_ARCHIVE_S3_REGION"),
Bucket: os.Getenv("ARTEX_ARCHIVE_S3_BUCKET"), Prefix: os.Getenv("ARTEX_ARCHIVE_S3_PREFIX"),
AccessKey: os.Getenv("ARTEX_ARCHIVE_S3_ACCESS_KEY_ID"), SecretKey: os.Getenv("ARTEX_ARCHIVE_S3_SECRET_ACCESS_KEY"),
PathStyle: os.Getenv("ARTEX_ARCHIVE_S3_PATH_STYLE") == "true",
SessionToken: os.Getenv("ARTEX_ARCHIVE_S3_SESSION_TOKEN"),
SSE: os.Getenv("ARTEX_ARCHIVE_S3_SSE"), KMSKeyID: os.Getenv("ARTEX_ARCHIVE_S3_KMS_KEY_ID"),
})
default:
return nil, errors.New("ARTEX_ARCHIVE_STORAGE must be local or s3")
}
}
func New(c Config) (*Store, error) {
u, err := url.Parse(c.Endpoint)
loopback := false
if err == nil {
loopback = u.Hostname() == "localhost"
if ip := net.ParseIP(u.Hostname()); ip != nil {
loopback = ip.IsLoopback()
}
}
if err != nil || u.Host == "" || u.User != nil || u.RawQuery != "" || u.Fragment != "" || (u.Path != "" && u.Path != "/") ||
(u.Scheme != "https" && !(u.Scheme == "http" && loopback)) {
return nil, errors.New("archive S3 endpoint must be an HTTPS origin (HTTP allowed only on loopback)")
}
c.Prefix = strings.Trim(c.Prefix, "/")
if c.Prefix == "" {
c.Prefix = "artex/tasks"
}
if path.Clean(c.Prefix) != c.Prefix || strings.Contains(c.Prefix, "..") || strings.ContainsAny(c.Prefix, "\\?#") {
return nil, errors.New("invalid archive S3 prefix")
}
if c.Bucket == "" || strings.ContainsAny(c.Bucket, "/\\:@?# ") {
return nil, errors.New("a valid archive S3 bucket is required")
}
explicitCredentials := c.AccessKey != "" || c.SecretKey != "" || c.SessionToken != ""
if explicitCredentials && (c.AccessKey == "" || c.SecretKey == "") {
return nil, errors.New("archive S3 access key and secret key must both be set when overriding AWS credentials")
}
if c.SSE == "" {
c.SSE = "AES256"
}
if c.SSE != "AES256" && c.SSE != "aws:kms" {
return nil, errors.New("archive S3 SSE must be AES256 or aws:kms; encryption cannot be disabled")
}
if c.KMSKeyID != "" && c.SSE != "aws:kms" {
return nil, errors.New("archive S3 KMS key requires SSE=aws:kms")
}
if c.KMSKeyID != "" {
key, err := arn.Parse(c.KMSKeyID)
if err != nil || key.Service != "kms" || key.Region == "" || key.AccountID == "" ||
!strings.HasPrefix(key.Resource, "key/") || len(key.Resource) <= len("key/") {
return nil, errors.New("archive S3 KMS key must be a full key ARN, not an alias or bare key ID")
}
}
if c.Region == "" {
c.Region = "us-east-1"
}
// Load shared AWS settings (including custom CAs) for both credential modes.
httpClient := awshttp.NewBuildableClient().WithTransportOptions(func(t *http.Transport) {
t.ResponseHeaderTimeout = 60 * time.Second
})
options := []func(*awsconfig.LoadOptions) error{
awsconfig.WithRegion(c.Region), awsconfig.WithHTTPClient(httpClient),
}
if explicitCredentials {
options = append(options, awsconfig.WithCredentialsProvider(
credentials.NewStaticCredentialsProvider(c.AccessKey, c.SecretKey, c.SessionToken)))
}
cfg, err := awsconfig.LoadDefaultConfig(context.Background(), options...)
if err != nil {
return nil, fmt.Errorf("load archive S3 AWS configuration: %w", err)
}
// The SDK's default client still follows 307/308. Use its CA-configured
// transport, but never redirect a signed archive request to another origin.
configuredClient := cfg.HTTPClient.(*awshttp.BuildableClient)
cfg.HTTPClient = &http.Client{
Transport: configuredClient.GetTransport(), Timeout: configuredClient.GetTimeout(),
CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse },
}
client := s3.NewFromConfig(cfg, func(o *s3.Options) {
o.BaseEndpoint = aws.String(c.Endpoint)
o.UsePathStyle = c.PathStyle
o.RequestChecksumCalculation = aws.RequestChecksumCalculationWhenRequired
o.ResponseChecksumValidation = aws.ResponseChecksumValidationWhenRequired
})
return &Store{client: client, bucket: c.Bucket, prefix: c.Prefix + "/",
encryption: types.ServerSideEncryption(c.SSE), kmsKeyID: c.KMSKeyID}, nil
}
func (s *Store) URI(taskID, archiveID int64, checksum string) string {
return "s3://" + s.bucket + "/" + s.prefix + fmt.Sprintf("task-%d-%d-%s.tar.zst", taskID, archiveID, checksum)
}
func (s *Store) key(uri string) (string, error) {
if s == nil {
return "", errors.New("S3 archive storage is not configured")
}
u, err := url.Parse(uri)
if err != nil || u.Scheme != "s3" || u.Host != s.bucket || u.User != nil || u.RawQuery != "" || u.Fragment != "" {
return "", errors.New("archive object is outside the configured bucket")
}
key := strings.TrimPrefix(u.Path, "/")
if !strings.HasPrefix(key, s.prefix) || len(key) <= len(s.prefix) || path.Clean(key) != key || strings.Contains(key, "\\") {
return "", errors.New("archive object is outside the configured prefix")
}
return key, nil
}
func (s *Store) Validate(uri string) error { _, err := s.key(uri); return err }
// Upload verifies the entire uploaded object by reading it back, including
// multipart uploads whose ETag is not a checksum. Callers retain source data
// until verification succeeds and PostgreSQL commits the remote location.
func (s *Store) Upload(ctx context.Context, uri, filename, checksum string) error {
key, err := s.key(uri)
if err != nil {
return err
}
if decoded, err := hex.DecodeString(checksum); err != nil || len(decoded) != sha256.Size {
return errors.New("invalid archive SHA-256")
}
f, err := os.Open(filename)
if err != nil {
return err
}
defer f.Close()
info, err := f.Stat()
if err != nil {
return err
}
uploader := manager.NewUploader(s.client, func(u *manager.Uploader) {
u.PartSize = 8 << 20
u.Concurrency = 2
u.LeavePartsOnError = true // Abort below with a fresh, bounded cleanup context.
u.RequestChecksumCalculation = aws.RequestChecksumCalculationWhenRequired
})
input := &s3.PutObjectInput{
Bucket: aws.String(s.bucket), Key: aws.String(key), Body: f,
ContentType: aws.String("application/zstd"), Metadata: map[string]string{"sha256": checksum},
ServerSideEncryption: s.encryption,
}
if s.kmsKeyID != "" {
input.SSEKMSKeyId = aws.String(s.kmsKeyID)
}
result, err := uploader.Upload(ctx, input)
if err != nil {
uploadErr := fmt.Errorf("upload archive: %w", err)
var multipart manager.MultiUploadFailure
if errors.As(err, &multipart) {
cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
defer cancel()
_, cleanupErr := s.client.AbortMultipartUpload(cleanupCtx, &s3.AbortMultipartUploadInput{
Bucket: aws.String(s.bucket), Key: aws.String(key), UploadId: aws.String(multipart.UploadID()),
})
if cleanupErr != nil {
return errors.Join(uploadErr, fmt.Errorf("abort archive multipart upload: %w", cleanupErr))
}
}
return uploadErr
}
if err := s.readVerified(ctx, key, io.Discard, checksum, info.Size(), true); err != nil {
cleanupCtx, cancel := context.WithTimeout(context.WithoutCancel(ctx), 30*time.Second)
defer cancel()
// Versioned buckets require deleting the version just uploaded; an
// unversioned DELETE would only hide it behind a delete marker.
_, cleanupErr := s.client.DeleteObject(cleanupCtx, &s3.DeleteObjectInput{
Bucket: aws.String(s.bucket), Key: aws.String(key), VersionId: result.VersionID,
})
if cleanupErr != nil {
return errors.Join(err, fmt.Errorf("delete unverified archive: %w", cleanupErr))
}
return err
}
return nil
}
func (s *Store) readVerified(ctx context.Context, key string, out io.Writer, checksum string, expectedSize int64, requireEncryption bool) error {
if decoded, err := hex.DecodeString(checksum); err != nil || len(decoded) != sha256.Size {
return errors.New("invalid archive SHA-256")
}
if expectedSize < 0 {
return errors.New("invalid archive size")
}
object, err := s.client.HeadObject(ctx, &s3.HeadObjectInput{Bucket: aws.String(s.bucket), Key: aws.String(key)})
if err != nil {
return fmt.Errorf("inspect archive: %w", err)
}
if requireEncryption && (object.ServerSideEncryption != s.encryption ||
(s.encryption == types.ServerSideEncryptionAwsKms && (aws.ToString(object.SSEKMSKeyId) == "" ||
(s.kmsKeyID != "" && aws.ToString(object.SSEKMSKeyId) != s.kmsKeyID)))) {
return errors.New("remote archive did not confirm the requested server-side encryption; source data retained")
}
if object.ContentLength == nil || *object.ContentLength != expectedSize || aws.ToString(object.ETag) == "" {
return errors.New("remote archive size mismatch or missing ETag; source data retained")
}
// Commit only complete, validated chunks to the output and hash. A broken
// connection can then retry its chunk without duplicating bytes or restarting
// a multi-gigabyte read. IfMatch pins every request to the same object.
h := sha256.New()
for offset := int64(0); offset < expectedSize; {
end := offset + min(archiveReadChunkSize, expectedSize-offset) - 1
data, err := s.readArchiveChunk(ctx, key, aws.ToString(object.ETag), offset, end, expectedSize)
if err != nil {
return err
}
n, err := out.Write(data)
if err != nil {
return err
}
if n != len(data) {
return io.ErrShortWrite
}
_, _ = h.Write(data)
offset += int64(len(data))
}
if !strings.EqualFold(hex.EncodeToString(h.Sum(nil)), checksum) {
return errors.New("remote archive size or SHA-256 mismatch; source data retained")
}
return nil
}
const (
archiveReadChunkSize = int64(8 << 20)
archiveReadAttempts = 5
)
func (s *Store) readArchiveChunk(ctx context.Context, key, etag string, start, end, total int64) ([]byte, error) {
var lastErr error
for attempt := 0; attempt < archiveReadAttempts; attempt++ {
if err := ctx.Err(); err != nil {
return nil, err
}
if attempt > 0 {
timer := time.NewTimer((250 * time.Millisecond) << (attempt - 1))
select {
case <-ctx.Done():
timer.Stop()
return nil, ctx.Err()
case <-timer.C:
}
}
data, retry, err := s.readArchiveChunkOnce(ctx, key, etag, start, end, total)
if err == nil {
return data, nil
}
if !retry {
return nil, err
}
lastErr = err
}
return nil, fmt.Errorf("read archive bytes %d-%d after %d attempts: %w", start, end, archiveReadAttempts, lastErr)
}
func (s *Store) readArchiveChunkOnce(ctx context.Context, key, etag string, start, end, total int64) ([]byte, bool, error) {
requestCtx, cancel := context.WithTimeout(ctx, 2*time.Minute)
defer cancel()
object, err := s.client.GetObject(requestCtx, &s3.GetObjectInput{
Bucket: aws.String(s.bucket), Key: aws.String(key), IfMatch: aws.String(etag),
Range: aws.String(fmt.Sprintf("bytes=%d-%d", start, end)),
}, func(o *s3.Options) {
// This loop owns both HTTP and interrupted-body retries: at most five
// wire requests per chunk, rather than five times the SDK's attempts.
o.RetryMaxAttempts = 1
})
if err != nil {
var networkError net.Error
var responseError *awshttp.ResponseError
throttled := errors.As(err, &responseError) && responseError.HTTPStatusCode() == http.StatusTooManyRequests
shouldRetry := throttled || retry.NewStandard().IsErrorRetryable(err) || errors.As(err, &networkError) || errors.Is(err, io.EOF) || errors.Is(err, io.ErrUnexpectedEOF) || errors.Is(err, context.DeadlineExceeded)
return nil, shouldRetry, fmt.Errorf("read archive range: %w", err)
}
defer object.Body.Close()
want := end - start + 1
if aws.ToString(object.ETag) != etag || aws.ToString(object.ContentRange) != fmt.Sprintf("bytes %d-%d/%d", start, end, total) || object.ContentLength == nil || *object.ContentLength != want {
return nil, false, errors.New("remote archive changed or returned an invalid byte range; source data retained")
}
data, err := io.ReadAll(io.LimitReader(object.Body, want+1))
if err != nil {
return nil, true, err
}
if int64(len(data)) < want {
return nil, true, io.ErrUnexpectedEOF
}
if int64(len(data)) != want {
return nil, false, errors.New("remote archive range exceeds its declared size")
}
return data, false, nil
}
func (s *Store) Download(ctx context.Context, uri, filename, checksum string, size int64) (err error) {
key, err := s.key(uri)
if err != nil {
return err
}
if size <= 0 {
return errors.New("invalid archive size")
}
f, err := os.OpenFile(filename, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600)
if err != nil {
return err
}
defer func() {
err = errors.Join(err, f.Close())
if err != nil {
_ = os.Remove(filename)
}
}()
if err = s.readVerified(ctx, key, f, checksum, size, false); err != nil {
return err
}
return f.Sync()
}
func (s *Store) Delete(ctx context.Context, uri string) error {
key, err := s.key(uri)
if err != nil {
return err
}
_, err = s.client.DeleteObject(ctx, &s3.DeleteObjectInput{Bucket: aws.String(s.bucket), Key: aws.String(key)})
return err
}
+420
View File
@@ -0,0 +1,420 @@
package archivestore
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"strings"
"sync"
"sync/atomic"
"testing"
)
func TestS3RoundTripAndIntegrity(t *testing.T) {
for _, sse := range []string{"AES256", "aws:kms"} {
kms := ""
if sse == "aws:kms" {
kms = "arn:aws:kms:us-east-1:123456789012:key/test-key"
}
for _, size := range []int{1024, 10 << 20} {
t.Run(sse+"/"+strconv.Itoa(size), func(t *testing.T) {
var mu sync.Mutex
var object []byte
parts := map[int][]byte{}
corrupt, multipart := false, false
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
mu.Lock()
defer mu.Unlock()
q := r.URL.Query()
if (r.Method == "PUT" && !q.Has("partNumber")) || (r.Method == "POST" && q.Has("uploads")) {
if r.Header.Get("X-Amz-Server-Side-Encryption") != sse || r.Header.Get("X-Amz-Server-Side-Encryption-Aws-Kms-Key-Id") != kms {
t.Error("upload did not explicitly request the configured encryption")
}
}
if r.Method == "HEAD" {
if r.Header.Get("X-Amz-Server-Side-Encryption") != "" {
t.Error("encryption write header leaked into HEAD")
}
w.Header().Set("X-Amz-Server-Side-Encryption", sse)
if kms != "" {
w.Header().Set("X-Amz-Server-Side-Encryption-Aws-Kms-Key-Id", kms)
}
}
w.Header().Set("ETag", `"test-etag"`)
switch {
case r.Method == "POST" && q.Has("uploads"):
multipart = true
fmt.Fprint(w, `<InitiateMultipartUploadResult><UploadId>test-upload</UploadId></InitiateMultipartUploadResult>`)
case r.Method == "PUT" && q.Has("partNumber"):
n, _ := strconv.Atoi(q.Get("partNumber"))
parts[n], _ = io.ReadAll(r.Body)
case r.Method == "POST" && q.Has("uploadId"):
for i := 1; i <= len(parts); i++ {
object = append(object, parts[i]...)
}
fmt.Fprint(w, `<CompleteMultipartUploadResult><ETag>test-etag</ETag></CompleteMultipartUploadResult>`)
case r.Method == "PUT":
object, _ = io.ReadAll(r.Body)
case r.Method == "HEAD":
w.Header().Set("Content-Length", strconv.Itoa(len(object)))
case r.Method == "GET":
data := object
if corrupt {
data = bytes.Clone(object)
data[0] ^= 0xff
}
serveArchiveRange(t, w, r, data)
case r.Method == "DELETE":
object = nil
w.WriteHeader(204)
default:
t.Errorf("unexpected request %s %s", r.Method, r.URL)
w.WriteHeader(400)
}
}))
defer srv.Close()
store, err := New(Config{Endpoint: srv.URL, Bucket: "test-bucket", Prefix: "test/tasks", AccessKey: "test", SecretKey: "test", PathStyle: true, SSE: sse, KMSKeyID: kms})
if err != nil {
t.Fatal(err)
}
data := bytes.Repeat([]byte{0x42}, size)
h := sha256.Sum256(data)
checksum := hex.EncodeToString(h[:])
root := t.TempDir()
source := filepath.Join(root, "source")
if err := os.WriteFile(source, data, 0600); err != nil {
t.Fatal(err)
}
uri := store.URI(1, 2, checksum)
ctx := context.Background()
if err := store.Upload(ctx, uri, source, checksum); err != nil {
t.Fatal(err)
}
if multipart != (size > 8<<20) {
t.Fatalf("multipart=%v size=%d", multipart, size)
}
dest := filepath.Join(root, "download")
if err := store.Download(ctx, uri, dest, checksum, int64(size)); err != nil {
t.Fatal(err)
}
got, _ := os.ReadFile(dest)
if !bytes.Equal(got, data) {
t.Fatal("download differs")
}
mu.Lock()
corrupt = true
mu.Unlock()
bad := filepath.Join(root, "bad")
if err := store.Download(ctx, uri, bad, checksum, int64(size)); err == nil {
t.Fatal("accepted corrupt object")
}
if _, err := os.Stat(bad); !os.IsNotExist(err) {
t.Fatal("left corrupt download")
}
if err := store.Upload(ctx, uri, source, checksum); err == nil {
t.Fatal("upload accepted failed readback")
}
if err := store.Delete(ctx, uri); err != nil {
t.Fatal(err)
}
})
}
}
}
func serveArchiveRange(t *testing.T, w http.ResponseWriter, r *http.Request, data []byte) {
t.Helper()
var start, end int64
if n, err := fmt.Sscanf(r.Header.Get("Range"), "bytes=%d-%d", &start, &end); err != nil || n != 2 || start < 0 || end < start || end >= int64(len(data)) {
t.Errorf("invalid range %q", r.Header.Get("Range"))
w.WriteHeader(http.StatusRequestedRangeNotSatisfiable)
return
}
if r.Header.Get("If-Match") != `"test-etag"` {
t.Errorf("missing object version condition: %q", r.Header.Get("If-Match"))
w.WriteHeader(http.StatusPreconditionFailed)
return
}
w.Header().Set("ETag", `"test-etag"`)
w.Header().Set("Content-Length", strconv.FormatInt(end-start+1, 10))
w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", start, end, len(data)))
w.WriteHeader(http.StatusPartialContent)
_, _ = w.Write(data[start : end+1])
}
func TestS3ReadbackRetriesInterruptedRange(t *testing.T) {
data := append(bytes.Repeat([]byte{0x42}, int(archiveReadChunkSize)), bytes.Repeat([]byte{0x73}, 1024)...)
var mu sync.Mutex
var ranges []string
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
mu.Lock()
defer mu.Unlock()
w.Header().Set("ETag", `"test-etag"`)
if r.Method == "HEAD" {
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
return
}
ranges = append(ranges, r.Header.Get("Range"))
if len(ranges) == 2 {
w.Header().Set("Content-Length", strconv.FormatInt(int64(len(data))-archiveReadChunkSize, 10))
w.Header().Set("Content-Range", fmt.Sprintf("bytes %d-%d/%d", archiveReadChunkSize, len(data)-1, len(data)))
w.WriteHeader(http.StatusPartialContent)
_, _ = w.Write(data[archiveReadChunkSize : archiveReadChunkSize+128]) // Close during a later chunk.
return
}
serveArchiveRange(t, w, r, data)
}))
defer srv.Close()
store := testRangeStore(t, srv.URL)
h := sha256.Sum256(data)
checksum := hex.EncodeToString(h[:])
dest := filepath.Join(t.TempDir(), "archive")
if err := store.Download(context.Background(), store.URI(1, 2, checksum), dest, checksum, int64(len(data))); err != nil {
t.Fatal(err)
}
got, err := os.ReadFile(dest)
if err != nil || !bytes.Equal(got, data) {
t.Fatalf("retried download differs: %v", err)
}
mu.Lock()
defer mu.Unlock()
if len(ranges) != 3 || ranges[1] != ranges[2] || ranges[0] != fmt.Sprintf("bytes=0-%d", archiveReadChunkSize-1) || ranges[2] != fmt.Sprintf("bytes=%d-%d", archiveReadChunkSize, len(data)-1) {
t.Fatalf("retry did not stay within the interrupted range: %v", ranges)
}
}
func testRangeStore(t *testing.T, endpoint string) *Store {
t.Helper()
s, err := New(Config{Endpoint: endpoint, Bucket: "test-bucket", Prefix: "test/tasks", AccessKey: "test", SecretKey: "test", PathStyle: true})
if err != nil {
t.Fatal(err)
}
return s
}
func TestS3ReadbackRejectsInvalidRangesAndExhaustedRetries(t *testing.T) {
for _, mode := range []string{"ignored-range", "changed-etag", "changed-object", "truncated"} {
t.Run(mode, func(t *testing.T) {
data := bytes.Repeat([]byte{0x42}, 1024)
var mu sync.Mutex
gets := 0
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
mu.Lock()
defer mu.Unlock()
w.Header().Set("ETag", `"test-etag"`)
if r.Method == "HEAD" {
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
return
}
gets++
if mode == "changed-object" {
w.WriteHeader(http.StatusPreconditionFailed)
return
}
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
if mode == "ignored-range" {
_, _ = w.Write(data)
return
}
if mode == "changed-etag" {
w.Header().Set("ETag", `"different-object"`)
}
w.Header().Set("Content-Range", fmt.Sprintf("bytes 0-%d/%d", len(data)-1, len(data)))
w.WriteHeader(http.StatusPartialContent)
if mode == "truncated" {
_, _ = w.Write(data[:128])
} else {
_, _ = w.Write(data)
}
}))
defer srv.Close()
store := testRangeStore(t, srv.URL)
h := sha256.Sum256(data)
checksum := hex.EncodeToString(h[:])
dest := filepath.Join(t.TempDir(), "archive")
if err := store.Download(context.Background(), store.URI(1, 2, checksum), dest, checksum, int64(len(data))); err == nil {
t.Fatal("accepted invalid or incomplete readback")
}
if _, err := os.Stat(dest); !os.IsNotExist(err) {
t.Fatal("left a failed download on disk")
}
mu.Lock()
defer mu.Unlock()
want := 1
if mode == "truncated" {
want = archiveReadAttempts
}
if gets != want {
t.Fatalf("GET count %d, want %d", gets, want)
}
})
}
}
type failedArchiveWriter struct{ err error }
func (w failedArchiveWriter) Write([]byte) (int, error) { return 0, w.err }
func TestS3ReadbackPropagatesOutputFailure(t *testing.T) {
data := []byte("test archive")
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("ETag", `"test-etag"`)
if r.Method == "HEAD" {
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
return
}
serveArchiveRange(t, w, r, data)
}))
defer srv.Close()
store := testRangeStore(t, srv.URL)
h := sha256.Sum256(data)
outputError := errors.New("output disk full")
err := store.readVerified(context.Background(), "test/tasks/archive", failedArchiveWriter{outputError}, hex.EncodeToString(h[:]), int64(len(data)), false)
if !errors.Is(err, outputError) {
t.Fatalf("lost output error: %v", err)
}
}
func TestS3ReadbackStopsOnCancellation(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
data := bytes.Repeat([]byte{0x42}, 1024)
gets := make(chan struct{}, archiveReadAttempts+1)
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Header().Set("ETag", `"test-etag"`)
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
if r.Method == "HEAD" {
return
}
gets <- struct{}{}
w.Header().Set("Content-Range", fmt.Sprintf("bytes 0-%d/%d", len(data)-1, len(data)))
w.WriteHeader(http.StatusPartialContent)
_, _ = w.Write(data[:128])
w.(http.Flusher).Flush()
cancel()
}))
defer srv.Close()
store := testRangeStore(t, srv.URL)
h := sha256.Sum256(data)
checksum := hex.EncodeToString(h[:])
dest := filepath.Join(t.TempDir(), "archive")
err := store.Download(ctx, store.URI(1, 2, checksum), dest, checksum, int64(len(data)))
if !errors.Is(err, context.Canceled) || len(gets) != 1 {
t.Fatalf("cancellation was not honored: error=%v GETs=%d", err, len(gets))
}
if _, err := os.Stat(dest); !os.IsNotExist(err) {
t.Fatal("left a cancelled download on disk")
}
}
func TestS3RejectsForeignLocations(t *testing.T) {
s, err := New(Config{Endpoint: "https://sfo3.digitaloceanspaces.com", Bucket: "allowed", Prefix: "archives/tasks", AccessKey: "test", SecretKey: "test"})
if err != nil {
t.Fatal(err)
}
for _, uri := range []string{"s3://other/archives/tasks/a", "s3://allowed/archives/other/a", "s3://allowed/archives/tasks/../a", "s3://allowed/archives/tasks/%2e%2e/a", "s3://allowed/archives/tasks/a?secret=x", "s3://user@allowed/archives/tasks/a", "file:///etc/passwd"} {
if err := s.Validate(uri); err == nil {
t.Errorf("accepted %s", uri)
}
}
var absent *Store
if absent.Validate("s3://allowed/archives/tasks/a") == nil {
t.Fatal("missing config accepted")
}
}
func TestS3UploadRejectsUnconfirmedEncryption(t *testing.T) {
for _, mode := range []string{"missing", "different", "kms-without-key"} {
t.Run(mode, func(t *testing.T) {
data := []byte("private archive")
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case "PUT":
_, _ = io.Copy(io.Discard, r.Body)
case "DELETE":
w.WriteHeader(204)
case "HEAD":
w.Header().Set("ETag", `"test-etag"`)
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
if mode != "missing" {
w.Header().Set("X-Amz-Server-Side-Encryption", "aws:kms")
}
default:
t.Errorf("content must not be accepted before encryption confirmation: %s", r.Method)
w.WriteHeader(400)
}
}))
defer srv.Close()
c := Config{Endpoint: srv.URL, Bucket: "test", Prefix: "tasks", AccessKey: "test", SecretKey: "test", PathStyle: true}
if mode == "kms-without-key" {
c.SSE = "aws:kms"
}
store, err := New(c)
if err != nil {
t.Fatal(err)
}
filename := filepath.Join(t.TempDir(), "source")
if err := os.WriteFile(filename, data, 0600); err != nil {
t.Fatal(err)
}
sum := sha256.Sum256(data)
checksum := hex.EncodeToString(sum[:])
if err := store.Upload(context.Background(), store.URI(1, 2, checksum), filename, checksum); err == nil || !strings.Contains(err.Error(), "encryption") {
t.Fatalf("unconfirmed encryption accepted: %v", err)
}
if got, err := os.ReadFile(filename); err != nil || !bytes.Equal(got, data) {
t.Fatal("source was not retained", err)
}
})
}
}
func TestS3MultipartFailureAbortsUpload(t *testing.T) {
var aborted atomic.Bool
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
q := r.URL.Query()
switch {
case r.Method == "POST" && q.Has("uploads"):
if r.Header.Get("X-Amz-Server-Side-Encryption") != "AES256" {
t.Error("multipart encryption missing")
}
fmt.Fprint(w, `<InitiateMultipartUploadResult><UploadId>failed-upload</UploadId></InitiateMultipartUploadResult>`)
case r.Method == "PUT" && q.Has("partNumber"):
_, _ = io.Copy(io.Discard, r.Body)
w.WriteHeader(403)
case r.Method == "DELETE" && q.Get("uploadId") == "failed-upload":
aborted.Store(true)
w.WriteHeader(204)
default:
t.Errorf("unexpected failed-upload request: %s", r.Method)
w.WriteHeader(400)
}
}))
defer srv.Close()
store := testRangeStore(t, srv.URL)
data := bytes.Repeat([]byte("x"), 9<<20)
checksum := sha256.Sum256(data)
sum := hex.EncodeToString(checksum[:])
filename := filepath.Join(t.TempDir(), "source")
if err := os.WriteFile(filename, data, 0600); err != nil {
t.Fatal(err)
}
if err := store.Upload(context.Background(), store.URI(1, 2, sum), filename, sum); err == nil {
t.Fatal("failed part accepted")
}
if !aborted.Load() {
t.Fatal("failed multipart upload was not aborted")
}
if info, err := os.Stat(filename); err != nil || info.Size() != int64(len(data)) {
t.Fatal("source was not retained", err)
}
}
+231
View File
@@ -0,0 +1,231 @@
package archivestore
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"encoding/pem"
"errors"
"fmt"
"io"
"net/http"
"net/http/httptest"
"os"
"path/filepath"
"strconv"
"strings"
"sync/atomic"
"testing"
)
func archiveSource(t *testing.T, data []byte) (string, string) {
t.Helper()
filename := filepath.Join(t.TempDir(), "source")
if err := os.WriteFile(filename, data, 0600); err != nil {
t.Fatal(err)
}
sum := sha256.Sum256(data)
return filename, hex.EncodeToString(sum[:])
}
func TestS3VerificationFailureCleansUploadedVersion(t *testing.T) {
for _, failure := range []string{"wrong-kms", "checksum", "cancelled", "delete-denied"} {
t.Run(failure, func(t *testing.T) {
data := []byte("private archive")
source, checksum := archiveSource(t, data)
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
var present, deleted atomic.Bool
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
switch r.Method {
case "PUT":
_, _ = io.Copy(io.Discard, r.Body)
present.Store(true)
w.Header().Set("X-Amz-Version-Id", "uploaded-version")
case "HEAD":
w.Header().Set("ETag", `"test-etag"`)
w.Header().Set("Content-Length", strconv.Itoa(len(data)))
w.Header().Set("X-Amz-Server-Side-Encryption", "aws:kms")
kms := "arn:aws:kms:us-east-1:123456789012:key/expected"
if failure == "wrong-kms" {
kms = "arn:aws:kms:us-east-1:123456789012:key/different"
}
w.Header().Set("X-Amz-Server-Side-Encryption-Aws-Kms-Key-Id", kms)
if failure == "cancelled" {
cancel()
}
case "GET":
corrupt := bytes.Clone(data)
corrupt[0] ^= 0xff
serveArchiveRange(t, w, r, corrupt)
case "DELETE":
if r.URL.Query().Get("versionId") != "uploaded-version" {
t.Error("cleanup did not target uploaded version")
}
deleted.Store(true)
if failure == "delete-denied" {
w.WriteHeader(403)
return
}
present.Store(false)
w.WriteHeader(204)
default:
t.Errorf("unexpected request %s", r.Method)
w.WriteHeader(400)
}
}))
defer srv.Close()
store, err := New(Config{Endpoint: srv.URL, Bucket: "test", AccessKey: "test", SecretKey: "test", PathStyle: true,
SSE: "aws:kms", KMSKeyID: "arn:aws:kms:us-east-1:123456789012:key/expected"})
if err != nil {
t.Fatal(err)
}
err = store.Upload(ctx, store.URI(1, 2, checksum), source, checksum)
if err == nil {
t.Fatal("accepted failed verification")
}
if failure == "wrong-kms" && !strings.Contains(err.Error(), "encryption") {
t.Fatal(err)
}
if failure == "cancelled" && !errors.Is(err, context.Canceled) {
t.Fatal(err)
}
if failure == "delete-denied" && (!strings.Contains(err.Error(), "SHA-256") || !strings.Contains(err.Error(), "delete unverified archive")) {
t.Fatalf("verification and cleanup errors must both survive: %v", err)
}
if !deleted.Load() || present.Load() != (failure == "delete-denied") {
t.Fatal("unverified object cleanup was not attempted/completed")
}
if got, readErr := os.ReadFile(source); readErr != nil || !bytes.Equal(got, data) {
t.Fatal("source changed", readErr)
}
})
}
}
func TestS3CancelledMultipartAbortsWithFreshContext(t *testing.T) {
for _, denyAbort := range []bool{false, true} {
t.Run(strconv.FormatBool(denyAbort), func(t *testing.T) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
var aborted atomic.Bool
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
q := r.URL.Query()
switch {
case r.Method == "POST" && q.Has("uploads"):
fmt.Fprint(w, `<InitiateMultipartUploadResult><UploadId>cancelled-upload</UploadId></InitiateMultipartUploadResult>`)
case r.Method == "PUT" && q.Has("partNumber"):
cancel()
_, _ = io.Copy(io.Discard, r.Body)
w.WriteHeader(403)
case r.Method == "DELETE" && q.Get("uploadId") == "cancelled-upload":
aborted.Store(true)
if denyAbort {
w.WriteHeader(403)
} else {
w.WriteHeader(204)
}
default:
t.Errorf("unexpected request %s", r.Method)
w.WriteHeader(400)
}
}))
defer srv.Close()
data := bytes.Repeat([]byte("x"), 9<<20)
source, sum := archiveSource(t, data)
store := testRangeStore(t, srv.URL)
err := store.Upload(ctx, store.URI(1, 2, sum), source, sum)
if !errors.Is(err, context.Canceled) || !aborted.Load() {
t.Fatalf("cancelled upload not aborted: %v", err)
}
if denyAbort && !strings.Contains(err.Error(), "abort archive multipart upload") {
t.Fatalf("cleanup failure lost: %v", err)
}
if got, readErr := os.ReadFile(source); readErr != nil || !bytes.Equal(got, data) {
t.Fatal("source changed", readErr)
}
})
}
}
func TestS3SignedRequestsNeverFollowRedirects(t *testing.T) {
var reached atomic.Int32
target := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { reached.Add(1); w.WriteHeader(204) }))
defer target.Close()
for _, status := range []int{301, 302, 303, 307, 308} {
t.Run(strconv.Itoa(status), func(t *testing.T) {
origin := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if r.Header.Get("Authorization") == "" || r.Header.Get("X-Amz-Security-Token") != "fixture-session" {
t.Error("fixture request must be signed with session credentials")
}
w.Header().Set("Location", target.URL+"/redirected")
w.WriteHeader(status)
}))
defer origin.Close()
store, err := New(Config{Endpoint: origin.URL, Bucket: "test", AccessKey: "test", SecretKey: "test", SessionToken: "fixture-session", PathStyle: true})
if err != nil {
t.Fatal(err)
}
if err := store.Delete(context.Background(), store.URI(1, 2, "test")); err == nil {
t.Fatal("redirect accepted")
}
if reached.Load() != 0 {
t.Fatal("signed request followed redirect")
}
})
}
}
func TestS3CustomCABundleForBothCredentialModes(t *testing.T) {
srv := httptest.NewTLSServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.WriteHeader(204) }))
defer srv.Close()
for _, explicit := range []bool{false, true} {
t.Run(strconv.FormatBool(explicit), func(t *testing.T) {
isolateAWSCredentials(t)
ca := filepath.Join(t.TempDir(), "ca.pem")
if err := os.WriteFile(ca, pem.EncodeToMemory(&pem.Block{Type: "CERTIFICATE", Bytes: srv.Certificate().Raw}), 0600); err != nil {
t.Fatal(err)
}
t.Setenv("AWS_CA_BUNDLE", ca)
c := Config{Endpoint: srv.URL, Bucket: "test", PathStyle: true}
if explicit {
c.AccessKey, c.SecretKey = "fixture", "fixture"
} else {
t.Setenv("AWS_ACCESS_KEY_ID", "fixture")
t.Setenv("AWS_SECRET_ACCESS_KEY", "fixture")
}
store, err := New(c)
if err != nil {
t.Fatal(err)
}
if err := store.Delete(context.Background(), store.URI(1, 2, "test")); err != nil {
t.Fatalf("configured CA not used: %v", err)
}
})
}
}
func TestS3RangeRetriesHaveOneWireAttemptEach(t *testing.T) {
for _, status := range []int{403, 429, 503} {
t.Run(strconv.Itoa(status), func(t *testing.T) {
var gets atomic.Int32
srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
gets.Add(1)
w.WriteHeader(status)
}))
defer srv.Close()
store := testRangeStore(t, srv.URL)
if _, err := store.readArchiveChunk(context.Background(), "key", `"etag"`, 0, 9, 10); err == nil {
t.Fatal("failed request accepted")
}
want := int32(archiveReadAttempts)
if status == 403 {
want = 1
}
if got := gets.Load(); got != want {
t.Fatalf("wire requests=%d want=%d", got, want)
}
})
}
}
+64
View File
@@ -0,0 +1,64 @@
// artex-archive-check tests the configured object store without touching tasks.
package main
import (
"context"
"crypto/sha256"
"encoding/hex"
"fmt"
"log"
"os"
"path/filepath"
"time"
"github.com/Autumn-27/artex/archivestore"
)
func main() {
if err := check(); err != nil {
log.Fatal(err)
}
}
func check() error {
s, err := archivestore.FromEnv()
if err != nil {
return err
}
if s == nil {
return fmt.Errorf("S3 archive storage is not configured")
}
dir, err := os.MkdirTemp("", "artex-archive-check-")
if err != nil {
return err
}
defer os.RemoveAll(dir)
data := []byte("ARTEX object storage connectivity check " + time.Now().UTC().Format(time.RFC3339Nano))
h := sha256.Sum256(data)
checksum := hex.EncodeToString(h[:])
uri := s.URI(0, time.Now().UnixNano(), checksum)
file := filepath.Join(dir, "check")
if err := os.WriteFile(file, data, 0600); err != nil {
return err
}
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
defer func() {
cleanup, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
if err := s.Delete(cleanup, uri); err != nil {
log.Printf("test object cleanup failed for %s: %v", uri, err)
}
}()
if err := s.Upload(ctx, uri, file, checksum); err != nil {
return err
}
if err := s.Download(ctx, uri, filepath.Join(dir, "download"), checksum, int64(len(data))); err != nil {
return err
}
if err := s.Delete(ctx, uri); err != nil {
return err
}
fmt.Println("S3 upload, full SHA-256 verification, download and delete passed")
return nil
}
+19
View File
@@ -4,6 +4,11 @@ go 1.26.10
require (
github.com/Autumn-27/norma v0.4.11
github.com/aws/aws-sdk-go-v2 v1.47.5
github.com/aws/aws-sdk-go-v2/config v1.33.13
github.com/aws/aws-sdk-go-v2/credentials v1.20.13
github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.23.19
github.com/aws/aws-sdk-go-v2/service/s3 v1.114.6
github.com/golang-jwt/jwt/v5 v5.3.1
github.com/google/uuid v1.6.0
github.com/gorilla/websocket v1.5.3
@@ -22,6 +27,20 @@ require (
require (
github.com/andybalholm/brotli v1.2.1 // indirect
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.25 // indirect
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.5 // indirect
github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.8 // indirect
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.8 // indirect
github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.8 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.23 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.9 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.8 // indirect
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.8 // indirect
github.com/aws/aws-sdk-go-v2/service/signin v1.12.1 // indirect
github.com/aws/aws-sdk-go-v2/service/sso v1.39.1 // indirect
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.1 // indirect
github.com/aws/aws-sdk-go-v2/service/sts v1.51.6 // indirect
github.com/aws/smithy-go v1.28.7 // indirect
github.com/aymerick/douceur v0.2.0 // indirect
github.com/creack/pty v1.1.24 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
+38
View File
@@ -4,6 +4,44 @@ github.com/andybalholm/brotli v1.2.1 h1:R+f5xP285VArJDRgowrfb9DqL18yVK0gKAW/F+eT
github.com/andybalholm/brotli v1.2.1/go.mod h1:rzTDkvFWvIrjDXZHkuS16NPggd91W3kUSvPlQ1pLaKY=
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 h1:DklsrG3dyBCFEj5IhUbnKptjxatkF07cF2ak3yi77so=
github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2/go.mod h1:WaHUgvxTVq04UNunO+XhnAqY/wQc+bxr74GqbsZ/Jqw=
github.com/aws/aws-sdk-go-v2 v1.47.5 h1:5yA+A+BiXbDq1ZLbYwPViwhEGDMdR0MEhL8Jh2LnLS4=
github.com/aws/aws-sdk-go-v2 v1.47.5/go.mod h1:iNIkogrRvFwm+1OQIUOP2lPBtlXZboOIUWiCa+pHEMw=
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.25 h1:MW0Iql1SOTgQPj8mCxrU/eH/K/AIDWi08ItOsXaWRLU=
github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.25/go.mod h1:+ucVYmHYB3JqVueY0E1RHahdXAnKQbIHqybSbvOUbOM=
github.com/aws/aws-sdk-go-v2/config v1.33.13 h1:u52x6ISQOx172tpwM0VRxhJzEsTJYpMcEYUGM2A1wrw=
github.com/aws/aws-sdk-go-v2/config v1.33.13/go.mod h1:/ixtz6XPHb42zekjQ0LqD9XjTpTysNWhIGwufY1OzI4=
github.com/aws/aws-sdk-go-v2/credentials v1.20.13 h1:j4z41OtspmQ3ftQycaDunJ26b69a9SHfaSVUPqgRv8k=
github.com/aws/aws-sdk-go-v2/credentials v1.20.13/go.mod h1:SgPA1oS3b+dlMxZb618jDmGNscpXSCaxz15igS52OlE=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.5 h1:iXjy2SFhGYNB1jWZBhQqq8HbhsbPF23w+/zbMvPXsTg=
github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.20.5/go.mod h1:k0RUiBnyXU0AXRJ9tJmY2jQke6XUIX2PNVnWtvgaPtc=
github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.23.19 h1:+JWfo9Mkg5HWwDwnpRPu7WNiiyEmiQRTaNSFsZ/1KIY=
github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.23.19/go.mod h1:l4/tI+TfymypMqq2oRCkhMAB7Gi7nlt5JaoUUz+cUbI=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.8 h1:gzIWc3DTPfPbWKrQnmL6BV6WD7NPD1htxzgdk/bQ/Z4=
github.com/aws/aws-sdk-go-v2/internal/configsources v1.5.8/go.mod h1:vvUA5cDAZWGo4R14FZPZfXfJCmgsafOWEq78Kg0D+ug=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.8 h1:PWv+vG8aCLS8qd+HPdYhK7Vees90aKHWFFQ1AGYD/8E=
github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.8.8/go.mod h1:xxPZEpflYHJA12366ZGyq66z9dHPCoeCIu99Jck+MPw=
github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.8 h1:WOp5De9iWdEHDPh2Kb0tBP3vGBm/dVAuRGh4a4tqduo=
github.com/aws/aws-sdk-go-v2/internal/v4a v1.5.8/go.mod h1:z8W8YgfhbWl62XqcTtK+CxPrE+iHGRVUOtrrbIOp7ZY=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.23 h1:MCIR6iZaCKO4UE0hUvoWWLI6JVjppopV64JfAJaMjng=
github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.23/go.mod h1:pphWFS+z0MmIPivj8c/6bATd1Z+Av7Ust75DPdEFsPA=
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.9 h1:GACgECI422Xt5n4Pojr3O0aocPv8lfH4PJe2Aon5Wv8=
github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.11.9/go.mod h1:lPfnRkHpn1qWZJLbVEw10rIqSuCee1pNQTyGkUjAYh8=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.8 h1:+PMpWlJYOn2tm7sm6OZ/ZLd4jStl17T7wjNapd1Rczs=
github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.14.8/go.mod h1:cnG3xZLGQL4c/bt8pjdzlFtZsW7epBBuNS04a5xMjdo=
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.8 h1:RS1Wt+K0r4X0ci9Vf4JYTUfHzsQihYA2LgGJeEneKpk=
github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.20.8/go.mod h1:adMnTy5kyoUW86jhXnGSVc/mvMQI4GZd1qYWMeaS8M8=
github.com/aws/aws-sdk-go-v2/service/s3 v1.114.6 h1:to7+Vr3rLkpYRwVKJ5QRriI0eE306vrVN/6TnVHgxvY=
github.com/aws/aws-sdk-go-v2/service/s3 v1.114.6/go.mod h1:Jc89ASa2k7HMAskj3bSnt8bf+k+p2IApzkoXnEjkgUw=
github.com/aws/aws-sdk-go-v2/service/signin v1.12.1 h1:WZLC+k/CZx11kZGQDqu9mpA8yhiXGX2I//jhuJE1FDo=
github.com/aws/aws-sdk-go-v2/service/signin v1.12.1/go.mod h1:wxAk0D2oVBSjuXEIzvcKxTZfM90zticdAbh/VD42L0Y=
github.com/aws/aws-sdk-go-v2/service/sso v1.39.1 h1:4VB/dnDo7pmXSLQMszSoBzWndENuc7mzwTpD6lQn77A=
github.com/aws/aws-sdk-go-v2/service/sso v1.39.1/go.mod h1:UGsEYgWz4Gi+46vDQ5zkFLqUgJziyOE2SXjZjgmfmHc=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.1 h1:w8yui2ZqdHmGwVBDGvazoIvKw/DnLENBLkYnN8q8iqo=
github.com/aws/aws-sdk-go-v2/service/ssooidc v1.44.1/go.mod h1:gJSdIY6YUzDvqQLcMtPVZgBRHrFwzHryvpE8Igzbxps=
github.com/aws/aws-sdk-go-v2/service/sts v1.51.6 h1:BVjKrtRUtSYKztBCCfE1oAB+d3ViKcW2cKZfserOqMQ=
github.com/aws/aws-sdk-go-v2/service/sts v1.51.6/go.mod h1:eSukFLeLkPMm+1OxDR+F0joauZdyBkF47Ow7MqjZiJw=
github.com/aws/smithy-go v1.28.7 h1:h/n1SHrwVtaDYLz8mR1/Kq4Xh4RaFbFW7bOYckg9mfE=
github.com/aws/smithy-go v1.28.7/go.mod h1:YE2RhdIuDbA5E5bTdciG9KrW3+TiEONeUWCqxX9i1Fc=
github.com/aymerick/douceur v0.2.0 h1:Mv+mAeH1Q+n9Fr+oyamOlAkUNPWPlA8PPGR0QAaYuPk=
github.com/aymerick/douceur v0.2.0/go.mod h1:wlT5vV2O3h55X9m7iVYN0TBM0NH/MmbLnd30/FjWUq4=
github.com/creack/pty v1.1.24 h1:bJrF4RRfyJnbTJqzRLHzcGaZK1NeM5kTC9jGgovnR1s=