>>FIRST MISSION//LOGS//security//ublock-trusted-the-channel-not-the-sender.MD
[ + ] TARGET_LOCKED200 OK
NOV 17, 2026timer 3 MIN READSYS_TAG: security STATUS: VERIFIED_WORKING

uBlock Origin Trusted the Channel, Not the Sender

The element picker's consent gate was a button inside a web-accessible frame, so any page could drive it over postMessage and smuggle a trusted filter through a field nobody validated. One click, then attacker JavaScript on any domain. Fixed in 1.75.4, but the shape of the bug is sitting in a lot of extension code.

ENGINE: KERNEL // STABLE
BASE_ARCH: x86_64
HOST: VASTORIGINS.COM
GPG: OKSIG_ID: 0x4EB27DB0

Any extension I have written that needed a UI inside the page ended up with the same two pieces: a frame in web_accessible_resources, and a postMessage bridge to the background script. I always treated the bridge as plumbing. The uBlock Origin element picker bug argues that the bridge is the entire security boundary, and that most of us never drew it.

The short version: a website could frame uBlock Origin’s element picker, drive it with messages, and get it to install a filter that runs the attacker’s JavaScript on any domain. It took one click anywhere on the page. The maintainer fixed it within two days of the report, and the researcher’s write-up went public on 15 November.

🎯 One Click, Then Code on Every Site

Smitty van Bodegom reported it by email on 1 November 2026. The GitHub advisory is GHSA-cmqw-9r2w-6wv2, rated high severity, with no CVE and no CWE assigned. Raymond Hill shipped the fix on 3 November and published the advisory about two weeks later, once a stable build was out.

The affected target is the full uBlock Origin on Manifest V2, which in practice means Firefox, including Firefox for Android. The advisory says the same trick could pull the equivalent long secret from the MV2 Chromium build. uBlock Origin Lite, the Manifest V3 version, had what van Bodegom calls “a similar but less problematic issue.”

uBlock Origin implements the element picker by injecting an iframe pointing at moz-extension://<uuid>/web_accessible_resources/epicker-ui.html. That frame is web accessible by design, because the extension injects it into ordinary pages. It talks to the background script and tells it to add filters.

A malicious page can do exactly what the extension does. Point an iframe at that URL, make it invisible with opacity: 0, post it { what: 'epickerStart' }, and then play along with the conversation it starts. The picker sends a start message, the page replies with showDialog and a filter of its choosing, then resultsetDetails to enable the Create button. Whatever the page put in the dialog is what the user is about to approve, so position the invisible frame where any click lands on Create.

Two things had to go right, and both are the interesting part.

🔑 The Install UUID Was a Secret, Not a Boundary

Firefox does not expose a stable extension ID to pages. The moz-extension:// host is a UUID that MDN says is “randomly generated for every browser instance,” specifically to stop websites fingerprinting a browser by its installed extensions. That is a privacy control, not an authorization control, and this bug is what happens when you use one as the other.

The picker’s only protection was that a page should not be able to guess that UUID. So the attack reduces to reading it, and uBlock Origin’s own default filter lists handed it over.

A large part of what an ad blocker does is replace third-party scripts with inert local shims. When a scriptlet such as no-fetch-if intercepts a request and fulfills it with a file bundled in the extension, it makes an XHR to a web accessible resource, and that request starts from the page’s own JS environment. So the page can patch XMLHttpRequest.prototype.open, watch for anything matching moz-extension://, and grab the host the moment the extension’s own hook fires. Six lines. Then trigger the rule with a fetch('/adsbygoogle.js').catch(() => {}) and the UUID arrives.

The demo used lootdest.*##+js(no-fetch-if, adsbygoogle, war:googlesyndication_adsbygoogle.js), a rule that ships in uAssets, which means the leak channel existed on default installs with no user configuration at all. Van Bodegom is careful to say there are several ways the UUID could leak and this was only the convenient one. The war: mechanism is implicated specifically: the follow-up commits include one titled “Prevent war:-related filters for the time being.”

One scope note, because “any website could do this” is not quite it. The leak needs the victim on a page where a scriptlet rule fulfills a request with a bundled file, so any page matching a war: rule qualifies and a page with no matching rule has no hook to piggyback on. The blast radius afterwards is unlimited; the entry condition is not.

