AI Developer Tools Supply Chain Attack in 2026: codexui-android, TrapDoor & How to Protect Your AI Coding StackAttaque Supply Chain sur les Outils IA Développeurs en 2026 : codexui-android, TrapDoor & Comment Protéger Votre Stack IA

In May and June 2026, three separate supply chain campaigns demonstrated a new attack pattern: malicious npm packages and broader cross-ecosystem payloads are now specifically targeting the credential files of AI developer tools. The codexui-android npm package — with 29,000 weekly downloads — silently exfiltrated OpenAI Codex OAuth refresh tokens for over 30 days before detection. The TrapDoor campaign planted invisible instructions hidden inside CLAUDE.md and .cursorrules files to trick AI coding assistants into performing credential exfiltration themselves. A third package, mouse5212-super-formatter, recursively uploaded the entire Claude AI user directory to an attacker-controlled GitHub repository. The message is clear: every tool in your AI coding stack is now a target.

En mai et juin 2026, trois campagnes supply chain distinctes ont démontré un nouveau pattern d’attaque : des packages npm malveillants et des payloads cross-écosystème ciblent désormais spécifiquement les fichiers de credentials des outils IA développeurs. Le package npm codexui-android — avec 29 000 téléchargements hebdomadaires — a exfiltré silencieusement des tokens OAuth OpenAI Codex pendant plus de 30 jours avant d’être détecté. La campagne TrapDoor a planté des instructions invisibles cachées dans des fichiers CLAUDE.md et .cursorrules pour tromper les assistants IA en leur faisant eux-mêmes exfiltrer des credentials. Un troisième package, mouse5212-super-formatter, a téléchargé récursivement tout le répertoire utilisateur Claude AI vers un dépôt GitHub contrôlé par l’attaquant. Le message est clair : chaque outil de votre stack IA de développement est désormais une cible.

codexui-android: The Sleeping Thief That Stole OpenAI Codex Tokens for 30+ Days

codexui-android : Le Voleur Dormant Qui a Dérobé des Tokens Codex Pendant 30+ Jours

On May 27, 2026, Aikido Security researcher Charlie Eriksen disclosed that the npm package codexui-android — published as a remote web UI for OpenAI Codex — had been silently exfiltrating developers’ Codex authentication tokens for over a month. The package had 29,000 weekly downloads on npm, an active GitHub repository, and accompanying Android applications with more than 60,000 combined installations. Nothing in the public source code raised an alarm: the GitHub repository was entirely clean.

Le 27 mai 2026, le chercheur en sécurité Charlie Eriksen d’Aikido Security a divulgué que le package npm codexui-android — publié comme une interface web distante pour OpenAI Codex — exfiltrait silencieusement les tokens d’authentification Codex des développeurs depuis plus d’un mois. Le package comptait 29 000 téléchargements hebdomadaires sur npm, un dépôt GitHub actif et des applications Android avec plus de 60 000 installations combinées. Rien dans le code source public ne tirait la sonnette d’alarme : le dépôt GitHub était entièrement propre.

The attack used a trust-building delay: for its first month of existence, the package behaved exactly as advertised. Then, starting with version 0.1.82, the attacker embedded exfiltration code directly into the distributed npm tarball — code that did not appear in the public GitHub repository. Every time a developer imported the package, the malicious code read the contents of ~/.codex/auth.json and HTTP-POSTed the entire OAuth blob to the attacker-controlled endpoint sentry.anyclaw.store. The C2 domain was registered on April 12, 2026, just two days after the first npm version (0.1.72) went live — evidence of careful pre-attack infrastructure preparation.

L’attaque utilisait un délai de construction de confiance : pendant son premier mois d’existence, le package fonctionnait exactement comme prévu. Puis, à partir de la version 0.1.82, l’attaquant a intégré du code d’exfiltration directement dans l’archive npm distribuée — du code qui n’apparaissait pas dans le dépôt GitHub public. À chaque import du package par un développeur, le code malveillant lisait le contenu de ~/.codex/auth.json et envoyait en HTTP POST l’intégralité du blob OAuth au point de terminaison contrôlé par l’attaquant sentry.anyclaw.store. Le domaine C2 avait été enregistré le 12 avril 2026, deux jours seulement après la première version npm (0.1.72) — preuve d’une préparation soignée de l’infrastructure avant l’attaque.

