CVE-2026-43194
High · 7.5CVSS
7.5
EPSS
0.5%
Published
May 6, 2026
CISA due date
—
Cloudanix analysis
A Linux networking bug can cause some connections to freeze unexpectedly, disrupting services until the system is updated or the connection is reset.
- Exploitation
- Remote Unauthenticated
- Attacker needs
- None
- Complexity
- Moderate
- Impact
- Denial Of Service
- Component
- OS kernel
- Class
- Denial of service
- Remediation
- Patch
- Effort
- Low
- Patch risk
- Low
What it actually does
This Linux kernel networking flaw can cause established TCP connections to stall when Generic Segmentation Offload (GSO) traffic is transmitted through a qdisc-less path and the underlying network device reports transmit errors for individual segments. TCP may incorrectly treat a partially transmitted GSO frame as if the unsent portion was never transmitted, leaving sender and receiver sequence-number state inconsistent. The result is an availability failure: retransmissions and acknowledgements no longer make forward progress, causing affected connections to hang until reset or timed out.
Why it matters to the business
Systems that rely on affected Linux kernel networking paths may experience unexplained connection hangs, service timeouts, failed transfers, or degraded availability. The risk is highest for workloads using virtual networking, veth-style interfaces, container networking, XDP-enabled paths, disabled TSO/GSO offload behavior, or other qdisc-less device configurations where transmit errors can occur. This issue is not currently listed in CISA KEV, is not known to be used in ransomware campaigns, and has a low, stable EPSS score, but it can still affect service reliability in exposed or high-throughput Linux networking environments.
How an attack unfolds
An attacker would need to trigger or influence TCP traffic over an affected Linux networking path where GSO frames are used and transmit failures can occur below TCP, such as certain virtual or qdisc-less network device configurations. By causing traffic bursts and packet drops or transmit errors at the right point in segmentation, some segments of a GSO frame can be delivered while others are treated by TCP as not sent. The receiver may acknowledge data beyond what the sender believes it transmitted. The sender then rejects those acknowledgements as referring to unsent data, retransmits older data, and the receiver continues acknowledging beyond the sender state. This feedback loop can leave the connection permanently stuck, creating a denial of service for that flow. There is no public exploit maturity reported and no named threat actor activity provided for this issue.
How to fix it
Apply Linux kernel updates from the relevant distribution or kernel vendor that include the fix for "net: consume xmit errors of GSO frames." No exact fixed package versions were provided in the input, so remediation should be validated against vendor advisories, distribution changelogs, or upstream stable kernel release notes for this patch. Where immediate patching is not possible, reduce exposure by avoiding qdisc-less/noqueue transmit paths where feasible, reviewing virtual network and veth configurations, disabling unnecessary XDP programs on affected paths, ensuring standard qdisc behavior where appropriate, and monitoring or tuning environments that frequently encounter transmit drops. These mitigations may reduce likelihood but should not be treated as a substitute for a fixed kernel.
How to confirm the fix worked
Confirm that the running kernel includes the vendor backport or upstream commit corresponding to "net: consume xmit errors of GSO frames." Use package manager metadata, kernel changelogs, distribution security advisories, or source inspection rather than relying only on the kernel version string, because vendors may backport fixes. Validate exposure by reviewing interfaces for qdisc-less/noqueue behavior using commands such as `tc qdisc show` and by checking offload/XDP-related configuration with tools such as `ip -d link show` and `ethtool -k`. Functional validation can include reproducing representative high-throughput TCP traffic over the relevant virtual or qdisc-less path and confirming that connections continue to make progress during induced drops rather than stalling indefinitely.
Typical attack path
- Identify a Linux-hosted service or network path using affected kernel networking behavior, especially virtual interfaces, veth/container networking, XDP, disabled TSO, or qdisc-less transmit paths.
- Establish or induce TCP traffic that is segmented using GSO/TSO-like batching before device transmission.
- Cause or rely on transmit failures or packet drops on individual segments of a GSO frame.
- Trigger a condition where some segments are delivered while TCP interprets the GSO transmit result as though later data was not sent.
- Force the TCP sender and receiver into inconsistent sequence-number state.
- Maintain or repeat the condition until affected connections stall, time out, or require reset, causing availability impact.
How to detect it
Detection is primarily behavioral because the flaw does not produce a unique default log entry. Review network and application telemetry for established TCP sessions that stop making progress, repeated retransmissions, excessive duplicate ACKs, service timeouts, or connections that remain open until reset. Useful sources include application timeout logs, load balancer health checks, host network metrics, `ss`/`netstat` snapshots, `/proc/net/snmp` TCP counters, kernel tracepoints, eBPF telemetry, packet captures, and interface drop/error counters. Focus on paths involving veth, container networking, XDP-attached interfaces, noqueue/qdisc-less devices, disabled TSO/GSO behavior, or bursts of transmit drops. In packet captures, look for repeated retransmissions from the sender while the receiver continues acknowledging sequence numbers beyond the sender's apparent progress. In kernel tracing, investigate TCP retransmission events, transmit errors from virtual devices, and ACK rejection behavior around stalled flows. No named threat actors or ransomware campaigns were provided for this vulnerability.
What your security team should do
- Prioritize patching Linux systems that host network-facing services, container platforms, virtual networking infrastructure, high-throughput TCP services, or interfaces using veth, XDP, noqueue/qdisc-less behavior, or disabled TSO paths.
- Track distribution advisories for the affected Linux kernel packages and confirm the specific fix is present, since no fixed versions were supplied.
- Inventory systems with virtual networking and qdisc-less interfaces using `tc qdisc show`, `ip -d link show`, and configuration management data.
- Add monitoring for abnormal TCP stalls, retransmission spikes, service timeouts, and long-lived connections with no forward progress.
- If patching is delayed, evaluate whether affected paths can be moved to standard qdisc handling or whether unnecessary XDP/offload-altering configurations can be removed.
- Do not treat the low EPSS score or lack of KEV listing as proof of no risk; use them to prioritize, but still remediate systems where availability is important.
The record
In the Linux kernel, the following vulnerability has been resolved: net: consume xmit errors of GSO frames udpgro_frglist.sh and udpgro_bench.sh are the flakiest tests currently in NIPA. They fail in the same exact way, TCP GRO test stalls occasionally and the test gets killed after 10min. These tests use veth to simulate GRO. They attach a trivial ("return XDP_PASS;") XDP program to the veth to force TSO off and NAPI on. Digging into the failure mode we can see that the connection is completely stuck after a burst of drops. The sender's snd_nxt is at sequence number N [1], but the receiver claims to have received (rcv_nxt) up to N + 3 * MSS [2]. Last piece of the puzzle is that senders rtx queue is not empty (let's say the block in the rtx queue is at sequence number N - 4 * MSS [3]). In this state, sender sends a retransmission from the rtx queue with a single segment, and sequence numbers N-4*MSS:N-3*MSS [3]. Receiver sees it and responds with an ACK all the way up to N + 3 * MSS [2]. But sender will reject this ack as TCP_ACK_UNSENT_DATA because it has no recollection of ever sending data that far out [1]. And we are stuck. The root cause is the mess of the xmit return codes. veth returns an error when it can't xmit a frame. We end up with a loss event like this: ------------------------------------------------- | GSO super frame 1 | GSO super frame 2 | |-----------------------------------------------| | seg | seg | seg | seg | seg | seg | seg | seg | | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | ------------------------------------------------- x ok ok <ok>| ok ok ok <x> \\ snd_nxt "x" means packet lost by veth, and "ok" means it went thru. Since veth has TSO disabled in this test it sees individual segments. Segment 1 is on the retransmit queue and will be resent. So why did the sender not advance snd_nxt even tho it clearly did send up to seg 8? tcp_write_xmit() interprets the return code from the core to mean that data has not been sent at all. Since TCP deals with GSO super frames, not individual segment the crux of the problem is that loss of a single segment can be interpreted as loss of all. TCP only sees the last return code for the last segment of the GSO frame (in <> brackets in the diagram above). Of course for the problem to occur we need a setup or a device without a Qdisc. Otherwise Qdisc layer disconnects the protocol layer from the device errors completely. We have multiple ways to fix this. 1) make veth not return an error when it lost a packet. While this is what I think we did in the past, the issue keeps reappearing and it's annoying to debug. The game of whack a mole is not great. 2) fix the damn return codes We only talk about NETDEV_TX_OK and NETDEV_TX_BUSY in the documentation, so maybe we should make the return code from ndo_start_xmit() a boolean. I like that the most, but perhaps some ancient, not-really-networking protocol would suffer. 3) make TCP ignore the errors It is not entirely clear to me what benefit TCP gets from interpreting the result of ip_queue_xmit()? Specifically once the connection is established and we're pushing data - packet loss is just packet loss? 4) this fix Ignore the rc in the Qdisc-less+GSO case, since it's unreliable. We already always return OK in the TCQ_F_CAN_BYPASS case. In the Qdisc-less case let's be a bit more conservative and only mask the GSO errors. This path is taken by non-IP-"networks" like CAN, MCTP etc, so we could regress some ancient thing. This is the simplest, but also maybe the hackiest fix? Similar fix has been proposed by Eric in the past but never committed because original reporter was working with an OOT driver and wasn't providing feedback (see Link).
Affected packages
| Ecosystem | Package | Introduced | Fixed |
|---|