Contents

CVE-2026-124855 How I Escaped Firefox's Sandbox

CVE-2026-124855 / Firefox / High / November 2026

A Blob URL comparison in Firefox let a compromised content renderer cross into a privileged about:newtab context. I chained it to native code execution, reported it to Mozilla, and eventually got a CVE with my name on it.

The whole thing came down to one equality check that matched two URLs by their text and ignored the authority behind them.

How I found it

I was reading through Firefox’s IPC and navigation code, mostly looking at how Blob URLs get passed between the content and parent processes.

Firefox serializes a Blob URL using HostObjectURIParams. Along with the URL itself, the serialized object carries a few extra fields, including a principal - the part that says who the URL speaks for.

The relevant code lives in dom/file/uri/BlobURL.cpp.

BlobURL::Serialize writes the principal into the IPC parameters, and BlobURL::Deserialize restores it on the receiving side.

That part made sense. What caught my attention was how Firefox compared two Blob URLs.

BlobURL::EqualsInternal delegated the comparison to nsSimpleURI. It compared the URL, but not the embedded principal.

So two Blob URL objects could have the exact same URL string while carrying different security principals, and Firefox would still treat them as equal.

Conceptually:

URI A:
  spec      = blob:null/<UUID>
  principal = NullPrincipal

URI B:
  spec      = blob:null/<UUID>
  principal = about:newtab principal

URI A == URI B  -> true

Same URL, different authority.

Normally that difference shouldn’t be something an untrusted content process can exploit. But then I found where the equality check was actually being used.

Where it actually mattered: ResultPrincipalURI

Firefox’s nsDocShellLoadState carries a ResultPrincipalURI, which can influence the principal associated with a navigation.

There was a check meant to make sure that a renderer-supplied result principal URI matched the main URI.

The important condition was effectively:

mResultPrincipalURI->Equals(mURI)

The problem was what Equals meant for a Blob URL: that same check from before, the one that never looked at the principal.

That meant I could hand over two Blob URL objects with the same blob:null/<UUID> string but different principals.

One was the real Blob URL, registered with a NullPrincipal. The other carried a forged principal tied to about:newtab.

The equality check passed - same string, so as far as Firefox was concerned, same URL.

But later, when it built the document’s principal, it could pick up the principal from the forged result URI.

The check that was supposed to keep the two URIs consistent never compared the thing that actually mattered.

The question was whether this was just a weird inconsistency or something I could turn into a real sandbox escape.

Getting into privilegedabout

Firefox uses a separate privilegedabout process for certain internal pages, including about:newtab.

If a compromised content renderer could get attacker-controlled content committed there with the wrong principal, that was the whole game.

I built a PoC on a local Firefox build from the September 14, 2026 mozilla-central revision.

I used source-side instrumentation to simulate control over the content process. The instrumentation gave me the IPC sender and some logging; it didn’t bypass any of the security checks on the receiving side.

The navigation itself went through Firefox’s normal IPC path:

Compromised content renderer
        |
        v
SendInternalLoad
        |
        v
Parent RecvInternalLoad
        |
        v
nsDocShellLoadState validation
        |
        v
ResultPrincipalURI equality check
        |
        v
Document commit

The payload used a live Blob URL as the main URI and a second Blob URL with the same string but a forged result principal.

The parent accepted the load, and the document was committed in privilegedabout with about:newtab authority.

That was the boundary crossing I was looking for.

To make sure I wasn’t just watching a normal navigation, I ran a control test with the same content and the same IPC path.

The only thing I changed was the embedded principal.

TestResult
Forged about:newtab principalPrivileged commit, access to the privileged context
Real NullPrincipalUnprivileged commit, cross-origin access denied

Both cases passed the URL equality check. Both reached the parent.

Only one got the privileged authority.

So the principal mismatch wasn’t just a theory - it was the bug.

From sandbox escape to native code execution

Landing in privilegedabout was already a sandbox escape. I wanted to know how far it could go.

I kept digging through the privileged functionality I now had access to, and found a path through Firefox’s download and file-opening behavior on Windows.

For the final test, I used the Windows Calculator executable as a harmless witness.

The PoC served a signed copy of calc.exe from a local loopback server. The test recorded the downloaded file, checked its SHA-256 against the original, inspected the Mark-of-the-Web state, and traced the native process launch.

The positive case reached the file-opening path, and a Calculator window popped up on the desktop.

The control case did nothing.

For evidence, I had:

  • A successful commit in privilegedabout with about:newtab authority.
  • A saved executable whose hash matched the signed source file.
  • No Zone.Identifier on the saved file.
  • A native file-launch call and an observed Calculator process.
  • A control run that didn’t produce the same privileged effects.

The whole chain started from an already compromised content renderer. I wasn’t claiming that just visiting some web page would trigger RCE on its own, without an initial compromise.

But a sandbox escape is exactly what matters once an attacker already has code execution in the renderer.

I submitted the full chain as Bug 2072096.

Mozilla’s response

Vincent Hilla from Mozilla picked up the report.

He mentioned that my original PoC was rather long and that he’d used Claude to help understand it. Fair enough. The submission came with a full Windows reproduction setup, instrumentation, positive and negative tests, process traces, and supporting evidence.

He then attached a smaller PoC showing the path from compromised content to about:newtab.

He also confirmed the root cause: the equality check ignored the principal entirely.

There was one complication.

Vincent was already working on another bug, 2061520, which involved inconsistent principal information in Blob URLs.

He considered my report partly overlapping with that earlier issue.

I explained that I had also demonstrated the rest of the chain, all the way to native code execution, and left the reports with them.

By then the fix was already taking shape.

The fix

The main patch landed in late October:

Bug 2072096 - Ensure all blob:null URIs hold consistent principals

Instead of trusting the principal stored in each serialized Blob URL on its own, Firefox now tracks the association between Blob URLs and their principals.

One of the important changes is in BlobURL::Deserialize:

auto principalEntry = BlobURLPrincipalEntry::Intern(
    SpecIgnoringRef(), hostParams.nullPrincipal());

if (principalEntry.isErr()) {
    NS_ERROR("Received inconsistent principal entry for BlobURL");
    return false;
}

In other words, Firefox now rejects a Blob URL whose principal doesn’t line up with what it already recorded for that URL.

The fix also keeps these associations around for parsed Blob URL objects and registered Blob data.

That closes the inconsistency my PoC relied on.

Mozilla landed the fix in the development branch and uplifted it to Firefox 160 and Firefox ESR 153.7.

On November 10, Mozilla published its security advisory.

The issue got CVE-2026-124855, rated High, with the description:

Sandbox escape in the DOM: Navigation component

The advisory listed:

Reporter: Tran Quac

I was pretty happy to see that.

Timeline

  1. Dug into Firefox’s Blob URL principal handling and submitted Bug 2072096 with the Windows reproduction and exploitation evidence.
  2. Mozilla reproduced the privilege-escalation path.
  3. Mozilla developed and landed the principal-consistency fix.
  4. CVE-2026-124855 published, credited to Tran Quac.

Final thoughts

I’m glad Mozilla fixed it, and the engineers who dug through the report and shipped the patch did careful work.

This was my first sandbox escape in Firefox, and what still gets me is how small the root cause was: one equality check that matched two URLs by their text and never asked who they spoke for. That was enough to walk a compromised renderer into a privileged process, and from there to native code.

A sandbox escape, a working RCE chain in my lab, and an official CVE - all hanging off one missing comparison.

References

Quac Tran