Light, fluffy, and always free - The AWS Local Emulator alternative
fix(core): route a shared Query action name by the Version it declares (#5549)
Priamo Germosen8a87e062c824
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex ea95d8df3d..d3a9339a74 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java@@ -34,22 +34,18 @@ import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.Response;import org.jboss.logging.Logger;+import java.util.List;import java.util.Set;import java.util.UUID;+import java.util.stream.Collectors;+import java.util.stream.Stream;/*** Generic dispatcher for all AWS services that use the Query Protocol (form-encoded POST, XML response).* Routes requests to the appropriate service handler based on the service name extracted from the- * Authorization header's credential scope, falling back to action-name matching when no auth header- * is present.- *- * <p>Currently supported services:- * <ul>- * <li>SQS — form-encoded query protocol</li>- * <li>SNS — form-encoded query protocol</li>- * <li>IAM — form-encoded query protocol (global service)</li>- * <li>STS — form-encoded query protocol (global service)</li>- * </ul>+ * Authorization header's credential scope. When there is no such header, or its scope names no+ * service that speaks the Query protocol, the action name and the {@code Version} the request+ * declares decide instead, as {@link #inferServiceFromAction} describes.** @see AwsJsonController*/@@ -162,7 +158,7 @@ public class AwsQueryController {"PutScalingPolicy", "DeletePolicy", "DescribePolicies","DescribeScalingActivities","DescribeAutoScalingNotificationTypes", "DescribeTerminationPolicyTypes",- "DescribeAdjustmentTypes", "DescribeAccountLimits",+ "DescribeAdjustmentTypes", "DescribeAccountLimits", "DescribeLoadBalancers","DescribeLifecycleHookTypes", "DescribeMetricCollectionTypes","EnableMetricsCollection", "DisableMetricsCollection");@@ -311,7 +307,7 @@ public class AwsQueryController {"The request must contain the parameter Action", 400);}- String service = serviceResolver.resolve(authorization, action);+ String service = serviceResolver.resolve(authorization, action, formParams.getFirst("Version"));LOG.debugv("Query protocol service={0} action={1}", service, action);String region = regionResolver.resolveRegion(httpHeaders);@@ -530,17 +526,13 @@ public class AwsQueryController {return Response.status(400).entity(xml).type(MediaType.APPLICATION_XML).build();}- /**- * Determines the target AWS service. Prefers the service name embedded in the- * Authorization header credential scope. Falls back to action-name lookup when- * the header is absent (e.g. raw HTTP testing without AWS SDK auth).- */private static final Set<String> ELASTICACHE_ACTIONS = Set.of("ValidateIamAuthToken","CreateReplicationGroup", "DescribeReplicationGroups", "ModifyReplicationGroup", "DeleteReplicationGroup","CreateUser", "DescribeUsers", "ModifyUser", "DeleteUser","CreateUserGroup", "DescribeUserGroups", "ModifyUserGroup", "DeleteUserGroup",- "CreateServerlessCache", "DescribeServerlessCaches", "ModifyServerlessCache", "DeleteServerlessCache"+ "CreateServerlessCache", "DescribeServerlessCaches", "ModifyServerlessCache", "DeleteServerlessCache",+ "ListTagsForResource");private static final Set<String> CLOUDWATCH_ACTIONS = Set.of(@@ -654,53 +646,87 @@ public class AwsQueryController {"GetClusterCredentials", "GetClusterCredentialsWithIAM");- static String inferServiceFromAction(String action) {- if (STS_ACTIONS.contains(action)) {- return "sts";- }- if (IAM_ACTIONS.contains(action)) {- return "iam";- }- if (SNS_ACTIONS.contains(action)) {- return "sns";- }- if (ELASTICACHE_ACTIONS.contains(action)) {- return "elasticache";- }- if (RDS_ACTIONS.contains(action)) {- return "rds";- }- if (CLOUDWATCH_ACTIONS.contains(action)) {- return "monitoring";- }- if (CLOUDFORMATION_ACTIONS.contains(action)) {- return "cloudformation";- }- if (SES_ACTIONS.contains(action)) {- return "email";- }- if (COGNITO_ACTIONS.contains(action)) {- return "cognito-idp";- }- if (EC2_ACTIONS.contains(action)) {- return "ec2";- }- if (ELB_V2_ACTIONS.contains(action)- || ElbClassicQueryHandler.CLASSIC_ONLY_ACTIONS.contains(action)) {- return "elasticloadbalancing";- }- if (AUTOSCALING_ACTIONS.contains(action)) {- return "autoscaling";- }- if (ELASTIC_BEANSTALK_ACTIONS.contains(action)) {- return "elasticbeanstalk";- }- if (REDSHIFT_ACTIONS.contains(action)) {- return "redshift";+ /**+ * Tried last, so by name alone SQS takes only what no other service defines, as it takes a name+ * nobody defines. Its {@code Version} is what wins back the two names SNS also defines.+ */+ private static final Set<String> SQS_ACTIONS = Set.of(+ "CreateQueue", "DeleteQueue", "ListQueues", "GetQueueUrl",+ "GetQueueAttributes", "SetQueueAttributes", "PurgeQueue",+ "SendMessage", "SendMessageBatch", "ReceiveMessage", "DeleteMessage", "DeleteMessageBatch",+ "ChangeMessageVisibility", "ChangeMessageVisibilityBatch",+ "TagQueue", "UntagQueue", "ListQueueTags", "ListDeadLetterSourceQueues",+ "StartMessageMoveTask", "ListMessageMoveTasks", "CancelMessageMoveTask",+ "AddPermission", "RemovePermission"+ );++ /** ELBv2's names and Classic's own. A name both APIs define is split by {@link #isElbClassicRequest}. */+ private static final Set<String> ELB_ACTIONS = Stream.concat(+ ELB_V2_ACTIONS.stream(), ElbClassicQueryHandler.CLASSIC_ONLY_ACTIONS.stream())+ .collect(Collectors.toUnmodifiableSet());++ /** A Query service, the API versions its clients declare, and the action names it serves. */+ private record QueryService(String name, Set<String> apiVersions, Set<String> actions) {+ }++ /**+ * Every Query service, in the order they are tried when the action name alone has to decide:+ * where two services define the same name, the earlier one takes it.+ *+ * <p>An API version is the {@code apiVersion} of the service's model. SES and Elastic Beanstalk+ * publish the same one and share no action name, so the action settles which of the two a+ * request is for. Both Elastic Load Balancing APIs lead to one service here and+ * {@link #isElbClassicRequest} splits them on the same field, and DocumentDB and Neptune publish+ * RDS's version and are split from it in the {@code rds} case. Cognito's model is JSON only, so+ * no Query client declares a version for it.+ */+ private static final List<QueryService> QUERY_SERVICES = List.of(+ new QueryService("sts", Set.of("2011-06-15"), STS_ACTIONS),+ new QueryService("iam", Set.of("2010-05-08"), IAM_ACTIONS),+ new QueryService("sns", Set.of("2010-03-31"), SNS_ACTIONS),+ new QueryService("elasticache", Set.of("2015-02-02"), ELASTICACHE_ACTIONS),+ new QueryService("rds", Set.of("2014-10-31"), RDS_ACTIONS),+ new QueryService("monitoring", Set.of("2010-08-01"), CLOUDWATCH_ACTIONS),+ new QueryService("cloudformation", Set.of("2010-05-15"), CLOUDFORMATION_ACTIONS),+ new QueryService("email", Set.of("2010-12-01"), SES_ACTIONS),+ new QueryService("cognito-idp", Set.of(), COGNITO_ACTIONS),+ new QueryService("ec2", Set.of("2016-11-15"), EC2_ACTIONS),+ new QueryService("elasticloadbalancing",+ Set.of(ELB_V2_API_VERSION, ELB_CLASSIC_API_VERSION), ELB_ACTIONS),+ new QueryService("autoscaling", Set.of("2011-01-01"), AUTOSCALING_ACTIONS),+ new QueryService("elasticbeanstalk", Set.of("2010-12-01"), ELASTIC_BEANSTALK_ACTIONS),+ new QueryService("redshift", Set.of("2012-12-01"), REDSHIFT_ACTIONS),+ new QueryService("sqs", Set.of("2012-11-05"), SQS_ACTIONS));++ /**+ * The service a Query request goes to when its credential scope does not name one.+ *+ * <p>The action name alone is ambiguous wherever two services define it, and then the earlier+ * one in {@link #QUERY_SERVICES} wins. The {@code Version} every Query client sends is what+ * tells them apart, as {@link #isElbClassicRequest} already uses it for the two Elastic Load+ * Balancing APIs: {@code CreateUser} under IAM's version is IAM's, and under ElastiCache's it+ * is ElastiCache's.+ *+ * <p>{@code Version} only chooses among the services that serve the name. One that names a+ * service without it, or none at all, leaves the order to decide, so a hand-rolled request that+ * omits the field goes exactly where it went before.+ */+ static String inferServiceFromAction(String action, String version) {+ String byName = null;+ for (QueryService service : QUERY_SERVICES) {+ if (!service.actions().contains(action)) {+ continue;+ }+ if (version != null && service.apiVersions().contains(version)) {+ return service.name();+ }+ if (byName == null) {+ byName = service.name();+ }}- // SQS actions are numerous and not enumerated — fall back to sqs only for- // requests that arrived without an Authorization header (raw/test clients)- return "sqs";+ // A name no service defines goes to SQS, which is how a raw SQS request without an+ // Authorization header gets there.+ return byName != null ? byName : "sqs";}private Response xmlErrorResponse(String code, String message, int status) {diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryServiceResolver.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryServiceResolver.javaindex 69c58d81a1..9431585f7e 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryServiceResolver.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryServiceResolver.java@@ -19,14 +19,19 @@ public class AwsQueryServiceResolver {this.catalog = catalog;}- public String resolve(String authorization, String action) {+ /**+ * The service named by a Query-capable signing scope, else the one the action and the request's+ * declared {@code Version} lead to. Both callers read {@code Version} from the form body, as they+ * do the action, so they cannot disagree about which service a request is for.+ */+ public String resolve(String authorization, String action, String version) {ServiceDescriptor descriptor = SigV4CredentialScope.serviceName(authorization).flatMap(catalog::byCredentialScope).orElse(null);if (descriptor != null && descriptor.supportsProtocol(ServiceProtocol.QUERY)) {return descriptor.externalKey();}- return AwsQueryController.inferServiceFromAction(action);+ return AwsQueryController.inferServiceFromAction(action, version);}/** Returns the operation the Query controller will dispatch from a form request. */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 94f0c799c1..3236f70381 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@@ -533,7 +533,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {if (queryAction == null || queryAction.isBlank()) {return new ResolvedAuthorization(claimedScope, null);}- String service = queryServiceResolver.resolve(auth, queryAction);+ String service = queryServiceResolver.resolve(auth, queryAction, actionRegistry.queryVersion(ctx));String servingScope = catalog.byExternalKey(service).map(descriptor -> iamServiceScope(descriptor, claimedScope)).orElseGet(() -> catalog.canonicalCredentialScope(service));diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamActionRegistry.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamActionRegistry.javaindex d84f082f2c..1372f3821a 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamActionRegistry.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamActionRegistry.java@@ -328,6 +328,14 @@ public class IamActionRegistry {RequestBodyReader.formField(ctx, "Operation"));}+ /**+ * Returns the API version a Query request declares, from the form body for the same reason as+ * {@link #queryAction}: it is the value the controller routes on.+ */+ public String queryVersion(ContainerRequestContext ctx) {+ return RequestBodyReader.formField(ctx, "Version");+ }+/** The same form POST at the root that the Query controller dispatches. */public static boolean isQueryRequest(ContainerRequestContext ctx) {if (!"POST".equalsIgnoreCase(ctx.getMethod()) || ctx.getUriInfo() == null) {diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.javaindex 43317726e0..aac60c8cb0 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryActionRoutingParityTest.java@@ -6,8 +6,10 @@ import java.io.IOException;import java.nio.file.Files;import java.nio.file.Path;import java.util.ArrayList;+import java.util.HashMap;import java.util.LinkedHashSet;import java.util.List;+import java.util.Map;import java.util.Set;import java.util.TreeSet;import java.util.regex.Matcher;@@ -23,15 +25,22 @@ import static org.junit.jupiter.api.Assertions.assertTrue;* services, which is what this test makes visible and stops growing.** <p>Routing only decides anything when a request arrives without a usable credential scope,- * because otherwise the service comes from the SigV4 scope. On that path the action name is all- * there is, and {@code inferServiceFromAction}'s chain ends in {@code return "sqs"}, so a missing- * name answers {@code UnsupportedOperation} in the SQS namespace rather than failing visibly.- * {@code AwsQueryServiceResolver} backs {@code IamEnforcementFilter} through the same code, so the- * same operation is also authorized under the wrong namespace, which is the part worth a test.+ * because otherwise the service comes from the SigV4 scope. On that path there is the action name+ * and the {@code Version} the request declares, and {@code inferServiceFromAction} falls back to+ * SQS, so a missing name answers {@code UnsupportedOperation} in the SQS namespace rather than+ * failing visibly. {@code AwsQueryServiceResolver} backs {@code IamEnforcementFilter}+ * through the same code, so the same operation is also authorized under the wrong namespace, which+ * is the part worth a test.+ *+ * <p>Each action is routed with its own service's {@code Version}, as any Query client sends it,+ * and again without one, as a hand-rolled request may leave it out. Without it a name two services+ * share goes to whichever is tried first, so that path is only held to reaching a service that+ * dispatches the name.** <p>The known gaps live in {@code src/test/resources/query-routing-known-gaps.tsv} rather than* here, so that fixing one is a line removed from a data file. The list is checked both ways: a new- * gap fails {@link #everyDispatchedActionRoutesToItsOwnService}, and a gap that has been fixed+ * gap fails {@link #everyDispatchedActionRoutesToItsOwnService} or+ * {@link #withoutAVersionEveryActionReachesAServiceThatDispatchesIt}, and a gap that has been fixed* without delisting fails {@link #theKnownGapListHasNoStaleEntries}.*/class AwsQueryActionRoutingParityTest {@@ -76,7 +85,7 @@ class AwsQueryActionRoutingParityTest {* their sets are checked as one and why {@code isElbClassicRequest} exists to split them on* {@code Version} afterwards.*- * <p>SQS is listed even though it is the fallback the chain ends in, because being the default+ * <p>SQS is listed even though it is the fallback routing ends in, because being the default* does not make it safe: a name an earlier service claims never reaches it.*/private static final List<QueryHandler> HANDLERS = List.of(@@ -106,6 +115,28 @@ class AwsQueryActionRoutingParityTest {new QueryHandler("redshift", HANDLERS_ROOT + "redshift/RedshiftQueryHandler.java"),new QueryHandler("sqs", HANDLERS_ROOT + "sqs/SqsQueryHandler.java"));+ /**+ * The {@code Version} each service's clients send, which is the {@code apiVersion} in its+ * botocore model. Stated here rather than read back from the controller, so a wrong version+ * there fails this test instead of agreeing with it. ELBv2's stands for both load balancing+ * APIs, since they route to one service by either version and are only split afterwards.+ */+ private static final Map<String, String> API_VERSIONS = Map.ofEntries(+ Map.entry("sts", "2011-06-15"),+ Map.entry("iam", "2010-05-08"),+ Map.entry("sns", "2010-03-31"),+ Map.entry("sqs", "2012-11-05"),+ Map.entry("elasticache", "2015-02-02"),+ Map.entry("rds", "2014-10-31"),+ Map.entry("monitoring", "2010-08-01"),+ Map.entry("cloudformation", "2010-05-15"),+ Map.entry("email", "2010-12-01"),+ Map.entry("ec2", "2016-11-15"),+ Map.entry("elasticloadbalancing", "2015-12-01"),+ Map.entry("autoscaling", "2011-01-01"),+ Map.entry("elasticbeanstalk", "2010-12-01"),+ Map.entry("redshift", "2012-12-01"));+private static final Path KNOWN_GAPS = Path.of("src/test/resources/query-routing-known-gaps.tsv");/**@@ -130,11 +161,11 @@ class AwsQueryActionRoutingParityTest {for (QueryHandler handler : HANDLERS) {for (String action : dispatchedActions(handler)) {- String reached = AwsQueryController.inferServiceFromAction(action);+ String reached = reached(handler, action);if (!handler.service().equals(reached)&& !known.contains(gapKey(handler.service(), action, reached))) {unexpected.add(handler.service() + " dispatches " + action- + " but the name reaches " + reached);+ + " but a request for it reaches " + reached);}}}@@ -142,11 +173,40 @@ class AwsQueryActionRoutingParityTest {assertTrue(unexpected.isEmpty(),"An action a handler dispatches has to route to that handler, or a request without "+ "a credential scope answers in the wrong namespace and is authorized "- + "under it too. Add the name to its service's set in AwsQueryController, "- + "having checked that no service earlier in inferServiceFromAction's "- + "chain already claims it. If an earlier service does claim it, the name "- + "needs the Version discriminator instead, and belongs in " + KNOWN_GAPS- + " with that noted. New: " + unexpected);+ + "under it too. Add the name to its service's set in AwsQueryController; "+ + "a name another service also defines is then told apart by the request's "+ + "Version. New: " + unexpected);+ }++ /**+ * Without a {@code Version} the name decides alone, and a name two services define goes to the+ * one tried first, which is right for either of them. What is wrong is reaching a service that+ * does not dispatch the name at all, and the check above cannot see it, because a+ * {@code Version} goes straight to the service it names: a set claiming a name its handler+ * lacks, tried ahead of the service that has it, takes every such request.+ */+ @Test+ void withoutAVersionEveryActionReachesAServiceThatDispatchesIt() throws IOException {+ Set<String> known = knownGaps();+ Map<String, Set<String>> dispatched = dispatchedByService();+ List<String> unexpected = new ArrayList<>();++ for (QueryHandler handler : HANDLERS) {+ for (String action : dispatchedActions(handler)) {+ String reached = reachedWithoutVersion(action);+ if (!dispatched.getOrDefault(reached, Set.of()).contains(action)+ && !known.contains(gapKey(handler.service(), action, reached))) {+ unexpected.add(handler.service() + " dispatches " + action+ + " but without a Version a request for it reaches " + reached);+ }+ }+ }++ assertTrue(unexpected.isEmpty(),+ "Without a Version an action has to reach a service that dispatches it, or the "+ + "request answers UnsupportedOperation in a namespace it was never for. "+ + "A set in AwsQueryController claims a name its handler does not "+ + "dispatch, ahead of the service that does: " + unexpected);}/**@@ -156,13 +216,18 @@ class AwsQueryActionRoutingParityTest {*/@Testvoid theKnownGapListHasNoStaleEntries() throws IOException {+ Map<String, Set<String>> dispatched = dispatchedByService();Set<String> live = new LinkedHashSet<>();for (QueryHandler handler : HANDLERS) {for (String action : dispatchedActions(handler)) {- String reached = AwsQueryController.inferServiceFromAction(action);+ String reached = reached(handler, action);if (!handler.service().equals(reached)) {live.add(gapKey(handler.service(), action, reached));}+ String reachedWithoutVersion = reachedWithoutVersion(action);+ if (!dispatched.getOrDefault(reachedWithoutVersion, Set.of()).contains(action)) {+ live.add(gapKey(handler.service(), action, reachedWithoutVersion));+ }}}@@ -270,6 +335,34 @@ class AwsQueryActionRoutingParityTest {+ "that counted it, including the total. " + wrong);}+ /**+ * Where an unsigned request for the action goes, carrying the handler's own {@code Version} the+ * way every Query client sends it.+ */+ private static String reached(QueryHandler handler, String action) {+ String version = API_VERSIONS.get(handler.service());+ assertTrue(version != null, "No API version listed for " + handler.service());+ return AwsQueryController.inferServiceFromAction(action, version);+ }++ /** Where an unsigned request for the action goes when it carries no {@code Version} at all. */+ private static String reachedWithoutVersion(String action) {+ return AwsQueryController.inferServiceFromAction(action, null);+ }++ /**+ * Every name each service dispatches, across all of its handlers. A service with no Query+ * handler, as Cognito has none, dispatches nothing.+ */+ private static Map<String, Set<String>> dispatchedByService() throws IOException {+ Map<String, Set<String>> dispatched = new HashMap<>();+ for (QueryHandler handler : HANDLERS) {+ dispatched.computeIfAbsent(handler.service(), service -> new TreeSet<>())+ .addAll(dispatchedActions(handler));+ }+ return dispatched;+ }+/** One line of the known-gap file: the service, the action, and what it reaches instead. */private static String gapKey(String service, String action, String reached) {return service + "\t" + action + "\t" + reached;diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryControllerIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryControllerIntegrationTest.javaindex 958cd309fd..9c3f261876 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryControllerIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryControllerIntegrationTest.java@@ -1,10 +1,15 @@package io.github.hectorvent.floci.core.common;+import io.github.hectorvent.floci.testing.PartitionCleanup;import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;import org.junit.jupiter.params.ParameterizedTest;import org.junit.jupiter.params.provider.ValueSource;+import java.util.UUID;+import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;import static org.hamcrest.Matchers.equalTo;@@ -14,6 +19,9 @@ import static org.hamcrest.Matchers.not;@QuarkusTestclass AwsQueryControllerIntegrationTest {+ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();+@Testvoid missingActionParameterReturns400MissingAction() {given()@@ -76,4 +84,94 @@ class AwsQueryControllerIntegrationTest {.contentType("application/xml").body("DescribeRegionsResponse.regionInfo.item.size()", greaterThan(0));}++ @Test+ void sharedActionNameReachesTheServiceItsVersionDeclares() {+ // IAM and ElastiCache both define CreateUser and IAM takes it by name. The Version an+ // ElastiCache client sends is what brings the request to ElastiCache instead.+ String userId = "version-routed-" + UUID.randomUUID().toString().substring(0, 8);+ // Registered first, so the user goes even when an assertion below fails. It asserts+ // nothing, so it stays quiet once the test has deleted the user itself.+ cleanup.register(() -> deleteElastiCacheUser(userId));+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateUser")+ .formParam("Version", "2015-02-02")+ .formParam("UserId", userId)+ .formParam("UserName", userId)+ .formParam("Engine", "redis")+ .formParam("AccessString", "on ~* +@all")+ .formParam("AuthenticationMode.Type", "no-password-required")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("CreateUserResponse.CreateUserResult.UserId", equalTo(userId));++ // DeleteUser is shared the same way.+ deleteElastiCacheUser(userId)+ .statusCode(200)+ .body("DeleteUserResponse.DeleteUserResult.UserId", equalTo(userId));+ }++ @Test+ void sqsPermissionActionReachesSqsUnderItsVersion() {+ // SNS also defines AddPermission and takes it by name, so it is SQS's Version that brings+ // this request to the queue rather than to SNS.+ String queueUrl = given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateQueue")+ .formParam("Version", "2012-11-05")+ .formParam("QueueName", "version-routed-" + UUID.randomUUID().toString().substring(0, 8))+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .extract().path("CreateQueueResponse.CreateQueueResult.QueueUrl");+ cleanup.register(() -> given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DeleteQueue")+ .formParam("Version", "2012-11-05")+ .formParam("QueueUrl", queueUrl)+ .when()+ .post("/")+ .then()+ .statusCode(200));++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "AddPermission")+ .formParam("Version", "2012-11-05")+ .formParam("QueueUrl", queueUrl)+ .formParam("Label", "granted-under-sqs-version")+ .formParam("AWSAccountId.1", "111122223333")+ .formParam("ActionName.1", "SendMessage")+ .when()+ .post("/")+ .then()+ .statusCode(200);++ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "GetQueueAttributes")+ .formParam("Version", "2012-11-05")+ .formParam("QueueUrl", queueUrl)+ .formParam("AttributeName.1", "Policy")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body(containsString("granted-under-sqs-version"));+ }++ private static ValidatableResponse deleteElastiCacheUser(String userId) {+ return given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "DeleteUser")+ .formParam("Version", "2015-02-02")+ .formParam("UserId", userId)+ .when()+ .post("/")+ .then();+ }}diff --git a/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryServiceResolverTest.java b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryServiceResolverTest.javaindex dc7aa1a7d5..19a770715f 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryServiceResolverTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/AwsQueryServiceResolverTest.java@@ -2,6 +2,8 @@ package io.github.hectorvent.floci.core.common;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import org.junit.jupiter.params.ParameterizedTest;+import org.junit.jupiter.params.provider.CsvSource;import java.util.Optional;import java.util.Set;@@ -26,7 +28,7 @@ class AwsQueryServiceResolverTest {when(catalog.byCredentialScope("lambda")).thenReturn(Optional.of(descriptor("lambda", ServiceProtocol.REST_JSON)));- assertEquals("iam", resolver.resolve(authorization("lambda"), "CreateUser"));+ assertEquals("iam", resolver.resolve(authorization("lambda"), "CreateUser", null));}@Test@@ -34,7 +36,7 @@ class AwsQueryServiceResolverTest {when(catalog.byCredentialScope("sqs")).thenReturn(Optional.of(descriptor("sqs", ServiceProtocol.QUERY)));- assertEquals("sqs", resolver.resolve(authorization("sqs"), "CreateUser"));+ assertEquals("sqs", resolver.resolve(authorization("sqs"), "CreateUser", null));}@Test@@ -42,12 +44,64 @@ class AwsQueryServiceResolverTest {when(catalog.byCredentialScope("iam")).thenReturn(Optional.of(descriptor("iam", ServiceProtocol.QUERY)));- assertEquals("iam", resolver.resolve(authorization("iam"), "CreateUser"));+ assertEquals("iam", resolver.resolve(authorization("iam"), "CreateUser", null));}@Testvoid missingAuthorizationKeepsActionFallback() {- assertEquals("sqs", resolver.resolve(null, "UnknownQueryAction"));+ assertEquals("sqs", resolver.resolve(null, "UnknownQueryAction", null));+ }++ /**+ * A name two services define goes to the one whose {@code Version} the request declares. With+ * no version, or one that does not settle it, the routing order decides as it always has.+ */+ @ParameterizedTest+ @CsvSource(nullValues = "none", value = {+ "CreateUser, 2015-02-02, elasticache",+ "CreateUser, 2010-05-08, iam",+ "CreateUser, none, iam",+ "AddPermission, 2012-11-05, sqs",+ "AddPermission, 2010-03-31, sns",+ "AddPermission, none, sns",+ "ListTagsForResource, 2014-10-31, rds",+ "ListTagsForResource, none, sns",+ "DeleteTags, 2012-12-01, redshift",+ "DeleteTags, 2011-01-01, autoscaling",+ "DeleteTags, none, ec2",+ "DescribeTags, 2012-06-01, elasticloadbalancing",+ "GetTemplate, 2010-12-01, email",+ "GetTemplate, none, cloudformation",+ "DescribeEnvironments, 2010-12-01, elasticbeanstalk",+ })+ void versionPicksAmongTheServicesThatShareAName(String action, String version, String expected) {+ assertEquals(expected, resolver.resolve(null, action, version));+ }++ @Test+ void versionOfAServiceWithoutTheActionLeavesTheOrderToDecide() {+ assertEquals("sns", resolver.resolve(null, "Publish", "2010-05-08"));+ }++ @Test+ void unrecognisedVersionLeavesTheOrderToDecide() {+ assertEquals("iam", resolver.resolve(null, "CreateUser", "2099-01-01"));+ }++ @Test+ void queryCapableSignedScopeOutranksVersion() {+ when(catalog.byCredentialScope("iam")).thenReturn(Optional.of(+ descriptor("iam", ServiceProtocol.QUERY)));++ assertEquals("iam", resolver.resolve(authorization("iam"), "CreateUser", "2015-02-02"));+ }++ @Test+ void unsupportedSignedScopeFallsBackToVersion() {+ when(catalog.byCredentialScope("lambda")).thenReturn(Optional.of(+ descriptor("lambda", ServiceProtocol.REST_JSON)));++ assertEquals("elasticache", resolver.resolve(authorization("lambda"), "CreateUser", "2015-02-02"));}private static String authorization(String scope) {diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamServingServiceEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamServingServiceEnforcementIntegrationTest.javaindex 6f2d054573..810cbb37a4 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamServingServiceEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamServingServiceEnforcementIntegrationTest.java@@ -18,6 +18,7 @@ import java.util.UUID;import static io.github.hectorvent.floci.testing.EnforcementFixtures.auth;import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;import static org.hamcrest.Matchers.not;@QuarkusTest@@ -92,6 +93,40 @@ class IamServingServiceEnforcementIntegrationTest {adminIam("GetUser", Map.of("UserName", attempted)).statusCode(404);}+ @Test+ void queryVersionMovesAuthorizationWithTheServiceItSelects() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String attempted = "version-denied-" + suffix;+ String accessKeyId = createUserWithPolicy("version-iam-only-" + suffix, "IamCreateUserOnly", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"iam:CreateUser","Resource":"*"}+ ]}""");++ elastiCacheCreateUser(accessKeyId, attempted)+ .statusCode(403)+ .body(containsString("elasticache:CreateUser"));++ adminIam("GetUser", Map.of("UserName", attempted)).statusCode(404);+ adminElastiCache("DescribeUsers", Map.of("UserId", attempted)).statusCode(404);+ }++ @Test+ void queryVersionReachesTheServiceItsPolicyAllows() {+ String suffix = UUID.randomUUID().toString().substring(0, 8);+ String attempted = "version-allowed-" + suffix;+ String accessKeyId = createUserWithPolicy("version-cache-only-" + suffix, "CacheCreateUserOnly", """+ {"Version":"2012-10-17","Statement":[+ {"Effect":"Allow","Action":"elasticache:CreateUser","Resource":"*"}+ ]}""");++ cleanup.register(() -> adminElastiCache("DeleteUser", Map.of("UserId", attempted)).statusCode(200));+ elastiCacheCreateUser(accessKeyId, attempted)+ .statusCode(200)+ .body("CreateUserResponse.CreateUserResult.UserId", equalTo(attempted));++ adminIam("GetUser", Map.of("UserName", attempted)).statusCode(404);+ }+@Testvoid restRequestCannotBypassApiGatewayPolicyWithIamScope() {String suffix = UUID.randomUUID().toString().substring(0, 8);@@ -175,6 +210,34 @@ class IamServingServiceEnforcementIntegrationTest {return iamCall(accessKeyId, scope, "Action", action, params);}+ /**+ * An ElastiCache {@code CreateUser}, a name IAM also defines and takes by name. Signed under a+ * scope that is not a Query service, so the scope cannot decide and the {@code Version} has to.+ */+ private static ValidatableResponse elastiCacheCreateUser(String accessKeyId, String userId) {+ return given()+ .header("Authorization", auth(accessKeyId, "lambda"))+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "CreateUser")+ .formParam("Version", "2015-02-02")+ .formParam("UserId", userId)+ .formParam("UserName", userId)+ .formParam("Engine", "redis")+ .formParam("AccessString", "on ~* +@all")+ .formParam("AuthenticationMode.Type", "no-password-required")+ .when().post("/").then();+ }++ private static ValidatableResponse adminElastiCache(String action, Map<String, String> params) {+ RequestSpecification spec = given()+ .header("Authorization", auth(ACCOUNT_ID, "elasticache"))+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", action)+ .formParam("Version", "2015-02-02");+ params.forEach(spec::formParam);+ return spec.when().post("/").then();+ }+private static ValidatableResponse iamOperationCall(String accessKeyId, String scope, String operation,Map<String, String> params) {return iamCall(accessKeyId, scope, "Operation", operation, params);diff --git a/src/test/resources/query-routing-known-gaps.tsv b/src/test/resources/query-routing-known-gaps.tsvindex dff27f0df2..e5e9a0b385 100644--- a/src/test/resources/query-routing-known-gaps.tsv+++ b/src/test/resources/query-routing-known-gaps.tsv@@ -3,35 +3,32 @@# Columns: service, action, service it reaches instead.## Routing only matters when a request arrives without a usable credential scope, since-# otherwise the service comes from the SigV4 scope. On that path the action name is all-# there is, and AwsQueryServiceResolver backs IamEnforcementFilter too, so an entry here-# is also authorized under the wrong namespace.+# otherwise the service comes from the SigV4 scope. On that path there is the action name+# and the Version the request declares, and AwsQueryServiceResolver backs+# IamEnforcementFilter too, so an entry here is also authorized under the wrong namespace.#-# Two kinds of entry, told apart by the third column:+# Nearly every entry is a name missing from its own service's routing set, and adding it+# there is the fix, as #5032 did for IAM. The third column only says where the request+# goes meanwhile: sqs when no set holds the name, since that is the default, or the+# service whose set does. A name two services define needs nothing more than being in+# both sets, because the Version a request carries decides between them.#-# -> sqs The name is in no routing set, so it falls through to the sqs default.-# Fixable by adding the name to its service's set, as #5032 did for IAM,-# once checked that no service earlier in the chain claims it.+# The exception is a request without a Version, which only a hand-rolled client sends.+# A name two services define then goes to the one tried first, which is a gap only when+# that one does not handle it. SNS defines AddPermission and RemovePermission, but its+# handler does not implement them, so SQS's reach SNS that way. Implementing them in SNS+# is the fix.#-# -> other A service earlier in inferServiceFromAction's chain already owns the-# name, so adding it to the right set changes nothing. These need the-# Version form field to disambiguate, the way isElbClassicRequest already-# reads it, which is a cross-service routing change of its own.-#-# 189 entries: 171 unrouted, 18 claimed by another service.+# 173 entries: 171 unrouted, 2 claimed by another service.## Shrink this file, never grow it. Removing a line is the point; adding one needs a# reason in the PR that adds it. AwsQueryActionRoutingParityTest fails on an entry that# is no longer a gap, so a fix cannot leave the list stale.-# autoscaling: 17 (13 unrouted, 4 claimed elsewhere)+# autoscaling: 13 (13 unrouted, 0 claimed elsewhere)autoscaling AttachTrafficSources sqs-autoscaling DeletePolicy iamautoscaling DeleteScheduledAction sqs-autoscaling DeleteTags ec2autoscaling DeleteWarmPool sqs-autoscaling DescribeAccountLimits elasticloadbalancing-autoscaling DescribeLoadBalancers elasticloadbalancingautoscaling DescribeScheduledActions sqsautoscaling DescribeTrafficSources sqsautoscaling DescribeWarmPool sqs@@ -133,39 +130,29 @@ ec2 ResetEbsDefaultKmsKeyId sqsec2 SearchTransitGatewayRoutes sqsec2 UnmonitorInstances sqs-# elasticache: 15 (12 unrouted, 3 claimed elsewhere)+# elasticache: 12 (12 unrouted, 0 claimed elsewhere)elasticache CreateCacheCluster sqselasticache CreateCacheParameterGroup sqselasticache CreateCacheSubnetGroup sqs-elasticache CreateUser iamelasticache DeleteCacheCluster sqselasticache DeleteCacheParameterGroup sqselasticache DeleteCacheSubnetGroup sqs-elasticache DeleteUser iamelasticache DescribeCacheClusters sqselasticache DescribeCacheParameterGroups sqselasticache DescribeCacheParameters sqselasticache DescribeCacheSubnetGroups sqs-elasticache ListTagsForResource snselasticache ModifyCacheParameterGroup sqselasticache ModifyCacheSubnetGroup sqs-# elasticloadbalancing: 4 (3 unrouted, 1 claimed elsewhere)+# elasticloadbalancing: 3 (3 unrouted, 0 claimed elsewhere)elasticloadbalancing DescribeCapacityReservation sqselasticloadbalancing DescribeListenerAttributes sqs-elasticloadbalancing DescribeTags ec2elasticloadbalancing ModifyListenerAttributes sqs-# email: 2 (1 unrouted, 1 claimed elsewhere)-email GetTemplate cloudformation+# email: 1 (1 unrouted, 0 claimed elsewhere)email UpdateAccountSendingEnabled sqs-# monitoring: 3 (0 unrouted, 3 claimed elsewhere)-monitoring ListTagsForResource sns-monitoring TagResource sns-monitoring UntagResource sns--# rds: 48 (47 unrouted, 1 claimed elsewhere)+# rds: 47 (47 unrouted, 0 claimed elsewhere)rds AddSourceIdentifierToSubscription sqsrds CopyDBClusterParameterGroup sqsrds CopyDBClusterSnapshot sqs@@ -190,7 +177,6 @@ rds DescribeEventSubscriptions sqsrds DescribeEvents sqsrds FailoverDBCluster sqsrds FailoverGlobalCluster sqs-rds ListTagsForResource snsrds ModifyDBClusterEndpoint sqsrds ModifyDBClusterSnapshotAttribute sqsrds ModifyDBSnapshot sqs@@ -215,16 +201,13 @@ rds StopDBInstance sqsrds SwitchoverGlobalCluster sqsrds SwitchoverReadReplica sqs-# redshift: 12 (9 unrouted, 3 claimed elsewhere)+# redshift: 9 (9 unrouted, 0 claimed elsewhere)redshift CreateIntegration sqs-redshift CreateTags ec2redshift DeleteIntegration sqs-redshift DeleteTags ec2redshift DescribeClusterVersions sqsredshift DescribeIntegrations sqsredshift DescribeLoggingStatus sqsredshift DescribeOrderableClusterOptions sqs-redshift DescribeTags ec2redshift DisableLogging sqsredshift EnableLogging sqsredshift ModifyClusterIamRoles sqs