/

CVE-2026-28502

Severity:

HIGH RISK

(8.8)

Unrestricted File Upload in WWBN AVideo Plugin Import

CVE-2026-28502

Analyzed

Vulnerability type

Category:

Unrestricted File Upload

CWE:

CWE-434

Impact:

Remote Code Execution by authenticated administrator

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

An unrestricted file upload vulnerability in WWBN AVideo's plugin upload/import feature allows an authenticated administrator to upload ZIP archives containing executable server-side files.

When these archives are extracted into a web-accessible plugin directory without sufficient validation, an attacker with admin access can achieve arbitrary PHP code execution on the server.

Affected context

This vulnerability exists in WWBN AVideo deployments that enable plugin management via the web interface.

It is relevant when:

  • Administrators can upload or import plugins as ZIP archives.
  • Uploaded archives are extracted into directories served by the web server (e.g., plugin directories).
  • There is no robust validation or restriction on the types and locations of files extracted from the archive.

In such configurations, embedded PHP files inside the plugin package can become directly accessible and executable over HTTP.

Exploit preconditions

  • Attack surface: AVideo web administration interface (plugin upload/import endpoint).
  • Required access: Valid authenticated administrative account or equivalent privileges that allow plugin upload.
  • Trigger point: Submission of a crafted ZIP file through the plugin upload/import functionality, followed by extraction into the plugin directory.
  • Why exploitation is possible: The server does not adequately inspect, filter, or restrict the contents of the uploaded ZIP archive. As a result, PHP files within the archive are extracted into a web-accessible location where the application or web server will execute them when requested.

Why this happens

The core issue is an unrestricted file upload pattern, where user-supplied archives are trusted too much and their contents are written directly into an executable web root.

Mapping to CWE-434, the application:

  • Accepts user-controlled plugin packages from an authenticated admin.
  • Extracts all contained files without enforcing strict file-type whitelisting, path controls, or separation between data and executable code.
  • Places the extracted files in a directory that the web server treats as executable PHP code.

This design breaks the assumption that plugins are inherently trusted and fails to provide defense-in-depth against compromised or malicious administrator accounts or abused integration paths.

Potential impact

  • Arbitrary PHP code execution on the AVideo server by an authenticated administrator.
  • Complete compromise of the AVideo application, including stored videos, metadata, and user accounts.
  • Lateral movement within the hosting environment, depending on server configuration and privileges.
  • Installation of persistent web shells or backdoors for continued access.
  • Exfiltration or tampering of sensitive configuration files, including credentials and API keys.
  • Use of the compromised server as a platform for further attacks (e.g., hosting malicious content, pivoting into internal networks).

General mitigation guidance

Risk reduction generally centers on constraining what can be uploaded, where it can be stored, and how it can be executed:

  • Enforce strict allowlists for plugin file types (e.g., configuration files, assets, and non-executable code formats) and reject or strip executable server-side files in uploaded packages.
  • Extract uploaded archives into directories that are not directly exposed as executable paths by the web server, and load plugin resources using controlled application logic instead of automatic web execution.
  • Apply strong path validation when extracting archives to prevent directory traversal and ensure files remain within designated plugin areas.
  • Run the web server and PHP interpreter with least-privilege accounts and limit file system permissions so that uploaded content cannot alter core application code or sensitive system paths.
  • Introduce defense-in-depth controls such as disabling direct execution of PHP (or other server-side languages) in upload/plugin directories via web server configuration.
  • Treat plugins as untrusted input by default and require an explicit review or signing mechanism for deployment to production environments.

How teams detect issues like this

Organizations can look for this class of issue using a combination of review and automation:

  • Static analysis & code review: Search for upload handlers or plugin import code that:
  • Accepts archives (ZIP, TAR, etc.) and extracts them using filesystem APIs.
  • Writes extracted content into directories under the web server document root.
  • Lacks explicit checks for file extensions, MIME types, or content signatures.
  • Policy and CI checks: Enforce development policies that prohibit placing uploaded files in executable locations, and use automated checks in CI to flag such patterns.
  • Runtime monitoring: Inspect web server logs for unusual requests to plugin directories, especially requests to new PHP files or paths immediately after plugin uploads.
  • File integrity monitoring: Track changes in plugin or webroot directories and alert when new executable files appear as a result of upload operations.

Security scanning tools and SAST platforms can complement manual review by flagging unrestricted upload and archive extraction patterns in PHP and associated frameworks.

Sources

SourceLink
github.comgithub.com/WWBN/AVideo/commit/b739aeeb9ce34aed9961d2c155d597810f8229db
github.comgithub.com/WWBN/AVideo/releases/tag/24.0
github.comgithub.com/WWBN/AVideo/security/advisories/GHSA-v8jw-8w5p-23g3

Frequently asked

questions

Not directly. Exploitation requires authenticated administrative access to the AVideo plugin upload/import feature. However, if an attacker can obtain or abuse admin credentials, remote code execution becomes feasible.

The attacker needs an account with sufficient privileges to upload or import plugins—typically a full administrator or a role configured with plugin management permissions.

The most robust fix is to treat all uploaded plugin packages as untrusted and:

  • Enforce strict file-type allowlists.
  • Extract them into non-executable locations.
  • Configure the web server so uploaded content cannot be executed as PHP or other server-side code.

Additional hardening such as plugin signing and verification adds another protective layer.

When designing upload or extension mechanisms:

  • Clearly separate data content from executable code and never execute files directly from upload directories.
  • Implement comprehensive validation for archive contents before extraction and loading.
  • Apply least-privilege and deny-by-default principles at both application and server configuration levels.
  • Incorporate security reviews and automated checks focused on upload, plugin, and extension systems in the development lifecycle.
Find out what's already
exploitable in your codebase.