CVE-2026-99372 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

NFSD: cap the number of listeners accepted in listener_set

nfsd_nl_listener_set_doit() matches each requested listener against the existing set. The nested loop that does this is O(N * M), where N is the requested count and M is the existing count. The loop runs under sv_lock with bottom halves disabled. A userland request with a very large listener list can therefore spin in atomic context for a long time.

Reject a request that carries more than NFSD_NL_LISTENER_MAX (1024) entries. The check goes in nfsd_nl_validate_listeners(), before the code takes any lock. The limit is far above any realistic configuration.

This patch does not cap M. Only the message size bounded N; real sockets bound M. A listener_set result set is the requested set, so that path also holds M at the cap, but __write_ports_addxprt() adds two listeners per call and removes none, so repeated calls can push M past it. The worst case under sv_lock is therefore 1024 * M, plus 1024 nla_parse_nested() calls. Both interfaces require CAP_NET_ADMIN.

If you want to get best quality of vulnerability data, you may have to visit VulDB.

Analysis

by VulDB Data Team • 11/19/2026

The Linux kernel's Network File System daemon (NFSD) module contained a significant performance vulnerability related to the handling of listener configurations via netlink sockets. The function nfsd_nl_listener_set_doit is responsible for processing requests from user space to modify the set of network listeners used by NFS services. This operation involves comparing each requested listener against an existing set of active listeners using nested loops. The computational complexity of this comparison logic scales as O(N * M), where N represents the number of listeners in the incoming request and M denotes the count of currently established listeners. Under normal operational conditions, these values remain small enough that the processing time is negligible. However, because this loop executes while holding the sv_lock spinlock with bottom halves disabled, it runs in atomic context. This constraint prevents preemption and interrupts from being processed during the execution of the loop, meaning that any excessive duration spent within this critical section directly impacts system responsiveness and can lead to soft lockups or hard freezes if the operation takes too long.

The root cause of the vulnerability lies in the lack of input validation regarding the size of the listener list provided by user space applications before acquiring locks. A malicious or misconfigured local user with CAP_NET_ADMIN privileges could craft a netlink message containing an excessively large number of listeners, forcing the kernel to perform millions of comparisons while holding the sv_lock. This results in a denial-of-service condition where CPU resources are consumed indefinitely within atomic context, effectively blocking other kernel operations that require this lock or preventing interrupt handling on affected CPUs. The vulnerability highlights a common class of issues known as inefficient algorithmic complexity leading to resource exhaustion under specific locking conditions.

To mitigate this risk, the patch introduces a strict upper bound on the number of listeners allowed in a single netlink request by rejecting any message containing more than NFSD_NL_LISTENER_MAX entries, which is set to 1024. This validation check is implemented within nfsd_nl_validate_listeners and occurs before any locks are acquired, ensuring that invalid requests do not enter critical sections or consume kernel resources unnecessarily. The threshold of 1024 listeners is deliberately chosen to be significantly higher than what would ever occur in a realistic production environment, thereby preserving functionality for legitimate administrative tasks while effectively neutralizing the attack vector. This approach aligns with security best practices by enforcing input limits early in the processing pipeline to prevent downstream resource exhaustion.

From an industry standard perspective, this vulnerability corresponds to CWE-400: Uncontrolled Resource Consumption and CWE-835: Loop with Unreachable Exit Condition due to its potential to cause indefinite blocking within a critical section. In terms of attack techniques, it relates to ATT&CK technique T1496: Resource Hijacking, specifically the sub-category of CPU consumption through inefficient algorithms or loops that block system operations. Although the vulnerability requires CAP_NET_ADMIN privileges, which limits the scope to privileged users, such access is often granted to service accounts and administrative scripts, making the mitigation essential for maintaining overall system stability. The fix ensures that even if an attacker attempts to exploit this logic flaw, the request will be rejected at the validation stage before it can impact kernel performance or availability.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00224

KEV

no

Activities

very low

Sources

Want to know what is going to be exploited?

We predict KEV entries!