Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft NSF file with chip_flags 0x3F
-
DeliveryDeliver file to victim via download or media library
-
ExploitApplication calls gme_open_data/gme_open_file
-
Executionmute_voices_ reads past 16-entry voice table
-
ImpactApplication crashes (denial of service)
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 a victim application to open an attacker-supplied NSF file through libgme's gme_open_data or gme_open_file entry points; the malicious trigger is an NSF header whose chip_flags value (e.g. 0x3F) implies a voice count exceeding the fixed 16-entry voice-type table, causing the out-of-bounds read in Classic_Emu::mute_voices_ during loading. Limiting factors: this is a local, file-based vector (AV:L) that depends on user interaction (UI:P) - the attacker cannot trigger it without the victim loading the crafted file - and only applies to applications linking libgme versions through 0.6.5 that process untrusted NSF input. Impact is confined to a crash (availability); no code execution, data disclosure, or privilege gain is indicated. |
| Impact | This is a medium-severity denial-of-service issue, not a top-tier priority, and the signals are largely consistent. The input CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:H) scores 6.8 and correctly reflects a local, file-parsing bug: the attacker does not deliver packets over a network but instead supplies a malicious NSF file that a victim (or an application processing untrusted input) must open, hence the passive user-interaction requirement and availability-only impact. A public POC/writeup exists (hackmd analysis by VulnCheck), which raises practical exploitability, but there is no CISA KEV listing and no EPSS score was provided, so there is no evidence of active or widespread exploitation - the exploit code demonstrates a crash, not remote code execution. The impact ceiling is low: CWE-125 out-of-bounds READ affecting only availability (a crash during loading), with no confidentiality or integrity impact per the vector. Note one tension worth flagging: the Tags list includes 'Information Disclosure', but both the description (crash/DoS only) and the CVSS metrics (VC:N/VI:N) indicate no data is exfiltrated - treat information disclosure as unconfirmed/theoretical for this global OOB read. Overall this is a real but modest bug: easy to trigger with a crafted file, but limited to crashing the consuming application. |
| Exploit ScenarioDerived | An attacker crafts a malicious NSF chiptune file with an invalid header (chip_flags set to 0x3F, implying a voice count beyond the 16-entry voice-type table) and distributes it via a download, chat, or media library. When a victim's media player or emulator built on libgme loads the file through gme_open_data or gme_open_file, Classic_Emu::mute_voices_ reads past a static array and crashes the application. A public proof-of-concept and technical writeup already demonstrate the out-of-bounds read. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 15, 2026
Opening a malicious NSF file through libgme's gme_open_data or gme_open_file entry points can crash the host application via a global out-of-bounds read in Classic_Emu::mute_voices_, as a chip_flags value such as 0x3F implies a voice count exceeding the fixed 16-entry voice-type table. This affects Game Music Emu (libgme) through version 0.6.5; the vulnerability is local (AV:L) and requires user interaction (UI:P) to load the crafted file, but requires no privileges (PR:N). Publicly available exploit code exists, and the CVSS 4.0 base score is 6.8, though no confirmed active exploitation (CISA KEV) has been observed. No vendor-released patch has been identified at time of analysis.
RemediationAI
No vendor-released patch has been identified at time of analysis. Until a fix is available, applications should avoid processing untrusted NSF files or should pre-validate NSF headers to reject any chip_flags value that would imply more than 16 voices (e.g., reject chip_flags 0x3F). Consider running libgme-dependent applications in a sandbox or with reduced privileges to limit the impact of a crash. Monitor the upstream repository and issue tracker at https://github.com/libgme/game-music-emu/issues/164 for a potential patch, and consult the VulnCheck advisory at https://www.vulncheck.com/advisories/game-music-emu-libgme-through-0.6.5-out-of-bounds-read-via-classic-emu-mute-voices for updates. Disabling NSF support in the application, if feasible, eliminates the attack vector but reduces functionality.
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
libgme (Game Music Emu) is a library for emulating chiptune and game music formats, including NSF (NES Sound Format). The NSF header contains a chip_flags field that indicates which sound chips are active; the Classic_Emu::mute_voices_ function uses a static 16-entry voice-type table to manage voices for the emulated chips. When chip_flags is set to a value like 0x3F, the implied voice count exceeds 16, causing an out-of-bounds read (CWE-125) past the end of the table during file loading. The vulnerability is reachable through gme_open_data or gme_open_file when processing untrusted NSF files, and it affects all versions of libgme up to and including 0.6.5 (CPE: cpe:2.3:a:libgme:game-music-emu:*:*:*:*:*:*:*:*). Source references point to gme/Classic_Emu.cpp (lines 66-80) and gme/Nsf_Emu.cpp (lines 212-218) in the libgme repository.
Know when Game Music Emu 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:N/VA:H/SC:N/SI:N/SA:N
File-parsing bug triggered by opening a crafted NSF, so AV:L and UI:R with no privileges (PR:N); out-of-bounds read only crashes the app, so C:N/I:N/A:H.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
Game Music Emu (libgme) through 0.6.5 contains a global out-of-bounds read vulnerability in Classic_Emu::mute_voices_ that allows attackers to crash applications by supplying NSF files whose voice count exceeds the 16-entry voice-type table. Attackers can craft an NSF header with chip_flags 0x3F, opened through gme_open_data or gme_open_file, to read past the static array during loading and cause denial of service.
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.
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Game Music Emu
View allgame-music-emu before 0.6.1 mishandles unspecified integer values. Rated critical severity (CVSS 9.8), this vulnerabilit
game-music-emu before 0.6.1 allows remote attackers to generate out of bounds 8-bit values. Rated high severity (CVSS 7.
game-music-emu before 0.6.1 allows remote attackers to write to arbitrary memory locations. Rated high severity (CVSS 7.
Stack-based buffer overflow in game-music-emu before 0.6.1. Rated high severity (CVSS 7.8), this vulnerability is no aut
Heap out-of-bounds read in libgme (Game Music Emu) through 0.6.5 allows local attackers to crash applications that parse
game-music-emu before 0.6.1 allows local users to cause a denial of service (divide by zero and process crash). Rated me
The Mem_File_Reader::read_avail function in Data_Reader.cpp in the Game_Music_Emu library (aka game-music-emu) 0.6.1 doe
EUVD-2026-102280
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB