CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-RQ7W-G337-39QQ

GHSA-RQ7W-G337-39QQ: Project Directory Path and Workspace UUID Disclosure in Nuxt Dev Server

Amit Schendel
Amit Schendel
Senior Security Researcher

Jun 15, 2026·6 min read·16 visits

Executive Summary (TL;DR)

The Nuxt development server exposes a Chrome DevTools workspace endpoint that lacks proper cross-origin or host validation. Remote sites visited by a developer can exfiltrate the local directory path and a workspace UUID via DNS rebinding.

A security vulnerability in the Nuxt development server allows unauthenticated local or cross-origin attackers to retrieve the host machine's absolute project directory path and a persistent Chrome DevTools workspace UUID. The issue stems from an unprotected endpoint registered at `/.well-known/appspecific/com.chrome.devtools.json` which does not validate the HTTP Host, Origin, or Referer headers.

Vulnerability Overview

The Nuxt framework development environment spins up a local server using the Nitro engine to facilitate rapid prototyping and hot module replacement. To integrate with browser developer tools, Nuxt automatically implements an endpoint at the standard path /.well-known/appspecific/com.chrome.devtools.json. This endpoint facilitates Chrome DevTools Workspaces, allowing real-time synchronization between the browser's console and the local filesystem source code.\n\nIn vulnerable versions of Nuxt, this configuration route was registered directly without any security checks. It exposes the project's root directory path on the local filesystem and a unique, persistent workspace identifier. The endpoint serves this highly sensitive data to any network client capable of making a successful HTTP GET request to the development port.\n\nThe vulnerability is classified as an improper input validation and access control issue, mapping to CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor). It represents an exposure of internal system configurations to untrusted actors on the local area network or malicious third-party websites. The primary attack surfaces include cross-origin requests executed via DNS rebinding and direct probing over local networks.

Root Cause Analysis

The underlying flaw resides in how Nuxt configures and registers the Chrome DevTools integration handler. The Nitro server engine registers dev handlers through a pipeline designed to host utility endpoints. In affected releases, the handler for the com.chrome.devtools.json route returned the configuration payload directly, omitting any checks on the incoming HTTP request.\n\nThe server did not implement origin, referer, or host header verification before responding to requests. Consequently, any HTTP client that addressed the server's port could retrieve the sensitive JSON object. This behavior violates standard browser security assumptions regarding local development ports, which are typically assumed to be isolated from remote web origins.\n\nUnder normal conditions, browsers enforce the Same-Origin Policy (SOP) to block cross-origin reads. However, because the server did not validate the HTTP Host header, it remained fully susceptible to DNS rebinding techniques. Furthermore, if the server bound to all interfaces (using 0.0.0.0), any host on the same local network could access the endpoint directly without triggering cross-origin protections.

Code Analysis

To understand the technical implementation, it is necessary to examine the original implementation within packages/nitro-server/src/index.ts. The handler was declared as a simple, unconditional event responder that returned the directory and project configuration.\n\ntypescript\n// Vulnerable Code Pattern\nnitro.options.devHandlers.push({\n route: '/.well-known/appspecific/com.chrome.devtools.json',\n handler: defineEventHandler(() => ({\n workspace: {\n ...projectConfiguration,\n root: nuxt.options.rootDir,\n },\n })),\n})\n\n\nThe pull request #35201 resolved this by inserting an authorization check. This validation relies on a new helper function named isLocalDevRequest. The function tests the incoming request's metadata before returning the payload, falling back to a 403 Forbidden status if the check fails.\n\ntypescript\n// Patched Code Pattern\nnitro.options.devHandlers.push({\n route: '/.well-known/appspecific/com.chrome.devtools.json',\n handler: defineEventHandler((event) => {\n if (!isLocalDevRequest(event, getDevHandlerAllowedHosts(nuxt))) {\n setResponseStatus(event, 403)\n return 'Forbidden'\n }\n return {\n workspace: {\n ...projectConfiguration,\n root: nuxt.options.rootDir,\n },\n }\n }),\n})\n\n\nThe patch introduces a helper isLocalDevRequest which parses the host header, the sec-fetch-site header, and fallback origin or referer headers. The primary verification checks if the request's host matches loopback IPs or explicitly allowed hosts configured in Vite. It also uses the sec-fetch-site header to ensure the request is same-origin or initiated directly by the user (none).\n\nThere is a minor limitation in the host parser: const host = hostHeader?.split(':')[0]. For IPv6 addresses containing ports, such as [::1]:3000, splitting on the colon splits the address itself. This causes the host to be evaluated as [ which fails the loopback validation check and generates a 403 error for legitimate local IPv6 requests.\n\nmermaid\ngraph LR\n subgraph Client [Browser Context]\n A["Malicious Page"] -->|1. Fetch Request| B["Localhost Dev Server"]\n end\n subgraph Nuxt [Vulnerable Dev Server]\n B -->|2. Route Handler| C["com.chrome.devtools.json"]\n C -->|3. Discloses| D["Absolute Root Path & UUID"]\n D -->|4. Exfiltrated Data| A\n end\n

