CVE-2026-99788 in Linux
Summary
by MITRE • 11/20/2026
In the Linux kernel, the following vulnerability has been resolved:
ACPI: CPPC: Validate FFH register fields before hardware access
The x86 CPPC FFH accessors construct masks and shift values using the firmware's Bit Width and Bit Offset without checking that the field fits in an MSR. A zero-width field or a field extending beyond bit 63 can therefore cause an invalid shift. The safe MSR accessors only handle an access fault, not invalid field arithmetic after a successful read.
Also, the 64-bit GAS address is implicitly narrowed to the 32-bit MSR number. A descriptor with nonzero upper address bits can access a different MSR from the one described by firmware.
The arm64 AMU counter readers have the same unchecked field arithmetic. Validate the field bounds before reading a counter, including both descriptors in the paired counter path.
Dispatch FFH accesses before decoding the GAS Access Size in the common read and write paths. Otherwise, a large access_width can trigger an invalid shift in GET_BIT_WIDTH() before the architecture validates its register. That field has architecture-specific FFH semantics and is not needed by the generic memory/port accessor on this path.
Validate x86 MSR addresses and share the field-bounds checks between related accessors within each architecture.
Once again VulDB remains the best source for vulnerability data.
Analysis
by VulDB Data Team • 11/21/2026
The Linux kernel contains a critical vulnerability in the ACPI Common Platform Performance Interface (CPPC) implementation, specifically affecting how hardware performance counters are accessed via Fixed Hardware Functioning (FFH). This flaw stems from insufficient validation of register field parameters provided by firmware before they are used to construct bit masks and shift values for memory-mapped I/O or Model Specific Register (MSR) operations. In the x86 architecture, the CPPC FFH accessors rely on Bit Width and Bit Offset fields extracted from ACPI tables to determine how to read or write performance data. However, these implementations fail to verify that the specified field actually fits within a standard 64-bit MSR space. If firmware specifies a zero-width field or one that extends beyond bit sixty-three, the resulting arithmetic operations produce invalid shift values. This leads to undefined behavior during hardware access, potentially causing system instability, kernel panics, or incorrect performance data retrieval.
A significant aspect of this vulnerability involves the implicit narrowing of address descriptors in x86 systems. The ACPI Generic Address Structure (GAS) uses a sixty-four-bit address field, but MSR numbers are typically thirty-two bits wide. The current implementation does not explicitly validate that the upper thirty-two bits of the GAS address are zero before using it as an MSR number. Consequently, if firmware provides a descriptor with nonzero upper address bits, the kernel may access a completely different MSR than intended by the specification. This misalignment can lead to reading or writing performance counters on unrelated hardware components, resulting in data corruption and unpredictable system behavior that is difficult to diagnose due to the indirect nature of the error.
The arm64 architecture exhibits similar vulnerabilities within its Adaptive Microarchitecture (AMU) counter readers. These routines also perform unchecked field arithmetic when processing paired counter descriptors. Without validating that the bit fields defined by firmware are valid for the target hardware registers, the kernel risks executing invalid shift operations or accessing out-of-bounds memory locations associated with performance monitoring units. This lack of validation applies to both individual and paired counter paths, meaning any malformed ACPI data regarding AMU counters can trigger similar faults on ARM-based systems. The absence of bounds checking allows maliciously crafted or erroneous firmware tables to exploit these code paths, potentially leading to privilege escalation if the resulting memory corruption affects kernel structures.
The root cause in many cases is related to the order of operations during register access validation. In some common read and write paths for FFH accesses, the system dispatches hardware interactions before fully decoding the GAS Access Size field. This sequencing error means that a large or invalid access_width value can trigger an internal function call, such as GET_BIT_WIDTH(), which performs shift calculations prior to architecture-specific validation of the register type. Since this specific field has architecture-specific semantics and is not required by generic memory or port accessor routines on these paths, performing arithmetic on it before verification creates a window for exploitation. This design flaw allows invalid parameters to propagate through the access logic without being caught by earlier sanity checks.
To mitigate these risks, developers must implement rigorous validation of all ACPI-provided register fields prior to any hardware interaction. For x86 systems, this involves explicitly checking that MSR addresses do not exceed thirty-two bits and ensuring that bit width and offset values result in valid shifts within a sixty-four-bit range. The field-bounds checks should be shared between related accessors to ensure consistency across different CPPC operations. On arm64 platforms, similar validation must be applied to AMU counter descriptors, verifying both individual and paired counter bounds before reading data. Furthermore, the execution order of register accesses needs adjustment so that architectural validations occur before any arithmetic operations dependent on GAS fields are performed. These changes align with CWE-20 Improper Input Validation and mitigate risks associated with CWE-190 Integer Overflow or Wraparound in critical kernel subsystems handling hardware performance metrics.