Study guide
10.1 IAM Roles Anywhere & Amazon Verified Permissions
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
10.1 IAM Roles Anywhere & Amazon Verified Permissions
Key Takeaways Explain This Topic AI
IAM Roles Anywhere extends AWS Identity and Access Management to non-AWS workloads (on-premises physical servers, hybrid containers, edge hardware) using X.509 digital certificates from an internal or external PKI, eliminating hardcoded long-term AWS access keys.
The open-source aws_signing_helper signs CreateSession requests with the workload's private key, and certificate revocation lists (CRLs) imported into IAM Roles Anywhere block compromised certificates before they expire.
The open-source aws_signing_helper tool automates client-side private key signing and CreateSession API calls, while Certificate Revocation Lists (CRLs) enable immediate invalidation of compromised certificates.
Amazon Verified Permissions provides fine-grained, policy-based application authorization decoupled from application code, utilizing the Cedar policy language which is deterministic, forbids recursion, and enforces default deny.
Cedar operates on schema-defined entity stores (principals, actions, resources, context), supporting static policies and reusable policy templates with seamless Amazon Cognito and OIDC token integration.
Last updated: September 2026
10.1 IAM Roles Anywhere & Amazon Verified Permissions
Modern cloud security architectures demand strict enforcement of least privilege across two distinct organizational tiers: infrastructure-level access to AWS service APIs and application-level authorization within custom software workloads. Historically, connecting workloads outside AWS to native cloud services required distributing long-term IAM access keys—a practice that introduced severe credential exposure risks, key rotation overhead, and secret sprawl. Simultaneously, application developers frequently hardcoded Role-Based Access Control (RBAC) rules directly into application business logic, resulting in brittle, fragmented authorization policies that resisted central compliance auditing.
AWS resolves these challenges through two complementary services: AWS Identity and Access Management (IAM) Roles Anywhere , which projects temporary, short-term AWS STS credentials to non-AWS workloads using Public Key Infrastructure (PKI), and Amazon Verified Permissions , which provides fine-grained, policy-based application authorization governed by the formally verified Cedar policy language.
Extending AWS IAM to External Workloads with IAM Roles Anywhere
Workloads running outside AWS—such as bare-metal databases in on-premises data centers, Kubernetes pods running in colocation facilities, and industrial Internet of Things (IoT) edge appliances—frequently need to interact with AWS services like Amazon S3, Amazon Kinesis, or AWS Systems Manager. Distributing static IAM access keys ( aws_access_key_id and aws_secret_access_key ) to these remote environments creates substantial security vulnerabilities: if a host is compromised, static keys are easily exfiltrated and misused indefinitely until revoked.
IAM Roles Anywhere eliminates the need for long-term credentials by establishing a cryptographic bridge between your enterprise Public Key Infrastructure (PKI) and AWS Security Token Service (AWS STS) . Non-AWS workloads exchange signatures generated from their X.509 certificates for short-term, temporary AWS credentials.
Core Architectural Constructs
IAM Roles Anywhere relies on four primary building blocks:
Trust Anchor : The foundational trust configuration within IAM Roles Anywhere. A trust anchor represents an authoritative Certificate Authority (CA). It can be linked directly to an AWS Private CA (ACM PCA) resource within your AWS account or configured as an External Certificate Authority by uploading an X.509 root or intermediate CA certificate bundle in PEM format.
IAM Role : A standard AWS IAM role whose trust policy designates the service principal rolesanywhere.amazonaws.com as an authorized entity to perform sts:AssumeRole , sts:TagSession , and sts:SetSourceIdentity .
Profile : A configuration object in IAM Roles Anywhere that defines the authorization boundary for sessions. A profile specifies which IAM roles can be assumed, the maximum session duration (from 900 seconds [15 minutes] up to 43,200 seconds [12 hours]), and optional managed or inline session policies that scope down the effective permissions of assumed sessions.
Credential Helper ( aws_signing_helper ) : An open-source, client-side utility provided by AWS that automates signing requests with the workload's local X.509 certificate and private key. It communicates with the regional IAM Roles Anywhere endpoint to obtain temporary STS credentials and outputs them in the standardized JSON format expected by the AWS CLI and AWS SDKs.
The Cryptographic Handshake & Role Assumption Flow
Loading diagram...
Session Request : The workload invokes aws_signing_helper specifying the certificate path, private key path, Trust Anchor ARN, Profile ARN, and target Role ARN.
Digital Signature : The helper calculates a standard AWS Signature Version 4 (SigV4) signature over the API request payload using the workload's private key.
Validation : The helper calls the rolesanywhere:CreateSession API. IAM Roles Anywhere verifies that the certificate was signed by a CA configured in the designated Trust Anchor and confirms the certificate is neither expired nor listed on an active Certificate Revocation List (CRL).
STS Invocation : Upon successful certificate validation, IAM Roles Anywhere calls AWS STS AssumeRole on behalf of the client, passing the requested session duration and any profile-defined session policies.
Credential Delivery : AWS STS issues temporary credentials ( AccessKeyId , SecretAccessKey , SessionToken , and Expiration ), which IAM Roles Anywhere returns to aws_signing_helper to authenticate AWS SDK or CLI operations.
IAM Role Trust Policy for Roles Anywhere
The target IAM role must have a trust policy that allows rolesanywhere.amazonaws.com . To enforce least privilege, the policy should evaluate certificate attributes via condition keys: {
- "Version": "2012-10-17",
- "Statement": [
- {
- "Sid": "AllowIAMRolesAnywhereWithCertConditions",
- "Effect": "Allow",
- "Principal": {
- "Service": "rolesanywhere.amazonaws.com"
- },
- "Action": [
- "sts:AssumeRole",
- "sts:TagSession",
- "sts:SetSourceIdentity"
- ],
- "Condition": {
- "ArnEquals": {
"rolesanywhere:ProfileArn": "arn:aws:rolesanywhere:us-east-1:111122223333:profile/a1b2c3d4-e5f6-7890-1234-56789abcdef0"
- },
- "StringEquals": {
- "rolesanywhere:X509Subject/O": "ExampleCorp Enterprise",
- "rolesanywhere:X509Subject/OU": "Database Operations"
- },
- "StringLike": {
- "rolesanywhere:X509Subject/CN": "db-prod-*.corp.example.com"
- }
- }
- }
- ]
- }
- Certificate Revocation Lists (CRLs)
If a physical host, container host, or private key is compromised, administrators cannot wait for the X.509 certificate to expire naturally. IAM Roles Anywhere supports Certificate Revocation Lists (CRLs) :
Administrators generate an X.509 CRL from the issuing CA; it must be signed by a CA in the trust anchor's certificate bundle.
The CRL is imported with the ImportCrl API (console, CLI, or SDK) and associated with the trust anchor, then enabled. IAM Roles Anywhere doesn't fetch CRLs or query OCSP responders itself, so publish updated CRLs with UpdateCrl whenever the CA revokes more certificates.
When an enabled CRL lists a certificate's serial number, CreateSession calls with that certificate fail, so no new credentials are issued. Sessions already issued stay valid until they expire, so also revoke active sessions on the role if the key was stolen.
Hybrid Credential Comparison
Feature IAM Roles Anywhere Systems Manager Hybrid Activations IAM User Access Keys Cognito Identity Pools
Primary Mechanism X.509 PKI Certificates Registration Code & ID Static Key ID & Secret Key OIDC / SAML / Social IdP
- Credential Lifetime Temporary (15m - 12h) Temporary (via SSM Agent) Long-Term / Static Temporary (15m - 1h)
- Agent Required? aws_signing_helper only Full SSM Agent daemon None (baked into SDK) AWS Mobile/Web SDK
Best Use Case On-prem servers & containers Systems management & patching Legacy scripting (discouraged) Mobile & Web end-users
Application-Layer Authorization with Amazon Verified Permissions
While IAM controls infrastructure access to AWS services, modern microservice applications require fine-grained access control over internal business resources—such as bank accounts, medical records, insurance claims, or software projects. Implementing authorization inside application source code using hardcoded if/else statements or basic role checks leads to significant vulnerabilities:
Authorization logic becomes duplicated and inconsistent across microservices.
Adding new permissions or roles requires altering application code and initiating a full continuous deployment pipeline.
Security compliance officers cannot independently review or audit authorization rules without inspecting application code repositories.
Amazon Verified Permissions (AVP) decouples application authorization from business logic, centralizing policy management into an enterprise policy store evaluated at millisecond latency.
The Cedar Policy Language
Amazon Verified Permissions is built entirely upon Cedar , an open-source, expressive, and formally verified authorization policy language developed by AWS. Cedar possesses three critical characteristics that are heavily emphasized on the AWS Certified Security – Specialty exam:
Deterministic Evaluation : Given a specific policy store, request context, and entity state, Cedar evaluations produce identical outcomes every time without side effects.
Forbids Recursion and Loops : Cedar is intentionally designed without loops, recursive calls, or user-defined functions . This mathematical constraint guarantees that policy evaluation always completes in bounded, predictable execution time. It completely prevents denial-of-service vulnerabilities caused by algorithmic complexity attacks (such as Regular Expression DoS or infinite execution loops).
Strict Default Deny with Explicit Override : Cedar evaluates all requests from an implicit deny state. Access is granted only if an explicit permit statement evaluates to true and no matching forbid statement evaluates to true. Any matching forbid statement immediately and unconditionally overrides all matching permit statements. // Permit auditors to view quarterly financial reports if MFA is verified
- permit (
- principal in Role::"FinancialAuditor",
- action in [Action::"ViewReport", Action::"ExportSummary"],
- resource in ReportFolder::"QuarterlyFinancials"
- )
- when {
- context.mfaAuthenticated == true &&
- context.networkSecurityScore >= 80
- };
- // Explicitly forbid any access to confidential reports if marked Restricted
- forbid (
- principal,
- action,
- resource
- )
- when {
- resource.classification == "Restricted" &&
- !principal.hasSpecialClearance
- };
- Entity Stores and Context
Cedar evaluates requests using a four-part tuple: (Principal, Action, Resource, Context) .
Principal : The actor initiating the request (e.g., User::"Alice" , ServiceAccount::"PaymentWorker" ).
Action : The operation being attempted (e.g., Action::"TransferFunds" , Action::"ReadMedicalRecord" ).
Resource : The domain entity targeted by the operation (e.g., Account::"12345" , Record::"Patient-987" ).
Context : Ephemeral runtime variables supplied by the application at evaluation time (e.g., context.clientIp , context.currentTimestamp , context.userLocation ).
Cedar supports hierarchical entities . For example, a principal User::"Bob" can be a member of Group::"DevOps" , which in turn belongs to Group::"Engineering" . Cedar uses the in operator to test hierarchical membership, allowing clean group-based and role-based policies without flattening group trees in application code.
Static Policies vs. Policy Templates
Amazon Verified Permissions supports two administrative models for policy authoring:
Static Policies : Self-contained Cedar policies whose principal, action, and resource identifiers are explicitly defined within the statement. Static policies are ideal for universal baseline guardrails (such as organizational administrators or compliance monitors).
Policy Templates : Parameterized Cedar policy blueprints that replace the principal, resource, or both with placeholders ( ?principal and ?resource ). // Cedar Policy Template for Document Collaboration
- permit (
- principal == ?principal,
- action in [Action::"ViewDocument", Action::"EditDocument", Action::"AddComment"],
- resource == ?resource
- );
When end-users share resources with colleagues, the application does not write custom policy text; instead, it instantiates a Template-Linked Policy , binding concrete entity IDs (e.g., ?principal = User::"carol" , ?resource = Document::"project-alpha" ) to the underlying template. This architecture provides massive scalability: updating the single parent template automatically and instantly propagates permission changes across millions of template-linked policies without individual policy edits.
Identity Provider Integration (Amazon Cognito & OIDC)
Applications typically authenticate users against Amazon Cognito User Pools or external OpenID Connect (OIDC) identity providers (such as Okta, Ping Identity, or Microsoft Entra ID). Amazon Verified Permissions integrates natively with these providers via Identity Sources :
When a user logs in, the identity provider issues a JSON Web Token (JWT)—either an ID token or an Access token.
The client application passes the bearer JWT directly to the Verified Permissions IsAuthorizedWithToken API.
Verified Permissions cryptographically verifies the token's digital signature, validates expiration and issuer claims, extracts user claims (such as sub , cognito:groups , and custom attributes), and maps them into Cedar principal entities and context variables automatically.
This allows applications to enforce policy-based authorization without writing custom token-parsing and signature-verification middleware.
Specialty Exam Pitfalls & Architectural Traps
Treating IAM Roles Anywhere as an Alternative to Amazon Cognito for Human Users : IAM Roles Anywhere is purpose-built for machine-to-machine workloads, servers, and containers possessing X.509 certificates. It is not designed for authenticating human end-users via web browsers or mobile apps; use Amazon Cognito or AWS IAM Identity Center for human identity federation.
Confusing Cedar Forbid Semantics with Deny Semantics in IAM : While both Cedar forbid and IAM Deny override allows, Cedar policies are evaluated exclusively at the application layer by Amazon Verified Permissions. Attaching a Cedar policy to an IAM role or SCP is syntactically impossible; Cedar policies reside exclusively within Verified Permissions policy stores.
Overlooking the aws_signing_helper Utility : Candidates often incorrectly assume that on-premises servers must run the complete AWS Systems Manager Agent or run an on-premises STS broker. IAM Roles Anywhere only requires the standalone aws_signing_helper executable to manage certificate reading, SigV4 signing, and local credential injection.
Editing Template-Linked Policies Directly : You cannot directly modify the Cedar statement of a template-linked policy. To change permissions across linked policies, you must update the parent Policy Template, which dynamically updates all child linked policies.
Loading diagram... IAM Roles Anywhere PKI Handshake vs. Amazon Verified Permissions Application Authorization Flow