Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

feat(cognito): implement VerifyUserAttribute (#2018)

Daniel Zwicker36c3ee4e22fe
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoVerifyUserAttributeTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoVerifyUserAttributeTest.java
new file mode 100644
index 0000000000..5032b26029
--- /dev/null
+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/CognitoVerifyUserAttributeTest.java
@@ -0,0 +1,239 @@
+package com.floci.test;
+
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import software.amazon.awssdk.services.cognitoidentityprovider.CognitoIdentityProviderClient;
+import software.amazon.awssdk.services.cognitoidentityprovider.model.AttributeType;
+import software.amazon.awssdk.services.cognitoidentityprovider.model.AuthFlowType;
+import software.amazon.awssdk.services.cognitoidentityprovider.model.CodeMismatchException;
+import software.amazon.awssdk.services.cognitoidentityprovider.model.ExpiredCodeException;
+import software.amazon.awssdk.services.cognitoidentityprovider.model.ExplicitAuthFlowsType;
+import software.amazon.awssdk.services.cognitoidentityprovider.model.MessageActionType;
+
+import java.net.URI;
+import java.net.URLEncoder;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.time.Duration;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+class CognitoVerifyUserAttributeTest {
+
+ private static final ObjectMapper JSON = new ObjectMapper();
+ private static final HttpClient HTTP = HttpClient.newBuilder()
+ .connectTimeout(Duration.ofSeconds(10))
+ .build();
+ private static final Pattern SIX_DIGIT_CODE = Pattern.compile("\\b(\\d{6})\\b");
+ private static final String PASSWORD = "Verify1234!";
+
+ private static CognitoIdentityProviderClient cognito;
+
+ private String poolId;
+
+ @BeforeAll
+ static void setUpClient() {
+ cognito = TestFixtures.cognitoClient();
+ }
+
+ @AfterAll
+ static void closeClient() {
+ if (cognito != null) {
+ cognito.close();
+ }
+ }
+
+ @AfterEach
+ void deletePool() {
+ if (poolId != null) {
+ cognito.deleteUserPool(b -> b.userPoolId(poolId));
+ poolId = null;
+ }
+ }
+
+ @Test
+ void verifiesEmailAndPhoneNumberWithAwsSdk() throws Exception {
+ poolId = cognito.createUserPool(b -> b.poolName("verify-attribute-" + UUID.randomUUID()))
+ .userPool()
+ .id();
+ String clientId = cognito.createUserPoolClient(b -> b
+ .userPoolId(poolId)
+ .clientName("verify-attribute-client")
+ .explicitAuthFlows(ExplicitAuthFlowsType.ALLOW_USER_PASSWORD_AUTH))
+ .userPoolClient()
+ .clientId();
+
+ String username = "verify-" + UUID.randomUUID();
+ String email = username + "@example.com";
+ String phoneNumber = "+1555" + ThreadLocalRandom.current().nextLong(1_000_000, 10_000_000);
+
+ cognito.adminCreateUser(b -> b
+ .userPoolId(poolId)
+ .username(username)
+ .messageAction(MessageActionType.SUPPRESS)
+ .userAttributes(
+ AttributeType.builder().name("email").value(email).build(),
+ AttributeType.builder().name("phone_number").value(phoneNumber).build()));
+ cognito.adminSetUserPassword(b -> b
+ .userPoolId(poolId)
+ .username(username)
+ .password(PASSWORD)
+ .permanent(true));
+
+ String accessToken = cognito.initiateAuth(b -> b
+ .clientId(clientId)
+ .authFlow(AuthFlowType.USER_PASSWORD_AUTH)
+ .authParameters(Map.of("USERNAME", username, "PASSWORD", PASSWORD)))
+ .authenticationResult()
+ .accessToken();
+
+ clearInspectionEndpoint("/_aws/ses");
+ clearInspectionEndpoint("/_aws/sns");
+
+ var emailDelivery = cognito.getUserAttributeVerificationCode(b -> b
+ .accessToken(accessToken)
+ .attributeName("email"))
+ .codeDeliveryDetails();
+ assertThat(emailDelivery.attributeName()).isEqualTo("email");
+ assertThat(emailDelivery.deliveryMediumAsString()).isEqualTo("EMAIL");
+ assertThat(emailDelivery.destination()).isEqualTo("v***@e***");
+ String emailCode = fetchLatestSesVerificationCode(email);
+
+ var phoneDelivery = cognito.getUserAttributeVerificationCode(b -> b
+ .accessToken(accessToken)
+ .attributeName("phone_number"))
+ .codeDeliveryDetails();
+ assertThat(phoneDelivery.attributeName()).isEqualTo("phone_number");
+ assertThat(phoneDelivery.deliveryMediumAsString()).isEqualTo("SMS");
+ assertThat(phoneDelivery.destination()).isEqualTo(maskedPhoneNumber(phoneNumber));
+ String phoneCode = fetchLatestSnsVerificationCode(phoneNumber);
+
+ assertThatThrownBy(() -> cognito.verifyUserAttribute(b -> b
+ .accessToken(accessToken)
+ .attributeName("email")
+ .code(differentCode(emailCode))))
+ .isInstanceOf(CodeMismatchException.class);
+ assertThat(userAttribute(username, "email_verified")).isNull();
+
+ cognito.verifyUserAttribute(b -> b
+ .accessToken(accessToken)
+ .attributeName("email")
+ .code(emailCode));
+ cognito.verifyUserAttribute(b -> b
+ .accessToken(accessToken)
+ .attributeName("phone_number")
+ .code(phoneCode));
+
+ assertThat(userAttribute(username, "email_verified")).isEqualTo("true");
+ assertThat(userAttribute(username, "phone_number_verified")).isEqualTo("true");
+
+ assertThatThrownBy(() -> cognito.verifyUserAttribute(b -> b
+ .accessToken(accessToken)
+ .attributeName("email")
+ .code(emailCode)))
+ .isInstanceOfSatisfying(ExpiredCodeException.class,
+ exception -> assertThat(exception.awsErrorDetails().errorMessage())
+ .isEqualTo("Invalid code provided, please request a code again."));
+
+ clearInspectionEndpoint("/_aws/ses");
+ clearInspectionEndpoint("/_aws/sns");
+
+ cognito.getUserAttributeVerificationCode(b -> b
+ .accessToken(accessToken)
+ .attributeName("email"));
+ String repeatedEmailCode = fetchLatestSesVerificationCode(email);
+
+ cognito.getUserAttributeVerificationCode(b -> b
+ .accessToken(accessToken)
+ .attributeName("phone_number"));
+ String repeatedPhoneCode = fetchLatestSnsVerificationCode(phoneNumber);
+
+ cognito.verifyUserAttribute(b -> b
+ .accessToken(accessToken)
+ .attributeName("email")
+ .code(repeatedEmailCode));
+ cognito.verifyUserAttribute(b -> b
+ .accessToken(accessToken)
+ .attributeName("phone_number")
+ .code(repeatedPhoneCode));
+
+ assertThat(userAttribute(username, "email_verified")).isEqualTo("true");
+ assertThat(userAttribute(username, "phone_number_verified")).isEqualTo("true");
+ }
+
+ private String userAttribute(String username, String attributeName) {
+ return cognito.adminGetUser(b -> b.userPoolId(poolId).username(username))
+ .userAttributes()
+ .stream()
+ .filter(attribute -> attributeName.equals(attribute.name()))
+ .map(AttributeType::value)
+ .findFirst()
+ .orElse(null);
+ }
+
+ private static void clearInspectionEndpoint(String path) throws Exception {
+ HttpResponse<String> response = HTTP.send(
+ HttpRequest.newBuilder()
+ .uri(TestFixtures.endpoint().resolve(path))
+ .DELETE()
+ .timeout(Duration.ofSeconds(10))
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+ assertThat(response.statusCode()).isEqualTo(200);
+ }
+
+ private static String fetchLatestSesVerificationCode(String recipient) throws Exception {
+ URI uri = TestFixtures.endpoint()
+ .resolve("/_aws/ses?email=" + URLEncoder.encode(recipient, StandardCharsets.UTF_8));
+ JsonNode messages = getInspectionMessages(uri);
+ return extractVerificationCode(messages.get(0).path("Body").path("text_part").asText());
+ }
+
+ private static String fetchLatestSnsVerificationCode(String phoneNumber) throws Exception {
+ URI uri = TestFixtures.endpoint()
+ .resolve("/_aws/sns?phone=" + URLEncoder.encode(phoneNumber, StandardCharsets.UTF_8));
+ JsonNode messages = getInspectionMessages(uri);
+ return extractVerificationCode(messages.get(0).path("Message").asText());
+ }
+
+ private static JsonNode getInspectionMessages(URI uri) throws Exception {
+ HttpResponse<String> response = HTTP.send(
+ HttpRequest.newBuilder()
+ .uri(uri)
+ .GET()
+ .timeout(Duration.ofSeconds(10))
+ .build(),
+ HttpResponse.BodyHandlers.ofString());
+ assertThat(response.statusCode()).isEqualTo(200);
+ JsonNode messages = JSON.readTree(response.body()).path("messages");
+ assertThat(messages.isArray() && !messages.isEmpty()).isTrue();
+ return messages;
+ }
+
+ private static String extractVerificationCode(String message) {
+ Matcher matcher = SIX_DIGIT_CODE.matcher(message);
+ assertThat(matcher.find()).isTrue();
+ return matcher.group(1);
+ }
+
+ private static String differentCode(String code) {
+ return "000000".equals(code) ? "000001" : "000000";
+ }
+
+ private static String maskedPhoneNumber(String phoneNumber) {
+ return "+" + "*".repeat(phoneNumber.length() - 5)
+ + phoneNumber.substring(phoneNumber.length() - 4);
+ }
+}
diff --git a/docs/services/cognito.md b/docs/services/cognito.md
index 52a6a8e0f0..aae9d52cf4 100644
--- a/docs/services/cognito.md
+++ b/docs/services/cognito.md
@@ -172,6 +172,7 @@ further divergences, both deliberate:
| ConfirmSignUp | Confirms a pending self-service signup. |
| GetUser | Returns attributes for the authenticated access-token user. |
| GetUserAttributeVerificationCode | Issues a verification code for the authenticated user's email or phone_number attribute. |
+| VerifyUserAttribute | Verifies an email or phone_number attribute with its issued verification code. |
| UpdateUserAttributes | Updates attributes for the authenticated access-token user. |
| ChangePassword | Changes the authenticated user's password. |
| ForgotPassword | Starts the local forgot-password flow for a user. |
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.java
index d793c33bc7..e132f427aa 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
@@ -104,6 +104,7 @@ public class CognitoJsonHandler {
case "ConfirmForgotPassword" -> handleConfirmForgotPassword(request);
case "GetUser" -> handleGetUser(request);
case "GetUserAttributeVerificationCode" -> handleGetUserAttributeVerificationCode(request);
+ case "VerifyUserAttribute" -> handleVerifyUserAttribute(request);
case "UpdateUserAttributes" -> handleUpdateUserAttributes(request);
case "DeleteUserAttributes" -> handleDeleteUserAttributes(request);
case "GlobalSignOut" -> handleGlobalSignOut(request);
@@ -1018,6 +1019,15 @@ public class CognitoJsonHandler {
return Response.ok(response).build();
}
+ private Response handleVerifyUserAttribute(JsonNode request) {
+ service.verifyUserAttribute(
+ request.path("AccessToken").asText(),
+ request.path("AttributeName").asText(),
+ request.path("Code").asText()
+ );
+ return Response.ok(objectMapper.createObjectNode()).build();
+ }
+
private Response handleUpdateUserAttributes(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.java
index c529fe2b96..942d4b0697 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
@@ -2594,6 +2594,48 @@ public class CognitoService implements ResourceProvider {
return response;
}
+ public void verifyUserAttribute(String accessToken, String attributeName, String code) {
+ VerifiedAccessToken token;
+ try {
+ token = verifyAccessToken(accessToken);
+ } catch (AwsException e) {
+ if ("NotAuthorizedException".equals(e.getErrorCode())
+ && INVALID_ACCESS_TOKEN_MESSAGE.equals(e.getMessage())) {
+ throw new AwsException("NotAuthorizedException", "Invalid Access Token", 400);
+ }
+ throw e;
+ }
+ requireScope(accessToken, "aws.cognito.signin.user.admin");
+ String username = token.username();
+ String poolId = token.poolId();
+
+ if (!"email".equals(attributeName) && !"phone_number".equals(attributeName)) {
+ throw new AwsException("InvalidParameterException",
+ "Invalid attribute name. Only phone_number and email can be verified.", 400);
+ }
+
+ CognitoUser user = adminGetUser(poolId, username);
+ if (blankToNull(user.getAttributes().get(attributeName)) == null) {
+ throw new AwsException("InvalidParameterException",
+ "Unable to verify attribute: " + attributeName + " no value set to verify",
+ 400);
+ }
+
+ VerificationCode.Purpose purpose = "email".equals(attributeName)
+ ? VerificationCode.Purpose.EMAIL_ATTRIBUTE_VERIFICATION
+ : VerificationCode.Purpose.PHONE_ATTRIBUTE_VERIFICATION;
+ ensureVerificationWiring();
+ try {
+ verificationCodeService.consume(poolId, user.getUsername(), purpose, code);
+ } catch (VerificationCodeException e) {
+ throw mapVerificationCodeException(e);
+ }
+
+ user.getAttributes().put(attributeName + "_verified", "true");
+ user.setLastModifiedDate(System.currentTimeMillis() / 1000L);
+ userStore.put(userKey(poolId, user.getUsername()), user);
+ }
+
public void updateUserAttributes(String accessToken, Map<String, String> attributes) {
VerifiedAccessToken token = verifyAccessToken(accessToken);
String username = token.username();
@@ -3715,6 +3757,43 @@ public class CognitoService implements ResourceProvider {
+ /**
+ * Extracts the space-separated {@code scope} claim from an already-verified access token
+ * (call after {@link #verifyAccessToken}). {@code null} means no scope claim at all, which
+ * every token this simulator currently issues also is not the case for access tokens (see
+ * {@code generateSignedJwt}, which always sets a default scope) but a caller-suppressed
+ * scope list still needs to be tolerated as "no restriction modeled" rather than treated the
+ * same as an empty, restrictive list.
+ */
+ private Set<String> extractScopesFromToken(String token) {
+ try {
+ String[] parts = token.split("\\.", -1);
+ JsonNode claims = MAPPER.readTree(Base64.getUrlDecoder().decode(parts[1]));
+ String scope = textClaim(claims, "scope");
+ if (scope == null || scope.isBlank()) return null;
+ Set<String> scopes = new HashSet<>();
+ for (String s : scope.split(" ")) {
+ if (!s.isBlank()) scopes.add(s);
+ }
+ return scopes;
+ } catch (Exception e) {
+ return null;
+ }
+ }
+
+ /**
+ * AWS requires an access token carrying the given scope for some operations (for example
+ * VerifyUserAttribute requires aws.cognito.signin.user.admin). Call after
+ * {@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) {
+ Set<String> scopes = extractScopesFromToken(accessToken);
+ if (scopes != null && !scopes.contains(requiredScope)) {
+ throw new AwsException("NotAuthorizedException", "Access Token does not have the required scope", 400);
+ }
+ }
+
/**
* Validate that a refresh token has not been revoked, including global user sign-out.
* Called from CognitoAuthFlowHandler for the REFRESH_TOKEN_AUTH flow.
diff --git a/src/main/java/io/github/hectorvent/floci/services/cognito/verification/VerificationCodeService.java b/src/main/java/io/github/hectorvent/floci/services/cognito/verification/VerificationCodeService.java
index ccdf41394b..f1c04e4295 100644
--- a/src/main/java/io/github/hectorvent/floci/services/cognito/verification/VerificationCodeService.java
+++ b/src/main/java/io/github/hectorvent/floci/services/cognito/verification/VerificationCodeService.java
@@ -86,9 +86,15 @@ public final class VerificationCodeService {
}
/**
- * Validate a code. On success, marks it consumed and removes it. On any
- * failure, throws {@link VerificationCodeException} with the specific
- * {@link VerificationCodeException.Kind}.
+ * Validate a code. On success, marks it consumed. For the attribute-verification
+ * purposes, retains the tombstone until it expires or a new code replaces it, so a
+ * reused code answers {@code EXPIRED} rather than {@code NOT_FOUND}, validated against
+ * a real Cognito pool for {@code VerifyUserAttribute} (see CognitoServiceTest /
+ * CognitoAttributeVerificationIntegrationTest). {@link VerificationCode.Purpose#SIGNUP_CONFIRMATION}
+ * and {@link VerificationCode.Purpose#PASSWORD_RESET} keep the original delete-on-consume
+ * behavior instead, since that reuse case was never validated against real Cognito for
+ * {@code ConfirmSignUp} or {@code ConfirmForgotPassword}. On any failure, throws
+ * {@link VerificationCodeException} with the specific {@link VerificationCodeException.Kind}.
*
* <p>Note: not thread-safe under concurrent {@code consume()} of the same
* (poolId, username, purpose) key — two racing wrong-code calls may
@@ -101,17 +107,17 @@ public final class VerificationCodeService {
VerificationCode vc = store.get(key).orElseThrow(() -> new VerificationCodeException(
VerificationCodeException.Kind.NOT_FOUND,
"Invalid verification code provided, please try again"));
- if (vc.isConsumed()) {
- throw new VerificationCodeException(
- VerificationCodeException.Kind.NOT_FOUND,
- "Invalid verification code provided, please try again");
- }
if (vc.isExpired(clock.instant())) {
store.delete(key);
throw new VerificationCodeException(
VerificationCodeException.Kind.EXPIRED,
"Invalid code provided, please request a code again");
}
+ if (vc.isConsumed()) {
+ throw new VerificationCodeException(
+ VerificationCodeException.Kind.EXPIRED,
+ "Invalid code provided, please request a code again");
+ }
if (vc.getAttemptsRemaining() <= 0) {
store.delete(key);
// AWS returns the generic invalid-code message here too, never the
@@ -136,7 +142,16 @@ public final class VerificationCodeService {
}
vc.markConsumed();
- store.delete(key);
+ if (retainsConsumedTombstone(purpose)) {
+ store.put(key, vc);
+ } else {
+ store.delete(key);
+ }
+ }
+
+ private boolean retainsConsumedTombstone(VerificationCode.Purpose purpose) {
+ return purpose == VerificationCode.Purpose.EMAIL_ATTRIBUTE_VERIFICATION
+ || purpose == VerificationCode.Purpose.PHONE_ATTRIBUTE_VERIFICATION;
}
/** Remove any active code for the (pool, user, purpose). Idempotent. */
diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoAttributeVerificationIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoAttributeVerificationIntegrationTest.java
index a105c514a2..2aaf2df1db 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoAttributeVerificationIntegrationTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoAttributeVerificationIntegrationTest.java
@@ -1,6 +1,7 @@
package io.github.hectorvent.floci.services.cognito;
import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;
import io.quarkus.test.junit.QuarkusTest;
import org.junit.jupiter.api.BeforeAll;
@@ -10,21 +11,31 @@ import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import java.util.UUID;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
import static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoAction;
import static io.github.hectorvent.floci.services.cognito.CognitoRestAssuredUtils.cognitoJson;
+import static io.restassured.RestAssured.given;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.hamcrest.Matchers.equalTo;
@QuarkusTest
@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
class CognitoAttributeVerificationIntegrationTest {
+ private static final ObjectMapper JSON = new ObjectMapper();
+ private static final Pattern SIX_DIGIT_CODE = Pattern.compile("\\b(\\d{6})\\b");
private static final String USERNAME = "verify+" + UUID.randomUUID() + "@example.com";
private static final String PASSWORD = "Verify1234!";
private static String poolId;
private static String clientId;
private static String accessToken;
+ private static String idToken;
+ private static String emailVerificationCode;
@BeforeAll
static void configureRestAssured() {
@@ -83,11 +94,14 @@ class CognitoAttributeVerificationIntegrationTest {
}
""".formatted(clientId, USERNAME, PASSWORD));
accessToken = auth.path("AuthenticationResult").path("AccessToken").asText();
+ idToken = auth.path("AuthenticationResult").path("IdToken").asText();
}
@Test
@Order(2)
- void issuesEmailVerificationCode() {
+ void issuesEmailVerificationCode() throws Exception {
+ clearInspectionEndpoint("/_aws/ses");
+
cognitoAction("GetUserAttributeVerificationCode", """
{
"AccessToken": "%s",
@@ -99,10 +113,62 @@ class CognitoAttributeVerificationIntegrationTest {
.body("CodeDeliveryDetails.AttributeName", equalTo("email"))
.body("CodeDeliveryDetails.DeliveryMedium", equalTo("EMAIL"))
.body("CodeDeliveryDetails.Destination", equalTo("v***@e***"));
+
+ emailVerificationCode = fetchLatestSesVerificationCode(USERNAME);
}
@Test
@Order(3)
+ void rejectsWrongVerificationCodeWithoutUpdatingAttribute() throws Exception {
+ cognitoAction("VerifyUserAttribute", """
+ {
+ "AccessToken": "%s",
+ "AttributeName": "email",
+ "Code": "%s"
+ }
+ """.formatted(accessToken, differentCode(emailVerificationCode)))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("CodeMismatchException"));
+
+ assertNull(userAttribute(USERNAME, "email_verified"));
+ }
+
+ @Test
+ @Order(4)
+ void verifiesEmailAttribute() throws Exception {
+ cognitoAction("VerifyUserAttribute", """
+ {
+ "AccessToken": "%s",
+ "AttributeName": "email",
+ "Code": "%s"
+ }
+ """.formatted(accessToken, emailVerificationCode))
+ .then()
+ .statusCode(200)
+ .body(equalTo("{}"));
+
+ assertEquals("true", userAttribute(USERNAME, "email_verified"));
+ }
+
+ @Test
+ @Order(5)
+ void rejectsConsumedVerificationCode() {
+ cognitoAction("VerifyUserAttribute", """
+ {
+ "AccessToken": "%s",
+ "AttributeName": "email",
+ "Code": "%s"
+ }
+ """.formatted(accessToken, emailVerificationCode))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("ExpiredCodeException"))
+ .body("message", equalTo("Invalid code provided, please request a code again."));
+ }
+
+ @Test
+ @Order(6)
void rejectsInvalidAccessToken() {
cognitoAction("GetUserAttributeVerificationCode", """
{
@@ -117,7 +183,7 @@ class CognitoAttributeVerificationIntegrationTest {
}
@Test
- @Order(4)
+ @Order(7)
void rejectsUnverifiableAttribute() {
cognitoAction("GetUserAttributeVerificationCode", """
{
@@ -128,11 +194,12 @@ class CognitoAttributeVerificationIntegrationTest {
.then()
.statusCode(400)
.body("__type", equalTo("InvalidParameterException"))
- .body("message", equalTo("Invalid attribute name. Only phone_number and email can be verified."));
+ .body("message", equalTo(
+ "Invalid attribute name. Only phone_number and email can be verified."));
}
@Test
- @Order(5)
+ @Order(8)
void rejectsAttributeWithoutValue() {
cognitoAction("GetUserAttributeVerificationCode", """
{
@@ -147,19 +214,20 @@ class CognitoAttributeVerificationIntegrationTest {
}
@Test
- @Order(6)
+ @Order(9)
void emailAndPhoneCodesAreIndependent() throws Exception {
String username = "verify-both+" + UUID.randomUUID() + "@example.com";
+ String phoneNumber = "+15551234567";
cognitoAction("AdminCreateUser", """
{
"UserPoolId": "%s",
"Username": "%s",
"UserAttributes": [
{ "Name": "email", "Value": "%s" },
- { "Name": "phone_number", "Value": "+15551234567" }
+ { "Name": "phone_number", "Value": "%s" }
]
}
- """.formatted(poolId, username, username))
+ """.formatted(poolId, username, username, phoneNumber))
.then()
.statusCode(200);
@@ -186,8 +254,9 @@ class CognitoAttributeVerificationIntegrationTest {
""".formatted(clientId, username, PASSWORD));
String token = auth.path("AuthenticationResult").path("AccessToken").asText();
- // Back-to-back requests for different attributes must not trip the shared
- // rate limit or overwrite each other: each attribute has its own code slot.
+ clearInspectionEndpoint("/_aws/ses");
+ clearInspectionEndpoint("/_aws/sns");
+
cognitoAction("GetUserAttributeVerificationCode", """
{
"AccessToken": "%s",
@@ -197,6 +266,7 @@ class CognitoAttributeVerificationIntegrationTest {
.then()
.statusCode(200)
.body("CodeDeliveryDetails.DeliveryMedium", equalTo("EMAIL"));
+ String emailCode = fetchLatestSesVerificationCode(username);
cognitoAction("GetUserAttributeVerificationCode", """
{
@@ -209,56 +279,139 @@ class CognitoAttributeVerificationIntegrationTest {
.body("CodeDeliveryDetails.AttributeName", equalTo("phone_number"))
.body("CodeDeliveryDetails.DeliveryMedium", equalTo("SMS"))
.body("CodeDeliveryDetails.Destination", equalTo("+*******4567"));
- }
+ String phoneCode = fetchLatestSnsVerificationCode(phoneNumber);
- @Test
- @Order(7)
- void allowsFreshCodeForAlreadyVerifiedAttribute() throws Exception {
- String username = "verify-already+" + UUID.randomUUID() + "@example.com";
- cognitoAction("AdminCreateUser", """
+ cognitoAction("VerifyUserAttribute", """
{
- "UserPoolId": "%s",
- "Username": "%s",
- "UserAttributes": [
- { "Name": "email", "Value": "%s" },
- { "Name": "email_verified", "Value": "true" }
- ]
+ "AccessToken": "%s",
+ "AttributeName": "phone_number",
+ "Code": "%s"
}
- """.formatted(poolId, username, username))
+ """.formatted(token, phoneCode))
.then()
.statusCode(200);
- cognitoAction("AdminSetUserPassword", """
+ cognitoAction("VerifyUserAttribute", """
{
- "UserPoolId": "%s",
- "Username": "%s",
- "Password": "%s",
- "Permanent": true
+ "AccessToken": "%s",
+ "AttributeName": "email",
+ "Code": "%s"
}
- """.formatted(poolId, username, PASSWORD))
+ """.formatted(token, emailCode))
.then()
.statusCode(200);
- JsonNode auth = cognitoJson("InitiateAuth", """
+ assertEquals("true", userAttribute(username, "email_verified"));
+ assertEquals("true", userAttribute(username, "phone_number_verified"));
+ }
+
+ @Test
+ @Order(10)
+ void rejectsUnverifiableAttributeDuringVerification() {
+ cognitoAction("VerifyUserAttribute", """
{
- "ClientId": "%s",
- "AuthFlow": "USER_PASSWORD_AUTH",
- "AuthParameters": {
- "USERNAME": "%s",
- "PASSWORD": "%s"
- }
+ "AccessToken": "%s",
+ "AttributeName": "given_name",
+ "Code": "123456"
}
- """.formatted(clientId, username, PASSWORD));
- String token = auth.path("AuthenticationResult").path("AccessToken").asText();
+ """.formatted(accessToken))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("InvalidParameterException"))
+ .body("message", equalTo(
+ "Invalid attribute name. Only phone_number and email can be verified."));
+ }
- cognitoAction("GetUserAttributeVerificationCode", """
+ @Test
+ @Order(11)
+ void rejectsVerificationForAttributeWithoutValue() {
+ cognitoAction("VerifyUserAttribute", """
{
"AccessToken": "%s",
- "AttributeName": "email"
+ "AttributeName": "phone_number",
+ "Code": "123456"
}
- """.formatted(token))
+ """.formatted(accessToken))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("InvalidParameterException"))
+ .body("message", equalTo(
+ "Unable to verify attribute: phone_number no value set to verify"));
+ }
+
+ @Test
+ @Order(12)
+ void rejectsIdTokenForVerification() {
+ // VerifyUserAttribute must be authorized with an access token, not an ID token,
+ // even though both carry the same username/pool claims this simulator reads.
+ cognitoAction("VerifyUserAttribute", """
+ {
+ "AccessToken": "%s",
+ "AttributeName": "email",
+ "Code": "123456"
+ }
+ """.formatted(idToken))
+ .then()
+ .statusCode(400)
+ .body("__type", equalTo("NotAuthorizedException"))
+ .body("message", equalTo("Invalid Access Token"));
+ }
+
+ private static void clearInspectionEndpoint(String path) {
+ given()
+ .delete(path)
+ .then()
+ .statusCode(200);
+ }
+
+ private static String fetchLatestSesVerificationCode(String recipient) throws Exception {
+ String response = given()
+ .queryParam("email", recipient)
+ .get("/_aws/ses")
.then()
.statusCode(200)
- .body("CodeDeliveryDetails.AttributeName", equalTo("email"));
+ .extract()
+ .asString();
+ JsonNode messages = JSON.readTree(response).path("messages");
+ assertTrue(messages.isArray() && !messages.isEmpty());
+ return extractVerificationCode(messages.get(0).path("Body").path("text_part").asText());
+ }
+
+ private static String fetchLatestSnsVerificationCode(String phoneNumber) throws Exception {
+ String response = given()
+ .queryParam("phone", phoneNumber)
+ .get("/_aws/sns")
+ .then()
+ .statusCode(200)
+ .extract()
+ .asString();
+ JsonNode messages = JSON.readTree(response).path("messages");
+ assertTrue(messages.isArray() && !messages.isEmpty());
+ return extractVerificationCode(messages.get(0).path("Message").asText());
+ }
+
+ private static String extractVerificationCode(String message) {
+ Matcher matcher = SIX_DIGIT_CODE.matcher(message);
+ assertTrue(matcher.find());
+ return matcher.group(1);
+ }
+
+ private static String differentCode(String code) {
+ return "000000".equals(code) ? "000001" : "000000";
+ }
+
+ private static String userAttribute(String username, String attributeName) throws Exception {
+ JsonNode user = cognitoJson("AdminGetUser", """
+ {
+ "UserPoolId": "%s",
+ "Username": "%s"
+ }
+ """.formatted(poolId, username));
+ for (JsonNode attribute : user.path("UserAttributes")) {
+ if (attributeName.equals(attribute.path("Name").asText())) {
+ return attribute.path("Value").asText();
+ }
+ }
+ return null;
}
}
diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java
index 3ae4faa6a3..be8cef3a37 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/CognitoServiceTest.java
@@ -2983,6 +2983,86 @@ class CognitoServiceTest {
}
}
+ // KenkoGeek review, PR #2018: VerifyUserAttribute must require an access token (not an
+ // ID token) carrying the aws.cognito.signin.user.admin scope.
+ @Nested
+ class VerifyUserAttributeAuthorization {
+
+ private CognitoService svc;
+ private VerificationCodeService verificationCodeService;
+ private UserPool pool;
+ private UserPoolClient client;
+ private CognitoUser user;
+
+ @BeforeEach
+ void setUpVerification() {
+ verificationCodeService = mock(VerificationCodeService.class);
+ CognitoMessageDispatcher messageDispatcher = mock(CognitoMessageDispatcher.class);
+ svc = new CognitoService(
+ new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
+ new InMemoryStorage<>(),
+ "http://localhost:4566",
+ regionResolver,
+ null,
+ acmService,
+ verificationCodeService,
+ messageDispatcher,
+ mock(TlsCertificateManager.class)
+ );
+ pool = svc.createUserPool(Map.of("PoolName", "ScopeTestPool"), "us-east-1");
+ client = svc.createUserPoolClient(pool.getId(), "c", false, false, List.of(), List.of());
+ svc.adminCreateUser(pool.getId(), "alice", Map.of("email", "[email protected]"), "TempPass1!");
+ svc.adminSetUserPassword(pool.getId(), "alice", "Perm1234!", true);
+ user = svc.adminGetUser(pool.getId(), "alice");
+ }
+
+ @Test
+ void rejectsIdTokenEvenThoughItSharesTheSameClaims() {
+ // ID tokens never carry a scope claim (matching real Cognito), so this must be
+ // rejected on token_use alone, before the scope check ever runs.
+ String idToken = svc.generateSignedJwt(user, pool, "id", client, null);
+
+ AwsException ex = assertThrows(AwsException.class,
+ () -> svc.verifyUserAttribute(idToken, "email", "123456"));
+
+ assertEquals("NotAuthorizedException", ex.getErrorCode());
+ verify(verificationCodeService, never()).consume(any(), any(), any(), any());
+ }
+
+ @Test
+ void rejectsAccessTokenMissingTheRequiredScope() {
+ // Access tokens carry aws.cognito.signin.user.admin by default (generateSignedJwt),
+ // so building one that lacks it means explicitly suppressing the default and
+ // substituting something else, the way a Pre-Token-Generation V2 Lambda trigger would.
+ String accessToken = svc.generateSignedJwt(user, pool, "access", client,
+ new CognitoService.ClaimsOverride(null, null, null, null,
+ List.of("openid"), List.of("aws.cognito.signin.user.admin"),
+ null, null, null));
+
+ AwsException ex = assertThrows(AwsException.class,
+ () -> svc.verifyUserAttribute(accessToken, "email", "123456"));
+
+ assertEquals("NotAuthorizedException", ex.getErrorCode());
+ verify(verificationCodeService, never()).consume(any(), any(), any(), any());
+ }
+
+ @Test
+ void acceptsDefaultAccessTokenSinceItAlreadyCarriesTheRequiredScope() {
+ String accessToken = svc.generateSignedJwt(user, pool, "access", client, null);
+
+ svc.verifyUserAttribute(accessToken, "email", "123456");
+
+ verify(verificationCodeService).consume(pool.getId(), user.getUsername(),
+ VerificationCode.Purpose.EMAIL_ATTRIBUTE_VERIFICATION, "123456");
+ }
+ }
+
// ──────── UsernameAttributes=email: immutable UUID username + mutable email alias ────────
private UserPool createEmailAliasPool() {
diff --git a/src/test/java/io/github/hectorvent/floci/services/cognito/verification/VerificationCodeServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/cognito/verification/VerificationCodeServiceTest.java
index 44d98766b6..71cbb39e5e 100644
--- a/src/test/java/io/github/hectorvent/floci/services/cognito/verification/VerificationCodeServiceTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/cognito/verification/VerificationCodeServiceTest.java
@@ -50,6 +50,57 @@ class VerificationCodeServiceTest {
VerificationCode.Purpose.SIGNUP_CONFIRMATION, code));
}
+ @Test
+ void consume_consumedAttributeVerificationCode_throwsExpired() {
+ String code = service.issue("pool", "alice",
+ VerificationCode.Purpose.EMAIL_ATTRIBUTE_VERIFICATION, Duration.ofHours(24));
+ service.consume("pool", "alice",
+ VerificationCode.Purpose.EMAIL_ATTRIBUTE_VERIFICATION, code);
+
+ VerificationCodeException ex = assertThrows(VerificationCodeException.class,
+ () -> service.consume("pool", "alice",
+ VerificationCode.Purpose.EMAIL_ATTRIBUTE_VERIFICATION, code));
+
+ assertEquals(VerificationCodeException.Kind.EXPIRED, ex.getKind());
+ }
+
+ @Test
+ void consume_consumedSignupOrResetCode_throwsNotFound() {
+ // Unlike the attribute-verification purposes, SIGNUP_CONFIRMATION and
+ // PASSWORD_RESET delete on consume rather than retaining a tombstone: that
+ // reuse behavior was never validated against real Cognito for ConfirmSignUp
+ // or ConfirmForgotPassword, so it stays exactly as it was before this change.
+ String signupCode = service.issue("pool", "alice",
+ VerificationCode.Purpose.SIGNUP_CONFIRMATION, Duration.ofHours(24));
+ service.consume("pool", "alice",
+ VerificationCode.Purpose.SIGNUP_CONFIRMATION, signupCode);
+ VerificationCodeException signupEx = assertThrows(VerificationCodeException.class,
+ () -> service.consume("pool", "alice",
+ VerificationCode.Purpose.SIGNUP_CONFIRMATION, signupCode));
+ assertEquals(VerificationCodeException.Kind.NOT_FOUND, signupEx.getKind());
+
+ String resetCode = service.issue("pool", "bob",
+ VerificationCode.Purpose.PASSWORD_RESET, Duration.ofHours(1));
+ service.consume("pool", "bob",
+ VerificationCode.Purpose.PASSWORD_RESET, resetCode);
+ VerificationCodeException resetEx = assertThrows(VerificationCodeException.class,
+ () -> service.consume("pool", "bob",
+ VerificationCode.Purpose.PASSWORD_RESET, resetCode));
+ assertEquals(VerificationCodeException.Kind.NOT_FOUND, resetEx.getKind());
+ }
+
+ @Test
+ void issue_afterConsumedCode_succeedsImmediately() {
+ String code = service.issue("pool", "alice",
+ VerificationCode.Purpose.SIGNUP_CONFIRMATION, Duration.ofHours(24));
+ service.consume("pool", "alice",
+ VerificationCode.Purpose.SIGNUP_CONFIRMATION, code);
+
+ assertDoesNotThrow(() ->
+ service.issue("pool", "alice",
+ VerificationCode.Purpose.SIGNUP_CONFIRMATION, Duration.ofHours(24)));
+ }
+
@Test
void consume_wrongCode_throwsMismatch() {
service.issue("pool", "alice",