Skip to main content

TuxGuitar EUVDEUVD-2026-102925

| CVE-2026-55543 HIGH
Code Injection (CWE-94)
2026-10-16 GitHub_M
8.5
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious .tg archive with embedded class
  2. Delivery
    Deliver file to victim via download or email
  3. Exploit
    Victim opens file in TuxGuitar
  4. Execution
    JARSoundbankReader instantiates attacker class via unverified loader
  5. Impact
    Arbitrary code execution as the user

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Code injection prevention, sandbox exec
MITRE ATT&CK

2 techniques across 2 tactics: Execution, Initial Access

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 .tg file in TuxGuitar prior to version 2.1.0; the file must set the gervil.soundbank.path property to reference an archive containing a META-INF/services/javax.sound.midi.Soundbank entry that names an attacker-controlled class bundled in that same archive. The limiting factors are: (1) mandatory user interaction - the user must actively open the malicious file (UI:P); (2) local delivery - there is no remote network service to attack, the payload travels as a document; and (3) the attacker-supplied class executes only with the privileges of the TuxGuitar process/user, not elevated. No special non-default configuration is needed because the vulnerable JARSoundbankReader and its service registration ship by default in affected versions.

Impact

This is a genuine code-execution vulnerability but its real-world priority is moderated by the delivery model. The CVSS 4.0 vector (AV:L/AC:L/AT:N/PR:N/UI:P, score 8.5) correctly captures the core dynamic: no authentication is required (PR:N) and complexity is low (AC:L), but exploitation is Local (AV:L) and requires passive user interaction (UI:P) - the victim must obtain and open a malicious .tg file in TuxGuitar. Impact is maximal (VC:H/VI:H/VA:H, CWE-94 arbitrary code execution in the process context), with no scope change to other systems (SC/SI/SA:N). No EPSS score, CISA KEV listing, or SSVC decision data was provided, and there is no evidence of a public proof-of-concept in the references (only the advisory, fix commit, and release) - so exploitation status is 'no public exploit identified at time of analysis.' The signals are internally consistent: a high-impact but user-interaction-gated, local-file-triggered flaw. The practical risk is therefore social-engineering-dependent (tricking a musician/user into opening a crafted tablature file) rather than mass-exploitable, and the niche user base limits widespread targeting. Treat as a priority for TuxGuitar users who handle shared .tg files, but not a drop-everything internet-facing emergency.

Exploit ScenarioDerived

An attacker crafts a malicious .tg tablature file that sets gervil.soundbank.path to point at an embedded archive (which can be the .tg file itself) containing a META-INF/services/javax.sound.midi.Soundbank entry naming an attacker-supplied class. The file is shared via a music forum, email, or download, and when the victim opens it in a vulnerable TuxGuitar (pre-2.1.0), JARSoundbankReader loads and instantiates the class, running its constructor with the user's privileges. No public exploit code was identified in the provided references, but the technique is fully described in the advisory and requires only that the victim open the file.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available

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

Alert me

AnalysisAIv1 – Oct 16, 2026

TuxGuitar versions before 2.1.0 will load and instantiate an attacker-supplied Java class contained in a crafted .tg tablature file, executing that class's constructor (and static initializer) with the privileges of the TuxGuitar process when the user opens the file. The document sets the gervil.soundbank.path property to an on-disk archive - the .tg file itself qualifies - whose META-INF/services/javax.sound.midi.Soundbank entry names a class bundled in that same archive, and the bundled Gervill media.sound.JARSoundbankReader loads it through an unverified URLClassLoader. The CVSS 4.0 vector is AV:L/AC:L/AT:N/PR:N/UI:P with a score of 8.5 (unauthenticated, no non-default configuration required), but the payload must be delivered as a document the victim opens, so real-world priority is moderated by that delivery model; no public exploit code has been identified at time of analysis and the issue is fixed in 2.1.0.

RemediationAI

