Study guide

9.2 Permission Boundaries & Safe Admin Delegation

AWS Certified Security – Specialty SCS-C03

Track your progress as you read

Finished sections get a check mark.

1 Chapter 0: Getting Started with the SCS-C03 Exam

0.1 SCS-C03 Exam Format, Domains & Study Strategy

2 Chapter 1: Security Monitoring, Alerting & Threat Detection Services

1.1 Workload Monitoring & Health Check Strategies 1.2 Amazon GuardDuty Architecture & Finding Types 1.3 AWS Security Hub & Automated Conformance Assessment 1.4 Amazon Macie & Automated Data Classification

3 Chapter 2: Enterprise Logging Architecture & Analysis

2.1 Multi-Account CloudTrail & Organization Trails 2.2 Amazon Security Lake & OCSF Log Normalization 2.3 Network Telemetry: VPC Flow Logs & Route 53 Resolver Logs 2.4 Troubleshooting Security Telemetry & Log Ingestion 2.5 Analyzing, Normalizing & Correlating Security Logs

4 Chapter 3: Incident Readiness, Response Planning & Automated Runbooks

3.1 Incident Response Planning & Blast Radius Mitigation 3.2 Testing & Validating Incident Response Plans 3.3 Automated Incident Remediation with EventBridge & Step Functions 3.4 Systems Manager OpsCenter & Incident Manager Runbooks

5 Chapter 4: Digital Forensics, Evidence Preservation & Root Cause Analysis

4.1 Forensic Artifact Capture & Chain of Custody 4.2 Threat Containment & Network Quarantine Techniques 4.3 Correlating Events & Root Cause Analysis with Amazon Detective

6 Chapter 5: Edge Protection, WAF & DDoS Mitigation

5.1 CloudFront Security Headers & Origin Access Control 5.2 AWS WAF Architecture & Advanced Rule Sets 5.3 AWS Shield Advanced & DDoS Defense Architectures 5.4 Edge Integrations: Managed Rule Groups, OCSF Ingestion, IoT Policies & CORS

7 Chapter 6: Compute Workload Hardening, Vulnerability Management & GenAI Security

6.1 Golden AMIs & Container Image Hardening Pipelines 6.2 Amazon Inspector Vulnerability Management & Patch Automation 6.3 Generative AI Security: Amazon Bedrock Guardrails & Model Protection 6.4 Instance Profiles, Service Roles & Execution Roles for Compute 6.5 Secure Administrative Access: Session Manager & EC2 Instance Connect

8 Chapter 7: Network Security, Segmentation, Private Connectivity & Encryption in Transit

7.1 Layered Traffic Filtering: SGs, NACLs & AWS Network Firewall 7.2 Hybrid Connectivity Security: VPN, Direct Connect & MACsec 7.3 Zero-Trust Access & Network Access Analysis 7.4 Enforcing Encryption in Transit: ELB Security Policies, TLS & HTTPS-Only Access 7.5 Private Access: VPC Endpoints, PrivateLink, Client VPN & Verified Access 7.6 Inter-Resource Encryption in Transit: Nitro, EMR, EKS & SageMaker AI

9 Chapter 8: Enterprise Authentication, Federation & Directory Services

8.1 AWS IAM Identity Center & Enterprise IdP Integration 8.2 Amazon Cognito User Pools & Identity Pools 8.3 AWS Security Token Service (STS) & Temporary Credential Workflows 8.4 Troubleshooting Identity & Authentication Failures

10 Chapter 9: Advanced Authorization Architecture & Policy Evaluation

9.1 Complete AWS Policy Evaluation Logic & Decision Flow 9.2 Permission Boundaries & Safe Admin Delegation 9.3 Attribute-Based Access Control (ABAC) with IAM Tags

11 Chapter 10: Least Privilege, Policy Validation & External Access Auditing

10.1 IAM Roles Anywhere & Amazon Verified Permissions 10.2 Auditing External & Unused Access with IAM Access Analyzer 10.3 Analyzing Authorization Failures & Policy Simulation

12 Chapter 11: Cryptographic Services: KMS Architecture & Key Governance

11.1 AWS KMS Architecture, Key Policies & Key Types 11.2 KMS Grants, Encryption Context & Multi-Region Keys 11.3 Imported Key Material (BYOK) & CloudHSM Key Stores

