Artigos aprofundados sobre a tecnologia que molda o que vem a seguir.

Vazamento de Segredos em Agentes de IA: Scanning vs Contenção

Vazamentos de segredos em agentes de código com IA via allowlists: scanning vs contenção e guardrails para impedir credenciais commitadas.

Um painel de comutação mecânico em que uma alavanca rotulada pela posição direciona cabos luminosos, alguns dos quais derramam luz para fora do painel
Allowlists de permissão dão sensação de controle, mas discretamente arquivam todo comando que você já aprovou, segredos incluídos.

Pesquisadores de segurança acabam de encontrar senhas, tokens de API e credenciais de nuvem em mais de mil arquivos públicos no GitHub — não em arquivos .env descuidados, mas nas configurações de agentes de codificação com IA. O culpado é um padrão silencioso de vazamentos de segredos em agentes de codificação com IA: o desenvolvedor aprova um comando como curl -H "Authorization: Bearer sk-...", clica em "Não perguntar novamente", e o comando completo, com o token incluído, é gravado em um arquivo de configuração local. Commite esse arquivo e o segredo fica público. Passei anos trabalhando com segurança de infraestrutura, e esta é uma das classes de vazamento mais evitáveis que já vi. Também é uma classe realmente nova, porque o arquivo que vaza o segredo não existia há dois anos.

As duas defesas que as equipes costumam usar são o secret scanning (detectar o vazamento e depois limpar) e a contenção (garantir que o segredo nunca toque o agente nem o repositório). Ambas são necessárias. Nenhuma basta sozinha. Este texto compara as duas lado a lado, mostrando quando cada uma vence e onde cada uma falha, e termina com o que eu realmente implantaria em um time que usa Claude Code, Cursor ou qualquer agente com allowlist de permissões.

Antes de tudo, uma coisa: isto não é um argumento contra ferramentas de codificação agêntica. Eu as uso todos os dias e não voltaria atrás. O prompt de permissão, em que o agente pergunta "posso executar isto?", é um dos melhores mecanismos de segurança que essas ferramentas trazem. O problema está exclusivamente no que acontece depois que você diz sim: onde esse "sim" é registrado e o que ele contém.

Como a Allowlist Vira um Cofre de Segredos

Para entender o modo de falha, é preciso olhar para o que "Não perguntar novamente" realmente persiste. Quando uma CLI agêntica pede para executar um comando, a implementação ingênua armazena a string completa do comando na regra de permissão. Não um padrão. Não um hash. A string literal que você aprovou.

Assim, quando um desenvolvedor aprova aws s3 cp s3://bucket/backup.sql . --profile prod, isso é inofensivo. Mas quando ele aprova psql postgresql://admin:hunter2@db.internal/myapp ou curl -u deploy:APIKEY123 https://.../deploy, as credenciais ficam guardadas em .claude/settings.local.json ou na configuração equivalente. O arquivo de configurações foi feito para ficar local, e o Claude Code até adiciona automaticamente ao gitignore quando a própria ferramenta cria o arquivo. Mas se o desenvolvedor criou o arquivo manualmente, ou o adicionou à força, ou o gitignore global não o cobre, basta um git add . e um push para ele estar no GitHub. Essa é exatamente a cadeia por trás dos 1.122 arquivos encontrados pelos pesquisadores.

Repare como muitos elos dessa cadeia são individualmente razoáveis. Aprovar um comando com credencial inline é algo que desenvolvedores fazem interativamente há décadas sem consequência: o comando roda, o histórico do shell o guarda localmente, e ninguém se importa. Clicar em "Não perguntar novamente" é racional; a fadiga com os prompts é real, e o grande atrativo desses agentes é justamente reduzir interrupções. Até o git add . é defensável quando a ferramenta disse que o arquivo era local. O incidente não é causado por um ato descuidado. É causado por um sistema em que cinco atos inofensivos se compõem em uma credencial pública. Esses são os piores tipos de falha de segurança para corrigir, porque nenhum indivíduo se vê fazendo algo errado.

