Sécurisation du déploiement de LLM / Agent

L’injection de prompt (OWASP LLM01:2025) est un risque réel et avéré. Pour un agent, l’enjeu dépasse la sortie textuelle : une donnée malveillante lue par l’agent (mail, page web, fichier, sortie d’outil) peut déclencher des actions — appels d’outils, exfiltration, modification d’état.

Cette note s’appuie principalement sur Beurer-Kellner et al., Design Patterns for Securing LLM Agents against Prompt Injections (2025, arXiv:2506.08837), travail commun d’Invariant Labs, IBM, EPFL, ETH Zurich, Google, Microsoft, Swisscom et Kyutai/Lakera.

Le constat de départ

« It is unlikely that general-purpose agents can provide meaningful and reliable safety guarantees. »

Les défenses au niveau du modèle (détection, entraînement adversarial) sont heuristiques : elles réduisent le taux de succès des attaques sans rien garantir. D’où le principe central de l’article :

Une fois qu’un agent a ingéré une donnée non fiable, il doit être contraint de sorte qu’il soit impossible pour cette donnée de déclencher une action conséquente.

Corollaire : on renonce à l’agent généraliste. Chaque pattern restreint volontairement ce que l’agent peut faire, et échange de l’utilité contre des garanties.

Défense en profondeur

L’article range les défenses existantes en trois niveaux. Elles se combinent : aucune ne suffit seule.

flowchart LR
    subgraph L1["Niveau LLM"]
        direction TB
        PE["Prompt engineering<br/>(délimiteurs, spotlighting)"]
        AT["Entraînement adversarial<br/>(StruQ, SecAlign, hiérarchie d'instructions)"]
    end
    subgraph L2["Niveau utilisateur"]
        direction TB
        CF["Confirmation des actions<br/>(risque de fatigue)"]
        AD["Attribution des données<br/>(montrer la source)"]
    end
    subgraph L3["Niveau système"]
        direction TB
        DET["Filtres input / output<br/>(classifieurs, guardrails)"]
        ISO["Isolation, moindre privilège,<br/>sandbox"]
        DP["Design patterns<br/>(cette note)"]
    end
    L1 --> L2 --> L3
    style DP fill:#2b6,color:#fff
  • Niveau LLM : améliore la robustesse du modèle, aucune garantie.
  • Niveau utilisateur : efficace sur les actions visibles, mais demander une confirmation à chaque étape n’est pas tenable (fatigue, clics automatiques) et rate les attaques discrètes.
  • Niveau système : seul niveau qui peut donner des garanties, à condition de structurer l’agent autour de frontières de confiance explicites.

Bonnes pratiques transverses

À appliquer quel que soit le pattern retenu :

  • Sandboxing des actions et moindre privilège : l’agent n’a que les droits de l’utilisateur qu’il sert, et seulement les outils nécessaires.
  • Formatage strict des données : sorties contraintes (booléen, énumération, JSON validé par schéma) dès qu’elles franchissent une frontière.
  • Confirmation utilisateur réservée aux actions irréversibles ou sortantes.
  • Attribution : afficher d’où vient chaque information pour que l’utilisateur puisse juger.

Design patterns

Convention des schémas : en rouge, ce qui est non fiable (potentiellement contrôlé par l’attaquant).

Sélecteur d’actions (Action-Selector)

L’agent traduit la requête en une ou plusieurs actions prédéfinies. Aucune sortie d’action ne revient dans son contexte. L’article le décrit comme un « switch piloté par un LLM ».

flowchart LR
    U(["Requête utilisateur"]) --> A["Agent (LLM)"]
    A -- "choisit et paramètre" --> SEL{"Ensemble fini<br/>d'actions autorisées"}
    subgraph EXE["Exécution contrôlée"]
        A1["Action 1"]
        A2["Action 2"]
        An["Action n"]
    end
    SEL --> A1
    SEL --> A2
    SEL --> An
    D[("Données non fiables")] --> EXE
    A1 & A2 & An --> R(["Résultat vers l'utilisateur"])
    style D fill:#c33,color:#fff

