pip-audit & Poetry Security in 2026: CVE-2026-34591, pylock.toml & PyPI Trusted PublishersSécurité pip-audit & Poetry en 2026 : CVE-2026-34591, pylock.toml & PyPI Trusted Publishers

Python's dependency ecosystem is under pressure. According to the OpenSSF's 2025 report, 72% of Python application dependencies contain at least one critical CVE — yet only 21% of organizations have complete visibility into their dependency tree (Anchore, 2024). The good news: 2026 has brought meaningful improvements to the toolchain. pip-audit 2.9.0 now audits PEP 751 pylock.toml files. PyPI Trusted Publishers have pushed provenance attestations to over 132,000 packages. And Poetry 2.3.3 quietly patched a path traversal flaw — CVE-2026-34591 — that could have let a malicious wheel overwrite arbitrary files on your system.

L'écosystème de dépendances Python est sous pression. Selon le rapport OpenSSF 2025, 72 % des dépendances d'applications Python contiennent au moins un CVE critique — mais seulement 21 % des organisations ont une visibilité complète sur leur arbre de dépendances (Anchore, 2024). La bonne nouvelle : 2026 a apporté des améliorations concrètes. pip-audit 2.9.0 audite désormais les fichiers PEP 751 pylock.toml. Les PyPI Trusted Publishers ont étendu les attestations de provenance à plus de 132 000 packages. Et Poetry 2.3.3 a silencieusement corrigé une faille de traversal — CVE-2026-34591 — qui permettait à une wheel malveillante d'écraser des fichiers arbitraires sur votre système.

This guide covers everything you need: the CVE-2026-34591 technical breakdown, how to integrate pip-audit into your CI/CD pipeline, how poetry.lock hash verification works and where it falls short, and how PyPI attestations close the gap that traditional scanning misses.

Ce guide couvre tout ce qu'il faut savoir : l'analyse technique de CVE-2026-34591, l'intégration de pip-audit dans votre pipeline CI/CD, le fonctionnement de la vérification des hashes de poetry.lock et ses limites, ainsi que la façon dont les attestations PyPI comblent les failles que le scan traditionnel ne détecte pas.

CVE-2026-34591: Poetry Wheel Path Traversal — What Happened

CVE-2026-34591 : Traversal via Wheel Poetry — Ce qui s'est Passé

On April 7, 2026, the Python Poetry team published a security advisory for CVE-2026-34591: a path traversal vulnerability in Poetry's wheel installer component. Any version of Poetry from 1.4.0 through 2.3.2 is affected. The fix is available in Poetry 2.3.3.

Le 7 avril 2026, l'équipe Poetry a publié un avis de sécurité pour CVE-2026-34591 : une vulnérabilité de traversal de chemin dans le composant d'installation des wheels. Toutes les versions de Poetry de 1.4.0 à 2.3.2 sont affectées. Le correctif est disponible dans Poetry 2.3.3.

The Technical Root Cause

La Cause Technique Racine

The vulnerability lives in how wheel_installer.py constructs target paths during package installation. The code concatenates the scheme directory with the path from inside the wheel archive without sanitizing traversal sequences first:

La vulnérabilité réside dans la façon dont wheel_installer.py construit les chemins cibles lors de l'installation. Le code concatène le répertoire scheme avec le chemin de la wheel sans assainir les séquences de traversal :

# Simplified vulnerable pattern (before Poetry 2.3.3)
# destination = scheme_dir + archive_path
# e.g. /home/user/.venv/lib/python3.12/site-packages + /../../../.bashrc
# = /home/user/.bashrc  ← arbitrary file overwrite

# Safe pattern (Poetry 2.3.3+)
# Uses pathlib.Path.resolve() + strict containment check
import pathlib

def safe_install_path(scheme_dir: pathlib.Path, archive_path: str) -> pathlib.Path:
    resolved = (scheme_dir / archive_path).resolve()
    if not resolved.is_relative_to(scheme_dir.resolve()):
        raise ValueError(f"Path traversal attempt detected: {archive_path}")
    return resolved

An attacker needs to convince a developer to install a malicious package — either via a supply chain attack on PyPI, a dependency confusion attack, or a typosquatted package name. Once installed, the crafted wheel can overwrite shell configuration files, inject code into system Python packages, or write SSH authorized keys.

