Summary
The PayloadCMS Puck plugin exposed CRUD endpoints under /api/puck/* that invoked Payload's local API with overrideAccess: true, effectively bypassing all collection-level access control.
As a result, access rules supplied to createPuckPlugin() and access policies on Puck-registered collections were ignored, allowing unauthorized callers to perform privileged operations where these endpoints were reachable.
Affected context
This vulnerability affects applications using the @delmaredigital/payload-puck plugin in PayloadCMS where:
- The Puck visual page builder is integrated via
createPuckPlugin() - CRUD routes are automatically registered under
/api/puck/* - These routes are exposed to users or services that should be subject to access control
In these setups, the plugin's handlers called the Payload local API with overrideAccess: true, causing normal collection access rules and plugin-level access options to be skipped for those endpoints.
Exploit preconditions
- Attack surface: HTTP API endpoints registered under
/api/puck/*(e.g., create, read, update, delete operations for Puck-managed data). - Required access: Ability to send HTTP requests to the affected endpoints (e.g., network access to the application, potentially even as an unauthenticated or low-privileged user depending on routing and middleware).
- Trigger point: Invoking the vulnerable CRUD handlers, which internally call the Payload local API with
overrideAccess: true. - Why exploitation is possible: The plugin forces access control bypass at the framework level, so collection-level access rules and the
accessconfiguration passed tocreatePuckPlugin()are never evaluated for/api/puck/*requests.
Why this happens
The root cause is a logic flaw in authorization handling, mapped to CWE-862: Missing Authorization.
Instead of delegating to Payload's standard access-control evaluation, the plugin's CRUD handlers explicitly invoked the local API with overrideAccess: true.
This design treats every request to /api/puck/* as implicitly trusted, ignoring both:
- Collection-level access rules defined in the Payload configuration, and
- Any
accessoption passed intocreatePuckPlugin().
The bug is not in permission checks themselves, but in bypassing them entirely for this integration, creating a hidden privileged path.
Potential impact
- Unauthorized reading of content and configuration from Puck-registered collections
- Unauthorized creation, modification, and deletion of Puck-managed pages or components
- Escalation from a low-privileged or unauthenticated role to effective admin-level control over Puck content
- Defacement of sites, injection of malicious content, or disruption of page layout and navigation
- Indirect compromise of users through manipulated content (e.g., phishing pages, malicious redirects)
General mitigation guidance
Mitigation generally centers on restoring strong, consistent authorization and minimizing blind trust in internal APIs:
- Ensure that integration points (like plugins) do not use override flags that bypass standard access control in the underlying CMS/framework.
- Route all CRUD operations for Puck-managed collections through the same access-control layer as other collections, honoring collection-level policies and plugin
accessoptions. - Prefer a secure-by-default approach where endpoints inherit restrictive access rules, and any temporary elevation requires explicit, narrowly scoped logic.
- Introduce a clear separation between internal, highly privileged APIs and public or semi-public routes; avoid exposing internal override capabilities to HTTP handlers.
- Apply least privilege to any service accounts, API keys, or roles used by page-builder tools, so even if an endpoint is misconfigured, impact is reduced.
How teams detect issues like this
Detection efforts can focus on configuration analysis, code review, and runtime monitoring:
- Static/code review:
- Search for usage of privileged flags (e.g.,
overrideAccess: true) in HTTP request handlers or plugin code. - Verify that all public routes and plugin endpoints explicitly enforce or delegate to unified access-control mechanisms.
- Check for discrepancies where routes under
/api/puck/*(or similar prefixes) omit authentication or authorization middleware. - Configuration review:
- Compare documented access rules for Puck-managed collections against what is actually enforced on exposed routes.
- Review plugin configuration to ensure
accessoptions are honored and not short-circuited. - Runtime/operational monitoring:
- Log and audit CRUD operations performed via
/api/puck/*endpoints, correlating requests with authenticated identities and expected permissions. - Use anomaly detection to identify unusual write/delete activity on Puck collections, especially from unauthenticated or low-privileged clients.
- Automated security testing and SAST tools can be configured to flag patterns where internal APIs are invoked with global access overrides from user-exposed code paths.

