CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-105805

CVE-2026-105805: Sorting-Based Side-Channel Information Disclosure in Payload CMS

Alon Barad
Alon Barad
Software Engineer

Oct 7, 2026·6 min read·20 visits

Executive Summary (TL;DR)

An authorization bypass vulnerability in Payload CMS enables unauthenticated users to deduce hidden values in restricted fields (such as passphrases, tokens, or boolean flags) by leveraging sorting parameters to alter the physical order of returned API records.

CVE-2026-105805 is an authorization bypass and information disclosure vulnerability in Payload CMS. Before version 3.88.0, user-controlled sorting was executed at the database level before field-level access control rules and data redaction were applied. This allowed unauthorized users to reconstruct restricted field values through a sorting side-channel.

Vulnerability Overview

Payload CMS is an open-source headless content management system. Within its architecture, developers define fields and associate access control rules to restrict sensitive properties (e.g., boolean flags, system tokens, hashed password strings) from public read access.

This security control is bypassed in vulnerable versions because database queries execute sorting logic on the raw, unredacted records prior to the application of field-level authorization and redaction logic.

An attacker with read access to a collection can exploit this behavioral sequence to construct a sorting-based side-channel (also called a sorting oracle). By passing custom sort parameters targeting restricted fields and analyzing the order of returned records, the attacker can infer hidden values.

Root Cause Analysis

The underlying technical flaw stems from incorrect authorization evaluation (CWE-863) combined with sensitive information exposure (CWE-200) within the query parsing logic of the CMS database adapters (such as MongoDB or Drizzle-managed SQL).

The processing sequence for collection query REST requests is structured as follows:

  1. The API endpoint receives query parameters, including the user-specified sort argument.
  2. The server translates this argument directly into a native database sorting directive and executes the query.
  3. The database returns the sorted, raw result set to the application backend.
  4. The application processes the records, evaluating field-level read permissions and stripping out values for which the requesting user lacks authorization.
  5. The sanitized JSON array is returned to the client.

Because database-level sorting occurs before post-query authorization redaction, the physical ordering of the document objects returned in the client response is determined by the values of the unauthorized fields. Although the JSON payload excludes the actual values, the structured position of the records reveals the comparative values of the hidden properties.

Code-Level Vulnerability & Patch Analysis

The vulnerability was resolved in commit a742140ab4fca3160f7f83e9e7d996552ffc3b5a by introducing a validation process called validateSortQuery.ts within the database query validation pipeline.

This validator maps the specified sorting fields to a temporary Where constraint structure and executes standard query validation logic against them. This ensures that a client cannot execute queries using sort parameters that reference fields they do not have the authorization to filter by.

// packages/payload/src/database/queryValidation/validateSortQuery.ts
import { validateQueryPaths } from './validateQueryPaths.js'
 
export const validateSortQuery = async ({
  collectionConfig,
  globalConfig,
  overrideAccess,
  req,
  sort,
  versionFields,
}: Args): Promise<void> => {
  if (overrideAccess || !sort) {
    return
  }
 
  const fields = versionFields || (globalConfig || collectionConfig).flattenedFields
  const sortFields = Array.isArray(sort) ? sort : [sort]
  const where: Where = {}
 
  for (const sortField of sortFields) {
    // Normalize sort arguments by stripping descending indicators and nested qualifiers
    const path = sortField.replace(/^-/, '').replace(/__/g, '.')
    const paths = getLocalizedPaths({
      collectionSlug: collectionConfig?.slug,
      fields,
      globalSlug: globalConfig?.slug,
      incomingPath: path,
      locale: req.locale!,
      overrideAccess: true,
      payload: req.payload,
    })
 
    if (path !== 'id' && path !== '_id' && paths.every(({ invalid }) => !invalid)) {
      where[path] = { exists: true }
    }
  }
 
  if (Object.keys(where).length === 0) {
    return
  }
 
  // Execute permissions check as if the client queried these paths directly in a filter
  if (collectionConfig) {
    await validateQueryPaths({
      collectionConfig,
      overrideAccess,
      req,
      versionFields,
      where,
    })
  } else {
    await validateQueryPaths({
      globalConfig,
      overrideAccess,
      req,
      versionFields,
      where,
    })
  }
}

This validator was integrated directly into find, findDistinct, findVersions, and update operation controllers. By routing the normalized sorting path into validateQueryPaths, the core permissions layer verifies if the requesting identity holds read capabilities on the field. If they do not, the application aborts the database transaction and responds with a validation error.

Exploitation Methodology

Exploiting this side-channel does not require system access or write capabilities. The attacker only needs access to a publicly queryable endpoint where custom sorting parameters are accepted.

To identify boolean-based hidden administrative flags (such as an isAdmin flag on a public profile list):

  1. The attacker queries the users collection sorted by the hidden parameter in ascending order: GET /api/users?sort=isAdmin The application returns the user objects sorted so that false (0) values appear at the beginning of the list, followed by true (1) values. The values of the isAdmin key are stripped.
  2. The attacker queries the collection sorted in descending order: GET /api/users?sort=-isAdmin This query forces true values to the top, and false values to the bottom.
  3. By comparing the relative positions of user IDs between the ascending and descending responses, the attacker identifies which specific records are assigned true versus false flags.

