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
- 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. - LiteLLM: make sure a master key is set and it isn't
sk-1234. - Open WebUI: make sure the first account, which becomes the admin, is yours.
- Patch anything named in Amazon's playbook, and look for keys in front-end files and
.envfiles you serve. - 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:
- "uninitialized installs that could be claimed",
- "anonymous management and provider-configuration endpoints",
- "default administrator credentials, such as the LiteLLM default master key",
- CVE-2025-3248 (Langflow) and CVE-2026-28797 (RAGFlow),
- "an authentication bypass via the isCliRequest header in One API family systems",
- "SSRF through URL-fetch features to cloud metadata services",
- "secrets left in client-side JavaScript, source maps, debug routes, and environment files".
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):
- No master key. "With no master key the proxy runs without authentication and accepts every request."
- The publicly known key. LiteLLM says this value "was widely advertised in LiteLLM's own docs and tutorials, so anyone who can reach the proxy can guess it." In LiteLLM's code, that value is
sk-1234(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:
- The Admin UI login. By default it accepts
UI_USERNAME(defaultadmin) withUI_PASSWORD, "and when UI_PASSWORD is unset, the master key itself." LiteLLM suggests creating a personal admin account (or SSO) and then settingdisable_env_credential_login: true(source). - The API docs pages. "By default the proxy serves Swagger UI at /, ReDoc at /redoc, and the raw OpenAPI schema at /openapi.json without authentication." Set
NO_DOCS,NO_REDOCandNO_OPENAPIto"True"in production (source). - Apps should use virtual keys, not the master key (source). With a LiteLLM Enterprise license, a virtual key can be rotated with
POST /key/{key}/regenerate(source). Without one, create a new key with/key/generate, move your apps to it, then delete the old key.
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.
- Open your instance. If it still shows Create Admin Account, it's unclaimed. Create the account now, or take it off the network first.
- If you're the admin, open the Admin Panel and look for user accounts you don't recognize.
- Check how the container was started.
WEBUI_AUTH=Falseis single-user mode with no login (source). Don't expose that to the internet.
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
- Langflow: CVE-2025-3248 affects versions before 1.3.0. NVD: "A remote and unauthenticated attacker can send crafted HTTP requests to execute arbitrary code" (source). Upgrade.
- RAGFlow: CVE-2026-28797 affects 0.24.0 and earlier and lets "any authenticated user" run operating system commands on the server. When NVD published it in April 2026, it said no public patch was available (source). Check the RAGFlow project for a fixed release, and don't let strangers sign up.
- One API family (One API, New API and others): Amazon names an authentication bypass via the
isCliRequestheader (source). Check your project's releases and security advisories. - Keys in files you serve. Amazon lists client-side JavaScript, source maps, debug routes and environment files. Open your public site the way a visitor would, search the JavaScript and any
.mapfiles for key prefixes such assk-, and make sure/.envdoesn't load.
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.
- 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.
- The app's own admin credentials. The LiteLLM master key (section 2), LiteLLM virtual keys, and the Open WebUI admin password.
- 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).
- Anything in the same
.envfile 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.
- Set spend limits at each provider, so a stolen key can only spend so much.
- LiteLLM alerting. LiteLLM can post budget crossings and weekly spend reports to Slack (Settings, then Logging & Alerts in the Admin UI) (source). It only sees traffic that goes through the gateway, not a key someone copied out of it.
- Watch at the provider. A key taken from your gateway gets used directly against the provider, so the provider's usage data is where it shows up.
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.
- Amazon (AWS Security Blog): Amazon Threat Intelligence observes threat actors running cybercrime campaigns with ARTEX AI agents, November 13, 2026 (dates, targets, playbook, 30-day rule, advice, IP indicators)
- LiteLLM: Rotating the Master Key (no key means no authentication, the publicly known key, safe rotation), Security Best Practices (Admin UI login, API docs pages, network access, virtual keys), Production Best Practices (what the master key is, alerting), Docker quick start (port 4000), Virtual Keys (key regeneration)
- LiteLLM source: master_key_boot_check.py (
sk-1234and the override setting) - Open WebUI: Quick start (ports, first account is admin, single-user mode), Hardening (signup, pending role, admin from environment variables, network placement), Connection errors (the OLLAMA_HOST=0.0.0.0 advice), open_webui/__init__.py (serve defaults to 0.0.0.0:8080)
- Ollama: FAQ (default bind address,
OLLAMA_HOST, proxies), Docker, Authentication (no auth on the local API, cloud models, API keys) - Docker: Port publishing and mapping, Packet filtering and firewalls (Docker and ufw)
- NVD: CVE-2025-3248, CVE-2026-28797
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.