/

CVE-2026-15488

Severity:

HIGH RISK

(7.3)

Unrestricted File Upload (CWE-434) in shiroiAdmin

CVE-2026-15488

Deferred

Vulnerability type

Category:

Unrestricted File Upload

CWE:

CWE-284, CWE-434

Impact:

Remote Code Execution and Arbitrary File Upload

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

shiroiAdmin versions 1.1 and 1.3 contain an unrestricted file upload flaw in the FileController::upload endpoint, allowing attackers to manipulate the uploaded file parameter.

When exposed over the network, this can let a remote attacker upload arbitrary files, potentially including executable scripts, leading to full application compromise.

Affected context

The vulnerability occurs in deployments of shiroiAdmin versions 1.1 and 1.3 that expose the file upload functionality implemented in app/common/controller/FileController.php.

The issue typically manifests where upload requests are accepted from users or external clients without strict validation of file type, content, or destination path.

Environments that process uploaded files in web-accessible directories, or where uploaded content can later be executed or interpreted by the server, are at heightened risk.

Exploit preconditions

  • Attack surface: HTTP(S) endpoint for file upload handled by FileController::upload.
  • Required access: Ability to send requests to the upload endpoint (often unauthenticated or with basic user-level access, depending on configuration).
  • Trigger point: Submission of a crafted file through the File argument that bypasses weak or missing validation.
  • Why exploitation is possible: The upload logic does not adequately enforce file type restrictions, content checks, or safe storage locations, allowing attacker-controlled files to be stored and potentially executed or accessed.

Why this happens

The root cause is insufficient enforcement of restrictions around what files can be uploaded and where they are stored, aligning with CWE-434: Unrestricted Upload of File with Dangerous Type.

The upload handler likely trusts client-supplied metadata such as file name or MIME type, does not robustly validate extensions or content, and saves files into locations accessible by the web server or application runtime.

Additionally, missing or weak authorization controls around the upload endpoint (related to CWE-284: Improper Access Control) mean that untrusted users can reach this functionality and abuse the lax validation.

Potential impact

  • Remote attackers could upload executable scripts or code that may be interpreted by the server.
  • Attackers may gain remote code execution or full control over the web application context.
  • Malicious files could be used for phishing, malware distribution, or defacement.
  • Uploaded content may enable data exfiltration, credential theft, or pivoting deeper into the infrastructure.
  • Storage exhaustion or denial-of-service conditions may arise from large or numerous uploads.

General mitigation guidance

Effective mitigation focuses on tightening upload handling and minimizing trust in user-provided files:

  • Enforce strict allowlists for file types based on server-side checks of both extension and content (e.g., magic bytes), rejecting anything outside expected formats.
  • Store uploaded files outside of web-accessible directories and serve them through controlled download handlers rather than direct execution paths.
  • Normalize and sanitize file names, ignoring client-supplied paths and stripping potentially dangerous characters or sequences.
  • Apply granular access control to the upload endpoint, limiting who can upload and under what conditions, and ensure uploads are tied to authenticated sessions when possible.
  • Implement size limits, rate limiting, and quotas to reduce abuse and protect storage resources.
  • Run application and web server processes with least-privilege accounts so that any compromise of uploaded content has constrained impact.

How teams detect issues like this

Organizations can identify and monitor for this class of vulnerability using:

  • Static analysis rules that flag file upload handlers lacking validation of content type, extension, or storage location.
  • Code review checklists that explicitly cover file upload paths, ensuring they use allowlists, content inspection, and non-executable storage directories.
  • Runtime logging and monitoring of upload endpoints, including anomalies such as uploads of uncommon file types, unexpected extensions, or files appearing in executable directories.
  • Security testing and dynamic analysis focused on upload features, attempting to upload benign test scripts or known markers and observing how the application stores and exposes them.
  • Integration of automated code review or SAST tools into CI pipelines to detect insecure upload patterns early in development.

Sources

SourceLink
github.comgithub.com/hcr707305003/shiroiAdmin/
github.comgithub.com/hcr707305003/shiroiAdmin/commit/3ecde28ea8a20a3840dbfefd6d6863ee79a83e70
github.comgithub.com/hcr707305003/shiroiAdmin/releases/tag/v1.4
vuldb.comvuldb.com/cve/CVE-2026-15488
vuldb.comvuldb.com/submit/843890
vuldb.comvuldb.com/vuln/377795
vuldb.comvuldb.com/vuln/377795/cti

Frequently asked

questions

Yes. Because the affected upload endpoint is typically exposed over HTTP(S), a remote attacker who can reach the application can submit malicious file upload requests.

In many configurations, only the ability to interact with the upload endpoint is required, which may be available to unauthenticated users or low-privileged accounts. The precise requirement depends on how access control is configured around FileController::upload.

The safest pattern is to strictly control what files can be uploaded using server-side allowlists and content validation, store uploads outside any executable or publicly browsable directories, and ensure that only authorized, authenticated users can access upload functionality.

Design upload features with a "deny by default" approach: assume all files are untrusted, require explicit allowlists, perform robust validation of content and name, restrict storage locations to non-executable paths, and include file upload security checks in code review, SAST rules, and architecture guidelines.

Find out what's already
exploitable in your codebase.