Raw vector
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:HCVSS and EPSS are reproduced from their sources (NVD, FIRST EPSS). Risk Priority is our own derived reading, not an NVD score.
Summary
CVE-2026-31669 is a critical-severity Use After Free (CWE-416) vulnerability in Linux Linux Kernel. Its CVSS base score is 9.8 (Critical).
Operationally, exploitation aligns with the MITRE ATT&CK technique Exploitation for Client Execution (T1203); ranked in the top 43% of CVEs by exploit likelihood; it is not currently listed in the CISA KEV catalog.
The strongest mitigations our analysis identified map to SA-11 (Developer Testing and Evaluation) and SA-8 (Security and Privacy Engineering Principles) — see the control section below for these in your framework.
Deeper analysis AI-assisted summary
Synthesised by an AI model from the NVD description and linked references — a reading aid, not an authoritative source.
CVE-2026-31669 is a slab-use-after-free vulnerability in the Linux kernel's MPTCP (Multipath TCP) implementation, specifically affecting IPv6 subflow child sockets during ehash table lookups in __inet_lookup_established. The issue arises because MPTCP's mptcp_subflow_init() copies the tcpv6_prot structure before inet6_init() registers it, leaving tcpv6_prot_override.slab as NULL. This causes subflow sockets to allocate from the kmalloc-4k cache, which lacks SLAB_TYPESAFE_BY_RCU, instead of the proper TCPv6 slab cache. Without SOCK_RCU_FREE protection, freed socket memory can be immediately reused, allowing concurrent lockless lookups under rcu_read_lock to access invalid memory.
Network-adjacent or remote attackers require no privileges or user interaction to exploit this vulnerability, as indicated by its CVSS 3.1 score of 9.8 (AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H). Exploitation involves triggering concurrent ehash lookups on MPTCP IPv6 subflows, leading to use-after-free access that could result in denial of service, data corruption, or potential code execution depending on memory reuse patterns.
Mitigation requires updating to a patched Linux kernel version incorporating the provided stable commit fixes, such as https://git.kernel.org/stable/c/15fa9ead4d5e6b6b9c794e84144146c917f2cb62 and related commits (3fd6547f5b8ac99687be6d937a0321efda760597, 9b55b253907e7431210483519c5ad711a37dafa1, b313e9037d98c13938740e5ebda7852929366dff, eb9c6aeb512f877cf397deb1e4526f646c70e4a7). These patches refactor IPv6-specific initialization into mptcp_subflow_v6_init(), called before protocol registration to ensure proper SLAB_TYPESAFE_BY_RCU inheritance.
EU & UK References
- 🇪🇺 ENISA EUVD: EUVD-2026-25562
Vulnerability Data
In the Linux kernel, the following vulnerability has been resolved: mptcp: fix slab-use-after-free in __inet_lookup_established The ehash table lookups are lockless and rely on SLAB_TYPESAFE_BY_RCU to guarantee socket memory stability during RCU read-side critical sections. Both tcp_prot and tcpv6_prot have…
more
their slab caches created with this flag via proto_register(). However, MPTCP's mptcp_subflow_init() copies tcpv6_prot into tcpv6_prot_override during inet_init() (fs_initcall, level 5), before inet6_init() (module_init/device_initcall, level 6) has called proto_register(&tcpv6_prot). At that point, tcpv6_prot.slab is still NULL, so tcpv6_prot_override.slab remains NULL permanently. This causes MPTCP v6 subflow child sockets to be allocated via kmalloc (falling into kmalloc-4k) instead of the TCPv6 slab cache. The kmalloc-4k cache lacks SLAB_TYPESAFE_BY_RCU, so when these sockets are freed without SOCK_RCU_FREE (which is cleared for child sockets by design), the memory can be immediately reused. Concurrent ehash lookups under rcu_read_lock can then access freed memory, triggering a slab-use-after-free in __inet_lookup_established. Fix this by splitting the IPv6-specific initialization out of mptcp_subflow_init() into a new mptcp_subflow_v6_init(), called from mptcp_proto_v6_init() before protocol registration. This ensures tcpv6_prot_override.slab correctly inherits the SLAB_TYPESAFE_BY_RCU slab cache.
- CWE(s)
Related Threats
MITRE ATT&CK Enterprise Techniques
CVEs Like This One
Affected Assets
Mitigating Controls
Control response
—
—
- 3 hardening rules · 3 OS baselines
V1.4.3
Mitigating Controls (NIST 800-53 r5) AI
Developer testing and evaluation can discover use-after-free bugs through dynamic analysis or fuzzing.
Engineering principles can require memory-safe constructs or languages that structurally avoid introducing use-after-free.
Process isolation confines the blast radius of use-after-free memory corruption to a single execution domain.
Memory protection controls limit exploitation impact by blocking unauthorized code execution from dangling pointers.
Mitigating Controls (NIST CSF 2.0) AI
Derived directly from the weakness types (CWEs) cited in the NVD entry via our AI-authored CWE→CSF cross-walk (authority under review) — links open the control.
Secure SDLC practices directly incorporate memory-safety tooling and reviews that prevent most use-after-free defects.
Vulnerability identification processes can discover use-after-free issues via scanning or analysis but do not prevent their introduction.
Routine patching removes known use-after-free instances after they have been introduced in released software.
Mitigating Controls (ISO/IEC 27001:2022 Annex A) AI
Derived directly from the weakness types (CWEs) cited in the NVD entry via our AI-authored CWE→ISO cross-walk (authority under review) — links open the control.
Security testing in development can detect use-after-free bugs before release.
Secure coding standards directly prescribe avoidance of use-after-free patterns.
Hardening callouts derived
Configuration rules from DISA STIG baselines that bear on weaknesses of the type cited by this CVE. Each rule is shown with the relationship its mapping actually records, against the CWE it was authored against. Derived via CVE→CWE over `controls_xwalks` (higher-evidence rows only; rows rated `none` are excluded).
Oracle Linux 8 (1 rule)
- V-248592 OL 8 must clear memory when it is freed to prevent use-after-free attacks. blocks CWE-416
RHEL 8 (1 rule)
- V-230279 RHEL 8 must clear memory when it is freed to prevent use-after-free attacks. blocks CWE-416
RHEL 9 (1 rule)
- V-257794 RHEL 9 must clear memory when it is freed to prevent use-after-free attacks. blocks CWE-416