/

CVE-2026-11474

Severity:

HIGH RISK

(7.3)

Unrestricted File Upload (CWE-434) in Student System

CVE-2026-11474

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

Kushan2k student-management-system contains an unrestricted file upload issue in the Registration Endpoint, allowing an attacker to manipulate the stimg parameter to upload arbitrary files.

When reachable over the network and not protected by additional filters, this can let remote attackers place executable or malicious files on the server, potentially leading to code execution or data compromise.

Affected context

The vulnerability appears in the service/RegisterService.php Registration Endpoint of the Kushan2k student-management-system when handling the stimg argument.

It manifests in deployments where:

  • The registration service is exposed over a network interface
  • The stimg parameter is accepted from client input and treated as an uploaded file
  • File type, content, or extension checks are absent or bypassable
  • Uploaded files are stored in web-accessible or executable locations on the server

Because the project uses a rolling release model, individual deployments may differ, and the precise conditions can vary across environments.

Exploit preconditions

  • Attack surface: HTTP(S) Registration Endpoint exposed by RegisterService.php
  • Required access: Remote network access to the student-management-system registration functionality; no special privileges are indicated
  • Trigger point: Submission of a crafted request that sets the stimg parameter to an arbitrary file payload
  • Why exploitation is possible:
  • The server-side handler accepts user-supplied file data without sufficient validation or restriction
  • Authorization or ownership checks around file upload paths appear weak or missing (CWE-284: Improper Access Control)
  • Uploaded content can be stored in locations that the web server or application can subsequently serve or execute

Why this happens

The underlying issue is a classic unrestricted file upload problem where user-controlled file input is trusted without adequate constraints.

In the affected RegisterService.php logic, the stimg parameter is evidently processed as an uploaded file without robust checks on content type, extension, size, or destination path.

This behavior maps primarily to CWE-434: Unrestricted Upload of File with Dangerous Type, because arbitrary files can be introduced into the server environment.

The mention of CWE-284: Improper Access Control suggests that access control around upload capabilities, storage directories, or execution rights is insufficient, allowing untrusted users to perform actions typically reserved for trusted roles.

The combination of weak validation and lax access control creates a path for attackers to upload web shells, scripts, or other malicious artifacts.

Potential impact

  • Remote attackers may upload executable scripts or web shells that can be invoked over HTTP
  • Malicious files could allow remote code execution under the web server or application user
  • Attackers may gain persistent access to the server or pivot to other internal systems
  • Defacement or alteration of application content via uploaded files can occur
  • Storage of malware, phishing pages, or other illicit content on the server is possible
  • Sensitive data may be exfiltrated or modified using attacker-controlled code

General mitigation guidance

Effective mitigation focuses on constraining what can be uploaded and how it is stored and executed.

Common defensive patterns include:

  • Restricting upload functionality to authenticated, authorized users with a clear business need
  • Validating file uploads using allowlists for MIME types and extensions, and rejecting any ambiguous or mismatched content
  • Performing server-side content inspection where feasible (e.g., image libraries verifying actual format) instead of trusting client-side metadata
  • Storing uploaded files outside of web-accessible and executable directories, serving them via indirect handlers rather than direct file paths
  • Ensuring the web server does not execute user-uploadable file types (e.g., disabling script execution in upload directories)
  • Applying least-privilege permissions to the account handling file storage so that compromise has limited reach
  • Introducing centralized upload handling utilities or middleware that enforce consistent validation and storage policies across endpoints

How teams detect issues like this

Detection often combines code-level review with behavioral monitoring:

  • Static analysis: Look for file upload handlers that write user-supplied files to disk without strong validation, especially in paths like RegisterService.php or other registration endpoints.
  • Code review signals: Absence of explicit checks for MIME type, extension, and content; direct use of user-controlled filenames or paths; uploads written into document roots or script-executable directories.
  • Configuration and policy checks: Enforce web server policies disabling script execution in upload folders and verifying directory permissions for uploaded content.
  • Runtime monitoring: Watch for unexpected new scripts or executable files appearing in web-accessible directories, and for anomalous HTTP requests invoking recently uploaded resources.
  • Security tooling: Use automated SAST/DAST tools configured with rules for CWE-434 and CWE-284 to flag endpoints with upload functionality lacking proper constraints.

Sources

SourceLink
github.comgithub.com/Kushan2k/student-management-system/
github.comgithub.com/Kushan2k/student-management-system/issues/1
vuldb.comvuldb.com/cve/CVE-2026-11474
vuldb.comvuldb.com/submit/833933
vuldb.comvuldb.com/vuln/369094
vuldb.comvuldb.com/vuln/369094/cti

Frequently asked

questions

Yes. The issue is reachable through the Registration Endpoint over the network, allowing remote attackers to upload files if they can access the affected service.

The description does not indicate an authentication requirement, so it should be assumed that an unauthenticated or minimally authenticated user could exploit it unless access controls are explicitly enforced in a given deployment.

The safest approach is to implement strict server-side controls on uploads: enforce an allowlist of safe file types, store uploads outside web-executable directories, disable script execution in upload locations, and limit upload permissions to trusted users.

Adopt standardized upload handling components, require security review for any endpoint accepting files, enforce least-privilege storage and execution policies at the platform level, and integrate automated checks for CWE-434 and access control weaknesses into the development and deployment pipeline.

Find out what's already
exploitable in your codebase.