Aug 6, 2026·4 min read·36 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.
CVE-2026-12243 is a path traversal vulnerability in the Natural Language Toolkit (NLTK) version 3.9.4. The flaw exists because the input validation routine fails to account for percent-encoded directory traversal sequences like '..%2f' before passing them to urllib.request.url2pathname(), which decodes them into active traversal sequences.
CVE-2026-73654 is a high-severity prototype pollution vulnerability in Trigger.dev. The flaw occurs during the handling of run-metadata updates through the PUT /api/v1/runs/:runId/metadata endpoint. Because user-supplied keys are parsed directly by the @jsonhero/path library without sanitization, an authenticated attacker with low privileges can pollute the global Object.prototype. This causes database queries via Prisma ORM to fail validation and induces unhandled exceptions in the Prometheus metrics client, resulting in a process-wide denial of service.
CVE-2026-73559 is an uncontrolled resource consumption vulnerability in the vLLM engine, specifically within the /v1/completions API endpoint, allowing authenticated attackers to cause application-level denial of service via unbounded prompt arrays.
A critical security bypass vulnerability in Argo Workflows allows authenticated attackers with workflow submission privileges to bypass 'Strict' or 'Secure' template referencing restrictions. By injecting unvalidated fields into the nested ArtifactGC configuration, attackers can execute arbitrary pod patches, leading to host namespace escape and cluster-wide privilege escalation.
A Server-Side Request Forgery (SSRF) / Confused Deputy vulnerability has been identified in Pydantic AI UI Adapters (such as VercelAIAdapter). Under certain conditions, a malicious client can supply manipulated message history with provider metadata that forces the server to resolve files within privileged cloud environments (AWS S3, Google Cloud Storage) or model providers. This occurs because the adapters deserialize client-provided metadata structures directly into UploadedFile instances without validation, which are subsequently fetched using high-privilege server credentials.
A path traversal vulnerability in the optional dashboard server of atomic-agents-stack before version 1.1.0 allows unauthenticated remote attackers to read arbitrary files from the host filesystem.