Exploitation Methodology

Exploitation requires that an attacker establish a vector to reach the development port, typically 3000, on the developer's local machine. Under a DNS rebinding attack, the target developer is enticed to visit a malicious domain controlled by the attacker. The attacker's domain is configured with a very low Time-To-Live (TTL) value to facilitate rapid IP changes.\n\nOnce the page loads, the attacker's DNS server updates its resolution to point to 127.0.0.1. The browser, believing it is communicating with the original domain, issues an asynchronous HTTP request to the development port. Because the browser treats this request as same-origin with the malicious page, the script can bypass standard SOP and read the JSON response.\n\nAlternatively, if the developer binds the server to 0.0.0.0, the endpoint is exposed directly to the local subnet. Any malicious device on the same local network can perform a direct HTTP GET request to retrieve the data. In this scenario, no browser-based interaction is required to successfully extract the information.\n\nbash\n# LAN-based data extraction command\ncurl -s http://192.168.1.50:3000/.well-known/appspecific/com.chrome.devtools.json\n

Impact Assessment

The exposure of the absolute filesystem path reveals local system details. This disclosure provides information such as local usernames, home directory structures, and naming conventions of internal development projects. For example, a response revealing /Users/restricted_dev/internal-projects/proprietary-finance leaks the precise organizational environment.\n\nThe exposure of the persistent workspace UUID represents a secondary security risk. This identifier remains constant across development sessions, allowing attackers to perform persistent tracking and fingerprinting of a specific developer's machine. This identifier could also be abused to target internal APIs exposed by browser extensions or IDE integrations that rely on the workspace configuration.\n\nWhile the vulnerability does not directly lead to remote code execution on its own, it functions as a critical reconnaissance step. Attackers can combine filesystem layout information with other local vulnerabilities, such as local file inclusion or directory traversal, to construct targeted exploit chains. The absence of validation on developer-facing local endpoints remains a significant threat vector.

Remediation and Mitigation

The primary mitigation strategy is upgrading the project's Nuxt dependencies to a version incorporating the fix from Pull Request #35201. This introduces the host validation mechanism and rejects unauthorized requests with a 403 status code. Developers should execute a clean package installation to ensure the patch is applied to the active node_modules environment.\n\nIf immediate upgrading is not possible, developers should ensure the development server is strictly bound to the loopback interface (127.0.0.1 or ::1). Binding to wildcard interfaces like 0.0.0.0 or --host should be avoided unless strictly necessary and conducted within an isolated network. Using containers can also isolate the host filesystem and mitigate directory disclosures.\n\nDevelopers can manually verify their exposure using network tools. Sending a modified Host header to the local server simulates a DNS rebinding attempt. If the server returns a 403 Forbidden status, the mitigation is active; a 200 OK status indicates the development server remains vulnerable.\n\nbash\n# Verification command simulating a rebinding host\ncurl -I -H "Host: rogue-domain.com" http://localhost:3000/.well-known/appspecific/com.chrome.devtools.json\n

Fix Analysis (1)

Technical Appendix

CVSS Score
6.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:N/A:N

Affected Systems

Nuxt framework development server

Affected Versions Detail

Product
Affected Versions
Fixed Version
Nuxt
Nuxt
All versions before patch #35201v3.12.0
AttributeDetail
CWE IDCWE-200
Attack VectorNetwork / Local
CVSS Score6.5
ImpactInformation Disclosure
Exploit StatusNone
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1592Gather Victim Host Information
Reconnaissance
CWE-200
Exposure of Sensitive Information to an Unauthorized Actor

The product exposes sensitive information to an actor who is not authorized to have access to that information.

References & Sources

  • [1]GitHub Pull Request #35201
  • [2]Official Fix Commit
  • [3]GitHub Advisory Database Record

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•1 day ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
6 views•10 min read
•1 day ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
12 views•12 min read
•1 day ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
6 views•12 min read
•1 day ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
13 views•10 min read
•1 day ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
14 views•10 min read
•1 day ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
6 views•9 min read