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-105854

CVE-2026-105854: Regular Expression Denial of Service (ReDoS) and Uncontrolled Resource Consumption in Payload CMS

Amit Schendel
Amit Schendel
Senior Security Researcher

Oct 6, 2026·6 min read·21 visits

Executive Summary (TL;DR)

Unauthenticated remote attackers can freeze the Payload CMS Node.js event loop and exhaust heap memory by sending malformed multipart HTTP requests, exploiting a ReDoS flaw in the boundary regex parser and a lack of request size limits in stream processing.

Payload CMS, a popular open-source headless Content Management System, contains a critical Regular Expression Denial of Service (ReDoS) and uncontrolled resource consumption vulnerability in versions prior to 3.90.0 and canary versions prior to 4.0.0-canary.34. Due to nested quantifiers in the multipart boundary regex validation pattern, and the absence of streaming backpressure controls, remote attackers can trigger catastrophic backtracking and memory exhaustion. This blocks the single-threaded Node.js event loop, resulting in a persistent and complete Denial of Service (DoS).

Vulnerability Overview

Payload CMS uses multipart request processing to facilitate file uploads and complex object parsing. The application exposes specific endpoints (such as /api/media and registration routes) that allow unauthenticated clients to transmit multipart payloads.

In vulnerable versions of Payload CMS, the initial validation logic evaluates the Content-Type header using an inefficient regular expression designed to confirm the presence of valid multipart parameters. If the header pattern deviates slightly from the expected format at the termination of the string, the underlying Javascript V8 engine falls into catastrophic backtracking.

Simultaneously, the secondary processing stage utilizes an unbounded stream parser that feeds incoming data directly into Busboy. The implementation lacks global size limits and fails to process socket events with proper backpressure. This omission enables concurrent attackers to consume substantial system memory, resulting in process termination or starvation of system resources.

Root Cause Analysis

The root cause of the vulnerability resides in two separate software components. First, in isEligibleRequest.ts, a regular expression is executed to parse the client-supplied Content-Type header. The vulnerable regex pattern is defined as:

