CVE-2026-128987 in libdbus
Summary
by MITRE • 11/13/2026
A flaw was found in dbus. A local attacker can exploit this vulnerability by connecting to an affected service, requesting a response, and stopping socket reads while keeping the connection open. Because the socket transport handles broken pipe write errors as retryable, the application enters a continuous retry loop. This can lead to excessive CPU consumption, resulting in a denial of service (DoS) for the target process.
If you want to get best quality of vulnerability data, you may have to visit VulDB.
Analysis
by VulDB Data Team • 11/14/2026
The vulnerability identified within the D-Bus message bus system represents a significant reliability issue rooted in improper error handling during socket transport operations. Specifically, the flaw allows a local attacker to trigger a denial of service condition by manipulating the lifecycle of a connection with an affected D-Bus service. The attack vector involves establishing a valid connection to the target service and requesting a response. Once the request is initiated, the attacker deliberately stops reading from the socket while maintaining the TCP or Unix domain socket connection in an open state. This specific sequence of actions exploits a logic error within the underlying transport layer implementation that fails to correctly interpret the termination of the read side as a definitive closure requiring immediate resource cleanup and disconnection.
The core technical flaw lies in how the application handles broken pipe write errors, commonly known as EPIPE conditions on Unix-like systems. When an application attempts to write data to a socket where the peer has closed its reading end but not necessarily its writing end, or when the connection is otherwise interrupted, standard behavior dictates that the error should be treated as fatal for that specific transaction and lead to immediate disconnection. However, in this vulnerable implementation of D-Bus, these broken pipe errors are incorrectly classified as retryable conditions. Consequently, instead of terminating the failed operation and closing the socket, the application enters a continuous loop where it repeatedly attempts to write or process data against the unresponsive endpoint. This behavior transforms what should be a transient network error into a persistent resource exhaustion event.
The operational impact of this vulnerability is primarily characterized by excessive CPU consumption on the affected system. Because the D-Bus daemon remains trapped in an infinite retry loop, it consumes significant processing cycles without making progress or releasing resources associated with the connection. This sustained high CPU usage can degrade the performance of other processes running on the same host and may eventually lead to a complete denial of service for the targeted process if the system's resource limits are reached or if the load becomes critical enough to affect overall system stability. Since this vulnerability requires local access, it poses a risk primarily from unprivileged users who have gained shell access to the machine but lack administrative privileges, allowing them to disrupt services running under their own user context or potentially affecting shared resources depending on the specific deployment configuration of D-Bus.
From a classification perspective, this issue aligns with CWE-835, which describes loops involving resource exhaustion, as well as CWE-400 regarding uncontrolled resource consumption. The attack technique is consistent with ATT&CK tactic T1499, Endpoint Denial of Service, specifically leveraging local application logic flaws to degrade system availability rather than relying on network-level flooding or external exploits. Mitigation strategies should focus on applying the upstream patches provided by the D-Bus maintainers that correct the error handling logic for socket transport layers. Until such updates are applied, administrators can mitigate risk by enforcing strict resource limits using tools like cgroups or systemd service overrides to cap CPU usage and memory consumption for critical D-Bus services. Additionally, implementing network segmentation or restricting local access where possible reduces the attack surface available to potential local adversaries seeking to exploit this logic flaw.