Skip to main content

Linux Kernel iavf EUVDEUVD-2026-24882

| CVE-2026-31505 HIGH
Out-of-bounds Write (CWE-787)
2026-04-22 416baaa9-dc9f-4396-8d5f-8c081fb06d67 GHSA-j72v-jx24-rm3p
7.8
CVSS 3.1 · Vendor: 416baaa9-dc9f-4396-8d5f-8c081fb06d67
View

Attack ChainAIDerived

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

  1. Access
    Gain local shell access
  2. Delivery
    Identify iavf interface
  3. Exploit
    Script concurrent ethtool operations
  4. Execution
    Trigger race condition during queue reconfiguration
  5. Persist
    Corrupt kernel memory via out-of-bounds write
  6. Impact
    Escalate privileges or crash system

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Privilege Escalation

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Requires local authenticated access with privileges to execute ethtool commands (typically root, CAP_NET_ADMIN, or netdev group membership). System must be running affected Linux kernel version (5.17 through unpatched 6.12.x/6.18.x/6.19.x/7.0) with active iavf driver managing Intel SR-IOV virtual function network interfaces. Exploitation depends on precise race condition timing achieved by executing 'ethtool -L' (channel reconfiguration) concurrently with 'ethtool -S' (statistics query) on the same iavf interface. Attack complexity is low (AC:L) from privilege perspective but timing precision increases practical difficulty. Does NOT require specific non-default configurations of iavf itself, though presence of SR-IOV virtual functions is inherent to iavf usage. No user interaction required beyond attacker's own commands. Limiting factor: race window is narrow and requires sustained concurrent operations to reliably trigger, making opportunistic exploitation difficult without scripted automation and multiple attempts.

Impact

CVSS vector indicates local attack requiring low privileges and no user interaction (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H) with 7.8 base score, suggesting significant impact if exploited. However, real-world risk is substantially lower based on convergent signals: EPSS probability of 0.02% (5th percentile) indicates minimal likelihood of widespread exploitation, no public exploit code exists, and CISA KEV does not list this vulnerability. The attack requires precise race condition timing between concurrent ethtool operations on the same iavf interface, which is operationally unlikely in production environments where network configuration changes are infrequent and administrative. Exploitation is further limited to local authenticated users with sufficient privileges to execute ethtool commands (typically root or CAP_NET_ADMIN). The vulnerability's discovery via KASAN testing rather than in-the-wild observation suggests low exploitability. While the integrity and availability impacts could enable local privilege escalation or denial of service in theory, practical exploitation faces significant timing constraints. Priority should be moderate for systems running affected kernel versions with iavf-enabled virtualized environments, particularly where multiple administrators perform concurrent network tuning operations.

Exploit ScenarioDerived

A local attacker with low-privilege access (e.g., member of netdev group or CAP_NET_ADMIN capability) on a virtualized Linux system using Intel SR-IOV initiates rapid channel reconfiguration via 'ethtool -L eth0 combined 8' while simultaneously scripting repeated 'ethtool -S eth0' statistics queries in a tight loop. The attacker times operations to exploit the race window between num_active_queues update and real_num_tx_queues synchronization, triggering out-of-bounds writes to vmalloc regions. By carefully crafting the timing and controlling the overflow content through specific queue configurations, the attacker could potentially corrupt adjacent kernel memory structures, leading to privilege escalation or denial of service. The KASAN detection mechanism in the description suggests detection in hardened kernels, but production systems without memory safety instrumentation remain vulnerable to silent memory corruption.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.0% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Apr 27, 2026

Out-of-bounds memory write in Linux kernel iavf (Intel Adaptive Virtual Function) driver allows local authenticated attackers with low privileges to achieve high confidentiality, integrity, and availability impact via race condition during concurrent ethtool operations. The vulnerability stems from inconsistent use of queue counters (real_num_tx_queues vs num_active_queues vs num_tx_queues) across ethtool statistics functions, enabling memory corruption when changing network channels via 'ethtool -L' while simultaneously querying statistics with 'ethtool -S'. Patches available for kernel versions 6.12.80, 6.18.21, 6.19.11, and 7.0. EPSS exploitation probability is low (0.02%, 5th percentile) with no public exploit or active exploitation identified at time of analysis.

