LLM Spend TripwireChecklistCodeHosted waitlist

Is your LiteLLM, Open WebUI or Ollama exposed? A key-theft self-check

From Swift Labs, makers of LLM Spend Tripwire. Written with AI help and checked against the sources linked below on November 19, 2026. Swift Labs isn't affiliated with Amazon, LiteLLM, Open WebUI, Ollama or Anthropic. This is general information, not security advice. Only run these checks on systems you own or run.

On November 13, 2026, Amazon Threat Intelligence published what its MadPot decoy sensors captured from AI agents between October 3 and November 5, 2026 (source). The agents ran on ARTEX, which Amazon describes as "an open-source agentic AI penetration testing framework". The most prominent campaign stole credentials for AI models, and Amazon says it was organized so that "stolen keys paid for the LLM inference powering further credential hunting."

The method, in Amazon's words: "find internet-exposed AI applications, extract the upstream provider keys they hold, validate those keys, and store them in a managed pool." The agents focused on apps that hold keys for other providers, "because one weak management interface can expose many downstream accounts."

Two things Amazon is careful to say. It learned most of this from the agents' own records, and it "cannot verify the outcomes the agents reported". And "None of the techniques in these campaigns were new." The agents succeeded where basic hygiene was missing. So the checks below are basic ones.

The short version

  1. Find out whether LiteLLM (port 4000), Open WebUI (3000 or 8080) or Ollama (11434) can be reached from the internet. If it can and doesn't need to be, bind it to 127.0.0.1.
  2. LiteLLM: make sure a master key is set and it isn't sk-1234.
  3. Open WebUI: make sure the first account, which becomes the admin, is yours.
  4. Patch anything named in Amazon's playbook, and look for keys in front-end files and .env files you serve.
  5. If anything was exposed, rotate every provider key the app held, then watch your usage and spend for the next few days.

What Amazon's report names

Targets. "LLM gateways and proxy platforms such as One API, New API, Veloera, Sub2API, and LiteLLM, and AI application builders such as Dify, FastGPT, Langflow, RAGFlow, Open WebUI, LobeChat, and Ollama" (source).

The playbook. Amazon says the agents mapped each product they found to a known attack chain, including:

Speed matters. The operators told the agents "to treat credentials exposed publicly for more than 30 days as low-value inventory." Amazon's advice is to "assume exposed secrets and misconfigurations will be found quickly and remediate accordingly."

Indicators. Amazon's post ends with a table of IP addresses seen in the campaigns, with first-seen and last-seen dates. You can search your reverse proxy or firewall logs for them. The rows marked "Campaign 1" are the key-theft campaign. Four of the addresses (104.28.x) are in Cloudflare's network (ARIN), which carries traffic for many unrelated people, so a match is a lead to check, not proof of an attack.

1. Can the internet reach it?

These are the ports the official docs use:

App Port in the docs Source
LiteLLM proxy 4000 LiteLLM quick start
Open WebUI 3000 on your machine with Docker (-p 3000:8080); 8080 with open-webui serve Open WebUI quick start
Ollama 11434 Ollama FAQ

Ollama "binds 127.0.0.1 port 11434 by default", and you change that with the OLLAMA_HOST environment variable (source). Ollama's local API "does not require authentication" (source). So if you set OLLAMA_HOST=0.0.0.0:11434 on a machine with a public address, anyone who can reach that port can use it. If you've signed in to ollama.com on that machine, cloud models also run through the local API (source), so they'd be usable too.

A common way this happens. Open WebUI's docs tell you to set OLLAMA_HOST=0.0.0.0 when Open WebUI runs in Docker and can't reach Ollama on the host (source). If you did that, binding Ollama back to 127.0.0.1 will break Open WebUI. Instead, block port 11434 from the internet with your server's or cloud provider's firewall, or run Ollama in Docker on the same network as Open WebUI without publishing 11434. Containers on the same Docker network can reach each other's ports, and other machines can't (source).

Docker publishes to every interface unless you say otherwise. Ollama's Docker command is docker run ... -p 11434:11434 ... (source), and Open WebUI's uses -p 3000:8080. Docker's docs say a mapping with no host address publishes "to all host addresses", and "Publishing container ports is insecure by default" (source). A ufw firewall rule doesn't help here: Docker says published container traffic is diverted "before it goes through the ufw firewall settings" (source).

Check on the host. See what's listening and on which address:

# 0.0.0.0 or [::] means every interface; 127.0.0.1 means this machine only
sudo ss -tlnp | grep -E ':(4000|3000|8080|11434)\b'

# Docker port mappings; look for 0.0.0.0:11434->11434 and similar
docker ps --format '{{.Names}}\t{{.Ports}}'

Check from outside. From a different network (a phone hotspot works), try your server's public address. For Ollama, /api/version is a harmless request:

curl -m 5 http://YOUR_PUBLIC_IP:11434/api/version

