The Python Dependency Security Problem

Le problème de sécurité des dépendances Python

The Python Package Index (PyPI) hosts over 500,000 packages and serves billions of downloads every month. Python powers everything from web applications with Django and Flask to data science pipelines, machine learning infrastructure, and DevOps automation. This ubiquity makes the Python ecosystem an increasingly attractive target for supply chain attacks.

Le Python Package Index (PyPI) héberge plus de 500 000 packages et sert des milliards de téléchargements chaque mois. Python alimente tout, des applications web avec Django et Flask aux pipelines de data science, l'infrastructure de machine learning et l'automatisation DevOps. Cette ubiquité fait de l'écosystème Python une cible de plus en plus attrayante pour les attaques de supply chain.

Unlike npm, Python's packaging landscape is fragmented across multiple tools: pip, poetry, pipenv, conda, and uv each have their own lockfile formats and dependency resolution strategies. This fragmentation makes it harder to maintain a consistent security posture across projects. A team might use requirements.txt for one project, poetry.lock for another, and Pipfile.lock for a third—each requiring different audit tools and workflows.

Contrairement à npm, le paysage de packaging Python est fragmenté entre plusieurs outils : pip, poetry, pipenv, conda et uv ont chacun leurs propres formats de lockfile et stratégies de résolution de dépendances. Cette fragmentation rend plus difficile le maintien d'une posture de sécurité cohérente entre les projets. Une équipe peut utiliser requirements.txt pour un projet, poetry.lock pour un autre, et Pipfile.lock pour un troisième—chacun nécessitant des outils d'audit et des workflows différents.

Recent high-profile incidents have underscored these risks. In 2022, researchers discovered thousands of typosquatting packages on PyPI designed to steal credentials and inject backdoors. The ctx package hijack exposed AWS keys of developers who installed what they thought was a trusted library. In 2023, malicious packages disguised as popular AI libraries targeted the growing machine learning community. These attacks demonstrate that any Python project with third-party dependencies is a potential target.

Des incidents récents de grande envergure ont souligné ces risques. En 2022, des chercheurs ont découvert des milliers de packages de typosquatting sur PyPI conçus pour voler des identifiants et injecter des backdoors. Le détournement du package ctx a exposé les clés AWS de développeurs qui avaient installé ce qu'ils pensaient être une bibliothèque de confiance. En 2023, des packages malveillants déguisés en bibliothèques IA populaires ciblaient la communauté grandissante du machine learning. Ces attaques démontrent que tout projet Python avec des dépendances tierces est une cible potentielle.

The challenge is compounded by Python's execution model: setup.py and pyproject.toml build scripts can execute arbitrary code during installation. A single pip install command can run untrusted code on your machine before you've even imported the package. This makes proactive vulnerability monitoring not just useful, but essential.

Le défi est amplifié par le modèle d'exécution de Python : les scripts de build setup.py et pyproject.toml peuvent exécuter du code arbitraire pendant l'installation. Une seule commande pip install peut exécuter du code non fiable sur votre machine avant même que vous ayez importé le package. Cela rend le monitoring proactif des vulnérabilités non seulement utile, mais essentiel.

How to Check Python Vulnerabilities

Comment vérifier les vulnérabilités Python

Using pip audit

Utiliser pip audit

The pip-audit tool (maintained by the Python Packaging Authority) scans your installed packages or a requirements file against the OSV.dev vulnerability database. It's the closest Python equivalent to npm audit.

L'outil pip-audit (maintenu par la Python Packaging Authority) scanne vos packages installés ou un fichier requirements contre la base de vulnérabilités OSV.dev. C'est l'équivalent Python le plus proche de npm audit.

Install and run a basic audit:

Installer et lancer un audit basique :

$ pip install pip-audit
$ pip-audit

Found 4 known vulnerabilities in 3 packages
Name        Version  ID                  Fix Versions
----------  -------  ------------------  ------------
django      3.2.15   GHSA-jrh2-hc4r-7jwx 3.2.16
requests    2.28.0   PYSEC-2023-74       2.31.0
cryptography 38.0.4  GHSA-w7pp-m8wf-vj6r 39.0.1
urllib3     1.26.12  GHSA-v845-jxx5-vc9f  1.26.18

