Summary
Vvveb before 1.0.8.3 allows super_admin users to upload plugin ZIP archives that are insufficiently validated, enabling arbitrary PHP files to be placed in web-accessible locations.
By crafting a malicious plugin package, an attacker with super_admin access can execute arbitrary PHP code via unauthenticated HTTP requests to the plugin's public path, resulting in full remote code execution as the web server user.
Affected context
This vulnerability occurs in Vvveb installations that:
- Allow super_admin users to upload plugins through the plugin upload endpoint
- Automatically extract plugin ZIP files into web-accessible directories
- Execute PHP code from plugin files located under a public plugin path
The risk is most significant in environments where:
- Super_admin credentials can be phished, shared, or otherwise compromised
- The application is directly exposed to the internet
- The web server user has broad filesystem or data access.
Exploit preconditions
- Attack surface: HTTP plugin upload endpoint used to install or update plugins.
- Required access: Authenticated access as a super_admin user (or compromise of such an account).
- Trigger point: Upload and installation of a crafted ZIP file containing:
- A
plugin.phpwith a valid Slug header to pass basic plugin recognition checks - A
public/index.phpfile containing arbitrary PHP code - Why exploitation is possible:
- The upload mechanism does not adequately restrict or sanitize the contents of plugin archives.
- Extracted plugin files, including arbitrary PHP files, are placed under a public path executable by the web server.
- The malicious PHP file is then reachable via unauthenticated HTTP requests to the plugin's public URL.
Why this happens
The underlying bug class is an unrestricted file upload vulnerability aligned with CWE-434.
The plugin upload endpoint treats plugin ZIP archives as trusted content once submitted by a super_admin and does not enforce strict controls on:
- Allowed file types and filenames within the archive
- Placement of PHP files into public, executable paths
- Separation of code and data in plugin distributions
As a result, an attacker can embed arbitrary PHP code inside a structurally valid plugin package. Because the system automatically extracts and exposes these files under a public web path, the application effectively converts uploaded content into executable code, creating a direct path to remote code execution. This also intersects with CWE-61 (UNIX Symbolic Link Following) conceptually when archive extraction or path resolution is not carefully constrained, although the primary observed issue is the acceptance and execution of untrusted PHP files.
Potential impact
- Remote execution of arbitrary PHP code with the privileges of the web server user
- Full compromise of the Vvveb application, including modification of content, configuration, and plugins
- Exfiltration or tampering of data stored or accessible by the web server user (databases, configuration files, local secrets)
- Establishment of persistent backdoors or web shells on the server
- Use of the compromised server as a pivot point for lateral movement inside the hosting environment or internal network
- Abuse of the server for spam, phishing pages, or hosting malicious content
General mitigation guidance
Mitigation focuses on hardening the plugin upload and execution model, and reducing trust in uploaded archives, even when submitted by privileged users.
Common defensive patterns include:
- Strict plugin archive validation:
- Enforce a whitelist of allowed file types (e.g., configuration, templates, assets) within plugin ZIP files.
- Reject PHP or other executable files in public/asset directories that are directly web-accessible.
- Validate plugin structure and prevent arbitrary paths, nested archives, or unexpected directory traversal patterns.
- Separate code and assets:
- Store plugin PHP code in non-public directories that are not directly web-accessible; route execution through controlled plugin loaders rather than direct URL access.
- Treat public plugin paths as static asset locations only (no executable PHP allowed).
- Least-privilege and execution constraints:
- Run the web server and PHP interpreter with minimal filesystem and OS privileges.
- Limit write access to directories that are executable by the server; ideally avoid any overlap between upload directories and PHP-executable paths.
- Defense-in-depth around administrative actions:
- Treat plugin upload as a sensitive operation requiring additional safeguards (e.g., administrative approval workflows, extra authentication factors, or restricted admin IP ranges).
- Monitor and log all plugin installation and update actions for later audit.
- General secure upload practices:
- Normalize and validate paths before extraction to avoid placing files in unintended locations.
- Sanitize archive content, rejecting files with dangerous extensions in web-served directories.
How teams detect issues like this
Effective detection combines code-level analysis, configuration review, and runtime monitoring:
- Static analysis and code review:
- Identify code paths that handle plugin uploads and ZIP extraction.
- Flag any extraction into web-accessible directories where PHP execution is enabled.
- Look for missing checks on allowed file types, absent validation of archive contents, and direct trust of admin-submitted uploads.
- Security policy enforcement:
- Define internal policies that forbid executing dynamically uploaded code or plugins without strict validation.
- Enforce architectural rules: upload directories must not be treated as executable code locations.
- Automated scanning:
- Use SAST tools to search for file upload handlers and dangerous file operations (e.g., arbitrary
move_uploaded_file,unzipinto public paths). - Use DAST or penetration testing tools to test plugin upload endpoints, checking whether uploaded files become reachable/executable via HTTP.
- Runtime and log monitoring:
- Monitor web server logs for unusual access patterns to plugin public paths, especially newly added PHP files.
- Alert on unexpected plugin installations, modifications, or uploads from atypical IPs or accounts.

