Light, fluffy, and always free - The AWS Local Emulator alternative
refactor(iam): measure session expiry on the injected clock (#5382)
Priamo Germosen0ab58edb3cbc
diff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.javaindex 6ea6e16ade..d74d2bd0df 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java@@ -33,6 +33,7 @@ import org.jboss.logging.Logger;import java.net.URLDecoder;import java.nio.charset.StandardCharsets;+import java.time.Clock;import java.time.Instant;import java.util.ArrayList;import java.util.HashMap;@@ -195,6 +196,8 @@ public class IamEnforcementFilter implements ContainerRequestFilter {private final Instance<ScpProvider> scpProvider;private final SessionAccountLookup sessionAccountLookup;private final Instance<ResourcePolicyProvider> resourcePolicyProviders;+ /** The clock {@link IamService} measures session expiry on, so both read the same time. */+ private final Clock clock;private final ResourceInfo resourceInfo;@Inject@@ -213,6 +216,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {Instance<ScpProvider> scpProvider,SessionAccountLookup sessionAccountLookup,Instance<ResourcePolicyProvider> resourcePolicyProviders,+ Clock clock,@Context ResourceInfo resourceInfo) {this.config = config;this.accountResolver = accountResolver;@@ -229,6 +233,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {this.scpProvider = scpProvider;this.sessionAccountLookup = sessionAccountLookup;this.resourcePolicyProviders = resourcePolicyProviders;+ this.clock = clock;this.resourceInfo = resourceInfo;}@@ -250,7 +255,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {this(config, accountResolver, iamService, evaluator, actionRegistry,new AwsQueryServiceResolver(catalog), arnBuilder, requestContext,conditionContextResolver, cloudTrailService, currentVertxRequest, catalog,- scpProvider, sessionAccountLookup, resourcePolicyProviders, null);+ scpProvider, sessionAccountLookup, resourcePolicyProviders, Clock.systemUTC(), null);}/** Package-private constructor for callers predating resourcePolicyProviders. */@@ -270,7 +275,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {this(config, accountResolver, iamService, evaluator, actionRegistry,new AwsQueryServiceResolver(catalog), arnBuilder, requestContext,conditionContextResolver, cloudTrailService, currentVertxRequest, catalog,- scpProvider, sessionAccountLookup, null, null);+ scpProvider, sessionAccountLookup, null, Clock.systemUTC(), null);}@Override@@ -339,7 +344,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {}// Both lookups are asked about one moment, so a session that expires between them is not// deleted and then answered as a key that exists nowhere.- Instant now = Instant.now();+ Instant now = clock.instant();if (iamService.isExpiredSession(akid, now)) {LOG.debugv("Rejecting request signed with an expired session {0}", akid);ctx.abortWith(expiredTokenResponse(credentialScope, ctx));@@ -861,7 +866,7 @@ public class IamEnforcementFilter implements ContainerRequestFilter {}// One moment for both lookups, as in filter(): a session expiring between them would// otherwise be deleted and then allowed below as a credential with no context.- Instant now = Instant.now();+ Instant now = clock.instant();if (iamService.isExpiredSession(akid, now)) {throw expiredTokenException(credentialScope);}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 03ab399579..e3048e15e8 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@@ -60,6 +60,7 @@ import java.security.SecureRandom;import java.security.cert.CertificateEncodingException;import java.security.cert.X509Certificate;import java.security.interfaces.RSAPublicKey;+import java.time.Clock;import java.time.Duration;import java.time.Instant;import java.time.ZoneOffset;@@ -382,6 +383,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {*/private final Object mfaDeviceLock = new Object();private final RegionResolver regionResolver;+ private final Clock clock;private final boolean seedDeployerPrincipal;private final String seededAccountAlias;/** Guards case-insensitive IAM name uniqueness checks and their corresponding writes. */@@ -397,7 +399,8 @@ public class IamService implements SessionAccountLookup, ResourceProvider {private final Map<String, Map<String, IamPolicy>> awsManagedPoliciesByPartition = new ConcurrentHashMap<>();@Inject- public IamService(StorageFactory storageFactory, EmulatorConfig config, RegionResolver regionResolver) {+ public IamService(StorageFactory storageFactory, EmulatorConfig config, RegionResolver regionResolver,+ Clock clock) {this(storageFactory.create("iam", "iam-users.json", new TypeReference<>() {}),storageFactory.create("iam", "iam-groups.json", new TypeReference<>() {}),@@ -423,7 +426,8 @@ public class IamService implements SessionAccountLookup, ResourceProvider {storageFactory.create("iam", "iam-outbound-federation.json", new TypeReference<>() {}),regionResolver,config.services().iam().seedDeployerPrincipal(),- config.services().iam().accountAlias().orElse(null)+ config.services().iam().accountAlias().orElse(null),+ clock);}@@ -447,6 +451,20 @@ public class IamService implements SessionAccountLookup, ResourceProvider {StorageBackend<String, SessionCredential> sessions,RegionResolver regionResolver,boolean seedDeployerPrincipal) {+ this(users, groups, roles, policies, accessKeys, instanceProfiles, sessions, regionResolver,+ seedDeployerPrincipal, Clock.systemUTC());+ }++ IamService(StorageBackend<String, IamUser> users,+ StorageBackend<String, IamGroup> groups,+ StorageBackend<String, IamRole> roles,+ StorageBackend<String, IamPolicy> policies,+ StorageBackend<String, AccessKey> accessKeys,+ StorageBackend<String, InstanceProfile> instanceProfiles,+ StorageBackend<String, SessionCredential> sessions,+ RegionResolver regionResolver,+ boolean seedDeployerPrincipal,+ Clock clock) {this(users, groups, roles, policies, accessKeys, instanceProfiles, sessions,new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),@@ -455,7 +473,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),- regionResolver, seedDeployerPrincipal, null);+ regionResolver, seedDeployerPrincipal, null, clock);}// 8-backend constructor (no org-root-features): kept for existing callers/tests;@@ -533,6 +551,39 @@ public class IamService implements SessionAccountLookup, ResourceProvider {RegionResolver regionResolver,boolean seedDeployerPrincipal,String seededAccountAlias) {+ this(users, groups, roles, policies, accessKeys, instanceProfiles, sessions, accountAliases,+ passwordPolicies, loginProfiles, oidcProviders, serviceLinkedRoleDeletions, orgRootFeatures,+ credentialReports, virtualMfaDevices, serverCertificates, signingCertificates, sshPublicKeys,+ serviceCredentials, accountProperties, stsPreferences, outboundFederation,+ regionResolver, seedDeployerPrincipal, seededAccountAlias, Clock.systemUTC());+ }++ IamService(StorageBackend<String, IamUser> users,+ StorageBackend<String, IamGroup> groups,+ StorageBackend<String, IamRole> roles,+ StorageBackend<String, IamPolicy> policies,+ StorageBackend<String, AccessKey> accessKeys,+ StorageBackend<String, InstanceProfile> instanceProfiles,+ StorageBackend<String, SessionCredential> sessions,+ StorageBackend<String, String> accountAliases,+ StorageBackend<String, AccountPasswordPolicy> passwordPolicies,+ StorageBackend<String, LoginProfile> loginProfiles,+ StorageBackend<String, OpenIDConnectProvider> oidcProviders,+ StorageBackend<String, String> serviceLinkedRoleDeletions,+ StorageBackend<String, OrganizationRootFeatures> orgRootFeatures,+ StorageBackend<String, CredentialReport> credentialReports,+ StorageBackend<String, VirtualMfaDevice> virtualMfaDevices,+ StorageBackend<String, ServerCertificate> serverCertificates,+ StorageBackend<String, SigningCertificate> signingCertificates,+ StorageBackend<String, SshPublicKey> sshPublicKeys,+ StorageBackend<String, ServiceSpecificCredential> serviceCredentials,+ StorageBackend<String, String> accountProperties,+ StorageBackend<String, String> stsPreferences,+ StorageBackend<String, OutboundWebIdentityFederation> outboundFederation,+ RegionResolver regionResolver,+ boolean seedDeployerPrincipal,+ String seededAccountAlias,+ Clock clock) {this.users = users;this.groups = groups;this.roles = roles;@@ -558,6 +609,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {this.regionResolver = regionResolver;this.seedDeployerPrincipal = seedDeployerPrincipal;this.seededAccountAlias = seededAccountAlias;+ this.clock = clock;}@PostConstruct@@ -3224,7 +3276,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {credential.setServiceSpecificCredentialId("ACCA" + randomId(SERVICE_CREDENTIAL_ID_SUFFIX_LENGTH));credential.setStatus(CREDENTIAL_STATUS_ACTIVE);- credential.setCreateDate(Instant.now());+ credential.setCreateDate(clock.instant());int version = freeCredentialVersion(all, userName, longTermKey, credential.getCreateDate());if (longTermKey) {@@ -3339,7 +3391,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {*/public String reportedStatus(ServiceSpecificCredential credential) {Instant expiry = credential.getExpirationDate();- if (expiry != null && !expiry.isAfter(Instant.now())) {+ if (expiry != null && !expiry.isAfter(clock.instant())) {return CREDENTIAL_STATUS_EXPIRED;}return credential.getStatus();@@ -4009,8 +4061,15 @@ public class IamService implements SessionAccountLookup, ResourceProvider {}private Optional<SessionCredential> currentSession(String accessKeyId) {- return findSessionAnyAccount(accessKeyId)- .filter(session -> session.getExpiration() == null || Instant.now().isBefore(session.getExpiration()));+ return findSessionAnyAccount(accessKeyId).filter(session -> !isExpired(session, clock.instant()));+ }++ /**+ * Whether {@code session} has expired as of {@code now}: from the instant its expiration names.+ * Every lookup, the enforcement check and the sweep share this boundary.+ */+ private static boolean isExpired(SessionCredential session, Instant now) {+ return session.getExpiration() != null && !session.getExpiration().isAfter(now);}private static boolean hasMatchingSessionToken(SessionCredential session, String sessionToken) {@@ -4318,16 +4377,23 @@ public class IamService implements SessionAccountLookup, ResourceProvider {return removed;}- /** Removes expired temporary sessions, including those left in persistent storage after a restart. */- public int sweepExpiredSessions(Instant now) {+ /**+ * Removes temporary sessions expired on the injected clock, including those left in persistent+ * storage after a restart.+ */+ public int sweepExpiredSessions() {+ return sweepExpiredSessions(clock.instant());+ }++ /** {@link #sweepExpiredSessions()} as of {@code now}. */+ int sweepExpiredSessions(Instant now) {if (sessions instanceof AccountAwareStorageBackend<SessionCredential> aware) {- return aware.deleteAllAccountsMatching(session ->- session.getExpiration() != null && !session.getExpiration().isAfter(now));+ return aware.deleteAllAccountsMatching(session -> isExpired(session, now));}List<SessionCredential> storedSessions = sessions.scan(key -> true);int removed = 0;for (SessionCredential session : storedSessions) {- if (session.getExpiration() == null || session.getExpiration().isAfter(now)) {+ if (!isExpired(session, now)) {continue;}deleteSession(session.getAccessKeyId(), session);@@ -4352,7 +4418,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {return Optional.empty();}SessionCredential session = sessionOpt.get();- if (session.getExpiration() != null && session.getExpiration().isBefore(Instant.now())) {+ if (isExpired(session, clock.instant())) {return Optional.empty();}String account = AwsArnUtils.accountOrDefault(session.getRoleArn(), session.getOriginAccountId());@@ -4513,7 +4579,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {* <p>Returns {@code null} if the access key is unknown (bypass — backward-compatible).*/public CallerContext resolveCallerContext(String accessKeyId) {- return resolveCallerContext(accessKeyId, Instant.now());+ return resolveCallerContext(accessKeyId, clock.instant());}/**@@ -4536,7 +4602,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {Optional<SessionCredential> sessionOpt = findSessionForCallerContext(accessKeyId);if (sessionOpt.isPresent()) {SessionCredential session = sessionOpt.get();- if (session.getExpiration() != null && session.getExpiration().isBefore(now)) {+ if (isExpired(session, now)) {deleteSession(accessKeyId, session);return null; // expired — unknown key → bypass}@@ -4622,8 +4688,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {return false;}return findSessionForCallerContext(accessKeyId)- .map(SessionCredential::getExpiration)- .filter(expiration -> expiration.isBefore(now))+ .filter(session -> isExpired(session, now)).isPresent();}@@ -4687,7 +4752,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {Optional<SessionCredential> sessionOpt = findSessionForCallerContext(accessKeyId);if (sessionOpt.isPresent()) {SessionCredential session = sessionOpt.get();- if (session.getExpiration() != null && session.getExpiration().isBefore(Instant.now())) {+ if (isExpired(session, clock.instant())) {deleteSession(accessKeyId, session);return Optional.empty();}@@ -4750,7 +4815,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {Optional<SessionCredential> sessionOpt = findSessionForCallerContext(accessKeyId);if (sessionOpt.isPresent()) {SessionCredential session = sessionOpt.get();- if (session.getExpiration() != null && session.getExpiration().isBefore(Instant.now())) {+ if (isExpired(session, clock.instant())) {deleteSession(accessKeyId, session);return Optional.empty();}diff --git a/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGenerator.java b/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGenerator.javaindex 38057e209a..f8c967ddb7 100644--- a/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGenerator.java+++ b/src/main/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGenerator.java@@ -219,9 +219,10 @@ public class PreSignedUrlGenerator {String method, Instant signedAt, int expiry) {// The in-memory retirement list cannot survive a restart. Sweep persisted expired// sessions once on first use, then retire this process's replacements as they expire.+ // IamService judges which sessions have expired on its own clock, as it does everywhere.if (expiredSessionsSwept.compareAndSet(false, true)) {try {- iamService.sweepExpiredSessions(signedAt);+ iamService.sweepExpiredSessions();} catch (RuntimeException failure) {expiredSessionsSwept.set(false);throw failure;diff --git a/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java b/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.javaindex c3b67e5285..ec905c94cf 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/IamEnforcementFilterTest.java@@ -34,7 +34,9 @@ import org.junit.jupiter.params.provider.CsvSource;import org.mockito.ArgumentCaptor;import java.nio.charset.StandardCharsets;+import java.time.Clock;import java.time.Instant;+import java.time.ZoneOffset;import java.util.List;import java.util.Map;import java.util.Optional;@@ -126,6 +128,10 @@ class IamEnforcementFilterTest {}private IamEnforcementFilter newFilter(ResourceInfo resourceInfo) {+ return newFilter(resourceInfo, Clock.systemUTC());+ }++ private IamEnforcementFilter newFilter(ResourceInfo resourceInfo, Clock clock) {@SuppressWarnings("unchecked")Instance<ScpProvider> scpProvider = mock(Instance.class);when(scpProvider.isResolvable()).thenReturn(false);@@ -134,7 +140,7 @@ class IamEnforcementFilterTest {new AwsQueryServiceResolver(catalog), arnBuilder, requestContext,conditionContextResolver, mock(CloudTrailService.class),mock(CurrentVertxRequest.class),- catalog, scpProvider, sessionAccountLookup, null, resourceInfo);+ catalog, scpProvider, sessionAccountLookup, null, clock, resourceInfo);}@Test@@ -615,6 +621,28 @@ class IamEnforcementFilterTest {assertSame(checked.getValue(), resolved.getValue());}+ @Test+ void theMomentBothLookupsAreAskedAboutIsReadFromTheInjectedClock() {+ // IamService measures session expiry on the injected clock, as AWS Sign-In stamps it, so a+ // moment read from the system clock would find a live Sign-In session expired in tests.+ Instant moment = Instant.parse("2026-01-01T00:00:00Z");+ IamEnforcementFilter filter = newFilter(null, Clock.fixed(moment, ZoneOffset.UTC));+ ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);+ String auth = "AWS4-HMAC-SHA256 Credential=ASIASESSION/20260101/us-east-1/s3/aws4_request, "+ + "SignedHeaders=host, Signature=abc";+ requestContext.setAccountId("000000000000");+ when(accountResolver.extractAccessKeyId(auth)).thenReturn("ASIASESSION");+ when(containerRequest.getHeaderString("Authorization")).thenReturn(auth);+ when(actionRegistry.resolve("s3", containerRequest)).thenReturn("s3:GetObject");++ filter.filter(containerRequest);+ // A presigned POST's credential reaches enforcement only through this call.+ filter.authorizeAdditionalResource(auth, "s3:PutObject", "arn:aws:s3:::bucket/key");++ verify(iamService, times(2)).isExpiredSession("ASIASESSION", moment);+ verify(iamService, times(2)).resolveCallerContext("ASIASESSION", moment);+ }+@Testvoid unknownAccessKeyIsRejectedOnAnRpcCallNoRuleMaps() {ContainerRequestContext containerRequest = mock(ContainerRequestContext.class);diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/ExpiredSessionEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/ExpiredSessionEnforcementIntegrationTest.javaindex d097d21ff7..c5edf58a82 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/ExpiredSessionEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/ExpiredSessionEnforcementIntegrationTest.java@@ -2,6 +2,7 @@ package io.github.hectorvent.floci.services.iam;import io.github.hectorvent.floci.testing.EnforcementFixtures;import io.github.hectorvent.floci.testing.IamEnforcementProfile;+import io.github.hectorvent.floci.testing.MutableClock;import io.github.hectorvent.floci.testing.PartitionCleanup;import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;import io.quarkus.test.common.http.TestHTTPResource;@@ -15,6 +16,7 @@ import org.junit.jupiter.api.extension.RegisterExtension;import java.net.URI;import java.nio.charset.StandardCharsets;+import java.time.Duration;import java.time.Instant;import java.util.Locale;import java.util.UUID;@@ -23,7 +25,7 @@ import static io.restassured.RestAssured.given;import static org.hamcrest.Matchers.containsString;/**- * With enforcement on, a session past its expiration is answered with AWS's+ * With enforcement on, a session past its expiration on the injected clock is answered with AWS's* {@code ExpiredTokenException}, not as a key that exists nowhere, on every call and every time.*/@QuarkusTest@@ -36,6 +38,9 @@ class ExpiredSessionEnforcementIntegrationTest {@InjectIamService iamService;+ @Inject+ MutableClock clock;+/*** The teardown runs after Quarkus has reset the port RestAssured points at, so it has to say* where the application is. The test port is random, which leaves this as the only place to@@ -114,12 +119,29 @@ class ExpiredSessionEnforcementIntegrationTest {.then().statusCode(403).body(containsString("<Code>ExpiredTokenException</Code>"));}+ @Test+ void aSessionIsLiveUntilTheInjectedClockPassesItsExpiry() {+ // AWS Sign-In stamps its sessions' expiry from the injected clock, so enforcement measures+ // it on that clock too. On the system clock such a session read as expired once issued.+ String accessKeyId = sessionExpiringAt(clock.instant().plus(Duration.ofMinutes(15)));++ getCallerIdentity(accessKeyId).then().statusCode(200);++ clock.advance(Duration.ofMinutes(16));+ getCallerIdentity(accessKeyId)+ .then().statusCode(403).body(containsString("<Code>ExpiredTokenException</Code>"));+ }+private String expiredSession() {- String accessKeyId = "ASIAEXPIRED"+ return sessionExpiringAt(LONG_AGO);+ }++ private String sessionExpiringAt(Instant expiration) {+ String accessKeyId = "ASIASESSION"+ UUID.randomUUID().toString().replace("-", "").substring(0, 9).toUpperCase(Locale.ROOT);cleanup.register(() -> iamService.unregisterSession(ACCOUNT_ID, accessKeyId));iamService.registerSessionForAccount(ACCOUNT_ID, accessKeyId, "secret",- "arn:aws:iam::" + ACCOUNT_ID + ":role/expired-session-role", LONG_AGO, null);+ "arn:aws:iam::" + ACCOUNT_ID + ":role/expired-session-role", expiration, null);return accessKeyId;}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 f36637b5fd..fbf150c85d 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@@ -23,16 +23,20 @@ import io.github.hectorvent.floci.services.iam.model.OrganizationRootFeatures;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 org.junit.jupiter.api.BeforeEach;import org.junit.jupiter.api.Test;import org.mockito.Mockito;import java.nio.charset.StandardCharsets;+import java.time.Clock;import java.time.Duration;import java.time.Instant;import java.time.OffsetDateTime;+import java.time.ZoneOffset;import java.time.temporal.ChronoUnit;import java.util.Base64;+import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Optional;@@ -41,6 +45,8 @@ import java.util.concurrent.ExecutorService;import java.util.concurrent.Executors;import java.util.concurrent.TimeUnit;import java.util.concurrent.atomic.AtomicInteger;+import java.util.function.BiPredicate;+import java.util.function.Predicate;import static io.github.hectorvent.floci.services.iam.InlinePolicyTestHelper.policyWithNonWhitespaceLength;import static org.junit.jupiter.api.Assertions.*;@@ -243,6 +249,80 @@ class IamServiceTest {assertTrue(service.resolveCallerArns("ASIAEXPIREDSESSION").isEmpty());}+ @Test+ void sessionExpiryFollowsTheInjectedClock() {+ MutableClock clock = new MutableClock();+ IamService service = new IamService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new RegionResolver("us-east-1", "000000000000"), false, clock);+ service.createRole("ClockRole", "/", "{}", null, 3600, null);+ Map<String, Predicate<String>> lookups = new LinkedHashMap<>();+ lookups.put("secret key", key -> service.findSecretKey(key, "token").isPresent());+ lookups.put("account", key -> service.resolveAccountId(key).isPresent());+ lookups.put("caller context", key -> service.resolveCallerContext(key) != null);+ lookups.put("caller ARNs", key -> service.resolveCallerArns(key).isPresent());+ lookups.put("user ID", key -> service.resolveCallerUserId(key, "token").isPresent());++ int sessionNumber = 0;+ for (Map.Entry<String, Predicate<String>> lookup : lookups.entrySet()) {+ // A fresh session per lookup: some lookups delete a session they find expired.+ String accessKeyId = "ASIACLOCKSESSION" + sessionNumber++;+ service.registerSession(accessKeyId, "secret", "token", "arn:aws:iam::000000000000:role/ClockRole",+ clock.instant().plusSeconds(60), null, "000000000000", "s", "AROACLOCKROLE:s");+ assertTrue(lookup.getValue().test(accessKeyId), lookup.getKey() + " before expiry");+ clock.advance(Duration.ofSeconds(61));+ assertFalse(lookup.getValue().test(accessKeyId), lookup.getKey() + " after expiry");+ }+ }++ @Test+ void aSessionIsExpiredFromTheInstantItsExpirationNames() {+ // Every lookup, the enforcement check and the sweep draw the same boundary, so none of them+ // accepts a session another one already treats as expired.+ Instant expiration = Instant.parse("2026-01-01T00:01:00Z");+ Map<String, BiPredicate<IamService, String>> expired = new LinkedHashMap<>();+ expired.put("secret key", (service, key) -> service.findSecretKey(key, "token").isEmpty());+ expired.put("account", (service, key) -> service.resolveAccountId(key).isEmpty());+ expired.put("caller context", (service, key) -> service.resolveCallerContext(key) == null);+ expired.put("caller ARNs", (service, key) -> service.resolveCallerArns(key).isEmpty());+ expired.put("user ID", (service, key) -> service.resolveCallerUserId(key, "token").isEmpty());+ expired.put("enforcement", (service, key) -> service.isExpiredSession(key, expiration));+ expired.put("sweep", (service, key) -> service.sweepExpiredSessions() == 1);++ for (Map.Entry<String, BiPredicate<IamService, String>> check : expired.entrySet()) {+ // A fresh service per check: some checks delete a session they find expired.+ IamService service = new IamService(new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(),+ new RegionResolver("us-east-1", "000000000000"), false, Clock.fixed(expiration, ZoneOffset.UTC));+ service.createRole("ClockRole", "/", "{}", null, 3600, null);+ service.registerSession("ASIABOUNDARYSESSION", "secret", "token",+ "arn:aws:iam::000000000000:role/ClockRole", expiration, null, "000000000000", "s",+ "AROACLOCKROLE:s");+ assertTrue(check.getValue().test(service, "ASIABOUNDARYSESSION"), check.getKey());+ }+ }++ @Test+ void theExpiredSessionSweepFollowsTheInjectedClock() {+ // The presigned URL generator sweeps every stored session on its first URL, so a session+ // live on the clock, as a Sign-In session is in tests, has to survive it.+ MutableClock clock = new MutableClock();+ IamService service = new IamService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new RegionResolver("us-east-1", "000000000000"), false, clock);+ service.registerSession("ASIALIVESESSION", "secret", "token", "arn:aws:iam::000000000000:role/ClockRole",+ clock.instant().plusSeconds(60), null, "000000000000", "s", "AROACLOCKROLE:s");+ service.registerSession("ASIAPASTSESSION", "secret", "token", "arn:aws:iam::000000000000:role/ClockRole",+ clock.instant().minusSeconds(1), null, "000000000000", "s", "AROACLOCKROLE:s");++ assertEquals(1, service.sweepExpiredSessions());+ assertTrue(service.findSecretKey("ASIALIVESESSION", "token").isPresent());++ clock.advance(Duration.ofSeconds(61));+ assertEquals(1, service.sweepExpiredSessions());+ }+private static final String READ_S3 = """{"Version":"2012-10-17","Statement":[{"Effect":"Allow","Action":"s3:GetObject","Resource":"*"}]}""";private static final String ALL_S3 = """diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/ServiceSpecificCredentialStateTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/ServiceSpecificCredentialStateTest.javaindex 5acf80f0a5..56a8cbca11 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/ServiceSpecificCredentialStateTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/ServiceSpecificCredentialStateTest.java@@ -9,12 +9,14 @@ import io.github.hectorvent.floci.core.storage.InMemoryStorage;import io.github.hectorvent.floci.core.storage.PersistentStorage;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.services.iam.model.ServiceSpecificCredential;+import io.github.hectorvent.floci.testing.MutableClock;import jakarta.enterprise.inject.Instance;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.io.TempDir;import java.nio.file.Path;-import java.time.Instant;+import java.time.Clock;+import java.time.Duration;import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;import java.util.List;@@ -62,6 +64,11 @@ class ServiceSpecificCredentialStateTest {private static IamService newService(StorageBackend<String, ServiceSpecificCredential> credentials, String defaultAccount) {+ return newService(credentials, defaultAccount, Clock.systemUTC());+ }++ private static IamService newService(+ StorageBackend<String, ServiceSpecificCredential> credentials, String defaultAccount, Clock clock) {return new IamService(new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),@@ -71,7 +78,7 @@ class ServiceSpecificCredentialStateTest {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),credentials,new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),- new RegionResolver("us-east-1", defaultAccount), false, null);+ new RegionResolver("us-east-1", defaultAccount), false, null, clock);}/**@@ -581,22 +588,18 @@ class ServiceSpecificCredentialStateTest {* A key past its {@code ExpirationDate} reports {@code Expired}, and an update to* {@code Active} cannot undo that: the status is derived on read, so the stored value is left* as the caller set it while the reported one tells the truth.- *- * <p>The expiry has to be planted directly in the store, because the smallest- * {@code CredentialAgeDays} AWS allows is one day, so no sequence of calls reaches a past- * expiry.*/@Testvoid aKeyPastItsExpiryReportsExpiredAndCannotBeReactivated() {- InMemoryStorage<String, ServiceSpecificCredential> store = new InMemoryStorage<>();- IamService service = newService(store, ACCOUNT_A);+ MutableClock clock = new MutableClock();+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A, clock);service.createUser("expiry-user", "/");+ // One day, the shortest CredentialAgeDays AWS allows.ServiceSpecificCredential credential =service.createServiceSpecificCredential("expiry-user", BEDROCK, 1);assertEquals("Active", service.reportedStatus(credential));- credential.setExpirationDate(Instant.now().minusSeconds(60));- store.put(credential.getServiceSpecificCredentialId(), credential);+ clock.advance(Duration.ofDays(1));assertEquals("Expired", service.reportedStatus(credential));assertEquals("Expired", service.reportedStatus(service@@ -615,16 +618,15 @@ class ServiceSpecificCredentialStateTest {/** Expiry is terminal, so it outranks a status the caller set to Inactive. */@Testvoid anExpiredKeyReportsExpiredRatherThanInactive() {- InMemoryStorage<String, ServiceSpecificCredential> store = new InMemoryStorage<>();- IamService service = newService(store, ACCOUNT_A);+ MutableClock clock = new MutableClock();+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A, clock);service.createUser("inactive-user", "/");ServiceSpecificCredential credential =service.createServiceSpecificCredential("inactive-user", BEDROCK, 1);service.updateServiceSpecificCredential("inactive-user", credential.getServiceSpecificCredentialId(), "Inactive");- credential.setExpirationDate(Instant.now().minusSeconds(60));- store.put(credential.getServiceSpecificCredentialId(), credential);+ clock.advance(Duration.ofDays(1));assertEquals("Expired", service.reportedStatus(credential));}diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGeneratorSessionTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGeneratorSessionTest.javaindex d0b32c37f7..e632da5f29 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGeneratorSessionTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/PreSignedUrlGeneratorSessionTest.java@@ -68,7 +68,7 @@ class PreSignedUrlGeneratorSessionTest {assertFalse(secrets.containsKey(firstKey), "Expired superseded sessions are removed");assertTrue(secrets.containsKey(secondKey));assertEquals(2, secrets.size(), "Unexpired object-scoped sessions remain available");- verify(iamService, times(1)).sweepExpiredSessions(start);+ verify(iamService, times(1)).sweepExpiredSessions();}@Testdiff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3ValidateSignaturesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3ValidateSignaturesIntegrationTest.javaindex 98f569a6ad..62b6b5aa7b 100644--- a/src/test/java/io/github/hectorvent/floci/services/s3/S3ValidateSignaturesIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/s3/S3ValidateSignaturesIntegrationTest.java@@ -1,23 +1,33 @@package io.github.hectorvent.floci.services.s3;import io.github.hectorvent.floci.core.common.auth.SigV4RequestValidator;+import io.github.hectorvent.floci.testing.MutableClock;import io.github.hectorvent.floci.testing.ValidateSignaturesProfile;import io.github.hectorvent.floci.testutil.AwsRequestSigner;import io.github.hectorvent.floci.testutil.S3RequestSigner;import io.quarkus.test.junit.QuarkusTest;import io.quarkus.test.junit.TestProfile;import io.restassured.path.xml.XmlPath;+import io.restassured.response.Response;+import jakarta.inject.Inject;import org.junit.jupiter.api.MethodOrderer;import org.junit.jupiter.api.Order;import org.junit.jupiter.api.Test;import org.junit.jupiter.api.TestMethodOrder;import java.io.ByteArrayOutputStream;+import java.net.URI;+import java.net.URLDecoder;import java.nio.charset.StandardCharsets;+import java.security.MessageDigest;+import java.time.Duration;import java.time.Instant;import java.time.ZoneOffset;import java.time.format.DateTimeFormatter;+import java.util.Arrays;import java.util.Base64;+import java.util.Map;+import java.util.stream.Collectors;import java.util.zip.ZipEntry;import java.util.zip.ZipOutputStream;@@ -27,7 +37,7 @@ import static org.hamcrest.Matchers.equalTo;/*** {@code floci.auth.validate-signatures} authenticates every signed S3 request, whichever- * placement carries the signature, without authorizing it: a forged or unknown credential is+ * placement carries the signature, without authorizing it: a forged, unknown or expired credential is* refused, while bucket policies are not evaluated and unsigned requests pass, as they do with* {@code enforce-auth} off. Shares {@link ValidateSignaturesProfile} with* {@link PreSignedUrlIntegrationTest}, which covers the presigned query-string placement.@@ -47,9 +57,16 @@ class S3ValidateSignaturesIntegrationTest {"Action":"s3:GetObject","Resource":"arn:aws:s3:::%s/*"}]}""".formatted(BUCKET);+ private static final String SIGNIN_CLIENT_ID = "arn:aws:signin:::devtools/same-device";+ private static final String SIGNIN_REDIRECT_URI = "http://127.0.0.1:4567/oauth/callback";+ private static final String SIGNIN_VERIFIER = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._~";+private static String userAccessKeyId;private static String userSecretKey;+ @Inject+ MutableClock clock;+@Testvoid layerContentLocationCanBeFetchedWithSignatureValidationEnabled() throws Exception {ByteArrayOutputStream archive = new ByteArrayOutputStream();@@ -296,6 +313,84 @@ class S3ValidateSignaturesIntegrationTest {.body(containsString("<Code>AuthorizationHeaderMalformed</Code>"));}+ @Test+ @Order(34)+ void headerSignedRequestsWithSigninCredentialsAreAcceptedUntilTheyExpire() throws Exception {+ // Sign-In stamps its access token's expiry from the injected clock, so IAM measures it on the same one.+ Response token = signIn();+ S3RequestSigner signinSigner = S3RequestSigner.signedAs(token.path("accessToken.accessKeyId"),+ token.path("accessToken.secretAccessKey"), token.path("accessToken.sessionToken"));+ given()+ .filter(signinSigner)+ .when()+ .get("/" + BUCKET + "/" + KEY)+ .then()+ .statusCode(200);++ clock.advance(Duration.ofSeconds(token.<Integer>path("expiresIn") + 1L));+ // A known gap from AWS, not the intended answer: S3 lists 400 ExpiredToken for a session past+ // its expiry, which only IAM enforcement gives today. Signature validation still answers it+ // as a key it does not know.+ given()+ .filter(signinSigner)+ .when()+ .get("/" + BUCKET + "/" + KEY)+ .then()+ .statusCode(403)+ .body("Error.Code", equalTo("InvalidAccessKeyId"));+ }++ /** Runs the AWS Sign-In authorization-code flow through its consent page and returns the token response. */+ private static Response signIn() throws Exception {+ byte[] digest = MessageDigest.getInstance("SHA-256")+ .digest(SIGNIN_VERIFIER.getBytes(StandardCharsets.US_ASCII));+ String consent = given()+ .redirects().follow(false)+ .queryParam("client_id", SIGNIN_CLIENT_ID)+ .queryParam("code_challenge", Base64.getUrlEncoder().withoutPadding().encodeToString(digest))+ .queryParam("code_challenge_method", "SHA-256")+ .queryParam("redirect_uri", SIGNIN_REDIRECT_URI)+ .queryParam("response_type", "code")+ .queryParam("scope", "openid")+ .queryParam("state", "validate-signatures")+ .when()+ .get("/v1/authorize")+ .then()+ .statusCode(302)+ .extract().header("Location");+ String callback = given()+ .redirects().follow(false)+ .contentType("application/x-www-form-urlencoded")+ .formParam("request_id", queryParams(URI.create(consent)).get("request_id"))+ .formParam("action", "continue")+ .when()+ .post("/_floci/signin/consent")+ .then()+ .statusCode(302)+ .extract().header("Location");+ return given()+ .contentType("application/json")+ .body(Map.of(+ "clientId", SIGNIN_CLIENT_ID,+ "grantType", "authorization_code",+ "code", queryParams(URI.create(callback)).get("code"),+ "redirectUri", SIGNIN_REDIRECT_URI,+ "codeVerifier", SIGNIN_VERIFIER))+ .when()+ .post("/v1/token")+ .then()+ .statusCode(200)+ .extract().response();+ }++ private static Map<String, String> queryParams(URI uri) {+ return Arrays.stream(uri.getRawQuery().split("&"))+ .map(pair -> pair.split("=", 2))+ .collect(Collectors.toMap(+ parts -> URLDecoder.decode(parts[0], StandardCharsets.UTF_8),+ parts -> URLDecoder.decode(parts[1], StandardCharsets.UTF_8)));+ }+private static void createIamUser(String userName) {// validate-signatures verifies IAM's signatures too, so these calls carry real ones.AwsRequestSigner iam = AwsRequestSigner.signedAs("test", "test", "iam");