/

CVE-2026-10249

Severity:

HIGH RISK

(7.3)

SQL Injection in Online Blood Bank Management System

CVE-2026-10249

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Data Access and Manipulation 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 Blood Bank Management System 1.0 contains a SQL injection vulnerability in the /admin/viewrequest.php endpoint, where the ID parameter is used unsafely in database queries.

A remote attacker can manipulate this parameter to interfere with SQL queries, potentially accessing, modifying, or deleting blood bank request data without authorization.

Affected context

The issue occurs within the administrative interface of the Online Blood Bank Management System, specifically in the /admin/viewrequest.php functionality that looks up blood request records by an ID parameter.

The vulnerability manifests when user-controlled input is passed to backend SQL queries without proper validation, escaping, or use of parameterized statements.

It is most relevant in deployments where the admin interface is network-accessible and database accounts have broad privileges on the application's schema.

Exploit preconditions

  • Attack surface: HTTP(S) requests to the /admin/viewrequest.php endpoint.
  • Required access: Ability to send requests to the administrative URL; depending on deployment, this may or may not be gated by authentication.
  • Input vector: The ID parameter in the request, which is processed by server-side code to construct a SQL query.
  • Trigger point: Execution of dynamically built SQL statements that incorporate the ID value directly.
  • Why exploitation is possible: The application concatenates raw input into SQL queries without using parameterized statements or robust input handling, allowing crafted values to alter query structure.

Why this happens

This vulnerability stems from insecure construction of SQL queries in the /admin/viewrequest.php script.

Instead of treating the ID parameter as data, the code appears to embed it directly into the SQL string, aligning with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection').

In addition, lack of rigorous server-side validation and context-aware encoding (CWE-74) means special characters and SQL control tokens are not neutralized, enabling attackers to inject or extend SQL commands.

Abstractly, the bug pattern is: user-controlled input → directly concatenated into SQL → executed by the database with elevated privileges.

Potential impact

  • Unauthorized reading of sensitive information stored in the database, including donor and patient request details.
  • Modification or deletion of blood request records, potentially impacting operational integrity.
  • Extraction of authentication-related data (e.g., admin credentials hashes) if stored in the same database.
  • Escalation to full application compromise if SQL injection is leveraged to write data, change configuration, or abuse database-specific features.
  • Potential pivot to the underlying host or other systems if the database engine and environment expose dangerous capabilities.

General mitigation guidance

Effective mitigation focuses on removing the ability for user input to change SQL structure and on limiting blast radius if input is mishandled:

  • Refactor database access code to rely on parameterized queries or prepared statements for all user-supplied values, including the ID parameter.
  • Apply strict server-side validation for identifiers, ensuring they conform to expected formats (e.g., integers or fixed patterns) before use.
  • Employ least-privilege principles for database accounts so that the web application can access only the minimal tables and operations required.
  • Centralize and standardize database access patterns (e.g., through a data access layer) to enforce safe querying practices by default.
  • Avoid building SQL fragments dynamically based on raw request parameters; where dynamic behavior is needed, constrain it to predefined, whitelisted values.

How teams detect issues like this

Organizations can identify this type of vulnerability using several complementary approaches:

  • Static analysis rules designed to flag string concatenation or interpolation in SQL query construction, especially where request parameters are involved.
  • Targeted code review of the admin modules, focusing on any direct use of $_GET/$_POST variables or their framework equivalents in database calls.
  • Web application firewalls (WAFs) or API gateways configured with SQL injection detection patterns, monitoring for anomalous characters or query structures in the ID parameter.
  • Continuous integration checks that run security linters or SAST tools on PHP or backend code to detect insecure query patterns before deployment.
  • Periodic dynamic application security testing (DAST) and penetration testing to probe endpoints like /admin/viewrequest.php for injection behavior.

Sources

SourceLink
github.comgithub.com/zhengdexu-bot/zhengdexu/issues/1
itsourcecode.comitsourcecode.com/
vuldb.comvuldb.com/cve/CVE-2026-10249
vuldb.comvuldb.com/submit/824023
vuldb.comvuldb.com/vuln/367527
vuldb.comvuldb.com/vuln/367527/cti

Frequently asked

questions

Yes. The vulnerable endpoint can be targeted over the network by sending crafted HTTP requests that manipulate the ID parameter, assuming the admin interface is reachable.

The description does not clarify authentication requirements. In some deployments, the admin path may be accessible only after login; in others, it may be exposed or weakly protected. Exploitation feasibility depends on how access control is configured.

The most robust fix is to replace all dynamically constructed SQL that incorporates the ID parameter with parameterized queries or prepared statements, combined with strict validation that enforces expected formats (such as numeric IDs). This eliminates the ability of input to alter query structure.

Establish development standards that mandate parameterized queries for all database access, implement centralized data access utilities that are safe by default, and integrate automated security checks (SAST/DAST) into the development pipeline to catch unsafe patterns before release.

Find out what's already
exploitable in your codebase.