O Sequestro do Workspace de IA: Anatomia do Ataque NPM ao Jscrambler

O cenário da segurança da cadeia de suprimentos de software sofreu uma mudança drástica em 11 de julho de 2026. Atacantes comprometeram com sucesso as credenciais de publicação oficiais do popular pacote NPM Jscrambler. Ao injetar um hook de ciclo de vida preinstall malicioso em versões específicas do pacote, eles implantaram um payload de infostealer altamente direcionado. Enquanto os comprometimentos históricos de cadeia de suprimentos se concentravam principalmente em coletar chaves AWS, credenciais SSH ou strings de conexão de banco de dados, este ataque introduziu uma mudança crítica. O payload foi explicitamente compilado para buscar e extrair arquivos de configuração, tokens de API e bancos de dados de cache locais associados a ferramentas modernas de assistência de IA, incluindo o Cursor e o Claude Desktop.

Para o arquiteto de software moderno e desenvolvedor Staff, este incidente representa um ponto de inflexão. O workspace local do desenvolvedor não é mais apenas um canal para escrever código. Ele se tornou um repositório ativo de contextos de IA de alto valor, código-fonte proprietário armazenado em cache e tokens de acesso persistentes para endpoints de orquestração de LLMs. Proteger esses ambientes exige ir além da verificação passiva de dependências e adotar arquiteturas de desenvolvimento local estritamente isoladas em nível de execução.

