/

CVE-2026-48232

Severity:

HIGH RISK

(7.1)

SQL Injection in Open ISES Tickets

CVE-2026-48232

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Unauthorized Database Access and Manipulation

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 3.44.2 contains a SQL injection vulnerability where the offset GET parameter in ajax/fullsit_incidents.php is concatenated directly into the LIMIT clause of a SELECT query.

An authenticated attacker who can control this parameter may alter query semantics to read, modify, or destroy database data by injecting crafted SQL fragments.

Affected context

The vulnerability appears in the PHP-based AJAX endpoint ajax/fullsit_incidents.php within Open ISES Tickets, specifically in code paths that construct paginated SQL queries using a LIMIT clause.

It manifests when the offset value from a GET request is used directly in the SQL statement without sanitization or parameterization.

The issue is relevant in deployments where authenticated users can reach this endpoint and pagination inputs are not centrally validated or constrained.

Exploit preconditions

  • Attack surface: HTTP(S) requests to the Open ISES Tickets web interface, targeting the ajax/fullsit_incidents.php endpoint.
  • Required access: Authenticated access with the ability to invoke the AJAX endpoint and control the offset GET parameter.
  • Trigger point: Server-side construction of a SQL SELECT statement that includes a LIMIT clause using the attacker-supplied offset value.
  • Why exploitation is possible: The offset parameter is directly concatenated into the SQL query string without using prepared statements or proper validation, enabling crafted input to break out of the intended numeric context and inject arbitrary SQL.

Why this happens

This vulnerability stems from dynamically building SQL queries by concatenating user-controlled input into the query text, a classic example of CWE-89: SQL Injection.

The application assumes the offset parameter will be a benign integer, but it does not enforce this assumption through strict input validation, type casting, or parameterized queries.

As a result, malicious input can alter the structure of the LIMIT clause and, depending on the database engine's parsing behavior, may affect the broader query, allowing attackers to manipulate the executed SQL beyond the developer's intent.

Potential impact

  • Unauthorized reading of database records that the current user should not normally access.
  • Modification of existing records, including incident tickets or related data.
  • Deletion or destruction of database rows, impacting data integrity and availability.
  • Possible escalation of privileges by tampering with user or role tables, if reachable via injected SQL.
  • Discovery of database schema details (tables, columns) that can facilitate further attacks.

General mitigation guidance

Effective mitigation focuses on eliminating direct string concatenation of user input in SQL and reducing trust in request parameters:

  • Use parameterized queries or prepared statements for all SQL operations, including LIMIT and pagination-related clauses where the database/driver supports bound numeric parameters.
  • Apply strict server-side validation and type enforcement for pagination parameters: treat them as integers, enforce ranges, and reject or normalize unexpected values.
  • Centralize input handling for query-building logic so that pagination, sorting, and filtering parameters are consistently validated and sanitized.
  • Employ least-privilege credentials for the application's database user so that even if a query is compromised, it cannot perform high-impact operations like dropping tables or altering schema.
  • Consider defensive database features such as read-only roles for endpoints that should not modify data.

How teams detect issues like this

Detection typically combines code-level inspection with runtime monitoring:

  • Static analysis rules targeting SQL construction patterns that concatenate $_GET, $_POST, or other request variables directly into query strings, especially around LIMIT, ORDER BY, and WHERE clauses.
  • Manual code review of AJAX endpoints and pagination logic, looking for missing prepared statements, inadequate validation, and repeated patterns of dynamic SQL assembly.
  • Application-level logging and monitoring for anomalous offset values (non-numeric inputs, special characters, or unusually large numbers) and for database errors indicating malformed queries.
  • Integration of automated security testing tools (SAST/DAST) into CI/CD pipelines to flag potential injection points early in development.

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-ajax-fullsit-incidents-php-offset-parameter

Frequently asked

questions

Yes. It can be exploited remotely via HTTP(S) requests, but only by users who are authenticated and can reach the vulnerable AJAX endpoint.

The attacker must have valid credentials for Open ISES Tickets with permissions sufficient to trigger ajax/fullsit_incidents.php and supply the offset GET parameter. No direct database access is required.

Replace dynamic SQL string concatenation with parameterized queries or prepared statements for all query components and enforce strict numeric validation and type casting on the offset parameter before it reaches the database layer.

Adopt a secure data access layer that standardizes parameterized queries, implement centralized input validation for all request parameters used in SQL, and include regular security-focused code reviews and automated scanning for injection patterns across the codebase.

Find out what's already
exploitable in your codebase.