/

CVE-2026-34746

Severity:

HIGH RISK

(7.7)

SSRF in Payload CMS Upload Functionality

CVE-2026-34746

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network Pivoting and Access to Internal Resources via SSRF

Severity:

HIGH RISK

(7.7)

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

An authenticated Server-Side Request Forgery (SSRF) vulnerability in Payload CMS's upload functionality allows users with create or update access on upload-enabled collections to trigger arbitrary outbound HTTP requests from the server.

When exploited, this can be used to reach internal or otherwise restricted network resources that are not directly accessible to the attacker's client.

Affected context

The vulnerability manifests in Payload CMS deployments where:

  • Upload-enabled collections are configured and actively used
  • Authenticated users can create or update records that involve file uploads or related metadata
  • The upload workflow can influence or construct server-side HTTP requests (for example, to fetch remote files or validate URLs)

In such setups, values controlled by authenticated users can be embedded into outbound requests, enabling SSRF when not properly constrained.

Exploit preconditions

  • Attack surface: Application endpoints handling uploads for upload-enabled collections in Payload CMS
  • Required access: Valid authenticated account with create and/or update permissions on at least one upload-enabled collection
  • Attacker control: Ability to supply or influence fields/parameters in the upload workflow that the server uses to construct outbound HTTP requests
  • Trigger point: Submission of crafted upload requests that cause the CMS to perform HTTP calls to attacker-specified URLs
  • Why exploitation is possible: The server trusts user-influenced data when generating outbound HTTP requests and does not sufficiently restrict target destinations (e.g., internal IP ranges, metadata services, or arbitrary domains).

Why this happens

This issue is rooted in CWE-918: Server-Side Request Forgery (SSRF), where user-controlled input is used to construct server-initiated HTTP requests.

In the abstract pattern, the server:

  • Accepts user-supplied URLs or URL components as part of normal application workflows (e.g., uploads, remote file retrieval, or URL validation),
  • Uses them directly to initiate outbound HTTP connections,
  • Lacks robust validation or allowlisting of reachable hosts, schemes, or network locations.

Because the CMS runs within a more privileged network position than the user's browser, the attacker can leverage this trust to pivot into internal services, cloud metadata endpoints, or other restricted targets.

Potential impact

  • Access to internal HTTP(S) services that are not exposed to the public internet
  • Discovery of internal network architecture and service behavior via response timing, status codes, or content
  • Interaction with cloud metadata endpoints, which can in some environments expose credentials or instance configuration
  • Use of the application server as a proxy to bypass network access controls or IP-based restrictions
  • Potential stepping stone toward more severe attacks (e.g., chaining SSRF with weaknesses in internal services)

General mitigation guidance

Effective mitigation focuses on treating any user-influenced URL or remote resource reference as untrusted and constraining where the server can connect.

Recommended design patterns include:

  • Strict network-level egress controls: Restrict the application server's outbound traffic so it can only reach explicitly required upstream services, not arbitrary hosts or internal subnets.
  • URL allowlisting: Only permit outbound connections to vetted, well-defined domains or endpoints needed for business logic; reject or normalize all other destinations.
  • Denylisting sensitive targets: As a defense-in-depth layer, actively block known sensitive ranges such as link-local addresses, private IP ranges, and cloud metadata endpoints.
  • Scheme and protocol validation: Accept only safe schemes (e.g., https) and disallow dangerous or unexpected protocols.
  • Separation of privileges: Run the CMS in a network segment and with credentials that minimize the blast radius if outbound HTTP requests are abused.
  • Input normalization and parsing: Parse and normalize URLs with robust libraries, and re-validate the normalized form, to avoid bypasses through URL encoding tricks.

How teams detect issues like this

Organizations can detect and monitor SSRF risks in Payload CMS and similar applications through:

  • Static analysis and code review:
  • Look for use of HTTP client libraries (e.g., fetch, axios, requests, node-fetch, etc.) where request URLs or hosts are derived from request parameters, body fields, or upload metadata.
  • Flag patterns where user input is concatenated into URLs without centralized validation/allowlisting.
  • Establish coding standards that require all outbound HTTP calls to pass through a vetted, shared helper that enforces network and host restrictions.
  • Dynamic analysis and testing:
  • Include SSRF test cases in security testing by providing internal-reserved or special IPs and domains to endpoints that issue server-side requests.
  • Use specialized security scanners that probe for SSRF behavior.
  • Operational monitoring:
  • Inspect outbound traffic patterns from the CMS host for unusual destinations (e.g., internal IPs, metadata endpoints, or previously unseen domains).
  • Apply logging around outbound HTTP calls and alert on connections to disallowed ranges or domains.

Sources

SourceLink
github.comgithub.com/payloadcms/payload/releases/tag/v3.79.1
github.comgithub.com/payloadcms/payload/security/advisories/GHSA-6r7f-q7f5-wpx8

Frequently asked

questions

It can be triggered remotely, but only by authenticated users who have the necessary permissions on upload-enabled collections. Unauthenticated users cannot directly exploit it in typical configurations.

The attacker must have a valid account with create or update rights for at least one collection that supports uploads. They do not need administrative access, but their role must allow them to trigger the upload workflow.

Centralize all outbound HTTP calls behind a strict validation layer that enforces allowlisted hosts and schemes, and couple this with network-level egress restrictions. Avoid building URLs directly from user input, and ensure any necessary user-influenced URLs are rigorously validated against a narrow set of permitted destinations.

Treat any user-controlled URL or remote resource reference as untrusted, design outbound request logic around allowlists and network segmentation, and enforce these patterns via code review and automated checks. Integrate security testing for SSRF into the development lifecycle so that new endpoints involving remote resource fetching are automatically scrutinized.

Find out what's already
exploitable in your codebase.