CVE-2026-112947 is a path traversal vulnerability in the Vite development server that allows an attacker to retrieve the first 4 bytes of arbitrary files on disk by sending a request with the query parameter '?vite-wasm-instance'. This occurs because the internal Wasm plugin's load hook reads files without applying server.fs access restrictions. The vulnerability affects Vite versions >=0.2.8 <1.1.0, >=8.2.0 <8.2.4, and >=8.3.0 <8.3.3. It only impacts applications that expose the Vite dev server to the network, run on Node.js or Deno, and have sensitive information in the first 4 bytes of a file. The issue is fixed in versions 1.1.0, 8.2.4, and 8.3.3.
### Summary
The content of files outside `server.fs` setting can be returned to the browser if the project imports a file path concatenated with the `root`. For example, if the project references `<path-to-project-root>/etc/hosts`, the content of `/etc/hosts` was possible to be returned.
The content of files outside the `server.fs.allow` option can be returned to the browser when a project imports a file whose root-relative path matches an absolute path on the host. For example, referencing `<project-root>/etc/hosts` could make Vite return the host's `/etc/hosts` file.
### Impact
Only apps that meet all of the following conditions are affected:
- explicitly expose the Vite dev server to the network (using `--host` or the [`server.host` option](https://vite.dev/config/server-options#server-host))
- contain an imported file whose root-relative browser URL is also the absolute path of a readable file on the host
- The sensitive file is not matched by [`server.fs.deny`](https://vite.dev/config/server-options#server-fs-deny)
- the dev server is not running on Windows
### Details
When Vite analyzes an in-root import, it rewrites the resolved module ID to a browser URL such as `/etc/hostname`. In affected versions, Vite converts that URL with `fsPathFromUrl` and adds the result to `safeModulePaths`. Because `fsPathFromUrl` ensures a leading slash without resolving the URL against the project root, the project URL `/etc/hostname` is recorded as if it were the absolute filesystem path `/etc/hostname`.
For a later request to `/@fs/etc/hostname`, the raw-filesystem middleware interprets `/etc/hostname` as an absolute path. The access check applies `server.fs.deny`, then accepts paths present in `safeModulePaths` before checking `server.fs.allow`. As a result, the request can return the host file instead of the project file that originally populated `safeModulePaths`.
### PoC
The following example requires Linux with a readable `/etc/hostname`:
```bash
$ mkdir vite-safe-module-path-poc
$ cd vite-safe-module-path-poc
$ npm init -y
$ npm install vite@8.3.1
$ mkdir -p etc
$ echo 'PROJECT-DECOY\n' > etc/hostname
$ echo 'import "./etc/hostname"\n' > main.js
$ npx vite --host 127.0.0.1
```
In another terminal:
```bash
$ curl -o /dev/null -s -w '%{http_code}\n' http://127.0.0.1:5173/main.js
200
$ curl -sS -o response -w '%{http_code}\n' http://127.0.0.1:5173/@fs/etc/hostname
200
$ cmp -s response /etc/hostname && echo 'response matches host file'
response matches host file
```
CVE-2026-112945 is a cross-site scripting (XSS) vulnerability in the Vite frontend tooling framework affecting versions prior to 6.4.4, 7.3.7, 8.1.6, 8.2.4, and 8.3.3. The flaw arises when applications using custom middleware pass an unchanged browser request URL to server.transformIndexHtml, allowing attacker-controlled module execution via crafted development-server pages. This can expose sensitive data or permit critical actions in the affected application. The issue has been fixed in the specified versions.
CVE-2026-111762 is a vulnerability in a2aproject's a2a-java SDK prior to version 1.3.0.Final. The issue involves sensitive information, including bearer tokens and authentication credentials, being logged in cleartext when a JSON request body fails protobuf deserialization. This occurs in the RestHandler.parseRequestBody method during error handling. An attacker with access to server logs could retrieve these credentials and potentially send forged push notification updates. The vulnerability is fixed in version 1.3.0.Final.
A denial of service (DoS) vulnerability exists in @angular/router when Server-Side Rendering (SSR) is enabled on Node.js. The router fails to validate auxiliary outlet segments in URLs, allowing crafted requests with multiple empty-path outlet segments to cause excessive memory and CPU usage. This leads to Node.js process termination due to heap exhaustion. The vulnerability affects SSR configurations with empty-path or named outlet routes and can be mitigated by upgrading to patched versions or rejecting malicious URL patterns upstream.
CVE-2026-107188 is a critical vulnerability in Eptura Archibus allowing unrestricted upload of files with dangerous types. Attackers can upload JSP or JSPX files as export reports, which can then be accessed to execute arbitrary commands on the server. This vulnerability can be combined with an authentication bypass to run code without authentication.
Semaphore UI versions up to 2.19.16 contain a remote code execution vulnerability. Users with the task_runner role can override protected Ansible variables by injecting arbitrary keys in the task environment JSON. This allows execution of commands as the Semaphore server user, potentially exposing sensitive data such as encryption keys, SSH keys, and stored secrets.
The fabtoolkit package on PyPI contains malicious code that executes a payload fetching a remote JSON configuration from an attacker-controlled server with TLS verification disabled. This payload can read arbitrary files, execute arbitrary commands, perform HTTP requests with stolen tokens, probe TCP ports, and establish a reverse shell daemon. It collects sensitive data such as credentials and cloud metadata, packages it, and uploads it to the attacker’s server. The malware enforces single-instance persistence by killing prior instances and is triggered by running 'python -m fabtoolkit' or importing certain functions. The package has no legitimate functionality matching its name.
The tailwind-animationlab package version 2.0.6 is a malicious npm package linked to a fake job interview campaign. It includes a private scoped dependency that requires an npm token to access, which delivers malicious code executed when the plugin loads in tailwind.config.js and the development server starts. Although the published package itself contains no install scripts or network code, the private dependency payload compromises the system. Multiple related malicious packages were published over a period from July to October 2026. Systems with this package installed should be considered fully compromised.
The tailwind-animate-kit npm package versions 2.0.6, 2.0.7, and 2.0.8 are part of a malicious campaign involving a private dependency that executes code when the plugin is loaded in tailwind.config.js. The malicious payload is hidden in a private scoped package that requires an npm token to resolve, enabling code execution during development server startup. The package tarballs themselves contain no install scripts or network code, making detection difficult. This campaign includes multiple malicious packages published under various accounts between July and October 2026. Systems with this package installed should be considered fully compromised.
The tailwind-css-keyframes package version 1.0.7 is identified as malicious, associated with a fake job interview campaign. It includes a private scoped dependency that requires an npm token to access, which can execute code when the plugin is loaded in tailwind.config.js and the development server starts. The public tarball itself contains no install scripts or network code, and the malicious payload resides in the private dependency. Multiple related malicious packages were published over a period from July to October 2026. No install-time or import-time network activity, credential access, or obfuscated payloads were observed in the public package.
The npm package tailwind-animatecss-kit version 2.0.6 is associated with a malicious campaign involving fake job interviews. It includes a private scoped dependency that requires an npm token to resolve, enabling code execution when the plugin is loaded in tailwind.config.js and the development server starts. The public tarball itself contains no install scripts or network code, and no direct harmful code paths were identified in the shipped contents. Multiple similar packages were published under various accounts during mid-2026.
The animatecss-tailwind-plugin version 2.0.6 is a malicious Tailwind CSS plugin linked to a fake job interview campaign. It includes a private scoped dependency that requires an npm token to access, which delivers malicious code executed when the plugin loads in tailwind.config.js and the development server starts. The published package itself contains no install scripts or network code, and the malicious payload resides in the private dependency. Multiple similar malicious packages were published under various accounts over a recent period.
snac2 versions before 2.93 have a heap-based buffer overflow vulnerability in the _xs_json_load_lexer() function. This flaw allows unauthenticated remote attackers to corrupt heap memory by sending specially crafted JSON strings containing a \u0000 escape sequence. The vulnerability can be triggered by sending a malicious application/activity+json POST request to activitypub_post_handler(), which processes the input before signature verification, leading to heap overflow and server crashes. The issue is fixed in version 2.93.
CVE-2026-104150 is a vulnerability in AdonisJS HTTP Server version 3.0 involving uncontrolled resource consumption and inefficient regular expression complexity. This flaw can lead to excessive resource usage, potentially degrading server performance or causing denial of service conditions. No CVSS score or detailed impact metrics are provided. No patch or remediation information is available from the vendor or source data.
A missing authorization vulnerability exists in the MariaDB server's CONNECT engine plugin file-access UDFs (json_file(), bson_file(), jfile_make(), bfile_make(), and jbin_file()) in certain versions. These functions do not enforce the FILE privilege or the secure_file_priv setting, allowing a low-privileged attacker to read or write files on the filesystem that the database account is not authorized to access, subject to OS permissions. The issue affects multiple MariaDB versions and has been fixed in later releases.
CVE-2026-42270 is a vulnerability in countly-server, the server-side component of the Countly analytics platform. Prior to versions 24.05.50 and 25.03.44, certain public image and screenshot routes use local filesystem storage and call getStream to pipe filesystem streams to HTTP responses without an error listener. An unauthenticated request with a URL-encoded dot can cause createReadStream to open a directory, triggering an asynchronous EISDIR error that is unhandled, leading to termination of the Node.js process. This results in denial of service by making the analytics API unavailable. The issue affects routes such as star-rating/images/, dashboards/images/screenshots/, /appimages/*, /memberimages/*, and */screenshots/*. The vulnerability is fixed in versions 24.05.50 and 25.03.44.
The Debloat – Remove Unused CSS, Optimize JS WordPress plugin versions up to 1.3.0 contains a directory traversal vulnerability via the 's' parameter. This flaw allows authenticated users with administrator-level access or higher to read arbitrary files on the server if the Optimize CSS feature with Inline Google Fonts is enabled. The vulnerability can be triggered by an unauthenticated visitor with a crafted GET request to the public search URL. The CVSS score is 5.9, indicating a medium severity issue.
CVE-2026-105037 is a critical vulnerability in EnergizeLab station-middleware (NestJS) Docker images versions 1.6.5 through 1.8.2. It allows any registered user with low privileges to read arbitrary files on the server by supplying a malicious file path. This flaw exposes sensitive middleware files and server secrets, potentially leading to full compromise of confidentiality, integrity, and availability.
Node.js HTTP client library undici versions 6.23.0 through 6.29.0, 7.18.0 through 7.30.0, and 8.0.0 through 8.12.1 contain a vulnerability in the fetch() implementation. When a malicious server returns a response with more than five content codings and closes the connection before sending the body, the Node.js process crashes due to an unhandled error. This leads to a denial of service. The issue is fixed in versions 6.29.1, 7.30.1, and 8.12.2, and users should upgrade to these or later versions. No workaround exists.