OWASP Top 10 para aplicativos agênticos

O que é o OWASP Top 10 para aplicativos agênticos?

Uma classificação dos riscos de segurança mais críticos específicos para sistemas de agentes de IA que planejam, usam ferramentas e interagem com serviços externos de forma autônoma. A edição de 2026 aborda as ameaças emergentes à medida que a IA agêntica passa da pesquisa para as implementações de produção.

1️⃣ ASI01 - Sequestro de meta do agente

Critical

Visão geral

Um invasor manipula as metas ou os objetivos de um agente por meio de entradas criadas, fazendo com que ele busque alvos não intencionais. Ao contrário da simples injeção de prompt, o sequestro de metas pode persistir em várias etapas de planejamento, fazendo com que o agente tome uma série de ações prejudiciais de forma autônoma.

Risco

Os invasores podem redirecionar agentes autônomos para exfiltrar dados, modificar configurações do sistema ou executar cadeias de ataque de várias etapas que são difíceis de detectar porque o agente parece operar normalmente.

Exemplo de código vulnerável

        Python
        ❌ Bad
      

# Agent goal is derived directly from untrusted input
def run_agent(user_request: str) -> str:
    goal = f"Complete this task: {user_request}"
    plan = llm.plan(goal)
    for step in plan:
        execute(step)  # No validation of planned steps

Exemplo de código seguro

        Python
        ✅ Good
      

import re

ALLOWED_GOALS = ["summarize", "search", "draft_email", "analyze_data"]

def sanitize_goal(user_request: str) -> str:
    # Strip injection patterns
    cleaned = re.sub(r'(?i)(ignore|override|new goal|forget).*', '', user_request)
    return cleaned.strip()

def run_agent(user_request: str) -> str:
    sanitized = sanitize_goal(user_request)
    goal = f"Complete this task: {sanitized}"
    plan = llm.plan(goal)

    # Validate each step against allowed actions
    for step in plan:
        if step.action not in ALLOWED_GOALS:
            raise ValueError(f"Disallowed action: {step.action}")
        if goal_drift_detected(step, sanitized):
            raise ValueError("Goal drift detected, aborting")
    for step in plan:
        execute(step)

Lista de verificação de mitigação

Sanitizar e validar todas as entradas antes da formulação de metas
Implementar a detecção de desvio de metas nas etapas de planejamento
Manter uma lista de permissão de objetivos de agentes permitidos
Registre todas as alterações de metas e acione alertas sobre modificações inesperadas

2️⃣ ASI02 - Uso indevido e exploração de ferramentas

Critical

Visão geral

Os agentes com acesso a ferramentas externas (APIs, sistemas de arquivos, bancos de dados, navegadores da Web) podem ser manipulados para fazer uso indevido dessas ferramentas. O acesso irrestrito a ferramentas permite que os invasores realizem operações não autorizadas por meio do agente.

Risco

Um agente com acesso irrestrito à ferramenta poderia excluir arquivos, enviar solicitações de API não autorizadas, extrair dados por meio de navegação na Web ou modificar configurações críticas do sistema.

Exemplo de código vulnerável

        Python
        ❌ Bad
      

# Agent can call any tool without restrictions
def agent_execute(tool_name: str, params: dict):
    tool = tools_registry.get(tool_name)
    return tool(**params)  # No validation or approval

Exemplo de código seguro

        Python
        ✅ Good
      

TOOL_ALLOWLIST = {
    "web_search": {"max_calls": 10, "approval": False},
    "send_email": {"max_calls": 1, "approval": True},
    "file_write": {"max_calls": 5, "approval": True},
}

def agent_execute(tool_name: str, params: dict, session) -> str:
    if tool_name not in TOOL_ALLOWLIST:
        return "Error: Tool not permitted"

    config = TOOL_ALLOWLIST[tool_name]
    if session.tool_calls[tool_name] >= config["max_calls"]:
        return "Error: Tool call limit exceeded"

    if config["approval"]:
        if not request_human_approval(tool_name, params):
            return "Action denied by user"

    session.tool_calls[tool_name] += 1
    return tools_registry[tool_name](**params)

