CVE-2026-74473 in Linux
Summary
by MITRE • 08/15/2026
In the Linux kernel, the following vulnerability has been resolved:
vxlan: use pskb_network_may_pull() in route_shortcircuit()
route_shortcircuit() currently calls pskb_may_pull(skb, sizeof(struct iphdr)) (or ipv6hdr), which checks if bytes are available starting from skb->data.
However, in vxlan_xmit(), skb->data points to the MAC header, so skb_network_offset(skb) is ETH_HLEN (14 bytes). Using pskb_may_pull(skb, 20) only checks 20 bytes from skb->data (which is 14 bytes MAC header + 6 bytes of IP header), leaving the rest of the IP header potentially un-pulled in non-linear frags. Subsequent dereferences of ip_hdr(skb)->daddr can read beyond the pulled linear buffer length.
Fix this by using pskb_network_may_pull(), which adds skb_network_offset(skb) to the length check to ensure the full network header is present in the linear buffer.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 08/15/2026
The vulnerability in question affects the Linux kernel's VXLAN implementation, specifically within the route_shortcircuit() function that handles packet routing for virtual extensible LANs. This issue stems from an improper handling of network header validation during packet processing, creating a potential for memory access violations and information disclosure. The flaw manifests when the kernel processes VXLAN packets where the network layer headers are not adequately validated before being dereferenced. The vulnerability resides in how the kernel determines whether sufficient data is available in the packet's linear buffer to safely access network layer fields, particularly the destination address field in IP headers.
The technical root cause involves a mismatch between the expected and actual memory layout of packet data structures within the Linux kernel networking stack. When vxlan_xmit() processes packets, it sets up the skb->data pointer to point to the MAC header location, which means that the network offset is properly established at ETH_HLEN (14 bytes). However, when route_shortcircuit() calls pskb_may_pull(skb, sizeof(struct iphdr)), this function only validates the requested number of bytes starting from the current skb->data pointer position. This approach fails to account for the network offset that was previously established, resulting in incomplete header validation. The consequence is that while 20 bytes may be pulled from the linear buffer starting at the MAC header location, the actual IP header may extend beyond this validated boundary, particularly in non-linear fragments where data is scattered across multiple memory regions.
This vulnerability creates a significant operational impact by potentially allowing attackers to trigger kernel memory corruption through carefully crafted VXLAN packets. The flaw enables a form of out-of-bounds memory access when subsequent code dereferences ip_hdr(skb)->daddr without ensuring the complete IP header resides within the validated linear buffer space. Such an issue could lead to kernel panics, denial of service conditions, or potentially more severe exploits depending on the specific memory layout and access patterns. The vulnerability affects all systems running Linux kernels with VXLAN support where packets are processed through the route_shortcircuit() path, making it a widespread concern for virtualized environments and network infrastructure deployments.
The fix implemented addresses this by replacing pskb_may_pull() with pskb_network_may_pull(), which properly incorporates the established network offset into its validation logic. This change ensures that when validating network headers, the function accounts for the actual position of the network layer data within the packet structure rather than just the raw buffer position. The solution aligns with best practices for kernel packet processing and follows established security patterns for memory safety in network drivers. This remediation directly addresses the weakness identified in CWE-129, which covers improper validation of array indices, and specifically targets the pattern of insufficient bounds checking that could lead to memory corruption. The fix also provides defense-in-depth against potential exploitation techniques categorized under ATT&CK technique T1059, as it prevents malicious actors from leveraging packet processing vulnerabilities to gain unauthorized access or escalate privileges within the kernel space.