Skip to content

LearnCloud

AWS IAM privilege escalation checks

Brief

Most IAM escalation paths come down to a handful of permissions that let a principal rewrite its own permissions or run code as something with more. Every check here is a read, and where the client wants a demonstration the proof is one call that is undone in the same session.

Track
Cloud
Stage
Escalation
Reviewed
On this page
  1. Check first
  2. AWS
  3. The defender sees
  4. Done when
  5. Not covered
  6. Tools
  7. Related research
  8. Where this page fits
  9. Reviewed

All commands

AWS book Chapter 5 of AWS Identity and Secrets, "The four AWS IAM path families", goes further than this page.

Situation
One IAM principal's keys: an access key found during another test, or a user the client created for this one, with rules of engagement that say how far we may follow it. The checks are read-only. The proof steps change something briefly, only with written permission for that specific change, on resources named for the test, and are reversed before we move on. Everything happens in the accounts the scope letter names.
Goal
A list of the escalation paths this principal holds, each with the policy statement that grants it and either the proof or the reason no proof was needed.
Outputs
Captured on 8 Nov 2026 (UTC) in the Atarus lab AWS Organization from the Atarus Bench edition 2026.11-cloud-0.3, AWS CLI 2.39.3, with account ids and other identifiers replaced by stable placeholders. The key is the lab's ci-deploy user, and every proof ran in the lab and was reversed in the same run: the policy version and the function deleted, the role session left to expire. The default version's document was read with the same key in a second run that day.

Check first

  • The identity, its policies, groups and permissions boundary, from the first hour. Every check below reads those documents.
  • Whether the account belongs to an organization; the simulator evaluates service control policies but not resource policies it is not given.
  • Every role in the account and what each one trusts.
  • Whether IAM Access Analyzer has an analyzer here, so the client's findings can be set beside ours.
  • Where CloudTrail is delivered, so each proof can be matched to its event.

Steps

AWS

Can this principal rewrite its own permissions through policy versions?

aws iam list-attached-user-policies --user-name ci-deploy --query 'AttachedPolicies[].PolicyArn' --output text
aws iam list-policy-versions --policy-arn arn:aws:iam::111122223333:policy/ci-deploy-policy \
  --query 'Versions[].[VersionId,IsDefaultVersion,CreateDate]' --output text
aws iam get-policy-version --policy-arn arn:aws:iam::111122223333:policy/ci-deploy-policy --version-id v1 \
  --query 'PolicyVersion.Document.Statement[].[Effect,Action]'
aws iam simulate-principal-policy --policy-source-arn arn:aws:iam::111122223333:user/ci-deploy \
  --action-names iam:CreatePolicyVersion iam:SetDefaultPolicyVersion iam:AttachUserPolicy iam:PutUserPolicy iam:CreateAccessKey \
  --query 'EvaluationResults[].[EvalActionName,EvalDecision]' --output text

Expected output

arn:aws:iam::111122223333:policy/ci-deploy-policy	arn:aws:iam::aws:policy/ReadOnlyAccess
v3	True	2026-11-08T04:01:02+00:00
v2	False	2026-11-08T04:01:01+00:00
v1	False	2026-11-08T04:01:00+00:00
[
    [
        "Allow",
        "*"   # <- an earlier version that allows everything is still one call away
    ]
]
iam:CreatePolicyVersion	implicitDeny   # <- not a verdict: no resource was named
iam:SetDefaultPolicyVersion	implicitDeny
iam:AttachUserPolicy	implicitDeny
iam:PutUserPolicy	implicitDeny
iam:CreateAccessKey	implicitDeny

A customer managed policy keeps up to five versions and any of them can be made the default. A principal that can create a version, or flip the default back to an old permissive one, is whatever that document says; iam:CreateAccessKey on other users is the sideways form of the same path. The simulation printed implicitDeny on all five. For three of them the reason is the unnamed resource: the document below grants iam:CreatePolicyVersion and iam:SetDefaultPolicyVersion on named policies and iam:CreateAccessKey on the key's own user, and none of those matches * (the rule is on the policy evaluation page). The other two, iam:AttachUserPolicy and iam:PutUserPolicy, are granted nowhere in it. The default version of the attached customer managed policy settles the first three:

aws iam get-policy --policy-arn arn:aws:iam::111122223333:policy/ci-deploy-policy --query 'Policy.DefaultVersionId' --output text
aws iam get-policy-version --policy-arn arn:aws:iam::111122223333:policy/ci-deploy-policy --version-id v3 --query 'PolicyVersion.Document' --output json