Já vi esse mesmo erro acontecer antes de existirem agentes. Um líder técnico de uma fintech para a qual eu prestei consultoria tinha um allowed_commands.sh para um bot auxiliar de CI, a mesma ideia feita à mão. Alguém aprovou uma migração de banco pontual com o DSN inline. Seis meses depois, o repositório foi aberto ao público, e o DSN estava no histórico do git de um arquivo que ninguém pensou em auditar porque "não era configuração". O arquivo era configuração. Só não parecia.

Essa é a ideia central: allowlists de permissão são arquivos de configuração que capturam segredos operacionais como efeito colateral. Ninguém as revisa em busca de segredos porque ninguém as considera portadoras de segredos. Sua política de gerenciamento de segredos cobre .env, credentials.yml, talvez o state do Terraform. Quase certamente não cobre .claude/settings.local.json nem as configurações em .cursor/. Escrevemos sobre um ponto cego semelhante em auditoria de clientes de API tratados como cofres de credenciais: as ferramentas que você usa diariamente acumulam segredos em lugares que sua política não menciona.

E a categoria está crescendo. Toda ferramenta agêntica lançada nos últimos anos tem alguma variante: allowlists, diretórios confiáveis, aprovações memorizadas, configurações de servidores MCP com tokens inline. Cada uma delas é um novo caminho de arquivo que suas políticas, gitignores e configurações de scanner existentes não mencionam. A próxima versão desse incidente será o mesmo erro em um arquivo com outro nome.

Secret Scanning vs Contenção: As Duas Defesas

Esta é a comparação que vou percorrer no restante do texto:

  • Detecção primeiro (secret scanning): hooks de pre-commit, scanners de repositório como gitleaks e trufflehog, push protection do GitHub ou GitLab, além de varreduras periódicas do histórico. Presuma que segredos vão vazar; capture-os rápido e rotacione.
  • Contenção primeiro (manter os segredos fora): segredos entram nos comandos apenas por variáveis de ambiente, CLIs de gerenciadores de senhas ou credenciais de curta duração; agentes rodam em sandboxes ou VMs efêmeras; arquivos de configuração locais são ignorados globalmente pelo git. Projete de forma que não haja nada a vazar.

Detecção é uma operação de limpeza. Contenção é uma propriedade de design. Elas falham em direções opostas: o scanning tem falsos negativos e sempre roda depois do fato; a contenção tem um custo de adoção e briga com a fricção do desenvolvedor. Qual vence depende de qual modo de falha você consegue tolerar.

Há também uma assimetria na forma como elas se degradam com o tempo. O scanning se degrada com elegância: um segredo perdido é ruim, mas os que ele pega continuam sendo pegos, e os conjuntos de regras melhoram. A contenção se degrada por exceção. Toda vez que um desenvolvedor contorna a fricção ("só desta vez, vou colar o token direto"), a propriedade enfraquece, e não há registro dessa perda. Você descobre que a contenção falhou do mesmo jeito que descobre que uma porta ficou destrancada: quando alguém verifica. Por isso as duas devem trabalhar juntas, e não como rivais, mas também por que eu as pondero de forma diferente. A seção abaixo explica por que o scanning, apesar de ser a resposta padrão da indústria, é o mais fraco das duas para esta classe específica de vazamento.

Secret Scanning: Pontos Fortes e Limites Rígidos

O secret scanning vence quando o vazamento já aconteceu ou está prestes a acontecer, o que, dada a natureza humana, é boa parte do tempo. O push protection do GitHub bloqueia formatos conhecidos de token no momento do push. O gitleaks em um hook de pre-commit pega uma quantidade surpreendente de coisas antes que elas saiam do notebook. Se você não fizer mais nada deste artigo, faça isto:

# .pre-commit-config.yaml
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.18.4
hooks:
- id: gitleaks

