Cloud systems concentrate capability behind managed services, APIs, identities, and automation. That can make diagrams look simpler while the actual trust model becomes more complex. Threat modeling in ISC2 CISSP is the disciplined process of identifying assets, trust boundaries, entry points, attackers, abuse paths, mitigations, and residual risk before those assumptions are tested by an incident.
NIST research on cloud threat modeling has used techniques such as attack surfaces, attack trees, and attack graphs to reason about complex cloud infrastructures. No single method is mandatory for a useful model. The value comes from asking structured adversarial questions about the real architecture and carrying the findings into design, backlog, validation, and monitoring.
Within security architecture, the cloud model should explicitly include shared-responsibility boundaries. A managed database may remove operating-system patching from the customer, but the customer still owns identities, data access, network exposure, configuration, application logic, and many forms of monitoring.
Model the business service, not only the cloud diagram
Threat modeling starts with what the system does and what would matter if it failed. Identify sensitive data, critical transactions, privileged actions, secrets, availability dependencies, and high-value identities. A list of cloud resources without business context makes it difficult to prioritize threats.
Data-flow diagrams are useful because they reveal movement. Show where data enters, how it is transformed, where it is stored, which identities cross boundaries, and which external services participate. Trust boundaries should include not only networks but also tenants, accounts, subscriptions, namespaces, identity domains, CI/CD systems, and third-party APIs.
Cloud shared responsibility should be visible in the model. For each control, know whether the cloud provider, platform team, application team, security team, or external vendor is expected to operate it.
Define the security objective for each critical flow. A payment request may require integrity and non-repudiation; a patient record may emphasize confidentiality; a control-plane API may prioritize authorization and auditability. Threats become easier to rank when the model states which security property an attacker is trying to break.
Identity paths are often more important than network paths
Cloud control planes are API-driven. An attacker who obtains an over-privileged workload identity may not need to exploit a network service at all; the attacker can use legitimate management APIs to read secrets, create credentials, alter logging, or deploy resources.
Model human administrators, service principals, managed identities, instance roles, CI/CD identities, federated partners, and emergency accounts separately. Ask how credentials are issued, where they can be used, what permissions they have, and how compromise would be detected.
Privilege escalation paths deserve explicit attention. A role that cannot directly read data may still be able to attach a more privileged role, modify a function that has access, change a policy, or deploy code into a trusted workload.
Federation creates additional paths. A compromised upstream identity provider, overly broad trust relationship, or weak claim mapping can grant cloud access without stealing a cloud-native credential. Threat models should include how external identities are mapped to local roles, which claims are trusted, and what happens when the federation relationship must be disabled quickly.
Attack surface includes control plane, data plane, and supply chain
The control plane changes configuration and permissions. The data plane handles application traffic and information. The software supply chain determines what code and infrastructure definitions reach both planes. Threat models should cover all three because attackers can move between them.
Attack-surface discovery should include public endpoints, management interfaces, exposed storage, identity providers, package registries, artifact repositories, webhooks, serverless triggers, and administrative tooling. A forgotten test endpoint can create the same business impact as a flaw in the primary application.
Ephemeral infrastructure also matters. Short-lived build runners, preview environments, temporary credentials, and dynamically created storage can escape inventories if the threat model assumes everything is long-lived.
Infrastructure as code belongs in the attack surface because it can create or modify every other control. Protect repositories, state files, deployment identities, policy modules, and plan approvals. A malicious infrastructure change can open storage, weaken logging, or create privileged identities while leaving application source code untouched.
Use structured threat categories without letting the method become the goal
STRIDE is useful for asking about spoofing, tampering, repudiation, information disclosure, denial of service, and elevation of privilege. Attack trees start from an attacker objective and decompose ways to achieve it. Abuse cases describe how legitimate features could be misused. Attack graphs help reason about multi-step paths.
The method should match the system and team. A small service may only need a focused flow review; a critical platform may justify deeper attack-path analysis. The important output is a set of credible threats tied to mitigations and owners.
Do not confuse a brainstorming list with a finished threat model. Findings should record the affected asset, preconditions, likely impact, existing controls, gaps, and what will verify the mitigation.
Managed services remove some threats and introduce different assumptions
A managed service can eliminate customer responsibility for low-level patching, hardware, or cluster management, but it introduces reliance on service configuration, provider identities, regional availability, quotas, and documented platform behavior. The threat model should remove controls the customer cannot operate and focus on the controls it still owns.
Serverless and platform services can also create event-driven trust paths that are not obvious in network diagrams. Object uploads, queue messages, scheduled jobs, event buses, and webhook callbacks can all cause code to execute. Validate the identity and data at those boundaries.
Hybrid cloud security spans different identity, network, logging, and administrative domains, so the threat model must represent transitions between them rather than assess each environment in isolation. A threat can cross a federation, routing, synchronization, or administrative boundary even when the controls inside each environment are individually strong.
Service defaults should be treated as assumptions to verify, not permanent truths. A managed service can change capabilities, deprecate versions, add integration features, or alter default network behavior over time. Threat models should cite the configuration and service behavior they rely on so later reviewers know what must be revalidated.
Zero trust changes how the model treats location
A modern threat model should not assume that internal network location means trusted. NIST zero-trust guidance focuses policy on resources, identities, and context rather than static perimeter membership. Zero-trust identity architecture reduces implicit attack paths by requiring explicit authorization at resource boundaries and by making identity, device or workload state, and policy evaluation visible in the model.
This does not mean network controls disappear. Segmentation, private connectivity, egress restrictions, and service firewalls still reduce reachable attack surface. The difference is that network placement is one control signal rather than the source of identity or authorization.
Threat scenarios should include compromised internal workloads. Ask what happens if an attacker already controls one application instance, build runner, or administrator workstation. The answer reveals whether lateral movement depends on implicit trust.
Egress deserves equal attention. Private ingress does not prevent a compromised workload from sending data outward through DNS, allowed APIs, software-update channels, or broadly permitted internet access. Threat models should state which destinations and protocols workloads actually need. Verify those assumptions.
Model data exfiltration and destructive actions separately
Confidentiality threats often focus on reading sensitive data, but cloud attackers may also delete, corrupt, encrypt, or manipulate resources. A role that cannot download a database might still have permission to delete backups. A storage policy that prevents public reads may still allow an application identity to overwrite records.
Model protection and recovery together. Immutable backups, versioning, soft delete, cross-account recovery, and independent administrative paths can reduce destructive impact. Recovery credentials should not share every dependency with the production environment they are meant to restore.
For exfiltration, consider legitimate channels such as export APIs, logging sinks, backup copies, analytics replicas, support tools, and outbound network paths. Data can leave through allowed features without triggering a classic perimeter alert.
Backups deserve their own threat paths. An attacker who cannot alter production may target snapshot permissions, backup keys, retention locks, or recovery accounts. Model whether destructive access to production automatically grants destructive access to recovery assets; ideally it does not.
Threat models should evolve with architecture and incidents
A threat model is a snapshot of assumptions. New integrations, regions, identity providers, AI agents, managed services, or deployment paths can invalidate it. Architecture-change reviews should ask whether trust boundaries or attack paths changed enough to require an update.
Risk ranking should consider exploit path length and detectability in addition to raw impact. A catastrophic threat that requires five independently controlled compromises may deserve a different priority from a high-impact path reachable through one exposed credential. The model should make those preconditions explicit rather than reducing every threat to a color on a heat map.
Incidents and near misses are especially valuable inputs. If an attacker or red team found a path that the model missed, add that pattern to future reviews. If a mitigation generated excessive operational friction and was bypassed, revise the design rather than keeping an ineffective control on paper.
The strongest cloud threat models are concise enough to use and specific enough to change decisions. They connect business impact to concrete abuse paths, assign mitigations to the right side of the shared-responsibility boundary, and leave evidence that the control was actually tested.