SeaweedFS is a distributed storage system for object storage (S3), file systems, Iceberg table buckets, and Lance vector buckets, designed to handle billions of files with O(1) disk access and effortless horizontal scaling.
Go blob-storagecloud-drivedistributed-file-systemdistributed-storageerasure-codingfusehadoop-hdfshdfskuberneteslancelancedbobject-storageposixs3s3-storageseaweedfstiered-file-systemvector-search
package s3api
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"testing"
"time"
"github.com/gorilla/mux"
iamlib "github.com/seaweedfs/seaweedfs/weed/iam"
"github.com/seaweedfs/seaweedfs/weed/s3api/s3_constants"
"github.com/seaweedfs/seaweedfs/weed/s3api/s3err"
"github.com/stretchr/testify/require"
)
func TestObjectLockRoutesUseDedicatedActions(t *testing.T) {
bindings := handlerActionBindings(t)
for _, tc := range []struct{ handler, want string }{
{"GetObjectRetentionHandler", "ACTION_GET_OBJECT_RETENTION"},
{"PutObjectRetentionHandler", "ACTION_PUT_OBJECT_RETENTION"},
{"GetObjectLegalHoldHandler", "ACTION_GET_OBJECT_LEGAL_HOLD"},
{"PutObjectLegalHoldHandler", "ACTION_PUT_OBJECT_LEGAL_HOLD"},
{"GetObjectLockConfigurationHandler", "ACTION_GET_BUCKET_OBJECT_LOCK_CONFIG"},
{"PutObjectLockConfigurationHandler", "ACTION_PUT_BUCKET_OBJECT_LOCK_CONFIG"},
} {
if got := bindings[tc.handler]; got != tc.want {
t.Errorf("%s is gated on %s, want %s", tc.handler, got, tc.want)
}
}
}
func TestGovernanceBypassUsesDedicatedAuthorization(t *testing.T) {
for _, tc := range []struct {
name string
action Action
allowed bool
}{
{"dedicated permission", Action(s3_constants.ACTION_BYPASS_GOVERNANCE_RETENTION + ":test-bucket/*"), true},
{"coarse write", Action(s3_constants.ACTION_WRITE + ":test-bucket/*"), false},
{"admin", Action(s3_constants.ACTION_ADMIN), true},
} {
t.Run(tc.name, func(t *testing.T) {
iam := newTestIAM()
iam.identities[0].Actions = []Action{tc.action}
iam.identities[0].Account = &Account{Id: "test-account"}
s3a := &S3ApiServer{iam: iam}
req := httptest.NewRequest(http.MethodDelete, "http://localhost:8333/test-bucket/test-object", nil)
req = mux.SetURLVars(req, map[string]string{"bucket": "test-bucket", "object": "test-object"})
require.NoError(t, signRawHTTPRequest(context.Background(), req,
"AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", "us-east-1"))
if got := s3a.checkGovernanceBypassPermission(req, "test-bucket", "/test-object"); got != tc.allowed {
t.Errorf("checkGovernanceBypassPermission() = %v, want %v", got, tc.allowed)
}
})
}
}
// The bypass check authorizes against a synthetic request shaped like the
// real one; DELETE ?versionId used to re-resolve to s3:DeleteObjectVersion,
// so the delete-version grant silently satisfied the bypass check.
func TestGovernanceBypassDoesNotInheritDeleteObjectVersion(t *testing.T) {
iam := &IdentityAccessManagement{}
require.NoError(t, iam.PutPolicy("DeleteVersions",
`{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["s3:DeleteObject","s3:DeleteObjectVersion"],"Resource":"arn:aws:s3:::worm/*"}]}`))
require.NoError(t, iam.PutPolicy("BypassGovernance",
`{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["s3:DeleteObject","s3:DeleteObjectVersion","s3:BypassGovernanceRetention"],"Resource":"arn:aws:s3:::worm/*"}]}`))
s3a := &S3ApiServer{iam: iam}
req := httptest.NewRequest(http.MethodDelete, "http://localhost:8333/worm/doc.txt?versionId=abc123", nil)
req = mux.SetURLVars(req, map[string]string{"bucket": "worm", "object": "doc.txt"})
req = req.WithContext(s3_constants.SetIdentityInContext(req.Context(), &Identity{
Name: "deleter",
PolicyNames: []string{"DeleteVersions"},
Account: &Account{Id: "test-account"},
}))
if s3a.checkGovernanceBypassPermission(req, "worm", "/doc.txt") {
t.Fatal("s3:DeleteObjectVersion alone satisfied the governance bypass check")
}
req = req.WithContext(s3_constants.SetIdentityInContext(req.Context(), &Identity{
Name: "breaker",
PolicyNames: []string{"BypassGovernance"},
Account: &Account{Id: "test-account"},
}))
if !s3a.checkGovernanceBypassPermission(req, "worm", "/doc.txt") {
t.Fatal("s3:BypassGovernanceRetention did not satisfy the governance bypass check")
}
}
// The object-lock request headers on PutObject/CreateMultipartUpload must be
// authorized as s3:PutObjectRetention / s3:PutObjectLegalHold; s3:PutObject
// alone used to set retention and legal hold on new versions.
func TestObjectLockHeadersRequireDedicatedActions(t *testing.T) {
iam := &IdentityAccessManagement{isAuthEnabled: true}
require.NoError(t, iam.PutPolicy("Writer",
`{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["s3:PutObject"],"Resource":"arn:aws:s3:::worm/*"}]}`))
require.NoError(t, iam.PutPolicy("Locked",
`{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["s3:PutObject","s3:PutObjectRetention","s3:PutObjectLegalHold"],"Resource":"arn:aws:s3:::worm/*"}]}`))
s3a := &S3ApiServer{iam: iam}
retainUntil := time.Now().Add(24 * time.Hour).Format(time.RFC3339)
for _, tc := range []struct {
name string
policy string
headers map[string]string
wantErr error
}{
{"writer sets retention", "Writer",
map[string]string{s3_constants.AmzObjectLockMode: "COMPLIANCE", s3_constants.AmzObjectLockRetainUntilDate: retainUntil},
ErrObjectLockNotAuthorized},
{"writer sets legal hold", "Writer",
map[string]string{s3_constants.AmzObjectLockLegalHold: s3_constants.LegalHoldOn},
ErrObjectLockNotAuthorized},
{"writer plain put", "Writer", nil, nil},
{"locked principal sets both", "Locked",
map[string]string{s3_constants.AmzObjectLockMode: "GOVERNANCE", s3_constants.AmzObjectLockRetainUntilDate: retainUntil, s3_constants.AmzObjectLockLegalHold: s3_constants.LegalHoldOn},
nil},
} {
t.Run(tc.name, func(t *testing.T) {
req := httptest.NewRequest(http.MethodPut, "http://localhost:8333/worm/doc.txt", nil)
req = mux.SetURLVars(req, map[string]string{"bucket": "worm", "object": "doc.txt"})
for k, v := range tc.headers {
req.Header.Set(k, v)
}
req = req.WithContext(s3_constants.SetIdentityInContext(req.Context(), &Identity{
Name: "caller",
PolicyNames: []string{tc.policy},
Account: &Account{Id: "test-account"},
}))
if err := s3a.validateObjectLockHeaders(req, "worm", "doc.txt", true); !errors.Is(err, tc.wantErr) {
t.Errorf("validateObjectLockHeaders() = %v, want %v", err, tc.wantErr)
}
})
}
}
func TestGovernanceBypassUsesBodyObjectKey(t *testing.T) {
iam := newTestIAM()
iam.identities[0].Actions = []Action{
Action(s3_constants.ACTION_BYPASS_GOVERNANCE_RETENTION + ":test-bucket/allowed/*"),
}
iam.identities[0].Account = &Account{Id: "test-account"}
s3a := &S3ApiServer{iam: iam}
req := httptest.NewRequest(http.MethodPost, "http://localhost:8333/test-bucket?delete", nil)
req = mux.SetURLVars(req, map[string]string{"bucket": "test-bucket"})
req = req.WithContext(s3_constants.SetIdentityInContext(req.Context(), iam.identities[0]))
if !s3a.checkGovernanceBypassPermission(req, "test-bucket", "allowed/object") {
t.Fatal("object-scoped bypass grant did not authorize a DeleteObjects body key")
}
if s3a.checkGovernanceBypassPermission(req, "test-bucket", "denied/object") {
t.Fatal("object-scoped bypass grant authorized a key outside its prefix")
}
}
func TestGovernanceBypassNormalizesBodyObjectKey(t *testing.T) {
iam := newTestIAM()
iam.identities[0].Account = &Account{Id: "test-account"}
s3a := &S3ApiServer{iam: iam}
req := httptest.NewRequest(http.MethodPost, "http://localhost:8333/test-bucket?delete", nil)
req = mux.SetURLVars(req, map[string]string{"bucket": "test-bucket"})
req = req.WithContext(s3_constants.SetIdentityInContext(req.Context(), iam.identities[0]))
iam.identities[0].Actions = []Action{
Action(s3_constants.ACTION_BYPASS_GOVERNANCE_RETENTION + ":test-bucket/allowed/o?ject"),
}
if !s3a.checkGovernanceBypassPermission(req, "test-bucket", "//allowed//object") {
t.Fatal("canonical object grant did not authorize the equivalent noncanonical body key")
}
iam.identities[0].Actions = []Action{
Action(s3_constants.ACTION_BYPASS_GOVERNANCE_RETENTION + ":test-bucket/allowed//o?ject"),
}
if s3a.checkGovernanceBypassPermission(req, "test-bucket", "//allowed//object") {
t.Fatal("noncanonical alias grant authorized the canonical mutation target")
}
}
func TestCoarseReadWriteDoNotGrantObjectLockActions(t *testing.T) {
identity := &Identity{
Name: "object-reader-writer",
Actions: []Action{
Action(s3_constants.ACTION_READ + ":test-bucket"),
Action(s3_constants.ACTION_WRITE + ":test-bucket"),
},
}
for _, action := range []string{
s3_constants.ACTION_GET_OBJECT_RETENTION,
s3_constants.ACTION_PUT_OBJECT_RETENTION,
s3_constants.ACTION_GET_OBJECT_LEGAL_HOLD,
s3_constants.ACTION_PUT_OBJECT_LEGAL_HOLD,
s3_constants.ACTION_GET_BUCKET_OBJECT_LOCK_CONFIG,
s3_constants.ACTION_PUT_BUCKET_OBJECT_LOCK_CONFIG,
s3_constants.ACTION_BYPASS_GOVERNANCE_RETENTION,
} {
if identity.CanDo(Action(action), "test-bucket", "some/key") {
t.Errorf("coarse Read/Write unexpectedly granted %s", action)
}
}
}
func TestObjectLockActionsRoundTrip(t *testing.T) {
for _, tc := range []struct{ policyAction, identityAction string }{
{"GetObjectRetention", s3_constants.ACTION_GET_OBJECT_RETENTION},
{"PutObjectRetention", s3_constants.ACTION_PUT_OBJECT_RETENTION},
{"GetObjectLegalHold", s3_constants.ACTION_GET_OBJECT_LEGAL_HOLD},
{"PutObjectLegalHold", s3_constants.ACTION_PUT_OBJECT_LEGAL_HOLD},
{"GetBucketObjectLockConfiguration", s3_constants.ACTION_GET_BUCKET_OBJECT_LOCK_CONFIG},
{"PutBucketObjectLockConfiguration", s3_constants.ACTION_PUT_BUCKET_OBJECT_LOCK_CONFIG},
{"BypassGovernanceRetention", s3_constants.ACTION_BYPASS_GOVERNANCE_RETENTION},
} {
t.Run(tc.policyAction, func(t *testing.T) {
for _, action := range []string{tc.policyAction, "s3:" + tc.policyAction} {
if got := iamlib.MapToStatementAction(action); got != tc.identityAction {
t.Errorf("MapToStatementAction(%q) = %q, want %q", action, got, tc.identityAction)
}
}
if got := iamlib.MapToIdentitiesAction(tc.identityAction); got != tc.policyAction {
t.Errorf("MapToIdentitiesAction(%q) = %q, want %q", tc.identityAction, got, tc.policyAction)
}
})
}
}
// Anonymous misses must not disclose bucket or key existence: 404 is only
// served when anonymous listing is allowed.
func TestAnonymousBucketListAuthorization(t *testing.T) {
s3a := &S3ApiServer{iam: &IdentityAccessManagement{}, bucketConfigCache: NewBucketConfigCache(time.Minute)}
s3a.bucketConfigCache.Set("open", &BucketConfig{Name: "open", IsPublicRead: true})
s3a.bucketConfigCache.Set("private", &BucketConfig{Name: "private"})
req := httptest.NewRequest(http.MethodGet, "http://localhost:8333/open/key", nil)
if got := s3a.authorizeAnonymousBucketList(req, "open"); got != s3err.ErrNone {
t.Errorf("listable bucket: %v, want ErrNone", got)
}
if got := s3a.authorizeAnonymousBucketList(req, "private"); got != s3err.ErrAccessDenied {
t.Errorf("private bucket: %v, want AccessDenied", got)
}
}
// Internal Seaweed-X-Amz-* headers carry server-validated object lock values
// into entry metadata; client-supplied ones must be dropped on entry or the
// dedicated-permission check on x-amz-object-lock-* is bypassed.
func TestInternalObjectLockHeadersStrippedOnAuth(t *testing.T) {
iam := newTestIAM()
internal := []string{
s3_constants.ExtObjectLockModeKey,
s3_constants.ExtRetentionUntilDateKey,
s3_constants.ExtLegalHoldKey,
s3_constants.ExtVersionIdKey,
s3_constants.SeaweedFSSSEKMSBaseIVHeader,
s3_constants.SeaweedFSSSES3BaseIVHeader,
s3_constants.SeaweedFSSSES3KeyDataHeader,
}
req := httptest.NewRequest(http.MethodPut, "http://localhost:8333/worm/doc.txt", nil)
for _, k := range internal {
req.Header.Set(k, "injected")
}
require.NoError(t, signRawHTTPRequest(context.Background(), req,
"AKIAIOSFODNN7EXAMPLE", "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY", "us-east-1"))
_, _, _ = iam.authenticateRequestInternal(req)
for _, k := range internal {
if got := req.Header.Get(k); got != "" {
t.Errorf("client-supplied %s survived authentication: %q", k, got)
}
}
}
// With IAM disabled the Auth wrapper calls the handler directly; internal
// headers must still be stripped so they never reach putToFiler.
func TestInternalHeadersStrippedWithoutAuth(t *testing.T) {
iam := &IdentityAccessManagement{}
internal := []string{
s3_constants.ExtObjectLockModeKey,
s3_constants.ExtRetentionUntilDateKey,
s3_constants.ExtLegalHoldKey,
s3_constants.ExtVersionIdKey,
s3_constants.SeaweedFSSSEKMSBaseIVHeader,
s3_constants.SeaweedFSSSES3BaseIVHeader,
s3_constants.SeaweedFSSSES3KeyDataHeader,
}
var leaked []string
handler := iam.Auth(func(w http.ResponseWriter, r *http.Request) {
for _, k := range internal {
if v := r.Header.Get(k); v != "" {
leaked = append(leaked, k)
}
}
}, s3_constants.ACTION_WRITE)
req := httptest.NewRequest(http.MethodPut, "http://localhost:8333/worm/doc.txt", nil)
for _, k := range internal {
req.Header.Set(k, "injected")
}
handler(httptest.NewRecorder(), req)
if len(leaked) > 0 {
t.Errorf("client-supplied internal headers reached handler with auth disabled: %v", leaked)
}
}