Severity:

HIGH RISK

(7.3)

SQL Injection in Electronic Judging System Admin Login

CVE-2026-9383

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

The Electronic Judging System 1.0 contains a SQL injection vulnerability in the admin login endpoint, where the Username parameter is embedded into database queries without proper safeguards.

An attacker can remotely manipulate this parameter to interfere with SQL query logic, potentially bypassing authentication and accessing or modifying sensitive data on the backend database.

Affected context

The vulnerability occurs in the admin login functionality at /intrams/admin/login.php, where user-supplied credentials are processed to authenticate administrators.

It manifests when the application builds SQL queries directly from the Username input without consistently applying parameterization or robust input handling.

Any deployment exposing this login page over a network, particularly to untrusted clients (e.g., the public internet), may be at risk if no compensating database or application-layer controls are in place.

Exploit preconditions

  • Attack surface: HTTP(S) request to /intrams/admin/login.php
  • Required access: Network access to the admin login page (no prior authentication required)
  • Trigger point: Submission of a crafted Username value through the login form or direct HTTP request
  • Why exploitation is possible: The server-side login code appears to interpolate the Username value into a SQL query string, allowing attackers to alter the query's structure rather than being constrained to data-only input

Why this happens

This issue stems from constructing SQL statements by concatenating raw user input with query strings, instead of using parameterized queries or prepared statements.

That behavior maps directly to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), where special characters (quotes, comment markers, operators) are not safely handled.

The presence of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component reflects the broader pattern of passing untrusted data into downstream interpreters—in this case, the database engine—as part of executable commands.

Potential impact

  • An attacker may bypass admin authentication and gain unauthorized access to administrative functions.
  • Attackers could read or enumerate sensitive records stored in the database.
  • Malicious actors may modify, insert, or delete application data, impacting integrity and availability.
  • Under certain configurations, SQL injection could be chained into filesystem access, privilege escalation within the DBMS, or further compromise of the hosting environment.

General mitigation guidance

Mitigation focuses on treating all credential fields as untrusted input and preventing them from altering query structure:

  • Use parameterized queries or prepared statements for all database interactions, especially in authentication flows.
  • Apply strict input validation and canonicalization for username fields, limiting characters to well-defined, expected sets where business requirements allow.
  • Centralize database-access patterns in a data access layer that enforces parameterization by default, reducing the chance of ad-hoc string-built queries.
  • Configure database accounts with least privilege so that even if a query is abused, the attacker's ability to read or modify data is minimized.
  • Consider employing application-level controls such as generic error messages and login attempt throttling; while not fixing injection, they can reduce information leakage and automated attack efficiency.

How teams detect issues like this

Effective detection typically combines code-level and runtime approaches:

  • Perform static code analysis to flag dynamic SQL construction patterns (string concatenation or interpolation) involving request parameters, particularly around login and authentication logic.
  • During code review, look for direct use of $_GET, $_POST, or similar request variables in SQL query strings and absence of prepared statements or binding APIs.
  • Implement security tests (including automated DAST) that probe login endpoints with benign SQL meta-characters to identify unexpected behavior or errors.
  • Use database and application logging to monitor for anomalous query patterns, such as unexpected operators, comment delimiters, or consistently failing login queries with suspicious payloads.

Sources

SourceLink
github.comgithub.com/nidieaaa/test/issues/11
itsourcecode.comitsourcecode.com/
vuldb.comvuldb.com/submit/813427
vuldb.comvuldb.com/vuln/365346
vuldb.comvuldb.com/vuln/365346/cti

Frequently asked

questions

Yes. Any attacker who can reach the /intrams/admin/login.php endpoint over the network can attempt to exploit the SQL injection through the Username parameter.

No prior authentication is required. The issue resides in the login process itself, so an unauthenticated user can supply crafted input.

Refactor the login code to use parameterized queries or prepared statements for all database access, ensuring that user-supplied values are bound as data and cannot change the SQL structure.

Adopt a consistent data access layer that enforces parameterization, apply strict input validation, integrate static and dynamic security testing into the development pipeline, and require security-focused code reviews for all authentication and database-related changes.

Find out what's already
exploitable in your codebase.