CVE-2026-99582 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

sctp: re-point retained control chunks on association migration

sctp_sock_migrate() transfers DATA chunk ownership but leaves retained control chunks pointing at the old socket. A later retransmission can therefore access the socket after it has been freed.

Extend the migration walk to cover retained control chunks and use sctp_control_set_owner_w() to assign their new owner. Reuse the DATA ownership check so each chunk is processed once per pass, even when it is reachable through multiple lists or retained pointers.

Preserve a control chunk's existing authentication key across migration so its final release can still generate SCTP_AUTH_FREE_KEY when needed.

If you want to get best quality of vulnerability data, you may have to visit VulDB.

Analysis

by VulDB Data Team • 11/20/2026

The Linux kernel contains a critical vulnerability within the Stream Control Transmission Protocol (SCTP) implementation that arises during association migrations, specifically involving the handling of retained control chunks. When an SCTP endpoint migrates to a new IP address or network interface, the sctp_sock_migrate function is invoked to transfer ownership of data chunks from the old socket structure to the newly created one. While this process correctly updates references for standard DATA chunks, it fails to update pointers for certain retained control chunks that remain associated with the original association context. This oversight leaves these specific control structures pointing at memory locations belonging to the old socket object rather than the new one.

This architectural flaw creates a dangerous use-after-free condition within the kernel space. Because the retained control chunks still reference the deprecated socket, any subsequent operation that attempts to retransmit or process these chunks will access invalid memory addresses once the original socket has been deallocated by the garbage collector. The consequence of this memory corruption is severe, potentially leading to a kernel panic due to an illegal memory access, or more insidiously allowing for arbitrary code execution if an attacker can control the data written into the freed memory region before it is reallocated for other purposes.

From a technical perspective, the root cause lies in incomplete traversal logic during the migration process. The existing implementation iterates through various chunk lists but neglects to include retained control chunks in this sweep. To resolve this issue, the fix extends the migration walk to explicitly cover these retained control structures. By applying sctp_control_set_owner_w to each relevant chunk, the patch ensures that all SCTP entities maintain valid references to their new socket owner after migration. Furthermore, the solution incorporates a deduplication mechanism by reusing existing DATA ownership checks, ensuring that each chunk is processed exactly once per pass even if it appears in multiple lists or retains pointers from different contexts, thereby preventing redundant operations and potential race conditions.

The mitigation strategy also addresses cryptographic integrity requirements inherent to SCTP authentication extensions. The patch preserves the association between control chunks and their respective authentication keys during migration. This ensures that when these objects are eventually released, the system can correctly trigger the sctp_auth_free_key routine to securely wipe sensitive key material from memory. Without this preservation step, there would be a risk of either leaking cryptographic secrets or failing to properly clear them, which could compromise future communications secured by those keys.

This vulnerability aligns with CWE-416, Use After Free, as it involves accessing memory after it has been freed due to improper pointer management during state transitions. In terms of the MITRE ATT&CK framework for enterprise security, this type of kernel-level exploitation falls under Privilege Escalation techniques, specifically those leveraging local exploits or vulnerabilities in system services such as T1068 Exploitation for Privilege Escalation via vulnerable drivers or kernels. Attackers could potentially leverage this flaw to gain root privileges on a compromised host by triggering the migration process and exploiting the resulting memory corruption.

System administrators and developers should prioritize applying kernel updates that include this SCTP fix, particularly in environments where dynamic IP address changes are common for SCTP-enabled services. Regular patching of the Linux kernel is essential to mitigate risks associated with complex protocol implementations like SCTP. Additionally, deploying intrusion detection systems capable of monitoring for unusual memory access patterns or kernel panics can provide early warning signs of exploitation attempts targeting this specific class of vulnerabilities in network stack components.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00202

KEV

no

Activities

very low

Sources

Do you know our Splunk app?

Download it now for free!