Oct 7, 2026·6 min read·62 visits
Unauthenticated remote attackers can pollute the global object prototype in Payload CMS to bypass access controls and execute arbitrary code on the server.
A critical prototype pollution vulnerability in the import-export plugin of Payload CMS allows unauthenticated remote attackers to bypass access controls and achieve remote code execution.
The @payloadcms/plugin-import-export plugin provides essential administrative capabilities to Payload CMS, a headless content management system built on Next.js. Specifically, the plugin manages collection data exports and imports, allowing administrators to transfer content via formats like JSON or CSV. To achieve this, it maps user-specified field arrays to configuration objects and queries.
Because the plugin does not properly sanitize or filter the user-supplied field paths, it exposes a critical entry point for prototype pollution. Unauthenticated attackers can submit custom paths containing special object properties such as proto. This lack of validation represents a significant implementation flaw in the processing engine.
This vulnerability is tracked under the identifier CVE-2026-105844 with a high CVSS rating. It falls under the category of CWE-1321, which designates improperly controlled modification of object prototype attributes. The ultimate impact of successful exploitation is arbitrary code execution, presenting a severe risk to affected deployments.
The root cause of this flaw lies in the path-parsing logic implemented within the plugin's utility files. Functions like setNestedValue are designed to dynamically traverse and set values on objects based on split dot-notation paths. When processing paths, the application splits the input string by periods and recursively accesses the corresponding keys on the current target object.
During traversal, the function dynamically creates intermediate empty objects when a given path segment is not found. However, the routine lacks checks to prevent traversal of the built-in JavaScript proto accessor. Consequently, if the path contains proto, the reference pointer is successfully redirected to the global Object.prototype structure.
Any subsequent key-value assignment is then applied directly to Object.prototype rather than a local, isolated property. Because all plain JavaScript objects inherit from this prototype, any properties added or altered during this process propagate globally. This mutation of basic object properties undermines the runtime environment's reliability and security controls.
In the vulnerable codebase, the setNestedValue function evaluates each split segment of the user-provided path sequentially. It makes no distinction between ordinary data fields and critical system properties. The lack of input validation enables attackers to pass prototype-polluting paths into the traversal loop directly.
// Vulnerable setNestedValue loop
for (let i = 0; i < parts.length; i++) {
const part = parts[i]
const isLast = i === parts.length - 1
const isIndex = !Number.isNaN(Number(part))
if (!isIndex) {
const currentObj = current as Record<string, unknown>
if (isLast) {
if (typeof part === 'string') {
currentObj[part] = value // Vulnerable assignment to prototype
}
} else {
if (typeof currentObj[part as string] !== 'object' || currentObj[part as string] === null) {
currentObj[part as string] = {}
}
current = currentObj[part as string]
}
}
}The remediated code implements strict filtering prior to executing any traversal or assignment. A newly added utility function, hasUnsupportedFieldPathSegment, validates that no path segments match proto, constructor, or prototype. Furthermore, the functions now utilize Object.create(null) to guarantee prototype-free container structures, eliminating the default prototype chain lookup entirely.
// Safe setNestedValue implementation
export const setNestedValue = (
obj: Record<string, unknown>,
path: string,
value: unknown,
source?: Record<string, unknown>,
): void => {
const parts = path.split('.')
if (hasUnsupportedFieldPathSegment(parts)) {
throw new APIError('Invalid field path.', 400, null, true)
}
// Traversal loop continues safely...
}Exploitation of CVE-2026-105844 requires that the target application has the @payloadcms/plugin-import-export plugin configured and enabled. An unauthenticated attacker can initiate the compromise by issuing a single, crafted HTTP POST request. The request targets the /api/exports/export-preview endpoint and includes a polluted payload inside the fields parameter.
The target application processes the fields array to generate an export layout, calling the vulnerable setNestedValue routine. By submitting a path like proto.overrideAccess with a value of true, the attacker modifies the base object prototype of the entire runtime. As a result, subsequent empty options objects checked by Payload's internal access engine will automatically return true for overrideAccess.
This behavior effectively disables access control verification across the entire application instance. Unauthenticated requests are then processed as though they possess full administrative privileges. From this position, attackers can execute sensitive operations, manipulate database entries, or leverage system utilities to gain remote code execution.
The overall impact of this vulnerability is critical, presenting a severe risk to any internet-exposed Payload CMS instance. Because the endpoint does not require authentication, attackers can execute this exploit from arbitrary network positions. No prior access credentials or system privileges are necessary to perform the attack successfully.
By leveraging the prototype pollution vulnerability, the attacker completely subverts the application's authorization and authentication layers. This subversion grants access to restricted administrative capabilities, including database operations, user management, and system tool execution. Consequently, the confidentiality, integrity, and availability of all hosted data are fully compromised.
Furthermore, the ability to control properties on the global Object.prototype opens multiple paths to remote code execution. Attackers can pollute options passed to system execution utilities such as child_process.spawn, or inject malicious options into templating engines. The resulting complete system compromise enables unauthorized actors to execute arbitrary operating system commands.
The complete resolution of this vulnerability is achieved by updating the Payload CMS packages to their respective non-vulnerable versions. Deployments on the 3.x release track must be updated to version 3.88.0 or higher. Deployments utilizing the canary pre-release track must be updated to version 4.0.0-canary.27 or higher.
If immediate software updates are impossible, temporary mitigation strategies must be applied. Web Application Firewalls (WAFs) should be configured with deep packet inspection rules to identify and drop requests targeting /exports/export-preview that contain proto, constructor, or prototype strings. These filters help reduce the immediate threat surface.
Additionally, access controls should be enforced at the reverse proxy level to limit exposure of administrative and preview endpoints to trusted networks only. While these workarounds reduce the likelihood of exploitation, they do not resolve the underlying vulnerability in the application logic. Complete security compliance can only be established by applying the vendor-supplied updates.
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
Payload CMS (@payloadcms/plugin-import-export) Payload CMS | >= 3.0.0, < 3.88.0 | 3.88.0 |
Payload CMS (canary) Payload CMS | < 4.0.0-canary.27 | 4.0.0-canary.27 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-1321 |
| Attack Vector | Network (AV:N) |
| CVSS Score | 9.3 (Critical) |
| EPSS Score | N/A |
| Impact | Remote Code Execution (RCE) / Privilege Escalation |
| Exploit Status | Proof of Concept (PoC) documented |
| KEV Status | Not listed |
Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')
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.
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.
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.
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.
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.
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.