Skip to main content

Linux Kernel CVE-2026-97451

| EUVDEUVD-2026-86064 HIGH
2026-09-24 Linux GHSA-w3m4-cvqw-754j
8.4
CVSS 3.1 · Vendor: Linux
View

Attack ChainAIDerived

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

  1. Access
    Gain firmware/root ability to load AML
  2. Delivery
    Craft Mid() with overflowing Index+Length
  3. Exploit
    Interpreter computes negative length
  4. Execution
    memcpy() with wrapped size
  5. Impact
    Kernel memory corruption / panic

Vulnerability Assessment

Exploitation Conditions

Requires the ability to have the kernel's ACPI interpreter execute attacker-controlled AML containing a crafted Mid() (three-operand) operation - realistically via malicious/crafted ACPI firmware tables (DSDT/SSDT) or a privileged path such as debugfs custom_method (root/CAP_SYS_ADMIN). It is NOT reachable by an ordinary unprivileged local user against a default configuration, and it is not remotely reachable. Limiting factors: needs firmware control or root-equivalent access to inject AML, the operand values must be chosen so Index+Length overflows, and vulnerable kernels are those before 6.12.111 / 6.18.53 / 7.2. Impact is dominated by kernel memory corruption and crash (denial of service).

Impact

The NVD CVSS of 8.4 (AV:L/AC:L/PR:N/UI:N/C:H/I:H/A:H) overstates real-world risk for this class of Linux-kernel ACPICA flaw. The bug is an integer overflow in the AML interpreter's Mid() operator (acpi_ex_opcode_3A_1T_1R), where an unchecked Index+Length yields a negative/oversized size passed to memcpy() - a memory-corruption/crash primitive, not a disclosure. Critically, reaching this code path requires executing attacker-influenced AML bytecode, which only comes from ACPI firmware tables (DSDT/SSDT) loaded at boot or from a root-loaded custom_method - so PR:N is misleading; a normal unprivileged local user cannot supply arbitrary AML operands. There is no EPSS score, no CISA KEV listing, and no public POC, so there is no evidence of active or imminent exploitation. Net: this is a legitimate hardening fix but a low-priority, crash-dominant, high-prerequisite issue rather than a high-severity threat. Conflicting signal to verify with vendor: CVSS marks PR:N/AC:L, yet the description implies the operands originate from AML that must be loaded via firmware or privileged interfaces - treat the PR:N/AC:L rating as optimistic.

Exploit ScenarioDerived

An attacker able to supply malicious ACPI tables - through control of platform firmware/a crafted DSDT-SSDT, or via a root-privileged custom_method write - crafts a Mid() operation with Index and Length values whose sum overflows. When the interpreter computes the truncation length it passes a negative (wrapped huge) size to memcpy(), corrupting kernel memory or crashing the system. No public exploit code is known at time of analysis.

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

Integer overflow in the Linux kernel's ACPICA AML interpreter allows memory corruption and a likely kernel crash when a crafted Mid() (three-operand) AML operation is evaluated with operand values chosen so that Index + Length wraps around. Affected are Linux kernels before 6.12.111, before 6.18.53, and before 7.2 in the mainline tree, as tracked under CPE cpe:2.3:a:linux:linux and EUVD-2026-86064. This is not remotely reachable: exploitation realistically requires either the ability to supply malicious ACPI firmware tables (DSDT/SSDT) or root/CAP_SYS_ADMIN-level access such as via debugfs custom_method, so an ordinary unprivileged local user cannot trigger it on a default configuration; no public exploit has been identified at time of analysis, and vendor patches are available. Note that the NVD CVSS of 8.4 (AV:L/AC:L/PR:N/UI:N/C:H/I:H/A:H) overstates real-world risk for this class of Linux-kernel ACPICA flaw; our assessment rates it AV:L/AC:H/PR:H/UI:N with impact dominated by kernel memory corruption and denial of service rather than a realistic full confidentiality/integrity compromise.

RemediationAI

