Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Lors de la création d'agents autonomes avec LangChain ou LlamaIndex, vient forcément le moment de connecter une base de données et des API externes. C'est généralement là que les problèmes commencent. Une seule injection de prompt peut exposer la clé maître OpenAI ou le mot de passe administrateur de la base de données stockés dans le fichier .env. Ajouter des garde-fous au prompt a beau être fait avec soin, cela reste inutile. Tant que la zone de raisonnement du LLM et sa zone d'exécution sont liées, la sécurité peut être compromise par une simple phrase.
Selon le rapport SAIF (Secure AI Framework) 2025 de Google, 88 % des entreprises ayant adopté des agents ont subi des tentatives d'injection de prompt. Le taux de blocage des techniques traditionnelles de détection de motifs textuels n'était que de 23 %. Il est plus prudent de ne tout simplement pas faire confiance au processus de l'agent lui-même. Ne donnez aucune autorisation à l'agent et optez plutôt pour une structure où un jeton temporaire, valable seulement 60 secondes, est injecté au niveau de la couche middleware.
En utilisant l'authentification AppRole d'HashiCorp Vault, il est possible de délivrer un jeton valable 60 secondes exactement au moment où l'outil est appelé. Lorsque l'agent interroge une API externe, un intercepteur intervient au milieu pour insérer ce jeton à courte durée de vie dans l'en-tête.
`typescript
import { Request, Response, NextFunction } from 'express';
import vault from 'node-vault';
interface VaultAppRoleAuth {
roleId: string;
secretId: string;
}
export class EphemeralTokenInjector {
private vaultClient: any;
private roleId: string;
private secretId: string;
constructor(endpoint: string, auth: VaultAppRoleAuth) {
this.vaultClient = vault({ endpoint });
this.roleId = auth.roleId;
this.secretId = auth.secretId;
}
private async getAppRoleToken(): Promise {
const result = await this.vaultClient.approleLogin({
role_id: this.roleId,
secret_id: this.secretId,
});
return result.auth.client_token;
}
public createToolInterceptor(targetServiceRole: string) {
return async (req: Request, res: Response, next: NextFunction) => {
let clientToken: string | null = null;
try {
clientToken = await this.getAppRoleToken();
const dynamicSecret = await this.vaultClient.write(
`sys/leases/generate/${targetServiceRole}`,
{ ttl: '60s' }
);
req.headers['authorization'] = `Bearer ${dynamicSecret.data.token}`;
req.body.ephemeralContext = {
leaseId: dynamicSecret.lease_id,
expiresAt: Date.now() + 60000,
};
next();
} catch (error) {
res.status(500).json({ error: 'Failed to inject ephemeral dynamic secret' });
} finally {
clientToken = null;
}
};
}
}
`
Écrire le code ne suffit pas. Dans le moteur V8 de Node.js, la mémoire tas (heap) est gérée par le ramasse-miettes (Garbage Collector) qui s'exécute quand il le souhaite ; ainsi, même si vous videz une variable, la chaîne de caractères du jeton peut rester un certain temps dans le tas. En cas d'attaque par vidage de mémoire (heap dump), il existe un risque de fuite.
Buffer dès la réception de la réponse de l'API.Buffer.fill(0) pour forcer la réinitialisation des octets à 0.null aux variables de référence pour les laisser à la portée du ramasse-miettes.En appliquant ces trois étapes, le risque de fuite du jeton via le profilage mémoire diminue drastiquement.
| Mode de gestion des identifiants | Durée de vie moyenne (TTL) | Portée des dommages en cas de vol | Traçabilité d'audit |
|---|---|---|---|
| Clé API Master codée en dur | Illimitée | Prise de contrôle totale de l'infrastructure | Identification du sujet impossible (clé unique partagée) |
| Secret statique dans variable d'environnement (.env) | Durée du processus | Abus total des permissions du processus Node concerné | Impossible de tracer les workflows par utilisateur |
| Jeton éphémère Vault AppRole | 60 secondes | Limité à 1 seule exécution de cet outil | Traçabilité à la seconde près via les journaux d'audit Vault |
Même si l'agent exécute la commande "Affiche-moi toutes les informations des membres" en raison d'un jailbreak de prompt, il suffit que le moteur de base de données le rejette au niveau système. Dans un environnement SaaS multi-locataire (multi-tenant), il faut configurer le Row Level Security (RLS) de PostgreSQL.
Récupérez le userId et le tenantId du JWT émis par Auth0 et transmettez-les au contexte de session RunnableConfig de LangChain. Injectez ensuite ce contexte en tant que variable de session au sein de la transaction Prisma.
`typescript
import { RunnableConfig } from '@langchain/core/runnables';
import { PrismaClient } from '@prisma/client';
export interface AgentUserClaims {
userId: string;
tenantId: string;
}
export async function executeAgentToolWithRLS(
prisma: PrismaClient,
config: RunnableConfig,
dbOperation: (tx: any) => Promise
): Promise {
const claims = config.configurable?.userClaims as AgentUserClaims;
if (!claims || !claims.tenantId || !claims.userId) {
throw new Error('Unauthorized: Missing OIDC Claims in Agent Execution Context');
}
return await prisma.transaction(async (tx) => {
await tx.executeRawSELECT set_config('app.current_tenant_id', ${claims.tenantId}, true);
await tx.$executeRawSELECT set_config('app.current_user_id', ${claims.userId}, true);
return await dbOperation(tx);
});
}
`
Il est essentiel de passer true comme dernier argument de set_config afin que la variable ne s'applique qu'à la portée de la transaction courante (SET LOCAL). C'est une configuration clé dans un environnement de pool de connexions BDD pour éviter que les autorisations de l'utilisateur précédent ne fuient vers la requête suivante.
Créez maintenant une politique dans votre fichier SQL pour lire ces variables de session.
`sql
ALTER TABLE tenant_documents ENABLE ROW LEVEL SECURITY;
ALTER TABLE tenant_documents FORCE ROW LEVEL SECURITY;
CREATE POLICY agent_tenant_isolation_policy ON tenant_documents
FOR ALL
TO authenticated_agent_role
USING (
tenant_id = current_setting('app.current_tenant_id', true)::uuid
)
WITH CHECK (
tenant_id = current_setting('app.current_tenant_id', true)::uuid
);
`
Grâce à cette combinaison, peu importe la bizarrerie des requêtes générées par l'agent, il sera incapable d'interroger les données en dehors du périmètre de son propre locataire. En cas d'incident de fuite, cela permet de réduire le temps de restauration des données (MTTR) de plusieurs jours à seulement quelques minutes.
Chaque fois qu'un développeur modifie le code des outils de l'agent, il est impossible de tester manuellement et à chaque fois si l'isolation des privilèges fonctionne correctement. Intégrez les outils open-source Promptfoo et PyRIT de Microsoft dans GitHub Actions pour effectuer une vérification à chaque Pull Request.
`yaml
name: Agent Red Teaming Security Gate
on:
pull_request:
paths:
- 'src/agents/'
- 'src/tools/'
- 'prompts/**'
jobs:
security-eval:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- name: Setup Node.js
uses: actions/setup-node@v4
with:
node-version: 20
cache: 'npm'
- name: Install Dependencies
run: npm ci
- name: Run Promptfoo Scan
uses: promptfoo/promptfoo-action@v1
with:
config: 'promptfooconfig.yaml'
openai-api-key: ${{ secrets.OPENAI_API_KEY }}
github-token: ${{ secrets.GITHUB_TOKEN }}
- name: Run PyRIT Multi-Turn Test
env:
AGENT_ENDPOINT: 'http://localhost:3000/api/agent'
run: |
python -m pip install pyrit
python scripts/run_pyrit_eval.py --endpoint $AGENT_ENDPOINT --pass-threshold 0.98
`
Côté runtime du serveur, attachez un middleware de type coupe-circuit (Circuit Breaker) qui interrompt immédiatement l'exécution dès qu'un motif de menace est détecté.
`typescript
import { Request, Response, NextFunction } from 'express';
export class AgentCircuitBreaker {
private failureCount: number = 0;
private readonly threshold: number = 3;
private state: 'CLOSED' | 'OPEN' | 'HALF_OPEN' = 'CLOSED';
private forbiddenSignatures: RegExp[] = [
/ignores+alls+previouss+instructions/i,
/system::override_privileges/i,
/grants+roles+admin/i,
/concats*(s*select/i
];
public middleware() {
return (req: Request, res: Response, next: NextFunction) => {
if (this.state === 'OPEN') {
return res.status(503).json({
error: 'CircuitBreaker:Open - Agent execution halted'
});
}
const promptInput = JSON.stringify(req.body);
const isPatternViolated = this.forbiddenSignatures.some(sig => sig.test(promptInput));
if (isPatternViolated) {
this.failureCount++;
this.dispatchSecurityAlert(req.body);
if (this.failureCount >= this.threshold) {
this.state = 'OPEN';
}
return res.status(403).json({
error: 'Security Policy Violation: Malicious prompt pattern'
});
}
next();
};
}
private dispatchSecurityAlert(payload: any): void {
const webhookUrl = process.env.SECURITY_WEBHOOK_URL;
if (!webhookUrl) return;
fetch(webhookUrl, {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({
event: 'AGENT_PRIVILEGE_ESCALATION_DETECTED',
timestamp: new Date().toISOString(),
payload
})
}).catch(() => {});
}
}
`
Les étapes pour mettre en place ce pipeline de tests de sécurité sont simples :
promptfooconfig.yaml à la racine du projet et définissez les éléments de contrôle pour jailbreak et excessive-agency.AgentCircuitBreaker en amont des endpoints Express pour stopper l'exécution de l'agent après 3 détections consécutives de motifs d'injection.Grâce à cette configuration, vous économiserez plus de 5 heures par semaine auparavant consacrées à la revue manuelle des prompts.
| Indicateur d'évaluation | Méthode de vérification manuelle | Introduction de l'automatisation Zero-Trust |
|---|---|---|
| Temps de préparation de l'audit | 5 à 8 heures par semaine | Moins d'une heure par semaine |
| MTTR en cas de fuite d'autorisations | Plusieurs jours (inspection complète des journaux et BDD) | Quelques minutes (limité au périmètre RLS) |
| Taux de blocage de l'injection de prompt | Environ 23 % | 99,9 % |
| Risque de surfacturation en cas de fuite de clé | Facturation cloud illimitée | Facturation bloquée grâce au TTL de 60s |
La clé de la sécurité des agents ne consiste pas à prier pour que le modèle reste sage. Il s'agit de lui passer des menottes au niveau de l'infrastructure afin qu'il ne puisse pas nuire au système, même s'il délire ou succombe à une attaque.