Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
new file mode 100644
index 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.md
index 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 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 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 in
through 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 the
request 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.java
index 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.java
index 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.java
index 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.java
index 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.java
index 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.yml
index eca27f317f..93256dd9d7 100644
--- a/src/main/resources/application.yml
+++ b/src/main/resources/application.yml
@@ -571,6 +571,7 @@ floci:
enabled: true
cognito:
enabled: true
+ google-issuer: https://accounts.google.com
enforce-token-validity-limits: true
stepfunctions:
enabled: true
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.java
index 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();
+ }
+ }
+ }
@BeforeAll
static 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"));
+ }
+
@Test
void 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.java
index 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 {
@Test
void 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 {
@Test
void 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));
+ }
+ }
+
@Test
void 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.java
index 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.yml
index 6549114ce7..2b153cb899 100644
--- a/src/test/resources/application.yml
+++ b/src/test/resources/application.yml
@@ -266,6 +266,7 @@ floci:
enabled: true
cognito:
enabled: true
+ google-issuer: https://accounts.google.com
enforce-token-validity-limits: true
stepfunctions:
enabled: true