CVE-2026-99767 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
xfrm4: use a full socket for local errors
xfrm4_local_error() passes skb->sk to inet_sk() and ip_local_error() without ensuring it points to a full socket. TCP SYN-ACK skbs can be owned by TCP_NEW_SYN_RECV request sockets.
xfrm4_tunnel_check_size() already checks sk_fullsock() since commit 1620c88887b1 ("xfrm: Fix the usage of skb->sk"), so iptfs_is_too_big() is the only remaining IPv4 caller passing a request socket here: the sk it tests is the listener, while skb->sk is the request socket.
When IP-TFS rejects such an skb because it exceeds its payload MTU, the local error path treats the request socket as a struct inet_sock. KASAN reports a slab-out-of-bounds read in ip_local_error() beyond the request_sock_TCP allocation.
Resolve the skb owner with skb_to_full_sk() before accessing inet_sock state or reporting the error. This maps a request socket to its listener and rejects sockets that cannot be used as full sockets, matching what commit 6973a21ee73c ("ipv6: xfrm: use full sockets in local error paths") did for xfrm6_local_error().
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel vulnerability identified involves a critical type confusion and out-of-bounds memory access within the IPv4 XFRM subsystem, specifically affecting the handling of local network errors. The core issue resides in the function xfrm4_local_error(), which is responsible for processing error conditions such as packet-too-big messages generated by IP-TFS when an skb exceeds its payload Maximum Transmission Unit. In this specific code path, the kernel retrieves a socket pointer from the sk_buff structure via skb->sk and immediately passes it to inet_sk() without verifying that the underlying object is a full socket instance. This oversight becomes problematic because TCP SYN-ACK packets are frequently owned by TCP_NEW_SYN_RECV request sockets rather than established connection sockets. When such an skb triggers an error condition, the kernel attempts to interpret the memory layout of a lightweight request_sock_TCP structure as if it were a fully initialized struct inet_sock.
This type confusion leads directly to a slab-out-of-bounds read vulnerability, which can be detected by Kernel Address Sanitizer (KASAN). Because the size and field offsets of a request socket differ significantly from those of a full socket, accessing fields intended for an inet_sock results in reading memory beyond the allocated bounds of the request sock structure. This constitutes a classic CWE-125 Out-of-bounds Read vulnerability. The security implications are severe as improper memory access within kernel space can potentially lead to information disclosure by leaking sensitive kernel data or cause a denial of service through a kernel panic if the invalid read triggers a fault in subsequent processing steps. While previous commits such as 1620c88887b1 addressed similar issues for xfrm4_tunnel_check_size() and commit 6973a21ee73c fixed the corresponding IPv6 path, this specific IPv4 error handling path remained unpatched until now.
From an operational perspective, exploiting this vulnerability would likely require an attacker to craft or manipulate network traffic that triggers a TCP SYN-ACK packet with an oversized payload under IP-TFS constraints. The attack vector aligns with CWE-20 Improper Input Validation and potentially maps to MITRE ATT&CK techniques involving remote code execution or denial of service via kernel exploitation. The vulnerability highlights the complexity of managing different socket states in high-performance networking stacks where request sockets are used for efficiency during connection establishment but must be carefully distinguished from full sockets when performing operations that assume complete initialization data structures.
The resolution involves modifying xfrm4_local_error() to utilize skb_to_full_sk() before accessing any inet_sock state or reporting the error. This helper function safely maps a request socket back to its associated listener socket, ensuring that subsequent operations are performed on valid memory with known layouts. It also explicitly rejects sockets that cannot be converted into full sockets, thereby preventing invalid type casts and out-of-bounds accesses. To mitigate this risk in environments where patching is not immediately feasible, administrators should ensure strict network segmentation and monitor for anomalous TCP traffic patterns involving SYN-ACK packets with unusual payload sizes. Furthermore, enabling KASAN in development or staging kernels can help detect similar latent issues before they reach production systems. Regular kernel updates are essential to maintain the integrity of these low-level networking abstractions against type confusion attacks.