/

CVE-2026-37430

Severity:

HIGH RISK

(7.3)

Arbitrary File Upload in qihang-wms

CVE-2026-37430

Deferred

Vulnerability type

Category:

Arbitrary File Upload

CWE:

CWE-434

Impact:

Remote Code Execution

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

An arbitrary file upload vulnerability in the ShopOrderImportController component of qihang-wms allows attackers to upload crafted files without proper validation.

When an attacker can reach the vulnerable upload endpoint, they may be able to execute arbitrary code on the server by uploading executable content that the application or runtime later processes.

Affected context

This vulnerability occurs in deployments of qihang-wms that expose the ShopOrderImportController file upload functionality to users or integrated systems.

It is most relevant when:

  • The upload endpoint is reachable over a network (e.g., intranet or internet),
  • Uploaded files are stored in a location that can be interpreted or executed by the application stack (such as script-capable directories), and
  • There is limited or no server-side validation of file type, content, or destination.

Exploit preconditions

  • Attack surface: HTTP(S) file upload endpoint provided by ShopOrderImportController.
  • Required access: Ability to send authenticated or unauthenticated requests to the upload interface, depending on how the application is configured.
  • Trigger point: Submission of a crafted file through the import/upload mechanism, which the server accepts and stores.
  • Why exploitation is possible: The controller does not sufficiently validate or restrict uploaded file types, content, or storage paths, allowing attacker-controlled files to be placed where they may be executed or processed as active code.

Why this happens

The root cause aligns with CWE-434: Unrestricted Upload of File with Dangerous Type.

The ShopOrderImportController appears to accept uploaded files but does not enforce strong constraints on:

  • The allowed MIME types and extensions,
  • The structure and content of the file,
  • The storage location relative to executable or publicly served paths.

As a result, an attacker can upload a file containing executable instructions (such as scripts, templates, or other interpretable formats) that the server or application later treats as active code, enabling arbitrary code execution.

Potential impact

  • Remote execution of attacker-controlled code on the application server
  • Installation of web shells or backdoors for persistent access
  • Unauthorized access to or modification of business and customer data
  • Pivoting to other internal systems reachable from the compromised server
  • Service disruption, data corruption, or deployment of ransomware

General mitigation guidance

Effective mitigation focuses on strict upload control and minimizing file execution risk:

  • Restrict uploads to a small, explicit allowlist of file types, validated by both MIME type and file content signatures.
  • Store uploaded files outside of web-accessible and executable directories, ensuring they cannot be directly interpreted as code by the server.
  • Normalize and sanitize file names and paths, avoiding use of client-supplied paths or extensions for any execution decision.
  • Apply server-side checks that treat all uploaded content as untrusted data, never as templates, scripts, or configuration without additional validation.
  • Run the application with least-privilege OS accounts so that, even if abused, file write locations and executable permissions are limited.

How teams detect issues like this

Detection typically combines code-centric and operational approaches:

  • Static analysis: Flag controllers or endpoints that:
  • Accept multipart/form-data and write files without extension/type checks,
  • Use user-controlled names or paths for file storage,
  • Store uploads under webroot or executable directories.
  • Code review: Look for missing validation layers, lack of allowlists, or direct file system writes tied to request parameters.
  • Runtime monitoring: Log and alert on:
  • Unexpected executable files appearing in upload directories,
  • New script or binary files created by the application process,
  • Access to uploaded files via HTTP immediately after upload.
  • Policy enforcement: Use CI/CD checks or security gates that enforce secure upload patterns and disallow deployment when risky patterns are detected.

Sources

SourceLink
gist.github.comgist.github.com/Y4y17/6587147a37eba5b31de832e067f317ef
github.comgithub.com/Y4y17/CVE/blob/main/%E5%90%AF%E8%88%AA%E7%94%B5%E5%95%86WMS/Security%20vulnerability.md

Frequently asked

questions

Yes, if the upload endpoint is exposed over the network, an attacker can exploit it remotely by sending crafted upload requests.

That depends on how qihang-wms is configured. If the ShopOrderImportController is protected by authentication or authorization, attackers would need those credentials; if not, any network-accessible user could attempt exploitation.

Implement strict server-side upload controls: use an allowlist of safe file types, validate both MIME type and file content, store files outside of executable and web-accessible paths, and treat uploaded data purely as passive content.

Adopt a standard upload security pattern in your codebase, enforce it through reusable components and code review, and supplement it with automated checks that flag unrestricted uploads or storage of user-supplied files in executable locations.

Find out what's already
exploitable in your codebase.