On 24 March 2026 two malicious versions of LiteLLM, the Python library and gateway for calling many LLM providers through one API, were published to PyPI: 1.82.7 and 1.82.8. Both carried a credential stealer that collected environment variables, SSH keys, cloud credentials, Kubernetes tokens and database passwords and sent them to models.litellm.cloud, a domain LiteLLM doesn't own. The malicious code never reached LiteLLM's GitHub repository; it was uploaded straight to PyPI. If any build, image or machine installed one of the two versions, treat it as compromised and rotate every secret it could read.
The way in was a security scanner. LiteLLM says it believes the compromise "originated from the Trivy dependency used in our CI/CD security scanning workflow", five days after the Trivy supply chain attack poisoned Trivy's releases and GitHub Actions. PyPI's incident report puts it the same way: the malicious releases came "after an API token exposure from an exploited Trivy dependency." A tool added to make the pipeline safer handed over the credentials that published the package.
What happened
| When (UTC) | What happened |
|---|---|
| 19 to 23 March | Trivy v0.69.4, the trivy-action and setup-trivy tags and two Docker Hub images were compromised with a credential stealer that ran inside CI jobs (CVE-2026-33634). |
| 24 March, 10:39 | According to LiteLLM, the malicious versions went live on PyPI. 1.82.7 carried the payload in litellm/proxy/proxy_server.py; 1.82.8 also added a litellm_init.pth file that runs at every Python start. |
| 24 March | FutureSearch found it when LiteLLM arrived as a transitive dependency of an MCP plugin running in Cursor and the .pth file spawned processes until the machine crashed, a bug in the malware. Users reported it on GitHub and to PyPI. |
| 24 March | PyPI quarantined the project. Its report counts 1 hour 19 minutes from upload to the first malware report and 2 hours 32 minutes from upload to quarantine, and more than 119,000 downloads of the malicious versions. The Python Packaging Authority published PYSEC-2026-2 the same day. |
| 24 to 30 March | LiteLLM removed the packages, rotated maintainer credentials, engaged Google's Mandiant for forensics of the build and publishing chain, paused releases, and audited every release from 1.78.0 to 1.82.6 as clean. |
| 26 March | CISA added CVE-2026-33634, whose CVE record lists LiteLLM 1.82.7 and 1.82.8 alongside Trivy, to its KEV catalog. |
| 30 March | LiteLLM announced 1.83.0, built through a new release pipeline with isolated environments, and began signing its GHCR images with cosign. |
The same CVE record also lists telnyx 4.87.1 and 4.87.2, a second PyPI package backdoored in the same campaign, which PyPI's report covers alongside LiteLLM. LiteLLM's own post leaves open how the upload happened: its early evidence is that the attacker bypassed the official CI/CD workflows and uploaded directly to PyPI, possibly through a maintainer's compromised PyPI account. Both LiteLLM and telnyx have since moved to PyPI's Trusted Publishing, according to PyPI.
Who is affected
According to LiteLLM's advisory, you may be affected if, between 10:39 and 16:00 UTC on 24 March 2026:
- you installed or upgraded LiteLLM with
pip, - you ran an unpinned
pip install litellmand got 1.82.7 or 1.82.8, - you built a Docker image with an unpinned LiteLLM install, or
- something you installed depends on LiteLLM without pinning it, such as an agent framework or an MCP server.
You are not affected if you used LiteLLM Cloud, the official ghcr.io/berriai/litellm Docker image (which pins its dependencies), version 1.82.6 or earlier without upgrading in the window, or LiteLLM installed from the GitHub source.
The window LiteLLM gives (more than five hours) is wider than the 2 hours 32 minutes PyPI reports from upload to quarantine. Use the wider one. Also count copies installed later from a cache or a mirror: a pip cache, a uv cache, a wheel in an internal package proxy or a Docker layer built that day can still hold a malicious version.
How it works
The PyPA advisory and LiteLLM's post describe the payload:
- It runs without being called. 1.82.7 put the stealer in
litellm/proxy/proxy_server.py; the PyPA advisory says it runs when any module from the package is imported. 1.82.8 also shippedlitellm_init.pthinsite-packages. Python'ssitemodule reads every.pthfile at interpreter start and executes lines that begin withimport, so any Python process in that environment ran the payload, whether or not it used LiteLLM: a test run, a linter,pipitself. - It collects everything in reach. Environment variables, SSH keys, Git and Docker credentials,
.envfiles, Kubernetes service account tokens, database and LDAP configuration, shell histories and cryptocurrency wallets. It queries cloud metadata servers for access tokens and reads secrets from AWS Secrets Manager. - It sends them out. The data goes to
models.litellm.cloud, which looks like LiteLLM's own domain but isn't. - It stays. It installs a systemd service disguised as "System Telemetry Service", creates a new pod in a Kubernetes environment, and the persistence script contacts
checkmarx.zonefor further instructions.
The advisory classifies it as embedded malicious code (CWE-506). Nothing in LiteLLM's source was wrong; the package on PyPI didn't match the source.
In a CI job, the first and second points meet. A build that installs dependencies and then runs tests starts a Python interpreter almost immediately, and the job's environment holds the secrets it needs to publish and deploy.
How to check whether you are affected
- Search every lockfile and requirements file on every branch for
litellm1.82.7 or 1.82.8:requirements*.txt,poetry.lock,uv.lock,Pipfile.lockandpdm.lock. - Find unpinned installs. A
pip install litellmin a workflow, Dockerfile or script with no version, and a dependency that pulls LiteLLM in without a pin, resolved to the malicious version during the window. Usepip show litellmorpipdeptree -r -p litellmin a built environment to see why LiteLLM is there. - Check what builds installed on 24 March. In CI, pip prints
Successfully installed ... litellm-1.82.7. If the logs still exist, search them; GitHub deletes Actions logs after 90 days by default, so for March 2026 they are usually gone. - Check images and environments. Run the commands below in every image built that week and on developer machines and servers that installed Python packages that day.
- Check caches and mirrors for
litellm-1.82.7andlitellm-1.82.8files.
Commands you can adapt. To search the lockfiles of every remote branch:
git fetch --all --quiet
for ref in $(git for-each-ref --format='%(refname:short)' refs/remotes); do
git grep -n -A1 -E 'litellm' "$ref" -- '*requirements*.txt' '*poetry.lock' '*uv.lock' '*Pipfile.lock' '*pdm.lock' \
| grep -E '1\.82\.[78]' | sed "s|^|$ref |"
done
To check a machine, a runner or a container for the package, the .pth file, cached copies and the persistence service:
python -m pip show litellm 2>/dev/null | grep -i '^version'
find / -name 'litellm_init.pth' 2>/dev/null
find / \( -name 'litellm-1.82.7*' -o -name 'litellm-1.82.8*' \) 2>/dev/null
grep -rl 'System Telemetry Service' /etc/systemd /usr/lib/systemd ~/.config/systemd 2>/dev/null
To check an image you built (replace IMAGE):
docker run --rm --entrypoint sh IMAGE -c \
"pip show litellm 2>/dev/null | grep -i ^version; find / -name litellm_init.pth 2>/dev/null"
Why the lockfile doesn't settle it
- Unpinned installs leave no record.
pip install litellmin a workflow or Dockerfile resolves at build time. The repository never says which version that build got. - Transitive dependencies. FutureSearch found the attack because LiteLLM came in through an MCP plugin, not through anything in their own project. AI tooling often installs its own dependencies at run time.
- Caches outlive the window. A wheel cached on 24 March can be installed weeks later by a build that never touched PyPI.
- An image can carry it for months. An image built in the window carries the malicious version for as long as it is deployed, and every time it starts, the
.pthfile runs.
You need a record of which package versions each build actually installed, kept per build. See are we affected? how to assess a new CVE across your builds.
How to fix it, and what to do if you can't patch yet
- Treat every environment that installed 1.82.7 or 1.82.8 as compromised. PyPA's advice is to "assume any credentials available to litellm environment may have been exposed, and revoke/rotate them accordingly." Rotate API keys for every LLM provider, cloud keys, database passwords, SSH keys, Kubernetes tokens, and anything in environment variables or configuration files.
- Isolate and inspect the host. Remove
litellm_init.pth, disable and delete the "System Telemetry Service" unit, delete pods you didn't create, and review the host "against any unexpected modifications and network traffic", as the advisory asks. If you can rebuild a host or runner from a clean image instead, do that. - Install a clean version. Pin to 1.82.6 or earlier, or to 1.83.0 or later, and rebuild every image built in the window.
- Purge caches and mirrors. Delete the two versions from pip and uv caches, internal package proxies, and CI caches:
pip cache remove 'litellm*'
uv cache clean litellm
gh cache delete --all --repo ORG/REPO # GitHub Actions caches, per repository
Verify the fix
- Every lockfile pins a clean version, and no workflow, Dockerfile or script installs LiteLLM without a version.
- No environment has the payload. The commands above find no
litellm_init.pthand no "System Telemetry Service". - The old credentials no longer work. Revoked provider keys and cloud credentials are deactivated, not just replaced.
- No traffic to the attacker's hosts. DNS and proxy logs show no lookups of
models.litellm.cloudorcheckmarx.zoneafter the cleanup. - The next build is clean. Check the version it actually installed, from its log or per-build SBOM, not only the lockfile.
How to reduce the damage next time
- Pin and hash.
pip install --require-hasheswith a lockfile installs only the files you locked, so a new upload, malicious or not, can't slip into a build. - Wait before adopting new versions. The malicious versions were on PyPI for hours. A cooldown on dependency updates keeps brand-new releases out of builds until others have looked at them.
- Publish with Trusted Publishing. PyPI's report recommends Trusted Publishers over long-lived API tokens, a separate deployment environment for releases, pinned dependencies in workflows and no risky triggers such as
pull_request_target. - Give your scanners no publish secrets. A scan job doesn't need the token that publishes your package. Run publishing in its own job with its own secrets. See GitHub Actions secrets: how they leak and how to lock them down and GitHub Actions security.
- Limit where builds can connect. A build that installs from PyPI and runs tests doesn't need to reach
models.litellm.cloud. With an egress policy, the upload of stolen secrets from the build fails. This protects the build, not the servers and laptops where the same package ran.
Check for compromise
From LiteLLM's post and PYSEC-2026-2:
| Type | Indicator |
|---|---|
| Files | litellm_init.pth in site-packages (1.82.8); the payload in litellm/proxy/proxy_server.py (1.82.7 and 1.82.8) |
| Network | models.litellm.cloud (exfiltration); checkmarx.zone, including https://checkmarx.zone/raw (persistence) |
| Persistence | A systemd service unit named "System Telemetry Service"; in Kubernetes, a new pod you didn't create |
When to assume compromise. Every environment that installed 1.82.7 or 1.82.8, from the first upload, even if the .pth file is gone and no connection shows up in your logs. On a CI runner the payload had the job's secrets; on a server it had whatever the server could reach, including cloud metadata.
Review what the credentials touched. Check cloud, Kubernetes and LLM provider audit logs from 24 March onwards for activity you can't explain. LLM provider keys are easy to miss, and LiteLLM exists to hold many of them.
What to tell your customers
If your product uses LiteLLM, or your builds may have installed it, customers will ask whether your product or their data was exposed. Answer with what you checked and what you did:
We checked every build and deployment of [product] against the malicious LiteLLM versions 1.82.7 and 1.82.8 published on PyPI on 24 March 2026. [No build or environment installed an affected version.] / [Builds of [component] on [date] installed [version]. We rotated every credential those environments could access, rebuilt [product] from clean dependencies and released [version]. We found [no evidence of misuse / the following: ...].] Releases [x to y] are affected; please upgrade to [version].
If you're still checking, say so and say when you'll answer. For templates for each outcome, see how to answer customers after a supply chain attack.
How CRACI helps
CRACI runs your GitHub Actions jobs on its own runners (runs-on: craci) and records every package each job actually fetches from PyPI and other registries, including packages restored from caches. An unpinned pip install litellm in a workflow step, a dependency pulled in by a tool, or an install inside a build script all show up, because the record comes from what the job downloaded, not from what a lockfile declared. Build history keeps every past build with its SBOM, so when the next incident like this is announced, you see which builds installed the affected versions and when, within your retention period (180 days by default), and each job's network trace shows what it connected to.
CRACI's egress policy limits where a job can connect, is validated before the job starts and fails closed, so a payload sending secrets to a host the build doesn't need, such as models.litellm.cloud, is blocked, even for an attack nobody has seen before. Known malicious releases with a published CVE are flagged like any other vulnerability, and policy gates can block builds that contain them. CRACI doesn't detect malicious packages by behavior or reputation, so a new one isn't flagged before an advisory exists. CRACI covers your builds; servers and developer machines that installed the package need the checks above. For the wider picture, see CI/CD security.
See the package record of one of your own builds
Other incidents: all vulnerabilities, including the Trivy compromise that led to this one and the Shai-Hulud npm worm.
Sources and updates
Primary sources:
- LiteLLM: security update, March 2026, GitHub issue #24518
- Python Packaging Authority: PYSEC-2026-2 (MAL-2026-2144); PyPI: incident report on LiteLLM and Telnyx
- FutureSearch, who reported it
- CVE-2026-33634 (CNA: GitHub), Aqua Security's GHSA-69fq-xp46-6x23, CISA's KEV catalog
- FIRST: EPSS score for CVE-2026-33634
Updates:
- 2026-11-16: First published.