CVE-2026-99487 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
rust: bug: pass TAINT_WARN to warn_slowpath_fmt() on UML
On UML, `warn_flags!` calls `warn_slowpath_fmt()` directly. Its third argument is a taint number, but `warn_on!` passes its bug flags there.
As a result, `add_taint()` gets 2304 instead of 9 (`TAINT_WARN`). The warning is not recorded: `/proc/sys/kernel/tainted` stays 0 after `warn_on!` fires, where it should be 512. It also causes an out-of-bounds write in `add_taint()`.
Pass `TAINT_WARN` directly, as C does on UML.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/19/2026
The Linux kernel's User Mode Linux (UML) subsystem contains a critical implementation flaw within its warning infrastructure that results in incorrect system state tracking and potential memory corruption. This vulnerability stems from an error in the Rust-based warning macros where the function warn_slowpath_fmt is invoked with an incorrect argument for taint classification. Specifically, while standard C implementations on UML correctly pass TAINT_WARN to indicate a non-fatal kernel warning, the Rust equivalent incorrectly passes raw bug flags instead of the designated taint constant. This discrepancy arises because the third parameter in warn_slowpath_fmt expects a specific taint number that maps directly to entries in the kernel's internal taint tracking system rather than generic error codes used for other purposes.
The immediate operational impact of this defect is twofold, affecting both observability and memory safety regarding the kernel's self-diagnostic mechanisms. First, the incorrect argument causes add_taint to receive a value of 2304 instead of the expected TAINT_WARN value which corresponds to nine in decimal but maps to bit position eight resulting in fifty-one-two when applied correctly or similar standard taint bits depending on architecture specifics though the core issue is the mismatch. Consequently, the kernel fails to record the warning event properly. This means that /proc/sys/kernel/tainted remains at zero even after a warn_on condition triggers, effectively hiding evidence of potential instability from system administrators and automated monitoring tools that rely on this flag for health assessment. The loss of accurate taint information undermines debugging capabilities and compliance with security auditing standards that require precise logging of kernel anomalies.
Secondly, the incorrect value passed to add_taint leads to an out-of-bounds write within the kernel's memory space. Since add_taint interprets its input as a bit shift or index into internal arrays managing taint flags, receiving 2304 instead of a small integer like nine causes it to access memory locations far beyond the intended bounds of the taint flag array. This out-of-bounds write constitutes a serious security vulnerability that can lead to kernel panic, data corruption, or potentially arbitrary code execution if an attacker can influence the conditions triggering this warning path. The flaw represents a classic case of improper input validation and type confusion where metadata meant for one subsystem is misinterpreted by another due to inconsistent API usage across different language implementations within the same codebase.
From a classification perspective, this vulnerability aligns with CWE-120 Buffer Overflow without bounds check as it involves writing data beyond allocated memory boundaries via add_taint. It also relates to CWE-754 Improper Check for Unusual or Exceptional Conditions because the warning mechanism fails to correctly flag exceptional states due to incorrect parameter passing. In terms of MITRE ATT&CK, this could be leveraged in techniques related to Defense Evasion by masking kernel warnings and potentially Privilege Escalation if the memory corruption allows control over execution flow. The fix requires correcting the Rust macro implementation to pass TAINT_WARN directly mirroring the behavior of the C counterpart ensuring consistent taint reporting across all kernel subsystems regardless of whether they are written in C or Rust.
Mitigation strategies involve applying the upstream patch that corrects the argument passed to warn_slowpath_fmt within the UML-specific warning macros. System administrators should ensure their kernels are updated to versions where this fix is included. For environments unable to immediately update, monitoring /proc/sys/kernel/tainted for unexpected zeros during known stress tests or error conditions may help detect instances of this flaw in older builds although detection is inherently difficult due to the silent nature of the bug. Long-term resolution requires rigorous code review processes that enforce consistency between C and Rust implementations of shared kernel interfaces particularly those involving state management like taint tracking to prevent similar discrepancies from arising as more subsystems transition to Rust.