Les actions sont :

  • atomiques
  • contrôlées
  • paramétrées
  • compatibles avec un recours humain

Ce que ça bloque : toute injection contenue dans les données traitées, puisque l’agent ne les lit jamais.

Limites :

  • L’utilité est plafonnée par la liste d’actions : c’est le goulot d’étranglement du pattern.
  • La requête utilisateur elle-même peut rester malveillante si l’utilisateur n’est pas de confiance.
  • Effort de conception : une analyse de risque sur chaque action permet d’éliminer celles qui se prêtent à un détournement.

Plan-Then-Execute

Le paradigme ReAct (Yao et al., 2022), très répandu, alterne raisonnement et appels d’outils : chaque sortie d’outil peut réorienter l’agent, donc une donnée malveillante peut le faire dérailler. Plan-Then-Execute fige le plan avant toute exposition à des données non fiables.

flowchart LR
    U(["Requête utilisateur"]) --> P["1 · LLM planifie<br/>avant toute donnée non fiable"]
    P --> PL["Plan figé<br/>(séquence d'outils)"]
    subgraph EXE["2 · Exécution"]
        direction LR
        T1["calendar.read(today)"] --> T2["email.write(…, john.doe@…)"]
    end
    PL --> T1
    T2 --> R(["Résultat"])
    D[("Contenu du calendrier")] -. "peut modifier le corps du mail,<br/>pas le destinataire ni les outils" .-> T2
    style D fill:#c33,color:#fff
  • Assure l’intégrité du flux de contrôle : une injection ne peut pas faire appeler un outil absent du plan.
  • Réduit la surface d’attaque.
  • Comportement prévisible et auditable.

Limites : n’empêche ni les injections dans la requête utilisateur, ni la manipulation des paramètres des outils (dans l’exemple, le corps du mail reste sous influence de l’attaquant).

⚠️ Penser au pire scénario si l’agent est détourné.

Méthode : commencer simple et penser aux cas d’erreur.

LLM Map-Reduce

Inspiré du MapReduce de Dean & Ghemawat (2008) : chaque donnée non fiable est traitée par un sous-agent isolé, puis les résultats sont agrégés.

flowchart TB
    subgraph MAP["MAP : un appel isolé par donnée non fiable"]
        direction LR
        D1(["Doc 1"]) --> L1["LLM isolé 1"] --> V1["Validation schéma"]
        D2(["Doc 2"]) --> L2["LLM isolé 2"] --> V2["Validation schéma"]
        Dn(["Doc n"]) --> Ln["LLM isolé n"] --> Vn["Validation schéma"]
    end
    V1 & V2 & Vn --> R["REDUCE<br/>(code déterministe ou LLM<br/>sur sorties contraintes)"]
    R --> O(["Résultat"])
    style D1 fill:#c33,color:#fff
    style D2 fill:#c33,color:#fff
    style Dn fill:#c33,color:#fff

Exemple de l’article : retrouver les factures parmi des fichiers et les envoyer par mail. Un LLM par fichier répond true / false ; seul le REDUCE envoie le mail.

  • Appels MAP : prompt système et instructions identiques, aucun outil.
  • Validation de schéma : sortie contrainte (booléen, énumération, regex, modèle Pydantic).
  • REDUCE : idéalement non-LLM ; sinon un LLM qui ne reçoit que les sorties validées.
  • Contrôle de délai pour lutter contre l’épuisement des ressources.
  • Isolation des erreurs : un appel qui échoue ou produit une sortie invalide est écarté sans bloquer les autres.

Ce que ça bloque : un document injecté ne contamine que son propre appel.

Limites : un fichier malveillant peut toujours se faire classer comme facture — mais l’attaquant obtiendrait le même effet en déposant une vraie facture.

Dual LLM

Proposé par Simon Willison (2023). Deux LLM aux rôles séparés, orchestrés par du code classique.

