Severity:

HIGH RISK

(7.3)

SQL Injection in itsourcecode Student Management System

CVE-2026-1701

Modified

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exfiltration and Manipulation via SQL Injection

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

A SQL injection vulnerability in the itsourcecode Student Management System 1.0 allows attackers to manipulate the ID parameter in /enrollment/index.php to interfere with database queries.

When user-supplied input is concatenated directly into SQL statements without proper validation or parameterization, a remote attacker can craft malicious requests that may access, modify, or delete data.

Affected context

This vulnerability arises in the web-based Student Management System 1.0, specifically within the enrollment functionality handled by /enrollment/index.php.

It is relevant in deployments where:

  • The application reads the ID argument from HTTP requests (e.g., GET or POST).
  • The value of ID is used in SQL queries without proper parameterization or escaping.
  • The database account used by the application has permissions beyond strictly necessary for read-only operations.

These conditions are typical in many PHP/MySQL-style applications that rely on dynamic query construction.

Exploit preconditions

  • Attack surface: Public or internal web interface exposing /enrollment/index.php.
  • Required access: Network access to the application; no prior authentication may be required if the endpoint is publicly reachable.
  • Trigger point: Supplying a crafted ID parameter value in an HTTP request that the application passes directly into a SQL query.
  • Why exploitation is possible: The server-side code performs dynamic SQL query construction with untrusted input, failing to use prepared statements or robust input validation, which maps to CWE-89 and CWE-74 (improper neutralization in downstream interpreters).

Why this happens

The core issue is unsafe composition of SQL queries using untrusted input from the ID argument.

Instead of using parameterized queries or prepared statements, the application likely concatenates the ID value directly into the SQL string.

This insecure pattern allows attackers to inject additional SQL syntax that the database interprets as part of the query logic.

Conceptually, this is a manifestation of CWE-89: Improper Neutralization of Special Elements used in an SQL Command and is related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component because the database acts as a downstream interpreter for improperly sanitized data.

Potential impact

  • Attackers may read sensitive student or administrative records stored in the database.
  • Attackers could modify or delete enrollment data, grades, or user accounts.
  • The application's authentication or authorization data might be altered, potentially leading to account takeover.
  • Under certain configurations, attackers could chain the SQL injection into file write or OS-level features of the database, increasing overall system compromise.
  • Data integrity may be undermined, impacting reporting, compliance, and operational reliability.

General mitigation guidance

Mitigation typically focuses on eliminating direct string concatenation in SQL construction and reducing the trust placed in user-controlled input:

  • Use parameterized queries / prepared statements for all database operations that involve user-supplied data, including the ID argument.
  • Apply strict type enforcement and whitelisting for identifier-like parameters (e.g., ensure ID is treated as an integer and reject non-conforming values early).
  • Centralize database access patterns in a data access layer where secure query-building practices can be enforced consistently.
  • Run the database with least-privilege credentials so that the application account can only perform the minimal set of actions required.
  • Implement generic input validation and normalization routines to reduce the risk of injection across the application, not just on this endpoint.

How teams detect issues like this

Effective detection typically combines code-focused and behavior-focused techniques:

  • Static analysis: Use rules that flag dynamic SQL construction involving superglobals (e.g., $_GET['ID'], $_POST['ID']) or string concatenation in query strings.
  • Code review: Look for SQL queries built via interpolation or concatenation and confirm that all query parameters pass through prepared statements or binding APIs.
  • Security testing: Perform automated and manual dynamic tests (DAST) that send crafted payloads in the ID parameter and monitor for SQL error messages, unexpected responses, or timing anomalies.
  • Logging and monitoring: Enable structured logging of query execution patterns and application errors; sudden SQL syntax errors or anomalous access to sensitive tables can signal injection attempts.
  • Policy enforcement: Integrate secure coding guidelines and pre-commit hooks or CI checks that block merging of code using insecure query construction patterns.

Sources

SourceLink
github.comgithub.com/ltranquility/CVE/issues/34
itsourcecode.comitsourcecode.com/
vuldb.comvuldb.com/?ctiid.343491
vuldb.comvuldb.com/?id.343491
vuldb.comvuldb.com/?submit.742024

Frequently asked

questions

Yes. As long as /enrollment/index.php is accessible over the network and accepts the ID parameter, an attacker can attempt exploitation remotely via crafted HTTP requests.

Not necessarily. If the vulnerable endpoint is reachable without logging in, no authentication is required. If access to /enrollment/index.php is restricted to logged-in users, then at least a low-privileged account would be needed.

The most robust approach is to replace all dynamic SQL built via string concatenation with parameterized queries or prepared statements, combined with strict input validation. Treat numeric IDs as typed values and bind them as parameters rather than embedding them directly in query strings.

Establish standard data access abstractions that enforce prepared statements by default, apply centralized input validation, and incorporate security reviews and automated checks into the development lifecycle so that unsafe query patterns are detected before deployment.

Find out what's already
exploitable in your codebase.