PoeLLM Malware Mines Crypto on Exposed AI Servers

The PoeLLM malware has infected 3,400+ exposed AI servers, turning LiteLLM and Ollama hosts into a cryptomining botnet.

Two IT technicians in a cramped server room crouch beside an open rack of GPU servers, one holding a laptop while cooling fans spin behind them.

PoeLLM malware is finding AI servers that were never meant to face the internet

Black Lotus Labs, the threat research arm inside Lumen, published findings this week on a cryptomining campaign that has quietly assembled a fleet out of other people’s AI hardware. The PoeLLM malware behind it has compromised more than 3,400 servers, and the researchers observed as many as 800 infected systems checking in on a single day. That second figure is the one I keep returning to. A botnet that size is not somebody’s weekend script pointed at a block of IPs, it is maintained infrastructure with an operator behind it.

The victims show up mostly in the United States and Western Europe, and the software they were running tells you how they got picked: exposed LiteLLM instances, Ollama endpoints, the Gotenberg PDF converter, Gitea, plus signs of Ivanti Sentry targeting. BleepingComputer’s coverage (opens in new tab) has the full list of what Black Lotus Labs found.

What connects those tools is not a shared vendor. It is a shared habit. Every one of them gets installed because somebody needs to reach it over the network, so the bind address goes to 0.0.0.0, authentication gets treated as a later problem, and the hostname gets remembered by exactly one person.

GPUs are why an operation like this bothers with AI tooling at all. XMRig grinding away on a shared two-vCPU VPS earns close to nothing after power. A single halfway decent GPU changes that arithmetic completely, and an Ollama box spends most of its day with that GPU sitting idle. If nobody is running inference on the card, someone else running a miner on it costs you nothing you would notice until the fan noise changes or the cloud bill arrives.

I have watched this exact pattern in my own hosting work. A customer provisions a GPU instance for a weekend prototype, gets the answer they came for, and walks away. The server stays up because nobody cancels it. The invoice is the only reminder it still exists. PoeLLM is what moves into that box afterward, and it usually does not need a clever exploit. It needs a port that answers.

The campaign has been running since at least April, with activity climbing sharply since, and Black Lotus Labs has counted at least 11 command-and-control servers stood up so far. The victim figure moved during reporting as well, revised from 2,100 to 3,400 in the live report within the same day.

Background: how AI tooling ended up on the public internet

The reason so many of these hosts are reachable is baked into how the tools get deployed. LiteLLM’s proxy listens on port 4000, and Ollama on 11434, and in both cases the first tutorial anyone follows tells you to make the service available to the rest of your infrastructure. Setting OLLAMA_HOST=0.0.0.0 is a one-line change, it is in the official docs, and once you have made it the service answers on every interface the machine has. Authentication is a separate exercise, and it is usually the exercise that gets postponed until after the demo.

Gotenberg’s 3000 and LiteLLM’s 4000 are the two ports PoeLLM scans for, which is not a coincidence. Those are the ports that answer when someone never finished the hardening pass.

The second half of the problem is provisioning. GPU capacity is expensive enough that people treat it like a rental car. You spin up the instance for a prototype, you get the model answering questions, and then the project moves on and the instance does not. There is no decommissioning step in a weekend experiment. Reviewing the security group on a box you have mentally moved on from is not something most teams put on a calendar.

LiteLLM’s MCP server test endpoints carry CVE-2026-42271, and the original advisory for it described a vulnerability that required authentication and assigned it a high severity score. That framing is where a lot of teams stopped reading, because “requires auth” sounds like the door is already locked. Horizon.ai researchers then demonstrated that CVE-2026-42271 could be chained with a second issue, CVE-2026-48710, to produce unauthenticated remote code execution. That chain is what PoeLLM is attempting when it hits port 4000.

This is worth sitting with. A vendor severity rating and an authentication requirement are two separate claims, and only one of them turns out to be durable. When I patch something like this on my own boxes I try to patch the underlying package version rather than reasoning about whether my particular configuration satisfies the precondition the advisory assumed. The precondition is somebody else’s model of my setup, and they have never seen my setup.

The exposure pattern is not really an AI problem. It is the same story as an unauthenticated Redis on 6379, or an Elasticsearch node on 9200 with no password, just with a newer set of tools and a much better reason to attack them.

How does PoeLLM malware get its command-and-control addresses?

Where does the malware look for its C2 server?

It reads four words or phrases out of a poem titled “On the Nature of Connection,” which lives in a dash.css file inside a GitHub repository. The repo looks like a fork of Node.js, so the stylesheet is the last file anyone would open. Each of the four words gets pushed through a hard-coded dictionary that returns a number, and four numbers in sequence build an IPv4 address. That address is where the implant calls home.

Why hide an IP inside a poem instead of just embedding it?

Because a hard-coded address burns the moment someone publishes it, and this campaign has already cycled through a fair number of them. Black Lotus Labs (opens in new tab) counted 11 modifications to the poem to date. Changing the C2 costs the operator one commit: edit the text, push, and every infected host that checks in afterward resolves a new address while the binary on disk stays byte-for-byte identical. File hashes remain the same across the whole botnet even as the infrastructure underneath rotates, which is the specific property that makes hash-based detection useless here.

I have dealt with cruder versions of this before, mostly domain generation algorithms. A DGA has the implant compute hundreds of candidate domains so the operator only has to register one. PoeLLM does the reverse and carries the lookup table on disk, fetching only the seed from a page anyone can edit. Same objective, and the same weakness: both need outbound access to something the operator controls, and both leave a pattern in the logs that does not look like normal application traffic.

What does the malware actually do once it is running?

