Vazamento no OpenCode Console em 2026: Como Proteger Suas Chaves de API de IA

Olá HaWkers, no sábado, 17 de outubro de 2026, o OpenCode, um dos agentes de código open source mais usados no terminal, confirmou que sofreu uma invasão. Chaves de API da OpenAI, da Anthropic e do Google que alguns usuários tinham salvado no OpenCode Console podem ter sido expostas. Em poucas horas apareceram relatos de cobranças que ninguém autorizou: de algumas centenas de dólares até US$ 1.700 em uma única noite. A discussão no Hacker News passou de 970 pontos.

O caso é pequeno em número de pessoas afetadas, mas grande no que ensina. A pergunta que todo dev que usa IA no dia a dia deveria fazer agora é simples: se a ferramenta onde eu guardei minha chave fosse invadida hoje, quanto eu perderia até perceber? Neste artigo você vai entender o que aconteceu de fato, o que ainda não se sabe, e vai sair com um roteiro prático, com código, para revogar, testar e limitar suas chaves de API de IA.

O Que Aconteceu no OpenCode Console

Primeiro, uma distinção importante. O OpenCode tem duas partes:

O app e a CLI open source, que rodam na sua máquina. Quando você conecta um provedor com o comando /connect, a chave fica salva localmente, em ~/.local/share/opencode/auth.json.
O OpenCode Console, a plataforma online da empresa. Nele, um workspace pode conectar contas de provedores para que os membros do time usem os modelos sem nunca ver a chave do provedor. A chave, portanto, fica guardada nos servidores do OpenCode.

O incidente atingiu só o Console. Segundo o cofundador Dax Raad, o app e a CLI open source não foram afetados, e chaves usadas no OpenCode local nunca chegam à empresa.

A linha do tempo divulgada até agora:

17/10, 00:30 UTC: horário mais antigo de possível exposição das chaves, segundo o e-mail enviado aos afetados.
17/10: o pesquisador de segurança Matt Johansen publica no X a captura do e-mail com o assunto "Action Required: Potential provider key breach".
17/10: o OpenCode confirma publicamente uma violação de segurança "relacionada a um ataque de destilação em larga escala".
19/10: TechCrunch e BleepingComputer publicam as primeiras reportagens completas.

A empresa disse que a invasão aconteceu em um sistema legado que já estava sendo desativado e que 1,4% dos usuários do Console foram afetados. Quem não recebeu o e-mail não foi impactado.

O Que Foi Exposto e Quanto Isso Custou

O que vazou foram as chaves de provedores externos salvas nos workspaces do Console. O e-mail cita OpenAI e Anthropic como exemplos, e as reportagens incluem também chaves do Google. A empresa afirmou que nenhum outro dado parece ter sido exposto.

O impacto apareceu primeiro na fatura. Desenvolvedores relataram alertas de gasto da OpenAI, da Anthropic e do Google, com cobranças de centenas de dólares e alguns totais acima de US$ 1.000. O maior valor relatado foi de US$ 1.700 de uma noite para o dia. Alguns usuários também tiveram projetos suspensos pelo Google, com a justificativa de "atividade abusiva consistente com recursos sequestrados".

A resposta dos provedores foi rápida:

Anthropic e Google bloquearam as chaves que acreditavam estar expostas.
OpenAI trabalhou com o OpenCode para restaurar o acesso e reembolsou os créditos usados no ataque.
OpenCode disse que os reembolsos de cobranças não autorizadas estão em andamento.

O Que É um "Ataque de Destilação"

O OpenCode escolheu o termo distillation attack para descrever o incidente, e isso gerou debate. Destilação, por si só, é uma técnica legítima: você treina um modelo menor usando as respostas de um modelo maior e mais capaz. Ela vira ataque quando as respostas são obtidas em larga escala, sem autorização, e muitas vezes pagas por outra pessoa.

A lógica econômica é cruel. Uma chave roubada é saída de modelo de ponta de graça para o atacante, cobrada no cartão de quem é dono da chave. Quanto mais caro o modelo, mais valiosa a chave.

