/

CVE-2026-21856

Severity:

HIGH RISK

(7.2)

SQL Injection in Tarkov Data Manager Webhook and Scanner

CVE-2026-21856

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Arbitrary SQL Query Execution Against Backend Database

Severity:

HIGH RISK

(7.2)

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 time-based blind SQL injection flaw in Tarkov Data Manager's webhook edit and scanner API endpoints allows crafted input to alter database queries at runtime.

When exploited by an authenticated attacker, this issue can enable arbitrary SQL execution against the MySQL backend, exposing or manipulating stored application data under certain conditions.

Affected context

This vulnerability occurs in Tarkov Data Manager deployments where:

  • The webhook edit and scanner API endpoints are exposed to authenticated users
  • User-controlled parameters are interpolated into SQL queries that target a MySQL database
  • Database access is performed with highly-privileged credentials (e.g., full read/write on the application schema)

The risk is more pronounced in environments where many users share access or where API tokens/credentials may be exposed or reused across systems.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoints for webhook editing and scanner operations.
  • Required access: Valid authenticated access to Tarkov Data Manager with permission to invoke the affected endpoints.
  • Trigger point: Submission of specially crafted parameter values in webhook edit or scanner API requests.
  • Why exploitation is possible: The server-side logic constructs SQL statements using unvalidated, unescaped user input, enabling attackers to inject time-based conditions to infer query results and execute arbitrary SQL over multiple requests.

Why this happens

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

The application dynamically builds SQL statements by concatenating or interpolating user-supplied input from webhook and scanner API parameters directly into query strings.

Without using parameterized queries or robust input neutralization, the database interprets attacker-supplied tokens as part of the SQL language rather than data, enabling time-based blind probing of database state and arbitrary query execution.

Potential impact

  • Attackers may enumerate and exfiltrate sensitive data stored in the MySQL database (e.g., configuration, item metadata, user-related information).
  • Database contents can be modified, including inserting, updating, or deleting records.
  • Application integrity can be undermined by corrupting item data or configuration values.
  • Depending on database permissions and environment configuration, the attacker could pivot to more severe impacts, such as executing dangerous MySQL functions or impacting other applications that share the same database instance.

General mitigation guidance

Effective mitigation focuses on eliminating direct interpolation of user-controlled data into SQL queries and limiting the blast radius of any single query:

  • Prefer parameterized queries / prepared statements for all database access paths, ensuring user input is always treated as data rather than query logic.
  • Introduce strict server-side validation and normalization for all fields accepted by the webhook and scanner APIs, enforcing expected types, ranges, and formats.
  • Centralize database access through a well-audited data access layer, avoiding ad-hoc query construction in controller or handler code.
  • Apply the principle of least privilege to database accounts used by the application so that even if a query is abused, its effect is constrained to necessary tables and operations.
  • Consider using query-building abstractions or ORM frameworks that default to safe parameter binding and discourage manual string concatenation.

How teams detect issues like this

Detection typically combines code-centric and runtime analysis:

  • Static analysis: Use SAST rules or linters to flag dynamic SQL construction that concatenates request parameters, especially in API handlers for webhook and scanner functionality.
  • Code review: During manual reviews, look for direct string-based SQL creation, conditional fragments assembled from user input, and missing parameter binding in database access functions.
  • Testing and DAST: Employ automated or manual security testing tools that probe API endpoints with SQL injection payload patterns, including time-based blind vectors, and monitor response timings.
  • Logging and monitoring: Enable detailed logging of SQL errors and unusual timing behavior, and monitor for requests sending suspicious query-like strings or patterns that correlate with slow database responses.

Sources

SourceLink
github.comgithub.com/the-hideout/tarkov-data-manager/commit/9bdb3a75a98a7047b6d70144eb1da1655d6992a8
github.comgithub.com/the-hideout/tarkov-data-manager/security/advisories/GHSA-4gcx-ghwc-rc78

Frequently asked

questions

Exploitation is limited to authenticated users who can reach the webhook edit and scanner API endpoints, but any such user with the ability to craft requests could potentially leverage the issue to run arbitrary SQL within the application's database context.

The attacker needs valid credentials or an access token that grants them permission to use the affected API endpoints. Without authenticated access, direct exploitation is unlikely unless other issues expose or bypass authentication.

Replace all string-concatenated SQL in the affected endpoints with parameterized queries or prepared statements, add strict server-side validation for incoming parameters, and funnel all database operations through vetted, reusable query helpers or an ORM that enforces safe binding.

Adopt a consistent secure coding standard that mandates parameterized queries, integrate static analysis and security checks into the CI pipeline, perform regular security-focused code reviews on data-access logic, and minimize database privileges so that unexpected queries have restricted impact.

Find out what's already
exploitable in your codebase.