Expected output

v3
{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "PolicyVersions",
            "Effect": "Allow",
            "Action": [
                "iam:CreatePolicyVersion",
                "iam:SetDefaultPolicyVersion",
                "iam:DeletePolicyVersion"
            ],
            "Resource": [
                "arn:aws:iam::111122223333:policy/ci-deploy-policy",   # <- its own policy: this key can make v1 the default
                "arn:aws:iam::111122223333:policy/atarus-test-policy"
            ]
        },
        {
            "Sid": "OwnKeys",
            "Effect": "Allow",
            "Action": "iam:CreateAccessKey",
            "Resource": "arn:aws:iam::111122223333:user/${aws:username}"   # <- keys for its own user only, not for other users
        },
        {
            "Sid": "PassAppRole",
            "Effect": "Allow",
            "Action": "iam:PassRole",
            "Resource": "arn:aws:iam::111122223333:role/app-deploy-role"
        },
        {
            "Sid": "Functions",
            "Effect": "Allow",
            "Action": [
                "lambda:CreateFunction",
                "lambda:InvokeFunction",
                "lambda:UpdateFunctionCode",
                "lambda:DeleteFunction"
            ],
            "Resource": "*"
        },
        {
            "Sid": "AssumeOps",
            "Effect": "Allow",
            "Action": "sts:AssumeRole",
            "Resource": "arn:aws:iam::111122223333:role/ops-*"
        },
        {
            "Sid": "RunCommand",
            "Effect": "Allow",
            "Action": "ssm:SendCommand",
            "Resource": [
                "arn:aws:ec2:us-east-1:111122223333:instance/*",   # <- named resources, which a simulation against * never matches
                "arn:aws:ssm:us-east-1::document/AWS-RunShellScript"
            ]
        },
        {
            "Sid": "TagTargets",
            "Effect": "Allow",
            "Action": [
                "ec2:CreateTags",
                "ec2:DeleteTags"
            ],
            "Resource": "arn:aws:ec2:us-east-1:111122223333:instance/*",
            "Condition": {
                "StringEquals": {
                    "aws:ResourceTag/app": "webhooks"
                }
            }
        },
        {
            "Sid": "ExportsDelete",
            "Effect": "Allow",
            "Action": "s3:DeleteObject",
            "Resource": "arn:aws:s3:::example-exports/*"
        },
        {
            "Sid": "ImpactRead",
            "Effect": "Allow",
            "Action": "kms:Decrypt",
            "Resource": "arn:aws:kms:us-east-1:111122223333:key/*"
        }
    ]
}

PolicyVersions grants iam:CreatePolicyVersion and iam:SetDefaultPolicyVersion on ci-deploy-policy itself, so this key can make v1, the version that allows everything, the default of its own policy. The path is present, and that statement with the old version is the finding. OwnKeys lets the key create access keys for its own user only, which is not the sideways path. For iam:AttachUserPolicy and iam:PutUserPolicy, ReadOnlyAccess grants reads alone, but the group's policies and any inline user policy were not printed here, so those two are marked absent only once they are read, or once a simulation that names the resources agrees. Four more statements are what the next three steps test: PassAppRole and Functions for PassRole, AssumeOps for the roles and RunCommand for the instance. The last three reach past deployment. TagTargets lets the key tag or untag instances labelled app=webhooks, and ExportsDelete lets it delete objects in the exports bucket; both go in the report with the key's write reach, which the impact checks show without using. ImpactRead, kms:Decrypt on every key in the account, is a finding in its own right: any key whose policy delegates to IAM decrypts for this CI key. When the client wants a demonstration, the least-impact proof is a new version of a test policy attached to nothing, identical to the current document, not set as default, deleted straight after; unchanged.json holds the test policy's current document.

aws iam create-policy-version --policy-arn arn:aws:iam::111122223333:policy/atarus-test-policy \
  --policy-document file://unchanged.json --no-set-as-default
aws iam delete-policy-version --policy-arn arn:aws:iam::111122223333:policy/atarus-test-policy --version-id v2

Expected output

{
    "PolicyVersion": {
        "VersionId": "v2",   # <- the proof: a version was written by this principal, then removed
        "IsDefaultVersion": false,
        "CreateDate": "2026-11-08T04:15:51+00:00"
    }
}