Upgrade to TuxGuitar 2.1.0 or later (vendor-released patch: 2.1.0, published at https://github.com/helge17/tuxguitar/releases/tag/2.1.0); the fixing commit https://github.com/helge17/tuxguitar/commit/a7eef20e2e02ee454597d42c295327d9f098c636 removes media.sound.JARSoundbankReader and its javax.sound.midi.spi.SoundbankReader service registration, closing the archive-driven code-loading path. If upgrading is not immediately possible, the practical compensating control is to reproduce the upstream change locally on the installed jars: remove or blank the media.sound.JARSoundbankReader line in META-INF/services/javax.sound.midi.spi.SoundbankReader inside the Gervill plugin/shared jars and delete or neutralize the media.sound.JARSoundbankReader class from the classpath - the trade-off is that soundbanks packaged as JAR/ZIP archives will no longer be auto-detected and loaded by TuxGuitar, while other soundbank formats continue to be handled by the remaining readers. Because exploitation requires the user to open a malicious document, also treat .tg files as untrusted input: do not open tablature files from unknown sources, and run TuxGuitar under a low-privilege account or in an OS-level sandbox so any constructor executed by a crafted file cannot reach user data or credentials. Review the vendor advisory at https://github.com/helge17/tuxguitar/security/advisories/GHSA-v66p-c82h-w3cq for any additional guidance; no vendor-documented configuration flag that disables only the affected reader was provided in the available data.

Affected VersionsENISA

tuxguitar < 2.1.0

Affected Packages

euvd tuxguitar fix: 2.1.0

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

TuxGuitar bundles Gervill, the Sun/OpenJDK-derived software synthesizer, to load MIDI soundbanks. Part of that code is media.sound.JARSoundbankReader, a javax.sound.midi.spi.SoundbankReader implementation that is registered as a Java service provider via META-INF/services/javax.sound.midi.spi.SoundbankReader and is therefore present and active by default. For a given URL, JARSoundbankReader checks only whether the resource starts with the ZIP magic bytes (0x50 0x4b 0x03 0x04), then creates URLClassLoader.newInstance(new URL[]{url}) over that untrusted archive, reads META-INF/services/javax.sound.midi.Soundbank from inside it, and for each listed line calls Class.forName(line.trim(), true, ucl) followed by newInstance(). Because the class loader is built from the attacker-controlled archive and the class name comes from a service file inside that same archive, the archive is both the source of the class name and the code source - a self-referential trust chain with no origin verification. Class initialization (static initializer) and the no-argument constructor of the resolved class both run, so arbitrary code executes before any type check occurs; the subsequent instanceof Soundbank test is a post-hoc check that never prevents execution. This is a code-injection defect (CWE-94) rooted in the missing validation of the origin/authenticity of the class named in the service descriptor rather than in a memory-safety bug. The upstream fix commit a7eef20e2e02ee454597d42c295327d9f098c636 deletes the entire JARSoundbankReader.java file from both desktop/gervill/src/main/java/media/sound/ and android/TuxGuitar-android-gervill/src/main/java/media/sound/, and removes the corresponding media.sound.JARSoundbankReader line from META-INF/services/javax.sound.midi.spi.SoundbankReader in the Android gervill plugin's share directory - eliminating the dynamic archive-based class-loading path altogether.

Know when Tuxguitar 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 (GitHub_M) PRIMARY 8.5 HIGH
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.8 HIGH

Attack is delivered as a malicious file the victim must open, so AV:L and UI:R; no prior auth is needed (PR:N) and arbitrary code runs with full C/I/A impact in the user's context (S:U).

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Passive
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Oct 16, 2026 - 17:17 EUVD
CVE Published
Oct 16, 2026 - 15:28 cve.org
HIGH 8.5

DescriptionCVE.org

TuxGuitar is an open-source guitar tablature editor. Prior to 2.1.0, an untrusted .tg file can set gervil.soundbank.path to reference an on-disk archive, including the .tg file itself, whose META-INF/services/javax.sound.midi.Soundbank entry names an attacker-supplied class stored in that archive. When a user opens the file, JARSoundbankReader uses an unverified class loader to load and instantiate that class, executing its constructor with the privileges of the TuxGuitar process. This issue is fixed in version 2.1.0.

Technical POC Analysis

Two chained defects, mapped to CWE-94 (Improper Control of Generation of Code) and CWE-470 (Use of Externally-Controlled Input to Select Classes or Code, "unsafe reflection").

Full technical POC analysis - root cause, step-by-step exploitation and patch breakdown - is part of the Pro and Business plans.

Executive ViewAI

Why It Matters

TuxGuitar, an open-source guitar tablature editor, will execute attacker-controlled Java code with the privileges of the running application when a user simply opens a crafted .tg tablature file in any version before 2.1.0. The risk is concentrated in staff who routinely open tablature files received from external sources such as email, forums, or shared repositories, since a successful compromise would give the attacker the same access as that user's workstation session. No public exploit code has been identified at time of analysis, and a fixed version (2.1.0) is available.

Business Impact: High
Compensating Controls

Apply vendor patch.

Threat Intelligence Overview

Prevalence
Low
niche open-source guitar tablature editor, no enterprise footprint
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 HIGH
CISA KEV No
Public POC No
EPSS N/A
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.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
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Code Injection CRITICAL

Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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