Un attaquant doit convaincre un développeur d'installer un package malveillant — via une attaque supply chain sur PyPI, une attaque de confusion de dépendances, ou un nom de package typosquatté. Une fois installé, la wheel craftée peut écraser des fichiers de configuration shell, injecter du code dans les packages Python système, ou écrire des clés SSH autorisées.

poetry --version
# Must be 2.3.3 or later
# Upgrade: pip install --upgrade poetry
# Or: pipx upgrade poetry

pip-audit in 2026: The Standard Python Dependency Scanner

pip-audit en 2026 : Le Scanner de Dépendances Python de Référence

Developed by Trail of Bits with Google support and maintained under the PyPA umbrella, pip-audit has become the de facto standard for Python dependency vulnerability scanning — reaching 11.2 million downloads per month in April 2026. It audits Python environments, requirements.txt, pyproject.toml, and (since version 2.9.0) PEP 751 pylock.toml files, cross-referencing against the Python Packaging Advisory Database (PyPI JSON API) and the OSV database.

Développé par Trail of Bits avec le support de Google et maintenu sous l'égide de la PyPA, pip-audit est devenu le standard de facto pour le scan de vulnérabilités des dépendances Python — atteignant 11,2 millions de téléchargements par mois en avril 2026. Il audite les environnements Python, les fichiers requirements.txt, pyproject.toml, et (depuis la version 2.9.0) les fichiers PEP 751 pylock.toml, en les croisant avec la Python Packaging Advisory Database et la base de données OSV.

Installation and Basic Usage

Installation et Utilisation de Base

# Install pip-audit (standalone, recommended)
pip install pip-audit
# or via pipx (isolated)
pipx install pip-audit

# Audit current environment
pip-audit

# Audit a requirements file
pip-audit -r requirements.txt

# Audit a Poetry project via pyproject.toml
pip-audit --requirement pyproject.toml

# Audit a pylock.toml file (pip-audit 2.9.0+, PEP 751)
pip-audit --locked  # scans pylock.*.toml in current directory

# JSON output for CI/CD integration
pip-audit --format json -o audit-report.json

# Auto-fix vulnerabilities (upgrades to minimum safe version)
pip-audit --fix

Scanning a Poetry Project: The Right Way

Scanner un Projet Poetry : La Bonne Méthode

pip-audit does not natively parse poetry.lock before version 2.9.0. The correct approach depends on your pip-audit version:

pip-audit ne parse pas nativement poetry.lock avant la version 2.9.0. L'approche correcte dépend de votre version de pip-audit :

# Option 1: pip-audit 2.9.0+ with PEP 751 (modern approach)
# Export poetry.lock to pylock.toml, then audit
poetry export --format pylock.toml -o pylock.toml
pip-audit --locked

# Option 2: pip-audit < 2.9.0 via requirements export
poetry export --format requirements.txt --without-hashes -o requirements-audit.txt
pip-audit -r requirements-audit.txt

# Option 3: poetry-audit-plugin (audits directly from poetry.lock)
poetry add --group dev poetry-audit-plugin
poetry audit

# Option 4: Install into Poetry venv, then audit the activated env
poetry run pip-audit

PEP 751 and pylock.toml: The New Python Lockfile Standard

PEP 751 et pylock.toml : Le Nouveau Standard de Lockfile Python

The Python ecosystem has long suffered from fragmented lockfile formats: poetry.lock, Pipfile.lock, pdm.lock, uv.lock — each incompatible with the others, each requiring a different tool to audit. PEP 751, now in the adoption phase, introduces pylock.toml as a standardized, tool-agnostic lockfile format with first-class security properties.

L'écosystème Python souffre depuis longtemps de formats de lockfiles fragmentés : poetry.lock, Pipfile.lock, pdm.lock, uv.lock — chacun incompatible avec les autres, chacun nécessitant un outil différent pour l'audit. PEP 751, en phase d'adoption, introduit pylock.toml comme format standardisé et agnostique aux outils.

Key security features of pylock.toml:

Fonctionnalités de sécurité clés de pylock.toml :

• File hashes (SHA-256/SHA-512) for every resolved package — tamper detection at install time
• Hashes de fichiers (SHA-256/SHA-512) pour chaque package résolu — détection de falsification à l'installation
• Explicit package sources with upload timestamps — auditability of the full dependency graph
• Sources de packages explicites avec horodatages d'upload — auditabilité du graphe complet
• Tool-agnostic: readable by pip-audit, pip, uv, PDM, and any PEP 751-compliant tool
• Agnostique aux outils : lisible par pip-audit, pip, uv, PDM et tout outil conforme PEP 751
• Machine-readable and human-readable TOML format with explicit SBOM-compatible metadata
• Format TOML lisible par les machines et par les humains avec des métadonnées compatibles SBOM

