Skip to main content

gbsplay CVE-2026-116727

| EUVDEUVD-2026-110475 MEDIUM
Out-of-bounds Read (CWE-125)
2026-10-26 VulnCheck GHSA-f826-v6gp-c5xh
4.8
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft VGM file with wait opcodes and no 0x66 terminator
  2. Delivery
    Deliver file to gbsplay user
  3. Exploit
    Victim plays crafted file
  4. Execution
    vgm_open() walks command stream past buffer end
  5. Impact
    Heap out-of-bounds read crashes player

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 the victim to open/play an attacker-supplied crafted VGM file in gbsplay (≤0.0.103) - the vector is local (AV:L) and mandates user interaction (UI:P), so there is no remote or unattended trigger. The specific trigger is a VGM command stream containing wait opcodes with the 0x66 end-of-data terminator absent, which makes the unbounded loop in vgm_open() read past the heap buffer. No special configuration is needed beyond running an affected build and the standard VGM-playback code path. Limiting factors: the attack only works against vulnerable versions, delivers a crash (no code execution or confirmed data exposure), and depends entirely on social delivery of the malicious file plus the user's decision to play it.

Impact

All signals converge on LOW real-world priority despite the medium 4.8 base score. The CVSS 4.0 vector is local and interaction-dependent (AV:L/AC:L/AT:N/PR:N/UI:P) with the only impact being availability (VA:L) - a crash - and no confidentiality or integrity impact (VC:N/VI:N), so this is a denial-of-service of a client-side media player, not a code-execution or data-exposure flaw. EPSS is 0.13% (3rd percentile), indicating very low predicted exploitation, and there is NO CISA KEV listing, so there is no evidence of active exploitation. The vuln.today decision label is 'this_month', the second-lowest urgency tier - not 'act_now' or 'emergency'. Note a tag/impact tension: the input tags include 'Information Disclosure', but the description and the CVSS vector (VC:N) describe a crash from an out-of-bounds READ with no attacker-observable data exposure, so treat this as a DoS, not confirmed information disclosure. The only amplifying factor is PR:N (no authentication to craft a file), but that is offset by the local vector and mandatory user interaction (the victim must choose to play the malicious file).

Exploit ScenarioDerived

An attacker crafts a malicious VGM file containing wait opcodes and omitting the 0x66 end-of-data terminator, then distributes it (e.g., bundled with chiptune/ROM archives) to a user of gbsplay 0.0.103 or earlier. When the victim plays the file, vgm_open() in gbs.c walks the command stream without bounds checks, reads past the end of the heap buffer, and crashes the player. A public PoC reference exists (hackmd write-up and GitHub issue #201); it is not verified as working exploit code, and the local vector plus required user interaction keep impact limited to a crash.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 28, 2026

Heap out-of-bounds read in gbsplay's VGM loader (vgm_open() in gbs.c) allows a crafted .vgm file to walk the command-stream parser past the end of its heap buffer and crash the player. All builds through 0.0.103 are affected; the trigger is a VGM stream containing wait opcodes without the 0x66 end-of-data terminator, which leaves the parse loop running to and beyond the buffer boundary. The vector is local and requires the victim to open or play the malicious file (CVSS:3.1/AV:L/AC:L/PR:N/UI:R), and impact is confined to availability - no code execution or confirmed disclosure. EPSS is 0.13% (3rd percentile), there is no KEV entry or confirmed active exploitation, no verified working exploit code is publicly available (a public technical write-up exists but is not verified as working exploit code), and a bounds-checking upstream fix commit is referenced.

RemediationAI

Apply the upstream fix commit 91b1f6df0abd3914f91caa528ec3213d731999e8 (https://github.com/mmitch/gbsplay/commit/91b1f6df0abd3914f91caa528ec3213d731999e8), which adds the missing bounds checks in vgm_open(); the vendor reports a patch is available, but no tagged fixed release version number is given in the available data, so confirm with the project repository or VulnCheck advisory before assuming a specific release contains it. Until a fixed build is deployed, the effective control is to avoid opening or playing untrusted .vgm files - the flaw is only reachable by parsing an attacker-supplied file through the normal VGM playback path, so restricting playback to files of known provenance removes the trigger entirely, at the cost of blocking legitimate third-party VGM content. Because impact is limited to a player crash, deployments that only process trusted content (or that run gbsplay in a non-critical, sandboxed context) face low operational exposure. Track the upstream issue https://github.com/mmitch/gbsplay/issues/201 for the release that ships the fix.

Affected VersionsENISA

gbsplay 0 ≤0.0.103

Affected Packages

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

gbsplay is a Game Boy sound emulator/player that, in addition to GBS files, can load VGM (Video Game Music) containers. vgm_open() parses the VGM header fields directly out of the in-memory file buffer: the total EOF offset at 0x4, the GD3 tag offset at 0x14, and the data-section offset at 0x34, after which it walks the VGM command stream looking for the end of the data block. In 0.0.103 the offsets were held in signed long/int32 vars and the data length was derived as gd3_ofs - data_ofs, so a header whose data or GD3 offsets were inconsistent could produce a negative or oversized length. The command-stream loop itself ran on a vgm_parsed flag with no comparison against the real end of the buffer, so a stream consisting of wait opcodes and lacking the 0x66 end-of-data terminator kept consuming bytes past the allocation - a classic CWE-125 out-of-bounds read that the crafted file turns into a crash. The upstream fix (commit 91b1f6df) converts the offsets to size_t, rejects headers where eof_ofs is below the minimum VGM header length HDR_LEN_VGM or beyond the file size, requires gd3_ofs <= eof_ofs, derives data_end = &buf[gd3_ofs] and bounds the parse loop with data < data_end in addition to explicit 'fewer than 3 bytes remaining' guards, and fails out with 'EOF before reaching end of data tag' when the terminator is never reached.

Know when Gbsplay 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 4.8 MEDIUM
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:L/SC:N/SI:N/SA:N
vuln.today AI 3.3 LOW

A victim must open a local crafted file (AV:L, UI:R) and no privileges are needed (PR:N); the only effect is a player crash, so C:N/I:N/A:L.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:N/I:N/A:L
4.0 AV:L/AC:L/AT:N/PR:N/UI:P/VC:N/VI:N/VA:L/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
None
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

DescriptionCVE.org

gbsplay through 0.0.103 contains a heap out-of-bounds read vulnerability in vgm_open() in gbs.c that walks the VGM command stream without bounds checks. Attackers can supply a crafted VGM file with wait opcodes and no 0x66 terminator to read past the heap buffer and crash the player.

Threat Intelligence Overview

EPSS Score
0.1%
Top 97% exploitable
Prevalence
Rare
niche open-source Game Boy sound player, hobbyist use only
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 No
EPSS 0.1%
Patch available Yes
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
Defer
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact· derived
Medium

Priority Score

24
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +24
PoC: 0
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