The stolen data had one critical property that made this attack particularly dangerous: the ~/.codex/auth.json file contains an OAuth refresh_token that never expires. Unlike access tokens (which typically expire after an hour), a refresh token allows an attacker to mint new access tokens indefinitely, silently, without ever touching the victim’s machine again. If you installed any version of codexui-android from 0.1.82 onwards, your OpenAI account remained permanently accessible to the attacker until you manually revoked your Codex OAuth session. The package also shipped as Android apps (“OpenClaw Codex Claude AI Agent” with 50,000+ downloads, and “Codex” with 10,000+) that ran the same exfiltration chain on mobile devices.

Les données volées avaient une propriété critique qui rendait cette attaque particulièrement dangereuse : le fichier ~/.codex/auth.json contient un refresh_token OAuth qui n’expire jamais. Contrairement aux tokens d’accès (qui expirent généralement après une heure), un refresh token permet à un attaquant de générer de nouveaux tokens d’accès indéfiniment, silencieusement, sans jamais retoucher à la machine de la victime. Si vous avez installé une version de codexui-android à partir de 0.1.82, votre compte OpenAI restait accessibles en permanence à l’attaquant jusqu’à ce que vous révoquiez manuellement votre session OAuth Codex. Le package existait aussi sous forme d’applications Android (« OpenClaw Codex Claude AI Agent » avec 50 000+ téléchargements et « Codex » avec 10 000+) qui exécutaient la même chaîne d’exfiltration sur appareils mobiles.

Attribution pointed to a threat actor operating under the npm username friuns (Igor Levochkin), the same identity active on GitHub and Google Play as BrutalStrike. This is not a sophisticated nation-state actor — it is an opportunistic developer-turned-attacker who identified that AI coding tool credential files are a high-value, underprotected target.

L’attribution pointait vers un acteur menaçant opérant sous le nom d’utilisateur npm friuns (Igor Levochkin), la même identité active sur GitHub et Google Play sous le nom de BrutalStrike. Il ne s’agit pas d’un acteur sophistiqué lié à un État — c’est un développeur opportuniste reconverti en attaquant qui a identifié que les fichiers de credentials des outils IA de développement sont une cible à haute valeur, sous-protégée.

TrapDoor: Poisoning CLAUDE.md and .cursorrules with Invisible Unicode Instructions

TrapDoor : Empoisonnement de CLAUDE.md et .cursorrules avec des Instructions Unicode Invisibles

The TrapDoor campaign, disclosed by Socket Research and first active on May 22, 2026, introduced an entirely novel attack class: rather than executing malicious code at install time, the packages planted poisoned AI context files into the developer’s project directory, then waited for the developer’s own AI coding assistant to execute the attack on their behalf. The campaign deployed 34 malicious packages across 384+ versions on three ecosystems: 21 on npm, 7 on PyPI, and 6 on Crates.io.

La campagne TrapDoor, divulguée par Socket Research et premièrement active le 22 mai 2026, a introduit une classe d’attaque entièrement nouvelle : plutôt qu’exécuter du code malveillant à l’installation, les packages plantaient des fichiers de contexte IA empoisonnés dans le répertoire de projet du développeur, puis attendaient que l’assistant IA de codage du développeur exécute l’attaque en son nom. La campagne a déployé 34 packages malveillants sur 384+ versions dans trois écosystèmes : 21 sur npm, 7 sur PyPI et 6 sur Crates.io.

