Light, fluffy, and always free - The AWS Local Emulator alternative
fix(appsync): refuse a long-term access key sent with a session token (#5880)
TATSUNO “Taz” Yasuhiroffb3d84bad3d
diff --git a/docs/services/appsync.md b/docs/services/appsync.mdindex b8a879d1d5..3c617d6e3a 100644--- a/docs/services/appsync.md+++ b/docs/services/appsync.md@@ -238,6 +238,7 @@ Responses are `application/json` with AWS AppSync wire shapes (`data` / `errors[| API exists but no executable schema (incl. PROCESSING) | **502** | `GraphQLSchemaException` — `No schema definition exists.` + `x-amzn-errortype` || Unexpected failure | 500 | `InternalFailure` || Missing/invalid/expired credentials, unconfigured mode, Lambda deny | **401** | `UnauthorizedException` — GraphQL does not run; `x-amzn-errortype` is set. Missing headers use message `Missing authorization header`. |+| `AWS_IAM` with an unknown access key, or a session token that does not fit the key | **403** | `UnrecognizedClientException`: `The security token included in the request is invalid`, ending with a period only when no token or an empty one came || Field directive mismatch, Cognito group miss, Lambda `deniedFields`, IAM field DENY | **200** | Field is `null` and `errors[]` contains `Unauthorized` — `Not Authorized to access {field} on type {type}` (no `x-amzn-errortype`) |**Evidence for data-plane statuses** (empty/`[]`/`{}` → 400; missing schema → 502): AppSync team sample in [graphql/graphql-over-http#81](https://github.com/graphql/graphql-over-http/issues/81) (@robzhu). The management API Reference lists `GraphQLSchemaException` as HTTP 400 for “schema not valid” on management operations — a different surface than the GraphQL execute data plane.@@ -248,7 +249,7 @@ Request auth runs after Content-Type and body parse and after API lookup (unknowHeaders are classified by **shape** (not primary-then-fallback). If both `x-api-key` and SigV4 `Authorization` are present, **SigV4 wins**. AppSync does not fall back to the API key when IAM validation fails.-Missing required auth headers return HTTP **401** `UnauthorizedException` with message `Missing authorization header`. Invalid or expired credentials that are present still return 401 with `You are not authorized to make this call.`+Missing required auth headers return HTTP **401** `UnauthorizedException` with message `Missing authorization header`. Invalid or expired credentials that are present still return 401 with `You are not authorized to make this call.`, except the 403 `AWS_IAM` cases in the table above.| Header shape | Mode ||---|---|@@ -262,7 +263,7 @@ Configured modes are the API default `authenticationType` plus `additionalAuthen| Mode | Emulator notes ||---|---|| API_KEY | Lookup by `ApiKey.id`, which is the key value (`da2-…`). Identity is absent (not `{}`). Default key expiry is 7 days when `expires` is omitted; stored `expires` is rounded down to the nearest hour. Create/UpdateApiKey require `expires` between 1 and 365 days from now (`ApiKeyValidityOutOfBoundsException`, 400). `deletes` is `expires` plus 60 days. |-| AWS_IAM | Verifies a real header-signed SigV4 request (`appsync` service, fixed `/v1/apis/{apiId}/graphql` canonical path, 5-minute clock skew): the `Credential=` access key must resolve to a secret via `IamService`, and the signature must match. The legacy `test`/`test` pair is still emulator ALLOW, but it must be signed with secret `test` like any other key, and it is not a bypass. A temporary (`ASIA...`) credential must also present the `X-Amz-Security-Token` header matching the one issued for it. An unknown or unsigned key is always 401 and never becomes the account-root identity. Known keys additionally evaluate `appsync:GraphQL`. |+| AWS_IAM | Verifies a real header-signed SigV4 request (`appsync` service, fixed `/v1/apis/{apiId}/graphql` canonical path, 5-minute clock skew): the `Credential=` access key must resolve to a secret via `IamService`, and the signature must match. The legacy `test`/`test` pair is still emulator ALLOW, but it must be signed with secret `test` like any other key, and it is not a bypass. A temporary (`ASIA...`) credential must also present the `X-Amz-Security-Token` header issued with it, and a long-term key must present none, as on AWS. The `test` key takes any token. An unknown key is 403 and an unsigned one 401, and neither becomes the account-root identity. Known keys additionally evaluate `appsync:GraphQL`. || Cognito / OIDC | JWT signature is verified, not just decoded. Cognito checks the token against the issuing user pool's own RS256 signing key (`alg`, `kid`, issuer, audience/`clientId`, expiry); OIDC checks it against the configured issuer's published JWKS (via OIDC discovery), the same way the HTTP API JWT authorizer does. Both fail closed: an unreachable issuer, unsupported algorithm (including `none`), unmatched `kid`, or bad signature is 401. OIDC as the sole mode still skips the token's own `iss` claim check, but the signature is always verified against the configured issuer's keys. OIDC identity is `{sub, issuer, claims}` (no `sourceIp`). || Lambda | AppSync `isAuthorized` contract via `LambdaService.invoke` (not an API Gateway policy document). |diff --git a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AppSyncAuth.java b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AppSyncAuth.javaindex 557c406daf..e264a06707 100644--- a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AppSyncAuth.java+++ b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AppSyncAuth.java@@ -8,6 +8,8 @@ public final class AppSyncAuth {public static final String UNAUTHORIZED_MESSAGE = "You are not authorized to make this call.";public static final String MISSING_AUTHORIZATION_HEADER = "Missing authorization header";public static final String FIELD_UNAUTHORIZED_TYPE = "Unauthorized";+ public static final String UNRECOGNIZED_CLIENT_TYPE = "UnrecognizedClientException";+ public static final String INVALID_SECURITY_TOKEN = "The security token included in the request is invalid";public static String fieldUnauthorizedMessage(String fieldName, String typeName) {return "Not Authorized to access " + fieldName + " on type " + typeName;@@ -26,6 +28,16 @@ public final class AppSyncAuth {return new AppSyncTransportException(401, UNAUTHORIZED_TYPE, UNAUTHORIZED_MESSAGE);}+ /** An access key AppSync does not know, a temporary key with no session token, or an empty token. */+ public static AppSyncTransportException unrecognizedClient() {+ return new AppSyncTransportException(403, UNRECOGNIZED_CLIENT_TYPE, INVALID_SECURITY_TOKEN + ".");+ }++ /** A session token that does not fit the key. AWS drops the period here. */+ public static AppSyncTransportException invalidSessionToken() {+ return new AppSyncTransportException(403, UNRECOGNIZED_CLIENT_TYPE, INVALID_SECURITY_TOKEN);+ }+public static AppSyncTransportException missingAuthorizationHeader() {return new AppSyncTransportException(401, UNAUTHORIZED_TYPE, MISSING_AUTHORIZATION_HEADER);}diff --git a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/IamAuthValidator.java b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/IamAuthValidator.javaindex 4e5c4974d8..eb0494d8d4 100644--- a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/IamAuthValidator.java+++ b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/IamAuthValidator.java@@ -5,6 +5,7 @@ import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsRegions;import io.github.hectorvent.floci.core.common.Digests;import io.github.hectorvent.floci.core.common.auth.CredentialScope;+import io.github.hectorvent.floci.core.common.auth.SessionTokenCheck;import io.github.hectorvent.floci.core.common.auth.SigV4AuthorizationHeader;import io.github.hectorvent.floci.core.common.auth.SigV4RequestValidator;import io.github.hectorvent.floci.services.appsync.graphql.AppSyncTransportException;@@ -124,7 +125,7 @@ public class IamAuthValidator {if (secretKey == null) {LOG.debugv("AppSync SigV4 request references unregistered access key={0}",SigV4RequestValidator.sanitizeForLog(accessKeyId));- throw AppSyncAuth.unauthorized();+ throw AppSyncAuth.unrecognizedClient();}checkSessionToken(accessKeyId, info.requestHeaders());try {@@ -166,40 +167,19 @@ public class IamAuthValidator {return iamService.findSecretKey(accessKeyId).orElse(null);}- /**- * Rejects a temporary ({@code ASIA...}) credential that does not present the session token- * Floci issued with it. Mirrors {@code ExecuteApiSigV4Authorizer.checkSessionToken}: a matching- * secret alone is not the whole credential, since AWS requires the session token on every- * request made with temporary credentials to confirm it is live and genuinely STS-issued.- *- * <p>The token is compared against the value recorded at mint time, not merely required to be- * present, so a fabricated token is rejected along with a missing one. A session recorded- * before Floci tracked tokens has no issued value to compare against ({@code findSessionToken}- * is empty there), so presence is all that can be demanded of it: rejecting that case would- * lock out an otherwise valid credential.- *- * <p>The token does not need to ride in {@code SignedHeaders}: comparing it against the issued- * value binds it regardless of where it rode, the same way the execute-api authorizer does.- */+ /** Rejects a session token that does not fit the access key. The local {@code test} key takes any token. */private void checkSessionToken(String accessKeyId, Map<String, String> requestHeaders) {- if (!IamService.isTemporaryAccessKey(accessKeyId)) {- return;- }- String presented = header(requestHeaders, SECURITY_TOKEN);- if (isBlank(presented)) {- LOG.debugv("AppSync SigV4 request uses temporary credential accessKey={0} with no {1}",- SigV4RequestValidator.sanitizeForLog(accessKeyId), SECURITY_TOKEN);- throw AppSyncAuth.unauthorized();- }- String issued = iamService.findSessionToken(accessKeyId).orElse(null);- if (issued == null) {+ if (LEGACY_ACCESS_KEY_ID.equals(accessKeyId)) {return;}- if (!MessageDigest.isEqual(issued.getBytes(StandardCharsets.UTF_8),- presented.getBytes(StandardCharsets.UTF_8))) {- LOG.debugv("AppSync SigV4 request presents a session token that does not match the one"- + " issued for accessKey={0}", SigV4RequestValidator.sanitizeForLog(accessKeyId));- throw AppSyncAuth.unauthorized();+ String presented = hasHeader(requestHeaders, SECURITY_TOKEN) ? header(requestHeaders, SECURITY_TOKEN) : null;+ AppSyncTransportException refusal = switch (SessionTokenCheck.of(iamService, accessKeyId, presented)) {+ case VALID -> null;+ case MISSING -> AppSyncAuth.unrecognizedClient();+ case INVALID -> AppSyncAuth.invalidSessionToken();+ };+ if (refusal != null) {+ throw refusal;}}@@ -253,6 +233,10 @@ public class IamAuthValidator {return "";}+ private static boolean hasHeader(Map<String, String> headers, String name) {+ return headers != null && headers.keySet().stream().anyMatch(name::equalsIgnoreCase);+ }+private static boolean isBlank(String value) {return value == null || value.isBlank();}diff --git a/src/test/java/io/github/hectorvent/floci/services/appsync/AppSyncAuthIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/appsync/AppSyncAuthIntegrationTest.javaindex 908c636f3f..c4bb323e1d 100644--- a/src/test/java/io/github/hectorvent/floci/services/appsync/AppSyncAuthIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/appsync/AppSyncAuthIntegrationTest.java@@ -2,18 +2,25 @@ package io.github.hectorvent.floci.services.appsync;import io.github.hectorvent.floci.core.common.ResolvedServiceCatalog;import io.github.hectorvent.floci.services.appsync.graphql.AppSyncExecutionController;+import io.github.hectorvent.floci.testing.EnforcementFixtures;+import io.github.hectorvent.floci.testing.EnforcementFixtures.UserCredentials;+import io.github.hectorvent.floci.testing.PartitionCleanup;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.github.hectorvent.floci.testing.SidecarContainersProfile;import io.github.hectorvent.floci.testutil.AppSyncRequestSigner;+import io.quarkus.test.common.http.TestHTTPResource;import io.quarkus.test.junit.QuarkusTest;import io.quarkus.test.junit.TestProfile;import io.restassured.RestAssured;import jakarta.inject.Inject;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;+import java.net.URI;import java.time.Duration;import java.time.Instant;+import java.util.LinkedHashMap;import java.util.Map;import java.util.UUID;@@ -36,6 +43,12 @@ class AppSyncAuthIntegrationTest {@InjectResolvedServiceCatalog catalog;+ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ @TestHTTPResource("/")+ URI baseUri;+@BeforeAllstatic void configureRestAssured() {SidecarContainersProfile.requireDockerAndImage("floci.services.appsync.graphql-image");@@ -210,6 +223,42 @@ class AppSyncAuthIntegrationTest {.body("errors[0].path", equalTo(java.util.List.of("hello")));}+ @Test+ void longTermKeyWithASessionTokenIsRefused() throws Exception {+ String apiId = given()+ .header("Authorization", MGMT_AUTH)+ .contentType("application/json")+ .body("""+ {"name": "token-%s", "authenticationType": "AWS_IAM"}+ """.formatted(UUID.randomUUID().toString().substring(0, 8)))+ .when()+ .post("/v1/apis")+ .then()+ .statusCode(200)+ .extract().path("graphqlApi.apiId");+ startSchema(apiId, "type Query { hello: String }");+ awaitSchemaSuccess(apiId);+ UserCredentials user = EnforcementFixtures.createUser(cleanup, baseUri.getPort(),+ EnforcementFixtures.auth("test", "iam"), "appsync-token-user");++ String body = "{\"query\":\"{ hello }\"}";+ Map<String, String> headers = new LinkedHashMap<>(AppSyncRequestSigner.signedHeaders(apiId,+ "localhost:" + RestAssured.port, body, user.accessKeyId(), user.secretAccessKey(), "us-east-1",+ Instant.now()));+ headers.put("X-Amz-Security-Token", "bogus");+ given()+ .contentType("application/json")+ .headers(headers)+ .body(body)+ .when()+ .post("/v1/apis/" + apiId + "/graphql")+ .then()+ .statusCode(403)+ .header("x-amzn-errortype", equalTo("UnrecognizedClientException"))+ .body("errors[0].errorType", equalTo("UnrecognizedClientException"))+ .body("errors[0].message", equalTo("The security token included in the request is invalid"));+ }+@Testvoid additionalModeIamCanIntrospect() throws Exception {String apiId = given()diff --git a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/IamAuthValidatorTest.java b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/IamAuthValidatorTest.javaindex 867bbc2dcf..7a30950534 100644--- a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/IamAuthValidatorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/IamAuthValidatorTest.java@@ -130,9 +130,7 @@ class IamAuthValidatorTest {Map<String, String> signed = AppSyncRequestSigner.signedHeaders("api-1", HOST, BODY, "AKIAUNKNOWN", "whatever-secret", REGION, Instant.now());- AppSyncTransportException ex = assertThrows(AppSyncTransportException.class,- () -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));- assertEquals(401, ex.getHttpStatus());+ assertRefused(signed, "The security token included in the request is invalid.");}@Test@@ -191,25 +189,44 @@ class IamAuthValidatorTest {}@Test- void temporaryCredentialSignedButNoSessionTokenIs401() throws Exception {+ void temporaryCredentialSignedButNoSessionTokenIsRefused() throws Exception {when(iamService.findSecretKey("ASIANOTOKEN")).thenReturn(Optional.of("session-secret"));Map<String, String> signed = AppSyncRequestSigner.signedHeaders("api-1", HOST, BODY, "ASIANOTOKEN", "session-secret", REGION, Instant.now());- AppSyncTransportException ex = assertThrows(AppSyncTransportException.class,- () -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));- assertEquals(401, ex.getHttpStatus());+ assertRefused(signed, "The security token included in the request is invalid.");}@Test- void temporaryCredentialWithMismatchedSessionTokenIs401() throws Exception {+ void temporaryCredentialWithMismatchedSessionTokenIsRefused() throws Exception {when(iamService.findSecretKey("ASIAFORGED")).thenReturn(Optional.of("session-secret"));when(iamService.findSessionToken("ASIAFORGED")).thenReturn(Optional.of("issued-token"));Map<String, String> signed = signedWithSessionToken("ASIAFORGED", "session-secret", "forged-token");+ assertRefused(signed, "The security token included in the request is invalid");+ }++ @Test+ void longTermKeyWithASessionTokenIsRefused() throws Exception {+ assertRefused(signedWithSessionToken("AKIAGOOD", "good-secret", "bogus"),+ "The security token included in the request is invalid");+ assertRefused(signedWithSessionToken("AKIAGOOD", "good-secret", ""),+ "The security token included in the request is invalid.");+ }++ @Test+ void legacyTestKeyTakesAnySessionToken() throws Exception {+ Map<String, String> signed = signedWithSessionToken("test", "test", "bogus");++ assertEquals("test", validator.validateRequest(authorization(signed), "api-1", infoWith(signed)).get("user"));+ }++ private void assertRefused(Map<String, String> signed, String message) {AppSyncTransportException ex = assertThrows(AppSyncTransportException.class,() -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));- assertEquals(401, ex.getHttpStatus());+ assertEquals(403, ex.getHttpStatus());+ assertEquals("UnrecognizedClientException", ex.getErrorType());+ assertEquals(message, ex.getMessage());}@Test