Gino Eising
Gino Eising
Nerd by Nature
Oct 28, 2026 8 min read

Trivy Scanned My Compromised Server This Morning. It Found Two OpenSSL Bugs.

thumbnail for this post

Cover: after René Magritte, The Lovers — two figures with heads covered, kissing; the scanner and the vulnerable image, intimately close, seeing nothing.

October 2026: the scanner was healthy, up to date, and looking straight at it.

Last weekend I finally got around to a project that sat on the backburner for months: proper vulnerability scanning for the cluster. Trivy Operator, a built-in server so scans avoid re-downloading the vulnerability database every run, a UI, alert rules, and an accepted-risk register with review dates. The works. I felt pretty good about it. The cluster was finally observed.

What I did not know is that while I was writing alert rules on Saturday, someone else’s software was unpacking itself inside my Plex pod. We were both deploying that weekend. Only one of us got coffee out of it.

The discovery, or: why is the storage node on fire?

I run Grafana OnCall for this cluster with pages sent directly to my phone. The alert system did do its job here, just completely sideways.

The alert fired because the storage node was pinned at 100% CPU. All four cores of its little N100 pegged solid, load average past fifteen, and the tiny fans screaming. My first thought was not security panic; it was standard homelab irritation: what is Plex doing now? A rogue library scan? Intro detection running wild? Credits analyzer stuck in a loop?

My OCD kicked in immediately: nothing burns 100% CPU on that storage node without my say-so. I opened a shell to go kill whatever Plex was doing.

Inside the pod, Plex Media Server was sitting at 0.4% CPU. Blissfully idle. It was not transcoding anything. Meanwhile, a process named postgresql was chewing through two and a half cores. There is no PostgreSQL in that pod, and there never has been. Supervising it were two processes claiming to be systemd, which was also an obvious lie.

That was not Plex having a rough day. That was an intruder.

In a strange way, my monitoring caught it anyway: not because a security tool flagged a breach, but because an unconstrained miner broke my baseline and annoyed me enough to look.

What had moved in

The technical breakdown: an XMRig Monero miner, dropped by an automated worm through a chain of Plex bugs (CVE-2026-96652, -96654, -96655, and -96656). The chain starts with an unauthenticated SSRF and ends in arbitrary file write with execution on load. Plex patched this in build 1.43.3.10861. I was on build 1.43.3.10828. Just thirty-three builds behind, which turned out to be the exact distance between a working media server and free hashing power for strangers.

The timeline is what stands out:

  • Tuesday: CVEs published and added to CISA’s Known Exploited Vulnerabilities catalog.
  • Friday: worm build stamp indicates it was packaged.
  • Saturday: worm lands in my pod. That exact Saturday, during the Trivy rollout.

Five days from public disclosure to mass internet exploitation.

The ridiculous part: Trivy scanned that exact container image while the miner was actively running inside it. The report timestamp sits right in the middle of the incident. It found zero criticals and two high-severity bugs in OpenSSL. The scanner ran cleanly, held fresh databases, and looked straight at a KEV-listed, actively exploited workload.

It just could not see what mattered.

Why the scanner was blind (and why that is normal)

Trivy, like most container scanners, checks packages against vulnerability databases. It parses Debian, Ubuntu, and Alpine packages, or language libraries from npm, PyPI, and Go modules. If a known package manager installed it, the scanner evaluates it.

Plex Media Server is shipped as a proprietary binary blob. It is not an upstream distro package with a security feed. The CVE had an NVD entry and a CPE string, but none of that feeds into static package manifests inside the container. The vulnerability lived where the scanner simply does not look.

There was a second failure, and this one belongs to me. Trivy Operator includes a config-audit scanner that checks running workloads for missing limits and dangerous capabilities. It would not have caught the unindexed binary flaw either, but it would have screamed about running without CPU limits. It also would have flagged an rclone sidecar running with elevated privileges. That sidecar needed /dev/fuse and bidirectional volume mounts so Plex could read virtual debrid storage, but it still widened the attack surface. I had turned off the config-audit scanner in my Helm values to keep the installation minimal and quiet.

The worm never bothered with container escapes or node escalation. It did not need to. It was an automated mass-dropper hunting idle CPU cycles across the web.

The uncomfortable math

Most self-hosters run zero scanners. I ran none until last weekend, even with family photos and email sitting in the cluster. Running Trivy with blind spots still beats running nothing, because nothing finds nothing every single time.

The real takeaway is knowing what question a tool answers. An image scanner answers “is this static image vulnerable?” It cannot answer “is this container compromised right now?”

The first question looks up records in a database. The second question requires runtime reality: Why is CPU at 300% when Plex is idle? Why is a media container talking TLS to a Monero pool? Why is a process renaming itself to systemd inside a container that has no init system?