For CI/CD pipelines, JSON output is more useful:

Pour les pipelines CI/CD, la sortie JSON est plus utile :

$ pip-audit --format json --output audit-report.json
$ pip-audit -r requirements.txt --format json

Using safety check

Utiliser safety check

The safety CLI (by SafetyCLI) is another popular option. It checks your dependencies against a curated vulnerability database:

Le CLI safety (par SafetyCLI) est une autre option populaire. Il vérifie vos dépendances contre une base de vulnérabilités curée :

$ pip install safety
$ safety check -r requirements.txt

+==============================================================================+
|                                                                              |
|                               /$$$$$$            /$$                         |
|                              /$$__  $$          | $$                         |
|                             | $$  \__/  /$$$$$$ | $$$$$$$   /$$$$$$          |
|                              \$$$$$$   |____  $$| $$_  $$  /$$__  $$         |
|                               \____  $$ /$$$$$$$| $$ \ $$ | $$$$$$$$         |
|                               /$$  \ $$/$$__  $$| $$ | $$ | $$_____/         |
|                              |  $$$$$$/  $$$$$$$| $$ | $$ |  $$$$$$$         |
|                               \______/ \_______/|__/ |__/  \_______/         |
|                                                                              |
+==============================================================================+

3 vulnerabilities found

Using poetry check and poetry audit

Utiliser poetry check et poetry audit

If you use Poetry, the poetry audit command (available since Poetry 1.6) checks your locked dependencies for vulnerabilities:

Si vous utilisez Poetry, la commande poetry audit (disponible depuis Poetry 1.6) vérifie les vulnérabilités de vos dépendances verrouillées :

$ poetry audit

Checking dependencies for known security vulnerabilities...

Package    Installed  Affected   CVE
---------  ---------  ---------  ---------------
django     3.2.15     <3.2.16   CVE-2022-41323
pillow     9.2.0      <9.3.0    CVE-2022-45198

The limitations of manual scanning

Les limites du scan manuel

All these tools share the same fundamental limitations: they're point-in-time, single-project commands that you must remember to run. Each tool only works with its own package manager—pip-audit for pip, poetry audit for Poetry, pipenv check for Pipenv. If your team uses multiple Python package managers across different projects, you need multiple tools and workflows.

Tous ces outils partagent les mêmes limitations fondamentales : ce sont des commandes ponctuelles, mono-projet que vous devez penser à exécuter. Chaque outil ne fonctionne qu'avec son propre gestionnaire de packages—pip-audit pour pip, poetry audit pour Poetry, pipenv check pour Pipenv. Si votre équipe utilise plusieurs gestionnaires de packages Python sur différents projets, vous avez besoin de multiples outils et workflows.

Why Manual Scanning Fails

Pourquoi le scan manuel échoue

Running pip-audit or safety check once is easy. Doing it consistently across every project, every day, is where teams fail. Here's why manual Python vulnerability scanning doesn't scale:

Exécuter pip-audit ou safety check une fois est facile. Le faire de manière cohérente sur chaque projet, chaque jour, c'est là que les équipes échouent. Voici pourquoi le scan manuel des vulnérabilités Python ne passe pas à l'échelle :

• You forget to scan. New CVEs are published daily. The critical Django vulnerability disclosed today won't be caught until someone remembers to run the audit tool—which could be days or weeks later.
• One project at a time. Each command audits a single project. If you manage 10 Django applications, 5 Flask APIs, and 3 data pipelines, that's 18 separate audit commands you need to run and review.
• No alerts when it matters. A critical vulnerability in requests, cryptography, or django can be published at any time. Manual tools don't notify you—you only discover the issue the next time you remember to check.
• No historical tracking. Was this vulnerability present in last month's scan? When was it introduced? Is your security posture improving or degrading? Manual scanning gives you snapshots, not trends.
• Fragmented tooling. pip-audit, safety, poetry audit, pipenv check—each works only with its respective package manager. A team using multiple Python tools needs to maintain multiple audit workflows, multiplying the chance that something slips through.
• No stakeholder reporting. Agencies and consultancies need to demonstrate security diligence to clients. Terminal output doesn't translate into professional reports that clients and compliance teams expect.

