/

CVE-2025-15426

Severity:

HIGH RISK

(7.3)

Unrestricted File Upload in H-ui.admin preview.php Library

CVE-2025-15426

Deferred

Vulnerability type

Category:

Unrestricted File Upload

CWE:

CWE-284, CWE-434

Impact:

Remote Code Execution and Server Compromise

Severity:

HIGH RISK

(7.3)

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

H-ui.admin up to version 3.1 contains an unrestricted file upload vulnerability in the /lib/webuploader/0.1.5/server/preview.php script, allowing attackers to upload arbitrary files without proper security controls.

When exposed to the internet, this flaw can enable remote attackers to upload executable files or malware to the server, potentially leading to full application or server compromise.

Affected context

The vulnerability occurs in H-ui.admin deployments that include and expose the WebUploader server-side handler at /lib/webuploader/0.1.5/server/preview.php.

It is relevant where:

  • File uploads are enabled through this endpoint,
  • The application does not enforce robust validation of file type, extension, or content,
  • Uploaded files are stored in web-accessible locations or otherwise processed in a way that can be executed or interpreted by the server.

Under these circumstances, arbitrary file upload increases the risk of code execution or data exposure.

Exploit preconditions

  • Attack surface: HTTP(S) endpoint handling file uploads (preview.php).
  • Required access: Remote network access to the affected upload endpoint; no special privileges assumed if the upload feature is publicly available.
  • Trigger point: Submission of a crafted upload request that places a malicious file on the server.
  • Why exploitation is possible:
  • Missing or insufficient authorization checks on who can upload (CWE-284).
  • Lack of strict server-side validation of file type, extension, and content (CWE-434).
  • Uploaded files potentially stored in locations that the web server can interpret or execute.

Why this happens

The underlying issue is improper enforcement of security controls on file upload operations.

The preview.php handler likely accepts user-supplied files and stores them on the server without:

  • Strong server-side checks on MIME type, extension, or file contents,
  • Enforced allowlists for safe file types,
  • Proper segregation of upload directories from executable paths.

This maps to CWE-434: Unrestricted Upload of File with Dangerous Type, where attackers can upload files that the system can execute or interpret, and CWE-284: Improper Access Control, where the ability to perform uploads is not adequately constrained.

The combination of weak access control and insufficient file validation creates a path from simple upload to potential arbitrary code execution.

Potential impact

  • Upload and execution of web shells or other server-side scripts.
  • Full compromise of the web application and potentially the underlying server.
  • Deployment of malware or ransomware on the server.
  • Use of the compromised server as a pivot for attacks against internal systems.
  • Unauthorized data access, modification, or exfiltration through uploaded tools.
  • Website defacement or distribution of malicious content to end users.

General mitigation guidance

Effective mitigation focuses on strict control of both who can upload and what can be uploaded, plus how uploads are stored:

  • Enforce server-side authorization checks so only authenticated and appropriately privileged users can access upload endpoints.
  • Implement strict allowlists for file types (e.g., by extension and validated MIME type), rejecting all other formats by default.
  • Inspect content signatures where feasible to ensure the file structure matches the claimed type (e.g., image magic bytes).
  • Store uploaded files outside of web-accessible and executable directories; serve them via controlled download mechanisms rather than direct file paths.
  • Configure the web server and runtime so that uploaded directories cannot execute code or interpret scripts.
  • Normalize file names and strip any path components or special characters to prevent path traversal or overwrites.
  • Apply least-privilege to the upload directory and the account writing files so that even if something is uploaded, its impact is constrained.

These defensive patterns reduce the chance that a malicious file upload can be turned into code execution or sensitive data access.

How teams detect issues like this

Organizations can look for this class of vulnerability and its exploitation using a mix of code-focused and operational techniques:

  • Static analysis and code review:
  • Flag upload handlers that write files directly from user input without validation or sanitization.
  • Search for use of generic file handling APIs in preview.php and related libraries that lack checks on extension, MIME type, or content.
  • Review configuration to ensure upload paths are not mapped to executable locations.
  • Policy and configuration checks:
  • Enforce security policies that prohibit executable permissions in upload directories.
  • Validate web server configurations to ensure script execution is disabled in file upload paths.
  • Runtime monitoring and logging:
  • Monitor HTTP logs for unusual upload patterns, such as uploads of known script extensions or suspicious file names.
  • Track access attempts to uploaded files, especially requests to new files with executable extensions.
  • Use host-based security tools and EDR solutions to detect creation or execution of unexpected binaries or scripts in upload directories.
  • Automated tooling:
  • Integrate automated security testing (SAST/DAST) in CI/CD pipelines to regularly test upload endpoints.
  • Use web application firewalls (WAFs) with rules that detect and block common malicious upload signatures.

Sources

SourceLink
github.comgithub.com/TiKi-r/CVE-Report/blob/main/H-ui.admin%20RCE.md
github.comgithub.com/TiKi-r/CVE-Report/blob/main/H-ui.admin%20RCE.md#4-proof-of-concept-poc
vuldb.comvuldb.com/?ctiid.339348
vuldb.comvuldb.com/?id.339348
vuldb.comvuldb.com/?submit.721457

Frequently asked

questions

Yes. If the upload endpoint is reachable over the network, an attacker can exploit the vulnerability remotely by sending crafted file upload requests.

It depends on how the application is configured. If the upload functionality is exposed without authentication or with weak access control, anonymous attackers may be able to exploit it. Restrictive authentication significantly raises the bar but does not remove the need for robust file validation.

The most reliable fix pattern is to combine strict server-side access control on upload endpoints with an aggressive allowlist-based validation of file types and storage of uploads in non-executable, non-public directories. Additionally, ensure the web server cannot run or interpret files from upload locations.

Treat all file uploads as untrusted input: design upload flows to minimize privileges, require authentication, strictly validate and sanitize files, and isolate uploaded content from executable paths. Back this with secure coding guidelines, automated security checks in CI/CD, and periodic security reviews of any file-handling code.

Find out what's already
exploitable in your codebase.