OWASP Top 10 für Agenten-Apps: Was API-Entwickler ändern müssen

Beispiel: Ein Stripe-Integrationsagent hat Zugriff auf GET /api/customers/:id Und POST /api/refunds. Der Agent liest die Zahlungshistorie eines Kunden und identifiziert die Transaktion mit dem höchsten Wert und erstattet sich selbst eine Rückerstattung. Jeder einzelne Anruf besteht die Autorisierung. Die Kette ist der Exploit.

Fix: Ratenbegrenzungen pro Agent und Verfolgung der Kettentiefe

Die standardmäßige Ratenbegrenzung zählt Anfragen pro IP oder pro API-Schlüssel. Durch die Agentenratenbegrenzung werden zwei Dimensionen hinzugefügt:

• Grenzwerte pro Werkzeug: Begrenzen Sie, wie oft ein einzelner Agent einen bestimmten Endpunkt innerhalb eines Fensters aufrufen kann
• Grenzen der Kettentiefe: Verfolgen Sie, wie viele aufeinanderfolgende API-Aufrufe ein Agent in einer einzelnen Sitzung durchführt, und unterbrechen Sie diese bei einem definierten Schwellenwert

Fordern Sie Agenten auf, eine zu senden X-Agent-Session Kopfzeile. Verfolgen Sie die Anrufanzahl pro Sitzung. Wenn die Wenn die Anzahl Ihren Schwellenwert überschreitet, geben Sie eine 429 mit einer eindeutigen Fehlermeldung zurück.

3. Unzureichende Protokollierung: Keine Sichtbarkeit der Agent-API-Aufrufe

48,9 % der Unternehmen sind blind für den Maschine-zu-Maschine-Verkehr. Wenn ein Agent Ihre API ausnutzt, sind Sie Ich muss antworten: Welcher Agent? Welche Endpunkte? In welcher Reihenfolge? Über welches Zeitfenster? Standardzugriffsprotokolle IP-Adressen und Zeitstempel anzeigen. Sie zeigen weder die Identität des Agenten noch die Anrufsequenzen an.

In der OWASP-Agentenliste wird eine unzureichende Protokollierung als größtes Risiko eingestuft, da Agentenangriffe so aussehen autorisierter Verkehr. Jede einzelne Anfrage besteht die Authentifizierung. Der Exploit lebt im Muster gegenüber mehrere Anfragen.

Fix: Attributionsheader und Protokollaufrufketten erforderlich

Fügen Sie drei erforderliche Header für Agent-Konsumenten hinzu:

• X-Agent-ID: eindeutige Kennung für den Agenten (gebunden an seinen API-Schlüssel)
• X-Agent-Session: Kennung für die aktuelle Aufgabe oder Konversation
• User-Agent: Agent-Framework und Version (z. B. LangChain/0.3.1)

// Middleware: log every agent request with attribution
function agentAuditLog(req, res, next) {
  const logEntry = {
    timestamp: new Date().toISOString(),
    agentId: req.headers["x-agent-id"] || "unknown",
    apiKey: req.headers["x-api-key"]?.slice(-8) || "none",
    method: req.method,
    path: req.path,
    sessionId: req.headers["x-agent-session"] || "none",
    ip: req.ip,
    userAgent: req.headers["user-agent"]
  };

  // Structured JSON log for your SIEM
  console.log(JSON.stringify(logEntry));

  // Track chain depth per session
  const session = req.headers["x-agent-session"];
  if (session) {
    const depth = chainTracker.increment(session);
    if (depth > MAX_CHAIN_DEPTH) {
      return res.status(429).json({
        error: "Agent chain depth exceeded",
        maxDepth: MAX_CHAIN_DEPTH,
        currentDepth: depth
      });
    }
  }

  next();
}

Diese Middleware protokolliert jede Anfrage als strukturiertes JSON, das in jedes SIEM- oder Protokollaggregator eingespeist wird. Außerdem wird die Kettentiefe erzwungen, indem aufeinanderfolgende Aufrufe pro Sitzung verfolgt werden. Wenn Sie einen Vorfall untersuchen, Sie können die gesamte Kette durch Filtern rekonstruieren sessionId.

4. Unsichere Ausgabeverarbeitung: Agenten vertrauen API-Antworten ohne Validierung

Ein Agent ruft Ihre API auf, empfängt eine JSON-Antwort und leitet sie an den nächsten Schritt in seiner Kette weiter. Wenn die Wenn die Antwort unerwartete Felder, falsche Typen oder eingefügten Inhalt enthält, verbreitet der Agent das Problem flussabwärts. Dies ist das Agentenäquivalent von OWASP API10 (unsicherer Verbrauch von APIs), verstärkt durch die Tatsache, dass Agenten Antworten automatisch und ohne menschliche Überprüfung verarbeiten.

