Light, fluffy, and always free - The AWS Local Emulator alternative
fix(appsync): verify JWT signatures and SigV4 requests for GraphQL auth (#3541)
Niels Kootstraf38a384e5101
diff --git a/docs/services/appsync.md b/docs/services/appsync.mdindex abb27e480d..9fcee65b56 100644--- a/docs/services/appsync.md+++ b/docs/services/appsync.md@@ -222,8 +222,8 @@ 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 | Parses `Credential=` access key; no HMAC. Known keys evaluate `appsync:GraphQL`. Unknown/`test` keys are emulator ALLOW. |-| Cognito / OIDC | JWT payload decode only (no JWKS). OIDC as the sole mode skips the `iss` check. OIDC identity is `{sub, issuer, claims}` (no `sourceIp`). |+| 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`. |+| 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). |SDL field auth: unmarked fields require the API **default** mode. Additional modes unlock fields tagged `@aws_api_key` / `@aws_iam` / `@aws_oidc` / `@aws_cognito_user_pools` / `@aws_lambda`. Multiple directives on a field are OR. Field-level directives override type-level. `@aws_auth` is allowed on `OBJECT \| FIELD_DEFINITION` and is ignored when additional modes exist.diff --git a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/JwtSignatureVerifier.java b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/JwtSignatureVerifier.javaindex 2cbda32ef9..1478f76eda 100644--- a/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/JwtSignatureVerifier.java+++ b/src/main/java/io/github/hectorvent/floci/services/apigatewayv2/JwtSignatureVerifier.java@@ -60,8 +60,12 @@ public class JwtSignatureVerifier {.build());}- /** Package-private for tests: injects a client pointed at a local fixture server. */- JwtSignatureVerifier(ObjectMapper objectMapper, HttpClient httpClient) {+ /**+ * Injects a caller-supplied client, so tests (including {@code OidcAuthValidatorTest} in the+ * AppSync auth package, which points it at a local fixture server) don't have to reach the+ * real network to exercise verification.+ */+ public JwtSignatureVerifier(ObjectMapper objectMapper, HttpClient httpClient) {this.objectMapper = objectMapper;this.httpClient = httpClient;}diff --git a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncExecutionController.java b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncExecutionController.javaindex a7ea596de8..86548c571f 100644--- a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncExecutionController.java+++ b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/AppSyncExecutionController.java@@ -97,7 +97,7 @@ public class AppSyncExecutionController {AppSyncAuthContext authContext;try {authContext = authMiddleware.authenticate(- headerMap(headers), api, authRequestInfo(parsed, headers));+ headerMap(headers), api, authRequestInfo(parsed, headers, body));} catch (AppSyncTransportException e) {return graphqlError(e.getHttpStatus(), e.getErrorType(), e.getMessage());}@@ -203,7 +203,7 @@ public class AppSyncExecutionController {return map;}- private AuthRequestInfo authRequestInfo(ParsedRequest parsed, HttpHeaders headers) {+ private AuthRequestInfo authRequestInfo(ParsedRequest parsed, HttpHeaders headers, String rawBody) {String accountId = requestContext.getAccountId() != null ? requestContext.getAccountId() : "000000000000";String region = requestContext.getRegion() != null ? requestContext.getRegion() : "us-east-1";String requestId = headers.getHeaderString("x-amzn-RequestId");@@ -218,7 +218,8 @@ public class AppSyncExecutionController {requestId,accountId,region,- headerMap(headers));+ headerMap(headers),+ rawBody);}private static List<String> sourceIp(HttpHeaders headers) {diff --git a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AuthRequestInfo.java b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AuthRequestInfo.javaindex 0219f40d38..d4b45c9f57 100644--- a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AuthRequestInfo.java+++ b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AuthRequestInfo.java@@ -11,11 +11,13 @@ public record AuthRequestInfo(String requestId,String accountId,String region,- Map<String, String> requestHeaders+ Map<String, String> requestHeaders,+ String rawBody) {public AuthRequestInfo {sourceIp = sourceIp == null ? List.of() : List.copyOf(sourceIp);variables = variables == null ? Map.of() : Map.copyOf(variables);requestHeaders = requestHeaders == null ? Map.of() : Map.copyOf(requestHeaders);+ rawBody = rawBody == null ? "" : rawBody;}}diff --git a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/CognitoAuthValidator.java b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/CognitoAuthValidator.javaindex 2344aa57cc..92f67b846f 100644--- a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/CognitoAuthValidator.java+++ b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/CognitoAuthValidator.java@@ -1,28 +1,50 @@package io.github.hectorvent.floci.services.appsync.graphql.auth;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cognito.CognitoService;+import io.github.hectorvent.floci.services.cognito.model.UserPool;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;+import java.nio.charset.StandardCharsets;+import java.security.KeyFactory;+import java.security.PublicKey;+import java.security.Signature;+import java.security.spec.X509EncodedKeySpec;import java.time.Clock;+import java.util.Base64;import java.util.List;import java.util.Map;import java.util.regex.Pattern;+/**+ * Verifies a Cognito user pool bearer token the same way real AppSync does: a valid RS256+ * signature from the pool's own signing key, a {@code kid} that names that key, and the pool's+ * real issuer, on top of the existing expiry/audience checks.+ *+ * <p>The signing key is read directly off the {@link UserPool} model rather than fetched over+ * HTTP from the emulator's own {@code .well-known/jwks.json}: Floci's Cognito emulator and AppSync+ * run in the same process, so there is a real key to read in memory, and looping back over HTTP to+ * ourselves would only add a network dependency a unit test would otherwise need to fake.+ */@ApplicationScopedpublic class CognitoAuthValidator {private final JwtClaimsDecoder jwtClaimsDecoder;+ private final CognitoService cognitoService;private final Clock clock;@Inject- public CognitoAuthValidator(JwtClaimsDecoder jwtClaimsDecoder, Clock clock) {+ public CognitoAuthValidator(JwtClaimsDecoder jwtClaimsDecoder, CognitoService cognitoService, Clock clock) {this.jwtClaimsDecoder = jwtClaimsDecoder;+ this.cognitoService = cognitoService;this.clock = clock;}public Map<String, Object> validate(String authorization, Map<String, Object> userPoolConfig, List<String> sourceIp) {Map<String, Object> claims = jwtClaimsDecoder.decode(authorization).orElseThrow(AppSyncAuth::unauthorized);+ verifySignature(authorization, userPoolConfig);if (claims.get("sub") == null || String.valueOf(claims.get("sub")).isBlank()) {throw AppSyncAuth.unauthorized();}@@ -39,6 +61,59 @@ public class CognitoAuthValidator {return IdentityBuilder.cognito(claims, sourceIp, defaultAction);}+ /**+ * Fails closed: a missing/blank pool id, a pool this emulator never issued+ * ({@code AwsException} from {@code describeUserPool}), an unsupported {@code alg}, a {@code kid}+ * that does not name the pool's current signing key, or a signature that does not verify are all+ * treated as verification failure, never as "unverifiable, so allow."+ */+ private void verifySignature(String authorization, Map<String, Object> userPoolConfig) {+ String poolId = userPoolConfig == null ? null : coerceString(userPoolConfig.get("userPoolId"), null);+ if (poolId == null) {+ throw AppSyncAuth.unauthorized();+ }+ UserPool pool;+ try {+ pool = cognitoService.describeUserPool(poolId);+ } catch (AwsException e) {+ throw AppSyncAuth.unauthorized();+ }+ Map<String, Object> header = jwtClaimsDecoder.decodeHeader(authorization)+ .orElseThrow(AppSyncAuth::unauthorized);+ if (!"RS256".equals(header.get("alg"))) {+ throw AppSyncAuth.unauthorized();+ }+ String kid = coerceString(header.get("kid"), null);+ if (kid == null || !kid.equals(pool.getSigningKeyId())) {+ throw AppSyncAuth.unauthorized();+ }+ String token = jwtClaimsDecoder.rawToken(authorization).orElseThrow(AppSyncAuth::unauthorized);+ int lastDot = token.lastIndexOf('.');+ String signingInput = token.substring(0, lastDot);+ byte[] signature = Base64.getUrlDecoder().decode(pad(token.substring(lastDot + 1)));+ if (!signatureValid(signingInput, signature, pool)) {+ throw AppSyncAuth.unauthorized();+ }+ }++ private boolean signatureValid(String signingInput, byte[] signature, UserPool pool) {+ try {+ byte[] encodedKey = Base64.getDecoder().decode(pool.getSigningPublicKey());+ PublicKey publicKey = KeyFactory.getInstance("RSA").generatePublic(new X509EncodedKeySpec(encodedKey));+ Signature verifier = Signature.getInstance("SHA256withRSA");+ verifier.initVerify(publicKey);+ verifier.update(signingInput.getBytes(StandardCharsets.UTF_8));+ return verifier.verify(signature);+ } catch (Exception e) {+ return false;+ }+ }++ private static String pad(String value) {+ int rem = value.length() % 4;+ return rem == 0 ? value : value + "=".repeat(4 - rem);+ }+boolean matchesProvider(Map<String, Object> claims, Map<String, Object> userPoolConfig) {return claims.get("sub") != null&& unexpired(claims)@@ -63,7 +138,14 @@ public class CognitoAuthValidator {return expected != null && expected.equals(iss);}- static String expectedIssuer(Map<String, Object> config) {+ /**+ * The real emulator issuer for the configured pool ({@code cognitoService.getIssuer(poolId)}),+ * unless the config carries an explicit override. There is no AWS-style+ * {@code https://cognito-idp.<region>.amazonaws.com/<poolId>} guess here any more: Floci's own+ * Cognito emulator never signs a token with that issuer, so comparing against it could never+ * match a genuine emulator-issued token.+ */+ private String expectedIssuer(Map<String, Object> config) {if (config == null) {return null;}@@ -72,11 +154,7 @@ public class CognitoAuthValidator {return issuer;}String poolId = coerceString(config.get("userPoolId"), null);- String region = coerceString(config.get("awsRegion"), null);- if (poolId == null || region == null) {- return null;- }- return "https://cognito-idp." + region + ".amazonaws.com/" + poolId;+ return poolId == null ? null : cognitoService.getIssuer(poolId);}private boolean audienceMatches(Map<String, Object> claims, Map<String, Object> config) {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 00026a00cf..df9dec33d0 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@@ -2,17 +2,56 @@ package io.github.hectorvent.floci.services.appsync.graphql.auth;import io.github.hectorvent.floci.core.common.AwsRegions;import io.github.hectorvent.floci.core.common.AccountResolver;+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;import io.github.hectorvent.floci.services.iam.model.CallerContext;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;+import org.jboss.logging.Logger;+import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.time.Instant;+import java.time.ZoneOffset;+import java.time.format.DateTimeFormatter;+import java.util.LinkedHashMap;+import java.util.Locale;import java.util.Map;+/**+ * Verifies the SigV4 signature on an AppSync GraphQL data-plane request, so {@code AWS_IAM} auth+ * actually requires a signed caller rather than merely a well-formed {@code Credential=} value.+ *+ * <p>Scoped narrowly to this one endpoint: header-signed only (AppSync's SDKs never presign this+ * call), signing service {@code "appsync"} (not {@code execute-api}), and a fixed canonical path of+ * {@code /v1/apis/{apiId}/graphql} with no query string, since that is the endpoint's entire shape.+ * Modeled on {@code ExecuteApiSigV4Authorizer} and {@code SigV4Validator}, which cannot be reused+ * directly: both hardcode a different signing service name.+ *+ * <p>The well-known local-dev {@code test}/{@code test} credential pair is honoured as a known+ * secret, exactly like every other SigV4 validator in this codebase: it still has to produce a+ * valid signature, it is not a bypass of the signature check itself. No other unregistered access+ * key is ever accepted, and an unresolvable key never falls back to a default secret or an+ * account-root identity.+ */@ApplicationScopedpublic class IamAuthValidator {+ private static final Logger LOG = Logger.getLogger(IamAuthValidator.class);++ private static final String ALGORITHM = "AWS4-HMAC-SHA256";+ private static final String SIGNING_SERVICE = "appsync";+ private static final String TERMINATOR = "aws4_request";+ 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 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;@@ -31,6 +70,7 @@ public class IamAuthValidator {if (accessKeyId == null || accessKeyId.isBlank()) {throw AppSyncAuth.unauthorized();}+ verifySignature(authorization, apiId, info, accessKeyId);if (!isEmulatorAllow(accessKeyId)) {CallerContext caller = iamService.resolveCallerContext(accessKeyId);if (caller != null) {@@ -43,11 +83,241 @@ public class IamAuthValidator {}}String userArn = iamService.resolveCallerArn(accessKeyId).orElseGet(- () -> "arn:aws:iam::" + nullToEmpty(info.accountId()) + ":root");+ () -> isEmulatorAllow(accessKeyId) ? "arn:aws:iam::" + nullToEmpty(info.accountId()) + ":root"+ : null);+ if (userArn == null) {+ // resolveSecretKey already proved the key is registered, so this is unreachable for any+ // real access key - only the legacy test/test pair has no IamService entry to resolve.+ throw AppSyncAuth.unauthorized();+ }String username = usernameFromArn(userArn, accessKeyId);return IdentityBuilder.iam(info.accountId(), accessKeyId, username, userArn, info.sourceIp());}+ /**+ * 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.+ */+ private void verifySignature(String authorization, String apiId, AuthRequestInfo info, String accessKeyId) {+ SignedRequest signed = headerSignedRequest(authorization, info.requestHeaders());+ if (signed == null) {+ throw AppSyncAuth.unauthorized();+ }+ CredentialScope scope = CredentialScope.parse(signed.credential());+ if (scope == null || !SIGNING_SERVICE.equals(scope.service()) || !accessKeyId.equals(scope.accessKeyId())) {+ throw AppSyncAuth.unauthorized();+ }+ Instant signedAt;+ try {+ signedAt = Instant.from(AMZ_DATE.parse(signed.amzDate()));+ } catch (Exception e) {+ throw AppSyncAuth.unauthorized();+ }+ if (Math.abs(Instant.now().getEpochSecond() - signedAt.getEpochSecond()) > MAX_CLOCK_SKEW_SECONDS) {+ throw AppSyncAuth.unauthorized();+ }+ String secretKey = resolveSecretKey(accessKeyId);+ if (secretKey == null) {+ LOG.debugv("AppSync SigV4 request references unregistered access key={0}", sanitizeForLog(accessKeyId));+ throw AppSyncAuth.unauthorized();+ }+ checkSessionToken(accessKeyId, info.requestHeaders());+ try {+ String canonicalUri = "/v1/apis/" + apiId + "/graphql";+ String payloadHash = 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"+ + sha256Hex(canonicalRequest.getBytes(StandardCharsets.UTF_8));+ byte[] signingKey = deriveSigningKey(secretKey, scope.date(), scope.region(), scope.service());+ String expected = hexEncode(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}", sanitizeForLog(accessKeyId));+ throw AppSyncAuth.unauthorized();+ }+ } catch (AppSyncTransportException e) {+ throw e;+ } catch (Exception e) {+ LOG.debugv(e, "AppSync SigV4 verification failed to complete: {0}", e.getMessage());+ throw AppSyncAuth.unauthorized();+ }+ }++ /**+ * Resolves the secret backing an access key, or {@code null} for a credential this emulator+ * will not authenticate. Never falls back to the access key id as its own secret and never+ * mints a secret for a key {@link IamService} does not know: that is exactly what let an+ * unregistered key sign its own requests before this fix.+ */+ private String resolveSecretKey(String accessKeyId) {+ if (LEGACY_ACCESS_KEY_ID.equals(accessKeyId)) {+ return LEGACY_SECRET_KEY;+ }+ 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.+ */+ 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}",+ sanitizeForLog(accessKeyId), SECURITY_TOKEN);+ throw AppSyncAuth.unauthorized();+ }+ String issued = iamService.findSessionToken(accessKeyId).orElse(null);+ if (issued == null) {+ 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}", sanitizeForLog(accessKeyId));+ throw AppSyncAuth.unauthorized();+ }+ }++ 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) {+ if (authorization == null) {+ return null;+ }+ String trimmed = authorization.trim();+ if (!trimmed.regionMatches(true, 0, ALGORITHM, 0, ALGORITHM.length())) {+ return null;+ }+ Map<String, String> parameters = new LinkedHashMap<>();+ 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());+ }+ }+ String credential = parameters.get("Credential");+ String signedHeaders = parameters.get("SignedHeaders");+ String signature = parameters.get("Signature");+ String amzDate = header(requestHeaders, "X-Amz-Date");+ if (isBlank(credential) || isBlank(signedHeaders) || isBlank(signature) || isBlank(amzDate)) {+ return null;+ }+ return new SignedRequest(credential, signedHeaders.toLowerCase(Locale.ROOT), signature, amzDate);+ }++ private record CredentialScope(String accessKeyId, String date, String region, String service) {++ String credentialScope() {+ return date + "/" + region + "/" + service + "/" + TERMINATOR;+ }++ static CredentialScope parse(String credential) {+ if (credential == null) {+ return null;+ }+ String[] parts = credential.split("/");+ if (parts.length != 5 || !TERMINATOR.equals(parts[4])) {+ return null;+ }+ if (parts[0].isBlank() || parts[1].length() != 8 || parts[2].isBlank() || parts[3].isBlank()) {+ return null;+ }+ return new CredentialScope(parts[0], parts[1], parts[2], parts[3].toLowerCase(Locale.ROOT));+ }+ }++ private static String canonicalHeaders(String signedHeaders, Map<String, String> requestHeaders) {+ StringBuilder canonical = new StringBuilder();+ for (String name : signedHeaders.split(";")) {+ canonical.append(name).append(':').append(normalizeHeaderValue(header(requestHeaders, name))).append('\n');+ }+ return canonical.toString();+ }++ private static String header(Map<String, String> headers, String name) {+ if (headers == null) {+ return "";+ }+ String direct = headers.get(name);+ if (direct != null) {+ return direct;+ }+ for (Map.Entry<String, String> entry : headers.entrySet()) {+ if (entry.getKey() != null && entry.getKey().equalsIgnoreCase(name)) {+ return entry.getValue() == null ? "" : entry.getValue();+ }+ }+ return "";+ }++ private static String normalizeHeaderValue(String value) {+ return value == null ? "" : value.trim().replaceAll("\\s+", " ");+ }++ private static byte[] deriveSigningKey(String secretKey, String date, String region, String service)+ throws Exception {+ byte[] kSecret = ("AWS4" + secretKey).getBytes(StandardCharsets.UTF_8);+ byte[] kDate = hmacSha256(kSecret, date);+ byte[] kRegion = hmacSha256(kDate, region);+ byte[] kService = hmacSha256(kRegion, service);+ return hmacSha256(kService, TERMINATOR);+ }++ private static byte[] hmacSha256(byte[] key, String data) throws Exception {+ Mac mac = Mac.getInstance("HmacSHA256");+ mac.init(new SecretKeySpec(key, "HmacSHA256"));+ return mac.doFinal(data.getBytes(StandardCharsets.UTF_8));+ }++ private static String sha256Hex(byte[] input) throws Exception {+ return hexEncode(MessageDigest.getInstance("SHA-256").digest(input));+ }++ private static String hexEncode(byte[] bytes) {+ StringBuilder hex = new StringBuilder(bytes.length * 2);+ for (byte b : bytes) {+ hex.append(Character.forDigit((b >> 4) & 0xF, 16)).append(Character.forDigit(b & 0xF, 16));+ }+ return hex.toString();+ }++ private static boolean isBlank(String value) {+ return value == null || value.isBlank();+ }++ /** Strips control characters from attacker-controlled values before they reach a log line. */+ private static String sanitizeForLog(String value) {+ return value == null ? null : value.replaceAll("\\p{Cntrl}", "");+ }+public boolean isFieldDenied(String accessKeyId, String fieldArn) {if (accessKeyId == null || isEmulatorAllow(accessKeyId)) {return false;diff --git a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/JwtClaimsDecoder.java b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/JwtClaimsDecoder.javaindex f96dbe7381..832e8a0ecb 100644--- a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/JwtClaimsDecoder.java+++ b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/JwtClaimsDecoder.java@@ -21,6 +21,35 @@ public class JwtClaimsDecoder {}public Optional<Map<String, Object>> decode(String authorization) {+ return part(authorization, 1).flatMap(this::readMap);+ }++ /** The JWT header segment ({@code alg}, {@code kid}, ...), decoded the same way as the claims. */+ public Optional<Map<String, Object>> decodeHeader(String authorization) {+ return part(authorization, 0).flatMap(this::readMap);+ }++ /** The bare JWT (no {@code Bearer } prefix), only when it has the three dot-separated segments. */+ public Optional<String> rawToken(String authorization) {+ return bearerToken(authorization).filter(token -> token.split("\\.", -1).length == 3);+ }++ private Optional<Map<String, Object>> readMap(String base64UrlSegment) {+ try {+ byte[] json = Base64.getUrlDecoder().decode(pad(base64UrlSegment));+ return Optional.of(objectMapper.readValue(json, new TypeReference<>() {}));+ } catch (Exception e) {+ return Optional.empty();+ }+ }++ private static Optional<String> part(String authorization, int index) {+ return bearerToken(authorization).map(token -> token.split("\\.", -1))+ .filter(parts -> parts.length == 3)+ .map(parts -> parts[index]);+ }++ private static Optional<String> bearerToken(String authorization) {if (authorization == null || authorization.isBlank()) {return Optional.empty();}@@ -28,17 +57,7 @@ public class JwtClaimsDecoder {if (authorization.regionMatches(true, 0, "Bearer ", 0, 7)) {token = authorization.substring(7).trim();}- String[] parts = token.split("\\.", -1);- if (parts.length != 3) {- return Optional.empty();- }- try {- byte[] json = Base64.getUrlDecoder().decode(pad(parts[1]));- Map<String, Object> claims = objectMapper.readValue(json, new TypeReference<>() {});- return Optional.of(claims);- } catch (Exception e) {- return Optional.empty();- }+ return Optional.of(token);}private static String pad(String value) {diff --git a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/OidcAuthValidator.java b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/OidcAuthValidator.javaindex 1b45196cfc..1ff3655b75 100644--- a/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/OidcAuthValidator.java+++ b/src/main/java/io/github/hectorvent/floci/services/appsync/graphql/auth/OidcAuthValidator.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.appsync.graphql.auth;+import io.github.hectorvent.floci.services.apigatewayv2.JwtSignatureVerifier;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -7,15 +8,24 @@ import java.time.Clock;import java.util.Map;import java.util.regex.Pattern;+/**+ * Verifies an OIDC bearer token's RS256 signature against the configured provider's own JWKS,+ * reusing {@link JwtSignatureVerifier} (already used by the HTTP API JWT authorizer): it fetches+ * {@code {issuer}/.well-known/openid-configuration}, resolves the token's {@code kid} against the+ * JWKS it points to, and fails closed on any network error, unreachable issuer, unsupported+ * algorithm, or unmatched key.+ */@ApplicationScopedpublic class OidcAuthValidator {private final JwtClaimsDecoder jwtClaimsDecoder;+ private final JwtSignatureVerifier jwtSignatureVerifier;private final Clock clock;@Inject- public OidcAuthValidator(JwtClaimsDecoder jwtClaimsDecoder, Clock clock) {+ public OidcAuthValidator(JwtClaimsDecoder jwtClaimsDecoder, JwtSignatureVerifier jwtSignatureVerifier, Clock clock) {this.jwtClaimsDecoder = jwtClaimsDecoder;+ this.jwtSignatureVerifier = jwtSignatureVerifier;this.clock = clock;}@@ -26,6 +36,7 @@ public class OidcAuthValidator {) {Map<String, Object> claims = jwtClaimsDecoder.decode(authorization).orElseThrow(AppSyncAuth::unauthorized);+ verifySignature(authorization, oidcConfig);if (claims.get("sub") == null || String.valueOf(claims.get("sub")).isBlank()) {throw AppSyncAuth.unauthorized();}@@ -41,6 +52,25 @@ public class OidcAuthValidator {return IdentityBuilder.oidc(claims);}+ /**+ * Verifies against the <em>configured</em> issuer's JWKS regardless of {@code skipIssuer}:+ * that configured URL is the only OIDC provider this API trusts, so it is what signs the keys+ * to check against even when the token's own {@code iss} claim is not separately asserted to+ * equal it.+ */+ private void verifySignature(String authorization, Map<String, Object> oidcConfig) {+ String issuer = oidcConfig == null ? null : CognitoAuthValidator.coerceString(oidcConfig.get("issuer"), null);+ if (issuer == null) {+ throw AppSyncAuth.unauthorized();+ }+ String token = jwtClaimsDecoder.rawToken(authorization).orElseThrow(AppSyncAuth::unauthorized);+ try {+ jwtSignatureVerifier.verify(token, issuer);+ } catch (JwtSignatureVerifier.JwtVerificationException e) {+ throw AppSyncAuth.unauthorized();+ }+ }+boolean matchesProvider(Map<String, Object> claims, Map<String, Object> oidcConfig, boolean skipIssuer) {return claims.get("sub") != null&& timestampsValid(claims, oidcConfig)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 0b8244ddef..c2ef2c2b3b 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@@ -3,12 +3,16 @@ 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.RestAssuredJsonUtils;+import io.github.hectorvent.floci.testutil.AppSyncRequestSigner;+import io.restassured.RestAssured;import io.quarkus.test.junit.QuarkusTest;import jakarta.inject.Inject;import org.junit.jupiter.api.BeforeAll;import org.junit.jupiter.api.Test;import java.time.Duration;+import java.time.Instant;+import java.util.Map;import java.util.UUID;import static io.restassured.RestAssured.given;@@ -163,7 +167,7 @@ class AppSyncAuthIntegrationTest {}@Test- void iamCallerOnApiKeyFieldReturns200WithUnauthorizedError() {+ void iamCallerOnApiKeyFieldReturns200WithUnauthorizedError() throws Exception {String apiId = given().header("Authorization", MGMT_AUTH).contentType("application/json")@@ -185,10 +189,11 @@ class AppSyncAuthIntegrationTest {startSchema(apiId, "type Query { hello: String @aws_api_key }");awaitSchemaSuccess(apiId);+ String body = "{\"query\":\"{ hello }\"}";given().contentType("application/json")- .header("Authorization", MGMT_AUTH)- .body("{\"query\":\"{ hello }\"}")+ .headers(iamSignedHeaders(apiId, body))+ .body(body).when().post("/v1/apis/" + apiId + "/graphql").then()@@ -201,7 +206,7 @@ class AppSyncAuthIntegrationTest {}@Test- void additionalModeIamCanIntrospect() {+ void additionalModeIamCanIntrospect() throws Exception {String apiId = given().header("Authorization", MGMT_AUTH).contentType("application/json")@@ -223,10 +228,11 @@ class AppSyncAuthIntegrationTest {startSchema(apiId, "type Query { hello: String }");awaitSchemaSuccess(apiId);+ String body = "{\"query\":\"{ __schema { types { name } } }\"}";given().contentType("application/json")- .header("Authorization", MGMT_AUTH)- .body("{\"query\":\"{ __schema { types { name } } }\"}")+ .headers(iamSignedHeaders(apiId, body))+ .body(body).when().post("/v1/apis/" + apiId + "/graphql").then()@@ -242,6 +248,15 @@ class AppSyncAuthIntegrationTest {awaitSchemaSuccess(apiId);}+ /**+ * Data-plane requests in {@code AWS_IAM} mode must carry a real SigV4 signature; the bare+ * {@code Credential=} header that is enough for the management plane is rejected there.+ */+ private static Map<String, String> iamSignedHeaders(String apiId, String body) throws Exception {+ return AppSyncRequestSigner.signedHeaders(apiId, "localhost:" + RestAssured.port, body,+ "test", "test", "us-east-1", Instant.now());+ }+private static String createApi(String name) {return given().header("Authorization", MGMT_AUTH)diff --git a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AuthMiddlewareTest.java b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AuthMiddlewareTest.javaindex 1d2803e5c7..f781602477 100644--- a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AuthMiddlewareTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/AuthMiddlewareTest.java@@ -42,7 +42,7 @@ class AuthMiddlewareTest {apiKeyAuthValidator, iamAuthValidator, cognitoAuthValidator, oidcAuthValidator,lambdaAuthorizerValidator, new JwtClaimsDecoder(new ObjectMapper()));info = new AuthRequestInfo("{ hello }", null, Map.of(), List.of("127.0.0.1"),- "req", "000000000000", "us-east-1", Map.of());+ "req", "000000000000", "us-east-1", Map.of(), "{ hello }");}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/CognitoAuthValidatorTest.java b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/CognitoAuthValidatorTest.javaindex 4c46d90ecc..961558fa57 100644--- a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/CognitoAuthValidatorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/CognitoAuthValidatorTest.java@@ -1,13 +1,28 @@package io.github.hectorvent.floci.services.appsync.graphql.auth;import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.appsync.graphql.AppSyncTransportException;+import io.github.hectorvent.floci.services.cognito.CognitoService;+import io.github.hectorvent.floci.services.cognito.model.UserPool;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.ExtendWith;+import org.mockito.Mock;+import org.mockito.junit.jupiter.MockitoExtension;+import java.security.GeneralSecurityException;+import java.security.KeyPair;+import java.security.KeyPairGenerator;+import java.security.Signature;+import java.security.interfaces.RSAPrivateKey;+import java.security.interfaces.RSAPublicKey;+import java.nio.charset.StandardCharsets;import java.time.Clock;import java.time.Instant;import java.time.ZoneOffset;+import java.util.Base64;import java.util.HashMap;import java.util.List;import java.util.Map;@@ -15,40 +30,106 @@ import java.util.Map;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNull;import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.mockito.Mockito.lenient;+import static org.mockito.Mockito.when;+@ExtendWith(MockitoExtension.class)class CognitoAuthValidatorTest {private static final Instant NOW = Instant.parse("2026-01-01T00:00:00Z");+ private static final String POOL_ID = "us-east-1_abc";+ private static final String KEY_ID = "signing-key-1";+ private static final String ISSUER = "http://127.0.0.1:12345/us-east-1_abc";+private final ObjectMapper mapper = new ObjectMapper();++ @Mock+ CognitoService cognitoService;+private CognitoAuthValidator validator;private Map<String, Object> config;+ private RSAPrivateKey privateKey;+ private UserPool pool;@BeforeEach- void setUp() {- validator = new CognitoAuthValidator(new JwtClaimsDecoder(mapper), Clock.fixed(NOW, ZoneOffset.UTC));+ void setUp() throws Exception {+ KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");+ gen.initialize(2048);+ KeyPair pair = gen.generateKeyPair();+ privateKey = (RSAPrivateKey) pair.getPrivate();+ RSAPublicKey publicKey = (RSAPublicKey) pair.getPublic();++ pool = new UserPool();+ pool.setSigningKeyId(KEY_ID);+ pool.setSigningPublicKey(Base64.getEncoder().encodeToString(publicKey.getEncoded()));++ lenient().when(cognitoService.describeUserPool(POOL_ID)).thenReturn(pool);+ lenient().when(cognitoService.getIssuer(POOL_ID)).thenReturn(ISSUER);++ validator = new CognitoAuthValidator(new JwtClaimsDecoder(mapper), cognitoService,+ Clock.fixed(NOW, ZoneOffset.UTC));config = new HashMap<>();- config.put("userPoolId", "us-east-1_abc");+ config.put("userPoolId", POOL_ID);config.put("awsRegion", "us-east-1");config.put("defaultAction", "ALLOW");config.put("appIdClientRegex", "client-1");}@Test- void validJwtBuildsUsernameAndAuthTypeIdentity() {+ void validSignedJwtBuildsUsernameAndAuthTypeIdentity() throws Exception {Map<String, Object> claims = baseClaims();claims.put("cognito:username", "alice");- Map<String, Object> identity = validator.validate("Bearer " + jwt(claims), config, List.of("127.0.0.1"));+ Map<String, Object> identity = validator.validate(+ "Bearer " + signedJwt(claims, KEY_ID, privateKey), config, List.of("127.0.0.1"));assertEquals("alice", identity.get("username"));assertEquals("abc", identity.get("sub"));assertNull(identity.get("cognitoUserPoolId"));}@Test- void expiredJwtIs401() {+ void unsignedAlgNoneTokenIs401() {+ Map<String, Object> claims = baseClaims();+ assertThrows(AppSyncTransportException.class,+ () -> validator.validate("Bearer " + JwtClaimsDecoder.encode(claims, mapper), config, List.of()));+ }++ @Test+ void tokenSignedByAForeignKeyIs401() throws Exception {+ KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");+ gen.initialize(2048);+ RSAPrivateKey forgedKey = (RSAPrivateKey) gen.generateKeyPair().getPrivate();+ Map<String, Object> claims = baseClaims();++ assertThrows(AppSyncTransportException.class,+ () -> validator.validate(+ "Bearer " + signedJwt(claims, KEY_ID, forgedKey), config, List.of()));+ }++ @Test+ void tokenWithUnknownKidIs401() throws Exception {+ Map<String, Object> claims = baseClaims();+ assertThrows(AppSyncTransportException.class,+ () -> validator.validate(+ "Bearer " + signedJwt(claims, "some-other-key", privateKey), config, List.of()));+ }++ @Test+ void tokenForAnUnregisteredPoolIs401() throws Exception {+ when(cognitoService.describeUserPool(POOL_ID))+ .thenThrow(new AwsException("ResourceNotFoundException", "User pool not found", 400));+ Map<String, Object> claims = baseClaims();++ assertThrows(AppSyncTransportException.class,+ () -> validator.validate(+ "Bearer " + signedJwt(claims, KEY_ID, privateKey), config, List.of()));+ }++ @Test+ void expiredJwtIs401() throws Exception {Map<String, Object> claims = baseClaims();claims.put("exp", NOW.getEpochSecond() - 10);assertThrows(AppSyncTransportException.class,- () -> validator.validate("Bearer " + jwt(claims), config, List.of()));+ () -> validator.validate("Bearer " + signedJwt(claims, KEY_ID, privateKey), config, List.of()));}@Test@@ -58,34 +139,62 @@ class CognitoAuthValidatorTest {}@Test- void missingSubIs401() {+ void missingSubIs401() throws Exception {Map<String, Object> claims = baseClaims();claims.remove("sub");assertThrows(AppSyncTransportException.class,- () -> validator.validate("Bearer " + jwt(claims), config, List.of()));+ () -> validator.validate("Bearer " + signedJwt(claims, KEY_ID, privateKey), config, List.of()));}@Test- void groupsNullVsEmpty() {- Map<String, Object> missing = validator.validate("Bearer " + jwt(baseClaims()), config, List.of());+ void wrongIssuerIs401() throws Exception {+ Map<String, Object> claims = baseClaims();+ claims.put("iss", "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_abc");+ assertThrows(AppSyncTransportException.class,+ () -> validator.validate("Bearer " + signedJwt(claims, KEY_ID, privateKey), config, List.of()));+ }++ @Test+ void groupsNullVsEmpty() throws Exception {+ Map<String, Object> missing = validator.validate(+ "Bearer " + signedJwt(baseClaims(), KEY_ID, privateKey), config, List.of());assertNull(missing.get("groups"));Map<String, Object> emptyClaims = baseClaims();emptyClaims.put("cognito:groups", List.of());- Map<String, Object> empty = validator.validate("Bearer " + jwt(emptyClaims), config, List.of());+ Map<String, Object> empty = validator.validate(+ "Bearer " + signedJwt(emptyClaims, KEY_ID, privateKey), config, List.of());assertEquals(List.of(), empty.get("groups"));}private Map<String, Object> baseClaims() {Map<String, Object> claims = new HashMap<>();claims.put("sub", "abc");- claims.put("iss", "https://cognito-idp.us-east-1.amazonaws.com/us-east-1_abc");+ claims.put("iss", ISSUER);claims.put("aud", "client-1");claims.put("exp", NOW.getEpochSecond() + 3600);return claims;}- private String jwt(Map<String, Object> claims) {- return JwtClaimsDecoder.encode(claims, mapper);+ private String signedJwt(Map<String, Object> claims, String kid, RSAPrivateKey signingKey)+ throws GeneralSecurityException {+ ObjectNode header = mapper.createObjectNode();+ header.put("alg", "RS256");+ header.put("typ", "JWT");+ header.put("kid", kid);++ ObjectNode payload = mapper.createObjectNode();+ claims.forEach((key, value) -> payload.putPOJO(key, value));++ String signingInput = base64Url(header.toString()) + "." + base64Url(payload.toString());+ Signature signature = Signature.getInstance("SHA256withRSA");+ signature.initSign(signingKey);+ signature.update(signingInput.getBytes(StandardCharsets.UTF_8));+ String encodedSignature = Base64.getUrlEncoder().withoutPadding().encodeToString(signature.sign());+ return signingInput + "." + encodedSignature;+ }++ private static String base64Url(String value) {+ return Base64.getUrlEncoder().withoutPadding().encodeToString(value.getBytes(StandardCharsets.UTF_8));}}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 7221d32906..867bbc2dcf 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@@ -6,12 +6,14 @@ import io.github.hectorvent.floci.services.appsync.graphql.AppSyncTransportExcepimport io.github.hectorvent.floci.services.iam.IamPolicyEvaluator;import io.github.hectorvent.floci.services.iam.IamService;import io.github.hectorvent.floci.services.iam.model.CallerContext;+import io.github.hectorvent.floci.testutil.AppSyncRequestSigner;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.extension.ExtendWith;import org.mockito.Mock;import org.mockito.junit.jupiter.MockitoExtension;+import java.time.Instant;import java.util.List;import java.util.Map;import java.util.Optional;@@ -21,6 +23,7 @@ import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertInstanceOf;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.lenient;import static org.mockito.Mockito.when;@ExtendWith(MockitoExtension.class)@@ -39,11 +42,14 @@ 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 }";+@MockIamService iamService;private IamAuthValidator validator;- private AuthRequestInfo info;@BeforeEachvoid setUp() {@@ -51,19 +57,29 @@ class IamAuthValidatorTest {new AccountResolver("000000000000"),iamService,new IamPolicyEvaluator(new ObjectMapper()));- info = new AuthRequestInfo("{ hello }", null, Map.of(), List.of("10.0.0.1"),- "req-1", "000000000000", "us-east-1", Map.of());+ lenient().when(iamService.findSecretKey("AKIAGOOD")).thenReturn(Optional.of("good-secret"));+ lenient().when(iamService.findSecretKey("AKIDDENY")).thenReturn(Optional.of("deny-secret"));+ }++ private AuthRequestInfo infoWith(Map<String, String> signedHeaders) {+ return new AuthRequestInfo("{ hello }", null, Map.of(), List.of("10.0.0.1"),+ "req-1", "000000000000", "us-east-1", signedHeaders, BODY);+ }++ private static String authorization(Map<String, String> signedHeaders) {+ return signedHeaders.get("Authorization");}@Test- void knownAllowBuildsIdentity() {+ void knownAllowBuildsIdentity() throws Exception {when(iamService.resolveCallerContext("AKIAGOOD")).thenReturn(CallerContext.of(List.of(ALLOW)));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());Map<String, Object> identity = validator.validateRequest(- "AWS4-HMAC-SHA256 Credential=AKIAGOOD/20260205/us-east-1/appsync/aws4_request",- "api-1", info);+ authorization(signed), "api-1", infoWith(signed));assertEquals("AKIAGOOD", identity.get("user"));assertEquals("alice", identity.get("username"));@@ -72,24 +88,81 @@ class IamAuthValidatorTest {}@Test- void knownRequestDenyThrows401() {+ 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());++ AppSyncTransportException ex = assertThrows(AppSyncTransportException.class,+ () -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));+ assertEquals(401, ex.getHttpStatus());+ }++ @Test+ void knownKeyWithBadSignatureIs401() 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)));+ }++ @Test+ void tamperedBodyAfterSigningIs401() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION, Instant.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,+ () -> validator.validateRequest(authorization(signed), "api-1", tampered));+ }++ @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())));+ }++ @Test+ void unknownAccessKeyNeverResolvesToRoot() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "AKIAUNKNOWN", "whatever-secret", REGION, Instant.now());AppSyncTransportException ex = assertThrows(AppSyncTransportException.class,- () -> validator.validateRequest(- "AWS4-HMAC-SHA256 Credential=AKIDDENY/20260205/us-east-1/appsync/aws4_request",- "api-1", info));+ () -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));assertEquals(401, ex.getHttpStatus());}@Test- void unknownTestKeyIsAllowed() {+ void expiredSignatureIsRejected() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "AKIAGOOD", "good-secret", REGION,+ Instant.now().minusSeconds(3600));++ assertThrows(AppSyncTransportException.class,+ () -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));+ }++ @Test+ void legacyTestKeyMustStillBeSigned() throws Exception {+ Map<String, String> signed = AppSyncRequestSigner.signedHeaders(+ "api-1", HOST, BODY, "test", "test", REGION, Instant.now());+Map<String, Object> identity = validator.validateRequest(- "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/appsync/aws4_request",- "api-1", info);+ authorization(signed), "api-1", infoWith(signed));+assertEquals("test", identity.get("user"));}+ @Test+ void unsignedLegacyTestKeyIsRejected() {+ assertThrows(AppSyncTransportException.class, () -> validator.validateRequest(+ "AWS4-HMAC-SHA256 Credential=test/20260205/us-east-1/appsync/aws4_request",+ "api-1", infoWith(Map.of())));+ }+/*** These two build the resource the policy evaluator matches against, and the ARN a customer* writes their policy from is the one AppSync minted, which carries the region's partition.@@ -117,6 +190,56 @@ class IamAuthValidatorTest {IamAuthValidator.requestArn(null, "000000000000", "api-1"));}+ @Test+ void temporaryCredentialSignedButNoSessionTokenIs401() 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());+ }++ @Test+ void temporaryCredentialWithMismatchedSessionTokenIs401() 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");++ AppSyncTransportException ex = assertThrows(AppSyncTransportException.class,+ () -> validator.validateRequest(authorization(signed), "api-1", infoWith(signed)));+ assertEquals(401, ex.getHttpStatus());+ }++ @Test+ void temporaryCredentialWithIssuedSessionTokenIsAllowed() throws Exception {+ when(iamService.findSecretKey("ASIALIVE")).thenReturn(Optional.of("session-secret"));+ when(iamService.findSessionToken("ASIALIVE")).thenReturn(Optional.of("issued-token"));+ when(iamService.resolveCallerArn("ASIALIVE")).thenReturn(+ Optional.of("arn:aws:sts::000000000000:assumed-role/app/floci-session"));+ Map<String, String> signed = signedWithSessionToken("ASIALIVE", "session-secret", "issued-token");++ Map<String, Object> identity = validator.validateRequest(+ authorization(signed), "api-1", infoWith(signed));++ assertEquals("ASIALIVE", identity.get("user"));+ assertEquals("floci-session", identity.get("username"));+ }++ /**+ * Presents the session token the way an SDK does: as a header outside {@code SignedHeaders}.+ * Nothing binds it to the signature, which is the point of comparing it against the issued+ * value instead.+ */+ 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()));+ signed.put("X-Amz-Security-Token", token);+ return signed;+ }+@Testvoid fieldArnDenyDetected() {when(iamService.resolveCallerContext("AKIAGOOD")).thenReturn(CallerContext.of(List.of(FIELD_DENY)));diff --git a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/LambdaAuthorizerValidatorTest.java b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/LambdaAuthorizerValidatorTest.javaindex 1269426e7d..44ad76711a 100644--- a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/LambdaAuthorizerValidatorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/LambdaAuthorizerValidatorTest.java@@ -41,7 +41,7 @@ class LambdaAuthorizerValidatorTest {void setUp() {validator = new LambdaAuthorizerValidator(lambdaService, new LambdaAuthorizerCache(), mapper);info = new AuthRequestInfo("{ hello }", "GetHello", Map.of("id", "1"),- List.of(), "req-1", "000000000000", "us-east-1", Map.of("authorization", "tok"));+ List.of(), "req-1", "000000000000", "us-east-1", Map.of("authorization", "tok"), "{ hello }");config = Map.of("authorizerUri", "arn:aws:lambda:us-east-1:000000000000:function:authz","authorizerResultTtlInSeconds", 30);diff --git a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/OidcAuthValidatorTest.java b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/OidcAuthValidatorTest.javaindex 90467ff47d..44b7b86910 100644--- a/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/OidcAuthValidatorTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/appsync/graphql/auth/OidcAuthValidatorTest.java@@ -1,13 +1,31 @@package io.github.hectorvent.floci.services.appsync.graphql.auth;import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import com.sun.net.httpserver.HttpServer;+import io.github.hectorvent.floci.services.apigatewayv2.JwtSignatureVerifier;import io.github.hectorvent.floci.services.appsync.graphql.AppSyncTransportException;+import org.junit.jupiter.api.AfterEach;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;+import java.io.IOException;+import java.math.BigInteger;+import java.net.InetSocketAddress;+import java.net.http.HttpClient;+import java.nio.charset.StandardCharsets;+import java.security.GeneralSecurityException;+import java.security.KeyPair;+import java.security.KeyPairGenerator;+import java.security.Signature;+import java.security.interfaces.RSAPrivateKey;+import java.security.interfaces.RSAPublicKey;import java.time.Clock;+import java.time.Duration;import java.time.Instant;import java.time.ZoneOffset;+import java.util.Arrays;+import java.util.Base64;import java.util.HashMap;import java.util.Map;@@ -15,61 +33,143 @@ import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertThrows;import static org.junit.jupiter.api.Assertions.assertTrue;+/**+ * Follows {@code JwtSignatureVerifierTest}'s pattern: a real local {@code com.sun.net.httpserver}+ * discovery/JWKS fixture and genuinely RS256-signed tokens, since {@link OidcAuthValidator} now+ * delegates its signature check to the real {@link JwtSignatureVerifier} rather than a fake.+ */class OidcAuthValidatorTest {private static final Instant NOW = Instant.parse("2026-01-01T00:00:00Z");+ private static final String KEY_ID = "test-key-1";+private final ObjectMapper mapper = new ObjectMapper();+ private HttpServer server;+ private String issuer;+ private RSAPrivateKey privateKey;+ private RSAPublicKey publicKey;private OidcAuthValidator validator;@BeforeEach- void setUp() {- validator = new OidcAuthValidator(new JwtClaimsDecoder(mapper), Clock.fixed(NOW, ZoneOffset.UTC));+ void setUp() throws Exception {+ KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");+ gen.initialize(2048);+ KeyPair pair = gen.generateKeyPair();+ privateKey = (RSAPrivateKey) pair.getPrivate();+ publicKey = (RSAPublicKey) pair.getPublic();++ server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ server.createContext("/.well-known/openid-configuration", this::discovery);+ server.createContext("/jwks", this::jwks);+ server.start();+ issuer = "http://127.0.0.1:" + server.getAddress().getPort();++ HttpClient httpClient = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build();+ validator = new OidcAuthValidator(new JwtClaimsDecoder(mapper),+ new JwtSignatureVerifier(mapper, httpClient), Clock.fixed(NOW, ZoneOffset.UTC));+ }++ @AfterEach+ void tearDown() {+ server.stop(0);+ }++ private void discovery(com.sun.net.httpserver.HttpExchange exchange) throws IOException {+ String body = "{\"issuer\":\"" + issuer + "\",\"jwks_uri\":\"" + issuer + "/jwks\"}";+ respond(exchange, body);+ }++ private void jwks(com.sun.net.httpserver.HttpExchange exchange) throws IOException {+ String n = base64UrlUnsigned(publicKey.getModulus());+ String e = base64UrlUnsigned(publicKey.getPublicExponent());+ String body = "{\"keys\":[{\"kty\":\"RSA\",\"kid\":\"" + KEY_ID + "\",\"alg\":\"RS256\",\"use\":\"sig\","+ + "\"n\":\"" + n + "\",\"e\":\"" + e + "\"}]}";+ respond(exchange, body);+ }++ private static void respond(com.sun.net.httpserver.HttpExchange exchange, String body) throws IOException {+ byte[] bytes = body.getBytes(StandardCharsets.UTF_8);+ exchange.getResponseHeaders().add("Content-Type", "application/json");+ exchange.sendResponseHeaders(200, bytes.length);+ exchange.getResponseBody().write(bytes);+ exchange.close();}@Test- void soleModeSkipsIssuer() {- Map<String, Object> config = config("https://configured-issuer", "my-client");+ void soleModeSkipsIssuerClaimButStillVerifiesSignatureAgainstConfiguredIssuer() throws Exception {+ Map<String, Object> config = config(issuer, "my-client");Map<String, Object> claims = baseClaims("https://other-issuer", "my-client");- Map<String, Object> identity = validator.validate("Bearer " + jwt(claims), config, true);+ Map<String, Object> identity = validator.validate(+ "Bearer " + signedJwt(claims, KEY_ID, privateKey), config, true);assertEquals("sub-1", identity.get("sub"));assertEquals("https://other-issuer", identity.get("issuer"));assertTrue(!identity.containsKey("sourceIp"));}@Test- void multiModeEnforcesIssuer() {- Map<String, Object> config = config("https://configured-issuer", "my-client");+ void multiModeEnforcesIssuerClaim() throws Exception {+ Map<String, Object> config = config(issuer, "my-client");Map<String, Object> claims = baseClaims("https://other-issuer", "my-client");assertThrows(AppSyncTransportException.class,- () -> validator.validate("Bearer " + jwt(claims), config, false));+ () -> validator.validate("Bearer " + signedJwt(claims, KEY_ID, privateKey), config, false));}@Test- void iatTtlExceededIs401() {- Map<String, Object> config = config("https://issuer", "my-client");+ void iatTtlExceededIs401() throws Exception {+ Map<String, Object> config = config(issuer, "my-client");config.put("iatTTL", 60);- Map<String, Object> claims = baseClaims("https://issuer", "my-client");+ Map<String, Object> claims = baseClaims(issuer, "my-client");claims.put("iat", NOW.getEpochSecond() - 120);assertThrows(AppSyncTransportException.class,- () -> validator.validate("Bearer " + jwt(claims), config, true));+ () -> validator.validate("Bearer " + signedJwt(claims, KEY_ID, privateKey), config, true));}@Test- void clientIdRegexMatchesAzp() {- Map<String, Object> config = config("https://issuer", "client-.*");- Map<String, Object> claims = baseClaims("https://issuer", "other");+ void clientIdRegexMatchesAzp() throws Exception {+ Map<String, Object> config = config(issuer, "client-.*");+ Map<String, Object> claims = baseClaims(issuer, "other");claims.remove("aud");claims.put("azp", "client-99");- Map<String, Object> identity = validator.validate("Bearer " + jwt(claims), config, true);+ Map<String, Object> identity = validator.validate(+ "Bearer " + signedJwt(claims, KEY_ID, privateKey), config, true);assertEquals("sub-1", identity.get("sub"));}@Test- void clientIdMismatchIs401() {- Map<String, Object> config = config("https://issuer", "client-1");- Map<String, Object> claims = baseClaims("https://issuer", "nope");+ void clientIdMismatchIs401() throws Exception {+ Map<String, Object> config = config(issuer, "client-1");+ Map<String, Object> claims = baseClaims(issuer, "nope");+ assertThrows(AppSyncTransportException.class,+ () -> validator.validate("Bearer " + signedJwt(claims, KEY_ID, privateKey), config, true));+ }++ @Test+ void unsignedAlgNoneTokenIs401() {+ Map<String, Object> config = config(issuer, "my-client");+ Map<String, Object> claims = baseClaims(issuer, "my-client");assertThrows(AppSyncTransportException.class,- () -> validator.validate("Bearer " + jwt(claims), config, true));+ () -> validator.validate("Bearer " + JwtClaimsDecoder.encode(claims, mapper), config, true));+ }++ @Test+ void tokenSignedByAForeignKeyIs401() throws Exception {+ KeyPairGenerator gen = KeyPairGenerator.getInstance("RSA");+ gen.initialize(2048);+ RSAPrivateKey forgedKey = (RSAPrivateKey) gen.generateKeyPair().getPrivate();+ Map<String, Object> config = config(issuer, "my-client");+ Map<String, Object> claims = baseClaims(issuer, "my-client");++ assertThrows(AppSyncTransportException.class,+ () -> validator.validate("Bearer " + signedJwt(claims, KEY_ID, forgedKey), config, true));+ }++ @Test+ void unreachableIssuerFailsClosed() throws Exception {+ Map<String, Object> config = config("http://127.0.0.1:1", "my-client"); // nothing listening+ Map<String, Object> claims = baseClaims("http://127.0.0.1:1", "my-client");++ assertThrows(AppSyncTransportException.class,+ () -> validator.validate("Bearer " + signedJwt(claims, KEY_ID, privateKey), config, true));}private Map<String, Object> config(String issuer, String clientId) {@@ -89,7 +189,33 @@ class OidcAuthValidatorTest {return claims;}- private String jwt(Map<String, Object> claims) {- return JwtClaimsDecoder.encode(claims, mapper);+ private String signedJwt(Map<String, Object> claims, String kid, RSAPrivateKey signingKey)+ throws GeneralSecurityException {+ ObjectNode header = mapper.createObjectNode();+ header.put("alg", "RS256");+ header.put("typ", "JWT");+ header.put("kid", kid);++ ObjectNode payload = mapper.createObjectNode();+ claims.forEach((key, value) -> payload.putPOJO(key, value));++ String signingInput = base64Url(header.toString()) + "." + base64Url(payload.toString());+ Signature signature = Signature.getInstance("SHA256withRSA");+ signature.initSign(signingKey);+ signature.update(signingInput.getBytes(StandardCharsets.UTF_8));+ String encodedSignature = Base64.getUrlEncoder().withoutPadding().encodeToString(signature.sign());+ return signingInput + "." + encodedSignature;+ }++ private static String base64Url(String value) {+ return Base64.getUrlEncoder().withoutPadding().encodeToString(value.getBytes(StandardCharsets.UTF_8));+ }++ private static String base64UrlUnsigned(BigInteger value) {+ byte[] bytes = value.toByteArray();+ if (bytes.length > 1 && bytes[0] == 0) {+ bytes = Arrays.copyOfRange(bytes, 1, bytes.length);+ }+ return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);}}diff --git a/src/test/java/io/github/hectorvent/floci/testutil/AppSyncRequestSigner.java b/src/test/java/io/github/hectorvent/floci/testutil/AppSyncRequestSigner.javanew file mode 100644index 0000000000..5b07c81e6e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testutil/AppSyncRequestSigner.java@@ -0,0 +1,97 @@+package io.github.hectorvent.floci.testutil;++import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.time.Instant;+import java.time.ZoneOffset;+import java.time.format.DateTimeFormatter;+import java.util.LinkedHashMap;+import java.util.Map;++/**+ * Signs an AppSync GraphQL data-plane request the way an AWS SDK signer would, so tests can+ * exercise the {@code AWS_IAM} enforcement in {@code IamAuthValidator} against real signatures+ * rather than against fixtures produced by the same code under test.+ *+ * <p>Header-signed only: real AppSync SDKs never presign this endpoint, and the fixed path/no+ * query-string shape of {@code /v1/apis/{apiId}/graphql} needs nothing else.+ */+public final class AppSyncRequestSigner {++ public static final String SIGNING_SERVICE = "appsync";++ private static final DateTimeFormatter AMZ_DATE =+ DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmss'Z'").withZone(ZoneOffset.UTC);+ private static final DateTimeFormatter SCOPE_DATE =+ DateTimeFormatter.ofPattern("yyyyMMdd").withZone(ZoneOffset.UTC);++ private AppSyncRequestSigner() {+ }++ /**+ * Returns the {@code Authorization}, {@code X-Amz-Date} and {@code Host} headers a header-signed+ * {@code POST /v1/apis/{apiId}/graphql} request carries.+ */+ public static Map<String, String> signedHeaders(String apiId, String host, String body,+ String accessKeyId, String secretKey,+ String region, Instant signedAt) throws Exception {+ String amzDate = AMZ_DATE.format(signedAt);+ String scopeDate = SCOPE_DATE.format(signedAt);+ String credentialScope = scopeDate + "/" + region + "/" + SIGNING_SERVICE + "/aws4_request";+ String signedHeaderNames = "host;x-amz-date";+ String canonicalUri = "/v1/apis/" + apiId + "/graphql";++ String canonicalRequest = "POST\n"+ + canonicalUri + "\n"+ + "\n"+ + "host:" + host + "\n"+ + "x-amz-date:" + amzDate + "\n"+ + "\n"+ + signedHeaderNames + "\n"+ + sha256Hex(body == null ? new byte[0] : body.getBytes(StandardCharsets.UTF_8));++ String stringToSign = "AWS4-HMAC-SHA256\n"+ + amzDate + "\n"+ + credentialScope + "\n"+ + sha256Hex(canonicalRequest.getBytes(StandardCharsets.UTF_8));+ byte[] signingKey = deriveSigningKey(secretKey, scopeDate, region);+ String signature = hexEncode(hmacSha256(signingKey, stringToSign));++ Map<String, String> headers = new LinkedHashMap<>();+ headers.put("Host", host);+ headers.put("X-Amz-Date", amzDate);+ headers.put("Authorization", "AWS4-HMAC-SHA256 "+ + "Credential=" + accessKeyId + "/" + credentialScope + ", "+ + "SignedHeaders=" + signedHeaderNames + ", "+ + "Signature=" + signature);+ return headers;+ }++ private static byte[] deriveSigningKey(String secretKey, String date, String region) throws Exception {+ byte[] kSecret = ("AWS4" + secretKey).getBytes(StandardCharsets.UTF_8);+ byte[] kDate = hmacSha256(kSecret, date);+ byte[] kRegion = hmacSha256(kDate, region);+ byte[] kService = hmacSha256(kRegion, SIGNING_SERVICE);+ return hmacSha256(kService, "aws4_request");+ }++ private static byte[] hmacSha256(byte[] key, String data) throws Exception {+ Mac mac = Mac.getInstance("HmacSHA256");+ mac.init(new SecretKeySpec(key, "HmacSHA256"));+ return mac.doFinal(data.getBytes(StandardCharsets.UTF_8));+ }++ private static String sha256Hex(byte[] input) throws Exception {+ return hexEncode(MessageDigest.getInstance("SHA-256").digest(input));+ }++ private static String hexEncode(byte[] bytes) {+ StringBuilder hex = new StringBuilder(bytes.length * 2);+ for (byte b : bytes) {+ hex.append(String.format("%02x", b));+ }+ return hex.toString();+ }+}