Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Une passerelle d’IA qui examine chaque requête à la recherche d’une tentative de passer outre le modèle

Les utilisateurs d’un assistant de support peuvent taper n’importe quoi, et une partie de ce qu’ils tapent tente de faire ignorer au modèle les instructions qu’il a reçues. La passerelle placée devant le modèle peut d’abord faire passer chaque requête par un garde : un service qui demande à un classifieur entraîné si la requête est une telle tentative, la refuse si c’est le cas et transmet le reste au modèle. Ce workspace compile cet agencement en manifestes Kubernetes : la passerelle, le garde et le détecteur dans lequel s’exécute le classifieur du garde.

La Feature qui le demande est core/prompt-injection-shield. Ce qu’elle fait est plus étroit que son nom ne le laisse penser, et cette page consacre autant de place à ce qu’elle ne fait pas qu’à ce qu’elle fait : le verdict est celui d’un classifieur probabiliste, elle manque certaines attaques et refuse certaines requêtes légitimes, elle est connue pour être contournable, et elle ne juge ni la réponse du modèle, ni les arguments des appels d’outils, ni les images. C’est un contrôle parmi d’autres.

Ce workspace ne rédige aucune entité de catalogue qui lui soit propre. Les trois fichiers d’entité présents ici — un Aggregate, un Manifest et une Release — sont tout ce que quiconque écrit.

Ce qu’il construit

instanceComponent du cataloguece qu’il est ici
routercore/gateway/litellmla passerelle d’IA : un alias, assistant, saisi dans sa table de modèles et pointant vers un modèle derrière le garde
guardcore/security/nemo-guardrailsle serveur de NVIDIA NeMo Guardrails sur le chemin du modèle, qui vérifie chaque requête de chat et transmet au modèle ce qu’il admet
detectorcore/security/trustyai-huggingface-detectorle service de classification qu’interroge le garde, exécutant son classifieur d’injection de prompt par défaut

Deux arêtes uses : le socket guard de la passerelle vers le garde, et le socket detector du garde vers le détecteur. Deux rattachements de Feature : shield, le bouclier, sur la passerelle, à sensitivity: standard ; et upstream_key, les informations d’identification que le garde présente à l’API du modèle, sur le garde.

Générer l’exemple

Vous pouvez construire cet exemple avec les commandes ci-dessous, ou le faire construire pour vous par votre assistant IA.

Écrivez l’exemple dans un nouveau dossier qui porte son nom :

Terminal window
aggrega scaffold --example ai-gateway-prompt-injection-shield

Elle affiche ensuite les prochaines commandes à exécuter. La première vous place dans le nouveau dossier :

Terminal window
cd ai-gateway-prompt-injection-shield

Build

Terminal window
aggrega build --release release.yaml --auto-pull

Une release a besoin d’un lockfile avant son build, et les lockfiles sont générés plutôt que livrés, de sorte qu’un clone neuf n’en contient aucun. Résolvez-en un d’abord, ou laissez le build le remplir :

Terminal window
aggrega pull --release release.yaml # resolve once, then build with no flag
aggrega build --release release.yaml --auto-pull # or resolve during the build

Ce workspace résout les entités du catalogue depuis le registre par défaut que nomme .aggrega-config.yaml. La réalisation du bouclier exécute un plugin qui n’est livré ni avec le compilateur ni avec le catalogue, l’étape de configuration de la passerelle pipeline-step/litellm-gateway-config, que la résolution récupère depuis le registre que nomme default_registry, hub.aggrega.ai.

Le build affiche, <workspace> désignant le dossier de cet exemple :