For alphanumeric secrets (e.g., reset tokens, keys), attackers can construct iterative binary search algorithms. By comparing the sorted positions of target documents against lexicographically known dummy records, they can systematically reconstruct sensitive data strings character by character.

Impact Assessment

The security impact of CVE-2026-105805 is categorized as medium (CVSS 6.9). The primary impact is unauthorized disclosure of sensitive parameters stored in databases. Attackers can leak restricted configuration flags, reset tokens, or backend attributes that are meant to be restricted.

Because this vulnerability resides in the core query processing structure of Payload CMS, it is widespread across any customized schemas that enforce field-level security while exposing custom client-defined sorting endpoints.

There is no recorded instance of active exploitation in the wild, and public weaponized exploit tools targeting this CVE have not been released. However, due to the logical simplicity of implementing sorting-based side-channel analyses, the exploitability potential is high.

Remediation and Defensive Guidance

The definitive fix for this vulnerability is upgrading the application to a patched version. Upgrade dependencies to version 3.88.0 or later, or version 4.0.0-canary.27 or later if using the canary release branch.

# Upgrade Payload CMS using npm
npm install payload@3.88.0

For systems where immediate updating is blocked, developers can implement Express-level parameter sanitization middleware. This middleware intercepts query payloads and strips out forbidden sort criteria before the query parameters reach the database adapter operation layer:

app.use('/api', (req, res, next) => {
  if (req.query && typeof req.query.sort === 'string') {
    const restrictedFields = ['password', 'resetToken', 'isAdmin', 'apiKey'];
    const normalizedPath = req.query.sort.replace(/^-/, '');
    
    if (restrictedFields.includes(normalizedPath)) {
      return res.status(403).json({
        error: 'Forbidden sorting parameter requested'
      });
    }
  }
  next();
});

Security teams should configure logging and alert rules on Web Application Firewalls (WAF) to detect successive requests featuring ascending and descending queries on the same schema fields, as this is a standard indicator of an automated extraction script mapping the sorting side-channel.

Official Patches

payloadcmsCore patch implementing validateSortQuery to resolve database sorting side-channel

Fix Analysis (1)

Technical Appendix

CVSS Score
6.9/ 10
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:N/SC:N/SI:N/SA:N

Affected Systems

Payload CMS

Affected Versions Detail

Product
Affected Versions
Fixed Version
Payload CMS
payloadcms
< 3.88.03.88.0
Payload CMS
payloadcms
>= 4.0.0-canary.0, < 4.0.0-canary.274.0.0-canary.27
AttributeDetail
CWE IDCWE-863 / CWE-200
Attack VectorNetwork
CVSS Score6.9 (Medium)
Exploit StatusNone
CISA KEV StatusNot Listed
Vulnerability TypeIncorrect Authorization (Sorting Side-Channel)

MITRE ATT&CK Mapping

T1005Data from Local System
Collection
T1552Unsecured Credentials
Credential Access
T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-863
Incorrect Authorization

The software does not perform or incorrectly performs an authorization check when an actor attempts to access a resource or perform an action.

Vulnerability Timeline

Strict path prefix checking logic patched (c6477b8)
2026-08-10
Core sorting verification mechanism patch committed (a742140)
2026-08-11
Payload CMS version 3.88.0 is officially released
2026-08-11
CVE-2026-105805 is published on NVD and CVE.org
2026-10-06

References & Sources

  • [1]Official GitHub Advisory GHSA-9g87-32v6-3c2r
  • [2]Core Mitigation Implementation Patch
  • [3]Payload CMS v3.88.0 Official Release Changelog
  • [4]NVD Vulnerability Details Reference Page
  • [5]Official CVE.org Record Details

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 7 hours ago•CVE-2026-58254
6.5

CVE-2026-58254: Authorization Bypass in NATS Server Message Tracing for Leaf Node Connections

NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.

Alon Barad
Alon Barad
4 views•10 min read
•about 8 hours ago•CVE-2026-63341
7.5

CVE-2026-63341: Unauthenticated Denial of Service via Unbounded Topic Depth in Aedes MQTT Broker

CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.

Alon Barad
Alon Barad
5 views•12 min read
•about 9 hours ago•CVE-2026-61725
6.1

CVE-2026-61725: Path Traversal and Arbitrary File Overwrite in sevenz-rust2

CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.

Alon Barad
Alon Barad
5 views•12 min read
•about 10 hours ago•CVE-2026-77309
8.8

CVE-2026-77309: Unauthenticated Remote Code Execution in NASA-AMMOS AIT-GUI via Incomplete File Cleanup and Path Traversal

CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 11 hours ago•CVE-2026-77332
2.3

CVE-2026-77332: Surfaced-Memory Envelope Injection and Stored Prompt Injection in memtomem-stm

A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.

Alon Barad
Alon Barad
9 views•10 min read
•about 12 hours ago•CVE-2026-77331
2.0

CVE-2026-77331: Race Condition and Session State Corruption in memtomem-stm

CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.

Amit Schendel
Amit Schendel
5 views•9 min read