Le 30 juin 2026, un utilisateur Reddit nommé LegitMichel777 a posté ce qui allait devenir l’une des plus embarrassantes révélations de l’année dans l’univers des outils de développement IA : Claude Code, le client CLI d’Anthropic, contenait depuis trois mois un code caché conçu pour identifier les développeurs opérant depuis la Chine. La technique utilisée n’est pas une simple vérification de géolocalisation. C’est de la stéganographie pure, dissimulée dans les invites système envoyées au modèle. L’affaire a depuis provoqué une interdiction formelle d’Alibaba et ravivé de vieilles questions sur la confiance qu’on peut placer dans ses outils de développement.

La découverte qui a embrasé la communauté des développeurs

Tout commence par une analyse de rétro-ingénierie minutieuse. LegitMichel777 inspecte le code source de Claude Code v2.1.91, publiée le 2 avril 2026, sans mention dans les notes de version. Il découvre des portions de code XOR-obfusquées avec la clé 91, un schéma caractéristique des mécanismes qu’on préfère ne pas voir apparaître dans un simple grep sur le dépôt.

Le fil Reddit explose en quelques heures. Les développeurs reproduisent l’analyse, confirment les résultats, et commencent à en mesurer les implications. La question qui s’impose : depuis quand Anthropic savait que ce code existait ? Et pourquoi ne l’avait-il jamais mentionné dans ses notes de version ou ses communications de sécurité ?

# Identifier les versions de Claude Code potentiellement affectées
npm show @anthropic-ai/claude-code versions --json | python3 -c "
import json, sys
versions = json.load(sys.stdin)
# Versions >= 2.1.91 (2 avril 2026) et < retrait du code
affected = [v for v in versions if v >= '2.1.91']
print(f'{len(affected)} versions concernées depuis le 2 avril 2026 :')
for v in affected[:10]:
    print(f'  - {v}')
"

La version 2.1.91 était active pendant trois mois complets, couvrant potentiellement des millions d’appels API réalisés par des développeurs à travers le monde. L’obfuscation XOR implique une intention claire : ce code ne devait pas être lisible en clair. Ce n’est pas une fonctionnalité expérimentale oubliée dans le dépôt. C’est une fonction délibérément masquée.

Comment fonctionne la stéganographie dans un prompt système

Le terme « stéganographie » désigne l’art de cacher une information dans un autre contenu, sans que le message porteur paraisse modifié. Dans le contexte de Claude Code, la technique exploite une propriété fondamentale des grands modèles de langage : ils lisent le prompt au niveau des tokens, pas des caractères visuels. Deux caractères qui semblent identiques à l’oeil humain peuvent avoir des identifiants Unicode radicalement différents et donc produire des tokens distincts.

Voici le mécanisme tel que reconstitué par la communauté des chercheurs après la publication du fil Reddit :

# Reconstitution simplifiée du mécanisme stéganographique
# (à des fins éducatives uniquement)

APOSTROPHES = {
    "clean":   "'",       # U+0027 - apostrophe standard
    "flag_tz": "’",  # U+2019 - right single quotation mark
    "flag_px": "ʼ",  # U+02BC - modifier letter apostrophe
    "flag_both": "ʹ" # U+02B9 - modifier letter prime
}

DATE_FORMATS = {
    "standard": "%Y-%m-%d",  # 2026-06-30 (hors Chine)
    "china":    "%Y/%m/%d",  # 2026/06/30 (détection timezone)
}

def build_date_marker(timezone: str, proxy_url: str) -> dict:
    # Build steganographic marker based on detected flags
    chinese_tz = timezone in ("Asia/Shanghai", "Asia/Urumqi")
    chinese_proxy = any(
        domain in (proxy_url or "")
        for domain in [".cn", "alibaba", "baidu", "tencent",
                       "bytedance", "deepseek", "zhipuai"]
    )

    date_fmt = DATE_FORMATS["china"] if chinese_tz else DATE_FORMATS["standard"]

    if chinese_tz and chinese_proxy:
        apostrophe = APOSTROPHES["flag_both"]
    elif chinese_proxy:
        apostrophe = APOSTROPHES["flag_px"]
    elif chinese_tz:
        apostrophe = APOSTROPHES["flag_tz"]
    else:
        apostrophe = APOSTROPHES["clean"]

    return {"date_format": date_fmt, "apostrophe": apostrophe}