The shared npm payload trap-core.js wrote two files to the project root upon installation: a poisoned .cursorrules (read by Cursor AI) and a poisoned CLAUDE.md (read by Claude Code). These files looked entirely routine to a human reviewer — containing standard project guidance like “Always run a security scan before committing” — but contained hidden instructions encoded using zero-width Unicode characters (U+200B zero-width space, U+200C zero-width non-joiner, U+200D zero-width joiner, U+FEFF mid-text byte order mark). These characters are completely invisible in any standard editor or terminal.

Le payload npm partagé trap-core.js écrivait deux fichiers à la racine du projet lors de l’installation : un .cursorrules empoisonné (lu par Cursor AI) et un CLAUDE.md empoisonné (lu par Claude Code). Ces fichiers paraissaient entièrement anodins pour un réviseur humain — contenant des consignes de projet standard comme « Toujours exécuter un scan de sécurité avant de committer » — mais contenaient des instructions cachées encodées via des caractères Unicode à largeur nulle (U+200B espace à largeur nulle, U+200C non-jointif à largeur nulle, U+200D jointif à largeur nulle, U+FEFF indicateur d’ordre des octets en milieu de texte). Ces caractères sont totalement invisibles dans tout éditeur ou terminal standard.

When the AI coding assistant processed the poisoned context file, it received hidden instructions to perform a “security scan” of the local environment — a scan that in reality sent SSH keys, cloud credentials, environment variables, GitHub tokens, and browser session data to an attacker-controlled exfiltration endpoint. The attack exploited the fundamental trust model of AI context files: developers grant their AI assistant broad read access to their project, and AI assistants follow instructions embedded in those files by design.

Quand l’assistant IA de codage traitait le fichier de contexte empoisonné, il recevait des instructions cachées pour exécuter un « scan de sécurité » de l’environnement local — un scan qui, en réalité, envoyait des clés SSH, des credentials cloud, des variables d’environnement, des tokens GitHub et des données de session de navigateur vers un point d’exfiltration contrôlé par l’attaquant. L’attaque exploitait le modèle de confiance fondamental des fichiers de contexte IA : les développeurs accordent à leur assistant IA un large accès en lecture à leur projet, et les assistants IA suivent par conception les instructions intégrées dans ces fichiers.

SlowMist described TrapDoor as one of 2026’s largest supply chain attacks due to its simultaneous cross-ecosystem reach. The packages impersonated development utilities commonly used in crypto, DeFi, Solana, and AI developer workflows — ecosystems where high-value credentials (crypto wallet keystores, exchange API keys, cloud infrastructure tokens) coexist with standard developer secrets on the same machine.

SlowMist a décrit TrapDoor comme l’une des plus grandes attaques supply chain de 2026 en raison de son envergure cross-écosystème simultanée. Les packages imitaient des utilitaires de développement couramment utilisés dans les workflows crypto, DeFi, Solana et IA — des écosystèmes où des credentials à haute valeur (keystores de wallets crypto, clés API d’échanges, tokens d’infrastructure cloud) coexistent avec les secrets de développeur standard sur la même machine.

Malware-Slop: When AI-Assisted Malware Targets the Claude User Directory

Malware-Slop : Quand le Malware Assisté par IA Cible le Répertoire Utilisateur Claude

On May 26–27, 2026, OX Security and The Hacker News reported on a third campaign: the npm package mouse5212-super-formatter (676 downloads), which used its postinstall hook to recursively upload every file from /mnt/user-data — the dedicated directory Claude AI uses for uploads and background outputs — to a threat actor-controlled GitHub repository. The package authenticated to GitHub either using a token found in the victim’s environment, or via a hardcoded fallback token; if the target repository did not exist, the package created it automatically.

Les 26 et 27 mai 2026, OX Security et The Hacker News ont rapporté une troisième campagne : le package npm mouse5212-super-formatter (676 téléchargements), qui utilisait son hook postinstall pour télécharger récursivement chaque fichier depuis /mnt/user-data — le répertoire dédié qu’utilise Claude AI pour les uploads et les sorties en arrière-plan — vers un dépôt GitHub contrôlé par l’acteur menaçant. Le package s’authentifiait à GitHub soit en utilisant un token trouvé dans l’environnement de la victime, soit via un token de secours codé en dur ; si le dépôt cible n’existait pas, le package le créait automatiquement.

