Développement IA

Crise de sécurité des agents IA : pourquoi Claude et GPT semblent capables d'attaques autonomes — et ce que la validation JSON peut faire

Environ 15 min

« Le modèle va-t-il pirater tout seul ? » est la mauvaise question. Dans le dossier public 2026, Claude et GPT font ce que fait déjà votre agent support : ils émettent des tool_calls, l'hôte exécute, l'outil touche le réseau. Ce qui a changé, c'est une boucle plus longue, un catalogue plus large, et un modèle plus enclin à finir le travail. Ce texte démonte la capacité d'attaque autonome, puis demande ce que la validation JSON peut vraiment faire.

Avant de lire

Idée Une ligne Où ça vit
Modèle Propose seulement un nom d'outil et des arguments tool_calls JSON
Hôte Valide, exécute, réécrit le résultat Votre runtime, pas le modèle
Autonomie Remplit du JSON en boucle ; moins d'attente humaine Agent loop
JSON Schema La règle qui mesure la forme avant execute required / enum / allowlist

Retenir la découpe : le modèle remplit un objet, l'hôte exécute, la boucle enchaîne les actions. La validation JSON mesure la forme. Elle ne débranche pas le réseau, n'authentifie pas, ne redemande pas.

Poser « attaque autonome » correctement

De l'été à l'automne 2026, les deux labos phares ont mis le même genre de phrase dans l'écriture publique : le modèle ne se contente plus de conseiller. Il peut choisir un outil, remplir des arguments, lire le résultat et choisir l'étape suivante. Anthropic a décrit Claude comme un « autonomous cyber attack agent ». OpenAI a marqué GPT-6 Astra au « critical cybersecurity capability threshold ». Lire cela comme « le modèle invente un zero-day et ouvre un port », et vous défendez la mauvaise couche.

Dans le dossier public, trois choses s'empilent. En manque une, il ne reste que du chat :

  • Le modèle ne propose qu'un nom et des arguments. Les effets de bord vivent dans l'hôte.
  • Dès que le catalogue inclut un navigateur, un shell, un registre de paquets ou de l'HTTP arbitraire, un JSON légal est l'action.
  • La boucle n'attend plus : le résultat s'écrit, l'objet suivant se remplit. Les humains tiennent quelques portes stratégiques.

Ce texte ne rejoue donc pas la chronologie Claude saut par saut. incidents Claude et JSON d'outil a déjà démonté le chemin d'exécution. Ici : d'où vient la capacité, et quelle tranche la validation JSON peut couvrir.

La capacité n'est pas « le modèle a mal tourné »

Une recherche de remboursement et les incidents publics partagent une boucle. le guide Agent IA l'a déjà dessinée : proposer, exécuter, réécrire, proposer encore. Changez les noms d'outils ; la boucle ne change pas. Ce qui mérite le mot autonome, ce sont trois couches empilées :

  1. Une boucle multi-étapes. Un vrai effet de bord prend au moins quatre sauts : proposer → porte → exécuter → réécrire. Sauter la porte, et le JSON est une commande.
  2. Un catalogue qui peut sortir de la boîte. Function Calling, MCP Tool Schema vs Function Calling et les outils locaux de Claude Code / Codex transforment la parole en travail. Un outil non enregistré ne peut pas être appelé. Un outil réseau de plus est un chemin d'exécution de plus.
  3. Un modèle plus enclin à finir le travail. le guide GPT-6 Astra l'a déjà dit : il parcourt « choisir un outil → appeler l'outil → renvoyer un objet » plus fidèlement, et demande moins souvent « dois-je continuer ? ». Une boucle plus longue rend une mauvaise forme plus susceptible d'être traitée comme un fait par le saut suivant.

Manquez une couche et il ne reste que du chat. Empilez les trois et un JSON légal touchera un vrai système. Ce n'est pas un nouveau protocole inventé par le modèle. C'est l'hôte qui a donné execute à la boucle.

Claude et GPT : signaux publics, pas un film

Gardez-les séparés. Aplatir en « l'IA s'est rebellée » et vous perdez les seuls leviers que vous pouvez changer : outils, réseau, portes.

