/

CVE-2026-24782

Severity:

HIGH RISK

(7.6)

SQL Injection in Kiteworks Secure Data Forms

CVE-2026-24782

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Unauthorized Data Access and Modification

Severity:

HIGH RISK

(7.6)

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

Kiteworks Secure Data Forms contained multiple SQL injection paths that allowed an authenticated attacker with the FormBuilder role to manipulate backend SQL queries.

Under these conditions, an attacker could retrieve or alter other users' form definitions and certain global configuration parameters by crafting malicious form-related inputs.

Affected context

The vulnerability occurs in the Kiteworks Secure Data Forms component when database queries are constructed using form-related input controlled by users with the FormBuilder role.

It is relevant in deployments where:

  • The FormBuilder role is assigned to users who can create or edit forms
  • Backend SQL statements are built dynamically from form metadata or parameters
  • Input validation and query parameterization are incomplete or inconsistently applied

In this context, crafted input from a FormBuilder can influence SQL queries that interact with form definitions and global settings.

Exploit preconditions

  • Attack surface: Application web interface / API exposed to authenticated Kiteworks users.
  • Required access: Valid Kiteworks account with the FormBuilder role or equivalent permissions to manage Secure Data Forms.
  • Trigger point: Submission or update of form definitions or related configuration fields that are concatenated into SQL statements.
  • Why exploitation is possible: User-controlled fields are interpolated into SQL queries without consistent parameterization or proper escaping, enabling attackers to alter the intended query structure.

Why this happens

The core issue is the construction of SQL statements using untrusted, dynamic input from form builders without safe query composition patterns.

This maps directly to CWE-89: Improper Neutralization of Special Elements used in an SQL Command ('SQL Injection'), where special characters and control tokens in user-controlled fields (e.g., form names, fields, filters, or metadata) are not neutralized before being included in database commands.

Instead of using prepared statements or strict query builders, the code likely relies on dynamic string concatenation or partial interpolation, which allows a malicious FormBuilder to inject additional clauses (such as extra predicates or UPDATE/DELETE fragments) into the SQL, affecting other users' forms and some global configuration records.

Potential impact

  • Unauthorized reading of other users' form definitions and associated metadata.
  • Modification or corruption of existing form definitions created by other users.
  • Manipulation of certain global configuration parameters that may affect application behavior.
  • Loss of integrity for workflows that depend on Secure Data Forms.
  • Indirect exposure of sensitive business processes encoded in form structures and configuration.

General mitigation guidance

Effective mitigation focuses on eliminating direct string-based SQL composition and tightening trust boundaries around form-building functionality.

Recommended defensive patterns include:

  • Using parameterized queries or ORM query builders for all interactions with form definitions and configuration tables, ensuring that user input can only affect values, not query structure.
  • Applying strict server-side validation and canonicalization for all form-related fields (names, labels, filters, conditions) to enforce allowed character sets, lengths, and formats.
  • Implementing clear separation of duties so that high-impact global configuration cannot be modified via form metadata or by general FormBuilder roles.
  • Applying least-privilege database accounts so that application-level SQL operations for form management have only the minimal permissions necessary.
  • Introducing centralized database access layers or repositories that encapsulate query construction, making ad hoc SQL concatenation harder or impossible.
  • Designing secure defaults in form-building workflows so that dangerous or unnecessary dynamic query capabilities are not exposed to user-controlled configuration.

How teams detect issues like this

Organizations can identify and monitor for this class of vulnerability through:

  • Static analysis: Rules that flag string concatenation in SQL execution paths (e.g., calls to query execution APIs using interpolated strings) and ensure parameters are always bound variables.
  • Code review: Manual inspection focusing on the Secure Data Forms implementation, especially where form metadata or configuration values influence WHERE, ORDER BY, or JOIN clauses.
  • Database-level monitoring: Logging and analyzing SQL statements for unusual patterns originating from form-related operations, such as unexpected comments, UNIONs, or stacked queries.
  • Security testing: Targeted application security testing (SAST/DAST) that exercises form creation and update workflows with injection payloads tailored to metadata fields.
  • Policy enforcement: CI/CD checks that prevent new code using raw SQL concatenation from being merged, and that require use of approved data access layers or ORMs.

Sources

SourceLink
github.comgithub.com/kiteworks/security-advisories/security/advisories/GHSA-849r-gm3r-4v5c

Frequently asked

questions

Yes, it is remotely exploitable through the Kiteworks web interface or APIs, but only by users who are authenticated and hold the FormBuilder role or similar privileges.

The attacker needs valid credentials and the specific FormBuilder capability to create or modify forms. Anonymous users or regular users without this role cannot typically exploit the vulnerable paths.

The safest approach is to enforce parameterized queries or use a robust ORM/query builder for all database operations related to forms and configuration, combined with strict validation of all form metadata and configuration inputs.

Prevention involves adopting a secure data access architecture: mandate parameterized queries, centralize database access in vetted modules, add static analysis rules for SQL construction, and integrate security-focused code reviews for any feature that allows users to influence query behavior.

Find out what's already
exploitable in your codebase.