RemediationAI

Upgrade to patched Linux kernel versions: 6.12.80 or later for 6.12.x series (commit bb85741d2dc2be207353a412f51b83697fcbefcf), 6.18.21 or later for 6.18.x series (commit fecacfc95f195b99c71c579a472120d0b4ed65fa), 6.19.11 or later for 6.19.x series (commit 1f931dee5b726df1940348ec31614d64bac03aa6), or 7.0 stable (commit fdf902bf86a80bf15792a1d20a67a5302498d7f1). Patches available from https://git.kernel.org/stable/c/ with commit IDs listed above. If immediate patching is not feasible, implement compensating controls: restrict ethtool command execution to dedicated maintenance windows with serialized operations, disable concurrent administrative sessions on iavf-enabled systems, or implement wrapper scripts enforcing mutex locks around ethtool -L and ethtool -S operations (though this introduces operational complexity and may impact monitoring tools). Monitor kernel logs for KASAN vmalloc-out-of-bounds reports as potential exploitation indicators. Note that disabling iavf entirely eliminates risk but breaks SR-IOV virtual function networking, unacceptable in most virtualized environments.

Affected VersionsENISA

Linux patch: 7.0
Linux patch: 6.12.80
Linux 64430f70ba6fcd5872ac190f4ae3ddee3f48f00d <bb85741d2dc2be207353a412f51b83697fcbefcf
Linux 64430f70ba6fcd5872ac190f4ae3ddee3f48f00d <1f931dee5b726df1940348ec31614d64bac03aa6
Linux patch: 6.19.11
Linux patch: 0
Linux 5.17
Linux patch: 6.18.21
Linux 64430f70ba6fcd5872ac190f4ae3ddee3f48f00d <fecacfc95f195b99c71c579a472120d0b4ed65fa
Linux 64430f70ba6fcd5872ac190f4ae3ddee3f48f00d <fdf902bf86a80bf15792a1d20a67a5302498d7f1

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 iavf driver manages Intel Adaptive Virtual Function (SR-IOV) network interfaces in virtualized environments. The vulnerability arises from a classic time-of-check-time-of-use (TOCTOU) race condition in the ethtool statistics implementation. Specifically, iavf_get_sset_count() and iavf_get_stat_strings() use real_num_tx_queues to determine buffer size allocation, while iavf_get_ethtool_stats() uses num_active_queues to populate statistics. Since real_num_tx_queues can change at runtime during queue reconfiguration, a race window exists where Thread 1 (ethtool -L changing channels from 1 to 8) updates num_active_queues to 8, Thread 3 (ethtool -S) allocates a buffer for only 1 queue based on the old real_num_tx_queues value, then attempts to write 8 queues of statistics into that undersized buffer before Thread 2's iavf_finish_config() updates real_num_tx_queues to 8. This triggers a vmalloc-out-of-bounds write condition detected by KASAN. The fix enforces use of immutable num_tx_queues across all ethtool statistics functions, eliminating the race condition. This affects kernel versions introducing commit 64430f70ba6f through patches in 6.12.80+, 6.18.21+, 6.19.11+, and 7.0+.

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

Vendor (416baaa9-dc9f-4396-8d5f-8c081fb06d67) PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
SUSE HIGH
Red Hat 6.1 MEDIUM

Primary rating from Vendor (416baaa9-dc9f-4396-8d5f-8c081fb06d67).

CVSS VectorVendor: 416baaa9-dc9f-4396-8d5f-8c081fb06d67

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

Lifecycle Timeline

4
Patch released
Apr 28, 2026 - 15:06 nvd
Patch available
CVSS changed
Apr 27, 2026 - 15:22 NVD
7.8 (HIGH)
Patch available
Apr 22, 2026 - 16:33 EUVD
CVE Published
Apr 22, 2026 - 14:16 nvd
HIGH 7.8

DescriptionCVE.org

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

iavf: fix out-of-bounds writes in iavf_get_ethtool_stats()

iavf incorrectly uses real_num_tx_queues for ETH_SS_STATS. Since the value could change in runtime, we should use num_tx_queues instead.

