Skip to main content

Linux Kernel EUVDEUVD-2026-86166

| CVE-2026-93287 HIGH
2026-09-24 Linux GHSA-9m6w-7g2q-r25c
7.8
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Gain local access to /dev/i2c device
  2. Delivery
    Craft SMBUS ioctl with oversized block[0] length
  3. Exploit
    Reach unvalidated tracepoint memcpy or native smbus_xfer callback
  4. Execution
    Trigger out-of-bounds read past 34-byte buffer
  5. Impact
    Kernel info disclosure or crash (DoS)

Vulnerability Assessment

Exploitation Conditions

Requires local access to an SMBus/I2C interface exposed via /dev/i2c-* (i2cdev), which on most systems is restricted to root or an i2c group, and the ability to issue I2C_SMBUS ioctls with a caller-supplied block length. The two demonstrated bugs each need a non-default configuration: Bug 1 requires SMBus tracepoints/tracing to be enabled so trace_smbus_write() fires before validation; Bug 2 requires the i2c-stub testing module to be loaded (its stub_xfer only clamps against 256-command, not I2C_SMBUS_BLOCK_MAX). More generally, any adapter whose native .smbus_xfer callback trusts the caller-supplied block[0] is reachable, but that depends on the specific hardware/driver present. Default production kernels without tracing enabled, without i2c-stub, and without unprivileged /dev/i2c access are not readily exploitable.

Impact

The provided CVSS 3.1 vector (AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H, 7.8) marks this as a local, low-privilege, high-impact kernel memory-safety flaw. That base score overstates real-world urgency once the multi-source signals are weighed. There is no CISA KEV listing, no EPSS score provided, and no public exploit code in the intelligence set - the crash traces in the description are the reporter's own KASAN/UBSAN reproductions on v7.0-rc6, not weaponized public POCs. Both demonstrated bugs are also gated by non-default conditions: Bug 1 (smbus_write tracepoint OOB) only fires when SMBus tracepoints/tracing are enabled, and Bug 2 requires the i2c-stub debug module (a test-only driver) to be loaded. The demonstrated primitives are out-of-bounds READS (KASAN 'stack-out-of-bounds' read, UBSAN 'array-index-out-of-bounds'), which supports C:H and A:H (crash) but makes NVD's I:H questionable. Exploitation also presupposes access to /dev/i2c-* character devices, which are typically restricted to root or an i2c group, consistent with PR:L but further narrowing the realistic attacker population. Net: a legitimate defense-in-depth kernel hardening fix, but a moderate/low real-world priority rather than an emergency - no active exploitation, no public exploit, and non-default preconditions for the demonstrated paths.

Exploit ScenarioDerived

A local user with access to an /dev/i2c-* device issues an I2C_SMBUS ioctl supplying an oversized block length (e.g. block[0]=0xfe or 0xff) for a caller-supplied block write/transfer. On a kernel with SMBus tracepoints enabled or the i2c-stub module loaded, this drives an out-of-bounds memory access (255-byte copy into a 34-byte buffer / array index past the union), leaking adjacent kernel memory or crashing the system. No public exploit code is provided; the description contains only the reporter's KASAN/UBSAN reproduction traces.

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

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

Alert me

AnalysisAIv1 – Sep 25, 2026

Oversized SMBus block transfers in the Linux kernel I2C subsystem can reach tracepoints and native driver callbacks without ever being validated against I2C_SMBUS_BLOCK_MAX, allowing local memory corruption and out-of-bounds reads. The flaw is fixed by adding an early length check in __i2c_smbus_xfer(), which previously deferred validation to i2c_smbus_xfer_emulated() - too late for the smbus_write tracepoint and skipped entirely by adapters that supply a native .smbus_xfer implementation. The independently assessed vector (AV:L/AC:H/PR:L/UI:N/S:U/C:H/I:N/A:H) reflects that exploitation requires local access to an /dev/i2c-* interface plus a non-default configuration - SMBus tracing enabled (Bug 1) or the i2c-stub testing module loaded (Bug 2) - and default production kernels without tracing, i2c-stub, or unprivileged i2cdev access are not readily exploitable; no public exploit code was identified at time of analysis.

RemediationAI