The campaign was dubbed Malware-Slop because the attackers used AI to generate the malware but failed at basic operational security (OPSEC) : the package inadvertently leaked the attacker’s own GitHub private token in the package code, effectively revealing the exfiltration repository. The GitHub account was created on May 26, 2026 — a few hours before the first malicious version was uploaded to npm. Despite its low download count (676), the campaign illustrates that even small, low-effort attacks now specifically identify AI assistant credential files as primary targets.

La campagne a été surnommée Malware-Slop parce que les attaquants ont utilisé l’IA pour générer le malware mais ont échoué dans leur sécurité opérationnelle (OPSEC) de base : le package a involontairement fuité le propre token GitHub privé de l’attaquant dans le code, révélant efficacement le dépôt d’exfiltration. Le compte GitHub a été créé le 26 mai 2026 — quelques heures avant l’upload de la première version malveillante sur npm. Malgré son faible nombre de téléchargements (676), la campagne illustre que même les attaques petites et peu sophistiquées identifient désormais spécifiquement les fichiers de credentials des assistants IA comme cibles prioritaires.

Why AI Developer Tools Have Become Prime Supply Chain Targets in 2026

Pourquoi les Outils IA Développeurs Sont Devenus des Cibles Supply Chain Prioritaires en 2026

These three campaigns are not isolated incidents. They reflect a fundamental shift in attacker priorities. AI coding tools represent an exceptionally attractive attack surface for four reasons:

Ces trois campagnes ne sont pas des incidents isolés. Elles reflètent un changement fondamental dans les priorités des attaquants. Les outils de codage IA représentent une surface d’attaque exceptionnellement attractive pour quatre raisons :

1. Privileged access to credentials by design. AI coding assistants are intentionally granted broad read access to the developer’s entire project and local environment. They read .env files, ~/.ssh/, cloud configuration directories, and context files — exactly what attackers want to harvest. The same capability that makes them useful makes them valuable as attack vectors.

1. Accès privilégié aux credentials par conception. Les assistants IA de codage se voient intentionnellement accorder un large accès en lecture à l’intégralité du projet du développeur et à l’environnement local. Ils lisent les fichiers .env, ~/.ssh/, les répertoires de configuration cloud et les fichiers de contexte — exactement ce que les attaquants veulent récupérer. La même capacité qui les rend utiles les rend précieux comme vecteurs d’attaque.

2. High-value, long-lived tokens. AI tool authentication tokens (OpenAI Codex OAuth, Anthropic API keys, GitHub Copilot tokens) grant access to powerful APIs with real operational and financial impact. The codexui-android attack specifically targeted the refresh_token because it never expires — a stolen Codex token provides indefinite access to the victim’s OpenAI account.

2. Tokens à haute valeur, longue durée de vie. Les tokens d’authentification des outils IA (OAuth OpenAI Codex, clés API Anthropic, tokens GitHub Copilot) donnent accès à des APIs puissantes avec un impact opérationnel et financier réel. L’attaque codexui-android ciblait spécifiquement le refresh_token parce qu’il n’expire jamais — un token Codex volé fournit un accès indéfini au compte OpenAI de la victime.

3. Context files are inherently trusted and rarely audited. Developers commit CLAUDE.md, .cursorrules, and AGENTS.md to their repositories. Security teams do not typically scan these files for hidden Unicode characters or covert instructions. Unlike package.json scripts, which draw scrutiny, context files are treated as plain documentation.

3. Les fichiers de contexte sont intrinsèquement fiables et rarement audités. Les développeurs commitent CLAUDE.md, .cursorrules et AGENTS.md dans leurs dépôts. Les équipes de sécurité ne scannent généralement pas ces fichiers pour des caractères Unicode cachés ou des instructions covertès. Contrairement aux scripts package.json, qui attirent la scrutin, les fichiers de contexte sont traités comme de la simple documentation.

