Severity:

HIGH RISK

(7.3)

SQL Injection in University Management System

CVE-2026-3765

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Data Access and Modification

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

The University Management System 1.0 contains a SQL injection flaw in /att_single_view.php where the dt parameter is used in database queries without proper sanitization.

A remote attacker can manipulate this parameter to interfere with SQL queries, potentially accessing or modifying sensitive university data when the application processes crafted requests.

Affected context

This vulnerability occurs in the web-based University Management System 1.0 within the /att_single_view.php endpoint that likely displays or processes attendance-related data.

It is exposed when user-controlled input from the dt parameter is interpolated directly into SQL statements without robust validation, encoding, or parameterization.

Any deployment that exposes this endpoint over a network and relies on a relational database backend may be affected, depending on configuration and access controls around the application.

Exploit preconditions

  • Attack surface: HTTP(S) endpoint /att_single_view.php accessible over the network.
  • Required access: Ability to send crafted requests to the vulnerable endpoint (typically unauthenticated or low-privileged web access, depending on deployment).
  • Trigger point: The server-side code reads the dt parameter and constructs a SQL query incorporating it.
  • Why exploitation is possible: The application appears to concatenate dt directly into a SQL statement without using bound parameters or rigorous input handling, allowing attacker-controlled syntax to alter the query structure.

Why this happens

The root cause aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') and is related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component.

The application likely builds SQL queries as strings, embedding the dt parameter directly and trusting its contents to be well-formed data rather than treating it as potentially hostile input.

Without prepared statements, strict whitelisting, or context-appropriate encoding, special characters and SQL operators provided by an attacker can escape the intended data context and modify the logic of the underlying database query.

Potential impact

  • May allow retrieval of sensitive records from attendance or related university tables beyond what the user is authorized to see.
  • Could enable modification or deletion of academic or administrative data, including attendance logs or student information.
  • Might permit creation of new records or alteration of existing ones, impacting data integrity and reporting.
  • In certain configurations, may be leveraged to run stacked queries or access database-level metadata, potentially aiding further compromise.
  • Could expose credentials or configuration data stored in the database if such information is accessible through SQL queries.

General mitigation guidance

Mitigation generally focuses on eliminating direct string concatenation in SQL queries and reducing trust in user input:

  • Use parameterized queries or prepared statements for all database interactions involving external input, ensuring that user data cannot change query structure.
  • Apply strict validation and whitelisting to the dt parameter, constraining it to expected formats (e.g., specific date patterns or discrete allowed values).
  • Centralize database access patterns so that query construction is reviewed and standardized rather than ad hoc.
  • Limit database privileges for the application account to the minimal operations required, reducing impact if an injection occurs.
  • Implement consistent input handling and encoding policies for data passed to downstream components such as databases.

How teams detect issues like this

Effective detection blends code-centric and behavior-centric approaches:

  • Use static analysis rules to flag dynamic SQL construction that incorporates request parameters like dt without parameterization.
  • During code review, look for direct concatenation of $_GET/$_POST variables (or equivalent) into SQL strings, particularly in files like att_single_view.php.
  • Employ runtime monitoring or web application firewalls configured to detect anomalous SQL patterns in incoming requests (e.g., presence of SQL keywords or comment tokens in dt).
  • Integrate security testing into CI/CD pipelines, including automated SQL injection tests against exposed endpoints.

Sources

SourceLink
github.comgithub.com/mfcluvlife12345-eng/xianyu/issues/1
itsourcecode.comitsourcecode.com/
vuldb.comvuldb.com/?ctiid.349743
vuldb.comvuldb.com/?id.349743
vuldb.comvuldb.com/?submit.768247

Frequently asked

questions

Yes. The vulnerable endpoint is reachable over HTTP(S), so a remote attacker who can send requests to the application can attempt to exploit the dt parameter.

That depends on how the instance is deployed. If /att_single_view.php is publicly accessible without login, the issue can be exploited anonymously; if it requires user sessions, an attacker would need at least that level of access.

Refactor all affected queries to use parameterized statements or prepared queries, and enforce strict validation on dt so that only valid, expected values are accepted by the application.

Adopt a development policy that forbids dynamic query string building with user input, use an abstraction layer or ORM that defaults to parameterized queries, and incorporate regular secure code reviews and automated scanning focused on injection risks.

Find out what's already
exploitable in your codebase.