/

CVE-2026-61520

Severity:

HIGH RISK

(7.7)

SSRF (CWE-918) in SMF Image Proxy Internal Requests

CVE-2026-61520

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Access and Service Interaction

Severity:

HIGH RISK

(7.7)

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

Simple Machines Forum (SMF) contains a server-side request forgery vulnerability in its image proxy feature that allows authenticated users to make the forum server fetch attacker-controlled URLs.

By embedding crafted image BBCode tags, an attacker can cause SMF to proxy internal HTTP requests to private or loopback addresses, potentially reaching services that are not directly exposed to the internet.

Affected context

This vulnerability appears in SMF 2.1 prior to commit 4bf35cf and 3.0 prior to commit b4d23df when the image proxy is enabled and used to fetch remote images embedded in posts.

The proxy logic trusts the resolved destination of user-supplied image URLs in BBCode without restricting access to private, loopback, or link-local IP ranges.

In deployments where the SMF server can reach internal services—such as cloud metadata endpoints, internal admin panels, container network APIs, or other backend web services—those services may be reachable through the proxy mechanism.

Exploit preconditions

  • Attack surface: SMF web application with the image proxy feature handling external image URLs embedded in BBCode.
  • Required access: Ability to create or edit content containing image tags (e.g., authenticated forum user with posting privileges).
  • Trigger point: Rendering or processing of posts with [img] BBCode, which causes the server-side proxy to fetch the referenced URL.
  • Why exploitation is possible: The proxy:
  • Generates valid HMAC signatures for arbitrary attacker-chosen image URLs.
  • Does not validate the final resolved IP address against private, loopback, or link-local ranges.
  • Allows outbound HTTP requests to destinations that may be reachable only from the forum server's network context.

Why this happens

The underlying issue is a classic server-side request forgery pattern: user-controlled URLs are used to drive server-initiated HTTP requests without robust network-level validation.

SMF's image proxy takes untrusted input (image URLs in BBCode) and, after signing them with an HMAC for integrity, fetches them directly from the server.

Because the proxy logic validates only the signature and general URL format, but not the resolved IP address or network segment, attackers can redirect the server to internal resources.

This behavior maps directly to CWE-918: Server-Side Request Forgery (SSRF), where an application acts as an HTTP client on behalf of a user and can be coerced into contacting unintended internal services.

Potential impact

  • Access to cloud instance metadata endpoints, which could expose credentials, tokens, or configuration data.
  • Interaction with internal admin or management interfaces that are not publicly reachable.
  • Discovery or enumeration of internal network services and open ports via response behavior.
  • Potential pivoting into container or service meshes by hitting internal HTTP APIs.
  • Leakage of sensitive internal data returned in proxied responses, depending on how SMF handles and caches fetched images.

General mitigation guidance

Effective mitigation focuses on hardening server-side outbound request handling, particularly for proxy features:

  • Introduce strict allow/deny lists for outbound HTTP destinations, blocking private, loopback, link-local, and other internal address ranges at the application layer.
  • Resolve hostnames and validate both the hostname and resulting IP address against restricted CIDR ranges before issuing a request.
  • Use dedicated egress controls (e.g., firewall rules or network policies) to prevent the web server from reaching internal management or metadata endpoints.
  • Where possible, segregate proxy-like functionality into isolated services or containers with limited network reach.
  • Treat all user-supplied URLs as untrusted, applying normalization and canonicalization before validation.

How teams detect issues like this

Detection typically combines code-focused and operational approaches:

  • Static analysis / code review:
  • Flag instances where user-controlled URLs are used in server-side HTTP clients without network range validation.
  • Look for proxy or fetch code paths that sign or rewrite URLs but do not inspect the resolved IP address.
  • Review configuration flags enabling image proxying or remote resource fetching.
  • Runtime and logging:
  • Monitor outbound HTTP requests from the web server, especially requests targeting RFC1918 addresses, loopback (127.0.0.0/8), or link-local ranges.
  • Configure application and reverse proxy logs to record destination hosts and IPs for proxied image fetches.
  • Use anomaly detection to alert on unusual outbound traffic patterns originating from the forum server.
  • Policy and tooling:
  • Apply security policies or web application firewalls (WAFs) that restrict or inspect server-initiated requests where possible.
  • Incorporate automated application security testing that simulates SSRF attempts against URL-based features such as image proxies.

Sources

SourceLink
github.comgithub.com/SimpleMachines/SMF/commit/4bf35cf9e45573a5f55a6f52995086c1da89c096
github.comgithub.com/SimpleMachines/SMF/commit/b4d23dfd74a511587c605f9d294cefc3a75b4b26
vulncheck.comvulncheck.com/advisories/simple-machines-forum-ssrf-via-image-proxy

Frequently asked

questions

Yes, in typical configurations any authenticated user who can post content with image BBCode can exploit the issue remotely, as long as the image proxy is active and the server can reach internal targets.

Not necessarily. Exploitation generally requires only standard posting privileges to embed [img] tags, since the proxy and HMAC generation are handled transparently by SMF.

The safest approach is to enforce strict outbound request controls for the image proxy: validate the final resolved IP against a denylist of internal ranges, restrict allowed schemes and ports, and optionally limit destinations to a known-safe allowlist, combined with network-level egress restrictions.

For any feature that performs server-side HTTP requests based on user input, design with "untrusted URL" assumptions: normalize and validate URLs, enforce network-based restrictions on destinations, avoid using powerful HTTP clients from high-privilege network locations, and integrate SSRF-specific checks into code review and security testing processes.

Find out what's already
exploitable in your codebase.