Skip to content

armgit / floci

Public Imported from GitHub
0

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.java
index 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.java
index 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.java
index 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.java
index 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);
+ }
+
@Test
void 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.java
index 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 {
@Inject
IamService 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.java
index 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.java
index 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.
*/
@Test
void 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. */
@Test
void 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.java
index 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();
}
@Test
diff --git a/src/test/java/io/github/hectorvent/floci/services/s3/S3ValidateSignaturesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/s3/S3ValidateSignaturesIntegrationTest.java
index 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;
+
@Test
void 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");