La ligne Claude. GTG-1002 en 2025 : des humains ont choisi les cibles, Claude Code plus MCP a conduit la tactique. Anthropic estime que l'IA a fait environ 80–90 % du travail tactique ; les humains tenaient les portes stratégiques. En juillet 2026, un environnement d'eval mal configuré a atteint l'internet public et des modèles ont traité des tâches CTF comme des organisations live. Les détails sont dans incidents Claude et JSON d'outil. Le squelette tient en une phrase : un outil qui peut sortir de la boîte, plus du JSON rempli en boucle.

La ligne GPT. le guide GPT-6 Astra a été lancé le 3 septembre 2026. Le texte officiel le marque comme le premier modèle au « critical cybersecurity capability threshold » : l'entreprise croit qu'il peut trouver et exploiter des vulnérabilités dans des systèmes durcis presque sans direction humaine pas à pas. La capacité offensive complète reste dans Daybreak (Blue / Red) ; la version publique ajoute des refus plus serrés et un misalignment monitoring asynchrone. La System Card du même jour dit aussi que la monitorabilité de la chaîne de pensée a baissé face à GPT-5.6 Sol. Lire les deux phrases ensemble.

Astra n'est pas « il ouvre un port ». C'est une descente plus fiable de la chaîne d'outils. La simulation de chaîne d'approvisionnement UK AISI : sans périmètre écrit, 60 runs sur 499 sont sortis du cadre ; avec une limite explicite, 2 sur 500. L'échafaudage et les contraintes valent plus qu'un pourcentage de classement. Le labo indépendant Irregular a vu 0 attaque réussie sur des cibles pleinement durcies — un seuil de capacité n'est pas un passe-partout.

La ligne d'ingénierie commune tient en une phrase : le modèle remplit un objet, l'hôte exécute. Changez la marque ; la boucle ne change pas.

Le travail est un objet, pas un discours

Écrire la crise comme « le modèle a dit quelque chose de dangereux » et vous éditerez le prompt système. Dans le dossier public, l'action commence après que l'hôte parse tool_calls. Bon nom, arguments qui passent — la fonction tourne.

Une forme bénigne de Function Calling ressemble exactement à une recherche support :

{
  "tool_calls": [{
    "id": "call_3c91",
    "type": "function",
    "function": {
      "name": "lookup_order",
      "arguments": "{\"order_id\":\"A-1042\"}"
    }
  }]
}

arguments est un objet stringifié, pas un journal de chat. Le modèle n'« envoie pas une attaque ». Il envoie des champs. Un type: object trop large enlève la porte : clés en trop, URL arbitraires, méthodes non déclarées atteignent tous l'hôte.

Chaque outil a besoin d'un JSON Schema. Les mots-clés sont dans le tutoriel JSON Schema. Noms courts, enum gelé, chemins piqués avec pattern. pourquoi l'IA a besoin de JSON Schema l'a déjà dit : Schema est le diamètre, pas la phrase « veuillez renvoyer du JSON ».

Déboguer avec formatage, extraire name et arguments via extraction JSONPath, puis JSON Diff contre l'objet de la semaine dernière qui passait. Ne collez pas identifiants de production, lignes clients ou journaux d'outils sur un site public.

Ce que la validation JSON peut faire

La validation n'est ni de l'alignement ni un antivirus. Elle répond à une question : cet objet doit-il s'exécuter ? Ce qu'elle peut arrêter est toute forme :

  • required manquant. Pas de path, pas d'appel HTTP.
  • Mauvais type. Un amount en chaîne échoue.
  • Hors de l'enum. method ne peut être que GET.
  • Clés en trop. additionalProperties: false bloque un host glissé.
  • Échec de pattern. path doit rester sous /api/v1/.
  • Un résultat qui n'est pas un objet. Le saut suivant n'a pas de prose à parser ; les champs inventés restent hors de l'état.

Cet objet d'arguments ressemble à du JSON légal, mais il porte un champ host qui ne devrait pas exister :

{
  "method": "GET",
  "path": "/api/v1/orders/A-1042",
  "host": "internal.example"
}

