Por que instruções de prompt não são controles de segurança

Enquanto um modelo de linguagem responde apenas texto dentro de uma janela de chat, o pior erro costuma ser uma resposta errada que o desenvolvedor descarta na hora. A conta muda completamente quando o mesmo modelo ganha acesso a ferramentas de execução: ler e gravar arquivos no repositório, rodar comandos no terminal, consultar bancos de dados, abrir pull requests ou acionar APIs internas.

Muitos times tentam conter esse risco escrevendo advertências em letras maiúsculas no prompt de sistema, do tipo "NUNCA apague arquivos fora do projeto" ou "NUNCA envie credenciais para fora". O problema estrutural é que o modelo trata instruções do sistema e dados lidos de fora no mesmo espaço de tokens. Um erro de interpretação durante uma depuração cansativa, ou uma instrução escondida dentro de um comentário de issue ou de uma página web consultada pelo agente, pode fazer o modelo ignorar a regra textual e disparar um comando real no sistema operacional.

Segurança operacional em automações com IA exige a mesma disciplina aplicada a APIs financeiras e fluxos críticos, como os tratados em segurança e fluxos de autenticação mobile: o modelo é tratado como um componente não determinístico e não confiável, cercado por camadas determinísticas de autorização, isolamento de ambiente e auditoria fora do alcance dele.

Princípio de desenho: um prompt orienta comportamento; um guardrail impõe limites. Se uma ação puder apagar dados, alterar produção ou expor segredos, o bloqueio precisa estar em código determinístico ou no sistema operacional, nunca apenas em texto enviado ao modelo.

Defesa em profundidade: quatro barreiras em torno do agente

Um erro comum ao desenhar automações corporativas é colocar toda a proteção em um único filtro de palavras proibidas antes do shell. Esse filtro cai diante da primeira variação de sintaxe (como encadear comandos com ;, usar substituição $(...) ou codificar argumentos em Base64). A proteção confiável distribui verificações determinísticas em quatro pontos distintos do ciclo de execução.

1. Input GuardrailMascara PII e segredosDelimita dados externosModelo (LLM)Planeja ações esolicita tool calls2. Policy EngineParser + AllowlistLimites de diretórioAprovação humana3. Sandbox OSFS restrito ao repoEgress de rede filtrado4. Output Guardrail, Varredura de Segredos e Trilha de Auditoria ImutávelValida diff gerado (SAST / CVEs / pacotes reais) e grava log JSON com usuário, comando e decisão
Fluxo de controle determinístico: dados entram sanitizados, cada chamada de ferramenta passa por análise estrutural de política e executa em sandbox com rede controlada.

Cada vetor de risco exige um controle específico. A matriz a seguir resume as falhas mais comuns observadas em automações com agentes de código e a contramedida técnica que realmente segura o ataque.

Vetor de riscoComo acontece na práticaPor que só o prompt falhaControle determinístico eficaz
Injeção de prompt indiretaTexto malicioso escondido em README, issue do GitHub ou resposta HTTP manda exfiltrar segredosO modelo mistura dados lidos com instruções no mesmo fluxo de atençãoDelimitação de conteúdo externo, aprovação humana para rede e bloqueio de egress no sandbox
Vazamento de credenciais locaisAgente lê .env, ~/.ssh ou tokens em variáveis de ambiente para "depurar" um erroO modelo age tentando ajudar a resolver a falha sem medir o impacto de privacidadeLista de caminhos negados resolvida com realpath + sandbox sem montar diretórios sensíveis
Ações destrutivas em massaExecução de git push --force, DROP TABLE ou rm -rf com variável vaziaUm erro de raciocínio ou parâmetro mal escapado executa sem voltaClassificação de risco por verbo (leitura, escrita local, remoto) exigindo confirmação humana
Vazamento de PII para API externaLogs de produção com CPF, e-mail ou PAN de cartão colados no contexto enviado ao provedorO envio acontece antes mesmo de o modelo processar qualquer regraRedator de PII síncrono na camada de entrada (input guardrail) com substituição por tokens opacos
Slopsquatting de dependênciasModelo inventa o nome de um pacote inexistente que um atacante registrou no npm ou PyPIAlucinação natural de nomes plausíveis fora do corte de treinoAllowlist de registry interno (Artifactory/Nexus) e revisão obrigatória em mudanças de lockfile

Classificação de políticas e análise estrutural de comandos

Em vez de tentar listar todas as formas possíveis de quebrar um comando perigoso via blacklist de regex, um motor de política sério classifica ações em três níveis: allow (leitura e testes locais sem efeito colateral externo), approve (operações que alteram estado compartilhado, como commits remotos, migrações ou chamadas HTTP de escrita) e deny (acesso a segredos, escalação de privilégio e execução de scripts baixados da internet).

{
  "workspace_root": "/workspace/app",
  "denied_paths": [
    "**/.env*",
    "**/*.pem",
    "**/*.key",
    "~/.ssh/**",
    "~/.aws/**"
  ],
  "tiers": {
    "allow": ["git status", "git diff", "rg", "pytest", "php -l", "swift test"],
    "approve": ["git push", "docker compose up", "kubectl apply", "curl"],
    "deny": ["sudo", "chmod 777", "rm -rf /", "mkfs", "dd"]
  },
  "egress_allowlist": [
    "pypi.org",
    "files.pythonhosted.org",
    "registry.npmjs.org"
  ]
}

Na camada de código que avalia comandos antes de chamar o shell, o ponto mais importante é rejeitar construções dinâmicas do shell (como pipes para interpretadores, subshells $(...), crases ou redirecionamentos para fora do workspace) e fazer parsing dos argumentos com shlex.split. Somado à resolução de links simbólicos com Path.resolve(), isso impede truques triviais como criar um symlink dentro do repositório apontando para /etc/shadow ou ~/.ssh/id_ed25519.

