DevSecOps e Supply Chain

Extensão Claude Code Trojanizada no Cursor, Backdoor SSH e o Megaroubo de US$ 6,3 Bi na Binance

Investigação técnica do ataque à cadeia de suprimentos de desenvolvedores: como versões trojanizadas da extensão oficial Claude Code (v2.1.312 e v2.1.313) foram publicadas no Cursor Marketplace com backdoor SSH persistente, e a anatomia do comprometimento de credenciais DevOps que levou ao desvio recorde de US$ 6,3 bilhões na Binance.

Resumo Executivo: O Ponto Cego da Engenharia de Software Moderna

No dia 29 de outubro de 2026, o ecossistema global de desenvolvimento de software e segurança corporativa foi sacudido por dois acontecimentos simultâneos que expuseram a maior fragilidade da infraestrutura digital contemporânea: a confiança cega em ambientes de desenvolvimento local e em extensões de inteligência artificial para IDEs.

Enquanto a maioria das equipes de segurança da informação concentra orçamentos milionários na proteção de perímetros de rede, firewalls de borda e clusters de produção, cibercriminosos avançados migraram o foco para a estação de trabalho do desenvolvedor e do engenheiro DevOps:

1. Ataque de Cadeia de Suprimentos no Cursor Marketplace: Versões maliciosas (`2.1.312` e `2.1.313`) da extensão oficial [Claude Code da Anthropic](https://cursor.com) foram inseridas diretamente no catálogo de extensões do editor [Cursor](https://cursor.com), permanecendo ativas por cerca de 11 horas e atingindo até 5.000 programadores com um payload desenhado para furtar segredos de ambiente e plantar backdoors SSH permanentes via `~/.ssh/authorized_keys`.

2. O Megaroubo de US$ 6,36 Bilhões na Binance via Credencial DevOps: No mesmo dia, a maior exchange de criptomoedas do mundo vinculou a extração não autorizada de US$ 6,36 bilhões em ativos digitais ao comprometimento do computador de um engenheiro de operações (DevOps), que permitiu a agentes maliciosos burlar barreiras de validação e manipular pipelines internos de saque.

Neste dossiê técnico da HG Soluções, analisamos o mecanismo de injeção de código do payload do Cursor, os erros de execução que limitaram o alcance do exploit e o protocolo completo de contenção, rotação de segredos e blindagem para estúdios de software e equipes de engenharia.

---

1. A Anatomia do Ataque no Cursor: Como a Extensão Oficial Foi Trojanizada

O editor de código Cursor (baseado no núcleo open-source do Visual Studio Code) ganhou tração maciça na indústria por integrar modelos de linguagem diretamente no fluxo de edição, terminal e depuração de código. Para fornecer extensões ao seu ecossistema, a plataforma mantém um marketplace proprietário de plugins.

Conforme reportado em detalhes investigativos pelo [BleepingComputer](https://www.bleepingcomputer.com) e pelo [The Hacker News](https://thehackernews.com/2026/10/cursor-extension-claude-code-trojanized.html), invasores conseguiram realizar o upload das versões adulteradas `2.1.312` e `2.1.313` do pacote `anthropic.claude-code` diretamente no marketplace do Cursor, preservando o identificador do desenvolvedor e o visual oficial da Anthropic.

+-----------------------------------------------------------------------------------+
|         FLUXO DE INVASÃO DA EXTENSÃO CLAUDE CODE NO CURSOR (v2.1.313)             |
+-----------------------------------------------------------------------------------+
|                                                                                   |
|  [1. Desenvolvedor abre o Cursor e atualiza extensões automaticamente]            |
|         |                                                                         |
|         v                                                                         |
|  [2. Marketplace do Cursor entrega build adulterada (2.1.312 / 2.1.313)]          |
|         |                                                                         |
|         v                                                                         |
|  [3. Inicialização do Plugin no Runtime Node.js do Editor]                        |
|      -> Executa IIFE (Immediately Invoked Function Expression) ofuscada           |
|         |                                                                         |
|         +---> Coleta de Telemetria e Segredos Locais                              |
|         |     (whoami, git config user.email, env vars, chaves AWS/GCP, .env)     |
|         |                                                                         |
|         +---> Exfiltração HTTP POST para Servidor de Comando & Controle (C2)      |
|         |                                                                         |
|         +---> Injeção de Chave Pública em ~/.ssh/authorized_keys                  |
|         |                                                                         |
|         +---> Tentativa de Abertura de Túnel SSH Reverso em Porta Alta            |
|         |                                                                         |
|         +---> Criação de Persistência no Sistema Operacional                      |
|               (Cron / LaunchAgents no macOS e Linux; Scheduled Tasks no Windows)  |
+-----------------------------------------------------------------------------------+

O Posicionamento Oficial da Anthropic

Logo após a detecção do incidente, a [Anthropic emitiu um comunicado público](https://ycombinator.com) esclarecendo pontos cruciais de governança e segurança:

  • Zero Invasão Interna na Anthropic: Os servidores internos, repositórios de código-fonte, laptops de colaboradores e credenciais da Anthropic não foram comprometidos.
  • Canais Oficiais Íntegros: Os canais primários de distribuição gerenciados diretamente pela Anthropic — incluindo o registro público [npm](https://www.npmjs.com) e o oficial [Microsoft Visual Studio Marketplace](https://marketplace.visualstudio.com) — permaneceram 100% íntegros e livres de qualquer adulteração.
  • Falha na Cadeia de Publicação do Marketplace Secundário: A invasão ocorreu especificamente na esteira de publicação ou nas chaves de autenticação utilizadas pelo marketplace independente mantido pela equipe do Cursor.

---

2. Engenharia Reversa do Payload: Coleta de Segredos, Chave SSH e Persistência

Ao inspecionar o arquivo JavaScript principal empacotado na extensão `anthropic.claude-code-2.1.313.vsix`, analistas de segurança da [Sophos](https://www.sophos.com) e da comunidade de código aberto identificaram uma função imediatamente invocada (IIFE) que iniciava operações assíncronas no momento em que o editor de código era aberto.

Etapa 1: Reconhecimento e Furto de Variáveis de Ambiente

Como as extensões do VS Code e Cursor executam no contexto do processo Node.js local da máquina do usuário (com permissões completas de leitura no sistema de arquivos do usuário logado), o script lia o objeto global `process.env` e executava comandos utilitários de terminal:

  • Leitura das variáveis de ambiente: chaves de acesso da AWS (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`), credenciais do Google Cloud (`GOOGLE_APPLICATION_CREDENTIALS`), tokens do GitHub/GitLab, chaves de bancos de dados locais e strings de conexão de arquivos `.env` abertos na área de trabalho.
  • Coleta de dados de identidade: execução silenciosa de `whoami`, `hostname`, `uname -a` e consulta à configuração global do Git (`git config --global user.email`).
  • Exfiltração imediata dos dados coletados via requisição HTTPS POST criptografada para o servidor de comando e controle (C2) dos criminosos.

Etapa 2: Plantação do Backdoor SSH (`authorized_keys`)

A ação mais audaciosa do malware era a tentativa de criar um canal permanente de acesso remoto direto ao computador do programador. O script procurava o diretório SSH padrão do usuário (`~/.ssh` no Linux/macOS ou `%USERPROFILE%\.ssh` no Windows):

# Simulação da rotina executada pelo payload malicioso da extensão
mkdir -p ~/.ssh && chmod 700 ~/.ssh
echo "ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAI... [malicious_key] support@dev-cloud-sync" >> ~/.ssh/authorized_keys
chmod 600 ~/.ssh/authorized_keys

Se o computador do desenvolvedor tivesse o serviço de servidor SSH (`sshd`) ativo — situação extremamente comum em estações Linux de engenharia e servidores de desenvolvimento remoto —, o invasor passava a conseguir autenticar-se diretamente no terminal da máquina a qualquer momento com privilégios completos de usuário.

Por Que Muitos Ataques Falharam?

Relatórios técnicos publicados pelo [Cursor](https://cursor.com) apontaram que, apesar da gravidade estrutural, a execução completa do backdoor falhou na maioria das máquinas afetadas por três fatores operacionais:

1. Ausência de Servidor SSH Ativo por Padrão: A esmagadora maioria dos computadores com Windows e macOS não possui o serviço `sshd` habilitado para receber conexões de entrada por padrão.

2. Erros de Código no Script de Túnel Reverso: A rotina que tentava estabelecer o túnel reverso caso a porta 22 estivesse bloqueada possuía erros de sintaxe em determinados ambientes de shell.

3. Privilégios Restritos: A criação de serviços permanentes no `systemd` ou no registro do Windows falhava silenciosamente quando o editor Cursor era executado com privilégios de usuário comum (não-administrador).

4. Remoção Rápida da Infraestrutura C2: A infraestrutura de servidores utilizada para receber os dados roubados foi desmantelada e colocada em lista de bloqueio poucas horas após o alerta inicial.

A equipe do Cursor desativou temporariamente o marketplace, removeu os pacotes comprometidos e publicou a atualização limpa oficial `2.1.314`.

---

3. A Conexão com o Megaroubo de US$ 6,36 Bilhões na Binance

O incidente da extensão Claude Code ilustra com precisão cirúrgica por que a máquina do engenheiro de software tornou-se o alvo prioritário dos maiores grupos cibercriminosos do mundo. Horas após o incidente no Cursor, a exchange de criptomoedas Binance confirmou que o maior furto da história do setor — US$ 6,36 bilhões em múltiplos criptoativos — teve como ponto de entrada o computador de um engenheiro DevOps.

+-----------------------------------------------------------------------------------+
|     DA ESTAÇÃO DO DESENVOLVEDOR AO DESVIO BILIONÁRIO: A CADEIA DE EXPLORAÇÃO      |
+-----------------------------------------------------------------------------------+
|                                                                                   |
|  [Laptop do Engenheiro DevOps Comprometido (Malware em IDE / Extensão / Phishing)] |
|         |                                                                         |
|         v                                                                         |
|  [Extração de Tokens de Sessão em Cache, Chaves SSH e Arquivos .kube/config]     |
|         |                                                                         |
|         v                                                                         |
|  [Acesso Direto aos Pipelines de CI/CD e Infraestrutura de Orquestração]          |
|         |                                                                         |
|         v                                                                         |
|  [Injeção de Instruções de Saque nos Contratos Inteligentes e Wallets Quentes]    |
|      -> Sem necessidade de quebrar a criptografia dos nós da blockchain!          |
+-----------------------------------------------------------------------------------+

Lições Críticas do Incidente Binance:

1. A Máquina DevOps É a Chave Mestra: Engenheiros de confiabilidade de sites (SRE) e DevOps possuem em suas máquinas locais certificados TLS corporativos, arquivos de configuração do Kubernetes (`~/.kube/config`), chaves de túneis VPN e tokens com poder de aprovação em esteiras de automação (GitHub Actions, GitLab CI, Terraform).

2. A Criptografia da Blockchain Não Protege Contra Credencial Comprometida: Nenhum algoritmo criptográfico (SHA-256, ECDSA, Ed25519) foi quebrado. O atacante utilizou credenciais legítimas extraídas do computador invadido para assinar operações como se fosse o operador autorizado.

3. Princípio de Múltipla Autorização Obrigatória (Multi-Party Computation — MPC): Ambientes de missão crítica financeira e infraestruturas vitais não podem permitir que ações de impacto catastrófico dependam da aprovação de um único computador ou de uma única chave privada.

---

4. Tabela Comparativa: Vetores de Ameaça em Extensões de IDE vs. Defesas Ativas

| Vetor de Risco em Extensões de IDE | Como Foi Explorado no Claude Code (v2.1.313) | Consequência no Ambiente de Desenvolvimento | Controle Defensivo Obrigatório (DevSecOps) |

| :--- | :--- | :--- | :--- |

| Acesso Irestrito a Variáveis de Ambiente | Leitura direta de `process.env` no runtime Node.js | Vazamento imediato de chaves de API, AWS Secrets e tokens de banco | Utilização de ferramentas como `direnv` com sanitização e cofres de segredos (HashiCorp Vault, AWS Secrets Manager) |

| Manipulação do Sistema de Arquivos Local | Escrita forçada de chaves públicas em `~/.ssh/authorized_keys` | Criação de porta dos fundos para acesso SSH persistente na máquina | Bloqueio de permissão de escrita em `~/.ssh` (`chmod 500 ~/.ssh`) e monitoramento EDR de arquivos de autenticação |

| Execução de Processos Filhos (`child_process`) | Execução de comandos de reconhecimento (`whoami`, `uname`, `git config`) | Mapeamento da rede interna e da identidade do colaborador | Bloqueio de execução de shells a partir de binários de editores de código via políticas de AppLocker/SELinux |

| Comunicação de Rede Não Monitorada | Requisições HTTPS para endpoints C2 externos não homologados | Exfiltração de código-fonte e metadados de projetos | Inspeção de tráfego de saída de estações de TI e bloqueio de domínios sem histórico reputacional |

| Atualização Automática sem Pinning de Hash | Instalação automática da versão maliciosa `2.1.313` | Comprometimento em massa de até 5.000 programadores em 11 horas | Desativação de atualizações automáticas de extensões; adoção de repositório privado interno de plugins homologados |

---

5. Protocolo Prático de Auditoria e Limpeza para Desenvolvedores

Se você utiliza o Cursor, o VS Code ou extensões de inteligência artificial em sua estação de trabalho, execute imediatamente este checklist técnico de quatro passos:

Passo 1: Verificar e Limpar Chaves Não Autorizadas no SSH

Inspecione minuciosamente o conteúdo de `~/.ssh/authorized_keys` no Linux e macOS:

#!/usr/bin/env bash
# Auditoria de chaves SSH autorizadas
set -euo pipefail

echo "=== Inspecionando ~/.ssh/authorized_keys ==="
if [ -f ~/.ssh/authorized_keys ]; then
    cat ~/.ssh/authorized_keys
    echo "------------------------------------------------"
    echo "Verifique se alguma chave listada acima não foi gerada por você!"
else
    echo "[OK] Nenhum arquivo authorized_keys encontrado no perfil local."
fi

# Bloquear permissão de escrita arbitrária na pasta .ssh
chmod 700 ~/.ssh
[ -f ~/.ssh/authorized_keys ] && chmod 600 ~/.ssh/authorized_keys

Passo 2: Auditar Tarefas Agendadas e Processos Suspeitos

No Linux e macOS, verifique se foram criadas rotinas de persistência:

# Verificar crontabs do usuário atual
crontab -l || echo "[OK] Nenhum crontab ativo."

# No macOS, verificar LaunchAgents do usuário
ls -la ~/Library/LaunchAgents/ 2>/dev/null || true

# Verificar processos ouvindo em conexões de rede
ss -tulnp 2>/dev/null || netstat -tulnp 2>/dev/null

Passo 3: Confirmar a Versão da Extensão no Cursor

1. Abra o Cursor, acerte o atalho `Ctrl + Shift + X` (ou `Cmd + Shift + X` no macOS) para abrir a aba de Extensões.

2. Localize Claude Code.

3. Confirme que a versão instalada é a `2.1.314` ou superior. Se identificar as versões `2.1.312` ou `2.1.313`, desinstale imediatamente, encerre o editor e execute a auditoria de chaves acima.

Passo 4: Rotacionar Credenciais Críticas

Por medida de segurança preventiva:

  • Rotacione todas as chaves de API presentes em arquivos `.env` locais que estavam abertos no editor.
  • Gere novos Personal Access Tokens (PATs) no GitHub e GitLab.
  • Invalide sessões ativas de AWS CLI e Google Cloud SDK executando `aws sts get-caller-identity` e gerando novos pares de chaves.

---

6. Fontes Primárias e Referências Técnicas

1. Cursor Marketplace Security Incident & Advisory: [Cursor Official Update](https://cursor.com) e notas da comunidade de engenharia.

2. Anthropic Official Statement on Claude Code Integrity: [Anthropic Technical Advisory](https://ycombinator.com).

3. BleepingComputer Cybersecurity Coverage: [Malicious Claude Code extension on Cursor marketplace targets developers](https://www.bleepingcomputer.com).

4. The Hacker News Global Reporting: [Official Claude Code Extension on Cursor Marketplace Trojanized](https://thehackernews.com/2026/10/cursor-extension-claude-code-trojanized.html).

5. Sophos Threat Intelligence & Supply Chain Analysis: [Análise técnica de vetores de persistência em extensões Node.js](https://www.sophos.com).