/

CVE-2026-49490

Severity:

HIGH RISK

(8.1)

SQL Injection in OpenCATS DataGrid Filter Handling

CVE-2026-49490

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Arbitrary SQL Query Execution Against Application Database

Severity:

HIGH RISK

(8.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

OpenCATS 0.9.1a and later contains an SQL injection vulnerability in the DataGrid filter logic for the Candidates view, specifically when filters are applied to the non-filterable Tags column.

An authenticated attacker who can submit crafted filter parameters may inject arbitrary SQL into the underlying query, allowing manipulation or disclosure of database data.

Affected context

This vulnerability occurs in OpenCATS installations that expose the Candidates DataGrid with filter functionality enabled.

The issue is tied to server-side processing of filter criteria, where the Tags column is marked as non-filterable in the UI but can still be targeted by crafted filter requests.

It becomes relevant in environments where authenticated users (such as recruiters or administrators) can interact with DataGrid filters over a web interface backed by a relational database.

Exploit preconditions

  • Attack surface: Web application interface handling DataGrid filter requests
  • Required access: Authenticated access with permission to view and filter the Candidates DataGrid
  • Trigger point: Submission of specially crafted filter parameters that reference the non-filterable Tags column
  • Why exploitation is possible: The server-side filter handling does not consistently enforce column filterability or safely parameterize filter input, allowing attacker-controlled values to be embedded directly into SQL queries

Why this happens

The root cause lies in how the DataGrid filter handling code constructs SQL queries from user-supplied filter criteria.

Even though the Tags column is marked as non-filterable, the backend still processes filter parameters that reference it, and fails to ensure those values are bound via safe parameterization or restricted to allowed columns.

This maps to CWE-89: Improper Neutralization of Special Elements used in an SQL Command (SQL Injection), where untrusted input is concatenated or interpolated into SQL statements without proper validation or escaping, enabling attackers to alter the query structure.

Potential impact

  • Disclosure of sensitive candidate, user, or configuration data from the database
  • Modification or deletion of database records, potentially impacting integrity of recruiting data
  • Creation of new accounts or escalation of privileges within the application if the database is used for access control
  • Potential pivot to underlying infrastructure if database-level features or stored procedures can be abused

General mitigation guidance

Addressing this issue typically involves tightening how filter inputs are translated into SQL and enforcing strict separation between user data and query structure.

Common patterns include:

  • Using parameterized queries or prepared statements for all filter conditions, ensuring user input cannot alter SQL syntax
  • Implementing a strict server-side whitelist of filterable columns and rejecting or ignoring filters targeting non-approved fields like Tags
  • Normalizing filter handling into a query builder or ORM layer that encodes conditions safely rather than building SQL strings directly
  • Applying least-privilege database accounts so that even if a query is compromised, available operations are constrained

These changes reduce the risk of injection even if an attacker can manipulate filter parameters.

How teams detect issues like this

Organizations can detect similar vulnerabilities through a mix of automated and manual techniques:

  • Static analysis rules that flag dynamic SQL construction using user-controlled filter parameters or unsafe string concatenation
  • Code review checklists that focus on DataGrid or search/filter logic, ensuring all query-building paths use parameterization and column whitelisting
  • Centralized query-building components where security controls (such as column allowlists and parameter binding) are enforced by design
  • Runtime monitoring and logging to detect anomalous filter requests, unusual SQL patterns, or errors indicative of injection attempts

Security-focused linters and application security testing tools can complement manual review by highlighting risky SQL usage patterns.

Sources

SourceLink
github.comgithub.com/opencats/OpenCATS/security/advisories/GHSA-gmpc-j6h7-vw74
vulncheck.comvulncheck.com/advisories/opencats-sql-injection-in-datagrid-filter-handling-for-tags-column

Frequently asked

questions

Yes, it can be exploited remotely through the web interface, but only by users who can authenticate and access the Candidates DataGrid filters.

The attacker needs valid credentials and sufficient permissions to view and filter the Candidates DataGrid; anonymous users cannot typically exploit this path.

The most robust pattern is to enforce strict parameterized queries for all filters and to implement a backend whitelist of allowed filterable columns, ignoring or rejecting any filters that fall outside this list.

Design filtering and search features around safe query builders or ORM abstractions, require parameterization for all user-driven conditions, and include SQL injection checks in code review and automated testing pipelines.

Find out what's already
exploitable in your codebase.