/

CVE-2026-35032

Severity:

HIGH RISK

(8.1)

Server-Side Request Forgery and Insecure Resource Access

CVE-2026-35032

Analyzed

Vulnerability type

Category:

Server-Side Request Forgery and Insecure Resource Access

CWE:

CWE-73, CWE-918

Impact:

Server-Side Request Forgery with Local File Read and Privilege Escalation

Severity:

HIGH RISK

(8.1)

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

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 EnableLiveTvManagement permission 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.

Sources

SourceLink
github.comgithub.com/jellyfin/jellyfin/releases/tag/v10.11.7
github.comgithub.com/jellyfin/jellyfin/security/advisories/GHSA-8fw7-f233-ffr8

Frequently asked

questions

Yes, if the Jellyfin instance is reachable and the attacker can obtain any authenticated user account, they can target the LiveTV tuner API over the network. However, successful exploitation also depends on what internal resources or local files the Jellyfin server can reach.

The attacker needs an authenticated Jellyfin account with LiveTV management permissions. In vulnerable versions, this permission is often granted by default to newly created users, making low-friction account creation a significant factor.

The safest pattern is to treat tuner configuration as an administrative function, strictly validate tuner URLs (scheme, host, and path), and ensure the server cannot freely reach sensitive local files or internal network services. Applying least privilege to the Jellyfin process and its network environment is crucial.

Adopt a design-time policy that any user-supplied URL or path is untrusted. Implement centralized validators for URLs and filesystem paths, enforce outbound request policies (allowlists, blocked internal ranges), restrict dangerous schemes, and require explicit, narrowly scoped privileges for any feature that causes the server to fetch external or local resources on behalf of a user.

Find out what's already
exploitable in your codebase.