CVE-2026-99764 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

9p/xen: validate the response size from the backend

p9_xen_response() takes the length of an incoming response from the ring -- the first field of the 9p header, which the Xen transport reuses as its framing header -- and uses it to advance the consumer index, but never checks that it is at least the header size or no larger than the number of bytes the backend has actually produced.

A malicious or buggy backend can post a response whose size is smaller than the header (for example 0). The consumer index then never advances, so the response work re-reads the same ring contents instead of making progress. In testing this raced with the teardown that the malformed reply triggers and dereferenced a freed p9_client:

9pfs 9pfs-0: Wrong req tag=ffff BUG: kernel NULL pointer dereference, address: 0000000000000060 #PF: supervisor read access in kernel mode #PF: error_code(0x0000) - not-present page PGD 0 P4D 0 Oops: Oops: 0000 [#1] SMP NOPTI
CPU: 0 UID: 0 PID: 11 Comm: kworker/0:1 Not tainted 7.2.0-rc5 #6 PREEMPT(lazy) Hardware name: QEMU Standard PC (Q35 + ICH9, 2009), BIOS rel-1.17.0-0-gb52ca86e094d-prebuilt.qemu.org 04/01/2014 Workqueue: events p9_xen_response RIP: 0010:idr_find+0x4/0x10 RSP: 0018:ffffbf5d80063de8 EFLAGS: 00010202 RAX: 0000000000000001 RBX: ffffa229c21195a0 RCX: ffffa229c2400000 RDX: ffffa229c11c2200 RSI: 000000000000ffff RDI: 0000000000000050 RBP: 000000000000ffff R08: 3fffffffffffdfff R09: ffffffffffffffff R10: 3fffffffffffdfff R11: ffffffff87a60e80 R12: 0000000000000050 R13: 0000000000000000 R14: 000000000000ffff R15: 0000000000100000 FS: 0000000000000000(0000) GS:ffffa22a7661c000(0000) knlGS:0000000000000000 CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033 CR2: 0000000000000060 CR3: 000000003ac34002 CR4: 0000000000770ef0 PKRU: 55555554 Call Trace: <TASK> p9_tag_lookup+0x2b/0x90 p9_xen_response+0x17c/0x2e0 process_one_work+0x16a/0x3a0 worker_thread+0x172/0x2e0 kthread+0xdd/0x110 ret_from_fork+0x18b/0x240 ret_from_fork_asm+0x1a/0x30 </TASK> Modules linked in: CR2: 0000000000000060 ---[ end trace 0000000000000000 ]---

Reject a response whose size is outside [sizeof(header), queued] before
using it, matching the validation the backend already applies to incoming requests.

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified in the Linux kernel's 9p filesystem implementation over Xen transport involves a critical lack of input validation regarding the response length field received from the virtualization backend. The function p9_xen_response is responsible for processing responses sent by the Xen domain zero or other domains to the guest operating system. This function extracts the size of the incoming response directly from the ring buffer, which serves as both the framing header and the payload indicator within the 9p protocol structure. However, prior to this fix, the code failed to verify that the reported length was at least equal to the minimum required header size or no larger than the actual number of bytes produced by the backend in the current ring slot. This omission creates a scenario where malformed or maliciously crafted responses can trigger undefined behavior within the kernel memory management and execution flow.

When a backend posts a response with an invalid length, such as zero or a value smaller than the header size, the consumer index used to track progress through the ring buffer is not advanced correctly. Consequently, the processing loop re-reads the same stale data from the ring buffer repeatedly instead of moving forward to process new messages. This creates a local denial-of-service condition where the worker thread responsible for handling 9p requests becomes stuck in an infinite or near-infinite loop consuming CPU resources without making progress on actual work items. The lack of bounds checking allows the system state to become desynchronized from the backend's actual output, leading to resource exhaustion and potential hangs within the virtualized environment.

The severity of this flaw is significantly amplified by race conditions that occur during teardown operations. In testing scenarios involving malformed replies, a race condition was observed between the ongoing response processing and the cleanup routines triggered by the error state. Specifically, the p9_client structure associated with the connection could be freed while still being referenced by the worker thread attempting to process the invalid response. This leads to a use-after-free vulnerability where the kernel attempts to dereference memory that has already been released back to the allocator. The resulting null pointer dereference causes an immediate kernel panic, as evidenced by the crash trace showing access to address zero within the idr_find function during tag lookup operations.

From a security architecture perspective, this flaw aligns with CWE-20 Improper Input Validation and CWE-416 Use After Free. It also maps to MITRE ATT&CK techniques related to Denial of Service via resource exhaustion and potentially privilege escalation if an attacker can leverage the kernel panic or memory corruption to execute arbitrary code in a future exploitation scenario, although the primary impact observed is system instability. The vulnerability highlights the risks inherent in trusting unverified data from virtualization backends, which are often considered semi-trusted but must still be validated rigorously at every interaction boundary.

The resolution involves adding explicit validation checks within p9_xen_response to ensure that the response size falls strictly within acceptable bounds before any further processing occurs. The fix mandates rejecting any response where the length is smaller than sizeof(header) or larger than the number of bytes queued in the ring buffer for consumption. This approach mirrors the existing validation logic applied by the backend when handling incoming requests, thereby enforcing symmetry and consistency in security checks across both directions of communication. By implementing these bounds checks, the kernel prevents the consumer index from stalling and avoids accessing freed memory structures during error paths or teardown sequences.

System administrators and developers should ensure that their Linux kernels are updated to include this patch, particularly for environments running 9p filesystems over Xen virtualization. Mitigation strategies also include monitoring ring buffer utilization metrics for signs of stalls or excessive CPU usage by worker threads handling network file system operations. In the interim before patching, restricting access to untrusted backends and ensuring that only trusted domains can communicate with the guest via the 9p protocol reduces the attack surface available to exploit this vulnerability. Continuous integration testing should include fuzzing scenarios for ring buffer inputs to detect similar validation gaps in other parts of the virtualization stack.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00168

KEV

no

Activities

very low

Sources

Interested in the pricing of exploits?

See the underground prices here!