L’attaque supply chain Rust qui vient de frapper la crate arrayref — 245 millions de téléchargements — change la nature du risque pour les PME-ETI : le code malveillant ne s’exécute plus au lancement de l’application, mais pendant la compilation. Autrement dit, il suffit d’un cargo build sur un poste de développeur ou dans un runner CI pour que l’infostealer parte à la chasse aux secrets. Cette bascule mérite qu’on s’y arrête, car elle invalide une bonne partie des réflexes défensifs hérités de l’ère npm.
Ce que révèle l’attaque supply chain Rust sur arrayref
Le scénario est désormais documenté : un compte mainteneur compromis, trois crates publiées dans la foulée, et une dépendance typosquattée nommée proc-macro1 — variante d’un paquet légitime largement utilisé. Le build script de cette dépendance télécharge puis exécute une charge distante au moment de la compilation, avant même que le binaire final n’existe.
Trois caractéristiques rendent cette attaque supply chain Rust particulièrement inconfortable :
- La cible n’est pas la production : ce sont les postes de développement et les runners CI/CD, historiquement moins surveillés que les serveurs exposés.
- L’exécution est légitime par conception : Cargo autorise les
build.rsà exécuter du code arbitraire. Ce n’est pas une faille, c’est une fonctionnalité du gestionnaire de paquets. - La détection arrive trop tard : un scan d’image ou un SBOM produit après le build documente un artefact déjà infecté par un processus qui a eu accès au cache, aux variables d’environnement et aux jetons.
Pourquoi les défenses classiques passent à côté
L’antivirus du poste voit un compilateur travailler, ce qu’il fait toute la journée. L’EDR voit du trafic sortant depuis un processus de build, comme lors de chaque résolution de dépendance. Et le pipeline CI, lui, dispose souvent de bien plus de droits que nécessaire : jetons de registre, clés cloud, accès en écriture au dépôt. C’est exactement le profil de victime recherché.
Le vrai enseignement : le build est un environnement d’exécution
La leçon stratégique dépasse l’écosystème Rust. Cargo, npm avec ses scripts postinstall, les setup.py Python, les plugins Gradle : tous partagent le même modèle où installer une dépendance signifie exécuter du code tiers. Une attaque supply chain Rust aujourd’hui, un paquet Go ou une action GitHub demain — le vecteur est structurel, pas conjoncturel.
Concrètement, cela implique de traiter le pipeline de build avec le même sérieux qu’un serveur de production. Nous avions déjà exploré cette logique à propos des vers npm qui volent les secrets CI/CD et de la sécurisation des workflows GitHub. L’épisode arrayref confirme la trajectoire.
Cinq mesures applicables cette semaine
- Épingler les versions exactes : verrouiller
Cargo.lock(et son équivalent dans chaque écosystème), interdire les plages de versions flottantes en CI. - Isoler le build : runner éphémère, réseau sortant restreint à une liste d’autorisation, aucun secret de production monté pendant la phase de compilation.
- Réduire les droits des jetons : un jeton de build ne doit ni publier de paquet, ni lire un coffre-fort, ni accéder au cloud de production.
- Auditer le cache : vérifier
~/.cargo/registryet les caches équivalents sur les postes développeurs, puis les purger en cas de doute. - Surveiller le comportement du build : toute connexion sortante inattendue depuis un processus de compilation est un signal, pas un bruit de fond.
Ce que les PME-ETI doivent retenir de cette attaque supply chain Rust
Il ne s’agit pas d’abandonner Rust, dont l’écosystème reste solide et réactif. Il s’agit d’admettre que la chaîne d’approvisionnement logicielle est devenue un périmètre à part entière, avec ses propres identités, ses propres privilèges et ses propres besoins de journalisation. Une organisation qui sait répondre à « quel processus a compilé ce binaire, avec quels droits, et vers quelles adresses a-t-il parlé ? » a déjà pris une longueur d’avance. Une attaque supply chain Rust ne se bloque pas avec un scanner : elle se contient avec une architecture de build qui suppose la compromission d’une dépendance et limite ce qu’elle peut atteindre.