13 Chapter 12: Secrets Management, Sensitive Data Masking & PKI

12.1 AWS Secrets Manager & Systems Manager Parameter Store 12.2 Sensitive Data Masking in Telemetry & Messaging 12.3 AWS Certificate Manager (ACM) & Private CA Architecture

14 Chapter 13: Storage Encryption, Integrity, Lifecycle & Backup Protection

13.1 S3 Encryption Modes & S3 Bucket Keys 13.2 Data Integrity Protection: Object Lock, Vault Lock & Code Signing 13.3 Secure Data Lifecycle, Cross-Account Replication & Backup Vault Lock 13.4 Lifecycle, Backup & Secure Replication Beyond S3: EFS, FSx, DLM, DataSync & Air-Gapped Vaults

15 Chapter 14: Multi-Account Architecture, Organizations & Control Tower Governance

14.1 AWS Organizations Structure, Hierarchy & Resource Control 14.2 AWS Control Tower Landing Zone & Guardrail Framework 14.3 Delegated Administrator Architecture & Root User Governance 14.4 Centralized Resource Sharing with RAM & Service Catalog

16 Chapter 15: Compliance Automation, Infrastructure as Code Security & Auditing

15.1 Infrastructure as Code Security & Multi-Account Deployment 15.2 AWS Config, Conformance Packs & Automated Remediation 15.3 Audit Evidence Collection & Well-Architected Security Reviews

9.2 Permission Boundaries & Safe Admin Delegation

Key Takeaways Explain This Topic AI

Safe delegation allows engineering and DevOps teams to create and manage application IAM roles autonomously without granting full administrative privileges or risking privilege escalation.

To prevent privilege escalation, delegated role creation must enforce the iam:PermissionsBoundary condition key on iam:CreateRole , iam:CreateUser , iam:PutRolePolicy , and iam:AttachRolePolicy .

Anti-tampering guardrails must explicitly deny delegated administrators the ability to delete or modify the boundary policy ( iam:DeleteRolePermissionsBoundary , iam:CreatePolicyVersion , iam:DeletePolicy ).

Permission boundaries define the maximum permissions ceiling for IAM identities but never grant permissions directly; an identity-based policy is still required to perform actions.

Permission boundaries never grant access. In the same account they also limit resource-based policies that name the role ARN, but not grants to an IAM user ARN or role session ARN, and they can't be attached to the root user or service-linked roles.

Last updated: September 2026

9.2 Permission Boundaries & Safe Admin Delegation

In modern cloud engineering, modernizing deployment velocity requires decentralizing administrative tasks. Continuous integration and continuous delivery (CI/CD) pipelines, serverless architectures, and containerized microservices frequently require creating new IAM roles for AWS Lambda functions, Amazon ECS tasks, and automated deployment jobs. However, granting engineers unrestricted iam:CreateRole and iam:AttachRolePolicy permissions introduces catastrophic privilege escalation risks .

An IAM Permission Boundary is an advanced authorization control that establishes the absolute maximum permissions an identity-based policy can grant to an IAM entity. By pairing permission boundaries with conditioned IAM policies, enterprise security teams achieve safe administrative delegation —allowing developers to provision and manage their own application roles without the ability to escalate privileges to full account administrator.

The Delegation Dilemma & Privilege Escalation Vectors

When security teams attempt to delegate role creation naively, they encounter a critical vulnerability: the Unbounded Role Creation Exploit .

Consider an IAM policy that allows a developer to perform iam:CreateRole and iam:AttachRolePolicy so they can configure IAM roles for their microservices. Without boundary guardrails, the developer can execute the following privilege escalation sequence:

Loading diagram...

The developer invokes iam:CreateRole to create an arbitrary role named BackdoorAdminRole with a trust policy allowing themselves to assume it.

The developer invokes iam:AttachRolePolicy , attaching the AWS-managed AdministratorAccess policy to BackdoorAdminRole .

The developer assumes BackdoorAdminRole using sts:AssumeRole .

The developer now possesses unrestricted *:* administrative permissions, bypassing all original organizational constraints, altering audit logs, or modifying production infrastructure.

To prevent this, security architects implement Permission Boundaries as non-bypassable guardrails.

Mechanics of IAM Permission Boundaries

