A critical use-after-free vulnerability exists in the Linux kernel's NFS server (nfsd) related to the initialization of the copy-notify stateid before it is published. This flaw allows a race condition where a crafted OFFLOAD_CANCEL request can free a state entry prematurely, leading to use-after-free conditions. The vulnerability affects multiple Linux kernel versions and has a CVSS score of 9.8, indicating high severity.
CVE-2026-89663 is a use-after-free vulnerability in the Linux kernel's NFS server (nfsd) related to improper handling of copy-notify stateids during revoke operations. The flaw occurs because stateids are unlinked only when their reference count reaches zero, but certain revoke paths drop references without unlinking, leaving entries accessible after being freed. This can lead to memory corruption detected by Kernel Address Sanitizer (KASAN).
A use-after-free vulnerability exists in the Linux kernel's NFSD component related to the unlock_filesystem interface. This flaw occurs when a local administrator stops the NFS server and then writes to /proc/fs/nfsd/unlock_filesystem, causing the system to access freed memory. The issue arises because the cancellation of async COPY operations happens before proper locking and verification that the server is running. This vulnerability has been resolved by moving the async COPY cancel operation into a protected section that ensures the server is running before accessing state tables.
CVE-2026-89649 is a critical vulnerability in the Linux kernel's Ceph filesystem implementation. It involves improper bounds checking of the last extended attribute (xattr) value length in the __build_xattrs() function. A malicious or compromised Ceph metadata server can specify an oversized value length for the final attribute, causing the kernel to copy data beyond the allocated buffer into user space. This results in disclosure of adjacent kernel heap memory to a local user via the getxattr(2) system call.
A vulnerability in the Linux kernel's Ceph client was resolved involving improper bounds checking during decoding of MDSCapAuth path and fs_name fields in the handle_session() function. This flaw allows a malicious or compromised Metadata Server (MDS) to cause an out-of-bounds read of up to 4 GiB during session setup, potentially crashing the client kernel. The issue arises because certain fields are copied without proper length checks, unlike other fields that use safe decode variants. The fix involves switching to safe decode functions that enforce bounds checks before copying.
A vulnerability in the Linux kernel's NFS server (nfsd) component allowed any authenticated NFSv4.2 client to cancel and free another client's copy-notify stateid due to insufficient ownership checks. The issue was caused by the management function freeing state without verifying client ownership, exploiting the guessable cyclic allocation of the lookup key. This could lead to improper state cancellation by unauthorized clients.
A vulnerability in the Linux kernel's NFS server (nfsd) affects the handling of writeback error cursors during asynchronous copy operations. The flaw can cause silent data loss by incorrectly marking copied data as durable even when writeback errors occur. This issue arises due to a race condition in error cursor sampling and writeback error detection. The vulnerability has a CVSS score of 7.5 and impacts specific Linux kernel versions used in various Ubuntu releases.
A vulnerability in the Linux kernel's NFS server (nfsd) was fixed involving improper handling of write verifiers during asynchronous COPY writeback failures. When the async COPY writeback fails, the server did not rotate the write verifier, causing clients to mistakenly believe that data was durably written when it was not, violating the NFS protocol's durability guarantees.
CVE-2026-89702 is a critical vulnerability in the Linux kernel's NFS daemon (nfsd) tracepoints related to server sockaddr slot sizing. The flaw arises because the nfsd_fh_verify and nfsd_fh_verify_err tracepoints declare the server sockaddr slot sized by xpt_remotelen but copy data from xpt_local using xpt_locallen. When xpt_locallen exceeds xpt_remotelen, a buffer overflow occurs, writing past the reserved ring-buffer slot. Conversely, if xpt_locallen is smaller, leftover data from previous contents may leak. This issue is reachable on NFS over UDP, where xpt_remotelen remains zero, causing out-of-bounds writes. The vulnerability has been fixed by adjusting the slot size to match xpt_locallen. The CVSS score is 9.8, indicating critical severity.
CVE-2026-89680 is a high-severity vulnerability in the Linux kernel affecting version 5.6. It involves a resource leak of nfsd_file objects during inter-server COPY setup failures in the NFS daemon (nfsd). The flaw occurs because the error handling path bypasses the cleanup code that releases certain kernel references, leading to resource exhaustion. This issue has been fixed in specific Linux kernel commits.
CVE-2026-89676 is a critical vulnerability in the Linux kernel's NFS server (nfsd) related to stale state ID entries in the async COPY operation. The flaw involves improper handling of state IDs in the s2s_cp_stateids IDR, leading to potential use-after-free conditions when IDR walkers dereference memory that has been reused by subsequent requests. This can cause kernel memory corruption and potentially allow for denial of service or privilege escalation. The issue affects Linux kernel version 4.20 and has been fixed in several subsequent commits.
CVE-2026-89652 is a critical buffer overflow vulnerability in the Linux kernel's Ceph filesystem NFS export code. It occurs due to an unchecked copy of a directory entry name length, which can lead to out-of-bounds writes when a malicious or compromised Ceph Metadata Server returns an excessively long name. This affects the ceph_get_name() and __get_snap_name() functions and is exploitable when a CephFS mount is re-exported over NFS. A fix has been implemented to bound the copied name length and prevent overflow.
CVE-2026-71416 is a high-severity improper authentication vulnerability in the Headroom WebSocket server. The server does not validate the Origin header of incoming WebSocket requests, allowing any client with network access to the proxy to connect without authentication. If the OpenAI API key is stored in the OPENAI_API_KEY environment variable, malicious clients can perform arbitrary LLM requests through the proxy. This enables unauthorized use of OpenAI API capabilities, including executing arbitrary instructions and tools. The vulnerability affects Headroom versions prior to 0.35.0 and has a CVSS score of 8.8.
Tourmaline is a sophisticated multi-stage Windows malware distributed via a fake Cloudflare CAPTCHA popup that tricks users into manually executing a malicious installer. The malware uses a custom Inno Setup installer bundling a full Python 3.11 runtime and employs an anti-sandbox time-lock mechanism to evade analysis. It establishes persistence under the name "TourmalineUpdate" disguised as a hardware monitoring service. The backdoor communicates with its command-and-control (C2) server via a custom DNS-over-UDP tunnel to a dynamically resolved IP address obtained from an Ethereum Sepolia testnet smart contract, making IP blocklisting ineffective. Commands from the C2 are ECDSA-signed and executed via Python's exec() function, allowing arbitrary remote code execution. Indicators of compromise and deobfuscated source code are publicly available for defensive research.
An insecure default configuration in the embedded Happytime RTSP server within the Sofia IPC daemon in Xiongmai IP Camera XM530 firmware HMT.CM2005-v220608.1837 and earlier ships with authentication disabled, allowing remote unauthenticated attackers to access live H.264 video and G.711 audio feeds in cleartext over unencrypted RTP/UDP.
A Server-Side Request Forgery (SSRF) vulnerability exists in nltk/nltk versions 3.9.4 and the current develop branch. The `nltk.pathsec.validate_network_url()` function, intended to prevent SSRF by rejecting internal network addresses, fails to reject IPs in the RFC 6598 shared address space (`100.64.0.0/10`). This occurs because Python's `ipaddress` module does not classify such addresses as `is_private` or `is_global`, and the current guard only checks `is_private` and a few explicit categories. An attacker who can influence a URL passed to NLTK's network-loading helpers can exploit this vulnerability to make a strict-mode application send requests to shared-address-space hosts, potentially exposing non-public infrastructure reachable from the application host. The impact is limited to SSRF-style confidentiality exposure, with no code execution claimed.