Skip to main content

Schism Tracker EUVDEUVD-2026-103460

| CVE-2026-112007 MEDIUM
Out-of-bounds Write (CWE-787)
2026-10-18 VulnCheck GHSA-qfh4-g83h-4vcx
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 .ult module to victim
  2. Delivery
    Victim opens file in Schism Tracker
  3. Exploit
    ult.c loader skips MAX_SAMPLES clamp
  4. Execution
    Heap out-of-bounds write corrupts instrument pointers
  5. Persist
    csf_destroy() frees attacker-chosen pointers
  6. Impact
    Application crash / potential code execution

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 to open an attacker-supplied, specially crafted .ult (UltraTracker) module file in Schism Tracker version through 20260524; the malicious file sets a one-byte sample count that is not clamped to MAX_SAMPLES, triggering the heap out-of-bounds write. Limiting factors: the attack vector is local file parsing (not network-reachable), mandatory user interaction (the victim must load the file) is required, and no authentication or special non-default configuration is needed since any build parsing .ult files is affected. The confirmed outcome is an application crash via freeing attacker-chosen pointers; reliable code execution would additionally depend on heap-layout control.

Impact

This is a moderate-severity, client-side memory-corruption flaw whose real-world risk is low despite the availability of public exploit code. The vendor-supplied CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:L/VA:H) correctly characterizes it as a local, user-interaction-dependent issue: an attacker cannot reach the vulnerable fmt_ult_load_song() parser remotely but must convince a victim to open a crafted .ult module file. Publicly available exploit code exists (hackmd write-up plus VulnCheck advisory), raising the practical likelihood of weaponization, but there is no CISA KEV listing and no EPSS score was provided, so there is no evidence of active or widespread exploitation - this appears to be no public exploit of in-the-wild activity, only proof-of-concept. The primary demonstrated impact is availability loss (crash via csf_destroy() freeing attacker-chosen pointers), with the heap out-of-bounds write and arbitrary-free primitive raising a plausible but unproven path to code execution; the input vector itself scores VI:L rather than full integrity compromise. Net assessment: a genuine bug worth patching in affected deployments, but not an urgent fleet-wide priority given the niche product, local-only vector, and required user interaction.

Exploit ScenarioDerived

An attacker crafts a malicious .ult tracker module with a one-byte sample count exceeding MAX_SAMPLES and distributes it via a music-sharing site, forum, or email attachment. When a victim opens the file in Schism Tracker, the loader writes past the instruments pointer array on the heap, and on cleanup csf_destroy() frees attacker-controlled pointers, crashing the application. Public proof-of-concept exploit code for this out-of-bounds write is already available.

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

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

Alert me

AnalysisAIv1 – Oct 18, 2026

Heap out-of-bounds write in Schism Tracker through 20260524 allows a crafted .ult (UltraTracker) module to corrupt the tracker's instruments pointer array, so that cleanup in csf_destroy() frees attacker-chosen pointers and crashes the application. The defect is in fmt_ult_load_song() in fmt/ult.c, which accepts the file's one-byte sample count without clamping it to MAX_SAMPLES; any build that parses .ult files is affected and no special configuration or privileges are required. Publicly available exploit code exists (the flaw is not in CISA KEV), but the vector is local file parsing that requires the victim to load the file, so the confirmed outcome is denial of service and code execution would additionally depend on controlling heap layout.

RemediationAI

No vendor-released patch version is identified in the available data; remediation therefore starts with tracking the upstream repository (https://github.com/schismtracker/schismtracker) and the VulnCheck advisory (https://www.vulncheck.com/advisories/schism-tracker-through-20260524-heap-out-of-bounds-write-via-ult-loader) for a fixed build, and upgrading as soon as one is published. Until then, treat .ult modules as untrusted input: block or strip .ult files at mail and download gateways, and instruct users not to open UltraTracker modules from unknown sources, since the write triggers at load time before any playback. Where users must handle such files, run Schism Tracker inside an OS sandbox or low-privilege container (bubblewrap, firejail, or a restricted Windows/macOS sandbox profile) so that invalid frees and heap corruption are contained to a disposable process - the trade-off is restricted access to the user's music library and configuration paths, which must be explicitly re-granted. Bulk/automated conversion pipelines that parse .ult files should run in an isolated worker with a memory limit and restart-on-crash supervisor, accepting throughput loss in exchange for containment. A proof-of-concept write-up is publicly available at https://hackmd.io/@haindpwn/schismtracker-ult-sample-count-oob-write, so these compensating controls should be applied promptly rather than treated as theoretical.

Affected VersionsENISA

Schism Tracker 0 ≤20260524

Affected Packages

euvd schism_tracker 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

Schism Tracker is an open-source reimplementation of Impulse Tracker that loads a wide range of legacy tracker module formats, including the UltraTracker (.ult) format implemented in fmt/ult.c. In fmt_ult_load_song(), the sample/instrument count is read from a single byte of the file header and used to populate the song's instruments pointer array without being validated against the MAX_SAMPLES bound, a classic CWE-787 out-of-bounds write where an untrusted length field from a binary file format is trusted for loop/index arithmetic. Because the overwritten region is an array of pointers, the corruption is not just a length overrun: during teardown, csf_destroy() walks that same array and calls free() on each entry, so the attacker-influenced pointer values become invalid frees that abort the process (secondary heap corruption or arbitrary-free style behavior is possible). The attack surface is entirely client-side file parsing - the module must be opened locally by the victim - and exploitation reliability beyond a crash depends on heap grooming and the allocator in use, which is why the assessed vector keeps confidentiality impact at none and integrity at low while availability is high.

Know when Schism Tracker 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

File must be opened locally by a user, so AV:L and UI:R; no privileges needed (PR:N); crash gives A:H and limited heap write gives I:L with no confidentiality 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

Schism Tracker through 20260524 contains a heap out-of-bounds write vulnerability in fmt_ult_load_song() in fmt/ult.c that fails to clamp the one-byte sample count to MAX_SAMPLES. Attackers can supply a crafted .ult module that overwrites the instruments pointer array, causing csf_destroy() to free attacker-chosen pointers and crash the application.

Threat Intelligence Overview

Prevalence
Low
niche open-source tracker/music-authoring tool, no enterprise footprint
Exploit
POC
Public exploit code exists
Data Quality
4 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 N/A
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