const ACCEPTABLE_CONTENT_TYPE =
  /multipart\/[\w'"()+,./:<=>?@[\\\]^-]+(?:; ?[\w'"()+,./:<=>?@[\\\]^-]*)+$/i

The pattern uses a nested quantifier sequence inside the non-capturing group (?:; ?[\w'"()+,./:<=>?@[\\\]^-]*)+$. Because the inner character class is quantified with * (zero or more matches) and the outer group is quantified with + (one or more matches), a string containing multiple nested semicolons and spaces (for example, ; ; ; ; ;) can be split and evaluated in an exponential number of ways by the engine.

When a remote client supplies a string containing thousands of trailing semicolons followed by an invalid character such as {, the V8 regular expression engine spends exponential time backtracking to try every possible path permutation. Because the Node.js event loop runs on a single execution thread, the catastrophic backtracking block locks the execution context, preventing the application from serving other requests.

Additionally, the multipart parsing routine in processMultipart.ts lacked backpressure handling and overall boundary checks. The logic read from the stream reader inside a standard while loop, invoking busboy.write() synchronously. This pattern ignores the write buffer state, meaning slow clients or extremely large requests can force the application to buffer infinite amounts of data directly in heap memory, causing Out-Of-Memory (OOM) crashes.

Code Analysis

In the vulnerable version of the codebase, the stream consumption loop handled chunks without awaiting the write state of the consumer. This allowed the node buffer space to grow unrestricted. Below is the vulnerable stream processing code:

// packages/payload/src/uploads/fetchAPI-multipart/processMultipart.ts
while (parsingRequest) {
  const { done, value } = await reader!.read()
 
  if (done) {
    parsingRequest = false
    busboy.end()
  }
 
  if (value && !shouldAbortProccessing) {
    // Synchronous write ignores backpressure constraints
    busboy.write(value)
  }
}

In contrast, the patched implementation defines a default maximum request limit (DEFAULT_REQUEST_SIZE_LIMIT) of 50 MiB and wraps the write operations in an asynchronous pump() function. The new logic respects write callbacks and dynamically calculates the current incoming byte length against the configured limit:

// Patched version of processMultipart.ts
const pump = async () => {
  try {
    while (!failure) {
      const { done, value } = await reader.read()
      if (failure) {
        break
      }
      if (done) {
        busboy.end()
        break
      }
      requestSize += value.byteLength
      if (requestSize > requestSizeLimit) {
        const err = requestSizeLimitError()
        fail(err)
        // Terminate and cancel the stream to stop data flow
        await reader.cancel(err).catch(() => {})
        break
      }
      // Await callback of busboy.write to ensure backpressure is resolved
      await new Promise<void>((resolve, reject) => {
        busboy.write(value, (err?: Error | null) => (err ? reject(err) : resolve()))
      })
    }
  } finally {
    reader.releaseLock()
  }
}

This safe fail-closed structure forces immediate stream destruction when the bytes exceed limits, saving both process memory and thread CPU time.

Exploitation Mechanics

An attacker can exploit this vulnerability without authenticating to the target Payload CMS instance. The attack consists of formulating a crafted HTTP request with a malformed header designed to trigger catastrophic backtracking. Below is the sequence of events during a typical attack vector:

To exploit the ReDoS flaw, an attacker sends an HTTP header resembling the following:

Content-Type: multipart/form-data; boundary=bar; a=1; a=1; a=1; [repeated 4000 times] {

The trailing curly brace { prevents the regular expression from matching successfully. The engine is then forced to evaluate every subset permutation of the repeated parameter assignments, consuming 100 percent of the host CPU core.

To exploit the uncontrolled stream processing, the attacker starts writing an endless stream of dummy bytes inside the body of a valid multipart payload. If the application server fails to enforce rate limiting or reverse proxy timeouts, the Payload Node process buffers the stream data globally on the heap, triggering a process crash due to memory exhaustion.

Mitigation and Remediation Guidance

The absolute resolution is to upgrade the application dependency to an official patched release. For environments operating on the major 3.x branch, upgrade to 3.90.0 or higher. For canary development tracks, upgrade to 4.0.0-canary.34 or later.

In cases where immediate package upgrade is not feasible, organizations can enforce mitigations at the edge or ingress proxy layer. Configure the Web Application Firewall (WAF) or ingress controller to filter incoming HTTP request headers. Establish a ceiling constraint on the maximum length of the Content-Type header (for example, limiting it to 256 bytes). Legitimate boundary strings rarely exceed this limit.

Additionally, implement request payload body limitations at the reverse proxy layer (such as Nginx's client_max_body_size directive). This ensures that large streaming uploads are dropped prior to being processed by the downstream Node.js service, preventing stream exhaustion vectors.

Official Patches

payloadcmsGit commit containing the streaming fix and regex evaluation limits

Fix Analysis (1)

Technical Appendix

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

Affected Systems

Payload CMS open-source application server

Affected Versions Detail

Product
Affected Versions
Fixed Version
payload
payloadcms
>= 3.0.0, < 3.90.03.90.0
payload
payloadcms
>= 4.0.0-canary.0, < 4.0.0-canary.344.0.0-canary.34
AttributeDetail
CWE IDCWE-1333, CWE-400
Attack VectorNetwork
CVSS Score8.7 (High)
Exploit Statuspoc
KEV Statusnot-listed
Remediation Statuspatched

MITRE ATT&CK Mapping

T1499.004Endpoint Denial of Service: Application Exhaustion
Impact
CWE-1333
Inefficient Regular Expression Complexity

Inefficient Regular Expression Complexity (ReDoS) leading to CPU starvation, coupled with Uncontrolled Resource Consumption (memory heap exhaustion) due to missing backpressure controls in stream parsing.

Vulnerability Timeline

Vulnerability patch committed to repository
2026-09-11
Official Security Advisory GHSA-2g7p-5934-q4w7 published
2026-10-06
CVE-2026-105854 assigned and published
2026-10-06

References & Sources

  • [1]Payload CMS Security Advisory GHSA-2g7p-5934-q4w7
  • [2]Payload CMS GitHub Release v3.90.0
  • [3]CVE Official Record - CVE-2026-105854

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

•41 minutes ago•CVE-2026-104885
6.3

CVE-2026-104885: Cross-Realm MQTT Session Disconnect via Missing Authorization in OpenRemote

OpenRemote prior to version 1.31.0 contains a Missing Authorization vulnerability (CWE-862) in the user management REST API endpoint responsible for disconnecting active MQTT sessions. The disconnectUserSession method in UserResourceImpl fails to verify whether the requesting user owns the target MQTT session, holds administrative privileges, or belongs to the realm specified in the request path. As a result, any authenticated user who obtains a valid MQTT session identifier can forcefully terminate active MQTT connections belonging to other users or IoT devices across any tenant realm.

Amit Schendel
Amit Schendel
1 views•9 min read
•about 2 hours ago•CVE-2026-69133
5.3

CVE-2026-69133: Cumulation Buffer Memory Retention in Netty OHTTP Codec

CVE-2026-69133 (GHSA-cg26-4c6j-2x8h) is a missing resource release vulnerability (CWE-772) in io.netty.incubator:netty-incubator-codec-ohttp affecting versions 0.0.20.Final through 0.0.26.Final. Both OHttpClientCodec and OHttpServerCodec retain the outer cumulationBuffer at its expanded high-water capacity after an Oblivious HTTP (OHTTP) exchange finishes. A remote unauthenticated attacker can complete a large OHTTP request or response over an HTTP keep-alive connection and leave the connection idle, pinning pooled or direct memory allocations across concurrent connections to induce denial of service.

Amit Schendel
Amit Schendel
2 views•8 min read
•about 3 hours ago•CVE-2026-104773
6.8

CVE-2026-104773: Session Fixation in CKAN User Registration View

A session fixation vulnerability (CWE-384) exists in CKAN (Comprehensive Knowledge Archive Network) prior to versions 2.10.11 and 2.11.6. When configured with server-side session storage and active public web registration, the user registration view programmatically authenticates newly created accounts without regenerating the active session identifier. An attacker capable of fixing or capturing a victim's pre-authentication session cookie can hijack the newly registered account immediately after registration completes.

Alon Barad
Alon Barad
2 views•9 min read
•about 4 hours ago•CVE-2026-35374
6.3

CVE-2026-35374: Arbitrary File Truncation via TOCTOU Race Condition in uutils coreutils split

CVE-2026-35374 is a Time-of-Check to Time-of-Use (TOCTOU) race condition (CWE-367) in the split utility of uutils coreutils. The utility validates that the input and output paths do not refer to the same file before opening the output file with truncation flags. A local attacker with write permissions in the destination directory can replace the output file path with a symbolic link during this race window, causing the process to truncate and overwrite arbitrary files accessible to the user executing split.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 5 hours ago•CVE-2026-35377
3.3

CVE-2026-35377: Local Denial of Service via Improper Single-Quote Backslash Parsing in uutils coreutils env

CVE-2026-35377 is an improper input validation vulnerability (CWE-20) in the env utility of uutils coreutils, the Rust-based reimplementation of GNU coreutils. When processing command-line arguments with the -S (--split-string) option, the uutils split-string tokenizer erroneously validates backslash sequences enclosed within single quotes against a fixed table of known escape characters. Under standard GNU env behavior, backslashes inside single quotes are treated literally (except for \\ and \'). Because uutils rejects unrecognized sequences such as \a, \x, or \| with exit code 125, automated scripts, shebang invocations, and administrative workflows relying on POSIX/GNU compatibility fail to execute, resulting in a local denial of service.

Alon Barad
Alon Barad
2 views•9 min read
•about 6 hours ago•CVE-2026-35376
4.5

CVE-2026-35376: Time-of-Check Time-of-Use (TOCTOU) Race Condition in uutils coreutils chcon

A Time-of-Check to Time-of-Use (TOCTOU) race condition in the chcon utility of uutils coreutils prior to version 0.8.0 allows a local attacker with write access to a directory tree undergoing recursive SELinux context relabeling to redirect extended attribute modifications to arbitrary system files.

Amit Schendel
Amit Schendel
2 views•10 min read