CVE-2026-99328 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
HID: picoLCD: check for fb_deferred_io_init() error
fb_deferred_io_init() allocates deferred I/O state, populating info->fbdefio_state, or leaving it NULL if an error occurs.
Currently picolcd_init_framebuffer() ignores its return value.
Therefore if an error arises in fb_deferred_io_init() (for instance, due to an allocation failure) info->fbdefio_state is left NULL.
When the file is subsequently opened, fb_open() will dereference a NULL pointer (calling fb_deferred_io_open()).
Fix this by checking for the error.
Also correct cleanup ordering - defio is initialised after the sysfs file, so cleanup defio first.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 11/20/2026
The Linux kernel's Human Interface Device subsystem contains a critical flaw within the picoLCD driver related to improper error handling during framebuffer initialization. The vulnerability stems from the picolcd_init_framebuffer function failing to validate the return value of fb_deferred_io_init, a core kernel routine responsible for allocating and initializing deferred I/O state structures. When this initialization sequence encounters an issue, such as a memory allocation failure or other resource constraints, it returns an error code while leaving the info->fbdefio_state pointer in a NULL state rather than populating it with valid data. By neglecting to check this return value, the driver proceeds under the false assumption that deferred I/O has been successfully established, creating a latent defect that manifests during subsequent runtime operations.
This oversight leads directly to a null pointer dereference vulnerability when the associated device file is opened by user-space applications or system processes. The fb_open function attempts to invoke fb_deferred_io_open as part of its standard initialization sequence for framebuffer devices. Because the deferred I/O state was never properly allocated due to the earlier ignored error, this call targets a NULL address in kernel memory space. Such an access violation triggers a kernel panic or oops condition, effectively causing a denial of service against the local system. This type of flaw is particularly dangerous because it can potentially be triggered by unprivileged users who have permission to open device nodes associated with HID devices, thereby allowing any local user to crash the entire operating system without requiring elevated privileges.
From a classification perspective, this vulnerability aligns closely with CWE-252, which describes unchecked return values as a common source of software weaknesses. The failure to verify that critical initialization functions have completed successfully is a fundamental deviation from secure coding practices in systems programming. Furthermore, the operational impact corresponds to ATT&CK technique T1083, specifically the file and directory discovery aspect where an attacker might probe for device availability, although the primary exploit vector here is simply opening the device node rather than complex reconnaissance. The resulting system instability represents a significant reliability issue that undermines the integrity of the kernel's stability guarantees.
The remediation strategy involves two key technical adjustments to restore robustness and correct resource management lifecycle ordering. First, the code must be modified to explicitly check the return value of fb_deferred_io_init within picolcd_init_framebuffer. If an error is detected, the initialization process should abort immediately, preventing the driver from registering a partially initialized device that would inevitably lead to crashes upon access. Second, the cleanup logic requires correction regarding resource deallocation order. Since deferred I/O structures are allocated after sysfs files in the initialization sequence, they must be released first during teardown to prevent use-after-free scenarios or double-free errors. This ensures that dependent resources do not outlive their dependencies, maintaining memory safety throughout the device's lifecycle and preventing secondary vulnerabilities arising from incorrect cleanup sequences.