A permission boundary is a standard customer-managed IAM policy that is applied to an IAM user or role to define its maximum allowable permissions. It does not grant permissions by itself; rather, it functions as an authorization filter.

Loading diagram...

Mathematical Intersection Model

The effective permissions of any principal subject to a permission boundary represent the strict intersection of the identity-based policy and the boundary:

Effective Permissions = Identity Policy ∩ Permission Boundary

If an action is permitted by the identity policy but omitted from the boundary, the action is implicitly denied .

If an action is permitted by the boundary but omitted from the identity policy, the action is implicitly denied .

If an action is explicitly denied in either the identity policy or the boundary, the action is explicitly denied .

Both policies must explicitly allow the action for access to be granted.

The Three-Tier Safe Delegation Architecture

Enterprise delegation relies on a synchronized three-tier policy framework comprising the Delegator Policy , the Permission Boundary Policy , and the Delegated Workload Policy :

Loading diagram...

1. The Delegator Policy (Attached to DevOps Engineers)

The Delegator Policy grants developers the ability to create roles, attach policies, and pass roles to compute services, but conditions those actions strictly on the presence of the boundary policy. {

  • "Version": "2012-10-17",
  • "Statement": [
  • {
  • "Sid": "AllowRoleCreationWithBoundary",
  • "Effect": "Allow",
  • "Action": [
  • "iam:CreateRole"
  • ],
  • "Resource": "arn:aws:iam::111122223333:role/app-roles/*",
  • "Condition": {
  • "StringEquals": {
  • "iam:PermissionsBoundary": "arn:aws:iam::111122223333:policy/AppPermissionBoundary"
  • }
  • }
  • },
  • {
  • "Sid": "AllowPolicyAttachmentToBoundedRoles",
  • "Effect": "Allow",
  • "Action": [
  • "iam:AttachRolePolicy",
  • "iam:PutRolePolicy",
  • "iam:DetachRolePolicy",
  • "iam:DeleteRolePolicy"
  • ],
  • "Resource": "arn:aws:iam::111122223333:role/app-roles/*",
  • "Condition": {
  • "StringEquals": {
  • "iam:PermissionsBoundary": "arn:aws:iam::111122223333:policy/AppPermissionBoundary"
  • }
  • }
  • },
  • {
  • "Sid": "PreventBoundaryTampering",
  • "Effect": "Deny",
  • "Action": [
  • "iam:DeleteRolePermissionsBoundary",
  • "iam:PutRolePermissionsBoundary",
  • "iam:DeleteUserPermissionsBoundary",
  • "iam:PutUserPermissionsBoundary"
  • ],
  • "Resource": "*"
  • },
  • {
  • "Sid": "PreventBoundaryPolicyModification",
  • "Effect": "Deny",
  • "Action": [
  • "iam:CreatePolicyVersion",
  • "iam:DeletePolicyVersion",
  • "iam:DeletePolicy",
  • "iam:SetDefaultPolicyVersion"
  • ],
  • "Resource": "arn:aws:iam::111122223333:policy/AppPermissionBoundary"
  • },
  • {
  • "Sid": "AllowPassRoleToApprovedServices",
  • "Effect": "Allow",
  • "Action": "iam:PassRole",
  • "Resource": "arn:aws:iam::111122223333:role/app-roles/*",
  • "Condition": {
  • "StringEqualsIfExists": {
  • "iam:PassedToService": [
  • "lambda.amazonaws.com",
  • "ecs-tasks.amazonaws.com"
  • ]
  • }
  • }
  • }
  • ]
  • }
  • Critical Policy Statement Rationale

