Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessReach adjacent DPAA2 switch network segment
-
Deliveryinduce receive error in dpaa2_switch_rx()
-
Exploiterror path calls dpaa2_switch_free_fd() on Rx FD
-
Executiondev_kfree_skb() runs on page (non-skb) pointer
-
Impactkernel memory corruption / denial of service
Vulnerability Assessment
| Exploitation Conditions | Exploitation requires a system running the Linux dpaa2-switch driver, i.e. NXP DPAA2/Layerscape hardware with the DPAA2 Ethernet switch in use - this is the key limiting factor and excludes the vast majority of Linux deployments. The attacker must be on the adjacent network segment (AV:A) and must drive dpaa2_switch_rx() into its error path during frame reception so that the incorrect dpaa2_switch_free_fd() call executes; the available sources do not state exactly what input produces that receive error, and CVSS AC:H indicates triggering it reliably is not straightforward. No authentication or user interaction is required (PR:N/UI:N), but the bug lives only in the Rx error branch, not the default success path. |
| Impact | Signals are consistent and point to a moderate, not urgent, priority. The supplied CVSS is 7.5 (AV:A/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H): adjacent-network, unauthenticated, no user interaction, but high attack complexity. EPSS is low at 0.21% (11th percentile) and there is no CISA KEV listing and no public exploit reference, so this is exploitation status 'no public exploit identified at time of analysis'. The vuln.today decision label is 'this_week', which aligns with a real-but-not-emergency fix cadence rather than act_now. The dominant caveat is scope of affected code: although tagged generically as 'Linux', the flaw is confined to the NXP DPAA2 Ethernet switch driver (dpaa2-switch), present only on specific NXP Layerscape/DPAA2 hardware, so real-world exposure is far narrower than the 'Linux kernel' label implies. The supplied C:H/I:H/A:H impact is also optimistic: the described defect is an invalid free (the Rx error path wrongly calls dpaa2_switch_free_fd(), which expects a Tx skb pointer in the software-annotation area), whose demonstrable consequence is kernel memory corruption/crash rather than a confirmed confidentiality read primitive. The 'Information Disclosure' tag is inconsistent with this wrong-free mechanism - verify impact classification with the kernel changelog. Net: genuine memory-safety bug worth patching on affected NXP hardware, but AC:H plus niche deployment make widespread opportunistic exploitation unlikely. |
| Exploit ScenarioDerived | An attacker on the Ethernet segment handled by an NXP DPAA2 switch sends traffic that forces an error during frame reception in dpaa2_switch_rx(); the error path incorrectly frees the receive buffer as if it were a transmit skb, calling dev_kfree_skb() on a non-skb (page) pointer and corrupting kernel memory, typically crashing the host. No public exploit code or PoC is identified at time of analysis, and the CVSS AC:H reflects that reliably triggering the error path is non-trivial. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 24, 2026
An error-path defect in the Linux kernel's dpaa2-switch driver allows an attacker on the adjacent network to push a received frame into the driver's failure branch, where the wrong cleanup helper is invoked on a receive frame descriptor. The result is memory corruption and potential kernel crash on systems running the NXP DPAA2 Ethernet switch, affecting kernel versions before the fixes in 5.15.222, 6.1.189, 6.6.158, 6.12.111 and 6.18.53 (mainline 7.2). Exposure is narrow - only NXP DPAA2/Layerscape hardware actively using this switch driver is affected - and the assessed vector is AV:A/AC:H/PR:N/UI:N with low integrity and high availability impact; EPSS is low at 0.21% (11th percentile), no CISA KEV entry and no public exploit identified at time of analysis.
RemediationAI
Vendor-released patch: upgrade to Linux 5.15.222, 6.1.189, 6.6.158, 6.12.111, 6.18.53 or mainline 7.2 (or later), which contain the stable-queue commits linked from the CVE record: https://git.kernel.org/stable/c/74c1c9f5c0c30bbd0c2cf87b6e3507e7ea46c13d, https://git.kernel.org/stable/c/791068c962469af0090e1a1ee63657fb9eef40db, https://git.kernel.org/stable/c/ee54f8d7e642c44cfcc2dcb390b4c50e145d81b8, https://git.kernel.org/stable/c/259ad6093204b999d41e7e6d0ad90ef9a71a44ab, https://git.kernel.org/stable/c/f4ceb8e3d6d5becb4cda7a7098a8638e18c835a1 and https://git.kernel.org/stable/c/fa232b4496cb59503ae5108c756cbe10e59b0bc3. Distribution kernels that backport the dpaa2-switch fix should be preferred where a vendor kernel is in use; the CVE record and https://nvd.nist.gov/vuln/detail/CVE-2026-98911 plus https://vuldb.com/vuln/425747 track those mappings. Because exploitation is confined to the receive error branch on NXP DPAA2/Layerscape hardware, the only reliable fix is the patched driver; where the update cannot be applied immediately, the practical exposure reduction is to keep untrusted traffic off the adjacent segment served by the DPAA2 switch ports and to avoid running the affected switch driver on untrusted network paths, accepting the loss of the switch's hardware-offload connectivity that this implies. No workaround other than the corrected driver is documented in the available sources.
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
DPAA2 (Data Path Acceleration Architecture 2) is NXP's hardware offload framework for Layerscape SoCs, and dpaa2-switch drives the embedded Ethernet switch that manages the DPNI/DPBPs on those devices. Frames move through the driver as frame descriptors (FDs) carrying a software annotation area used to stash metadata such as a pointer to the associated skb; transmit FDs are cleaned up by dpaa2_switch_free_fd(), which reads that annotation and calls dev_kfree_skb() on what it finds. The receive path in dpaa2_switch_rx() had reused that Tx-oriented helper as its error handler, so an Rx failure occurring before an skb was ever allocated resulted in teardown operating on a descriptor whose annotation did not hold a valid skb reference. The upstream fix restructures the flow: the dma_unmap_page() call is lifted out of dpaa2_switch_build_linear_skb() into dpaa2_switch_rx() itself, letting the error branch call free_pages() when no skb exists yet and kfree_skb() only after an skb has been created. No CWE identifier is assigned in the supplied data; the class is a receive-path error-handling flaw abusing a Tx-specific cleanup routine. The sources do not describe precisely which receive condition drives execution into the failing branch, and the high attack complexity metric reflects that triggering it reliably is not straightforward.
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:A/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
Adjacent because the driver processes received frames; AC:H as it needs the Rx error path; the confirmed effect is an invalid free causing crash (A:H) with limited corruption (I:L) and no read primitive (C:N).
Primary rating from Vendor (Linux).
CVSS VectorVendor: Linux
Lifecycle Timeline
4DescriptionCVE.org
In the Linux kernel, the following vulnerability has been resolved:
dpaa2-switch: fix the error path in dpaa2_switch_rx()
In case of an error in dpaa2_switch_rx(), the dpaa2_switch_free_fd() function is called in order to free the FD. This is incorrect since the dpaa2_switch_free_fd() is intended to be used on Tx frame descriptors, meaning that it expects in the software annotation area of the FD data to find a valid skb pointer on which to call dev_kfree_skb().
Fix this by extracting the dma_unmap_page() from dpaa2_switch_build_linear_skb() directly into the dpaa2_switch_rx() function. This allows us to directly use free_pages() in case of an error before an SKB was created and kfree_skb() afterwards.
Executive ViewAI
A high-severity vulnerability in the Linux kernel's NXP DPAA2 switch driver can cause memory corruption and potential kernel crashes when processing frames from adjacent networks. Organizations using NXP DPAA2/Layerscape hardware in networking or embedded roles face operational disruption; leadership should care due to the potential for service outages and the need to patch affected systems promptly, though exploit likelihood is currently low.
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-108867
GHSA-2gxg-jvpv-v5rf
NVD
CVE.org
EPSS
VulDB
Exploit-DB