Skip to main content

libTiMidity EUVDEUVD-2026-102281

| CVE-2026-111154 MEDIUM
Out-of-bounds Write (CWE-787)
2026-10-15 VulnCheck
6.9
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Deliver crafted .sf2 SoundFont file
  2. Delivery
    Victim app loads file via libTiMidity
  3. Exploit
    parse_gen processes out-of-range pgen/igen operators
  4. Execution
    Chosen 16-bit values written past Layer object
  5. Impact
    Stack memory corruption and crash

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, write limits
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

Exploitation requires the victim's application to load an attacker-supplied, crafted .sf2 SoundFont file through libTiMidity's SoundFont loader, where parse_gen reads out-of-range pgen/igen generator operator values. Key limiting factors: the CVSS vector is local (AV:L) and requires passive user interaction (UI:P) - the victim must open or process the malicious SoundFont - so there is no remote, autonomous exploitation; impact is primarily denial of service (crash) with only a constrained 16-bit write primitive, and exploitation depends on the host application actually using libTiMidity's .sf2 loading path.

Impact

Signals point to a moderate, file-parsing memory-safety bug rather than a top priority. The authoritative CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H) describes a local attack requiring the victim to process a malicious file, with the dominant impact being availability (VA:H, crashes) and only limited integrity (VI:L, bounded 16-bit writes) and no confidentiality loss - consistent with the description of a stack out-of-bounds write of chosen 16-bit values near the Layer object. A public POC/write-up exists (publicly available exploit code exists), but there is NO CISA KEV listing and NO EPSS score was provided, so there is no evidence of widespread or active exploitation; the POC demonstrates feasibility, not in-the-wild use. CWE-787 plus a controllable 16-bit write raises the theoretical ceiling toward code execution, but the vector's VI:L/VC:N rating and the 'causing crashes' framing suggest reliable arbitrary-code execution is not established. Net: a real, confirmed bug worth patching in affected deployments, but local+UI-dependent exploitation and the lack of KEV/EPSS keep it well below internet-facing critical issues. Note the input mixes signals - POC availability does not equal active exploitation, and the 16-bit write primitive means I:L/VI:L may understate the ceiling if exploitation is refined; treat RCE potential as unverified.

Exploit ScenarioDerived

An attacker distributes a crafted .sf2 SoundFont file (e.g., bundled with a song, shared online, or embedded in game/audio content) to a victim whose application uses libTiMidity for MIDI rendering. When the victim loads the file, parse_gen processes out-of-range pgen/igen generator operators and writes attacker-chosen 16-bit values past the stack Layer object, corrupting stack memory and crashing the process. A public POC write-up from VulnCheck demonstrates the out-of-bounds write.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 15, 2026

Stack out-of-bounds write in libTiMidity through 0.2.8 occurs when the SoundFont loader parses crafted .sf2 files, allowing an unauthenticated local attacker to corrupt stack memory via out-of-range pgen/igen generator operators in parse_gen, which writes chosen 16-bit values near the stack Layer object. This leads primarily to denial of service (crash) with a constrained memory corruption primitive; exploitation requires the victim to load a malicious SoundFont file (user interaction), and publicly available exploit code exists but there is no confirmed active exploitation. The assessed severity is moderate (CVSS 3.1 base score 6.1), consistent with a file-parsing memory-safety bug rather than a top-priority threat.

RemediationAI

No vendor-released patch was identified at the time of analysis. To mitigate, avoid loading untrusted .sf2 SoundFont files with libTiMidity; if SoundFont support is not required, disable or remove the .sf2 loading path. When processing potentially malicious files is unavoidable, run the parsing application in a sandboxed environment with minimal privileges and memory protections (ASLR, stack canaries) enabled-though these reduce exploit reliability, they do not eliminate the flaw. A source-level fix requires validating pgen/igen operator values against the SoundFont specification before writing; the vulnerable code is in src/sndfont.c lines 468-480. Consider switching to an alternative MIDI library that properly validates SoundFont files. Monitor the vendor repository (https://github.com/sezero/libtimidity) and the VulnCheck advisory (https://www.vulncheck.com/advisories/libtimidity-through-0.2.8-stack-out-of-bounds-write-via-parse-gen-in-soundfont-loader) for updates, and apply an official patch as soon as it becomes available. Public exploit code exists, so prioritize mitigations if your application processes .sf2 files from untrusted sources.

Affected VersionsENISA

libtimidity 0.2.8 ≤0.2.8

Affected Packages

euvd libtimidity no fix

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 1 package in euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

libTiMidity is a MIDI-to-WAV conversion library that supports SoundFont 2 (.sf2) files. The vulnerability resides in the SoundFont loader's parse_gen function (src/sndfont.c, lines 468-480), which processes generator operators (pgen and igen) from the file. CWE-787 (out-of-bounds write) is caused by missing bounds validation on these operator indices: out-of-range values cause a write of a 16-bit value to a location beyond the intended stack-allocated Layer structure, corrupting adjacent stack memory. The affected product is identified by CPE cpe:2.3:a:sezero:libtimidity:*:*:*:*:*:*:*:*, indicating all versions of sezero's libTiMidity are in scope, with the CVE specifically noting versions through 0.2.8. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N) confirms a local attack vector, no authentication, passive user interaction, and high availability impact, while the independent CVSS 3.1 assessment (AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:L/A:H) aligns with a denial-of-service outcome and low integrity impact. Publicly available exploit code exists (see references), but no KEV status is present.

Know when Libtimidity 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

Vendor (VulnCheck) PRIMARY 6.9 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N
vuln.today AI 6.1 MEDIUM

Local crafted-file parsing needing the victim to load the .sf2 gives AV:L/UI:R/PR:N; crashes drive A:H while the bounded 16-bit write yields I:L and no C impact.

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

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
Low
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

libTiMidity through 0.2.8 contains a stack out-of-bounds write vulnerability in the SoundFont loader that allows attackers to corrupt stack memory via unchecked generator operators in parse_gen. Attackers can supply a crafted .sf2 file with out-of-range pgen/igen operator values to write chosen 16-bit values near the stack Layer object, causing crashes and stack memory corruption.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Low
niche MIDI-to-WAVE rendering library, limited multimedia/audio-app footprint
Exploit
POC
Public exploit code exists
Data Quality
5 sources
Confidence: Medium

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 MEDIUM
CISA KEV No
Public POC Yes
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Medium

Priority Score

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

Attack Technique

A buffer overflow occurs when a program writes more data to a memory buffer than it was allocated to hold, causing the excess data to spill into adjacent memory regions.

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.

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