CVE-2026-99771 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
wifi: mac80211: reload TDLS header pointer after skb_linearize()
ieee80211_process_tdls_channel_switch() sets tf = skb->data before it calls skb_linearize(), and reads tf->action_code afterwards.
ieee80211_rx_h_data() queues TDLS channel switch requests and responses to the interface after pulling only offsetof(struct ieee80211_tdls_data, u) bytes, so the skb can still be non-linear when the interface work handles it. Drivers that build paged RX skbs do this for every frame that does not fit into the skb head, e.g. iwlwifi (mvm), which is also the only mac80211 driver that sets NL80211_FEATURE_TDLS_CHANNEL_SWITCH. If the remaining data does not fit into the tailroom, skb_linearize() moves the data to a new head and frees the old one, and the action code is then read from freed memory. Depending on what that memory holds by then, the frame is handled as before or ends in the WARN_ON_ONCE() of the default case.
The frame only has to be a data frame with the TDLS ethertype from an authorized peer, e.g. relayed by the AP from another station in the BSS; the read happens before the sender is checked to be a TDLS peer.
Load tf after skb_linearize(), as the request and response handlers already do.
Found by static analysis tool CodeQL.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 11/21/2026
The vulnerability identified within the Linux kernel's mac80211 wireless subsystem represents a critical use-after-free condition arising from improper pointer management during packet processing operations. Specifically, the function ieee80211_process_tdls_channel_switch initializes a pointer tf to point at the start of the socket buffer data before invoking skb_linearize(). This sequence creates a race-like scenario where the memory address stored in tf may become invalid if the underlying data structure is reallocated or freed during the linearization process. The root cause lies in the assumption that the initial data location remains valid after potential memory operations, which contradicts the dynamic nature of kernel socket buffer handling when dealing with non-linear packet structures common in high-throughput wireless drivers such as iwlwifi.
From a technical perspective, this flaw is classified under CWE-416, Use After Free, and aligns with ATT&CK technique T1059, Command Scripting or System Network Configuration Modification if exploited to alter network behavior via TDLS channel switch requests. The vulnerability manifests when the kernel processes Data frames carrying the TDLS ethertype from an authorized peer. Because drivers like iwlwifi construct paged receive socket buffers for frames that exceed headroom capacity, the initial portion of the packet may be pulled into the linear area while the remainder stays in a separate page. When ieee80211_rx_h_data() queues these requests to the interface workqueue, it does not guarantee linearity. Consequently, when ieee80211_process_tdls_channel_switch executes skb_linearize(), any remaining data that cannot fit into the tailroom triggers a reallocation of the buffer head and frees the original memory block. The pointer tf, however, still references this now-freed memory region.
The operational impact of this vulnerability is significant as it allows for potential information disclosure or denial of service through kernel warnings and crashes. If the freed memory has not been overwritten with sensitive data, reading from it may yield stale values causing incorrect frame handling logic to proceed silently. However, if the memory contains new allocations or garbage data, the action code read from tf will likely be invalid, leading the switch statement in ieee80211_process_tdls_channel_switch to fall into its default case and trigger a WARN_ON_ONCE() macro. This results in kernel log spam and potential system instability depending on configuration settings that treat warnings as fatal errors or panic conditions. Furthermore, since this check occurs before sender validation against TDLS peers, an attacker within the same Basic Service Set could potentially exploit this by relaying crafted frames through the access point to trigger the condition remotely without direct peer-to-peer association requirements initially being verified.
Mitigation strategies primarily involve applying the upstream kernel patch that corrects the pointer initialization sequence. The fix requires reloading the tf pointer after skb_linearize() has completed, ensuring it points to the current valid data location rather than a potentially freed address. This aligns with existing practices in request and response handlers within the same subsystem which already perform this reload operation correctly. Administrators should ensure their systems are updated with kernel versions containing this fix, particularly those running wireless drivers that support TDLS channel switching features such as iwlwifi. Additionally, monitoring for WARN_ON_ONCE messages in system logs can serve as an indicator of attempted exploitation or accidental triggering due to malformed network traffic patterns targeting vulnerable kernel builds.