Vendor-released patch: Linux 6.12.111, 6.18.53 and 7.1, carrying the upstream commits 4710317891e4824ce1510a6b5066abbd3e917750 (mainline) plus stable backports c4b478bc50b7ca9865e237909941253a0f7111a2, f09edffba97d37b1fdff5f818a9a45f8a98ac171 and 3051cd060fa496df42954291fa2306ed2eab4ecc, referenced at https://git.kernel.org/stable/c/c4b478bc50b7ca9865e237909941253a0f7111a2 and https://git.kernel.org/stable/c/3051cd060fa496df42954291fa2306ed2eab4ecc; apply the kernel update or backport the early __i2c_smbus_xfer() length check. Where immediate patching is not possible, the demonstrated attack paths can be closed by configuration: do not load the i2c-stub module on production systems (blacklist it - it is a development/testing driver, and removing it eliminates the Bug 2 stub_xfer overflow, though it also removes a debugging aid), and keep SMBus tracepoints disabled in production so trace_smbus_write() cannot fire before validation (a trade-off in observability/tracing coverage). Most broadly, restrict access to /dev/i2c-* to root only or to a tightly controlled i2c group, since the assessed vector requires local access to an i2cdev interface; this does not fix the underlying bug but removes the unprivileged trigger, and it will break legitimate userspace tools that rely on group access to the I2C bus. Note that these mitigations do not address adapters whose native .smbus_xfer callback trusts caller-supplied block lengths, so patching remains the definitive fix.

Affected VersionsENISA

Linux patch: 6.12.111
Linux patch: 7.1
Linux patch: 6.18.53
Linux 2.6.33
Linux 4710317891e4824ce1510a6b5066abbd3e917750 <f09edffba97d37b1fdff5f818a9a45f8a98ac171
Linux 4710317891e4824ce1510a6b5066abbd3e917750 <3051cd060fa496df42954291fa2306ed2eab4ecc
Linux patch: 0
Linux 4710317891e4824ce1510a6b5066abbd3e917750 <c4b478bc50b7ca9865e237909941253a0f7111a2

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 vulnerability lives in the kernel's SMBus/I2C transfer layer, specifically the i2c_smbus_data union whose block field is a fixed __u8 block[I2C_SMBUS_BLOCK_MAX + 2] (34 bytes, with I2C_SMBUS_BLOCK_MAX = 32). Callers reach this path through the i2cdev character device: i2cdev_ioctl() -> i2cdev_ioctl_smbus() -> i2c_smbus_xfer() -> __i2c_smbus_xfer(). Historically, the zero-or-oversized block length (data->block[0]) was only rejected in i2c_smbus_xfer_emulated(), which is too late because the smbus_write tracepoint in include/trace/events/smbus.h fires first and memcpy's block[0]+1 bytes into a 34-byte event buffer - with block[0]=0xfe that is 255 bytes, a 221-byte stack out-of-bounds write. Adapters that provide a native .smbus_xfer callback bypass the emulated path entirely, so the check never ran at all; the i2c-stub test driver's stub_xfer() only clamped block[0] against 256-command rather than I2C_SMBUS_BLOCK_MAX, so with block[0]=0xff and command=0 its loop indexes block[1+i] for i up to 254, well past the 34-byte union (UBSAN: index 34 out of range). The fix adds an early rejection in __i2c_smbus_xfer() scoped to operations where the length is actually caller-supplied (SMBus block reads fill block[0] from the device, so they are excluded), preserving the existing -EINVAL convention and protecting all downstream consumers at once. The underlying defect class is improper input validation of a caller-controlled length leading to out-of-bounds read/write; CWE was not supplied by the source data, but the pattern maps to CWE-20/CWE-125/CWE-787.

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 (Linux) PRIMARY 7.8 HIGH
AV:L/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 6.3 MEDIUM

Local /dev/i2c access is privileged (PR:L); demonstrated paths need tracing enabled or i2c-stub loaded (AC:H); OOB read yields memory disclosure (C:H) and crash (A:H) but no clear integrity impact (I:N).

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

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

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

Lifecycle Timeline

