/

CVE-2026-10263

Severity:

HIGH RISK

(7.3)

SQL Injection in SourceCodester Computer Repair Shop

CVE-2026-10263

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

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

A SQL injection vulnerability in the /admin/products/manage_product.php endpoint of SourceCodester Computer Repair Shop Management System allows manipulation of the ID parameter to alter backend database queries.

When exploited over the network, this flaw can let an attacker access, modify, or delete application data, and potentially pivot to broader system compromise depending on database privileges.

Affected context

This vulnerability appears in the administrative product management functionality of the Computer Repair Shop Management System, specifically within /admin/products/manage_product.php.

It manifests when the ID parameter is incorporated directly into SQL statements without adequate validation, sanitization, or parameterization.

The issue is most relevant in deployments where the admin interface is exposed to untrusted networks or where an attacker can reach the affected endpoint, including scenarios with weak or shared administrative credentials.

Exploit preconditions

  • Attack surface: HTTP(S) requests to the web application, targeting /admin/products/manage_product.php.
  • Required access: Ability to send crafted requests to the admin product management endpoint; depending on configuration, this may require valid admin or elevated credentials, or may be reachable if access controls are misconfigured.
  • Trigger point: The ID parameter is processed by backend PHP code and embedded into a SQL query during product management operations.
  • Why exploitation is possible: User-controlled data from the ID argument is concatenated into SQL statements without using parameterized queries, input validation, or context-aware escaping, enabling attackers to inject additional SQL fragments.

Why this happens

The core issue is the construction of SQL queries using untrusted input from the ID parameter without proper parameterization or sanitization.

This aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), where application code directly embeds user input into SQL query strings.

The presence of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component reflects that the database acts as a downstream interpreter of improperly neutralized data.

Instead of binding values through prepared statements, the application likely concatenates strings, allowing injected control characters and SQL syntax to alter the intended query structure.

Potential impact

  • Unauthorized reading of sensitive data stored in the application database (customers, inventory, pricing, or repair records).
  • Modification or deletion of database records, potentially corrupting business-critical information.
  • Creation of new administrative or application users within the database context, depending on schema design.
  • Execution of stacked queries (if enabled) that can change database configuration or enable further attacks.
  • Potential pivot to remote code execution on the server if the database and environment are misconfigured or additional weaknesses exist.

General mitigation guidance

Effective mitigation focuses on eliminating direct concatenation of user input into SQL statements and strengthening input handling:

  • Use parameterized queries (prepared statements) consistently for all database interactions, especially where identifiers like ID are involved.
  • Apply strict server-side validation and type enforcement for the ID parameter (e.g., ensuring it is a numeric identifier within expected bounds).
  • Centralize query building logic to enforce safe-by-default patterns and reduce the risk of ad hoc string concatenation.
  • Minimize database privileges for the application account so that even if a query is manipulated, its capabilities are limited to essential operations.
  • Implement defense-in-depth controls such as application-level access controls, segmentation of admin interfaces, and generic error messages that do not leak query details.

How teams detect issues like this

Detection typically combines code-centric and runtime monitoring approaches:

  • Static analysis: Scan PHP code for dynamic SQL query construction involving $_GET, $_POST, or other user input variables, particularly where the ID parameter is concatenated into query strings without prepared statements.
  • Code review signals: Look for raw SQL strings built with string interpolation or concatenation, missing parameter binding, and lack of validation around ID-based lookups in admin modules.
  • Automated tooling: Use SAST tools that flag CWE-89 and CWE-74 patterns, and enforce rules in CI pipelines to prevent introduction of new injection sinks.
  • Runtime monitoring: Enable database query logging and WAF or RASP solutions that can detect anomalous query patterns, such as unexpected operators, comments, or stacked statements in the ID parameter.

Sources

SourceLink
github.comgithub.com/gxcyyjy/CVE/issues/4
vuldb.comvuldb.com/cve/CVE-2026-10263
vuldb.comvuldb.com/submit/824919
vuldb.comvuldb.com/vuln/367543
vuldb.comvuldb.com/vuln/367543/cti
sourcecodester.comsourcecodester.com/

Frequently asked

questions

Yes. An attacker who can reach the /admin/products/manage_product.php endpoint over the network can exploit the SQL injection by sending crafted HTTP requests, subject to any access controls in place.

In many deployments, the vulnerable functionality resides under an admin path, so valid credentials or an access control bypass may be required. However, if the admin interface is misconfigured, exposed publicly, or protected by weak credentials, practical exploitation becomes easier.

The most robust pattern is to replace all dynamic SQL string concatenation with parameterized queries (prepared statements) and enforce strict type and range validation on all externally supplied parameters, including ID.

Establish secure coding standards that mandate use of prepared statements for all database operations, integrate static analysis into the development pipeline to flag potential injection sinks, and conduct regular security-focused code reviews of data access layers and admin functionality.

Find out what's already
exploitable in your codebase.