Skip to content

armgit / floci

Public Imported from GitHub
0

Light, fluffy, and always free - The AWS Local Emulator alternative

fix: serialize IAM and STS Query timestamps with millisecond precision (#5110)

Andre Kurait3cdc9ef22d85
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.java
index 2d19d93489..0bb9156d2f 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
@@ -32,6 +32,7 @@ import org.jboss.logging.Logger;
import java.nio.charset.StandardCharsets;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
import java.util.ArrayList;
import java.util.Base64;
import java.util.HashMap;
@@ -2936,7 +2937,7 @@ public class IamQueryHandler {
private String isoDate(Instant instant) {
if (instant == null) return "";
- return DateTimeFormatter.ISO_INSTANT.format(instant);
+ return DateTimeFormatter.ISO_INSTANT.format(instant.truncatedTo(ChronoUnit.MILLIS));
}
/** For a member AWS types as a blob, which the Query protocol carries base64-encoded. */
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 db3a2818da..46e723a4ab 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
@@ -236,6 +236,9 @@ public class IamService implements SessionAccountLookup, ResourceProvider {
/** The creation half of a long-term API key's alias. */
private static final DateTimeFormatter CREDENTIAL_ALIAS_DATE =
DateTimeFormatter.ofPattern("yyyyMMdd").withZone(ZoneOffset.UTC);
+ /** The credential report's timestamps, as in the User Guide's example rows: 2014-10-15T16:31:25+00:00. */
+ private static final DateTimeFormatter CREDENTIAL_REPORT_TIME =
+ DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ssxxx").withZone(ZoneOffset.UTC);
/** AWS General Reference, IAM service quotas: "SSH Public keys per user", not adjustable. */
private static final int MAX_SSH_PUBLIC_KEYS_PER_USER = 5;
/** publicKeyIdType is 20 to 128 of [\w]+, and AWS's own examples use the APKA prefix. */
@@ -5358,6 +5361,6 @@ public class IamService implements SessionAccountLookup, ResourceProvider {
}
private String isoDate(Instant instant) {
- return instant == null ? "" : DateTimeFormatter.ISO_INSTANT.format(instant);
+ return instant == null ? "" : CREDENTIAL_REPORT_TIME.format(instant);
}
}
diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java
index 18710501a3..9b72356a84 100644
--- a/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java
+++ b/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java
@@ -26,8 +26,10 @@ import org.jboss.logging.Logger;
import java.security.SecureRandom;
import java.security.interfaces.RSAPublicKey;
+import java.time.Clock;
import java.time.Instant;
import java.time.format.DateTimeFormatter;
+import java.time.temporal.ChronoUnit;
import java.util.List;
import java.util.Map;
import java.util.Optional;
@@ -55,6 +57,7 @@ public class StsQueryHandler {
private final OidcIssuerKeyLookup oidcIssuerKeys;
private final SAMLProviderService samlProviderService;
private final SAMLTrustPolicyEvaluator samlTrustEvaluator;
+ private final Clock clock;
/** CSPRNG for session secret keys and session tokens; ordinary IDs keep using {@link ThreadLocalRandom}. */
private final SecureRandom secureRandom = new SecureRandom();
@@ -73,6 +76,18 @@ public class StsQueryHandler {
OidcIssuerKeyLookup oidcIssuerKeys,
SAMLProviderService samlProviderService,
SAMLTrustPolicyEvaluator samlTrustEvaluator) {
+ this(iamService, accountResolver, regionResolver, config, trustPolicyEvaluator, webIdentityTrustEvaluator,
+ tokenVerifier, oidcIssuerKeys, samlProviderService, samlTrustEvaluator, Clock.systemUTC());
+ }
+
+ StsQueryHandler(IamService iamService, AccountResolver accountResolver, RegionResolver regionResolver,
+ EmulatorConfig config, AssumeRolePolicyEvaluator trustPolicyEvaluator,
+ WebIdentityTrustPolicyEvaluator webIdentityTrustEvaluator,
+ WebIdentityTokenVerifier tokenVerifier,
+ OidcIssuerKeyLookup oidcIssuerKeys,
+ SAMLProviderService samlProviderService,
+ SAMLTrustPolicyEvaluator samlTrustEvaluator,
+ Clock clock) {
this.iamService = iamService;
this.accountResolver = accountResolver;
this.regionResolver = regionResolver;
@@ -83,6 +98,7 @@ public class StsQueryHandler {
this.oidcIssuerKeys = oidcIssuerKeys;
this.samlProviderService = samlProviderService;
this.samlTrustEvaluator = samlTrustEvaluator;
+ this.clock = clock;
}
public Response handle(String action, MultivaluedMap<String, String> params) {
@@ -117,7 +133,7 @@ public class StsQueryHandler {
String accessKeyId = "ASIA" + randomId(16);
String secretKey = randomSecret(40);
String sessionToken = randomSecret(200);
- Instant expiration = Instant.now().plusSeconds(durationSeconds);
+ Instant expiration = clock.instant().plusSeconds(durationSeconds);
String roleName = roleArn != null && roleArn.contains("/")
? roleArn.substring(roleArn.lastIndexOf('/') + 1)
@@ -238,7 +254,7 @@ public class StsQueryHandler {
String accessKeyId = "ASIA" + randomId(16);
String secretKey = randomSecret(40);
String sessionToken = randomSecret(200);
- Instant expiration = Instant.now().plusSeconds(durationSeconds);
+ Instant expiration = clock.instant().plusSeconds(durationSeconds);
String result = credentialsXml(accessKeyId, secretKey, sessionToken, expiration);
// No role ARN: the credentials route back to the caller's account and act as the caller.
@@ -286,7 +302,7 @@ public class StsQueryHandler {
String accessKeyId = "ASIA" + randomId(16);
String secretKey = randomSecret(40);
String sessionToken = randomSecret(200);
- Instant expiration = Instant.now().plusSeconds(durationSeconds);
+ Instant expiration = clock.instant().plusSeconds(durationSeconds);
String sessionRoleArn = canonicalRoleArn(role, accountId, roleName);
String assumedRoleArn = assumedRoleArn(sessionRoleArn, accountId, roleName, sessionName);
@@ -454,7 +470,7 @@ public class StsQueryHandler {
new AwsException("InvalidIdentityToken", "The SAML provider is not trusted.", 400));
SAMLAssertionVerifier.Verified verified;
try {
- verified = SAMLAssertionVerifier.verify(getParam(params, "SAMLAssertion"), provider, Instant.now());
+ verified = SAMLAssertionVerifier.verify(getParam(params, "SAMLAssertion"), provider, clock.instant());
} catch (SAMLAssertionVerifier.InvalidAssertionException e) {
throw new AwsException("InvalidIdentityToken", e.awsMessage(), 400);
}
@@ -482,8 +498,8 @@ public class StsQueryHandler {
if (sessionName.length() > 64) {
sessionName = sessionName.substring(0, 64);
}
- Instant requestedExpiration = Instant.now().plusSeconds(durationSeconds);
- Instant roleExpiration = Instant.now().plusSeconds(role.getMaxSessionDuration());
+ Instant requestedExpiration = clock.instant().plusSeconds(durationSeconds);
+ Instant roleExpiration = clock.instant().plusSeconds(role.getMaxSessionDuration());
Instant expiration = verified.expiration().isBefore(requestedExpiration) ? verified.expiration() : requestedExpiration;
if (roleExpiration.isBefore(expiration)) {
expiration = roleExpiration;
@@ -528,7 +544,7 @@ public class StsQueryHandler {
String accessKeyId = "ASIA" + randomId(16);
String secretKey = randomSecret(40);
String sessionToken = randomSecret(200);
- Instant expiration = Instant.now().plusSeconds(durationSeconds);
+ Instant expiration = clock.instant().plusSeconds(durationSeconds);
String accountId = regionResolver.getAccountId();
String federatedUserId = accountId + ":" + name;
String federatedUserArn = regionResolver.buildGlobalArn("sts", accountId, "federated-user/" + name);
@@ -632,7 +648,7 @@ public class StsQueryHandler {
}
private String isoDate(Instant instant) {
- return DateTimeFormatter.ISO_INSTANT.format(instant);
+ return DateTimeFormatter.ISO_INSTANT.format(instant.truncatedTo(ChronoUnit.MILLIS));
}
private static String randomId(int length) {
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamQueryHandlerTest.java
new file mode 100644
index 0000000000..a65acdb1f7
--- /dev/null
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamQueryHandlerTest.java
@@ -0,0 +1,114 @@
+package io.github.hectorvent.floci.services.iam;
+
+import io.github.hectorvent.floci.core.common.XmlParser;
+import io.github.hectorvent.floci.services.iam.model.IamRole;
+import io.github.hectorvent.floci.services.iam.model.ServerCertificate;
+import jakarta.ws.rs.core.MultivaluedHashMap;
+import jakarta.ws.rs.core.MultivaluedMap;
+import jakarta.ws.rs.core.Response;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.w3c.dom.Document;
+import org.w3c.dom.NodeList;
+
+import java.time.Instant;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/** Direct Query handler tests with a mocked service, without a Quarkus application or HTTP server. */
+class IamQueryHandlerTest {
+
+ private static final String ROLE_NAME = "TimestampRole";
+ private static final String CERTIFICATE_NAME = "TimestampCertificate";
+
+ /**
+ * Smithy's date-time format carries at most millisecond precision and asks serializers to truncate
+ * anything finer; ISO_INSTANT then prints the fraction in groups of three, or not at all.
+ */
+ static Stream<Arguments> timestampCases() {
+ return Stream.of(
+ Arguments.of("2026-10-05T05:47:29.777826302Z", "2026-10-05T05:47:29.777Z"),
+ Arguments.of("2026-10-05T05:47:29.785090420Z", "2026-10-05T05:47:29.785Z"),
+ Arguments.of("2026-10-05T05:47:29Z", "2026-10-05T05:47:29Z"),
+ Arguments.of("2026-10-05T05:47:29.000000001Z", "2026-10-05T05:47:29Z"),
+ Arguments.of("2026-10-05T05:47:29.000999999Z", "2026-10-05T05:47:29Z"),
+ Arguments.of("2026-10-05T05:47:29.001000000Z", "2026-10-05T05:47:29.001Z"),
+ Arguments.of("2026-10-05T05:47:29.010000000Z", "2026-10-05T05:47:29.010Z"),
+ Arguments.of("2026-12-31T23:59:59.999999999Z", "2026-12-31T23:59:59.999Z"),
+ Arguments.of("1969-12-31T23:59:59.999999999Z", "1969-12-31T23:59:59.999Z"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("timestampCases")
+ void serverCertificateResponsesWriteMillisecondTimestamps(String stored, String expected) throws Exception {
+ Instant timestamp = Instant.parse(stored);
+ ServerCertificate certificate = new ServerCertificate();
+ certificate.setServerCertificateName(CERTIFICATE_NAME);
+ certificate.setServerCertificateId("certificate-id");
+ certificate.setArn("arn:aws:iam::000000000000:server-certificate/TimestampCertificate");
+ certificate.setCertificateBody("fabricated-certificate");
+ certificate.setUploadDate(timestamp);
+ certificate.setExpiration(timestamp);
+
+ IamService service = mock(IamService.class);
+ when(service.uploadServerCertificate(CERTIFICATE_NAME, "/", "fabricated-certificate",
+ "fabricated-key", null, Map.of())).thenReturn(certificate);
+ when(service.getServerCertificate(CERTIFICATE_NAME)).thenReturn(certificate);
+ when(service.listServerCertificates(null)).thenReturn(List.of(certificate));
+ IamQueryHandler handler = new IamQueryHandler(service, null, null, null, null, null, null);
+
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("ServerCertificateName", CERTIFICATE_NAME);
+ params.putSingle("Path", "/");
+ params.putSingle("CertificateBody", "fabricated-certificate");
+ params.putSingle("PrivateKey", "fabricated-key");
+
+ for (String action : List.of("UploadServerCertificate", "GetServerCertificate", "ListServerCertificates")) {
+ try (Response response = handler.handle(action, params, null)) {
+ assertXmlMember(response, "UploadDate", expected);
+ assertXmlMember(response, "Expiration", expected);
+ }
+ }
+ }
+
+ @ParameterizedTest
+ @MethodSource("timestampCases")
+ void roleResponsesWriteMillisecondTimestamps(String stored, String expected) throws Exception {
+ IamRole role = new IamRole();
+ role.setRoleName(ROLE_NAME);
+ role.setRoleId("role-id");
+ role.setPath("/");
+ role.setArn("arn:aws:iam::000000000000:role/TimestampRole");
+ role.setAssumeRolePolicyDocument("{}");
+ role.setCreateDate(Instant.parse(stored));
+ IamService service = mock(IamService.class);
+ when(service.createRole(ROLE_NAME, "/", "{}", null, 3600, Map.of(), null)).thenReturn(role);
+ when(service.getRole(ROLE_NAME)).thenReturn(role);
+ IamQueryHandler handler = new IamQueryHandler(service, null, null, null, null, null, null);
+
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("RoleName", ROLE_NAME);
+ params.putSingle("Path", "/");
+ params.putSingle("AssumeRolePolicyDocument", "{}");
+
+ for (String action : List.of("CreateRole", "GetRole")) {
+ try (Response response = handler.handle(action, params, null)) {
+ assertXmlMember(response, "CreateDate", expected);
+ }
+ }
+ }
+
+ private static void assertXmlMember(Response response, String member, String expected) throws Exception {
+ assertEquals(200, response.getStatus());
+ Document document = XmlParser.parseDocument((String) response.getEntity());
+ NodeList matches = document.getElementsByTagNameNS("*", member);
+ assertEquals(1, matches.getLength(), member);
+ assertEquals(expected, matches.item(0).getTextContent(), member);
+ }
+}
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 89041f313d..16eb890ba9 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
@@ -30,6 +30,8 @@ import org.mockito.Mockito;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.time.Instant;
+import java.time.OffsetDateTime;
+import java.time.temporal.ChronoUnit;
import java.util.Base64;
import java.util.List;
import java.util.Map;
@@ -2683,6 +2685,33 @@ class IamServiceTest {
assertTrue(csv.contains("<root_account>,arn:aws:iam::"), "expected a root account row, got: " + csv);
}
+ /**
+ * The User Guide's example report writes every timestamp as 2014-10-15T16:31:25+00:00: whole
+ * seconds and a numeric offset, never a nanosecond fraction or a trailing Z.
+ */
+ @Test
+ void credentialReportWritesTimestampsInTheDocumentedForm() {
+ IamUser user = iamService.createUser("cred-report-time-user", "/");
+ iamService.createLoginProfile("cred-report-time-user", "Sup3r-Secret!", false);
+ AccessKey key = iamService.createAccessKey("cred-report-time-user");
+ Instant passwordChanged = iamService.getLoginProfile("cred-report-time-user").getPasswordLastChanged();
+ iamService.generateCredentialReport();
+
+ String csv = new String(Base64.getDecoder().decode(iamService.getCredentialReport().base64Content()));
+ String[] fields = csv.lines().filter(line -> line.startsWith("cred-report-time-user,")).findFirst()
+ .orElseThrow(() -> new AssertionError("no row for cred-report-time-user in: " + csv))
+ .split(",", -1);
+
+ assertReportTime(user.getCreateDate(), fields[2], "user_creation_time");
+ assertReportTime(passwordChanged, fields[5], "password_last_changed");
+ assertReportTime(key.getCreateDate(), fields[9], "access_key_1_last_rotated");
+ }
+
+ private static void assertReportTime(Instant stored, String field, String column) {
+ assertTrue(field.matches("\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}\\+00:00"), column + ": " + field);
+ assertEquals(stored.truncatedTo(ChronoUnit.SECONDS), OffsetDateTime.parse(field).toInstant(), column);
+ }
+
@Test
void getCredentialReportIncludesEveryUserWithPasswordAndAccessKeyState() {
iamService.createUser("cred-report-user", "/");
diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java
index a1e331c3fa..57a6d49831 100644
--- a/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java
+++ b/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java
@@ -14,10 +14,15 @@ import jakarta.ws.rs.core.MultivaluedMap;
import jakarta.ws.rs.core.Response;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.MethodSource;
import org.junit.jupiter.params.provider.ValueSource;
+import org.mockito.ArgumentCaptor;
import java.security.interfaces.RSAPublicKey;
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneOffset;
import java.util.List;
import java.util.Optional;
import java.util.regex.Matcher;
@@ -31,6 +36,7 @@ import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyMap;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
+import static org.mockito.ArgumentMatchers.isNull;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -44,6 +50,7 @@ class StsQueryHandlerTest {
Pattern.compile("<SessionToken>([^<]+)</SessionToken>");
private static final Pattern ARN = Pattern.compile("<Arn>([^<]+)</Arn>");
+ private static final Pattern EXPIRATION = Pattern.compile("<Expiration>([^<]+)</Expiration>");
private static StsQueryHandler newHandler() {
IamRole role = new IamRole();
@@ -67,6 +74,10 @@ class StsQueryHandlerTest {
}
private static StsQueryHandler newHandler(IamService iamService, RegionResolver regionResolver) {
+ return newHandler(iamService, regionResolver, Clock.systemUTC());
+ }
+
+ private static StsQueryHandler newHandler(IamService iamService, RegionResolver regionResolver, Clock clock) {
EmulatorConfig config = mock(EmulatorConfig.class);
EmulatorConfig.ServicesConfig services = mock(EmulatorConfig.ServicesConfig.class);
EmulatorConfig.IamServiceConfig iam = mock(EmulatorConfig.IamServiceConfig.class);
@@ -84,7 +95,8 @@ class StsQueryHandlerTest {
mock(WebIdentityTokenVerifier.class),
mock(OidcIssuerKeyLookup.class),
mock(SAMLProviderService.class),
- mock(SAMLTrustPolicyEvaluator.class));
+ mock(SAMLTrustPolicyEvaluator.class),
+ clock);
}
@Test
@@ -541,6 +553,42 @@ class StsQueryHandlerTest {
assertTrue(body.contains("<AssumedRoleId>AROAKX9OBMP2TSQJZ48H:my-session</AssumedRoleId>"), body);
}
+ /**
+ * Smithy's date-time format carries at most millisecond precision and asks serializers to truncate
+ * anything finer, so the XML drops the sub-millisecond digits while the session keeps the full instant.
+ */
+ @ParameterizedTest
+ @CsvSource({
+ "2026-10-05T05:47:29.777826302Z, 2026-10-05T05:47:29.777Z",
+ "2026-10-05T05:47:29.010000000Z, 2026-10-05T05:47:29.010Z",
+ "2026-10-05T05:47:29.000999999Z, 2026-10-05T05:47:29Z",
+ "2026-10-05T05:47:29Z, 2026-10-05T05:47:29Z"
+ })
+ void assumeRoleWritesExpirationAtMillisecondPrecision(String expiresAt, String expected) {
+ IamRole role = new IamRole();
+ role.setRoleName("TestRole");
+ role.setArn("arn:aws:iam::000000000000:role/TestRole");
+ IamService iamService = mock(IamService.class);
+ when(iamService.findRole(anyString(), anyString())).thenReturn(Optional.of(role));
+ Instant expiration = Instant.parse(expiresAt);
+ Clock clock = Clock.fixed(expiration.minusSeconds(900), ZoneOffset.UTC);
+ StsQueryHandler handler = newHandler(iamService, new RegionResolver(REGION, "000000000000"), clock);
+
+ MultivaluedMap<String, String> params = new MultivaluedHashMap<>();
+ params.putSingle("RoleArn", role.getArn());
+ params.putSingle("RoleSessionName", "s");
+ params.putSingle("DurationSeconds", "900");
+
+ Response response = handler.handle("AssumeRole", params);
+
+ assertEquals(200, response.getStatus(), (String) response.getEntity());
+ assertEquals(expected, extract(EXPIRATION, (String) response.getEntity()));
+ ArgumentCaptor<Instant> sessionExpiration = ArgumentCaptor.forClass(Instant.class);
+ verify(iamService).registerSession(anyString(), anyString(), anyString(), eq(role.getArn()),
+ sessionExpiration.capture(), isNull(), eq("000000000000"), eq("s"), anyString());
+ assertEquals(expiration, sessionExpiration.getValue());
+ }
+
private static String extract(Pattern pattern, String body) {
Matcher matcher = pattern.matcher(body);
assertTrue(matcher.find(), "expected " + pattern + " in " + body);