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.