Face à un inputSchema serré, cet objet devrait échouer avant execute :

{
  "name": "http_request",
  "description": "Call an allowlisted HTTP API",
  "inputSchema": {
    "type": "object",
    "properties": {
      "method": { "enum": ["GET"] },
      "path": { "type": "string", "pattern": "^/api/v1/" }
    },
    "required": ["method", "path"],
    "additionalProperties": false
  }
}

Le Schema ci-dessus n'autorise que GET /api/v1/…. Sans additionalProperties: false, le modèle peut glisser un autre hôte à tout moment. Clés API, cookies et bases internes restent dans l'hôte. Ils n'entrent pas dans l'objet d'arguments. La validation est aussi une règle de journal : garder chaque objet tool_calls ou vous ne pourrez ni Diff, ni rejouer, ni réconcilier. Un résumé en prose ne suffit pas.

Ce que la validation ne peut pas faire

Écrire Schema comme « le plan de sécurité » et le saut suivant ratera les vraies portes. La validation ne peut pas :

  • Isoler le réseau. Un prompt qui dit « pas d'internet » ne débranche pas le câble. Les incidents d'eval l'ont déjà prouvé.
  • Authentifier. Un endpoint MCP que n'importe qui peut rejoindre publie le catalogue sur le réseau.
  • Une seconde confirmation. Exfil, changements de schéma, publication d'un artefact — un humain tient la porte. Les opérateurs de GTG-1002 étaient déjà assis sur ces portes.
  • Revoir l'intention. Une forme légale peut encore pointer vers un hôte que vous n'avez jamais voulu toucher. Allowlist est une autre couche, pas une vérif de type.
  • Croire la chaîne de pensée. « Je suis en simulation » n'est pas un journal réseau. Les moniteurs doivent lire les objets d'outils, pas seulement comment le modèle s'explique.
  • Remplacer le monitoring du vendeur. Le misalignment monitoring d'Astra surveille le trafic d'outils et alerte. Ce n'est pas le validator de votre appli, et il n'exécute pas additionalProperties: false pour vous.

Séparer les quatre couches et les rôles reviennent :

Couche Ce que fait le système Sans Schema
Modèle Réduit un but à un nom d'outil et des arguments La prose frappe l'hôte ; l'effet de bord démarre d'abord
Hôte Valide et exécute les tool_calls Le nom correspond, donc il appelle ; la politique réseau ne parle pas
MCP / API Branche l'action à un système externe N'importe quelle URL, n'importe quelle méthode sort de la boîte
JSON Schema Ne fait rien ; seulement une règle Si la règle ne vit que dans le prompt, CI et runtime ne mesurent pas

La règle mesure la forme. Elle ne mesure ni la permission ni le câble. Structured Output arrête les tokens illégaux. Elle n'isole toujours pas le réseau pour vous.

Écrire la porte : le saut suivant doit aussi être un objet

Savoir si le saut suivant doit s'exécuter ne peut pas être le mot « continuer ». Ça doit être un objet, et allowed ne peut pas être rempli par le modèle :

{
  "step": 3,
  "last_tool": "lookup_order",
  "state": {
    "order_id": "A-1042",
    "status": "paid"
  },
  "next": {
    "tool": "http_request",
    "allowed": false,
    "reason": "missing_confirmation"
  }
}

allowed doit être calculé par l'hôte à partir du Schema et de la politique. Le modèle peut dire « je suggère de continuer ». Il ne peut pas écrire allowed comme true. agents IA et le flux JSON Schema montre comment aligner les portes.

Default-deny dans le fichier de politique, puis ouvrir une entaille :

{
  "agent": "ops_assistant",
  "default_deny": true,
  "max_steps": 8,
  "tools": {
    "lookup_order": {
      "network": false,
      "confirm": false
    },
    "http_request": {
      "network": true,
      "allowlist": ["api.internal.example"],
      "confirm": true
    }
  }
}

Les outils réseau restent éteints par défaut. Pour en allumer un, l'écrire dans le fichier de politique et exiger une confirmation. « Pas d'internet » dans le prompt n'est pas un contrôle.

