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-verifyendpoint 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.

