Skip to main content

Linux Kernel EUVDEUVD-2026-45597

| CVE-2026-64024 CRITICAL
Memory Leak (CWE-401)
2026-07-19 Linux GHSA-h337-654q-329c
Critical
Disputed · 9.4 Vendor: Linux
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Send TCP packet hitting a drop path
  2. Delivery
    Leave stale tcp_tw_isn on target CPU
  3. Exploit
    Race victim SYN onto same CPU
  4. Execution
    Victim assigned predictable ISN
  5. Impact
    Spoof or inject into connection

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Resource cleanup, leak prevention
Exploitation Conditions

Exploitation requires that the attacker cause an inbound TCP packet to be dropped on one of the specific intermediate paths between the ISN producer in tcp_v{4,6}_rcv() and the consumer in tcp_conn_request() - namely a min_ttl/min_hopcount rejection, an xfrm policy drop, a tcp_inbound_hash() MD5/AO mismatch, a tcp_filter() eBPF/SO_ATTACH_FILTER drop, a th->syn && th->fin discard on a TCP_LISTEN socket, a psp_sk_rx_policy_check() failure, a tcp_checksum_complete() failure, or tcp_v{4,6}_cookie_check() returning NULL. That leaves tcp_tw_isn stale, and a following victim SYN must be processed on the same CPU to inherit the predictable ISN. Limiting factors: the value is merely predictable rather than attacker-chosen, success depends on same-CPU affinity and timing races (making real complexity high despite the CVSS AC:L), the kernel must be 6.10 through the fixed versions, and some of the drop paths themselves require non-default configuration such as active eBPF filters, TCP-MD5/AO, xfrm/IPsec policy, or PSP offload to be triggerable.

Impact

The signals conflict sharply. The supplied CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:H, score 9.4) rates this near-critical, but that appears inflated for the actual mechanism: exploitation is not a simple low-complexity network hit. Realistically an attacker must induce a packet drop on a specific intermediate path, land it on the same CPU as a subsequent victim SYN, and then leverage a merely predictable (not attacker-chosen) ISN for spoofing - closer to high attack complexity than AC:L, and the A:H (availability) impact is not well supported by the description, which is an ISN-prediction/integrity issue, not a crash or DoS. Corroborating this lower real-world risk: EPSS is 0.17% (6th percentile) and the tag is 'Information Disclosure,' not remote code execution. There is no KEV listing and no public exploit identified at time of analysis. Net assessment: this is a legitimate integrity-weakening kernel bug worth patching in normal cycles, but the 9.4 headline overstates practical urgency - treat it as medium priority rather than an emergency, and note the CVSS availability/complexity metrics are questionable versus the described behavior.

Exploit ScenarioDerived

An off-path attacker who can reliably trigger one of the kernel's SYN drop paths (for example, by sending a packet that fails an eBPF/socket filter or checksum, or a SYN+FIN to a listening socket) causes the stale tcp_tw_isn to persist on that CPU. A legitimate client's subsequent SYN handled on the same CPU is then assigned a predictable ISN, which the attacker can use to spoof or inject segments into the resulting connection. No public exploit is identified at time of analysis, and the required timing/CPU-affinity alignment makes reliable exploitation difficult.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Jul 20, 2026

Predictable TCP Initial Sequence Number (ISN) generation in the Linux kernel's TCP stack (introduced in 6.10) stems from a stale per-CPU tcp_tw_isn value leaking between packets. A regression moved the TIME_WAIT-derived ISN from the per-skb control block to a per-CPU variable on the assumption it would always be consumed by the same packet; when that packet is instead dropped on any of several intermediate paths, the value persists and the next SYN handled on that CPU inherits a non-zero, potentially predictable ISN, weakening TCP connection integrity. NVD assigns CVSS 9.4, but EPSS is low at 0.17% (6th percentile), there is no public exploit identified at time of analysis, and it is not in CISA KEV.

RemediationAI

Vendor-released patch: upgrade to Linux 6.18.34, 7.0.11, or 7.1 (or the corresponding distribution backport that includes stable commits e47f7060, 4affe063, or 1bbf0ced from git.kernel.org/stable/c/). Because the fix is a small, self-contained revert to skb->cb[], it backports cleanly and should be prioritized during the next kernel maintenance window. No configuration-level workaround fully removes the flaw since it resides in core TCP receive processing, but interim risk can be reduced by hardening against ISN-prediction abuse: enable and enforce TCP-AO or TCP-MD5 signatures on sensitive/long-lived sessions (e.g. BGP) so predictable ISNs cannot be leveraged for injection, and restrict exposure of the affected hosts behind stateful firewalls that validate sequence numbers - with the trade-off that TCP-AO/MD5 add configuration overhead and per-packet CPU cost, and firewall sequence validation does not help against on-path or same-segment attackers. Verify the backport landed via your distribution's advisory before treating hosts as remediated.

Affected VersionsENISA

Linux patch: 7.1
Linux 6.10
Linux patch: 6.18.34
Linux patch: 7.0.11
Linux patch: 0
Linux 41eecbd712b73f0d5dcf1152b9a1c27b1f238028 <1bbf0ced1d9db73ac7893c2187f3459288603e0d
Linux 41eecbd712b73f0d5dcf1152b9a1c27b1f238028 <4affe063fa56c880cbea8d0bfded0bb80751579d
Linux 41eecbd712b73f0d5dcf1152b9a1c27b1f238028 <e47f7060eaf60894e3e4d0e3c4fe6e1f2eacfbdd

