Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cognito): support Google identity provider federation (#5868)
Vũ Thế Huye38dba5f11fb
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoGoogleFederationTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoGoogleFederationTest.javanew file mode 100644index 0000000000..e1f0980063--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoGoogleFederationTest.java@@ -0,0 +1,80 @@+package com.floci.test;++import org.junit.jupiter.api.DisplayName;+import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.cognitoidentityprovider.CognitoIdentityProviderClient;+import software.amazon.awssdk.services.cognitoidentityprovider.model.IdentityProviderType;++import java.net.URI;+import java.net.URLDecoder;+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.UUID;++import static org.assertj.core.api.Assertions.assertThat;++@DisplayName("Cognito Google federation")+class CognitoGoogleFederationTest {++ @Test+ @DisplayName("AWS SDK provider details round-trip and Google authorization redirect")+ void googleProviderUsesDefaultAuthorizationEndpointWithoutChangingStoredDetails() throws Exception {+ try (CognitoIdentityProviderClient cognito = TestFixtures.cognitoClient()) {+ String poolId = cognito.createUserPool(request -> request.poolName("google-federation-" + UUID.randomUUID()))+ .userPool().id();+ try {+ Map<String, String> details = Map.of("client_id", "google-client", "client_secret", "google-secret",+ "authorize_scopes", "openid email profile");+ cognito.createIdentityProvider(request -> request.userPoolId(poolId).providerName("Google")+ .providerType("Google").providerDetails(details).attributeMapping(Map.of("email", "email")));+ IdentityProviderType provider = cognito.describeIdentityProvider(request -> request+ .userPoolId(poolId).providerName("Google")).identityProvider();+ assertThat(provider.providerTypeAsString()).isEqualTo("Google");+ assertThat(provider.providerDetails()).containsExactlyInAnyOrderEntriesOf(details);+ assertThat(provider.attributeMapping()).containsEntry("email", "email");++ String callback = "https://client.example/callback";+ String clientId = cognito.createUserPoolClient(request -> request.userPoolId(poolId)+ .clientName("google-client").allowedOAuthFlowsUserPoolClient(true)+ .allowedOAuthFlowsWithStrings("code").allowedOAuthScopes("openid", "email", "profile")+ .supportedIdentityProviders("Google").callbackURLs(callback)).userPoolClient().clientId();+ URI authorize = URI.create(TestFixtures.endpoint() + "/cognito-idp/oauth2/authorize?client_id=" + clientId+ + "&response_type=code&scope=openid&identity_provider=Google&redirect_uri="+ + URLEncoder.encode(callback, StandardCharsets.UTF_8));+ HttpClient http = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(10)).build();+ HttpResponse<Void> response = http.send(HttpRequest.newBuilder(authorize).timeout(Duration.ofSeconds(20))+ .GET().build(), HttpResponse.BodyHandlers.discarding());++ assertThat(response.statusCode()).isEqualTo(302);+ URI redirect = URI.create(response.headers().firstValue("Location").orElseThrow());+ assertThat(redirect.getHost()).isEqualTo("accounts.google.com");+ assertThat(redirect.getPath()).isEqualTo("/o/oauth2/v2/auth");+ Map<String, String> parameters = queryParameters(redirect);+ assertThat(parameters).containsEntry("client_id", "google-client")+ .containsEntry("scope", "openid email profile").containsEntry("response_type", "code");+ assertThat(parameters.get("state")).isNotBlank();+ assertThat(redirect.toString()).doesNotContain("google-secret");+ assertThat(cognito.describeIdentityProvider(request -> request.userPoolId(poolId).providerName("Google"))+ .identityProvider().providerDetails()).containsExactlyInAnyOrderEntriesOf(details);+ } finally {+ cognito.deleteUserPool(request -> request.userPoolId(poolId));+ }+ }+ }++ private Map<String, String> queryParameters(URI uri) {+ Map<String, String> parameters = new LinkedHashMap<>();+ for (String pair : uri.getRawQuery().split("&")) {+ String[] entry = pair.split("=", 2);+ parameters.put(URLDecoder.decode(entry[0], StandardCharsets.UTF_8),+ URLDecoder.decode(entry[1], StandardCharsets.UTF_8));+ }+ return parameters;+ }+}diff --git a/docs/services/cognito.md b/docs/services/cognito.mdindex ed6701e8b1..a17c761207 100644--- a/docs/services/cognito.md+++ b/docs/services/cognito.md@@ -118,17 +118,42 @@ pool's Region rather than the `SourceArn` Region, and does not apply `ReplyToEma| UpdateIdentityProvider | Updates a provider's details, attribute mapping or identifiers. || DeleteIdentityProvider | Deletes an identity provider from a user pool. |-Providers can be used for generic OIDC authorization-code sign-in. Floci routes the+Providers can be used for generic OIDC and Google authorization-code sign-in. Floci routes theAWS-shaped `/oauth2/authorize` and `/oauth2/idpresponse` endpoints to the configured localOIDC 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 implement social providers-such as Google, Facebook, Login with Amazon or SignInWithApple. The pool's own users sign in+This flow supports `ProviderType=OIDC` and `ProviderType=Google`. Facebook, Login with Amazon+and SignInWithApple are not implemented. The pool's own users sign inthrough managed login instead (see [Managed login](#managed-login)).-Two deliberate divergences from AWS, both consequences of not calling out to a third-party:+#### Google sign-in++Register a Google provider with `client_id`, `client_secret`, and `authorize_scopes` in+`ProviderDetails`, for example `openid email profile`. Enable `Google` in the app client's+`SupportedIdentityProviders`, then pass `identity_provider=Google` to `/oauth2/authorize`.+Floci uses Google's authorization endpoint at `https://accounts.google.com/o/oauth2/v2/auth`,+token endpoint at `https://oauth2.googleapis.com/token`, and OIDC userinfo endpoint at+`https://openidconnect.googleapis.com/v1/userinfo`.++The redirect URI to register with Google is `<base-url>/cognito-idp/oauth2/idpresponse`+(or `https://<domain>/oauth2/idpresponse` on a custom user pool domain). Google accepts+plain HTTP redirect URIs only for `localhost`.++Google users receive usernames of the form `Google_<sub>`. Repeated sign-ins reconcile the same+user. `AttributeMapping` maps userinfo claims such as `email`, `email_verified`, `name`,+`given_name`, `family_name`, `picture`, and `sub` to user pool attributes. The `identities`+attribute records `providerName` and `providerType` as `Google`.++For an offline test provider, set `floci.services.cognito.google-issuer` or+`FLOCI_SERVICES_COGNITO_GOOGLE_ISSUER` to its issuer URL. The default is+`https://accounts.google.com`. When overridden, Floci resolves the authorization, token, and+userinfo endpoints from `<issuer>/.well-known/openid-configuration` during sign-in. The discovery+document must return the configured `issuer` and all three endpoints. Local test issuers may+use HTTP. Google endpoint overrides in `ProviderDetails` are not used: endpoint selection is+controlled by the server configuration.++Two deliberate divergences from AWS in identity provider registration:- **No create-time validation of `ProviderDetails`.** AWS resolves an OIDC provider's`oidc_issuer` discovery document while handling `CreateIdentityProvider`, and rejects@@ -136,7 +161,8 @@ party:outbound request, so it also does not enforce the per-provider-type required keys.- **No injected provider defaults.** AWS adds keys such as`attributes_url_add_attributes` to an OIDC provider's stored details; Floci returns- only what was supplied.+ only what was supplied, including for Google. Effective Google endpoints are resolved+ during sign-in and are not added to the stored `ProviderDetails`.`AttributeMapping` and `IdpIdentifiers` follow AWS's update semantics: a member therequest omits is left unchanged, and an explicitly empty map or list is what clears it.diff --git a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.javaindex 1fdab8a3b7..196dbc7359 100644--- a/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java+++ b/src/main/java/io/github/hectorvent/floci/config/EmulatorConfig.java@@ -1964,6 +1964,10 @@ public interface EmulatorConfig {@WithDefault("true")boolean enabled();+ /** Google federation issuer; override to use a local OIDC provider for testing. */+ @WithDefault("https://accounts.google.com")+ String googleIssuer();+/*** Rejects an app client whose token validity is outside AWS's limits: access and ID tokens* between 5 minutes and 1 day, refresh tokens between 60 minutes and 3,650 days. Env: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.javaindex ebcc1d9e1f..2b7782577f 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoFederationService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoFederationService.java@@ -57,14 +57,14 @@ public class CognitoFederationService {public String beginAuthorization(String userPoolId, String clientId, String redirectUri,List<String> requestedScopes, List<String> grantedScopes, String nonce,String providerName, String relyingPartyState, String codeChallenge) {- IdentityProvider provider = cognitoService.describeIdentityProvider(userPoolId, providerName);- requireOidcProvider(provider);+ IdentityProvider provider = federationProvider(userPoolId, providerName);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, grantedScopes, nonce, providerName, relyingPartyState, codeChallenge, expiresAt);+ redirectUri, grantedScopes, nonce, providerName, relyingPartyState, codeChallenge,+ provider.getProviderDetails(), expiresAt);String state = stateStore.putTransaction(transaction);Map<String, String> parameters = new LinkedHashMap<>();@@ -86,9 +86,7 @@ public class CognitoFederationService {}String completeAuthorization(CognitoAuthorizationTransaction transaction, String providerCode) {- IdentityProvider provider = cognitoService.describeIdentityProvider(- transaction.userPoolId(), transaction.providerName());- requireOidcProvider(provider);+ IdentityProvider provider = transactionProvider(transaction);String providerCallback = cognitoService.getIdentityProviderCallbackEndpoint(transaction.userPoolId());JsonNode tokenResponse = oidcClient.exchangeCode(provider, providerCode, providerCallback);String accessToken = requiredText(tokenResponse, "access_token", "access token");@@ -104,6 +102,33 @@ public class CognitoFederationService {return stateStore.putAuthorizationCode(authorizationCode);}+ private IdentityProvider transactionProvider(CognitoAuthorizationTransaction transaction) {+ IdentityProvider stored = cognitoService.describeIdentityProvider(transaction.userPoolId(),+ transaction.providerName());+ if ("Google".equals(stored.getProviderType())) {+ if (transaction.providerDetails() != null && !transaction.providerDetails().isEmpty()) {+ Map<String, String> details = new LinkedHashMap<>(stored.getProviderDetails());+ details.putAll(transaction.providerDetails());+ IdentityProvider resolved = new IdentityProvider();+ resolved.setUserPoolId(stored.getUserPoolId());+ resolved.setProviderName(stored.getProviderName());+ resolved.setProviderType(stored.getProviderType());+ resolved.setProviderDetails(details);+ resolved.setAttributeMapping(stored.getAttributeMapping());+ resolved.setIdpIdentifiers(stored.getIdpIdentifiers());+ resolved.setCreationDate(stored.getCreationDate());+ resolved.setLastModifiedDate(stored.getLastModifiedDate());+ return resolved;+ }+ return oidcClient.googleProvider(stored);+ }+ if (!OIDC_PROVIDER_TYPE.equals(stored.getProviderType())) {+ throw new AwsException("InvalidParameterException", "Identity provider " + stored.getProviderName()+ + " must have ProviderType OIDC or Google", 400);+ }+ return stored;+ }+private Map<String, String> mapAttributes(IdentityProvider provider, JsonNode claims) {Map<String, String> attributes = new LinkedHashMap<>();for (Map.Entry<String, String> mapping : provider.getAttributeMapping().entrySet()) {@@ -130,6 +155,9 @@ public class CognitoFederationService {}private String optionalText(JsonNode json, String fieldName) {+ if (json == null) {+ return null;+ }JsonNode value = json.get(fieldName);if (value == null || value.isNull() || !value.isValueNode() || value.asText().isBlank()) {return null;@@ -146,11 +174,16 @@ public class CognitoFederationService {return value;}- private void requireOidcProvider(IdentityProvider provider) {+ private IdentityProvider federationProvider(String userPoolId, String providerName) {+ IdentityProvider provider = cognitoService.describeIdentityProvider(userPoolId, providerName);+ if ("Google".equals(provider.getProviderType())) {+ return oidcClient.googleProvider(provider);+ }if (!OIDC_PROVIDER_TYPE.equals(provider.getProviderType())) {throw new AwsException("InvalidParameterException", "Identity provider " + provider.getProviderName()- + " must have ProviderType OIDC", 400);+ + " must have ProviderType OIDC or Google", 400);}+ return provider;}private void validateAuthorizeEndpoint(String endpoint, String providerName) {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.javaindex ecb7683aa8..da0a1354db 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOidcClient.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOidcClient.java@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.cognito;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.services.cognito.model.IdentityProvider;import jakarta.enterprise.context.ApplicationScoped;@@ -24,18 +25,99 @@ public class CognitoOidcClient {private static final Duration CONNECT_TIMEOUT = Duration.ofSeconds(10);private static final Duration REQUEST_TIMEOUT = Duration.ofSeconds(15);+ private static final String GOOGLE_ISSUER = "https://accounts.google.com";private final HttpClient httpClient;private final ObjectMapper objectMapper;+ private final String googleIssuer;@Inject- public CognitoOidcClient(ObjectMapper objectMapper) {- this(HttpClient.newBuilder().connectTimeout(CONNECT_TIMEOUT).build(), objectMapper);+ public CognitoOidcClient(ObjectMapper objectMapper, EmulatorConfig config) {+ this(defaultHttpClient(), objectMapper, config.services().cognito().googleIssuer());}- CognitoOidcClient(HttpClient httpClient, ObjectMapper objectMapper) {+ CognitoOidcClient(ObjectMapper objectMapper) {+ this(defaultHttpClient(), objectMapper, GOOGLE_ISSUER);+ }++ CognitoOidcClient(ObjectMapper objectMapper, String googleIssuer) {+ this(defaultHttpClient(), objectMapper, googleIssuer);+ }++ CognitoOidcClient(HttpClient httpClient, ObjectMapper objectMapper, String googleIssuer) {this.httpClient = httpClient;this.objectMapper = objectMapper;+ this.googleIssuer = googleIssuer;+ }++ private static HttpClient defaultHttpClient() {+ return HttpClient.newBuilder()+ .connectTimeout(CONNECT_TIMEOUT)+ .followRedirects(HttpClient.Redirect.NORMAL)+ .build();+ }++ IdentityProvider googleProvider(IdentityProvider provider) {+ Map<String, String> details = new LinkedHashMap<>(provider.getProviderDetails());+ details.putAll(googleEndpoints(provider.getProviderName()));+ IdentityProvider resolved = new IdentityProvider();+ resolved.setUserPoolId(provider.getUserPoolId());+ resolved.setProviderName(provider.getProviderName());+ resolved.setProviderType(provider.getProviderType());+ resolved.setProviderDetails(details);+ resolved.setAttributeMapping(provider.getAttributeMapping());+ resolved.setIdpIdentifiers(provider.getIdpIdentifiers());+ resolved.setCreationDate(provider.getCreationDate());+ resolved.setLastModifiedDate(provider.getLastModifiedDate());+ return resolved;+ }++ private Map<String, String> googleEndpoints(String providerName) {+ if (GOOGLE_ISSUER.equals(googleIssuer)) {+ return Map.of("authorize_url", "https://accounts.google.com/o/oauth2/v2/auth",+ "token_url", "https://oauth2.googleapis.com/token",+ "attributes_url", "https://openidconnect.googleapis.com/v1/userinfo",+ "oidc_issuer", GOOGLE_ISSUER);+ }+ validateGoogleIssuer(providerName);+ String discoveryUrl = googleIssuer + (googleIssuer.endsWith("/") ? "" : "/")+ + ".well-known/openid-configuration";+ HttpRequest request = buildRequest(discoveryUrl, providerName, "discovery", builder -> builder+ .header("Accept", "application/json").GET().build());+ JsonNode discovery = send(request, "discovery request");+ if (!googleIssuer.equals(discovery.path("issuer").asText())) {+ throw new AwsException("InvalidParameterException", "Identity provider discovery issuer does not match "+ + "the configured Google issuer", 400);+ }+ Map<String, String> endpoints = new LinkedHashMap<>();+ endpoints.put("authorize_url", discoveryEndpoint(discovery, "authorization_endpoint", providerName));+ endpoints.put("token_url", discoveryEndpoint(discovery, "token_endpoint", providerName));+ endpoints.put("attributes_url", discoveryEndpoint(discovery, "userinfo_endpoint", providerName));+ endpoints.put("oidc_issuer", googleIssuer);+ return endpoints;+ }++ private void validateGoogleIssuer(String providerName) {+ try {+ URI issuer = URI.create(googleIssuer);+ if (issuer.getRawQuery() != null || issuer.getRawFragment() != null || issuer.getUserInfo() != null) {+ throw new IllegalArgumentException("Issuer must not contain query, fragment or user info");+ }+ buildRequest(googleIssuer, providerName, "issuer", builder -> builder.GET().build());+ } catch (IllegalArgumentException exception) {+ throw new AwsException("InvalidParameterException", "Identity provider " + providerName+ + " has an invalid Google issuer configured", 400);+ }+ }++ private String discoveryEndpoint(JsonNode discovery, String name, String providerName) {+ JsonNode endpoint = discovery.get(name);+ if (endpoint == null || !endpoint.isTextual() || endpoint.asText().isBlank()) {+ throw new AwsException("InvalidParameterException", "Identity provider discovery is missing " + name, 400);+ }+ String value = endpoint.asText();+ buildRequest(value, providerName, name, builder -> builder.GET().build());+ return value;}public JsonNode exchangeCode(IdentityProvider provider, String code, String redirectUri) {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 96d8e3dcd8..fdafb21af7 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@@ -2860,42 +2860,71 @@ public class CognitoService implements ResourceProvider {describeUserPool(userPoolId);String prefix = userPoolId + "::";return userStore.scan(key -> key.startsWith(prefix)).stream()- .filter(user -> providerName.equals(user.getFederatedProviderName())- && subject.equals(user.getFederatedSubject()))+ .filter(user -> (providerName.equals(user.getFederatedProviderName())+ && subject.equals(user.getFederatedSubject()))+ || hasLinkedIdentity(user, providerName, subject)).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());+ while (true) {+ String targetUsername = findFederatedUser(userPoolId, provider.getProviderName(), subject)+ .map(CognitoUser::getUsername)+ .orElseGet(() -> provider.getProviderName() + "_"+ + ("Google".equals(provider.getProviderType()) ? subject : UUID.randomUUID().toString()));+ Object lock = userLock(userPoolId, targetUsername);+ synchronized (lock) {+ synchronized (identityLinkLock) {+ Optional<CognitoUser> existing = findFederatedUser(userPoolId, provider.getProviderName(), subject);+ if (existing.isPresent() && !existing.get().getUsername().equals(targetUsername)) {+ // Another thread linked this identity to a different destination user concurrently.+ // Release locks and retry with the new destination user's lock stripe.+ continue;+ }+ CognitoUser user;+ if (existing.isPresent()) {+ user = existing.get();+ if (!user.isEnabled()) {+ throw new AwsException("NotAuthorizedException", "User is disabled.", 400);+ }+ } else {+ if (userStore.get(userKey(userPoolId, targetUsername)).isPresent()) {+ throw new AwsException("UsernameExistsException", "User already exists", 400);+ }+ user = new CognitoUser();+ user.setUsername(targetUsername);+ 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;+ }}- 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();+ long dateCreated = System.currentTimeMillis();for (JsonNode identity : identities) {- if (!provider.getProviderName().equals(identity.path("providerName").asText())- || !subject.equals(identity.path("userId").asText())) {+ if (provider.getProviderName().equals(identity.path("providerName").asText())+ && subject.equals(identity.path("userId").asText())) {+ if (identity.has("dateCreated") && identity.path("dateCreated").isIntegralNumber()) {+ dateCreated = identity.path("dateCreated").asLong();+ }+ } else {reconciled.add(identity);}}@@ -2905,7 +2934,7 @@ public class CognitoService implements ResourceProvider {.put("providerType", provider.getProviderType()).put("issuer", issuer).put("primary", false)- .put("dateCreated", System.currentTimeMillis());+ .put("dateCreated", dateCreated);user.getAttributes().put(IDENTITIES_ATTRIBUTE, reconciled.toString());}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.javaindex 5f8e11f505..d67a5d903e 100644--- 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.java@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.cognito.model;import java.time.Instant;import java.util.List;+import java.util.Map;public record CognitoAuthorizationTransaction(String userPoolId,@@ -12,9 +13,25 @@ public record CognitoAuthorizationTransaction(String providerName,String relyingPartyState,String codeChallenge,+ Map<String, String> providerDetails,Instant expiresAt) {public CognitoAuthorizationTransaction {scopes = List.copyOf(scopes);+ providerDetails = providerDetails != null ? Map.copyOf(providerDetails) : Map.of();+ }++ public CognitoAuthorizationTransaction(+ String userPoolId,+ String clientId,+ String redirectUri,+ List<String> scopes,+ String nonce,+ String providerName,+ String relyingPartyState,+ String codeChallenge,+ Instant expiresAt) {+ this(userPoolId, clientId, redirectUri, scopes, nonce, providerName, relyingPartyState, codeChallenge,+ Map.of(), expiresAt);}}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex eca27f317f..93256dd9d7 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -571,6 +571,7 @@ floci:enabled: truecognito:enabled: true+ google-issuer: https://accounts.google.comenforce-token-validity-limits: truestepfunctions:enabled: truediff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederatedSignInIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederatedSignInIntegrationTest.javaindex b8ce2cd3d4..6543b6ef42 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederatedSignInIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederatedSignInIntegrationTest.java@@ -3,11 +3,14 @@ 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.common.QuarkusTestResource;+import io.quarkus.test.common.QuarkusTestResourceLifecycleManager;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.io.IOException;import java.net.URI;import java.net.URLDecoder;import java.net.http.HttpClient;@@ -18,6 +21,7 @@ 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.cognitoAction;import static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoJson;import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.equalTo;@@ -26,16 +30,138 @@ import static org.junit.jupiter.api.Assertions.assertFalse;import static org.junit.jupiter.api.Assertions.assertNotNull;@QuarkusTest+@QuarkusTestResource(value = CognitoFederatedSignInIntegrationTest.GoogleProviderResource.class,+ restrictToAnnotatedClass = true)class CognitoFederatedSignInIntegrationTest {private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();private static final String DOMAIN = "federated-" + System.nanoTime() + ".teos.localhost.floci.io";+ private MockOidcProvider googleProvider;++ public static class GoogleProviderResource implements QuarkusTestResourceLifecycleManager {+ private MockOidcProvider provider;++ @Override+ public Map<String, String> start() {+ try {+ provider = new MockOidcProvider();+ return Map.of("floci.services.cognito.google-issuer", provider.baseUrl());+ } catch (IOException exception) {+ throw new IllegalStateException("Cannot start the Google test provider", exception);+ }+ }++ @Override+ public void inject(TestInjector testInjector) {+ testInjector.injectIntoFields(provider, new TestInjector.MatchesType(MockOidcProvider.class));+ }++ @Override+ public void stop() {+ if (provider != null) {+ provider.close();+ }+ }+ }@BeforeAllstatic void configureRestAssured() {RestAssuredJsonUtils.configureAwsContentTypes();}+ @Test+ void googleProviderSignsInWithConfiguredIssuerAndPreservesAwsProviderDetails() throws Exception {+ String domain = "google-" + System.nanoTime() + ".teos.localhost.floci.io";+ String poolId = cognitoJson("CreateUserPool", "{\"PoolName\":\"GoogleFederationPool\"}")+ .path("UserPool").path("Id").asText();+ String clientId = cognitoJson("CreateUserPoolClient", """+ {"UserPoolId":"%s","ClientName":"google-client","AllowedOAuthFlowsUserPoolClient":true,+ "AllowedOAuthFlows":["code"],"AllowedOAuthScopes":["openid","email","profile"],+ "SupportedIdentityProviders":["Google"],"CallbackURLs":["https://client.example/callback"]}+ """.formatted(poolId)).path("UserPoolClient").path("ClientId").asText();+ cognitoJson("CreateIdentityProvider", """+ {"UserPoolId":"%s","ProviderName":"Google","ProviderType":"Google",+ "ProviderDetails":{"client_id":"google-client","client_secret":"google-secret",+ "authorize_scopes":"openid email profile"},+ "AttributeMapping":{"email":"email","email_verified":"email_verified","name":"name",+ "given_name":"given_name","family_name":"family_name","picture":"picture"}}+ """.formatted(poolId));+ assertEquals(0, googleProvider.discoveryRequests());+ cognitoJson("CreateUserPoolDomain", customDomain(domain, poolId, requestCertificate(domain)));++ String firstUsername = null;+ for (int attempt = 0; attempt < 2; attempt++) {+ String location = 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", "Google").queryParam("state", "client-state")+ .when().get("/oauth2/authorize").then().statusCode(302).extract().header("Location");+ assertEquals(googleProvider.baseUrl() + "/authorize", location.substring(0, location.indexOf('?')));+ assertEquals("openid email profile", queryParameter(location, "scope"));+ assertEquals("google-client", queryParameter(location, "client_id"));++ String callback = given().redirects().follow(false).header("Host", domain)+ .queryParam("state", queryParameter(location, "state")).queryParam("code", "provider-code")+ .when().get("/oauth2/idpresponse").then().statusCode(302).extract().header("Location");+ assertEquals("client-state", queryParameter(callback, "state"));+ given().header("Host", domain).formParam("grant_type", "authorization_code")+ .formParam("client_id", clientId).formParam("code", queryParameter(callback, "code"))+ .formParam("redirect_uri", "https://client.example/callback")+ .when().post("/oauth2/token").then().statusCode(200).body("token_type", equalTo("Bearer"));++ JsonNode users = cognitoJson("ListUsers", "{\"UserPoolId\":\"%s\"}".formatted(poolId)).path("Users");+ assertEquals(1, users.size());+ JsonNode user = users.get(0);+ String username = user.path("Username").asText();+ assertEquals("Google_provider-subject", username);+ if (firstUsername != null) {+ assertEquals(firstUsername, username);+ }+ firstUsername = username;+ JsonNode attributes = user.path("Attributes");+ assertEquals("[email protected]", attributeValue(attributes, "email"));+ assertEquals("true", attributeValue(attributes, "email_verified"));+ assertEquals("Federated User", attributeValue(attributes, "name"));+ assertEquals("Federated", attributeValue(attributes, "given_name"));+ assertEquals("User", attributeValue(attributes, "family_name"));+ assertEquals("https://picture.example/user", attributeValue(attributes, "picture"));+ JsonNode identity = OBJECT_MAPPER.readTree(attributeValue(attributes, "identities")).get(0);+ assertEquals("Google", identity.path("providerName").asText());+ assertEquals("Google", identity.path("providerType").asText());+ assertEquals("provider-subject", identity.path("userId").asText());+ }++ cognitoAction("AdminDisableUser", """+ {"UserPoolId":"%s","Username":"%s"}+ """.formatted(poolId, firstUsername)).then().statusCode(200);++ String disabledAuthorize = 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", "Google").queryParam("state", "client-state")+ .when().get("/oauth2/authorize").then().statusCode(302).extract().header("Location");++ given().redirects().follow(false).header("Host", domain)+ .queryParam("state", queryParameter(disabledAuthorize, "state")).queryParam("code", "provider-code")+ .when().get("/oauth2/idpresponse").then().statusCode(400)+ .body("error", equalTo("invalid_request"))+ .body("error_description", equalTo("User is disabled."));++ JsonNode disabledUser = cognitoJson("AdminGetUser", """+ {"UserPoolId":"%s","Username":"%s"}+ """.formatted(poolId, firstUsername));+ assertFalse(disabledUser.path("Enabled").asBoolean());++ assertEquals("google-secret", formValue(googleProvider.tokenRequestBody(), "client_secret"));+ assertEquals("Bearer provider-access-token", googleProvider.userInfoAuthorization());+ JsonNode details = cognitoJson("DescribeIdentityProvider", """+ {"UserPoolId":"%s","ProviderName":"Google"}+ """.formatted(poolId)).path("IdentityProvider").path("ProviderDetails");+ assertEquals(3, details.size());+ assertFalse(details.has("authorize_url"));+ assertFalse(details.has("oidc_issuer"));+ }+@Testvoid oidcProviderReceivesAuthorizationRequestAndDiscoveryAdvertisesCodeFlow() throws Exception {try (MockOidcProvider provider = new MockOidcProvider()) {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.javaindex 8ba0425c49..20a5cab395 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederationServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoFederationServiceTest.java@@ -26,6 +26,7 @@ import java.io.IOException;import java.net.InetSocketAddress;import java.net.URI;import java.net.URLDecoder;+import java.net.http.HttpClient;import java.nio.charset.StandardCharsets;import java.time.Clock;import java.time.Instant;@@ -34,6 +35,12 @@ import java.util.ArrayList;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;+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.concurrent.atomic.AtomicInteger;import java.util.concurrent.atomic.AtomicReference;import static org.junit.jupiter.api.Assertions.assertEquals;@@ -116,7 +123,7 @@ class CognitoFederationServiceTest {@Testvoid beginAuthorizationRejectsNonOidcProviderBeforeStoringState() {- createProvider("ExampleGoogle", "Google", Map.of(+ createProvider("ExampleFacebook", "Facebook", Map.of("client_id", "provider-client","authorize_url", "https://provider.example.test/authorize","token_url", endpoint("/token"),@@ -124,7 +131,7 @@ class CognitoFederationServiceTest {AwsException exception = assertThrows(AwsException.class, () -> federationService.beginAuthorization(pool.getId(), "cognito-client", "https://application.example.test/callback",- List.of("openid"), "nonce-value", "ExampleGoogle"));+ List.of("openid"), "nonce-value", "ExampleFacebook"));assertEquals("InvalidParameterException", exception.getErrorCode());assertNull(tokenRequest.get());@@ -161,12 +168,12 @@ class CognitoFederationServiceTest {@Testvoid completeAuthorizationRejectsNonOidcProvider() {- createProvider("ExampleGoogle", "Google", Map.of(+ createProvider("ExampleFacebook", "Facebook", 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");+ String state = putTransaction("ExampleFacebook");AwsException exception = assertThrows(AwsException.class,() -> federationService.completeAuthorization(state, "provider-code"));@@ -350,6 +357,330 @@ class CognitoFederationServiceTest {assertEquals("preserve-me", reconciledUser.getAttributes().get("custom:note"));}+ @Test+ void googleAuthorizationUsesDefaultsWithoutChangingStoredDetails() {+ Map<String, String> details = Map.of("client_id", "google-client", "client_secret", "google-secret",+ "authorize_scopes", "openid email profile");+ createProvider("Google", "Google", details, Map.of("email", "email"));++ String redirect = federationService.beginAuthorization(pool.getId(), "cognito-client",+ "https://application.example.test/callback", List.of("openid"), "google-nonce", "Google");++ assertTrue(redirect.startsWith("https://accounts.google.com/o/oauth2/v2/auth?"), redirect);+ assertEquals("google-client", queryValue(redirect, "client_id"));+ assertEquals("openid email profile", queryValue(redirect, "scope"));+ assertEquals("google-nonce", queryValue(redirect, "nonce"));+ assertFalse(redirect.contains("google-secret"));+ assertEquals(details, cognitoService.describeIdentityProvider(pool.getId(), "Google").getProviderDetails());+ }++ @Test+ void googleEndpointOverridesComeOnlyFromServerConfiguration() {+ Map<String, String> supplied = Map.of("client_id", "google-client",+ "authorize_url", "https://untrusted.example/authorize", "token_url", "https://untrusted.example/token",+ "attributes_url", "https://untrusted.example/userinfo", "oidc_issuer", "https://untrusted.example");+ IdentityProvider provider = createProvider("Google", "Google", supplied, Map.of());++ IdentityProvider effective = new CognitoOidcClient(MAPPER).googleProvider(provider);++ assertEquals("https://accounts.google.com/o/oauth2/v2/auth", effective.getProviderDetails().get("authorize_url"));+ assertEquals("https://oauth2.googleapis.com/token", effective.getProviderDetails().get("token_url"));+ assertEquals("https://openidconnect.googleapis.com/v1/userinfo", effective.getProviderDetails().get("attributes_url"));+ assertEquals("https://accounts.google.com", effective.getProviderDetails().get("oidc_issuer"));+ assertEquals(supplied, provider.getProviderDetails());+ }++ @Test+ void googleSignInDiscoversConfiguredIssuerAndMapsUserInfoClaims() throws Exception {+ CognitoFederationService googleFederation = googleFederation(discovery(), 200);+ Map<String, String> details = Map.of("client_id", "google-client", "client_secret", "google-secret",+ "authorize_scopes", "openid email profile");+ createProvider("Google", "Google", details, Map.of("email", "email", "email_verified", "email_verified",+ "name", "name", "given_name", "given_name", "family_name", "family_name", "picture", "picture"));+ claimsResponse = """+ {"sub":"google-subject","email":"[email protected]","email_verified":true,+ "name":"Google User","given_name":"Google","family_name":"User","picture":"https://picture.example/user"}+ """;++ String redirect = googleFederation.beginAuthorization(pool.getId(), "cognito-client",+ "https://application.example.test/callback", List.of("openid"), "nonce-value", "Google");+ assertTrue(redirect.startsWith(endpoint("/authorize") + "?"), redirect);+ assertEquals("openid email profile", queryValue(redirect, "scope"));+ String code = googleFederation.completeAuthorization(queryValue(redirect, "state"), "provider-code");+ CognitoAuthorizationCode storedCode = stateStore.consumeAuthorizationCode(code).orElseThrow();+ CognitoUser user = cognitoService.adminGetUser(pool.getId(), storedCode.userId());++ assertEquals("Google_google-subject", user.getUsername());+ assertEquals("[email protected]", user.getAttributes().get("email"));+ assertEquals("true", user.getAttributes().get("email_verified"));+ assertEquals("Google User", user.getAttributes().get("name"));+ assertEquals("Google", user.getAttributes().get("given_name"));+ assertEquals("User", user.getAttributes().get("family_name"));+ assertEquals("https://picture.example/user", user.getAttributes().get("picture"));+ assertEquals("google-client", formValue(tokenRequest.get().body(), "client_id"));+ assertEquals("google-secret", formValue(tokenRequest.get().body(), "client_secret"));+ assertEquals("Bearer provider-access-token", claimsRequest.get().authorization());+ assertEquals(details, cognitoService.describeIdentityProvider(pool.getId(), "Google").getProviderDetails());+ }++ @Test+ void googleSignInRejectsUntrustedOrIncompleteDiscoveryBeforeExchangingCredentials() throws Exception {+ createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ for (String body : List.of(discovery().replace(endpoint(""), "https://other-issuer.example"),+ "{\"issuer\":\"" + endpoint("") + "\"}",+ discovery().replace(endpoint("/token"), "file:///tmp/token"), "[]")) {+ CognitoFederationService googleFederation = googleFederation(body, 200);+ assertThrows(AwsException.class, () -> googleFederation.beginAuthorization(pool.getId(), "cognito-client",+ "https://application.example.test/callback", List.of("openid"), null, "Google"));+ oidcServer.removeContext("/.well-known/openid-configuration");+ }+ assertNull(tokenRequest.get());+ assertNull(claimsRequest.get());+ }++ @Test+ void googleSignInReportsDiscoveryFailureWithoutLeakingTheResponse() throws Exception {+ createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ CognitoFederationService googleFederation = googleFederation("sensitive response", 503);++ AwsException failure = assertThrows(AwsException.class, () -> googleFederation.beginAuthorization(+ pool.getId(), "cognito-client", "https://application.example.test/callback", List.of("openid"), null, "Google"));++ assertEquals("NotAuthorizedException", failure.getErrorCode());+ assertFalse(failure.getMessage().contains("sensitive response"));+ assertNull(tokenRequest.get());+ assertNull(claimsRequest.get());+ }++ @Test+ void googleProvisioningUsesSubjectAndReconcilesTheSameUser() throws Exception {+ IdentityProvider provider = createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ CognitoUser first = cognitoService.provisionFederatedUser(pool.getId(), provider, "google-subject", null,+ Map.of("email", "[email protected]"));+ CognitoUser second = cognitoService.provisionFederatedUser(pool.getId(), provider, "google-subject", null,+ Map.of("email", "[email protected]"));++ assertEquals("Google_google-subject", first.getUsername());+ assertEquals(first.getUsername(), second.getUsername());+ assertEquals("[email protected]", second.getAttributes().get("email"));+ JsonNode identity = MAPPER.readTree(second.getAttributes().get("identities")).get(0);+ assertEquals("Google", identity.path("providerName").asText());+ assertEquals("Google", identity.path("providerType").asText());+ assertEquals("google-subject", identity.path("userId").asText());+ }++ @Test+ void googleProvisioningDoesNotReplaceAnUnlinkedUserWithTheSameUsername() {+ IdentityProvider provider = createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ cognitoService.adminCreateUser(pool.getId(), "Google_google-subject", Map.of("email", "[email protected]"),+ "Password123!");++ AwsException failure = assertThrows(AwsException.class, () -> cognitoService.provisionFederatedUser(+ pool.getId(), provider, "google-subject", null, Map.of("email", "[email protected]")));++ assertEquals("UsernameExistsException", failure.getErrorCode());+ assertEquals("[email protected]", cognitoService.adminGetUser(pool.getId(), "Google_google-subject")+ .getAttributes().get("email"));+ }++ @Test+ void googleSignInFollowsDiscoveryRedirect() throws Exception {+ createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ oidcServer.createContext("/.well-known/openid-configuration", exchange -> {+ exchange.getResponseHeaders().set("Location", endpoint("/redirected-discovery"));+ exchange.sendResponseHeaders(302, -1);+ exchange.close();+ });+ oidcServer.createContext("/redirected-discovery", exchange -> writeResponse(exchange, 200, discovery()));+ CognitoFederationService googleFederation = new CognitoFederationService(cognitoService, stateStore,+ new CognitoOidcClient(MAPPER, endpoint("")), CLOCK);++ String redirect = googleFederation.beginAuthorization(pool.getId(), "cognito-client",+ "https://application.example.test/callback", List.of("openid"), null, "Google");++ assertTrue(redirect.startsWith(endpoint("/authorize") + "?"), redirect);+ }++ @Test+ void googleCallbackSucceedsWhenDiscoveryOutageOccursAfterAuthorization() throws Exception {+ createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ CognitoFederationService googleFederation = googleFederation(discovery(), 200);++ String redirect = googleFederation.beginAuthorization(pool.getId(), "cognito-client",+ "https://application.example.test/callback", List.of("openid"), "nonce-value", "Google");+ assertTrue(redirect.startsWith(endpoint("/authorize") + "?"), redirect);++ // Simulate a discovery outage after the authorization transaction has begun.+ oidcServer.removeContext("/.well-known/openid-configuration");++ String code = googleFederation.completeAuthorization(queryValue(redirect, "state"), "provider-code");+ CognitoAuthorizationCode storedCode = stateStore.consumeAuthorizationCode(code).orElseThrow();+ CognitoUser user = cognitoService.adminGetUser(pool.getId(), storedCode.userId());++ assertEquals("Google_provider-subject", user.getUsername());+ assertNotNull(tokenRequest.get());+ assertNotNull(claimsRequest.get());+ }++ @Test+ void googleProvisioningReconcilesUserLinkedViaAdminLinkProviderForUser() throws Exception {+ IdentityProvider provider = createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ cognitoService.adminCreateUser(pool.getId(), "alice", Map.of("email", "[email protected]"), "Password123!");+ cognitoService.adminLinkProviderForUser(pool.getId(), "alice", "Google", "google-subject");++ CognitoUser reconciled = cognitoService.provisionFederatedUser(pool.getId(), provider, "google-subject", null,+ Map.of("email", "[email protected]"));++ assertEquals("alice", reconciled.getUsername());+ assertEquals("[email protected]", reconciled.getAttributes().get("email"));+ JsonNode identity = MAPPER.readTree(reconciled.getAttributes().get("identities")).get(0);+ assertEquals("Google", identity.path("providerName").asText());+ assertEquals("google-subject", identity.path("userId").asText());++ // Verify no duplicate user was created.+ assertTrue(cognitoService.listUsers(pool.getId(), null).stream()+ .noneMatch(u -> "Google_google-subject".equals(u.getUsername())));+ }++ @Test+ void googleProvisioningReconcilesUserLinkedWithGeneratedUsername() throws Exception {+ IdentityProvider provider = createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ cognitoService.adminCreateUser(pool.getId(), "Google_google-subject",+ Map.of("email", "[email protected]"), "Password123!");+ cognitoService.adminLinkProviderForUser(pool.getId(), "Google_google-subject", "Google", "google-subject");++ CognitoUser reconciled = cognitoService.provisionFederatedUser(pool.getId(), provider, "google-subject", null,+ Map.of("email", "[email protected]"));++ assertEquals("Google_google-subject", reconciled.getUsername());+ assertEquals("[email protected]", reconciled.getAttributes().get("email"));+ assertEquals("[email protected]", cognitoService.adminGetUser(pool.getId(), "Google_google-subject")+ .getAttributes().get("email"));+ }++ @Test+ void disabledLinkedUserCannotAuthenticateViaFederation() throws Exception {+ IdentityProvider provider = createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ cognitoService.adminCreateUser(pool.getId(), "alice", Map.of("email", "[email protected]"), "Password123!");+ cognitoService.adminLinkProviderForUser(pool.getId(), "alice", "Google", "google-subject");+ cognitoService.adminDisableUser(pool.getId(), "alice");++ AwsException ex = assertThrows(AwsException.class, () ->+ cognitoService.provisionFederatedUser(pool.getId(), provider, "google-subject", null,+ Map.of("email", "[email protected]")));++ assertEquals("NotAuthorizedException", ex.getErrorCode());+ assertEquals("User is disabled.", ex.getMessage());+ assertFalse(cognitoService.adminGetUser(pool.getId(), "alice").isEnabled());+ }++ @Test+ void disabledFederatedUserCannotReauthenticate() throws Exception {+ IdentityProvider provider = createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ CognitoUser provisioned = cognitoService.provisionFederatedUser(pool.getId(), provider, "google-subject", null,+ Map.of("email", "[email protected]"));+ assertEquals("Google_google-subject", provisioned.getUsername());+ assertTrue(provisioned.isEnabled());++ cognitoService.adminDisableUser(pool.getId(), provisioned.getUsername());+ assertFalse(cognitoService.adminGetUser(pool.getId(), provisioned.getUsername()).isEnabled());++ AwsException ex = assertThrows(AwsException.class, () ->+ cognitoService.provisionFederatedUser(pool.getId(), provider, "google-subject", null,+ Map.of("email", "[email protected]")));++ assertEquals("NotAuthorizedException", ex.getErrorCode());+ assertEquals("User is disabled.", ex.getMessage());+ assertFalse(cognitoService.adminGetUser(pool.getId(), provisioned.getUsername()).isEnabled());+ }++ @Test+ void completeAuthorizationFailsWhenLinkedUserIsDisabled() throws Exception {+ createProvider("Google", "Google", Map.of("client_id", "google-client", "client_secret", "google-secret"),+ Map.of("email", "email"));+ cognitoService.adminCreateUser(pool.getId(), "alice", Map.of("email", "[email protected]"), "Password123!");+ cognitoService.adminLinkProviderForUser(pool.getId(), "alice", "Google", "provider-subject");+ cognitoService.adminDisableUser(pool.getId(), "alice");++ CognitoFederationService service = googleFederation(discovery(), 200);+ String state = service.beginAuthorization(pool.getId(), "cognito-client",+ "https://client.example/callback", List.of("openid", "email"), List.of("openid", "email"),+ "nonce-123", "Google", "rp-state", null);++ tokenResponse = """+ {"access_token":"provider-access-token","token_type":"Bearer"}+ """;+ claimsResponse = """+ {"sub":"provider-subject","email":"[email protected]"}+ """;++ AwsException ex = assertThrows(AwsException.class, () ->+ service.completeAuthorization(queryValue(state, "state"), "provider-code"));+ assertEquals("NotAuthorizedException", ex.getErrorCode());+ assertEquals("User is disabled.", ex.getMessage());+ assertFalse(cognitoService.adminGetUser(pool.getId(), "alice").isEnabled());+ }++ @Test+ void googleProvisioningRacesSafelyWithAdminCreateUser() throws Exception {+ IdentityProvider provider = createProvider("Google", "Google", Map.of("client_id", "google-client"), Map.of());+ String targetUsername = "Google_concurrent-subject";++ for (int i = 0; i < 10; i++) {+ UserPool racePool = cognitoService.createUserPool(Map.of("PoolName", "race-pool-" + i), "us-east-1");+ cognitoService.createIdentityProvider(racePool.getId(), provider.getProviderName(),+ provider.getProviderType(), provider.getProviderDetails(), provider.getAttributeMapping(), List.of());++ ExecutorService executor = Executors.newFixedThreadPool(2);+ CountDownLatch start = new CountDownLatch(1);+ AtomicInteger successes = new AtomicInteger();+ AtomicInteger usernameExistsExceptions = new AtomicInteger();++ Future<?> federatedTask = executor.submit(() -> {+ try {+ start.await();+ cognitoService.provisionFederatedUser(racePool.getId(), provider, "concurrent-subject", null,+ Map.of("email", "[email protected]"));+ successes.incrementAndGet();+ } catch (AwsException e) {+ if ("UsernameExistsException".equals(e.getErrorCode())) {+ usernameExistsExceptions.incrementAndGet();+ }+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ }+ });++ Future<?> adminTask = executor.submit(() -> {+ try {+ start.await();+ cognitoService.adminCreateUser(racePool.getId(), targetUsername,+ Map.of("email", "[email protected]"), "Password123!");+ successes.incrementAndGet();+ } catch (AwsException e) {+ if ("UsernameExistsException".equals(e.getErrorCode())) {+ usernameExistsExceptions.incrementAndGet();+ }+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ }+ });++ start.countDown();+ federatedTask.get(5, TimeUnit.SECONDS);+ adminTask.get(5, TimeUnit.SECONDS);+ executor.shutdown();++ assertEquals(1, successes.get(), "Exactly one creation should succeed");+ assertEquals(1, usernameExistsExceptions.get(), "Exactly one operation should receive UsernameExistsException");++ CognitoUser user = cognitoService.adminGetUser(racePool.getId(), targetUsername);+ assertNotNull(user);+ String email = user.getAttributes().get("email");+ assertTrue("[email protected]".equals(email) || "[email protected]".equals(email));+ }+ }+@Testvoid completeAuthorizationStoresAwsCompatibleIdentityFields() throws Exception {createDefaultProvider();@@ -412,6 +743,18 @@ class CognitoFederationServiceTest {return "http://127.0.0.1:" + oidcServer.getAddress().getPort() + path;}+ private String discovery() {+ return """+ {"issuer":"%s","authorization_endpoint":"%s","token_endpoint":"%s","userinfo_endpoint":"%s"}+ """.formatted(endpoint(""), endpoint("/authorize"), endpoint("/token"), endpoint("/userinfo"));+ }++ private CognitoFederationService googleFederation(String discovery, int status) {+ oidcServer.createContext("/.well-known/openid-configuration", exchange -> writeResponse(exchange, status, discovery));+ return new CognitoFederationService(cognitoService, stateStore,+ new CognitoOidcClient(MAPPER, endpoint("")), CLOCK);+ }+private void handleToken(HttpExchange exchange) throws IOException {tokenRequest.set(new Request(exchange.getRequestMethod(),new String(exchange.getRequestBody().readAllBytes(), StandardCharsets.UTF_8),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.javaindex 19b9d97320..b6b4554d97 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/MockOidcProvider.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/MockOidcProvider.java@@ -11,16 +11,25 @@ import java.nio.charset.StandardCharsets;import java.util.LinkedHashMap;import java.util.Map;import java.util.concurrent.ConcurrentHashMap;+import java.util.concurrent.atomic.AtomicInteger;final class MockOidcProvider implements AutoCloseable {private final HttpServer server;private final Map<String, String> authorizationParameters = new ConcurrentHashMap<>();+ private final AtomicInteger discoveryRequests = new AtomicInteger();private volatile String tokenRequestBody;private volatile String userInfoAuthorization;MockOidcProvider() throws IOException {server = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);+ server.createContext("/.well-known/openid-configuration", exchange -> {+ discoveryRequests.incrementAndGet();+ respond(exchange, 200, """+ {"issuer":"%s","authorization_endpoint":"%s/authorize",+ "token_endpoint":"%s/token","userinfo_endpoint":"%s/userinfo"}+ """.formatted(baseUrl(), baseUrl(), baseUrl(), baseUrl()));+ });server.createContext("/authorize", exchange -> {authorizationParameters.putAll(queryParameters(exchange.getRequestURI().getRawQuery()));respond(exchange, 302, "");@@ -31,7 +40,11 @@ final class MockOidcProvider implements AutoCloseable {});server.createContext("/userinfo", exchange -> {userInfoAuthorization = exchange.getRequestHeaders().getFirst("Authorization");- respond(exchange, 200, "{\"sub\":\"provider-subject\",\"email\":\"[email protected]\"}");+ respond(exchange, 200, """+ {"sub":"provider-subject","email":"[email protected]","email_verified":true,+ "name":"Federated User","given_name":"Federated","family_name":"User",+ "picture":"https://picture.example/user"}+ """);});server.start();}@@ -52,6 +65,10 @@ final class MockOidcProvider implements AutoCloseable {return userInfoAuthorization;}+ int discoveryRequests() {+ return discoveryRequests.get();+ }+private Map<String, String> queryParameters(String query) {Map<String, String> parameters = new LinkedHashMap<>();if (query == null || query.isBlank()) {diff --git a/src/test/resources/application.yml b/src/test/resources/application.ymlindex 6549114ce7..2b153cb899 100644--- a/src/test/resources/application.yml+++ b/src/test/resources/application.yml@@ -266,6 +266,7 @@ floci:enabled: truecognito:enabled: true+ google-issuer: https://accounts.google.comenforce-token-validity-limits: truestepfunctions:enabled: true