Summary
The itsourcecode University Management System 1.0 is vulnerable to SQL injection in the /att_add.php endpoint via the Name parameter.
An attacker who can send crafted HTTP requests to this endpoint may be able to manipulate database queries, potentially leading to data exposure, modification, or account compromise.
Affected context
The vulnerability occurs in the web-based University Management System 1.0, specifically in the /att_add.php script handling the Name parameter.
It is relevant when user-controlled input is concatenated directly into SQL statements without proper validation, sanitization, or use of parameterized queries.
Any deployment where /att_add.php is reachable over a network and tied to a backend database may be affected, depending on database privileges and configuration.
Exploit preconditions
- Attack surface: HTTP(S) interface exposing /att_add.php
- Required access: Network access to the application; no special privileges are inherently required beyond reaching the vulnerable endpoint
- Trigger point: Submission of crafted input in the Name parameter, typically via GET or POST
- Why exploitation is possible: The application appears to interpolate the Name parameter directly into SQL queries without proper escaping or parameterization, allowing attacker-controlled fragments to alter the intended query structure.
Why this happens
This issue stems from building SQL statements by concatenating raw user input from the Name parameter into the query string.
Instead of treating user input as data only, the application allows that input to influence the SQL syntax, which maps to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').
More generally, it reflects CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component, where the downstream component is the SQL database engine.
The absence of prepared statements, input validation, and robust encoding enables attackers to inject additional SQL logic.
Potential impact
- An attacker may read sensitive data from database tables, depending on privileges.
- An attacker could modify, insert, or delete records, impacting integrity of academic or administrative data.
- An attacker may leverage the database account's permissions to create or alter accounts, or manipulate authentication data.
- In some environments, SQL injection could be chained to gain access to underlying server resources or execute database-specific functions.
General mitigation guidance
Effective mitigation focuses on treating all external input as untrusted and isolating it from SQL syntax:
- Use parameterized queries or prepared statements for all database access, ensuring user input is bound as data, not concatenated into query strings.
- Apply server-side validation on the Name parameter, enforcing expected formats (e.g., character sets, length limits) and rejecting unexpected patterns.
- Implement a centralized data access layer where query construction rules can be consistently enforced.
- Restrict database user privileges so that the application account operates with least privilege, reducing impact if injection occurs.
- Consider defense-in-depth measures such as query whitelisting patterns and database-level controls (e.g., read-only roles for certain operations).
How teams detect issues like this
Detection typically combines code-centric and behavior-centric approaches:
- Static analysis rules searching for string concatenation or interpolation in SQL query construction, especially where variables like
$_GET/$_POST/request parameters flow into database APIs. - Manual code review focusing on PHP data access sections in /att_add.php and related modules, verifying use of prepared statements and absence of dynamic SQL built from user input.
- Runtime monitoring of database queries for anomalous patterns such as tautologies, UNION queries, or stacked statements originating from web requests.
- Integration of automated security testing tools (e.g., SAST and DAST) into CI/CD pipelines to flag potential SQL injection sinks and validate that fixes remain effective over time.