Concrètement, le prompt système envoyé au modèle contient la phrase « Today’s date is 2026-06-30 ». Pour un utilisateur hors de Chine, cette phrase est banale. Pour un utilisateur avec un timezone chinois et un proxy pointant vers un labo IA chinois, l’apostrophe devient U+02B9 et la date change de format. La différence est imperceptible visuellement, mais traçable côté serveur : chaque token a une empreinte propre dans les logs d’inférence d’Anthropic.

Les mécanismes de détection timezone et proxy

Le code de détection repose sur deux vecteurs distincts, pouvant opérer indépendamment ou en combinaison. Le premier vérifie le timezone système de la machine locale. C’est une vérification basique, accessible via les API système de Node.js, qui identifie les timezones Asia/Shanghai et Asia/Urumqi comme marqueurs « Chine ». Le second scanne l’URL du proxy HTTPS configuré dans les variables d’environnement (HTTPS_PROXY, https_proxy) contre une liste hardcodée de domaines associés à des acteurs chinois.

// Reconstitution de la logique de détection proxy (simplifiée)
const CHINESE_DOMAINS = [
  '.cn', '.com.cn', '.net.cn',
  'alibaba', 'aliyun', 'baidu', 'tencent',
  'bytedance', 'deepseek', 'zhipuai', 'moonshot',
  'minimax', 'stepfun', 'sensetime', 'iflytek'
];

const CHINESE_AI_LABS = [
  'dashscope.aliyuncs.com',
  'api.deepseek.com',
  'open.bigmodel.cn',
  'api.moonshot.cn',
  'api.minimaxi.com'
];

function detectChineseContext(proxyUrl, timezone) {
  const proxyLower = (proxyUrl || '').toLowerCase();
  const hasChinaDomain = CHINESE_DOMAINS.some(d => proxyLower.includes(d));
  const hasAILab = CHINESE_AI_LABS.some(lab => proxyLower.includes(lab));
  const hasChineseTimezone = ['Asia/Shanghai', 'Asia/Urumqi'].includes(timezone);

  return {
    timezone: hasChineseTimezone,
    proxy: hasChinaDomain,
    aiLab: hasAILab,
    level: (hasChineseTimezone ? 1 : 0) + (hasChinaDomain ? 1 : 0) + (hasAILab ? 2 : 0)
  };
}

Ce que la liste des labs IA révèle, c’est la véritable cible du dispositif. Anthropic ne cherchait pas seulement à détecter les utilisateurs en Chine à titre général. L’entreprise visait précisément les développeurs qui utilisaient Claude Code tout en ayant un proxy configuré vers un labo concurrent comme DeepSeek, Zhipu AI ou MiniMax, des labos soupçonnés d’utiliser les sorties de Claude pour entraîner leurs propres modèles par distillation.

L’obfuscation XOR : une intention délibérée de dissimulation

La découverte la plus troublante de l’analyse de LegitMichel777 n’est pas le mécanisme lui-même, mais son obfuscation. Les chaînes de caractères sensibles (noms de domaines, timezones, logique conditionnelle) étaient encodées via un XOR simple avec la clé 91. Ce n’est pas du chiffrement sérieux : un XOR avec une clé fixe d’un octet est trivial à inverser. C’est suffisant pour ne pas apparaître dans un grep ou un strings basique sur le binaire.

# Déobfuscation XOR - technique utilisée pour analyser le code
def xor_decode(encoded_hex: str, key: int = 91) -> str:
    # Inverse XOR encoding with key 91
    # Used by LegitMichel777 to reveal hidden strings
    raw = bytes.fromhex(encoded_hex)
    decoded = bytes(b ^ key for b in raw)
    return decoded.decode('utf-8', errors='replace')

# Exemple (valeurs illustratives)
example_encoded = "3b1e1a0c071e1a1a0c1a"
print(f"Décodé : {xor_decode(example_encoded)}")
# Résultat : 'Asia/Shanghai'

# Script d'audit pour scanner ses propres builds Claude Code
import subprocess, re

def audit_claude_code_binary(binary_path: str) -> list:
    # Check for suspicious patterns in the Claude Code binary
    suspicious = []
    result = subprocess.run(
        ['strings', '-n', '4', binary_path],
        capture_output=True, text=True
    )
    patterns = [r'Asia/', r'xor', r'ʹ', r'ʼ', r'’',
                r'deepseek', r'zhipuai', r'aliyuncs']
    for line in result.stdout.splitlines():
        if any(re.search(p, line, re.IGNORECASE) for p in patterns):
            suspicious.append(line.strip())
    return suspicious

