/

CVE-2026-41075

Severity:

HIGH RISK

(8.8)

SQL Injection in RT Issue and Ticket Tracking System

CVE-2026-41075

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Unauthorized Data Access and Manipulation via SQL Injection

Severity:

HIGH RISK

(8.8)

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

RT issue and ticket tracking deployments from 5.0.0–5.0.9 and 6.0.0–6.0.2 contain an SQL injection vulnerability that allows crafted user input to be embedded into database queries without proper validation.

An authenticated user who can reach the vulnerable functionality may be able to read or modify data in the RT database by manipulating these queries.

Affected context

This vulnerability affects RT instances where authenticated users can submit data that is later interpolated into SQL queries without robust parameterization or filtering.

It is most relevant in workflows that accept flexible, user-controlled input (such as search parameters, filters, or dynamic query options) and relay it to the database layer.

The issue arises in application code paths that construct SQL statements using user-provided values, allowing them to influence the structure of the query beyond simple data binding.

Exploit preconditions

  • Attack surface: Web-based RT interface accessible to authenticated users.
  • Required access: A valid RT account with permission to access the affected feature or form where input flows into SQL queries.
  • Trigger point: Submission of specially crafted input through normal application actions (e.g., forms, filters, or query fields) that is later embedded into SQL without safe parameterization.
  • Why exploitation is possible: The application concatenates or otherwise directly embeds user input into SQL statements without consistently using prepared statements, parameter binding, or rigorous server-side validation, enabling attackers to alter query structure.

Why this happens

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

RT constructs SQL queries using values derived from user input in a way that allows those values to influence the query syntax itself.

Instead of confining user data to parameters in prepared statements, the code path in question permits untrusted values to be merged into the SQL string, making it possible for an attacker to inject additional clauses or operations.

This pattern reflects a broader class of injection flaws where the application fails to clearly separate code (the query) from data (user input), trusting client-provided content in a context where meta-characters and control tokens have special meaning.

Potential impact

  • Authenticated users may be able to read database records they are not authorized to access.
  • Attackers could modify or delete RT tickets or related metadata within their database permissions.
  • Compromised queries can reveal sensitive configuration or user data stored in RT.
  • SQL injection could be chained with other weaknesses to escalate privileges within the application's data model.
  • In some environments, injected queries might impact database integrity, leading to corruption or inconsistent ticket data.

General mitigation guidance

Effective mitigation typically centers on removing the injection primitive by enforcing strict separation between SQL code and user input.

Recommended defensive patterns include:

  • Using parameterized queries and prepared statements for all database interactions that involve user-supplied values.
  • Avoiding dynamic SQL string construction; where dynamic behavior is needed, limit allowed tokens to a known safe whitelist (e.g., enumerated column names or operators).
  • Applying robust server-side validation and normalization to user inputs, ensuring only expected formats and values pass through to the query layer.
  • Implementing least-privilege principles at the database level so application accounts cannot perform unnecessary operations even if a query is manipulated.
  • Introducing centralized query-building utilities or ORM patterns that enforce safe defaults and reduce direct string concatenation.

How teams detect issues like this

Detection efforts can focus on both code and runtime behavior:

  • Static analysis: Configure rules to flag string concatenation or interpolation involving SQL keywords and user-controlled variables; emphasize areas where queries are built manually instead of using parameterized APIs.
  • Code review: During peer review, pay special attention to search or reporting features that assemble dynamic queries; look for any bypass of shared database abstraction layers that normally enforce parameterization.
  • Logging and monitoring: Analyze database logs for anomalous query patterns such as unexpected operators, stacked statements (if supported), or irregular filtering expressions originating from user-driven workflows.
  • Security testing: Include automated and manual injection tests in QA pipelines, focusing on form fields and advanced search inputs; neutral, third-party tools can help identify residual SQL injection patterns.

Sources

SourceLink
github.comgithub.com/bestpractical/rt/releases/tag/rt-5.0.10
github.comgithub.com/bestpractical/rt/releases/tag/rt-6.0.3
github.comgithub.com/bestpractical/rt/security/advisories/GHSA-7vf8-xv7w-97c6

Frequently asked

questions

Exploitation is limited to authenticated users who can access the affected RT features, but within that scope it may significantly expand what data they can read or alter in the RT database.

No, administrative access is not strictly required; a non-admin user with access to the vulnerable input path may exploit the issue, though the impact is constrained by their existing data access and the database account privileges.

The most reliable fix is to refactor all affected queries to use parameterized statements or an ORM that enforces binding, eliminating direct concatenation of user input into SQL and constraining dynamic elements to validated, whitelisted values.

Establish coding standards that mandate prepared statements, centralize query construction through vetted helpers, integrate security-focused static analysis into CI, and include injection-specific checks in design and code reviews for any feature that builds dynamic queries.

Find out what's already
exploitable in your codebase.