Prompt Injection Indireto e Context Smuggling: Isolando Dados Não Confiáveis Antes do LLM com agent-context-firewall

Por que concatenar páginas web, chunks de RAG e saídas de ferramentas MCP diretamente no prompt colapsa a fronteira entre dados e instruções—e como o Benni-OS/agent-context-firewall remove Unicode smuggling, expurga diretivas HTML ocultas e sela payloads em envelopes determinísticos de quarentena em menos de 0,5 ms.

Prompt Injection Indireto e Context Smuggling: Isolando Dados Não Confiáveis Antes do LLM com agent-context-firewall

1. O Colapso do Plano de Controle em Agentes de IA

Na engenharia de sistemas clássica, o gargalo de Von Neumann ensinou uma lição dura: quando código e dados compartilham o mesmo espaço de memória sem fronteiras impostas por hardware, um simples estouro de buffer transforma entrada não confiável em execução arbitrária. Hoje, todo agente autônomo construído com concatenação crua de contexto repete exatamente esse erro.

Quando seu agente busca uma issue no GitHub, lê um e-mail de suporte, faz scraping de documentação ou recupera um chunk de um banco vetorial RAG, ele injeta texto externo bruto no mesmo fluxo de tokens do seu system prompt. O LLM não possui um bit nativo de hardware capaz de distinguir instruções confiáveis do plano de controle de dados não confiáveis do plano de dados.

Tese Central: Não se resolve uma falha arquitetural de fronteira com engenharia de prompt. Pedir para o LLM "ignorar instruções dentro de texto não confiável" é probabilístico. O Benni-OS/agent-context-firewall impõe um perímetro determinístico de pré-inferência em CPU local antes que um único token não confiável entre no modelo.

2. Anatomia do Context Smuggling: Unicode e HTML Oculto

A maioria dos guardrails em produção falha porque assume que ataques parecem frases em texto claro como "Ignore previous instructions". Na prática, ataques modernos de prompt injection indireto exploram duas camadas furtivas:

A. Unicode Tag & Bidi Smuggling

Atacantes embutem instruções ASCII no bloco de Tags Unicode (U+E0000–U+E007F), caracteres de largura zero (U+200B, U+200C, U+200D, U+FEFF) ou controles bidirecionais (U+202E). Em navegadores, IDEs ou logs de telemetria, o texto parece vazio ou legítimo. Contudo, tokenizadores BPE ainda processam a sequência oculta ou quebram palavras-chave entre caracteres invisíveis para driblar scanners baseados em regex.

B. Diretivas Ocultas em HTML, ARIA e Markdown

Quando agentes de navegação web ou pipelines RAG ingerem HTML, Markdown ou SVG, atacantes escondem diretivas dentro de:


3. Arquitetura: Quarentena Zero-Trust Pré-Inferência

O Benni-OS/agent-context-firewall atua entre cada fronteira externa de I/O (ferramentas MCP, fetchers HTTP, leitores de e-mail, retrievers RAG) e o montador de prompt do LLM. Todo payload não confiável atravessa um pipeline determinístico de quatro estágios em < 0,5 ms:

flowchart LR A["Fonte Não Confiável\n(Web / RAG / Email / MCP)"] -->|"Bytes Brutos"| B["Estágio 1: Purificador Unicode\n(NFKC + Remove Tags e Zero-Width)"] B -->|"Texto Normalizado"| C["Estágio 2: Expurgo DOM/Markup\n(Remove Comentários e Nós Ocultos)"] C -->|"Texto Limpo"| D["Estágio 3: Gate de Política e Role-Spoof\n(< 0.5ms Scan Determinístico)"] D -->|"Aprova / Redact"| E["Estágio 4: Envelope de Quarentena\n(trust=0 + Selo SHA-256)"] E -->|"Frame Isolado"| F["Fronteira de Contexto do LLM\n(Plano de Controle Preservado)"]

