- Orange Tsai demonstrated at Pwn2Own how a chain of logical errors allowed one to escape Edge's isolation without memory corruption.
- The first bug affected a login navigation with Entra ID and ended up enabling a UXSS by associating with the active tab.
- The sequence took advantage of Immersive Reader mode and a diagnostic function to write files and eventually execute code outside the browser.
- Microsoft fixed the problem in Edge Stable 148.0.3967.70 with several CVEs and the case was settled with $175.000 and 17,5 points.
Microsoft Edge has once again found itself at the center of a security news story, although this time the issue has nothing to do with performance improvements or new productivity features. A researcher managed to break the browser's isolation through a series of logical errors, without resorting to the classic memory vulnerabilities that usually appear in these types of attacks.
The demonstration was presented at the Pwn2Own competition and earned the author $175.000 and 17,5 points . What's striking is not just the prize, but how it was won: the attack relied on design flaws and poorly implemented checks, not on memory overflows or the use of already freed memory. This detail significantly changes the perspective on where to look when reviewing browser security.
The starting point was a navigation process that Edge initiated for a corporate login flow using Entra ID . This operation wasn't properly linked to the content that triggered it. If the user switched tabs before the process finished, the code could end up executing with the origin of the site that was active at that moment. This is where the first serious problem appears: a UXSS vulnerability, that is, the ability to execute JavaScript in the context of another website.
To prevent the issue from remaining merely a theoretical flaw, the chain required more pieces. These included a CORS configuration of assets.msn.com that allowed access to the email of the connected account. Checks related to trusted sources, pop-ups, and automatic login also had to be overcome. None of these pieces, on their own, explained the full extent of the problem; the danger lay in how they were combined.
From a web script to execution outside of isolation
Simply remaining within the browser wasn't enough to complete the demonstration. The researcher used Immersive Reader's read-only mode , which operates under the read:// scheme, to gain an additional foothold. He then exploited an internal function intended for diagnostic logs and used it to write a file with a name and content controlled by the attacker to a location on the system.
This file writing allowed modification of the configuration that determines which sites can launch specific protocol handlers. After restarting Edge, the string launched a telnet:// connection . Since Windows doesn't include a telnet client by default, the system searched for the program in the folders included in the PATH; one of these could be written to by a user without privileges. The executable that closed the loop outside the isolation was placed there.
Two months of work and less than one hundred lines
Researcher Orange Tsai explained that he spent about two months manually preparing the code string. The final result was much more compact than expected: the complete exploit was less than 100 lines long. Even so, the difficulty wasn't in writing that many instructions, but in finding and fitting together the necessary logic errors to make everything work.
The work received 17,5 Master of Pwn points and the aforementioned $175.000. Since it was a contest entry, the focus is on the technique and the lessons it offers to software designers and reviewers, rather than on widespread use by attackers.
The patch that closed the chain
Microsoft released the fix on May 15th in Edge Stable version 148.0.3967.70 . The security notes list several references to this issue: CVE-2026-45492, CVE-2026-45494, and CVE-2026-45495. The update resolves the described vulnerability chain, so it's advisable to ensure your browser is up to date.
Beyond this specific case, the incident offers a valuable warning for any software development team. Source checks, CORS configurations, and login flows often seem like minor details, but they can become the gateway for a chained attack. Reviewing business logic and standard processes with the same rigor applied to memory vulnerabilities is a task many organizations still need to address.
The Edge story serves as a reminder that a browser doesn't break solely due to low-level errors. Sometimes, it only takes several seemingly innocuous decisions coming together in the right order. The combination of poorly implemented navigation, email access facilitated by CORS, read-only mode, and file writing turned a series of oversights into a chain of events capable of breaking through isolation. The patch is now available; the underlying lesson remains the importance of thoroughly reviewing the logic before assuming that a simple component is secure.