/

CVE-2026-33478

Severity:

CRITICAL RISK

(10.0)

Authentication Bypass and OS Command Injection

CVE-2026-33478

Analyzed

Vulnerability type

Category:

Authentication Bypass and OS Command Injection

CWE:

CWE-78, CWE-284

Impact:

Remote Code Execution with Full Application Compromise

Severity:

CRITICAL RISK

(10.0)

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's CloneSite plugin contains a chain of flaws that let an unauthenticated attacker escalate from information disclosure to full remote code execution on the server.

By leaking clone secrets, dumping the database to recover weakly protected admin credentials, and then abusing an OS command injection in rsync construction, an attacker can fully compromise the AVideo host.

Affected context

The vulnerability affects WWBN AVideo deployments that have the CloneSite plugin enabled and exposed to the network.

It is relevant where:

  • The clones.json.php, cloneServer.json.php, and cloneClient.json.php endpoints are reachable without strict access control.
  • Clone secrets are treated as sufficient authorization without additional verification layers.
  • Administrative passwords are stored as unsalted MD5 hashes, allowing trivial offline cracking.
  • The clone client logic assembles rsync commands using attacker-influenced input without proper sanitization.

Exploit preconditions

  • Attack surface: Public-facing HTTP endpoints provided by the CloneSite plugin.
  • Required access: None; an unauthenticated network attacker can reach the vulnerable endpoints if they are exposed.
  • Trigger points:
  • clones.json.php leaks clone secret keys without enforcing authentication or authorization.
  • cloneServer.json.php accepts the leaked secrets to initiate and retrieve a full database dump.
  • cloneClient.json.php constructs an rsync command incorporating values controlled by an authenticated (now compromised) admin.
  • Why exploitation is possible:
  • Insufficient access control (CWE-284) on clone management endpoints allows arbitrary retrieval and misuse of secret keys.
  • Weak password storage (MD5 hashes) makes it easy to convert database-stored hashes into valid admin credentials.
  • The rsync command construction fails to correctly validate or escape input, enabling OS command injection (CWE-78).

Why this happens

This issue stems from a combination of flawed authorization design and unsafe command construction.

The CloneSite API exposes sensitive clone secrets without verifying the caller's identity or permissions, violating the principle of least privilege and mapping to CWE-284 (Improper Access Control).

These secrets are then trusted as proof of authorization for database dumping operations, expanding the blast radius of a single design flaw.

Separately, the clone client composes shell commands by directly embedding parameters derived from user-controllable or admin-level inputs into an rsync invocation.

Without strict validation or shell-safe escaping, this pattern becomes a classic OS command injection (CWE-78), where the application mistakenly treats data as executable shell syntax.

The use of MD5 for password hashing further weakens the chain by lowering the cost of pivoting from database access to full admin control.

Potential impact

  • Execution of arbitrary system commands under the web server or application user account.
  • Complete compromise of the AVideo instance, including configuration, content, and user data.
  • Theft or manipulation of the entire database, including user accounts, access tokens, and configuration secrets.
  • Creation of new administrative accounts or backdoors for persistent access.
  • Use of the compromised server as a pivot point for lateral movement within the hosting environment.
  • Defacement of video portals, disruption of service, or deployment of malicious content to end users.

General mitigation guidance

Risk reduction should focus on tightening access control, hardening authentication data, and eliminating shell injection primitives:

  • Treat all management endpoints (clone configuration, secrets, and database operations) as administrative APIs requiring strong authentication and explicit authorization checks.
  • Replace MD5 (and similarly weak algorithms) with modern, adaptive password hashing functions (e.g., bcrypt, Argon2, PBKDF2) configured with appropriate work factors.
  • Avoid constructing shell commands by concatenating strings; use parameterized process execution APIs that do not invoke a shell by default.
  • Where shell invocation is unavoidable, strictly validate inputs against allowlists and apply robust argument escaping routines before passing values to the shell.
  • Reduce the trust placed in "secret keys" by:
  • Limiting their scope and lifetime.
  • Binding them to specific origins or IP ranges where feasible.
  • Logging and monitoring their use for anomalies.
  • Apply least-privilege principles to the runtime environment:
  • Run the web server and application under minimally privileged accounts.
  • Restrict filesystem and network permissions so that a compromise has limited blast radius.
  • Isolate cloning and backup operations into separate services or workers with constrained capabilities instead of performing them directly from the web-facing process.

How teams detect issues like this

Security teams can detect and monitor for similar vulnerabilities using a combination of static and dynamic techniques:

  • Static analysis and code scanning:
  • Flag direct use of shell execution functions (e.g., exec, system, shell_exec, passthru, backticks) where user or configuration data is interpolated.
  • Identify HTTP endpoints that:
  • Return secrets, keys, or tokens.
  • Perform sensitive operations (backups, cloning, database exports) without explicit access control checks.
  • Highlight uses of weak hashing algorithms such as MD5 or SHA-1 for password storage or credential protection.
  • Code review practices:
  • Require explicit authentication and authorization checks for all administrative or operational APIs.
  • Review any code that handles secrets or tokens to ensure they are never returned to clients and are properly scoped.
  • Examine backup, cloning, and synchronization features for signs of shell command construction or elevated privileges.
  • Runtime and log-based detection:
  • Monitor logs for unexpected calls to clone, backup, or database export endpoints from untrusted IP ranges.
  • Track unusual rsync invocations or shell processes spawned by the web server user.
  • Use intrusion detection or endpoint monitoring tools to flag suspicious command patterns or outbound connections from the AVideo host.
  • Automated policy enforcement:
  • Integrate SAST/DAST tools into CI/CD to enforce policies against unsafe shell invocation patterns and weak password hashing.
  • Use configuration scanning to ensure administrative endpoints are not exposed directly to the public Internet without protection.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/c85d076375fab095a14170df7ddb27058134d38c
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-687q-32c6-8x68

Frequently asked

questions

The chain is remotely exploitable by any unauthenticated attacker who can reach the affected CloneSite endpoints over the network.

Because no initial login is required and the database dump plus weak hashing make privilege escalation straightforward, the exposure is effectively full remote code execution.

Initially, none; only network access to the vulnerable AVideo instance is required.

The attack progresses from unauthenticated access to clone secrets, to database access, to recovered admin credentials, and finally to code execution via command injection under the context of the application or web server user.

Apply a layered fix:

  • Enforce strict authentication and authorization on all clone- and backup-related endpoints.
  • Remove or redesign any API that exposes secrets or allows unbounded database dumping.
  • Replace string-based shell command construction with safe process execution APIs and robust input validation.
  • Upgrade password handling to use modern, salted, and adaptive hashing functions.

This combination addresses both the immediate exploit chain and its underlying design flaws.

Adopt secure design practices early:

  • Classify administrative and operational APIs and protect them with strong authentication, role-based authorization, and audit logging.
  • Treat secrets and keys as highly sensitive; never expose them via APIs and limit their scope and lifetime.
  • Standardize on safe primitives for command execution, storage, and crypto across the codebase, backed by coding guidelines and automated checks.
  • Include security review in the design and code review process for features involving replication, backups, or direct system-level operations.
Find out what's already
exploitable in your codebase.