4
CVSS changed
Sep 25, 2026 - 05:23 NVD
7.8 (HIGH)
Patch available
Sep 24, 2026 - 17:03 EUVD
CVE Published
Sep 24, 2026 - 16:02 cve.org
HIGH 7.8
CVE Published
Sep 24, 2026 - 16:02 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.org

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

i2c: smbus: reject oversized block transfers in the common path

The SMBus block transfer length data->block[0] is validated in i2c_smbus_xfer_emulated() but that check runs too late for tracepoints and is skipped entirely when the adapter provides a native smbus_xfer implementation. This allows user-controlled oversized block lengths to reach tracepoint memcpy calls and driver callbacks unchecked.

Add an early validation in __i2c_smbus_xfer() that rejects block transfers whose caller-supplied length is zero or exceeds I2C_SMBUS_BLOCK_MAX before any tracepoint fires or driver callback runs. data->block[0] is filled in by the device on SMBus block reads, so the check is scoped to operations where the length is actually supplied by the caller. This is consistent with the existing -EINVAL convention in the emulated path and protects all downstream consumers at once: the smbus_write tracepoint, all native smbus_xfer driver implementations, and the emulated path.

Two distinct bugs are fixed by this change:

Bug 1: smbus_write tracepoint OOB (include/trace/events/smbus.h) trace_smbus_write() fires before any validation and copies data->block[0]+1 bytes into a 34-byte event buffer. With block[0]=0xfe the tracepoint copies 255 bytes, overflowing by 221.

BUG: KASAN: stack-out-of-bounds in trace_event_raw_event_smbus_write+0x27c/0x530 Read of size 255 at addr ffff88800d98fcf8 by task poc_smbus/91 Call Trace: <TASK> __asan_memcpy+0x23/0x80 trace_event_raw_event_smbus_write+0x27c/0x530 __i2c_smbus_xfer+0x43a/0xa40 i2c_smbus_xfer+0x19e/0x340 i2cdev_ioctl_smbus+0x38f/0x7f0 i2cdev_ioctl+0x35e/0x680 __x64_sys_ioctl+0x147/0x1e0 do_syscall_64+0xcf/0x15a0 entry_SYSCALL_64_after_hwframe+0x76/0x7e </TASK>

Bug 2: i2c-stub I2C_SMBUS_I2C_BLOCK_DATA OOB (drivers/i2c/i2c-stub.c) stub_xfer() implements .smbus_xfer directly and only clamps block[0] against 256-command, not I2C_SMBUS_BLOCK_MAX. With block[0]=0xff and command=0 the loop accesses block[1+i] for i up to 254, far past the 34-byte union.

UBSAN: array-index-out-of-bounds in drivers/i2c/i2c-stub.c:223:44 index 34 is out of range for type '__u8 [34]' Call Trace: <TASK> __ubsan_handle_out_of_bounds+0xd7/0x120 stub_xfer+0x1971/0x198f [i2c_stub] __i2c_smbus_xfer+0x306/0xa40 i2c_smbus_xfer+0x19e/0x340 i2cdev_ioctl_smbus+0x38f/0x7f0 i2cdev_ioctl+0x35e/0x680 __x64_sys_ioctl+0x147/0x1e0 do_syscall_64+0xcf/0x15a0 entry_SYSCALL_64_after_hwframe+0x76/0x7e </TASK>

Both traces reproduced on v7.0-rc6+i2c/for-current with KASAN+UBSAN.

Executive ViewAI

Why It Matters

A high-severity vulnerability in the Linux kernel I2C subsystem can allow a local authenticated user with low privileges to cause memory corruption or out-of-bounds reads, but only when non-default configurations such as SMBus tracing or the i2c-stub testing module are enabled and /dev/i2c-* interfaces are accessible. Default production kernels without those configurations are not readily exploitable, and no public exploit code was identified at time of analysis. Leadership should care because unpatched embedded, OT, or engineering Linux systems with those configurations could expose sensitive local data or provide a foothold for further compromise, even though broader enterprise risk is limited.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Ubiquitous
Linux kernel runs almost everywhere, though the vulnerable i2c/SMBus ioctl path is niche
Data Quality
4 sources
Confidence: Medium

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.1%
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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
Medium

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.

Vendor StatusVendor

SUSE

Severity: Moderate
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