Skip to content

armgit / floci

Public Imported from GitHub
0

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.md
index 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 BucketAlreadyExis
creates 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 reuse
after 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.java
index 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.java
index 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 that
diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProviders.java b/src/main/java/io/github/hectorvent/floci/services/iam/ResourcePolicyProviders.java
index 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.java
index 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.java
index 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;
+ }
+
@Override
public 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.java
new file mode 100644
index 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.java
index 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