Summary
WWBN AVideo up to and including version 26.0 contains an OS command injection flaw in its restreamer endpoint, where user-controlled identifiers are embedded into shell commands without sanitization.
An authenticated user who can call this endpoint may inject shell metacharacters into the log file path parameters and execute arbitrary commands on the underlying server.
Affected context
The vulnerability appears in the WWBN AVideo restreamer endpoint, which builds a log file path from values supplied in the JSON request body (specifically users_id and liveTransmitionHistory_id).
The issue is relevant when:
- The application exposes the restreamer endpoint to authenticated users
- The server constructs shell commands using these parameters and calls
exec()or similar APIs - No robust input validation, escaping, or parameterization is applied before passing data to the shell
In such deployments, any authenticated user with access to this functionality could attempt command injection.
Exploit preconditions
- Attack surface: HTTP(S) API, specifically the restreamer endpoint in the AVideo application.
- Required access: Valid authenticated user account with permission to invoke the restreamer functionality.
- Input control: Ability to supply crafted
users_idandliveTransmitionHistory_idvalues in the JSON request body. - Trigger point: Server-side execution of shell commands that embed the constructed log file path, passed to
exec()or an equivalent shell-invoking function. - Why exploitation is possible: The application interpolates untrusted identifiers directly into command strings without sanitization or safe parameterization, allowing shell metacharacters (e.g.,
$(), backticks,;) to be interpreted by the shell rather than treated as data.
Why this happens
This vulnerability stems from constructing shell command strings by concatenating untrusted input and then executing them via exec() or similar APIs.
Instead of treating users_id and liveTransmitionHistory_id as opaque data, the code interpolates them into a log file path, which is then embedded in a command interpreted by a shell.
This pattern matches CWE-78: Improper Neutralization of Special Elements used in an OS Command, where failure to neutralize shell metacharacters allows attackers to change the meaning of a command.
Conceptually, any time application-level identifiers are directly merged into command-line strings without rigorous escaping or use of non-shell execution APIs, the boundary between data and code breaks, enabling command injection.
Potential impact
- Authenticated users could execute arbitrary OS commands within the web server's security context.
- Attackers may read, modify, or delete application and system files accessible to the process.
- Compromise of other application components, including databases and media storage, through follow-on attacks.
- Installation of backdoors or cryptocurrency miners on the host.
- Use of the compromised server as a pivot point for lateral movement within the surrounding network.
General mitigation guidance
Effective mitigation focuses on removing direct shell interpretation of user-controlled data and hardening the surrounding execution environment.
Common defensive patterns include:
- Avoid building shell command strings from dynamic input; instead, use language-native APIs (e.g., process execution functions that take argument arrays and do not invoke a shell by default).
- If external utilities are truly required, strictly validate parameters against allowlists (e.g., numeric IDs, fixed patterns) before using them.
- Normalize and constrain any file path construction to known directories and safe filename formats, rejecting unexpected characters such as whitespace, backticks, dollar signs, semicolons, pipes, and parentheses.
- Apply the principle of least privilege to the web server and associated processes so that, even if a command executes, its capabilities are limited.
- Centralize input validation rules for IDs and other routine fields to ensure consistent enforcement across endpoints.
How teams detect issues like this
Detection typically involves a mix of code-centric and operational approaches:
- Static analysis: Configure rules to flag calls to
exec(),shell_exec(),system(), or similar APIs when arguments are built from HTTP request parameters or other untrusted sources. - Code review: Look for string concatenation or interpolation involving user data and shell commands, particularly around logging, backup scripts, media processing, or restreaming logic.
- Security testing: Incorporate automated tests and DAST tools that inject common command injection payload patterns into parameters such as IDs and filenames, monitoring for anomalies.
- Runtime monitoring: Use application and OS-level logging to detect unusual command execution patterns or spikes in process creation originating from the web server user.
- Policy enforcement: Establish secure coding guidelines that discourage shell invocation from web-exposed code and require explicit justification and review when such patterns are introduced.

