Summary
Jellyfin's LiveTV M3U tuner endpoint accepts attacker-controlled tuner URLs without proper validation, enabling local file read via non-HTTP paths and Server-Side Request Forgery (SSRF) via HTTP URLs.
Any authenticated user with default Live TV management permissions can abuse this behavior to exfiltrate sensitive internal resources such as the Jellyfin database and potentially escalate to administrator privileges.
Affected context
The vulnerability occurs in Jellyfin instances that expose the LiveTV functionality and allow users to configure M3U tuners through the /LiveTv/TunerHosts endpoint.
It is relevant in deployments where:
- The
EnableLiveTvManagementpermission is enabled for standard or newly created users. - The Jellyfin server can access internal network resources or local files that should not be exposed to users.
- M3U tuner URLs are accepted from clients and used by the server to fetch playlists or stream data without strict scheme, host, or path validation.
Exploit preconditions
- Attack surface: Jellyfin HTTP API, specifically the LiveTV M3U tuner creation endpoint (
POST /LiveTv/TunerHosts). - Required access: Any authenticated user account with Live TV management privileges (which are enabled by default for new users in affected versions).
- Trigger point: Submission of a crafted tuner configuration whose URL points either to:
- Non-HTTP paths resolving to local files, or
- HTTP endpoints on internal or external servers controlled by the attacker.
- Why exploitation is possible: The server trusts and dereferences the attacker-supplied URL without enforcing scheme restrictions, host allowlists, or path constraints, enabling both SSRF and unintended local file access.
Why this happens
The core issue is insufficient validation and restriction of user-supplied URLs that are later dereferenced by the server in a high-privilege context.
From a vulnerability-class perspective:
- It maps to CWE-918: Server-Side Request Forgery (SSRF) because the application allows an authenticated user to make arbitrary HTTP requests from the server to attacker-chosen destinations, using the server's network position.
- It also maps to CWE-73: External Control of File Name or Path, as non-HTTP tuner paths can be crafted so the server accesses local files that the user should not be able to read.
Conceptually, LiveTV tuner configuration acts as a semi-trusted data channel, but its values are treated as fully trusted instructions for outbound requests and file access.
The lack of scheme, host, and path-level safeguards means the application breaks the intended separation between user-supplied configuration data and sensitive backend resources.
Potential impact
- Exfiltration of internal Jellyfin data stores, including the underlying database.
- Theft of active admin session tokens or other credentials stored in backend systems.
- Escalation from a low-privileged user to a full Jellyfin administrator.
- Unauthorized access to local files readable by the Jellyfin process.
- Discovery and probing of internal network services reachable from the Jellyfin server.
- Further compromise of the hosting environment if sensitive secrets or tokens are obtained.
General mitigation guidance
Effective mitigation focuses on constraining what user-supplied URLs can do and minimizing privileges around LiveTV configuration:
- Constrain tuner URL schemes and destinations:
- Accept only explicitly allowed schemes (e.g.,
http/https) and reject file-like or platform-specific path formats. - Enforce host allowlists or controlled patterns for tuner destinations, avoiding arbitrary internal or loopback addresses.
- Isolate access to sensitive resources:
- Ensure the Jellyfin process runs with least-privilege filesystem and network access, limiting both local file visibility and internal network reach.
- Avoid collocating highly sensitive services or databases on the same network segment or host without network controls.
- Harden LiveTV management permissions:
- Treat LiveTV tuner configuration as an administrative capability rather than a default user permission.
- Use role-based assignments so only trusted admin roles can add or modify tuner hosts.
- Validate and sanitize configuration input:
- Apply strict validation to tuner URLs at the API boundary, rejecting malformed or unexpected patterns.
- Centralize URL validation logic to prevent bypasses and ensure consistent enforcement.
These patterns apply independently of specific Jellyfin versions and help reduce similar SSRF and path control risks in other features.
How teams detect issues like this
Detection typically combines code-centric and operational approaches:
- Static and code review checks:
- Flag code paths where user-controllable URLs or file paths are dereferenced, especially in network or IO libraries.
- Look for tuner/stream configuration flows where input is passed directly to HTTP clients, filesystem APIs, or media fetching utilities without validation.
- Enforce secure coding guidelines that mandate scheme and host validation before making outbound server requests.
- Configuration and permission reviews:
- Periodically audit default roles and permissions, particularly LiveTV-related capabilities, to ensure they are not broadly granted.
- Review server configuration for unnecessary access to local sensitive paths or internal services.
- Runtime and log-based detection:
- Monitor logs for unusual tuner URLs, including those targeting
localhost, internal IP ranges, or non-standard schemes. - Alert on repeated tuner creation attempts or tuners referencing database endpoints or internal service ports.
- Automated tooling:
- Use security scanners or custom scripts that test LiveTV and similar endpoints with canary URLs to discover SSRF-like behavior.
- Integrate SSRF-focused checks into CI pipelines to detect new or modified paths that accept user-supplied URLs.

