NebuSec says a webpage led to root in a Meta Muse VM; 49 days from test to post, no fix dates, no Meta statement read
NebuSec's two pages of 20 November 2026 describe a lab chain from an exported webpage to root in a Meta Muse user VM, tested on 2 October, 49 days earlier (derived). Every stage is NebuSec's own claim; no Meta statement, fix date or CVE is in the saved set.
By Parminder Kumar Sharma · LinkedIn · · 20 min read
49 days from a stated test date to publication, and no fix date or Meta statement in the saved pages (derived)
NebuSec, a security company, published two pages on 20 November 2026 (the page data gives the date and no time). The overview, headed "Hacking Muse: Stealing Private Chats Through Browser Use" and served at an address that says credential exposure, and a longer technical post, titled "Inside Meta Muse: Browser, Sentinel and the Shared-Kernel Boundary" and described as the first in a series, tell the story of a lab demonstration against Meta's Muse. Muse, as NebuSec describes it, is a cloud hosted AI assistant that runs one agent per user in its own virtual machine (VM). This site saved the overview at about 15:57 UTC and the technical post at about 17:11 UTC on 21 November 2026.
NebuSec's account has three stages. One: asking Muse to export an attacker controlled page gave code execution inside the agent's runtime container, through a flaw in a Chromium build that NebuSec says lagged Chrome releases. Two: weaknesses in how an egress guard called Sentinel classified and inspected outbound requests let NebuSec send a user's conversation history and stored memories to its own server without an approval prompt, and alter stored memories and history. Three: Linux kernel exploits from NebuSec's automated exploit generation framework escaped the container and gave root in the user's VM, which NebuSec says exposed persistent storage, "Secure Credential Storage" and Sentinel itself.
The only test date either page prints is "Oct. 2", for the kernel step, and neither page prints a year. From that day to the 20 November publication is 49 days (derived: 29 days left in October after the 2nd, plus 20 in November). The pages do not say when NebuSec reported to the Muse team, when any fix shipped, or how long any of this was possible. They say that all of the exploits described had been patched by publication: the overview writes "all exploits described in our research had been patched by the time of publication".
What that does not establish. Everything above is NebuSec's account. Meta's own post on security for Muse, linked from the technical post, was not read: this site's check of that host's robots.txt returned 200 and disallows automated clients, so nothing was requested from it. No Meta statement, advisory or CVE record is in the saved set. Neither page reports an affected user, says whose Muse account the tests ran against, or says anything was exploited outside NebuSec's own runs. The demo video on the overview was not saved or viewed. NebuSec sells security audits, code security and incident response, and its pages invite readers to book a demo; the overview's last piece of advice, "Validate whether vulnerabilities can actually be exploited", describes what its audit service sells ("validated with working exploits"). This site shares no vendor's interest. It names no individual: the pages name none.
The dates NebuSec prints, to scale, and the ones it leaves out
The technical post prints its dates without years, with one exception. The kernel in the test VM carried a build stamp of Thursday 24 September 2026, which with the 20 November page data points to 2026 for the others (inference). The Chromium patch release in the bundled browser "shipped on Sept. 3". The kernel test was on "Oct. 2". The pages are dated 20 November. NebuSec writes "In early October" for the browser snapshot, with no day.
Spans between the dates NebuSec prints (derived by this site; arithmetic shown)
| Span | Days | Arithmetic and caveat |
|---|---|---|
| 3 Sep Chromium patch release to the 2 Oct test | 29 | 27 days to 30 Sep, plus 2 (1 and 2 Oct). Holds only if the browser snapshot was taken on the test day; the page says "early October" and does not tie it to the 2nd |
| 24 Sep kernel build stamp to the 2 Oct test | 8 | 6 days to 30 Sep, plus 2 |
| 2 Oct test to the 20 Nov publication | 49 | 29 days left in October after the 2nd, plus 20 in November |
| 3 Sep patch release to the 20 Nov publication | 78 | 27 plus 31 (October) plus 20 (November) |
| 24 Sep kernel stamp to the 20 Nov publication | 57 | 6 plus 31 plus 20 |
| Report to the Muse team, each fix, the end of any exposure | not stated | Neither page prints a date or a span for any of them |
The span that matters to a Muse user is not in any of those rows: how long the chain could be run, and by whom, before the fixes. The pages give the test date and the publication date and nothing between. A reader should not take 49 days as an exposure window or a fix time. It is the gap between a stated test and a post.
The design NebuSec describes, and the three stages it says crossed it
From the technical post: Meta provisions a 2 vCPU, 8 GiB Cloud Hypervisor VM for each user, starts a systemd-nspawn container inside it and runs a Codex-like Muse agent in the container. The agent runs as root inside the container, which NebuSec says does not give it root in the VM. Memories and conversation history live on persistent storage dedicated to that VM. NebuSec adds that the Muse website, mobile app and WhatsApp assistant "all connect to the same agent in the user's VM"; this site cannot say how that works in practice, and it is NebuSec's description.
Three services sit outside the container, inside the VM, according to NebuSec: a safety reviewer for model input and output, Sentinel, and a credential mediator. Sentinel audits outbound traffic from the runtime container. The agent holds stand in tokens, and Sentinel replaces them with connector scoped credentials in outbound requests, so the real credentials stay out of the agent's reach. NebuSec's reading of the intent: if Muse runs untrusted code, for example a compromised dependency, Sentinel should still intercept that code's outbound requests and apply the same rules.
Stage one, in NebuSec's words, is a "0.5-click RCE": a single request to export a malicious web page gave command execution in the runtime container. The trigger it describes is a user asking Muse to save an attacker controlled page. Neither page says how an attacker gets a user to ask, or whether Muse would export a page unprompted. Stage two is the one the overview leads with: the user's conversation history and stored memories went to an outside server, and entries could be added to or changed in the history and the memories. Stage three is the kernel step. NebuSec says root inside the container alone was not enough: it "didn't immediately grant unrestricted network access or access to the underlying VM". The kernel step did.
Four ways Muse browses, and the one NebuSec used
NebuSec says Muse chooses among four browser backends according to the task, and its table lists each. NebuSec says it "focused" on one of the four: the bundled Chromium that the agent starts directly or through Playwright, used for reviewing page screenshots, generating file thumbnails and exporting PDFs. That one inherits the runtime container's path through Sentinel. NebuSec says the two local backends used different network boundaries, and that a browser exploit "inherited the egress policy of the backend it compromised", which for the bundled browser is still Sentinel.
On the version, NebuSec writes that Muse updates its bundled browser from time to time, but "our snapshots showed it lagging behind Chrome releases". "In early October" the container still carried Chromium 152.0.7977.82; NebuSec says that major version entered stable in August and that this patch release shipped on 3 September. A later snapshot carried 155.0.8059.80, and the table prints that version for all three Chromium backed paths, with no date. If the snapshot was taken on the test day, the build was 29 days past its patch release (derived, and only on that assumption). NebuSec calls the gap a window for flaws that were already public. This site prints no flaw identifiers: the saved page lists tracker numbers for browser bugs, and an n day flaw in a lagging build is not something to hand a reader.
The sandbox is the second claim. "The Chromium process used for PDF export had its IPC sandbox disabled." NebuSec says that when a user asked Muse to save an attacker controlled page, a single renderer bug, "worth about $500", was enough to run shell commands in the runtime container with the agent's privileges. NebuSec does not say what the dollar figure measures, and it is not independently sourced. The sentence says a single bug was enough; it does not say that bug was public, though the same section is about public ones.
Sentinel: a guard that runs beside the thing it guards
NebuSec's account of how Sentinel works is the longest part of the technical post. Sentinel attributes each request to the process that made it and applies built in policy rules. Requests are split into reads and writes, and the two are treated differently. Content is screened for sensitive data, checked for entropy, sent to a model for review when suspicious, and counted against traffic budgets per originator and per domain over a rolling window. This site prints none of the thresholds, encodings or rule details the page gives, and none of what NebuSec says it did to pass the checks. The page names the stages; that is enough to know what the design intends.
What the pages do say about outcome is short. "Our first attempts to send command output to an external server produced approval prompts." The approval prompt, NebuSec says, appeared even for programs running as root inside the container, because the decision comes from outside it. After studying Sentinel's policy, NebuSec says it used the browser chain to send the user's conversation history and stored memories to its own server without a prompt, and to inject entries into the history and alter stored memories. The overview puts it as retrieving them "without triggering Muse's network approval prompts". The two pages differ on one point here: the overview says no prompt was triggered, the technical post says the first attempts did trigger one.
Where the check runs is the second half of the Sentinel story. NebuSec says the container's only external interface leads to Sentinel, that its DNS and proxy answer there, and that a kernel level program attached to the container's control group redirects direct connections to Sentinel too. After the kernel step gave VM root, NebuSec says the hook "did not cover processes running directly in the user VM", and "Those processes could send outbound traffic without passing through Sentinel." The VM, it adds, had its own public IPv6 address. The overview states the principle: network monitoring can restrict unauthorised communication, but its effectiveness depends on where enforcement occurs and whether compromised processes can operate outside that boundary.
The kernel step: what NebuSec says, and what it does not name
NebuSec says the user VM ran a custom, heavily stripped, Ubuntu based kernel in the 7.0 line, with a build stamp of 24 September 2026, 8 days before the Oct. 2 test (derived). It says many hardware drivers, file systems and peripheral protocols were removed, and that interfaces such as KALLSYMS_ALL and /proc/kcore were disabled. It also says several security hardening options were disabled (the page names three; this site does not repeat them). A defender can check the hardening options of any kernel build that sits under agent code. NebuSec says it had no copy of the target kernel image to study, so its exploits had to work without fixed offsets.
NebuSec writes that "Linux 7.0 fell within the published affected ranges of multiple CVEs". It does not name them, and neither does this site. The technical post says nothing about which kernel flaws were used, whether they are fixed in mainline Linux, or what Meta did about them: change the kernel, change its configuration, or both. A reader who runs a similar stack therefore cannot tell from these pages which kernels to check. NebuSec says it will describe its pipeline in a later post, and that it keeps monitoring new vulnerabilities.
Two numbers are NebuSec's own. The exploits "succeeded more than 99.9% of the time" in its test runs (the overview: "more than 99.9% of test runs"). Neither page gives the number of runs, so the figure cannot be turned into a count of failures; more than 99.9 percent success means a failure rate below 0.1 percent (derived: 100 minus 99.9), on a count of runs the pages do not give. And "More than 170 of our patches have already been merged into mainline Linux". That sentence is about NebuSec's wider kernel work, not Muse. This site did not check either figure.
After root: what NebuSec says it reached, and what it says it did not
What NebuSec says it reached at each step, and the limits it states (technical post and overview, read 21 November 2026)
| Step | What NebuSec says was reached | What NebuSec says was not |
|---|---|---|
| Stage one: container code execution | Commands inside the runtime container with the agent's privileges; the user's data in the container | Unrestricted network access; the VM. NebuSec says root in the container alone did not give those |
| Stage two: egress without a prompt | History and memories sent to an outside server; entries added to and changed in history and memories | How long it worked, and whether Sentinel's rules have since changed: not stated |
| Stage three: VM root | Persistent storage not mounted in the container, "Secure Credential Storage", Sentinel itself, the target kernel image under the boot directory | The hypervisor host and other tenants. Nothing about using any credential found |
| After stage three | Outbound traffic from VM processes that Sentinel's hook did not cover | Any effect on a connected service (the overview names email, documents and collaboration platforms as what agent credentials can reach, as context, not as a result) |
NebuSec says the persistent state sat on a LUKS2 volume that was "already unlocked and mounted in the VM", so root in the VM saw what the container could not. That is the point the overview makes about credentials: separating them from the agent's runtime reduces risk, but "that protection depends on the integrity of the boundary separating those resources". The fourth of the overview's key findings begins "Credential storage became accessible". The word is accessible. Neither page says what the storage held, that any credential was read out of it, or that any credential was used.
Friendly names doing the work of evidence
Four labels in this story each sound like a result. Secure Credential Storage is a product name; NebuSec says VM root exposed it, and says no more about its contents. Sentinel is a guard that runs outside the container; the overview's own phrase is that security controls can work as designed while still failing to prevent a complete attack chain. Approval prompt is a user control that NebuSec says appeared at first and then did not. Patched is the fourth. The overview says all exploits described "had been patched", and the technical post says the Muse team "was aware of every finding described here and had patched all exploits". An exploit is patched when the flaw it uses is fixed or the path it needs is closed; neither page says which, per stage, or when. Being aware of a finding and fixing it are two separate claims, and the pages make the second for exploits, not for each weakness.
What NebuSec states, and what it does not
Stated and not stated across the two saved NebuSec pages (read 21 November 2026)
| Question | What NebuSec states | What the pages do not state |
|---|---|---|
| Did a webpage lead to code execution? | Yes, in the runtime container, after Muse exported an attacker controlled page | How an attacker gets a user or the agent to export it; whose account the test used |
| Did data leave without a prompt? | Yes: conversation history and stored memories to NebuSec's server | Volume, duration, any real user's data |
| Could data be changed? | Yes: entries added to history, stored memories altered | Whether a later conversation used the changed entries |
| Was the VM root reached? | Yes, with kernel exploits from NebuSec's framework | The CVE ids, the exploit method (this site prints none), Meta's kernel fix |
| Were credentials taken or used? | VM root "exposed" credential storage | Any credential read, any connector used |
| Was it fixed? | All exploits described were patched by publication; the Muse team was aware of every finding | Report date, each fix date, what was changed |
| Did Meta confirm? | Nothing in the saved set. Meta's own post was not read (robots disallow) | Any Meta statement, advisory, bounty or CVE |
| Was anything exploited in the wild? | Neither page says anything about it | Any victim, any attacker, any count |
| Could it be reproduced independently? | The demo video is described as obscured | Any third party check |
| Which model runs inside Muse? | Neither page says. The agent is called "Codex-like" | The model, its vendor, its version |
Where the two NebuSec pages differ
The overview and the technical post come from the same company a day apart in the saved copies, and they are not worded alike. The differences are small and they matter to a reader who only reads the overview.
Points where the overview and the technical post word the same event differently (read 21 November 2026)
| Point | Overview | Technical post |
|---|---|---|
| Name of the page | Headed "Hacking Muse: Stealing Private Chats Through Browser Use", served at an address that says credential exposure | Titled "Inside Meta Muse: Browser, Sentinel and the Shared-Kernel Boundary" |
| Approval prompts | Data retrieved "without triggering Muse's network approval prompts" | "Our first attempts to send command output to an external server produced approval prompts." |
| Credentials | "Credential storage became accessible"; storage exposed | VM root let NebuSec "access" Secure Credential Storage; nothing about contents |
| Fixes | "all exploits described in our research had been patched by the time of publication" | Muse team "was aware of every finding" and "had patched all exploits described in this post" |
| Link to Meta's post | None in the saved text | Linked twice; NebuSec cites it for the brokered browser and for io_uring handling |
| Trigger | "By having the agent export an attacker-controlled webpage" | "When a user asked Muse to save an attacker-controlled page"; called a 0.5 click |
What to do, in order
First what NebuSec advises, then this site's suggestions, marked as such.
Take this with you
Actions, in the order worth doing
- NebuSec's advice: protect credentials beyond the agent's runtime, and design credential protections to limit the consequences if an attacker escapes the sandbox, including restricting credential scope and access.
- NebuSec's advice: evaluate the whole execution environment, meaning the browser, the container, the operating system, the network enforcement and the credential service, and test whether their boundaries hold against chained attacks.
- NebuSec's advice: validate whether vulnerabilities can actually be exploited. It sells that service; the point stands or falls on the evidence a test produces, not on who sells it.
- This site's suggestion: if you build an agent that renders web pages, treat the renderer as a code execution surface. Keep its browser on the browser vendor's patch cadence and leave the browser's own sandbox on.
- This site's suggestion: enforce egress where the agent cannot step outside the enforcement. NebuSec says processes in the VM itself bypassed a container level hook, which is why where the check runs matters as much as what it checks.
- This site's suggestion: do not let untrusted agent code share a kernel with credential holders unless the kernel is hardened and patched on a cadence to match. Check the hardening options NebuSec names in your own builds.
- This site's suggestion: scope connector credentials narrowly, so that a compromise of the machine the agent runs on reaches little.
- This site's suggestion, for users: think before asking any assistant to save or export a page from a site you do not know, and review stored memories for entries you did not write. NebuSec says memories could be altered.
- This site's suggestion: where Meta publishes a statement, advisory or fix dates for this chain, read them before taking NebuSec's account as complete. None was in the saved set.
The nesting NebuSec prints
The technical post prints one block that a builder can copy into a design review: the nesting of a Muse agent, from the host to the agent. A defender uses it as a checklist of boundaries, asking for each arrow what enforces it and where that check runs. The post prints more, including addresses, socket paths, ranges, thresholds, flaw identifiers and a kernel string. This site leaves those out: none helps a defender and some help an attacker.
Linux hypervisor host
└─ KVM
└─ Cloud Hypervisor
└─ Per-user Ubuntu VM
└─ systemd-nspawn runtime container
└─ Muse agent
The four browser backend names in the table (a remote page fetching service, an on demand browser VM, a local browser container and a bundled Chromium) are in the second diagram above. The page also prints a policy engine's name, service unit names and file paths; they are left out for the same reason.
The question the chain leaves open
NebuSec's reading of the design is that Sentinel exists so that code running in the container cannot send anything out without the same rules applying. Sentinel ran in the same VM, on the same kernel, as the container it watched. Once the kernel step gave root in the VM, NebuSec says the guard itself was reachable and VM processes sat outside its hook. If the check that decides what leaves the agent runs inside the thing being attacked, what is it protecting? And until Meta says which of its fixes closed which stage, and when, how would a Muse user know the answer is now different?
Key facts
Sources
- PrimaryNebuSec overview headed Hacking Muse: Stealing Private Chats Through Browser Use, saved by this site at about 15:57 UTC on 21 November 2026: the three stages, the scope limits, the patched statement, the advice for builders; the demo video was not savedNebuSec (research overview, page data dated 20 November 2026)accessed 2026-11-21
- PrimaryNebuSec technical post Inside Meta Muse: Browser, Sentinel and the Shared-Kernel Boundary, saved by this site at about 17:11 UTC on 21 November 2026: the design, the four browser paths, Sentinel, the kernel step, the dates and the nestingNebuSec (technical post, page data dated 20 November 2026)accessed 2026-11-21


