The media room is the part of a community building that got a network connection first, because someone wanted it for the projector. What runs on that connection is, more often than any self-hosting guide admits, Plex Media Server — a proprietary, closed-source media server that organizes an archive of movies, photographs, home videos, and music, and streams it to players on the LAN and to relatives over the internet. It is the service nobody audits, because it is the service nobody filed under infrastructure. Its port, 32400, is the one that forwards get cut for without a change window, because the feature that motivated the forwarding is a relative's movie night.

And its history as an entry point is not hypothetical. In 2020, CISA catalogued CVE-2020-5741, a Plex remote-code-execution flaw it would later list as actively exploited; the company that lost the most from that bug was not a Plex user but LastPass, whose August 2022 corporate-vault breach began, investigators believe, when attackers compromised the home Plex installation of a senior DevOps engineer and moved from there to his work machine. Plex itself had to force password resets in 2022 after attackers stole a database of emails, usernames, and hashed credentials. Shadowserver has measured the exposed fleet continuously since September 4 of this year: over 36,000 internet-reachable Plex Media Servers still unpatched, scanned and reported daily. That is the installed base this story landed on.

What Zach Main found

On July 27, security researcher Zach Main reported four vulnerabilities in Plex Media Server 1.43.2 and earlier to security@plex.tv. Individually, each is the kind of medium-severity finding that would sit politely in a queue forever — Plex acknowledges them, QNAP later describes the set as bugs that "present limited risk on their own." Chained, the researcher scores them 9.8: an unauthenticated attacker on the internet reaches code execution with the privileges of the plex user. The PoC is public. Plex's own October update lists the four identifiers and what each one is:

| CVE | What Plex says it is | | --- | --- | | CVE-2026-96652 | Unauthenticated SSRF in the player timeline endpoint | | CVE-2026-96654 | Access to internal agent functions over the loopback interface | | CVE-2026-96655 | Disclosure of the server owner's admin token | | CVE-2026-96656 | Arbitrary file write to the Codecs directory through transcoder preferences |

Walk the chain, because each stage is a breach of a trust contract the code never states anywhere:

Stage 1 — the token gate that does not check tokens. /player/timeline, part of the companion protocol by which remote controls and casting devices talk to the server, is gated from the internet on the X-Plex-Token header. The check asks only whether the header exists. X-Plex-Token: junk passes. The endpoint then builds a callback URL from parameters the player supplies — protocol, host, port — and protocol is spliced in raw. Supply a full URL and the server will, on unsubscribe, POST to it from itself, from a genuine 127.0.0.1 origin, with attacker-chosen contents. Blind, POST-only, and exactly enough.

