The npm package 'clxofwfjskaz7' version 1.0.0 contains malicious code embedded in an HTML file that renders a fake Cloudflare interstitial page and redirects browsers to a constructed URL using obfuscated JavaScript. This malicious behavior does not execute during npm install or require in Node.js environments, but targets browsers loading the package via npm-backed CDNs. Systems with this package installed may be fully compromised, and secrets or keys on those systems should be rotated immediately. Removal of the package alone may not fully remediate the compromise.
The npm package 'fghvbmniwu' versions 1.0.0 and 1.0.1 contains malicious code that serves a heavily obfuscated HTML page embedding a Cloudflare-branded Turnstile widget. This page redirects browsers to a constructed URL at runtime, indicating abuse of the npm registry as a free CDN for phishing or redirect landing pages. The malicious behavior only affects browsers loading the file via CDN mirrors and does not execute code during package installation or require/import in Node.js environments. Despite this, a security source warns that any system with this package installed or running should be considered fully compromised, recommending immediate secret/key rotation and package removal, though removal may not fully eliminate the threat. No official patch or fix is documented.
The npm package 'nihzvdeowx5' version 1.0.0 contains malicious code disguised as an HTML file that impersonates a Cloudflare Turnstile challenge page. It includes obfuscated JavaScript that redirects browsers to a phishing URL. The package does not execute this code during installation or when required in Node.js, indicating the attack targets browsers loading the package from a CDN rather than developers. Any system with this package installed should be considered fully compromised, and all secrets should be rotated immediately.
The npm package 'unitel4' version 1.0.0 contains malicious code in the form of an HTML file that impersonates a Cloudflare interstitial page. When served to an end-user browser, it executes obfuscated JavaScript that redirects the user to a suspicious '.club' domain, indicating registry abuse for phishing or cloaking purposes. The malicious payload does not execute in Node.js environments during installation or runtime, so it is not a direct supply-chain attack on developers. However, any system running this package should be considered fully compromised due to potential backdoors or additional malware. Immediate removal and secret/key rotation are recommended.
The npm package 'vkldhcmieru6' version 1.0.0 contains a malicious index.html file that impersonates a Cloudflare Turnstile challenge and redirects browser visitors to a potentially harmful URL. The package does not execute code during installation or when required in Node.js environments, so the threat targets users who visit the hosted HTML content rather than developers installing the package. There is no official patch or remediation information available.
The npm package 'bcnfjndwbkf2' version 1.0.0 contains malicious code that serves an obfuscated HTML redirect page mimicking a Cloudflare interstitial. This package does not execute code during installation or runtime in Node.js environments but redirects browser visitors who access the package via npm CDN mirrors to a potentially malicious URL. Although it does not represent a traditional supply-chain attack via npm install, the package abuses npm as a static host for browser-side redirection. One source claims that any system with this package installed or running should be considered fully compromised, recommending immediate secret rotation and package removal.
The npm package 'bvdfhdfvnk3' version 1.0.0 contains a malicious payload in the form of a static HTML file that redirects browsers to a potentially harmful external site after completing a Cloudflare Turnstile challenge. The package does not execute code during installation or require time, as Node.js cannot run an HTML file as the main entrypoint. However, if the HTML file is opened directly in a browser, it triggers a redirect to a cloaked campaign URL. Security sources warn that any system with this package installed should be considered fully compromised, recommending immediate secret and key rotation and package removal, though full remediation cannot be guaranteed due to potential deeper compromise.
The npm package csbcldfvivwfgd4 version 1.0.0 contains a malicious index.html file that mimics a Cloudflare challenge page and includes obfuscated JavaScript which redirects browser users to a potentially harmful URL. This malicious behavior only triggers when the HTML is rendered in a browser via an npm-backed CDN, not during installation or import in a Node.js environment. There is no code execution or credential theft on the installer's machine, but the package is abused as a phishing or malvertising redirect hosted on the npm registry.
The npm package 'yangming708' version 1.0.0 contains a tarball with only a package.json and an index.html file. The package.json specifies 'index.html' as the main entry, which is not a Node.js module, and no lifecycle scripts are declared. The index.html includes an obfuscated script that, when opened in a browser, redirects to a potentially malicious URL. Installing or requiring the package in a Node.js environment does not execute this code. However, if the HTML is opened in a browser, it can lead to a redirect to a malicious site. The package appears to be registry spam or a mispublished browser-side redirect page rather than a direct supply-chain attack. Despite this, one source claims that any system with this package installed or running should be considered compromised, recommending immediate secret rotation and package removal.
The npm package 'jkbnwsdf8' contains a single HTML file styled as a Cloudflare Turnstile challenge that executes obfuscated JavaScript to redirect browser users to a constructed URL. This redirect only triggers when the HTML is loaded via an npm CDN in a browser, not during package installation or require() in Node.js environments. The package abuses npm as a static-hosting CDN for redirect/cloaking purposes and does not execute code on the installer's machine. However, another source claims that any system with this package installed or running should be considered fully compromised, recommending immediate secret/key rotation and package removal. No official patch or remediation guidance is provided.
The biklirouter npm package versions 0.5.46 and 0.5.47 include a compiled Next.js application that routes AI/LLM provider CLI commands and manages OAuth flows. While the package uses Node.js built-ins such as child_process and network modules consistent with its declared functionality, a detailed review found no direct evidence of exfiltration of sensitive installer secrets or hardcoded command-and-control destinations. However, a malware advisory states that any system running this package should be considered fully compromised, recommending immediate secret rotation and package removal due to potential full system compromise.
A denial of service (DoS) vulnerability exists in the brace-expansion npm package used in Red Hat Hardened Images. The flaw allows a remote attacker to cause excessive memory consumption by providing specially crafted input to the expand() function, potentially crashing the Node.js process with an out-of-memory error. This vulnerability affects applications that pass untrusted input to brace-expansion directly or indirectly via minimatch or glob patterns. The issue is primarily a risk during build or development tooling, as brace-expansion is typically not exposed to untrusted network input at runtime in most Red Hat products. Red Hat has released updated RPM packages addressing this vulnerability.
Faker generates massive amounts of fake data in the browser and Node.js. Prior to 10.5.0, the faker.helpers.fake method in src/modules/helpers/eval.ts allows attacker-controlled fake templates to access the Function constructor through fakeEval.resolveProperty when a function returns another function, enabling arbitrary JavaScript code execution. This issue is fixed in version 10.5.0.
### Summary
`npx claude-code-templates --studio` launches "Claude Code Studio", an Express HTTP server (`cli-tool/src/sandbox-server.js`, default port 3444) that binds to **all interfaces** (`0.0.0.0`), sets `Access-Control-Allow-Origin: *`, and requires **no authentication**. Two POST endpoints pass attacker-controlled request-body fields into `child_process.spawn(..., { shell: true })`. Because `shell: true` makes Node join the argv array into a single `sh -c` string, the fields are parsed by the shell and metacharacters execute. Any unauthenticated attacker who can reach the port — a malicious web page the developer visits, or anyone on the same LAN — can execute arbitrary OS commands on the developer's machine.
### Details
In `cli-tool/src/sandbox-server.js`:
- `app.listen(PORT, ...)` is called with no host argument, so the server listens on `0.0.0.0` / `::` (reachable from the LAN, not just localhost).
- The CORS middleware sends `Access-Control-Allow-Origin: *` and answers the preflight `OPTIONS` for any origin, so a browser will deliver cross-origin POSTs to it.
- There is no authentication on any endpoint.
The vulnerable sinks:
1. `POST /api/execute` — the `prompt` body field flows into `executeLocalTask()`:
```js
const child = spawn('claude', [finalPrompt], { /* ... */ shell: true });
The only validation on prompt is a length check (>= 10 chars). With shell: true, finalPrompt is interpreted by the shell.
2. POST /api/install-agent — the agentName body field:
const child = spawn('npx', ['claude-code-templates@latest', '--agent', agentName, '--yes'], { /* ... */ shell: true });
2. agentName is used unvalidated. (The same unsafe pattern is also reachable through /api/execute's agent field via checkAndInstallAgent().)
Root cause: spawn(cmd, argsArray, { shell: true }) does not keep argsArray as separate argv entries — Node builds cmd + ' ' + argsArray.join(' ') and runs it via sh -c, so every element is subject to shell parsing.
PoC
# Victim
npx claude-code-templates --studio # server on 0.0.0.0:3444
# Attacker (another LAN host, or a malicious web page fetch(), or locally)
curl -s -X POST http://127.0.0.1:3444/api/execute \
-H 'Content-Type: application/json' \
--data '{"prompt":"aaaaaaaaaa; touch /tmp/CCT_RCE_PROOF","mode":"local"}'
curl -s -X POST http://127.0.0.1:3444/api/install-agent \
-H 'Content-Type: application/json' \
--data '{"agentName":"x; touch /tmp/CCT_AGENT_PROOF #"}'
ls -la /tmp/CCT_RCE_PROOF /tmp/CCT_AGENT_PROOF # both created => injected commands ran
The aaaaaaaaaa padding satisfies the 10-char minimum, then ; (or $(...), or backticks) starts the injected command. claude/npx do not even need to be installed — the injected segment runs regardless.
Confirmed at runtime on v1.28.13 (Node 22, Linux): both marker files were created, the server listened on *:3444, and an OPTIONS preflight from Origin: https://evil.example returned 200 with Access-Control-Allow-Origin: *.
Impact
Unauthenticated remote code execution (CWE-78) on any machine running --studio. Two reachability paths:
- Drive-by: a developer running --studio who visits an attacker-controlled web page — the page's cross-origin fetch() (Content-Type application/json) passes the wildcard CORS preflight and delivers the POST, achieving RCE with no other interaction.
- LAN: because the server binds 0.0.0.0, anyone on the same network (office, co-working space, public Wi-Fi) can hit port 3444 directly.
Impact is full compromise of the developer's user account (arbitrary command execution with the developer's privileges): source code, SSH keys, cloud credentials, and .env secrets.
Suggested fix
- Remove shell: true from all three spawns so arguments stay discrete argv entries (kills the injection).
- Validate agentName against a strict allowlist (^[A-Za-z0-9._/-]+$).
- Bind to loopback only (app.listen(PORT, '127.0.0.1', ...)).
- Replace the wildcard CORS with a same-origin allowlist and reject other origins.
The npm package whs4_ued version 1.0.0 contains malicious code that executes during installation. Its postinstall script runs a Node.js script that sends sensitive host information, including the absolute path of the package file (revealing OS username and home directory structure), Node.js version, platform, and architecture, to an attacker-controlled Discord webhook without user consent.
The npm package zeal-rq-hooks version 0.0.0 contains embedded malicious code in canary.js that collects host-identifying information such as hostname, username, platform, Node/npm version, and current working directory. This data is sent via a POST request to a hardcoded external endpoint not affiliated with the npm registry or the package publisher. This behavior constitutes a privacy and security risk due to unauthorized data exfiltration.
@openzeppelin-5/contracts is a malicious npm package published by npm account `mssjeep843` that impersonates OpenZeppelin's `@openzeppelin/contracts` (the v5 line) via the look-alike scope `@openzeppelin-5`, falsely describing itself as a "compatibility distribution". It ships no Solidity contracts — only an install-time payload (index.js) run via preinstall/postinstall that harvests credential-shaped environment variables and reads and exfiltrates SSH private keys, cloud credentials (AWS/GCP/Kubernetes/Docker), Solana/Anchor/NEAR/Sui wallet keys, Foundry keystores, `.git-credentials` and local `.env` files to `https://webhook.site/326b0891-2093-4800-a4c1-686ce3e07b09`. It is one of a series of DeFi/crypto impersonation packages from the same account sharing this webhook.site endpoint, which also squat Aerodrome Finance, Camelot AMM, Euler EVC, BoringVault and Uniswap Permit2.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (800da818da3fee0353766227eafcd43c0c7cf7fd0126af5ded48b7c1ba522e21)
Package name typosquats @openzeppelin/contracts. package.json declares both preinstall and postinstall as `node index.js || true`, so the payload auto-executes on `npm install`. index.js harvests process.env entries matching KEY|TOKEN|SECRET|MNEMONIC|WALLET|AWS|GITHUB|NPM and reads installer-side credential files including ~/.aws/credentials, ~/.ssh/id_rsa, ~/.ssh/id_ed25519, ~/.kube/config, ~/.docker/config.json, ~/.netrc, ~/.npmrc, ~/.git-credentials, gcloud/solana/sui/foundry keystores, and local.env files. The bundle is POSTed to a hardcoded webhook.site endpoint (path 326b0891-2093-4800-a4c1-686ce3e07b09) via a detached child process spawned with a randomized 60–240 second delay to outlive install-time scanning windows. A hostname regex (/^(scan-|detonation|sandbox|ubuntu-fc-uvm)/i) throws early on known sandbox/scanner hosts as anti-analysis gating.
The node-internal-svg-loader npm package versions 1.0.0 and 1.0.1 contain malicious code that fetches JavaScript from an untrusted external domain and executes it via eval in the Node.js environment. This allows arbitrary code execution with full access to the host system. Any system with this package installed should be considered fully compromised, and all secrets on the system should be rotated immediately. Removal of the package alone may not eliminate the compromise.
n8n's JavaScript task runner shared a single module cache across all users' Code-node executions. In affected versions (before 1.123.67, 2.31.5, and 2.32.1), a user able to run a Code node could poison a cached module and thereby alter other users' Code-node executions on the same runner, affecting their confidentiality, integrity, or availability. This is a cross-user isolation break within a single n8n instance and does not constitute a sandbox escape or remote code execution. Only multi-user instances running the JS task runner with built-in or external modules enabled are affected.
n8n before 1.123.67, 2.31.5, and 2.32.1 validates credential-access only for a node's top-level credentials and not for credentials referenced inside an Execute Sub-workflow node's inline workflow JSON. A member with Editor access to a shared workflow (when workflow sharing is enabled) who knows a target credential's ID can reference that credential in the inline JSON; it passes save-time and runtime validation and resolves in the parent workflow's project context, allowing the attacker to use or exfiltrate credentials they are not permitted to access.