Lista de verificação de mitigação

Manter uma lista de permissão rigorosa de ferramentas que o agente pode invocar
Exigir aprovação humana para operações com ferramentas de alto impacto
Impor limites de taxa por sessão e por ferramenta
Validar os parâmetros da ferramenta em relação aos esquemas esperados antes da execução

3️⃣ ASI03 - Abuso de identidade e privilégio

Critical

Visão geral

Os agentes geralmente herdam a identidade e as permissões do usuário ou da conta de serviço que os iniciou. Essa herança excessiva de privilégios permite que os agentes executem ações além do necessário, criando uma ampla superfície de ataque se o agente for comprometido.

Risco

Um agente comprometido executado com credenciais de administrador pode acessar todos os sistemas, modificar permissões e aumentar os privilégios em toda a organização.

Exemplo de código vulnerável

        Python
        ❌ Bad
      

# Agent inherits full user credentials
def create_agent(user_session):
    agent = Agent(
        credentials=user_session.full_credentials,  # All permissions!
        scope="*",
    )
    return agent

Exemplo de código seguro

        Python
        ✅ Good
      

def create_agent(user_session, task_type: str):
    # Issue scoped, short-lived credentials for the agent
    scoped_token = auth.create_scoped_token(
        parent_token=user_session.token,
        scopes=TASK_SCOPES[task_type],  # Minimal required permissions
        ttl_minutes=30,
        max_actions=50,
    )

    agent = Agent(
        credentials=scoped_token,
        scope=TASK_SCOPES[task_type],
        audit_log=True,
    )
    return agent

TASK_SCOPES = {
    "summarize": ["read:documents"],
    "draft_email": ["read:contacts", "draft:email"],
    "analyze": ["read:data", "write:reports"],
}

Lista de verificação de mitigação

Emitir credenciais com escopo e de curta duração específicas para a tarefa do agente
Nunca passe credenciais completas de usuário ou administrador para os agentes
Implementar limites de permissão por tarefa com limites máximos de ação
Auditar todas as operações privilegiadas realizadas pelos agentes

4️⃣ ASI04 - Vulnerabilidades da cadeia de suprimentos autêntica

High

Visão geral

Os sistemas de agentes dependem de plug-ins de terceiros, integrações de ferramentas e estruturas de agentes compartilhados. Componentes comprometidos ou mal-intencionados na cadeia de suprimentos do agente podem introduzir backdoors, canais de exfiltração de dados ou recursos não autorizados.

        Python
        ❌ Bad
      

# Loading plugins without verification
def load_plugin(plugin_url: str):
    code = requests.get(plugin_url).text
    exec(code)  # Arbitrary code execution!

        Python
        ✅ Good
      

import hashlib, importlib

TRUSTED_PLUGINS = {
    "search_plugin": "sha256:a1b2c3...",
    "email_plugin": "sha256:d4e5f6...",
}

def load_plugin(plugin_name: str) -> None:
    if plugin_name not in TRUSTED_PLUGINS:
        raise ValueError(f"Untrusted plugin: {plugin_name}")

    module = importlib.import_module(f"plugins.{plugin_name}")
    actual_hash = compute_hash(module.__file__)

    if actual_hash != TRUSTED_PLUGINS[plugin_name]:
        raise ValueError("Plugin integrity check failed")

    module.init(sandbox=True)

Lista de verificação de mitigação

Verificar a integridade do plug-in com assinaturas criptográficas antes do carregamento
Manter um registro com curadoria de plug-ins e ferramentas de agente aprovados
Execute plug-ins de terceiros em ambientes de área restrita com permissões limitadas
Implementar o rastreamento de SBOM para todas as dependências da estrutura do agente

5️⃣ ASI05 - Execução inesperada de código

Critical

Visão geral

Os agentes que podem gerar e executar códigos (por exemplo, agentes de análise de dados, assistentes de codificação) podem ser induzidos a executar códigos maliciosos. Sem o sandboxing adequado, isso pode levar ao comprometimento do sistema, ao roubo de dados ou à movimentação lateral.

