Severity:

HIGH RISK

(7.3)

Unrestricted File Upload in Projectworlds House Rental

CVE-2026-0643

Analyzed

Vulnerability type

Category:

Unrestricted File Upload

CWE:

CWE-284, CWE-434

Impact:

Remote Code Execution and Server-Side 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

An unrestricted file upload vulnerability in the signup feature of Projectworlds House Rental and Property Listing 1.0 allows user-supplied image files to be uploaded without adequate validation.

When attackers can upload arbitrary files via /app/register.php?action=reg, they may place executable or malicious content on the server, potentially leading to remote code execution or other server-side compromise.

Affected context

The issue occurs in the user registration (Signup) functionality, specifically in /app/register.php?action=reg, where users can submit an image parameter as part of their signup data.

The vulnerability is present when the application accepts uploaded files into a web-accessible or executable directory and does not enforce strict checks on file type, content, or destination.

Deployments that allow public registration and do not have additional layers (e.g., WAF rules, execution restrictions on upload directories) are more exposed to risk.

Exploit preconditions

  • Attack surface: Public-facing web application endpoint /app/register.php?action=reg
  • Required access: Ability to reach the registration page and submit a signup form (typically unauthenticated or low-barrier access)
  • Trigger point: Submission of a crafted image parameter that contains a malicious file, not limited to safe image formats
  • Why exploitation is possible: The server-side logic does not sufficiently validate file type, extension, or content, nor does it enforce safe storage locations or execution restrictions, allowing arbitrary files to be written to the server and potentially executed.

Why this happens

This vulnerability stems from improper access control and insufficient file handling safeguards in the upload logic, aligning with CWE-434: Unrestricted Upload of File with Dangerous Type and CWE-284: Improper Access Control.

The signup handler appears to trust client-provided file metadata (such as extension or MIME type) or does not check it at all, and stores uploaded files where they can be accessed or executed by the web server.

Abstractly, the insecure pattern is: accepting file uploads from untrusted users, performing little or no validation on file type and content, and placing them into locations where they can influence server behavior or be invoked as code.

Potential impact

  • Upload and potential execution of server-side scripts, leading to remote code execution
  • Installation of web shells or backdoors for persistent access
  • Defacement of the site by serving attacker-controlled content
  • Use of the compromised server as a pivot point for lateral movement inside the network
  • Data exfiltration or tampering by leveraging elevated server access
  • Abuse of the server for malware hosting, spam campaigns, or phishing pages

General mitigation guidance

Effective mitigation typically focuses on tightening file upload handling and reducing the privileges of uploaded content:

  • Enforce strict allowlists of permitted file types (e.g., specific image formats) based on server-side checks, not client-provided metadata.
  • Validate file content signatures (magic numbers) and enforce size limits to reduce the chance of disguised executables.
  • Store uploaded files outside of web-accessible or executable directories, and serve them via indirection or controlled download scripts.
  • Configure the web server to disallow execution of scripts in upload directories (e.g., disabling PHP, CGI, or other dynamic handlers in those paths).
  • Apply least-privilege to the account handling uploads and restrict filesystem permissions so that uploaded files cannot overwrite critical application or configuration files.
  • Centralize and standardize file upload handling logic to apply consistent security checks across all upload endpoints.

How teams detect issues like this

Organizations can approach detection by combining code-level analysis and runtime monitoring:

  • Static analysis: Search for file upload patterns (e.g., use of move_uploaded_file, file write APIs) that lack checks for extension, MIME type, and content validation, particularly in registration or profile-related handlers.
  • Code review: Flag endpoints that accept user-uploaded files but store them in directories mapped directly under the web root, or that accept broad file extensions without an allowlist.
  • Configuration review: Examine web server and application configurations to ensure execution is disabled in upload paths and that directory permissions are restrictive.
  • Runtime monitoring: Use logging and intrusion detection to track unusual file uploads, especially executable files or files with suspicious extensions being requested shortly after upload.
  • Automated security testing tools and DAST scanners can also help identify unrestricted upload points by attempting to upload benign test payloads across suspected endpoints.

Sources

SourceLink
github.comgithub.com/1uzpk/cve/issues/4
vuldb.comvuldb.com/?ctiid.339686
vuldb.comvuldb.com/?id.339686
vuldb.comvuldb.com/?submit.732563

Frequently asked

questions

Yes. Because the vulnerable registration endpoint is typically exposed over the web, attackers can exploit it remotely by submitting crafted signup requests containing malicious uploads.

Usually, only the ability to reach the signup page and submit a registration form is required. If registration is open to the public, no prior authentication or special privileges are needed.

The safest pattern is to strictly control what can be uploaded (using allowlists and content validation), store files in non-executable locations, and configure the server so that uploaded content can never be executed as code, regardless of file type or extension.

Adopt a standardized, security-hardened file upload module across the application, enforce least-privilege and non-executable storage for uploads, and include upload-specific checks in secure coding guidelines, code review checklists, and automated security testing pipelines.

Find out what's already
exploitable in your codebase.