- What happened: A high-severity advisory shows web pages could drive uBlock Origin’s element picker and add trusted filters.
- Who is affected: uBlock Origin 1.75.2 and lower, mainly the Firefox MV2 build.
- What to do now: Update. Mozilla’s listing showed 1.76.4 on November 15, 2026. Patched floor is 1.75.4.
- Interview angle: postMessage trust, clickjacking, universal XSS and why “what you show” must equal “what you commit”.
The uBlock Origin XSS bug let a malicious page talk to the extension’s element picker, hide it under a click target, and add a filter the user never saw. Trusted filters can run scripts on other sites, so one click became universal XSS. Version 1.75.4 patches it. Update to the latest release.
Universal XSS (UXSS) is cross-site scripting that works across many sites, not just one buggy app. It comes from a flaw in something that sits above every page, such as the browser or an extension. It breaks the same-origin policy for sites that did nothing wrong.
The uBlock Origin XSS disclosure landed on November 15, 2026, and it reached the top of Hacker News within hours. Most coverage stops at “update now”. This post covers the patch, then the reusable lesson: the bug class is the same one that hits embedded widgets, payment iframes and OAuth popups in ordinary web apps. I also ran a small Node.js demo of the vulnerable and fixed message-handling patterns.
What changed and who is affected by the uBlock Origin XSS?
The maintainer published GHSA-cmqw-9r2w-6wv2 on November 15, 2026, rated High. It lists no CVE ID and no CVSS score. A researcher reported it by email on November 1, 2026. Fixes shipped in stages over the following week.
| Item | Value | Source |
|---|---|---|
| Affected | 1.75.2 and lower | GHSA advisory |
| Patched (advisory) | 1.75.4 | GHSA advisory |
| Picker requires secret token | 1.75.4, Nov 3, 2026 | Fix commit 9859477 |
| Picker validates new filter; war: filters blocked | 1.76.0, Nov 8, 2026 | Commits b1f7d27, 150df12 |
| Latest on Firefox Add-ons | 1.76.4, updated Nov 15, 2026 | addons.mozilla.org |
| Install base (Firefox) | about 11.5 million users | addons.mozilla.org |
The proof of concept targeted the Firefox Manifest V2 build. The researcher’s write-up says uBlock Origin Lite, the MV3 version, had a similar but less serious issue that is also fixed. The researcher credits GPT-5.6 Sol with most of the discovery work, which fits the trend we covered in AI-driven vulnerability discovery.
How does the uBlock Origin XSS work?
This is a trust-boundary bug, not a classic injection into HTML. Here is the chain at advisory level. I have left out the parts that would make it a recipe.
- Locate the extension. Firefox extension URLs include a per-install random UUID. A scriptlet path leaked that UUID to the page.
- Embed the privileged UI. The page loaded the element picker, an extension page, in an iframe.
- Drive it with messages. The picker accepted control messages without verifying the sender.
- Show one filter, save another. An unvalidated field let the saved filter differ from the displayed one, per the advisory.
- Get a click. The picker could be made invisible under a page element. One click pressed the hidden button.
- Run anywhere. Picker-created filters were treated as trusted, and trusted scriptlets can execute script on other sites.
Each step is a familiar web bug: an information leak, an unauthenticated message channel, a display/commit mismatch, and clickjacking. Chained, they give universal XSS. It is a textbook confused deputy: privileged code used its authority on behalf of an untrusted page.
Vulnerable vs fixed pattern, tested in Node.js
The real fix makes the picker demand a verified secret token that only the extension’s content script holds. To show why that works, I wrote a generic widget that accepts commands over a MessageChannel. It contains no uBlock code. I ran it with Node.js v22.23.4.
// picker-demo.mjs — generic pattern, no uBlock code
import { randomBytes, timingSafeEqual } from 'node:crypto';
function makeWidget({ requireToken }) {
const secret = randomBytes(16); // given only to the trusted launcher
const committed = [];
const { port1, port2 } = new MessageChannel();
port1.on('message', (msg) => {
if (requireToken) {
const got = Buffer.from(String(msg.token ?? ''), 'hex');
if (got.length !== secret.length || !timingSafeEqual(got, secret)) {
committed.push({ rejected: msg.cmd }); return;
}
// what gets saved must equal what the user was shown
if (msg.cmd === 'commit' && msg.payload !== msg.shown) {
committed.push({ rejected: 'display/commit mismatch' }); return;
}
}
if (msg.cmd === 'commit') committed.push({ accepted: msg.payload });
});
return { port: port2, token: secret.toString('hex'), committed };
}
// Three senders: trusted launcher, untrusted holder of the port,
// trusted token with a payload that differs from what was shown.
Output from node picker-demo.mjs:
node v22.23.4
NAIVE [{"accepted":"rule-A"},{"accepted":"rule-EVIL"},{"accepted":"rule-B"}]
FIXED [{"accepted":"rule-A"},{"rejected":"commit"},{"rejected":"display/commit mismatch"}]
The naive handler accepts everything, including a message from a sender that merely holds the port. The fixed handler rejects the tokenless message and the payload that differs from what was shown. Note that MessagePort messages carry no reliable sender origin, so a capability token is the right tool here.
What should developers do right now?
- Detect. In Firefox, open Add-ons and Themes and check the uBlock Origin version. This guide shows the exact menu path.
- Patch. Update to the latest stable. The floor is 1.75.4; the listing showed 1.76.4.
- Audit your own message handlers. Every
messagelistener should checkevent.originagainst an allowlist, as MDN advises. Never post sensitive data with a*target origin. - Use capability tokens on ports. If you hand out a
MessagePort, require a per-session secret, compared in constant time. - Re-validate at commit time. Save only what the user saw and confirmed. Rebuild the value server-side or in the trusted context.
- Block framing of sensitive UI. Set CSP frame-ancestors on pages with privileged buttons.
- Extension authors: keep web_accessible_resources minimal. Chrome added dynamic WAR URLs in Chrome 130 to reduce fingerprinting.
For more on auth boundaries in modern frameworks, see our Next.js 16 auth security mistakes guide.
Interview questions this update prepares you for
How do you handle postMessage securely between frames?
On the receiving side, check event.origin against an exact allowlist before reading event.data. Treat the data as untrusted input: validate its shape and never pass it to innerHTML or eval. On the sending side, always give an explicit target origin instead of *, because the target window may have navigated somewhere else. If you use MessageChannel, remember a port has no origin of its own. Whoever holds it can send, so pair it with a secret or capability token.
Follow-up they may ask: Why is event.source alone not enough?
What is clickjacking and how do you prevent it?
Clickjacking loads a target page in an invisible or disguised iframe. The victim thinks they are clicking the attacker’s page but actually clicks a button in the framed page. Defences start with refusing to be framed: Content-Security-Policy: frame-ancestors 'self' or the older X-Frame-Options. For actions that must be embeddable, require a deliberate confirmation step or a second gesture.
Follow-up they may ask: Why does SameSite cookie policy not fully solve clickjacking?
How is universal XSS different from stored or reflected XSS?
Stored and reflected XSS are bugs in one application. Attacker input ends up as script in that app’s pages, so the damage is limited to that origin. Universal XSS comes from a component trusted by every origin, usually the browser or an extension. It lets an attacker run script in sites that have no bug at all. It is often treated as more severe. App-level defences like output encoding and CSP on your site may not stop it, because the script is injected from above.
Follow-up they may ask: Can a strict CSP on your site block an extension-injected script?
The NexGismo verdict: My recommendation is to update today and then audit your own message listeners this week. The uBlock Origin XSS is not exotic. It is four ordinary mistakes chained together, and most web apps with embeds or popups have at least one of them.
- The uBlock Origin advisory GHSA-cmqw-9r2w-6wv2 is rated High and lists 1.75.2 and lower as affected.
- Version 1.75.4 is the patched floor; 1.76.0 added filter validation in the element picker.
- The attack needed one user click on a malicious page, using a hidden picker iframe.
- Picker-created filters were trusted, which turned a UI bug into universal XSS.
- Message ports have no sender origin, so privileged handlers need capability tokens.
Frequently Asked Questions
Is uBlock Origin safe to use after the XSS bug?
Yes, once it is updated. The advisory lists 1.75.2 and lower as affected and 1.75.4 as patched. Further hardening shipped in 1.76.0, and Mozilla’s add-on page showed 1.76.4 on November 15, 2026. Check your installed version in the Firefox add-ons manager and update if it is older. Auto-updates normally handle this for you.
Which uBlock Origin version fixes the universal XSS?
The GitHub advisory marks 1.75.4 as the patched version. Two of the four fix commits landed in 1.76.0, which added filter validation in the picker and blocked war:-related filters. The safest choice is the latest stable release, which was 1.76.4 on Mozilla’s add-on page on November 15, 2026.
Does the uBlock Origin XSS affect Chrome?
The proof of concept targeted the Firefox Manifest V2 build. The reporter told the maintainer that the same secret could be extracted on MV2 Chromium builds. The researcher also says uBlock Origin Lite, the Manifest V3 version, had a similar but less serious issue that has been fixed. Update whichever build you use through its browser store.
What is a universal XSS vulnerability?
Universal XSS (UXSS) lets an attacker run script on sites they do not control, not just on one vulnerable site. It usually comes from a bug in the browser or a browser extension, which sits above every page. Normal XSS is a flaw in one web app. UXSS breaks the same-origin policy for many sites at once, which makes it more serious.
The uBlock Origin XSS is fixed, and updating takes seconds. The bigger value is the pattern. Any privileged UI that takes commands from a less trusted context must authenticate the sender and commit only what the user saw. If your app uses iframes, popups or message channels, review those handlers now. Have a question about your setup? Leave a comment and we will look at it in a follow-up.
Sources
- GitHub — gorhill/uBlock advisory GHSA-cmqw-9r2w-6wv2
- iter.ca — Universal XSS in uBlock Origin from website-driven element picker
- Mozilla Add-ons — uBlock Origin listing
- All About Cookies — uBlock Origin security flaw update
- MDN — Window.postMessage() security concerns
- MDN — CSP frame-ancestors
- MDN — web_accessible_resources
- Chromium Extensions — PSA: Dynamic URL support in Chrome 130
