Light, fluffy, and always free - The AWS Local Emulator alternative
fix(iam): match absent context keys with ForAllValues (#5482)
David Phillipsea8da22226d9
diff --git a/docs/services/iam.md b/docs/services/iam.mdindex a5beba9cf5..1d90655e0b 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -1199,11 +1199,13 @@ account key carries no identity policies of its own.- `NumericEquals`, `NumericNotEquals`, `NumericLessThan`, `NumericGreaterThan` (and Equals variants)- `DateEquals`, `DateNotEquals`, `DateLessThan`, `DateGreaterThan` (and Equals variants)- `Bool`, `IpAddress`, `NotIpAddress`, `Null`-- Supports `...IfExists` variants for all operators.+- Supports `...IfExists` variants for all operators except `Null`.- Set operators `ForAllValues:` and `ForAnyValue:` over multi-valued condition keys, in AWS'sown spelling (the prefix match is case-sensitive). They compose with `IfExists`- (`ForAnyValue:StringEqualsIfExists`). `ForAllValues:` over an empty set matches vacuously- and `ForAnyValue:` over an empty set does not match, so pair `ForAllValues:` with+ (`ForAnyValue:StringEqualsIfExists`). `ForAllValues:` matches when the context key is absent+ or its value set is empty; `ForAnyValue:` does not match either case. This follows the+ [AWS set-operator rules](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-single-vs-multi-valued-context-keys.html).+ Pair `ForAllValues:` with`"Null":{"<key>":"false"}` as you would on AWS: `Null` treats a present-but-empty set asabsent, so the guard fires either way.- When a condition lists several values, a positive operator matches if the request value@@ -1232,11 +1234,17 @@ floci populates:An allow conditioned on it denies the delete of a correctly tagged object, and a create cannotbe gated on tags an object does not have yet.- `s3:RequestObjectTag/<key>`: a tag the request asks to attach. `s3:PutObject` reads these- from the `x-amz-tagging` header and `s3:PutObjectTagging` from the `<Tagging>` body. Any pair+ from the `x-amz-tagging` header, or its query parameter when the header is absent,+ and `s3:PutObjectTagging` from the `<Tagging>` body. Any pairthat does not decode is dropped, so a policy conditioned on the key denies such a request. Whereenforcement lets it through, the handler still answers a malformed header with- `400 InvalidTag`. `s3:RequestObjectTagKeys` is **not** populated, so a condition on it never- matches.+ `400 InvalidTag`.+- `s3:RequestObjectTagKeys`: the case-sensitive requested object tag keys from the same+ `PutObject` header/query source or `PutObjectTagging` body. Header and query tag keys+ are URL-decoded before matching; a present header takes precedence over the query.+ `ForAllValues:StringEquals` can limit all requested keys without a `Null` guard; an+ omitted or empty tag set still follows the absent-key rules above. Existing object tags+ do not contribute to this requested set. See the [AWS object-tag policy guidance](https://docs.aws.amazon.com/AmazonS3/latest/userguide/tagging-and-policies.html).- A `PutObject` carrying `If-Match` is authorized as `s3:GetObject` as well, and that secondcheck is made without the object's tags in the context, as measured on AWS. `If-None-Match`needs no such permission.@@ -1247,6 +1255,9 @@ floci populates:`assumed-role` session ARN, as AWS reports it ("For IAM roles, the request context returns theARN of the role"); a condition naming the session ARN does not match. It is **absent** only forunknown keys, where nothing about the caller can be resolved.+- `aws:TagKeys`: the case-sensitive requested tag keys for EC2 `RunInstances` and+ `CreateTags`, and S3 `PutBucketTagging`. `ForAllValues:StringEquals` can restrict the+ complete requested set without a `Null` guard; no tags still means absent context.- `dynamodb:LeadingKeys`, `dynamodb:Attributes`, `dynamodb:Select`: from the DynamoDB requestbody, for `GetItem`, `PutItem`, `UpdateItem`, `DeleteItem`, `Query`, `BatchGetItem` and`BatchWriteItem` (`dynamodb:Select` for `Query` and `Scan`). `LeadingKeys` holds the@@ -1256,18 +1267,16 @@ floci populates:projection / update / filter / condition / key-condition expressions, and`ExpressionAttributeNames`); a request with no projection returns every attribute whilereporting only the names it mentions, exactly as on AWS, which is why AWS pairs `Attributes`- with `dynamodb:Select`. Each key is **omitted** when it cannot be determined (unknown table,- a `Key` that omits the partition attribute, an unparseable `KeyConditionExpression`, a- multi-table batch), so a policy scoping access through it denies the request rather than- allowing an unproven one.-- **Consequence:** with enforcement on and access scoped purely through `dynamodb:LeadingKeys`,- a malformed request (such as a `GetItem` whose `Key` omits the partition attribute) is answered with- `AccessDeniedException` instead of the `ValidationException` DynamoDB would return. Failing- closed is the correct direction for a security boundary.--**Any other condition key is absent from the request context.** A plain (non-`IfExists`)-operator on an absent key makes the whole statement *not apply*: it neither matches nor+ with `dynamodb:Select`. Query equality supports the attribute on either side, including aliases.+ Each batch entry uses its own table schema; authorization evaluates each table's requested+ keys separately, combining name and ARN entries for the same table. Each key is **omitted**+ when it cannot be determined, such as an unknown table, a missing partition attribute, or+ an unparseable expression. A `ForAllValues` condition matches absent context; add+ `Null:false` when the policy must require a resolved key. Malformed requests that pass+ authorization are still checked by the DynamoDB handler.++**Any other condition key is absent from the request context.** A positive scalar operator+without `IfExists` on an absent key makes the whole statement *not apply*: it neither matches norblocks. A `DenyRootUser`-style guardrail keyed on `aws:PrincipalArn` therefore fires againstthe account root the same way it does on real AWS, consistent with the account root alreadybeing bounded by SCPs (below): both forms of root enforcement now agree. A negated operatordiff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamConditionContextResolver.java b/src/main/java/io/github/hectorvent/floci/core/common/IamConditionContextResolver.javaindex 4f670dabd0..675758df6a 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/IamConditionContextResolver.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/IamConditionContextResolver.java@@ -1,6 +1,7 @@package io.github.hectorvent.floci.core.common;import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.services.dynamodb.DynamoDbConditionKeys;import io.github.hectorvent.floci.services.dynamodb.DynamoDbFacade;@@ -24,8 +25,10 @@ import java.nio.charset.Charset;import java.nio.charset.StandardCharsets;import java.util.ArrayList;import java.util.LinkedHashMap;+import java.util.LinkedHashSet;import java.util.List;import java.util.Map;+import java.util.Set;/*** Builds the IAM request context: the condition keys a policy's Condition block can match,@@ -53,6 +56,7 @@ public class IamConditionContextResolver {private static final String RESOURCE_TAG_PREFIX = "aws:ResourceTag/";public static final String EXISTING_OBJECT_TAG_PREFIX = "s3:ExistingObjectTag/";public static final String REQUEST_OBJECT_TAG_PREFIX = "s3:RequestObjectTag/";+ public static final String REQUEST_OBJECT_TAG_KEYS = "s3:RequestObjectTagKeys";private final Instance<DynamoDbFacade> dynamoDbFacade;private final Instance<Ec2Service> ec2Service;@@ -183,15 +187,20 @@ public class IamConditionContextResolver {}/**- * {@code s3:RequestObjectTag/<key>} from a PutObject's {@code x-amz-tagging} header, which the- * S3 model documents as a URL query parameter encoding of the tag-set.+ * {@code s3:RequestObjectTag/<key>} from a PutObject's {@code x-amz-tagging} header, or the+ * query parameter where a presigner may place it. The header takes precedence, including+ * an empty header, matching the source the S3 controller applies to the object.*/private Map<String, List<String>> s3RequestObjectTagConditionContext(ContainerRequestContext ctx) {String header = ctx.getHeaderString("x-amz-tagging");+ if (header == null && ctx.getUriInfo() != null) {+ header = ctx.getUriInfo().getQueryParameters().getFirst("x-amz-tagging");+ }if (header == null || header.isBlank()) {return null;}Map<String, List<String>> conditions = new LinkedHashMap<>();+ Set<String> requestedKeys = new LinkedHashSet<>();for (String pair : header.split("&")) {int eq = pair.indexOf('=');if (eq <= 0) {@@ -203,6 +212,10 @@ public class IamConditionContextResolver {continue;}conditions.put(REQUEST_OBJECT_TAG_PREFIX + name, List.of(value));+ requestedKeys.add(name);+ }+ if (!requestedKeys.isEmpty()) {+ conditions.put(REQUEST_OBJECT_TAG_KEYS, new ArrayList<>(requestedKeys));}return conditions.isEmpty() ? null : conditions;}@@ -220,6 +233,7 @@ public class IamConditionContextResolver {}Map<String, List<String>> conditions = new LinkedHashMap<>();tags.forEach((k, v) -> conditions.put(REQUEST_OBJECT_TAG_PREFIX + k, List.of(v)));+ conditions.put(REQUEST_OBJECT_TAG_KEYS, new ArrayList<>(tags.keySet()));return conditions;}@@ -286,6 +300,9 @@ public class IamConditionContextResolver {new String(body, StandardCharsets.UTF_8), "Tag", "Key", "Value");Map<String, List<String>> conditions = new LinkedHashMap<>();requested.forEach((key, value) -> conditions.put(REQUEST_TAG_PREFIX + key, List.of(value)));+ if (!requested.isEmpty()) {+ conditions.put("aws:TagKeys", List.copyOf(requested.keySet()));+ }return conditions.isEmpty() ? null : conditions;}@@ -408,7 +425,12 @@ public class IamConditionContextResolver {String prefix) {for (int i = 1; form.containsKey(prefix + i + ".Key"); i++) {String value = form.get(prefix + i + ".Value");- conditions.put(REQUEST_TAG_PREFIX + form.get(prefix + i + ".Key"),+ String key = form.get(prefix + i + ".Key");+ List<String> keys = conditions.computeIfAbsent("aws:TagKeys", ignored -> new ArrayList<>());+ if (!keys.contains(key)) {+ keys.add(key);+ }+ conditions.put(REQUEST_TAG_PREFIX + key,List.of(value == null ? "" : value));}}@@ -499,16 +521,19 @@ public class IamConditionContextResolver {* {@code dynamodb:Select} from the buffered request body.** <p>A key that cannot be resolved (unknown table, a Key that omits the partition- * attribute, an unparseable KeyConditionExpression) is omitted rather than guessed. A- * policy scoping access through the missing key then does not match, so the request is- * denied: a request that cannot be proven in scope is treated as out of scope.+ * attribute, an unparseable KeyConditionExpression) is omitted rather than guessed.+ * A {@code ForAllValues} condition matches an absent key; policies must pair it with+ * {@code Null:false} to require a resolved key.*/Map<String, List<String>> dynamoDbConditionContext(String action, ContainerRequestContext ctx) {JsonNode body = bufferedJsonBody(ctx);if (body == null || !body.isObject()) {return null;}- TableDefinition table = describeTargetTable(body);+ if (isDynamoDbBatch(action)) {+ return dynamoDbBatchConditionContext(action, ctx, null);+ }+ TableDefinition table = describeTargetTable(targetTableName(body));DynamoDbConditionKeys.Result keys = DynamoDbConditionKeys.extract(action, body, table);Map<String, List<String>> conditions = new LinkedHashMap<>();@@ -524,6 +549,53 @@ public class IamConditionContextResolver {return conditions.isEmpty() ? null : conditions;}+ /** Resolves each batch entry with its own schema, optionally restricted to one resource. */+ Map<String, List<String>> dynamoDbBatchConditionContext(String action, ContainerRequestContext ctx,+ String resourceArn) {+ if (!isDynamoDbBatch(action)) {+ return null;+ }+ Map<String, List<String>> conditions = new LinkedHashMap<>();+ JsonNode body = bufferedJsonBody(ctx);+ JsonNode items = body == null ? null : body.get("RequestItems");+ if (items == null || !items.isObject()) {+ return conditions;+ }+ List<String> leadingKeys = new ArrayList<>();+ Set<String> attributes = new LinkedHashSet<>();+ items.properties().forEach(entry -> {+ String reference = entry.getKey().trim();+ if (resourceArn != null && !matchesTableResource(reference, resourceArn)) {+ return;+ }+ ObjectNode single = ((ObjectNode) body).objectNode();+ single.setAll((ObjectNode) body);+ single.putObject("RequestItems").set(entry.getKey(), entry.getValue());+ DynamoDbConditionKeys.Result keys = DynamoDbConditionKeys.extract(+ action, single, describeTargetTable(reference));+ leadingKeys.addAll(keys.leadingKeys());+ attributes.addAll(keys.attributes());+ });+ if (!leadingKeys.isEmpty()) {+ conditions.put("dynamodb:LeadingKeys", List.copyOf(leadingKeys));+ }+ if (!attributes.isEmpty()) {+ conditions.put("dynamodb:Attributes", List.copyOf(attributes));+ }+ return conditions;+ }++ private static boolean isDynamoDbBatch(String action) {+ return "dynamodb:BatchGetItem".equals(action) || "dynamodb:BatchWriteItem".equals(action);+ }++ private static boolean matchesTableResource(String reference, String resourceArn) {+ if (AwsArnUtils.isArn(reference)) {+ return reference.equals(resourceArn);+ }+ return AwsArnUtils.parse(resourceArn).resource().equals("table/" + reference);+ }+private JsonNode bufferedJsonBody(ContainerRequestContext ctx) {Object cached = ctx.getProperty(BUFFERED_JSON_BODY);return cached instanceof JsonNode node ? node : null;@@ -535,8 +607,7 @@ public class IamConditionContextResolver {* {@code findTable} rather than {@code describeTable} so the O(items) item-count refresh* never runs on the enforcement hot path.*/- private TableDefinition describeTargetTable(JsonNode body) {- String tableName = targetTableName(body);+ private TableDefinition describeTargetTable(String tableName) {if (tableName == null || !dynamoDbFacade.isResolvable()) {return null;}@@ -546,11 +617,7 @@ public class IamConditionContextResolver {return dynamoDb.tables().findTable(dynamoDb.scope(region), tableName).orElse(null);}- /**- * The single table this request targets: the TableName field, or the sole RequestItems- * entry for the batch operations. A multi-table batch has no single key schema, so it- * gets no leading keys and fails closed.- */+ /** The table targeted by a non-batch request. */private String targetTableName(JsonNode body) {if (body.hasNonNull("TableName")) {String tableName = body.get("TableName").asText().trim();@@ -558,10 +625,6 @@ public class IamConditionContextResolver {return tableName;}}- JsonNode requestItems = body.get("RequestItems");- if (requestItems != null && requestItems.isObject() && requestItems.size() == 1) {- return requestItems.fieldNames().next();- }return null;}}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 e280b6caa2..94f0c799c1 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@@ -684,6 +684,16 @@ public class IamEnforcementFilter implements ContainerRequestFilter {for (Map<String, List<String>> targetContext : targetContexts) {Map<String, List<String>> effectiveContext = IamConditionContextResolver.withGlobalContext(targetContext, resource, region, accountId, resourceOwnerAccountId);+ if ("dynamodb".equals(credentialScope)) {+ Map<String, List<String>> batchContext =+ conditionContextResolver.dynamoDbBatchConditionContext(action, ctx, resource);+ if (batchContext != null) {+ effectiveContext.remove("dynamodb:LeadingKeys");+ effectiveContext.remove("dynamodb:Attributes");+ effectiveContext.remove("dynamodb:Select");+ effectiveContext.putAll(batchContext);+ }+ }ResourcePolicyDecision resourcePolicyDecision = evaluator.evaluateResourcePolicyFor(effectiveResourcePolicies, principal, action, resource, effectiveContext);Decision decision = evaluator.evaluateResolvedResourcePolicy(@@ -759,7 +769,8 @@ public class IamEnforcementFilter implements ContainerRequestFilter {Map<String, List<String>> copy = new HashMap<>(targetContext);copy.keySet().removeIf(key ->key.startsWith(IamConditionContextResolver.EXISTING_OBJECT_TAG_PREFIX)- || key.startsWith(IamConditionContextResolver.REQUEST_OBJECT_TAG_PREFIX));+ || key.startsWith(IamConditionContextResolver.REQUEST_OBJECT_TAG_PREFIX)+ || key.equals(IamConditionContextResolver.REQUEST_OBJECT_TAG_KEYS));stripped.add(copy.isEmpty() ? null : copy);}return stripped;diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeys.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeys.javaindex 381e9b2f9d..26ed67da82 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeys.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeys.java@@ -24,9 +24,9 @@ import java.util.regex.Pattern;** <p>Everything is best effort. Whatever cannot be determined is simply absent from the* result: an unresolvable leading key produces an empty list, the condition key is then- * omitted from the request context, and a policy that scopes access through it fails closed.- * Note that this "fail closed" behavior applies to {@code dynamodb:LeadingKeys}; for- * {@code dynamodb:Attributes} evaluated under {@code ForAllValues}, under-reporting is the+ * omitted from the request context. A {@code ForAllValues} policy must include a+ * {@code Null:false} guard to require a resolved leading key.+ * For {@code dynamodb:Attributes} evaluated under {@code ForAllValues}, under-reporting is the* unsafe direction because omitting a referenced attribute could allow an unauthorized* operation to pass.*/@@ -307,7 +307,7 @@ public final class DynamoDbConditionKeys {* Top-level attribute names a DynamoDB expression references: a FilterExpression,* ConditionExpression or KeyConditionExpression. Walks the parsed tree so a literal name* such as {@code ssn} in {@code "ssn = :x"} is captured, not only {@code #alias}es.- * A malformed expression yields nothing, which only ever denies.+ * A malformed expression yields no attribute names; normal absent-key condition rules apply.*/private static void addExpressionAttributes(Set<String> attributes, String expression,JsonNode exprAttrNames) {diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParser.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParser.javaindex 38d9bfaae3..b4174b3747 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParser.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParser.java@@ -17,7 +17,8 @@ import java.util.List;* <p>Exists so IAM condition-key extraction can reuse the expression parser without making* the whole {@link DynamoDbAccessPathValidator} public. Everything here is best effort: a* malformed or unsupported expression yields {@code null}, and the caller treats that as- * "the leading key could not be determined", which fails closed at the policy layer.+ * "the leading key could not be determined". A {@code ForAllValues} policy needs a+ * {@code Null:false} guard to require that key.*/final class DynamoDbKeyConditionParser {@@ -43,22 +44,24 @@ final class DynamoDbKeyConditionParser {try {root = ExpressionEvaluator.parse(keyConditionExpression);} catch (RuntimeException e) {- return null; // unparseable expression → leading key unknown → fail closed upstream+ return null; // Unparseable expression: omit the unknown leading key from the context.}if (root == null) {return null;}List<Expr> conditions = root instanceof AndExpr and ? and.operands() : List.of(root);for (Expr condition : conditions) {- if (!(condition instanceof CompareExpr compare)- || compare.op() != TokenType.EQ- || !(compare.right() instanceof PlaceholderOperand placeholder)) {+ if (!(condition instanceof CompareExpr compare) || compare.op() != TokenType.EQ) {continue;}- if (!pkName.equals(topLevelAttribute(compare.left(), exprAttrNames))) {- continue;+ if (compare.right() instanceof PlaceholderOperand placeholder+ && pkName.equals(topLevelAttribute(compare.left(), exprAttrNames))) {+ return scalarValue(exprAttrValues.get(placeholder.name()));+ }+ if (compare.left() instanceof PlaceholderOperand placeholder+ && pkName.equals(topLevelAttribute(compare.right(), exprAttrNames))) {+ return scalarValue(exprAttrValues.get(placeholder.name()));}- return scalarValue(exprAttrValues.get(placeholder.name()));}return null;}diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluator.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluator.javaindex 56a2e4c792..f95db3d6ac 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluator.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluator.java@@ -1218,6 +1218,9 @@ public class IamPolicyEvaluator {private boolean evaluateConditionBlock(String operator,Map<String, List<String>> keyValueMap,Map<String, List<String>> ctx) {+ if (!isSupportedConditionOperator(operator)) {+ return false;+ }ParsedOperator parsed = parseOperator(operator);String baseOp = parsed.baseOp();boolean ifExists = parsed.ifExists();@@ -1239,6 +1242,9 @@ public class IamPolicyEvaluator {if (ifExists) {continue; // key missing + IfExists → pass this key}+ if (parsed.quantifier() == SetQuantifier.FOR_ALL_VALUES) {+ continue;+ }// A negated operator asks for the key not to match, and an absent key matches// nothing, so the condition holds (IAM User Guide, condition operators). The set// operators keep their own rule for an absent key.diff --git a/src/test/java/io/github/hectorvent/floci/core/common/IamConditionContextResolverTest.java b/src/test/java/io/github/hectorvent/floci/core/common/IamConditionContextResolverTest.javaindex f3b5a9981c..12396aeaf4 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/IamConditionContextResolverTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/IamConditionContextResolverTest.java@@ -26,9 +26,11 @@ import org.mockito.ArgumentCaptor;import java.io.ByteArrayInputStream;import java.io.InputStream;import java.nio.charset.StandardCharsets;+import java.util.HashSet;import java.util.List;import java.util.Map;import java.util.Optional;+import java.util.Set;import static org.junit.jupiter.api.Assertions.assertArrayEquals;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -92,6 +94,7 @@ class IamConditionContextResolverTest {UriInfo uriInfo = mock(UriInfo.class);when(containerRequest.getUriInfo()).thenReturn(uriInfo);when(uriInfo.getPath()).thenReturn(path);+ when(uriInfo.getQueryParameters()).thenReturn(new MultivaluedHashMap<>());when(containerRequest.getEntityStream()).thenReturn(new ByteArrayInputStream(body.getBytes(StandardCharsets.UTF_8)));return containerRequest;@@ -149,6 +152,55 @@ class IamConditionContextResolverTest {assertNull(resolver.resolve("s3", "s3:GetObject", containerRequest));}+ @Test+ void objectTagKeysDecodeHeadersAndRetainCaseWithoutDuplicates() {+ ContainerRequestContext request = s3Request("/bucket/object", "");+ when(request.getHeaderString("x-amz-tagging"))+ .thenReturn("%54eam=one&Team=two&team=three&Cost%20Center=four&bad=%zz");+ Map<String, List<String>> conditions = resolver.resolve("s3", "s3:PutObject", request);+ assertEquals(List.of("Team", "team", "Cost Center"), conditions.get("s3:RequestObjectTagKeys"));+ assertEquals(List.of("two"), conditions.get("s3:RequestObjectTag/Team"));+ assertFalse(conditions.containsKey("s3:RequestObjectTag/bad"));+ }++ @Test+ void queryObjectTagKeysUseHeaderPrecedenceIncludingAnEmptyHeader() {+ ContainerRequestContext request = s3Request("/bucket/object", "");+ request.getUriInfo().getQueryParameters().putSingle("x-amz-tagging", "%54eam=payments");+ Map<String, List<String>> query = resolver.resolve("s3", "s3:PutObject", request);+ assertEquals(List.of("Team"), query.get("s3:RequestObjectTagKeys"));+ assertEquals(List.of("payments"), query.get("s3:RequestObjectTag/Team"));+ when(request.getHeaderString("x-amz-tagging")).thenReturn("Other=value");+ assertEquals(List.of("Other"), resolver.resolve("s3", "s3:PutObject", request)+ .get("s3:RequestObjectTagKeys"));+ when(request.getHeaderString("x-amz-tagging")).thenReturn("");+ assertNull(resolver.resolve("s3", "s3:PutObject", request));+ }++ @Test+ void objectTagKeysComeOnlyFromTheRequestedXmlTags() {+ ContainerRequestContext request = s3Request("/bucket/object",+ "<Tagging><TagSet><Tag><Key>Team</Key><Value>payments</Value></Tag>"+ + "<Tag><Key>Cost&Center</Key><Value>42</Value></Tag></TagSet></Tagging>");+ when(request.getUriInfo().getQueryParameters()).thenReturn(new MultivaluedHashMap<>());+ when(s3Service.getObjectTagging("bucket", "object", null)).thenReturn(Map.of("Previous", "old"));+ Map<String, List<String>> conditions = resolver.resolve("s3", "s3:PutObjectTagging", request);+ assertEquals(Set.of("Team", "Cost&Center"), new HashSet<>(conditions.get("s3:RequestObjectTagKeys")));+ assertEquals(List.of("old"), conditions.get("s3:ExistingObjectTag/Previous"));+ assertEquals(List.of("42"), conditions.get("s3:RequestObjectTag/Cost&Center"));+ }++ @Test+ void emptyObjectTagRequestsDoNotExposeRequestedKeys() {+ assertNull(resolver.resolve("s3", "s3:PutObject", s3Request("/bucket/object", "")));+ ContainerRequestContext empty = s3Request("/bucket/object", "<Tagging><TagSet/></Tagging>");+ when(empty.getUriInfo().getQueryParameters()).thenReturn(new MultivaluedHashMap<>());+ when(s3Service.getObjectTagging("bucket", "object", null)).thenReturn(Map.of("Previous", "old"));+ Map<String, List<String>> conditions = resolver.resolve("s3", "s3:PutObjectTagging", empty);+ assertEquals(List.of("old"), conditions.get("s3:ExistingObjectTag/Previous"));+ assertFalse(conditions.containsKey("s3:RequestObjectTagKeys"));+ }+@Testvoid resolvesDynamoDbLeadingKeysForGetItem() {ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);@@ -220,19 +272,25 @@ class IamConditionContextResolverTest {}@Test- void omitsLeadingKeysForAMultiTableBatch() {- // A batch spanning two tables has no single key schema: applying table A's partition- // key name to table B's items would be wrong, so no leading keys are produced.+ void resolvesEachBatchTableWithItsOwnSchema() {ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);when(containerRequest.getProperty("floci.bufferedJsonBody")).thenReturn(json("""{"RequestItems":{"FgacTable":{"Keys":[{"PK":{"S":"USER_alice"}}]},- "OtherTable":{"Keys":[{"PK":{"S":"USER_bob"}}]}}}"""));+ "OtherTable":{"Keys":[{"Tenant":{"S":"USER_bob"}}]}}}"""));+ TableDefinition other = new TableDefinition();+ other.setTableName("OtherTable");+ other.setKeySchema(List.of(new KeySchemaElement("Tenant", "HASH")));+ when(dynamoDbService.findTable("FgacTable", "us-east-1")).thenReturn(Optional.of(fgacTable()));+ when(dynamoDbService.findTable("OtherTable", "us-east-1")).thenReturn(Optional.of(other));Map<String, List<String>> conditions =resolver.resolve("dynamodb", "dynamodb:BatchGetItem", containerRequest);- assertFalse(conditions.containsKey("dynamodb:LeadingKeys"));+ assertEquals(List.of("USER_alice", "USER_bob"), conditions.get("dynamodb:LeadingKeys"));+ assertEquals(List.of("USER_bob"), resolver.dynamoDbBatchConditionContext(+ "dynamodb:BatchGetItem", containerRequest,+ "arn:aws:dynamodb:us-east-1:000000000000:table/OtherTable").get("dynamodb:LeadingKeys"));}// ── aws:RequestTag and aws:ResourceTag ─────────────────────────────────────@@ -249,6 +307,7 @@ class IamConditionContextResolverTest {assertEquals(List.of("payments"), conditions.get("aws:RequestTag/Team"));assertEquals(List.of("prod"), conditions.get("aws:RequestTag/Env"));+ assertEquals(Set.of("Team", "Env"), new HashSet<>(conditions.get("aws:TagKeys")));}@Test@@ -295,6 +354,7 @@ class IamConditionContextResolverTest {assertEquals(List.of("payments"), conditions.get("aws:RequestTag/Team"));assertEquals(List.of("prod"), conditions.get("aws:RequestTag/Env"));+ assertEquals(List.of("Team", "Env"), conditions.get("aws:TagKeys"));assertFalse(conditions.containsKey("aws:ResourceTag/Team"));}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbFgacEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbFgacEnforcementIntegrationTest.javaindex 36f20e52e9..0f572a5e8d 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbFgacEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbFgacEnforcementIntegrationTest.java@@ -6,6 +6,9 @@ import io.quarkus.test.junit.QuarkusTest;import io.quarkus.test.junit.TestProfile;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;+import org.junit.jupiter.params.provider.ValueSource;import java.util.UUID;@@ -88,9 +91,8 @@ class DynamoDbFgacEnforcementIntegrationTest {String accessKeyId = assumeRoleWithLeadingKeysSessionPolicy(roleName);- // The Key omits the partition attribute, so the leading key cannot be resolved. With- // access scoped purely through dynamodb:LeadingKeys this is denied rather than passed- // to DynamoDB, which is the correct direction for a security boundary.+ // The Key omits the partition attribute, so the leading key cannot be resolved.+ // The session policy's Null:false guard denies it before DynamoDB handles the request.given().header("Authorization", auth(accessKeyId, "dynamodb")).header("X-Amz-Target", "DynamoDB_20120810.GetItem")@@ -155,6 +157,115 @@ class DynamoDbFgacEnforcementIntegrationTest {.body(containsString("AccessDeniedException"));}+ @ParameterizedTest+ @ValueSource(strings = {":uid = PK", ":uid = #pk"})+ void reversedQueryRequiresTheRequestedPartitionWithoutNullGuard(String expression) {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String table = "fgac-reversed-" + suffix;+ String role = "FgacReversed" + suffix;+ createTable(table);+ putItem(table, "USER_alice");+ putItem(table, "USER_bob");+ createRole(role);+ putBroadDynamoDbRolePolicy(role);+ String accessKey = assumeRoleWithLeadingKeysSessionPolicy(role, false);+ for (String user : new String[]{"USER_alice", "USER_bob"}) {+ given().header("Authorization", auth(accessKey, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.Query")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s","KeyConditionExpression":"%s",%s+ "ExpressionAttributeValues":{":uid":{"S":"%s"}}}+ """.formatted(table, expression, expression.contains("#")+ ? "\"ExpressionAttributeNames\":{\"#pk\":\"PK\"}," : "", user))+ .post("/").then().statusCode(user.equals("USER_alice") ? 200 : 400)+ .body(containsString(user.equals("USER_alice") ? "USER_alice" : "AccessDeniedException"));+ }+ }++ @ParameterizedTest+ @CsvSource({"BatchGetItem,false", "BatchGetItem,true", "BatchWriteItem,false", "BatchWriteItem,true"})+ void everyBatchEntryContributesLeadingKeysWithoutNullGuard(String action, boolean alias) {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String table = "fgac-batch-" + suffix;+ String other = alias ? "arn:aws:dynamodb:" + REGION + ":" + ROLE_ACCOUNT_ID + ":table/" + table+ : "fgac-other-" + suffix;+ String role = "FgacBatch" + suffix;+ createTable(table);+ if (!alias) {+ createTable(other);+ }+ putItem(table, "USER_alice");+ putItem(other, "USER_bob");+ createRole(role);+ putBroadDynamoDbRolePolicy(role);+ String accessKey = assumeRoleWithLeadingKeysSessionPolicy(role, false);+ for (String user : new String[]{"USER_alice_2", "USER_bob"}) {+ String first = batchEntry(action, "USER_alice");+ String second = batchEntry(action, user);+ given().header("Authorization", auth(accessKey, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810." + action)+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("{\"RequestItems\":{\"" + table + "\":" + first + ",\"" + other + "\":" + second + "}}")+ .post("/").then().statusCode(user.equals("USER_bob") ? 400 : 200)+ .body(containsString(user.equals("USER_bob") ? "AccessDeniedException"+ : action.equals("BatchGetItem") ? "Responses" : "UnprocessedItems"));+ }+ given().header("Authorization", auth(ROLE_ACCOUNT_ID, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.GetItem")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("{\"TableName\":\"" + other + "\",\"Key\":{\"PK\":{\"S\":\"USER_bob\"}}}")+ .post("/").then().statusCode(200).body("Item.PK.S", equalTo("USER_bob"));+ }++ @Test+ void batchPoliciesEvaluateEachTableWithOnlyItsOwnKeys() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String first = "fgac-first-" + suffix;+ String second = "fgac-second-" + suffix;+ String role = "FgacSeparate" + suffix;+ createTable(first);+ createTable(second);+ putItem(first, "USER_alice");+ putItem(second, "USER_bob");+ createRole(role);+ String statements = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:BatchGetItem","Resource":"%s",+ "Condition":{"ForAllValues:StringEquals":{"dynamodb:LeadingKeys":["USER_alice"]}}},+ {"Effect":"Allow","Action":"dynamodb:BatchGetItem","Resource":"%s",+ "Condition":{"ForAllValues:StringEquals":{"dynamodb:LeadingKeys":["USER_bob"]}}}]}+ """.formatted("arn:aws:dynamodb:" + REGION + ":" + ROLE_ACCOUNT_ID + ":table/" + first,+ "arn:aws:dynamodb:" + REGION + ":" + ROLE_ACCOUNT_ID + ":table/" + second);+ given().header("Authorization", auth(ROLE_ACCOUNT_ID, "iam"))+ .formParam("Action", "PutRolePolicy").formParam("RoleName", role)+ .formParam("PolicyName", "Tables").formParam("PolicyDocument", statements)+ .post("/").then().statusCode(200);+ String accessKey = given().header("Authorization", auth(CALLER_ACCOUNT_ID, "sts"))+ .formParam("Action", "AssumeRole")+ .formParam("RoleArn", "arn:aws:iam::" + ROLE_ACCOUNT_ID + ":role/" + role)+ .formParam("RoleSessionName", "separate-tables")+ .post("/").then().statusCode(200).extract()+ .path("AssumeRoleResponse.AssumeRoleResult.Credentials.AccessKeyId");+ for (boolean swapped : new boolean[]{false, true}) {+ given().header("Authorization", auth(accessKey, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.BatchGetItem")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("{\"RequestItems\":{\"" + first + "\":"+ + batchEntry("BatchGetItem", swapped ? "USER_bob" : "USER_alice")+ + ",\"" + second + "\":"+ + batchEntry("BatchGetItem", swapped ? "USER_alice" : "USER_bob") + "}}")+ .post("/").then().statusCode(swapped ? 400 : 200)+ .body(containsString(swapped ? "AccessDeniedException" : "USER_bob"));+ }+ }++ private static String batchEntry(String action, String user) {+ String key = "{\"PK\":{\"S\":\"" + user + "\"}}";+ return action.equals("BatchGetItem") ? "{\"Keys\":[" + key + "]}"+ : "[{\"DeleteRequest\":{\"Key\":" + key + "}}]";+ }+private static void createTable(String tableName) {given().header("Authorization", auth(ROLE_ACCOUNT_ID, "dynamodb"))@@ -272,16 +383,21 @@ class DynamoDbFgacEnforcementIntegrationTest {* allow or a deny can only come from the LeadingKeys condition.*/private static String assumeRoleWithLeadingKeysSessionPolicy(String roleName) {+ return assumeRoleWithLeadingKeysSessionPolicy(roleName, true);+ }++ private static String assumeRoleWithLeadingKeysSessionPolicy(String roleName, boolean nullGuard) {+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:*","Resource":"*",+ "Condition":{"ForAllValues:StringLike":{"dynamodb:LeadingKeys":["USER_alice*"]}%s}}+ ]}+ """.formatted(nullGuard ? ",\"Null\":{\"dynamodb:LeadingKeys\":\"false\"}" : "");return given().formParam("Action", "AssumeRole").formParam("RoleArn", "arn:aws:iam::" + ROLE_ACCOUNT_ID + ":role/" + roleName).formParam("RoleSessionName", "fgac-leading-keys-test")- .formParam("Policy", """- {"Version":"2012-10-17","Statement":[- {"Effect":"Allow","Action":"dynamodb:*","Resource":"*",- "Condition":{"ForAllValues:StringLike":- {"dynamodb:LeadingKeys":["USER_alice*"]}}}- ]}""")+ .formParam("Policy", policy).header("Authorization", auth(CALLER_ACCOUNT_ID, "sts")).when().post("/")diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamEnforcementIntegrationTest.javaindex a938b8ceeb..b6c1a26187 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamEnforcementIntegrationTest.java@@ -219,7 +219,8 @@ class IamEnforcementIntegrationTest {{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":["dynamodb:GetItem","dynamodb:Query"],"Resource":"arn:aws:dynamodb:us-east-1:000000000000:table/FgacTable",- "Condition":{"ForAllValues:StringLike":{"dynamodb:LeadingKeys":["USER_alice*"]}}}+ "Condition":{"ForAllValues:StringLike":{"dynamodb:LeadingKeys":["USER_alice*"]},+ "Null":{"dynamodb:LeadingKeys":"false"}}}]}""";@Test@@ -234,7 +235,7 @@ class IamEnforcementIntegrationTest {"arn:aws:dynamodb:us-east-1:000000000000:table/FgacTable",Map.of("dynamodb:LeadingKeys", List.of("USER_bob"))));- // The leading key could not be resolved from the request: fail closed.+ // Null:false requires a leading key even though ForAllValues alone would match.assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(List.of(LEADING_KEYS_SCOPED_POLICY), "dynamodb:GetItem","arn:aws:dynamodb:us-east-1:000000000000:table/FgacTable",diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamIntegrationTest.javaindex 1c0561167a..59f6a15c16 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamIntegrationTest.java@@ -7,6 +7,7 @@ import org.junit.jupiter.api.Order;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.TestMethodOrder;import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;import org.junit.jupiter.params.provider.ValueSource;import java.util.LinkedHashMap;@@ -421,6 +422,51 @@ class IamIntegrationTest {equalTo("implicitDeny"));}+ @ParameterizedTest+ @CsvSource({+ "ForAllValues:StringLike, allowed",+ "ForAllValues:StringNotLike, allowed",+ "ForAnyValue:StringLike, implicitDeny",+ "ForAnyValue:StringNotLike, implicitDeny"+ })+ void simulateCustomPolicyUsesSetOperatorSemanticsForMissingKeys(String operator, String decision) {+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"%s":{"dynamodb:LeadingKeys":["USER_alice*"]}}}+ ]}""".formatted(operator);+ given()+ .formParam("Action", "SimulateCustomPolicy")+ .formParam("PolicyInputList.member.1", policy)+ .formParam("ActionNames.member.1", "dynamodb:GetItem")+ .formParam("ResourceArns.member.1", "*")+ .header("Authorization", IAM_AUTH)+ .when().post("/").then().statusCode(200)+ .body("SimulateCustomPolicyResponse.SimulateCustomPolicyResult.EvaluationResults.member.EvalDecision",+ equalTo(decision));+ }++ @ParameterizedTest+ @ValueSource(strings = {"ForAllValues:StringTypoIfExists", "ForAnyValue:StringTypoIfExists",+ "StringTypoIfExists", "ForAllValues:Null", "ForAnyValue:Null", "NullIfExists",+ "ForAllValues:NullIfExists", "ForAnyValue:NullIfExists"})+ void simulateCustomPolicyRejectsUnsupportedMissingKeyShortcuts(String operator) {+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"%s":{"dynamodb:LeadingKeys":["true"]}}}+ ]}""".formatted(operator);+ given()+ .formParam("Action", "SimulateCustomPolicy")+ .formParam("PolicyInputList.member.1", policy)+ .formParam("ActionNames.member.1", "dynamodb:GetItem")+ .formParam("ResourceArns.member.1", "*")+ .header("Authorization", IAM_AUTH)+ .when().post("/").then().statusCode(200)+ .body("SimulateCustomPolicyResponse.SimulateCustomPolicyResult.EvaluationResults.member.EvalDecision",+ equalTo("implicitDeny"));+ }+@Test@Order(37)void simulateCustomPolicyAppliesPermissionsBoundary() {diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluatorTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluatorTest.javaindex b197d27162..06e7c1c572 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluatorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluatorTest.java@@ -7,6 +7,8 @@ import io.github.hectorvent.floci.services.iam.IamPolicyEvaluator.ResourceAccounimport io.github.hectorvent.floci.services.iam.IamPolicyEvaluator.ResourcePolicyDecision;import io.github.hectorvent.floci.services.iam.model.CallerContext;import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;import java.time.Duration;import java.util.List;@@ -396,11 +398,81 @@ class IamPolicyEvaluatorTest {}@Test- void setOperatorWithoutIfExistsFailsClosedWhenTheKeyIsAbsent() {- // The key is absent from the context entirely — not an empty set. A request that- // cannot be proven in scope is treated as out of scope.- assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ void forAllValuesMatchesWhenTheKeyIsAbsent() {+ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(List.of(LEADING_KEYS_FOR_ALL), "dynamodb:GetItem", "*", Map.of()));+ assertEquals(Decision.ALLOW, evaluator.evaluate(CallerContext.of(List.of(LEADING_KEYS_FOR_ALL)),+ List.of(), "dynamodb:GetItem", "*", Map.of()));+ }++ @Test+ void forAllValuesExplicitDenyMatchesWhenTheKeyIsAbsent() {+ String deny = LEADING_KEYS_FOR_ALL.replace("\"Effect\":\"Allow\"", "\"Effect\":\"Deny\"");+ assertEquals(Decision.DENY, evaluator.evaluate(CallerContext.of(List.of(ALLOW_ALL, deny)),+ List.of(), "dynamodb:GetItem", "*", Map.of()));+ assertEquals(IamPolicyEvaluator.SimulationDecision.EXPLICIT_DENY, evaluator.simulatePrincipalPolicy(+ CallerContext.of(List.of(ALLOW_ALL, deny)), "dynamodb:GetItem", "*", Map.of()));+ }++ @Test+ void forAllValuesMissingKeyStillRequiresOtherConditionKeysToMatch() {+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"ForAllValues:StringLike":{+ "dynamodb:LeadingKeys":["USER_alice*"],"aws:TagKeys":["environment"]}}}+ ]}""";+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(List.of(policy), "dynamodb:GetItem", "*",+ Map.of("aws:TagKeys", List.of("unapproved"))));+ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(List.of(policy), "dynamodb:GetItem", "*",+ Map.of("aws:TagKeys", List.of("environment"))));+ }++ @Test+ void unknownForAllValuesOperatorsDoNotMatchMissingKeys() {+ for (String operator : List.of("ForAllValues:StringTypo", "ForAllValues:ForAnyValue:StringLike")) {+ String allow = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"%s":{"dynamodb:LeadingKeys":["USER_alice*"]}}}+ ]}""".formatted(operator);+ String deny = allow.replace("\"Effect\":\"Allow\"", "\"Effect\":\"Deny\"");+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(allow), "dynamodb:GetItem", "*", Map.of()));+ assertEquals(Decision.DENY, evaluator.evaluate(CallerContext.of(List.of(allow)),+ List.of(), "dynamodb:GetItem", "*", Map.of()));+ assertEquals(IamPolicyEvaluator.SimulationDecision.ALLOWED, evaluator.simulatePrincipalPolicy(+ CallerContext.of(List.of(ALLOW_ALL, deny)), "dynamodb:GetItem", "*", Map.of()));+ assertEquals(Decision.ALLOW, evaluator.evaluate(CallerContext.of(List.of(ALLOW_ALL, deny)),+ List.of(), "dynamodb:GetItem", "*", Map.of()));+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"ForAllValues:StringTypoIfExists", "ForAnyValue:StringTypoIfExists",+ "StringTypoIfExists", "ForAllValues:Null", "ForAnyValue:Null", "NullIfExists",+ "ForAllValues:NullIfExists", "ForAnyValue:NullIfExists"})+ void unsupportedOperatorsCannotBypassConditionChecks(String operator) {+ String allow = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"%s":{"dynamodb:LeadingKeys":["true"]}}}+ ]}""".formatted(operator);+ String deny = allow.replace("\"Effect\":\"Allow\"", "\"Effect\":\"Deny\"");+ List<Map<String, List<String>>> contexts = List.of(Map.of(),+ Map.of("dynamodb:LeadingKeys", List.of()),+ Map.of("dynamodb:LeadingKeys", List.of("USER_alice")));+ for (Map<String, List<String>> context : contexts) {+ assertFalse(IamPolicyEvaluator.isSupportedConditionOperator(operator));+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(allow), "dynamodb:GetItem", "*", context));+ assertEquals(Decision.DENY, evaluator.evaluate(CallerContext.of(List.of(allow)),+ List.of(), "dynamodb:GetItem", "*", context));+ assertEquals(IamPolicyEvaluator.SimulationDecision.ALLOWED, evaluator.simulatePrincipalPolicy(+ CallerContext.of(List.of(ALLOW_ALL, deny)), "dynamodb:GetItem", "*", context));+ assertEquals(Decision.ALLOW, evaluator.evaluate(CallerContext.of(List.of(ALLOW_ALL, deny)),+ List.of(), "dynamodb:GetItem", "*", context));+ }}@Test@@ -426,7 +498,7 @@ class IamPolicyEvaluatorTest {{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*","Condition":{- "ForAllValues:StringLikeIfExists":{"dynamodb:LeadingKeys":["USER_alice*"]},+ "ForAllValues:StringLike":{"dynamodb:LeadingKeys":["USER_alice*"]},"Null":{"dynamodb:LeadingKeys":"false"}}}]}""";diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamTagKeysEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamTagKeysEnforcementIntegrationTest.javanew file mode 100644index 0000000000..bc34f29a06--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamTagKeysEnforcementIntegrationTest.java@@ -0,0 +1,199 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.testing.IamEnforcementProfile;+import io.github.hectorvent.floci.testing.PartitionCleanup;+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 java.net.URI;+import java.util.UUID;++import static io.github.hectorvent.floci.testing.EnforcementFixtures.auth;+import static io.github.hectorvent.floci.testing.EnforcementFixtures.createUser;+import static io.github.hectorvent.floci.testing.EnforcementFixtures.removeBucket;+import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;++@QuarkusTest+@TestProfile(IamEnforcementProfile.class)+class IamTagKeysEnforcementIntegrationTest {++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ @TestHTTPResource+ URI endpoint;++ @Test+ void ec2CreateTagsRejectsAnUnlistedKeyWithoutNullGuard() {+ String id = given().header("Authorization", auth("test", "ec2"))+ .formParam("Action", "CreateVpc").formParam("CidrBlock", "10.89.0.0/16")+ .post("/").then().statusCode(200).extract().path("CreateVpcResponse.vpc.vpcId");+ int port = endpoint.getPort();+ cleanup.register(() -> given().port(port).header("Authorization", auth("test", "ec2"))+ .formParam("Action", "DeleteVpc").formParam("VpcId", id).post("/"));+ String key = scopedUser("ec2:CreateTags", "aws:TagKeys");+ given().header("Authorization", auth(key, "ec2"))+ .formParam("Action", "CreateTags").formParam("ResourceId.1", id)+ .formParam("Tag.1.Key", "Team").formParam("Tag.1.Value", "payments")+ .post("/").then().statusCode(200);+ given().header("Authorization", auth(key, "ec2"))+ .formParam("Action", "CreateTags").formParam("ResourceId.1", id)+ .formParam("Tag.1.Key", "Team").formParam("Tag.1.Value", "payments")+ .formParam("Tag.2.Key", "Admin").formParam("Tag.2.Value", "true")+ .post("/").then().statusCode(403).body(containsString("AccessDenied"));+ }++ @Test+ void s3BucketTaggingRejectsAnUnlistedKeyWithoutNullGuard() {+ String bucket = bucket();+ String key = scopedUser("s3:PutBucketTagging", "aws:TagKeys");+ String allowed = "<Tag><Key>Team</Key><Value>payments</Value></Tag>";+ given().header("Authorization", auth(key, "s3")).queryParam("tagging", "")+ .body("<Tagging><TagSet>" + allowed + "</TagSet></Tagging>")+ .put("/" + bucket).then().statusCode(204);+ given().header("Authorization", auth(key, "s3")).queryParam("tagging", "")+ .body("<Tagging><TagSet>" + allowed+ + "<Tag><Key>Admin</Key><Value>true</Value></Tag></TagSet></Tagging>")+ .put("/" + bucket).then().statusCode(403).body(containsString("AccessDenied"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"Admin", "team"})+ void s3ObjectUploadRestrictsAllRequestedKeysWithoutNullGuard(String forbiddenKey) {+ String bucket = bucket();+ String key = scopedUser("s3:PutObject", "s3:RequestObjectTagKeys");+ String path = "/" + bucket + "/object";+ given().header("Authorization", auth(key, "s3")).header("x-amz-tagging", "%54eam=payments")+ .body("original").put(path).then().statusCode(200);+ given().header("Authorization", auth(key, "s3"))+ .header("x-amz-tagging", "Team=payments&" + forbiddenKey + "=true")+ .body("forbidden replacement").put(path).then().statusCode(403)+ .body(containsString("AccessDenied"));+ given().header("Authorization", auth("test", "s3")).get(path)+ .then().statusCode(200).body(equalTo("original"));+ given().header("Authorization", auth("test", "s3")).queryParam("tagging", "").get(path)+ .then().statusCode(200).body(containsString("<Key>Team</Key>"))+ .body(not(containsString("<Key>" + forbiddenKey + "</Key>")));+ // No tags retain the vacuous ForAllValues match; there is no Null guard.+ given().header("Authorization", auth(key, "s3")).body("untagged").put(path)+ .then().statusCode(200);+ }++ @ParameterizedTest+ @ValueSource(strings = {"Admin", "team"})+ void s3ObjectTaggingRestrictsAllRequestedKeysWithoutNullGuard(String forbiddenKey) {+ String bucket = bucket();+ String path = "/" + bucket + "/object";+ given().header("Authorization", auth("test", "s3")).body("original").put(path)+ .then().statusCode(200);+ String key = scopedUser("s3:PutObjectTagging", "s3:RequestObjectTagKeys");+ String allowed = "<Tag><Key>Team</Key><Value>payments</Value></Tag>";+ given().header("Authorization", auth(key, "s3")).queryParam("tagging", "")+ .body("<Tagging><TagSet>" + allowed + "</TagSet></Tagging>")+ .put(path).then().statusCode(200);+ given().header("Authorization", auth(key, "s3")).queryParam("tagging", "")+ .body("<Tagging><TagSet>" + allowed + "<Tag><Key>" + forbiddenKey+ + "</Key><Value>true</Value></Tag></TagSet></Tagging>")+ .put(path).then().statusCode(403).body(containsString("AccessDenied"));+ given().header("Authorization", auth("test", "s3")).queryParam("tagging", "").get(path)+ .then().statusCode(200).body(containsString("<Key>Team</Key>"))+ .body(not(containsString("<Key>" + forbiddenKey + "</Key>")));+ // An empty tag set removes the tags and still matches ForAllValues.+ given().header("Authorization", auth(key, "s3")).queryParam("tagging", "")+ .body("<Tagging><TagSet/></Tagging>").put(path).then().statusCode(200);+ given().header("Authorization", auth("test", "s3")).queryParam("tagging", "").get(path)+ .then().statusCode(200).body(not(containsString("<Key>Team</Key>")));+ }++ @ParameterizedTest+ @ValueSource(strings = {"Admin", "team"})+ void s3QueryTagKeysAreCheckedBeforeAnUpload(String forbiddenKey) {+ String bucket = bucket();+ String key = scopedUser("s3:PutObject", "s3:RequestObjectTagKeys");+ String path = "/" + bucket + "/object";+ given().header("Authorization", auth(key, "s3")).queryParam("x-amz-tagging", "%54eam=payments")+ .body("original").put(path).then().statusCode(200);+ given().header("Authorization", auth(key, "s3"))+ .queryParam("x-amz-tagging", "Team=payments&" + forbiddenKey + "=true")+ .body("forbidden").put(path).then().statusCode(403);+ given().header("Authorization", auth("test", "s3")).get(path)+ .then().statusCode(200).body(equalTo("original"));+ given().header("Authorization", auth("test", "s3")).queryParam("tagging", "").get(path)+ .then().statusCode(200).body(containsString("<Key>Team</Key>"))+ .body(not(containsString("<Key>" + forbiddenKey + "</Key>")));+ }++ @Test+ void s3TagHeaderTakesPrecedenceOverTheQuery() {+ String bucket = bucket();+ String key = scopedUser("s3:PutObject", "s3:RequestObjectTagKeys");+ String path = "/" + bucket + "/object";+ given().header("Authorization", auth(key, "s3")).header("x-amz-tagging", "Team=payments")+ .queryParam("x-amz-tagging", "Admin=true").body("original").put(path).then().statusCode(200);+ given().header("Authorization", auth(key, "s3")).header("x-amz-tagging", "Admin=true")+ .queryParam("x-amz-tagging", "Team=payments").body("forbidden").put(path).then().statusCode(403);+ given().header("Authorization", auth("test", "s3")).get(path)+ .then().statusCode(200).body(equalTo("original"));+ given().header("Authorization", auth("test", "s3")).queryParam("tagging", "").get(path)+ .then().statusCode(200).body(containsString("<Key>Team</Key>"))+ .body(not(containsString("<Key>Admin</Key>")));+ }++ @Test+ void conditionalUploadCannotUseRequestedKeysToGrantReadAccess() {+ String bucket = bucket();+ String path = "/" + bucket + "/object";+ String etag = given().header("Authorization", auth("test", "s3")).body("original")+ .put(path).then().statusCode(200).extract().header("ETag");+ String key = userWithPolicy("""+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:PutObject","Resource":"*"},+ {"Effect":"Allow","Action":"s3:GetObject","Resource":"*",+ "Condition":{"ForAnyValue:StringEquals":{"s3:RequestObjectTagKeys":["Team"]}}}]}+ """);+ given().header("Authorization", auth(key, "s3")).header("x-amz-tagging", "Team=payments")+ .header("If-Match", etag).body("forbidden").put(path).then().statusCode(403);+ given().header("Authorization", auth("test", "s3")).get(path)+ .then().statusCode(200).body(equalTo("original"));+ String allowedKey = userWithPolicy("""+ {"Version":"2012-10-17","Statement":[{"Effect":"Allow",+ "Action":["s3:PutObject","s3:GetObject"],"Resource":"*"}]}+ """);+ given().header("Authorization", auth(allowedKey, "s3")).header("x-amz-tagging", "Team=payments")+ .header("If-Match", etag).body("allowed").put(path).then().statusCode(200);+ given().header("Authorization", auth("test", "s3")).get(path)+ .then().statusCode(200).body(equalTo("allowed"));+ }++ private String bucket() {+ String bucket = "tagkeys-" + UUID.randomUUID();+ int port = endpoint.getPort();+ cleanup.register(() -> removeBucket(port, auth("test", "s3"), bucket));+ given().header("Authorization", auth("test", "s3")).put("/" + bucket).then().statusCode(200);+ return bucket;+ }++ private String scopedUser(String action, String conditionKey) {+ return userWithPolicy("""+ {"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"%s",+ "Resource":"*","Condition":{"ForAllValues:StringEquals":{"%s":["Team"]}}}]}+ """.formatted(action, conditionKey));+ }++ private String userWithPolicy(String policy) {+ String user = "tagkeys-" + UUID.randomUUID();+ String accessKey = createUser(cleanup, endpoint.getPort(), auth("test", "iam"), user).accessKeyId();+ given().header("Authorization", auth("test", "iam"))+ .formParam("Action", "PutUserPolicy").formParam("UserName", user).formParam("PolicyName", "tags")+ .formParam("PolicyDocument", policy).post("/").then().statusCode(200);+ return accessKey;+ }+}