Light, fluffy, and always free - The AWS Local Emulator alternative
feat(iam): model account properties and outbound web identity federation (#5177)
Priamo Germosen04a3b9734636
diff --git a/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamAccountPropertiesTest.java b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamAccountPropertiesTest.javanew file mode 100644index 0000000000..803cf65d35--- /dev/null+++ b/compatibility-tests/sdk-test-java/src/test/java/com/floci/test/IamAccountPropertiesTest.java@@ -0,0 +1,156 @@+package com.floci.test;++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.DisableOutboundWebIdentityFederationRequest;+import software.amazon.awssdk.services.iam.model.EnableOutboundWebIdentityFederationRequest;+import software.amazon.awssdk.services.iam.model.FeatureDisabledException;+import software.amazon.awssdk.services.iam.model.FeatureEnabledException;+import software.amazon.awssdk.services.iam.model.GetAccountPropertiesRequest;+import software.amazon.awssdk.services.iam.model.GetAccountPropertiesResponse;+import software.amazon.awssdk.services.iam.model.GetOutboundWebIdentityFederationInfoRequest;+import software.amazon.awssdk.services.iam.model.GetOutboundWebIdentityFederationInfoResponse;+import software.amazon.awssdk.services.iam.model.GlobalEndpointTokenVersion;+import software.amazon.awssdk.services.iam.model.PutAccountPropertiesRequest;+import software.amazon.awssdk.services.iam.model.SetSecurityTokenServicePreferencesRequest;++import java.util.LinkedHashMap;+import java.util.Map;++import static org.assertj.core.api.Assertions.assertThat;+import static org.assertj.core.api.Assertions.assertThatThrownBy;++/**+ * The account property and outbound federation operations 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 mis-named element or a map serialised in the wrong shape fails here+ * even though the raw XML looked right. The {@code Properties} map is the interesting one, since it+ * travels as {@code Properties.entry.N.key} and {@code Properties.entry.N.value} in both+ * directions.+ *+ * <p>It also pins the error codes: the SDK maps {@code FeatureEnabled} and {@code FeatureDisabled}+ * onto typed exceptions, so emitting the wrong code would arrive as a plain {@code IamException}.+ */+@DisplayName("IAM Account Properties and Outbound Federation")+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+class IamAccountPropertiesTest {++ private static final String NAMESPACE = "SdkTestNs";++ private static IamClient iam() {+ return TestFixtures.iamClient();+ }++ @Test+ @Order(1)+ @DisplayName("PutAccountProperties and GetAccountProperties round-trip the map")+ void propertiesRoundTrip() {+ Map<String, String> properties = new LinkedHashMap<>();+ properties.put(NAMESPACE + "/Enabled", "true");+ properties.put(NAMESPACE + "/Mode", "strict");++ iam().putAccountProperties(PutAccountPropertiesRequest.builder()+ .properties(properties)+ .build());++ GetAccountPropertiesResponse response = iam().getAccountProperties(+ GetAccountPropertiesRequest.builder().build());++ assertThat(response.hasProperties()).isTrue();+ assertThat(response.properties())+ .containsEntry(NAMESPACE + "/Enabled", "true")+ .containsEntry(NAMESPACE + "/Mode", "strict");+ }++ @Test+ @Order(2)+ @DisplayName("All keys in one request must share a namespace")+ void mixedNamespacesAreRejected() {+ Map<String, String> properties = new LinkedHashMap<>();+ properties.put(NAMESPACE + "/Alpha", "1");+ properties.put("OtherSdkNs/Beta", "2");++ assertThatThrownBy(() -> iam().putAccountProperties(PutAccountPropertiesRequest.builder()+ .properties(properties)+ .build()))+ .hasMessageContaining("same namespace");+ }++ @Test+ @Order(3)+ @DisplayName("SetSecurityTokenServicePreferences takes the version as a typed enum")+ void setTokenVersion() {+ iam().setSecurityTokenServicePreferences(+ SetSecurityTokenServicePreferencesRequest.builder()+ .globalEndpointTokenVersion(GlobalEndpointTokenVersion.V2_TOKEN)+ .build());++ // No getter for it in the API, so the assertion is that the SDK round-tripped the enum+ // without the service rejecting it.+ iam().setSecurityTokenServicePreferences(+ SetSecurityTokenServicePreferencesRequest.builder()+ .globalEndpointTokenVersion(GlobalEndpointTokenVersion.V1_TOKEN)+ .build());+ }++ /**+ * The whole switch in one test, because it is one account-level flag and separate tests would+ * race each other. The asymmetry is the point: enabling twice is FeatureEnabled, disabling+ * twice is FeatureDisabled.+ */+ @Test+ @Order(4)+ @DisplayName("Outbound federation refuses both redundant directions, with typed errors")+ void federationSwitch() {+ IamClient client = iam();+ // Start from a known state, however an earlier run left it.+ try {+ client.disableOutboundWebIdentityFederation(+ DisableOutboundWebIdentityFederationRequest.builder().build());+ } catch (FeatureDisabledException expected) {+ // already disabled, which is the state this test wants+ }++ assertThatThrownBy(() -> client.getOutboundWebIdentityFederationInfo(+ GetOutboundWebIdentityFederationInfoRequest.builder().build()))+ .isInstanceOf(FeatureDisabledException.class);++ String issuer = client.enableOutboundWebIdentityFederation(+ EnableOutboundWebIdentityFederationRequest.builder().build())+ .issuerIdentifier();+ assertThat(issuer)+ .as("the issuer is a per-account host under tokens.sts.global")+ .matches("https://[0-9a-f-]{36}\\.tokens\\.sts\\.global\\..+");++ assertThatThrownBy(() -> client.enableOutboundWebIdentityFederation(+ EnableOutboundWebIdentityFederationRequest.builder().build()))+ .isInstanceOf(FeatureEnabledException.class);++ GetOutboundWebIdentityFederationInfoResponse info =+ client.getOutboundWebIdentityFederationInfo(+ GetOutboundWebIdentityFederationInfoRequest.builder().build());+ assertThat(info.issuerIdentifier()).isEqualTo(issuer);+ assertThat(info.jwtVendingEnabled()).isTrue();++ client.disableOutboundWebIdentityFederation(+ DisableOutboundWebIdentityFederationRequest.builder().build());+ assertThatThrownBy(() -> client.disableOutboundWebIdentityFederation(+ DisableOutboundWebIdentityFederationRequest.builder().build()))+ .isInstanceOf(FeatureDisabledException.class);++ // Re-enabling returns the same issuer: a relying party has pinned it.+ String reissued = client.enableOutboundWebIdentityFederation(+ EnableOutboundWebIdentityFederationRequest.builder().build())+ .issuerIdentifier();+ assertThat(reissued).isEqualTo(issuer);++ client.disableOutboundWebIdentityFederation(+ DisableOutboundWebIdentityFederationRequest.builder().build());+ }+}diff --git a/docs/services/iam.md b/docs/services/iam.mdindex f276e9d24f..4f017efbdd 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -531,6 +531,52 @@ ready. `GenerateCredentialReport`'s `State`/`Description` for the no-report-exisown documented example response (`STARTED` / "No report exists. Starting a new report generationtask"); the wording for the report-expired case is Floci's own, since AWS does not document it.+### Account Properties and Outbound Federation++| Action | Description |+|--------|-------------|+| GetAccountProperties | Returns the account's properties as a `Namespace/PropertyName` to value map. |+| PutAccountProperties | Sets account properties, all of which must share one namespace. |+| SetSecurityTokenServicePreferences | Sets the account's global endpoint token version, `v1Token` or `v2Token`. |+| EnableOutboundWebIdentityFederation | Turns on outbound web identity federation and returns the account's issuer URL. |+| DisableOutboundWebIdentityFederation | Turns it off. |+| GetOutboundWebIdentityFederationInfo | Returns the issuer URL and whether JWT vending is on. |++A property key is `Namespace/PropertyName` with exactly one forward slash and neither a leading nor+a trailing one, 1 to 50 characters matching `^[A-Za-z][A-Za-z0-9/_-]*$`, and a value of 1 to 1024.+**Every key in one `PutAccountProperties` request must belong to the same namespace**, which AWS+states directly, so a request mixing namespaces is rejected whole rather than partly applied. Role+Manager is the only namespace AWS names, and any well-formed key is accepted rather than only that+one, since an allowlist of one would refuse keys AWS takes.++**Enabling federation twice is an error, and so is disabling it twice**, which is the asymmetry+worth noticing: `EnableOutboundWebIdentityFederation` answers `FeatureEnabled` with status 409,+while `DisableOutboundWebIdentityFederation` answers `FeatureDisabled` with status **404**. AWS+documents both, including the message wording. `GetOutboundWebIdentityFederationInfo` answers+`FeatureDisabled` too when the feature is off, reusing the disable operation's own text, so a getter+reports that the feature cannot be disabled twice. That reads oddly and is matched rather than+improved.++The issuer URL is `https://<uuid>.tokens.sts.global.<dual-stack suffix>`, which the API Reference+shows as `https://a1d2b0fd-1177-4468-9351-2fEXAMPLE723.tokens.sts.global.api.aws`. The suffix comes+from the request's partition rather than the literal, since `api.aws` is only the commercial+partition's. It is minted once per account and kept across a disable, so re-enabling returns the+same URL. AWS does not document which way that goes; the reasoning is that a relying party+verifying tokens will have pinned the URL, so regenerating it would break verification silently.++Two things the feature references are not modeled. The issuer URL is documented as hosting OIDC+discovery endpoints at `/.well-known/openid-configuration` and `/.well-known/jwks.json`, and the+operation's description points at a `GetWebIdentityToken` API for obtaining JWTs. Neither is served+here: these six are the management operations only. `JwtVendingEnabled` is therefore reported as+true whenever the feature is enabled, which is the only reading available, since nothing in the API+toggles it separately.++`SetSecurityTokenServicePreferences` stores the version, and `GetAccountSummary` reports it as+`GlobalEndpointTokenVersion`, which the operation's own description requires. What does not follow+it is STS itself: Floci does not vary its token format by account preference, so the setting is+observable in the summary rather than in a token. `v1Token` is reported as the default for an account+that has never set one.+### Organizations Root Access| Action | Description |diff --git a/docs/services/index.md b/docs/services/index.mdindex bbd98874c8..52d5a11d14 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -22,7 +22,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [Lambda MicroVMs](lambda-microvms.md) | `/2025-09-09/...` + `/2026-04-04/...` | REST JSON | 22 || [API Gateway v1](api-gateway.md) | `/restapis/...` | REST JSON | 79 || [API Gateway v2](api-gateway.md#v2) | `/v2/apis/...` | REST JSON | 53 + data-plane |-| [IAM](iam.md) | `POST /` with `Action=` param | Query | 158 |+| [IAM](iam.md) | `POST /` with `Action=` param | Query | 164 || [STS](sts.md) | `POST /` with `Action=` param | Query | 7 || [AWS Sign-In](iam.md#aws-sign-in-login-credentials) | `/v1/authorize`, `/v1/token` | REST JSON | 2 || [Organizations](organizations.md) | `POST /` + `X-Amz-Target: AWSOrganizationsV20161128.*` | JSON 1.1 | 56 |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 779675ca6e..a9717a0fcc 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@@ -119,6 +119,9 @@ public class AwsQueryController {"CreateVirtualMFADevice", "DeleteVirtualMFADevice", "ListVirtualMFADevices","EnableMFADevice", "DeactivateMFADevice", "ResyncMFADevice", "ListMFADevices","TagMFADevice", "UntagMFADevice", "ListMFADeviceTags",+ "GetAccountProperties", "PutAccountProperties",+ "SetSecurityTokenServicePreferences", "EnableOutboundWebIdentityFederation",+ "DisableOutboundWebIdentityFederation", "GetOutboundWebIdentityFederationInfo","CreateServiceSpecificCredential", "ListServiceSpecificCredentials","UpdateServiceSpecificCredential", "ResetServiceSpecificCredential","DeleteServiceSpecificCredential",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 dad337f7ba..aaad4419a5 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@@ -12,6 +12,7 @@ import io.github.hectorvent.floci.services.iam.model.IamUser;import io.github.hectorvent.floci.services.iam.model.InstanceProfile;import io.github.hectorvent.floci.services.iam.model.LoginProfile;import io.github.hectorvent.floci.services.iam.model.OpenIDConnectProvider;+import io.github.hectorvent.floci.services.iam.model.OutboundWebIdentityFederation;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;@@ -205,6 +206,16 @@ public class IamQueryHandler {case "ListPolicies" -> handleListPolicies(params);case "ListEntitiesForPolicy" -> handleListEntitiesForPolicy(params);case "GetAccountSummary" -> handleGetAccountSummary(params);+ case "GetAccountProperties" -> handleGetAccountProperties(params);+ case "PutAccountProperties" -> handlePutAccountProperties(params);+ case "SetSecurityTokenServicePreferences" ->+ handleSetSecurityTokenServicePreferences(params);+ case "EnableOutboundWebIdentityFederation" ->+ handleEnableOutboundWebIdentityFederation(params);+ case "DisableOutboundWebIdentityFederation" ->+ handleDisableOutboundWebIdentityFederation(params);+ case "GetOutboundWebIdentityFederationInfo" ->+ handleGetOutboundWebIdentityFederationInfo(params);case "GetAccountAuthorizationDetails" -> handleGetAccountAuthorizationDetails(params);case "GenerateCredentialReport" -> handleGenerateCredentialReport(params);case "GetCredentialReport" -> handleGetCredentialReport(params);@@ -1432,6 +1443,69 @@ public class IamQueryHandler {return Response.ok(AwsQueryResponse.envelope("GetAccountSummary", AwsNamespaces.IAM, xml.build())).build();}+ private Response handleGetAccountProperties(MultivaluedMap<String, String> params) {+ XmlBuilder xml = new XmlBuilder().start("Properties");+ for (Map.Entry<String, String> entry : iamService.getAccountProperties().entrySet()) {+ xml.start("entry").elem("key", entry.getKey())+ .elem("value", entry.getValue()).end("entry");+ }+ xml.end("Properties");+ return Response.ok(AwsQueryResponse.envelope("GetAccountProperties",+ AwsNamespaces.IAM, xml.build())).build();+ }++ /**+ * The Properties map arrives as {@code Properties.entry.N.key} and+ * {@code Properties.entry.N.value}, which is how the API Reference spells the member.+ */+ private Response handlePutAccountProperties(MultivaluedMap<String, String> params) {+ Map<String, String> properties = new LinkedHashMap<>();+ for (int i = 1; ; i++) {+ String key = getParam(params, "Properties.entry." + i + ".key");+ if (key == null) {+ break;+ }+ properties.put(key, getParam(params, "Properties.entry." + i + ".value"));+ }+ iamService.putAccountProperties(properties);+ return Response.ok(AwsQueryResponse.envelopeNoResult("PutAccountProperties",+ AwsNamespaces.IAM)).build();+ }++ private Response handleSetSecurityTokenServicePreferences(+ MultivaluedMap<String, String> params) {+ iamService.setSecurityTokenServicePreferences(+ requireParam(params, "GlobalEndpointTokenVersion"));+ return Response.ok(AwsQueryResponse.envelopeNoResult("SetSecurityTokenServicePreferences",+ AwsNamespaces.IAM)).build();+ }++ private Response handleEnableOutboundWebIdentityFederation(+ MultivaluedMap<String, String> params) {+ XmlBuilder xml = new XmlBuilder()+ .elem("IssuerIdentifier", iamService.enableOutboundWebIdentityFederation());+ return Response.ok(AwsQueryResponse.envelope("EnableOutboundWebIdentityFederation",+ AwsNamespaces.IAM, xml.build())).build();+ }++ private Response handleDisableOutboundWebIdentityFederation(+ MultivaluedMap<String, String> params) {+ iamService.disableOutboundWebIdentityFederation();+ return Response.ok(AwsQueryResponse.envelopeNoResult(+ "DisableOutboundWebIdentityFederation", AwsNamespaces.IAM)).build();+ }++ private Response handleGetOutboundWebIdentityFederationInfo(+ MultivaluedMap<String, String> params) {+ OutboundWebIdentityFederation state = iamService.getOutboundWebIdentityFederationInfo();+ XmlBuilder xml = new XmlBuilder()+ .elem("IssuerIdentifier", state.getIssuerIdentifier())+ // Vending is on whenever the feature is: nothing in the API toggles it apart.+ .elem("JwtVendingEnabled", true);+ return Response.ok(AwsQueryResponse.envelope("GetOutboundWebIdentityFederationInfo",+ AwsNamespaces.IAM, xml.build())).build();+ }+private Response handleGenerateCredentialReport(MultivaluedMap<String, String> params) {IamService.CredentialReportGeneration generation = iamService.generateCredentialReport();// State before Description: GenerateCredentialReportResponse's member order in thediff --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 e05a10f563..a39d91e555 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@@ -9,7 +9,9 @@ import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.AwsPartition;import io.github.hectorvent.floci.core.common.AwsPartitions;+import io.github.hectorvent.floci.core.common.AwsRegions;import io.github.hectorvent.floci.core.common.CertificateMaterialException;import io.github.hectorvent.floci.core.common.Pem;import io.github.hectorvent.floci.core.common.RegionResolver;@@ -37,6 +39,7 @@ import io.github.hectorvent.floci.services.iam.model.InstanceProfile;import io.github.hectorvent.floci.services.iam.model.LoginProfile;import io.github.hectorvent.floci.services.iam.model.OpenIDConnectProvider;import io.github.hectorvent.floci.services.iam.model.OrganizationRootFeatures;+import io.github.hectorvent.floci.services.iam.model.OutboundWebIdentityFederation;import io.github.hectorvent.floci.services.iam.model.PolicyVersion;import io.github.hectorvent.floci.services.iam.model.ServerCertificate;import io.github.hectorvent.floci.services.iam.model.ServiceSpecificCredential;@@ -121,6 +124,15 @@ public class IamService implements SessionAccountLookup, ResourceProvider {private static final int MAX_OIDC_THUMBPRINTS = 5;private static final int MAX_OIDC_URL_LENGTH = 255;private static final String ACCOUNT_PASSWORD_POLICY_KEY = "account-password-policy";+ private static final String STS_PREFERENCES_KEY = "sts-preferences";+ private static final String OUTBOUND_FEDERATION_KEY = "outbound-web-identity-federation";+ /** accountPropertiesMapType's key: 1 to 50 of this, and a value of 1 to 1024. */+ private static final Pattern ACCOUNT_PROPERTY_KEY_PATTERN =+ Pattern.compile("^[A-Za-z][A-Za-z0-9/_-]*$");+ private static final int MAX_ACCOUNT_PROPERTY_KEY_LENGTH = 50;+ private static final int MAX_ACCOUNT_PROPERTY_VALUE_LENGTH = 1024;+ /** globalEndpointTokenVersion's only two values. */+ private static final Set<String> GLOBAL_ENDPOINT_TOKEN_VERSIONS = Set.of("v1Token", "v2Token");/** AWS-documented bounds for the account password policy's numeric fields. */private static final int MIN_PASSWORD_LENGTH_FLOOR = 6;private static final int MIN_PASSWORD_LENGTH_CEILING = 128;@@ -297,6 +309,36 @@ public class IamService implements SessionAccountLookup, ResourceProvider {* single-value-per-account shape as {@link #accountAliases}.*/private final StorageBackend<String, AccountPasswordPolicy> passwordPolicies;+ /**+ * One entry per account property, keyed by the property key AWS defines+ * ({@code Namespace/PropertyName}). Keyed per property rather than one entry holding a map,+ * because PutAccountProperties sets a subset while GetAccountProperties returns all of them,+ * which a key-per-entry store does without a read-modify-write.+ */+ private final StorageBackend<String, String> accountProperties;+ /**+ * Guards the batch in PutAccountProperties. A request carries several keys and AWS models+ * ConcurrentModification for it, so the keys land together rather than interleaved with+ * another request's.+ */+ private final Object accountPropertiesLock = new Object();+ /**+ * Holds at most one entry per account under {@link #STS_PREFERENCES_KEY}, the value being the+ * global endpoint token version. Same single-value-per-account shape as+ * {@link #accountAliases}.+ */+ private final StorageBackend<String, String> stsPreferences;+ /**+ * Holds at most one entry per account under {@link #OUTBOUND_FEDERATION_KEY}, present once the+ * feature has ever been enabled.+ */+ private final StorageBackend<String, OutboundWebIdentityFederation> outboundFederation;+ /**+ * Guards the check-then-act in enable and disable. Both answer an error when the feature is+ * already in the state asked for, so two racing enables must not both mint an issuer and both+ * report success.+ */+ private final Object outboundFederationLock = new Object();private final StorageBackend<String, LoginProfile> loginProfiles;private final StorageBackend<String, OpenIDConnectProvider> oidcProviders;/** Deletion is synchronous, so an issued task id is a completed one; the value is its role. */@@ -368,6 +410,9 @@ public class IamService implements SessionAccountLookup, ResourceProvider {storageFactory.create("iam", "iam-signing-certificates.json", new TypeReference<>() {}),storageFactory.create("iam", "iam-ssh-public-keys.json", new TypeReference<>() {}),storageFactory.create("iam", "iam-service-specific-credentials.json", new TypeReference<>() {}),+ storageFactory.create("iam", "iam-account-properties.json", new TypeReference<>() {}),+ storageFactory.create("iam", "iam-sts-preferences.json", new TypeReference<>() {}),+ storageFactory.create("iam", "iam-outbound-federation.json", new TypeReference<>() {}),regionResolver,config.services().iam().seedDeployerPrincipal(),config.services().iam().accountAlias().orElse(null)@@ -401,6 +446,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),regionResolver, seedDeployerPrincipal, null);}@@ -426,6 +472,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),regionResolver, seedDeployerPrincipal, seededAccountAlias);}@@ -449,6 +496,7 @@ public class IamService implements SessionAccountLookup, ResourceProvider {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),regionResolver, seedDeployerPrincipal, null);}@@ -471,6 +519,9 @@ public class IamService implements SessionAccountLookup, ResourceProvider {StorageBackend<String, SigningCertificate> signingCertificates,StorageBackend<String, SshPublicKey> sshPublicKeys,StorageBackend<String, ServiceSpecificCredential> serviceCredentials,+ StorageBackend<String, String> accountProperties,+ StorageBackend<String, String> stsPreferences,+ StorageBackend<String, OutboundWebIdentityFederation> outboundFederation,RegionResolver regionResolver,boolean seedDeployerPrincipal,String seededAccountAlias) {@@ -493,6 +544,9 @@ public class IamService implements SessionAccountLookup, ResourceProvider {this.signingCertificates = signingCertificates;this.sshPublicKeys = sshPublicKeys;this.serviceCredentials = serviceCredentials;+ this.accountProperties = accountProperties;+ this.stsPreferences = stsPreferences;+ this.outboundFederation = outboundFederation;this.regionResolver = regionResolver;this.seedDeployerPrincipal = seedDeployerPrincipal;this.seededAccountAlias = seededAccountAlias;@@ -1461,8 +1515,14 @@ public class IamService implements SessionAccountLookup, ResourceProvider {summary.put("AccountPasswordPresent", 0L);// The STS global endpoint (and so the v1/v2 token choice it reports) exists only where// the partition publishes one: aws today. Elsewhere AWS has no such entry to report.+ //+ // The value follows SetSecurityTokenServicePreferences, whose own description says the+ // version it sets "is reported in the GlobalEndpointTokenVersion entry of the response of+ // the GetAccountSummary operation". Reporting a constant would leave a caller that set+ // v2Token reading back 1.if (AwsPartitions.byId(regionResolver.getPartition()).hasGlobalSts()) {- summary.put("GlobalEndpointTokenVersion", 1L);+ summary.put("GlobalEndpointTokenVersion",+ "v2Token".equals(getGlobalEndpointTokenVersion()) ? 2L : 1L);}return summary;}@@ -2227,6 +2287,176 @@ public class IamService implements SessionAccountLookup, ResourceProvider {}}+ // Account properties and outbound web identity federation+ // =========================================================================++ /** Every account property, as GetAccountProperties returns them. */+ public Map<String, String> getAccountProperties() {+ Map<String, String> properties = new LinkedHashMap<>();+ for (String key : accountProperties.keys()) {+ accountProperties.get(key).ifPresent(value -> properties.put(key, value));+ }+ return properties;+ }++ /**+ * Sets account properties, all of which must be in one namespace.+ *+ * <p>The key is {@code Namespace/PropertyName}: AWS requires exactly one {@code /}, forbids a+ * leading or trailing one, and states that "all keys must belong to the same namespace". A+ * request mixing namespaces is rejected whole rather than partly applied.+ */+ public void putAccountProperties(Map<String, String> properties) {+ if (properties == null || properties.isEmpty()) {+ throw new AwsException("ValidationError",+ "Value null at 'properties' failed to satisfy constraint: Member must not be "+ + "null", 400);+ }+ String namespace = null;+ for (Map.Entry<String, String> entry : properties.entrySet()) {+ String keyNamespace = validateAccountPropertyKey(entry.getKey());+ validateAccountPropertyValue(entry.getKey(), entry.getValue());+ if (namespace == null) {+ namespace = keyNamespace;+ } else if (!namespace.equals(keyNamespace)) {+ throw new AwsException("InvalidInput",+ "All property keys must belong to the same namespace, but the request "+ + "names both " + namespace + " and " + keyNamespace + ".", 400);+ }+ }+ synchronized (accountPropertiesLock) {+ for (Map.Entry<String, String> entry : properties.entrySet()) {+ accountProperties.put(entry.getKey(), entry.getValue());+ }+ }+ LOG.infov("Set {0} account property/properties in namespace {1}",+ properties.size(), namespace);+ }++ /** The namespace half of the key, having checked the whole key against the model. */+ private String validateAccountPropertyKey(String key) {+ if (key == null || key.isEmpty() || key.length() > MAX_ACCOUNT_PROPERTY_KEY_LENGTH+ || !ACCOUNT_PROPERTY_KEY_PATTERN.matcher(key).matches()) {+ throw new AwsException("InvalidInput",+ "Value '" + key + "' at 'properties' failed to satisfy constraint: Map keys "+ + "must satisfy constraint: [Member must have length less than or "+ + "equal to " + MAX_ACCOUNT_PROPERTY_KEY_LENGTH + ", Member must "+ + "satisfy regular expression pattern: "+ + ACCOUNT_PROPERTY_KEY_PATTERN.pattern() + "]", 400);+ }+ int separator = key.indexOf('/');+ if (separator <= 0 || separator != key.lastIndexOf('/') || separator == key.length() - 1) {+ throw new AwsException("InvalidInput",+ "Value '" + key + "' at 'properties' failed to satisfy constraint: a key is "+ + "Namespace/PropertyName, with exactly one forward slash and neither "+ + "a leading nor a trailing one.", 400);+ }+ return key.substring(0, separator);+ }++ private void validateAccountPropertyValue(String key, String value) {+ if (value == null || value.isEmpty()+ || value.length() > MAX_ACCOUNT_PROPERTY_VALUE_LENGTH) {+ throw new AwsException("InvalidInput",+ "Value at 'properties." + key + "' failed to satisfy constraint: Member must "+ + "have length between 1 and " + MAX_ACCOUNT_PROPERTY_VALUE_LENGTH,+ 400);+ }+ }++ /** The account's global endpoint token version, {@code v1Token} or {@code v2Token}. */+ public void setSecurityTokenServicePreferences(String globalEndpointTokenVersion) {+ if (globalEndpointTokenVersion == null+ || !GLOBAL_ENDPOINT_TOKEN_VERSIONS.contains(globalEndpointTokenVersion)) {+ throw new AwsException("ValidationError",+ "Value '" + globalEndpointTokenVersion + "' at 'globalEndpointTokenVersion' "+ + "failed to satisfy constraint: Member must satisfy enum value set: ["+ + String.join(", ", GLOBAL_ENDPOINT_TOKEN_VERSIONS) + "]", 400);+ }+ stsPreferences.put(STS_PREFERENCES_KEY, globalEndpointTokenVersion);+ LOG.infov("Set the global endpoint token version to {0}", globalEndpointTokenVersion);+ }++ /** The stored token version, which AWS defaults to {@code v1Token} for an existing account. */+ public String getGlobalEndpointTokenVersion() {+ return stsPreferences.get(STS_PREFERENCES_KEY).orElse("v1Token");+ }++ /**+ * Turns on outbound web identity federation and returns the account's issuer URL. Enabling an+ * already-enabled account is {@code FeatureEnabled}, which AWS states directly: "You cannot+ * enable the feature multiple times."+ *+ * <p>The issuer is minted once and kept across a disable, so re-enabling returns the same URL.+ * See {@link OutboundWebIdentityFederation} for why.+ */+ public String enableOutboundWebIdentityFederation() {+ synchronized (outboundFederationLock) {+ OutboundWebIdentityFederation state =+ outboundFederation.get(OUTBOUND_FEDERATION_KEY).orElse(null);+ if (state != null && state.isEnabled()) {+ throw new AwsException("FeatureEnabled",+ "Outbound identity federation is already enabled for your AWS account. "+ + "You cannot enable the feature multiple times.", 409);+ }+ if (state == null) {+ state = new OutboundWebIdentityFederation();+ state.setIssuerIdentifier(mintIssuerIdentifier());+ }+ state.setEnabled(true);+ outboundFederation.put(OUTBOUND_FEDERATION_KEY, state);+ LOG.infov("Enabled outbound web identity federation with issuer {0}",+ state.getIssuerIdentifier());+ return state.getIssuerIdentifier();+ }+ }++ /** Turns it off. Disabling an already-disabled account is {@code FeatureDisabled}. */+ public void disableOutboundWebIdentityFederation() {+ synchronized (outboundFederationLock) {+ OutboundWebIdentityFederation state = enabledOutboundFederation();+ state.setEnabled(false);+ outboundFederation.put(OUTBOUND_FEDERATION_KEY, state);+ LOG.info("Disabled outbound web identity federation");+ }+ }++ /** The issuer URL and whether JWT vending is on, which it is while the feature is enabled. */+ public OutboundWebIdentityFederation getOutboundWebIdentityFederationInfo() {+ synchronized (outboundFederationLock) {+ return enabledOutboundFederation();+ }+ }++ /**+ * The federation state, or {@code FeatureDisabled} when the feature is off. AWS answers the+ * getter with the disable operation's own wording, so a getter reports that the feature cannot+ * be disabled twice. Matched rather than improved.+ */+ private OutboundWebIdentityFederation enabledOutboundFederation() {+ OutboundWebIdentityFederation state =+ outboundFederation.get(OUTBOUND_FEDERATION_KEY).orElse(null);+ if (state == null || !state.isEnabled()) {+ throw new AwsException("FeatureDisabled",+ "Outbound identity federation is already disabled for your AWS account. You "+ + "cannot disable the feature multiple times", 404);+ }+ return state;+ }++ /**+ * The issuer URL AWS mints for an account: a per-account host under+ * {@code tokens.sts.global.<dual-stack suffix>}, which the API Reference shows as+ * {@code https://<uuid>.tokens.sts.global.api.aws}. The suffix comes from the request's+ * partition rather than the literal, since {@code api.aws} is only the commercial one.+ */+ private String mintIssuerIdentifier() {+ String suffix = AwsPartitions.find(regionResolver.getPartition())+ .map(AwsPartition::dualStackDnsSuffix)+ .orElseGet(() -> AwsRegions.dnsSuffixFor(regionResolver.getDefaultRegion()));+ return "https://" + UUID.randomUUID() + ".tokens.sts.global." + suffix;+ }+// Server certificates// =========================================================================diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/model/OutboundWebIdentityFederation.java b/src/main/java/io/github/hectorvent/floci/services/iam/model/OutboundWebIdentityFederation.javanew file mode 100644index 0000000000..6e63740e41--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iam/model/OutboundWebIdentityFederation.java@@ -0,0 +1,31 @@+package io.github.hectorvent.floci.services.iam.model;++import com.fasterxml.jackson.annotation.JsonIgnoreProperties;+import io.quarkus.runtime.annotations.RegisterForReflection;++/**+ * The account's outbound web identity federation state: whether the feature is on, and the issuer+ * URL minted for the account.+ *+ * <p>One of these exists per account once the feature has ever been enabled, and {@code enabled}+ * then toggles. The entry outliving a disable is deliberate: AWS describes the issuer as "a unique+ * issuer URL for your AWS account", and a relying party verifying tokens will have pinned it, so+ * re-enabling mints nothing new. AWS does not document which way that goes, so this is a choice+ * rather than an observed behaviour.+ */+@RegisterForReflection+@JsonIgnoreProperties(ignoreUnknown = true)+public class OutboundWebIdentityFederation {++ private String issuerIdentifier;+ private boolean enabled;++ public OutboundWebIdentityFederation() {}++ public String getIssuerIdentifier() { return issuerIdentifier; }+ public void setIssuerIdentifier(String issuerIdentifier) {+ this.issuerIdentifier = issuerIdentifier;+ }+ public boolean isEnabled() { return enabled; }+ public void setEnabled(boolean enabled) { this.enabled = enabled; }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/AccountPropertiesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/AccountPropertiesIntegrationTest.javanew file mode 100644index 0000000000..8e2dfda14e--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/AccountPropertiesIntegrationTest.java@@ -0,0 +1,228 @@+package io.github.hectorvent.floci.services.iam;++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.matchesPattern;+import static org.hamcrest.Matchers.not;+import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertNotNull;++/**+ * The account property and outbound federation operations over the wire.+ *+ * <p>These are account-level singletons, so the tests share one account and are written not to+ * depend on each other's properties: each uses its own namespace.+ */+@QuarkusTest+class AccountPropertiesIntegrationTest {++ private static final String IAM_AUTH =+ "AWS4-HMAC-SHA256 Credential=test/20260227/us-east-1/iam/aws4_request";++ private static RequestSpecification iam(String action) {+ return given().header("Authorization", IAM_AUTH).formParam("Action", action);+ }++ private static String namespace() {+ return "Ns" + Long.toString(System.nanoTime(), 36).replace("-", "");+ }++ private static final String PROPERTIES =+ "GetAccountPropertiesResponse.GetAccountPropertiesResult.Properties.";++ @Test+ void propertiesRoundTripThroughPutAndGet() {+ String ns = namespace();++ iam("PutAccountProperties")+ .formParam("Properties.entry.1.key", ns + "/RoleManagerEnabled")+ .formParam("Properties.entry.1.value", "true")+ .formParam("Properties.entry.2.key", ns + "/Mode")+ .formParam("Properties.entry.2.value", "strict")+ .when().post("/").then().statusCode(200);++ iam("GetAccountProperties").when().post("/").then().statusCode(200)+ .body(containsString(ns + "/RoleManagerEnabled"))+ .body(containsString(ns + "/Mode"))+ .body(containsString("strict"));+ }++ /** "All keys must belong to the same namespace." */+ @Test+ void mixingNamespacesInOneRequestIsRejected() {+ String first = namespace();+ String second = namespace();++ iam("PutAccountProperties")+ .formParam("Properties.entry.1.key", first + "/Alpha")+ .formParam("Properties.entry.1.value", "1")+ .formParam("Properties.entry.2.key", second + "/Beta")+ .formParam("Properties.entry.2.value", "2")+ .when().post("/").then().statusCode(400)+ .body(containsString("InvalidInput"))+ .body(containsString("same namespace"));++ // Rejected whole, not partly applied: neither key was written.+ iam("GetAccountProperties").when().post("/").then().statusCode(200)+ .body(not(containsString(first + "/Alpha")))+ .body(not(containsString(second + "/Beta")));+ }++ /** The key is Namespace/PropertyName: exactly one slash, not at either end. */+ @Test+ void aMalformedKeyIsRejected() {+ for (String key : List.of("NoSlash", "/LeadingSlash", "Trailing/", "Two/Slashes/Here",+ "1StartsWithADigit", "Has Space/Prop", "Ns/Prop!")) {+ iam("PutAccountProperties")+ .formParam("Properties.entry.1.key", key)+ .formParam("Properties.entry.1.value", "x")+ .when().post("/").then().statusCode(400)+ .body(containsString("InvalidInput"));+ }+ }++ @Test+ void aKeyOrValueOutsideItsLengthBoundsIsRejected() {+ String ns = namespace();+ // keyLength is 1 to 50.+ iam("PutAccountProperties")+ .formParam("Properties.entry.1.key", ns + "/" + "P".repeat(60))+ .formParam("Properties.entry.1.value", "x")+ .when().post("/").then().statusCode(400).body(containsString("InvalidInput"));++ // valueLength is 1 to 1024.+ iam("PutAccountProperties")+ .formParam("Properties.entry.1.key", ns + "/TooLongValue")+ .formParam("Properties.entry.1.value", "v".repeat(1025))+ .when().post("/").then().statusCode(400).body(containsString("InvalidInput"));++ // And the top of the range is accepted, so the bound is not off by one.+ iam("PutAccountProperties")+ .formParam("Properties.entry.1.key", ns + "/AtTheLimit")+ .formParam("Properties.entry.1.value", "v".repeat(1024))+ .when().post("/").then().statusCode(200);+ }++ @Test+ void anAbsentPropertiesMapIsRejected() {+ iam("PutAccountProperties").when().post("/").then().statusCode(400)+ .body(containsString("ValidationError"));+ }++ @Test+ void theTokenVersionTakesOnlyTheTwoDocumentedValues() {+ for (String version : List.of("v1Token", "v2Token")) {+ iam("SetSecurityTokenServicePreferences")+ .formParam("GlobalEndpointTokenVersion", version)+ .when().post("/").then().statusCode(200);+ }++ for (String version : List.of("v3Token", "V1Token", "")) {+ iam("SetSecurityTokenServicePreferences")+ .formParam("GlobalEndpointTokenVersion", version)+ .when().post("/").then().statusCode(400)+ .body(containsString("ValidationError"));+ }++ iam("SetSecurityTokenServicePreferences").when().post("/").then().statusCode(400)+ .body(containsString("ValidationError"))+ .body(containsString("globalEndpointTokenVersion"));+ }++ /**+ * The version set here is what GetAccountSummary reports, which the operation's own+ * description requires: the version "is reported in the GlobalEndpointTokenVersion entry of+ * the response of the GetAccountSummary operation". Reporting a constant leaves a caller that+ * set v2Token reading back 1.+ */+ @Test+ void theTokenVersionIsWhatTheAccountSummaryReports() {+ String key = "GetAccountSummaryResponse.GetAccountSummaryResult.SummaryMap.entry"+ + ".find { it.key == 'GlobalEndpointTokenVersion' }.value";++ iam("SetSecurityTokenServicePreferences")+ .formParam("GlobalEndpointTokenVersion", "v2Token")+ .when().post("/").then().statusCode(200);+ iam("GetAccountSummary").when().post("/").then().statusCode(200)+ .body(key, equalTo("2"));++ iam("SetSecurityTokenServicePreferences")+ .formParam("GlobalEndpointTokenVersion", "v1Token")+ .when().post("/").then().statusCode(200);+ iam("GetAccountSummary").when().post("/").then().statusCode(200)+ .body(key, equalTo("1"));+ }++ /**+ * The federation lifecycle, in one test because it is one account-level switch: the order of+ * enable and disable is the behaviour under test and separate tests would race each other.+ *+ * <p>The asymmetry is the interesting part: enabling twice is 409, disabling twice is 404.+ */+ @Test+ void theFederationSwitchRefusesBothRedundantDirections() {+ String enabled = "EnableOutboundWebIdentityFederationResponse"+ + ".EnableOutboundWebIdentityFederationResult.IssuerIdentifier";+ String info = "GetOutboundWebIdentityFederationInfoResponse"+ + ".GetOutboundWebIdentityFederationInfoResult.";++ // Start from a known state: disabled, however earlier runs left it.+ iam("DisableOutboundWebIdentityFederation").when().post("/");++ iam("GetOutboundWebIdentityFederationInfo").when().post("/").then().statusCode(404)+ .body(containsString("FeatureDisabled"));++ String issuer = iam("EnableOutboundWebIdentityFederation")+ .when().post("/").then().statusCode(200)+ // https://<uuid>.tokens.sts.global.<dual-stack suffix>, api.aws in this partition.+ .body(enabled, matchesPattern(+ "https://[0-9a-f-]{36}\\.tokens\\.sts\\.global\\.api\\.aws"))+ .extract().path(enabled);+ assertNotNull(issuer);++ iam("EnableOutboundWebIdentityFederation").when().post("/").then().statusCode(409)+ .body(containsString("FeatureEnabled"))+ .body(containsString("cannot enable the feature multiple times"));++ iam("GetOutboundWebIdentityFederationInfo").when().post("/").then().statusCode(200)+ .body(info + "IssuerIdentifier", equalTo(issuer))+ .body(info + "JwtVendingEnabled", equalTo("true"));++ iam("DisableOutboundWebIdentityFederation").when().post("/").then().statusCode(200);+ iam("DisableOutboundWebIdentityFederation").when().post("/").then().statusCode(404)+ .body(containsString("FeatureDisabled"))+ .body(containsString("cannot disable the feature multiple times"));++ // Re-enabling returns the same issuer: a relying party has pinned it.+ String reissued = iam("EnableOutboundWebIdentityFederation")+ .when().post("/").then().statusCode(200).extract().path(enabled);+ assertEquals(issuer, reissued, "the issuer is minted once per account");++ iam("DisableOutboundWebIdentityFederation").when().post("/").then().statusCode(200);+ }++ /**+ * 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.+ */+ @Test+ void theActionsRouteToIamWithNoAuthHeader() {+ for (String action : List.of("GetAccountProperties", "PutAccountProperties",+ "SetSecurityTokenServicePreferences", "EnableOutboundWebIdentityFederation",+ "DisableOutboundWebIdentityFederation",+ "GetOutboundWebIdentityFederationInfo")) {+ 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/AccountPropertiesStateTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/AccountPropertiesStateTest.javanew file mode 100644index 0000000000..18e1e9ebf7--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/AccountPropertiesStateTest.java@@ -0,0 +1,242 @@+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.iam.model.OutboundWebIdentityFederation;+import jakarta.enterprise.inject.Instance;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.io.TempDir;++import java.nio.file.Path;+import java.util.LinkedHashMap;+import java.util.Map;+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.assertNotEquals;+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;++/**+ * What the wire tests cannot reach for the account-level singletons: that they survive a restart,+ * that one account cannot see another's, and that two racing enables cannot both succeed.+ */+class AccountPropertiesStateTest {++ private static final String ACCOUNT_A = "000000000000";+ private static final String ACCOUNT_B = "111111111111";++ @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, String> accountProperties,+ StorageBackend<String, String> stsPreferences,+ StorageBackend<String, OutboundWebIdentityFederation> federation,+ 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<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ accountProperties, stsPreferences, federation,+ new RegionResolver("us-east-1", defaultAccount), false, null);+ }++ private static IamService inMemory(String defaultAccount) {+ return newService(new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(), defaultAccount);+ }++ /**+ * All three singletons survive a restart. The issuer matters most: a relying party has pinned+ * it, so losing it on restart would break verification with no way to notice from the API.+ */+ @Test+ void thePropertiesTheTokenVersionAndTheIssuerSurviveARestart(@TempDir Path dir) {+ Path propertiesFile = dir.resolve("iam-account-properties.json");+ Path stsFile = dir.resolve("iam-sts-preferences.json");+ Path federationFile = dir.resolve("iam-outbound-federation.json");++ PersistentStorage<String, String> properties =+ new PersistentStorage<>(propertiesFile, new TypeReference<>() {});+ PersistentStorage<String, String> sts =+ new PersistentStorage<>(stsFile, new TypeReference<>() {});+ PersistentStorage<String, OutboundWebIdentityFederation> federation =+ new PersistentStorage<>(federationFile, new TypeReference<>() {});+ properties.load();+ sts.load();+ federation.load();++ IamService before = newService(properties, sts, federation, ACCOUNT_A);+ before.putAccountProperties(Map.of("RoleManager/Enabled", "true"));+ before.setSecurityTokenServicePreferences("v2Token");+ String issuer = before.enableOutboundWebIdentityFederation();++ PersistentStorage<String, String> properties2 =+ new PersistentStorage<>(propertiesFile, new TypeReference<>() {});+ PersistentStorage<String, String> sts2 =+ new PersistentStorage<>(stsFile, new TypeReference<>() {});+ PersistentStorage<String, OutboundWebIdentityFederation> federation2 =+ new PersistentStorage<>(federationFile, new TypeReference<>() {});+ properties2.load();+ sts2.load();+ federation2.load();+ IamService after = newService(properties2, sts2, federation2, ACCOUNT_A);++ assertEquals(Map.of("RoleManager/Enabled", "true"), after.getAccountProperties());+ assertEquals("v2Token", after.getGlobalEndpointTokenVersion());+ assertEquals(issuer,+ after.getOutboundWebIdentityFederationInfo().getIssuerIdentifier());+ assertTrue(after.getOutboundWebIdentityFederationInfo().isEnabled());+ }++ @Test+ void oneAccountCannotSeeAnothersProperties() {+ AtomicReference<String> account = new AtomicReference<>(ACCOUNT_A);+ Instance<RequestContext> context = requestContextFor(account);+ AccountAwareStorageBackend<String> properties = new AccountAwareStorageBackend<>(+ new InMemoryStorage<>(), context, ACCOUNT_A);+ AccountAwareStorageBackend<String> sts = new AccountAwareStorageBackend<>(+ new InMemoryStorage<>(), context, ACCOUNT_A);+ AccountAwareStorageBackend<OutboundWebIdentityFederation> federation =+ new AccountAwareStorageBackend<>(new InMemoryStorage<>(), context, ACCOUNT_A);++ IamService inA = newService(properties, sts, federation, ACCOUNT_A);+ IamService inB = newService(properties, sts, federation, ACCOUNT_B);++ inA.putAccountProperties(Map.of("RoleManager/Mode", "a"));+ inA.setSecurityTokenServicePreferences("v2Token");+ String issuerA = inA.enableOutboundWebIdentityFederation();++ account.set(ACCOUNT_B);+ assertTrue(inB.getAccountProperties().isEmpty(), "B must not see A's properties");+ assertEquals("v1Token", inB.getGlobalEndpointTokenVersion(),+ "B falls back to the default rather than reading A's preference");+ assertThrows(AwsException.class, inB::getOutboundWebIdentityFederationInfo,+ "B's federation is off, whatever A did");++ // And B enabling mints its own issuer rather than inheriting A's.+ String issuerB = inB.enableOutboundWebIdentityFederation();+ assertNotEquals(issuerA, issuerB);++ account.set(ACCOUNT_A);+ assertEquals(Map.of("RoleManager/Mode", "a"), inA.getAccountProperties());+ assertEquals(issuerA,+ inA.getOutboundWebIdentityFederationInfo().getIssuerIdentifier());+ }++ /**+ * Enabling is a check-then-act on one switch, so two racing enables must not both mint an+ * issuer and both report success. Asserted by counting the winners, because an invariant+ * phrased as "the stored issuer is one of the two" passes with the lock removed too.+ */+ @Test+ void racingEnablesProduceOneWinner() throws Exception {+ for (int trial = 0; trial < 60; trial++) {+ IamService service = inMemory(ACCOUNT_A);+ int attempts = 8;+ ExecutorService pool = Executors.newFixedThreadPool(attempts);+ CountDownLatch start = new CountDownLatch(1);+ AtomicInteger enabled = new AtomicInteger();+ try {+ for (int i = 0; i < attempts; i++) {+ pool.submit(() -> {+ start.await();+ try {+ service.enableOutboundWebIdentityFederation();+ enabled.incrementAndGet();+ } catch (AwsException expected) {+ // FeatureEnabled for the losers, which is the point.+ }+ return null;+ });+ }+ start.countDown();+ pool.shutdown();+ assertTrue(pool.awaitTermination(30, TimeUnit.SECONDS), "trial did not finish");+ } finally {+ pool.shutdownNow();+ }+ assertEquals(1, enabled.get(),+ "trial " + trial + ": exactly one enable should have succeeded");+ }+ }++ /** The issuer is minted once: a disable and re-enable returns the same URL. */+ @Test+ void theIssuerIsStableAcrossADisableAndReEnable() {+ IamService service = inMemory(ACCOUNT_A);+ String first = service.enableOutboundWebIdentityFederation();+ service.disableOutboundWebIdentityFederation();+ assertThrows(AwsException.class, service::getOutboundWebIdentityFederationInfo);+ assertEquals(first, service.enableOutboundWebIdentityFederation());+ }++ private static IamService inRegion(String region) {+ 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<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),+ new RegionResolver(region, ACCOUNT_A), false, null);+ }++ /**+ * The issuer host comes from the request's partition rather than the commercial literal the+ * API Reference's example happens to show. This is the test the mistake would survive+ * otherwise: hardcoding {@code api.aws} passes everything else.+ */+ @Test+ void theIssuerHostFollowsThePartition() {+ String commercial = inRegion("us-east-1").enableOutboundWebIdentityFederation();+ String chinese = inRegion("cn-north-1").enableOutboundWebIdentityFederation();++ assertTrue(commercial.endsWith(".tokens.sts.global.api.aws"), commercial);+ assertTrue(chinese.startsWith("https://"), chinese);+ assertNotEquals(commercial.substring(commercial.indexOf(".tokens")),+ chinese.substring(chinese.indexOf(".tokens")),+ "the suffix must differ between partitions, but China gave " + chinese);+ }++ /** A request mixing namespaces is rejected whole, so nothing from it is written. */+ @Test+ void aMixedNamespaceRequestWritesNothing() {+ IamService service = inMemory(ACCOUNT_A);+ service.putAccountProperties(Map.of("RoleManager/Kept", "yes"));++ Map<String, String> mixed = new LinkedHashMap<>();+ mixed.put("RoleManager/A", "1");+ mixed.put("Other/B", "2");+ assertThrows(AwsException.class, () -> service.putAccountProperties(mixed));++ assertEquals(Map.of("RoleManager/Kept", "yes"), service.getAccountProperties(),+ "neither key of the rejected request may have landed");+ }+}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 e3abbee350..33ebb3cd3d 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@@ -234,6 +234,7 @@ class IamServicePersistenceTest {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), 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 250408cc1c..25aacdf231 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@@ -2641,6 +2641,7 @@ class IamServiceTest {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new RegionResolver("us-east-1", "000000000000"), false, null);AwsException ex = assertThrows(AwsException.class, withExpiredReport::getCredentialReport);@@ -2662,6 +2663,7 @@ class IamServiceTest {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ 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 22168f7a21..fe834cab17 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@@ -83,6 +83,7 @@ class ServerCertificateStateTest {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new RegionResolver("us-east-1", defaultAccount), false, null);}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/ServiceSpecificCredentialStateTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/ServiceSpecificCredentialStateTest.javaindex 606b5f7594..c00d3db98e 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/ServiceSpecificCredentialStateTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/ServiceSpecificCredentialStateTest.java@@ -70,6 +70,7 @@ class ServiceSpecificCredentialStateTest {new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),credentials,+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new RegionResolver("us-east-1", defaultAccount), false, null);}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.javaindex 86059fbb25..d4f1002a6d 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/SigningCertificateStateTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/SigningCertificateStateTest.java@@ -73,6 +73,7 @@ class SigningCertificateStateTest {certificates,new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new RegionResolver("us-east-1", defaultAccount), false, null);}@@ -90,6 +91,7 @@ class SigningCertificateStateTest {certificates,new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new RegionResolver("us-east-1", defaultAccount), false, null);}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/SshPublicKeyStateTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/SshPublicKeyStateTest.javaindex 758a0d2797..900363f9a8 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/SshPublicKeyStateTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/SshPublicKeyStateTest.java@@ -76,6 +76,7 @@ class SshPublicKeyStateTest {new InMemoryStorage<>(), new InMemoryStorage<>(),keys,new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new RegionResolver("us-east-1", defaultAccount), false, null);}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 aedc8494b1..0e30196f2b 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@@ -54,6 +54,7 @@ class VirtualMfaAccountScopeTest {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new RegionResolver("us-east-1", ACCOUNT_A), false, null);VirtualMfaDevice device = service.createVirtualMfaDevice("shared-name", "/", Map.of());@@ -95,6 +96,7 @@ class VirtualMfaAccountScopeTest {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), 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 9ea92267c6..912b9341ab 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@@ -41,6 +41,7 @@ class VirtualMfaConcurrencyTest {new InMemoryStorage<>(),new InMemoryStorage<>(),new InMemoryStorage<>(),+ new InMemoryStorage<>(), new InMemoryStorage<>(), new InMemoryStorage<>(),new RegionResolver("eu-central-1", "000000000000"), false, null);}