Affected Packages

euvd linux no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

The flaw lives in the IPv4/IPv6 TCP receive path (tcp_v4_rcv/tcp_v6_rcv, tcp_conn_request). The Initial Sequence Number is a core anti-spoofing mechanism in TCP: it must be unpredictable so off-path attackers cannot guess valid sequence numbers to inject or spoof segments into a connection. The blamed commit optimized handling of the TIME_WAIT-recycled ISN by storing it in a per-CPU variable (__this_cpu_write(tcp_tw_isn, isn)) rather than in skb->cb[], expecting the producer in tcp_v{4,6}_rcv() and the consumer in tcp_conn_request() to always align on the same packet. Numerous drop paths break that invariant - min_ttl/min_hopcount checks, xfrm policy checks, tcp_inbound_hash() MD5/AO mismatch, tcp_filter() eBPF/SO_ATTACH_FILTER drops, SYN+FIN discard in TCP_LISTEN, psp_sk_rx_policy_check(), tcp_checksum_complete() failures, and tcp_v{4,6}_cookie_check() returning NULL - each of which leaves tcp_tw_isn set. This is fundamentally a use of insufficiently random / stale values for a security-sensitive field (CWE-330 class; CWE field marked N/A in source data). The fix reverts the ISN back into skb->cb[], eliminating the per-CPU variable entirely, with negligible code-size impact (-7 bytes per bloat-o-meter).

Know when the next one hits your stack

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Sources disagree (Medium–Critical)
Vendor (Linux) PRIMARY 9.4 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:H/A:H
vuln.today AI 5.9 MEDIUM

Network-reachable but requires racing a drop path onto the same CPU (AC:H); impact is predictable ISN weakening connection integrity (I:H), with no confidentiality or availability loss.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:N/I:H/A:N
4.0 AV:N/AC:H/AT:N/PR:N/UI:N/VC:N/VI:H/VA:N/SC:N/SI:N/SA:N
SUSE CRITICAL
Red Hat 7.0 MEDIUM

vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.

CVSS VectorVendor: Linux

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
Low
Integrity
High
Availability
High

Lifecycle Timeline

4
CVSS changed
Jul 20, 2026 - 15:22 NVD
9.4 (CRITICAL)
Patch available
Jul 19, 2026 - 17:03 EUVD
CVE Published
Jul 19, 2026 - 15:39 cve.org
CRITICAL 9.4
CVE Published
Jul 19, 2026 - 15:39 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

In the Linux kernel, the following vulnerability has been resolved:

tcp: fix stale per-CPU tcp_tw_isn leak enabling ISN prediction

Blamed commit moved the TIME_WAIT-derived ISN from the skb control block to a per-CPU variable, assuming the value would always be consumed by tcp_conn_request() for the same packet that wrote it. That assumption is violated by multiple drop paths between the producer (__this_cpu_write(tcp_tw_isn, isn) in tcp_v{4,6}_rcv()) and the consumer (tcp_conn_request()):

  • min_ttl / min_hopcount check
  • xfrm policy check
  • tcp_inbound_hash() MD5/AO mismatch
  • tcp_filter() eBPF/SO_ATTACH_FILTER drop
  • th->syn && th->fin discard in tcp_rcv_state_process() TCP_LISTEN
  • psp_sk_rx_policy_check() in tcp_v{4,6}_do_rcv()
  • tcp_checksum_complete() in tcp_v{4,6}_do_rcv()
  • tcp_v{4,6}_cookie_check() returning NULL

When a packet is dropped on any of these paths, tcp_tw_isn is left set.

The next SYN processed on the same CPU then consumes the non zero value in tcp_conn_request(), receiving a potentially predictable ISN.

This patch moves back tcp_tw_isn to skb->cb[], getting rid of the per-cpu variable.

Note that tcp_v{4,6}_fill_cb() do not set it.

Very litle impact on overall code size/complexity:

$ scripts/bloat-o-meter -t vmlinux.old vmlinux.new add/remove: 0/0 grow/shrink: 2/1 up/down: 8/-15 (-7) Function old new delta tcp_v6_rcv 3038 3042 +4 tcp_v4_rcv 3035 3039 +4 tcp_conn_request 2938 2923 -15 Total: Before=24436060, After=24436053, chg -0.00%

Executive ViewAI

Why It Matters

A regression affecting Linux kernel 6.10+ undermines TCP connection security by generating predictable sequence numbers, creating potential for unauthorized connection interception. Although rated CRITICAL by technical standards, exploitation probability is currently low with no public exploit identified at time of analysis. Organizations with Linux deployments require immediate patching to eliminate this TCP hijacking risk.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 94% exploitable
Prevalence
Ubiquitous
Linux kernel TCP stack runs on nearly all Linux servers and devices
Data Quality
6 sources
Confidence: High

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
Yes
Human Impact
High

Priority Score

47
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +47
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

Vendor StatusVendor

SUSE

Severity: Critical
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 15 SP7 Affected
SUSE Linux Enterprise High Availability Extension 16.0 Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy