Rust & Cargo Security Vulnerabilities in 2026: CVE-2026-33055 (Archive Smuggling), CVE-2026-33056 (Symlink chmod) & Complete cargo audit GuideVulnérabilités Sécurité Rust & Cargo en 2026 : CVE-2026-33055 (Smuggling d'Archives), CVE-2026-33056 (Symlink chmod) & Guide cargo audit Complet

In March 2026, the Rust Security Response Team disclosed two vulnerabilities in the tar-rs crate — the archive library that Cargo uses to extract packages during a build. One allows a malicious crate to silently modify permissions on arbitrary directories on your filesystem (CVE-2026-33056). The other enables hidden entries to be smuggled past security validators using a parser differential (CVE-2026-33055). Both were patched in tar 0.4.45 and Rust 1.94.1, released March 26, 2026.

En mars 2026, l'équipe de réponse sécurité Rust a divulgué deux vulnérabilités dans le crate tar-rs — la bibliothèque d'archives utilisée par Cargo pour extraire les packages lors d'un build. L'une permet à un crate malveillant de modifier silencieusement les permissions de répertoires arbitraires sur votre système de fichiers (CVE-2026-33056). L'autre permet de faire passer des entrées cachées devant les validateurs de sécurité grâce à un différentiel de parseur (CVE-2026-33055). Les deux ont été corrigées dans tar 0.4.45 et Rust 1.94.1, publié le 26 mars 2026.

Rust's memory safety guarantees are well-known — but they don't protect you from vulnerable dependencies in your supply chain. With over 200,000 crates on crates.io and the RustSec Advisory Database tracking approximately 600 advisories, the Rust ecosystem has the same dependency risk surface as every other language. This guide covers every detail of the March 2026 CVEs, how to audit your project with cargo audit and cargo-deny, and a complete Cargo.lock security checklist.

Les garanties de sécurité mémoire de Rust sont bien connues — mais elles ne vous protègent pas des dépendances vulnérables dans votre chaîne d'approvisionnement. Avec plus de 200 000 crates sur crates.io et la base de données d'avis RustSec suivant environ 600 avis, l'écosystème Rust présente la même surface de risque de dépendance que tous les autres langages. Ce guide couvre chaque détail des CVE de mars 2026, comment auditer votre projet avec cargo audit et cargo-deny, et une checklist de sécurité Cargo.lock complète.

The March 2026 Rust Security Release: Two tar-rs CVEs

La Release de Sécurité Rust de Mars 2026 : Deux CVE tar-rs

On March 21, 2026, the Rust Security Response Team published an advisory for the tar-rs crate (tar on crates.io), covering two distinct vulnerabilities. The tar crate is a dependency of Cargo itself — meaning every Rust developer who runs cargo build, cargo install, or cargo add depends on it. On March 26, 2026, Rust 1.94.1 was released with tar updated to 0.4.45, resolving both issues. Microsoft's Security Response Center independently flagged both CVEs as supply chain risks impacting software using Cargo-based build pipelines.

Le 21 mars 2026, l'équipe de réponse sécurité Rust a publié un avis pour le crate tar-rs (tar sur crates.io), couvrant deux vulnérabilités distinctes. Le crate tar est une dépendance de Cargo lui-même — ce qui signifie que chaque développeur Rust qui exécute cargo build, cargo install ou cargo add en dépend. Le 26 mars 2026, Rust 1.94.1 a été publié avec tar mis à jour vers 0.4.45, corrigeant les deux problèmes. Le centre de réponse de sécurité de Microsoft a indépendamment signalé les deux CVE comme des risques de supply chain affectant les pipelines de build basés sur Cargo.

CVE-2026-33056: tar-rs Symlink Following Allows Arbitrary Directory chmod

CVE-2026-33056 : Suivi de Lien Symbolique tar-rs Permet un chmod de Répertoire Arbitraire

CVE-2026-33056 (CVSS v4.0 5.1 — Medium) affects tar-rs versions 0.4.44 and below. The vulnerability lives in the unpack_dir function inside src/entry.rs. When extracting a tar archive that already has a matching path on the filesystem, the function calls std::fs::metadata() to confirm the existing path is a directory before merging the contents.

CVE-2026-33056 (CVSS v4.0 5.1 — Medium) affecte les versions de tar-rs 0.4.44 et inférieures. La vulnérabilité se trouve dans la fonction unpack_dir dans src/entry.rs. Lors de l'extraction d'une archive tar qui a déjà un chemin correspondant sur le système de fichiers, la fonction appelle std::fs::metadata() pour confirmer que le chemin existant est un répertoire avant de fusionner le contenu.

The flaw: std::fs::metadata() follows symbolic links — it returns the metadata of the target of a symlink, not the symlink itself. A crafted tarball can contain a symlink entry first (pointing to any directory on the system), followed by a directory entry with the same name. When tar-rs processes the directory entry, it resolves the symlink and finds a directory — then applies chmod to the symlink's target, not to the extraction root. This allows changing permissions on directories like /etc, /tmp, or any other path reachable by the user running Cargo.

La faille : std::fs::metadata() suit les liens symboliques — elle retourne les métadonnées de la cible d'un lien symbolique, pas du lien lui-même. Une archive tar construite malicieusement peut contenir d'abord une entrée de lien symbolique (pointant vers n'importe quel répertoire du système), suivie d'une entrée de répertoire avec le même nom. Quand tar-rs traite l'entrée de répertoire, il résout le lien symbolique et trouve un répertoire — puis applique chmod à la cible du lien, pas à la racine d'extraction. Cela permet de modifier les permissions de répertoires comme /etc, /tmp, ou tout autre chemin accessible par l'utilisateur exécutant Cargo.

Real-world risk: The Rust Security Response Team confirmed that a change was deployed on March 13th, 2026 to prevent uploading new crates exploiting this vulnerability to crates.io, and that all previously published crates were audited with none found exploiting it. However, projects using private registries, vendored dependencies, or third-party build systems that unpack crates from arbitrary archives remain exposed unless upgraded to tar 0.4.45+.

Risque réel : L'équipe de réponse sécurité Rust a confirmé qu'un changement a été déployé le 13 mars 2026 pour empêcher le téléchargement de nouveaux crates exploitant cette vulnérabilité sur crates.io, et que tous les crates publiés antérieurement ont été audités sans qu'aucun n'exploite la faille. Cependant, les projets utilisant des registres privés, des dépendances vendored, ou des systèmes de build tiers qui décompressent des crates depuis des archives arbitraires restent exposés sans mise à niveau vers tar 0.4.45+.

$ cargo tree -i tar
tar v0.4.44  ← vulnerable (upgrade required)
tar v0.4.45  ← patched ✅

# Upgrade tar-rs if it appears directly in Cargo.toml
$ cargo update -p tar

# Or upgrade Rust to 1.94.1+ (Cargo bundles tar 0.4.45)
$ rustup update stable

CVE-2026-33055: PAX Header Parser Differential Enables Archive Smuggling

CVE-2026-33055 : Différentiel de Parseur PAX Permet le Smuggling d'Archives

CVE-2026-33055 (CVSS 7.3 — High) is the more technically subtle of the two. It exploits a discrepancy between how tar-rs handles PAX extended headers and how every other major tar implementation (including Go's archive/tar) handles them.

CVE-2026-33055 (CVSS 7.3 — Haut) est le plus techniquement subtil des deux. Il exploite une divergence entre la façon dont tar-rs gère les en-têtes étendus PAX et la façon dont toutes les autres implémentations tar majeures (y compris archive/tar de Go) les gèrent.

Technical root cause: The PAX format (POSIX.1-2001) allows entries to carry extended headers that override USTAR base header fields, including file size. The vulnerable tar-rs logic reads the USTAR size first and only falls back to the PAX size if the USTAR size is exactly zero. If the USTAR size is any non-zero value, the PAX size is silently discarded. Every other compliant tar parser unconditionally uses the PAX size if a PAX header is present.

Cause racine technique : Le format PAX (POSIX.1-2001) permet aux entrées de porter des en-têtes étendus qui remplacent les champs d'en-tête de base USTAR, y compris la taille du fichier. La logique vulnérable de tar-rs lit d'abord la taille USTAR et ne revient à la taille PAX que si la taille USTAR est exactement zéro. Si la taille USTAR a n'importe quelle valeur non nulle, la taille PAX est silencieusement ignorée. Chaque autre parseur tar conforme utilise inconditionnellement la taille PAX si un en-tête PAX est présent.

Attack vectors enabled: This parser differential creates a class of crafted archives that appear differently depending on which tool extracts them. Security scanners that validate archive contents before extraction may see a benign entry — then tar-rs extracts a completely different payload from the same bytes. Common exploitation paths include: writing arbitrary files outside the extraction root, creating symbolic links that enable directory traversal, and planting executable payloads in build artifact directories. Microsoft's Security Response Center flagged this as a software supply chain risk for teams using Cargo in automated pipelines.

Vecteurs d'attaque activés : Ce différentiel de parseur crée une classe d'archives construites qui apparaissent différemment selon l'outil qui les extrait. Les scanners de sécurité qui valident le contenu d'une archive avant l'extraction peuvent voir une entrée bénigne — puis tar-rs extrait un payload complètement différent des mêmes octets. Les chemins d'exploitation courants incluent : écriture de fichiers arbitraires en dehors de la racine d'extraction, création de liens symboliques permettant la traversée de répertoires, et plantation de payloads exécutables dans les répertoires d'artefacts de build. Le Centre de Réponse de Sécurité de Microsoft a signalé cela comme un risque de supply chain logiciel pour les équipes utilisant Cargo dans des pipelines automatisés.

# Crafted TAR entry structure:
# PAX extended header:  size = 0      (benign — what validators see)
# USTAR base header:    size = 4096   (non-zero → tar-rs uses THIS)
# Actual payload:       4096 bytes of malicious content

# tar-rs (vulnerable ≤ 0.4.44): extracts 4096 bytes  ← malicious
# GNU tar / Go archive/tar:      extracts 0 bytes     ← safe

# Fix in tar 0.4.45: always use PAX size when PAX header present

Rust 1.94.1: The Patch Release and What Changed

Rust 1.94.1 : La Release de Correctif et Ce Qui a Changé

Rust 1.94.1 was released on March 26, 2026, five days after the CVE advisory. It updates the bundled Cargo toolchain to use tar 0.4.45, which applies two targeted fixes:

Rust 1.94.1 a été publié le 26 mars 2026, cinq jours après l'avis CVE. Il met à jour la chaîne d'outils Cargo intégrée pour utiliser tar 0.4.45, qui applique deux correctifs ciblés :

• CVE-2026-33056 fix: Replaces std::fs::metadata() with std::fs::symlink_metadata() in unpack_dir, which does NOT follow symbolic links — it returns metadata for the link itself, breaking the chmod-via-symlink attack chain.
• Correctif CVE-2026-33056 : Remplace std::fs::metadata() par std::fs::symlink_metadata() dans unpack_dir, qui ne suit PAS les liens symboliques — il retourne les métadonnées du lien lui-même, brisant la chaîne d'attaque chmod-via-symlink.
• CVE-2026-33055 fix: Unconditionally uses the PAX size value when a PAX extended header is present, aligning tar-rs behavior with the POSIX.1-2001 specification and all other compliant implementations.
• Correctif CVE-2026-33055 : Utilise inconditionnellement la valeur de taille PAX lorsqu'un en-tête étendu PAX est présent, alignant le comportement de tar-rs avec la spécification POSIX.1-2001 et toutes les autres implémentations conformes.

# Check current version
$ rustc --version
rustc 1.93.0  ← upgrade required

# Upgrade via rustup (recommended)
$ rustup update stable

# Verify
$ rustc --version
rustc 1.94.1 (2026-03-26)  ✅

# Confirm bundled tar version in Cargo
$ cargo tree -i tar
tar v0.4.45  ✅

The Broader Rust Supply Chain Risk: What cargo audit Misses

Le Risque Supply Chain Rust Plus Large : Ce que cargo audit Ne Détecte Pas

The tar-rs CVEs are not an isolated incident. In April 2025, a malicious crate named evm-units was published to crates.io and accumulated over 7,000 downloads over eight months before detection. It downloaded an OS-specific payload, checked whether Qihoo 360 antivirus was running, and executed silently from the system temp directory. The Rust ecosystem is growing rapidly — with 200,000+ crates and crates.io serving nearly 1 billion downloads per day — and the dependency graph risk grows with it.

Les CVE tar-rs ne sont pas un incident isolé. En avril 2025, un crate malveillant nommé evm-units a été publié sur crates.io et a accumulé plus de 7 000 téléchargements sur huit mois avant d'être détecté. Il téléchargeait un payload spécifique à l'OS, vérifiait si l'antivirus Qihoo 360 tournait, et s'exécutait silencieusement depuis le répertoire temp du système. L'écosystème Rust croît rapidement — avec plus de 200 000 crates et crates.io servant près d'un milliard de téléchargements par jour — et le risque du graphe de dépendances croît avec lui.

A 2025 deep-dive analysis of the crates.io ecosystem found that approximately 20% of actively used crates fail a standard cargo-deny configuration — either due to known vulnerabilities, unmaintained status, or prohibited licenses. Complexity (deep transitive dependency trees) is a stronger predictor of vulnerability inheritance than crate age. This means large Rust projects — especially those using async runtimes like Tokio, web frameworks like Actix-web or Axum, or cryptography crates — carry meaningful supply chain exposure.

Une analyse approfondie 2025 de l'écosystème crates.io a révélé qu'environ 20% des crates activement utilisés échouent une configuration standard de cargo-deny — soit en raison de vulnérabilités connues, d'un statut non maintenu, ou de licences interdites. La complexité (arbres de dépendances transitives profondes) est un prédicteur plus fort de l'héritage de vulnérabilités que l'âge du crate. Cela signifie que les grands projets Rust — notamment ceux utilisant des runtimes async comme Tokio, des frameworks web comme Actix-web ou Axum, ou des crates de cryptographie — portent une exposition supply chain significative.

cargo audit: The Essential Rust Vulnerability Scanner

cargo audit : Le Scanner de Vulnérabilités Rust Essentiel

cargo audit checks your Cargo.lock against the RustSec Advisory Database — a repository of ~600 security advisories maintained by the Rust Security Working Group, covering both active vulnerabilities and unmaintained crates. It's the first tool every Rust project should run.

cargo audit vérifie votre Cargo.lock par rapport à la base de données d'avis RustSec — un dépôt d'environ 600 avis de sécurité maintenu par le groupe de travail sécurité Rust, couvrant à la fois les vulnérabilités actives et les crates non maintenus. C'est le premier outil que chaque projet Rust devrait exécuter.

# Install
$ cargo install cargo-audit --features=fix

# Run a basic audit
$ cargo audit

# Auto-fix patched vulnerabilities (upgrades Cargo.lock)
$ cargo audit fix

# Check for unmaintained crates too (highly recommended)
$ cargo audit --deny warnings

# Example output for a vulnerable project:
Fetching advisory database from `https://github.com/RustSec/advisory-db.git`
Loaded 623 security advisories (from ~/.cargo/advisory-db)

error[RUSTSEC-2026-0056]: tar-rs unpack_in can chmod arbitrary directories
  Crate:         tar
  Version:       0.4.44
  Date:          2026-03-21
  URL:           https://rustsec.org/advisories/RUSTSEC-2026-0056.html
  Solution:      upgrade to >= 0.4.45

error[RUSTSEC-2026-0055]: tar-rs PAX header parser differential
  Crate:         tar
  Version:       0.4.44
  Date:          2026-03-21
  URL:           https://rustsec.org/advisories/RUSTSEC-2026-0055.html
  Solution:      upgrade to >= 0.4.45

One unique feature of cargo audit — through the RustSec database — is detection of unmaintained crates. Unlike npm audit or pip audit, RustSec explicitly tracks crates whose maintainers have abandoned them, with "informational" advisories that flag the risk before a CVE is even filed. This catches an entire category of supply chain risk that vulnerability databases miss entirely.

Une fonctionnalité unique de cargo audit — via la base de données RustSec — est la détection des crates non maintenus. Contrairement à npm audit ou pip audit, RustSec suit explicitement les crates dont les mainteneurs les ont abandonnés, avec des avis "informationnels" qui signalent le risque avant même qu'une CVE soit soumise. Cela capture toute une catégorie de risque supply chain que les bases de données de vulnérabilités manquent entièrement.

cargo-deny: Policy Enforcement Beyond Vulnerability Scanning

cargo-deny : Application de Politiques au-delà du Scan de Vulnérabilités

While cargo audit is focused on CVEs and advisory matching, cargo-deny enforces broader supply chain policies — blocking disallowed licenses, flagging duplicate versions of the same crate, restricting allowed crate sources, and denying known-bad advisories. It's the tool that catches the other 20% of issues.

Alors que cargo audit est centré sur les CVE et la correspondance d'avis, cargo-deny applique des politiques de supply chain plus larges — bloquant les licences non autorisées, signalant les versions en double du même crate, restreignant les sources de crates autorisées, et refusant les avis connus mauvais. C'est l'outil qui capture les 20% de problèmes restants.

[advisories]
# Deny all active vulnerabilities
deny = ["unmaintained", "unsound", "yanked"]
# Vulnerability database
db-path = "~/.cargo/advisory-db"
db-urls = ["https://github.com/rustsec/advisory-db"]

[licenses]
# Only allow permissive/common licenses
allow = ["MIT", "Apache-2.0", "BSD-2-Clause", "BSD-3-Clause", "ISC"]
deny = ["GPL-2.0", "GPL-3.0", "AGPL-3.0"]

[bans]
# Deny duplicate versions of the same crate
multiple-versions = "warn"
# Block wildcards in Cargo.toml dependencies
wildcards = "deny"

[sources]
# Only allow crates from crates.io
unknown-registry = "deny"
unknown-git = "deny"

# Install
$ cargo install cargo-deny

# Initialize config
$ cargo deny init

# Run all checks
$ cargo deny check

# Run only security advisory checks
$ cargo deny check advisories

# Add to CI (GitHub Actions)
- name: Cargo Deny
  uses: EmbarkStudios/cargo-deny-action@v1

Integrating Cargo Security into Your CI/CD Pipeline

Intégrer la Sécurité Cargo dans Votre Pipeline CI/CD

Running cargo audit and cargo-deny locally is a start, but the real value comes from making them blocking steps in your CI pipeline. Here's a complete GitHub Actions workflow for Rust projects:

Exécuter cargo audit et cargo-deny localement est un début, mais la vraie valeur vient de les rendre des étapes bloquantes dans votre pipeline CI. Voici un workflow GitHub Actions complet pour les projets Rust :

name: Rust Security Audit

on:
  push:
    branches: [main, develop]
  pull_request:
  schedule:
    - cron: '0 8 * * 1'  # Weekly on Monday (catch new advisories)

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

      # Pin Rust version to avoid toolchain supply chain risk
      - name: Install Rust 1.94.1+
        uses: dtolnay/rust-toolchain@stable
        with:
          toolchain: stable

      # cargo audit — CVE check via RustSec
      - name: Install cargo-audit
        run: cargo install cargo-audit --features=fix

      - name: Run cargo audit
        run: cargo audit --deny warnings

      # cargo-deny — policy enforcement
      - name: Cargo Deny
        uses: EmbarkStudios/cargo-deny-action@v1
        with:
          command: check advisories licenses bans sources

Key addition: the weekly scheduled run. New advisories are added to the RustSec database continuously — a dependency that was safe when you last committed may have a new CVE filed today. The scheduled Monday run catches advisories that land between your commits, before they become a production incident.

Ajout clé : l'exécution programmée hebdomadaire. De nouveaux avis sont ajoutés à la base de données RustSec en continu — une dépendance qui était sûre lors de votre dernier commit peut avoir une nouvelle CVE déposée aujourd'hui. L'exécution du lundi programmée capture les avis qui arrivent entre vos commits, avant qu'ils ne deviennent un incident de production.

Cargo.lock Security Checklist: 8 Rules for Rust Projects

Checklist de Sécurité Cargo.lock : 8 Règles pour les Projets Rust

• 1. Always commit Cargo.lock for binaries and applications. Not committing it means CI resolves dependencies fresh each run, potentially pulling in malicious minor version bumps. Applications and binaries must pin their full dependency graph.
• 1. Committez toujours Cargo.lock pour les binaires et applications. Ne pas le committer signifie que CI résout les dépendances fraîchement à chaque run, pouvant tirer des bumps de version mineure malveillants. Les applications et binaires doivent fixer leur graphe de dépendances complet.
• 2. Keep tar ≥ 0.4.45 in your Cargo.lock. Run cargo tree -i tar to check. If you depend on a crate that pins tar 0.4.44, file an issue or use [patch.crates-io] to override.
• 2. Gardez tar ≥ 0.4.45 dans votre Cargo.lock. Exécutez cargo tree -i tar pour vérifier. Si vous dépendez d'un crate qui fixe tar 0.4.44, signalez un problème ou utilisez [patch.crates-io] pour le remplacer.
• 3. Run cargo audit in CI on every pull request. Make it a blocking step. Use --deny warnings to fail on unmaintained crates, not just active CVEs.
• 3. Exécutez cargo audit en CI sur chaque pull request. Faites-en une étape bloquante. Utilisez --deny warnings pour échouer sur les crates non maintenus, pas seulement sur les CVE actives.
• 4. Add a weekly scheduled CI run. New advisories land between commits. A weekly cron job on your default branch catches them before they reach production.
• 4. Ajoutez un run CI programmé hebdomadaire. De nouveaux avis arrivent entre les commits. Un cron hebdomadaire sur votre branche principale les capture avant qu'ils n'atteignent la production.
• 5. Use cargo-deny for policy enforcement. Block unknown registries, disallowed licenses, and wildcard version constraints. This prevents dependency confusion and license compliance issues.
• 5. Utilisez cargo-deny pour l'application des politiques. Bloquez les registres inconnus, les licences interdites et les contraintes de version wildcard. Cela prévient la confusion de dépendances et les problèmes de conformité de licence.
• 6. Pin Rust toolchain version in CI with rust-toolchain.toml. A floating stable toolchain in CI can pull in a compromised or regressed nightly build. Explicit pinning gives you reproducibility and a clear upgrade path.
• 6. Fixez la version de la chaîne d'outils Rust en CI avec rust-toolchain.toml. Une chaîne d'outils stable flottante en CI peut tirer un build nightly compromis ou régressif. Le pinning explicite vous donne de la reproductibilité et un chemin de mise à niveau clair.
• 7. Review crates.io Security tab before adding new dependencies. crates.io now shows a "Security" tab on each crate page displaying all RustSec advisories. Check it before running cargo add.
• 7. Consultez l'onglet Sécurité de crates.io avant d'ajouter de nouvelles dépendances. crates.io affiche maintenant un onglet "Sécurité" sur chaque page de crate montrant tous les avis RustSec. Vérifiez-le avant d'exécuter cargo add.
• 8. Avoid using unsafe in dependencies without audit. Rust's memory safety guarantees break down inside unsafe blocks. Use cargo geiger to measure the unsafe code surface in your dependency tree.
• 8. Évitez d'utiliser unsafe dans les dépendances sans audit. Les garanties de sécurité mémoire de Rust s'effondrent dans les blocs unsafe. Utilisez cargo geiger pour mesurer la surface de code unsafe dans votre arbre de dépendances.

Frequently Asked Questions

Questions Fréquentes