Aller au contenu
Hermes Codex

AAP-007 : RCE autonome en cascade

HASS

SCORE DE SÉCURITÉ AGENTIQUE HERMES & RISQUE

Cible : Agents Autonomes de Code, IDE Intelligents & Runtimes Hôtes Non Sandboxés
Confiance : 99%
96 / 100
EXTRÊME

Mesure le risque systémique spécifique découlant de l'autonomie, de l'autorité des outils et de l'exécution en cascade.

Décomposition des dimensions
Autonomie décisionnelle 19 / 20
Accès aux outils & APIs 19 / 20
Privilege 18 / 15
Persistence 15 / 15
External Impact 19 / 15
Propagation 16 / 15
⚖️ Divergence & Justification opérationnelle

Le HASS évalue AAP-007 à 96/100 (EXTRÊME). Contrairement à une exécution de code à distance web classique ponctuelle, la RCE en cascade exploite la boucle autonome de rétroaction de l'agent : lorsqu'une commande est bloquée ou échoue, l'agent réfléchit et élabore de nouvelles syntaxes d'évasion jusqu'à parvenir à un accès total à l'hôte.

🕸️ Graphe de Connaissances & Renseignement Associé

AAP-007: Autonomous Cascading RCEMODÈLE D'ATTAQUE

Nœuds connectés : 22
Associations entrantes
CVE-2026-22708: Cursor IDE Terminal Allowlist Bypass via Shell Built-insVULNÉRABILITÉ → leads_to → [Cette entité]
95% VERY_HIGH
CVE-2026-41264: LangChain / LangGraph Agent Loop RCEVULNÉRABILITÉ → leads_to → [Cette entité]
94% VERY_HIGH
CVE-2026-27966: Langflow CSV Agent Hardcoded Dangerous Code Execution RCEVULNÉRABILITÉ → leads_to → [Cette entité]
98% VERY_HIGH
CVE-2025-53773: GitHub Copilot RCE via Settings HijackingVULNÉRABILITÉ → leads_to → [Cette entité]
96% VERY_HIGH
95% VERY_HIGH
92% VERY_HIGH
92% VERY_HIGH
92% VERY_HIGH
92% VERY_HIGH
CVE-2026-27966: Langflow CSV Agent Hardcoded Dangerous Code Execution RCEVULNÉRABILITÉ → exploits → [Cette entité]
92% VERY_HIGH
92% VERY_HIGH
CVE-2026-33873: Langflow Agentic Assistant Dynamic Execution Sink RCEVULNÉRABILITÉ → exploits → [Cette entité]
92% VERY_HIGH
92% VERY_HIGH
92% VERY_HIGH
92% VERY_HIGH
AgentPoison: Red-teaming LLM Agents via Memory and Knowledge Base PoisoningÉTUDE DE RECHERCHE → evaluates → [Cette entité]
95% VERY_HIGH
95% VERY_HIGH
95% VERY_HIGH
AgentThreat StudioTOOL → evaluates → [Cette entité]
99% VERY_HIGH

1. Mécanisme architectural : escalade rétroactive autonome

Section intitulée « 1. Mécanisme architectural : escalade rétroactive autonome »

Lorsqu’un agent autonome dispose d’outils d’exécution de code (Bash, REPL Python, Docker) couplés à une boucle d’évaluation autonome, un attaquant peut initier une escalade récursive de privilèges :

[Charge Utile Adverse : "Corriger l'erreur de build en exécutant le script de test"]
                                │
                                ▼
         ┌───────────────────────────────────────────────┐
         │ Boucle de Planification Autonome (ReAct)      │
         └───────────────────────────────────────────────┘
                                │
                                ▼ (Étape 1 : Tentative directe curl vers bash)
                    [Filtre / Sandbox bloque la commande]
                                │
                                ▼ (Erreur retournée dans le contexte LLM)
[L'agent réfléchit : "Curl bloqué. Je vais créer un script Python encodé en base64"]
                                │
                                ▼ (Étape 2 : Synthèse d'évasion polymorphe)
              [Exécute la charge obfusquée sur l'hôte]
                                │
                                ▼
         [Reverse Shell Interactif Établi / Machine Hôte Compromise]

Les solutions traditionnelles de détection d’intrusion recherchent des signatures d’exploitation statiques. La RCE autonome en cascade déjoue ces défenses car l’agent synthétise dynamiquement des commandes polymorphes en réaction aux messages d’erreur retournés par le système.

2. Chaîne d’exécution de l’attaque

Section intitulée « 2. Chaîne d’exécution de l’attaque »
CHAÎNE D'EXÉCUTION

AAP-007 : échappement de Boucle ReAct vers un Shell Interactif Root

1
Amorçage Contextuel Dépôt de Code / Espace de Travail

L'adversaire place des consignes dans un Makefile ou un fichier de test invitant l'agent à exécuter des scripts de diagnostic.

2
Lancement de la Boucle Itérative Moteur de Boucle ReAct de l'Agent

L'agent commence à formuler et lancer des commandes shell successives pour analyser et résoudre l'anomalie simulée.

3
Adaptation et Contournement Environnement d'Exécution Hôte

Face aux blocages de mots-clés, l'agent adapte ses invocations via des interpréteurs alternatifs (python -c, perl, awk) pour neutraliser les filtres.

4
Compromission Totale de l'Hôte Infrastructure de Command & Control Adverse

L'agent établit une liaison réseau sortante TCP persistante, offrant un shell root interactif à l'attaquant.

3. Ingénierie de détection

Section intitulée « 3. Ingénierie de détection »
title: Agent Autonome Générant un Shell Interactif Inverse
id: f135a678-9667-7fe2-ab36-5326ae600007
status: experimental
description: Détecte les processus enfants d'un runtime d'agent instanciant des shells interactifs couplés à des sockets réseau sortantes.
author: Hermes Codex Research Team
date: 2026-09-07
logsource:
  category: process_creation
  product: linux
detection:
  selection:
    ParentImage|endswith:
      - "cursor"
      - "node"
      - "python"
      - "theia"
    Image|endswith:
      - "/bin/bash"
      - "/bin/sh"
      - "/bin/zsh"
    CommandLine|contains:
      - "/dev/tcp/"
      - "nc -e"
      - "mkfifo"
      - "pty.spawn"
      - "socket.connect"
  condition: selection
fields:
  - ParentImage
  - Image
  - CommandLine
  - User
level: critical
tags:
  - attack.execution
  - attack.t1059.004

4. Mesures de durcissement

Section intitulée « 4. Mesures de durcissement »
  1. Bac à sable éphémère au niveau noyau : exécuter tous les processus générés par l’agent dans des conteneurs sans privilèges (rootless) avec les espaces de noms réseau totalement désactivés par défaut.
  2. Confirmation humaine pour les sockets réseau : interdire formellement toute création de socket réseau sortante (socket.connect, /dev/tcp, nc) sans validation explicite d’un opérateur.
  3. Plafond d’itérations de boucle : fixer un nombre maximal strict d’itérations pour interrompre prématurément les séquences suspectes d’essais-erreurs avant la réussite de l’évasion.