Active Exploitation of Vite Dev Server RCE Using Memory-Resident Node.js Implants
Vite Advisory GHSA-p4f5-76q4-ffq7 | No CVE Assigned
Executive Summary
Wraithwatch's Intelligence Mesh has observed a memory-resident Node.js implant being deployed against Vite development servers through GHSA-p4f5-76q4-ffq7, a critical vulnerability published seven days before the first delivery. The implant hooks the running HTTP server, accepts commands through a header formatted as an AWS X-Ray trace, exfiltrates the process environment, rewrites error responses to conceal itself, and stages an encrypted second payload. Delivery reached the Mesh on November 17, 2026 from a single host at Contabo and expanded within three days to 24 hosts at six providers operating in synchronized waves.
The target is the development server of Vite, the build tool beneath most of the modern JavaScript web, including Nuxt, SvelteKit, Astro, Angular and React Router. Vite was downloaded 290 million times from npm in the week of November 13 to 19; 83 percent of those downloads were versions its maintainers had listed as vulnerable one week earlier. Approximately 25,000 Vite development servers are reachable on the public internet. Controlled testing also established that a server bound to localhost executes the exploit when the request is delivered by the developer's own browser from any web page, subject only to a local-network permission prompt in Chrome and Safari. The exposed population is therefore not the 25,000 servers alone but every developer running an affected Vite with a browser open.
One independent public account exists: Tiago Henriques, writing on November 18, described the same campaign from a separate sensor network that received it from November 16 and decoded twenty builds, including a credential collector and an SSH-key persistence mechanism that the Mesh did not receive. No vendor report, scanner signature, proof-of-concept repository or CVE identifier exists. This report corroborates that account from a second network and extends it with the localhost delivery path, the size and ownership of the exposed population, and the campaign's growth to 24 hosts.
Key findings
- GHSA-p4f5-76q4-ffq7 is under active exploitation. The campaign began no later than November 16 and reached the Mesh on November 17. As of November 20 there is one public account and no vendor report, signature, proof of concept or CVE.
- The payload is a complete post-exploitation implant. It hooks the Node.js HTTP server in memory, executes attacker JavaScript carried in the
X-Amzn-Trace-Contextheader, returns the process environment on demand, rewrites error responses to status 200, and stages an encrypted second payload. Earlier builds collect credentials with a stated preference for AI service keys and write an SSH key for persistence. - The circulating payload executes against Vite 7.x. The advisory lists 4.0.0 through 8.3.6 as affected. Execution was confirmed on 7.3.7 and not reproduced on 6.4.5 or 8.3.5, whose triggers differ.
- A localhost-bound server is reachable through the developer's browser. A page the developer loads can deliver the request; the server executes before any reply. Firefox blocks this by default. Chrome and Safari show a generic local-network permission prompt, and one acceptance completes the exploit. Browsers predating the control have no gate.
- One week after the fixes, 83 percent of Vite downloads were vulnerable versions. The 4.x and 5.x lines, 11 percent of downloads, will not receive a fix.
Background
Vite's development server is the process a developer runs on their own machine during development. It serves the application over HTTP, by default on port 5173 and on localhost only. The --host flag exposes it to the network; some projects run it on cloud development machines or behind a reverse proxy.
On November 9, 2026 the Vite maintainers released fixed versions of every supported line, and on November 10 published GHSA-p4f5-76q4-ffq7, Critical, CVSS 9.1. When a browser requests a Node.js built-in that cannot run in a browser, the development server generates a small virtual module named from the request URL, and the name is inserted into generated JavaScript without escaping. A crafted request terminates the generated string and appends code. A call to import.meta.glob appended in this way has its options evaluated by the server with new Function before the module is served. One unauthenticated GET request yields code execution inside the development server's Node.js process. The advisory's proof of concept reads a file outside the project directory.
Evidence 1. In-the-Wild Exploitation Preceding Public Reporting
Exploitation began no later than November 16, 2026, 09:16 UTC, six days after the advisory. The Mesh's first observation followed 32 hours later.
| Date (UTC) | Event |
|---|---|
| 2026-11-09 10:23 | Vite 8.3.7 released; 8.2.5, 8.1.7, 7.3.8 and 6.4.6 follow within 40 minutes |
| 2026-11-10 | GHSA-p4f5-76q4-ffq7 published by the Vite security maintainer. Critical, CVSS 4.0 9.1, CWE-116. No CVE. Proof of concept demonstrates a file read. Credits: g2hsec, spansh, martinpriest, zooyeon |
| 2026-11-16 09:16 | First build received by the independent sensor network (Henriques): file and environment theft only |
| 2026-11-16 11:34 to 20:31 | Request hook, SSH key, sudo and Docker escalation, log scrubbing, disguised key label, PING check for already-implanted servers added (independent account) |
| 2026-11-17 04:52 to 21:25 | Staged design: minimal first stage, main code in header chunks, X-V0-S1 second header, error page rewritten to carry stolen data (independent account) |
| 2026-11-17 17:31 | First exploitation observed by the Mesh. One Contabo host, 36 ports, the staged build |
| 2026-11-17 22:45 and 23:53 | Same host repeats the sequence |
| 2026-11-17 to 11-19 | Ten further hosts, 2 to 12 requests each |
| 2026-11-18 | Henriques publishes the first account of the campaign (LinkedIn), with decoded builds, the SSH key, and indicators |
| 2026-11-18 and 11-19 | Two third-party write-ups of the advisory itself (atlasum.net, brandefense.io). Neither claims exploitation |
| 2026-11-20 04:53 to 05:41 | Twelve hosts in four synchronized waves; Nuxt-prefixed paths appear |
As of November 20 the public record consists of that one practitioner account. The vulnerability has no CVE identifier, no entry in the GitHub global advisory database or in CISA's Known Exploited Vulnerabilities catalog, no GreyNoise tag, no nuclei template, and no proof-of-concept repository.
Evidence 2. The Exploit and the Implant
An implant is code an attacker leaves running inside a system they have reached so they can return without exploiting it again. This one lives inside the Node.js process that runs the development server, writes nothing to disk, and leaves the application serving normally. It modifies two functions of the running HTTP server in memory: the one that handles each incoming request, which becomes the command channel, and the one that writes each response, which becomes the concealment layer. The hook disappears when the process restarts, which for a development server is frequent; the operator re-exploited the same surface three times in six hours. The earlier builds decoded by the independent account add the parts that survive a restart: an SSH public key appended to authorized_keys and a file at /tmp/.ls1a.
The Vulnerable Module
When a browser asks the development server for a Node.js built-in, Vite answers with a generated module whose only job is to throw a helpful error. The module name is taken from the request URL and placed inside a template literal without escaping:
// Vite dev server, resolve plugin (abbreviated). `id` is everything after
// "__vite-browser-external:" in the request URL, decoded but not escaped.
export default new Proxy({}, {
get(_, key) {
throw new Error(`Module "${id}" has been externalized for browser compatibility. Cannot access "${id}.${key}" in client code. ...`)
}
})
The Request
The request path is /@id/__vite-browser-external: followed by the injection and the query ?import. The injection, decoded, has four parts.
GET /@id/__vite-browser-external:<injection>?import HTTP/1.1
Host: <target>:5173
<injection>, decoded:
# 1. Closing sequence. Ends the template literal, the Error(...) call, the
# throw statement, the get() method, the Proxy options object and the
# new Proxy(...) call in Vite's generated module.
`);}});
# 2. Trigger. The option object's computed key is a template literal that
# interpolates an object whose toString is Function("CODE"). Evaluating
# the key calls toString, which calls the compiled function, which runs
# CODE. Vite evaluates this server-side in evalValue.
import.meta.glob('./*',{[`${{toString:Function("CODE")}}`]:1});
# 3. The implant, as CODE. 3,400 characters in the install build.
# 4. Reopening sequence. Starts a new template literal that swallows the
# remainder of Vite's generated module so the result still parses.
var z=new Proxy({},{get(_,k){throw new Error(`
evalValue shadows process, require and four other names before calling new Function, but leaves globalThis reachable. The implant's first act is to recover require through it, a bypass the advisory mentions in one sentence and the operator implemented with two fallbacks.
What the Implant Does
| Step | Mechanism | Purpose |
|---|---|---|
Acquire require | globalThis.process.getBuiltinModule, falling back to process.mainModule.require, then a dynamic import("module") with createRequire | Defeat the name shadowing in evalValue |
| Patch responses | Replace ServerResponse.prototype.writeHead and .end on the http, https and tls modules | Rewrite any status of 400 or above to 200, remove content-length, and substitute the stored environment snapshot as the body when a flag is set |
| Patch requests | Replace Server.prototype.emit so every request event is inspected first | Install the command channel without touching application routes |
| Command channel | If X-Amzn-Trace-Context starts with Root=1-672e9988-, base64-decode the remainder and run it as Function("process","require","req","res", code) | Arbitrary code execution on demand. Reply is [GHOST_OK v3=True] plus the result; errors reply ERR: plus the message |
| Retrieval path | If the URL contains __v?v=1, reply 200 with the stored snapshot | Read the environment without the command channel |
| Live-request hook | Walk process._getActiveHandles(), patch each live socket's response prototype, and execute any x-v0-s1 header found on an in-flight request | Reach servers where the module-level patch is not yet in the path |
| Snapshot | "V0_" + base64(JSON{u: uid, c: cwd, e: process.env, f}) + "_E" | The environment is where development credentials live |
| Idempotence | Guards _lw, _lboot, _lilith_v3 on the patched objects | Re-exploitation does not stack hooks |
A legitimate X-Ray trace id carries a current epoch timestamp in the position where this one carries 672e9988, which is November 8, 2024. The prefix is a fixed key, not a trace. The hook guards are named _lilith_v3 and _lilith_orig_emit; nothing in the payload or the corpus connects the name to any product or project, and we treat it as the author's label.
Earlier builds (independent account, not received by the Mesh). Henriques's decode of twenty builds reports collection of up to about 150 KB per request: the server's environment, .env files in the project and the directories above it, ~/.claude.json and ~/.claude/.credentials.json, AWS and Google Cloud credentials, ~/.kube/config, SSH private keys, .npmrc, terraform.tfstate, wrangler.toml, service-account and MCP configuration files, the environment of every process in /proc filtered on provider prefixes (sk-, AKIA, AIza, ANTHROPIC, OPENAI, GEMINI, OPENROUTER, GROQ, XAI, SUPABASE, GITHUB and others), and the environment of running containers. Later builds add privilege escalation through passwordless sudo and the Docker socket, an SSH public key written to authorized_keys and labeled to match an existing key, log scrubbing, and a hook that answers any other party's exploit attempt with 404 so an implanted server appears unexploitable to everyone but the operator. The provider list grew across 36 hours, nearly every addition an AI provider or gateway.
The second stage arrives through the command channel. The three decoded trace-header payloads from November 17 each assign a high-entropy base64 blob of 883 to 1,307 characters to globalThis._s1a. The blobs do not decompress and differ between runs while sharing a prefix. We read _s1a as chunk a of stage s1, with further chunks and an assembly-and-decrypt step withheld until the implant acknowledges. The instrumented surface could not acknowledge, so the stage-2 body is not in hand.
Evidence 3. The Operator's Infrastructure and Cadence
The campaign runs from rented virtual machines at six providers with a shared toolkit in two modes.
| Mode | Marker | Hosts | First seen | Behavior |
|---|---|---|---|---|
| Install | _lilith_v3 implant, 3.4 KB injection | 12 | 2026-11-17 17:31 | Full implant; follow-up retrieval and stage-2 requests when the response reads as success |
| Probe | toString:Function`return"V0_HIT"` | 4 | 2026-11-20 05:41 | Minimal eval proof; 7 requests per host |
| Unresolved | Request truncated below 140 bytes in capture | 8 | 2026-11-19 | Same path prefix; payload not recoverable |
Providers by host count on the Mesh: Contabo 5, Hetzner 4, DigitalOcean 3, Scaleway 2, Tencent Cloud 1, Amazon Web Services 1, with the remainder at smaller European hosts. The independent account lists eleven addresses for November 16 and 17; seven also appear in the Mesh's corpus, all on or after November 17, for a union of 28 source hosts. The November 20 waves were synchronized to within seconds across three to four hosts each. Twelve of the 24 hosts also requested the path with a /_nuxt prefix, and several sent /@fs/proc/self/environ?raw??, the credential-read bypass from the September 2026 campaign (CVE-2026-39364), in the same wave. The toolkit carries both: the old file read for servers patched against neither, and the new execution path for the rest. The September campaign reported by F5 Labs is otherwise a different operation: a file-read bug rather than code execution, Google Cloud exit addresses with forged crawler user agents rather than rented machines, and no shared source hosts.
None of this is reflected in public reputation data. Of the 29 addresses across both networks, 10 carry no detection from any engine and the rest carry only generic scanner labels from GreyNoise and SOCRadar. No engine, vote or comment references Vite, a development server, or this implant.
The ports swept by the first host, in order, are a curated list of development-server defaults across Vite, Next.js, Angular, Astro, Storybook, Flask and common proxies, not a port scan:
80 443
3000 3001 3002 3003 3004 3005 3008 3010 3030 3080
4000 4173 4200 4321
5000 5001 5173 5174 5175 5176 5177 5178 5179 5180
6006 7000
8000 8001 8008 8080 8081 8443 8888
9000
Evidence 4. Localhost-Bound Servers and the Browser as Delivery Path
The advisory describes localhost-bound servers as unaffected. That claim was tested. A Vite 7.3.7 server bound to localhost executed the exploit when the request carried the full header set a browser attaches to a cross-site request, for each of the three request forms available to a page: a fetch call, an image element and a script element. The browser path is not a Vite flaw. It is a standing property of browsers that becomes consequential because the vulnerability converts a single GET into execution, and it determines that the exposed population is developers rather than servers.
The mechanism:
- A page can make the browser send a request anywhere. HTML and JavaScript may reference resources at any address through
<img src>,<script src>orfetch(), includinghttp://localhost:5173/. The same-origin policy restricts what a page may read from another origin; it does not restrict what the page may send. Loading the page is sufficient. An advertisement in an iframe on a legitimate site is sufficient. - Vite's only origin check passes. The
server.allowedHostscontrol, added in 2025 against DNS rebinding, inspects theHostheader, which readslocalhost. CORS settings govern the reply, and the server has generated, transformed and evaluated the module before any reply exists. In testing, each of the three request forms produced the marker file; only a forgedHostheader was refused. - The reply is irrelevant. The code executes inside the development server's Node.js process, as the developer, with the developer's environment variables, SSH agent, cloud credentials, source tree and unrestricted outbound network. It can transmit all of these directly. The in-the-wild implant waits for commands over a custom header that a page cannot set without a CORS preflight, so an operator targeting developers would have the first stage call out instead.
- The browser control is the only gate. Current Chrome, Safari and Firefox classify the attacker's page as a public origin and the target as the local machine, and apply Local Network Access. Firefox blocks without a prompt at its default. Chrome and Safari present a permission prompt asking whether the site may connect to devices on the local network; it does not reference the development server, and the same prompt is produced by legitimate pages that discover printers or casting devices. One acceptance admits all pending requests. Browser releases predating the control, embedded browsers in desktop applications, and pages served from the developer's own network are not subject to it.
The request as the development server receives it from an image element on a cross-site page:
GET /@id/__vite-browser-external:<injection>?import HTTP/1.1
Host: localhost:5173
Origin: https://attacker.example
Referer: https://attacker.example/
Sec-Fetch-Site: cross-site
Sec-Fetch-Mode: no-cors
Sec-Fetch-Dest: image
→ allowedHosts checks Host only. Host reads localhost. The module is generated,
transformed and evaluated before the response headers are decided.
No port was forwarded, no --host flag was set, and no configuration was altered. The exposed condition is the ordinary working state of a front-end developer.
Test Results
Test instrument: an isolated Ubuntu 24.04 virtual machine with unmodified Vite 7.3.7 and 8.3.5 installed from npm and started with their defaults, which bind to localhost. The payload was the operator's probe-mode injection with the marker replaced by a call that writes a timestamped file under /tmp. Vite decodes the path with decodeURI, which leaves reserved characters encoded, so the $ in the trigger must be sent literally, as the operator's payload does.
Server-side results, Vite 7.3.7:
| Request | Headers | Executed |
|---|---|---|
| Plain GET from the same machine | none | yes |
| Cross-site fetch | Origin and Referer of a remote site, Sec-Fetch-Site: cross-site, Sec-Fetch-Mode: no-cors, Sec-Fetch-Dest: empty | yes |
| Cross-site image | as above with Sec-Fetch-Dest: image | yes |
| Cross-site script | as above with Sec-Fetch-Dest: script | yes |
| Spoofed Host | Host: attacker.example | no, 403 from server.allowedHosts |
Vite 8.3.5 did not execute this payload: its resolver, implemented in the Rolldown bundler, emits the module name inside a double-quoted string and escapes quotes and backslashes. Vite 6.4.5 did not either: the 6.x import-glob plugin rejects options that are not static literals before evaluating them. The advisory lists both lines as affected, so each has a trigger that differs from the one in circulation. Neither was reproduced. The payload in the wild is tuned to 7.x, which is 60 million downloads a week.
Browser results, with the test page served from a public IP address so that Local Network Access applies, requesting the exploit URL at localhost:5173 and 127.0.0.1:5173 through fetch, an image element and a script element:
| Browser | Configuration | Localhost requests executed |
|---|---|---|
| Google Chrome 158.0.8127.36 | default | none of six; console reports access blocked |
| Google Chrome 158.0.8127.36 | --disable-features=LocalNetworkAccessChecks,PrivateNetworkAccess* | fetch, image and script all executed |
| Mozilla Firefox 160.0.1 | default | none; NetworkError |
| Mozilla Firefox 160.0.1 | network.lna.enabled=false, network.lna.blocking=false | fetch, image and script to localhost executed; 127.0.0.1 still blocked |
| Safari 27.2 (macOS 27.2.1, Apple silicon) | default, interactive session, page served over HTTP from a public address | local-network permission prompt shown; after the user accepted, fetch, image and script to localhost executed within five seconds |
The prompt is the only control on two of the three browsers, and it asks a developer to approve what reads as a routine local-network permission. Not covered: browser versions predating Local Network Access, Electron and other embedded Chromium hosts, and any attacker whose page is served from the developer's own network.
Evidence 5. The Affected Population
About 25,000 Vite development servers are reachable on the public internet, and 83 percent of last week's Vite downloads were versions the advisory lists as affected. The circulating payload reaches the 7.x fifth of that population today; the remainder is one payload revision away.
Internet exposure, measured by the client script the dev server injects into every page and production builds omit:
| Source | Query | Count | Date |
|---|---|---|---|
| Shodan | http.html:"/@vite/client" | 25,466 hosts | 2026-11-20 |
| Netlas | http.body:"/@vite/client" | 28,494 responses | 2026-11-20 |
| Shodan | same, port 443 only | 7,825 | 2026-11-20 |
| Shodan | http.html:"/_nuxt/@vite/client" | 318 | 2026-11-20 |
Ownership, from Shodan organization and hostname facets on the same query:
| Slice | Hosts |
|---|---|
| Cloud and VPS providers (Amazon, Tencent, Alibaba, Hetzner, DigitalOcean, Contabo, Selectel, Google, Microsoft, OVH, Oracle) | about 12,000 |
| Consumer and business ISP space after excluding 80 hosting and carrier organizations | 12,492 |
| One national utility application, a single deployment on a single ISP | 1,893 |
| A widely deployed VPN management panel serving the dev-client script (58 percent of all exposed instances of that product) | 1,231 |
| Hostnames under government domains, 101 of them on AWS; national and federal agencies on five continents | 124 |
| University-owned networks across North America, Europe and Asia | 64 |
| A national interbank payments operator | 1 |
Shodan attributes 10,106 of these responses to nginx and 925 to Apache: reverse proxies standing in front of a dev server that may well be bound to localhost. A proxy forwards the exploit request unchanged, and Apache's default proxy configuration rewrites the Host header to the backend address, which satisfies Vite's only origin check. Several hosts in the government slice follow this pattern. Localhost binding is not a control once a proxy is in front. Nor is the population scaffold projects: only 69 of the hosts carry Vite's default "Vite App" title. At least two products appear to ship with the development server running in production, which puts VPN gateways and operational systems in reach at fleet scale. Product names and per-host ownership data are held in the disclosure record, not in this report.
Version distribution of npm downloads of vite, November 13 to 19, 2026, total 289,652,957:
| Class | Downloads | Share |
|---|---|---|
| Affected per advisory, fix available | 209,170,746 | 72.2% |
| Affected per advisory, 4.x and 5.x, no fix | 32,482,208 | 11.2% |
| Patched | 47,498,469 | 16.4% |
The single most-downloaded version, 8.3.5, is in the advisory's affected range; the circulating payload did not execute against it in testing. The 7.x line, against which it does execute, accounted for 60 million downloads. Vitest, which shares the server code, saw 195 million downloads in the same week.
Detection and Mitigation
Indicators, in order of durability. Block on the request shape and the headers, not on the source list.
# Request paths. The legitimate remainder is a bare Node built-in (fs, path, ...).
/@id/__vite-browser-external:<remainder containing ` or import.meta.glob or toString:Function>
/@id/__vite-optional-peer-dep:<same>
# Command channel. 672e9988 is a 2024 timestamp; a live X-Ray id carries a current one.
X-Amzn-Trace-Context: Root=1-672e9988-<base64>
# Secondary header and retrieval path
x-v0-s1: <base64>
__v?v=1
# Response markers
[GHOST_OK v3=True]
V0_[A-Za-z0-9+/=]+_E
LB64_<base64>_END # earlier builds, independent account
# Globals on Server.prototype, ServerResponse.prototype or globalThis in a running dev server
_lilith_v3 _lilith_orig_emit _lboot _lw _lv0 _lv00 _lv0p _lreq
_LILITH_VITE_V3_VER _LILITH_VITE_V3_SMART _LILITH_VITE_V3_PERSIST # earlier builds
# Any dev-server process whose writeHead or end are not the originals
# Persistence, earlier builds (independent account). Search for the key text, not the label.
ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIPGfgb9OgwNn9P736FRhvFEVFAt0waxe+cbAIj7Ami6t
labels seen: root@localhost, c2-ops-maint, lilith@clonoth, or copied from an existing key
/tmp/.ls1a
A negative test is not evidence of absence: an implanted server answers exploit attempts and credential-file reads from anyone but the operator with 404. Reputation feeds will not help; as of November 20 no VirusTotal engine, vote or comment associates any source host with this campaign.
Mitigation. Upgrade to Vite 6.4.6, 7.3.8, 8.1.7, 8.2.5, 8.3.7 or later, or vite-plus 1.5.1. Vite 4.x and 5.x must move to a supported line. Do not run the dev server with --host on a reachable interface, and do not put a reverse proxy in front of one. On any host that was exposed, restarting the development server removes the hook only; search authorized_keys for the key above and rotate every credential the process could read: AI provider keys, cloud credentials, Kubernetes tokens, SSH keys, npm tokens and the contents of .env files. Keep browsers current. Local Network Access is the control that stops the browser-delivered path, and in Chrome and Safari it is a prompt that should be declined.
Source hosts observed, November 17 to 20, 2026. All are rented virtual machines and are expected to rotate.
164.68.100.175 194.163.182.93 145.223.19.41 161.97.88.80
46.202.146.149 212.56.40.125 76.13.246.78 217.217.253.51
5.75.157.175 162.141.109.119 5.175.140.155 188.34.156.37
43.130.29.5 207.154.244.253 161.97.162.177 147.45.229.69
164.68.118.79 65.109.74.202 157.22.182.227 87.106.205.73
46.101.135.161 62.210.171.105 109.94.169.80 3.74.136.164
Methodology
Instrumented surfaces of Wraithwatch's Intelligence Mesh record complete HTTP requests, including bodies and headers, and answer in ways that permit an operator's tooling to proceed, which is how the stage-2 delivery was observed. Reproduction used an isolated cloud virtual machine with Node.js 22 and Vite 7.3.7 and 8.3.5 from the npm registry; Chrome 158.0.8127.36 and Firefox 160.0.1 run headless on Linux; and Safari 27.2 on macOS 27.2.1 in an interactive session. Evidence of execution was a file written by the dev-server process. No request was sent to any host outside the test machine. Exposure counts are Shodan and Netlas public results for the dev-server client-script fingerprint on November 20, 2026; download counts are from the npm registry API for November 13 to 19, classified against the advisory's affected ranges. Reputation checks used the VirusTotal API v3, passive lookups only.
The independent account is Tiago Henriques, "Lilith: a backdoor that lives inside your Vite dev server and takes your AI keys", LinkedIn, November 18, 2026. Its observations are cited as such and not merged with the Mesh's.
The injection scaffold, trigger string, header prefix and response markers are campaign-generic and are published verbatim. Per-victim stage-2 blobs, Mesh surface identifiers, and the names of exposed organizations and products are withheld.