Light, fluffy, and always free - The AWS Local Emulator alternative
fix(s3): honor bucket-policy grants on presigned POST uploads (#4278)
Matheus Oliveira60b8fd20371c
diff --git a/docs/services/s3.md b/docs/services/s3.mdindex 95bc906f99..ad83d3bd47 100644--- a/docs/services/s3.md+++ b/docs/services/s3.md@@ -246,6 +246,8 @@ Bucket policy statements can specify principals using `Principal` or `NotPrincip5. Unsigned (anonymous) requests and ACL-based public access fall back to standard S3 ACL and anonymous authorization paths.6. Unknown access key IDs return HTTP 403 with `InvalidAccessKeyId`.+With `FLOCI_SERVICES_IAM_ENFORCEMENT_ENABLED` also on, the bucket policy and the caller's identity policies are combined the way AWS combines them. For same-account access, an explicit `Allow` in either policy grants the request, so a principal that only the bucket policy names needs no identity policy at all. For cross-account access, both the bucket policy and the caller's identity policy must allow the action. An explicit `Deny` in either policy denies the request in both cases.+### Wire Response ShapeWhen a request is denied by bucket policy enforcement, Floci returns HTTP 403 with an S3 XML error body including the `<Resource>` element:diff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.javaindex f0fc7df390..3896d87702 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java@@ -399,10 +399,15 @@ public class IamEnforcementFilter implements ContainerRequestFilter {* for the duration of this call so that {@link IamService#resolveCallerContext} and* {@link IamService#resolveCallerArn}, which both key their per-account lookups off the* ambient account, resolve the credential's actual owner instead of the default account.+ *+ * <p>The caller supplies no resource-policy decision here, so this overload resolves the+ * applicable resource policies itself through {@link ResourcePolicyProvider}, exactly as+ * {@link #filter} does for the request's primary resource. Skipping that resolution would+ * make the resource policy invisible on this path and leave a same-account principal that+ * only a resource policy names without any grant at all.*/public void authorizeAdditionalResource(String authorizationHeader, String action, String resource) {- authorizeAdditionalResource(- authorizationHeader, action, resource, ResourcePolicyDecision.NEUTRAL, null);+ authorizeAdditionalResource(authorizationHeader, action, resource, null, null);}/**@@ -422,6 +427,19 @@ public class IamEnforcementFilter implements ContainerRequestFilter {/*** Authorizes a secondary resource whose owning account is known. Resource-policy grants* crossing an account boundary require a matching identity-policy grant as well.+ *+ * <p>A {@code null} {@code resourcePolicyDecision} means the caller has no decision of its+ * own and the registered {@link ResourcePolicyProvider}s are consulted here instead, under+ * the credential's own account context.+ *+ * <p>The condition context built here never includes per-action, header-derived keys (such as+ * {@code s3:RequestObjectTag/*} from an {@code x-amz-tagging} header) the way {@link #filter}+ * builds for the request's primary resource. A presigned POST's outer HTTP headers are not+ * covered by its signed policy document and do not correspond to what {@code S3Controller}+ * actually applies to the uploaded object, so trusting one here would let an attacker satisfy a+ * tag-scoped grant condition with a header the object is never actually tagged with. Only the+ * caller-identity {@code aws:PrincipalArn} and the server-derived global keys (via {@link+ * IamConditionContextResolver#withGlobalContext}) are safe to add.*/public void authorizeAdditionalResource(String authorizationHeader,@@ -439,7 +457,8 @@ public class IamEnforcementFilter implements ContainerRequestFilter {if (akid == null || "test".equals(akid)) {return;}- if (extractCredentialScope(authorizationHeader) == null) {+ String credentialScope = extractCredentialScope(authorizationHeader);+ if (credentialScope == null) {return;}@@ -476,13 +495,34 @@ public class IamEnforcementFilter implements ContainerRequestFilter {conditionContext.put("aws:PrincipalArn", List.of(principalArn.get()));}- ResourceAccountRelationship accountRelationship = resourceOwnerAccountId == null- || accountId.equals(resourceOwnerAccountId)+ Map<String, List<String>> effectiveContext = conditionContext;+ ResourcePolicyDecision effectiveDecision = resourcePolicyDecision;+ String effectiveOwnerAccountId = resourceOwnerAccountId;+ if (effectiveDecision == null) {+ List<ResourcePolicyProvider.ResourcePolicy> resourcePolicies = resolveResourcePolicies(+ credentialScope, resource);+ effectiveOwnerAccountId = resourcePolicies.isEmpty()+ ? null : resourcePolicies.getFirst().ownerAccountId();+ List<String> policyDocs = resourcePolicies.stream()+ .map(ResourcePolicyProvider.ResourcePolicy::policyDocument)+ .filter(doc -> doc != null && !doc.isBlank())+ .toList();+ String region = requestContext.getRegion() == null+ ? config.defaultRegion() : requestContext.getRegion();+ effectiveContext = IamConditionContextResolver.withGlobalContext(+ conditionContext, resource, region, accountId, effectiveOwnerAccountId);+ effectiveDecision = evaluator.evaluateResourcePolicy(+ policyDocs.isEmpty() ? null : policyDocs,+ caller.principalArn(), action, resource, effectiveContext);+ }++ ResourceAccountRelationship accountRelationship = effectiveOwnerAccountId == null+ || accountId.equals(effectiveOwnerAccountId)? ResourceAccountRelationship.SAME_ACCOUNT: ResourceAccountRelationship.CROSS_ACCOUNT;Decision decision = evaluator.evaluateResolvedResourcePolicy(- caller, resourcePolicyDecision, accountRelationship,- action, resource, conditionContext);+ caller, effectiveDecision, accountRelationship,+ action, resource, effectiveContext);if (decision != Decision.DENY) {return;}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3BucketPolicyEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3BucketPolicyEnforcementIntegrationTest.javaindex 98f3dd177b..7b166359fd 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3BucketPolicyEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3BucketPolicyEnforcementIntegrationTest.java@@ -404,5 +404,114 @@ class S3BucketPolicyEnforcementIntegrationTest {.statusCode(200).body(equalTo(content));}-}+ @Test+ void sameAccountPrimaryRequestNeedsOnlyOneAllowAcrossBothPolicies() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String bucket = "bp-either-" + suffix;++ createBucket(bucket);++ String developerName = "dev-" + suffix;+ Credentials developer = createUserWithCredentials(developerName);+ String writerName = "writer-" + suffix;+ Credentials writer = createUserWithCredentials(writerName);+ putUserPolicy(writerName, "WriteBucket", """+ {+ "Version": "2012-10-17",+ "Statement": [+ {+ "Effect": "Allow",+ "Action": "s3:PutObject",+ "Resource": "arn:aws:s3:::%s/*"+ }+ ]+ }""".formatted(bucket), "000000000000");++ putBucketPolicy(bucket, """+ {+ "Version": "2012-10-17",+ "Statement": [+ {+ "Effect": "Allow",+ "Principal": {"AWS": "%s"},+ "Action": ["s3:GetObject", "s3:PutObject"],+ "Resource": "arn:aws:s3:::%s/*"+ }+ ]+ }""".formatted(developer.userArn(), bucket));++ // 1. Bucket policy alone grants the developer, who has no identity policy at all+ given()+ .filter(developer.signer())+ .contentType("text/plain")+ .body("bucket policy only")+ .when()+ .put("/" + bucket + "/from-bucket-policy.txt")+ .then()+ .statusCode(200);++ // 2. Identity policy alone grants the writer, whom the bucket policy never names+ given()+ .filter(writer.signer())+ .contentType("text/plain")+ .body("identity policy only")+ .when()+ .put("/" + bucket + "/from-identity-policy.txt")+ .then()+ .statusCode(200);++ // 3. An explicit deny in the bucket policy overrides the writer's identity allow+ putBucketPolicy(bucket, """+ {+ "Version": "2012-10-17",+ "Statement": [+ {+ "Effect": "Allow",+ "Principal": {"AWS": "%s"},+ "Action": ["s3:GetObject", "s3:PutObject"],+ "Resource": "arn:aws:s3:::%s/*"+ },+ {+ "Effect": "Deny",+ "Principal": {"AWS": "%s"},+ "Action": "s3:PutObject",+ "Resource": "arn:aws:s3:::%s/*"+ }+ ]+ }""".formatted(developer.userArn(), bucket, writer.userArn(), bucket));++ given()+ .filter(writer.signer())+ .contentType("text/plain")+ .body("denied by bucket policy")+ .when()+ .put("/" + bucket + "/denied-by-bucket-policy.txt")+ .then()+ .statusCode(403)+ .body(containsString("<Code>AccessDenied</Code>"));++ // 4. An explicit deny in the identity policy overrides the developer's bucket-policy allow+ putUserPolicy(developerName, "DenyWrite", """+ {+ "Version": "2012-10-17",+ "Statement": [+ {+ "Effect": "Deny",+ "Action": "s3:PutObject",+ "Resource": "arn:aws:s3:::%s/*"+ }+ ]+ }""".formatted(bucket), "000000000000");++ given()+ .filter(developer.signer())+ .contentType("text/plain")+ .body("denied by identity policy")+ .when()+ .put("/" + bucket + "/denied-by-identity-policy.txt")+ .then()+ .statusCode(403)+ .body(containsString("<Code>AccessDenied</Code>"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostAuthEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostAuthEnforcementIntegrationTest.javaindex 86337b4cb4..1db64ec18c 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostAuthEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostAuthEnforcementIntegrationTest.java@@ -19,6 +19,7 @@ import javax.crypto.Mac;import javax.crypto.spec.SecretKeySpec;import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;import static org.hamcrest.Matchers.notNullValue;/**@@ -399,6 +400,158 @@ class S3PresignedPostAuthEnforcementIntegrationTest {.header("ETag", notNullValue());}+ @Test+ @Order(32)+ void acceptsGenuineSignatureWhenOnlyBucketPolicyAllowsPutObject() {+ String bucket = "presigned-post-bucket-policy-bucket";+ String key = "uploads/bucket-policy-only.txt";+ String fileContent = "uploaded under a bucket-policy-only grant";+ String userName = "presigned-post-bucket-policy-user";+ String[] credentials = createUserAndAccessKey(userName);+ String accessKeyId = credentials[0];+ String secretKey = credentials[1];++ createBucket(bucket);+ putBucketPolicy(bucket, """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow",+ "Principal":{"AWS":"arn:aws:iam::000000000000:user/%1$s"},+ "Action":"s3:PutObject",+ "Resource":"arn:aws:s3:::%2$s/*"}+ ]}""".formatted(userName, bucket));++ String policyBase64 = buildPolicyBase64(bucket, key);+ String credential = accessKeyId + "/20260101/us-east-1/s3/aws4_request";+ String signature = signPolicy(policyBase64, credential, secretKey);++ given()+ .multiPart("key", key)+ .multiPart("policy", policyBase64)+ .multiPart("x-amz-algorithm", "AWS4-HMAC-SHA256")+ .multiPart("x-amz-credential", credential)+ .multiPart("x-amz-date", AMZ_DATE)+ .multiPart("x-amz-signature", signature)+ .multiPart("file", "bucket-policy-only.txt",+ fileContent.getBytes(StandardCharsets.UTF_8), "text/plain")+ .when()+ .post("/" + bucket)+ .then()+ .statusCode(204)+ .header("ETag", notNullValue());+ }++ @Test+ @Order(33)+ void rejectsGenuineSignatureWhenBucketPolicyDeniesPutObject() {+ String bucket = "presigned-post-bucket-policy-deny-bucket";+ String key = "uploads/bucket-policy-denied.txt";+ String userName = "presigned-post-bucket-policy-denied-user";+ String[] credentials = createUserAndAccessKey(userName);+ String accessKeyId = credentials[0];+ String secretKey = credentials[1];+ putUserPolicy(userName, "AllowPutObject", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:PutObject","Resource":"*"}+ ]}""");++ createBucket(bucket);+ putBucketPolicy(bucket, """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Deny",+ "Principal":{"AWS":"arn:aws:iam::000000000000:user/%1$s"},+ "Action":"s3:PutObject",+ "Resource":"arn:aws:s3:::%2$s/*"}+ ]}""".formatted(userName, bucket));++ String policyBase64 = buildPolicyBase64(bucket, key);+ String credential = accessKeyId + "/20260101/us-east-1/s3/aws4_request";+ String signature = signPolicy(policyBase64, credential, secretKey);++ given()+ .multiPart("key", key)+ .multiPart("policy", policyBase64)+ .multiPart("x-amz-algorithm", "AWS4-HMAC-SHA256")+ .multiPart("x-amz-credential", credential)+ .multiPart("x-amz-date", AMZ_DATE)+ .multiPart("x-amz-signature", signature)+ .multiPart("file", "bucket-policy-denied.txt",+ "should not be stored".getBytes(StandardCharsets.UTF_8), "text/plain")+ .when()+ .post("/" + bucket)+ .then()+ .statusCode(403)+ .body("Error.Code", equalTo("AccessDenied"));+ }++ /**+ * Regression for a tag-condition spoofing gap: a presigned POST's signed policy document+ * covers the multipart fields, never the request's outer HTTP headers, and {@code+ * S3Controller} does not apply any tag to the uploaded object on this path at all. A+ * bucket-policy grant conditioned on {@code s3:RequestObjectTag/*} must not be satisfiable by+ * setting an unsigned {@code x-amz-tagging} header, since a caller could then obtain a grant+ * meant only for tagged uploads without the object ever carrying that tag.+ */+ @Test+ @Order(34)+ void rejectsGenuineSignatureWhenBucketPolicyGrantRequiresATagTheHeaderCannotSupply() {+ String bucket = "presigned-post-tag-condition-bucket";+ String key = "uploads/tag-condition.txt";+ String userName = "presigned-post-tag-condition-user";+ String[] credentials = createUserAndAccessKey(userName);+ String accessKeyId = credentials[0];+ String secretKey = credentials[1];++ createBucket(bucket);+ putBucketPolicy(bucket, """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow",+ "Principal":{"AWS":"arn:aws:iam::000000000000:user/%1$s"},+ "Action":"s3:PutObject",+ "Resource":"arn:aws:s3:::%2$s/*",+ "Condition":{"StringEquals":{"s3:RequestObjectTag/team":"eng"}}}+ ]}""".formatted(userName, bucket));++ String policyBase64 = buildPolicyBase64(bucket, key);+ String credential = accessKeyId + "/20260101/us-east-1/s3/aws4_request";+ String signature = signPolicy(policyBase64, credential, secretKey);++ given()+ .header("x-amz-tagging", "team=eng")+ .multiPart("key", key)+ .multiPart("policy", policyBase64)+ .multiPart("x-amz-algorithm", "AWS4-HMAC-SHA256")+ .multiPart("x-amz-credential", credential)+ .multiPart("x-amz-date", AMZ_DATE)+ .multiPart("x-amz-signature", signature)+ .multiPart("file", "tag-condition.txt",+ "should not be stored".getBytes(StandardCharsets.UTF_8), "text/plain")+ .when()+ .post("/" + bucket)+ .then()+ .statusCode(403)+ .body("Error.Code", equalTo("AccessDenied"));+ }++ private static void createBucket(String bucket) {+ given()+ .filter(S3RequestSigner.signedAs(LEGACY_ACCESS_KEY_ID, LEGACY_SECRET_KEY))+ .when()+ .put("/" + bucket)+ .then()+ .statusCode(200);+ }++ private static void putBucketPolicy(String bucket, String policyDocument) {+ given()+ .filter(S3RequestSigner.signedAs(LEGACY_ACCESS_KEY_ID, LEGACY_SECRET_KEY))+ .contentType("application/json")+ .body(policyDocument)+ .when()+ .put("/" + bucket + "?policy")+ .then()+ .statusCode(200);+ }+private static final String IAM_ROOT_AUTH ="AWS4-HMAC-SHA256 Credential=" + LEGACY_ACCESS_KEY_ID + "/20260101/us-east-1/iam/aws4_request"+ ", SignedHeaders=host, Signature=abc";diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostBucketPolicyAccountContextIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostBucketPolicyAccountContextIntegrationTest.javanew file mode 100644index 0000000000..9c5cd5927e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostBucketPolicyAccountContextIntegrationTest.java@@ -0,0 +1,135 @@+package io.github.hectorvent.floci.services.s3;++import io.github.hectorvent.floci.core.common.IamEnforcementFilter;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.QuarkusTestProfile;+import io.quarkus.test.junit.TestProfile;+import org.junit.jupiter.api.Test;++import java.nio.charset.StandardCharsets;+import java.time.Instant;+import java.time.ZoneOffset;+import java.time.format.DateTimeFormatter;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;++/**+ * Regression coverage for a presigned POST bucket-policy-only grant where the bucket and the+ * signer both live in a non-default account, distinct from+ * {@code S3PresignedPostIamOnlyEnforcementIntegrationTest}'s identity-policy coverage of the+ * same account-context gap. {@link IamEnforcementFilter#authorizeAdditionalResource(String,+ * String, String)} must resolve the applicable bucket policy under the signing credential's own+ * account context (pushed onto {@code RequestContext} for the duration of that call), or a bucket+ * owned by a non-default account is invisible to it and the grant is silently dropped.+ *+ * <p>{@code global-bucket-namespace} is enabled so bucket resolution (both here and in the+ * eventual object write) does not itself depend on the ambient account, isolating the assertion+ * to the account used for the identity/resource-policy relationship rather than to bucket lookup+ * scoping.+ */+@QuarkusTest+@TestProfile(S3PresignedPostBucketPolicyAccountContextIntegrationTest.GlobalNamespaceIamOnlyProfile.class)+class S3PresignedPostBucketPolicyAccountContextIntegrationTest {++ private static final String REGION = "us-east-1";+ /** A non-default account, distinct from the configured {@code 000000000000} default. */+ private static final String NON_DEFAULT_ACCOUNT = "222233334444";+ private static final DateTimeFormatter AMZ_DATE_FMT =+ DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'").withZone(ZoneOffset.UTC);++ public static final class GlobalNamespaceIamOnlyProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of(+ "floci.services.iam.enforcement-enabled", "true",+ "floci.services.s3.enforce-auth", "false",+ "floci.services.s3.global-bucket-namespace", "true");+ }+ }++ @Test+ void presignedPostSucceedsForNonDefaultAccountBucketAndSignerWhenOnlyBucketPolicyAllows() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String bucket = "presigned-post-bp-xacct-" + suffix;+ String userName = "presigned-post-bp-xacct-user-" + suffix;++ createBucketAsRoot(bucket, NON_DEFAULT_ACCOUNT);+ String accessKeyId = createUser(userName, NON_DEFAULT_ACCOUNT);+ putBucketPolicy(bucket, """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow",+ "Principal":{"AWS":"arn:aws:iam::%1$s:user/%2$s"},+ "Action":"s3:PutObject",+ "Resource":"arn:aws:s3:::%3$s/*"}+ ]}""".formatted(NON_DEFAULT_ACCOUNT, userName, bucket), NON_DEFAULT_ACCOUNT);++ given()+ .multiPart("key", "bp-allowed-xacct.txt")+ .multiPart("x-amz-credential", presignedCredential(accessKeyId))+ .multiPart("file", "bp-allowed-xacct.txt",+ "uploaded via presigned POST".getBytes(StandardCharsets.UTF_8), "text/plain")+ .when()+ .post("/" + bucket)+ .then()+ .statusCode(204);+ }++ private static String presignedCredential(String accessKeyId) {+ String amzDate = AMZ_DATE_FMT.format(Instant.now());+ String dateStamp = amzDate.substring(0, 8);+ return accessKeyId + "/" + dateStamp + "/" + REGION + "/s3/aws4_request";+ }++ private static void createBucketAsRoot(String bucket, String accountId) {+ given()+ .header("Authorization", auth(accountId, "s3"))+ .when()+ .put("/" + bucket)+ .then()+ .statusCode(200);+ }++ private static void putBucketPolicy(String bucket, String policyDocument, String accountId) {+ given()+ .header("Authorization", auth(accountId, "s3"))+ .contentType("application/json")+ .body(policyDocument)+ .when()+ .put("/" + bucket + "?policy")+ .then()+ .statusCode(200);+ }++ /** Creates the user (and its access key) as root in {@code accountId}. */+ private static String createUser(String userName, String accountId) {+ String authHeader = auth(accountId, "iam");+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserName", userName)+ .header("Authorization", authHeader)+ .when()+ .post("/")+ .then()+ .statusCode(200);++ return given()+ .formParam("Action", "CreateAccessKey")+ .formParam("UserName", userName)+ .header("Authorization", authHeader)+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract()+ .path("CreateAccessKeyResponse.CreateAccessKeyResult.AccessKey.AccessKeyId");+ }++ private static String auth(String accessKeyId, String service) {+ String amzDate = AMZ_DATE_FMT.format(Instant.now()).substring(0, 8);+ return "AWS4-HMAC-SHA256 Credential=" + accessKeyId + "/" + amzDate + "/" + REGION + "/" + service+ + "/aws4_request, SignedHeaders=host, Signature=abc";+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostIamOnlyEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostIamOnlyEnforcementIntegrationTest.javaindex 8cd88daba5..bb6a593a92 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostIamOnlyEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3PresignedPostIamOnlyEnforcementIntegrationTest.java@@ -142,6 +142,61 @@ class S3PresignedPostIamOnlyEnforcementIntegrationTest {.statusCode(204);}+ /**+ * Regression for {@code IamEnforcementFilter#authorizeAdditionalResource} resolving the+ * bucket policy without the global condition keys ({@code aws:PrincipalAccount} in+ * particular) that {@code filter()} always supplies for the header-signed and presigned-URL+ * paths. A bucket-policy {@code Deny} conditioned on the account key being absent must not+ * fire for a genuine signed principal, whose account this filter always knows. Exercised in+ * this IAM-only profile (rather than {@code S3PresignedPostAuthEnforcementIntegrationTest})+ * so only {@code authorizeAdditionalResource} gates the request: with+ * {@code s3.enforce-auth} on, {@code S3Service#authorizeSignedBucketPolicy} independently+ * re-evaluates the same bucket policy through its own, narrower condition context.+ */+ @Test+ void presignedPostSucceedsWhenBucketPolicyDeniesOnlyForMissingPrincipalAccount() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String bucket = "presigned-post-null-condition-" + suffix;+ String userName = "presigned-post-null-condition-user-" + suffix;++ createBucketAsRoot(bucket);+ String accessKeyId = createUser(userName);+ putUserPolicy(userName, "AllowPutObject", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:PutObject","Resource":"*"}+ ]}""");+ putBucketPolicy(bucket, """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Deny",+ "Principal":{"AWS":"arn:aws:iam::000000000000:user/%1$s"},+ "Action":"s3:PutObject",+ "Resource":"arn:aws:s3:::%2$s/*",+ "Condition":{"Null":{"aws:PrincipalAccount":"true"}}}+ ]}""".formatted(userName, bucket));++ given()+ .multiPart("key", "principal-account-present.txt")+ .multiPart("x-amz-credential", presignedCredential(accessKeyId))+ .multiPart("file", "principal-account-present.txt",+ "uploaded with aws:PrincipalAccount populated".getBytes(StandardCharsets.UTF_8),+ "text/plain")+ .when()+ .post("/" + bucket)+ .then()+ .statusCode(204);+ }++ private static void putBucketPolicy(String bucket, String policyDocument) {+ given()+ .header("Authorization", auth("test", "s3"))+ .contentType("application/json")+ .body(policyDocument)+ .when()+ .put("/" + bucket + "?policy")+ .then()+ .statusCode(200);+ }+private static String presignedCredential(String accessKeyId) {String amzDate = AMZ_DATE_FMT.format(Instant.now());String dateStamp = amzDate.substring(0, 8);