/

CVE-2026-14756

Severity:

HIGH RISK

(7.3)

SQL Injection (CWE-89) in Tour Management Admin Page

CVE-2026-14756

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-74, CWE-89

Impact:

Data Exposure and Integrity Compromise

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 flaw in the Tour Management admin page of the Hotel and Tourism Reservation system allows crafted input in the delete_image parameter to be embedded directly into database queries.

When this parameter is not properly sanitized, a remote attacker can manipulate SQL statements, potentially accessing or altering reservation and tour data via the affected admin endpoint.

Affected context

The vulnerability appears in the administrative Tour Management page (/admin/add_tour.php) of the Hotel and Tourism Reservation application.

It manifests when the delete_image argument is taken from HTTP requests and incorporated into SQL queries without sufficient validation or escaping.

This typically affects deployments where the admin interface is reachable over the network and where database accounts used by the application hold broad privileges over reservation or customer tables.

Exploit preconditions

  • Attack surface: HTTP requests targeting /admin/add_tour.php within the Tour Management section.
  • Required access: Ability to send requests to the admin endpoint; in some deployments this may require valid admin session, while misconfigurations can expose it more broadly.
  • Trigger point: Submission of a specially crafted delete_image parameter value causing the backend to generate unsafe SQL.
  • Why exploitation is possible: User-controlled input is concatenated or interpolated directly into SQL statements without robust parameterization, escaping, or context-aware filtering, allowing attackers to alter query structure.

Why this happens

The core issue aligns with CWE-89: Improper Neutralization of Special Elements used in an SQL Command (SQL Injection).

Application code in /admin/add_tour.php likely builds SQL queries using dynamic string construction, trusting the delete_image parameter without neutralizing metacharacters such as quotes, comment markers, or operators.

Because SQL syntax is controlled by user input, the database interprets injected fragments as part of the command, not as data.

The presence of CWE-74: Improper Neutralization of Special Elements in Output Used by a Downstream Component reflects that user-supplied data is being forwarded to the database (a downstream component) without proper context-aware sanitization.

Potential impact

  • Attackers may read reservation, customer, and tour records they should not access.
  • Database contents could be modified, including changing tour details or reservation status.
  • Records can be deleted, leading to data loss and operational disruption.
  • Additional SQL injection exploitation could enable creation of new admin accounts or alteration of authentication data.
  • Depending on database configuration, the vulnerability may enable access to other schemas or system tables.

General mitigation guidance

Effective mitigation focuses on removing direct string-based query construction and reducing trust in all user-supplied parameters.

Recommended patterns include:

  • Using parameterized queries or prepared statements for all database access, ensuring user input is always treated as data.
  • Applying strict server-side validation on inputs like delete_image, constraining values to expected formats (e.g., numeric IDs or whitelisted tokens).
  • Centralizing query-building logic and prohibiting ad-hoc concatenation of request parameters into SQL strings.
  • Assigning least-privilege roles to the application's database user so that even if injection occurs, accessible operations are limited.
  • Implementing secure coding guidelines and linters that flag raw SQL concatenation in the codebase.

How teams detect issues like this

Detection commonly involves a combination of code-centric and runtime techniques:

  • Static analysis rules that flag SQL queries built via string concatenation or interpolation with request parameters like $_GET/$_POST.
  • Code reviews focused on database access layers, where reviewers search for unparameterized queries and missing input validation.
  • Security testing and dynamic analysis (e.g., web application scanning) looking for error messages, anomalous responses, or behavior when special SQL characters are injected into the delete_image parameter.
  • Policy enforcement in CI/CD pipelines requiring use of prepared statements frameworks and rejecting changes that introduce raw query construction.
  • Logging and monitoring for suspicious query patterns, such as unexpected use of UNION, OR 1=1, or comment sequences originating from web inputs.

Sources

SourceLink
code-projects.orgcode-projects.org/
raw.githubusercontent.comraw.githubusercontent.com/anubhavv106/Security-Advisories/refs/heads/main/Hotel-Tourism-Reservation-add_tour.php-SQLi.md
vuldb.comvuldb.com/cve/CVE-2026-14756
vuldb.comvuldb.com/submit/850366
vuldb.comvuldb.com/vuln/376345
vuldb.comvuldb.com/vuln/376345/cti

Frequently asked

questions

Exploitability depends on how exposed the /admin/add_tour.php endpoint is. If it is reachable over the internet and access controls are weak or misconfigured, remote attackers can reliably target it using publicly available exploit techniques.

At minimum, an attacker needs the ability to send crafted HTTP requests to the Tour Management admin page. Some deployments may require authentication to reach this endpoint, while others may inadvertently allow unauthenticated access due to configuration or routing issues.

The most robust fix is to refactor all affected queries to use parameterized statements and remove any reliance on string concatenation with user inputs. Pair this with strict input validation on delete_image and related parameters to ensure only expected, well-formed values reach the database layer.

Adopting secure coding practices for database interactions is key: always use prepared statements, enforce validation at the server, and ban ad-hoc SQL construction in project guidelines. Complement this with automated static analysis, regular security reviews of data access code, and least-privilege configurations for database accounts to reduce the impact of any future flaws.

Find out what's already
exploitable in your codebase.