CVE-2026-99486 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

rust: configfs: fix data offset calculation for subsystem callbacks

`get_group_data()` chooses between `Group::<Parent>::container_of()` and `Subsystem::<Parent>::container_of()` based on whether `this` represents the root group of a configfs subsystem. It detects this by checking `(*this).cg_subsys.is_null()`, but `link_group()` in `fs/configfs/dir.c` unconditionally sets `cg_subsys` for every `config_group` attached anywhere in a registered subsystem, including the subsystem's own `su_group`. The only `config_group` with a NULL `cg_subsys` is the configfs root, on which userspace cannot trigger callbacks. The check is therefore always false at runtime, and the `Subsystem` branch is dead. Subsystem-level callbacks reach the `Group` branch and may read `data` at the wrong offset.

Thus change the `is_root` check to correctly identify whether a group is a root group by comparing `this` to `subsys.su_group`.

[ Andreas: Fix clippy warning on 1.85.0 by moving safety comment. ]

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 vulnerability identified in the Linux kernel involves an incorrect data offset calculation within the configfs subsystem, specifically affecting Rust-based implementations of filesystem callbacks. The core issue resides in the `get_group_data()` function, which is responsible for determining whether a given configuration group belongs to a specific parent structure using container_of macros. This determination dictates how memory offsets are calculated when accessing associated data structures. The original implementation relied on checking if the `cg_subsys` pointer within the config_group structure was null to distinguish between root groups and regular subsystem groups. However, this logic is fundamentally flawed due to an initialization behavior in the `link_group()` function located in fs/configfs/dir.c.

The `link_group()` function unconditionally sets the `cg_subsys` field for every config_group attached within a registered subsystem. This includes not only child groups but also the subsystem's own root group, referred to as su_group. Consequently, the condition checking for a null cg_subsys is never true for any group that can be accessed through normal userspace interactions with the filesystem hierarchy. The only instance where cg_subsys remains null is at the absolute configfs root level, which is not exposed in a manner that allows userspace to trigger callbacks on it. This discrepancy means that the code path intended for subsystem-level operations becomes unreachable dead code during runtime execution.

As a direct result of this logical error, all subsystem-level callbacks are incorrectly routed through the group branch rather than the subsystem branch. This misrouting leads to an incorrect calculation of memory offsets when accessing data structures associated with these groups. Specifically, the system may read or write data at wrong memory addresses relative to the expected structure layout. In a Rust context where safety is paramount, such offset miscalculations can lead to undefined behavior, potentially causing kernel panics, data corruption, or in more severe scenarios, privilege escalation if an attacker can manipulate these offsets to access restricted memory regions. This represents a significant integrity and availability risk within the kernel's configuration filesystem interface.

From a classification perspective, this vulnerability aligns with CWE-824, which covers Access of Incorrectly Referenced Memory, as well as CWE-691 related to use of less secure constructs or logic errors in security-critical code. The flaw allows for potential exploitation through the configfs interface, potentially falling under ATT&CK techniques involving local privilege escalation via kernel vulnerabilities if an attacker can leverage the memory misalignment to execute arbitrary code or crash the system. The impact is primarily localized to systems utilizing Rust-based configfs implementations and depends on specific configurations where subsystem callbacks are invoked with group-level data structures that rely on accurate offset calculations.

To mitigate this vulnerability, it is essential to apply the upstream kernel patch that corrects the root detection logic. The fix involves replacing the null pointer check for cg_subsys with a direct comparison of the current group pointer against the subsystem's su_group field. This ensures that the code correctly identifies whether a group is indeed the root of a subsystem, thereby routing callbacks through the appropriate branch and ensuring accurate memory offset calculations. System administrators should update their Linux kernels to versions containing this fix immediately. Additionally, developers integrating Rust into kernel modules must ensure they are using updated libraries and adhering to strict safety comments as highlighted in recent compiler updates like Clippy 1.85.0, which helped identify some of these logical inconsistencies during static analysis. Regular auditing of filesystem driver implementations for similar pointer logic errors is also recommended to prevent recurrence of such structural flaws.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00166

KEV

no

Activities

very low

Sources

Are you interested in using VulDB?

Download the whitepaper to learn more about our service!