/

CVE-2026-43986

Severity:

CRITICAL RISK

(9.9)

Unauthenticated SSRF via Image Hash Lookup (CWE-918) in Tautulli Image Proxy Endpoint

CVE-2026-43986

Deferred

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Server-Side Request Forgery with potential access to internal network resources and sensitive services

Severity:

CRITICAL RISK

(9.9)

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

Tautulli versions prior to 2.17.1 contain a server-side request forgery (SSRF) issue in the public /image/<hash> endpoint, which replays attacker-controlled image URLs via internal server-side fetch logic.

A low-privilege guest can plant a malicious URL into the image_hash_lookup table, after which any unauthenticated user can trigger server-side HTTP requests from the Plex Media Server (PMS) or Tautulli host to arbitrary attacker-chosen destinations.

Affected context

This vulnerability occurs in Tautulli deployments that:

  • Run a version prior to 2.17.1
  • Expose the /image/<hash> route over a network interface accessible to untrusted users
  • Allow at least low-privilege guest accounts to interact with image-related features that populate the image_hash_lookup table

In such setups, the public image route becomes a replay mechanism for attacker-controlled URLs, effectively turning internal image proxying logic into an unauthenticated SSRF gadget.

Exploit preconditions

  • Attack surface: The public /image/<hash> HTTP endpoint, reachable without authentication once a hash exists.
  • Required access:
  • Initial setup requires a low-privilege guest or similarly constrained account that can cause Tautulli to store a URL in image_hash_lookup.
  • After seeding the entry, any external, unauthenticated user who can reach Tautulli's HTTP interface can exploit it.
  • Trigger point: A GET request to /image/<hash> (e.g., /image/<hash>.png) for a previously seeded hash value.
  • Why exploitation is possible: The endpoint trusts the image_hash_lookup mapping as benign, reusing internal server-side image fetch logic for entries that can be attacker-controlled, and it does so without enforcing authentication or robust outbound request restrictions.

Why this happens

The underlying flaw is a misuse of server-side URL fetching in a context where the input source is not properly constrained or authenticated.

Tautulli maintains an image_hash_lookup table associating hashes with image URLs and exposes a public /image/<hash> route that looks up these hashes and proxies the corresponding images through server-side HTTP requests.

Because low-privilege users can influence the URLs associated with these hashes and the public endpoint does not re-check authentication or enforce strict URL allowlisting, an originally authenticated SSRF primitive is transformed into a persistent unauthenticated SSRF channel.

This maps to CWE-918: Server-Side Request Forgery, where a server is tricked into making arbitrary outbound requests, potentially reaching internal or otherwise protected services.

Potential impact

  • The server may issue HTTP(S) requests to arbitrary external domains, enabling:
  • Log pollution, callback endpoints, or further chained attacks
  • The server could reach internal network services (e.g., PMS backends, databases, admin panels) that are not directly exposed to the internet.
  • Internal metadata endpoints (such as cloud provider instance metadata services) could be probed for sensitive configuration or credentials, depending on network topology.
  • The attacker may map parts of the internal network through timing and response analysis, aiding further lateral movement.
  • Outbound request capacity could be abused for reflected attacks or as part of a larger pivot in a compromised environment.

General mitigation guidance

Risk reduction centers on constraining where server-side image proxying is allowed to connect and tightening trust around lookup-driven requests.

Useful defensive patterns include:

  • Strict outbound URL allowlisting: Restrict server-side fetch logic to known-safe hosts, schemes, and ports (e.g., only HTTPS to trusted CDNs or media servers), rejecting all other destinations.
  • Authentication on SSRF-prone endpoints: Require appropriate authentication and authorization for any route that proxies remote resources, even if it merely serves images.
  • Isolation of proxy logic: Run image proxying and similar outbound HTTP components in isolated network segments or containers that have no access to sensitive internal services.
  • Immutable or validated lookup tables: Treat image_hash_lookup-style structures as privileged data:
  • Only permit controlled, validated URLs to be persisted.
  • Enforce schema and host checks before storing or using entries.
  • Defense-in-depth with network controls: Use firewall rules, egress filters, and service mesh policies to limit which external and internal addresses the server can contact.

How teams detect issues like this

Detection approaches can focus both on code-level patterns and on operational traffic behavior:

  • Static analysis and code review:
  • Flag endpoints that accept an identifier (e.g., hash, token) and then perform server-side HTTP requests based on lookup results with minimal validation.
  • Search for reuse of shared proxy/fetch utilities in routes that do not require authentication.
  • Identify absence of host allowlists, IP range checks, or scheme validation in outbound request helpers.
  • Dynamic analysis and testing:
  • Use automated scanners or security tests that attempt to inject external URLs via low-privilege features and then trigger server-side fetches from unauthenticated paths.
  • Monitor logs for unusual outbound destinations originating from the application, particularly to internal or non-standard ports.
  • Runtime monitoring:
  • Inspect egress traffic from the Tautulli or PMS host for atypical patterns, such as requests to internal-only address ranges or cloud metadata endpoints.
  • Set alerts on repeated failures or access attempts to sensitive internal hosts initiated by the application process.
  • Automated tooling:
  • Integrate SAST/DAST tools that specifically look for SSRF sinks (e.g., HTTP client calls) tied to user-influenced input, especially in routing code and template-driven lookup mechanisms.

Sources

SourceLink
github.comgithub.com/Tautulli/Tautulli/releases/tag/v2.17.1
github.comgithub.com/Tautulli/Tautulli/security/advisories/GHSA-m6j6-rc2c-8vpm

Frequently asked

questions

Once a malicious hash entry has been seeded into image_hash_lookup, the issue can be triggered by any unauthenticated user who can reach the /image/<hash> endpoint, making the SSRF primitive broadly accessible in exposed deployments.

No. The initial setup only requires a low-privilege guest (or equivalent) account capable of influencing which URLs are stored in the image hash lookup.

After that, no authentication is required to drive server-side requests via the public image endpoint.

The most robust approach is to treat server-side proxy features as sensitive sinks:

  • Enforce authentication and authorization on routes that trigger outbound requests.
  • Implement strict allowlists for destinations.
  • Ensure lookup tables cannot be populated with unvalidated, attacker-controlled URLs.

Organizations can reduce risk by:

  • Minimizing server-side fetching of user-influenced URLs.
  • Applying consistent host/scheme/IP validation and outbound network restrictions wherever HTTP clients are used.
  • Reviewing any feature that proxies or relays external content for proper access control.
  • Incorporating SSRF-focused checks into code review, static analysis rules, and regular security testing.
Find out what's already
exploitable in your codebase.