node-re2 provides RE2 regular expression bindings for Node.js. Prior to version 1.25.1, the WrappedRE2::Replace function built its replacement result and passed it to V8 using ToLocalChecked without checking for the empty MaybeLocal that V8 returns when the resulting string or buffer exceeds V8's maximum string length. When a global replace uses an output amplifying replacement template, the result can grow quadratically with the input size, and once the result exceeds V8's maximum string length, the unchecked ToLocalChecked call causes a fatal, uncatchable process abort instead of a catchable exception. This issue is fixed in version 1.25.1.
OpenZeppelin Contracts Wizard is a web application to interactively build a contract out of components from OpenZeppelin Contracts. Versions prior to 0.10.9 generate a Hardhat test file (`test/test.ts`) by interpolating user-supplied `opts.name` (ERC20/ERC721) and `opts.uri` (ERC1155) directly into TypeScript string literals at `zip-hardhat.ts:48` and `:50` without any JavaScript string escaping. No authentication is required: an attacker crafts a URL such as `https[:]//wizard[.]openzeppelin[.]com/#/erc20?name=");require("child_process").execSync("...");("` and shares it with a developer. When the victim downloads the resulting zip archive and runs `npx hardhat test`, the injected Node.js code executes with the developer's local OS privileges. Version 0.10.9 fixes the issue.
js-yaml versions 3.x and 4.x contain a quadratic CPU consumption vulnerability in the resolution of the !!omap YAML type. The vulnerability arises from a linear scan to enforce key uniqueness, causing CPU usage to grow quadratically with the number of entries. This can lead to denial of service by blocking the Node.js event loop during YAML parsing of attacker-controlled input. The issue is fixed in js-yaml 5.2.1 by using a Set to track keys, but this fix was not backported to the 3.x and 4.x lines.
The supersig npm package version 1.0.5 contains malicious code concealed in its distributed bundles that is not present in the source tree. This code decrypts and executes a payload at load time by spawning a new Node.js process and feeding it decrypted code from an external dependency. The decryption key is obtained from an unpinned dependency, allowing the payload to be changed dynamically by whoever controls that dependency. Any system with this package installed should be considered fully compromised.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (5f6b581f4ab8d027c727649fae10749a9ac9a59af4619f5576362ab9243cb6c6)
The package's exported API (getPlugin/setPlugin) decodes two base64 string literals at runtime: the first decodes to `npm install node-internal-svg-loader --no-save --silent --no-audit --no-fund`, which is passed to child_process.spawn; the second decodes to the module name `node-internal-svg-loader`, which is then require()'d and whose getPlugin()/setPlugin() are invoked. The fetched package is not declared in package.json dependencies, and both the shell command and the require target are concealed in base64 to evade static inspection. Any consumer that imports this library and calls its documented API causes an undeclared, hidden third-party npm package to be installed and its code executed in the installer's Node.js process.
## Source: ghsa-malware (8da5f5874a95540b2a9ef4a13235eda70e4c5d853fcefeb886e2d0452eb98aa9)
Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it.
The npm package 'xxdxax' versions 1.0.0 and 1.0.1 contains obfuscated malicious code designed to execute only in a browser environment when loaded on a specific WordPress site (noviembrenacional.com). The code exfiltrates page HTML and authenticated session data to a hardcoded external endpoint, then abuses the victim's WordPress session to delete other users' accounts or hijack the target account by changing its email and triggering a password reset. The payload is concealed using unicode escapes and string reversal techniques. This package is not a general-purpose library but a targeted offensive tool for account takeover on a specific WordPress site. Installing the package does not trigger the payload in Node.js environments, as it relies on browser APIs and site-specific conditions.
The express-chai npm package version 3.7.9 contains malicious code that impersonates an Express logger middleware. It fetches a remote JSON payload from a base64-obfuscated URL and executes code from the payload with full access to the Node.js require function and application context, enabling arbitrary code execution during middleware setup.
## Summary
There is a critical authentication-bypass vulnerability in Traefik's `ReplacePathRegex` middleware. When it is configured with a regular expression that captures user-controlled path segments without a mandatory separator (for example `regex: "^/api(.*)"`, `replacement: "/$1"`), a crafted request can produce an un-normalized replacement path such as `/../admin`, which Traefik forwarded to the backend without validation. A backend that normalizes the path may resolve it to a protected route, letting an unauthenticated attacker reach resources located behind authentication middleware. This is the same class of issue that was fixed for `StripPrefix` in CVE-2026-48020; that post-replacement normalization check had not been applied to `ReplacePathRegex`. The fix rejects any request whose replaced path does not match its normalized form.
## Patches
- https://github.com/traefik/traefik/releases/tag/v2.11.52
- https://github.com/traefik/traefik/releases/tag/v3.6.23
- https://github.com/traefik/traefik/releases/tag/v3.7.7
## For more information
If you have any questions or comments about this advisory, please [open an issue](https://github.com/traefik/traefik/issues).
<details>
<summary>Original Description</summary>
### Summary
A path traversal vulnerability in the ReplacePathRegex middleware allows an unauthenticated remote attacker to bypass authentication middleware and access protected routes by sending a single crafted HTTP request. The vulnerability exists because ReplacePathRegex does not perform post-replacement path normalization validation - the same check added to StripPrefix in the fix for CVE-2026-48020 was not applied to ReplacePathRegex.
### Details
When ReplacePathRegex is configured with a regex that captures user-controlled path segments without a mandatory path separator (e.g., `regex: "^/api(.*)"`, `replacement: "/$1"`), an attacker can inject implicit traversal sequences into the capture group.
**Root cause:** `pkg/middlewares/replacepathregex/replace_path_regex.go`, function `ServeHTTP` (lines 56-74). After the regex substitution produces a new path, the middleware forwards it to the backend without checking whether the path normalizes differently - unlike StripPrefix which rejects such paths with HTTP 400 after the CVE-2026-48020 fix.
**Attack flow:**
1. Attacker sends `GET /api../admin`
2. `sanitizePath` passes it unchanged (`api..` is a valid segment name, not a dot-segment)
3. Router matches `PathPrefix(/api)` → selects the public router (no auth middleware)
4. ReplacePathRegex applies `^/api(.*)` → captures `../admin` → replacement produces `/../admin`
5. No normalization check exists → path forwarded to backend as-is
6. Backend framework (Express, Flask, Django, Spring, ASP.NET) normalizes `/../admin` to `/admin`
7. Attacker receives protected content without authentication
**Suggested fix:** Add the same JoinPath equality check after line 67:
```go
if cleanPath := req.URL.JoinPath(); cleanPath.Path != req.URL.Path {
http.Error(rw, http.StatusText(http.StatusBadRequest), http.StatusBadRequest)
return
}
```
### PoC
**Prerequisites:** Docker Engine 20.10+, Docker Compose v2, curl
**1. Create `docker-compose.yml`:**
```yaml
services:
traefik:
image: traefik:v3.7.6
command:
- "--api.insecure=true"
- "--providers.file.filename=/etc/traefik/dynamic.yml"
- "--entrypoints.web.address=:80"
ports:
- "8080:8080"
- "80:80"
volumes:
- ./dynamic.yml:/etc/traefik/dynamic.yml:ro
healthcheck:
test: ["CMD", "traefik", "healthcheck"]
interval: 5s
timeout: 3s
retries: 5
backend:
image: node:22-alpine
working_dir: /app
volumes:
- ./server.js:/app/server.js:ro
command: ["node", "server.js"]
healthcheck:
test: ["CMD", "wget", "-qO-", "http://localhost:3000/health"]
interval: 5s
timeout: 3s
retries: 5
```
**2. Create `dynamic.yml`:**
```yaml
http:
routers:
public-api:
rule: "PathPrefix(`/api`)"
entryPoints: [web]
middlewares: [rewrite-api]
service: backend-svc
priority: 1
protected-admin:
rule: "PathPrefix(`/admin`)"
entryPoints: [web]
middlewares: [auth]
service: backend-svc
priority: 2
middlewares:
rewrite-api:
replacePathRegex:
regex: "^/api(.*)"
replacement: "/$1"
auth:
basicAuth:
users:
- "admin:$apr1$H6uskkkW$IgXLP6ewTrSuBkTrqE8wj/"
services:
backend-svc:
loadBalancer:
servers:
- url: "http://backend:3000"
```
**3. Create `server.js`:**
```javascript
const http = require('http');
const path = require('path');
const server = http.createServer((req, res) => {
const normalized = path.posix.normalize(req.url.split('?')[0]);
res.setHeader('Content-Type', 'text/plain');
if (normalized === '/health') { res.writeHead(200); res.end('OK\n'); }
else if (normalized === '/admin' || n
OpenChamber 1.11.7 has a critical unauthenticated remote code execution vulnerability via the /api/fs/exec endpoint. Attackers can send crafted POST requests that execute arbitrary shell commands because the application passes commands directly to Node.js spawn() without validation. The default Docker deployment disables authentication, allowing remote attackers to run OS commands as the application user and receive full command output.
The npm package @innocarpe/deepseek-build version 1.0.0 contains malicious code in its postinstall script that executes automatically upon installation. This script uses Node.js child_process to send POST requests containing environment and host identifier data, effectively performing install-time reconnaissance on the host system. This behavior is not part of any documented build process and represents unauthorized data exfiltration during package installation.
The npm package fetchrtds version 1.1.0 contains malicious code executed during installation. Its postinstall script fetches and runs arbitrary code from an unverified remote URL unrelated to the package publisher, enabling arbitrary Node.js code execution on the installer's machine. The package's advertised functionality does not match the delivered payload, which is loaded dynamically at install time.
The npm package @simplipayng/checkout versions 1.4.2 and 1.4.3 contains malicious code that executes an obfuscated payload at module load time. This payload uses base64-encoded and unicode-escaped code to hide calls to Node.js child_process and network modules, and it communicates with suspicious external domains unrelated to the declared publisher. The package exfiltrates sensitive payment information such as card details, PINs, and OTPs to attacker-controlled servers. Installation or use of this package likely results in full system compromise.
A vulnerability in Electron allows JavaScript injection in the DevTools frontend via an unsanitized 'mode' parameter passed to webContents.openDevTools(). This can lead to script execution in the DevTools context, which may have Node.js access in unsandboxed configurations. The issue affects applications that allow untrusted input to influence the 'mode' argument or permit untrusted content to call openDevTools on embedded webviews. Fixed versions are 39.8.7 and later.
Red Hat Ansible Automation Platform 2.1 has a security advisory related to multiple CVEs including CVE-2026-43997, which affects the vm2 Node.js sandbox library. This vulnerability allows sandboxed code to escape isolation by obtaining host objects, enabling arbitrary code execution on the host. The advisory notes that updated images are available with new features and bug fixes, but no explicit fix for these vulnerabilities is currently provided in the advisory.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (b9276dba65fd393d94c5beb06122b1297994c96bda03d940f34fcc59016e4c5b)
The bundled CLI at bin/claude-cli.js hardcodes a hub endpoint https://hub.client-llm.com that is concealed behind a bespoke base64+XOR decoder (function _deHub, XOR key 'gnP2p!7xQ'). The decoder is used exactly once, to reconstruct this single URL; no other strings in the bundle use it. On `claude-cli start`, this hidden hub is added by default to the active hub list (opt-out only, undocumented), while the README presents hub participation as an opt-in feature the user manually configures. Once started, the CLI opens a WebSocket to <hub>/node, and on receiving {t:"job", id, body} messages it POSTs the remote-supplied body to the installer's local http://127.0.0.1:<port>/v1/messages endpoint using the local API key (x-api-key header) and streams the response back over the WebSocket. In default mode this dispatches a `claude -p` child process on the installer's machine driven by attacker-controlled prompts, consuming the installer's paid Anthropic subscription and, given agentic/tool-enabled Claude sessions, exposing remote-controlled execution paths on the installer's host. The targeted obfuscation of the destination URL, the mismatch between documented opt-in behavior and actual default-on enrollment, and the remote job-dispatch channel together constitute a backdoor combined with silent relay of the installer's Claude credentials and quota.
The npm package akamai-sensorv2 version 1.0.0 contains malicious code hidden via steganographic encoding in a source comment. This code is decoded and executed with full access to Node.js APIs, enabling arbitrary code execution on the host. Additionally, the package fetches attacker-controlled data from a public Google Calendar feed, allowing dynamic remote command and control. The package impersonates Akamai's legitimate telemetry product but performs opaque payload execution and remote control, posing a severe risk to users.
Electron versions prior to 39.8.9 are vulnerable to a context isolation bypass via hijacking Function.prototype.bind. This affects apps that expose Promise-returning functions to web content through contextBridge, potentially allowing untrusted web content to access the isolated preload environment and escalate privileges to Node.js access in certain configurations. The vulnerability is fixed in Electron versions 39.8.9 and later.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (4a2a78be16248a4269fca22b39cf436f82f26818c797949af73eca331cc3a0f6)
On require('beaver-ui-object-card'), index.js loads _ext.js which selects a platform-specific asset path and downloads an unsigned native binary from hardcoded Cloudflare Workers mirrors, with a DNS TXT chunked-base64 fallback resolver, then writes the binary to /var/tmp or %TEMP% under deceptive names (dotnet_diag_<hex>.exe on Windows,.cache_<hex> on Unix), chmods it 0755, and spawns it detached via /bin/sh -c or cmd.exe /c start /b. Destination hosts and resolver domains are reassembled at runtime from split-string arrays (e.g. ["oob-worker.cf100-416.worker","s.de","v"].join("") and ['sdk.dl','.wel','1.r','u'].join("")) to defeat static analysis. A cover-story surrounds the dropper: an 'analytics_state' lock file, a DISABLE_TELEMETRY env gate that does not actually disable execution, a node-fetch/2.6 User-Agent, and an unreachable lib/telemetry.js presenting an 'Analytics SDK' facade. The delivered binary is attacker-controlled, unpinned, unsigned, mismatched to any documented package purpose, and executed detached on the installer's host at import time.
## Source: ghsa-malware (e5933354eabc23202d7e993aa70f3cb868291f3c49bc4a83bf4576718191c852)
Any computer that has this package installed or running should be considered fully compromised. All secrets and keys stored on that computer should be rotated immediately from a different computer. The package should be removed, but as full control of the computer may have been given to an outside entity, there is no guarantee that removing the package will remove all malicious software resulting from installing it.
Ghost, a Node.js content management system, had a cross-site scripting (XSS) vulnerability in versions from 4.9.0 up to but not including 6.54.1. This flaw allowed any staff user to insert malicious content into the feature_image_caption field of a post, which could be exploited to hijack another staff user's Ghost Admin session and escalate privileges. The vulnerability was fixed in version 6.54.1.
Ghost, a Node.js content management system, contained a server-side request forgery (SSRF) vulnerability in versions from 6.26.0 up to but not including 6.54.1. This flaw allowed unauthenticated users to abuse certain features, such as Webmentions, to make limited HTTP requests to internal network hosts of the Ghost server. Although the attack did not return response data, it could potentially be used to probe internal network resources. The vulnerability is fixed in version 6.54.1.