Light, fluffy, and always free - The AWS Local Emulator alternative
fix(cognito): scope OAuth tokens to the requested scopes (#4771)
jwoa95f1d718cae272
diff --git a/docs/services/cognito.md b/docs/services/cognito.mdindex 059c3b94bd..800efe5437 100644--- a/docs/services/cognito.md+++ b/docs/services/cognito.md@@ -198,6 +198,17 @@ further divergences, both deliberate:| ForgotPassword | Starts the local forgot-password flow for a user. || ConfirmForgotPassword | Completes the forgot-password flow by setting a replacement password. |+As on AWS, every operation authorized by the user's access token (`GetUser`,+`GetUserAuthFactors`, `UpdateUserAttributes`, `DeleteUserAttributes`, `ChangePassword`,+`GetUserAttributeVerificationCode`, `VerifyUserAttribute`, `SetUserMFAPreference`,+`GlobalSignOut`, and `AssociateSoftwareToken` and `VerifySoftwareToken` with an `AccessToken`)+requires the token's `scope` to include `aws.cognito.signin.user.admin`. Tokens from+`InitiateAuth` and the other API sign-in flows always carry it; a token from the OAuth token+endpoint carries it only when the authorization request asked for it, or asked for no scope and+the client allows it. Without it the call fails with `NotAuthorizedException:+Access Token does not have required scopes`, as it does for a token with no `scope` claim at all,+which a pre token generation trigger leaves when it suppresses every scope.+### Authentication| Action | Description |@@ -367,7 +378,9 @@ the callback in `CallbackURLs`. No domain is needed; on a custom domain the same1. `GET /cognito-idp/oauth2/authorize` redirects to `/cognito-idp/login` with the request'sparameters. If the browser already has a managed login session in the pool, it skips the- form and redirects straight to the callback with a code, as AWS does.+ form and redirects straight to the callback with a code, as AWS does. A `scope` the client's+ `AllowedOAuthScopes` does not include is refused first, as on AWS, with a redirect to the+ callback carrying `error=invalid_request`, `error_description=invalid_scope` and the `state`.2. `GET /cognito-idp/login` renders a plain username and password form. The form carries therequest in hidden fields and a CSRF token that must match the `XSRF-TOKEN` cookie set with it.3. `POST /cognito-idp/login` checks the password as `USER_PASSWORD_AUTH` does, including@@ -378,9 +391,12 @@ the callback in `CallbackURLs`. No domain is needed; on a custom domain the same4. `POST /cognito-idp/oauth2/token` redeems the code. It invokes the pre token generationtrigger with triggerSource `TokenGeneration_HostedAuth`, as AWS does for a hosted-UIsign-in, so a pool that customises its claims gets the same tokens here as from- `InitiateAuth`. The trigger is told the scopes the request asked for, narrowed to the- client's `AllowedOAuthScopes`, since the authorize endpoint does not check them itself. The- ID token carries the request's `nonce`, which the trigger cannot override.+ `InitiateAuth`. The access token's `scope` is the scopes the request asked for, or every+ scope in the client's `AllowedOAuthScopes` when it asked for none, as on AWS, and the+ trigger is told the same scopes. The code keeps the scopes granted when it was issued: a+ scope the client is allowed only afterwards is not added, and one it no longer allows is+ dropped. A V2 trigger's `scopesToAdd` and `scopesToSuppress` apply on top of them. The ID token is issued only when the scopes include `openid`, and it carries+ the request's `nonce`, which the trigger cannot override.5. `GET /cognito-idp/logout?client_id=...&logout_uri=...` ends the session and redirects to`logout_uri`, which must be one of the client's `LogoutURLs`. With `redirect_uri` and`response_type=code` instead of `logout_uri`, it ends the session and redirects to the@@ -399,7 +415,8 @@ Differences from AWS:confirmed, sees an error on the form instead. Sign-up, forgot-password, MFA and passkeypages are not served, and `prompt`, `login_hint`, `lang` and `idp_identifier` are ignored.- **Errors are JSON.** An authorization request error returns `400` with an OAuth error body,- even after `redirect_uri` is validated, where AWS redirects the error to the callback.+ even after `redirect_uri` is validated, where AWS redirects the error to the callback. The+ exception is an unallowed `scope`, which is redirected as on AWS.- **Relative redirect.** The redirect from `/oauth2/authorize` to the sign-in form has arelative `Location`, where AWS's is absolute.- **One session cookie per host.** Floci's own host serves every pool, so signing in to a@@ -450,7 +467,8 @@ curl -s -b jar -o /dev/null -w '%{http_code} %{redirect_url}\n' \- It requires `AllowedOAuthFlowsUserPoolClient=true` and `AllowedOAuthFlows=["client_credentials"]`.- It doesn't require a Cognito domain.- Client-credentials returns only `access_token`, `token_type`, and `expires_in`; authorization-code- redemption returns the Cognito access, ID and refresh token set.+ redemption returns the Cognito access and refresh tokens, and an ID token when the granted scopes+ include `openid`.- It validates requested OAuth scopes against the app client's `AllowedOAuthScopes` and the pool's registered resource-server scopes.- It advertises the prefixed token endpoint in `/{userPoolId}/.well-known/openid-configuration`, or`https://<domain>/oauth2/token` when the pool has a custom domain (see Custom domains above).@@ -486,8 +504,8 @@ literal `Username` you supply, unchanged.Floci mirrors AWS's access-token / ID-token split:- **Access token:** `sub`, `username` (the UUID), `scope` (`aws.cognito.signin.user.admin` for API- sign-in), `client_id`, `cognito:groups`, `jti`/`origin_jti`. It does **not** carry `cognito:username`- or user attributes like `email`.+ sign-in, the granted OAuth scopes for an authorization code), `client_id`, `cognito:groups`,+ `jti`/`origin_jti`. It does **not** carry `cognito:username` or user attributes like `email`.- **ID token:** `sub`, `cognito:username`, `aud`, and readable user attributes (`email`,`email_verified`, `phone_number`, `custom:*`, ...). Attribute claims are filtered by the app client's`ReadAttributes` (an unset/empty list means all attributes are readable).diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.javaindex 15cafae333..c649c8794b 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoAuthFlowHandler.java@@ -1778,7 +1778,7 @@ final class CognitoAuthFlowHandler {** <p>AWS names this trigger source {@code TokenGeneration_HostedAuth}, which it uses for sign-in* through the hosted UI regardless of whether the user is native or federated. {@code scopes} are- * the scopes the authorization request asked for, which a V2 lambda may branch on.+ * the scopes the authorization request was granted, which a V2 lambda may branch on.*/CognitoService.ClaimsOverride preTokenGenerationForHostedAuth(UserPool pool, UserPoolClient client,CognitoUser user, List<String> scopes) {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 f4b52b78f8..ebcc1d9e1f 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@@ -40,18 +40,23 @@ public class CognitoFederationService {this.clock = clock;}+ /** Grants exactly the requested {@code scopes}. */public String beginAuthorization(String userPoolId, String clientId, String redirectUri, List<String> scopes,String nonce, String providerName) {- return beginAuthorization(userPoolId, clientId, redirectUri, scopes, nonce, providerName, null, null);+ return beginAuthorization(userPoolId, clientId, redirectUri, scopes, scopes, nonce, providerName, null, null);}/**- * @param codeChallenge the relying party's S256 PKCE challenge, or null. It stays with Cognito:- * the relying party proves it at Cognito's token endpoint, not the provider's.+ * @param requestedScopes the scopes the authorization request named, which the provider is asked+ * for when it has no {@code authorize_scopes}+ * @param grantedScopes the scopes Cognito granted the request, which the transaction and then+ * the authorization code keep; they never reach the provider+ * @param codeChallenge the relying party's S256 PKCE challenge, or null. It stays with Cognito:+ * the relying party proves it at Cognito's token endpoint, not the provider's.*/- public String beginAuthorization(String userPoolId, String clientId, String redirectUri, List<String> scopes,- String nonce, String providerName, String relyingPartyState,- String codeChallenge) {+ 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);String authorizeEndpoint = requiredProviderDetail(provider, "authorize_url", "authorize endpoint");@@ -59,14 +64,14 @@ public class CognitoFederationService {validateAuthorizeEndpoint(authorizeEndpoint, provider.getProviderName());Instant expiresAt = clock.instant().plus(TRANSACTION_LIFETIME);CognitoAuthorizationTransaction transaction = new CognitoAuthorizationTransaction(userPoolId, clientId,- redirectUri, scopes, nonce, providerName, relyingPartyState, codeChallenge, expiresAt);+ redirectUri, grantedScopes, nonce, providerName, relyingPartyState, codeChallenge, expiresAt);String state = stateStore.putTransaction(transaction);Map<String, String> parameters = new LinkedHashMap<>();parameters.put("response_type", "code");parameters.put("client_id", providerClientId);parameters.put("redirect_uri", cognitoService.getIdentityProviderCallbackEndpoint(userPoolId));- parameters.put("scope", providerScopes(provider, scopes));+ parameters.put("scope", providerScopes(provider, requestedScopes));parameters.put("state", state);if (nonce != null && !nonce.isBlank()) {parameters.put("nonce", nonce);diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoManagedLoginService.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoManagedLoginService.javaindex a8731e4871..7c3083a71d 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoManagedLoginService.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoManagedLoginService.java@@ -57,9 +57,11 @@ public class CognitoManagedLoginService {* Issues an authorization code to the user of the browser's session, or nothing when there is* no session for the client's pool. Every pool's session travels in the same cookie on Floci's* own host, so a session of one pool must never sign its user in to another.+ *+ * @param grantedScopes the scopes the authorization request was granted, which the code keeps*/public Optional<String> issueAuthorizationCode(String sessionId, UserPoolClient client, String redirectUri,- List<String> scopes, String nonce, String codeChallenge) {+ List<String> grantedScopes, String nonce, String codeChallenge) {Optional<CognitoManagedLoginSession> session = stateStore.findSession(sessionId).filter(candidate -> candidate.userPoolId().equals(client.getUserPoolId()));if (session.isEmpty()) {@@ -70,7 +72,7 @@ public class CognitoManagedLoginService {return Optional.empty();}CognitoAuthorizationCode code = new CognitoAuthorizationCode(client.getUserPoolId(), client.getClientId(),- session.get().username(), redirectUri, scopes, nonce, codeChallenge,+ session.get().username(), redirectUri, grantedScopes, nonce, codeChallenge,clock.instant().plus(AUTHORIZATION_CODE_LIFETIME));return Optional.of(stateStore.putAuthorizationCode(code));}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthController.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthController.javaindex f3c034cf42..6ef0b62f44 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthController.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthController.java@@ -106,10 +106,11 @@ public class CognitoOAuthController {if (check.error() != null) {return check.error();}+ List<String> requestedScopes = splitScopes(scope);try {String location = federationService.beginAuthorization(check.client().getUserPoolId(), clientId,- redirectUri, splitScopes(scope), trimToNull(nonce), providerName, relyingPartyState,- trimToNull(codeChallenge));+ redirectUri, requestedScopes, CognitoService.grantedScopes(check.client(), requestedScopes),+ trimToNull(nonce), providerName, relyingPartyState, trimToNull(codeChallenge));return Response.status(Response.Status.FOUND).location(URI.create(location)).build();} catch (AwsException e) {return oauthError("invalid_request", e.getMessage());@@ -421,7 +422,10 @@ public class CognitoOAuthController {nonceClaim(consumedCode.nonce()), consumedCode.scopes());ObjectNode body = objectMapper.createObjectNode();body.put("access_token", (String) authentication.get("AccessToken"));- body.put("id_token", (String) authentication.get("IdToken"));+ // Minted only for a grant with openid; AWS leaves the field out otherwise.+ if (authentication.get("IdToken") instanceof String idToken) {+ body.put("id_token", idToken);+ }body.put("refresh_token", (String) authentication.get("RefreshToken"));body.put("expires_in", ((Number) authentication.get("ExpiresIn")).longValue());body.put("token_type", (String) authentication.get("TokenType"));@@ -459,16 +463,19 @@ public class CognitoOAuthController {return redirect(request.redirectUri(), parameters);}+ /** Binds the code to the scopes the request is granted now; redemption never widens them. */private Optional<String> issueAuthorizationCode(String sessionId, UserPoolClient client,AuthorizationRequest request) {return managedLoginService.issueAuthorizationCode(sessionId, client, request.redirectUri(),- splitScopes(request.scope()), trimToNull(request.nonce()), trimToNull(request.codeChallenge()));+ CognitoService.grantedScopes(client, splitScopes(request.scope())), trimToNull(request.nonce()),+ trimToNull(request.codeChallenge()));}/*** The checks every authorization request passes, for managed login and federation alike. Errors- * are 400 JSON, including those found after redirect_uri is known to be registered, where AWS- * redirects the error to it instead.+ * are 400 JSON, including most of those found after redirect_uri is known to be registered, where+ * AWS redirects the error to it instead. A scope the client is not allowed is redirected, as AWS+ * does.*/private AuthorizationCheck checkAuthorizationRequest(ContainerRequestContext requestContext,AuthorizationRequest request) {@@ -496,9 +503,28 @@ public class CognitoOAuthController {if (pkceError != null) {return AuthorizationCheck.rejected(oauthError("invalid_request", pkceError));}+ if (!allowsEveryScope(client, splitScopes(request.scope()))) {+ return AuthorizationCheck.rejected(invalidScopeRedirect(request));+ }return check;}+ private static boolean allowsEveryScope(UserPoolClient client, List<String> scopes) {+ List<String> allowed = client.getAllowedOAuthScopes();+ return scopes.isEmpty() || (allowed != null && allowed.containsAll(scopes));+ }++ /** AWS's redirect for a scope the client is not allowed, parameters in the order AWS sends them. */+ private Response invalidScopeRedirect(AuthorizationRequest request) {+ Map<String, String> parameters = new LinkedHashMap<>();+ parameters.put("error_description", "invalid_scope");+ if (request.state() != null) {+ parameters.put("state", request.state());+ }+ parameters.put("error", "invalid_request");+ return redirect(request.redirectUri(), parameters);+ }+/** An authorization request that managed login answers, at the authorize, login, and logout endpoints. */private AuthorizationCheck checkManagedLoginRequest(ContainerRequestContext requestContext,AuthorizationRequest request) {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 bf12d155c5..4208e774c0 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@@ -101,6 +101,9 @@ public class CognitoService implements ResourceProvider {private static final Logger LOG = Logger.getLogger(CognitoService.class);private static final ObjectMapper MAPPER = new ObjectMapper();private static final String INVALID_ACCESS_TOKEN_MESSAGE = "Invalid access token";+ /** The scope of every access token from an API sign-in such as InitiateAuth, and what the user's own operations need. */+ private static final String USER_ADMIN_SCOPE = "aws.cognito.signin.user.admin";+ private static final List<String> API_SIGN_IN_SCOPES = List.of(USER_ADMIN_SCOPE);private static final String IDENTITIES_ATTRIBUTE = "identities";@@ -2000,6 +2003,7 @@ public class CognitoService implements ResourceProvider {}VerifiedAccessToken token = verifyAccessToken(accessToken);+ requireScope(accessToken, USER_ADMIN_SCOPE);String username = token.username();String poolId = token.poolId();CognitoUser user;@@ -3012,6 +3016,7 @@ public class CognitoService implements ResourceProvider {public void changePassword(String accessToken, String previousPassword, String proposedPassword) {VerifiedAccessToken token = verifyAccessToken(accessToken);+ requireScope(accessToken, USER_ADMIN_SCOPE);String username = token.username();String poolId = token.poolId();@@ -3079,6 +3084,7 @@ public class CognitoService implements ResourceProvider {public Map<String, Object> getUser(String accessToken) {VerifiedAccessToken token = verifyAccessToken(accessToken);+ requireScope(accessToken, USER_ADMIN_SCOPE);String username = token.username();String poolId = token.poolId();@@ -3107,7 +3113,7 @@ public class CognitoService implements ResourceProvider {}throw e;}- requireScope(accessToken, "aws.cognito.signin.user.admin");+ requireScope(accessToken, USER_ADMIN_SCOPE);CognitoUser user = adminGetUser(token.poolId(), token.username());Map<String, Object> result = new LinkedHashMap<>();@@ -3137,6 +3143,7 @@ public class CognitoService implements ResourceProvider {}throw e;}+ requireScope(accessToken, USER_ADMIN_SCOPE);String username = token.username();String poolId = token.poolId();@@ -3195,7 +3202,7 @@ public class CognitoService implements ResourceProvider {}throw e;}- requireScope(accessToken, "aws.cognito.signin.user.admin");+ requireScope(accessToken, USER_ADMIN_SCOPE);String username = token.username();String poolId = token.poolId();@@ -3242,6 +3249,7 @@ public class CognitoService implements ResourceProvider {public List<Map<String, Object>> updateUserAttributes(String accessToken, Map<String, String> attributes) {VerifiedAccessToken token = verifyAccessToken(accessToken);+ requireScope(accessToken, USER_ADMIN_SCOPE);String username = token.username();String poolId = token.poolId();@@ -3336,6 +3344,7 @@ public class CognitoService implements ResourceProvider {public void deleteUserAttributes(String accessToken, List<String> attributeNames) {VerifiedAccessToken token = verifyAccessToken(accessToken);+ requireScope(accessToken, USER_ADMIN_SCOPE);String username = token.username();String poolId = token.poolId();@@ -3531,37 +3540,51 @@ public class CognitoService implements ResourceProvider {* <p>{@code protocolClaims} carries claims the OIDC flow itself owns, currently the request's* {@code nonce}. They are applied <em>after</em> the trigger's, so a trigger cannot displace them:* AWS likewise refuses to let this trigger override {@code nonce} and the other reserved claims.- * Passing {@code null} for either side leaves the other's claims untouched. {@code requestedScopes}- * are the scopes the authorization request asked for, narrowed to the ones the client may actually- * use before the trigger is told about them.+ * Passing {@code null} for either side leaves the other's claims untouched.+ *+ * <p>{@code grantedScopes} are the scopes the authorization code was granted at authorize (see+ * {@link #grantedScopes}). The access token carries them, narrowed to the ones the client still+ * allows, rather than the {@code aws.cognito.signin.user.admin} of an API sign-in, and the ID+ * token is minted only when they include {@code openid}, as on AWS. The trigger is told the same+ * scopes, and a V2 trigger's scope changes apply on top of them.*/Map<String, Object> generateAuthResultForHostedAuth(CognitoUser user, UserPool pool, UserPoolClient client,- ClaimsOverride protocolClaims, List<String> requestedScopes) {- ClaimsOverride trigger = authFlowHandler.preTokenGenerationForHostedAuth(pool, client, user,- scopesAllowedForClient(client, requestedScopes));- return generateAuthResult(user, pool, client, mergeUnderProtocolClaims(trigger, protocolClaims));+ ClaimsOverride protocolClaims, List<String> grantedScopes) {+ List<String> scopes = scopesStillAllowed(client, grantedScopes);+ ClaimsOverride trigger = authFlowHandler.preTokenGenerationForHostedAuth(pool, client, user, scopes);+ return generateAuthResult(user, pool, client, mergeUnderProtocolClaims(trigger, protocolClaims),+ UUID.randomUUID().toString(), scopes, scopes.contains("openid"));}/**- * The requested scopes the client is allowed to use, in the order requested and without duplicates.- *- * <p>An authorization request names its own scopes, and nothing checks them against the client's- * AllowedOAuthScopes when the code is issued, so the stored code can carry a scope the client may- * not use. A V2 trigger is free to grant claims or add scopes based on what it is told was- * requested, so it is told only what the client was entitled to ask for. An unallowed scope is- * dropped rather than refused, which is how AWS treats a scope that is not associated with the- * client.+ * The scopes an authorization request is granted at authorize, where the authorization code is+ * bound to them: every scope the client allows when it asked for none, as on AWS, and otherwise+ * the requested scopes the client allows, in the order requested and without duplicates.*/- private static List<String> scopesAllowedForClient(UserPoolClient client, List<String> requestedScopes) {- if (requestedScopes == null || requestedScopes.isEmpty()) {+ static List<String> grantedScopes(UserPoolClient client, List<String> requestedScopes) {+ List<String> allowed = client.getAllowedOAuthScopes();+ if (allowed == null || allowed.isEmpty()) {return List.of();}+ if (requestedScopes == null || requestedScopes.isEmpty()) {+ return List.copyOf(new LinkedHashSet<>(allowed));+ }+ return scopesStillAllowed(client, requestedScopes);+ }++ /**+ * The code's granted scopes that the client still allows, in their order and without duplicates.+ * The client's AllowedOAuthScopes can change between authorize and redemption: a scope removed in+ * between is dropped, and one added in between is never granted. A V2 trigger is free to grant+ * claims or add scopes based on what it is told was granted, so it is told only these.+ */+ private static List<String> scopesStillAllowed(UserPoolClient client, List<String> grantedScopes) {List<String> allowed = client.getAllowedOAuthScopes();- if (allowed == null || allowed.isEmpty()) {+ if (allowed == null || grantedScopes == null) {return List.of();}List<String> kept = new ArrayList<>();- for (String scope : requestedScopes) {+ for (String scope : grantedScopes) {if (allowed.contains(scope) && !kept.contains(scope)) {kept.add(scope);}@@ -3603,9 +3626,17 @@ public class CognitoService implements ResourceProvider {}Map<String, Object> generateAuthResult(CognitoUser user, UserPool pool, UserPoolClient client, ClaimsOverride override, String originJti) {+ return generateAuthResult(user, pool, client, override, originJti, API_SIGN_IN_SCOPES, true);+ }++ private Map<String, Object> generateAuthResult(CognitoUser user, UserPool pool, UserPoolClient client,+ ClaimsOverride override, String originJti,+ List<String> accessScopes, boolean withIdToken) {Map<String, Object> auth = new HashMap<>();- auth.put("AccessToken", generateSignedJwt(user, pool, "access", client, override, originJti));- auth.put("IdToken", generateSignedJwt(user, pool, "id", client, override, originJti));+ auth.put("AccessToken", generateSignedJwt(user, pool, "access", client, override, originJti, accessScopes));+ if (withIdToken) {+ auth.put("IdToken", generateSignedJwt(user, pool, "id", client, override, originJti, accessScopes));+ }auth.put("RefreshToken", buildRefreshToken(pool, user.getUsername(), client.getClientId(), originJti));auth.put("ExpiresIn", resolveAccessTokenLifetimeSeconds(client));auth.put("TokenType", "Bearer");@@ -3617,6 +3648,15 @@ public class CognitoService implements ResourceProvider {}String generateSignedJwt(CognitoUser user, UserPool pool, String type, UserPoolClient client, ClaimsOverride override, String originJti) {+ return generateSignedJwt(user, pool, type, client, override, originJti, API_SIGN_IN_SCOPES);+ }++ /**+ * @param accessScopes the access token's {@code scope} claim before any V2 trigger changes, left+ * out when empty; ignored for an ID token+ */+ private String generateSignedJwt(CognitoUser user, UserPool pool, String type, UserPoolClient client,+ ClaimsOverride override, String originJti, List<String> accessScopes) {String header = encodeJwtHeader(pool);long now = System.currentTimeMillis() / 1000L;long lifetimeSeconds = resolveTokenLifetimeSeconds(client, type);@@ -3632,7 +3672,9 @@ public class CognitoService implements ResourceProvider {claims.put("iat", now);if ("access".equals(type)) {claims.put("username", user.getUsername());- claims.put("scope", "aws.cognito.signin.user.admin");+ if (!accessScopes.isEmpty()) {+ claims.put("scope", String.join(" ", accessScopes));+ }} else if ("id".equals(type)) {claims.put("cognito:username", user.getUsername());}@@ -4615,9 +4657,10 @@ public class CognitoService implements ResourceProvider {/*** The scopes in the space-separated {@code scope} claim of an already-verified access token- * (call after {@link #verifyAccessToken}), empty when the claim is absent or blank. Every access- * token Floci mints sets the claim (see {@code generateSignedJwt}); it is missing only when a- * PreTokenGeneration trigger removed it, and such a token grants no scope.+ * (call after {@link #verifyAccessToken}), empty when the claim is absent or blank. An access+ * token lacks the claim only when a PreTokenGeneration trigger removed it, or when an+ * authorization code was granted no scope because its client allows none, which AWS does not let+ * an OAuth client do. Such a token grants no scope.*/private Set<String> extractScopesFromToken(String token) {try {@@ -4639,10 +4682,10 @@ public class CognitoService implements ResourceProvider {}/**- * AWS requires an access token carrying the given scope for some operations (for example- * VerifyUserAttribute requires aws.cognito.signin.user.admin), and refuses a token with no- * scope claim. Call after {@link #verifyAccessToken}, which already confirms the token is a- * valid, unexpired access token; this only adds the scope check on top.+ * AWS requires an access token carrying the given scope for some operations (every operation+ * authorized by the user's access token requires aws.cognito.signin.user.admin), and refuses a+ * token with no scope claim. Call after {@link #verifyAccessToken}, which already confirms the+ * token is a valid, unexpired access token; this only adds the scope check on top.*/void requireScope(String accessToken, String requiredScope) {Set<String> scopes = extractScopesFromToken(accessToken);@@ -5149,6 +5192,7 @@ public class CognitoService implements ResourceProvider {Boolean emailPreferred) {VerifiedAccessToken token = verifyAccessToken(accessToken);+ requireScope(accessToken, USER_ADMIN_SCOPE);synchronized (userLock(token.poolId(), token.username())) {setUserMFAPreferenceUnderUserLock(token.poolId(), token.username(), emailEnabled, emailPreferred);diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationCode.java b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationCode.javaindex d13c47311a..5500a7d406 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationCode.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoAuthorizationCode.java@@ -4,9 +4,11 @@ import java.time.Instant;import java.util.List;/**- * A one-time authorization code. {@code nonce} and {@code codeChallenge} are the authorization- * request's values, or null when it sent none; the token endpoint puts the nonce in the ID token- * and requires a matching {@code code_verifier} when there is a challenge.+ * A one-time authorization code. {@code scopes} are the scopes the authorization request was granted+ * when the code was issued, which redemption narrows to the client's current AllowedOAuthScopes but+ * never widens. {@code nonce} and {@code codeChallenge} are the authorization request's values, or+ * null when it sent none; the token endpoint puts the nonce in the ID token and requires a matching+ * {@code code_verifier} when there is a challenge.*/public record CognitoAuthorizationCode(String userPoolId,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 3bfa5eedd8..8ba0425c49 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@@ -137,7 +137,7 @@ class CognitoFederationServiceTest {String redirect = federationService.beginAuthorization(pool.getId(), "cognito-client", "https://application.example.test/callback",- List.of("openid"), "nonce-value", "ExampleOidc", "relying-party-state", null);+ List.of("openid"), List.of("openid"), "nonce-value", "ExampleOidc", "relying-party-state", null);CognitoAuthorizationTransaction transaction = stateStore.consumeTransaction(queryValue(redirect, "state")).orElseThrow();assertEquals("relying-party-state", transaction.relyingPartyState());@@ -149,7 +149,7 @@ class CognitoFederationServiceTest {String challenge = "E9Melhoa2OwvFrEMTJguCHaoeK1t8URWbuGJSstw-cM";String redirect = federationService.beginAuthorization(pool.getId(), "cognito-client", "https://application.example.test/callback",- List.of("openid"), "nonce-value", "ExampleOidc", null, challenge);+ List.of("openid"), List.of("openid"), "nonce-value", "ExampleOidc", null, challenge);String authorizationCode = federationService.completeAuthorization(queryValue(redirect, "state"), "provider-code");diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoLambdaTriggersTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoLambdaTriggersTest.javaindex 33fc15f3f8..d63948755a 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoLambdaTriggersTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoLambdaTriggersTest.java@@ -34,6 +34,7 @@ import java.util.Base64;import java.util.HashMap;import java.util.List;import java.util.Map;+import java.util.Set;import javax.crypto.Mac;import javax.crypto.spec.SecretKeySpec;@@ -854,9 +855,9 @@ class CognitoLambdaTriggersTest {}/**- * Nothing checks an authorization request's scopes against the client's AllowedOAuthScopes when the- * code is issued, so the stored code can name a scope the client may not use. A V2 trigger may grant- * claims or scopes from what it is told was requested, so it must never be told about one.+ * The authorize endpoint refuses a scope the client may not use, but a client's AllowedOAuthScopes+ * can change before its code is redeemed. A V2 trigger may grant claims or scopes from what it is+ * told was requested, so it must never be told about one the client no longer allows.*/@Test@SuppressWarnings("unchecked")@@ -914,7 +915,7 @@ class CognitoLambdaTriggersTest {void redemptionKeepsTheRequestNonceOverATriggerThatTriesToChangeIt() {UserPool pool = createPoolWithLambdaConfig(Map.of("PreTokenGeneration", "arn:aws:lambda:::pre-token"));seedUser(pool, "alice", "Perm1234!");- UserPoolClient client = createClient(pool);+ UserPoolClient client = createOAuthClient(pool, List.of("openid"));CognitoUser user = service.adminGetUser(pool.getId(), "alice");when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-token"), any(byte[].class), any())).thenReturn(ok(Map.of("claimsOverrideDetails", Map.of(@@ -940,7 +941,7 @@ class CognitoLambdaTriggersTest {void redemptionMintsTokensWhenNoPreTokenGenerationTriggerIsConfigured() {UserPool pool = createPoolWithLambdaConfig(Map.of());seedUser(pool, "alice", "Perm1234!");- UserPoolClient client = createClient(pool);+ UserPoolClient client = createOAuthClient(pool, List.of("openid"));CognitoUser user = service.adminGetUser(pool.getId(), "alice");Map<String, Object> auth = service.generateAuthResultForHostedAuth(user, pool, client,@@ -960,6 +961,127 @@ class CognitoLambdaTriggersTest {verify(lambdaService, never()).invoke(anyString(), anyString(), any(byte[].class), any());}+ /**+ * AWS grants every scope the client allows to a request that names none, and that grant is what+ * the trigger is told and what the access token carries.+ */+ @Test+ @SuppressWarnings("unchecked")+ void aRequestWithoutScopesIsGrantedEveryAllowedScope() {+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreTokenGeneration", "arn:aws:lambda:::pre-token"));+ seedUser(pool, "alice", "Perm1234!");+ UserPoolClient client = createOAuthClient(pool, List.of("openid", "email", "aws.cognito.signin.user.admin"));+ CognitoUser user = service.adminGetUser(pool.getId(), "alice");+ ArgumentCaptor<byte[]> payloadCap = ArgumentCaptor.forClass(byte[].class);+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-token"), payloadCap.capture(), any()))+ .thenReturn(ok(Map.of()));++ List<String> granted = CognitoService.grantedScopes(client, List.of());+ Map<String, Object> auth = service.generateAuthResultForHostedAuth(user, pool, client, null, granted);++ assertEquals(List.of("openid", "email", "aws.cognito.signin.user.admin"), granted);+ Map<String, Object> event;+ Map<String, Object> accessClaims;+ try {+ event = MAPPER.readValue(payloadCap.getValue(), new TypeReference<>() {});+ accessClaims = MAPPER.readValue(decodeJwtPayload((String) auth.get("AccessToken")), new TypeReference<>() {});+ } catch (Exception e) {+ throw new RuntimeException(e);+ }+ assertEquals(granted, ((Map<String, Object>) event.get("request")).get("scopes"));+ assertEquals(Set.copyOf(granted), Set.of(((String) accessClaims.get("scope")).split(" ")));+ assertNotNull(auth.get("IdToken"));+ }++ /** Redemption issues the code's grant and never widens it, even when that grant is empty. */+ @Test+ void redemptionNeverWidensTheCodesGrant() {+ UserPool pool = createPoolWithLambdaConfig(Map.of());+ seedUser(pool, "alice", "Perm1234!");+ UserPoolClient client = createOAuthClient(pool, List.of("openid", "email"));+ CognitoUser user = service.adminGetUser(pool.getId(), "alice");++ Map<String, Object> auth = service.generateAuthResultForHostedAuth(user, pool, client, null, List.of());++ Map<String, Object> accessClaims;+ try {+ accessClaims = MAPPER.readValue(decodeJwtPayload((String) auth.get("AccessToken")), new TypeReference<>() {});+ } catch (Exception e) {+ throw new RuntimeException(e);+ }+ assertFalse(accessClaims.containsKey("scope"), "an empty grant stays empty: " + accessClaims);+ assertFalse(auth.containsKey("IdToken"));+ }++ /** A V2 trigger that suppresses every scope of the grant leaves no scope claim. */+ @Test+ void preTokenGenerationV2SuppressingTheWholeCodeGrantRemovesTheScopeClaim() {+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreTokenGeneration", "arn:aws:lambda:::pre-token"));+ seedUser(pool, "alice", "Perm1234!");+ UserPoolClient client = createOAuthClient(pool, List.of("openid", "email"));+ CognitoUser user = service.adminGetUser(pool.getId(), "alice");+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-token"), any(byte[].class), any()))+ .thenReturn(ok(Map.of("claimsAndScopeOverrideDetails", Map.of(+ "accessTokenGeneration", Map.of("scopesToSuppress", List.of("email"))))));++ Map<String, Object> auth = service.generateAuthResultForHostedAuth(user, pool, client, null, List.of("email"));++ Map<String, Object> accessClaims;+ try {+ accessClaims = MAPPER.readValue(decodeJwtPayload((String) auth.get("AccessToken")), new TypeReference<>() {});+ } catch (Exception e) {+ throw new RuntimeException(e);+ }+ assertFalse(accessClaims.containsKey("scope"), "suppressing the only granted scope leaves none: " + accessClaims);+ }++ /** Only a grant with {@code openid} gets an ID token, and the access token carries just the grant. */+ @Test+ void redemptionWithoutOpenidMintsNoIdToken() {+ UserPool pool = createPoolWithLambdaConfig(Map.of());+ seedUser(pool, "alice", "Perm1234!");+ UserPoolClient client = createOAuthClient(pool, List.of("openid", "email"));+ CognitoUser user = service.adminGetUser(pool.getId(), "alice");++ Map<String, Object> auth = service.generateAuthResultForHostedAuth(user, pool, client, null, List.of("email"));++ Map<String, Object> accessClaims;+ try {+ accessClaims = MAPPER.readValue(decodeJwtPayload((String) auth.get("AccessToken")), new TypeReference<>() {});+ } catch (Exception e) {+ throw new RuntimeException(e);+ }+ assertEquals("email", accessClaims.get("scope"));+ assertFalse(auth.containsKey("IdToken"), "no openid, no ID token: " + auth.keySet());+ assertNotNull(auth.get("RefreshToken"));+ }++ /** V2 scope changes apply on top of the grant, not on top of a fixed default scope. */+ @Test+ void preTokenGenerationV2ScopeChangesApplyOnTopOfTheCodeGrant() {+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreTokenGeneration", "arn:aws:lambda:::pre-token"));+ seedUser(pool, "alice", "Perm1234!");+ UserPoolClient client = createOAuthClient(pool, List.of("openid", "email", "profile"));+ CognitoUser user = service.adminGetUser(pool.getId(), "alice");+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-token"), any(byte[].class), any()))+ .thenReturn(ok(Map.of("claimsAndScopeOverrideDetails", Map.of(+ "accessTokenGeneration", Map.of(+ "scopesToSuppress", List.of("email"),+ "scopesToAdd", List.of("aws.cognito.signin.user.admin"))))));++ Map<String, Object> auth = service.generateAuthResultForHostedAuth(user, pool, client, null,+ List.of("openid", "email"));++ Map<String, Object> accessClaims;+ try {+ accessClaims = MAPPER.readValue(decodeJwtPayload((String) auth.get("AccessToken")), new TypeReference<>() {});+ } catch (Exception e) {+ throw new RuntimeException(e);+ }+ assertEquals(Set.of("openid", "aws.cognito.signin.user.admin"),+ Set.of(((String) accessClaims.get("scope")).split(" ")));+ }+@Testvoid managedLoginPreAuthenticationErrorBlocksSignIn() {UserPool pool = createPoolWithLambdaConfig(Map.of(diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoManagedLoginIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoManagedLoginIntegrationTest.javaindex 15aacf359a..da1a0c44cc 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoManagedLoginIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoManagedLoginIntegrationTest.java@@ -16,9 +16,11 @@ import org.mockito.ArgumentCaptor;import java.net.URI;import java.net.URLDecoder;import java.nio.charset.StandardCharsets;+import java.util.HashSet;import java.util.LinkedHashMap;import java.util.List;import java.util.Map;+import java.util.Set;import java.util.regex.Matcher;import java.util.regex.Pattern;@@ -39,6 +41,8 @@ import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;import static org.mockito.ArgumentMatchers.anyString;import static org.mockito.ArgumentMatchers.eq;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;import static org.mockito.Mockito.when;/**@@ -60,6 +64,7 @@ class CognitoManagedLoginIntegrationTest {private static final Pattern HIDDEN_FIELD = Pattern.compile("<input type=\"hidden\" name=\"([^\"]*)\" value=\"([^\"]*)\">");private static final Pattern FORM_ACTION = Pattern.compile("<form method=\"post\" action=\"([^\"]*)\">");private static final String PRE_TOKEN_GENERATION_ARN = "arn:aws:lambda:::pre-token-generation";+ private static final String ADMIN_SCOPE = "aws.cognito.signin.user.admin";private static final ObjectMapper MAPPER = new ObjectMapper();/** Only the PreTokenGeneration trigger is configured on any pool here, so nothing else invokes it. */@@ -236,52 +241,196 @@ class CognitoManagedLoginIntegrationTest {}/**- * The authorize endpoint stores the scopes the request named without checking them against the- * client's AllowedOAuthScopes, so a request can carry one the client may not use. A V2 trigger can- * grant claims or scopes from what it is told was requested, so an unallowed scope must not reach it.+ * AWS refuses a scope outside the client's AllowedOAuthScopes at the authorize endpoint, before+ * the sign-in form and even for a browser that is already signed in, by redirecting to the+ * callback with {@code error=invalid_request} and {@code error_description=invalid_scope}. No+ * code is issued, so a V2 trigger never hears of the scope.*/@Test- void aScopeTheClientIsNotAllowedDoesNotReachTheTrigger() throws Exception {- Pool pool = newPoolWithPreTokenGenerationTrigger();- Map<String, String> query = authorizeRequest(pool.clientId());- query.put("scope", "openid email admin/superuser");- ArgumentCaptor<byte[]> event = ArgumentCaptor.forClass(byte[].class);- when(lambdaService.invoke(anyString(), eq(PRE_TOKEN_GENERATION_ARN), event.capture(), any()))- .thenReturn(triggerResponse(Map.of()));+ void aScopeTheClientIsNotAllowedIsRedirectedToTheCallbackAsInvalidScope() throws Exception {+ Pool withoutAdmin = newPoolWithPreTokenGenerationTrigger();+ Pool withAdmin = newPool(List.of("openid", "email", ADMIN_SCOPE));+ String session = signIn(null, withoutAdmin, authorizeRequest(withoutAdmin.clientId())).getCookie("cognito");+ Map<String, Pool> requests = new LinkedHashMap<>();+ requests.put("openid " + ADMIN_SCOPE, withoutAdmin);+ requests.put("openid email admin/superuser", withoutAdmin);+ requests.put("openid phone", withAdmin);++ for (Map.Entry<String, Pool> request : requests.entrySet()) {+ Map<String, String> query = withField(authorizeRequest(request.getValue().clientId()), "scope",+ request.getKey());+ for (String sessionCookie : new String[] {null, session}) {+ String location = browserGet(null, "/cognito-idp/oauth2/authorize", query, sessionCookie)+ .then().statusCode(302).extract().header("Location");++ assertTrue(location.startsWith(CALLBACK + "?"), location);+ assertEquals(Map.of("error", "invalid_request", "error_description", "invalid_scope",+ "state", "client-state"), queryOf(location), "scope=" + request.getKey());+ }+ }+ verify(lambdaService, never()).invoke(anyString(), anyString(), any(byte[].class), any());+ }- Response tokens = redeem(null, pool.clientId(), code(signIn(null, pool, query)), VERIFIER);+ /** AWS: the requested scopes, or every scope the client allows when the request names none. */+ @Test+ void theAccessTokenCarriesTheRequestedScopesOrEveryAllowedScopeWhenNoneAreRequested() throws Exception {+ Pool pool = newPool(List.of("openid", "email", ADMIN_SCOPE));+ Map<String, Set<String>> expected = new LinkedHashMap<>();+ expected.put("openid email", Set.of("openid", "email"));+ expected.put("openid email " + ADMIN_SCOPE, Set.of("openid", "email", ADMIN_SCOPE));+ expected.put(null, Set.of("openid", "email", ADMIN_SCOPE));++ for (Map.Entry<String, Set<String>> request : expected.entrySet()) {+ Map<String, String> query = withField(authorizeRequest(pool.clientId()), "scope", request.getKey());++ Response tokens = redeem(null, pool.clientId(), code(signIn(null, pool, query)), VERIFIER);++ tokens.then().statusCode(200);+ assertEquals(request.getValue(), scopes(tokens.path("access_token")), "scope=" + request.getKey());+ assertEquals(Set.of("access_token", "id_token", "refresh_token", "expires_in", "token_type"),+ fieldNames(tokens), "scope=" + request.getKey());+ }+ }++ /** AWS issues an ID token only for a request with {@code openid}. */+ @Test+ void withoutOpenidTheTokenEndpointIssuesNoIdToken() throws Exception {+ Pool pool = newPool(List.of("openid", "email", ADMIN_SCOPE));++ for (String requested : new String[] {"email", ADMIN_SCOPE}) {+ Map<String, String> query = withField(authorizeRequest(pool.clientId()), "scope", requested);++ Response tokens = redeem(null, pool.clientId(), code(signIn(null, pool, query)), VERIFIER);++ tokens.then().statusCode(200);+ assertEquals(Set.of("access_token", "refresh_token", "expires_in", "token_type"), fieldNames(tokens),+ "scope=" + requested);+ assertEquals(Set.of(requested), scopes(tokens.path("access_token")));+ }+ }++ /**+ * A code carries the scopes granted when it was issued. A request without a scope is granted+ * every scope the client allows then, so a scope the client is allowed only afterwards is not+ * added when the code is redeemed.+ */+ @Test+ void aScopeTheClientIsAllowedAfterTheCodeWasIssuedIsNotAdded() throws Exception {+ Pool pool = newPool();+ String code = code(signIn(null, pool, withField(authorizeRequest(pool.clientId()), "scope", null)));+ allowScopes(pool, List.of("openid", "email", ADMIN_SCOPE));++ Response tokens = redeem(null, pool.clientId(), code, VERIFIER);tokens.then().statusCode(200);- assertEquals(List.of("openid", "email"),- MAPPER.convertValue(MAPPER.readTree(event.getValue()).path("request").path("scopes"), List.class),- "admin/superuser is not in the client's AllowedOAuthScopes, so the trigger never sees it");+ assertEquals(Set.of("openid", "email"), scopes(tokens.path("access_token")));}/**- * GetUserAuthFactors needs {@code aws.cognito.signin.user.admin} in the access token's scope.- * Floci stamps that scope on every code-grant access token whatever the request asked for, so a- * V2 trigger reshapes this token's scope to the {@code openid email} the request named.+ * A scope the client no longer allows is dropped from a code issued before the change, here+ * one issued to a browser that was already signed in.*/@Test- void codeGrantAccessTokenWithoutTheAdminScopeCannotReadAuthFactors() throws Exception {- String accessToken = codeGrantAccessTokenReshapedByTrigger(Map.of(- "scopesToAdd", List.of("openid", "email"),- "scopesToSuppress", List.of("aws.cognito.signin.user.admin")));- assertEquals("openid email", jwtPayload(accessToken).path("scope").asText());+ void aScopeTheClientNoLongerAllowsIsDroppedFromAnIssuedCode() throws Exception {+ Pool pool = newPool(List.of("openid", "email", ADMIN_SCOPE));+ String session = signIn(null, pool, authorizeRequest(pool.clientId())).getCookie("cognito");+ String code = code(browserGet(null, "/cognito-idp/oauth2/authorize",+ withField(authorizeRequest(pool.clientId()), "scope", null), session));+ allowScopes(pool, List.of("openid", ADMIN_SCOPE));- cognitoAction("GetUserAuthFactors", """- {"AccessToken":"%s"}- """.formatted(accessToken))+ Response tokens = redeem(null, pool.clientId(), code, VERIFIER);++ tokens.then().statusCode(200);+ assertEquals(Set.of("openid", ADMIN_SCOPE), scopes(tokens.path("access_token")));+ }++ /**+ * Floci lets an OAuth client allow no scopes. Its code grant has no scope claim and no ID token,+ * and none of the user's own operations accepts a token without a scope.+ */+ @Test+ void aCodeGrantOfAClientThatAllowsNoScopesCannotCallTheUsersOwnOperations() throws Exception {+ Pool pool = newPool(List.of());++ Response tokens = redeem(null, pool.clientId(),+ code(signIn(null, pool, withField(authorizeRequest(pool.clientId()), "scope", null))), VERIFIER);++ tokens.then().statusCode(200);+ assertEquals(Set.of("access_token", "refresh_token", "expires_in", "token_type"), fieldNames(tokens));+ String accessToken = tokens.path("access_token");+ assertFalse(jwtPayload(accessToken).has("scope"));+ cognitoAction("GetUser", "{\"AccessToken\":\"%s\"}".formatted(accessToken)).then().statusCode(400).body("__type", equalTo("NotAuthorizedException")).body("message", equalTo("Access Token does not have required scopes"));}- /** A trigger that suppresses the token's only scope leaves no scope claim, which grants nothing. */+ /**+ * {@code aws.cognito.signin.user.admin} is what lets an access token call the user's own API+ * operations. A code-grant token requested without it is refused with AWS's message, and the+ * refused calls change nothing.+ */+ @Test+ void aCodeGrantTokenWithoutTheAdminScopeCannotCallTheUsersOwnOperations() throws Exception {+ Pool pool = newPool(List.of("openid", "email", ADMIN_SCOPE));+ String withoutAdmin = accessToken(pool, "openid email");+ String withAdmin = accessToken(pool, "openid email " + ADMIN_SCOPE);+ Map<String, String> requests = new LinkedHashMap<>();+ requests.put("GetUser", "{\"AccessToken\":\"%s\"}");+ requests.put("GetUserAuthFactors", "{\"AccessToken\":\"%s\"}");+ requests.put("UpdateUserAttributes",+ "{\"AccessToken\":\"%s\",\"UserAttributes\":[{\"Name\":\"given_name\",\"Value\":\"Changed\"}]}");+ requests.put("DeleteUserAttributes", "{\"AccessToken\":\"%s\",\"UserAttributeNames\":[\"email\"]}");+ requests.put("ChangePassword",+ "{\"AccessToken\":\"%s\",\"PreviousPassword\":\"" + PASSWORD + "\",\"ProposedPassword\":\"Other1234!\"}");+ requests.put("GetUserAttributeVerificationCode", "{\"AccessToken\":\"%s\",\"AttributeName\":\"email\"}");+ requests.put("VerifyUserAttribute", "{\"AccessToken\":\"%s\",\"AttributeName\":\"email\",\"Code\":\"123456\"}");+ requests.put("SetUserMFAPreference", "{\"AccessToken\":\"%s\",\"EmailMfaSettings\":{\"Enabled\":true}}");+ requests.put("AssociateSoftwareToken", "{\"AccessToken\":\"%s\"}");+ requests.put("VerifySoftwareToken", "{\"AccessToken\":\"%s\",\"UserCode\":\"123456\"}");+ requests.put("GlobalSignOut", "{\"AccessToken\":\"%s\"}");++ for (Map.Entry<String, String> request : requests.entrySet()) {+ cognitoAction(request.getKey(), request.getValue().formatted(withoutAdmin))+ .then().statusCode(400)+ .body("__type", equalTo("NotAuthorizedException"))+ .body("message", equalTo("Access Token does not have required scopes"));+ }++ JsonNode user = cognitoJson("GetUser", "{\"AccessToken\":\"%s\"}".formatted(withAdmin));+ assertEquals(pool.username(), user.path("Username").asText(), "the user was not signed out");+ assertTrue(user.path("UserAttributes").toString().contains("\"email\""), user.toString());+ assertFalse(user.path("UserAttributes").toString().contains("given_name"), user.toString());+ code(signIn(null, pool, authorizeRequest(pool.clientId())));+ }++ /**+ * A V2 trigger's {@code scopesToAdd} and {@code scopesToSuppress} apply on top of the scopes the+ * request was granted, so a trigger can still give a token the scope that API calls need.+ */+ @Test+ void preTokenGenerationV2ScopeChangesApplyOnTopOfTheGrantedScopes() throws Exception {+ Pool pool = newPoolWithPreTokenGenerationTrigger();+ when(lambdaService.invoke(anyString(), eq(PRE_TOKEN_GENERATION_ARN), any(byte[].class), any()))+ .thenReturn(triggerResponse(Map.of("claimsAndScopeOverrideDetails", Map.of(+ "accessTokenGeneration", Map.of(+ "scopesToSuppress", List.of("email"),+ "scopesToAdd", List.of(ADMIN_SCOPE))))));++ Response tokens = redeem(null, pool.clientId(),+ code(signIn(null, pool, authorizeRequest(pool.clientId()))), VERIFIER);++ tokens.then().statusCode(200);+ String accessToken = tokens.path("access_token");+ assertEquals(Set.of("openid", ADMIN_SCOPE), scopes(accessToken));+ cognitoAction("GetUser", "{\"AccessToken\":\"%s\"}".formatted(accessToken)).then().statusCode(200);+ }++ /** A trigger that suppresses every scope the request was granted leaves no scope claim, which grants nothing. */@Testvoid codeGrantAccessTokenWithEveryScopeSuppressedCannotReadAuthFactors() throws Exception {String accessToken = codeGrantAccessTokenReshapedByTrigger(Map.of(- "scopesToSuppress", List.of("aws.cognito.signin.user.admin")));+ "scopesToSuppress", List.of("openid", "email")));assertFalse(jwtPayload(accessToken).has("scope"));cognitoAction("GetUserAuthFactors", """@@ -295,7 +444,7 @@ class CognitoManagedLoginIntegrationTest {@Testvoid codeGrantAccessTokenWithEveryScopeSuppressedCannotVerifyAnAttribute() throws Exception {String accessToken = codeGrantAccessTokenReshapedByTrigger(Map.of(- "scopesToSuppress", List.of("aws.cognito.signin.user.admin")));+ "scopesToSuppress", List.of("openid", "email")));assertFalse(jwtPayload(accessToken).has("scope"));cognitoAction("VerifyUserAttribute", """@@ -308,15 +457,8 @@ class CognitoManagedLoginIntegrationTest {@Testvoid codeGrantAccessTokenWithTheAdminScopeReadsAuthFactors() throws Exception {- String poolId = cognitoJson("CreateUserPool", "{\"PoolName\":\"ManagedLoginAdminScopePool\"}")- .path("UserPool").path("Id").asText();- Pool pool = withUser(poolId,- codeClient(poolId, "\"openid\",\"email\",\"aws.cognito.signin.user.admin\""),- "user-" + System.nanoTime());- Map<String, String> query = authorizeRequest(pool.clientId());- query.put("scope", "openid email aws.cognito.signin.user.admin");- String accessToken = redeem(null, pool.clientId(), code(signIn(null, pool, query)), VERIFIER)- .path("access_token");+ Pool pool = newPool(List.of("openid", "email", ADMIN_SCOPE));+ String accessToken = accessToken(pool, "openid email " + ADMIN_SCOPE);cognitoAction("GetUserAuthFactors", """{"AccessToken":"%s"}@@ -471,7 +613,7 @@ class CognitoManagedLoginIntegrationTest {""".formatted(poolId));String clientId = cognitoJson("CreateUserPoolClient", """{"UserPoolId":"%s","ClientName":"federated-only","AllowedOAuthFlowsUserPoolClient":true,- "AllowedOAuthFlows":["code"],"AllowedOAuthScopes":["openid"],"CallbackURLs":["%s"],+ "AllowedOAuthFlows":["code"],"AllowedOAuthScopes":["openid","email"],"CallbackURLs":["%s"],"SupportedIdentityProviders":["ExampleOidc"]}""".formatted(poolId, CALLBACK)).path("UserPoolClient").path("ClientId").asText();Map<String, String> query = authorizeRequest(clientId);@@ -562,6 +704,26 @@ class CognitoManagedLoginIntegrationTest {.then().statusCode(400).body("error", equalTo("invalid_client"));}+ @Test+ void customDomainScopesTheCodeGrantTheSameWay() throws Exception {+ Pool pool = newPool(List.of("openid", "email", ADMIN_SCOPE));+ String domain = "managed-login-scope-" + System.nanoTime() + ".teos.localhost.floci.io";+ cognitoJson("CreateUserPoolDomain", customDomain(domain, pool.poolId(), requestCertificate(domain)));++ Response tokens = redeem(domain, pool.clientId(),+ code(signIn(domain, pool, withField(authorizeRequest(pool.clientId()), "scope", "email"))), VERIFIER);++ tokens.then().statusCode(200);+ assertEquals(Set.of("access_token", "refresh_token", "expires_in", "token_type"), fieldNames(tokens));+ assertEquals(Set.of("email"), scopes(tokens.path("access_token")));+ String refused = browserGet(domain, "/oauth2/authorize",+ withField(authorizeRequest(pool.clientId()), "scope", "openid phone"), null)+ .then().statusCode(302).extract().header("Location");+ assertTrue(refused.startsWith(CALLBACK + "?"), refused);+ assertEquals(Map.of("error", "invalid_request", "error_description", "invalid_scope", "state", "client-state"),+ queryOf(refused));+ }+/** Without a custom domain Host, /login stays S3's path-style bucket route. */@Testvoid loginOnFlocisOwnHostIsNotManagedLogin() {@@ -585,8 +747,12 @@ class CognitoManagedLoginIntegrationTest {}private static Pool newPool() throws Exception {+ return newPool(List.of("openid", "email"));+ }++ private static Pool newPool(List<String> allowedScopes) throws Exception {String poolId = cognitoJson("CreateUserPool", "{\"PoolName\":\"ManagedLoginPool\"}").path("UserPool").path("Id").asText();- return withUser(poolId, codeClient(poolId), "user-" + System.nanoTime());+ return withUser(poolId, codeClient(poolId, allowedScopes), "user-" + System.nanoTime());}private static Pool newPoolWithPreTokenGenerationTrigger() throws Exception {@@ -615,16 +781,26 @@ class CognitoManagedLoginIntegrationTest {}private static String codeClient(String poolId) throws Exception {- return codeClient(poolId, "\"openid\",\"email\"");+ return codeClient(poolId, List.of("openid", "email"));}- /** {@code allowedScopes} is the body of the AllowedOAuthScopes JSON array. */- private static String codeClient(String poolId, String allowedScopes) throws Exception {+ private static String codeClient(String poolId, List<String> allowedScopes) throws Exception {return cognitoJson("CreateUserPoolClient", """{"UserPoolId":"%s","ClientName":"managed-login","AllowedOAuthFlowsUserPoolClient":true,- "AllowedOAuthFlows":["code"],"AllowedOAuthScopes":[%s],"CallbackURLs":["%s"],+ "AllowedOAuthFlows":["code"],"AllowedOAuthScopes":%s,"CallbackURLs":["%s"],"LogoutURLs":["%s"],"SupportedIdentityProviders":["COGNITO"],"ExplicitAuthFlows":["ALLOW_REFRESH_TOKEN_AUTH"]}- """.formatted(poolId, allowedScopes, CALLBACK, SIGNED_OUT)).path("UserPoolClient").path("ClientId").asText();+ """.formatted(poolId, MAPPER.writeValueAsString(allowedScopes), CALLBACK, SIGNED_OUT))+ .path("UserPoolClient").path("ClientId").asText();+ }++ /** Replaces the client's AllowedOAuthScopes, sending the rest of its OAuth configuration unchanged. */+ private static void allowScopes(Pool pool, List<String> allowedScopes) throws Exception {+ cognitoJson("UpdateUserPoolClient", """+ {"UserPoolId":"%s","ClientId":"%s","ClientName":"managed-login","AllowedOAuthFlowsUserPoolClient":true,+ "AllowedOAuthFlows":["code"],"AllowedOAuthScopes":%s,"CallbackURLs":["%s"],+ "LogoutURLs":["%s"],"SupportedIdentityProviders":["COGNITO"],"ExplicitAuthFlows":["ALLOW_REFRESH_TOKEN_AUTH"]}+ """.formatted(pool.poolId(), pool.clientId(), MAPPER.writeValueAsString(allowedScopes), CALLBACK,+ SIGNED_OUT));}private static Pool withUser(String poolId, String clientId, String username) throws Exception {@@ -723,6 +899,13 @@ class CognitoManagedLoginIntegrationTest {return request.when().post(host == null ? "/cognito-idp/oauth2/token" : "/oauth2/token");}+ /** An access token for the pool's user from a fresh sign-in that requested {@code scope}. */+ private static String accessToken(Pool pool, String scope) {+ Map<String, String> query = withField(authorizeRequest(pool.clientId()), "scope", scope);+ return redeem(null, pool.clientId(), code(signIn(null, pool, query)), VERIFIER)+ .then().statusCode(200).extract().path("access_token");+ }+private static String code(Response callbackRedirect) {callbackRedirect.then().statusCode(302);String code = queryOf(callbackRedirect.getHeader("Location")).get("code");@@ -732,6 +915,17 @@ class CognitoManagedLoginIntegrationTest {// ──────────────────────────── Parsing ────────────────────────────+ /** The access token's scopes, as a set: AWS does not promise their order. */+ private static Set<String> scopes(String accessToken) throws Exception {+ return Set.of(jwtPayload(accessToken).path("scope").asText().split(" "));+ }++ private static Set<String> fieldNames(Response tokens) throws Exception {+ Set<String> names = new HashSet<>();+ MAPPER.readTree(tokens.asString()).fieldNames().forEachRemaining(names::add);+ return names;+ }+/** The Set-Cookie header that sets {@code name}, or null. */private static String setCookie(Response response, String name) {for (String header : response.getHeaders().getValues("Set-Cookie")) {diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthControllerTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthControllerTest.javaindex ed38e4923b..e54ece597c 100644--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthControllerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoOAuthControllerTest.java@@ -7,6 +7,7 @@ import io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationCodimport io.github.hectorvent.floci.services.cognito.model.CognitoAuthorizationTransaction;import io.github.hectorvent.floci.services.cognito.model.CognitoManagedLoginSession;import io.github.hectorvent.floci.services.cognito.model.CognitoUser;+import io.github.hectorvent.floci.services.cognito.model.IdentityProvider;import io.github.hectorvent.floci.services.cognito.model.UserPool;import io.github.hectorvent.floci.services.cognito.model.UserPoolClient;import jakarta.ws.rs.container.ContainerRequestContext;@@ -18,10 +19,13 @@ import org.junit.jupiter.params.ParameterizedTest;import org.junit.jupiter.params.provider.CsvSource;import org.mockito.ArgumentCaptor;+import java.net.URI;+import java.net.URLDecoder;import java.nio.charset.StandardCharsets;import java.time.Clock;import java.time.Instant;import java.time.ZoneOffset;+import java.util.ArrayList;import java.util.Base64;import java.util.List;import java.util.Map;@@ -65,8 +69,8 @@ class CognitoOAuthControllerTest {@Testvoid authorizeRedirectsToConfiguredIdentityProvider() {- when(federationService.beginAuthorization(POOL_ID, CLIENT_ID, CALLBACK_URI, List.of("openid"), "nonce", "ExampleOidc",- " relying-party-state ", RFC_7636_CHALLENGE))+ when(federationService.beginAuthorization(POOL_ID, CLIENT_ID, CALLBACK_URI, List.of("openid"), List.of("openid"),+ "nonce", "ExampleOidc", " relying-party-state ", RFC_7636_CHALLENGE)).thenReturn("https://provider.example.test/authorize?state=provider-state");Response response = controller.authorize(requestContext(null), CLIENT_ID, CALLBACK_URI, "code", "openid", "nonce",@@ -156,6 +160,77 @@ class CognitoOAuthControllerTest {}}+ /** AWS redirects an unallowed scope to the callback, in this parameter order, before any provider is involved. */+ @Test+ void authorizeRedirectsAScopeTheClientIsNotAllowedToTheCallbackForEitherProvider() {+ for (String provider : new String[] {null, "COGNITO", "ExampleOidc"}) {+ Response response = controller.authorize(requestContext(null), CLIENT_ID, CALLBACK_URI, "code", "openid phone",+ null, provider, "s1", null, null, null);++ assertEquals(302, response.getStatus());+ assertEquals(CALLBACK_URI + "?error_description=invalid_scope&state=s1&error=invalid_request",+ response.getHeaderString("Location"));+ }+ Response withoutState = controller.authorize(requestContext(null), CLIENT_ID, CALLBACK_URI, "code",+ "aws.cognito.signin.user.admin", null, null, null, null, null, null);+ assertEquals(CALLBACK_URI + "?error_description=invalid_scope&error=invalid_request",+ withoutState.getHeaderString("Location"));+ verify(federationService, never()).beginAuthorization(any(), any(), any(), any(), any(), any(), any(), any(),+ any());+ }++ /**+ * Federation asks the provider for what the request named, its {@code authorize_scopes} aside, as+ * before; the grant governs only Cognito's own code. A request without a scope therefore asks the+ * provider for none, while its code is granted every scope the client allows.+ */+ @Test+ void authorizeWithoutAScopeAsksTheProviderForNoneWhileTheCodeGetsEveryAllowedScope() throws Exception {+ IdentityProvider provider = new IdentityProvider();+ provider.setUserPoolId(POOL_ID);+ provider.setProviderName("ExampleOidc");+ provider.setProviderType("OIDC");+ provider.setProviderDetails(Map.of("authorize_url", "https://provider.example.test/authorize",+ "client_id", "provider-client"));+ when(cognitoService.describeIdentityProvider(POOL_ID, "ExampleOidc")).thenReturn(provider);+ when(cognitoService.getIdentityProviderCallbackEndpoint(POOL_ID))+ .thenReturn("http://localhost:4566/cognito-idp/oauth2/idpresponse");+ when(cognitoService.provisionFederatedUser(eq(POOL_ID), eq(provider), eq("provider-subject"), any(), any()))+ .thenReturn(user());+ CognitoOidcClient oidcClient = mock(CognitoOidcClient.class);+ when(oidcClient.exchangeCode(eq(provider), eq("provider-code"), any()))+ .thenReturn(objectMapper.readTree("{\"access_token\":\"provider-access-token\"}"));+ when(oidcClient.fetchClaims(provider, "provider-access-token"))+ .thenReturn(objectMapper.readTree("{\"sub\":\"provider-subject\"}"));+ CognitoOAuthController federating = new CognitoOAuthController(cognitoService, objectMapper,+ new CognitoFederationService(cognitoService, stateStore, oidcClient, CLOCK), stateStore,+ new CognitoManagedLoginService(cognitoService, stateStore, CLOCK));++ String toProvider = federating.authorize(requestContext(null), CLIENT_ID, CALLBACK_URI, "code", null, null,+ "ExampleOidc", "s1", null, null, null).getHeaderString("Location");+ String toCallback = federating.idpResponse(requestContext(null), queryParameter(toProvider, "state"),+ "provider-code", null, null).getHeaderString("Location");++ assertTrue(toProvider.startsWith("https://provider.example.test/authorize?"), toProvider);+ assertEquals("", queryParameter(toProvider, "scope"));+ assertEquals(List.of("openid", "email"), storedCode(toCallback).scopes());+ }++ @Test+ void authorizeWithASessionBindsTheCodeToTheScopesGrantedThen() {+ when(cognitoService.adminGetUser(POOL_ID, "session-user")).thenReturn(user("session-user"));+ String sessionId = stateStore.putSession(new CognitoManagedLoginSession(POOL_ID, "session-user",+ CLOCK.instant().plusSeconds(60)));++ String withoutScope = controller.authorize(requestContext(null), CLIENT_ID, CALLBACK_URI, "code", null, null,+ null, null, null, null, sessionId).getHeaderString("Location");+ String withScope = controller.authorize(requestContext(null), CLIENT_ID, CALLBACK_URI, "code", "email email",+ null, null, null, null, null, sessionId).getHeaderString("Location");++ assertEquals(List.of("openid", "email"), storedCode(withoutScope).scopes());+ assertEquals(List.of("email"), storedCode(withScope).scopes());+ }+@Testvoid authorizeWithASessionOfThePoolRedirectsWithACodeCarryingTheNonceAndChallenge() {when(cognitoService.adminGetUser(POOL_ID, "session-user")).thenReturn(user("session-user"));@@ -259,6 +334,21 @@ class CognitoOAuthControllerTest {assertOAuthError(replay, "invalid_grant");}+ /** AWS leaves {@code id_token} out of the response, rather than sending it as null, without openid. */+ @Test+ void tokenLeavesTheIdTokenOutWhenNoneWasMinted() {+ String code = putAuthorizationCode();+ when(cognitoService.generateAuthResultForHostedAuth(any(CognitoUser.class), any(UserPool.class), eq(client), eq(null), any()))+ .thenReturn(Map.of("AccessToken", "access-token", "RefreshToken", "refresh-token",+ "ExpiresIn", 3600, "TokenType", "Bearer"));++ Response response = controller.token(null, requestContext(null), validAuthorizationCodeForm(code));++ assertEquals(200, response.getStatus());+ JsonNode body = (JsonNode) response.getEntity();+ assertEquals(List.of("access_token", "refresh_token", "expires_in", "token_type"), fieldNames(body));+ }+@Testvoid tokenRejectsAuthorizationCodeForAnotherClient() {String code = stateStore.putAuthorizationCode(new CognitoAuthorizationCode(@@ -421,7 +511,7 @@ class CognitoOAuthControllerTest {assertEquals(200, response.getStatus());verify(cognitoService).generateAuthResultForHostedAuth(any(CognitoUser.class), any(UserPool.class), eq(client),any(), scopes.capture());- assertEquals(List.of("openid"), scopes.getValue(), "the code's requested scopes reach the trigger");+ assertEquals(List.of("openid"), scopes.getValue(), "the code's granted scopes reach the trigger");verify(cognitoService, never()).generateAuthResult(any(CognitoUser.class), any(UserPool.class), any(), any());}@@ -466,6 +556,7 @@ class CognitoOAuthControllerTest {result.setUserPoolId(POOL_ID);result.setAllowedOAuthFlowsUserPoolClient(true);result.setAllowedOAuthFlows(List.of("code"));+ result.setAllowedOAuthScopes(List.of("openid", "email"));result.setCallbackURLs(List.of(CALLBACK_URI));result.setSupportedIdentityProviders(List.of("COGNITO"));return result;@@ -507,6 +598,29 @@ class CognitoOAuthControllerTest {return "Basic " + Base64.getEncoder().encodeToString(credentials.getBytes(StandardCharsets.UTF_8));}+ /** The code a redirect to the callback carries, as the state store holds it. */+ private CognitoAuthorizationCode storedCode(String location) {+ assertTrue(location.startsWith(CALLBACK_URI + "?code="), location);+ return stateStore.findAuthorizationCode(queryParameter(location, "code")).orElseThrow();+ }++ /** A query parameter of {@code location}, decoded, or null when it has none of that name. */+ private static String queryParameter(String location, String name) {+ for (String pair : URI.create(location).getRawQuery().split("&")) {+ String[] parts = pair.split("=", 2);+ if (parts[0].equals(name)) {+ return parts.length == 2 ? URLDecoder.decode(parts[1], StandardCharsets.UTF_8) : "";+ }+ }+ return null;+ }++ private static List<String> fieldNames(JsonNode body) {+ List<String> names = new ArrayList<>();+ body.fieldNames().forEachRemaining(names::add);+ return names;+ }+private void assertOAuthError(Response response, String error) {assertEquals(400, response.getStatus());assertNotNull(response.getEntity());