São dez minutos de configuração, e a classe específica de vazamento desta história, um token em um arquivo de configuração commitado, praticamente desaparece, porque o gitleaks não se importa que o arquivo seja um JSON de configurações. Ele analisa o conteúdo, não os nomes de arquivo. Adicione uma regex para os prefixos de token internos da sua empresa, se você tiver.

Há mais uma camada de scanning que vale a pena ter e que as equipes esquecem: escanear periodicamente a própria máquina local em busca de segredos não commitados. Os hooks no nível do repositório só disparam no momento do commit ou do push. Um arquivo de configuração que fica no disco por três meses antes de alguém rodar git add . é uma janela de três meses em que o segredo está a um comando de se tornar público. Um job agendado, até um cron semanal que roda o gitleaks sobre os dotfiles do seu diretório home, reduz essa janela para dias. É feio, mas funciona.

Mas o scanning tem três limites rígidos que a história do Claude Code expõe muito bem. Primeiro, detectores baseados em entropia perdem segredos de baixa entropia. Uma senha como Winter2024! numa string de conexão do psql não dispara uma checagem de entropia, e, se não estiver em um formato de provedor conhecido, nenhuma regra a reconhece. Os pesquisadores encontraram muitas senhas em texto puro, não apenas chaves no estilo AWS. Segundo, o scanning é posterior ao fato, na camada de push. O push protection interrompe o push, o que é ótimo, mas, se ele não disparar, o segredo está no histórico, e o histórico é para sempre. Rotacionar após um vazamento significa caçar cada lugar em que a credencial foi usada, e nunca vi essa limpeza levar menos de um dia. Terceiro, o scanning cria uma falsa sensação de completude. As equipes veem o check verde e param de pensar em como os segredos fluem. Como já argumentamos em nosso texto sobre scanners de segurança com IA, um scanner é uma rede de proteção, não um substituto para não cair.

Sobre o segundo ponto, vale ser preciso quanto ao que "limpeza" realmente envolve quando uma credencial atinge um repositório público, porque as equipes subestimam isso com frequência. A rotação é a parte fácil: revogue o token, emita um novo, atualize o cofre de segredos. A parte difícil é a arqueologia. Cada pipeline de deploy, job de cron, notebook de desenvolvedor e integração de terceiros que usava a credencial antiga precisa ser encontrado e atualizado, e perder um deles significa uma indisponibilidade no pior momento possível. Depois há o problema espelhado: se o repositório é público, você precisa presumir que o segredo foi coletado em minutos. Bots de coleta de credenciais monitoram continuamente o fluxo de eventos do GitHub. Quando seu scanner dispara o alerta, o segredo provavelmente já foi clonado, indexado e possivelmente testado contra seus endpoints de produção. A detecção lhe deu consciência. Não lhe deu segurança.

Dito isso, quero ser justo com o scanning, porque ele é descartado com facilidade demais nesses debates. Para organizações grandes, com centenas de repositórios e milhares de desenvolvedores, o scanning é a única camada que escala sem mudança de comportamento. Você não consegue treinar para sair de um vazamento nessa escala, mas consegue proteger por push a maior parte dele. Se você é um time de plataforma decidindo onde gastar sua primeira semana de esforço, a resposta é o scanning: é barato, centralizado e pega os tokens de provedores de alta entropia que causam mais dano. Só não o confunda com a solução completa.

Uma rede de pesca com grandes buracos sendo puxada de águas escuras, a maioria dos peixes luminosos escapando pelas frestas enquanto alguns poucos são capturados
O scanning pega os segredos que reconhece; senhas de baixa entropia e formatos novos escapam.

Contenção: Variáveis de Ambiente, Sandboxes e Credenciais de Curta Duração

