Slopsquatting : quand les agents IA installent de faux paquets
Matt · · Mis à jour le · 12 min de lecture · Guides
Comment le slopsquatting fait entrer un faux paquet dans un dépôt par la pull request d'un agent IA, cinq défenses et une barrière de CI à copier qui bloque les nouveaux paquets.
Sur cette page
Le slopsquatting, c'est quand un attaquant publie un paquet sous un nom que les modèles d'IA ont tendance à inventer, et qu'un développeur ou un agent de codage l'installe ensuite parce que le modèle l'a suggéré. La défense consiste à traiter chaque nouvelle dépendance d'une pull request écrite par l'IA comme non vérifiée : la rechercher avant que quoi que ce soit ne l'installe, et bloquer les noms qui n'existent pas, qui sont tout récents ou qui n'ont presque aucun utilisateur. Voici cinq contrôles, et une barrière de CI que j'ai exécutée et qui fait cette recherche.
Ce qu'est le slopsquatting
Demandez à un modèle du code qui analyse un fichier de configuration ou qui dialogue avec une API de paiement, et il importe souvent un paquet pour faire le travail. La plupart du temps, le paquet existe. Parfois non. Le modèle a vu des milliers de noms similaires, et il en produit un qui sonne juste mais n'a jamais été publié.
Quand une personne lit ce code, un faux nom n'est qu'une gêne : l'installation échoue et elle choisit une autre bibliothèque. Cela devient une attaque de la supply chain quand quelqu'un remarque quels faux noms les modèles produisent régulièrement et publie de vrais paquets sous ces noms. Le développeur suivant, ou l'agent suivant, qui reçoit la même suggestion installe le code de l'attaquant. C'est le slopsquatting : du typosquatting où la faute de frappe est commise par l'IA.
La meilleure mesure publique que je connaisse est l'article We Have a Package for You! A Comprehensive Analysis of Package Hallucinations by Code Generating LLMs de Joseph Spracklen et ses coauteurs, accepté à USENIX Security 2025 (résumé vérifié le 24 octobre 2026). Ils ont utilisé 16 modèles de code et deux jeux de prompts pour générer 576 000 échantillons de code. En moyenne, au moins 5.2% des paquets suggérés par les modèles commerciaux et 21.7% de ceux suggérés par les modèles open source n'existaient pas. Sur l'ensemble de l'étude, ils ont recueilli 205 474 noms de paquets hallucinés uniques.
L'attaque n'a pas besoin de tous les faux noms. Il lui en faut un qui revient plus d'une fois, car un nom que les modèles suggèrent sans cesse vaut la peine d'être enregistré. Ces chiffres valent pour les modèles testés à l'époque ; les plus récents font peut-être mieux, ou moins bien, et je ne m'avancerai pas à dire lesquels. Les défenses ne dépendent pas du taux exact.
Comment il atteint un dépôt par la pull request d'un agent
Quand une personne copie une suggestion depuis une fenêtre de chat, il y a un moment où elle lit l'import, cherche peut-être la bibliothèque, et remarque qu'elle compte trois téléchargements et a été publiée la semaine précédente.
Un agent de codage saute ce moment. Il écrit l'import, ajoute le nom à package.json et lance l'installation, parce que c'est à cela que ressemble une tâche terminée. Si l'installation réussit, l'agent passe à la suite et ouvre une pull request. Le nouveau nom n'est qu'une ligne dans un manifeste et quelques centaines de lignes de lockfile, sous un résumé qui annonce « ajout de la validation des entrées ».
C'est l'installation qui fait les dégâts, souvent avant que quiconque ne relise la pull request. npm exécute les scripts de cycle de vie des paquets qu'il installe, sauf si vous lui dites de ne pas le faire. La documentation de configuration de npm décrit ignore-scripts ainsi : « si true, npm n'exécute pas les scripts spécifiés dans les fichiers package.json », avec false comme valeur par défaut (vérifié le 24 octobre 2026). Un script postinstall présent dans un paquet fraîchement squatté s'exécute donc sur la machine qui a fait l'installation, quelle qu'elle soit. Sur le portable d'un développeur, cette machine détient des clés SSH et des identifiants cloud. Sur un runner de CI, elle détient des tokens de déploiement.
La question n'est donc pas seulement « allons-nous fusionner ceci ? ». C'est aussi « où ce nom est-il installé avant que quiconque ne décide ? ».
Défenses
Aucune ne nécessite un nouveau produit. Ce sont des règles ordinaires d'hygiène des paquets, appliquées en partant du principe que certains noms d'un changement n'ont jamais été vérifiés par une personne.
Les lockfiles
npm ci installe exactement ce que dit le lockfile. La documentation de npm ci indique que le projet doit avoir un package-lock.json ou un npm-shrinkwrap.json, et que si les dépendances du lockfile ne correspondent pas à celles de package.json, « npm ci s'arrête avec une erreur au lieu de mettre à jour le package lock » (vérifié le 24 octobre 2026). « L'agent a ajouté un nom et oublié le lockfile » devient ainsi un build rouge, et non une résolution silencieuse.
Cela n'aide pas quand l'agent a aussi mis à jour le lockfile, ce que font la plupart. Mais chaque nouvelle dépendance apparaît alors dans un diff du lockfile qu'une vérification peut lire.
Listes d'autorisation et registres
Décidez d'où viennent les paquets et quel code peut s'exécuter à l'installation :
- Faites pointer la CI vers un seul registre dans son
.npmrcou sonpip.conf. Si vous utilisez un registre privé ou un proxy, il peut contenir une liste de paquets approuvés, et un nom qui n'y figure pas ne se résout pas. - Définissez
ignore-scripts=truedans le.npmrcdes jobs qui ne font que lire le code, comme le lint ou une vérification des dépendances. Certains paquets ont besoin de leurs scripts d'installation, par exemple pour récupérer un binaire natif : testez donc avant de l'activer partout. Là où vous ne pouvez pas désactiver les scripts, lancez l'installation sur un runner qui ne détient aucun secret. - Pour Python, la page sur les installations sécurisées de pip décrit le mode de vérification des empreintes (
--require-hashes), dans lequel chaque dépendance, transitives comprises, doit être épinglée et accompagnée de son empreinte. Elle recommande aussi--only-binary :all:pour refuser les distributions source, puisque leur construction exécute le code du paquet.
Vérifier qu'un paquet existe, et depuis quand
C'est le contrôle qui vise directement le slopsquatting. Quand une pull request ajoute une dépendance, recherchez-la dans le registre avant que quoi que ce soit ne l'installe. Trois réponses doivent arrêter la fusion :
- le nom n'est pas dans le registre (l'agent l'a inventé et personne ne l'a encore revendiqué) ;
- le nom existe, mais sa première publication est très récente (quelqu'un vient peut-être de le revendiquer) ;
- le nom existe, mais presque personne ne le télécharge.
La section suivante propose un script qui fait les trois.
L'audit des dépendances comme barrière de fusion
Un outil d'analyse de la composition logicielle couvre le versant vulnérabilités connues d'une nouvelle dépendance, et il doit être une vérification requise, pas un simple rapport. Dans AI CodeOps, l'agent Dependency Auditor lit vos manifestes et signale les vulnérabilités connues, les problèmes de licence et les paquets qui semblent abandonnés. La revue en fin de session en fait des constats, et un constat ouvert de gravité high ou critical bloque la pull request jusqu'à ce qu'il soit marqué fixed, won't fix, false positive ou duplicate.
Soyons clairs sur sa limite : l'auditeur s'appuie sur les connaissances propres du modèle et n'interroge ni le registre ni une base d'avis de sécurité. Il ne peut pas vous dire qu'un nom a été enregistré il y a une heure. C'est pourquoi la vérification de l'existence et de l'âge est une barrière distincte.
Relire le diff des SBOM
Un SBOM liste chaque composant que contient un build, transitifs compris. Comparer le SBOM de la branche de base à celui de la pull request montre ce que le changement a réellement ajouté, souvent plus que le seul nom visible dans le manifeste. Le comparateur de SBOM compare deux fichiers JSON CycloneDX dans votre navigateur et liste les composants ajoutés, retirés et modifiés, avec leurs versions et leurs licences. Un composant nouveau dans le SBOM est le premier à examiner.
Exemple : une barrière qui bloque un paquet récent et peu téléchargé
Ce script Node compare le package.json de la branche de base avec celui de la pull request et repère les noms ajoutés. Pour chacun, il demande au registre la date de première publication du paquet avec npm view <name> time.created, puis interroge l'API publique des téléchargements de npm sur le nombre de téléchargements de la semaine écoulée. Il n'installe jamais rien. Il est écrit pour un runner Linux, où npm peut être lancé sans shell.
// scripts/check-new-deps.mjs
// Usage: node scripts/check-new-deps.mjs base/package.json head/package.json
// Fails when a dependency added between the two files is not on the npm
// registry, was first published fewer than MIN_AGE_DAYS days ago, or had
// fewer than MIN_WEEKLY_DOWNLOADS downloads last week.
import { readFileSync } from "node:fs"
import { execFileSync } from "node:child_process"
const MIN_AGE_DAYS = Number(process.env.MIN_AGE_DAYS ?? 30)
const MIN_WEEKLY_DOWNLOADS = Number(process.env.MIN_WEEKLY_DOWNLOADS ?? 500)
const FIELDS = ["dependencies", "devDependencies", "optionalDependencies", "peerDependencies"]
const names = (file) => {
const pkg = JSON.parse(readFileSync(file, "utf8"))
return new Set(FIELDS.flatMap((f) => Object.keys(pkg[f] ?? {})))
}
const before = names(process.argv[2])
const added = [...names(process.argv[3])].filter((n) => !before.has(n))
const VALID = /^(@[a-z0-9][\w.-]*\/)?[a-z0-9][\w.-]*$/
let failed = false
for (const name of added) {
if (!VALID.test(name)) {
console.log(`BLOCK ${name}: not a valid npm package name`)
failed = true
continue
}
let created
try {
// execFile, not a shell: the name comes from an untrusted pull request.
created = JSON.parse(
execFileSync("npm", ["view", name, "time.created", "--json"], {
encoding: "utf8",
stdio: ["ignore", "pipe", "ignore"],
}),
)
} catch {
console.log(`BLOCK ${name}: not found on the registry`)
failed = true
continue
}
const days = Math.floor((Date.now() - new Date(created).getTime()) / 86_400_000)
if (days < MIN_AGE_DAYS) {
console.log(`BLOCK ${name}: first published ${days} days ago (${created})`)
failed = true
continue
}
const res = await fetch(`https://api.npmjs.org/downloads/point/last-week/${name}`)
const downloads = res.ok ? (await res.json()).downloads : 0
if (downloads < MIN_WEEKLY_DOWNLOADS) {
console.log(`BLOCK ${name}: ${downloads} downloads last week`)
failed = true
continue
}
console.log(`ok ${name}: first published ${created.slice(0, 10)}, ${downloads} downloads last week`)
}
if (added.length === 0) console.log("No new dependencies.")
process.exit(failed ? 1 : 0)
Je l'ai exécuté avec Node 22 le 24 octobre 2026, sur un fichier de base ne contenant que express et un fichier de tête qui ajoutait zod, @types/node, vitest et un nom inventé, fastify-auth-session-helper-x7 :
ok zod: first published 2020-03-07, 221643257 downloads last week
ok @types/node: first published 2016-05-17, 296109529 downloads last week
BLOCK fastify-auth-session-helper-x7: not found on the registry
ok vitest: first published 2021-12-03, 83654107 downloads last week
Il s'est terminé avec le statut 1. Sans nouveau nom, il affiche « No new dependencies. » et se termine avec le statut 0. Pour vérifier les deux autres branches du script, j'ai relevé les seuils : MIN_AGE_DAYS=2500 a bloqué zod et vitest comme trop récents, et MIN_WEEKLY_DOWNLOADS=250000000 les a bloqués pour trop peu de téléchargements.
Pour l'exécuter sur chaque pull request dans GitHub Actions :
name: New dependency check
on: pull_request
permissions:
contents: read
jobs:
new-deps:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v7
with:
fetch-depth: 0
- uses: actions/setup-node@v7
with:
node-version: 22
- name: Look up dependencies the pull request adds
env:
BASE_REF: ${{ github.base_ref }}
run: |
git show "origin/$BASE_REF:package.json" > "$RUNNER_TEMP/base-package.json"
node scripts/check-new-deps.mjs "$RUNNER_TEMP/base-package.json" package.json
Quelques remarques :
- Il s'exécute sur chaque pull request au lieu de filtrer sur
paths, pour pouvoir servir de vérification requise sans rester en attente sur les pull requests qui ne touchent paspackage.json. - Il ne lit que le
package.jsonracine. Dans un monorepo, bouclez sur le fichier de chaque workspace. npm viewutilise le registre et les identifiants de votre.npmrc. Si vous installez des paquets privés sous scope, donnez au job le même.npmrc, sinon un nom privé apparaîtra comme « not found ». L'API des téléchargements ne connaît que les paquets publics : sautez donc cette vérification pour votre propre scope.- Trente jours et 500 téléchargements par semaine sont des points de départ, pas des seuils que je peux étayer par des données. Un nom bloqué invite une personne à regarder de plus près ; ce n'est pas la preuve d'une attaque.
Ce que fait AI CodeOps quand une session ajoute une dépendance
AI CodeOps exécute les agents sur sa plateforme : la question « où ce nom est-il installé ? » a donc une réponse précise, vérifiée dans le code à la date de cet article.
Les agents n'exécutent pas de gestionnaire de paquets. Les agents d'une session écrivent le changement sous forme de modifications de fichiers. Le seul endroit où une session exécute quoi que ce soit est l'étape verify (vérification), qui lance les tests de votre projet dans un bac à sable.
Vos dépendances existantes s'installent d'abord, puis le réseau disparaît. Pour un projet connecté à un dépôt, l'étape verify clone ce dépôt dans le bac à sable et installe les dépendances déjà présentes sur votre branche par défaut, avec accès au réseau, avant qu'aucune des modifications de l'IA ne soit écrite. Elle coupe ensuite le bac à sable du réseau et le confirme depuis l'intérieur. Si elle ne peut pas le confirmer, le changement n'est pas exécuté du tout.
Une nouvelle dépendance doit s'installer hors ligne. Si le changement touche un manifeste de dépendances ou un lockfile, comme package.json, requirements.txt, go.mod ou Cargo.toml, l'installation est relancée, toujours hors ligne. Un paquet qui n'était pas déjà installé ne peut pas être téléchargé : un nom halluciné ou fraîchement squatté n'est donc jamais récupéré, et ses scripts d'installation ne s'exécutent jamais dans notre bac à sable. La suite de tests ne s'exécute pas non plus : la page d'exécution affiche « The change's dependencies could not be installed with the sandbox offline, so the suite never ran », et l'étape est enregistrée comme ignorée. Une étape ignorée n'enregistre aucun résultat de test et ne bloque donc pas à elle seule. Ce qui arrête le changement, c'est l'approbation humaine qu'il lui faut toujours, donnée par une personne qui voit qu'il n'a pas été testé.
Vous pouvez refuser entièrement les changements de dépendances venant des sessions. Une règle de politique de l'espace de travail sur l'action diff.apply est vérifiée pour chaque fichier que touche un changement au moment où sa pull request est ouverte, et un deny arrête la pull request. **/package.json exige une barre oblique avant le nom, si bien que le fichier racine a besoin de sa propre règle :
[
{ "id": "no-ai-root-manifest", "action": "diff.apply", "resource": "package.json", "decision": "deny" },
{ "id": "no-ai-nested-manifests", "action": "diff.apply", "resource": "**/package.json", "decision": "deny" },
{ "id": "no-ai-root-lockfile", "action": "diff.apply", "resource": "package-lock.json", "decision": "deny" }
]
C'est une règle stricte. Elle empêche aussi le workflow intégré Dependency Refresh de livrer ses mises à jour : réservez-la donc aux cas où vous voulez que ce soient des personnes, et non des sessions, qui ajoutent des paquets. Essayez-la d'abord en mode log-only pour voir à quelle fréquence elle se déclencherait. La page DevSecOps explique comment cela s'articule avec les constats, les SBOM et les contrôles de licences.
Checklist
- [ ] La CI installe depuis le lockfile (
npm ci, pip avec vérification des empreintes) et échoue en cas de divergence. - [ ] La CI utilise un seul registre, et les scripts d'installation sont désactivés là où les jobs n'en ont pas besoin.
- [ ] Chaque pull request qui ajoute une dépendance lance une vérification de l'existence, de l'âge et des téléchargements avant toute installation.
- [ ] Un audit des dépendances s'exécute comme vérification requise, et les constats de gravité élevée bloquent la fusion.
- [ ] Le diff des SBOM entre la base et la pull request est relu pour repérer les nouveaux composants et les nouvelles licences.
- [ ] Une personne approuve chaque nouvelle dépendance ajoutée par un agent, et sait dire qui la publie et pourquoi elle est nécessaire.
Le slopsquatting est une voie d'entrée dans votre arbre de dépendances, pas la seule. Un paquet réel et populaire peut être compromis par le vol du token de son mainteneur, et un agent peut choisir un paquet bien réel qui est tout simplement un mauvais choix. Le guide Qu'est-ce que la sécurité de la supply chain logicielle ? couvre les SBOM et la provenance de build, qui vous aident à répondre à « qu'avons-nous livré ? » une fois un mauvais paquet découvert.
À retenir
- Les modèles inventent des noms de paquets assez souvent pour que cela compte : au moins 5.2% pour les modèles commerciaux et 21.7% pour les modèles open source dans l'étude de Spracklen.
- Les agents de codage installent ce qu'ils importent : le risque se concrétise donc sur la machine qui exécute l'installation, avant que quiconque ne relise la pull request.
- Les lockfiles, un registre unique et des scripts d'installation désactivés réduisent la brèche, mais ne la referment pas.
- Recherchez chaque nouveau nom avant de l'installer : bloquez les noms qui n'existent pas, qui sont tout récents ou qui n'ont presque aucun téléchargement.
- Faites de l'audit des dépendances et de la vérification des nouvelles dépendances des vérifications requises, et gardez une personne sur chaque nouveau paquet.
Questions fréquentes
Qu'est-ce que le slopsquatting ?
Le slopsquatting consiste à enregistrer un paquet sous un nom que les modèles d'IA inventent. Quand un modèle ou un agent de codage suggère de nouveau ce nom inventé, quiconque l'installe récupère le code de l'attaquant.
En quoi le slopsquatting diffère-t-il du typosquatting ?
Le typosquatting attend qu'une personne fasse une faute de frappe dans le nom d'un vrai paquet. Le slopsquatting attend qu'un modèle produise un nom qui sonne juste mais n'a jamais été publié, si bien que personne n'a fait la moindre faute de frappe.
Un lockfile arrête-t-il le slopsquatting ?
En partie seulement. Un lockfile rend chaque nouvelle dépendance visible et empêche la CI de résoudre des noms que personne n'a consignés, mais un agent qui ajoute un paquet met généralement le lockfile à jour en même temps. Il vous faut quand même une vérification que le paquet existe et n'est pas tout récent.
Voir aussi
- Slopsquatting (paquets inventés par l'IA)
- Audit des dépendances
- Analyse de la composition logicielle (SCA)
- Qu'est-ce que la sécurité de la supply chain logicielle ?
- Revue de sécurité et suivi des SBOM pour le code écrit par l'IA
- Revue de code IA en 2026 : prix par utilisateur, crédit ou exécution
- Tous les articles du blog