Light, fluffy, and always free - The AWS Local Emulator alternative
feat(iam): support DynamoDB fine-grained access control (#2926) (#3011)
Vũ Thế Huy6653b9a4e4be
diff --git a/docs/services/iam.md b/docs/services/iam.mdindex 3e3b31aa5e..7b864f042e 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -391,21 +391,49 @@ account key carries no identity policies of its own.- `DateEquals`, `DateNotEquals`, `DateLessThan`, `DateGreaterThan` (and Equals variants)- `Bool`, `IpAddress`, `NotIpAddress`, `Null`- Supports `...IfExists` variants for all operators.+- Set operators `ForAllValues:` and `ForAnyValue:` over multi-valued condition keys, in AWS's+ own 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+ `"Null":{"<key>":"false"}` as you would on AWS: `Null` treats a present-but-empty set as+ absent, so the guard fires either way.+- When a condition lists several values, a positive operator matches if the request value+ equals **any** of them; a negated operator (`StringNotEquals`, `ArnNotLike`, `NotIpAddress`,+ …) matches only if the request value differs from **all** of them. This is what makes+ `ForAllValues:StringNotEquals` on `dynamodb:Attributes` a usable deny-list.#### Condition keys floci populatesA `Condition` operator can only match a key floci actually places in the request context.floci populates:-- `s3:prefix`, `s3:delimiter`, `s3:max-keys` — from the S3 request parameters.-- `aws:PrincipalArn` — the caller's ARN, resolved from the signing access key. It is the+- `s3:prefix`, `s3:delimiter`, `s3:max-keys`: from the S3 request parameters.+- `aws:PrincipalArn`: the caller's ARN, resolved from the signing access key. It is theIAM-user ARN for a user access key, the assumed-role ARN for an STS session, and`arn:aws:iam::<account>:root` for the bare account-id key (floci's account-root principal),matching the ARN shape AWS itself reports for the account root. It is **absent** only forunknown keys, where nothing about the caller can be resolved.+- `dynamodb:LeadingKeys`, `dynamodb:Attributes`, `dynamodb:Select`: from the DynamoDB request+ body, for `GetItem`, `PutItem`, `UpdateItem`, `DeleteItem`, `Query`, `BatchGetItem` and+ `BatchWriteItem` (`dynamodb:Select` for `Query` and `Scan`). `LeadingKeys` holds the+ partition-key values the request names: from `Key`, `Item`, the `KeyConditionExpression`+ equality, the legacy `KeyConditions` `EQ` entry, or each `RequestItems` entry. `Attributes`+ holds the attribute names the request *names* (item and key fields, `AttributesToGet`,+ projection / update / filter / condition / key-condition expressions, and+ `ExpressionAttributeNames`); a request with no projection returns every attribute while+ reporting 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+operator 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.@@ -414,7 +442,9 @@ being bounded by SCPs (below): both forms of root enforcement now agree.so `aws:PrincipalArn` for an assumed-role caller will not match a condition that pins adifferent session name. This matches what `sts:GetCallerIdentity` already reports.-**Not yet supported**: `NotPrincipal`, resource-based policies (S3 bucket policy, Lambda resource policy).+**Not yet supported**: `NotPrincipal`, resource-based policies (S3 bucket policy, Lambda resource+policy), and `dynamodb:LeadingKeys` for `Scan`, `TransactWriteItems` / `TransactGetItems` and the+PartiQL operations.### Assumed rolesdiff --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 d713a9acfa..8211f48595 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,42 +1,146 @@package io.github.hectorvent.floci.core.common;+import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbConditionKeys;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbService;+import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;import jakarta.enterprise.context.ApplicationScoped;+import jakarta.enterprise.inject.Instance;+import jakarta.inject.Inject;import jakarta.ws.rs.container.ContainerRequestContext;import jakarta.ws.rs.core.MultivaluedMap;import java.util.LinkedHashMap;+import java.util.List;import java.util.Map;+/**+ * Builds the IAM request context: the condition keys a policy's Condition block can match,+ * for the request currently being enforced.+ */@ApplicationScopedpublic class IamConditionContextResolver {- public Map<String, String> resolve(String credentialScope, String action, ContainerRequestContext ctx) {+ /** Set by {@code ResourceArnBuilder.readJsonBody}, which runs earlier in the same filter pass. */+ private static final String BUFFERED_JSON_BODY = "floci.bufferedJsonBody";++ private final Instance<DynamoDbService> dynamoDbService;+ private final RequestContext requestContext;+ private final EmulatorConfig config;++ @Inject+ public IamConditionContextResolver(Instance<DynamoDbService> dynamoDbService,+ RequestContext requestContext,+ EmulatorConfig config) {+ this.dynamoDbService = dynamoDbService;+ this.requestContext = requestContext;+ this.config = config;+ }++ public Map<String, List<String>> resolve(String credentialScope, String action,+ ContainerRequestContext ctx) {return switch (credentialScope) {case "s3" -> s3ConditionContext(action, ctx);+ case "dynamodb" -> dynamoDbConditionContext(action, ctx);default -> null;};}- private Map<String, String> s3ConditionContext(String action, ContainerRequestContext ctx) {+ // ── S3 ──────────────────────────────────────────────────────────────────────++ private Map<String, List<String>> s3ConditionContext(String action, ContainerRequestContext ctx) {return switch (action) {case "s3:ListBucket" -> s3BucketListConditionContext(ctx.getUriInfo().getQueryParameters());default -> null;};}- Map<String, String> s3BucketListConditionContext(MultivaluedMap<String, String> queryParameters) {- Map<String, String> conditions = new LinkedHashMap<>();+ Map<String, List<String>> s3BucketListConditionContext(MultivaluedMap<String, String> queryParameters) {+ Map<String, List<String>> conditions = new LinkedHashMap<>();addQueryCondition(conditions, "s3:prefix", queryParameters, "prefix");addQueryCondition(conditions, "s3:delimiter", queryParameters, "delimiter");addQueryCondition(conditions, "s3:max-keys", queryParameters, "max-keys");return conditions.isEmpty() ? null : conditions;}- private static void addQueryCondition(Map<String, String> conditions, String conditionKey,+ private static void addQueryCondition(Map<String, List<String>> conditions, String conditionKey,MultivaluedMap<String, String> queryParameters, String queryParameter) {String value = queryParameters.getFirst(queryParameter);if (value != null) {- conditions.put(conditionKey, value);+ conditions.put(conditionKey, List.of(value));+ }+ }++ // ── DynamoDB ────────────────────────────────────────────────────────────────++ /**+ * Populates {@code dynamodb:LeadingKeys}, {@code dynamodb:Attributes} and+ * {@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.+ */+ Map<String, List<String>> dynamoDbConditionContext(String action, ContainerRequestContext ctx) {+ JsonNode body = bufferedJsonBody(ctx);+ if (body == null || !body.isObject()) {+ return null;+ }+ TableDefinition table = describeTargetTable(body);+ DynamoDbConditionKeys.Result keys = DynamoDbConditionKeys.extract(action, body, table);++ Map<String, List<String>> conditions = new LinkedHashMap<>();+ if (!keys.leadingKeys().isEmpty()) {+ conditions.put("dynamodb:LeadingKeys", keys.leadingKeys());+ }+ if (!keys.attributes().isEmpty()) {+ conditions.put("dynamodb:Attributes", keys.attributes());+ }+ if (keys.select() != null) {+ conditions.put("dynamodb:Select", List.of(keys.select()));+ }+ return conditions.isEmpty() ? null : conditions;+ }++ private JsonNode bufferedJsonBody(ContainerRequestContext ctx) {+ Object cached = ctx.getProperty(BUFFERED_JSON_BODY);+ return cached instanceof JsonNode node ? node : null;+ }++ /**+ * Looks up the table whose key schema names the partition key. Resolved lazily through+ * Instance so core.common keeps no hard dependency on the DynamoDB service, and via+ * {@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);+ if (tableName == null || !dynamoDbService.isResolvable()) {+ return null;+ }+ String region = requestContext.getRegion() == null+ ? config.defaultRegion() : requestContext.getRegion();+ return dynamoDbService.get().findTable(tableName, region).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.+ */+ private String targetTableName(JsonNode body) {+ if (body.hasNonNull("TableName")) {+ String tableName = body.get("TableName").asText().trim();+ if (!tableName.isEmpty()) {+ 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 d5fc3085a3..0ed7b8f31f 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@@ -171,7 +171,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {List<String> resources = arnBuilder.buildResources(credentialScope, ctx, region, accountId);- Map<String, String> conditionContext = conditionContextResolver.resolve(credentialScope, action, ctx);+ Map<String, List<String>> conditionContext = conditionContextResolver.resolve(credentialScope, action, ctx);// aws:PrincipalArn is populated for every principal this filter can identify — IAM users,// assumed-role sessions, and now the synthesized account-root principal above, using AWS's@@ -184,7 +184,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {: iamService.resolveCallerArn(akid);if (principalArn.isPresent()) {conditionContext = conditionContext == null ? new HashMap<>() : new HashMap<>(conditionContext);- conditionContext.put("aws:PrincipalArn", principalArn.get());+ conditionContext.put("aws:PrincipalArn", List.of(principalArn.get()));}for (String resource : resources) {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.javanew file mode 100644index 0000000000..381e9b2f9d--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeys.java@@ -0,0 +1,397 @@+package io.github.hectorvent.floci.services.dynamodb;++import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.services.dynamodb.model.GlobalSecondaryIndex;+import io.github.hectorvent.floci.services.dynamodb.model.KeySchemaElement;+import io.github.hectorvent.floci.services.dynamodb.model.LocalSecondaryIndex;+import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;++import java.util.ArrayList;+import java.util.Iterator;+import java.util.LinkedHashSet;+import java.util.List;+import java.util.Locale;+import java.util.Set;+import java.util.regex.Matcher;+import java.util.regex.Pattern;++/**+ * Extracts the DynamoDB IAM condition keys - {@code dynamodb:LeadingKeys},+ * {@code dynamodb:Attributes} and {@code dynamodb:Select} - from a request body.+ *+ * <p>Public and static, following the precedent of {@link DynamoDbPartiQLParser}, which the+ * IAM package already calls across the package boundary.+ *+ * <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+ * unsafe direction because omitting a referenced attribute could allow an unauthorized+ * operation to pass.+ */+public final class DynamoDbConditionKeys {++ private DynamoDbConditionKeys() {}++ /**+ * @param action the IAM action, e.g. {@code dynamodb:GetItem}+ * @param body the parsed request body; may be {@code null}+ * @param table the target table's definition, used only for the HASH key name; may be+ * {@code null}, in which case no leading keys are produced+ */+ public static Result extract(String action, JsonNode body, TableDefinition table) {+ if (body == null || !body.isObject()) {+ return new Result(List.of(), List.of(), null);+ }+ String pkName = partitionKeyName(table);+ List<String> leadingKeys = new ArrayList<>();+ Set<String> attributes = new LinkedHashSet<>();++ switch (action == null ? "" : action) {+ case "dynamodb:GetItem", "dynamodb:DeleteItem", "dynamodb:UpdateItem" -> {+ JsonNode key = body.get("Key");+ addAttributeNames(attributes, key);+ addLeadingKey(leadingKeys, key, pkName);+ }+ case "dynamodb:PutItem" -> {+ JsonNode item = body.get("Item");+ addAttributeNames(attributes, item);+ addLeadingKey(leadingKeys, item, pkName);+ }+ case "dynamodb:Query" -> {+ String indexName = textOrNull(body.get("IndexName"));+ String queryPkName = partitionKeyName(table, indexName);+ String value = DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ textOrNull(body.get("KeyConditionExpression")),+ body.get("ExpressionAttributeNames"),+ body.get("ExpressionAttributeValues"),+ queryPkName);+ if (value == null) {+ value = legacyKeyConditionEqualityValue(body.get("KeyConditions"), queryPkName);+ }+ if (value != null) {+ leadingKeys.add(value);+ }+ // Legacy map forms of the same clauses; the expression forms are covered below.+ addAttributeNames(attributes, body.get("KeyConditions"));+ addAttributeNames(attributes, body.get("QueryFilter"));+ }+ case "dynamodb:BatchGetItem" -> {+ for (JsonNode tableRequest : requestItemsFor(body, table)) {+ JsonNode keys = tableRequest.get("Keys");+ if (keys != null && keys.isArray()) {+ for (JsonNode key : keys) {+ addAttributeNames(attributes, key);+ addLeadingKey(leadingKeys, key, pkName);+ }+ }+ addAttributesToGet(attributes, tableRequest.get("AttributesToGet"));+ addProjectionAttributes(attributes,+ textOrNull(tableRequest.get("ProjectionExpression")),+ tableRequest.get("ExpressionAttributeNames"));+ }+ }+ case "dynamodb:BatchWriteItem" -> {+ for (JsonNode tableRequest : requestItemsFor(body, table)) {+ if (!tableRequest.isArray()) {+ continue;+ }+ for (JsonNode write : tableRequest) {+ JsonNode put = write.path("PutRequest").get("Item");+ addAttributeNames(attributes, put);+ addLeadingKey(leadingKeys, put, pkName);+ JsonNode delete = write.path("DeleteRequest").get("Key");+ addAttributeNames(attributes, delete);+ addLeadingKey(leadingKeys, delete, pkName);+ }+ }+ }+ default -> {+ // Scan and everything else: no leading keys. Attributes and Select below+ // still apply where the body carries them.+ }+ }++ addAttributesToGet(attributes, body.get("AttributesToGet"));+ addProjectionAttributes(attributes, textOrNull(body.get("ProjectionExpression")),+ body.get("ExpressionAttributeNames"));+ addUpdateExpressionAttributes(attributes, textOrNull(body.get("UpdateExpression")),+ body.get("ExpressionAttributeNames"));+ addExpressionAttributeNameValues(attributes, body.get("ExpressionAttributeNames"));++ // Names an expression references are attributes the request touches too. Under-reporting+ // these is the unsafe direction: a Query projecting only allowed attributes but filtering+ // on a forbidden one would still slip past a ForAllValues:StringEquals on dynamodb:Attributes.+ JsonNode exprAttrNames = body.get("ExpressionAttributeNames");+ addExpressionAttributes(attributes, textOrNull(body.get("KeyConditionExpression")), exprAttrNames);+ addExpressionAttributes(attributes, textOrNull(body.get("FilterExpression")), exprAttrNames);+ addExpressionAttributes(attributes, textOrNull(body.get("ConditionExpression")), exprAttrNames);++ // Legacy map forms naming attributes being read or updated.+ addAttributeNames(attributes, body.get("AttributeUpdates"));+ addAttributeNames(attributes, body.get("Expected"));+ addAttributeNames(attributes, body.get("ScanFilter"));++ return new Result(List.copyOf(leadingKeys), List.copyOf(attributes),+ textOrNull(body.get("Select")));+ }++ /**+ * The extracted keys. {@code leadingKeys} holds partition-key values in request order+ * (duplicates preserved), {@code attributes} holds attribute names in first-seen order+ * with duplicates removed, {@code select} is the raw Select value or {@code null}.+ */+ public record Result(List<String> leadingKeys, List<String> attributes, String select) {}++ // -- Helpers -----------------------------------------------------------------++ private static String partitionKeyName(TableDefinition table) {+ return partitionKeyName(table, null);+ }++ private static String partitionKeyName(TableDefinition table, String indexName) {+ if (table == null) {+ return null;+ }+ if (indexName != null) {+ if (table.getGlobalSecondaryIndexes() != null) {+ for (GlobalSecondaryIndex gsi : table.getGlobalSecondaryIndexes()) {+ if (indexName.equals(gsi.getIndexName())) {+ return hashKeyName(gsi.getKeySchema());+ }+ }+ }+ if (table.getLocalSecondaryIndexes() != null) {+ for (LocalSecondaryIndex lsi : table.getLocalSecondaryIndexes()) {+ if (indexName.equals(lsi.getIndexName())) {+ return hashKeyName(lsi.getKeySchema());+ }+ }+ }+ }+ return hashKeyName(table.getKeySchema());+ }++ private static String hashKeyName(List<KeySchemaElement> schema) {+ if (schema == null) {+ return null;+ }+ return schema.stream()+ .filter(key -> "HASH".equals(key.getKeyType()))+ .map(KeySchemaElement::getAttributeName)+ .findFirst()+ .orElse(null);+ }++ /**+ * The RequestItems entries this request touches. Prefers the entry named by the resolved+ * table, because only that table's HASH key name is known; falls back to every entry when+ * nothing matches, so a stub or an aliased name still yields something.+ */+ private static List<JsonNode> requestItemsFor(JsonNode body, TableDefinition table) {+ JsonNode requestItems = body.get("RequestItems");+ if (requestItems == null || !requestItems.isObject()) {+ return List.of();+ }+ String tableName = table == null ? null : table.getTableName();+ if (tableName != null && requestItems.has(tableName)) {+ return List.of(requestItems.get(tableName));+ }+ List<JsonNode> all = new ArrayList<>();+ requestItems.elements().forEachRemaining(all::add);+ return all;+ }++ private static void addLeadingKey(List<String> leadingKeys, JsonNode attributeMap, String pkName) {+ if (attributeMap == null || !attributeMap.isObject() || pkName == null) {+ return;+ }+ String value = scalarValue(attributeMap.get(pkName));+ if (value != null) {+ leadingKeys.add(value);+ }+ }++ private static void addAttributeNames(Set<String> attributes, JsonNode attributeMap) {+ if (attributeMap == null || !attributeMap.isObject()) {+ return;+ }+ Iterator<String> names = attributeMap.fieldNames();+ while (names.hasNext()) {+ attributes.add(names.next());+ }+ }++ private static void addAttributesToGet(Set<String> attributes, JsonNode attributesToGet) {+ if (attributesToGet == null || !attributesToGet.isArray()) {+ return;+ }+ for (JsonNode attribute : attributesToGet) {+ if (attribute.isTextual()) {+ attributes.add(attribute.asText());+ }+ }+ }++ private static void addProjectionAttributes(Set<String> attributes, String projectionExpression,+ JsonNode exprAttrNames) {+ if (projectionExpression == null || projectionExpression.isBlank()) {+ return;+ }+ try {+ attributes.addAll(ProjectionEvaluator.topLevelAttributes(projectionExpression, exprAttrNames));+ } catch (RuntimeException e) {+ // A malformed projection is the request handler's problem to report; for condition+ // keys it just means those attribute names stay unknown.+ }+ }++ private static void addExpressionAttributeNameValues(Set<String> attributes, JsonNode exprAttrNames) {+ if (exprAttrNames == null || !exprAttrNames.isObject()) {+ return;+ }+ exprAttrNames.elements().forEachRemaining(value -> {+ if (value.isTextual()) {+ attributes.add(value.asText());+ }+ });+ }++ private static final Set<String> UPDATE_EXPRESSION_KEYWORDS = Set.of(+ "set", "remove", "add", "delete", "if_not_exists", "list_append"+ );+ private static final Pattern UPDATE_EXPRESSION_ATTRIBUTE_PATTERN =+ Pattern.compile("(?<![.#a-zA-Z0-9_:'\"])(#?[a-zA-Z_][a-zA-Z0-9_]*)");++ /**+ * Top-level attribute names an UpdateExpression reads or writes. Captures LHS targets of+ * SET/REMOVE/ADD/DELETE and RHS operands (such as attributes in arithmetic, list_append,+ * or if_not_exists).+ */+ private static void addUpdateExpressionAttributes(Set<String> attributes, String updateExpression,+ JsonNode exprAttrNames) {+ if (updateExpression == null || updateExpression.isBlank()) {+ return;+ }+ Matcher matcher = UPDATE_EXPRESSION_ATTRIBUTE_PATTERN.matcher(updateExpression);+ while (matcher.find()) {+ String token = matcher.group(1);+ if (UPDATE_EXPRESSION_KEYWORDS.contains(token.toLowerCase(Locale.ROOT))) {+ continue;+ }+ String resolved = resolveAlias(token, exprAttrNames);+ if (resolved != null && !resolved.startsWith("#")) {+ attributes.add(resolved);+ }+ }+ }++ /** The EQ value a legacy {@code KeyConditions} map pins the partition key to, or {@code null}. */+ private static String legacyKeyConditionEqualityValue(JsonNode keyConditions, String pkName) {+ if (keyConditions == null || !keyConditions.isObject() || pkName == null) {+ return null;+ }+ JsonNode condition = keyConditions.get(pkName);+ if (condition == null || !"EQ".equals(textOrNull(condition.get("ComparisonOperator")))) {+ return null;+ }+ JsonNode list = condition.get("AttributeValueList");+ if (list == null || !list.isArray() || list.isEmpty()) {+ return null;+ }+ return scalarValue(list.get(0));+ }++ /**+ * 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.+ */+ private static void addExpressionAttributes(Set<String> attributes, String expression,+ JsonNode exprAttrNames) {+ if (expression == null || expression.isBlank()) {+ return;+ }+ ExpressionEvaluator.Expr root;+ try {+ root = ExpressionEvaluator.parse(expression);+ } catch (RuntimeException e) {+ return;+ }+ collectExpressionPaths(root, attributes, exprAttrNames);+ }++ private static void collectExpressionPaths(ExpressionEvaluator.Expr expr, Set<String> attributes,+ JsonNode exprAttrNames) {+ if (expr == null) {+ return;+ }+ switch (expr) {+ case ExpressionEvaluator.AndExpr and ->+ and.operands().forEach(o -> collectExpressionPaths(o, attributes, exprAttrNames));+ case ExpressionEvaluator.OrExpr or ->+ or.operands().forEach(o -> collectExpressionPaths(o, attributes, exprAttrNames));+ case ExpressionEvaluator.NotExpr not ->+ collectExpressionPaths(not.operand(), attributes, exprAttrNames);+ case ExpressionEvaluator.CompareExpr cmp -> {+ collectOperandPath(cmp.left(), attributes, exprAttrNames);+ collectOperandPath(cmp.right(), attributes, exprAttrNames);+ }+ case ExpressionEvaluator.BetweenExpr between -> {+ collectOperandPath(between.value(), attributes, exprAttrNames);+ collectOperandPath(between.low(), attributes, exprAttrNames);+ collectOperandPath(between.high(), attributes, exprAttrNames);+ }+ case ExpressionEvaluator.InExpr in -> {+ collectOperandPath(in.value(), attributes, exprAttrNames);+ in.candidates().forEach(c -> collectOperandPath(c, attributes, exprAttrNames));+ }+ case ExpressionEvaluator.FunctionCallExpr fn ->+ fn.args().forEach(a -> collectOperandPath(a, attributes, exprAttrNames));+ default -> { }+ }+ }++ private static void collectOperandPath(ExpressionEvaluator.Operand operand, Set<String> attributes,+ JsonNode exprAttrNames) {+ if (operand instanceof ExpressionEvaluator.PathOperand path && !path.segments().isEmpty()) {+ String name = resolveAlias(path.segments().getFirst(), exprAttrNames);+ if (name != null && !name.startsWith(":")) {+ attributes.add(name);+ }+ } else if (operand instanceof ExpressionEvaluator.FunctionOperand fn) {+ fn.args().forEach(a -> collectOperandPath(a, attributes, exprAttrNames));+ }+ }++ private static String resolveAlias(String segment, JsonNode exprAttrNames) {+ if (segment.startsWith("#") && exprAttrNames != null && exprAttrNames.has(segment)) {+ return exprAttrNames.get(segment).asText();+ }+ return segment;+ }++ /** Unwraps an AttributeValue to its scalar text. Only S, N and B can be key values. */+ private static String scalarValue(JsonNode attributeValue) {+ if (attributeValue == null || !attributeValue.isObject()) {+ return null;+ }+ for (String type : List.of("S", "N", "B")) {+ JsonNode payload = attributeValue.get(type);+ if (payload != null && payload.isTextual()) {+ return payload.asText();+ }+ }+ return null;+ }++ private static String textOrNull(JsonNode node) {+ if (node == null || !node.isTextual()) {+ return null;+ }+ String text = node.asText();+ return text.isEmpty() ? null : text;+ }+}\ No newline at end of filediff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParser.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParser.javanew file mode 100644index 0000000000..38d9bfaae3--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParser.java@@ -0,0 +1,91 @@+package io.github.hectorvent.floci.services.dynamodb;++import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.services.dynamodb.ExpressionEvaluator.AndExpr;+import io.github.hectorvent.floci.services.dynamodb.ExpressionEvaluator.CompareExpr;+import io.github.hectorvent.floci.services.dynamodb.ExpressionEvaluator.Expr;+import io.github.hectorvent.floci.services.dynamodb.ExpressionEvaluator.PathOperand;+import io.github.hectorvent.floci.services.dynamodb.ExpressionEvaluator.PlaceholderOperand;+import io.github.hectorvent.floci.services.dynamodb.ExpressionEvaluator.TokenType;++import java.util.List;++/**+ * Narrow read-only view over a Query {@code KeyConditionExpression}: the scalar value the+ * partition key is pinned to by an equality condition.+ *+ * <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.+ */+final class DynamoDbKeyConditionParser {++ private DynamoDbKeyConditionParser() {}++ /**+ * @param keyConditionExpression the raw Query KeyConditionExpression+ * @param exprAttrNames ExpressionAttributeNames, or {@code null}+ * @param exprAttrValues ExpressionAttributeValues, or {@code null}+ * @param pkName the table's HASH key attribute name+ * @return the S / N / B scalar the partition key equals, or {@code null} when it cannot+ * be resolved+ */+ static String partitionKeyEqualityValue(String keyConditionExpression,+ JsonNode exprAttrNames,+ JsonNode exprAttrValues,+ String pkName) {+ if (keyConditionExpression == null || keyConditionExpression.isBlank()+ || pkName == null || exprAttrValues == null) {+ return null;+ }+ Expr root;+ try {+ root = ExpressionEvaluator.parse(keyConditionExpression);+ } catch (RuntimeException e) {+ return null; // unparseable expression → leading key unknown → fail closed upstream+ }+ 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)) {+ continue;+ }+ if (!pkName.equals(topLevelAttribute(compare.left(), exprAttrNames))) {+ continue;+ }+ return scalarValue(exprAttrValues.get(placeholder.name()));+ }+ return null;+ }++ /** Resolves a single-segment path operand, following a {@code #alias} when one is used. */+ private static String topLevelAttribute(Object operand, JsonNode exprAttrNames) {+ if (!(operand instanceof PathOperand path) || path.segments().size() != 1) {+ return null;+ }+ String segment = path.segments().getFirst();+ if (segment.startsWith("#") && exprAttrNames != null && exprAttrNames.has(segment)) {+ return exprAttrNames.get(segment).asText();+ }+ return segment;+ }++ /** Unwraps an AttributeValue to its scalar text. Only S, N and B can be key values. */+ private static String scalarValue(JsonNode attributeValue) {+ if (attributeValue == null || !attributeValue.isObject()) {+ return null;+ }+ for (String type : List.of("S", "N", "B")) {+ JsonNode payload = attributeValue.get(type);+ if (payload != null && payload.isTextual()) {+ return payload.asText();+ }+ }+ return null;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.javaindex a0dbf13b70..bd1ae61d43 100644--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbService.java@@ -45,6 +45,7 @@ import java.util.LinkedHashSet;import java.util.Iterator;import java.util.List;import java.util.Map;+import java.util.Optional;import java.util.Set;import java.util.TreeMap;import java.util.UUID;@@ -396,6 +397,19 @@ public class DynamoDbService implements ResourceProvider {return table;}+ /**+ * The stored table definition without the {@link #describeTable} item-count refresh,+ * which is {@code O(items)} on the item map. For callers that only need static metadata+ * such as the key schema — notably IAM condition-key resolution, which runs on the+ * request hot path before the request is even authorized.+ *+ * @return the definition, or empty when no such table exists in the region+ */+ public Optional<TableDefinition> findTable(String tableName, String region) {+ String storageKey = regionKey(region, canonicalTableName(region, tableName));+ return tableStore.get(storageKey);+ }+public void persistTable(String tableName, TableDefinition table, String region) {String canonicalTableName = canonicalTableName(region, tableName);tableStore.put(regionKey(region, canonicalTableName), table);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 94ec217efb..a62d894586 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@@ -72,15 +72,15 @@ public class IamPolicyEvaluator {* @param resourcePolicies resource-based policy documents (Phase 2); may be null or empty* @param action IAM action, e.g. "s3:GetObject"* @param resource resource ARN, e.g. "arn:aws:s3:::my-bucket/key"- * @param conditionCtx condition context key-value pairs; may be null or empty+ * @param conditionCtx condition context key → values; may be null or empty* @return {@link Decision#ALLOW} or {@link Decision#DENY}*/public Decision evaluate(CallerContext caller,List<String> resourcePolicies,String action,String resource,- Map<String, String> conditionCtx) {- Map<String, String> ctx = normalizeConditionContext(conditionCtx);+ Map<String, List<String>> conditionCtx) {+ Map<String, List<String>> ctx = normalizeConditionContext(conditionCtx);List<PolicyStatement> identityStmts = parseAll(caller.identityPolicies());List<PolicyStatement> resourceStmts = resourcePolicies == null ? List.of() : parseAll(resourcePolicies);@@ -139,15 +139,15 @@ public class IamPolicyEvaluator {public Decision simulateCustomPolicy(List<String> policyDocuments,String action,String resource,- Map<String, String> conditionCtx) {+ Map<String, List<String>> conditionCtx) {return evaluate(CallerContext.of(policyDocuments), null, action, resource, conditionCtx);}public SimulationDecision simulatePrincipalPolicy(CallerContext caller,String action,String resource,- Map<String, String> conditionCtx) {- Map<String, String> ctx = normalizeConditionContext(conditionCtx);+ Map<String, List<String>> conditionCtx) {+ Map<String, List<String>> ctx = normalizeConditionContext(conditionCtx);List<PolicyStatement> identityStmts = parseAll(caller.identityPolicies());List<PolicyStatement> sessionStmts = caller.sessionPolicyDocument() == null? null : parseAll(List.of(caller.sessionPolicyDocument()));@@ -183,7 +183,7 @@ public class IamPolicyEvaluator {* everything the operator meant to forbid.</p>*/private boolean scpAllows(List<List<String>> scpLevels, String action, String resource,- Map<String, String> ctx) {+ Map<String, List<String>> ctx) {if (scpLevels == null) {return true;}@@ -208,20 +208,31 @@ public class IamPolicyEvaluator {// Statement matching// ------------------------------------------------------------------------ private Map<String, String> normalizeConditionContext(Map<String, String> conditionCtx) {+ /**+ * Lower-cases keys and copies the value lists, dropping null keys, null lists and null+ * members. An empty list is preserved: an empty set is not the same thing as an absent+ * key — AWS's set operators give it its own semantics (ForAllValues matches vacuously,+ * ForAnyValue does not match).+ */+ private Map<String, List<String>> normalizeConditionContext(Map<String, List<String>> conditionCtx) {if (conditionCtx == null || conditionCtx.isEmpty()) {return Map.of();}- return conditionCtx.entrySet().stream()- .filter(entry -> entry.getKey() != null && entry.getValue() != null)- .collect(java.util.stream.Collectors.toMap(- entry -> entry.getKey().toLowerCase(java.util.Locale.ROOT),- Map.Entry::getValue,- (first, ignored) -> first));+ Map<String, List<String>> normalized = new LinkedHashMap<>();+ for (Map.Entry<String, List<String>> entry : conditionCtx.entrySet()) {+ if (entry.getKey() == null || entry.getValue() == null) {+ continue;+ }+ List<String> values = entry.getValue().stream()+ .filter(java.util.Objects::nonNull)+ .toList();+ normalized.putIfAbsent(entry.getKey().toLowerCase(java.util.Locale.ROOT), values);+ }+ return normalized;}private boolean anyExplicitDeny(List<PolicyStatement> stmts, String action, String resource,- Map<String, String> ctx) {+ Map<String, List<String>> ctx) {for (PolicyStatement stmt : stmts) {if (stmt.isDeny() && matchesStatement(stmt, action, resource, ctx)) {return true;@@ -231,7 +242,7 @@ public class IamPolicyEvaluator {}private boolean anyExplicitAllow(List<PolicyStatement> stmts, String action, String resource,- Map<String, String> ctx) {+ Map<String, List<String>> ctx) {for (PolicyStatement stmt : stmts) {if (stmt.isAllow() && matchesStatement(stmt, action, resource, ctx)) {return true;@@ -241,7 +252,7 @@ public class IamPolicyEvaluator {}private boolean matchesStatement(PolicyStatement stmt, String action, String resource,- Map<String, String> ctx) {+ Map<String, List<String>> ctx) {return matchesAction(stmt, action)&& matchesResource(stmt, resource)&& matchesConditions(stmt.getConditions(), ctx);@@ -290,7 +301,7 @@ public class IamPolicyEvaluator {* Returns true if ALL blocks pass (or there are no conditions).*/private boolean matchesConditions(Map<String, Map<String, List<String>>> conditions,- Map<String, String> ctx) {+ Map<String, List<String>> ctx) {if (conditions == null || conditions.isEmpty()) {return true;}@@ -302,18 +313,82 @@ public class IamPolicyEvaluator {return true;}+ /**+ * AWS set-operator quantifier. {@code ForAllValues:} requires every value the request+ * carries for the key to match the policy; {@code ForAnyValue:} requires at least one.+ */+ private enum SetQuantifier { NONE, FOR_ALL_VALUES, FOR_ANY_VALUE }++ private record ParsedOperator(SetQuantifier quantifier, String baseOp, boolean ifExists) {}++ /**+ * Splits a condition operator into its set quantifier, base operator and IfExists flag.+ * The prefix match is case-sensitive on exactly AWS's own spelling, so a mis-cased+ * "forallvalues:" stays an unknown operator instead of silently behaving like the+ * real quantifier. The IfExists strip runs on what is left, so+ * "ForAnyValue:StringEqualsIfExists" composes correctly.+ */+ private static ParsedOperator parseOperator(String operator) {+ SetQuantifier quantifier = SetQuantifier.NONE;+ String rest = operator;+ if (rest.startsWith("ForAllValues:")) {+ quantifier = SetQuantifier.FOR_ALL_VALUES;+ rest = rest.substring("ForAllValues:".length());+ } else if (rest.startsWith("ForAnyValue:")) {+ quantifier = SetQuantifier.FOR_ANY_VALUE;+ rest = rest.substring("ForAnyValue:".length());+ }+ boolean ifExists = rest.endsWith("IfExists");+ String baseOp = ifExists ? rest.substring(0, rest.length() - "IfExists".length()) : rest;+ return new ParsedOperator(quantifier, baseOp, ifExists);+ }++ /**+ * Combines the policy's condition values for a single request value. Positive operators+ * OR — the request value may match any listed value. Negated operators AND — the request+ * value must differ from every listed value, which is AWS's documented rule for a+ * multi-valued negated condition and the deny-list idiom for keys such as+ * {@code dynamodb:Attributes} ({@code ForAllValues:StringNotEquals}).+ */+ private boolean matchesCondValues(String baseOp, String ctxValue, List<String> condValues) {+ if (isNegatedOperator(baseOp)) {+ for (String condValue : condValues) {+ if (!evaluateSingleCondition(baseOp, ctxValue, condValue)) {+ return false;+ }+ }+ return true;+ }+ for (String condValue : condValues) {+ if (evaluateSingleCondition(baseOp, ctxValue, condValue)) {+ return true;+ }+ }+ return false;+ }++ private static boolean isNegatedOperator(String baseOp) {+ return switch (baseOp) {+ case "StringNotEquals", "StringNotEqualsIgnoreCase", "StringNotLike",+ "ArnNotEquals", "ArnNotLike", "NumericNotEquals", "DateNotEquals",+ "NotIpAddress" -> true;+ default -> false;+ };+ }+private boolean evaluateConditionBlock(String operator,Map<String, List<String>> keyValueMap,- Map<String, String> ctx) {- boolean ifExists = operator.endsWith("IfExists");- String baseOp = ifExists ? operator.substring(0, operator.length() - "IfExists".length()) : operator;+ Map<String, List<String>> ctx) {+ ParsedOperator parsed = parseOperator(operator);+ String baseOp = parsed.baseOp();+ boolean ifExists = parsed.ifExists();for (Map.Entry<String, List<String>> entry : keyValueMap.entrySet()) {- String condKey = entry.getKey().toLowerCase();+ String condKey = entry.getKey().toLowerCase(java.util.Locale.ROOT);List<String> condValues = entry.getValue();- String ctxValue = ctx.get(condKey);+ List<String> ctxValues = ctx.get(condKey);- if (ctxValue == null) {+ if (ctxValues == null) {if ("Null".equalsIgnoreCase(baseOp)) {// Null: {key: "true"} → key must be absent → pass when any condValue is "true"boolean expectAbsent = condValues.stream().anyMatch("true"::equalsIgnoreCase);@@ -329,22 +404,31 @@ public class IamPolicyEvaluator {}if ("Null".equalsIgnoreCase(baseOp)) {- // Key is present — Null:{key:"true"} should fail, Null:{key:"false"} should pass+ // Key is present. An empty set counts as nonexistent for Null, matching AWS,+ // so the Null:{key:"false"} guard that policies pair with ForAllValues still+ // blocks a vacuous match. Null:{key:"true"} passes only when effectively absent.boolean expectAbsent = condValues.stream().anyMatch("true"::equalsIgnoreCase);- if (expectAbsent) {- return false; // expected absent but key has value+ boolean effectivelyAbsent = ctxValues.isEmpty();+ if (expectAbsent != effectivelyAbsent) {+ return false;}continue;}- // OR across condValues for this key- boolean keyMatch = false;- for (String condValue : condValues) {- if (evaluateSingleCondition(baseOp, ctxValue, condValue)) {- keyMatch = true;- break;- }- }+ boolean keyMatch = switch (parsed.quantifier()) {+ // Every request value must match at least one policy value. An empty set+ // matches vacuously, which is why real policies pair ForAllValues with a+ // Null:{key:"false"} guard.+ case FOR_ALL_VALUES -> ctxValues.stream()+ .allMatch(ctxValue -> matchesCondValues(baseOp, ctxValue, condValues));+ // At least one request value must match. An empty set never matches.+ case FOR_ANY_VALUE -> ctxValues.stream()+ .anyMatch(ctxValue -> matchesCondValues(baseOp, ctxValue, condValues));+ // A bare operator against a multi-valued key is a policy authoring error in+ // AWS; mirror that by comparing only the first value.+ case NONE -> !ctxValues.isEmpty()+ && matchesCondValues(baseOp, ctxValues.getFirst(), condValues);+ };if (!keyMatch) {return false;}@@ -352,6 +436,7 @@ public class IamPolicyEvaluator {return true;}+private boolean evaluateSingleCondition(String operator, String ctxValue, String condValue) {return switch (operator) {case "StringEquals" -> ctxValue.equals(condValue);diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.javaindex d266434d4a..08f30b3f84 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java@@ -1174,7 +1174,7 @@ public class IamQueryHandler {if (resourceArns.isEmpty()) {resourceArns = List.of("*");}- Map<String, String> context = extractContextEntries(params);+ Map<String, List<String>> context = extractContextEntries(params);XmlBuilder results = new XmlBuilder().start("EvaluationResults");for (String actionName : actionNames) {@@ -1402,14 +1402,21 @@ public class IamQueryHandler {return values;}- private Map<String, String> extractContextEntries(MultivaluedMap<String, String> params) {- Map<String, String> context = new HashMap<>();+ /**+ * Reads every {@code ContextEntries.member.N.ContextKeyValues.member.M}. AWS context keys+ * are set-typed, and the evaluator's set operators quantify over the whole set, so reading+ * only {@code member.1} silently dropped the values a ForAnyValue:/ForAllValues: condition+ * has to see. An entry that names a key but supplies no value is skipped.+ */+ private Map<String, List<String>> extractContextEntries(MultivaluedMap<String, String> params) {+ Map<String, List<String>> context = new HashMap<>();for (int i = 1; ; i++) {String name = params.getFirst("ContextEntries.member." + i + ".ContextKeyName");if (name == null) break;- String value = params.getFirst("ContextEntries.member." + i + ".ContextKeyValues.member.1");- if (value != null) {- context.put(name, value);+ List<String> values = extractIndexedValues(+ params, "ContextEntries.member." + i + ".ContextKeyValues.member");+ if (!values.isEmpty()) {+ context.put(name, values);}}return context;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 9aa1e3a262..0231298f76 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@@ -1,21 +1,69 @@package io.github.hectorvent.floci.core.common;+import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.services.dynamodb.DynamoDbService;+import io.github.hectorvent.floci.services.dynamodb.model.KeySchemaElement;+import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;+import jakarta.enterprise.inject.Instance;import jakarta.ws.rs.container.ContainerRequestContext;import jakarta.ws.rs.core.MultivaluedHashMap;import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.UriInfo;+import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import java.util.List;import java.util.Map;+import java.util.Optional;import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNull;+import static org.mockito.ArgumentMatchers.anyString;+import static org.mockito.ArgumentMatchers.eq;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.when;class IamConditionContextResolverTest {- private final IamConditionContextResolver resolver = new IamConditionContextResolver();+ private final ObjectMapper mapper = new ObjectMapper();+ private DynamoDbService dynamoDbService;+ private Instance<DynamoDbService> dynamoDbServiceInstance;+ private RequestContext requestContext;+ private EmulatorConfig config;+ private IamConditionContextResolver resolver;++ @SuppressWarnings("unchecked")+ @BeforeEach+ void setUp() {+ dynamoDbService = mock(DynamoDbService.class);+ dynamoDbServiceInstance = mock(Instance.class);+ when(dynamoDbServiceInstance.isResolvable()).thenReturn(true);+ when(dynamoDbServiceInstance.get()).thenReturn(dynamoDbService);+ requestContext = new RequestContext();+ requestContext.setRegion("us-east-1");+ config = mock(EmulatorConfig.class);+ when(config.defaultRegion()).thenReturn("us-east-1");+ resolver = new IamConditionContextResolver(+ dynamoDbServiceInstance, requestContext, config);+ }++ private TableDefinition fgacTable() {+ TableDefinition table = new TableDefinition();+ table.setTableName("FgacTable");+ table.setKeySchema(List.of(new KeySchemaElement("PK", "HASH")));+ return table;+ }++ private JsonNode json(String raw) {+ try {+ return mapper.readTree(raw);+ } catch (Exception e) {+ throw new IllegalStateException(e);+ }+ }@Testvoid resolvesS3ListBucketQueryConditionContext() {@@ -29,11 +77,12 @@ class IamConditionContextResolverTest {when(containerRequest.getUriInfo()).thenReturn(uriInfo);when(uriInfo.getQueryParameters()).thenReturn(query);- Map<String, String> conditions = resolver.resolve("s3", "s3:ListBucket", containerRequest);+ Map<String, List<String>> conditions =+ resolver.resolve("s3", "s3:ListBucket", containerRequest);- assertEquals("my_namespace/table/", conditions.get("s3:prefix"));- assertEquals("/", conditions.get("s3:delimiter"));- assertEquals("100", conditions.get("s3:max-keys"));+ assertEquals(List.of("my_namespace/table/"), conditions.get("s3:prefix"));+ assertEquals(List.of("/"), conditions.get("s3:delimiter"));+ assertEquals(List.of("100"), conditions.get("s3:max-keys"));}@Test@@ -48,4 +97,90 @@ class IamConditionContextResolverTest {assertNull(resolver.resolve("lambda", "lambda:InvokeFunction", containerRequest));assertNull(resolver.resolve("s3", "s3:GetObject", containerRequest));}++ @Test+ void resolvesDynamoDbLeadingKeysForGetItem() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ when(containerRequest.getProperty("floci.bufferedJsonBody")).thenReturn(json("""+ {"TableName":"FgacTable","Key":{"PK":{"S":"USER_alice"}}}"""));+ when(dynamoDbService.findTable("FgacTable", "us-east-1")).thenReturn(Optional.of(fgacTable()));++ Map<String, List<String>> conditions =+ resolver.resolve("dynamodb", "dynamodb:GetItem", containerRequest);++ assertEquals(List.of("USER_alice"), conditions.get("dynamodb:LeadingKeys"));+ assertEquals(List.of("PK"), conditions.get("dynamodb:Attributes"));+ assertFalse(conditions.containsKey("dynamodb:Select"));+ }++ @Test+ void omitsLeadingKeysWhenTheTableIsUnknown() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ when(containerRequest.getProperty("floci.bufferedJsonBody")).thenReturn(json("""+ {"TableName":"MissingTable","Key":{"PK":{"S":"USER_alice"}}}"""));+ when(dynamoDbService.findTable(eq("MissingTable"), anyString()))+ .thenReturn(Optional.empty());++ Map<String, List<String>> conditions =+ resolver.resolve("dynamodb", "dynamodb:GetItem", containerRequest);++ assertFalse(conditions.containsKey("dynamodb:LeadingKeys"));+ // Attribute names do not depend on the key schema, so they are still populated.+ assertEquals(List.of("PK"), conditions.get("dynamodb:Attributes"));+ }++ @Test+ void carriesSelectForQuery() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ when(containerRequest.getProperty("floci.bufferedJsonBody")).thenReturn(json("""+ {"TableName":"FgacTable",+ "KeyConditionExpression":"PK = :v",+ "ExpressionAttributeValues":{":v":{"S":"USER_alice"}},+ "Select":"COUNT"}"""));+ when(dynamoDbService.findTable("FgacTable", "us-east-1")).thenReturn(Optional.of(fgacTable()));++ Map<String, List<String>> conditions =+ resolver.resolve("dynamodb", "dynamodb:Query", containerRequest);++ assertEquals(List.of("USER_alice"), conditions.get("dynamodb:LeadingKeys"));+ assertEquals(List.of("COUNT"), conditions.get("dynamodb:Select"));+ }++ @Test+ void returnsNullWhenNoBodyWasBuffered() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ when(containerRequest.getProperty("floci.bufferedJsonBody")).thenReturn(null);++ assertNull(resolver.resolve("dynamodb", "dynamodb:GetItem", containerRequest));+ }++ @Test+ void resolvesBatchGetItemAcrossEveryRequestedKey() {+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ when(containerRequest.getProperty("floci.bufferedJsonBody")).thenReturn(json("""+ {"RequestItems":{"FgacTable":{"Keys":[+ {"PK":{"S":"USER_alice"}},{"PK":{"S":"USER_bob"}}]}}}"""));+ when(dynamoDbService.findTable("FgacTable", "us-east-1")).thenReturn(Optional.of(fgacTable()));++ Map<String, List<String>> conditions =+ resolver.resolve("dynamodb", "dynamodb:BatchGetItem", containerRequest);++ assertEquals(List.of("USER_alice", "USER_bob"), conditions.get("dynamodb:LeadingKeys"));+ }++ @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.+ 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"}}]}}}"""));++ Map<String, List<String>> conditions =+ resolver.resolve("dynamodb", "dynamodb:BatchGetItem", containerRequest);++ assertFalse(conditions.containsKey("dynamodb:LeadingKeys"));+ }}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.javaindex 7d1d310a88..be664559bd 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@@ -256,7 +256,7 @@ class IamEnforcementFilterTest {@Testvoid filterPassesS3ListBucketConditionContext() {ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);- Map<String, String> conditions = Map.of("s3:prefix", "my_namespace/table/");+ Map<String, List<String>> conditions = Map.of("s3:prefix", List.of("my_namespace/table/"));String auth = "AWS4-HMAC-SHA256 Credential=ASIASESSION/20260706/us-east-1/s3/aws4_request, "+ "SignedHeaders=host, Signature=abc";diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeysTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeysTest.javanew file mode 100644index 0000000000..6152f221cd--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeysTest.java@@ -0,0 +1,360 @@+package io.github.hectorvent.floci.services.dynamodb;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.services.dynamodb.model.GlobalSecondaryIndex;+import io.github.hectorvent.floci.services.dynamodb.model.KeySchemaElement;+import io.github.hectorvent.floci.services.dynamodb.model.LocalSecondaryIndex;+import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.util.List;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertTrue;++class DynamoDbConditionKeysTest {++ private final ObjectMapper mapper = new ObjectMapper();+ private TableDefinition table;++ @BeforeEach+ void setUp() {+ table = new TableDefinition();+ table.setTableName("FgacTable");+ table.setKeySchema(List.of(+ new KeySchemaElement("PK", "HASH"),+ new KeySchemaElement("SK", "RANGE")));+ }++ private JsonNode json(String raw) {+ try {+ return mapper.readTree(raw);+ } catch (Exception e) {+ throw new IllegalStateException(e);+ }+ }++ @Test+ void getItemExposesTheKeyValueAndTheKeyAttributeNames() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:GetItem",+ json("""+ {"TableName":"FgacTable",+ "Key":{"PK":{"S":"USER_alice"},"SK":{"S":"profile"}}}"""),+ table);++ assertEquals(List.of("USER_alice"), result.leadingKeys());+ assertEquals(List.of("PK", "SK"), result.attributes());+ assertNull(result.select());+ }++ @Test+ void putItemExposesTheItemPartitionKeyAndEveryItemAttribute() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:PutItem",+ json("""+ {"TableName":"FgacTable",+ "Item":{"PK":{"S":"USER_alice"},"SK":{"S":"profile"},"email":{"S":"[email protected]"}}}"""),+ table);++ assertEquals(List.of("USER_alice"), result.leadingKeys());+ assertEquals(List.of("PK", "SK", "email"), result.attributes());+ }++ @Test+ void updateItemExposesTheKeyValueAndTheUpdateExpressionTargets() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:UpdateItem",+ json("""+ {"TableName":"FgacTable",+ "Key":{"PK":{"S":"USER_alice"},"SK":{"S":"profile"}},+ "UpdateExpression":"SET #e = :e REMOVE nickname",+ "ExpressionAttributeNames":{"#e":"email"},+ "ExpressionAttributeValues":{":e":{"S":"[email protected]"}}}"""),+ table);++ assertEquals(List.of("USER_alice"), result.leadingKeys());+ assertTrue(result.attributes().contains("PK"), result.attributes().toString());+ assertTrue(result.attributes().contains("email"), result.attributes().toString());+ assertTrue(result.attributes().contains("nickname"), result.attributes().toString());+ }++ @Test+ void deleteItemExposesTheKeyValue() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:DeleteItem",+ json("""+ {"TableName":"FgacTable","Key":{"PK":{"S":"USER_bob"},"SK":{"S":"profile"}}}"""),+ table);++ assertEquals(List.of("USER_bob"), result.leadingKeys());+ }++ @Test+ void queryResolvesTheLeadingKeyFromTheKeyConditionExpressionAndCarriesSelect() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:Query",+ json("""+ {"TableName":"FgacTable",+ "KeyConditionExpression":"PK = :v AND SK > :s",+ "ExpressionAttributeValues":{":v":{"S":"USER_alice"},":s":{"S":"2020"}},+ "ProjectionExpression":"email, #n",+ "ExpressionAttributeNames":{"#n":"nickname"},+ "Select":"SPECIFIC_ATTRIBUTES"}"""),+ table);++ assertEquals(List.of("USER_alice"), result.leadingKeys());+ assertEquals("SPECIFIC_ATTRIBUTES", result.select());+ assertTrue(result.attributes().contains("email"), result.attributes().toString());+ assertTrue(result.attributes().contains("nickname"), result.attributes().toString());+ }++ @Test+ void queryResolvesAnAliasedPartitionKey() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:Query",+ json("""+ {"TableName":"FgacTable",+ "KeyConditionExpression":"#p = :v",+ "ExpressionAttributeNames":{"#p":"PK"},+ "ExpressionAttributeValues":{":v":{"S":"USER_alice"}}}"""),+ table);++ assertEquals(List.of("USER_alice"), result.leadingKeys());+ }++ @Test+ void batchGetItemExposesEveryRequestedKey() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:BatchGetItem",+ json("""+ {"RequestItems":{"FgacTable":{"Keys":[+ {"PK":{"S":"USER_alice"},"SK":{"S":"a"}},+ {"PK":{"S":"USER_alice_2"},"SK":{"S":"b"}},+ {"PK":{"S":"USER_bob"},"SK":{"S":"c"}}]}}}"""),+ table);++ assertEquals(List.of("USER_alice", "USER_alice_2", "USER_bob"), result.leadingKeys());+ }++ @Test+ void batchWriteItemExposesPutAndDeleteKeys() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:BatchWriteItem",+ json("""+ {"RequestItems":{"FgacTable":[+ {"PutRequest":{"Item":{"PK":{"S":"USER_alice"},"SK":{"S":"a"}}}},+ {"DeleteRequest":{"Key":{"PK":{"S":"USER_bob"},"SK":{"S":"b"}}}}]}}"""),+ table);++ assertEquals(List.of("USER_alice", "USER_bob"), result.leadingKeys());+ }++ @Test+ void nullTableYieldsNoLeadingKeysAndDoesNotThrow() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:GetItem",+ json("""+ {"TableName":"FgacTable","Key":{"PK":{"S":"USER_alice"}}}"""),+ null);++ assertTrue(result.leadingKeys().isEmpty());+ assertEquals(List.of("PK"), result.attributes());+ }++ @Test+ void aKeyMissingThePartitionAttributeYieldsNoLeadingKeys() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:GetItem",+ json("""+ {"TableName":"FgacTable","Key":{"SK":{"S":"profile"}}}"""),+ table);++ assertTrue(result.leadingKeys().isEmpty());+ }++ @Test+ void nullBodyYieldsAnEmptyResult() {+ DynamoDbConditionKeys.Result result =+ DynamoDbConditionKeys.extract("dynamodb:GetItem", null, table);++ assertTrue(result.leadingKeys().isEmpty());+ assertTrue(result.attributes().isEmpty());+ assertNull(result.select());+ }++ @Test+ void queryCollectsLiteralAttributeNamesFromAFilterExpression() {+ // A projection of only allowed attributes must not hide a filter on a forbidden one.+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:Query",+ json("""+ {"TableName":"FgacTable",+ "KeyConditionExpression":"PK = :v",+ "ExpressionAttributeValues":{":v":{"S":"USER_alice"},":x":{"S":"y"}},+ "FilterExpression":"ssn = :x",+ "ProjectionExpression":"email"}"""),+ table);++ assertTrue(result.attributes().contains("ssn"), result.attributes().toString());+ assertTrue(result.attributes().contains("email"), result.attributes().toString());+ assertTrue(result.attributes().contains("PK"), result.attributes().toString());+ }++ @Test+ void putItemCollectsLiteralAttributeNamesFromAConditionExpression() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:PutItem",+ json("""+ {"TableName":"FgacTable",+ "Item":{"PK":{"S":"USER_alice"},"SK":{"S":"profile"}},+ "ConditionExpression":"attribute_not_exists(locked)"}"""),+ table);++ assertTrue(result.attributes().contains("locked"), result.attributes().toString());+ }++ @Test+ void queryResolvesTheLeadingKeyFromALegacyKeyConditionsMap() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:Query",+ json("""+ {"TableName":"FgacTable",+ "KeyConditions":{"PK":{"ComparisonOperator":"EQ",+ "AttributeValueList":[{"S":"USER_alice"}]}}}"""),+ table);++ assertEquals(List.of("USER_alice"), result.leadingKeys());+ assertTrue(result.attributes().contains("PK"), result.attributes().toString());+ }++ @Test+ void attributesToGetAreExposed() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:GetItem",+ json("""+ {"TableName":"FgacTable","Key":{"PK":{"S":"USER_alice"}},+ "AttributesToGet":["email","nickname"]}"""),+ table);++ assertTrue(result.attributes().contains("email"), result.attributes().toString());+ assertTrue(result.attributes().contains("nickname"), result.attributes().toString());+ }++ @Test+ void queryAgainstGsiResolvesGsiPartitionKeyAsLeadingKey() {+ GlobalSecondaryIndex gsi = new GlobalSecondaryIndex();+ gsi.setIndexName("EmailGSI");+ gsi.setKeySchema(List.of(+ new KeySchemaElement("GSI_PK", "HASH"),+ new KeySchemaElement("GSI_SK", "RANGE")));+ table.setGlobalSecondaryIndexes(List.of(gsi));++ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:Query",+ json("""+ {"TableName":"FgacTable",+ "IndexName":"EmailGSI",+ "KeyConditionExpression":"GSI_PK = :email",+ "ExpressionAttributeValues":{":email":{"S":"[email protected]"}}}"""),+ table);++ assertEquals(List.of("[email protected]"), result.leadingKeys());+ assertTrue(result.attributes().contains("GSI_PK"), result.attributes().toString());+ }++ @Test+ void queryAgainstLsiResolvesTablePartitionKeyAsLeadingKey() {+ LocalSecondaryIndex lsi = new LocalSecondaryIndex();+ lsi.setIndexName("CreatedLSI");+ lsi.setKeySchema(List.of(+ new KeySchemaElement("PK", "HASH"),+ new KeySchemaElement("CreatedAt", "RANGE")));+ table.setLocalSecondaryIndexes(List.of(lsi));++ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:Query",+ json("""+ {"TableName":"FgacTable",+ "IndexName":"CreatedLSI",+ "KeyConditionExpression":"PK = :pk",+ "ExpressionAttributeValues":{":pk":{"S":"USER_alice"}}}"""),+ table);++ assertEquals(List.of("USER_alice"), result.leadingKeys());+ assertTrue(result.attributes().contains("PK"), result.attributes().toString());+ }++ @Test+ void updateItemExposesReadOperandsAndTargetsFromUpdateExpression() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:UpdateItem",+ json("""+ {"TableName":"FgacTable",+ "Key":{"PK":{"S":"USER_alice"},"SK":{"S":"profile"}},+ "UpdateExpression":"SET total = price + :tax, history = list_append(oldHistory, :entry), city = if_not_exists(fallbackCity, :def) REMOVE oldFlag, tags[0] ADD score :pts DELETE categories :cat",+ "ExpressionAttributeValues":{":tax":{"N":"5"},":entry":{"S":"login"},":def":{"S":"HN"},":pts":{"N":"1"},":cat":{"SS":["old"]}}}"""),+ table);++ assertEquals(List.of("USER_alice"), result.leadingKeys());+ assertTrue(result.attributes().contains("total"), result.attributes().toString());+ assertTrue(result.attributes().contains("price"), result.attributes().toString());+ assertTrue(result.attributes().contains("history"), result.attributes().toString());+ assertTrue(result.attributes().contains("oldHistory"), result.attributes().toString());+ assertTrue(result.attributes().contains("city"), result.attributes().toString());+ assertTrue(result.attributes().contains("fallbackCity"), result.attributes().toString());+ assertTrue(result.attributes().contains("oldFlag"), result.attributes().toString());+ assertTrue(result.attributes().contains("tags"), result.attributes().toString());+ assertTrue(result.attributes().contains("score"), result.attributes().toString());+ assertTrue(result.attributes().contains("categories"), result.attributes().toString());+ }++ @Test+ void updateItemDoesNotExposeNestedAttributeNamesAsTopLevelAttributes() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:UpdateItem",+ json("""+ {"TableName":"FgacTable",+ "Key":{"PK":{"S":"USER_alice"}},+ "UpdateExpression":"SET #a.subfield = :v, nested[0].detail = :d",+ "ExpressionAttributeNames":{"#a":"actualTop"},+ "ExpressionAttributeValues":{":v":{"S":"val"},":d":{"S":"detail"}}}"""),+ table);++ assertTrue(result.attributes().contains("actualTop"), result.attributes().toString());+ assertTrue(result.attributes().contains("nested"), result.attributes().toString());+ assertFalse(result.attributes().contains("subfield"), result.attributes().toString());+ assertFalse(result.attributes().contains("detail"), result.attributes().toString());+ }++ @Test+ void legacyAttributeUpdatesAndExpectedAreExposedAsAttributes() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:UpdateItem",+ json("""+ {"TableName":"FgacTable",+ "Key":{"PK":{"S":"USER_alice"}},+ "AttributeUpdates":{"status":{"Action":"PUT","Value":{"S":"active"}}},+ "Expected":{"version":{"ComparisonOperator":"EQ","AttributeValueList":[{"N":"1"}]}}}"""),+ table);++ assertTrue(result.attributes().contains("status"), result.attributes().toString());+ assertTrue(result.attributes().contains("version"), result.attributes().toString());+ }++ @Test+ void scanExposesLegacyScanFilterAttributes() {+ DynamoDbConditionKeys.Result result = DynamoDbConditionKeys.extract(+ "dynamodb:Scan",+ json("""+ {"TableName":"FgacTable",+ "ScanFilter":{"inStock":{"ComparisonOperator":"EQ","AttributeValueList":[{"BOOL":true}]}}}"""),+ table);++ assertTrue(result.attributes().contains("inStock"), result.attributes().toString());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParserTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParserTest.javanew file mode 100644index 0000000000..86b0490e97--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbKeyConditionParserTest.java@@ -0,0 +1,85 @@+package io.github.hectorvent.floci.services.dynamodb;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import org.junit.jupiter.api.Test;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNull;++class DynamoDbKeyConditionParserTest {++ private final ObjectMapper mapper = new ObjectMapper();++ private JsonNode json(String raw) {+ try {+ return mapper.readTree(raw);+ } catch (Exception e) {+ throw new IllegalStateException(e);+ }+ }++ @Test+ void resolvesSimplePartitionKeyEquality() {+ assertEquals("USER_alice", DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "pk = :v", null, json("{\":v\":{\"S\":\"USER_alice\"}}"), "pk"));+ }++ @Test+ void resolvesPartitionKeyEqualityAlongsideASortKeyCondition() {+ assertEquals("USER_alice", DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "pk = :v AND sk > :s", null,+ json("{\":v\":{\"S\":\"USER_alice\"},\":s\":{\"S\":\"2020\"}}"), "pk"));+ }++ @Test+ void resolvesAnAliasedPartitionKeyThroughExpressionAttributeNames() {+ assertEquals("USER_alice", DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "#p = :v", json("{\"#p\":\"pk\"}"),+ json("{\":v\":{\"S\":\"USER_alice\"}}"), "pk"));+ }++ @Test+ void resolvesNumericAndBinaryPartitionKeys() {+ assertEquals("42", DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "pk = :v", null, json("{\":v\":{\"N\":\"42\"}}"), "pk"));+ assertEquals("YWJj", DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "pk = :v", null, json("{\":v\":{\"B\":\"YWJj\"}}"), "pk"));+ }++ @Test+ void returnsNullWhenThePartitionKeyIsNotPinnedByEquality() {+ assertNull(DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "sk > :s", null, json("{\":s\":{\"S\":\"2020\"}}"), "pk"));+ }++ @Test+ void returnsNullForABeginsWithConditionOnThePartitionKey() {+ // begins_with is a valid sort-key condition but never an equality; treating it as+ // one would pin the leading key to a prefix and wrongly allow a whole partition range.+ assertNull(DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "begins_with(pk, :v)", null, json("{\":v\":{\"S\":\"USER_\"}}"), "pk"));+ }++ @Test+ void returnsNullWhenThePartitionKeyEqualityIsUnderAnOr() {+ // A top-level OR means the request is not constrained to a single partition value.+ assertNull(DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "pk = :a OR pk = :b", null,+ json("{\":a\":{\"S\":\"USER_alice\"},\":b\":{\"S\":\"USER_bob\"}}"), "pk"));+ }++ @Test+ void returnsNullOnUnparseableOrMissingInput() {+ assertNull(DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "pk = = :v", null, json("{\":v\":{\"S\":\"x\"}}"), "pk"));+ assertNull(DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ null, null, json("{}"), "pk"));+ assertNull(DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "pk = :v", null, null, "pk"));+ assertNull(DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "pk = :v", null, json("{\":other\":{\"S\":\"x\"}}"), "pk"));+ assertNull(DynamoDbKeyConditionParser.partitionKeyEqualityValue(+ "pk = :v", null, json("{\":v\":{\"S\":\"x\"}}"), null));+ }+}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.javanew file mode 100644index 0000000000..dd3d88d721--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbFgacEnforcementIntegrationTest.java@@ -0,0 +1,307 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.QuarkusTestProfile;+import io.quarkus.test.junit.TestProfile;+import org.junit.jupiter.api.BeforeAll;+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.equalTo;+import static org.hamcrest.Matchers.startsWith;++/**+ * End-to-end proof of the scenario in issue #2926: one session scoped by+ * ForAllValues:StringLike on dynamodb:LeadingKeys reads its own partition and is denied+ * another tenant's, through the real filter, resolver and evaluator.+ */+@QuarkusTest+@TestProfile(DynamoDbFgacEnforcementIntegrationTest.IamEnforcementProfile.class)+class DynamoDbFgacEnforcementIntegrationTest {++ private static final String DYNAMODB_CONTENT_TYPE = "application/x-amz-json-1.0";+ private static final String CALLER_ACCOUNT_ID = "111122223333";+ private static final String ROLE_ACCOUNT_ID = "222233334444";+ private static final String REGION = "us-east-1";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void leadingKeysScopedSessionReadsItsOwnPartitionAndIsDeniedAnotherTenants() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String tableName = "fgac-" + suffix;+ String roleName = "FgacRole" + suffix;++ createTable(tableName);+ putItem(tableName, "USER_alice");+ putItem(tableName, "USER_bob");+ createRole(roleName);+ putBroadDynamoDbRolePolicy(roleName);++ String accessKeyId = assumeRoleWithLeadingKeysSessionPolicy(roleName);++ // In scope: the session policy's ForAllValues:StringLike matches USER_alice*.+ given()+ .header("Authorization", auth(accessKeyId, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.GetItem")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s","Key":{"PK":{"S":"USER_alice"}}}"""+ .formatted(tableName))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Item.PK.S", equalTo("USER_alice"));++ // Out of scope: same session, same table, different partition.+ given()+ .header("Authorization", auth(accessKeyId, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.GetItem")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s","Key":{"PK":{"S":"USER_bob"}}}"""+ .formatted(tableName))+ .when()+ .post("/")+ .then()+ .statusCode(403)+ .body(containsString("AccessDeniedException"));+ }++ @Test+ void requestThatCannotProveItsLeadingKeyIsDenied() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String tableName = "fgac-noprove-" + suffix;+ String roleName = "FgacNoProveRole" + suffix;++ createTable(tableName);+ createRole(roleName);+ putBroadDynamoDbRolePolicy(roleName);++ 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.+ given()+ .header("Authorization", auth(accessKeyId, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.GetItem")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s","Key":{"SK":{"S":"profile"}}}"""+ .formatted(tableName))+ .when()+ .post("/")+ .then()+ .statusCode(403)+ .body(containsString("AccessDeniedException"));+ }++ @Test+ void leadingKeysScopedSessionQueriesGsiByItsOwnPartitionKeyAndIsDeniedAnother() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String tableName = "fgac-gsi-" + suffix;+ String roleName = "FgacGsiRole" + suffix;++ createTableWithGsi(tableName, "TenantGSI");+ putItemWithGsiKey(tableName, "item-1", "USER_alice");+ putItemWithGsiKey(tableName, "item-2", "USER_bob");+ createRole(roleName);+ putBroadDynamoDbRolePolicy(roleName);++ String accessKeyId = assumeRoleWithLeadingKeysSessionPolicy(roleName);++ // In scope: query targets GSI partition key matching USER_alice*.+ given()+ .header("Authorization", auth(accessKeyId, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.Query")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s",+ "IndexName":"TenantGSI",+ "KeyConditionExpression":"GSI_PK = :gsi",+ "ExpressionAttributeValues":{":gsi":{"S":"USER_alice"}}}"""+ .formatted(tableName))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("Count", equalTo(1))+ .body("Items[0].PK.S", equalTo("item-1"));++ // Out of scope: query targets GSI partition key of another tenant.+ given()+ .header("Authorization", auth(accessKeyId, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.Query")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s",+ "IndexName":"TenantGSI",+ "KeyConditionExpression":"GSI_PK = :gsi",+ "ExpressionAttributeValues":{":gsi":{"S":"USER_bob"}}}"""+ .formatted(tableName))+ .when()+ .post("/")+ .then()+ .statusCode(403)+ .body(containsString("AccessDeniedException"));+ }++ private static void createTable(String tableName) {+ given()+ .header("Authorization", auth(ROLE_ACCOUNT_ID, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.CreateTable")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s",+ "KeySchema":[{"AttributeName":"PK","KeyType":"HASH"}],+ "AttributeDefinitions":[{"AttributeName":"PK","AttributeType":"S"}],+ "BillingMode":"PAY_PER_REQUEST"}"""+ .formatted(tableName))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private static void putItem(String tableName, String partitionKey) {+ given()+ .header("Authorization", auth(ROLE_ACCOUNT_ID, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.PutItem")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s","Item":{"PK":{"S":"%s"},"email":{"S":"[email protected]"}}}"""+ .formatted(tableName, partitionKey))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private static void createTableWithGsi(String tableName, String indexName) {+ given()+ .header("Authorization", auth(ROLE_ACCOUNT_ID, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.CreateTable")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s",+ "KeySchema":[{"AttributeName":"PK","KeyType":"HASH"}],+ "AttributeDefinitions":[+ {"AttributeName":"PK","AttributeType":"S"},+ {"AttributeName":"GSI_PK","AttributeType":"S"}+ ],+ "GlobalSecondaryIndexes":[+ {+ "IndexName":"%s",+ "KeySchema":[{"AttributeName":"GSI_PK","KeyType":"HASH"}],+ "Projection":{"ProjectionType":"ALL"}+ }+ ],+ "BillingMode":"PAY_PER_REQUEST"}"""+ .formatted(tableName, indexName))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ private static void putItemWithGsiKey(String tableName, String partitionKey, String gsiKey) {+ given()+ .header("Authorization", auth(ROLE_ACCOUNT_ID, "dynamodb"))+ .header("X-Amz-Target", "DynamoDB_20120810.PutItem")+ .contentType(DYNAMODB_CONTENT_TYPE)+ .body("""+ {"TableName":"%s","Item":{"PK":{"S":"%s"},"GSI_PK":{"S":"%s"},"email":{"S":"[email protected]"}}}"""+ .formatted(tableName, partitionKey, gsiKey))+ .when()+ .post("/")+ .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 putBroadDynamoDbRolePolicy(String roleName) {+ given()+ .formParam("Action", "PutRolePolicy")+ .formParam("RoleName", roleName)+ .formParam("PolicyName", "AllowDynamoDb")+ .formParam("PolicyDocument", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:*","Resource":"*"}+ ]}""")+ .header("Authorization", auth(ROLE_ACCOUNT_ID, "iam"))+ .when()+ .post("/")+ .then()+ .statusCode(200);+ }++ /**+ * The session policy is the only thing that discriminates: Resource is "*", so an+ * allow or a deny can only come from the LeadingKeys condition.+ */+ private static String assumeRoleWithLeadingKeysSessionPolicy(String roleName) {+ 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*"]}}}+ ]}""")+ .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 + "/20260904/" + 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");+ }+ }+}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 a8213e3d14..3793f8ce0e 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@@ -148,7 +148,7 @@ class IamEnforcementIntegrationTest {List.of(policy),"s3:GetObject","arn:aws:s3:::bucket/key",- Map.of("AWS:SourceIP", "127.0.0.1")));+ Map.of("AWS:SourceIP", List.of("127.0.0.1"))));}// =========================================================================@@ -188,4 +188,48 @@ class IamEnforcementIntegrationTest {"arn:aws:s3:::my-bucket/*","arn:aws:s3:::other-bucket/file.txt"));}++ // =========================================================================+ // DynamoDB fine-grained access control (issue #2926)+ // =========================================================================++ private static final String LEADING_KEYS_SCOPED_POLICY = """+ {"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*"]}}}+ ]}""";++ @Test+ void leadingKeysConditionAllowsTheInScopeItemAndDeniesTheOutOfScopeOne() {+ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(LEADING_KEYS_SCOPED_POLICY), "dynamodb:GetItem",+ "arn:aws:dynamodb:us-east-1:000000000000:table/FgacTable",+ Map.of("dynamodb:LeadingKeys", List.of("USER_alice"))));++ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(LEADING_KEYS_SCOPED_POLICY), "dynamodb:GetItem",+ "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.+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(LEADING_KEYS_SCOPED_POLICY), "dynamodb:GetItem",+ "arn:aws:dynamodb:us-east-1:000000000000:table/FgacTable",+ Map.of()));+ }++ @Test+ void wildcardActionAndResourcePolicyStillAllowsRegardlessOfLeadingKeys() {+ // Control: the condition is what discriminates above, not the action or the ARN.+ String wildcard = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"*","Resource":"*"}+ ]}""";++ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(wildcard), "dynamodb:GetItem",+ "arn:aws:dynamodb:us-east-1:000000000000:table/FgacTable",+ Map.of("dynamodb:LeadingKeys", List.of("USER_bob"))));+ }}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 0f96f9d3a3..ee53cb9aa9 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@@ -1117,4 +1117,54 @@ class IamIntegrationTest {.body(containsString("ListPoliciesOmitCheckPolicy")).body(not(containsString("<Description>")));}++ @Test+ void simulatePrincipalPolicyReadsEveryContextKeyValue() {+ // A ForAnyValue: condition is satisfied only by the SECOND supplied context value,+ // so a handler that reads only ContextKeyValues.member.1 returns implicitDeny.+ given()+ .formParam("Action", "CreateUser")+ .formParam("UserName", "multi-context-user")+ .header("Authorization",+ "AWS4-HMAC-SHA256 Credential=test/20260904/us-east-1/iam/aws4_request")+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .formParam("Action", "PutUserPolicy")+ .formParam("UserName", "multi-context-user")+ .formParam("PolicyName", "AllowAliceLeadingKeys")+ .formParam("PolicyDocument", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"ForAnyValue:StringEquals":{"dynamodb:LeadingKeys":["USER_alice"]}}}+ ]}""")+ .header("Authorization",+ "AWS4-HMAC-SHA256 Credential=test/20260904/us-east-1/iam/aws4_request")+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .formParam("Action", "SimulatePrincipalPolicy")+ .formParam("PolicySourceArn", "arn:aws:iam::000000000000:user/multi-context-user")+ .formParam("ActionNames.member.1", "dynamodb:GetItem")+ .formParam("ResourceArns.member.1", "*")+ .formParam("ContextEntries.member.1.ContextKeyName", "dynamodb:LeadingKeys")+ .formParam("ContextEntries.member.1.ContextKeyValues.member.1", "USER_bob")+ .formParam("ContextEntries.member.1.ContextKeyValues.member.2", "USER_alice")+ .header("Authorization",+ "AWS4-HMAC-SHA256 Credential=test/20260904/us-east-1/iam/aws4_request")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("SimulatePrincipalPolicyResponse.SimulatePrincipalPolicyResult.EvaluationResults"+ + ".member.find { it.EvalActionName == 'dynamodb:GetItem' }.EvalDecision",+ equalTo("allowed"));+ }}+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 ec4a1e9af1..63e5ee0ece 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@@ -6,6 +6,7 @@ import io.github.hectorvent.floci.services.iam.model.CallerContext;import org.junit.jupiter.api.Test;import java.util.List;+import java.util.Map;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -101,4 +102,184 @@ class IamPolicyEvaluatorTest {assertEquals(Decision.ALLOW,evaluator.evaluate(caller, null, "s3:GetObject", "*", null));}++ @Test+ void singleValuedConditionKeyStillMatchesUnderTheMultiValuedContext() {+ // A plain (non-set) operator against a one-element list keeps today's semantics:+ // the first value is compared against the OR of the policy's condition values.+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"s3:GetObject","Resource":"*",+ "Condition":{"StringEquals":{"aws:PrincipalArn":"arn:aws:iam::111122223333:user/alice"}}}+ ]}""";++ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(policy), "s3:GetObject", "arn:aws:s3:::bucket/key",+ Map.of("aws:PrincipalArn", List.of("arn:aws:iam::111122223333:user/alice"))));+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(policy), "s3:GetObject", "arn:aws:s3:::bucket/key",+ Map.of("aws:PrincipalArn", List.of("arn:aws:iam::111122223333:user/bob"))));+ }++ private static final String LEADING_KEYS_FOR_ALL = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"ForAllValues:StringLike":{"dynamodb:LeadingKeys":["USER_alice*"]}}}+ ]}""";++ @Test+ void forAllValuesRequiresEveryContextValueToMatch() {+ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(LEADING_KEYS_FOR_ALL), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_alice"))));+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(LEADING_KEYS_FOR_ALL), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_bob"))));+ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(LEADING_KEYS_FOR_ALL), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_alice", "USER_alice_2"))));+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(LEADING_KEYS_FOR_ALL), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_alice", "USER_bob"))));+ }++ @Test+ void forAnyValueRequiresAtLeastOneContextValueToMatch() {+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"ForAnyValue:StringEquals":{"dynamodb:LeadingKeys":["USER_alice"]}}}+ ]}""";++ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_bob", "USER_alice"))));+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_bob", "USER_carol"))));+ }++ @Test+ void emptySetMatchesForAllValuesAndNotForAnyValue() {+ // AWS: ForAllValues over an empty set is vacuously true; ForAnyValue is false.+ String anyValue = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"ForAnyValue:StringLike":{"dynamodb:LeadingKeys":["USER_alice*"]}}}+ ]}""";++ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(LEADING_KEYS_FOR_ALL), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.<String>of())));+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(anyValue), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.<String>of())));+ }++ @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(+ List.of(LEADING_KEYS_FOR_ALL), "dynamodb:GetItem", "*", Map.of()));+ }++ @Test+ void setOperatorComposesWithIfExists() {+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"ForAnyValue:StringEqualsIfExists":{"dynamodb:LeadingKeys":["USER_alice"]}}}+ ]}""";++ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*", Map.of()));+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_bob"))));+ }++ @Test+ void nullGuardBlocksTheVacuousForAllValuesAllowWhenTheKeyIsAbsent() {+ // The idiomatic AWS pairing: ForAllValues plus Null:false so the vacuous+ // empty-set truth cannot grant access when the key was never populated.+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{+ "ForAllValues:StringLikeIfExists":{"dynamodb:LeadingKeys":["USER_alice*"]},+ "Null":{"dynamodb:LeadingKeys":"false"}}}+ ]}""";++ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*", Map.of()));+ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_alice"))));+ }++ @Test+ void setOperatorPrefixIsMatchedCaseSensitively() {+ // AWS spells these exactly "ForAllValues:" / "ForAnyValue:". A different spelling is+ // an unknown operator and must not silently behave like the real thing.+ String allValues = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"forallvalues:StringLike":{"dynamodb:LeadingKeys":["USER_alice*"]}}}+ ]}""";+ String anyValue = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"forAnyValue:StringLike":{"dynamodb:LeadingKeys":["USER_alice*"]}}}+ ]}""";++ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(allValues), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_alice"))));+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(anyValue), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_alice"))));+ }++ @Test+ void forAllValuesWithANegatedOperatorAndsAcrossThePolicyValues() {+ // The deny-list idiom for dynamodb:Attributes: allow only while none of the+ // attributes the request touches is one of the forbidden names. AWS ANDs the+ // negated match across the listed values; an OR would let "ssn" through as long+ // as it differed from "secret".+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{"ForAllValues:StringNotEquals":{"dynamodb:Attributes":["secret","ssn"]}}}+ ]}""";++ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*",+ Map.of("dynamodb:Attributes", List.of("name", "email"))));+ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*",+ Map.of("dynamodb:Attributes", List.of("name", "ssn"))));+ }++ @Test+ void nullTreatsAPresentButEmptySetAsAbsent() {+ // Same idiomatic pairing as the key-absent case, but here the key is present with an+ // empty set. AWS treats an empty-set key as nonexistent for Null, so the Null:false+ // guard must still block the vacuous ForAllValues allow.+ String policy = """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"dynamodb:GetItem","Resource":"*",+ "Condition":{+ "ForAllValues:StringLike":{"dynamodb:LeadingKeys":["USER_alice*"]},+ "Null":{"dynamodb:LeadingKeys":"false"}}}+ ]}""";++ assertEquals(Decision.DENY, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of())));+ assertEquals(Decision.ALLOW, evaluator.simulateCustomPolicy(+ List.of(policy), "dynamodb:GetItem", "*",+ Map.of("dynamodb:LeadingKeys", List.of("USER_alice"))));+ }}+