Light, fluffy, and always free - The AWS Local Emulator alternative
fix(iam): take every access key status the model publishes (#5968)
Priamo Germosenb14537baa71c
diff --git a/docs/services/iam.md b/docs/services/iam.mdindex 558139ea64..22c2c9b58b 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -193,6 +193,17 @@ own documented role subset.| UpdateAccessKey | Updates an access key's status. || DeleteAccessKey | Deletes an access key from a user. |+`UserName` is optional on `UpdateAccessKey`, `ListAccessKeys` and `DeleteAccessKey`: it defaults to+the user resolved from the signing access key, the same fallback `GetUser` uses.++`Status` takes any of the three values `statusType` publishes, `Active`, `Inactive` and `Expired`,+which is what the reference's Valid Values line on `UpdateAccessKey` lists, and it is held to that+set the same way `UpdateSigningCertificate`, `UpdateSSHPublicKey` and+`UpdateServiceSpecificCredential` hold theirs. It is read before the key is looked up, so a status+outside the set answers `ValidationError` whether or not the key exists. The `AWS::IAM::AccessKey`+CloudFormation resource takes the same three, its Allowed values line reading "Active | Inactive |+Expired" as well.+### Account Aliases| Action | Description |diff --git a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamAccessKeyCfnProvisioner.java b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamAccessKeyCfnProvisioner.javaindex f1ea84e5bd..6dff15754b 100644--- a/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamAccessKeyCfnProvisioner.java+++ b/src/main/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamAccessKeyCfnProvisioner.java@@ -9,6 +9,7 @@ import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;import java.util.HashMap;+import java.util.List;import java.util.Map;import java.util.Set;@@ -27,6 +28,8 @@ import java.util.Set;public class IamAccessKeyCfnProvisioner implements CfnResourceProvisioner {private static final String TYPE = "AWS::IAM::AccessKey";+ /** The resource's own Allowed values line, which matches the IAM API's {@code statusType}. */+ private static final List<String> STATUS_VALUES = List.of("Active", "Inactive", "Expired");private static final String SERIAL_ATTR = "__FlociAccessKeySerial";private final IamService iamService;@@ -48,13 +51,14 @@ public class IamAccessKeyCfnProvisioner implements CfnResourceProvisioner {throw new AwsException("ValidationError", "AWS::IAM::AccessKey requires a UserName.", 400);}String serial = serialOf(props, ctx);- // Status (Active/Inactive) is a mutable property. Validate it up front, before any key is- // created, so a bad value fails cleanly: a user is capped at two keys, so creating one and- // only then rejecting the status could orphan it.+ // Status is a mutable property whose Allowed values line reads "Active | Inactive |+ // Expired", the same three the IAM API's statusType publishes. Validate it up front,+ // before any key is created, so a bad value fails cleanly: a user is capped at two keys,+ // so creating one and only then rejecting the status could orphan it.String status = ctx.resolveOptional(props, "Status");- if (status != null && !"Active".equals(status) && !"Inactive".equals(status)) {+ if (status != null && !STATUS_VALUES.contains(status)) {throw new AwsException("ValidationError",- "AWS::IAM::AccessKey Status must be Active or Inactive.", 400);+ "AWS::IAM::AccessKey Status must be Active, Inactive or Expired.", 400);}Map<String, String> attributesBefore = new HashMap<>(r.getAttributes());@@ -75,8 +79,8 @@ public class IamAccessKeyCfnProvisioner implements CfnResourceProvisioner {r.getAttributes().put("Id", key.getAccessKeyId());r.getAttributes().put("SecretAccessKey", key.getSecretAccessKey());r.getAttributes().put(SERIAL_ATTR, serial);- // A new key is Active; only touch it when the template asked for Inactive.- if ("Inactive".equals(status)) {+ // A new key is Active; only touch it when the template asked for something else.+ if (status != null && !"Active".equals(status)) {iamService.updateAccessKey(userName, key.getAccessKeyId(), status);}// On a createOnly change this new key replaced the prior one; record it so the displaceddiff --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 f68b81dd87..75614650e0 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@@ -284,7 +284,7 @@ public class IamQueryHandler {case "CreateAccessKey" -> handleCreateAccessKey(params);case "DeleteAccessKey" -> handleDeleteAccessKey(params, authorization);case "ListAccessKeys" -> handleListAccessKeys(params, authorization);- case "UpdateAccessKey" -> handleUpdateAccessKey(params);+ case "UpdateAccessKey" -> handleUpdateAccessKey(params, authorization);case "GetAccessKeyLastUsed" -> handleGetAccessKeyLastUsed(params);case "ListOrganizationsFeatures" -> handleListOrganizationsFeatures(params);@@ -358,8 +358,8 @@ public class IamQueryHandler {return Response.ok(AwsQueryResponse.envelope("CreateUser", AwsNamespaces.IAM, result)).build();}- // UserName is optional on GetUser/ListAccessKeys/DeleteAccessKey: real AWS determines- // it implicitly from the access key that signed the request. Mirrors moto: an access+ // UserName is optional on GetUser/ListAccessKeys/DeleteAccessKey/UpdateAccessKey: real AWS+ // determines it implicitly from the access key that signed the request. Mirrors moto: an access// key that maps to no stored IAM user is the documented NoSuchEntity error.private String resolveUserName(MultivaluedMap<String, String> params, String authorization) {String userName = getParam(params, "UserName");@@ -1964,9 +1964,12 @@ public class IamQueryHandler {return Response.ok(AwsQueryResponse.envelope("ListAccessKeys", AwsNamespaces.IAM, xml.build())).build();}- private Response handleUpdateAccessKey(MultivaluedMap<String, String> params) {- iamService.updateAccessKey(getParam(params, "UserName"),- getParam(params, "AccessKeyId"), getParam(params, "Status"));+ private Response handleUpdateAccessKey(MultivaluedMap<String, String> params, String authorization) {+ // "If the UserName is not specified, the user name is determined implicitly based on the+ // AWS access key ID used to sign the request", the same sentence DeleteAccessKey carries.+ // Read the way the other three statusType operations read theirs, the status included.+ iamService.updateAccessKey(resolveUserName(params, authorization),+ requireParam(params, "AccessKeyId"), getParam(params, "Status"));return Response.ok(AwsQueryResponse.envelopeNoResult("UpdateAccessKey", AwsNamespaces.IAM)).build();}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 c3760f7ca7..03a0e60885 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@@ -279,9 +279,10 @@ public class IamService implements SessionAccountLookup, ResourceProvider {private static final String CREDENTIAL_STATUS_ACTIVE = "Active";private static final String CREDENTIAL_STATUS_EXPIRED = "Expired";/**- * statusType's values, shared by signing certificates and SSH public keys: Active, Inactive- * and Expired. Each operation's prose explains only the first two, so the third is easy to- * reject by mistake, while the API Reference lists all three as valid.+ * statusType's values, shared by access keys, signing certificates, SSH public keys and+ * service-specific credentials: Active, Inactive and Expired. Each operation's prose explains+ * only the first two, so the third is easy to reject by mistake, while the API Reference lists+ * all three as valid on each of them.*/private static final Set<String> CREDENTIAL_STATUSES =Set.of(CREDENTIAL_STATUS_ACTIVE, "Inactive", CREDENTIAL_STATUS_EXPIRED);@@ -401,6 +402,14 @@ public class IamService implements SessionAccountLookup, ResourceProvider {private final Object signingCertificateLock = new Object();private final Object sshPublicKeyLock = new Object();private final Object serviceCredentialLock = new Object();+ /**+ * Guards every check-then-write on an access key, the way its three sibling credential+ * families are guarded. Both halves of this family need it: CreateAccessKey counts a user's+ * keys and only then stores another, so two requests racing the quota would both pass a check+ * for two; and UpdateAccessKey reads a key, changes its status and writes it back, so an+ * update racing a delete would store the key the delete had just removed.+ */+ private final Object accessKeyLock = new Object();/*** Guards every check-then-write on an MFA device. Assignment is the reason it has to exist:* EnableMFADevice reads the device to confirm it is unassigned and reads the user's device@@ -835,39 +844,43 @@ public class IamService implements SessionAccountLookup, ResourceProvider {throw new AwsException("DeleteConflict","Cannot delete entity, must delete policies first.", 409);}- if (!userAccessKeys(userName).isEmpty()) {- throw new AwsException("DeleteConflict",- "Cannot delete entity, must delete access keys first.", 409);- }- // Both locks are held across the delete rather than just the checks: UploadSigningCertificate- // UploadSigningCertificate and EnableMFADevice confirm the user under their own lock, so- // none of them can interleave into a credential owned by a deleted user. Taken in this- // order here and in UpdateUser, and nowhere else in more than one, so it cannot deadlock.- synchronized (serviceCredentialLock) {- // AWS lists these among the items to remove first, under their CodeCommit- // name: "Git credentials (DeleteServiceSpecificCredential)". Unlike the- // cases above it has no message of its own: AWS falls back to the generic- // referenced-objects wording here.- if (!userServiceCredentials(userName).isEmpty()) {+ // The credential locks are held across the delete rather than just the checks:+ // CreateAccessKey, UploadSigningCertificate and EnableMFADevice each confirm the user+ // under their own lock, so none of them can interleave into a credential owned by a+ // user that is already gone. Access keys are the outermost of the five here, and+ // UpdateUser takes that lock on its own rather than inside the others, so no two of+ // them are ever held in opposite orders.+ synchronized (accessKeyLock) {+ if (!userAccessKeys(userName).isEmpty()) {throw new AwsException("DeleteConflict",- "Cannot delete entity, must remove referenced objects first.", 409);+ "Cannot delete entity, must delete access keys first.", 409);}- synchronized (sshPublicKeyLock) {- if (!userSshPublicKeys(userName).isEmpty()) {+ synchronized (serviceCredentialLock) {+ // AWS lists these among the items to remove first, under their CodeCommit+ // name: "Git credentials (DeleteServiceSpecificCredential)". Unlike the+ // cases above it has no message of its own: AWS falls back to the generic+ // referenced-objects wording here.+ if (!userServiceCredentials(userName).isEmpty()) {throw new AwsException("DeleteConflict",- "Cannot delete entity, must delete SSH public keys first.", 409);+ "Cannot delete entity, must remove referenced objects first.", 409);}- synchronized (signingCertificateLock) {- if (!userSigningCertificates(userName).isEmpty()) {+ synchronized (sshPublicKeyLock) {+ if (!userSshPublicKeys(userName).isEmpty()) {throw new AwsException("DeleteConflict",- "Cannot delete entity, must delete signing certificates first.", 409);+ "Cannot delete entity, must delete SSH public keys first.", 409);}- synchronized (mfaDeviceLock) {- if (!mfaDevicesForUser(userName).isEmpty()) {+ synchronized (signingCertificateLock) {+ if (!userSigningCertificates(userName).isEmpty()) {throw new AwsException("DeleteConflict",- "Cannot delete entity, must deactivate MFA device first.", 409);+ "Cannot delete entity, must delete signing certificates first.", 409);+ }+ synchronized (mfaDeviceLock) {+ if (!mfaDevicesForUser(userName).isEmpty()) {+ throw new AwsException("DeleteConflict",+ "Cannot delete entity, must deactivate MFA device first.", 409);+ }+ users.delete(userName);}- users.delete(userName);}}}@@ -904,7 +917,6 @@ public class IamService implements SessionAccountLookup, ResourceProvider {throw new AwsException("EntityAlreadyExists","User with name " + newUserName + " already exists.", 409);}- List<AccessKey> keysToMove = userAccessKeys(userName);// The rename publishes the user under its new name and moves the credentials that// DeleteUser refuses to delete a user over: its MFA devices, its signing// certificates and its SSH public keys. Each moves under the lock DeleteUser checks it with, because split@@ -955,9 +967,15 @@ public class IamService implements SessionAccountLookup, ResourceProvider {loginProfiles.put(newUserName, profile);});}- for (AccessKey key : keysToMove) {- key.setUserName(newUserName);- accessKeys.put(key.getAccessKeyId(), key);+ synchronized (accessKeyLock) {+ // Read inside the lock that rewrites them, the way each credential above is+ // read inside its own: a DeleteAccessKey landing between a read taken earlier+ // and this loop would be undone, the deleted key coming back under the new+ // name and still authenticating.+ for (AccessKey key : userAccessKeys(userName)) {+ key.setUserName(newUserName);+ accessKeys.put(key.getAccessKeyId(), key);+ }}for (String groupName : user.getGroupNames()) {groups.get(groupName).ifPresent(group -> {@@ -2231,31 +2249,30 @@ public class IamService implements SessionAccountLookup, ResourceProvider {// =========================================================================public AccessKey createAccessKey(String userName) {- getUser(userName); // validates existence- long existingCount = accessKeys.scan(k -> true).stream()- .filter(ak -> userName.equals(ak.getUserName()))- .count();- if (existingCount >= 2) {- throw new AwsException("LimitExceeded",- "Cannot exceed quota for AccessKeysPerUser: 2", 409);+ synchronized (accessKeyLock) {+ // Confirmed under the lock, not before it, the way UploadSigningCertificate confirms+ // its own: DeleteUser checks for access keys holding this same lock, so the two cannot+ // interleave into a key owned by a user that no longer exists.+ getUser(userName);+ long existingCount = userAccessKeys(userName).size();+ if (existingCount >= 2) {+ throw new AwsException("LimitExceeded",+ "Cannot exceed quota for AccessKeysPerUser: 2", 409);+ }+ String keyId = "AKIA" + randomId(16);+ String secretKey = randomSecret(40);+ AccessKey key = new AccessKey(keyId, secretKey, userName);+ accessKeys.put(keyId, key);+ LOG.infov("Created access key for user: {0}", userName);+ return key;}- String keyId = "AKIA" + randomId(16);- String secretKey = randomSecret(40);- AccessKey key = new AccessKey(keyId, secretKey, userName);- accessKeys.put(keyId, key);- LOG.infov("Created access key for user: {0}", userName);- return key;}public void deleteAccessKey(String userName, String accessKeyId) {- AccessKey key = accessKeys.get(accessKeyId)- .orElseThrow(() -> new AwsException("NoSuchEntity",- "Access key " + accessKeyId + " not found.", 404));- if (!key.getUserName().equals(userName)) {- throw new AwsException("NoSuchEntity",- "Access key " + accessKeyId + " does not belong to user " + userName + ".", 404);+ synchronized (accessKeyLock) {+ AccessKey key = userAccessKey(userName, accessKeyId);+ accessKeys.delete(key.getAccessKeyId());}- accessKeys.delete(accessKeyId);}public List<AccessKey> listAccessKeys(String userName) {@@ -2269,7 +2286,22 @@ public class IamService implements SessionAccountLookup, ResourceProvider {.toList();}+ /**+ * Sets an access key's status, validated before the key is looked up the way the other three+ * {@code statusType} operations validate theirs: a status outside the enum is answered for the+ * status whether or not the key exists.+ */public void updateAccessKey(String userName, String accessKeyId, String status) {+ requireStatusFromEnum(status);+ synchronized (accessKeyLock) {+ AccessKey key = userAccessKey(userName, accessKeyId);+ key.setStatus(status);+ accessKeys.put(accessKeyId, key);+ }+ }++ /** The user's key with this id, or the NoSuchEntity each of these operations answers. */+ private AccessKey userAccessKey(String userName, String accessKeyId) {AccessKey key = accessKeys.get(accessKeyId).orElseThrow(() -> new AwsException("NoSuchEntity","Access key " + accessKeyId + " not found.", 404));@@ -2277,12 +2309,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {throw new AwsException("NoSuchEntity","Access key " + accessKeyId + " does not belong to user " + userName + ".", 404);}- if (!"Active".equals(status) && !"Inactive".equals(status)) {- throw new AwsException("ValidationError",- "Status must be Active or Inactive.", 400);- }- key.setStatus(status);- accessKeys.put(accessKeyId, key);+ return key;}// =========================================================================@@ -3284,12 +3311,12 @@ public class IamService implements SessionAccountLookup, ResourceProvider {return getServerCertificate(name).getTags();}- // Credential status, shared by the three operations that take statusType+ // Credential status, shared by the four operations that take statusType// =========================================================================/**- * {@code statusType}, shared by UpdateSigningCertificate, UpdateSSHPublicKey and- * UpdateServiceSpecificCredential. One rendering serves all three because one front end+ * {@code statusType}, shared by UpdateAccessKey, UpdateSigningCertificate, UpdateSSHPublicKey+ * and UpdateServiceSpecificCredential. One rendering serves all four because one front end* validates one shape: the recording is of UpdateServiceSpecificCredential, and AWS names* neither the offending value nor the permitted set, unlike this message elsewhere in the* tree. Matched rather than made uniform.diff --git a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamAccessKeyCfnProvisionerTest.java b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamAccessKeyCfnProvisionerTest.javaindex 5938904ee7..3e62725db5 100644--- a/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamAccessKeyCfnProvisionerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/cloudformation/provisioners/IamAccessKeyCfnProvisionerTest.java@@ -117,6 +117,22 @@ class IamAccessKeyCfnProvisionerTest {verify(iam, never()).updateAccessKey(anyString(), anyString(), anyString());}+ @Test+ void createWithExpiredStatusIsTakenToo() throws Exception {+ // The resource's Allowed values line reads "Active | Inactive | Expired", so Expired is a+ // status the template may declare and not one to refuse.+ AccessKey key = new AccessKey();+ key.setAccessKeyId("AKIA1");+ key.setSecretAccessKey("secret-1");+ when(iam.createAccessKey("alice")).thenReturn(key);++ provisioner.provision(resource(), props("{\"UserName\": \"alice\", \"Status\": \"Expired\"}"),+ ctx(null));++ verify(iam).createAccessKey("alice");+ verify(iam).updateAccessKey("alice", "AKIA1", "Expired");+ }+@Testvoid aBogusStatusIsRejectedBeforeCreatingAKey() {AwsException e = assertThrows(AwsException.class, () -> provisioner.provision(diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamAccessKeyStatusIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamAccessKeyStatusIntegrationTest.javanew file mode 100644index 0000000000..e22abcb01c--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamAccessKeyStatusIntegrationTest.java@@ -0,0 +1,168 @@+package io.github.hectorvent.floci.services.iam;++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;++/**+ * {@code UpdateAccessKey} over the wire, for the three things the reference publishes about it that+ * the handler did not follow.+ *+ * <p>The status is a {@code statusType}, whose Valid Values line reads "Active | Inactive |+ * Expired", so {@code Expired} is a value the operation takes rather than one to refuse. A value+ * outside that set breaks a constraint the model declares, which the Common Errors page answers as+ * {@code ValidationError}, and it is read before the key is looked up, so it is answered even when+ * the key named does not exist. And "if the UserName is not specified, the user name is determined+ * implicitly based on the AWS access key ID used to sign the request", the sentence this operation+ * shares with DeleteAccessKey and ListAccessKeys.+ *+ * <p>The refusal is the rendering {@code IamService.requireStatusFromEnum} already answers for the+ * other three operations that take this shape, which names neither the offending value nor the+ * permitted set, as AWS's own recording of one of them does not.+ */+@QuarkusTest+class IamAccessKeyStatusIntegrationTest {++ private static final String ACCOUNT = "000000000912";+ private static final String REGION = "us-east-1";++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ @Test+ void expiredIsAStatusTheOperationTakes() {+ String userName = user("expired");+ String accessKeyId = accessKeyFor(userName);++ update(ACCOUNT, Map.of("UserName", userName, "AccessKeyId", accessKeyId,+ "Status", "Expired")).statusCode(200);++ admin("ListAccessKeys", Map.of("UserName", userName)).statusCode(200)+ .body("ListAccessKeysResponse.ListAccessKeysResult.AccessKeyMetadata.member.Status",+ equalTo("Expired"));+ }++ @Test+ void aStatusOutsideTheEnumIsAValidationError() {+ String userName = user("bad-status");+ String accessKeyId = accessKeyFor(userName);++ update(ACCOUNT, Map.of("UserName", userName, "AccessKeyId", accessKeyId,+ "Status", "Disabled")).statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ .body("ErrorResponse.Error.Message",+ equalTo("1 validation error detected: Value at 'status' failed to satisfy "+ + "constraint: Member must satisfy enum value set"));++ assertStatusStillActive(userName);+ }++ @Test+ void anAbsentStatusIsAnsweredTheSameWay() {+ String userName = user("absent-status");+ String accessKeyId = accessKeyFor(userName);++ update(ACCOUNT, Map.of("UserName", userName, "AccessKeyId", accessKeyId)).statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ .body("ErrorResponse.Error.Message", containsString("at 'status'"));++ assertStatusStillActive(userName);+ }++ /** A refused status leaves the key as it was: the value is read before anything is written. */+ private void assertStatusStillActive(String userName) {+ admin("ListAccessKeys", Map.of("UserName", userName)).statusCode(200)+ .body("ListAccessKeysResponse.ListAccessKeysResult.AccessKeyMetadata.member.Status",+ equalTo("Active"));+ }++ @Test+ void anAbsentAccessKeyIdNamesItself() {+ update(ACCOUNT, Map.of("UserName", user("absent-id"), "Status", "Inactive")).statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"))+ .body("ErrorResponse.Error.Message", containsString("Value null at 'accessKeyId'"));+ }++ @Test+ void theStatusIsReadBeforeTheKeyIsLookedUp() {+ // Both are wrong, and the shape is what AWS answers for: the key would otherwise decide,+ // which is NoSuchEntity 404 for a key that is not there.+ update(ACCOUNT, Map.of("UserName", user("order"), "AccessKeyId", "AKIANOSUCHKEY00000",+ "Status", "Disabled")).statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));++ update(ACCOUNT, Map.of("UserName", user("order-valid"), "AccessKeyId", "AKIANOSUCHKEY00000",+ "Status", "Inactive")).statusCode(404)+ .body("ErrorResponse.Error.Code", equalTo("NoSuchEntity"));+ }++ @Test+ void theSignersOwnKeyNeedsNoUserName() {+ String userName = user("implicit");+ String accessKeyId = accessKeyFor(userName);++ update(accessKeyId, Map.of("AccessKeyId", accessKeyId, "Status", "Inactive"))+ .statusCode(200);++ admin("ListAccessKeys", Map.of("UserName", userName)).statusCode(200)+ .body("ListAccessKeysResponse.ListAccessKeysResult.AccessKeyMetadata.member.Status",+ equalTo("Inactive"));+ }++ @Test+ void anotherUsersKeyIsStillNoSuchEntity() {+ String owner = user("owner");+ String ownerKey = accessKeyFor(owner);+ String stranger = user("stranger");++ update(ACCOUNT, Map.of("UserName", stranger, "AccessKeyId", ownerKey,+ "Status", "Inactive")).statusCode(404)+ .body("ErrorResponse.Error.Code", equalTo("NoSuchEntity"));+ }++ private String user(String label) {+ String userName = "access-key-status-" + 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 static ValidatableResponse update(String accessKeyId, Map<String, String> params) {+ return iam(accessKeyId, "UpdateAccessKey", params);+ }++ private static 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+ + "/20261018/" + 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 5495afbc45..5029dccc46 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@@ -1,5 +1,6 @@package io.github.hectorvent.floci.services.iam;+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.iam.model.IamPolicy;@@ -15,6 +16,8 @@ import java.util.concurrent.CountDownLatch;import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicBoolean;+import java.util.concurrent.atomic.AtomicReference;import java.util.function.IntConsumer;import java.util.function.ToIntFunction;import java.util.stream.Stream;@@ -397,6 +400,175 @@ class IamConcurrencyTest {}}+ @Test+ void anUpdateCannotResurrectADeletedAccessKey() throws Exception {+ // UpdateAccessKey reads a key, sets its status and writes it back, so without a lock the+ // write lands after a delete that ran in between and the credential comes back. Measured+ // at 80 of 2000 trials before the lock.+ ExecutorService pool = Executors.newFixedThreadPool(THREADS);+ try {+ for (int trial = 0; trial < 2000; trial++) {+ IamService iam = newIamService();+ iam.createUser("racer", "/");+ String keyId = iam.createAccessKey("racer").getAccessKeyId();+ CountDownLatch start = new CountDownLatch(1);+ CountDownLatch done = new CountDownLatch(2);+ List<String> unexpected = new CopyOnWriteArrayList<>();++ pool.execute(raceStep(start, done, unexpected,+ () -> iam.updateAccessKey("racer", keyId, "Inactive")));+ pool.execute(raceStep(start, done, unexpected,+ () -> iam.deleteAccessKey("racer", keyId)));+ start.countDown();+ assertTrue(done.await(30, TimeUnit.SECONDS), "access key workers stalled");++ if (!iam.listAccessKeys("racer").isEmpty() || !unexpected.isEmpty()) {+ fail("access key trial " + trial + ": the deleted key is still listed"+ + ", unexpectedErrors=" + unexpected);+ }+ }+ } finally {+ pool.shutdownNow();+ }+ }++ @Test+ void concurrentAccessKeyCreatesStayInsideTheQuota() throws Exception {+ // AccessKeysPerUser is 2, counted and then written, so without a lock four callers racing+ // the count all pass it. Measured at 226 of 500 trials before the lock.+ ExecutorService pool = Executors.newFixedThreadPool(THREADS);+ try {+ for (int trial = 0; trial < 500; trial++) {+ IamService iam = newIamService();+ iam.createUser("racer", "/");+ CountDownLatch start = new CountDownLatch(1);+ CountDownLatch done = new CountDownLatch(4);+ List<String> unexpected = new CopyOnWriteArrayList<>();++ for (int i = 0; i < 4; i++) {+ pool.execute(raceStep(start, done, unexpected, () -> iam.createAccessKey("racer")));+ }+ start.countDown();+ assertTrue(done.await(30, TimeUnit.SECONDS), "access key workers stalled");++ int stored = iam.listAccessKeys("racer").size();+ if (stored != 2 || !unexpected.isEmpty()) {+ fail("access key quota trial " + trial + ": stored=" + stored+ + " unexpectedErrors=" + unexpected);+ }+ }+ } finally {+ pool.shutdownNow();+ }+ }++ @Test+ void aRenameCannotResurrectADeletedAccessKey() throws Exception {+ // UpdateUser rewrites each key's owner. Reading that list before taking the lock lets a+ // DeleteAccessKey land in between, and the loop then writes the deleted key back under the+ // new name, where it authenticates again.+ ExecutorService pool = Executors.newFixedThreadPool(THREADS);+ try {+ for (int trial = 0; trial < 2000; trial++) {+ IamService iam = newIamService();+ iam.createUser("racer", "/");+ String keyId = iam.createAccessKey("racer").getAccessKeyId();+ CountDownLatch start = new CountDownLatch(1);+ CountDownLatch done = new CountDownLatch(2);+ List<String> unexpected = new CopyOnWriteArrayList<>();+ AtomicBoolean deleted = new AtomicBoolean();++ pool.execute(raceStep(start, done, unexpected,+ () -> iam.updateUser("racer", "renamed", null)));+ pool.execute(raceStep(start, done, unexpected, () -> {+ iam.deleteAccessKey("racer", keyId);+ deleted.set(true);+ }));+ start.countDown();+ assertTrue(done.await(30, TimeUnit.SECONDS), "rename workers stalled");++ // The delete can lose the race, the key having moved to the new name before it+ // looked, and then the key is meant to still be there. What may never happen is a+ // delete that answered 200 and a key that is still stored.+ boolean stored = iam.findUserNameByAccessKeyId(keyId).isPresent();+ if ((deleted.get() && stored) || !unexpected.isEmpty()) {+ fail("rename trial " + trial + ": deleted=" + deleted.get()+ + " stillStored=" + stored + " unexpectedErrors=" + unexpected);+ }+ }+ } finally {+ pool.shutdownNow();+ }+ }++ @Test+ void anAccessKeyCannotBeCreatedForAUserBeingDeleted() throws Exception {+ // CreateAccessKey confirming the user before taking the lock, and DeleteUser checking for+ // keys without holding it, leaves the pair free to interleave: the create passes the check+ // and stores a key for a user the delete has just removed.+ ExecutorService pool = Executors.newFixedThreadPool(THREADS);+ try {+ for (int trial = 0; trial < 2000; trial++) {+ IamService iam = newIamService();+ iam.createUser("racer", "/");+ CountDownLatch start = new CountDownLatch(1);+ CountDownLatch done = new CountDownLatch(2);+ List<String> unexpected = new CopyOnWriteArrayList<>();+ AtomicReference<String> created = new AtomicReference<>();++ pool.execute(raceStep(start, done, unexpected,+ () -> created.set(iam.createAccessKey("racer").getAccessKeyId())));+ pool.execute(raceStep(start, done, unexpected, () -> iam.deleteUser("racer")));+ start.countDown();+ assertTrue(done.await(30, TimeUnit.SECONDS), "delete-user workers stalled");++ boolean userGone = userIsGone(iam);+ boolean orphan = userGone && created.get() != null+ && iam.findUserNameByAccessKeyId(created.get()).isPresent();+ if (orphan || !unexpected.isEmpty()) {+ fail("delete-user trial " + trial + ": a key is stored for a user that is gone"+ + ", unexpectedErrors=" + unexpected);+ }+ }+ } finally {+ pool.shutdownNow();+ }+ }++ private static boolean userIsGone(IamService iam) {+ try {+ iam.getUser("racer");+ return false;+ } catch (AwsException e) {+ return true;+ }+ }++ /**+ * One racer: waits for the start, runs the step, and keeps any error that is not one of the+ * refusals the race is allowed to produce, a key already gone, a quota already full or a user+ * that still has a key when the delete looks.+ */+ private static Runnable raceStep(CountDownLatch start, CountDownLatch done,+ List<String> unexpected, Runnable step) {+ return () -> {+ try {+ start.await(10, TimeUnit.SECONDS);+ step.run();+ } catch (AwsException e) {+ if (!"NoSuchEntity".equals(e.getErrorCode())+ && !"LimitExceeded".equals(e.getErrorCode())+ && !"DeleteConflict".equals(e.getErrorCode())) {+ unexpected.add(e.getErrorCode());+ }+ } catch (InterruptedException e) {+ Thread.currentThread().interrupt();+ } finally {+ done.countDown();+ }+ };+ }+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 532d3229d8..e7968cd8e9 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@@ -2030,6 +2030,52 @@ class IamServiceTest {assertTrue(iamService.listAccessKeys("alice").isEmpty());}+ @Test+ void anAccessKeyTakesEveryStatusTheModelPublishes() {+ // statusType is Active, Inactive or Expired, which is what the reference's Valid Values+ // line on UpdateAccessKey lists, so Expired is a value to store rather than to refuse.+ iamService.createUser("alice", "/");+ AccessKey key = iamService.createAccessKey("alice");++ for (String status : List.of("Inactive", "Expired", "Active")) {+ iamService.updateAccessKey("alice", key.getAccessKeyId(), status);+ assertEquals(status, iamService.listAccessKeys("alice").getFirst().getStatus());+ }+ }++ @Test+ void anAccessKeyStatusIsReadBeforeTheKeyIsFound() {+ // The key does not exist either, and the status is what answers: AWS reads a request's+ // shape before it resolves anything, so the lookup's NoSuchEntity does not get there first.+ iamService.createUser("alice", "/");++ AwsException error = assertThrows(AwsException.class,+ () -> iamService.updateAccessKey("alice", "AKIANOSUCHKEY00000", "Disabled"));++ assertEquals("ValidationError", error.getErrorCode());+ // The rendering the three sibling operations already answer with, taken from a recording+ // of UpdateServiceSpecificCredential: AWS names neither the value nor the permitted set.+ assertEquals("1 validation error detected: Value at 'status' failed to satisfy "+ + "constraint: Member must satisfy enum value set", error.getMessage());+ }++ @Test+ void anAbsentAccessKeyStatusIsAnsweredLikeAnInvalidOne() {+ // The shared helper reads a null as a value outside the enum, which is how the other three+ // statusType operations answer one. Changing that would change all four, so it stays.+ iamService.createUser("alice", "/");+ AccessKey key = iamService.createAccessKey("alice");++ AwsException error = assertThrows(AwsException.class,+ () -> iamService.updateAccessKey("alice", key.getAccessKeyId(), null));++ assertEquals("ValidationError", error.getErrorCode());+ assertEquals("1 validation error detected: Value at 'status' failed to satisfy "+ + "constraint: Member must satisfy enum value set", error.getMessage());+ // And the key is as it was: the status is read before the lookup, so nothing is written.+ assertEquals("Active", iamService.listAccessKeys("alice").getFirst().getStatus());+ }+@Testvoid aSessionWithNoRoleAndNoRecordedIssuerIsNoCredential() {// How GetSessionToken stored its sessions before it recorded the key that minted them. Such