In the Linux kernel, the following vulnerability has been resolved: net/sched: cls_api: Handle TC_ACT_CONSUMED in tcf_qevent_handle tcf_classify() can return TC_ACT_CONSUMED while the skb is held by the defragmentation engine (e.g. act_ct on out-of-order fragments). When that happens the skb is no longer owned by the caller and must not be touched again. tcf_qevent_handle() did not handle TC_ACT_CONSUMED: it fell through the switch and returned the skb to the caller as if classification had passed. The only qdisc that wires up qevents today is RED, via three call sites (qe_mark on RED_PROB_MARK/HARD_MARK, qe_early_drop on congestion_drop) red_enqueue() was continuing to operate on an skb it no longer owns in this case -- enqueueing it, dropping it, or updating statistics. Resulting in a UAF. tc qdisc add dev eth0 root handle 1: red ... qevent early_drop block 10 tc filter add block 10 ... action ct (with ct defrag enabled and traffic that produces out-of-order fragments,
Casky was already ahead
This CVE exploits attack patterns that Casky's 0matched skills already investigate — long before this vulnerability was disclosed. Claude's reasoning model maps these techniques to MITRE ATT&CK, so practitioners who ran these skills have already seen the threat behaviour in their findings.
CVE-2026-64530 is a critical memory safety vulnerability in the Linux kernel's traffic control (TC) subsystem, specifically in how the tcf_qevent_handle() function manages packet buffers (skbs) during classification. When the defragmentation engine (such as act_ct processing out-of-order fragments) returns TC_ACT_CONSUMED, it signals that the packet is no longer owned by the caller and must not be accessed. However, tcf_qevent_handle() failed to recognize this return value, causing it to improperly return the skb to the caller as if normal classification had occurred. This creates a use-after-free condition where freed or transferred memory is accessed, potentially leading to kernel crashes, information disclosure, or privilege escalation. The vulnerability affects any Linux system using the kernel's qdisc and traffic control features, making it relevant to routers, load balancers, containers, and network namespaces in cloud environments.
Casky's security skills powered by Claude AI would detect attack patterns related to this vulnerability by analyzing kernel behavior anomalies in traffic control paths. Practitioners using Casky would observe findings related to memory safety violations and kernel exploitation chains—particularly those involving network packet manipulation (MITRE ATT&CK: T1499 for denial of service through resource exhaustion, or T1548 for abuse of elevation control mechanisms). The platform would flag suspicious kernel module interactions with defragmentation engines, abnormal skb lifetime patterns in tcf classification routines, and indicators of memory corruption in network processing contexts. Extended reasoning analysis would correlate fragmented packet handling with unexpected kernel state changes, enabling practitioners to identify exploitation attempts before system compromise occurs.
Composite risk scoring from EPSS, CISA KEV, Shodan, and GreyNoise — 21 security APIs correlated into a single Casky Risk Score. Coming in Casky Pro. Join early access →
Casky has 0 skills that investigate the attack patterns behind CVE-2026-64530. Run one and get CVSS-scored findings in 3 minutes.
Run the skill that detects this →© 2026 Casky.AI, Inc. · AI Security Investigation