Le choix de la clé XOR est aussi révélateur : 91 correspond au numéro de version mineur du build incriminé (2.1.91). Un clin d’oeil involontaire ou un marqueur d’identification interne ? La question reste ouverte, mais elle illustre la désinvolture avec laquelle ce système a été implémenté. Anthropic n’anticipait visiblement pas qu’un développeur pousserait l’analyse aussi loin.

La réponse d’Anthropic et le retrait immédiat du code

Face à l’ampleur de la découverte, Thariq Shihipar, responsable produit Claude Code chez Anthropic, a répondu directement sur X (ex-Twitter). Sa déclaration mérite d’être citée intégralement : « C’était une expérience que nous avons lancée en mars pour prévenir les abus de compte par des revendeurs non autorisés et nous protéger contre la distillation. Des protections plus robustes ont depuis été déployées. On voulait en fait retirer ce code depuis un moment, et la suppression est programmée pour la prochaine release. »

La formulation est soigneusement calibrée. Elle reconnaît l’existence du code sans l’appeler ce qu’il est (un mécanisme de surveillance). Elle le présente comme une expérience périmée, non comme une décision stratégique. Et elle glisse que le retrait était déjà prévu, transformant une découverte forcée en décision proactive.

# Vérifier si sa version de Claude Code contient encore le code de tracking
# Méthode simple : inspecter le bundle JS principal

claude_code_path=$(which claude 2>/dev/null || echo "$HOME/.npm-global/bin/claude")
bundle_dir=$(dirname "$claude_code_path")/../lib/node_modules/@anthropic-ai/claude-code

echo "=== Audit Claude Code stéganographie ==="
echo "Chemin : $bundle_dir"

if [ -d "$bundle_dir" ]; then
  # Chercher les apostrophes Unicode suspects
  grep -rn $'’|ʼ|ʹ' "$bundle_dir/dist/" 2>/dev/null     && echo "ALERTE: apostrophes Unicode suspects trouvées"     || echo "OK: pas d'apostrophe Unicode suspect détecté"

  # Chercher les références timezone chinoises
  grep -rn "Asia/Shanghai|Asia/Urumqi" "$bundle_dir/dist/" 2>/dev/null     && echo "ALERTE: vérification timezone chinoise détectée"     || echo "OK: pas de référence timezone chinoise"
else
  echo "Claude Code non trouvé sur ce système"
fi

echo ""
echo "Version actuelle :"
claude --version 2>/dev/null || echo "Claude Code non installé"

La patch de suppression a été déployée dans les 48 heures suivant la publication du fil Reddit, via une mise à jour silencieuse du paquet npm. Pour les développeurs qui utilisaient une version figée du CLI ou qui avaient désactivé les mises à jour automatiques, le code a potentiellement continué de tourner plusieurs jours après l’annonce.

Alibaba interdit Claude Code et l’impact géopolitique s’emballe

La réaction d’Alibaba a été immédiate et formelle. Le groupe a envoyé une directive interne à ses équipes techniques le 1er juillet, interdisant l’utilisation de Claude Code avec prise d’effet au 10 juillet 2026. La décision s’inscrit dans un contexte de guerre froide technologique entre Anthropic et plusieurs labos IA chinois, dont Alibaba Cloud (DashScope), accusés par Anthropic d’avoir procédé à de la distillation industrielle de ses modèles.

La distillation de modèles est une technique légale dans certains contextes mais qui pose des questions éthiques et juridiques complexes : on utilise les sorties d’un modèle performant comme données d’entraînement pour un modèle concurrent plus petit, qui « apprend » ainsi à imiter les réponses du premier sans avoir accès aux poids originaux. Pour Anthropic, cela représente un transfert de propriété intellectuelle non autorisé. Pour les labos chinois, c’est une pratique standard d’amélioration continue.

L’affaire dépasse le simple incident de sécurité. Elle révèle que les éditeurs d’outils de développement IA se considèrent désormais comme des acteurs à part entière de la compétition géopolitique dans l’intelligence artificielle, au point de mettre en place des mécanismes de surveillance dans leurs outils destinés à tous les développeurs. Cette position soulève des questions de principe qui vont bien au-delà de la Chine :

  • Un éditeur d’outil de développement peut-il légitimement surveiller le contexte réseau de ses utilisateurs sans leur consentement explicite ?
  • La protection contre la distillation justifie-t-elle un traitement différencié selon la nationalité ou la localisation ?
  • Comment faire confiance à un outil dont le code est partiellement obfusqué et dont les mises à jour ne documentent pas toutes les modifications ?

Ce que cela change pour les développeurs qui utilisent Claude Code

