One Root Cause, Three Cross-Tenant Breaks in Azure

Haakon Gulbrandsrud (Security Researcher · Binary Security AS)

BlueHat Asia 2026 · Day 2 · Main Stage

Overview

In this compelling BlueHat Asia talk, Haakon Gulbrandsrud, a security researcher at Binary Security AS, unveils a series of critical cross-tenant vulnerabilities discovered in Microsoft Azure, all stemming from a single, unaddressed architectural root cause. The presentation, aptly titled "One Root Cause, Three Cross-Tenant Breaks in Azure," details how flaws in the design and implementation of Azure Logic Apps' API Connections allowed an attacker to bypass security boundaries and access sensitive data or execute arbitrary commands in other tenants' resources. Gulbrandsrud highlights the persistent challenge of fixing fundamental architectural issues versus patching symptoms, demonstrating how his repeated reports led to superficial fixes that he subsequently bypassed multiple times.

Watch on YouTube

Visual summary for One Root Cause, Three Cross-Tenant Breaks in Azure by Haakon Gulbrandsrud
Visual summary for One Root Cause, Three Cross-Tenant Breaks in Azure by Haakon Gulbrandsrud

Key moments

  1. 2:15 Applying white-box insights to black-box Azure systems
  2. 5:45 Initial discovery: Unexpected Jira access via Logic Apps
  3. 13:30 Understanding Azure API Management's role in connections
  4. 19:00 Demo: Cross-tenant Key Vault secret leakage via path traversal
  5. 21:30 Exploiting undocumented endpoints for SQL injection
  6. 25:00 Demo: Cross-tenant API connection abuse via runtime URL
  7. 27:30 The 'root cause' problem and AI's role in fixes

One Root Cause, Three Cross-Tenant Breaks in Azure

Speakers: Haakon Gulbrandsrud (Security Researcher, Binary Security AS)

Conference: BlueHat Asia

YouTube: https://www.youtube.com/watch?v=sQsiVxAHvE4

Overview

In this compelling BlueHat Asia talk, Haakon Gulbrandsrud, a security researcher at Binary Security AS, unveils a series of critical cross-tenant vulnerabilities discovered in Microsoft Azure, all stemming from a single, unaddressed architectural root cause. The presentation, aptly titled "One Root Cause, Three Cross-Tenant Breaks in Azure," details how flaws in the design and implementation of Azure Logic Apps' API Connections allowed an attacker to bypass security boundaries and access sensitive data or execute arbitrary commands in other tenants' resources. Gulbrandsrud highlights the persistent challenge of fixing fundamental architectural issues versus patching symptoms, demonstrating how his repeated reports led to superficial fixes that he subsequently bypassed multiple times.

The talk is particularly significant for cloud security professionals, developers, and architects working with Azure. It provides a deep technical dive into how a seemingly innocuous feature – the ability for Logic Apps to connect to external services – can become a vector for severe cross-tenant compromise when underlying design principles are flawed. Gulbrandsrud’s methodology, grounded in deep white-box analysis, offers valuable insights into identifying and exploiting such systemic weaknesses in large, complex cloud platforms, urging a shift towards comprehensive root cause remediation.

Background

▶ Watch: Applying white-box insights to black-box Azure systems (2:15)

Haakon Gulbrandsrud begins by contrasting his preferred methodology of white-box application penetration testing with more traditional black-box approaches. At Binary Security, he and his team gain full access to source code, user accounts, logs, and configurations, enabling them to understand the entire system picture. This contrasts sharply with black-box testing, often associated with bug bounties, which relies heavily on guessing, brute-forcing, and specialized lists for common vulnerabilities like XSS or SQL injection – a realm Gulbrandsrud admits he lacks the patience for. His talk aims to bridge this gap, demonstrating how a deep understanding of a system's architecture can reveal vulnerabilities without requiring extensive black-box guesswork.

The genesis of this research lies in the practical experience gained from securing customer environments. Many Norwegian businesses extensively utilize Azure, often deploying a wide variety of services. During routine security assessments, Gulbrandsrud's team observed "something in the Azure environment that kind of looked strange." This anomaly sparked their dedicated research time (20% of work hours), focusing on Azure Logic Apps. Described as an "enterprise platform for agentic business process automation," Logic Apps are essentially a GUI-driven, scratch-like programming language. Users drag and drop boxes to define workflows, with a trigger initiating execution, followed by a sequence of actions. These actions can call out to other services, such as adding alerts to Defender, interacting with Jira, listing keys in a Key Vault, or performing operations on Azure Resource Manager.

During a pen test, Gulbrandsrud noticed an intriguing network request fired when inspecting a Logic App action: a call from his machine to the Azure Resource Manager (ARM) targeting a connection resource, specifically Jira. The URL path included extensions proxy OAuth token accessible resources. The response indicated access to an Atlassian server – a resource Gulbrandsrud, as an external consultant, should not have had access to. This unexpected access to a customer's Jira through Azure's proxy mechanism immediately signaled a potential vulnerability, prompting a deeper investigation into how API Connections function within Azure Logic Apps.