A contenção vence em todos os lugares onde o segredo, de outro modo, seria escrito em algum lugar, exatamente onde este incidente vive. Se a credencial nunca aparece como string literal em um comando, a allowlist não tem nada perigoso para armazenar. O comando aprovado vira curl -H "Authorization: Bearer $DEPLOY_TOKEN" ..., e o arquivo de configurações contém apenas um nome de variável inofensivo. Duas regras cobrem a maior parte:

  • Segredos entram nos comandos apenas por variáveis de ambiente ou indireção ($TOKEN, $(op read ...), um arquivo de configuração que o agente lê em tempo de execução), nunca como valores literais.
  • Diretórios de configuração locais de agentes (.claude/, .cursor/, .aider*) vão para o seu gitignore global da máquina (~/.config/git/ignore), e não apenas por repositório, para que nenhum projeto possa commitá-los.
# Global gitignore covers every repo on this machine
git config --global core.excludesFile ~/.config/git/ignore
cat >> ~/.config/git/ignore <<'EOF'
.claude/
.cursor/
.aider*
.env*
EOF

Por que global e não por repositório? Por dois motivos. Primeiro, gitignores por repositório só existem se alguém lembrar de adicioná-los a cada novo repositório, e novos repositórios são criados justamente quando ninguém está pensando em higiene de segurança. Segundo, um gitignore global é política da máquina, não do projeto: ele não pode ser removido por acidente em um pull request que "limpa o gitignore", algo que eu vi acontecer de fato. A versão por repositório protege um repositório. A global protege um desenvolvedor, e o desenvolvedor é a unidade propensa a vazamentos aqui.

A regra das variáveis de ambiente merece o mesmo escrutínio, porque tem um modo de falha sutil: os perfis do shell. Se o desenvolvedor "resolve" a exigência da variável exportando DEPLOY_TOKEN=sk-... no seu .bashrc, você apenas moveu o segredo de um dotfile sem revisão para outro. A regra precisa terminar em um backend de segredos real, como 1Password CLI, direnv lendo de um armazenamento criptografado ou um gerenciador de segredos na nuvem com aws ssm ou op inject no início da sessão. O agente recebe a variável; o disco nunca recebe o valor. É uma indireção a mais, e é a diferença entre contenção e cosmética.

A versão mais forte da contenção é o que chamo de sandboxing de verdade: rodar o agente em uma VM ou contêiner efêmero por tarefa, em uma rede isolada, com um proxy na frente das APIs externas. Uma configuração de um praticante que admiro coloca um proxy de API entre o agente e uma chave SaaS com acesso total: leituras passam, escritas exigem um toque no celular. Isso é defesa em profundidade bem feita. Mesmo um agente totalmente comprometido com --dangerously-skip-permissions só consegue tocar no que o proxy permite. Cobrimos o trade-off mais amplo em contenção vs monitoramento de agentes de IA; esta história é um argumento a favor da contenção.

Credenciais de curta duração são a outra metade da versão forte, e são subestimadas porque reduzem o raio de explosão mesmo quando todas as outras camadas falham. Uma chave estática de acesso da AWS vazada no GitHub vale até alguém notar. Uma credencial emitida via OIDC com TTL de uma hora, vazada no GitHub, é apenas uma entrada de log. Se o seu provedor de nuvem suporta federação de identidade de workloads (e todos os grandes suportam), as credenciais do agente deveriam expirar mais rápido do que o seu processo de resposta a incidentes consegue sequer marcar uma reunião.

O custo honesto da contenção é a fricção. CLIs de gerenciadores de senhas significam prompts de impressão digital no meio da tarefa. VMs efêmeras significam tempo de configuração e latência de inicialização a frio em cada execução. Proxies com escopo significam que alguém precisa construir e manter o proxy. Para um desenvolvedor solo em um projeto paralelo, o sandboxing completo é exagero, e a versão com gitignore global mais variáveis de ambiente é a escolha certa. Para um time cujos agentes tocam credenciais de produção, a fricção é o preço de não ser o próximo comunicado de vazamento.

A Camada do Meio: Corrigindo a Própria Allowlist

