@vitejs/plugin-rsc CVE-2025-67489
CRITICALAttack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach dev server over network (vite --host)
-
DeliveryPOST crafted request to /_.rsc server-function endpoint
-
ExploitInject data: URL via x-rsc-action/reference id
-
ExecutionUnsafe dynamic import executes attacker JS as Node
-
ImpactExfiltrate source/credentials or pivot internally
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires (1) a running Vite DEVELOPMENT server using @vitejs/plugin-rsc <= 0.5.5 in an RSC application that exposes server-function endpoints (the loadServerAction/decodeReply/decodeAction request handler, e.g. the /_.rsc route), and (2) network reachability to that dev server. The vulnerable code path is the development-mode dynamic import of server/client references, which accepts attacker-controlled 'data:' URL modules. LIMITING FACTORS: it affects dev servers ONLY (production builds are not exposed); the dev server binds to localhost by default, so remote exploitation realistically requires the developer to have run 'vite --host' (or equivalent binding) exposing the port on a reachable interface; no authentication or user interaction is needed once the endpoint is reachable. |
| Impact | The raw CVSS 3.1 base score of 9.8 (AV:N/AC:L/PR:N/UI:N, C:H/I:H/A:H) reads as a critical, remotely-exploitable, unauthenticated RCE, and in isolation would demand emergency patching. However, this score materially overstates real-world risk because the flaw affects only the Vite DEVELOPMENT server, not production builds - a context CVSS base metrics cannot express. Contrasting signals align with this: EPSS is low at 0.81% (56th percentile), indicating no modeled likelihood of widespread opportunistic exploitation, and the CVE is NOT on CISA KEV, so there is no evidence of active exploitation. A detailed, working proof-of-concept IS published in the GitHub Security Advisory (poc.js plus a StackBlitz repro), so publicly available exploit code exists and the technical barrier to abuse is trivial. Net assessment: this is a genuine code-injection (CWE-94) RCE that should be patched promptly by developers, but it is a developer-workstation / CI-exposure risk rather than an internet-facing production threat. The dev server binds to localhost by default; the high-severity scenario requires the developer to run 'vite --host' (or otherwise expose the port) on an untrusted network. The low EPSS despite a published POC is consistent with a developer-tooling vulnerability that is hard to reach at scale, not a mass-exploitation target. |
| Exploit ScenarioDerived | A developer runs the RSC dev server with 'vite --host' on a shared or untrusted network. An attacker on that network sends a crafted POST to the /_.rsc server-function endpoint with an x-rsc-action header (or server-reference id) pointing at a 'data:text/javascript,...' URL, which the unsafe dynamic import loads and executes with Node.js privileges. A fully functional POC is published in the GHSA advisory, so exploitation is turnkey and the attacker gains arbitrary code execution to read files, steal environment variables/credentials, or pivot to internal services. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 14, 2026
Arbitrary remote code execution in @vitejs/plugin-rsc 0.5.5 and earlier lets unauthenticated network attackers run JavaScript with Node.js privileges on a running Vite development server that uses React Server Components and exposes server-function endpoints. The flaw lives in the development-mode dynamic import path used by loadServerAction, decodeReply, and decodeAction, which accepts attacker-controlled references (including data: URL modules) supplied via the x-rsc-action header and request body; a public proof-of-concept exploit exists in the GitHub Security Advisory, though EPSS rates near-term exploitation likelihood low at 0.81% (56th percentile) and it is not in CISA KEV. Impact is confined to development servers - production builds are unaffected - but risk rises sharply when developers run 'vite --host', exposing the port on all network interfaces.
RemediationAI
Upgrade @vitejs/plugin-rsc to 0.5.6, which is the vendor-released fix and adds reference allowlist validation (commit fe634b58210d0a4a146a7faae56cd71af3bb9af4; advisory GHSA-j76j-5p5g-9wfr at https://github.com/vitejs/vite-plugin-react/security/advisories/GHSA-j76j-5p5g-9wfr). Because the vulnerable code path only exists on the development server, the highest-value compensating control is network containment: do not run 'vite dev' with '--host' or any binding that exposes the port beyond localhost, and if remote access is required, place the dev server behind an authenticated reverse proxy or VPN rather than a public interface - the trade-off is added access friction for remote developers. Additionally, firewall the dev port (default 5173) to trusted source addresses and run dev servers inside an isolated container or network namespace with minimal filesystem and environment-variable exposure, since successful exploitation yields file read/write and credential exfiltration with Node.js privileges; the trade-off is reduced convenience and potential breakage of cross-service dev integrations. Disabling or removing the RSC server-function endpoint handler (the /_.rsc route) in any shared or internet-reachable environment eliminates the attack surface entirely, at the cost of the development functionality that depends on it. Rotate any environment variables, tokens, or source-repository credentials that were present in a dev server known to have been exposed, as the flaw permits data exfiltration.
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerability is a code-injection flaw (CWE-94) in the React Server Components integration layer of the Vite plugin ecosystem. In development mode, the plugin resolves server and client references by performing dynamic imports of module identifiers derived from request data; because the reference identifier is taken directly from the 'x-rsc-action' header and the serialized multipart FormData body consumed by loadServerAction/decodeReply/decodeAction, an attacker can supply a 'data:text/javascript,...' URL that Vite's dev-time module runner happily imports and evaluates. The patch commit fe634b58210d0a4a146a7faae56cd71af3bb9af4 addresses this by introducing a 'virtual:vite-rsc/reference-validation' module and a parseReferenceValidationVirtual helper; the rsc.tsx and ssr.tsx entry points now probe that virtual module before importing a reference, and the plugin's load handler errors with "[vite-rsc] invalid reference" when the supplied id does not match a known client or server reference registered in the manager's reference meta maps. New end-to-end tests assert that bogus references such as '__invalid_reference__' produce a 500 response instead of being imported, converting what was an arbitrary-import primitive into an allowlist check.
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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Reachable dev-server endpoint accepts attacker data: URLs with no auth or interaction (AV:N/AC:L/PR:N/UI:N) yielding full Node code execution (C:H/I:H/A:H); dev-only scope is not modeled by base metrics.
Primary rating from Vendor (github).
CVSS VectorVendor: github
DescriptionCVE.org
@vitejs/plugin-rs provides React Server Components (RSC) support for Vite. Versions 0.5.5 and below are vulnerable to arbitrary remote code execution on the development server through unsafe dynamic imports in server function APIs (loadServerAction, decodeReply, decodeAction) when integrated into RSC applications that expose server function endpoints. Attackers with network access to the development server can read/modify files, exfiltrate sensitive data (source code, environment variables, credentials), or pivot to other internal services. While this affects development servers only, the risk increases when using vite --host to expose the server on all network interfaces. This issue is fixed in version 0.5.6.
Executive ViewAI
@vitejs/plugin-rsc 0.5.5 and earlier carries a critical remote code execution flaw that lets a remote attacker execute arbitrary JavaScript with Node.js privileges on a running Vite development server using React Server Components. Only development-mode servers are affected - production builds are not - but developer workstations and shared development hosts frequently hold source code, API keys, cloud tokens, and database credentials, so a single exposed dev server can become a stepping stone into the wider environment. Engineering teams that run 'vite --host' or otherwise expose dev ports beyond localhost should treat this as urgent, particularly given that proof-of-concept exploit code is publicly documented.
No vendor-released patch identified at time of analysis. Interim mitigations: bind Vite dev servers to loopback only and never use 'vite --host' on untrusted or shared networks; block inbound network access to dev ports via host firewall or security group; run dev servers only in isolated containers or VMs under a least-privileged non-root Node user without access to production data or secrets; avoid placing sensitive credentials in development environments; monitor dev server logs for anomalous x-rsc-action header values and data: URL module imports; and apply the vendor fix immediately once the @vitejs/plugin-rsc advisory publishes a remediated release.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
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
Vitejs Vite before v2.9.13 was discovered to allow attackers to perform a directory traversal via a crafted URL to the v
Vite is a frontend tooling framework for JavaScript. Rated low severity (CVSS 2.3), this vulnerability is remotely explo
Vite is a frontend tooling framework for JavaScript. Rated low severity (CVSS 2.3), this vulnerability is remotely explo
Vite is a frontend tooling framework for javascript. Rated medium severity (CVSS 6.5), this vulnerability is remotely ex
NVD
CVE.org
EPSS
GitHub
Exploit-DB