Stealing From Thieves

Nicholas Anastasi, Juan Pablo Gomez Postigo

CypherCon 9.0 (2026)

Overview

In "Stealing From Thieves," Nicholas Anastasi and Juan Pablo Gomez Postigo (JP) unveiled critical security vulnerabilities within the popular "Servarr stack" — a suite of applications (Radarr, Sonarr, Lidarr, Readarr) widely used for automating media piracy home labs. The talk, delivered at CypherCon, delved into an authentication bypass exploit that leveraged a misconfigured X-Forwarded-For header, enabling unauthorized access to potentially thousands of internet-exposed instances. Beyond the technical exploit, the speakers presented a fascinating statistical analysis of the modern piracy landscape, revealing the scale of exposed media libraries, user preferences, and the financial value of compromised API keys.

Watch on YouTube

Visual summary for Stealing From Thieves by Nicholas Anastasi, Juan Pablo Gomez Postigo
Visual summary for Stealing From Thieves by Nicholas Anastasi, Juan Pablo Gomez Postigo

Key moments

  1. 2:00 Talk introduction and modern piracy home lab overview
  2. 6:10 Understanding the automated Servarr media management stack
  3. 11:00 Deep dive into Usenet: protocol, NZB files, benefits
  4. 23:50 Uncovering the DFLA authentication bypass vulnerability
  5. 32:00 Scanning the internet for exposed Servarr instances
  6. 44:50 Discovering 'the whales': massive piracy media libraries
  7. 47:50 Dumping credentials, API keys, and Plex admin takeover
  8. 51:50 Shadow patch, disclosure timeline, and home lab security advice

Stealing From Thieves

Speakers: Nicholas Anastasi, Hacker; Juan Pablo Gomez Postigo, Hacker

Conference: CypherCon

YouTube: https://www.youtube.com/watch?v=qZocBMKOCIk

Overview

In "Stealing From Thieves," Nicholas Anastasi and Juan Pablo Gomez Postigo (JP) unveiled critical security vulnerabilities within the popular "Servarr stack" — a suite of applications (Radarr, Sonarr, Lidarr, Readarr) widely used for automating media piracy home labs. The talk, delivered at CypherCon, delved into an authentication bypass exploit that leveraged a misconfigured X-Forwarded-For header, enabling unauthorized access to potentially thousands of internet-exposed instances. Beyond the technical exploit, the speakers presented a fascinating statistical analysis of the modern piracy landscape, revealing the scale of exposed media libraries, user preferences, and the financial value of compromised API keys.

The core of their research highlights a significant security oversight stemming from the Servarr stack's unique development model, where a shared codebase across multiple projects leads to a high attacker return on investment (ROI). By demonstrating how an attacker could gain full administrative control, download sensitive backups containing cleartext credentials, and even manipulate vast media collections, Anastasi and Gomez Postigo underscored the critical importance of secure configuration and responsible disclosure in the open-source community. Their findings serve as a stark reminder for self-hosters about the dangers of exposing internal services to the public internet and for developers about the complexities of maintaining security across forked projects.

This talk not only exposed a prevalent security flaw but also offered a unique glimpse into the otherwise clandestine world of automated media piracy, providing valuable insights for both defenders and curious observers. The speakers' journey from discovering the vulnerability to engaging with the maintainers and observing the subsequent "shadow patch" painted a realistic picture of the challenges in securing widely adopted, community-driven software.

Background

▶ Watch: Talk introduction and modern piracy home lab overview (2:00)

The evolution of media piracy has mirrored the advancements in computing and network technology. From the early 1990s and 2000s, which saw the rise of mass peer-to-peer file sharing via platforms like Napster and The Pirate Bay, the landscape has continually shifted. Initial methods were largely manual, requiring users to actively search for and download content. This era was characterized by significant anti-piracy crackdowns, famously encapsulated by "you wouldn't download a car" campaigns.

As users sought greater convenience, automation tools began to emerge. Early projects like Sick Beard and Couch Potato aimed to simplify the process of acquiring TV shows and movies. Concurrently, file-sharing sites such as MediaFire and MegaUpload provided alternative distribution channels, though these also faced severe legal challenges, as exemplified by the seizure of MegaUpload. This relentless pursuit of automation led to what the speakers term the "R era," marking the advent of the modern piracy stack.

