/

CVE-2026-40348

Severity:

HIGH RISK

(7.7)

SSRF in Movary Jellyfin Server URL Verification

CVE-2026-40348

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery (SSRF)

CWE:

CWE-918

Impact:

Internal Network Reconnaissance and Potential Lateral Access via SSRF

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

Movary versions prior to 0.71.1 contain a server-side request forgery (SSRF) issue in the Jellyfin server URL verification endpoint, allowing authenticated users to make the server send HTTP requests to arbitrary internal targets.

By supplying a crafted server URL to /settings/jellyfin/server-url-verify, an ordinary user can abuse the backend to probe internal network hosts, ports, and services that are not directly exposed externally.

Affected context

This vulnerability affects Movary deployments that:

  • Are running a version prior to 0.71.1
  • Expose the /settings/jellyfin/server-url-verify endpoint to ordinary authenticated users
  • Allow the Movary server to initiate outbound HTTP connections to internal networks, loopback addresses, or cloud/provider metadata services

The issue becomes relevant in environments where the Movary server has network reachability to sensitive internal services or infrastructure endpoints that should not be reachable from regular users.

Exploit preconditions

  • Attack surface: Application HTTP endpoint POST /settings/jellyfin/server-url-verify
  • Required access: Any ordinary authenticated Movary user account (no special privileges)
  • User-controlled input: The server-url (or equivalent) parameter, which is concatenated with /system/info/public
  • Trigger point: When the application invokes Guzzle to perform the server-side HTTP request to the constructed URL
  • Why exploitation is possible: The backend performs outbound HTTP requests to user-specified hosts without restrictions on:
  • Private IP ranges (e.g., RFC1918, link-local)
  • Loopback or localhost addresses
  • Other internal-only hostnames or services

Why this happens

The core issue is a lack of network-layer and host validation when the application uses user-supplied URLs for server-initiated HTTP requests.

In the Jellyfin server URL verification flow, Movary:

  • Accepts a URL parameter from an authenticated user
  • Appends /system/info/public
  • Uses Guzzle to perform an HTTP request from the Movary server to that destination

Because this URL is not constrained to allowed hosts, schemes, or network ranges, the server effectively becomes a proxy into its own reachable network space.

This aligns with CWE-918: Server-Side Request Forgery (SSRF), where an attacker can induce the server to make arbitrary network requests, enabling internal reconnaissance and, in some architectures, indirect access to sensitive services.

Potential impact

  • Internal host discovery and network mapping via differential responses and timing
  • Port-state probing (open/closed/filtered) on internal services reachable from the Movary server
  • Service fingerprinting by observing HTTP status codes, headers, and response bodies
  • Potential access to internal administrative panels or APIs that are not externally exposed
  • Possible interaction with cloud provider metadata endpoints if reachable, which can sometimes lead to credential exposure in misconfigured environments
  • Use of the Movary server as a pivot point for more complex multi-step attacks within the internal network

General mitigation guidance

Effective mitigation typically focuses on constraining where server-initiated HTTP requests can go and reducing the server's ability to act as an unbounded network proxy.

Host and network restrictions

  • Enforce allowlists of valid external domains or IPs for any URL that will be used for outbound HTTP verification.
  • Block requests to loopback, link-local, and private IP ranges at the application or network layer.
  • Reject raw IP literals or unresolvable hostnames when a URL is intended for trusted external services.

URL and scheme validation

  • Normalize and parse URLs before use, rejecting unexpected schemes (e.g., non-HTTP/HTTPS).
  • Re-resolve hostnames after DNS lookups (DNS pinning) and verify they do not resolve into prohibited address ranges.
  • Avoid blindly concatenating paths; instead, construct known-safe base URLs and append only validated path segments.

Network hardening

  • Limit the Movary server's network reach to only those outbound destinations strictly required for operation.
  • Isolate Movary in segmented network zones so that even if SSRF occurs, reachable internal services are minimized.
  • Use firewall and egress controls to prevent access to metadata endpoints and administration interfaces from application hosts.

Principle of least privilege

  • Run Movary with minimal OS and network permissions, and avoid co-locating high-value services on the same host or unrestricted VLANs.
  • Treat URL-verification and similar helper features as high-risk and design them with restrictive defaults and explicit host constraints.

How teams detect issues like this

Organizations can detect and monitor for SSRF patterns in several ways:

Static and code-level analysis

  • Scan for usage of HTTP client libraries (e.g., Guzzle) where the destination URL incorporates user-controlled input.
  • Flag endpoints that accept URLs or hostnames and subsequently perform server-initiated HTTP calls without explicit host or network checks.
  • Add secure coding guidelines and linting rules that require allowlists for outbound HTTP requests.

Code review signals

  • Pay special attention to "connectivity test" or "URL verification" features that reach out to third-party services based on user input.
  • Look for absence of checks against private IP ranges, localhost, or metadata service IPs in URL-handling logic.
  • Review any implementation that concatenates user input into URLs or paths used by server-side HTTP clients.

Operational monitoring

  • Log outbound HTTP requests from the Movary server, including destination host, IP, and response status, and alert on unusual internal destinations.
  • Correlate spikes in outbound connections or attempts to access internal or metadata IP ranges with user accounts and sessions.
  • Use network-level monitoring and IDS/IPS signatures to detect atypical egress patterns indicative of SSRF activity.

Sources

SourceLink
github.comgithub.com/leepeuker/movary/commit/d459b3513293d41254f7093aef07010a8e5dcf04
github.comgithub.com/leepeuker/movary/pull/751
github.comgithub.com/leepeuker/movary/releases/tag/0.71.1
github.comgithub.com/leepeuker/movary/security/advisories/GHSA-2m2v-v563-qqvj

Frequently asked

questions

It is highly exploitable in environments where Movary is reachable to normal users and the server has network access to internal services or metadata endpoints. Any authenticated user can leverage the vulnerable endpoint to perform internal network probing.

No. An ordinary authenticated Movary account is sufficient. The attacker does not need shell access or elevated privileges; exploitation occurs entirely via HTTP requests to the Movary application.

The safest approach is to enforce strict outbound destination controls for any server-initiated HTTP request derived from user input. This typically means allowlisting known-good hosts/domains, blocking private and loopback ranges, validating schemes, and treating URL-verification features as security-sensitive components.

Design any functionality that triggers outbound requests from user-provided URLs with an "assume hostile" mindset: normalize and inspect URLs, reject unsafe destinations, constrain network reach at the firewall level, and include SSRF-specific checks in code review and automated security testing.

Find out what's already
exploitable in your codebase.