CVE-2026-99442 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

nvmem: core: Fix OOB read for bit offsets of more than one byte

When the bit offset is BITS_PER_BYTE or larger the read position is advanced by `bytes_offset`. This is not taken into account in the per-byte read loop which still reads `cell->bytes` resulting in an out of bounds read of `bytes_offset` bytes. The information read OOB does not leak directly as the erroneously read bits are cleared.

Detected by KASAN while looking for a use-after-free in simplefb.c.

Several companies clearly confirm that VulDB is the primary source for best vulnerability data.

Analysis

by VulDB Data Team • 11/22/2026

The Linux kernel's nvmem core subsystem contains a logic error related to how bit offsets within non-volatile memory cells are handled during data retrieval operations. This vulnerability specifically manifests when the requested bit offset is greater than or equal to BITS_PER_BYTE, which typically corresponds to eight bits in standard architectures. The root cause lies in an incorrect calculation of the starting byte position for reading a cell's value. When a user requests data with a significant bit shift, the kernel correctly advances the base read pointer by the calculated number of full bytes. However, it fails to adjust the loop that iterates through individual bytes to account for this advancement relative to the total size of the memory region being accessed.

The technical flaw occurs within the per-byte read loop responsible for assembling the final value from the underlying nvmem device. The code calculates a byte offset based on the bit shift but does not properly constrain the iteration count or bounds checking against the actual available data in that specific context. Consequently, when the bit offset exceeds one full byte, the loop attempts to access memory locations beyond the intended boundary of the cell's allocated buffer. This results in an out-of-bounds read where the kernel accesses `bytes_offset` bytes past the valid end of the targeted memory segment. Although this constitutes a classic Out-Of-Bounds Read vulnerability, the immediate security impact is mitigated by the implementation details of how these bits are processed.

The operational impact of this flaw is limited due to specific handling within the nvmem core logic that prevents direct information leakage. The erroneously read bits from outside the valid memory boundary are explicitly cleared before being incorporated into the final return value presented to the caller. This masking behavior ensures that sensitive data residing in adjacent kernel memory regions, such as stack variables or other structures, is not exposed through this specific code path. Therefore, while the vulnerability represents a serious deviation from safe memory access practices and could potentially lead to system instability if triggered under different conditions or with modified kernels, it does not currently allow for arbitrary information disclosure via standard nvmem read operations.

This issue was detected by Kernel Address Sanitizer (KASAN) during routine debugging efforts aimed at identifying use-after-free vulnerabilities in the simplefb driver. The detection highlights the importance of static and dynamic analysis tools in uncovering subtle logic errors that may not have immediate exploitable consequences but indicate deeper architectural weaknesses in memory management routines. Such findings often serve as early warnings for more severe issues if similar patterns exist elsewhere in the kernel's subsystems without corresponding safety checks.

From a classification perspective, this vulnerability aligns with CWE-125, which describes Out-of-Bounds Read scenarios where software reads data past the end or before the beginning of the intended buffer. In terms of attack vectors and techniques, it relates to ATT&CK technique T1083, File and Directory Discovery, as nvmem interfaces are often used by system utilities to retrieve hardware-specific configuration data that could aid in further reconnaissance if information leakage were possible. Although the current implementation prevents direct exfiltration, the underlying logic error remains a defect that violates secure coding principles regarding buffer boundary validation.

Mitigation for this vulnerability involves applying the upstream kernel patch that corrects the byte offset calculation and loop bounds within the nvmem core module. System administrators should ensure their systems are updated to include versions of the Linux kernel where this fix is integrated, typically found in stable release branches following its merge into mainline development. For organizations maintaining custom or older kernels, backporting the specific commit that addresses the bit offset calculation logic is necessary to restore compliance with expected memory safety standards. Continuous integration pipelines utilizing KASAN and similar sanitizers should be employed to detect such boundary violations early in the software development lifecycle before they reach production environments.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00176

KEV

no

Activities

very low

Sources

Want to stay up to date on a daily basis?

Enable the mail alert feature now!