Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach exposed Vite dev server
-
DeliveryRequest restricted path with ?vite-wasm-instance query
-
ExploitWasm plugin reads file, skips server.fs check
-
ExecutionWebAssembly parse fails, error thrown
-
ImpactLeak first 4 bytes of file to browser
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V5 - File Handling Path canonicalization, traversal prevention
MITRE ATT&CK
2 techniques across 2 tactics: Discovery, Collection The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires a network-reachable Vite dev server running an affected version (8.2.0 through 8.2.3, or 8.3.0 through 8.3.2) - note Vite's dev server defaults to localhost binding, so practical exploitation needs the server exposed to the attacker (e.g. bound to 0.0.0.0, proxied, or on a shared network). The attacker sends a request whose path targets a file outside the server.fs allowed roots with a ?vite-wasm-instance query string, which routes to the internal Wasm plugin's load hook that strips the query and reads from disk without the server.fs restriction. The disclosure only occurs when the targeted file fails WebAssembly parsing (true for virtually all non-.wasm files), causing Node or Deno to throw an error containing the bytes. Strong limiting factors: only the FIRST 4 BYTES of the file are leaked (no full-file read), and the dev server is not meant to be a production/internet-facing surface. |
| Impact | This is a moderate, bounded information-disclosure flaw rather than a top-tier priority. The vendor-supplied CVSS 4.0 vector (CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N, 6.3) correctly captures the shape of the issue: network-reachable and unauthenticated (PR:N), but with an Attack Requirement (AT:P) and only Low confidentiality impact (VC:L) because the primitive leaks just the first 4 bytes of a targeted file via a WebAssembly parse-error message. There is no EPSS score, no CISA KEV listing, and no public exploit code supplied in the intelligence, so this is 'no public exploit identified at time of analysis' and there is no evidence of active exploitation. A key limiting factor not fully reflected in AV:N is that the affected component is the Vite development server, which by default binds to localhost and is not intended to be internet-exposed - so the network vector is realistic mainly where a dev server is deliberately or accidentally exposed. The source diff confirms the root cause and fix (adding wasmInstanceRE to the guard in transform.ts so ?vite-wasm-instance requests undergo the same restriction as ?raw/?url/?inline/?svg, returning 403), which strengthens confidence in the mechanism. Net: a genuine but low-severity, narrow-primitive leak; prioritize patching dev tooling but it does not warrant emergency response absent exposure. |
| Exploit ScenarioDerived | A developer runs a Vite dev server (8.2.0-8.2.3 or 8.3.0-8.3.2) that is reachable by an attacker - for example bound to 0.0.0.0 on a shared network or proxied externally. The attacker requests a sensitive file outside the allowed server.fs roots with a ?vite-wasm-instance query (e.g. /root/src/.env?vite-wasm-instance); Vite's internal Wasm plugin reads it without the fs check, fails to parse it as WebAssembly, and the thrown Node/Deno error echoes the file's first 4 bytes back to the attacker. No public exploit code was provided, though the fix commit and test cases make the technique straightforward to reproduce. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 20, 2026
A path-traversal information-disclosure flaw in Vite's development server (versions 8.2.0 through 8.2.3 and 8.3.0 through 8.3.2) lets a remote requester read the first 4 bytes of any file on the host filesystem - including files deliberately excluded from server.fs allowed roots, such as .env secrets and private keys - by appending a ?vite-wasm-instance query string to the request path. The internal Wasm plugin's load hook strips the query, reads the target path directly from disk without applying server.fs checks, then fails WebAssembly parsing and leaks the file's leading bytes in the resulting Node/Deno error message. Exploitation requires a network-reachable dev server (localhost-bound by default, so exposure via 0.0.0.0 binding, proxying, or a shared network is a precondition); no public exploit code exists in the provided data and CISA KEV does not list it, while the assessed impact is limited confidentiality loss given only 4 bytes leak per request.
RemediationAI
Vendor-released patch: upgrade to Vite 8.2.4 or 8.3.3 (or later), which applies the server.fs validation to ?vite-wasm-instance requests via the wasmInstanceRE guard in the transform middleware; see GHSA-vfpm-58rq-9qcg (https://github.com/vitejs/vite/security/advisories/GHSA-vfpm-58rq-9qcg) and PR https://github.com/vitejs/vite/pull/23655. If an immediate upgrade is not possible, the most effective compensating control is to stop exposing the dev server: keep it bound to 127.0.0.1 (the default) and remove any --host / server.host 0.0.0.0 configuration, at the cost of losing LAN or container-to-host access for testing - reproduce that access with an SSH tunnel or an authenticated reverse proxy instead. Additionally, reject requests whose query string contains vite-wasm-instance at the proxy layer (a single rewrite/deny rule, though it only blocks this specific parameter and not other future bypasses), and ensure sensitive material such as .env files, key stores, and cloud credential files are not co-located on the same filesystem as the dev server root, since each leaked request still discloses 4 bytes of any readable file. Note that per-request leakage is small, so repeated requests against structured formats can progressively reveal file headers.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Vite is a JavaScript frontend tooling framework whose dev server exposes internal plugins for handling special module types, including WebAssembly. The vulnerable component is the internal Wasm plugin's load hook, which is selected whenever a request URL carries the ?vite-wasm-instance query parameter. That hook removes the query and reads the corresponding file path straight from disk, bypassing the server.fs allow-list that normally restricts Vite's dev server to explicitly permitted roots (and to dotfile/.env denials). Because the raw bytes are then handed to a WebAssembly parser, any non-Wasm file causes Node or Deno to throw a parse error, and that error message embeds the first 4 bytes of the file - the disclosure primitive. The root cause maps to CWE-22 (Improper Limitation of a Pathname to a Restricted Directory / Path Traversal) - specifically a path-canonicalization/authorization gap in which the URL-rewriting middleware fails to normalize a stripped query suffix before filesystem access. The upstream fix in PR #23655 adds a wasmInstanceRE check to the transform middleware so requests bearing ?vite-wasm-instance are subject to the same fs-serve matrix validation as raw, url, inline, and svg imports, and regression tests assert 403 Restricted responses for out-of-root files and denied .env files. Affected packages are the vitejs:vite and vitejs:vite-plus CPEs.
Know when Vite gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:P/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N
Unauthenticated network request to the dev server (AV:N/PR:N/UI:N); confidentiality Low because only the first 4 bytes leak, with no integrity or availability impact.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Vite is a frontend tooling framework for JavaScript. From 8.2.0 until 8.2.4 and 8.3.3, the first 4 bytes of files outside of server.fs setting can be returned to the browser by a request containing ?vite-wasm-instance. Requests containing the ?vite-wasm-instance query are handled by the internal Wasm plugin's load hook. The hook removes the query and reads the resulting path directly from disk, but the server.fs checks were not applied. After reading the file, Vite attempts to parse it as WebAssembly. When that parse fails, Node and deno throws an error that contains the first 4 bytes of the file. This vulnerability is fixed in 8.2.4 and 8.3.3.
Blast Radius
ecosystem impact- 99 npm packages depend on vite (33 direct, 68 indirect)
Ecosystem-wide dependent count for version 8.3.0.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Vite is a frontend tooling framework for javascript. Rated medium severity (CVSS 5.3), this vulnerability is remotely ex
Vite, a provider of frontend development tooling, has a vulnerability in versions prior to 6.2.3, 6.1.2, 6.0.12, 5.4.15,
launch-editor allows users to open files with line numbers in editor from Node.js. Rated high severity (CVSS 7.5), this
Vite is a frontend tooling framework for javascript. Rated high severity (CVSS 7.5), this vulnerability is remotely expl
Vite provides frontend tooling. Rated high severity (CVSS 7.5), this vulnerability is remotely exploitable, no authentic
Vite is a frontend tooling framework for javascript. Rated medium severity (CVSS 6.0), this vulnerability is remotely ex
Vite is a website frontend framework. Rated medium severity (CVSS 6.1), this vulnerability is remotely exploitable, no a
Arbitrary remote code execution in @vitejs/plugin-rsc 0.5.5 and earlier lets unauthenticated network attackers run JavaS
Vitejs Vite before v2.9.13 was discovered to allow attackers to perform a directory traversal via a crafted URL to the v
Path-validation bypass in launch-editor before 2.14.2 on Windows allows unauthenticated remote attackers to pass a craft
Information disclosure in the Vite development server 6.4.4 lets a network attacker retrieve files that server.fs.deny i
Vite is a frontend tooling framework for JavaScript. Rated low severity (CVSS 2.3), this vulnerability is remotely explo
EUVD-2026-105135
GHSA-vfpm-58rq-9qcg
NVD
CVE.org
EPSS
Exploit-DB