Light, fluffy, and always free - The AWS Local Emulator alternative
fix(iam): check iam:PassRole from a table generated from the Service Reference (#6422)
Priamo Germosen1276a8857f68
diff --git a/.github/workflows/iam-data-drift.yml b/.github/workflows/iam-data-drift.ymlindex ec4b6b2b23..a2ddee2647 100644--- a/.github/workflows/iam-data-drift.yml+++ b/.github/workflows/iam-data-drift.yml@@ -1,8 +1,9 @@name: IAM Data Drift-# Checks the three vendored files that come from AWS's live service reference rather than from a+# Checks the four vendored files that come from AWS's live service reference rather than from a# pinned dependency: the IAM service namespace list, the map of which resource each IAM action is-# authorized against, and the map of operations AWS authorizes as an action of another name. That+# authorized against, the map of operations AWS authorizes as an action of another name, and the+# table of the operations that pass a role and the services they pass it to. That# needs the live service reference index, so unlike every other check here it can# fail without anything in the repository having changed: an AWS outage, or a namespace AWS has# retired. It therefore runs on its own, never as part of a job that ordinary changes trigger.@@ -36,6 +37,9 @@ on:- 'src/main/resources/aws/iam-authorized-actions.json'- 'tools/aws/regen_iam_authorized_actions.py'- 'tools/aws/test_regen_iam_authorized_actions.py'+ - 'src/main/resources/aws/iam-passed-roles.json'+ - 'tools/aws/regen_iam_passed_roles.py'+ - 'tools/aws/test_regen_iam_passed_roles.py'- '.github/workflows/iam-data-drift.yml'schedule:# Mondays at 06:00 UTC, before the working week rather than during it.diff --git a/Makefile b/Makefileindex bde7e44d74..d3f5676475 100644--- a/Makefile+++ b/Makefile@@ -64,7 +64,8 @@ PREFIX ?= $(HOME)/.localiam-action-resources-sync iam-action-resources-check iam-action-resources-verify \iam-action-resources-test iam-authorized-actions-sync iam-authorized-actions-check \cfn-property-types-sync cfn-property-types-check cfn-property-types-verify cfn-property-types-test \- iam-authorized-actions-verify iam-authorized-actions-test iam-data-verify+ iam-authorized-actions-verify iam-authorized-actions-test iam-passed-roles-sync iam-passed-roles-check \+ iam-passed-roles-verify iam-passed-roles-test iam-data-verifyhelp: ## List the targets below@grep -hE '^[a-zA-Z_-]+:.*?## ' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf " %-14s %s\n", $$1, $$2}'@@ -305,6 +306,7 @@ aws-data-check: ## CI gate: the vendored AWS data must match a fresh generationecho " Run 'make aws-data-sync' with local/aws checked out and commit the result."; \exit 1; \}+ @$(MAKE) --no-print-directory iam-passed-roles-checkaws-data-test: ## Run the AWS data generators' unit tests$(PYTHON) -m pytest tools/aws -q@@ -365,11 +367,12 @@ iam-data-verify: ## CI gate (online): every vendored IAM file must still match A@# Both halves run even when the first fails, so one file's drift cannot hide the other's@# state. Sequential steps in CI stop at the first failure, which once left the action@# resource gate unexercised while the namespace list was stale.- @namespaces=0; actions=0; authorized=0; \+ @namespaces=0; actions=0; authorized=0; passed=0; \$(MAKE) --no-print-directory iam-namespaces-verify || namespaces=$$?; \$(MAKE) --no-print-directory iam-action-resources-verify || actions=$$?; \$(MAKE) --no-print-directory iam-authorized-actions-verify || authorized=$$?; \- if [ $$namespaces -ne 0 ] || [ $$actions -ne 0 ] || [ $$authorized -ne 0 ]; then \+ $(MAKE) --no-print-directory iam-passed-roles-verify || passed=$$?; \+ if [ $$namespaces -ne 0 ] || [ $$actions -ne 0 ] || [ $$authorized -ne 0 ] || [ $$passed -ne 0 ]; then \echo ""; \echo "error: vendored IAM data does not match upstream:"; \if [ $$namespaces -ne 0 ]; then \@@ -381,6 +384,9 @@ iam-data-verify: ## CI gate (online): every vendored IAM file must still match Aif [ $$authorized -ne 0 ]; then \echo " the map of operations to their IAM actions, see its message above"; \fi; \+ if [ $$passed -ne 0 ]; then \+ echo " the table of the roles operations pass, see its message above"; \+ fi; \exit 1; \fi@@ -414,6 +420,34 @@ iam-authorized-actions-verify: ## CI gate (online): every vendored operation musiam-authorized-actions-test: ## Run the IAM authorized-action generator's unit tests$(PYTHON) -m pytest tools/aws/test_regen_iam_authorized_actions.py -q+iam-passed-roles-sync: ## Regenerate src/main/resources/aws/iam-passed-roles.json from AWS and botocore (commit the result)+ $(PYTHON) tools/aws/regen_iam_passed_roles.py++iam-passed-roles-check: ## CI gate (offline): every vendored role member must be what the pinned botocore gives+ @$(PYTHON) tools/aws/regen_iam_passed_roles.py --check || { \+ echo ""; \+ echo "error: src/main/resources/aws/iam-passed-roles.json is malformed or out of date."; \+ echo " Run 'make iam-passed-roles-sync' and commit the result."; \+ exit 1; \+ }++iam-passed-roles-verify: ## CI gate (online): every vendored operation must still pass a role as AWS says+ @$(PYTHON) tools/aws/regen_iam_passed_roles.py --verify; status=$$?; \+ if [ $$status -eq 2 ]; then \+ echo ""; \+ echo "error: could not reach AWS's service reference, so nothing was verified."; \+ exit 1; \+ elif [ $$status -ne 0 ]; then \+ echo ""; \+ echo "error: the vendored table reads a role from an operation AWS does not pass it from,"; \+ echo " or checks it for a service AWS does not pass it to."; \+ echo " Run 'make iam-passed-roles-sync' and commit the result."; \+ exit 1; \+ fi++iam-passed-roles-test: ## Run the IAM passed role generator's unit tests+ $(PYTHON) -m pytest tools/aws/test_regen_iam_passed_roles.py -q+cfn-property-types-sync: ## Regenerate src/main/resources/aws/cfn-property-types.json from AWS's resource schemas (commit the result)$(PYTHON) tools/aws/regen_cfn_property_types.pydiff --git a/docs/services/iam.md b/docs/services/iam.mdindex cd5711cc83..3d6b901f48 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -1526,8 +1526,8 @@ role each passes:`targetRoleArn`, which the association's role assumes. `CreateAccessEntry` passes `principalArn`to `ec2.amazonaws.com` when its `type` is `EC2_LINUX` or `EC2_WINDOWS`: "If you create an accessentry with type EC2_LINUX or EC2_WINDOWS, the IAM principal creating the access entry must have- the iam:PassRole permission." AWS also checks it for `CreateCapability`, `UpdateCapability`,- `RegisterCluster` and `UpdateClusterConfig`, which Floci does not serve.+ the iam:PassRole permission." `CreateCapability`, `UpdateCapability` and `RegisterCluster`, which+ Floci does not serve, are checked from the table below.- **CloudFormation:** `CreateStack`, `UpdateStack`, `DeleteStack`, `CreateChangeSet` and`ContinueUpdateRollback` pass `RoleARN` to `cloudformation.amazonaws.com` when the request namesone. `CreateStackSet` and `UpdateStackSet` pass `AdministrationRoleARN`, or, for a self-managed@@ -1586,8 +1586,57 @@ holds it. Redshift takes a role only under the ARN IAM holds it under, path inclon the ARN as the request names it covers the role `COPY`, `UNLOAD` and Spectrum then use. The RDSuser guide has the Enhanced Monitoring role checked: "The user that enables Enhanced Monitoring mustbe granted the PassRole permission." Removing a role from an RDS instance or cluster is checked as-adding one is, since the Service Reference lists `iam:PassRole` for both. The role parameters of-other services are not checked yet.+adding one is, since the Service Reference lists `iam:PassRole` for both.++Every other operation the Service Reference lists with `iam:PassRole`, in the services Floci serves+over the JSON and Query protocols and Smithy RPC v2 CBOR and in the REST services whose routes are+authorized as operations, is checked from a table generated from the Service Reference and+botocore's models, `src/main/resources/aws/iam-passed-roles.json`. A request member names a role+when its name ends in `Role`, `RoleArn` or `RoleName` (or a plural, or one of those followed by+`Update` or `Override`) and it holds a string, or a list or map of them; it is read from a JSON or+CBOR body or from Query form parameters, in either list form, and its role is passed to the service+the Service Reference names. That covers Athena, CloudTrail, CloudWatch metric streams (to+`streams.metrics.cloudwatch.amazonaws.com`), CodeBuild, CodeDeploy, CodePipeline, Cognito, Config,+DataSync, ECR, Firehose, Glue, Kinesis Analytics, CloudWatch Logs, SageMaker, Secrets Manager,+Budgets actions, SES, SSM, Service Catalog, SWF, Textract, Transcribe and Transfer Family, among+others. The table lists an operation whether or not Floci serves it, so one Floci serves later is+checked from the start; one it does not serve answers `AccessDenied` rather than its usual error+when the caller may not pass the role.+- A member whose documentation says it takes a role by name, as a Glue job's `Role` and a CodeBuild+ build's `serviceRoleOverride` do, is checked on the ARN IAM holds the role under, path included,+ or, for a role IAM does not hold, the ARN the name gives.+- A role the Service Reference passes to no named service, as it does Cognito's group, user pool and+ identity pool roles, is checked with no `iam:PassedToService`, so a grant conditioned on that key+ does not cover it.+- Members that name no role passed to the service are left out: the roles a Budgets IAM action+ attaches a policy to, a CodePipeline action's `roleArn`, which the pipeline's role assumes, the+ execution role of each SSM target account, the roles a Glue job's code-generated nodes assume with+ STS, a role a Redshift cluster already holds, and Firehose's Snowflake role.+- Members the rule does not see are added: a Cognito user pool's SMS caller roles, a Glue+ connection's `ROLE_ARN` property ("The role to be used for running queries"), the role that+ defines a Glue view, `TableInput.ViewDefinition.Definer` (Lake Formation's view prerequisites ask+ for "The iam:PassRole permission for AWS Glue and Lake Formation"), and the Service Catalog+ `AssumeRole` and `LAUNCH_ROLE` keys of a service action's definition and a provisioned product's+ properties.+- Some operations are read by hand instead. SNS names its roles in attributes: a topic's+ `<ENDPOINT>SuccessFeedbackRoleArn` and `<ENDPOINT>FailureFeedbackRoleArn`, which "are used to give+ Amazon SNS write access to use CloudWatch Logs on your behalf", a platform application's+ `SuccessFeedbackRoleArn` and `FailureFeedbackRoleArn`, a Firehose subscription's+ `SubscriptionRoleArn` and the SMS `DeliveryStatusIAMRole`, read as the SNS handlers read the map.+ A CloudWatch Logs subscription filter policy names its `RoleArn` in its document. A Service+ Catalog launch constraint names its role in its `Parameters` document, by `RoleArn` or by+ `LocalRoleName`, which is checked on the ARN IAM holds the role under, and an update goes by the+ type of the constraint it changes. The type is matched in any case, since Floci keeps it as given.+ An SWF decision is read from the attributes its `decisionType` names.+- Not read: an operation whose request names no role (SSM `CreateDocument`, for one); one whose role+ is a parameter of the runbook it runs (SSM `StartAutomationExecution`, Config+ `PutRemediationConfigurations`); one the Service Reference passes roles from to several services+ without saying which member goes where (EMR `RunJobFlow`, whose `JobFlowRole` also names an+ instance profile, EKS `UpdateClusterConfig`, CloudWatch Logs `CreateImportTask`, SageMaker+ `CreateTrainingSession`); and one whose body is XML (S3 `PutBucketReplication`). EC2's+ `RequestSpotFleet` names its roles in EC2's own protocol, one of them as an instance profile. The+ REST services whose routes no rule maps yet, and API Gateway, which is authorized by HTTP method,+ are not read either.A request that names its operation, in a Query `Action`, an `X-Amz-Target` header or a Smithy RPC v2path (`/service/<service>/operation/<operation>`), is authorized as the action AWS checks for that@@ -1713,8 +1762,10 @@ policy it creates, checked against `*` like `logs:PutAccountPolicy` itself: `logfor `DATA_PROTECTION_POLICY`, `logs:PutSubscriptionFilter` for `SUBSCRIPTION_FILTER_POLICY`,`logs:PutTransformer` for `TRANSFORMER_POLICY`, `logs:PutIndexPolicy` for `FIELD_INDEX_POLICY` and`logs:PutMetricExtractionPolicy` for `METRIC_EXTRACTION_POLICY`. Without it the request is refused with-`AccessDeniedException` and no policy is stored. The `iam:PassRole` a subscription filter policy with a-`RoleArn` also needs is not checked.+`AccessDeniedException` and no policy is stored. A subscription filter policy whose document names a+`RoleArn` also needs `iam:PassRole` on it for `logs.amazonaws.com`: "To perform a PutAccountPolicy+subscription filter operation for any destination except a Lambda function, you must also have the+iam:PassRole permission."`DescribeAccountPolicies` likewise needs the read action for the type it lists:`logs:GetDataProtectionPolicy`, `logs:DescribeSubscriptionFilters`, `logs:GetTransformer` or`logs:DescribeIndexPolicies`. Its reference names none for `METRIC_EXTRACTION_POLICY`, which needs onlydiff --git a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.javaindex a621af0cbc..7d834c6cb9 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/IamEnforcementFilter.java@@ -908,10 +908,11 @@ public class IamEnforcementFilter implements ContainerRequestFilter {/*** A request that passes a role to a service also needs {@code iam:PassRole} on that role (see* {@link PassedRoles}), checked as the caller with {@code iam:PassedToService} naming the- * service and the keys that say who is calling, which {@code callerArns} writes when it is known.- * What a request names that holds roles, an instance profile, a launch template or a task- * definition, is looked up in the request's account, as the service resolves it; one that does not- * exist passes nothing, and the operation reports it. Returns true when the request was aborted.+ * service, when AWS's Service Reference names one, and the keys that say who is calling, which+ * {@code callerArns} writes when it is known. What a request names that holds roles, an instance+ * profile, a launch template or a task definition, is looked up in the request's account, as the+ * service resolves it; one that does not exist passes nothing, and the operation reports it. Returns+ * true when the request was aborted.*/private boolean abortIfRolePassDenied(ContainerRequestContext ctx, CallerContext caller, RequestPrincipal principal,CallerArns callerArns, String action, String credentialScope,@@ -921,7 +922,9 @@ public class IamEnforcementFilter implements ContainerRequestFilter {if (callerArns != null) {callerArns.putPrincipalKeys(context);}- context.put("iam:PassedToService", List.of(passed.passedToService()));+ if (passed.passedToService() != null) {+ context.put("iam:PassedToService", List.of(passed.passedToService()));+ }if (abortIfDenied(ctx, caller, principal, "iam:PassRole", action, credentialScope,List.of(passed.roleArn()), List.of(context), region, accountId, akid)) {return true;@@ -980,6 +983,11 @@ public class IamEnforcementFilter implements ContainerRequestFilter {public Optional<String> heldRoleArn(String roleName) {return iamService.findRole(accountId, roleName).map(IamRole::getArn);}++ @Override+ public Optional<String> serviceCatalogConstraintType(String constraintId) {+ return firstFound(lookup -> lookup.serviceCatalogConstraintType(constraintId));+ }};}diff --git a/src/main/java/io/github/hectorvent/floci/core/common/PassedRoleMembers.java b/src/main/java/io/github/hectorvent/floci/core/common/PassedRoleMembers.javanew file mode 100644index 0000000000..89666db8b9--- /dev/null+++ b/src/main/java/io/github/hectorvent/floci/core/common/PassedRoleMembers.java@@ -0,0 +1,156 @@+package io.github.hectorvent.floci.core.common;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;++import java.io.IOException;+import java.io.InputStream;+import java.util.ArrayList;+import java.util.LinkedHashMap;+import java.util.LinkedHashSet;+import java.util.List;+import java.util.Map;+import java.util.Set;+import java.util.regex.Matcher;+import java.util.regex.Pattern;++/**+ * Where each operation's request names the roles it passes, read once from the vendored+ * {@code aws/iam-passed-roles.json}.+ *+ * <p>The file is generated by {@code tools/aws/regen_iam_passed_roles.py} from AWS's Service Reference,+ * which lists {@code iam:PassRole} among an operation's authorized actions with the services the role goes+ * to, and from botocore's model of the request, which gives the members that name a role. Every operation+ * of the namespaces it reads is in it once: with the members to read, as one {@link PassedRoles} reads by+ * hand, or as one whose request names no role it can read. {@code make iam-passed-roles-check} re-derives+ * every member from botocore and {@code make iam-passed-roles-verify} checks every operation against AWS.+ *+ * <p>A missing or malformed resource is a build defect, so loading fails with+ * {@link IllegalStateException} rather than leaving every operation it reads unchecked.+ */+final class PassedRoleMembers {++ static final String RESOURCE_NAME = "aws/iam-passed-roles.json";++ private static final ObjectMapper MAPPER = new ObjectMapper();++ /** One step of a member path: a member, then each element of a list, each value of a map, or one key's value. */+ private static final Pattern STEP = Pattern.compile(+ "([A-Za-z][A-Za-z0-9_]*)(?:\\[([A-Za-z0-9_]*)]|\\{([A-Za-z0-9_]*)})?");++ /** How a member path goes on from a member. */+ enum Into { NONE, LIST, MAP, KEY }++ /**+ * A step of a member path: the member {@code name}, then for {@link Into#LIST} each element, named+ * {@code key} in the Query protocol when its shape names it, for {@link Into#MAP} each value, and for+ * {@link Into#KEY} the value under {@code key}.+ */+ record Step(String name, Into into, String key) {+ }++ /**+ * A member of a request that names a role, the service it is passed to (null when the Service Reference+ * names none) and whether the member takes the role by name as well as by ARN. {@code queryKeys} matches+ * the form parameters the Query protocol sends the member as; null for a member it cannot carry.+ */+ record Member(String path, List<Step> steps, Pattern queryKeys, String passedTo, boolean byName) {+ }++ /** The file: the members of each operation read from it, and the operations read by hand. */+ record Table(Map<String, List<Member>> members, Set<String> byHand, Set<String> notRead,+ Set<String> namespaces, Set<String> notCovered, Set<String> otherNamespaces) {+ }++ private static final class Holder {+ static final Table TABLE = VendoredResources.read(RESOURCE_NAME, "IAM passed role table",+ PassedRoleMembers::parse);+ }++ private PassedRoleMembers() {+ }++ /** The members a request for {@code action} names its roles in; null when this table does not read it. */+ static List<Member> of(String action) {+ return Holder.TABLE.members().get(action);+ }++ static Table table() {+ return Holder.TABLE;+ }++ static Table parse(InputStream in) throws IOException {+ JsonNode document = MAPPER.readTree(in);+ JsonNode operations = document.path("operations");+ if (!operations.isObject() || operations.isEmpty()) {+ throw new IllegalStateException(RESOURCE_NAME + " carries no operations");+ }+ Map<String, List<Member>> members = new LinkedHashMap<>();+ Set<String> byHand = new LinkedHashSet<>();+ Set<String> notRead = new LinkedHashSet<>();+ operations.properties().forEach(operation -> {+ JsonNode entry = operation.getValue();+ if (entry.has("byHand")) {+ byHand.add(operation.getKey());+ } else if (entry.has("notRead")) {+ notRead.add(operation.getKey());+ } else if (entry.path("roles").isArray() && !entry.path("roles").isEmpty()) {+ List<Member> roles = new ArrayList<>();+ for (JsonNode role : entry.path("roles")) {+ roles.add(member(operation.getKey(), role));+ }+ members.put(operation.getKey(), List.copyOf(roles));+ } else {+ throw new IllegalStateException(RESOURCE_NAME + " says nothing usable for " + operation.getKey());+ }+ });+ return new Table(Map.copyOf(members), Set.copyOf(byHand), Set.copyOf(notRead),+ Set.copyOf(document.path("namespaces").propertyStream().map(Map.Entry::getKey).toList()),+ Set.copyOf(document.path("notCovered").propertyStream().map(Map.Entry::getKey).toList()),+ Set.copyOf(document.path("otherNamespaces").valueStream().map(JsonNode::asText).toList()));+ }++ private static Member member(String operation, JsonNode role) {+ String path = role.path("member").asText("");+ List<Step> steps = new ArrayList<>();+ for (String step : path.split("\\.", -1)) {+ Matcher matcher = STEP.matcher(step);+ if (!matcher.matches()) {+ throw new IllegalStateException(RESOURCE_NAME + " reads " + operation + " at " + path+ + ", which is no member path");+ }+ Into into = matcher.group(2) != null ? Into.LIST : matcher.group(3) == null ? Into.NONE+ : matcher.group(3).isEmpty() ? Into.MAP : Into.KEY;+ String key = into == Into.LIST ? matcher.group(2) : into == Into.KEY ? matcher.group(3) : null;+ steps.add(new Step(matcher.group(1), into, key));+ }+ String passedTo = role.hasNonNull("passedTo") ? role.get("passedTo").asText() : null;+ return new Member(path, List.copyOf(steps), queryKeys(steps), passedTo, role.path("byName").asBoolean(false));+ }++ /**+ * The form parameters the Query protocol sends a member as: a list's elements numbered under its name,+ * generically as {@code member.N}, under the name its shape gives them or bare, as {@link AwsQueryLists}+ * reads them, and a map's values as {@code entry.N.value}. A step into one key of a map is not read from a+ * form, whose keys and values are separate parameters.+ */+ private static Pattern queryKeys(List<Step> steps) {+ StringBuilder regex = new StringBuilder();+ for (Step step : steps) {+ if (step.into() == Into.KEY) {+ return null;+ }+ if (!regex.isEmpty()) {+ regex.append("\\.");+ }+ regex.append(Pattern.quote(step.name()));+ if (step.into() == Into.LIST) {+ regex.append(step.key().isEmpty() ? "(\\.member)?" : "(\\.member|\\." + Pattern.quote(step.key()) + ")?")+ .append("\\.\\d+");+ } else if (step.into() == Into.MAP) {+ regex.append("\\.entry\\.\\d+\\.value");+ }+ }+ return Pattern.compile(regex.toString());+ }+}diff --git a/src/main/java/io/github/hectorvent/floci/core/common/PassedRoles.java b/src/main/java/io/github/hectorvent/floci/core/common/PassedRoles.javaindex 65e3a0aa63..8d3fd41da9 100644--- a/src/main/java/io/github/hectorvent/floci/core/common/PassedRoles.java+++ b/src/main/java/io/github/hectorvent/floci/core/common/PassedRoles.java@@ -1,5 +1,6 @@package io.github.hectorvent.floci.core.common;+import com.fasterxml.jackson.core.JsonProcessingException;import com.fasterxml.jackson.databind.JsonNode;import com.fasterxml.jackson.databind.ObjectMapper;import com.fasterxml.jackson.dataformat.cbor.CBORFactory;@@ -10,6 +11,7 @@ import org.jboss.logging.Logger;import java.io.IOException;import java.util.ArrayList;+import java.util.LinkedHashMap;import java.util.List;import java.util.Map;import java.util.Optional;@@ -21,7 +23,14 @@ import java.util.regex.Pattern;* The IAM user guide: "To pass a role (and its permissions) to an AWS service, a user must have* permissions to pass the role to the service." AWS's Service Reference names, for each operation* that passes one, the service the role goes to, which the check offers as {@code iam:PassedToService};- * where the request carries the role differs per operation and is listed here.+ * where the request carries the role differs per operation.+ *+ * <p>Most operations name their roles in plain request members, which {@link PassedRoleMembers} reads+ * from a table generated from the Service Reference and botocore's models. A member that takes a role+ * by name is read as the role IAM holds under that name, or else the one the name gives in the+ * request's account, and a role the Service Reference passes to no named service is checked with no+ * {@code iam:PassedToService}. The operations below are read here instead, since their roles are not+ * such a member.** <p>An EC2 request names an instance profile rather than a role, and passes the roles the profile* holds. Launching from a launch template passes nothing here: the EC2 user guide warns that a user@@ -89,6 +98,20 @@ import java.util.regex.Pattern;* {@code IAM_ROLE_ARN} setting, as SQL Server's backup and audit options do. A DMS endpoint passes to* {@code dms.amazonaws.com} its service access role and the roles its settings name for each engine, and* a replication instance the role its Kerberos settings name.+ *+ * <p>An SNS topic's delivery status roles are attributes, which "are used to give Amazon SNS write access+ * to use CloudWatch Logs on your behalf": {@code <ENDPOINT>SuccessFeedbackRoleArn} and+ * {@code <ENDPOINT>FailureFeedbackRoleArn} for each kind of endpoint. So are a platform application's+ * {@code SuccessFeedbackRoleArn} and {@code FailureFeedbackRoleArn}, a Firehose subscription's+ * {@code SubscriptionRoleArn} and the SMS {@code DeliveryStatusIAMRole}; all go to {@code sns.amazonaws.com}.+ * A CloudWatch Logs subscription filter policy names its role in its document: "To perform a+ * PutAccountPolicy subscription filter operation for any destination except a Lambda function, you must+ * also have the iam:PassRole permission."+ *+ * <p>A Service Catalog launch constraint names its launch role in its parameters document, by+ * {@code RoleArn} or by {@code LocalRoleName}, which names the role without its path, so it is checked on+ * the ARN IAM holds the role under. An SWF decision that starts a workflow execution names its Lambda role+ * in the attributes its {@code decisionType} names.*/final class PassedRoles {@@ -118,6 +141,27 @@ final class PassedRoles {private static final String REDSHIFT_SERVERLESS = ServicePrincipals.of("redshift-serverless");private static final String RDS = ServicePrincipals.of("rds");private static final String DMS = ServicePrincipals.of("dms");+ private static final String SNS = ServicePrincipals.of("sns");+ private static final String LOGS = ServicePrincipals.of("logs");+ private static final String SERVICE_CATALOG = ServicePrincipals.of("servicecatalog");+ private static final String SWF = ServicePrincipals.of("swf");++ /** The topic attributes that name a delivery status role, a success and a failure one per kind of endpoint. */+ private static final Set<String> SNS_TOPIC_ROLES = Set.of(+ "ApplicationSuccessFeedbackRoleArn", "ApplicationFailureFeedbackRoleArn",+ "FirehoseSuccessFeedbackRoleArn", "FirehoseFailureFeedbackRoleArn",+ "HTTPSuccessFeedbackRoleArn", "HTTPFailureFeedbackRoleArn",+ "LambdaSuccessFeedbackRoleArn", "LambdaFailureFeedbackRoleArn",+ "SQSSuccessFeedbackRoleArn", "SQSFailureFeedbackRoleArn");+ private static final Set<String> SNS_SUBSCRIPTION_ROLES = Set.of("SubscriptionRoleArn");+ private static final Set<String> SNS_PLATFORM_ROLES = Set.of("SuccessFeedbackRoleArn", "FailureFeedbackRoleArn");+ private static final Set<String> SNS_SMS_ROLES = Set.of("DeliveryStatusIAMRole");+ private static final String SUBSCRIPTION_FILTER_POLICY = "SUBSCRIPTION_FILTER_POLICY";+ private static final String LAUNCH_CONSTRAINT = "LAUNCH";+ /** The SWF decisions that start a workflow execution, and the member each carries its attributes in. */+ private static final Map<String, String> SWF_EXECUTION_DECISIONS = Map.of(+ "ContinueAsNewWorkflowExecution", "continueAsNewWorkflowExecutionDecisionAttributes",+ "StartChildWorkflowExecution", "startChildWorkflowExecutionDecisionAttributes");/** The RDS operations whose request takes a {@code MonitoringRoleArn}. */private static final Set<String> RDS_MONITORING_ROLE = Set.of("rds:CreateDBCluster", "rds:CreateDBInstance",@@ -162,7 +206,7 @@ final class PassedRoles {private static final String DEFAULT_AUTOSCALING_ROLE =":role/aws-service-role/" + AUTOSCALING + "/AWSServiceRoleForAutoScaling";- /** A role a request passes, and the service principal it is passed to. */+ /** A role a request passes, and the service principal it is passed to; null when AWS names none. */record PassedRole(String roleArn, String passedToService) {}@@ -199,6 +243,9 @@ final class PassedRoles {/** The ARN, path included, of the role IAM holds under {@code roleName}; empty when it holds none. */Optional<String> heldRoleArn(String roleName);++ /** The type of the Service Catalog constraint {@code constraintId}; empty when there is none. */+ Optional<String> serviceCatalogConstraintType(String constraintId);}private PassedRoles() {@@ -206,6 +253,15 @@ final class PassedRoles {/** The roles a request for {@code action} passes; empty when the operation passes none or the request names none. */static List<PassedRole> of(String action, ContainerRequestContext ctx, Lookups lookups) {+ List<PassedRole> byHand = byHand(action, ctx, lookups);+ return byHand != null ? byHand : fromTable(PassedRoleMembers.of(action), ctx, lookups);+ }++ /**+ * The roles a request for {@code action} passes, for an operation read here rather than from the table;+ * null for any other.+ */+ static List<PassedRole> byHand(String action, ContainerRequestContext ctx, Lookups lookups) {return switch (action) {case "lambda:CreateFunction", "lambda:UpdateFunctionConfiguration" -> fromJson(ctx, LAMBDA, "Role");case "lambda:CreateWebFunction" ->@@ -268,10 +324,211 @@ final class PassedRoles {case "dms:CreateEndpoint", "dms:ModifyEndpoint" -> dmsEndpointRoles(jsonBody(ctx));case "dms:CreateReplicationInstance", "dms:ModifyReplicationInstance" ->fromJson(ctx, DMS, "KerberosAuthenticationSettings", "KeyCacheSecretIamArn");- default -> List.of();+ case "sns:CreateTopic" -> snsAttributeRoles(ctx, "Attributes", SNS_TOPIC_ROLES);+ case "sns:SetTopicAttributes" -> snsAttributeRole(ctx, SNS_TOPIC_ROLES);+ case "sns:Subscribe" -> snsAttributeRoles(ctx, "Attributes", SNS_SUBSCRIPTION_ROLES);+ case "sns:SetSubscriptionAttributes" -> snsAttributeRole(ctx, SNS_SUBSCRIPTION_ROLES);+ case "sns:CreatePlatformApplication", "sns:SetPlatformApplicationAttributes" ->+ snsAttributeRoles(ctx, "Attributes", SNS_PLATFORM_ROLES);+ case "sns:SetSMSAttributes" -> snsAttributeRoles(ctx, "attributes", SNS_SMS_ROLES);+ case "logs:PutAccountPolicy" -> subscriptionFilterPolicyRole(jsonBody(ctx));+ case "servicecatalog:CreateConstraint" -> launchConstraintRoles(jsonBody(ctx), lookups, false);+ case "servicecatalog:UpdateConstraint" -> launchConstraintRoles(jsonBody(ctx), lookups, true);+ case "swf:RespondDecisionTaskCompleted" -> swfDecisionRoles(jsonBody(ctx));+ default -> null;};}+ /**+ * The roles a request names in the members the table gives for its operation: from its form parameters+ * when it comes in the Query protocol, and from its JSON or CBOR body otherwise.+ */+ private static List<PassedRole> fromTable(List<PassedRoleMembers.Member> members, ContainerRequestContext ctx,+ Lookups lookups) {+ if (members == null) {+ return List.of();+ }+ Map<String, String> form = IamConditionContextResolver.formParameters(ctx);+ JsonNode body = form.isEmpty() ? jsonBody(ctx) : null;+ List<PassedRole> passed = new ArrayList<>();+ for (PassedRoleMembers.Member member : members) {+ List<String> roles = new ArrayList<>();+ if (!form.isEmpty()) {+ if (member.queryKeys() != null) {+ form.forEach((key, value) -> {+ if (member.queryKeys().matcher(key).matches()) {+ roles.add(value);+ }+ });+ }+ } else {+ collect(body, member.steps(), 0, roles);+ }+ passed.addAll(passed(member.byName() ? heldOrNamedRoles(roles, lookups) : roles,+ member.passedTo() == null ? null : ServicePrincipals.of(member.passedTo())));+ }+ return passed;+ }++ private static void collect(JsonNode node, List<PassedRoleMembers.Step> steps, int index, List<String> found) {+ if (node == null) {+ return;+ }+ if (index == steps.size()) {+ if (node.isTextual()) {+ found.add(node.asText());+ }+ return;+ }+ PassedRoleMembers.Step step = steps.get(index);+ JsonNode value = node.get(step.name());+ switch (step.into()) {+ case NONE -> collect(value, steps, index + 1, found);+ case KEY -> collect(value == null ? null : value.get(step.key()), steps, index + 1, found);+ case LIST, MAP -> {+ if (value != null && (step.into() == PassedRoleMembers.Into.LIST ? value.isArray() : value.isObject())) {+ for (JsonNode element : value) {+ collect(element, steps, index + 1, found);+ }+ }+ }+ }+ }++ /** Roles given by ARN or by name: a name is the role IAM holds under it, or else the one it gives. */+ private static List<String> heldOrNamedRoles(List<String> roles, Lookups lookups) {+ List<String> arns = new ArrayList<>();+ for (String role : roles) {+ if (!role.isBlank()) {+ arns.add(role.startsWith("arn:") ? role+ : lookups.heldRoleArn(role).orElseGet(() -> lookups.roleArn(role)));+ }+ }+ return arns;+ }++ /**+ * The roles among an SNS request's attributes {@code map}, read as the SNS handlers read the map: from a+ * form, each {@code map.entry.N} from 1 up to the first with no key, the last value of a key named twice;+ * from a JSON body, the {@code map} object.+ */+ private static List<PassedRole> snsAttributeRoles(ContainerRequestContext ctx, String map, Set<String> roleAttributes) {+ Map<String, String> form = IamConditionContextResolver.formParameters(ctx);+ Map<String, String> attributes = new LinkedHashMap<>();+ if (!form.isEmpty()) {+ for (int i = 1; form.get(map + ".entry." + i + ".key") != null; i++) {+ attributes.put(form.get(map + ".entry." + i + ".key"), form.get(map + ".entry." + i + ".value"));+ }+ } else {+ JsonNode body = jsonBody(ctx);+ JsonNode values = body == null ? null : body.get(map);+ if (values != null && values.isObject()) {+ values.properties().forEach(entry -> attributes.put(entry.getKey(), entry.getValue().asText(null)));+ }+ }+ List<String> roles = new ArrayList<>();+ attributes.forEach((name, value) -> {+ if (roleAttributes.contains(name)) {+ roles.add(value);+ }+ });+ return passed(roles, SNS);+ }++ /**+ * The role an SNS {@code AttributeValue} names, when its {@code AttributeName} is one that names a role; a+ * request with no value names none, and is left to SNS to answer.+ */+ private static List<PassedRole> snsAttributeRole(ContainerRequestContext ctx, Set<String> roleAttributes) {+ Map<String, String> form = IamConditionContextResolver.formParameters(ctx);+ String name;+ String value;+ if (!form.isEmpty()) {+ name = form.get("AttributeName");+ value = form.get("AttributeValue");+ } else {+ JsonNode body = jsonBody(ctx);+ name = body == null ? null : body.path("AttributeName").asText(null);+ value = body == null ? null : body.path("AttributeValue").asText(null);+ }+ if (name == null || value == null || !roleAttributes.contains(name)) {+ return List.of();+ }+ return passed(List.of(value), SNS);+ }++ /** The role a CloudWatch Logs subscription filter policy's document names; another policy names none. */+ private static List<PassedRole> subscriptionFilterPolicyRole(JsonNode body) {+ if (body == null || !SUBSCRIPTION_FILTER_POLICY.equals(body.path("policyType").asText(null))) {+ return List.of();+ }+ return passed(values(embeddedJson(body.get("policyDocument")), "RoleArn"), LOGS);+ }++ /**+ * The launch role a Service Catalog launch constraint names in its {@code Parameters}, a JSON document,+ * by {@code RoleArn} or by {@code LocalRoleName}, which names the role of that name in the caller's+ * account without its path. A constraint of another type names no launch role. An update is read by+ * the type Floci keeps for the constraint, since its request names none. The type is matched in any+ * case, since Floci keeps it as given.+ */+ private static List<PassedRole> launchConstraintRoles(JsonNode body, Lookups lookups, boolean update) {+ JsonNode parameters = body == null ? null : embeddedJson(body.get("Parameters"));+ if (parameters == null) {+ return List.of();+ }+ String type;+ if (update) {+ String id = blankToNull(body.path("Id").asText(null));+ type = id == null ? null : lookups.serviceCatalogConstraintType(id).orElse(null);+ } else {+ type = body.path("Type").asText(null);+ }+ if (!LAUNCH_CONSTRAINT.equalsIgnoreCase(type)) {+ return List.of();+ }+ List<String> roles = new ArrayList<>(values(parameters, "RoleArn"));+ for (String name : values(parameters, "LocalRoleName")) {+ if (!name.isBlank()) {+ roles.add(lookups.heldRoleArn(name).orElseGet(() -> lookups.roleArn(name)));+ }+ }+ return passed(roles, SERVICE_CATALOG);+ }++ /**+ * The roles of the decisions that start a workflow execution, each read from the attributes its+ * {@code decisionType} names, as the SWF handler reads a decision.+ */+ private static List<PassedRole> swfDecisionRoles(JsonNode body) {+ JsonNode decisions = body == null ? null : body.get("decisions");+ if (decisions == null || !decisions.isArray()) {+ return List.of();+ }+ List<String> roles = new ArrayList<>();+ for (JsonNode decision : decisions) {+ String attributes = SWF_EXECUTION_DECISIONS.get(decision.path("decisionType").asText(""));+ if (attributes != null) {+ roles.addAll(values(decision, attributes, "lambdaRole"));+ }+ }+ return passed(roles, SWF);+ }++ /** The JSON document a string member holds; null when the member holds no JSON. */+ private static JsonNode embeddedJson(JsonNode member) {+ if (member == null || !member.isTextual()) {+ return null;+ }+ try {+ return MAPPER.readTree(member.asText());+ } catch (JsonProcessingException e) {+ // A document that is not JSON has no member to name a role in.+ LOG.debugv(e, "Embedded document is not JSON, so it passes no role");+ return null;+ }+ }+/*** The role AddRoleToInstanceProfile adds, which {@code RoleName} names without its path: the ARN IAM* holds it under, or else the one the name gives, so a role IAM does not hold is checked as named.diff --git a/src/main/java/io/github/hectorvent/floci/services/iam/PassedRoleLookup.java b/src/main/java/io/github/hectorvent/floci/services/iam/PassedRoleLookup.javaindex a93aef47bf..968f512056 100644--- a/src/main/java/io/github/hectorvent/floci/services/iam/PassedRoleLookup.java+++ b/src/main/java/io/github/hectorvent/floci/services/iam/PassedRoleLookup.java@@ -7,8 +7,9 @@ import java.util.Optional;* Looks up what a stored resource holds that the {@code iam:PassRole} check of a request needs, for* the operations that pass a role the request does not name itself: an ECS task started from a task* definition runs with the definition's roles, a self-managed StackSet that names no- * administration role uses the default one, and an Auto Scaling group launches its instances with- * the instance profile of its launch template, or of the instance its launch configuration was made from.+ * administration role uses the default one, an Auto Scaling group launches its instances with+ * the instance profile of its launch template, or of the instance its launch configuration was made from,+ * and a Service Catalog constraint update names no type, which says whether it sets a launch role.** <p>Implemented by the services that own those resources, each answering for its own and leaving* the default for the rest; consumed lazily by {@code IamEnforcementFilter} via@@ -61,4 +62,9 @@ public interface PassedRoleLookup {String version, String region) {return Optional.empty();}++ /** The type of the Service Catalog constraint {@code constraintId}; empty when there is none. */+ default Optional<String> serviceCatalogConstraintType(String constraintId) {+ return Optional.empty();+ }}diff --git a/src/main/java/io/github/hectorvent/floci/services/servicecatalog/ServiceCatalogService.java b/src/main/java/io/github/hectorvent/floci/services/servicecatalog/ServiceCatalogService.javaindex 63ebb5617a..afa32f70ec 100644--- a/src/main/java/io/github/hectorvent/floci/services/servicecatalog/ServiceCatalogService.java+++ b/src/main/java/io/github/hectorvent/floci/services/servicecatalog/ServiceCatalogService.java@@ -9,6 +9,7 @@ import io.github.hectorvent.floci.core.common.AwsArnUtils;import io.github.hectorvent.floci.core.common.AwsException;import io.github.hectorvent.floci.core.storage.StorageBackend;import io.github.hectorvent.floci.core.storage.StorageFactory;+import io.github.hectorvent.floci.services.iam.PassedRoleLookup;import io.github.hectorvent.floci.services.organizations.OrganizationsService;import io.github.hectorvent.floci.services.organizations.model.CreateAccountStatus;import io.github.hectorvent.floci.services.organizations.model.OrganizationAccount;@@ -22,7 +23,7 @@ import java.util.Optional;import java.util.UUID;@ApplicationScoped-public class ServiceCatalogService {+public class ServiceCatalogService implements PassedRoleLookup {static final String CONTROL_TOWER_PORTFOLIO_ID = "port-flocicontrol1";static final String CONTROL_TOWER_PORTFOLIO_NAME = "AWS Control Tower Account Factory Portfolio";@@ -998,6 +999,12 @@ public class ServiceCatalogService {return require(associationStore, id, "constraint").deepCopy();}+ /** The constraint's type, which says whether an update of its parameters sets a launch role. */+ @Override+ public Optional<String> serviceCatalogConstraintType(String constraintId) {+ return associationStore.get(constraintId).map(constraint -> constraint.path("Type").asText(""));+ }+public ObjectNode describeProvisionedProduct(String id, String name) {if (id != null && !id.isBlank()) {return require(provisionedProductStore, id, "provisioned product").deepCopy();diff --git a/src/main/resources/aws/iam-passed-roles.json b/src/main/resources/aws/iam-passed-roles.jsonnew file mode 100644index 0000000000..41ec05025e--- /dev/null+++ b/src/main/resources/aws/iam-passed-roles.json@@ -0,0 +1,1066 @@+{+ "_source": {"generator": "tools/aws/regen_iam_passed_roles.py", "reference": "https://servicereference.us-east-1.amazonaws.com/", "botocore": "botocore 1.43.113 (installed package)", "retrieved": "2026-10-24", "note": "make iam-passed-roles-check re-derives every member from botocore; make iam-passed-roles-verify checks every operation against AWS."},+ "namespaces": {"application-autoscaling": ["application-autoscaling"], "athena": ["athena"], "autoscaling": ["autoscaling"], "budgets": ["budgets"], "cloudformation": ["cloudcontrol", "cloudformation"], "cloudtrail": ["cloudtrail"], "cloudwatch": ["cloudwatch", "cloudwatchomni"], "codebuild": ["codebuild"], "codedeploy": ["codedeploy"], "codepipeline": ["codepipeline"], "cognito-identity": ["cognito-identity"], "cognito-idp": ["cognito-idp"], "comprehend": ["comprehend"], "config": ["config"], "datasync": ["datasync"], "dms": ["dms"], "dsql": ["dsql"], "ec2": ["ec2"], "ecr": ["ecr"], "ecs": ["ecs"], "eks": ["eks"], "elasticmapreduce": ["emr"], "events": ["eventbridgev2", "events"], "firehose": ["firehose"], "glue": ["glue"], "iam": ["iam"], "kinesis": ["kinesis"], "kinesisanalytics": ["kinesisanalytics", "kinesisanalyticsv2"], "lambda": ["lambda", "lambda-core", "lambda-microvms", "lambda-web"], "logs": ["logs"], "pipes": ["pipes"], "rds": ["docdb", "neptune", "rds"], "redshift": ["redshift"], "redshift-serverless": ["redshift-serverless"], "rekognition": ["rekognition"], "resource-groups": ["resource-groups"], "s3": ["s3", "s3control"], "sagemaker": ["sagemaker"], "scheduler": ["scheduler"], "secretsmanager": ["secretsmanager"], "servicecatalog": ["servicecatalog"], "ses": ["mailmanager", "pinpoint-email", "ses", "sesv2"], "sns": ["sns"], "ssm": ["ssm"], "states": ["stepfunctions"], "swf": ["swf"], "textract": ["textract"], "transcribe": ["transcribe"], "transfer": ["transfer"], "translate": ["translate"]},+ "notCovered": {"access-analyzer": "REST routes no rule maps yet", "airflow": "REST routes no rule maps yet", "apigateway": "authorized by HTTP method, so no request is checked as one of these operations", "appconfig": "REST routes no rule maps yet", "appsync": "REST routes no rule maps yet", "aps": "REST routes no rule maps yet", "aws-marketplace": "REST routes no rule maps yet", "backup": "REST routes no rule maps yet", "batch": "REST routes no rule maps yet", "bedrock": "REST routes no rule maps yet", "bedrock-agentcore": "REST routes no rule maps yet", "cloudfront": "REST routes no rule maps yet", "dlm": "REST routes no rule maps yet", "elasticfilesystem": "REST routes no rule maps yet", "emr-serverless": "REST routes no rule maps yet", "es": "REST routes no rule maps yet", "fis": "REST routes no rule maps yet", "guardduty": "REST routes no rule maps yet", "iot": "REST routes no rule maps yet", "kafka": "REST routes no rule maps yet", "macie2": "REST routes no rule maps yet", "mq": "REST routes no rule maps yet", "rum": "REST routes no rule maps yet", "s3tables": "REST routes no rule maps yet"},+ "otherNamespaces": ["agent-registry", "aidevops", "aiops", "airflow-serverless", "amplify", "aoss", "appflow", "appmesh", "apprunner", "appstream", "arc-region-switch", "backup-gateway", "backup-search", "bcm-dashboards", "braket", "chatbot", "chime", "cleanrooms", "cleanrooms-ml", "codeconnections", "codestar-connections", "cognito-sync", "comprehendmedical", "databrew", "dataexchange", "datapipeline", "datazone", "dax", "deadline", "devicefarm", "elemental-inference", "emr-containers", "entityresolution", "fms", "forecast", "frauddetector", "gamelift", "gameliftstreams", "geo", "grafana", "greengrass", "groundstation", "health-agent", "healthlake", "imagebuilder", "inspector", "iotdeviceadvisor", "iotfleetwise", "iotmanagedintegrations", "iotsitewise", "iottwinmaker", "iotwireless", "kafkaconnect", "kendra", "lex", "lookoutequipment", "m2", "machinelearning", "mediaconnect", "mediaconvert", "medialive", "mediapackage", "mediapackage-vod", "mediapackagev2", "mediastore", "medical-imaging", "mobiletargeting", "neptune-graph", "observabilityadmin", "odb", "omics", "opensearch", "osis", "partnercentral", "pcs", "personalize", "profile", "proton", "qbusiness", "quicksight", "repostspace", "resiliencehub", "rolesanywhere", "s3files", "sagemaker-geospatial", "securityagent", "securitylake", "shield", "sms-voice", "snowball", "social-messaging", "ssm-incidents", "ssm-quicksetup", "storagegateway", "supportapp", "synthetics", "timestream", "voiceid", "wellarchitected", "wisdom", "workmail", "workspaces"],+ "operations": {+ "application-autoscaling:RegisterScalableTarget": {"passedTo": ["application-autoscaling"], "byHand": "the scalable target's role"},+ "athena:CreateWorkGroup": {"passedTo": ["athena"], "roles": [+ {"member": "Configuration.ExecutionRole", "passedTo": "athena"}+ ]},+ "athena:StartSession": {"passedTo": ["athena"], "roles": [+ {"member": "ExecutionRole", "passedTo": "athena"}+ ]},+ "athena:UpdateWorkGroup": {"passedTo": ["athena"], "roles": [+ {"member": "ConfigurationUpdates.ExecutionRole", "passedTo": "athena"}+ ]},+ "autoscaling:CreateAutoScalingGroup": {"passedTo": ["autoscaling", "ec2"], "byHand": "the roles of each launch template's instance profile, and the service-linked and lifecycle hook roles"},+ "autoscaling:CreateLaunchConfiguration": {"passedTo": ["ec2"], "byHand": "the roles of the instance profile it names or takes from an instance"},+ "autoscaling:PutLifecycleHook": {"passedTo": ["autoscaling"], "byHand": "the hook's role"},+ "autoscaling:UpdateAutoScalingGroup": {"passedTo": ["autoscaling"], "byHand": "the roles of each launch template's instance profile, and the service-linked and lifecycle hook roles"},+ "budgets:CreateBudgetAction": {"passedTo": ["budgets"], "roles": [+ {"member": "ExecutionRoleArn", "passedTo": "budgets"}+ ]},+ "budgets:UpdateBudgetAction": {"passedTo": ["budgets"], "roles": [+ {"member": "ExecutionRoleArn", "passedTo": "budgets"}+ ]},+ "cloudformation:ActivateType": {"passedTo": ["resources.cloudformation"], "roles": [+ {"member": "ExecutionRoleArn", "passedTo": "resources.cloudformation"},+ {"member": "LoggingConfig.LogRoleArn", "passedTo": "resources.cloudformation"}+ ]},+ "cloudformation:ContinueUpdateRollback": {"passedTo": ["cloudformation"], "byHand": "the stack's service role"},+ "cloudformation:CreateChangeSet": {"passedTo": ["cloudformation"], "byHand": "the stack's service role"},+ "cloudformation:CreateResource": {"passedTo": ["cloudformation"], "roles": [+ {"member": "RoleArn", "passedTo": "cloudformation"}+ ]},+ "cloudformation:CreateStack": {"passedTo": ["cloudformation"], "byHand": "the stack's service role"},+ "cloudformation:CreateStackSet": {"passedTo": ["cloudformation"], "byHand": "the administration role, named or the default one"},+ "cloudformation:DeleteResource": {"passedTo": ["cloudformation"], "roles": [+ {"member": "RoleArn", "passedTo": "cloudformation"}+ ]},+ "cloudformation:DeleteStack": {"passedTo": ["cloudformation"], "byHand": "the stack's service role"},+ "cloudformation:GetResource": {"passedTo": ["cloudformation"], "roles": [+ {"member": "RoleArn", "passedTo": "cloudformation"}+ ]},+ "cloudformation:ListResources": {"passedTo": ["cloudformation"], "roles": [+ {"member": "RoleArn", "passedTo": "cloudformation"}+ ]},+ "cloudformation:RegisterType": {"passedTo": ["resources.cloudformation"], "roles": [+ {"member": "ExecutionRoleArn", "passedTo": "resources.cloudformation"},+ {"member": "LoggingConfig.LogRoleArn", "passedTo": "resources.cloudformation"}+ ]},+ "cloudformation:RollbackStack": {"passedTo": ["cloudformation"], "roles": [+ {"member": "RoleARN", "passedTo": "cloudformation"}+ ]},+ "cloudformation:UpdateResource": {"passedTo": ["cloudformation"], "roles": [+ {"member": "RoleArn", "passedTo": "cloudformation"}+ ]},+ "cloudformation:UpdateStack": {"passedTo": ["cloudformation"], "byHand": "the stack's service role"},+ "cloudformation:UpdateStackSet": {"passedTo": ["cloudformation"], "byHand": "the administration role, by the StackSet's permission model"},+ "cloudtrail:CreateTrail": {"passedTo": ["cloudtrail"], "roles": [+ {"member": "CloudWatchLogsRoleArn", "passedTo": "cloudtrail"}+ ]},+ "cloudtrail:EnableFederation": {"passedTo": ["cloudtrail"], "roles": [+ {"member": "FederationRoleArn", "passedTo": "cloudtrail"}+ ]},+ "cloudtrail:StartImport": {"passedTo": ["cloudtrail"], "roles": [+ {"member": "ImportSource.S3.S3BucketAccessRoleArn", "passedTo": "cloudtrail"}+ ]},+ "cloudtrail:UpdateTrail": {"passedTo": ["cloudtrail"], "roles": [+ {"member": "CloudWatchLogsRoleArn", "passedTo": "cloudtrail"}+ ]},+ "cloudwatch:CreateDomainForOrganization": {"passedTo": ["cloudwatch"], "roles": [+ {"member": "domainAccessRoleArn", "passedTo": "cloudwatch"}+ ]},+ "cloudwatch:CreateIntegration": {"passedTo": ["cloudwatch"], "roles": [+ {"member": "roleArn", "passedTo": "cloudwatch"}+ ]},+ "cloudwatch:CreateSpace": {"passedTo": ["cloudwatch"], "roles": [+ {"member": "agentCoreEvaluationRoleArn", "passedTo": "cloudwatch"},+ {"member": "dataAccessRoleArn", "passedTo": "cloudwatch"}+ ]},+ "cloudwatch:PutLogAlarm": {"passedTo": ["cloudwatch"], "roles": [+ {"member": "ActionLogLineRoleArn", "passedTo": "cloudwatch"},+ {"member": "ScheduledQueryConfiguration.ScheduledQueryRoleARN", "passedTo": "cloudwatch"}+ ]},+ "cloudwatch:PutMetricStream": {"passedTo": ["streams.metrics.cloudwatch"], "roles": [+ {"member": "RoleArn", "passedTo": "streams.metrics.cloudwatch"}+ ]},+ "cloudwatch:UpdateIntegration": {"passedTo": ["cloudwatch"], "roles": [+ {"member": "roleArn", "passedTo": "cloudwatch"}+ ]},+ "cloudwatch:UpdateSpace": {"passedTo": ["cloudwatch"], "roles": [+ {"member": "agentCoreEvaluationRoleArn", "passedTo": "cloudwatch"}+ ]},+ "codebuild:CreateFleet": {"passedTo": [], "roles": [+ {"member": "fleetServiceRole"}+ ]},+ "codebuild:CreateProject": {"passedTo": ["codebuild"], "roles": [+ {"member": "buildBatchConfig.serviceRole", "passedTo": "codebuild"},+ {"member": "serviceRole", "passedTo": "codebuild"}+ ]},+ "codebuild:StartBuild": {"passedTo": ["codebuild"], "roles": [+ {"member": "serviceRoleOverride", "passedTo": "codebuild", "byName": true}+ ]},+ "codebuild:StartBuildBatch": {"passedTo": ["codebuild"], "roles": [+ {"member": "buildBatchConfigOverride.serviceRole", "passedTo": "codebuild"},+ {"member": "serviceRoleOverride", "passedTo": "codebuild", "byName": true}+ ]},+ "codebuild:UpdateFleet": {"passedTo": [], "roles": [+ {"member": "fleetServiceRole"}+ ]},+ "codebuild:UpdateProject": {"passedTo": ["codebuild"], "roles": [+ {"member": "buildBatchConfig.serviceRole", "passedTo": "codebuild"},+ {"member": "serviceRole", "passedTo": "codebuild"}+ ]},+ "codebuild:UpdateProjectVisibility": {"passedTo": ["codebuild"], "roles": [+ {"member": "resourceAccessRole", "passedTo": "codebuild"}+ ]},+ "codedeploy:CreateDeploymentGroup": {"passedTo": ["codedeploy"], "roles": [+ {"member": "serviceRoleArn", "passedTo": "codedeploy"}+ ]},+ "codedeploy:UpdateDeploymentGroup": {"passedTo": ["codedeploy"], "roles": [+ {"member": "serviceRoleArn", "passedTo": "codedeploy"}+ ]},+ "codepipeline:CreatePipeline": {"passedTo": ["cloudformation", "codebuild", "codepipeline"], "roles": [+ {"member": "pipeline.roleArn", "passedTo": "codepipeline"},+ {"member": "pipeline.stages[].beforeEntry.conditions[].rules[].roleArn", "passedTo": "codepipeline"},+ {"member": "pipeline.stages[].onFailure.conditions[].rules[].roleArn", "passedTo": "codepipeline"},+ {"member": "pipeline.stages[].onSuccess.conditions[].rules[].roleArn", "passedTo": "codepipeline"}+ ]},+ "codepipeline:UpdatePipeline": {"passedTo": ["cloudformation", "codebuild", "codepipeline"], "roles": [+ {"member": "pipeline.roleArn", "passedTo": "codepipeline"},+ {"member": "pipeline.stages[].beforeEntry.conditions[].rules[].roleArn", "passedTo": "codepipeline"},+ {"member": "pipeline.stages[].onFailure.conditions[].rules[].roleArn", "passedTo": "codepipeline"},+ {"member": "pipeline.stages[].onSuccess.conditions[].rules[].roleArn", "passedTo": "codepipeline"}+ ]},+ "cognito-identity:SetIdentityPoolRoles": {"passedTo": [], "roles": [+ {"member": "RoleMappings{}.RulesConfiguration.Rules[].RoleARN"},+ {"member": "Roles{}"}+ ]},+ "cognito-idp:CreateGroup": {"passedTo": [], "roles": [+ {"member": "RoleArn"}+ ]},+ "cognito-idp:CreateUserImportJob": {"passedTo": [], "roles": [+ {"member": "CloudWatchLogsRoleArn"}+ ]},+ "cognito-idp:CreateUserPool": {"passedTo": [], "roles": [+ {"member": "SmsConfiguration.EumsSms.CallerArn"},+ {"member": "SmsConfiguration.SnsCallerArn"}+ ]},+ "cognito-idp:CreateUserPoolClient": {"passedTo": [], "roles": [+ {"member": "AnalyticsConfiguration.RoleArn"}+ ]},+ "cognito-idp:SetUserPoolMfaConfig": {"passedTo": [], "roles": [+ {"member": "SmsMfaConfiguration.SmsConfiguration.EumsSms.CallerArn"},+ {"member": "SmsMfaConfiguration.SmsConfiguration.SnsCallerArn"}+ ]},+ "cognito-idp:UpdateGroup": {"passedTo": [], "roles": [+ {"member": "RoleArn"}+ ]},+ "cognito-idp:UpdateUserPool": {"passedTo": [], "roles": [+ {"member": "SmsConfiguration.EumsSms.CallerArn"},+ {"member": "SmsConfiguration.SnsCallerArn"}+ ]},+ "cognito-idp:UpdateUserPoolClient": {"passedTo": [], "roles": [+ {"member": "AnalyticsConfiguration.RoleArn"}+ ]},+ "comprehend:CreateDocumentClassifier": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:CreateEndpoint": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:CreateEntityRecognizer": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:CreateFlywheel": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:ImportModel": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:StartDocumentClassificationJob": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:StartDominantLanguageDetectionJob": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:StartEntitiesDetectionJob": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:StartEventsDetectionJob": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:StartKeyPhrasesDetectionJob": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:StartPiiEntitiesDetectionJob": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:StartSentimentDetectionJob": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:StartTargetedSentimentDetectionJob": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:StartTopicsDetectionJob": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:UpdateEndpoint": {"passedTo": ["comprehend"], "roles": [+ {"member": "DesiredDataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "comprehend:UpdateFlywheel": {"passedTo": ["comprehend"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "comprehend"}+ ]},+ "config:PutConfigurationAggregator": {"passedTo": ["config"], "roles": [+ {"member": "OrganizationAggregationSource.RoleArn", "passedTo": "config"}+ ]},+ "config:PutConfigurationRecorder": {"passedTo": ["config"], "roles": [+ {"member": "ConfigurationRecorder.roleARN", "passedTo": "config"}+ ]},+ "config:PutConformancePack": {"passedTo": ["ssm"], "notRead": "no member of the request names a role"},+ "config:PutOrganizationConformancePack": {"passedTo": ["ssm"], "notRead": "no member of the request names a role"},+ "config:PutRemediationConfigurations": {"passedTo": ["ssm"], "notRead": "the role is a parameter of the runbook it runs, not a member of the request"},+ "datasync:CreateLocationAzureBlob": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:CreateLocationEfs": {"passedTo": ["datasync"], "roles": [+ {"member": "FileSystemAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:CreateLocationFsxOntap": {"passedTo": ["datasync"], "roles": [+ {"member": "Protocol.SMB.CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:CreateLocationFsxWindows": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:CreateLocationHdfs": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:CreateLocationObjectStorage": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:CreateLocationS3": {"passedTo": ["datasync"], "roles": [+ {"member": "S3Config.BucketAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:CreateLocationSmb": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:CreateTask": {"passedTo": ["datasync"], "roles": [+ {"member": "ManifestConfig.Source.S3.BucketAccessRoleArn", "passedTo": "datasync"},+ {"member": "TaskReportConfig.Destination.S3.BucketAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:StartTaskExecution": {"passedTo": ["datasync"], "roles": [+ {"member": "ManifestConfig.Source.S3.BucketAccessRoleArn", "passedTo": "datasync"},+ {"member": "TaskReportConfig.Destination.S3.BucketAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:UpdateLocationAzureBlob": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:UpdateLocationEfs": {"passedTo": ["datasync"], "roles": [+ {"member": "FileSystemAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:UpdateLocationFsxOntap": {"passedTo": ["datasync"], "roles": [+ {"member": "Protocol.SMB.CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:UpdateLocationFsxWindows": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:UpdateLocationHdfs": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:UpdateLocationObjectStorage": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:UpdateLocationS3": {"passedTo": ["datasync"], "roles": [+ {"member": "S3Config.BucketAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:UpdateLocationSmb": {"passedTo": ["datasync"], "roles": [+ {"member": "CustomSecretConfig.SecretAccessRoleArn", "passedTo": "datasync"}+ ]},+ "datasync:UpdateTask": {"passedTo": ["datasync"], "roles": [+ {"member": "ManifestConfig.Source.S3.BucketAccessRoleArn", "passedTo": "datasync"},+ {"member": "TaskReportConfig.Destination.S3.BucketAccessRoleArn", "passedTo": "datasync"}+ ]},+ "dms:CreateDataMigration": {"passedTo": ["dms"], "roles": [+ {"member": "ServiceAccessRoleArn", "passedTo": "dms"}+ ]},+ "dms:CreateDataProvider": {"passedTo": ["dms"], "roles": [+ {"member": "Settings.IbmDb2LuwSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.IbmDb2zOsSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.MariaDbSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.MicrosoftSqlServerSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.MySqlSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.OracleSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.OracleSettings.SecretsManagerOracleAsmAccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.OracleSettings.SecretsManagerSecurityDbEncryptionAccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.PostgreSqlSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.RedshiftSettings.S3AccessRoleArn", "passedTo": "dms"}+ ]},+ "dms:CreateEndpoint": {"passedTo": ["dms"], "byHand": "the endpoint's role and the roles of the settings structures DMS stores"},+ "dms:CreateFleetAdvisorCollector": {"passedTo": ["dms"], "roles": [+ {"member": "ServiceAccessRoleArn", "passedTo": "dms"}+ ]},+ "dms:CreateInstanceProfile": {"passedTo": ["dms"], "notRead": "no member of the request names a role"},+ "dms:CreateMigrationProject": {"passedTo": ["dms"], "roles": [+ {"member": "SchemaConversionApplicationAttributes.S3BucketRoleArn", "passedTo": "dms"},+ {"member": "SourceDataProviderDescriptors[].SecretsManagerAccessRoleArn", "passedTo": "dms"},+ {"member": "TargetDataProviderDescriptors[].SecretsManagerAccessRoleArn", "passedTo": "dms"}+ ]},+ "dms:CreateReplicationInstance": {"passedTo": ["dms"], "byHand": "the role of the Kerberos settings"},+ "dms:ModifyDataMigration": {"passedTo": ["dms"], "roles": [+ {"member": "ServiceAccessRoleArn", "passedTo": "dms"}+ ]},+ "dms:ModifyDataProvider": {"passedTo": ["dms"], "roles": [+ {"member": "Settings.IbmDb2LuwSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.IbmDb2zOsSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.MariaDbSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.MicrosoftSqlServerSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.MySqlSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.OracleSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.OracleSettings.SecretsManagerOracleAsmAccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.OracleSettings.SecretsManagerSecurityDbEncryptionAccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.PostgreSqlSettings.S3AccessRoleArn", "passedTo": "dms"},+ {"member": "Settings.RedshiftSettings.S3AccessRoleArn", "passedTo": "dms"}+ ]},+ "dms:ModifyEndpoint": {"passedTo": ["dms"], "byHand": "the endpoint's role and the roles of the settings structures DMS stores"},+ "dms:ModifyInstanceProfile": {"passedTo": ["dms"], "notRead": "no member of the request names a role"},+ "dms:ModifyMigrationProject": {"passedTo": ["dms"], "roles": [+ {"member": "SchemaConversionApplicationAttributes.S3BucketRoleArn", "passedTo": "dms"},+ {"member": "SourceDataProviderDescriptors[].SecretsManagerAccessRoleArn", "passedTo": "dms"},+ {"member": "TargetDataProviderDescriptors[].SecretsManagerAccessRoleArn", "passedTo": "dms"}+ ]},+ "dms:ModifyReplicationInstance": {"passedTo": ["dms"], "byHand": "the role of the Kerberos settings"},+ "dms:StartReplicationTaskAssessmentRun": {"passedTo": ["dms"], "roles": [+ {"member": "ServiceAccessRoleArn", "passedTo": "dms"}+ ]},+ "dsql:CreateStream": {"passedTo": ["dsql"], "roles": [+ {"member": "targetDefinition.kinesis.roleArn", "passedTo": "dsql"}+ ]},+ "ec2:AssociateIamInstanceProfile": {"passedTo": ["ec2"], "byHand": "the roles of the instance profile it names"},+ "ec2:CreateFlowLogs": {"passedTo": ["vpc-flow-logs"], "byHand": "the delivery role"},+ "ec2:CreateLaunchTemplate": {"passedTo": ["ec2"], "byHand": "the roles of the instance profile the template names"},+ "ec2:CreateLaunchTemplateVersion": {"passedTo": ["ec2"], "byHand": "the roles of the instance profile the template names"},+ "ec2:ReplaceIamInstanceProfileAssociation": {"passedTo": ["ec2"], "byHand": "the roles of the instance profile it names"},+ "ec2:RequestSpotFleet": {"passedTo": ["ec2"], "notRead": "the request names its roles in EC2's own protocol, one of them as an instance profile"},+ "ec2:RequestSpotInstances": {"passedTo": ["ec2"], "byHand": "the roles of the instance profile it names"},+ "ec2:RunInstances": {"passedTo": ["ec2"], "byHand": "the roles of the instance profile it names"},+ "ecr:CreatePullThroughCacheRule": {"passedTo": ["ecr"], "roles": [+ {"member": "customRoleArn", "passedTo": "ecr"}+ ]},+ "ecr:CreateRepositoryCreationTemplate": {"passedTo": ["ecr"], "roles": [+ {"member": "customRoleArn", "passedTo": "ecr"}+ ]},+ "ecr:UpdatePullThroughCacheRule": {"passedTo": ["ecr"], "roles": [+ {"member": "customRoleArn", "passedTo": "ecr"}+ ]},+ "ecr:UpdateRepositoryCreationTemplate": {"passedTo": ["ecr"], "roles": [+ {"member": "customRoleArn", "passedTo": "ecr"}+ ]},+ "ecs:CreateCapacityProvider": {"passedTo": ["ecs"], "byHand": "the infrastructure role, by name or ARN"},+ "ecs:CreateDaemon": {"passedTo": ["ecs-tasks"], "notRead": "the roles are the daemon task definition's, which only a lookup finds"},+ "ecs:CreateExpressGatewayService": {"passedTo": ["ecs", "ecs-tasks"], "roles": [+ {"member": "executionRoleArn", "passedTo": "ecs-tasks"},+ {"member": "infrastructureRoleArn", "passedTo": "ecs"},+ {"member": "taskRoleArn", "passedTo": "ecs-tasks"}+ ]},+ "ecs:CreateGateway": {"passedTo": ["ecs"], "notRead": "botocore's model has no such operation"},+ "ecs:CreateService": {"passedTo": ["ecs", "ecs-tasks"], "byHand": "the task definition's roles and the service's infrastructure roles"},+ "ecs:CreateTaskSet": {"passedTo": ["ecs-tasks"], "byHand": "the task definition's roles"},+ "ecs:RegisterDaemonTaskDefinition": {"passedTo": ["ecs-tasks"], "roles": [+ {"member": "executionRoleArn", "passedTo": "ecs-tasks"},+ {"member": "taskRoleArn", "passedTo": "ecs-tasks", "byName": true}+ ]},+ "ecs:RegisterTaskDefinition": {"passedTo": ["ecs-tasks"], "byHand": "the task and task execution roles, by name or ARN"},+ "ecs:RunTask": {"passedTo": ["ecs", "ecs-tasks"], "byHand": "the task definition's roles, their overrides and the volumes' infrastructure role"},+ "ecs:StartTask": {"passedTo": ["ecs", "ecs-tasks"], "byHand": "the task definition's roles, their overrides and the volumes' infrastructure role"},+ "ecs:UpdateCapacityProvider": {"passedTo": ["ecs"], "byHand": "the infrastructure role, by name or ARN"},+ "ecs:UpdateDaemon": {"passedTo": ["ecs-tasks"], "notRead": "the roles are the daemon task definition's, which only a lookup finds"},+ "ecs:UpdateExpressGatewayService": {"passedTo": ["ecs", "ecs-tasks"], "roles": [+ {"member": "executionRoleArn", "passedTo": "ecs-tasks"},+ {"member": "taskRoleArn", "passedTo": "ecs-tasks"}+ ]},+ "ecs:UpdateGateway": {"passedTo": ["ecs"], "notRead": "botocore's model has no such operation"},+ "ecs:UpdateService": {"passedTo": ["ecs", "ecs-tasks"], "byHand": "the task definition's roles and the service's infrastructure roles"},+ "eks:CreateAccessEntry": {"passedTo": ["ec2"], "byHand": "the principal, for the node types alone"},+ "eks:CreateAddon": {"passedTo": ["eks"], "byHand": "the service account role and each Pod Identity association's role"},+ "eks:CreateCapability": {"passedTo": ["eks"], "roles": [+ {"member": "roleArn", "passedTo": "eks"}+ ]},+ "eks:CreateCluster": {"passedTo": ["ec2", "eks"], "byHand": "the cluster role"},+ "eks:CreateFargateProfile": {"passedTo": ["eks"], "byHand": "the pod execution role"},+ "eks:CreateNodegroup": {"passedTo": ["eks"], "byHand": "the node role"},+ "eks:CreatePodIdentityAssociation": {"passedTo": ["pods.eks"], "byHand": "the association's role, not its target role"},+ "eks:RegisterCluster": {"passedTo": ["eks"], "roles": [+ {"member": "connectorConfig.roleArn", "passedTo": "eks"}+ ]},+ "eks:UpdateAddon": {"passedTo": ["eks"], "byHand": "the service account role and each Pod Identity association's role"},+ "eks:UpdateCapability": {"passedTo": ["eks"], "roles": [+ {"member": "roleArn", "passedTo": "eks"}+ ]},+ "eks:UpdateClusterConfig": {"passedTo": ["ec2", "eks"], "notRead": "the reference passes the node role to ec2 or eks and nothing says which"},+ "eks:UpdatePodIdentityAssociation": {"passedTo": ["pods.eks"], "byHand": "the association's role, not its target role"},+ "elasticmapreduce:CreateStudio": {"passedTo": [], "roles": [+ {"member": "ServiceRole"},+ {"member": "UserRole"}+ ]},+ "elasticmapreduce:RunJobFlow": {"passedTo": ["application-autoscaling", "ec2", "elasticmapreduce"], "notRead": "JobFlowRole names an instance profile, and the reference passes the roles to three services without saying which goes where"},+ "elasticmapreduce:StartNotebookExecution": {"passedTo": [], "roles": [+ {"member": "ExecutionEngine.ExecutionRoleArn"},+ {"member": "ServiceRole", "byName": true}+ ]},+ "elasticmapreduce:StartSession": {"passedTo": ["elasticmapreduce"], "roles": [+ {"member": "ExecutionRoleArn", "passedTo": "elasticmapreduce"}+ ]},+ "elasticmapreduce:UpdateStudio": {"passedTo": [], "notRead": "no member of the request names a role"},+ "events:CreateEndpoint": {"passedTo": ["events"], "roles": [+ {"member": "RoleArn", "passedTo": "events"}+ ]},+ "events:CreateSubscriber": {"passedTo": ["events"], "roles": [+ {"member": "InvokeConfiguration.RoleArn", "passedTo": "events"}+ ]},+ "events:PutRule": {"passedTo": ["events"], "byHand": "the rule's role"},+ "events:PutTargets": {"passedTo": ["events"], "byHand": "each target's role"},+ "events:UpdateEndpoint": {"passedTo": ["events"], "roles": [+ {"member": "RoleArn", "passedTo": "events"}+ ]},+ "events:UpdateSubscriber": {"passedTo": ["events"], "roles": [+ {"member": "InvokeConfiguration.RoleArn", "passedTo": "events"}+ ]},+ "firehose:CreateDeliveryStream": {"passedTo": ["firehose"], "roles": [+ {"member": "AmazonOpenSearchServerlessDestinationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "AmazonOpenSearchServerlessDestinationConfiguration.S3Configuration.RoleARN", "passedTo": "firehose"},+ {"member": "AmazonOpenSearchServerlessDestinationConfiguration.VpcConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "AmazonopensearchserviceDestinationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "AmazonopensearchserviceDestinationConfiguration.S3Configuration.RoleARN", "passedTo": "firehose"},+ {"member": "AmazonopensearchserviceDestinationConfiguration.VpcConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "DatabaseSourceConfiguration.DatabaseSourceAuthenticationConfiguration.SecretsManagerConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "ElasticsearchDestinationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "ElasticsearchDestinationConfiguration.S3Configuration.RoleARN", "passedTo": "firehose"},+ {"member": "ElasticsearchDestinationConfiguration.VpcConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "ExtendedS3DestinationConfiguration.DataFormatConversionConfiguration.SchemaConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "ExtendedS3DestinationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "ExtendedS3DestinationConfiguration.S3BackupConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "HttpEndpointDestinationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "HttpEndpointDestinationConfiguration.S3Configuration.RoleARN", "passedTo": "firehose"},+ {"member": "HttpEndpointDestinationConfiguration.SecretsManagerConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "IcebergDestinationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "IcebergDestinationConfiguration.S3Configuration.RoleARN", "passedTo": "firehose"},+ {"member": "KinesisStreamSourceConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "MSKSourceConfiguration.AuthenticationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "RedshiftDestinationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "RedshiftDestinationConfiguration.S3BackupConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "RedshiftDestinationConfiguration.S3Configuration.RoleARN", "passedTo": "firehose"},+ {"member": "RedshiftDestinationConfiguration.SecretsManagerConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "S3DestinationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "SnowflakeDestinationConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "SnowflakeDestinationConfiguration.S3Configuration.RoleARN", "passedTo": "firehose"},+ {"member": "SnowflakeDestinationConfiguration.SecretsManagerConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "SplunkDestinationConfiguration.S3Configuration.RoleARN", "passedTo": "firehose"},+ {"member": "SplunkDestinationConfiguration.SecretsManagerConfiguration.RoleARN", "passedTo": "firehose"}+ ]},+ "firehose:UpdateDestination": {"passedTo": ["firehose"], "roles": [+ {"member": "AmazonOpenSearchServerlessDestinationUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "AmazonOpenSearchServerlessDestinationUpdate.S3Update.RoleARN", "passedTo": "firehose"},+ {"member": "AmazonopensearchserviceDestinationUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "AmazonopensearchserviceDestinationUpdate.S3Update.RoleARN", "passedTo": "firehose"},+ {"member": "ElasticsearchDestinationUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "ElasticsearchDestinationUpdate.S3Update.RoleARN", "passedTo": "firehose"},+ {"member": "ExtendedS3DestinationUpdate.DataFormatConversionConfiguration.SchemaConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "ExtendedS3DestinationUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "ExtendedS3DestinationUpdate.S3BackupUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "HttpEndpointDestinationUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "HttpEndpointDestinationUpdate.S3Update.RoleARN", "passedTo": "firehose"},+ {"member": "HttpEndpointDestinationUpdate.SecretsManagerConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "IcebergDestinationUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "IcebergDestinationUpdate.S3Configuration.RoleARN", "passedTo": "firehose"},+ {"member": "RedshiftDestinationUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "RedshiftDestinationUpdate.S3BackupUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "RedshiftDestinationUpdate.S3Update.RoleARN", "passedTo": "firehose"},+ {"member": "RedshiftDestinationUpdate.SecretsManagerConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "S3DestinationUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "SnowflakeDestinationUpdate.RoleARN", "passedTo": "firehose"},+ {"member": "SnowflakeDestinationUpdate.S3Update.RoleARN", "passedTo": "firehose"},+ {"member": "SnowflakeDestinationUpdate.SecretsManagerConfiguration.RoleARN", "passedTo": "firehose"},+ {"member": "SplunkDestinationUpdate.S3Update.RoleARN", "passedTo": "firehose"},+ {"member": "SplunkDestinationUpdate.SecretsManagerConfiguration.RoleARN", "passedTo": "firehose"}+ ]},+ "glue:CreateCatalog": {"passedTo": ["glue"], "roles": [+ {"member": "CatalogInput.CatalogProperties.DataLakeAccessProperties.DataTransferRole", "passedTo": "glue"},+ {"member": "CatalogInput.CatalogProperties.IcebergOptimizationProperties.RoleArn", "passedTo": "glue"}+ ]},+ "glue:CreateColumnStatisticsTaskSettings": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue"}+ ]},+ "glue:CreateConnection": {"passedTo": ["glue"], "roles": [+ {"member": "ConnectionInput.ConnectionProperties{ROLE_ARN}", "passedTo": "glue"}+ ]},+ "glue:CreateCrawler": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue", "byName": true}+ ]},+ "glue:CreateDevEndpoint": {"passedTo": ["glue"], "roles": [+ {"member": "RoleArn", "passedTo": "glue"}+ ]},+ "glue:CreateIntegrationResourceProperty": {"passedTo": ["glue"], "roles": [+ {"member": "SourceProcessingProperties.RoleArn", "passedTo": "glue"},+ {"member": "TargetProcessingProperties.RoleArn", "passedTo": "glue"}+ ]},+ "glue:CreateJob": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue", "byName": true}+ ]},+ "glue:CreateMLTransform": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue", "byName": true}+ ]},+ "glue:CreateSession": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue"}+ ]},+ "glue:CreateTable": {"passedTo": ["glue"], "roles": [+ {"member": "TableInput.ViewDefinition.Definer", "passedTo": "glue"}+ ]},+ "glue:CreateTableOptimizer": {"passedTo": ["glue"], "roles": [+ {"member": "TableOptimizerConfiguration.roleArn", "passedTo": "glue"}+ ]},+ "glue:GetJob": {"passedTo": ["glue"], "notRead": "no member of the request names a role"},+ "glue:GetJobs": {"passedTo": ["glue"], "notRead": "no member of the request names a role"},+ "glue:PutDataCatalogEncryptionSettings": {"passedTo": ["glue"], "roles": [+ {"member": "DataCatalogEncryptionSettings.EncryptionAtRest.CatalogEncryptionServiceRole", "passedTo": "glue"}+ ]},+ "glue:StartBlueprintRun": {"passedTo": ["glue"], "roles": [+ {"member": "RoleArn", "passedTo": "glue"}+ ]},+ "glue:StartColumnStatisticsTaskRun": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue"}+ ]},+ "glue:StartDataQualityRuleRecommendationRun": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue"}+ ]},+ "glue:StartDataQualityRulesetEvaluationRun": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue"}+ ]},+ "glue:TestConnection": {"passedTo": ["glue"], "roles": [+ {"member": "TestConnectionInput.ConnectionProperties{ROLE_ARN}", "passedTo": "glue"}+ ]},+ "glue:UpdateCatalog": {"passedTo": ["glue"], "roles": [+ {"member": "CatalogInput.CatalogProperties.DataLakeAccessProperties.DataTransferRole", "passedTo": "glue"},+ {"member": "CatalogInput.CatalogProperties.IcebergOptimizationProperties.RoleArn", "passedTo": "glue"}+ ]},+ "glue:UpdateColumnStatisticsTaskSettings": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue"}+ ]},+ "glue:UpdateConnection": {"passedTo": ["glue"], "roles": [+ {"member": "ConnectionInput.ConnectionProperties{ROLE_ARN}", "passedTo": "glue"}+ ]},+ "glue:UpdateCrawler": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue", "byName": true}+ ]},+ "glue:UpdateIntegrationResourceProperty": {"passedTo": ["glue"], "roles": [+ {"member": "SourceProcessingProperties.RoleArn", "passedTo": "glue"},+ {"member": "TargetProcessingProperties.RoleArn", "passedTo": "glue"}+ ]},+ "glue:UpdateJob": {"passedTo": ["glue"], "roles": [+ {"member": "JobUpdate.Role", "passedTo": "glue", "byName": true}+ ]},+ "glue:UpdateMLTransform": {"passedTo": ["glue"], "roles": [+ {"member": "Role", "passedTo": "glue", "byName": true}+ ]},+ "glue:UpdateTable": {"passedTo": ["glue"], "roles": [+ {"member": "TableInput.ViewDefinition.Definer", "passedTo": "glue"}+ ]},+ "glue:UpdateTableOptimizer": {"passedTo": ["glue"], "roles": [+ {"member": "TableOptimizerConfiguration.roleArn", "passedTo": "glue"}+ ]},+ "iam:AddRoleToInstanceProfile": {"passedTo": ["ec2"], "byHand": "the role it adds, on the ARN IAM holds it under"},+ "kinesis:CreateChannel": {"passedTo": ["kinesis"], "roles": [+ {"member": "ServiceExecutionRoleARN", "passedTo": "kinesis"}+ ]},+ "kinesisanalytics:AddApplicationCloudWatchLoggingOption": {"passedTo": ["kinesisanalytics"], "roles": [+ {"member": "CloudWatchLoggingOption.RoleARN", "passedTo": "kinesisanalytics"}+ ]},+ "kinesisanalytics:AddApplicationInput": {"passedTo": ["kinesisanalytics"], "roles": [+ {"member": "Input.InputProcessingConfiguration.InputLambdaProcessor.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Input.KinesisFirehoseInput.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Input.KinesisStreamsInput.RoleARN", "passedTo": "kinesisanalytics"}+ ]},+ "kinesisanalytics:AddApplicationOutput": {"passedTo": ["kinesisanalytics"], "roles": [+ {"member": "Output.KinesisFirehoseOutput.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Output.KinesisStreamsOutput.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Output.LambdaOutput.RoleARN", "passedTo": "kinesisanalytics"}+ ]},+ "kinesisanalytics:AddApplicationReferenceDataSource": {"passedTo": ["kinesisanalytics"], "roles": [+ {"member": "ReferenceDataSource.S3ReferenceDataSource.ReferenceRoleARN", "passedTo": "kinesisanalytics"}+ ]},+ "kinesisanalytics:CreateApplication": {"passedTo": ["kinesisanalytics"], "roles": [+ {"member": "CloudWatchLoggingOptions[].RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Inputs[].InputProcessingConfiguration.InputLambdaProcessor.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Inputs[].KinesisFirehoseInput.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Inputs[].KinesisStreamsInput.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Outputs[].KinesisFirehoseOutput.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Outputs[].KinesisStreamsOutput.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "Outputs[].LambdaOutput.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "ServiceExecutionRole", "passedTo": "kinesisanalytics"}+ ]},+ "kinesisanalytics:DiscoverInputSchema": {"passedTo": ["kinesisanalytics"], "roles": [+ {"member": "InputProcessingConfiguration.InputLambdaProcessor.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "S3Configuration.RoleARN", "passedTo": "kinesisanalytics"},+ {"member": "ServiceExecutionRole", "passedTo": "kinesisanalytics"}+ ]},+ "kinesisanalytics:UpdateApplication": {"passedTo": ["kinesisanalytics"], "roles": [+ {"member": "ApplicationUpdate.CloudWatchLoggingOptionUpdates[].RoleARNUpdate", "passedTo": "kinesisanalytics"},+ {"member": "ApplicationUpdate.InputUpdates[].InputProcessingConfigurationUpdate.InputLambdaProcessorUpdate.RoleARNUpdate", "passedTo": "kinesisanalytics"},+ {"member": "ApplicationUpdate.InputUpdates[].KinesisFirehoseInputUpdate.RoleARNUpdate", "passedTo": "kinesisanalytics"},+ {"member": "ApplicationUpdate.InputUpdates[].KinesisStreamsInputUpdate.RoleARNUpdate", "passedTo": "kinesisanalytics"},+ {"member": "ApplicationUpdate.OutputUpdates[].KinesisFirehoseOutputUpdate.RoleARNUpdate", "passedTo": "kinesisanalytics"},+ {"member": "ApplicationUpdate.OutputUpdates[].KinesisStreamsOutputUpdate.RoleARNUpdate", "passedTo": "kinesisanalytics"},+ {"member": "ApplicationUpdate.OutputUpdates[].LambdaOutputUpdate.RoleARNUpdate", "passedTo": "kinesisanalytics"},+ {"member": "ApplicationUpdate.ReferenceDataSourceUpdates[].S3ReferenceDataSourceUpdate.ReferenceRoleARNUpdate", "passedTo": "kinesisanalytics"},+ {"member": "ServiceExecutionRoleUpdate", "passedTo": "kinesisanalytics"}+ ]},+ "lambda:AddEventSource": {"passedTo": ["lambda"], "notRead": "botocore's model has no such operation"},+ "lambda:CreateCapacityProvider": {"passedTo": ["lambda"], "roles": [+ {"member": "PermissionsConfig.CapacityProviderOperatorRoleArn", "passedTo": "lambda"}+ ]},+ "lambda:CreateFunction": {"passedTo": ["lambda"], "byHand": "the execution role"},+ "lambda:CreateMicrovmImage": {"passedTo": ["lambda"], "byHand": "the build role"},+ "lambda:CreateNetworkConnector": {"passedTo": ["lambda"], "byHand": "the operator role"},+ "lambda:CreateWebFunction": {"passedTo": ["lambda"], "byHand": "the execution role"},+ "lambda:CreateWebFunctionRevision": {"passedTo": ["lambda"], "byHand": "the execution role"},+ "lambda:RunMicrovm": {"passedTo": ["lambda"], "byHand": "the execution role"},+ "lambda:UpdateFunctionConfiguration": {"passedTo": ["lambda"], "byHand": "the execution role"},+ "lambda:UpdateMicrovmImage": {"passedTo": ["lambda"], "byHand": "the build role"},+ "lambda:UpdateNetworkConnector": {"passedTo": ["lambda"], "byHand": "the operator role"},+ "logs:CreateImportTask": {"passedTo": ["cloudtrail", "logs"], "notRead": "the reference passes the role to cloudtrail or logs and nothing says which"},+ "logs:CreateScheduledQuery": {"passedTo": ["logs"], "roles": [+ {"member": "destinationConfiguration.lookupTableConfiguration.roleArn", "passedTo": "logs"},+ {"member": "destinationConfiguration.s3Configuration.roleArn", "passedTo": "logs"},+ {"member": "executionRoleArn", "passedTo": "logs"}+ ]},+ "logs:PutAccountPolicy": {"passedTo": ["logs"], "byHand": "the role a subscription filter policy's document names"},+ "logs:PutDestination": {"passedTo": ["logs"], "roles": [+ {"member": "roleArn", "passedTo": "logs"}+ ]},+ "logs:PutSubscriptionFilter": {"passedTo": ["logs"], "roles": [+ {"member": "roleArn", "passedTo": "logs"}+ ]},+ "logs:UpdateScheduledQuery": {"passedTo": ["logs"], "roles": [+ {"member": "destinationConfiguration.lookupTableConfiguration.roleArn", "passedTo": "logs"},+ {"member": "destinationConfiguration.s3Configuration.roleArn", "passedTo": "logs"},+ {"member": "executionRoleArn", "passedTo": "logs"}+ ]},+ "pipes:CreatePipe": {"passedTo": ["pipes"], "byHand": "the pipe's role"},+ "pipes:UpdatePipe": {"passedTo": ["pipes"], "byHand": "the pipe's role"},+ "rds:AddRoleToDBCluster": {"passedTo": ["rds"], "byHand": "the role it adds"},+ "rds:AddRoleToDBInstance": {"passedTo": ["rds", "rds-preview"], "byHand": "the role it adds"},+ "rds:CreateBlueGreenDeployment": {"passedTo": ["rds"], "notRead": "no member of the request names a role"},+ "rds:CreateDBCluster": {"passedTo": ["rds", "rds-preview"], "byHand": "the directory, monitoring and associated roles"},+ "rds:CreateDBInstance": {"passedTo": ["rds", "rds-preview"], "byHand": "the directory and monitoring roles"},+ "rds:CreateDBInstanceReadReplica": {"passedTo": ["rds", "rds-preview"], "byHand": "the directory and monitoring roles"},+ "rds:CreateDBProxy": {"passedTo": ["rds"], "byHand": "the proxy's role"},+ "rds:ModifyDBCluster": {"passedTo": ["rds", "rds-preview"], "byHand": "the directory and monitoring roles"},+ "rds:ModifyDBInstance": {"passedTo": ["rds", "rds-preview"], "byHand": "the directory and monitoring roles"},+ "rds:ModifyDBProxy": {"passedTo": ["rds"], "byHand": "the proxy's role"},+ "rds:ModifyOptionGroup": {"passedTo": ["rds"], "byHand": "the role each option takes in its IAM_ROLE_ARN setting"},+ "rds:RemoveRoleFromDBCluster": {"passedTo": ["rds"], "byHand": "the role it removes"},+ "rds:RemoveRoleFromDBInstance": {"passedTo": ["rds"], "byHand": "the role it removes"},+ "rds:RestoreDBClusterFromS3": {"passedTo": ["rds", "rds-preview"], "roles": [+ {"member": "AssociatedRoles[DBClusterAssociatedRole].RoleArn", "passedTo": "rds"},+ {"member": "DomainIAMRoleName", "passedTo": "rds", "byName": true},+ {"member": "S3IngestionRoleArn", "passedTo": "rds"}+ ]},+ "rds:RestoreDBClusterFromSnapshot": {"passedTo": ["rds"], "byHand": "the directory, monitoring and associated roles"},+ "rds:RestoreDBClusterToPointInTime": {"passedTo": ["rds"], "byHand": "the directory, monitoring and associated roles"},+ "rds:RestoreDBInstanceFromDBSnapshot": {"passedTo": ["rds", "rds-preview"], "byHand": "the directory role"},+ "rds:RestoreDBInstanceFromS3": {"passedTo": ["rds"], "roles": [+ {"member": "MonitoringRoleArn", "passedTo": "rds"},+ {"member": "S3IngestionRoleArn", "passedTo": "rds"}+ ]},+ "rds:RestoreDBInstanceToPointInTime": {"passedTo": ["rds", "rds-preview"], "byHand": "the directory role"},+ "rds:StartExportTask": {"passedTo": ["rds"], "byHand": "the export role"},+ "redshift-serverless:CreateNamespace": {"passedTo": ["redshift-serverless"], "byHand": "the namespace's roles and its default"},+ "redshift-serverless:CreateScheduledAction": {"passedTo": ["redshift-serverless"], "byHand": "the scheduled action's role"},+ "redshift-serverless:UpdateLakehouseConfiguration": {"passedTo": ["redshift-serverless"], "notRead": "no member of the request names a role"},+ "redshift-serverless:UpdateNamespace": {"passedTo": ["redshift-serverless"], "byHand": "the namespace's roles and its default"},+ "redshift-serverless:UpdateScheduledAction": {"passedTo": ["redshift-serverless"], "byHand": "the scheduled action's role"},+ "redshift:CreateCluster": {"passedTo": ["redshift"], "byHand": "the roles it associates"},+ "redshift:CreateScheduledAction": {"passedTo": ["redshift"], "roles": [+ {"member": "IamRole", "passedTo": "redshift"}+ ]},+ "redshift:ModifyClusterIamRoles": {"passedTo": ["redshift"], "byHand": "the roles it associates"},+ "redshift:ModifyLakehouseConfiguration": {"passedTo": ["redshift"], "notRead": "no member of the request names a role"},+ "redshift:ModifyScheduledAction": {"passedTo": ["redshift"], "roles": [+ {"member": "IamRole", "passedTo": "redshift"}+ ]},+ "redshift:RestoreFromClusterSnapshot": {"passedTo": ["redshift"], "byHand": "the roles it associates"},+ "rekognition:CreateStreamProcessor": {"passedTo": ["rekognition"], "roles": [+ {"member": "RoleArn", "passedTo": "rekognition"}+ ]},+ "rekognition:StartCelebrityRecognition": {"passedTo": ["rekognition"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "rekognition"}+ ]},+ "rekognition:StartContentModeration": {"passedTo": ["rekognition"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "rekognition"}+ ]},+ "rekognition:StartFaceDetection": {"passedTo": ["rekognition"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "rekognition"}+ ]},+ "rekognition:StartFaceSearch": {"passedTo": ["rekognition"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "rekognition"}+ ]},+ "rekognition:StartLabelDetection": {"passedTo": ["rekognition"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "rekognition"}+ ]},+ "rekognition:StartSegmentDetection": {"passedTo": ["rekognition"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "rekognition"}+ ]},+ "rekognition:StartTextDetection": {"passedTo": ["rekognition"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "rekognition"}+ ]},+ "resource-groups:StartTagSyncTask": {"passedTo": ["resource-groups"], "roles": [+ {"member": "RoleArn", "passedTo": "resource-groups"}+ ]},+ "s3:CreateAccessGrantsLocation": {"passedTo": [], "notRead": "the request body is XML, which PassedRoles does not read"},+ "s3:PutBucketReplication": {"passedTo": ["s3"], "notRead": "the request body is XML, which PassedRoles does not read"},+ "sagemaker:CreateAIBenchmarkJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateAIRecommendationJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateAlgorithm": {"passedTo": ["sagemaker"], "roles": [+ {"member": "ValidationSpecification.ValidationRole", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateAutoMLJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateAutoMLJobV2": {"passedTo": ["sagemaker"], "roles": [+ {"member": "AutoMLComputeConfig.EmrServerlessComputeConfig.ExecutionRoleARN", "passedTo": "sagemaker"},+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateCluster": {"passedTo": ["sagemaker"], "roles": [+ {"member": "ClusterRole", "passedTo": "sagemaker"},+ {"member": "InstanceGroups[].ExecutionRole", "passedTo": "sagemaker"},+ {"member": "RestrictedInstanceGroups[].ExecutionRole", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateCompilationJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateDataQualityJobDefinition": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateDomain": {"passedTo": ["sagemaker"], "roles": [+ {"member": "DefaultSpaceSettings.ExecutionRole", "passedTo": "sagemaker"},+ {"member": "DefaultUserSettings.CanvasAppSettings.EmrServerlessSettings.ExecutionRoleArn", "passedTo": "sagemaker"},+ {"member": "DefaultUserSettings.CanvasAppSettings.GenerativeAiSettings.AmazonBedrockRoleArn", "passedTo": "sagemaker"},+ {"member": "DefaultUserSettings.CanvasAppSettings.TimeSeriesForecastingSettings.AmazonForecastRoleArn", "passedTo": "sagemaker"},+ {"member": "DefaultUserSettings.ExecutionRole", "passedTo": "sagemaker"},+ {"member": "DomainSettings.RStudioServerProDomainSettings.DomainExecutionRoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateEndpointConfig": {"passedTo": ["sagemaker"], "roles": [+ {"member": "ExecutionRoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateFeatureGroup": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateFlowDefinition": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateHyperParameterTuningJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "TrainingJobDefinition.RoleArn", "passedTo": "sagemaker"},+ {"member": "TrainingJobDefinitions[].RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateImage": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateInferenceExperiment": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateInferenceRecommendationsJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateJob": {"passedTo": ["job.sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "job.sagemaker"}+ ]},+ "sagemaker:CreateLabelingJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateMlflowApp": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateMlflowTrackingServer": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateModel": {"passedTo": ["sagemaker"], "roles": [+ {"member": "ExecutionRoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateModelBiasJobDefinition": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateModelExplainabilityJobDefinition": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateModelPackage": {"passedTo": ["sagemaker"], "roles": [+ {"member": "ValidationSpecification.ValidationRole", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateModelQualityJobDefinition": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateMonitoringSchedule": {"passedTo": ["sagemaker"], "roles": [+ {"member": "MonitoringScheduleConfig.MonitoringJobDefinition.RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateNotebookInstance": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateOptimizationJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreatePartnerApp": {"passedTo": ["sagemaker"], "roles": [+ {"member": "ExecutionRoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreatePipeline": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateProcessingJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateProject": {"passedTo": ["sagemaker"], "roles": [+ {"member": "TemplateProviders[].CfnTemplateProvider.RoleARN", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateTrainingJob": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:CreateTrainingSession": {"passedTo": ["sagemaker", "training-session.sagemaker"], "notRead": "the reference passes the role to sagemaker or training-session.sagemaker and nothing says which"},+ "sagemaker:CreateTransformJob": {"passedTo": ["sagemaker"], "notRead": "no member of the request names a role"},+ "sagemaker:CreateUserProfile": {"passedTo": ["sagemaker"], "roles": [+ {"member": "UserSettings.CanvasAppSettings.EmrServerlessSettings.ExecutionRoleArn", "passedTo": "sagemaker"},+ {"member": "UserSettings.CanvasAppSettings.GenerativeAiSettings.AmazonBedrockRoleArn", "passedTo": "sagemaker"},+ {"member": "UserSettings.CanvasAppSettings.TimeSeriesForecastingSettings.AmazonForecastRoleArn", "passedTo": "sagemaker"},+ {"member": "UserSettings.ExecutionRole", "passedTo": "sagemaker"}+ ]},+ "sagemaker:ImportHubContent": {"passedTo": ["sagemaker"], "notRead": "no member of the request names a role"},+ "sagemaker:RenderUiTemplate": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:UpdateCluster": {"passedTo": ["sagemaker"], "roles": [+ {"member": "ClusterRole", "passedTo": "sagemaker"},+ {"member": "InstanceGroups[].ExecutionRole", "passedTo": "sagemaker"},+ {"member": "RestrictedInstanceGroups[].ExecutionRole", "passedTo": "sagemaker"}+ ]},+ "sagemaker:UpdateDomain": {"passedTo": ["sagemaker"], "roles": [+ {"member": "DefaultSpaceSettings.ExecutionRole", "passedTo": "sagemaker"},+ {"member": "DefaultUserSettings.CanvasAppSettings.EmrServerlessSettings.ExecutionRoleArn", "passedTo": "sagemaker"},+ {"member": "DefaultUserSettings.CanvasAppSettings.GenerativeAiSettings.AmazonBedrockRoleArn", "passedTo": "sagemaker"},+ {"member": "DefaultUserSettings.CanvasAppSettings.TimeSeriesForecastingSettings.AmazonForecastRoleArn", "passedTo": "sagemaker"},+ {"member": "DefaultUserSettings.ExecutionRole", "passedTo": "sagemaker"},+ {"member": "DomainSettingsForUpdate.RStudioServerProDomainSettingsForUpdate.DomainExecutionRoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:UpdateImage": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:UpdateMonitoringSchedule": {"passedTo": ["sagemaker"], "roles": [+ {"member": "MonitoringScheduleConfig.MonitoringJobDefinition.RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:UpdateNotebookInstance": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:UpdatePipeline": {"passedTo": ["sagemaker"], "roles": [+ {"member": "RoleArn", "passedTo": "sagemaker"}+ ]},+ "sagemaker:UpdateUserProfile": {"passedTo": ["sagemaker"], "roles": [+ {"member": "UserSettings.CanvasAppSettings.EmrServerlessSettings.ExecutionRoleArn", "passedTo": "sagemaker"},+ {"member": "UserSettings.CanvasAppSettings.GenerativeAiSettings.AmazonBedrockRoleArn", "passedTo": "sagemaker"},+ {"member": "UserSettings.CanvasAppSettings.TimeSeriesForecastingSettings.AmazonForecastRoleArn", "passedTo": "sagemaker"},+ {"member": "UserSettings.ExecutionRole", "passedTo": "sagemaker"}+ ]},+ "scheduler:CreateSchedule": {"passedTo": ["scheduler"], "byHand": "the target's role"},+ "scheduler:UpdateSchedule": {"passedTo": ["scheduler"], "byHand": "the target's role"},+ "secretsmanager:RotateSecret": {"passedTo": ["secretsmanager"], "roles": [+ {"member": "ExternalSecretRotationRoleArn", "passedTo": "secretsmanager"}+ ]},+ "servicecatalog:CreateConstraint": {"passedTo": ["servicecatalog"], "byHand": "a launch constraint's role, from its parameters document"},+ "servicecatalog:CreateServiceAction": {"passedTo": ["servicecatalog"], "roles": [+ {"member": "Definition{AssumeRole}", "passedTo": "servicecatalog"}+ ]},+ "servicecatalog:UpdateConstraint": {"passedTo": ["servicecatalog"], "byHand": "a launch constraint's role, by the type the constraint holds"},+ "servicecatalog:UpdateProvisionedProductProperties": {"passedTo": ["servicecatalog"], "roles": [+ {"member": "ProvisionedProductProperties{LAUNCH_ROLE}", "passedTo": "servicecatalog"}+ ]},+ "servicecatalog:UpdateServiceAction": {"passedTo": ["servicecatalog"], "roles": [+ {"member": "Definition{AssumeRole}", "passedTo": "servicecatalog"}+ ]},+ "ses:CreateConfigurationSetEventDestination": {"passedTo": ["ses"], "roles": [+ {"member": "EventDestination.KinesisFirehoseDestination.IAMRoleARN", "passedTo": "ses"},+ {"member": "EventDestination.KinesisFirehoseDestination.IamRoleArn", "passedTo": "ses"}+ ]},+ "ses:CreateReceiptRule": {"passedTo": ["ses"], "roles": [+ {"member": "Rule.Actions[].ConnectAction.IAMRoleARN", "passedTo": "ses"},+ {"member": "Rule.Actions[].S3Action.IamRoleArn", "passedTo": "ses"}+ ]},+ "ses:CreateRuleSet": {"passedTo": ["ses"], "roles": [+ {"member": "Rules[].Actions[].Bounce.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].DeliverToMailbox.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].DeliverToQBusiness.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].InvokeLambda.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].PublishToSns.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].Send.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].WriteToS3.RoleArn", "passedTo": "ses"}+ ]},+ "ses:UpdateConfigurationSetEventDestination": {"passedTo": ["ses"], "roles": [+ {"member": "EventDestination.KinesisFirehoseDestination.IAMRoleARN", "passedTo": "ses"},+ {"member": "EventDestination.KinesisFirehoseDestination.IamRoleArn", "passedTo": "ses"}+ ]},+ "ses:UpdateReceiptRule": {"passedTo": ["ses"], "roles": [+ {"member": "Rule.Actions[].ConnectAction.IAMRoleARN", "passedTo": "ses"},+ {"member": "Rule.Actions[].S3Action.IamRoleArn", "passedTo": "ses"}+ ]},+ "ses:UpdateRuleSet": {"passedTo": ["ses"], "roles": [+ {"member": "Rules[].Actions[].Bounce.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].DeliverToMailbox.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].DeliverToQBusiness.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].InvokeLambda.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].PublishToSns.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].Send.RoleArn", "passedTo": "ses"},+ {"member": "Rules[].Actions[].WriteToS3.RoleArn", "passedTo": "ses"}+ ]},+ "sns:CreatePlatformApplication": {"passedTo": ["sns"], "byHand": "the delivery status roles among its attributes"},+ "sns:CreateTopic": {"passedTo": ["sns"], "byHand": "the delivery status roles among its attributes"},+ "sns:SetPlatformApplicationAttributes": {"passedTo": ["sns"], "byHand": "the delivery status roles among its attributes"},+ "sns:SetSMSAttributes": {"passedTo": ["sns"], "byHand": "the delivery status role among its attributes"},+ "sns:SetSubscriptionAttributes": {"passedTo": ["sns"], "byHand": "the subscription role, when it is the attribute set"},+ "sns:SetTopicAttributes": {"passedTo": ["sns"], "byHand": "a delivery status role, when it is the attribute set"},+ "sns:Subscribe": {"passedTo": ["sns"], "byHand": "the subscription role among its attributes"},+ "ssm:CreateActivation": {"passedTo": ["ssm"], "roles": [+ {"member": "IamRole", "passedTo": "ssm", "byName": true}+ ]},+ "ssm:CreateAssociation": {"passedTo": ["ssm"], "roles": [+ {"member": "AssociationDispatchAssumeRole", "passedTo": "ssm"}+ ]},+ "ssm:CreateAssociationBatch": {"passedTo": ["ssm"], "roles": [+ {"member": "AssociationDispatchAssumeRole", "passedTo": "ssm"}+ ]},+ "ssm:CreateCloudConnector": {"passedTo": ["ssm"], "roles": [+ {"member": "RoleArn", "passedTo": "ssm"}+ ]},+ "ssm:CreateDocument": {"passedTo": ["justintimeaccess.ssm", "ssm"], "notRead": "no member of the request names a role"},+ "ssm:DescribeAutomationStepExecutions": {"passedTo": ["ssm"], "notRead": "no member of the request names a role"},+ "ssm:GetAutomationExecution": {"passedTo": ["ssm"], "notRead": "no member of the request names a role"},+ "ssm:RegisterTaskWithMaintenanceWindow": {"passedTo": ["ssm"], "roles": [+ {"member": "ServiceRoleArn", "passedTo": "ssm"},+ {"member": "TaskInvocationParameters.RunCommand.ServiceRoleArn", "passedTo": "ssm"}+ ]},+ "ssm:SendCommand": {"passedTo": ["ssm"], "roles": [+ {"member": "ServiceRoleArn", "passedTo": "ssm"}+ ]},+ "ssm:StartAutomationExecution": {"passedTo": ["ssm"], "notRead": "the role is a parameter of the runbook it runs, not a member of the request"},+ "ssm:StartChangeRequestExecution": {"passedTo": ["ssm"], "notRead": "the role is a parameter of the runbook it runs, not a member of the request"},+ "ssm:UpdateAssociation": {"passedTo": ["ssm"], "roles": [+ {"member": "AssociationDispatchAssumeRole", "passedTo": "ssm"}+ ]},+ "ssm:UpdateDocument": {"passedTo": ["justintimeaccess.ssm", "ssm"], "notRead": "no member of the request names a role"},+ "ssm:UpdateMaintenanceWindowTask": {"passedTo": ["ssm"], "roles": [+ {"member": "ServiceRoleArn", "passedTo": "ssm"},+ {"member": "TaskInvocationParameters.RunCommand.ServiceRoleArn", "passedTo": "ssm"}+ ]},+ "ssm:UpdateManagedInstanceRole": {"passedTo": ["ssm"], "roles": [+ {"member": "IamRole", "passedTo": "ssm", "byName": true}+ ]},+ "ssm:UpdateServiceSetting": {"passedTo": ["ssm"], "notRead": "a role is only ever a setting's value, which the request names by SettingId"},+ "states:CreateStateMachine": {"passedTo": ["states"], "byHand": "the state machine's role"},+ "states:TestState": {"passedTo": ["states"], "roles": [+ {"member": "roleArn", "passedTo": "states"}+ ]},+ "states:UpdateStateMachine": {"passedTo": ["states"], "byHand": "the state machine's role"},+ "swf:RegisterWorkflowType": {"passedTo": ["swf"], "roles": [+ {"member": "defaultLambdaRole", "passedTo": "swf"}+ ]},+ "swf:RespondDecisionTaskCompleted": {"passedTo": ["swf"], "byHand": "the Lambda role of each decision that starts an execution, read from the attributes its decisionType names"},+ "swf:StartWorkflowExecution": {"passedTo": ["swf"], "roles": [+ {"member": "lambdaRole", "passedTo": "swf"}+ ]},+ "textract:StartDocumentAnalysis": {"passedTo": ["textract"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "textract"}+ ]},+ "textract:StartDocumentTextDetection": {"passedTo": ["textract"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "textract"}+ ]},+ "textract:StartExpenseAnalysis": {"passedTo": ["textract"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "textract"}+ ]},+ "textract:StartLendingAnalysis": {"passedTo": ["textract"], "roles": [+ {"member": "NotificationChannel.RoleArn", "passedTo": "textract"}+ ]},+ "transcribe:CreateLanguageModel": {"passedTo": ["transcribe"], "roles": [+ {"member": "InputDataConfig.DataAccessRoleArn", "passedTo": "transcribe"}+ ]},+ "transcribe:CreateVocabulary": {"passedTo": ["transcribe"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "transcribe"}+ ]},+ "transcribe:CreateVocabularyFilter": {"passedTo": ["transcribe"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "transcribe"}+ ]},+ "transcribe:StartCallAnalyticsJob": {"passedTo": ["transcribe"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "transcribe"}+ ]},+ "transcribe:StartMedicalScribeJob": {"passedTo": ["transcribe"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "transcribe"}+ ]},+ "transcribe:StartTranscriptionJob": {"passedTo": ["transcribe"], "roles": [+ {"member": "JobExecutionSettings.DataAccessRoleArn", "passedTo": "transcribe"}+ ]},+ "transcribe:UpdateLanguageModel": {"passedTo": ["transcribe"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "transcribe"}+ ]},+ "transcribe:UpdateVocabulary": {"passedTo": ["transcribe"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "transcribe"}+ ]},+ "transcribe:UpdateVocabularyFilter": {"passedTo": ["transcribe"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "transcribe"}+ ]},+ "transfer:CreateAccess": {"passedTo": ["transfer"], "roles": [+ {"member": "Role", "passedTo": "transfer"}+ ]},+ "transfer:CreateAgreement": {"passedTo": ["transfer"], "roles": [+ {"member": "AccessRole", "passedTo": "transfer"}+ ]},+ "transfer:CreateConnector": {"passedTo": ["transfer"], "roles": [+ {"member": "AccessRole", "passedTo": "transfer"},+ {"member": "LoggingRole", "passedTo": "transfer"}+ ]},+ "transfer:CreateServer": {"passedTo": ["transfer"], "roles": [+ {"member": "IdentityProviderDetails.InvocationRole", "passedTo": "transfer"},+ {"member": "LoggingRole", "passedTo": "transfer"},+ {"member": "WorkflowDetails.OnPartialUpload[].ExecutionRole", "passedTo": "transfer"},+ {"member": "WorkflowDetails.OnUpload[].ExecutionRole", "passedTo": "transfer"}+ ]},+ "transfer:CreateUser": {"passedTo": ["transfer"], "roles": [+ {"member": "Role", "passedTo": "transfer"}+ ]},+ "transfer:CreateWebApp": {"passedTo": ["transfer"], "roles": [+ {"member": "IdentityProviderDetails.IdentityCenterConfig.Role", "passedTo": "transfer"}+ ]},+ "transfer:UpdateAccess": {"passedTo": ["transfer"], "roles": [+ {"member": "Role", "passedTo": "transfer"}+ ]},+ "transfer:UpdateAgreement": {"passedTo": ["transfer"], "roles": [+ {"member": "AccessRole", "passedTo": "transfer"}+ ]},+ "transfer:UpdateConnector": {"passedTo": ["transfer"], "roles": [+ {"member": "AccessRole", "passedTo": "transfer"},+ {"member": "LoggingRole", "passedTo": "transfer"}+ ]},+ "transfer:UpdateServer": {"passedTo": ["transfer"], "roles": [+ {"member": "IdentityProviderDetails.InvocationRole", "passedTo": "transfer"},+ {"member": "LoggingRole", "passedTo": "transfer"},+ {"member": "WorkflowDetails.OnPartialUpload[].ExecutionRole", "passedTo": "transfer"},+ {"member": "WorkflowDetails.OnUpload[].ExecutionRole", "passedTo": "transfer"}+ ]},+ "transfer:UpdateUser": {"passedTo": ["transfer"], "roles": [+ {"member": "Role", "passedTo": "transfer"}+ ]},+ "transfer:UpdateWebApp": {"passedTo": ["transfer"], "roles": [+ {"member": "IdentityProviderDetails.IdentityCenterConfig.Role", "passedTo": "transfer"}+ ]},+ "translate:StartTextTranslationJob": {"passedTo": ["translate"], "roles": [+ {"member": "DataAccessRoleArn", "passedTo": "translate"}+ ]}+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/core/common/PassedRoleMembersTest.java b/src/test/java/io/github/hectorvent/floci/core/common/PassedRoleMembersTest.javanew file mode 100644index 0000000000..c1367b8358--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/PassedRoleMembersTest.java@@ -0,0 +1,255 @@+package io.github.hectorvent.floci.core.common;++import com.fasterxml.jackson.databind.JsonNode;+import com.fasterxml.jackson.databind.ObjectMapper;+import com.fasterxml.jackson.databind.node.ObjectNode;+import com.fasterxml.jackson.databind.node.TextNode;+import io.github.hectorvent.floci.core.common.PassedRoleMembers.Into;+import io.github.hectorvent.floci.core.common.PassedRoleMembers.Member;+import io.github.hectorvent.floci.core.common.PassedRoleMembers.Step;+import io.github.hectorvent.floci.core.common.PassedRoles.PassedRole;+import jakarta.ws.rs.container.ContainerRequestContext;+import jakarta.ws.rs.core.MediaType;+import org.junit.jupiter.api.DynamicTest;+import org.junit.jupiter.api.Test;+import org.junit.jupiter.api.TestFactory;++import java.io.ByteArrayInputStream;+import java.net.URLEncoder;+import java.nio.charset.StandardCharsets;+import java.util.ArrayList;+import java.util.List;+import java.util.Optional;+import java.util.stream.Stream;++import static org.junit.jupiter.api.Assertions.assertEquals;+import static org.junit.jupiter.api.Assertions.assertFalse;+import static org.junit.jupiter.api.Assertions.assertNotNull;+import static org.junit.jupiter.api.Assertions.assertNull;+import static org.junit.jupiter.api.Assertions.assertThrows;+import static org.junit.jupiter.api.Assertions.assertTrue;+import static org.mockito.Mockito.mock;+import static org.mockito.Mockito.when;++/**+ * The vendored table of where each operation's request names the roles it passes, and that+ * {@link PassedRoles} reads every member it gives, from a JSON body and from Query form parameters.+ */+class PassedRoleMembersTest {++ private static final ObjectMapper MAPPER = new ObjectMapper();+ private static final String ROLE = "arn:aws:iam::111122223333:role/passed";+ private static final String NAMED = "named-role";+ private static final String HELD = "arn:aws:iam::111122223333:role/held/named-role";++ /** IAM holds {@code named-role} under the path {@code /held/}; nothing else is there to look up. */+ private static final PassedRoles.Lookups LOOKUPS = new PassedRoles.Lookups() {+ @Override+ public List<String> instanceProfileRoleArns(String profileName, String profileArn) {+ return List.of();+ }++ @Override+ public List<String> taskDefinitionRoles(String reference) {+ return List.of();+ }++ @Override+ public Optional<String> stackSetPermissionModel(String stackSetName) {+ return Optional.empty();+ }++ @Override+ public Optional<String> launchTemplateInstanceProfile(String templateId, String templateName, String version) {+ return Optional.empty();+ }++ @Override+ public Optional<String> launchConfigurationInstanceProfile(String instanceId) {+ return Optional.empty();+ }++ @Override+ public Optional<String> instanceRefreshInstanceProfile(String groupName, String templateId,+ String templateName, String version) {+ return Optional.empty();+ }++ @Override+ public String roleArn(String roleName) {+ return "arn:aws:iam::111122223333:role/" + roleName;+ }++ @Override+ public Optional<String> heldRoleArn(String roleName) {+ return NAMED.equals(roleName) ? Optional.of(HELD) : Optional.empty();+ }++ @Override+ public Optional<String> serviceCatalogConstraintType(String constraintId) {+ return Optional.empty();+ }+ };++ @Test+ void theTableReadsTheOperationsOfEveryNamespaceItCoversOnce() {+ PassedRoleMembers.Table table = PassedRoleMembers.table();+ assertFalse(table.members().isEmpty());+ for (String operation : table.members().keySet()) {+ assertFalse(table.byHand().contains(operation) || table.notRead().contains(operation), operation);+ assertTrue(table.namespaces().contains(operation.substring(0, operation.indexOf(':'))), operation);+ }+ assertFalse(table.byHand().stream().anyMatch(table.notRead()::contains));+ assertTrue(table.otherNamespaces().stream().noneMatch(table.namespaces()::contains));+ assertTrue(table.notCovered().stream().noneMatch(table.namespaces()::contains));+ }++ @Test+ void aMemberPathIsReadAsItsSteps() {+ Member list = member("Rule.Actions[].S3Action.IamRoleArn", "ses");+ assertEquals(List.of(new Step("Rule", Into.NONE, null), new Step("Actions", Into.LIST, ""),+ new Step("S3Action", Into.NONE, null), new Step("IamRoleArn", Into.NONE, null)), list.steps());+ assertTrue(list.queryKeys().matcher("Rule.Actions.member.2.S3Action.IamRoleArn").matches());+ assertTrue(list.queryKeys().matcher("Rule.Actions.2.S3Action.IamRoleArn").matches());+ assertFalse(list.queryKeys().matcher("Rule.Actions.S3Action.IamRoleArn").matches());++ Member named = member("AssociatedRoles[DBClusterAssociatedRole].RoleArn", "rds");+ assertTrue(named.queryKeys().matcher("AssociatedRoles.DBClusterAssociatedRole.1.RoleArn").matches());+ assertTrue(named.queryKeys().matcher("AssociatedRoles.member.1.RoleArn").matches());+ assertFalse(named.queryKeys().matcher("AssociatedRoles.Other.1.RoleArn").matches());++ assertTrue(member("Roles{}", null).queryKeys().matcher("Roles.entry.3.value").matches());+ // One key of a map cannot be told apart in a form, whose keys and values are separate parameters.+ Member key = member("Definition{AssumeRole}", "servicecatalog");+ assertEquals(new Step("Definition", Into.KEY, "AssumeRole"), key.steps().get(0));+ assertNull(key.queryKeys());+ }++ @Test+ void aMalformedTableFailsToLoad() {+ assertThrows(IllegalStateException.class, () -> parse("{\"operations\":{}}"));+ assertThrows(IllegalStateException.class, () -> parse("{\"operations\":{\"a:B\":{\"passedTo\":[]}}}"));+ assertThrows(IllegalStateException.class, () -> parse(+ "{\"operations\":{\"a:B\":{\"passedTo\":[],\"roles\":[{\"member\":\"A..B\"}]}}}"));+ }++ /**+ * Every operation the table says is read by hand has a case in {@link PassedRoles#byHand}, and no+ * other operation of the table does, so neither shadows the other.+ */+ @Test+ void exactlyTheOperationsReadByHandHaveACaseOfTheirOwn() {+ PassedRoleMembers.Table table = PassedRoleMembers.table();+ for (String operation : table.byHand()) {+ assertNotNull(PassedRoles.byHand(operation, json("{}"), LOOKUPS), operation + " has no case of its own");+ }+ Stream.concat(table.members().keySet().stream(), table.notRead().stream()).forEach(operation ->+ assertNull(PassedRoles.byHand(operation, json("{}"), LOOKUPS),+ operation + " is read by hand; say so in the generator's BY_HAND"));+ }++ @TestFactory+ Stream<DynamicTest> everyMemberOfTheTableIsReadFromAJsonBody() {+ return PassedRoleMembers.table().members().entrySet().stream()+ .flatMap(operation -> operation.getValue().stream().map(member -> DynamicTest.dynamicTest(+ operation.getKey() + " " + member.path(), () -> assertEquals(List.of(expected(member)),+ PassedRoles.of(operation.getKey(), json(body(member).toString()), LOOKUPS)))));+ }++ @TestFactory+ Stream<DynamicTest> everyMemberOfTheTableAQueryRequestCanCarryIsReadFromItsForm() {+ return PassedRoleMembers.table().members().entrySet().stream()+ .flatMap(operation -> operation.getValue().stream()+ .filter(member -> member.queryKeys() != null)+ .map(member -> DynamicTest.dynamicTest(operation.getKey() + " " + member.path(),+ () -> assertEquals(List.of(expected(member)),+ PassedRoles.of(operation.getKey(), form(formKey(member) + "="+ + URLEncoder.encode(value(member), StandardCharsets.UTF_8)), LOOKUPS)))));+ }++ @TestFactory+ Stream<DynamicTest> aMemberHoldingSomethingOtherThanARolePassesNothing() {+ return PassedRoleMembers.table().members().entrySet().stream()+ .flatMap(operation -> operation.getValue().stream().map(member -> DynamicTest.dynamicTest(+ operation.getKey() + " " + member.path(), () -> assertEquals(List.of(),+ PassedRoles.of(operation.getKey(),+ json(body(member, "arn:aws:s3:::bucket").toString()), LOOKUPS)))));+ }++ /** The role a request names at the member: by name where the member takes one, else by ARN. */+ private static String value(Member member) {+ return member.byName() ? NAMED : ROLE;+ }++ private static PassedRole expected(Member member) {+ return new PassedRole(member.byName() ? HELD : ROLE,+ member.passedTo() == null ? null : ServicePrincipals.of(member.passedTo()));+ }++ private static JsonNode body(Member member) {+ return body(member, value(member));+ }++ private static JsonNode body(Member member, String value) {+ JsonNode node = TextNode.valueOf(value);+ List<Step> steps = member.steps();+ for (int i = steps.size() - 1; i >= 0; i--) {+ Step step = steps.get(i);+ JsonNode inner = switch (step.into()) {+ case NONE -> node;+ case LIST -> MAPPER.createArrayNode().add(node);+ case MAP -> MAPPER.createObjectNode().set("any", node);+ case KEY -> MAPPER.createObjectNode().set(step.key(), node);+ };+ ObjectNode outer = MAPPER.createObjectNode();+ outer.set(step.name(), inner);+ node = outer;+ }+ return node;+ }++ /** The member's form key, a list's first element in the generic form and a map's first value. */+ private static String formKey(Member member) {+ List<String> parts = new ArrayList<>();+ for (Step step : member.steps()) {+ parts.add(step.name());+ if (step.into() == Into.LIST) {+ parts.add("member.1");+ } else if (step.into() == Into.MAP) {+ parts.add("entry.1.value");+ }+ }+ return String.join(".", parts);+ }++ private static Member member(String path, String passedTo) {+ String role = passedTo == null ? "{\"member\":\"" + path + "\"}"+ : "{\"member\":\"" + path + "\",\"passedTo\":\"" + passedTo + "\"}";+ try {+ return parse("{\"operations\":{\"a:B\":{\"passedTo\":[],\"roles\":[" + role + "]}}}")+ .members().get("a:B").get(0);+ } catch (Exception e) {+ throw new AssertionError(e);+ }+ }++ private static PassedRoleMembers.Table parse(String document) throws Exception {+ return PassedRoleMembers.parse(new ByteArrayInputStream(document.getBytes(StandardCharsets.UTF_8)));+ }++ private static ContainerRequestContext json(String body) {+ return request("application/x-amz-json-1.1", body);+ }++ private static ContainerRequestContext form(String body) {+ return request("application/x-www-form-urlencoded", body);+ }++ private static ContainerRequestContext request(String mediaType, String body) {+ byte[] bytes = body.getBytes(StandardCharsets.UTF_8);+ ContainerRequestContext request = mock(ContainerRequestContext.class);+ when(request.getMediaType()).thenReturn(MediaType.valueOf(mediaType));+ when(request.getEntityStream()).thenAnswer(invocation -> new ByteArrayInputStream(bytes));+ return request;+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/core/common/PassedRoleNamespacesIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/core/common/PassedRoleNamespacesIntegrationTest.javanew file mode 100644index 0000000000..cc2e545f7b--- /dev/null+++ b/src/test/java/io/github/hectorvent/floci/core/common/PassedRoleNamespacesIntegrationTest.java@@ -0,0 +1,35 @@+package io.github.hectorvent.floci.core.common;++import io.quarkus.test.junit.QuarkusTest;+import jakarta.inject.Inject;+import org.junit.jupiter.api.Test;++import java.util.Set;+import java.util.TreeSet;++import static org.junit.jupiter.api.Assertions.assertEquals;++/**+ * Every IAM namespace Floci serves whose operations the Service Reference lists with {@code iam:PassRole} is+ * one the vendored table of passed roles reads, or one it names as not read yet, so a service Floci adds is+ * not left passing roles unchecked.+ */+@QuarkusTest+class PassedRoleNamespacesIntegrationTest {++ @Inject+ ResolvedServiceCatalog catalog;++ @Test+ void everyNamespaceFlociServesThatPassesARoleIsReadOrNamedAsNotReadYet() {+ Set<String> served = new TreeSet<>();+ for (ServiceDescriptor descriptor : catalog.all()) {+ for (String scope : descriptor.credentialScopes()) {+ served.add(catalog.canonicalCredentialScope(scope));+ }+ }+ Set<String> unread = new TreeSet<>(served);+ unread.retainAll(PassedRoleMembers.table().otherNamespaces());+ assertEquals(Set.of(), unread, "add these to NAMESPACES or NOT_COVERED in tools/aws/regen_iam_passed_roles.py");+ }+}diff --git a/src/test/java/io/github/hectorvent/floci/core/common/PassedRolesTest.java b/src/test/java/io/github/hectorvent/floci/core/common/PassedRolesTest.javaindex 7869300c59..572cabd239 100644--- a/src/test/java/io/github/hectorvent/floci/core/common/PassedRolesTest.java+++ b/src/test/java/io/github/hectorvent/floci/core/common/PassedRolesTest.java@@ -43,7 +43,8 @@ class PassedRolesTest {* instance {@code i-arn} runs with that other profile, and the group {@code g} launches from* {@code lt-web} once a refresh names only a version, or from {@code arn-template} at the group's* version 2 once a refresh names that template alone. IAM holds the role {@code app-role} under the- * path {@code /app/}.+ * path {@code /app/}. Service Catalog holds a launch constraint {@code cons-launch} and a notification+ * constraint {@code cons-notify}.*/private static final PassedRoles.Lookups LOOKUPS = new PassedRoles.Lookups() {@Override@@ -103,6 +104,16 @@ class PassedRolesTest {public Optional<String> heldRoleArn(String roleName) {return "app-role".equals(roleName) ? Optional.of(ROLES + "app/app-role") : Optional.empty();}++ @Override+ public Optional<String> serviceCatalogConstraintType(String constraintId) {+ return switch (constraintId) {+ case "cons-launch" -> Optional.of("LAUNCH");+ case "cons-lowercase" -> Optional.of("launch");+ case "cons-notify" -> Optional.of("NOTIFICATION");+ default -> Optional.empty();+ };+ }};@Test@@ -495,6 +506,197 @@ class PassedRolesTest {}}+ @Test+ void ssmPassesAnAssociationsDispatchRoleAndACommandsNotificationRoleToSsm() {+ String ssm = "ssm.amazonaws.com";+ // An Automation runbook's assume role is a parameter the runbook names, and a target location's+ // execution role is one in each target account: neither is read.+ String association = "{\"Name\":\"doc\",\"AssociationDispatchAssumeRole\":\"" + ROLES + "dispatch\","+ + "\"Parameters\":{\"AutomationAssumeRole\":[\"" + ROLES + "automation\"]},"+ + "\"TargetLocations\":[{\"ExecutionRoleName\":\"execution\"}]}";+ for (String action : new String[] {"ssm:CreateAssociation", "ssm:UpdateAssociation"}) {+ assertEquals(List.of(passed("dispatch", ssm)), PassedRoles.of(action, json(association), LOOKUPS), action);+ assertEquals(List.of(), PassedRoles.of(action, json("{\"Name\":\"doc\"}"), LOOKUPS), action);+ }+ assertEquals(List.of(passed("notifications", ssm)), PassedRoles.of("ssm:SendCommand",+ json("{\"DocumentName\":\"AWS-RunShellScript\",\"ServiceRoleArn\":\"" + ROLES + "notifications\","+ + "\"NotificationConfig\":{\"NotificationArn\":\"arn:aws:sns:us-east-1:111122223333:t\"}}"),+ LOOKUPS));+ // A document's request names no role, and a role is only ever a setting's value.+ assertEquals(List.of(), PassedRoles.of("ssm:CreateDocument",+ json("{\"Name\":\"d\",\"Content\":\"{\\\"assumeRole\\\":\\\"" + ROLES + "runbook\\\"}\"}"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("ssm:UpdateServiceSetting",+ json("{\"SettingId\":\"/ssm/managed-instance/default-ec2-instance-management-role\","+ + "\"SettingValue\":\"service-role/AWSSystemsManagerDefaultEC2InstanceManagementRole\"}"),+ LOOKUPS));+ }++ @Test+ void serviceCatalogPassesTheLaunchRoleAConstraintAnActionOrAProvisionedProductNames() {+ String catalog = "servicecatalog.amazonaws.com";+ assertEquals(List.of(passed("launch", catalog)), PassedRoles.of("servicecatalog:CreateConstraint",+ json(constraint("LAUNCH", "{\\\"RoleArn\\\":\\\"" + ROLES + "launch\\\"}")), LOOKUPS));+ // A local role name carries no path: the ARN IAM holds the role under, or else the one the name gives.+ assertEquals(List.of(new PassedRole(ROLES + "app/app-role", catalog)), PassedRoles.of(+ "servicecatalog:CreateConstraint",+ json(constraint("LAUNCH", "{\\\"LocalRoleName\\\":\\\"app-role\\\"}")), LOOKUPS));+ assertEquals(List.of(passed("gone", catalog)), PassedRoles.of("servicecatalog:CreateConstraint",+ json(constraint("LAUNCH", "{\\\"LocalRoleName\\\":\\\"gone\\\"}")), LOOKUPS));+ // Only a launch constraint names a launch role, and only in a JSON document.+ assertEquals(List.of(), PassedRoles.of("servicecatalog:CreateConstraint",+ json(constraint("NOTIFICATION", "{\\\"RoleArn\\\":\\\"" + ROLES + "launch\\\"}")), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("servicecatalog:CreateConstraint",+ json(constraint("LAUNCH", "RoleArn=" + ROLES + "launch")), LOOKUPS));+ // Floci keeps a constraint's type as given, so a launch constraint is one in any case.+ assertEquals(List.of(passed("launch", catalog)), PassedRoles.of("servicecatalog:CreateConstraint",+ json(constraint("launch", "{\\\"RoleArn\\\":\\\"" + ROLES + "launch\\\"}")), LOOKUPS));++ // An update names no type, so it goes by the constraint's own.+ String parameters = "\"Parameters\":\"{\\\"RoleArn\\\":\\\"" + ROLES + "launch\\\"}\"";+ assertEquals(List.of(passed("launch", catalog)), PassedRoles.of("servicecatalog:UpdateConstraint",+ json("{\"Id\":\"cons-launch\"," + parameters + "}"), LOOKUPS));+ assertEquals(List.of(passed("launch", catalog)), PassedRoles.of("servicecatalog:UpdateConstraint",+ json("{\"Id\":\"cons-lowercase\"," + parameters + "}"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("servicecatalog:UpdateConstraint",+ json("{\"Id\":\"cons-notify\"," + parameters + "}"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("servicecatalog:UpdateConstraint",+ json("{\"Id\":\"cons-missing\"," + parameters + "}"), LOOKUPS));++ for (String action : new String[] {"servicecatalog:CreateServiceAction", "servicecatalog:UpdateServiceAction"}) {+ assertEquals(List.of(passed("action", catalog)), PassedRoles.of(action,+ json("{\"Definition\":{\"Name\":\"AWS-RestartEC2Instance\",\"AssumeRole\":\"" + ROLES+ + "action\"}}"), LOOKUPS), action);+ // LAUNCH_ROLE reuses the provisioned product's launch role, which passes nothing new.+ assertEquals(List.of(), PassedRoles.of(action,+ json("{\"Definition\":{\"AssumeRole\":\"LAUNCH_ROLE\"}}"), LOOKUPS), action);+ }+ assertEquals(List.of(passed("launch", catalog)), PassedRoles.of(+ "servicecatalog:UpdateProvisionedProductProperties",+ json("{\"ProvisionedProductProperties\":{\"LAUNCH_ROLE\":\"" + ROLES + "launch\","+ + "\"OWNER\":\"" + ROLES + "owner\"}}"), LOOKUPS));+ }++ @Test+ void secretsManagerBudgetsAndSwfPassTheRolesTheirRequestsName() {+ assertEquals(List.of(passed("rotation", "secretsmanager.amazonaws.com")), PassedRoles.of(+ "secretsmanager:RotateSecret", json("{\"SecretId\":\"s\",\"ExternalSecretRotationRoleArn\":\""+ + ROLES + "rotation\",\"RotationLambdaARN\":\"arn:aws:lambda:us-east-1:111122223333:"+ + "function:rotate\"}"), LOOKUPS));+ // The roles an IAM budget action attaches its policy to are what it acts on, not roles it passes.+ String budgetAction = "{\"ExecutionRoleArn\":\"" + ROLES + "execution\",\"Definition\":{\"IamActionDefinition\":"+ + "{\"PolicyArn\":\"arn:aws:iam::111122223333:policy/deny\",\"Roles\":[\"" + ROLES + "target\"]}}}";+ for (String action : new String[] {"budgets:CreateBudgetAction", "budgets:UpdateBudgetAction"}) {+ assertEquals(List.of(passed("execution", "budgets.amazonaws.com")),+ PassedRoles.of(action, json(budgetAction), LOOKUPS), action);+ }++ String swf = "swf.amazonaws.com";+ assertEquals(List.of(passed("default", swf)), PassedRoles.of("swf:RegisterWorkflowType",+ json("{\"name\":\"w\",\"defaultLambdaRole\":\"" + ROLES + "default\"}"), LOOKUPS));+ assertEquals(List.of(passed("execution", swf)), PassedRoles.of("swf:StartWorkflowExecution",+ json("{\"workflowId\":\"w\",\"lambdaRole\":\"" + ROLES + "execution\"}"), LOOKUPS));+ // Each decision is read from the attributes its type names, as the SWF handler reads it.+ assertEquals(List.of(passed("next", swf), passed("child", swf)), PassedRoles.of(+ "swf:RespondDecisionTaskCompleted", json("{\"taskToken\":\"t\",\"decisions\":["+ + "{\"decisionType\":\"ContinueAsNewWorkflowExecution\","+ + "\"continueAsNewWorkflowExecutionDecisionAttributes\":{\"lambdaRole\":\"" + ROLES + "next\"}},"+ + "{\"decisionType\":\"ScheduleLambdaFunction\","+ + "\"scheduleLambdaFunctionDecisionAttributes\":{\"id\":\"f\",\"name\":\"f\"}},"+ + "{\"decisionType\":\"StartChildWorkflowExecution\","+ + "\"startChildWorkflowExecutionDecisionAttributes\":{\"lambdaRole\":\"" + ROLES + "child\"},"+ + "\"continueAsNewWorkflowExecutionDecisionAttributes\":{\"lambdaRole\":\"" + ROLES + "unread\"}}]}"),+ LOOKUPS));+ }++ @Test+ void snsPassesTheRolesItsAttributesNameToSns() {+ String sns = "sns.amazonaws.com";+ // Read as the Query handler reads the map: up to the first entry with no key, a key's last value.+ assertEquals(List.of(passed("lambda-success", sns), passed("sqs-failure", sns)), PassedRoles.of("sns:CreateTopic",+ form("Name=t&Attributes.entry.1.key=LambdaSuccessFeedbackRoleArn&Attributes.entry.1.value=" + ROLES+ + "first&Attributes.entry.2.key=DisplayName&Attributes.entry.2.value=" + ROLES + "display"+ + "&Attributes.entry.3.key=SQSFailureFeedbackRoleArn&Attributes.entry.3.value=" + ROLES+ + "sqs-failure&Attributes.entry.4.key=LambdaSuccessFeedbackRoleArn&Attributes.entry.4.value="+ + ROLES + "lambda-success&Attributes.entry.6.key=HTTPSuccessFeedbackRoleArn"+ + "&Attributes.entry.6.value=" + ROLES + "after-gap"), LOOKUPS));+ assertEquals(List.of(passed("firehose", sns)), PassedRoles.of("sns:CreateTopic",+ json("{\"Name\":\"t\",\"Attributes\":{\"FirehoseFailureFeedbackRoleArn\":\"" + ROLES+ + "firehose\",\"Policy\":\"{}\"}}"), LOOKUPS));+ assertEquals(List.of(passed("http", sns)), PassedRoles.of("sns:SetTopicAttributes",+ form("TopicArn=t&AttributeName=HTTPSuccessFeedbackRoleArn&AttributeValue=" + ROLES + "http"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("sns:SetTopicAttributes",+ form("TopicArn=t&AttributeName=DisplayName&AttributeValue=" + ROLES + "http"), LOOKUPS));+ // A role attribute with no value names no role; SNS answers the request.+ assertEquals(List.of(), PassedRoles.of("sns:SetTopicAttributes",+ form("TopicArn=t&AttributeName=HTTPSuccessFeedbackRoleArn"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("sns:SetTopicAttributes",+ json("{\"TopicArn\":\"t\",\"AttributeName\":\"HTTPSuccessFeedbackRoleArn\"}"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("sns:SetSubscriptionAttributes",+ form("SubscriptionArn=s&AttributeName=SubscriptionRoleArn"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("sns:SetSubscriptionAttributes",+ json("{\"SubscriptionArn\":\"s\",\"AttributeName\":\"SubscriptionRoleArn\",\"AttributeValue\":null}"),+ LOOKUPS));+ // A subscription's role is its own attribute, not a topic's.+ assertEquals(List.of(passed("subscription", sns)), PassedRoles.of("sns:Subscribe",+ form("TopicArn=t&Protocol=firehose&Attributes.entry.1.key=SubscriptionRoleArn&Attributes.entry.1.value="+ + ROLES + "subscription"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("sns:Subscribe",+ form("TopicArn=t&Attributes.entry.1.key=LambdaSuccessFeedbackRoleArn&Attributes.entry.1.value="+ + ROLES + "topic"), LOOKUPS));+ assertEquals(List.of(passed("subscription", sns)), PassedRoles.of("sns:SetSubscriptionAttributes",+ json("{\"SubscriptionArn\":\"s\",\"AttributeName\":\"SubscriptionRoleArn\",\"AttributeValue\":\""+ + ROLES + "subscription\"}"), LOOKUPS));+ for (String action : new String[] {"sns:CreatePlatformApplication", "sns:SetPlatformApplicationAttributes"}) {+ assertEquals(List.of(passed("platform", sns)), PassedRoles.of(action,+ form("Name=a&Attributes.entry.1.key=FailureFeedbackRoleArn&Attributes.entry.1.value=" + ROLES+ + "platform"), LOOKUPS), action);+ }+ assertEquals(List.of(passed("sms", sns)), PassedRoles.of("sns:SetSMSAttributes",+ form("attributes.entry.1.key=DeliveryStatusIAMRole&attributes.entry.1.value=" + ROLES + "sms"), LOOKUPS));+ }++ @Test+ void aLogsSubscriptionFilterPolicyPassesTheRoleItsDocumentNamesToLogs() {+ String document = "\"{\\\"DestinationArn\\\":\\\"arn:aws:kinesis:us-east-1:111122223333:stream/s\\\","+ + "\\\"RoleArn\\\":\\\"" + ROLES + "delivery\\\"}\"";+ assertEquals(List.of(passed("delivery", "logs.amazonaws.com")), PassedRoles.of("logs:PutAccountPolicy",+ json("{\"policyName\":\"p\",\"policyType\":\"SUBSCRIPTION_FILTER_POLICY\",\"policyDocument\":"+ + document + "}"), LOOKUPS));+ // Another type of policy names no role, and a document that is not JSON names none either.+ assertEquals(List.of(), PassedRoles.of("logs:PutAccountPolicy",+ json("{\"policyName\":\"p\",\"policyType\":\"FIELD_INDEX_POLICY\",\"policyDocument\":"+ + document + "}"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("logs:PutAccountPolicy",+ json("{\"policyName\":\"p\",\"policyType\":\"SUBSCRIPTION_FILTER_POLICY\",\"policyDocument\":"+ + "\"RoleArn=" + ROLES + "delivery\"}"), LOOKUPS));+ }++ @Test+ void theTableReadsARoleInAQueryListAByNameMemberAMapAndOneWithNoNamedService() {+ // SES's receipt rule actions in either list form the Query protocol sends.+ assertEquals(List.of(passed("connect", "ses.amazonaws.com"), passed("s3", "ses.amazonaws.com")),+ PassedRoles.of("ses:CreateReceiptRule", form("RuleSetName=r&Rule.Name=n"+ + "&Rule.Actions.member.1.S3Action.IamRoleArn=" + ROLES + "s3"+ + "&Rule.Actions.2.ConnectAction.IAMRoleARN=" + ROLES + "connect"), LOOKUPS));+ // Glue takes a job's role by name, which is the role IAM holds under it, path included.+ assertEquals(List.of(new PassedRole(ROLES + "app/app-role", "glue.amazonaws.com")),+ PassedRoles.of("glue:CreateJob", json("{\"Name\":\"j\",\"Role\":\"app-role\"}"), LOOKUPS));+ assertEquals(List.of(passed("gone", "glue.amazonaws.com")),+ PassedRoles.of("glue:CreateJob", json("{\"Name\":\"j\",\"Role\":\"gone\"}"), LOOKUPS));+ // An identity pool's roles are the values of a map, which the Service Reference passes to no service.+ assertEquals(List.of(new PassedRole(ROLES + "authenticated", null)), PassedRoles.of(+ "cognito-identity:SetIdentityPoolRoles", json("{\"IdentityPoolId\":\"p\",\"Roles\":{\"authenticated\":\""+ + ROLES + "authenticated\"}}"), LOOKUPS));+ // A member taking only an ARN passes nothing for a name.+ assertEquals(List.of(), PassedRoles.of("codebuild:CreateProject",+ json("{\"name\":\"p\",\"serviceRole\":\"app-role\"}"), LOOKUPS));+ }++ private static String constraint(String type, String parameters) {+ return "{\"PortfolioId\":\"port\",\"ProductId\":\"prod\",\"Type\":\"" + type + "\",\"Parameters\":\""+ + parameters + "\"}";+ }+private static PassedRole passed(String roleName, String service) {return new PassedRole(ROLES + roleName, service);}diff --git a/src/test/java/io/github/hectorvent/floci/services/iam/IamPassRoleEnforcementIntegrationTest.java b/src/test/java/io/github/hectorvent/floci/services/iam/IamPassRoleEnforcementIntegrationTest.javaindex e2dd20ba38..59defc61f3 100644--- a/src/test/java/io/github/hectorvent/floci/services/iam/IamPassRoleEnforcementIntegrationTest.java+++ b/src/test/java/io/github/hectorvent/floci/services/iam/IamPassRoleEnforcementIntegrationTest.java@@ -23,6 +23,7 @@ import java.io.IOException;import java.net.URI;import java.util.LinkedHashMap;import java.util.Map;+import java.util.UUID;import java.util.zip.GZIPOutputStream;import static io.github.hectorvent.floci.testing.EnforcementFixtures.auth;@@ -57,6 +58,8 @@ class IamPassRoleEnforcementIntegrationTest {private static final String REDSHIFT_SERVERLESS = "redshift-serverless.amazonaws.com";private static final String RDS = "rds.amazonaws.com";private static final String DMS = "dms.amazonaws.com";+ private static final String SSM = "ssm.amazonaws.com";+ private static final String SERVICE_CATALOG = "servicecatalog.amazonaws.com";private static final String SERVICE_LINKED_ROLES ="arn:aws:iam::" + ACCOUNT + ":role/aws-service-role/autoscaling.amazonaws.com/";private static final ObjectMapper CBOR_MAPPER = new ObjectMapper(new CBORFactory());@@ -1119,6 +1122,353 @@ class IamPassRoleEnforcementIntegrationTest {"{\"Resources\":{\"Q\":{\"Type\":\"AWS::SQS::Queue\"}}}");}+ @Test+ void anSsmAssociationAndACommandNeedPassRoleOnTheRolesTheyNameForSsm() {+ String role = role("ssm-dispatch");+ User user = user("passrole-ssm");+ String association = "{\"Name\":\"passrole-missing-document\",\"InstanceId\":\"i-0123456789abcdef0\","+ + "\"AssociationDispatchAssumeRole\":\"" + role + "\"}";+ String update = "{\"AssociationId\":\"" + UUID.randomUUID() + "\",\"AssociationDispatchAssumeRole\":\""+ + role + "\"}";+ // The command names no instance, so SSM refuses it once it is authorized.+ String command = "{\"DocumentName\":\"AWS-RunShellScript\",\"ServiceRoleArn\":\"" + role + "\"}";+ String actions = allow("ssm:CreateAssociation", "*") + "," + allow("ssm:UpdateAssociation", "*") + ","+ + allow("ssm:SendCommand", "*");++ // A grant to pass the role to Lambda does not cover SSM.+ user.policy(actions + "," + passRole(role, LAMBDA));+ deniedJson(ssm(user, "CreateAssociation").body(association).post("/").then());+ deniedJson(ssm(user, "UpdateAssociation").body(update).post("/").then());+ deniedJson(ssm(user, "SendCommand").body(command).post("/").then());++ user.policy(actions + "," + passRole(role, SSM));+ ssm(user, "CreateAssociation").body(association).post("/").then()+ .statusCode(400).body(containsString("InvalidDocument"));+ ssm(user, "UpdateAssociation").body(update).post("/").then()+ .statusCode(400).body(containsString("AssociationDoesNotExist"));+ ssm(user, "SendCommand").body(command).post("/").then()+ .statusCode(400).body(containsString("InvalidInstanceId"));+ }++ @Test+ void aServiceCatalogLaunchRoleNeedsPassRoleForServiceCatalog() {+ String role = role("catalog-launch");+ User user = user("passrole-catalog");+ String portfolio = catalogAdmin("CreatePortfolio", "{\"DisplayName\":\"passrole-" + suffix()+ + "\",\"ProviderName\":\"floci\"}").extract().path("PortfolioDetail.Id");+ cleanup.register(() -> deleteFromCatalog("DeletePortfolio", portfolio));+ String product = catalogAdmin("CreateProduct", "{\"Name\":\"passrole-" + suffix() + "\",\"Owner\":\"floci\","+ + "\"ProvisioningArtifactParameters\":[{\"Name\":\"v1\"}]}")+ .extract().path("ProductViewDetail.ProductViewSummary.Id");+ cleanup.register(() -> deleteFromCatalog("DeleteProduct", product));+ String launch = catalogAdmin("CreateConstraint", constraint(portfolio, product, "LAUNCH", "{}"))+ .extract().path("ConstraintDetail.ConstraintId");+ String notification = catalogAdmin("CreateConstraint", constraint(portfolio, product, "NOTIFICATION",+ "{\\\"NotificationArns\\\":[]}")).extract().path("ConstraintDetail.ConstraintId");+ // Floci keeps a constraint's type as given, so one typed in lowercase is a launch constraint too.+ String lowercase = catalogAdmin("CreateConstraint", constraint(portfolio, product, "launch", "{}"))+ .extract().path("ConstraintDetail.ConstraintId");+ cleanup.register(() -> deleteFromCatalog("DeleteConstraint", launch));+ cleanup.register(() -> deleteFromCatalog("DeleteConstraint", notification));+ cleanup.register(() -> deleteFromCatalog("DeleteConstraint", lowercase));+ String launchRole = "{\\\"RoleArn\\\":\\\"" + role + "\\\"}";+ String create = constraint(portfolio, product, "LAUNCH", launchRole);+ String updateLaunch = "{\"Id\":\"" + launch + "\",\"Parameters\":\"" + launchRole + "\"}";+ String updateNotification = "{\"Id\":\"" + notification + "\",\"Parameters\":\"" + launchRole + "\"}";+ String createLowercase = constraint(portfolio, product, "launch", launchRole);+ String updateLowercase = "{\"Id\":\"" + lowercase + "\",\"Parameters\":\"" + launchRole + "\"}";+ String serviceAction = "{\"Name\":\"passrole-" + suffix() + "\",\"DefinitionType\":\"SSM_AUTOMATION\","+ + "\"Definition\":{\"Name\":\"AWS-RestartEC2Instance\",\"Version\":\"1\",\"AssumeRole\":\""+ + role + "\"},\"IdempotencyToken\":\"" + suffix() + "\"}";+ String properties = "{\"ProvisionedProductId\":\"pp-passrolemissing\",\"IdempotencyToken\":\"" + suffix()+ + "\",\"ProvisionedProductProperties\":{\"LAUNCH_ROLE\":\"" + role + "\"}}";+ String actions = allow("servicecatalog:*", "*");++ // A grant to pass the role to SSM does not cover Service Catalog.+ user.policy(actions + "," + passRole(role, SSM));+ deniedJson(catalog(user, "CreateConstraint").body(create).post("/").then());+ deniedJson(catalog(user, "UpdateConstraint").body(updateLaunch).post("/").then());+ deniedJson(catalog(user, "CreateConstraint").body(createLowercase).post("/").then());+ deniedJson(catalog(user, "UpdateConstraint").body(updateLowercase).post("/").then());+ deniedJson(catalog(user, "CreateServiceAction").body(serviceAction).post("/").then());+ deniedJson(catalog(user, "UpdateProvisionedProductProperties").body(properties).post("/").then());+ // The update goes by the constraint's own type: a notification constraint takes no launch role.+ catalog(user, "UpdateConstraint").body(updateNotification).post("/").then().statusCode(200);++ user.policy(actions + "," + passRole(role, SERVICE_CATALOG));+ String created = catalog(user, "CreateConstraint").body(create).post("/").then().statusCode(200)+ .extract().path("ConstraintDetail.ConstraintId");+ cleanup.register(() -> deleteFromCatalog("DeleteConstraint", created));+ catalog(user, "UpdateConstraint").body(updateLaunch).post("/").then().statusCode(200);+ String action = catalog(user, "CreateServiceAction").body(serviceAction).post("/").then().statusCode(200)+ .extract().path("ServiceActionDetail.ServiceActionSummary.Id");+ cleanup.register(() -> deleteFromCatalog("DeleteServiceAction", action));+ catalog(user, "UpdateProvisionedProductProperties").body(properties).post("/").then()+ .statusCode(400).body(containsString("ResourceNotFoundException"));+ }++ @Test+ void aServiceCatalogLocalRoleNameNeedsPassRoleOnTheArnIamHoldsItUnder() {+ String held = role("/catalog/", "catalog-local");+ String pathless = "arn:aws:iam::" + ACCOUNT + ":role/" + roleName(held);+ User user = user("passrole-catalog-local");+ String update = "{\"Id\":\"cons-passrolemissing\",\"Parameters\":\"{\\\"LocalRoleName\\\":\\\""+ + roleName(held) + "\\\"}\"}";+ String create = constraint("port-passrolemissing", "prod-passrolemissing", "LAUNCH",+ "{\\\"LocalRoleName\\\":\\\"" + roleName(held) + "\\\"}");++ // The name carries no path, but the role it names is the one IAM holds under /catalog/.+ user.policy(allow("servicecatalog:CreateConstraint", "*") + "," + passRole(pathless, SERVICE_CATALOG));+ deniedJson(catalog(user, "CreateConstraint").body(create).post("/").then());+ user.policy(allow("servicecatalog:CreateConstraint", "*") + "," + passRole(held, SERVICE_CATALOG));+ catalog(user, "CreateConstraint").body(create).post("/").then()+ .statusCode(400).body(containsString("ResourceNotFoundException"));++ // A constraint Floci does not hold has no type to read a launch role by, and Service Catalog reports it.+ user.policy(allow("servicecatalog:UpdateConstraint", "*"));+ catalog(user, "UpdateConstraint").body(update).post("/").then()+ .statusCode(400).body(containsString("ResourceNotFoundException"));+ }++ @Test+ void aRotationRoleABudgetActionsRoleAndAWorkflowsLambdaRoleNeedPassRoleForTheirService() {+ String role = role("service-role");+ User user = user("passrole-mixed");+ String rotate = "{\"SecretId\":\"passrole-missing-secret\",\"ExternalSecretRotationRoleArn\":\"" + role + "\"}";+ String budgetAction = ("{\"AccountId\":\"%s\",\"BudgetName\":\"passrole-missing\",\"NotificationType\":\"ACTUAL\","+ + "\"ActionType\":\"APPLY_IAM_POLICY\",\"ActionThreshold\":{\"ActionThresholdValue\":80,"+ + "\"ActionThresholdType\":\"PERCENTAGE\"},\"Definition\":{\"IamActionDefinition\":{\"PolicyArn\":"+ + "\"arn:aws:iam::%s:policy/passrole-deny\",\"Roles\":[\"target\"]}},\"ExecutionRoleArn\":\"%s\","+ + "\"ApprovalModel\":\"AUTOMATIC\",\"Subscribers\":[{\"SubscriptionType\":\"EMAIL\","+ + "\"Address\":\"[email protected]\"}]}").formatted(ACCOUNT, ACCOUNT, role);+ String workflowType = "{\"domain\":\"passrole-missing\",\"name\":\"w\",\"version\":\"1\","+ + "\"defaultLambdaRole\":\"" + role + "\"}";+ String execution = "{\"domain\":\"passrole-missing\",\"workflowId\":\"w\",\"workflowType\":"+ + "{\"name\":\"w\",\"version\":\"1\"},\"lambdaRole\":\"" + role + "\"}";+ String decisions = "{\"taskToken\":\"passrole-missing\",\"decisions\":[{\"decisionType\":"+ + "\"StartChildWorkflowExecution\",\"startChildWorkflowExecutionDecisionAttributes\":"+ + "{\"workflowType\":{\"name\":\"w\",\"version\":\"1\"},\"workflowId\":\"child\","+ + "\"lambdaRole\":\"" + role + "\"}}]}";+ String actions = allow("secretsmanager:RotateSecret", "*") + "," + allow("budgets:CreateBudgetAction", "*")+ + "," + allow("swf:*", "*");++ // Each grant is for another service's principal.+ user.policy(actions + "," + passRole(role, "budgets.amazonaws.com") + "," + passRole(role, SSM));+ deniedJson(user.json("secretsmanager", "secretsmanager.RotateSecret").body(rotate).post("/").then());+ user.policy(actions + "," + passRole(role, "secretsmanager.amazonaws.com") + "," + passRole(role, SSM));+ deniedJson(user.json("budgets", "AWSBudgetServiceGateway.CreateBudgetAction").body(budgetAction).post("/")+ .then());+ user.policy(actions + "," + passRole(role, "secretsmanager.amazonaws.com") + ","+ + passRole(role, "budgets.amazonaws.com"));+ deniedJson(swf(user, "RegisterWorkflowType").body(workflowType).post("/").then());+ deniedJson(swf(user, "StartWorkflowExecution").body(execution).post("/").then());+ deniedJson(swf(user, "RespondDecisionTaskCompleted").body(decisions).post("/").then());++ // With all three, each request reaches its service, which has nothing of that name.+ user.policy(actions + "," + passRole(role, "secretsmanager.amazonaws.com") + ","+ + passRole(role, "budgets.amazonaws.com") + "," + passRole(role, "swf.amazonaws.com"));+ user.json("secretsmanager", "secretsmanager.RotateSecret").body(rotate).post("/").then()+ .statusCode(400).body(containsString("ResourceNotFoundException"));+ user.json("budgets", "AWSBudgetServiceGateway.CreateBudgetAction").body(budgetAction).post("/").then()+ .statusCode(400).body(containsString("NotFoundException"));+ swf(user, "RegisterWorkflowType").body(workflowType).post("/").then()+ .statusCode(400).body(containsString("UnknownResourceFault"));+ swf(user, "StartWorkflowExecution").body(execution).post("/").then()+ .statusCode(400).body(containsString("UnknownResourceFault"));+ swf(user, "RespondDecisionTaskCompleted").body(decisions).post("/").then()+ .statusCode(400).body(containsString("Unknown or expired task token"));+ }++ @Test+ void anSnsTopicsDeliveryStatusRoleNeedsPassRoleForSns() {+ String role = role("sns-feedback");+ User user = user("passrole-sns");+ String topic = "passrole-topic-" + suffix();+ String topicArn = "arn:aws:sns:us-east-1:" + ACCOUNT + ":" + topic;+ String actions = allow("sns:CreateTopic", "*") + "," + allow("sns:SetTopicAttributes", "*");++ user.policy(actions + "," + passRole(role, LAMBDA));+ denied(user.query("sns", "CreateTopic").formParam("Name", topic)+ .formParam("Attributes.entry.1.key", "LambdaFailureFeedbackRoleArn")+ .formParam("Attributes.entry.1.value", role).post("/").then());+ denied(user.query("sns", "SetTopicAttributes").formParam("TopicArn", topicArn)+ .formParam("AttributeName", "SQSSuccessFeedbackRoleArn").formParam("AttributeValue", role)+ .post("/").then());++ user.policy(actions + "," + passRole(role, "sns.amazonaws.com"));+ user.query("sns", "CreateTopic").formParam("Name", topic)+ .formParam("Attributes.entry.1.key", "LambdaFailureFeedbackRoleArn")+ .formParam("Attributes.entry.1.value", role).post("/").then().statusCode(200);+ cleanup.register(() -> admin("sns").formParam("Action", "DeleteTopic").formParam("TopicArn", topicArn).post("/"));+ user.query("sns", "SetTopicAttributes").formParam("TopicArn", topicArn)+ .formParam("AttributeName", "SQSSuccessFeedbackRoleArn").formParam("AttributeValue", role)+ .post("/").then().statusCode(200);++ // A role attribute with no value names no role, so SNS answers it: a topic takes it, and a Firehose+ // subscription refuses it.+ user.policy(actions + "," + allow("sns:SetSubscriptionAttributes", "*"));+ user.query("sns", "SetTopicAttributes").formParam("TopicArn", topicArn)+ .formParam("AttributeName", "SQSSuccessFeedbackRoleArn").post("/").then().statusCode(200);+ String subscription = admin("sns").formParam("Action", "Subscribe").formParam("TopicArn", topicArn)+ .formParam("Protocol", "firehose")+ .formParam("Endpoint", "arn:aws:firehose:us-east-1:" + ACCOUNT + ":deliverystream/passrole")+ .formParam("Attributes.entry.1.key", "SubscriptionRoleArn")+ .formParam("Attributes.entry.1.value", role).post("/").then().statusCode(200)+ .extract().xmlPath().getString("SubscribeResponse.SubscribeResult.SubscriptionArn");+ user.query("sns", "SetSubscriptionAttributes").formParam("SubscriptionArn", subscription)+ .formParam("AttributeName", "SubscriptionRoleArn").post("/").then().statusCode(400)+ .body(containsString("SubscriptionRoleArn must be a valid IAM role ARN"));+ }++ @Test+ void aReceiptRulesRoleAndAMetricStreamsRoleInAQueryRequestNeedPassRoleForTheirService() {+ String role = role("query-roles");+ User user = user("passrole-query");+ String stream = "passrole-stream-" + suffix();+ String actions = allow("ses:CreateReceiptRule", "*") + "," + allow("cloudwatch:PutMetricStream", "*");++ user.policy(actions + "," + passRole(role, LAMBDA));+ denied(receiptRule(user, role).post("/").then());+ denied(metricStream(user, stream, role).post("/").then());++ user.policy(actions + "," + passRole(role, "ses.amazonaws.com") + ","+ + passRole(role, "streams.metrics.cloudwatch.amazonaws.com"));+ receiptRule(user, role).post("/").then().statusCode(400).body(containsString("RuleSetDoesNotExist"));+ metricStream(user, stream, role).post("/").then().statusCode(200);+ cleanup.register(() -> admin("monitoring").formParam("Action", "DeleteMetricStream").formParam("Name", stream)+ .post("/"));+ }++ @Test+ void aBuildProjectsServiceRoleAndADeliveryStreamsRoleNeedPassRoleForTheirService() {+ String role = role("json-roles");+ User user = user("passrole-json");+ String project = "passrole-project-" + suffix();+ String deliveryStream = "passrole-delivery-" + suffix();+ String createProject = ("{\"name\":\"%s\",\"source\":{\"type\":\"NO_SOURCE\",\"buildspec\":\"version: 0.2\"},"+ + "\"artifacts\":{\"type\":\"NO_ARTIFACTS\"},\"environment\":{\"type\":\"LINUX_CONTAINER\","+ + "\"image\":\"aws/codebuild/standard:7.0\",\"computeType\":\"BUILD_GENERAL1_SMALL\"},"+ + "\"serviceRole\":\"%s\"}").formatted(project, role);+ String createStream = ("{\"DeliveryStreamName\":\"%s\",\"ExtendedS3DestinationConfiguration\":"+ + "{\"RoleARN\":\"%s\",\"BucketARN\":\"arn:aws:s3:::passrole-bucket\"}}").formatted(deliveryStream, role);+ String actions = allow("codebuild:CreateProject", "*") + "," + allow("firehose:CreateDeliveryStream", "*");++ user.policy(actions + "," + passRole(role, LAMBDA));+ deniedJson(user.json("codebuild", "CodeBuild_20161006.CreateProject").body(createProject).post("/").then());+ deniedJson(user.json("firehose", "Firehose_20150804.CreateDeliveryStream").body(createStream).post("/").then());++ user.policy(actions + "," + passRole(role, "codebuild.amazonaws.com") + ","+ + passRole(role, "firehose.amazonaws.com"));+ user.json("codebuild", "CodeBuild_20161006.CreateProject").body(createProject).post("/").then().statusCode(200);+ cleanup.register(() -> admin("codebuild").header("X-Amz-Target", "CodeBuild_20161006.DeleteProject")+ .contentType("application/x-amz-json-1.1").body("{\"name\":\"" + project + "\"}").post("/"));+ user.json("firehose", "Firehose_20150804.CreateDeliveryStream").body(createStream).post("/").then()+ .statusCode(200);+ cleanup.register(() -> admin("firehose").header("X-Amz-Target", "Firehose_20150804.DeleteDeliveryStream")+ .contentType("application/x-amz-json-1.1").body("{\"DeliveryStreamName\":\"" + deliveryStream + "\"}")+ .post("/"));+ }++ @Test+ void aGlueJobsRoleNamedByNameNeedsPassRoleOnTheArnIamHoldsItUnder() {+ String role = role("/glue/", "glue-job");+ String name = roleName(role);+ User user = user("passrole-glue");+ String job = "passrole-job-" + suffix();+ String createJob = ("{\"Name\":\"%s\",\"Role\":\"%s\",\"Command\":{\"Name\":\"glueetl\","+ + "\"ScriptLocation\":\"s3://passrole-bucket/job.py\"}}").formatted(job, name);++ // The name carries no path; the role it names is the one IAM holds under /glue/.+ user.policy(allow("glue:CreateJob", "*") + ","+ + passRole("arn:aws:iam::" + ACCOUNT + ":role/" + name, "glue.amazonaws.com"));+ deniedJson(user.json("glue", "AWSGlue.CreateJob").body(createJob).post("/").then());++ user.policy(allow("glue:CreateJob", "*") + "," + passRole(role, "glue.amazonaws.com"));+ user.json("glue", "AWSGlue.CreateJob").body(createJob).post("/").then().statusCode(200);+ cleanup.register(() -> admin("glue").header("X-Amz-Target", "AWSGlue.DeleteJob")+ .contentType("application/x-amz-json-1.1").body("{\"JobName\":\"" + job + "\"}").post("/"));+ }++ @Test+ void aCognitoGroupsRoleIsPassedToNoNamedService() {+ String role = role("cognito-group");+ User user = user("passrole-cognito");+ String group = "{\"UserPoolId\":\"us-east-1_passrolemissing\",\"GroupName\":\"g\",\"RoleArn\":\"" + role + "\"}";++ // The Service Reference names no service for a group's role, so a grant naming one does not match.+ user.policy(allow("cognito-idp:CreateGroup", "*") + "," + passRole(role, "cognito-idp.amazonaws.com"));+ deniedJson(user.json("cognito-idp", "AWSCognitoIdentityProviderService.CreateGroup").body(group).post("/")+ .then());++ user.policy(allow("cognito-idp:CreateGroup", "*") + "," + allow("iam:PassRole", role));+ user.json("cognito-idp", "AWSCognitoIdentityProviderService.CreateGroup").body(group).post("/").then()+ .statusCode(400).body(containsString("ResourceNotFoundException"));+ }++ @Test+ void aSubscriptionFilterPolicysRoleNeedsPassRoleForLogs() {+ String role = role("logs-delivery");+ User user = user("passrole-logs");+ String policy = "passrole-policy-" + suffix();+ String body = ("{\"policyName\":\"%s\",\"policyType\":\"SUBSCRIPTION_FILTER_POLICY\",\"policyDocument\":"+ + "\"{\\\"DestinationArn\\\":\\\"arn:aws:kinesis:us-east-1:%s:stream/passrole\\\","+ + "\\\"RoleArn\\\":\\\"%s\\\"}\"}").formatted(policy, ACCOUNT, role);++ // A subscription filter policy also needs logs:PutSubscriptionFilter, which Floci checks too.+ String actions = allow("logs:PutAccountPolicy", "*") + "," + allow("logs:PutSubscriptionFilter", "*");+ user.policy(actions + "," + passRole(role, LAMBDA));+ deniedJson(user.json("logs", "Logs_20140328.PutAccountPolicy").body(body).post("/").then());++ user.policy(actions + "," + passRole(role, "logs.amazonaws.com"));+ user.json("logs", "Logs_20140328.PutAccountPolicy").body(body).post("/").then().statusCode(200);+ cleanup.register(() -> admin("logs").header("X-Amz-Target", "Logs_20140328.DeleteAccountPolicy")+ .contentType("application/x-amz-json-1.1")+ .body("{\"policyName\":\"" + policy + "\",\"policyType\":\"SUBSCRIPTION_FILTER_POLICY\"}").post("/"));+ }++ private static RequestSpecification receiptRule(User user, String role) {+ return user.query("ses", "CreateReceiptRule").formParam("RuleSetName", "passrole-missing")+ .formParam("Rule.Name", "r").formParam("Rule.Enabled", "true")+ .formParam("Rule.Actions.member.1.S3Action.BucketName", "passrole-bucket")+ .formParam("Rule.Actions.member.1.S3Action.IamRoleArn", role);+ }++ private static RequestSpecification metricStream(User user, String name, String role) {+ return user.query("monitoring", "PutMetricStream").formParam("Name", name)+ .formParam("FirehoseArn", "arn:aws:firehose:us-east-1:" + ACCOUNT + ":deliverystream/passrole")+ .formParam("RoleArn", role).formParam("OutputFormat", "json");+ }++ private static RequestSpecification ssm(User user, String operation) {+ return user.json("ssm", "AmazonSSM." + operation);+ }++ private static RequestSpecification catalog(User user, String operation) {+ return user.json("servicecatalog", "AWS242ServiceCatalogService." + operation);+ }++ private static ValidatableResponse catalogAdmin(String operation, String body) {+ return admin("servicecatalog").header("X-Amz-Target", "AWS242ServiceCatalogService." + operation)+ .contentType("application/x-amz-json-1.1").body(body).post("/").then().statusCode(200);+ }++ private static void deleteFromCatalog(String operation, String id) {+ admin("servicecatalog").header("X-Amz-Target", "AWS242ServiceCatalogService." + operation)+ .contentType("application/x-amz-json-1.1").body("{\"Id\":\"" + id + "\"}").post("/");+ }++ /** A CreateConstraint body; {@code parameters} is the document, its quotes escaped for the JSON string it sits in. */+ private static String constraint(String portfolio, String product, String type, String parameters) {+ return "{\"PortfolioId\":\"" + portfolio + "\",\"ProductId\":\"" + product + "\",\"Type\":\"" + type+ + "\",\"Parameters\":\"" + parameters + "\",\"IdempotencyToken\":\"" + suffix() + "\"}";+ }++ /** SWF speaks JSON 1.0. */+ private static RequestSpecification swf(User user, String operation) {+ return given().header("Authorization", auth(user.accessKeyId(), "swf"))+ .header("X-Amz-Target", "SimpleWorkflowService." + operation).contentType("application/x-amz-json-1.0");+ }+private static String roleName(String roleArn) {return roleArn.substring(roleArn.lastIndexOf('/') + 1);}@@ -1272,6 +1622,10 @@ class IamPassRoleEnforcementIntegrationTest {.contentType("application/cbor").accept("application/cbor");}+ RequestSpecification query(String service, String action) {+ return given().header("Authorization", auth(accessKeyId, service)).formParam("Action", action);+ }+RequestSpecification cfn(String action) {return given().header("Authorization", auth(accessKeyId, "cloudformation")).formParam("Action", action);}diff --git a/tools/aws/regen_iam_passed_roles.py b/tools/aws/regen_iam_passed_roles.pynew file mode 100644index 0000000000..489bae8185--- /dev/null+++ b/tools/aws/regen_iam_passed_roles.py@@ -0,0 +1,874 @@+#!/usr/bin/env python3+"""Regenerate src/main/resources/aws/iam-passed-roles.json from AWS's Service Reference and botocore.++A request that passes a role to a service also needs `iam:PassRole` on that role. The IAM user guide:+"To pass a role (and its permissions) to an AWS service, a user must have permissions to pass the+role to the service." `PassedRoles` finds the roles a request passes, and this file tells it where+each operation's request carries them. It comes from two sources, each answering what the other+cannot:++- AWS's Service Reference, which lists `iam:PassRole` among an operation's `AuthorizedActions`, with+ the services the role goes to as `iam:PassedToService`, but does not say which request member+ names the role:++ https://servicereference.us-east-1.amazonaws.com/ (the index of services)+ https://servicereference.us-east-1.amazonaws.com/v1/<svc>/<svc>.json++- botocore's model of each SDK client the reference lists the operation for (Apache-2.0,+ https://github.com/boto/botocore, the pinned release), which gives the request's members but+ not which of them AWS checks.++A member of the operation's request is read as a role it passes when its name ends in `Role`,+`RoleArn`, `RoleName`, the plural of one, or one of those followed by `Update` or `Override`+(`RoleARNUpdate`, `serviceRoleOverride`), and it is a string or a list of strings without an enum.+That leaves out `RoleSessionName` and `AmbiguousRoleResolution`, which name no role. A member whose+own documentation says it takes a role by name as well as by ARN is marked `byName`, and Floci+resolves the name in the request's account, as the services do. What the rule gets wrong for an+operation is corrected here, each with its reason: a role member it does not see (`EXTRA_MEMBERS`),+a member it sees that passes no role (`EXCLUDED_MEMBERS`), and which service a member's role goes to+when the reference names several (`MEMBER_SERVICES`).++Only the namespaces in `NAMESPACES` are read, and in them every operation the reference lists with+`iam:PassRole`, whether Floci serves it or not, so an operation Floci adds is checked from the+start. Each of those operations ends up in exactly one of three places, and generation fails on an+operation that would end up in none:++- `roles`: the members it reads, each with the service its role is passed to.+- `byHand`: operations `PassedRoles` reads itself, because their roles are not a request member: an+ instance profile's roles, a task definition's, a launch template's, or one that depends on the+ resource the request names. `PassedRolesCoverageTest` holds the two lists to each other.+- `notRead`: operations whose request names no role this table can read, each with its reason.++The Service Reference is live rather than a pinned dependency, so a fresh generation is not+byte-identical. The two gates split along the sources:++- `--check` is offline and needs the pinned botocore. The file must be well-formed, and every+ operation's members must be exactly what the rule and the corrections give from botocore for the+ models the file names, so a hand-edited member fails.+- `--verify` is online and stdlib-only. Every operation the file carries must still list+ `iam:PassRole`, to the same services, for the same SDK clients. An operation AWS has added is+ reported without failing: until the next sync it passes roles unchecked, which is where it was+ before this file existed.++Run from anywhere in the repo:+ python3 tools/aws/regen_iam_passed_roles.py # rewrite the vendored file in place+ python3 tools/aws/regen_iam_passed_roles.py --check # offline: members match botocore+ python3 tools/aws/regen_iam_passed_roles.py --verify # online: operations match AWS+ python3 tools/aws/regen_iam_passed_roles.py --source-dir <dir> # read saved <svc>.json files+"""+from __future__ import annotations++import argparse+import json+import re+import sys+from datetime import datetime, timezone+from pathlib import Path++from regen_iam_authorized_actions import fetch_references+from regen_partitions import resolve_botocore_data+from regen_query_services import latest_model_dir, load_model++REPO_ROOT = Path(__file__).resolve().parents[2]+OUTPUT = REPO_ROOT / "src/main/resources/aws/iam-passed-roles.json"++PASSED_TO_SERVICE = "iam:PassedToService"+SERVICE_SUFFIX = ".amazonaws.com"++# The IAM namespaces whose operations this file reads: those Floci serves over the JSON and Query+# protocols and Smithy RPC v2 CBOR, and the REST ones whose routes Floci authorizes by operation.+NAMESPACES = (+ "application-autoscaling", "athena", "autoscaling", "budgets", "cloudformation", "cloudtrail",+ "cloudwatch", "codebuild", "codedeploy", "codepipeline", "cognito-identity", "cognito-idp",+ "comprehend", "config", "datasync", "dms", "dsql", "ec2", "ecr", "ecs", "eks", "elasticmapreduce",+ "events", "firehose", "glue", "iam", "kinesis", "kinesisanalytics", "lambda", "logs", "pipes",+ "rds", "redshift", "redshift-serverless", "rekognition", "resource-groups", "s3", "sagemaker", "scheduler",+ "secretsmanager", "servicecatalog", "ses", "sns", "ssm", "states", "swf", "textract",+ "transcribe", "transfer", "translate",+)++# Namespaces Floci serves whose operations list iam:PassRole but are not read here yet, each with+# why. `PassedRolesCoverageTest` fails for a namespace Floci serves that is in neither list.+NOT_COVERED = {+ "apigateway": "authorized by HTTP method, so no request is checked as one of these operations",+ "access-analyzer": "REST routes no rule maps yet",+ "airflow": "REST routes no rule maps yet",+ "appconfig": "REST routes no rule maps yet",+ "appsync": "REST routes no rule maps yet",+ "aps": "REST routes no rule maps yet",+ "aws-marketplace": "REST routes no rule maps yet",+ "backup": "REST routes no rule maps yet",+ "batch": "REST routes no rule maps yet",+ "bedrock": "REST routes no rule maps yet",+ "bedrock-agentcore": "REST routes no rule maps yet",+ "cloudfront": "REST routes no rule maps yet",+ "dlm": "REST routes no rule maps yet",+ "elasticfilesystem": "REST routes no rule maps yet",+ "emr-serverless": "REST routes no rule maps yet",+ "es": "REST routes no rule maps yet",+ "fis": "REST routes no rule maps yet",+ "guardduty": "REST routes no rule maps yet",+ "iot": "REST routes no rule maps yet",+ "kafka": "REST routes no rule maps yet",+ "macie2": "REST routes no rule maps yet",+ "mq": "REST routes no rule maps yet",+ "rum": "REST routes no rule maps yet",+ "s3tables": "REST routes no rule maps yet",+}++# A member that names a role: Role, RoleArn, RoleName, their plurals, and an Update or Override of one.+ROLE_MEMBER_RE = re.compile(r"role(arn|name)?s?(update|override)?$", re.IGNORECASE)+# A member named for a role's name rather than its ARN.+ROLE_NAME_MEMBER_RE = re.compile(r"rolenames?$", re.IGNORECASE)+# Documentation saying the member takes a role's name: "The name or Amazon Resource Name (ARN) of the+# IAM role", "The short name or full Amazon Resource Name (ARN)", "The IAM role or Amazon Resource+# Name (ARN) of an IAM role", "The name of a service role".+BY_NAME_DOC_RE = re.compile(r"\bname or (the |its )?(full )?(ARN|Amazon Resource Name)\b"+ r"|\bshort name or\b|\b(ARN|Amazon Resource Name)( \(ARN\))? or (the )?name\b"+ r"|\brole or (the )?(ARN|Amazon Resource Name)\b"+ r"|(?<!Resource )\bname of (the |a |an )?(\S+ ){0,5}role\b",+ re.IGNORECASE)+# The protocols whose requests PassedRoles reads: form parameters, or a JSON or CBOR body.+READ_PROTOCOLS = {"json", "query", "rest-json", "smithy-rpc-v2-cbor"}+# How a vendored member path is written: dotted segments, a list step as `[]` or `[Name]` when its+# shape names its members, a map step as `{}` for every value or `{KEY}` for one key's.+MEMBER_PATH_RE = re.compile(r"^[A-Za-z][A-Za-z0-9_]*(\[[A-Za-z0-9_]*\]|\{[A-Za-z0-9_]*\})?"+ r"(\.[A-Za-z][A-Za-z0-9_]*(\[[A-Za-z0-9_]*\]|\{[A-Za-z0-9_]*\})?)*$")+NAMESPACE_RE = re.compile(r"^[a-z0-9][a-z0-9-]{0,63}$")+OPERATION_RE = re.compile(r"^[a-z0-9-]+:[A-Za-z][A-Za-z0-9]{0,127}$")+SERVICE_RE = re.compile(r"^[a-z0-9][a-z0-9.-]*$")++BODY_LOCATIONS = (None, "")++# Operations PassedRoles reads itself, and what it reads.+BY_HAND = {+ "autoscaling:CreateAutoScalingGroup": "the roles of each launch template's instance profile, and the "+ "service-linked and lifecycle hook roles",+ "autoscaling:CreateLaunchConfiguration": "the roles of the instance profile it names or takes from an "+ "instance",+ "autoscaling:PutLifecycleHook": "the hook's role",+ "autoscaling:UpdateAutoScalingGroup": "the roles of each launch template's instance profile, and the "+ "service-linked and lifecycle hook roles",+ "application-autoscaling:RegisterScalableTarget": "the scalable target's role",+ "cloudformation:ContinueUpdateRollback": "the stack's service role",+ "cloudformation:CreateChangeSet": "the stack's service role",+ "cloudformation:CreateStack": "the stack's service role",+ "cloudformation:CreateStackSet": "the administration role, named or the default one",+ "cloudformation:DeleteStack": "the stack's service role",+ "cloudformation:UpdateStack": "the stack's service role",+ "cloudformation:UpdateStackSet": "the administration role, by the StackSet's permission model",+ "dms:CreateEndpoint": "the endpoint's role and the roles of the settings structures DMS stores",+ "dms:CreateReplicationInstance": "the role of the Kerberos settings",+ "dms:ModifyEndpoint": "the endpoint's role and the roles of the settings structures DMS stores",+ "dms:ModifyReplicationInstance": "the role of the Kerberos settings",+ "ec2:AssociateIamInstanceProfile": "the roles of the instance profile it names",+ "ec2:CreateFlowLogs": "the delivery role",+ "ec2:CreateLaunchTemplate": "the roles of the instance profile the template names",+ "ec2:CreateLaunchTemplateVersion": "the roles of the instance profile the template names",+ "ec2:ReplaceIamInstanceProfileAssociation": "the roles of the instance profile it names",+ "ec2:RequestSpotInstances": "the roles of the instance profile it names",+ "ec2:RunInstances": "the roles of the instance profile it names",+ "ecs:CreateCapacityProvider": "the infrastructure role, by name or ARN",+ "ecs:CreateService": "the task definition's roles and the service's infrastructure roles",+ "ecs:CreateTaskSet": "the task definition's roles",+ "ecs:RegisterTaskDefinition": "the task and task execution roles, by name or ARN",+ "ecs:RunTask": "the task definition's roles, their overrides and the volumes' infrastructure role",+ "ecs:StartTask": "the task definition's roles, their overrides and the volumes' infrastructure role",+ "ecs:UpdateCapacityProvider": "the infrastructure role, by name or ARN",+ "ecs:UpdateService": "the task definition's roles and the service's infrastructure roles",+ "eks:CreateAccessEntry": "the principal, for the node types alone",+ "eks:CreateAddon": "the service account role and each Pod Identity association's role",+ "eks:CreateCluster": "the cluster role",+ "eks:CreateFargateProfile": "the pod execution role",+ "eks:CreateNodegroup": "the node role",+ "eks:CreatePodIdentityAssociation": "the association's role, not its target role",+ "eks:UpdateAddon": "the service account role and each Pod Identity association's role",+ "eks:UpdatePodIdentityAssociation": "the association's role, not its target role",+ "events:PutRule": "the rule's role",+ "events:PutTargets": "each target's role",+ "iam:AddRoleToInstanceProfile": "the role it adds, on the ARN IAM holds it under",+ "lambda:CreateFunction": "the execution role",+ "lambda:CreateMicrovmImage": "the build role",+ "lambda:CreateNetworkConnector": "the operator role",+ "lambda:CreateWebFunction": "the execution role",+ "lambda:CreateWebFunctionRevision": "the execution role",+ "lambda:RunMicrovm": "the execution role",+ "lambda:UpdateFunctionConfiguration": "the execution role",+ "lambda:UpdateMicrovmImage": "the build role",+ "lambda:UpdateNetworkConnector": "the operator role",+ "pipes:CreatePipe": "the pipe's role",+ "pipes:UpdatePipe": "the pipe's role",+ "rds:AddRoleToDBCluster": "the role it adds",+ "rds:AddRoleToDBInstance": "the role it adds",+ "rds:CreateDBCluster": "the directory, monitoring and associated roles",+ "rds:CreateDBInstance": "the directory and monitoring roles",+ "rds:CreateDBInstanceReadReplica": "the directory and monitoring roles",+ "rds:CreateDBProxy": "the proxy's role",+ "rds:ModifyDBCluster": "the directory and monitoring roles",+ "rds:ModifyDBInstance": "the directory and monitoring roles",+ "rds:ModifyDBProxy": "the proxy's role",+ "rds:ModifyOptionGroup": "the role each option takes in its IAM_ROLE_ARN setting",+ "rds:RemoveRoleFromDBCluster": "the role it removes",+ "rds:RemoveRoleFromDBInstance": "the role it removes",+ "rds:RestoreDBClusterFromSnapshot": "the directory, monitoring and associated roles",+ "rds:RestoreDBClusterToPointInTime": "the directory, monitoring and associated roles",+ "rds:RestoreDBInstanceFromDBSnapshot": "the directory role",+ "rds:RestoreDBInstanceToPointInTime": "the directory role",+ "rds:StartExportTask": "the export role",+ "redshift:CreateCluster": "the roles it associates",+ "redshift:ModifyClusterIamRoles": "the roles it associates",+ "redshift:RestoreFromClusterSnapshot": "the roles it associates",+ "redshift-serverless:CreateNamespace": "the namespace's roles and its default",+ "redshift-serverless:CreateScheduledAction": "the scheduled action's role",+ "redshift-serverless:UpdateNamespace": "the namespace's roles and its default",+ "redshift-serverless:UpdateScheduledAction": "the scheduled action's role",+ "scheduler:CreateSchedule": "the target's role",+ "scheduler:UpdateSchedule": "the target's role",+ "states:CreateStateMachine": "the state machine's role",+ "states:UpdateStateMachine": "the state machine's role",+}++BY_HAND.update({+ "logs:PutAccountPolicy": "the role a subscription filter policy's document names",+ "servicecatalog:CreateConstraint": "a launch constraint's role, from its parameters document",+ "servicecatalog:UpdateConstraint": "a launch constraint's role, by the type the constraint holds",+ "sns:CreatePlatformApplication": "the delivery status roles among its attributes",+ "sns:CreateTopic": "the delivery status roles among its attributes",+ "sns:SetPlatformApplicationAttributes": "the delivery status roles among its attributes",+ "sns:SetSMSAttributes": "the delivery status role among its attributes",+ "sns:SetSubscriptionAttributes": "the subscription role, when it is the attribute set",+ "sns:SetTopicAttributes": "a delivery status role, when it is the attribute set",+ "sns:Subscribe": "the subscription role among its attributes",+ "swf:RespondDecisionTaskCompleted": "the Lambda role of each decision that starts an execution, read from "+ "the attributes its decisionType names",+})++NO_ROLE_MEMBER = "no member of the request names a role"+RUNBOOK_PARAMETER = "the role is a parameter of the runbook it runs, not a member of the request"+XML_BODY = "the request body is XML, which PassedRoles does not read"++# Operations whose request names no role this file can read.+NOT_READ = {+ "config:PutConformancePack": NO_ROLE_MEMBER,+ "config:PutOrganizationConformancePack": NO_ROLE_MEMBER,+ "config:PutRemediationConfigurations": RUNBOOK_PARAMETER,+ "dms:CreateInstanceProfile": NO_ROLE_MEMBER,+ "dms:ModifyInstanceProfile": NO_ROLE_MEMBER,+ "ec2:RequestSpotFleet": "the request names its roles in EC2's own protocol, one of them as an instance profile",+ "ecs:CreateDaemon": "the roles are the daemon task definition's, which only a lookup finds",+ "ecs:CreateGateway": "botocore's model has no such operation",+ "ecs:UpdateDaemon": "the roles are the daemon task definition's, which only a lookup finds",+ "ecs:UpdateGateway": "botocore's model has no such operation",+ "eks:UpdateClusterConfig": "the reference passes the node role to ec2 or eks and nothing says which",+ "elasticmapreduce:RunJobFlow": "JobFlowRole names an instance profile, and the reference passes the roles "+ "to three services without saying which goes where",+ "elasticmapreduce:UpdateStudio": NO_ROLE_MEMBER,+ "glue:GetJob": NO_ROLE_MEMBER,+ "glue:GetJobs": NO_ROLE_MEMBER,+ "lambda:AddEventSource": "botocore's model has no such operation",+ "logs:CreateImportTask": "the reference passes the role to cloudtrail or logs and nothing says which",+ "rds:CreateBlueGreenDeployment": NO_ROLE_MEMBER,+ "s3:CreateAccessGrantsLocation": XML_BODY,+ "s3:PutBucketReplication": XML_BODY,+ "redshift:ModifyLakehouseConfiguration": NO_ROLE_MEMBER,+ "redshift-serverless:UpdateLakehouseConfiguration": NO_ROLE_MEMBER,+ "sagemaker:CreateTrainingSession": "the reference passes the role to sagemaker or training-session.sagemaker "+ "and nothing says which",+ "sagemaker:CreateTransformJob": NO_ROLE_MEMBER,+ "sagemaker:ImportHubContent": NO_ROLE_MEMBER,+ "ssm:CreateDocument": NO_ROLE_MEMBER,+ "ssm:DescribeAutomationStepExecutions": NO_ROLE_MEMBER,+ "ssm:GetAutomationExecution": NO_ROLE_MEMBER,+ "ssm:StartAutomationExecution": RUNBOOK_PARAMETER,+ "ssm:StartChangeRequestExecution": RUNBOOK_PARAMETER,+ "ssm:UpdateDocument": NO_ROLE_MEMBER,+ "ssm:UpdateServiceSetting": "a role is only ever a setting's value, which the request names by SettingId",+}++# A member the rule reads that passes no role, by operation, or by namespace for all its operations.+EXCLUDED_MEMBERS = {+ # "A list of roles to be attached": the roles the action attaches a policy to.+ "budgets:*": {"Definition.IamActionDefinition.Roles[]": "the roles the action attaches a policy to"},+ # "This is assumed through the roleArn for the pipeline": the pipeline's role assumes it.+ "codepipeline:*": {"pipeline.stages[].actions[].roleArn": "assumed with the pipeline's role, not passed"},+ # "The Snowflake role you wish to configure".+ "firehose:*": {+ "SnowflakeDestinationConfiguration.SnowflakeRoleConfiguration.SnowflakeRole": "a Snowflake role",+ "SnowflakeDestinationUpdate.SnowflakeRoleConfiguration.SnowflakeRole": "a Snowflake role",+ },+ # Glue's code-generated job nodes: "the role to assume using AWS Security Token Service (AWS STS)" for+ # a Kinesis source and "the Amazon Web Services Security Token Service (STS) role to assume" for a+ # DynamoDB one, which the job's own role assumes, and the role a Redshift node's temporary directory+ # is read and written with, which the Redshift cluster holds.+ "glue:*": {+ prefix + node: reason+ for prefix in ("CodeGenConfigurationNodes{}.", "JobUpdate.CodeGenConfigurationNodes{}.")+ for node, reason in (+ ("CatalogKinesisSource.StreamingOptions.RoleArn", "assumed with STS by the job's role"),+ ("DirectKinesisSource.StreamingOptions.RoleArn", "assumed with STS by the job's role"),+ ("DynamoDBELTConnectorSource.ConnectionOptions.DynamodbStsRoleArn", "assumed with STS by the job's role"),+ ("RedshiftSource.TmpDirIAMRole", "a role the Redshift cluster holds"),+ ("RedshiftTarget.TmpDirIAMRole", "a role the Redshift cluster holds"),+ )+ },+ # "The IAM role attached to your Redshift cluster that Amazon SageMaker uses to generate datasets":+ # a role the cluster already holds. "The Amazon Resource Name (ARN) of the SageMaker model registry+ # account": a role in another account.+ "sagemaker:*": {+ "ProcessingInputs[].DatasetDefinition.RedshiftDatasetDefinition.ClusterRoleArn":+ "a role the Redshift cluster already holds",+ "DefaultUserSettings.CanvasAppSettings.ModelRegisterSettings.CrossAccountModelRegisterRoleArn":+ "a role in the model registry's account",+ "UserSettings.CanvasAppSettings.ModelRegisterSettings.CrossAccountModelRegisterRoleArn":+ "a role in the model registry's account",+ # "the IAM roles that the execution role of SageMaker can assume", and those "used by the Amazon+ # EMR cluster instances or job execution environments".+ **{prefix + "JupyterLabAppSettings.EmrSettings." + member: reason+ for prefix in ("DefaultSpaceSettings.", "DefaultUserSettings.", "UserSettings.")+ for member, reason in (("AssumableRoleArns[]", "assumed by the execution role"),+ ("ExecutionRoleArns[]", "the EMR clusters' own roles"))},+ # "The name of the in-app role within the SageMaker Partner AI App".+ "ApplicationConfig.RoleGroupAssignments[].RoleName": "an in-app role, not an IAM one",+ },+ # The Automation execution role of each target account, which the run assumes there.+ "ssm:*": {+ "TargetLocations[].ExecutionRoleName": "a role in each target account",+ "Entries[].TargetLocations[].ExecutionRoleName": "a role in each target account",+ },+}++# A member naming a role that the rule does not see: (byName, why it names one).+_SNS_CALLER = ("SnsCallerArn", "\"the ARN of the IAM role in your Amazon Web Services account that Amazon Cognito "+ "will use to send SMS messages\"")+_EUMS_CALLER = ("CallerArn", "\"The ARN of the IAM role that Amazon Cognito assumes to send SMS messages\"")+# Glue's API reference: "ROLE_ARN - The role to be used for running queries."+_GLUE_CONNECTION_ROLE = (False, "the ROLE_ARN connection property, \"The role to be used for running queries\"")+# Lake Formation's view prerequisites: the role that defines a view needs "The iam:PassRole permission+# for AWS Glue and Lake Formation".+_GLUE_VIEW_DEFINER = (False, "the role that defines the view")+EXTRA_MEMBERS = {+ "cognito-idp:CreateUserPool": {+ "SmsConfiguration." + _SNS_CALLER[0]: (False, _SNS_CALLER[1]),+ "SmsConfiguration.EumsSms." + _EUMS_CALLER[0]: (False, _EUMS_CALLER[1]),+ },+ "cognito-idp:UpdateUserPool": {+ "SmsConfiguration." + _SNS_CALLER[0]: (False, _SNS_CALLER[1]),+ "SmsConfiguration.EumsSms." + _EUMS_CALLER[0]: (False, _EUMS_CALLER[1]),+ },+ "cognito-idp:SetUserPoolMfaConfig": {+ "SmsMfaConfiguration.SmsConfiguration." + _SNS_CALLER[0]: (False, _SNS_CALLER[1]),+ "SmsMfaConfiguration.SmsConfiguration.EumsSms." + _EUMS_CALLER[0]: (False, _EUMS_CALLER[1]),+ },+ "glue:CreateConnection": {"ConnectionInput.ConnectionProperties{ROLE_ARN}": _GLUE_CONNECTION_ROLE},+ "glue:UpdateConnection": {"ConnectionInput.ConnectionProperties{ROLE_ARN}": _GLUE_CONNECTION_ROLE},+ "glue:TestConnection": {"TestConnectionInput.ConnectionProperties{ROLE_ARN}": _GLUE_CONNECTION_ROLE},+ "glue:CreateTable": {"TableInput.ViewDefinition.Definer": _GLUE_VIEW_DEFINER},+ "glue:UpdateTable": {"TableInput.ViewDefinition.Definer": _GLUE_VIEW_DEFINER},+ # Keys the model's own enums give the maps: ServiceActionDefinitionKey's AssumeRole and+ # PropertyKey's LAUNCH_ROLE.+ "servicecatalog:CreateServiceAction": {"Definition{AssumeRole}": (False, "the role the action runs as")},+ "servicecatalog:UpdateServiceAction": {"Definition{AssumeRole}": (False, "the role the action runs as")},+ "servicecatalog:UpdateProvisionedProductProperties": {+ "ProvisionedProductProperties{LAUNCH_ROLE}": (False, "the role the product is launched with"),+ },+}++# The service a member's role goes to, for an operation the reference lists with several; "*" for+# every member.+ECS_INFRASTRUCTURE = "ecs"+ECS_TASKS = "ecs-tasks"+MEMBER_SERVICES = {+ # "The Amazon Resource Name (ARN) for CodePipeline to use", and "The pipeline role ARN associated+ # with the rule".+ "codepipeline:*": {+ "pipeline.roleArn": "codepipeline",+ "pipeline.stages[].beforeEntry.conditions[].rules[].roleArn": "codepipeline",+ "pipeline.stages[].onFailure.conditions[].rules[].roleArn": "codepipeline",+ "pipeline.stages[].onSuccess.conditions[].rules[].roleArn": "codepipeline",+ },+ # ECS infrastructure roles go to ecs, task and task execution roles to ecs-tasks, as PassedRoles'+ # ECS cases pass them.+ "ecs:*": {+ "executionRoleArn": ECS_TASKS,+ "taskRoleArn": ECS_TASKS,+ "infrastructureRoleArn": ECS_INFRASTRUCTURE,+ },+ # rds-preview is the principal of RDS's preview environment; PassedRoles' RDS cases pass to rds.+ "rds:*": {"*": "rds"},+}+++# --------------------------------------------------------------------------- #+# The Service Reference: which operations pass a role, to which services+# --------------------------------------------------------------------------- #+def passed_role_operations(documents: list[dict]) -> dict[str, dict]:+ """Every operation of every namespace that lists iam:PassRole, with the services the role goes+ to, as `<service>` without `.amazonaws.com`, and the SDK clients it is listed for."""+ found: dict[str, dict] = {}+ for document in documents:+ namespace = document.get("Name")+ if not isinstance(namespace, str) or not NAMESPACE_RE.match(namespace):+ raise ValueError(f"{namespace!r} is not usable as an IAM namespace")+ for operation in document.get("Operations", []):+ name = operation.get("Name") if isinstance(operation, dict) else None+ if not isinstance(name, str):+ raise ValueError(f"{namespace}: operation entry without a usable 'Name': {operation!r}")+ authorized = operation.get("AuthorizedActions") or []+ if not isinstance(authorized, list) or not all(isinstance(entry, dict) for entry in authorized):+ raise ValueError(f"{namespace}:{name}: 'AuthorizedActions' is not a list of objects")+ passes = [entry for entry in authorized+ if entry.get("Service") == "iam" and entry.get("Name") == "PassRole"]+ if not passes:+ continue+ services: set[str] = set()+ for entry in passes:+ context = entry.get("Context") or {}+ if not isinstance(context, dict):+ raise ValueError(f"{namespace}:{name}: iam:PassRole 'Context' is not an object")+ for service in context.get(PASSED_TO_SERVICE, []):+ if not isinstance(service, str) or not service.endswith(SERVICE_SUFFIX):+ raise ValueError(f"{namespace}:{name}: {service!r} is not a service principal")+ services.add(service[:-len(SERVICE_SUFFIX)])+ clients = sorted({sdk["Name"] for sdk in operation.get("SDK") or []+ if isinstance(sdk, dict) and sdk.get("Package") == "Boto3"+ and isinstance(sdk.get("Name"), str)})+ key = f"{namespace}:{name}"+ entry = found.setdefault(key, {"passedTo": set(), "clients": set()})+ entry["passedTo"] |= services+ entry["clients"] |= set(clients)+ return {key: {"passedTo": sorted(value["passedTo"]), "clients": sorted(value["clients"])}+ for key, value in sorted(found.items())}+++# --------------------------------------------------------------------------- #+# botocore: which members of the request name a role+# --------------------------------------------------------------------------- #+def _documentation(member: dict, shape: dict) -> str:+ text = member.get("documentation") or shape.get("documentation") or ""+ return re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", text))+++def _is_role_member(name: str, model: dict, shape_name: str) -> bool:+ return bool(ROLE_MEMBER_RE.search(name)) and _leaf(model, shape_name) is not None+++def _leaf(model: dict, shape_name: str) -> dict | None:+ """The string shape a member holds itself, as each element of a list or each value of a map; None+ when it holds anything else, or an enum, which names no role."""+ shape = model["shapes"][shape_name]+ if shape["type"] == "list":+ shape = model["shapes"][shape["member"]["shape"]]+ elif shape["type"] == "map":+ shape = model["shapes"][shape["value"]["shape"]]+ return shape if shape["type"] == "string" and "enum" not in shape else None+++def _step(shape: dict) -> str:+ """The path step into a list's elements or a map's values, and nothing for any other shape."""+ if shape["type"] == "list":+ return "[" + shape["member"].get("locationName", "") + "]"+ return "{}" if shape["type"] == "map" else ""+++def _takes_name(name: str, member: dict, model: dict) -> bool:+ """Whether the member takes a role by name: it is named for one, or its documentation says it takes+ one, unless its pattern only admits an ARN."""+ shape = _leaf(model, member["shape"])+ if shape.get("pattern", "").lstrip("^").startswith("arn:"):+ return False+ return bool(ROLE_NAME_MEMBER_RE.search(name) or BY_NAME_DOC_RE.search(_documentation(member, shape)))+++def readable(model: dict) -> bool:+ """Whether the model's requests come as form parameters or a JSON or CBOR body."""+ metadata = model["metadata"]+ return bool(READ_PROTOCOLS & set(metadata.get("protocols") or [metadata.get("protocol")]))+++def role_members(model: dict, operation: str) -> dict[str, bool]:+ """The members of the operation's request the rule reads, as vendored paths, each with whether+ it takes a role by name."""+ spec = model["operations"].get(operation)+ if spec is None or "input" not in spec or not readable(model):+ return {}+ root = model["shapes"][spec["input"]["shape"]]+ payload = root.get("payload")+ found: dict[str, bool] = {}++ def walk(shape_name: str, prefix: str, top: bool, seen: frozenset) -> None:+ if shape_name in seen:+ return+ shape = model["shapes"][shape_name]+ seen = seen | {shape_name}+ if shape["type"] == "list":+ walk(shape["member"]["shape"], prefix + _step(shape), False, seen)+ elif shape["type"] == "map":+ walk(shape["value"]["shape"], prefix + _step(shape), False, seen)+ elif shape["type"] == "structure":+ for name, member in shape.get("members", {}).items():+ if top and member.get("location") not in BODY_LOCATIONS:+ continue+ serialized = member.get("locationName", name)+ path = f"{prefix}.{serialized}" if prefix else serialized+ if _is_role_member(name, model, member["shape"]):+ leaf = path + _step(model["shapes"][member["shape"]])+ by_name = _takes_name(name, member, model)+ found[leaf] = found.get(leaf, False) or by_name+ else:+ walk(member["shape"], path, False, seen)++ if payload is not None:+ member = root["members"][payload]+ walk(member["shape"], "", False, frozenset())+ else:+ walk(spec["input"]["shape"], "", True, frozenset())+ return found+++PATH_STEP_RE = re.compile(r"^(?P<name>[A-Za-z][A-Za-z0-9_]*)(?:\[(?P<list>[A-Za-z0-9_]*)\]|\{(?P<key>[A-Za-z0-9_]*)\})?$")+++def member_exists(model: dict, operation: str, path: str) -> bool:+ """Whether the operation's request has a string member at `path`, a `{KEY}` step naming a key+ the map's key enum lists when it has one."""+ spec = model["operations"].get(operation)+ if spec is None or "input" not in spec or not readable(model):+ return False+ shape = model["shapes"][spec["input"]["shape"]]+ for step in path.split("."):+ match = PATH_STEP_RE.match(step)+ if match is None or shape["type"] != "structure":+ return False+ found = [member for name, member in shape.get("members", {}).items()+ if member.get("locationName", name) == match["name"]]+ if not found:+ return False+ shape = model["shapes"][found[0]["shape"]]+ if match["list"] is not None:+ if shape["type"] != "list":+ return False+ shape = model["shapes"][shape["member"]["shape"]]+ elif match["key"] is not None:+ if shape["type"] != "map":+ return False+ keys = model["shapes"][shape["key"]["shape"]].get("enum")+ if match["key"] and keys is not None and match["key"] not in keys:+ return False+ shape = model["shapes"][shape["value"]["shape"]]+ return shape["type"] == "string"+++def load_models(data: Path, clients: set[str]) -> dict[str, dict]:+ return {client: load_model(latest_model_dir(data, client))+ for client in sorted(clients) if (data / client).is_dir()}+++# --------------------------------------------------------------------------- #+# The vendored document+# --------------------------------------------------------------------------- #+def namespace_of(operation: str) -> str:+ return operation.split(":", 1)[0]+++def _overrides_for(table: dict, operation: str) -> dict:+ merged = dict(table.get(namespace_of(operation) + ":*", {}))+ merged.update(table.get(operation, {}))+ return merged+++def entry_for(operation: str, passed_to: list[str], models: dict[str, dict]) -> dict:+ """What the file says for one operation, from its services and the models of its namespace."""+ if operation in BY_HAND:+ return {"passedTo": passed_to, "byHand": BY_HAND[operation]}+ if operation in NOT_READ:+ return {"passedTo": passed_to, "notRead": NOT_READ[operation]}+ name = operation.split(":", 1)[1]+ members: dict[str, bool] = {}+ for model in models.values():+ for path, by_name in role_members(model, name).items():+ members[path] = members.get(path, False) or by_name+ excluded = _overrides_for(EXCLUDED_MEMBERS, operation)+ for path in excluded:+ members.pop(path, None)+ for path, (by_name, _reason) in _overrides_for(EXTRA_MEMBERS, operation).items():+ if not any(member_exists(model, name, path) for model in models.values()):+ raise ValueError(f"{operation}: EXTRA_MEMBERS names {path}, which its request does not have")+ members[path] = by_name+ if not members:+ raise ValueError(f"{operation}: no request member names a role; read it by hand (BY_HAND), "+ f"name the member (EXTRA_MEMBERS) or say why it is not read (NOT_READ)")+ services = _overrides_for(MEMBER_SERVICES, operation)+ roles = []+ for path in sorted(members):+ role: dict = {"member": path}+ if path in services or "*" in services:+ role["passedTo"] = services.get(path, services.get("*"))+ elif len(passed_to) == 1:+ role["passedTo"] = passed_to[0]+ elif passed_to:+ raise ValueError(f"{operation}: the role at {path} can go to any of {passed_to}; "+ f"say which in MEMBER_SERVICES")+ if members[path]:+ role["byName"] = True+ roles.append(role)+ return {"passedTo": passed_to, "roles": roles}+++def build(documents: list[dict], provenance: str, data: Path, botocore: str) -> dict:+ upstream = passed_role_operations(documents)+ covered = {operation: value for operation, value in upstream.items()+ if namespace_of(operation) in NAMESPACES}+ _check_overrides(covered)+ namespaces: dict[str, list[str]] = {}+ for namespace in sorted(NAMESPACES):+ clients = sorted({client for operation, value in covered.items()+ if namespace_of(operation) == namespace for client in value["clients"]})+ namespaces[namespace] = clients+ operations = {}+ unread = []+ for operation, value in covered.items():+ models = load_models(data, set(namespaces[namespace_of(operation)]))+ try:+ operations[operation] = entry_for(operation, value["passedTo"], models)+ except ValueError as e:+ unread.append(str(e))+ unread += _unmatched_corrections(covered, namespaces, data)+ if unread:+ raise ValueError("\n".join(unread))+ elsewhere = sorted({namespace_of(operation) for operation in upstream} - set(NAMESPACES))+ return {+ "_source": {+ "generator": "tools/aws/regen_iam_passed_roles.py",+ "reference": provenance,+ "botocore": botocore,+ "retrieved": datetime.now(timezone.utc).strftime("%Y-%m-%d"),+ "note": "make iam-passed-roles-check re-derives every member from botocore; "+ "make iam-passed-roles-verify checks every operation against AWS.",+ },+ "namespaces": namespaces,+ "notCovered": dict(sorted(NOT_COVERED.items())),+ "otherNamespaces": [namespace for namespace in elsewhere if namespace not in NOT_COVERED],+ "operations": operations,+ }+++def _unmatched_corrections(covered: dict[str, dict], namespaces: dict[str, list[str]], data: Path) -> list[str]:+ """An exclusion or a member's service that no operation it applies to has, so none outlives its member."""+ found: dict[str, set[str]] = {}+ for operation in covered:+ if operation in BY_HAND or operation in NOT_READ:+ continue+ name = operation.split(":", 1)[1]+ for model in load_models(data, set(namespaces[namespace_of(operation)])).values():+ found.setdefault(operation, set()).update(role_members(model, name))+ problems = []+ for table_name, table in (("EXCLUDED_MEMBERS", EXCLUDED_MEMBERS), ("MEMBER_SERVICES", MEMBER_SERVICES)):+ for key, paths in table.items():+ scope = [operation for operation in found+ if operation == key or (key.endswith(":*") and namespace_of(operation) == namespace_of(key))]+ for path in paths:+ if path != "*" and not any(path in found[operation] for operation in scope):+ problems.append(f"{table_name} names {path} for {key}, which no operation there has")+ return problems+++def _check_overrides(covered: dict[str, dict]) -> None:+ """Every correction names an operation the reference lists with iam:PassRole, so none outlives it."""+ stale = []+ for table_name, table in (("BY_HAND", BY_HAND), ("NOT_READ", NOT_READ),+ ("EXCLUDED_MEMBERS", EXCLUDED_MEMBERS), ("EXTRA_MEMBERS", EXTRA_MEMBERS),+ ("MEMBER_SERVICES", MEMBER_SERVICES)):+ for key in table:+ if key.endswith(":*"):+ if namespace_of(key) not in NAMESPACES:+ stale.append(f"{table_name} names {key}, a namespace this file does not read")+ elif key not in covered:+ stale.append(f"{table_name} names {key}, which the reference does not list with iam:PassRole")+ overlap = set(BY_HAND) & set(NOT_READ)+ stale += [f"{operation} is both read by hand and not read" for operation in sorted(overlap)]+ if stale:+ raise ValueError("; ".join(stale))+++def render(document: dict) -> str:+ """The document with one operation to a line and one role to a line under it."""+ lines = ["{"]+ for key in ("_source", "namespaces", "notCovered", "otherNamespaces"):+ lines.append(f' "{key}": {json.dumps(document[key])},')+ lines.append(' "operations": {')+ operations = list(document["operations"].items())+ for index, (operation, entry) in enumerate(operations):+ tail = "," if index < len(operations) - 1 else ""+ head = {key: value for key, value in entry.items() if key != "roles"}+ if "roles" not in entry:+ lines.append(f" {json.dumps(operation)}: {json.dumps(head)}{tail}")+ continue+ opening = json.dumps(head)[:-1] + ', "roles": ['+ lines.append(f" {json.dumps(operation)}: {opening}")+ roles = entry["roles"]+ for role_index, role in enumerate(roles):+ lines.append(f" {json.dumps(role)}{',' if role_index < len(roles) - 1 else ''}")+ lines.append(f" ]}}{tail}")+ lines += [" }", "}"]+ return "\n".join(lines) + "\n"+++# --------------------------------------------------------------------------- #+# Gates+# --------------------------------------------------------------------------- #+def validate(document: dict) -> list[str]:+ """Problems that make the vendored file unusable, rather than out of date."""+ problems: list[str] = []+ namespaces = document.get("namespaces")+ operations = document.get("operations")+ if not isinstance(namespaces, dict) or not namespaces:+ return ["namespaces is missing or empty"]+ if not isinstance(operations, dict) or not operations:+ return ["operations is missing or empty"]+ if list(namespaces) != sorted(namespaces):+ problems.append("namespaces is not sorted")+ if list(operations) != sorted(operations):+ problems.append("operations is not sorted")+ for operation, entry in operations.items():+ if not OPERATION_RE.match(operation) or namespace_of(operation) not in namespaces:+ problems.append(f"{operation!r} is not an operation of a namespace the file reads")+ continue+ kinds = [kind for kind in ("roles", "byHand", "notRead") if kind in entry]+ if len(kinds) != 1:+ problems.append(f"{operation} is not exactly one of roles, byHand and notRead")+ continue+ passed_to = entry.get("passedTo")+ if not isinstance(passed_to, list) or not all(isinstance(s, str) and SERVICE_RE.match(s) for s in passed_to):+ problems.append(f"{operation} has no usable passedTo")+ continue+ if kinds[0] != "roles":+ if not isinstance(entry[kinds[0]], str) or not entry[kinds[0]]:+ problems.append(f"{operation} gives no reason for {kinds[0]}")+ continue+ roles = entry["roles"]+ if not isinstance(roles, list) or not roles:+ problems.append(f"{operation} reads no role")+ continue+ for role in roles:+ path = role.get("member") if isinstance(role, dict) else None+ if not isinstance(path, str) or not MEMBER_PATH_RE.match(path):+ problems.append(f"{operation} reads {role!r}, which is no member path")+ continue+ service = role.get("passedTo")+ if service is None and passed_to:+ problems.append(f"{operation}: the role at {path} goes to no service")+ if service is not None and service not in passed_to:+ problems.append(f"{operation}: the role at {path} goes to {service}, which the reference "+ f"does not name")+ if set(role) - {"member", "passedTo", "byName"} or role.get("byName", True) is not True:+ problems.append(f"{operation}: the role at {path} carries an unknown field")+ return problems+++def derive(document: dict, data: Path) -> list[str]:+ """Where the members the file gives differ from what botocore gives for the models it names."""+ problems: list[str] = []+ for operation, entry in document["operations"].items():+ models = load_models(data, set(document["namespaces"][namespace_of(operation)]))+ try:+ expected = entry_for(operation, entry["passedTo"], models)+ except ValueError as e:+ problems.append(str(e))+ continue+ if expected != entry:+ problems.append(f"{operation}: the file has {json.dumps(entry)}, botocore gives {json.dumps(expected)}")+ return problems+++def verify_against(vendored: dict, upstream: dict[str, dict]) -> tuple[list[str], list[str]]:+ """What the file claims and AWS does not, and the operations AWS has added since."""+ untrue: list[str] = []+ for operation, entry in vendored["operations"].items():+ actual = upstream.get(operation)+ if actual is None:+ untrue.append(f"AWS no longer lists iam:PassRole for {operation}")+ elif actual["passedTo"] != entry["passedTo"]:+ untrue.append(f"AWS passes {operation}'s role to {actual['passedTo']}, not {entry['passedTo']}")+ elif not set(actual["clients"]) <= set(vendored["namespaces"][namespace_of(operation)]):+ untrue.append(f"AWS lists {operation} for {actual['clients']}, which the file does not read")+ added = sorted(operation for operation in upstream+ if namespace_of(operation) in vendored["namespaces"] and operation not in vendored["operations"])+ return untrue, added+++def _shown(path: Path) -> Path:+ try:+ return path.resolve().relative_to(REPO_ROOT)+ except ValueError:+ return path+++def main(argv: list[str] | None = None) -> int:+ parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)+ parser.add_argument("--check", action="store_true", help="offline: members match the pinned botocore")+ parser.add_argument("--verify", action="store_true", help="online: operations match AWS")+ parser.add_argument("--source-dir", type=Path, default=None,+ help="read saved <service>.json reference files instead of fetching them")+ parser.add_argument("--botocore-data", type=Path, default=None, help="botocore data directory")+ parser.add_argument("--output", type=Path, default=OUTPUT, help=argparse.SUPPRESS)+ args = parser.parse_args(argv)++ if args.check or args.verify:+ if not args.output.exists():+ print(f"error: {args.output} does not exist", file=sys.stderr)+ return 1+ document = json.loads(args.output.read_text(encoding="utf-8"))+ problems = validate(document)+ if not problems and args.check:+ data, _ = resolve_botocore_data(args.botocore_data)+ problems = derive(document, data)+ for problem in problems:+ print(f"error: {problem}", file=sys.stderr)+ if problems:+ return 1+ entries = len(document["operations"])+ if args.check:+ print(f"{_shown(args.output)} matches botocore ({entries} operations over "+ f"{len(document['namespaces'])} namespaces)")+ return 0+ try:+ documents, provenance = fetch_references(args.source_dir)+ upstream = passed_role_operations(documents)+ except (OSError, ValueError) as e:+ print(f"error: could not read the Service Reference ({e})", file=sys.stderr)+ return 2+ untrue, added = verify_against(document, upstream)+ for claim in untrue:+ print(f"error: {claim}", file=sys.stderr)+ if untrue:+ print(f"error: {len(untrue)} vendored operation(s) do not hold upstream.", file=sys.stderr)+ return 1+ if added:+ print(f"{_shown(args.output)}: all {entries} operations verified. AWS has since added "+ f"{len(added)}, so the file is incomplete but not wrong (run without --verify to refresh): "+ f"{', '.join(added[:10])}{'...' if len(added) > 10 else ''}")+ else:+ print(f"{_shown(args.output)}: all {entries} operations verified against {provenance}, "+ f"nothing added upstream.")+ return 0++ data, botocore = resolve_botocore_data(args.botocore_data)+ try:+ documents, provenance = fetch_references(args.source_dir)+ document = build(documents, provenance, data, botocore)+ except (OSError, ValueError) as e:+ print(f"error: {e}", file=sys.stderr)+ return 2+ problems = validate(document)+ for problem in problems:+ print(f"error: {problem}", file=sys.stderr)+ if problems:+ return 1+ args.output.write_text(render(document), encoding="utf-8")+ print(f"wrote {_shown(args.output)} ({len(document['operations'])} operations over "+ f"{len(document['namespaces'])} namespaces, from {provenance})")+ return 0+++if __name__ == "__main__":+ raise SystemExit(main())diff --git a/tools/aws/test_regen_iam_passed_roles.py b/tools/aws/test_regen_iam_passed_roles.pynew file mode 100644index 0000000000..f1d14fcf9d--- /dev/null+++ b/tools/aws/test_regen_iam_passed_roles.py@@ -0,0 +1,314 @@+"""Tests for regen_iam_passed_roles.++Run with: pytest tools/aws -q (or: make iam-passed-roles-test)+"""+from __future__ import annotations++import json++import pytest++import regen_iam_passed_roles as r+++def reference(namespace: str, operations: dict[str, list[str] | None], clients: dict[str, list[str]] | None = None) -> dict:+ """A Service Reference document. Each operation maps to the services it passes a role to, or to None+ when it lists no iam:PassRole; `clients` gives an operation's SDK clients, the namespace by default."""+ entries = []+ for name, services in operations.items():+ authorized = [{"Service": namespace, "Name": name}]+ if services is not None:+ authorized.append({"Service": "iam", "Name": "PassRole",+ "Context": {"iam:PassedToService": [s + ".amazonaws.com" for s in services]}})+ sdk = [{"Name": c, "Method": name, "Package": "Boto3"} for c in (clients or {}).get(name, [namespace])]+ entries.append({"Name": name, "AuthorizedActions": authorized, "SDK": sdk})+ return {"Name": namespace, "Operations": entries}+++def model(operations: dict[str, dict], shapes: dict[str, dict], protocol: str = "json") -> dict:+ """A botocore model whose operations take the input shape each names."""+ return {"metadata": {"protocol": protocol},+ "operations": {name: {"input": {"shape": shape}} for name, shape in operations.items()},+ "shapes": {"String": {"type": "string"}, **shapes}}+++def structure(**members) -> dict:+ return {"type": "structure", "members": {name: ({"shape": spec} if isinstance(spec, str) else spec)+ for name, spec in members.items()}}+++def corrections(monkeypatch):+ """No corrections at all, so a test sees the rule alone and sets what it needs."""+ for name in ("BY_HAND", "NOT_READ", "EXCLUDED_MEMBERS", "EXTRA_MEMBERS", "MEMBER_SERVICES"):+ monkeypatch.setattr(r, name, {})+ monkeypatch.setattr(r, "NAMESPACES", ("svc",))+ return monkeypatch+++# --------------------------------------------------------------------------- #+# The Service Reference+# --------------------------------------------------------------------------- #+def test_only_operations_listing_pass_role_are_kept_with_their_services_and_clients():+ found = r.passed_role_operations([reference("svc", {"CreateThing": ["svc", "other"], "GetThing": None},+ {"CreateThing": ["svc", "svcv2"]})])+ assert found == {"svc:CreateThing": {"passedTo": ["other", "svc"], "clients": ["svc", "svcv2"]}}+++def test_a_pass_role_with_no_service_passes_to_none():+ document = reference("svc", {"CreateGroup": []})+ assert r.passed_role_operations([document])["svc:CreateGroup"]["passedTo"] == []+++def test_a_passed_to_service_that_is_no_principal_is_a_malformed_response():+ document = reference("svc", {"CreateThing": ["svc"]})+ document["Operations"][0]["AuthorizedActions"][1]["Context"]["iam:PassedToService"] = ["svc"]+ with pytest.raises(ValueError, match="service principal"):+ r.passed_role_operations([document])+++def test_an_unusable_namespace_is_rejected():+ with pytest.raises(ValueError, match="not usable"):+ r.passed_role_operations([{"Name": "Not A Namespace", "Operations": []}])+++# --------------------------------------------------------------------------- #+# botocore: the members that name a role+# --------------------------------------------------------------------------- #+def test_a_member_is_a_role_by_its_name_when_it_holds_a_string():+ m = model({"Op": "In"}, {+ "In": structure(Role="String", ServiceRoleArn="String", IamRoleName="String", IamRoles="Roles",+ RoleARNUpdate="String", serviceRoleOverride="String", RoleSessionName="String",+ AmbiguousRoleResolution="String", RoleCount="Integer", Name="String"),+ "Roles": {"type": "list", "member": {"shape": "String"}},+ "Integer": {"type": "integer"},+ })+ assert r.role_members(m, "Op") == {"Role": False, "ServiceRoleArn": False, "IamRoleName": True,+ "IamRoles[]": False, "RoleARNUpdate": False, "serviceRoleOverride": False}+++def test_an_enum_names_no_role():+ m = model({"Op": "In"}, {"In": structure(role="RoleType"), "RoleType": {"type": "string", "enum": ["ADMIN"]}})+ assert r.role_members(m, "Op") == {}+++def test_nested_lists_maps_and_named_list_members_are_written_as_steps():+ m = model({"Op": "In"}, {+ "In": structure(Rule="Rule", Roles="RoleMap", Associated="Associated"),+ "Rule": structure(Actions="Actions"),+ "Actions": {"type": "list", "member": {"shape": "Action"}},+ "Action": structure(S3Action="S3Action"),+ "S3Action": structure(IamRoleArn="String"),+ "RoleMap": {"type": "map", "key": {"shape": "String"}, "value": {"shape": "String"}},+ "Associated": {"type": "list", "member": {"shape": "Assoc", "locationName": "AssociatedRole"}},+ "Assoc": structure(RoleArn="String"),+ }, protocol="query")+ assert r.role_members(m, "Op") == {"Rule.Actions[].S3Action.IamRoleArn": False, "Roles{}": False,+ "Associated[AssociatedRole].RoleArn": False}+++def test_a_member_serialized_under_another_name_is_written_under_it():+ m = model({"Op": "In"}, {"In": structure(RoleArn={"shape": "String", "locationName": "roleArn"})})+ assert r.role_members(m, "Op") == {"roleArn": False}+++def test_a_member_bound_to_the_uri_a_header_or_the_query_string_is_not_read():+ m = model({"Op": "In"}, {"In": structure(RoleArn={"shape": "String", "location": "uri"},+ BodyRoleArn="String")}, protocol="rest-json")+ assert r.role_members(m, "Op") == {"BodyRoleArn": False}+++def test_a_payload_member_is_the_body():+ m = model({"Op": "In"}, {"In": {"type": "structure", "payload": "Config",+ "members": {"Config": {"shape": "Config"}}},+ "Config": structure(RoleArn="String")}, protocol="rest-json")+ assert r.role_members(m, "Op") == {"RoleArn": False}++[email protected]("documentation", [+ "The name or Amazon Resource Name (ARN) of the IAM role associated with this job.",+ "The short name or full Amazon Resource Name (ARN) of the IAM role.",+ "The IAM role or Amazon Resource Name (ARN) of an IAM role used by the new crawler.",+ "The name of a service role for this build.",+])+def test_documentation_saying_a_member_takes_a_name_marks_it_by_name(documentation):+ m = model({"Op": "In"}, {"In": structure(Role={"shape": "String", "documentation": documentation})})+ assert r.role_members(m, "Op") == {"Role": True}+++def test_an_amazon_resource_name_alone_takes_no_name():+ m = model({"Op": "In"}, {"In": structure(RoleArn={"shape": "String", "documentation":+ "The Amazon Resource Name of the IAM role assumed."})})+ assert r.role_members(m, "Op") == {"RoleArn": False}+++def test_a_pattern_that_only_admits_an_arn_takes_no_name():+ m = model({"Op": "In"}, {"In": structure(ExecutionRoleArn={"shape": "RoleArn", "documentation":+ "The name of the IAM execution role."}),+ "RoleArn": {"type": "string", "pattern": "arn:.+:iam::[0-9]{12}:role/.+"}})+ assert r.role_members(m, "Op") == {"ExecutionRoleArn": False}++[email protected]("protocol", ["ec2", "rest-xml"])+def test_a_model_whose_requests_are_not_read_has_no_members(protocol):+ m = model({"Op": "In"}, {"In": structure(RoleArn="String")}, protocol=protocol)+ assert r.role_members(m, "Op") == {}+++def test_a_member_path_with_a_map_key_exists_only_for_a_key_the_enum_lists():+ m = model({"Op": "In"}, {"In": structure(Definition="Definition"),+ "Definition": {"type": "map", "key": {"shape": "Key"}, "value": {"shape": "String"}},+ "Key": {"type": "string", "enum": ["Name", "AssumeRole"]}})+ assert r.member_exists(m, "Op", "Definition{AssumeRole}")+ assert not r.member_exists(m, "Op", "Definition{Missing}")+ assert not r.member_exists(m, "Op", "Definition[]")+ assert not r.member_exists(m, "Op", "Other")+++# --------------------------------------------------------------------------- #+# One operation's entry+# --------------------------------------------------------------------------- #+SIMPLE = {"svc": model({"CreateThing": "In"}, {"In": structure(RoleArn="String", Roles="RoleList"),+ "RoleList": {"type": "list", "member": {"shape": "String"}}})}+++def test_each_member_goes_to_the_one_service_the_reference_names(corrections):+ assert r.entry_for("svc:CreateThing", ["svc"], SIMPLE) == {+ "passedTo": ["svc"],+ "roles": [{"member": "RoleArn", "passedTo": "svc"}, {"member": "Roles[]", "passedTo": "svc"}]}+++def test_a_role_passed_to_no_named_service_carries_none(corrections):+ assert r.entry_for("svc:CreateThing", [], SIMPLE)["roles"][0] == {"member": "RoleArn"}+++def test_several_services_need_a_member_service(corrections):+ with pytest.raises(ValueError, match="MEMBER_SERVICES"):+ r.entry_for("svc:CreateThing", ["svc", "other"], SIMPLE)+ corrections.setattr(r, "MEMBER_SERVICES", {"svc:*": {"*": "other"}})+ assert {role["passedTo"] for role in r.entry_for("svc:CreateThing", ["svc", "other"], SIMPLE)["roles"]} == {"other"}+++def test_hand_and_unread_operations_carry_their_reason_and_no_members(corrections):+ corrections.setattr(r, "BY_HAND", {"svc:CreateThing": "an instance profile's roles"})+ assert r.entry_for("svc:CreateThing", ["svc"], SIMPLE) == {"passedTo": ["svc"],+ "byHand": "an instance profile's roles"}+ corrections.setattr(r, "BY_HAND", {})+ corrections.setattr(r, "NOT_READ", {"svc:CreateThing": "no member of the request names a role"})+ assert r.entry_for("svc:CreateThing", ["svc"], SIMPLE)["notRead"] == "no member of the request names a role"+++def test_an_exclusion_drops_a_member_and_an_extra_one_adds_it(corrections):+ corrections.setattr(r, "EXCLUDED_MEMBERS", {"svc:*": {"Roles[]": "roles a policy is attached to"}})+ corrections.setattr(r, "EXTRA_MEMBERS", {"svc:CreateThing": {"RoleArn": (True, "takes a name")}})+ assert r.entry_for("svc:CreateThing", ["svc"], SIMPLE)["roles"] == [+ {"member": "RoleArn", "passedTo": "svc", "byName": True}]+++def test_an_extra_member_the_request_does_not_have_fails(corrections):+ corrections.setattr(r, "EXTRA_MEMBERS", {"svc:CreateThing": {"Missing.RoleArn": (False, "a typo")}})+ with pytest.raises(ValueError, match="does not have"):+ r.entry_for("svc:CreateThing", ["svc"], SIMPLE)+++def test_an_operation_naming_no_role_must_say_why(corrections):+ empty = {"svc": model({"CreateThing": "In"}, {"In": structure(Name="String")})}+ with pytest.raises(ValueError, match="NOT_READ"):+ r.entry_for("svc:CreateThing", ["svc"], empty)+++# --------------------------------------------------------------------------- #+# The whole document+# --------------------------------------------------------------------------- #+def write_models(root, models: dict[str, dict]):+ for name, value in models.items():+ directory = root / name / "2020-01-01"+ directory.mkdir(parents=True)+ (directory / "service-2.json").write_text(json.dumps(value), encoding="utf-8")+++def test_a_built_document_validates_and_matches_botocore(corrections, tmp_path):+ write_models(tmp_path, SIMPLE)+ document = r.build([reference("svc", {"CreateThing": ["svc"]}), reference("elsewhere", {"Op": ["x"]})],+ "test", tmp_path, "botocore test")+ assert r.validate(document) == []+ assert r.derive(document, tmp_path) == []+ assert document["namespaces"] == {"svc": ["svc"]}+ assert document["otherNamespaces"] == ["elsewhere"]+ assert json.loads(r.render(document)) == document+++def test_a_hand_edited_member_does_not_match_botocore(corrections, tmp_path):+ write_models(tmp_path, SIMPLE)+ document = r.build([reference("svc", {"CreateThing": ["svc"]})], "test", tmp_path, "botocore test")+ document["operations"]["svc:CreateThing"]["roles"].append({"member": "Other", "passedTo": "svc"})+ assert r.validate(document) == []+ assert len(r.derive(document, tmp_path)) == 1+++def test_a_correction_naming_an_operation_the_reference_does_not_list_fails(corrections, tmp_path):+ write_models(tmp_path, SIMPLE)+ corrections.setattr(r, "NOT_READ", {"svc:Gone": "no member of the request names a role"})+ with pytest.raises(ValueError, match="svc:Gone"):+ r.build([reference("svc", {"CreateThing": ["svc"]})], "test", tmp_path, "botocore test")+++def test_an_exclusion_no_operation_has_fails(corrections, tmp_path):+ write_models(tmp_path, SIMPLE)+ corrections.setattr(r, "EXCLUDED_MEMBERS", {"svc:*": {"Missing": "no longer there"}})+ with pytest.raises(ValueError, match="no operation there has"):+ r.build([reference("svc", {"CreateThing": ["svc"]})], "test", tmp_path, "botocore test")+++def good_document() -> dict:+ return {"namespaces": {"svc": ["svc"]}, "operations": {+ "svc:A": {"passedTo": ["svc"], "roles": [{"member": "Rule.Actions[].RoleArn", "passedTo": "svc"}]},+ "svc:B": {"passedTo": ["svc"], "byHand": "an instance profile's roles"},+ "svc:C": {"passedTo": [], "notRead": "no member of the request names a role"}}}+++def test_a_well_formed_document_validates():+ assert r.validate(good_document()) == []++[email protected]("change, problem", [+ (lambda d: d["operations"]["svc:A"].update(byHand="x"), "exactly one"),+ (lambda d: d["operations"]["svc:A"]["roles"][0].update(member="Rule..RoleArn"), "no member path"),+ (lambda d: d["operations"]["svc:A"]["roles"][0].update(passedTo="other"), "does not name"),+ (lambda d: d["operations"]["svc:A"]["roles"][0].pop("passedTo"), "goes to no service"),+ (lambda d: d["operations"]["svc:A"]["roles"][0].update(byName=False), "unknown field"),+ (lambda d: d["operations"].update({"other:D": {"passedTo": [], "notRead": "x"}}), "namespace the file reads"),+])+def test_a_malformed_document_is_rejected(change, problem):+ document = good_document()+ change(document)+ assert any(problem in p for p in r.validate(document)), r.validate(document)+++def test_verify_fails_on_a_claim_aws_does_not_make_and_reports_an_added_operation():+ vendored = good_document()+ upstream = {"svc:A": {"passedTo": ["svc"], "clients": ["svc"]},+ "svc:B": {"passedTo": ["other"], "clients": ["svc"]},+ "svc:D": {"passedTo": ["svc"], "clients": ["svc"]},+ "elsewhere:E": {"passedTo": ["x"], "clients": ["elsewhere"]}}+ untrue, added = r.verify_against(vendored, upstream)+ assert len(untrue) == 2 and any("svc:B" in u for u in untrue) and any("svc:C" in u for u in untrue)+ assert added == ["svc:D"]+++def test_verify_fails_when_aws_lists_an_operation_for_a_client_the_file_does_not_read():+ untrue, _ = r.verify_against(good_document(), {+ "svc:A": {"passedTo": ["svc"], "clients": ["svc", "svcv2"]},+ "svc:B": {"passedTo": ["svc"], "clients": ["svc"]},+ "svc:C": {"passedTo": [], "clients": ["svc"]}})+ assert untrue == ["AWS lists svc:A for ['svc', 'svcv2'], which the file does not read"]+++def test_the_vendored_file_is_well_formed():+ document = json.loads(r.OUTPUT.read_text(encoding="utf-8"))+ assert r.validate(document) == []+ assert document["operations"]["athena:CreateWorkGroup"]["roles"] == [+ {"member": "Configuration.ExecutionRole", "passedTo": "athena"}]+ assert document["operations"]["budgets:CreateBudgetAction"]["roles"] == [+ {"member": "ExecutionRoleArn", "passedTo": "budgets"}]+ assert document["operations"]["ec2:RunInstances"].get("byHand")