Severity:

HIGH RISK

(7.3)

SQL Injection in login.php of Online Class Record System

CVE-2026-2087

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Authentication Bypass and Data Compromise 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

The Online Class Record System 1.0 contains a SQL injection vulnerability in the /admin/login.php endpoint, where the user_email parameter is incorporated into database queries without proper sanitization.

A remote attacker can manipulate this parameter to interfere with SQL query execution, which may lead to authentication bypass, data disclosure, or modification of class records depending on database privileges.

Affected context

This vulnerability occurs in the administrative login functionality of the Online Class Record System 1.0, specifically in the /admin/login.php script that handles user_email input.

It is typically present when the application directly concatenates user-supplied email values into SQL statements for authentication checks, without using parameterized queries or robust input validation.

The issue is most relevant in deployments where the admin panel is internet-accessible and the underlying database account has broad access to application data.

Exploit preconditions

  • Attack surface: Public or internally exposed web interface at /admin/login.php
  • Required access: Network access to the application; no prior authentication is strictly required if the login endpoint is exposed
  • Input vector: The user_email request parameter, typically provided via POST or GET data
  • Trigger point: Execution of the SQL query used to validate login credentials or fetch user records
  • Why exploitation is possible: The application interpolates user_email directly into SQL statements without parameterization or adequate escaping, allowing crafted input to alter query structure

Why this happens

The underlying bug is improper construction of SQL queries using untrusted input from the user_email parameter.

Instead of using parameterized queries or prepared statements, the application appears to build SQL strings by concatenating raw request data, which is a textbook CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

Because the database treats parts of the input as executable query syntax, an attacker can inject additional conditions, unioned queries, or control flow that the developer did not intend.

The reference to CWE-74 highlights the broader pattern of insufficient neutralization of special elements in data sent to downstream interpreters, with SQL being the specific interpreter in this case.

Potential impact

  • Authentication bypass to gain administrative or privileged access to the system
  • Unauthorized reading of sensitive data, such as student information, grades, or administrator accounts
  • Modification or deletion of class records, grades, or user accounts
  • Creation of new administrative users to maintain persistent access
  • Potential execution of stacked or second-order queries, depending on database configuration, which can further expand impact

General mitigation guidance

Effective mitigation centers on removing direct string concatenation of user input into SQL queries and minimizing the trust placed in login parameters.

Recommended defensive patterns include:

  • Use parameterized queries or prepared statements for all database access involving user_email and other user-controlled fields
  • Apply strict server-side validation on email fields, enforcing a well-defined format and rejecting unexpected characters
  • Centralize database access through a data access layer that enforces safe query construction patterns by default
  • Limit database account privileges so the application user has only the minimal rights necessary (e.g., no ability to drop tables or access unrelated schemas)
  • Implement generic error handling that avoids exposing raw SQL error messages to clients, reducing information leakage about query structure

How teams detect issues like this

Detection can focus on both code-level patterns and runtime behavior:

  • Static analysis: Configure SAST rules to flag dynamic SQL construction using request parameters (e.g., concatenation of $_POST['user_email'] or $_GET['user_email'] into query strings without binding)
  • Code review: During manual reviews, inspect authentication and login flows for inline SQL, missing prepared statements, and absence of validation on email inputs
  • Security testing: Perform targeted SQL injection tests on login forms, looking for anomalous responses, authentication bypass, or SQL error messages when special characters are supplied
  • Runtime monitoring: Enable database and application logging to detect suspicious query patterns, such as unexpected use of logical operators, UNION, or comment syntax originating from login endpoints

Sources

SourceLink
github.comgithub.com/xiaoccm07/cve/issues/1
vuldb.comvuldb.com/?ctiid.344654
vuldb.comvuldb.com/?id.344654
vuldb.comvuldb.com/?submit.746510
sourcecodester.comsourcecodester.com/

Frequently asked

questions

Yes. As long as the /admin/login.php endpoint is reachable over the network, a remote attacker can attempt to exploit the SQL injection using crafted user_email values.

Typically no. The flaw is in the login handling itself, so an unauthenticated user can often exploit the vulnerability, provided they can send requests to the admin login page.

Refactor the login code to use parameterized queries or prepared statements exclusively, combined with strict server-side validation of the email field, and ensure no user-controlled data is ever concatenated directly into SQL strings.

Adopt a development standard that mandates prepared statements for all database access, centralize data access in a vetted library or ORM, integrate static analysis and security testing into CI pipelines, and regularly review authentication code paths for unsafe query construction.

Find out what's already
exploitable in your codebase.