/

CVE-2026-32275

Severity:

CRITICAL RISK

(9.1)

Cross-Site Scripting (XSS) in Tautulli API

CVE-2026-32275

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Client-Side Code Execution and API Key Theft

Severity:

CRITICAL RISK

(9.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

A reflected cross-site scripting (XSS) vulnerability in Tautulli's JSONP API endpoints allows an attacker to inject arbitrary JavaScript through an unsanitized callback parameter.

If a victim is tricked into loading a crafted URL while logged into or otherwise authorized against Tautulli, the attacker can run scripts in the context of the Tautulli web UI and steal API keys or other sensitive data.

Affected context

The vulnerability exists in Tautulli's web interface where JSONP responses are used to return data to browser clients.

A callback query parameter is accepted and reflected directly into the response without adequate validation or encoding.

When users access these crafted JSONP URLs in a browser that has an authenticated or otherwise trusted session with Tautulli, the injected script executes in the origin of the Tautulli instance, exposing in-browser secrets such as API keys and session-bound data.

Exploit preconditions

  • Attack surface: HTTP(S) endpoints on the Tautulli web interface that return JSONP responses.
  • Required access: Ability to make the victim's browser send a request to the vulnerable endpoint (e.g., via phishing links, malicious websites, or in-app links). The victim must have a valid session or usable auth context with Tautulli for sensitive data to be exposed.
  • Trigger point: A crafted URL containing a malicious callback parameter that is reflected into the JSONP wrapper and interpreted as JavaScript by the browser.
  • Why exploitation is possible: The callback parameter is not sanitized or strictly validated as an identifier, and output encoding is insufficient. As a result, attacker-controlled JavaScript is included and executed in the page context, enabling cross-origin script injection and access to API keys.

Why this happens

The core issue is an unvalidated JSONP callback parameter being incorporated directly into the JavaScript response.

Instead of treating the callback strictly as a function name and enforcing a narrow character set (e.g., alphanumerics and limited punctuation) with robust output encoding, the implementation allows arbitrary characters.

This maps to CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting), specifically a reflected XSS variant in which attacker-controlled input is echoed into a script context.

Because JSONP executes as JavaScript in the page's origin, this insecure pattern allows an attacker's payload to run with the same privileges as legitimate Tautulli scripts.

Potential impact

  • Theft of Tautulli API keys and associated tokens from the browser context.
  • Execution of arbitrary JavaScript in the victim's browser under the Tautulli origin.
  • Unauthorized access to or modification of Tautulli data via the victim's session (e.g., viewing media statistics, modifying monitored libraries).
  • Use of stolen API keys to integrate with or query other services tied to Tautulli.
  • Pivoting into broader account or infrastructure compromise if the same keys or credentials are reused elsewhere.

General mitigation guidance

Mitigation for this vulnerability class typically focuses on eliminating unsafe JSONP patterns and enforcing strict output encoding:

  • Avoid JSONP entirely where possible; prefer CORS-based JSON APIs with explicit, server-controlled origins.
  • If JSONP must remain, treat the callback purely as an identifier: enforce a strict allowlist of characters (e.g., ^[a-zA-Z0-9_.]+$) and reject anything else.
  • Apply context-appropriate output encoding to any user-controlled data included in script blocks or JavaScript responses.
  • Implement a secure-by-default API design that does not expose sensitive values such as API keys to browser clients unless absolutely necessary.
  • Reduce session privileges and avoid placing long-lived or highly privileged tokens in browser-accessible contexts.

These patterns reduce opportunities for attacker-controlled script execution and limit the value of any data that could be exfiltrated.

How teams detect issues like this

High-level detection and assurance strategies for this kind of issue include:

  • Static analysis: Search for JSONP-style responses where a request parameter (often named callback) is concatenated into a script or function wrapper without sanitization. Pattern-match direct usage of query parameters in script contexts.
  • Code review cues: Flag any usage of dynamic script construction, JSONP endpoints, or responses where untrusted data appears in <script> tags or inline JavaScript. Review places where API keys or secrets are exposed to the frontend.
  • Security testing: Use automated and manual web application scanning to probe endpoints with common XSS payloads in callback parameters and verify that responses do not echo raw values into executable contexts.
  • Policy enforcement: Adopt coding guidelines that discourage JSONP and mandate output encoding libraries and centralized helpers for rendering any user-controlled data into HTML or JavaScript.

Sources

SourceLink
github.comgithub.com/Tautulli/Tautulli/releases/tag/v2.17.0
github.comgithub.com/Tautulli/Tautulli/security/advisories/GHSA-95mg-wpqw-9qxh

Frequently asked

questions

Yes. An attacker can host or deliver a crafted URL pointing to the vulnerable JSONP endpoint. When a victim with an active Tautulli session visits that URL, the attacker's JavaScript executes in the Tautulli origin.

The attacker does not need direct access to Tautulli, but the victim's browser must have a valid session or applicable authorization to Tautulli for sensitive impacts like API key theft. Without a valid session, script execution may still occur but will yield limited or no sensitive data.

The most robust fix is to deprecate JSONP endpoints in favor of standard JSON APIs with CORS and to ensure all user-controlled input is strictly validated and contextually encoded before being emitted into any script context.

Establish secure coding standards that ban or tightly constrain JSONP, require centralized output-encoding utilities, and integrate automated scanning and code review checks focused on user input flowing into HTML or JavaScript contexts. Regular security testing of web endpoints for XSS patterns further reduces recurrence.

Find out what's already
exploitable in your codebase.