Light, fluffy, and always free - The AWS Local Emulator alternative
fix(s3): preserve bucket collision errors with IAM enforcement (#6539)
Andre Kurait2bc53956fd53
diff --git a/docs/services/s3.md b/docs/services/s3.mdindex 7d16be4181..8653c72ce2 100644--- a/docs/services/s3.md+++ b/docs/services/s3.md@@ -350,6 +350,9 @@ Creating a bucket whose name another account owns returns `409 BucketAlreadyExiscreates and deletion share the same bucket-name lock. Recreating an owned bucket succeeds in`us-east-1` and returns `409 BucketAlreadyOwnedByYou` in other regions. `ListObjects` and`ListObjectsV2` read the named bucket's owner's objects; `ListBuckets` stays caller-scoped.+With IAM enforcement enabled, a foreign bucket's policy neither grants nor denies creation of a+bucket with the same name. Caller permission checks, including requested creation settings, still+run before the collision check. A bucket owned by the caller retains its existing policy checks.The default per-account namespace and authentication settings are unchanged. Bucket-name reuseafter deletion is immediate in Floci; AWS may temporarily return `409 OperationAborted`.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 180a0a1fb3..a40d01f5fc 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@@ -1111,7 +1111,8 @@ public class IamEnforcementFilter implements ContainerRequestFilter {List<String> resources, List<Map<String, List<String>>> targetContexts,String region, String accountId, String akid) {for (String resource : resources) {- List<ResourcePolicyProvider.ResourcePolicy> resourcePolicies = resolveResourcePolicies(credentialScope, resource);+ List<ResourcePolicyProvider.ResourcePolicy> resourcePolicies =+ resolveResourcePolicies(credentialScope, operationAction, resource);String resourceOwnerAccountId = resourcePolicies.isEmpty() ? null : resourcePolicies.getFirst().ownerAccountId();List<String> policyDocs = resourcePolicies.stream().map(ResourcePolicyProvider.ResourcePolicy::policyDocument)@@ -1404,7 +1405,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {// signing alias such as s3express, would otherwise see no bucket policy at all.String resourcePolicyScope = catalog.canonicalCredentialScope(action.split(":", 2)[0]);List<ResourcePolicyProvider.ResourcePolicy> resourcePolicies = resolveResourcePolicies(- resourcePolicyScope, resource);+ resourcePolicyScope, action, resource);effectiveOwnerAccountId = resourcePolicies.isEmpty()? null : resourcePolicies.getFirst().ownerAccountId();policyDocs = resourcePolicies.stream()@@ -1688,8 +1689,9 @@ public class IamEnforcementFilter implements ContainerRequestFilter {return resolved;}- private List<ResourcePolicyProvider.ResourcePolicy> resolveResourcePolicies(String credentialScope, String resourceArn) {- return ResourcePolicyProviders.policiesFor(resourcePolicyProviders, credentialScope, resourceArn);+ private List<ResourcePolicyProvider.ResourcePolicy> resolveResourcePolicies(+ String credentialScope, String action, String resourceArn) {+ return ResourcePolicyProviders.policiesFor(resourcePolicyProviders, credentialScope, action, resourceArn);}/**diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProvider.java b/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProvider.javaindex cbcd366e5b..f232e320a0 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProvider.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProvider.java@@ -23,6 +23,14 @@ public interface ResourcePolicyProvider {*/List<ResourcePolicy> getResourcePolicies(String credentialScope, String resourceArn);+ /**+ * Policies applying to an action. A service may exclude operations that do not act on+ * an existing resource.+ */+ default List<ResourcePolicy> getResourcePolicies(String credentialScope, String action, String resourceArn) {+ return getResourcePolicies(credentialScope, resourceArn);+ }+/*** The ARN the resource is actually named by, which policies are matched against. A request's* resource ARN is built in the request's partition; a provider whose resources outlive thatdiff --git a/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProviders.java b/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProviders.javaindex 62624f5017..da99cee705 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProviders.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProviders.java@@ -21,13 +21,20 @@ public final class ResourcePolicyProviders {*/public static List<ResourcePolicyProvider.ResourcePolicy> policiesFor(Instance<ResourcePolicyProvider> providers, String credentialScope, String resourceArn) {+ return policiesFor(providers, credentialScope, null, resourceArn);+ }++ /** The policies applying to an action, as determined by each resource-owning service. */+ public static List<ResourcePolicyProvider.ResourcePolicy> policiesFor(+ Instance<ResourcePolicyProvider> providers, String credentialScope, String action, String resourceArn) {if (providers == null || providers.isUnsatisfied()) {return List.of();}List<ResourcePolicyProvider.ResourcePolicy> policies = new ArrayList<>();for (ResourcePolicyProvider provider : providers) {List<ResourcePolicyProvider.ResourcePolicy> supplied =- provider.getResourcePolicies(credentialScope, resourceArn);+ action == null ? provider.getResourcePolicies(credentialScope, resourceArn)+ : provider.getResourcePolicies(credentialScope, action, resourceArn);if (supplied != null && !supplied.isEmpty()) {policies.addAll(supplied);}diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java b/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.javaindex 018ee6b792..13c47a4cde 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/S3Controller.java@@ -15,6 +15,7 @@ import io.github.hectorvent.floci.core.common.RequestContext;import io.github.hectorvent.floci.core.common.XmlBuilder;import io.github.hectorvent.floci.core.common.XmlParser;import io.github.hectorvent.floci.services.cloudtrail.CloudTrailService;+import io.github.hectorvent.floci.services.iam.IamPolicyEvaluator.ResourcePolicyDecision;import io.github.hectorvent.floci.services.iam.IamService;import io.github.hectorvent.floci.services.s3.model.Bucket;import io.github.hectorvent.floci.services.s3.model.ChecksumAlgorithm;@@ -4522,8 +4523,10 @@ public class S3Controller {}String credential = iamCredential(httpHeaders, uriInfo);String resource = S3PublicAccessEvaluator.bucketArn(AwsRegions.partitionFor(region), bucket);+ ResourcePolicyDecision policyDecision = s3Service.ownsBucket(bucket) ? null : ResourcePolicyDecision.NEUTRAL;for (String action : actions) {- iamEnforcementFilter.authorizeAdditionalResource(credential, action, resource);+ iamEnforcementFilter.authorizeAdditionalResource(+ credential, action, resource, policyDecision);}}diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/S3ResourcePolicyProvider.java b/src/main/java/io/github/hectorvent/floci/services/s3/S3ResourcePolicyProvider.javaindex 8c818897ab..955cbf06b3 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/S3ResourcePolicyProvider.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/S3ResourcePolicyProvider.java@@ -35,6 +35,16 @@ public class S3ResourcePolicyProvider implements ResourcePolicyProvider {.orElseGet(List::of);}+ @Override+ public List<ResourcePolicy> getResourcePolicies(String credentialScope, String action, String resourceArn) {+ List<ResourcePolicy> policies = getResourcePolicies(credentialScope, resourceArn);+ if ("s3:CreateBucket".equals(action) && !policies.isEmpty()+ && !s3Service.ownsBucket(extractBucketName(resourceArn))) {+ return List.of();+ }+ return policies;+ }+@Overridepublic String resolveResourceArn(String credentialScope, String resourceArn) {if (!"s3".equalsIgnoreCase(credentialScope) || resourceArn == null) {diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3BucketCollisionIamEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3BucketCollisionIamEnforcementIntegrationTest.javanew file mode 100644index 0000000000..445df8fff7--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3BucketCollisionIamEnforcementIntegrationTest.java@@ -0,0 +1,187 @@+package io.github.hectorvent.floci.services.s3;++import io.github.hectorvent.floci.testing.EnforcementFixtures;+import io.github.hectorvent.floci.testing.EnforcementFixtures.UserCredentials;+import io.github.hectorvent.floci.testing.PartitionCleanup;+import io.github.hectorvent.floci.testing.S3IamEnforcementProfile;+import io.github.hectorvent.floci.testutil.S3RequestSigner;+import io.quarkus.test.common.http.TestHTTPResource;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;+import software.amazon.awssdk.regions.Region;+import software.amazon.awssdk.services.s3.S3Client;+import software.amazon.awssdk.services.s3.model.CreateBucketRequest;+import software.amazon.awssdk.services.s3.model.ObjectOwnership;+import software.amazon.awssdk.services.s3.model.S3Exception;++import java.net.URI;+import java.util.UUID;++import static io.github.hectorvent.floci.testing.EnforcementFixtures.auth;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++@QuarkusTest+@TestProfile(S3IamEnforcementProfile.class)+class S3BucketCollisionIamEnforcementIntegrationTest {++ private static final String OWNER = "111122223333";+ private static final String CALLER = "222233334444";+ private static final String ALLOW_S3 = """+ {"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"s3:*","Resource":"*"}]}+ """;++ @TestHTTPResource("/")+ URI endpoint;++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ @ParameterizedTest+ @ValueSource(strings = {"none", "Allow", "Deny"})+ void foreignBucketPolicyDoesNotAuthorizeCreation(String effect) {+ UserCredentials ownerKeys = user(OWNER, ALLOW_S3);+ UserCredentials callerKeys = user(CALLER, ALLOW_S3);+ try (S3Client owner = client(ownerKeys); S3Client caller = client(callerKeys)) {+ String bucket = createBucket(owner, ownerKeys);+ if (!"none".equals(effect)) {+ owner.putBucketPolicy(request -> request.bucket(bucket).policy(bucketPolicy(bucket, effect)));+ }++ if ("Allow".equals(effect)) {+ caller.headBucket(request -> request.bucket(bucket));+ } else {+ assertEquals(403, assertThrows(S3Exception.class,+ () -> caller.headBucket(request -> request.bucket(bucket))).statusCode());+ }+ assertError("BucketAlreadyExists", 409, () -> caller.createBucket(createRequest(bucket)));+ assertError("BucketAlreadyExists", 409, () -> caller.createBucket(createRequest(bucket)+ .toBuilder().objectOwnership(ObjectOwnership.OBJECT_WRITER).build()));+ assertError("BucketAlreadyOwnedByYou", 409, () -> owner.createBucket(createRequest(bucket)));+ assertEquals(ObjectOwnership.BUCKET_OWNER_ENFORCED, owner.getBucketOwnershipControls(+ request -> request.bucket(bucket)).ownershipControls().rules().getFirst().objectOwnership());+ assertTrue(caller.listBuckets().buckets().stream().noneMatch(value -> bucket.equals(value.name())));+ owner.headBucket(request -> request.bucket(bucket));+ }+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void callerStillNeedsIdentityPermissionBeforeCollision(boolean explicitDeny) {+ UserCredentials ownerKeys = user(OWNER, ALLOW_S3);+ String policy = explicitDeny ? """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:*","Resource":"*"},+ {"Effect":"Deny","Action":"s3:CreateBucket","Resource":"*"}]}+ """ : """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:ListBucket","Resource":"*"}]}+ """;+ UserCredentials callerKeys = user(CALLER, policy);+ try (S3Client owner = client(ownerKeys); S3Client caller = client(callerKeys)) {+ String bucket = createBucket(owner, ownerKeys);+ owner.putBucketPolicy(request -> request.bucket(bucket).policy(bucketPolicy(bucket, "Allow")));+ caller.headBucket(request -> request.bucket(bucket));+ assertError("AccessDenied", 403, () -> caller.createBucket(createRequest(bucket)));+ owner.headBucket(request -> request.bucket(bucket));+ }+ }++ @Test+ void ownerPolicyStillDeniesCreationRetries() {+ UserCredentials ownerKeys = user(OWNER, ALLOW_S3);+ UserCredentials callerKeys = user(CALLER, ALLOW_S3);+ try (S3Client owner = client(ownerKeys); S3Client caller = client(callerKeys)) {+ String bucket = createBucket(owner, ownerKeys);+ try {+ owner.putBucketPolicy(request -> request.bucket(bucket).policy("""+ {"Version":"2012-10-17","Statement":[{"Effect":"Deny","Principal":"*",+ "NotAction":["s3:DeleteBucketPolicy","s3:DeleteBucket","s3:GetBucketOwnershipControls"],+ "Resource":"arn:aws:s3:::%s"}]}+ """.formatted(bucket)));+ assertEquals(403, assertThrows(S3Exception.class,+ () -> owner.headBucket(request -> request.bucket(bucket))).statusCode());+ assertEquals(403, assertThrows(S3Exception.class,+ () -> caller.headBucket(request -> request.bucket(bucket))).statusCode());+ assertError("BucketAlreadyExists", 409, () -> caller.createBucket(createRequest(bucket)));+ assertError("BucketAlreadyExists", 409, () -> caller.createBucket(createRequest(bucket)+ .toBuilder().objectOwnership(ObjectOwnership.OBJECT_WRITER).build()));+ assertError("AccessDenied", 403, () -> owner.createBucket(createRequest(bucket)));+ assertError("AccessDenied", 403, () -> owner.createBucket(createRequest(bucket)+ .toBuilder().objectOwnership(ObjectOwnership.OBJECT_WRITER).build()));+ assertEquals(ObjectOwnership.BUCKET_OWNER_ENFORCED, owner.getBucketOwnershipControls(+ request -> request.bucket(bucket)).ownershipControls().rules().getFirst().objectOwnership());+ } finally {+ owner.deleteBucketPolicy(request -> request.bucket(bucket));+ }+ assertError("BucketAlreadyOwnedByYou", 409, () -> owner.createBucket(createRequest(bucket)));+ }+ }++ @Test+ void creationSettingsStillNeedIdentityPermissionBeforeCollision() {+ UserCredentials ownerKeys = user(OWNER, ALLOW_S3);+ UserCredentials callerKeys = user(CALLER, """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:CreateBucket","Resource":"*"}]}+ """);+ try (S3Client owner = client(ownerKeys); S3Client caller = client(callerKeys)) {+ String bucket = createBucket(owner, ownerKeys);+ owner.putBucketPolicy(request -> request.bucket(bucket).policy(bucketPolicy(bucket, "Allow")));+ assertError("BucketAlreadyExists", 409, () -> caller.createBucket(createRequest(bucket)));+ assertError("AccessDenied", 403, () -> caller.createBucket(createRequest(bucket)+ .toBuilder().objectOwnership(ObjectOwnership.OBJECT_WRITER).build()));+ owner.headBucket(request -> request.bucket(bucket));+ }+ }++ private UserCredentials user(String account, String policy) {+ String name = "collision-" + UUID.randomUUID();+ UserCredentials credentials = EnforcementFixtures.createUser(+ cleanup, endpoint.getPort(), auth(account, "iam"), name);+ EnforcementFixtures.putUserPolicy(endpoint.getPort(), auth(account, "iam"), name, "s3", policy);+ return credentials;+ }++ private S3Client client(UserCredentials credentials) {+ return S3Client.builder().endpointOverride(endpoint).region(Region.US_EAST_2).forcePathStyle(true)+ .credentialsProvider(StaticCredentialsProvider.create(+ AwsBasicCredentials.create(credentials.accessKeyId(), credentials.secretAccessKey())))+ .build();+ }++ private String createBucket(S3Client owner, UserCredentials credentials) {+ String bucket = "collision-" + UUID.randomUUID();+ cleanup.register(() -> EnforcementFixtures.removeBucket(endpoint.getPort(),+ S3RequestSigner.signedAs(credentials.accessKeyId(), credentials.secretAccessKey())+ .inRegion("us-east-2"), bucket));+ owner.createBucket(createRequest(bucket));+ return bucket;+ }++ private static CreateBucketRequest createRequest(String bucket) {+ return CreateBucketRequest.builder().bucket(bucket)+ .createBucketConfiguration(configuration -> configuration.locationConstraint("us-east-2")).build();+ }++ private static String bucketPolicy(String bucket, String effect) {+ return """+ {"Version":"2012-10-17","Statement":[{"Effect":"%s",+ "Principal":{"AWS":"arn:aws:iam::%s:root"},"Action":"s3:*",+ "Resource":["arn:aws:s3:::%s","arn:aws:s3:::%s/*"]}]}+ """.formatted(effect, CALLER, bucket, bucket);+ }++ private static void assertError(String code, int status, Runnable request) {+ S3Exception error = assertThrows(S3Exception.class, request::run);+ assertEquals(code, error.awsErrorDetails().errorCode());+ assertEquals(status, error.statusCode());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/testing/S3IamEnforcementProfile.java b/src/test/java/io/github/hectorvent/floci/testing/S3IamEnforcementProfile.javaindex 51d2060dbf..e744d318f9 100644--- a/src/test/java/io/github/hectorvent/floci/testing/S3IamEnforcementProfile.java+++ b/src/test/java/io/github/hectorvent/floci/testing/S3IamEnforcementProfile.java@@ -15,6 +15,7 @@ import java.util.Map;* <li>{@code floci.services.s3.enforce-auth=true} makes S3 verify every signature and run its own* access checks, bucket policies among them, beside IAM's.* {@code S3BucketPolicyEnforcementIntegrationTest},+ * {@code S3BucketCollisionIamEnforcementIntegrationTest},* {@code S3CopyObjectSourcePermissionIntegrationTest},* {@code S3DeleteObjectsSignedIamEnforcementIntegrationTest} and* {@code S3PresignedPostAuthEnforcementIntegrationTest} rely on it.</li>@@ -26,6 +27,7 @@ import java.util.Map;* account that owns it, whoever calls.* {@code ResourcePolicyPrincipalTypeEnforcementIntegrationTest},* {@code S3BucketPolicyEnforcementIntegrationTest},+ * {@code S3BucketCollisionIamEnforcementIntegrationTest},* {@code S3CopyObjectSourcePermissionIntegrationTest} and* {@code S3DeleteObjectsSignedIamEnforcementIntegrationTest} call another account's bucket, and* {@code StsIssuedSessionEnforcementIntegrationTest} reads one anonymously, which Floci serves as