Vale registrar que nem todo mundo comprou essa explicação. Parte da comunidade argumentou que o caso é simplesmente um vazamento, e que a ligação com destilação ainda não foi provada. O OpenCode também não explicou como os atacantes entraram, como as chaves eram armazenadas nem a extensão total do uso indevido. A empresa diz que o incidente continua em andamento.

A Parte Mais Estranha: IA Se Recusando a Defender

Um detalhe do relato do Dax Raad chamou atenção. Ele contou que os atacantes tentaram invadir os sistemas sem parar por pelo menos 48 horas, usando agentes de IA, e que o time colocou agentes defensivos de IA para trabalhar o tempo todo.

O problema: os modelos usados na investigação ajudaram no começo, mas se recusaram a continuar quando o código malicioso disparou os filtros de segurança. Raad chamou isso de "um pouco frustrante". A situação só se estabilizou quando o OpenCode ganhou acesso ao programa Daybreak da OpenAI, que oferece a usuários verificados modelos menos propensos a recusar trabalho de segurança defensiva.

Não é a primeira vez que isso acontece em 2026. Em julho, a Hugging Face relatou que modelos comerciais se recusaram a analisar logs de uma intrusão feita por agentes autônomos e resumiu o dilema: os guardrails "não conseguem distinguir quem responde a um incidente de quem ataca". Se o seu plano de resposta a incidentes depende de um assistente de IA, tenha um plano B.

Por Que Agentes de Código Viraram Ímã de Credenciais

O caso do OpenCode é sintoma de algo maior. Ferramentas de IA para código concentram exatamente o que um atacante quer:

Chaves de vários provedores no mesmo lugar, muitas vezes sem limite de gasto.
Chaves de alto valor, porque dão acesso aos modelos mais caros.
Uso que já é intenso por natureza, então um pico de consumo demora a parecer anormal.

E o vazamento não precisa vir de uma invasão sofisticada. Chaves de IA expostas em repositórios públicos já são um problema antigo, como mostrei no artigo sobre empresas de IA que expuseram API keys no GitHub. E agentes atacando a cadeia de suprimentos já viraram realidade, como no ataque ao RubyGems feito com agentes da OpenAI.

A conclusão prática: trate cada chave de IA como um cartão de crédito sem limite, porque, sem configuração, é isso que ela é.

Roteiro Prático: Como Proteger Suas Chaves de IA

Agora a parte que interessa para quem foi afetado e, principalmente, para quem não foi. São quatro passos, do mais urgente para o mais estrutural.

Passo 1: Revogue e Confirme Que a Chave Morreu

Se você recebeu o e-mail do OpenCode, ou se tinha qualquer chave no Console, a recomendação oficial é revogar e substituir a chave direto no painel de cada provedor. Trocar a senha do OpenCode ou apagar a configuração local não invalida uma chave que já vazou.

Depois de revogar, confirme. Uma chave revogada deve responder HTTP 401 numa chamada de teste. O script abaixo testa as três de uma vez, sem gastar tokens, porque só lista os modelos disponíveis:

#!/usr/bin/env bash
# check-keys.sh - confirma se chaves antigas foram mesmo revogadas
# Uso: OLD_OPENAI_KEY=... OLD_ANTHROPIC_KEY=... OLD_GEMINI_KEY=... ./check-keys.sh

check() {
  local name="$1" status="$2"
  if [ "$status" = "401" ] || [ "$status" = "403" ] || [ "$status" = "400" ]; then
    echo "OK    $name revogada (HTTP $status)"
  else
    echo "ALERTA $name ainda responde (HTTP $status) - revogue agora"
  fi
}

# OpenAI: endpoint de listagem de modelos, não consome tokens
if [ -n "$OLD_OPENAI_KEY" ]; then
  s=$(curl -s -o /dev/null -w "%{http_code}" https://api.openai.com/v1/models \
    -H "Authorization: Bearer $OLD_OPENAI_KEY")
  check "OpenAI" "$s"
fi