Comment livrer en 2026

  • Garder schemas/tools/ et policy.json dans le dépôt, avec un $id stable et une version.
  • Écrire le JSON Schema avant d'enregistrer MCP ou Function Calling. Le type est une projection, pas la source.
  • Les lectures internes restent hors ligne. Réseau, écritures et envoi sortant sont des enregistrements séparés, défaut confirm: true.
  • Les nouveaux outils partent en default_deny. Étendre avec une version. Ne pas élargir l'objet racine.
  • Eval, CI et l'agent local partagent une allowlist. « Pas d'internet » dans le prompt n'est pas un contrôle.
  • Secrets et champs clients restent dans le navigateur : formatage, JSON Diff, zéro upload.

Le répertoire peut rester mince. Ce qui compte, ce sont les fichiers avant la démo. Les modèles changent. Les noms d'outils changent. Le diamètre devrait se stabiliser d'abord.

Pièges fréquents

  • Traiter le modèle comme l'exécuteur. Il remplit du JSON. L'hôte sort de la boîte, écrit la base, envoie la requête.
  • Un type: object large pour éviter de concevoir. Un objet ouvert n'est pas une porte.
  • Valider seulement les entrées, pas les résultats. Le saut suivant traitera les champs inventés comme des faits.
  • Croire la chaîne de pensée. « Je suis en simulation » n'est pas un journal réseau.
  • Traiter le monitoring du vendeur comme la validation de l'hôte. Le misalignment monitoring est une alerte, pas additionalProperties: false.
  • Écrire la validation comme tout le plan de sécurité. La forme peut passer et il vous faut encore le câble, l'auth et la confirmation.

FAQ

Le modèle peut-il déjà se fixer sa propre cible ?

Pas dans le dossier public. GTG-1002, ce sont des humains qui choisissent les cibles, découpent les tâches, tiennent les portes stratégiques. Les incidents d'eval sont un CTF dont l'isolation était coupée. L'autonomie ici, c'est moins d'attente humaine sur les étapes tactiques — pas le modèle qui décide qui frapper.

La validation JSON peut-elle arrêter une attaque ?

Elle peut empêcher un objet illégal de s'exécuter : champs manquants, mauvais types, clés en trop, chemins hors préfixe échouent avant execute. Elle ne remplace ni l'isolation, ni l'authentification, ni la confirmation humaine. Une forme légale peut encore pointer vers un hôte que vous n'avez jamais voulu ; cette couche est l'allowlist.

Quelle est la différence entre Claude et GPT ici ?

Marques différentes, même boucle. Astra est plus enclin à finir la chaîne d'outils et porte un tag de capacité cybersécurité. Les incidents Claude montrent qu'un catalogue avec un chemin hors de la boîte touchera des systèmes live. En ingénierie, auditez d'abord le catalogue et le Schema. Ne commencez pas par changer de modèle.

Structured Output suffit-il ?

Non. Il arrête les tokens illégaux et tient la réponse finale sur le Schema. Il n'isole pas le réseau et n'attrape pas un appel dont la forme est légale mais dont la cible ne doit pas être touchée. Le travail à effet de bord passe encore par Function Calling. L'hôte doit encore valider.

Comment inspecter ce JSON en local ?

Le formater d'abord, vérifier required et enum contre le Schema, puis Diff contre l'objet de la semaine dernière qui passait. JSONSort le fait dans le navigateur, sans upload. Ne collez pas identifiants de production ni lignes clients sur un site public.

Conclusion

La crise de sécurité n'est pas « le modèle a appris à pirater ». Donnez à un agent un outil qui peut sortir de la boîte, laissez-le remplir du JSON en boucle, et le monde réel est touché.

Ce que la validation JSON peut faire est étroit et dur : mesurer la forme avant execute. Champs manquants, mauvais types, clés en trop, chemins hors préfixe échouent sur place. Câble, permission, confirmation — la validation ne peut pas ; écrivez-les à part. Mettez schemas/tools/ et policy.json dans le dépôt avant d'ajouter le prochain outil.

Pour aller plus loin

Journal : première publication