Today, setting up an automated media piracy home lab can be achieved in as little as 30 minutes using readily available hardware like a Raspberry Pi or a mini PC with attached storage, often within a Dockerized environment on platforms like Proxmox or Synology NAS. The core of this setup is the Servarr stack, a collection of applications designed for specific media types: Sonarr for TV shows, Radarr for movies, Lidarr for music, and Readarr for books. These applications monitor for new releases, manage download requests, and organize media libraries. Crucially, they are highly scriptable and interact via APIs, making them ideal for automation.

To facilitate media acquisition, Servarr apps integrate with download clients such as NZBGet for Usenet and qBittorrent for torrenting. Once downloaded, media is typically managed and streamed by media servers like Plex or Jellyfin, which offer a Netflix-like experience within the home network. The entire ecosystem is often complemented by supporting tools found in repositories like awesome-selfhosted.

The typical workflow begins when a user requests a movie (e.g., Source Code) via a frontend like Overseerr (now known as Seerr). Overseerr forwards this request to Radarr, which then consults indexers (often managed by Prowlarr) to find matching releases based on quality and language preferences. These indexers serve as search engines for available content, providing either NZB files for Usenet or torrent files for peer-to-peer downloads.

A significant portion of the talk delves into Usenet, a protocol predating the World Wide Web. Originating in the early 1990s for sharing binary files (like software updates), Usenet involved splitting large files into multiple chunks, Base64 encoding them into text, and posting them to binary newsgroups. Users would download these text chunks, decode them, and reconstruct the original file. This method proved highly effective for pirated media. The introduction of NZB files (XML documents pointing to the locations of these chunks) streamlined the process, allowing specialized software like Newsbin and later NZBGet to automate downloading and reconstruction. Unlike torrents, which rely on peer-to-peer seeding, Usenet requires paid subscriptions to Usenet providers (e.g., Omicron) for chunk storage and Usenet indexers (e.g., NZBGeek, Drunken Slug) for NZB file access.

