Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cognito): implement federated sign-in (#3748)
Vũ Thế Huyf004aeaad517
diff --git a/docs/services/cognito.md b/docs/services/cognito.mdindex d53b7a774e..b64ad94a8b 100644--- a/docs/services/cognito.md+++ b/docs/services/cognito.md@@ -70,10 +70,14 @@ An action given a user pool ID that does not resolve returns `ResourceNotFoundEx| UpdateIdentityProvider | Updates a provider's details, attribute mapping or identifiers. || DeleteIdentityProvider | Deletes an identity provider from a user pool. |-Providers are stored configuration only. Floci does not perform the federated sign-in-flow: there is no `/oauth2/authorize` or `/oauth2/idpresponse` endpoint, so a registered-provider cannot be used to authenticate. This covers infrastructure tooling that creates-and reads provider configuration, not federated login.+Providers can be used for generic OIDC authorization-code sign-in. Floci routes the+AWS-shaped `/oauth2/authorize` and `/oauth2/idpresponse` endpoints to the configured local+OIDC provider, exchanges the returned code, provisions or reconciles the federated user,+and issues a Cognito authorization code for the registered callback.++Only `ProviderType=OIDC` is supported by this flow. Floci does not provide a built-in hosted+UI and does not implement social providers such as Google, Facebook, Login with Amazon or+SignInWithApple.Two deliberate divergences from AWS, both consequences of not calling out to a thirdparty:@@ -116,8 +120,7 @@ the account that created it, since these requests carry no AWS credential: a `clanother pool is refused with `invalid_client`, and an access token issued by another pool with`invalid_token`. Domain names are unique across all accounts, as on AWS. The pool's `openid-configuration` advertises the custom-domainURLs when one exists. Prefix domains (`<prefix>.auth.<region>.amazoncognito.com`) are stored but not-routed, since that hostname never reaches Floci. `/oauth2/authorize`, `/login` and `/logout` are not-served on any host.+routed, since that hostname never reaches Floci. `/login` and `/logout` are not served on any host.With TLS enabled, a custom domain (`CustomDomainConfig` set) is added to Floci's servercertificate as soon as it is created, so `https://<domain>` verifies without a restart; see@@ -273,16 +276,30 @@ and returned rather than rendered. Two divergences follow from that:|------------------------------------------------------|------------------------------------------------------------------|| `GET /{userPoolId}/.well-known/openid-configuration` | OpenID discovery document || `GET /{userPoolId}/.well-known/jwks.json` | JSON Web Key Set for JWT validation |-| `POST /cognito-idp/oauth2/token` | Relaxed OAuth token endpoint for `grant_type=client_credentials` |+| `GET /cognito-idp/oauth2/authorize` | OIDC authorization-code start endpoint |+| `GET /cognito-idp/oauth2/idpresponse` | OIDC provider callback endpoint |+| `POST /cognito-idp/oauth2/token` | OAuth authorization-code and client-credentials token endpoint |++The OAuth endpoints support browser-style OIDC authorization-code sign-in as well as the+emulator-friendly client-credentials flow:++- `GET /cognito-idp/oauth2/authorize` validates the app client and callback, then redirects+ to the configured provider with an opaque state and nonce.+- `GET /cognito-idp/oauth2/idpresponse` consumes the provider state, exchanges the provider+ code and redirects to the registered callback with a one-time Cognito authorization code.+- `POST /cognito-idp/oauth2/token` redeems that authorization code once, or issues a machine+ token for `grant_type=client_credentials`.`POST /cognito-idp/oauth2/token` is intentionally emulator-friendly rather than full Cognito parity:- It requires an existing `client_id`.- It accepts `client_id` and `client_secret` from the form body or Basic auth.-- It requires a confidential app client created with `GenerateSecret=true`.+- Client-credentials requires a confidential app client created with `GenerateSecret=true`.+- Authorization-code redemption validates the client, callback URI and one-time code binding.- It requires `AllowedOAuthFlowsUserPoolClient=true` and `AllowedOAuthFlows=["client_credentials"]`.- It doesn't require a Cognito domain.-- It returns only `access_token`, `token_type`, and `expires_in`.+- Client-credentials returns only `access_token`, `token_type`, and `expires_in`; authorization-code+ redemption returns the Cognito access, ID and refresh token set.- It validates requested OAuth scopes against the app client's `AllowedOAuthScopes` and the pool's registered resource-server scopes.- It advertises the prefixed token endpoint in `/{userPoolId}/.well-known/openid-configuration`, or`https://<domain>/oauth2/token` when the pool has a custom domain (see Custom domains above).diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoCustomDomainFilter.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoCustomDomainFilter.javaindex ad38831d9b..9be7bccefe 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoCustomDomainFilter.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoCustomDomainFilter.java@@ -16,7 +16,8 @@ import java.util.Optional;/*** Routes Cognito custom-domain requests by Host. On AWS a custom domain serves- * {@code https://<domain>/oauth2/token} and {@code /oauth2/userInfo}; Floci maps those onto+ * {@code https://<domain>/oauth2/token}, {@code /oauth2/userInfo}, {@code /oauth2/authorize}, and+ * {@code /oauth2/idpresponse}; Floci maps those onto* the {@code /cognito-idp/oauth2/...} handlers and pins the pool and the account that own the* domain, since the request itself carries no AWS credential.*/diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoFederationService.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoFederationService.javanew file mode 100644index 0000000000..06470cc5fc--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoFederationService.java@@ -0,0 +1,172 @@+package io.github.hectorvent.floci.services.cognito;++import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationCode;+import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationTransaction;+import io.github.hectorvent.floci.services.cognito.model.CognitoUser;+import io.github.hectorvent.floci.services.cognito.model.IdentityProvider;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.net.URI;+import java.net.URLEncoder;+import java.nio.charset.StandardCharsets;+import java.time.Clock;+import java.time.Duration;+import java.time.Instant;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;++@ApplicationScoped+public class CognitoFederationService {++ private static final Duration TRANSACTION_LIFETIME = Duration.ofMinutes(5);+ private static final Duration AUTHORIZATION_CODE_LIFETIME = Duration.ofMinutes(5);+ private static final String OIDC_PROVIDER_TYPE = "OIDC";++ private final CognitoService cognitoService;+ private final CognitoFederationStateStore stateStore;+ private final CognitoOidcClient oidcClient;+ private final Clock clock;++ @Inject+ public CognitoFederationService(CognitoService cognitoService, CognitoFederationStateStore stateStore,+ CognitoOidcClient oidcClient, Clock clock) {+ this.cognitoService = cognitoService;+ this.stateStore = stateStore;+ this.oidcClient = oidcClient;+ this.clock = clock;+ }++ public String beginAuthorization(String userPoolId, String clientId, String redirectUri, List<String> scopes,+ String nonce, String providerName) {+ return beginAuthorization(userPoolId, clientId, redirectUri, scopes, nonce, providerName, null);+ }++ public String beginAuthorization(String userPoolId, String clientId, String redirectUri, List<String> scopes,+ String nonce, String providerName, String relyingPartyState) {+ IdentityProvider provider = cognitoService.describeIdentityProvider(userPoolId, providerName);+ requireOidcProvider(provider);+ String authorizeEndpoint = requiredProviderDetail(provider, "authorize_url", "authorize endpoint");+ String providerClientId = requiredProviderDetail(provider, "client_id", "client_id");+ validateAuthorizeEndpoint(authorizeEndpoint, provider.getProviderName());+ Instant expiresAt = clock.instant().plus(TRANSACTION_LIFETIME);+ CognitoAuthorizationTransaction transaction = new CognitoAuthorizationTransaction(+ userPoolId, clientId, redirectUri, scopes, nonce, providerName, relyingPartyState, expiresAt);+ String state = stateStore.putTransaction(transaction);++ Map<String, String> parameters = new LinkedHashMap<>();+ parameters.put("response_type", "code");+ parameters.put("client_id", providerClientId);+ parameters.put("redirect_uri", cognitoService.getIdentityProviderCallbackEndpoint(userPoolId));+ parameters.put("scope", providerScopes(provider, scopes));+ parameters.put("state", state);+ if (nonce != null && !nonce.isBlank()) {+ parameters.put("nonce", nonce);+ }+ return appendQuery(authorizeEndpoint, parameters);+ }++ public String completeAuthorization(String state, String providerCode) {+ CognitoAuthorizationTransaction transaction = stateStore.consumeTransaction(state)+ .orElseThrow(() -> new AwsException("InvalidParameterException", "Invalid federation state", 400));+ return completeAuthorization(transaction, providerCode);+ }++ String completeAuthorization(CognitoAuthorizationTransaction transaction, String providerCode) {+ IdentityProvider provider = cognitoService.describeIdentityProvider(+ transaction.userPoolId(), transaction.providerName());+ requireOidcProvider(provider);+ String providerCallback = cognitoService.getIdentityProviderCallbackEndpoint(transaction.userPoolId());+ JsonNode tokenResponse = oidcClient.exchangeCode(provider, providerCode, providerCallback);+ String accessToken = requiredText(tokenResponse, "access_token", "access token");+ JsonNode claims = oidcClient.fetchClaims(provider, accessToken);+ String subject = requiredText(claims, "sub", "subject");+ String issuer = optionalText(claims, "iss");+ CognitoUser user = cognitoService.provisionFederatedUser(transaction.userPoolId(), provider,+ subject, issuer, mapAttributes(provider, claims));+ CognitoAuthorizationCode authorizationCode = new CognitoAuthorizationCode(+ transaction.userPoolId(), transaction.clientId(), user.getUsername(), transaction.redirectUri(),+ transaction.scopes(), clock.instant().plus(AUTHORIZATION_CODE_LIFETIME));+ return stateStore.putAuthorizationCode(authorizationCode);+ }++ private Map<String, String> mapAttributes(IdentityProvider provider, JsonNode claims) {+ Map<String, String> attributes = new LinkedHashMap<>();+ for (Map.Entry<String, String> mapping : provider.getAttributeMapping().entrySet()) {+ JsonNode claim = claims.get(mapping.getValue());+ if (claim != null && !claim.isNull() && claim.isValueNode()) {+ attributes.put(mapping.getKey(), claim.asText());+ }+ }+ return attributes;+ }++ private String providerScopes(IdentityProvider provider, List<String> scopes) {+ String configuredScopes = provider.getProviderDetails().get("authorize_scopes");+ return configuredScopes != null && !configuredScopes.isBlank()+ ? configuredScopes : String.join(" ", scopes);+ }++ private String requiredText(JsonNode json, String fieldName, String description) {+ String value = optionalText(json, fieldName);+ if (value == null) {+ throw new AwsException("InvalidParameterException", "Identity provider response is missing " + description, 400);+ }+ return value;+ }++ private String optionalText(JsonNode json, String fieldName) {+ JsonNode value = json.get(fieldName);+ if (value == null || value.isNull() || !value.isValueNode() || value.asText().isBlank()) {+ return null;+ }+ return value.asText();+ }++ private String requiredProviderDetail(IdentityProvider provider, String detailName, String description) {+ String value = provider.getProviderDetails().get(detailName);+ if (value == null || value.isBlank()) {+ throw new AwsException("InvalidParameterException", "Identity provider " + provider.getProviderName()+ + " does not have a " + description + " configured", 400);+ }+ return value;+ }++ private void requireOidcProvider(IdentityProvider provider) {+ if (!OIDC_PROVIDER_TYPE.equals(provider.getProviderType())) {+ throw new AwsException("InvalidParameterException", "Identity provider " + provider.getProviderName()+ + " must have ProviderType OIDC", 400);+ }+ }++ private void validateAuthorizeEndpoint(String endpoint, String providerName) {+ try {+ URI uri = URI.create(endpoint);+ if (!uri.isAbsolute()) {+ throw new IllegalArgumentException("URI must be absolute");+ }+ } catch (IllegalArgumentException e) {+ throw new AwsException("InvalidParameterException", "Identity provider " + providerName+ + " has an invalid authorize endpoint", 400);+ }+ }++ private String appendQuery(String endpoint, Map<String, String> parameters) {+ StringBuilder result = new StringBuilder(endpoint);+ result.append(endpoint.contains("?") ? '&' : '?');+ boolean first = true;+ for (Map.Entry<String, String> parameter : parameters.entrySet()) {+ if (!first) {+ result.append('&');+ }+ result.append(URLEncoder.encode(parameter.getKey(), StandardCharsets.UTF_8));+ result.append('=');+ result.append(URLEncoder.encode(parameter.getValue(), StandardCharsets.UTF_8));+ first = false;+ }+ return result.toString();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoFederationStateStore.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoFederationStateStore.javanew file mode 100644index 0000000000..ee35192bb1--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoFederationStateStore.java@@ -0,0 +1,87 @@+package io.github.hectorvent.floci.services.cognito;++import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationCode;+import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationTransaction;+import jakarta.enterprise.context.ApplicationScoped;++import java.security.SecureRandom;+import java.time.Clock;+import java.time.Instant;+import java.util.Base64;+import java.util.Optional;+import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.atomic.AtomicReference;+import java.util.function.Function;++@ApplicationScoped+public class CognitoFederationStateStore {++ private static final int OPAQUE_KEY_BYTES = 32;++ private final ConcurrentHashMap<String, CognitoAuthorizationTransaction> transactions = new ConcurrentHashMap<>();+ private final ConcurrentHashMap<String, CognitoAuthorizationCode> authorizationCodes = new ConcurrentHashMap<>();+ private final Clock clock;+ private final SecureRandom secureRandom = new SecureRandom();++ public CognitoFederationStateStore(Clock clock) {+ this.clock = clock;+ }++ public String putTransaction(CognitoAuthorizationTransaction transaction) {+ return put(transactions, transaction);+ }++ public Optional<CognitoAuthorizationTransaction> consumeTransaction(String state) {+ return consume(transactions, state, CognitoAuthorizationTransaction::expiresAt);+ }++ public String putAuthorizationCode(CognitoAuthorizationCode authorizationCode) {+ return put(authorizationCodes, authorizationCode);+ }++ public Optional<CognitoAuthorizationCode> consumeAuthorizationCode(String code) {+ return consume(authorizationCodes, code, CognitoAuthorizationCode::expiresAt);+ }++ public Optional<CognitoAuthorizationCode> findAuthorizationCode(String code) {+ CognitoAuthorizationCode authorizationCode = authorizationCodes.get(code);+ if (authorizationCode == null) {+ return Optional.empty();+ }+ if (isExpired(authorizationCode.expiresAt())) {+ authorizationCodes.remove(code, authorizationCode);+ return Optional.empty();+ }+ return Optional.of(authorizationCode);+ }++ private <T> String put(ConcurrentHashMap<String, T> store, T value) {+ String key;+ do {+ key = generateOpaqueKey();+ } while (store.putIfAbsent(key, value) != null);+ return key;+ }++ private <T> Optional<T> consume(ConcurrentHashMap<String, T> store, String key,+ Function<T, Instant> expiresAt) {+ AtomicReference<T> consumed = new AtomicReference<>();+ store.computeIfPresent(key, (ignored, value) -> {+ if (!isExpired(expiresAt.apply(value))) {+ consumed.set(value);+ }+ return null;+ });+ return Optional.ofNullable(consumed.get());+ }++ private boolean isExpired(Instant expiresAt) {+ return !expiresAt.isAfter(clock.instant());+ }++ private String generateOpaqueKey() {+ byte[] bytes = new byte[OPAQUE_KEY_BYTES];+ secureRandom.nextBytes(bytes);+ return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthController.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthController.javaindex 20c0aface3..f38f1cf835 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthController.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthController.java@@ -3,12 +3,19 @@ package io.github.hectorvent.floci.services.cognito;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.cognito.model.CognitoAuthorizationCode;+import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationTransaction;+import io.github.hectorvent.floci.services.cognito.model.CognitoUser;+import io.github.hectorvent.floci.services.cognito.model.UserPool;+import io.github.hectorvent.floci.services.cognito.model.UserPoolClient;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import jakarta.ws.rs.Consumes;+import jakarta.ws.rs.GET;import jakarta.ws.rs.HeaderParam;import jakarta.ws.rs.POST;import jakarta.ws.rs.Path;+import jakarta.ws.rs.QueryParam;import jakarta.ws.rs.Produces;import jakarta.ws.rs.container.ContainerRequestContext;import jakarta.ws.rs.core.Context;@@ -17,9 +24,16 @@ import jakarta.ws.rs.core.MultivaluedMap;import jakarta.ws.rs.core.Response;import org.jboss.logging.Logger;+import java.net.URI;+import java.net.URLEncoder;import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.util.ArrayList;import java.util.Base64;+import java.util.LinkedHashMap;+import java.util.List;import java.util.Map;+import java.util.Optional;@ApplicationScoped@Path("/")@@ -30,11 +44,100 @@ public class CognitoOAuthController {private final CognitoService cognitoService;private final ObjectMapper objectMapper;+ private final CognitoFederationService federationService;+ private final CognitoFederationStateStore stateStore;@Inject- public CognitoOAuthController(CognitoService cognitoService, ObjectMapper objectMapper) {+ public CognitoOAuthController(CognitoService cognitoService, ObjectMapper objectMapper,+ CognitoFederationService federationService,+ CognitoFederationStateStore stateStore) {this.cognitoService = cognitoService;this.objectMapper = objectMapper;+ this.federationService = federationService;+ this.stateStore = stateStore;+ }++ @GET+ @Path("/cognito-idp/oauth2/authorize")+ public Response authorize(@Context ContainerRequestContext requestContext,+ @QueryParam("client_id") String clientId,+ @QueryParam("redirect_uri") String redirectUri,+ @QueryParam("response_type") String responseType,+ @QueryParam("scope") String scope,+ @QueryParam("nonce") String nonce,+ @QueryParam("identity_provider") String providerName,+ @QueryParam("state") String relyingPartyState) {+ if (!"code".equals(trimToNull(responseType))) {+ return oauthError("unsupported_response_type", "Only response_type=code is supported");+ }+ if (trimToNull(clientId) == null || trimToNull(redirectUri) == null || trimToNull(providerName) == null) {+ return oauthError("invalid_request", "client_id, redirect_uri, and identity_provider are required");+ }++ UserPoolClient client;+ try {+ client = cognitoService.findClientById(clientId);+ } catch (AwsException e) {+ return oauthError("invalid_client", "Client not found");+ }+ String domainPoolId = (String) requestContext.getProperty(CognitoCustomDomainFilter.POOL_PROPERTY);+ if (domainPoolId != null && !domainPoolId.equals(client.getUserPoolId())) {+ return oauthError("invalid_client", "Client not found");+ }+ if (!client.isAllowedOAuthFlowsUserPoolClient() || !client.getAllowedOAuthFlows().contains("code")) {+ return oauthError("unauthorized_client", "Client is not allowed to use the authorization code flow");+ }+ if (!client.getCallbackURLs().contains(redirectUri)) {+ return oauthError("invalid_request", "redirect_uri is not registered for this client");+ }++ try {+ String location = federationService.beginAuthorization(client.getUserPoolId(), clientId, redirectUri,+ splitScopes(scope), trimToNull(nonce), providerName, relyingPartyState);+ return Response.status(Response.Status.FOUND).location(URI.create(location)).build();+ } catch (AwsException e) {+ return oauthError("invalid_request", e.getMessage());+ }+ }++ @GET+ @Path("/cognito-idp/oauth2/idpresponse")+ public Response idpResponse(@Context ContainerRequestContext requestContext,+ @QueryParam("state") String state,+ @QueryParam("code") String providerCode,+ @QueryParam("error") String error,+ @QueryParam("error_description") String errorDescription) {+ String normalizedState = trimToNull(state);+ if (normalizedState == null) {+ return oauthError("invalid_request", "state is required");+ }+ Optional<CognitoAuthorizationTransaction> transaction = stateStore.consumeTransaction(normalizedState);+ if (transaction.isEmpty()) {+ return oauthError("invalid_request", "Invalid federation state");+ }+ String domainPoolId = (String) requestContext.getProperty(CognitoCustomDomainFilter.POOL_PROPERTY);+ if (domainPoolId != null && !domainPoolId.equals(transaction.get().userPoolId())) {+ return oauthError("invalid_request", "Invalid federation state");+ }+ if (trimToNull(error) != null) {+ Map<String, String> errorParameters = new LinkedHashMap<>();+ errorParameters.put("error", error);+ errorParameters.put("error_description", errorDescription == null ? "" : errorDescription);+ putRelyingPartyState(errorParameters, transaction.get());+ return redirect(transaction.get().redirectUri(), errorParameters);+ }+ if (trimToNull(providerCode) == null) {+ return oauthError("invalid_request", "code is required");+ }+ try {+ String authorizationCode = federationService.completeAuthorization(transaction.get(), providerCode);+ Map<String, String> parameters = new LinkedHashMap<>();+ parameters.put("code", authorizationCode);+ putRelyingPartyState(parameters, transaction.get());+ return redirect(transaction.get().redirectUri(), parameters);+ } catch (AwsException e) {+ return oauthError("invalid_request", e.getMessage());+ }}@POST@@ -53,10 +156,6 @@ public class CognitoOAuthController {if (grantType == null) {return oauthError("invalid_request", "grant_type is required");}- if (!"client_credentials".equals(grantType)) {- return oauthError("unsupported_grant_type", "Only client_credentials is supported");- }-BasicCredentials basicCredentials;try {basicCredentials = parseBasicCredentials(authorization);@@ -69,7 +168,7 @@ public class CognitoOAuthController {String basicClientId = basicCredentials != null ? basicCredentials.clientId() : null;String basicClientSecret = basicCredentials != null ? basicCredentials.clientSecret() : null;- if (bodyClientSecret != null && basicClientSecret != null && !bodyClientSecret.equals(basicClientSecret)) {+ if (bodyClientSecret != null && basicClientSecret != null && !secretsEqual(bodyClientSecret, basicClientSecret)) {return oauthError("invalid_request", "client_secret does not match Authorization header");}@@ -83,6 +182,12 @@ public class CognitoOAuthController {}String clientSecret = bodyClientSecret != null ? bodyClientSecret : basicClientSecret;+ if ("authorization_code".equals(grantType)) {+ return redeemAuthorizationCode(clientId, clientSecret, formParams, domainPoolId);+ }+ if (!"client_credentials".equals(grantType)) {+ return oauthError("unsupported_grant_type", "Only client_credentials and authorization_code are supported");+ }String scope = trimToNull(formParams.getFirst("scope"));try {@@ -111,6 +216,99 @@ public class CognitoOAuthController {}}+ private Response redeemAuthorizationCode(String clientId, String clientSecret,+ MultivaluedMap<String, String> formParams, String domainPoolId) {+ String code = trimToNull(formParams.getFirst("code"));+ String redirectUri = trimToNull(formParams.getFirst("redirect_uri"));+ if (code == null || redirectUri == null) {+ return oauthError("invalid_request", "code and redirect_uri are required");+ }+ UserPoolClient client;+ try {+ client = cognitoService.findClientById(clientId);+ } catch (AwsException e) {+ return oauthError("invalid_client", "Client not found");+ }+ if (client.getClientSecret() != null && !client.getClientSecret().isBlank()+ && !secretsEqual(client.getClientSecret(), clientSecret)) {+ return oauthError("invalid_client", "Client secret is invalid");+ }++ Optional<CognitoAuthorizationCode> authorizationCode = stateStore.findAuthorizationCode(code);+ if (authorizationCode.isEmpty()) {+ return oauthError("invalid_grant", "Authorization code is invalid or has expired");+ }+ CognitoAuthorizationCode storedCode = authorizationCode.get();+ if (!clientId.equals(storedCode.clientId()) || !redirectUri.equals(storedCode.redirectUri())+ || (domainPoolId != null && !domainPoolId.equals(storedCode.userPoolId()))+ || !storedCode.userPoolId().equals(client.getUserPoolId())) {+ return oauthError("invalid_grant", "Authorization code was not issued to this client");+ }+ Optional<CognitoAuthorizationCode> consumed = stateStore.consumeAuthorizationCode(code);+ if (consumed.isEmpty()) {+ return oauthError("invalid_grant", "Authorization code is invalid or has expired");+ }+ CognitoAuthorizationCode consumedCode = consumed.get();+ try {+ UserPool pool = cognitoService.describeUserPool(consumedCode.userPoolId());+ CognitoUser user = cognitoService.adminGetUser(consumedCode.userPoolId(), consumedCode.userId());+ Map<String, Object> authentication = cognitoService.generateAuthResult(user, pool, client, null);+ ObjectNode body = objectMapper.createObjectNode();+ body.put("access_token", (String) authentication.get("AccessToken"));+ body.put("id_token", (String) authentication.get("IdToken"));+ body.put("refresh_token", (String) authentication.get("RefreshToken"));+ body.put("expires_in", ((Number) authentication.get("ExpiresIn")).longValue());+ body.put("token_type", (String) authentication.get("TokenType"));+ return Response.ok(body).type(MediaType.APPLICATION_JSON)+ .header("Cache-Control", "no-store").header("Pragma", "no-cache").build();+ } catch (AwsException e) {+ LOG.error("Failed to redeem Cognito authorization code", e);+ return oauthError("invalid_grant", e.getMessage());+ }+ }++ private Response redirect(String redirectUri, Map<String, String> parameters) {+ StringBuilder location = new StringBuilder(redirectUri);+ location.append(redirectUri.contains("?") ? '&' : '?');+ boolean first = true;+ for (Map.Entry<String, String> parameter : parameters.entrySet()) {+ if (!first) {+ location.append('&');+ }+ location.append(URLEncoder.encode(parameter.getKey(), StandardCharsets.UTF_8));+ location.append('=').append(URLEncoder.encode(parameter.getValue(), StandardCharsets.UTF_8));+ first = false;+ }+ return Response.status(Response.Status.FOUND).location(URI.create(location.toString())).build();+ }++ private boolean secretsEqual(String expected, String actual) {+ if (expected == null || actual == null) {+ return expected == actual;+ }+ return MessageDigest.isEqual(expected.getBytes(StandardCharsets.UTF_8), actual.getBytes(StandardCharsets.UTF_8));+ }++ private void putRelyingPartyState(Map<String, String> parameters, CognitoAuthorizationTransaction transaction) {+ if (transaction.relyingPartyState() != null) {+ parameters.put("state", transaction.relyingPartyState());+ }+ }++ private List<String> splitScopes(String scope) {+ String normalizedScope = trimToNull(scope);+ if (normalizedScope == null) {+ return List.of();+ }+ List<String> scopes = new ArrayList<>();+ for (String value : normalizedScope.split("\\s+")) {+ if (!value.isBlank()) {+ scopes.add(value);+ }+ }+ return scopes;+ }+private Response oauthError(String error, String description) {ObjectNode body = objectMapper.createObjectNode();body.put("error", error);diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOidcClient.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOidcClient.javanew file mode 100644index 0000000000..ecb7683aa8--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOidcClient.java@@ -0,0 +1,140 @@+package io.github.hectorvent.floci.services.cognito;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cognito.model.IdentityProvider;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.inject.Inject;++import java.io.IOException;+import java.net.URI;+import java.net.URLEncoder;+import java.net.http.HttpClient;+import java.net.http.HttpRequest;+import java.net.http.HttpResponse;+import java.nio.charset.StandardCharsets;+import java.time.Duration;+import java.util.LinkedHashMap;+import java.util.Map;+import java.util.function.Function;++@ApplicationScoped+public class CognitoOidcClient {++ private static final Duration CONNECT_TIMEOUT = Duration.ofSeconds(10);+ private static final Duration REQUEST_TIMEOUT = Duration.ofSeconds(15);++ private final HttpClient httpClient;+ private final ObjectMapper objectMapper;++ @Inject+ public CognitoOidcClient(ObjectMapper objectMapper) {+ this(HttpClient.newBuilder().connectTimeout(CONNECT_TIMEOUT).build(), objectMapper);+ }++ CognitoOidcClient(HttpClient httpClient, ObjectMapper objectMapper) {+ this.httpClient = httpClient;+ this.objectMapper = objectMapper;+ }++ public JsonNode exchangeCode(IdentityProvider provider, String code, String redirectUri) {+ String tokenEndpoint = requiredEndpoint(provider, "token_url", "token");+ Map<String, String> form = new LinkedHashMap<>();+ form.put("grant_type", "authorization_code");+ form.put("client_id", requiredProviderDetail(provider, "client_id"));+ String clientSecret = provider.getProviderDetails().get("client_secret");+ if (clientSecret != null && !clientSecret.isBlank()) {+ form.put("client_secret", clientSecret);+ }+ form.put("code", code);+ form.put("redirect_uri", redirectUri);++ HttpRequest request = buildRequest(tokenEndpoint, provider.getProviderName(), "token", builder -> builder+ .header("Accept", "application/json")+ .header("Content-Type", "application/x-www-form-urlencoded")+ .POST(HttpRequest.BodyPublishers.ofString(formEncode(form)))+ .build());+ return send(request, "token exchange");+ }++ public JsonNode fetchClaims(IdentityProvider provider, String accessToken) {+ String claimsEndpoint = requiredEndpoint(provider, "attributes_url", "claims");+ if (accessToken == null || accessToken.isBlank()) {+ throw new AwsException("NotAuthorizedException", "Identity provider did not return an access token", 400);+ }++ HttpRequest request = buildRequest(claimsEndpoint, provider.getProviderName(), "claims", builder -> builder+ .header("Accept", "application/json")+ .header("Authorization", "Bearer " + accessToken)+ .GET()+ .build());+ return send(request, "claims request");+ }++ private JsonNode send(HttpRequest request, String operation) {+ try {+ HttpResponse<String> response = httpClient.send(request, HttpResponse.BodyHandlers.ofString());+ if (response.statusCode() < 200 || response.statusCode() >= 300) {+ throw new AwsException("NotAuthorizedException", "Identity provider " + operation + " failed", 400);+ }+ JsonNode responseJson = objectMapper.readTree(response.body());+ if (responseJson == null || !responseJson.isObject()) {+ throw new AwsException("NotAuthorizedException", "Identity provider " + operation+ + " returned an invalid response", 400);+ }+ return responseJson;+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ throw new AwsException("NotAuthorizedException", "Identity provider " + operation + " was interrupted", 400);+ } catch (IOException | IllegalArgumentException e) {+ throw new AwsException("NotAuthorizedException", "Identity provider " + operation + " failed", 400);+ }+ }++ private String requiredEndpoint(IdentityProvider provider, String detailName, String endpointName) {+ String endpoint = provider.getProviderDetails().get(detailName);+ if (endpoint == null || endpoint.isBlank()) {+ throw new AwsException("InvalidParameterException", "Identity provider " + provider.getProviderName()+ + " does not have a " + endpointName + " endpoint configured", 400);+ }+ return endpoint;+ }++ private HttpRequest buildRequest(String endpoint, String providerName, String endpointName,+ Function<HttpRequest.Builder, HttpRequest> requestFactory) {+ try {+ URI uri = URI.create(endpoint);+ if (!"http".equalsIgnoreCase(uri.getScheme()) && !"https".equalsIgnoreCase(uri.getScheme())) {+ throw new IllegalArgumentException("Unsupported URI scheme");+ }+ HttpRequest.Builder builder = HttpRequest.newBuilder(uri).timeout(REQUEST_TIMEOUT);+ return requestFactory.apply(builder);+ } catch (IllegalArgumentException e) {+ throw new AwsException("InvalidParameterException", "Identity provider " + providerName+ + " has an invalid " + endpointName + " endpoint", 400);+ }+ }++ private String requiredProviderDetail(IdentityProvider provider, String detailName) {+ String value = provider.getProviderDetails().get(detailName);+ if (value == null || value.isBlank()) {+ throw new AwsException("InvalidParameterException", "Identity provider " + provider.getProviderName()+ + " does not have " + detailName + " configured", 400);+ }+ return value;+ }++ private String formEncode(Map<String, String> form) {+ StringBuilder encoded = new StringBuilder();+ for (Map.Entry<String, String> entry : form.entrySet()) {+ if (!encoded.isEmpty()) {+ encoded.append('&');+ }+ encoded.append(URLEncoder.encode(entry.getKey(), StandardCharsets.UTF_8));+ encoded.append('=');+ encoded.append(URLEncoder.encode(entry.getValue(), StandardCharsets.UTF_8));+ }+ return encoded.toString();+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.javaindex b8c7f0d868..cff7653b5b 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoService.java@@ -2034,6 +2034,59 @@ public class CognitoService implements ResourceProvider {return MAPPER.createArrayNode();}+ public Optional<CognitoUser> findFederatedUser(String userPoolId, String providerName, String subject) {+ describeUserPool(userPoolId);+ String prefix = userPoolId + "::";+ return userStore.scan(key -> key.startsWith(prefix)).stream()+ .filter(user -> providerName.equals(user.getFederatedProviderName())+ && subject.equals(user.getFederatedSubject()))+ .findFirst();+ }++ public CognitoUser provisionFederatedUser(String userPoolId, IdentityProvider provider, String subject,+ String issuer, Map<String, String> mappedAttributes) {+ describeUserPool(userPoolId);+ synchronized (identityLinkLock) {+ CognitoUser user = findFederatedUser(userPoolId, provider.getProviderName(), subject).orElse(null);+ if (user == null) {+ user = new CognitoUser();+ user.setUsername(provider.getProviderName() + "_" + UUID.randomUUID());+ user.setUserPoolId(userPoolId);+ user.getAttributes().put("sub", UUID.randomUUID().toString());+ }+ user.getAttributes().putAll(mappedAttributes);+ user.setFederatedProviderName(provider.getProviderName());+ user.setFederatedSubject(subject);+ updateFederatedIdentity(user, provider, subject, issuer);+ user.setEnabled(true);+ user.setUserStatus("CONFIRMED");+ user.setLastModifiedDate(System.currentTimeMillis() / 1000L);+ userStore.put(userKey(userPoolId, user.getUsername()), user);+ LOG.infov("Reconciled federated user {0} from provider {1} in pool {2}",+ user.getUsername(), provider.getProviderName(), userPoolId);+ return user;+ }+ }++ private void updateFederatedIdentity(CognitoUser user, IdentityProvider provider, String subject, String issuer) {+ ArrayNode identities = readIdentities(user);+ ArrayNode reconciled = MAPPER.createArrayNode();+ for (JsonNode identity : identities) {+ if (!provider.getProviderName().equals(identity.path("providerName").asText())+ || !subject.equals(identity.path("userId").asText())) {+ reconciled.add(identity);+ }+ }+ reconciled.addObject()+ .put("userId", subject)+ .put("providerName", provider.getProviderName())+ .put("providerType", provider.getProviderType())+ .put("issuer", issuer)+ .put("primary", false)+ .put("dateCreated", System.currentTimeMillis());+ user.getAttributes().put(IDENTITIES_ATTRIBUTE, reconciled.toString());+ }+public List<CognitoUser> listUsers(String userPoolId, String filter) {describeUserPool(userPoolId);String prefix = userPoolId + "::";@@ -2998,6 +3051,16 @@ public class CognitoService implements ResourceProvider {return oauthEndpoint(poolId, "userInfo");}+ /**+ * Returns the callback endpoint that an external identity provider uses to return its+ * authorization response to Cognito.+ */+ public String getIdentityProviderCallbackEndpoint(String poolId) {+ return findCustomDomainForPool(poolId)+ .map(d -> "https://" + d.getDomain() + "/oauth2/idpresponse")+ .orElse(baseUrl + "/cognito-idp/oauth2/idpresponse");+ }+private String oauthEndpoint(String poolId, String operation) {return findCustomDomainForPool(poolId).map(d -> "https://" + d.getDomain() + "/oauth2/" + operation)diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoWellKnownController.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoWellKnownController.javaindex d184b6f4b0..d3bae7b8e5 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoWellKnownController.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoWellKnownController.java@@ -10,6 +10,8 @@ import jakarta.ws.rs.core.MediaType;import jakarta.ws.rs.core.Response;import java.math.BigInteger;+import java.security.interfaces.RSAPublicKey;+import java.util.Arrays;import java.util.Base64;/**@@ -43,7 +45,7 @@ public class CognitoWellKnownController {public Response getJwks(@PathParam("poolId") String poolId) {UserPool pool = cognitoService.describeUserPool(poolId);String kid = cognitoService.getSigningKeyId(pool);- var publicKey = cognitoService.getSigningPublicKey(pool);+ RSAPublicKey publicKey = cognitoService.getSigningPublicKey(pool);String modulus = base64UrlEncodeUnsigned(publicKey.getModulus());String exponent = base64UrlEncodeUnsigned(publicKey.getPublicExponent());@@ -61,17 +63,18 @@ public class CognitoWellKnownController {String jwksUri = cognitoService.getJwksUri(pool.getId());String tokenEndpoint = cognitoService.getTokenEndpoint(pool.getId());String userInfoEndpoint = cognitoService.getUserInfoEndpoint(pool.getId());+ String authorizationEndpoint = tokenEndpoint.replace("/token", "/authorize");String body = """- {"issuer":"%s","jwks_uri":"%s","token_endpoint":"%s","userinfo_endpoint":"%s","subject_types_supported":["public"],"response_types_supported":[],"grant_types_supported":["client_credentials"],"token_endpoint_auth_methods_supported":["client_secret_basic","client_secret_post"],"id_token_signing_alg_values_supported":["RS256"]}- """.formatted(issuer, jwksUri, tokenEndpoint, userInfoEndpoint).strip();+ {"issuer":"%s","jwks_uri":"%s","authorization_endpoint":"%s","token_endpoint":"%s","userinfo_endpoint":"%s","subject_types_supported":["public"],"response_types_supported":["code"],"grant_types_supported":["client_credentials","authorization_code"],"token_endpoint_auth_methods_supported":["client_secret_basic","client_secret_post"],"id_token_signing_alg_values_supported":["RS256"]}+ """.formatted(issuer, jwksUri, authorizationEndpoint, tokenEndpoint, userInfoEndpoint).strip();return Response.ok(body).build();}private String base64UrlEncodeUnsigned(BigInteger value) {byte[] bytes = value.toByteArray();if (bytes.length > 1 && bytes[0] == 0) {- bytes = java.util.Arrays.copyOfRange(bytes, 1, bytes.length);+ bytes = Arrays.copyOfRange(bytes, 1, bytes.length);}return Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationCode.java b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationCode.javanew file mode 100644index 0000000000..f71fc8a1ad--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationCode.java@@ -0,0 +1,17 @@+package io.github.hectorvent.floci.services.cognito.model;++import java.time.Instant;+import java.util.List;++public record CognitoAuthorizationCode(+ String userPoolId,+ String clientId,+ String userId,+ String redirectUri,+ List<String> scopes,+ Instant expiresAt) {++ public CognitoAuthorizationCode {+ scopes = List.copyOf(scopes);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationTransaction.java b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationTransaction.javanew file mode 100644index 0000000000..1c2482a0bf--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationTransaction.java@@ -0,0 +1,19 @@+package io.github.hectorvent.floci.services.cognito.model;++import java.time.Instant;+import java.util.List;++public record CognitoAuthorizationTransaction(+ String userPoolId,+ String clientId,+ String redirectUri,+ List<String> scopes,+ String nonce,+ String providerName,+ String relyingPartyState,+ Instant expiresAt) {++ public CognitoAuthorizationTransaction {+ scopes = List.copyOf(scopes);+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoUser.java b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoUser.javaindex ee89911f94..e765d42785 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoUser.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoUser.java@@ -26,6 +26,8 @@ public class CognitoUser {private String srpSalt;private String srpVerifier;private EmailMfaSettings emailMfaSettings;+ private String federatedProviderName;+ private String federatedSubject;public CognitoUser() {long now = System.currentTimeMillis() / 1000L;@@ -89,4 +91,20 @@ public class CognitoUser {public void setEmailMfaSettings(EmailMfaSettings emailMfaSettings) {this.emailMfaSettings = emailMfaSettings;}++ public String getFederatedProviderName() {+ return federatedProviderName;+ }++ public void setFederatedProviderName(String federatedProviderName) {+ this.federatedProviderName = federatedProviderName;+ }++ public String getFederatedSubject() {+ return federatedSubject;+ }++ public void setFederatedSubject(String federatedSubject) {+ this.federatedSubject = federatedSubject;+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoCustomDomainOAuthContractIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoCustomDomainOAuthContractIntegrationTest.javaindex 84a11b3708..b10c7101f4 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoCustomDomainOAuthContractIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoCustomDomainOAuthContractIntegrationTest.java@@ -98,7 +98,7 @@ class CognitoCustomDomainOAuthContractIntegrationTest {@Test@Order(4)- void unsupportedGrantTypeIsRefused() {+ void authorizationCodeGrantRequiresItsMandatoryParameters() {given().header("Host", DOMAIN).header("Authorization", basic(clientA, secretA))@@ -108,7 +108,7 @@ class CognitoCustomDomainOAuthContractIntegrationTest {.post("/oauth2/token").then().statusCode(400)- .body("error", equalTo("unsupported_grant_type"));+ .body("error", equalTo("invalid_request"));}@Test@@ -175,11 +175,35 @@ class CognitoCustomDomainOAuthContractIntegrationTest {.header("WWW-Authenticate", startsWith("Bearer error=\"invalid_token\""));}- /** Floci has no hosted UI: the other endpoints AWS serves on a domain are absent, not stubbed. */+ /** Floci has no hosted UI revoke endpoint. */@Test@Order(9)- void otherHostedUiPathsAreNotServed() {- for (String path : List.of("/oauth2/authorize", "/oauth2/revoke", "/oauth2/idpresponse")) {+ void authorizeRouteIsServedOnCustomDomain() {+ given()+ .header("Host", DOMAIN)+ .when()+ .get("/oauth2/authorize")+ .then()+ .statusCode(400)+ .body("error", equalTo("unsupported_response_type"));+ }++ @Test+ @Order(10)+ void idpResponseRouteIsServedOnCustomDomain() {+ given()+ .header("Host", DOMAIN)+ .when()+ .get("/oauth2/idpresponse")+ .then()+ .statusCode(400)+ .body("error", equalTo("invalid_request"));+ }++ @Test+ @Order(11)+ void revokeEndpointIsNotServed() {+ for (String path : List.of("/oauth2/revoke")) {given().header("Host", DOMAIN).when()@@ -191,7 +215,7 @@ class CognitoCustomDomainOAuthContractIntegrationTest {/** A prefix domain's hostname resolves to AWS, so Floci never routes by it. */@Test- @Order(10)+ @Order(12)void prefixDomainHostIsNotRouted() throws Exception {String prefix = "routing-prefix-" + System.nanoTime();cognitoJson("CreateUserPoolDomain", """@@ -211,7 +235,7 @@ class CognitoCustomDomainOAuthContractIntegrationTest {* requests on many threads must never let one request's pin decide another's answer.*/@Test- @Order(11)+ @Order(13)void concurrentRequestsKeepTheirOwnPinnedPool() throws Exception {ExecutorService pool = Executors.newFixedThreadPool(8);try {diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederatedSignInIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederatedSignInIntegrationTest.javanew file mode 100644index 0000000000..b8ce2cd3d4--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederatedSignInIntegrationTest.java@@ -0,0 +1,156 @@+package io.github.hectorvent.floci.services.cognito;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.Response;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.net.URI;+import java.net.URLDecoder;+import java.net.http.HttpClient;+import java.net.http.HttpRequest;+import java.net.http.HttpResponse;+import java.nio.charset.StandardCharsets;+import java.util.Map;++import static io.github.hectorvent.floci.services.cognito.CognitoCustomDomainFixtures.customDomain;+import static io.github.hectorvent.floci.services.cognito.CognitoCustomDomainFixtures.requestCertificate;+import static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoJson;+import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNotNull;++@QuarkusTest+class CognitoFederatedSignInIntegrationTest {++ private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();+ private static final String DOMAIN = "federated-" + System.nanoTime() + ".teos.localhost.floci.io";++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void oidcProviderReceivesAuthorizationRequestAndDiscoveryAdvertisesCodeFlow() throws Exception {+ try (MockOidcProvider provider = new MockOidcProvider()) {+ String poolId = cognitoJson("CreateUserPool", "{\"PoolName\":\"FederatedPool\"}")+ .path("UserPool").path("Id").asText();+ JsonNode client = cognitoJson("CreateUserPoolClient", """+ {"UserPoolId":"%s","ClientName":"federated-client","AllowedOAuthFlowsUserPoolClient":true,+ "AllowedOAuthFlows":["code"],"AllowedOAuthScopes":["openid"],"CallbackURLs":["https://client.example/callback"]}+ """.formatted(poolId)).path("UserPoolClient");+ String clientId = client.path("ClientId").asText();+ cognitoJson("CreateIdentityProvider", """+ {"UserPoolId":"%s","ProviderName":"LocalOidc","ProviderType":"OIDC",+ "ProviderDetails":{"authorize_url":"%s/authorize","token_url":"%s/token","attributes_url":"%s/userinfo","client_id":"provider-client","client_secret":"provider-secret"},+ "AttributeMapping":{"email":"email","username":"sub"}}+ """.formatted(poolId, provider.baseUrl(), provider.baseUrl(), provider.baseUrl()));+ cognitoJson("CreateUserPoolDomain", customDomain(DOMAIN, poolId, requestCertificate(DOMAIN)));++ Response authorizeResponse = given()+ .redirects().follow(false)+ .header("Host", DOMAIN)+ .queryParam("client_id", clientId)+ .queryParam("redirect_uri", "https://client.example/callback")+ .queryParam("response_type", "code")+ .queryParam("scope", "openid")+ .queryParam("identity_provider", "LocalOidc")+ .queryParam("state", "client-state")+ .when()+ .get("/oauth2/authorize")+ .then().statusCode(302).extract().response();+ String location = authorizeResponse.getHeader("Location");+ assertNotNull(location, authorizeResponse.getHeaders().toString());++ assertEquals(provider.baseUrl() + "/authorize", URI.create(location).resolve("/authorize").toString());+ String providerState = queryParameter(location, "state");+ assertNotNull(providerState);+ assertFalse(providerState.equals("client-state"));+ assertEquals("code", queryParameter(location, "response_type"));++ HttpClient httpClient = HttpClient.newHttpClient();+ HttpResponse<Void> providerAuthorizeResponse = httpClient.send(+ HttpRequest.newBuilder(URI.create(location)).GET().build(),+ HttpResponse.BodyHandlers.discarding());+ assertEquals(302, providerAuthorizeResponse.statusCode());+ Map<String, String> providerParameters = provider.authorizationParameters();+ assertEquals("provider-client", providerParameters.get("client_id"));+ assertEquals("code", providerParameters.get("response_type"));+ assertEquals("https://" + DOMAIN + "/oauth2/idpresponse", providerParameters.get("redirect_uri"));+ assertEquals("openid", providerParameters.get("scope"));++ Response callbackResponse = given()+ .redirects().follow(false)+ .header("Host", DOMAIN)+ .queryParam("state", providerState)+ .queryParam("code", "provider-code")+ .when()+ .get("/oauth2/idpresponse")+ .then().statusCode(302).extract().response();+ String callbackLocation = callbackResponse.getHeader("Location");+ assertEquals("client-state", queryParameter(callbackLocation, "state"));+ String authorizationCode = queryParameter(callbackLocation, "code");++ Response tokenResponse = given()+ .header("Host", DOMAIN)+ .formParam("grant_type", "authorization_code")+ .formParam("client_id", clientId)+ .formParam("code", authorizationCode)+ .formParam("redirect_uri", "https://client.example/callback")+ .when()+ .post("/oauth2/token")+ .then().statusCode(200)+ .body("token_type", equalTo("Bearer"))+ .extract().response();+ assertEquals("authorization_code", formValue(provider.tokenRequestBody(), "grant_type"));+ assertEquals("Bearer provider-access-token", provider.userInfoAuthorization());++ JsonNode users = cognitoJson("ListUsers", "{\"UserPoolId\":\"%s\",\"Filter\":\"email = \\\"[email protected]\\\"\"}".formatted(poolId));+ JsonNode attributes = users.path("Users").get(0).path("Attributes");+ assertEquals("[email protected]", attributeValue(attributes, "email"));+ JsonNode identities = OBJECT_MAPPER.readTree(attributeValue(attributes, "identities")).get(0);+ assertEquals("LocalOidc", identities.path("providerName").asText());+ assertEquals("provider-subject", identities.path("userId").asText());+ assertFalse(identities.path("primary").asBoolean());+ String accessToken = tokenResponse.path("access_token").toString();+ assertFalse(accessToken.isBlank());++ given()+ .get("/" + poolId + "/.well-known/openid-configuration")+ .then()+ .statusCode(200)+ .body("response_types_supported[0]", equalTo("code"))+ .body("authorization_endpoint", equalTo("https://" + DOMAIN + "/oauth2/authorize"))+ .body("grant_types_supported[1]", equalTo("authorization_code"));+ }+ }++ private String queryParameter(String location, String name) {+ for (String parameter : URI.create(location).getRawQuery().split("&")) {+ String[] pair = parameter.split("=", 2);+ if (pair[0].equals(name)) {+ return URLDecoder.decode(pair[1], StandardCharsets.UTF_8);+ }+ }+ return null;+ }++ private String formValue(String form, String name) {+ return queryParameter("http://localhost/?" + form, name);+ }++ private String attributeValue(JsonNode attributes, String name) {+ for (JsonNode attribute : attributes) {+ if (name.equals(attribute.path("Name").asText())) {+ return attribute.path("Value").asText();+ }+ }+ return null;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederationServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederationServiceTest.javanew file mode 100644index 0000000000..c45e033465--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederationServiceTest.java@@ -0,0 +1,438 @@+package io.github.hectorvent.floci.services.cognito;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.sun.net.httpserver.HttpExchange;+import com.sun.net.httpserver.HttpServer;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.acm.AcmService;+import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationCode;+import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationTransaction;+import io.github.hectorvent.floci.services.cognito.model.CognitoGroup;+import io.github.hectorvent.floci.services.cognito.model.CognitoUser;+import io.github.hectorvent.floci.services.cognito.model.IdentityProvider;+import io.github.hectorvent.floci.services.cognito.model.ResourceServer;+import io.github.hectorvent.floci.services.cognito.model.RevokedTokenInfo;+import io.github.hectorvent.floci.services.cognito.model.UserPool;+import io.github.hectorvent.floci.services.cognito.model.UserPoolClient;+import io.github.hectorvent.floci.services.cognito.model.UserPoolDomain;+import org.junit.jupiter.api.AfterEach;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.io.IOException;+import java.net.InetSocketAddress;+import java.net.URI;+import java.net.URLDecoder;+import java.nio.charset.StandardCharsets;+import java.time.Clock;+import java.time.Instant;+import java.time.ZoneOffset;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.List;+import java.util.Map;+import java.util.concurrent.atomic.AtomicReference;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.mock;++class CognitoFederationServiceTest {++ private static final Clock CLOCK = Clock.fixed(Instant.parse("2026-09-16T00:00:00Z"), ZoneOffset.UTC);+ private static final ObjectMapper MAPPER = new ObjectMapper();++ private HttpServer oidcServer;+ private CognitoService cognitoService;+ private CognitoFederationStateStore stateStore;+ private CognitoFederationService federationService;+ private UserPool pool;+ private final AtomicReference<Request> tokenRequest = new AtomicReference<>();+ private final AtomicReference<Request> claimsRequest = new AtomicReference<>();+ private volatile int tokenStatus;+ private volatile String tokenResponse;+ private volatile int claimsStatus;+ private volatile String claimsResponse;++ @BeforeEach+ void setUp() throws IOException {+ oidcServer = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ oidcServer.createContext("/token", this::handleToken);+ oidcServer.createContext("/userinfo", this::handleClaims);+ oidcServer.start();++ cognitoService = new CognitoService(+ new InMemoryStorage<String, UserPool>(),+ new InMemoryStorage<String, UserPoolClient>(),+ new InMemoryStorage<String, ResourceServer>(),+ new InMemoryStorage<String, UserPoolDomain>(),+ new InMemoryStorage<String, IdentityProvider>(),+ new InMemoryStorage<String, CognitoUser>(),+ new InMemoryStorage<String, CognitoGroup>(),+ new InMemoryStorage<String, RevokedTokenInfo>(),+ "http://localhost:4566",+ new RegionResolver("us-east-1", "000000000000"),+ null,+ mock(AcmService.class),+ null,+ null,+ null);+ stateStore = new CognitoFederationStateStore(CLOCK);+ federationService = new CognitoFederationService(+ cognitoService, stateStore, new CognitoOidcClient(MAPPER), CLOCK);+ pool = cognitoService.createUserPool(Map.of("PoolName", "FederationPool"), "us-east-1");+ tokenStatus = 200;+ tokenResponse = "{\"access_token\":\"provider-access-token\"}";+ claimsStatus = 200;+ claimsResponse = "{\"sub\":\"provider-subject\",\"iss\":\"https://issuer.example.test\","+ + "\"email\":\"[email protected]\",\"name\":\"Alice Provider\"}";+ }++ @AfterEach+ void tearDown() {+ oidcServer.stop(0);+ }++ @Test+ void beginAuthorizationRejectsProviderWithoutAuthorizeEndpoint() {+ createProvider(Map.of(+ "client_id", "provider-client",+ "token_url", endpoint("/token"),+ "attributes_url", endpoint("/userinfo")), Map.of());++ AwsException exception = assertThrows(AwsException.class, () -> federationService.beginAuthorization(+ pool.getId(), "cognito-client", "https://application.example.test/callback",+ List.of("openid"), "nonce-value", "ExampleOidc"));++ assertEquals("InvalidParameterException", exception.getErrorCode());+ }++ @Test+ void beginAuthorizationRejectsNonOidcProviderBeforeStoringState() {+ createProvider("ExampleGoogle", "Google", Map.of(+ "client_id", "provider-client",+ "authorize_url", "https://provider.example.test/authorize",+ "token_url", endpoint("/token"),+ "attributes_url", endpoint("/userinfo")), Map.of());++ AwsException exception = assertThrows(AwsException.class, () -> federationService.beginAuthorization(+ pool.getId(), "cognito-client", "https://application.example.test/callback",+ List.of("openid"), "nonce-value", "ExampleGoogle"));++ assertEquals("InvalidParameterException", exception.getErrorCode());+ assertNull(tokenRequest.get());+ assertNull(claimsRequest.get());+ }++ @Test+ void beginAuthorizationStoresRelyingPartyStateInTransaction() {+ createDefaultProvider();++ String redirect = federationService.beginAuthorization(+ pool.getId(), "cognito-client", "https://application.example.test/callback",+ List.of("openid"), "nonce-value", "ExampleOidc", "relying-party-state");++ CognitoAuthorizationTransaction transaction = stateStore.consumeTransaction(queryValue(redirect, "state")).orElseThrow();+ assertEquals("relying-party-state", transaction.relyingPartyState());+ }++ @Test+ void completeAuthorizationRejectsNonOidcProvider() {+ createProvider("ExampleGoogle", "Google", Map.of(+ "client_id", "provider-client",+ "authorize_url", "https://provider.example.test/authorize",+ "token_url", endpoint("/token"),+ "attributes_url", endpoint("/userinfo")), Map.of());+ String state = putTransaction("ExampleGoogle");++ AwsException exception = assertThrows(AwsException.class,+ () -> federationService.completeAuthorization(state, "provider-code"));++ assertEquals("InvalidParameterException", exception.getErrorCode());+ assertNull(tokenRequest.get());+ assertNull(claimsRequest.get());+ }++ @Test+ void completeAuthorizationRejectsProviderWithoutTokenEndpoint() {+ createProvider(Map.of(+ "client_id", "provider-client",+ "authorize_url", "https://provider.example.test/authorize",+ "attributes_url", endpoint("/userinfo")), Map.of());+ String state = beginAuthorization();++ AwsException exception = assertThrows(AwsException.class,+ () -> federationService.completeAuthorization(state, "provider-code"));++ assertEquals("InvalidParameterException", exception.getErrorCode());+ }++ @Test+ void completeAuthorizationRejectsProviderWithoutClaimsEndpoint() {+ createProvider(Map.of(+ "client_id", "provider-client",+ "authorize_url", "https://provider.example.test/authorize",+ "token_url", endpoint("/token")), Map.of());+ String state = beginAuthorization();++ AwsException exception = assertThrows(AwsException.class,+ () -> federationService.completeAuthorization(state, "provider-code"));++ assertEquals("InvalidParameterException", exception.getErrorCode());+ }++ @Test+ void completeAuthorizationConvertsInvalidTokenEndpointUriToAwsException() {+ createProvider(Map.of(+ "client_id", "provider-client",+ "authorize_url", "https://provider.example.test/authorize",+ "token_url", "http://[invalid",+ "attributes_url", endpoint("/userinfo")), Map.of());+ String state = beginAuthorization();++ AwsException exception = assertThrows(AwsException.class,+ () -> federationService.completeAuthorization(state, "provider-code"));++ assertEquals("InvalidParameterException", exception.getErrorCode());+ }++ @Test+ void completeAuthorizationRejectsUnsupportedTokenEndpointScheme() {+ createProvider(Map.of(+ "client_id", "provider-client",+ "authorize_url", "https://provider.example.test/authorize",+ "token_url", "ftp://provider.example.test/token",+ "attributes_url", endpoint("/userinfo")), Map.of());+ String state = beginAuthorization();++ AwsException exception = assertThrows(AwsException.class,+ () -> federationService.completeAuthorization(state, "provider-code"));++ assertEquals("InvalidParameterException", exception.getErrorCode());+ }++ @Test+ void completeAuthorizationRejectsUnsupportedClaimsEndpointScheme() {+ createProvider(Map.of(+ "client_id", "provider-client",+ "authorize_url", "https://provider.example.test/authorize",+ "token_url", endpoint("/token"),+ "attributes_url", "ftp://provider.example.test/userinfo"), Map.of());+ String state = beginAuthorization();++ AwsException exception = assertThrows(AwsException.class,+ () -> federationService.completeAuthorization(state, "provider-code"));++ assertEquals("InvalidParameterException", exception.getErrorCode());+ }++ @Test+ void completeAuthorizationRejectsFailedTokenExchange() {+ createDefaultProvider();+ tokenStatus = 400;+ tokenResponse = "{\"error\":\"invalid_grant\"}";+ String state = beginAuthorization();++ AwsException exception = assertThrows(AwsException.class,+ () -> federationService.completeAuthorization(state, "provider-code"));++ assertEquals("NotAuthorizedException", exception.getErrorCode());+ }++ @Test+ void completeAuthorizationRejectsFailedClaimsRequest() {+ createDefaultProvider();+ claimsStatus = 503;+ claimsResponse = "{\"error\":\"temporarily_unavailable\"}";+ String state = beginAuthorization();++ AwsException exception = assertThrows(AwsException.class,+ () -> federationService.completeAuthorization(state, "provider-code"));++ assertEquals("NotAuthorizedException", exception.getErrorCode());+ }++ @Test+ void completeAuthorizationRejectsClaimsWithoutSubject() {+ createDefaultProvider();+ claimsResponse = "{\"email\":\"[email protected]\"}";+ String state = beginAuthorization();++ AwsException exception = assertThrows(AwsException.class,+ () -> federationService.completeAuthorization(state, "provider-code"));++ assertEquals("InvalidParameterException", exception.getErrorCode());+ }++ @Test+ void completeAuthorizationMapsClaimsAndUsesOidcRequests() {+ createDefaultProvider();+ String state = beginAuthorization();++ String authorizationCode = federationService.completeAuthorization(state, "provider code");++ CognitoAuthorizationCode storedCode = stateStore.consumeAuthorizationCode(authorizationCode).orElseThrow();+ CognitoUser user = cognitoService.adminGetUser(pool.getId(), storedCode.userId());+ assertEquals("[email protected]", user.getAttributes().get("email"));+ assertEquals("Alice Provider", user.getAttributes().get("name"));+ assertEquals("ExampleOidc", user.getFederatedProviderName());+ assertEquals("provider-subject", user.getFederatedSubject());++ Request observedTokenRequest = tokenRequest.get();+ assertNotNull(observedTokenRequest);+ assertEquals("POST", observedTokenRequest.method());+ assertEquals("authorization_code", formValue(observedTokenRequest.body(), "grant_type"));+ assertEquals("provider-client", formValue(observedTokenRequest.body(), "client_id"));+ assertEquals("provider-secret", formValue(observedTokenRequest.body(), "client_secret"));+ assertEquals("provider code", formValue(observedTokenRequest.body(), "code"));+ assertEquals(cognitoService.getIdentityProviderCallbackEndpoint(pool.getId()),+ formValue(observedTokenRequest.body(), "redirect_uri"));++ Request observedClaimsRequest = claimsRequest.get();+ assertNotNull(observedClaimsRequest);+ assertEquals("GET", observedClaimsRequest.method());+ assertEquals("Bearer provider-access-token", observedClaimsRequest.authorization());+ }++ @Test+ void completeAuthorizationProvisionsNewFederatedUser() {+ createDefaultProvider();++ CognitoAuthorizationCode storedCode = completeAndConsumeAuthorizationCode();+ CognitoUser user = cognitoService.adminGetUser(pool.getId(), storedCode.userId());++ assertEquals(pool.getId(), user.getUserPoolId());+ assertEquals("CONFIRMED", user.getUserStatus());+ assertTrue(user.isEnabled());+ assertFalse(user.getUsername().isBlank());+ assertNotNull(user.getAttributes().get("sub"));+ }++ @Test+ void completeAuthorizationReconcilesExistingFederatedUserWithoutLosingOtherAttributes() {+ createDefaultProvider();+ CognitoAuthorizationCode firstCode = completeAndConsumeAuthorizationCode();+ CognitoUser firstUser = cognitoService.adminGetUser(pool.getId(), firstCode.userId());+ cognitoService.adminUpdateUserAttributes(pool.getId(), firstUser.getUsername(),+ Map.of("custom:note", "preserve-me", "email", "[email protected]"));+ claimsResponse = "{\"sub\":\"provider-subject\",\"iss\":\"https://issuer.example.test\","+ + "\"email\":\"[email protected]\",\"name\":\"Updated Provider\"}";++ CognitoAuthorizationCode secondCode = completeAndConsumeAuthorizationCode();+ CognitoUser reconciledUser = cognitoService.adminGetUser(pool.getId(), secondCode.userId());++ assertEquals(firstUser.getUsername(), reconciledUser.getUsername());+ assertEquals("[email protected]", reconciledUser.getAttributes().get("email"));+ assertEquals("Updated Provider", reconciledUser.getAttributes().get("name"));+ assertEquals("preserve-me", reconciledUser.getAttributes().get("custom:note"));+ }++ @Test+ void completeAuthorizationStoresAwsCompatibleIdentityFields() throws Exception {+ createDefaultProvider();++ CognitoAuthorizationCode storedCode = completeAndConsumeAuthorizationCode();+ CognitoUser user = cognitoService.adminGetUser(pool.getId(), storedCode.userId());+ JsonNode identity = MAPPER.readTree(user.getAttributes().get("identities")).get(0);+ List<String> fieldNames = new ArrayList<>();+ identity.fieldNames().forEachRemaining(fieldNames::add);++ assertEquals(List.of("userId", "providerName", "providerType", "issuer", "primary", "dateCreated"),+ fieldNames);+ assertEquals("provider-subject", identity.path("userId").asText());+ assertEquals("ExampleOidc", identity.path("providerName").asText());+ assertEquals("OIDC", identity.path("providerType").asText());+ assertEquals("https://issuer.example.test", identity.path("issuer").asText());+ assertFalse(identity.path("primary").asBoolean());+ assertTrue(identity.path("dateCreated").asLong() > 0L);+ }++ private IdentityProvider createDefaultProvider() {+ return createProvider(Map.of(+ "client_id", "provider-client",+ "client_secret", "provider-secret",+ "authorize_url", "https://provider.example.test/authorize",+ "token_url", endpoint("/token"),+ "attributes_url", endpoint("/userinfo")),+ Map.of("email", "email", "name", "name"));+ }++ private IdentityProvider createProvider(Map<String, String> details, Map<String, String> attributeMapping) {+ return createProvider("ExampleOidc", "OIDC", details, attributeMapping);+ }++ private IdentityProvider createProvider(String providerName, String providerType, Map<String, String> details,+ Map<String, String> attributeMapping) {+ return cognitoService.createIdentityProvider(pool.getId(), providerName, providerType, details,+ attributeMapping, List.of());+ }++ private CognitoAuthorizationCode completeAndConsumeAuthorizationCode() {+ String authorizationCode = federationService.completeAuthorization(beginAuthorization(), "provider-code");+ return stateStore.consumeAuthorizationCode(authorizationCode).orElseThrow();+ }++ private String beginAuthorization() {+ String redirect = federationService.beginAuthorization(+ pool.getId(), "cognito-client", "https://application.example.test/callback",+ List.of("openid"), "nonce-value", "ExampleOidc");+ return queryValue(redirect, "state");+ }++ private String putTransaction(String providerName) {+ return stateStore.putTransaction(new CognitoAuthorizationTransaction(+ pool.getId(), "cognito-client", "https://application.example.test/callback",+ List.of("openid"), "nonce-value", providerName, null, CLOCK.instant().plusSeconds(60)));+ }++ private String endpoint(String path) {+ return "http://127.0.0.1:" + oidcServer.getAddress().getPort() + path;+ }++ private void handleToken(HttpExchange exchange) throws IOException {+ tokenRequest.set(new Request(exchange.getRequestMethod(),+ new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8),+ exchange.getRequestHeaders().getFirst("Authorization")));+ writeResponse(exchange, tokenStatus, tokenResponse);+ }++ private void handleClaims(HttpExchange exchange) throws IOException {+ claimsRequest.set(new Request(exchange.getRequestMethod(),+ new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8),+ exchange.getRequestHeaders().getFirst("Authorization")));+ writeResponse(exchange, claimsStatus, claimsResponse);+ }++ private void writeResponse(HttpExchange exchange, int status, String response) throws IOException {+ byte[] body = response.getBytes(StandardCharsets.UTF_8);+ exchange.getResponseHeaders().set("Content-Type", "application/json");+ exchange.sendResponseHeaders(status, body.length);+ exchange.getResponseBody().write(body);+ exchange.close();+ }++ private String queryValue(String uri, String name) {+ String query = URI.create(uri).getRawQuery();+ for (String pair : query.split("&")) {+ String[] parts = pair.split("=", 2);+ if (parts.length == 2 && name.equals(URLDecoder.decode(parts[0], StandardCharsets.UTF_8))) {+ return URLDecoder.decode(parts[1], StandardCharsets.UTF_8);+ }+ }+ throw new AssertionError("Query parameter " + name + " was absent from " + uri);+ }++ private String formValue(String form, String name) {+ return queryValue("https://form.example.test/?" + form, name);+ }++ private record Request(String method, String body, String authorization) {+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederationStateStoreTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederationStateStoreTest.javanew file mode 100644index 0000000000..356afdcecc--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederationStateStoreTest.java@@ -0,0 +1,198 @@+package io.github.hectorvent.floci.services.cognito;++import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationCode;+import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationTransaction;+import org.junit.jupiter.api.Test;++import java.lang.reflect.Field;+import java.time.Clock;+import java.time.Instant;+import java.time.ZoneId;+import java.time.ZoneOffset;+import java.util.List;+import java.util.Optional;+import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.Future;+import java.util.concurrent.TimeUnit;+import java.util.function.BiFunction;+import java.util.stream.IntStream;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++class CognitoFederationStateStoreTest {++ private static final Instant NOW = Instant.parse("2026-09-16T12:00:00Z");++ @Test+ void consumeTransaction_returnsStoredUnexpiredTransaction() {+ CognitoFederationStateStore store = storeAt(NOW);+ CognitoAuthorizationTransaction transaction = transaction(NOW.plusSeconds(60));++ String state = store.putTransaction(transaction);++ assertEquals(Optional.of(transaction), store.consumeTransaction(state));+ }++ @Test+ void consumeTransaction_expiredTransactionReturnsEmpty() {+ CognitoFederationStateStore store = storeAt(NOW);+ String state = store.putTransaction(transaction(NOW));++ assertTrue(store.consumeTransaction(state).isEmpty());+ }++ @Test+ void consumeTransaction_expiringAtMapMutationReturnsEmpty() throws ReflectiveOperationException {+ Instant expiresAt = NOW.plusSeconds(1);+ MutableClock clock = new MutableClock(NOW);+ CognitoFederationStateStore store = new CognitoFederationStateStore(clock);+ replaceStoreMap(store, "transactions", new ExpiringAtMutationMap<>(clock, expiresAt));+ String state = store.putTransaction(transaction(expiresAt));++ assertTrue(store.consumeTransaction(state).isEmpty());+ }++ @Test+ void consumeTransaction_concurrentRequestsReturnTransactionOnlyOnce() throws Exception {+ CognitoFederationStateStore store = storeAt(NOW);+ String state = store.putTransaction(transaction(NOW.plusSeconds(60)));+ int consumers = 16;+ CountDownLatch ready = new CountDownLatch(consumers);+ CountDownLatch start = new CountDownLatch(1);+ ExecutorService executor = Executors.newFixedThreadPool(consumers);++ try {+ List<Future<Optional<CognitoAuthorizationTransaction>>> results = IntStream.range(0, consumers)+ .mapToObj(ignored -> executor.submit(() -> {+ ready.countDown();+ start.await();+ return store.consumeTransaction(state);+ }))+ .toList();+ assertTrue(ready.await(5, TimeUnit.SECONDS));++ start.countDown();++ long successfulConsumptions = 0;+ for (Future<Optional<CognitoAuthorizationTransaction>> result : results) {+ if (result.get(5, TimeUnit.SECONDS).isPresent()) {+ successfulConsumptions++;+ }+ }+ assertEquals(1, successfulConsumptions);+ } finally {+ executor.shutdownNow();+ }+ }++ @Test+ void consumeAuthorizationCode_returnsStoredUnexpiredCode() {+ CognitoFederationStateStore store = storeAt(NOW);+ CognitoAuthorizationCode authorizationCode = authorizationCode(NOW.plusSeconds(60));++ String code = store.putAuthorizationCode(authorizationCode);++ assertEquals(Optional.of(authorizationCode), store.consumeAuthorizationCode(code));+ }++ @Test+ void consumeAuthorizationCode_replayedCodeReturnsEmpty() {+ CognitoFederationStateStore store = storeAt(NOW);+ CognitoAuthorizationCode authorizationCode = authorizationCode(NOW.plusSeconds(60));+ String code = store.putAuthorizationCode(authorizationCode);++ assertEquals(Optional.of(authorizationCode), store.consumeAuthorizationCode(code));+ assertFalse(store.consumeAuthorizationCode(code).isPresent());+ }++ @Test+ void consumeAuthorizationCode_expiringAtMapMutationReturnsEmpty() throws ReflectiveOperationException {+ Instant expiresAt = NOW.plusSeconds(1);+ MutableClock clock = new MutableClock(NOW);+ CognitoFederationStateStore store = new CognitoFederationStateStore(clock);+ replaceStoreMap(store, "authorizationCodes", new ExpiringAtMutationMap<>(clock, expiresAt));+ String code = store.putAuthorizationCode(authorizationCode(expiresAt));++ assertTrue(store.consumeAuthorizationCode(code).isEmpty());+ }++ private CognitoFederationStateStore storeAt(Instant now) {+ return new CognitoFederationStateStore(Clock.fixed(now, ZoneOffset.UTC));+ }++ private CognitoAuthorizationTransaction transaction(Instant expiresAt) {+ return new CognitoAuthorizationTransaction(+ "pool-id", "client-id", "https://example.com/callback", List.of("openid", "email"),+ "nonce", "ExampleOidc", null, expiresAt+ );+ }++ private CognitoAuthorizationCode authorizationCode(Instant expiresAt) {+ return new CognitoAuthorizationCode(+ "pool-id", "client-id", "user-id", "https://example.com/callback", List.of("openid", "email"),+ expiresAt+ );+ }++ private void replaceStoreMap(CognitoFederationStateStore store, String fieldName,+ ConcurrentHashMap<?, ?> replacement) throws ReflectiveOperationException {+ Field field = CognitoFederationStateStore.class.getDeclaredField(fieldName);+ field.setAccessible(true);+ field.set(store, replacement);+ }++ private static final class MutableClock extends Clock {+ private Instant now;++ private MutableClock(Instant now) {+ this.now = now;+ }++ void set(Instant now) {+ this.now = now;+ }++ @Override+ public ZoneOffset getZone() {+ return ZoneOffset.UTC;+ }++ @Override+ public Clock withZone(ZoneId zone) {+ return this;+ }++ @Override+ public Instant instant() {+ return now;+ }+ }++ private static final class ExpiringAtMutationMap<V> extends ConcurrentHashMap<String, V> {+ private final MutableClock clock;+ private final Instant expiresAt;++ private ExpiringAtMutationMap(MutableClock clock, Instant expiresAt) {+ this.clock = clock;+ this.expiresAt = expiresAt;+ }++ @Override+ public boolean remove(Object key, Object value) {+ clock.set(expiresAt);+ return super.remove(key, value);+ }++ @Override+ public V computeIfPresent(String key,+ BiFunction<? super String, ? super V, ? extends V> remappingFunction) {+ clock.set(expiresAt);+ return super.computeIfPresent(key, remappingFunction);+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthControllerTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthControllerTest.javanew file mode 100644index 0000000000..31dcbd5899--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthControllerTest.java@@ -0,0 +1,292 @@+package io.github.hectorvent.floci.services.cognito;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationCode;+import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationTransaction;+import io.github.hectorvent.floci.services.cognito.model.CognitoUser;+import io.github.hectorvent.floci.services.cognito.model.UserPool;+import io.github.hectorvent.floci.services.cognito.model.UserPoolClient;+import jakarta.ws.rs.container.ContainerRequestContext;+import jakarta.ws.rs.core.MultivaluedHashMap;+import jakarta.ws.rs.core.Response;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.nio.charset.StandardCharsets;+import java.time.Clock;+import java.time.Instant;+import java.time.ZoneOffset;+import java.util.Base64;+import java.util.List;+import java.util.Map;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.ArgumentMatchers.any;+import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++class CognitoOAuthControllerTest {++ private static final Clock CLOCK = Clock.fixed(Instant.parse("2026-09-16T00:00:00Z"), ZoneOffset.UTC);+ private static final String POOL_ID = "us-east-1_pool";+ private static final String CLIENT_ID = "cognito-client";+ private static final String CALLBACK_URI = "https://application.example.test/callback";++ private final ObjectMapper objectMapper = new ObjectMapper();+ private final CognitoService cognitoService = mock(CognitoService.class);+ private final CognitoFederationService federationService = mock(CognitoFederationService.class);+ private CognitoFederationStateStore stateStore;+ private CognitoOAuthController controller;+ private UserPoolClient client;++ @BeforeEach+ void setUp() {+ stateStore = new CognitoFederationStateStore(CLOCK);+ controller = new CognitoOAuthController(cognitoService, objectMapper, federationService, stateStore);+ client = client();+ when(cognitoService.findClientById(CLIENT_ID)).thenReturn(client);+ }++ @Test+ void authorizeRedirectsToConfiguredIdentityProvider() {+ when(federationService.beginAuthorization(POOL_ID, CLIENT_ID, CALLBACK_URI, List.of("openid"), "nonce", "ExampleOidc",+ " relying-party-state "))+ .thenReturn("https://provider.example.test/authorize?state=provider-state");++ Response response = controller.authorize(requestContext(null), CLIENT_ID, CALLBACK_URI, "code", "openid", "nonce",+ "ExampleOidc", " relying-party-state ");++ assertEquals(302, response.getStatus());+ assertEquals("https://provider.example.test/authorize?state=provider-state", response.getHeaderString("Location"));+ }++ @Test+ void authorizeReturnsInvalidClientForUnknownClient() {+ when(cognitoService.findClientById("missing-client"))+ .thenThrow(new AwsException("ResourceNotFoundException", "Client not found", 400));++ Response response = controller.authorize(requestContext(null), "missing-client", CALLBACK_URI, "code", "openid", null,+ "ExampleOidc", null);++ assertOAuthError(response, "invalid_client");+ }++ @Test+ void authorizeReturnsInvalidRequestForUnregisteredRedirectUri() {+ Response response = controller.authorize(requestContext(null), CLIENT_ID, "https://other.example.test/callback", "code", "openid",+ null, "ExampleOidc", null);++ assertOAuthError(response, "invalid_request");+ }++ @Test+ void authorizeReturnsUnsupportedResponseTypeForTokenResponse() {+ Response response = controller.authorize(requestContext(null), CLIENT_ID, CALLBACK_URI, "token", "openid", null, "ExampleOidc", null);++ assertOAuthError(response, "unsupported_response_type");+ }++ @Test+ void idpResponseReturnsInvalidRequestForUnknownState() {+ Response response = controller.idpResponse(requestContext(null), "unknown-state", "provider-code", null, null);++ assertOAuthError(response, "invalid_request");+ }++ @Test+ void idpResponseRedirectsProviderErrorToApplication() {+ String state = putTransaction("relying-party-state");++ Response response = controller.idpResponse(requestContext(null), state, null, "access_denied", "The provider refused access");++ assertEquals(302, response.getStatus());+ assertEquals(CALLBACK_URI + "?error=access_denied&error_description=The+provider+refused+access&state=relying-party-state",+ response.getHeaderString("Location"));+ }++ @Test+ void idpResponseRedirectsAuthorizationCodeToApplication() {+ String state = putTransaction("relying-party-state");+ when(federationService.completeAuthorization(any(CognitoAuthorizationTransaction.class), eq("provider-code")))+ .thenReturn("authorization-code");++ Response response = controller.idpResponse(requestContext(null), state, "provider-code", null, null);++ assertEquals(302, response.getStatus());+ assertEquals(CALLBACK_URI + "?code=authorization-code&state=relying-party-state", response.getHeaderString("Location"));+ }++ @Test+ void tokenRedeemsAuthorizationCodeOnce() throws Exception {+ String code = stateStore.putAuthorizationCode(new CognitoAuthorizationCode(+ POOL_ID, CLIENT_ID, "federated-user", CALLBACK_URI, List.of("openid"), CLOCK.instant().plusSeconds(60)));+ when(cognitoService.describeUserPool(POOL_ID)).thenReturn(pool());+ when(cognitoService.adminGetUser(POOL_ID, "federated-user")).thenReturn(user());+ when(cognitoService.generateAuthResult(any(CognitoUser.class), any(UserPool.class), eq(client), eq(null)))+ .thenReturn(Map.of("AccessToken", "access-token", "IdToken", "id-token", "RefreshToken", "refresh-token",+ "ExpiresIn", 3600, "TokenType", "Bearer"));++ MultivaluedHashMap<String, String> form = form("grant_type", "authorization_code", "client_id", CLIENT_ID,+ "code", code, "redirect_uri", CALLBACK_URI);+ Response first = controller.token(null, requestContext(null), form);+ Response replay = controller.token(null, requestContext(null), form);++ assertEquals(200, first.getStatus());+ JsonNode body = (JsonNode) first.getEntity();+ assertEquals("access-token", body.path("access_token").asText());+ assertEquals("id-token", body.path("id_token").asText());+ assertEquals("refresh-token", body.path("refresh_token").asText());+ assertEquals(3600, body.path("expires_in").asInt());+ assertOAuthError(replay, "invalid_grant");+ }++ @Test+ void tokenRejectsAuthorizationCodeForAnotherClient() {+ String code = stateStore.putAuthorizationCode(new CognitoAuthorizationCode(+ POOL_ID, "other-client", "federated-user", CALLBACK_URI, List.of("openid"), CLOCK.instant().plusSeconds(60)));++ Response response = controller.token(null, requestContext(null), form("grant_type", "authorization_code",+ "client_id", CLIENT_ID, "code", code, "redirect_uri", CALLBACK_URI));++ assertOAuthError(response, "invalid_grant");+ }++ @Test+ void tokenDoesNotConsumeAuthorizationCodeWhenRedirectUriIsInvalid() {+ String code = putAuthorizationCode();++ Response invalid = controller.token(null, requestContext(null), form("grant_type", "authorization_code", "client_id", CLIENT_ID,+ "code", code, "redirect_uri", "https://application.example.test/other"));+ Response valid = controller.token(null, requestContext(null), validAuthorizationCodeForm(code));++ assertOAuthError(invalid, "invalid_grant");+ assertEquals(200, valid.getStatus());+ }++ @Test+ void tokenDoesNotConsumeAuthorizationCodeWhenClientDoesNotMatch() {+ UserPoolClient otherClient = client("other-client");+ when(cognitoService.findClientById("other-client")).thenReturn(otherClient);+ String code = putAuthorizationCode();++ Response invalid = controller.token(null, requestContext(null), form("grant_type", "authorization_code", "client_id", "other-client",+ "code", code, "redirect_uri", CALLBACK_URI));+ Response valid = controller.token(null, requestContext(null), validAuthorizationCodeForm(code));++ assertOAuthError(invalid, "invalid_grant");+ assertEquals(200, valid.getStatus());+ }++ @Test+ void tokenDoesNotConsumeAuthorizationCodeWhenClientSecretIsInvalid() {+ client.setClientSecret("correct-secret");+ String code = putAuthorizationCode();++ Response invalid = controller.token(null, requestContext(null), form("grant_type", "authorization_code", "client_id", CLIENT_ID,+ "client_secret", "wrong-secret", "code", code, "redirect_uri", CALLBACK_URI));+ Response valid = controller.token(null, requestContext(null), form("grant_type", "authorization_code", "client_id", CLIENT_ID,+ "client_secret", "correct-secret", "code", code, "redirect_uri", CALLBACK_URI));++ assertOAuthError(invalid, "invalid_client");+ assertEquals(200, valid.getStatus());+ }++ @Test+ void tokenDoesNotConsumeAuthorizationCodeWhenDomainDoesNotMatch() {+ String code = putAuthorizationCode();++ Response invalid = controller.token(null, requestContext("other-pool"), validAuthorizationCodeForm(code));+ Response valid = controller.token(null, requestContext(null), validAuthorizationCodeForm(code));++ assertOAuthError(invalid, "invalid_grant");+ assertEquals(200, valid.getStatus());+ }++ @Test+ void tokenRejectsMismatchedBasicAndFormClientAuthentication() {+ Response response = controller.token(basicAuthorization(CLIENT_ID, "header-secret"), requestContext(null),+ form("grant_type", "authorization_code", "client_id", CLIENT_ID, "client_secret", "form-secret",+ "code", "authorization-code", "redirect_uri", CALLBACK_URI));++ assertOAuthError(response, "invalid_request");+ }++ private String putTransaction(String relyingPartyState) {+ return stateStore.putTransaction(new CognitoAuthorizationTransaction(POOL_ID, CLIENT_ID, CALLBACK_URI,+ List.of("openid"), "nonce", "ExampleOidc", relyingPartyState, CLOCK.instant().plusSeconds(60)));+ }++ private String putAuthorizationCode() {+ String code = stateStore.putAuthorizationCode(new CognitoAuthorizationCode(+ POOL_ID, CLIENT_ID, "federated-user", CALLBACK_URI, List.of("openid"), CLOCK.instant().plusSeconds(60)));+ when(cognitoService.describeUserPool(POOL_ID)).thenReturn(pool());+ when(cognitoService.adminGetUser(POOL_ID, "federated-user")).thenReturn(user());+ when(cognitoService.generateAuthResult(any(CognitoUser.class), any(UserPool.class), eq(client), eq(null)))+ .thenReturn(Map.of("AccessToken", "access-token", "IdToken", "id-token", "RefreshToken", "refresh-token",+ "ExpiresIn", 3600, "TokenType", "Bearer"));+ return code;+ }++ private static MultivaluedHashMap<String, String> validAuthorizationCodeForm(String code) {+ return form("grant_type", "authorization_code", "client_id", CLIENT_ID, "code", code, "redirect_uri", CALLBACK_URI);+ }++ private static UserPoolClient client() {+ return client(CLIENT_ID);+ }++ private static UserPoolClient client(String clientId) {+ UserPoolClient result = new UserPoolClient();+ result.setClientId(clientId);+ result.setUserPoolId(POOL_ID);+ result.setAllowedOAuthFlowsUserPoolClient(true);+ result.setAllowedOAuthFlows(List.of("code"));+ result.setCallbackURLs(List.of(CALLBACK_URI));+ return result;+ }++ private static UserPool pool() {+ UserPool result = new UserPool();+ result.setId(POOL_ID);+ return result;+ }++ private static CognitoUser user() {+ CognitoUser result = new CognitoUser();+ result.setUsername("federated-user");+ result.setUserPoolId(POOL_ID);+ return result;+ }++ private static ContainerRequestContext requestContext(String poolId) {+ ContainerRequestContext result = mock(ContainerRequestContext.class);+ when(result.getProperty(CognitoCustomDomainFilter.POOL_PROPERTY)).thenReturn(poolId);+ return result;+ }++ private static MultivaluedHashMap<String, String> form(String... values) {+ MultivaluedHashMap<String, String> result = new MultivaluedHashMap<>();+ for (int index = 0; index < values.length; index += 2) {+ result.add(values[index], values[index + 1]);+ }+ return result;+ }++ private static String basicAuthorization(String clientId, String clientSecret) {+ String credentials = clientId + ":" + clientSecret;+ return "Basic " + Base64.getEncoder().encodeToString(credentials.getBytes(StandardCharsets.UTF_8));+ }++ private void assertOAuthError(Response response, String error) {+ assertEquals(400, response.getStatus());+ assertNotNull(response.getEntity());+ JsonNode body = (JsonNode) response.getEntity();+ assertEquals(error, body.path("error").asText());+ assertTrue(body.hasNonNull("error_description"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/MockOidcProvider.java b/src/test/java/io/github/hectorvent/floci/services/cognito/MockOidcProvider.javanew file mode 100644index 0000000000..19b9d97320--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/MockOidcProvider.java@@ -0,0 +1,82 @@+package io.github.hectorvent.floci.services.cognito;++import com.sun.net.httpserver.HttpExchange;+import com.sun.net.httpserver.HttpServer;++import java.io.IOException;+import java.io.OutputStream;+import java.net.InetSocketAddress;+import java.net.URLDecoder;+import java.nio.charset.StandardCharsets;+import java.util.LinkedHashMap;+import java.util.Map;+import java.util.concurrent.ConcurrentHashMap;++final class MockOidcProvider implements AutoCloseable {++ private final HttpServer server;+ private final Map<String, String> authorizationParameters = new ConcurrentHashMap<>();+ private volatile String tokenRequestBody;+ private volatile String userInfoAuthorization;++ MockOidcProvider() throws IOException {+ server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ server.createContext("/authorize", exchange -> {+ authorizationParameters.putAll(queryParameters(exchange.getRequestURI().getRawQuery()));+ respond(exchange, 302, "");+ });+ server.createContext("/token", exchange -> {+ tokenRequestBody = new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8);+ respond(exchange, 200, "{\"access_token\":\"provider-access-token\",\"token_type\":\"Bearer\"}");+ });+ server.createContext("/userinfo", exchange -> {+ userInfoAuthorization = exchange.getRequestHeaders().getFirst("Authorization");+ respond(exchange, 200, "{\"sub\":\"provider-subject\",\"email\":\"[email protected]\"}");+ });+ server.start();+ }++ String baseUrl() {+ return "http://127.0.0.1:" + server.getAddress().getPort();+ }++ Map<String, String> authorizationParameters() {+ return new LinkedHashMap<>(authorizationParameters);+ }++ String tokenRequestBody() {+ return tokenRequestBody;+ }++ String userInfoAuthorization() {+ return userInfoAuthorization;+ }++ private Map<String, String> queryParameters(String query) {+ Map<String, String> parameters = new LinkedHashMap<>();+ if (query == null || query.isBlank()) {+ return parameters;+ }+ for (String parameter : query.split("&")) {+ String[] pair = parameter.split("=", 2);+ if (pair.length == 2) {+ parameters.put(URLDecoder.decode(pair[0], StandardCharsets.UTF_8),+ URLDecoder.decode(pair[1], StandardCharsets.UTF_8));+ }+ }+ return parameters;+ }++ private void respond(HttpExchange exchange, int status, String body) throws IOException {+ byte[] bytes = body.getBytes(StandardCharsets.UTF_8);+ exchange.sendResponseHeaders(status, bytes.length);+ try (OutputStream output = exchange.getResponseBody()) {+ output.write(bytes);+ }+ }++ @Override+ public void close() {+ server.stop(0);+ }+}