Stage 2 — the guard swallowed by its decorator. The loopback origin now qualifies for /system/agents/*, the plugin-management API family that Plex opens tokenless on loopback because loopback should mean itself. The searchOne endpoint checks that the requested agent identifier is registered — inside a function wrapped by a @lock decorator that discards the wrapper's return value. When the guard's early return fires, it returns from the inner function; search_one continues anyway. The identifier is then spliced unsanitized into an internal URL: a ? in it opens a query string, a # truncates the tail. The attacker now controls the path and query of a loopback request to any plugin function.

Stage 3 — the prefix that hands over the admin token. The bundled TheTVDB metadata agent has a network-fetch function the attacker can now call with an arbitrary URL. The plugin framework's outbound HTTP requests carry the owner's local-* administrative token whenever the destination URL starts with http://127.0.0.1 — an unbounded string-prefix match, attached so the server can authenticate to itself. The researcher points the injected call at http://127.0.0.1.<attacker-ip>.sslip.io:8952/ : the prefix matches, the token is attached, and DNS resolves the rest of the hostname to the attacker, who now holds owner administrative credentials without ever proving possession of one.

Stages 4 and 5 — write what you like, load what you wrote. With owner access comes PUT /:/prefs, and among the owner-writable preferences is TranscoderH264Options — a string appended verbatim to the x264 encoder's command line on every transcode. x264 has a debug option, dump-yuv, that writes decoded frames to a file path of the caller's choosing. Setting lossless encoding (qp=0) makes the written frames a bit-exact copy of the input, and the input is attacker-hosted video: the frame's pixels are an ELF shared object, byte for byte. The write lands in Plex's own Codecs directory — which the transcoder enumerates at startup, dlopening every file ending in .so with no lib-prefix check, no execute-bit requirement, no signature verification, no required symbol. The ELF's constructor runs on load. One more transcode later, the attacker's code is executing as the plex user, which in the PoC means a reverse shell.

Four contracts, each broken quietly: a gate that checks existence instead of validity, a decorator that eats its callee's early return, a string-prefix decision standing in for a real origin check, and a loader that trusts a directory the attacker can now write to. None of them would have survived an hour of adversarial review with source in hand. Plex is closed source; the reviewer had hours anyway. That is the auditability column of this site's ledger, written by someone who did not need it.

The timeline the ledger keeps

The mechanics are one story. The dates are the other, and they are the reason this site files this under its warnings-without-CVEs ledger.

  • July 27 — reported to Plex.
  • August 4 — acknowledged, bounty paid, and the fixed build 1.43.3.10861 ships the same week. Eight days from report to fix: fast. Honest column first: Plex's response to the researcher was not the problem.
  • September 1 — Plex posts a warning to all users: update your servers to "1.43.3 or newer" and your desktop clients, "to address a number of security issues," with no description of what the issues are, and this sentence: "CVEs have been requested and we'll reply to this thread with more details once they're published." It also flags, quietly and correctly, the failure mode that dominates the weeks ahead: "If you're running Plex Media Server on a NAS device, the updated version may not be available in their package manager yet."
  • September 4–9 — Shadowserver begins daily scanning and reporting of unpatched, internet-reachable Plex servers, and publishes the count: 36,000+. Their framing is the sharpest sentence in the whole record: "No CVEs have been issued meaning the vulnerabilities are invisible to the security community limiting an effective response." A warning exists. A number exists. A pin for trackers does not.
  • September 23 — the four CVEs are assigned.
  • October 16 — the technical write-up publishes. October 17 — first reports of exploitation in the wild, honeypot servers catching a cryptominer within a day. October 19 — the PoC goes public, and Plex replies in its own thread with the CVE table and the sentence that matters: "These vulnerabilities are being actively and widely exploited… If your server is older than 1.43.3.10861 and reachable from the internet, assume it may be compromised."
  • October 20 — CISA adds all four to the Known Exploited Vulnerabilities catalog and gives federal agencies three days — until October 23 — to patch or mitigate.
  • November 6 — QNAP publishes a security notice: it has received multiple reports from users that Plex Media Server on their NAS appears to have been compromised. Its support team is working the cases — and confirms, worth saying plainly, that no data loss occurred in those it assisted. QNAP PSIRT confirms the flaw is in Plex, not QTS or QuTS hero.

Count the ledger distances, because they are the structural entry, not the vendor:

  • Fix to CVE: 7 weeks. The build existed; the identifier did not. Every CVE-driven patch tool, compliance checklist, and scanner sat blind on a bug CISA would later certify as exploited in the wild.
  • Warning to details: 6 weeks. Users were told to patch on trust in September — the right request, made properly opaque. Vendors do this for exploit-window reasons. There is no evidence of harm caused by the delay. It is still the mechanism by which a 36,000-server fleet sat exposed and measurable (by Shadowserver, by anyone scanning) yet un-prioritizable, for the entire window.
  • Threshold drift: the whole story in one build number. September's instruction was "be on 1.43.3 or newer." October's truth is that 1.43.3.10861 specifically is the line: Plex says "1.43.3.10861 and later are not affected". An early-1.43.3 server — exactly what September's instruction produced — does not clear Plex2Shell. Check the build, not the minor: Plex Web → Settings → General → 1.43.3.10861 or later.

The appliance column closes its own parentheses: on September 1 Plex had already warned that NAS package managers may lag, and on November 6 — two months later — QNAP's App Center instruction is to update to 1.43.3.10861 immediately, with later releases to follow "once verified. Do not wait for them." The fleet that updates only when something screams is the fleet that gets popped in October; the fleet that cannot update until the appliance vendor distributes is the one QNAP was fielding reports from in November. Neither failure is Plex-shaped. This is the same long tail the GS1900 switch story measured in firmware: the exploit arrives weeks after the researchers, and months — in bandwidth, not blame — after the fix.

How it was found

The method is now a standing entry in this site's ledger of security work done with language models in the loop, and Zach Main's write-up describes it with the same candor this site asks of itself: "Recon -> Hunt -> Verify -> Chain" — component maps, focused hunting per component, then a step most reports skip: "Spawn a separate agent to try to disprove each finding. If it can't refute the bug, it's likely real." Four repeated hunt cycles; LLMs used heavily throughout; hours of iterative work, dead ends included, with the judgment calls — what to chase, what to deprioritize — all human. The same shape as August's Linux-kernel handshake race, the same shape as November's musl star-field sshd bypass, the same shape as Binarly emulating Zyxel firmware to test whether the vendor's patch actually patched. What separates this workflow from the model-hype coverage is the disprove step: an LLM that only confirms will confirm a bug that isn't there. An agent armed to refute, and failing to, is the closest thing this field has to a second signature.

The operator checklist

For a fire hall, community hall, shared office, or the box in the closet that streams movie nights:

  1. Check the exact build. Plex Web → Settings → General. You need 1.43.3.10861 or later. On a QNAP NAS, App Center → My Apps → update Plex Media Server now; Synology's package was lagging too — Plex posted manual-install instructions for every platform in the same thread. The version number in the app icon is not the number in Settings. Trust the one in Settings.
  2. Classify your exposure honestly. Internet-reachable does not mean only "I forwarded a port." QNAP's notice names the two you forget: Plex Remote Access, and the port opened automatically through UPnP or router auto-configuration. If either was on while the server ran a version below 1.43.3.10861, your box was on the internet.
  3. If vulnerable and internet-reachable, assume compromised. Both the vendor and Plex say it in those words. Updating now removes the bug, not the attacker. QNAP's remediation, and Plex's, agree on the order: check the tells first, then rebuild from a clean installation rather than reusing the old Plex data directory — at minimum empty the Codecs folder (the .so drop location) and audit Preferences.xml for transcoder options you never set (TranscoderH264Options is the persistence key) — then sign out of all devices from your Plex account and change the password. If you want QNAP's help validating a suspected compromise, preserve the Plex Logs folder before removing Plex, then open a support case with it attached.
  4. Hunt, per Plex's own published tells: processes started by Plex Media Server that you did not ask for — the observed names are myawesomeproxy, mylovelyminer, x12345 — unfamiliar .so or .dll files in the Codecs directory, outbound connections to proxystream.st, and sustained CPU load while nothing is playing.
  5. Treat the blast radius as everything the plex user could touch. On most NAS installs that means the media share — photographs, family archives, the community's whole digitized collection. Plex's guidance: assume anything the service account could reach was exposed, including credentials, mounted shares, or other services on the same machine. The LastPass chain in 2022 ran exactly this pattern, one hop at a time.
  6. Change the posture, not just the version. If remote access is genuinely needed, put it behind VPN instead of forwarding 32400. If it is not needed, switch off Remote Access under Settings and make sure the router is not auto-opening the port under you. The media server does not need a front door; it needs one admin who knows where the back door is.

The closing honest note

This is not a story about a vendor behaving badly. Plex answered in eight days, paid the bounty, warned its fleet in September, published the mechanism, the IoC list, and an "assume compromised" sentence that many vendors would have buried, and Zach Main's write-up closes by thanking the Plex security team for the quick response and fixes — earned words, not boilerplate. The failures in the record are structural, and every one of them lives downstream of the vendor: a proprietary binary that lets nobody but its own team weigh exposure; a warning-without-CVE window that left trackers and scanners staring at a measurable 36,000-server blind spot; a threshold that moved from "1.43.3" to a specific build without telling anyone outside the PSIRT; and an appliance distribution model in which the fix's availability and the fix's distribution are different months.

And the honest part for this site's own audience: the service most community buildings run without filing it under infrastructure is the service that sits between the internet and the photograph archive. If the media server is on your network, it is on your patching schedule, or it is on someone else's exploitation schedule. The self-hosting story this site keeps telling — the fix that shipped before the advisory and the webshells that landed before the CVE — ends the same way every time: the tools exist to know your exposure; the deciding factor is whether anyone is assigned to the knowing.