Skip to content
Python
27.8 KB
Raw Blame
//! Permission domains for the emitted CloudFormation resources. Mutating IAM is
//! intentionally absent: bootstrap owns every platform and execution identity.
use super::*;
pub(super) struct Policies {
    pub execution: BTreeMap<String, Value>,
    pub cleanup: Value,
    pub review: Value,
}
fn statement(
    sid: &str,
    actions: &[&str],
    resources: Vec<String>,
    condition: Option<Value>,
) -> Value {
    let mut v = json!({"Sid":sid,"Effect":"Allow","Action":actions,"Resource":resources});
    if let Some(c) = condition {
        v["Condition"] = c;
    }
    v
}
pub(super) fn generate(p: &Plan, i: &Inputs, infra: &Value, guard: &Value) -> Result<Policies> {
    let (account, region) = scope(p);
    let prefix = p.prefix();
    let ec2 = |kind: &str| format!("arn:aws:ec2:{region}:{account}:{kind}/*");
    let regional = json!({"StringEquals":{"aws:RequestedRegion":region}});
    let owned = json!({"StringEquals":{"aws:RequestedRegion":region,"ec2:ResourceTag/ows:deployment-id":p.deployment_id}});
    let creating = json!({"StringEquals":{"aws:RequestedRegion":region,"aws:RequestTag/ows:deployment-id":p.deployment_id}});
    let mut create = vec![];
    for (sid, action, kind, parents) in [
        ("Vpc", "ec2:CreateVpc", "vpc", vec![]),
        (
            "Gateway",
            "ec2:CreateInternetGateway",
            "internet-gateway",
            vec![],
        ),
        ("Address", "ec2:AllocateAddress", "elastic-ip", vec![]),
        ("Subnet", "ec2:CreateSubnet", "subnet", vec!["vpc"]),
        ("Routes", "ec2:CreateRouteTable", "route-table", vec!["vpc"]),
        (
            "SecurityGroup",
            "ec2:CreateSecurityGroup",
            "security-group",
            vec!["vpc"],
        ),
        (
            "Nat",
            "ec2:CreateNatGateway",
            "natgateway",
            vec!["subnet", "elastic-ip", "vpc"],
        ),
        (
            "LaunchTemplate",
            "ec2:CreateLaunchTemplate",
            "launch-template",
            vec![],
        ),
    ] {
        create.push(statement(
            &format!("Create{sid}"),
            &[action],
            vec![ec2(kind)],
            Some(creating.clone()),
        ));
        if !parents.is_empty() {
            create.push(statement(
                &format!("Parents{sid}"),
                &[action],
                parents.iter().map(|k| ec2(k)).collect(),
                Some(owned.clone()),
            ));
        }
    }
    create.push(statement("CreationTags",&["ec2:CreateTags"],["vpc","internet-gateway","elastic-ip","subnet","route-table","security-group","natgateway","launch-template"].iter().map(|k|ec2(k)).collect(),Some(json!({"StringEquals":{"aws:RequestTag/ows:deployment-id":p.deployment_id,"ec2:CreateAction":["CreateVpc","CreateInternetGateway","AllocateAddress","CreateSubnet","CreateRouteTable","CreateSecurityGroup","CreateNatGateway","CreateLaunchTemplate"]}}))));
    let mut network = vec![statement(
        "NetworkObservation",
        &[
            "ec2:DescribeVpcs",
            "ec2:DescribeVpcAttribute",
            "ec2:DescribeSubnets",
            "ec2:DescribeInternetGateways",
            "ec2:DescribeRouteTables",
            "ec2:DescribeAddresses",
            "ec2:DescribeNatGateways",
            "ec2:DescribeSecurityGroups",
            "ec2:DescribeSecurityGroupRules",
            "ec2:DescribeNetworkInterfaces",
            "ec2:DescribeLaunchTemplates",
            "ec2:DescribeLaunchTemplateVersions",
            "ec2:DescribeTags",
            "ec2:DescribeAvailabilityZones",
            "ec2:DescribeAccountAttributes",
            "ec2:DescribeKeyPairs",
            "ec2:DescribeNetworkAcls",
        ],
        vec!["*".into()],
        Some(regional.clone()),
    )];
    for (sid, actions, kinds) in [
        (
            "VpcLifecycle",
            vec!["ec2:ModifyVpcAttribute", "ec2:DeleteVpc"],
            vec!["vpc"],
        ),
        (
            "SubnetLifecycle",
            vec!["ec2:ModifySubnetAttribute", "ec2:DeleteSubnet"],
            vec!["subnet"],
        ),
        (
            "GatewayAttach",
            vec!["ec2:AttachInternetGateway", "ec2:DetachInternetGateway"],
            vec!["vpc", "internet-gateway"],
        ),
        (
            "GatewayDelete",
            vec!["ec2:DeleteInternetGateway"],
            vec!["internet-gateway"],
        ),
        (
            "RoutesLifecycle",
            vec![
                "ec2:CreateRoute",
                "ec2:ReplaceRoute",
                "ec2:DeleteRoute",
                "ec2:DeleteRouteTable",
            ],
            vec!["route-table"],
        ),
        (
            "RouteAssociations",
            vec![
                "ec2:AssociateRouteTable",
                "ec2:DisassociateRouteTable",
                "ec2:ReplaceRouteTableAssociation",
            ],
            vec!["route-table", "subnet"],
        ),
        (
            "AddressRelease",
            vec!["ec2:ReleaseAddress"],
            vec!["elastic-ip"],
        ),
        (
            "NatDelete",
            vec!["ec2:DeleteNatGateway"],
            vec!["natgateway"],
        ),
        (
            "SecurityGroupLifecycle",
            vec![
                "ec2:AuthorizeSecurityGroupIngress",
                "ec2:AuthorizeSecurityGroupEgress",
                "ec2:RevokeSecurityGroupIngress",
                "ec2:RevokeSecurityGroupEgress",
                "ec2:DeleteSecurityGroup",
            ],
            vec!["security-group"],
        ),
        (
            "LaunchTemplateLifecycle",
            vec![
                "ec2:CreateLaunchTemplateVersion",
                "ec2:ModifyLaunchTemplate",
                "ec2:DeleteLaunchTemplateVersions",
                "ec2:DeleteLaunchTemplate",
            ],
            vec!["launch-template"],
        ),
    ] {
        network.push(statement(
            sid,
            &actions,
            kinds.iter().map(|k| ec2(k)).collect(),
            Some(owned.clone()),
        ));
    }
    let tag_resources = [
        "vpc",
        "internet-gateway",
        "elastic-ip",
        "subnet",
        "route-table",
        "security-group",
        "natgateway",
        "launch-template",
    ]
    .iter()
    .map(|k| ec2(k))
    .collect::<Vec<_>>();
    network.push(statement("UpdateOwnedTags",&["ec2:CreateTags"],tag_resources.clone(),Some(json!({"StringEquals":{"ec2:ResourceTag/ows:deployment-id":p.deployment_id},"StringEqualsIfExists":{"aws:RequestTag/ows:deployment-id":p.deployment_id}}))));
    network.push(statement("RemoveOtherOwnedTags",&["ec2:DeleteTags"],tag_resources,Some(json!({"StringEquals":{"ec2:ResourceTag/ows:deployment-id":p.deployment_id},"ForAllValues:StringNotEquals":{"aws:TagKeys":["ows:deployment-id"]},"Null":{"aws:TagKeys":"false"}}))));
    let cluster = format!("arn:aws:eks:{region}:{account}:cluster/{prefix}");
    let eks_arn = |kind: &str| format!("arn:aws:eks:{region}:{account}:{kind}/{prefix}/*");
    let eks_resources = vec![
        cluster.clone(),
        eks_arn("nodegroup"),
        eks_arn("addon"),
        eks_arn("access-entry"),
        eks_arn("podidentityassociation"),
    ];
    let mut eks = vec![
        statement(
            "CreateTaggedPrivateCluster",
            &["eks:CreateCluster"],
            vec!["*".into()],
            Some(
                json!({"StringEquals":{"aws:RequestedRegion":region,"aws:RequestTag/ows:deployment-id":p.deployment_id,"eks:authenticationMode":"API"},"Bool":{"eks:endpointPublicAccess":"false","eks:endpointPrivateAccess":"true","eks:bootstrapClusterCreatorAdminPermissions":"false"}}),
            ),
        ),
        statement(
            "ClusterLifecycle",
            &[
                "eks:DescribeCluster",
                "eks:UpdateClusterVersion",
                "eks:DeleteCluster",
                "eks:DescribeUpdate",
                "eks:ListUpdates",
                "eks:CreateNodegroup",
                "eks:CreateAddon",
                "eks:CreateAccessEntry",
                "eks:CreatePodIdentityAssociation",
                "eks:ListNodegroups",
                "eks:ListAddons",
                "eks:ListAccessEntries",
                "eks:ListPodIdentityAssociations",
            ],
            vec![cluster.clone()],
            None,
        ),
        statement(
            "ChildrenLifecycle",
            &[
                "eks:DescribeNodegroup",
                "eks:UpdateNodegroupConfig",
                "eks:UpdateNodegroupVersion",
                "eks:DeleteNodegroup",
                "eks:DescribeAddon",
                "eks:UpdateAddon",
                "eks:DeleteAddon",
                "eks:DescribeAccessEntry",
                "eks:UpdateAccessEntry",
                "eks:DeleteAccessEntry",
                "eks:DescribePodIdentityAssociation",
                "eks:UpdatePodIdentityAssociation",
                "eks:DeletePodIdentityAssociation",
                "eks:ListAssociatedAccessPolicies",
                "eks:DescribeUpdate",
            ],
            eks_resources.clone(),
            None,
        ),
        statement(
            "PlatformAccess",
            &["eks:AssociateAccessPolicy", "eks:DisassociateAccessPolicy"],
            vec![eks_arn("access-entry")],
            Some(
                json!({"StringEquals":{"eks:policyArn":"arn:aws:eks::aws:cluster-access-policy/AmazonEKSClusterAdminPolicy"}}),
            ),
        ),
        statement(
            "EksTags",
            &[
                "eks:TagResource",
                "eks:UntagResource",
                "eks:ListTagsForResource",
            ],
            eks_resources,
            None,
        ),
    ];
    eks.push(statement(
        "AddonPodIdentityDependencies",
        &["eks:CreateAddon"],
        vec![eks_arn("podidentityassociation")],
        None,
    ));
    eks.push(statement("KeepClusterPrivate", &["eks:UpdateClusterConfig"], vec![cluster.clone()], Some(json!({"BoolIfExists":{"eks:endpointPublicAccess":"false","eks:endpointPrivateAccess":"true"}}))));
    for (sid, roles, services) in [
        (
            "PassClusterRole",
            vec!["cluster"],
            vec!["eks.amazonaws.com"],
        ),
        (
            "PassNodeRole",
            vec!["node"],
            vec!["eks.amazonaws.com", "ec2.amazonaws.com"],
        ),
        (
            "PassPodRoles",
            vec!["ebs", "artifacts"],
            vec!["pods.eks.amazonaws.com", "eks.amazonaws.com"],
        ),
    ] {
        eks.push(statement(
            sid,
            &["iam:PassRole"],
            roles.iter().map(|r| role_arn(p, r)).collect(),
            Some(json!({"StringEquals":{"iam:PassedToService":services}})),
        ));
    }
    eks.push(statement(
        "ReadExactPlatformRoles",
        &["iam:GetRole", "iam:ListAttachedRolePolicies"],
        ["cluster", "node", "ebs", "artifacts"]
            .iter()
            .map(|r| role_arn(p, r))
            .collect(),
        None,
    ));
    // EKS validates that its already-created node-group service-linked role exists
    // using the caller's GetRole authority. Preflight's operator check is not a
    // substitute for these exact executor reads. No SLR creation/modification.
    eks.push(statement(
        "ReadRequiredServiceLinkedRoles",
        &["iam:GetRole", "iam:ListAttachedRolePolicies"],
        [
            ("eks.amazonaws.com", "AWSServiceRoleForAmazonEKS"),
            (
                "eks-nodegroup.amazonaws.com",
                "AWSServiceRoleForAmazonEKSNodegroup",
            ),
            ("autoscaling.amazonaws.com", "AWSServiceRoleForAutoScaling"),
            ("rds.amazonaws.com", "AWSServiceRoleForRDS"),
        ]
        .iter()
        .map(|(service, name)| {
            format!("arn:aws:iam::{account}:role/aws-service-role/{service}/{name}")
        })
        .collect(),
        None,
    ));
    let db = format!("arn:aws:rds:{region}:{account}:db:{prefix}");
    let dbsub = format!("arn:aws:rds:{region}:{account}:subgrp:{prefix}");
    let dbparam = format!("arn:aws:rds:{region}:{account}:pg:{prefix}");
    let secret =
        format!("arn:aws:secretsmanager:{region}:{account}:secret:{prefix}-database-??????");
    let bucket_arn = format!("arn:aws:s3:::{}", bucket(p));
    let data = vec![
        statement(
            "DatabaseLifecycle",
            &[
                "rds:CreateDBInstance",
                "rds:ModifyDBInstance",
                "rds:DeleteDBInstance",
                "rds:DescribeDBInstances",
            ],
            vec![db.clone(), dbsub.clone(), dbparam.clone()],
            None,
        ),
        statement(
            "DatabaseSubnets",
            &[
                "rds:CreateDBSubnetGroup",
                "rds:ModifyDBSubnetGroup",
                "rds:DeleteDBSubnetGroup",
                "rds:DescribeDBSubnetGroups",
            ],
            vec![dbsub.clone()],
            None,
        ),
        statement(
            "ReadDatabaseEngineDefaults",
            &[
                "rds:DescribeEngineDefaultParameters",
                "rds:DescribeDBEngineVersions",
            ],
            vec!["*".into()],
            Some(regional.clone()),
        ),
        statement(
            "DatabaseParameters",
            &[
                "rds:CreateDBParameterGroup",
                "rds:ModifyDBParameterGroup",
                "rds:ResetDBParameterGroup",
                "rds:DeleteDBParameterGroup",
                "rds:DescribeDBParameterGroups",
                "rds:DescribeDBParameters",
            ],
            vec![dbparam.clone()],
            None,
        ),
        statement(
            "DatabaseTags",
            &[
                "rds:AddTagsToResource",
                "rds:RemoveTagsFromResource",
                "rds:ListTagsForResource",
            ],
            vec![db, dbsub, dbparam],
            None,
        ),
        statement(
            "NamedDatabaseSecret",
            &[
                "secretsmanager:CreateSecret",
                "secretsmanager:DescribeSecret",
                "secretsmanager:UpdateSecret",
                "secretsmanager:PutSecretValue",
                "secretsmanager:GetSecretValue",
                "secretsmanager:DeleteSecret",
                "secretsmanager:TagResource",
                "secretsmanager:UntagResource",
            ],
            vec![secret],
            None,
        ),
        statement(
            "GenerateDatabasePassword",
            &["secretsmanager:GetRandomPassword"],
            vec!["*".into()],
            Some(regional.clone()),
        ),
        statement(
            "DescribeEncryptionKeys",
            &["kms:DescribeKey"],
            vec![format!("arn:aws:kms:{region}:{account}:key/*")],
            None,
        ),
        statement(
            "ArtifactBucketLifecycle",
            &[
                "s3:CreateBucket",
                "s3:DeleteBucket",
                "s3:GetBucketLocation",
                "s3:GetAccelerateConfiguration",
                "s3:GetAnalyticsConfiguration",
                "s3:GetBucketCORS",
                "s3:GetInventoryConfiguration",
                "s3:GetBucketLogging",
                "s3:GetMetricsConfiguration",
                "s3:GetBucketNotification",
                "s3:GetBucketVersioning",
                "s3:GetReplicationConfiguration",
                "s3:GetBucketWebsite",
                "s3:GetBucketObjectLockConfiguration",
                "s3:GetBucketAcl",
                "s3:GetIntelligentTieringConfiguration",
                "s3:GetBucketMetadataTableConfiguration",
                "s3:ListBucket",
                "s3:GetBucketPolicy",
                "s3:PutBucketPolicy",
                "s3:DeleteBucketPolicy",
                "s3:GetBucketTagging",
                "s3:PutBucketTagging",
                "s3:GetBucketPublicAccessBlock",
                "s3:PutBucketPublicAccessBlock",
                "s3:GetEncryptionConfiguration",
                "s3:PutEncryptionConfiguration",
                "s3:GetBucketOwnershipControls",
                "s3:PutBucketOwnershipControls",
                "s3:GetLifecycleConfiguration",
                "s3:PutLifecycleConfiguration",
            ],
            vec![bucket_arn.clone()],
            None,
        ),
        statement(
            "ImageRepositories",
            &[
                "ecr:CreateRepository",
                "ecr:DescribeRepositories",
                "ecr:GetLifecyclePolicy",
                "ecr:GetRepositoryPolicy",
                "ecr:DeleteRepository",
                "ecr:TagResource",
                "ecr:UntagResource",
                "ecr:ListTagsForResource",
                "ecr:PutImageTagMutability",
                "ecr:PutImageScanningConfiguration",
            ],
            ["harness", "runner", "service-ui"]
                .iter()
                .map(|s| format!("arn:aws:ecr:{region}:{account}:repository/{prefix}/{s}"))
                .collect(),
            None,
        ),
    ];
    let lambda = format!("arn:aws:lambda:{region}:{account}:function:{prefix}-cleanup");
    let rule = format!("arn:aws:events:{region}:{account}:rule/{prefix}-cleanup");
    let log = format!("arn:aws:logs:{region}:{account}:log-group:/aws/lambda/{prefix}-cleanup");
    let guard_permissions = vec![
        statement(
            "GuardControlTable",
            &[
                "dynamodb:CreateTable",
                "dynamodb:DescribeTable",
                "dynamodb:DeleteTable",
                "dynamodb:UpdateTable",
                "dynamodb:TagResource",
                "dynamodb:UntagResource",
                "dynamodb:ListTagsOfResource",
            ],
            vec![format!(
                "arn:aws:dynamodb:{region}:{account}:table/{prefix}-control"
            )],
            None,
        ),
        statement(
            "GuardFunction",
            &[
                "lambda:CreateFunction",
                "lambda:GetFunction",
                "lambda:GetFunctionConfiguration",
                "lambda:UpdateFunctionCode",
                "lambda:UpdateFunctionConfiguration",
                "lambda:DeleteFunction",
                "lambda:PutFunctionConcurrency",
                "lambda:DeleteFunctionConcurrency",
                "lambda:GetFunctionConcurrency",
                "lambda:AddPermission",
                "lambda:RemovePermission",
                "lambda:GetPolicy",
                "lambda:TagResource",
                "lambda:UntagResource",
                "lambda:ListTags",
            ],
            vec![lambda],
            None,
        ),
        statement(
            "PassGuardRole",
            &["iam:PassRole"],
            vec![role_arn(p, "cleanup")],
            Some(json!({"StringEquals":{"iam:PassedToService":"lambda.amazonaws.com"}})),
        ),
        statement(
            "PinnedGuardCode",
            &["s3:GetObjectVersion"],
            vec![format!(
                "arn:aws:s3:::{}/{}",
                i.guard_code.bucket, i.guard_code.key
            )],
            Some(json!({"StringEquals":{"s3:VersionId":i.guard_code.version_id}})),
        ),
        statement(
            "GuardSchedule",
            &[
                "events:PutRule",
                "events:DescribeRule",
                "events:DeleteRule",
                "events:PutTargets",
                "events:RemoveTargets",
                "events:ListTargetsByRule",
                "events:TagResource",
                "events:UntagResource",
                "events:ListTagsForResource",
            ],
            vec![rule],
            None,
        ),
        statement(
            "GuardLogs",
            &[
                "logs:CreateLogGroup",
                "logs:DeleteLogGroup",
                "logs:PutRetentionPolicy",
                "logs:DeleteRetentionPolicy",
                "logs:TagResource",
                "logs:UntagResource",
                "logs:ListTagsForResource",
            ],
            vec![log.clone(), format!("{log}:*")],
            None,
        ),
        statement(
            "ObserveLogGroups",
            &["logs:DescribeLogGroups"],
            vec!["*".into()],
            Some(regional.clone()),
        ),
    ];
    let cleanup = policy(json!([
        statement(
            "GuardControlRecord",
            &["dynamodb:GetItem", "dynamodb:PutItem"],
            vec![format!(
                "arn:aws:dynamodb:{region}:{account}:table/{prefix}-control"
            )],
            Some(
                json!({"ForAllValues:StringEquals":{"dynamodb:LeadingKeys":[p.deployment_id]},"Null":{"dynamodb:LeadingKeys":"false"}})
            )
        ),
        statement(
            "ObserveOwnedInfraStack",
            &[
                "cloudformation:DescribeStacks",
                "cloudformation:DescribeStackEvents",
                "cloudformation:ListStackResources"
            ],
            vec![format!(
                "arn:aws:cloudformation:{region}:{account}:stack/{prefix}-infra/*"
            )],
            None
        ),
        statement(
            "DeleteOwnedInfraStack",
            &["cloudformation:DeleteStack"],
            vec![format!(
                "arn:aws:cloudformation:{region}:{account}:stack/{prefix}-infra/*"
            )],
            Some(json!({"StringEquals":{"cloudformation:RoleArn":role_arn(p,"executor")}}))
        ),
        statement(
            "PassDeletionExecutor",
            &["iam:PassRole"],
            vec![role_arn(p, "executor")],
            Some(json!({"StringEquals":{"iam:PassedToService":"cloudformation.amazonaws.com"}}))
        ),
        statement(
            "CheckBucketOwnership",
            &[
                "s3:GetBucketTagging",
                "s3:GetBucketVersioning",
                "s3:ListBucket",
                "s3:ListBucketMultipartUploads"
            ],
            vec![bucket_arn.clone()],
            None
        ),
        statement(
            "DeleteOwnedObjects",
            &[
                "s3:DeleteObject",
                "s3:AbortMultipartUpload",
                "s3:ListMultipartUploadParts"
            ],
            vec![format!("{bucket_arn}/{}/*", p.deployment_id)],
            None
        ),
        statement(
            "ObserveVolumes",
            &["ec2:DescribeVolumes"],
            vec!["*".into()],
            Some(regional)
        ),
        statement(
            "DeleteOwnedVolumes",
            &["ec2:DeleteVolume"],
            vec![ec2("volume")],
            Some(owned)
        ),
        statement(
            "GuardActivity",
            &["logs:CreateLogStream", "logs:PutLogEvents"],
            vec![format!("{log}:log-stream:*")],
            None
        ),
    ]));
    let mut execution = BTreeMap::from([
        ("NetworkCreate".into(), policy(json!(create))),
        ("NetworkManage".into(), policy(json!(network))),
        ("Eks".into(), policy(json!(eks))),
        ("Nodes".into(), nodes::permissions(p)),
        ("Data".into(), policy(json!(data))),
        ("Guard".into(), policy(json!(guard_permissions))),
    ]);
    if i.operator_access.is_some() {
        execution.insert("Access".into(), access::permissions(p));
    }
    let mut coverage = BTreeMap::new();
    for (phase, t) in [("infrastructure", infra), ("guard", guard)] {
        for (logical, r) in t["Resources"]
            .as_object()
            .context("Template resources missing")?
        {
            let kind = r["Type"].as_str().context("Resource type missing")?;
            let domains = match kind {
                "AWS::EC2::VPC"
                | "AWS::EC2::InternetGateway"
                | "AWS::EC2::Subnet"
                | "AWS::EC2::RouteTable"
                | "AWS::EC2::EIP"
                | "AWS::EC2::NatGateway"
                | "AWS::EC2::SecurityGroupIngress"
                | "AWS::EC2::SecurityGroup"
                | "AWS::EC2::LaunchTemplate" => vec!["NetworkCreate", "NetworkManage"],
                "AWS::EC2::VPCGatewayAttachment"
                | "AWS::EC2::Route"
                | "AWS::EC2::SubnetRouteTableAssociation" => vec!["NetworkManage"],
                "AWS::EC2::Instance" => vec!["Access"],
                "AWS::EKS::Nodegroup" => vec!["Eks", "Nodes"],
                "AWS::EKS::Cluster"
                | "AWS::EKS::Addon"
                | "AWS::EKS::AccessEntry"
                | "AWS::EKS::PodIdentityAssociation" => vec!["Eks"],
                "AWS::RDS::DBInstance"
                | "AWS::RDS::DBSubnetGroup"
                | "AWS::RDS::DBParameterGroup"
                | "AWS::SecretsManager::Secret"
                | "AWS::SecretsManager::SecretTargetAttachment"
                | "AWS::S3::Bucket"
                | "AWS::S3::BucketPolicy"
                | "AWS::ECR::Repository" => vec!["Data"],
                "AWS::DynamoDB::Table"
                | "AWS::Lambda::Function"
                | "AWS::Lambda::Permission"
                | "AWS::Events::Rule"
                | "AWS::Logs::LogGroup" => vec!["Guard"],
                _ => bail!("Resource has no reviewed permission domain: {kind}"),
            };
            coverage.insert(
                format!("{phase}/{logical}"),
                json!({"type":kind,"domains":domains}),
            );
        }
    }
    let review = json!({"schemaVersion":1,"cloudValidated":false,"coverage":coverage,
        "broadGrants":[
            {"statement":"NetworkObservation","reason":"EC2 Describe APIs do not support individual resource scoping; regional metadata only"},
            {"statement":"CreateTaggedPrivateCluster","reason":"EKS CreateCluster requires Resource *; request ownership tag and region/private-endpoint conditions constrain creation but do not cap cost or count"},
            {"statement":"RegistryLogin (setup)","reason":"ECR GetAuthorizationToken requires Resource *; requested region/expiry constrain login; actual image writes are restricted to three exact repositories"},
            {"statement":"ReadDatabaseEngineDefaults","reason":"RDS handlers read built-in engine-family defaults and engine-version metadata; this catalog API has no individual-resource authorization and is region constrained, with no database data or secret reads"},
            {"statement":"GenerateDatabasePassword","reason":"GetRandomPassword has no resource; returns generated randomness, not existing secret data"},
            {"statement":"ObserveLogGroups","reason":"DescribeLogGroups has no individual-resource authorization; regional metadata"},
            {"statement":"DescribeEncryptionKeys","reason":"Default AWS-managed key IDs resolve online; DescribeKey only within this account/region, no decrypt/grant/write"},
            {"statement":"Worker launch dependencies","reason":"Tagged EKS launch templates require caller RunInstances/CreateTags. Regional image/interface ARNs are permitted only through a launch template that separately must have this deployment ownership tag; instance type, subnet, cluster security group and new instance/volume tags are independently constrained. EKS resolves the pinned recommended release AMI; preflight checks it, not this IAM wildcard."},
            {"statement":"EC2 create/manage","reason":"Resource IDs are not known offline; resource-type/account/region ARN scopes plus creation/ownership tags. Parent resource authorizations are separate"},
            {"statement":"AWS managed platform policies","reason":"Explicit AWS-managed cluster/node/CSI grants are attached only by customer bootstrap; review their upstream permissions and node metadata isolation"}
        ],"notGranted":["IAM identity/policy mutation by executor","arbitrary PassRole","model secret reads","unrelated object reads","account-wide AdministratorAccess","service-linked role creation"],
        "remainingVerification":["AWS service IAM simulation and live resource handlers","creation/rollback/delete dependency permissions","SCP and permission boundaries","guard package digest and behavior","private control-plane connectivity","post-install network enforcement and volume ownership tagging"]});
    Ok(Policies {
        execution,
        cleanup,
        review,
    })
}