Oct 7, 2026·7 min read·13 visits
Payload CMS failed to enforce field-level access controls and the disableDuplicate configuration during document duplication, allowing standard users to duplicate administrator profiles and escalate their privileges.
A critical access control bypass vulnerability (CVE-2026-105851) in Payload CMS allows authenticated users to bypass field-level access controls during document duplication. By duplicating high-privilege documents, such as administrator accounts, standard users can inherit sensitive fields (e.g., role configurations or API keys), leading to privilege escalation.
Payload CMS contains a critical privilege escalation vulnerability, designated as CVE-2026-105851, in its document duplication mechanism. When duplicating an existing collection document, the application initializes a document creation pipeline that copies properties from a specified source document to a new one. This behavior exposed an expanded attack surface within authentication-enabled and highly restricted collections.\n\nThe core of the vulnerability lies in the improper registration and exposure of duplication endpoints, coupled with a complete bypass of field-level access controls. An attacker holding low-privilege access can send duplication requests targeting high-privilege documents, such as administrative accounts. The system then populates the new record with sensitive and restricted properties from the target, bypassing standard authorization rules.\n\nThe security impact of this flaw is significant, mapped to CWE-284 (Improper Access Control) and CWE-863 (Incorrect Authorization). It permits authenticated users to execute unauthorized operations, duplicate administrative configurations, and acquire higher privilege contexts without triggering validation checks. The vulnerability affects Payload CMS installations across the 3.x and 4.x canary branches prior to the release of patched versions.
The root cause of CVE-2026-105851 involves two distinct security omissions in the Payload CMS architecture: endpoint exposure and the lack of field-level validation during cloning operations. In a standard deployment, developers use the disableDuplicate flag to restrict document cloning on sensitive collections, particularly those handling authentication. However, in vulnerable versions, this flag failed to inhibit the REST API endpoint /:id/duplicate from registering, allowing clients to send programmatic requests to cloning paths on all collections.\n\nmermaid\ngraph LR\n Attacker["Attacker (Low Privilege)"] -->|"POST /:id/duplicate"| DuplicationEndpoint["Duplication Endpoint (/duplicate)"]\n DuplicationEndpoint -->|"Bypasses disableDuplicate Check"| InternalPipeline["Internal Duplication Pipeline"]\n InternalPipeline -->|"Directly Copies Fields"| SourceDoc["Source Administrator Document (Roles: ['admin'])"]\n SourceDoc -->|"Clones Sensitive Properties"| NewDoc["Created User (Inherits: ['admin'])"]\n\n\nWhen a duplication is triggered, Payload CMS executes an internal creation process powered by createOperation containing a duplicateFromID reference. Instead of passing through a standard sanitization and field-level permission pipeline, the application copied the source document's field values directly into the database insertion payload. This mechanism bypassed the user-level permissions typically enforced during standard create operations.\n\nConsequently, fields marked as hidden or protected by custom access.read or access.create hooks were successfully cloned. Because the field-level access control functions were never invoked against the caller's context during the duplication routine, restricted fields like administrative roles, API tokens, and operational flags were directly duplicated into the newly created account. This enabled privilege escalation by allowing standard users to inherit the capabilities of the duplicated source user.
To mitigate this vulnerability, the developers introduced multiple layers of security validations in commit 099ef12e2682f076aa8e8d0ccb790536b4e1027f to ensure duplication settings are consistently enforced across both REST and programmatic interfaces.\n\nFirst, duplication is now explicitly disabled by default for all authentication-enabled collections within packages/payload/src/collections/config/sanitize.ts:\n\ntypescript\nif (sanitized.auth) {\n // disable duplicate for auth enabled collections by default\n sanitized.disableDuplicate = sanitized.disableDuplicate ?? true\n}\n\n\nSecond, the system ensures that the /duplicate endpoint is omitted during route registration if disableDuplicate is enabled, blocking external access to the REST endpoint:\n\ntypescript\nfor (const endpoint of defaultCollectionEndpoints) {\n if (endpoint !== duplicateEndpoint || sanitized.disableDuplicate !== true) {\n sanitized.endpoints.push(endpoint)\n }\n}\n\n\nThird, programmatic calls are protected inside the core creation operation in packages/payload/src/collections/operations/create.ts:\n\ntypescript\nconst isDuplicating = duplicateFromID !== undefined && duplicateFromID !== null\n\nif (isDuplicating && collectionConfig.disableDuplicate === true) {\n throw new APIError(\n `The collection with slug ${String(collectionConfig.slug)} cannot be duplicated.`,\n 400,\n )\n}\n\n\nFinally, to resolve the field-level bypass, the validation pipeline now enforces granular field checks. In packages/payload/src/fields/hooks/beforeValidate/promise.ts, the application evaluates isDocumentValueAllowed against the caller's active context. If access is unauthorized, the application redirects the value retrieval to a secure default or fallback handler rather than cloning the original document's properties:\n\ntypescript\nif (typeof siblingData[field.name!] === 'undefined' && !req.context?.isRestoringVersion) {\n const isDocumentValueAllowed = operation === 'update' || isAccessAllowed\n\n siblingData[field.name!] =\n !fallbackResult.executed || !isDocumentValueAllowed\n ? await getFallbackValue({ field, isDocumentValueAllowed, req, siblingDoc })\n : fallbackResult.value\n}\n\n\nInside getFallbackValue.ts, the isDocumentValueAllowed flag acts as a gate, ensuring that unauthorized users cannot clone restricted database values during duplication:\n\ntypescript\nif (isDocumentValueAllowed && typeof siblingDoc[field.name] !== 'undefined') {\n fallbackValue = cloneDataFromOriginalDoc(siblingDoc[field.name])\n} else if ('defaultValue' in field && typeof field.defaultValue !== 'undefined') {\n fallbackValue = await getDefaultValue({ ... })\n}\n
Exploitation of CVE-2026-105851 requires that the attacker has authenticated access to the target Payload CMS instance, holding at least standard user privileges. The target collection must expose duplicate capabilities (either because it is not an authentication collection, or because it runs a vulnerable version that fails to enforce the disableDuplicate setting). Additionally, the collection must contain high-privilege configuration fields such as roles or boolean flags that grant operational permissions.\n\nTo perform the exploit, the attacker must identify a target user ID containing the desired privilege context. The attacker then issues a POST request to the duplication endpoint of the target collection, pointing to the target administrative document in the path. In the request body, the attacker supplies their own credentials, such as a modified email address and password:\n\nhttp\nPOST /api/users/64f0a2e31bc2a9001bfa8290/duplicate HTTP/1.1\nHost: target-application.local\nAuthorization: JWT <low-privilege-jwt-token>\nContent-Type: application/json\nConnection: close\n\n{\n "email": "escalated-user@target-domain.com",\n "password": "OperationalPassword123!"\n}\n\n\nUpon receiving the request, the vulnerable server executes the duplication logic. It duplicates all fields of the user 64f0a2e31bc2a9001bfa8290, including the roles: ['admin'] array, because it fails to perform field-level verification against the standard user's session context. The server registers the new user account with administrative roles, allowing the attacker to authenticate using the newly created credentials and achieve complete administrative control over the application.
The technical impact of CVE-2026-105851 is characterized by a complete compromise of the authorization model within affected Payload CMS installations. An authenticated attacker can escalate their privileges from a standard or guest role to a full administrator role. Once administrative access is achieved, the attacker can execute arbitrary read, write, and delete operations across all collections, modify system configurations, and retrieve sensitive application configurations.\n\nThe vulnerability is assigned a CVSS v4.0 score of 9.3, indicating extreme severity. This calculation underscores that the attack vector is network-based, requires low complexity, requires no user interaction, and yields a high impact on integrity. Because authentication collections often map directly to administrative users, bypassing access controls on these documents constitutes a direct path to full infrastructure compromise.\n\nCurrently, there is no evidence of active exploitation in the wild, and CISA has not listed the vulnerability within its Known Exploited Vulnerabilities catalog. However, because the logical flow of the exploit is straightforward, organizations running vulnerable instances must prioritize remediation to prevent the weaponization of proof-of-concept scripts.
The primary remediation for CVE-2026-105851 is upgrading the affected Payload CMS package to a secure version. For deployments built on the 3.x release line, teams must update the dependencies to version 3.90.0 or higher. For projects tracking the 4.x canary branch, the application must be updated to version 4.0.0-canary.34 or higher. These updates ensure that both the REST endpoints and the internal creation operation correctly restrict duplication settings.\n\nIf upgrading is not immediately feasible, organizations must apply immediate configuration-based workarounds. Specifically, administrators must explicitly define disableDuplicate: true inside the schema configuration of all authentication-enabled and high-security collections:\n\ntypescript\nexport const Users: CollectionConfig = {\n slug: 'users',\n auth: true,\n disableDuplicate: true,\n fields: [\n // Field definitions...\n ]\n}\n\n\nAdditionally, developers can restrict sensitive fields manually by implementing custom validation or hooks. For example, registering a beforeChange hook on fields like roles allows developers to verify if the incoming modification is part of a duplication process and actively strip high-privilege parameters when the request context does not authorize them.\n\nAn evaluation of the patch indicates that the fix is robust. By disabling duplication on auth collections by default, removing the endpoint route registration, and executing isDocumentValueAllowed checks during the field fallback sequence, the developers have closed both the network-facing routes and the internal program paths that led to the access bypass.
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:H/VA:N/SC:H/SI:H/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
payload payloadcms | >= 3.0.0, < 3.90.0 | 3.90.0 |
payload payloadcms | >= 4.0.0-canary.0, < 4.0.0-canary.34 | 4.0.0-canary.34 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-284 / CWE-863 |
| Attack Vector | Network (Unauthenticated or Low-Privileged Local Network/API Access) |
| CVSS v4.0 | 9.3 (Critical) |
| EPSS Score | Not Available |
| Impact | Privilege Escalation / Unauthorized Data Access |
| Exploit Status | Conceptual / Proof-of-Concept |
| CISA KEV Status | Not Listed |
The software does not restrict or incorrectly restricts access to resource properties during duplication, allowing unauthorized modifications or permission inheritance.
CVE-2026-122244 (GHSA-r2q3-7m4h-63qg) is a high-severity cross-privilege Stored Cross-Site Scripting (XSS) vulnerability in Budibase prior to version 3.50.0. The flaw occurs due to defective character escaping in the JSON formatter utility combined with raw HTML rendering via Svelte's {@html} directive in the Budibase Builder interface. A low-privileged application user or an unauthenticated form visitor can store malicious HTML markup in a shared datasource, which subsequently executes arbitrary JavaScript in the browser session of an administrator or application builder inspecting Handlebars formula bindings.
A tenant-confusion vulnerability in the user initialization endpoint of the Budibase worker service (prior to version 3.50.0) allows unauthenticated remote attackers to bypass the one-time administrative setup guard. By supplying arbitrary tenant identifiers in POST requests to /api/global/users/init, an attacker can force the underlying CouchDB datastore to dynamically provision unlimited tenant databases and persist latent global administrator accounts. This results in datastore resource exhaustion, denial of service, and unauthorized administrative account creation inside non-default tenant contexts.
Paymenter versions prior to 1.5.7 contain an arbitrary method invocation vulnerability within the base Livewire component architecture. The application includes a legacy trait, HasConfirmation, inside app/Livewire/Component.php, which is inherited across 36 client-facing Livewire components. This trait exposes a public remote procedure call (RPC) endpoint named executeConfirmedAction without access controls or method allowlisting. Remote attackers can invoke arbitrary methods on any inheriting component, including Livewire's internal fill() method, enabling them to bypass #[Locked] property protections and manipulate internal component state and hydrated Eloquent models.
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.
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.
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.