/

CVE-2026-48236

Severity:

HIGH RISK

(7.1)

SQL Injection in Open ISES Tickets db_loader.php

CVE-2026-48236

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Confidentiality, Integrity, and Availability compromise of the application database through SQL injection

Severity:

HIGH RISK

(7.1)

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

Open ISES Tickets before version 3.44.2 suffers from a SQL injection vulnerability where multiple POST parameters are directly concatenated into mysqli connection arguments and dynamic SQL statements without sanitization.

An authenticated attacker who can control these parameters can manipulate query semantics to read, modify, or destroy database contents in the connected ticketing database.

Affected context

This vulnerability occurs in Open ISES Tickets deployments using db_loader.php to establish database connections and run queries based on POST-supplied connection parameters.

It is relevant when the application:

  • Accepts ticketsdb, ticketshost, ticketsuser, and ticketspassword via HTTP POST
  • Concatenates these values into mysqli connection arguments and subsequent SQL queries
  • Does not enforce strict validation, parameterization, or allowlisting of connection and database identifiers

In such configurations, authenticated users who can reach db_loader.php form an attack surface for SQL injection.

Exploit preconditions

  • Attack surface: HTTP POST endpoint(s) reaching db_loader.php in Open ISES Tickets.
  • Required access: Authenticated access to the application with permission to submit forms or requests that populate ticketsdb, ticketshost, ticketsuser, and ticketspassword.
  • User-controlled inputs: The POST parameters ticketsdb, ticketshost, ticketsuser, and ticketspassword are taken as-is and used in mysqli initialization and dynamic SQL.
  • Trigger point: Execution of PHP code in db_loader.php that builds connection strings and queries through string concatenation using the supplied POST values.
  • Why exploitation is possible: The application treats attacker-controlled POST parameters as trusted SQL and connection metadata, does not apply sufficient validation or parameterization, and therefore allows crafted input to alter SQL syntax and logic.

Why this happens

The underlying flaw is a classic CWE-89: Improper Neutralization of Special Elements used in an SQL Command (SQL Injection).

In db_loader.php, user-supplied POST parameters (ticketsdb, ticketshost, ticketsuser, ticketspassword) are directly embedded into mysqli connection arguments and dynamic SQL without proper neutralization or use of parameterized queries.

This pattern mixes data and code in a single SQL string, allowing an attacker to inject control characters and SQL operators that change the intended query structure.

Because the code trusts these values as configuration and does not enforce strict allowlists or safe construction APIs, the application's database layer executes attacker-influenced SQL.

Potential impact

  • An attacker may read sensitive information from the ticketing database, including user records, ticket contents, and configuration data.
  • An attacker may modify or corrupt ticket data, user accounts, or configuration tables.
  • An attacker may delete or truncate tables, leading to partial or total loss of ticketing data.
  • An attacker may create new administrative or backdoor data entries within the database to maintain persistence.
  • In some environments, an attacker could pivot to other connected databases or services if the same credentials and network access are reused.

General mitigation guidance

Effective mitigation centers on separating user data from SQL code and treating all externally influenced values as untrusted configuration:

  • Replace string-concatenated SQL with parameterized queries (prepared statements) for all variable components that can be interpreted as data.
  • Avoid constructing connection descriptors or database identifiers directly from request parameters; instead, use server-side configuration or strictly validated, allowlisted values.
  • Apply strict validation to any remaining dynamic elements:
  • Enforce allowlists for database names and hosts.
  • Reject inputs containing SQL metacharacters where they are not expected.
  • Centralize database access logic behind a minimal, well-reviewed API rather than building ad-hoc queries in multiple files.
  • Run the database with least-privilege accounts to limit the damage if injection occurs (e.g., no unnecessary DROP/ALTER permissions).

How teams detect issues like this

Detection strategies for this pattern typically include:

  • Static analysis:
  • Rules that flag SQL queries built via string concatenation in PHP, especially where $_POST or other superglobals influence the query string or connection parameters.
  • Patterns that detect direct interpolation of request parameters into mysqli or PDO functions without prepared statements.
  • Code review:
  • Manually inspect db_loader.php and other database bootstrap files for any use of external inputs in connection arguments and SQL text.
  • Review for the absence of parameter binding and reliance on raw string concatenation.
  • Security testing:
  • Targeted dynamic testing (DAST) submitting crafted values in ticketsdb, ticketshost, ticketsuser, and ticketspassword to observe abnormal database behavior or error messages.
  • Policy enforcement:
  • Enforce coding guidelines that mandate parameterized queries and forbid using request parameters to select arbitrary database endpoints.
  • Integrate automated tools in CI that flag new instances of non-parameterized SQL that involve user input.

Sources

SourceLink
github.comgithub.com/openises/tickets/commit/ecfeb406a016766cae81c749e14b5145a9f2dbff
github.comgithub.com/openises/tickets/releases/tag/v3.44.2
vulncheck.comvulncheck.com/advisories/open-ises-tickets-sql-injection-via-db-loader-php-multiple-parameters

Frequently asked

questions

Yes, if the Open ISES Tickets instance is exposed over the network and authenticated users can access the functionality that posts to db_loader.php. Exploitation does not require local access to the server but does require valid application credentials and reachability of the affected endpoint.

The description indicates that authenticated attackers are sufficient. Whether additional permissions are needed depends on how the application gates access to the functionality that uses ticketsdb, ticketshost, ticketsuser, and ticketspassword. Any role allowed to submit those POST parameters is potentially able to exploit the issue.

The safest pattern is to eliminate dynamic SQL built from request parameters, move database connection details to server-side configuration, and use parameterized queries everywhere user-supplied or runtime data touches SQL. Where dynamic elements are unavoidable, constrain them to strictly validated, allowlisted values rather than free-form input.

Adopt a defensive development standard that requires prepared statements, bans direct concatenation of request data into SQL or connection strings, and treats configuration coming from HTTP requests as untrusted. Combine this with regular secure code reviews, automated static analysis rules for SQL construction, and principle of least privilege for database accounts so that any remaining defects have reduced impact.

Find out what's already
exploitable in your codebase.