Aug 6, 2026·4 min read·6 visits
Nuxt DevTools before 3.3.1 allows unauthenticated remote attackers to execute arbitrary shell commands via exposed WebSocket RPC endpoints.
An unauthenticated remote code execution (RCE) vulnerability exists in Nuxt DevTools prior to version 3.3.1. The vulnerability arises from an unauthenticated RPC channel exposed over the Vite Hot Module Replacement (HMR) WebSocket server, allowing an attacker to modify file editor configurations and execute arbitrary commands under the server context.
Nuxt DevTools exposes a bidirectional RPC (Remote Procedure Call) channel designed to assist developers in inspecting and debugging Nuxt applications directly from their browsers.\n\nThis communication channel is established automatically during development and runs on top of the Vite Hot Module Replacement (HMR) WebSocket server using the vite-hmr subprotocol.\n\nIn vulnerable versions of @nuxt/devtools (prior to 3.3.1), the RPC interface is exposed without authorization controls, origin checks, or authentication handshake protocols, presenting an unauthenticated entry point to the host system.
The core of the vulnerability lies in the lack of privilege verification on sensitive RPC methods.\n\nWhile some actions that modify the server state require a developer authentication token (devAuthToken), several administrative functions were left entirely unguarded.\n\nSpecifically, the updateOptions() and openInEditor() methods did not require any authentication token. This oversight allows an unauthenticated client connecting to the Vite HMR WebSocket to invoke updateOptions() to alter the configuration mapping for the file editor to a malicious shell command.\n\nWhen the client subsequently calls openInEditor(), the backend utilizes the launch-editor Node.js library to execute the modified editor command as a child process via child_process.spawn or child_process.exec, resulting in command injection and execution under the context of the running Node.js development server.
To understand the flaw, we examine the differences in the RPC service definition and execution flow. The following diff illustrates how the server handlers were refactored to enforce authentication.\n\ntypescript\n// In packages/devtools-kit/src/_types/rpc.ts\nexport interface ServerFunctions {\n- updateOptions: <T extends keyof NuxtDevToolsOptions>(tab: T, settings: Partial<NuxtDevToolsOptions[T]>) => Promise<void>\n- clearOptions: () => Promise<void>\n+ updateOptions: <T extends keyof NuxtDevToolsOptions>(token: string, tab: T, settings: Partial<NuxtDevToolsOptions[T]>) => Promise<void>\n+ clearOptions: (token: string) => Promise<void>\n\n- openInEditor: (filepath: string) => Promise<boolean>\n+ openInEditor: (token: string, filepath: string) => Promise<boolean>\n}\n\n\nIn the patched version, the backend explicitly verifies the user-provided token against the generated devAuthToken before proceeding with the operation.\n\ntypescript\n// In packages/devtools/src/server-rpc/general.ts\n- async openInEditor(input: string): Promise<boolean> {\n+ async openInEditor(token: string, input: string): Promise<boolean> {\n+ await ensureDevAuthToken(token)\n if (input.startsWith('./') || !ABSOLUTE_PATH_RE.test(input))\n input = resolve(process.cwd(), input)\n\n\nWithout this token validation, any local or external entity capable of establishing a WebSocket connection could modify settings and execute arbitrary commands.
An attacker can exploit this vulnerability through two main pathways: local network exposure or Cross-Site WebSocket Hijacking (CSWSH).\n\nIf a developer starts their server binding to all interfaces (e.g., 0.0.0.0), an attacker on the same local network can establish a WebSocket connection directly. Alternatively, if the server is bound to localhost, a malicious website visited by the developer can perform a CSWSH attack, exploiting the fact that browsers do not restrict cross-origin WebSocket connections.\n\nmermaid\ngraph LR\n Attacker[\"Attacker Client\"] -->|\"1. Connects with subprotocol 'vite-hmr'\"| WS[\"Vite HMR WebSocket Port\"]\n Attacker -->|\"2. Send updateOptions RPC to change editor to malicious cmd\"| WS\n Attacker -->|\"3. Send openInEditor RPC\"| WS\n WS -->|\"4. launch-editor runs command\"| OS[\"Host Operating System Command Execution\"]\n\n\nTo trigger the execution, the attacker sends two distinct JSON-RPC frames over the WebSocket protocol. The first payload registers a malicious payload in the openInEditor setting. The second payload triggers the execution of that editor command by requesting a standard project file to be opened.
Successful exploitation allows an unauthenticated remote attacker to achieve arbitrary code execution on the developer's workstation under the context of the user running the Node.js application.\n\nBecause developers often operate with elevated privileges or hold sensitive credentials (such as API keys, SSH keys, and cloud environment variables) on their workstations, a compromise of the development host has high severity.\n\nThis vulnerability is tracked as CVE-2026-71319 with a CVSS v3.1 score of 9.6, indicating critical severity due to the potential for complete host takeover.
The primary remediation strategy is upgrading @nuxt/devtools to version 3.3.1 or newer, which enforces devAuthToken validation on all sensitive endpoints.\n\nIf an immediate upgrade is not feasible, developers should disable Nuxt DevTools in their configuration file.\n\ntypescript\n// In nuxt.config.ts\nexport default defineNuxtConfig({\n devtools: {\n enabled: false\n }\n})\n\n\nAdditionally, developers should ensure that the development server binds only to loopback interfaces (such as 127.0.0.1) rather than 0.0.0.0 to minimize exposure to local network actors.
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Nuxt DevTools (@nuxt/devtools) Nuxt | < 3.3.1 | 3.3.1 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-94 / CWE-306 |
| Attack Vector | Network |
| CVSS Score | 9.6 |
| Exploit Status | Proof of Concept (PoC) |
| CISA KEV Status | Not Listed |
| Ransomware Association | No |
The application constructs code or command sequences using externally-influenced input, allowing unauthorized execution of arbitrary commands.
A local encoding path traversal vulnerability exists in rclone versions from v1.51.0 up to v1.75.0. When non-default local encoding parameters (such as Slash, None, or Raw) are specified, rclone's standard decoder maps safely encoded fullwidth dot-dot characters back into native directory traversal components. Since the local backend historically lacked a post-resolution path containment check, these relative segments resolved outside the designated synchronization root, allowing arbitrary file creation and modification on the host system.
An security bypass vulnerability exists in Nuxt frameworks where route rules containing mixed-case characters are silently dropped during case-insensitive routing. This occurs because lookups are folded to lowercase, but keys are stored in their original casing in the route-matching trie. As a result, critical authorization middleware, such as appMiddleware, is bypassed, allowing unauthorized access to restricted pages.
CVE-2026-71316 is a high-severity vulnerability affecting the Nuxt web development framework in versions 4.4.0 up to (but excluding) 4.5.1. Due to the lack of runtime isolation in the shared server runtime storage driver, unauthenticated remote attackers can query the static-like JSON representation of a route's server-side rendered (SSR) state (_payload.json) and bypass configured page guards and application middleware to obtain highly sensitive user session records.
CVE-2026-71318 is a vulnerability in Nuxt where unauthenticated remote attackers can trigger unauthorized component instantiation and arbitrary HTML element injection. This security flaw is caused by default attribute inheritance (fallthrough) combined with polymorphic root components inside island components accessible via the /__nuxt_island/ endpoint. Attackers can bypass standard routing checks to instantiate globally registered components or inject raw HTML tags like iframes. This vector is highly reachable since it does not require enabling the vue.runtimeCompiler option. It is patched in Nuxt versions 3.21.10 and 4.5.1.
A highly critical Server-Side Remote Code Execution (RCE) vulnerability exists in the Nuxt framework when Server Islands and the Vue runtime compiler are simultaneously enabled. This allows unauthenticated remote attackers to execute arbitrary system commands on the host process by passing a crafted component definition object to the dynamic component resolution engine via public island endpoints.
An unauthenticated remote denial of service vulnerability exists in the Nuxt framework island renderer endpoint. By transmitting large or deeply nested JSON payloads, an attacker can block the single-threaded Node.js event loop, resulting in application-wide CPU exhaustion before signature verification occurs.