Cloud Attack Paths: Five 'Low' Findings, One Owner
How cloud attack paths chain five 'low' Azure misconfigurations from a leaked storage key to subscription Owner, and the controls that break each step.
In the second half of 2025, attackers got their first foothold through a misconfiguration in 21% of the Google Cloud incidents Google analysed, and through weak or absent credentials in another 27.2%. That is from Google's Cloud Threat Horizons Report H1 2026. Orca's 2025 cloud report adds the other half of the picture: 76% of organisations had at least one public-facing asset that enables lateral movement. The entry point is rarely the breach. What turns a foothold into an incident is the path behind it.
Most security teams still read the cloud as a list: thousands of posture findings, sorted by severity, worked from the top. Attackers read graphs: this key opens that storage account, which holds code that runs as an identity, which can change a vault, which holds the secret of an Owner. This article is for the people who decide what gets fixed first: CISOs, cloud platform leads and security architects. We walk through one composite Azure attack path built from five findings a scanner would usually rank low or medium, and the control that breaks each step.
TL;DR / Key takeaways
- Severity lives on the path, not the finding. Five tolerable-looking findings chain from a leaked storage key to Owner of a production subscription. Each is documented behaviour.
- Fix the edges, not the backlog. One control per step breaks the chain: disallow Shared Key, identity-based storage connections, scoped managed identities, Key Vault on Azure RBAC, no standing Owner service principals.
- Credential edges are everywhere. Datadog's 2026 data shows 43% of Azure organisations still authenticate GitHub Actions with long-lived secrets only. Public storage, the classic headline, is down to 1.3% of Azure Blob containers.
- The tooling has caught up. Defender CSPM attack paths, Exposure Management choke points and BloodHound with AzureHound make graph thinking practical.
- Regulators expect it, even if they don't name it. NIS2 Article 21 (§ 30 BSIG in Germany) and DORA's ICT risk framework expect you to know how one weakness reaches a critical function.
Download: Editable draw.io file · Open in diagrams.net · Chart data (CSV)
Why graph thinking became the default in 2026
John Lambert wrote "Defenders think in lists. Attackers think in graphs." in April 2015, about on-premises networks. What changed is that cloud vendors now ship the graph as a product, and cloud estates became mostly identity.
Defender for Cloud's cloud security graph collects inventory, permissions, exposure and "lateral movement possibilities", and defines an attack path as "a series of steps a potential attacker uses to breach your environment and access your assets". Microsoft Security Exposure Management adds choke points: nodes where several paths converge on the way to a critical asset. Fix a choke point and many paths disappear at once. That is this article's argument in one product feature.
The data says the edges are mostly identity. Google's report attributes 83% of the major cloud and SaaS incidents Mandiant handled in H2 2025 to identity issues at initial access. It also describes attackers going from a developer's machine to full cloud administration in under 72 hours by abusing OpenID Connect trust between a CI/CD provider and the cloud. Datadog's State of Cloud Security 2026 finds that 97% of Azure organisations keep the default long-lived keys on their Foundry resources. Every one of those keys is an edge.
Defaults are moving too. From Key Vault API version 2026-02-01, Azure RBAC is the default for new vaults. Existing vaults keep what they had, and that is exactly where step ④ lives.
The path, edge by edge
The hero diagram is a composite, not one customer. Each step is documented behaviour, drawn from Orca Security's 2023 Shared Key research and from Microsoft Learn. The dashed arrow is attacker preparation, searching repositories and build logs for connection strings, so it carries no number.
① A leaked key meets an account that still accepts it
The finding: a storage account allows Shared Key authorisation, and its connection string, with AccountKey= in it, has leaked into a repository, a CI log or a client bundle.
Why it scores low: Shared Key is the platform default. Microsoft's documentation says the AllowSharedKeyAccess property "is not set by default", and the account permits Shared Key when the value is null or true. Thousands of accounts share it, so the finding blends in.
What the attacker gets: full access to every blob, file share, queue and table in the account. Key use is a data-plane operation: the Activity Log does not show it, only storage resource logs do.
Control A: disallow Shared Key and move clients to Entra ID. The built-in policy Storage accounts should prevent shared key access finds accounts in audit mode and blocks them in deny mode. Add secret scanning on repositories and pipeline logs, and rotate exposed keys.
② Function code lives where the key can write
The finding: the storage account is also the content store of a function app.
Why it scores low: it is how Azure Functions works. On the Consumption (Windows) and Premium plans, Microsoft Learn says you "store your function code and configuration files in Azure Files in the linked storage account". That share is reached through a connection string in WEBSITE_CONTENTAZUREFILECONNECTIONSTRING; Azure Files does not support identity-based connections for it.
What the attacker gets: the function's code. Orca demonstrated exactly this in 2023: find the share holding the code, edit it, wait for the next run. According to Orca, Microsoft treated it as by-design behaviour rather than a vulnerability. Microsoft Learn now warns that this account "persists important data, such as function code".
Control B: take the code out of key-reachable storage. Use Flex Consumption, whose deployment storage supports managed-identity connections, or run from a package that the app's managed identity reads, with an identity-based AzureWebJobsStorage. Give each app its own storage account and send at least StorageWrite logs to Log Analytics.
③ The code runs as an identity with subscription-wide rights
The finding: the function app's system-assigned managed identity holds Contributor at subscription scope.
Why it scores low: managed identities look like best practice, and the broad role came from a deployment that needed it once. And the entry point here is a leaked key, not an internet-exposed CVE, so tools that look for "exposed, vulnerable and privileged" combinations may not connect the dots.
What the attacker gets: the modified function requests a token for Azure Resource Manager from the managed identity endpoint and sends it out, or uses it in place. Contributor can change almost every resource; in Orca's demonstration the token ran commands on a virtual machine. What Contributor cannot do is assign roles. Hence the next two steps.
Control C: scope every workload identity to the resource group or resource it needs, with the narrowest role that works, and review subscription-scope assignments monthly. Our PIM guide for Azure covers the human side of the same rule.
④ Contributor rewrites the vault's access policy
The finding: a Key Vault in the same subscription still uses the legacy access-policy permission model.
Why it scores low: access policies are supported, and many vaults predate RBAC. A vault with purge protection and a private endpoint scores well.
What the attacker gets: the secrets. Microsoft is explicit that under access policies, users with Contributor, Key Vault Contributor or any role with Microsoft.KeyVault/vaults/write "can grant themselves data plane access by configuring a Key Vault access policy". The stolen token adds a policy for itself and reads every secret.
Control D: migrate vaults to the Azure RBAC permission model. Under RBAC, granting data-plane access requires Owner or User Access Administrator, or a constrained role such as Key Vault Data Access Administrator. For existing vaults, migration is a project: inventory who reads what, map policies to roles such as Key Vault Secrets User, then switch.
⑤ A standing Owner with a secret in that vault
The finding: the vault holds the client secret of a deployment service principal that is Owner of the subscription.
Why it scores low: the secret is in a vault, as every guideline says. An old pipeline "needs to create role assignments", so its principal got Owner.
What the attacker gets: Owner of the subscription: every resource, all data, and the right to assign any role, including persistence for themselves.
Control E: remove standing Owner from automation. Replace the client secret with a federated credential, so there is nothing to steal. Where a pipeline must assign roles, use Role Based Access Control Administrator with conditions that restrict which roles and principal types it can assign. Humans get Owner through PIM, time-limited and approved.
No step needed a software vulnerability. Nothing was noisy in the Activity Log until the vault change in ④. Each finding, read alone, has a reasonable explanation. That is the point.
Seeing the graph in your own estate
You don't need a new platform to find the worst edges. Three Azure Resource Graph queries surface the raw material of this path.
// Storage accounts that still accept Shared Key (null counts as allowed)
resources
| where type =~ 'microsoft.storage/storageaccounts'
| extend allowSharedKey = tostring(properties.allowSharedKeyAccess)
| where allowSharedKey != 'false'
| project subscriptionId, resourceGroup, name, allowSharedKey
// Service principals and managed identities holding Owner, Contributor
// or User Access Administrator at subscription scope
authorizationresources
| where type =~ 'microsoft.authorization/roleassignments'
| extend scope = tostring(properties.scope),
principalType = tostring(properties.principalType),
roleId = tostring(split(tostring(properties.roleDefinitionId), '/')[-1])
| where principalType =~ 'ServicePrincipal'
| where scope matches regex @'^/subscriptions/[^/]+$'
| where roleId in~ ('8e3af657-a8ff-443c-a75c-2fe8c4bcb635',
'b24988ac-6180-42a0-ab88-20f7382dd24c',
'18d7d88d-d35e-4fb5-a5c3-7773c20a72d9')
| project scope, principalId = tostring(properties.principalId), roleId
// Key vaults still on the access-policy model
resources
| where type =~ 'microsoft.keyvault/vaults'
| where tostring(properties.enableRbacAuthorization) != 'true'
| project subscriptionId, resourceGroup, nameJoin the results on a whiteboard. If an account from the first list hosts a function app whose identity is in the second, and a vault from the third sits in the same subscription, you have this path. Test the queries in your tenant first; property casing varies between resource types. Then decide on tooling to keep the graph current: Defender CSPM for attack path analysis, Exposure Management for cross-workload paths and choke points, or BloodHound with AzureHound as the open-source option. Our Defender for Cloud vs. third-party CSPM comparison covers the commercial trade-offs.
What the numbers say
The denominators differ, so read this as orders of magnitude, not a ranking. Three things stand out. First, the classic headline, a public storage container, is now rare: Datadog measured 1.3% of Azure Blob containers as effectively public in 2025, down from 5% in 2023. Second, credential edges are everywhere: 40% of Entra ID applications had credentials older than a year, and 43% of Azure organisations feed GitHub Actions only long-lived secrets. Third, paths concentrate: Orca found 36% of organisations had an asset on more than 100 attack paths, and 13% one on more than 1,000. That asset is your choke point.
Entry points shift fast. Between the two halves of 2025, weak or absent credentials fell from 47.1% to 27.2% of Google Cloud initial access and misconfiguration from 29.4% to 21%, while third-party software exploitation reached 44.5%. You cannot predict the next entry point, but you can control what it connects to. A vulnerable web app with no attached identity is a cleanup job. The same app running as Contributor is an incident.
In a recent engagement…
During a cloud security review this year for a mid-sized European manufacturer, we started where most teams start: a posture dashboard with thousands of open recommendations and a target to cut the "high" count. Nobody had looked at how the medium and low findings connected.
We started with the three queries above and a whiteboard. The result was not one dramatic path but a handful of short ones through the same two nodes: an automation identity with Contributor on several production subscriptions, and a shared Key Vault on access policies holding deployment secrets for several teams. Neither was anywhere near the top of the dashboard.
The fixes were unglamorous. We scoped the automation identity to the resource groups it actually touched, which took longer than anyone expected. We migrated the shared vault to RBAC and split it per team. We disabled Shared Key wherever no Azure Files workload depended on it, starting in audit mode. The dashboard's severity count barely moved. The paths to Owner went to none we could find. That gap is the lesson.
The checklist: five misconfigurations, five edges
The screenshot-able part. Step matches the diagram callouts.
| Step | Misconfiguration | Why a scanner ranks it low | Edge it creates | Control that breaks it | Effort |
|---|---|---|---|---|---|
| ① | Shared Key allowed on storage, key leaked | Platform default; thousands of identical findings | Leaked key → full data access | A: policy Storage accounts should prevent shared key access; secret scanning; rotate exposed keys | Medium: SAS and Azure Files clients need migration |
| ② | Function code in key-reachable storage | Default for Consumption and Premium plans | Data access → code execution | B: Flex Consumption or run-from-package with managed identity; one storage account per app; StorageWrite logs | Medium |
| ③ | Managed identity with Contributor at subscription scope | Managed identities look like best practice | Code execution → control of resources | C: scope to resource group, narrow role, monthly review | Low to medium |
| ④ | Key Vault on access policies | Supported model; vault otherwise well configured | Contributor → secrets | D: migrate to Azure RBAC; RBAC is default for new vaults from API 2026-02-01 | Medium: map every reader |
| ⑤ | Standing Owner service principal with client secret | Secret is "safely" in a vault | Secret → Owner | E: federated credential; RBAC Administrator with conditions; PIM for humans | Medium |
Two warnings. Disabling Shared Key breaks service and account SAS and some Azure Files access, so audit and migrate before you deny. And scoping an automation identity always finds one forgotten job that needed the broad role, so watch deployment logs before you cut.
Governance for European enterprises
No European regulation says "attack path". Several describe it.
NIS2. Article 21 of Directive (EU) 2022/2555 requires appropriate and proportionate measures, including risk analysis, access control and asset management, and policies to assess whether those measures are effective. In Germany this is § 30 BSIG, applicable since 6 December 2025 with no transition period. A documented attack-path review answers the effectiveness question well: it tests whether access controls stop a chain, not only whether they exist. Our NIS2 measures on Azure maps them to controls.
DORA. Regulation (EU) 2022/2554 has applied to financial entities since 17 January 2025. Its ICT risk-management framework expects you to identify assets and dependencies, protect, detect and test. An Owner-level service principal with its secret in a shared vault is exactly such a dependency.
GDPR. If the account in step ① holds personal data, the leaked key is already an Article 32 problem before anyone reaches Owner.
The habit is the same everywhere: name your critical assets, keep the graph of what reaches them current, and keep evidence that you broke the paths you found.
A pragmatic adoption path
- Week 1: name the crown jewels. List assets whose compromise is an incident on its own: subscription Owner, production data, the identity tenant, backups. Attack-path tools are only as good as this list.
- Week 2: run the three queries. Find Shared Key accounts, privileged service principals at subscription scope and vaults on access policies. Draw the connecting paths by hand.
- Weeks 3–6: break the choke points. Fix the nodes on the most paths first, whatever their scanner severity.
- Month 2: change the defaults. Shared Key policy in audit, then deny; require RBAC on vaults by policy. Our Azure Policy-as-code guide shows how to roll this out without breaking deployments.
- Month 3: make it continuous. Turn on attack path analysis in Defender CSPM or your CNAPP, review new paths weekly, and add detections for the edges you could not remove: StorageWrite on content shares, vault policy writes, role assignment writes, new-location service principal sign-ins. For AI agents, apply the same lens; our piece on AI-induced lateral movement walks through that variant.
The verdict
Cloud breaches are rarely one catastrophic mistake. They are five ordinary decisions, each with a reason, lined up in a row. Severity scoring scores nodes; attacks run along edges.
Our view is blunt. Stop measuring cloud security by the number of open high findings. Measure the number of paths from the internet to your crown jewels, and the time it takes to break a new one. If you do one thing this quarter, scope your automation identities. If you do two, move your vaults to RBAC. Shared Key and federated pipeline credentials take longer, and are worth it.
If you want help drawing the first graph of your estate, our zero-trust and cloud security team runs this review as a short, fixed-scope engagement. You leave with your own version of the diagram and the checklist filled in.
FAQ
What is a cloud attack path?
A cloud attack path is a chain of steps from an entry point, such as a leaked credential or an exposed endpoint, to a critical asset, such as subscription ownership or a sensitive database. Each step uses an edge in your environment: a key, an identity attached to a workload, a role assignment, a secret in a vault. Microsoft Defender for Cloud defines it as a series of steps a potential attacker uses to breach your environment and access your assets.
Why do low-severity misconfigurations matter if they are low?
Because posture tools score each finding alone, while attackers move along chains. A storage account that allows Shared Key, a function app whose code lives in it, and a managed identity with Contributor on the subscription each look tolerable. Together they give whoever holds the storage key code execution with subscription-wide rights. The risk sits in the connection, not the node.
Can Contributor on Azure escalate to Owner?
Not directly, because Contributor cannot create role assignments. But under the legacy Key Vault access-policy model, Microsoft documents that anyone with Contributor or Microsoft.KeyVault/vaults/write can grant themselves data-plane access. If that vault holds the secret of an Owner-level service principal, Contributor becomes Owner in two steps. Moving vaults to Azure RBAC closes that edge.
Should we disable Shared Key authorisation on every storage account?
On almost every account, yes, but audit first. Service and account SAS tokens stop working once Shared Key is disallowed, and Azure Files workloads need preparation. Assign the built-in policy Storage accounts should prevent shared key access in audit mode, use storage metrics and logs to find key-based clients, migrate them, then switch the policy to deny.
Do we need a CNAPP to find attack paths?
It helps, but it is not the starting point. Defender CSPM, Microsoft Security Exposure Management and third-party CNAPPs build the graph and highlight choke points. You can find the most dangerous edges yourself with Azure Resource Graph queries for Shared Key access, privileged service principals at subscription scope and vaults on access policies. Start with the queries, then buy tooling to keep the graph current.
Which European regulations make attack-path management relevant?
NIS2 Article 21 requires risk-based measures including access control, asset management and assessing their effectiveness; in Germany this is § 30 BSIG, applicable since 6 December 2025. DORA requires financial entities to identify ICT assets and dependencies, protect, detect and test. Neither names attack paths, but both expect you to know how one weakness reaches a critical function.
Sources
All sources checked on 15 November 2026. Industry figures are quoted with the denominator the publisher used; we have not re-analysed their data.
Tier A: primary, platform documentation and regulatory
- Microsoft Learn, Security explorer and attack paths in Microsoft Defender for Cloud: https://learn.microsoft.com/en-us/azure/defender-for-cloud/concept-attack-path
- Microsoft Learn, Work with attack paths in Microsoft Security Exposure Management: https://learn.microsoft.com/en-us/security-exposure-management/work-attack-paths-overview
- Microsoft Learn, Prevent authorization with Shared Key (Azure Storage): https://learn.microsoft.com/en-us/azure/storage/common/shared-key-authorization-prevent
- Microsoft Learn, Storage considerations for Azure Functions: https://learn.microsoft.com/en-us/azure/azure-functions/storage-considerations
- Microsoft Learn, Azure RBAC vs. access policies (Key Vault), including the API 2026-02-01 default: https://learn.microsoft.com/en-us/azure/key-vault/general/rbac-access-policy
- Microsoft Learn, Delegate Azure access management to others with conditions: https://learn.microsoft.com/en-us/azure/role-based-access-control/delegate-role-assignments-overview
- Directive (EU) 2022/2555 (NIS2), Article 21: https://eur-lex.europa.eu/eli/dir/2022/2555/oj/eng
- Regulation (EU) 2022/2554 (DORA): https://eur-lex.europa.eu/eli/reg/2022/2554/oj/eng
Tier B: research and threat intelligence
- Google Cloud, Cloud Threat Horizons Report H1 2026 (covering H2 2025): https://cloud.google.com/security/report/resources/cloud-threat-horizons-report-h1-2026
- Datadog, State of Cloud Security 2026: https://www.datadoghq.com/state-of-cloud-security/
- Datadog, State of Cloud Security 2025: https://www.datadoghq.com/state-of-cloud-security-2025/
- Orca Security, "From listKeys to Glory: How We Achieved a Subscription Privilege Escalation and RCE by Abusing Azure Storage Account Keys" (11 April 2023): https://orca.security/resources/blog/azure-shared-key-authorization-exploitation/
- John Lambert, "Defenders think in lists. Attackers think in graphs." (2015): https://github.com/JohnLaTwC/Shared/blob/master/Defenders%20think%20in%20lists.%20Attackers%20think%20in%20graphs.%20As%20long%20as%20this%20is%20true%2C%20attackers%20win.md
Tier C: vendor, directional
- Orca Security, 2025 State of Cloud Security Report: https://orca.security/lp/2025-state-of-cloud-security-report/
- SpecterOps, AzureHound (BloodHound collector for Azure): https://github.com/SpecterOps/AzureHound
Topics