Risco

Os agentes que usam eval() ou exec() no código gerado podem ser explorados para execução remota de código, permitindo que os invasores obtenham acesso total ao sistema.

Exemplo de código vulnerável

        Python
        ❌ Bad
      

# Agent executes generated code directly
def code_agent(task: str) -> str:
    code = llm.generate_code(task)
    result = eval(code)  # Dangerous!
    return str(result)

Exemplo de código seguro

        Python
        ✅ Good
      

import subprocess, tempfile, os

BLOCKED_MODULES = ["os", "subprocess", "socket", "shutil"]

def code_agent(task: str) -> str:
    code = llm.generate_code(task)

    # Static analysis: block dangerous imports
    for mod in BLOCKED_MODULES:
        if f"import {mod}" in code or f"from {mod}" in code:
            raise ValueError(f"Blocked import: {mod}")

    # Execute in sandboxed container with resource limits
    result = sandbox.run(
        code=code,
        timeout=30,
        memory_mb=256,
        network=False,
        read_only_fs=True,
    )
    return result.output

Lista de verificação de mitigação

Nunca use eval() ou exec() em códigos gerados por agentes no ambiente do host
Execute o código gerado em contêineres de área restrita com limites de recursos
Realizar análise estática para bloquear importações e chamadas de sistema perigosas
Desative o acesso à rede e imponha sistemas de arquivos somente leitura em ambientes de execução de código

6️⃣ ASI06 - Envenenamento de memória e contexto

High

Visão geral

Os agentes que mantêm memória persistente (RAG, histórico de conversas, preferências aprendidas) são vulneráveis ao envenenamento de memória. Os invasores injetam conteúdo malicioso na base de conhecimento do agente, fazendo com que ele produza resultados comprometidos em interações futuras.

        Python
        ❌ Bad
      

# Agent stores all interactions without validation
def store_memory(agent_id: str, interaction: str):
    memory_db.insert(agent_id, interaction)  # No filtering

        Python
        ✅ Good
      

def store_memory(agent_id: str, interaction: str, source: str):
    # Validate content before storing
    if contains_injection_patterns(interaction):
        log.warning(f"Blocked poisoned memory: {agent_id}")
        return

    memory_db.insert(
        agent_id=agent_id,
        content=interaction,
        source=source,
        provenance=compute_provenance(source),
        timestamp=now(),
        ttl_days=30,  # Auto-expire old memories
    )

def retrieve_memory(agent_id: str, query: str) -> list:
    results = memory_db.search(agent_id, query)
    # Filter by provenance score
    return [r for r in results if r.provenance_score > 0.8]

Lista de verificação de mitigação

Validar e higienizar todas as entradas antes de armazená-las na memória do agente
Rastreie a procedência de todas as entradas de memória e filtre por pontuação de confiança
Implementar TTL (time-to-live) para entradas de memória para limitar a persistência de envenenamento
Monitorar padrões anômalos na memória armazenada e permitir a reversão

7️⃣ ASI07 - Comunicação insegura entre agentes

High

Visão geral

Os sistemas multiagentes em que os agentes se comunicam entre si são vulneráveis à adulteração, falsificação e espionagem de mensagens. Sem verificações adequadas de autenticação e integridade, um agente comprometido pode injetar instruções maliciosas na rede de agentes.

        Python
        ❌ Bad
      

# Agents communicate via plain text messages
def send_to_agent(target: str, message: str):
    channel.send(target, message)  # No auth, no signing

        Python
        ✅ Good
      

import hmac, json, time

def send_to_agent(target: str, message: str, sender_key: bytes):
    payload = {
        "content": message,
        "sender": agent_id,
        "target": target,
        "timestamp": time.time(),
        "nonce": os.urandom(16).hex(),
    }
    signature = hmac.new(
        sender_key, json.dumps(payload).encode(), "sha256"
    ).hexdigest()
    payload["signature"] = signature

    encrypted = encrypt(json.dumps(payload), target_public_key)
    channel.send(target, encrypted)

