Written with AI assistance from the source video. The video is the authority.
Log in to leave a comment
No posts yet
Wenn Sie autonome Agenten mit LangChain oder LlamaIndex entwickeln, kommen Sie irgendwann an den Punkt, an dem Sie Datenbanken und externe APIs anbinden müssen. Und genau hier passieren meistens die Fehler. Ein einziger Prompt-Injection-Angriff reicht aus, um den in der .env-Datei gespeicherten OpenAI-Master-Key oder das DB-Admin-Passwort offenzulegen. Selbst die akribischsten Prompt-Guardrails nützen dann nichts mehr. Solange die Schlussfolgerungs- und die Ausführungsebene des LLMs miteinander verknüpft sind, lässt sich die Sicherheit durch einen einzigen Satz erschüttern.
Laut dem SAIF-Bericht (Secure AI Framework) von Google aus dem Jahr 2025 waren 88 % der Unternehmen, die Agenten einsetzen, bereits Ziel von Prompt-Injection-Versuchen. Die Blockierungsrate herkömmlicher Textmuster-Erkennungsmethoden lag bei lediglich 23 %. Es ist daher ratsam, dem Agentenprozess selbst grundsätzlich zu misstrauen. Geben Sie dem Agenten gar keine festen Rechte, sondern stellen Sie die Architektur so um, dass über eine Middleware-Schicht ein temporäres Token injiziert wird, das nur 60 Sekunden lang gültig ist.
Mithilfe der AppRole-Authentifizierung von HashiCorp Vault können Sie genau in dem Moment, in dem ein Tool aufgerufen wird, ein Token mit einer Gültigkeit von 60 Sekunden ausstellen. Sobald der Agent eine externe API anfragt, greift ein Interceptor ein und fügt dieses Short-lived Token in den Header ein.
`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;
}
};
}
}
`
Das Schreiben des Codes allein reicht jedoch nicht aus. Da der Garbage Collector der Node.js V8-Engine nach eigenem Ermessen arbeitet, verbleibt der Token-String selbst nach dem Leeren der Variablen noch eine Zeit lang im Heap-Speicher. Bei einem Heap-Dump-Angriff besteht somit das Risiko eines Datenlecks.
Buffer-Objekt.Buffer.fill(0) aus, um die Bytes erzwungen mit Nullen zu überschreiben.null zu, damit sie vom Garbage Collector erfasst werden kann.Wenn Sie diese drei Schritte befolgen, sinkt die Wahrscheinlichkeit drastisch, dass Tokens durch Speicher-Profiling entwendet werden.
| Credential-Management-Methode | Durchschnittliche Lebensdauer (TTL) | Schadensausmaß bei Entwendung | Audit-Trail |
|---|---|---|---|
| Hartcodierter Master-API-Key | Unbegrenzt | Übernahme der gesamten Infrastrukturrechte | Keine Subjektidentifikation möglich, da ein einziger Schlüssel geteilt wird |
| Umgebungsvariable (.env) Static Secret | Lebensdauer des Prozesses | Missbrauch aller Rechte des jeweiligen Node-Prozesses | Benutzerspezifische Workflows können nicht nachverfolgt werden |
| Vault AppRole Ephemeral Token | 60 Sekunden | Beschränkt auf die einmalige Ausführung des Tools | Sekundengenaue Nachverfolgung über das Vault-Audit-Log |
Selbst wenn ein Agent aufgrund eines Prompt-Jailbreaks den Befehl "Zeige mir alle Mitgliederdaten an" ausführt, sollte die Datenbank-Engine dies einfach verweigern. In einer Multi-Tenant-SaaS-Umgebung sollten Sie dazu Row Level Security (RLS) in PostgreSQL konfigurieren.
Extrahieren Sie userId und tenantId aus dem von Auth0 ausgestellten JWT und übergeben Sie diese an den RunnableConfig-Sitzungskontext von LangChain. Injektieren Sie diesen Kontext anschließend innerhalb einer Prisma-Transaktion als Sitzungsvariablen.
`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);
});
}
`
Indem Sie als letzten Parameter von set_config den Wert true übergeben, stellen Sie sicher, dass die Variablen nur für den aktuellen Transaktionsbereich (SET LOCAL) gelten. Dies ist eine entscheidende Einstellung in Datenbank-Connection-Pooling-Umgebungen, um zu verhindern, dass die Rechte eines vorherigen Benutzers auf nachfolgende Anfragen übergreifen.
Erstellen Sie nun in Ihrer SQL-Datei eine Richtlinie, die diese Sitzungsvariablen liest.
`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
);
`
Mit dieser Kombination kann der Agent noch so ungewöhnliche Abfragen generieren – der Zugriff auf Daten außerhalb seines eigenen Mandantenbereichs ist schlicht unmöglich. Selbst im Falle eines Datenlecks lässt sich die Wiederherstellungszeit (MTTR) von mehreren Tagen auf wenige Minuten reduzieren.
Es ist unpraktisch, jedes Mal manuell zu testen, ob die Rechteisolierung noch ordnungsgemäß funktioniert, wenn Entwickler den Code von Agenten-Tools ändern. Binden Sie stattdessen die Open-Source-Tools Promptfoo und Microsoft PyRIT in GitHub Actions ein, um jeden Pull Request automatisch zu überprüfen.
`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
`
Implementieren Sie in der Server-Laufzeitumgebung eine Circuit-Breaker-Middleware, die den Betrieb sofort stoppt, sobald ein Bedrohungsmuster erkannt wird.
`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[] = [
/ignore\s+all\s+previous\s+instructions/i,
/system::override_privileges/i,
/grant\s+role\s+admin/i,
/concat\s*(\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(() => {});
}
}
`
Der Aufbau einer solchen Sicherheitsprüfungs-Pipeline gliedert sich in folgende Schritte:
promptfooconfig.yaml im Stammverzeichnis des Projekts an und definieren Sie darin die Prüfpunkte jailbreak und excessive-agency.AgentCircuitBreaker-Middleware vor Ihre Express-Endpunkte, um die Ausführung des Agenten zu stoppen, sobald dreimal in Folge ein Injection-Muster erkannt wird.Durch diese Architektur sparen Sie wöchentlich mehr als 5 Stunden ein, die andernfalls für manuelle Überprüfungen von Prompts aufgewendet werden müssten.
| Evaluierungsmetrik | Manuelle Überprüfungsmethode | Einführung der Zero-Trust-Automatisierung |
|---|---|---|
| Vorbereitungszeit für Audits | 5–8 Stunden pro Woche | Unter 1 Stunde pro Woche |
| MTTR bei Rechteentwendung | Mehrere Tage (Vollständige Analyse von Logs/DB) | Wenige Minuten (Auf RLS-Bereich beschränkt) |
| Prompt-Injection-Abwehrrate | Ca. 23 % | 99,9 % |
| Kostenrisiko bei Key-Entwendung | Unbegrenzte Cloud-Kosten | Kostenstopp durch 60-Sekunden-TTL |
Der Schlüssel zur Sicherheit von Agenten liegt nicht darin, darauf zu hoffen, dass das Modell stets den Anweisungen folgt. Es geht vielmehr darum, dem System auf Infrastrukturebene Fesseln anzulegen, damit das Modell selbst im Falle eines Fehlverhaltens oder eines erfolgreichen Angriffs keinen Schaden anrichten kann.