Light, fluffy, and always free - The AWS Local Emulator alternative
fix(appsync): answer a failed AWS_IAM request with AppSync's errors (#5901)
TATSUNO “Taz” Yasuhiro0dd443478c0e
diff --git a/docs/services/appsync.md b/docs/services/appsync.mdindex 3c617d6e3a..8e0cbab664 100644--- a/docs/services/appsync.md+++ b/docs/services/appsync.md@@ -237,7 +237,9 @@ Responses are `application/json` with AWS AppSync wire shapes (`data` / `errors[| Unknown `apiId` | 404 | `NotFoundException` || 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`. |+| 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`. An `AWS_IAM` caller whose policies deny `appsync:GraphQL` gets `Permission denied`. |+| `AWS_IAM` with a `SigV4` header that misses a part or a date, a date not in the ISO-8601 basic format, a credential without 5 parts, or a signed header the request lacks | **403** | `IncompleteSignatureException` with AWS's message. A missing part names a Base64 SHA-256 hash of the `Authorization` header. |+| `AWS_IAM` signed outside 5 minutes, without `host` in `SignedHeaders`, scoped to another service, terminator or date, or with a signature that does not match | **400** | `BadRequestException` with AWS's message. A mismatch names the canonical request and the string to sign that Floci computed. || `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`) |@@ -249,7 +251,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.`, except the 403 `AWS_IAM` cases in the table above.+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 `AWS_IAM` cases in the table above.| Header shape | Mode ||---|---|@@ -263,7 +265,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 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`. |+| 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. The checks run in AppSync's order. The scope's region is not checked, because Floci takes the request's region from it. 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/core/common/SigV4HeaderSignatureFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/SigV4HeaderSignatureFilter.javaindex c43840aac8..41a6e5ffa8 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/SigV4HeaderSignatureFilter.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/SigV4HeaderSignatureFilter.java@@ -160,7 +160,7 @@ public class SigV4HeaderSignatureFilter implements ContainerRequestFilter {return;}signed = new SigV4AuthorizationHeader(query.getFirst("X-Amz-Credential"),- query.getFirst("X-Amz-SignedHeaders"), query.getFirst("X-Amz-Signature"));+ query.getFirst("X-Amz-SignedHeaders"), query.getFirst("X-Amz-Signature"), false);} else {signed = SigV4AuthorizationHeader.parse(authorization);if (signed == null) {diff --git a/src/main/java/io/github/hectorvent/floci/core/common/auth/CredentialScope.java b/src/main/java/io/github/hectorvent/floci/core/common/auth/CredentialScope.javaindex 6eae14fc5a..368aa7e115 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/auth/CredentialScope.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/auth/CredentialScope.java@@ -7,9 +7,8 @@ import java.util.Locale;* carried by a {@code Credential} parameter, whether that parameter arrived in an* {@code Authorization} header or an {@code X-Amz-Credential} query/token component. Shared by* every SigV4 verifier in this codebase that checks an Authorization-header-signed request- * against this exact five-part shape: {@code ExecuteApiSigV4Authorizer} (API Gateway) and- * {@code IamAuthValidator} (AppSync) both parsed and rebuilt this independently before this class- * existed.+ * against this exact five-part shape. AppSync's {@code IamAuthValidator} splits the scope itself,+ * because it names each fault the way AppSync does.*/public record CredentialScope(String accessKeyId, String date, String region, String service) {diff --git a/src/main/java/io/github/hectorvent/floci/core/common/auth/SigV4AuthorizationHeader.java b/src/main/java/io/github/hectorvent/floci/core/common/auth/SigV4AuthorizationHeader.javaindex 0782114100..c2544b9ab7 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/auth/SigV4AuthorizationHeader.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/auth/SigV4AuthorizationHeader.java@@ -9,8 +9,11 @@ import java.util.Map;* Shared by every SigV4 verifier in this codebase that accepts a header-signed request:* {@code ExecuteApiSigV4Authorizer} (API Gateway) and {@code IamAuthValidator} (AppSync) both* parsed this independently before this class existed.+ *+ * <p>{@code missingEqualSign} is true when a part has no {@code =}. AppSync refuses such a header.*/-public record SigV4AuthorizationHeader(String credential, String signedHeaders, String signature) {+public record SigV4AuthorizationHeader(String credential, String signedHeaders, String signature,+ boolean missingEqualSign) {private static final String ALGORITHM = "AWS4-HMAC-SHA256";@@ -29,13 +32,16 @@ public record SigV4AuthorizationHeader(String credential, String signedHeaders,return null;}Map<String, String> parameters = new LinkedHashMap<>();+ boolean missingEqualSign = false;for (String part : trimmed.substring(ALGORITHM.length()).split(",")) {int equals = part.indexOf('=');if (equals > 0) {parameters.put(part.substring(0, equals).trim(), part.substring(equals + 1).trim());+ } else if (equals < 0 && !part.isBlank()) {+ missingEqualSign = true;}}- return new SigV4AuthorizationHeader(- parameters.get("Credential"), parameters.get("SignedHeaders"), parameters.get("Signature"));+ return new SigV4AuthorizationHeader(parameters.get("Credential"), parameters.get("SignedHeaders"),+ parameters.get("Signature"), missingEqualSign);}}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 e264a06707..e0a174b0f9 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@@ -38,6 +38,19 @@ public final class AppSyncAuth {return new AppSyncTransportException(403, UNRECOGNIZED_CLIENT_TYPE, INVALID_SECURITY_TOKEN);}+ /** An {@code AWS_IAM} caller whose policies do not allow {@code appsync:GraphQL}. */+ public static AppSyncTransportException permissionDenied() {+ return new AppSyncTransportException(401, UNAUTHORIZED_TYPE, "Permission denied");+ }++ public static AppSyncTransportException incompleteSignature(String message) {+ return new AppSyncTransportException(403, "IncompleteSignatureException", message);+ }++ public static AppSyncTransportException badRequest(String message) {+ return new AppSyncTransportException(400, "BadRequestException", message);+ }+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 eb0494d8d4..13c1797f9c 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@@ -1,13 +1,12 @@package io.github.hectorvent.floci.services.appsync.graphql.auth;-import io.github.hectorvent.floci.core.common.AccountResolver;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.core.common.auth.SigV4SignedRequest;import io.github.hectorvent.floci.services.appsync.graphql.AppSyncTransportException;import io.github.hectorvent.floci.services.iam.IamPolicyEvaluator;import io.github.hectorvent.floci.services.iam.IamService;@@ -18,9 +17,14 @@ import org.jboss.logging.Logger;import java.nio.charset.StandardCharsets;import java.security.MessageDigest;+import java.time.Clock;+import java.time.DateTimeException;import java.time.Instant;import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;+import java.util.ArrayList;+import java.util.Base64;+import java.util.List;import java.util.Locale;import java.util.Map;@@ -49,30 +53,34 @@ public class IamAuthValidator {private static final String SIGNING_SERVICE = "appsync";private static final DateTimeFormatter AMZ_DATE =DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'").withZone(ZoneOffset.UTC);- private static final long MAX_CLOCK_SKEW_SECONDS = 300;+ private static final String TERMINATOR = "aws4_request";+ private static final String SIGNATURE_MISMATCH = "The request signature we calculated does not match the signature"+ + " you provided. Check your AWS Secret Access Key and signing method. Consult the service documentation"+ + " for details.";private static final String LEGACY_ACCESS_KEY_ID = "test";private static final String LEGACY_SECRET_KEY = "test";private static final String SECURITY_TOKEN = "X-Amz-Security-Token";- private final AccountResolver accountResolver;private final IamService iamService;private final IamPolicyEvaluator iamPolicyEvaluator;+ private final Clock clock;@Inject- public IamAuthValidator(AccountResolver accountResolver,- IamService iamService,- IamPolicyEvaluator iamPolicyEvaluator) {- this.accountResolver = accountResolver;+ public IamAuthValidator(IamService iamService, IamPolicyEvaluator iamPolicyEvaluator) {+ this(iamService, iamPolicyEvaluator, Clock.systemUTC());+ }++ IamAuthValidator(IamService iamService, IamPolicyEvaluator iamPolicyEvaluator, Clock clock) {this.iamService = iamService;this.iamPolicyEvaluator = iamPolicyEvaluator;+ this.clock = clock;}public Map<String, Object> validateRequest(String authorization, String apiId, AuthRequestInfo info) {- String accessKeyId = accountResolver.extractAccessKeyId(authorization);- if (accessKeyId == null || accessKeyId.isBlank()) {+ if (authorization == null || !authorization.trim().startsWith(ALGORITHM)) {throw AppSyncAuth.unauthorized();}- verifySignature(authorization, apiId, info, accessKeyId);+ String accessKeyId = verifySignature(authorization.trim(), apiId, info);if (!isEmulatorAllow(accessKeyId)) {CallerContext caller = iamService.resolveCallerContext(accessKeyId);if (caller != null) {@@ -80,7 +88,7 @@ public class IamAuthValidator {IamPolicyEvaluator.Decision decision = iamPolicyEvaluator.evaluate(caller, null, "appsync:GraphQL", resource, null);if (decision == IamPolicyEvaluator.Decision.DENY) {- throw AppSyncAuth.unauthorized();+ throw AppSyncAuth.permissionDenied();}}}@@ -98,60 +106,140 @@ public class IamAuthValidator {}/**- * Fails closed: a missing/unparsable {@code Authorization} header, a credential not scoped to- * {@code appsync}, a signing timestamp outside the accepted clock skew, an access key this- * emulator has never registered, or a signature that does not match are all rejected. There is- * no default secret and no path that authenticates an unregistered key.+ * Returns the access key that signed the request. The checks run in AppSync's order with its+ * wording. AppSync names the scope region it refuses, but Floci takes the request's region from+ * that scope, so it is not checked. There is no default secret and no path that authenticates+ * an unregistered key.*/- private void verifySignature(String authorization, String apiId, AuthRequestInfo info, String accessKeyId) {- SignedRequest signed = headerSignedRequest(authorization, info.requestHeaders());- if (signed == null) {- throw AppSyncAuth.unauthorized();+ private String verifySignature(String authorization, String apiId, AuthRequestInfo info) {+ Map<String, String> headers = info.requestHeaders();+ SigV4AuthorizationHeader parsed = SigV4AuthorizationHeader.parse(authorization);+ if (parsed.missingEqualSign()) {+ throw AppSyncAuth.incompleteSignature("Invalid key=value pair (missing equal-sign) in Authorization"+ + " header (hashed with SHA-256 and encoded with Base64): '" + hashed(authorization) + "'.");}- CredentialScope scope = CredentialScope.parse(signed.credential());- if (scope == null || !SIGNING_SERVICE.equals(scope.service()) || !accessKeyId.equals(scope.accessKeyId())) {- throw AppSyncAuth.unauthorized();+ String credential = parsed.credential();+ String signedHeaders = parsed.signedHeaders();+ String signature = parsed.signature();+ String date = hasHeader(headers, "X-Amz-Date") ? header(headers, "X-Amz-Date")+ : hasHeader(headers, "Date") ? header(headers, "Date") : null;+ List<String> missing = new ArrayList<>();+ if (isBlank(credential)) {+ missing.add("Authorization header requires 'Credential' parameter.");}- Instant signedAt;- try {- signedAt = Instant.from(AMZ_DATE.parse(signed.amzDate()));- } catch (Exception e) {- throw AppSyncAuth.unauthorized();+ if (isBlank(signature)) {+ missing.add("Authorization header requires 'Signature' parameter.");}- if (Math.abs(Instant.now().getEpochSecond() - signedAt.getEpochSecond()) > MAX_CLOCK_SKEW_SECONDS) {- throw AppSyncAuth.unauthorized();+ if (isBlank(signedHeaders)) {+ missing.add("Authorization header requires 'SignedHeaders' parameter.");+ }+ if (date == null) {+ missing.add("Authorization header requires existence of either a 'X-Amz-Date' or a 'Date' header.");+ }+ if (!missing.isEmpty()) {+ throw AppSyncAuth.incompleteSignature(String.join(" ", missing)+ + " (Hashed with SHA-256 and encoded with Base64) Authorization=" + hashed(authorization));+ }+ Instant signedAt = signedAt(date);+ if (signedAt == null) {+ throw AppSyncAuth.incompleteSignature("Date must be in ISO-8601 'basic format'. Got '" + date+ + "'. See http://en.wikipedia.org/wiki/ISO_8601");}+ checkSigningTime(signedAt);+ for (String name : signedHeaders.split(";")) {+ if (!hasHeader(headers, name)) {+ throw AppSyncAuth.incompleteSignature("'" + name+ + "' is named as a SignedHeader, but it does not exist in the HTTP request.");+ }+ }+ String names = signedHeaders.toLowerCase(Locale.ROOT);+ if (!SigV4RequestValidator.containsHeader(names, "host")+ && !SigV4RequestValidator.containsHeader(names, ":authority")) {+ throw AppSyncAuth.badRequest("'Host' or ':authority' must be a 'SignedHeader' in the AWS Authorization.");+ }+ String[] scope = credential.split("/", -1);+ if (scope.length != 5) {+ throw AppSyncAuth.incompleteSignature("Credential must have exactly 5 slash-delimited elements,"+ + " e.g. keyid/date/region/service/term, got '" + credential + "'");+ }+ String amzDate = AMZ_DATE.format(signedAt);+ checkScope(scope, amzDate);+ String accessKeyId = scope[0];String secretKey = resolveSecretKey(accessKeyId);if (secretKey == null) {LOG.debugv("AppSync SigV4 request references unregistered access key={0}",SigV4RequestValidator.sanitizeForLog(accessKeyId));throw AppSyncAuth.unrecognizedClient();}- checkSessionToken(accessKeyId, info.requestHeaders());+ String canonicalRequest = "POST\n/v1/apis/" + apiId + "/graphql\n\n" + canonicalHeaders(names, headers)+ + "\n" + names + "\n" + Digests.sha256Hex(info.rawBody().getBytes(StandardCharsets.UTF_8));+ String stringToSign = ALGORITHM + "\n" + amzDate + "\n" + String.join("/", scope[1], scope[2], scope[3], scope[4])+ + "\n" + Digests.sha256Hex(canonicalRequest.getBytes(StandardCharsets.UTF_8));+ String expected;try {- String canonicalUri = "/v1/apis/" + apiId + "/graphql";- String payloadHash = Digests.sha256Hex(info.rawBody().getBytes(StandardCharsets.UTF_8));- String canonicalHeaders = canonicalHeaders(signed.signedHeaders(), info.requestHeaders());- String canonicalRequest = "POST\n" + canonicalUri + "\n\n"- + canonicalHeaders + "\n" + signed.signedHeaders() + "\n" + payloadHash;- String stringToSign = ALGORITHM + "\n" + signed.amzDate() + "\n" + scope.credentialScope() + "\n"- + Digests.sha256Hex(canonicalRequest.getBytes(StandardCharsets.UTF_8));- byte[] signingKey = SigV4RequestValidator.deriveSigningKey(- secretKey, scope.date(), scope.region(), scope.service());- String expected = SigV4RequestValidator.hexEncode(- SigV4RequestValidator.hmacSha256(signingKey, stringToSign));- if (!MessageDigest.isEqual(expected.getBytes(StandardCharsets.UTF_8),- signed.signature().getBytes(StandardCharsets.UTF_8))) {- LOG.debugv("AppSync SigV4 signature mismatch for accessKey={0}",- SigV4RequestValidator.sanitizeForLog(accessKeyId));- throw AppSyncAuth.unauthorized();- }- } catch (AppSyncTransportException e) {- throw e;+ byte[] signingKey = SigV4RequestValidator.deriveSigningKey(secretKey, scope[1], scope[2], scope[3]);+ expected = SigV4RequestValidator.hexEncode(SigV4RequestValidator.hmacSha256(signingKey, stringToSign));} catch (Exception e) {LOG.debugv(e, "AppSync SigV4 verification failed to complete: {0}", e.getMessage());throw AppSyncAuth.unauthorized();}+ if (!MessageDigest.isEqual(expected.getBytes(StandardCharsets.UTF_8), signature.getBytes(StandardCharsets.UTF_8))) {+ LOG.debugv("AppSync SigV4 signature mismatch for accessKey={0}",+ SigV4RequestValidator.sanitizeForLog(accessKeyId));+ throw AppSyncAuth.badRequest(SIGNATURE_MISMATCH + "\n\nThe Canonical String for this request should have been\n'"+ + canonicalRequest + "'\n\nThe String-to-Sign should have been\n'" + stringToSign + "'\n");+ }+ checkSessionToken(accessKeyId, headers);+ return accessKeyId;+ }++ private static String hashed(String authorization) {+ return Base64.getEncoder().encodeToString(Digests.sha256(authorization.getBytes(StandardCharsets.UTF_8)));+ }++ /** AppSync reads the basic format, and the extended one too. */+ private static Instant signedAt(String date) {+ try {+ return Instant.from(AMZ_DATE.parse(date));+ } catch (DateTimeException notBasic) {+ try {+ return Instant.parse(date);+ } catch (DateTimeException expected) {+ // Refused with the basic format message.+ return null;+ }+ }+ }++ private void checkSigningTime(Instant signedAt) {+ Instant now = clock.instant();+ Instant earliest = now.minusSeconds(SigV4SignedRequest.MAX_CLOCK_SKEW_SECONDS);+ Instant latest = now.plusSeconds(SigV4SignedRequest.MAX_CLOCK_SKEW_SECONDS);+ if (signedAt.isBefore(earliest)) {+ throw AppSyncAuth.badRequest("Signature expired: " + AMZ_DATE.format(signedAt) + " is now earlier than "+ + AMZ_DATE.format(earliest) + " (" + AMZ_DATE.format(now) + " - 5 min.)");+ }+ if (signedAt.isAfter(latest)) {+ throw AppSyncAuth.badRequest("Signature not yet current: " + AMZ_DATE.format(signedAt)+ + " is still later than " + AMZ_DATE.format(latest) + " (" + AMZ_DATE.format(now) + " + 5 min.)");+ }+ }++ /** {@code scope} is key, date, region, service and terminator. AppSync reports every fault at once. */+ private static void checkScope(String[] scope, String amzDate) {+ List<String> faults = new ArrayList<>();+ if (!SIGNING_SERVICE.equals(scope[3])) {+ faults.add("Credential should be scoped to correct service: '" + SIGNING_SERVICE + "'.");+ }+ if (!TERMINATOR.equals(scope[4])) {+ faults.add("Credential should be scoped with a valid terminator: '" + TERMINATOR + "'.");+ }+ if (!amzDate.substring(0, 8).equals(scope[1])) {+ faults.add("Date in Credential scope does not match YYYYMMDD from ISO-8601 version of date from HTTP.");+ }+ if (!faults.isEmpty()) {+ throw AppSyncAuth.badRequest(String.join(" ", faults) + " ");+ }}/**@@ -183,31 +271,6 @@ public class IamAuthValidator {}}- private record SignedRequest(String credential, String signedHeaders, String signature, String amzDate) {}-- /**- * {@code X-Amz-Date} is a real HTTP header on a header-signed request, never a field inside the- * {@code Authorization} value itself (that only ever carries {@code Credential}/- * {@code SignedHeaders}/{@code Signature}), so it is read from {@code requestHeaders} - the same- * source {@code ExecuteApiSigV4Authorizer} reads it from. There is no fallback to the plain- * {@code Date} header: unlike {@code X-Amz-Date}, it is RFC 1123-formatted, which {@link- * #AMZ_DATE} can never parse, so a request that only sets {@code Date} is rejected below- * regardless.- */- private static SignedRequest headerSignedRequest(String authorization, Map<String, String> requestHeaders) {- SigV4AuthorizationHeader parsed = SigV4AuthorizationHeader.parse(authorization);- if (parsed == null) {- return null;- }- String amzDate = header(requestHeaders, "X-Amz-Date");- if (isBlank(parsed.credential()) || isBlank(parsed.signedHeaders())- || isBlank(parsed.signature()) || isBlank(amzDate)) {- return null;- }- return new SignedRequest(parsed.credential(), parsed.signedHeaders().toLowerCase(Locale.ROOT),- parsed.signature(), amzDate);- }-private static String canonicalHeaders(String signedHeaders, Map<String, String> requestHeaders) {StringBuilder canonical = new StringBuilder();for (String name : signedHeaders.split(";")) {diff --git a/src/test/java/io/github/hectorvent/floci/core/common/SigV4HeaderSignatureIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/core/common/SigV4HeaderSignatureIntegrationTest.javaindex def4d81c89..ff7682eec0 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/SigV4HeaderSignatureIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/SigV4HeaderSignatureIntegrationTest.java@@ -427,7 +427,7 @@ class SigV4HeaderSignatureIntegrationTest {@Order(17)void appSyncGraphqlIsLeftToItsOwnIamCheck() throws Exception {// The management plane is verified here like any other service; the GraphQL endpoint is- // AppSync's own, and a wrong secret there gets AppSync's UnauthorizedException envelope.+ // AppSync's own, and a wrong secret there gets AppSync's BadRequestException envelope.String apiId = given().filter(AwsRequestSigner.signedAs("test", "test", "appsync")).contentType("application/json")@@ -448,9 +448,9 @@ class SigV4HeaderSignatureIntegrationTest {.when().post("/v1/apis/" + apiId + "/graphql").then()- .statusCode(401)- .header("x-amzn-errortype", containsString("UnauthorizedException"))- .body("errors[0].errorType", equalTo("UnauthorizedException"));+ .statusCode(400)+ .header("x-amzn-errortype", containsString("BadRequestException"))+ .body("errors[0].errorType", equalTo("BadRequestException"));}private static HttpResponse<String> sendSqsListQueues(URI uri, Map<String, String> auth, String contentType,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 7a30950534..2eb8c0fbc5 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@@ -1,7 +1,7 @@package io.github.hectorvent.floci.services.appsync.graphql.auth;import com.fasterxml.jackson.databind.ObjectMapper;-import io.github.hectorvent.floci.core.common.AccountResolver;+import io.github.hectorvent.floci.core.common.Digests;import io.github.hectorvent.floci.services.appsync.graphql.AppSyncTransportException;import io.github.hectorvent.floci.services.iam.IamPolicyEvaluator;import io.github.hectorvent.floci.services.iam.IamService;@@ -13,7 +13,12 @@ import org.junit.jupiter.api.extension.ExtendWith;import org.mockito.Mock;import org.mockito.junit.jupiter.MockitoExtension;+import java.nio.charset.StandardCharsets;+import java.time.Clock;import java.time.Instant;+import java.time.ZoneOffset;+import java.util.Base64;+import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Optional;@@ -45,6 +50,7 @@ class IamAuthValidatorTest {private static final String HOST = "appsync.us-east-1.amazonaws.com";private static final String REGION = "us-east-1";private static final String BODY = "{ hello }";+ private static final Instant NOW = Instant.parse("2026-10-17T22:16:18Z");@MockIamService iamService;@@ -54,9 +60,9 @@ class IamAuthValidatorTest {@BeforeEachvoid setUp() {validator = new IamAuthValidator(- new AccountResolver("000000000000"),iamService,- new IamPolicyEvaluator(new ObjectMapper()));+ new IamPolicyEvaluator(new ObjectMapper()),+ Clock.fixed(NOW, ZoneOffset.UTC));lenient().when(iamService.findSecretKey("AKIAGOOD")).thenReturn(Optional.of("good-secret"));lenient().when(iamService.findSecretKey("AKIDDENY")).thenReturn(Optional.of("deny-secret"));}@@ -76,7 +82,7 @@ class IamAuthValidatorTest {when(iamService.resolveCallerArn("AKIAGOOD")).thenReturn(Optional.of("arn:aws:iam::000000000000:user/alice"));Map<String, String> signed = AppSyncRequestSigner.signedHeaders(- "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, Instant.now());+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, NOW);Map<String, Object> identity = validator.validateRequest(authorization(signed), "api-1", infoWith(signed));@@ -91,44 +97,172 @@ class IamAuthValidatorTest {void knownRequestDenyThrows401() throws Exception {when(iamService.resolveCallerContext("AKIDDENY")).thenReturn(CallerContext.of(List.of(DENY)));Map<String, String> signed = AppSyncRequestSigner.signedHeaders(- "api-1", HOST, BODY, "AKIDDENY", "deny-secret", REGION, Instant.now());+ "api-1", HOST, BODY, "AKIDDENY", "deny-secret", REGION, NOW);AppSyncTransportException ex = assertThrows(AppSyncTransportException.class,() -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));assertEquals(401, ex.getHttpStatus());+ assertEquals("UnauthorizedException", ex.getErrorType());+ assertEquals("Permission denied", ex.getMessage());}@Test- void knownKeyWithBadSignatureIs401() throws Exception {+ void knownKeyWithBadSignatureIsABadRequestNamingTheCanonicalRequest() throws Exception {Map<String, String> signed = AppSyncRequestSigner.signedHeaders(- "api-1", HOST, BODY, "AKIAGOOD", "wrong-secret", REGION, Instant.now());-- assertThrows(AppSyncTransportException.class,- () -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));+ "api-1", HOST, BODY, "AKIAGOOD", "wrong-secret", REGION, NOW);++ AppSyncTransportException ex = assertRejected(signed, 400, "BadRequestException");+ assertTrue(ex.getMessage().startsWith("The request signature we calculated does not match the signature you"+ + " provided. Check your AWS Secret Access Key and signing method. Consult the service documentation"+ + " for details.\n\nThe Canonical String for this request should have been\n'POST\n"+ + "/v1/apis/api-1/graphql\n\nhost:" + HOST + "\nx-amz-date:" + signed.get("X-Amz-Date")+ + "\n\nhost;x-amz-date\n"), ex.getMessage());+ assertTrue(ex.getMessage().contains("'\n\nThe String-to-Sign should have been\n'AWS4-HMAC-SHA256\n"+ + signed.get("X-Amz-Date") + "\n"), ex.getMessage());}@Test- void tamperedBodyAfterSigningIs401() throws Exception {+ void tamperedBodyAfterSigningIsABadRequest() throws Exception {Map<String, String> signed = AppSyncRequestSigner.signedHeaders(- "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, Instant.now());+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, NOW);AuthRequestInfo tampered = new AuthRequestInfo("{ hello }", null, Map.of(), List.of("10.0.0.1"),"req-1", "000000000000", "us-east-1", signed, "{ hello, tampered }");- assertThrows(AppSyncTransportException.class,+ AppSyncTransportException ex = assertThrows(AppSyncTransportException.class,() -> validator.validateRequest(authorization(signed), "api-1", tampered));+ assertEquals(400, ex.getHttpStatus());}@Test- void unsignedRequestIsRejected() {- assertThrows(AppSyncTransportException.class, () -> validator.validateRequest(- "AWS4-HMAC-SHA256 Credential=AKIAGOOD/20260205/us-east-1/appsync/aws4_request",- "api-1", infoWith(Map.of())));+ void missingPartsAreNamedTogetherWithTheHeaderHash() throws Exception {+ String authorization = "AWS4-HMAC-SHA256 Credential=AKIAGOOD/20260205/us-east-1/appsync/aws4_request";+ AppSyncTransportException ex = assertRejected(authorization, Map.of(), 403, "IncompleteSignatureException");+ assertEquals("Authorization header requires 'Signature' parameter."+ + " Authorization header requires 'SignedHeaders' parameter."+ + " Authorization header requires existence of either a 'X-Amz-Date' or a 'Date' header."+ + " (Hashed with SHA-256 and encoded with Base64) Authorization=" + hashed(authorization),+ ex.getMessage());++ assertEquals("Authorization header requires 'Credential' parameter."+ + " Authorization header requires 'Signature' parameter."+ + " Authorization header requires 'SignedHeaders' parameter."+ + " (Hashed with SHA-256 and encoded with Base64) Authorization=" + hashed("AWS4-HMAC-SHA256"),+ assertRejected("AWS4-HMAC-SHA256", Map.of("X-Amz-Date", "20260205T000000Z"), 403,+ "IncompleteSignatureException").getMessage());+ }++ @Test+ void aPartWithoutAnEqualsSignRefusesTheHeader() {+ String authorization = "AWS4-HMAC-SHA256 garbage";+ assertEquals("Invalid key=value pair (missing equal-sign) in Authorization header (hashed with SHA-256 and"+ + " encoded with Base64): '" + hashed(authorization) + "'.",+ assertRejected(authorization, Map.of(), 403, "IncompleteSignatureException").getMessage());+ }++ @Test+ void theDateMustBeInTheBasicFormatAndTheCredentialHaveFiveParts() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, NOW);+ Map<String, String> dated = new LinkedHashMap<>(signed);+ dated.remove("X-Amz-Date");+ dated.put("Date", "Sat, 17 Oct 2026 22:15:13 GMT");+ assertEquals("Date must be in ISO-8601 'basic format'. Got 'Sat, 17 Oct 2026 22:15:13 GMT'."+ + " See http://en.wikipedia.org/wiki/ISO_8601",+ assertRejected(dated, 403, "IncompleteSignatureException").getMessage());++ String credential = "AKIAGOOD/x/y";+ assertEquals("Credential must have exactly 5 slash-delimited elements, e.g. keyid/date/region/service/term,"+ + " got 'AKIAGOOD/x/y'", assertRejected(withCredential(signed, credential), 403,+ "IncompleteSignatureException").getMessage());+ }++ @Test+ void aSignatureFromTheFutureIsNotYetCurrent() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, NOW.plusSeconds(600));++ assertEquals("Signature not yet current: 20261017T222618Z is still later than 20261017T222118Z"+ + " (20261017T221618Z + 5 min.)", assertRejected(signed, 400, "BadRequestException").getMessage());+ }++ @Test+ void theHostMustBeSignedBeforeTheScopeIsChecked() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, NOW);+ Map<String, String> unsignedHost = withCredential(signed,+ credential(signed).replace("/appsync/", "/execute-api/"));+ unsignedHost.put("Authorization", unsignedHost.get("Authorization").replace("host;x-amz-date", "x-amz-date"));++ assertEquals("'Host' or ':authority' must be a 'SignedHeader' in the AWS Authorization.",+ assertRejected(unsignedHost, 400, "BadRequestException").getMessage());+ }++ @Test+ void everyScopeFaultIsNamedAtOnce() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, NOW);+ String[] scope = credential(signed).split("/");+ String faulty = String.join("/", scope[0], "20200101", scope[2], "execute-api", "aws5_request");++ assertEquals("Credential should be scoped to correct service: 'appsync'."+ + " Credential should be scoped with a valid terminator: 'aws4_request'."+ + " Date in Credential scope does not match YYYYMMDD from ISO-8601 version of date from HTTP. ",+ assertRejected(withCredential(signed, faulty), 400, "BadRequestException").getMessage());+ }++ @Test+ void aSignedHeaderMustBeInTheRequestBeforeTheHostOrTheCredentialIsChecked() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, NOW);+ Map<String, String> missing = withCredential(signed, "AKIAGOOD/x/y");+ missing.put("Authorization", missing.get("Authorization").replace("host;x-amz-date", "x-amz-date;X-Extra"));++ assertEquals("'X-Extra' is named as a SignedHeader, but it does not exist in the HTTP request.",+ assertRejected(missing, 403, "IncompleteSignatureException").getMessage());+ }++ @Test+ void theHostIsCheckedBeforeTheCredentialParts() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, NOW);+ Map<String, String> unsignedHost = withCredential(signed, "AKIAGOOD/x/y");+ unsignedHost.put("Authorization", unsignedHost.get("Authorization").replace("host;x-amz-date", "x-amz-date"));++ assertEquals("'Host' or ':authority' must be a 'SignedHeader' in the AWS Authorization.",+ assertRejected(unsignedHost, 400, "BadRequestException").getMessage());+ }++ private AppSyncTransportException assertRejected(Map<String, String> signed, int status, String errorType) {+ return assertRejected(authorization(signed), signed, status, errorType);+ }++ private AppSyncTransportException assertRejected(String authorization, Map<String, String> headers, int status,+ String errorType) {+ AppSyncTransportException ex = assertThrows(AppSyncTransportException.class,+ () -> validator.validateRequest(authorization, "api-1", infoWith(headers)));+ assertEquals(status, ex.getHttpStatus(), ex.getMessage());+ assertEquals(errorType, ex.getErrorType());+ return ex;+ }++ private static String credential(Map<String, String> signed) {+ return authorization(signed).split("Credential=")[1].split(",")[0];+ }++ private static Map<String, String> withCredential(Map<String, String> signed, String credential) {+ Map<String, String> changed = new LinkedHashMap<>(signed);+ changed.put("Authorization", authorization(signed).replace(credential(signed), credential));+ return changed;+ }++ private static String hashed(String authorization) {+ return Base64.getEncoder().encodeToString(Digests.sha256(authorization.getBytes(StandardCharsets.UTF_8)));}@Testvoid unknownAccessKeyNeverResolvesToRoot() throws Exception {Map<String, String> signed = AppSyncRequestSigner.signedHeaders(- "api-1", HOST, BODY, "AKIAUNKNOWN", "whatever-secret", REGION, Instant.now());+ "api-1", HOST, BODY, "AKIAUNKNOWN", "whatever-secret", REGION, NOW);assertRefused(signed, "The security token included in the request is invalid.");}@@ -137,16 +271,16 @@ class IamAuthValidatorTest {void expiredSignatureIsRejected() throws Exception {Map<String, String> signed = AppSyncRequestSigner.signedHeaders("api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION,- Instant.now().minusSeconds(3600));+ NOW.minusSeconds(3600));- assertThrows(AppSyncTransportException.class,- () -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));+ assertEquals("Signature expired: 20261017T211618Z is now earlier than 20261017T221118Z"+ + " (20261017T221618Z - 5 min.)", assertRejected(signed, 400, "BadRequestException").getMessage());}@Testvoid legacyTestKeyMustStillBeSigned() throws Exception {Map<String, String> signed = AppSyncRequestSigner.signedHeaders(- "api-1", HOST, BODY, "test", "test", REGION, Instant.now());+ "api-1", HOST, BODY, "test", "test", REGION, NOW);Map<String, Object> identity = validator.validateRequest(authorization(signed), "api-1", infoWith(signed));@@ -192,7 +326,7 @@ class IamAuthValidatorTest {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());+ "api-1", HOST, BODY, "ASIANOTOKEN", "session-secret", REGION, NOW);assertRefused(signed, "The security token included in the request is invalid.");}@@ -252,7 +386,7 @@ class IamAuthValidatorTest {private static Map<String, String> signedWithSessionToken(String accessKeyId, String secretKey, String token)throws Exception {Map<String, String> signed = new java.util.LinkedHashMap<>(AppSyncRequestSigner.signedHeaders(- "api-1", HOST, BODY, accessKeyId, secretKey, REGION, Instant.now()));+ "api-1", HOST, BODY, accessKeyId, secretKey, REGION, NOW));signed.put("X-Amz-Security-Token", token);return signed;}