Skip to main content

FluidSynth CVE-2025-68617

HIGH
Use After Free (CWE-416)
2025-12-23 security-advisories@github.com
7.0
CVSS 3.1 · NVD
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Gain local control of FluidSynth-embedding application
  2. Delivery
    Trigger concurrent DLS file unload and synth teardown
  3. Exploit
    Win heap use-after-free race window
  4. Execution
    Reuse freed sample/font memory
  5. Impact
    Heap 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.2% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

NVD PRIMARY 7.0 HIGH
AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 7.0 HIGH

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.

3.1 AV:L/AC:H/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:H/AT:P/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from NVD.

CVSS VectorNVD

Attack Vector
Local
Attack Complexity
High
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

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

Why It Matters

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.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

EPSS Score
0.2%
Top 89% exploitable
Prevalence
Medium
common open-source audio synthesis library, but niche DLS feature and local-only vector
Exploit
POC
Public exploit code exists
Data Quality
3 sources
Confidence: Low

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC Yes
EPSS 0.2%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
Poc
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

55
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +35
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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

cpe:2.3:a:fluidsynth:fluidsynth:*:*:*:*:*:*:*:*

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy