CVE-2026-99661 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

mm/gup: check for overflow when converting nr_pages to bytes in GUP-fast

The overflow check in gup_fast_fallback() only covers the addition to start. The preceding nr_pages << PAGE_SHIFT can already have truncated the length on 32bit.

Users such as RapidIO's rio_dma_transfer() can derive such page counts from a 64-bit userspace length.

Let's just check_shl_overflow() to reject any such overflow with -EOVERFLOW early.

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/21/2026

The Linux kernel contains an integer overflow vulnerability within the get_user_pages_fast mechanism, specifically in the gup_fast_fallback function located in mm/gup.c. This flaw arises during the conversion of a page count into byte offsets for memory mapping operations. The existing validation logic only verifies that adding the starting address to the calculated length does not result in an arithmetic overflow relative to the end of the user space range. However, it fails to check whether the multiplication operation itself, implemented as a bitwise left shift of nr_pages by PAGE_SHIFT, causes an integer truncation or wrap-around on 32-bit architectures. This oversight allows maliciously crafted inputs to bypass size validation checks entirely.

The technical root cause lies in the assumption that shifting page counts by the system page size will not exceed the limits of the underlying data type before being added to a base address. On 32-bit systems, where integer registers are limited to thirty-two bits, large values passed from user space can overflow when shifted left by twelve or thirteen bits depending on the configuration. This truncation results in a significantly smaller byte count than intended, effectively allowing access to memory regions that should be out of bounds according to the original request size. The vulnerability is particularly relevant for subsystems like RapidIO, where drivers such as rio_dma_transfer may derive page counts from sixty-four-bit user-space length parameters without adequate intermediate validation on thirty-two-bit kernels.

From an operational perspective, this integer overflow can lead to severe security implications including out-of-bounds memory access and potential privilege escalation. An attacker who can trigger the gup_fast_fallback path with a carefully crafted input size may read or write to kernel memory outside of the intended user-space mapping boundaries. This violates the fundamental isolation between user space and kernel space, potentially exposing sensitive data stored in adjacent kernel structures or allowing for arbitrary code execution if the overwritten memory contains critical control flow pointers. The impact is most pronounced on 32-bit architectures where the integer width limitation directly enables the truncation behavior that bypasses subsequent bounds checking logic.

This vulnerability aligns with CWE-190, which describes Integer Overflow or Wraparound, and falls under MITRE ATT&CK technique T1055, specifically related to process injection or memory manipulation via improper validation of input parameters. The lack of early rejection for oversized inputs allows the kernel to proceed with invalid calculations that compromise memory safety guarantees. To mitigate this risk, developers must implement robust overflow detection before performing arithmetic operations on user-supplied values. Utilizing helper functions such as check_shl_overflow ensures that any attempt to shift a value beyond its representable range is caught immediately and rejected with an EOVERFLOW error code rather than proceeding with truncated data. This approach enforces strict input validation at the earliest possible point in the execution path, preventing downstream logic from operating on corrupted or misleading size parameters.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!