Moreover iavf_get_ethtool_stats() uses num_active_queues while iavf_get_sset_count() and iavf_get_stat_strings() use real_num_tx_queues, which triggers out-of-bounds writes when we do "ethtool -L" and "ethtool -S" simultaneously [1].

For example when we change channels from 1 to 8, Thread 3 could be scheduled before Thread 2, and out-of-bounds writes could be triggered in Thread 3:

Thread 1 (ethtool -L) Thread 2 (work) Thread 3 (ethtool -S) iavf_set_channels() ... iavf_alloc_queues() -> num_active_queues = 8 iavf_schedule_finish_config() iavf_get_sset_count() real_num_tx_queues: 1 -> buffer for 1 queue iavf_get_ethtool_stats() num_active_queues: 8 -> out-of-bounds! iavf_finish_config() -> real_num_tx_queues = 8

Use immutable num_tx_queues in all related functions to avoid the issue.

[1] BUG: KASAN: vmalloc-out-of-bounds in iavf_add_one_ethtool_stat+0x200/0x270 Write of size 8 at addr ffffc900031c9080 by task ethtool/5800

CPU: 1 UID: 0 PID: 5800 Comm: ethtool Not tainted 6.19.0-enjuk-08403-g8137e3db7f1c #241 PREEMPT(full) Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS 1.16.3-debian-1.16.3-2 04/01/2014 Call Trace: <TASK> dump_stack_lvl+0x6f/0xb0 print_report+0x170/0x4f3 kasan_report+0xe1/0x180 iavf_add_one_ethtool_stat+0x200/0x270 iavf_get_ethtool_stats+0x14c/0x2e0 __dev_ethtool+0x3d0c/0x5830 dev_ethtool+0x12d/0x270 dev_ioctl+0x53c/0xe30 sock_do_ioctl+0x1a9/0x270 sock_ioctl+0x3d4/0x5e0 __x64_sys_ioctl+0x137/0x1c0 do_syscall_64+0xf3/0x690 entry_SYSCALL_64_after_hwframe+0x77/0x7f RIP: 0033:0x7f7da0e6e36d ... </TASK>

The buggy address belongs to a 1-page vmalloc region starting at 0xffffc900031c9000 allocated at __dev_ethtool+0x3cc9/0x5830 The buggy address belongs to the physical page: page: refcount:1 mapcount:0 mapping:0000000000000000 index:0xffff88813a013de0 pfn:0x13a013 flags: 0x200000000000000(node=0|zone=2) raw: 0200000000000000 0000000000000000 dead000000000122 0000000000000000 raw: ffff88813a013de0 0000000000000000 00000001ffffffff 0000000000000000 page dumped because: kasan: bad access detected

Memory state around the buggy address: ffffc900031c8f80: f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 ffffc900031c9000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 >ffffc900031c9080: f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 ^ ffffc900031c9100: f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 ffffc900031c9180: f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8 f8

Executive ViewAI

Why It Matters

CVE-2026-31505 is a local privilege escalation vulnerability in the Linux kernel iavf driver that allows authenticated users with low privileges to corrupt system memory through a race condition, potentially compromising system confidentiality, integrity, and availability. Organizations running affected kernel versions on systems with iavf-dependent network virtualization must prioritize patching to prevent local attackers from achieving kernel-level code execution.

Business Impact: High
Compensating Controls

Apply vendor patch. Until patching is complete, restrict local user access to ethtool operations via sudo rules (disable 'ethtool -L' and 'ethtool -S' for non-root users), disable concurrent network channel modifications during production operations, and monitor for unusual process behavior or system crashes that may indicate exploitation attempts.

Threat Intelligence Overview

EPSS Score
0.0%
Top 95% exploitable
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 HIGH
CISA KEV No
Public POC No
EPSS 0.0%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
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
Small
Automatable· derived
No
Human Impact
High

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.

Vendor StatusVendor

SUSE

Severity: High
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Fixed
SUSE Linux Enterprise Desktop 15 SP7 Fixed
SUSE Linux Enterprise High Availability Extension 15 SP7 Fixed
SUSE Linux Enterprise High Availability Extension 15 SP7 Fixed
SUSE Linux Enterprise High Performance Computing 15 SP7 Fixed

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