The delete prints nothing when it succeeds; listing the test policy's versions afterwards shows v1 alone.

Negative result. implicitDeny on all five actions in a simulation that names the attached policies and the account's users as resources, or no statement granting them on those resources in the attached managed policies' default versions, the group's policies or any inline user policy, and one version on every policy attached to the principal.

Fix. Deny the policy-changing IAM actions to everyone but the platform team's role with a service control policy conditioned on aws:PrincipalARN. Require a permissions boundary on anything that creates or changes principals through the iam:PermissionsBoundary condition key. Delete non-default versions when a policy is tightened, and read the Access Analyzer UnusedPermission findings, which name actions this principal never uses.

Can it pass a role to Lambda or EC2 and run code as that role?

aws iam list-roles --query 'Roles[].[RoleName,Arn]' --output text
aws iam get-role --role-name app-deploy-role --query 'Role.AssumeRolePolicyDocument.Statement[].Principal'
aws iam list-attached-role-policies --role-name app-deploy-role --query 'AttachedPolicies[].PolicyName' --output text
aws iam simulate-principal-policy --policy-source-arn arn:aws:iam::111122223333:user/ci-deploy \
  --action-names iam:PassRole --resource-arns arn:aws:iam::111122223333:role/app-deploy-role \
  --query 'EvaluationResults[].[EvalActionName,EvalDecision]' --output text
aws iam simulate-principal-policy --policy-source-arn arn:aws:iam::111122223333:user/ci-deploy \
  --action-names lambda:CreateFunction lambda:InvokeFunction lambda:UpdateFunctionCode ec2:RunInstances \
  --query 'EvaluationResults[].[EvalActionName,EvalDecision]' --output text

Expected output

admin	arn:aws:iam::111122223333:role/admin
app-deploy-role	arn:aws:iam::111122223333:role/app-deploy-role
app-runtime	arn:aws:iam::111122223333:role/app-runtime
atarus-review	arn:aws:iam::111122223333:role/atarus-review
AWSReservedSSO_AtarusOperator_aaaa000000000001	arn:aws:iam::111122223333:role/aws-reserved/sso.amazonaws.com/AWSReservedSSO_AtarusOperator_aaaa000000000001
AWSServiceRoleForAccessAnalyzer	arn:aws:iam::111122223333:role/aws-service-role/access-analyzer.amazonaws.com/AWSServiceRoleForAccessAnalyzer
AWSServiceRoleForCloudTrail	arn:aws:iam::111122223333:role/aws-service-role/cloudtrail.amazonaws.com/AWSServiceRoleForCloudTrail
AWSServiceRoleForOrganizations	arn:aws:iam::111122223333:role/aws-service-role/organizations.amazonaws.com/AWSServiceRoleForOrganizations
AWSServiceRoleForSSO	arn:aws:iam::111122223333:role/aws-service-role/sso.amazonaws.com/AWSServiceRoleForSSO
AWSServiceRoleForSupport	arn:aws:iam::111122223333:role/aws-service-role/support.amazonaws.com/AWSServiceRoleForSupport
AWSServiceRoleForTrustedAdvisor	arn:aws:iam::111122223333:role/aws-service-role/trustedadvisor.amazonaws.com/AWSServiceRoleForTrustedAdvisor
ci-deploy	arn:aws:iam::111122223333:role/ci-deploy
lambda-basic	arn:aws:iam::111122223333:role/lambda-basic
legacy-sync	arn:aws:iam::111122223333:role/legacy-sync
ops-audit	arn:aws:iam::111122223333:role/ops-audit
ops-break-glass	arn:aws:iam::111122223333:role/ops-break-glass
orders-api-execution	arn:aws:iam::111122223333:role/orders-api-execution
OrganizationAccountAccessRole	arn:aws:iam::111122223333:role/OrganizationAccountAccessRole
prod-api-role	arn:aws:iam::111122223333:role/prod-api-role
reporting-batch	arn:aws:iam::111122223333:role/reporting-batch
vendor-monitoring	arn:aws:iam::111122223333:role/vendor-monitoring
[
    {
        "Service": "lambda.amazonaws.com"
    }
]
AdministratorAccess   # <- a role Lambda may assume, and it is an administrator
iam:PassRole	allowed   # <- allowed once the role is named in --resource-arns
lambda:CreateFunction	allowed
lambda:InvokeFunction	allowed
lambda:UpdateFunctionCode	allowed   # <- also a way into existing functions that already hold a role
ec2:RunInstances	implicitDeny