# pylock.toml (PEP 751) — simplified example
lock-version = "1.0"
created-by = "poetry 2.3.3"
requires-python = ">=3.11"

[[packages]]
name = "requests"
version = "2.32.3"
wheel = [
  { name = "requests-2.32.3-py3-none-any.whl",
    upload-time = "2024-05-29T16:57:43.742Z",
    url = "https://files.pythonhosted.org/packages/.../requests-2.32.3-py3-none-any.whl",
    hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6" }
]

pip-audit 2.9.0 introduced the --locked flag specifically for PEP 751 files. As the ecosystem migrates, committing your pylock.toml to version control and running pip-audit --locked in CI is now the most reliable way to catch vulnerabilities before deployment.

pip-audit 2.9.0 a introduit le flag --locked spécifiquement pour les fichiers PEP 751. À mesure que l'écosystème migre, committer votre pylock.toml dans le contrôle de version et exécuter pip-audit --locked en CI est désormais la méthode la plus fiable pour détecter les vulnérabilités avant le déploiement.

poetry.lock Security: What It Protects and What It Doesn’t

Sécurité de poetry.lock : Ce qu'il Protège et Ce qu'il ne Protège Pas

poetry.lock stores the exact resolved versions and SHA-256 hashes for every dependency in your project. When you run poetry install, Poetry verifies each downloaded package against these hashes before unpacking. This prevents tampering during transit — a package on PyPI cannot be swapped for a malicious version without the hash changing.

poetry.lock stocke les versions exactes résolues et les hashes SHA-256 de chaque dépendance de votre projet. Lors de poetry install, Poetry vérifie chaque package téléchargé contre ces hashes avant de le décompresser. Cela empêche la falsification en transit — un package sur PyPI ne peut pas être remplacé sans que le hash change.

However, poetry.lock has important limitations that teams often overlook:

Cependant, poetry.lock a des limites importantes que les équipes négligent souvent :

The key insight from CVE-2026-34591: a package can have a valid, expected hash and still be malicious. The hash only guarantees you got what was published — not that what was published is safe. This is why vulnerability scanning (pip-audit) and provenance verification (PyPI Trusted Publishers) are both necessary, on top of lockfile pinning.

L'enseignement clé de CVE-2026-34591 : un package peut avoir un hash valide et attendu et être quand même malveillant. Le hash garantit seulement que vous avez reçu ce qui a été publié — pas que ce qui a été publié est sûr. C'est pourquoi le scan de vulnérabilités (pip-audit) et la vérification de provenance (PyPI Trusted Publishers) sont tous deux nécessaires, en plus du pin de lockfile.

PyPI Trusted Publishers and Attestations: Provenance in 2026

PyPI Trusted Publishers et Attestations : La Provenance en 2026

The TeamPCP supply chain attack that compromised LiteLLM in March 2025 was possible because an API token stored as a GitHub Actions secret was exfiltrated. Trusted Publishing — PyPI's OIDC-based publishing mechanism — eliminates this attack vector by replacing long-lived tokens with short-lived identity tokens that expire automatically after each use.

L'attaque supply chain TeamPCP qui a compromis LiteLLM en mars 2025 a été possible parce qu'un token API stocké en secret GitHub Actions a été exfiltré. Les Trusted Publishers — le mécanisme de publication OIDC de PyPI — éliminent ce vecteur d'attaque en remplaçant les tokens de longue durée par des tokens d'identité à courte durée qui expirent automatiquement après chaque utilisation.

As of March 2026, 132,360+ packages on PyPI have cryptographic provenance attestations, enabled by default for any package published via GitHub Actions using the official PyPA publish action. These attestations link each release to a specific repository, workflow, and commit — making it verifiable that a published package was actually built from the expected source code.

En mars 2026, plus de 132 360 packages sur PyPI disposent d'attestations de provenance cryptographiques, activées par défaut pour tout package publié via GitHub Actions avec l'action PyPA officielle. Ces attestations relient chaque release à un dépôt, un workflow et un commit spécifiques.

# .github/workflows/publish.yml — Trusted Publisher (OIDC, no API tokens)
name: Publish to PyPI

on:
  push:
    tags: ["v*"]

permissions:
  id-token: write  # Required for OIDC

jobs:
  publish:
    runs-on: ubuntu-latest
    environment: pypi
    steps:
      - uses: actions/checkout@v4
      - name: Build distribution
        run: pip install build && python -m build
      - name: Publish to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1
        # No API token needed — OIDC handles authentication
        # Attestations generated automatically

To verify attestations on a package you're about to install:

Pour vérifier les attestations d'un package avant installation :

# Verify attestations using the PyPI CLI
pip install pypi-attestations
pypi-attestations verify requests==2.32.3

# Or check directly on PyPI
# https://pypi.org/project/requests/#files
# Packages with attestations show a "View attestation" link

pip-audit in CI/CD: Complete 2026 Integration Guide

pip-audit en CI/CD : Guide d'Intégration Complet 2026

A clean audit today is meaningless if a CVE is disclosed tomorrow while the same dependency version sits in production. The right architecture scans on every dependency change and periodically on a schedule, even when code hasn't changed.

Un audit propre aujourd'hui est sans valeur si un CVE est divulgué demain pendant que la même version de dépendance tourne en production. La bonne architecture scanne à chaque changement de dépendance et périodiquement selon un planning, même sans changement de code.

# .github/workflows/security.yml
name: Dependency Security Audit

on:
  push:
    paths:
      - "poetry.lock"
      - "pyproject.toml"
      - "requirements*.txt"
  pull_request:
    paths:
      - "poetry.lock"
      - "pyproject.toml"
  schedule:
    - cron: "0 8 * * 1"  # Every Monday morning

jobs:
  pip-audit:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: "3.12"

      - name: Install Poetry
        run: pip install poetry>=2.3.3  # Ensure patched version

      - name: Install pip-audit
        run: pip install pip-audit

      - name: Export dependencies
        run: poetry export --format requirements.txt --without-hashes -o requirements-audit.txt

      - name: Run pip-audit
        run: |
          pip-audit \
            -r requirements-audit.txt \
            --format json \
            -o pip-audit-report.json \
            --desc on

      - name: Upload audit report
        if: always()
        uses: actions/upload-artifact@v4
        with:
          name: pip-audit-report
          path: pip-audit-report.json

# Pre-commit hook integration (.pre-commit-config.yaml)
repos:
  - repo: local
    hooks:
      - id: pip-audit
        name: pip-audit dependency check
        entry: bash -c 'poetry export --format requirements.txt --without-hashes -o /tmp/req-audit.txt && pip-audit -r /tmp/req-audit.txt'
        language: system
        files: "^(poetry\\.lock|pyproject\\.toml)$"
        pass_filenames: false

Python Dependency Security Checklist for 2026

Checklist de Sécurité des Dépendances Python en 2026

• Upgrade Poetry to 2.3.3+ immediately (CVE-2026-34591 path traversal fix)
• Mettre à jour Poetry vers 2.3.3+ immédiatement (correctif traversal CVE-2026-34591)
• Run pip-audit in CI on every poetry.lock / pyproject.toml change
• Exécuter pip-audit en CI à chaque modification de poetry.lock / pyproject.toml
• Add a weekly scheduled pip-audit job — don't only scan on code changes
• Ajouter un job pip-audit hebdomadaire planifié — ne pas auditer uniquement lors des changements de code
• Commit poetry.lock to version control — never .gitignore it
• Committer poetry.lock dans le contrôle de version — ne jamais l'ajouter au .gitignore
• Migrate to PEP 751 pylock.toml and pip-audit 2.9.0+ for tool-agnostic auditing
• Migrer vers PEP 751 pylock.toml et pip-audit 2.9.0+ pour un audit agnostique aux outils
• Use PyPI Trusted Publishers for your own packages — eliminate stored API tokens
• Utiliser les PyPI Trusted Publishers pour vos propres packages — éliminer les tokens API stockés
• Verify attestations on critical dependencies before adding them
• Vérifier les attestations des dépendances critiques avant de les ajouter
• Review every pyproject.toml and poetry.lock diff in PRs as carefully as application code
• Examiner chaque diff de pyproject.toml et poetry.lock dans les PRs aussi soigneusement que le code applicatif

Frequently Asked Questions

Questions Fréquentes