def receive_message(data: bytes, private_key) -> dict:
    payload = json.loads(decrypt(data, private_key))
    if not verify_signature(payload):
        raise ValueError("Invalid message signature")
    if is_replay(payload["nonce"]):
        raise ValueError("Replay attack detected")
    return payload

Lista de verificação de mitigação

Assinar todas as mensagens entre agentes com HMAC ou assinaturas digitais
Criptografar canais de comunicação entre agentes de ponta a ponta
Implementar a prevenção de ataques de repetição baseados em nonce
Autenticar a identidade do agente antes de aceitar mensagens

8️⃣ ASI08 - Falhas em cascata

High

Visão geral

Em fluxos de trabalho com vários agentes ou várias etapas, um erro ou uma ação mal-intencionada em um agente pode se propagar pelo sistema, causando falhas em cascata. Sem limites de erro adequados, uma única etapa comprometida pode corromper todo o pipeline.

        Python
        ❌ Bad
      

# Errors propagate without boundaries
def pipeline(data):
    result1 = agent_a.process(data)
    result2 = agent_b.process(result1)  # If agent_a fails or is poisoned...
    result3 = agent_c.process(result2)  # ...error cascades to all
    return result3

        Python
        ✅ Good
      

from circuitbreaker import circuit

class AgentPipeline:
    def __init__(self):
        self.circuit_breakers = {}

    @circuit(failure_threshold=3, recovery_timeout=60)
    def safe_execute(self, agent, data):
        result = agent.process(data)
        if not validate_output(result):
            raise ValueError("Output validation failed")
        return result

    def pipeline(self, data):
        try:
            r1 = self.safe_execute(agent_a, data)
        except Exception:
            r1 = fallback_a(data)

        try:
            r2 = self.safe_execute(agent_b, r1)
        except Exception:
            r2 = fallback_b(r1)

        return r2

Lista de verificação de mitigação

Implementar disjuntores entre os estágios do pipeline do agente
Validar as saídas em cada estágio do pipeline antes de passar para o próximo
Fornecer manipuladores de fallback para cada agente crítico no fluxo de trabalho
Defina tempos limite e limites de repetição para evitar loops infinitos nas cadeias de agentes

9️⃣ ASI09 - Exploração da confiança entre humanos e agentes

Medium

Visão geral

Os usuários podem confiar demais nos resultados dos agentes e aprovar ações sem uma análise adequada. Os agentes que apresentam recomendações com alta confiança, mas com embasamento insuficiente, podem levar os usuários a tomar decisões prejudiciais. Os invasores podem explorar essa relação de confiança.

        Python
        ❌ Bad
      

# Agent requests approval without context
def request_action(action: str):
    # "Deploy to production?" - user clicks Yes without review
    return ui.confirm(f"Execute: {action}?")

        Python
        ✅ Good
      

def request_action(action: str, context: dict) -> bool:
    confidence = context.get("confidence", 0.0)
    risk_level = assess_risk(action)

    approval_request = {
        "action": action,
        "confidence": f"{confidence:.0%}",
        "risk_level": risk_level,
        "reasoning": context["reasoning"],
        "affected_systems": context["systems"],
        "reversible": context.get("reversible", False),
    }

    # Force detailed review for high-risk or low-confidence
    if risk_level == "high" or confidence < 0.8:
        return ui.detailed_review(approval_request)

    return ui.confirm(approval_request)

Lista de verificação de mitigação

Exibir os índices de confiança e o raciocínio de todas as recomendações do agente
Exigir revisão detalhada para ações de alto risco ou de baixa confiança
Mostrar os sistemas afetados e o status de reversibilidade nas caixas de diálogo de aprovação
Implementar confiança progressiva: começar com mais supervisão, reduzir à medida que o agente se mostrar confiável

🔟 ASI10 - Agentes desonestos

High

Visão geral

Os agentes podem se desviar da finalidade pretendida devido ao desalinhamento de metas, à manipulação adversária ou a comportamentos emergentes. Os agentes desonestos podem buscar objetivos que entrem em conflito com as metas organizacionais, acumular recursos ou resistir a tentativas de desligamento.

        Python
        ❌ Bad
      