# Anthropic: mesma ideia, com os headers obrigatórios
if [ -n "$OLD_ANTHROPIC_KEY" ]; then
  s=$(curl -s -o /dev/null -w "%{http_code}" https://api.anthropic.com/v1/models \
    -H "x-api-key: $OLD_ANTHROPIC_KEY" -H "anthropic-version: 2023-06-01")
  check "Anthropic" "$s"
fi

# Gemini: a chave vai como query string
if [ -n "$OLD_GEMINI_KEY" ]; then
  s=$(curl -s -o /dev/null -w "%{http_code}" \
    "https://generativelanguage.googleapis.com/v1beta/models?key=$OLD_GEMINI_KEY")
  check "Gemini" "$s"
fi

Uma dica para o Gemini: crie a chave nova no AI Studio antes de desativar a antiga, para não derrubar o que está em produção no meio da troca.

Passo 2: Ache Todos os Lugares Onde a Chave Antiga Vive

Revogar sem atualizar quebra suas aplicações; atualizar sem procurar deixa a chave antiga escondida em algum .env esquecido. Antes de fechar o incidente, varra o projeto e a sua home procurando os formatos conhecidos de chave:

# find-ai-keys.sh - procura chaves de IA em texto puro
# Prefixos comuns: sk-ant- (Anthropic), sk-proj- / sk- (OpenAI), AIza (Google)
PATTERN='(sk-ant-[A-Za-z0-9_-]{20,}|sk-proj-[A-Za-z0-9_-]{20,}|sk-[A-Za-z0-9]{32,}|AIza[0-9A-Za-z_-]{35})'

# Arquivos do projeto atual, ignorando node_modules e .git
grep -rEn --exclude-dir={node_modules,.git,dist} "$PATTERN" . 2>/dev/null \
  | sed -E 's/(sk-ant-|sk-proj-|sk-|AIza)[A-Za-z0-9_-]{6}[A-Za-z0-9_-]*/\1******/g'

# Histórico do git: a chave pode ter sido removida do arquivo, mas não do commit
git log -p --all 2>/dev/null | grep -Eo "$PATTERN" | cut -c1-12 | sort -u

O sed mascara a chave na saída, para você não colar um segredo em um terminal compartilhado ou em um print. Se algo aparecer no histórico do git, revogar é obrigatório: reescrever o histórico não desfaz o fato de a chave ter sido publicada.

Não esqueça os lugares fora do código: secrets de CI (GitHub Actions, Vercel, Railway), variáveis no servidor, o próprio workspace do OpenCode Console e qualquer outra ferramenta de IA onde você colou a mesma chave.

Passo 3: Limite o Estrago Antes do Próximo Incidente

A segunda metade da lição é reduzir o tamanho do prejuízo quando, e não se, uma chave vazar de novo:

Uma chave por serviço. Se o OpenCode, o seu backend e o seu script de testes usam a mesma chave, você precisa trocar tudo de uma vez e não sabe de onde veio o gasto.
Limite de gasto. Na Anthropic, workspaces permitem definir um limite mensal próprio, sempre abaixo do limite da organização, e as chaves ficam presas ao workspace onde foram criadas. Na OpenAI, os limites ficam no nível de organização e de projeto, então crie um projeto separado para cada ferramenta.
Escopo mínimo. O Google recomenda restringir chaves do Gemini apenas à API do Gemini.
Monitoramento por chave, para que uma anomalia apareça logo.

Para o último ponto, dá para montar um alerta simples. O exemplo abaixo, em Node.js, compara o gasto da última hora com a média da semana e dispara um aviso quando o salto é grande. A função fetchHourlySpend é um ponto de integração: ligue nela a API de uso do seu provedor ou o seu próprio log de chamadas.

// spend-alert.mjs - alerta de pico de gasto por chave de API
// fetchHourlySpend(keyId) deve retornar um array com o gasto (US$) das últimas 168 horas
import { fetchHourlySpend } from './usage-source.mjs';

const KEYS = ['opencode-local', 'backend-prod', 'ci-tests'];
const SPIKE_FACTOR = 5; // 5x acima da média já merece atenção
const MIN_ABSOLUTE = 10; // ignora picos abaixo de US$ 10