• Vous oubliez de scanner. De nouveaux CVE sont publiés quotidiennement. La vulnérabilité critique Django divulguée aujourd'hui ne sera pas détectée tant que quelqu'un ne pensera pas à lancer l'outil d'audit—ce qui peut prendre des jours ou des semaines.
• Un projet à la fois. Chaque commande audite un seul projet. Si vous gérez 10 applications Django, 5 APIs Flask et 3 pipelines de données, ce sont 18 commandes d'audit distinctes à exécuter et vérifier.
• Aucune alerte quand ça compte. Une vulnérabilité critique dans requests, cryptography ou django peut être publiée à tout moment. Les outils manuels ne vous préviennent pas—vous ne découvrez le problème que la prochaine fois que vous pensez à vérifier.
• Aucun suivi historique. Cette vulnérabilité était-elle présente dans le scan du mois dernier ? Quand a-t-elle été introduite ? Votre posture de sécurité s'améliore-t-elle ou se dégrade-t-elle ? Le scan manuel vous donne des instantanés, pas des tendances.
• Outillage fragmenté. pip-audit, safety, poetry audit, pipenv check—chacun ne fonctionne qu'avec son gestionnaire de packages respectif. Une équipe utilisant plusieurs outils Python doit maintenir plusieurs workflows d'audit, multipliant les risques que quelque chose passe entre les mailles du filet.
• Pas de reporting pour les parties prenantes. Les agences et les consultants doivent démontrer leur diligence sécuritaire à leurs clients. La sortie terminal ne se traduit pas en rapports professionnels attendus par les clients et les équipes de conformité.

OptiBot: Continuous Python Vulnerability Monitoring

OptiBot : Monitoring continu des vulnérabilités Python

OptiBot is a Python vulnerability scanner built for teams who manage multiple projects and need more than a one-time audit. It works with all major Python package managers—pip, Poetry, and Pipenv—from a single dashboard. No Python environment required, no code access needed.

OptiBot est un scanner de vulnérabilités Python conçu pour les équipes qui gèrent plusieurs projets et ont besoin de plus qu'un audit ponctuel. Il fonctionne avec tous les principaux gestionnaires de packages Python—pip, Poetry et Pipenv—depuis un tableau de bord unique. Pas d'environnement Python requis, pas d'accès au code nécessaire.

How it works

Comment ça fonctionne

Works with ALL Python package managers

Fonctionne avec TOUS les gestionnaires de packages Python

Unlike standalone tools that only support one format, OptiBot accepts:

Contrairement aux outils autonomes qui ne supportent qu'un seul format, OptiBot accepte :

• requirements.txt — Standard pip format, the most common dependency file in the Python ecosystem
• poetry.lock — Poetry's lockfile with exact resolved versions and dependency hashes
• Pipfile.lock — Pipenv's lockfile with pinned versions and integrity checksums

• requirements.txt — Format pip standard, le fichier de dépendances le plus courant de l'écosystème Python
• poetry.lock — Le lockfile de Poetry avec les versions résolues exactes et les hashes de dépendances
• Pipfile.lock — Le lockfile de Pipenv avec les versions fixées et les checksums d'intégrité

No code access required

Aucun accès au code nécessaire

OptiBot only reads package names and versions from your lockfile. It never sees your source code, never requires a GitHub integration or SSH key. This makes it ideal for agencies auditing client projects—just ask the client for their dependency file and start monitoring. No trust boundary issues, no security review required.

OptiBot ne lit que les noms de packages et les versions de votre lockfile. Il ne voit jamais votre code source, ne nécessite jamais d'intégration GitHub ni de clé SSH. C'est idéal pour les agences auditant des projets clients—demandez simplement au client son fichier de dépendances et commencez le monitoring. Pas de problème de limite de confiance, pas d'examen de sécurité requis.

Multi-stack monitoring

Monitoring multi-stack

Most Python projects don't exist in isolation. Your Django app likely has a JavaScript frontend, and your deployment might include PHP services. OptiBot also supports package-lock.json (Node.js) and composer.lock (PHP), so you can monitor your entire stack from a single dashboard.

La plupart des projets Python n'existent pas de manière isolée. Votre application Django a probablement un frontend JavaScript, et votre déploiement peut inclure des services PHP. OptiBot supporte aussi package-lock.json (Node.js) et composer.lock (PHP), vous permettant de surveiller toute votre stack depuis un seul tableau de bord.

