CVE-2026-53008: Linux ice Driver TX Timestamp Race Condition Denial of Service
A race condition exists in the Linux kernel's ice driver that can cause a system crash when one CPU is cleaning up TX timestamp resources while another CPU is actively using them. The vulnerability occurs because pointer cleanup and flag clearing happen in the wrong order, allowing a concurrent operation to dereference a NULL pointer. The impact is limited to systems with the ice driver loaded and TX timestamping enabled, and requires local access to trigger.
Source data · NVD / CISA · public domain
- CVSS
- 3.1 · 4.7 MEDIUM · CVSS:3.1/AV:L/AC:H/PR:L/UI:N/S:U/C:N/I:N/A:H
- Weaknesses (CWE)
- CWE-362
- Affected products
- 1 configuration(s)
- Published / Modified
- 2026-06-24 / 2026-07-14
NVD description (verbatim)
In the Linux kernel, the following vulnerability has been resolved: ice: fix race condition in TX timestamp ring cleanup Fix a race condition between ice_free_tx_tstamp_ring() and ice_tx_map() that can cause a NULL pointer dereference. ice_free_tx_tstamp_ring currently clears the ICE_TX_FLAGS_TXTIME flag after NULLing the tstamp_ring. This could allow a concurrent ice_tx_map call on another CPU to dereference the tstamp_ring, which could lead to a NULL pointer dereference. CPU A:ice_free_tx_tstamp_ring() | CPU B:ice_tx_map() --------------------------------|--------------------------------- tx_ring->tstamp_ring = NULL | | ice_is_txtime_cfg() -> true | tstamp_ring = tx_ring->tstamp_ring | tstamp_ring->count // NULL deref! flags &= ~ICE_TX_FLAGS_TXTIME | Fix by: 1. Reordering ice_free_tx_tstamp_ring() to clear the flag before NULLing the pointer, with smp_wmb() to ensure proper ordering. 2. Adding smp_rmb() in ice_tx_map() after the flag check to order the flag read before the pointer read, using READ_ONCE() for the pointer, and adding a NULL check as a safety net. 3. Converting tx_ring->flags from u8 to DECLARE_BITMAP() and using atomic bitops (set_bit(), clear_bit(), test_bit()) for all flag operations throughout the driver: - ICE_TX_RING_FLAGS_XDP - ICE_TX_RING_FLAGS_VLAN_L2TAG1 - ICE_TX_RING_FLAGS_VLAN_L2TAG2 - ICE_TX_RING_FLAGS_TXTIME
2 reference(s) · View on NVD →
SEC.co analysis · AI-assisted, reviewed against source
Technical summary
CVE-2026-53008 is a race condition (CWE-362) in the ice network driver's TX timestamp ring management. The vulnerability stems from improper synchronization in ice_free_tx_tstamp_ring() and ice_tx_map() functions. When ice_free_tx_tstamp_ring() NULLs the tstamp_ring pointer before clearing the ICE_TX_FLAGS_TXTIME flag, a concurrent ice_tx_map() call on another CPU may read the flag as set and attempt to dereference the already-freed pointer. The fix involves: (1) reordering flag clearing before pointer NULLing with appropriate memory barriers (smp_wmb/smp_rmb), (2) adding defensive NULL checks in ice_tx_map(), and (3) converting the flags field from u8 to an atomic bitmap with proper atomic bitops (set_bit/clear_bit/test_bit) to eliminate future ordering issues. This ensures memory operations are visible across CPUs before dependent operations proceed.
Business impact
Systems running the ice driver with TX timestamping features enabled face a denial-of-service risk. Exploitation requires local access and specific timing but can cause kernel panics affecting network availability. The vulnerability is not in CISA's active exploitation list and carries a CVSS score of 4.7 (MEDIUM), reflecting that impact is availability-focused and requires privilege and precise race condition timing. Organizations dependent on Intel 800-series Ethernet devices with timestamping workloads should treat this as a standard maintenance priority rather than an emergency.
Affected systems
Linux kernel systems with the ice driver loaded, particularly those using Intel 800-series Ethernet adapters (E810, E823, etc.). The vulnerability is only exploitable when TX timestamping is configured and active, which is common in financial trading, telecommunications, and other time-sensitive networking workloads. Bare-metal servers, virtual machines with SR-IOV passthrough, and container hosts using these NICs are affected. Systems without the ice driver or with timestamping disabled are not vulnerable.
Exploitability
The vulnerability requires local code execution (AV:L) and can be triggered by an unprivileged user with the ability to send network traffic and cause scheduling conditions that create the race window (AC:H). While the race window is narrow and timing-dependent, determined attackers can increase probability through repeated attempts. No remote exploitation is possible, and no public exploit code is known. The vulnerability has not been added to CISA's Known Exploited Vulnerabilities catalog.
Remediation
Deploy kernel updates that include the race condition fix. The patch reorders operations in ice_free_tx_tstamp_ring() to clear flags before NULLing pointers, adds memory barriers for proper ordering, introduces defensive NULL checks in ice_tx_map(), and converts the flags field to atomic bitmap operations. Verify patch availability from your Linux distribution or verify against the Linux kernel stable/LTS branches. Immediate patching is recommended for systems with heavy use of TX timestamping features; other systems can follow standard maintenance windows.
Patch guidance
Patch status depends on your Linux distribution and kernel branch. The fix is expected in stable and LTS kernels; check your distribution's security advisories and kernel update channels. For custom or self-compiled kernels, the upstream fix involves changes to ice_free_tx_tstamp_ring(), ice_tx_map(), and conversion of tx_ring->flags operations to atomic bitmap calls. Ensure any patch includes the smp_wmb()/smp_rmb() memory barrier changes and the DECLARE_BITMAP() conversion. Test patched kernels in non-production environments before rollout, particularly for systems relying on TX timestamping accuracy.
Detection guidance
Monitor system logs for ice driver errors or kernel panics correlated with TX timestamping activity. Kernel logs will show NULL pointer dereference messages mentioning ice driver functions. For active detection, monitor CPU contention and TX ring behavior during high network load on systems using TX timestamping. Systems using TX timestamping can log timestamp ring state periodically to catch anomalies. Consider enabling kernel debug symbols (CONFIG_DEBUG_INFO) in test environments to get better stack traces if panics occur.
Why prioritize this
Treat as MEDIUM priority aligned with the CVSS 4.7 score. Prioritize systems that actively use TX timestamping (e.g., financial, telecom, precision timing applications) and those with high concurrency on TX rings (high-throughput data centers). Patch within your standard 30–90 day maintenance cycle unless you operate latency-sensitive or high-frequency trading environments, where expedited patching (within 2 weeks) is warranted. Systems without TX timestamping enabled can defer patching to a regular update window.
Risk score, explained
The CVSS 3.1 score of 4.7 reflects: AV:L (local access required), AC:H (high complexity due to race condition timing), PR:L (low privilege sufficient), and A:H (high availability impact from kernel panic). The score does not account for the relatively narrow affected deployment scope (timestamping-enabled ice driver systems) or the absence of active exploitation. Organizations with TX timestamping at scale should consider a practical risk bump; others can apply standard guidance.
Frequently asked questions
What is TX timestamping and why is it important?
TX (transmit) timestamping records the precise moment a packet leaves the network interface, enabling applications to maintain accurate network timing for financial markets, distributed systems, or industrial control. The ice driver supports hardware-based TX timestamping on Intel Ethernet adapters. Without this feature, many systems function normally; it is primarily critical for time-sensitive workloads.
Does this vulnerability affect my system if I don't use TX timestamping?
No. The race condition only manifests when TX timestamping is active and ice_free_tx_tstamp_ring() is called concurrently with ice_tx_map(). Systems with the ice driver loaded but timestamping disabled or unused are not vulnerable.
What exactly happens if this race condition is triggered?
A NULL pointer dereference causes a kernel panic, crashing the system or causing a network driver reset. This is a denial-of-service condition; there is no data leak or privilege escalation. Systems will restart or recover once the driver is reloaded, depending on kernel crash dump settings.
Why does the fix involve converting to atomic bitmap operations?
Atomic bitmap operations (set_bit, clear_bit, test_bit) are atomic across CPUs and include necessary memory barriers, eliminating the need to manually manage smp_wmb/smp_rmb. This provides a more robust, maintainable solution than relying on careful barrier placement and reduces the risk of similar race conditions elsewhere in the code.
This analysis is based on the published CVE description and CVSS scoring. Actual patch availability, deployment timelines, and version numbers must be verified against official Linux distribution security advisories and vendor announcements. Organizations should test patches in non-production environments before deploying to production systems. This advisory does not constitute legal advice or a guarantee of system security and is provided for informational purposes to support vulnerability management decisions. Source: NVD (public-domain), retrieved 2026-07-31. Analysis generated by SEC.co (claude-haiku-4-5).
Related vulnerabilities
- CVE-2026-11253MEDIUMChrome Permissions Flaw Allows Cross-Origin Data Leak
- CVE-2026-46187MEDIUMLinux RSI Driver Use-After-Free Vulnerability (CVSS 4.7)
- CVE-2026-46272MEDIUMLinux CoreSight TMC-ETR Race Condition DoS
- CVE-2026-46298MEDIUMLinux PAPR HVPIPE Race Condition Denial of Service
- CVE-2026-10006HIGHChrome WebAudio Race Condition Remote Code Execution
- CVE-2026-1220HIGHV8 Race Condition Type Confusion in Chrome – Patch Guidance
- CVE-2026-46157HIGHLinux Kernel ALSA PCM OSS Data Race Vulnerability
- CVE-2026-46275HIGHLinux Kernel Bluetooth HCI UART Use-After-Free & Race Condition Vulnerability