Skip to main content
← Back to Blog

Active Exploitation of Vite Dev Server RCE Using Memory-Resident Node.js Implants

November 20, 2026|Wraithwatch Intelligence

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.

Figure 1 — From Fixed Release to Field Exploitation
Advisory to Exploitation: November 9 to 20, 2026 6 days Nov 9 Fixed releases 8.3.7, 7.3.8, 6.4.6 Nov 10 GHSA-p4f5-76q4-ffq7 Critical, CVSS 9.1, no CVE Nov 16 09:16 First build received independent sensor network Nov 17 17:31 First seen by the Mesh 1 host, 36 ports, full implant Nov 18 First public account Henriques, LinkedIn Nov 20 04:53 24 hosts, 6 providers 4 synchronized waves

Key findings

  1. 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.
  2. 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-Context header, 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.
  3. 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.
  4. 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.
  5. 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:23Vite 8.3.7 released; 8.2.5, 8.1.7, 7.3.8 and 6.4.6 follow within 40 minutes
2026-11-10GHSA-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:16First build received by the independent sensor network (Henriques): file and environment theft only
2026-11-16 11:34 to 20:31Request 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:25Staged 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:31First exploitation observed by the Mesh. One Contabo host, 36 ports, the staged build
2026-11-17 22:45 and 23:53Same host repeats the sequence
2026-11-17 to 11-19Ten further hosts, 2 to 12 requests each
2026-11-18Henriques publishes the first account of the campaign (LinkedIn), with decoded builds, the SSH key, and indicators
2026-11-18 and 11-19Two third-party write-ups of the advisory itself (atlasum.net, brandefense.io). Neither claims exploitation
2026-11-20 04:53 to 05:41Twelve 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. ...`)
  }
})
Figure 2 — One Unauthenticated GET to Code Execution
GHSA-p4f5-76q4-ffq7: Request to Implant 01 One GET request to the dev server no authentication 02 Vite generates a virtual module URL text, unescaped 03 Injection closes Vite's template `);}}); 04 import.meta.glob appended options carry CODE 05 Server evaluates options with new Function globalThis still reachable 06 CODE runs inside the dev-server process as the developer. Nothing on disk 07 Hooks installed emit, writeHead, end command channel live

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

StepMechanismPurpose
Acquire requireglobalThis.process.getBuiltinModule, falling back to process.mainModule.require, then a dynamic import("module") with createRequireDefeat the name shadowing in evalValue
Patch responsesReplace ServerResponse.prototype.writeHead and .end on the http, https and tls modulesRewrite 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 requestsReplace Server.prototype.emit so every request event is inspected firstInstall the command channel without touching application routes
Command channelIf 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 pathIf the URL contains __v?v=1, reply 200 with the stored snapshotRead the environment without the command channel
Live-request hookWalk process._getActiveHandles(), patch each live socket's response prototype, and execute any x-v0-s1 header found on an in-flight requestReach 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
IdempotenceGuards _lw, _lboot, _lilith_v3 on the patched objectsRe-exploitation does not stack hooks
Figure 3 — The Implant in Memory
Request Hook, Response Hook, Command Channel Node.js process started by npm run dev Incoming request Patched Server.prototype.emit inspects every request first X-Amzn-Trace-Context: Root=1-672e9988-… base64 → Function(process,require,req,res) reply [GHOST_OK v3=True] + result URL contains __v?v=1 returns the stored snapshot 200 V0_<base64 env>_E Anything else passed to Vite; the app serves normally an implanted server looks healthy Patched writeHead / end status ≥ 400 → 200, content-length removed snapshot swapped into the body when flagged Live-request hook process._getActiveHandles() → patch in-flight sockets execute any x-v0-s1 header already in flight Idempotence guards: _lw, _lboot, _lilith_v3 re-exploitation does not stack hooks Snapshot V0_ + base64({u: uid, c: cwd, e: process.env}) + _E the environment is where dev credentials live

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.

ModeMarkerHostsFirst seenBehavior
Install_lilith_v3 implant, 3.4 KB injection122026-11-17 17:31Full implant; follow-up retrieval and stage-2 requests when the response reads as success
ProbetoString:Function`return"V0_HIT"`42026-11-20 05:41Minimal eval proof; 7 requests per host
UnresolvedRequest truncated below 140 bytes in capture82026-11-19Same 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.

Figure 4 — Delivery Through the Developer's Own Browser
A Page the Developer Loads Reaches a Server Bound to localhost Attacker's web page public origin, or an ad in an iframe on a legitimate site Developer's browser <img src="http://localhost :5173/…exploit…"> LOCAL NETWORK ACCESS CONTROL Chrome 158 / Safari 27.2 prompt; one Allow admits the request Firefox 160 blocked by default, no prompt Pre-LNA browsers, Electron, LAN-hosted page no gate Vite 7.3.7 on localhost:5173 Host: localhost → allowedHosts passes code executes before any reply is written Runs as the developer ~/.ssh, ~/.aws, .env, source, network Why the browser is a delivery path Same-origin policy and CORS restrict what the page may READ from another origin. They do not restrict what the browser may SEND to it. The server executes on receipt of one GET. No reply is needed, so the read restrictions are irrelevant. No --host flag or port forward was needed.

The mechanism:

  1. A page can make the browser send a request anywhere. HTML and JavaScript may reference resources at any address through <img src>, <script src> or fetch(), including http://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.
  2. Vite's only origin check passes. The server.allowedHosts control, added in 2025 against DNS rebinding, inspects the Host header, which reads localhost. 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 forged Host header was refused.
  3. 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.
  4. 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:

RequestHeadersExecuted
Plain GET from the same machinenoneyes
Cross-site fetchOrigin and Referer of a remote site, Sec-Fetch-Site: cross-site, Sec-Fetch-Mode: no-cors, Sec-Fetch-Dest: emptyyes
Cross-site imageas above with Sec-Fetch-Dest: imageyes
Cross-site scriptas above with Sec-Fetch-Dest: scriptyes
Spoofed HostHost: attacker.exampleno, 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:

BrowserConfigurationLocalhost requests executed
Google Chrome 158.0.8127.36defaultnone 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.1defaultnone; NetworkError
Mozilla Firefox 160.0.1network.lna.enabled=false, network.lna.blocking=falsefetch, 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 addresslocal-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:

SourceQueryCountDate
Shodanhttp.html:"/@vite/client"25,466 hosts2026-11-20
Netlashttp.body:"/@vite/client"28,494 responses2026-11-20
Shodansame, port 443 only7,8252026-11-20
Shodanhttp.html:"/_nuxt/@vite/client"3182026-11-20

Ownership, from Shodan organization and hostname facets on the same query:

SliceHosts
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 organizations12,492
One national utility application, a single deployment on a single ISP1,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 continents124
University-owned networks across North America, Europe and Asia64
A national interbank payments operator1

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:

ClassDownloadsShare
Affected per advisory, fix available209,170,74672.2%
Affected per advisory, 4.x and 5.x, no fix32,482,20811.2%
Patched47,498,46916.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.