🪤 A Newline in a Field Nobody Validated

The second half is where a filter that hides things becomes a filter that executes things.

uBlock Origin supports trusted filters, which can inject scriptlets into a page. They exist so the extension can defuse ad and tracking scripts, and normally only the extension’s own signed filter lists can add them. Filters created through the element picker are trusted too, at least until the next filter-list recompile, because a human just clicked Create.

The picker does not let you type a scriptlet by hand. But resultsetDetails carries an opt field, which is supposed to be the request type to match, like image, and gets appended to the filter with a $. It is not validated. Van Bodegom’s payload sets it to "image\ngoogle.com##+js(trusted-rpnt, script, ...)", and a newline does the rest: the first line becomes the visible filter the user is nominally approving, and the second line becomes a separate trusted filter for a completely different domain.

Put together, the malicious page adds a trusted rule for google.com that injects a scriptlet. Every time the user later visits google.com, the attacker’s JavaScript runs there, in the page’s context. Repeat for the bank, the webmail, the internal admin panel.

The reason the field was never validated is the bug in one sentence: random websites were not supposed to talk to the element picker, so nobody validated what they said. That reasoning is circular in every extension that ships a post-able frame. Reachability is not a validation strategy, and postMessage does not tell you who sent a message.

🧱 The Fix Is a Shared Secret, and That Is the Lesson

The 1.75.4 release on 3 November carries a single changelog line: “Launch element picker only with a verified secret token.” The real frame now has to present a secret it gets from the content script, which the page cannot know. If it cannot prove the extension opened it, no picker session starts.

That is the right fix, and it arrived after a first attempt failed. Hill committed a fix the day after the report, and van Bodegom bypassed it within hours using a responseText getter on the XHR prototype to grab the same URL. Hill replied that he would rather not publish details until a stable release existed, then amended the commit message with the full report once 1.75.4 was live. Report to stable fix in two days, for an extension maintained largely by one person and given away for free.

Hardening continued after that. The 1.75.5 release candidates carry “Validate about to be created filter in element picker” and the war: restriction above, and PrivacyAffairs reports those reached stable in 1.76.0 on 8 November, with 1.76.2 and 1.76.4 following on 13 and 15 November. Versions at or below 1.75.2 are the unsafe line.

One figure from the secondary coverage is inference rather than vendor statement. PrivacyAffairs gives uBO Lite’s fixed version as 2026.1110.1816 and says plainly that this is “our reading of the code history,” since the same kind of safeguard landed on 3 November. The vendor has not published a Lite advisory or a version range. If you run Lite, update and move on; do not treat that number as a vendor commitment.

There is also no report of this being used against anyone in the wild, and PrivacyAffairs says it asked Hill and had not received an answer by publication. Coordinated disclosure worked here, which is worth saying out loud in a year where it often did not.

If you want to check your own install, open the uBlock Origin dashboard, go to My filters, and read it. Picker-created rules land there. Anything with +js( in it that you did not write should be deleted and applied.

🧠 Final Thoughts

The finding is a browser extension bug, but its shape is not confined to browser extensions. It is the same shape as VS Code webviews, Electron ipcRenderer bridges, OAuth popups that trust the opener, and every embedded widget that ships a postMessage listener with a wildcard target origin.

The transferable rules are short. Treat every message channel you expose to a page as a public API, because it is: anything reachable from the page is reachable by the page. Verify the sender with something it cannot forge, not with a value you assume is unguessable. Validate every field in the payload as if a stranger wrote it, including the ones that are “just” an enum. And never let an artifact inherit trust from the UI that produced it. A picker-made filter was trusted because a human clicked Create, but the click was in the DOM, and the DOM belongs to the page.

The other thing I keep coming back to is how it was found. Van Bodegom asked GPT-5.6 Sol to look for a UXSS from filter injection, the model proposed one, he verified it, and Claude wrote most of the proof-of-concept code. He wrote the prose himself and says so. That is the workflow I want: a model for the search space, a human for the judgment, a maintainer who ships in two days. The model was useful and the human was load-bearing.

Thanks for reading.

[ SIGNATURE VERIFIED // GPG 0x4EB27DB0 // PROVENANCE SECURE ]
➔ RETURN TO LOGS