/

CVE-2026-10110

Severity:

HIGH RISK

(7.3)

SQL Injection in Student Details Management System

CVE-2026-10110

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exposure and Modification 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

Student Details Management System 1.0 contains a SQL injection flaw in /index.php, where the roll parameter is used unsafely in database queries.

A remote attacker can manipulate this parameter to alter SQL logic, potentially accessing or modifying student records and other backend data.

Affected context

The vulnerability exists in web deployments of the Student Details Management System 1.0 where:

  • The /index.php entry point is exposed over HTTP/S
  • The roll parameter is accepted from user input (e.g., query string or form field)
  • The parameter value is interpolated into SQL statements without robust parameterization
  • Database accounts have permissions to read or update sensitive tables (such as student details)

It is most relevant in environments where the application is internet-facing or reachable by untrusted users.

Exploit preconditions

  • Attack surface: Public or internal web interface at /index.php
  • Required access: Network access to the application; no prior authentication may be needed depending on how /index.php is used
  • User-controlled input: Ability to supply or tamper with the roll parameter (URL parameter, form field, or similar)
  • Trigger point: Execution of SQL queries in response to requests using roll without proper parameterization or escaping
  • Why exploitation is possible: The application directly incorporates user-controlled data into SQL statements, violating separation between code and data, which enables attackers to modify query structure.

Why this happens

The underlying issue is improper neutralization of special elements used in SQL commands (CWE-89), likely combined with insufficient output encoding or query construction safeguards (CWE-74).

Instead of using prepared statements with bound parameters, the application appears to build SQL strings by concatenating the roll parameter directly into the query.

This pattern allows user input to break out of its intended data context and inject additional SQL clauses, conditions, or statements.

The problem is conceptual: any time user input is treated as part of SQL syntax rather than as data, injection becomes possible.

Potential impact

  • Access to student records that the attacker should not be able to view
  • Modification or deletion of student details and related academic records
  • Extraction of other data stored in the same database (users, credentials hashes, configuration)
  • Creation of new accounts or escalation of privileges via tampering with authorization-related tables
  • Potential disruption of application availability through destructive queries (e.g., dropping tables)
  • Indirect compromise of other systems that trust this database or reuse its credentials

General mitigation guidance

Effective mitigation focuses on treating all user input as untrusted and strictly separating SQL code from data:

  • Prefer parameterized queries (prepared statements with bound variables) for every database interaction involving user input.
  • Apply centralized input validation for identifiers like roll (e.g., numeric-only or constrained formats) and reject values that do not meet strict patterns.
  • Avoid constructing SQL dynamically from raw request parameters; if dynamic behavior is needed, restrict it to whitelisted values or structural components.
  • Enforce least-privilege for database accounts so that the application user has only the minimal permissions needed (e.g., no schema modification).
  • Introduce a defensive coding standard that prohibits ad-hoc string concatenation for SQL and encourage the use of ORM or query builder abstractions that default to safe parameter binding.

How teams detect issues like this

Organizations can detect this class of issue through a combination of code-centric and runtime techniques:

  • Static analysis: Configure SAST rules to flag raw SQL query construction that concatenates superglobals or request parameters (such as $_GET, $_POST).
  • Code review: Look for SQL execution calls in /index.php and related modules where roll or other user inputs are embedded directly in the query string.
  • Security testing: Use automated DAST scanners and manual penetration testing to send crafted roll values and observe anomalous responses or database error messages.
  • Logging and monitoring: Implement structured logging of failed queries and unexpected errors, then alert on patterns indicative of injection attempts (e.g., frequent quotes, comment tokens, or SQL keywords in parameters).
  • Policy enforcement: Integrate secure coding guidelines into CI/CD, requiring that new database access patterns use prepared statements and pass security checks before deployment.

Sources

SourceLink
code-projects.orgcode-projects.org/
github.comgithub.com/Xmyronn/Student-Details-Management-System-1.0---SQL-Injection-Unauthenticated-.git
vuldb.comvuldb.com/submit/818504
vuldb.comvuldb.com/vuln/367288
vuldb.comvuldb.com/vuln/367288/cti

Frequently asked

questions

The vulnerability can typically be exploited by any user who can reach /index.php and control the roll parameter. If the page is public and unauthenticated, the risk extends to any internet-based attacker.

Not necessarily. If the vulnerable query executes before authentication or on a publicly accessible function, exploitation does not require valid credentials. If it is tied to an authenticated feature, the attacker would need at least low-privileged access.

The most robust fix is to refactor all queries involving roll to use parameterized statements, combined with strict input validation on that parameter, and to eliminate direct concatenation of user input into SQL strings.

Adopting a secure data access layer (ORM or query builder) that uses bound parameters by default, enforcing coding standards against dynamic SQL string concatenation, and integrating automated security testing in the development pipeline can significantly reduce the likelihood of similar vulnerabilities.

Find out what's already
exploitable in your codebase.