/

CVE-2026-45012

Severity:

HIGH RISK

(7.6)

Authenticated SSRF (CWE-918) in ApostropheCMS widgets

CVE-2026-45012

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal network access and data exfiltration via SSRF

Severity:

HIGH RISK

(7.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

ApostropheCMS suffers from an authenticated server-side request forgery issue in the rich-text widget import flow, where user-controlled URLs are fetched by the server during validation.

An authenticated user with permission to submit or edit rich-text widgets can coerce the CMS into making arbitrary outbound HTTP requests and, for image-like responses, persist and re-host the fetched content, enabling response exfiltration from reachable internal services.

Affected context

The vulnerability appears in ApostropheCMS deployments that expose rich-text widgets to authenticated users who can create or edit content.

During the import and validation flow for rich-text content, the application accepts user-provided URLs and has the server fetch those URLs directly, without sufficient restriction on the target.

Any environment where the CMS server can reach internal HTTP services, metadata endpoints, or otherwise sensitive network locations may be affected, especially when image-compatible responses can be stored and served back through Apostrophe.

Exploit preconditions

  • Attack surface: HTTP(S) interface of ApostropheCMS where authenticated users manage or edit rich-text widgets.
  • Required access: Valid authenticated account with the ability to submit or modify rich-text widget content (e.g., editor or similar role).
  • Trigger point: Supplying an attacker-controlled URL in the rich-text widget import flow so that validation or preview logic issues a server-side HTTP request.
  • Why exploitation is possible: The server trusts user-supplied URLs and performs outbound requests without strict allowlisting, network segmentation checks, or adequate validation of target hosts, enabling SSRF and potential persistence of image-like responses.

Why this happens

This issue stems from treating user-controlled URLs as safe to fetch from the server side during rich-text widget validation and import.

In SSRF patterns, the application inadvertently acts as an HTTP client on behalf of the user, bridging otherwise unreachable network locations because it does not sufficiently constrain where outbound requests may go.

Conceptually, this matches CWE-918: Server-Side Request Forgery, where server-side request mechanisms are exposed to user input without robust validation, allowlisting, or contextual access controls, allowing attackers to pivot into internal networks or services.

Potential impact

  • Discovery and interaction with internal HTTP services that are not directly exposed to users.
  • Exfiltration of sensitive responses that appear as image-compatible content and can be stored or re-hosted by Apostrophe.
  • Access to cloud instance metadata endpoints or management interfaces, where network paths permit.
  • Use of the CMS server as a proxy for further probing of internal network topology and available services.
  • Potential exposure of configuration details, API keys, or other secrets returned by reachable internal endpoints.

General mitigation guidance

Effective mitigation generally centers on reducing trust in user-supplied URLs and tightly constraining outbound requests from the server.

Common defensive patterns include:

  • Implementing strict allowlists for external domains or schemes that the application will contact, and rejecting all other targets by default.
  • Validating resolved IP addresses to block private, loopback, link-local, and other non-public ranges before performing any outbound request.
  • Isolating the CMS server in the network so that it cannot reach highly sensitive internal services or metadata endpoints, even if an HTTP client is abused.
  • Introducing layered validation for rich-text imports, ensuring that URL-handling logic is separate from general content processing and applies consistent policy checks.
  • Storing or re-hosting only content fetched from trusted sources, and avoiding automatic persistence of arbitrary remote responses.

How teams detect issues like this

Organizations can look for SSRF patterns through a combination of code analysis, configuration review, and runtime monitoring:

  • Static analysis: Flag code paths where user-controllable inputs flow into HTTP client libraries or URL-fetching utilities without explicit allowlist or network constraints.
  • Code review: Examine rich-text import and validation logic for places where URLs are fetched server-side, checking for hostname, IP range, and scheme validation, as well as DNS rebinding defenses.
  • Policy enforcement: Apply internal secure coding guidelines that require outbound-request wrappers with centralized filtering and logging, rather than ad-hoc HTTP calls.
  • Runtime observability: Monitor outbound requests from the CMS process, including unusual destinations (e.g., internal IP ranges, metadata endpoints), and set alerts on anomalous patterns.

Sources

SourceLink
github.comgithub.com/apostrophecms/apostrophe/security/advisories/GHSA-pr28-mf3q-qpg6

Frequently asked

questions

It is exploitable by remote users who can authenticate to ApostropheCMS and access rich-text widget editing. The SSRF itself targets internal or external resources that the CMS server can reach, not necessarily what is directly exposed to the public internet.

The attacker needs an authenticated account with permissions to create or modify rich-text widget content. Higher privileges are not strictly required if standard editorial roles have this capability.

The safest pattern is to centralize and constrain all server-side URL fetching behind a strict allowlist and robust network validation, ensuring that user-supplied URLs cannot point to internal or sensitive locations and that only explicitly trusted domains are reachable from the rich-text workflow.

Treat any user-influenced URL as untrusted, require defensive wrappers around HTTP-client usage, enforce network egress policies that block access to internal ranges from web-facing components, and incorporate SSRF-focused checks into code review and automated security testing pipelines.

Find out what's already
exploitable in your codebase.