Uncovering Five Critical Cross-Tenant Vulnerabilities in Azure API Connections
A deep dive into how path traversal and logic flaws enabled cross-tenant compromise.
1Systemic Architectural Flaws
Azure API Connections suffer from fundamental architectural weaknesses that allow unauthorized cross-tenant access. By exploiting the API Management instance, attackers can manipulate connections to target backend services like Key Vaults or SQL databases. These inherent flaws demonstrate how complex cloud integrations often struggle with rigorous input validation across diverse service boundaries.
2DynamicInvoke Path Traversal
The initial discovery involved a path traversal vulnerability within the DynamicInvoke endpoint of the ARM REST API. By crafting specific payloads, an attacker could bypass intended restrictions to access resources in different tenants. This exploit proved that the Azure Resource Manager had excessive, unchecked access to connections regardless of the tenant origin.
3Undocumented Endpoint Exploitation
Further investigation revealed four undocumented functions, including DynamicList, which shared the same vulnerabilities as DynamicInvoke. These endpoints were discovered by extracting code from a Standard Logic App host. Despite Microsoft’s initial attempts to blacklist specific paths, the underlying logic remained flawed, allowing attackers to perform arbitrary SQL queries on victim databases.
4Consumption vs Standard Logic
A critical distinction exists between Consumption and Standard Logic Apps regarding connection flows. Consumption apps create Version 1 connections that lack managed identity authorization, leading to implicit access risks. This architectural gap meant that every Consumption Logic App could potentially interact with any Version 1 API Connection if input validation failed.
5RuntimeUrl Parameter Manipulation
The host.api.RuntimeUrl parameter emerged as a significant security oversight within Logic Apps. By modifying this parameter, researchers could redirect traffic to unauthorized endpoints while still including valid Authorization headers. This bypass worked because the system accepted modified URLs as long as they maintained the required azure-apihub.net domain suffix structure.
6Validation Timing Vulnerabilities
Microsoft attempted to fix the RuntimeUrl issue by enforcing strict path matching, but the validation occurred before path normalization. This timing error allowed attackers to bypass checks by using path traversal sequences that the runtime initially deemed valid. The APIM instance subsequently interpreted the normalized path differently, enabling the exploit to persist.
7Regression in Security Fixes
Security patches for these vulnerabilities were often incomplete or introduced regressions. When Microsoft addressed the path traversal issue, the original RuntimeUrl validation was inadvertently weakened, allowing previously patched attacks to function again. This cycle highlights the difficulty of securing interconnected cloud services where fixes in one component impact others.
8Financial Impact of Research
The discovery of these five critical elevation-of-privilege vulnerabilities resulted in a total bounty of $200,000. These findings were presented at Blue Hat Asia 2026, emphasizing the severity of the flaws. The researcher successfully demonstrated that even well-documented cloud systems can harbor deep-seated architectural issues that remain hidden from standard security audits.
9Scope of Affected Services
The vulnerabilities affected a wide range of backend services, including Jira, Salesforce, and internal Azure components. Because API Connections act as a bridge, compromising them grants full access to the connected backend. The lack of minimal privilege scoping for OAuth tokens and API keys significantly exacerbated the potential impact of these exploits.
10Lessons for Cloud Security
These findings underscore the necessity of rigorous input validation and proper scoping in cloud-native architectures. Relying on blacklisting specific endpoints is insufficient when the underlying logic is flawed. Developers must prioritize secure-by-design principles, ensuring that cross-tenant boundaries are strictly enforced and that validation logic is robust against normalization and timing attacks.