flowchart TB
    U(["Utilisateur"]) --> P["LLM privilégié<br/>(planifie, appelle les outils)"]
    P -- "instructions avec références $VAR1" --> C["Contrôleur (déterministe)<br/>stocke $VAR1, $VAR2…"]
    C -- "renvoie uniquement les noms $VAR" --> P
    D[("Données non fiables")] --> C
    C -- "données non fiables" --> Q["LLM quarantaine<br/>(aucun outil)"]
    Q -- "sortie stockée sous $VAR1" --> C
    C -- "substitue $VAR1 au moment de l'appel" --> T["Outils"]
    style D fill:#c33,color:#fff
    style Q fill:#f99
  • Le LLM privilégié ne voit jamais de donnée non fiable ; il ne manipule que des références symboliques et ne peut pas les déréférencer.
  • Le LLM quarantaine lit les données non fiables mais n’a aucun outil.
  • Le contrôleur fait la substitution au moment de l’appel d’outil.

Limites : le LLM quarantaine reste injectable. Sa sortie peut être contrôlée par l’attaquant, et s’il a reçu des données sensibles, il peut les encoder dans un contenu (par exemple un brouillon de réponse) qui sera ensuite envoyé. La frontière protège le flux de contrôle, pas le flux de données.

Code-Then-Execute

L’agent génère un programme complet capable d’appeler des outils, de gérer une logique de branchement complexe et d’appeler des LLM non privilégiés pour traiter du texte. Une fois écrit, il s’exécute de façon déterministe dans une sandbox. C’est une généralisation de Plan-Then-Execute (le plan devient du code), souvent combinée au Dual LLM.

flowchart LR
    U(["Requête utilisateur"]) --> P["LLM<br/>écrit le programme"]
    P --> CODE["Programme<br/>(boucles, conditions)"]
    subgraph SB["Sandbox"]
        CODE --> T["Outils"]
        CODE --> QL["LLM non privilégiés"]
        T --> CODE
        QL --> CODE
    end
    D[("Données non fiables")] --> T
    CODE --> R(["Résultat"])
    style D fill:#c33,color:#fff

Limites :

  • Suppose un LLM solide derrière l’agent.
  • Réduit la malléabilité : couper la boucle de rétroaction entre résultats et LLM coûte de l’utilité.
  • Comme Plan-Then-Execute, n’empêche pas l’influence sur les paramètres des outils ni la fuite de données via les sorties.

Extension : CaMeL

Debenedetti et al., Defeating Prompt Injections by Design (Google DeepMind / ETH Zurich, 2025, arXiv:2503.18813).

Les patterns précédents laissent ouvertes les attaques de flux de données : une entrée non fiable influe silencieusement sur les arguments des outils ou sur les données envoyées. CaMeL ajoute un contrôle de la donnée elle-même.

  • Interpréteur dédié d’un sous-ensemble de Python.
  • Chaque valeur porte des capacités : sa provenance et qui a le droit de la lire.
  • Un graphe des flux de données propage ces métadonnées à travers le programme.
  • Des politiques déclaratives sont vérifiées avant chaque appel d’outil (ex. « un document lu depuis le Drive ne peut être envoyé qu’à ses lecteurs autorisés »).
  • Repose sur le Dual LLM.
flowchart LR
    U(["Requête utilisateur"]) --> P["LLM privilégié<br/>(génère le code, ne voit jamais<br/>les données non fiables)"]
    P -- "programme" --> I["Interpréteur Python restreint"]
    I -- "texte non fiable à analyser" --> Q["LLM quarantaine<br/>(aucun outil)"]
    Q -- "valeurs structurées" --> I
    I --> G["Graphe des flux de données<br/>(provenance de chaque valeur)"]
    G --> POL{"Politiques déclaratives<br/>(avant chaque appel d'outil)"}
    POL -- autorisé --> T["Outils"]
    POL -- refusé --> X["Blocage ou<br/>confirmation utilisateur"]
    T -- "résultats marqués non fiables" --> I

Évalué sur le benchmark AgentDojo : sécurité prouvable sur la majorité des tâches, au prix d’une baisse d’utilité modérée par rapport à un agent non défendu.

Minimisation du contexte (Context-Minimization)

Retirer du contexte, une fois qu’il a servi, tout contenu non fiable — y compris la requête utilisateur.

