/

CVE-2026-45806

Severity:

HIGH RISK

(7.7)

SSRF (CWE-918) via Remote Image Import in Penpot

CVE-2026-45806

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Access to internal network resources and potential data exposure via forged backend HTTP requests

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

A server-side request forgery (SSRF) vulnerability in Penpot's remote image import feature allows authenticated file editors to cause the backend to make HTTP requests to arbitrary URLs.

By controlling the image URL, an attacker can pivot the shared HTTP client toward internal-only endpoints, becoming risky wherever internal services are accessible over HTTP from the Penpot server.

Affected context

The vulnerability occurs in Penpot deployments where the remote image import functionality is enabled and the backend HTTP client can reach internal network endpoints.

It manifests when user-supplied URLs from the frontend are forwarded to the backend RPC layer without sufficient destination validation or filtering.

Risk increases in environments where the Penpot server shares a network with sensitive services (e.g., admin APIs, metadata endpoints, or internal HTTP applications).

Exploit preconditions

  • Attack surface: Remote image import feature exposed to authenticated users with file editor permissions.
  • Required access: Valid authenticated session and ability to edit a file or workspace that permits importing remote images.
  • Trigger point: Supplying a crafted URL to the image import flow, which is forwarded to :create-file-media-object-from-url and then to media/download-image.
  • Why exploitation is possible: The shared HTTP client performs outbound requests without destination filtering or network segmentation, enabling user-controlled URLs to target internal-only HTTP endpoints.

Why this happens

This issue stems from trusting a user-controlled URL when performing backend HTTP requests, a classic CWE-918: Server-Side Request Forgery pattern.

The remote image import workflow propagates the URL from the frontend into backend RPC code, where a shared HTTP client fetches the resource without validating whether the destination is external, safe, or allowed.

Conceptually, the bug class is an "unrestricted backend fetch" of attacker-specified URLs, allowing the server to act as an unwilling proxy to internal infrastructure or cloud metadata services.

Potential impact

  • An attacker may reach internal-only HTTP services that are not directly exposed to the internet.
  • Attackers could enumerate or access sensitive information from admin APIs or internal dashboards reachable from the Penpot server.
  • The vulnerability can allow probing of network topology or internal hosts through timing and error responses.
  • Under certain configurations, attackers could access cloud instance metadata or service credentials exposed via HTTP.
  • The issue may facilitate further lateral movement if internal endpoints accept requests from the application server.

General mitigation guidance

Mitigation focuses on constraining where the backend can send HTTP requests and reducing trust in user-provided URLs.

Recommended design patterns include:

  • Implement strict allowlists or blocklists for outbound destinations on remote fetch functionality.
  • Enforce URL validation that rejects private IP ranges, loopback addresses, link-local ranges, and internal hostnames.
  • Separate HTTP clients or outbound routes so that user-driven fetches cannot reach sensitive services.
  • Apply network-level egress controls and segmentation, ensuring application servers cannot directly contact high-value internal APIs.
  • Log and monitor remote fetch operations and failures to detect anomalous internal probing behavior.

How teams detect issues like this

High-level detection approaches include:

  • Static analysis or manual code review to identify patterns where user-supplied URLs are used in backend HTTP clients without destination filtering.
  • Searching for functions that accept arbitrary URLs and feed them to shared HTTP client utilities, particularly in media or import workflows.
  • Policy enforcement that requires URL normalization and checks against reserved IP ranges or internal hostnames before any server-side fetch.
  • Runtime monitoring of outbound HTTP requests from the application, flagging requests to internal IP ranges or unexpected hosts initiated by user actions.
  • Integration of automated security review tools that highlight HTTP client usage driven by untrusted input.

Sources

SourceLink
github.comgithub.com/penpot/penpot/releases/tag/2.15.0
github.comgithub.com/penpot/penpot/security/advisories/GHSA-35g2-w7f6-8v9h

Frequently asked

questions

Yes, in typical deployments an attacker can exploit it remotely, but they must be an authenticated file editor within the Penpot instance to submit crafted image URLs.

The attacker needs a valid authenticated account with permissions to edit files or workspaces and use the remote image import feature; no direct shell or infrastructure access is required.

The safest pattern is to enforce strict destination validation on all user-controlled URLs, disallowing internal address ranges and sensitive hostnames, and to restrict outbound network access so user-driven fetches cannot reach protected services.

Adopt a design where backend HTTP clients never operate on raw, unvalidated user input; use centralized URL validation, maintain egress filtering policies, separate network zones, and include SSRF checks in code review and automated security testing pipelines.

Find out what's already
exploitable in your codebase.