/

CVE-2026-94106

Severity:

HIGH RISK

(8.8)

OS Command Injection (CWE-78) in getID3 Shell Handlers

CVE-2026-94106

Awaiting Analysis

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Arbitrary Command Execution

Severity:

HIGH RISK

(8.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A command injection vulnerability in getID3 shell-out handlers can allow shell metacharacters in filenames to alter commands executed by the library. An attacker who can introduce or control a filename processed by an affected handler may execute arbitrary operating-system commands with the privileges of the embedding process.

Affected context

The vulnerability occurs in getID3 deployments that use shell-out handlers to process media or metadata and pass filenames into command strings without adequate escaping. Risk depends on whether an attacker can influence filenames that reach these handlers and on the privileges available to the process embedding the library.

Exploit preconditions

  • Attack surface: Filename handling in getID3 shell-out handlers
  • Required access: Ability to create, upload, rename, or otherwise influence a filename processed by getID3
  • Trigger point: Affected media or metadata processing invokes a shell command containing the attacker-controlled filename
  • Why exploitation is possible: Untrusted filename data is incorporated into a command string without reliably separating data from shell syntax

Why this happens

The underlying bug is a failure to treat filenames as untrusted data when constructing operating-system command strings. Shell interpreters can assign special meaning to metacharacters and other control syntax, so concatenating an unescaped filename into a command may cause unintended command interpretation. This behavior maps to CWE-78: Improper Neutralization of Special Elements used in an OS Command, commonly called OS command injection.

Potential impact

  • An attacker may execute arbitrary commands under the embedding process's account.
  • The application or host environment could be compromised.
  • Confidential files and service credentials may be exposed.
  • Data could be modified, deleted, or poisoned.
  • The compromised process may be used for lateral movement, depending on network access and privileges.

General mitigation guidance

Mitigation generally focuses on removing shell interpretation from filename-processing paths and reducing the trust placed in external names.

Common defensive patterns include:

  • Prefer direct process-execution APIs that pass arguments separately instead of building shell command strings.
  • Apply platform-appropriate argument handling when an external tool is unavoidable.
  • Treat filenames as untrusted input and avoid deriving executable options or command structure from them.
  • Use allowlisted tools, fixed argument positions, and strict input validation where suitable.
  • Run the embedding process with least privilege and isolate media-processing workloads.
  • Restrict filesystem, network, and credential access available to the processing component.

How teams detect issues like this

Detection can combine:

  • Static analysis searches for shell execution APIs, command-string concatenation, and filename variables flowing into process invocations.
  • Code review checks for unescaped paths, shell-enabled execution, and missing argument separation.
  • Runtime monitoring for unexpected child processes, unusual command interpreters, or process launches containing uploaded filenames.
  • Policy enforcement that prohibits shell execution for user-controlled paths unless an approved exception exists.
  • Automated security review tools can help identify command-injection data flows during development.

Sources

SourceLink
github.comgithub.com/JamesHeinrich/getID3
github.comgithub.com/JamesHeinrich/getID3/blob/fefffe762b02be155dcc32eec57feff8a49bc4b5/getid3/write.vorbiscomment.php#L85-L110
github.comgithub.com/JamesHeinrich/getID3/commit/2c6f3f96546f05746405872848114754ed7fe9b4
github.comgithub.com/JamesHeinrich/getID3/commit/ce598c4f3823441d878c5a7a2a9f2f703a3e10b6
github.comgithub.com/JamesHeinrich/getID3/issues/503
github.comgithub.com/JamesHeinrich/getID3/releases/tag/v1.9.26
github.comgithub.com/JamesHeinrich/getID3/security/advisories/GHSA-qf3m-pmjh-h6fx
vulncheck.comvulncheck.com/advisories/getid3-before-1.9.26-os-command-injection-via-unescaped-filenames

Frequently asked

questions

It can be remotely exploitable in applications that accept attacker-controlled filenames through uploads, APIs, or other network-accessible workflows and then process those names with an affected getID3 handler.

The attacker generally needs a way to introduce or influence a filename that reaches the vulnerable shell-out path. Direct access to the host is not necessarily required when an application exposes file-upload or media-processing functionality.

Avoid shell command construction with untrusted filenames. Use direct execution interfaces with separate, fixed arguments, and apply strict validation and allowlisting where external tools are required.

Treat filenames and paths as untrusted data, enforce secure process-execution policies, review data flows into shell APIs, and run processing components with minimal privileges.

Find out what's already
exploitable in your codebase.