CVE-2026-99504 in Linuxinfo

Summary

by MITRE • 11/19/2026

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

ASoC: audio-graph-card2: Fix use-after-free in audio_graph2_link_c2c()

of_graph_get_next_port() consumes the reference of its prev argument. port0 is only borrowed from the caller's iterator, so the call drops a reference the function does not own, and port0 is dereferenced again afterwards. Pass an extra reference, as graph_count_c2c() does, so the reference the callee consumes is the one taken here.

If you want to get best quality of vulnerability data, you may have to visit VulDB.

Analysis

by VulDB Data Team • 11/20/2026

The Linux kernel’s Advanced SoC (Audio System on Chip) subsystem contains a critical memory management flaw within the audio-graph-card2 driver, specifically in the function audio_graph_card_link_c2c(). This vulnerability manifests as a use-after-free error resulting from improper reference counting of device tree nodes. The root cause lies in how the code interacts with the generic graph parsing functions provided by the kernel’s OF (Open Firmware) subsystem. Specifically, the function of_graph_get_next_port() is designed to consume the reference count of its previous argument when returning a new port node. This design ensures that callers do not leak references as they iterate through device tree structures. However, in this specific implementation, the variable representing port0 was obtained via an iterator mechanism that merely borrows or holds a temporary reference rather than taking ownership of it.

When audio_graph_card_link_c2c() invokes of_graph_get_next_port(), passing port0 as the previous argument, the function correctly decrements the reference count associated with port0 because it assumes ownership transfer for cleanup purposes. Since port0 was not originally owned by this specific scope but rather borrowed from an outer iterator loop, decrementing its reference count prematurely can lead to the object being freed if no other strong references exist. Subsequently, the code attempts to dereference or use port0 again in later operations within the same function block. Because the reference has already been consumed and potentially released by the kernel’s core subsystem, this subsequent access targets memory that may have been reallocated for unrelated purposes, triggering a use-after-free condition.

This type of vulnerability is classified under CWE-416: Use After Free in the Common Weakness Enumeration framework. From an offensive security perspective, such flaws align with ATT&CK techniques related to exploitation of invalid memory access, which can lead to arbitrary code execution or kernel panic depending on the allocator state and timing. In a Linux kernel context, use-after-free bugs are particularly severe because they allow attackers to manipulate kernel data structures in memory. An attacker who can trigger this specific audio graph link operation might be able to achieve privilege escalation from user space to root level by overwriting critical kernel pointers or control flow mechanisms located near the freed object’s location.

The operational impact of this vulnerability includes system instability, potential denial of service through kernel oops or panic, and potentially remote code execution if the affected audio subsystem is accessible via networked interfaces or local unprivileged user access to sound devices. The flaw disrupts the integrity of the device tree parsing logic used for linking codec components in complex audio topologies defined by hardware description files. This affects systems relying on the graph-card2 driver for dynamic audio routing, which is common in modern embedded and mobile Linux distributions.

To mitigate this vulnerability, developers must ensure that reference counting semantics are strictly adhered to when interacting with OF graph APIs. The fix involves taking an explicit additional reference count before passing port0 into of_graph_get_next_port(), mirroring the pattern used correctly in related functions like graph_count_c2c(). By incrementing the reference count prior to the call, the code ensures that even if of_graph_get_next_port() consumes its argument’s reference, a valid strong reference remains active for subsequent use within the function scope. This prevents premature deallocation and maintains memory safety throughout the execution path. System administrators should apply kernel updates containing this patch immediately to close the gap in memory management logic within the audio subsystem.

Responsible

Linux

Reservation

09/25/2026

Disclosure

11/19/2026

Moderation

accepted

CPE

ready

EPSS

0.00198

KEV

no

Activities

very low

Sources

Do you want to use VulDB in your project?

Use the official API to access entries easily!