Key Findings

▶ Watch: Understanding Azure API Management's role in connections (13:30)

Gulbrandsrud’s research uncovered a series of critical cross-tenant vulnerabilities within Azure Logic Apps' API Connection feature, all rooted in a single architectural flaw: inadequate validation and isolation within the proxying mechanism. Instead of addressing the fundamental design issue, Microsoft initially implemented superficial fixes, which Gulbrandsrud consistently bypassed.

  1. Cross-Tenant Path Traversal in dynamic invoke Endpoint (CVE-2023-38155): The first discovery involved a path traversal vulnerability (..%2f) within the extensions proxy and dynamic invoke endpoints. This allowed an attacker to manipulate the URI constructed by the Azure Resource Manager, redirecting authenticated requests meant for their own API Connection to a victim's connection, leading to unauthorized access to secrets in services like Azure Key Vault.
  1. Cross-Tenant Command Execution via Undocumented Endpoints: Following the initial patch for the dynamic invoke endpoint, Gulbrandsrud discovered three previously undocumented API endpoints: dynamic list, dynamic tree, and dynamic schema. These endpoints exhibited the same underlying path traversal vulnerability, albeit with slightly different parameter structures. This allowed for similar cross-tenant abuse, demonstrated by injecting arbitrary SQL commands into a victim's database connection.
  1. Bypass of host.api.runtimeurl Validation in Consumption Logic Apps: The final and most recent finding involved a bypass in the validation logic for host.api.runtimeurl within version one (consumption tier) Logic Apps. Due to a missing authorization step in the creation flow for consumption Logic Apps, these apps implicitly had access to all version one API connections. By manipulating the runtimeurl parameter in the Logic App's code view, an attacker could specify a victim's connection after initial validation passed, leading to another instance of cross-tenant API connection abuse.

The overarching "root cause" identified across all these findings is the failure to properly isolate and validate requests made through the Azure API Management proxy layer, coupled with an over-reliance on input blacklisting rather than a secure-by-design approach to multi-tenancy.

Technical Deep Dive

▶ Watch: Demo: Cross-tenant Key Vault secret leakage via path traversal (19:00)

The core of the vulnerabilities lies within Azure Logic Apps API Connections, which serve as the bridge between a Logic App workflow and external services like Jira, Key Vault, or SQL databases. These connections encapsulate authentication details and configuration necessary for the Logic App to interact with the target service. Gulbrandsrud distinguishes between two Logic App tiers: Consumption (multi-tenant, shared infrastructure, version 1 API connections) and Standard (dedicated host, Azure Web App, version 2 API connections). While their underlying architecture differs, both present the same GUI for workflow creation.

When an API Connection is created, Azure Resource Manager (ARM) stores a significant amount of metadata. Key fields include:

  • ID: The unique identifier of the connection resource.
  • kind: Indicates the connection version (version 1 for Consumption, version 2 for Standard).
  • connection ID: An opaque string used to identify the specific connection.

Crucially, the programmatic response reveals "test links" and "test requests" URLs, such as extensions proxy OAuth token accessible resources and endpoints ending with dynamic invoke. These internal endpoints are used to test and interact with the configured API connection. For Standard Logic Apps (version 2), an additional field, connection runtime URL, exposes the shared infrastructure endpoint (e.g., common.logic.norwayeast.azure-api.net/apim/arm/{connection ID}/...), strongly hinting at the involvement of Azure API Management (APIM).

Gulbrandsrud deduces the underlying architecture: a user's request to ARM for an API Connection action first undergoes ARM's authentication and authorization checks. Then, the request is forwarded to an internal "magical box," suspected to be Azure API Management. APIM performs a "token exchange" – retrieving the actual connection token (API token, password, or OAuth access token) from a credential metadata store using the provided connection ID, and then adding this token to the request before forwarding it to the target endpoint service. This architecture is partially confirmed by Microsoft's own documentation, though Gulbrandsrud notes an omission: ARM's initial role in proxying requests to APIM.

The attack surface emerges from this proxying mechanism. Gulbrandsrud hypothesized that if he could manipulate the target of the APIM proxy, he could redirect a request authenticated with victim's credentials to his server, or leverage a victim's authenticated connection directly.

Vulnerability 1: Path Traversal in dynamic invoke (CVE-2023-38155)

The first vulnerability exploited the dynamic invoke endpoint. This endpoint takes a path parameter within its request body. The Azure Resource Manager constructs the final URI by concatenating a shared host, the connection type (e.g., apim/jira), the connection ID, and the attacker-supplied path.

