/

CVE-2026-46697

Severity:

HIGH RISK

(7.5)

Server-Side Request Forgery (CWE-918) in Fediverse Embeds

CVE-2026-46697

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal data exposure and open proxy abuse via SSRF

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 the Fediverse Embeds WordPress plugin allowed any unauthenticated user to proxy arbitrary URLs through the site's backend.

By sending a base64-encoded URL to an unprotected REST endpoint, an attacker could force the server to fetch and return the full contents of internal or external resources, making the site act as a full-read open proxy.

Affected context

This vulnerability affects WordPress sites using the Fediverse Embeds plugin with the media proxy REST route enabled and exposed to unauthenticated visitors.

The issue manifests where the plugin's /ftf/media-proxy endpoint accepts attacker-controlled, base64-encoded URLs and forwards requests via wp_remote_get() without checking them against an allowlist of trusted Fediverse domains.

Any deployment where outbound HTTP(S) from the web server reaches internal services, metadata endpoints, or restricted resources becomes significantly more exposed under these conditions.

Exploit preconditions

  • Attack surface: Publicly accessible WordPress REST API endpoint /ftf/media-proxy
  • Required access: No authentication required; any anonymous visitor can send requests
  • Trigger point: Supplying a crafted base64-encoded URL parameter to the media proxy route
  • Why exploitation is possible: The route's permission_callback always returns true, the decoded URL is passed directly to wp_remote_get() without allowlist checks, and the full response body is echoed back, turning the server into a generic HTTP fetcher and responder

Why this happens

The core bug is an SSRF pattern where user-controlled URLs are fetched server-side without restriction and with their responses returned to the client.

Despite commentary in the source noting that URLs should be restricted to known Fediverse domains, the implemented validation only set a local $can_download_media flag that was never consulted, leaving the fetch logic effectively unguarded.

This aligns with CWE-918: Server-Side Request Forgery (SSRF), where the application acts as an unintended proxy, enabling attackers to leverage its network position and trust relationships to access resources they otherwise could not reach.

Potential impact

  • Attackers can coerce the server into fetching internal HTTP endpoints (e.g., admin panels, internal APIs, metadata services) that are not directly exposed to the internet
  • Sensitive information from internal or external endpoints can be read via the echoed response body
  • The website may be abused as an open proxy to anonymize and relay malicious traffic
  • Access to cloud instance metadata endpoints could potentially reveal credentials or configuration data, depending on network topology
  • Increased risk of secondary attacks such as internal service enumeration, request smuggling against downstream services, or chained exploitation with other weaknesses

General mitigation guidance

Effective mitigation focuses on tightly controlling where server-side HTTP requests can go and how they are triggered.

Common defensive patterns include:

  • Enforcing strict allowlists of permitted remote hosts or domains for any server-initiated HTTP requests
  • Avoiding direct use of user-supplied URLs; instead, mapping user selections to pre-approved endpoints or identifiers
  • Normalizing and validating URLs before use, including scheme, host, port, and path checks, and rejecting IP-literal or loopback addresses
  • Isolating outbound HTTP fetch functionality in low-privilege components or network segments with minimal reach into internal infrastructure
  • Applying defense-in-depth at the network layer (e.g., egress filtering, firewall rules) to block access from web-facing systems to sensitive internal or metadata endpoints

How teams detect issues like this

Detection efforts can combine code-centric and operational perspectives.

Helpful approaches include:

  • Static analysis rules that flag server-side HTTP calls (e.g., wp_remote_get, cURL, HTTP clients) when their target is derived from request parameters or other untrusted input without validation
  • Code review checklists that explicitly question any feature acting as a "proxy" or "media fetcher" and require clear host/domain allowlists
  • Security linters or WordPress-specific scanning tools that look for REST routes with permission_callback set to __return_true and that forward arbitrary URLs
  • Runtime monitoring and logging that track unusual outbound HTTP patterns, such as requests to internal IP ranges, metadata addresses, or unexpected external domains
  • WAF or reverse proxy rules that detect and throttle suspicious usage patterns of media proxy or fetch endpoints, especially with encoded URL parameters

Sources

SourceLink
github.comgithub.com/stefanbohacek/fediverse-embeds-wordpress-plugin/commit/2f021faf4dadaccef67eda7b81a0b7ceaef450df
github.comgithub.com/stefanbohacek/fediverse-embeds-wordpress-plugin/security/advisories/GHSA-mpq6-hjh3-m543

Frequently asked

questions

Yes. Any remote, unauthenticated user who can reach the WordPress site's REST API can exploit the endpoint to make the server perform HTTP requests and return the response data.

No login is required. The route was registered with a permission callback that always grants access, so anonymous visitors can supply arbitrary base64-encoded URLs.

The safest approach is to restrict server-side HTTP requests to a well-defined set of allowed domains or resources, ensure that URL inputs cannot point to arbitrary hosts, and apply robust permission checks on any REST endpoints that proxy or fetch remote content.

Treat any functionality that performs server-side HTTP requests as security-sensitive, require explicit allowlists and URL validation during design and code review, avoid exposing generic proxy-like endpoints, and reinforce these expectations with automated checks in CI and periodic security reviews.

Find out what's already
exploitable in your codebase.