Statement 1 ( AllowRoleCreationWithBoundary ) : Allows iam:CreateRole strictly under the path /app-roles/* and enforces the iam:PermissionsBoundary condition key. If a developer attempts to run aws iam create-role without --permissions-boundary , the API call fails immediately with AccessDenied .

Statement 2 ( AllowPolicyAttachmentToBoundedRoles ) : Restricts policy attachment. Even if a role was created with a boundary, developers must not be allowed to attach policies to unbounded roles (such as existing security administration roles).

Statement 3 ( PreventBoundaryTampering ) : Explicitly denies removing or changing the boundary once a role is created.

Statement 4 ( PreventBoundaryPolicyModification ) : Crucial security safeguard. If a developer has permission to create a new default policy version ( iam:CreatePolicyVersion ) for the boundary policy, they could simply edit the boundary to allow *:* . Denying modification APIs on the boundary ARN closes this backdoor.

Statement 5 ( AllowPassRoleToApprovedServices ) : Restricts iam:PassRole so developers can only pass bounded roles to specific services like AWS Lambda and Amazon ECS, preventing them from passing roles to unauthorized compute instances.

2. The Permission Boundary Policy ( AppPermissionBoundary )

The boundary policy defines the broad capabilities application workloads are permitted to use, while establishing permanent enterprise guardrails: {

  • "Version": "2012-10-17",
  • "Statement": [
  • {
  • "Sid": "AllowApplicationServices",
  • "Effect": "Allow",
  • "Action": [
  • "s3:*",
  • "dynamodb:*",
  • "sqs:*",
  • "sns:*",
  • "logs:*"
  • ],
  • "Resource": "*"
  • },
  • {
  • "Sid": "DenySecurityServicesModification",
  • "Effect": "Deny",
  • "Action": [
  • "cloudtrail:DeleteTrail",
  • "cloudtrail:StopLogging",
  • "cloudtrail:UpdateTrail",
  • "guardduty:DeleteDetector",
  • "guardduty:DisassociateFromMasterAccount",
  • "securityhub:DisableSecurityHub",
  • "config:DeleteConfigRule"
  • ],
  • "Resource": "*"
  • },
  • {
  • "Sid": "DenyIAMManagement",
  • "Effect": "Deny",
  • "Action": [
  • "iam:*",
  • "organizations:*"
  • ],
  • "Resource": "*"
  • }
  • ]
  • }

Even if a developer attaches AdministratorAccess ( *:* ) to an application role, the role can never modify CloudTrail, disable GuardDuty, alter AWS Config rules, or execute IAM API calls because those actions are explicitly denied by the boundary.

Boundary Limitations & Architectural Edge Cases

Understanding where permission boundaries do not apply is a major focus of specialty certification scenarios:

Resource-Based Policies Depend on the Principal Named : In the same account, a bucket or queue policy that names the role ARN is still limited by the role's boundary. A policy that names a role session ARN or an IAM user ARN grants access directly, even if the boundary omits the service. Cross-account access always needs the boundary (and identity policy) to allow the action.

Boundaries Do Not Grant Access : Attaching a permission boundary granting s3:* to a role that has no identity policies attached results in zero access. A matching identity-based policy must be attached.

Root User and Service-Linked Roles : Permission boundaries cannot be attached to the AWS account root user, nor do they apply to AWS service-linked roles created by AWS services to manage infrastructure.

Cross-Account Roles : When a principal in Account A assumes a cross-account role in Account B, any permission boundary attached to the principal in Account A has no effect on actions performed in Account B. The role in Account B is evaluated based on its own policies and any boundary attached directly to the Account B role.

Specialty Exam Pitfalls & Architectural Traps

The Policy Versioning Escalation Trap : When constructing delegation policies, never grant iam:CreatePolicyVersion on all policies. If a delegated user has iam:CreatePolicyVersion on * , they can update the boundary policy itself to add AdministratorAccess , bypassing all protections. Always deny policy versioning and deletion on the boundary policy ARN.

The iam:PassRole Without Boundary Trap : Granting iam:PassRole with Resource: "*" allows an engineer to create a Lambda function or EC2 instance and attach a pre-existing administrative role (e.g., OrganizationAccountAccessRole ), thereby executing arbitrary code as full administrator. Always restrict iam:PassRole to roles within the approved path /app-roles/* that carry the boundary.

Confusing Permission Boundaries with SCPs : Service Control Policies apply account-wide across all principals (except the management account) and are managed at the AWS Organizations level. Permission boundaries are attached individually to specific IAM users and roles within an account. SCPs enforce compliance across accounts; boundaries enable safe delegation within an account.

The iam:PutRolePolicy Backdoor : Security engineers often enforce boundaries on iam:CreateRole but forget to condition iam:PutRolePolicy (inline policies) and iam:AttachRolePolicy (managed policies). Without conditioning policy attachment APIs, an engineer can create a bounded role, delete its boundary (if not denied), or attach policies to unmonitored existing roles.

Loading diagram... Safe IAM Delegation Workflow & Permission Boundary Ceiling