Light, fluffy, and always free - The AWS Local Emulator alternative
fix(logs): enforce group permissions for lifecycle changes (#5840)
David Phillips92be67d2df29
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsArnTagAuthorizationTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsArnTagAuthorizationTest.javaindex d75700e3a1..16684294a3 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsArnTagAuthorizationTest.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsArnTagAuthorizationTest.java@@ -40,17 +40,6 @@ class CloudWatchLogsArnTagAuthorizationTest extends CloudWatchLogsAuthorizationFassertResult(action, otherGroup, "false", response);}- @ParameterizedTest- @ValueSource(strings = {"TagResource", "UntagResource", "ListTagsForResource"})- void incompleteArnPrefixIsALiteralName(String action) {- String name = "arn:" + TestFixtures.uniqueName("archive");- createGroup(name, Map.of("protected", "true"));- policy(statement("Allow", action, arn(name)));- Map<String, String> response = invokeResource(caller, action, name);- assertResult(action, name, "true", response);- assertTags(protectedGroup, Map.of("protected", "true"));- }-@ParameterizedTest@ValueSource(strings = {"TagResource", "UntagResource", "ListTagsForResource"})void rootCannotResolveNoncanonicalMarkersIntoLocalNames(String action) {diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsAuthorizationFixture.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsAuthorizationFixture.javaindex fdf5ef18c1..5e234181d0 100644--- a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsAuthorizationFixture.java+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsAuthorizationFixture.java@@ -100,10 +100,14 @@ abstract class CloudWatchLogsAuthorizationFixture {final String createGroup(String name, Map<String, String> tags) {root.createLogGroup(r -> r.logGroupName(name).tags(tags));- groups.add(() -> root.deleteLogGroup(r -> r.logGroupName(name)));+ groups.add(() -> deleteGroup(name));return name;}+ void deleteGroup(String name) {+ root.deleteLogGroup(r -> r.logGroupName(name));+ }+final void policy(String statements) {iam.putUserPolicy(r -> r.userName(user).policyName(policyName).policyDocument("{\"Version\":\"2012-10-17\",\"Statement\":[" + statements + "]}"));diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsGroupAuthorizationTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsGroupAuthorizationTest.javanew file mode 100644index 0000000000..02d9b49e4b--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsGroupAuthorizationTest.java@@ -0,0 +1,154 @@+package com.floci.test;++import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;+import software.amazon.awssdk.services.cloudwatchlogs.model.CloudWatchLogsException;+import software.amazon.awssdk.services.cloudwatchlogs.model.LogGroup;++import java.util.Map;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++@DisplayName("CloudWatch Logs group resource permissions")+class CloudWatchLogsGroupAuthorizationTest extends CloudWatchLogsAuthorizationFixture {++ CloudWatchLogsGroupAuthorizationTest() {+ super("logs-group-permissions", "groups");+ }++ @Override+ void deleteGroup(String name) {+ if (groupExists(name)) {+ super.deleteGroup(name);+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogGroup", "DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void exactGroupGrant(String action) {+ prepare(action);+ policy(statement("Allow", action, groupArn(protectedGroup)));+ assertThatThrownBy(() -> invoke(action, otherGroup))+ .isInstanceOfSatisfying(CloudWatchLogsException.class, this::assertDenied);+ assertState(action, otherGroup, false);+ invoke(action, protectedGroup);+ assertState(action, protectedGroup, true);+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogGroup", "DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void bareGroupGrant(String action) {+ prepare(action);+ policy(statement("Allow", action, TestFixtures.arn("logs", "000000000000", "log-group:" + protectedGroup)));+ assertThatThrownBy(() -> invoke(action, otherGroup))+ .isInstanceOfSatisfying(CloudWatchLogsException.class, this::assertDenied);+ assertState(action, otherGroup, false);+ invoke(action, protectedGroup);+ assertState(action, protectedGroup, true);+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogGroup", "DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void exactGroupDenyOverridesWildcard(String action) {+ prepare(action);+ policy(statement("Allow", action, "*") + "," + statement("Deny", action, groupArn(protectedGroup)));+ assertThatThrownBy(() -> invoke(action, protectedGroup))+ .isInstanceOfSatisfying(CloudWatchLogsException.class, this::assertDenied);+ assertState(action, protectedGroup, false);+ invoke(action, otherGroup);+ assertState(action, otherGroup, true);+ }++ @ParameterizedTest+ @ValueSource(strings = {"DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void groupTagDeny(String action) {+ prepare(action);+ policy(statement("Allow", action, "*") + ","+ + "{\"Effect\":\"Deny\",\"Action\":\"logs:" + action + "\",\"Resource\":\"*\","+ + "\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/protected\":\"true\"}}}");+ assertThatThrownBy(() -> invoke(action, protectedGroup))+ .isInstanceOfSatisfying(CloudWatchLogsException.class, this::assertDenied);+ assertState(action, protectedGroup, false);+ invoke(action, otherGroup);+ assertState(action, otherGroup, true);+ }++ @ParameterizedTest+ @ValueSource(strings = {"TagResource", "TagLogGroup"})+ void taggedCreateRequiresEitherPermission(String tagAction) {+ prepare("CreateLogGroup");+ String primary = statement("Allow", "CreateLogGroup", groupArn(protectedGroup));+ policy(primary);+ assertThatThrownBy(() -> caller.createLogGroup(r -> r.logGroupName(protectedGroup)+ .tags(Map.of("team", "blue"))))+ .isInstanceOfSatisfying(CloudWatchLogsException.class, this::assertDenied);+ assertState("CreateLogGroup", protectedGroup, false);+ String resource = tagAction.equals("TagResource")+ ? TestFixtures.arn("logs", "000000000000", "log-group:" + protectedGroup)+ : groupArn(protectedGroup);+ String unused = tagAction.equals("TagResource") ? "TagLogGroup" : "TagResource";+ policy(primary + "," + statement("Deny", unused, "*") + ","+ + "{\"Effect\":\"Allow\",\"Action\":\"logs:" + tagAction + "\",\"Resource\":\"" + resource+ + "\",\"Condition\":{\"StringEquals\":{\"aws:RequestTag/team\":\"blue\"},"+ + "\"ForAllValues:StringEquals\":{\"aws:TagKeys\":[\"team\"]}}}");+ assertThatThrownBy(() -> caller.createLogGroup(r -> r.logGroupName(protectedGroup)+ .tags(Map.of("team", "red"))))+ .isInstanceOfSatisfying(CloudWatchLogsException.class, this::assertDenied);+ assertState("CreateLogGroup", protectedGroup, false);+ caller.createLogGroup(r -> r.logGroupName(protectedGroup).tags(Map.of("team", "blue")));+ assertState("CreateLogGroup", protectedGroup, true);+ assertThat(root.listTagsLogGroup(r -> r.logGroupName(protectedGroup)).tags()).containsEntry("team", "blue");+ }++ private void prepare(String action) {+ if (action.equals("CreateLogGroup")) {+ root.deleteLogGroup(r -> r.logGroupName(protectedGroup));+ root.deleteLogGroup(r -> r.logGroupName(otherGroup));+ } else if (action.equals("PutRetentionPolicy") || action.equals("DeleteRetentionPolicy")) {+ root.putRetentionPolicy(r -> r.logGroupName(protectedGroup).retentionInDays(7));+ root.putRetentionPolicy(r -> r.logGroupName(otherGroup).retentionInDays(7));+ }+ }++ private String statement(String effect, String action, String resource) {+ return "{\"Effect\":\"" + effect + "\",\"Action\":\"logs:" + action+ + "\",\"Resource\":\"" + resource + "\"}";+ }++ private String groupArn(String group) {+ return TestFixtures.arn("logs", "000000000000", "log-group:" + group + ":*");+ }++ private void invoke(String action, String group) {+ switch (action) {+ case "CreateLogGroup" -> caller.createLogGroup(r -> r.logGroupName(group));+ case "DeleteLogGroup" -> caller.deleteLogGroup(r -> r.logGroupName(group));+ case "PutRetentionPolicy" -> caller.putRetentionPolicy(r -> r.logGroupName(group).retentionInDays(14));+ case "DeleteRetentionPolicy" -> caller.deleteRetentionPolicy(r -> r.logGroupName(group));+ default -> throw new IllegalArgumentException(action);+ }+ }++ private void assertState(String action, String group, boolean changed) {+ LogGroup found = root.describeLogGroupsPaginator(r -> r.logGroupNamePrefix(group)).logGroups().stream()+ .filter(g -> group.equals(g.logGroupName())).findFirst().orElse(null);+ boolean exists = action.equals("CreateLogGroup") ? changed : !action.equals("DeleteLogGroup") || !changed;+ if (!exists) {+ assertThat(found).isNull();+ return;+ }+ assertThat(found).isNotNull();+ if (action.equals("PutRetentionPolicy")) {+ assertThat(found.retentionInDays()).isEqualTo(changed ? 14 : 7);+ } else if (action.equals("DeleteRetentionPolicy")) {+ assertThat(found.retentionInDays()).isEqualTo(changed ? null : 7);+ }+ }++ private boolean groupExists(String group) {+ return root.describeLogGroupsPaginator(r -> r.logGroupNamePrefix(group)).logGroups().stream()+ .anyMatch(g -> group.equals(g.logGroupName()));+ }+}diff --git a/docs/services/iam.md b/docs/services/iam.mdindex f272d5156d..bbf712f0a6 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -1271,6 +1271,18 @@ before changing storage, preventing delimiter aliases from targeting another strThese checks also apply to deletion: legacy streams with names containing `:` or `*` cannot bedeleted through `DeleteLogStream`. Existing stored names are not automatically migrated.+**CloudWatch Logs groups.** `CreateLogGroup`, `DeleteLogGroup`, `PutRetentionPolicy` and+`DeleteRetentionPolicy` accept policy resources naming the selected group with a bare ARN+or its legacy `:*` form. Both forms participate in each statement, including explicit denies+and `NotResource`, without bypassing session, boundary or SCP ceilings. The three operations on+existing groups read that group's resource tags; creation uses the request's `tags` for+`aws:RequestTag/<key>` and `aws:TagKeys`. Tagged creation additionally requires either+`logs:TagResource` on the bare group ARN or `logs:TagLogGroup` on either group ARN form.+The group name constraints apply before mutation, and deletion preserves streams and filters+whose stored group identity belongs to another historical group. These four operations reject `:`+or `*` in a group name. Historical names remain taggable through the ARN tagging APIs below;+they cannot be newly created or deleted through the group lifecycle APIs. Stored names are not migrated.+**CloudWatch Logs ARN tagging.** For log groups, `logs:TagResource`, `logs:UntagResource`and `logs:ListTagsForResource` evaluate the group's ARN without a trailing `:*`. The ARN mustidentify a group in the request's account, region and partition; a different owner or resource@@ -1466,8 +1478,9 @@ floci populates:`ResourceId.N` or `InstanceId.N`), and for `s3:GetBucketTagging`, `s3:DeleteBucket` and the`s3:PutBucketTagging` that `DeleteBucketTagging` is checked as (the bucket). A request naming several EC2 resources is evaluatedonce per resource and denied when any of them fails the condition, as on AWS.- `logs:CreateLogStream`, `logs:DeleteLogStream`, `logs:TagResource`, `logs:UntagResource`- and `logs:ListTagsForResource` use the owning log group's tags.+ `logs:CreateLogStream`, `logs:DeleteLogStream`, `logs:TagResource`, `logs:UntagResource`,+ `logs:ListTagsForResource`, `logs:DeleteLogGroup`, `logs:PutRetentionPolicy` and+ `logs:DeleteRetentionPolicy` use the owning log group's tags.- `s3:ExistingObjectTag/<key>`: the tags already on the target object version, for`s3:GetObject`, `s3:GetObjectTagging`, `s3:GetObjectAcl`, `s3:PutObjectAcl`,`s3:DeleteObjectTagging`, `s3:PutObjectTagging` and the annotation actions, and for theirdiff --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 5079a905be..4fbadbc182 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@@ -100,19 +100,37 @@ public class IamConditionContextResolver {case "ec2" -> ec2ConditionContext(action, ctx);case "dynamodb" -> dynamoDbConditionContext(action, ctx);case "iam" -> iamConditionContext(action, ctx);- case "logs" -> logStreamConditionContext(action, ctx);+ case "logs" -> logsConditionContext(action, ctx);default -> null;};}- /** Stream access uses the owning log group's tags, in the handler's account and region. */- private Map<String, List<String>> logStreamConditionContext(String action, ContainerRequestContext ctx) {+ /** Group mutations and stream access use the handler's group and request scope. */+ private Map<String, List<String>> logsConditionContext(String action, ContainerRequestContext ctx) {if (!("logs:CreateLogStream".equals(action) || "logs:DeleteLogStream".equals(action)- || LogGroupTagTarget.supports(action))) {+ || LogGroupTagTarget.supports(action) || "logs:CreateLogGroup".equals(action) || "logs:DeleteLogGroup".equals(action)+ || "logs:PutRetentionPolicy".equals(action) || "logs:DeleteRetentionPolicy".equals(action))) {return null;}JsonNode body = bufferedJsonBody(ctx);- if (body == null || !logsService.isResolvable()) {+ if (body == null) {+ return null;+ }+ if ("logs:CreateLogGroup".equals(action)) {+ JsonNode tags = body.path("tags");+ if (!tags.isObject() || tags.isEmpty()) {+ return null;+ }+ Map<String, List<String>> conditions = new LinkedHashMap<>();+ List<String> keys = new ArrayList<>();+ tags.properties().forEach(entry -> {+ keys.add(entry.getKey());+ conditions.put("aws:RequestTag/" + entry.getKey(), List.of(entry.getValue().asText()));+ });+ conditions.put("aws:TagKeys", keys);+ return conditions;+ }+ if (!logsService.isResolvable()) {return null;}String region = requestContext.getRegion() == null ? config.defaultRegion() : requestContext.getRegion();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 ce20d80c87..40cdd58019 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@@ -417,7 +417,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {List<String> resources = resolveResourceArns(credentialScope,"logs".equals(credentialScope)- ? arnBuilder.buildLogStreamResources(action, ctx, region, accountId, requestPartition())+ ? arnBuilder.buildLogResources(action, ctx, region, accountId, requestPartition()): arnBuilder.buildResources(credentialScope, ctx, region, accountId));Optional<PresignedScope> presignedScope = iamService.presignedScope(akid);@@ -518,6 +518,25 @@ public class IamEnforcementFilter implements ContainerRequestFilter {return;}+ // Tagged group creation requires either tagging permission, using the same resolved+ // caller (including session, boundary and SCP ceilings) as the primary operation.+ if ("logs:CreateLogGroup".equals(action) && conditionContext != null+ && !conditionContext.getOrDefault("aws:TagKeys", List.of()).isEmpty()) {+ String groupResource = resources.getFirst();+ String taggingResource = groupResource.substring(0, groupResource.length() - 2);+ Map<String, List<String>> taggingContext = IamConditionContextResolver.withGlobalContext(+ conditionContext, taggingResource, region, accountId, accountId);+ Map<String, List<String>> groupContext = IamConditionContextResolver.withGlobalContext(+ conditionContext, groupResource, region, accountId, accountId);+ if (evaluator.evaluate(caller, null, "logs:TagResource", taggingResource, taggingContext) == Decision.DENY+ && evaluator.evaluate(caller, null, "logs:TagLogGroup", groupResource, groupContext) == Decision.DENY) {+ LOG.infov("IAM enforcement DENY: akid={0} action={1} resource={2}",+ akid, "logs:TagResource", taggingResource);+ ctx.abortWith(accessDeniedForRequest("logs:TagResource", credentialScope, ctx, taggingResource));+ return;+ }+ }+// A PutObject carrying If-Match compares against the object it replaces, and S3 authorizes// that read as s3:GetObject, WITHOUT the object's tags in the request context. Measured// against real AWS: under a GetObject allow conditioned on s3:ExistingObjectTag thediff --git a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandler.java b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandler.javaindex 3150c331a9..55c5b5f379 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsHandler.java@@ -90,6 +90,7 @@ public class CloudWatchLogsHandler {private Response handleCreateLogGroup(JsonNode request, String region) {String name = request.path("logGroupName").asText();+ requireLogGroupName(name);Integer retentionInDays = request.has("retentionInDays")? request.path("retentionInDays").asInt() : null;boolean deletionProtectionEnabled = request.path("deletionProtectionEnabled").asBoolean(false);@@ -101,6 +102,7 @@ public class CloudWatchLogsHandler {private Response handleDeleteLogGroup(JsonNode request, String region) {String name = request.path("logGroupName").asText();+ requireLogGroupName(name);logsService.deleteLogGroup(name, region);return Response.ok(objectMapper.createObjectNode()).build();}@@ -264,10 +266,14 @@ public class CloudWatchLogsHandler {return Response.ok(objectMapper.createObjectNode()).build();}- private static void requireLogStreamNames(String group, String stream) {+ private static void requireLogGroupName(String group) {if (group.isEmpty() || group.length() > 512 || !LOG_GROUP_NAME.matcher(group).matches()) {throw new AwsException("InvalidParameterException", "Invalid logGroupName.", 400);}+ }++ private static void requireLogStreamNames(String group, String stream) {+ requireLogGroupName(group);int streamLength = stream.codePointCount(0, stream.length());if (streamLength < 1 || streamLength > 512 || stream.indexOf(':') >= 0 || stream.indexOf('*') >= 0) {throw new AwsException("InvalidParameterException", "Invalid logStreamName.", 400);@@ -510,6 +516,7 @@ public class CloudWatchLogsHandler {private Response handlePutRetentionPolicy(JsonNode request, String region) {String groupName = request.path("logGroupName").asText();+ requireLogGroupName(groupName);int days = request.path("retentionInDays").asInt();logsService.putRetentionPolicy(groupName, days, region);return Response.ok(objectMapper.createObjectNode()).build();@@ -517,6 +524,7 @@ public class CloudWatchLogsHandler {private Response handleDeleteRetentionPolicy(JsonNode request, String region) {String groupName = request.path("logGroupName").asText();+ requireLogGroupName(groupName);logsService.deleteRetentionPolicy(groupName, region);return Response.ok(objectMapper.createObjectNode()).build();}diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsMetricFilterService.java b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsMetricFilterService.javaindex ce96c01230..ff53f37e6b 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsMetricFilterService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsMetricFilterService.java@@ -522,7 +522,11 @@ public class CloudWatchLogsMetricFilterService implements Resettable {synchronized (store) {String account = regionResolver.getAccountId();String prefix = groupPrefix(event.region(), event.logGroupName());- store.keys().stream().filter(key -> key.startsWith(prefix)).toList().forEach(store::delete);+ store.keys().stream().filter(storedKey -> storedKey.startsWith(prefix)+ && store.get(storedKey).map(filter -> event.logGroupName().equals(filter.getLogGroupName())+ && storedKey.equals(key(event.region(), event.logGroupName(), filter.getFilterName())))+ .orElse(false))+ .toList().forEach(store::delete);pending.values().removeIf(p -> p.owner().account().equals(account)&& p.owner().region().equals(event.region()) && p.owner().group().equals(event.logGroupName()));forgetCompletedOutages();diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsService.java b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsService.javaindex af4cc4695f..36c5a69790 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsService.java@@ -285,6 +285,7 @@ public class CloudWatchLogsService implements ResourceProvider {synchronized (metricFilterStore) {String key = groupKey(region, name);LogGroup group = groupStore.get(key)+ .filter(stored -> name.equals(stored.getLogGroupName())).orElseThrow(() -> new AwsException("ResourceNotFoundException","The specified log group does not exist: " + name, 400));if (group.isDeletionProtectionEnabled()) {@@ -301,15 +302,22 @@ public class CloudWatchLogsService implements ResourceProvider {.toList();for (String sk : streamKeys) {LogStream stream = streamStore.get(sk).orElse(null);- if (stream != null) {+ if (stream != null && name.equals(stream.getLogGroupName())+ && sk.equals(streamKey(region, name, stream.getLogStreamName()))) {deleteEventsForStream(region, name, stream.getLogStreamName());streamStore.delete(sk);}}- metricFilterStore.keys().stream().filter(k -> k.startsWith(streamPrefix))+ metricFilterStore.keys().stream().filter(k -> k.startsWith(streamPrefix)+ && metricFilterStore.get(k).map(filter -> name.equals(filter.getLogGroupName())+ && k.equals(streamPrefix + filter.getFilterName())).orElse(false)).toList().forEach(metricFilterStore::delete);String subscriptionPrefix = subscriptionFilterKeyPrefix(region, name);- subscriptionFilterStore.keys().stream().filter(k -> k.startsWith(subscriptionPrefix))+ subscriptionFilterStore.keys().stream().filter(k -> k.startsWith(subscriptionPrefix)+ && subscriptionFilterStore.get(k)+ .map(filter -> name.equals(filter.getLogGroupName())+ && k.equals(subscriptionFilterKey(region, name, filter.getFilterName())))+ .orElse(false)).toList().forEach(subscriptionFilterStore::delete);groupStore.delete(key);LOG.infov("Deleted log group: {0}", name);@@ -358,6 +366,7 @@ public class CloudWatchLogsService implements ResourceProvider {public void putRetentionPolicy(String groupName, int days, String region) {String key = groupKey(region, groupName);LogGroup group = groupStore.get(key)+ .filter(stored -> groupName.equals(stored.getLogGroupName())).orElseThrow(() -> new AwsException("ResourceNotFoundException","The specified log group does not exist: " + groupName, 400));group.setRetentionInDays(days);@@ -367,6 +376,7 @@ public class CloudWatchLogsService implements ResourceProvider {public void deleteRetentionPolicy(String groupName, String region) {String key = groupKey(region, groupName);LogGroup group = groupStore.get(key)+ .filter(stored -> groupName.equals(stored.getLogGroupName())).orElseThrow(() -> new AwsException("ResourceNotFoundException","The specified log group does not exist: " + groupName, 400));group.setRetentionInDays(null);diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluator.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluator.javaindex d1f785f877..bd80877bd0 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluator.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamPolicyEvaluator.java@@ -908,7 +908,7 @@ public class IamPolicyEvaluator {return false;}return matchesAction(stmt, action)- && matchesResource(stmt, resource, ctx)+ && matchesResource(stmt, action, resource, ctx)&& matchesConditions(stmt.getConditions(), ctx, policyVariables(stmt));}@@ -944,7 +944,7 @@ public class IamPolicyEvaluator {PrincipalMatch match = principalMatch(stmt, principal);if (match == PrincipalMatch.NONE|| !matchesAction(stmt, action)- || !matchesResource(stmt, resource, ctx)+ || !matchesResource(stmt, action, resource, ctx)|| !matchesConditions(stmt.getConditions(), ctx, policyVariables(stmt))) {return PrincipalMatch.NONE;}@@ -1121,7 +1121,7 @@ public class IamPolicyEvaluator {private boolean matchesStatement(PolicyStatement stmt, String action, String resource,Map<String, List<String>> ctx) {return matchesAction(stmt, action)- && matchesResource(stmt, resource, ctx)+ && matchesResource(stmt, action, resource, ctx)&& matchesConditions(stmt.getConditions(), ctx, policyVariables(stmt));}@@ -1142,15 +1142,44 @@ public class IamPolicyEvaluator {}/** Resource: matches if any Resource pattern matches; NotResource: matches if NO pattern matches. */- private boolean matchesResource(PolicyStatement stmt, String resource,+ private boolean matchesResource(PolicyStatement stmt, String action, String resource,Map<String, List<String>> ctx) {- if (stmt.getResources() != null) {- return matchesAnyResource(stmt.getResources(), resource, ctx, policyVariables(stmt));+ List<String> patterns = stmt.getResources() != null ? stmt.getResources() : stmt.getNotResources();+ if (patterns == null) {+ return false;+ }+ String alias = logGroupResourceAlias(action, resource);+ boolean matched = matchesAnyResource(patterns, resource, ctx, policyVariables(stmt))+ || alias != null && matchesAnyResource(patterns, alias, ctx, policyVariables(stmt));+ return stmt.getResources() != null ? matched : !matched;+ }++ /**+ * Group-management policies accept both documented bare group ARNs and legacy :* ARNs.+ * Match them inside each statement so explicit denies, NotResource and caller ceilings+ * retain their normal precedence. Stream actions and the three ARN tag APIs stay distinct.+ */+ private static String logGroupResourceAlias(String action, String resource) {+ if (action == null || !switch (action) {+ case "logs:createloggroup", "logs:deleteloggroup", "logs:putretentionpolicy",+ "logs:deleteretentionpolicy", "logs:tagloggroup" -> true;+ default -> false;+ } || !AwsArnUtils.isArnFor(resource, "logs")) {+ return null;}- if (stmt.getNotResources() != null) {- return !matchesAnyResource(stmt.getNotResources(), resource, ctx, policyVariables(stmt));+ String target = AwsArnUtils.parse(resource).resource();+ if (!target.startsWith("log-group:")) {+ return null;}- return false;+ String name = target.substring("log-group:".length());+ boolean suffixed = name.endsWith(":*");+ if (suffixed) {+ name = name.substring(0, name.length() - 2);+ }+ if (name.isEmpty() || name.indexOf(':') >= 0 || name.indexOf('*') >= 0 || name.indexOf('?') >= 0) {+ return null;+ }+ return suffixed ? resource.substring(0, resource.length() - 2) : resource + ":*";}/**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 a674f1e58c..ec5682a39f 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@@ -98,11 +98,16 @@ public class ResourceArnBuilder {};}- /** Uses the serving operation, not an independently parsed target header. */- public List<String> buildLogStreamResources(String action, ContainerRequestContext ctx,- String region, String accountId, String partition) {- if (!("logs:CreateLogStream".equals(action) || "logs:DeleteLogStream".equals(action)- || LogGroupTagTarget.supports(action))) {+ /** Uses the serving operation and the same raw names as the handler. */+ public List<String> buildLogResources(String action, ContainerRequestContext ctx,+ String region, String accountId, String partition) {+ boolean stream = "logs:CreateLogStream".equals(action) || "logs:DeleteLogStream".equals(action);+ boolean group = switch (action) {+ case "logs:CreateLogGroup", "logs:DeleteLogGroup", "logs:PutRetentionPolicy",+ "logs:DeleteRetentionPolicy" -> true;+ default -> false;+ };+ if (!stream && !group && !LogGroupTagTarget.supports(action)) {return List.of("*");}JsonNode body = readJsonBody(ctx);@@ -112,11 +117,10 @@ public class ResourceArnBuilder {if (LogGroupTagTarget.supports(action)) {return List.of(LogGroupTagTarget.resolve(body.path("resourceArn").asText(), region, accountId, partition).arn());}- // Match the handler's coercion and raw names, including whitespace and numeric values.- String group = body.path("logGroupName").asText();- String stream = body.path("logStreamName").asText();- return List.of(new AwsArnUtils.Arn(partition, "logs", region, accountId,- "log-group:" + group + ":log-stream:" + stream).toString());+ String name = body.path("logGroupName").asText();+ String resource = "log-group:" + name + (stream+ ? ":log-stream:" + body.path("logStreamName").asText() : ":*");+ return List.of(new AwsArnUtils.Arn(partition, "logs", region, accountId, resource).toString());}// ── IAM ─────────────────────────────────────────────────────────────────────diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsGroupDeletionObserverIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsGroupDeletionObserverIntegrationTest.javanew file mode 100644index 0000000000..3199b2e233--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsGroupDeletionObserverIntegrationTest.java@@ -0,0 +1,82 @@+package io.github.hectorvent.floci.services.cloudwatch.logs;++import io.github.hectorvent.floci.core.common.RequestScopes;+import io.github.hectorvent.floci.services.cloudwatch.logs.model.MetricFilter;+import io.github.hectorvent.floci.testing.EnforcementFixtures;+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.Response;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;++import java.net.URI;+import java.util.List;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.junit.jupiter.api.Assertions.assertAll;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;++@QuarkusTest+@TestProfile(IamEnforcementProfile.class)+class CloudWatchLogsGroupDeletionObserverIntegrationTest {++ private static final String ACCOUNT = "111111111111";+ private static final String REGION = "us-east-1";++ @Inject+ CloudWatchLogsService logs;++ @Inject+ CloudWatchLogsMetricFilterService metrics;++ @TestHTTPResource+ URI endpoint;++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ @BeforeAll+ static void configureContentTypes() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void actualDeletionObserverPreservesHistoricalChildMetricFilters() {+ assertNotNull(metrics);+ String parent = "logs-observer-" + UUID.randomUUID();+ String child = parent + "::child";+ for (String group : List.of(parent, child)) {+ cleanup.register(() -> RequestScopes.runAs(ACCOUNT, REGION, () -> {+ if (logs.describeLogGroups(group, REGION).stream()+ .anyMatch(stored -> group.equals(stored.getLogGroupName()))) {+ logs.deleteLogGroup(group, REGION);+ }+ }));+ logs.createLogGroupForAccount(ACCOUNT, group, null, Map.of(), REGION);+ RequestScopes.runAs(ACCOUNT, REGION, () -> {+ MetricFilter filter = new MetricFilter();+ filter.setLogGroupName(group);+ filter.setFilterName("m");+ logs.metricFilterStore().put(REGION + "::" + group + "::m", filter);+ assertNotNull(logs.metricFilterStore().get(REGION + "::" + group + "::m").orElse(null));+ });+ }+ Response response = given().port(endpoint.getPort()).contentType("application/x-amz-json-1.1")+ .header("Authorization", EnforcementFixtures.auth(ACCOUNT, "logs"))+ .header("X-Amz-Target", "Logs_20140328.DeleteLogGroup")+ .body(Map.of("logGroupName", parent)).when().post("/");+ RequestScopes.runAs(ACCOUNT, REGION, () -> assertAll("real CDI observer retains the unrelated child filter",+ () -> response.then().statusCode(200),+ () -> assertNull(logs.metricFilterStore().get(REGION + "::" + parent + "::m").orElse(null)),+ () -> assertNotNull(logs.metricFilterStore().get(REGION + "::" + child + "::m").orElse(null))));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsGroupIsolationTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsGroupIsolationTest.javanew file mode 100644index 0000000000..d86449eca4--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cloudwatch/logs/CloudWatchLogsGroupIsolationTest.java@@ -0,0 +1,122 @@+package io.github.hectorvent.floci.services.cloudwatch.logs;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.cloudwatch.logs.model.LogEvent;+import io.github.hectorvent.floci.services.cloudwatch.logs.model.LogGroup;+import io.github.hectorvent.floci.services.cloudwatch.logs.model.LogStream;+import io.github.hectorvent.floci.services.cloudwatch.logs.model.MetricFilter;+import io.github.hectorvent.floci.services.cloudwatch.logs.model.SubscriptionFilter;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import static org.junit.jupiter.api.Assertions.assertAll;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;++class CloudWatchLogsGroupIsolationTest {++ private final InMemoryStorage<String, LogGroup> groups = new InMemoryStorage<>();+ private final InMemoryStorage<String, LogStream> streams = new InMemoryStorage<>();+ private final InMemoryStorage<String, LogEvent> events = new InMemoryStorage<>();+ private final InMemoryStorage<String, SubscriptionFilter> subscriptions = new InMemoryStorage<>();+ private final InMemoryStorage<String, MetricFilter> metrics = new InMemoryStorage<>();+ private CloudWatchLogsService service;++ @BeforeEach+ void setUp() {+ service = new CloudWatchLogsService(groups, streams, events, subscriptions, metrics,+ 10_000, new RegionResolver("us-east-1", "000000000000"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void collidingRegionAndNameCannotMutateAnotherStoredGroup(String action) {+ LogGroup protectedGroup = new LogGroup();+ protectedGroup.setLogGroupName("x::victim");+ protectedGroup.setRetentionInDays(7);+ groups.put("r::x::victim", protectedGroup);+ assertNotNull(groups.get("r::x::victim").orElse(null));+ assertAll("reject mismatched stored identity and preserve group",+ () -> assertThrows(AwsException.class, () -> {+ switch (action) {+ case "DeleteLogGroup" -> service.deleteLogGroup("victim", "r::x");+ case "PutRetentionPolicy" -> service.putRetentionPolicy("victim", 14, "r::x");+ case "DeleteRetentionPolicy" -> service.deleteRetentionPolicy("victim", "r::x");+ default -> throw new AssertionError(action);+ }+ }),+ () -> assertEquals(protectedGroup, groups.get("r::x::victim").orElse(null)),+ () -> assertEquals(7, protectedGroup.getRetentionInDays()));+ }++ @Test+ void deletingGroupRetainsHistoricalPrefixChildResources() {+ service.createLogGroup("g", null, null, "us-east-1");+ LogGroup historical = new LogGroup();+ historical.setLogGroupName("g::child");+ groups.put("us-east-1::g::child", historical);+ for (String group : new String[]{"g", "g::child"}) {+ LogStream stream = new LogStream();+ stream.setLogGroupName(group);+ stream.setLogStreamName("s");+ streams.put("us-east-1::" + group + "::s", stream);+ MetricFilter metric = new MetricFilter();+ metric.setLogGroupName(group);+ metric.setFilterName("m");+ metrics.put("us-east-1::" + group + "::m", metric);+ SubscriptionFilter subscription = new SubscriptionFilter();+ subscription.setLogGroupName(group);+ subscription.setFilterName("f");+ subscriptions.put("us-east-1::" + group + "::filter::f", subscription);+ }+ service.deleteLogGroup("g", "us-east-1");+ assertAll("remove owned resources but retain historical child",+ () -> assertNull(groups.get("us-east-1::g").orElse(null)),+ () -> assertNull(streams.get("us-east-1::g::s").orElse(null)),+ () -> assertNull(metrics.get("us-east-1::g::m").orElse(null)),+ () -> assertNull(subscriptions.get("us-east-1::g::filter::f").orElse(null)),+ () -> assertEquals(historical, groups.get("us-east-1::g::child").orElse(null)),+ () -> assertNotNull(streams.get("us-east-1::g::child::s").orElse(null)),+ () -> assertNotNull(metrics.get("us-east-1::g::child::m").orElse(null)),+ () -> assertNotNull(subscriptions.get("us-east-1::g::child::filter::f").orElse(null)));+ }++ @ParameterizedTest+ @ValueSource(strings = {"::g::x", "::g::filter::x"})+ void deletingGroupRetainsSameNamedGroupInAliasingRegion(String regionSuffix) {+ String region = "us-east-1";+ String otherRegion = region + regionSuffix;+ for (String ownerRegion : new String[]{region, otherRegion}) {+ service.createLogGroup("g", null, null, ownerRegion);+ LogStream stream = new LogStream();+ stream.setLogGroupName("g");+ stream.setLogStreamName("s");+ streams.put(ownerRegion + "::g::s", stream);+ MetricFilter metric = new MetricFilter();+ metric.setLogGroupName("g");+ metric.setFilterName("m");+ metrics.put(ownerRegion + "::g::m", metric);+ SubscriptionFilter subscription = new SubscriptionFilter();+ subscription.setLogGroupName("g");+ subscription.setFilterName("f");+ subscriptions.put(ownerRegion + "::g::filter::f", subscription);+ }+ service.deleteLogGroup("g", region);+ assertAll("cleanup keeps the same named group's other region",+ () -> assertNull(groups.get(region + "::g").orElse(null)),+ () -> assertNull(streams.get(region + "::g::s").orElse(null)),+ () -> assertNull(metrics.get(region + "::g::m").orElse(null)),+ () -> assertNull(subscriptions.get(region + "::g::filter::f").orElse(null)),+ () -> assertNotNull(groups.get(otherRegion + "::g").orElse(null)),+ () -> assertNotNull(streams.get(otherRegion + "::g::s").orElse(null)),+ () -> assertNotNull(metrics.get(otherRegion + "::g::m").orElse(null)),+ () -> assertNotNull(subscriptions.get(otherRegion + "::g::filter::f").orElse(null)));+ }++}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/LogGroupArnPolicyCompatibilityTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/LogGroupArnPolicyCompatibilityTest.javanew file mode 100644index 0000000000..b6e1ddaf97--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/LogGroupArnPolicyCompatibilityTest.java@@ -0,0 +1,180 @@+package io.github.hectorvent.floci.services.iam;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.services.iam.model.CallerContext;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.ValueSource;++import java.util.List;+import java.util.Map;++import static io.github.hectorvent.floci.services.iam.IamPolicyEvaluator.Decision;+import static org.junit.jupiter.api.Assertions.assertEquals;++class LogGroupArnPolicyCompatibilityTest {++ private static final String GROUP = "arn:aws:logs:us-east-1:111111111111:log-group:/app/selected";+ private static final String OTHER = "arn:aws:logs:us-east-1:111111111111:log-group:/app/other";+ private final IamPolicyEvaluator evaluator = new IamPolicyEvaluator(new ObjectMapper());++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogGroup", "DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy", "TagLogGroup"})+ void documentedGroupArnsAndLegacySuffixesSelectTheSameGroup(String operation) {+ String action = "logs:" + operation;+ for (String location : List.of("aws:logs:us-east-1", "aws-cn:logs:cn-north-1", "aws-us-gov:logs:us-gov-west-1")) {+ String selected = "arn:" + location + ":111111111111:log-group:/app/selected";+ for (String policySuffix : List.of("", ":*")) {+ String policy = document(statement("Allow", action, "Resource", selected + policySuffix));+ for (String requestSuffix : List.of("", ":*")) {+ assertEquals(Decision.ALLOW, decide(policy, action, selected + requestSuffix));+ assertEquals(Decision.DENY, decide(policy, action,+ selected.replace("/selected", "/other") + requestSuffix));+ assertEquals(Decision.DENY, decide(policy, action,+ selected.replace("111111111111", "222222222222") + requestSuffix));+ }+ }+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogGroup", "DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy", "TagLogGroup"})+ void explicitDenyWinsEvenWhenItsArnUsesTheOtherForm(String operation) {+ String action = "logs:" + operation;+ for (String denySuffix : List.of("", ":*")) {+ String allowSuffix = denySuffix.isEmpty() ? ":*" : "";+ String policy = document(statement("Allow", action, "Resource", GROUP + allowSuffix),+ statement("Deny", action, "Resource", GROUP + denySuffix));+ for (String requestSuffix : List.of("", ":*")) {+ assertEquals(Decision.DENY, decide(policy, action, GROUP + requestSuffix));+ }+ String control = document(statement("Allow", action, "Resource", "*"),+ statement("Deny", action, "Resource", GROUP + denySuffix));+ assertEquals(Decision.ALLOW, decide(control, action, OTHER));+ }+ }++ @Test+ void notResourceExcludesTheGroupInEitherForm() {+ String action = "logs:DeleteLogGroup";+ for (String excludedSuffix : List.of("", ":*")) {+ String exclude = statement("Deny", action, "NotResource", GROUP + excludedSuffix);+ String policy = document(statement("Allow", action, "Resource", "*"), exclude);+ assertEquals(Decision.DENY, decide(policy, action, OTHER));+ assertEquals(Decision.ALLOW, decide(policy, action, GROUP));+ assertEquals(Decision.ALLOW, decide(policy, action, GROUP + ":*"));+ String allowOutside = document(statement("Allow", action, "NotResource", GROUP + excludedSuffix));+ assertEquals(Decision.ALLOW, decide(allowOutside, action, OTHER));+ assertEquals(Decision.DENY, decide(allowOutside, action, GROUP));+ assertEquals(Decision.DENY, decide(allowOutside, action, GROUP + ":*"));+ }+ }++ @Test+ void variablesResolveBeforeGroupMatchingAndMissingVariablesGrantNothing() {+ String action = "logs:PutRetentionPolicy";+ String pattern = GROUP.replace("selected", "${aws:username}");+ Map<String, List<String>> context = Map.of("aws:username", List.of("selected"));+ String allow = document(statement("Allow", action, "Resource", pattern));+ CallerContext caller = CallerContext.of(List.of(allow));+ assertEquals(Decision.ALLOW, evaluator.evaluate(caller, null, action, GROUP + ":*", context));+ assertEquals(Decision.DENY, evaluator.evaluate(caller, null, action, GROUP + ":*", Map.of()));+ assertEquals(Decision.DENY, evaluator.evaluate(caller, null, action, OTHER, context));+ String deny = document(statement("Allow", action, "Resource", "*"),+ statement("Deny", action, "Resource", pattern));+ assertEquals(Decision.DENY, evaluator.evaluate(CallerContext.of(List.of(deny)), null,+ action, GROUP + ":*", context));+ assertEquals(Decision.ALLOW, evaluator.evaluate(CallerContext.of(List.of(deny)), null,+ action, GROUP + ":*", Map.of()));+ String legacy = allow.replace("2012-10-17", "2008-10-17");+ assertEquals(Decision.DENY, evaluator.evaluate(CallerContext.of(List.of(legacy)), null,+ action, GROUP + ":*", context));+ }++ @ParameterizedTest+ @ValueSource(strings = {"session", "boundary", "scp"})+ void callerCeilingsMustAllowAndMustNotDenyEitherForm(String ceiling) {+ String action = "logs:CreateLogGroup";+ String identity = document(statement("Allow", action, "Resource", GROUP + ":*"));+ String grant = document(statement("Allow", action, "Resource", GROUP));+ String missingGrant = document(statement("Allow", action, "Resource", OTHER));+ String denial = document(statement("Allow", action, "Resource", "*"),+ statement("Deny", action, "Resource", GROUP));+ assertEquals(Decision.ALLOW, evaluator.evaluate(caller(ceiling, identity, grant), null,+ action, GROUP + ":*", Map.of()));+ assertEquals(Decision.DENY, evaluator.evaluate(caller(ceiling, identity, missingGrant), null,+ action, GROUP + ":*", Map.of()));+ assertEquals(Decision.DENY, evaluator.evaluate(caller(ceiling, identity, denial), null,+ action, GROUP + ":*", Map.of()));+ String reverseIdentity = document(statement("Allow", action, "Resource", GROUP));+ String reverseDeny = document(statement("Allow", action, "Resource", "*"),+ statement("Deny", action, "Resource", GROUP + ":*"));+ assertEquals(Decision.DENY, evaluator.evaluate(caller(ceiling, reverseIdentity, reverseDeny), null,+ action, GROUP, Map.of()));+ }++ @Test+ void resourcePolicyGrantAndDenyUseTheSameGroupIdentity() {+ String action = "logs:DeleteLogGroup";+ String userArn = "arn:aws:iam::111111111111:user/alice";+ CallerContext caller = CallerContext.of(List.of()).withPrincipalArn(userArn);+ String grant = document(resourceStatement("Allow", action, GROUP, userArn));+ assertEquals(Decision.ALLOW, evaluator.evaluate(caller, List.of(grant), action, GROUP + ":*", Map.of()));+ String deny = document(resourceStatement("Deny", action, GROUP + ":*", userArn));+ CallerContext allowed = CallerContext.of(List.of(document(statement("Allow", action, "Resource", GROUP))))+ .withPrincipalArn(userArn);+ assertEquals(Decision.DENY, evaluator.evaluate(allowed, List.of(deny), action, GROUP, Map.of()));+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream", "TagResource", "UntagResource", "ListTagsForResource"})+ void otherLogsActionsDoNotAcquireGroupArnAliases(String operation) {+ String action = "logs:" + operation;+ String policy = document(statement("Allow", action, "Resource", GROUP));+ assertEquals(Decision.ALLOW, decide(policy, action, GROUP));+ assertEquals(Decision.DENY, decide(policy, action, GROUP + ":*"));+ assertEquals(Decision.DENY, decide(policy, action, GROUP + ":log-stream:s"));+ }++ @Test+ void otherServicesCaseAndMalformedGroupIdentifiersDoNotBecomeAliases() {+ String action = "logs:DeleteLogGroup";+ for (String resource : List.of(GROUP.replace(":logs:", ":s3:"), GROUP + ":child",+ GROUP.substring(0, GROUP.lastIndexOf(':') + 1), "log-group:/app/selected")) {+ String policy = document(statement("Allow", action, "Resource", resource));+ assertEquals(Decision.DENY, decide(policy, action, resource + ":*"), resource);+ }+ String policy = document(statement("Allow", action, "Resource", GROUP));+ assertEquals(Decision.DENY, decide(policy, action, GROUP.replace("/selected", "/Selected") + ":*"));+ assertEquals(Decision.DENY, decide(policy, "s3:DeleteBucket", GROUP + ":*"));+ String streamPattern = document(statement("Allow", action, "Resource", GROUP + ":log-stream:*"));+ assertEquals(Decision.DENY, decide(streamPattern, action, GROUP + ":*"));+ }++ private Decision decide(String policy, String action, String resource) {+ return evaluator.evaluate(CallerContext.of(List.of(policy)), null, action, resource, Map.of());+ }++ private static CallerContext caller(String ceiling, String identity, String policy) {+ return switch (ceiling) {+ case "session" -> new CallerContext(List.of(identity), policy, null, null);+ case "boundary" -> new CallerContext(List.of(identity), null, policy, null);+ case "scp" -> new CallerContext(List.of(identity), null, null, List.of(List.of(policy)));+ default -> throw new IllegalArgumentException(ceiling);+ };+ }++ private static String document(String... statements) {+ return "{\"Version\":\"2012-10-17\",\"Statement\":[" + String.join(",", statements) + "]}";+ }++ private static String statement(String effect, String action, String resourceElement, String resource) {+ return "{\"Effect\":\"" + effect + "\",\"Action\":\"" + action + "\",\"" + resourceElement+ + "\":\"" + resource + "\"}";+ }++ private static String resourceStatement(String effect, String action, String resource, String principal) {+ return "{\"Effect\":\"" + effect + "\",\"Action\":\"" + action + "\",\"Resource\":\"" + resource+ + "\",\"Principal\":{\"AWS\":\"" + principal + "\"}}";+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/LogsArnTagAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/LogsArnTagAuthorizationIntegrationTest.javaindex 9a4f0c2093..e9ca914c36 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/LogsArnTagAuthorizationIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/LogsArnTagAuthorizationIntegrationTest.java@@ -1,5 +1,7 @@package io.github.hectorvent.floci.services.iam;+import io.github.hectorvent.floci.core.common.RequestScopes;+import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;import io.github.hectorvent.floci.testing.IamEnforcementProfile;import io.github.hectorvent.floci.testing.LogsAuthorizationFixtures;import io.github.hectorvent.floci.testing.PartitionCleanup;@@ -8,6 +10,7 @@ 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;@@ -40,6 +43,9 @@ class LogsArnTagAuthorizationIntegrationTest {@TestHTTPResourceURI endpoint;+ @Inject+ CloudWatchLogsService logsService;+@BeforeAllstatic void configureContentTypes() {RestAssuredJsonUtils.configureAwsContentTypes();@@ -111,7 +117,7 @@ class LogsArnTagAuthorizationIntegrationTest {@ParameterizedTest@ValueSource(strings = {"TagResource", "UntagResource", "ListTagsForResource"})void incompleteArnPrefixRemainsALiteralLegacyName(String action) {- String name = groupNamed("arn:archive-" + UUID.randomUUID(), Map.of("team", "blue"));+ String name = historicalGroupNamed("arn:archive-" + UUID.randomUUID(), Map.of("team", "blue"));String caller = user(statement("Allow", action, arn(name)));assertSuccess(invoke(caller, action, name), action);assertTags(name, expectedTags(action));@@ -140,7 +146,7 @@ class LogsArnTagAuthorizationIntegrationTest {assertAll("noncanonical input cannot access the shortened local name",() -> response.statusCode(400).body(containsString("ResourceNotFoundException")),() -> assertTags(local, Map.of("team", "blue")));- String literal = groupNamed(input, Map.of("team", "blue"));+ String literal = historicalGroupNamed(input, Map.of("team", "blue"));assertSuccess(invoke(caller, action, input), action);assertTags(literal, expectedTags(action));assertTags(local, Map.of("team", "blue"));@@ -219,6 +225,12 @@ class LogsArnTagAuthorizationIntegrationTest {return name;}+ private String historicalGroupNamed(String name, Map<String, String> tags) {+ cleanup.register(() -> RequestScopes.runAs(ACCOUNT, REGION, () -> logsService.deleteLogGroup(name, REGION)));+ logsService.createLogGroupForAccount(ACCOUNT, name, null, tags, REGION);+ return name;+ }+private String user(String statements) {return LogsAuthorizationFixtures.user(cleanup, endpoint.getPort(), ACCOUNT, "logs-arn-tag-","arn-tags", statements);diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/LogsGroupAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/LogsGroupAuthorizationIntegrationTest.javanew file mode 100644index 0000000000..3d2d3d1157--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/LogsGroupAuthorizationIntegrationTest.java@@ -0,0 +1,363 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.core.common.RequestScopes;+import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;+import io.github.hectorvent.floci.testing.EnforcementFixtures;+import io.github.hectorvent.floci.testing.IamEnforcementProfile;+import io.github.hectorvent.floci.testing.LogsAuthorizationFixtures;+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.Response;+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.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertAll;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;++@QuarkusTest+@TestProfile(IamEnforcementProfile.class)+class LogsGroupAuthorizationIntegrationTest {++ private static final String ACCOUNT = "111111111111";+ private static final String REGION = "us-east-1";++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ @TestHTTPResource+ URI endpoint;++ @Inject+ CloudWatchLogsService logsService;++ @BeforeAll+ static void configureContentTypes() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogGroup", "DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void exactGroupPermissionAllowsOnlyTheSelectedGroup(String action) {+ String selected = group(action);+ String other = group(action);+ String caller = user(policy("Allow", action, arn(selected)));+ Response denied = operation(caller, action, other).extract().response();+ assertAll("unrelated group denied without mutation",+ () -> denied.then().statusCode(400).body(containsString("AccessDeniedException")),+ () -> assertUnchanged(action, other));+ operation(caller, action, selected).statusCode(200);+ assertChanged(action, selected);+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogGroup", "DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void bareGroupPermissionAllowsOnlyTheSelectedGroup(String action) {+ String selected = group(action);+ String other = group(action);+ String caller = user(policy("Allow", action, bareArn(selected)));+ Response denied = operation(caller, action, other).extract().response();+ assertAll("bare group grant denies unrelated state changes",+ () -> denied.then().statusCode(400).body(containsString("AccessDeniedException")),+ () -> assertUnchanged(action, other));+ operation(caller, action, selected).statusCode(200);+ assertChanged(action, selected);+ }++ @ParameterizedTest+ @CsvSource({"CreateLogGroup,false", "CreateLogGroup,true", "DeleteLogGroup,false", "DeleteLogGroup,true",+ "PutRetentionPolicy,false", "PutRetentionPolicy,true", "DeleteRetentionPolicy,false",+ "DeleteRetentionPolicy,true"})+ void oppositeGroupArnFormDenyOverridesExactAllow(String action, boolean bareAllow) {+ String selected = group(action);+ String other = group(action);+ String selectedAllow = bareAllow ? bareArn(selected) : arn(selected);+ String otherAllow = bareAllow ? bareArn(other) : arn(other);+ String selectedDeny = bareAllow ? arn(selected) : bareArn(selected);+ String caller = user(policy("Allow", action, selectedAllow) + ","+ + policy("Allow", action, otherAllow) + "," + policy("Deny", action, selectedDeny));+ Response denied = operation(caller, action, selected).extract().response();+ assertAll("equivalent group ARN deny preserves the selected group",+ () -> denied.then().statusCode(400).body(containsString("AccessDeniedException")),+ () -> assertUnchanged(action, selected));+ operation(caller, action, other).statusCode(200);+ assertChanged(action, other);+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogGroup", "DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void exactGroupDenyOverridesWildcardAllow(String action) {+ String selected = group(action);+ String other = group(action);+ String caller = user(policy("Allow", action, "*") + "," + policy("Deny", action, arn(selected)));+ Response denied = operation(caller, action, selected).extract().response();+ assertAll("selected group denied without mutation",+ () -> denied.then().statusCode(400).body(containsString("AccessDeniedException")),+ () -> assertUnchanged(action, selected));+ operation(caller, action, other).statusCode(200);+ assertChanged(action, other);+ }++ @ParameterizedTest+ @ValueSource(strings = {"DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void resourceTagDenyProtectsExistingGroup(String action) {+ String selected = group(action);+ String other = group(action);+ call(endpoint.getPort(), ACCOUNT, "TagLogGroup",+ Map.of("logGroupName", selected, "tags", Map.of("protected", "true"))).statusCode(200);+ String condition = ",\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/protected\":\"true\"}}";+ String caller = user(policy("Allow", action, "*") + ","+ + policy("Deny", action, "*", condition));+ Response denied = operation(caller, action, selected).extract().response();+ assertAll("group tag deny preserves state",+ () -> denied.then().statusCode(400).body(containsString("AccessDeniedException")),+ () -> assertUnchanged(action, selected));+ operation(caller, action, other).statusCode(200);+ assertChanged(action, other);+ }++ @Test+ void createRequestTagsUseHandlerValues() {+ String selected = group("CreateLogGroup");+ String other = group("CreateLogGroup");+ String condition = ",\"Condition\":{\"StringEquals\":{\"aws:RequestTag/team\":\"42\"}}";+ String caller = user(policy("Allow", "CreateLogGroup", "*", condition)+ + "," + policy("Allow", "TagResource", "*"));+ call(endpoint.getPort(), caller, "CreateLogGroup",+ Map.of("logGroupName", other, "tags", Map.of("team", "red")))+ .statusCode(400).body(containsString("AccessDeniedException"));+ assertNull(find(other));+ call(endpoint.getPort(), caller, "CreateLogGroup",+ Map.of("logGroupName", selected, "tags", Map.of("team", 42))).statusCode(200);+ call(endpoint.getPort(), ACCOUNT, "ListTagsLogGroup", Map.of("logGroupName", selected))+ .statusCode(200).body("tags.team", equalTo("42"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"none", "TagResource", "TagLogGroup"})+ void taggedCreateRequiresEitherTagPermission(String taggingAction) {+ String selected = group("CreateLogGroup");+ String untagged = group("CreateLogGroup");+ String statements = policy("Allow", "CreateLogGroup", "*");+ if (!taggingAction.equals("none")) {+ statements += "," + policy("Allow", taggingAction, "*");+ }+ String caller = user(statements);+ call(endpoint.getPort(), caller, "CreateLogGroup", Map.of("logGroupName", untagged)).statusCode(200);+ assertNotNull(find(untagged));+ Response response = call(endpoint.getPort(), caller, "CreateLogGroup",+ Map.of("logGroupName", selected, "tags", Map.of("team", "blue"))).extract().response();+ if (taggingAction.equals("none")) {+ assertAll("tagged creation requires an alternative permission",+ () -> response.then().statusCode(400).body(containsString("AccessDeniedException")),+ () -> assertNull(find(selected)));+ } else {+ response.then().statusCode(200);+ call(endpoint.getPort(), ACCOUNT, "ListTagsLogGroup", Map.of("logGroupName", selected))+ .statusCode(200).body("tags.team", equalTo("blue"));+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogGroup", "DeleteLogGroup", "PutRetentionPolicy", "DeleteRetentionPolicy"})+ void ambiguousGroupNamesCannotBecomeAuthorizedAliases(String action) {+ String name = "logs-group-invalid-" + UUID.randomUUID() + ":child";+ if (!action.equals("CreateLogGroup")) {+ cleanup.register(() -> RequestScopes.runAs(ACCOUNT, REGION, () -> logsService.deleteLogGroup(name, REGION)));+ logsService.createLogGroupForAccount(ACCOUNT, name, 7, Map.of(), REGION);+ }+ String caller = user(policy("Allow", action, "*"));+ operation(caller, action, name).statusCode(400).body(containsString("InvalidParameterException"));+ assertUnchanged(action, name);+ }++ @ParameterizedTest+ @CsvSource({"TagResource,false,false", "TagResource,true,false", "TagLogGroup,false,false",+ "TagLogGroup,true,false", "TagLogGroup,false,true", "TagLogGroup,true,true"})+ void createTagAlternativesUseTheirOwnArnAndConditions(String taggingAction, boolean primaryBare,+ boolean taggingBare) {+ String selected = group("CreateLogGroup");+ String otherAction = taggingAction.equals("TagResource") ? "TagLogGroup" : "TagResource";+ String resource = taggingAction.equals("TagResource") || taggingBare ? bareArn(selected) : arn(selected);+ String condition = ",\"Condition\":{\"StringEquals\":{\"aws:RequestTag/team\":\"blue\"},"+ + "\"ForAllValues:StringEquals\":{\"aws:TagKeys\":[\"team\"]}}";+ String caller = user(policy("Allow", "CreateLogGroup", primaryBare ? bareArn(selected) : arn(selected)) + ","+ + policy("Allow", taggingAction, resource, condition) + "," + policy("Deny", otherAction, "*"));+ for (Map<String, String> rejected : List.of(Map.of("team", "red"), Map.of("team", "blue", "extra", "value"))) {+ Response denied = call(endpoint.getPort(), caller, "CreateLogGroup",+ Map.of("logGroupName", selected, "tags", rejected)).extract().response();+ assertAll("secondary permission conditions must reject before creating",+ () -> denied.then().statusCode(400).body(containsString("AccessDeniedException")),+ () -> assertNull(find(selected)));+ }+ call(endpoint.getPort(), caller, "CreateLogGroup",+ Map.of("logGroupName", selected, "tags", Map.of("team", "blue"))).statusCode(200);+ call(endpoint.getPort(), ACCOUNT, "ListTagsLogGroup", Map.of("logGroupName", selected))+ .statusCode(200).body("tags.team", equalTo("blue"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"array", "text", "number", "empty-object", "null"})+ void ignoredOrEmptyTagsDoNotRequireTaggingPermission(String kind) {+ String selected = group("CreateLogGroup");+ String caller = user(policy("Allow", "CreateLogGroup", arn(selected)));+ Object tags = switch (kind) {+ case "array" -> List.of("team");+ case "text" -> "team";+ case "number" -> 42;+ case "empty-object" -> Map.of();+ case "null" -> null;+ default -> throw new AssertionError(kind);+ };+ Map<String, Object> body = new LinkedHashMap<>();+ body.put("logGroupName", selected);+ body.put("tags", tags);+ call(endpoint.getPort(), caller, "CreateLogGroup", body).statusCode(200);+ assertEquals(Map.of(), call(endpoint.getPort(), ACCOUNT, "ListTagsLogGroup",+ Map.of("logGroupName", selected)).statusCode(200).extract().path("tags"));+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void taggedCreationRetainsAssumedRoleSessionCeilings(boolean taggingAllowed) {+ String selected = group("CreateLogGroup");+ String untagged = group("CreateLogGroup");+ String role = "logs-group-session-" + UUID.randomUUID();+ int port = endpoint.getPort();+ String root = EnforcementFixtures.auth(ACCOUNT, "iam");+ cleanup.register(() -> EnforcementFixtures.removeRole(port, root, role));+ String roleArn = given().port(port).header("Authorization", root)+ .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().xmlPath()+ .getString("CreateRoleResponse.CreateRoleResult.Role.Arn");+ String create = policy("Allow", "CreateLogGroup", "*");+ String tagging = policy("Allow", "TagResource", "*");+ given().port(port).header("Authorization", root).formParam("Action", "PutRolePolicy")+ .formParam("RoleName", role).formParam("PolicyName", "groups")+ .formParam("PolicyDocument", "{\"Version\":\"2012-10-17\",\"Statement\":[" + create + "," + tagging + "]}")+ .post("/").then().statusCode(200);+ String sessionPolicy = "{\"Version\":\"2012-10-17\",\"Statement\":["+ + create + (taggingAllowed ? "," + tagging : "") + "]}";+ Response assumed = given().port(port).header("Authorization", EnforcementFixtures.auth(ACCOUNT, "sts"))+ .formParam("Action", "AssumeRole").formParam("RoleArn", roleArn)+ .formParam("RoleSessionName", "groups").formParam("Policy", sessionPolicy)+ .post("/").then().statusCode(200).extract().response();+ String key = assumed.xmlPath().getString("AssumeRoleResponse.AssumeRoleResult.Credentials.AccessKeyId");+ String token = assumed.xmlPath().getString("AssumeRoleResponse.AssumeRoleResult.Credentials.SessionToken");+ sessionCreate(port, key, token, Map.of("logGroupName", untagged)).then().statusCode(200);+ assertNotNull(find(untagged));+ Response response = sessionCreate(port, key, token,+ Map.of("logGroupName", selected, "tags", Map.of("team", "blue")));+ assertAll("secondary permission must retain the issued session policy",+ () -> response.then().statusCode(taggingAllowed ? 200 : 400),+ () -> assertEquals(taggingAllowed, find(selected) != null),+ () -> {+ if (!taggingAllowed) {+ response.then().body(containsString("AccessDeniedException"));+ }+ });+ }++ private static Response sessionCreate(int port, String key, String token, Map<String, ?> body) {+ return given().port(port).contentType("application/x-amz-json-1.1")+ .header("Authorization", EnforcementFixtures.auth(key, "logs"))+ .header("X-Amz-Security-Token", token).header("X-Amz-Target", "Logs_20140328.CreateLogGroup")+ .body(body).when().post("/");+ }++ private String group(String action) {+ String name = "logs-group-auth-" + UUID.randomUUID();+ int port = endpoint.getPort();+ cleanup.register(() -> {+ if (find(name) != null) {+ call(port, ACCOUNT, "DeleteLogGroup", Map.of("logGroupName", name)).statusCode(200);+ }+ });+ if (!action.equals("CreateLogGroup")) {+ call(port, ACCOUNT, "CreateLogGroup", Map.of("logGroupName", name)).statusCode(200);+ call(port, ACCOUNT, "PutRetentionPolicy", Map.of("logGroupName", name, "retentionInDays", 7))+ .statusCode(200);+ }+ return name;+ }++ private String user(String statements) {+ return LogsAuthorizationFixtures.user(cleanup, endpoint.getPort(), ACCOUNT, "logs-group-auth-",+ "groups", statements);+ }++ private static String policy(String effect, String action, String resource) {+ return policy(effect, action, resource, "");+ }++ private static String policy(String effect, String action, String resource, String condition) {+ return "{\"Effect\":\"" + effect + "\",\"Action\":\"logs:" + action+ + "\",\"Resource\":\"" + resource + "\"" + condition + "}";+ }++ private static String bareArn(String group) {+ return "arn:aws:logs:" + REGION + ":" + ACCOUNT + ":log-group:" + group;+ }++ private static String arn(String group) {+ return bareArn(group) + ":*";+ }++ private ValidatableResponse operation(String caller, String action, String group) {+ Map<String, ?> body = action.equals("PutRetentionPolicy")+ ? Map.of("logGroupName", group, "retentionInDays", 14) : Map.of("logGroupName", group);+ return call(endpoint.getPort(), caller, action, body);+ }++ private Map<String, Object> find(String group) {+ List<Map<String, Object>> groups = call(endpoint.getPort(), ACCOUNT, "DescribeLogGroups",+ Map.of("logGroupNamePrefix", group)).statusCode(200).extract().path("logGroups");+ return groups.stream().filter(item -> group.equals(item.get("logGroupName"))).findFirst().orElse(null);+ }++ private void assertUnchanged(String action, String group) {+ if (action.equals("CreateLogGroup")) {+ assertNull(find(group));+ } else {+ Map<String, Object> stored = find(group);+ assertNotNull(stored);+ assertEquals(7, stored.get("retentionInDays"));+ }+ }++ private void assertChanged(String action, String group) {+ if (action.equals("DeleteLogGroup")) {+ assertNull(find(group));+ } else {+ Map<String, Object> stored = find(group);+ assertNotNull(stored);+ assertEquals(action.equals("PutRetentionPolicy") ? 14 : null, stored.get("retentionInDays"));+ }+ }++ private static ValidatableResponse call(int port, String caller, String action, Map<String, ?> body) {+ return LogsAuthorizationFixtures.call(port, caller, "20261016", REGION, action, body).then();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/LogsStreamAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/LogsStreamAuthorizationIntegrationTest.javaindex 9d75a9fe8d..2387a7076a 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/LogsStreamAuthorizationIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/LogsStreamAuthorizationIntegrationTest.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.iam;+import io.github.hectorvent.floci.core.common.RequestScopes;import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;import io.github.hectorvent.floci.testing.EnforcementFixtures;import io.github.hectorvent.floci.testing.IamEnforcementProfile;@@ -261,7 +262,7 @@ class LogsStreamAuthorizationIntegrationTest {String group = "logs-key-alias-" + UUID.randomUUID();String protectedGroup = group + "::x";createGroup(ACCOUNT, REGION, group, Map.of("team", "blue"));- createGroup(ACCOUNT, REGION, protectedGroup, Map.of("team", "red"));+ seedHistoricalGroup(protectedGroup, Map.of("team", "red"));seedHistoricalStream(protectedGroup, "s");assertPresent(protectedGroup, "s", true);assertEvent(protectedGroup, "s");@@ -280,7 +281,7 @@ class LogsStreamAuthorizationIntegrationTest {String group = "logs-arn-alias-" + UUID.randomUUID();String actualGroup = group + ":log-stream:x";createGroup(ACCOUNT, REGION, group, Map.of());- createGroup(ACCOUNT, REGION, actualGroup, Map.of());+ seedHistoricalGroup(actualGroup, Map.of());boolean delete = action.equals("DeleteLogStream");if (delete) {seedHistoricalStream(actualGroup, "s");@@ -362,6 +363,11 @@ class LogsStreamAuthorizationIntegrationTest {}/** Existing service storage APIs seed historical invalid names without bypassing the HTTP request under test. */+ private void seedHistoricalGroup(String group, Map<String, String> tags) {+ cleanup.register(() -> RequestScopes.runAs(ACCOUNT, REGION, () -> logsService.deleteLogGroup(group, REGION)));+ logsService.createLogGroupForAccount(ACCOUNT, group, null, tags, REGION);+ }+private void seedHistoricalStream(String group, String stream) {seedHistoricalStream(group, stream, "retained");}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/LogsUnknownRegionAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/LogsUnknownRegionAuthorizationIntegrationTest.javaindex 8acd9aa7f7..2e45242f73 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/LogsUnknownRegionAuthorizationIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/LogsUnknownRegionAuthorizationIntegrationTest.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.iam;+import io.github.hectorvent.floci.core.common.RequestScopes;import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;import io.github.hectorvent.floci.testing.LogsAuthorizationFixtures;import io.github.hectorvent.floci.testing.PartitionCleanup;@@ -93,8 +94,8 @@ class LogsUnknownRegionAuthorizationIntegrationTest {String historicalStream = streamAlias ? "x::" + group + "::s" : "s";String aliasRegion = streamAlias ? REGION + "::" + group + "::x" : REGION + "::x";String validUnknownRegion = "custom-region-1";- cleanup.register(() -> call(port, ACCOUNT, REGION, "DeleteLogGroup", Map.of("logGroupName", historical))- .then().statusCode(200));+ cleanup.register(() -> RequestScopes.runAs(ACCOUNT, REGION,+ () -> logsService.deleteLogGroup(historical, REGION)));cleanup.register(() -> call(port, ACCOUNT, validUnknownRegion, "DeleteLogGroup", Map.of("logGroupName", group)).then().statusCode(200));logsService.createLogGroupForAccount(ACCOUNT, historical, null, Map.of("team", "blue"), REGION);@@ -178,6 +179,43 @@ class LogsUnknownRegionAuthorizationIntegrationTest {});}+ @ParameterizedTest+ @CsvSource({"TagResource,Allow", "TagLogGroup,Allow", "TagResource,Deny", "TagLogGroup,Deny"})+ void taggedGroupCreationUsesCanonicalOwnerForBothAlternatives(String taggingAction, String effect) {+ int port = endpoint.getPort();+ String region = "custom-222222222222";+ String group = "logs-create-owner-" + UUID.randomUUID();+ cleanup.register(() -> {+ List<Map<String, Object>> groups = call(port, ACCOUNT, region, "DescribeLogGroups",+ Map.of("logGroupNamePrefix", group)).then().statusCode(200).extract().path("logGroups");+ if (groups.stream().anyMatch(item -> group.equals(item.get("logGroupName")))) {+ call(port, ACCOUNT, region, "DeleteLogGroup", Map.of("logGroupName", group)).then().statusCode(200);+ }+ });+ String statements = "{\"Effect\":\"Allow\",\"Action\":\"logs:CreateLogGroup\",\"Resource\":\"*\"},";+ if (effect.equals("Deny")) {+ statements += "{\"Effect\":\"Allow\",\"Action\":\"logs:" + taggingAction + "\",\"Resource\":\"*\"},";+ }+ statements += "{\"Effect\":\"" + effect + "\",\"Action\":\"logs:" + taggingAction+ + "\",\"Resource\":\"*\",\"Condition\":{\"StringEquals\":{\"aws:ResourceAccount\":\""+ + ACCOUNT + "\"}}}";+ String caller = LogsAuthorizationFixtures.user(cleanup, port, ACCOUNT, "logs-create-owner-",+ "tagging-owner", statements);+ Response response = call(port, caller, region, "CreateLogGroup",+ Map.of("logGroupName", group, "tags", Map.of("team", "blue")));+ List<Map<String, Object>> groups = call(port, ACCOUNT, region, "DescribeLogGroups",+ Map.of("logGroupNamePrefix", group)).then().statusCode(200).extract().path("logGroups");+ boolean allowed = effect.equals("Allow");+ assertAll("both tagging alternatives use the actual storage owner",+ () -> response.then().statusCode(allowed ? 200 : 400),+ () -> assertEquals(allowed, groups.stream().anyMatch(item -> group.equals(item.get("logGroupName")))),+ () -> {+ if (!allowed) {+ response.then().body(containsString("AccessDeniedException"));+ }+ });+ }+private static void assertPresent(int port, String region, String group, boolean expected) {assertPresent(port, region, group, "s", expected);}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.javaindex 423d3b2328..386cca463a 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.java@@ -655,7 +655,21 @@ class ResourceArnBuilderTest {when(ctx.getHeaderString("X-Amz-Target")).thenReturn("Logs_20140328.DeleteLogGroup");assertEquals(List.of("arn:" + AwsRegions.partitionFor(region)+ ":logs:" + region + ":123456789012:log-group: /group :log-stream:42"),- builder.buildLogStreamResources(action, ctx, region, "123456789012", AwsRegions.partitionFor(region)));+ builder.buildLogResources(action, ctx, region, "123456789012", AwsRegions.partitionFor(region)));+ }+ }+ }++ @Test+ void logGroupTargetsUseTheServingActionAndRequestPartition() {+ for (String action : List.of("logs:CreateLogGroup", "logs:DeleteLogGroup", "logs:PutRetentionPolicy",+ "logs:DeleteRetentionPolicy")) {+ for (String region : List.of("us-east-1", "cn-north-1", "us-gov-west-1")) {+ setJsonBody("{\"logGroupName\":42}");+ when(ctx.getHeaderString("X-Amz-Target")).thenReturn("Logs_20140328.DeleteLogStream");+ assertEquals(List.of("arn:" + AwsRegions.partitionFor(region)+ + ":logs:" + region + ":123456789012:log-group:42:*"),+ builder.buildLogResources(action, ctx, region, "123456789012", AwsRegions.partitionFor(region)));}}}@@ -668,17 +682,16 @@ class ResourceArnBuilderTest {String arn = "arn:" + partition + ":logs:" + region + ":" + ACCOUNT + ":log-group:group";setJsonBody("{\"resourceArn\":\"" + arn + "\"}");when(ctx.getHeaderString("X-Amz-Target")).thenReturn("Logs_20140328.DeleteLogGroup");- assertEquals(List.of(arn), builder.buildLogStreamResources(action, ctx, region, ACCOUNT, partition));+ assertEquals(List.of(arn), builder.buildLogResources(action, ctx, region, ACCOUNT, partition));}}}@Testvoid excludedLogsActionsKeepWildcardResources() {- for (String action : List.of("logs:CreateLogGroup", "logs:DeleteLogGroup", "logs:PutRetentionPolicy",- "logs:DeleteRetentionPolicy", "logs:PutLogEvents")) {+ for (String action : List.of("logs:PutLogEvents")) {setJsonBody("{\"logGroupName\":\"group\",\"logStreamName\":\"stream\"}");- assertEquals(List.of("*"), builder.buildLogStreamResources(action, ctx, "us-east-1", ACCOUNT, "aws"));+ assertEquals(List.of("*"), builder.buildLogResources(action, ctx, "us-east-1", ACCOUNT, "aws"));}}diff --git a/src/test/java/io/github/hectorvent/floci/testing/LogsAuthorizationFixtures.java b/src/test/java/io/github/hectorvent/floci/testing/LogsAuthorizationFixtures.javaindex 8a72820a1c..14d074fe45 100644--- a/src/test/java/io/github/hectorvent/floci/testing/LogsAuthorizationFixtures.java+++ b/src/test/java/io/github/hectorvent/floci/testing/LogsAuthorizationFixtures.java@@ -27,7 +27,11 @@ public final class LogsAuthorizationFixtures {}public static Response call(int port, String caller, String region, String action, Map<String, ?> body) {- String authorization = "AWS4-HMAC-SHA256 Credential=" + caller + "/20261015/" + region+ return call(port, caller, "20261015", region, action, body);+ }++ public static Response call(int port, String caller, String date, String region, String action, Map<String, ?> body) {+ String authorization = "AWS4-HMAC-SHA256 Credential=" + caller + "/" + date + "/" + region+ "/logs/aws4_request, SignedHeaders=host, Signature=abc";return given().port(port).contentType("application/x-amz-json-1.1").header("Authorization", authorization).header("X-Amz-Target", "Logs_20140328." + action)