PUT-ting on the Risk: How Swapping a Simple GET Request Netted Five Criticals and MVR Status
Vaisha Bernard (Chief Hacker · Eye Security), Cameron Vincent (Microsoft)
BlueHat Asia 2026 · Day 1 · Main Stage
Overview
In a compelling presentation at BlueHat Asia, Vaisha Bernard, Chief Hacker at Eye Security, alongside Cameron Vincent of Microsoft, unveiled a series of critical vulnerabilities stemming from a deceptively simple action: changing an HTTP GET request to a PUT request. This seemingly minor alteration exposed widespread misconfigurations across numerous internal Microsoft systems, ultimately leading to five critical-rated vulnerabilities and securing Bernard his second consecutive Microsoft Most Valuable Researcher (MVR) status. The talk meticulously details the journey from initial curiosity to profound impact, highlighting the critical importance of the principle of least privilege in cloud environments.

Key moments
- 0:00 Talk introduction and MVR motivation
- 3:10 Identifying Azure Blob Storage and Front Door interaction
- 6:40 The GET-to-PUT discovery and successful file write
- 8:15 Overwriting JWKS and forging service account tokens
- 13:10 Microsoft's variant hunting process and triggers
- 18:45 Understanding Azure Front Door origin paths and CDN
- 23:25 Root cause: Managed identities with excessive permissions
PUT-ting on the Risk: How Swapping a Simple GET Request Netted Five Criticals and MVR Status
Speakers: Vaisha Bernard (Chief Hacker, Eye Security), Cameron Vincent (Microsoft)
Conference: BlueHat Asia
YouTube: https://www.youtube.com/watch?v=yWLRl7wUfJ4
Overview
In a compelling presentation at BlueHat Asia, Vaisha Bernard, Chief Hacker at Eye Security, alongside Cameron Vincent of Microsoft, unveiled a series of critical vulnerabilities stemming from a deceptively simple action: changing an HTTP GET request to a PUT request. This seemingly minor alteration exposed widespread misconfigurations across numerous internal Microsoft systems, ultimately leading to five critical-rated vulnerabilities and securing Bernard his second consecutive Microsoft Most Valuable Researcher (MVR) status. The talk meticulously details the journey from initial curiosity to profound impact, highlighting the critical importance of the principle of least privilege in cloud environments.
The core of the discovery revolved around the interaction between Azure Front Door and Azure Blob Storage, where over-privileged managed identities allowed unauthorized write access to sensitive configuration files. Bernard's ability to manipulate OpenID configuration and JSON Web Key Set (JWKS) files demonstrated a path to forging service account tokens, with potential implications for privilege escalation and unauthorized access across Microsoft's ecosystem. This research not only underscores the often-overlooked power of basic HTTP methods but also provides invaluable lessons for both red teams identifying such flaws and blue teams implementing robust cloud security postures.
This presentation serves as a testament to the fact that groundbreaking security research doesn't always require complex reverse engineering or zero-day exploits. Sometimes, it's the methodical exploration of fundamental interactions and the critical eye for misconfigurations that yield the most significant findings. Bernard's journey, driven by a desire to validate his initial MVR recognition, culminated in a profound contribution to Microsoft's security, triggering an extensive internal variant hunt and reinforcing the collaborative spirit between independent researchers and security vendors.
Background
▶ Watch: Talk introduction and MVR motivation (0:00)
Vaisha Bernard's journey into this impactful research began with a personal challenge to validate his earlier recognition as a Microsoft Most Valuable Researcher (MVR). His initial MVR status in 2025 was earned through a discovery he humbly described as "just logging in." This involved identifying a misconfiguration on Microsoft's aka.ms and eng.ms link shortener domains that allowed him to access an internal Microsoft engineering hub—a system he should never have been able to reach—by simply logging in with his personal Microsoft account. This flaw, which affected 24 other internal Microsoft systems, was presented at Black Hat and established his initial MVR status. Despite the significant impact, Bernard felt a degree of "impostor syndrome," compelling him to pursue further research to truly earn his title.
His subsequent investigation began with a list of Microsoft subdomains he had previously collected. While systematically visiting these domains, Bernard observed a recurring error message: "invalid query parameter value." This specific error, combined with the domain patterns, led him to deduce that he was interacting with Azure Blob Storage accounts, proxied through Azure Front Door. Azure Blob Storage, as Bernard explained, functions as a cloud-based file system, comprising storage accounts that host containers (analogous to folders), which in turn hold blobs (files). Access to these blobs can be direct via HTTP or through a REST API, which supports various parameters for interaction, such as comp=list and restype=container to enumerate container contents.
Azure Front Door, Microsoft's global, scalable entry point that uses the Microsoft global edge network to create fast, secure, and widely scalable web applications, played a crucial role. It acts as a Content Delivery Network (CDN), a Layer 7 load balancer, and can incorporate a Web Application Firewall (WAF). Critically, Front Door was configured to relay HTTP requests and their parameters directly to the backend Azure Blob Storage. Bernard leveraged a Tampermonkey script to automate the addition of listing parameters (comp=list, restype=container) to URLs as he browsed. This quickly revealed numerous listable storage containers, some exposing sensitive data like Azure Activity Monitor logs and CSV files containing confidential information.
The pivotal moment arrived when Bernard encountered a subdomain of aks.azure.com (Azure Kubernetes Service) that was also listable. This container hosted tens of thousands of files ending in .well-known/openid-configuration and associated JWKS files. While these files are inherently designed to be public (providing metadata and public keys for OAuth and OpenID Connect token validation), the sheer volume and the listability of the container itself piqued Bernard's curiosity, setting the stage for the groundbreaking discovery that followed.
Key Findings
▶ Watch: The GET-to-PUT discovery and successful file write (6:40)
The central revelation of Bernard's research was the discovery that a simple alteration from a GET request to a PUT request could grant write access to critical Azure Blob Storage containers, leading to severe security implications. While investigating the listable aks.azure.com container hosting OpenID configuration and JWKS files, Bernard, without prior experience in Azure Kubernetes, theorized about the impact of changing these files. He used Burp Repeater to transform a standard GET request into a PUT request targeting one of these files. Initially, he received a "missing required header" error, which explicitly instructed him on the header to add. Upon adding the specified header, he was met with a 201 Created response, confirming that he had successfully written a file to the Azure Kubernetes storage container.
This success immediately escalated his heart rate, as he recognized the profound implications. To ensure proper attribution for his bug bounty submission, he embedded an identifier ("greetings from Wild Raccoon," a nickname adopted from an earlier Microsoft incident he caused) within the file he wrote. The critical impact stemmed from his ability to overwrite the JWKS files, which contain the public keys used to verify the signatures of JSON Web Tokens (JWTs) in OpenID Connect processes. By injecting his own public key (from a key pair where he controlled the private key), Bernard could effectively sign his own tokens.
These forged tokens were not just any tokens; they were service account tokens used within Azure Kubernetes. More alarmingly, these service account tokens could be exchanged at Microsoft Entra (formerly Azure Active Directory) for Entra tokens, granting access within the broader Microsoft tenant. The entire process hinges on Microsoft Entra consulting the OpenID configuration and JWKS files hosted on the now-overwritable Azure Blob Storage to validate token signatures.
Bernard's initial discovery was not an isolated incident. He subsequently found this same misconfiguration in several other critical Microsoft systems:
- Dynamics 365: Two subdomains pointed to storage containers hosting JavaScript files imported by millions of users running Dataverse and Omni Channel components. Overwriting these files could lead to widespread supply chain attacks. This particular finding was significant enough to be assigned a cloud-specific CVE.
- Streaming Content Storage: A storage account containing petabytes of streaming content was found, allowing for potential alteration of video assets.
- Microsoft Defender Threat Intel Blog: The storage account hosting images for the official threat intelligence blog could be manipulated, allowing an attacker to change official imagery.
- SPF Co-pilot Related Storage: Another unspecified storage related to "SPF co-pilot" was also vulnerable.
In total, Bernard submitted approximately 15 cases related to Azure storage container vulnerabilities in Q4 of the previous year. This, combined with 180 other reports, with over 60% rated as important or critical, propelled him to the number one spot on the leaderboard and secured his MVR status once again. The sheer scale and criticality of these findings prompted Microsoft's MSRC team to initiate a comprehensive variant hunt, signaling the widespread nature of the underlying misconfiguration.
Technical Deep Dive
▶ Watch: Overwriting JWKS and forging service account tokens (8:15)
The technical root cause of these critical vulnerabilities lies in the interplay between Azure Front Door, Azure Blob Storage, and the misapplication of managed identities and Role-Based Access Control (RBAC) permissions.
Azure Blob Storage serves as a scalable, highly available cloud object storage solution. It's structured with storage accounts, which contain containers (like directories), and within these containers reside blobs (the actual files). Access to blobs can be achieved via direct HTTP URLs or through a REST API, which supports various operations including GET for reading and PUT for writing.
Azure Front Door acts as a global entry point for web applications, providing features like a Content Delivery Network (CDN), Layer 7 load balancing, and WAF capabilities. A key configuration in Azure Front Door is the origin path, which defines how Front Door routes incoming requests to a backend service, such as an Azure Blob Storage account. When a user sends a request to the Front Door endpoint, Front Door processes it and then forwards it to the configured origin.
The critical vulnerability emerged from how Azure Front Door authenticated to the backend Azure Blob Storage. Azure Front Door can be configured to use a system-managed identity for authentication to its origins. A managed identity is an Azure Active Directory (now Microsoft Entra ID) identity that is automatically managed by Azure. When a managed identity is assigned to an Azure Front Door instance, it can then be granted specific RBAC roles on the backend storage account. For example, to allow Front Door to serve static website assets from a Blob Storage container, the managed identity would typically be granted Storage Blob Data Reader permissions. This allows Front Door to GET (read) blobs from the storage account.
The "why" behind Bernard's successful PUT request was that the managed identities associated with the vulnerable Azure Front Door instances had excessive privileges. Instead of being limited to read-only access, these managed identities were assigned roles like Contributor or other roles that implicitly included write permissions to the Blob Storage containers.
When Bernard sent his PUT request to the Azure Front Door endpoint, Front Door, acting as a proxy, received the request. The managed identity attached to that Front Door instance then authenticated to the backend Azure Blob Storage. Because this managed identity possessed Contributor (write) permissions, the PUT request was authorized and successfully executed, resulting in a 201 Created response. This bypasses any direct internet access restrictions on the Blob Storage itself, as the requests are authenticated and authorized by the Front Door's managed identity.
The impact of overwriting OpenID configuration and JWKS files is profound. OpenID Connect is an authentication layer built on OAuth 2.0, where clients obtain ID Tokens (JWTs) that assert the end-user's identity. The OpenID configuration file, typically found at a .well-known endpoint, provides metadata about the identity provider, including the jwks_uri—the URL where the JSON Web Key Set (JWKS) can be found. The JWKS contains the public cryptographic keys used by the identity provider to sign its JWTs. By controlling the JWKS file, an attacker can:
- Add their own public key to the JWKS.
- Generate a JWT (e.g., a service account token) and sign it with the corresponding private key they control.
- Present this forged JWT to relying parties (like Azure Kubernetes or Microsoft Entra ID). Since the relying party will fetch the public key from the compromised JWKS endpoint and successfully verify the signature, the forged token will be accepted as legitimate.
This allows for token forging and subsequent privilege escalation or unauthorized access. In the context of Azure Kubernetes, a forged service account token could grant an attacker control over clusters. When exchanged for Microsoft Entra tokens, the attacker could gain access to resources within the broader Microsoft cloud ecosystem, demonstrating a critical failure in the principle of least privilege. The underlying issue was a systemic misconfiguration where system-level identities were granted overly broad write permissions where only read access was required for their operational function.
Demo / Proof of Concept
▶ Watch: Understanding Azure Front Door origin paths and CDN (18:45)
While the talk did not feature a live, real-time demonstration, Vaisha Bernard meticulously described his Proof of Concept (PoC) steps, making the process clear and replicable. The core of his PoC was remarkably straightforward, relying on standard web proxy tools.
Bernard utilized Burp Repeater, a common tool for manipulating and replaying HTTP requests, to execute his PoC. The critical action was changing the HTTP method of a request from GET to PUT when interacting with the identified Azure Blob Storage endpoints (specifically those hosting OpenID configuration files).
His initial attempt with the PUT request resulted in a "missing required header" error. Crucially, the error message itself was informative, guiding him on which specific header to add to the request. After adding the necessary header (though not explicitly detailed in the slide, it was a standard Azure storage API header for PUT operations), he re-sent the request. The immediate response was a 201 Created HTTP status code, confirming that his arbitrary file had been successfully written to the Azure Blob Storage container.
To further solidify the PoC and ensure clear attribution for his bug bounty submission, Bernard embedded a unique identifier within the content of the file he wrote. He humorously mentioned adding "greetings from Wild Raccoon," referencing his adopted nickname from a previous incident.
The subsequent "demonstration" of impact was conceptual but clearly articulated:
- Overwriting JWKS: By writing a custom JWKS file (or appending to an existing one) containing a public key for which he possessed the corresponding private key.
- Forging Tokens: Using his private key, he could then sign arbitrary JSON Web Tokens (JWTs), such as Azure Kubernetes service account tokens.
- Token Exchange: These forged Kubernetes service account tokens could then be presented to Microsoft Entra ID and exchanged for Entra tokens, effectively granting him unauthorized access and potentially significant privileges within the Microsoft tenant.
Cameron Vincent later visually reinforced this flow with a diagram, illustrating how a client (representing Bernard or the "Wild Raccoon") sends a PUT request through Azure Front Door. This request is then authenticated by an over-privileged managed identity attached to the Front Door instance, which, having Contributor (write) access to the backend Azure Blob Storage, successfully writes the file. This conceptual explanation, combined with Bernard's detailed account of his actions and the system's responses, served as a compelling "proof" of the vulnerability without a live, potentially risky, in-conference demonstration.
Defensive Implications
▶ Watch: Root cause: Managed identities with excessive permissions (23:25)
The findings presented by Vaisha Bernard and Cameron Vincent offer critical defensive implications for organizations leveraging Azure and other cloud environments. The core takeaway revolves around the stringent application of the principle of least privilege.
- Strictly Enforce Least Privilege for Managed Identities: This is the paramount defensive measure. Managed identities, whether system-assigned or user-assigned, should only be granted the absolute minimum permissions required for their specific function. In the discovered vulnerabilities, managed identities associated with Azure Front Door instances had
Contributoraccess to Azure Blob Storage accounts, when onlyStorage Blob Data Reader(or similar read-only access) was necessary. Defenders must meticulously review and audit the RBAC roles assigned to all managed identities, especially those interacting with critical or sensitive storage.
- Understand Service-to-Service Authentication and Authorization: Cloud architectures often involve complex chains of services interacting with each other. Defenders must have a comprehensive understanding of how services like Azure Front Door authenticate to backend services like Azure Blob Storage, and what permissions are effectively granted at each step. This includes scrutinizing origin path configurations and their associated authentication mechanisms.
- Regular Audits of Cloud Resource Permissions: Proactive and regular audits of RBAC assignments across Azure subscriptions are essential. Automated tools and scripts should be employed to identify and flag overly broad permissions, particularly
ContributororOwnerroles assigned to non-human identities (like managed identities or service principals). Focus should be placed on storage accounts, identity providers, and critical application components.
- Monitor for Unusual Write Operations: Implement robust logging and monitoring for write operations (
PUT,POST,DELETE) on critical storage containers, especially those hosting configuration files, JavaScript assets, or public keys (like OpenID configuration and JWKS). Anomalous write activities, particularly from unexpected sources or managed identities, should trigger immediate alerts and investigation.
- Secure Identity Provider Configuration: Given the impact of manipulating OpenID configuration and JWKS files, special attention must be paid to the security of identity provider endpoints. Ensure that the storage hosting these critical files is protected by the most restrictive permissions possible, ideally read-only access for the public and tightly controlled, auditable write access for authorized deployment processes only.
- Implement WAF and Network Controls: While the vulnerability here bypassed direct storage access via Front Door, Web Application Firewalls (WAFs) can still provide a layer of defense by filtering unexpected HTTP methods or malicious payloads. Network security groups and other network controls should restrict direct access to storage accounts from the public internet, forcing traffic through controlled Front Door instances.
- Embrace Internal Variant Hunting: Microsoft's MSRC team's rapid initiation of a variant hunt underscores the importance of internal security teams adopting a similar proactive approach. Once a systemic vulnerability or misconfiguration pattern is identified, organizations should dedicate resources to scour their entire infrastructure for similar instances, rather than waiting for external reports.
- Developer Education and Secure-by-Design Principles: Foster a culture of security among development and DevOps teams. Educate them on the implications of over-privileged service accounts, the importance of least privilege in cloud deployments, and secure configuration practices for Azure services. Integrating security into the CI/CD pipeline can help catch such misconfigurations before they reach production.
By diligently applying these defensive strategies, organizations can significantly reduce their attack surface against similar misconfiguration-based vulnerabilities and enhance the overall security posture of their cloud environments.
Key Takeaways
- Don't Dismiss Simple Actions: Even the most basic changes, like swapping an HTTP
GETrequest for aPUT, can uncover profound vulnerabilities. Security researchers, especially beginners, should always test "stupidly simple things" as they often yield significant results, as demonstrated by Bernard's journey to two MVR titles. - Least Privilege is Paramount: The fundamental cause of these critical vulnerabilities was the violation of the principle of least privilege. Managed identities and service accounts must be granted only the minimum permissions necessary for their intended function, especially in complex cloud environments like Azure.
- Over-privileged Managed Identities are a Major Risk: Managed identities, while convenient for authentication, become a critical attack vector when granted excessive permissions. Their interaction with services like Azure Front Door and backend storage requires meticulous auditing and strict RBAC enforcement.
- Understand the Full Cloud Stack: Defenders and developers must fully grasp how different cloud services (e.g., Azure Front Door, Azure Blob Storage, Microsoft Entra ID) interact, authenticate, and authorize requests. A holistic understanding is crucial to identify and mitigate misconfigurations that span multiple services.
- Identity Configuration is Critical: Misconfigurations affecting core identity components like OpenID configuration and JWKS files can lead to severe consequences, including the ability to forge tokens and gain unauthorized access or privilege escalation across an organization's cloud resources.
- Proactive Variant Hunting is Essential: The MSRC's swift response with a variant hunt highlights the necessity for organizations to internally identify and remediate similar vulnerabilities once a root cause is discovered. This proactive approach is vital for containing widespread security flaws.
About the Speaker(s)
Vaisha Bernard is the Chief Hacker at Eye Security, a European cybersecurity firm based in the Netherlands with offices in Germany and Belgium, currently expanding into nine more countries. He is a two-time Microsoft Most Valuable Researcher (MVR), earning the title in both 2025 (where he achieved the #1 spot on the quarterly leaderboard in Q4) and 2026. Bernard gained prior recognition for his research presented at Black Hat, where he demonstrated how a misconfiguration allowed him to log into internal Microsoft systems. This particular incident led to him adopting the internal Microsoft nickname "Wild Raccoon." His work consistently highlights the impact of simple yet overlooked misconfigurations in complex environments.
Cameron Vincent works at Microsoft within the Microsoft Security Response Center (MSRC) and the Vulnerability & Mitigation (V&M) team. He plays a crucial role in Microsoft's incident response and variant hunting processes, which involve identifying and remediating similar vulnerabilities across the company's vast ecosystem once a specific flaw is reported. Vincent was directly involved in the variant hunt triggered by Vaisha Bernard's initial MVR-winning research and subsequently for the findings discussed in this talk. He emphasizes the immense value of external researcher submissions and the critical importance of cross-team collaboration within Microsoft to ensure the highest level of product and customer protection.
Reviews
Dr. Zero (Offensive Security Researcher) — SOLID
Solid, well-executed bug bounty war story that delivers exactly what it promises: a simple technique (GET→PUT), clear exploitation path, and a satisfying payout in critical vulns. Not novel methodology, but the AKS/JWKS angle and the Microsoft-side variant hunt perspective from Vincent add real value. Good teaching talk for the 'try dumb things' crowd.
Heather Calloway (CISO) — STRONG ACCEPT
This is a clean, actionable case study in cloud misconfiguration with immediate relevance for anyone running Azure workloads. The finding is simple — over-privileged managed identities turning read-only proxies into write-capable attack paths — but the impact is severe and the pattern is almost certainly present in your environment.