CVE-2026-39406 is a path traversal vulnerability in honojs node-server versions prior to 1.19.13. The issue arises from inconsistent path handling in the serveStatic function, which normalizes repeated slashes in request paths. When route-based middleware is used for authorization, paths containing repeated slashes may bypass middleware checks, allowing unauthorized access to protected static files. This vulnerability has a CVSS score of 5.3 (medium severity) and does not affect availability or integrity, only confidentiality to a limited extent. The vulnerability is fixed in version 1.19.13.
Parse Server is an open source backend that can be deployed to any infrastructure that can run Node.js. Prior to 9.8.0-alpha.7 and 8.6.75, the GET /sessions/me endpoint returns _Session fields that the server operator explicitly configured as protected via the protectedFields server option. Any authenticated user can retrieve their own session's protected fields with a single request. The equivalent GET /sessions and GET /sessions/:objectId endpoints correctly strip protected fields. This vulnerability is fixed in 9.8.0-alpha.7 and 8.6.75.
### Summary
Any files ending with `.map` even out side the project can be returned to the browser.
### Impact
Only apps that match the following conditions are affected:
- explicitly exposes the Vite dev server to the network (using `--host` or [`server.host` config option](https://vitejs.dev/config/server-options.html#server-host))
- have a sensitive content in files ending with `.map` and the path is predictable
### Details
In Vite v7.3.1, the dev server’s handling of `.map` requests for optimized dependencies resolves file paths and calls `readFile` without restricting `../` segments in the URL. As a result, it is possible to bypass the [`server.fs.strict`](https://vite.dev/config/server-options#server-fs-strict) allow list and retrieve `.map` files located outside the project root, provided they can be parsed as valid source map JSON.
### PoC
1. Create a minimal PoC sourcemap outside the project root
```bash
cat > /tmp/poc.map <<'EOF'
{"version":3,"file":"x.js","sources":[],"names":[],"mappings":""}
EOF
```
2. Start the Vite dev server (example)
```bash
pnpm -C playground/fs-serve dev --host 127.0.0.1 --port 18080
```
3. Confirm that direct `/@fs` access is blocked by `strict` (returns 403)
<img width="4004" height="1038" alt="image" src="https://github.com/user-attachments/assets/15a859a8-1dc6-4105-8d58-80527c0dd9ab" />
4. Inject `../` segments under the optimized deps `.map` URL prefix to reach `/tmp/poc.map`
<img width="2790" height="846" alt="image" src="https://github.com/user-attachments/assets/5d02957d-2e6a-4c45-9819-3f024e0e81f2" />
### Summary
The contents of files that are specified by [`server.fs.deny`](https://vite.dev/config/server-options#server-fs-deny) can be returned to the browser.
### Impact
Only apps that match the following conditions are affected:
- explicitly exposes the Vite dev server to the network (using `--host` or [`server.host` config option](https://vitejs.dev/config/server-options.html#server-host))
- the sensitive file exists in the allowed directories specified by [`server.fs.allow`](https://vite.dev/config/server-options#server-fs-allow)
- the sensitive file is denied with a pattern that matches a file by [`server.fs.deny`](https://vite.dev/config/server-options#server-fs-deny)
### Details
On the Vite dev server, files that should be blocked by `server.fs.deny` (e.g., `.env`, `*.crt`) can be retrieved with HTTP 200 responses when query parameters such as `?raw`, `?import&raw`, or `?import&url&inline` are appended.
### PoC
1. Start the dev server: `pnpm exec vite root --host 127.0.0.1 --port 5175 --strictPort`
2. Confirm that `server.fs.deny` is enforced (expect 403): `curl -i http://127.0.0.1:5175/src/.env | head -n 20`
<img width="3944" height="1092" alt="image" src="https://github.com/user-attachments/assets/ecb9f2e0-e08f-4ac7-b194-e0f988c4cd4f" />
3. Confirm that the same files can be retrieved with query parameters (expect 200):
<img width="2014" height="373" alt="image" src="https://github.com/user-attachments/assets/76bc2a6a-44f4-4161-ae47-eab5ae0c04a8" />
### Summary
[`server.fs`](https://vite.dev/config/server-options#server-fs-strict) check was not enforced to the `fetchModule` method that is exposed in Vite dev server's WebSocket.
### Impact
Only apps that match the following conditions are affected:
- explicitly exposes the Vite dev server to the network (using `--host` or [`server.host` config option](https://vitejs.dev/config/server-options.html#server-host))
- WebSocket is not disabled by `server.ws: false`
Arbitrary files on the server (development machine, CI environment, container, etc.) can be exposed.
### Details
If it is possible to connect to the Vite dev server’s WebSocket **without an `Origin` header**, an attacker can invoke `fetchModule` via the custom WebSocket event `vite:invoke` and combine `file://...` with `?raw` (or `?inline`) to retrieve the contents of arbitrary files on the server as a JavaScript string (e.g., `export default "..."`).
The access control enforced in the HTTP request path (such as `server.fs.allow`) is not applied to this WebSocket-based execution path.
### PoC
1. Start the dev server on the target
Example (used during validation with this repository):
```bash
pnpm -C playground/alias exec vite --host 0.0.0.0 --port 5173
```
2. Confirm that access is blocked via the HTTP path (example: arbitrary file)
```bash
curl -i 'http://localhost:5173/@fs/etc/passwd?raw'
```
Result: `403 Restricted` (outside the allow list)
<img width="3898" height="1014" alt="image" src="https://github.com/user-attachments/assets/f6593377-549c-45d7-b562-5c19833438af" />
3. Confirm that the same file can be retrieved via the WebSocket path
By connecting to the HMR WebSocket without an `Origin` header and sending a `vite:invoke` request that calls `fetchModule` with a `file://...` URL and `?raw`, the file contents are returned as a JavaScript module.
<img width="1049" height="296" alt="image" src="https://github.com/user-attachments/assets/af969f7b-d34e-4af4-8adb-5e2b83b31972" />
<img width="1382" height="955" alt="image" src="https://github.com/user-attachments/assets/6a230d2e-197a-4c9c-b373-d0129756d5d7" />
A Cross-Site Request Forgery (CSRF) vulnerability exists in RedwoodJS SDK versions from 1.0.0-beta.50 up to but not including 1.0.6. Server functions exported from "use server" files could be invoked via GET requests, bypassing intended HTTP method restrictions. In cookie-authenticated applications, this allowed cross-site GET navigations to trigger state-changing functions due to browsers sending SameSite=Lax cookies on top-level GET requests. This affects all server functions, including serverAction() handlers and bare exported functions. The vulnerability is fixed in version 1.
WWBN AVideo is an open source video platform. In versions 26.0 and prior, objects/aVideoEncoderReceiveImage.json.php allowed an authenticated uploader to fetch attacker-controlled same-origin /videos/... URLs, bypass traversal scrubbing, and expose server-local files through the GIF poster storage path. The vulnerable GIF branch could be abused to read local files such as /etc/passwd or application source files and republish those bytes through a normal public GIF media URL.
Parse Server is an open source backend that can be deployed to any infrastructure that can run Node.js. Prior to 9.8.0-alpha.6 and 8.6.74, he login endpoint response time differs measurably depending on whether the submitted username or email exists in the database. When a user is not found, the server responds immediately. When a user exists but the password is wrong, a bcrypt comparison runs first, adding significant latency. This timing difference allows an unauthenticated attacker to enumerate valid usernames. This vulnerability is fixed in 9.8.0-alpha.6 and 8.6.74.
PraisonAI is a multi-agent teams system. Prior to 1.5.113, PraisonAI's recipe registry publish endpoint writes uploaded recipe bundles to a filesystem path derived from the bundle's internal manifest.json before it verifies that the manifest name and version match the HTTP route. A malicious publisher can place ../ traversal sequences in the bundle manifest and cause the registry server to create files outside the configured registry root even though the request is ultimately rejected with HTTP 400. This is an arbitrary file write / path traversal issue on the registry host. It affects deployments that expose the recipe registry publish flow. If the registry is intentionally run without a token, any network client that can reach the service can trigger it. If a token is configured, any user with publish access can still exploit it. This vulnerability is fixed in 1.5.113.
A vulnerability in the NestJS framework prior to version 11.1.18 allows improper neutralization of newline characters in Server-Sent Events (SSE) output. Specifically, the SseStream. _transform() method interpolates message.type and message.id directly into SSE text output without sanitizing carriage return and newline characters. This can enable an attacker who controls these fields to inject arbitrary SSE events, spoof event types, and disrupt reconnection state. The issue is fixed in version 11.1.
CVE-2026-5627 is a critical path traversal vulnerability in mintplex-labs/anything-llm up to version 1.9.1, specifically in the AgentFlows component. It allows attackers with high privileges to bypass directory restrictions via crafted input to loadFlow and deleteFlow methods, potentially accessing or deleting arbitrary JSON files on the server. This can lead to disclosure of sensitive configuration files containing API keys or denial of service by deleting important files like package.json. The vulnerability is fixed in version 1.12.1. No official patch link or advisory is provided in the data, and no known exploits are reported in the wild.
The npm package @langgraphjs/toolkit versions 1.2.10 and 1.2.11 contains malicious code that executes a postinstall script to collect sensitive system information and exfiltrate it to a hardcoded external server. The package impersonates the LangChain/LangGraph ecosystem to deceive users. The exfiltrated data includes hostname, OS username, current working directory, git committer email, and GitHub login/email, violating user consent and privacy. Installation of this package may lead to full system compromise, requiring immediate secret and key rotation and package removal.
Parse Server is an open source backend that can be deployed to any infrastructure that can run Node.js. Prior to 8.6.73 and 9.7.1, a file can be uploaded with a filename extension that passes the file extension allowlist (e.g., .txt) but with a Content-Type header that differs from the extension (e.g., text/html). The Content-Type is passed to the storage adapter without consistency validation. Storage adapters that store and serve the provided Content-Type (such as S3 or GCS) serve the file with the mismatched Content-Type. The default GridFS adapter is not affected because it derives Content-Type from the filename at serving time. This vulnerability is fixed in 8.6.73 and 9.7.1.
WWBN AVideo versions 26.0 and earlier contain a vulnerability where the plugin/API/check.ffmpeg.json.php endpoint exposes FFmpeg remote server connectivity status without requiring authentication. This contrasts with other FFmpeg management endpoints that do require administrative privileges. The vulnerability is classified as CWE-306 (Missing Authentication for Critical Function) and has a CVSS 3.1 base score of 5.3, indicating medium severity.
Open edX Platform enables the authoring and delivery of online learning at any scale. The view_survey endpoint accepts a redirect_url GET parameter that is passed directly to HttpResponseRedirect() without any URL validation. When a non-existent survey name is provided, the server issues an immediate HTTP 302 redirect to the attacker-controlled URL. Additionally, the same unvalidated URL is embedded in a hidden form field and returned in a JSON response after form submission, where client-side JavaScript performs location.href = url. This enables phishing and credential theft attacks against authenticated Open edX users. This vulnerability is fixed with commit 76462f1e5fa9b37d2621ad7ad19514b403908970.
WWBN AVideo versions 26.0 and earlier contain a missing authorization vulnerability in the SocialMediaPublisher plugin. The publishInstagram.json.php endpoint acts as an unauthenticated proxy to the Facebook/Instagram Graph API, accepting user-controlled parameters including access tokens and Instagram account IDs. This allows unauthenticated users to make arbitrary Graph API calls through the server, potentially abusing stolen tokens or the platform's credentials. The vulnerability has a medium severity with a CVSS score of 5.3. No official patch or remediation guidance has been provided by the vendor as of the publication date.
vLLM versions from 0.16.0 up to but not including 0.19.0 contain a server-side request forgery (SSRF) vulnerability in the download_bytes_from_url function. This flaw allows an attacker who can control batch input JSON to make the vLLM batch runner issue arbitrary HTTP/HTTPS requests from the server without any URL validation or domain restrictions. The vulnerability enables targeting of internal services accessible from the vLLM host, such as cloud metadata endpoints or internal HTTP APIs. The issue is fixed in version 0.19.0.
Pi-hole Admin Interface is a web interface for managing Pi-hole, a network-level ad and internet tracker blocking application. From 6.0 to before 6.5, the formatInfo() function in queries.js renders data.upstream, data.client.ip, and data.ede.text into HTML without escaping when a user expands a query row in the Query Log, enabling stored HTML injection. JavaScript execution is blocked by the server's CSP (script-src 'self'). The same fields are properly escaped in the table view (rowCallback), confirming the omission was an oversight. This vulnerability is fixed in 6.5.
A flaw was found in Keycloak. A remote attacker can exploit a Cross-Origin Resource Sharing (CORS) header injection vulnerability in Keycloak's User-Managed Access (UMA) token endpoint. This flaw occurs because the `azp` claim from a client-supplied JSON Web Token (JWT) is used to set the `Access-Control-Allow-Origin` header before the JWT signature is validated. When a specially crafted JWT with an attacker-controlled `azp` value is processed, this value is reflected as the CORS origin, even if the grant is later rejected. This can lead to the exposure of low-sensitivity information from authorization server error responses, weakening origin isolation, but only when a target client is misconfigured with `webOrigins: ["*"]`.
A memory leak vulnerability exists in Node.js HTTP/2 servers when a client sends WINDOW_UPDATE frames on stream 0 that cause the flow control window to exceed the maximum allowed value. Although the server responds with a GOAWAY frame, the associated Http2Session object is not properly cleaned up, leading to resource leakage. This affects multiple Node.js versions including 20, 21, 23, and 25 within specified version ranges.