Light, fluffy, and always free - The AWS Local Emulator alternative
fix(iam): check iam:PassRole for RDS and DMS (#6389)
Priamo Germosen6215b6fd381a
diff --git a/docs/services/iam.md b/docs/services/iam.mdindex 663427e3de..cd5711cc83 100644--- a/docs/services/iam.md+++ b/docs/services/iam.md@@ -1551,6 +1551,21 @@ role each passes:**Redshift Serverless:** `CreateNamespace` and `UpdateNamespace` pass the roles in `iamRoles` andthe one in `defaultIamRoleArn`, and `CreateScheduledAction` and `UpdateScheduledAction` pass`roleArn`, to `redshift-serverless.amazonaws.com`.+- **RDS:** `AddRoleToDBCluster`, `AddRoleToDBInstance`, `RemoveRoleFromDBCluster`,+ `RemoveRoleFromDBInstance`, `CreateDBProxy` and `ModifyDBProxy` pass `RoleArn`, and+ `StartExportTask` passes `IamRoleArn`, to `rds.amazonaws.com`. `CreateDBInstance`,+ `CreateDBInstanceReadReplica`, `ModifyDBInstance`, `CreateDBCluster`, `ModifyDBCluster`,+ `RestoreDBClusterFromSnapshot` and `RestoreDBClusterToPointInTime` pass the Enhanced Monitoring+ role, `MonitoringRoleArn`, there too. They, `RestoreDBInstanceFromDBSnapshot` and+ `RestoreDBInstanceToPointInTime` pass the directory role `DomainIAMRoleName` names, checked on the+ ARN IAM holds it under, since the name carries no path. `CreateDBCluster` and the two cluster+ restores pass each role in `AssociatedRoles`, and `ModifyOptionGroup` passes the role each option+ it includes takes in its `IAM_ROLE_ARN` setting, as SQL Server's native backup and audit options+ do. **DMS:** `CreateEndpoint` and `ModifyEndpoint` pass `ServiceAccessRoleArn` and the role+ members the DMS model gives each engine's settings structure (`ServiceAccessRoleArn`,+ `SecretsManagerAccessRoleArn`, `SecretsManagerOracleAsmAccessRoleArn`), and+ `CreateReplicationInstance` and `ModifyReplicationInstance` pass+ `KerberosAuthenticationSettings.KeyCacheSecretIamArn`, to `dms.amazonaws.com`.Launching an instance from a launch template does not check the template's role, as on AWS: the EC2user guide warns that a user who can create launch template versions "can potentially update a launch@@ -1568,8 +1583,11 @@ a user must have iam:PassRole permission for that IAM role." A role named only adefault, `DefaultIamRoleArn`, is not checked on its own, since the default is one of the roles thecluster holds. A namespace's `defaultIamRoleArn` is, since Floci keeps it whether or not `iamRoles`holds it. Redshift takes a role only under the ARN IAM holds it under, path included, so the check-on the ARN as the request names it covers the role `COPY`, `UNLOAD` and Spectrum then use. The role-parameters of other services are not checked yet.+on the ARN as the request names it covers the role `COPY`, `UNLOAD` and Spectrum then use. The RDS+user guide has the Enhanced Monitoring role checked: "The user that enables Enhanced Monitoring must+be 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.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 thatdiff --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 3f1cdc5878..65e3a0aa63 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@@ -13,6 +13,7 @@ import java.util.ArrayList;import java.util.List;import java.util.Map;import java.util.Optional;+import java.util.Set;import java.util.regex.Pattern;/**@@ -80,6 +81,14 @@ import java.util.regex.Pattern;* default, which Floci keeps whether or not the namespace's roles hold it. Redshift takes a role only* under the ARN IAM holds it under, path included, so the ARN as the request names it is the role it* passes.+ *+ * <p>An RDS request passes to {@code rds.amazonaws.com} every role it names for the instance or cluster:+ * the role it adds or removes, a proxy's role, an export task's role, the Enhanced Monitoring role (the+ * RDS user guide: "The user that enables Enhanced Monitoring must be granted the PassRole permission."),+ * the directory role it names by name, a cluster's associated roles, and the role an option takes in its+ * {@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.*/final class PassedRoles {@@ -107,6 +116,45 @@ final class PassedRoles {private static final String APPLICATION_AUTOSCALING = ServicePrincipals.of("application-autoscaling");private static final String REDSHIFT = ServicePrincipals.of("redshift");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");++ /** The RDS operations whose request takes a {@code MonitoringRoleArn}. */+ private static final Set<String> RDS_MONITORING_ROLE = Set.of("rds:CreateDBCluster", "rds:CreateDBInstance",+ "rds:CreateDBInstanceReadReplica", "rds:ModifyDBCluster", "rds:ModifyDBInstance",+ "rds:RestoreDBClusterFromSnapshot", "rds:RestoreDBClusterToPointInTime");+ /** The RDS operations whose request takes a cluster's {@code AssociatedRoles}. */+ private static final Set<String> RDS_ASSOCIATED_ROLES = Set.of("rds:CreateDBCluster",+ "rds:RestoreDBClusterFromSnapshot", "rds:RestoreDBClusterToPointInTime");+ /** An associated role's ARN, in either list form the RDS handler reads, at any index. */+ private static final Pattern ASSOCIATED_ROLE =+ Pattern.compile("AssociatedRoles\\.(DBClusterAssociatedRole|member)\\.\\d+\\.RoleArn");+ /** The option setting SQL Server's backup and audit options take their role in. */+ private static final String OPTION_ROLE_SETTING = "IAM_ROLE_ARN";+ private static final String DMS_SERVICE_ACCESS_ROLE = "ServiceAccessRoleArn";+ private static final String DMS_SECRETS_ROLE = "SecretsManagerAccessRoleArn";+ /**+ * The role members of each DMS endpoint settings structure, as the DMS model gives them. Every structure+ * here is one the DMS handler stores; the others ({@code KafkaSettings}, {@code RedisSettings},+ * {@code TimestreamSettings}) name no role.+ */+ private static final Map<String, List<String>> DMS_SETTINGS_ROLES = Map.ofEntries(+ Map.entry("DynamoDbSettings", List.of(DMS_SERVICE_ACCESS_ROLE)),+ Map.entry("S3Settings", List.of(DMS_SERVICE_ACCESS_ROLE)),+ Map.entry("DmsTransferSettings", List.of(DMS_SERVICE_ACCESS_ROLE)),+ Map.entry("KinesisSettings", List.of(DMS_SERVICE_ACCESS_ROLE)),+ Map.entry("ElasticsearchSettings", List.of(DMS_SERVICE_ACCESS_ROLE)),+ Map.entry("NeptuneSettings", List.of(DMS_SERVICE_ACCESS_ROLE)),+ Map.entry("RedshiftSettings", List.of(DMS_SERVICE_ACCESS_ROLE, DMS_SECRETS_ROLE)),+ Map.entry("PostgreSQLSettings", List.of(DMS_SERVICE_ACCESS_ROLE, DMS_SECRETS_ROLE)),+ Map.entry("MySQLSettings", List.of(DMS_SERVICE_ACCESS_ROLE, DMS_SECRETS_ROLE)),+ Map.entry("MongoDbSettings", List.of(DMS_SECRETS_ROLE)),+ Map.entry("OracleSettings", List.of(DMS_SECRETS_ROLE, "SecretsManagerOracleAsmAccessRoleArn")),+ Map.entry("SybaseSettings", List.of(DMS_SECRETS_ROLE)),+ Map.entry("MicrosoftSQLServerSettings", List.of(DMS_SECRETS_ROLE)),+ Map.entry("IBMDb2Settings", List.of(DMS_SECRETS_ROLE)),+ Map.entry("DocDbSettings", List.of(DMS_SECRETS_ROLE)),+ Map.entry("GcpMySQLSettings", List.of(DMS_SECRETS_ROLE)));private static final String STACK_SET_ADMINISTRATION_ROLE = "AWSCloudFormationStackSetAdministrationRole";private static final String SERVICE_MANAGED = "SERVICE_MANAGED";@@ -208,6 +256,18 @@ final class PassedRoles {case "redshift-serverless:CreateNamespace", "redshift-serverless:UpdateNamespace" -> namespaceRoles(ctx);case "redshift-serverless:CreateScheduledAction", "redshift-serverless:UpdateScheduledAction" ->fromJson(ctx, REDSHIFT_SERVERLESS, "roleArn");+ case "rds:AddRoleToDBCluster", "rds:AddRoleToDBInstance", "rds:RemoveRoleFromDBCluster",+ "rds:RemoveRoleFromDBInstance", "rds:CreateDBProxy", "rds:ModifyDBProxy" ->+ fromForm(ctx, RDS, "RoleArn");+ case "rds:StartExportTask" -> fromForm(ctx, RDS, "IamRoleArn");+ case "rds:CreateDBInstance", "rds:CreateDBInstanceReadReplica", "rds:ModifyDBInstance",+ "rds:RestoreDBInstanceFromDBSnapshot", "rds:RestoreDBInstanceToPointInTime", "rds:CreateDBCluster",+ "rds:ModifyDBCluster", "rds:RestoreDBClusterFromSnapshot", "rds:RestoreDBClusterToPointInTime" ->+ rdsDatabaseRoles(action, ctx, lookups);+ case "rds:ModifyOptionGroup" -> optionGroupRoles(ctx);+ case "dms:CreateEndpoint", "dms:ModifyEndpoint" -> dmsEndpointRoles(jsonBody(ctx));+ case "dms:CreateReplicationInstance", "dms:ModifyReplicationInstance" ->+ fromJson(ctx, DMS, "KerberosAuthenticationSettings", "KeyCacheSecretIamArn");default -> List.of();};}@@ -432,6 +492,72 @@ final class PassedRoles {return passed(roles, REDSHIFT_SERVERLESS);}+ /**+ * The roles an RDS instance or cluster request names: the directory role {@code DomainIAMRoleName}+ * names without its path, which is checked on the ARN IAM holds it under as+ * {@link #instanceProfileRole} checks a role name; and the {@code MonitoringRoleArn} and the+ * {@code AssociatedRoles} where the operation takes them, every associated role at any index, as the RDS+ * handler reads them.+ */+ private static List<PassedRole> rdsDatabaseRoles(String action, ContainerRequestContext ctx, Lookups lookups) {+ Map<String, String> form = IamConditionContextResolver.formParameters(ctx);+ List<String> roles = new ArrayList<>();+ String directoryRole = blankToNull(form.get("DomainIAMRoleName"));+ if (directoryRole != null) {+ roles.add(lookups.heldRoleArn(directoryRole).orElseGet(() -> lookups.roleArn(directoryRole)));+ }+ if (RDS_MONITORING_ROLE.contains(action)) {+ roles.add(form.get("MonitoringRoleArn"));+ }+ if (RDS_ASSOCIATED_ROLES.contains(action)) {+ form.forEach((key, value) -> {+ if (ASSOCIATED_ROLE.matcher(key).matches()) {+ roles.add(value);+ }+ });+ }+ return passed(roles, RDS);+ }++ /**+ * The role each option of a ModifyOptionGroup request takes in its {@code IAM_ROLE_ARN} setting, read+ * as the RDS handler reads {@code OptionsToInclude}: in either list form, each option from 1 up to the+ * first with no {@code OptionName}, each setting up to the first with no {@code Name}, and of an option+ * naming the setting twice the last.+ */+ private static List<PassedRole> optionGroupRoles(ContainerRequestContext ctx) {+ Map<String, String> form = IamConditionContextResolver.formParameters(ctx);+ List<String> roles = new ArrayList<>();+ for (String options : List.of("OptionsToInclude.OptionConfiguration.", "OptionsToInclude.member.")) {+ for (int option = 1; form.get(options + option + ".OptionName") != null; option++) {+ String role = null;+ for (String settings : List.of(".OptionSettings.OptionSetting.", ".OptionSettings.member.")) {+ String setting = options + option + settings;+ for (int index = 1; form.get(setting + index + ".Name") != null; index++) {+ if (OPTION_ROLE_SETTING.equals(form.get(setting + index + ".Name"))) {+ role = form.get(setting + index + ".Value");+ }+ }+ }+ roles.add(role);+ }+ }+ return passed(roles, RDS);+ }++ /** A DMS endpoint's service access role, and the role members of each engine's settings structure it sets. */+ private static List<PassedRole> dmsEndpointRoles(JsonNode body) {+ List<String> roles = new ArrayList<>(values(body, DMS_SERVICE_ACCESS_ROLE));+ if (body != null) {+ for (Map.Entry<String, JsonNode> member : body.properties()) {+ for (String role : DMS_SETTINGS_ROLES.getOrDefault(member.getKey(), List.of())) {+ roles.addAll(values(member.getValue(), role));+ }+ }+ }+ return passed(roles, DMS);+ }+private static List<PassedRole> fromJson(ContainerRequestContext ctx, String service, String... path) {return passed(values(jsonBody(ctx), path), service);}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 c2c17bc7c0..7869300c59 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@@ -32,6 +32,8 @@ class PassedRolesTest {private static final String DEFAULT_ADMINISTRATION = ROLES + "AWSCloudFormationStackSetAdministrationRole";private static final String EC2 = "ec2.amazonaws.com";private static final String AUTOSCALING = "autoscaling.amazonaws.com";+ private static final String RDS = "rds.amazonaws.com";+ private static final String DMS = "dms.amazonaws.com";private static final String PROFILE_ARN = "arn:aws:iam::111122223333:instance-profile/arn-profile";/**@@ -418,6 +420,81 @@ class PassedRolesTest {}}+ @Test+ void rdsPassesEachRoleARequestNamesForAnInstanceOrClusterToRds() {+ for (String action : new String[] {"rds:AddRoleToDBCluster", "rds:AddRoleToDBInstance",+ "rds:RemoveRoleFromDBCluster", "rds:RemoveRoleFromDBInstance", "rds:CreateDBProxy", "rds:ModifyDBProxy"}) {+ assertEquals(List.of(passed("feature", RDS)), PassedRoles.of(action,+ form("DBInstanceIdentifier=d&RoleArn=" + ROLES + "feature&FeatureName=s3Import"), LOOKUPS), action);+ }+ assertEquals(List.of(passed("export", RDS)), PassedRoles.of("rds:StartExportTask",+ form("ExportTaskIdentifier=e&IamRoleArn=" + ROLES + "export"), LOOKUPS));+ // The directory role is named without its path, so it is checked on the ARN IAM holds it under.+ assertEquals(List.of(new PassedRole(ROLES + "app/app-role", RDS), passed("monitoring", RDS)),+ PassedRoles.of("rds:CreateDBInstance", form("DBInstanceIdentifier=d&DomainIAMRoleName=app-role"+ + "&MonitoringRoleArn=" + ROLES + "monitoring"), LOOKUPS));+ assertEquals(List.of(passed("gone", RDS)), PassedRoles.of("rds:ModifyDBCluster",+ form("DBClusterIdentifier=c&DomainIAMRoleName=gone"), LOOKUPS));+ // A cluster's associated roles at any index, in either list form; a restore of an instance takes no+ // monitoring role, and a modify of a cluster no associated roles.+ assertEquals(List.of(passed("monitoring", RDS), passed("s3", RDS), passed("lambda", RDS)),+ PassedRoles.of("rds:RestoreDBClusterToPointInTime", form("DBClusterIdentifier=c&MonitoringRoleArn="+ + ROLES + "monitoring&AssociatedRoles.DBClusterAssociatedRole.1.RoleArn=" + ROLES+ + "s3&AssociatedRoles.member.3.RoleArn=" + ROLES + "lambda"), LOOKUPS));+ assertEquals(List.of(passed("gone", RDS)), PassedRoles.of("rds:RestoreDBInstanceFromDBSnapshot",+ form("DBInstanceIdentifier=d&DomainIAMRoleName=gone&MonitoringRoleArn=" + ROLES + "monitoring"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("rds:ModifyDBCluster",+ form("DBClusterIdentifier=c&AssociatedRoles.member.1.RoleArn=" + ROLES + "s3"), LOOKUPS));+ assertEquals(List.of(), PassedRoles.of("rds:CreateDBCluster", form("DBClusterIdentifier=c"), LOOKUPS));+ }++ @Test+ void anOptionGroupPassesTheRoleEachOptionTakesInItsIamRoleSettingToRds() {+ String backup = "OptionsToInclude.OptionConfiguration.1.";+ String audit = "OptionsToInclude.OptionConfiguration.2.";+ String legacy = "OptionsToInclude.member.1.";+ // Read as the handler reads it: both list forms, up to the first gap, and a setting named twice+ // as its last value.+ assertEquals(List.of(passed("audit", RDS), passed("legacy", RDS)), PassedRoles.of("rds:ModifyOptionGroup",+ form("OptionGroupName=g&" + backup + "OptionName=SQLSERVER_BACKUP_RESTORE&" + backup+ + "OptionSettings.OptionSetting.2.Name=IAM_ROLE_ARN&" + backup+ + "OptionSettings.OptionSetting.2.Value=" + ROLES + "after-gap&" + audit+ + "OptionName=SQLSERVER_AUDIT&" + audit + "OptionSettings.OptionSetting.1.Name=S3_BUCKET_ARN&"+ + audit + "OptionSettings.OptionSetting.1.Value=" + ROLES + "bucket&" + audit+ + "OptionSettings.OptionSetting.2.Name=IAM_ROLE_ARN&" + audit+ + "OptionSettings.OptionSetting.2.Value=" + ROLES + "first&" + audit+ + "OptionSettings.member.1.Name=IAM_ROLE_ARN&" + audit + "OptionSettings.member.1.Value="+ + ROLES + "audit&" + legacy + "OptionName=SQLSERVER_BACKUP_RESTORE&" + legacy+ + "OptionSettings.member.1.Name=IAM_ROLE_ARN&" + legacy + "OptionSettings.member.1.Value="+ + ROLES + "legacy&OptionsToInclude.OptionConfiguration.4.OptionName=SQLSERVER_AUDIT&"+ + "OptionsToInclude.OptionConfiguration.4.OptionSettings.OptionSetting.1.Name=IAM_ROLE_ARN&"+ + "OptionsToInclude.OptionConfiguration.4.OptionSettings.OptionSetting.1.Value=" + ROLES+ + "option-after-gap"), LOOKUPS));+ }++ @Test+ void dmsPassesItsEndpointsAndReplicationInstancesRolesToDms() {+ String endpoint = """+ {"EndpointIdentifier":"e","ServiceAccessRoleArn":"%1$saccess",+ "S3Settings":{"ServiceAccessRoleArn":"%1$ss3","BucketName":"b"},+ "PostgreSQLSettings":{"SecretsManagerAccessRoleArn":"%1$ssecrets"},+ "OracleSettings":{"SecretsManagerOracleAsmAccessRoleArn":"%1$sasm"},+ "Tags":[{"Key":"ServiceAccessRoleArn","Value":"%1$stag"}],+ "FooSettings":{"ServiceAccessRoleArn":"%1$sunknown-structure"},+ "KafkaSettings":{"ServiceAccessRoleArn":"%1$sno-role-member"},+ "DynamoDbSettings":{"SecretsManagerAccessRoleArn":"%1$snot-its-member"}}""".formatted(ROLES);+ // Only the role members the DMS model gives each settings structure the handler stores.+ for (String action : new String[] {"dms:CreateEndpoint", "dms:ModifyEndpoint"}) {+ assertEquals(List.of(passed("access", DMS), passed("s3", DMS), passed("secrets", DMS), passed("asm", DMS)),+ PassedRoles.of(action, json(endpoint), LOOKUPS), action);+ }+ for (String action : new String[] {"dms:CreateReplicationInstance", "dms:ModifyReplicationInstance"}) {+ assertEquals(List.of(passed("key-cache", DMS)), PassedRoles.of(action, json(+ "{\"KerberosAuthenticationSettings\":{\"KeyCacheSecretIamArn\":\"" + ROLES + "key-cache\"}}"),+ LOOKUPS), action);+ }+ }+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 ecefb83a44..e2dd20ba38 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@@ -21,6 +21,8 @@ import org.junit.jupiter.api.extension.RegisterExtension;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.net.URI;+import java.util.LinkedHashMap;+import java.util.Map;import java.util.zip.GZIPOutputStream;import static io.github.hectorvent.floci.testing.EnforcementFixtures.auth;@@ -53,6 +55,8 @@ class IamPassRoleEnforcementIntegrationTest {private static final String AUTOSCALING = "autoscaling.amazonaws.com";private static final String REDSHIFT = "redshift.amazonaws.com";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 SERVICE_LINKED_ROLES ="arn:aws:iam::" + ACCOUNT + ":role/aws-service-role/autoscaling.amazonaws.com/";private static final ObjectMapper CBOR_MAPPER = new ObjectMapper(new CBORFactory());@@ -888,6 +892,90 @@ class IamPassRoleEnforcementIntegrationTest {serverless(user, "UpdateNamespace").body(defaultOnly).post("/").then().statusCode(200);}+ @Test+ void anRdsRequestNeedsPassRoleOnEachRoleItNamesForRds() {+ String role = role("rds-feature");+ User user = user("passrole-rds");+ String missing = "passrole-missing-" + suffix();+ String option = "OptionsToInclude.OptionConfiguration.1.";+ Map<String, Map<String, String>> requests = new LinkedHashMap<>();+ requests.put("AddRoleToDBInstance", Map.of("DBInstanceIdentifier", missing, "RoleArn", role,+ "FeatureName", "s3Import"));+ requests.put("RemoveRoleFromDBCluster", Map.of("DBClusterIdentifier", missing, "RoleArn", role,+ "FeatureName", "s3Import"));+ requests.put("ModifyDBProxy", Map.of("DBProxyName", missing, "RoleArn", role));+ requests.put("ModifyDBInstance", Map.of("DBInstanceIdentifier", missing, "MonitoringInterval", "60",+ "MonitoringRoleArn", role));+ requests.put("RestoreDBClusterFromSnapshot", Map.of("DBClusterIdentifier", missing, "SnapshotIdentifier",+ missing, "Engine", "aurora-postgresql", "AssociatedRoles.DBClusterAssociatedRole.1.RoleArn", role));+ requests.put("ModifyOptionGroup", Map.of("OptionGroupName", missing, option + "OptionName",+ "SQLSERVER_BACKUP_RESTORE", option + "OptionSettings.OptionSetting.1.Name", "IAM_ROLE_ARN",+ option + "OptionSettings.OptionSetting.1.Value", role));+ requests.put("StartExportTask", Map.of("ExportTaskIdentifier", missing, "SourceArn",+ "arn:aws:rds:us-east-1:" + ACCOUNT + ":snapshot:" + missing, "S3BucketName", missing,+ "IamRoleArn", role, "KmsKeyId", "alias/" + missing));++ // A grant to pass the role to Redshift does not cover RDS; with one for RDS, each reaches RDS, which+ // has no such resource.+ user.policy(allow("rds:*", "*") + "," + passRole(role, REDSHIFT));+ requests.forEach((action, params) -> denied(user.rds(action).formParams(params).post("/").then()));+ user.policy(allow("rds:*", "*") + "," + passRole(role, RDS));+ requests.forEach((action, params) -> user.rds(action).formParams(params).post("/").then()+ .statusCode(not(403)).body(not(containsString("iam:PassRole"))));+ }++ @Test+ void anRdsDirectoryRoleNamedByNameNeedsPassRoleOnTheArnIamHoldsItUnder() {+ String role = role("/directory/", "rds-directory");+ User user = user("passrole-rds-directory");+ String pathless = "arn:aws:iam::" + ACCOUNT + ":role/" + roleName(role);+ String cluster = "passrole-missing-" + suffix();++ user.policy(allow("rds:ModifyDBCluster", "*") + "," + passRole(pathless, RDS));+ denied(modifyClusterDirectoryRole(user, cluster, roleName(role)).then());+ user.policy(allow("rds:ModifyDBCluster", "*") + "," + passRole(role, RDS));+ modifyClusterDirectoryRole(user, cluster, roleName(role)).then()+ .statusCode(404).body(containsString("DBClusterNotFound"));+ }++ private static Response modifyClusterDirectoryRole(User user, String cluster, String roleName) {+ return user.rds("ModifyDBCluster").formParam("DBClusterIdentifier", cluster)+ .formParam("DomainIAMRoleName", roleName).post("/");+ }++ @Test+ void aDmsEndpointAndReplicationInstanceNeedPassRoleOnTheirRolesForDms() {+ String role = role("dms-access");+ User user = user("passrole-dms");+ String endpoint = ("{\"EndpointIdentifier\":\"passrole-%s\",\"EndpointType\":\"target\",\"EngineName\":\"s3\","+ + "\"S3Settings\":{\"ServiceAccessRoleArn\":\"%s\",\"BucketName\":\"passrole-bucket\"}}")+ .formatted(suffix(), role);+ String modifyEndpoint = ("{\"EndpointArn\":\"arn:aws:dms:us-east-1:%s:endpoint:PASSROLEMISSING\","+ + "\"PostgreSQLSettings\":{\"SecretsManagerAccessRoleArn\":\"%s\"}}").formatted(ACCOUNT, role);+ String modifyInstance = ("{\"ReplicationInstanceArn\":\"arn:aws:dms:us-east-1:%s:rep:PASSROLEMISSING\","+ + "\"KerberosAuthenticationSettings\":{\"KeyCacheSecretIamArn\":\"%s\"}}").formatted(ACCOUNT, role);++ // A grant to pass the role to RDS does not cover DMS.+ user.policy(allow("dms:*", "*") + "," + passRole(role, RDS));+ deniedJson(dms(user, "CreateEndpoint").body(endpoint).post("/").then());+ deniedJson(dms(user, "ModifyEndpoint").body(modifyEndpoint).post("/").then());+ deniedJson(dms(user, "ModifyReplicationInstance").body(modifyInstance).post("/").then());++ user.policy(allow("dms:*", "*") + "," + passRole(role, DMS));+ String endpointArn = dms(user, "CreateEndpoint").body(endpoint).post("/").then().statusCode(200)+ .extract().path("Endpoint.EndpointArn");+ cleanup.register(() -> admin("dms").header("X-Amz-Target", "AmazonDMSv20160101.DeleteEndpoint")+ .contentType("application/x-amz-json-1.1").body("{\"EndpointArn\":\"" + endpointArn + "\"}").post("/"));+ dms(user, "ModifyEndpoint").body(modifyEndpoint).post("/").then()+ .statusCode(400).body(containsString("ResourceNotFoundFault"));+ dms(user, "ModifyReplicationInstance").body(modifyInstance).post("/").then()+ .statusCode(400).body(containsString("ResourceNotFoundFault"));+ }++ private static RequestSpecification dms(User user, String operation) {+ return user.json("dms", "AmazonDMSv20160101." + operation);+ }+private static Response restore(User user, String cluster, String role) {return user.redshift("RestoreFromClusterSnapshot").formParam("ClusterIdentifier", cluster).formParam("SnapshotIdentifier", "passrole-no-snapshot").formParam("IamRoles.IamRoleArn.1", role)@@ -1156,6 +1244,10 @@ class IamPassRoleEnforcementIntegrationTest {return given().header("Authorization", auth(accessKeyId, "redshift")).formParam("Action", action);}+ RequestSpecification rds(String action) {+ return given().header("Authorization", auth(accessKeyId, "rds")).formParam("Action", action);+ }+RequestSpecification ecs(String action) {return json("ecs", "AmazonEC2ContainerServiceV20141113." + action);}