Light, fluffy, and always free - The AWS Local Emulator alternative
feat(iam): change the calling user's console password (#5546)
Priamo Germosen5ea632cc1335
diff --git a/docs/services/iam.md b/docs/services/iam.mdindex 5f38141553..fd9bbcba39 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -305,6 +305,7 @@ validation.| GetLoginProfile | Returns a user's login profile. || UpdateLoginProfile | Updates a user's login profile password and/or reset-required flag. || DeleteLoginProfile | Deletes a user's login profile. |+| ChangePassword | Changes the console password of the user who is calling. |`UserName` is optional on `CreateLoginProfile`, `GetLoginProfile` and `DeleteLoginProfile`: itdefaults to the user resolved from the signing access key, the same fallback `GetUser` uses. It is@@ -321,6 +322,37 @@ also checked against that policy's length and character-class requirements, with`PasswordPolicyViolation` returned on either action if it doesn't comply. The password itself is neverechoed back by any of these actions, matching AWS.+`ChangePassword` is the self-service half of `UpdateLoginProfile`. It takes no `UserName` and acts+only on the user whose access key signed the request, which is what the API reference means by "the+IAM user who is calling this operation", and the account root password is not affected by it. A+caller with no IAM user behind its key, which is Floci's stand-in for account root credentials, is+refused with `InvalidUserType`, the error the CLI reference documents for that case. `OldPassword`+must match the stored password, and the reference publishes no error for a mismatch, so Floci+answers `InvalidParameterValue`, the common error type for a parameter value the service cannot+accept. It is checked before the new password is held to the account policy, so a caller who cannot+prove the current password learns nothing about what the policy requires. A successful change+clears `PasswordResetRequired`, which is what lets a user whose password an administrator reset+restore their own console access programmatically, and it updates the `password_last_changed` the+credential report reads.++`PasswordReusePrevention` is enforced on `ChangePassword` and on `UpdateLoginProfile`, which share+one history per login profile, so an administrator reset cannot put back a password a user has just+been refused. The reference defines the value as "the number of previous passwords that IAM users+are prevented from reusing", and says that with no value set users "are not prevented from reusing+previous passwords". The password the profile currently holds is refused alongside the superseded+ones, which the reference does not spell out: read the other way, the smallest window the policy+accepts would still allow setting a password to the value it already has, and would not refuse the+change away and straight back that the setting exists for. History is recorded whether or not a+window is set, so switching the policy on has something to compare against, bounded at the 24 the+policy can ask for, and it goes with the profile when `DeleteLoginProfile` removes it.++`AllowUsersToChangePassword` is accepted and reported but grants nothing. The user+guide says the option gives all users in the account "access to the iam:ChangePassword action for+only their user and to the iam:GetAccountPasswordPolicy action", applied at the account level+rather than by attaching a policy to each user. Floci authorizes both actions from identity+policies alone, so under [enforcement](#iam-enforcement-mode) a caller needs a policy naming their+own user however the flag is set.+`DeleteUser` returns `DeleteConflict`, as on AWS, while the user still has a login profile, accesskeys, inline policies, attached managed policies, group memberships, an[enabled MFA device](#multi-factor-authentication), adiff --git a/docs/services/index.md b/docs/services/index.mdindex c5bd2a89d1..cda7b79b1e 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -22,7 +22,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [Lambda MicroVMs](lambda-microvms.md) | `/2025-09-09/...` + `/2026-04-04/...` | REST JSON | 22 || [API Gateway v1](api-gateway.md) | `/restapis/...` | REST JSON | 79 || [API Gateway v2](api-gateway.md#v2) | `/v2/apis/...` | REST JSON | 53 + data-plane |-| [IAM](iam.md) | `POST /` with `Action=` param | Query | 166 |+| [IAM](iam.md) | `POST /` with `Action=` param | Query | 167 || [STS](sts.md) | `POST /` with `Action=` param | Query | 7 || [AWS Sign-In](iam.md#aws-sign-in-login-credentials) | `/v1/authorize`, `/v1/token` | REST JSON | 2 || [Organizations](organizations.md) | `POST /` + `X-Amz-Target: AWSOrganizationsV20161128.*` | JSON 1.1 | 56 |diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex fe6962402d..ea95d8df3d 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java@@ -104,6 +104,7 @@ public class AwsQueryController {"TagPolicy", "UntagPolicy", "ListPolicyTags","TagInstanceProfile", "UntagInstanceProfile", "ListInstanceProfileTags","CreateLoginProfile", "GetLoginProfile", "DeleteLoginProfile", "UpdateLoginProfile",+ "ChangePassword","GenerateCredentialReport", "GetCredentialReport","GetAccountSummary", "GetAccountAuthorizationDetails","SimulatePrincipalPolicy", "SimulateCustomPolicy",diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.javaindex 09c8b5986b..3e45bf929e 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java@@ -130,6 +130,7 @@ public class IamQueryHandler {case "GetLoginProfile" -> handleGetLoginProfile(params, authorization);case "UpdateLoginProfile" -> handleUpdateLoginProfile(params);case "DeleteLoginProfile" -> handleDeleteLoginProfile(params, authorization);+ case "ChangePassword" -> handleChangePassword(params, authorization);// Multi-factor authenticationcase "CreateVirtualMFADevice" -> handleCreateVirtualMFADevice(params);@@ -571,6 +572,40 @@ public class IamQueryHandler {return Response.ok(AwsQueryResponse.envelopeNoResult("DeleteLoginProfile", AwsNamespaces.IAM)).build();}+ /**+ * Changes the calling user's console password. The operation takes no {@code UserName}: the+ * reference says it "changes the password of the IAM user who is calling this operation", and+ * the CLI reference adds that it "can be called by IAM users only. If this command is called+ * using AWS account (root) credentials, the command returns an InvalidUserType error". A+ * signing key that belongs to no stored user is Floci's stand-in for exactly that caller, so+ * it answers the same way rather than reporting the key as missing.+ */+ private Response handleChangePassword(MultivaluedMap<String, String> params,+ String authorization) {+ // Both members are required, and read through getParam rather than requireParam because+ // requireParam refuses a blank value where passwordType permits one: the pattern starts+ // at \u0020, so a password of spaces is a value the model accepts. The shape check+ // therefore stays with the pattern, which also names which of the two members failed.+ iamService.changePassword(callingIamUser(authorization),+ getParam(params, "OldPassword"), getParam(params, "NewPassword"));+ return Response.ok(+ AwsQueryResponse.envelopeNoResult("ChangePassword", AwsNamespaces.IAM)).build();+ }++ /**+ * The IAM user whose access key signed the request, for the one operation that acts on the+ * caller and gives no way to name anyone else. Unlike {@link #resolveUserName}, a key with no+ * user behind it is not a missing entity here: the caller is not an IAM user, which is the+ * case {@code InvalidUserType} is published for.+ */+ private String callingIamUser(String authorization) {+ String accessKeyId = accountResolver.extractAccessKeyId(authorization);+ return iamService.findUserNameByAccessKeyId(accessKeyId)+ .orElseThrow(() -> new AwsException("InvalidUserType",+ "The request was rejected because the type of user for the transaction "+ + "was incorrect.", 400));+ }+private String loginProfileXml(LoginProfile profile) {return new XmlBuilder().elem("PasswordResetRequired", profile.isPasswordResetRequired())diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.javaindex d4d288cd89..72f1a7342a 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java@@ -387,6 +387,15 @@ public class IamService implements SessionAccountLookup, ResourceProvider {private final String seededAccountAlias;/** Guards case-insensitive IAM name uniqueness checks and their corresponding writes. */private final Object resourceNameLock = new Object();+ /**+ * Guards every check-then-write on a login profile. ChangePassword is the reason it has to+ * exist: it reads the profile to compare the old password, then writes the new one, so two+ * requests presenting the same valid old password would otherwise both pass the comparison+ * and both report success while only the later write survived. Every writer takes it, since a+ * guard one writer skips guarantees nothing: a racing UpdateLoginProfile would overwrite the+ * password a ChangePassword had just been told it could set.+ */+ private final Object loginProfileLock = new Object();/*** AWS-managed policies ({@code arn:<partition>:iam::aws:policy/...}), keyed by ARN, one map@@ -888,11 +897,13 @@ public class IamService implements SessionAccountLookup, ResourceProvider {credential.getServiceSpecificCredentialId(), credential);}}- loginProfiles.get(userName).ifPresent(profile -> {- loginProfiles.delete(userName);- profile.setUserName(newUserName);- loginProfiles.put(newUserName, profile);- });+ synchronized (loginProfileLock) {+ loginProfiles.get(userName).ifPresent(profile -> {+ loginProfiles.delete(userName);+ profile.setUserName(newUserName);+ loginProfiles.put(newUserName, profile);+ });+ }for (AccessKey key : keysToMove) {key.setUserName(newUserName);accessKeys.put(key.getAccessKeyId(), key);@@ -2338,13 +2349,19 @@ public class IamService implements SessionAccountLookup, ResourceProvider {/** A user holds at most one login profile: creating a second is EntityAlreadyExists. */public LoginProfile createLoginProfile(String userName, String password, boolean passwordResetRequired) {getUser(userName);- if (loginProfiles.get(userName).isPresent()) {- throw new AwsException("EntityAlreadyExists",- "Login Profile for User " + userName + " already exists.", 409);+ LoginProfile profile;+ synchronized (loginProfileLock) {+ if (loginProfiles.get(userName).isPresent()) {+ throw new AwsException("EntityAlreadyExists",+ "Login Profile for User " + userName + " already exists.", 409);+ }+ validatePassword(password, "password");+ // No profile to pass: a password being set for the first time replaces nothing, and a+ // profile deleted and recreated takes its history with it.+ checkPasswordPolicy(password, null);+ profile = new LoginProfile(userName, password, passwordResetRequired);+ loginProfiles.put(userName, profile);}- validateLoginProfilePassword(password);- LoginProfile profile = new LoginProfile(userName, password, passwordResetRequired);- loginProfiles.put(userName, profile);LOG.infov("Created IAM login profile for user: {0}", userName);return profile;}@@ -2364,42 +2381,166 @@ public class IamService implements SessionAccountLookup, ResourceProvider {* clear the reset-required flag, and vice versa.*/public void updateLoginProfile(String userName, String password, Boolean passwordResetRequired) {- LoginProfile profile = getLoginProfile(userName);- if (password != null) {- validateLoginProfilePassword(password);- profile.setPassword(password);- profile.setPasswordLastChanged(Instant.now());- }- if (passwordResetRequired != null) {- profile.setPasswordResetRequired(passwordResetRequired);+ synchronized (loginProfileLock) {+ LoginProfile profile = getLoginProfile(userName);+ if (password != null) {+ validatePassword(password, "password");+ checkPasswordPolicy(password, profile);+ recordSupersededPassword(profile);+ profile.setPassword(password);+ profile.setPasswordLastChanged(Instant.now());+ }+ if (passwordResetRequired != null) {+ profile.setPasswordResetRequired(passwordResetRequired);+ }+ loginProfiles.put(userName, profile);}- loginProfiles.put(userName, profile);LOG.infov("Updated IAM login profile for user: {0}", userName);}public void deleteLoginProfile(String userName) {getUser(userName);- if (loginProfiles.get(userName).isEmpty()) {- throw new AwsException("NoSuchEntity",- "Login Profile for User " + userName + " cannot be found.", 404);+ synchronized (loginProfileLock) {+ if (loginProfiles.get(userName).isEmpty()) {+ throw new AwsException("NoSuchEntity",+ "Login Profile for User " + userName + " cannot be found.", 404);+ }+ loginProfiles.delete(userName);}- loginProfiles.delete(userName);LOG.infov("Deleted IAM login profile for user: {0}", userName);}/**- * Base wire validation shared by Create/UpdateLoginProfile, then, only when the account has- * ever set one (matching {@link #getAccountPasswordPolicy}'s own NoSuchEntity-by-default- * semantics), the account's password policy.+ * Changes the password of the IAM user who is calling, which is the only user+ * {@code ChangePassword} can act on: the reference says it "changes the password of the IAM+ * user who is calling this operation" and that "the AWS account root user password is not+ * affected by this operation". The caller is resolved from the signing access key before this+ * is reached, so the user name here is already that user.+ *+ * <p>The old password is checked before the new one is held to the account's policy, so a+ * caller who cannot prove the current password is refused on that alone and learns nothing+ * about what the policy would have required.+ *+ * <p>The comparison and the write are one step under {@code loginProfileLock}, which is what+ * makes the refusal above mean anything: read apart from the write, two requests presenting+ * the same valid old password would both pass the comparison and both be told they had set+ * the password, while only the later write survived.+ *+ * <p>A successful change clears {@code PasswordResetRequired}. The user guide's own reason for+ * the "Password expiration requires administrator reset" option is that it stops users+ * updating their own password through the console, and says that even then "IAM users with+ * iam:ChangePassword permission and active access keys can reset their own IAM user console+ * password programmatically", which is only true if the change itself clears the state the+ * reset left behind.+ *+ * <p>An old password that does not match is the one refusal the reference leaves unnamed:+ * every error it publishes for this operation describes something else, and the error it+ * documents for a caller that is not an IAM user is {@code InvalidUserType}, raised by the+ * handler. The common error types are additive per action, so this answers+ * {@code InvalidParameterValue}, which is the published one for a parameter value the service+ * cannot accept, with the same 400 as the operation's other sender faults.*/- private void validateLoginProfilePassword(String password) {- if (password == null || !LOGIN_PROFILE_PASSWORD_PATTERN.matcher(password).matches()) {+ public void changePassword(String userName, String oldPassword, String newPassword) {+ validatePassword(oldPassword, "oldPassword");+ validatePassword(newPassword, "newPassword");+ synchronized (loginProfileLock) {+ LoginProfile profile = getLoginProfile(userName);+ if (!oldPassword.equals(profile.getPassword())) {+ throw new AwsException("InvalidParameterValue",+ "The old password supplied is not the current password for user "+ + userName + ".", 400);+ }+ checkPasswordPolicy(newPassword, profile);+ recordSupersededPassword(profile);+ profile.setPassword(newPassword);+ profile.setPasswordLastChanged(Instant.now());+ profile.setPasswordResetRequired(false);+ loginProfiles.put(userName, profile);+ }+ LOG.infov("Changed the IAM console password of user: {0}", userName);+ }++ /**+ * The account's password policy applied to a password about to be stored, and only when the+ * account has ever set one, matching {@link #getAccountPasswordPolicy}'s own+ * NoSuchEntity-by-default semantics. {@code replacing} is the profile the password is being+ * written over, or null when there is none to reuse a password from.+ */+ private void checkPasswordPolicy(String password, LoginProfile replacing) {+ getAccountPasswordPolicy().ifPresent(policy -> {+ checkPasswordAgainstPolicy(password, policy);+ if (replacing != null) {+ checkPasswordNotReused(replacing, password, policy);+ }+ });+ }++ /**+ * Refuses a password the account's reuse window still holds. The reference defines+ * {@code PasswordReusePrevention} as "the number of previous passwords that IAM users are+ * prevented from reusing", with no value meaning "IAM users are not prevented from reusing+ * previous passwords", so the window is that many superseded passwords.+ *+ * <p>The password the profile currently holds is refused alongside them, which the reference+ * does not spell out. Reading it the other way makes a window of 1 refuse nothing a user+ * would attempt: it would leave setting a password to the value it already has allowed, and+ * that is reuse in the only sense the setting exists to stop. Counting the current password+ * first is also what makes the A to B and back to A case refusable at the smallest window the+ * policy accepts.+ */+ private static void checkPasswordNotReused(LoginProfile profile, String password,+ AccountPasswordPolicy policy) {+ Integer window = policy.getPasswordReusePrevention();+ if (window == null) {+ return;+ }+ List<String> held = profile.getPreviousPasswords();+ List<String> refused = new ArrayList<>();+ refused.add(profile.getPassword());+ refused.addAll(held.subList(0, Math.min(window, held.size())));+ if (refused.contains(password)) {+ throw new AwsException("PasswordPolicyViolation",+ "Password does not conform to the account password policy. It must not be the "+ + "current password or one of the previous " + window+ + " passwords.", 400);+ }+ }++ /**+ * Moves the password a profile is about to lose into its history, newest first. Bounded at the+ * largest window {@code PasswordReusePrevention} accepts, since nothing can be asked about a+ * password further back than that.+ */+ private static void recordSupersededPassword(LoginProfile profile) {+ List<String> held = profile.getPreviousPasswords();+ held.add(0, profile.getPassword());+ while (held.size() > PASSWORD_REUSE_PREVENTION_CEILING) {+ held.remove(held.size() - 1);+ }+ }++ /**+ * {@code passwordType}, which every password member on every one of these operations shares.+ * The member is named so the message is the one AWS gives for the parameter that failed:+ * {@code ChangePassword} has two of them, and a caller told that 'password' failed has to+ * guess which.+ *+ * <p>An absent member and an empty one are different answers. The pattern requires at least+ * one character, so an empty value fails the constraint, where an absent one was never+ * supplied at all.+ */+ private static void validatePassword(String password, String member) {+ if (password == null) {throw new AwsException("ValidationError",- "1 validation error detected: Value at 'password' failed to satisfy constraint: "- + "Member must have length less than or equal to 128 and greater than or "- + "equal to 1", 400);+ "1 validation error detected: Value null at '" + member+ + "' failed to satisfy constraint: Member must not be null", 400);+ }+ if (!LOGIN_PROFILE_PASSWORD_PATTERN.matcher(password).matches()) {+ throw new AwsException("ValidationError",+ "1 validation error detected: Value at '" + member+ + "' failed to satisfy constraint: Member must have length less than "+ + "or equal to 128 and greater than or equal to 1", 400);}- getAccountPasswordPolicy().ifPresent(policy -> checkPasswordAgainstPolicy(password, policy));}private void checkPasswordAgainstPolicy(String password, AccountPasswordPolicy policy) {@@ -3476,7 +3617,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {* <p>The API Reference publishes a length of 20 to 128 as well as the pattern, so both are* checked, and both are reported when both are broken, in the order it prints them. The* pattern message is the one recorded against AWS; the length wording is the form AWS uses for- * a member carrying both bounds, which {@link #validateLoginProfilePassword} spells the same+ * a member carrying both bounds, which {@link #validatePassword} spells the same* way.*/private void requireCredentialIdFormat(String credentialId) {diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/model/LoginProfile.java b/src/main/java/io/github/hectorvent/floci/services/iam/model/LoginProfile.javaindex 284423b9b4..1936feaeef 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/model/LoginProfile.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/model/LoginProfile.java@@ -4,13 +4,16 @@ import com.fasterxml.jackson.annotation.JsonIgnoreProperties;import io.quarkus.runtime.annotations.RegisterForReflection;import java.time.Instant;+import java.util.ArrayList;+import java.util.List;/*** A user's console (password) login profile. At most one per user, mirroring AWS: creating* one when the user already has one is {@code EntityAlreadyExists}, and a user with no- * console password simply has no entry here. The password is stored in plain text, matching- * how {@link AccessKey} already stores its secret: this is an emulator, not a credential- * store, and AWS itself never echoes the password back on any of these actions.+ * console password simply has no entry here. The password, and the history the reuse window is+ * checked against, are stored in plain text, matching how {@link AccessKey} already stores its+ * secret: this is an emulator, not a credential store, and AWS itself never echoes the password+ * back on any of these actions.*/@RegisterForReflection@JsonIgnoreProperties(ignoreUnknown = true)@@ -27,6 +30,13 @@ public class LoginProfile {* a profile persisted before this field existed; callers fall back to {@link #createDate}.*/private Instant passwordLastChanged;+ /**+ * The passwords this profile held before the current one, most recent first, bounded at the 24+ * {@code PasswordReusePrevention} is allowed to ask for. Recorded whether or not the account+ * sets that policy, so switching it on has something to compare against, and empty for a+ * profile persisted before this field existed.+ */+ private List<String> previousPasswords = new ArrayList<>();public LoginProfile() {}@@ -54,4 +64,16 @@ public class LoginProfile {public Instant getPasswordLastChanged() { return passwordLastChanged; }public void setPasswordLastChanged(Instant passwordLastChanged) { this.passwordLastChanged = passwordLastChanged; }++ public List<String> getPreviousPasswords() {+ if (previousPasswords == null) {+ previousPasswords = new ArrayList<>();+ }+ return previousPasswords;+ }++ public void setPreviousPasswords(List<String> previousPasswords) {+ this.previousPasswords =+ previousPasswords != null ? new ArrayList<>(previousPasswords) : new ArrayList<>();+ }}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamChangePasswordIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamChangePasswordIntegrationTest.javanew file mode 100644index 0000000000..38d7f0f431--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamChangePasswordIntegrationTest.java@@ -0,0 +1,174 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.core.common.AwsQueryController;+import io.github.hectorvent.floci.testing.PartitionCleanup;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.response.ValidatableResponse;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;++import java.util.Map;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;++/**+ * {@code ChangePassword} over the wire, which is the only IAM operation that acts on the caller+ * and gives no way to name anyone else.+ *+ * <p>Driven through the whole stack because two of the things worth checking live outside the+ * handler. The caller is read from the signing access key, so a request signed with a key that+ * belongs to a user has to reach that user and nobody else. And the action name is shared with+ * Cognito, so a request that arrives without a usable credential scope has to be routed to IAM by+ * {@link AwsQueryController}: Cognito is further down that chain and answers+ * {@code UnsupportedOperation} to every form request, so the routing is what decides whether the+ * operation exists at all on that path.+ *+ * <p>Runs in an account of its own, like the other IAM classes that set account-wide state: the+ * emulator is shared, and an account password policy left visible to another class changes what+ * that class's passwords are held to.+ */+@QuarkusTest+class IamChangePasswordIntegrationTest {++ private static final String ACCOUNT = "000000000911";+ private static final String REGION = "us-east-1";+ private static final String PASSWORD = "Sup3r$ecret!";+ private static final String NEW_PASSWORD = "An0ther$ecret!";++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ @Test+ void theSignerChangesItsOwnPassword() {+ String accessKeyId = userWithAConsolePassword("changes-own");++ signedAs(accessKeyId, Map.of("OldPassword", PASSWORD, "NewPassword", NEW_PASSWORD))+ .statusCode(200)+ .body("ChangePasswordResponse.ResponseMetadata.RequestId", not(equalTo("")));++ // Nothing echoes a password back, so the proof the write took is the next call: the old+ // password is no longer the current one and the new one is.+ signedAs(accessKeyId, Map.of("OldPassword", PASSWORD, "NewPassword", "Th1rd$ecret!"))+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidParameterValue"));+ signedAs(accessKeyId, Map.of("OldPassword", NEW_PASSWORD, "NewPassword", "Th1rd$ecret!"))+ .statusCode(200);+ }++ @Test+ void aSignerWithNoConsolePasswordIsNoSuchEntity() {+ String accessKeyId = userWithoutAConsolePassword("no-profile");++ signedAs(accessKeyId, Map.of("OldPassword", PASSWORD, "NewPassword", NEW_PASSWORD))+ .statusCode(404)+ .body("ErrorResponse.Error.Code", equalTo("NoSuchEntity"));+ }++ @Test+ void anAccountCredentialIsInvalidUserType() {+ // The account's own credential stands in for the root user, which the CLI reference says+ // this operation answers InvalidUserType for.+ admin("ChangePassword", Map.of("OldPassword", PASSWORD, "NewPassword", NEW_PASSWORD))+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidUserType"));+ }++ @Test+ void anUnsignedRequestIsAnsweredByIamRatherThanCognito() {+ // No credential scope, so the service comes from the action name alone. Cognito also+ // publishes ChangePassword; reaching it would answer UnsupportedOperation instead.+ given()+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", "ChangePassword")+ .formParam("Version", "2010-05-08")+ .formParam("OldPassword", PASSWORD)+ .formParam("NewPassword", NEW_PASSWORD)+ .when().post("/")+ .then()+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidUserType"))+ .body(not(containsString("UnsupportedOperation")));+ }++ @Test+ void anAbsentMemberNamesItself() {+ String accessKeyId = userWithAConsolePassword("absent-member");++ signedAs(accessKeyId, Map.of("NewPassword", NEW_PASSWORD))+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ .body("ErrorResponse.Error.Message", containsString("'oldPassword'"));+ }++ @Test+ void theNewPasswordIsHeldToTheAccountPasswordPolicy() {+ String accessKeyId = userWithAConsolePassword("policy");+ admin("UpdateAccountPasswordPolicy", Map.of("MinimumPasswordLength", "20",+ "RequireSymbols", "true", "RequireNumbers", "true")).statusCode(200);+ cleanup.register(() -> admin("DeleteAccountPasswordPolicy", Map.of()).statusCode(200));++ signedAs(accessKeyId, Map.of("OldPassword", PASSWORD, "NewPassword", "sh0rt!"))+ .statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("PasswordPolicyViolation"));++ signedAs(accessKeyId,+ Map.of("OldPassword", PASSWORD, "NewPassword", "L0ngEn0ugh$ecret!!!!"))+ .statusCode(200);+ }++ /** A user holding a console password, with an access key to sign its own requests with. */+ private String userWithAConsolePassword(String label) {+ String userName = user(label);+ admin("CreateLoginProfile", Map.of("UserName", userName, "Password", PASSWORD))+ .statusCode(200);+ cleanup.register(() -> admin("DeleteLoginProfile", Map.of("UserName", userName))+ .statusCode(200));+ return accessKeyFor(userName);+ }++ /** The same, minus the console password: an IAM user with nothing to change. */+ private String userWithoutAConsolePassword(String label) {+ return accessKeyFor(user(label));+ }++ private String user(String label) {+ String userName = "change-password-" + label;+ admin("CreateUser", Map.of("UserName", userName)).statusCode(200);+ cleanup.register(() -> admin("DeleteUser", Map.of("UserName", userName)).statusCode(200));+ return userName;+ }++ private String accessKeyFor(String userName) {+ String accessKeyId = admin("CreateAccessKey", Map.of("UserName", userName)).statusCode(200)+ .extract().path("CreateAccessKeyResponse.CreateAccessKeyResult.AccessKey"+ + ".AccessKeyId");+ cleanup.register(() -> admin("DeleteAccessKey",+ Map.of("UserName", userName, "AccessKeyId", accessKeyId)).statusCode(200));+ return accessKeyId;+ }++ private ValidatableResponse signedAs(String accessKeyId, Map<String, String> params) {+ return iam(accessKeyId, "ChangePassword", params);+ }++ private ValidatableResponse admin(String action, Map<String, String> params) {+ return iam(ACCOUNT, action, params);+ }++ private static ValidatableResponse iam(String accessKeyId, String action,+ Map<String, String> params) {+ RequestSpecification spec = given()+ .header("Authorization", "AWS4-HMAC-SHA256 Credential=" + accessKeyId+ + "/20261012/" + REGION + "/iam/aws4_request, SignedHeaders=host, "+ + "Signature=abc")+ .contentType("application/x-www-form-urlencoded")+ .formParam("Action", action)+ .formParam("Version", "2010-05-08");+ params.forEach(spec::formParam);+ return spec.when().post("/").then();+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamConcurrencyTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamConcurrencyTest.javaindex e39161df87..5495afbc45 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamConcurrencyTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamConcurrencyTest.java@@ -346,6 +346,57 @@ class IamConcurrencyTest {}}+ /**+ * Every racing ChangePassword presents the same valid old password, so exactly one can be+ * right: once the first write lands, the old password the others hold is no longer the current+ * one. A request told it succeeded has to be the one whose password is in the store, since the+ * caller has no way to find out otherwise, the operation echoing nothing back.+ */+ @Test+ void concurrentPasswordChangesLeaveExactlyOneWinner() throws Exception {+ ExecutorService pool = Executors.newFixedThreadPool(THREADS);+ try {+ for (int trial = 0; trial < TRIALS; trial++) {+ IamService iam = newIamService();+ iam.createUser("racer", "/");+ iam.createLoginProfile("racer", "Passw0rd$start", false);+ CountDownLatch start = new CountDownLatch(1);+ CountDownLatch done = new CountDownLatch(N);+ List<String> winners = new CopyOnWriteArrayList<>();+ List<String> unexpected = new CopyOnWriteArrayList<>();++ for (int i = 0; i < N; i++) {+ String candidate = "Passw0rd$" + i;+ pool.execute(() -> {+ try {+ start.await(10, TimeUnit.SECONDS);+ iam.changePassword("racer", "Passw0rd$start", candidate);+ winners.add(candidate);+ } catch (io.github.hectorvent.floci.core.common.AwsException e) {+ if (!"InvalidParameterValue".equals(e.getErrorCode())) {+ unexpected.add(e.getErrorCode());+ }+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ } finally {+ done.countDown();+ }+ });+ }+ start.countDown();+ assertTrue(done.await(30, TimeUnit.SECONDS), "password workers stalled");++ String stored = iam.getLoginProfile("racer").getPassword();+ if (winners.size() != 1 || !winners.contains(stored) || !unexpected.isEmpty()) {+ fail("changePassword trial " + trial + ": winners=" + winners+ + " stored=" + stored + " unexpectedErrors=" + unexpected);+ }+ }+ } finally {+ pool.shutdownNow();+ }+ }+private static String[] createPolicies(IamService iam, String prefix) {String[] arns = new String[N];for (int i = 0; i < N; i++) {diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.javaindex 46ec1e3660..3f43e1156d 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamServiceTest.java@@ -871,6 +871,194 @@ class IamServiceTest {assertEquals("alice", profile.getUserName());}+ @Test+ void changePasswordReplacesThePasswordAndClearsTheResetFlag() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Sup3r$ecret!", true);++ iamService.changePassword("alice", "Sup3r$ecret!", "An0ther$ecret!");++ LoginProfile profile = iamService.getLoginProfile("alice");+ assertFalse(profile.isPasswordResetRequired(),+ "a self-service change is what clears the reset an administrator required");+ assertNotNull(profile.getPasswordLastChanged());+ // The proof the write took is behavioural rather than a read of the stored field: the+ // new password is now the current one and the old one is not.+ iamService.changePassword("alice", "An0ther$ecret!", "Th1rd$ecret!");+ assertEquals("InvalidParameterValue", assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", "An0ther$ecret!", "F0urth$ecret!"))+ .getErrorCode());+ }++ @Test+ void changePasswordWithTheWrongOldPasswordChangesNothing() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Sup3r$ecret!", false);++ AwsException ex = assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", "N0tTheOne!", "An0ther$ecret!"));++ assertEquals("InvalidParameterValue", ex.getErrorCode());+ assertEquals(400, ex.getHttpStatus());+ // The refusal left the password alone, so the original still changes it.+ iamService.changePassword("alice", "Sup3r$ecret!", "An0ther$ecret!");+ }++ @Test+ void changePasswordChecksTheOldPasswordBeforeTheAccountPolicy() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Sup3r$ecret!", false);+ AccountPasswordPolicy policy = new AccountPasswordPolicy();+ policy.setMinimumPasswordLength(12);+ iamService.updateAccountPasswordPolicy(policy);++ // Both halves of the request are wrong. A caller who cannot prove the current password is+ // told that and nothing about what the policy would have required.+ AwsException ex = assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", "N0tTheOne!", "short"));++ assertEquals("InvalidParameterValue", ex.getErrorCode());+ }++ @Test+ void changePasswordHoldsTheNewPasswordToTheAccountPolicy() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Sup3r$ecret!", false);+ AccountPasswordPolicy policy = new AccountPasswordPolicy();+ policy.setMinimumPasswordLength(12);+ policy.setRequireSymbols(true);+ policy.setRequireNumbers(true);+ iamService.updateAccountPasswordPolicy(policy);++ AwsException ex = assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", "Sup3r$ecret!", "short"));++ assertEquals("PasswordPolicyViolation", ex.getErrorCode());+ assertEquals(400, ex.getHttpStatus());+ iamService.changePassword("alice", "Sup3r$ecret!", "An0ther$ecret!");+ }++ @Test+ void changePasswordNamesTheMemberThatFailedItsConstraint() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Sup3r$ecret!", false);++ AwsException missing = assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", null, "An0ther$ecret!"));+ assertEquals("ValidationError", missing.getErrorCode());+ assertTrue(missing.getMessage().contains("Value null at 'oldPassword'"), missing.getMessage());++ // An empty member is a value that fails the pattern rather than a member never supplied,+ // and the message names the one that failed, there being two password members here.+ AwsException empty = assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", "Sup3r$ecret!", ""));+ assertEquals("ValidationError", empty.getErrorCode());+ assertTrue(empty.getMessage().contains("Value at 'newPassword'"), empty.getMessage());+ }++ @Test+ void changePasswordRefusesAPasswordTheReuseWindowStillHolds() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Sup3r$ecret!", false);+ AccountPasswordPolicy policy = new AccountPasswordPolicy();+ policy.setPasswordReusePrevention(1);+ iamService.updateAccountPasswordPolicy(policy);++ iamService.changePassword("alice", "Sup3r$ecret!", "An0ther$ecret!");++ // The window is one superseded password, and the one in hand counts alongside it, so+ // neither going back nor standing still is allowed.+ assertEquals("PasswordPolicyViolation", assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", "An0ther$ecret!", "Sup3r$ecret!"))+ .getErrorCode());+ assertEquals("PasswordPolicyViolation", assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", "An0ther$ecret!", "An0ther$ecret!"))+ .getErrorCode());+ }++ @Test+ void changePasswordAllowsAPasswordThatHasLeftTheReuseWindow() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Sup3r$ecret!", false);+ AccountPasswordPolicy policy = new AccountPasswordPolicy();+ policy.setPasswordReusePrevention(1);+ iamService.updateAccountPasswordPolicy(policy);++ iamService.changePassword("alice", "Sup3r$ecret!", "An0ther$ecret!");+ iamService.changePassword("alice", "An0ther$ecret!", "Th1rd$ecret!");++ // A window of one reaches the current password and the one before it, and the first is+ // now two back, so it is reachable again.+ iamService.changePassword("alice", "Th1rd$ecret!", "Sup3r$ecret!");+ assertNotNull(iamService.getLoginProfile("alice").getPasswordLastChanged());+ }++ @Test+ void changePasswordWithNoReusePolicyTakesTheOldPasswordBack() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Sup3r$ecret!", false);+ AccountPasswordPolicy policy = new AccountPasswordPolicy();+ policy.setMinimumPasswordLength(8);+ iamService.updateAccountPasswordPolicy(policy);++ // A policy that sets no window prevents nothing: the reference's default is that users+ // "are not prevented from reusing previous passwords".+ iamService.changePassword("alice", "Sup3r$ecret!", "An0ther$ecret!");+ iamService.changePassword("alice", "An0ther$ecret!", "Sup3r$ecret!");+ }++ @Test+ void updateLoginProfileIsHeldToTheSameReuseWindow() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Sup3r$ecret!", false);+ AccountPasswordPolicy policy = new AccountPasswordPolicy();+ policy.setPasswordReusePrevention(2);+ iamService.updateAccountPasswordPolicy(policy);+ iamService.updateLoginProfile("alice", "An0ther$ecret!", null);++ // An administrator reset is a password the policy applies to as much as a self-service+ // change, and the two share one history.+ assertEquals("PasswordPolicyViolation", assertThrows(AwsException.class,+ () -> iamService.updateLoginProfile("alice", "Sup3r$ecret!", null)).getErrorCode());+ assertEquals("PasswordPolicyViolation", assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", "An0ther$ecret!", "Sup3r$ecret!"))+ .getErrorCode());+ }++ @Test+ void loginProfileHistoryStopsAtTheWidestWindowThePolicyAccepts() {+ iamService.createUser("alice", "/");+ iamService.createLoginProfile("alice", "Passw0rd$0", false);+ for (int i = 1; i <= 30; i++) {+ iamService.updateLoginProfile("alice", "Passw0rd$" + i, null);+ }++ // Nothing can be asked about a password further back than the largest window, so the+ // history stops there rather than growing with every change.+ assertEquals(24, iamService.getLoginProfile("alice").getPreviousPasswords().size());+ assertEquals("Passw0rd$29",+ iamService.getLoginProfile("alice").getPreviousPasswords().get(0));+ }++ @Test+ void changePasswordForAUserWithoutAConsolePasswordIsNoSuchEntity() {+ iamService.createUser("alice", "/");++ AwsException ex = assertThrows(AwsException.class,+ () -> iamService.changePassword("alice", "Sup3r$ecret!", "An0ther$ecret!"));++ assertEquals("NoSuchEntity", ex.getErrorCode());+ assertEquals(404, ex.getHttpStatus());+ }++ @Test+ void changePasswordForAnUnknownUserIsNoSuchEntity() {+ AwsException ex = assertThrows(AwsException.class,+ () -> iamService.changePassword("nobody", "Sup3r$ecret!", "An0ther$ecret!"));++ assertEquals("NoSuchEntity", ex.getErrorCode());+ }+@Testvoid deleteUserWithLoginProfileIsDeleteConflict() {iamService.createUser("alice", "/");