/

CVE-2026-54597

Severity:

HIGH RISK

(8.3)

Time-Based SQL Injection (CWE-89) in ITFlow Sharing

CVE-2026-54597

Deferred

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Blind SQL Injection and Sensitive Data Exposure

Severity:

HIGH RISK

(8.3)

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

ITFlow contains a time-based blind SQL injection vulnerability in the credential-sharing link workflow. An authenticated user with the required support permissions and access to a credential record may inject a crafted expression through the expires parameter, infer database contents from response delays, and potentially obtain sensitive secrets or support further account compromise.

Affected context

The vulnerability occurs in ITFlow deployments where an authenticated user has module_support write permission and can access a credential record. The share_generate_link handler processes the expires parameter in agent/ajax.php and incorporates it into a MySQL INTERVAL expression without treating the value as a strictly typed, safely parameterized value. Exploitation depends on the handler being reachable and the attacker having the required application privileges.

Exploit preconditions

  • Attack surface: Authenticated web application request handled by the credential-sharing workflow
  • Required access: A valid account with module_support write permission and access to a credential record
  • Trigger point: Processing of the expires parameter by the share_generate_link handler
  • Why exploitation is possible: The parameter is inserted into an unquoted MySQL INTERVAL expression, allowing crafted database expressions whose results can be inferred through response timing

Why this happens

The underlying issue is SQL injection caused by placing user-controlled input into a database expression without using a typed, parameterized construction. String-context escaping is insufficient when a value is inserted into an unquoted numeric or interval expression, because the database may interpret crafted input as executable SQL syntax. This behavior maps to CWE-89: Improper Neutralization of Special Elements used in an SQL Command, commonly known as SQL injection.

Potential impact

  • An attacker may infer database metadata and sensitive records through timing differences.
  • Password hashes, SMTP credentials, API keys, and encrypted vault data could be exposed.
  • Retrieved credentials could support unauthorized access to connected services.
  • Credential cracking could enable administrative account takeover.
  • The database and dependent IT management operations could be compromised.

General mitigation guidance

Mitigation generally focuses on ensuring that database expressions never interpret user input as SQL syntax.

Common defensive patterns include:

  • Use parameterized queries or database APIs that safely represent values in the relevant expression context.
  • Treat expiration values as typed data, such as validated integers, rather than as SQL fragments.
  • Apply strict allowlist validation for interval units and reject unexpected syntax, signs, ranges, and delimiters.
  • Avoid relying on generic escaping when input is used outside a quoted string context.
  • Enforce least privilege for application database accounts and restrict access to credential records.
  • Minimize the storage and disclosure of secrets, using protected secret-management mechanisms where practical.
  • Use secure-by-default authorization checks for credential-sharing operations.

How teams detect issues like this

Organizations can look for this class of issue through:

  • Static analysis rules identifying string concatenation or interpolation in SQL statements.
  • Review of query construction involving unquoted numeric, date, interval, ordering, or identifier contexts.
  • Code review checks confirming that all user-controlled database values are parameterized and type-validated.
  • Dynamic testing that supplies boundary and malformed values while monitoring database errors and response-time anomalies.
  • Web application monitoring for repeated requests to credential-sharing endpoints with unusual expiration values or timing patterns.
  • Database auditing for unexpected conditional queries issued by the application account.
  • Automated security review tools that flag SQL construction and insufficient input validation.

Sources

SourceLink
github.comgithub.com/itflow-org/itflow/commit/63d86917ae0438548d21d4e28e4d3c55176f5cbf
github.comgithub.com/itflow-org/itflow/pull/1289
github.comgithub.com/itflow-org/itflow/releases/tag/v26.07
github.comgithub.com/itflow-org/itflow/security/advisories/GHSA-m63v-j7fw-hq2h

Frequently asked

questions

It can be exploited through the web application by an authenticated user who satisfies the required permission and credential-record access conditions. It does not generally represent unauthenticated exposure by itself.

The attacker needs an account with module_support write permission and access to a credential record used by the sharing workflow. Deployment-specific authorization and network controls may further limit reachability.

Treat the expiration value as a strictly validated application data type and pass it through a database-safe, parameterized construction. Do not place user-controlled text directly into an unquoted SQL expression.

Combine parameterized database access with allowlist validation, least-privilege database permissions, focused review of non-string SQL contexts, and monitoring for anomalous timing-based requests.

Find out what's already
exploitable in your codebase.