# Agent runs without monitoring or kill switch
def run_agent(task):
    while True:
        agent.step()  # No termination condition

        Python
        ✅ Good
      

class MonitoredAgent:
    def __init__(self, agent, max_steps=100):
        self.agent = agent
        self.max_steps = max_steps
        self.step_count = 0
        self.behavior_log = []

    def run(self):
        while self.step_count < self.max_steps:
            action = self.agent.next_action()

            # Check for rogue behavior
            if self.is_off_task(action):
                log.alert(f"Rogue behavior: {action}")
                self.shutdown()
                return

            # Check guardrails
            if not guardrails.check(action):
                log.warning(f"Guardrail violation: {action}")
                continue

            self.agent.execute(action)
            self.step_count += 1
            self.behavior_log.append(action)

    def shutdown(self):
        self.agent.stop()
        revoke_credentials(self.agent.id)
        notify_admin(self.behavior_log)

Lista de verificação de mitigação

Implementar monitoramento de comportamento com detecção de anomalias para todos os agentes
Definir limites máximos de etapas e aplicar o encerramento automático
Implantar guardrails que verificam cada ação em relação à política antes da execução
Manter um kill switch que revoga as credenciais e interrompe a execução do agente

📊 Tabela de resumo

ID	Vulnerabilidade	Gravidade	Principais medidas de mitigação
ASI01	Sequestro de metas do agente	Critical	Higienização de entrada, detecção de desvio de meta, listas de permissão de objetivos
ASI02	Uso indevido e exploração de ferramentas	Critical	Listas de permissão de ferramentas, aprovação humana, limites de taxas
ASI03	Abuso de identidade e privilégio	Critical	Credenciais com escopo, tokens de curta duração, privilégio mínimo
ASI04	Vulnerabilidades da cadeia de suprimentos autêntica	High	Verificação da assinatura do plug-in, execução em área restrita
ASI05	Execução inesperada de código	Critical	Contêineres em área restrita, análise estática, sem eval()
ASI06	Envenenamento de memória e contexto	High	Validação de entrada, rastreamento de proveniência, TTL na memória
ASI07	Comunicação insegura entre agentes	High	Assinatura de mensagens, criptografia, prevenção de repetição
ASI08	Falhas em cascata	High	Disjuntores, validação de saída, manipuladores de fallback
ASI09	Exploração da confiança entre homem e agente	Medium	Exibição de confiança, revisão detalhada, confiança progressiva
ASI10	Agentes desonestos	High	Monitoramento de comportamento, grades de proteção, kill switch

OWASP Top 10 para aplicativos agênticos (2026)

1️⃣ ASI01 - Sequestro de meta do agente

Visão geral

Exemplo de código vulnerável

Exemplo de código seguro

Lista de verificação de mitigação

2️⃣ ASI02 - Uso indevido e exploração de ferramentas

Visão geral

Exemplo de código vulnerável

Exemplo de código seguro

Lista de verificação de mitigação

3️⃣ ASI03 - Abuso de identidade e privilégio

Visão geral

Exemplo de código vulnerável

Exemplo de código seguro

Lista de verificação de mitigação

4️⃣ ASI04 - Vulnerabilidades da cadeia de suprimentos autêntica

Visão geral

Lista de verificação de mitigação

5️⃣ ASI05 - Execução inesperada de código

Visão geral

Exemplo de código vulnerável

Exemplo de código seguro

Lista de verificação de mitigação

6️⃣ ASI06 - Envenenamento de memória e contexto

Visão geral

Lista de verificação de mitigação

7️⃣ ASI07 - Comunicação insegura entre agentes

Visão geral

Lista de verificação de mitigação

8️⃣ ASI08 - Falhas em cascata

Visão geral

Lista de verificação de mitigação

9️⃣ ASI09 - Exploração da confiança entre humanos e agentes

Visão geral

Lista de verificação de mitigação

🔟 ASI10 - Agentes desonestos

Visão geral

Lista de verificação de mitigação

📊 Tabela de resumo