06 β Cloud Security Testing
Cloud computing has fundamentally changed the attack surface of modern enterprises.
Traditional penetration testing often starts with:
IP Address βPort βService βVulnerability βSystem AccessCloud security testing frequently starts somewhere very different:
Cloud Identity βIAM Permission βCloud API βResource βAdditional Identity βPrivilege βCloud Control PlaneAn attacker may never need to exploit a traditional server vulnerability.
A single:
-
Exposed credential
-
Overprivileged identity
-
Public storage bucket
-
Misconfigured role
-
Leaked API key
-
Workload identity
-
CI/CD credential
-
Insecure trust relationship
may create a path deep into the cloud environment.
For an Ethical Hacker, cloud security testing therefore requires a shift in mindset.
Cloud hacking is often identity, permission, configuration, and trust-path hacking.
Module Mission
Section titled βModule MissionβYour mission is to learn how to systematically assess authorised cloud environments across AWS, Microsoft Azure, Google Cloud, and modern cloud-native workloads.
The core methodology is:
Scope βUnderstand Cloud Architecture βIdentify Accounts / Subscriptions / Projects βEstablish Current Identity βEnumerate Permissions βDiscover Resources βMap External Exposure βAssess IAM βAssess Storage βAssess Networking βAssess Compute βAssess Workload Identities βAssess Secrets βAssess Serverless / Containers / Kubernetes βAnalyse Trust Relationships βIdentify Privilege Paths βValidate Safely βCollect Evidence βReportThe objective is not simply to discover misconfigurations.
The objective is to answer:
How could an attacker move from initial cloud access to meaningful business impact?
1. Cloud Security Testing
Section titled β1. Cloud Security TestingβCloud security testing evaluates the security of:
Cloud Identities
Cloud Resources
Cloud Configurations
Cloud Networks
Cloud Applications
Cloud Workloads
Cloud APIs
Trust Relationships
Management PlanesThe assessment may include both:
External Attack Surface +Authenticated Cloud Assessment2. Why Cloud Pentesting Is Different
Section titled β2. Why Cloud Pentesting Is DifferentβIn traditional infrastructure:
Server βOperating System βApplicationIn cloud:
Cloud Control Plane β βββ Identity βββ Compute βββ Storage βββ Network βββ Database βββ Serverless βββ Containers βββ Security ServicesThe management API itself becomes part of the attack surface.
3. Cloud Control Plane
Section titled β3. Cloud Control PlaneβThe control plane allows authorised identities to create, modify, and delete cloud resources.
Examples include:
Create Virtual Machine
Modify Firewall
Create IAM User
Attach Role
Read Secret
Create Function
Modify Storage Policy
Change LoggingControl-plane access can be more powerful than access to an individual server.
4. Data Plane
Section titled β4. Data PlaneβThe data plane represents interaction with deployed resources and their data.
Example:
User βWeb Application βDatabasewhile control-plane interaction may look like:
Administrator βCloud API βModify Database ConfigurationBoth must be considered during cloud assessments.
5. Shared Responsibility
Section titled β5. Shared ResponsibilityβCloud providers secure the underlying cloud infrastructure.
Customers remain responsible for significant parts of their deployed environment.
Conceptually:
Cloud Provider βSecurity OF the Cloud
Customer βSecurity IN the CloudThe exact division varies by service.
6. Shared Responsibility Changes by Service
Section titled β6. Shared Responsibility Changes by ServiceβFor Infrastructure as a Service:
Providerβββ Physical Infrastructureβββ Hardwareβββ Core Cloud Platform
Customerβββ Operating Systemβββ Applicationsβββ Identityβββ Dataβββ ConfigurationFor managed services, the provider may manage more of the underlying stack.
But customers still commonly control:
Identity
Access
Data
Configuration7. Cloud Providers
Section titled β7. Cloud ProvidersβThis module focuses on principles applicable across:
Amazon Web Services
Microsoft Azure
Google Cloud PlatformDo not memorise only service names.
Understand the security concepts behind them.
8. Cloud Hierarchy
Section titled β8. Cloud HierarchyβDifferent providers organise environments differently.
A simplified comparison:
| Security Concept | AWS | Azure | Google Cloud |
|---|---|---|---|
| Top-level environment | Organization | Tenant | Organization |
| Workload boundary | Account | Subscription | Project |
| Identity | IAM | Entra ID / Azure RBAC | Cloud IAM |
| Compute | EC2 | Virtual Machines | Compute Engine |
| Object storage | S3 | Blob Storage | Cloud Storage |
| Serverless | Lambda | Functions | Cloud Functions |
| Secrets | Secrets Manager | Key Vault | Secret Manager |
The names differ.
The security questions remain similar.
9. Cloud Scope
Section titled β9. Cloud ScopeβCloud assessments require precise scope.
Example:
Provider:AWS
Organization:Example Corporation
In Scope:Account 111111111111Account 222222222222
Regions:eu-west-1us-east-1
Services:IAMEC2S3Lambda
Out of Scope:Production destructive testingDoSThird-party SaaSUnapproved accounts10. Cloud Provider Testing Policies
Section titled β10. Cloud Provider Testing PoliciesβCloud providers may have specific penetration-testing policies.
Before conducting an engagement:
Client Authorization +Cloud Provider Rules +Rules of Engagementmust all be understood.
Never assume traditional penetration-testing rules automatically apply to every managed cloud service.
11. Start With Identity
Section titled β11. Start With IdentityβWhen given authorised cloud access, your first question should be:
Who am I?
Not:
Which exploit should I run?
Establish:
Identity
Account
Tenant
Subscription
Project
Roles
Permissions
Authentication Method12. Identity Is the New Perimeter
Section titled β12. Identity Is the New PerimeterβTraditional security:
Internet βFirewall βInternal NetworkCloud environments increasingly operate like:
User / Workload βIdentity βPolicy βCloud API βResourceTherefore:
Identity configuration often determines the effective cloud perimeter.
13. Human and Machine Identities
Section titled β13. Human and Machine IdentitiesβCloud identities include:
Human Users
Administrators
Applications
Virtual Machines
Containers
Serverless Functions
CI/CD Systems
Automation PlatformsMachine identities deserve the same scrutiny as human identities.
14. Authentication vs Authorization
Section titled β14. Authentication vs AuthorizationβAuthentication answers:
Who are you?
Authorization answers:
What are you allowed to do?
Example:
Alice βAuthenticated βCloud Environment βRead Storage βCannot Modify IAMBoth controls matter.
15. AWS Identity Model
Section titled β15. AWS Identity ModelβImportant AWS IAM concepts include:
IAM Users
IAM Groups
IAM Roles
Policies
Resource Policies
Temporary Credentials
Service RolesA simplified model:
Identity βPolicy βPermission βAWS Resource16. Azure Identity Model
Section titled β16. Azure Identity ModelβAzure commonly combines:
Microsoft Entra ID +Azure RBACConceptually:
User / Service Principal βRole Assignment βScope βAzure ResourceScope may exist at:
Management Group
Subscription
Resource Group
Resource17. Google Cloud IAM
Section titled β17. Google Cloud IAMβGoogle Cloud IAM uses principals, roles, and resource hierarchy.
Conceptually:
Principal βRole βOrganization / Folder / Project / ResourceInherited permissions can create broad access.
18. IAM Assessment
Section titled β18. IAM AssessmentβFor each identity determine:
Who Is It?
Why Does It Exist?
How Does It Authenticate?
Which Roles?
Which Permissions?
Which Resources?
Can It Assume Another Identity?
Can It Modify IAM?
Can It Access Secrets?
Is MFA Required?
Is It Still Needed?19. Least Privilege
Section titled β19. Least PrivilegeβCloud identities should receive only the permissions required.
Example:
Application βNeeds:Read Object ABut receives:
Storage AdministratorThis creates unnecessary attack capability.
20. Effective Permissions
Section titled β20. Effective PermissionsβDo not evaluate only directly assigned roles.
Effective privilege may result from:
Direct Permissions +Group Membership +Inherited Permissions +Resource Policies +Role Assumption +Trust RelationshipsThis makes cloud permission analysis complex.
21. Cloud Privilege Escalation
Section titled β21. Cloud Privilege EscalationβCloud privilege escalation often occurs when an identity can use apparently limited permissions to obtain greater control.
Conceptually:
Low-Privilege Identity βCloud Permission βModify Resource / Identity βAssume Stronger Privilege βAdministrative AccessThe key question is:
What can this permission indirectly allow the identity to become?
22. IAM Privilege Paths
Section titled β22. IAM Privilege PathsβExample:
Developer βCan Modify Application βApplication Uses Privileged Role βDeveloper Influences Workload βPrivileged Cloud AccessThe developer did not need direct administrative permission.
The workload created the path.
23. Permission Chaining
Section titled β23. Permission ChainingβCloud risk frequently comes from combinations.
Suppose an identity can:
Create Workload +Assign Existing RoleNeither permission should be assessed in isolation.
Together they may produce:
Create Workload βAttach Privileged Identity βWorkload Runs βHigher PrivilegeThis is permission chaining.
24. Cloud Reconnaissance
Section titled β24. Cloud ReconnaissanceβCloud reconnaissance attempts to understand the environment before deeper testing.
Information may include:
Domains
Cloud Providers
Public IP Addresses
Storage Names
Applications
APIs
CDNs
Authentication Portals
Public Repositories
Cloud Service ReferencesOnly actively interact with systems included in scope.
25. External Cloud Attack Surface
Section titled β25. External Cloud Attack SurfaceβA cloud environment may expose:
Web Applications
APIs
Storage
Load Balancers
Virtual Machines
Serverless Endpoints
Container Services
Kubernetes APIs
Management InterfacesCreate an external inventory before testing individual components.
26. Cloud Asset Inventory
Section titled β26. Cloud Asset InventoryβExample:
| Asset | Provider | Exposure | Identity | Purpose |
|---|---|---|---|---|
| Web App | AWS | Public | App Role | Customer portal |
| Storage | AWS | Restricted | Storage Role | Documents |
| VM | Azure | Internal | Managed Identity | Application |
| Function | GCP | Public API | Service Account | Processing |
Asset context is essential.
27. Public Does Not Automatically Mean Vulnerable
Section titled β27. Public Does Not Automatically Mean VulnerableβSome resources must be public.
Examples:
Public Website
Public API
Static Website ContentThe question is whether:
Intended Exposure =Actual Exposure28. Cloud Storage
Section titled β28. Cloud StorageβObject storage is widely used for:
Documents
Backups
Application Data
Logs
Media
Deployment Files
Static WebsitesExamples include:
Amazon S3
Azure Blob Storage
Google Cloud Storage29. Storage Security Questions
Section titled β29. Storage Security QuestionsβFor every storage resource ask:
Is It Public?
Who Can Read?
Who Can Write?
Who Can Delete?
Is Encryption Enabled?
Is Versioning Used?
Is Logging Enabled?
Does It Contain Secrets?
Is Access Cross-Account?30. Public Storage Exposure
Section titled β30. Public Storage ExposureβA risky configuration may look like:
Internet βPublic Storage βSensitive DataBut not every publicly accessible object is sensitive.
Validate the intended business use.
31. Storage Write Access
Section titled β31. Storage Write AccessβUnauthorised write access can sometimes be more dangerous than read access.
Potential impact includes:
Content Modification
Malware Distribution
Application Manipulation
Data Destruction
Supply-Chain RiskAlways evaluate permissions beyond simple public readability.
32. Cloud Networking
Section titled β32. Cloud NetworkingβCloud networking commonly includes:
Virtual Networks
Subnets
Routes
Security Groups
Firewall Rules
Load Balancers
Gateways
Private Endpoints
VPNs
PeeringUnderstand the architecture before assessing exposure.
33. Security Groups and Firewalls
Section titled β33. Security Groups and FirewallsβA simplified rule:
Source βProtocol βPort βDestinationReview whether sensitive services are exposed more broadly than required.
34. Common Network Exposure
Section titled β34. Common Network ExposureβExamples requiring investigation include:
Administrative Services β Internet
Database Services β Internet
Kubernetes Management β Internet
Internal Applications β InternetExposure alone does not establish exploitability, but it expands attack surface.
35. Network Segmentation
Section titled β35. Network SegmentationβCloud environments should separate workloads according to trust.
Example:
Internet βPublic Load Balancer βApplication Tier βDatabase TierNot:
Internet βEverything36. Cloud Peering
Section titled β36. Cloud PeeringβCloud networks may connect through peering or similar mechanisms.
Example:
Development Network βPeering βProduction NetworkReview:
Routing
Firewall Rules
Trust Direction
DNS
Identity
Shared Services37. Hybrid Connectivity
Section titled β37. Hybrid ConnectivityβCloud environments may connect to on-premises networks through:
VPN
Private Connectivity
SD-WAN
Dedicated LinksConceptually:
Cloud βPrivate Connection βCorporate Network βActive DirectoryThis can create cloud-to-on-premises attack paths.
38. Compute Security
Section titled β38. Compute SecurityβCloud compute includes:
Virtual Machines
Managed Instances
Container Hosts
Autoscaling WorkloadsAssess both:
Operating System Security +Cloud Configuration39. Compute Security Questions
Section titled β39. Compute Security QuestionsβFor every cloud VM ask:
Is It Public?
Which Ports?
Which Identity Is Attached?
What Can That Identity Access?
How Is Administration Performed?
Are Patches Current?
Are Secrets Stored Locally?
Is Logging Enabled?40. Public IP Exposure
Section titled β40. Public IP ExposureβA VM with a public IP may be intentionally exposed.
Determine:
Why Public?
Which Services?
Which Source Networks?
Is a Load Balancer Better?
Is Administration Restricted?Do not automatically report every public IP.
41. Cloud Metadata Services
Section titled β41. Cloud Metadata ServicesβCloud workloads may access metadata services providing information about the workload and, depending on architecture, temporary credentials.
Conceptually:
Cloud Workload βMetadata Service βWorkload Information βTemporary Identity CredentialsThis makes metadata access security-sensitive.
42. Why Metadata Matters
Section titled β42. Why Metadata MattersβConsider:
Application Vulnerability βApplication Can Reach Metadata βWorkload Identity βCloud APIA web application issue may therefore become a cloud IAM issue.
43. SSRF-to-Cloud Concept
Section titled β43. SSRF-to-Cloud ConceptβServer-Side Request Forgery can sometimes allow an application to make unintended requests.
In cloud environments, a dangerous conceptual chain is:
SSRF βMetadata Access βTemporary Credential βCloud Permission βCloud ResourceModern cloud protections and secure application design should be used to break this path.
44. Metadata Defensive Controls
Section titled β44. Metadata Defensive ControlsβControls may include:
Modern Metadata Protections
Least-Privilege Workload Identity
Application Egress Restrictions
SSRF Prevention
Network Controls
MonitoringDo not depend on a single control.
45. Workload Identities
Section titled β45. Workload IdentitiesβModern cloud systems often avoid storing long-lived static credentials.
Instead:
Workload βAssigned Identity βTemporary Credential βCloud APIThis is generally stronger than embedding permanent API keys.
But the identity still requires least privilege.
46. Secrets Management
Section titled β46. Secrets ManagementβCloud applications need secrets such as:
API Keys
Database Credentials
Certificates
Tokens
Encryption KeysThese should not be scattered through application code and configuration.
47. Secret Exposure
Section titled β47. Secret ExposureβCommon locations worth reviewing include:
Source Code
Configuration Files
Environment Variables
Build Pipelines
Container Images
Deployment Templates
Logs
BackupsOnly inspect authorised repositories and resources.
48. Cloud Secret Managers
Section titled β48. Cloud Secret ManagersβCloud platforms provide managed secret storage services.
Examples include:
AWS Secrets Manager
Azure Key Vault
Google Secret ManagerThe presence of a secret manager does not automatically mean secrets are secure.
Review who can access it.
49. Secret Access Paths
Section titled β49. Secret Access PathsβExample:
Developer βCan Read Secret βDatabase Credential βProduction DatabaseThe real permission may be hidden behind secret access.
50. Encryption Keys
Section titled β50. Encryption KeysβCloud Key Management Services control encryption keys.
Key access may permit:
Encrypt
Decrypt
Sign
Verify
Key AdministrationCryptographic permissions should be reviewed separately from resource permissions.
51. Serverless Security
Section titled β51. Serverless SecurityβServerless platforms include:
AWS Lambda
Azure Functions
Google Cloud FunctionsArchitecture:
Event βFunction βWorkload Identity βCloud ResourcesThe functionβs identity becomes particularly important.
52. Serverless Attack Surface
Section titled β52. Serverless Attack SurfaceβReview:
Trigger
Input Validation
Authentication
Function Code
Environment Variables
Secrets
IAM Role
Network Access
LoggingA vulnerable function may provide a bridge into cloud resources.
53. Serverless Privilege Path
Section titled β53. Serverless Privilege PathβExample:
Public Function βApplication Weakness βFunction Execution Context βOverprivileged Role βSensitive StorageThe application issue and IAM misconfiguration combine into one attack path.
54. Containers in Cloud Environments
Section titled β54. Containers in Cloud EnvironmentsβCloud environments frequently run containers through:
Managed Container Platforms
Kubernetes
Serverless Containers
Virtual MachinesContainer security involves both:
Container Security +Cloud Identity Security55. Container Image Security
Section titled β55. Container Image SecurityβReview images for:
Outdated Components
Embedded Secrets
Unnecessary Tools
Unsafe Configuration
Excessive PrivilegeContainer images should be treated as software supply-chain artifacts.
56. Container Registry Security
Section titled β56. Container Registry SecurityβRegistries may contain proprietary application images.
Review:
Public Exposure
Push Permissions
Pull Permissions
Administrative Rights
Image Signing
Vulnerability ScanningUnauthorised write access can create supply-chain risk.
57. Kubernetes Security
Section titled β57. Kubernetes SecurityβCloud Kubernetes environments combine several security layers:
Cloud IAM βKubernetes Authentication βKubernetes RBAC βWorkloads βService Accounts βCloud ResourcesThis creates complex cross-layer attack paths.
58. Kubernetes Security Questions
Section titled β58. Kubernetes Security QuestionsβAssess:
API Server Exposure
Authentication
RBAC
Namespaces
Service Accounts
Secrets
Pod Security
Network Policies
Container Privileges
Cloud Identity Integration59. Kubernetes Privilege Path
Section titled β59. Kubernetes Privilege PathβExample:
Developer βCan Create Pod βPod Uses Powerful Service Account βService Account βSensitive Kubernetes ResourcesAgain, permissions must be analysed in combination.
60. Kubernetes-to-Cloud Attack Path
Section titled β60. Kubernetes-to-Cloud Attack PathβModern Kubernetes clusters may provide workloads with cloud identities.
Conceptually:
Pod βKubernetes Service Account βCloud Workload Identity βCloud IAM βStorage / Database / SecretsA Kubernetes compromise can therefore become a cloud compromise.
61. CI/CD Security
Section titled β61. CI/CD SecurityβCloud environments depend heavily on deployment pipelines.
Typical flow:
Developer βSource Repository βCI/CD βCloud Credential βProduction DeploymentThe pipeline is part of the cloud attack surface.
62. CI/CD Questions
Section titled β62. CI/CD QuestionsβReview:
Who Can Modify Pipeline?
Which Credentials Exist?
Which Cloud Roles?
Can Developers Trigger Production?
Are Secrets Protected?
Are Branch Controls Enforced?
Are Actions Logged?63. CI/CD Privilege Path
Section titled β63. CI/CD Privilege PathβExample:
Repository Contributor βModify Pipeline βPipeline Uses Deployment Identity βProduction CloudA source-code permission may therefore become a production cloud privilege.
64. Infrastructure as Code
Section titled β64. Infrastructure as CodeβCloud infrastructure is often deployed through:
Terraform
CloudFormation
Bicep
ARM Templates
Other IaC PlatformsIaC repositories can reveal the intended cloud architecture.
65. IaC Security
Section titled β65. IaC SecurityβReview for:
Public Resources
Weak IAM
Open Firewall Rules
Embedded Secrets
Missing Encryption
Unsafe Defaults
Overprivileged WorkloadsFinding weaknesses before deployment is preferable to discovering them in production.
66. Cloud API Keys
Section titled β66. Cloud API KeysβLong-lived access keys create significant risk when poorly managed.
Review:
Age
Owner
Purpose
Last Use
Permissions
Storage Location
Rotation
Whether Still RequiredPrefer temporary credentials where supported.
67. Exposed Credentials
Section titled β67. Exposed CredentialsβPotential exposure locations include:
Public Repository
Developer Laptop
CI/CD Log
Container Image
Backup
Configuration File
Support TicketAn exposed credential should immediately trigger permission and blast-radius analysis.
68. Credential Blast Radius
Section titled β68. Credential Blast RadiusβDo not stop at:
We found a cloud key.
Determine:
Credential βIdentity βPermissions βResources βAssumable Roles βCritical AssetsThis determines actual severity.
69. Temporary Credentials
Section titled β69. Temporary CredentialsβTemporary credentials generally reduce long-term exposure.
But they can still be abused while valid.
Security therefore requires:
Short Lifetime +Least Privilege +Secure Delivery +Monitoring70. Role Assumption
Section titled β70. Role AssumptionβCloud platforms support mechanisms for identities to obtain other roles.
Conceptually:
Identity A βTrusted by Role B βAssume Role B βNew PermissionsTrust configuration must be carefully reviewed.
71. Cross-Account Trust
Section titled β71. Cross-Account TrustβLarge enterprises often connect cloud accounts.
Example:
Security Account βTrust βProduction AccountCross-account access is not inherently dangerous.
The question is whether trust is appropriately constrained.
72. Cross-Account Attack Path
Section titled β72. Cross-Account Attack PathβExample:
Development Identity βAssumable Role βShared Services βProduction Role βProduction ResourcesThe attack path may cross several account boundaries.
73. Azure Cross-Scope Privilege
Section titled β73. Azure Cross-Scope PrivilegeβAzure permissions may inherit through:
Management Group βSubscription βResource Group βResourceA role assigned high in the hierarchy can have a much larger blast radius than expected.
74. Google Cloud Inheritance
Section titled β74. Google Cloud InheritanceβGoogle Cloud IAM can similarly inherit through its resource hierarchy.
Always determine:
Where Was Permission Assigned?
Where Does It Apply?
What Inherits It?Scope is fundamental to cloud privilege analysis.
75. Multi-Cloud Environments
Section titled β75. Multi-Cloud EnvironmentsβEnterprises may operate:
AWS +Azure +Google Cloud +SaaSThese environments may share:
Identity
CI/CD
Secrets
Networking
MonitoringA compromise in one platform may create paths into another.
76. Multi-Cloud Attack Path
Section titled β76. Multi-Cloud Attack PathβExample:
Corporate Identity βCI/CD Platform βAWS Deployment Role βShared Secret βAzure ApplicationCloud boundaries do not necessarily equal security boundaries.
77. Cloud SSO
Section titled β77. Cloud SSOβEnterprises often use central identity providers.
Conceptually:
Corporate Identity βSSO βAWSAzureGCPSaaSCompromise of the central identity system can create a very large blast radius.
78. MFA
Section titled β78. MFAβPrivileged cloud identities should generally use strong authentication.
MFA can reduce account takeover risk.
But MFA does not fix:
Excessive Permissions
Weak Workload Identities
Exposed API Keys
Unsafe Trust Policies
Misconfigured ResourcesIdentity security requires multiple layers.
79. Break-Glass Accounts
Section titled β79. Break-Glass AccountsβOrganisations may maintain emergency administrative accounts.
Review:
Purpose
Credential Protection
Monitoring
Testing
Access Restrictions
Usage HistoryEmergency access should not become an unmonitored permanent backdoor.
80. Root Accounts and Equivalent Identities
Section titled β80. Root Accounts and Equivalent IdentitiesβSome platforms provide extremely powerful top-level identities.
These should receive exceptional protection.
Ask:
Is Daily Use Prevented?
Is MFA Enabled?
Are Credentials Protected?
Is Activity Monitored?
Are Access Keys Disabled Where Possible?81. Cloud Logging
Section titled β81. Cloud LoggingβCloud security depends heavily on control-plane logging.
Important events may include:
Authentication
API Calls
IAM Changes
Resource Creation
Network Changes
Storage Changes
Key Access
Secret Access
Logging Changes82. AWS Logging
Section titled β82. AWS LoggingβAWS environments commonly use services such as:
CloudTrail
CloudWatch
AWS Config
Security Hub
GuardDutyAn Ethical Hacker should understand whether relevant security activity becomes visible.
83. Azure Logging
Section titled β83. Azure LoggingβAzure environments may use:
Azure Activity Logs
Microsoft Entra Logs
Azure Monitor
Defender for Cloud
Microsoft SentinelIdentity and control-plane telemetry should be considered together.
84. Google Cloud Logging
Section titled β84. Google Cloud LoggingβGoogle Cloud environments provide services such as:
Cloud Audit Logs
Cloud Logging
Security Command CenterThe exact tooling matters less than the question:
Can the organisation reconstruct important cloud security activity?
85. Logging Is a Security Control
Section titled β85. Logging Is a Security ControlβSuppose:
Compromised Identity βReads Secret βCreates New Credential βModifies FirewallA mature environment should have telemetry for these high-risk activities.
86. Logging Tampering
Section titled β86. Logging TamperingβAttackers with sufficient privilege may attempt to:
Disable Logging
Delete Logs
Modify Retention
Change DestinationsTherefore logging infrastructure itself must be protected.
87. Centralised Logging
Section titled β87. Centralised LoggingβA stronger architecture may use:
Workload Accounts βCentral Security Account βProtected LogsSeparating security telemetry from workloads makes tampering more difficult.
88. Cloud Detection Engineering
Section titled β88. Cloud Detection EngineeringβPotential detections include:
Unusual Authentication
New Access Keys
Privilege Changes
Public Storage Changes
Firewall Changes
Secret Access
Cross-Account Role Assumption
Logging DisabledDuring testing ask:
Would the security team detect this activity?
89. Cloud Security Posture Management
Section titled β89. Cloud Security Posture ManagementβOrganisations may use posture-management capabilities to identify:
Misconfigurations
Policy Violations
Public Exposure
Weak IAM
Compliance IssuesAutomated posture tools are useful but should not replace attack-path analysis.
90. Scanner Finding vs Attack Path
Section titled β90. Scanner Finding vs Attack PathβA scanner might report:
Storage Logging DisabledAnother finding:
Role Is OverprivilegedAnother:
Application Is PublicAttack-path analysis may reveal:
Public Application βApplication Weakness βWorkload Role βSensitive Storage βLogging GapThe combined story is much more valuable.
91. Cloud Attack Path Analysis
Section titled β91. Cloud Attack Path AnalysisβFor each initial foothold ask:
What Identity?
What Permissions?
What Resources?
What Secrets?
What Trust?
What Networks?
What Other Identities?
What Can Be Modified?
What Can Be Assumed?
What Is the Final Impact?92. Attack Path Example β Exposed Credential
Section titled β92. Attack Path Example β Exposed CredentialβPublic Repository βCloud Credential βDeveloper Identity βRead Secret βDatabase Credential βProduction DatabaseThe exposed key is only the beginning.
93. Attack Path Example β Workload Identity
Section titled β93. Attack Path Example β Workload IdentityβWeb Application βApplication Vulnerability βWorkload Context βOverprivileged Role βSecret Manager βProduction CredentialThis combines application and cloud security.
94. Attack Path Example β CI/CD
Section titled β94. Attack Path Example β CI/CDβDeveloper Account βRepository Write βPipeline Modification βDeployment Identity βProduction CloudSoftware supply-chain permissions become cloud permissions.
95. Attack Path Example β Hybrid Identity
Section titled β95. Attack Path Example β Hybrid IdentityβCloud Workload βHybrid Connectivity βOn-Premises Server βActive Directory βPrivileged IdentityCloud testing can connect directly to the Active Directory techniques studied earlier.
96. Attack Path Example β Kubernetes
Section titled β96. Attack Path Example β KubernetesβApplication βContainer βKubernetes Service Account βCloud Workload Identity βCloud Secrets βProduction ResourceModern attack paths cross technology layers.
97. Think in Security Boundaries
Section titled β97. Think in Security BoundariesβMap:
Internet
Cloud Edge
Account
Subscription
Project
Virtual Network
Subnet
Workload
Identity
Management Plane
DataThen ask:
What controls movement between these boundaries?
98. Cloud Privilege Is Often Indirect
Section titled β98. Cloud Privilege Is Often IndirectβAn identity may not have:
Administratorbut may have:
Modify Function
Pass Role
Create Deployment
Modify Policy
Read SecretOne or more of these permissions may indirectly provide greater privilege.
99. Read vs Write Permissions
Section titled β99. Read vs Write PermissionsβDo not assume write permissions are the only dangerous permissions.
Read access may expose:
Secrets
Credentials
Private Keys
Source Code
Backups
Sensitive DataThese can create new attack paths.
100. Resource Creation Permissions
Section titled β100. Resource Creation PermissionsβThe ability to create resources can also matter.
Ask:
Can Identity Create Compute?
Can It Attach an Identity?
Can It Create Credentials?
Can It Modify Networking?
Can It Trigger Automation?Cloud permissions should always be analysed for downstream effects.
101. Destructive Cloud Operations
Section titled β101. Destructive Cloud OperationsβCloud APIs can perform destructive actions very quickly.
Examples include:
Delete Storage
Terminate Compute
Delete Database
Modify IAM
Disable LoggingDo not perform destructive validation unless explicitly authorised and safely planned.
102. Minimum Necessary Validation
Section titled β102. Minimum Necessary ValidationβSuppose you prove an identity has permission to delete a production database.
You generally do not need to:
Delete the database.
Instead document:
Identity
Permission
Resource
Policy Evidence
Potential ImpactThe evidence may already establish the risk.
103. Cloud Evidence Collection
Section titled β103. Cloud Evidence CollectionβFor each finding capture:
Evidence ID
Cloud Provider
Account / Subscription / Project
Identity
Resource
Region
Permission
Configuration
Relevant Output
TimestampCloud environments can change quickly, so timestamps matter.
104. Avoid Sensitive Data Collection
Section titled β104. Avoid Sensitive Data CollectionβIf storage access is being validated:
Confirm Access βCollect Minimum Evidence βStopDo not download large quantities of customer or production data merely to demonstrate access.
105. Example Evidence
Section titled β105. Example EvidenceβEvidence ID:CLOUD-EV-017
Provider:AWS
Account:Production
Identity:ApplicationRole
Resource:CustomerDataBucket
Observation:The application workload identity possesses read access to the production customer-data storage resource beyond its documented operational requirement.
Validation:Permission relationship confirmed without downloading customer records.106. Example Finding β Excessive Workload Privilege
Section titled β106. Example Finding β Excessive Workload PrivilegeβCLOUD-001 β Application Workload Identity Has Excessive Access to Production Resources
Section titled βCLOUD-001 β Application Workload Identity Has Excessive Access to Production ResourcesβObservation
Section titled βObservationβThe application workload identity possessed permissions to access cloud resources beyond those required for its documented function.
Attack Scenario
Section titled βAttack ScenarioβAn attacker compromising the application could inherit the workload identity and use its cloud permissions to access additional production resources.
Successful exploitation could expand an application compromise into broader cloud data or infrastructure compromise.
Recommendation
Section titled βRecommendationβReduce the workload identity to the minimum required permissions and continuously review effective permissions.
107. Example Finding β Public Storage
Section titled β107. Example Finding β Public StorageβCLOUD-002 β Sensitive Cloud Storage Is Publicly Accessible
Section titled βCLOUD-002 β Sensitive Cloud Storage Is Publicly AccessibleβObservation
Section titled βObservationβA cloud storage resource containing non-public organisational information was accessible without the intended authenticated access controls.
Unauthorised parties could potentially access sensitive information.
Recommendation
Section titled βRecommendationβRemove unintended public access, enforce centrally managed public-access restrictions, review historical access logs, and classify affected data.
108. Example Finding β Overly Broad Administrative Exposure
Section titled β108. Example Finding β Overly Broad Administrative ExposureβCLOUD-003 β Cloud Administrative Service Is Exposed to Untrusted Networks
Section titled βCLOUD-003 β Cloud Administrative Service Is Exposed to Untrusted NetworksβObservation
Section titled βObservationβAdministrative connectivity to a cloud-hosted workload was permitted from broad internet address ranges.
Broad network exposure increases the attack surface of administrative services and may enable credential-based or vulnerability-based attacks.
Recommendation
Section titled βRecommendationβRestrict administrative access to approved management networks, VPN infrastructure, private access mechanisms, or identity-aware administrative services.
109. Example Finding β Long-Lived Access Key
Section titled β109. Example Finding β Long-Lived Access KeyβCLOUD-004 β Long-Lived Cloud Credential Remains Active
Section titled βCLOUD-004 β Long-Lived Cloud Credential Remains ActiveβObservation
Section titled βObservationβA long-lived access credential associated with a human or automation identity remained active beyond the organisationβs expected credential lifecycle.
Long-lived credentials increase the window in which accidental exposure can lead to unauthorised cloud access.
Recommendation
Section titled βRecommendationβRemove unnecessary static credentials and prefer temporary, identity-based authentication mechanisms.
110. Example Finding β Excessive Cross-Account Trust
Section titled β110. Example Finding β Excessive Cross-Account TrustβCLOUD-005 β Production Role Trusts a Broad External Identity Scope
Section titled βCLOUD-005 β Production Role Trusts a Broad External Identity ScopeβObservation
Section titled βObservationβA privileged production role could be assumed by a broader set of identities from another cloud account than required.
Attack Scenario
Section titled βAttack ScenarioβCompromise of an authorised identity in the trusted account could provide a path into production resources.
Recommendation
Section titled βRecommendationβRestrict trust to explicitly required identities and conditions and periodically review cross-account trust relationships.
111. Example Finding β Inadequate Cloud Logging
Section titled β111. Example Finding β Inadequate Cloud LoggingβCLOUD-006 β Critical Control-Plane Activity Is Not Centrally Retained
Section titled βCLOUD-006 β Critical Control-Plane Activity Is Not Centrally RetainedβObservation
Section titled βObservationβSecurity-relevant cloud management events were not consistently forwarded to a protected central logging environment.
An attacker obtaining sufficient cloud privilege could perform high-impact actions while reducing the organisationβs ability to investigate the incident.
Recommendation
Section titled βRecommendationβEnable comprehensive control-plane logging, centralise telemetry in a protected security environment, restrict log modification, and monitor logging configuration changes.
112. Root Cause Analysis
Section titled β112. Root Cause AnalysisβSuppose you discover:
Overprivileged Users
Overprivileged Workloads
Broad Cross-Account Trust
Excessive Service RolesThe root cause may be:
Weak cloud IAM governance and insufficient least-privilege engineering.
This is more useful than reporting dozens of unrelated IAM observations.
113. Cloud Security Themes
Section titled β113. Cloud Security ThemesβCommon themes include:
Identity Governance
Section titled βIdentity GovernanceβWho has cloud access?
Privileged Access
Section titled βPrivileged AccessβWho can control the environment?
Workload Identity
Section titled βWorkload IdentityβWhat can applications become?
Network Exposure
Section titled βNetwork ExposureβWhich resources are reachable?
Data Security
Section titled βData SecurityβWho can access sensitive data?
Secret Management
Section titled βSecret ManagementβWhere are credentials stored?
Which accounts, tenants, projects, and systems trust one another?
Monitoring
Section titled βMonitoringβCan suspicious cloud activity be detected?
114. Cloud Attack Surface Workbook
Section titled β114. Cloud Attack Surface WorkbookβCreate:
| Resource | Exposure | Identity | Data | Trust | Risk |
|---|---|---|---|---|---|
| Web App | Public | AppRole | Customer | Internal API | Review |
| VM01 | Private | VMRole | None | AD | Review |
| Bucket01 | Restricted | StorageRole | Sensitive | Cross-account | High |
| Function01 | Public | FunctionRole | API | Database | Review |
This becomes the foundation of your attack-path analysis.
115. Cloud Identity Workbook
Section titled β115. Cloud Identity WorkbookβCreate:
| Identity | Type | Role | Scope | Privilege | MFA |
|---|---|---|---|---|---|
| Alice | Human | Developer | Dev | Medium | Yes |
| AppRole | Workload | Custom | Production | High | N/A |
| CICD | Automation | Deployment | Production | Critical | N/A |
Pay particular attention to machine identities.
116. Cloud Trust Register
Section titled β116. Cloud Trust RegisterβDocument:
Account A βTrusts Role βAccount Bor:
Azure Tenant βFederated Identity βCI/CD Platformor:
Kubernetes βWorkload Identity βCloud IAMTrust mapping often reveals hidden paths.
117. Practical Lab Scenario
Section titled β117. Practical Lab ScenarioβAssume an isolated training AWS environment:
Training Accountββββ Web Applicationβββ EC2 Instanceβββ S3 Bucketβββ IAM Roleβββ Lambda Functionβββ CloudTrailYou are provided an authorised low-privilege training identity:
lab-developerYour mission:
Determine whether the identity or workloads possess unnecessary paths to sensitive cloud resources.
118. Step 1 β Confirm Scope
Section titled β118. Step 1 β Confirm ScopeβDocument:
Account:Training Account
Identity:lab-developer
Allowed:IAM EnumerationResource EnumerationConfiguration ReviewControlled Permission Validation
Not Allowed:DoSResource DeletionProduction AccessUnapproved Accounts119. Step 2 β Establish Identity
Section titled β119. Step 2 β Establish IdentityβDetermine:
Who Am I?
Which Account?
Which Roles?
Which Policies?
Which Session?This establishes your initial position.
120. Step 3 β Enumerate Resources
Section titled β120. Step 3 β Enumerate ResourcesβBuild:
Training Accountββββ WEB01βββ AppBucketβββ ApplicationRoleβββ ProcessorFunctionβββ Audit LoggingDo not immediately attempt privilege escalation.
Understand the environment first.
121. Step 4 β Analyse Current Permissions
Section titled β121. Step 4 β Analyse Current PermissionsβSuppose:
lab-developer βCan Modify βProcessorFunctionAt first glance this appears to be application-development access.
Continue analysing.
122. Step 5 β Inspect Workload Identity
Section titled β122. Step 5 β Inspect Workload IdentityβSuppose:
ProcessorFunction βUses βApplicationRoleNow determine what the role can access.
123. Step 6 β Identify Sensitive Permission
Section titled β123. Step 6 β Identify Sensitive PermissionβSuppose:
ApplicationRole βCan Read βSensitive Application SecretYour emerging path becomes:
lab-developer βModify Function βFunction Uses ApplicationRole βApplicationRole βSensitive Secret124. Step 7 β Validate Without Extracting the Secret
Section titled β124. Step 7 β Validate Without Extracting the SecretβYou may already have enough evidence from:
Developer Permission
Function Configuration
Role Assignment
Role Policy
Secret PermissionDo not retrieve the production-like secret simply because you can.
Use minimum necessary validation.
125. Step 8 β Build the Attack Path
Section titled β125. Step 8 β Build the Attack PathβDocument:
Developer Identity βFunction Modification Permission βPrivileged Workload Context βApplicationRole βSecret Access βPotential Production Resource AccessThis explains the security impact.
126. Step 9 β Determine Root Cause
Section titled β126. Step 9 β Determine Root CauseβPotential root causes:
Excessive Developer Permission
Overprivileged Workload Role
Insufficient Separation of DutiesMultiple controls contributed to the path.
127. Step 10 β Recommend Controls
Section titled β127. Step 10 β Recommend ControlsβPotential remediation:
-
Restrict who can modify the function.
-
Reduce
ApplicationRolepermissions. -
Separate development and production administration.
-
Scope secret access to required resources.
-
Monitor function and IAM modifications.
-
Use automated IAM policy analysis.
-
Periodically review cloud attack paths.
128. Step 11 β Retest
Section titled β128. Step 11 β RetestβAfter remediation verify:
Developer βRequired Development Actions β
Developer βPrivileged Workload Path XSecurity fixes should remove the attack path without unnecessarily breaking legitimate workflows.
129. Cloud + Active Directory
Section titled β129. Cloud + Active DirectoryβCloud environments often connect to enterprise identity.
Example:
Active Directory βIdentity Federation βCloud SSO βCloud RolesA compromised enterprise identity may therefore provide cloud access.
130. Active Directory + Cloud Attack Path
Section titled β130. Active Directory + Cloud Attack PathβExample:
Standard Domain User βAD Privilege Path βCloud Administrator βSSO βCloud ManagementThe previous Active Directory module directly connects to cloud security.
131. Wireless + Cloud Attack Path
Section titled β131. Wireless + Cloud Attack PathβConsider:
Corporate Wireless βManaged Endpoint βEnterprise Identity βCloud SSO βCloud ResourcesSecurity domains connect together.
132. Web + Cloud Attack Path
Section titled β132. Web + Cloud Attack PathβExample:
Public Web Application βApplication Weakness βCloud Workload βWorkload Identity βCloud API βSensitive ResourceThis is one of the most important cloud attack-path patterns to understand.
133. Cloud + CI/CD Attack Path
Section titled β133. Cloud + CI/CD Attack PathβExample:
Developer βSource Repository βPipeline βDeployment Identity βCloud ProductionCloud security increasingly includes software supply-chain security.
134. Cloud + Kubernetes Attack Path
Section titled β134. Cloud + Kubernetes Attack PathβExample:
Application βPod βKubernetes Identity βCloud Identity βCloud Control PlaneModern attackers follow identities across platforms.
135. Think Like an Ethical Hacker
Section titled β135. Think Like an Ethical HackerβWhen you discover:
Cloud Credentialdo not stop at:
Credential found.
Think:
Which Identity? βWhich Permissions? βWhich Roles? βWhich Resources? βWhich Secrets? βWhich Trusts? βWhich Final Impact?When you discover:
Public Storagethink:
What Data? βRead or Write? βIntentional? βAuthentication? βBusiness Impact?When you discover:
Workload Identitythink:
Which Workload? βWho Controls Workload? βWhich Permissions? βWhich Secrets? βCan Privilege Expand?136. Think Like the Defender
Section titled β136. Think Like the DefenderβFor every attack path ask:
Which Control Prevents It?
Which Control Detects It?
Who Owns the Control?
How Is It Tested?
How Is It Continuously Monitored?Example:
Compromised Application βOverprivileged Role βSensitive StoragePreventive controls:
Least Privilege
Workload Isolation
Scoped Storage PolicyDetective controls:
Cloud API Logging
Anomalous Access Detection
Storage Access Monitoring137. Common Cloud Testing Mistakes
Section titled β137. Common Cloud Testing MistakesβTreating Cloud Like a Traditional Network
Section titled βTreating Cloud Like a Traditional NetworkβCloud APIs and identities are part of the attack surface.
Running Tools Before Understanding Identity
Section titled βRunning Tools Before Understanding IdentityβAlways establish your current security context first.
Reporting Every Public Resource
Section titled βReporting Every Public ResourceβPublic exposure may be intentional.
Ignoring Workload Identities
Section titled βIgnoring Workload IdentitiesβApplications can possess powerful cloud privileges.
Ignoring Permission Combinations
Section titled βIgnoring Permission CombinationsβTwo low-risk permissions may combine into a critical path.
Ignoring CI/CD
Section titled βIgnoring CI/CDβDeployment systems frequently hold production privilege.
Ignoring Cross-Account Trust
Section titled βIgnoring Cross-Account TrustβAttack paths may cross account boundaries.
Ignoring Hybrid Identity
Section titled βIgnoring Hybrid IdentityβCloud and Active Directory may share the same identity plane.
Ignoring Kubernetes
Section titled βIgnoring KubernetesβCloud-native workloads can bridge Kubernetes and cloud IAM.
Downloading Sensitive Data as Proof
Section titled βDownloading Sensitive Data as ProofβUse minimum necessary validation.
Performing Destructive Actions
Section titled βPerforming Destructive ActionsβCloud APIs can create irreversible impact very quickly.
Trusting Scanner Severity
Section titled βTrusting Scanner SeverityβAlways determine the real business attack path.
138. Cloud Security Testing Checklist
Section titled β138. Cloud Security Testing Checklistβ[ ] Authorization confirmed[ ] Provider rules reviewed[ ] Accounts / subscriptions / projects scoped[ ] Regions scoped[ ] Current identity established[ ] Human identities reviewed[ ] Machine identities reviewed[ ] MFA reviewed[ ] Privileged identities identified[ ] Effective permissions analysed[ ] Role assumption reviewed[ ] Cross-account trust reviewed[ ] External attack surface mapped[ ] Public resources reviewed[ ] Storage reviewed[ ] Network exposure reviewed[ ] Segmentation reviewed[ ] Peering reviewed[ ] Hybrid connectivity reviewed[ ] Compute reviewed[ ] Workload identities reviewed[ ] Metadata protections reviewed[ ] Secrets reviewed[ ] Encryption keys reviewed[ ] Serverless reviewed[ ] Containers reviewed[ ] Registries reviewed[ ] Kubernetes reviewed[ ] CI/CD reviewed[ ] Infrastructure as Code reviewed[ ] Long-lived credentials reviewed[ ] Logging reviewed[ ] Detection reviewed[ ] Attack paths developed[ ] Sensitive data minimised[ ] Evidence collected[ ] Findings validated[ ] Root causes identified[ ] Recommendations developed[ ] Retesting completed[ ] Cleanup completed139. Build Your Cloud Security Testing Toolkit
Section titled β139. Build Your Cloud Security Testing ToolkitβCreate:
Cloud Security Testing Toolkit/ββββ 01 Cloud Scope Templateβββ 02 Provider Testing Rulesβββ 03 Account Inventoryβββ 04 Identity Inventoryβββ 05 IAM Reviewβββ 06 Privilege Path Analysisβββ 07 Storage Reviewβββ 08 Network Reviewβββ 09 Compute Reviewβββ 10 Workload Identity Reviewβββ 11 Metadata Security Reviewβββ 12 Secrets Reviewβββ 13 Key Management Reviewβββ 14 Serverless Reviewβββ 15 Container Reviewβββ 16 Kubernetes Reviewβββ 17 CI-CD Reviewβββ 18 Infrastructure as Code Reviewβββ 19 Cross-Account Trust Reviewβββ 20 Hybrid Identity Reviewβββ 21 Logging Reviewβββ 22 Attack Path Registerβββ 23 Evidence Logβββ 24 Finding Templateβββ 25 Cloud Security Report Template140. The Most Important Cloud Questions
Section titled β140. The Most Important Cloud QuestionsβFor every identity ask:
Who or what owns it?
How does it authenticate?
What can it access?
What can it modify?
What identities can it assume?
Can it modify IAM?
Can it access secrets?
For every workload ask:
Who can modify it?
Which identity does it use?
What permissions does that identity have?
What network access exists?
What secrets are available?
For every resource ask:
Is it externally exposed?
Who can read it?
Who can modify it?
Which identities trust it?
What sensitive data exists?
For every cloud environment ask:
If the initial identity is compromised, how far can an attacker go?
That is the central cloud security testing question.
141. Definition of Success
Section titled β141. Definition of SuccessβA successful cloud security assessment is not:
I found 100 misconfigurations.
It is not:
I ran a cloud scanner.
It is not:
I obtained administrator access.
Success means understanding:
Initial Exposure βIdentity βPermission βCloud Resource βWorkload βSecret / Trust βPrivilege βControl Plane βSensitive Asset βBusiness Impactand identifying where the organisation should break the path.
Key Takeaways
Section titled βKey TakeawaysβCloud security testing is fundamentally different from traditional infrastructure testing.
Remember:
Identity is one of the most important cloud security boundaries.
Cloud permissions must be analysed for indirect privilege, not merely direct privilege.
Human and machine identities both matter.
A workload compromise may become a cloud control-plane compromise.
Metadata services and workload identities require careful protection.
Public resources must be evaluated in business context.
Strong storage security requires both access control and data governance.
Cloud network segmentation still matters.
Secrets should not be embedded in code, images, pipelines, or configuration.
Serverless functions carry identities and permissions.
Kubernetes can create paths into cloud IAM.
CI/CD systems are part of the cloud security boundary.
Cross-account and cross-project trust can create hidden attack paths.
Hybrid identity connects cloud security with Active Directory security.
Logging and detection must protect the cloud control plane.
Do not perform destructive actions merely to prove permission.
The attack path matters more than the individual misconfiguration.
Your core methodology is:
Scope βEstablish Identity βDiscover Resources βMap Exposure βAnalyse IAM βAnalyse Network βAnalyse Data βAnalyse Workloads βAnalyse Secrets βAnalyse Trust βIdentify Privilege Paths βBuild Attack Paths βValidate Safely βCollect Evidence βReport βRemediate βRetestThe strongest Cloud Ethical Hackers understand:
identity, permissions, APIs, resources, workloads, secrets, networking, trust relationships, attack paths, detection, and business impact.
Whatβs Next?
Section titled βWhatβs Next?ββ‘οΈ 07 β Red Team Fundamentals
In the next module, you will move from testing individual security domains into understanding how adversary behaviour is simulated across an enterprise.
You will learn:
-
Red team fundamentals
-
Red team vs penetration testing
-
Adversary emulation
-
Threat intelligence
-
Rules of engagement
-
Operational security
-
Attack infrastructure concepts
-
Initial access
-
Execution
-
Persistence concepts
-
Privilege escalation
-
Credential access
-
Discovery
-
Lateral movement
-
Command-and-control concepts
-
Defense evasion
-
Collection
-
Exfiltration concepts
-
MITRE ATT&CK
-
Attack chains
-
Detection validation
-
Purple teaming
-
Evidence collection
-
Red team reporting
You will move from asking:
Can this cloud environment be compromised through identity, configuration, workload, or trust weaknesses?
to asking:
Can we safely simulate a realistic adversary across multiple enterprise security controls and determine whether the organisation can prevent, detect, and respond to the attack?