Tautulli
CVE-2025-58763
HIGH
Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as Tautulli administrator
-
DeliverySubmit crafted GIT_REMOTE/GIT_BRANCH via checkout_git_branch
-
ExploitStore unsanitized $() payload in config
-
ExecutionrunGit passes payload to shell=True Popen
-
ImpactExecute arbitrary commands as service account
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization OS command sanitization, avoid shell exec
MITRE ATT&CK
2 techniques across 1 tactic: Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Two concrete prerequisites must both hold: (1) the attacker must possess Tautulli administrative privileges (CVSS PR:H), granting access to the checkout_git_branch endpoint that writes the GIT_REMOTE and GIT_BRANCH configuration keys; and (2) the instance must have been installed by cloning the Tautulli GitHub repository and run manually, so that the git-based update/versioning code path (runGit in versioncheck.py, invoked with subprocess.Popen shell=True) is active - packaged, Docker, or non-git installations do not reach this code and are not exploitable. The exact trigger is injecting |
| Impact | Signals are mixed and net out to a moderate, conditional priority rather than an urgent one. CVSS 3.1 base is 7.2 (High) with AV:N/AC:L but critically PR:H - exploitation requires existing administrative access to Tautulli, so this is a privilege-escalation-to-RCE primitive for an already-trusted admin, not an unauthenticated internet-facing RCE. The description adds a second gating condition the CVSS vector does not capture: the instance must have been cloned from GitHub and installed manually (so that git-based update logic is active), which excludes packaged/Docker/one-click deployments. EPSS is low at 0.37% (59th percentile), consistent with the narrow preconditions, and the vulnerability is NOT on CISA KEV, so there is no confirmed active exploitation. A public exploit path is documented in the GitHub Security Advisory (POC available). Bottom line: the combination of required admin privileges plus a non-default manual-git install meaningfully suppresses real-world risk below what the 7.2 score alone implies; EPSS being low despite POC availability supports treating this as a patch-in-normal-cycle item for the subset of manually-cloned deployments, not a drop-everything emergency. One explicit caveat: the CVSS vector marks AC:L, but the manual-GitHub-install prerequisite is a real condition outside the attacker's control - verify your deployment method before scoring this against your fleet. |
| Exploit ScenarioDerived | An attacker who already holds (or has phished/credential-stuffed) a Tautulli administrator account targets an instance that was installed by cloning the GitHub repo. Using the checkout_git_branch endpoint, they store a malicious GIT_REMOTE or GIT_BRANCH value containing |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Oct 19, 2026
Command injection in Tautulli 2.15.3 and earlier lets an authenticated administrator achieve remote code execution on the application server, but only when the instance was installed by manually cloning the GitHub repository so that the git-based update and versioning code path is live. The flaw lies in the checkout_git_branch endpoint, which persists attacker-controlled GIT_REMOTE and GIT_BRANCH values without sanitization and later interpolates them into a shell command executed with shell=True, so $() payloads run as the Tautulli process user. Publicly available exploit code exists, though EPSS is low at 0.37% (59th percentile) and there is no CISA KEV entry; the requirement for administrative credentials plus a non-default manual-git deployment keeps exposure narrow. Version 2.16.0 contains the fix.
Earlier versions of this analysis (1)
Tautulli is a Python based monitoring and tracking tool for Plex Media Server. Rated high severity (CVSS 8.0), this vulnerability is remotely exploitable. Public exploit code available and no vendor patch available.
RemediationAI
Vendor-released patch: upgrade to Tautulli 2.16.0, which removes the injection from the git update path; the release notes and GHSA-jrm9-r57q-6cvf advisory should be reviewed before upgrading. Until the upgrade can be applied, restrict access to the Tautulli admin interface and the checkout_git_branch endpoint to trusted networks or place it behind an authenticating reverse proxy, since the endpoint requires administrative privileges and is the sole documented trigger - the trade-off is reduced administrative convenience for remote maintainers. Migration to a packaged, Docker, or other non-git installation also eliminates the vulnerable runGit code path entirely, at the cost of changing the update workflow and losing in-app git-based upgrades. Avoid storing arbitrary user-supplied values in GIT_REMOTE or GIT_BRANCH, and audit existing configuration for shell metacharacters such as $( or backticks. Tooling-based exploit code is publicly available, so treat admin credential exposure as a direct route to server compromise on git-cloned deployments.
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 monitoring and statistics front-end for Plex Media Server. Its self-update mechanism in versioncheck.py calls a runGit helper that invokes subprocess.Popen with shell=True (CWE-78: OS Command Injection). Because the shell interprets metacharacters, string interpolation of any user-influenced value into that command becomes an injection primitive. The concrete sink is the checkout_git_branch endpoint, which writes user-supplied remote and branch names directly into the GIT_REMOTE and GIT_BRANCH configuration keys and later formats them into the git checkout/update command, so a value such as $(<command>) executes on the server. Only deployments installed by cloning the GitHub repository and run manually exercise this code; containerized, packaged, or otherwise non-git installations never reach runGit and are not exploitable. The CPE cpe:2.3:a:tautulli:tautulli:*:*:*:*:*:*:*:* confirms all releases up to and including 2.15.3 are in scope. Our assessment rates the issue AC:H rather than NVD's AC:L, reflecting the dual preconditions of administrative access and a specific manual-git deployment.
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
PR:H because admin access is required; AC:H because exploitation depends on the non-attacker-controlled manual-GitHub-install deployment mode; network-reachable admin UI gives AV:N and full C/I/A impact via RCE.
Primary rating from NVD.
CVSS VectorNVD
Lifecycle Timeline
4DescriptionNVD
Tautulli is a Python based monitoring and tracking tool for Plex Media Server. A command injection vulnerability in Tautulli v2.15.3 and prior allows attackers with administrative privileges to obtain remote code execution on the application server. This vulnerability requires the application to have been cloned from GitHub and installed manually. When Tautulli is cloned directly from GitHub and installed manually, the application manages updates and versioning through calls to the git command. In the code, this is performed through the runGit function in versioncheck.py. Since shell=True is passed to subproces.Popen, this call is vulnerable to subject to command injection, as shell characters within arguments will be passed to the underlying shell. A concrete location where this can be triggered is in the checkout_git_branch endpoint. This endpoint stores a user-supplied remote and branch name into the GIT_REMOTE and GIT_BRANCH configuration keys without sanitization. Downstream, these keys are then fetched and passed directly into runGit using a format string. Hence, code execution can be obtained by using $() interpolation in a command. Version 2.16.0 contains a fix for the issue.
Executive ViewAI
Tautulli versions 2.15.3 and earlier contain a command-injection flaw that can let an attacker with administrator access to the web interface run code on the application server, but only on instances installed by manually cloning the GitHub repository. Publicly available exploit code exists; there is no CISA KEV entry and EPSS is low, and the administrative-access and non-default deployment prerequisites keep exposure narrow. Leadership should care because a successful compromise could give an attacker control of the Tautulli host and any data or credentials it can reach, so manual-git deployments should be prioritized for remediation.
Apply vendor patch: 2.16.0.
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
OS command injection occurs when an application passes unsanitized user input directly into system shell commands.
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
Remote code execution in Tautulli through 2.15.3 requires pre-existing administrative access: an attacker who can repoin
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