The implant is an ELF binary named libgcrypt, a name chosen so it sits quietly in a process list next to the legitimate libgcrypt shared library your distribution already ships. It carries a remote shell, the XMRig and Iron cryptocurrency miners, HTTP and HTTPS scanning, and the ability to push exploits at whatever that scanner finds. Infected hosts communicate with Kryptex, a Russian cryptomining service, which is where the revenue from your GPU hours ends up.

Blocklisting the addresses themselves is a losing game when the list changes on the operator’s schedule rather than yours.

What this means for anyone running an exposed LiteLLM or Ollama instance

The part that gets underestimated is the second job your box gets handed. PoeLLM does not just mine. It runs HTTP and HTTPS scanning on its own, sweeps ports 3000 and 4000 looking for the next Gotenberg or LiteLLM instance, and throws exploits at whatever answers. Black Lotus Labs describes the victims as springboards in its report (opens in new tab), and that wording is accurate. Your server ends up doing the operator’s reconnaissance for them, and it does it from your IP address. The abuse report lands in your ticket queue, not theirs.

Anyone who has had a shared hosting account compromised will recognise the shape of this. The account starts sending spam, the datacenter nulls your IP, and you spend two weeks on delisting forms while the person who actually broke in has already moved to another host. Cryptomining is the same trap with a larger power draw attached.

There is a detail in the research worth sitting with. Several of the C2 servers were sitting behind vulnerable router administration interfaces. That points to compromised routers being reused as command-and-control rather than dedicated servers rented for the purpose. The infrastructure this botnet depends on is other people’s neglected hardware, which says something about how low the barrier is on the defence side too. If a router’s admin panel is reachable from the internet with default or weak credentials, that router could be a link in this chain whether or not its owner runs any AI tooling.

Attribution deserves care. The researchers assess with moderate confidence that the operator is Italian, based on comments in the malware and an Italy-based server hosting the administrative interface. That is a lead, not a conclusion. Malware authors leave comments that point elsewhere on purpose, and a server in a country is not a person in that country. I would not build a threat model around nationality here.

What is not in doubt is the economics. Payouts run through Kryptex, a Russian cryptomining service, and the arrangement is simple: your electricity bill, your GPU depreciation, someone else’s revenue. There is no clever business model underneath any of this. It is theft of compute, sold at spot price.

What to expect next

The poem is going to change again. Black Lotus Labs counted 11 modifications to that dash.css file so far, and the researchers expect at least one more. That has a direct consequence for anyone defending these hosts: a detection rule built by matching the current wording of “On the Nature of Connection” is a rule with a very short expiry date. The fetch to that GitHub repository is the more durable signal, along with the outbound connection that follows it. A string match dies the moment the operator edits a few lines of verse, and a file hash dies the next time the binary is rebuilt.

The same fragility applies to the headline numbers. Both the C2 count and the victim count moved upward while the campaign was being reported, and the compromised server figure was corrected from 2,100 to 3,400 within the same day. That revision is a live incident being measured rather than sloppy reporting. When you cite 3,400 in a change meeting, treat it as a snapshot and not a total.

My expectation, and this is inference rather than anything the report states, is that the next targets will be AI services outside LiteLLM and Ollama. The pattern that made those hosts attractive is not specific to either project. It is a model runtime installed to listen on a public interface, with authentication treated as a problem for later. Every new tool in this space gets deployed that way during a proof of concept, and the ones that survive to production usually keep the configuration they were built with. A speech model wrapper, an image generation endpoint, an embeddings service, whatever gets popular next quarter, the misconfiguration travels with it.

That pushes detection toward behaviour rather than static indicators. Outbound connections to mining pools, a host that starts probing ports 3000 and 4000 across your own subnets, a process tree nobody scheduled. Those survive a poem rewrite and an IP change. Indicators of compromise are useful for the sweep you run the week a report drops. They are not a monitoring strategy, and treating them as one is how a machine stays infected for a month while everyone assumes the blocklist is doing the work.

Check your own boxes today

I have done this sweep on my own boxes more than once, and it takes about ten minutes if you know what you are looking for. Start with ss -tulpn and read the output properly. You want to know whether anything on port 3000 or 4000 is bound to 0.0.0.0 or :: rather than 127.0.0.1. Gotenberg and LiteLLM are the two the malware scans for, but if you find a container port published to the world that you did not intend to publish, that is your problem regardless of which service is behind it. On a Docker host, docker ps alongside iptables -t nat -L -n will tell you the same thing from the other direction.

Then patch LiteLLM. Both CVE-2026-42271 and CVE-2026-48710, not just the first one. I understand the temptation to read “requires authentication” in the original advisory and file it under lower priority, because most of your LiteLLM surface does sit behind a proxy. Horizon.ai showed that assumption does not hold once the two issues are chained into unauthenticated remote code execution, which is precisely the chain PoeLLM is attempting. The login page you put in front of the app means nothing if the exploit runs before authentication is evaluated.

For the file check, the binary is an ELF file named libgcrypt. The real libgcrypt lives in your system library directories, so search specifically outside them. find / -name 'libgcrypt*' -not -path '/usr/lib/*' -not -path '/lib/*' 2>/dev/null is a reasonable starting point. Then look at your process list for XMRig or Iron instances you did not start, and watch outbound traffic for sustained connections to mining pools or to Kryptex. A CPU graph that climbs to 100 percent at 3am and stays there is not a cron job you forgot about.

Cross-check your network logs against the Black Lotus Labs indicators of compromise today, because that is a one-off task and it is worth doing while the addresses are still current. The part that actually matters is what you do next week, when the poem has been rewritten and the IPs in that list point at nothing. Pick the one behaviour you can detect reliably on your own infrastructure, whether that is an unexpected process opening outbound connections or a host scanning internally, and write the alert rule before you close the ticket. If you only do one thing after reading this, do that.