Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix(iam): enforce STS session policies (#1636)

Robert Stupp4f4e7be90eb9
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamEnforcementTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamEnforcementTest.java
index cf3ae7b50f..661487b7c0 100644
--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamEnforcementTest.java
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamEnforcementTest.java
@@ -30,6 +30,7 @@ import static org.assertj.core.api.Assertions.*;
* <li>Wildcard action policy grants access → ALLOW</li>
* <li>Assumed role with no policies → DENY</li>
* <li>Assumed role with attached allow policy → ALLOW</li>
+ * <li>Assumed role session policy deny overrides role allow → DENY</li>
* </ul>
*/
@DisplayName("IAM Enforcement Mode")
@@ -63,6 +64,12 @@ class IamEnforcementTest {
{"Effect":"Allow","Action":"s3:*","Resource":"*"}
]}""";
+ private static final String DENY_S3_LIST_SESSION_POLICY = """
+ {"Version":"2012-10-17","Statement":[
+ {"Effect":"Allow","Action":"s3:ListAllMyBuckets","Resource":"*"},
+ {"Effect":"Deny","Action":"s3:ListAllMyBuckets","Resource":"*"}
+ ]}""";
+
// ── Shared state ───────────────────────────────────────────────────────────
private static IamClient iam;
private static StsClient sts;
@@ -293,4 +300,30 @@ class IamEnforcementTest {
assertThatCode(s3::listBuckets).doesNotThrowAnyException();
}
}
+
+ @Test
+ @Order(7)
+ @DisplayName("assumed role session policy deny overrides role allow")
+ void assumedRoleSessionPolicyDenyOverridesRoleAllow() {
+ assumeEnforcementEnabled();
+
+ iam.attachRolePolicy(AttachRolePolicyRequest.builder()
+ .roleName(ROLE).policyArn(allowPolicyArn).build());
+
+ AssumeRoleResponse assumed = sts.assumeRole(AssumeRoleRequest.builder()
+ .roleArn(roleArn)
+ .roleSessionName("enf-test-session-deny")
+ .policy(DENY_S3_LIST_SESSION_POLICY)
+ .build());
+
+ try (S3Client s3 = s3WithSessionCredentials(
+ assumed.credentials().accessKeyId(),
+ assumed.credentials().secretAccessKey(),
+ assumed.credentials().sessionToken())) {
+ assertThatThrownBy(s3::listBuckets)
+ .isInstanceOf(S3Exception.class)
+ .extracting(e -> ((S3Exception) e).statusCode())
+ .isEqualTo(403);
+ }
+ }
}
diff --git a/docs/configuration/multi-account.md b/docs/configuration/multi-account.md
index 135f676f31..ff4fc7097f 100644
--- a/docs/configuration/multi-account.md
+++ b/docs/configuration/multi-account.md
@@ -33,7 +33,7 @@ Account 111111111111 ──AssumeRole arn:aws:iam::222222222222:role/Deployer─
ASIA… temp key ──CreateTable orders──▶ stored as 222222222222/...::orders ◀──┘
```
-This makes the cross-account `AssumeRole`-then-provision pattern (e.g. CloudFormation deploying into a target account) work locally exactly as it does in AWS. Resolution precedence is: **12-digit AKID → temporary-session lookup → `FLOCI_DEFAULT_ACCOUNT_ID`.**
+This makes the cross-account `AssumeRole`-then-provision pattern (e.g. CloudFormation deploying into a target account) work locally exactly as it does in AWS. Resolution precedence is: **12-digit AKID → account ID; otherwise temporary-session lookup → `FLOCI_DEFAULT_ACCOUNT_ID`.**
## Default Behavior (Single Account)
diff --git a/docs/services/iam.md b/docs/services/iam.md
index 5a74ff9c57..4e35e8cde8 100644
--- a/docs/services/iam.md
+++ b/docs/services/iam.md
@@ -194,9 +194,11 @@ environment:
Policy evaluation follows the standard AWS precedence:
-1. An explicit **Deny** in any policy → request is denied (HTTP 403 `AccessDeniedException`)
-2. An explicit **Allow** in any policy → request is allowed
-3. No matching statement → implicit deny (HTTP 403)
+1. An explicit **Deny** in any identity, session, or boundary policy → request is denied (HTTP 403 `AccessDeniedException`)
+2. An explicit **Allow** in an identity policy creates the base grant
+3. If a session policy is present, it must also explicitly allow the request
+4. If a permission boundary is present, it must also explicitly allow the request
+5. No matching effective allow → implicit deny (HTTP 403)
### Bypass rules
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 b6df884d7c..900f535550 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
@@ -6,6 +6,7 @@ import io.github.hectorvent.floci.services.iam.IamPolicyEvaluator;
import io.github.hectorvent.floci.services.iam.IamPolicyEvaluator.Decision;
import io.github.hectorvent.floci.services.iam.IamService;
import io.github.hectorvent.floci.services.iam.ResourceArnBuilder;
+import io.github.hectorvent.floci.services.iam.model.CallerContext;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.inject.Inject;
import jakarta.ws.rs.container.ContainerRequestContext;
@@ -15,7 +16,6 @@ import jakarta.ws.rs.core.Response;
import jakarta.ws.rs.ext.Provider;
import org.jboss.logging.Logger;
-import java.util.List;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@@ -32,8 +32,9 @@ import java.util.regex.Pattern;
* <li>The action cannot be resolved (unknown mapping → permissive)</li>
* </ul>
*
- * <p>Phase 1 evaluates identity-based policies only.
- * Resource-based policies (S3 bucket policy, Lambda resource policy, etc.) are Phase 2.
+ * <p>Evaluates the caller's identity policies, optional session policy, and optional
+ * permissions boundary. Resource-based policies (S3 bucket policy, Lambda resource
+ * policy, etc.) are not yet supplied to this filter.
*/
@Provider
@ApplicationScoped
@@ -51,6 +52,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {
private final IamPolicyEvaluator evaluator;
private final IamActionRegistry actionRegistry;
private final ResourceArnBuilder arnBuilder;
+ private final RequestContext requestContext;
@Inject
public IamEnforcementFilter(EmulatorConfig config,
@@ -58,13 +60,15 @@ public class IamEnforcementFilter implements ContainerRequestFilter {
IamService iamService,
IamPolicyEvaluator evaluator,
IamActionRegistry actionRegistry,
- ResourceArnBuilder arnBuilder) {
+ ResourceArnBuilder arnBuilder,
+ RequestContext requestContext) {
this.config = config;
this.accountResolver = accountResolver;
this.iamService = iamService;
this.evaluator = evaluator;
this.actionRegistry = actionRegistry;
this.arnBuilder = arnBuilder;
+ this.requestContext = requestContext;
}
@Override
@@ -93,16 +97,18 @@ public class IamEnforcementFilter implements ContainerRequestFilter {
return; // unknown action → ALLOW (permissive)
}
- List<String> policies = iamService.resolveCallerPolicies(akid);
- if (policies == null) {
+ CallerContext caller = iamService.resolveCallerContext(akid);
+ if (caller == null) {
return; // unknown access key → bypass (backward-compat)
}
- String region = config.defaultRegion();
- String accountId = accountResolver.resolve(auth);
+ String region = requestContext.getRegion() == null ? config.defaultRegion() : requestContext.getRegion();
+ String accountId = requestContext.getAccountId() == null
+ ? accountResolver.resolve(auth)
+ : requestContext.getAccountId();
String resource = arnBuilder.build(credentialScope, ctx, region, accountId);
- Decision decision = evaluator.evaluate(policies, action, resource);
+ Decision decision = evaluator.evaluate(caller, null, action, resource, null);
if (decision == Decision.DENY) {
LOG.infov("IAM enforcement DENY: akid={0} action={1} resource={2}", akid, action, resource);
ctx.abortWith(accessDeniedResponse(action, credentialScope, ctx.getMediaType()));
diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java
index 1d41af31ba..81644d7272 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java
@@ -48,6 +48,7 @@ public class IamService implements SessionAccountLookup {
private static final Logger LOG = Logger.getLogger(IamService.class);
private static final String CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+ private static final String TEMPORARY_ACCESS_KEY_PREFIX = "ASIA";
private static final String DEFAULT_DEPLOYER_USER = "floci-deployer";
private static final String DEFAULT_DEPLOYER_ACCESS_KEY_ID = "floci";
private static final String DEFAULT_DEPLOYER_SECRET_ACCESS_KEY = "floci";
@@ -935,7 +936,7 @@ public class IamService implements SessionAccountLookup {
if (fromAccessKey.isPresent()) {
return fromAccessKey;
}
- return sessions.get(accessKeyId).map(SessionCredential::getSecretAccessKey);
+ return findSessionAnyAccount(accessKeyId).map(SessionCredential::getSecretAccessKey);
}
// =========================================================================
@@ -989,9 +990,7 @@ public class IamService implements SessionAccountLookup {
*/
@Override
public Optional<String> resolveAccountId(String accessKeyId) {
- // STS issues only ASIA-prefixed temporary keys, so anything else cannot be a session.
- // Short-circuit here to keep the per-request hot path off the session-store scan below.
- if (accessKeyId == null || !accessKeyId.startsWith("ASIA")) {
+ if (!isTemporaryAccessKey(accessKeyId)) {
return Optional.empty();
}
Optional<SessionCredential> sessionOpt = findSessionAnyAccount(accessKeyId);
@@ -1015,6 +1014,9 @@ public class IamService implements SessionAccountLookup {
* across all accounts; the access key's global uniqueness keeps the result unambiguous.
*/
private Optional<SessionCredential> findSessionAnyAccount(String accessKeyId) {
+ if (!isTemporaryAccessKey(accessKeyId)) {
+ return Optional.empty();
+ }
if (sessions instanceof AccountAwareStorageBackend<SessionCredential> aware) {
return Optional.ofNullable(aware.scanAllAccountsAsMap().get(accessKeyId));
}
@@ -1037,12 +1039,13 @@ public class IamService implements SessionAccountLookup {
return new CallerContext(identityPolicies, null, boundaryDoc);
}
- // Check assumed-role sessions
- Optional<SessionCredential> sessionOpt = sessions.get(accessKeyId);
+ // Check assumed-role sessions. These can be stored under the account that minted the
+ // session, while request routing for temporary credentials uses the role's account.
+ Optional<SessionCredential> sessionOpt = findSessionForCallerContext(accessKeyId);
if (sessionOpt.isPresent()) {
SessionCredential session = sessionOpt.get();
if (session.getExpiration() != null && session.getExpiration().isBefore(java.time.Instant.now())) {
- sessions.delete(accessKeyId);
+ deleteSession(accessKeyId, session);
return null; // expired — unknown key → bypass
}
@@ -1058,6 +1061,20 @@ public class IamService implements SessionAccountLookup {
return null;
}
+ private Optional<SessionCredential> findSessionForCallerContext(String accessKeyId) {
+ if (accessKeyId == null || accessKeyId.isBlank()) {
+ return Optional.empty();
+ }
+ Optional<SessionCredential> session = sessions.get(accessKeyId);
+ if (session.isPresent()) {
+ return session;
+ }
+ if (!isTemporaryAccessKey(accessKeyId)) {
+ return Optional.empty();
+ }
+ return findSessionAnyAccount(accessKeyId);
+ }
+
/**
* Collects all identity-based policy documents applicable to the caller identified
* by {@code accessKeyId}.
@@ -1083,11 +1100,11 @@ public class IamService implements SessionAccountLookup {
return users.get(userName).map(IamUser::getArn);
}
- Optional<SessionCredential> sessionOpt = sessions.get(accessKeyId);
+ Optional<SessionCredential> sessionOpt = findSessionForCallerContext(accessKeyId);
if (sessionOpt.isPresent()) {
SessionCredential session = sessionOpt.get();
if (session.getExpiration() != null && session.getExpiration().isBefore(java.time.Instant.now())) {
- sessions.delete(accessKeyId);
+ deleteSession(accessKeyId, session);
return Optional.empty();
}
String roleArn = session.getRoleArn();
@@ -1099,6 +1116,20 @@ public class IamService implements SessionAccountLookup {
return Optional.empty();
}
+ private static boolean isTemporaryAccessKey(String accessKeyId) {
+ return accessKeyId != null && accessKeyId.startsWith(TEMPORARY_ACCESS_KEY_PREFIX);
+ }
+
+ private void deleteSession(String accessKeyId, SessionCredential session) {
+ String originAccountId = session.getOriginAccountId();
+ if (originAccountId != null && !originAccountId.isBlank()
+ && sessions instanceof AccountAwareStorageBackend<SessionCredential> aware) {
+ aware.deleteForAccount(originAccountId, accessKeyId);
+ return;
+ }
+ sessions.delete(accessKeyId);
+ }
+
public CallerContext resolvePrincipalContext(String principalArn) {
if (principalArn == null || principalArn.isBlank()) {
throw new AwsException("ValidationError", "PolicySourceArn is required.", 400);
diff --git a/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java b/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java
index e052cd5b97..27a4fe3745 100644
--- a/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java
+++ b/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java
@@ -1,14 +1,28 @@
package io.github.hectorvent.floci.core.common;
+import io.github.hectorvent.floci.config.EmulatorConfig;
+import io.github.hectorvent.floci.services.iam.IamActionRegistry;
+import io.github.hectorvent.floci.services.iam.IamPolicyEvaluator;
+import io.github.hectorvent.floci.services.iam.IamService;
+import io.github.hectorvent.floci.services.iam.ResourceArnBuilder;
+import io.github.hectorvent.floci.services.iam.model.CallerContext;
import jakarta.ws.rs.core.MediaType;
import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.container.ContainerRequestContext;
import org.junit.jupiter.api.Test;
import java.nio.charset.StandardCharsets;
+import java.util.List;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
* Unit tests for {@link IamEnforcementFilter#accessDeniedResponse}, focused on
@@ -19,6 +33,56 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
*/
class IamEnforcementFilterTest {
+ @Test
+ void filterBuildsResourceArnWithRequestContextAccount() {
+ EmulatorConfig config = mock(EmulatorConfig.class);
+ EmulatorConfig.ServicesConfig services = mock(EmulatorConfig.ServicesConfig.class);
+ EmulatorConfig.IamServiceConfig iamConfig = mock(EmulatorConfig.IamServiceConfig.class);
+ AccountResolver accountResolver = mock(AccountResolver.class);
+ IamService iamService = mock(IamService.class);
+ IamPolicyEvaluator evaluator = mock(IamPolicyEvaluator.class);
+ IamActionRegistry actionRegistry = mock(IamActionRegistry.class);
+ ResourceArnBuilder arnBuilder = mock(ResourceArnBuilder.class);
+ RequestContext requestContext = new RequestContext();
+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);
+
+ String auth = "AWS4-HMAC-SHA256 Credential=ASIASESSION/20260629/us-east-1/lambda/aws4_request, "
+ + "SignedHeaders=host, Signature=abc";
+ requestContext.setAccountId("222233334444");
+ requestContext.setRegion("us-east-1");
+
+ when(config.services()).thenReturn(services);
+ when(services.iam()).thenReturn(iamConfig);
+ when(iamConfig.enforcementEnabled()).thenReturn(true);
+ when(config.defaultRegion()).thenReturn("us-east-1");
+ when(accountResolver.extractAccessKeyId(auth)).thenReturn("ASIASESSION");
+ when(accountResolver.resolve(auth)).thenReturn("000000000000");
+ when(containerRequest.getHeaderString("Authorization")).thenReturn(auth);
+ when(actionRegistry.resolve("lambda", containerRequest)).thenReturn("lambda:InvokeFunction");
+ when(iamService.resolveCallerContext("ASIASESSION"))
+ .thenReturn(CallerContext.of(List.of("""
+ {"Version":"2012-10-17","Statement":[
+ {"Effect":"Allow","Action":"lambda:InvokeFunction",
+ "Resource":"arn:aws:lambda:us-east-1:222233334444:function:fn"}
+ ]}""")));
+ when(arnBuilder.build("lambda", containerRequest, "us-east-1", "222233334444"))
+ .thenReturn("arn:aws:lambda:us-east-1:222233334444:function:fn");
+ when(evaluator.evaluate(
+ any(),
+ isNull(),
+ eq("lambda:InvokeFunction"),
+ eq("arn:aws:lambda:us-east-1:222233334444:function:fn"),
+ isNull()))
+ .thenReturn(IamPolicyEvaluator.Decision.ALLOW);
+
+ IamEnforcementFilter filter = new IamEnforcementFilter(
+ config, accountResolver, iamService, evaluator, actionRegistry, arnBuilder, requestContext);
+
+ filter.filter(containerRequest);
+
+ verify(arnBuilder).build("lambda", containerRequest, "us-east-1", "222233334444");
+ }
+
@Test
void queryProtocolGetsXmlErrorResponse() {
// IAM/STS/EC2/SQS/SNS/RDS/ELBv2/CFN/... — Query protocol, form-encoded body, XML response.
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java
index 9a73a0798a..0e39790470 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java
@@ -2,7 +2,9 @@ package io.github.hectorvent.floci.services.iam;
import io.github.hectorvent.floci.core.common.AwsException;
import io.github.hectorvent.floci.core.common.RegionResolver;
+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;
import io.github.hectorvent.floci.core.storage.InMemoryStorage;
+import io.github.hectorvent.floci.core.storage.StorageBackend;
import io.github.hectorvent.floci.services.iam.model.AccessKey;
import io.github.hectorvent.floci.services.iam.model.IamGroup;
import io.github.hectorvent.floci.services.iam.model.IamPolicy;
@@ -10,6 +12,7 @@ import io.github.hectorvent.floci.services.iam.model.IamRole;
import io.github.hectorvent.floci.services.iam.model.IamUser;
import io.github.hectorvent.floci.services.iam.model.InstanceProfile;
import io.github.hectorvent.floci.services.iam.model.PolicyVersion;
+import io.github.hectorvent.floci.services.iam.model.SessionCredential;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
@@ -33,6 +36,11 @@ class IamServiceTest {
}
private static IamService iamService(boolean seedDeployerPrincipal, InMemoryStorage<String, AccessKey> accessKeys) {
+ return iamService(seedDeployerPrincipal, accessKeys, new InMemoryStorage<>());
+ }
+
+ private static IamService iamService(boolean seedDeployerPrincipal, InMemoryStorage<String, AccessKey> accessKeys,
+ StorageBackend<String, SessionCredential> sessions) {
return new IamService(
new InMemoryStorage<>(),
new InMemoryStorage<>(),
@@ -40,7 +48,7 @@ class IamServiceTest {
new InMemoryStorage<>(),
accessKeys,
new InMemoryStorage<>(),
- new InMemoryStorage<>(),
+ sessions,
new RegionResolver("us-east-1", "000000000000"),
seedDeployerPrincipal
);
@@ -453,6 +461,31 @@ class IamServiceTest {
assertTrue(iamService.resolveAccountId(null).isEmpty());
}
+ @Test
+ void resolveAccountIdDoesNotScanSessionsForLongTermAccessKey() {
+ CountingAccountAwareSessionStorage sessions = new CountingAccountAwareSessionStorage();
+ IamService service = iamService(false, new InMemoryStorage<>(), sessions);
+
+ assertTrue(service.resolveAccountId("AKIAIOSFODNN7EXAMPLE").isEmpty());
+ assertEquals(0, sessions.scanAllAccountsAsMapCalls);
+ }
+
+ private static final class CountingAccountAwareSessionStorage
+ extends AccountAwareStorageBackend<SessionCredential> {
+
+ private int scanAllAccountsAsMapCalls;
+
+ private CountingAccountAwareSessionStorage() {
+ super(new InMemoryStorage<>(), null, "000000000000");
+ }
+
+ @Override
+ public Map<String, SessionCredential> scanAllAccountsAsMap() {
+ scanAllAccountsAsMapCalls++;
+ return super.scanAllAccountsAsMap();
+ }
+ }
+
@Test
void resolveAccountIdEmptyForExpiredSession() {
iamService.registerSession(
@@ -467,6 +500,25 @@ class IamServiceTest {
assertTrue(iamService.resolveAccountId("ASIAEXPIRED").isEmpty());
}
+ @Test
+ void resolveCallerContextDeletesExpiredCrossAccountSessionFromOriginAccount() {
+ String accessKeyId = "ASIAEXPIREDCROSSACCOUNT";
+ AccountAwareStorageBackend<SessionCredential> sessions = new AccountAwareStorageBackend<>(
+ new InMemoryStorage<>(), null, "222233334444");
+ sessions.putForAccount("111122223333", accessKeyId, new SessionCredential(
+ accessKeyId,
+ "temp-secret",
+ "arn:aws:iam::222233334444:role/CrossAccountAccess",
+ Instant.now().minusSeconds(60),
+ null,
+ "111122223333"));
+ IamService service = iamService(false, new InMemoryStorage<>(), sessions);
+
+ assertNull(service.resolveCallerContext(accessKeyId));
+
+ assertTrue(sessions.getForAccount("111122223333", accessKeyId).isEmpty());
+ }
+
// =========================================================================
// Instance Profiles
// =========================================================================
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/StsSessionPolicyS3EnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/StsSessionPolicyS3EnforcementIntegrationTest.java
new file mode 100644
index 0000000000..e1189a3b7c
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/StsSessionPolicyS3EnforcementIntegrationTest.java
@@ -0,0 +1,161 @@
+package io.github.hectorvent.floci.services.iam;
+
+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.util.Map;
+import java.util.UUID;
+
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.startsWith;
+
+@QuarkusTest
+@TestProfile(StsSessionPolicyS3EnforcementIntegrationTest.IamEnforcementProfile.class)
+class StsSessionPolicyS3EnforcementIntegrationTest {
+
+ private static final String CALLER_ACCOUNT_ID = "111122223333";
+ private static final String ROLE_ACCOUNT_ID = "222233334444";
+ private static final String REGION = "us-east-1";
+
+ @Test
+ void assumeRoleSessionPolicyDenyRestrictsS3PutObject() {
+ String suffix = UUID.randomUUID().toString().substring(0, 8);
+ String bucket = "session-policy-" + suffix;
+ String roleName = "SessionPolicyRole" + suffix;
+
+ createBucket(bucket);
+ createRole(roleName);
+ putBroadS3RolePolicy(roleName, bucket);
+
+ String accessKeyId = assumeRoleWithS3SessionPolicy(roleName, bucket);
+
+ given()
+ .header("Authorization", auth(accessKeyId, "s3"))
+ .contentType("text/plain")
+ .body("allowed")
+ .when()
+ .put("/" + bucket + "/allowed/file.txt")
+ .then()
+ .statusCode(200);
+
+ given()
+ .header("Authorization", auth(accessKeyId, "s3"))
+ .contentType("text/plain")
+ .body("denied")
+ .when()
+ .put("/" + bucket + "/blocked/file.txt")
+ .then()
+ .statusCode(403)
+ .body(containsString("<Code>AccessDenied</Code>"));
+ }
+
+ private static void createBucket(String bucket) {
+ given()
+ .header("Authorization", auth(ROLE_ACCOUNT_ID, "s3"))
+ .when()
+ .put("/" + bucket)
+ .then()
+ .statusCode(200);
+ }
+
+ private static void createRole(String roleName) {
+ given()
+ .formParam("Action", "CreateRole")
+ .formParam("RoleName", roleName)
+ .formParam("Path", "/")
+ .formParam("AssumeRolePolicyDocument", """
+ {
+ "Version": "2012-10-17",
+ "Statement": [
+ {
+ "Effect": "Allow",
+ "Principal": { "AWS": "*" },
+ "Action": "sts:AssumeRole"
+ }
+ ]
+ }
+ """)
+ .header("Authorization", auth(ROLE_ACCOUNT_ID, "iam"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ private static void putBroadS3RolePolicy(String roleName, String bucket) {
+ given()
+ .formParam("Action", "PutRolePolicy")
+ .formParam("RoleName", roleName)
+ .formParam("PolicyName", "AllowS3")
+ .formParam("PolicyDocument", """
+ {
+ "Version": "2012-10-17",
+ "Statement": [
+ {
+ "Effect": "Allow",
+ "Action": "s3:*",
+ "Resource": [
+ "arn:aws:s3:::%1$s",
+ "arn:aws:s3:::%1$s/*"
+ ]
+ }
+ ]
+ }
+ """.formatted(bucket))
+ .header("Authorization", auth(ROLE_ACCOUNT_ID, "iam"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200);
+ }
+
+ private static String assumeRoleWithS3SessionPolicy(String roleName, String bucket) {
+ return given()
+ .formParam("Action", "AssumeRole")
+ .formParam("RoleArn", "arn:aws:iam::" + ROLE_ACCOUNT_ID + ":role/" + roleName)
+ .formParam("RoleSessionName", "session-policy-test")
+ .formParam("Policy", """
+ {
+ "Version": "2012-10-17",
+ "Statement": [
+ {
+ "Effect": "Allow",
+ "Action": "s3:*",
+ "Resource": [
+ "arn:aws:s3:::%1$s",
+ "arn:aws:s3:::%1$s/*"
+ ]
+ },
+ {
+ "Effect": "Deny",
+ "Action": "s3:*",
+ "Resource": "arn:aws:s3:::%1$s/blocked/*"
+ }
+ ]
+ }
+ """.formatted(bucket))
+ .header("Authorization", auth(CALLER_ACCOUNT_ID, "sts"))
+ .when()
+ .post("/")
+ .then()
+ .statusCode(200)
+ .body("AssumeRoleResponse.AssumeRoleResult.Credentials.AccessKeyId", startsWith("ASIA"))
+ .extract()
+ .path("AssumeRoleResponse.AssumeRoleResult.Credentials.AccessKeyId");
+ }
+
+ private static String auth(String accessKeyId, String service) {
+ return "AWS4-HMAC-SHA256 Credential=" + accessKeyId + "/20260629/" + REGION + "/" + service
+ + "/aws4_request, SignedHeaders=host, Signature=abc";
+ }
+
+ public static final class IamEnforcementProfile implements QuarkusTestProfile {
+ @Override
+ public Map<String, String> getConfigOverrides() {
+ return Map.of("floci.services.iam.enforcement-enabled", "true");
+ }
+ }
+}