Light, fluffy, and always free - The AWS Local Emulator alternative
feat(cognito): support software-token MFA setup and challenges (#4620)
XuJian433893d29833
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoTotpMfaTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoTotpMfaTest.javanew file mode 100644index 0000000000..e3653385cb--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoTotpMfaTest.java@@ -0,0 +1,116 @@+package com.floci.test;++import org.junit.jupiter.api.Test;+import software.amazon.awssdk.services.cognitoidentityprovider.CognitoIdentityProviderClient;+import software.amazon.awssdk.services.cognitoidentityprovider.model.AssociateSoftwareTokenResponse;+import software.amazon.awssdk.services.cognitoidentityprovider.model.AuthFlowType;+import software.amazon.awssdk.services.cognitoidentityprovider.model.ChallengeNameType;+import software.amazon.awssdk.services.cognitoidentityprovider.model.CreateUserPoolResponse;+import software.amazon.awssdk.services.cognitoidentityprovider.model.ExplicitAuthFlowsType;+import software.amazon.awssdk.services.cognitoidentityprovider.model.InitiateAuthResponse;+import software.amazon.awssdk.services.cognitoidentityprovider.model.MessageActionType;+import software.amazon.awssdk.services.cognitoidentityprovider.model.RespondToAuthChallengeResponse;+import software.amazon.awssdk.services.cognitoidentityprovider.model.UserPoolMfaType;+import software.amazon.awssdk.services.cognitoidentityprovider.model.VerifySoftwareTokenResponse;++import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;+import java.nio.ByteBuffer;+import java.time.Instant;+import java.util.Locale;+import java.util.Map;+import java.util.UUID;++import static org.assertj.core.api.Assertions.assertThat;++class CognitoTotpMfaTest {+ private static final String USERNAME = "totp-sdk-user";+ private static final String PASSWORD = "SdkTotp123!";++ @Test+ void sdkCompletesSetupAndLaterSoftwareTokenChallenges() throws Exception {+ try (CognitoIdentityProviderClient cognito = TestFixtures.cognitoClient()) {+ CreateUserPoolResponse created = cognito.createUserPool(b -> b+ .poolName("totp-sdk-" + UUID.randomUUID()));+ String poolId = created.userPool().id();+ try {+ cognito.setUserPoolMfaConfig(b -> b.userPoolId(poolId)+ .mfaConfiguration(UserPoolMfaType.ON)+ .softwareTokenMfaConfiguration(m -> m.enabled(true)));+ String clientId = cognito.createUserPoolClient(b -> b.userPoolId(poolId)+ .clientName("totp-sdk-client")+ .explicitAuthFlows(ExplicitAuthFlowsType.ALLOW_USER_PASSWORD_AUTH))+ .userPoolClient().clientId();+ cognito.adminCreateUser(b -> b.userPoolId(poolId).username(USERNAME)+ .messageAction(MessageActionType.SUPPRESS));+ cognito.adminSetUserPassword(b -> b.userPoolId(poolId).username(USERNAME)+ .password(PASSWORD).permanent(true));++ InitiateAuthResponse first = passwordLogin(cognito, clientId);+ assertThat(first.challengeName()).isEqualTo(ChallengeNameType.MFA_SETUP);+ assertThat(first.authenticationResult()).isNull();+ assertThat(first.challengeParameters().get("MFAS_CAN_SETUP"))+ .contains("SOFTWARE_TOKEN_MFA");++ AssociateSoftwareTokenResponse associated = cognito.associateSoftwareToken(+ b -> b.session(first.session()));+ assertThat(associated.secretCode()).matches("[A-Z2-7]{32}");+ String setupCode = totp(associated.secretCode(), Instant.now());+ VerifySoftwareTokenResponse verified = cognito.verifySoftwareToken(b -> b+ .session(associated.session())+ .userCode(setupCode));+ assertThat(verified.statusAsString()).isEqualTo("SUCCESS");++ RespondToAuthChallengeResponse completed = cognito.respondToAuthChallenge(b -> b+ .clientId(clientId).challengeName(ChallengeNameType.MFA_SETUP)+ .session(verified.session())+ .challengeResponses(Map.of("USERNAME", USERNAME)));+ assertThat(completed.authenticationResult().accessToken()).isNotBlank();++ InitiateAuthResponse later = passwordLogin(cognito, clientId);+ assertThat(later.challengeName()).isEqualTo(ChallengeNameType.SOFTWARE_TOKEN_MFA);+ assertThat(later.authenticationResult()).isNull();+ String signInCode = totp(associated.secretCode(), Instant.now());+ RespondToAuthChallengeResponse signedIn = cognito.respondToAuthChallenge(b -> b+ .clientId(clientId).challengeName(ChallengeNameType.SOFTWARE_TOKEN_MFA)+ .session(later.session())+ .challengeResponses(Map.of("USERNAME", USERNAME,+ "SOFTWARE_TOKEN_MFA_CODE", signInCode)));+ assertThat(signedIn.authenticationResult().accessToken()).isNotBlank();+ } finally {+ cognito.deleteUserPool(b -> b.userPoolId(poolId));+ }+ }+ }++ private static InitiateAuthResponse passwordLogin(CognitoIdentityProviderClient cognito, String clientId) {+ return cognito.initiateAuth(b -> b.clientId(clientId)+ .authFlow(AuthFlowType.USER_PASSWORD_AUTH)+ .authParameters(Map.of("USERNAME", USERNAME, "PASSWORD", PASSWORD)));+ }++ private static String totp(String secret, Instant now) throws Exception {+ byte[] key = new byte[secret.length() * 5 / 8];+ int buffer = 0;+ int bits = 0;+ int index = 0;+ for (int i = 0; i < secret.length(); i++) {+ buffer = (buffer << 5) | "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567".indexOf(secret.charAt(i));+ bits += 5;+ if (bits >= 8) {+ key[index++] = (byte) (buffer >>> (bits - 8));+ bits -= 8;+ }+ }+ Mac mac = Mac.getInstance("HmacSHA1");+ mac.init(new SecretKeySpec(key, "HmacSHA1"));+ byte[] digest = mac.doFinal(ByteBuffer.allocate(Long.BYTES)+ .putLong(now.getEpochSecond() / 30).array());+ int offset = digest[digest.length - 1] & 15;+ int binary = ((digest[offset] & 127) << 24)+ | ((digest[offset + 1] & 255) << 16)+ | ((digest[offset + 2] & 255) << 8)+ | (digest[offset + 3] & 255);+ return String.format(Locale.ROOT, "%06d", binary % 1_000_000);+ }+}diff --git a/docs/services/cognito.md b/docs/services/cognito.mdindex f542bacbaa..9bb07891d9 100644--- a/docs/services/cognito.md+++ b/docs/services/cognito.md@@ -199,7 +199,21 @@ further divergences, both deliberate:|--------|-------------|| InitiateAuth | Authenticates app-client users through supported user-password and SRP-style flows. || AdminInitiateAuth | Starts an admin authentication flow for a user pool user. |-| RespondToAuthChallenge | Responds to supported Cognito auth challenges. |+| RespondToAuthChallenge | Responds to supported Cognito auth challenges, including TOTP setup and software-token MFA. |+| AssociateSoftwareToken | Creates a TOTP secret for a user identified by an MFA setup session or access token. |+| VerifySoftwareToken | Verifies the TOTP code and enables the user's software token. |++With `MfaConfiguration=ON` and software-token MFA enabled, a successful password or SRP+first factor returns `MFA_SETUP` instead of tokens for a user without a verified token.+Call `AssociateSoftwareToken` with that session, then `VerifySoftwareToken` with the+returned session and a six-digit TOTP code. Finish with `RespondToAuthChallenge`+(`MFA_SETUP`) to receive tokens. Later sign-ins return `SOFTWARE_TOKEN_MFA`, which+requires a fresh code in `SOFTWARE_TOKEN_MFA_CODE`. Both token-management actions+also accept an access token for an already authenticated user. Sessions expire with+the app client's `AuthSessionValidity` and cannot be replayed after completion.++This flow currently covers software-token MFA required by a pool. Optional MFA+preferences, SMS/email MFA challenges, and managed-login MFA are not emulated.### User Listingdiff --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 ef7e7dc1a3..eb0538fd04 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@@ -30,6 +30,7 @@ import java.util.Map;import java.util.UUID;import java.util.concurrent.ConcurrentHashMap;import java.util.concurrent.ThreadLocalRandom;+import java.util.concurrent.atomic.AtomicInteger;import java.util.function.Function;/**@@ -60,6 +61,7 @@ final class CognitoAuthFlowHandler {private final Clock clock;private final ConcurrentHashMap<String, SrpSession> srpSessions = new ConcurrentHashMap<>();private final ConcurrentHashMap<String, CustomAuthToken> customAuthSessions = new ConcurrentHashMap<>();+ private final ConcurrentHashMap<String, TotpSession> totpSessions = new ConcurrentHashMap<>();private final Object userAuthSessionLock = new Object();private final LinkedHashMap<String, UserAuthSession> userAuthSessions = new LinkedHashMap<>();private final LinkedHashMap<String, UserAuthSession> simulatedUserAuthSessions = new LinkedHashMap<>();@@ -69,6 +71,13 @@ final class CognitoAuthFlowHandler {String secretBlockBase64, Map<String, String> clientMetadata,Instant expiresAt) {}+ private enum TotpPhase { SETUP, ASSOCIATED, VERIFIED, CODE_REQUIRED }++ private record TotpSession(String userPoolId, String username, String clientId,+ TotpPhase phase, Map<String, String> clientMetadata,+ String triggerSource, Instant expiresAt, String secret,+ AtomicInteger failedAttempts) {}+/*** Correlates a USER_AUTH challenge response back to the InitiateAuth/RespondToAuthChallenge* call that issued it, the same way {@link SrpSession} and {@link CustomAuthSession} do for@@ -279,12 +288,148 @@ final class CognitoAuthFlowHandler {return processChallenge(pool, client, challengeName, session, responses, clientMetadata);}+ Map<String, Object> associateSoftwareToken(String accessToken, String session) {+ requireOneTotpCredential(accessToken, session);+ String poolId;+ String username;+ TotpSession state = null;+ if (session != null) {+ state = requireTotpSession(session, TotpPhase.SETUP);+ poolId = state.userPoolId();+ username = state.username();+ } else {+ CognitoService.VerifiedAccessToken token = service.verifyAccessToken(accessToken);+ service.requireScope(accessToken, "aws.cognito.signin.user.admin");+ poolId = token.poolId();+ username = token.username();+ }+ UserPool pool = service.describeUserPool(poolId);+ if (!Boolean.TRUE.equals(pool.getSoftwareTokenMfaEnabled())) {+ throw new AwsException("SoftwareTokenMFANotFoundException",+ "Software token MFA is not enabled for this user pool", 400);+ }+ String secret = CognitoTotp.newSecret();+ if (state != null && !totpSessions.remove(session, state)) {+ throw new AwsException("NotAuthorizedException", "Session not found", 400);+ }+ service.beginSoftwareTokenMfa(poolId, username, secret);+ Map<String, Object> result = new HashMap<>();+ result.put("SecretCode", secret);+ if (state != null) {+ result.put("Session", issueTotpSession(state.userPoolId(), state.username(), state.clientId(),+ TotpPhase.ASSOCIATED, state.clientMetadata(), state.triggerSource(), state.expiresAt(), secret));+ }+ return result;+ }++ Map<String, Object> verifySoftwareToken(String accessToken, String session, String userCode) {+ requireOneTotpCredential(accessToken, session);+ if (userCode == null || !userCode.matches("[0-9]{6}")) {+ throw new AwsException("InvalidParameterException", "UserCode must be a six-digit code", 400);+ }+ String poolId;+ String username;+ TotpSession state = null;+ if (session != null) {+ state = requireTotpSession(session, TotpPhase.ASSOCIATED);+ poolId = state.userPoolId();+ username = state.username();+ } else {+ CognitoService.VerifiedAccessToken token = service.verifyAccessToken(accessToken);+ service.requireScope(accessToken, "aws.cognito.signin.user.admin");+ poolId = token.poolId();+ username = token.username();+ }+ if (!service.activateSoftwareTokenMfa(poolId, username, state == null ? null : state.secret(),+ userCode, clock.instant())) {+ throw new AwsException("CodeMismatchException",+ "Invalid verification code provided, please try again.", 400);+ }+ Map<String, Object> result = new HashMap<>();+ result.put("Status", "SUCCESS");+ if (state != null) {+ totpSessions.remove(session, state);+ result.put("Session", issueTotpSession(state.userPoolId(), state.username(), state.clientId(),+ TotpPhase.VERIFIED, state.clientMetadata(), state.triggerSource(), state.expiresAt(),+ state.secret()));+ }+ return result;+ }++ private static void requireOneTotpCredential(String accessToken, String session) {+ if ((accessToken == null) == (session == null)) {+ throw new AwsException("InvalidParameterException", "Provide either AccessToken or Session", 400);+ }+ }++ private String issueTotpSession(String poolId, String username, String clientId, TotpPhase phase,+ Map<String, String> metadata, String triggerSource, Instant expiresAt,+ String secret) {+ purgeExpired(totpSessions, TotpSession::expiresAt);+ String token = buildSessionToken(poolId, username, clientId);+ totpSessions.put(token, new TotpSession(poolId, username, clientId, phase, metadata, triggerSource,+ expiresAt, secret, new AtomicInteger()));+ return token;+ }++ private TotpSession requireTotpSession(String session, TotpPhase phase) {+ TotpSession state = session == null ? null : totpSessions.get(session);+ if (state == null || state.phase() != phase) {+ throw new AwsException("NotAuthorizedException", "Session not found", 400);+ }+ if (sessionExpired(state.expiresAt())) {+ totpSessions.remove(session, state);+ throw sessionExpiredException();+ }+ return state;+ }++ private Map<String, Object> handleTotpChallenge(UserPool pool, UserPoolClient client, String challengeName,+ String session, Map<String, String> responses,+ Map<String, String> clientMetadata) {+ TotpPhase phase = "MFA_SETUP".equals(challengeName) ? TotpPhase.VERIFIED : TotpPhase.CODE_REQUIRED;+ TotpSession state = requireTotpSession(session, phase);+ if (!pool.getId().equals(state.userPoolId()) || !client.getClientId().equals(state.clientId())) {+ throw new AwsException("NotAuthorizedException", "Session does not match client", 400);+ }+ String username = responses.get("USERNAME");+ if (username == null || !username.equals(state.username())) {+ throw new AwsException("NotAuthorizedException", "Session does not match user", 400);+ }+ validateSecretHash(client, responses, username);+ CognitoUser user = service.adminGetUser(pool.getId(), username);+ requireSignInEligible(user);+ synchronized (state) {+ if (phase == TotpPhase.VERIFIED) {+ if (!state.secret().equals(user.getSoftwareTokenMfaSecret())) {+ throw new AwsException("NotAuthorizedException", "Software token is not verified", 400);+ }+ } else if (!state.secret().equals(user.getSoftwareTokenMfaSecret())+ || !CognitoTotp.validCode(state.secret(),+ responses.get("SOFTWARE_TOKEN_MFA_CODE"), clock.instant())) {+ if (state.failedAttempts().incrementAndGet() >= CognitoTotp.MAX_FAILED_ATTEMPTS) {+ totpSessions.remove(session, state);+ }+ throw new AwsException("CodeMismatchException", "Invalid verification code provided, please try again.", 400);+ }+ if (!totpSessions.remove(session, state)) {+ throw new AwsException("NotAuthorizedException", "Session not found", 400);+ }+ }+ Map<String, String> metadata = clientMetadata != null && !clientMetadata.isEmpty()+ ? clientMetadata : state.clientMetadata();+ return authenticationResult(pool, client, user, state.triggerSource(), metadata);+ }+private Map<String, Object> processChallenge(UserPool pool, UserPoolClient client, String challengeName,String session, Map<String, String> responses,Map<String, String> clientMetadata) {if ("PASSWORD_VERIFIER".equals(challengeName)) {return handlePasswordVerifierChallenge(pool, client, session, responses, clientMetadata);}+ if ("MFA_SETUP".equals(challengeName) || "SOFTWARE_TOKEN_MFA".equals(challengeName)) {+ return handleTotpChallenge(pool, client, challengeName, session, responses, clientMetadata);+ }if ("CUSTOM_CHALLENGE".equals(challengeName)) {return handleCustomChallenge(pool, client, session, responses, clientMetadata);}@@ -321,10 +466,7 @@ final class CognitoAuthFlowHandler {service.adminUpdateUserAttributes(pool.getId(), username, attrUpdates);}CognitoUser user = service.adminGetUser(pool.getId(), username);- Map<String, Object> result = new HashMap<>();- result.put("AuthenticationResult",- issueTokens(pool, client, user, "TokenGeneration_NewPasswordChallenge", clientMetadata));- return result;+ return completePrimaryAuth(pool, client, user, "TokenGeneration_NewPasswordChallenge", clientMetadata);}throw new AwsException("InvalidParameterException", "Unsupported challenge: " + challengeName, 400);}@@ -345,10 +487,7 @@ final class CognitoAuthFlowHandler {return buildNewPasswordRequiredChallenge(pool, client, user);}- Map<String, Object> result = new HashMap<>();- result.put("AuthenticationResult",- issueTokens(pool, client, user, "TokenGeneration_Authentication", clientMetadata));- return result;+ return completePrimaryAuth(pool, client, user, "TokenGeneration_Authentication", clientMetadata);}/**@@ -584,6 +723,9 @@ final class CognitoAuthFlowHandler {srpSessions.remove(session);throw sessionExpiredException();}+ if (!pool.getId().equals(srp.userPoolId()) || !client.getClientId().equals(srp.clientId())) {+ throw new AwsException("NotAuthorizedException", "Session does not match client", 400);+ }String username = responses.get("USERNAME");String claimSignature = responses.get("PASSWORD_CLAIM_SIGNATURE");@@ -592,6 +734,9 @@ final class CognitoAuthFlowHandler {throw new AwsException("InvalidParameterException","USERNAME, PASSWORD_CLAIM_SIGNATURE and TIMESTAMP are required", 400);}+ if (!username.equals(srp.username())) {+ throw new AwsException("NotAuthorizedException", "Session does not match user", 400);+ }validateSecretHash(client, responses, username);CognitoUser user = service.adminGetUser(pool.getId(), username);@@ -620,10 +765,7 @@ final class CognitoAuthFlowHandler {return buildNewPasswordRequiredChallenge(pool, client, user);}- Map<String, Object> result = new HashMap<>();- result.put("AuthenticationResult",- issueTokens(pool, client, user, "TokenGeneration_Authentication", effectiveMetadata));- return result;+ return completePrimaryAuth(pool, client, user, "TokenGeneration_Authentication", effectiveMetadata);}// ──────────────────────────── USER_AUTH (choice-based) ────────────────────────────@@ -760,10 +902,7 @@ final class CognitoAuthFlowHandler {if (user.isTemporaryPassword() || "FORCE_CHANGE_PASSWORD".equals(user.getUserStatus())) {return buildNewPasswordRequiredChallenge(pool, client, user);}- Map<String, Object> result = new HashMap<>();- result.put("AuthenticationResult",- issueTokens(pool, client, user, "TokenGeneration_Authentication", clientMetadata));- return result;+ return completePrimaryAuth(pool, client, user, "TokenGeneration_Authentication", clientMetadata);}/**@@ -1064,10 +1203,7 @@ final class CognitoAuthFlowHandler {}if (Boolean.TRUE.equals(defineResp.get("issueTokens"))) {customAuthSessions.remove(session);- Map<String, Object> result = new HashMap<>();- result.put("AuthenticationResult",- issueTokens(pool, client, user, "TokenGeneration_Authentication", state.clientMetadata));- return result;+ return completePrimaryAuth(pool, client, user, "TokenGeneration_Authentication", state.clientMetadata);}String nextChallenge = (String) defineResp.getOrDefault("challengeName", "CUSTOM_CHALLENGE");@@ -1534,6 +1670,36 @@ final class CognitoAuthFlowHandler {}}+ private Map<String, Object> completePrimaryAuth(UserPool pool, UserPoolClient client, CognitoUser user,+ String triggerSource, Map<String, String> clientMetadata) {+ if (!"ON".equals(pool.getMfaConfiguration())+ || !Boolean.TRUE.equals(pool.getSoftwareTokenMfaEnabled())) {+ return authenticationResult(pool, client, user, triggerSource, clientMetadata);+ }+ TotpPhase phase = user.getSoftwareTokenMfaSecret() == null+ ? TotpPhase.SETUP : TotpPhase.CODE_REQUIRED;+ String challengeName = phase == TotpPhase.SETUP ? "MFA_SETUP" : "SOFTWARE_TOKEN_MFA";+ Map<String, Object> result = new HashMap<>();+ result.put("ChallengeName", challengeName);+ result.put("Session", issueTotpSession(pool.getId(), user.getUsername(), client.getClientId(),+ phase, clientMetadata == null ? Map.of() : Map.copyOf(clientMetadata), triggerSource,+ sessionExpiry(client, clock.instant()), user.getSoftwareTokenMfaSecret()));+ Map<String, String> parameters = new HashMap<>();+ parameters.put("USERNAME", user.getUsername());+ if (phase == TotpPhase.SETUP) {+ parameters.put("MFAS_CAN_SETUP", "[\"SOFTWARE_TOKEN_MFA\"]");+ }+ result.put("ChallengeParameters", parameters);+ return result;+ }++ private Map<String, Object> authenticationResult(UserPool pool, UserPoolClient client, CognitoUser user,+ String triggerSource, Map<String, String> clientMetadata) {+ Map<String, Object> result = new HashMap<>();+ result.put("AuthenticationResult", issueTokens(pool, client, user, triggerSource, clientMetadata));+ return result;+ }+private Map<String, Object> issueTokens(UserPool pool, UserPoolClient client, CognitoUser user,String triggerSource, Map<String, String> clientMetadata) {firePostAuthentication(pool, client, user, clientMetadata, false);diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.javaindex 4cdf38c8cf..c178a9e264 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoJsonHandler.java@@ -95,6 +95,8 @@ public class CognitoJsonHandler {case "AdminInitiateAuth" -> handleAdminInitiateAuth(request);case "RespondToAuthChallenge" -> handleRespondToAuthChallenge(request);case "AdminRespondToAuthChallenge" -> handleAdminRespondToAuthChallenge(request);+ case "AssociateSoftwareToken" -> handleAssociateSoftwareToken(request);+ case "VerifySoftwareToken" -> handleVerifySoftwareToken(request);case "SignUp" -> handleSignUp(request);case "ConfirmSignUp" -> handleConfirmSignUp(request);case "ResendConfirmationCode" -> handleResendConfirmationCode(request);@@ -916,6 +918,19 @@ public class CognitoJsonHandler {return Response.ok(objectMapper.valueToTree(result)).build();}+ private Response handleAssociateSoftwareToken(JsonNode request) {+ Map<String, Object> result = service.associateSoftwareToken(+ request.path("AccessToken").asText(null), request.path("Session").asText(null));+ return Response.ok(objectMapper.valueToTree(result)).build();+ }++ private Response handleVerifySoftwareToken(JsonNode request) {+ Map<String, Object> result = service.verifySoftwareToken(+ request.path("AccessToken").asText(null), request.path("Session").asText(null),+ request.path("UserCode").asText(null));+ return Response.ok(objectMapper.valueToTree(result)).build();+ }+private Response handleSignUp(JsonNode request) {Map<String, String> attrs = new HashMap<>();request.path("UserAttributes").forEach(a -> attrs.put(a.path("Name").asText(), a.path("Value").asText()));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 f53bbcbbe7..3731c157e1 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@@ -2943,6 +2943,54 @@ public class CognitoService implements ResourceProvider {return authFlowHandler.adminRespondToAuthChallenge(userPoolId, clientId, challengeName, session, responses, clientMetadata);}+ public Map<String, Object> associateSoftwareToken(String accessToken, String session) {+ return authFlowHandler.associateSoftwareToken(accessToken, session);+ }++ public Map<String, Object> verifySoftwareToken(String accessToken, String session, String userCode) {+ return authFlowHandler.verifySoftwareToken(accessToken, session, userCode);+ }++ void beginSoftwareTokenMfa(String poolId, String username, String secret) {+ synchronized (userLock(poolId, username)) {+ CognitoUser user = adminGetUser(poolId, username);+ user.setPendingSoftwareTokenMfaSecret(secret);+ user.setPendingSoftwareTokenMfaAttemptsRemaining(CognitoTotp.MAX_FAILED_ATTEMPTS);+ user.setLastModifiedDate(System.currentTimeMillis() / 1000L);+ userStore.put(userKey(poolId, user.getUsername()), user);+ }+ }++ boolean activateSoftwareTokenMfa(String poolId, String username, String expectedSecret,+ String code, Instant now) {+ synchronized (userLock(poolId, username)) {+ CognitoUser user = adminGetUser(poolId, username);+ String pending = user.getPendingSoftwareTokenMfaSecret();+ if (pending == null) {+ throw new AwsException("InvalidParameterException", "No software token is awaiting verification", 400);+ }+ if (expectedSecret != null && !expectedSecret.equals(pending)) {+ throw new AwsException("NotAuthorizedException", "Software token association has changed", 400);+ }+ Integer storedAttempts = user.getPendingSoftwareTokenMfaAttemptsRemaining();+ int attemptsRemaining = storedAttempts == null ? CognitoTotp.MAX_FAILED_ATTEMPTS : storedAttempts;+ if (attemptsRemaining <= 0) {+ return false;+ }+ if (!CognitoTotp.validCode(pending, code, now)) {+ user.setPendingSoftwareTokenMfaAttemptsRemaining(attemptsRemaining - 1);+ userStore.put(userKey(poolId, user.getUsername()), user);+ return false;+ }+ user.setSoftwareTokenMfaSecret(pending);+ user.setPendingSoftwareTokenMfaSecret(null);+ user.setPendingSoftwareTokenMfaAttemptsRemaining(null);+ user.setLastModifiedDate(System.currentTimeMillis() / 1000L);+ userStore.put(userKey(poolId, user.getUsername()), user);+ return true;+ }+ }+public void changePassword(String accessToken, String previousPassword, String proposedPassword) {VerifiedAccessToken token = verifyAccessToken(accessToken);String username = token.username();@@ -4534,7 +4582,7 @@ public class CognitoService implements ResourceProvider {* {@link #verifyAccessToken}, which already confirms the token is a valid, unexpired access* token; this only adds the scope check on top.*/- private void requireScope(String accessToken, String requiredScope) {+ void requireScope(String accessToken, String requiredScope) {Set<String> scopes = extractScopesFromToken(accessToken);if (scopes != null && !scopes.contains(requiredScope)) {throw new AwsException("NotAuthorizedException", "Access Token does not have the required scope", 400);diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoTotp.java b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoTotp.javanew file mode 100644index 0000000000..54b243a7fd--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/CognitoTotp.java@@ -0,0 +1,92 @@+package io.github.hectorvent.floci.services.cognito;++import java.nio.ByteBuffer;+import java.nio.charset.StandardCharsets;+import java.security.GeneralSecurityException;+import java.security.MessageDigest;+import java.security.SecureRandom;+import java.time.Instant;+import java.util.Locale;+import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;++final class CognitoTotp {+ // Match verification-code emulation; AWS does not publish an exact attempt threshold.+ static final int MAX_FAILED_ATTEMPTS = 5;+ private static final char[] BASE32 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567".toCharArray();+ private static final SecureRandom RANDOM = new SecureRandom();++ private CognitoTotp() {}++ static String newSecret() {+ byte[] bytes = new byte[20];+ RANDOM.nextBytes(bytes);+ StringBuilder encoded = new StringBuilder(32);+ int buffer = 0;+ int bits = 0;+ for (byte value : bytes) {+ buffer = (buffer << 8) | (value & 0xff);+ bits += 8;+ while (bits >= 5) {+ encoded.append(BASE32[(buffer >>> (bits - 5)) & 31]);+ bits -= 5;+ }+ }+ return encoded.toString();+ }++ static boolean validCode(String secret, String code, Instant now) {+ if (secret == null || code == null || !code.matches("[0-9]{6}")) {+ return false;+ }+ byte[] key = decode(secret);+ long step = Math.floorDiv(now.getEpochSecond(), 30);+ for (long candidate = step - 1; candidate <= step + 1; candidate++) {+ byte[] expected = codeAt(key, candidate).getBytes(StandardCharsets.US_ASCII);+ if (MessageDigest.isEqual(expected, code.getBytes(StandardCharsets.US_ASCII))) {+ return true;+ }+ }+ return false;+ }++ static String code(String secret, Instant now) {+ return codeAt(decode(secret), Math.floorDiv(now.getEpochSecond(), 30));+ }++ private static String codeAt(byte[] key, long counter) {+ try {+ Mac mac = Mac.getInstance("HmacSHA1");+ mac.init(new SecretKeySpec(key, "HmacSHA1"));+ byte[] digest = mac.doFinal(ByteBuffer.allocate(Long.BYTES).putLong(counter).array());+ int offset = digest[digest.length - 1] & 15;+ int binary = ((digest[offset] & 127) << 24)+ | ((digest[offset + 1] & 255) << 16)+ | ((digest[offset + 2] & 255) << 8)+ | (digest[offset + 3] & 255);+ return String.format(Locale.ROOT, "%06d", binary % 1_000_000);+ } catch (GeneralSecurityException e) {+ throw new IllegalStateException("TOTP HMAC is unavailable", e);+ }+ }++ private static byte[] decode(String secret) {+ byte[] decoded = new byte[secret.length() * 5 / 8];+ int buffer = 0;+ int bits = 0;+ int index = 0;+ for (int i = 0; i < secret.length(); i++) {+ int value = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567".indexOf(secret.charAt(i));+ if (value < 0) {+ throw new IllegalArgumentException("Invalid TOTP secret");+ }+ buffer = (buffer << 5) | value;+ bits += 5;+ if (bits >= 8) {+ decoded[index++] = (byte) (buffer >>> (bits - 8));+ bits -= 8;+ }+ }+ return decoded;+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoUser.java b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoUser.javaindex e765d42785..554f89955f 100644--- a/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoUser.java+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/model/CognitoUser.java@@ -26,6 +26,9 @@ public class CognitoUser {private String srpSalt;private String srpVerifier;private EmailMfaSettings emailMfaSettings;+ private String softwareTokenMfaSecret;+ private String pendingSoftwareTokenMfaSecret;+ private Integer pendingSoftwareTokenMfaAttemptsRemaining;private String federatedProviderName;private String federatedSubject;@@ -92,6 +95,17 @@ public class CognitoUser {this.emailMfaSettings = emailMfaSettings;}+ public String getSoftwareTokenMfaSecret() { return softwareTokenMfaSecret; }+ public void setSoftwareTokenMfaSecret(String secret) { this.softwareTokenMfaSecret = secret; }++ public String getPendingSoftwareTokenMfaSecret() { return pendingSoftwareTokenMfaSecret; }+ public void setPendingSoftwareTokenMfaSecret(String secret) { this.pendingSoftwareTokenMfaSecret = secret; }++ public Integer getPendingSoftwareTokenMfaAttemptsRemaining() { return pendingSoftwareTokenMfaAttemptsRemaining; }+ public void setPendingSoftwareTokenMfaAttemptsRemaining(Integer attempts) {+ this.pendingSoftwareTokenMfaAttemptsRemaining = attempts;+ }+public String getFederatedProviderName() {return federatedProviderName;}diff --git a/src/main/resources/application.yml b/src/main/resources/application.ymlindex 5962d97796..d95acfcc97 100644--- a/src/main/resources/application.yml+++ b/src/main/resources/application.yml@@ -100,6 +100,7 @@ quarkus:- --initialize-at-run-time=io.github.hectorvent.floci.services.acm.CertificateGenerator- --initialize-at-run-time=io.github.hectorvent.floci.config.TlsConfigSource- --initialize-at-run-time=io.github.hectorvent.floci.services.cognito.CognitoSrpHelper+ - --initialize-at-run-time=io.github.hectorvent.floci.services.cognito.CognitoTotp- --initialize-at-run-time=io.github.hectorvent.floci.services.route53.Route53Service- --initialize-at-run-time=io.github.hectorvent.floci.services.kms.KmsService- --initialize-at-run-time=io.github.hectorvent.floci.services.bedrockagentcore.BedrockAgentCoreEventServicediff --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 8c040a90ac..f7476ffcaa 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@@ -28,14 +28,14 @@ import org.junit.jupiter.params.provider.NullAndEmptySource;import org.junit.jupiter.params.provider.ValueSource;import org.mockito.ArgumentCaptor;-import javax.crypto.Mac;-import javax.crypto.spec.SecretKeySpec;import java.nio.charset.StandardCharsets;import java.time.Duration;import java.util.Base64;import java.util.HashMap;import java.util.List;import java.util.Map;+import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertFalse;@@ -491,6 +491,37 @@ class CognitoLambdaTriggersTest {// PreTokenGeneration// =========================================================================+ @Test+ void newPasswordMfaSetupPreservesPreTokenGenerationSource() throws Exception {+ MutableClock clock = new MutableClock();+ service = serviceWithClock(clock);+ UserPool pool = createPoolWithLambdaConfig(Map.of("PreTokenGeneration", "arn:aws:lambda:::pre-token"));+ service.adminCreateUser(pool.getId(), "alice", Map.of("email", "[email protected]"), "Temp1234!");+ service.setUserPoolMfaConfig(pool.getId(), "ON", true, false);+ UserPoolClient client = createClient(pool);+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::pre-token"), any(byte[].class), any()))+ .thenReturn(ok(Map.of()));++ Map<String, Object> login = service.initiateAuth(client.getClientId(), "USER_PASSWORD_AUTH",+ Map.of("USERNAME", "alice", "PASSWORD", "Temp1234!"));+ assertEquals("NEW_PASSWORD_REQUIRED", login.get("ChallengeName"));+ Map<String, Object> setup = service.respondToAuthChallenge(client.getClientId(),+ "NEW_PASSWORD_REQUIRED", (String) login.get("Session"),+ Map.of("USERNAME", "alice", "NEW_PASSWORD", "Perm1234!"));+ assertEquals("MFA_SETUP", setup.get("ChallengeName"));+ Map<String, Object> associated = service.associateSoftwareToken(null, (String) setup.get("Session"));+ String code = CognitoTotp.code((String) associated.get("SecretCode"), clock.instant());+ Map<String, Object> verified = service.verifySoftwareToken(null, (String) associated.get("Session"), code);+ Map<String, Object> tokens = service.respondToAuthChallenge(client.getClientId(),+ "MFA_SETUP", (String) verified.get("Session"), Map.of("USERNAME", "alice"));+ assertNotNull(tokens.get("AuthenticationResult"));++ ArgumentCaptor<byte[]> payload = ArgumentCaptor.forClass(byte[].class);+ verify(lambdaService).invoke(anyString(), eq("arn:aws:lambda:::pre-token"), payload.capture(), any());+ Map<String, Object> event = MAPPER.readValue(payload.getValue(), new TypeReference<>() {});+ assertEquals("TokenGeneration_NewPasswordChallenge", event.get("triggerSource"));+ }+@Test@SuppressWarnings("unchecked")void preTokenGenerationAddsAndOverridesClaims() {@@ -984,6 +1015,30 @@ class CognitoLambdaTriggersTest {// CUSTOM_AUTH triggers (already covered indirectly; check triggerSource wiring)// =========================================================================+ @Test+ void customPasswordChallengeRequiresTotpBeforeIssuingTokens() {+ UserPool pool = createPoolWithLambdaConfig(Map.of(+ "DefineAuthChallenge", "arn:aws:lambda:::define",+ "CreateAuthChallenge", "arn:aws:lambda:::create"));+ seedUser(pool, "alice", "Perm1234!");+ service.setUserPoolMfaConfig(pool.getId(), "ON", true, false);+ UserPoolClient client = createClient(pool);+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::define"), any(byte[].class), any()))+ .thenReturn(ok(Map.of("challengeName", "PASSWORD_VERIFIER")))+ .thenReturn(ok(Map.of("issueTokens", true)));+ when(lambdaService.invoke(anyString(), eq("arn:aws:lambda:::create"), any(byte[].class), any()))+ .thenReturn(ok(Map.of()));++ Map<String, Object> started = service.initiateAuth(client.getClientId(), "CUSTOM_AUTH",+ Map.of("USERNAME", "alice"));+ assertEquals("PASSWORD_VERIFIER", started.get("ChallengeName"));+ Map<String, Object> completed = service.respondToAuthChallenge(client.getClientId(),+ "PASSWORD_VERIFIER", (String) started.get("Session"),+ Map.of("USERNAME", "alice", "ANSWER", "Perm1234!"));+ assertEquals("MFA_SETUP", completed.get("ChallengeName"));+ assertFalse(completed.containsKey("AuthenticationResult"));+ }+@Test@SuppressWarnings("unchecked")void customAuthInvokesDefineAndCreateChallengeTriggers() {diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoTotpMfaIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoTotpMfaIntegrationTest.javanew file mode 100644index 0000000000..7ddd0d7eb5--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoTotpMfaIntegrationTest.java@@ -0,0 +1,95 @@+package io.github.hectorvent.floci.services.cognito;++import com.fasterxml.jackson.databind.JsonNode;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;++import java.time.Clock;++import static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoAction;+import static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoJson;+import static org.hamcrest.Matchers.equalTo;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++@QuarkusTest+class CognitoTotpMfaIntegrationTest {+ @Inject+ Clock clock;++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void jsonProtocolRequiresTotpBeforeIssuingTokens() throws Exception {+ String poolId = cognitoJson("CreateUserPool", """+ {"PoolName":"TotpProtocolPool"}+ """).path("UserPool").path("Id").asText();+ cognitoJson("SetUserPoolMfaConfig", """+ {"UserPoolId":"%s","MfaConfiguration":"ON",+ "SoftwareTokenMfaConfiguration":{"Enabled":true}}+ """.formatted(poolId));+ String clientId = cognitoJson("CreateUserPoolClient", """+ {"UserPoolId":"%s","ClientName":"totp-protocol-client",+ "ExplicitAuthFlows":["ALLOW_USER_PASSWORD_AUTH","ALLOW_USER_SRP_AUTH"]}+ """.formatted(poolId)).path("UserPoolClient").path("ClientId").asText();+ cognitoJson("AdminCreateUser", """+ {"UserPoolId":"%s","Username":"totp-user","MessageAction":"SUPPRESS"}+ """.formatted(poolId));+ cognitoJson("AdminSetUserPassword", """+ {"UserPoolId":"%s","Username":"totp-user",+ "Password":"Perm1234!","Permanent":true}+ """.formatted(poolId));++ String loginRequest = """+ {"ClientId":"%s","AuthFlow":"USER_PASSWORD_AUTH",+ "AuthParameters":{"USERNAME":"totp-user","PASSWORD":"Perm1234!"}}+ """.formatted(clientId);+ JsonNode login = cognitoJson("InitiateAuth", loginRequest);+ assertEquals("MFA_SETUP", login.path("ChallengeName").asText());+ assertTrue(login.path("AuthenticationResult").isMissingNode());+ String firstSession = login.path("Session").asText();++ JsonNode associated = cognitoJson("AssociateSoftwareToken", """+ {"Session":"%s"}+ """.formatted(firstSession));+ assertTrue(associated.path("SecretCode").asText().matches("[A-Z2-7]{32}"));+ String code = CognitoTotp.code(associated.path("SecretCode").asText(), clock.instant());+ String wrongCode = code.equals("000000") ? "000001" : "000000";+ cognitoAction("VerifySoftwareToken", """+ {"Session":"%s","UserCode":"%s"}+ """.formatted(associated.path("Session").asText(), wrongCode))+ .then().statusCode(400).body("__type", equalTo("CodeMismatchException"));+ JsonNode verified = cognitoJson("VerifySoftwareToken", """+ {"Session":"%s","UserCode":"%s"}+ """.formatted(associated.path("Session").asText(), code));+ assertEquals("SUCCESS", verified.path("Status").asText());++ JsonNode completed = cognitoJson("RespondToAuthChallenge", """+ {"ClientId":"%s","ChallengeName":"MFA_SETUP","Session":"%s",+ "ChallengeResponses":{"USERNAME":"totp-user"}}+ """.formatted(clientId, verified.path("Session").asText()));+ assertFalse(completed.path("AuthenticationResult").path("AccessToken").asText().isEmpty());++ JsonNode later = cognitoJson("InitiateAuth", loginRequest);+ assertEquals("SOFTWARE_TOKEN_MFA", later.path("ChallengeName").asText());+ assertTrue(later.path("AuthenticationResult").isMissingNode());+ JsonNode signedIn = cognitoJson("RespondToAuthChallenge", """+ {"ClientId":"%s","ChallengeName":"SOFTWARE_TOKEN_MFA","Session":"%s",+ "ChallengeResponses":{"USERNAME":"totp-user","SOFTWARE_TOKEN_MFA_CODE":"%s"}}+ """.formatted(clientId, later.path("Session").asText(), code));+ assertFalse(signedIn.path("AuthenticationResult").path("AccessToken").asText().isEmpty());++ String replay = """+ {"ClientId":"%s","ChallengeName":"SOFTWARE_TOKEN_MFA","Session":"%s",+ "ChallengeResponses":{"USERNAME":"totp-user","SOFTWARE_TOKEN_MFA_CODE":"%s"}}+ """.formatted(clientId, later.path("Session").asText(), code);+ cognitoAction("RespondToAuthChallenge", replay).then().statusCode(400);+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoTotpMfaTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoTotpMfaTest.javanew file mode 100644index 0000000000..1d19adb07d--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoTotpMfaTest.java@@ -0,0 +1,361 @@+package io.github.hectorvent.floci.services.cognito;++import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.acm.AcmService;+import io.github.hectorvent.floci.services.cognito.model.CognitoUser;+import io.github.hectorvent.floci.services.cognito.model.UserPool;+import io.github.hectorvent.floci.services.cognito.model.UserPoolClient;+import io.github.hectorvent.floci.testing.MutableClock;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;++import java.math.BigInteger;+import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.time.Duration;+import java.util.Arrays;+import java.util.Base64;+import java.util.List;+import java.util.Map;+import javax.crypto.Mac;+import javax.crypto.spec.SecretKeySpec;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.mock;++class CognitoTotpMfaTest {+ private static final String USERNAME = "alice";+ private static final String PASSWORD = "Perm1234!";++ private CognitoService service;+ private MutableClock clock;+ private UserPool pool;+ private UserPoolClient client;++ @BeforeEach+ void setUp() {+ clock = new MutableClock();+ service = new CognitoService(new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ "http://localhost:4566", "cloudfront.net",+ new RegionResolver("us-east-1", "000000000000"), null, mock(AcmService.class),+ null, null, null, clock);+ pool = service.createUserPool(Map.of("PoolName", "TotpTestPool"), "us-east-1");+ service.adminCreateUser(pool.getId(), USERNAME, Map.of("email", "[email protected]"), null);+ service.adminSetUserPassword(pool.getId(), USERNAME, PASSWORD, true);+ client = service.createUserPoolClient(pool.getId(), "totp-client", false, false, List.of(), List.of());+ client.setExplicitAuthFlows(List.of("ALLOW_USER_PASSWORD_AUTH", "ALLOW_USER_SRP_AUTH"));+ service.setUserPoolMfaConfig(pool.getId(), "ON", true, false);+ }++ @Test+ void setupAndLaterSignInRequireSeparateTotpChallenges() {+ Map<String, Object> login = passwordLogin();+ assertEquals("MFA_SETUP", login.get("ChallengeName"));+ assertFalse(login.containsKey("AuthenticationResult"));+ assertTrue(String.valueOf(login.get("ChallengeParameters")).contains("SOFTWARE_TOKEN_MFA"));++ String loginSession = (String) login.get("Session");+ Map<String, Object> association = service.associateSoftwareToken(null, loginSession);+ String secret = (String) association.get("SecretCode");+ String associationSession = (String) association.get("Session");+ assertNotNull(secret);+ assertFalse(loginSession.equals(associationSession));++ AwsException wrong = assertThrows(AwsException.class, () -> service.verifySoftwareToken(+ null, associationSession, "not-a-code"));+ assertEquals("InvalidParameterException", wrong.getErrorCode());++ String code = CognitoTotp.code(secret, clock.instant());+ Map<String, Object> verified = service.verifySoftwareToken(null, associationSession, code);+ assertEquals("SUCCESS", verified.get("Status"));+ String verifiedSession = (String) verified.get("Session");+ assertFalse(associationSession.equals(verifiedSession));++ assertEquals("NotAuthorizedException", assertThrows(AwsException.class,+ () -> service.respondToAuthChallenge(client.getClientId(), "MFA_SETUP", loginSession,+ Map.of("USERNAME", USERNAME))).getErrorCode());+ Map<String, Object> authenticated = service.respondToAuthChallenge(client.getClientId(),+ "MFA_SETUP", verifiedSession, Map.of("USERNAME", USERNAME));+ assertNotNull(((Map<?, ?>) authenticated.get("AuthenticationResult")).get("AccessToken"));+ assertEquals("NotAuthorizedException", assertThrows(AwsException.class,+ () -> service.respondToAuthChallenge(client.getClientId(), "MFA_SETUP", verifiedSession,+ Map.of("USERNAME", USERNAME))).getErrorCode());++ Map<String, Object> later = passwordLogin();+ assertEquals("SOFTWARE_TOKEN_MFA", later.get("ChallengeName"));+ assertFalse(later.containsKey("AuthenticationResult"));+ String laterSession = (String) later.get("Session");+ String wrongCode = code.equals("000000") ? "000001" : "000000";+ AwsException mismatch = assertThrows(AwsException.class, () -> service.respondToAuthChallenge(+ client.getClientId(), "SOFTWARE_TOKEN_MFA", laterSession,+ Map.of("USERNAME", USERNAME, "SOFTWARE_TOKEN_MFA_CODE", wrongCode)));+ assertEquals("CodeMismatchException", mismatch.getErrorCode());+ Map<String, Object> completed = service.respondToAuthChallenge(client.getClientId(),+ "SOFTWARE_TOKEN_MFA", laterSession,+ Map.of("USERNAME", USERNAME, "SOFTWARE_TOKEN_MFA_CODE", code));+ assertNotNull(((Map<?, ?>) completed.get("AuthenticationResult")).get("AccessToken"));+ }++ @Test+ void disabledUserCannotCompleteMfaSetupChallenge() {+ String loginSession = (String) passwordLogin().get("Session");+ Map<String, Object> association = service.associateSoftwareToken(null, loginSession);+ String code = CognitoTotp.code((String) association.get("SecretCode"), clock.instant());+ String verifiedSession = (String) service.verifySoftwareToken(null,+ (String) association.get("Session"), code).get("Session");++ service.adminDisableUser(pool.getId(), USERNAME);++ AwsException disabled = assertThrows(AwsException.class,+ () -> service.respondToAuthChallenge(client.getClientId(), "MFA_SETUP", verifiedSession,+ Map.of("USERNAME", USERNAME)));+ assertEquals("UserNotConfirmedException", disabled.getErrorCode());+ }++ @Test+ void disabledUserCannotCompleteSoftwareTokenChallenge() {+ String loginSession = (String) passwordLogin().get("Session");+ Map<String, Object> association = service.associateSoftwareToken(null, loginSession);+ String code = CognitoTotp.code((String) association.get("SecretCode"), clock.instant());+ String verifiedSession = (String) service.verifySoftwareToken(null,+ (String) association.get("Session"), code).get("Session");+ service.respondToAuthChallenge(client.getClientId(), "MFA_SETUP", verifiedSession,+ Map.of("USERNAME", USERNAME));+ String challengeSession = (String) passwordLogin().get("Session");++ service.adminDisableUser(pool.getId(), USERNAME);++ AwsException disabled = assertThrows(AwsException.class,+ () -> service.respondToAuthChallenge(client.getClientId(), "SOFTWARE_TOKEN_MFA", challengeSession,+ Map.of("USERNAME", USERNAME, "SOFTWARE_TOKEN_MFA_CODE", code)));+ assertEquals("UserNotConfirmedException", disabled.getErrorCode());+ }++ @Test+ void setupSessionExpiresAndCannotBeUsedByAnotherClient() {+ String session = (String) passwordLogin().get("Session");+ UserPoolClient other = service.createUserPoolClient(pool.getId(), "other", false, false, List.of(), List.of());+ assertEquals("NotAuthorizedException", assertThrows(AwsException.class,+ () -> service.respondToAuthChallenge(other.getClientId(), "MFA_SETUP", session,+ Map.of("USERNAME", USERNAME))).getErrorCode());++ clock.advance(Duration.ofMinutes(client.getAuthSessionValidity()).plusSeconds(1));+ AwsException expired = assertThrows(AwsException.class,+ () -> service.associateSoftwareToken(null, session));+ assertEquals("NotAuthorizedException", expired.getErrorCode());+ assertTrue(expired.getMessage().contains("expired"));+ }++ @Test+ void associationRejectsPoolsWithoutSoftwareTokenMfa() {+ service.setUserPoolMfaConfig(pool.getId(), "OFF", null, false);+ String accessToken = (String) ((Map<?, ?>) passwordLogin().get("AuthenticationResult")).get("AccessToken");++ AwsException unsupported = assertThrows(AwsException.class,+ () -> service.associateSoftwareToken(accessToken, null));+ assertEquals("SoftwareTokenMFANotFoundException", unsupported.getErrorCode());+ }++ @Test+ void invalidSetupCodeUsesCodeMismatchError() {+ String loginSession = (String) passwordLogin().get("Session");+ Map<String, Object> associated = service.associateSoftwareToken(null, loginSession);+ String code = CognitoTotp.code((String) associated.get("SecretCode"), clock.instant());+ String wrongCode = code.equals("000000") ? "000001" : "000000";++ AwsException mismatch = assertThrows(AwsException.class,+ () -> service.verifySoftwareToken(null, (String) associated.get("Session"), wrongCode));+ assertEquals("CodeMismatchException", mismatch.getErrorCode());+ }++ @Test+ void repeatedWrongSetupCodesInvalidatePendingSoftwareToken() throws Exception {+ String loginSession = (String) passwordLogin().get("Session");+ Map<String, Object> associated = service.associateSoftwareToken(null, loginSession);+ String session = (String) associated.get("Session");+ String code = CognitoTotp.code((String) associated.get("SecretCode"), clock.instant());+ String wrongCode = code.equals("000000") ? "000001" : "000000";++ for (int attempt = 0; attempt < CognitoTotp.MAX_FAILED_ATTEMPTS; attempt++) {+ AwsException mismatch = assertThrows(AwsException.class,+ () -> service.verifySoftwareToken(null, session, wrongCode));+ assertEquals("CodeMismatchException", mismatch.getErrorCode());+ }+ CognitoUser pending = service.adminGetUser(pool.getId(), USERNAME);+ ObjectMapper mapper = new ObjectMapper();+ CognitoUser reloaded = mapper.readValue(mapper.writeValueAsBytes(pending), CognitoUser.class);+ assertEquals(0, reloaded.getPendingSoftwareTokenMfaAttemptsRemaining());+ assertEquals("CodeMismatchException", assertThrows(AwsException.class,+ () -> service.verifySoftwareToken(null, session, code)).getErrorCode());++ Map<String, Object> replacement = service.associateSoftwareToken(null,+ (String) passwordLogin().get("Session"));+ String replacementCode = CognitoTotp.code((String) replacement.get("SecretCode"), clock.instant());+ assertEquals("SUCCESS", service.verifySoftwareToken(null,+ (String) replacement.get("Session"), replacementCode).get("Status"));+ }++ @Test+ void accessTokenCannotRetryExhaustedSoftwareTokenAssociation() {+ service.setUserPoolMfaConfig(pool.getId(), "OFF", null, false);+ String accessToken = (String) ((Map<?, ?>) passwordLogin().get("AuthenticationResult")).get("AccessToken");+ service.setUserPoolMfaConfig(pool.getId(), "ON", true, false);+ Map<String, Object> associated = service.associateSoftwareToken(accessToken, null);+ String code = CognitoTotp.code((String) associated.get("SecretCode"), clock.instant());+ String wrongCode = code.equals("000000") ? "000001" : "000000";++ for (int attempt = 0; attempt < CognitoTotp.MAX_FAILED_ATTEMPTS; attempt++) {+ assertEquals("CodeMismatchException", assertThrows(AwsException.class,+ () -> service.verifySoftwareToken(accessToken, null, wrongCode)).getErrorCode());+ }+ assertEquals("CodeMismatchException", assertThrows(AwsException.class,+ () -> service.verifySoftwareToken(accessToken, null, code)).getErrorCode());+ }++ @Test+ void repeatedWrongSignInCodesInvalidateChallengeSession() {+ Map<String, Object> associated = service.associateSoftwareToken(null,+ (String) passwordLogin().get("Session"));+ String code = CognitoTotp.code((String) associated.get("SecretCode"), clock.instant());+ String verifiedSession = (String) service.verifySoftwareToken(null,+ (String) associated.get("Session"), code).get("Session");+ service.respondToAuthChallenge(client.getClientId(), "MFA_SETUP", verifiedSession,+ Map.of("USERNAME", USERNAME));++ String session = (String) passwordLogin().get("Session");+ String wrongCode = code.equals("000000") ? "000001" : "000000";+ for (int attempt = 0; attempt < CognitoTotp.MAX_FAILED_ATTEMPTS; attempt++) {+ assertEquals("CodeMismatchException", assertThrows(AwsException.class,+ () -> service.respondToAuthChallenge(client.getClientId(), "SOFTWARE_TOKEN_MFA", session,+ Map.of("USERNAME", USERNAME, "SOFTWARE_TOKEN_MFA_CODE", wrongCode)))+ .getErrorCode());+ }+ assertEquals("NotAuthorizedException", assertThrows(AwsException.class,+ () -> service.respondToAuthChallenge(client.getClientId(), "SOFTWARE_TOKEN_MFA", session,+ Map.of("USERNAME", USERNAME, "SOFTWARE_TOKEN_MFA_CODE", code))).getErrorCode());+ assertNotNull(service.respondToAuthChallenge(client.getClientId(), "SOFTWARE_TOKEN_MFA",+ (String) passwordLogin().get("Session"),+ Map.of("USERNAME", USERNAME, "SOFTWARE_TOKEN_MFA_CODE", code)).get("AuthenticationResult"));+ }++ @Test+ void accessTokenCanAssociateSoftwareTokenWithoutAnAuthSession() {+ service.setUserPoolMfaConfig(pool.getId(), "OFF", null, false);+ String accessToken = (String) ((Map<?, ?>) passwordLogin().get("AuthenticationResult")).get("AccessToken");+ service.setUserPoolMfaConfig(pool.getId(), "ON", true, false);++ Map<String, Object> association = service.associateSoftwareToken(accessToken, null);+ assertFalse(association.containsKey("Session"));+ String code = CognitoTotp.code((String) association.get("SecretCode"), clock.instant());+ Map<String, Object> verified = service.verifySoftwareToken(accessToken, null, code);+ assertEquals("SUCCESS", verified.get("Status"));+ assertFalse(verified.containsKey("Session"));+ assertEquals("SOFTWARE_TOKEN_MFA", passwordLogin().get("ChallengeName"));+ }++ @Test+ void laterAssociationInvalidatesEarlierSecretAndSession() {+ String firstLogin = (String) passwordLogin().get("Session");+ String secondLogin = (String) passwordLogin().get("Session");+ Map<String, Object> first = service.associateSoftwareToken(null, firstLogin);+ Map<String, Object> second = service.associateSoftwareToken(null, secondLogin);+ assertEquals("NotAuthorizedException", assertThrows(AwsException.class,+ () -> service.associateSoftwareToken(null, firstLogin)).getErrorCode());++ String firstCode = CognitoTotp.code((String) first.get("SecretCode"), clock.instant());+ assertEquals("NotAuthorizedException", assertThrows(AwsException.class,+ () -> service.verifySoftwareToken(null, (String) first.get("Session"), firstCode)).getErrorCode());++ String secondCode = CognitoTotp.code((String) second.get("SecretCode"), clock.instant());+ Map<String, Object> verified = service.verifySoftwareToken(null, (String) second.get("Session"), secondCode);+ assertNotNull(service.respondToAuthChallenge(client.getClientId(), "MFA_SETUP",+ (String) verified.get("Session"), Map.of("USERNAME", USERNAME)).get("AuthenticationResult"));+ }++ @Test+ void registeredSecretSurvivesUserSerialization() throws Exception {+ String loginSession = (String) passwordLogin().get("Session");+ Map<String, Object> associated = service.associateSoftwareToken(null, loginSession);+ String secret = (String) associated.get("SecretCode");+ String code = CognitoTotp.code(secret, clock.instant());+ service.verifySoftwareToken(null, (String) associated.get("Session"), code);++ CognitoUser persisted = service.adminGetUser(pool.getId(), USERNAME);+ ObjectMapper mapper = new ObjectMapper();+ CognitoUser restored = mapper.readValue(mapper.writeValueAsBytes(persisted), CognitoUser.class);+ assertEquals(secret, restored.getSoftwareTokenMfaSecret());+ assertNull(restored.getPendingSoftwareTokenMfaSecret());+ assertTrue(CognitoTotp.validCode(restored.getSoftwareTokenMfaSecret(), code, clock.instant()));+ }++ @Test+ @SuppressWarnings("unchecked")+ void successfulSrpProofContinuesToMfaSetupWithoutTokens() throws Exception {+ BigInteger privateA = new BigInteger("123456789abcdef123456789abcdef", 16);+ BigInteger publicA = CognitoSrpHelper.G.modPow(privateA, CognitoSrpHelper.N);+ Map<String, Object> started = service.initiateAuth(client.getClientId(), "USER_SRP_AUTH",+ Map.of("USERNAME", USERNAME, "SRP_A", publicA.toString(16)));+ assertEquals("PASSWORD_VERIFIER", started.get("ChallengeName"));+ Map<String, String> params = (Map<String, String>) started.get("ChallengeParameters");+ String timestamp = "Wed Apr 8 12:00:00 UTC 2026";+ byte[] sessionKey = clientSrpSessionKey(privateA, publicA,+ new BigInteger(params.get("SRP_B"), 16), params.get("SALT"));+ byte[] secretBlock = Base64.getDecoder().decode(params.get("SECRET_BLOCK"));+ String signature = Base64.getEncoder().encodeToString(CognitoSrpHelper.computeSignature(+ sessionKey, pool.getId(), USERNAME, secretBlock, timestamp));+ UserPoolClient other = service.createUserPoolClient(pool.getId(), "other-srp-client", false, false,+ List.of(), List.of());+ assertEquals("NotAuthorizedException", assertThrows(AwsException.class,+ () -> service.respondToAuthChallenge(other.getClientId(), "PASSWORD_VERIFIER",+ (String) started.get("Session"), Map.of(+ "USERNAME", USERNAME,+ "PASSWORD_CLAIM_SECRET_BLOCK", params.get("SECRET_BLOCK"),+ "PASSWORD_CLAIM_SIGNATURE", signature,+ "TIMESTAMP", timestamp))).getErrorCode());+ Map<String, Object> verified = service.respondToAuthChallenge(client.getClientId(),+ "PASSWORD_VERIFIER", (String) started.get("Session"), Map.of(+ "USERNAME", USERNAME,+ "PASSWORD_CLAIM_SECRET_BLOCK", params.get("SECRET_BLOCK"),+ "PASSWORD_CLAIM_SIGNATURE", signature,+ "TIMESTAMP", timestamp));+ assertEquals("MFA_SETUP", verified.get("ChallengeName"));+ assertFalse(verified.containsKey("AuthenticationResult"));+ }++ private byte[] clientSrpSessionKey(BigInteger privateA, BigInteger publicA,+ BigInteger publicB, String saltHex) throws Exception {+ MessageDigest hash = MessageDigest.getInstance("SHA-256");+ hash.update((CognitoSrpHelper.extractPoolName(pool.getId()) + USERNAME + ":" + PASSWORD)+ .getBytes(StandardCharsets.UTF_8));+ byte[] inner = hash.digest();+ hash.update(new BigInteger(saltHex, 16).toByteArray());+ BigInteger x = new BigInteger(1, hash.digest(inner));+ hash.update(publicA.toByteArray());+ BigInteger u = new BigInteger(1, hash.digest(publicB.toByteArray()));+ BigInteger base = publicB.subtract(CognitoSrpHelper.K.multiply(+ CognitoSrpHelper.G.modPow(x, CognitoSrpHelper.N))).mod(CognitoSrpHelper.N);+ BigInteger shared = base.modPow(privateA.add(u.multiply(x)), CognitoSrpHelper.N);+ Mac mac = Mac.getInstance("HmacSHA256");+ mac.init(new SecretKeySpec(u.toByteArray(), "HmacSHA256"));+ byte[] prk = mac.doFinal(shared.toByteArray());+ mac.init(new SecretKeySpec(prk, "HmacSHA256"));+ mac.update("Caldera Derived Key".getBytes(StandardCharsets.UTF_8));+ mac.update((byte) 1);+ return Arrays.copyOf(mac.doFinal(), 16);+ }++ private Map<String, Object> passwordLogin() {+ return service.initiateAuth(client.getClientId(), "USER_PASSWORD_AUTH",+ Map.of("USERNAME", USERNAME, "PASSWORD", PASSWORD));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoTotpTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoTotpTest.javanew file mode 100644index 0000000000..47cb2f7895--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoTotpTest.java@@ -0,0 +1,30 @@+package io.github.hectorvent.floci.services.cognito;++import org.junit.jupiter.api.Test;++import java.time.Instant;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertTrue;++class CognitoTotpTest {+ @Test+ void usesRfc6238Sha1CounterAndSixDigits() {+ String secret = "GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ";+ assertEquals("287082", CognitoTotp.code(secret, Instant.ofEpochSecond(59)));+ assertTrue(CognitoTotp.validCode(secret, "287082", Instant.ofEpochSecond(59)));+ assertTrue(CognitoTotp.validCode(secret, "287082", Instant.ofEpochSecond(89)));+ assertFalse(CognitoTotp.validCode(secret, "287082", Instant.ofEpochSecond(90)));+ assertFalse(CognitoTotp.validCode(secret, "28782", Instant.ofEpochSecond(59)));+ }++ @Test+ void newSecretIsBase32Encoded() {+ String first = CognitoTotp.newSecret();+ String second = CognitoTotp.newSecret();+ assertTrue(first.matches("[A-Z2-7]{32}"));+ assertFalse(first.equals(second));+ assertTrue(CognitoTotp.validCode(first, CognitoTotp.code(first, Instant.EPOCH), Instant.EPOCH));+ }+}