OWASP Top 10 para aplicativos agentes: o que os desenvolvedores de API precisam mudar

Exemplo: Um agente de integração Stripe tem acesso a GET /api/customers/:id e POST /api/refunds. O agente lê o histórico de pagamentos de um cliente, identifica o transação de maior valor e emite um reembolso para si mesmo. Cada chamada individual passa pela autorização. A cadeia é a exploração.

Correção: limites de taxa por agente e rastreamento de profundidade da cadeia

A limitação de taxa padrão conta solicitações por IP ou por chave de API. A limitação da taxa de agente adiciona duas dimensões:

• Limites por ferramenta: Limite quantas vezes um único agente pode ligar para um endpoint específico em uma janela
• Limites de profundidade da cadeia: Acompanhe quantas chamadas sequenciais de API um agente faz em uma única sessão e interrompa-as em um limite definido

Exigir que os agentes enviem um X-Agent-Session cabeçalho. Acompanhe a contagem de chamadas por sessão. Quando o contagem excede seu limite, retorne 429 com uma mensagem de erro clara.

3. Registro insuficiente: sem visibilidade das chamadas de API do agente

48,9% das organizações não percebem o tráfego máquina a máquina. Quando um agente explora sua API, você preciso responder: qual agente? Quais pontos finais? Em que ordem? Em que janela de tempo? Logs de acesso padrão mostrar endereços IP e carimbos de data/hora. Eles não mostram a identidade do agente nem sequências de chamadas.

A lista de agentes do OWASP sinaliza o registro insuficiente como um dos principais riscos porque os ataques de agentes parecem tráfego autorizado. Cada solicitação individual passa pela autenticação. A exploração reside no padrão em vários pedidos.

Correção: exigir cabeçalhos de atribuição e cadeias de chamadas de registro

Adicione três cabeçalhos obrigatórios para consumidores de agentes:

• X-Agent-ID: identificador exclusivo do agente (vinculado à sua chave API)
• X-Agent-Session: identificador da tarefa ou conversa atual
• User-Agent: estrutura e versão do agente (por exemplo, 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();
}

Este middleware registra cada solicitação como JSON estruturado, que alimenta qualquer SIEM ou agregador de log. Ele também reforça a profundidade da cadeia rastreando chamadas sequenciais por sessão. Quando você investiga um incidente, você pode reconstruir a cadeia completa filtrando sessionId.

4. Tratamento de saída inseguro: agentes que confiam nas respostas da API sem validação

Um agente chama sua API, recebe uma resposta JSON e a passa para a próxima etapa da cadeia. Se o resposta contém campos inesperados, tipos errados ou conteúdo injetado, o agente propaga o problema a jusante. Este é o equivalente agente do OWASP API10 (consumo inseguro de APIs), amplificado por o fato de os agentes processarem as respostas automaticamente, sem revisão humana.

Exemplo: Um concorrente compromete uma API de preços de terceiros. O agente busca o produto preços, recebe uma resposta com um manipulado price campo definido como 0,01 e faz um pedido a esse preço. Nenhum humano jamais viu a resposta.

Correção: valide todas as respostas em um esquema JSON

Comece gerando um esquema a partir de uma resposta válida. O /v1/schema/json-to-jsonschema endpoint produz um esquema JSON a partir de qualquer JSON de amostra:

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 }
      ]
    }
  }'

Resposta:

{
  "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" }
            }
          }
        }
      }
    }
  }
}

Em seguida, valide cada resposta que seu agente recebe em relação a esse esquema. O /v1/schema/validate endpoint verifica um objeto JSON em relação a qualquer esquema JSON e retorna erros específicos:

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"
    }
  }'

Resposta:

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

A validação capturada internalNote, um campo que não pertence à resposta. Se uma API começar a retornar campos inesperados, seu agente interromperá o processamento em vez de transmitir dados corrompidos downstream.

Aqui está o padrão completo usando o SDK Botoi Node.js:

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. Vulnerabilidades da cadeia de suprimentos: definições de ferramentas comprometidas

Os agentes de IA descobrem ferramentas por meio de servidores MCP, especificações OpenAPI e manifestos de ferramentas. Se um invasor modificar uma definição de ferramenta, o agente chama um endpoint diferente, envia dados para um servidor diferente ou executa com parâmetros diferentes dos pretendidos pelo desenvolvedor.

Exemplo: Você usa um servidor MCP de código aberto que define 30 ferramentas. Um invasor envia uma solicitação pull que altera o URL da API de uma ferramenta de api.stripe.com para api.str1pe.com. A alteração passa na revisão do código porque é um único caractere. Seu agente agora envia dados de pagamento para o servidor do invasor.

Correção: definições de ferramentas de hash e verificação em tempo de execução

Faça hash de cada definição de ferramenta no momento da implantação. Antes que seu agente registre uma ferramenta em tempo de execução, faça hash novamente e compare. O /v1/hash endpoint gera um hash SHA-256 de qualquer string:

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"
  }'

Resposta:

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

Aqui está o fluxo de trabalho completo de verificação de integridade usando o 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}\`
    );
  }
}

Execute a etapa de geração de hash em seu pipeline de CI. Armazene o arquivo hashes junto com sua implantação artefato. Em tempo de execução, cada ferramenta é verificada antes do registro. Um único personagem alterado em qualquer a definição da ferramenta desencadeia uma falha grave.

OWASP Agentic top 10 vs API Security top 10: comparação

As duas listas se complementam. Veja como os cinco riscos de agente são mapeados para a segurança de API mais próxima homólogos e o que muda:

Lista de verificação de envio: cinco correções para segurança de API de agente

Cada correção é independente. Escolha um, envie-o e passe para o próximo.

O que vem a seguir

O OWASP Top 10 completo para aplicações Agentic está disponível em owasp.org. Cisco, Microsoft e Google anunciaram iniciativas de segurança de agentes no RSAC 2026, então espere ferramentas e padrões para avançar rapidamente durante o resto do ano.

Os cinco riscos restantes da lista (injeção imediata, envenenamento de memória, falhas em cascata, dados Vazamento e sandboxing inadequado) exigem correções na camada de estrutura do agente, não na camada de API. Se você executa uma estrutura de agente, leia o documento OWASP completo. Se você executa APIs, as cinco correções acima são seu ponto de partida.

Comece com chaves de API com escopo definido. Essa única mudança bloqueia a maior parte do uso excessivo de agências e ferramentas cenários. Em seguida, adicione cabeçalhos de atribuição para ver o que seus agentes estão fazendo. O resto decorre de visibilidade.