Severity:

HIGH RISK

(7.3)

SQL Injection in checkEmail Endpoint of SourceCodester

CVE-2026-7545

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

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

The checkEmail endpoint in SourceCodester Advanced School Management System 1.0 is vulnerable to SQL injection due to unsafe handling of user-supplied input in commonController.php.

An attacker can remotely manipulate parameters sent to this endpoint to alter backend SQL queries, potentially accessing or modifying sensitive school management data.

Affected context

This vulnerability occurs in deployments of SourceCodester Advanced School Management System 1.0 that expose the checkEmail endpoint implemented in commonController.php.

The issue manifests when user-controlled parameters from HTTP requests are incorporated into SQL queries without robust validation, sanitization, or parameterization.

Any environment where this endpoint is reachable over a network and tied to a database backend is potentially affected, including internet-facing and intranet deployments.

Exploit preconditions

  • Attack surface: HTTP interface of the checkEmail endpoint in commonController.php.
  • Required access: Network-level access to the application; no special privileges are necessarily required beyond the ability to send crafted requests.
  • Trigger point: Submission of maliciously crafted input (e.g., email or identifier fields) that is incorporated into a SQL query by the checkEmail logic.
  • Why exploitation is possible: The application appears to construct SQL statements by concatenating raw user input into query strings, without using parameterized queries or adequate escaping, allowing attackers to inject arbitrary SQL fragments.

Why this happens

The underlying bug class is SQL injection, mapped to CWE-89: Improper Neutralization of Special Elements used in an SQL Command.

In the affected code path, user-supplied data sent to the checkEmail endpoint is likely interpolated directly into an SQL query string, such as within WHERE clauses, without parameter binding or strict validation.

Additionally, the presence of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component suggests that unsanitized input is being passed to a downstream component (the database engine) in a context where control characters (quotes, comment markers, operators) alter the intended command structure.

This insecure pattern allows attacker-controlled input to be interpreted as part of the SQL command rather than as data, enabling query manipulation.

Potential impact

  • Unauthorized reading of sensitive application data, such as student, teacher, or administrative records.
  • Modification or deletion of database contents, including grades, schedules, and user accounts.
  • Creation of new application accounts or escalation of privileges by altering authentication or role records.
  • Extraction of password hashes or credential material that can be used for further compromise.
  • Disruption of application availability through destructive queries (e.g., dropping tables) or expensive queries causing performance degradation.

General mitigation guidance

Effective mitigation focuses on eliminating direct concatenation of user input into SQL statements and narrowing trust boundaries around all incoming data.

Common defensive patterns include:

  • Using parameterized queries (prepared statements) for all database access, ensuring user input is always treated as data, not executable command text.
  • Applying strict server-side validation on all fields accepted by the checkEmail endpoint (e.g., enforcing well-formed email formats or ID patterns).
  • Centralizing database access through vetted data access layers or ORM abstractions that default to safe query construction.
  • Minimizing the privileges of the database account used by the application so that, even if an injection occurs, the scope of damage is reduced.
  • Implementing a general input-handling policy that treats all external input as untrusted by default and applies context-aware encoding and validation before passing it to downstream components like the database.

How teams detect issues like this

Organizations can detect and monitor for SQL injection issues in this context using a combination of static and dynamic techniques:

  • Static application security testing (SAST) rules that flag SQL query construction using string concatenation or interpolation with request parameters in PHP code (particularly in commonController.php and related controllers).
  • Code review checklists that explicitly require reviewers to verify use of prepared statements and parameter binding in all data-access functions.
  • Runtime protections such as web application firewalls (WAFs) configured with rulesets for common SQL injection patterns, tuned specifically for endpoints like checkEmail.
  • Dynamic application security testing (DAST) that sends crafted payloads to the checkEmail endpoint and watches for anomalous responses or error signatures indicative of injection.
  • Logging and monitoring focused on unusual database queries (e.g., queries containing comment markers, UNION operators, or tautologies) that could signal attempted exploitation.

Sources

SourceLink
github.comgithub.com/eqwerwq/CVE/issues/2
vuldb.comvuldb.com/submit/804340
vuldb.comvuldb.com/vuln/360356
vuldb.comvuldb.com/vuln/360356/cti
sourcecodester.comsourcecodester.com/

Frequently asked

questions

Yes. Because the vulnerable checkEmail endpoint is accessible over HTTP, an attacker with network access to the application can exploit the SQL injection remotely by sending crafted requests.

Not necessarily. If the checkEmail endpoint is exposed without prior authentication, an unauthenticated attacker may be able to exploit the vulnerability. Actual requirements depend on how routing and access control are configured in the deployment.

The most robust fix is to refactor all affected database interactions to use parameterized queries or prepared statements, ensuring that user input is never concatenated directly into SQL strings. This should be combined with strict server-side validation of all input fields.

Adopting secure coding standards that mandate parameterized queries, enforcing them via code review and automated static analysis, and using database abstraction layers or ORMs that promote safe patterns by default are effective strategies. Treat all externally sourced data as untrusted, validate it against expected formats, and ensure developers receive regular training on injection risks and secure database access patterns.

Find out what's already
exploitable in your codebase.