Severity:

HIGH RISK

(7.3)

SQL Injection in Login Authentication of Online FIR System

CVE-2026-5665

Deferred

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

Online FIR System 1.0 contains a SQL injection vulnerability in the login functionality (/Login/checklogin.php), where the email and password parameters are unsafely embedded into database queries.

An attacker can remotely manipulate these inputs to alter the SQL logic, potentially bypassing authentication and accessing or modifying backend data.

Affected context

The vulnerability occurs in the login component of Online FIR System 1.0, specifically within /Login/checklogin.php, when processing user-supplied email and password fields.

It is most relevant in deployments where user input is directly concatenated into SQL queries without parameterization or robust validation, and where the database account used by the application has broad read or write permissions on sensitive tables.

Exploit preconditions

  • Attack surface: Public-facing web login endpoint at /Login/checklogin.php.
  • Required access: Network reachability to the web application; no prior authentication required.
  • User-controllable input: The email and password parameters in the login form or equivalent HTTP requests.
  • Trigger point: Server-side execution of an SQL query that incorporates these parameters without proper escaping or parameter binding.
  • Why exploitation is possible: The application interpolates raw input into SQL statements, allowing crafted values to break out of intended query structure and inject additional SQL clauses or conditions.

Why this happens

This issue stems from constructing SQL statements by concatenating or interpolating raw user input into query strings without using prepared statements or safe parameter binding.

This pattern maps directly to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection') and is related to CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component.

Because the login code trusts email and password values to be benign, it fails to neutralize metacharacters such as quotes and logical operators, enabling attackers to change the query's logic at runtime.

Potential impact

  • Attacker may bypass authentication and gain access to accounts without valid credentials.
  • Attacker could read sensitive records stored in the database, such as user details or complaint information, depending on database privileges.
  • Attacker may modify, insert, or delete records, potentially tampering with or erasing FIR data.
  • Attacker could enumerate database structure and metadata to facilitate broader compromise.
  • In some configurations, attacker might leverage SQL injection to execute additional database functions that could impact server integrity.

General mitigation guidance

Effective mitigation centers on eliminating direct use of user input in SQL query construction and reducing the trust boundary around authentication data.

Recommended defensive patterns include:

  • Using parameterized queries or prepared statements for all database access in the login component and elsewhere.
  • Implementing a robust data access layer that encapsulates query construction and disallows raw string concatenation.
  • Applying strict server-side validation and normalization for authentication fields (e.g., ensuring email conforms to expected format and limiting length).
  • Using least-privilege database accounts so that even if a query is manipulated, accessible data and operations are minimized.
  • Centralizing secure coding guidelines and patterns for database interaction to ensure consistent defenses across the application.

How teams detect issues like this

Organizations can identify this class of issue using a combination of code-centric and behavior-centric approaches:

  • Static code analysis: Scan PHP code for SQL query construction that uses string concatenation, interpolation, or unvalidated $_POST/$_GET variables, especially in authentication routines.
  • Code review: Manually inspect /Login/checklogin.php and related data access layers for direct insertion of email and password into SQL, absence of prepared statements, and missing validation.
  • Dynamic testing: Use web application scanners or security testing tools configured to send payloads in login fields and monitor for SQL error messages, anomalies in responses, or authentication bypass.
  • Policy enforcement: Establish CI/CD checks and secure coding standards that forbid non-parameterized SQL and require use of approved database access abstractions.

Sources

SourceLink
code-projects.orgcode-projects.org/
github.comgithub.com/ahmadmarz10-hub/CVEsMarz/blob/main/SQL%20Injection%20in%20Online%20FIR%20System%20PHP%20email%20Parameter.md
vuldb.comvuldb.com/submit/786310
vuldb.comvuldb.com/vuln/355488
vuldb.comvuldb.com/vuln/355488/cti

Frequently asked

questions

Yes. Because the login endpoint is typically exposed to end users, an attacker can exploit the vulnerability remotely by sending crafted requests to /Login/checklogin.php.

No prior authentication is generally required. The vulnerability resides in the login handling itself, so unauthenticated attackers can attempt SQL injection via the email and password parameters.

The most reliable fix is to refactor database interactions to use prepared statements or parameterized queries everywhere, ensuring that user input is always passed as data, never as executable query text. Coupling this with least-privilege database accounts further limits potential damage.

Adopt a standard data access layer that enforces parameterization, enforce secure coding guidelines through code review and automated checks, validate and constrain all user inputs, and include regular security testing (static, dynamic, and manual review) as part of the development lifecycle.

Find out what's already
exploitable in your codebase.