4. Rapid adoption creates a large unprotected population. OpenAI Codex, Claude Code, Cursor, Copilot, and Gemini CLI have collectively reached tens of millions of developer installations in 2025–2026. Most users have not considered that their AI tool’s credential files are a theft target — let alone that a malicious npm package could read and exfiltrate them silently.

4. L’adoption rapide crée une grande population non protégée. OpenAI Codex, Claude Code, Cursor, Copilot et Gemini CLI ont collectivement atteint des dizaines de millions d’installations de développeurs en 2025–2026. La plupart des utilisateurs n’ont pas considéré que les fichiers de credentials de leur outil IA sont une cible de vol — encore moins qu’un package npm malveillant pourrait les lire et les exfiltrer silencieusement.

The AI Credential Files Under Attack: A Complete Map

Les Fichiers de Credentials IA Ciblés : Une Cartographie Complète

Based on analysis of the three campaigns above, plus the Miasma and Phantom Gyp attacks covered in earlier articles, here is the current map of AI developer tool credential files being targeted by malicious supply chain packages in 2026:

Sur la base de l’analyse des trois campagnes ci-dessus, plus des attaques Miasma et Phantom Gyp couvertes dans des articles précédents, voici la cartographie actuelle des fichiers de credentials d’outils IA développeurs ciblés par des packages malveillants supply chain en 2026 :

• ~/.codex/auth.json — OpenAI Codex CLI OAuth tokens (targeted by codexui-android, Miasma)
• ~/.codex/auth.json — tokens OAuth OpenAI Codex CLI (ciblé par codexui-android, Miasma)
• ~/.claude/ — Claude Code configuration, session data, API credentials (targeted by Phantom Gyp Wave 2, Miasma, mouse5212-super-formatter)
• ~/.claude/ — configuration Claude Code, données de session, credentials API (ciblé par Phantom Gyp Vague 2, Miasma, mouse5212-super-formatter)
• /mnt/user-data/ — Claude AI web interface upload directory (targeted by mouse5212-super-formatter)
• /mnt/user-data/ — répertoire d’uploads de l’interface web Claude AI (ciblé par mouse5212-super-formatter)
• .cursorrules (project root) — Cursor AI context injection point (targeted by TrapDoor, Miasma)
• .cursorrules (racine du projet) — point d’injection de contexte Cursor AI (ciblé par TrapDoor, Miasma)
• CLAUDE.md (project root or ~/.claude/CLAUDE.md) — Claude Code global/project instructions, context injection (targeted by TrapDoor, Miasma, Check Point Research hooking CVE)
• CLAUDE.md (racine du projet ou ~/.claude/CLAUDE.md) — instructions globales/projet Claude Code, injection de contexte (ciblé par TrapDoor, Miasma, Check Point Research hooking CVE)
• AGENTS.md (project root) — GitHub Copilot agent instructions (targeted by Miasma-family payloads, CSA Agent Context Poisoning)
• AGENTS.md (racine du projet) — instructions agent GitHub Copilot (ciblé par les payloads famille Miasma, CSA Agent Context Poisoning)
• .gemini/ — Gemini CLI credentials and configuration (targeted by Phantom Gyp Wave 2)
• .gemini/ — credentials et configuration Gemini CLI (ciblé par Phantom Gyp Vague 2)
• ~/.config/github-copilot/ — GitHub Copilot authentication tokens (targeted by broader AI IDE attack campaigns)
• ~/.config/github-copilot/ — tokens d’authentification GitHub Copilot (ciblé par les campagnes d’attaques IDE IA plus larges)
• ~/.cursor/ — Cursor AI settings, API key storage (targeted by TrapDoor, Miasma)
• ~/.cursor/ — paramètres Cursor AI, stockage des clés API (ciblé par TrapDoor, Miasma)

Detection & Remediation: What to Do If You Installed Affected Packages

