Skip to main content

Linux dpaa2-switch CVE-2026-98911

| EUVDEUVD-2026-108867 HIGH
2026-10-23 Linux GHSA-2gxg-jvpv-v5rf
7.5
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Reach adjacent DPAA2 switch network segment
  2. Delivery
    induce receive error in dpaa2_switch_rx()
  3. Exploit
    error path calls dpaa2_switch_free_fd() on Rx FD
  4. Execution
    dev_kfree_skb() runs on page (non-skb) pointer
  5. Impact
    kernel 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.

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

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

Alert me

AnalysisAIv1 – 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

Linux patch: 7.2
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <791068c962469af0090e1a1ee63657fb9eef40db
Linux 0 <6.12.111
Linux patch: 6.6.158
Linux 0 <6.18.53
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <259ad6093204b999d41e7e6d0ad90ef9a71a44ab
Linux patch: 6.18.53
Linux patch: 5.15.222
Linux 0 <6.6.158
Linux 0 <6.1.189
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <74c1c9f5c0c30bbd0c2cf87b6e3507e7ea46c13d
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <f4ceb8e3d6d5becb4cda7a7098a8638e18c835a1
Linux patch: 6.1.189
Linux patch: 6.12.111
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <fa232b4496cb59503ae5108c756cbe10e59b0bc3
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <ee54f8d7e642c44cfcc2dcb390b4c50e145d81b8
Linux 0 <5.15.222

Affected Packages

euvd linux fix: 5.15.222, 6.1.189, 6.6.158, 6.12.111, 6.18.53

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

Vendor (Linux) PRIMARY 7.5 HIGH
AV:A/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 5.9 MEDIUM

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).

3.1 AV:A/AC:H/PR:N/UI:N/S:U/C:N/I:L/A:H
4.0 AV:A/AC:H/AT:N/PR:N/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (Linux).

CVSS VectorVendor: Linux

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

Lifecycle Timeline

4
CVSS changed
Oct 24, 2026 - 14:22 NVD
7.5 (HIGH)
Patch available
Oct 23, 2026 - 13:17 EUVD
CVE Published
Oct 23, 2026 - 11:54 cve.org
HIGH 7.5
CVE Published
Oct 23, 2026 - 11:54 cve.org
UNKNOWN (no severity yet)

DescriptionCVE.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

Why It Matters

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.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Low
driver limited to NXP DPAA2 switch hardware; niche embedded networking footprint
Data Quality
5 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.2%
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
Controlled
Automatable· derived
No
Human Impact
Medium

Priority Score

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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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