s3: route ';' queries as authorized, and report an empty s3:prefix to policies (#12702)

* s3: escape raw semicolons before the router matches a route

registerRouter applied EscapeSemicolonsInQuery with router.Use, but mux
runs router middleware only after it has picked the route. Queries()
matchers split pairs on ';', so GET /bucket?uploads;x=1 reached the
multipart listing handler while the handler and the IAM resolver read
uploads%3Bx=1 and saw no uploads subresource. Wrap the S3 router with the
escape so routing and authorization read the same query.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* s3api: report a listing without prefix as s3:prefix "" in policy conditions

The advanced IAM path already sets s3:prefix to "" when a bucket listing
names no prefix, as AWS does, but bucket policies and attached policies
read conditions from ExtractConditionValuesFromRequest, which leaves the
key out. The AWS home-directory policy that grants s3:prefix ["", "home/"]
then denied the root listing, and a Deny keyed on the empty prefix never
applied.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* s3: test the served handler composition for the semicolon escape

Move the escape and the Vectors split into s3Handler so a command test can
send ';' queries through the handler the server actually serves.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* s3: keep the isVectorsRequest doc comment on its function

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Chris LuandClaude Opus 5.5 authored and GitHub committed 2026-11-17 17:05:34 -08:00
1 parent 1d30b0de21
commit c4e1802e3e
7 files changed
+132 -12

No files matched your search

+18 -11
View File
@@ -449,17 +449,7 @@ func (s3opt *S3Options) startS3Server() bool {
// The Vectors API rides the main -port listener whenever a weed-vector
// backend is reachable — /s3vectors/ in the SigV4 credential scope picks
// the vectors router.
vectorsHandler := http.Handler(router)
if vectorsRouter := s3opt.vectorsRouter(s3ApiServer, grpcDialOption, masterAddresses, filerGroup); vectorsRouter != nil {
vr, mainRouter := vectorsRouter, router
vectorsHandler = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if isVectorsRequest(r) {
vr.ServeHTTP(w, r)
return
}
mainRouter.ServeHTTP(w, r)
})
}
vectorsHandler := s3Handler(router, s3opt.vectorsRouter(s3ApiServer, grpcDialOption, masterAddresses, filerGroup))
if runtime.GOOS != "windows" {
localSocket := *s3opt.localSocket
@@ -768,6 +758,23 @@ func (s3opt *S3Options) vectorsRouter(s3ApiServer *s3api.S3ApiServer, grpcDialOp
return vectorsRouter
}
// s3Handler serves router, and vectors for Vectors API requests when set. mux
// matches Queries() before router middleware runs, so the escape wraps the
// router for routing and authorization to read one query.
func s3Handler(router, vectors *mux.Router) http.Handler {
main := util_http.EscapeSemicolonsInQuery(router)
if vectors == nil {
return main
}
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
if isVectorsRequest(r) {
vectors.ServeHTTP(w, r)
return
}
main.ServeHTTP(w, r)
})
}
// isVectorsRequest routes by the SigV4 credential scope — the s3vectors
// service name lives there, not in the path.
func isVectorsRequest(r *http.Request) bool {
+30
View File
@@ -0,0 +1,30 @@
package command
import (
"net/http"
"net/http/httptest"
"testing"
"github.com/gorilla/mux"
"github.com/stretchr/testify/assert"
)
// A raw ';' pair must not select a Queries() route that the handler, reading
// the escaped query, does not see.
func TestS3HandlerEscapesSemicolonsBeforeRouting(t *testing.T) {
router := mux.NewRouter().SkipClean(true)
var served string
var hasUploads bool
router.Methods(http.MethodGet).Path("/{bucket}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
served, hasUploads = "uploads", r.URL.Query().Has("uploads")
}).Queries("uploads", "")
router.Methods(http.MethodGet).Path("/{bucket}").HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
served, hasUploads = "list", r.URL.Query().Has("uploads")
})
for query, want := range map[string]string{"uploads": "uploads", "uploads;x=1": "list", "x=1;uploads": "list"} {
s3Handler(router, nil).ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/bkt?"+query, nil))
assert.Equal(t, want, served, query)
assert.Equal(t, want == "uploads", hasUploads, query)
}
}
+9
View File
@@ -1948,6 +1948,14 @@ func isBucketListingRequest(r *http.Request, action Action) bool {
return object == "" || object == "/"
}
// addEmptyListPrefix reports a listing that names no prefix as s3:prefix "",
// as AWS and the advanced IAM path do.
func addEmptyListPrefix(conditions map[string][]string, r *http.Request, action Action) {
if _, ok := conditions["s3:prefix"]; !ok && isBucketListingRequest(r, action) {
conditions["s3:prefix"] = []string{""}
}
}
// multipartListingAction returns the scoped action for a request the router
// sends to ListObjectPartsHandler or ListMultipartUploadsHandler, or "" for
// any other request. It follows the route order in s3api_server.go and reads
@@ -2752,6 +2760,7 @@ func (iam *IdentityAccessManagement) evaluateAttachedIAMPolicies(r *http.Request
principal := buildPrincipalARN(identity, r)
explicitAllow := false
conditions := engine.ExtractConditionValuesFromRequest(r)
addEmptyListPrefix(conditions, r, action)
for key, values := range vectorIAMConditions(r) {
conditions[key] = values
}
@@ -86,6 +86,50 @@ func TestEvaluateIAMPolicies_ListBucketPrefixCondition(t *testing.T) {
"prefix outside the s3:prefix condition must be denied")
}
// A listing without ?prefix is the empty prefix, so the home-directory policy
// that grants s3:prefix "" for the root level matches it in attached and
// bucket policies alike.
func TestListBucketWithoutPrefixMatchesEmptyPrefix(t *testing.T) {
const bucket = "test-bucket"
statement := map[string]any{
"Effect": "Allow",
"Action": "s3:ListBucket",
"Resource": "arn:aws:s3:::" + bucket,
"Condition": map[string]any{"StringEquals": map[string]any{
"s3:prefix": []string{"", "home/"},
"s3:delimiter": "/",
}},
}
iam := &IdentityAccessManagement{}
require.NoError(t, iam.PutPolicy("home-root", mustPolicy(t, map[string]any{
"Version": "2012-10-17", "Statement": []map[string]any{statement},
})))
identity := &Identity{Name: "carol", Account: &AccountAdmin, PolicyNames: []string{"home-root"}}
statement["Principal"] = "*"
engine := NewBucketPolicyEngine()
require.NoError(t, engine.engine.SetBucketPolicy(bucket, mustPolicy(t, map[string]any{
"Version": "2012-10-17", "Statement": []map[string]any{statement},
})))
for _, tt := range []struct {
query string
allowed bool
}{
{"list-type=2&delimiter=/", true},
{"list-type=2&prefix=&delimiter=/", true},
{"list-type=2&prefix=home/&delimiter=/", true},
{"list-type=2&prefix=other/&delimiter=/", false},
{"list-type=2", false},
} {
req := httptest.NewRequest("GET", "/"+bucket+"?"+tt.query, nil)
require.Equal(t, tt.allowed, iam.evaluateIAMPolicies(req, identity, s3_constants.ACTION_LIST, bucket, ""), "attached policy, %s", tt.query)
allowed, evaluated, err := engine.EvaluatePolicy(bucket, "", string(s3_constants.ACTION_LIST), "arn:aws:iam::000000000000:user/carol", req, nil, nil)
require.NoError(t, err)
require.Equal(t, tt.allowed, evaluated && allowed, "bucket policy, %s", tt.query)
}
}
// Listing variants keep their specific action even when a prefix is promoted
// into object: ?versions resolves to s3:ListBucketVersions, not s3:ListBucket.
func TestEvaluateIAMPolicies_ListBucketVersionsWithPrefix(t *testing.T) {
@@ -7,6 +7,7 @@ import (
"testing"
"github.com/gorilla/mux"
util_http "github.com/seaweedfs/seaweedfs/weed/util/http"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
@@ -140,3 +141,32 @@ func TestRouteQueryKeysAreClassified(t *testing.T) {
})
require.NoError(t, err)
}
// mux matches Queries() on the raw query, splitting pairs on ';', before any
// router middleware runs, while handlers and the IAM resolver read the escaped
// query. The server escapes ahead of the router so both see one operation.
func TestSemicolonQueryRoutesAsAuthorized(t *testing.T) {
router := mux.NewRouter().SkipClean(true)
setupRoutingTestServer(t).registerRouter(router)
match := func(r *http.Request) *mux.Route {
var m mux.RouteMatch
require.True(t, router.Match(r, &m))
return m.Route
}
raw := func(query string) *mux.Route {
return match(httptest.NewRequest(http.MethodGet, "/bucket?"+query, nil))
}
escaped := func(query string) (route *mux.Route) {
util_http.EscapeSemicolonsInQuery(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
assert.False(t, r.URL.Query().Has("uploads"))
route = match(r)
})).ServeHTTP(httptest.NewRecorder(), httptest.NewRequest(http.MethodGet, "/bucket?"+query, nil))
return route
}
uploads, listing := raw("uploads"), raw("x=1")
require.NotSame(t, uploads, listing)
assert.Same(t, uploads, raw("uploads;x=1"), "unescaped, mux reads the ';' pair as uploads")
assert.Same(t, listing, escaped("uploads;x=1"))
assert.Same(t, listing, escaped("x=1;uploads"))
}
+1
View File
@@ -147,6 +147,7 @@ func (bpe *BucketPolicyEngine) EvaluatePolicy(bucket, object, action, principal
if r != nil {
args.OriginalGrantConditions = policy_engine.OriginalGrantConditionsFromRequest(r)
args.Conditions = bpe.engine.ExtractConditionValuesFromRequest(r)
addEmptyListPrefix(args.Conditions, r, Action(action))
// Extract principal-related variables (aws:username, etc.) from principal ARN
principalVars := principalVariables(principal, claims)
-1
View File
@@ -962,7 +962,6 @@ func (s3a *S3ApiServer) UnifiedPostHandler(w http.ResponseWriter, r *http.Reques
}
func (s3a *S3ApiServer) registerRouter(router *mux.Router) {
// runs before subrouter matching so Queries() matchers see the fixed query
router.Use(util_http.EscapeSemicolonsInQuery)
// a request naming two subresources routes one way and authorizes another;
// reject it rather than guess