/

CVE-2026-43985

Severity:

HIGH RISK

(8.8)

Cross-Site Request Forgery (CWE-352) in Tautulli Admin Configuration Endpoint

CVE-2026-43985

Deferred

Vulnerability type

Category:

Cross-Site Request Forgery (CSRF)

CWE:

CWE-352

Impact:

Administrative Account Takeover and Full Interface Compromise

Severity:

HIGH RISK

(8.8)

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 Cross-Site Request Forgery (CSRF) flaw in Tautulli's /configUpdate endpoint allows an attacker to modify administrator credentials by abusing an authenticated admin's browser.

If a logged-in administrator is tricked into visiting a malicious site, that site can trigger a cross-site request that changes the local admin username and password, enabling full takeover of the Tautulli administrative interface.

Affected context

This vulnerability affects Tautulli deployments running versions prior to 2.17.1 that use the web-based administrative interface.

The issue is present where:

  • The /configUpdate route is reachable to authenticated administrators
  • Sessions are established using the default form or JWT-based authentication
  • The administrator is actively logged in in their browser (with a valid session cookie)

Under these conditions, a cross-site navigation from a malicious site can reach the state-changing endpoint without additional confirmation or token checks.

Exploit preconditions

  • Attack surface: Web admin interface, specifically the /configUpdate endpoint
  • Required access: Attacker needs no direct access to Tautulli; they only need to lure a logged-in administrator to visit a malicious web page they control
  • Trigger point: A crafted cross-origin request (e.g., auto-submitting form or redirect) from the attacker's page to /configUpdate while the admin's browser holds a valid Tautulli session cookie
  • Why exploitation is possible:
  • /configUpdate is state-changing but does not enforce the POST method, allowing actions via top-level navigation requests
  • The endpoint lacks anti-CSRF mechanisms such as per-request tokens or double-submit checks
  • The session cookie is issued with SameSite=Lax, allowing it to be sent on top-level cross-site navigation requests, so the browser automatically authenticates the forged request

Why this happens

The underlying issue is an absence of CSRF protection on a sensitive, state-changing administrative endpoint, combined with permissive HTTP method handling.

The /configUpdate route:

  • Performs configuration changes (including administrator username and password) without verifying user intent via CSRF tokens or similar mechanisms
  • Does not restrict itself to non-idempotent methods like POST with appropriate checks, enabling state changes via simple cross-site navigations

This matches CWE-352: Cross-Site Request Forgery, where a web application relies solely on browser-managed session cookies for authentication and fails to ensure that state-changing requests originate from legitimate user actions within the trusted site origin.

Potential impact

  • Attacker may overwrite the local administrator username and password
  • Attacker could obtain persistent administrative access to the Tautulli interface
  • Attacker can view or modify monitoring and tracking data associated with Plex Media Server
  • Attacker may change additional configuration settings, including integrations and notifications, potentially leading to data exposure or further abuse
  • Compromised admin interface could be used as a foothold for broader environment reconnaissance or social engineering

General mitigation guidance

Effective mitigation focuses on enforcing request authenticity for state-changing operations and tightening session handling.

Useful defensive patterns include:

  • CSRF defenses for sensitive endpoints:
  • Require and validate per-request CSRF tokens or synchronizer tokens on all state-changing routes, especially administrative ones
  • Use origin and/or Referer header validation as an additional signal to ensure requests originate from the same site
  • Strict HTTP method handling:
  • Restrict configuration-changing operations to POST (or PUT/PATCH) and reject state changes via GET or top-level navigations
  • Enforce content-type expectations (e.g., application/x-www-form-urlencoded or application/json) and reject inconsistent requests
  • Session cookie hardening:
  • Consider more restrictive cookie policies where appropriate, such as SameSite=Strict for highly sensitive admin-only sessions, while balancing usability requirements
  • Combine cookie protections with server-side checks rather than relying on browser defaults alone
  • Privilege and workflow design:
  • Separate high-risk configuration operations and require explicit re-authentication or step-up verification for critical admin changes
  • Limit the number of users with full administrative privileges and encourage separate, low-privilege accounts for routine tasks

How teams detect issues like this

Detection can focus on both code-level patterns and behavioral indicators.

Static and code review approaches:

  • Search for sensitive or administrative endpoints (e.g., configuration updates, credential changes) that:
  • Accept state changes without verifying CSRF tokens or equivalent protections
  • Use session cookies for authentication without additional request-origin checks
  • Allow state modifications over GET or do not enforce HTTP method constraints
  • Establish secure coding guidelines that flag any admin route lacking CSRF protection as a review blocker
  • Use static analysis or linters that recognize missing CSRF decorators, middleware, or token validation logic in web handlers

Runtime and logging approaches:

  • Monitor logs for unusual configuration changes, particularly repeated credential resets or changes initiated from unexpected IP ranges or user agents
  • Implement alerts for high-risk admin actions executed in rapid succession or from previously unseen admin environments
  • Where feasible, correlate configuration changes with user interaction patterns to detect anomalies suggesting automated or cross-site request flows

Sources

SourceLink
github.comgithub.com/Tautulli/Tautulli/releases/tag/v2.17.1
github.comgithub.com/Tautulli/Tautulli/security/advisories/GHSA-v622-pmjj-gpx3

Frequently asked

questions

Yes, in many deployments. An attacker does not need direct network access to Tautulli itself; they only need the ability to lure a logged-in administrator into visiting a malicious web page that can send cross-site requests to the Tautulli instance, assuming it is reachable from the admin's browser (e.g., via LAN or VPN).

The attacker does not require prior authentication to Tautulli. They must, however, rely on a victim who is already authenticated as an administrator in their browser. Exploitation hinges on social engineering or another mechanism to cause that admin's browser to issue the crafted request.

The most robust fix pattern is to require explicit CSRF protection on all state-changing and administrative endpoints, combined with strict HTTP method enforcement. This typically involves integrating framework-level CSRF middleware, validating per-request tokens, checking request origin where appropriate, and rejecting configuration-changing operations that do not meet these conditions.

Treat CSRF protection as a default requirement for any endpoint that mutates state, especially within administrative or configuration areas. Standardize patterns such as:

  • Always using CSRF tokens or equivalent mechanisms for authenticated changes
  • Enforcing appropriate HTTP methods and content types
  • Applying secure cookie attributes and origin checks
  • Making CSRF-safe patterns part of code review checklists and automated tests
Find out what's already
exploitable in your codebase.