iam:PassRole is a permission, not an API call: the service checks it when a role is handed over at creation, and code in the function or on the instance then runs with that role's credentials. A principal that can create compute and pass an administrator role is an administrator, and lambda:UpdateFunctionCode on a function that already holds a strong role is the same path with no PassRole at all. The role list is where the candidates come from: every role a service trusts is one this principal might pass. Service-linked roles (AWSServiceRoleFor...) and the Identity Center role (AWSReservedSSO_...) trust only their own service or sign-in, so nothing this key creates could use them; each other role's trust is read with get-role, and app-deploy-role, which trusts Lambda and holds AdministratorAccess, is the one followed here. Named in --resource-arns, app-deploy-role comes back allowed; the first hour simulation of the same key, with no resource named, printed implicitDeny for the same action. We prefer the Lambda proof to RunInstances because it costs nothing, touches no network and leaves nothing behind once deleted: one function whose handler returns sts get-caller-identity, one invocation, one deletion, with written permission.

aws lambda create-function --function-name atarus-passrole-proof --runtime python3.12 \
  --role arn:aws:iam::111122223333:role/app-deploy-role --handler proof.handler --zip-file fileb://proof.zip
aws lambda wait function-active-v2 --function-name atarus-passrole-proof
aws lambda invoke --function-name atarus-passrole-proof response.json && cat response.json
aws lambda delete-function --function-name atarus-passrole-proof

Expected output

{
    "FunctionName": "atarus-passrole-proof",
    "FunctionArn": "arn:aws:lambda:us-east-1:111122223333:function:atarus-passrole-proof",
    "Runtime": "python3.12",
    "Role": "arn:aws:iam::111122223333:role/app-deploy-role",
    "Handler": "proof.handler",
    "CodeSize": 216,
    "Description": "",
    "Timeout": 3,
    "MemorySize": 128,
    "LastModified": "2026-11-08T04:15:56.712+0000",
    "CodeSha256": "SLHaH2cCTf/rzK+QxpyldxxADY0U4wnVZmGyWNlVgrA=",
    "Version": "$LATEST",
    "TracingConfig": {
        "Mode": "PassThrough"
    },
    "RevisionId": "00000000-0000-4000-8000-aaaaaaaa0001",
    "State": "Pending",   # <- not ready yet, which is why the wait comes next
    "StateReason": "The function is being created.",
    "StateReasonCode": "Creating",
    "PackageType": "Zip",
    "Architectures": [
        "x86_64"
    ],
    "EphemeralStorage": {
        "Size": 512
    },
    "SnapStart": {
        "ApplyOn": "None",
        "OptimizationStatus": "Off"
    },
    "RuntimeVersionConfig": {
        "RuntimeVersionArn": "arn:aws:lambda:us-east-1::runtime:a8b19198a828662ade07d066a1dce047429a5869166346747ab7d57435583a29"
    },
    "LoggingConfig": {
        "LogFormat": "Text",
        "LogGroup": "/aws/lambda/atarus-passrole-proof"
    }
}
{
    "StatusCode": 200,
    "ExecutedVersion": "$LATEST"
}
"arn:aws:sts::111122223333:assumed-role/app-deploy-role/atarus-passrole-proof"   # <- our code ran as the administrator role
{
    "StatusCode": 204   # <- the function is deleted
}

create-function answers with the new function's configuration in state Pending, the wait returns silently once it is active, the invocation prints its status and then the handler's answer, and the deletion answers 204.

Negative result. iam:PassRole denied on every role named in --resource-arns, or allowed only on roles trusted by services this principal cannot create resources in, and no UpdateFunctionCode on functions whose role is stronger than the principal's own.

Fix. Scope iam:PassRole to named roles and add the iam:PassedToService condition so a role meant for Lambda cannot go to EC2. Give roles trusted by lambda.amazonaws.com only what the function uses, scope lambda:UpdateFunctionCode to a pipeline's own functions, and act on the UnusedIAMRole findings: a role nobody uses is a role nobody watches.

Which roles can it assume, and what does each trust policy say?

aws iam list-roles \
  --query "Roles[?AssumeRolePolicyDocument.Statement[?Principal.AWS]].[RoleName,AssumeRolePolicyDocument.Statement[].Principal.AWS]"