Any answer means the port is open to the internet. Try http://YOUR_PUBLIC_IP:4000/, http://YOUR_PUBLIC_IP:3000/ and http://YOUR_PUBLIC_IP:8080/ in a browser the same way. open-webui serve listens on every interface (0.0.0.0) unless you pass --host 127.0.0.1 (source).

Fix. If only this machine needs it, publish to localhost: -p 127.0.0.1:11434:11434 (source). If other people need it, put it behind a reverse proxy with authentication. Ollama's FAQ shows Nginx, ngrok and Cloudflare Tunnel setups (source). Open WebUI says it "is built for private, trusted networks" and suggests a reverse proxy with authentication and IP allowlisting (source). LiteLLM says to run the gateway "on a private network when possible and expose only the routes clients need" (source).

2. LiteLLM: the master key

LiteLLM's master key "is the proxy admin credential: it authenticates admin API calls and is the Admin UI login password" (source). A key owned by a proxy admin "can manage keys, users, and teams" (source).

Two settings are dangerous (source):

Current LiteLLM versions refuse to start in either case, unless someone turned on the override LITELLM_DANGEROUSLY_PERMIT_WEAK_OR_UNSET_MASTER_KEY (or dangerously_permit_weak_or_unset_master_key in config.yaml) (source). An older version, or that override, means you need to check yourself.

Check. In the folder with your LiteLLM deployment files:

# Any hit is a problem: the example key, or the override
grep -rnE 'sk-1234|DANGEROUSLY_PERMIT_WEAK|dangerously_permit_weak' \
  .env config.yaml docker-compose.yml 2>/dev/null

# Is a master key set at all? Prints "set" or "NOT SET", never the key
grep -qE '^\s*LITELLM_MASTER_KEY=.+' .env && echo set || echo "NOT SET in .env"

Also check general_settings.master_key in config.yaml. If it holds a literal value, LiteLLM uses it over the environment variable (source).

Fix. Generate a new key with echo "sk-$(openssl rand -hex 32)" and set it wherever LITELLM_MASTER_KEY is set (source). Read LiteLLM's rotation page before you swap it. If no LITELLM_SALT_KEY is set, the master key also encrypts the provider credentials stored in the database, and "replacing the key alone makes them unreadable". The page explains the LITELLM_MIGRATE_FROM_MASTER_KEY step for that case. Back up the database first.

While you're there:

3. Open WebUI: who is the admin?

On a new Open WebUI install, the first screen offers Create Admin Account. "That first account is the administrator: it manages users and every instance-wide setting" (source). Signup "is open only until the first user registers, who becomes the administrator" (source).

That's the "uninitialized installs that could be claimed" case from Amazon's list. If you started Open WebUI on a reachable address and never finished setup, whoever loads the page first can create the admin account. Connections to model servers, such as Ollama, are set in the admin section of Settings (source).

Check.

Fix. For automated deployments, you can create the admin at startup with WEBUI_ADMIN_EMAIL, WEBUI_ADMIN_PASSWORD and WEBUI_ADMIN_NAME; this "only takes effect when no users exist in the database" (source). Keep the default DEFAULT_USER_ROLE=pending, so new accounts can't do anything until you approve them. Open WebUI's advice: "Do not re-enable open registration on instances that are accessible beyond a trusted network."

4. The rest of the playbook

5. If anything was exposed: rotate

Close the hole first (section 1), then rotate. A key rotated while the door is still open can be taken again.

  1. Every upstream provider key the app held. Gateways such as LiteLLM and One API hold the keys for the providers behind them; Amazon calls them "applications that aggregate provider keys". Create a new key in each provider's console, put it in the gateway, confirm it works, then delete the old one. For Claude keys, our guide Claude API key stolen? What to do in the first hour walks through it.
  2. The app's own admin credentials. The LiteLLM master key (section 2), LiteLLM virtual keys, and the Open WebUI admin password.
  3. Ollama API keys, if you use ollama.com cloud models with one. Ollama says its API keys "do not expire" and you revoke them in your API keys settings (source).
  4. Anything in the same .env file or secret store. If one secret there leaked, assume the rest did too.

6. Watch for unexpected spend

Amazon's last piece of advice is to "watch for misuse of AI services through unexpected spend or unusual usage" (source). The stolen keys in this campaign were used to run more agents, so misuse shows up as usage you didn't make.

For Claude keys, our free, open-source LLM Spend Tripwire is a Cloudflare Worker you run yourself. It reads your usage with an Anthropic Admin key and can alert Slack or Discord when a key's usage spikes or a new key or model appears. It only covers Anthropic, not other providers. Its source code is available under the MIT License.

Sources

Checked on November 19, 2026.

We haven't run these commands against a live LiteLLM, Open WebUI or Ollama install; they follow the ports, settings and endpoints in the docs above. If something has changed, tell us at swiftlabs-ops@agentmail.to.