Observe que o Estágio 4 jamais entrega texto cru ao prompt. Ele envolve o payload sanitizado em um Envelope de Quarentena selado criptograficamente com atributo explícito trust="0", tags de borda escapadas e um digest SHA-256—garantindo que tags de fechamento injetadas no conteúdo não consigam escapar do frame de dados.


4. Implementação de Referência: Sanitização e Quarentena em Python

Abaixo está o padrão determinístico central implementado no agent-context-firewall. Ele executa remoção de caracteres invisíveis e Tags Unicode, canonicalização NFKC, expurgo de HTML oculto, neutralização de delimitadores de papel e selagem SHA-256—tudo sem chamadas externas de API:

import hashlib
import html
import re
import unicodedata
from dataclasses import dataclass
from typing import List, Tuple

# Faixas Unicode invisíveis / smuggling: Zero-Width, Bidi Overrides, Tag Block (U+E0000-U+E007F)
_INVISIBLE_CODEPOINTS = re.compile(
    r"[\u200B-\u200F\u202A-\u202E\u2060-\u206F\uFEFF\U000E0000-\U000E007F]"
)
_HTML_COMMENT_RE = re.compile(r"<!--.*?-->", re.DOTALL)
_HIDDEN_STYLE_RE = re.compile(
    r"<(span|div|p|section)[^>]*style\s*=\s*['\"][^'\"]*(?:display\s*:\s*none|opacity\s*:\s*0|font-size\s*:\s*0)[^'\"]*['\"][^>]*>.*?</\1>",
    re.IGNORECASE | re.DOTALL,
)
_INJECTION_PATTERNS = [
    re.compile(r"(?i)ignore\s+(all\s+)?(previous|prior|above)\s+instructions"),
    re.compile(r"(?i)</?(system|assistant|developer|tool_call)\b[^>]*>"),
    re.compile(r"(?i)\b(exfiltrate|override\s+system\s+prompt|reveal\s+api\s+key)\b"),
]


@dataclass(frozen=True)
class QuarantineEnvelope:
    source: str
    trust_level: int
    sha256_digest: str
    findings: Tuple[str, ...]
    sealed_payload: str


class ContextFirewall:
    """Firewall determinístico pré-LLM contra prompt injection indireto."""

    def sanitize_and_quarantine(
        self, raw_text: str, source: str, block_on_hit: bool = False
    ) -> QuarantineEnvelope:
        findings: List[str] = []

        # 1. Remove code points Unicode de smuggling e normaliza em NFKC
        if _INVISIBLE_CODEPOINTS.search(raw_text):
            findings.append("unicode_smuggling_stripped")
        cleaned = _INVISIBLE_CODEPOINTS.sub("", raw_text)
        cleaned = unicodedata.normalize("NFKC", cleaned)

        # 2. Expurga comentários HTML e nós DOM visualmente ocultos
        if _HTML_COMMENT_RE.search(cleaned):
            findings.append("html_comments_purged")
            cleaned = _HTML_COMMENT_RE.sub("", cleaned)
        if _HIDDEN_STYLE_RE.search(cleaned):
            findings.append("hidden_dom_nodes_purged")
            cleaned = _HIDDEN_STYLE_RE.sub("", cleaned)

        # 3. Escaneia assinaturas de role-spoofing e injeção de controle
        for pattern in _INJECTION_PATTERNS:
            if pattern.search(cleaned):
                findings.append(f"signature_matched:{pattern.pattern[:32]}")
                if block_on_hit:
                    raise PermissionError(
                        f"Payload bloqueado da origem {source}: {findings}"
                    )
                cleaned = pattern.sub("[DIRETIVA_REMOVIDA]", cleaned)

        # 4. Escapa delimitadores XML/HTML e sela no Envelope de Quarentena
        digest = hashlib.sha256(cleaned.encode("utf-8")).hexdigest()
        escaped = html.escape(cleaned, quote=False)
        sealed = (
            f'<untrusted_data source="{html.escape(source)}" '
            f'trust="0" sha256="{digest[:16]}">\n'
            f"{escaped}\n"
            f"</untrusted_data>"
        )
        return QuarantineEnvelope(
            source=source,
            trust_level=0,
            sha256_digest=digest,
            findings=tuple(findings),
            sealed_payload=sealed,
        )

