Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver crafted .ult module to victim
-
DeliveryVictim opens file in Schism Tracker
-
Exploitult.c loader skips MAX_SAMPLES clamp
-
ExecutionHeap out-of-bounds write corrupts instrument pointers
-
Persistcsf_destroy() frees attacker-chosen pointers
-
ImpactApplication 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
Affected Packages
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
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
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.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
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
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
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.
More in Schism Tracker
View allAn issue was discovered in Schism Tracker through 20190722. Rated high severity (CVSS 7.8), this vulnerability is no aut
An issue was discovered in Schism Tracker through 20190722. Rated high severity (CVSS 7.8), this vulnerability is no aut
fmt_mtm_load_song in fmt/mtm.c in Schism Tracker 20190722 has a heap-based buffer overflow. Rated high severity (CVSS 7.
EUVD-2026-103460
GHSA-qfh4-g83h-4vcx
NVD
CVE.org
Exploit-DB