CVE-2026-64114
Received Received - Intake

Heap-based OOB in Linux Kernel IPv4 Raw Socket Handling

Vulnerability report for CVE-2026-64114, including description, CVSS score, EPSS score, affected products, exploitability, helpful resources, and attack-flow context.

Publication date: 2026-07-19

Last updated on: 2026-07-19

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: ipv4: raw: reject IP_HDRINCL packets with ihl < 5 raw_send_hdrinc() validates that the caller-supplied IPv4 header fits within the message length: iphlen = iph->ihl * 4; err = -EINVAL; if (iphlen > length) goto error_free; if (iphlen >= sizeof(*iph)) { /* fix up saddr, tot_len, id, csum, transport_header */ } It does not, however, reject ihl < 5. For such a packet the "if (iphlen >= sizeof(*iph))" branch is skipped, leaving the crafted iphdr untouched, but the packet is still handed to __ip_local_out() and onward. Downstream consumers that read iph->ihl assume a sane value: net/ipv4/ah4.c:ah_output() in particular subtracts sizeof(struct iphdr) from top_iph->ihl * 4 and passes the (signed-int-negative, then cast to size_t) result to memcpy(), producing an OOB access of length close to SIZE_MAX and a host kernel panic. An IPv4 header with ihl < 5 is malformed by definition (RFC 791: "Internet Header Length is the length of the internet header in 32 bit words ... Note that the minimum value for a correct header is 5."). The kernel should not be willing to inject such a packet into its own output path. Reject "iphlen < sizeof(*iph)" alongside the existing "iphlen > length" check. This matches the principle that locally constructed packets that re-enter the IP stack must pass the same basic sanity tests that a foreign packet would be subjected to. Once this lands, the "if (iphlen >= sizeof(*iph))" wrapper around the fixup branch becomes redundant; left in place to keep the patch minimal and backport-friendly. A follow-up can unwrap it. Note that commit 86f4c90a1c5c ("ipv4, ipv6: ensure raw socket message is big enough to hold an IP header") ensures the message buffer is large enough to hold an iphdr, but does not constrain the self-reported iph->ihl. Reachability: the malformed packet source is any caller with CAP_NET_RAW, including an unprivileged process in a user+net namespace on a kernel with CONFIG_USER_NS=y. The reproduced AH crash also requires a matching xfrm AH policy on the outgoing route; a container granted CAP_NET_ADMIN can install that state and policy in its netns. Loopback bypasses xfrm_output, so the trigger uses a real netdev. Reproduced on UML + KASAN: kernel-mode fault at addr 0x0 with memcpy_orig at the crash site. Same shape reproduces inside a rootless Docker container with --cap-add NET_ADMIN on a stock distro kernel.

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-07-19
Last Modified
2026-07-19
Generated
2026-07-20
AI Q&A
2026-07-19
EPSS Evaluated
N/A
NVD
EUVD

Affected Vendors & Products

Showing 1 associated CPE
Vendor Product Version / Range
linux linux_kernel *

Helpful Resources

Exploitability

CWE
CWE Icon
KEV
KEV Icon
CWE ID Description
CWE-UNKNOWN

Attack-Flow Graph

AI Quick Actions

Instant insights powered by AI
Executive Summary

This vulnerability in the Linux kernel involves improper handling of IPv4 packets with a malformed header. Specifically, the kernel fails to reject packets where the Internet Header Length (ihl) is less than 5, which is invalid per RFC 791. This oversight allows crafted packets to bypass sanity checks and trigger a kernel panic when processed by downstream components like AH4 (Authentication Header) processing.

Detection Guidance

Detecting this vulnerability requires checking for raw socket usage with malformed IPv4 headers. Monitor for processes using raw sockets with CAP_NET_RAW privileges. Check kernel logs for crashes related to IPv4 header processing or AH (Authentication Header) modules. Use tools like tcpdump to capture packets with ihl < 5, though this requires deep packet inspection.

Impact Analysis

An attacker with CAP_NET_RAW privileges (including unprivileged processes in user namespaces with CONFIG_USER_NS=y) can exploit this to crash the kernel. In a containerized environment with CAP_NET_ADMIN, an attacker could install policies to trigger the crash via a real network device. This leads to a denial-of-service condition, halting the system.

Compliance Impact

This vulnerability does not directly affect compliance with GDPR or HIPAA as it pertains to a Linux kernel networking issue. However, if exploited, it could lead to kernel panics and denial-of-service conditions, potentially impacting system availability and integrity. Such disruptions may indirectly affect compliance by violating availability requirements in standards like HIPAA for healthcare systems or GDPR for data processing systems.

Mitigation Strategies

Apply the kernel patch that adds validation for ihl >= sizeof(*iph) in raw_send_hdrinc(). Restrict CAP_NET_RAW capabilities to only trusted processes. Disable AH policies if not required. Update to a patched kernel version. Monitor for suspicious raw socket activity in logs.

Chat Assistant

Ask questions about this CVE
Hi! I’m here to help you understand CVE-2026-64114. Ask me anything about the vulnerability, its impact, or mitigation strategies.
0/70

EPSS Chart