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.javanew file mode 100644index 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.mdindex 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 negatabsent key cannot equal what the policy names, so the condition holds, and a `Deny` writtenthat 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 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 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.javaindex 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.javaindex 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.javaindex 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.javanew file mode 100644index 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.javanew file mode 100644index 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) {+ }+}