Light, fluffy, and always free - The AWS Local Emulator alternative
fix(iam): return UserName from GetAccessKeyLastUsed (#5579)
Allen Sanborn372d3d11d5e6
diff --git a/src/main/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackend.java b/src/main/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackend.javaindex 10b4cc370b..ccc9fdd484 100644--- a/src/main/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackend.java+++ b/src/main/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackend.java@@ -307,6 +307,16 @@ public class AccountAwareStorageBackend<V> implements StorageBackend<String, V>return delegate.get(accountId + "/" + key);}+ /**+ * An unprefixed pre-multi-account entry, read in place (never migrated). Such entries belong+ * to {@code defaultAccountId}, as in {@link #scanAllAccountEntries}, so any other account+ * gets empty.+ */+ public Optional<V> getLegacyForAccount(String accountId, String key) {+ return defaultAccountId.equals(accountId) && !hasAccountPrefix(key)+ ? delegate.get(key) : Optional.empty();+ }+/*** Returns an explicitly scoped entry, or safely migrates a matching legacy unscoped entry.*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 3e45bf929e..8942b38ae8 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@@ -1955,12 +1955,14 @@ public class IamQueryHandler {private Response handleGetAccessKeyLastUsed(MultivaluedMap<String, String> params) {// Access-key usage is not modeled, so return the IAM API's documented// "never used" shape: an AccessKeyLastUsed with ServiceName=N/A and Region=N/A- // and NO LastUsedDate. UserName is optional and its type is non-empty- // (length 1-128); since the emulator exposes no AccessKeyId→UserName lookup,- // the element is omitted rather than emitted empty — an empty string could be- // rejected by a strict client, and callers that need the owner already have it- // from the preceding ListAccessKeys call.- String result = new XmlBuilder()+ // and NO LastUsedDate. UserName names the key's owner; Terraform's+ // aws_iam_access_key import reads it and fails on "empty response" without it.+ // Its type is non-empty (length 1-128), so for a key the emulator does not+ // hold the element is omitted rather than emitted empty.+ XmlBuilder xml = new XmlBuilder();+ iamService.findAccessKeyOwnerInThisAccount(getParam(params, "AccessKeyId"))+ .ifPresent(userName -> xml.elem("UserName", userName));+ String result = xml.start("AccessKeyLastUsed").elem("ServiceName", "N/A").elem("Region", "N/A")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 73ecf17d5f..537ae87117 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@@ -777,6 +777,25 @@ public class IamService implements SessionAccountLookup, ResourceProvider {return accessKeys.get(accessKeyId).map(AccessKey::getUserName);}+ /**+ * The owner of a key in the calling account, for a read that is not the owner's own request.+ * Unlike {@link #findUserNameByAccessKeyId}, this never migrates: an unprefixed+ * pre-multi-account key belongs to the default account and is only read in place, so another+ * account asking (even one with a same-named user) neither learns the owner nor moves the key.+ */+ public Optional<String> findAccessKeyOwnerInThisAccount(String accessKeyId) {+ if (accessKeyId == null) {+ return Optional.empty();+ }+ if (!(accessKeys instanceof AccountAwareStorageBackend<AccessKey> aware)) {+ return findUserNameByAccessKeyId(accessKeyId);+ }+ String accountId = aware.accountId();+ return aware.getForAccount(accountId, accessKeyId)+ .or(() -> aware.getLegacyForAccount(accountId, accessKeyId))+ .map(AccessKey::getUserName);+ }+public void deleteUser(String userName) {synchronized (resourceNameLock) {IamUser user = getUser(userName);diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java b/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.javaindex b391a485ff..5e344cf539 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java@@ -443,7 +443,7 @@ public class ResourceArnBuilder {if (accessKeyId == null || accessKeyId.isBlank() || iamService == null) {return List.of("*");}- return iamService.get().findUserNameByAccessKeyId(accessKeyId)+ return iamService.get().findAccessKeyOwnerInThisAccount(accessKeyId).flatMap(userName -> storedIamEntity("user", userName, accountId)).map(stored -> List.of(stored.arn())).orElse(List.of("*"));diff --git a/src/test/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackendTest.java b/src/test/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackendTest.javaindex 92452d191e..d89845abda 100644--- a/src/test/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackendTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/storage/AccountAwareStorageBackendTest.java@@ -62,6 +62,19 @@ class AccountAwareStorageBackendTest {assertEquals("owned", raw.get("111111111111/resource").orElseThrow());}+ @Test+ void legacyLookupReadsUnprefixedKeyInPlaceOnlyForDefaultAccount() {+ InMemoryStorage<String, String> raw = new InMemoryStorage<>();+ raw.put("resource", "legacy");+ AccountAwareStorageBackend<String> storage =+ new AccountAwareStorageBackend<>(raw, null, "111111111111");++ assertEquals("legacy", storage.getLegacyForAccount("111111111111", "resource").orElseThrow());+ assertTrue(storage.getLegacyForAccount("222222222222", "resource").isEmpty());+ assertEquals("legacy", raw.get("resource").orElseThrow());+ assertTrue(raw.get("111111111111/resource").isEmpty());+ }+@Testvoid guardedLegacyLookupLeavesRejectedRawValueUntouched() {InMemoryStorage<String, String> raw = new InMemoryStorage<>();diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamIntegrationTest.javaindex 59f6a15c16..d57ffdde82 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamIntegrationTest.java@@ -691,7 +691,29 @@ class IamIntegrationTest {.statusCode(200).contentType("application/xml").body("GetAccessKeyLastUsedResponse.GetAccessKeyLastUsedResult"- + ".AccessKeyLastUsed.ServiceName", equalTo("N/A"));+ + ".AccessKeyLastUsed.ServiceName", equalTo("N/A"))+ .body(not(containsString("<UserName>")));+ }++ @Test+ @Order(49)+ void getAccessKeyLastUsedReturnsOwningUserName() {+ // Terraform's aws_iam_access_key import resolves the owner from this field.+ createUser("last-used-owner");+ String keyId = createAccessKeyFor("last-used-owner");+ given()+ .formParam("Action", "GetAccessKeyLastUsed")+ .formParam("AccessKeyId", keyId)+ .header("Authorization",+ "AWS4-HMAC-SHA256 Credential=test/20260227/us-east-1/iam/aws4_request")+ .when()+ .post("/")+ .then()+ .statusCode(200)+ .body("GetAccessKeyLastUsedResponse.GetAccessKeyLastUsedResult.UserName",+ equalTo("last-used-owner"))+ .body("GetAccessKeyLastUsedResponse.GetAccessKeyLastUsedResult"+ + ".AccessKeyLastUsed.Region", equalTo("N/A"));}@Testdiff --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 750f682d2a..7f4dd3f00c 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@@ -4,6 +4,7 @@ import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.RequestContext;import io.github.hectorvent.floci.core.common.Totp;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.InMemoryStorage;@@ -24,6 +25,7 @@ import io.github.hectorvent.floci.services.iam.model.PolicyVersion;import io.github.hectorvent.floci.services.iam.model.SessionCredential;import io.github.hectorvent.floci.services.iam.model.VirtualMfaDevice;import io.github.hectorvent.floci.testing.MutableClock;+import jakarta.enterprise.inject.Instance;import org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.mockito.Mockito;@@ -45,6 +47,7 @@ import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicInteger;+import java.util.concurrent.atomic.AtomicReference;import java.util.function.BiPredicate;import java.util.function.Predicate;@@ -1270,6 +1273,44 @@ class IamServiceTest {assertEquals("alicia", iamService.findUserNameByAccessKeyId(keyId).orElseThrow());}+ @Test+ void anotherAccountCannotClaimALegacyAccessKeyThroughItsOwnerLookup() {+ assertLegacyKeyStaysWithTheDefaultAccount(false);+ }++ @Test+ void aSameNamedUserInAnotherAccountCannotClaimALegacyAccessKey() {+ assertLegacyKeyStaysWithTheDefaultAccount(true);+ }++ /** One shared key store, two accounts told apart by the request context, as in a real boot. */+ @SuppressWarnings("unchecked")+ private static void assertLegacyKeyStaysWithTheDefaultAccount(boolean strangerHasSameNamedUser) {+ AtomicReference<String> caller = new AtomicReference<>("000000000000");+ RequestContext context = Mockito.mock(RequestContext.class);+ Mockito.when(context.getAccountId()).thenAnswer(inv -> caller.get());+ Instance<RequestContext> contexts = Mockito.mock(Instance.class);+ Mockito.when(contexts.get()).thenReturn(context);+ InMemoryStorage<String, AccessKey> raw = new InMemoryStorage<>();+ raw.put("AKIALEGACYEXAMPLE", new AccessKey("AKIALEGACYEXAMPLE", "secret", "worker"));+ AccountAwareStorageBackend<AccessKey> keys = new AccountAwareStorageBackend<>(raw, contexts, "000000000000");+ IamService owner = iamService(false, keys);+ IamService stranger = iamService(false, keys);+ owner.createUser("worker", "/");++ caller.set("111122223333");+ if (strangerHasSameNamedUser) {+ stranger.createUser("worker", "/");+ }+ assertTrue(stranger.findAccessKeyOwnerInThisAccount("AKIALEGACYEXAMPLE").isEmpty());+ assertTrue(raw.get("AKIALEGACYEXAMPLE").isPresent(), "the stranger's lookup must leave the key unmoved");+ assertTrue(raw.get("111122223333/AKIALEGACYEXAMPLE").isEmpty(), "the stranger's lookup must not copy the key");++ caller.set("000000000000");+ assertEquals("worker", owner.findAccessKeyOwnerInThisAccount("AKIALEGACYEXAMPLE").orElseThrow());+ assertTrue(raw.get("AKIALEGACYEXAMPLE").isPresent(), "the owner's read must not migrate either");+ }+@Testvoid renamingAUserUpdatesItsGroupMembership() {iamService.createUser("alice", "/");diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.javaindex f13e0f56ec..f64fe2a854 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilderTest.java@@ -1,6 +1,11 @@package io.github.hectorvent.floci.services.iam;import com.fasterxml.jackson.databind.ObjectMapper;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.RequestContext;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+import io.github.hectorvent.floci.core.storage.InMemoryStorage;+import io.github.hectorvent.floci.services.iam.model.AccessKey;import io.github.hectorvent.floci.services.iam.model.IamGroup;import io.github.hectorvent.floci.services.iam.model.IamRole;import io.github.hectorvent.floci.services.iam.model.IamUser;@@ -27,6 +32,7 @@ import java.util.Optional;import static org.junit.jupiter.api.Assertions.assertEquals;import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertTrue;import static org.mockito.ArgumentMatchers.any;import static org.mockito.Mockito.doAnswer;import static org.mockito.Mockito.mock;@@ -329,11 +335,39 @@ class ResourceArnBuilderTest {void iamNamesTheUserOwningAnAccessKey() {String arn = "arn:aws:iam::000000000000:user/bob";IamService store = storeHolding("bob", "/", arn);- when(store.findUserNameByAccessKeyId("AKIAEXAMPLE")).thenReturn(Optional.of("bob"));+ when(store.findAccessKeyOwnerInThisAccount("AKIAEXAMPLE")).thenReturn(Optional.of("bob"));assertEquals(arn, resourceOf(backedBy(store),"Action=GetAccessKeyLastUsed&AccessKeyId=AKIAEXAMPLE"));}+ /**+ * The enforcement filter resolves the key's owner before the handler runs, so the resolver+ * must not migrate a pre-multi-account key into the caller's partition either: another+ * account asking about it, even one with a same-named user, gets the wildcard and leaves the+ * key where it was.+ */+ @Test+ void iamDoesNotLetAnotherAccountClaimALegacyAccessKeyThroughTheOwnerLookup() {+ String stranger = "111122223333";+ RequestContext context = mock(RequestContext.class);+ when(context.getAccountId()).thenReturn(stranger);+ @SuppressWarnings("unchecked")+ Instance<RequestContext> contexts = mock(Instance.class);+ when(contexts.get()).thenReturn(context);+ InMemoryStorage<String, AccessKey> raw = new InMemoryStorage<>();+ raw.put("AKIALEGACYEXAMPLE", new AccessKey("AKIALEGACYEXAMPLE", "secret", "worker"));+ IamService iam = new IamService(new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(),+ new AccountAwareStorageBackend<>(raw, contexts, ACCOUNT), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new RegionResolver("us-east-1", ACCOUNT), false);+ iam.createUser("worker", "/");++ setFormBody("Action=GetAccessKeyLastUsed&AccessKeyId=AKIALEGACYEXAMPLE");+ assertEquals(List.of("*"), backedBy(iam).buildResources("iam", ctx, "us-east-1", stranger));+ assertTrue(raw.get("AKIALEGACYEXAMPLE").isPresent(), "the lookup must leave the key unmoved");+ assertTrue(raw.get(stranger + "/AKIALEGACYEXAMPLE").isEmpty(), "the lookup must not copy the key");+ }+/*** A hardware MFA device's {@code SerialNumber} is a bare serial rather than an ARN, so there* is nothing to pass through and nothing a policy could be written against.