FluidSynth
CVE-2025-68617
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessGain local control of FluidSynth-embedding application
-
DeliveryTrigger concurrent DLS file unload and synth teardown
-
ExploitWin heap use-after-free race window
-
ExecutionReuse freed sample/font memory
-
ImpactHeap corruption enabling crash or code execution
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Memory lifecycle management
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Privilege Escalation The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Requires FluidSynth built WITH native DLS support (builds compiled without native DLS support are entirely unaffected), running an affected version 2.5.0 through 2.5.1. The flaw triggers only in a multithreaded condition: a thread pending to unload a DLS file races against either concurrent synthesizer destruction OR concurrent audio synthesis that still uses samples from the file being unloaded. LIMITING FACTORS: exploitation needs local access to (or control over) the host application's DLS load/unload and synthesis lifecycle, precise thread timing to win the race (hence AC:H), and application-driven user interaction (UI:R). The bug does NOT occur when a DLS file is explicitly unloaded before synth destruction provided no active voices are using that file's samples at unload time. |
| Impact | This is a genuine but conditional memory-safety flaw, not a top-tier emergency. The vendor-assigned CVSS 3.1 vector (AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H = 7.0 High) is internally consistent with the description: exploitation is LOCAL (AV:L), requires winning a concurrency race (AC:H), needs the victim application to perform specific actions such as loading/unloading a DLS file (UI:R), but needs no prior authentication (PR:N). A publicly available exploit/repro exists (GitHub issue #1717 is flagged as an exploit), which raises practical concern, but there is NO CISA KEV listing and NO EPSS score provided in the input, so there is no evidence of active, widespread exploitation - exploitation status is 'publicly available exploit code exists' and must NOT be conflated with in-the-wild use. SSVC-style reasoning: technical impact is total (C/I/A all High, consistent with a heap use-after-free that can corrupt memory), but the attack is NOT automatable - it depends on a non-deterministic thread-timing race (AC:H) triggered by application-controlled load/unload operations, so this is realistically a targeted or local-abuse scenario rather than a mass-exploitable remote bug. The CVSS High (7.0) therefore somewhat overstates real-world urgency for most deployments because the local vector, high attack complexity, and required user/application interaction sharply narrow who can trigger it. Note one caveat to verify: the raw CVSS is vendor-reported and EPSS is absent, so the exploitation-likelihood signal is incomplete. |
| Exploit ScenarioDerived | An application embedding FluidSynth (compiled with native DLS support, versions 2.5.0 up to but not including 2.5.2) unloads a DLS SoundFont while, on another thread, the synthesizer is being destroyed or voices are still rendering audio from that file's samples. The race causes one thread to use heap memory already freed by the other, corrupting the heap and potentially enabling crash or code execution. A public reproducer exists in the project's issue tracker, though triggering requires precise thread timing (AC:H) and local control over the host application's DLS operations. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 19, 2026
Heap-based use-after-free in FluidSynth 2.5.0 through 2.5.1 built with native DLS support allows memory corruption when a DLS file unload races against synthesizer destruction or against audio synthesis still referencing that file's samples, yielding high confidentiality, integrity and availability impact (CVSS 3.1 base 7.0). The attacker profile is a local, unauthenticated actor (AV:L, PR:N, AC:H, UI:R) who can influence the host application's DLS load/unload and synthesis lifecycle and win a narrow thread-timing window. Publicly available exploit code exists (referenced GitHub issues) but there is no CISA KEV confirmation of active exploitation, and builds compiled without native DLS support are unaffected. Vendor-released patch: 2.5.2.
RemediationAI
Upgrade FluidSynth to 2.5.2 or later (vendor-released patch; see https://github.com/FluidSynth/fluidsynth/security/advisories/GHSA-ffw2-xvvp-39ch), or apply the upstream commits 685e54cdc44911ace31774260bd0c9ec89887491 and 962b9946b5cb6b16f0c08b89dd1b7016d4fce886 if backporting to an embedded copy - note these are upstream commits, so a downstream patched release is not independently confirmed for third-party forks. Where immediate upgrade is not possible, the strongest compensating control is to configure or rebuild FluidSynth without native DLS support (the vulnerable code is excluded entirely), at the cost of losing DLS bank playback; alternatively, disable DLS loading at the application layer and accept the same functional loss. Applications that must keep DLS support should serialize DLS unload against synthesizer destruction and audio rendering with an application-level mutex covering the load/unload and synthesis lifecycle, trading real-time audio latency and possible render-thread stalls for race elimination, and should never unload a DLS file while voices still reference its samples (the documented safe pattern: unload explicitly before synth destruction once no active voices use the file). Finally, avoid loading DLS files from untrusted sources and keep host applications on vendor-updated FluidSynth builds, since exploit code for the race is publicly referenced in the upstream issue tracker (https://github.com/FluidSynth/fluidsynth/issues/1717).
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
FluidSynth is a real-time software synthesizer library that renders SoundFont 2 and Downloadable Sounds (DLS) sample banks into audio across multiple threads; voices hold references into loaded sample data while a separate thread may load or unload fonts. The root cause is CWE-416 (use-after-free) driven by a race condition in the DLS loader: internal structures (fluid_dls_font and the defsfont loader) stored a borrowed const fluid_file_callbacks_t* pointer rather than owning a copy, so after a font was deleted the callback table could be dereferenced while a concurrently pending unload or a still-active voice touched freed sample memory. The upstream fix (commit 685e54cdc44911ace31774260bd0c9ec89887491) changes fluid_file_callbacks_t from a pointer member to an inline value copy in fluid_dls_font and fluid_defsfont, and adjusts fluid_sffile_open() to pass &defsfont->fcbs, eliminating the dangling callback reference and the lifetime dependency between the font object and its callbacks; a companion fix is commit 962b9946b5cb6b16f0c08b89dd1b7016d4fce886. Because the defect lives in the DLS code path (src/sfloader/fluid_dls.cpp), configurations built without native DLS support never execute the vulnerable logic.
Know when Fluidsynth gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
Local in-process concurrency race (AV:L), timing-dependent race gives AC:H, no auth needed (PR:N) but app-driven DLS/synth actions are required (UI:R); UAF can fully corrupt memory so C/I/A all High.
Primary rating from NVD.
CVSS VectorNVD
DescriptionNVD
FluidSynth is a software synthesizer based on the SoundFont 2 specifications. From versions 2.5.0 to before 2.5.2, a race condition during unloading of a DLS file can trigger a heap-based use-after-free. A concurrently running thread may be pending to unload a DLS file, leading to use of freed memory, if the synthesizer is being concurrently destroyed, or samples of the (unloaded) DLS file are concurrently used to synthesize audio. This issue has been patched in version 2.5.2. The problem will not occur, when explicitly unloading a DLS file (before synth destruction), provided that at the time of unloading, no samples of the respective file are used by active voices. The problem will not occur in versions of FluidSynth that have been compiled without native DLS support.
Executive ViewAI
FluidSynth 2.5.0 and 2.5.1 builds with native DLS support contain a heap use-after-free that can corrupt memory when a DLS file is unloaded during synthesizer teardown or audio synthesis, creating a local code-execution and crash risk for applications that embed this library. Publicly available exploit code exists, but CISA KEV has not confirmed active exploitation, so the immediate business concern is targeted local attacks or destabilization of audio-processing workloads rather than broad opportunistic compromise. Leadership should prioritize inventory and remediation of affected embedded and host applications, especially where untrusted DLS files or user-controlled audio assets are processed.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Use-after-free vulnerabilities occur when a program continues to access memory through a pointer after that memory has been deallocated.
Memory corruption occurs when a program writes data beyond the boundaries of allocated memory regions or accesses memory in unintended ways, violating the integrity of the process's address space.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Affected Products (CPE)NVD
More in Fluidsynth
View allfluidsynth-2.4.6 and earlier versions is vulnerable to Null pointer dereference in fluid_synth_monopoly.c, that can be t
Out-of-bounds heap write in FluidSynth's command handler lets an attacker supply an out-of-range channel argument to the
fluidsynth is a software synthesizer based on the SoundFont 2 specifications. Rated medium severity (CVSS 5.5), this vul
Out-of-bounds reads in FluidSynth 2.5.0 through 2.5.5 can be triggered when the process loads and renders an attacker-co
Out-of-bounds heap read and write in FluidSynth's MIDI player channel-tracking logic corrupts memory whenever the synth.
Out-of-bounds write in FluidSynth (versions through 2.6.1) allows an attacker to corrupt heap and stack memory by gettin
FluidSynth builds compiled with the native DLS parser enabled can be driven into a local denial of service by a crafted
A 32-bit integer overflow in FluidSynth's native DLS parser lets a crafted DLS sound-bank file bypass the ptbl chunk-siz
Memory exhaustion and denial of service in FluidSynth 2.5.0 through 2.5.5 allows an attacker to crash any application th
NVD
CVE.org
EPSS
GitHub
Exploit-DB