The speakers highlighted several advantages of Usenet over torrenting: significantly faster download speeds due to direct TCP connections to providers, higher reliability for older or obscure content (as it doesn't depend on active seeders), and greater resilience against DMCA takedowns due to the decentralized nature of text chunks and the separation of concerns between providers and indexers. Furthermore, Usenet traffic is less visible to Internet Service Providers (ISPs) compared to torrenting, which often triggers copyright infringement notices.

The Servarr stack itself has an interesting lineage. It began in 2010 as NZBDrone, an automation tool for TV shows. In 2014, it was renamed Sonarr. Subsequently, a "fork era" began, leading to the creation of Radarr for movies, Lidarr for music, and Readarr for books. While these applications share approximately 70% of their codebase, they are maintained as separate projects. The core Sonarr developer often cherry-picks code changes into the other repositories, rather than relying on a shared library. This development model, while functional, creates a significant challenge for security patching: a vulnerability in the shared core code impacts all Servarr applications, making coordinated disclosure and patching difficult and providing a very high attacker ROI.

Key Findings

▶ Watch: Deep dive into Usenet: protocol, NZB files, benefits (11:00)

The central discovery presented by Anastasi and Gomez Postigo was a critical authentication bypass vulnerability affecting all applications within the Servarr stack. This flaw exploited a specific setting called DFLA (Disable For Local Addresses), intended to allow users on their home network to access the applications without needing to log in. However, when these applications were inadvertently exposed to the internet, the DFLA setting could be trivially bypassed.

The bypass mechanism involved manipulating the X-Forwarded-For HTTP header. This header is typically used in environments with reverse proxies to indicate the original IP address of a client request. The Servarr applications, when configured with DFLA, incorrectly trusted the value of this header to determine if a request originated from a local IP address. An attacker could simply inject X-Forwarded-For: 127.0.0.1 (or any other RFC1918 internal IP address like 192.168.1.1) into their request. This fooled the application into believing the request came from a local source, thereby bypassing any configured authentication.

The immediate impact of this bypass was access to the /api/v3/system/status/initialize.json endpoint. This endpoint, designed to provide frontend applications with dynamic configuration details, would return the admin API key for the Servarr instance in cleartext. With this API key, an attacker gained full administrative control over the compromised application. Due to the shared codebase across Sonarr, Radarr, Lidarr, and Readarr, a single vulnerability affected the entire family of widely deployed applications, amplifying the potential for exploitation.

To assess the scale of this vulnerability, the researchers scanned the internet for exposed Servarr instances. While Shodan and Censys proved "pretty bad" at identifying residential IPs, they found success using Fofa.cn. Their scans revealed thousands of instances publicly accessible, many of which were vulnerable to the DFLA bypass. This allowed them to collect extensive statistics on the modern piracy landscape.

Key statistical findings included:

  • Prevalence: Radarr and Sonarr were almost equally popular, but Prowlarr instances were also surprisingly exposed, despite its primary role as an indexer manager with no direct user interface for media consumption.
  • Media Libraries: They uncovered "whales" – users with colossal media collections. The largest movie library found belonged to a user in Jersey, boasting 441 terabytes of movies. The largest TV show library was in the UK, with 250 terabytes. Across the top 10 movie libraries alone, they aggregated 1.5 petabytes, contributing to an estimated 8 petabytes of movies and TV shows across all vulnerable instances.
  • Financial Impact: The compromise of these instances meant access to valuable paid services. The researchers estimated that the combined value of all compromised Usenet indexer and provider API keys could exceed $10,000+ annually.
  • Cleartext Credentials: While direct API queries obfuscated secrets, downloading a raw backup of a compromised Servarr instance (possible with the admin API key) revealed cleartext credentials for download clients (like NZBGet) and all stored indexer API keys (for Prowlarr). Furthermore, if Plex was integrated, its API token was also exposed, potentially granting an attacker administrative control over the user's Plex server.

The vulnerability was responsibly disclosed to the Servarr team, leading to a "shadow patch" that was quietly rolled out without a public announcement. This approach, while effective, highlights the difficulties open-source maintainers face in coordinating security updates across a broad and often non-security-minded user base.

Technical Deep Dive

▶ Watch: Scanning the internet for exposed Servarr instances (32:00)

The technical heart of the vulnerability lies in the Servarr stack's handling of HTTP headers and its "Disable For Local Addresses" (DFLA) authentication setting. When DFLA is enabled, the application is designed to bypass authentication checks if the incoming request appears to originate from an internal or local IP address. This functionality is crucial for users who access their home lab services from within their private network without repeatedly entering credentials.

However, the implementation failed to correctly distinguish between a truly local request and a spoofed one when the application was exposed to the public internet, often behind a reverse proxy like Traefik. Reverse proxies commonly add an X-Forwarded-For header to requests, containing the client's original IP address, which helps the backend application understand the true source of the request. The Servarr applications' code, being a .NET application, would read the value of this X-Forwarded-For header and trust it as the originating IP.

The vulnerability specifically manifested when an attacker sent a request with X-Forwarded-For: 127.0.0.1 (or any RFC1918 private IP address like 192.168.1.1). The application's logic, as observed in the code, would:

  1. Clear "all known networks and known proxies."
  2. Set a remote IP variable based on the value provided in the X-Forwarded-For header.
  3. During the authentication and authorization phase, check if this remote IP (which was spoofed) fell within an internal IP range.
  4. If it did, the DFLA setting would trigger, bypassing authentication entirely.

This allowed unauthenticated access to sensitive API endpoints. The primary target was the /api/v3/system/status/initialize.json endpoint. This endpoint was peculiar because, upon a successful "local" access (or after initial authentication), it would return a JSON payload containing the application's version, API route, and, critically, the admin API key. This API key, once obtained, would then be used in subsequent requests as a session token, granting full administrative control over the Servarr instance. The speakers speculated that this design was a "quick win" for implementing authentication without building a complex authorization system, driven by the need to support various frontends and API versions within the forked project structure.

The discovery of vulnerable instances involved a multi-pronged approach to internet scanning. While popular services like Shodan and Censys were initially used, they proved "pretty bad" at identifying residential IPs, which constitute the majority of self-hosted Servarr instances. The researchers found Fofa.cn, a Chinese internet scanning company, to be more effective for this purpose. They crafted specific queries targeting HTTP title values and standard ports (e.g., Radarr typically runs on port 8989).

Once an instance was identified and confirmed vulnerable via the X-Forwarded-For bypass and initialize.json endpoint, the admin API key was extracted. This key then allowed the researchers to interact with the Servarr application's "well-documented, pretty uniform API." Through API calls, they could enumerate details about the instance, including its stored movie and TV show lists, configured download clients (e.g., NZBGet, qBittorrent, SABnzbd), and associated indexers (e.g., NZBGeek, The Pirate Bay).

A critical finding regarding data exfiltration was that while direct API queries for secrets (like indexer API keys or download client credentials) returned obfuscated values, the API key enabled the download of a raw backup of the Servarr application's database. These backups, typically intended for local administration, contained all sensitive credentials in cleartext, including:

  • Download client credentials (e.g., username/password for NZBGet).
  • API keys for Usenet indexers and torrent trackers (e.g., NZBGeek, DogNZB).
  • The hashed admin password for the Servarr instance (though the API key already provided full access).
  • Plex API tokens, which could be used to gain administrative control over the user's Plex server.

The patch implemented by the Servarr developers was remarkably concise, involving only "three lines of code and one import." Instead of blindly trusting the X-Forwarded-For header, the patched code now only trusts its contents if the immediate incoming request originates from an internal IP address. This allows legitimate reverse proxy setups to function while preventing external spoofing, demonstrating an elegant solution to a critical flaw.

Demo / Proof of Concept

▶ Watch: Discovering 'the whales': massive piracy media libraries (44:50)

During the talk, the speakers provided a clear and concise demonstration of the authentication bypass. They showcased a standard Radarr instance that had DFLA (Disable For Local Addresses) enabled.

The demonstration followed these steps:

  1. They first attempted to access the /api/v3/system/status/initialize.json endpoint directly without any authentication or header manipulation. As expected, this attempt failed, demonstrating that the instance was indeed protected by some form of authentication.
  2. Next, they modified their request by adding the X-Forwarded-For header with a local IP address value, specifically X-Forwarded-For: localhost (or 127.0.0.1).
  3. Upon sending this modified request, the application was successfully tricked into believing the request originated from a local network. Consequently, the DFLA setting was bypassed, and the /api/v3/system/status/initialize.json endpoint returned a JSON payload.
  4. Crucially, this JSON response contained the admin API key for the Radarr instance in cleartext.

While the live demonstration focused on retrieving the API key, the speakers then elaborated on the full capabilities and implications of this access, which they stated they did not perform on live vulnerable instances. With the admin API key, an attacker could:

  • Download a raw backup of the Servarr instance's database, which contained cleartext credentials for linked download clients (e.g., NZBGet), API keys for Usenet indexers (e.g., NZBGeek), and Plex tokens.
  • Theoretically, delete every movie or TV show from the victim's Servarr library and replace it with a single, custom entry (e.g., "Hackers"), demonstrating the destructive potential across potentially thousands of instances.
  • Pivot to other linked services like Plex using the extracted token, potentially taking control of the entire media server.

The demo effectively illustrated the ease and impact of the vulnerability, showing how a simple header manipulation could lead to complete compromise of a Servarr instance and access to a wealth of sensitive information.

Defensive Implications

▶ Watch: Shadow patch, disclosure timeline, and home lab security advice (51:50)

The findings presented in "Stealing From Thieves" offer crucial defensive implications for both individual self-hosters and the wider open-source community. The primary and most emphatic takeaway is simple: do not expose internal home lab applications directly to the public internet. This vulnerability, like many others affecting self-hosted services, underscores the inherent risks of making internal services externally accessible without robust security measures.

For users currently running Servarr applications (Radarr, Sonarr, Lidarr, Readarr, Prowlarr) or any other self-hosted service:

  1. Restrict Internet Exposure: The most effective defense is to keep these applications off the public internet entirely. If remote access is required, utilize secure tunneling solutions like Tailscale, VPNs, or SSH tunnels. These methods establish encrypted, authenticated connections without exposing the service directly to the internet.
  2. Disable DFLA (Disable For Local Addresses): If, for any reason, an application must be internet-facing (e.g., behind a reverse proxy for legitimate use cases like family media requests via Overseerr), ensure that the "Disable For Local Addresses" setting is explicitly disabled. Authentication should always be enforced, regardless of the perceived origin of the request.
  3. Keep Software Updated: Although the patch for this specific vulnerability was initially a "shadow patch," it was eventually rolled out. Users should regularly update their Servarr applications to the latest versions to benefit from security fixes. The patch specifically addresses the X-Forwarded-For header logic, ensuring it only trusts internal IPs when the request itself originates internally.
  4. Secure Reverse Proxy Configuration: For those using reverse proxies (e.g., Traefik, Nginx, Caddy), configure them securely. Ensure that they do not inadvertently pass sensitive internal headers or allow for easy header spoofing that could bypass backend application logic. While the Servarr patch mitigates this specific issue, a well-configured reverse proxy adds an additional layer of defense.
  5. Strong Authentication and Authorization: Beyond this specific vulnerability, always use strong, unique passwords for all self-hosted services. Where possible, enable multi-factor authentication (MFA). Although the Servarr apps initially lacked robust authentication, their evolution demonstrates an ongoing effort to improve security.
  6. Monitor for Anomalous Activity: Implement logging and monitoring for unusual access patterns or API calls to your self-hosted services. Unauthorized access attempts, especially those involving initialize.json or backup downloads, should raise immediate alerts.
  7. Consider Attacker ROI: As highlighted by the speakers, compromising a self-hosted instance of a tech-savvy individual (e.g., an IT admin or developer) could lead to higher-value targets. This "attacker ROI" should motivate a higher standard of security for home lab setups.

For open-source maintainers and developers, this talk underscores the challenges of:

  • Shared Codebase Management: Forked projects, while enabling rapid iteration, complicate coordinated security patching. Implementing shared libraries for core functionalities, especially security-critical components, can streamline vulnerability management.
  • Responsible Disclosure: The "shadow patch" scenario highlights the tension between securing users quickly and providing transparent disclosure. While quick remediation is vital, clear communication about vulnerabilities and patches is essential for user trust and effective defense.
  • Security by Default: Applications should prioritize secure-by-default configurations, especially regarding authentication and network exposure, rather than relying on users to actively configure security settings.

Key Takeaways

  • Avoid exposing home lab services to the internet: The most critical defense is to keep applications like the Servarr stack off the public internet. Use secure remote access solutions like Tailscale for safe internal access.
  • Critical authentication bypass existed in Servarr apps: A vulnerability allowed X-Forwarded-For header spoofing to bypass the "Disable For Local Addresses" (DFLA) setting, granting unauthenticated access and revealing admin API keys.
  • Shared codebase creates high attacker ROI: A single vulnerability in the core NZBDrone code impacted Radarr, Sonarr, Lidarr, and Readarr simultaneously, making it a lucrative target for attackers.
  • Vast amounts of sensitive data were exposed: Thousands of vulnerable instances on the internet revealed extensive media libraries (totaling an estimated 8 petabytes), cleartext download client credentials, expensive Usenet indexer API keys (valued at over $10,000+), and Plex tokens.
  • Open-source maintainers face significant challenges: Patching widely distributed, forked projects with a diverse and often non-security-minded user base is complex, sometimes leading to "shadow patching" as a pragmatic solution.
  • Always enforce strong authentication: Do not rely on local network exemptions (DFLA) if a service is even indirectly exposed to the internet. Keep all software updated to benefit from security fixes.

About the Speaker(s)

Nicholas Anastasi is a hacker who co-presented "Stealing From Thieves" at CypherCon. His work for this talk involved deep dives into Usenet protocols and code analysis of the Servarr stack's vulnerability.

Juan Pablo Gomez Postigo (JP) is also a hacker and co-presented "Stealing From Thieves" alongside Nicholas Anastasi. His contributions included extensive internet scanning, data collection, and statistical analysis of the exposed Servarr instances and their contents.

Both speakers identify as "hackers" and demonstrated a strong passion for cybersecurity research, particularly in uncovering vulnerabilities within widely used, community-driven software. Their presentation provided a unique blend of technical exploit details and a broad analysis of the online piracy ecosystem.

Reviews

Dr. Zero (Offensive Security Researcher) — SOLID

Anastasi and JP found a painfully simple X-Forwarded-For auth bypass in the Servarr piracy stack and mapped the global fallout. It’s an elementary bug in home-lab software, but the Fofa-driven ecosystem analysis and the maintainer shadow-patch drama make it a highly pragmatic watch.

Heather Calloway (CISO) — SOLID

This is a hacker-con presentation about exploiting home media piracy servers via a simple header bypass. It has virtually no direct enterprise relevance, but it serves as a stark reminder of what happens when consumer-grade remote access software meets the public internet. Enterprise leadership can skip this, though it validates our architectural assumptions about hostile remote-work environments.

→ Top-rated talks at CypherCon 9.0 (2026)

All talks from CypherCon 9.0 (2026)