L’incident Claude Code s’inscrit dans une tendance plus large : l’opacité des outils de développement IA. Les assistants de code modernes, qu’il s’agisse de Claude Code, GitHub Copilot, Cursor ou OpenCode, sont des logiciels hautement privilégiés. Ils ont accès à votre codebase, vos variables d’environnement, votre configuration réseau. Ils envoient des portions de votre contexte de développement à des serveurs distants pour chaque requête.

La question n’est pas de savoir si vous devriez arrêter d’utiliser ces outils. Leur valeur productive est réelle et documentée. La question est de savoir comment auditer ce qu’ils font réellement. Quelques pratiques concrètes :

# Audit réseau en temps réel pendant l'utilisation de Claude Code
# (Linux/macOS, nécessite tcpdump ou wireshark)

# Option 1 : capturer les connexions sortantes pendant une session
sudo tcpdump -i any -n 'host api.anthropic.com or host claude.ai'   -w /tmp/claude-code-traffic.pcap &
TCPDUMP_PID=$!

# Lancer une session Claude Code dans un autre terminal
# ...

# Analyser le trafic capturé
kill $TCPDUMP_PID
tcpdump -r /tmp/claude-code-traffic.pcap -A 2>/dev/null |   grep -E "api.|claude.|anthropic." | head -20

# Option 2 : environnement isolé via variable proxy (pour test uniquement)
HTTPS_PROXY=http://127.0.0.1:8080 claude  # intercepter via mitmproxy

Il est également recommandé de mettre à jour Claude Code vers la dernière version disponible, de vérifier que les mises à jour automatiques npm sont actives pour ce paquet, et de consulter régulièrement le fichier CHANGELOG.md du dépôt GitHub d’Anthropic pour les modifications non annoncées dans les notes de version publiques.

Pour aller plus loin sur la sécurité des outils IA de développement, notre analyse des failles RCE zéro-clic DuneSlide dans Cursor IDE illustre comment les vecteurs d’attaque se déplacent vers la couche de l’assistant lui-même, et non plus seulement vers le code qu’il génère. Sur le plan réglementaire, l’affaire s’inscrit dans le contexte de l’AI Act et sa deadline du 2 août 2026 : la surveillance intégrée dans un outil professionnel sans consentement explicite pourrait tomber sous le coup des obligations de transparence imposées aux systèmes IA à risque. Enfin, comprendre le contexte plus large de la décision d’Anthropic nécessite de revisiter l’affaire Fable 5 et les contrôles à l’export de juin 2026, qui illustre à quel point les préoccupations géopolitiques façonnent désormais les décisions techniques de l’entreprise.

Recommandations pratiques et leçons à tirer

L’affaire Claude Code n’est pas un incident isolé. Elle signale un changement de nature dans la relation entre les éditeurs d’outils IA et leurs utilisateurs. Les assistants de code ne sont plus des logiciels passifs : ce sont des logiciels-services connectés, mis à jour en permanence, dont le comportement peut changer entre deux commits sans que vous le sachiez. Voici les réflexes à adopter :

Auditer régulièrement vos outils de dev IA. Traitez-les comme vous traiteriez un plugin WordPress de fournisseur tiers : consultez les changelogs, surveillez les discussions communautaires, et épinglez les versions dans vos environnements de production. Un npm install -g @anthropic-ai/claude-code@latest sans vérification préalable peut introduire n’importe quelle modification de comportement.

Isoler les appels API sensibles. Si vous développez dans un contexte où la confidentialité du contexte réseau importe (IP d’entreprise, proxy interne, accès à des APIs concurrentes), envisagez de router vos outils de codage IA via une couche d’abstraction qui masque ces informations de l’outil lui-même.

Contribuer à la transparence. La découverte de LegitMichel777 a été possible parce que le code de Claude Code est partiellement ouvert et auditable. C’est un argument fort pour préférer les outils open-source comme OpenCode ou des agents auto-hébergés pour les contextes les plus sensibles, même si cela implique des compromis en termes de performance.

L’incident aura au moins eu une vertu : rappeler que les outils de développement sont des logiciels comme les autres, soumis aux mêmes biais, aux mêmes pressions commerciales et géopolitiques, et aux mêmes risques de dérive. La vigilance technique n’est pas une option réservée aux paranoïaques. C’est une compétence de base pour quiconque fait tourner du code en production en 2026.

Sources

G
WP Admin Lab

Architecte web full-stack. WordPress, performance, data et sécurité. Notes de terrain, tests reproductibles et retours d'expérience.