ROPE: Routed Origin Policy Enforcement

Código-fonte do nosso artigo:

ROPE: Routed Origin Policy Enforcement contra Injeção Indireta de Prompt por Xinhang Ma, Chaowei Xiao, William Yeoh, Ning Zhang, Yevgeniy Vorobeychik

Resumo

A injeção indireta de prompt (IPI) insere instruções no conteúdo que um agente LLM que usa ferramentas lê, direcionando o agente para chamadas de ferramentas prejudiciais. As defesas mais fortes são em nível de sistema, empregando técnicas como triagem de ferramentas condicionada à tarefa para impedir a execução de ferramentas maliciosas e controle de fluxo de informações para evitar a execução de ferramentas com parâmetros não confiáveis. No entanto, à medida que os agentes se tornam mais capazes, os usuários delegam mais à automação. Consequentemente, as sequências de execução de ferramentas e os valores de parâmetros são cada vez mais determinados em tempo de execução e não podem ser triados de forma confiável usando informações contidas apenas na consulta do usuário, sem perda significativa de utilidade. Apresentamos o ROPE (Routed Origin Policy Enforcement), que se ancora em uma noção estrutural de confiança: um valor pode alcançar uma ferramenta que altera o estado somente se ele rastrear de forma infalsificável até o usuário, uma fonte que o usuário nomeou explicitamente ou os registros autoritativos do próprio usuário. A aplicação é então uma verificação determinística de origem sobre um conjunto auditado de parâmetros sensíveis de ferramentas, e a única dependência de um modelo de linguagem envolve exclusivamente a solicitação confiável do usuário, fora do alcance do atacante. Nossa abordagem admite duas garantias comprováveis: 1) em cada etapa de uma trajetória, nenhum valor cuja única origem seja conteúdo gravável pelo atacante alcança um parâmetro protegido por origem, e 2) nenhuma reformulação de uma injeção altera uma decisão de admissão. Por meio de extensa avaliação experimental, mostramos que, em quatro modelos de agente em suítes de agente de final aberto, o ROPE mantém a taxa de sucesso do ataque em 1,6–2,6%, ao mesmo tempo em que retém 82–100% da utilidade limpa sem defesa, superando significativamente as defesas de nível de sistema de última geração em utilidade, ao mesmo tempo em que atinge segurança comparável ou melhor em fluxos de trabalho dinâmicos complexos. Além disso, mostramos que otimizar a injeção contra o ROPE é amplamente ineficaz, enquanto ataques de horizonte longo que derrotam defesas anteriores de nível de sistema alcançam taxa de sucesso zero em nosso caso.

Estrutura do repositório

Configuração

Python 3.12 com openai, pydantic, jsonschema, pyyaml (e google-genai para o caminho nativo do Gemini). A partir da raiz do repositório:

export PYTHONPATH=$PWD/autodojo/src:$PWD/src

Reproduzir os números relatados a partir dos logs fornecidos (sem necessidade de acesso à API)

cd runs
python aggregate.py         # CU / UA / ASR por suíte + totais (ambos os benchmarks)
python adaptive_rope.py     # estático vs adaptativo, CU/UA/ASR (ataque AutoDojo, ambos os benchmarks)
python longhorizon_rope.py  # horizonte longo (AgentLAB Task-Injection)
python ablation.py          # ablação de política: sempre totalmente especificado / sempre ação aberta
python router.py            # roteadores mais baratos, com e sem o clamp de aplicação
python failures.py          # censo de falhas: cada sucesso residual de ataque + falhas de tarefas limpas
python buckets.py           # tabelas por categoria (bucket de subespecificação)
python router_deviation.py  # contagens de afrouxamento/aperto por roteador vs o piso auditado

Cada script recalcula sua tabela a partir dos logs e a imprime; nenhum carrega valores esperados. buckets.py e router_deviation.py precisam de PYTHONPATH definido como acima (eles leem as definições das suítes e os escopos em cache); os demais leem apenas os logs JSON fornecidos.

runs/<model>/<suite>/user_task_*/, runs/ablation/<policy>/<suite>/user_task_*/ e runs/router/<router>[-clamp]/<suite>/user_task_*/ contêm cada um um JSON por célula avaliada: none/ (limpo), important_instructions/ (ataque estático), autodojo/ (ataque adaptativo) e agentlab_longhorizon/ (ataque encenado de horizonte longo).

Correções de pontuação. Três oráculos de benchmark são insólidos para defesas que bloqueiam execução. runs/corrections.py despacha as três re-pontuações baseadas em efeito — slack IT5, dailylife IT7, github IT1 — e os agregadores as aplicam; o docstring de cada módulo documenta o artefato e a correção. CU e UA nunca são tocados.

Executar a defesa

# configuração do resultado principal (roteador opus em cache, correspondência estrita, sem clamp):
python -m rope.run_eval --suite github --attack important_instructions
python -m rope.run_eval --suite github --attack none            # utilidade limpa
python -m rope.run_eval --suite github --defense passthrough    # linha de base sem defesa

# roteadores mais baratos do estudo de roteadores, opcionalmente com clamp no piso auditado:
python -m rope.run_eval --suite github --router gemini-3-flash --clamp

# roteador ao vivo (recalcula o escopo em tempo de execução com qualquer modelo compatível com OpenAI):
python -m rope.run_eval --suite github --router live --router-model openai/gpt-4o-mini --clamp

# ataque adaptativo: reproduz as injeções otimizadas em cache do AutoDojo
AUTODOJO_CACHE=$PWD/autodojo/variant_generation/variants/github/openai/gpt-4o-mini/routed/injections.json \
  python -m rope.run_eval --suite github --attack autodojo

# ataque de horizonte longo: reproduz as trilhas em cache do AgentLAB (consulte agentlab/README.md)
python agentlab/run_eval.py --suite banking --user-task user_task_0 --injection-task injection_task_0

Variáveis de ambiente: OPENROUTER_API_KEY (modelo de agente e roteador ao vivo; todas as execuções relatadas chamam os modelos de agente por meio do OpenRouter), ROPE_AGENT_MODEL (padrão openai/gpt-4o-mini), ROPE_PIPELINE_TAG para marcar os logs de execução (deve conter um nome de modelo do AgentDojo para que os modelos de ataque sejam resolvidos).

Os roteadores em cache tornam a defesa totalmente determinística e sem API no lado do roteamento: opus cobre todas as seis suítes; gemini-3-flash e gpt-oss-20b cobrem as suítes do AgentDyn (o escopo do estudo de roteadores). Para avaliar seu próprio roteador, coloque-o em cache uma vez e reutilize-o como um integrado:

python -m rope.cache_router --router my-router --router-model <llm-id> --suite github
python -m rope.run_eval     --router my-router --suite github --attack important_instructions

Agradecimentos

Este repositório incorpora ou se baseia em: AgentDojo e AgentDyn (suítes de benchmark), AutoDojo (ataque adaptativo) e AgentLAB (benchmark de horizonte longo e trilhas de ataque Task-Injection). Consulte os respectivos artigos para detalhes.

Referências

Se você achar este trabalho útil, agradecemos se puder citar gentilmente:

@article{rope,
  title={ROPE: Routed Origin Policy Enforcement against Indirect Prompt Injection},
  author={Ma, Xinhang and Xiao, Chaowei and Yeoh, William and Zhang, Ning and Vorobeychik, Yevgeniy},
  journal={arXiv preprint arXiv:2608.27496},
  year={2026}
}