Severity:

HIGH RISK

(7.2)

SSRF in WordPress Webmention Plugin Author Parsing

CVE-2026-0686

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Network pivoting and unauthorized interaction with internal or protected services via SSRF

Severity:

HIGH RISK

(7.2)

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

The Webmention plugin for WordPress contains a Server-Side Request Forgery (SSRF) vulnerability in the MF2::parse_authorpage code path, reachable via the Receiver::post function.

Unauthenticated attackers can cause the WordPress server to initiate arbitrary outbound HTTP requests, which may allow querying or modifying data on internal services that are not otherwise exposed.

Affected context

This vulnerability occurs in WordPress sites that have the Webmention plugin enabled and accept incoming Webmention requests.

The issue is present in the logic that processes incoming Webmention posts, where the plugin retrieves and parses remote author pages.

Because target URLs in Webmention payloads are not strictly constrained to safe destinations, an attacker-controlled URL can cause the server to perform HTTP requests to arbitrary endpoints, including internal network resources or metadata services, depending on the environment's network topology and filtering.

Exploit preconditions

  • Attack surface: Public Webmention endpoint exposed by a WordPress site using the vulnerable plugin.
  • Required access: No authentication; the attacker only needs the ability to send crafted HTTP requests to the Webmention receiver.
  • Trigger point: Submission of a Webmention that causes Receiver::post to call MF2::parse_authorpage with attacker-controlled URLs.
  • Why exploitation is possible: The plugin treats user-supplied URLs as trusted targets for server-side HTTP requests, without sufficient restrictions on destination hosts, schemes, or network ranges, enabling SSRF into arbitrary or internal locations.

Why this happens

The underlying issue aligns with CWE-918: Server-Side Request Forgery (SSRF).

The Webmention plugin's author-parsing workflow is designed to fetch and analyze remote pages referenced in Webmention payloads.

In doing so, it uses attacker-controlled URLs as direct inputs to server-side HTTP client code without:

  • Enforcing strict allowlists (e.g., limiting to public HTTP/HTTPS targets),
  • Blocking access to internal address spaces (e.g., 127.0.0.0/8, RFC1918 ranges, link-local, metadata IPs),
  • Or normalizing and validating redirects.

This pattern of issuing outbound requests based on untrusted user input is a classic SSRF anti-pattern, allowing the application server to act as a proxy into otherwise unreachable resources.

Potential impact

  • May allow attackers to probe and enumerate internal network services (port scanning via HTTP responses).
  • Could enable unauthorized access to internal HTTP-based APIs, dashboards, or admin endpoints.
  • May allow reading sensitive internal metadata, configuration endpoints, or cloud instance metadata where accessible.
  • Could be used to trigger state-changing operations on internal services that trust the WordPress server's IP.
  • Can facilitate partial network pivoting, potentially aiding further compromise beyond the WordPress application.

General mitigation guidance

Effective mitigation focuses on constraining outbound requests and reducing trust in user-supplied URLs in the Webmention processing pipeline.

Defensive patterns include:

  • Enforcing a strict allowlist of domains or URL patterns that the plugin will contact, rather than accepting arbitrary destinations.
  • Blocking or rejecting URLs that resolve to:
  • Private, loopback, link-local, or multicast IP ranges,
  • Non-HTTP/HTTPS schemes,
  • Or dynamically resolved internal hostnames.
  • Performing DNS resolution and IP checks before making HTTP requests, and repeating checks after redirects, dropping any unsafe targets.
  • Using a hardened HTTP client abstraction that centrally enforces network egress policies and host validation, rather than raw low-level request calls.
  • Isolating outbound HTTP requests into a constrained network segment or egress proxy that cannot reach sensitive internal or metadata services, and operates under least-privilege network rules.
  • Treating incoming Webmention data as untrusted input, with explicit validation and normalization of URLs before use.

How teams detect issues like this

Detection is typically based on identifying untrusted URLs being used as direct arguments to HTTP client calls in Webmention handling code.

Practical strategies include:

  • Static analysis:
  • Rules that flag HTTP requests (e.g., wp_remote_get, cURL, Guzzle, or similar) where the URL originates from request parameters or Webmention payloads without intervening validation or allowlist checks.
  • Data-flow analysis tracing inputs from Receiver::post or comparable entry points into network functions.
  • Code review cues:
  • Any logic fetching "author pages", "callback URLs", or "remote content" supplied by external sites.
  • Absence of domain/IP allowlisting, scheme checks, or private-address blocking nearby.
  • Reliance on user-provided URLs combined with automatic redirect-following.
  • Runtime monitoring:
  • Application or WAF logs indicating outbound requests to unusual or internal-looking hosts following Webmention submissions.
  • Network monitoring or egress proxy logs highlighting the WordPress host making requests to internal IP ranges.
  • Policy and tooling:
  • CI pipelines that enforce network-safety linting for request-issuing helpers.
  • Optional use of application security testing tools configured with SSRF-specific rules targeting URL-handling paths.

Sources

SourceLink
github.comgithub.com/pfefferle/wordpress-webmention/blob/057223cee18a9e93b017d0f21db6ea77a7686489/includes/handler/class-mf2.php#L878
plugins.trac.wordpress.orgplugins.trac.wordpress.org/browser/webmention/tags/5.6.2/includes/class-receiver.php#L260
plugins.trac.wordpress.orgplugins.trac.wordpress.org/browser/webmention/tags/5.6.2/includes/handler/class-mf2.php#L877
plugins.trac.wordpress.orgplugins.trac.wordpress.org/changeset/3494831/webmention
wordfence.comwordfence.com/threat-intel/vulnerabilities/id/08d15c46-d15f-4803-80be-90bf33335c18?source=cve

Frequently asked

questions

Yes. The attack surface is the public Webmention endpoint; unauthenticated attackers can send crafted Webmention requests that cause the server to make outbound HTTP requests on their behalf.

No. Exploitation does not require authentication as long as the Webmention endpoint is reachable. The attacker only needs network access to the site and the ability to submit Webmention payloads.

The safest pattern is to never issue server-side HTTP requests to arbitrary user-supplied URLs. Instead, strictly validate and constrain destinations using allowlists, block access to private/internal ranges, and centralize outbound request logic behind a hardened, policy-enforcing client.

Adopt a design policy that treats all external URLs as untrusted data: validate schemes and hosts, restrict to known-safe domains, enforce IP-range checks, and route all outbound traffic through controlled egress layers. Combine these patterns with code review checklists and automated static analysis focused on network calls sourced from user input.

Find out what's already
exploitable in your codebase.