CVE-2026-99508 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

media: ipu-bridge: Fix use-after-free in IVSC error path

ipu_bridge_get_ivsc_acpi_dev() returns an ACPI device with a reference held. If no matching CSI device is found, ipu_bridge_check_ivsc_dev() drops that reference before passing the device to dev_err(). Concurrent CSI device and ACPI namespace removal can drop the other references, making this the final put. dev_err() then reads the freed struct acpi_device and its kobject name.

This was reproduced without kprobes by racing normal CSI platform-device unregistration and ACPI configfs table removal against the production ipu_bridge_init() entry. KASAN reported the final free through device_release(), followed by invalid reads through _dev_err().

Emit the error message while the lookup reference is still held, then drop the reference as before.

Source reproducers and vulnerable/fixed serial logs, with only the build hostname redacted, are available at: https://github.com/kimaiden1984-boop/linux-ipu-bridge-acpi-uaf-reproducer

The fixed target builds with W=1 on x86-64. This was not tested on physical IPU hardware. The tests establish runtime reachability but do not measure occurrence frequency on shipping systems or establish exploitability.

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 media subsystem contains a critical use-after-free vulnerability within the ipu_bridge driver, specifically affecting the initialization path when interacting with Intel Video Sensor Controller (IVSC) devices via ACPI. The core of this flaw lies in improper reference counting management during error handling sequences. When the function ipu_bridge_get_ivsc_acpi_dev() is invoked to locate an associated CSI device, it returns a pointer to an acpi_device structure while holding a reference count on that object. Under normal operational conditions where a matching device is found, this reference is managed correctly throughout the lifecycle of the driver initialization. However, in scenarios where no matching CSI device exists or if specific error conditions are triggered during the lookup process, the code path within ipu_bridge_check_ivsc_dev() prematurely drops this reference count before logging an error message via dev_err().

This premature release creates a race condition window that can be exploited through concurrent system events. Specifically, when normal platform-device unregistration for CSI devices occurs simultaneously with ACPI configuration file system table removals, the kernel's device core may execute additional cleanup routines such as device_release(). If these parallel operations reduce the reference count to zero before the error logging function completes its execution, the acpi_device structure is freed from memory. Subsequently, when dev_err() attempts to access the struct acpi_device pointer and read its kobject name field for diagnostic output purposes, it performs a read operation on already deallocated memory. This constitutes a classic use-after-free vulnerability that can lead to kernel panics, data corruption, or potentially arbitrary code execution depending on how the freed memory is reallocated by other subsystems.

The technical nature of this flaw aligns with CWE-416, which describes Use After Free vulnerabilities where software continues to use a pointer after it has been freed. In the context of attack frameworks such as MITRE ATT&CK, this vulnerability falls under techniques related to privilege escalation or denial of service through memory corruption exploitation. The ability to trigger a kernel crash via concurrent device removal and ACPI namespace manipulation demonstrates that an attacker with local access could potentially destabilize the system by racing these specific events during driver initialization phases. While direct exploitability for code execution requires further analysis of heap state management, the immediate impact is severe reliability degradation due to invalid memory reads causing undefined behavior within the kernel space.

Mitigation strategies primarily involve correcting the reference counting logic in the affected source files. The resolution entails ensuring that error messages are emitted while the lookup reference remains valid and held by the calling function. Only after the diagnostic output has been safely generated should the reference count be decremented to release ownership of the device structure. This simple ordering change eliminates the window where the pointer becomes dangling but is still accessed. For system administrators, applying kernel updates that include this patch is essential to restore stability in environments utilizing Intel IPU hardware or similar ACPI-managed media devices. Additionally, developers should audit other error paths within the ipu_bridge driver and related subsystems for similar patterns of premature reference dropping before logging operations to prevent recurrence of such memory safety issues across the Linux kernel codebase.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00208

KEV

no

Activities

very low

Sources

Do you need the next level of professionalism?

Upgrade your account now!