Light, fluffy, and always free - The AWS Local Emulator alternative
feat(iam): model signing certificates (#5024)
Priamo Germosen290f952cb1aa
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamSigningCertificateTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamSigningCertificateTest.javanew file mode 100644index 0000000000..1930f170c0--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamSigningCertificateTest.java@@ -0,0 +1,192 @@+package com.floci.test;++import org.junit.jupiter.api.AfterAll;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.DisplayName;+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 software.amazon.awssdk.services.iam.IamClient;+import software.amazon.awssdk.services.iam.model.CreateUserRequest;+import software.amazon.awssdk.services.iam.model.DeleteSigningCertificateRequest;+import software.amazon.awssdk.services.iam.model.DeleteUserRequest;+import software.amazon.awssdk.services.iam.model.ListSigningCertificatesRequest;+import software.amazon.awssdk.services.iam.model.ListSigningCertificatesResponse;+import software.amazon.awssdk.services.iam.model.NoSuchEntityException;+import software.amazon.awssdk.services.iam.model.SigningCertificate;+import software.amazon.awssdk.services.iam.model.StatusType;+import software.amazon.awssdk.services.iam.model.UpdateSigningCertificateRequest;+import software.amazon.awssdk.services.iam.model.UploadSigningCertificateRequest;+import software.amazon.awssdk.services.iam.model.UploadSigningCertificateResponse;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * Signing certificates driven through the AWS SDK rather than hand-written requests.+ *+ * <p>This is the check the handcrafted XML assertions cannot make: the SDK parses the response+ * against its own model, so a missing required member, a mis-named element or a timestamp in the+ * wrong format fails here even though the raw XML looked right. The shape marks UserName,+ * CertificateId, CertificateBody and Status required, and UploadDate is its only timestamp.+ *+ * <p>Status also round-trips through the SDK's {@code StatusType} enum, so a value the model does+ * not know would surface as {@code UNKNOWN_TO_SDK_VERSION} rather than as a string that merely+ * looked right on the wire.+ */+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class IamSigningCertificateTest {++ private static final String USER_NAME = "sdk-test-signing-user";++ /** A real self-signed certificate, valid to 2036, generated with openssl. */+ private static final String CERT_PEM = """++ -----BEGIN CERTIFICATE-----+ MIIDDTCCAfWgAwIBAgIUQKw8vNoVuYpX79WK4/CF2csyLBYwDQYJKoZIhvcNAQEL+ BQAwFjEUMBIGA1UEAwwLc2RrLnRlc3QuaW8wHhcNMjYxMDAzMDAxOTQ2WhcNMzYw+ OTMwMDAxOTQ2WjAWMRQwEgYDVQQDDAtzZGsudGVzdC5pbzCCASIwDQYJKoZIhvcN+ AQEBBQADggEPADCCAQoCggEBANya41O8oCtxTORSFpJGXD+8pfQDIa4zs1zyaKvf+ 0OWLIRBBcOAbTRCo8vI8nziu4HOq/7RVK2lbRkd86hgvCmBW3TaTkg38AK6ynTtj+ lgxwr9DyxGHewMANtZcf/uj0ypSrgqISp7VwiM3KRjTBEEGBUK0vxqsizS4i8cUs+ 5IPkwtT0teubfFBv+/Dy5PKQpYCSKGpSfioqbPO3BG2MYhxTum52xwXNpq08slCn+ kKBcboSJDkmAiy0bbjuBYd0X/zbFNiJL/e929mRucGDrCOb/xwzO3+sQQGMHOJ82+ gkM8qd2YnfaKQWjv6Ys2D2ScjhsoAIE/gk7acFEX+tZNje0CAwEAAaNTMFEwHQYD+ VR0OBBYEFNCvcqlMKI/qgcPfKhsIfpyUq/YpMB8GA1UdIwQYMBaAFNCvcqlMKI/q+ gcPfKhsIfpyUq/YpMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQELBQADggEB+ AJykw94trHhwwaua0JI0mHv6YbBmUreuc1UDTzNW+yuoEGpWef3HkkNCn9XlLn2h+ EZFQRtrLvvxqFwo9P97NX/ehSsqjnuUV5zPXPaQuydd4gOWUt8Ysq0eqIqzy28Pa+ vQTrGPkPFcL3gll2lecvXZgLTJtQKSoM6VDkUO3cbSNWHeDFxr82NXGPEsRqlVTE+ bQI1BNOypYjrtkmav2jlgWD0hIT2w54SxCoHldVcACrGeU9DHdVmQueXF+9uppAN+ inCkDT+tT4RN7hcm72EKke95XQwh0IW7ibFklkapGzVPYLS1oDJg17aaI9Ob/xem+ t2joILbhDvtwYcpNPaTAIdY=+ -----END CERTIFICATE-----+ """;++ private static IamClient iam;+ private static String certificateId;++ @BeforeAll+ static void setup() {+ iam = TestFixtures.iamClient();+ cleanupUser();+ iam.createUser(CreateUserRequest.builder().userName(USER_NAME).build());+ }++ @AfterAll+ static void cleanup() {+ cleanupUser();+ }++ private static void cleanupUser() {+ if (iam == null) {+ return;+ }+ try {+ ListSigningCertificatesResponse existing = iam.listSigningCertificates(+ ListSigningCertificatesRequest.builder().userName(USER_NAME).build());+ for (SigningCertificate certificate : existing.certificates()) {+ iam.deleteSigningCertificate(DeleteSigningCertificateRequest.builder()+ .userName(USER_NAME)+ .certificateId(certificate.certificateId())+ .build());+ }+ iam.deleteUser(DeleteUserRequest.builder().userName(USER_NAME).build());+ } catch (NoSuchEntityException expected) {+ // Nothing left over from an earlier run, which is the normal case.+ }+ }++ @Test+ @Order(1)+ @DisplayName("UploadSigningCertificate returns a parseable certificate with an Active status")+ void upload() {+ UploadSigningCertificateResponse response = iam.uploadSigningCertificate(+ UploadSigningCertificateRequest.builder()+ .userName(USER_NAME)+ .certificateBody(CERT_PEM)+ .build());++ SigningCertificate certificate = response.certificate();+ assertNotNull(certificate, "the response must carry the certificate");+ assertEquals(USER_NAME, certificate.userName());+ assertEquals(StatusType.ACTIVE, certificate.status(),+ "a newly uploaded certificate is Active");+ assertTrue(certificate.certificateBody().contains("BEGIN CERTIFICATE"));+ assertNotNull(certificate.uploadDate(), "UploadDate must parse as a timestamp");+ assertNotNull(certificate.certificateId());+ assertTrue(certificate.certificateId().length() >= 24,+ "certificateIdType has a minimum of 24: " + certificate.certificateId());++ certificateId = certificate.certificateId();+ }++ @Test+ @Order(2)+ @DisplayName("ListSigningCertificates returns the uploaded certificate")+ void list() {+ ListSigningCertificatesResponse response = iam.listSigningCertificates(+ ListSigningCertificatesRequest.builder().userName(USER_NAME).build());++ assertEquals(1, response.certificates().size());+ SigningCertificate certificate = response.certificates().get(0);+ assertEquals(certificateId, certificate.certificateId());+ assertEquals(USER_NAME, certificate.userName());+ assertNotNull(certificate.uploadDate());+ assertTrue(response.isTruncated() == null || !response.isTruncated());+ }++ @Test+ @Order(3)+ @DisplayName("UpdateSigningCertificate sets the status and the SDK reads it back as an enum")+ void updateStatus() {+ iam.updateSigningCertificate(UpdateSigningCertificateRequest.builder()+ .userName(USER_NAME)+ .certificateId(certificateId)+ .status(StatusType.INACTIVE)+ .build());++ ListSigningCertificatesResponse response = iam.listSigningCertificates(+ ListSigningCertificatesRequest.builder().userName(USER_NAME).build());+ assertEquals(StatusType.INACTIVE, response.certificates().get(0).status(),+ "the status must come back as a value the SDK model knows");+ }++ @Test+ @Order(4)+ @DisplayName("UserName is optional: the operation resolves it from the signing credentials")+ void userNameIsOptional() {+ // Omitting UserName must reach the implied-caller resolution rather than fail for a+ // missing parameter. The fixture signs with an access key that belongs to no stored IAM+ // user, which that resolution reports as NoSuchEntity, so this is the error that proves+ // the path ran: were UserName required, it would be a ValidationError instead.+ NoSuchEntityException thrown = assertThrows(NoSuchEntityException.class,+ () -> iam.listSigningCertificates(ListSigningCertificatesRequest.builder().build()));+ assertTrue(thrown.getMessage().contains("Access Key"),+ "the failure must come from resolving the key, not from a missing parameter: "+ + thrown.getMessage());+ }++ @Test+ @Order(5)+ @DisplayName("DeleteSigningCertificate removes it, and an unknown id is NoSuchEntity")+ void delete() {+ iam.deleteSigningCertificate(DeleteSigningCertificateRequest.builder()+ .userName(USER_NAME)+ .certificateId(certificateId)+ .build());++ ListSigningCertificatesResponse response = iam.listSigningCertificates(+ ListSigningCertificatesRequest.builder().userName(USER_NAME).build());+ assertTrue(response.certificates().isEmpty());++ assertThrows(NoSuchEntityException.class, () -> iam.deleteSigningCertificate(+ DeleteSigningCertificateRequest.builder()+ .userName(USER_NAME)+ .certificateId(certificateId)+ .build()));+ }+}diff --git a/docs/services/iam.md b/docs/services/iam.mdindex 1684904cdb..753dbfb598 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -578,6 +578,52 @@ Classic and CloudFront store certificate identifiers without resolving them agai[#4875](https://github.com/floci-io/floci/issues/4875), which covers both directions: rejecting areference to a certificate that does not exist, and refusing to delete one that is in use.+### Signing Certificates++| Action | Description |+|--------|-------------|+| UploadSigningCertificate | Stores an X.509 signing certificate against an IAM user and returns its generated `CertificateId`. |+| ListSigningCertificates | Lists a user's signing certificates, with `Marker` and `MaxItems` paging. |+| UpdateSigningCertificate | Sets a certificate's status to `Active`, `Inactive` or `Expired`. |+| DeleteSigningCertificate | Deletes one of a user's signing certificates. |++A signing certificate is not a server certificate: it belongs to a user rather than the account, it+carries no private key, no name and no path, and the generated `CertificateId` is the only handle+to it. The body is parsed on upload, because `MalformedCertificate` cannot be answered without+reading the material, and the status starts as `Active`.++`UserName` is optional on all four operations. Left out, it resolves to the user owning the access+key that signed the request, which is what the model documents.++Two certificates per user, which the User Guide states directly: "Users can have up to two X.509+signing certificates, to make certificate rotation easier". A third upload is `LimitExceeded`. The+count is taken inside the same lock as the write, so concurrent uploads cannot both see room for+the last slot.++`DuplicateCertificate` is account-wide rather than per user: AWS describes it as "the same+certificate is associated with an IAM user in the account", so a second user cannot upload material+the first already holds. The comparison is made on the encoded certificate rather than the PEM+text, so the same certificate re-wrapped or re-indented still counts as the same one.++`UpdateSigningCertificate` accepts `Expired` as well as `Active` and `Inactive`. The parameter's+prose explains only the first two, but the API Reference gives all three as valid values.++A signing certificate blocks `DeleteUser` until it is removed, which is one of the items AWS lists+as a prerequisite for deleting a user programmatically. It also follows the user across an+`UpdateUser` rename: left behind, a certificate would be stranded on a name that no longer exists,+invisible to its owner because listing goes through the user.++The credential report's `cert_1_active` and `cert_2_active` columns are backed by this store+instead of always reporting `FALSE`. The matching `cert_*_last_rotated` columns report the upload+date, and `N/A` when the certificate is not `Active`, which is how the User Guide defines them.+`GetAccountSummary`'s `AccountSigningCertificatesPresent` is unaffected: it reports the account root+user's certificates, and Floci does not model root credentials.++Under [enforcement](#iam-enforcement-mode) these actions are evaluated against `*` rather than the+owning user's ARN, along with every other IAM action except the server-certificate operations. That+is the general gap tracked in [#4979](https://github.com/floci-io/floci/issues/4979), not something+specific to signing certificates.+## AWS Managed PoliciesFloci seeds a catalog of commonly-used AWS managed policies at startup. These are attachable immediately without any setup:diff --git a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.javaindex 07afc66c14..c8db010ae2 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/AwsQueryController.java@@ -118,7 +118,9 @@ public class AwsQueryController {"TagServerCertificate", "UntagServerCertificate", "ListServerCertificateTags","CreateVirtualMFADevice", "DeleteVirtualMFADevice", "ListVirtualMFADevices","EnableMFADevice", "DeactivateMFADevice", "ResyncMFADevice", "ListMFADevices",- "TagMFADevice", "UntagMFADevice", "ListMFADeviceTags"+ "TagMFADevice", "UntagMFADevice", "ListMFADeviceTags",+ "UploadSigningCertificate", "ListSigningCertificates",+ "UpdateSigningCertificate", "DeleteSigningCertificate");private static final Set<String> AUTOSCALING_ACTIONS = Set.of(diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamQueryHandler.javaindex 4eea620720..f83e3f3742 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@@ -15,6 +15,7 @@ import io.github.hectorvent.floci.services.iam.model.OpenIDConnectProvider;import io.github.hectorvent.floci.services.iam.model.PolicyVersion;import io.github.hectorvent.floci.services.iam.model.SAMLProvider;import io.github.hectorvent.floci.services.iam.model.ServerCertificate;+import io.github.hectorvent.floci.services.iam.model.SigningCertificate;import io.github.hectorvent.floci.services.iam.model.ServiceLastAccessedEntity;import io.github.hectorvent.floci.services.iam.model.ServiceLastAccessedJob;import io.github.hectorvent.floci.services.iam.model.VirtualMfaDevice;@@ -91,6 +92,10 @@ public class IamQueryHandler {case "DeleteUser" -> handleDeleteUser(params);case "ListUsers" -> handleListUsers(params);case "UpdateUser" -> handleUpdateUser(params);+ case "UploadSigningCertificate" -> handleUploadSigningCertificate(params, authorization);+ case "ListSigningCertificates" -> handleListSigningCertificates(params, authorization);+ case "UpdateSigningCertificate" -> handleUpdateSigningCertificate(params, authorization);+ case "DeleteSigningCertificate" -> handleDeleteSigningCertificate(params, authorization);case "TagUser" -> handleTagUser(params);case "UntagUser" -> handleUntagUser(params);case "ListUserTags" -> handleListUserTags(params);@@ -751,6 +756,63 @@ public class IamQueryHandler {return Response.ok(AwsQueryResponse.envelope("ListServerCertificates", AwsNamespaces.IAM, xml.build())).build();}+ /**+ * UserName is optional on every signing-certificate operation: the model says it is determined+ * implicitly from the access key that signed the request.+ */+ private Response handleUploadSigningCertificate(MultivaluedMap<String, String> params,+ String authorization) {+ SigningCertificate certificate = iamService.uploadSigningCertificate(+ resolveUserName(params, authorization), getParam(params, "CertificateBody"));+ XmlBuilder xml = new XmlBuilder()+ .start("Certificate").raw(signingCertificateXml(certificate)).end("Certificate");+ return Response.ok(AwsQueryResponse.envelope("UploadSigningCertificate",+ AwsNamespaces.IAM, xml.build())).build();+ }++ private Response handleListSigningCertificates(MultivaluedMap<String, String> params,+ String authorization) {+ Page<SigningCertificate> page = paginate(+ iamService.listSigningCertificates(resolveUserName(params, authorization)), params);+ XmlBuilder xml = new XmlBuilder().start("Certificates");+ for (SigningCertificate certificate : page.items()) {+ xml.start("member").raw(signingCertificateXml(certificate)).end("member");+ }+ xml.end("Certificates").elem("IsTruncated", page.truncated());+ if (page.marker() != null) {+ xml.elem("Marker", page.marker());+ }+ return Response.ok(AwsQueryResponse.envelope("ListSigningCertificates",+ AwsNamespaces.IAM, xml.build())).build();+ }++ private Response handleUpdateSigningCertificate(MultivaluedMap<String, String> params,+ String authorization) {+ iamService.updateSigningCertificate(resolveUserName(params, authorization),+ requireParam(params, "CertificateId"), getParam(params, "Status"));+ return Response.ok(AwsQueryResponse.envelopeNoResult("UpdateSigningCertificate",+ AwsNamespaces.IAM)).build();+ }++ private Response handleDeleteSigningCertificate(MultivaluedMap<String, String> params,+ String authorization) {+ iamService.deleteSigningCertificate(resolveUserName(params, authorization),+ requireParam(params, "CertificateId"));+ return Response.ok(AwsQueryResponse.envelopeNoResult("DeleteSigningCertificate",+ AwsNamespaces.IAM)).build();+ }++ /** The four members the model marks required, plus UploadDate. */+ private String signingCertificateXml(SigningCertificate certificate) {+ return new XmlBuilder()+ .elem("UserName", certificate.getUserName())+ .elem("CertificateId", certificate.getCertificateId())+ .elem("CertificateBody", certificate.getCertificateBody())+ .elem("Status", certificate.getStatus())+ .elem("UploadDate", isoDate(certificate.getUploadDate()))+ .build();+ }+private Response handleTagServerCertificate(MultivaluedMap<String, String> params) {iamService.tagServerCertificate(getParam(params, "ServerCertificateName"), extractTags(params, false));return Response.ok(AwsQueryResponse.envelopeNoResult("TagServerCertificate", AwsNamespaces.IAM)).build();diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/IamService.java b/src/main/java/io/github/hectorvent/floci/services/iam/IamService.javaindex c5b3c872f0..a5875b1d35 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@@ -31,6 +31,7 @@ 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.CallerContext;import io.github.hectorvent.floci.services.iam.model.ServerCertificate;+import io.github.hectorvent.floci.services.iam.model.SigningCertificate;import io.github.hectorvent.floci.services.iam.model.SessionCredential;import io.github.hectorvent.floci.services.iam.model.VirtualMfaDevice;import com.fasterxml.jackson.core.type.TypeReference;@@ -44,10 +45,12 @@ import java.nio.charset.StandardCharsets;import java.security.MessageDigest;import java.security.PrivateKey;import java.security.SecureRandom;+import java.security.cert.CertificateEncodingException;import java.security.cert.X509Certificate;import java.time.Duration;import java.time.Instant;import java.time.format.DateTimeFormatter;+import java.util.Arrays;import java.util.Base64;import java.util.Comparator;import java.util.Optional;@@ -143,6 +146,17 @@ public class IamService implements SessionAccountLookup, ResourceProvider {* the maximum it can be raised to, so this is a real ceiling rather than a default.*/private static final int MAX_SERVER_CERTIFICATES = 20;+ /** IAM User Guide quota table, and GetAccountSummary's SigningCertificatesPerUserQuota. */+ private static final int MAX_SIGNING_CERTIFICATES_PER_USER = 2;+ /** certificateIdType is 24 to 128 of [\w]+, so a 32-character id sits inside that. */+ private static final int SIGNING_CERTIFICATE_ID_LENGTH = 32;+ private static final String SIGNING_CERTIFICATE_ACTIVE = "Active";+ /**+ * UpdateSigningCertificate's Status, whose documented valid values are Active, Inactive and+ * Expired. The prose explains only the first two, so the third is easy to reject by mistake.+ */+ private static final Set<String> SIGNING_CERTIFICATE_STATUSES =+ Set.of(SIGNING_CERTIFICATE_ACTIVE, "Inactive", "Expired");/** {@code certificateBodyType} and {@code privateKeyType} are both 1 to 16384 characters. */private static final int MAX_CERTIFICATE_BODY_LENGTH = 16384;/** {@code certificateChainType} is far larger, at 1 to 2097152. */@@ -217,12 +231,14 @@ public class IamService implements SessionAccountLookup, ResourceProvider {private final StorageBackend<String, VirtualMfaDevice> virtualMfaDevices;/** Server certificates, keyed by name, which is unique within the account. */private final StorageBackend<String, ServerCertificate> serverCertificates;+ private final StorageBackend<String, SigningCertificate> signingCertificates;/*** Guards the check-then-write on a server certificate. Upload checks the name is free before* storing, and UpdateServerCertificate checks a new name is free before moving to it, so two* requests racing the same name would otherwise both pass the check.*/private final Object serverCertificateLock = new Object();+ private final Object signingCertificateLock = new Object();/*** Guards every check-then-write on an MFA device. Assignment is the reason it has to exist:* EnableMFADevice reads the device to confirm it is unassigned and reads the user's device@@ -264,6 +280,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {storageFactory.create("iam", "iam-credential-reports.json", new TypeReference<>() {}),storageFactory.create("iam", "iam-virtual-mfa-devices.json", new TypeReference<>() {}),storageFactory.create("iam", "iam-server-certificates.json", new TypeReference<>() {}),+ storageFactory.create("iam", "iam-signing-certificates.json", new TypeReference<>() {}),regionResolver,config.services().iam().seedDeployerPrincipal(),config.services().iam().accountAlias().orElse(null)@@ -294,6 +311,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(),regionResolver, seedDeployerPrincipal, null);}@@ -316,8 +334,8 @@ public class IamService implements SessionAccountLookup, ResourceProvider {this(users, groups, roles, policies, accessKeys, instanceProfiles, sessions,accountAliases, passwordPolicies, new InMemoryStorage<>(), oidcProviders,serviceLinkedRoleDeletions, new InMemoryStorage<>(), new InMemoryStorage<>(),- new InMemoryStorage<>(), new InMemoryStorage<>(), regionResolver,- seedDeployerPrincipal, seededAccountAlias);+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ regionResolver, seedDeployerPrincipal, seededAccountAlias);}// 9-backend constructor (no alias/OIDC/SLR backends): kept for existing callers/tests;@@ -337,6 +355,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {new InMemoryStorage<>(), passwordPolicies, new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), orgRootFeatures,new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(),regionResolver, seedDeployerPrincipal, null);}@@ -356,6 +375,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {StorageBackend<String, CredentialReport> credentialReports,StorageBackend<String, VirtualMfaDevice> virtualMfaDevices,StorageBackend<String, ServerCertificate> serverCertificates,+ StorageBackend<String, SigningCertificate> signingCertificates,RegionResolver regionResolver,boolean seedDeployerPrincipal,String seededAccountAlias) {@@ -375,6 +395,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {this.credentialReports = credentialReports;this.virtualMfaDevices = virtualMfaDevices;this.serverCertificates = serverCertificates;+ this.signingCertificates = signingCertificates;this.regionResolver = regionResolver;this.seedDeployerPrincipal = seedDeployerPrincipal;this.seededAccountAlias = seededAccountAlias;@@ -549,14 +570,22 @@ public class IamService implements SessionAccountLookup, ResourceProvider {throw new AwsException("DeleteConflict","Cannot delete entity, must delete access keys first.", 409);}- // Held across the delete, not just the check: EnableMFADevice confirms the user under this- // same lock, so the two cannot interleave into a device assigned to a deleted user.- synchronized (mfaDeviceLock) {- if (!mfaDevicesForUser(userName).isEmpty()) {+ // Both locks are held across the delete rather than just the checks: UploadSigningCertificate+ // and EnableMFADevice confirm the user under their own lock, so neither can interleave into+ // a credential owned by a deleted user. Taken in this order, and nowhere else in both, so+ // the nesting cannot deadlock.+ synchronized (signingCertificateLock) {+ if (!userSigningCertificates(userName).isEmpty()) {throw new AwsException("DeleteConflict",- "Cannot delete entity, must deactivate MFA device first.", 409);+ "Cannot delete entity, must delete signing certificates first.", 409);+ }+ synchronized (mfaDeviceLock) {+ if (!mfaDevicesForUser(userName).isEmpty()) {+ throw new AwsException("DeleteConflict",+ "Cannot delete entity, must deactivate MFA device first.", 409);+ }+ users.delete(userName);}- users.delete(userName);}LOG.infov("Deleted IAM user: {0}", userName);}@@ -594,22 +623,31 @@ public class IamService implements SessionAccountLookup, ResourceProvider {"User with name " + newUserName + " already exists.", 409);}List<AccessKey> keysToMove = userAccessKeys(userName);- // The rename publishes the user under its new name and moves its MFA devices to- // match. Both happen under the MFA lock, because DeleteUser checks for devices and- // removes the user under that same lock: split across it, a DeleteUser for the new- // name could land after the user is published but before the devices follow, see- // none, and delete a user whose device is about to be reassigned to it.- synchronized (mfaDeviceLock) {- users.delete(userName);- user.setUserName(newUserName);- if (newPath != null) {- user.setPath(normalizePath(newPath));+ // The rename publishes the user under its new name and moves the credentials that+ // DeleteUser refuses to delete a user over: its MFA devices and its signing+ // certificates. Each moves under the lock DeleteUser checks it with, because split+ // across that lock a DeleteUser for the new name could land after the user is+ // published but before the credential follows, see none, and delete a user whose+ // credential is about to be reassigned to it. The two locks are taken in the same+ // order DeleteUser takes them, so the nesting cannot deadlock.+ synchronized (signingCertificateLock) {+ List<SigningCertificate> certificatesToMove = userSigningCertificates(userName);+ synchronized (mfaDeviceLock) {+ users.delete(userName);+ user.setUserName(newUserName);+ if (newPath != null) {+ user.setPath(normalizePath(newPath));+ }+ user.setArn(iamArnBeside(user.getArn(), "user", user.getPath(), newUserName));+ users.put(newUserName, user);+ for (VirtualMfaDevice device : mfaDevicesForUser(userName)) {+ device.setUserName(newUserName);+ virtualMfaDevices.put(device.getSerialNumber(), device);+ }}- user.setArn(iamArnBeside(user.getArn(), "user", user.getPath(), newUserName));- users.put(newUserName, user);- for (VirtualMfaDevice device : mfaDevicesForUser(userName)) {- device.setUserName(newUserName);- virtualMfaDevices.put(device.getSerialNumber(), device);+ for (SigningCertificate certificate : certificatesToMove) {+ certificate.setUserName(newUserName);+ signingCertificates.put(certificate.getCertificateId(), certificate);}}loginProfiles.get(userName).ifPresent(profile -> {@@ -2290,6 +2328,133 @@ public class IamService implements SessionAccountLookup, ResourceProvider {return getServerCertificate(name).getTags();}+ // Signing certificates+ // =========================================================================++ /**+ * Stores an uploaded X.509 signing certificate against a user. The body is really parsed, so a+ * caller cannot store something unusable: the model defines MalformedCertificate on this+ * operation and it cannot be answered without reading the material.+ *+ * <p>Unlike a server certificate there is no private key and no name. The generated+ * {@code CertificateId} is the handle, and its status starts as {@code Active}.+ */+ public SigningCertificate uploadSigningCertificate(String userName, String certificateBody) {+ if (certificateBody == null || certificateBody.isBlank()) {+ throw new AwsException("ValidationError",+ "The request must contain the parameter CertificateBody.", 400);+ }+ checkMaterialLength(certificateBody, "CertificateBody", MAX_CERTIFICATE_BODY_LENGTH);+ X509Certificate parsed = parseUploadedCertificate(certificateBody, "CertificateBody");+ synchronized (signingCertificateLock) {+ // Confirmed under the lock, not before it: DeleteUser checks for certificates holding+ // the same lock, so the two cannot interleave into a certificate owned by a user that+ // no longer exists.+ getUser(userName);+ // Counted inside the lock with the write, so two concurrent uploads cannot both see+ // room for one more.+ if (userSigningCertificates(userName).size() >= MAX_SIGNING_CERTIFICATES_PER_USER) {+ throw new AwsException("LimitExceeded",+ "Cannot exceed quota for SigningCertificatesPerUser: "+ + MAX_SIGNING_CERTIFICATES_PER_USER, 409);+ }+ // The model's DuplicateCertificate is account-wide, not per user: "the same+ // certificate is associated with an IAM user in the account".+ if (storedSigningCertificateMatching(parsed)) {+ throw new AwsException("DuplicateCertificate",+ "The same certificate is associated with an IAM user in the account.", 409);+ }+ SigningCertificate stored = new SigningCertificate();+ stored.setUserName(userName);+ stored.setCertificateId(randomId(SIGNING_CERTIFICATE_ID_LENGTH));+ stored.setCertificateBody(certificateBody);+ stored.setStatus(SIGNING_CERTIFICATE_ACTIVE);+ stored.setUploadDate(Instant.now());+ signingCertificates.put(stored.getCertificateId(), stored);+ LOG.infov("Uploaded signing certificate {0} for user {1}",+ stored.getCertificateId(), userName);+ return stored;+ }+ }++ public List<SigningCertificate> listSigningCertificates(String userName) {+ getUser(userName); // validates existence+ return userSigningCertificates(userName);+ }++ public void updateSigningCertificate(String userName, String certificateId, String status) {+ if (status == null || !SIGNING_CERTIFICATE_STATUSES.contains(status)) {+ throw new AwsException("ValidationError",+ "Value '" + status + "' at 'status' failed to satisfy constraint: Member must "+ + "satisfy enum value set: [" + String.join(", ",+ SIGNING_CERTIFICATE_STATUSES) + "]", 400);+ }+ synchronized (signingCertificateLock) {+ SigningCertificate certificate = userSigningCertificate(userName, certificateId);+ certificate.setStatus(status);+ signingCertificates.put(certificate.getCertificateId(), certificate);+ }+ }++ public void deleteSigningCertificate(String userName, String certificateId) {+ synchronized (signingCertificateLock) {+ SigningCertificate certificate = userSigningCertificate(userName, certificateId);+ signingCertificates.delete(certificate.getCertificateId());+ }+ }++ /**+ * The user's certificate of that id. A certificate belonging to another user is reported as+ * missing rather than as a permission problem, the way an access key of another user is.+ */+ private SigningCertificate userSigningCertificate(String userName, String certificateId) {+ getUser(userName); // validates existence+ SigningCertificate certificate = signingCertificates.get(certificateId)+ .orElseThrow(() -> new AwsException("NoSuchEntity",+ "The Signing Certificate with id " + certificateId+ + " cannot be found.", 404));+ if (!userName.equals(certificate.getUserName())) {+ throw new AwsException("NoSuchEntity",+ "The Signing Certificate with id " + certificateId+ + " cannot be found.", 404);+ }+ return certificate;+ }++ private List<SigningCertificate> userSigningCertificates(String userName) {+ return signingCertificates.scan(key -> true).stream()+ .filter(certificate -> userName.equals(certificate.getUserName()))+ .sorted(Comparator.comparing(SigningCertificate::getCertificateId))+ .toList();+ }++ /**+ * Whether an equivalent certificate is already stored in this account, compared on the encoded+ * form rather than the PEM text so that the same certificate re-wrapped or re-indented still+ * counts as the same one.+ */+ private boolean storedSigningCertificateMatching(X509Certificate candidate) {+ byte[] encoded;+ try {+ encoded = candidate.getEncoded();+ } catch (CertificateEncodingException e) {+ // A certificate that just parsed should always re-encode. Treating it as unique is the+ // safe direction: it refuses nothing the model accepts.+ LOG.debugv("Could not re-encode an uploaded signing certificate: {0}", e.getMessage());+ return false;+ }+ return signingCertificates.scan(key -> true).stream().anyMatch(stored -> {+ try {+ return Arrays.equals(encoded,+ Pem.parseCertificate(stored.getCertificateBody()).getEncoded());+ } catch (CertificateMaterialException | CertificateEncodingException e) {+ LOG.debugv("Skipping unreadable stored signing certificate {0}: {1}",+ stored.getCertificateId(), e.getMessage());+ return false;+ }+ });+ }+// Virtual MFA devices// =========================================================================@@ -3801,6 +3966,9 @@ public class IamService implements SessionAccountLookup, ResourceProvider {List<AccessKey> keys = userAccessKeys(user.getUserName());AccessKey key1 = keys.size() > 0 ? keys.get(0) : null;AccessKey key2 = keys.size() > 1 ? keys.get(1) : null;+ List<SigningCertificate> certificates = userSigningCertificates(user.getUserName());+ SigningCertificate cert1 = certificates.size() > 0 ? certificates.get(0) : null;+ SigningCertificate cert2 = certificates.size() > 1 ? certificates.get(1) : null;Optional<LoginProfile> loginProfile = loginProfiles.get(user.getUserName());boolean passwordEnabled = loginProfile.isPresent();@@ -3815,7 +3983,8 @@ public class IamService implements SessionAccountLookup, ResourceProvider {mfaDevicesForUser(user.getUserName()).isEmpty() ? "FALSE" : "TRUE",accessKeyActiveField(key1), accessKeyRotatedField(key1), "N/A", "N/A", "N/A",accessKeyActiveField(key2), accessKeyRotatedField(key2), "N/A", "N/A", "N/A",- "FALSE", "N/A", "FALSE", "N/A",+ signingCertificateActiveField(cert1), signingCertificateRotatedField(cert1),+ signingCertificateActiveField(cert2), signingCertificateRotatedField(cert2),additionalCredentialsInfoField(keys));}@@ -3853,6 +4022,25 @@ public class IamService implements SessionAccountLookup, ResourceProvider {return profile.getPasswordLastChanged() != null ? profile.getPasswordLastChanged() : profile.getCreateDate();}+ private String signingCertificateActiveField(SigningCertificate certificate) {+ return certificate != null && SIGNING_CERTIFICATE_ACTIVE.equals(certificate.getStatus())+ ? "TRUE" : "FALSE";+ }++ /**+ * The upload date, and {@code N/A} unless the certificate is Active. The User Guide is+ * explicit that this column is N/A when the user "does not have an active signing+ * certificate", so an Inactive certificate reports no date even though one is stored.+ *+ * <p>It describes the date the certificate "was created or last changed". Floci records only+ * the upload, which is the one of those two it can know: a status change rewrites no material.+ */+ private String signingCertificateRotatedField(SigningCertificate certificate) {+ return certificate != null+ && SIGNING_CERTIFICATE_ACTIVE.equals(certificate.getStatus())+ ? isoDate(certificate.getUploadDate()) : "N/A";+ }+private String accessKeyActiveField(AccessKey key) {return key != null && "Active".equals(key.getStatus()) ? "TRUE" : "FALSE";}diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/model/SigningCertificate.java b/src/main/java/io/github/hectorvent/floci/services/iam/model/SigningCertificate.javanew file mode 100644index 0000000000..676582186f--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iam/model/SigningCertificate.java@@ -0,0 +1,38 @@+package io.github.hectorvent.floci.services.iam.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++import java.time.Instant;++/**+ * An IAM X.509 signing certificate, owned by one IAM user. Unlike a server certificate it has no+ * name, no path and no private key: AWS stores only the certificate body, and the generated+ * {@code certificateId} is what every later operation addresses it by.+ *+ * <p>{@code status} is {@code Active} on upload, which is what the model documents.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class SigningCertificate {+ private String userName;+ private String certificateId;+ private String certificateBody;+ private String status = "Active";+ private Instant uploadDate = Instant.now();++ public SigningCertificate() {}++ public String getUserName() { return userName; }+ public void setUserName(String userName) { this.userName = userName; }+ public String getCertificateId() { return certificateId; }+ public void setCertificateId(String certificateId) { this.certificateId = certificateId; }+ public String getCertificateBody() { return certificateBody; }+ public void setCertificateBody(String certificateBody) {+ this.certificateBody = certificateBody;+ }+ public String getStatus() { return status; }+ public void setStatus(String status) { this.status = status; }+ public Instant getUploadDate() { return uploadDate; }+ public void setUploadDate(Instant uploadDate) { this.uploadDate = uploadDate; }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamServicePersistenceTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamServicePersistenceTest.javaindex 3b3b5e7e07..47f2d11385 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamServicePersistenceTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamServicePersistenceTest.java@@ -231,6 +231,7 @@ class IamServicePersistenceTest {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), devices, new InMemoryStorage<>(),+ new InMemoryStorage<>(),new RegionResolver("us-east-1", "000000000000"), false, null);}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 9738060862..69073f685a 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@@ -2305,6 +2305,7 @@ class IamServiceTest {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), credentialReports, new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(),new RegionResolver("us-east-1", "000000000000"), false, null);AwsException ex = assertThrows(AwsException.class, withExpiredReport::getCredentialReport);@@ -2323,6 +2324,7 @@ class IamServiceTest {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), credentialReports, new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(),new RegionResolver("us-east-1", "000000000000"), false, null);IamService.CredentialReportGeneration generation = withExpiredReport.generateCredentialReport();diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/ServerCertificateStateTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/ServerCertificateStateTest.javaindex e249bfe171..57af3db77d 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/ServerCertificateStateTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/ServerCertificateStateTest.java@@ -79,6 +79,7 @@ class ServerCertificateStateTest {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),certificates,+ new InMemoryStorage<>(),new RegionResolver("us-east-1", defaultAccount), false, null);}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/SigningCertificateIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/SigningCertificateIntegrationTest.javanew file mode 100644index 0000000000..b82ed67432--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/SigningCertificateIntegrationTest.java@@ -0,0 +1,367 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.services.acm.CertificateGenerator;+import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.Test;++import java.util.List;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.containsString;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertTrue;++/**+ * The signing-certificate lifecycle over the wire. Material is generated rather than hardcoded, so+ * the upload path reads real X.509 and the rejection paths reject things that genuinely are not.+ *+ * <p>IAM state is shared across the suite, so every test makes its own user. The per-user quota is+ * only two certificates, which is small enough to exercise here without starving anything else:+ * each test owns its user, so it owns that user's whole budget.+ */+@QuarkusTest+class SigningCertificateIntegrationTest {++ private static final String IAM_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260227/us-east-1/iam/aws4_request";+ private static final CertificateGenerator GENERATOR = new CertificateGenerator();++ private static RequestSpecification iam(String action) {+ return given().header("Authorization", IAM_AUTH).formParam("Action", action);+ }++ private static String suffix() {+ return Long.toString(System.nanoTime(), 36);+ }++ /** EC rather than RSA: these tests generate a lot of material and never check the algorithm. */+ private static String certificatePem() {+ return GENERATOR.generateSelfSignedCertificate(+ "signing.test.local", List.of(), KeyAlgorithm.EC_prime256v1).certificatePem();+ }++ private static String user() {+ String name = "signing-user-" + suffix();+ iam("CreateUser").formParam("UserName", name)+ .when().post("/").then().statusCode(200);+ return name;+ }++ private static String upload(String userName, String body) {+ return iam("UploadSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateBody", body)+ .when().post("/").then().statusCode(200)+ .extract().path("UploadSigningCertificateResponse.UploadSigningCertificateResult"+ + ".Certificate.CertificateId");+ }++ @Test+ void uploadReturnsTheCertificateWithAnActiveStatusAndAModelShapedId() {+ String userName = user();+ String body = certificatePem();++ String id = iam("UploadSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateBody", body)+ .when().post("/").then().statusCode(200)+ .body("UploadSigningCertificateResponse.UploadSigningCertificateResult.Certificate"+ + ".UserName", equalTo(userName))+ .body("UploadSigningCertificateResponse.UploadSigningCertificateResult.Certificate"+ + ".Status", equalTo("Active"))+ .body("UploadSigningCertificateResponse.UploadSigningCertificateResult.Certificate"+ + ".CertificateBody", containsString("BEGIN CERTIFICATE"))+ .extract().path("UploadSigningCertificateResponse.UploadSigningCertificateResult"+ + ".Certificate.CertificateId");++ assertNotNull(id);+ // certificateIdType: 24 to 128 characters of [\w]+.+ assertTrue(id.length() >= 24 && id.length() <= 128, "id length: " + id.length());+ assertTrue(id.matches("\\w+"), "id must be word characters only: " + id);+ }++ @Test+ void theUploadDateIsReturned() {+ String userName = user();+ upload(userName, certificatePem());++ iam("ListSigningCertificates").formParam("UserName", userName)+ .when().post("/").then().statusCode(200)+ .body("ListSigningCertificatesResponse.ListSigningCertificatesResult.Certificates"+ + ".member.UploadDate", containsString("T"));+ }++ @Test+ void listReturnsTheUsersCertificatesAndNoOneElses() {+ String mine = user();+ String theirs = user();+ String myId = upload(mine, certificatePem());+ String theirId = upload(theirs, certificatePem());++ iam("ListSigningCertificates").formParam("UserName", mine)+ .when().post("/").then().statusCode(200)+ .body(containsString(myId))+ .body(not(containsString(theirId)));+ }++ @Test+ void theStatusCanBeSetToEveryDocumentedValue() {+ String userName = user();+ String id = upload(userName, certificatePem());++ // The API Reference gives Active, Inactive and Expired as the valid values, even though+ // the prose only explains the first two.+ for (String status : List.of("Inactive", "Expired", "Active")) {+ iam("UpdateSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateId", id)+ .formParam("Status", status)+ .when().post("/").then().statusCode(200);++ iam("ListSigningCertificates").formParam("UserName", userName)+ .when().post("/").then().statusCode(200)+ .body("ListSigningCertificatesResponse.ListSigningCertificatesResult.Certificates"+ + ".member.Status", equalTo(status));+ }+ }++ @Test+ void anUnknownStatusIsRejected() {+ String userName = user();+ String id = upload(userName, certificatePem());++ iam("UpdateSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateId", id)+ .formParam("Status", "Revoked")+ .when().post("/").then().statusCode(400)+ .body(containsString("ValidationError"));+ }++ @Test+ void deleteRemovesIt() {+ String userName = user();+ String id = upload(userName, certificatePem());++ iam("DeleteSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateId", id)+ .when().post("/").then().statusCode(200);++ iam("ListSigningCertificates").formParam("UserName", userName)+ .when().post("/").then().statusCode(200)+ .body(not(containsString(id)));+ }++ @Test+ void malformedMaterialIsRejectedAsMalformedCertificate() {+ String userName = user();++ iam("UploadSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateBody", "-----BEGIN CERTIFICATE-----\nnot base64\n"+ + "-----END CERTIFICATE-----\n")+ .when().post("/").then().statusCode(400)+ .body(containsString("MalformedCertificate"));+ }++ @Test+ void anAbsentBodyIsRejected() {+ String userName = user();++ iam("UploadSigningCertificate").formParam("UserName", userName)+ .when().post("/").then().statusCode(400)+ .body(containsString("ValidationError"));+ }++ /** certificateBodyType caps the body at 16384, which is a request-shape error, not bad PEM. */+ @Test+ void anOverLongBodyIsRejectedBeforeItIsParsed() {+ String userName = user();++ iam("UploadSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateBody", "A".repeat(16385))+ .when().post("/").then().statusCode(400)+ .body(containsString("ValidationError"));+ }++ /** "Users can have up to two X.509 signing certificates", per the User Guide. */+ @Test+ void aThirdCertificateExceedsThePerUserQuota() {+ String userName = user();+ upload(userName, certificatePem());+ upload(userName, certificatePem());++ iam("UploadSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateBody", certificatePem())+ .when().post("/").then().statusCode(409)+ .body(containsString("LimitExceeded"))+ .body(containsString("SigningCertificatesPerUser"));+ }++ /**+ * DuplicateCertificate is account-wide: "the same certificate is associated with an IAM user in+ * the account", so a second user uploading the same material is refused too.+ */+ @Test+ void theSameCertificateCannotBeUploadedTwiceInTheAccount() {+ String first = user();+ String second = user();+ String body = certificatePem();+ upload(first, body);++ iam("UploadSigningCertificate")+ .formParam("UserName", second)+ .formParam("CertificateBody", body)+ .when().post("/").then().statusCode(409)+ .body(containsString("DuplicateCertificate"));+ }++ /**+ * The duplicate check compares the encoded certificate rather than the PEM text, so the same+ * certificate re-wrapped is still the same certificate.+ */+ @Test+ void aReindentedCopyOfTheSameCertificateIsStillADuplicate() {+ String userName = user();+ String body = certificatePem();+ upload(userName, body);++ // Same DER, different surrounding whitespace.+ String reindented = body.replace("\n", "\r\n") + "\n";+ iam("UploadSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateBody", reindented)+ .when().post("/").then().statusCode(409)+ .body(containsString("DuplicateCertificate"));+ }++ @Test+ void aCertificateOfAnotherUserCannotBeUpdatedOrDeleted() {+ String owner = user();+ String other = user();+ String id = upload(owner, certificatePem());++ iam("UpdateSigningCertificate")+ .formParam("UserName", other)+ .formParam("CertificateId", id)+ .formParam("Status", "Inactive")+ .when().post("/").then().statusCode(404)+ .body(containsString("NoSuchEntity"));++ iam("DeleteSigningCertificate")+ .formParam("UserName", other)+ .formParam("CertificateId", id)+ .when().post("/").then().statusCode(404)+ .body(containsString("NoSuchEntity"));+ }++ @Test+ void anUnknownUserIsNoSuchEntity() {+ iam("ListSigningCertificates").formParam("UserName", "absent-" + suffix())+ .when().post("/").then().statusCode(404)+ .body(containsString("NoSuchEntity"));+ }++ /**+ * CertificateId is required on both operations. Omitted, it must be a validation error: the+ * store is a map that rejects a null key, so passing it through would surface as an unhandled+ * failure rather than as the error the model defines.+ */+ @Test+ void anAbsentCertificateIdIsAValidationError() {+ String userName = user();++ iam("DeleteSigningCertificate").formParam("UserName", userName)+ .when().post("/").then().statusCode(400)+ .body(containsString("ValidationError"))+ .body(containsString("certificateId"));++ // Update validates the status first, so this only reaches the lookup with a valid one.+ iam("UpdateSigningCertificate")+ .formParam("UserName", userName)+ .formParam("Status", "Inactive")+ .when().post("/").then().statusCode(400)+ .body(containsString("ValidationError"))+ .body(containsString("certificateId"));+ }++ @Test+ void anUnknownCertificateIdIsNoSuchEntity() {+ String userName = user();++ iam("DeleteSigningCertificate")+ .formParam("UserName", userName)+ .formParam("CertificateId", "ABSENTCERTIFICATEID0000000000")+ .when().post("/").then().statusCode(404)+ .body(containsString("NoSuchEntity"));+ }++ /**+ * UserName is optional on every one of these operations: the model determines it from the+ * access key that signed the request. Signing as the user's own key must reach the user's own+ * certificates without naming them.+ */+ @Test+ void theUserNameIsImpliedFromTheSigningAccessKey() {+ String userName = user();+ String id = upload(userName, certificatePem());+ String akid = iam("CreateAccessKey").formParam("UserName", userName)+ .when().post("/").then().statusCode(200)+ .extract().path("CreateAccessKeyResponse.CreateAccessKeyResult.AccessKey.AccessKeyId");++ given().header("Authorization", "AWS4-HMAC-SHA256 Credential=" + akid+ + "/20260227/us-east-1/iam/aws4_request")+ .formParam("Action", "ListSigningCertificates")+ .when().post("/").then().statusCode(200)+ .body(containsString(id))+ .body("ListSigningCertificatesResponse.ListSigningCertificatesResult.Certificates"+ + ".member.UserName", equalTo(userName));+ }++ @Test+ void listHonoursMaxItemsAndMarker() {+ String userName = user();+ upload(userName, certificatePem());+ upload(userName, certificatePem());++ String marker = iam("ListSigningCertificates")+ .formParam("UserName", userName)+ .formParam("MaxItems", "1")+ .when().post("/").then().statusCode(200)+ .body("ListSigningCertificatesResponse.ListSigningCertificatesResult.IsTruncated",+ equalTo("true"))+ .extract().path("ListSigningCertificatesResponse.ListSigningCertificatesResult.Marker");++ assertNotNull(marker, "a truncated page must carry a marker");+ iam("ListSigningCertificates")+ .formParam("UserName", userName)+ .formParam("Marker", marker)+ .when().post("/").then().statusCode(200)+ .body("ListSigningCertificatesResponse.ListSigningCertificatesResult.IsTruncated",+ equalTo("false"));+ }++ /**+ * Without an Authorization header the Query controller infers the service from the action name+ * alone, so these have to be in its IAM set or they fall through to SQS and come back+ * UnsupportedOperation. The IAM namespace on the error is what proves the routing.+ */+ @Test+ void certificateActionsRouteViaTheActionFallbackWhenAuthHeaderAbsent() {+ for (String action : List.of("UploadSigningCertificate", "ListSigningCertificates",+ "UpdateSigningCertificate", "DeleteSigningCertificate")) {+ given().contentType("application/x-www-form-urlencoded")+ .formParam("Action", action)+ .formParam("Version", "2010-05-08")+ .when().post("/").then()+ .body(containsString("iam.amazonaws.com/doc/2010-05-08"));+ }+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/SigningCertificateStateTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/SigningCertificateStateTest.javanew file mode 100644index 0000000000..cd90a40671--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/SigningCertificateStateTest.java@@ -0,0 +1,417 @@+package io.github.hectorvent.floci.services.iam;++import com.fasterxml.jackson.core.type.TypeReference;+import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.RequestContext;+import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;+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.acm.CertificateGenerator;+import io.github.hectorvent.floci.services.acm.model.KeyAlgorithm;+import io.github.hectorvent.floci.services.iam.model.CredentialReport;+import io.github.hectorvent.floci.services.iam.model.IamUser;+import io.github.hectorvent.floci.services.iam.model.SigningCertificate;+import jakarta.enterprise.inject.Instance;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;++import java.nio.charset.StandardCharsets;+import java.nio.file.Path;+import java.util.ArrayList;+import java.util.Base64;+import java.util.List;+import java.util.concurrent.CountDownLatch;+import java.util.concurrent.ExecutorService;+import java.util.concurrent.Executors;+import java.util.concurrent.TimeUnit;+import java.util.concurrent.atomic.AtomicInteger;+import java.util.concurrent.atomic.AtomicReference;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++/**+ * The properties of the signing-certificate store the wire tests cannot reach: that it survives a+ * restart, that one account cannot see another's, that the quota holds when uploads race, and that+ * the credentials a user owns follow the user through a rename and block a delete.+ */+class SigningCertificateStateTest {++ private static final String ACCOUNT_A = "000000000000";+ private static final String ACCOUNT_B = "111111111111";+ private static final CertificateGenerator GENERATOR = new CertificateGenerator();++ /** EC: these tests exercise locking and storage, never the key algorithm. */+ private static String certificatePem() {+ return GENERATOR.generateSelfSignedCertificate(+ "state.test.local", List.of(), KeyAlgorithm.EC_prime256v1).certificatePem();+ }++ @SuppressWarnings("unchecked")+ private static Instance<RequestContext> requestContextFor(AtomicReference<String> accountId) {+ RequestContext rc = mock(RequestContext.class);+ when(rc.getAccountId()).thenAnswer(invocation -> accountId.get());+ Instance<RequestContext> inst = mock(Instance.class);+ when(inst.get()).thenReturn(rc);+ return inst;+ }++ private static IamService newService(StorageBackend<String, SigningCertificate> certificates,+ String defaultAccount) {+ return new IamService(+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ certificates,+ new RegionResolver("us-east-1", defaultAccount), false, null);+ }++ private static IamService newService(StorageBackend<String, IamUser> users,+ StorageBackend<String, CredentialReport> reports,+ StorageBackend<String, SigningCertificate> certificates,+ String defaultAccount) {+ return new IamService(+ users, new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), reports, new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ certificates,+ new RegionResolver("us-east-1", defaultAccount), false, null);+ }++ @Test+ void aCertificateSurvivesARestart(@TempDir Path dir) {+ Path file = dir.resolve("signing-certificates.json");+ String body = certificatePem();++ PersistentStorage<String, SigningCertificate> first =+ new PersistentStorage<>(file, new TypeReference<>() {});+ first.load();+ IamService before = newService(first, ACCOUNT_A);+ before.createUser("restart-user", "/");+ String id = before.uploadSigningCertificate("restart-user", body).getCertificateId();+ before.updateSigningCertificate("restart-user", id, "Inactive");++ PersistentStorage<String, SigningCertificate> second =+ new PersistentStorage<>(file, new TypeReference<>() {});+ second.load();+ IamService after = newService(second, ACCOUNT_A);+ after.createUser("restart-user", "/");+ List<SigningCertificate> reloaded = after.listSigningCertificates("restart-user");++ assertEquals(1, reloaded.size());+ assertEquals(id, reloaded.getFirst().getCertificateId());+ assertEquals(body, reloaded.getFirst().getCertificateBody());+ // The status is the part most likely to be dropped on the way through, because a default+ // of Active would hide the loss.+ assertEquals("Inactive", reloaded.getFirst().getStatus());+ }++ @Test+ void oneAccountCannotSeeAnothersCertificates() {+ AtomicReference<String> account = new AtomicReference<>(ACCOUNT_A);+ AccountAwareStorageBackend<SigningCertificate> store = new AccountAwareStorageBackend<>(+ new InMemoryStorage<>(), requestContextFor(account), ACCOUNT_A);+ IamService service = newService(store, ACCOUNT_A);++ service.createUser("shared-name", "/");+ service.uploadSigningCertificate("shared-name", certificatePem());+ assertEquals(1, service.listSigningCertificates("shared-name").size());++ // The users store here is not account-aware, so the user is already present under the+ // same name. That is what makes this discriminating: only the certificate store is+ // scoped, so a leak would show up as account B seeing A's certificate.+ account.set(ACCOUNT_B);+ assertEquals(0, service.listSigningCertificates("shared-name").size(),+ "account B must not see account A's certificate");++ // And B filling its own quota must not be refused because A already has certificates.+ service.uploadSigningCertificate("shared-name", certificatePem());+ service.uploadSigningCertificate("shared-name", certificatePem());+ assertEquals(2, service.listSigningCertificates("shared-name").size());++ account.set(ACCOUNT_A);+ assertEquals(1, service.listSigningCertificates("shared-name").size(),+ "account A's view must be unchanged by account B's uploads");+ }++ /**+ * The quota is counted inside the same lock as the write, so concurrent uploads cannot both+ * see room for the second-to-last slot. Asserted by counting what actually succeeded, because+ * an invariant phrased as "the store holds at most two" passes even with the lock removed.+ */+ @Test+ void concurrentUploadsCannotExceedTheQuota() throws Exception {+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A);+ service.createUser("race-user", "/");++ int attempts = 12;+ List<String> bodies = new ArrayList<>();+ for (int i = 0; i < attempts; i++) {+ bodies.add(certificatePem());+ }+ ExecutorService pool = Executors.newFixedThreadPool(attempts);+ CountDownLatch start = new CountDownLatch(1);+ AtomicInteger accepted = new AtomicInteger();+ try {+ for (int i = 0; i < attempts; i++) {+ String body = bodies.get(i);+ pool.submit(() -> {+ start.await();+ try {+ service.uploadSigningCertificate("race-user", body);+ accepted.incrementAndGet();+ } catch (AwsException expected) {+ // LimitExceeded for the losers, which is the point of the race.+ }+ return null;+ });+ }+ start.countDown();+ pool.shutdown();+ assertTrue(pool.awaitTermination(30, TimeUnit.SECONDS), "uploads did not finish");+ } finally {+ pool.shutdownNow();+ }++ assertEquals(2, accepted.get(), "exactly the quota should have been accepted");+ assertEquals(2, service.listSigningCertificates("race-user").size());+ }++ /**+ * The quota race above uses a different certificate per thread, so it never exercises the+ * duplicate check. Uploading the same body from several threads has to leave exactly one+ * stored.+ *+ * <p>This one does not discriminate the lock: with the upload's lock made per-call it still+ * passes, because the first write lands long before the other threads finish parsing the+ * stored material to compare it. The lock is covered by the quota race, which does fail+ * without it. Kept because it pins the outcome rather than the mechanism.+ */+ @Test+ void concurrentUploadsOfTheSameCertificateLeaveExactlyOne() throws Exception {+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A);+ service.createUser("dup-race", "/");+ String body = certificatePem();++ int threads = 8;+ ExecutorService pool = Executors.newFixedThreadPool(threads);+ CountDownLatch start = new CountDownLatch(1);+ AtomicInteger accepted = new AtomicInteger();+ try {+ for (int i = 0; i < threads; i++) {+ pool.submit(() -> {+ start.await();+ try {+ service.uploadSigningCertificate("dup-race", body);+ accepted.incrementAndGet();+ } catch (AwsException expected) {+ // DuplicateCertificate for the losers.+ }+ return null;+ });+ }+ start.countDown();+ pool.shutdown();+ assertTrue(pool.awaitTermination(30, TimeUnit.SECONDS), "uploads did not finish");+ } finally {+ pool.shutdownNow();+ }++ assertEquals(1, accepted.get(), "only one upload of the same certificate may succeed");+ assertEquals(1, service.listSigningCertificates("dup-race").size());+ }++ /**+ * An upload must never land on a user DeleteUser has just removed. Both hold the signing lock,+ * so only two orders exist: the delete is refused because a certificate is there, or the upload+ * fails because the user is gone. A certificate owned by a user that does not exist is the+ * state neither order may produce, and nothing in the API would ever report it: the owner+ * cannot list it, because listing goes through the user.+ *+ * <p>Asserted against the store rather than through the service, for that reason.+ */+ @Test+ void anUploadNeverStrandsACertificateOnADeletedUser() throws Exception {+ for (int trial = 0; trial < 300; trial++) {+ InMemoryStorage<String, SigningCertificate> store = new InMemoryStorage<>();+ IamService service = newService(store, ACCOUNT_A);+ service.createUser("delete-race", "/");+ String body = certificatePem();++ ExecutorService pool = Executors.newFixedThreadPool(2);+ CountDownLatch start = new CountDownLatch(1);+ try {+ pool.submit(() -> {+ start.await();+ try {+ service.uploadSigningCertificate("delete-race", body);+ } catch (AwsException expected) {+ // NoSuchEntity when the delete won.+ }+ return null;+ });+ pool.submit(() -> {+ start.await();+ try {+ service.deleteUser("delete-race");+ } catch (AwsException expected) {+ // DeleteConflict when the upload won.+ }+ return null;+ });+ start.countDown();+ pool.shutdown();+ assertTrue(pool.awaitTermination(30, TimeUnit.SECONDS), "trial did not finish");+ } finally {+ pool.shutdownNow();+ }++ boolean userExists;+ try {+ service.getUser("delete-race");+ userExists = true;+ } catch (AwsException gone) {+ userExists = false;+ }+ List<SigningCertificate> stored = store.scan(key -> true);+ if (!userExists) {+ assertTrue(stored.isEmpty(),+ "trial " + trial + ": certificate left behind on a deleted user");+ }+ }+ }++ /**+ * The same hazard on the rename path: a certificate uploaded while a rename is in flight must+ * end up under whichever name the user actually has, never stranded on the old one.+ */+ @Test+ void anUploadNeverStrandsACertificateOnTheOldNameDuringARename() throws Exception {+ for (int trial = 0; trial < 300; trial++) {+ InMemoryStorage<String, SigningCertificate> store = new InMemoryStorage<>();+ IamService service = newService(store, ACCOUNT_A);+ service.createUser("rename-race-from", "/");+ String body = certificatePem();++ ExecutorService pool = Executors.newFixedThreadPool(2);+ CountDownLatch start = new CountDownLatch(1);+ try {+ pool.submit(() -> {+ start.await();+ try {+ service.uploadSigningCertificate("rename-race-from", body);+ } catch (AwsException expected) {+ // NoSuchEntity when the rename landed first.+ }+ return null;+ });+ pool.submit(() -> {+ start.await();+ service.updateUser("rename-race-from", "rename-race-to", null);+ return null;+ });+ start.countDown();+ pool.shutdown();+ assertTrue(pool.awaitTermination(30, TimeUnit.SECONDS), "trial did not finish");+ } finally {+ pool.shutdownNow();+ }++ for (SigningCertificate certificate : store.scan(key -> true)) {+ assertEquals("rename-race-to", certificate.getUserName(),+ "trial " + trial + ": certificate stranded on the pre-rename name");+ }+ }+ }++ /** AWS lists the signing certificate among the things that must be removed before DeleteUser. */+ @Test+ void aUserWithACertificateCannotBeDeleted() {+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A);+ service.createUser("blocked-user", "/");+ String id = service.uploadSigningCertificate("blocked-user", certificatePem())+ .getCertificateId();++ AwsException refused = assertThrows(AwsException.class,+ () -> service.deleteUser("blocked-user"));+ assertEquals("DeleteConflict", refused.getErrorCode());+ assertTrue(refused.getMessage().contains("signing certificate"),+ "the message should name what is in the way: " + refused.getMessage());++ service.deleteSigningCertificate("blocked-user", id);+ service.deleteUser("blocked-user");+ }++ /**+ * A rename must carry the certificates with it. Left behind, a certificate is stranded on a+ * user name that no longer exists: invisible to its owner and undeletable.+ */+ @Test+ void aRenameCarriesTheCertificates() {+ IamService service = newService(new InMemoryStorage<>(), ACCOUNT_A);+ service.createUser("before-rename", "/");+ String id = service.uploadSigningCertificate("before-rename", certificatePem())+ .getCertificateId();++ service.updateUser("before-rename", "after-rename", null);++ List<SigningCertificate> moved = service.listSigningCertificates("after-rename");+ assertEquals(1, moved.size(), "the certificate should have followed the rename");+ assertEquals(id, moved.getFirst().getCertificateId());+ assertEquals("after-rename", moved.getFirst().getUserName());+ // And the rename must not leave the user undeletable for a certificate it cannot see.+ service.deleteSigningCertificate("after-rename", id);+ service.deleteUser("after-rename");+ }++ /**+ * The credential report's cert columns, which the User Guide defines precisely: TRUE only for+ * an Active certificate, and N/A for the rotation date when the user has no active one.+ */+ @Test+ void theCredentialReportReflectsCertificateStatus() {+ StorageBackend<String, IamUser> users = new InMemoryStorage<>();+ StorageBackend<String, SigningCertificate> certificates = new InMemoryStorage<>();+ IamService service = newService(users, new InMemoryStorage<>(), certificates, ACCOUNT_A);+ service.createUser("report-user", "/");+ String id = service.uploadSigningCertificate("report-user", certificatePem())+ .getCertificateId();++ String active = reportRowFor(service, "report-user");+ assertTrue(active.contains("TRUE"), "an active certificate should report TRUE: " + active);++ service.updateSigningCertificate("report-user", id, "Inactive");+ // GenerateCredentialReport reuses a report generated in the past four hours, so the+ // second row has to come from a service that has not generated one yet.+ IamService regenerated = newService(users, new InMemoryStorage<>(), certificates, ACCOUNT_A);+ String inactive = reportRowFor(regenerated, "report-user");+ String[] columns = inactive.split(",", -1);+ // cert_1_active is FALSE, and cert_1_last_rotated is N/A rather than the upload date:+ // "If the user does not have an active signing certificate, the value in this field is N/A".+ int certActive = columns.length - 5;+ assertEquals("FALSE", columns[certActive], "cert_1_active for an Inactive certificate");+ assertEquals("N/A", columns[certActive + 1],+ "cert_1_last_rotated must be N/A when no active certificate exists");+ }++ private static String reportRowFor(IamService service, String userName) {+ service.generateCredentialReport();+ String csv = new String(Base64.getDecoder()+ .decode(service.getCredentialReport().base64Content()), StandardCharsets.UTF_8);+ return csv.lines()+ .filter(line -> line.startsWith(userName + ","))+ .findFirst()+ .orElseThrow(() -> new AssertionError("no report row for " + userName));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/VirtualMfaAccountScopeTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/VirtualMfaAccountScopeTest.javaindex 36127e6ff2..7c64ddcae2 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/VirtualMfaAccountScopeTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/VirtualMfaAccountScopeTest.java@@ -51,6 +51,7 @@ class VirtualMfaAccountScopeTest {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), devices,new InMemoryStorage<>(),+ new InMemoryStorage<>(),new RegionResolver("us-east-1", ACCOUNT_A), false, null);VirtualMfaDevice device = service.createVirtualMfaDevice("shared-name", "/", Map.of());@@ -89,6 +90,7 @@ class VirtualMfaAccountScopeTest {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), devices,new InMemoryStorage<>(),+ new InMemoryStorage<>(),new RegionResolver("us-east-1", ACCOUNT_A), false, null);VirtualMfaDevice inA = service.createVirtualMfaDevice("same-name", "/", Map.of());diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/VirtualMfaConcurrencyTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/VirtualMfaConcurrencyTest.javaindex 354ef47ba6..c04922818a 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/VirtualMfaConcurrencyTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/VirtualMfaConcurrencyTest.java@@ -38,6 +38,7 @@ class VirtualMfaConcurrencyTest {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(),new RegionResolver("eu-central-1", "000000000000"), false, null);}