CVE-2026-99355 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
SUNRPC: fix oversized GSS proxy token copy
gss_read_proxy_verf() allocates one page per token chunk, but it copies the entire linear head of an RPC request into in_token->pages[0]. A UDP datagram
can leave more than PAGE_SIZE bytes in the linear head, so a large RPCSEC_GSS INIT token overwrites following pages.
Copy the linear head in page-sized chunks before switching to the request page array. The linear head itself can span multiple pages.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/21/2026
The Linux kernel contains a critical buffer overflow vulnerability within the SUNRPC subsystem specifically affecting the GSS proxy verification logic, identified by CVE-2024-something (generic reference). This flaw resides in the gss_read_proxy_verf function which is responsible for parsing and processing RPCSEC_GSS initialization tokens. The underlying technical defect stems from an incorrect assumption regarding memory allocation versus data copying boundaries. Specifically, the code allocates exactly one page of memory per token chunk to store incoming security context information. However, when handling the initial part of the request, it attempts to copy the entire linear head buffer directly into the first allocated page without verifying if the size of that linear head exceeds the capacity of a single PAGE_SIZE block.
In network environments utilizing UDP as the transport protocol, datagrams can carry payloads significantly larger than standard Ethernet MTU limits due to fragmentation or specific application behaviors. When an attacker crafts a malicious RPCSEC_GSS INIT token with a large initial segment, the linear portion of that request can easily surpass one page in size. Because the code blindly copies this oversized linear head into pages[0], it writes data beyond the allocated boundary of that first memory page. This results in a heap-based buffer overflow where subsequent kernel structures or adjacent memory allocations are overwritten with attacker-controlled data from the RPC payload.
The operational impact of this vulnerability is severe, potentially leading to arbitrary code execution within the kernel space if an unprivileged user can trigger the affected path via network requests. Even without full exploitation for remote code execution, such a buffer overflow causes memory corruption that typically results in immediate system instability or a kernel panic, effectively providing a denial-of-service vector against systems relying on SUNRPC services like NFSv4 with Kerberos authentication. The vulnerability highlights a common class of errors where developers assume network packet headers fit within standard page boundaries without accounting for maximum transmission unit variations or specific protocol header sizes.
This issue aligns closely with CWE-120, Buffer Copy without Checking Size of Input, as the code fails to validate that the input data fits into the destination buffer before performing the copy operation. From a threat modeling perspective using MITRE ATT&CK techniques, this vulnerability facilitates Initial Access through network service exploitation and allows for Privilege Escalation by compromising kernel integrity from user-space processes interacting with RPC services. The attack vector is classified as Network because it requires sending crafted packets to an exposed SUNRPC endpoint rather than local file system access or physical interaction.
Mitigation strategies primarily involve applying the upstream Linux kernel patch that modifies gss_read_proxy_verf to handle multi-page linear heads correctly. Developers and administrators should ensure systems are updated with kernels containing this fix, which implements a loop to copy data in page-sized chunks before switching to the request page array structure. This ensures that regardless of how large the initial linear head is, it is safely distributed across multiple allocated pages without overwriting adjacent memory regions. Additionally, organizations should enforce strict network segmentation and firewall rules to limit exposure of SUNRPC services to trusted networks only, reducing the attack surface available for such exploitation attempts until patches are fully deployed.