async function checkKey(keyId) {
  const hours = await fetchHourlySpend(keyId);
  const lastHour = hours.at(-1) ?? 0;
  const history = hours.slice(0, -1);
  const avg = history.reduce((sum, v) => sum + v, 0) / Math.max(history.length, 1);

  // Só alerta quando o salto é relativo E absoluto, para evitar ruído
  if (lastHour > MIN_ABSOLUTE && lastHour > avg * SPIKE_FACTOR) {
    return `Chave ${keyId}: US$ ${lastHour.toFixed(2)} na última hora (média US$ ${avg.toFixed(2)})`;
  }
  return null;
}

const alerts = (await Promise.all(KEYS.map(checkKey))).filter(Boolean);

if (alerts.length > 0) {
  // Troque por Slack, e-mail ou PagerDuty
  console.error('Pico de gasto detectado:\n' + alerts.join('\n'));
  process.exitCode = 1;
}

Rodando isso a cada 15 minutos num cron, um ataque como o do OpenCode seria percebido em minutos, não na manhã seguinte, quando a fatura já fechou em US$ 1.700.

Passo 4: Cuide Também das Chaves Locais

O incidente não atingiu a CLI, mas vale olhar para ela. Chaves salvas localmente estão em texto puro em um arquivo da sua home. Qualquer processo rodando com o seu usuário consegue ler, e isso inclui um pacote npm malicioso ou uma extensão comprometida. O mínimo é garantir que só o seu usuário tenha acesso:

# Confere e corrige a permissão do arquivo de credenciais do OpenCode
AUTH="$HOME/.local/share/opencode/auth.json"

if [ -f "$AUTH" ]; then
  ls -l "$AUTH"          # deve mostrar -rw------- (600)
  chmod 600 "$AUTH"      # leitura e escrita só para o dono
fi

# Bônus: nunca deixe o arquivo entrar em backups sincronizados ou em dotfiles públicos
grep -q "opencode/auth.json" ~/.gitignore_global 2>/dev/null \
  || echo ".local/share/opencode/auth.json" >> ~/.gitignore_global

Permissão de arquivo não protege contra tudo, mas fecha a porta para o vazamento mais bobo: o arquivo indo parar num repositório de dotfiles público.

O Que Ainda Não Sabemos

Para manter os pés no chão, aqui está o que continua em aberto até a publicação deste artigo:

Quantas contas exatamente correspondem aos 1,4% dos usuários do Console.
Como os atacantes entraram no sistema legado e por quanto tempo tiveram acesso.
Como as chaves eram armazenadas e se todas foram de fato copiadas.
Se o rótulo de "ataque de destilação" se confirma ou se é apenas um vazamento com uso indevido das chaves.

Se você usa o Console, acompanhe os canais oficiais do OpenCode e revise o uso das suas chaves pelo menos desde 16 de outubro.

Perspectivas: Chave de API Virou Ativo Financeiro

O incidente do OpenCode mostra que, em 2026, uma chave de API de IA é tratada pelos atacantes como dinheiro, e com razão. Os modelos mais caros custam caro por token, e uma chave sem limite é crédito ilimitado para quem a encontrar. Ao mesmo tempo, plataformas que guardam chaves "para facilitar a vida do time" passam a ser alvos tão valiosos quanto um gateway de pagamento.

A boa notícia é que a defesa não exige nada exótico: uma chave por serviço, limite de gasto em todas, monitoramento por chave e o hábito de testar se a chave antiga morreu de verdade. Quem já fazia isso viu o incidente como notícia. Quem não fazia, viu na fatura.

Bora pra cima! 🦅

📚 Quer Acompanhar o Que Vem Por Aí?

Este artigo cobriu o vazamento de chaves de API no OpenCode Console e como proteger suas chaves de IA, mas o ecossistema muda toda semana e nem tudo vira artigo aqui.

No X eu compartilho o que estou testando, os bastidores dos projetos e as novidades que aparecem antes de virarem post.

Me Segue Lá

👉 Seguir @jeffbruchado no X

💡 Conteúdo diário sobre desenvolvimento, carreira e as ferramentas que eu realmente uso