/

CVE-2026-42595

Severity:

HIGH RISK

(8.6)

SSRF in Gotenberg Chromium URL-to-PDF Endpoint

CVE-2026-42595

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access via SSRF

Severity:

HIGH RISK

(8.6)

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

Gotenberg's Chromium URL-to-PDF endpoint allows unauthenticated users to make HTTP/HTTPS requests to arbitrary internal network resources and receive the responses rendered as PDFs.

Because the default deny-list only blocks file:// URIs and redirect targets are not re-validated, an attacker can abuse the service as an SSRF proxy to reach loopback, private IP ranges, and cloud metadata endpoints.

Affected context

This vulnerability affects Gotenberg deployments that expose the Chromium URL-to-PDF endpoint (/forms/chromium/convert/url) and rely on its default or deny-list–based protections.

The issue is most relevant when:

  • Gotenberg is reachable from untrusted networks (e.g., the public internet or multi-tenant environments).
  • Gotenberg can reach internal services, private RFC 1918 address ranges, or cloud provider metadata endpoints.
  • Operators use deny-lists instead of strict allow-lists, and redirects from external sites to internal IPs are possible.

In such setups, the Chromium engine effectively becomes a network client that attackers can steer toward sensitive internal targets.

Exploit preconditions

  • Attack surface: The /forms/chromium/convert/url HTTP endpoint exposed by the Gotenberg service.
  • Required access: Network access to the Gotenberg API; no authentication is required by default for this specific behavior.
  • Trigger point: Submitting a conversion request that supplies a URL under attacker control, optionally chaining one or more HTTP redirects.
  • Why exploitation is possible:
  • The default deny-list only blocks file:// URIs, leaving HTTP/HTTPS-based internal targets reachable.
  • Even when a custom deny-list is configured, Chromium follows 302-style redirects from attacker-controlled URLs to internal destinations.
  • Redirect destinations are not re-validated against the deny-list, so internal IPs and metadata endpoints can still be reached.

Why this happens

The underlying issue is a classic Server-Side Request Forgery pattern where a server-side HTTP client is allowed to fetch arbitrary URLs without robust origin controls.

In this case, Gotenberg's Chromium instance:

  • Accepts user-supplied URLs from an externally exposed API.
  • Uses a deny-list model that, by default, only blocks file:// schemes.
  • Does not consistently enforce URL validation across the full request lifecycle, notably after HTTP redirects.

This maps to CWE-918: Server-Side Request Forgery (SSRF), where the server becomes a proxy to internal resources because input URLs and redirect targets are not constrained to a safe, pre-defined set of destinations.

Potential impact

  • Access to internal web applications and APIs that are not otherwise exposed to the attacker.
  • Retrieval of data from loopback services running on 127.0.0.1 or other local interfaces.
  • Extraction of cloud instance metadata (e.g., IAM credentials, tokens, configuration) from metadata endpoints.
  • Network mapping of internal IP ranges and identification of live services or open ports via behavioral differences.
  • Potential pivot to further attacks if internal endpoints expose unauthenticated or weakly protected functionality.

General mitigation guidance

Effective mitigation typically focuses on constraining where server-side HTTP clients are allowed to connect and reducing the trust placed in user-supplied URLs.

General defensive patterns include:

  • Adopt allow-listing over deny-listing: Restrict outbound requests to a curated set of hostnames or domains that are known to be safe, instead of trying to block known-bad patterns.
  • Enforce validation after redirects: Ensure that every effective request URL, including post-redirect destinations, is validated against the same safety policy as the original URL.
  • Constrain network egress: Use firewall rules, container network policies, or service meshes to block access from Gotenberg to sensitive IP ranges (e.g., 169.254.169.254, RFC 1918 space) unless strictly needed.
  • Segregate deployment and privileges: Run Gotenberg in a network segment with limited reachability to internal control planes and critical back-end services, and avoid granting it access tokens or credentials that are not necessary for PDF generation.
  • Harden default configuration: Prefer secure-by-default settings that minimize open-ended URL fetching, including optional authentication and rate-limiting in front of the conversion endpoint.

How teams detect issues like this

Identifying and monitoring SSRF patterns generally involves a mix of code-level and runtime techniques:

  • Static analysis and code review:
  • Flag components that fetch URLs derived from client input, especially in PDF converters, screenshot services, or other headless browser integrations.
  • Verify that URL validation routines cover schemes, hosts, ports, and IP ranges, and that they are applied consistently before and after redirects.
  • Look for reliance on simple deny-lists or regex-based URL filters without complementary network controls.
  • Configuration and policy checks:
  • Enforce policies that require allow-lists for outbound HTTP traffic from services that process untrusted URLs.
  • Review container orchestration and firewall rules to ensure sensitive internal ranges and metadata services are not routable from the conversion service.
  • Runtime monitoring:
  • Log outbound requests made by Gotenberg (destination host, IP, and path) and alert on requests to internal or unexpected networks.
  • Use anomaly detection to identify unusual patterns such as repeated requests to metadata endpoints or sequential scanning of IP ranges.
  • Automated tooling:
  • Employ security scanners and CI checks that specifically test SSRF surfaces by attempting to reach canary endpoints or internal IP markers via URL-based features.

Sources

SourceLink
github.comgithub.com/gotenberg/gotenberg/security/advisories/GHSA-chwh-f6gm-r836

Frequently asked

questions

Yes, if the Gotenberg API is exposed to the internet or other untrusted networks, an attacker can exploit this SSRF remotely by sending crafted requests to the Chromium URL-to-PDF endpoint.

In typical configurations described by this issue, no authentication is required to trigger the behavior; the attacker only needs network access to the vulnerable endpoint. However, if operators have placed Gotenberg behind an authentication or gateway layer, those controls can raise the bar for exploitation.

The most robust pattern is to enforce strict allow-listing of outbound destinations and to re-validate every effective URL after redirects. Combining this with network-layer egress controls and hardened defaults dramatically reduces SSRF risk, independent of implementation details.

When designing features that fetch external URLs, assume that all URLs supplied by clients are untrusted. Use allow-lists, comprehensive URL and redirect validation, and network segmentation from the outset. Additionally, incorporate SSRF-focused checks into code review, threat modeling, and automated security testing so that risky patterns are addressed before deployment.

Find out what's already
exploitable in your codebase.