Détection & Remédiation : Quoi Faire si Vous Avez Installé des Packages Affectés

If you installed codexui-android:

Si vous avez installé codexui-android :

1. Immediately revoke your OpenAI Codex OAuth session via the OpenAI account dashboard → Connected apps → Revoke all Codex CLI sessions.
2. Révoquez immédiatement votre session OAuth OpenAI Codex via le dashboard du compte OpenAI → Applications connectées → Révoquer toutes les sessions Codex CLI.
3. Delete and regenerate any OpenAI API keys stored in your environment or CI/CD pipeline.
4. Supprimez et régénérez les clés API OpenAI stockées dans votre environnement ou pipeline CI/CD.
5. Check ~/.codex/auth.json — if it exists, delete it and re-authenticate after revoking the old session.
6. Vérifiez ~/.codex/auth.json — s’il existe, supprimez-le et re-authentifiez-vous après avoir révoqué l’ancienne session.
7. Audit OpenAI account usage logs for unexpected API calls between April 12 and May 27, 2026.
8. Auditez les journaux d’utilisation du compte OpenAI pour détecter des appels API inattendus entre le 12 avril et le 27 mai 2026.

If you may have installed TrapDoor-affected packages:

Si vous avez potentiellement installé des packages affectés par TrapDoor :

1. Scan your project directories for .cursorrules and CLAUDE.md files that were not authored by you. Check for zero-width Unicode characters using: cat -A .cursorrules | grep -P '[\x{200B}\x{200C}\x{200D}\x{FEFF}]' or use a hex editor to inspect the files byte by byte.
2. Scannez vos répertoires de projet pour des fichiers .cursorrules et CLAUDE.md que vous n’avez pas rédigés. Vérifiez la présence de caractères Unicode à largeur nulle avec : cat -A .cursorrules | grep -P '[\x{200B}\x{200C}\x{200D}\x{FEFF}]' ou utilisez un éditeur hexadécimal pour inspecter les fichiers octet par octet.
3. Rotate all SSH keys, cloud credentials, GitHub tokens, and environment variables that could have been accessed in affected project directories.
4. Faites pivoter toutes les clés SSH, credentials cloud, tokens GitHub et variables d’environnement qui auraient pu être accédés dans les répertoires de projet affectés.
5. Check your npm, PyPI, and Crates.io install logs for any packages with names matching development utilities that were not explicitly added by your team.
6. Vérifiez vos journaux d’installation npm, PyPI et Crates.io pour tout package dont le nom correspond à des utilitaires de développement qui n’ont pas été explicitement ajoutés par votre équipe.

General hardening for your AI coding stack:

Durcissement général pour votre stack de codage IA :