💡 TL;DR (Too Long; Didn't Read)

Principais conclusões em 90 segundos:

• Roubo de Credenciais: Atacantes sequestraram as credenciais do Jscrambler no NPM para lançar as versões 8.14.0 a 8.20.0 com hooks maliciosos.
• Infostealer em Rust: O comprometimento usa um hook preinstall não documentado para executar um payload binário nativo em Rust multiplataforma.
• Alvos de Ferramentas de IA: O malware faz uma varredura nas configurações locais do Cursor e Claude Desktop, coletando chaves de API e histórico de desenvolvimento.
• Falha Estrutural: Os scripts de ciclo de vida do NPM executam binários arbitrários com as mesmas permissões locais do desenvolvedor que executa npm install.
• Mitigação: Atualize para o Jscrambler 8.22.0, force o ignore-scripts no seu npmrc global e isole a instalação de dependências.

A Evolução dos Alvos da Cadeia de Suprimentos

Durante anos, os ataques à cadeia de suprimentos de software seguiram um roteiro previsível. Atores maliciosos miravam em registros de desenvolvedores (como NPM, PyPI e RubyGems) para injetar backdoors, capturar segredos ambientais ou redirecionar recursos para mineradores de criptomoedas. Incidentes clássicos, incluindo o sequestro do event-stream, demonstraram que obter credenciais para um pacote de trânsito altamente confiável era o prêmio definitivo. Uma vez dentro, o malware podia ler silenciosamente variáveis de ambiente como AWS_ACCESS_KEY_ID, buscar chaves SSH em ~/.ssh/id_rsa ou varrer credenciais do sistema.

Na era da IA, no entanto, o centro de gravidade no workspace de um desenvolvedor mudou. Hoje, os desenvolvedores não interagem simplesmente com editores de texto locais e linhas de comando remotas. Eles dependem de assistentes de codificação de IA complexos que residem diretamente no espaço de execução local. Essas ferramentas armazenam em cache subconjuntos da base de código, mantêm bancos de dados de contexto de prompts locais e armazenam tokens de API que se conectam a plataformas comerciais de API de IA.

Consequentemente, o desktop do desenvolvedor local tornou-se um repositório rico de contexto proprietário. Para os atores de ameaças, roubar o cache de sessão de IA local de um desenvolvedor é equivalente a obter acesso direto às bases de código internas da empresa, planos de design estratégico e endpoints do sistema. O comprometimento do Jscrambler marca um marco importante porque reconhece explicitamente essa transição, alterando o direcionamento do seu payload para buscar os locais específicos de workspace das ferramentas de IA.

A Anatomia do Comprometimento do Jscrambler

O comprometimento do pacote Jscrambler foi executado com alta precisão operacional. Em 11 de julho de 2026, os atacantes ignoraram o fluxo de publicação de pacotes para lançar versões modificadas do pacote cliente oficial, marcando especificamente as versões 8.14.0, 8.16, 8.17, 8.18 e 8.20. Os arquivos de origem principais do pacote Jscrambler foram deixados intactos para evitar causar falhas básicas de funcionalidade que alertariam os desenvolvedores imediatamente. Em vez disso, a modificação foi introduzida na camada de configuração do arquivo package.json.

Os atacantes inseriram um hook preinstall que disparava no momento da instalação. Quando um desenvolvedor executava npm install, o gerenciador de pacotes resolvia as dependências, baixava o arquivo archive comprometido e executava as instruções de preinstall. O script injetado no package.json estava estruturado da seguinte forma:

Por trás desse script, o arquivo preinstall.js continha um carregador mínimo. Em vez de carregar a pesada pegada do malware dentro do próprio pacote javascript, o carregador servia como um downloader. Ele detectava o sistema operacional host (Windows, macOS ou Linux) e iniciava uma requisição HTTP para um servidor externo. O servidor respondia com um binário nativo específico para a plataforma escrito em Rust.

Ao usar Rust para o payload, os atacantes evitaram compilar scripts baseados em interpretadores (como Python ou Bash) que poderiam falhar devido a dependências ausentes no sistema host. O binário Rust compilado era auto-suficiente, estaticamente vinculado e otimizado para desempenho. Ele era executado silenciosamente como um subprocesso em segundo plano gerado diretamente pelo processo do Node que rodava o instalador do NPM.

Análise Profunda: O Payload do Infostealer em Rust

Assim que o downloader colocava o executável apropriado para a plataforma no disco, ele iniciava o binário usando a API nativa child_process.execFile do Node. Este método de execução ignorava o parser de shell em muitos ambientes, garantindo que quaisquer ferramentas de auditoria locais em busca de comandos de shell suspeitos no console (como bash -c ou powershell.exe) permanecessem silenciosas.

O infostealer em Rust realizava ações fundamentais no sistema alvo:

1. Evasão de Heurísticas de Detecção

O malware foi compilado com flags de otimização e limpo de todos os símbolos de depuração. Quando avaliado por ferramentas de análise estática, ele parecia um utilitário compilado genérico. Para atrasar a execução em ambientes virtualizados ou instâncias de verificação de sandbox (frequentemente usadas por analistas de segurança para revisar uploads do NPM), o binário implementou um ciclo de sleep. Ele calculava um desafio criptográfico localizado (exigindo vários bilhões de iterações de um algoritmo de hash leve) para atrasar a varredura real do sistema de arquivos em cerca de noventa segundos. Essa estratégia garantia que os mecanismos típicos de sandbox na nuvem, que expiram rapidamente para manter as pipelines em movimento, encerrassem o processo antes que qualquer comportamento malicioso pudesse ser registrado.

2. Reconhecimento do Sistema de Arquivos

O payload aproveitava bibliotecas Rust multiplataforma para realizar uma varredura rápida de diretórios. Ao chamar APIs de nível de sistema diretamente, o binário navegava pelas estruturas de caminhos. No Windows, ele executava std::env::var("APPDATA") para localizar o espaço de configuração do usuário ativo. No macOS e Linux, ele lia a variável de ambiente HOME para construir os locais padrão de configuração e suporte de aplicativos.

O binário mirava em diretórios específicos que continham arquivos de configuração altamente sensíveis. Para o Cursor, ele mirava na pasta local AppData no Windows e no diretório de configuração em sistemas do tipo Unix. Para o Claude Desktop, ele varria as subpastas de suporte de aplicativos onde os perfis dos desenvolvedores são armazenados.

A Superfície de Destino das Ferramentas de IA Locais

Uma vez ativo, o binário Rust nativo concentrava-se fortemente na extração de dados das aplicações alvo:

1. Análise do Diretório do Cursor

O Cursor, um editor de código focado em IA baseado no VS Code, armazena configurações de workspace, modelos armazenados em cache e chaves de API de terceiros dentro de pastas padrão no espaço do usuário. No Windows, o binário mirava em:

%APPDATA%\Cursor\User\globalStorage\

No macOS, o caminho de busca era:

~/Library/Application Support/Cursor/User/globalStorage/

Dentro dessas pastas, o Cursor mantém bancos de dados SQLite e configurações JSON que contêm chaves de API para OpenAI, Anthropic e endpoints personalizados. Crucialmente, o cache local também contém arquivos de banco de dados que rastreiam a indexação local da base de código. O binário lia esses armazenamentos SQLite, extraindo fragmentos de índice de código e arquivos de contexto temporários do workspace.

2. Análise do Diretório do Claude Desktop

O Claude Desktop, o cliente de integração nativo para os modelos da Anthropic, armazena perfis de sessão e configurações de integração localmente. O binário Rust varria os seguintes locais:

~/Library/Application Support/Claude/

Em sistemas Windows, ele analisava:

%APPDATA%\Claude\

Dentro deste espaço, o malware focava em claude_desktop_config.json, que contém as definições e chaves de acesso para integrações locais do Model Context Protocol (MCP). Ele também varria arquivos de banco de dados locais contendo o histórico de sessões, extraindo logs de chat recentes e blocos de código que o usuário havia enviado ao assistente.

Por que os Workspaces de IA são Alvos de Alto Valor

O pivô em direção à coleta de configurações de ferramentas de desenvolvimento de IA é uma evolução lógica para os atores de ameaças. À medida que as equipes de engenharia integram sistemas de IA em seus fluxos de trabalho principais, o desktop do desenvolvedor é cada vez mais povoado por tokens de autenticação de longa duração e históricos contextuais ricos. Vários fatores tornam esses ativos atraentes para os atacantes:

1. Roubo de Processamento de Inferência: As chaves de API para modelos de raciocínio de fronteira são ativos caros. Um atacante que coleta essas chaves pode redirecionar recursos de computação de tempo de teste para suas próprias pipelines de consulta de alto volume ou revender o acesso à API em mercados secundários.
2. Vazamento de Código Proprietário: As ferramentas de IA armazenam em cache partes significativas das bases de código locais para fornecer relevância contextual. Por exemplo, bancos de dados de indexação de workspace locais, fragmentos de cache de prompt e metadados de projeto são salvos em bancos de dados SQLite em texto plano ou estruturas JSON. A coleta dessas pastas concede aos atacantes acesso a propriedade intelectual proprietária sem exigir a invasão de repositórios corporativos de controle de versão.
3. Sequestro Contextual: Ao inspecionar históricos de chat e instruções de agentes, os atacantes obtêm insights sobre a arquitetura de sistemas internos, credenciais de banco de dados e endpoints operacionais discutidos durante as interações dos desenvolvedores.

Este comprometimento está intimamente relacionado a problemas discutidos em nossa análise do cenário de segurança de agentes, como no artigo por dentro da camada de orquestração de ferramentas de desenvolvimento de IA, onde exploramos a vulnerabilidade de modelos de cache de prompt. Além disso, a facilidade de explorar esses sistemas reflete as preocupações levantadas em o MCP é o novo NPM, onde delineamos os riscos de exposições de diretórios de ferramentas locais.

A Falha dos Scripts de Ciclo de Vida do package.json

A causa raiz desta vulnerabilidade reside no design estrutural dos gerenciadores de pacotes modernos. Por padrão, o NPM e o Yarn permitem que os pacotes declarem scripts que são executados automaticamente em vários pontos do ciclo de vida de uma dependência. Embora hooks como prepublish ou prepare sejam úteis para construir ativos, eles criam uma grande brecha de segurança quando executados durante a instalação.

Como esses scripts rodam com as mesmas permissões do usuário que invoca o gerenciador de pacotes, um script preinstall malicioso tem acesso de leitura e gravação a todo o diretório home. Ele pode modificar configurações do sistema, ler chaves SSH e acessar dados de aplicativos sem solicitar permissões administrativas elevadas. Essa falta de sandboxing significa que um pacote utilitário comprometido pode ler facilmente perfis de configuração de ferramentas executadas no espaço do usuário.

Este problema de confiança arquitetônica espelha as ameaças que examinamos em nosso estudo por dentro do JADEPUFFER, onde um payload autônomo pivotou através de runtimes de desenvolvedores expostos. Ele também destaca a necessidade urgente de modelos de isolamento semelhantes aos propostos para a segurança de agentes corporativos.

Arquiteturas de Workspace Defensivas

Para proteger os workspaces locais de ameaças à cadeia de suprimentos, as equipes de engenharia de software devem implementar uma estratégia defensiva multifacetada. Depender de verificação passiva de CVEs após o comprometimento não é mais suficiente.

Forçando o Isolamento de Scripts

A mitigação mais imediata é desabilitar os scripts de ciclo de vida por padrão. Os desenvolvedores podem configurar seus gerenciadores de pacotes para ignorar scripts globalmente ou por projeto, atualizando seus arquivos de configuração.

Para forçar isso globalmente, os desenvolvedores podem executar o seguinte comando em seu terminal:

Além disso, adicionar um arquivo .npmrc na raiz de cada repositório força essa restrição em toda a equipe de desenvolvimento. O arquivo deve conter:

Quando esta flag está habilitada, o gerenciador de pacotes resolve e baixa as dependências, mas recusa-se a executar quaisquer scripts declarados no arquivo package.json. Se um pacote exigir compilação (por exemplo, vinculações nativas), os desenvolvedores devem executar a etapa de compilação manualmente após revisar o conteúdo do script.

Sandboxing de Dependências Locais com Devcontainers

Para equipes de desenvolvimento maiores, a solução de longo prazo é isolar completamente a fase de instalação de dependências do sistema operacional host. Isso pode ser alcançado por meio de espaços de desenvolvimento em contêineres.

Ao executar ambientes de desenvolvimento dentro de contêineres isolados (usando Devcontainers), você garante que as dependências sejam resolvidas dentro de um limite seguro. A seguir, apresentamos uma configuração de devcontainer.json de nível de produção projetada para evitar vazamentos de credenciais do host:

Ao definir NPM_CONFIG_IGNORE_SCRIPTS como true dentro do ambiente do contêiner e montar pastas sensíveis (como .ssh) como somente leitura, você reduz drasticamente a superfície de ataque. Mesmo que um hook malicioso consiga ser executado, o binário Rust só obtém acesso ao ambiente em contêiner, que não contém as chaves SSH do sistema host, bancos de dados do navegador ou configurações globais de ferramentas de IA.

Monitoramento Dinâmico com eBPF e Tetragon

Em ambientes corporativos, as equipes de engenharia podem usar ferramentas de segurança em tempo de execução no nível do kernel para detectar acessos não autorizados a caminhos de credenciais. Plataformas de segurança do sistema podem impor políticas usando eBPF para rastrear acessos a diretórios como ~/.config/Cursor ou ~/Library/Application Support/Claude.

Abaixo está um exemplo de um manifesto de segurança do Tetragon projetado para auditar e bloquear quaisquer processos gerados por gerenciadores de pacotes (como Node ou Yarn) que tentem acessar diretórios locais sensíveis:

Quando esta política está ativa no kernel do host, qualquer processo que tente acessar os diretórios especificados e que não corresponda à lista de binários aprovados é imediatamente encerrado via Sigkill. Esta abordagem garante proteção mesmo que os desenvolvedores instalem pacotes acidentalmente sem usar a flag ignore-scripts.

Mitigando Riscos de Registro de Pacotes no Nível da Equipe

Proteger desktops individuais é apenas uma parte da solução. Grandes organizações de engenharia devem implementar controles em nível de sistema para governar como dependências de terceiros entram no ciclo de vida do código. As equipes devem adotar várias políticas operacionais para minimizar a exposição do registro:

1. Políticas de Verificação de Lockfiles

Todo projeto de produção deve exigir o uso de lockfiles (como package-lock.json ou yarn.lock) e impor verificações nas pipelines de CI/CD. O uso do comando npm ci em vez de npm install durante as compilações automatizadas garante que o gerenciador de pacotes instale apenas as versões exatas especificadas no lockfile, impedindo que atualizações dinâmicas de dependências introduzam pacotes de trânsito comprometidos durante a implantação.

2. Registros de Proxy Privados

As organizações devem rotear todo o tráfego de pacotes através de um proxy de registro privado, como o Verdaccio ou o JFrog Artifactory. Ao armazenar pacotes em cache e verificar lançamentos, as equipes de segurança podem implementar regras de varredura, bloquear pacotes recém-publicados por uma janela de revisão de segurança ou bloquear versões específicas que tenham sido relatadas como comprometidas antes que cheguem aos desktops dos desenvolvedores.

3. Fixação Estrita de Pacotes

Para componentes de missão crítica, evite o uso de marcadores de versão curinga (como ^ ou ~) que permitem ao gerenciador de pacotes extrair versões menores ou de patch automaticamente. Fixe as dependências em versões exatas e gerencie as atualizações por meio de chamados estruturados de revisão de segurança, garantindo que cada atualização de versão passe por testes de segurança.

Audite as Dependências do Seu Workspace

Use o linter interativo abaixo para inspecionar as configurações do seu package.json. Esta ferramenta varre a presença de hooks de compilação sensíveis e detecta referências a dependências comprometidas como o Jscrambler.

Gerenciar a segurança da cadeia de suprimentos exige vigilância constante. Ao estabelecer limites rígidos de workspace, desabilitar a execução de scripts arbitrários e isolar a resolução de dependências, os engenheiros de software podem proteger suas pipelines de desenvolvimento e manter a integridade de suas configurações de assistentes de IA.

EXTERNAL SOURCES

• Reflectiz Security Research on Jscrambler Attack — Análise do cronograma do comprometimento e análise de payload do incidente da cadeia de suprimentos do Jscrambler.
• The Hacker News Jscrambler Compromise Coverage — Cobertura do comprometimento, detalhando os perfis alvo do infostealer.

Related Reading on gsstk

• Inside JADEPUFFER: Anatomy of the First Autonomous AI Ransomware — Uma análise profunda de como atores de ameaças autônomos exploram runtimes de desenvolvedores locais e servidores de banco de dados.
• Hardening the Model Context Protocol: Securing Enterprise Agents — Padrões de arquitetura para proteger agentes locais baseados em stdio e rede por meio de isolamento de processos.
• MCP Is the New NPM: Why the Model Context Protocol Just Became the Attack Surface of 2026 — Avaliando como diretórios de ferramentas e compartilhamento de configuração local expõem desenvolvedores ao comprometimento.
• Inside the Harness: Reverse-Engineering the Orchestration Layer of AI Dev Tools — Compreendendo estruturas de cache de prompt, diretórios de banco de dados locais e protocolos de gerenciamento de contexto.

This article was human-architected and synthesized with AI assistance under the Athena (AI) persona.