The controls that catch this quickly are behavioral:

  • Targeted CPU alerts: a rule catching high pod CPU while the primary process idles names the bad workload immediately.
  • Egress policies: default-deny outbound filtering suffocates miners and droppers before they pull payloads or stratum configs.
  • Runtime detection: tools like Falco catch binaries running out of /tmp or faking process names instantly.
  • Aggressive patch cadence: five days was too slow for internet-facing services on KEV.

The parting gift: an abuse sweep

Before closing out the incident, I spent thirty minutes making life harder for whoever ran this campaign.

Worms rely on fragile staging and payout pipelines. Once you pull the strings from the binary, the infrastructure is right there:

  1. The mining pool (SupportXMR): The worker hashed to wallet 83YFdNe...6f5SeX with "rig-id": null to lump all victims together. Querying the pool’s API revealed the campaign: roughly 8.72 MH/s aggregate hash rate, nearly 300 million valid shares, 26.3 XMR paid out, and ~0.35 XMR pending. I submitted an abuse report to SupportXMR administration with binary hashes and infection logs, requesting a freeze on pending payouts.
  2. The C2 beacon (AlexHost): The worm checked http://176.123.7.7/ks/ksoftirqd.vlog on AS200019 to rotate pools and push configuration updates. I filed an abuse ticket with AlexHost to terminate the endpoint.
  3. The staging server (FreeINet): Droppers fetched ELF binaries directly from http://80.87.206.86/bins/. I sent FreeINet abuse the SHA-256 hashes for the dropper (a43724fa...), the miner (77d764ce...), and the supervisor (e9c4bc82...) to take down the distribution box.

When cleaning up after malware, do not just wipe the volume and move on. Extract the indicators, query the pool, and report the infrastructure. Freezing wallets and killing staging hosts turns a hands-off profit stream into real operational pain for the attacker.

The measures: closing the blast radius

Here is what actually changed in the cluster:

  1. Rebuild, sanitize, and verify: Upgraded Plex to patched release 1.43.5.11079 through GitOps, purged the persistent storage of dropper and supervisor files (.irc, .f, modified scanner), and rotated PLEX_TOKEN via Bitwarden. Host-level sweeps confirmed the host roots remained untouched.
  2. Resource limits: Added strict CPU limits (2000m on main, 500m on sidecars) with minimal requests to fit node scheduling. If a rogue process spikes, it throttles hard and trips alarms instead of starving neighbors.
  3. Behavioral alerting: Added Prometheus alerts for PodRunawayCPU, PodCpuThrottledHard, and NodeCpuSaturated.
  4. Runtime security with Falco: Deployed Falco with eBPF across every node to monitor system calls directly for executions in /tmp, hidden binaries, and outbound mining ports.
  5. Egress restrictions: Applied NetworkPolicies blocking outbound traffic and blackholing known malicious C2 and mining ranges.

What I would tell Saturday-me

Deploying the scanner was fine, but treating it like a perimeter was a mistake. Scanners are smoke detectors: they report specific signatures in specific areas, and say nothing about whether someone already walked in through an open window.

The attacker was not outsmarting my tooling. They were simply playing a different game: scanning the internet for vulnerable targets faster than routine patch cadences run.

Limits constrain the damage. Egress rules kill the payout. Runtime monitoring makes it loud.

The scanner still has its place for scheduled maintenance. Just do not expect it to tell you when you are actively on fire.

Update, one day later: the pool answered, and I outsmarted myself

Two additions worth reporting.

The abuse sweep worked. SupportXMR replied within hours: wallet denylisted. The pool API the next morning told the rest of the story. Hash rate zero. Last share submitted an hour before the ban. Nearly three hundred million shares of stolen compute, suddenly mining into a void. The operator now has to rotate wallets across however many thousands of victims remain, and the beacon they would use to push that rotation is sitting in an abuse queue in Moldova.

The honest footnote: they kept the pending balance. A final payout of roughly 0.44 XMR landed right before the denylist hit. I killed the income stream, not the last paycheck. If you ever find yourself reporting a botnet wallet: do it the same hour, not the same day. Pools pay out on thresholds, and the worm’s threshold was lower than my response time.

And the rollout took Plex down. The resource limits from measure two? I set limits without requests. Kubernetes, helpfully, defaults a missing request to equal the limit. My media server suddenly demanded two full CPU cores on a node with 99% of its request budget already allocated. The scheduler took one look and said no. Plex spent part of the evening unschedulable, taken offline not by the worm but by the fix for the worm. The repair: token requests of a few millicores, keep the hard limits, let the limits do the throttling. There is a special kind of humility in paging yourself with your own security hardening.

The host scans also finished: all three nodes clean. The worm never left the container it came in through, which makes that privileged rclone sidecar the luckiest near-miss of the whole incident.