Beispiel: Ein Konkurrent kompromittiert eine Preis-API eines Drittanbieters. Der Agent holt das Produkt Preise, erhält eine manipulierte Antwort price Feld auf 0,01 gesetzt und gibt eine Bestellung auf zu diesem Preis. Kein Mensch hat jemals die Reaktion gesehen.

Fix: Validieren Sie jede Antwort anhand eines JSON-Schemas

Beginnen Sie mit der Generierung eines Schemas aus einer bekanntermaßen guten Antwort. Der /v1/schema/json-to-jsonschema endpoint erzeugt ein JSON-Schema aus einem beliebigen JSON-Beispiel:

curl -s -X POST https://api.botoi.com/v1/schema/json-to-jsonschema \\
  -H "Content-Type: application/json" \\
  -H "X-API-Key: YOUR_API_KEY" \\
  -d '{
    "json": {
      "orderId": "ord_12345",
      "status": "shipped",
      "total": 49.99,
      "items": [
        { "sku": "WIDGET-A", "quantity": 2 }
      ]
    }
  }'

Antwort:

{
  "success": true,
  "data": {
    "schema": {
      "type": "object",
      "properties": {
        "orderId": { "type": "string" },
        "status": { "type": "string" },
        "total": { "type": "number" },
        "items": {
          "type": "array",
          "items": {
            "type": "object",
            "properties": {
              "sku": { "type": "string" },
              "quantity": { "type": "integer" }
            }
          }
        }
      }
    }
  }
}

Anschließend validieren Sie jede Antwort, die Ihr Agent erhält, anhand dieses Schemas. Der /v1/schema/validate Der Endpunkt prüft ein JSON-Objekt anhand eines beliebigen JSON-Schemas und gibt bestimmte Fehler zurück:

curl -s -X POST https://api.botoi.com/v1/schema/validate \\
  -H "Content-Type: application/json" \\
  -H "X-API-Key: YOUR_API_KEY" \\
  -d '{
    "schema": {
      "type": "object",
      "required": ["orderId", "status", "total"],
      "properties": {
        "orderId": { "type": "string" },
        "status": { "type": "string", "enum": ["pending", "shipped", "delivered"] },
        "total": { "type": "number", "minimum": 0 }
      },
      "additionalProperties": false
    },
    "data": {
      "orderId": "ord_12345",
      "status": "shipped",
      "total": 49.99,
      "internalNote": "rush order"
    }
  }'

Antwort:

{
  "success": true,
  "data": {
    "valid": false,
    "errors": [
      {
        "path": "",
        "message": "must NOT have additional properties: internalNote"
      }
    ]
  }
}

Die Validierung wurde blockiert internalNote, ein Feld, das nicht in die Antwort gehört. Wenn eine API Wenn unerwartete Felder zurückgegeben werden, stoppt Ihr Agent die Verarbeitung, anstatt fehlerhafte Daten weiterzuleiten.

Hier ist das vollständige Muster mit dem Botoi Node.js SDK:

import Botoi from "botoi";

const botoi = new Botoi({ apiKey: process.env.BOTOI_API_KEY });

// Step 1: generate a schema from a known-good response
const schemaResult = await botoi.schema.jsonToJsonschema({
  json: knownGoodResponse
});
const responseSchema = schemaResult.data.schema;

// Step 2: validate every agent-received response against that schema
async function validateAgentResponse(response) {
  const validation = await botoi.schema.validate({
    schema: responseSchema,
    data: response
  });

  if (!validation.data.valid) {
    console.error("Response failed validation:", validation.data.errors);
    throw new Error("Untrusted response rejected by schema validation");
  }

  return response;
}

5. Schwachstellen in der Lieferkette: kompromittierte Tooldefinitionen

KI-Agenten entdecken Tools über MCP-Server, OpenAPI-Spezifikationen und Tool-Manifeste. Wenn ein Angreifer Änderungen vornimmt Bei einer Tooldefinition ruft der Agent einen anderen Endpunkt auf, sendet Daten an einen anderen Server oder führt ihn aus mit anderen Parametern als vom Entwickler vorgesehen.

