CVE-2026-74621
Received Received - Intake

Linux Kernel sk_buff Leak in Netfilter Connection Tracking

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

Publication date: 2026-08-22

Last updated on: 2026-08-22

Assigner: kernel.org

Description

In the Linux kernel, the following vulnerability has been resolved: net/sched: act_ct: fix sk_buff leak when the header checks reject a packet tcf_ct_handle_fragments() runs its header sanity checks before handing anything to the defragmentation engine: if (family == NFPROTO_IPV4) err = tcf_ct_ipv4_is_fragment(skb, &frag); else err = tcf_ct_ipv6_is_fragment(skb, &frag); if (err || !frag) return err; tcf_ct_ipv4_is_fragment() returns -EINVAL or -ENOMEM; tcf_ct_ipv6_is_fragment() adds -EPROTO when ipv6_find_hdr() fails. None of them frees or queues the skb, so on that path the caller still owns it. tcf_ct_act() however funnels every non-zero return into the ownership-transfer exit: err = tcf_ct_handle_fragments(net, skb, family, p->zone, &defrag); if (err) goto out_frag; ... out_frag: if (err != -EINPROGRESS) tcf_action_inc_drop_qstats(&c->common); return TC_ACT_CONSUMED; TC_ACT_CONSUMED means the action took ownership of the skb, so no caller frees it - sch_handle_ingress(), sch_handle_egress() and tcf_qevent_handle() all deliberately skip the free for that verdict. The skb is therefore orphaned: one sk_buff plus its data buffer is leaked per malformed packet, unbounded. Note the drop counter is already incremented for these errors, so the statistics claim a drop that never happens. Three different ownership states reach out_frag: today - the skb may be queued by the defrag engine (-EINPROGRESS), already freed by nf_ct_handle_fragments(), or still owned by us. Tell the caller which of those it is, and free the packet ourselves in the last case, which restores the TC_ACT_SHOT behaviour that predated the Fixes: commit. Reproduced on v7.2-rc6 with a 54-byte frame carrying a 40-byte IPv6 header with nexthdr = 0 (hop-by-hop) and nothing after it, on a clsact ingress chain with "action ct". kmemleak reports one leaked 232-byte skbuff_head_cache object plus its 704-byte data buffer per packet; with this patch it reports none.

CVSS Scores

EPSS Scores

Probability:
Percentile:

Meta Information

Published
2026-08-22
Last Modified
2026-08-22
Generated
2026-08-22
AI Q&A
2026-08-22
EPSS Evaluated
N/A
NVD
EUVD

Affected Vendors & Products

Showing 1 associated CPE
Vendor Product Version / Range
linux linux_kernel 7.2-rc6

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 a memory leak in the network traffic control subsystem. When processing packets, the code fails to free sk_buff structures (network packet buffers) if header checks reject a packet. This happens because the function tcf_ct_handle_fragments() returns an error code without freeing the packet, and the caller assumes ownership is transferred, preventing proper cleanup.

Detection Guidance

This vulnerability involves a kernel memory leak in the net/sched act_ct module when handling malformed packets. Detection requires monitoring for sk_buff leaks in the kernel, particularly in traffic control (TC) ingress/egress paths. Use kmemleak or similar tools to track orphaned sk_buff objects. Check for increased memory usage in kernel slab caches related to networking. Monitor drop counters in TC statistics for discrepancies between reported drops and actual memory usage.

Impact Analysis

This vulnerability can lead to memory exhaustion on systems processing malformed network packets. Each rejected packet leaks a small amount of memory (sk_buff and its data buffer), which can accumulate over time and cause system instability or crashes due to resource depletion.

Mitigation Strategies

Apply the kernel patch that fixes the sk_buff leak in tcf_ct_handle_fragments(). Update to a Linux kernel version containing the fix. If immediate patching is not possible, consider disabling the affected traffic control action (ct) module or filtering malformed packets at the network edge. Monitor memory usage and kernel logs for signs of the leak until patched.

Chat Assistant

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

EPSS Chart