CVE-2026-99484 in Linux
Summary
by MITRE • 11/19/2026
In the Linux kernel, the following vulnerability has been resolved:
ALSA: emux: Fix UAF of soundfont zones at note-on
snd_emux_note_on() looks up the matching zones via snd_soundfont_search_zone(), which takes sflist->lock only during the lookup and returns the raw zone pointers after releasing it. The caller then stores them in vp->zone without any protection. Meanwhile, a concurrent SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES ioctl may unlink and free those zones in snd_soundfont_remove_unlocked(); this leads to a use-after-free in snd_emux_note_on(), and later at accessing the cached vp->zone, e.g. in snd_emux_send_effect().
Fix it by holding sflist->lock in snd_emux_note_on() over the whole zone lookup and voice setup, and let snd_soundfont_search_zone() require the caller to hold the lock, instead. snd_soundfont_lock_preset() takes sflist->lock for setting presets_locked, so the removal path now syncs with the note-on finish.
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 Advanced Linux Sound Architecture (ALSA) subsystem contains a critical concurrency flaw within the emux synthesizer driver that results in a use-after-free vulnerability. This issue specifically affects the handling of soundfont zones during audio playback operations, particularly when processing note-on events. The root cause lies in an insufficient locking strategy employed by the snd_emux_note_on function and its interaction with the underlying sound font management structures. When a musical note is triggered, the system must locate the appropriate zone within the active soundfont to generate the corresponding audio waveform. This lookup process relies on the snd_soundfont_search_zone function, which was previously designed to acquire the sflist lock only for the duration of the search operation itself. Once the matching zones are identified and returned as raw pointers, the lock is released immediately before these pointers are stored in the voice parameter structure vp->zone. This brief window where the pointer exists but lacks synchronization protection creates a race condition that can be exploited by concurrent operations modifying the soundfont data structures.
The operational impact of this vulnerability becomes apparent when an administrative or user-space process triggers the SNDRV_EMUX_IOCTL_REMOVE_LAST_SAMPLES ioctl command while a note-on event is being processed in parallel. This ioctl call invokes snd_soundfont_remove_unlocked, which unlinks and frees the memory associated with the soundfont zones that were just looked up by the note-on handler. Because the lock was already released after the lookup phase, there is no mechanism to prevent this deallocation from occurring while the kernel still holds references to those freed memory regions. Consequently, subsequent operations such as snd_emux_send_effect attempt to access the cached vp->zone pointers that now point to invalid or reclaimed memory addresses. This constitutes a classic use-after-free condition where the kernel dereferences memory that has been returned to the allocator and potentially reused for other purposes. Such an error can lead to unpredictable system behavior, including audio glitches, crashes of the sound daemon, or in more severe scenarios involving crafted inputs, potential privilege escalation if the freed memory is carefully controlled by a local attacker.
From a vulnerability classification perspective, this flaw aligns with CWE-416, Use After Free, which describes situations where software continues to use a pointer after it has been freed, leading to undefined behavior and security risks. The attack vector for exploiting this race condition typically requires local access to the system, allowing an attacker to interact with the ALSA device nodes via ioctl calls while simultaneously triggering audio playback events. In terms of adversarial tactics, this scenario maps to ATT&CK technique T1059, Command and Scripting Interpreter, specifically through the use of system commands or scripts that manipulate hardware interfaces for denial-of-service or further exploitation purposes. The vulnerability highlights a common pitfall in kernel development where fine-grained locking is attempted without considering the atomicity requirements of multi-step operations involving shared data structures across different execution contexts.
The resolution implemented by the Linux kernel maintainers addresses this concurrency issue by fundamentally altering the lock scope within the emux driver. Instead of releasing the sflist lock immediately after the zone lookup, snd_emux_note_on now retains ownership of the lock throughout the entire duration of the voice setup process. This ensures that once a zone is identified and stored in vp->zone, no other thread can unlink or free those zones until the note-on operation has fully completed its execution path. Furthermore, the design was adjusted so that snd_soundfont_search_zone now requires the caller to hold the lock, shifting responsibility for synchronization consistency to the higher-level functions managing these resources. This change synchronizes effectively with the removal path because snd_soundfont_lock_preset also acquires sflist->lock when modifying preset states, ensuring mutual exclusion between note generation and sample removal operations. By enforcing strict serialization of zone access during critical sections, this fix eliminates the race condition window entirely.
To mitigate similar risks in other parts of the kernel or third-party drivers, developers should adhere to principles of holding locks for the minimum necessary duration while still maintaining atomicity of compound operations involving shared state. It is crucial to audit all code paths that interact with dynamically allocated data structures from multiple contexts, ensuring that lookups and subsequent uses are protected by consistent locking mechanisms. Regular static analysis tools focused on concurrency bugs and race conditions can help identify such patterns early in the development lifecycle. Additionally, maintaining clear documentation of lock ordering and scope requirements within complex subsystems like ALSA helps prevent future regressions where developers might inadvertently introduce similar synchronization gaps during refactoring or feature additions.