/

CVE-2026-42846

Severity:

CRITICAL RISK

(9.8)

OS Command Injection (CWE-78) in ClipBucket v5

CVE-2026-42846

Deferred

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution

Severity:

CRITICAL RISK

(9.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

ClipBucket v5's Remote Play feature suffers from an OS command injection flaw where user-supplied video URLs are concatenated directly into shell commands.

Any authenticated user who can add a Remote Play video may craft a URL containing shell metacharacters, leading to arbitrary command execution on the underlying server.

Affected context

This vulnerability occurs in ClipBucket v5 deployments that enable and expose the Remote Play feature to authenticated users.

The issue arises when the application imports videos using external URLs as sources and passes those URLs directly into shell commands without escaping or sanitization.

It is most relevant in environments where the application process has access to sensitive files, system utilities, or network resources that can be influenced through the injected commands.

Exploit preconditions

  • Attack surface: Web application functionality for adding/importing remote videos (Remote Play).
  • Required access: Any authenticated user account with permission to add videos via Remote Play.
  • Trigger point: Submission of a crafted external URL that includes shell metacharacters, passed as a parameter to a backend shell command.
  • Why exploitation is possible: The URL parameter is concatenated directly into shell command strings and executed by the server without proper escaping, quoting, or command construction safeguards, allowing the shell to interpret metacharacters as additional commands.

Why this happens

The root cause aligns with CWE-78: OS Command Injection.

Instead of invoking system utilities through parameterized, API-level calls or properly escaped arguments, the application builds shell command strings by directly concatenating user-supplied URLs.

This pattern lets user input break out of the intended command context, injecting arbitrary shell syntax that the operating system executes.

The absence of rigorous input validation, escaping, or use of safer process execution APIs creates a direct path for user-controlled data to become executable shell instructions.

Potential impact

  • Arbitrary OS command execution with the privileges of the ClipBucket process.
  • Unauthorized access to or modification of application data and configuration files.
  • Pivoting to other services or systems reachable from the application host.
  • Installation of backdoors, web shells, or malware for persistent compromise.
  • Exfiltration of sensitive information, including database credentials or user data.

General mitigation guidance

Mitigation focuses on removing unsafe shell command construction and strictly separating data from code.

Recommended patterns include:

  • Replacing shell-based utilities with language-native APIs or libraries that accept structured parameters rather than free-form commands.
  • If a system command is unavoidable, using process execution functions that pass arguments as arrays and avoid shell interpretation, combined with strict whitelisting of allowed parameters.
  • Enforcing input validation and normalization on external URLs, including rejecting unexpected characters such as shell metacharacters and constraining accepted schemes, hosts, and paths.
  • Running the application with least-privilege OS accounts and limiting filesystem and network access so that even if a command is abused, its impact is reduced.
  • Applying a defense-in-depth approach by combining secure coding patterns with web application firewalls or command execution monitoring where appropriate.

How teams detect issues like this

Detection can combine code-level review and runtime monitoring:

  • Static analysis: Configure rules to flag any use of shell execution functions (e.g., exec, system, backticks, or similar APIs) that concatenate variables or user-controlled data into command strings.
  • Code review: During manual review, highlight locations where external URLs or other user inputs influence command construction; insist on seeing validation, escaping, and clear separation between data and command logic.
  • Security testing: Incorporate focused tests in QA and penetration testing that supply benign shell metacharacters to external URL fields, observing whether errors or unexpected behavior occur.
  • Runtime monitoring: Implement command execution logging or host-based intrusion detection that can alert when unusual commands are invoked by the application process, especially those not aligned with expected video-processing workflows.

Sources

SourceLink
github.comgithub.com/MacWarrior/clipbucket-v5/security/advisories/GHSA-hvfx-hxmr-28c7

Frequently asked

questions

Exploitation requires authenticated access to the Remote Play feature. However, if registration is open or low-friction, attackers may easily obtain accounts and exploit the issue over the network.

The attacker needs an authenticated ClipBucket account that can add videos through Remote Play. No elevated application privileges are strictly necessary if basic contributors can use this feature.

The safest pattern is to avoid building shell commands from user input entirely: use language-native functions or libraries to perform the needed work, or invoke system utilities via APIs that treat arguments as data, not as part of a shell command string.

Adopt a secure coding policy that forbids direct concatenation of user input into command lines, enforce stringent input validation and whitelisting, use safer process execution patterns, and integrate static analysis and security review checkpoints into the development lifecycle.

Find out what's already
exploitable in your codebase.