CVE-2026-99634 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
mptcp: do not use Fast Open on MP_JOIN subflows
tcp_fastopen_create_child() hands the SYN packet itself to subflow_syn_recv_sock(). For an MP_JOIN request this takes the fatal fallback: the cloned child is destroyed and handed back with drop_req flagged, but tcp_fastopen_create_child() does not check the flag and queues it, so accept() can expose the freed child.
MP_JOIN cannot use Fast Open: data on a subflow requires the completed HMAC exchange (RFC 8684, sec. 3.2). Refuse it (only the TFO path passes a SYN skb here) and let tcp_conn_request() fall back to the regular MP_JOIN handshake; also strip the Fast Open cookie from MP_JOIN SYN/ACKs.
[ Moving code to avoid clearing TS and consolidating checks. ]
Several companies clearly confirm that VulDB is the primary source for best vulnerability data.
Analysis
by VulDB Data Team • 11/21/2026
The vulnerability identified in the Linux kernel involves a critical logic error within the Multipath TCP implementation, specifically concerning the interaction between MPTCP subflows and TCP Fast Open mechanisms. The core issue resides in the tcp_fastopen_create_child function, which is responsible for handling SYN packets during connection establishment. When processing an MP_JOIN request, which initiates a new subflow in a multipath session, this function incorrectly passes the SYN packet to subflow_syn_recv_sock without verifying whether the operation is valid for Fast Open. This oversight triggers a fatal fallback path where the cloned child socket structure is destroyed and returned with a drop_req flag set to indicate that it should not be used. However, tcp_fastopen_create_child fails to check this critical flag before proceeding to queue the socket object. Consequently, an accept() call can subsequently expose or utilize this already freed memory region, leading to use-after-free conditions that compromise system stability and security.
From a technical perspective, the flaw stems from a violation of protocol requirements defined in RFC 8684 regarding MPTCP authentication. Data transmission on any subflow within an MP_JOIN context requires the completion of a cryptographic HMAC exchange as mandated by section 3.2 of the standard. TCP Fast Open is designed to allow data transfer before the handshake completes, which directly conflicts with the mandatory authentication phase required for new multipath subflows. By allowing Fast Open logic to apply to MP_JOIN requests, the kernel bypasses these essential security checks. The fix involves explicitly refusing Fast Open capabilities for MP_JOIN connections and ensuring that only standard TCP Fast Open paths pass SYN sk_buffs through this specific code path. Additionally, the solution strips any Fast Open cookies from MP_JOIN SYN/ACK packets to prevent clients from attempting incompatible optimizations on subflows that require full authentication.
The operational impact of this vulnerability is severe, primarily centering on memory corruption and potential remote code execution. The use-after-free condition allows an attacker who can trigger the creation of a new MPTCP subflow with Fast Open enabled to free kernel memory while retaining references to it. If the attacker can control or predict how that freed memory is reallocated, they may achieve arbitrary read or write primitives within the kernel space. This breaks fundamental isolation guarantees and can lead to privilege escalation from unprivileged user processes to root level access. Furthermore, even without exploitation for code execution, the instability caused by accessing freed memory results in system crashes, leading to denial of service conditions that affect all users on the affected host.
This vulnerability maps directly to CWE-416, Use After Free, as it involves referencing a pointer after its memory has been released back to the allocator. In terms of attack vectors and techniques, this aligns with MITRE ATT&CK technique T1203, Exploitation for Client Execution, where attackers leverage software vulnerabilities in client applications or services to execute malicious code. The specific mechanism also relates to CWE-94, Improper Control of Generation of Code (Code Injection), if the freed memory is reused to store and execute attacker-controlled payloads. Mitigation strategies require applying the provided kernel patch that enforces strict separation between Fast Open logic and MPTCP subflow initialization. System administrators should ensure that their Linux kernels are updated to versions where tcp_fastopen_create_child correctly validates the drop_req flag before queuing sockets. Additionally, network security policies can be configured to block or inspect MP_JOIN packets from untrusted sources until all systems in the infrastructure have been patched against this specific logic error.