The attack payload involved URL-encoded path traversal sequences: ..%2f..%2f. When ARM processed a request containing https://management.azure.com/subscriptions/{attacker_sub}/resourceGroups/{attacker_rg}/providers/Microsoft.Web/connections/{attacker_connection}/extensions/proxy/dynamicinvoke?api-version=2018-07-01-preview with a body like {"path": "..%2f..%2f{victim_connection_id}%2factions%2fListSecrets"} for a Key Vault connection, ARM would perform URL decoding and path normalization. This effectively changed the target connection ID from the attacker's to the victim's, while retaining the attacker's authorization to invoke the proxy. Because the connection ID is not considered a secret, it can be enumerated.

The impact was severe: cross-tenant Key Vault secret leaking. An attacker could list all secrets in a victim's Key Vault and then retrieve their values. Microsoft's fix involved a simple blacklist for ..%2f within a function called validateManagedApiConnectionDynamicInvokeDefinition, which Gulbrandsrud found by inspecting the Logic App's code. This fix, however, did not address the root cause of how connection ID was used or validated in the proxy chain.

Vulnerability 2: Undocumented Endpoints

Recognizing the superficial nature of the first fix, Gulbrandsrud delved deeper into the Logic App code. He discovered three additional, completely undocumented endpoints: dynamic list, dynamic tree, and dynamic schema. These endpoints exhibited the same fundamental path traversal vulnerability. While their parameter structures were slightly different, requiring an operation ID and pathParameters delimited by slashes, the core exploit remained the same.

For instance, by targeting a victim's SQL database connection with a ..%2f payload and an action to "perform arbitrary SQL commands," Gulbrandsrud demonstrated cross-tenant arbitrary SQL command execution. Microsoft's response was to block all three undocumented endpoints, again via blacklisting, rather than fixing the underlying architectural flaw. Gulbrandsrud notes that the internal code for these endpoints remains vulnerable, suggesting that if the routing block were ever removed, the vulnerability would resurface.

Vulnerability 3: host.api.runtimeurl Bypass

The final vulnerability exploited a subtle difference in the authentication flow for Consumption (version 1) Logic Apps. Unlike Standard (version 2) Logic Apps, which explicitly authorize their managed identity to use an API Connection, Consumption Logic Apps lack this step. This implies that all Consumption Logic Apps inherently have access to all version 1 API Connections, with only input validation acting as a barrier.

Gulbrandsrud observed a parameter within the Logic App's code view (accessible by clicking "code" at the top of the GUI) called host.api.runtimeurl. This parameter, intended to reference the Logic App's own connection, was subject to initial validation to ensure it belonged to the user's subscription. However, after this validation passed, the attacker could change the runtimeurl to point to a victim's API Connection. The underlying system would then use the victim's connection details to fulfill the request.

