/

CVE-2026-26801

Severity:

HIGH RISK

(7.5)

Server-Side Request Forgery (SSRF) in pdfmake URLResolver

CVE-2026-26801

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Information Disclosure via Server-Side Network Access

Severity:

HIGH RISK

(7.5)

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) flaw in pdfmake's URLResolver component allows remote attackers to trigger server-side HTTP requests to arbitrary URLs when untrusted input is used to resolve external resources.

In server-side deployments that do not restrict which URLs pdfmake may access, an attacker can abuse document content to probe internal services or retrieve sensitive information over the network.

Affected context

This vulnerability occurs when pdfmake is used in a server-side or backend rendering context and is configured (implicitly or explicitly) to resolve external URLs, such as images or other remote assets, using src/URLResolver.js.

The risk is present when user-controlled or otherwise untrusted data can influence which URLs are fetched and there is no effective URL access policy limiting outbound requests.

Environments with accessible internal services (e.g., microservices, metadata endpoints, or admin panels) on the same network as the pdfmake process are particularly exposed.

Exploit preconditions

  • Attack surface: PDF generation endpoints or services that accept user input (templates, document definitions, or resource URLs) and render PDFs using pdfmake.
  • Required access: Ability to submit or control the content used by pdfmake—typically via HTTP requests to an API, web form, or message queue feeding the PDF generation service.
  • Trigger point: Any code path where pdfmake resolves external URLs (for images or other resources) through URLResolver without a restrictive access policy.
  • Why exploitation is possible: The URL resolution logic issues outbound requests based on attacker-influenced URLs without enforcing strict network or host allow/deny rules, enabling the server to be used as a blind or reflective proxy to internal or otherwise protected endpoints.

Why this happens

The root cause aligns with CWE-918: Server-Side Request Forgery (SSRF): the application makes network requests on behalf of users to attacker-controlled URLs without adequate validation or policy enforcement.

In pdfmake, the URLResolver component is designed to fetch external resources referenced in document definitions.

When untrusted input controls these URLs and no explicit access policy is applied, the server runs arbitrary HTTP requests from a trusted network position, inadvertently extending its own network reach to the attacker.

This pattern reflects a broader design issue where server-side resource fetchers inherit full network privileges but are not constrained by domain, scheme, or IP-based rules.

Potential impact

  • Access to internal HTTP(S) services that are not directly exposed to the internet.
  • Retrieval of sensitive data from internal APIs, configuration endpoints, or cloud metadata services.
  • Use of the pdfmake host as a proxy to scan internal networks (e.g., port scanning or service enumeration).
  • Possible interaction with administrative interfaces that trust internal network traffic, potentially leading to further compromise depending on those services' behavior.

General mitigation guidance

Mitigation typically focuses on strictly controlling outbound requests from server-side PDF rendering and treating all URL inputs as untrusted:

  • Introduce an explicit URL access policy for all server-side URL resolution, using allowlists for domains, schemes, and paths instead of general-purpose fetching.
  • Validate and sanitize any user-influenced URLs before they reach the PDF generation layer, rejecting or normalizing unexpected schemes (e.g., file:, gopher:, custom protocols) and private IP ranges where appropriate.
  • Architect the PDF rendering service to run in a network segment with minimal access—ideally isolating it from sensitive internal services and metadata endpoints.
  • Apply network-level controls (firewalls, egress filters, service meshes) so that the rendering process can only reach known, necessary destinations.
  • Prefer serving required assets (such as images) from a pre-approved, internal asset store or CDN, referenced by opaque identifiers instead of raw URLs supplied by clients.

How teams detect issues like this

Effective detection combines code-centric and environment-centric analysis:

  • Static analysis & code review: Flag patterns where server-side pdfmake usage passes user-controlled URLs to URL resolution logic without validation or access control.
  • Configuration review: Examine PDF generation services to verify that a URL access policy or equivalent restrictions are defined and enforced; absence of such controls is a red flag.
  • Network monitoring: Monitor outbound HTTP(S) traffic from PDF rendering hosts for unusual destinations, such as internal IP ranges, cloud metadata endpoints, or non-standard ports.
  • Logging & telemetry: Ensure that URL resolution attempts (including blocked ones) are logged with sufficient detail to identify suspicious patterns, such as repeated access to internal or unexpected hosts.
  • Security testing: Incorporate SSRF-focused tests into application security assessments, attempting to influence pdfmake resource URLs and observing whether internal resources become reachable.

Sources

SourceLink
github.comgithub.com/bpampuch/pdfmake
github.comgithub.com/bpampuch/pdfmake/blob/master/src/URLResolver.js
github.comgithub.com/bpampuch/pdfmake/pull/2920
github.comgithub.com/bpampuch/pdfmake/releases/tag/0.3.6
mariopepe.github.iomariopepe.github.io/cve-2026-26801-pdfmake-ssrf

Frequently asked

questions

Yes. If an external user can influence document content or resource URLs used by a server-side pdfmake instance, they can remotely trigger server-side requests within the hosting environment.

The attacker typically only needs the ability to supply or control the PDF content, template, or parameters that pdfmake uses—commonly via a web API or form that generates PDFs on demand.

Implement a strict URL access policy for all server-side URL resolution, limiting destinations to a narrow, documented allowlist and rejecting anything outside those rules, alongside running the rendering service in a tightly constrained network environment.

Treat any server-side component that makes outbound network calls on behalf of users as a high-risk boundary, enforce input validation and explicit allowlists for destinations, and use network and architectural isolation so that such components cannot freely reach sensitive internal services.

Find out what's already
exploitable in your codebase.