5. Comparação Empírica: Contexto Cru vs. Guardrails LLM vs. agent-context-firewall

Dimensão de Segurança e Performance Concatenação Crua de Contexto Guardrail LLM-as-a-Judge Benni-OS/agent-context-firewall
Unicode & Bidi Smuggling Totalmente vulnerável Frequentemente enganado ou inconsistente 100% Removido (NFKC + Range Purge)
Diretivas HTML / CSS Ocultas Executadas como texto plano Exige tokens extras de prompt Expurgadas Antes da Tokenização
Isolamento de Fronteira Nenhum (fluxo único de tokens) Classificação probabilística Envelope de Quarentena SHA-256 Escapado
Latência de Inspeção 0 ms 400 – 2.000 ms (ida e volta de rede) < 0,5 ms em CPU Local
Custo Adicional de Tokens 0 Tokens +100% a +200% em tokens de entrada 0 Tokens (Custo Zero de Inferência)

6. Aplicando Fronteiras Zero-Trust em Pipelines MCP e RAG

Como o ContextFirewall é determinístico e sem estado, ele se acopla diretamente a qualquer wrapper de ferramenta MCP, nó do LangGraph ou retriever RAG sem alterar seu provedor de modelos. Cada leitura externa—seja de um scraper web, fila de chamados ou documento local—recebe o selo trust=0 e registra seu sha256_digest para auditoria completa.

Combinado com as camadas de ledger de execução e sandbox da suíte Benni OS, seus agentes ganham defesa em profundidade real: dados não confiáveis são sanitizados antes da inferência, isolados em frames de quarentena durante o raciocínio e validados contra gates de política antes de qualquer ferramenta com efeito colateral executar.

Blinde a Fronteira de Contexto dos Seus Agentes

Clone o Benni-OS/agent-context-firewall, envolva suas saídas de RAG e MCP em envelopes determinísticos de quarentena e elimine o prompt injection indireto com custo zero de tokens.

Explorar Benni-OS/agent-context-firewall no GitHub →

Perguntas Frequentes

Qual é a diferença entre prompt injection direto e indireto?
O prompt injection direto acontece quando o próprio usuário digita instruções adversariais no chat. O prompt injection indireto ocorre quando diretivas maliciosas são embutidas em fontes de dados externas—como páginas web, PDFs, e-mails, issues do GitHub ou documentos RAG—que um agente autônomo lê e concatena na janela de contexto.
Como o Unicode smuggling burla filtros ingênuos de palavras-chave?
Atacantes utilizam caracteres invisíveis do bloco Unicode Tag (U+E0000 a U+E007F), zero-width joiners (U+200B/U+200D) e controles bidirecionais (RLO) para ocultar instruções de revisores humanos e regex simples, enquanto o tokenizador do LLM continua decodificando o payload semântico.
O que é um Envelope de Quarentena no agent-context-firewall?
Um Envelope de Quarentena é um contêiner determinístico com hash criptográfico (contendo metadados da origem, trust="0" e digest SHA-256) que isola payloads externos sanitizados das instruções confiáveis do sistema, impedindo que texto não confiável se passe por diretiva do plano de controle.
Por que não usar um segundo LLM como guardrail em vez do agent-context-firewall?
Guardrails baseados em LLM-as-a-Judge adicionam de 400ms a 2.000ms de latência por chamada de ferramenta, dobram o custo de tokens e continuam vulneráveis aos mesmos ataques estocásticos de prompt injection. O agent-context-firewall executa deterministicamente em CPU local em menos de 0,5ms com custo zero de tokens.