Há uma terceira opção que pertence aos fornecedores de ferramentas, não a você: não armazenar o comando literal. Uma regra de permissão que persiste curl -H "Authorization: Bearer *" como padrão, com os valores dos argumentos redigidos, é igualmente útil para correspondência e não carrega nenhum segredo. A equipe do Claude Code já disse que está estudando como impedir exatamente essa classe, e a direção recomendada por eles é um modo de permissão automático que não exige manter listas de allow/deny. Esse é o instinto correto. Cada allowlist mantida manualmente é um incidente futuro com um carimbo de data que você ainda não consegue ver.

Correspondência de padrões também não é almoço grátis, para ser claro. Um glob como curl * casa tanto com o comando de deploy benigno quanto com o comando malicioso de exfiltração, então uma redação agressiva troca risco de vazamento por risco de amplitude de aprovação. O projeto certo provavelmente é estrutural, e não textual: persistir qual binário e quais flags foram aprovados, nunca os valores dos argumentos. Isso mantém a correspondência precisa (sim para curl com headers, não para curl enviando dados a um domínio novo) sem armazenar nada em que uma credencial possa se esconder. Os fornecedores vão chegar lá; o incentivo agora é uma evidência de mais de mil arquivos públicos.

Até que os fornecedores entreguem isso, você pode se aproximar com higiene: rodar periodicamente um scanner sobre os próprios arquivos de configuração locais. Um comando como gitleaks detect --no-git --source ~/.claude .claude audita exatamente os arquivos desta história, antes que eles cheguem perto de um repositório. Coloque isso no script de configuração dos seus dotfiles e não custa nada.

Minha Recomendação: Contenção por Padrão, Scanning como Rede de Proteção

Se for obrigado a escolher um, escolha a contenção. Um vazamento que nunca acontece é melhor que um vazamento detectado rapidamente, sempre. O scanning é o que você usa quando a contenção falha, e ela vai falhar, porque alguém vai colar uma string de conexão em um chat às 1 da manhã. Mas ele deve ser o tratador de exceções, e não a política.

Na prática, para um time que está adotando ferramentas agênticas de codificação neste trimestre, em ordem de esforço:

  1. Gitignore global para os diretórios de configuração de agentes em todas as máquinas de desenvolvedores: cinco minutos, elimina por completo o vazamento de configurações commitadas.
  2. Regra: segredos apenas via variáveis de ambiente ou CLI de gerenciador de senhas, nunca inline em comandos. Coloque isso no onboarding, não em uma wiki que ninguém lê.
  3. gitleaks como hook de pre-commit mais push protection na forge, a rede de proteção para tudo o que foi descrito acima.
  4. Credenciais de curta duração e com escopo para qualquer coisa que o agente toque (credenciais de nuvem emitidas via OIDC em vez de chaves estáticas), para que um vazamento expire em horas.
  5. Para agentes com acesso à produção: sandbox efêmero mais um proxy de API que limite o que as credenciais do agente podem fazer.

Repare na ordem. Os dois itens mais baratos são de contenção, e eliminam a classe inteira de incidentes em vez de apenas reduzir sua probabilidade. Os itens de scanning vêm em terceiro, não em primeiro, não porque sejam menos importantes, mas porque são a rede sob o trapézio, e você arma a rede depois de checar as cordas. Os itens quatro e cinco são onde você deixa de se defender de acidentes e passa a se defender de comprometimento, para onde as ferramentas agênticas estão indo, quer planejemos ou não.

Uma muralha de fortaleza com um pequeno portão, atrás da qual há uma segunda muralha interna e um cofre trancado no centro
Contenção em camadas: mesmo que a muralha externa falhe, o cofre não guarda nada estático que valha a pena roubar.

Só os dois primeiros itens teriam evitado praticamente todos os arquivos do conjunto de dados dos pesquisadores. Essa é a parte frustrante deste incidente: não é um ataque sofisticado. É um novo tipo de arquivo carregando um erro antigo, e a correção é a mesma higiene que pregamos desde o primeiro .env commitado, aplicada a um diretório que nenhuma política ainda menciona.

Atualize a política. Os agentes não vão a lugar nenhum, e o botão "Não perguntar novamente" também não.