/

CVE-2026-34747

Severity:

HIGH RISK

(8.5)

SQL Injection in Payload Headless CMS Request Handling

CVE-2026-34747

Analyzed

Vulnerability type

Category:

SQL Injection

CWE:

CWE-89

Impact:

Unauthorized Data Access and Modification

Severity:

HIGH RISK

(8.5)

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

Payload, an open source headless CMS, contained an input validation flaw that allows crafted requests to influence underlying SQL query construction.

Under specific conditions where attacker-controlled parameters are directly incorporated into database queries, this weakness can expose or modify data stored in CMS collections.

Affected context

The vulnerability occurs in Payload deployments where incoming HTTP request fields are used to build SQL queries for collection operations.

When certain parameters (such as filters, sorting, or query operators) are accepted without strict validation or normalization, they can alter how SQL statements are generated and executed.

This is most relevant in setups that expose public or semi-public APIs where clients have broad control over query parameters without restrictive schemas or server-side query whitelisting.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoints exposed by Payload CMS (REST or GraphQL-style interfaces).
  • Required access: Ability to send crafted requests to vulnerable endpoints; in many deployments this may be unauthenticated or low-privilege authenticated access.
  • Trigger point: Server-side request handling paths that map request parameters directly into SQL query builders or raw SQL fragments for collection operations.
  • Why exploitation is possible: The system trusted some request parameters without sufficient validation or constraint, allowing attacker-controlled values to influence SQL query structure instead of being treated strictly as data.

Why this happens

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

Conceptually, the bug arises when user-supplied input is allowed to participate in query construction logic—such as conditions, operators, or ordering—without strong normalization and parameterization.

Instead of restricting clients to a fixed, well-defined query shape where inputs are always bound as parameters, some Payload request fields could shape the resulting SQL, effectively blending untrusted input with query syntax.

This pattern breaks the fundamental separation between code and data at the database boundary and enables attackers to alter query behavior.

Potential impact

  • Retrieval of data from collections that the requester may not be authorized to access.
  • Modification or deletion of records in CMS collections, potentially defacing content or corrupting data.
  • Bypassing of logical access controls implemented at the query layer (e.g., row-level filters).
  • Enumeration of database structure through error behavior or side channels, depending on surrounding controls.
  • In certain configurations, use of SQL features that could facilitate broader lateral movement in the data tier.

General mitigation guidance

Effective mitigation focuses on strict separation of query structure and user input, along with tight control over query capabilities exposed to clients:

  • Use parameterized queries or ORM query builders in a way that never concatenates or interpolates raw client input into SQL fragments.
  • Enforce rigid server-side schemas for all request parameters that can affect queries (filters, sort fields, operators), validating both type and allowed values.
  • Whitelist permissible fields, operators, and directions for querying collections instead of interpreting arbitrary client-supplied keys or expressions.
  • Implement centralized query-building utilities that encode safe patterns, rather than constructing queries ad hoc across the codebase.
  • Apply least-privilege database accounts so that, even if a query is influenced, the account cannot read or modify unrelated tables or schemas.

How teams detect issues like this

SQL injection risks are often identified through a combination of static, dynamic, and review-based techniques:

  • Static analysis rules that flag uses of raw SQL or dynamic query construction where input originates from HTTP request objects or generic payloads.
  • Code review checklists that require reviewers to confirm all query-relevant inputs are validated, normalized, and bound as parameters, and that only whitelisted fields/operators are accepted.
  • Centralized logging of query execution with correlation to request metadata to spot atypical query patterns or inputs indicative of injection attempts.
  • Use of application security testing (DAST) tools configured to fuzz API endpoints with injection probes and observe anomalous responses or errors.
  • Policy enforcement in CI pipelines requiring that all data-access paths route through vetted query builder abstractions or repositories.

Sources

SourceLink
github.comgithub.com/payloadcms/payload/releases/tag/v3.79.1
github.comgithub.com/payloadcms/payload/security/advisories/GHSA-7xxh-373w-35vg

Frequently asked

questions

Yes. Because the attack surface is the HTTP(S) interface of the CMS, an attacker who can reach a vulnerable endpoint over the network can attempt to exploit it with crafted requests.

It depends on how the CMS is configured. If vulnerable endpoints are exposed publicly, unauthenticated exploitation may be possible; in more locked-down deployments, a low-privileged account with API access may be required.

The most robust fix is to ensure all database interactions are built with parameterized queries or safe ORM abstractions, coupled with strict whitelisting and schema validation for any request parameters that influence querying (such as filters or sort options).

Standardize on a secure query-building layer, prohibit raw SQL construction from untrusted inputs, enforce strict API schemas, and integrate automated checks and security-focused code reviews to flag any new patterns that mix user input into query logic.

Find out what's already
exploitable in your codebase.