Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach host on LAN743x interface
-
DeliveryTransient window after live MTU increase
-
ExploitSend multi-buffer (oversized) frame
-
ExecutionUAF write on checksum path
-
ImpactKernel heap corruption / crash
Vulnerability Assessment
| Exploitation Conditions | Exploitation requires the host to use a Microchip LAN743x (lan7430/lan7431) Ethernet controller and is limited to the specific path lan743x_rx_process_buffer() → lan743x_rx_trim_skb(). The bug ONLY triggers when a single received packet spans more than one RX buffer (frag_list is populated), which per the description occurs only transiently after a live MTU increase, because existing ring entries keep their old (smaller) buffer size until replenished. Limiting factors: the attacker does not control the MTU change (operator action), the vulnerable window is short-lived until the ring is refilled, and the driver's presence is hardware-dependent. Per CVSS PR:N the attacker is unauthenticated, but reaching the RX path realistically requires same-segment/adjacent network access to deliver oversized frames. |
| Impact | Signals are mixed and point to a LOW real-world priority despite the high 8.1 CVSS. The CVSS vector (AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H) rates full Confidentiality/Integrity/Availability impact with high attack complexity, which is why the base score is high. However, EPSS is only 0.18% (7th percentile), the CVE is NOT on CISA KEV, and no public exploit code is identified - so exploitation probability is very low. Crucially, the high CVSS C:H/I:H/A:H impact is a theoretical ceiling for a one-byte kernel-heap use-after-free write; translating that into reliable disclosure or code execution is non-trivial. The dominant mitigating factor is the narrow trigger window: the bug only manifests on multi-buffer receives, which the description says occur only after a live MTU increase while stale ring entries retain their old buffer size. That is an operator-initiated, transient condition the attacker does not control, so AC:H is well-justified and arguably understates the difficulty. Conflict to verify with vendor: AV:N implies remote network triggering, but the vulnerability is confined to the niche Microchip LAN743x Ethernet driver AND depends on an administrator having just changed the MTU - effectively a local/operational precondition that the AV:N metric does not capture. |
| Exploit ScenarioDerived | An attacker on the same L2 segment as a host using a Microchip LAN743x NIC waits for (or induces) a live MTU increase on that interface, then sends frames large enough to span multiple RX buffers before the ring is replenished, triggering a use-after-free write in lan743x_rx_process_buffer() on the checksum-success path. In the best case for the attacker this corrupts kernel heap memory adjacent to the freed fragment skb, potentially leading to a crash (DoS) or, far less reliably, memory corruption. No public exploit exists; the only demonstrated trigger is an in-tree KUnit test using a two-buffer packet, and the fix was never validated on physical hardware. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 07, 2026
A use-after-free write in the Linux kernel's lan743x Ethernet driver (Microchip LAN7430/LAN7431) lets a packet that spans more than one RX buffer trigger a kernel memory corruption through a stale skb pointer in the checksum-success path of lan743x_rx_process_buffer(), with the flawed write landing on freed fragment skb metadata. According to the vendor description this multi-buffer condition only arises transiently after an operator performs a live MTU increase, because existing ring entries retain their old, smaller buffer size until they are replenished; the vulnerable driver must be present and the host must be using that specific Microchip hardware. Vendor patches are available in the stable trees (6.1.189, 6.6.158, 6.12.112, 6.18.54, 7.2.8 and 7.3-rc4), EPSS is low at 0.18% (7th percentile), and no public exploit code or CISA KEV activity was identified at time of analysis; our independent assessment rates real-world priority LOW despite the vendor-supplied 8.1 CVSS because exploitation is gated on hardware, a concurrent operator-initiated MTU change, and a short-lived window.
RemediationAI
Apply the vendor-released kernel updates: move to 6.1.189, 6.6.158, 6.12.112, 6.18.54, 7.2.8 or 7.3-rc4 (or later), or cherry-pick the corresponding stable commit from https://git.kernel.org/stable/c/161a403c8625e152de03d1da22bbf9cda6dc9f9f and its siblings against your baseline; the fix simply writes ip_summed to the surviving head skb instead of the freed fragment, so it carries minimal regression risk. If patching must be delayed, the most effective compensating control is to avoid live MTU increases on LAN743x-equipped hosts - bring the interface down and up (or otherwise force the RX ring to be fully replenished) so no packet can arrive while old, smaller ring buffers are still in place, at the cost of brief link interruption and service blips. As a secondary measure you can disable RX checksum offload on the affected interface (ethtool -K <iface> rx off), which avoids the checksum-success branch that performs the bad write; the trade-off is higher CPU utilization and loss of hardware checksum validation. Reducing untrusted same-segment/adjacent L2 reachability limits who can deliver the oversized frames needed to populate frag_list, but it does not remove the bug; there is no module parameter or configuration switch that safely removes the driver while LAN743x hardware remains in use.
Affected VersionsENISA
Affected Packages
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 defect lives in the receive path of the lan743x PCIe Gigabit Ethernet driver, specifically the interaction between lan743x_rx_process_buffer() and lan743x_rx_trim_skb(). When the NIC delivers a packet that is split across multiple RX buffers, the non-first buffers are chained onto the head skb's frag_list. On the final descriptor, lan743x_rx_trim_skb() linearizes the head skb and frees the fragment skb metadata. The checksum-success branch then writes ip_summed through a local skb pointer that still references that freed final fragment, producing a use-after-free write (the root-cause class is CWE-416, use-after-free; no CWE was supplied in the input). A KUnit test driving lan743x_rx_process_buffer() with a two-buffer packet reproduced a one-byte KASAN use-after-free write before the fix and passed afterwards, and the driver builds cleanly with W=1; the change was not validated on physical LAN743x hardware. The fix redirects the ip_summed assignment to the surviving head skb. The critical precondition is that a single packet spans more than one receive buffer so frag_list is actually populated, which per the description happens only transiently after a live MTU increase while old ring entries are still being replenished. CPE data identifies the impacted platform as cpe:2.3:a:linux:linux:*:*:*:*:*:*:*:*, i.e. the upstream kernel rather than a standalone driver package.
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
AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
Packet-triggered so AV:N/PR:N; AC:H because it needs the transient post-MTU-increase multi-buffer window; one-byte UAF write gives high integrity/availability but limited confidentiality.
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
net: lan743x: fix RX checksum use-after-free
lan743x_rx_process_buffer() adds each non-first receive buffer to the head skb's frag_list. On the last descriptor, lan743x_rx_trim_skb() linearizes the head and frees the fragment skb metadata.
The checksum-success path then writes ip_summed through the local skb pointer, which still points to the final fragment. This causes a use-after-free write when a packet spans more than one receive buffer.
Set ip_summed on the surviving head skb instead. Multi-buffer receive can occur after a live MTU increase because existing ring entries keep their old buffer size until they are replenished.
A KUnit test invoking lan743x_rx_process_buffer() with a two-buffer packet produced a one-byte KASAN use-after-free write before this change. The same test passed after the change. The driver object also builds with W=1. This was not tested on physical LAN743x hardware.
Executive ViewAI
A memory-corruption flaw in the Linux kernel's lan743x driver affects only systems running Microchip LAN7430/LAN7431 Ethernet adapters, and only transiently after an operator performs a live MTU increase on those interfaces. Successful triggering could crash or corrupt the kernel on the affected host, but no public exploit code or active exploitation has been identified and real-world likelihood is low. Leadership should treat this primarily as a fleet hygiene item for systems using this specific network hardware rather than an urgent enterprise-wide exposure.
Apply vendor patch.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
EUVD-2026-93167
GHSA-qcgj-xcvr-2727
NVD
CVE.org
EPSS
Exploit-DB