import json
import re
import shlex
import sys
from datetime import datetime, timezone
from pathlib import Path

WORKSPACE = Path("/workspace/app").resolve()
SHELL_META = re.compile(r"[;&|`]|(\$\()|(>>?)|(<)")
SECRET_PATHS = re.compile(r"(\.env(\.|$)|id_rsa|id_ed25519|\.pem$|\.key$|\.aws/credentials)", re.I)

ALLOW_BINS = {"rg", "pytest", "php", "swift", "ls", "cat"}
GIT_READ_SUBCMDS = {"status", "diff", "log", "show", "branch"}

def evaluate_command(command_line: str) -> tuple[str, str]:
    if SHELL_META.search(command_line):
        return ("deny", "Operadores de encadeamento ou subshell exigem revisao manual")

    try:
        tokens = shlex.split(command_line)
    except ValueError:
        return ("deny", "Sintaxe de comando invalida ou aspas nao fechadas")

    if not tokens:
        return ("deny", "Comando vazio")

    binary = Path(tokens[0]).name

    for arg in tokens[1:]:
        if SECRET_PATHS.search(arg):
            return ("deny", f"Acesso bloqueado a arquivo sensivel: {arg}")
        if not arg.startswith("-") and ("/" in arg or arg.startswith("~")):
            resolved = Path(arg).expanduser().resolve()
            if not resolved.is_relative_to(WORKSPACE):
                return ("deny", f"Caminho fora do workspace permitido: {resolved}")

    if binary == "git":
        sub = tokens[1] if len(tokens) > 1 else ""
        if sub in GIT_READ_SUBCMDS:
            return ("allow", "Operacao git somente leitura")
        if sub == "push" and any(flag in tokens for flag in ("--force", "-f")):
            return ("deny", "Force push bloqueado por politica")
        return ("approve", f"Operacao git com escrita ({sub}) requer confirmacao humana")

    if binary in ALLOW_BINS:
        return ("allow", f"Binario liberado dentro do workspace ({binary})")

    return ("approve", f"Binario fora da lista automatica ({binary}) requer aprovacao")

def audit_log(user: str, cmd: str, decision: str, reason: str) -> None:
    record = {
        "ts": datetime.now(timezone.utc).isoformat(),
        "actor": user,
        "command": cmd,
        "decision": decision,
        "reason": reason,
    }
    print(json.dumps(record, ensure_ascii=False), file=sys.stderr)

Isolamento de rede, escopo de credenciais e risco na memória

Mesmo com um bom motor de política na aplicação, o isolamento real acontece no sistema operacional. Rodar agentes de codificação dentro de um contêiner efêmero ou sandbox local com sistema de arquivos restrito ao repositório e política de saída (egress) fechada por padrão anula a maior parte dos cenários de exfiltração. Se o agente não consegue abrir conexão TCP para domínios desconhecidos, uma injeção de prompt escondida em uma biblioteca clonada perde o canal de retorno para o atacante.

As credenciais que o agente realmente precisa usar (por exemplo, um token para abrir pull requests ou consultar o sistema de tickets) devem ter escopo mínimo e validade curta. Em vez de injetar um Personal Access Token pessoal com permissão de administrador na conta inteira, crie tokens efêmeros restritos ao repositório específico e sem permissão de merge direto na branch principal. E quando o agente também mantém arquivos de aprendizado entre sessões, aplique a mesma barreira de revisão descrita em arquitetura de memória de longo prazo para agentes de IA: nenhuma instrução lida de conteúdo externo pode virar regra persistente sem aprovação explícita de um engenheiro.

Validação de saída e auditoria contínua

A última barreira entra depois que o agente conclui a edição e antes que o código chegue à revisão humana. Um pipeline de output guardrails roda automaticamente três verificações baratas: detector de segredos no diff (como Gitleaks ou TruffleHog) para barrar chaves coladas por engano, análise estática (Semgrep, SwiftLint ou PHPStan) para pegar padrões inseguros introduzidos pelo modelo, e checagem de dependências novas contra o registro aprovado pela empresa.

Todo bloqueio ou aprovação manual precisa alimentar um log estruturado em JSON enviado para fora do ambiente do agente, contendo carimbo de hora, identificador da sessão, ferramenta chamada, argumentos normalizados e decisão tomada. Revisar esses logs quinzenalmente revela dois sinais úteis: tentativas de bypass ou prompts maliciosos que chegaram ao time, e regras restritivas demais que estão gerando fadiga de aprovação nos desenvolvedores e precisam ser refinadas.

A fadiga de aprovação é um risco real que muita área de segurança subestima. Se o engenheiro precisa clicar em "aprovar" quarenta vezes por hora para comandos inofensivos como git status ou pytest, ele para de ler o conteúdo da caixa de diálogo e passa a apertar Enter no automático. Quando aparecer um comando realmente perigoso no meio dessa sequência, o clique sai por reflexo. Por isso, calibrar bem a fronteira entre a faixa allow e a faixa approve protege mais do que bloquear tudo indiscriminadamente: leitura local e testes dentro do sandbox rodam livres, enquanto comandos com escrita externa, mudança de infraestrutura ou acesso de rede param com destaque claro do comando exato e do alvo afetado.

Por fim, guardrails também merecem suite própria de testes de regressão no CI. Manter uma coleção pequena de casos adversariais (comandos com $(curl ...), paths com ../../.env, symlinks apontando para fora do workspace e exemplos de injeção indireta em comentários) executada a cada mudança no motor de políticas garante que uma refatoração futura não abra brechas silenciosas na barreira que protege o ambiente de produção.