Severity:

HIGH RISK

(7.3)

SQL Injection in Vehicle Showroom Management System

CVE-2026-6149

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Unauthorized Data Access and Manipulation

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

Vehicle Showroom Management System 1.0 contains a SQL injection vulnerability in /util/BookVehicleFunction.php, where the BRANCH_ID parameter is incorporated into database queries without sufficient sanitization.

A remote attacker can manipulate this parameter to alter backend SQL queries, which may allow unauthorized data access, modification, or other database-driven abuse when the vulnerable endpoint is reachable.

Affected context

The vulnerability occurs in the booking-related functionality implemented in /util/BookVehicleFunction.php of Vehicle Showroom Management System 1.0.

It is relevant when:

  • The application exposes this PHP endpoint over a network (e.g., internet or internal LAN).
  • User-controlled input is accepted through the BRANCH_ID parameter (GET, POST, or similar).
  • The backend uses a relational database and concatenates BRANCH_ID directly into SQL queries without proper parameterization.

Environments where database accounts have broad privileges or where network access controls are weak are more exposed to risk.

Exploit preconditions

  • Attack surface: HTTP(S) interface of the Vehicle Showroom Management System, specifically the route invoking /util/BookVehicleFunction.php.
  • Required access: Network-level access to the web application; no special authentication may be required if the vulnerable functionality is publicly exposed.
  • Trigger point: Submission of crafted data in the BRANCH_ID parameter that is later embedded into SQL statements.
  • Why exploitation is possible: The application dynamically builds SQL queries with untrusted BRANCH_ID data, failing to use prepared statements or robust input handling, which allows attackers to inject arbitrary SQL fragments.

Why this happens

This issue stems from constructing SQL statements by concatenating raw user input from the BRANCH_ID parameter into query strings.

Such patterns align with CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), where meta-characters like quotes, comment markers, or operators are not sufficiently neutralized before being interpreted by the database.

The mention of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component reflects that untrusted data is passed downstream (from PHP to the database) without appropriate context-aware encoding or parameterization.

As a result, the database parses part of the user-supplied value as executable SQL rather than as data.

Potential impact

  • Access to sensitive customer or vehicle data that the attacker is not authorized to view.
  • Modification or deletion of booking records and related showroom data.
  • Creation of fraudulent entries that can affect business logic and reporting.
  • Enumeration of database structure (tables, columns, and schema) to support further attacks.
  • In some configurations, execution of database-level procedures that could affect system availability or integrity.

General mitigation guidance

Effective mitigation focuses on eliminating direct concatenation of user input into SQL queries and tightening trust boundaries around database access:

  • Use parameterized queries or prepared statements for all database interactions involving BRANCH_ID and similar inputs.
  • Apply strict server-side validation on identifiers, enforcing type constraints (e.g., numeric only) and rejecting unexpected formats.
  • Centralize data access logic so that query construction follows consistent, reviewed patterns rather than ad hoc string building.
  • Limit database account privileges to only the operations required by the application, reducing the blast radius of a successful injection.
  • Consider implementing a data access abstraction layer that enforces safe query construction by default.

How teams detect issues like this

Organizations can identify this class of vulnerability using a combination of static and dynamic approaches:

  • Static analysis rules that flag string-built SQL queries, especially where variables such as $_GET, $_POST, or other request parameters are concatenated into query strings.
  • Manual code reviews focusing on database access layers and PHP files like /util/BookVehicleFunction.php that process request parameters and interact with the database.
  • Security testing (including automated DAST tools) that sends crafted values in BRANCH_ID and monitors for error messages, anomalous responses, or data leakage patterns indicative of SQL injection.
  • CI/CD policy checks that prohibit use of deprecated or unsafe query APIs in favor of parameterized database libraries.

Sources

SourceLink
code-projects.orgcode-projects.org/
github.comgithub.com/mrpgi/cve/issues/4
vuldb.comvuldb.com/submit/796282
vuldb.comvuldb.com/vuln/357029
vuldb.comvuldb.com/vuln/357029/cti

Frequently asked

questions

Yes. As long as the vulnerable endpoint is network-accessible, an attacker can send crafted requests remotely to trigger SQL injection through the BRANCH_ID parameter.

It depends on how the application is deployed. If the booking functionality using /util/BookVehicleFunction.php is accessible without login, no authentication is required. If it is behind a login, the attacker would need valid credentials or another way to reach the endpoint.

The most robust pattern is to replace all string-concatenated SQL with parameterized queries or prepared statements, combined with strict server-side validation of BRANCH_ID and similar inputs.

Establish development standards that mandate parameterized database access, use input validation by default, and integrate security-focused code review and static analysis into the development lifecycle so unsafe query construction is detected early.

Find out what's already
exploitable in your codebase.