/

CVE-2026-11472

Severity:

HIGH RISK

(7.3)

SQL Injection (CWE-89) in Exam Timetabling Password Field

CVE-2026-11472

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Authentication Bypass and Data Exposure

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 Class and Exam Timetabling System 1.0 contains a SQL injection flaw in index1.php where the Password parameter is not safely handled.

A remote attacker can inject crafted input into this parameter to manipulate backend queries, potentially bypassing authentication or accessing sensitive data.

Affected context

The vulnerability occurs in web deployments of the SourceCodester Class and Exam Timetabling System 1.0 where index1.php is exposed to users as part of a login or password-handling flow.

It manifests when user-supplied data from the Password argument is directly concatenated into SQL statements without robust input handling or parameterization.

The issue is more likely in default or unmodified installations where security hardening, such as input validation and prepared statements, has not been applied consistently.

Exploit preconditions

  • Attack surface: Public-facing web interface, specifically HTTP requests targeting /index1.php.
  • Required access: Network access to the application; no prior authentication is typically required if the vulnerable parameter is part of a login form.
  • Trigger point: Submission of a crafted Password parameter value that is incorporated into a SQL query.
  • Why exploitation is possible: The application dynamically builds SQL queries by interpolating the Password parameter directly into the query string, without using parameterized queries or adequate escaping, enabling attackers to alter query logic.

Why this happens

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

The application constructs SQL statements by concatenating raw user input from the Password parameter into a query string, assuming it is benign and well-formed.

Because special characters and SQL metasyntax are not neutralized or bound as parameters, the database interprets parts of the user input as executable SQL.

CWE-74 is also implicated because the system fails to properly neutralize user-controlled data before inserting it into a backend interpreter context (the SQL engine), illustrating a broader output encoding and contextualization problem.

Potential impact

  • Attackers may bypass authentication and gain unauthorized access to user or administrator accounts.
  • Sensitive information such as user credentials, schedules, and exam-related data could be read or exfiltrated from the database.
  • Database contents can be modified, including tampering with timetables, grades, or user records.
  • The database schema might be enumerated, facilitating further targeted attacks.
  • In some configurations, SQL injection could be chained into file write or command execution primitives through database-specific features.

General mitigation guidance

Effective mitigation focuses on eliminating direct concatenation of user input into SQL commands and reducing trust in frontend-supplied data:

  • Use parameterized queries or prepared statements for all database interactions involving user-controlled values, including login and password handling.
  • Apply strict server-side validation on authentication fields (e.g., enforcing expected character sets and length constraints for passwords and usernames).
  • Centralize database access logic behind a data access layer that enforces safe query-building patterns by design.
  • Limit database privileges for the application user to the minimum required operations, reducing impact if injection occurs.
  • Introduce generic error handling that avoids exposing raw SQL errors, while still logging sufficient diagnostics for administrators.

How teams detect issues like this

Detection generally combines code-centric review and runtime observation:

  • Perform static analysis to flag string-concatenated SQL queries, especially those including request parameters like Password, username, or other form inputs.
  • During code review, look for direct use of $_GET, $_POST, or similar request variables inside SQL query construction or ORM raw-query methods.
  • Enforce development policies that mandate prepared statements and prohibit ad-hoc query concatenation in coding standards.
  • Use interactive application security testing (IAST) or dynamic analysis tools that can detect SQL injection sinks when fuzzing authentication endpoints.
  • Monitor logs and database activity for anomalous query patterns containing typical SQL injection markers, such as unmatched quotes or tautological conditions.

Sources

SourceLink
github.comgithub.com/Icecream102/cve/issues/3
vuldb.comvuldb.com/cve/CVE-2026-11472
vuldb.comvuldb.com/submit/833859
vuldb.comvuldb.com/vuln/369092
vuldb.comvuldb.com/vuln/369092/cti
sourcecodester.comsourcecodester.com/

Frequently asked

questions

Yes. An attacker who can reach the web interface over the network can send crafted requests to /index1.php and attempt to exploit the vulnerable Password parameter.

Typically no. Because the flaw appears in a login-related flow, the attacker usually does not need to be authenticated beforehand, assuming the endpoint is publicly accessible.

Refactor all database interactions to use parameterized queries or prepared statements, ensuring that user inputs like Password are bound as parameters rather than concatenated into SQL strings, and add strict server-side validation for authentication inputs.

Adopt coding standards that forbid raw SQL string concatenation with user input, use a vetted database abstraction layer or ORM with safe defaults, integrate static analysis into the CI pipeline to flag dangerous patterns, and provide developer training on context-aware input handling and query construction.

Find out what's already
exploitable in your codebase.