1. Pin npm packages to exact versions and enable lockfile integrity verification. Use npm ci in CI/CD instead of npm install. This prevents the “latest” version of a package from silently introducing malicious code.
2. Épinglez les packages npm sur des versions exactes et activez la vérification d’intégrité du lockfile. Utilisez npm ci en CI/CD plutôt que npm install. Cela empêche la dernière version d’un package d’introduire silencieusement du code malveillant.
3. Audit context files before letting AI tools process them. Treat CLAUDE.md, .cursorrules, and AGENTS.md as code, not documentation. Review them in a hex-aware editor when they arrive from external dependencies or cloned repositories.
4. Auditez les fichiers de contexte avant de laisser les outils IA les traiter. Traitez CLAUDE.md, .cursorrules et AGENTS.md comme du code, pas comme de la documentation. Examinez-les dans un éditeur conscient du hex lorsqu’ils proviennent de dépendances externes ou de dépôts clonés.
5. Restrict AI assistant file system scope. Configure your AI tool to only access specific project directories, not your entire home directory. For Claude Code, use ~/.claude/settings.json to restrict allowedDirectories.
6. Limitez la portée du système de fichiers de l’assistant IA. Configurez votre outil IA pour accéder uniquement aux répertoires de projet spécifiques, pas à l’intégralité de votre répertoire home. Pour Claude Code, utilisez ~/.claude/settings.json pour restreindre allowedDirectories.
7. Store AI tokens in a secrets manager, not on disk. Where possible, configure AI tools to use environment variables for authentication rather than persisting tokens in files like ~/.codex/auth.json. Rotate tokens regularly (ideally set expiry policies where the tool allows).
8. Stockez les tokens IA dans un gestionnaire de secrets, pas sur le disque. Dans la mesure du possible, configurez les outils IA pour utiliser des variables d’environnement pour l’authentification plutôt que de persister des tokens dans des fichiers comme ~/.codex/auth.json. Faites pivoter régulièrement les tokens (idéalement, définissez des politiques d’expiration là où l’outil le permet).
9. Use a dependency scanner that monitors published tarball content, not just GitHub source code. The codexui-android attack exploited the gap between a clean GitHub repository and a malicious npm tarball. Scanners that only check source repositories would miss this. Look for tools that verify tarball-vs-source consistency.
10. Utilisez un scanner de dépendances qui surveille le contenu des tarballs publiés, pas uniquement le code source GitHub. L’attaque codexui-android exploitait l’écart entre un dépôt GitHub propre et un tarball npm malveillant. Les scanners qui ne vérifient que les dépôts sources manqueraient cela. Cherchez des outils qui vérifient la cohérence tarball/source.
11. Run --ignore-scripts for untrusted packages. Note that this is no longer sufficient against Phantom Gyp (which bypasses --ignore-scripts via binding.gyp), but it still blocks the majority of supply chain attacks that rely on postinstall/preinstall hooks.
12. Utilisez --ignore-scripts pour les packages non fiables. Notez que cela n’est plus suffisant contre Phantom Gyp (qui contourne --ignore-scripts via binding.gyp), mais cela bloque toujours la majorité des attaques supply chain qui reposent sur des hooks postinstall/preinstall.

Quick Detection Script: Audit Your AI Credentials Directory

Script de Détection Rapide : Auditer Votre Répertoire de Credentials IA

Run this script to check for suspicious modifications to AI tool credential files on your developer machine:

Exécutez ce script pour détecter des modifications suspectes dans les fichiers de credentials des outils IA sur votre machine de développeur :

#!/bin/bash
# Audit AI developer tool credential files for suspicious access patterns
# Run on developer machines after installing untrusted npm/PyPI/Crates packages

AI_CRED_FILES=(
  "$HOME/.codex/auth.json"
  "$HOME/.claude/credentials"
  "$HOME/.claude/settings.json"
  "$HOME/.cursor/mutable_extension_state"
  "$HOME/.config/github-copilot/hosts.json"
  "$HOME/.gemini/credentials.json"
)

echo "=== AI Credential File Audit ==="
for f in "${AI_CRED_FILES[@]}"; do
  if [ -f "$f" ]; then
    ACCESSED=$(stat -c '%x' "$f" 2>/dev/null || stat -f '%Sa' "$f" 2>/dev/null)
    MODIFIED=$(stat -c '%y' "$f" 2>/dev/null || stat -f '%Sm' "$f" 2>/dev/null)
    echo "EXISTS: $f"
    echo "  Last accessed: $ACCESSED"
    echo "  Last modified: $MODIFIED"
  else
    echo "NOT FOUND: $f"
  fi
done

echo ""
echo "=== Context File Unicode Check ==="
for ctxfile in ".cursorrules" "CLAUDE.md" "AGENTS.md"; do
  if [ -f "$ctxfile" ]; then
    HIDDEN=$(grep -cP '[\x{200B}\x{200C}\x{200D}\x{FEFF}]' "$ctxfile" 2>/dev/null || echo 0)
    echo "$ctxfile: hidden Unicode chars = $HIDDEN"
    if [ "$HIDDEN" -gt 0 ]; then
      echo "  WARNING: Possible TrapDoor-style payload detected!"
    fi
  fi
done

Frequently Asked Questions

Questions Fréquentes