Light, fluffy, and always free - The AWS Local Emulator alternative
feat(iam): enforce AssumeRole trust policies when enforcement is enabled (#1552)
Alex Bannad54a307ca911
diff --git a/docs/services/sts.md b/docs/services/sts.mdindex 1477e09cd4..b71b42649f 100644--- a/docs/services/sts.md+++ b/docs/services/sts.md@@ -20,6 +20,24 @@|---|---|---|| `FLOCI_SERVICES_STS_ENABLED` | `true` | Enable or disable the service |+## Trust Policy Enforcement++By default `AssumeRole` succeeds for any caller. When `FLOCI_SERVICES_IAM_ENFORCEMENT_ENABLED=true`,+`AssumeRole` evaluates the target role's trust policy (`AssumeRolePolicyDocument`) against the caller+and returns `AccessDenied` if it is not permitted. AWS principal forms are matched — `"*"`, an+account id, an account-root ARN (`arn:aws:iam::<acct>:root`), and exact principal ARNs — and an+explicit `Deny` always wins. Both `Action` and `NotAction` elements are honored when matching+`sts:AssumeRole`. Roles that Floci has no record of stay permissive, so this only affects roles+created through IAM with a real trust policy.++### Known limitations++- **`Condition` blocks are not evaluated.** A trust policy that requires `sts:ExternalId` (the+ confused-deputy guard) is matched on its principal alone, so the role is assumable without passing+ `ExternalId`, and the `ExternalId` request parameter is ignored. This matches moto/LocalStack.+- **Only the trust policy is checked.** Cross-account `AssumeRole` in AWS also requires the caller's+ own identity policy to allow `sts:AssumeRole`; that side is not enforced.+## Examples```bashdiff --git a/src/main/java/io/github/hectorvent/floci/services/iam/AssumeRolePolicyEvaluator.java b/src/main/java/io/github/hectorvent/floci/services/iam/AssumeRolePolicyEvaluator.javanew file mode 100644index 0000000000..5bf2e0c9b1--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iam/AssumeRolePolicyEvaluator.java@@ -0,0 +1,190 @@+package io.github.hectorvent.floci.services.iam;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;+import org.jboss.logging.Logger;++import java.util.regex.Pattern;++/**+ * Evaluates a role's trust policy (AssumeRolePolicyDocument) to decide whether a caller may assume+ * the role via {@code sts:AssumeRole}.+ *+ * <p>Trust policies are principal-centric and carry no {@code Resource} element, so they cannot be+ * evaluated by {@link IamPolicyEvaluator} (which is identity/resource oriented). This focused+ * evaluator matches each statement's {@code Action} and {@code Principal} against the caller and+ * applies AWS precedence: an explicit {@code Deny} wins, otherwise a matching {@code Allow} grants.+ *+ * <p>Only AWS principals are modeled (account-root, bare account id, exact principal ARN, and+ * {@code "*"}); {@code Service} and {@code Federated} principals never match a SigV4 caller and are+ * ignored. A caller using assumed-role temporary credentials (whose ARN is an STS+ * {@code assumed-role} ARN) also matches a trust policy that names the underlying IAM role ARN, as+ * AWS resolves the session back to its role for trust-policy evaluation.+ */+@ApplicationScoped+public class AssumeRolePolicyEvaluator {++ private static final Logger LOG = Logger.getLogger(AssumeRolePolicyEvaluator.class);+ private static final String ASSUME_ROLE_ACTION = "sts:AssumeRole";+ private static final Pattern ACCOUNT_ROOT_ARN = Pattern.compile("^arn:aws:iam::(\\d{12}):root$");+ private static final Pattern ASSUMED_ROLE_ARN =+ Pattern.compile("^arn:aws:sts::(\\d{12}):assumed-role/([^/]+)/.*$");++ private final ObjectMapper objectMapper;++ @Inject+ public AssumeRolePolicyEvaluator(ObjectMapper objectMapper) {+ this.objectMapper = objectMapper;+ }++ /**+ * Returns true if {@code trustPolicyDocument} allows the caller (identified by+ * {@code callerArn}, in {@code callerAccount}) to perform {@code sts:AssumeRole}.+ *+ * <p>A null/blank/unparseable document or one with no matching {@code Allow} denies.+ */+ public boolean allows(String trustPolicyDocument, String callerArn, String callerAccount) {+ if (trustPolicyDocument == null || trustPolicyDocument.isBlank()) {+ return false;+ }+ JsonNode statements;+ try {+ statements = objectMapper.readTree(trustPolicyDocument).path("Statement");+ } catch (Exception e) {+ LOG.warnv("Failed to parse trust policy: {0}", e.getMessage());+ return false;+ }++ boolean allow = false;+ if (statements.isArray()) {+ for (JsonNode stmt : statements) {+ switch (evaluateStatement(stmt, callerArn, callerAccount)) {+ case DENY -> { return false; }+ case ALLOW -> allow = true;+ case NO_MATCH -> { }+ }+ }+ } else if (statements.isObject()) {+ return evaluateStatement(statements, callerArn, callerAccount) == Match.ALLOW;+ }+ return allow;+ }++ private enum Match { ALLOW, DENY, NO_MATCH }++ private Match evaluateStatement(JsonNode stmt, String callerArn, String callerAccount) {+ if (!actionApplies(stmt)) {+ return Match.NO_MATCH;+ }+ if (!matchesPrincipal(stmt.get("Principal"), callerArn, callerAccount)) {+ return Match.NO_MATCH;+ }+ return "Deny".equalsIgnoreCase(stmt.path("Effect").asText("Allow")) ? Match.DENY : Match.ALLOW;+ }++ /**+ * True if the statement's action element applies to {@code sts:AssumeRole}. An {@code Action}+ * element applies when any of its patterns match; a {@code NotAction} element applies when none+ * of its patterns match (AWS semantics, mirroring {@link IamPolicyEvaluator}'s action handling).+ * A statement with neither key expresses no action constraint and does not apply.+ */+ private boolean actionApplies(JsonNode stmt) {+ JsonNode action = stmt.get("Action");+ if (action != null) {+ return matchesAssumeRoleAction(action);+ }+ JsonNode notAction = stmt.get("NotAction");+ if (notAction != null) {+ return !matchesAssumeRoleAction(notAction);+ }+ return false;+ }++ private boolean matchesAssumeRoleAction(JsonNode actionNode) {+ if (actionNode == null) {+ return false;+ }+ if (actionNode.isTextual()) {+ return IamPolicyEvaluator.globMatches(actionNode.asText(), ASSUME_ROLE_ACTION);+ }+ if (actionNode.isArray()) {+ for (JsonNode a : actionNode) {+ if (a.isTextual() && IamPolicyEvaluator.globMatches(a.asText(), ASSUME_ROLE_ACTION)) {+ return true;+ }+ }+ }+ return false;+ }++ private boolean matchesPrincipal(JsonNode principalNode, String callerArn, String callerAccount) {+ if (principalNode == null) {+ return false;+ }+ // Principal: "*"+ if (principalNode.isTextual()) {+ return "*".equals(principalNode.asText());+ }+ if (!principalNode.isObject()) {+ return false;+ }+ // Only the AWS principal type can match a SigV4 caller.+ JsonNode aws = principalNode.get("AWS");+ if (aws == null) {+ return false;+ }+ if (aws.isTextual()) {+ return matchesAwsPrincipal(aws.asText(), callerArn, callerAccount);+ }+ if (aws.isArray()) {+ for (JsonNode entry : aws) {+ if (entry.isTextual() && matchesAwsPrincipal(entry.asText(), callerArn, callerAccount)) {+ return true;+ }+ }+ }+ return false;+ }++ private boolean matchesAwsPrincipal(String principal, String callerArn, String callerAccount) {+ if (principal == null) {+ return false;+ }+ if ("*".equals(principal)) {+ return true;+ }+ // Bare 12-digit account id, or an account-root ARN → matches any principal in that account.+ if (principal.matches("\\d{12}")) {+ return principal.equals(callerAccount);+ }+ var rootMatcher = ACCOUNT_ROOT_ARN.matcher(principal);+ if (rootMatcher.matches()) {+ return rootMatcher.group(1).equals(callerAccount);+ }+ // Otherwise an exact (glob-capable) principal ARN.+ if (callerArn == null) {+ return false;+ }+ if (IamPolicyEvaluator.globMatches(principal, callerArn)) {+ return true;+ }+ // When the caller used assumed-role temporary credentials, callerArn is the STS+ // assumed-role ARN (arn:aws:sts::ACCT:assumed-role/Role/session). A role's trust policy is+ // written with the role's *IAM* principal ARN (arn:aws:iam::ACCT:role/Role) — AWS resolves+ // the session back to the role for trust matching — so also match that canonical form.+ String roleArn = assumedRoleToRoleArn(callerArn);+ return roleArn != null && IamPolicyEvaluator.globMatches(principal, roleArn);+ }++ /**+ * Maps an STS assumed-role ARN ({@code arn:aws:sts::ACCT:assumed-role/Role/session}) to the+ * underlying IAM role ARN ({@code arn:aws:iam::ACCT:role/Role}), or {@code null} if {@code arn}+ * is not an assumed-role ARN.+ */+ private static String assumedRoleToRoleArn(String arn) {+ var m = ASSUMED_ROLE_ARN.matcher(arn);+ return m.matches() ? "arn:aws:iam::" + m.group(1) + ":role/" + m.group(2) : null;+ }+}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.javaindex 4ee2335df1..1d41af31ba 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@@ -357,6 +357,19 @@ public class IamService implements SessionAccountLookup {"The role with name " + roleName + " cannot be found.", 404));}+ /**+ * Looks up a role by name in a specific account's namespace, without throwing when absent.+ *+ * <p>Roles are account-namespaced, so a cross-account caller (e.g. STS AssumeRole) must resolve+ * the role in its owning account — taken from the role ARN — rather than the request's account.+ */+ public Optional<IamRole> findRole(String accountId, String roleName) {+ if (roles instanceof AccountAwareStorageBackend<IamRole> aware) {+ return aware.getForAccount(accountId, roleName);+ }+ return roles.get(roleName);+ }+public void deleteRole(String roleName) {IamRole role = getRole(roleName);if (!role.getAttachedPolicyArns().isEmpty() || !role.getInlinePolicies().isEmpty()) {diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.javaindex c6997647a7..e39dcb9846 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.iam;+import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsNamespaces;import io.github.hectorvent.floci.core.common.AwsQueryController;@@ -7,6 +8,7 @@ import io.github.hectorvent.floci.core.common.AwsQueryResponse;import io.github.hectorvent.floci.core.common.AccountResolver;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.common.XmlBuilder;+import io.github.hectorvent.floci.services.iam.model.IamRole;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import jakarta.ws.rs.core.Context;@@ -17,6 +19,7 @@ import org.jboss.logging.Logger;import java.time.Instant;import java.time.format.DateTimeFormatter;+import java.util.Optional;import java.util.concurrent.ThreadLocalRandom;/**@@ -33,15 +36,20 @@ public class StsQueryHandler {private final IamService iamService;private final AccountResolver accountResolver;private final RegionResolver regionResolver;+ private final EmulatorConfig config;+ private final AssumeRolePolicyEvaluator trustPolicyEvaluator;@ContextHttpHeaders headers;@Inject- public StsQueryHandler(IamService iamService, AccountResolver accountResolver, RegionResolver regionResolver) {+ public StsQueryHandler(IamService iamService, AccountResolver accountResolver, RegionResolver regionResolver,+ EmulatorConfig config, AssumeRolePolicyEvaluator trustPolicyEvaluator) {this.iamService = iamService;this.accountResolver = accountResolver;this.regionResolver = regionResolver;+ this.config = config;+ this.trustPolicyEvaluator = trustPolicyEvaluator;}public Response handle(String action, MultivaluedMap<String, String> params) {@@ -79,6 +87,12 @@ public class StsQueryHandler {: "UnknownRole";String callerAccountId = regionResolver.getAccountId();String accountId = AwsArnUtils.accountOrDefault(roleArn, callerAccountId);++ Response trustDenied = enforceTrustPolicy(roleArn, roleName, accountId);+ if (trustDenied != null) {+ return trustDenied;+ }+String assumedRoleArn = AwsArnUtils.Arn.of("sts", "", accountId, "assumed-role/" + roleName + "/" + sessionName).toString();String assumedRoleId = "AROA" + randomId(16) + ":" + sessionName;@@ -99,6 +113,32 @@ public class StsQueryHandler {return Response.ok(AwsQueryResponse.envelope("AssumeRole", AwsNamespaces.STS, result)).build();}+ /**+ * When IAM enforcement is enabled, denies AssumeRole if the target role's trust policy does not+ * permit the caller. Returns {@code null} to allow — enforcement disabled, the role is unknown+ * to Floci (permissive, backward-compatible), or the caller is permitted.+ */+ private Response enforceTrustPolicy(String roleArn, String roleName, String roleAccountId) {+ if (!config.services().iam().enforcementEnabled()) {+ return null;+ }+ Optional<IamRole> role = iamService.findRole(roleAccountId, roleName);+ if (role.isEmpty()) {+ return null;+ }+ String auth = headers == null ? null : headers.getHeaderString("Authorization");+ String callerAccount = accountResolver.resolve(auth);+ String callerArn = iamService.resolveCallerArn(+ auth == null ? null : accountResolver.extractAccessKeyId(auth))+ .orElse(AwsArnUtils.Arn.of("iam", "", callerAccount, "root").toString());+ if (trustPolicyEvaluator.allows(role.get().getAssumeRolePolicyDocument(), callerArn, callerAccount)) {+ return null;+ }+ return AwsQueryResponse.error("AccessDenied",+ "User: " + callerArn + " is not authorized to perform: sts:AssumeRole on resource: " + roleArn,+ AwsNamespaces.STS, 403);+ }+private Response handleGetCallerIdentity(MultivaluedMap<String, String> params) {String accountId = regionResolver.getAccountId();String authorization = headers == null ? null : headers.getHeaderString("Authorization");diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/AssumeRolePolicyEvaluatorTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/AssumeRolePolicyEvaluatorTest.javanew file mode 100644index 0000000000..6797faf19c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/AssumeRolePolicyEvaluatorTest.java@@ -0,0 +1,167 @@+package io.github.hectorvent.floci.services.iam;++import com.fasterxml.jackson.databind.ObjectMapper;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++class AssumeRolePolicyEvaluatorTest {++ private final AssumeRolePolicyEvaluator evaluator = new AssumeRolePolicyEvaluator(new ObjectMapper());++ private static final String CALLER_ARN = "arn:aws:iam::111111111111:user/alice";+ private static final String CALLER_ACCOUNT = "111111111111";++ private static String trust(String principal) {+ return """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Principal":%s,"Action":"sts:AssumeRole"}]}+ """.formatted(principal);+ }++ @Test+ void allowsAccountRootPrincipal() {+ assertTrue(evaluator.allows(+ trust("{\"AWS\":\"arn:aws:iam::111111111111:root\"}"), CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void allowsBareAccountPrincipal() {+ assertTrue(evaluator.allows(trust("{\"AWS\":\"111111111111\"}"), CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void allowsExactPrincipalArn() {+ assertTrue(evaluator.allows(+ trust("{\"AWS\":\"arn:aws:iam::111111111111:user/alice\"}"), CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void allowsWildcardPrincipal() {+ assertTrue(evaluator.allows(trust("\"*\""), CALLER_ARN, CALLER_ACCOUNT));+ assertTrue(evaluator.allows(trust("{\"AWS\":\"*\"}"), CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void allowsWhenPrincipalListContainsCaller() {+ assertTrue(evaluator.allows(+ trust("{\"AWS\":[\"arn:aws:iam::999999999999:root\",\"arn:aws:iam::111111111111:root\"]}"),+ CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void deniesWhenAccountDoesNotMatch() {+ assertFalse(evaluator.allows(+ trust("{\"AWS\":\"arn:aws:iam::999999999999:root\"}"), CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void deniesWhenPrincipalArnDiffers() {+ assertFalse(evaluator.allows(+ trust("{\"AWS\":\"arn:aws:iam::111111111111:user/bob\"}"), CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void explicitDenyOverridesAllow() {+ String doc = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Principal":{"AWS":"*"},"Action":"sts:AssumeRole"},+ {"Effect":"Deny","Principal":{"AWS":"arn:aws:iam::111111111111:root"},"Action":"sts:AssumeRole"}]}+ """;+ assertFalse(evaluator.allows(doc, CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void deniesWhenActionIsNotAssumeRole() {+ String doc = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Principal":{"AWS":"*"},"Action":"sts:TagSession"}]}+ """;+ assertFalse(evaluator.allows(doc, CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void allowsWildcardAction() {+ String doc = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Principal":{"AWS":"111111111111"},"Action":"sts:*"}]}+ """;+ assertTrue(evaluator.allows(doc, CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void deniesWhenDenyNotActionExcludesAssumeRole() {+ // Deny applies to every action except sts:TagSession — which includes sts:AssumeRole — so it blocks.+ String doc = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Principal":{"AWS":"*"},"Action":"sts:AssumeRole"},+ {"Effect":"Deny","Principal":{"AWS":"*"},"NotAction":"sts:TagSession"}]}+ """;+ assertFalse(evaluator.allows(doc, CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void allowsWhenDenyNotActionIncludesAssumeRole() {+ // Deny applies to every action except sts:AssumeRole, so it does NOT block the assume.+ String doc = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Principal":{"AWS":"*"},"Action":"sts:AssumeRole"},+ {"Effect":"Deny","Principal":{"AWS":"*"},"NotAction":"sts:AssumeRole"}]}+ """;+ assertTrue(evaluator.allows(doc, CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void allowsWhenAllowNotActionDoesNotCoverAssumeRole() {+ // Allow applies to every action except sts:GetSessionToken, so it grants sts:AssumeRole.+ String doc = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Principal":{"AWS":"111111111111"},"NotAction":"sts:GetSessionToken"}]}+ """;+ assertTrue(evaluator.allows(doc, CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void allowsAssumedRoleCallerAgainstRolePrincipalArn() {+ // The caller used assumed-role temp creds (callerArn is the STS assumed-role ARN), but the+ // trust policy names the underlying IAM role ARN — the canonical trust-policy form. It must+ // match, since AWS resolves the session back to its role for trust evaluation.+ String assumedRoleArn = "arn:aws:sts::111111111111:assumed-role/AppRole/session-abc";+ assertTrue(evaluator.allows(+ trust("{\"AWS\":\"arn:aws:iam::111111111111:role/AppRole\"}"),+ assumedRoleArn, CALLER_ACCOUNT));+ }++ @Test+ void deniesAssumedRoleCallerWhenRolePrincipalDiffers() {+ // A trust policy naming a different role must not be satisfied by this session.+ String assumedRoleArn = "arn:aws:sts::111111111111:assumed-role/AppRole/session-abc";+ assertFalse(evaluator.allows(+ trust("{\"AWS\":\"arn:aws:iam::111111111111:role/OtherRole\"}"),+ assumedRoleArn, CALLER_ACCOUNT));+ }++ @Test+ void allowsAssumedRoleCallerAgainstExactSessionArn() {+ // A trust policy that names the exact assumed-role session ARN still matches directly.+ String assumedRoleArn = "arn:aws:sts::111111111111:assumed-role/AppRole/session-abc";+ assertTrue(evaluator.allows(+ trust("{\"AWS\":\"arn:aws:sts::111111111111:assumed-role/AppRole/session-abc\"}"),+ assumedRoleArn, CALLER_ACCOUNT));+ }++ @Test+ void deniesServiceOnlyPrincipal() {+ assertFalse(evaluator.allows(+ trust("{\"Service\":\"lambda.amazonaws.com\"}"), CALLER_ARN, CALLER_ACCOUNT));+ }++ @Test+ void deniesBlankOrMalformedDocument() {+ assertFalse(evaluator.allows(null, CALLER_ARN, CALLER_ACCOUNT));+ assertFalse(evaluator.allows("", CALLER_ARN, CALLER_ACCOUNT));+ assertFalse(evaluator.allows("{}", CALLER_ARN, CALLER_ACCOUNT));+ assertFalse(evaluator.allows("not json", CALLER_ARN, CALLER_ACCOUNT));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/AssumeRoleTrustPolicyIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/AssumeRoleTrustPolicyIntegrationTest.javanew file mode 100644index 0000000000..d06ed27cc3--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/AssumeRoleTrustPolicyIntegrationTest.java@@ -0,0 +1,105 @@+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;++/**+ * Verifies that, with {@code iam.enforcement-enabled=true}, STS AssumeRole honors the target role's+ * trust policy: a caller the trust policy permits succeeds; one it does not is denied; and a role+ * Floci does not know about stays permissive (backward-compatible).+ */+@QuarkusTest+@TestProfile(AssumeRoleTrustPolicyIntegrationTest.EnforcementProfile.class)+class AssumeRoleTrustPolicyIntegrationTest {++ public static class EnforcementProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.iam.enforcement-enabled", "true");+ }+ }++ private static final String ACCOUNT_A = "111111111111";+ private static final String ACCOUNT_B = "222222222222";+ private static final String ACCOUNT_C = "333333333333";++ private static final String TRUST_ALLOW_A = "{\"Version\":\"2012-10-17\",\"Statement\":[{"+ + "\"Effect\":\"Allow\",\"Principal\":{\"AWS\":\"arn:aws:iam::" + ACCOUNT_A + ":root\"},"+ + "\"Action\":\"sts:AssumeRole\"}]}";++ private static String auth(String account, String service) {+ return "AWS4-HMAC-SHA256 Credential=" + account + "/20260215/us-east-1/" + service+ + "/aws4_request, SignedHeaders=host, Signature=abc";+ }++ private static void createRoleInB(String roleName) {+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateRole")+ .formParam("RoleName", roleName)+ .formParam("AssumeRolePolicyDocument", TRUST_ALLOW_A)+ .header("Authorization", auth(ACCOUNT_B, "iam"))+ .when().post("/")+ .then().statusCode(200);+ }++ @Test+ void permittedCallerCanAssumeRole() {+ String role = "trust-ok-" + UUID.randomUUID().toString().substring(0, 8);+ createRoleInB(role);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "AssumeRole")+ .formParam("RoleArn", "arn:aws:iam::" + ACCOUNT_B + ":role/" + role)+ .formParam("RoleSessionName", "s")+ .header("Authorization", auth(ACCOUNT_A, "sts"))+ .when().post("/")+ .then().statusCode(200)+ .body("AssumeRoleResponse.AssumeRoleResult.Credentials.AccessKeyId", startsWith("ASIA"));+ }++ @Test+ void unauthorizedCallerIsDenied() {+ String role = "trust-deny-" + UUID.randomUUID().toString().substring(0, 8);+ createRoleInB(role);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "AssumeRole")+ .formParam("RoleArn", "arn:aws:iam::" + ACCOUNT_B + ":role/" + role)+ .formParam("RoleSessionName", "s")+ .header("Authorization", auth(ACCOUNT_C, "sts"))+ .when().post("/")+ .then().statusCode(403)+ .body(containsString("AccessDenied"))+ // AWS prefixes the denial with the caller and names the action and resource.+ .body(containsString("User: "))+ .body(containsString("is not authorized to perform: sts:AssumeRole on resource: "+ + "arn:aws:iam::" + ACCOUNT_B + ":role/" + role));+ }++ @Test+ void unknownRoleStaysPermissive() {+ // No role created — enforcement must not block roles Floci has never seen.+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "AssumeRole")+ .formParam("RoleArn", "arn:aws:iam::" + ACCOUNT_B + ":role/never-created-"+ + UUID.randomUUID().toString().substring(0, 8))+ .formParam("RoleSessionName", "s")+ .header("Authorization", auth(ACCOUNT_C, "sts"))+ .when().post("/")+ .then().statusCode(200)+ .body("AssumeRoleResponse.AssumeRoleResult.Credentials.AccessKeyId", startsWith("ASIA"));+ }+}