Skip to main content

libTiMidity EUVDEUVD-2026-102282

| CVE-2026-111155 MEDIUM
Out-of-bounds Read (CWE-125)
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 to victim
  2. Delivery
    Victim loads file via mid_set_soundfont()
  3. Exploit
    Unvalidated sampleId/generator used as table index
  4. Execution
    Out-of-bounds heap read in sndfont.c
  5. Impact
    Memory disclosure and application crash

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Bounds checking, read limits
MITRE ATT&CK

1 technique across 1 tactic: Collection

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires that the target application call libTiMidity's mid_set_soundfont() to load an attacker-controlled .sf2 SoundFont file (through libTiMidity version 0.2.8 or earlier); the specific trigger is a crafted sampleId value and/or instrument generator value used directly as a table index in the SoundFont loader (src/sndfont.c). LIMITING FACTORS: the attack is local (AV:L) and requires passive user interaction (UI:P) - the victim must open or load the malicious SoundFont, so there is no remote or autonomous exploitation; impact is limited to a heap out-of-bounds read yielding memory disclosure and application crash, with no confirmed integrity or code-execution impact. Any product that does not parse untrusted/third-party SoundFont files is effectively unaffected.

Impact

This is a genuine but moderate-priority issue, not a critical remote threat. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/VA:H, score 6.9) describes a LOCAL attack requiring passive user interaction - the victim must load an attacker-supplied .sf2 SoundFont file via mid_set_soundfont(). This is not network-reachable despite PR:N, so the PR:N (no privileges) is offset by the mandatory file-delivery and UI:P requirement. Impact is dominated by availability (VA:H, application crash) with only low confidentiality (VC:L, limited heap memory disclosure via out-of-bounds read); there is no integrity impact and no code execution asserted in the description. Publicly available exploit code exists (reported by VulnCheck), which raises practical exploitability, but there is no CISA KEV listing and no EPSS score provided, so there is no evidence of active or widespread exploitation. NOTE A CONFLICT: the exploit reference (hackmd) is titled '...generator-oper-oob-write' implying an out-of-bounds WRITE, while the CVE description and CWE-125 both specify an out-of-bounds READ - verify whether a write primitive also exists, as that would materially increase severity beyond crash/info-leak. Net: a real, confirmed-with-POC bug worth patching in any product that parses untrusted SoundFonts, but the local vector and user-interaction requirement keep real-world risk moderate rather than urgent.

Exploit ScenarioDerived

An attacker crafts a malicious .sf2 SoundFont file with manipulated sampleId or instrument generator values and delivers it to a victim (e.g., bundled with a MIDI package or hosted for download). When the victim's application loads the file through libTiMidity's mid_set_soundfont(), the unvalidated indices drive an out-of-bounds heap read, leaking adjacent heap memory and/or crashing the application. Publicly available exploit code (VulnCheck) demonstrates the condition, and the local/user-interaction nature means delivery relies on social engineering or malicious content distribution.

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

Heap out-of-bounds reads in the SoundFont loader (src/sndfont.c) of libTiMidity 0.2.8 and earlier allow an attacker to disclose heap memory and crash an application whenever a crafted .sf2 SoundFont is loaded through mid_set_soundfont(). The attack is local and requires the victim to open or otherwise load the malicious SoundFont (UI:P with AV:L), so the impact is bounded to low-confidentiality memory disclosure and a high-availability crash, with no confirmed integrity loss or code execution; any product that never parses untrusted or third-party SoundFont files is effectively unaffected. Publicly available exploit code exists - a public writeup and the referenced upstream source lines demonstrate the unvalidated sampleId/generator indexing - but there is no evidence of active exploitation, and exploitation prerequisites make this a moderate-priority rather than a critical remote threat.

RemediationAI

No vendor-released patch was identified at time of analysis - no fixed version is listed in the advisory data, and the references point only to the upstream repository - so monitor https://github.com/sezero/libtimidity and the VulnCheck advisory at https://www.vulncheck.com/advisories/libtimidity-through-0.2.8-out-of-bounds-read-via-soundfont-loader-sndfont-c for a release newer than 0.2.8 and upgrade as soon as one appears. In the meantime, the single most effective control is to stop calling mid_set_soundfont() on attacker-influenced .sf2 files and restrict the library to vetted, locally trusted SoundFont banks; if user-supplied SoundFonts are an explicit product requirement, isolate the parsing path by loading the bank in a sandboxed, low-privilege child process (seccomp, AppArmor, or sandbox-exec with no network access and a read-only filesystem), which contains a crash or memory leak but adds process-management complexity. Validate and sanitize incoming .sf2 files before handing them to libTiMidity - checking that sampleId and instrument generator values fall inside their expected table ranges and rejecting banks that fail - with the caveat that hand-rolled parsers are themselves bypass-prone and may reject legitimate banks, so this should be layered, not relied upon alone. Run any parsing of untrusted banks under AddressSanitizer or Valgrind in test pipelines to catch malformed inputs early, and since the bug is a read, treat any application crash on a third-party SoundFont as a potential heap-layout disclosure event. Outright disabling SoundFont playback eliminates the attack surface at the cost of audio functionality; upgrading to a version that bounds-checks these indices is the only complete fix.

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 lightweight MIDI rendering library that converts MIDI sequences to PCM/WAV by pulling samples from SoundFont 2 (.sf2) banks; applications load such banks by calling the API mid_set_soundfont(). The .sf2 format stores instruments as lists of generator records plus sample identifiers, and libTiMidity's parser in src/sndfont.c (the referenced code is lines 578-590 of the sezero fork at commit a52adf6) uses the attacker-controlled sampleId and instrument generator values directly as indices into heap-allocated tables without validating them against the table bounds. This is the classic CWE-125 out-of-bounds read pattern: the index is never range-checked, so a malformed SoundFont causes reads past the end of a heap buffer, yielding disclosure of adjacent heap contents and, depending on the allocator layout, a crash. The CPE cpe:2.3:a:sezero:libtimidity:*:*:*:*:*:*:*:* identifies the affected codebase as the sezero libTiMidity fork through 0.2.8. The supplied CVSS 4.0 vector (6.9, AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/VA:H) is consistent with our independently assessed CVSS 3.1 vector (AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H): unauthenticated in the sense that no credentials are needed, but entirely dependent on the victim loading attacker-supplied data, with confidentiality limited and availability impact high due to the crash. Note that one reference URL is titled '...oob-write'; the CVE description, CWE-125 assignment, and our assessment all characterize the confirmed defect as an out-of-bounds read, so any write-related claim in that writeup should be treated as unverified.

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:L/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 6.1 MEDIUM

Requires a victim to locally load a crafted .sf2 file, so AV:L and UI:R; no auth needed (PR:N); impact is limited heap read (C:L) and crash (A:H), no integrity.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:L/I:N/A:H
4.0 AV:L/AC:L/AT:N/PR:N/UI:P/VC:L/VI:N/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
Low
Vulnerable system: Integrity
None
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 heap out-of-bounds read vulnerability in the SoundFont loader in src/sndfont.c that uses unvalidated sampleId and instrument generator values as table indices. Attackers can supply a crafted .sf2 file loaded through mid_set_soundfont() to read heap memory out of bounds and crash the application.

Threat Intelligence Overview

EPSS Score
0.1%
Top 98% exploitable
Prevalence
Low
niche MIDI-to-audio library, limited to specific media/game software
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.

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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