Microsoft Threat Intelligence identified an active supply chain attack involving malicious npm packages that employ dependency confusion techniques. Between May 28-29, 2026, a threat actor using three maintainer aliases published malicious packages across nine organizational scopes that mirror real corporate namespaces. The packages execute obfuscated reconnaissance payloads through npm lifecycle hooks, collecting system information, environment variables, and developer credentials. All packages connect to the same command-and-control server and deploy a 17KB JavaScript dropper designed for environment fingerprinting. The campaign includes platform-specific payloads for Windows, macOS, and Linux, with CI/CD detection bypass capabilities. The architecture operates in reconnaissance-only mode but supports server-side toggling for full exploitation. Forensic analysis indicates all three accounts are operated by a single individual, evidenced by shared C2 infrastructure, identical hardcoded authentication toke...
> [!NOTE]
> Practical impact depends on whether request body-size limits are enforced upstream (proxy/web-server/framework). Deployments with typical body-size caps (≤2 MB) bound the amplifier significantly; deployments accepting larger token inputs are more exposed.
When verifying detached JWS tokens using the unencoded-payload option (`"b64": false`, RFC 7797), PyJWT performs **Base64URL decoding of the compact-serialization payload segment** *before* enforcing the detached-payload rules.
For `b64=false`, PyJWT later **discards** that decoded payload and replaces it with the caller-provided `detached_payload`. In practice, this turns the middle segment into an attacker-controlled “work amplifier”: a remote client can supply an arbitrarily large Base64URL payload segment that forces **CPU work + memory allocations** even if the signature is invalid.
This creates an **unauthenticated DoS** vector against any endpoint that verifies detached JWS using PyJWT.
---
## Affected Component(s)
* `jwt/api_jws.py`
* `PyJWS.decode()` / `PyJWS.decode_complete()`
* `_load()` (parsing and Base64URL decoding)
---
## Root Cause (exact logic flaw)
### What happens in the code
In `jwt/api_jws.py`, `decode_complete()` does the following (order matters):
* Calls `_load(jwt)` first, which decodes the token segments
* Only after that, checks `header.get("b64")` and if `False`, it replaces `payload = detached_payload` and rebuilds the signing input
This behavior is visible in `decode_complete()`:
* `_load(jwt)` happens **before** the `b64=false` handling
* then `payload = detached_payload` and `signing_input = ... detached_payload` happens afterward ([GitHub][1])
Inside `_load()`, PyJWT unconditionally performs:
* `payload = base64url_decode(payload_segment)`
This is the expensive step the attacker can amplify ([GitHub][1])
### Why this becomes a vulnerability
For `b64=false` detached JWS, the payload segment in compact form is effectively **not needed** for verification in PyJWT’s own logic (since the library uses `detached_payload` as the real payload). Yet PyJWT still decodes it first, meaning:
* cost is paid **even when signature is invalid**
* the decoded bytes are **discarded**
* attacker controls the size of this cost via token length
---
## Impact (evidence-driven)
### Security impact
* **Unauthenticated remote DoS**: decoding work happens before signature rejection → attacker does not need signing key.
* **CPU amplification**: Base64URL decode time scales linearly with payload segment size.
* **Memory amplification**: decoded output allocates large byte buffers (tens of MB per request).
* **Operational impact**: request queueing / worker starvation under modest concurrency bursts.
### Standards context (RFC 7797)
RFC 7797 explicitly notes this option is used when payload is large and/or detached, and discusses interoperability requirements around marking it critical (“crit” with “b64”). ([IETF Datatracker][2])
(PyJWT supports `crit` validation, but the issue here is decode order / unbounded decode of an unused segment.)
---
## Affected Versions
* **Confirmed affected:** PyJWT **2.12.1** (tested from your local editable install and repo).
* **Likely affected:** all versions that include detached payload support for JWS decoding, which was introduced in **2.4.0** (“Add detached payload support for JWS encoding and decoding”). ([pyjwt.readthedocs.io][3])
(For GHSA, this phrasing is strong: “confirmed” + “likely since feature introduction”.)
---
# Threat Model
### Typical real deployment
A service verifies signed HTTP requests or webhooks using detached JWS:
* token is provided in JSON body / query / header
* actual payload is the HTTP request body passed as `detached_payload`
### Attacker
* remote unauthenticated client
* can send requests to verify endpoint
* does **not** need a valid signature (invalid signature still triggers the expensive decode path)
### Attack chain
1. Attacker crafts a JWS compact token with header containing `"b64": false` and `crit:["b64"]`.
2. Attacker inflates the **payload segment** (middle segment) to millions of Base64URL characters.
3. Server calls `PyJWS.decode(...detached_payload=...)`.
4. PyJWT decodes the inflated segment (CPU + memory).
5. Signature is rejected afterward (401) — but resources already consumed.
6. Repeated requests or bursts cause queueing/worker starvation → DoS.
---
# Proof of Concept - file names + results
## PoC placement
* [server_localhost.py](https://github.com/user-attachments/files/26132755/server_localhost.py)
* [client_localhost.py](https://github.com/user-attachments/files/26132757/client_localhost.py)
* [flood_localhost.py](https://github.com/user-attachments/files/26132760/flood_localhost.py)
---
## PoC # 1 - Localhost verification server
**File:** [server_localhost.py](https://github.com/user-attachments/files/26132755/server_localhost.py)
**Purpose:** real HTTP endpoint (`POST /verify`) that calls PyJ
Microsoft UFO open-source framework for intelligent automation across devices and platforms. In 3.0.1-4-ge2626659, Microsoft UFO accepts client-supplied session_id values in WebSocket task messages and reuses an existing in-memory session object if that session_id already exists. If a prior session has completed and remains in memory with populated results, a different authenticated client can send a new TASK message using the same session_id. The server re-enters the existing session object and sends the stale stored result to the new requester through the normal send_task_end() callback path. This is an authenticated cross-client stale result replay issue. The issue requires that the attacker knows or can predict a live or recently completed session_id.
A vulnerability in golang.org/x/crypto/ssh version 3.0 can cause a server deadlock when the client sends unexpected responses. This issue may impact server availability by causing it to become unresponsive.
Microsoft has confirmed a new known issue affecting Windows Server 2016 systems that causes domain controller lookups to fail after installing the KB5087537 May 2026 security update. [...]
A multi-stage attack on Linux devices began with an exposed F5 BIG-IP edge appliance and pivoted to an internal Confluence server for credential theft and identity compromise. Learn how the threat actor attempted Kerberos relay and lateral movement, and how Microsoft Defender detected, blocked, and unraveled the attack. The post From edge appliance to enterprise compromise: Multi-stage Linux intrusion via F5 and Confluence appeared first on Microsoft Security Blog .
Corteza contains a SQL injection vulnerability in its Microsoft SQL Server (MSSQL) backend when filtering Compose records by the meta field.This issue affects corteza: 2024.9.8.
Operation HookedWing is a prolonged phishing campaign active for over four years, targeting more than 500 organizations across multiple critical sectors including aviation, energy, logistics, and public administration. The campaign uses phishing emails impersonating trusted sources and leverages GitHub and compromised servers to host phishing infrastructure. Victims are lured to fake Microsoft Outlook login pages that personalize content to increase credibility and steal credentials along with geolocation data. The threat actor focuses on high-value targets with access to sensitive information and high-privilege credentials. The campaign has evolved over time, expanding its infrastructure, languages, and phishing themes to maintain effectiveness.
A sophisticated multi-stage intrusion campaign was identified leveraging a weaponized PowerShell payload disguised as a JPEG image file (sysupdate.jpeg) to deploy a trojanized ConnectWise ScreenConnect instance for covert remote access. The attack likely originates through social engineering techniques including phishing emails or malicious attachments. Upon execution, the malware establishes a staging environment, retrieves additional payloads from attacker-controlled infrastructure, and dynamically compiles a custom launcher using Microsoft's legitimate .NET compiler (csc.exe) to evade detection. The intrusion abuses ComputerDefaults.exe and a malicious ms-settings registry hijack to perform a fileless UAC bypass and obtain elevated privileges. Once elevated, the malware deploys a persistent service masquerading as OneDriveServers and launches a modified ScreenConnect framework capable of credential interception, remote command execution, surveillance operations, SYSTEM-level execution, encrypted command...
A use-after-free vulnerability exists in the redis-server component related to the unblock client flow. This flaw may allow remote code execution. The affected version is 3.0. A patch is available to address this issue.
A use-after-free vulnerability exists in the Lua scripting component of redis-server, potentially allowing remote code execution. This vulnerability affects multiple versions of the redis-server software. Fixed versions have been released to address this issue.
CVE-2026-25243 is a vulnerability in redis-server's RESTORE command that may lead to invalid memory access and potentially allow remote code execution. The affected versions are 3.0 and 4.0. No CVSS score or detailed impact information is provided. No known exploits in the wild or patch information is available.
CVE-2026-43870 refers to multiple vulnerabilities in Apache Thrift's Node.js web_server.js component. The advisory lacks detailed technical information and CVSS scoring. The affected versions are specifically 2.0 and 3.0. No patch or remediation guidance is provided, and there are no known exploits in the wild.
A vulnerability identified as CVE-2026-31711 involves a resource leak in the SMB server component related to active connection count management during transport allocation failures. This issue affects Microsoft product version 3.0. No CVSS score or detailed impact information is provided.
Xu Zewei, a Chinese national and alleged member of the state-sponsored APT group Silk Typhoon, was extradited from Italy to the US. He is accused of conducting cyberattacks on behalf of China's Ministry of State Security and Shanghai State Security Bureau, targeting US universities and researchers, particularly those involved in COVID-19 research. The attacks included exploiting Microsoft Exchange Server zero-day vulnerabilities to deploy web shells and exfiltrate sensitive information. Xu faces multiple charges including wire fraud, computer hacking, and identity theft. The FBI conducted operations to remove web shells from affected US systems. Another suspect remains at large.
PhantomRPC is a local privilege escalation vulnerability in Windows RPC that allows an attacker to impersonate privileged services by deploying a fake RPC server. This architectural weakness enables escalation to System privileges by intercepting RPC requests intended for legitimate services. The issue affects multiple Windows versions and exploits legitimate Windows impersonation mechanisms. Kaspersky reported the vulnerability, and Microsoft has classified it as moderate severity, stating it does not require immediate remediation. No official patch is currently available. Exploitation requires compromising a privileged service and setting up a fake RPC server to intercept and impersonate RPC calls. Several attack paths have been identified involving services running under Network Service and Local Service accounts. The vulnerability increases the attack surface for local privilege escalation but requires specific conditions to exploit.
A new variant of the LOTUSLITE backdoor, version 1.1, has been identified targeting India's banking sector and South Korean diplomatic circles. The backdoor is delivered via DLL sideloading using legitimate Microsoft-signed executables and initially through CHM files containing malicious JavaScript. It communicates with dynamic DNS-based command-and-control servers over HTTPS, supporting remote shell access, file operations and session management. Code-level analysis reveals direct lineage to LOTUSLITE v1.0, including identical command structures, shared persistence mechanisms, and residual exports from the original codebase. The campaign demonstrates incremental improvements including updated magic values, API resolution techniques, and delivery mechanisms evolving from CHM-based to JavaScript loaders to DLL sideloading. Infrastructure hosted under Dynu Systems shows continuity with previous operations.
IOCs related to FlowerStorm phishing‑kit–driven campaign that delivers fake Microsoft authentication pages via compromised domains fronted by Cloudflare. The activity abuses legitimate cloud and CDN services for delivery while credential harvesting occurs on attacker‑controlled infrastructure, with incidental contact to Microsoft services during normal browser behavior.that uses its own web servers to target victims' login credentials and access to their personal details and login details on its servers.
Improper neutralization of special elements used in an sql command ('sql injection') in SQL Server allows an authorized attacker to elevate privileges locally.