Skip to content

armgit / floci

Public Imported from GitHub
0

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

fix(iam): check DynamoDB transaction item permissions (#5576)

David Phillips69bbd2242b5f
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbTransactionAuthorizationTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbTransactionAuthorizationTest.java
new file mode 100644
index 0000000000..db00b0efc6
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/DynamoDbTransactionAuthorizationTest.java
@@ -0,0 +1,195 @@
+package com.floci.test;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Assumptions;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
+import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
+import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
+import software.amazon.awssdk.services.dynamodb.model.AttributeValue;
+import software.amazon.awssdk.services.dynamodb.model.BillingMode;
+import software.amazon.awssdk.services.dynamodb.model.ConditionCheck;
+import software.amazon.awssdk.services.dynamodb.model.Delete;
+import software.amazon.awssdk.services.dynamodb.model.DynamoDbException;
+import software.amazon.awssdk.services.dynamodb.model.Get;
+import software.amazon.awssdk.services.dynamodb.model.KeyType;
+import software.amazon.awssdk.services.dynamodb.model.Put;
+import software.amazon.awssdk.services.dynamodb.model.ScalarAttributeType;
+import software.amazon.awssdk.services.dynamodb.model.TransactGetItem;
+import software.amazon.awssdk.services.dynamodb.model.TransactWriteItem;
+import software.amazon.awssdk.services.dynamodb.model.Update;
+import software.amazon.awssdk.services.iam.IamClient;
+import software.amazon.awssdk.services.iam.model.AccessKey;
+
+import java.util.Map;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+@DisplayName("DynamoDB transaction item permissions with IAM enforcement")
+class DynamoDbTransactionAuthorizationTest {
+
+ private IamClient iam;
+ private DynamoDbClient admin;
+ private DynamoDbClient caller;
+ private String user;
+ private String table;
+ private String tableArn;
+ private AccessKey accessKey;
+ private boolean policyCreated;
+
+ @BeforeEach
+ void setUp() {
+ iam = TestFixtures.iamClient();
+ admin = TestFixtures.dynamoDbClient();
+ String name = TestFixtures.uniqueName("tx-auth");
+ iam.createUser(r -> r.userName(name));
+ user = name;
+ accessKey = iam.createAccessKey(r -> r.userName(user)).accessKey();
+ caller = DynamoDbClient.builder().endpointOverride(TestFixtures.endpoint()).region(TestFixtures.region())
+ .credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create(
+ accessKey.accessKeyId(), accessKey.secretAccessKey()))).build();
+ boolean enforced = false;
+ try {
+ caller.listTables();
+ } catch (DynamoDbException error) {
+ assertThat(error.awsErrorDetails().errorCode()).isEqualTo("AccessDeniedException");
+ enforced = true;
+ }
+ Assumptions.assumeTrue(enforced, "Requires floci.services.iam.enforcement-enabled=true");
+ tableArn = admin.createTable(r -> r.tableName(name).billingMode(BillingMode.PAY_PER_REQUEST)
+ .keySchema(k -> k.attributeName("PK").keyType(KeyType.HASH))
+ .attributeDefinitions(a -> a.attributeName("PK").attributeType(ScalarAttributeType.S)))
+ .tableDescription().tableArn();
+ table = name;
+ admin.putItem(r -> r.tableName(table).item(item("item", "original")));
+ }
+
+ @AfterEach
+ void cleanUp() {
+ try {
+ if (table != null) {
+ admin.deleteTable(r -> r.tableName(table));
+ }
+ } finally {
+ try {
+ if (policyCreated) {
+ iam.deleteUserPolicy(r -> r.userName(user).policyName("transaction"));
+ }
+ } finally {
+ try {
+ if (accessKey != null) {
+ iam.deleteAccessKey(r -> r.userName(user).accessKeyId(accessKey.accessKeyId()));
+ }
+ } finally {
+ try {
+ if (user != null) {
+ iam.deleteUser(r -> r.userName(user));
+ }
+ } finally {
+ if (caller != null) {
+ caller.close();
+ }
+ if (admin != null) {
+ admin.close();
+ }
+ if (iam != null) {
+ iam.close();
+ }
+ }
+ }
+ }
+ }
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Update", "Delete", "Get", "ConditionCheck"})
+ void itemPermissionAllowsTransactionButTransactionVerbDoesNot(String operation) {
+ allow("dynamodb:" + enclosing(operation), "");
+ assertThatThrownBy(() -> transaction(operation)).isInstanceOfSatisfying(DynamoDbException.class,
+ error -> assertThat(error.awsErrorDetails().errorCode()).isEqualTo("AccessDeniedException"));
+ assertThat(read().get("value").s()).isEqualTo("original");
+ allow("dynamodb:" + operation + "Item", "");
+ transaction(operation);
+ if ("Delete".equals(operation)) {
+ assertThat(read()).isEmpty();
+ } else {
+ assertThat(read().get("value").s()).isEqualTo(
+ "Put".equals(operation) || "Update".equals(operation) ? "changed" : "original");
+ }
+ }
+
+ @Test
+ void enclosingOperationAllowsTransactionAndDeniesStandaloneRead() {
+ allow("dynamodb:GetItem", ",\"Condition\":{\"ForAnyValue:StringEquals\":{"
+ + "\"dynamodb:EnclosingOperation\":[\"TransactGetItems\"]}}");
+ transaction("Get");
+ assertThatThrownBy(() -> caller.getItem(r -> r.tableName(table).key(key("item"))))
+ .isInstanceOfSatisfying(DynamoDbException.class,
+ error -> assertThat(error.awsErrorDetails().errorCode()).isEqualTo("AccessDeniedException"));
+ }
+
+ @Test
+ void laterForbiddenKeyPreventsEarlierWriteWithoutNullGuard() {
+ allow("dynamodb:PutItem", ",\"Condition\":{\"ForAllValues:StringEquals\":{"
+ + "\"dynamodb:LeadingKeys\":[\"item\"]}}");
+ assertThatThrownBy(() -> caller.transactWriteItems(r -> r.transactItems(
+ TransactWriteItem.builder().put(Put.builder().tableName(table).item(item("item", "changed")).build()).build(),
+ TransactWriteItem.builder().put(Put.builder().tableName(table).item(item("forbidden", "changed"))
+ .build()).build())))
+ .isInstanceOfSatisfying(DynamoDbException.class,
+ error -> assertThat(error.awsErrorDetails().errorCode()).isEqualTo("AccessDeniedException"));
+ assertThat(read().get("value").s()).isEqualTo("original");
+ assertThat(admin.getItem(r -> r.tableName(table).key(key("forbidden"))).item()).isEmpty();
+ }
+
+ private void transaction(String operation) {
+ if ("Get".equals(operation)) {
+ assertThat(caller.transactGetItems(r -> r.transactItems(TransactGetItem.builder()
+ .get(Get.builder().tableName(table).key(key("item")).build()).build()))
+ .responses().get(0).item().get("value").s()).isEqualTo("original");
+ return;
+ }
+ TransactWriteItem request = switch (operation) {
+ case "Put" -> TransactWriteItem.builder().put(Put.builder()
+ .tableName(table).item(item("item", "changed")).build()).build();
+ case "Update" -> TransactWriteItem.builder().update(Update.builder()
+ .tableName(table).key(key("item")).updateExpression("SET #v = :v")
+ .expressionAttributeNames(Map.of("#v", "value"))
+ .expressionAttributeValues(Map.of(":v", AttributeValue.fromS("changed"))).build()).build();
+ case "Delete" -> TransactWriteItem.builder().delete(Delete.builder()
+ .tableName(table).key(key("item")).build()).build();
+ case "ConditionCheck" -> TransactWriteItem.builder().conditionCheck(ConditionCheck.builder()
+ .tableName(table).key(key("item")).conditionExpression("attribute_exists(PK)").build()).build();
+ default -> throw new IllegalArgumentException(operation);
+ };
+ caller.transactWriteItems(r -> r.transactItems(request));
+ }
+
+ private void allow(String action, String condition) {
+ String document = "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":\""
+ + action + "\",\"Resource\":\"" + tableArn + "\"" + condition + "}]}";
+ iam.putUserPolicy(r -> r.userName(user).policyName("transaction").policyDocument(document));
+ policyCreated = true;
+ }
+
+ private Map<String, AttributeValue> read() {
+ return admin.getItem(r -> r.tableName(table).key(key("item"))).item();
+ }
+
+ private static String enclosing(String operation) {
+ return "Get".equals(operation) ? "TransactGetItems" : "TransactWriteItems";
+ }
+
+ private static Map<String, AttributeValue> key(String value) {
+ return Map.of("PK", AttributeValue.fromS(value));
+ }
+
+ private static Map<String, AttributeValue> item(String key, String value) {
+ return Map.of("PK", AttributeValue.fromS(key), "value", AttributeValue.fromS(value));
+ }
+}
diff --git a/docs/services/iam.md b/docs/services/iam.md
index 1ec51646fa..c9c59650ed 100644
--- a/docs/services/iam.md
+++ b/docs/services/iam.md
@@ -1335,8 +1335,16 @@ being bounded by SCPs (below): both forms of root enforcement now agree. A negat
absent key cannot equal what the policy names, so the condition holds, and a `Deny` written
that way applies when the key is missing.
-**Not yet supported**: `dynamodb:LeadingKeys` for `Scan`, `TransactWriteItems` / `TransactGetItems`
-and the PartiQL operations.
+Transactions check each item as `PutItem`, `UpdateItem`, `DeleteItem`, `GetItem`, or
+`ConditionCheckItem` before executing the request. Each item uses its own table, leading key
+and requested attributes. `dynamodb:EnclosingOperation` identifies `TransactWriteItems` or
+`TransactGetItems`; write items expose `ReturnValuesOnConditionCheckFailure` as
+`dynamodb:ReturnValues` only when the request supplies a non-null value. An omitted value leaves
+the condition key absent. Transaction API names alone do not grant item access.
+Transaction item authorization uses the effective local table ARN, matching execution.
+A permission on a foreign account table cannot grant access to a same-named local table.
+
+**Not yet supported**: `dynamodb:LeadingKeys` for `Scan` and the PartiQL operations.
### Assumed roles
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamConditionContextResolver.java b/src/main/java/io/github/hectorvent/floci/core/common/IamConditionContextResolver.java
index d550850410..bb347532b8 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
@@ -5,9 +5,11 @@ import com.fasterxml.jackson.databind.node.ObjectNode;
import io.github.hectorvent.floci.config.EmulatorConfig;
import io.github.hectorvent.floci.services.dynamodb.DynamoDbConditionKeys;
import io.github.hectorvent.floci.services.dynamodb.DynamoDbFacade;
+import io.github.hectorvent.floci.services.dynamodb.DynamoDbTableNames;
import io.github.hectorvent.floci.services.dynamodb.model.TableDefinition;
import io.github.hectorvent.floci.services.ec2.Ec2Service;
import io.github.hectorvent.floci.services.ec2.model.Tag;
+import io.github.hectorvent.floci.services.iam.ResourceArnBuilder;
import io.github.hectorvent.floci.services.s3.S3Service;
import jakarta.enterprise.context.ApplicationScoped;
import jakarta.enterprise.inject.Instance;
@@ -561,6 +563,61 @@ public class IamConditionContextResolver {
return conditions.isEmpty() ? null : conditions;
}
+ /** One transaction item keeps its action, table and condition keys together. */
+ record DynamoDbTransactionItem(String action, String resource, Map<String, List<String>> context) {
+ }
+
+ /**
+ * Resolves every recognized item before the handler can mutate anything. Unknown envelope fields
+ * cannot turn item checks back into a transaction-verb permission check.
+ */
+ List<DynamoDbTransactionItem> dynamoDbTransactionItems(String action, ContainerRequestContext ctx,
+ String region, String accountId) {
+ boolean read = "dynamodb:TransactGetItems".equals(action);
+ if (!read && !"dynamodb:TransactWriteItems".equals(action)) {
+ return List.of();
+ }
+ JsonNode body = bufferedJsonBody(ctx);
+ JsonNode items = body == null ? null : body.get("TransactItems");
+ if (items == null || !items.isArray()) {
+ return List.of();
+ }
+ List<DynamoDbTransactionItem> checks = new ArrayList<>();
+ List<String> operations = read ? List.of("Get") : List.of("Put", "Delete", "Update", "ConditionCheck");
+ for (JsonNode item : items) {
+ for (String operation : operations) {
+ JsonNode request = item.get(operation);
+ if (request == null || !request.isObject()) {
+ continue;
+ }
+ String tableName = targetTableName(request);
+ if (tableName == null) {
+ continue;
+ }
+ // Execution resolves ARN inputs within the request account; authorize that same table.
+ String executionTable = DynamoDbTableNames.resolveWithRegion(tableName, region).name();
+ String itemAction = "dynamodb:" + operation + "Item";
+ DynamoDbConditionKeys.Result keys = DynamoDbConditionKeys.extract(
+ itemAction, request, describeTargetTable(executionTable));
+ Map<String, List<String>> context = new LinkedHashMap<>();
+ context.put("dynamodb:EnclosingOperation", List.of(read ? "TransactGetItems" : "TransactWriteItems"));
+ if (!keys.leadingKeys().isEmpty()) {
+ context.put("dynamodb:LeadingKeys", keys.leadingKeys());
+ }
+ if (!keys.attributes().isEmpty()) {
+ context.put("dynamodb:Attributes", keys.attributes());
+ }
+ if (!read && request.hasNonNull("ReturnValuesOnConditionCheckFailure")) {
+ context.put("dynamodb:ReturnValues",
+ List.of(request.path("ReturnValuesOnConditionCheckFailure").asText()));
+ }
+ checks.add(new DynamoDbTransactionItem(itemAction,
+ ResourceArnBuilder.toDynamoDbTableArn(executionTable, region, accountId), context));
+ }
+ }
+ return checks;
+ }
+
/** Resolves each batch entry with its own schema, optionally restricted to one resource. */
Map<String, List<String>> dynamoDbBatchConditionContext(String action, ContainerRequestContext ctx,
String resourceArn) {
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java
index 3236f70381..4d5df6fec0 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
@@ -464,17 +464,33 @@ public class IamEnforcementFilter implements ContainerRequestFilter {
if (callerArns.isPresent()) {
caller = caller.withPrincipalArn(callerArns.get().callerArn());
conditionContext = conditionContext == null ? new HashMap<>() : new HashMap<>(conditionContext);
- conditionContext.put("aws:PrincipalArn", List.of(callerArns.get().principalArn()));
+ putPrincipalKeys(conditionContext, callerArns.get());
}
List<Map<String, List<String>>> targetContexts = new ArrayList<>();
targetContexts.add(conditionContext);
for (Map<String, List<String>> target : remainingTargets) {
Map<String, List<String>> targetContext = new HashMap<>(target);
- callerArns.ifPresent(arns -> targetContext.put("aws:PrincipalArn", List.of(arns.principalArn())));
+ callerArns.ifPresent(arns -> putPrincipalKeys(targetContext, arns));
targetContexts.add(targetContext);
}
RequestPrincipal principal = RequestPrincipal.caller(callerArns.orElse(null));
+ List<IamConditionContextResolver.DynamoDbTransactionItem> transactionItems =
+ "dynamodb".equals(credentialScope)
+ ? conditionContextResolver.dynamoDbTransactionItems(action, ctx, region, accountId)
+ : List.of();
+ if (!transactionItems.isEmpty()) {
+ for (IamConditionContextResolver.DynamoDbTransactionItem item : transactionItems) {
+ Map<String, List<String>> itemContext = new HashMap<>(item.context());
+ callerArns.ifPresent(arns -> putPrincipalKeys(itemContext, arns));
+ if (abortIfDenied(ctx, caller, principal, item.action(), credentialScope,
+ resolveResourceArns(credentialScope, List.of(item.resource())), List.of(itemContext),
+ region, accountId, akid)) {
+ return;
+ }
+ }
+ return;
+ }
if (abortIfDenied(ctx, caller, principal, action, credentialScope, resources, targetContexts,
region, accountId, akid)) {
return;
@@ -653,6 +669,10 @@ public class IamEnforcementFilter implements ContainerRequestFilter {
private record ResolvedAuthorization(String credentialScope, String action) {
}
+ private static void putPrincipalKeys(Map<String, List<String>> context, CallerArns arns) {
+ context.put("aws:PrincipalArn", List.of(arns.principalArn()));
+ }
+
/** Floci's account-root principal, which is both the caller and the request's aws:PrincipalArn. */
private CallerArns accountRootArns(String accountId) {
String rootArn = AwsArnUtils.Arn.global(requestPartition(), "iam", accountId, "root").toString();
@@ -918,7 +938,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {
if (callerArns.isPresent()) {
caller = caller.withPrincipalArn(callerArns.get().callerArn());
conditionContext = new HashMap<>();
- conditionContext.put("aws:PrincipalArn", List.of(callerArns.get().principalArn()));
+ putPrincipalKeys(conditionContext, callerArns.get());
}
ResourcePolicyDecision effectiveDecision = resourcePolicyDecision;
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.java
index 26ed67da82..01af5e36c9 100644
--- a/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeys.java
+++ b/src/main/java/io/github/hectorvent/floci/services/dynamodb/DynamoDbConditionKeys.java
@@ -49,7 +49,8 @@ public final class DynamoDbConditionKeys {
Set<String> attributes = new LinkedHashSet<>();
switch (action == null ? "" : action) {
- case "dynamodb:GetItem", "dynamodb:DeleteItem", "dynamodb:UpdateItem" -> {
+ case "dynamodb:GetItem", "dynamodb:DeleteItem", "dynamodb:UpdateItem",
+ "dynamodb:ConditionCheckItem" -> {
JsonNode key = body.get("Key");
addAttributeNames(attributes, key);
addLeadingKey(leadingKeys, key, pkName);
diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java b/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java
index c408850bdd..b391a485ff 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java
@@ -828,7 +828,7 @@ public class ResourceArnBuilder {
return io.github.hectorvent.floci.services.dynamodb.DynamoDbPartiQLParser.extractTable(statement);
}
- private String toDynamoDbTableArn(String tableName, String region, String accountId) {
+ public static String toDynamoDbTableArn(String tableName, String region, String accountId) {
if (AwsArnUtils.isArnFor(tableName, "dynamodb")) {
return tableName;
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbTransactionAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbTransactionAuthorizationIntegrationTest.java
new file mode 100644
index 0000000000..c37f9d4cab
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbTransactionAuthorizationIntegrationTest.java
@@ -0,0 +1,345 @@
+package io.github.hectorvent.floci.services.iam;
+
+import io.github.hectorvent.floci.testing.IamEnforcementProfile;
+import io.github.hectorvent.floci.testing.PartitionCleanup;
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.common.http.TestHTTPResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.TestProfile;
+import io.restassured.response.ValidatableResponse;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.net.URI;
+import java.util.UUID;
+
+import static io.github.hectorvent.floci.testing.EnforcementFixtures.auth;
+import static io.github.hectorvent.floci.testing.EnforcementFixtures.createUser;
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+
+@QuarkusTest
+@TestProfile(IamEnforcementProfile.class)
+class DynamoDbTransactionAuthorizationIntegrationTest {
+
+ @RegisterExtension
+ final PartitionCleanup cleanup = new PartitionCleanup();
+
+ @TestHTTPResource
+ URI endpoint;
+
+ @BeforeAll
+ static void configureContentType() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Update", "Delete", "Get", "ConditionCheck"})
+ void itemPermissionAloneAllowsItsTransactionalOperation(String operation) {
+ String table = table();
+ String user = user(policy("dynamodb:" + operation + "Item", ""));
+ transaction(user, operation, table).statusCode(200);
+ assertResult(operation, table);
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Update", "Delete", "Get", "ConditionCheck"})
+ void broadPermissionControlExecutesTheSameTransaction(String operation) {
+ String table = table();
+ transaction(user(policy("dynamodb:*", "")), operation, table).statusCode(200);
+ assertResult(operation, table);
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Update", "Delete", "Get", "ConditionCheck"})
+ void transactionVerbAloneDoesNotGrantItemPermission(String operation) {
+ String table = table();
+ String user = user(policy("dynamodb:" + enclosing(operation), ""));
+ transaction(user, operation, table).statusCode(400).body(containsString("AccessDeniedException"));
+ request("test", "GetItem", keyBody(table)).statusCode(200).body("Item.value.S", equalTo("original"));
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Get"})
+ void enclosingOperationConditionAllowsTransactionsButNotStandaloneCalls(String operation) {
+ String table = table();
+ String condition = ",\"Condition\":{\"ForAnyValue:StringEquals\":{"
+ + "\"dynamodb:EnclosingOperation\":[\"" + enclosing(operation) + "\"]}}";
+ String user = user(policy("dynamodb:" + operation + "Item", condition));
+ transaction(user, operation, table).statusCode(200);
+ request(user, operation + "Item", itemBody(operation, table)).statusCode(400)
+ .body(containsString("AccessDeniedException"));
+ }
+
+ @Test
+ void deniedLaterItemPreventsAllWrites() {
+ String first = table();
+ String second = table();
+ String user = user("""
+ {"Version":"2012-10-17","Statement":[
+ {"Effect":"Allow","Action":"dynamodb:*","Resource":"*"},
+ {"Effect":"Deny","Action":"dynamodb:DeleteItem","Resource":"*"}]}
+ """);
+ request(user, "TransactWriteItems", "{\"TransactItems\":[{\"Put\":" + itemBody("Put", first)
+ + "},{\"Delete\":" + itemBody("Delete", second) + "}]}")
+ .statusCode(400).body(containsString("AccessDeniedException"));
+ request("test", "GetItem", keyBody(first)).statusCode(200).body("Item.value.S", equalTo("original"));
+ request("test", "GetItem", keyBody(second)).statusCode(200).body("Item.value.S", equalTo("original"));
+ }
+
+ @Test
+ void eachTransactionalItemContributesItsLeadingKeyWithoutNullGuard() {
+ String table = table();
+ String user = user(policy("dynamodb:*", ",\"Condition\":{\"ForAllValues:StringEquals\":{"
+ + "\"dynamodb:LeadingKeys\":[\"allowed\"]}}"));
+ transaction(user, "Put", table).statusCode(400).body(containsString("AccessDeniedException"));
+ request("test", "GetItem", keyBody(table)).statusCode(200).body("Item.value.S", equalTo("original"));
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Update", "Delete", "Get", "ConditionCheck"})
+ void extraEnvelopeFieldCannotBypassItemAuthorization(String operation) {
+ String table = table();
+ String user = user(policy("dynamodb:" + enclosing(operation), ""));
+ request(user, enclosing(operation), "{\"TransactItems\":[{\"Ignored\":true,\"" + operation
+ + "\":" + itemBody(operation, table) + "}]}")
+ .statusCode(400).body(containsString("AccessDeniedException"));
+ request("test", "GetItem", keyBody(table)).statusCode(200).body("Item.value.S", equalTo("original"));
+ }
+
+ @Test
+ void eachItemUsesItsOwnActionAndTablePolicy() {
+ String first = table();
+ String second = table();
+ String policy = """
+ {"Version":"2012-10-17","Statement":[
+ {"Effect":"Allow","Action":"dynamodb:PutItem",
+ "Resource":"arn:aws:dynamodb:us-east-1:000000000000:table/%s"},
+ {"Effect":"Allow","Action":"dynamodb:DeleteItem",
+ "Resource":"arn:aws:dynamodb:us-east-1:000000000000:table/%s"}]}
+ """.formatted(first, second);
+ String user = user(policy);
+ request(user, "TransactWriteItems", "{\"TransactItems\":[{\"Put\":" + itemBody("Put", first)
+ + "},{\"Delete\":" + itemBody("Delete", second) + "}]}").statusCode(200);
+ assertResult("Put", first);
+ assertResult("Delete", second);
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Update", "Delete", "ConditionCheck"})
+ void transactionFailureImagesRequireTheRequestedReturnValues(String operation) {
+ String table = table();
+ String user = user(policy("dynamodb:" + operation + "Item",
+ ",\"Condition\":{\"StringEqualsIfExists\":{\"dynamodb:ReturnValues\":\"NONE\"}}"));
+ String item = itemBody(operation, table);
+ String disallowed = item.substring(0, item.length() - 1)
+ + ",\"ReturnValuesOnConditionCheckFailure\":\"ALL_OLD\"}";
+ request(user, enclosing(operation), "{\"TransactItems\":[{\"" + operation + "\":" + disallowed + "}]}")
+ .statusCode(400).body(containsString("AccessDeniedException"));
+ request("test", "GetItem", keyBody(table)).statusCode(200).body("Item.value.S", equalTo("original"));
+ transaction(user, operation, table).statusCode(200);
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Update", "Delete", "ConditionCheck"})
+ void strictReturnValuesConditionRequiresAnExplicitValue(String operation) {
+ String table = table();
+ String user = user(policy("dynamodb:" + operation + "Item",
+ ",\"Condition\":{\"StringEquals\":{\"dynamodb:ReturnValues\":\"NONE\"}}"));
+ transaction(user, operation, table).statusCode(400).body(containsString("AccessDeniedException"));
+ for (String value : new String[]{"null", "\"\"", "\"ALL_OLD\""}) {
+ request(user, enclosing(operation), transactionWithReturnValues(operation, table, value))
+ .statusCode(400).body(containsString("AccessDeniedException"));
+ }
+ request("test", "GetItem", keyBody(table)).statusCode(200).body("Item.value.S", equalTo("original"));
+ request(user, enclosing(operation), transactionWithReturnValues(operation, table, "\"NONE\""))
+ .statusCode(200);
+ assertResult(operation, table);
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Update", "Delete", "ConditionCheck"})
+ void nullReturnValuesConditionDistinguishesMissingFromExplicitNone(String operation) {
+ String table = table();
+ String user = user(policy("dynamodb:" + operation + "Item",
+ ",\"Condition\":{\"Null\":{\"dynamodb:ReturnValues\":\"true\"}}"));
+ request(user, enclosing(operation), transactionWithReturnValues(operation, table, "\"NONE\""))
+ .statusCode(400).body(containsString("AccessDeniedException"));
+ request("test", "GetItem", keyBody(table)).statusCode(200).body("Item.value.S", equalTo("original"));
+ transaction(user, operation, table).statusCode(200);
+ assertResult(operation, table);
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Put", "Update", "Delete", "ConditionCheck"})
+ void explicitFailureImageValueCanBeAuthorized(String operation) {
+ String table = table();
+ String user = user(policy("dynamodb:" + operation + "Item",
+ ",\"Condition\":{\"StringEquals\":{\"dynamodb:ReturnValues\":\"ALL_OLD\"}}"));
+ request(user, enclosing(operation), transactionWithReturnValues(operation, table, "\"ALL_OLD\""))
+ .statusCode(200);
+ assertResult(operation, table);
+ }
+
+ @Test
+ void explicitReturnValuesOnOneItemCannotAuthorizeAnotherItem() {
+ String first = table();
+ String second = table();
+ String user = user(policy("dynamodb:PutItem",
+ ",\"Condition\":{\"StringEquals\":{\"dynamodb:ReturnValues\":\"NONE\"}}"));
+ String firstItem = itemBody("Put", first);
+ firstItem = firstItem.substring(0, firstItem.length() - 1)
+ + ",\"ReturnValuesOnConditionCheckFailure\":\"NONE\"}";
+ request(user, "TransactWriteItems", "{\"TransactItems\":[{\"Put\":" + firstItem
+ + "},{\"Put\":" + itemBody("Put", second) + "}]}")
+ .statusCode(400).body(containsString("AccessDeniedException"));
+ request("test", "GetItem", keyBody(first)).statusCode(200).body("Item.value.S", equalTo("original"));
+ request("test", "GetItem", keyBody(second)).statusCode(200).body("Item.value.S", equalTo("original"));
+ }
+
+ private static String transactionWithReturnValues(String operation, String table, String value) {
+ String item = itemBody(operation, table);
+ item = item.substring(0, item.length() - 1) + ",\"ReturnValuesOnConditionCheckFailure\":" + value + "}";
+ return "{\"TransactItems\":[{\"" + operation + "\":" + item + "}]}";
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"Get", "Update", "ConditionCheck"})
+ void itemAttributesAreEnforcedWithoutNullGuard(String operation) {
+ String table = table();
+ String item = itemBody(operation, table);
+ if ("Get".equals(operation)) {
+ item = item.substring(0, item.length() - 1)
+ + ",\"ProjectionExpression\":\"#v\",\"ExpressionAttributeNames\":{\"#v\":\"value\"}}";
+ } else if ("ConditionCheck".equals(operation)) {
+ item = keyBody(table);
+ item = item.substring(0, item.length() - 1)
+ + ",\"ConditionExpression\":\"attribute_exists(#v)\","
+ + "\"ExpressionAttributeNames\":{\"#v\":\"value\"}}";
+ }
+ String request = "{\"TransactItems\":[{\"" + operation + "\":" + item + "}]}";
+ String denied = user(policy("dynamodb:" + operation + "Item",
+ ",\"Condition\":{\"ForAllValues:StringEquals\":{\"dynamodb:Attributes\":[\"PK\"]}}"));
+ request(denied, enclosing(operation), request).statusCode(400)
+ .body(containsString("AccessDeniedException"));
+ request("test", "GetItem", keyBody(table)).statusCode(200).body("Item.value.S", equalTo("original"));
+ String allowed = user(policy("dynamodb:" + operation + "Item",
+ ",\"Condition\":{\"ForAllValues:StringEquals\":{\"dynamodb:Attributes\":[\"PK\",\"value\"]}}"));
+ ValidatableResponse response = request(allowed, enclosing(operation), request).statusCode(200);
+ if ("Get".equals(operation)) {
+ response.body("Responses[0].Item.value.S", equalTo("original"));
+ }
+ assertResult(operation, table);
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void eachTableUsesItsOwnPartitionKeySchema(boolean forbiddenLaterKey) {
+ String first = table();
+ String second = table("tenant");
+ String secondItem = itemBody("Put", second).replace("\"PK\"", "\"tenant\"");
+ if (forbiddenLaterKey) {
+ secondItem = secondItem.replace("\"item\"", "\"forbidden\"");
+ }
+ String caller = user(policy("dynamodb:PutItem", ",\"Condition\":{\"ForAllValues:StringEquals\":{"
+ + "\"dynamodb:LeadingKeys\":[\"item\"]}}"));
+ ValidatableResponse response = request(caller, "TransactWriteItems", "{\"TransactItems\":[{\"Put\":"
+ + itemBody("Put", first) + "},{\"Put\":" + secondItem + "}]}");
+ if (forbiddenLaterKey) {
+ response.statusCode(400).body(containsString("AccessDeniedException"));
+ request("test", "GetItem", keyBody(second).replace("\"PK\"", "\"tenant\"")
+ .replace("\"item\"", "\"forbidden\"")).statusCode(200).body(equalTo("{}"));
+ } else {
+ response.statusCode(200);
+ }
+ String expected = forbiddenLaterKey ? "original" : "changed";
+ request("test", "GetItem", keyBody(first)).statusCode(200).body("Item.value.S", equalTo(expected));
+ request("test", "GetItem", keyBody(second).replace("\"PK\"", "\"tenant\""))
+ .statusCode(200).body("Item.value.S", equalTo(expected));
+ }
+
+ private void assertResult(String operation, String table) {
+ ValidatableResponse response = request("test", "GetItem", keyBody(table)).statusCode(200);
+ if ("Delete".equals(operation)) {
+ response.body(equalTo("{}"));
+ } else {
+ response.body("Item.value.S", equalTo("Put".equals(operation) || "Update".equals(operation)
+ ? "changed" : "original"));
+ }
+ }
+
+ private ValidatableResponse transaction(String user, String operation, String table) {
+ return request(user, enclosing(operation), "{\"TransactItems\":[{\"" + operation + "\":"
+ + itemBody(operation, table) + "}]}");
+ }
+
+ private static String enclosing(String operation) {
+ return "Get".equals(operation) ? "TransactGetItems" : "TransactWriteItems";
+ }
+
+ private static String itemBody(String operation, String table) {
+ if ("Put".equals(operation)) {
+ return "{\"TableName\":\"" + table + "\",\"Item\":{\"PK\":{\"S\":\"item\"},"
+ + "\"value\":{\"S\":\"changed\"}}}";
+ }
+ String base = keyBody(table);
+ if ("Update".equals(operation)) {
+ return base.substring(0, base.length() - 1) + ",\"UpdateExpression\":\"SET #v = :v\","
+ + "\"ExpressionAttributeNames\":{\"#v\":\"value\"},"
+ + "\"ExpressionAttributeValues\":{\":v\":{\"S\":\"changed\"}}}";
+ }
+ if ("ConditionCheck".equals(operation)) {
+ return base.substring(0, base.length() - 1) + ",\"ConditionExpression\":\"attribute_exists(PK)\"}";
+ }
+ return base;
+ }
+
+ private static String keyBody(String table) {
+ return "{\"TableName\":\"" + table + "\",\"Key\":{\"PK\":{\"S\":\"item\"}}}";
+ }
+
+ private String table() {
+ return table("PK");
+ }
+
+ private String table(String partitionKey) {
+ String table = "tx-auth-" + UUID.randomUUID();
+ int port = endpoint.getPort();
+ cleanup.register(() -> given().port(port).header("Authorization", auth("test", "dynamodb"))
+ .header("X-Amz-Target", "DynamoDB_20120810.DeleteTable")
+ .contentType("application/x-amz-json-1.0").body("{\"TableName\":\"" + table + "\"}")
+ .post("/").then().statusCode(200));
+ request("test", "CreateTable", """
+ {"TableName":"%s","KeySchema":[{"AttributeName":"%s","KeyType":"HASH"}],
+ "AttributeDefinitions":[{"AttributeName":"%s","AttributeType":"S"}],
+ "BillingMode":"PAY_PER_REQUEST"}
+ """.formatted(table, partitionKey, partitionKey)).statusCode(200);
+ request("test", "PutItem", itemBody("Put", table).replace("changed", "original")
+ .replace("\"PK\"", "\"" + partitionKey + "\"")).statusCode(200);
+ return table;
+ }
+
+ private String user(String policy) {
+ String name = "tx-auth-" + UUID.randomUUID();
+ String key = createUser(cleanup, endpoint.getPort(), auth("test", "iam"), name).accessKeyId();
+ given().header("Authorization", auth("test", "iam")).formParam("Action", "PutUserPolicy")
+ .formParam("UserName", name).formParam("PolicyName", "transaction")
+ .formParam("PolicyDocument", policy).post("/").then().statusCode(200);
+ return key;
+ }
+
+ private static String policy(String action, String condition) {
+ return "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":\""
+ + action + "\",\"Resource\":\"*\"" + condition + "}]}";
+ }
+
+ private ValidatableResponse request(String key, String action, String body) {
+ return given().header("Authorization", auth(key, "dynamodb"))
+ .header("X-Amz-Target", "DynamoDB_20120810." + action)
+ .contentType("application/x-amz-json-1.0").body(body).post("/").then();
+ }
+}
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbTransactionPolicyBoundaryIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbTransactionPolicyBoundaryIntegrationTest.java
new file mode 100644
index 0000000000..0012296a70
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/DynamoDbTransactionPolicyBoundaryIntegrationTest.java
@@ -0,0 +1,268 @@
+package io.github.hectorvent.floci.services.iam;
+
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.github.hectorvent.floci.testing.PartitionCleanup;
+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
+import io.quarkus.test.common.http.TestHTTPResource;
+import io.quarkus.test.junit.QuarkusTest;
+import io.quarkus.test.junit.TestProfile;
+import io.restassured.response.ValidatableResponse;
+import jakarta.inject.Inject;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.net.URI;
+import java.util.List;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ThreadLocalRandom;
+
+import static io.github.hectorvent.floci.testing.EnforcementFixtures.auth;
+import static io.github.hectorvent.floci.testing.EnforcementFixtures.createUser;
+import static io.github.hectorvent.floci.testing.EnforcementFixtures.removeRole;
+import static io.restassured.RestAssured.given;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.equalTo;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+@QuarkusTest
+@TestProfile(ScpEnforcementLeaveOrganizationIntegrationTest.ScpEnforcementProfile.class)
+class DynamoDbTransactionPolicyBoundaryIntegrationTest {
+
+ @RegisterExtension
+ final PartitionCleanup cleanup = new PartitionCleanup();
+
+ @TestHTTPResource
+ URI endpoint;
+
+ @Inject
+ ObjectMapper mapper;
+
+ @BeforeAll
+ static void configureContentType() {
+ RestAssuredJsonUtils.configureAwsContentTypes();
+ }
+
+ @ParameterizedTest
+ @CsvSource({"us-east-1,false", "us-east-1,true", "cn-north-1,false", "cn-north-1,true"})
+ void itemResourcesAndGlobalContextUseCallerAccountAndRegion(String region, boolean useArn) {
+ String name = "tx-boundary-" + UUID.randomUUID();
+ Table first = table("717171717171", region, name);
+ Table otherAccount = table("727272727272", region, name);
+ Table otherRegion = table(first.account(), "us-west-2", name);
+ String conditions = ",\"Condition\":{\"StringEquals\":{\"aws:PrincipalAccount\":\""
+ + first.account() + "\",\"aws:ResourceAccount\":\"" + first.account()
+ + "\",\"aws:RequestedRegion\":\"" + region + "\"}}";
+ String caller = user(first.account(), policy("dynamodb:PutItem", first.arn(), conditions));
+ transact(caller, first.region(), put(first, "item", useArn)).statusCode(200);
+ read(first, "item").body("Item.value.S", equalTo("changed"));
+ read(otherAccount, "item").body("Item.value.S", equalTo("original"));
+ read(otherRegion, "item").body("Item.value.S", equalTo("original"));
+ transact(caller, otherRegion.region(), put(otherRegion, "item", useArn)).statusCode(400)
+ .body(containsString("AccessDeniedException"));
+ String otherCaller = user(otherAccount.account(), policy("dynamodb:PutItem", first.arn(), conditions));
+ transact(otherCaller, otherAccount.region(), put(otherAccount, "item", useArn)).statusCode(400)
+ .body(containsString("AccessDeniedException"));
+ read(otherAccount, "item").body("Item.value.S", equalTo("original"));
+ read(otherRegion, "item").body("Item.value.S", equalTo("original"));
+ }
+
+ @ParameterizedTest
+ @CsvSource({"Put,us-east-1", "Update,us-east-1", "Delete,us-east-1", "ConditionCheck,us-east-1",
+ "Get,us-east-1", "Put,cn-north-1", "Update,cn-north-1", "Delete,cn-north-1",
+ "ConditionCheck,cn-north-1", "Get,cn-north-1"})
+ void foreignArnPermissionCannotAuthorizeTheLocalExecutionTarget(String operation, String region) {
+ String name = "tx-foreign-" + UUID.randomUUID();
+ Table local = table("757575757575", region, name);
+ Table foreign = table("767676767676", region, name);
+ Table earlier = table(local.account(), region, name + "-earlier");
+ String document = """
+ {"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"dynamodb:*",
+ "Resource":["%s","%s"]}]}
+ """.formatted(earlier.arn(), foreign.arn());
+ String caller = user(local.account(), document);
+ Map<String, Object> key = Map.of("PK", Map.of("S", "item"));
+ Map<String, Object> request = switch (operation) {
+ case "Put" -> Map.of("TableName", foreign.arn(), "Item", item("item", "changed"));
+ case "Update" -> Map.of("TableName", foreign.arn(), "Key", key,
+ "UpdateExpression", "SET #v = :v", "ExpressionAttributeNames", Map.of("#v", "value"),
+ "ExpressionAttributeValues", Map.of(":v", Map.of("S", "changed")));
+ case "ConditionCheck" -> Map.of("TableName", foreign.arn(), "Key", key,
+ "ConditionExpression", "attribute_exists(PK)");
+ default -> Map.of("TableName", foreign.arn(), "Key", key);
+ };
+ ValidatableResponse response = operation.equals("Get")
+ ? json(caller, region, "dynamodb", "DynamoDB_20120810.TransactGetItems",
+ encode(Map.of("TransactItems", List.of(Map.of(operation, request)))))
+ : transact(caller, region, put(earlier, "item", true), Map.of(operation, request));
+ assertAll(
+ () -> response.statusCode(400).body(containsString("AccessDeniedException")),
+ () -> read(earlier, "item").body("Item.value.S", equalTo("original")),
+ () -> read(local, "item").body("Item.value.S", equalTo("original")),
+ () -> read(foreign, "item").body("Item.value.S", equalTo("original")));
+ }
+
+ @Test
+ void sessionPolicyRestrictsEachItemAndPreservesRolePrincipalContext() {
+ Table table = table("737373737373", "us-east-1", "tx-session-" + UUID.randomUUID());
+ String role = "tx-role-" + UUID.randomUUID();
+ int port = endpoint.getPort();
+ cleanup.register(() -> removeRole(port, auth(table.account(), "iam"), role));
+ String roleArn = given().port(port).header("Authorization", auth(table.account(), "iam"))
+ .formParam("Action", "CreateRole").formParam("RoleName", role)
+ .formParam("AssumeRolePolicyDocument", """
+ {"Version":"2012-10-17","Statement":[{"Effect":"Allow",
+ "Principal":{"AWS":"*"},"Action":"sts:AssumeRole"}]}
+ """).post("/").then().statusCode(200).extract()
+ .path("CreateRoleResponse.CreateRoleResult.Role.Arn");
+ given().port(port).header("Authorization", auth(table.account(), "iam"))
+ .formParam("Action", "PutRolePolicy").formParam("RoleName", role)
+ .formParam("PolicyName", "transaction")
+ .formParam("PolicyDocument", policy("dynamodb:PutItem", table.arn(),
+ ",\"Condition\":{\"ArnEquals\":{\"aws:PrincipalArn\":\"" + roleArn + "\"}}"))
+ .post("/").then().statusCode(200);
+ String sessionPolicy = """
+ {"Version":"2012-10-17","Statement":[
+ {"Effect":"Allow","Action":"dynamodb:PutItem","Resource":"%s"},
+ {"Effect":"Deny","Action":"dynamodb:PutItem","Resource":"%s",
+ "Condition":{"ForAnyValue:StringEquals":{"dynamodb:LeadingKeys":["forbidden"]}}}]}
+ """.formatted(table.arn(), table.arn());
+ String session = given().port(port).header("Authorization", auth(table.account(), "sts"))
+ .formParam("Action", "AssumeRole").formParam("RoleArn", roleArn)
+ .formParam("RoleSessionName", "transaction").formParam("Policy", sessionPolicy)
+ .post("/").then().statusCode(200).extract()
+ .path("AssumeRoleResponse.AssumeRoleResult.Credentials.AccessKeyId");
+ transact(session, table.region(), put(table, "item", false), put(table, "forbidden", true))
+ .statusCode(400).body(containsString("AccessDeniedException"));
+ read(table, "item").body("Item.value.S", equalTo("original"));
+ read(table, "forbidden").body(equalTo("{}"));
+ transact(session, table.region(), put(table, "item", true)).statusCode(200);
+ read(table, "item").body("Item.value.S", equalTo("changed"));
+ }
+
+ @ParameterizedTest
+ @ValueSource(booleans = {false, true})
+ void scpDeniesUnderlyingItemActionForMemberRootAndUser(boolean rootCaller) {
+ String management = Long.toString(ThreadLocalRandom.current().nextLong(800000000000L, 899999999999L));
+ org(management, "CreateOrganization", Map.of("FeatureSet", "ALL")).statusCode(200);
+ cleanup.register(() -> org(management, "DeleteOrganization", Map.of()).statusCode(200));
+ String root = org(management, "ListRoots", Map.of()).statusCode(200).extract().path("Roots[0].Id");
+ org(management, "EnablePolicyType", Map.of("RootId", root, "PolicyType", "SERVICE_CONTROL_POLICY"))
+ .statusCode(200);
+ String member = org(management, "CreateAccount", Map.of("AccountName", "tx-member",
+ "Email", UUID.randomUUID() + "@example.com")).statusCode(200).extract()
+ .path("CreateAccountStatus.AccountId");
+ cleanup.register(() -> org(management, "RemoveAccountFromOrganization", Map.of("AccountId", member))
+ .statusCode(200));
+ Table table = table(member, "us-east-1", "tx-scp-" + UUID.randomUUID());
+ String caller = rootCaller ? member : user(member, policy("dynamodb:*", table.arn(), ""));
+ String content = """
+ {"Version":"2012-10-17","Statement":[{"Effect":"Deny",
+ "Action":"dynamodb:PutItem","Resource":"%s"}]}
+ """.formatted(table.arn());
+ String policyId = org(management, "CreatePolicy", Map.of("Name", "deny-item",
+ "Type", "SERVICE_CONTROL_POLICY", "Description", "Deny transaction writes", "Content", content))
+ .statusCode(200).extract().path("Policy.PolicySummary.Id");
+ cleanup.register(() -> org(management, "DeletePolicy", Map.of("PolicyId", policyId)).statusCode(200));
+ org(management, "AttachPolicy", Map.of("PolicyId", policyId, "TargetId", member)).statusCode(200);
+ cleanup.register(() -> org(management, "DetachPolicy", Map.of("PolicyId", policyId, "TargetId", member))
+ .statusCode(200));
+ transact(caller, table.region(), put(table, "item", true)).statusCode(400)
+ .body(containsString("AccessDeniedException"));
+ read(table, "item").body("Item.value.S", equalTo("original"));
+ org(management, "DetachPolicy", Map.of("PolicyId", policyId, "TargetId", member)).statusCode(200);
+ transact(caller, table.region(), put(table, "item", true)).statusCode(200);
+ read(table, "item").body("Item.value.S", equalTo("changed"));
+ org(management, "AttachPolicy", Map.of("PolicyId", policyId, "TargetId", member)).statusCode(200);
+ }
+
+ @ParameterizedTest
+ @CsvSource(value = {"{}|ValidationException", "{\"TransactItems\":[]}|ValidationException",
+ "{\"TransactItems\":null}|ValidationException", "{\"TransactItems\":{}}|SerializationException"},
+ delimiter = '|')
+ void absentRecognizedItemsStillReachRequestShapeChecks(String body, String error) {
+ Table table = table("747474747474", "us-east-1", "tx-shape-" + UUID.randomUUID());
+ String caller = user(table.account(), policy("dynamodb:TransactWriteItems", "*", ""));
+ json(caller, table.region(), "dynamodb", "DynamoDB_20120810.TransactWriteItems", body)
+ .statusCode(400).body(containsString(error));
+ read(table, "item").body("Item.value.S", equalTo("original"));
+ }
+
+ private Table table(String account, String region, String name) {
+ String arn = json(account, region, "dynamodb", "DynamoDB_20120810.CreateTable", encode(Map.of(
+ "TableName", name, "BillingMode", "PAY_PER_REQUEST",
+ "KeySchema", List.of(Map.of("AttributeName", "PK", "KeyType", "HASH")),
+ "AttributeDefinitions", List.of(Map.of("AttributeName", "PK", "AttributeType", "S")))))
+ .statusCode(200).extract().path("TableDescription.TableArn");
+ Table table = new Table(account, region, name, arn);
+ cleanup.register(() -> json(account, region, "dynamodb", "DynamoDB_20120810.DeleteTable",
+ encode(Map.of("TableName", name))).statusCode(200));
+ json(account, region, "dynamodb", "DynamoDB_20120810.PutItem",
+ encode(Map.of("TableName", name, "Item", item("item", "original")))).statusCode(200);
+ return table;
+ }
+
+ private String user(String account, String policy) {
+ String name = "tx-boundary-" + UUID.randomUUID();
+ String key = createUser(cleanup, endpoint.getPort(), auth(account, "iam"), name).accessKeyId();
+ given().port(endpoint.getPort()).header("Authorization", auth(account, "iam"))
+ .formParam("Action", "PutUserPolicy").formParam("UserName", name)
+ .formParam("PolicyName", "transaction").formParam("PolicyDocument", policy)
+ .post("/").then().statusCode(200);
+ return key;
+ }
+
+ @SafeVarargs
+ private final ValidatableResponse transact(String key, String region, Map<String, Object>... items) {
+ return json(key, region, "dynamodb", "DynamoDB_20120810.TransactWriteItems",
+ encode(Map.of("TransactItems", List.of(items))));
+ }
+
+ private ValidatableResponse read(Table table, String key) {
+ return json(table.account(), table.region(), "dynamodb", "DynamoDB_20120810.GetItem",
+ encode(Map.of("TableName", table.name(), "Key", Map.of("PK", Map.of("S", key)))))
+ .statusCode(200);
+ }
+
+ private static Map<String, Object> put(Table table, String key, boolean useArn) {
+ return Map.of("Put", Map.of("TableName", useArn ? table.arn() : table.name(),
+ "Item", item(key, "changed")));
+ }
+
+ private static Map<String, Object> item(String key, String value) {
+ return Map.of("PK", Map.of("S", key), "value", Map.of("S", value));
+ }
+
+ private static String policy(String action, String resource, String condition) {
+ return "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\",\"Action\":\""
+ + action + "\",\"Resource\":\"" + resource + "\"" + condition + "}]}";
+ }
+
+ private ValidatableResponse org(String account, String action, Map<String, String> body) {
+ return json(account, "us-east-1", "organizations", "AWSOrganizationsV20161128." + action, encode(body));
+ }
+
+ private ValidatableResponse json(String key, String region, String service, String target, String body) {
+ return given().port(endpoint.getPort())
+ .header("Authorization", auth(key, service).replace("/us-east-1/", "/" + region + "/"))
+ .header("X-Amz-Target", target)
+ .contentType("dynamodb".equals(service) ? "application/x-amz-json-1.0" : "application/x-amz-json-1.1")
+ .body(body).post("/").then();
+ }
+
+ private String encode(Object value) {
+ try {
+ return mapper.writeValueAsString(value);
+ } catch (JsonProcessingException exception) {
+ throw new IllegalArgumentException("Cannot encode transaction fixture", exception);
+ }
+ }
+
+ private record Table(String account, String region, String name, String arn) {
+ }
+}