Vendor-released patches exist: upgrade to Linux 6.12.111, 6.18.53, or 7.2 (or the corresponding fixed stable/mainline releases), which include the overflow check introduced by upstream commits 0e2021f49e64b3c8a9aa880d0c62a218bfe147ce, d0d89f2e16a874e0f8fb17045da293e8bedf8b21 and b96401812cbfbb4803faabeefa1f20b8562268b3, referenced from https://git.kernel.org/stable/c/d0d89f2e16a874e0f8fb17045da293e8bedf8b21, https://git.kernel.org/stable/c/b96401812cbfbb4803faabeefa1f20b8562268b3 and https://git.kernel.org/stable/c/0e2021f49e64b3c8a9aa880d0c62a218bfe147ce; distribution users should apply their vendor's kernel update rather than building these versions directly, and consult https://nvd.nist.gov/vuln/detail/CVE-2026-97451 for the consolidated record. Where an immediate kernel update is not feasible, compensating controls should target the AML-injection preconditions rather than the bug itself: ensure the kernel is not built with CONFIG_ACPI_CUSTOM_METHOD so the /sys/kernel/debug/acpi/custom_method AML-injection path is unavailable (trade-off: removes a firmware/AML debugging aid relied on by some driver developers), and where the kernel supports it enforce kernel lockdown in confidentiality or integrity mode and keep Secure Boot enabled so runtime ACPI table override and custom_method are blocked (trade-off: lockdown also restricts other low-level debug and kexec/ioperm style functionality and can break development workflows). Because the bug is only reachable by code that can already load or override ACPI tables, restricting local administrative and firmware-level access (no unvetted root-equivalent delegation, physical and BMC/firmware flashing controls) is a meaningful reduction in exposure. There is no configuration toggle that disables the AML Mid() operator, so patching remains the only complete fix.

Affected VersionsENISA

Linux patch: 6.12.111
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <0e2021f49e64b3c8a9aa880d0c62a218bfe147ce
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <d0d89f2e16a874e0f8fb17045da293e8bedf8b21
Linux patch: 6.18.53
Linux 0 <6.12.111
Linux 0 <6.18.53
Linux patch: 7.2
Linux 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 <b96401812cbfbb4803faabeefa1f20b8562268b3

Affected Packages

euvd linux fix: 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

ACPICA is the reference implementation of the ACPI Component Architecture, and in Linux it is the AML interpreter that evaluates bytecode supplied by platform firmware (DSDT/SSDT tables, and, on some configurations, overridden tables or the debugfs custom_method interface). The vulnerable routine, acpi_ex_opcode_3A_1T_1R(), is the common execution handler for AML opcodes that take three source operands, one target and one result - the Mid() string-extraction operator is the specific path described. The handler computes a truncation length from the operand-derived Index + Length values; when that sum overflows the integer type used, the resulting length becomes negative and is passed as the size argument to memcpy(), where conversion to an unsigned size type turns it into a very large value. The root cause class is integer overflow leading to improper validation of a length/size field and consequent out-of-bounds memory copy (buffer overflow, per the source tags); no CWE identifier was provided in the input data, so the classification is drawn from the patch description rather than an assigned CWE. The affected code has existed since the earliest commit in the tracked history (1da177e4c3f41524e886b7f1b8a0c1fc7321cac2), indicating a longstanding defect rather than a recent regression, and it was remediated by adding an explicit overflow check on Index + Length before the truncation length is used. Because the input is AML, the values of Index and Length are attacker-influenced only to the extent the attacker can control the AML stream, which is why the practical precondition is firmware control or a privileged AML-injection path.

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 8.4 HIGH
AV:L/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 4.7 MEDIUM

Reaching the interpreter requires loading malicious AML via firmware or root (PR:H, AC:H); outcome is a negative-size memcpy causing corruption/panic, so A:H with limited I and no C.

3.1 AV:L/AC:H/PR:H/UI:N/S:U/C:N/I:L/A:H
4.0 AV:L/AC:H/AT:N/PR:H/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
SUSE 7.8 HIGH
AV:L/AC:L/PR:L/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
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

Lifecycle Timeline

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

DescriptionCVE.org

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

ACPICA: Fix integer overflow in acpi_ex_opcode_3A_1T_1R() (mid_op)

Add overflow check for Index + Length to prevent integer overflow when calculating the truncation length. This prevents negative size parameter being passed to memcpy().

Executive ViewAI

Why It Matters

A memory-corruption defect in the Linux kernel's ACPI interpreter (CVE-2026-97451) can crash or destabilize affected hosts, but reaching it requires either administrator-level access or the ability to supply malicious ACPI firmware tables, neither of which is available to an ordinary user or an external attacker. The practical risk is therefore concentrated on infrastructure running unpatched kernels (below 6.12.111, 6.18.53, or 7.2) where privileged insiders, malicious firmware, or a chained privilege-escalation path could convert it into a denial-of-service event; vendor patches are already published. Leadership should treat this as a routine patch-management and firmware-supply-chain item rather than an urgent breach vector.

Business Impact: Medium
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Ubiquitous
ACPICA is core to every ACPI-enabled Linux kernel deployment
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

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
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: Important
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