aws iam simulate-principal-policy --policy-source-arn arn:aws:iam::111122223333:user/ci-deploy \
  --action-names sts:AssumeRole --resource-arns arn:aws:iam::111122223333:role/ops-break-glass \
  --query 'EvaluationResults[].[EvalActionName,EvalDecision]' --output text

Expected output

[
    [
        "admin",
        [
            "arn:aws:iam::111122223333:root"
        ]
    ],
    [
        "atarus-review",
        [
            "arn:aws:iam::111122223333:root"
        ]
    ],
    [
        "ci-deploy",
        [
            "arn:aws:iam::111122223333:root"
        ]
    ],
    [
        "legacy-sync",
        [
            "AROA0000000001EXAMPLE"   # <- a unique id where an ARN was: the role it trusted was deleted
        ]
    ],
    [
        "ops-audit",
        [
            "*"   # <- every AWS account, unless a condition this query does not print narrows it
        ]
    ],
    [
        "ops-break-glass",
        [
            "arn:aws:iam::111122223333:root"   # <- any principal in the account that is allowed sts:AssumeRole
        ]
    ],
    [
        "OrganizationAccountAccessRole",
        [
            "arn:aws:iam::123456789012:root"
        ]
    ],
    [
        "vendor-monitoring",
        [
            "arn:aws:iam::444455556666:root"   # <- another account: look for an ExternalId condition
        ]
    ]
]
sts:AssumeRole	allowed

A trust policy that names the account root defers to identity policies: anyone in the account allowed sts:AssumeRole on that role gets it. Four roles here do that, and the simulation shows this key's own policy reaches ops-break-glass. A principal of * with no condition is open to every AWS account; the query prints principals and not conditions, so the ops-audit trust is read in full with get-role before it is called open. A trust for another account's root without sts:ExternalId is the confused deputy problem our third-party trust piece describes: vendor-monitoring is the one to read. Two trusts are expected and noted rather than reported: atarus-review is the review role the lab made for the test, and OrganizationAccountAccessRole trusts the management account because Organizations creates it that way, so its reach is the management account's, which the SCP review covers. A unique id such as AROA... in place of an ARN means the principal the trust named was deleted; the trust matches nothing now, and a new role with the old name would not match it either. The proof is read-only and expires on its own: assume the role, print the session ARN and the expiry, never the keys.

aws sts assume-role --role-arn arn:aws:iam::111122223333:role/ops-break-glass --role-session-name atarus-test \
  --query '{session:AssumedRoleUser.Arn,expires:Credentials.Expiration}'

Expected output

{
    "session": "arn:aws:sts::111122223333:assumed-role/ops-break-glass/atarus-test",   # <- assumed; the credentials are not printed
    "expires": "2026-11-08T05:16:05+00:00"
}

Negative result. Apart from the review role made for the test and the role Organizations creates, no role trusts the account root or *, sts:AssumeRole is denied on every role we test, and every other cross-account trust carries an sts:ExternalId or aws:PrincipalOrgID condition.

Fix. Trust named principals, not the account. Use aws:PrincipalOrgID inside the organization, sts:ExternalId for vendors and sts:SourceIdentity so the person behind a session is in CloudTrail. Access Analyzer ExternalAccess findings list every role assumable from outside the zone of trust.

Can it reach an instance profile's role through EC2 or SSM?

aws ec2 describe-instances \
  --query 'Reservations[].Instances[].[InstanceId,IamInstanceProfile.Arn,MetadataOptions.HttpTokens]' --output text
aws iam get-instance-profile --instance-profile-name prod-api-profile --query 'InstanceProfile.Roles[].RoleName' --output text
aws iam simulate-principal-policy --policy-source-arn arn:aws:iam::111122223333:user/ci-deploy \
  --action-names ssm:SendCommand ssm:StartSession ec2-instance-connect:SendSSHPublicKey ec2:ModifyInstanceAttribute ec2:AssociateIamInstanceProfile \
  --query 'EvaluationResults[].[EvalActionName,EvalDecision]' --output text

Expected output

i-0abc1234def567890	arn:aws:iam::111122223333:instance-profile/prod-api-profile	optional   # <- optional: the metadata service answers here without a token
i-0aaaa000000000001	None	required
prod-api-role
ssm:SendCommand	implicitDeny   # <- not a verdict, for the reason the policy-version step gave
ssm:StartSession	implicitDeny
ec2-instance-connect:SendSSHPublicKey	implicitDeny
ec2:ModifyInstanceAttribute	implicitDeny
ec2:AssociateIamInstanceProfile	implicitDeny