Common Python Vulnerabilities

Vulnérabilités Python courantes

Understanding the types of vulnerabilities found in Python packages helps you assess risk and prioritize fixes. Here are the most common categories affecting the PyPI ecosystem:

Comprendre les types de vulnérabilités trouvées dans les packages Python vous aide à évaluer les risques et prioriser les corrections. Voici les catégories les plus courantes affectant l'écosystème PyPI :

Python Dependency Security Best Practices

Bonnes pratiques de sécurité des dépendances Python

Securing your Python supply chain requires discipline and the right tools. Follow these practices to minimize your attack surface:

Sécuriser votre supply chain Python demande de la discipline et les bons outils. Suivez ces pratiques pour minimiser votre surface d'attaque :

• Pin your dependency versions. Always use pinned versions in your requirements file (django==4.2.11, not django>=4.0). Unpinned dependencies mean different environments can install different—potentially vulnerable—versions. Use a lockfile (poetry.lock or Pipfile.lock) for deterministic builds.
• Use lockfiles for every project. A requirements.txt with version ranges is not a lockfile. Use pip freeze > requirements.txt, Poetry, or Pipenv to generate files with exact versions. This ensures reproducible builds and accurate vulnerability scanning.
• Audit on every CI run. Add pip-audit -r requirements.txt --fail-on-vuln to your CI pipeline. Block deployments when known vulnerabilities are present. This is your last line of defense before code reaches production.
• Separate production and development dependencies. Use [tool.poetry.group.dev.dependencies] or separate requirements-dev.txt files. Development-only packages like ipython or pytest don't need to be deployed to production, reducing your attack surface.
• Monitor continuously, not manually. New CVEs are published daily. A project that was clean yesterday may have critical vulnerabilities today. Use a continuous monitoring tool like OptiBot to get alerted the moment a new CVE affects your dependencies—across all your projects simultaneously.
• Review new dependencies before installing. Check maintenance status, contributor count, and known vulnerabilities before adding a package. Prefer well-maintained packages from trusted authors. Consider the pip-audit check as part of your code review process for any PR that adds new dependencies.

• Fixez vos versions de dépendances. Utilisez toujours des versions fixées dans votre fichier de requirements (django==4.2.11, pas django>=4.0). Des dépendances non fixées signifient que différents environnements peuvent installer des versions différentes—potentiellement vulnérables. Utilisez un lockfile (poetry.lock ou Pipfile.lock) pour des builds déterministes.
• Utilisez des lockfiles pour chaque projet. Un requirements.txt avec des plages de versions n'est pas un lockfile. Utilisez pip freeze > requirements.txt, Poetry ou Pipenv pour générer des fichiers avec des versions exactes. Cela garantit des builds reproductibles et un scan de vulnérabilités précis.
• Auditez à chaque exécution CI. Ajoutez pip-audit -r requirements.txt --fail-on-vuln à votre pipeline CI. Bloquez les déploiements quand des vulnérabilités connues sont présentes. C'est votre dernière ligne de défense avant que le code n'atteigne la production.
• Séparez les dépendances de production et de développement. Utilisez [tool.poetry.group.dev.dependencies] ou des fichiers requirements-dev.txt séparés. Les packages uniquement pour le développement comme ipython ou pytest n'ont pas besoin d'être déployés en production, réduisant votre surface d'attaque.
• Surveillez en continu, pas manuellement. De nouveaux CVE sont publiés quotidiennement. Un projet propre hier peut avoir des vulnérabilités critiques aujourd'hui. Utilisez un outil de monitoring continu comme OptiBot pour être alerté dès qu'un nouveau CVE affecte vos dépendances—sur tous vos projets simultanément.
• Vérifiez les nouvelles dépendances avant installation. Vérifiez l'état de maintenance, le nombre de contributeurs et les vulnérabilités connues avant d'ajouter un package. Préférez les packages bien maintenus d'auteurs de confiance. Intégrez la vérification pip-audit dans votre processus de revue de code pour toute PR ajoutant de nouvelles dépendances.

Frequently Asked Questions

Questions fréquentes

Related pages

Pages associées