Beispiel: Sie verwenden einen Open-Source-MCP-Server, der 30 Tools definiert. Ein Angreifer unterwirft sich eine Pull-Anfrage, die die API-URL eines Tools ändert api.stripe.com Zu api.str1pe.com. Die Änderung besteht die Codeüberprüfung, da es sich um ein einzelnes Zeichen handelt. Ihr Agent sendet nun Zahlungsdaten an den Server des Angreifers.

Fix: Hash-Tool-Definitionen und Überprüfung zur Laufzeit

Hashen Sie jede Tooldefinition zum Zeitpunkt der Bereitstellung. Bevor Ihr Agent ein Tool zur Laufzeit registriert, hashen Sie es erneut und vergleichen. Der /v1/hash Endpunkt generiert einen SHA-256-Hash einer beliebigen Zeichenfolge:

curl -s -X POST https://api.botoi.com/v1/hash \\
  -H "Content-Type: application/json" \\
  -H "X-API-Key: YOUR_API_KEY" \\
  -d '{
    "text": "{\\"name\\":\\"get_order_status\\",\\"description\\":\\"Retrieve current order status by order ID\\",\\"parameters\\":{\\"orderId\\":\\"string\\"}}",
    "algorithm": "sha256"
  }'

Antwort:

{
  "success": true,
  "data": {
    "hash": "a3f2b8c1d4e5f67890abcdef1234567890abcdef1234567890abcdef12345678",
    "algorithm": "sha256"
  }
}

Hier ist der vollständige Workflow zur Integritätsprüfung mit dem Botoi SDK:

import Botoi from "botoi";
import fs from "fs";

const botoi = new Botoi({ apiKey: process.env.BOTOI_API_KEY });

// Hash every tool definition at deploy time
const toolDefs = JSON.parse(fs.readFileSync("./mcp-tools.json", "utf-8"));
const hashes = {};

for (const tool of toolDefs) {
  const result = await botoi.hash.sha256({
    text: JSON.stringify(tool)
  });
  hashes[tool.name] = result.data.hash;
}

fs.writeFileSync("./tool-hashes.json", JSON.stringify(hashes, null, 2));

// At runtime, verify before registering any tool
async function verifyToolIntegrity(tool) {
  const result = await botoi.hash.sha256({
    text: JSON.stringify(tool)
  });
  const expected = hashes[tool.name];

  if (result.data.hash !== expected) {
    throw new Error(
      \`Tool "\${tool.name}" failed integrity check. \\n\` +
      \`Expected: \${expected}\\n\` +
      \`Got: \${result.data.hash}\`
    );
  }
}

Führen Sie den Hash-Generierungsschritt in Ihrer CI-Pipeline aus. Speichern Sie die Hash-Datei zusammen mit Ihrer Bereitstellung Artefakt. Zur Laufzeit wird jedes Tool vor der Registrierung überprüft. Ein einzelnes geändertes Zeichen in jedem Die Werkzeugdefinition löst einen schweren Fehler aus.

OWASP-Agent Top 10 vs. API Security Top 10: Vergleich

Die beiden Listen ergänzen sich. Hier erfahren Sie, wie die fünf Agentenrisiken ihrer nächstgelegenen API-Sicherheit zugeordnet werden Gegenstücke und welche Änderungen:

Versand-Checkliste: Fünf Korrekturen für die Agenten-API-Sicherheit

Jeder Fix ist unabhängig. Wählen Sie eines aus, versenden Sie es und fahren Sie mit dem nächsten fort.

Was kommt als nächstes?

Die vollständigen OWASP Top 10 für Agentenanwendungen finden Sie unter owasp.org. Cisco, Microsoft und Google haben alle auf der RSAC 2026 Initiativen zur Agentensicherheit angekündigt, also rechnen Sie damit Werkzeuge und Standards werden für den Rest des Jahres schnell verfügbar sein.

Die fünf verbleibenden Risiken auf der Liste (Prompt Injection, Memory Poisoning, Cascading Failures, Data Leckagen und unzureichendes Sandboxing) erfordern Korrekturen auf der Agent-Framework-Ebene, nicht auf der API-Ebene. Wenn Wenn Sie ein Agent-Framework ausführen, lesen Sie das vollständige OWASP-Dokument. Wenn Sie APIs ausführen, gelten die fünf oben genannten Korrekturen Ihr Ausgangspunkt.

Beginnen Sie mit bereichsbezogenen API-Schlüsseln. Diese einzige Änderung verhindert den Großteil des übermäßigen Missbrauchs von Agenturen und Werkzeugen Szenarien. Fügen Sie dann Attributions-Header hinzu, damit Sie sehen können, was Ihre Agenten tun. Der Rest ergibt sich aus Sichtbarkeit.