Phase de design

Audit création agents IA — Risques architecturaux

Tool use validation, escalade de privilèges, memory poisoning, orchestration non contrainte. Comment concevoir un agent autonome sécurisé ? Quels patterns éviter ? Les quatre risques critiques en phase de design.

Les agents LLM (Claude avec tools, GPT-4 functions, LangChain, AutoGen) donnent à un modèle langage la capacité d'exécuter du code, d'appeler des APIs, de lire des fichiers, de modifier une base. Si l'architecture n'est pas sécurisée dès le départ, l'agent peut escalader ses privilèges, accéder à des ressources interdites, ou contourner ses propres garde-fous.

Cet audit couvre la phase de conception : comment valider avant exécution, comment isoler les contextes, comment constrainer l'orchestration pour éviter que tout déraille.

OWASP LLM08 · MITRE ATLAS

Tool Use Validation

Critique
Le problème

L'agent génère un appel fonction. Si cet appel n'est pas validé avant exécution, l'agent peut invoquer des outils non autorisés, avec des paramètres malveillants, ou halluciner des fonctions qui n'existent pas.

Cas réels
  • Agent appelle outil sans permission
  • Injection SQL via paramètres non validés
  • Hallucination : fonction n'existe pas
  • Exécution directe sans checklist
Hallucination d'outils

Les LLM hallucinant sur ce qu'ils peuvent faire (même avec Anthropic Claude), validation stricte est essentielle. Pas de fallback sur "il a sûrement raison".

Remédiations
  • Whitelist stricte des fonctions
  • Validation schéma JSON
  • Type checking paramètres
  • Audit logging chaque invocation
Pattern vulnérable
tools = get_all_available_tools() # 50 outils ! response = claude.messages.create(tools=tools) # Pas de validation, exécution directe result = execute_tool_call(response.tool_use[0])
Pattern sécurisé : validation stricte
AUTHORIZED_TOOLS = {"read_file", "send_email"} for tool_call in response.tool_use: if tool_call.name not in AUTHORIZED_TOOLS: raise SecurityError(f"Tool not allowed: {tool_call.name}") # Valider params contre schéma params = validate_json_schema(tool_call.input, schema) # Audit log audit_log(f"Tool call: {tool_call.name}, params: {params}") # Exécuter result = execute(tool_call.name, params)
OWASP LLM08 · MITRE TACTICS

Escalade de privilèges

Critique
Définition

L'agent commence avec un accès restreint. Par manipulation du prompt ou hallucination, il se convainc qu'il a accès à des outils supplémentaires. Exemple : agent limité à "chat" hallucine qu'il peut appeler "delete_user_account" ou "modify_database".

Mécanismes
  • Hallucination de permission élevée
  • Chaîne requêtes contournant restrictions
  • Injection dans wrapper d'outils
  • Confusion entre contexte utilisateur
Least privilege en agents

Chaque agent doit avoir accès qu'aux outils strictement nécessaires. Pas de "on lui donne tout et on espère". Isolation par rôle/tenant.

Remédiations
  • Isoler par rôle / tenant
  • Permissions déclaratives & validées
  • Audit exhaustif chaque action
  • Human-in-the-loop actions irréversibles
Isolation par rôle : pattern sécurisé
TOOLS_BY_ROLE = { "support_agent": ["search_kb", "send_email"], "admin_agent": ["manage_users", "audit_logs"], "user_facing": ["chat", "ask_question"] } agent_tools = TOOLS_BY_ROLE[user_role] # L'agent ne peut JAMAIS appeler au-delà de cette liste # Validation stricte à chaque appel
OWASP LLM06/08 · Agent context

Memory Poisoning

Critique
Définition

L'agent stocke un contexte (historique conversation, données utilisateur, états). Attaquant injecte des données malveillantes dans ce contexte. Exemple : chat RAG stocke messages en DB → attaquant injecte doc malveillant → l'agent le traite comme contexte légitime → hallucine instructions d'attaque.

Vecteurs d'injection
  • Contexte utilisateur compromis
  • Historique conversation altéré
  • Documents RAG injectés
  • État d'agent DB manipulé
Différent de training poisoning

Training poisoning est une attaque sur le corpus d'entraînement. Memory poisoning affecte le contexte runtime de l'agent. Plus ciblée mais toujours critique.

Remédiations
  • Isolation contexte par utilisateur
  • Validation source contexte
  • Size limits (prev. bloat)
  • Expiration TTL (stale data)
Contexte sécurisé : isolation utilisateur
class AgentContext: def __init__(self, user_id): self.user_id = user_id self.messages = [] # Isolé par user self.max_size = 32 # Limite taille def add_message(self, source, content): # Valider la source if source not in TRUSTED_SOURCES: raise SecurityError("Untrusted source") # Ajouter avec validation contenu validated = sanitize(content) self.messages.append(validated)
OWASP LLM08/09 · Agent control flow

Orchestration non contrainte

Critique
Définition

L'agent itère librement : call outil → reçoit résultat → décide prochaine action. Aucune limite sur le nombre d'itérations, actions parallèles, dépendances outils. L'agent peut rentrer en boucle infinie, appeler le même outil 1000 fois, ou créer une chaîne d'appels dangereuse.

Cas réels
  • Boucle infinie → coûts API explosent
  • Chaîne appels non validée
  • Dépendances circulaires entre outils
  • Race conditions multi-threads
OWASP LLM09 : Overreliance

Confiance aveugle dans les décisions de l'agent sans supervision. C'est un choix architectural : autour-boucle ou boucle-fermée ?

Remédiations
  • Max iterations limit (ex: 5 appels)
  • Max tokens par action (prev. verbosity)
  • Timeout stricte par appel
  • Human-in-the-loop critiques
Orchestration contrainte : limites strictes
class ConstrainedAgent: def __init__(self): self.max_iterations = 5 self.max_tokens_per_call = 2000 self.call_timeout = 30 # seconds def run(self, user_message): iterations = 0 while iterations < self.max_iterations: iterations += 1 # LLM décide prochaine action action = self.llm_decide(user_message) # Exécuter avec timeout try: result = execute_with_timeout( action, timeout=self.call_timeout ) except TimeoutError: return "Action took too long, stopping" # Valider résultat avant feedback if len(result) > self.max_tokens_per_call: result = result[:self.max_tokens_per_call] return "Max iterations reached"

Audit architecture : Avant de déployer un agent : vérifiez tool validation, permissions par rôle, contraintes orchestration (max iterations, timeouts). Une faille architecturale est exponentiellement plus coûteuse à corriger en prod.

Testing : Fiches de test (checklist) pour chaque pattern sécurisé. Rejouer les scénarios d'attaque : hallucination outil, escalade privilège, poisoning contexte.

Audit complet : Consultez aussi les audits LLM (vulnérabilités modèle) et production (monitoring) pour une stratégie end-to-end.

← Retour accueil