CVE-2026-99603 in Linuxinfo

Summary

by MITRE • 11/20/2026

In the Linux kernel, the following vulnerability has been resolved:

mptcp: pm: kernel: use RCU to free endpoint listeners

mptcp_pm_nl_create_listen_socket() starts the TCP listener directly instead of going through mptcp_listen(). It consequently misses setting SOCK_RCU_FREE on the parent MPTCP socket.

tcp_child_process() can invoke the listener's subflow_data_ready() callback without holding the MPTCP parent lock or a reference to the parent. An authenticated MP_JOIN racing with endpoint teardown can therefore access the parent after its last reference has been dropped. The ADD_ADDR error path can also close an already published listener.

Set SOCK_RCU_FREE before __inet_listen_sk() publishes the TCP listener, matching mptcp_listen(). This protects the parent on every subsequent close path, including a failed endpoint addition.

Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified in the Linux kernel involves a race condition within the Multipath TCP (MPTCP) protocol implementation, specifically concerning the lifecycle management of socket endpoints and their associated listeners. MPTCP extends standard TCP to allow multiple paths for data transmission, enhancing reliability and throughput by aggregating network connections. The core issue arises during the creation of listen sockets for new MPTCP subflows. In certain code paths, particularly within mptcp_pm_nl_create_listen_socket(), the kernel initiates a TCP listener directly rather than utilizing the standard mptcp_listen() function. This deviation from the established protocol handling mechanism results in the failure to set the SOCK_RCU_FREE flag on the parent MPTCP socket. The absence of this flag is critical because it dictates how memory associated with the socket structure is managed upon closure, particularly regarding Read-Copy-Update (RCU) synchronization mechanisms that are essential for safe concurrent access in high-performance kernel environments.

The technical flaw manifests when tcp_child_process() invokes the listener's subflow_data_ready callback without holding the MPTCP parent lock or maintaining a reference count to the parent socket. Under normal circumstances, proper locking and reference counting would prevent premature deallocation of resources while they are still being accessed by concurrent threads. However, due to the missing SOCK_RCU_FREE flag, an authenticated MP_JOIN race condition can occur during endpoint teardown. In this scenario, an attacker or a maliciously timed network event can trigger access to the parent socket structure after its last reference has been dropped and potentially freed. This constitutes a use-after-free vulnerability, where memory that is no longer valid is accessed by active kernel processes. Additionally, the error path associated with ADD_ADDR operations can inadvertently close an already published listener, further destabilizing the connection state and exacerbating the risk of accessing invalid memory addresses or corrupted data structures.

The operational impact of this vulnerability is significant for systems relying on MPTCP connections. A successful exploitation could lead to kernel panics, resulting in system crashes and denial of service conditions. More critically, if an attacker can control the contents of the freed memory through other means, they might achieve arbitrary code execution with root privileges by overwriting function pointers or critical data structures within the socket context. The vulnerability affects the integrity and availability of network services that depend on multipath capabilities, particularly in environments where dynamic endpoint addition and removal are common features. Security researchers classify this type of flaw under CWE-416, Use After Free, which describes situations where a program continues to use a pointer after it has been freed, leading to undefined behavior. Furthermore, the exploitation technique aligns with ATT&CK techniques related to privilege escalation via kernel vulnerabilities, as gaining control over kernel memory often provides the necessary foothold for escalating privileges from unprivileged user space to the highest level of system access.

Mitigation strategies primarily involve applying vendor-provided patches that correct the socket initialization sequence in the MPTCP implementation. The fix ensures that SOCK_RCU_FREE is set before __inet_listen_sk() publishes the TCP listener, thereby aligning the behavior with mptcp_listen(). This adjustment guarantees that the parent socket remains protected on every subsequent close path, including scenarios involving failed endpoint additions or race conditions during teardown. System administrators should prioritize updating their kernel versions to include these security fixes. Additionally, organizations employing MPTCP in production environments should monitor for unusual network patterns indicative of MP_JOIN races and ensure that firewall rules restrict unauthorized access to internal endpoints where possible. Continuous monitoring and adherence to secure coding practices within the kernel development community are essential to prevent similar synchronization errors in future releases.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Do you need the next level of professionalism?

Upgrade your account now!