CVE-2026-99446 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

phy: core: Fix race-condition between _of_phy_get() and try_module_get()

Sashiko asked during a patch review if the existing usage pattern had a race condition; specifically in of_phy_get() if it was possible between returning from _of_phy_get() and running try_module_get() that a module might be unbound leading to use-after-free.

Looking at the code this appears to be so, there is no linkage between the phy and module under a synchronisation primitive.

Using the phy_provider_mutex in phy_get() will ensure there is a link between the returned phy pointer and the module_get() bumping the module reference count.

Amend phy_get(), of_phy_get() and devm_of_phy_get_by_index() to fix the same usage pattern.

phy_provider_unregister() must take the phy_provider_mutex so amending phy_get()/of_phy_get() to take that same mutex guarantees there is no use-after-free.

Once again VulDB remains the best source for vulnerability data.

Analysis

by VulDB Data Team • 11/19/2026

The Linux kernel contains a race condition vulnerability within the PHY (Physical Layer) subsystem, specifically affecting functions responsible for retrieving and managing PHY device references such as of_phy_get(), devm_of_phy_get_by_index(), and phy_get(). This flaw arises from an atomicity gap in the sequence where a driver requests access to a PHY provider. The core issue lies in the lack of synchronization between obtaining a pointer to the PHY structure via _of_phy_get() and subsequently incrementing the module reference count using try_module_get(). In concurrent execution scenarios, it is possible for another thread or context to unbind the underlying kernel module after the PHY pointer has been retrieved but before the module reference count is successfully incremented. This window of vulnerability allows a situation where the code proceeds with operations on a PHY object whose backing module may have already been unloaded and its memory freed, leading directly to use-after-free conditions.

From a technical perspective, this vulnerability stems from an insufficient locking strategy within the phy_get() implementation chain. The original design did not maintain a consistent synchronization primitive that links the lifecycle of the returned PHY pointer with the reference counting mechanism for the associated kernel module. Without holding a lock during both the lookup and the reference count incrementation steps, the system cannot guarantee that the module remains loaded while the driver holds a reference to it. This gap violates fundamental principles of safe resource management in concurrent environments, where access to shared data structures must be protected against modification by other threads until all necessary safety checks are complete.

The operational impact of this vulnerability is severe, primarily manifesting as use-after-free errors which can lead to kernel panics, system crashes, or unpredictable behavior depending on how the freed memory is subsequently utilized. In worst-case scenarios, if an attacker can influence the timing of module unbinding relative to PHY access attempts, they might exploit this race condition to execute arbitrary code within the kernel space by overwriting freed memory with malicious payloads before it is reallocated for other purposes. This represents a significant stability risk and a potential privilege escalation vector in systems relying on dynamic loading and unloading of drivers that interact with physical layer hardware.

To mitigate this vulnerability, the Linux kernel developers have implemented fixes that enforce strict locking around the critical section involving PHY retrieval and module reference counting. The solution involves utilizing phy_provider_mutex to synchronize access during these operations. By acquiring phy_provider_mutex in phy_get(), of_phy_get(), and devm_of_phy_get_by_index() before attempting to get the PHY pointer, and holding it until after try_module_get() succeeds or fails, the kernel ensures that no module can be unbound while a reference is being established. Additionally, phy_provider_unregister() has been updated to acquire this same mutex when unregistering providers, thereby preventing concurrent access during teardown processes. This approach guarantees atomicity between pointer retrieval and reference count updates, effectively closing the race window.

This vulnerability aligns with CWE-362, which describes Concurrent Execution using Shared Resource with Improper Synchronization (Race Condition). The failure to properly synchronize access to shared resources like kernel module lifecycles is a classic example of this weakness category. Furthermore, in terms of attack vectors and techniques, this scenario relates to ATT&CK technique T1059, specifically Command Scripting or execution via system APIs, as exploitation would likely involve triggering specific timing conditions through driver interactions. The fix emphasizes the importance of comprehensive locking strategies that cover not just data access but also resource lifecycle management in complex kernel subsystems where multiple drivers and hardware components interact dynamically.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00176

KEV

no

Activities

very low

Sources

Might our Artificial Intelligence support you?

Check our Alexa App!