flowchart LR
    U(["Requête utilisateur"]) --> L1["LLM<br/>traduit en requête BD"]
    L1 --> DB[("Base de données")]
    DB --> L2["LLM<br/>formule la réponse"]
    L2 --> R(["Réponse"])
    U -. "retirée du contexte" .-x L2
    style U fill:#c33,color:#fff

Exemple de l’article : un client demande un devis automobile ; sa demande devient une requête en base, puis est retirée avant que le LLM ne rédige la réponse à partir des résultats.

« Empêcher des instructions malveillantes passées de contaminer les décisions futures. »

À combiner avec :

  • Sélecteur d’actions
  • Plan-Then-Execute
  • Dual LLM

Limites : n’empêche pas la manipulation de l’étape de récupération elle-même.

Synthèse

PatternBloqueNe bloque pasCoût en utilité
Sélecteur d’actionsInjections via données et sorties d’outilsRequête utilisateur malveillanteÉlevé (actions figées)
Plan-Then-ExecuteAppel d’outils hors planManipulation des paramètresMoyen
Map-ReduceContamination entre documentsManipulation d’un document sur lui-mêmeFaible à moyen
Dual LLMDétournement du LLM privilégiéSortie du LLM quarantaine, exfiltration encodéeMoyen
Code-Then-ExecuteFlux de contrôle détournéFlux de données (sans CaMeL)Moyen
CaMeLFlux de contrôle et de données selon politiquesCe que les politiques n’expriment pasMoyen, plus la rédaction des politiques
Minimisation du contexteInjection persistante dans la conversationManipulation de la récupérationFaible

Choisir un pattern

Arbre indicatif, dérivé des études de cas de l’article :

flowchart TB
    S{"Les tâches sont-elles<br/>énumérables à l'avance ?"}
    S -- oui --> AS["Sélecteur d'actions"]
    S -- non --> N{"Données non fiables<br/>indépendantes entre elles ?"}
    N -- oui --> MR["Map-Reduce"]
    N -- non --> K{"Séquence d'outils<br/>connue avant lecture ?"}
    K -- oui --> PTE["Plan-Then-Execute"]
    K -- non --> DL["Dual LLM / Code-Then-Execute<br/>+ politiques de flux (CaMeL)"]
    AS & MR & PTE & DL --> CM["+ Minimisation du contexte<br/>si la requête utilisateur est non fiable"]

Études de cas de l’article

L’article applique les patterns à dix applications, en partant d’un design naïf pour aboutir à un design défendu :

ApplicationVecteur d’attaquePatterns retenus
Assistant OS (recherche floue de fichiers)Contenu et noms de fichiersMap-Reduce + contrôleur (Dual LLM)
Agent SQLRequête ou contenu de la baseCode-Then-Execute, Python en sandbox
Assistant mail et calendrierMails et invitations tiersPlan / Code-Then-Execute, Dual LLM, confirmation
Chatbot service clientRequête du clientClassifieur de sujet, Sélecteur d’actions, minimisation du contexte
Assistant de réservationUtilisateur, descriptions d’hôtels, événementsMoindre privilège, API calendrier restreinte, Dual LLM / Code-Then-Execute
Recommandation de produitsAvis clientsMap-Reduce (une injection reste confinée à son avis)
Tri de CVInstructions cachées dans les CVMap-Reduce, Dual LLM
Chatbot notice de médicamentsRequête utilisateurAttribution des données, minimisation du contexte
Diagnostic médical via LLMRequête patientMinimisation du contexte, formatage structuré des symptômes
Agent d’ingénierie logicielleDocumentation, paquets tiersDual LLM (doc convertie en API strictement formatée), sandbox

Recommandations finales de l’article :

  1. Privilégier des agents spécifiques à une application, avec des frontières de confiance définies.
  2. Combiner les patterns : aucun ne couvre seul tous les modèles de menace.

Rule of Two

Formulée par Meta (Agents Rule of Two, 2025), elle dérive de la « lethal trifecta » de Simon Willison : données privées, contenu non fiable, capacité de communication externe.

