Tautulli
CVE-2025-58762
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain Tautulli admin access
-
DeliveryPoint PMS URL to attacker server
-
ExploitSend pms_image_proxy request with traversal in img_format
-
ExecutionWrite malicious Python script via server response
-
PersistTrigger Script notification agent
-
ImpactExecute arbitrary code on host
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V5 - File Handling File name/path control
|
| Exploitation Conditions | Requires pre-existing Tautulli ADMINISTRATIVE access (CVSS PR:H confirms this): the attacker must be able to change the configured Plex Media Server (PMS) URL to a server they control. Exploitation specifically abuses the pms_image_proxy endpoint, supplying the image source in the img parameter and an unsanitized img_format parameter that forms the end of the constructed file path, allowing path-traversal characters to control the written filename. Achieving RCE additionally requires the built-in Script notification agent to be usable to execute the written Python file. Limiting factors: this is NOT remotely exploitable by unauthenticated users - the admin-access requirement is the primary constraint, meaning realistic risk is confined to scenarios of compromised admin credentials, malicious operators, or improperly exposed/over-shared admin consoles. Affected: Tautulli v2.15.3 and earlier; fixed in 2.16.0. |
| Impact | This is a genuine but conditional risk. The CVSS vector (AV:N/AC:L/PR:H/UI:N, base 7.2) confirms a network-exploitable, low-complexity flaw that nonetheless REQUIRES high privileges (PR:H) - the description corroborates this, stating the attacker needs 'administrative access' to Tautulli to change the PMS URL and abuse the pms_image_proxy endpoint. The signals are internally consistent (CVSS PR:H matches the description's admin-only prerequisite), so there is no contradiction to flag. EPSS is low at 0.61% (70th percentile), and the vulnerability is NOT in CISA KEV, indicating no confirmed widespread active exploitation. However, publicly available exploit code exists via the GitHub Security Advisory (GHSA-pxhr-29gv-4j8v). The low EPSS combined with POC availability and an admin-access precondition suggests this is a privilege-escalation-to-RCE post-authentication issue rather than a mass-exploitable perimeter bug. Real priority is MODERATE: it matters most where Tautulli admin credentials could be compromised or where a lower-trust operator should not be able to reach code execution, but it is not a drive-by unauthenticated threat. The SSVC framing would lean toward lower urgency (exploitation not automatable, requires prior admin control), tempering the high technical impact (full RCE). |
| Exploit ScenarioDerived | An attacker who has obtained Tautulli administrative access (or a malicious/over-privileged admin operator) reconfigures the Plex Media Server URL to point at an attacker-controlled server, then sends a pms_image_proxy request supplying a crafted img_format containing path-traversal characters to write an attacker-supplied Python script anywhere in the application filesystem. They then invoke the built-in Script notification agent to execute that script, achieving remote code execution on the Tautulli host. Public exploit code for this chain is available via the vendor's GitHub Security Advisory. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Oct 19, 2026
Remote code execution in Tautulli through 2.15.3 requires pre-existing administrative access: an attacker who can repoint the configured Plex Media Server URL to a server they control can abuse the pms_image_proxy endpoint to write an arbitrary Python file via path traversal in the unsanitized img_format parameter, then execute it through the built-in Script notification agent. Publicly available exploit code exists, and the vendor fixed the issue in 2.16.0; EPSS is 0.61% (70th percentile). Because CVSS PR:H confirms the admin prerequisite, realistic exposure is limited to compromised admin credentials, malicious operators, or over-shared admin consoles rather than unauthenticated remote attackers.
Earlier versions of this analysis (1)
Tautulli is a Python based monitoring and tracking tool for Plex Media Server. Rated critical severity (CVSS 9.1), this vulnerability is remotely exploitable, low attack complexity. Public exploit code available.
RemediationAI
Vendor-released patch: 2.16.0. Upgrade Tautulli to 2.16.0 using the advisory at https://github.com/Tautulli/Tautulli/security/advisories/GHSA-pxhr-29gv-4j8v and commit https://github.com/Tautulli/Tautulli/commit/26e6b328112eb2cf35c164f981e0718f3a3d31a7. Because exploitation requires administrative access, interim controls should reduce that exposure: restrict the Tautulli admin UI to trusted networks or a VPN (side effect: remote administration becomes inconvenient), audit and minimize administrator accounts and credentials (side effect: operational overhead), and monitor or alert on changes to the configured PMS URL and pms_image_proxy requests with unexpected img_format values. If the Script notification agent is not required, disable it to break the RCE chain (side effect: loss of script-based notifications); this does not prevent the file-write primitive, so patching remains the primary fix.
Affects your stack
Find out whether the stacks and servers you run are on an affected version.
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Tautulli is a Python-based web application for monitoring and tracking Plex Media Server (PMS). The pms_image_proxy endpoint constructs a cache file path from a hash of requested metadata plus the caller-supplied img_format value; because img_format occupies the end of the path and is not sanitized, path-traversal characters let an administrator choose the written filename. The attacker also controls the configured PMS URL, so the proxy fetch returns arbitrary bytes that Tautulli writes to the chosen path. Writing a Python file and invoking the Script notification agent then yields code execution. This is CWE-73 (External Control of File Name or Path), reflected in CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H. The referenced patch commit modifies cache-directory creation in plexpy/webserve.py (os.makedirs(..., exist_ok=True)); the GitHub security advisory GHSA-pxhr-29gv-4j8v documents the vendor fix in 2.16.0, and CPE cpe:2.3:a:tautulli:tautulli:*:*:*:*:*:*:*:* covers affected releases.
Know when Tautulli gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H
Network-reachable endpoint with low complexity, but requires administrative privileges to change the PMS URL (PR:H); resulting RCE yields full C/I/A impact with no scope change.
Primary rating from NVD.
CVSS VectorNVD
Lifecycle Timeline
6DescriptionNVD
Tautulli is a Python based monitoring and tracking tool for Plex Media Server. In Tautulli v2.15.3 and earlier, an attacker with administrative access can use the pms_image_proxy endpoint to write arbitrary python scripts into the application filesystem. This leads to remote code execution when combined with the Script notification agent. If an attacker with administrative access changes the URL of the PMS to a server they control, they can then abuse the pms_image_proxy to obtain a file write into the application filesystem. This can be done by making a pms_image_proxy request with a URL in the img parameter and the desired file name in the img_format parameter. Tautulli then uses a hash of the desired metadata together with the img_format in order to construct a file path. Since the attacker controls img_format which occupies the end of the file path, and img_format is not sanitised, the attacker can then use path traversal characters to specify filename of their choosing. If the specified file does not exist, Tautaulli will then attempt to fetch the image from the configured PMS. Since the attacker controls the PMS, they can return arbitrary content in response to this request, which will then be written into the specified file. An attacker can write an arbitrary python script into a location on the application file system. The attacker can then make use of the built-in Script notification agent to run the local script, obtaining remote code execution on the application server. Users should upgrade to version 2.16.0 to receive a patch.
Executive ViewAI
Tautulli, a Plex media-server monitoring utility, contains a high-severity remote code execution flaw (CVE-2025-58762) affecting versions through 2.15.3 that allows an attacker holding administrative rights in the application to run arbitrary code on the underlying host. Because the attacker must already possess admin access, the realistic exposure is insider misuse, stolen or widely shared administrator credentials, or an over-exposed admin console rather than broad external attack. Leadership should care because a successful exploit turns a convenience-tier tool into a foothold on internal infrastructure, and publicly available exploit code shortens the window in which that risk can be exercised.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Path traversal exploits occur when applications use user-controlled input to construct file system paths without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Affected Products (CPE)NVD
Path traversal in Tautulli's /newsletter/image/images API endpoint allows unauthenticated remote attackers to read arbit
Unauthenticated path traversal in Tautulli 2.15.3 and earlier allows remote attackers to read arbitrary files from the s
Path traversal in Tautulli 2.15.3 and earlier allows unauthenticated remote attackers to read arbitrary files through th
Command injection in Tautulli 2.15.3 and earlier lets an authenticated administrator achieve remote code execution on th
In Tautulli 2.1.9, CSRF in the /shutdown URI allows an attacker to shut down the remote media server. Rated medium sever
data/interfaces/default/history.html in Tautulli 2.1.26 has XSS via a crafted Plex username that is mishandled when cons
Unauthenticated server-side request forgery in Tautulli versions prior to 2.17.1 allows remote attackers to coerce the T
Remote code execution in Tautulli versions prior to 2.17.1 allows attackers to achieve unauthenticated RCE on fresh inst
Stored cross-site scripting in Tautulli before 2.17.1 allows low-privilege authenticated users (including guests when gu
Cross-site request forgery in Tautulli versions prior to 2.17.1 allows remote attackers to hijack administrator accounts
Remote code execution in Tautulli (Python-based Plex Media Server monitoring tool) versions prior to 2.17.0 allows authe
Cross-site scripting (XSS) in Tautulli 1.3.10 through 2.16.x allows remote attackers to inject malicious scripts via uns
NVD
CVE.org
EPSS
GitHub
Exploit-DB