Light, fluffy, and always free - The AWS Local Emulator alternative
fix(logs): enforce stream resource permissions (#5694)
David Phillipsdbe7fdb92eea
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsStreamAuthorizationTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsStreamAuthorizationTest.javanew file mode 100644index 0000000000..b6e3f95829--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CloudWatchLogsStreamAuthorizationTest.java@@ -0,0 +1,199 @@+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.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.cloudwatchlogs.CloudWatchLogsClient;+import software.amazon.awssdk.services.cloudwatchlogs.model.CloudWatchLogsException;+import software.amazon.awssdk.services.cloudwatchlogs.model.InvalidParameterException;+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;+import static org.junit.jupiter.api.Assertions.assertAll;++@DisplayName("CloudWatch Logs stream resource permissions")+class CloudWatchLogsStreamAuthorizationTest {++ private IamClient iam;+ private CloudWatchLogsClient root;+ private CloudWatchLogsClient caller;+ private String user;+ private AccessKey key;+ private String protectedGroup;+ private String otherGroup;+ private boolean policyCreated;++ @BeforeEach+ void setUp() {+ Assumptions.assumeFalse(TestFixtures.isRealAws(), "Uses emulator account-root credentials");+ iam = TestFixtures.iamClient("000000000000");+ root = client("000000000000", "test");+ String name = TestFixtures.uniqueName("logs-stream-permissions");+ iam.createUser(r -> r.userName(name));+ user = name;+ key = iam.createAccessKey(r -> r.userName(user)).accessKey();+ caller = client(key.accessKeyId(), key.secretAccessKey());+ boolean enforced = false;+ try {+ caller.describeLogGroups();+ } catch (CloudWatchLogsException error) {+ assertDenied(error);+ enforced = true;+ }+ Assumptions.assumeTrue(enforced, "Requires floci.services.iam.enforcement-enabled=true");+ String group = name + "-protected";+ root.createLogGroup(r -> r.logGroupName(group).tags(Map.of("protected", "true")));+ protectedGroup = group;+ String other = name + "-other";+ root.createLogGroup(r -> r.logGroupName(other).tags(Map.of("protected", "false")));+ otherGroup = other;+ }++ @AfterEach+ void cleanUp() {+ assertAll("remove Logs and IAM fixtures and close every client",+ () -> {+ if (protectedGroup != null) {+ root.deleteLogGroup(r -> r.logGroupName(protectedGroup));+ }+ },+ () -> {+ if (otherGroup != null) {+ root.deleteLogGroup(r -> r.logGroupName(otherGroup));+ }+ },+ () -> {+ if (policyCreated) {+ iam.deleteUserPolicy(r -> r.userName(user).policyName("streams"));+ }+ },+ () -> {+ if (key != null) {+ iam.deleteAccessKey(r -> r.userName(user).accessKeyId(key.accessKeyId()));+ }+ },+ () -> {+ if (user != null) {+ iam.deleteUser(r -> r.userName(user));+ }+ },+ () -> {+ if (caller != null) {+ caller.close();+ }+ },+ () -> {+ if (root != null) {+ root.close();+ }+ },+ () -> {+ if (iam != null) {+ iam.close();+ }+ });+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ @DisplayName("exact stream grants do not allow another group's stream")+ void exactStreamPermission(boolean delete) {+ prepare(delete);+ String action = delete ? "DeleteLogStream" : "CreateLogStream";+ String arn = TestFixtures.arn("logs", "000000000000", "log-group:" + protectedGroup + ":log-stream:selected");+ policy("{\"Effect\":\"Allow\",\"Action\":\"logs:" + action + "\",\"Resource\":\"" + arn + "\"}");+ assertThatThrownBy(() -> invoke(delete, otherGroup))+ .isInstanceOfSatisfying(CloudWatchLogsException.class, this::assertDenied);+ assertPresent(otherGroup, delete);+ invoke(delete, protectedGroup);+ assertPresent(protectedGroup, !delete);+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ @DisplayName("a parent-group tag deny overrides wildcard stream permission")+ void parentGroupTagDeny(boolean delete) {+ prepare(delete);+ String action = delete ? "DeleteLogStream" : "CreateLogStream";+ policy("{\"Effect\":\"Allow\",\"Action\":\"logs:" + action + "\",\"Resource\":\"*\"},"+ + "{\"Effect\":\"Deny\",\"Action\":\"logs:" + action + "\",\"Resource\":\"*\","+ + "\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/protected\":\"true\"}}}");+ assertThatThrownBy(() -> invoke(delete, protectedGroup))+ .isInstanceOfSatisfying(CloudWatchLogsException.class, this::assertDenied);+ assertPresent(protectedGroup, delete);+ invoke(delete, otherGroup);+ assertPresent(otherGroup, !delete);+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ @DisplayName("stream name constraints reject aliases and preserve valid Unicode names")+ void nameConstraintsPreventAmbiguousTargets(boolean delete) {+ prepare(delete);+ String action = delete ? "DeleteLogStream" : "CreateLogStream";+ policy("{\"Effect\":\"Allow\",\"Action\":\"logs:" + action + "\",\"Resource\":\"*\"}");+ for (String invalid : new String[]{"", "bad::stream", "bad*stream", "s".repeat(513)}) {+ assertThatThrownBy(() -> invoke(delete, protectedGroup, invalid))+ .isInstanceOfSatisfying(InvalidParameterException.class, error ->+ assertThat(error.statusCode()).isEqualTo(400));+ }+ assertPresent(protectedGroup, delete);+ String maximum = "π".repeat(512);+ if (delete) {+ root.createLogStream(r -> r.logGroupName(protectedGroup).logStreamName(maximum));+ }+ invoke(delete, protectedGroup, maximum);+ assertThat(root.describeLogStreams(r -> r.logGroupName(protectedGroup)).logStreams().stream()+ .anyMatch(stream -> maximum.equals(stream.logStreamName()))).isEqualTo(!delete);+ }++ private void prepare(boolean delete) {+ if (delete) {+ root.createLogStream(r -> r.logGroupName(protectedGroup).logStreamName("selected"));+ root.createLogStream(r -> r.logGroupName(otherGroup).logStreamName("selected"));+ }+ }++ private void policy(String statements) {+ iam.putUserPolicy(r -> r.userName(user).policyName("streams")+ .policyDocument("{\"Version\":\"2012-10-17\",\"Statement\":[" + statements + "]}"));+ policyCreated = true;+ }++ private void invoke(boolean delete, String group) {+ invoke(delete, group, "selected");+ }++ private void invoke(boolean delete, String group, String stream) {+ if (delete) {+ caller.deleteLogStream(r -> r.logGroupName(group).logStreamName(stream));+ } else {+ caller.createLogStream(r -> r.logGroupName(group).logStreamName(stream));+ }+ }++ private void assertPresent(String group, boolean expected) {+ assertThat(root.describeLogStreams(r -> r.logGroupName(group)).logStreams().stream()+ .anyMatch(stream -> "selected".equals(stream.logStreamName()))).isEqualTo(expected);+ }++ private void assertDenied(CloudWatchLogsException error) {+ assertThat(error.statusCode()).isEqualTo(400);+ assertThat(error.awsErrorDetails().errorCode()).contains("AccessDenied");+ }++ private static CloudWatchLogsClient client(String accessKey, String secret) {+ return CloudWatchLogsClient.builder().endpointOverride(TestFixtures.endpoint()).region(TestFixtures.region())+ .credentialsProvider(StaticCredentialsProvider.create(AwsBasicCredentials.create(accessKey, secret)))+ .build();+ }+}diff --git a/docs/services/iam.md b/docs/services/iam.mdindex a59ef0f531..4ed61be371 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -1194,6 +1194,15 @@ These identities always bypass enforcement (backward-compatible defaults):| No `Authorization` header | **Rejected** for a JSON, CBOR or Query management call, unless AWS serves the operation without credentials. Allowed for a REST request such as a health check (see [Unsigned requests](#unsigned-requests)) || Unresolvable IAM action for the request | Allowed β unknown mappings are permissive |+**CloudWatch Logs streams.** `logs:CreateLogStream` and `logs:DeleteLogStream` evaluate the+specific log-stream ARN, so policies can allow or deny one stream within a group. Their+`aws:ResourceTag/<key>` conditions read the owning log group's current tags in the request's+account and region. Both stream operations check the documented group and stream name constraints+before changing storage, preventing delimiter aliases from targeting another stream. Other Logs+actions retain their existing wildcard resource evaluation.+These checks also apply to deletion: legacy streams with names containing `:` or `*` cannot be+deleted through `DeleteLogStream`. Existing stored names are not automatically migrated.+**IAM's own resources are named.** When enforcement evaluates a request, the target resource comesfrom `ResourceArnBuilder`, which builds an ARN for S3, Lambda, SQS, SNS, DynamoDB, Kinesis, SecretsManager, SSM, KMS and IAM. Within IAM the resource type each action is evaluated against is the one@@ -1372,6 +1381,7 @@ floci populates:`ResourceId.N` or `InstanceId.N`), and for `s3:GetBucketTagging`, `s3:DeleteBucketTagging`and `s3:DeleteBucket` (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` and `logs:DeleteLogStream` 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` and `s3:PutObjectTagging`. A `versionId` in the request selects thediff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.javaindex d27dc680ec..859dc6d866 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsJson11Controller.java@@ -314,7 +314,7 @@ public class AwsJson11Controller {case "elasticmapreduce" -> emrHandler.handle(action, request, region);case "wafv2" -> wafV2Handler.handle(action, request, region);case "memorydb" -> memoryDbHandler.handle(action, request, region);- case "logs" -> cloudWatchLogsHandler.handle(action, request, region);+ case "logs" -> cloudWatchLogsHandler.handle(action, request, regionResolver.getRegion());case "secretsmanager" -> secretsManagerJsonHandler.handle(action, request, region,IamEnforcementFilter.requestAuthorization(httpHeaders.getHeaderString("Authorization"), uriInfo.getQueryParameters()));diff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamConditionContextResolver.java b/src/main/java/io/github/hectorvent/floci/core/common/IamConditionContextResolver.javaindex cbdcdd4d9e..97fb5d9261 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@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.core.common;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;import io.github.hectorvent.floci.services.dynamodb.DynamoDbConditionKeys;import io.github.hectorvent.floci.services.dynamodb.DynamoDbFacade;import io.github.hectorvent.floci.services.dynamodb.DynamoDbTableNames;@@ -70,6 +71,7 @@ public class IamConditionContextResolver {private final Instance<DynamoDbFacade> dynamoDbFacade;private final Instance<Ec2Service> ec2Service;private final Instance<S3Service> s3Service;+ private final Instance<CloudWatchLogsService> logsService;private final RequestContext requestContext;private final EmulatorConfig config;@@ -77,11 +79,13 @@ public class IamConditionContextResolver {public IamConditionContextResolver(Instance<DynamoDbFacade> dynamoDbFacade,Instance<Ec2Service> ec2Service,Instance<S3Service> s3Service,+ Instance<CloudWatchLogsService> logsService,RequestContext requestContext,EmulatorConfig config) {this.dynamoDbFacade = dynamoDbFacade;this.ec2Service = ec2Service;this.s3Service = s3Service;+ this.logsService = logsService;this.requestContext = requestContext;this.config = config;}@@ -93,10 +97,40 @@ public class IamConditionContextResolver {case "ec2" -> ec2ConditionContext(action, ctx);case "dynamodb" -> dynamoDbConditionContext(action, ctx);case "iam" -> iamConditionContext(action, ctx);+ case "logs" -> logStreamConditionContext(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) {+ if (!("logs:CreateLogStream".equals(action) || "logs:DeleteLogStream".equals(action))) {+ return null;+ }+ JsonNode body = bufferedJsonBody(ctx);+ if (body == null || !logsService.isResolvable()) {+ return null;+ }+ String region = requestContext.getRegion() == null ? config.defaultRegion() : requestContext.getRegion();+ Map<String, String> tags;+ try {+ tags = logsService.get().listTagsLogGroup(body.path("logGroupName").asText(), region);+ } catch (AwsException e) {+ if (!"ResourceNotFoundException".equals(e.getErrorCode())) {+ throw e;+ }+ // Leave the handler to report a missing group; unexpected lookup errors must not hide a deny.+ return null;+ }+ if (tags == null || tags.isEmpty()) {+ return null;+ }+ Map<String, List<String>> conditions = new LinkedHashMap<>();+ tags.forEach((key, value) -> conditions.put(RESOURCE_TAG_PREFIX + key,+ List.of(value == null ? "" : value)));+ return conditions;+ }+private static Map<String, List<String>> iamConditionContext(String action, ContainerRequestContext ctx) {return switch (action) {case "iam:AttachRolePolicy", "iam:DetachRolePolicy", "iam:AttachUserPolicy",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 e1711dc4a6..7edc6638a0 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@@ -416,7 +416,9 @@ public class IamEnforcementFilter implements ContainerRequestFilter {}List<String> resources = resolveResourceArns(credentialScope,- arnBuilder.buildResources(credentialScope, ctx, region, accountId));+ "logs".equals(credentialScope)+ ? arnBuilder.buildLogStreamResources(action, ctx, region, accountId, requestPartition())+ : arnBuilder.buildResources(credentialScope, ctx, region, accountId));Optional<PresignedScope> presignedScope = iamService.presignedScope(akid);if (presignedScope.isPresent()) {@@ -750,6 +752,10 @@ public class IamEnforcementFilter implements ContainerRequestFilter {for (Map<String, List<String>> targetContext : targetContexts) {Map<String, List<String>> effectiveContext = IamConditionContextResolver.withGlobalContext(targetContext, resource, region, accountId, resourceOwnerAccountId);+ if ("logs".equals(credentialScope)+ && ("logs:CreateLogStream".equals(action) || "logs:DeleteLogStream".equals(action))) {+ effectiveContext.put("aws:ResourceAccount", List.of(accountId));+ }if ("dynamodb".equals(credentialScope)) {Map<String, List<String>> batchContext =conditionContextResolver.dynamoDbBatchConditionContext(action, ctx, resource);diff --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 efe66ca3fe..a32f1d334d 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@@ -22,10 +22,13 @@ import java.util.HashMap;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;+import java.util.regex.Pattern;@ApplicationScopedpublic class CloudWatchLogsHandler {+ private static final Pattern LOG_GROUP_NAME = Pattern.compile("[._/#A-Za-z0-9-]+");+private final CloudWatchLogsService logsService;private final CloudWatchLogsCrossAccountService crossAccountService;private final CloudWatchLogsMetricFilterHandler metricFilterHandler;@@ -248,6 +251,7 @@ public class CloudWatchLogsHandler {private Response handleCreateLogStream(JsonNode request, String region) {String groupName = request.path("logGroupName").asText();String streamName = request.path("logStreamName").asText();+ requireLogStreamNames(groupName, streamName);logsService.createLogStream(groupName, streamName, region);return Response.ok(objectMapper.createObjectNode()).build();}@@ -255,10 +259,21 @@ public class CloudWatchLogsHandler {private Response handleDeleteLogStream(JsonNode request, String region) {String groupName = request.path("logGroupName").asText();String streamName = request.path("logStreamName").asText();+ requireLogStreamNames(groupName, streamName);logsService.deleteLogStream(groupName, streamName, region);return Response.ok(objectMapper.createObjectNode()).build();}+ private static void requireLogStreamNames(String group, String stream) {+ if (group.isEmpty() || group.length() > 512 || !LOG_GROUP_NAME.matcher(group).matches()) {+ throw new AwsException("InvalidParameterException", "Invalid logGroupName.", 400);+ }+ 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);+ }+ }+private Response handleDescribeLogStreams(JsonNode request, String region) {String groupName = resolveLogGroupName(request);String prefix = request.path("logStreamNamePrefix").asText(null);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 6c1d33f5d9..b1ce0e84f0 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@@ -424,6 +424,7 @@ public class CloudWatchLogsService implements ResourceProvider {public Map<String, String> listTagsLogGroup(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));return group.getTags();@@ -439,6 +440,7 @@ public class CloudWatchLogsService implements ResourceProvider {String accountId, String groupName, String streamName, String region) {String groupKey = groupKey(region, groupName);getForAccount(groupStore, accountId, groupKey)+ .filter(stored -> groupName.equals(stored.getLogGroupName())).orElseThrow(() -> new AwsException("ResourceNotFoundException","The specified log group does not exist: " + groupName, 400));@@ -460,6 +462,8 @@ public class CloudWatchLogsService implements ResourceProvider {public void deleteLogStream(String groupName, String streamName, String region) {String streamKey = streamKey(region, groupName, streamName);streamStore.get(streamKey)+ .filter(stored -> groupName.equals(stored.getLogGroupName())+ && streamName.equals(stored.getLogStreamName())).orElseThrow(() -> new AwsException("ResourceNotFoundException","The specified log stream does not exist: " + streamName, 400));@@ -1264,8 +1268,10 @@ public class CloudWatchLogsService implements ResourceProvider {private void deleteEventsForStream(String region, String groupName, String streamName) {String eventPrefix = eventKeyPrefix(region, groupName, streamName);+ String groupPrefix = streamKeyPrefix(region, groupName);List<String> keys = eventStore.keys().stream()- .filter(k -> k.startsWith(eventPrefix))+ .filter(k -> k.startsWith(eventPrefix)+ && streamName.equals(streamNameFromEventKey(k, groupPrefix))).toList();keys.forEach(eventStore::delete);}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 0a42832371..31166b9ea9 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@@ -97,6 +97,23 @@ 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))) {+ return List.of("*");+ }+ JsonNode body = readJsonBody(ctx);+ if (body == null) {+ return List.of("*");+ }+ // 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());+ }+// ββ IAM βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ/** A stored entity's ARN and path, the two things a target ARN is built from. */diff --git a/src/test/java/io/github/hectorvent/floci/core/common/IamConditionContextResolverTest.java b/src/test/java/io/github/hectorvent/floci/core/common/IamConditionContextResolverTest.javaindex e196ef4513..d0e404450c 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/IamConditionContextResolverTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/IamConditionContextResolverTest.java@@ -3,6 +3,7 @@ package io.github.hectorvent.floci.core.common;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.config.EmulatorConfig;+import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;import io.github.hectorvent.floci.services.dynamodb.DynamoDbFacade;import io.github.hectorvent.floci.services.dynamodb.DynamoDbService;import io.github.hectorvent.floci.services.dynamodb.backend.NativeDynamoDbBackend;@@ -36,9 +37,12 @@ import static org.junit.jupiter.api.Assertions.assertArrayEquals;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertSame;+import static org.junit.jupiter.api.Assertions.assertThrows;import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.doThrow;import static org.mockito.Mockito.mock;import static org.mockito.Mockito.verify;import static org.mockito.Mockito.when;@@ -50,6 +54,7 @@ class IamConditionContextResolverTest {private Instance<DynamoDbFacade> dynamoDbFacadeInstance;private Ec2Service ec2Service;private S3Service s3Service;+ private CloudWatchLogsService logsService;private RequestContext requestContext;private EmulatorConfig config;private IamConditionContextResolver resolver;@@ -71,12 +76,55 @@ class IamConditionContextResolverTest {Instance<S3Service> s3ServiceInstance = mock(Instance.class);when(s3ServiceInstance.isResolvable()).thenReturn(true);when(s3ServiceInstance.get()).thenReturn(s3Service);+ logsService = mock(CloudWatchLogsService.class);+ Instance<CloudWatchLogsService> logsServiceInstance = mock(Instance.class);+ when(logsServiceInstance.isResolvable()).thenReturn(true);+ when(logsServiceInstance.get()).thenReturn(logsService);requestContext = new RequestContext();requestContext.setRegion("us-east-1");config = mock(EmulatorConfig.class);when(config.defaultRegion()).thenReturn("us-east-1");resolver = new IamConditionContextResolver(- dynamoDbFacadeInstance, ec2ServiceInstance, s3ServiceInstance, requestContext, config);+ dynamoDbFacadeInstance, ec2ServiceInstance, s3ServiceInstance, logsServiceInstance, requestContext, config);+ }++ @Test+ void logStreamTagsUseRawParentNameAndRequestRegion() throws Exception {+ ContainerRequestContext request = mock(ContainerRequestContext.class);+ when(request.getProperty("floci.bufferedJsonBody"))+ .thenReturn(mapper.readTree("{\"logGroupName\":\" group \",\"logStreamName\":42}"));+ when(logsService.listTagsLogGroup(" group ", "eu-west-1")).thenReturn(Map.of("team", "blue"));+ requestContext.setRegion("eu-west-1");+ for (String action : List.of("logs:CreateLogStream", "logs:DeleteLogStream")) {+ assertEquals(Map.of("aws:ResourceTag/team", List.of("blue")), resolver.resolve("logs", action, request));+ }+ requestContext.setRegion(null);+ when(logsService.listTagsLogGroup(" group ", "us-east-1")).thenReturn(Map.of("team", "red"));+ assertEquals(Map.of("aws:ResourceTag/team", List.of("red")),+ resolver.resolve("logs", "logs:CreateLogStream", request));+ }++ @Test+ void missingLogGroupTagsDoNotReplaceTheHandlersMissingResourceError() throws Exception {+ ContainerRequestContext request = mock(ContainerRequestContext.class);+ when(request.getProperty("floci.bufferedJsonBody")).thenReturn(mapper.readTree("{\"logGroupName\":42}"));+ when(logsService.listTagsLogGroup("42", "us-east-1"))+ .thenThrow(new AwsException("ResourceNotFoundException", "missing", 400));+ assertNull(resolver.resolve("logs", "logs:DeleteLogStream", request));+ }++ @Test+ void unexpectedLogGroupLookupFailuresCannotEraseTagDenies() throws Exception {+ ContainerRequestContext request = mock(ContainerRequestContext.class);+ when(request.getProperty("floci.bufferedJsonBody")).thenReturn(mapper.readTree("{\"logGroupName\":\"group\"}"));+ AwsException failure = new AwsException("InternalFailure", "storage unavailable", 500);+ when(logsService.listTagsLogGroup("group", "us-east-1")).thenThrow(failure);+ assertSame(failure, assertThrows(AwsException.class,+ () -> resolver.resolve("logs", "logs:CreateLogStream", request)));+ IllegalStateException unexpected = new IllegalStateException("unavailable");+ doThrow(unexpected).when(logsService).listTagsLogGroup("group", "us-east-1");+ assertSame(unexpected, assertThrows(IllegalStateException.class,+ () -> resolver.resolve("logs", "logs:DeleteLogStream", request)));}/** A form request whose body can be read again, as a real request's restored stream can. */diff --git a/src/test/java/io/github/hectorvent/floci/services/dynamodb/backend/DynamoDbFacadeTest.java b/src/test/java/io/github/hectorvent/floci/services/dynamodb/backend/DynamoDbFacadeTest.javaindex bed8bea6aa..8a5ab76e00 100644--- a/src/test/java/io/github/hectorvent/floci/services/dynamodb/backend/DynamoDbFacadeTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/dynamodb/backend/DynamoDbFacadeTest.java@@ -152,7 +152,7 @@ class DynamoDbFacadeTest {RequestContext requestContext = new RequestContext();requestContext.setRegion(OTHER_REGION);IamConditionContextResolver resolver = new IamConditionContextResolver(dynamoDb,- mock(Instance.class), mock(Instance.class), requestContext, mock(EmulatorConfig.class));+ mock(Instance.class), mock(Instance.class), mock(Instance.class), requestContext, mock(EmulatorConfig.class));ContainerRequestContext request = mock(ContainerRequestContext.class);JsonNode body = mapper.readTree("""{"TableName": "recorded-table", "Key": {"id": {"S": "USER_alice"}}}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/LogsGovUnknownRegionAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/LogsGovUnknownRegionAuthorizationIntegrationTest.javanew file mode 100644index 0000000000..30ca1d83b3--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/LogsGovUnknownRegionAuthorizationIntegrationTest.java@@ -0,0 +1,13 @@+package io.github.hectorvent.floci.services.iam;++import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;++@QuarkusTest+@TestProfile(LogsNoncommercialUnknownRegionAuthorizationIntegrationTest.GovProfile.class)+class LogsGovUnknownRegionAuthorizationIntegrationTest extends LogsNoncommercialUnknownRegionAuthorizationIntegrationTest {+ @Override+ String deploymentPartition() {+ return "aws-us-gov";+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/LogsNoncommercialUnknownRegionAuthorizationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/LogsNoncommercialUnknownRegionAuthorizationIntegrationTest.javanew file mode 100644index 0000000000..a5791ca27e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/LogsNoncommercialUnknownRegionAuthorizationIntegrationTest.java@@ -0,0 +1,134 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.testing.EnforcementFixtures;+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.QuarkusTestProfile;+import io.quarkus.test.junit.TestProfile;+import io.restassured.response.Response;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.extension.RegisterExtension;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;++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.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;++@QuarkusTest+@TestProfile(LogsNoncommercialUnknownRegionAuthorizationIntegrationTest.ChinaProfile.class)+class LogsNoncommercialUnknownRegionAuthorizationIntegrationTest {+ public static class ChinaProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.iam.enforcement-enabled", "true",+ "floci.partitions.allow-unknown-regions", "true", "floci.default-region", "cn-north-1");+ }+ }++ public static class GovProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.iam.enforcement-enabled", "true",+ "floci.partitions.allow-unknown-regions", "true", "floci.default-region", "us-gov-west-1");+ }+ }++ private static final String ACCOUNT = "111111111111";++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();+ @TestHTTPResource+ URI endpoint;++ @BeforeAll+ static void configureContentTypes() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @ParameterizedTest+ @CsvSource({"CreateLogStream,false,polygondwanaland-west-1", "DeleteLogStream,false,polygondwanaland-west-1",+ "CreateLogStream,true,polygondwanaland-west-1", "DeleteLogStream,true,polygondwanaland-west-1",+ "CreateLogStream,false,cn-north-1", "DeleteLogStream,false,cn-north-1",+ "CreateLogStream,true,cn-north-1", "DeleteLogStream,true,cn-north-1",+ "CreateLogStream,false,us-gov-west-1", "DeleteLogStream,false,us-gov-west-1",+ "CreateLogStream,true,us-gov-west-1", "DeleteLogStream,true,us-gov-west-1",+ "CreateLogStream,false,us-east-1", "DeleteLogStream,false,us-east-1",+ "CreateLogStream,true,us-east-1", "DeleteLogStream,true,us-east-1"})+ void streamPoliciesUseTheSamePartitionAsTheStoredGroup(String action, boolean deny, String region) {+ int port = endpoint.getPort();+ String group = "logs-partition-" + UUID.randomUUID();+ cleanup.register(() -> call(ACCOUNT, region, "DeleteLogGroup", Map.of("logGroupName", group))+ .then().statusCode(200));+ call(ACCOUNT, region, "CreateLogGroup", Map.of("logGroupName", group)).then().statusCode(200);+ String partition = switch (region) {+ case "cn-north-1" -> "aws-cn";+ case "us-gov-west-1" -> "aws-us-gov";+ case "us-east-1" -> "aws";+ default -> deploymentPartition();+ };+ String groupArn = "arn:" + partition + ":logs:" + region + ":" + ACCOUNT + ":log-group:" + group;+ call(ACCOUNT, region, "DescribeLogGroups", Map.of("logGroupNamePrefix", group))+ .then().statusCode(200).body("logGroups[0].arn", equalTo(groupArn + ":*"));+ boolean delete = action.equals("DeleteLogStream");+ if (delete) {+ call(ACCOUNT, region, "CreateLogStream", Map.of("logGroupName", group, "logStreamName", "s"))+ .then().statusCode(200);+ call(ACCOUNT, region, "PutLogEvents", Map.of("logGroupName", group, "logStreamName", "s",+ "logEvents", List.of(Map.of("timestamp", System.currentTimeMillis(), "message", "retained"))))+ .then().statusCode(200);+ }+ String user = "logs-partition-" + UUID.randomUUID();+ String root = EnforcementFixtures.auth(ACCOUNT, "iam");+ String caller = EnforcementFixtures.createUser(cleanup, port, root, user).accessKeyId();+ String allow = deny ? "{\"Effect\":\"Allow\",\"Action\":\"logs:" + action+ + "\",\"Resource\":\"*\"}," : "";+ String effect = deny ? "Deny" : "Allow";+ String statement = "{\"Effect\":\"" + effect + "\",\"Action\":\"logs:" + action+ + "\",\"Resource\":\"" + groupArn + ":log-stream:s\"}";+ given().port(port).header("Authorization", root).formParam("Action", "PutUserPolicy")+ .formParam("UserName", user).formParam("PolicyName", "streams")+ .formParam("PolicyDocument", "{\"Version\":\"2012-10-17\",\"Statement\":[" + allow + statement + "]}")+ .when().post("/").then().statusCode(200);+ Response response = call(caller, region, action, Map.of("logGroupName", group, "logStreamName", "s"));+ assertAll("canonical partition governs the same stream and retained events",+ () -> response.then().statusCode(deny ? 400 : 200),+ () -> {+ if (deny) {+ response.then().body(containsString("AccessDeniedException"));+ }+ },+ () -> {+ List<Map<String, Object>> streams = call(ACCOUNT, region, "DescribeLogStreams",+ Map.of("logGroupName", group)).then().statusCode(200).extract().path("logStreams");+ assertEquals(deny == delete, streams.stream().anyMatch(s -> "s".equals(s.get("logStreamName"))));+ },+ () -> {+ if (deny && delete) {+ call(ACCOUNT, region, "GetLogEvents", Map.of("logGroupName", group, "logStreamName", "s"))+ .then().statusCode(200).body("events[0].message", equalTo("retained"));+ }+ });+ }++ String deploymentPartition() {+ return "aws-cn";+ }++ private Response call(String caller, String region, String action, Map<String, ?> body) {+ String auth = "AWS4-HMAC-SHA256 Credential=" + caller + "/20261015/" + region+ + "/logs/aws4_request, SignedHeaders=host, Signature=abc";+ return given().port(endpoint.getPort()).contentType("application/x-amz-json-1.1")+ .header("Authorization", auth).header("X-Amz-Target", "Logs_20140328." + action)+ .body(body).when().post("/");+ }+}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.javanew file mode 100644index 0000000000..f8a5e97893--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/LogsStreamAuthorizationIntegrationTest.java@@ -0,0 +1,453 @@+package io.github.hectorvent.floci.services.iam;++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.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 io.restassured.specification.RequestSpecification;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeAll;+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.hamcrest.Matchers.hasItem;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertAll;+import static org.junit.jupiter.api.Assertions.assertEquals;++@QuarkusTest+@TestProfile(IamEnforcementProfile.class)+class LogsStreamAuthorizationIntegrationTest {++ 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 = {"CreateLogStream", "DeleteLogStream"})+ void exactStreamPermissionAllowsOnlyThatStream(String action) {+ String group = group(Map.of());+ prepare(action, group, "selected");+ prepare(action, group, "other");+ String caller = user(policy("Allow", action, streamArn(group, "selected"), ""));++ stream(caller, action, group, "other").statusCode(400)+ .body(containsString("AccessDeniedException"));+ assertPresent(group, "other", action.equals("DeleteLogStream"));+ stream(caller, action, group, "selected").statusCode(200);+ assertPresent(group, "selected", action.equals("CreateLogStream"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void groupTagDenyPreventsMutationEvenWithWildcardAllow(String action) {+ String group = group(Map.of("protected", "true"));+ prepare(action, group, "selected");+ String caller = user(policy("Allow", action, "*", "") + ","+ + policy("Deny", action, "*",+ ",\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/protected\":\"true\"}}"));++ stream(caller, action, group, "selected").statusCode(400)+ .body(containsString("AccessDeniedException"));+ assertPresent(group, "selected", action.equals("DeleteLogStream"));+ if (action.equals("DeleteLogStream")) {+ assertEvent(group, "selected");+ }+ for (Map<String, String> tags : List.of(Map.of("protected", "false"), Map.<String, String>of())) {+ String allowed = group(tags);+ prepare(action, allowed, "selected");+ stream(caller, action, allowed, "selected").statusCode(200);+ assertPresent(allowed, "selected", action.equals("CreateLogStream"));+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void resourceTagAllowReadsTheOwningGroup(String action) {+ String group = group(Map.of("team", "blue"));+ String other = group(Map.of("team", "red"));+ String untagged = group(Map.of());+ prepare(action, group, "selected");+ prepare(action, other, "selected");+ prepare(action, untagged, "selected");+ String caller = user(policy("Allow", action, "*",+ ",\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/team\":\"blue\"}}"));++ stream(caller, action, other, "selected").statusCode(400)+ .body(containsString("AccessDeniedException"));+ assertPresent(other, "selected", action.equals("DeleteLogStream"));+ stream(caller, action, untagged, "selected").statusCode(400)+ .body(containsString("AccessDeniedException"));+ assertPresent(untagged, "selected", action.equals("DeleteLogStream"));+ stream(caller, action, group, "selected").statusCode(200);+ assertPresent(group, "selected", action.equals("CreateLogStream"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void exactDenyOverridesWildcardAllowWithoutChangingTheStream(String action) {+ String group = group(Map.of());+ prepare(action, group, "protected");+ prepare(action, group, "allowed");+ String caller = user(policy("Allow", action, "*", "") + ","+ + policy("Deny", action, streamArn(group, "protected"), ""));+ stream(caller, action, group, "protected").statusCode(400)+ .body(containsString("AccessDeniedException"));+ assertPresent(group, "protected", action.equals("DeleteLogStream"));+ if (action.equals("DeleteLogStream")) {+ assertEvent(group, "protected");+ }+ stream(caller, action, group, "allowed").statusCode(200);+ assertPresent(group, "allowed", action.equals("CreateLogStream"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void numericNamesUseTheSameTargetAsTheHandler(String action) {+ String group = group(Map.of());+ prepare(action, group, "42");+ String caller = user(policy("Allow", action, "*", "") + ","+ + policy("Deny", action, streamArn(group, "42"), ""));+ call(endpoint.getPort(), caller, action, Map.of("logGroupName", group, "logStreamName", 42))+ .statusCode(400).body(containsString("AccessDeniedException"));+ assertPresent(group, "42", action.equals("DeleteLogStream"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void sameNamedGroupsKeepTheirAccountAndRegionTags(String action) {+ String group = "logs-stream-scope-" + UUID.randomUUID();+ String otherAccount = "222222222222";+ String otherRegion = "eu-west-1";+ createGroup(ACCOUNT, REGION, group, Map.of("team", "blue"));+ createGroup(ACCOUNT, otherRegion, group, Map.of("team", "red"));+ createGroup(otherAccount, REGION, group, Map.of("team", "red"));+ if (action.equals("DeleteLogStream")) {+ for (String[] scope : List.of(new String[]{ACCOUNT, REGION}, new String[]{ACCOUNT, otherRegion},+ new String[]{otherAccount, REGION})) {+ call(endpoint.getPort(), scope[0], scope[1], "CreateLogStream",+ Map.of("logGroupName", group, "logStreamName", "selected")).statusCode(200);+ }+ }+ String statements = policy("Allow", action, "*",+ ",\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/team\":\"blue\"}}");+ String caller = user(statements);+ String otherCaller = user(otherAccount, statements);+ call(endpoint.getPort(), caller, otherRegion, action,+ Map.of("logGroupName", group, "logStreamName", "selected"))+ .statusCode(400).body(containsString("AccessDeniedException"));+ call(endpoint.getPort(), otherCaller, REGION, action,+ Map.of("logGroupName", group, "logStreamName", "selected"))+ .statusCode(400).body(containsString("AccessDeniedException"));+ assertPresent(ACCOUNT, otherRegion, group, "selected", action.equals("DeleteLogStream"));+ assertPresent(otherAccount, REGION, group, "selected", action.equals("DeleteLogStream"));+ stream(caller, action, group, "selected").statusCode(200);+ assertPresent(group, "selected", action.equals("CreateLogStream"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void missingGroupKeepsTheHandlersResourceNotFoundResponse(String action) {+ String caller = user(policy("Allow", action, "*", ""));+ stream(caller, action, "missing-" + UUID.randomUUID(), "selected")+ .statusCode(400).body(containsString("ResourceNotFoundException"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void queryCredentialsAuthorizeAndMutateTheSameRegion(String action) {+ String group = "logs-query-scope-" + UUID.randomUUID();+ String region = "eu-west-1";+ createGroup(ACCOUNT, REGION, group, Map.of("team", "red"));+ createGroup(ACCOUNT, region, group, Map.of("team", "blue"));+ if (action.equals("DeleteLogStream")) {+ for (String targetRegion : List.of(REGION, region)) {+ call(endpoint.getPort(), ACCOUNT, targetRegion, "CreateLogStream",+ Map.of("logGroupName", group, "logStreamName", "selected")).statusCode(200);+ }+ }+ String resource = "arn:aws:logs:" + region + ":" + ACCOUNT + ":log-group:" + group + ":log-stream:selected";+ String caller = user(policy("Allow", action, resource,+ ",\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/team\":\"blue\"}}"));+ given().port(endpoint.getPort()).contentType("application/x-amz-json-1.1")+ .queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256")+ .queryParam("X-Amz-Credential", caller + "/20261015/" + region + "/logs/aws4_request")+ .queryParam("X-Amz-Signature", "abc")+ .header("X-Amz-Target", "Logs_20140328." + action)+ .body(Map.of("logGroupName", group, "logStreamName", "selected"))+ .when().post("/").then().statusCode(200);+ assertPresent(ACCOUNT, REGION, group, "selected", action.equals("DeleteLogStream"));+ assertPresent(ACCOUNT, region, group, "selected", action.equals("CreateLogStream"));+ // A real Authorization header remains authoritative over conflicting query credentials.+ given().port(endpoint.getPort()).contentType("application/x-amz-json-1.1")+ .header("Authorization", EnforcementFixtures.auth(caller, "logs"))+ .queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256")+ .queryParam("X-Amz-Credential", caller + "/20261015/" + region + "/logs/aws4_request")+ .header("X-Amz-Target", "Logs_20140328." + action)+ .body(Map.of("logGroupName", group, "logStreamName", "selected"))+ .when().post("/").then().statusCode(400).body(containsString("AccessDeniedException"));+ assertPresent(ACCOUNT, REGION, group, "selected", action.equals("DeleteLogStream"));+ assertPresent(ACCOUNT, region, group, "selected", action.equals("CreateLogStream"));+ }++ @ParameterizedTest+ @CsvSource({"CreateLogStream,blank-header", "DeleteLogStream,blank-header",+ "CreateLogStream,missing-algorithm", "DeleteLogStream,missing-algorithm"})+ void credentialEdgeCasesKeepTheCanonicalRequestRegion(String action, String mode) {+ String account = "000000000000";+ String remote = "eu-west-1";+ String group = "logs-query-edge-" + UUID.randomUUID();+ boolean blankHeader = mode.equals("blank-header");+ String selectedRegion = blankHeader ? remote : REGION;+ String otherRegion = blankHeader ? REGION : remote;+ createGroup(account, selectedRegion, group, Map.of("team", "blue"));+ createGroup(account, otherRegion, group, Map.of("team", "red"));+ if (action.equals("DeleteLogStream")) {+ for (String region : List.of(REGION, remote)) {+ call(endpoint.getPort(), account, region, "CreateLogStream",+ Map.of("logGroupName", group, "logStreamName", "selected")).statusCode(200);+ }+ }+ String resource = "arn:aws:logs:" + selectedRegion + ":" + account+ + ":log-group:" + group + ":log-stream:selected";+ String caller = user(account, policy("Allow", action, resource,+ ",\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/team\":\"blue\"}}"));+ RequestSpecification request = given().port(endpoint.getPort()).contentType("application/x-amz-json-1.1")+ .queryParam("X-Amz-Credential", caller + "/20261015/" + remote + "/logs/aws4_request")+ .queryParam("X-Amz-Signature", "abc")+ .header("X-Amz-Target", "Logs_20140328." + action)+ .body(Map.of("logGroupName", group, "logStreamName", "selected"));+ if (blankHeader) {+ request.header("Authorization", "").queryParam("X-Amz-Algorithm", "AWS4-HMAC-SHA256");+ }+ request.when().post("/").then().statusCode(200);+ assertPresent(account, otherRegion, group, "selected", action.equals("DeleteLogStream"));+ assertPresent(account, selectedRegion, group, "selected", action.equals("CreateLogStream"));+ }++ @ParameterizedTest+ @ValueSource(booleans = {false, true})+ void storageKeyAliasesCannotDeleteAnotherGroupsStream(boolean exactGrant) {+ 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"));+ seedHistoricalStream(protectedGroup, "s");+ assertPresent(protectedGroup, "s", true);+ assertEvent(protectedGroup, "s");+ String caller = user(policy("Allow", "DeleteLogStream", exactGrant ? streamArn(group, "x::s") : "*",+ ",\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/team\":\"blue\"}}"));+ Response response = stream(caller, "DeleteLogStream", group, "x::s").extract().response();+ assertAll("reject storage alias and retain historical stream and event",+ () -> response.then().statusCode(400).body(containsString("InvalidParameterException")),+ () -> assertPresent(protectedGroup, "s", true),+ () -> assertEvent(protectedGroup, "s"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void arnDelimiterAliasesCannotGrantAccessToAnotherGroup(String action) {+ 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());+ boolean delete = action.equals("DeleteLogStream");+ if (delete) {+ seedHistoricalStream(actualGroup, "s");+ }+ prepare(action, group, "safe");+ assertPresent(actualGroup, "s", delete);+ String caller = user(policy("Allow", action, streamArn(group, "x:log-stream:s"), "")+ + "," + policy("Allow", action, streamArn(group, "safe"), ""));+ Response response = stream(caller, action, actualGroup, "s").extract().response();+ assertAll("reject ambiguous ARN identity without changing the stored target",+ () -> response.then().statusCode(400).body(containsString("InvalidParameterException")),+ () -> assertPresent(actualGroup, "s", delete),+ () -> {+ if (delete) {+ assertEvent(actualGroup, "s");+ }+ });+ stream(caller, action, group, "safe").statusCode(200);+ assertPresent(group, "safe", !delete);+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void publicStreamNamesFollowTheDocumentedConstraints(String action) {+ String group = group(Map.of());+ String caller = user(policy("Allow", action, "*", ""));+ prepare(action, group, "selected");+ for (String invalid : List.of("", "bad:group", "bad*group", "bad group", "g".repeat(513))) {+ stream(caller, action, invalid, "selected").statusCode(400)+ .body(containsString("InvalidParameterException"));+ }+ for (String invalid : List.of("", "bad:stream", "bad*stream", "s".repeat(513))) {+ stream(caller, action, group, invalid).statusCode(400)+ .body(containsString("InvalidParameterException"));+ }+ assertPresent(group, "selected", action.equals("DeleteLogStream"));+ if (action.equals("DeleteLogStream")) {+ assertEvent(group, "selected");+ }+ stream(caller, action, group, "selected").statusCode(200);+ assertPresent(group, "selected", action.equals("CreateLogStream"));+ }++ @ParameterizedTest+ @ValueSource(strings = {"CreateLogStream", "DeleteLogStream"})+ void maximumLengthAndWhitespaceStreamNamesRemainUsable(String action) {+ String prefix = "logs-name-boundary-" + UUID.randomUUID();+ String group = prefix + "g".repeat(512 - prefix.length());+ createGroup(ACCOUNT, REGION, group, Map.of());+ String caller = user(policy("Allow", action, "*", ""));+ for (String stream : List.of("s", " ", "π".repeat(512))) {+ prepare(action, group, stream);+ stream(caller, action, group, stream).statusCode(200);+ assertPresent(group, stream, action.equals("CreateLogStream"));+ }+ }++ @ParameterizedTest+ @ValueSource(strings = {"s::child", "s::child::nested"})+ void deletingAnAuthorizedStreamPreservesHistoricalSiblingEvents(String sibling) {+ String group = group(Map.of());+ seedHistoricalStream(group, "s", "selected-event");+ seedHistoricalStream(group, sibling, "protected-sibling-event");+ assertPresent(group, "s", true);+ assertPresent(group, sibling, true);+ call(endpoint.getPort(), ACCOUNT, "GetLogEvents", Map.of("logGroupName", group, "logStreamName", sibling))+ .statusCode(200).body("events[0].message", equalTo("protected-sibling-event"));+ String caller = user(policy("Allow", "DeleteLogStream", streamArn(group, "s"), ""));+ stream(caller, "DeleteLogStream", group, "s").statusCode(200);+ assertAll("delete only the selected stream and its emitted events",+ () -> assertPresent(group, "s", false),+ () -> assertPresent(group, sibling, true),+ () -> call(endpoint.getPort(), ACCOUNT, "GetLogEvents",+ Map.of("logGroupName", group, "logStreamName", sibling))+ .statusCode(200).body("events[0].message", equalTo("protected-sibling-event")),+ () -> call(endpoint.getPort(), ACCOUNT, "GetLogEvents",+ Map.of("logGroupName", group, "logStreamName", "s"))+ .statusCode(200).body("events.message", not(hasItem("selected-event"))));+ }++ /** Existing service storage APIs seed historical invalid names without bypassing the HTTP request under test. */+ private void seedHistoricalStream(String group, String stream) {+ seedHistoricalStream(group, stream, "retained");+ }++ private void seedHistoricalStream(String group, String stream, String message) {+ logsService.createLogStreamForAccount(ACCOUNT, group, stream, REGION);+ logsService.putLogEventsForAccount(ACCOUNT, group, stream,+ List.of(Map.of("timestamp", System.currentTimeMillis(), "message", message)), REGION);+ }++ private void prepare(String action, String group, String name) {+ if (action.equals("DeleteLogStream")) {+ stream(ACCOUNT, "CreateLogStream", group, name).statusCode(200);+ call(endpoint.getPort(), ACCOUNT, "PutLogEvents", Map.of("logGroupName", group,+ "logStreamName", name, "logEvents", List.of(Map.of("timestamp", System.currentTimeMillis(),+ "message", "retained")))).statusCode(200);+ }+ }++ private String group(Map<String, String> tags) {+ String group = "logs-stream-auth-" + UUID.randomUUID();+ createGroup(ACCOUNT, REGION, group, tags);+ return group;+ }++ private void createGroup(String account, String region, String group, Map<String, String> tags) {+ int port = endpoint.getPort();+ cleanup.register(() -> call(port, account, region, "DeleteLogGroup", Map.of("logGroupName", group))+ .statusCode(200));+ call(port, account, region, "CreateLogGroup", Map.of("logGroupName", group, "tags", tags)).statusCode(200);+ }++ private String user(String statements) {+ return user(ACCOUNT, statements);+ }++ private String user(String account, String statements) {+ int port = endpoint.getPort();+ String name = "logs-stream-auth-" + UUID.randomUUID();+ String root = EnforcementFixtures.auth(account, "iam");+ EnforcementFixtures.UserCredentials credentials = EnforcementFixtures.createUser(cleanup, port, root, name);+ given().port(port).header("Authorization", root).formParam("Action", "PutUserPolicy")+ .formParam("UserName", name).formParam("PolicyName", "streams")+ .formParam("PolicyDocument", "{\"Version\":\"2012-10-17\",\"Statement\":[" + statements + "]}")+ .when().post("/").then().statusCode(200);+ return credentials.accessKeyId();+ }++ private static String policy(String effect, String action, String resource, String condition) {+ return "{\"Effect\":\"" + effect + "\",\"Action\":\"logs:" + action+ + "\",\"Resource\":\"" + resource + "\"" + condition + "}";+ }++ private static String streamArn(String group, String stream) {+ return "arn:aws:logs:" + REGION + ":" + ACCOUNT + ":log-group:" + group + ":log-stream:" + stream;+ }++ private ValidatableResponse stream(String caller, String action, String group, String stream) {+ return call(endpoint.getPort(), caller, action, Map.of("logGroupName", group, "logStreamName", stream));+ }++ private void assertPresent(String group, String stream, boolean expected) {+ assertPresent(ACCOUNT, REGION, group, stream, expected);+ }++ private void assertEvent(String group, String stream) {+ call(endpoint.getPort(), ACCOUNT, "GetLogEvents", Map.of("logGroupName", group, "logStreamName", stream))+ .statusCode(200).body("events[0].message", equalTo("retained"));+ }++ private void assertPresent(String account, String region, String group, String stream, boolean expected) {+ List<Map<String, Object>> streams = call(endpoint.getPort(), account, region, "DescribeLogStreams",+ Map.of("logGroupName", group)).statusCode(200).extract().path("logStreams");+ assertEquals(expected, streams.stream().anyMatch(item -> stream.equals(item.get("logStreamName"))));+ }++ private static ValidatableResponse call(int port, String caller, String action, Map<String, ?> body) {+ return call(port, caller, REGION, action, body);+ }++ private static ValidatableResponse call(int port, String caller, String region, String action, Map<String, ?> body) {+ String authorization = "AWS4-HMAC-SHA256 Credential=" + caller + "/20261015/" + 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)+ .body(new LinkedHashMap<>(body)).when().post("/").then();+ }+}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.javanew file mode 100644index 0000000000..69e28ef1c6--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/LogsUnknownRegionAuthorizationIntegrationTest.java@@ -0,0 +1,179 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.services.cloudwatch.logs.CloudWatchLogsService;+import io.github.hectorvent.floci.testing.EnforcementFixtures;+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.QuarkusTestProfile;+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.extension.RegisterExtension;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;++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.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;++@QuarkusTest+@TestProfile(LogsUnknownRegionAuthorizationIntegrationTest.UnknownRegionProfile.class)+class LogsUnknownRegionAuthorizationIntegrationTest {++ public static class UnknownRegionProfile implements QuarkusTestProfile {+ @Override+ public Map<String, String> getConfigOverrides() {+ return Map.of("floci.services.iam.enforcement-enabled", "true",+ "floci.partitions.allow-unknown-regions", "true");+ }+ }++ 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+ @CsvSource({"CreateLogStream,false,false", "DeleteLogStream,false,false", "CreateLogStream,true,false",+ "DeleteLogStream,true,false", "DeleteLogStream,false,true"})+ void optedInRegionLabelsCannotAliasHistoricalGroupNames(String action, boolean conditional, boolean streamAlias) {+ int port = endpoint.getPort();+ String group = "logs-region-alias-" + UUID.randomUUID();+ String historical = streamAlias ? group : "x::" + group;+ 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(() -> call(port, ACCOUNT, validUnknownRegion, "DeleteLogGroup", Map.of("logGroupName", group))+ .then().statusCode(200));+ logsService.createLogGroupForAccount(ACCOUNT, historical, null, Map.of("team", "blue"), REGION);+ logsService.createLogGroupForAccount(ACCOUNT, group, null, Map.of("team", "blue"), validUnknownRegion);+ boolean delete = action.equals("DeleteLogStream");+ if (delete) {+ for (String[] target : List.of(new String[]{historical, REGION, historicalStream},+ new String[]{group, validUnknownRegion, "s"})) {+ logsService.createLogStreamForAccount(ACCOUNT, target[0], target[2], target[1]);+ logsService.putLogEventsForAccount(ACCOUNT, target[0], target[2],+ List.of(Map.of("timestamp", System.currentTimeMillis(), "message", "retained")), target[1]);+ }+ }+ assertPresent(port, REGION, historical, historicalStream, delete);+ String user = "logs-region-alias-" + UUID.randomUUID();+ String root = EnforcementFixtures.auth(ACCOUNT, "iam");+ String caller = EnforcementFixtures.createUser(cleanup, port, root, user).accessKeyId();+ String condition = conditional ? ",\"Condition\":{\"StringEquals\":{\"aws:ResourceTag/team\":\"blue\"}}" : "";+ String resources = "[\"arn:aws:logs:" + aliasRegion + ":" + ACCOUNT + ":log-group:" + group+ + ":log-stream:s\",\"arn:aws:logs:" + validUnknownRegion + ":" + ACCOUNT+ + ":log-group:" + group + ":log-stream:s\"]";+ given().port(port).header("Authorization", root).formParam("Action", "PutUserPolicy")+ .formParam("UserName", user).formParam("PolicyName", "streams")+ .formParam("PolicyDocument", "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\","+ + "\"Action\":\"logs:" + action + "\",\"Resource\":" + resources + condition + "}]}")+ .when().post("/").then().statusCode(200);+ Response response = call(port, caller, aliasRegion, action,+ Map.of("logGroupName", group, "logStreamName", "s"));+ assertAll("preserve stored identity across an opted-in region delimiter",+ () -> response.then().statusCode(400).body(containsString(+ conditional ? "AccessDeniedException" : "ResourceNotFoundException")),+ () -> assertPresent(port, REGION, historical, historicalStream, delete),+ () -> {+ if (delete) {+ call(port, ACCOUNT, REGION, "GetLogEvents",+ Map.of("logGroupName", historical, "logStreamName", historicalStream))+ .then().statusCode(200).body("events[0].message", equalTo("retained"));+ }+ });+ call(port, caller, validUnknownRegion, action, Map.of("logGroupName", group, "logStreamName", "s"))+ .then().statusCode(200);+ assertPresent(port, validUnknownRegion, group, !delete);+ }++ @ParameterizedTest+ @CsvSource({"CreateLogStream,Allow,false", "DeleteLogStream,Allow,false",+ "CreateLogStream,Allow,true", "DeleteLogStream,Allow,true",+ "CreateLogStream,Deny,false", "DeleteLogStream,Deny,false",+ "CreateLogStream,Deny,true", "DeleteLogStream,Deny,true"})+ void resourceAccountUsesStorageOwnerInOptedInRegion(String action, String effect, boolean actualOwner) {+ int port = endpoint.getPort();+ String otherAccount = "222222222222";+ String region = "custom:" + otherAccount;+ String group = "logs-resource-owner-" + UUID.randomUUID();+ cleanup.register(() -> call(port, ACCOUNT, region, "DeleteLogGroup", Map.of("logGroupName", group))+ .then().statusCode(200));+ logsService.createLogGroupForAccount(ACCOUNT, group, null, null, region);+ boolean delete = action.equals("DeleteLogStream");+ if (delete) {+ logsService.createLogStreamForAccount(ACCOUNT, group, "s", region);+ logsService.putLogEventsForAccount(ACCOUNT, group, "s",+ List.of(Map.of("timestamp", System.currentTimeMillis(), "message", "retained")), region);+ }+ String user = "logs-resource-owner-" + UUID.randomUUID();+ String root = EnforcementFixtures.auth(ACCOUNT, "iam");+ String caller = EnforcementFixtures.createUser(cleanup, port, root, user).accessKeyId();+ String grant = effect.equals("Deny")+ ? "{\"Effect\":\"Allow\",\"Action\":\"logs:" + action + "\",\"Resource\":\"*\"}," : "";+ String owner = actualOwner ? ACCOUNT : otherAccount;+ String statement = "{\"Effect\":\"" + effect + "\",\"Action\":\"logs:" + action+ + "\",\"Resource\":\"*\",\"Condition\":{\"StringEquals\":{\"aws:ResourceAccount\":\""+ + owner + "\"}}}";+ given().port(port).header("Authorization", root).formParam("Action", "PutUserPolicy")+ .formParam("UserName", user).formParam("PolicyName", "streams")+ .formParam("PolicyDocument", "{\"Version\":\"2012-10-17\",\"Statement\":[" + grant + statement + "]}")+ .when().post("/").then().statusCode(200);+ boolean allowed = effect.equals("Allow") == actualOwner;+ Response response = call(port, caller, region, action, Map.of("logGroupName", group, "logStreamName", "s"));+ assertAll("use the canonical account independently of region punctuation",+ () -> response.then().statusCode(allowed ? 200 : 400),+ () -> assertPresent(port, region, group, allowed != delete),+ () -> {+ if (!allowed) {+ response.then().body(containsString("AccessDeniedException"));+ if (delete) {+ call(port, ACCOUNT, region, "GetLogEvents",+ Map.of("logGroupName", group, "logStreamName", "s"))+ .then().statusCode(200).body("events[0].message", equalTo("retained"));+ }+ }+ });+ }++ private static void assertPresent(int port, String region, String group, boolean expected) {+ assertPresent(port, region, group, "s", expected);+ }++ private static void assertPresent(int port, String region, String group, String name, boolean expected) {+ List<Map<String, Object>> streams = call(port, ACCOUNT, region, "DescribeLogStreams",+ Map.of("logGroupName", group)).then().statusCode(200).extract().path("logStreams");+ assertEquals(expected, streams.stream().anyMatch(stream -> name.equals(stream.get("logStreamName"))));+ }++ private static Response call(int port, String caller, String region, String action, Map<String, ?> body) {+ String auth = "AWS4-HMAC-SHA256 Credential=" + caller + "/20261015/" + region+ + "/logs/aws4_request, SignedHeaders=host, Signature=abc";+ return given().port(port).contentType("application/x-amz-json-1.1").header("Authorization", auth)+ .header("X-Amz-Target", "Logs_20140328." + action).body(body).when().post("/");+ }+}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 f64fe2a854..2b38fcd593 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@@ -1,6 +1,7 @@package io.github.hectorvent.floci.services.iam;import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsRegions;import io.github.hectorvent.floci.core.common.RegionResolver;import io.github.hectorvent.floci.core.common.RequestContext;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;@@ -646,6 +647,28 @@ class ResourceArnBuilderTest {}).when(ctx).setEntityStream(any(InputStream.class));}+ @Test+ void logStreamTargetsUseTheServingActionAndRequestPartition() {+ for (String action : List.of("logs:CreateLogStream", "logs:DeleteLogStream")) {+ for (String region : List.of("us-east-1", "cn-north-1", "us-gov-west-1")) {+ setJsonBody("{\"logGroupName\":\" /group \",\"logStreamName\":42}");+ 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)));+ }+ }+ }++ @Test+ void excludedLogsActionsKeepWildcardResources() {+ for (String action : List.of("logs:CreateLogGroup", "logs:DeleteLogGroup", "logs:PutRetentionPolicy",+ "logs:TagResource", "logs:UntagResource", "logs:ListTagsForResource", "logs:PutLogEvents")) {+ setJsonBody("{\"logGroupName\":\"group\",\"logStreamName\":\"stream\"}");+ assertEquals(List.of("*"), builder.buildLogStreamResources(action, ctx, "us-east-1", ACCOUNT, "aws"));+ }+ }+// ββ DynamoDB βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ@Test