Each of those actions ends at the instance's credentials: SendCommand runs as the agent, StartSession opens a shell, SendSSHPublicKey grants a login, ModifyInstanceAttribute rewrites user data for the next boot, and AssociateIamInstanceProfile with PassRole attaches a stronger profile to a reachable instance. HttpTokens of optional means the metadata service answers without a session token, which turns a request forgery on that host into the same credentials. Only ssm:SendCommand is the resource-scoping case: RunCommand in the default version grants it on the account's instances and the AWS-RunShellScript document, which never match *. The other four are granted nowhere in that version or in ReadOnlyAccess, so their denials stand. The SendCommand path is marked from that statement, or from a simulation that names the instance and the document; here the proof settles it. The proof, on an instance the client names, is one command that prints the role name through IMDSv2 and the caller identity, nothing else.

aws ssm send-command --instance-ids i-0abc1234def567890 --document-name AWS-RunShellScript \
  --parameters 'commands=["TOKEN=$(curl -s -X PUT http://169.254.169.254/latest/api/token -H X-aws-ec2-metadata-token-ttl-seconds:60)","curl -s -H X-aws-ec2-metadata-token:$TOKEN http://169.254.169.254/latest/meta-data/iam/security-credentials/","aws sts get-caller-identity --query Arn"]' \
  --query 'Command.CommandId' --output text

Expected output

00000000-0000-4000-8000-aaaaaaaa0002   # <- the command id; the next two calls look it up as the instance's latest
aws ssm wait command-executed --command-id "$(aws ssm list-commands --instance-id i-0abc1234def567890 --max-items 1 --query 'Commands[0].CommandId' --output text)" --instance-id i-0abc1234def567890
aws ssm get-command-invocation --command-id "$(aws ssm list-commands --instance-id i-0abc1234def567890 --max-items 1 --query 'Commands[0].CommandId' --output text)" --instance-id i-0abc1234def567890 \
  --query StandardOutputContent --output text

Expected output

prod-api-role"arn:aws:sts::111122223333:assumed-role/prod-api-role/i-0abc1234def567890"   # <- the role name and the caller ARN on one line: the metadata listing has no newline

list-commands finds the instance's latest command, which is the send above when nothing else ran there; holding the id the send printed in a variable does the same. The wait returns silently once the command has finished, so the read never catches it half done. The metadata listing of role names ends without a newline, so prod-api-role and the caller ARN, the instance role's session reached from the CI key, print on one line. Already on an instance from another finding, the two curl lines alone are the proof; the credential document is never fetched.

Negative result. Every action denied with the instances and documents named in --resource-arns, required on every instance, and no instance profile role stronger than the principal itself.

Fix. Require IMDSv2 with aws ec2 modify-instance-metadata-options --http-tokens required and refuse launches without it through the ec2:MetadataHttpTokens condition. Scope ssm:SendCommand and ssm:StartSession to tagged instances and the people who operate them, and give instance roles what the workload uses.

The defender sees

Everything above is in CloudTrail under the principal we used. The reads are ListAttachedUserPolicies, ListPolicyVersions, GetPolicy, GetPolicyVersion, SimulatePrincipalPolicy, ListRoles, GetRole, ListAttachedRolePolicies, GetInstanceProfile, DescribeInstances, ListCommands and GetCommandInvocation, while GetCallerIdentity appears under the function's role and the instance role, not ours; IAM events and calls to the STS global endpoint land in us-east-1 whatever region the CLI is set to. SimulatePrincipalPolicy from a CI key is itself a good alert: pipelines do not ask what they may do. The proofs are CreatePolicyVersion and DeletePolicyVersion; CreateFunction20150331 with the passed role ARN in its request parameters, since there is no PassRole event, then DeleteFunction20150331, with Invoke only where data events are on; AssumeRole, written in the role's account and, where the trust crosses accounts, in the calling account too; and SendCommand. If none of it raised an alert, that is a finding beside the paths.

Done when

Each of the four paths is marked present or absent with its simulation result, every proof is recorded with the command that cleaned it up, and the account's Access Analyzer status is known.

Not covered

Reaching the keys in the first place and the broad enumeration the cloud first hour covers, and the many service-specific paths beyond IAM, Lambda, EC2, SSM and STS.