Oct 6, 2026·5 min read·21 visits
Vulnerable versions of Payload CMS fail to restrict read access to the dynamically generated apiKey field, exposing active plaintext API keys to any user with standard read access to user collections.
A sensitive data exposure vulnerability in Payload CMS allows authenticated low-privilege users to retrieve decrypted, plaintext API keys of other users, including administrators, leading to full administrative account takeover and privilege escalation.
The affected component is Payload's default API key authentication mechanism. When a collection configuration enables useAPIKey, the CMS generates default authentication fields, specifically apiKey. In vulnerable versions, Payload fails to enforce adequate field-level read-authorization controls or default masking on this generated apiKey field.
Consequently, any user with ordinary read access to other authentication documents in that collection can retrieve active, unmasked API keys for other users.
This exposes a substantial attack surface, as low-privilege users can query the /api/users endpoint or custom authentication collections and retrieve active keys of higher-privilege administrative accounts. The bug falls under CWE-201 (Insertion of Sensitive Information Into Sent Data) and CWE-862 (Missing Authorization).
In Payload CMS, collections configured with authentication support can generate API keys to allow external integrations or API clients to execute operations. Setting useAPIKey to true dynamically inserts default fields into the collection schema, including enableAPIKey and apiKey.
The root cause of the vulnerability lies in the lack of read-level restrictions in the default field definition of apiKey under packages/payload/src/auth/baseFields/apiKey.ts. The default apiKey field definition did not implement explicit field-level access control, such as access.read = () => false. Consequently, the field inherited the read permissions of the parent document.
Furthermore, the field definition integrated an afterRead hook that mapped to decryptKey. Whenever a read operation was executed on a document within the collection, the database engine returned the ciphertext, the hook automatically decrypted it using the primary payload secret, and the plaintext API key was rendered directly in the output JSON.
An examination of the patch in commit 880d2e900be22cd66a9e939f2b3e702fa413180f reveals the structural remediation of this design flaw. The developer replaced the implicit read inheritance with a hard block on standard read operations. The access.read attribute is now explicitly defined as () => false for the apiKey field.
The patch also eliminates the automated decryption process during standard reads. The decryptKey hook was completely removed, replaced by the omitEncryptedAPIKey hook within afterRead, which guarantees that the raw or encrypted key cannot be leaked even if database extraction occurs. A new dedicated and secured reveal endpoint (/:id/api-key/reveal) was introduced, implementing granular verification checks that demand admin panel access capabilities alongside read and write permissions on the targeted document.
Exploitation requires that the attacker has authenticated credentials with standard read permissions to the user collection. In a standard multi-tenant or multi-user configuration, standard users or content authors might have permissions to view other profiles, or a lax API configuration might permit broad read access to the /api/users endpoint.
The attacker queries the endpoint using standard HTTP REST or GraphQL operations. Because the apiKey field is decrypted on read, the server returns the plaintext API keys in the response payload.
The attacker extracts the active API key of an administrative user and places it in the Authorization header of subsequent requests. Since the API key authentication middleware identifies the key and maps it to the target user context, the attacker assumes the full permissions of the administrative account, achieving complete privilege escalation.
An attacker who exploits this vulnerability gains full, unauthenticated administrative access over the affected CMS instance. Because API keys bypass multi-factor authentication and standard login logging protocols, the attacker's activities may remain undetected within standard authentication monitoring channels.
The vulnerability carries a CVSS v4.0 base score of 7.7, reflecting high confidentiality, integrity, and availability impacts within the local CMS instance. While the vulnerability is restricted to the Payload CMS application layer, administrative compromise allows complete data exfiltration, database tampering, and arbitrary execution of any integrated headless processes.
The primary remediation strategy is upgrading the Payload installation to version 3.90.0 or higher, or 4.0.0-canary.34 or higher. These releases implement the hardened field configuration and secure disclosure endpoints.
If upgrading is not immediately possible, security teams should implement immediate manual overrides. This includes modifying collection definitions to explicitly set the access.read constraint of the apiKey field to () => false.
Additionally, read permissions on user collections must be locked down using granular access rules so that non-administrative users can only read their own documents. Finally, any potentially exposed API keys must be immediately rotated to invalidate cached sessions.
CVSS:4.0/AV:N/AC:L/AT:P/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N| Product | Affected Versions | Fixed Version |
|---|---|---|
payload Payload CMS | >= 3.0.0 < 3.90.0 | 3.90.0 |
payload Payload CMS | >= 4.0.0-canary.0 < 4.0.0-canary.34 | 4.0.0-canary.34 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-201, CWE-862 |
| Attack Vector | Network |
| CVSS Score | 7.7 |
| EPSS Score | N/A |
| Impact | Account Takeover / Privilege Escalation |
| Exploit Status | poc |
| KEV Status | Not Listed |
The product houses sensitive information in a resource that is accessible to unauthorized actors, resulting in the exposure of this information.
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.
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.