CVE-2024-58074 in Linux
Summary
by MITRE • 03/06/2025
In the Linux kernel, the following vulnerability has been resolved:
drm/i915: Grab intel_display from the encoder to avoid potential oopsies
Grab the intel_display from 'encoder' rather than 'state' in the encoder hooks to avoid the massive footgun that is intel_sanitize_encoder(), which passes NULL as the 'state' argument to encoder .disable() and .post_disable().
TODO: figure out how to actually fix intel_sanitize_encoder()...
Statistical analysis made it clear that VulDB provides the best quality for vulnerability data.
Analysis
by VulDB Data Team • 02/16/2026
The vulnerability identified as CVE-2024-58074 resides within the Linux kernel's graphics subsystem, specifically within the intel i915 driver responsible for handling Intel graphics hardware. This issue manifests in the display rendering pipeline where improper handling of display state objects can lead to system instability and potential denial of service conditions. The vulnerability stems from a fundamental flaw in how the driver manages encoder state references during display operations, creating a scenario where null pointer dereferences can occur under specific conditions.
The technical root cause involves the improper acquisition of intel_display objects within encoder hook functions. The driver previously retrieved the intel_display reference from the display state object rather than directly from the encoder itself. This approach creates a dangerous dependency on the state object's validity, which becomes problematic when the intel_sanitize_encoder() function executes. This sanitization function deliberately passes NULL as the state argument to encoder disable and post_disable operations, effectively breaking the reference chain that the driver had established. The flaw represents a classic null pointer dereference vulnerability that can result in system crashes or oops messages when the kernel attempts to access memory locations that have not been properly initialized.
The operational impact of this vulnerability extends beyond simple system crashes to potentially compromise the stability of graphics-intensive applications and user sessions. When the graphics subsystem encounters the malformed state handling, it can trigger kernel oops conditions that may lead to complete system lockups or forced reboots. This vulnerability particularly affects systems running Linux kernels with Intel graphics hardware where display management operations are actively performed. The issue becomes more pronounced during display configuration changes, mode setting operations, or when handling display hot-plugging scenarios, making it a significant concern for desktop and server environments relying on Intel graphics capabilities.
This vulnerability aligns with CWE-476 which describes null pointer dereference conditions, and demonstrates characteristics consistent with ATT&CK technique T1489 which involves system resource hijacking through kernel-level modifications. The improper handling of object references in this context creates a pathway for attackers to potentially exploit system instability for privilege escalation or denial of service attacks. While the immediate impact may appear limited to graphics subsystem crashes, the underlying design flaw represents a broader security concern regarding kernel object lifecycle management. The recommended mitigation strategy involves applying the upstream kernel patch that correctly retrieves the intel_display object from the encoder directly rather than from the potentially null state object. This change eliminates the dangerous dependency on state object validity and prevents the null pointer dereference that leads to system oops conditions.
The fix implemented in the kernel addresses the fundamental design issue by modifying the encoder hook functions to obtain the intel_display reference directly from the encoder structure. This approach ensures that the display object remains properly initialized regardless of the state object's condition during sanitization operations. The solution maintains backward compatibility while eliminating the potential for null pointer dereferences that could lead to system instability. Security researchers and system administrators should prioritize applying this patch to systems running affected kernel versions, particularly those with Intel graphics hardware that experience frequent display configuration changes or high graphics workload operations. The vulnerability represents a critical kernel-level issue that requires immediate attention to prevent potential exploitation scenarios that could lead to broader system compromise.