/

CVE-2026-39397

Severity:

CRITICAL RISK

(9.4)

Missing Authorization in Payload Puck CRUD API Endpoints

CVE-2026-39397

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation and Unauthorized Data Access/Modification

Severity:

CRITICAL RISK

(9.4)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

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 access configuration passed to createPuckPlugin() 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 access option passed into createPuckPlugin().

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 access options.
  • 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 access options 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.

Sources

SourceLink
github.comgithub.com/delmaredigital/payload-puck/commit/9148201c6bbfa140d44546438027a2f8a70f79a4
github.comgithub.com/delmaredigital/payload-puck/issues/7
github.comgithub.com/delmaredigital/payload-puck/security/advisories/GHSA-65w6-pf7x-5g85

Frequently asked

questions

Yes. If the /api/puck/* endpoints are reachable over the network, an attacker can remotely invoke them and perform actions that should normally be restricted by collection-level access rules.

Not necessarily. The requirement depends on how the host application routes and protects /api/puck/*. If those routes are accessible without authentication, an unauthenticated attacker may be able to perform privileged CRUD operations; if they require login, any authenticated user may gain more power than intended.

The safest pattern is to remove any unconditional access overrides from HTTP handlers and ensure that all plugin endpoints delegate to the standard authorization layer. Endpoints should respect both collection-level access rules and explicit access options provided to the plugin, defaulting to least privilege.

Adopt a design where authorization is centralized and mandatory for all routes, including those introduced by plugins. During development and code review, flag any use of global override flags for access control, enforce security tests around new API endpoints, and maintain documentation that clearly maps which roles can access which integration routes.

Find out what's already
exploitable in your codebase.