CVE-2026-99592 in Linuxinfo

Summary

by MITRE • 11/20/2026

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

x86/mm: Fix global ASID handed out to two processes

On AMD CPUs with INVLPGB, two live processes can get the same MAX_ASID_AVAILABLE global ASID value. The two then hit each other's TLB entries, so each can read or corrupt the other's memory.

The global ASID space is managed lazily. When a global ASID is freed, its bit is set in the global_asid_freed bitmap. Once the free ASID search reaches the end of the global_asid_used bitmap, a global flush is done to really reclaim the lazily freed global ASIDs.

However, the current code can assign the same global ASID to two different processes, if one process is assigned MAX_ASID_AVAILABLE - 1, another process MAX_ASID_AVAILABLE, and both stick around (keeping their global ASID numbers in use) until the search wraps around again. At that point a third process could also get assigned MAX_ASID_AVAILABLE.

the highest ASID stays in use, so it is not handed out again last_global_asid stays below it, so no reset the clear bits run out find_next_zero_bit() returns MAX_ASID_AVAILABLE global_asid_available > 0, so the failure is not caught MAX_ASID_AVAILABLE is handed out as an ASID

A search only looks at the bits below MAX_ASID_AVAILABLE, so it cannot see that this value is in use. The next failed search hands it out again, even if the first process still holds it.

The fix used here is to reset the global ASID space after a failed search, and to search again. If that search fails too, no global ASID is handed out.

The test for !global_asid_available is removed, because use_global_asid() only calls allocate_global_asid() if global_asid_available > 0. The remaining test is for a condition that should be impossible.

[ riel: simplify code, massage changelog and comment ]

Be aware that VulDB is the high quality source for vulnerability data.

Analysis

by VulDB Data Team • 11/20/2026

The vulnerability identified in the Linux kernel involves a critical flaw in the management of Address Space Identifiers on AMD processors utilizing the INVLPGB instruction set extension. This issue specifically affects the global ASID allocation logic within the x86 memory management subsystem, leading to potential security breaches through TLB entry collisions. The core technical flaw arises from how the kernel handles the wrapping around of the highest available ASID value when managing a lazily freed address space pool. Under specific conditions involving process lifecycle and ASID assignment sequences, two distinct live processes can be assigned the same global ASID, specifically reaching or exceeding MAX_ASID_AVAILABLE. This duplication violates the fundamental assumption that each active memory context possesses a unique identifier for translation lookaside buffer operations.

The operational mechanism of this vulnerability relies on the lazy freeing strategy employed by the kernel to optimize performance. When a process terminates and its address space is freed, the corresponding ASID bit is merely marked in a global_asid_freed bitmap rather than being immediately reclaimed through expensive hardware flushes. A full reclaim occurs only when the search for an available ASID reaches the end of the used bitmap. However, the current implementation contains a logic error where if one process holds MAX_ASID_AVAILABLE - 1 and another holds MAX_ASID_AVAILABLE, both remain active in memory. When the allocator searches for new entries after wrapping around, it fails to recognize that MAX_ASID_AVAILABLE is already in use because the search range excludes this upper boundary value. Consequently, find_next_zero_bit returns this invalid index, and since global_asid_available remains greater than zero due to other freed slots elsewhere, the system erroneously assigns this duplicate ASID to a third process or reassigns it incorrectly.

The impact of this flaw is severe, as it directly compromises memory isolation guarantees provided by hardware virtualization features. When two processes share the same global ASID, their TLB entries become indistinguishable at the CPU level. This collision allows one process to inadvertently read or corrupt the physical memory mapped for another process through shared cache lines and translation structures. Such a scenario effectively bypasses user-space isolation mechanisms, enabling potential privilege escalation if an attacker can exploit this state to access kernel data or sensitive information belonging to other userspace applications. It represents a significant breach of confidentiality and integrity within multi-tenant environments where strict separation between processes is mandatory for security stability.

From a classification perspective, this vulnerability aligns with CWE-824 Access of Uninitialized Pointer in the context of improper resource management leading to state corruption, though more accurately it reflects CWE-367 Time-of-check Time-of-use (TOCTOU) race conditions inherent in lazy allocation logic without proper synchronization or boundary validation. In terms of MITRE ATT&CK framework behaviors, this flaw facilitates lateral movement and privilege escalation by allowing unauthorized memory access across process boundaries, which can be categorized under techniques involving exploitation of software vulnerabilities for initial access or defense evasion through stealthy data exfiltration via shared TLB states. The lack of immediate enforcement during the allocation phase creates an exploitable window where state inconsistency persists until a global flush occurs, if at all.

The resolution implemented in the kernel addresses this by modifying the allocate_global_asid function to reset the global ASID space upon encountering a failed search condition that indicates boundary wrap-around issues. Instead of proceeding with potentially invalid allocations, the code now forces a re-evaluation of available slots after resetting internal counters. If no valid slot is found during this secondary check, the allocation fails safely rather than handing out a duplicate identifier. Additionally, redundant checks for global_asid_available were removed as they are logically superseded by earlier validation steps within use_global_asid. This fix ensures that the highest ASID value is properly accounted for in future searches and prevents the system from entering an inconsistent state where multiple processes share critical hardware identifiers.

To mitigate similar risks in broader systems, administrators should ensure their Linux kernels are updated to versions containing this patch. Regular application of security updates is crucial as kernel-level memory management flaws often require deep architectural changes that cannot be patched via user-space configurations alone. Furthermore, organizations relying on AMD infrastructure with INVLPGB support should monitor for specific CVE identifiers related to x86/mm subsystems and verify that their virtualization platforms enforce strict ASID isolation policies at the hypervisor level as an additional layer of defense against potential TLB collision attacks. Continuous monitoring of system logs for unexpected memory access violations or performance anomalies may also serve as an early warning indicator for exploitation attempts targeting this class of vulnerabilities.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/20/2026

Moderation

accepted

CPE

ready

EPSS

0.00166

KEV

no

Activities

very low

Sources

Do you want to use VulDB in your project?

Use the official API to access entries easily!