/

CVE-2026-45578

Severity:

HIGH RISK

(8.8)

OS Command Injection in WWBN AVideo Live YPTSocket

CVE-2026-45578

Analyzed

Vulnerability type

Category:

OS Command Injection

CWE:

CWE-78

Impact:

Remote Code Execution on the Application Server

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

WWBN AVideo up to version 29.0 contains a shell metacharacter injection vulnerability in the Live plugin's YPTSocket notification path, where command lines are built via string concatenation without proper shell escaping.

If an attacker can influence the values used in the execAsync() call, a single quote in those values can break out of the intended argument context and allow arbitrary commands to be appended and executed on the server.

Affected context

The issue occurs within the Live plugin, specifically in plugin/Live/on_publish.php, when constructing a command for execAsync() in the YPTSocket notification branch.

The vulnerable code builds a shell command by concatenating three dynamic values ($users_id, $m3u8, $obj->liveTransmitionHistory_id) into single-quoted arguments without using escapeshellarg() or equivalent.

Environments where an attacker can indirectly control any of these values, and where the PHP process has permission to execute the underlying command, are exposed to elevated risk.

Exploit preconditions

  • Attack surface: HTTP(S) interaction with the WWBN AVideo instance, typically via live streaming or publishing flows that reach the YPTSocket notification logic.
  • Required access: Ability to supply or influence $users_id, $m3u8, or $obj->liveTransmitionHistory_id (e.g., via authenticated publishing actions, crafted stream keys, or manipulated parameters tied to these fields).
  • Trigger point: Execution of the YPTSocket notification branch in plugin/Live/on_publish.php, which calls execAsync() with a shell command constructed from attacker-controlled data.
  • Why exploitation is possible: The command line is assembled by string concatenation with naive single-quoting; no call to escapeshellarg() or comparable encoding is used. A single quote (') in any interpolated value terminates the intended argument and allows injection of additional shell tokens or commands.

Why this happens

This vulnerability stems from constructing shell commands by concatenating raw, externally influenced strings and relying solely on manual quoting for safety.

Despite wrapping values in single quotes, the code does not account for embedded quote characters, nor does it use safe abstractions such as escapeshellarg() or direct argument arrays that bypass the shell.

As a result, attacker-supplied data is interpreted by the shell as part of the command structure rather than inert text, which aligns with CWE-78: Improper Neutralization of Special Elements used in an OS Command ('OS Command Injection').

The abstract pattern is: user-controlled input → interpolated into shell command string → executed by a shell without robust neutralization or avoiding the shell altogether.

Potential impact

  • Execution of arbitrary OS commands with the privileges of the web server or PHP process
  • Reading, modifying, or deleting application and system files accessible to the service account
  • Pivoting to other internal services or databases from the compromised host
  • Installation of backdoors, crypto-miners, or other persistent malware on the server
  • Exfiltration or tampering of video content, user data, or configuration
  • Complete takeover of the affected AVideo instance and possible lateral movement within the hosting environment

General mitigation guidance

Effective mitigation focuses on eliminating direct shell interpretation of user-influenced strings and hardening command execution boundaries:

  • Prefer APIs that bypass the shell entirely by passing command and arguments as structured arrays (e.g., using process execution functions or libraries that do not invoke /bin/sh parsing).
  • Where shell invocation is unavoidable, apply robust argument escaping (e.g., escapeshellarg() for each parameter) instead of manual quoting or string concatenation.
  • Minimize the set of values that ever reach command execution code; only pass whitelisted, strongly-typed identifiers or file paths derived from controlled sources.
  • Restrict what commands can be executed from web-exposed code paths, and centralize command execution logic to a small, reviewable module.
  • Run the application and any helper processes under least-privilege service accounts, and limit filesystem and network access so that a successful injection has reduced blast radius.
  • Consider separating the live publishing logic from the main web frontend (e.g., via dedicated worker services or message queues) to reduce direct coupling between user inputs and OS-level operations.

How teams detect issues like this

Detecting and monitoring for similar issues typically involves both code-level analysis and runtime observation:

  • Use static analysis tools or custom linters to flag direct use of exec, shell_exec, system, backticks, or custom wrappers like execAsync() where arguments are built via string concatenation.
  • Add secure coding guidelines and pre-commit/CI checks that enforce the use of safe helpers (e.g., mandatory escapeshellarg() or argument-array patterns) whenever commands are executed.
  • During code review, look for:
  • Shell commands composed from variables originating in HTTP parameters, database fields, or other user-controlled sources.
  • Manual quoting patterns (e.g., wrapping variables in '...' or "...") without centralized escaping.
  • Helper functions that abstract command execution but still rely on string concatenation.
  • At runtime, monitor logs and system telemetry for suspicious command invocations originating from the web server process, such as unexpected interpreters (e.g., bash, sh, curl, wget) or anomalous arguments.
  • Periodically perform security testing (dynamic analysis, fuzzing, and penetration testing) targeting endpoints that trigger live streaming, notifications, or background jobs that may execute OS commands.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-xw67-cg5f-4m2r

Frequently asked

questions

Yes. If an attacker can remotely influence any of the values interpolated into the execAsync() command ($users_id, $m3u8, or $obj->liveTransmitionHistory_id), they can potentially trigger command injection over the network through normal application workflows.

It depends on how the application is configured and where those values originate. In many deployments, these fields are tied to authenticated publishing or streaming actions, meaning an attacker may at least need a valid account or stream key. However, if any of the parameters can be set via unauthenticated or weakly protected inputs, the exposure could extend to unauthenticated users.

The most robust fix is to stop passing user-influenced strings directly to the shell. Use an execution interface that accepts an argument list rather than a raw command line, or centralize command execution through a vetted helper that always applies proper escaping or parameterization for each argument.

Establish coding standards that prohibit raw shell command construction from request or database data, enforce use of safe wrappers in code review and CI, and educate developers about the risks of shell metacharacters. Combining these practices with static analysis and periodic security testing reduces the likelihood of similar injection flaws reappearing.

Find out what's already
exploitable in your codebase.