Light, fluffy, and always free - The AWS Local Emulator alternative
feat(sts): dispatch AssumeRoot and authorize centralized root access (#6251)
Priamo Germosenc094ce397377
diff --git a/docs/services/iam.md b/docs/services/iam.mdindex 37fcad765b..b3beca6687 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -787,9 +787,27 @@ that has never set one.| EnableOrganizationsRootSessions | Enables the `RootSessions` feature. || DisableOrganizationsRootSessions | Disables the `RootSessions` feature. |-Only the set of enabled features is stored, and enabling a feature twice is idempotent. Floci does not-model root credentials or root sessions themselves, so the flags change what `ListOrganizationsFeatures`-returns and nothing else.+Only the set of enabled features is stored, and enabling a feature twice is idempotent. Floci does+not model root credentials themselves, so `RootCredentialsManagement` changes what+`ListOrganizationsFeatures` returns and nothing else; `RootSessions` is what STS `AssumeRoot` reads+before opening a privileged session.++All five answer for one organization, so all five check the caller, each refusal being a shape the+reference models on them and on nothing else. In the order they are asked: no organization at all+is `OrganizationNotFoundException`, an organization without All features is+`OrganizationNotInAllFeaturesModeException`, one without trusted access for IAM in Organizations is+`ServiceAccessNotEnabledException`, and a caller that is neither the management account nor a+delegated administrator for IAM is `AccountNotManagementOrDelegatedAdministratorException`. The two+enable operations add `CallerIsNotManagementAccountException`, which is modeled on them alone, so a+delegated administrator may read the features and turn them off but not on. Each is 400 and carries+the shape name as its code: botocore declares no `error.code` for any of the five.++The feature set belongs to the organization rather than to whoever asked for it, so it is read and+written in the management account's scope and a delegated administrator sees what the management+account enabled. The order is chosen rather than read, and so is the account the record lives in; a+toggle set before this moved sat in the calling account's scope and is set again once. The+`OrganizationId` the model declares beside `EnabledFeatures` is answered now that the organization+is known either way.### Server Certificatesdiff --git a/docs/services/index.md b/docs/services/index.mdindex e932309b35..57b35500f5 100644--- a/docs/services/index.md+++ b/docs/services/index.md@@ -24,7 +24,7 @@ Operation counts are exact. For dispatch-table services (Query and JSON 1.1) eac| [API Gateway v1](api-gateway.md) | `/restapis/...` | REST JSON | 80 || [API Gateway v2](api-gateway.md#v2) | `/v2/apis/...` | REST JSON | 53 + data-plane || [IAM](iam.md) | `POST /` with `Action=` param | Query | 176 |-| [STS](sts.md) | `POST /` with `Action=` param | Query | 9 |+| [STS](sts.md) | `POST /` with `Action=` param | Query | 10 || [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 || [Cognito](cognito.md) | `POST /` + `X-Amz-Target: AWSCognitoIdentityProviderService.*` | JSON 1.1 | 90 |diff --git a/docs/services/sts.md b/docs/services/sts.mdindex 783d0206ef..1d4c73966c 100644--- a/docs/services/sts.md+++ b/docs/services/sts.md@@ -15,6 +15,50 @@| `DecodeAuthorizationMessage` | Decode an encoded authorization failure message || `GetDelegatedAccessToken` | Exchange a delegation request's trade-in token for temporary credentials || `GetAccessKeyInfo` | Returns the account an access key ID belongs to |+| `AssumeRoot` | Opens a privileged session on a member account of the organization |++## Privileged Root Sessions++`AssumeRoot` returns "short term credentials you can use to perform privileged tasks on a member+account in your organization". The session acts as that member account's root user, which no+identity policy grants or denies, scoped by the `TaskPolicyArn` the request names: the five AWS+managed policies the model names for it, under `arn:aws:iam::aws:policy/root-task/`, each deny+everything they do not name, so the policy is the whole of the session's bound. Whose policy it is+counts as much as where it sits: a customer-managed policy can carry the same path, and installing+one would bound the session by whatever that document allows, so only AWS's own are accepted and+anything else is refused.++The caller has to be able to manage root access: the management account or a delegated+administrator for IAM, in an organization with All features and trusted access for IAM enabled, and+with `RootSessions` on. The target has to be a member account other than the management account,+privileged tasks being what the management account performs on members. `DurationSeconds` is 0 to+900 and defaults to 900, "the maximum session duration of 900 seconds (15 minutes)".++Four things are deviations rather than readings, since the operation models only+`RegionDisabledException` and `ExpiredTokenException`:++- Every caller, target and feature refusal is `AccessDenied` 403, and a task policy outside the+ root-task path is a `ValidationError`, which is the shape every other member violation answers.+- "You cannot use root user credentials to call sts:AssumeRoot" is the guide's rule; what is+ decided here is which credential that means. Both the one resolving to a root ARN, a privileged+ session opening another among them, and the bare 12-digit account-id key are refused, the latter+ because the enforcement filter already reads it as "floci's account-root principal, never an IAM+ user's key". A privileged session is therefore opened by an IAM user or role of the management+ account, as on AWS, rather than by the account itself.+- "The global endpoint is not supported for AssumeRoot" is refused when the request arrives on the+ partition's global STS host. A request to a local host carries no such name, and the signing+ region cannot tell the two apart, so there is nothing to refuse there.+- `SessionTokenSize` is answered as the length of the token issued, and `MinimumSessionTokenSize`+ pads it to at least the size asked for, held to the 0 to 4096 the model declares, "The value must+ not exceed 4,096 bytes", since the size asked for is the size materialized. Out of that range is+ a `ValidationError` and a value that is no integer an `InvalidParameterValue`, the pair+ `DurationSeconds` already answers. `SessionTokenUtilization` is not answered: the model documents+ neither member, so only the one with an obvious meaning is filled.++The audit reads the `IAMAuditRootUserCredentials` task policy allows name the member account's root+user when they are called with no `UserName`, which is what that policy's own `arn:aws:iam::*:root`+asks for. Floci keeps no user record for a root user, so those reads answer `NoSuchEntity` rather+than the credentials report AWS returns.## Access Key Infodiff --git a/src/main/java/io/github/hectorvent/floci/services/iam/CentralRootAccess.java b/src/main/java/io/github/hectorvent/floci/services/iam/CentralRootAccess.javanew file mode 100644index 0000000000..d63ed283fe--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iam/CentralRootAccess.java@@ -0,0 +1,146 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.core.common.AwsException;+import io.github.hectorvent.floci.core.common.RequestScopes;+import jakarta.enterprise.context.ApplicationScoped;+import jakarta.enterprise.inject.Instance;+import jakarta.inject.Inject;++import java.util.List;+import java.util.Optional;+import java.util.function.Supplier;++/**+ * Centralized root access: who may turn the two root features on and off, and who may launch a+ * privileged session with them. The five IAM operations behind the feature set+ * ({@code ListOrganizationsFeatures}, {@code Enable}/{@code DisableOrganizationsRootCredentialsManagement},+ * {@code Enable}/{@code DisableOrganizationsRootSessions}) all answer for one organization, so+ * every one of them goes through here and {@link IamService} keeps only the toggles themselves.+ *+ * <p>Two things this fixes about those toggles. They took no caller check at all, so any account+ * could enable or disable organization-wide root features; the reference models five refusals on+ * them and they are all made here. And the record they write is account-scoped like every other+ * IAM record, so the management account's toggle was invisible to a delegated administrator: the+ * feature set belongs to the organization, so it is read and written in the management account's+ * scope whoever asks. A toggle set before this change sat in the calling account's scope and is+ * not read any more, so it is set again once.+ *+ * <p>The organization itself is answered by {@link RootAccessOrganization}, which Organizations+ * implements, so IAM still does not depend on Organizations.+ */+@ApplicationScoped+public class CentralRootAccess {++ /** The wire code is the shape name: botocore gives these five shapes no {@code error.code}. */+ private static final int REFUSED = 400;++ private final IamService iamService;+ private final Instance<RootAccessOrganization> organizations;++ @Inject+ public CentralRootAccess(IamService iamService, Instance<RootAccessOrganization> organizations) {+ this.iamService = iamService;+ this.organizations = organizations;+ }++ /** The organization id and its enabled features, which every one of the five operations answers. */+ public record Features(String organizationId, List<String> enabledFeatures) {}++ public Features list(String callerAccountId) {+ RootAccessOrganization.Membership organization = authorize(callerAccountId, false);+ return features(organization, iamService::listOrganizationsFeatures);+ }++ public Features enableRootCredentialsManagement(String callerAccountId) {+ RootAccessOrganization.Membership organization = authorize(callerAccountId, true);+ return features(organization, iamService::enableOrganizationsRootCredentialsManagement);+ }++ public Features enableRootSessions(String callerAccountId) {+ RootAccessOrganization.Membership organization = authorize(callerAccountId, true);+ return features(organization, iamService::enableOrganizationsRootSessions);+ }++ public Features disableRootCredentialsManagement(String callerAccountId) {+ RootAccessOrganization.Membership organization = authorize(callerAccountId, false);+ return features(organization, iamService::disableOrganizationsRootCredentialsManagement);+ }++ public Features disableRootSessions(String callerAccountId) {+ RootAccessOrganization.Membership organization = authorize(callerAccountId, false);+ return features(organization, iamService::disableOrganizationsRootSessions);+ }++ /**+ * The organization a privileged session may be launched in, or a refusal. The caller must be+ * able to manage root access and {@code RootSessions} must be enabled, which is what the guide+ * means by "You have enabled centralized root access in your organization".+ *+ * <p>{@code AssumeRoot} models neither refusal, so both are {@code AccessDenied} 403, the+ * answer STS publishes for a caller it will not mint credentials for.+ */+ RootAccessOrganization.Membership privilegedSessionOrganization(String callerAccountId) {+ Optional<RootAccessOrganization.Membership> found = membershipOf(callerAccountId);+ if (found.isEmpty() || !found.get().allFeatures() || !found.get().iamTrustedAccess()+ || !found.get().isManagementOrDelegatedAdministrator(callerAccountId)) {+ throw new AwsException("AccessDenied", "User: " + callerAccountId + " is not authorized to perform:"+ + " sts:AssumeRoot because it is not the management account or a delegated administrator"+ + " account for centralized root access.", 403);+ }+ RootAccessOrganization.Membership organization = found.get();+ if (!features(organization, iamService::listOrganizationsFeatures)+ .enabledFeatures().contains(IamService.FEATURE_ROOT_SESSIONS)) {+ throw new AwsException("AccessDenied", "User: " + callerAccountId + " is not authorized to perform:"+ + " sts:AssumeRoot because centralized root access is not enabled for the organization."+ + " Call EnableOrganizationsRootSessions first.", 403);+ }+ return organization;+ }++ /**+ * The five refusals the reference models on the feature operations, in the order they are+ * asked: whether there is an organization at all, what it has enabled, and who is asking.+ * {@code CallerIsNotManagementAccount} is modeled on the two enable operations only, so a+ * delegated administrator may list and disable but not enable.+ */+ private RootAccessOrganization.Membership authorize(String callerAccountId, boolean managementOnly) {+ RootAccessOrganization.Membership organization = membershipOf(callerAccountId)+ .orElseThrow(() -> refused("OrganizationNotFoundException",+ "The request was rejected because no organization is associated with your account."));+ if (!organization.allFeatures()) {+ throw refused("OrganizationNotInAllFeaturesModeException", "The request was rejected because your"+ + " organization does not have All features enabled.");+ }+ if (!organization.iamTrustedAccess()) {+ throw refused("ServiceAccessNotEnabledException", "The request was rejected because trusted access"+ + " is not enabled for IAM in Organizations.");+ }+ if (!organization.isManagementOrDelegatedAdministrator(callerAccountId)) {+ throw refused("AccountNotManagementOrDelegatedAdministratorException", "The request was rejected"+ + " because the account making the request is not the management account or delegated"+ + " administrator account for centralized root access.");+ }+ if (managementOnly && !organization.isManagementAccount(callerAccountId)) {+ throw refused("CallerIsNotManagementAccountException", "The request was rejected because the account"+ + " making the request is not the management account for the organization.");+ }+ return organization;+ }++ /** The feature set belongs to the organization, so the management account's scope holds it. */+ private Features features(RootAccessOrganization.Membership organization, Supplier<List<String>> toggle) {+ return new Features(organization.organizationId(),+ RequestScopes.callAs(organization.managementAccountId(), toggle));+ }++ private Optional<RootAccessOrganization.Membership> membershipOf(String accountId) {+ if (!organizations.isResolvable()) {+ return Optional.empty();+ }+ return organizations.get().membershipOf(accountId);+ }++ private static AwsException refused(String code, String message) {+ return new AwsException(code, message, REFUSED);+ }+}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 1d53a6a797..ab7348b0eb 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@@ -85,6 +85,7 @@ public class IamQueryHandler {private final ServiceLastAccessedService serviceLastAccessedService;private final OrganizationsAccessReportService organizationsAccessReportService;private final DelegationRequestService delegationRequestService;+ private final CentralRootAccess centralRootAccess;private final RegionResolver regionResolver;private final Instance<ServerCertificateReferenceProvider> serverCertificateReferenceProviders;/** Signs each page's Marker, so only a marker this handler issued names an item. */@@ -96,6 +97,7 @@ public class IamQueryHandler {ServiceLastAccessedService serviceLastAccessedService,OrganizationsAccessReportService organizationsAccessReportService,DelegationRequestService delegationRequestService,+ CentralRootAccess centralRootAccess,RegionResolver regionResolver,Instance<ServerCertificateReferenceProvider> serverCertificateReferenceProviders) {this.iamService = iamService;@@ -105,6 +107,7 @@ public class IamQueryHandler {this.serviceLastAccessedService = serviceLastAccessedService;this.organizationsAccessReportService = organizationsAccessReportService;this.delegationRequestService = delegationRequestService;+ this.centralRootAccess = centralRootAccess;this.regionResolver = regionResolver;this.serverCertificateReferenceProviders = serverCertificateReferenceProviders;}@@ -2024,38 +2027,42 @@ public class IamQueryHandler {// =========================================================================private Response handleListOrganizationsFeatures(MultivaluedMap<String, String> params) {- return rootFeaturesResponse("ListOrganizationsFeatures", iamService.listOrganizationsFeatures());+ return rootFeaturesResponse("ListOrganizationsFeatures",+ centralRootAccess.list(regionResolver.getAccountId()));}private Response handleEnableOrganizationsRootCredentialsManagement(MultivaluedMap<String, String> params) {return rootFeaturesResponse("EnableOrganizationsRootCredentialsManagement",- iamService.enableOrganizationsRootCredentialsManagement());+ centralRootAccess.enableRootCredentialsManagement(regionResolver.getAccountId()));}private Response handleEnableOrganizationsRootSessions(MultivaluedMap<String, String> params) {return rootFeaturesResponse("EnableOrganizationsRootSessions",- iamService.enableOrganizationsRootSessions());+ centralRootAccess.enableRootSessions(regionResolver.getAccountId()));}private Response handleDisableOrganizationsRootCredentialsManagement(MultivaluedMap<String, String> params) {return rootFeaturesResponse("DisableOrganizationsRootCredentialsManagement",- iamService.disableOrganizationsRootCredentialsManagement());+ centralRootAccess.disableRootCredentialsManagement(regionResolver.getAccountId()));}private Response handleDisableOrganizationsRootSessions(MultivaluedMap<String, String> params) {return rootFeaturesResponse("DisableOrganizationsRootSessions",- iamService.disableOrganizationsRootSessions());+ centralRootAccess.disableRootSessions(regionResolver.getAccountId()));}/**- * Builds the shared {@code <EnabledFeatures><member>..</member></EnabledFeatures>} result used by- * both {@code ListOrganizationsFeatures} and the enable/disable ops. The org-scoped- * {@code OrganizationId} is intentionally omitted — LZA's root-user-management module reads only- * the enabled-feature set, and omitting it avoids coupling the IAM endpoint to Organizations.+ * The shared {@code OrganizationId} and {@code EnabledFeatures} result all five feature+ * operations answer, in the order the model declares them. The organization id used to be+ * omitted here to keep IAM off Organizations; the caller checks the reference models on these+ * operations need the organization anyway, and {@link CentralRootAccess} asks for it through a+ * provider interface, so the member is answered as published.*/- private Response rootFeaturesResponse(String action, List<String> features) {- XmlBuilder xml = new XmlBuilder().start("EnabledFeatures");- for (String feature : features) {+ private Response rootFeaturesResponse(String action, CentralRootAccess.Features features) {+ XmlBuilder xml = new XmlBuilder()+ .elem("OrganizationId", features.organizationId())+ .start("EnabledFeatures");+ for (String feature : features.enabledFeatures()) {xml.elem("member", feature);}String result = xml.end("EnabledFeatures").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 92e7ff844f..65877f0e22 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@@ -2388,6 +2388,10 @@ public class IamService implements SessionAccountLookup, ResourceProvider {// Centralized root access management (org-scoped, IAM Query endpoint)// =========================================================================+ // The toggles themselves. Who may read or move them, and which organization's record they+ // belong to, is CentralRootAccess: it is the caller of all five and the only one that should+ // be, these having no caller check of their own.+/** Currently-enabled centralized root features, in enablement order. Empty for a fresh org. */public List<String> listOrganizationsFeatures() {return new ArrayList<>(currentRootFeatures().getEnabledFeatures());@@ -5252,6 +5256,18 @@ public class IamService implements SessionAccountLookup, ResourceProvider {}return sessionTokenContext(session);}+ if (isAccountRootArn(session.getRoleArn())) {+ // A privileged session (AssumeRoot) acts as the member account's root user, which+ // no identity policy grants and none denies: collecting role policies for a root+ // ARN finds none, which would refuse everything. What scopes it is its task+ // policy, and the five AWS publishes for the purpose carry Deny statements only,+ // so it is read beside the root's own allow-all rather than as a session policy,+ // where an intersection with nothing to allow would refuse everything too.+ return new CallerContext(session.getSessionPolicyDocument() == null+ ? List.of(SCOPED_IDENTITY_SESSION_BASE_POLICY)+ : List.of(SCOPED_IDENTITY_SESSION_BASE_POLICY, session.getSessionPolicyDocument()),+ null, null);+ }List<String> identityPolicies = collectRolePolicies(session.getRoleArn());String boundaryDoc = resolveRoleBoundaryDocument(session.getRoleArn());return new CallerContext(identityPolicies, session.getSessionPolicyDocument(), boundaryDoc);@@ -5521,6 +5537,13 @@ public class IamService implements SessionAccountLookup, ResourceProvider {}return issuingUser(session).map(IamService::callerForUser);}+ if (isAccountRootArn(roleArn)) {+ // A privileged session (AssumeRoot) is the member account's root user, not an+ // assumed role: the ARN it reports is the root ARN it was minted for, and its+ // aws:userid is the account id, as the account root's always is.+ return Optional.of(new CallerArns(roleArn, roleArn, CallerArns.TYPE_ACCOUNT,+ AwsArnUtils.accountOrDefault(roleArn, regionResolver.getAccountId()), null));+ }String roleName = roleArn.contains("/") ? roleArn.substring(roleArn.lastIndexOf('/') + 1) : "UnknownRole";String accountId = AwsArnUtils.accountOrDefault(roleArn, regionResolver.getAccountId());String sessionName = session.getRoleSessionName();diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java b/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.javaindex 29483ae6b9..589473dfa0 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/ResourceArnBuilder.java@@ -570,10 +570,21 @@ public class ResourceArnBuilder {if (iamService == null) {return List.of("*");}- return SigV4CredentialScope.accessKeyId(ctx.getHeaderString("Authorization"))- .flatMap(accessKeyId -> iamService.get().findUserNameByAccessKeyId(accessKeyId))+ Optional<String> accessKeyId = SigV4CredentialScope.accessKeyId(ctx.getHeaderString("Authorization"));+ Optional<List<String>> user = accessKeyId+ .flatMap(key -> iamService.get().findUserNameByAccessKeyId(key)).flatMap(userName -> storedIamEntity("user", userName, accountId))- .map(stored -> List.of(stored.arn()))+ .map(stored -> List.of(stored.arn()));+ if (user.isPresent()) {+ return user.get();+ }+ // A caller that is the account root names the root user, which is what these actions act+ // on when they are called with no UserName. AWS's own task policy for auditing root+ // credentials is written against arn:aws:iam::*:root, so a privileged session calling+ // GetUser or ListAccessKeys has to name that resource rather than the wildcard.+ return accessKeyId.flatMap(key -> iamService.get().resolveCallerArn(key))+ .filter(arn -> arn.endsWith(":root"))+ .map(List::of).orElse(List.of("*"));}diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/RootAccessOrganization.java b/src/main/java/io/github/hectorvent/floci/services/iam/RootAccessOrganization.javanew file mode 100644index 0000000000..3b3b195603--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/services/iam/RootAccessOrganization.java@@ -0,0 +1,50 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.core.common.ServicePrincipals;++import java.util.Optional;+import java.util.Set;++/**+ * Supplies what centralized root access needs to know about an account's organization: who runs+ * it, whether IAM is trusted in it, and who may act for IAM inside it.+ *+ * <p>Implemented by the Organizations service; consumed lazily by {@link CentralRootAccess} via+ * {@code Instance<RootAccessOrganization>} so IAM never depends on Organizations directly, the+ * way {@link ScpProvider} already does it (Organizations depends on IAM for role provisioning).+ */+public interface RootAccessOrganization {++ /** The IAM service principal whose trusted access and delegated administrators decide this. */+ String IAM_SERVICE_PRINCIPAL = ServicePrincipals.of("iam");++ /**+ * The organization the account belongs to, or empty when it belongs to none.+ *+ * @param accountId the account a request arrived for+ */+ Optional<Membership> membershipOf(String accountId);++ /**+ * One account's view of its organization.+ *+ * @param organizationId the organization's own id, which the root-feature operations answer+ * @param managementAccountId the account that created the organization+ * @param allFeatures whether the organization has the All features set enabled+ * @param iamTrustedAccess whether trusted access is enabled for IAM in Organizations+ * @param iamDelegatedAdmins the accounts registered as delegated administrators for IAM+ * @param memberAccountIds every account in the organization, the management account included+ */+ record Membership(String organizationId, String managementAccountId, boolean allFeatures,+ boolean iamTrustedAccess, Set<String> iamDelegatedAdmins,+ Set<String> memberAccountIds) {++ public boolean isManagementAccount(String accountId) {+ return managementAccountId.equals(accountId);+ }++ public boolean isManagementOrDelegatedAdministrator(String accountId) {+ return isManagementAccount(accountId) || iamDelegatedAdmins.contains(accountId);+ }+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java b/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.javaindex 3d0abf11f6..cce27bc01f 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/StsQueryHandler.java@@ -7,6 +7,7 @@ import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.AwsNamespaces;import io.github.hectorvent.floci.core.common.AwsQueryController;import io.github.hectorvent.floci.core.common.AwsQueryResponse;+import io.github.hectorvent.floci.core.common.AwsRegions;import io.github.hectorvent.floci.core.common.IamConditionContextResolver;import io.github.hectorvent.floci.core.common.IamEnforcementFilter;import io.github.hectorvent.floci.core.common.OidcIssuerKeyLookup;@@ -16,6 +17,7 @@ import io.github.hectorvent.floci.core.common.WebIdentityToken;import io.github.hectorvent.floci.core.common.WebIdentityTokenVerifier;import io.github.hectorvent.floci.core.common.XmlBuilder;import io.github.hectorvent.floci.services.iam.model.DelegationRequest;+import io.github.hectorvent.floci.services.iam.model.IamPolicy;import io.github.hectorvent.floci.services.iam.model.IamRole;import jakarta.enterprise.context.ApplicationScoped;import jakarta.inject.Inject;@@ -53,6 +55,11 @@ public class StsQueryHandler {private static final Logger LOG = Logger.getLogger(StsQueryHandler.class);private static final String CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";+ /** Where the five task policies the guide names for a privileged session live. */+ private static final String ROOT_TASK_POLICY_PATH = "/root-task/";+ /** "the maximum session duration of 900 seconds (15 minutes)", which is also the default here. */+ private static final int MAX_ROOT_SESSION_SECONDS = 900;+ private static final int MAX_SESSION_TOKEN_SIZE = 4096;private static final String STS_AUDIENCE = "sts.amazonaws.com"; // partition-literal: web-identity audience; no source outside the commercial partition (P9)private final IamService iamService;@@ -66,6 +73,7 @@ public class StsQueryHandler {private final SAMLProviderService samlProviderService;private final SAMLTrustPolicyEvaluator samlTrustEvaluator;private final DelegationRequestService delegationRequestService;+ private final CentralRootAccess centralRootAccess;private final Clock clock;/** CSPRNG for session secret keys and session tokens; ordinary IDs keep using {@link ThreadLocalRandom}. */@@ -85,10 +93,11 @@ public class StsQueryHandler {OidcIssuerKeyLookup oidcIssuerKeys,SAMLProviderService samlProviderService,SAMLTrustPolicyEvaluator samlTrustEvaluator,- DelegationRequestService delegationRequestService) {+ DelegationRequestService delegationRequestService,+ CentralRootAccess centralRootAccess) {this(iamService, accountResolver, regionResolver, config, trustPolicyEvaluator, webIdentityTrustEvaluator,tokenVerifier, oidcIssuerKeys, samlProviderService, samlTrustEvaluator, delegationRequestService,- Clock.systemUTC());+ centralRootAccess, Clock.systemUTC());}StsQueryHandler(IamService iamService, AccountResolver accountResolver, RegionResolver regionResolver,@@ -99,6 +108,7 @@ public class StsQueryHandler {SAMLProviderService samlProviderService,SAMLTrustPolicyEvaluator samlTrustEvaluator,DelegationRequestService delegationRequestService,+ CentralRootAccess centralRootAccess,Clock clock) {this.iamService = iamService;this.accountResolver = accountResolver;@@ -111,6 +121,7 @@ public class StsQueryHandler {this.samlProviderService = samlProviderService;this.samlTrustEvaluator = samlTrustEvaluator;this.delegationRequestService = delegationRequestService;+ this.centralRootAccess = centralRootAccess;this.clock = clock;}@@ -127,6 +138,7 @@ public class StsQueryHandler {case "GetFederationToken" -> handleGetFederationToken(params);case "DecodeAuthorizationMessage" -> handleDecodeAuthorizationMessage(params);case "GetDelegatedAccessToken" -> handleGetDelegatedAccessToken(params);+ case "AssumeRoot" -> handleAssumeRoot(params);default -> AwsQueryResponse.error("UnsupportedOperation","Operation " + action + " is not supported by STS.", AwsNamespaces.STS, 400);};@@ -710,6 +722,187 @@ public class StsQueryHandler {AwsNamespaces.STS, result)).build();}+ /**+ * A privileged session on a member account: "Returns a set of short term credentials you can+ * use to perform privileged tasks on a member account in your organization." The session acts+ * as that account's root user, scoped by the task policy the request names, which is what the+ * guide means by "you must define TaskPolicyArn to scope the session to the privileged action+ * to be performed during the session".+ *+ * <p>Four refusals, each from a published sentence and each {@code AccessDenied} 403 because+ * the operation models only {@code RegionDisabled} and {@code ExpiredToken}: the caller must+ * be the management account or a delegated administrator for IAM, must not be root ("You+ * cannot use root user credentials to call sts:AssumeRoot"), must have {@code RootSessions}+ * enabled for the organization, and the target must be a member account other than the+ * management account, privileged tasks being what the management account does to members. Both+ * credentials this emulator reads as the account root are refused, so the caller is an IAM+ * user or role of that account. The+ * task policy is held to the five AWS publishes for it, by the {@code /root-task/} path of an+ * AWS managed policy rather than by a list of names, and anything else is a+ * {@code ValidationError}: no source gives a code for that one, so it is the shape every other+ * member violation answers here.+ *+ * <p>The global endpoint is refused when the request arrives on it, "The global endpoint is+ * not supported for AssumeRoot. You must send this request to a Regional AWS STS endpoint." A+ * request to a local host carries no such name, so there is nothing to refuse there.+ */+ private Response handleAssumeRoot(MultivaluedMap<String, String> params) {+ if (arrivedOnTheGlobalEndpoint()) {+ return AwsQueryResponse.error("ValidationError", "The global endpoint is not supported for"+ + " AssumeRoot. You must send this request to a Regional AWS STS endpoint.",+ AwsNamespaces.STS, 400);+ }+ Response validation = validateRequired(params, "TargetPrincipal", "TaskPolicyArn.arn");+ if (validation != null) {+ return validation;+ }+ String targetPrincipal = getParam(params, "TargetPrincipal");+ if (targetPrincipal.length() < 12 || targetPrincipal.length() > 2048) {+ String constraint = targetPrincipal.length() < 12+ ? "Member must have length greater than or equal to 12"+ : "Member must have length less than or equal to 2048";+ return AwsQueryResponse.error("ValidationError",+ SmithyValidationErrors.message(List.of("Value '" + targetPrincipal+ + "' at 'targetPrincipal' failed to satisfy constraint: " + constraint)),+ AwsNamespaces.STS, 400);+ }+ Response durationValidation = validateDurationSeconds(params, 0, 900);+ if (durationValidation != null) {+ return durationValidation;+ }+ Response tokenSizeValidation = validateMinimumSessionTokenSize(params);+ if (tokenSizeValidation != null) {+ return tokenSizeValidation;+ }+ String callerAccountId = regionResolver.getAccountId();+ Response rootCaller = refuseRootCredentials(callerAccountId);+ if (rootCaller != null) {+ return rootCaller;+ }+ RootAccessOrganization.Membership organization =+ centralRootAccess.privilegedSessionOrganization(callerAccountId);+ String targetAccountId = accountOf(targetPrincipal);+ if (targetAccountId == null || !organization.memberAccountIds().contains(targetAccountId)+ || organization.isManagementAccount(targetAccountId)) {+ return AwsQueryResponse.error("AccessDenied", "User: " + callerAccountId + " is not authorized to"+ + " perform: sts:AssumeRoot on " + targetPrincipal + " because it is not a member account"+ + " of the organization.", AwsNamespaces.STS, 403);+ }+ String taskPolicyArn = getParam(params, "TaskPolicyArn.arn");+ if (!namesARootTaskPolicy(taskPolicyArn)) {+ return AwsQueryResponse.error("ValidationError", "The task policy "+ + taskPolicyArn + " cannot scope a privileged session. Use one of the AWS managed"+ + " policies under " + ROOT_TASK_POLICY_PATH + ".", AwsNamespaces.STS, 400);+ }+ IamPolicy taskPolicy = iamService.getPolicy(taskPolicyArn);++ int durationSeconds = getIntParam(params, "DurationSeconds", MAX_ROOT_SESSION_SECONDS);+ Instant expiration = clock.instant().plusSeconds(durationSeconds);+ String accessKeyId = "ASIA" + randomId(16);+ String secretKey = randomSecret(40);+ String sessionToken = randomSecret(Math.max(200,+ getIntParam(params, "MinimumSessionTokenSize", 0)));+ // The session is the member account's root user, bounded by the task policy. The origin is+ // the member account too: the privileged task is performed there, not where it was asked for.+ iamService.registerSession(accessKeyId, secretKey, sessionToken,+ regionResolver.buildGlobalArn("iam", targetAccountId, "root"), expiration,+ taskPolicy.getVersions().get(taskPolicy.getDefaultVersionId()).getDocument(),+ targetAccountId);+ LOG.debugv("Privileged session for {0} opened by {1} under {2}", targetAccountId, callerAccountId,+ taskPolicy.getArn());++ String result = new XmlBuilder()+ .raw(credentialsXml(accessKeyId, secretKey, sessionToken, expiration))+ .elem("SessionTokenSize", String.valueOf(sessionToken.length()))+ .build();+ return Response.ok(AwsQueryResponse.envelope("AssumeRoot", AwsNamespaces.STS, result)).build();+ }++ /**+ * True when the ARN names one of the AWS managed policies a privileged session may be scoped+ * by. The member's own documentation is the list: "You must use one of following Amazon Web+ * Services managed policies to scope root session actions", naming the five that sit under+ * {@code /root-task/}. Whose policy it is counts as much as the path: a customer-managed+ * policy at the same path is the caller's own document, and installing one would leave the+ * session bounded by whatever that document says rather than by a privileged task.+ */+ private static boolean namesARootTaskPolicy(String arn) {+ if (!AwsManagedPolicies.isManagedPolicyArn(arn) || !AwsArnUtils.isArn(arn)) {+ return false;+ }+ return AwsArnUtils.parse(arn).resource().startsWith("policy" + ROOT_TASK_POLICY_PATH);+ }++ /**+ * {@code MinimumSessionTokenSize} is 0 to 4096 in the model, "The value must not exceed 4,096+ * bytes", and the size it asks for is materialized, so the bound is enforced rather than+ * clamped: a value outside it is the same {@code ValidationError} every other member violation+ * answers, and one that is no integer at all the same {@code InvalidParameterValue}+ * {@code DurationSeconds} gives.+ */+ private Response validateMinimumSessionTokenSize(MultivaluedMap<String, String> params) {+ String value = params.getFirst("MinimumSessionTokenSize");+ if (value == null) {+ return null;+ }+ int size;+ try {+ size = Integer.parseInt(value);+ } catch (NumberFormatException e) {+ return AwsQueryResponse.error("InvalidParameterValue", "Value " + value + " for parameter"+ + " MinimumSessionTokenSize is invalid. Reason: Must be an integer.",+ AwsNamespaces.STS, 400);+ }+ if (size < 0 || size > MAX_SESSION_TOKEN_SIZE) {+ String constraint = size < 0+ ? "Member must have value greater than or equal to 0"+ : "Member must have value less than or equal to " + MAX_SESSION_TOKEN_SIZE;+ return AwsQueryResponse.error("ValidationError",+ SmithyValidationErrors.message(List.of("Value '" + size+ + "' at 'minimumSessionTokenSize' failed to satisfy constraint: " + constraint)),+ AwsNamespaces.STS, 400);+ }+ return null;+ }++ /** The account a {@code TargetPrincipal} names, whether it is an account id or a principal ARN. */+ private static String accountOf(String targetPrincipal) {+ if (targetPrincipal.matches("\\d{12}")) {+ return targetPrincipal;+ }+ return AwsArnUtils.isArn(targetPrincipal) ? AwsArnUtils.parse(targetPrincipal).accountId() : null;+ }++ /**+ * "You cannot use root user credentials to call sts:AssumeRoot." Two credentials are the+ * account root here and neither may open a session. One resolves to a root ARN, which is how a+ * privileged session opening another is caught. The other is the bare 12-digit account-id key,+ * which {@code IamEnforcementFilter} reads as "floci's account-root principal, never an IAM+ * user's key": it resolves to no ARN at all, so the first test cannot see it, and refusing it+ * is what leaves the operation to an IAM user or role of the management account, which is the+ * caller AWS asks for.+ */+ private Response refuseRootCredentials(String callerAccountId) {+ String accessKeyId = callerAccessKeyId();+ boolean accountRootKey = accessKeyId != null && accessKeyId.equals(callerAccountId);+ String callerArn = accountRootKey ? null : iamService.resolveCallerArn(accessKeyId).orElse(null);+ if (!accountRootKey && (callerArn == null || !callerArn.endsWith(":root"))) {+ return null;+ }+ return AwsQueryResponse.error("AccessDenied", "Root user credentials cannot call sts:AssumeRoot."+ + " Call it as an IAM user or role with the sts:AssumeRoot permission.", AwsNamespaces.STS, 403);+ }++ /** True when the request arrived on the partition's global STS host rather than a Regional one. */+ private boolean arrivedOnTheGlobalEndpoint() {+ String host = headers == null ? null : headers.getHeaderString(HttpHeaders.HOST);+ if (host == null || host.isBlank()) {+ return false;+ }+ String name = host.split(":", 2)[0];+ return name.equalsIgnoreCase("sts." + AwsRegions.dnsSuffixFor(regionResolver.getRegion()));+ }+private Response handleDecodeAuthorizationMessage(MultivaluedMap<String, String> params) {Response validation = validateRequired(params, "EncodedMessage");if (validation != null) {diff --git a/src/main/java/io/github/hectorvent/floci/services/organizations/OrganizationsService.java b/src/main/java/io/github/hectorvent/floci/services/organizations/OrganizationsService.javaindex d6619faeb4..f2593a8850 100644--- a/src/main/java/io/github/hectorvent/floci/services/organizations/OrganizationsService.java+++ b/src/main/java/io/github/hectorvent/floci/services/organizations/OrganizationsService.java@@ -7,8 +7,10 @@ import com.fasterxml.jackson.databind.node.ObjectNode;import io.github.hectorvent.floci.config.EmulatorConfig;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.common.RegionResolver;+import io.github.hectorvent.floci.core.common.ServicePrincipals;import io.github.hectorvent.floci.core.storage.AccountAwareStorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.iam.RootAccessOrganization;import io.github.hectorvent.floci.services.iam.ScpProvider;import io.github.hectorvent.floci.services.organizations.model.CreateAccountStatus;import io.github.hectorvent.floci.services.organizations.model.Handshake;@@ -30,6 +32,7 @@ import java.time.temporal.ChronoUnit;import java.util.ArrayList;import java.util.Comparator;import java.util.LinkedHashMap;+import java.util.LinkedHashSet;import java.util.List;import java.util.Map;import java.util.Optional;@@ -53,7 +56,7 @@ import java.util.regex.Pattern;* @see <a href="https://docs.aws.amazon.com/organizations/latest/APIReference/Welcome.html">AWS Organizations API Reference</a>*/@ApplicationScoped-public class OrganizationsService implements ScpProvider {+public class OrganizationsService implements ScpProvider, RootAccessOrganization {private static final Logger LOG = Logger.getLogger(OrganizationsService.class);@@ -1405,6 +1408,31 @@ public class OrganizationsService implements ScpProvider {// ──────────────────────────── Collection helpers ────────────────────────────+ @Override+ public Optional<Membership> membershipOf(String accountId) {+ return findOrganizationForAccount(accountId).map(organization -> {+ Set<String> delegatedAdmins = new LinkedHashSet<>();+ Set<String> members = new LinkedHashSet<>();+ members.add(organization.getMasterAccountId());+ for (OrganizationAccount account : accountsIn(organization)) {+ members.add(account.getId());+ if (namesIam(account.getDelegatedServices().keySet())) {+ delegatedAdmins.add(account.getId());+ }+ }+ return new Membership(organization.getId(), organization.getMasterAccountId(),+ FEATURE_SET_ALL.equals(organization.getFeatureSet()),+ namesIam(organization.getEnabledServicePrincipals().keySet()),+ delegatedAdmins, members);+ });+ }++ /** Whether IAM is among these principals, legacy per-partition spellings folded in. */+ private static boolean namesIam(Set<String> principals) {+ return principals.stream()+ .anyMatch(principal -> IAM_SERVICE_PRINCIPAL.equals(ServicePrincipals.canonical(principal)));+ }+private List<OrganizationAccount> accountsIn(Organization organization) {return accounts.scanAllAccounts().stream().filter(account -> organization.getId().equals(account.getOrganizationId()))diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/CentralRootAccessTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/CentralRootAccessTest.javanew file mode 100644index 0000000000..59ccbdfc7b--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/CentralRootAccessTest.java@@ -0,0 +1,160 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.core.common.AwsException;+import jakarta.enterprise.inject.Instance;+import org.junit.jupiter.api.BeforeEach;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.function.Executable;++import java.util.List;+import java.util.Optional;+import java.util.Set;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.never;+import static org.mockito.Mockito.verify;+import static org.mockito.Mockito.when;++/**+ * The caller checks the reference models on the five centralized root features. Each refusal is a+ * shape botocore declares on those operations and no other, and the order they are asked in is+ * the order below: whether there is an organization, what it has enabled, then who is asking.+ */+class CentralRootAccessTest {++ private static final String ORGANIZATION = "o-rootaccess1";+ private static final String MANAGEMENT = "100000000001";+ private static final String DELEGATED_ADMIN = "100000000002";+ private static final String MEMBER = "100000000003";++ private IamService iamService;+ private RootAccessOrganization organizations;+ private CentralRootAccess rootAccess;++ @SuppressWarnings("unchecked")+ @BeforeEach+ void setUp() {+ iamService = mock(IamService.class);+ organizations = mock(RootAccessOrganization.class);+ Instance<RootAccessOrganization> instance = mock(Instance.class);+ when(instance.isResolvable()).thenReturn(true);+ when(instance.get()).thenReturn(organizations);+ rootAccess = new CentralRootAccess(iamService, instance);+ }++ private void organizationOf(String caller, boolean allFeatures, boolean trustedAccess) {+ when(organizations.membershipOf(caller)).thenReturn(Optional.of(+ new RootAccessOrganization.Membership(ORGANIZATION, MANAGEMENT, allFeatures, trustedAccess,+ Set.of(DELEGATED_ADMIN), Set.of(MANAGEMENT, DELEGATED_ADMIN, MEMBER))));+ }++ private static String codeOf(Executable call) {+ return assertThrows(AwsException.class, call).getErrorCode();+ }++ @Test+ void anAccountInNoOrganizationIsRefused() {+ when(organizations.membershipOf(MANAGEMENT)).thenReturn(Optional.empty());++ assertEquals("OrganizationNotFoundException", codeOf(() -> rootAccess.list(MANAGEMENT)));+ verify(iamService, never()).listOrganizationsFeatures();+ }++ @Test+ void anOrganizationWithoutAllFeaturesIsRefused() {+ organizationOf(MANAGEMENT, false, true);++ assertEquals("OrganizationNotInAllFeaturesModeException", codeOf(() -> rootAccess.list(MANAGEMENT)));+ }++ @Test+ void iamNeedsTrustedAccessInOrganizations() {+ organizationOf(MANAGEMENT, true, false);++ assertEquals("ServiceAccessNotEnabledException", codeOf(() -> rootAccess.list(MANAGEMENT)));+ }++ @Test+ void anOrdinaryMemberAccountCannotSeeOrMoveTheFeatures() {+ organizationOf(MEMBER, true, true);++ assertEquals("AccountNotManagementOrDelegatedAdministratorException",+ codeOf(() -> rootAccess.list(MEMBER)));+ assertEquals("AccountNotManagementOrDelegatedAdministratorException",+ codeOf(() -> rootAccess.enableRootSessions(MEMBER)));+ verify(iamService, never()).enableOrganizationsRootSessions();+ }++ /**+ * {@code CallerIsNotManagementAccount} is modeled on the two enable operations and on neither+ * disable one, so a delegated administrator may read the features and turn them off but not on.+ */+ @Test+ void aDelegatedAdministratorMayListAndDisableButNotEnable() {+ organizationOf(DELEGATED_ADMIN, true, true);+ when(iamService.listOrganizationsFeatures()).thenReturn(List.of(IamService.FEATURE_ROOT_SESSIONS));+ when(iamService.disableOrganizationsRootSessions()).thenReturn(List.of());++ assertEquals(List.of(IamService.FEATURE_ROOT_SESSIONS), rootAccess.list(DELEGATED_ADMIN).enabledFeatures());+ assertEquals(List.of(), rootAccess.disableRootSessions(DELEGATED_ADMIN).enabledFeatures());+ assertEquals("CallerIsNotManagementAccountException",+ codeOf(() -> rootAccess.enableRootSessions(DELEGATED_ADMIN)));+ assertEquals("CallerIsNotManagementAccountException",+ codeOf(() -> rootAccess.enableRootCredentialsManagement(DELEGATED_ADMIN)));+ verify(iamService, never()).enableOrganizationsRootSessions();+ }++ @Test+ void theFeatureSetIsAnsweredWithTheOrganizationItBelongsTo() {+ organizationOf(MANAGEMENT, true, true);+ when(iamService.enableOrganizationsRootSessions())+ .thenReturn(List.of(IamService.FEATURE_ROOT_SESSIONS));++ CentralRootAccess.Features features = rootAccess.enableRootSessions(MANAGEMENT);++ assertEquals(ORGANIZATION, features.organizationId());+ assertEquals(List.of(IamService.FEATURE_ROOT_SESSIONS), features.enabledFeatures());+ }++ /**+ * A privileged session needs the feature the guide asks for: "You have enabled centralized+ * root access in your organization", which is {@code EnableOrganizationsRootSessions}.+ */+ @Test+ void aPrivilegedSessionNeedsRootSessionsEnabled() {+ organizationOf(MANAGEMENT, true, true);+ when(iamService.listOrganizationsFeatures())+ .thenReturn(List.of(IamService.FEATURE_ROOT_CREDENTIALS));++ AwsException refused = assertThrows(AwsException.class,+ () -> rootAccess.privilegedSessionOrganization(MANAGEMENT));++ assertEquals("AccessDenied", refused.getErrorCode());+ assertEquals(403, refused.getHttpStatus());+ }++ @Test+ void aPrivilegedSessionAnswersTheOrganizationOnceItIsEnabled() {+ organizationOf(DELEGATED_ADMIN, true, true);+ when(iamService.listOrganizationsFeatures()).thenReturn(List.of(IamService.FEATURE_ROOT_SESSIONS));++ RootAccessOrganization.Membership organization =+ rootAccess.privilegedSessionOrganization(DELEGATED_ADMIN);++ assertEquals(ORGANIZATION, organization.organizationId());+ assertEquals(MANAGEMENT, organization.managementAccountId());+ }++ @Test+ void anAccountOutsideTheOrganizationCannotOpenAPrivilegedSession() {+ when(organizations.membershipOf(MEMBER)).thenReturn(Optional.empty());++ AwsException refused = assertThrows(AwsException.class,+ () -> rootAccess.privilegedSessionOrganization(MEMBER));++ assertEquals("AccessDenied", refused.getErrorCode());+ assertEquals(403, refused.getHttpStatus());+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamQueryHandlerTest.javaindex fad7003311..f13d33db18 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamQueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamQueryHandlerTest.java@@ -61,7 +61,7 @@ class IamQueryHandlerTest {"fabricated-key", null, Map.of())).thenReturn(certificate);when(service.getServerCertificate(CERTIFICATE_NAME)).thenReturn(certificate);when(service.listServerCertificates(null)).thenReturn(List.of(certificate));- IamQueryHandler handler = new IamQueryHandler(service, null, null, null, null, null, null, null, null);+ IamQueryHandler handler = new IamQueryHandler(service, null, null, null, null, null, null, null, null, null);MultivaluedMap<String, String> params = new MultivaluedHashMap<>();params.putSingle("ServerCertificateName", CERTIFICATE_NAME);@@ -90,7 +90,7 @@ class IamQueryHandlerTest {IamService service = mock(IamService.class);when(service.createRole(ROLE_NAME, "/", "{}", null, 3600, Map.of(), null)).thenReturn(role);when(service.getValidatedRole(ROLE_NAME)).thenReturn(role);- IamQueryHandler handler = new IamQueryHandler(service, null, null, null, null, null, null, null, null);+ IamQueryHandler handler = new IamQueryHandler(service, null, null, null, null, null, null, null, null, null);MultivaluedMap<String, String> params = new MultivaluedHashMap<>();params.putSingle("RoleName", ROLE_NAME);diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/StsAssumeRootEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/StsAssumeRootEnforcementIntegrationTest.javanew file mode 100644index 0000000000..f96d9c094a--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/StsAssumeRootEnforcementIntegrationTest.java@@ -0,0 +1,132 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.testing.EnforcementFixtures;+import io.github.hectorvent.floci.testing.OrganizationsRequests;+import io.github.hectorvent.floci.testing.PartitionCleanup;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.github.hectorvent.floci.testing.S3IamEnforcementProfile;+import io.quarkus.test.common.http.TestHTTPResource;+import io.quarkus.test.junit.QuarkusTest;+import io.quarkus.test.junit.TestProfile;+import io.restassured.response.ExtractableResponse;+import io.restassured.response.Response;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.extension.RegisterExtension;++import java.net.URI;+import java.util.UUID;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;++/**+ * What a privileged session may do, under IAM enforcement. The session is the member account's+ * root user, which no identity policy grants or denies, so the whole of the bound is the task+ * policy the request named: "you must define TaskPolicyArn to scope the session to the privileged+ * action to be performed during the session".+ *+ * <p>{@code IAMAuditRootUserCredentials} is the one used here. It denies every action it does not+ * name and then denies the ones it does on any resource but {@code arn:aws:iam::*:root}, so one+ * policy shows both halves of the scope: the audit reads it allows on the root user, and+ * everything else refused.+ */+@QuarkusTest+@TestProfile(S3IamEnforcementProfile.class)+class StsAssumeRootEnforcementIntegrationTest {++ private static final String MANAGEMENT = "777777777771";+ private static final String TASK_POLICY = "arn:aws:iam::aws:policy/root-task/IAMAuditRootUserCredentials";++ @TestHTTPResource("/")+ static URI baseUri;++ @RegisterExtension+ final PartitionCleanup cleanup = new PartitionCleanup();++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ @Test+ void aPrivilegedSessionMayAuditTheRootUserAndNothingElse() {+ String member = memberAccountWithRootSessions();+ ExtractableResponse<Response> session = privilegedSession(member, callerWithAssumeRoot());+ String accessKeyId = session.path("AssumeRootResponse.AssumeRootResult.Credentials.AccessKeyId");+ String sessionToken = session.path("AssumeRootResponse.AssumeRootResult.Credentials.SessionToken");++ // Allowed: the policy's first statement denies every action it does not name, and the+ // account summary is one it names, on no particular resource.+ privileged(accessKeyId, sessionToken, "GetAccountSummary")+ .when().post("/").then().statusCode(200);++ // Denied on any resource but the root user, which is the policy's second statement. The+ // audit reads it allows with no UserName name that root user here, since a root caller's+ // self-resource is its root ARN, but Floci keeps no user record for the root user, so+ // those calls answer NoSuchEntity rather than the credentials report AWS gives.+ privileged(accessKeyId, sessionToken, "GetUser")+ .formParam("UserName", "someone-else")+ .when().post("/").then().statusCode(403)+ .body("ErrorResponse.Error.Code", equalTo("AccessDenied"));+ // And denied outright for an action the policy does not name, which is its first.+ privileged(accessKeyId, sessionToken, "CreateUser")+ .formParam("UserName", "made-by-a-privileged-session")+ .when().post("/").then().statusCode(403)+ .body("ErrorResponse.Error.Code", equalTo("AccessDenied"));+ }++ /** An organization with one member account and {@code RootSessions} enabled. */+ private String memberAccountWithRootSessions() {+ OrganizationsRequests.request(MANAGEMENT, "CreateOrganization", "{\"FeatureSet\":\"ALL\"}")+ .when().post("/").then().statusCode(200);+ String member = OrganizationsRequests.request(MANAGEMENT, "CreateAccount",+ "{\"Email\":\"[email protected]\",\"AccountName\":\"Audit\"}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("CreateAccountStatus.AccountId");+ OrganizationsRequests.request(MANAGEMENT, "EnableAWSServiceAccess",+ "{\"ServicePrincipal\":\"iam.amazonaws.com\"}")+ .when().post("/").then().statusCode(200);+ given().header("Authorization", EnforcementFixtures.auth(MANAGEMENT, "iam"))+ .formParam("Action", "EnableOrganizationsRootSessions")+ .formParam("Version", "2010-05-08")+ .when().post("/").then().statusCode(200);+ return member;+ }++ /**+ * An IAM user of the management account allowed {@code sts:AssumeRoot}, which is the caller the+ * guide's prerequisites ask for. The account root cannot be it, AssumeRoot refusing root+ * credentials, so under enforcement the permission is granted to somebody rather than+ * inherited from the account's own allow-all.+ */+ private String callerWithAssumeRoot() {+ String userName = "root-session-caller-" + UUID.randomUUID();+ String authorization = EnforcementFixtures.auth(MANAGEMENT, "iam");+ String accessKeyId = EnforcementFixtures+ .createUser(cleanup, baseUri.getPort(), authorization, userName).accessKeyId();+ EnforcementFixtures.putUserPolicy(baseUri.getPort(), authorization, userName, "assume-root",+ "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\":\"Allow\","+ + "\"Action\":\"sts:AssumeRoot\",\"Resource\":\"*\"}]}");+ return accessKeyId;+ }++ private ExtractableResponse<Response> privilegedSession(String member, String callerKey) {+ return given()+ .header("Authorization", EnforcementFixtures.auth(callerKey, "sts"))+ .formParam("Action", "AssumeRoot")+ .formParam("Version", "2011-06-15")+ .formParam("TargetPrincipal", member)+ .formParam("TaskPolicyArn.arn", TASK_POLICY)+ .when().post("/").then().statusCode(200).extract();+ }++ private static RequestSpecification privileged(String accessKeyId, String sessionToken, String action) {+ return given()+ .header("Authorization", EnforcementFixtures.auth(accessKeyId, "iam"))+ .header("X-Amz-Security-Token", sessionToken)+ .formParam("Action", action)+ .formParam("Version", "2010-05-08");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/StsAssumeRootIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/StsAssumeRootIntegrationTest.javanew file mode 100644index 0000000000..8777fb3a74--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/services/iam/StsAssumeRootIntegrationTest.java@@ -0,0 +1,308 @@+package io.github.hectorvent.floci.services.iam;++import io.github.hectorvent.floci.testing.EnforcementFixtures;+import io.github.hectorvent.floci.testing.OrganizationsRequests;+import io.github.hectorvent.floci.testing.RestAssuredJsonUtils;+import io.quarkus.test.junit.QuarkusTest;+import io.restassured.specification.RequestSpecification;+import org.junit.jupiter.api.BeforeAll;+import org.junit.jupiter.api.MethodOrderer;+import org.junit.jupiter.api.Order;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestInstance;+import org.junit.jupiter.api.TestMethodOrder;++import static io.restassured.RestAssured.given;+import static org.hamcrest.Matchers.equalTo;+import static org.hamcrest.Matchers.notNullValue;+import static org.hamcrest.Matchers.startsWith;++/**+ * Centralized root access end to end: the management account turns the feature on, a delegated+ * administrator sees the same organization-wide answer, and a privileged session acts as a member+ * account's root user scoped to the task policy it names.+ *+ * <p>Floci resolves a 12-digit access key id straight to an account id, so each request carries a+ * SigV4-shaped {@code Authorization} header naming the calling account. The accounts here are+ * their own, so this class never contends with another over one organization.+ */+@QuarkusTest+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)+@TestInstance(TestInstance.Lifecycle.PER_CLASS)+class StsAssumeRootIntegrationTest {++ private static final String MANAGEMENT = "666666666661";+ private static final String OUTSIDER = "666666666669";+ private static final String UNRELATED_ACCOUNT = "666666666668";+ private static final String TASK_POLICY = "arn:aws:iam::aws:policy/root-task/S3UnlockBucketPolicy";++ private String organizationId;+ private String memberAccount;+ private String delegatedAdmin;+ private String managementKey;+ private String adminKey;+ private String outsiderKey;++ @BeforeAll+ static void configureRestAssured() {+ RestAssuredJsonUtils.configureAwsContentTypes();+ }++ /**+ * An IAM user of {@code accountId} holding one access key. AssumeRoot refuses the account root,+ * both the key that resolves to its ARN and the bare account-id key floci reads as that+ * principal, so every caller here is a user of the account rather than the account itself.+ */+ private static String accessKeyFor(String accountId, String userName) {+ iam(accountId, "CreateUser").formParam("UserName", userName)+ .when().post("/").then().statusCode(200);+ return iam(accountId, "CreateAccessKey").formParam("UserName", userName)+ .when().post("/").then().statusCode(200)+ .extract().path("CreateAccessKeyResponse.CreateAccessKeyResult.AccessKey.AccessKeyId");+ }++ private static RequestSpecification iam(String accountId, String action) {+ return given()+ .header("Authorization", EnforcementFixtures.auth(accountId, "iam"))+ .formParam("Action", action)+ .formParam("Version", "2010-05-08");+ }++ private static RequestSpecification assumeRoot(String accessKeyId, String targetPrincipal,+ String taskPolicyArn) {+ return given()+ .header("Authorization", EnforcementFixtures.auth(accessKeyId, "sts"))+ .formParam("Action", "AssumeRoot")+ .formParam("Version", "2011-06-15")+ .formParam("TargetPrincipal", targetPrincipal)+ .formParam("TaskPolicyArn.arn", taskPolicyArn);+ }++ @Test+ @Order(1)+ void anOrganizationWithAMemberAndADelegatedAdministrator() {+ organizationId = OrganizationsRequests.request(MANAGEMENT, "CreateOrganization", "{\"FeatureSet\":\"ALL\"}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("Organization.Id");++ memberAccount = OrganizationsRequests.request(MANAGEMENT, "CreateAccount",+ "{\"Email\":\"[email protected]\",\"AccountName\":\"Member\"}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("CreateAccountStatus.AccountId");+ delegatedAdmin = OrganizationsRequests.request(MANAGEMENT, "CreateAccount",+ "{\"Email\":\"[email protected]\",\"AccountName\":\"IamAdmin\"}")+ .when().post("/").then().statusCode(200)+ .extract().jsonPath().getString("CreateAccountStatus.AccountId");++ OrganizationsRequests.request(MANAGEMENT, "EnableAWSServiceAccess",+ "{\"ServicePrincipal\":\"iam.amazonaws.com\"}")+ .when().post("/").then().statusCode(200);+ OrganizationsRequests.request(MANAGEMENT, "RegisterDelegatedAdministrator",+ "{\"AccountId\":\"" + delegatedAdmin + "\",\"ServicePrincipal\":\"iam.amazonaws.com\"}")+ .when().post("/").then().statusCode(200);++ managementKey = accessKeyFor(MANAGEMENT, "root-session-caller");+ adminKey = accessKeyFor(delegatedAdmin, "delegated-session-caller");+ outsiderKey = accessKeyFor(OUTSIDER, "outsider-session-caller");+ }++ /** "You have enabled centralized root access in your organization" is a prerequisite, not a default. */+ @Test+ @Order(2)+ void aPrivilegedSessionIsRefusedBeforeRootSessionsIsEnabled() {+ assumeRoot(managementKey, memberAccount, TASK_POLICY)+ .when().post("/").then().statusCode(403)+ .body("ErrorResponse.Error.Code", equalTo("AccessDenied"));+ }++ @Test+ @Order(3)+ void theManagementAccountEnablesRootSessions() {+ iam(MANAGEMENT, "EnableOrganizationsRootSessions")+ .when().post("/").then().statusCode(200)+ .body("EnableOrganizationsRootSessionsResponse.EnableOrganizationsRootSessionsResult"+ + ".OrganizationId", equalTo(organizationId))+ .body("EnableOrganizationsRootSessionsResponse.EnableOrganizationsRootSessionsResult"+ + ".EnabledFeatures.member", equalTo("RootSessions"));+ }++ /** The feature set is the organization's, so the delegated administrator reads what was enabled. */+ @Test+ @Order(4)+ void aDelegatedAdministratorSeesTheOrganizationsOwnFeatureSet() {+ iam(delegatedAdmin, "ListOrganizationsFeatures")+ .when().post("/").then().statusCode(200)+ .body("ListOrganizationsFeaturesResponse.ListOrganizationsFeaturesResult.OrganizationId",+ equalTo(organizationId))+ .body("ListOrganizationsFeaturesResponse.ListOrganizationsFeaturesResult"+ + ".EnabledFeatures.member", equalTo("RootSessions"));+ }++ @Test+ @Order(5)+ void onlyTheRightCallerMayMoveTheFeatures() {+ iam(delegatedAdmin, "EnableOrganizationsRootCredentialsManagement")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("CallerIsNotManagementAccountException"));+ iam(memberAccount, "ListOrganizationsFeatures")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code",+ equalTo("AccountNotManagementOrDelegatedAdministratorException"));+ iam(OUTSIDER, "ListOrganizationsFeatures")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("OrganizationNotFoundException"));+ }++ @Test+ @Order(6)+ void aPrivilegedSessionActsAsTheMemberAccountRoot() {+ String accessKeyId = assumeRoot(managementKey, memberAccount, TASK_POLICY)+ .formParam("DurationSeconds", "900")+ .when().post("/").then().statusCode(200)+ .body("AssumeRootResponse.AssumeRootResult.Credentials.AccessKeyId", startsWith("ASIA"))+ .body("AssumeRootResponse.AssumeRootResult.Credentials.Expiration", notNullValue())+ .body("AssumeRootResponse.AssumeRootResult.SessionTokenSize", notNullValue())+ .extract().path("AssumeRootResponse.AssumeRootResult.Credentials.AccessKeyId");+ String sessionToken = assumeRoot(managementKey, memberAccount, TASK_POLICY)+ .when().post("/").then().statusCode(200)+ .extract().path("AssumeRootResponse.AssumeRootResult.Credentials.SessionToken");++ given()+ .header("Authorization", EnforcementFixtures.auth(accessKeyId, "sts"))+ .header("X-Amz-Security-Token", sessionToken)+ .formParam("Action", "GetCallerIdentity")+ .formParam("Version", "2011-06-15")+ .when().post("/").then().statusCode(200)+ .body("GetCallerIdentityResponse.GetCallerIdentityResult.Account", equalTo(memberAccount))+ .body("GetCallerIdentityResponse.GetCallerIdentityResult.Arn",+ equalTo("arn:aws:iam::" + memberAccount + ":root"));+ }++ @Test+ @Order(7)+ void aDelegatedAdministratorMayOpenOneToo() {+ assumeRoot(adminKey, memberAccount, TASK_POLICY)+ .when().post("/").then().statusCode(200)+ .body("AssumeRootResponse.AssumeRootResult.Credentials.AccessKeyId", startsWith("ASIA"));+ }++ @Test+ @Order(8)+ void theCallerTheTargetAndTheTaskPolicyAreAllChecked() {+ assumeRoot(outsiderKey, memberAccount, TASK_POLICY)+ .when().post("/").then().statusCode(403)+ .body("ErrorResponse.Error.Code", equalTo("AccessDenied"));+ assumeRoot(managementKey, UNRELATED_ACCOUNT, TASK_POLICY)+ .when().post("/").then().statusCode(403)+ .body("ErrorResponse.Error.Code", equalTo("AccessDenied"));+ // Privileged tasks are what the management account performs on members, not on itself.+ assumeRoot(managementKey, MANAGEMENT, TASK_POLICY)+ .when().post("/").then().statusCode(403)+ .body("ErrorResponse.Error.Code", equalTo("AccessDenied"));+ assumeRoot(managementKey, memberAccount, "arn:aws:iam::aws:policy/AdministratorAccess")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));+ assumeRoot(managementKey, memberAccount, TASK_POLICY)+ .formParam("DurationSeconds", "901")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));+ given()+ .header("Authorization", EnforcementFixtures.auth(managementKey, "sts"))+ .formParam("Action", "AssumeRoot")+ .formParam("Version", "2011-06-15")+ .formParam("TaskPolicyArn.arn", TASK_POLICY)+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));+ }++ /**+ * "The global endpoint is not supported for AssumeRoot. You must send this request to a+ * Regional AWS STS endpoint." Floci can only see that when the request names the global host,+ * which is why the refusal is on the host rather than on the signing region.+ */+ @Test+ @Order(9)+ void theGlobalEndpointIsRefusedWhenTheRequestArrivesOnIt() {+ assumeRoot(managementKey, memberAccount, TASK_POLICY)+ .header("Host", "sts.amazonaws.com")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));+ }++ /** The five task policies the guide names all live under the one path the check reads. */+ @Test+ @Order(10)+ void everyTaskPolicyTheGuideNamesIsUsable() {+ for (String policy : new String[] {"IAMAuditRootUserCredentials", "IAMCreateRootUserPassword",+ "IAMDeleteRootUserCredentials", "S3UnlockBucketPolicy", "SQSUnlockQueuePolicy"}) {+ assumeRoot(managementKey, memberAccount, "arn:aws:iam::aws:policy/root-task/" + policy)+ .when().post("/").then().statusCode(200)+ .body("AssumeRootResponse.AssumeRootResult.Credentials.SessionToken", notNullValue());+ }+ iam(MANAGEMENT, "ListOrganizationsFeatures")+ .when().post("/").then().statusCode(200)+ .body("ListOrganizationsFeaturesResponse.ListOrganizationsFeaturesResult"+ + ".EnabledFeatures.member", equalTo("RootSessions"));+ }++ /**+ * A customer-managed policy can carry the {@code /root-task/} path as easily as AWS's own, so+ * whose policy it is decides and not only where it sits: the model names five AWS managed+ * policies, and a document of the caller's own would scope the session to whatever it allows.+ */+ @Test+ @Order(11)+ void onlyAwsOwnRootTaskPoliciesCanScopeASession() {+ String ownPolicy = iam(MANAGEMENT, "CreatePolicy")+ .formParam("PolicyName", "LooksLikeATaskPolicy")+ .formParam("Path", "/root-task/")+ .formParam("PolicyDocument", "{\"Version\":\"2012-10-17\",\"Statement\":[{\"Effect\""+ + ":\"Allow\",\"Action\":\"*\",\"Resource\":\"*\"}]}")+ .when().post("/").then().statusCode(200)+ .extract().path("CreatePolicyResponse.CreatePolicyResult.Policy.Arn");++ assumeRoot(managementKey, memberAccount, ownPolicy)+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));+ }++ /**+ * {@code MinimumSessionTokenSize} is 0 to 4096 in the model, "The value must not exceed 4,096+ * bytes", and the size it asks for is the size issued, so it is held to that bound rather than+ * clamped to it.+ */+ @Test+ @Order(12)+ void theMinimumSessionTokenSizeIsHeldToTheBoundTheModelDeclares() {+ assumeRoot(managementKey, memberAccount, TASK_POLICY)+ .formParam("MinimumSessionTokenSize", "4097")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));+ assumeRoot(managementKey, memberAccount, TASK_POLICY)+ .formParam("MinimumSessionTokenSize", "-1")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("ValidationError"));+ assumeRoot(managementKey, memberAccount, TASK_POLICY)+ .formParam("MinimumSessionTokenSize", "two thousand")+ .when().post("/").then().statusCode(400)+ .body("ErrorResponse.Error.Code", equalTo("InvalidParameterValue"));+ assumeRoot(managementKey, memberAccount, TASK_POLICY)+ .formParam("MinimumSessionTokenSize", "1024")+ .when().post("/").then().statusCode(200)+ .body("AssumeRootResponse.AssumeRootResult.SessionTokenSize", equalTo("1024"));+ }++ /**+ * "You cannot use root user credentials to call sts:AssumeRoot." The bare account-id key is+ * floci's own account-root principal, which {@code IamEnforcementFilter} says in as many words, so it+ * is refused here as the credential it stands for even though it resolves to no ARN.+ */+ @Test+ @Order(13)+ void theAccountRootCannotOpenAPrivilegedSession() {+ assumeRoot(MANAGEMENT, memberAccount, TASK_POLICY)+ .when().post("/").then().statusCode(403)+ .body("ErrorResponse.Error.Code", equalTo("AccessDenied"))+ .body("ErrorResponse.Error.Message", startsWith("Root user credentials cannot call"));+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.javaindex a6f51f17a3..5113348e95 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/StsQueryHandlerTest.java@@ -107,6 +107,7 @@ class StsQueryHandlerTest {mock(SAMLProviderService.class),mock(SAMLTrustPolicyEvaluator.class),delegation,+ mock(CentralRootAccess.class),clock);}@@ -661,7 +662,7 @@ class StsQueryHandlerTest {StsQueryHandler handler = new StsQueryHandler(iamService, mock(AccountResolver.class),new RegionResolver(REGION, "000000000000"), config, mock(AssumeRolePolicyEvaluator.class),trust, verifier, keys, mock(SAMLProviderService.class), mock(SAMLTrustPolicyEvaluator.class),- mock(DelegationRequestService.class));+ mock(DelegationRequestService.class), mock(CentralRootAccess.class));MultivaluedMap<String, String> params = new MultivaluedHashMap<>();params.putSingle("RoleArn", requestedRoleArn);params.putSingle("RoleSessionName", "app");diff --git a/src/test/java/io/github/hectorvent/floci/testing/OrganizationsRequests.java b/src/test/java/io/github/hectorvent/floci/testing/OrganizationsRequests.javanew file mode 100644index 0000000000..71826f21c5--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/testing/OrganizationsRequests.java@@ -0,0 +1,27 @@+package io.github.hectorvent.floci.testing;++import io.restassured.specification.RequestSpecification;++import static io.restassured.RestAssured.given;++/**+ * Organizations calls over its JSON 1.1 wire, signed as the calling account the way+ * {@link EnforcementFixtures#auth} signs every other fixture here.+ */+public final class OrganizationsRequests {++ private static final String CONTENT_TYPE = "application/x-amz-json-1.1";+ private static final String TARGET_PREFIX = "AWSOrganizationsV20161128.";++ private OrganizationsRequests() {+ }++ /** One call, named by its action, carrying {@code body} as its payload. */+ public static RequestSpecification request(String accountId, String action, String body) {+ return given()+ .header("Authorization", EnforcementFixtures.auth(accountId, "organizations"))+ .header("X-Amz-Target", TARGET_PREFIX + action)+ .contentType(CONTENT_TYPE)+ .body(body);+ }+}