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
imageparameter 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.