Trois propriétés d’un agent :

  • A : traiter des données non fiables
  • B : accéder à des systèmes ou données sensibles
  • C : changer d’état ou communiquer vers l’extérieur

Règle : sans supervision humaine, un agent cumule au plus deux des trois propriétés.

flowchart TB
    A["A · Traiter des données non fiables"]
    B["B · Accéder à des systèmes / données sensibles"]
    C["C · Changer d'état / communiquer"]
    A & B & C --> D["⚠️ Les trois réunies : DANGER"]
    D --> H["Supervision humaine obligatoire"]
    style D fill:#f66,color:#fff

Approche : étiqueter outils et données pour vérifier la règle à la conception.

  • Rouge : source de contenu non fiable (A)
  • Bleu : accès à un système ou une donnée sensible (B)
  • Action : outil qui modifie un état ou communique (C)

3 configurations sûres :

ConfigurationCombinaisonContrainte
Intelligence sans actionA + BAucune action externe
Action en isolementA + CAucun accès à des données sensibles, sandbox
Opérations de confianceB + CUniquement des données de confiance en entrée

Les design patterns sont des moyens concrets de respecter la règle : le Dual LLM retire A au LLM qui détient B + C ; Map-Reduce retire C aux sous-agents qui détiennent A.


État de l’art et outils

Références

  • Indirect prompt injection — Greshake et al., Not what you’ve signed up for, 2023 (arXiv:2302.12173). Article fondateur sur l’injection via données tierces.
  • Dual LLM — Simon Willison, The Dual LLM pattern for building AI assistants that can resist prompt injection, 2023 (simonwillison.net).
  • Lethal trifecta — Simon Willison, 2025 (simonwillison.net).
  • CaMeL — Debenedetti et al., 2025 (arXiv:2503.18813).
  • FIDES — Costa et al. (Microsoft), Securing AI Agents with Information-Flow Control, 2025 (arXiv:2505.23643). Contrôle de flux d’information par étiquettes de confidentialité et d’intégrité, dans la lignée de CaMeL.
  • Agents Rule of Two — Meta AI, 2025.
  • Spotlighting — Hines et al. (Microsoft), 2024 (arXiv:2403.14720). Marquer les données non fiables (délimiteurs, encodage) pour que le modèle les distingue des instructions.
  • Instruction hierarchy — Wallace et al. (OpenAI), 2024 (arXiv:2404.13208). Entraîner le modèle à prioriser système > utilisateur > outils.
  • StruQ — Chen et al., 2024 (arXiv:2402.06363) et SecAlign — Chen et al., 2024 (arXiv:2410.05451). Séparer instructions et données par entraînement.
  • Séparation instructions / données — Zverev et al., Can LLMs Separate Instructions From Data?, 2024 (arXiv:2403.06833).

Benchmarks

  • AgentDojo — Debenedetti et al., 2024 (arXiv:2406.13352). Environnement d’évaluation d’agents (mail, banque, voyage, Slack) sous injection ; référence pour comparer utilité et robustesse des défenses.

Outils de détection et guardrails

Heuristiques : utiles en couche supplémentaire, jamais suffisants seuls.

  • Llama Prompt Guard 2 et LlamaFirewall (Meta) — classifieur d’injection et framework de guardrails pour agents (arXiv:2505.03574).
  • Prompt Shields (Microsoft Azure AI Content Safety).
  • Lakera Guard.
  • ProtectAI — modèles deberta-v3-base-prompt-injection (Hugging Face), cités par l’article parmi les filtres de détection.
  • NeMo Guardrails (NVIDIA).
  • Invariant Guardrails (Invariant Labs) — règles sur les traces d’exécution d’agents.

Outils de red teaming

  • garak (NVIDIA) — scanner de vulnérabilités LLM.
  • PyRIT (Microsoft) — framework de red teaming génératif.
  • promptfoo — tests et red teaming de prompts et d’agents.

Cadres de référence

  • OWASP Top 10 for LLM Applications 2025 — LLM01 Prompt Injection, LLM06 Excessive Agency.
  • MITRE ATLAS — AML.T0051 LLM Prompt Injection.

Voir aussi : prompt_injection, llm_output_attacks