CVE-2026-99636 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

net: reject a negative TCP header offset in qdisc_pkt_len_segs_init()

qdisc_pkt_len_segs_init() stores skb_transport_offset(), or the inner offset, in the unsigned hdr_len. A header in front of skb->data gives a negative offset. For an offset a little below zero, pskb_may_pull() gets a small length and succeeds. Then a 64-bit kernel reads the TCP header far after the skb and can crash. Further below zero pskb_may_pull() fails.

Commit 28a57fb2c5df ("net: iptunnel: fix stale transport header during tunnel decapsulation") fixed one source of such offsets. Other code that removes bytes from the front of a packet can leave the same stale header.

Return SKB_DROP_REASON_SKB_BAD_GSO for a negative offset in the TCP branch. SKB_GSO_UDP_L4 and the other GSO types read no header and still get a wrong qdisc_pkt_len(). On a 64-bit kernel only packets that cause the read after the skb today get a new result. Then __dev_queue_xmit() drops them and returns -EINVAL, but sch_handle_ingress() ignores the result. Their content can be valid. Thus the code that leaves the header stale needs its own fix.

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 Linux kernel contains a critical vulnerability within the network subsystem's packet scheduling logic, specifically in the qdisc_pkt_len_segs_init function which is responsible for initializing segment lengths for Generic Segmentation Offload operations. The core technical flaw arises from an improper handling of signed integer values when calculating header offsets. Specifically, the function stores the result of skb_transport_offset or its inner offset equivalent into an unsigned variable named hdr_len without validating that the underlying transport header pointer has not moved backward relative to the start of the socket buffer data. In normal packet processing, headers are typically prepended and then stripped during decapsulation or tunneling operations. When bytes are removed from the front of a packet by code paths such as those involved in IP tunnel decapsulation, the skb_transport_offset value can become negative if it references memory preceding the current start of the socket buffer data. Because this negative offset is cast to an unsigned type, it results in a very large positive integer representing hdr_len.

This arithmetic error leads directly to severe operational instability and potential denial of service conditions on 64-bit systems. When pskb_may_pull is subsequently called with this erroneously large length derived from the unsigned conversion of a negative offset, the function may succeed if the calculated pull amount happens to fall within valid memory bounds due to specific packet structures or kernel layout variations. However, subsequent code that attempts to read the TCP header using this corrupted hdr_len value will access memory far beyond the allocated boundaries of the socket buffer. On 64-bit kernels, such out-of-bounds reads can trigger a general protection fault or page fault, resulting in an immediate kernel panic and system crash. This represents a classic case of improper type conversion leading to out-of-bounds read vulnerabilities where signed integer values are incorrectly treated as unsigned without range checking.

The vulnerability is exacerbated by the fact that previous fixes have addressed some sources of stale transport headers but not all code paths that manipulate packet data fronts. For instance, commit 28a57fb2c5df fixed issues related to IP tunnel decapsulation leaving stale headers, yet other mechanisms for removing bytes from packet frontiers remain unpatched in this context. Furthermore, the impact varies across different Generic Segmentation Offload types. While GSO UDP L4 and similar variants do not read headers and thus avoid the direct crash scenario, they still result in incorrect qdisc_pkt_len calculations which can disrupt network scheduling logic. For TCP traffic on 64-bit systems, although __dev_queue_xmit may eventually drop packets returning an error code due to invalid parameters, sch_handle_ingress often ignores these return values allowing malformed or potentially valid content to proceed through the ingress path with corrupted metadata, leading to unpredictable networking behavior and potential security bypasses.

To mitigate this vulnerability, developers have implemented a check within qdisc_pkt_len_segs_init that explicitly rejects negative TCP header offsets by returning SKB_DROP_REASON_SKB_BAD_GSO. This ensures that packets with invalid transport header pointers are dropped early in the processing pipeline rather than propagating corrupted state to downstream functions. Additionally, broader remediation requires auditing all code paths that modify packet data fronts or perform decapsulation operations to ensure they correctly update skb_transport_offset and related metadata fields. System administrators should apply kernel updates containing this fix immediately to prevent remote attackers from triggering kernel panics via crafted network packets designed to exploit the stale header condition. This issue aligns with CWE-190 Integer Overflow Wraparound and CWE-787 Out-of-bounds Read, while its exploitation vector relates to ATT&CK techniques involving resource exhaustion through denial of service attacks against critical infrastructure components.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00167

KEV

no

Activities

very low

Sources

Do you need the next level of professionalism?

Upgrade your account now!