The result was another instance of cross-tenant API connection abuse, demonstrated again by leaking secrets from a victim's Key Vault. Gulbrandsrud humorously speculates that Microsoft's fix, which involved a strict whitelist requiring the host.api.runtimeurl to be exactly the correct one, might have been implemented with the help of AI (like Microsoft's "Argus" system) due to the "too long, informative, and kind" error message. However, this is still a whitelist, not a root cause fix, leaving open the possibility of future bypasses if the parameter could be manipulated after initial validation.

Demo / Proof of Concept

▶ Watch: Demo: Cross-tenant API connection abuse via runtime URL (25:00)

Gulbrandsrud effectively demonstrated each of the three cross-tenant vulnerabilities with clear, concise proof-of-concept videos.

  1. Key Vault Secret Leaking (Vulnerability 1): The first demo showcased the path traversal in the dynamic invoke endpoint. The video displayed a victim's Azure Key Vault with a secret. Gulbrandsrud then navigated to an attacker's tenant, constructed a malicious payload using the victim's readily available API Connection ID and the ..%2f..%2f path traversal. Executing this payload through the attacker's Logic App successfully listed all secrets within the victim's Key Vault. Following this, he demonstrated retrieving the actual value of a specific secret, unequivocally proving cross-tenant data exfiltration.
  1. SQL Database Command Execution (Vulnerability 2): For the undocumented endpoints, Gulbrandsrud demonstrated the ability to execute arbitrary SQL commands. While the video didn't show the full SQL injection, it illustrated the setup: targeting a victim's SQL database connection with a manipulated pathParameters containing ..%2f and an action to perform SQL. The result confirmed that arbitrary data could be added to the victim's database, implying full control over the database via the compromised connection.
  1. host.api.runtimeurl Bypass (Vulnerability 3): The final demo illustrated the bypass of host.api.runtimeurl validation. Starting with a victim's Key Vault connection, the attacker, in their own tenant, modified the Logic App's code to specify the victim's runtimeurl after initial validation. When this modified Logic App workflow was run, the action's result showed the victim's secrets, confirming yet another method of cross-tenant API connection abuse and data leakage.

Each demonstration clearly highlighted the attacker's ability to leverage a vulnerability in their own tenant to impact resources belonging to another, demonstrating the severe implications of these architectural flaws.

Defensive Implications

▶ Watch: The 'root cause' problem and AI's role in fixes (27:30)

The series of cross-tenant vulnerabilities uncovered by Haakon Gulbrandsrud in Azure Logic Apps carries significant defensive implications for organizations leveraging Microsoft's cloud platform.

First and foremost, defenders must recognize that shared infrastructure in multi-tenant cloud environments introduces unique threat models. Assumptions about isolation and security boundaries must be rigorously tested. "Opaque strings" like API Connection IDs, while not explicitly labeled as secrets, should not be treated as security boundaries if they are exposed and can be used to reference resources across tenants. Their public nature, combined with flawed validation, can turn them into critical attack vectors.

Secondly, the talk underscores the critical weakness of relying solely on input validation (blacklisting) to secure fundamental architectural flaws. Microsoft's repeated attempts to patch these vulnerabilities by blocking specific payloads (e.g., ..%2f) or whitelisting exact values proved to be temporary fixes, easily bypassed by a determined researcher. Defenders should advocate for and implement security solutions that address root causes through secure-by-design principles, rather than superficial patches. This includes proper authorization checks at every stage of a proxy chain and robust isolation mechanisms.

Thirdly, the distinction between Consumption (v1) and Standard (v2) Logic Apps highlights a potential design flaw in managed identity and authorization. The fact that Consumption Logic Apps implicitly had broader access to API Connections due to a missing authorization step is a critical insight. Organizations should thoroughly review how managed identities are granted permissions, especially in multi-tenant services, ensuring that the principle of least privilege is strictly enforced and that implicit access is identified and mitigated.

Finally, organizations should monitor for unusual API connection activity. This includes calls to API Connections that do not belong to their tenant, unexpected path parameters in requests to extensions proxy or dynamic invoke-like endpoints, or suspicious modifications to Logic App code (e.g., host.api.runtimeurl). While Logic App code might not be directly monitored by standard security tools, internal auditing and logging should be configured to detect such anomalies. Regular security assessments, especially white-box penetration tests that examine the underlying architecture and code, are crucial for uncovering deep-seated vulnerabilities that automated scanners might miss.

Key Takeaways

  • Root Cause vs. Symptom Fixing: Relying on superficial patches (like blacklisting specific characters) instead of addressing underlying architectural flaws leads to recurring vulnerabilities and prolonged exposure.
  • Shared Infrastructure Risks: Multi-tenant cloud services introduce complex security challenges where a single design flaw can enable cross-tenant attacks, bypassing intended isolation.
  • "Opaque" Identifiers are Not Secrets: Values like API Connection IDs, if exposed and not treated as security boundaries, can be leveraged by attackers when combined with validation bypasses.
  • Undocumented APIs are Dangerous: The discovery of undocumented endpoints (dynamic list, dynamic tree, dynamic schema) highlights a hidden attack surface that can persist even after documented vulnerabilities are patched.
  • Thorough Architectural Understanding is Key: Deep white-box analysis and understanding a system's internal architecture are critical for identifying and exploiting complex, systemic vulnerabilities in large cloud platforms.
  • Authorization Gaps in Managed Identities: Discrepancies in how managed identities are authorized across different tiers of a service (e.g., Consumption vs. Standard Logic Apps) can create significant security weaknesses.

About the Speaker(s)

Haakon Gulbrandsrud is a Security Researcher at Binary Security AS, a small Norwegian security and pen testing company. He specializes in white-box application penetration testing, a methodology that involves deep analysis of a system's source code, configurations, and internal workings. Gulbrandsrud leverages the insights gained from his extensive customer engagements to identify architectural flaws and drive security research, focusing on understanding systems thoroughly rather than relying on black-box guesswork. His work highlights the value of in-depth analysis in uncovering complex vulnerabilities in modern cloud environments.

Reviews

Dr. Zero (Offensive Security Researcher) — STRONG ACCEPT

Real cross-tenant bugs in Azure, demonstrated three times against the same root cause Microsoft kept band-aiding. This is what cloud vuln research looks like when someone actually reads the code instead of fuzzing endpoints. Falls short of a 5 because the exploitation is straightforward once you see the architecture — clever pattern recognition, not novel technique.

Heather Calloway (CISO) — STRONG ACCEPT

This is the kind of cloud security research that should change procurement conversations and vendor management practices. Three cross-tenant breaks in Azure Logic Apps, all from the same unaddressed root cause, with Microsoft patching symptoms instead of architecture. Any CISO running Azure workloads needs to understand what this implies about shared infrastructure risk.

→ Top-rated talks at BlueHat Asia 2026

All talks from BlueHat Asia 2026