[… omitted: a line reporting on the gateway configuration step's plugin, a warning that the upstream_key credential's declared-sensitive origin reaches the target with no per-key sensitivity marking, because the realization maps it through a valuesMapping, the resolution's summary, a notice that core/referenced-secret declares origin in both of its pillars, and a total build time, which differs per run]
Build completed: 10 files written to <workspace>/dist

La Release nomme les images du garde et du détecteur, parce que le catalogue ne nomme ni l’une ni l’autre. L’infra.image de chaque Component est un paramètre obligatoire sans valeur par défaut ; le commentaire qui l’accompagne dans le Component dit pourquoi, et nomme la version sur laquelle son comportement a été vérifié. Les deux valeurs de release.yaml sont des espaces réservés pour une copie de la version que vous exécutez, mise en miroir dans un registre que vous contrôlez. Le build achemine la chaîne qui s’y trouve, quelle qu’elle soit ; remplacez les deux avant de déployer.

Avec un assistant IA

Un assistant IA configuré avec les outils d’Aggrega peut faire de même : collez-lui ce prompt.

Utilisez uniquement les outils Aggrega et ne créez vous-même aucun dossier. Si le dossier de l’espace de travail ne contient pas encore de dossier `ai-gateway-prompt-injection-shield`, appelez une seule fois l’outil `scaffold` avec `example` défini sur `ai-gateway-prompt-injection-shield` et sans `dir` : il écrit l’exemple dans un nouveau dossier `ai-gateway-prompt-injection-shield`. Appelez ensuite l’outil `build` avec `workspace_root` défini sur `ai-gateway-prompt-injection-shield`, `release` défini sur `release.yaml`, `auto_pull` défini sur true et `write` défini sur true. Indiquez-moi quels fichiers le build a écrits ; ils se trouvent sous `ai-gateway-prompt-injection-shield/dist/`.

L’arborescence rendue

dist/helm/
├── detector-default-service.yaml
├── detector-deployment.yaml
├── guard--upstream-zukey--guard-secret-guard-upstream-key.yaml
├── guard-default-service.yaml
├── guard-deployment.yaml
├── guard/
│ └── nemo-guardrails-config.configmap.yaml
├── router-default-service.yaml
├── router-deployment.yaml
└── router/
├── litellm-gateway-config/
│ └── configmap.yaml
└── request-guard/
└── request-guard.yaml

Le bouclier n’apporte aucun fichier à lui. Ce qu’il fait est écrit dans la configuration de la passerelle.

La route, telle que la passerelle la lit

Le corps de configuration de la passerelle, la clé config.yaml de dist/helm/router/litellm-gateway-config/configmap.yaml :

model_list:
- model_name: assistant
litellm_params:
model: openai/gpt-4o-mini
api_base: "http://guard-default:8000/v1"
api_key: "the-guard-holds-the-upstream-credential"
litellm_settings:
callbacks:
- /etc/litellm-request-guard/request_field_filter.filter
callback_settings:
request_field_filter.router-shield:
policies:
-
reason: "sends every model request through a prompt-injection guard, which checks chat completions only"
served_request_types:
- acompletion

Trois choses méritent d’y être relevées.

Chaque alias est adressé au garde. api_base est l’endpoint que publie le garde, lu sur l’arête guard, si bien qu’une requête pour assistant va au garde via l’API d’OpenAI, en demandant gpt-4o-mini ; le garde transmet ce qu’il admet à l’API de modèle que release.yaml nomme dans son upstream_endpoint. Retirez le bouclier et l’entrée est écrite sans api_base, exactement comme avant. C’est pourquoi l’alias est saisi dans les values.models de la passerelle plutôt que servi par un modèle câblé à son socket models : l’entrée d’un modèle câblé est écrite avec l’endpoint propre à ce modèle et la clé propre à sa connexion, si bien que ses requêtes iraient au modèle en contournant le garde, et le bouclier refuse une telle connexion, comme on le verra plus bas.

La passerelle ne détient aucune information d’identification pour le modèle. L’entrée nomme un mot fixe à la place d’une clé, parce que la passerelle atteint le garde plutôt que le fournisseur, et le garde présente ses propres informations d’identification, celles rattachées à son emplacement upstream_key. L’en-tête Authorization propre à un appelant n’atteint jamais le modèle.

Seules les complétions de chat sont servies. Le garde vérifie les complétions de chat et ne sert aucune route completions, embeddings, responses ou messages, si bien que la politique fait refuser par le garde de requêtes de la passerelle toute autre sorte de requête avec un HTTP 400, en disant pourquoi, avant que quoi que ce soit ne soit transmis :

This gateway sends every model request through a prompt-injection guard, which checks chat completions only, and it does not serve embeddings requests while it does, so the request was not forwarded. It serves chat completions requests.

Ce que fait le garde

La configuration du garde, la clé config.yaml de dist/helm/guard/nemo-guardrails-config.configmap.yaml, à partir de ses rails :

rails:
config:
hf_classifier:
prompt_injection:
engine: fms
model: "protectai/deberta-v3-base-prompt-injection-v2"
base_url: "http://detector-default:8000"
threshold: 0.5
blocked_labels: ["INJECTION"]
input:
flows:
- hf classifier check input $classifier=prompt_injection

Pour chaque requête de chat, simple ou en streaming, le garde envoie le dernier message de l’utilisateur au détecteur, qui lui attribue un score avec le classifieur qu’il a chargé, et refuse la requête lorsque le détecteur signale INJECTION à 0.5 ou au-dessus. À une requête refusée, le garde répond lui-même, par une complétion ordinaire dont le message est I’m sorry, I can’t respond to that. (Je suis désolé, je ne peux pas répondre à cela.) — en streaming lorsque la requête demandait un flux — et rien d’elle n’atteint le modèle. Une requête qu’il admet atteint le modèle telle que l’appelant l’a envoyée, son message système et les tours précédents compris.

Un appelant ne peut pas désactiver la vérification depuis la requête. La configuration du garde contient un flow, rails.co, qui exécute la vérification quoi que demande un corps de requête, et le garde exécute cette seule configuration et refuse une requête qui en nomme une autre. Sur cette passerelle, un champ guardrails appartient à la passerelle elle-même et n’est pas transmis, et un champ que la passerelle n’a pas été configurée pour transmettre, comme extra_body, est refusé.

Ce qu’elle ne fait pas

  • Elle manque certaines attaques et refuse certaines requêtes légitimes. Le verdict est le score d’un classifieur comparé à un seuil. Une tentative reformulée, écrite dans une autre langue, encodée ou réorthographiée peut obtenir un score bas et être servie ; une requête ordinaire peut obtenir un score élevé et être refusée.
  • Elle ne lit que le dernier message de l’utilisateur. Une tentative placée dans un message système, un tour précédent ou un résultat d’outil atteint le modèle sans être lue.
  • Elle ne juge pas la réponse du modèle, ni les arguments des appels d’outils ni les images.
  • Elle ne couvre que le trafic qui traverse la passerelle. Une charge de travail qui appelle directement l’adresse du modèle la contourne. Le garde et le détecteur n’authentifient aucun appelant, si bien que leurs Services sont des adresses pour les composants qui les appellent, et non des adresses à publier.

Sensibilité

standard et strict s’appliquent comme seuil du garde : 0.5 et 0.001. Ces deux nombres sont mesurés pour le classifieur par défaut du détecteur, dont les scores se situent près de 0 ou près de 1. À 0.5, le garde refuse les tentatives simples de passer outre les instructions du modèle. À 0.001, il refuse aussi une telle tentative réécrite en leetspeak, à laquelle le classifieur attribue un score proche de 0.008, et avec elle certaines requêtes ordinaires auxquelles le classifieur attribue un score bas mais pas proche de zéro.

Le seuil est une valeur propre au garde, donc passer à strict demande deux modifications faites ensemble : sensitivity: strict sur le rattachement, et threshold: 0.001 dans les values du garde. La réalisation vérifie que les deux concordent. Elle voit le garde et non le détecteur derrière lui, donc elle ne peut pas savoir quel modèle le détecteur a chargé ; un détecteur exécutant un autre modèle attribue des scores différents, et ses seuils sont mesurés à nouveau.

Ce qui arrête le build

Chacun de ces cas est une phrase qu’affiche le build, nommant ce qu’il faut changer :

  • La sensibilité et le seuil du garde ne concordent pas. Définissez sensitivity: strict et laissez le garde à sa valeur par défaut :

    [… omitted: a line reporting on the gateway configuration step's plugin, what resolving the lockfile prints, the same halt among it, and a notice that core/referenced-secret declares origin in both of its pillars]
    [CATALOG_ERROR E0010] instance router
    node "router": pipeline step failed
    [… omitted: the step, the template position and the template's own source]
    error calling fail: core/prompt-injection-shield attachment "shield" on "router" asks for sensitivity strict, which this realization runs as the guard's threshold 0.001, but the guard "guard" runs at 0.5; set values.threshold of "guard" to 0.001
  • Aucun garde câblé. Retirez le bloc uses de la passerelle, qui ne contient que l’arête guard, et le build s’arrête avant que quoi que ce soit ne soit rendu, en nommant le socket :

    [… omitted: a line reporting on the gateway configuration step's plugin, what resolving the lockfile prints, the same halt among it, and a notice that core/referenced-secret declares origin in both of its pillars]
    [CATALOG_ERROR E0033]
    Recipe/FeatureRecipe assertions
    caused by: FeatureRecipe "prompt-injection-shield-litellm" instance "router" assertion "guard_is_wired": [… omitted: the template position and the assertion's own source]: error calling fail: assertion failed: core/prompt-injection-shield attachment "shield" on "router" needs a guard to send the gateway's model requests through, but nothing is wired to its guard socket; wire a core/security/nemo-guardrails to the guard socket of "router"
  • Un modèle câblé au socket models de la passerelle. Son entrée serait envoyée à l’endpoint propre à ce modèle avec la clé propre à sa connexion, en contournant le garde. Câblez un core/ai-model/openai au socket sous le nom fast, avec des informations d’identification sur la connexion, à côté de l’alias saisi — en définissant values.model: assistant, puisque la passerelle sert alors deux alias et en publie un, et en nommant fast dans la Release et sa Recipe dans le Manifest — et le build s’arrête avant que quoi que ce soit ne soit rendu, en nommant la connexion :

    [… omitted: a line reporting on the gateway configuration step's plugin, what resolving the lockfile prints, the same halt among it, and a notice that core/referenced-secret declares origin in both of its pillars]
    [CATALOG_ERROR E0033]
    Recipe/FeatureRecipe assertions
    caused by: FeatureRecipe "prompt-injection-shield-litellm" instance "router" assertion "no_wired_models": [… omitted: the template position and the assertion's own source]: error calling fail: assertion failed: core/prompt-injection-shield attachment "shield" on "router" sends every model request through the guard, which forwards it to its own upstream with its own credential, but the models socket of "router" holds fast, each sent to its own model's endpoint with its own connection's credential, past the guard; remove those connections and reach that model through the guard's upstream, or remove the shield attachment
  • Des informations d’identification sur l’emplacement provider_key de la passerelle. Elles seraient présentées au garde et à aucun modèle ; le build nomme à la place l’emplacement upstream_key du garde.

  • Un autre garde. Le socket admet tout composant dont le garde de prompts est celui d’un classifieur entraîné, et la réalisation s’arrête sur tout composant autre que core/security/nemo-guardrails, celui sur lequel ses deux sensibilités sont mesurées — ainsi que sur un second garde câblé au socket.

  • Une cible qui n’est pas écrite openai/<model>, que la passerelle adresserait au garde via une autre API.

  • core/semantic-caching sur la même passerelle. Le cache calcule l’embedding de chaque prompt via un alias de la table, qui serait envoyé au garde, lequel ne répond à aucune requête d’embeddings ; le cache ne mettrait rien en cache.

  • Un second bouclier sur la passerelle.

Lorsque le garde ou le détecteur est injoignable

La requête est refusée, et rien n’atteint le modèle. Lorsque le détecteur est hors service, le garde répond à une requête simple par une complétion signalant une erreur interne, et à une requête en streaming par un flux ne contenant aucun texte. Lorsque le garde est hors service, la passerelle répond par une erreur. Rien dans cette configuration n’envoie une requête en contournant le garde lorsqu’il est en échec.

Là où le compilateur n’interprète pas

Le compilateur achemine le nom du Service et le port du garde vers la configuration de la passerelle, et le seuil et l’adresse du détecteur vers celle du garde, sous forme de chaînes. Il n’évalue aucun prompt, ne sait pas quel score attribuera le classifieur, et ne contacte ni le garde, ni le détecteur, ni le modèle. Chaque arrêt ci-dessus est déclaré par les propres entités du catalogue, comme une assertion dans la réalisation du bouclier ou une vérification dans son étape de pipeline, et aucun d’eux ne repose sur une quelconque compréhension du trafic.

L’adapter

  • Plus strict. Définissez sensitivity: strict sur le rattachement et threshold: 0.001 sur le garde, ensemble.
  • Un modèle que vous exécutez vous-même. Faites pointer l’upstream_endpoint du garde vers l’endpoint du serveur de modèle — core/ai-model/vllm en publie un — et écrivez la cible de l’alias openai/<the name that server serves>.
  • Une passerelle NGINX à la place. core/gateway/nginx déclare le même socket guard, et prompt-injection-shield-nginx, sur helm et sur compose, fait pointer son unique location vers le garde au lieu de son upstream. Réglez l’upstream_endpoint du garde sur le modèle que nomme le socket upstream de la passerelle. Chaque requête sur cette location va au garde, qui sert les complétions de chat et répond 404 aux autres routes de modèle.