Severity:

HIGH RISK

(7.3)

SQL Injection in add_result.php of University Management

CVE-2026-3747

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Database Access and Manipulation

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

University Management System 1.0 contains a SQL injection vulnerability in the /add_result.php endpoint, where the subject parameter is incorporated into database queries without proper sanitization.

A remote attacker can manipulate this parameter to alter SQL queries, potentially accessing, modifying, or deleting data in the underlying database when the vulnerable functionality is invoked.

Affected context

The vulnerability occurs in the University Management System 1.0 within the /add_result.php functionality that interacts with the backend database to create or update student result records.

It is exposed when user-controlled input (the subject parameter) is passed directly into SQL statements without adequate parameterization or escaping.

This typically manifests in web deployments where the application is reachable over a network and uses a relational database for storing academic and administrative information.

Exploit preconditions

  • Attack surface: HTTP(S) interface to the /add_result.php endpoint of the University Management System.
  • Required access: Ability to send requests to the web application; exploitation may or may not require prior authentication depending on how the endpoint is protected.
  • Trigger point: Submission of crafted input in the subject parameter (e.g., via form fields or direct HTTP requests) that is concatenated into SQL queries.
  • Why exploitation is possible: The application constructs SQL statements by directly embedding user-supplied subject values without using prepared statements or robust input validation, allowing attackers to inject arbitrary SQL fragments.

Why this happens

The root cause aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

In the vulnerable code path, the subject parameter is likely concatenated into a query string (e.g., SELECT, INSERT, or UPDATE) without parameter binding or proper escaping.

This insecure pattern treats user input as trusted and fails to neutralize SQL meta-characters, enabling attackers to alter the intended query logic, access additional data, bypass application checks, or perform destructive operations on the database.

The presence of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component reflects a broader issue where untrusted input is propagated to downstream components (the database engine) without appropriate sanitization.

Potential impact

  • Unauthorized reading of sensitive student, staff, or administrative records.
  • Modification or deletion of academic results and other critical data.
  • Creation of fake records, grade manipulation, or tampering with transcripts.
  • Bypassing of application-level authorization checks enforced in the application logic.
  • Potential disclosure of database schema details and other configuration information.
  • In some environments, possible pivoting to remote code execution via database-specific features or stored procedures.

General mitigation guidance

Effective mitigation typically focuses on eliminating direct concatenation of user input into SQL and tightening data handling around database operations:

  • Prefer parameterized queries or prepared statements for all database interactions, binding the subject parameter as data rather than SQL code.
  • Apply strict server-side validation and normalization of input fields, restricting subject values to expected patterns (e.g., whitelisted identifiers or codes).
  • Use database abstraction layers or ORM frameworks that encourage safe-by-default query construction.
  • Enforce least-privilege database accounts so that the application's DB user only has the minimal required permissions (e.g., no schema modification if not needed).
  • Implement centralized input handling and sanitization policies to reduce inconsistent protections across different PHP endpoints.
  • Consider additional controls such as web application firewalls (WAF) configured with rules targeting SQL injection patterns as a compensating layer.

How teams detect issues like this

Detection usually involves combining code-level review with runtime monitoring:

  • Static analysis to identify string-based SQL construction patterns involving the subject parameter and other user-controlled inputs, especially in PHP scripts such as add_result.php.
  • Manual code review focusing on database access layers, looking for concatenation of $_GET, $_POST, or other request variables into query strings without parameterization.
  • Use of security linters or SAST tools that support PHP and have rules for CWE-89 and CWE-74 to automatically flag risky query patterns.
  • Runtime monitoring and logging of SQL queries, enabling detection of anomalous query structures or repeated injection-like patterns.
  • Application-level logging of input parameters and error messages, with alerts for database errors such as syntax faults that may indicate injection attempts.

Sources

SourceLink
github.comgithub.com/1873454331sss/CVE/issues/1
itsourcecode.comitsourcecode.com/
vuldb.comvuldb.com/?ctiid.349725
vuldb.comvuldb.com/?id.349725
vuldb.comvuldb.com/?submit.767947

Frequently asked

questions

Yes. The vulnerable functionality is accessible over the network, and an attacker who can reach the /add_result.php endpoint can attempt SQL injection via crafted subject parameter values.

It depends on how the University Management System is configured. If the add_result.php page requires login or specific roles, the attacker must first obtain such access; if it is exposed to unauthenticated users, exploitation may occur without any credentials.

Refactor the affected code to use parameterized queries or prepared statements for all database interactions, ensuring that the subject parameter and other user inputs are always bound as data and never concatenated directly into SQL strings.

Establish development standards that mandate parameterized queries, apply strict server-side validation and whitelisting for all user inputs, integrate SAST or code scanning into the CI pipeline to catch unsafe query construction early, and perform regular security-focused code reviews of database access layers.

Find out what's already
exploitable in your codebase.