Segurança

Sequestro de Agentes IA via AGENTS.md (MALFEX) e Ataque Supply Chain no LiteLLM

Análise técnica do sequestro de agentes de codificação IA (Codex e Claude Code) via arquivos AGENTS.md na campanha MALFEX e do ataque supply chain ao gateway LiteLLM v1.107.0 via fork Berri-AI/litellm.

A adoção massiva de assistentes autônomos de codificação em linha de comando — como o OpenAI Codex e o Anthropic Claude Code — ao lado de gateways unificados de modelos de linguagem como o LiteLLM consolidou uma nova camada crítica na infraestrutura de engenharia de software em 2026. Nas últimas horas, porém, relatórios técnicos divulgados por pesquisadores da Forever Security, Datadog Security Labs, Cycode e Socket.dev demonstraram que criminosos cibernéticos passaram a mirar diretamente o elo de confiança entre o desenvolvedor, o agente de Inteligência Artificial e os repositórios de pacotes.

Dois incidentes de alto impacto expuseram a superfície de ataque dessa nova arquitetura: o sequestro silencioso de agentes de codificação locais por meio de arquivos de contexto `AGENTS.md` e `CLAUDE.md` envenenados (distribuindo o pacote malicioso `function-color` vinculado à campanha MALFEX) e o comprometimento da cadeia de suprimentos (Supply Chain) do pacote Python e das imagens de container do LiteLLM versão `1.107.0` no PyPI, Docker Hub e GitHub Container Registry (GHCR).

Sob a ótica da engenharia de segurança defensiva, compreender esses dois vetores é urgente. Quando um agente de IA possui permissão para executar comandos no terminal ou quando um gateway de IA roda com acesso irrestrito às chaves de nuvem da organização, qualquer quebra na validação de contexto transforma ferramentas de produtividade em vetores de exfiltração imediata.

---

1. Anatomia do Sequestro de Agentes de Codificação IA via Arquivos `AGENTS.md` e Campanha MALFEX

O primeiro vetor documentado pela equipe de pesquisa da Forever Security explora um comportamento arquitetural nativo dos agentes modernos de engenharia de software. Para que ferramentas como Claude Code, OpenAI Codex e assistentes similares compreendam os padrões de projeto de uma empresa sem que o programador precise repetir instruções a cada prompt, esses agentes procuram e leem automaticamente arquivos de configuração em texto puro — padronizados sob nomes como `AGENTS.md` ou `CLAUDE.md` — presentes no diretório de trabalho atual ou em pastas superiores da árvore de arquivos.

+-------------------------------------------------------------------------+
|     CADEIA DE ATAQUE: DRIVE-BY DOWNLOAD + INJEÇÃO INDIRETA AGENTS.MD    |
+-------------------------------------------------------------------------+
|                                                                         |
|  1. NAVEGADOR WEB (Drive-by Download Silencioso)                        |
|     O desenvolvedor visita uma página comprometida ou anúncio malicioso |
|     que baixa silenciosamente um arquivo "AGENTS.md" na pasta           |
|     "~/Downloads" (sem exigir clique de execução de binário).           |
|                                  |                                      |
|                                  v                                      |
|  2. INICIALIZAÇÃO DO AGENTE NO DIRETÓRIO CONTAMINADO                    |
|     O desenvolvedor abre o terminal em "~/Downloads" (ou subpasta) e    |
|     inicia o agente de codificação (Codex / Claude Code) para analisar  |
|     um script, planilha ou projeto recém-baixado.                       |
|                                  |                                      |
|                                  v                                      |
|  3. LEITURA AUTOMÁTICA DE CONTEXTO (Indirect Prompt Injection)          |
|     O agente carrega automaticamente "~/Downloads/AGENTS.md" como       |
|     instrução prioritária de ambiente e confia no texto oculto.         |
|                                  |                                      |
|                                  v                                      |
|  4. ALTERAÇÃO DE CONFIGURAÇÃO E EXECUÇÃO DE PAYLOAD (Campanha MALFEX)   |
|     - Modifica "~/.codex/config.toml" registrando servidor externo      |
|     - Executa "npm install function-color" (pacote malicioso MALFEX)    |
|     - Exfiltra tokens OAuth, variáveis ".env" e chaves SSH locais       |
+-------------------------------------------------------------------------+

Por Que a Pasta `~/Downloads` Tornou-se uma Armadilha Silenciosa?

Tradicionalmente, navegadores modernos bloqueiam a execução automática de arquivos `.exe`, `.msi` ou `.sh`, mas permitem que páginas web iniciem o download automático de arquivos de texto inofensivos (como `.md` ou `.txt`) diretamente para o diretório padrão `~/Downloads` do usuário.

  • O Pulo do Gato dos Golpistas: Como um arquivo `AGENTS.md` é apenas texto Markdown, nenhum antivírus tradicional de assinatura o bloqueia no momento do download.
  • A Ativação por Contexto: Dias depois, quando o desenvolvedor baixa um arquivo `.zip` ou script legítimo na pasta `~/Downloads`, abre o terminal naquela pasta e invoca seu agente de codificação IA para inspecionar o código, o agente varre o diretório, encontra o `AGENTS.md` plantado anteriormente e interpreta seu conteúdo como regras obrigatórias de inicialização do projeto.

O Payload Real: `~/.codex/config.toml`, Pacote `function-color` e Malware MALFEX

Na investigação forense reportada pela Forever Security, o arquivo `AGENTS.md` malicioso continha instruções de Injeção Indireta de Prompt (Indirect Prompt Injection) cuidadosamente redigidas para parecerem etapas obrigatórias de preparação de ambiente (bootstrap). O texto instruía o agente autônomo a:

1. Adulterar a Configuração Persistente do Agente: Inserir entradas de servidores de contexto controlados pelo atacante diretamente no arquivo local `~/.codex/config.toml`, garantindo persistência mesmo quando o desenvolvedor mudasse de pasta posteriormente;

2. Instalar Dependência Maliciosa via NPM: Executar silenciosamente a instalação do pacote npm `function-color`, um artefato vinculado à campanha de malware MALFEX (monitorada também por pesquisadores da CloudSEK), projetado para atuar como downloader de segundo estágio, roubar tokens de sessão OAuth e comprometer estações Windows e Linux/macOS.

---

2. O Ataque à Cadeia de Suprimentos do LiteLLM (`v1.107.0`) via Fork `Berri-AI/litellm`

Enquanto o vetor do `AGENTS.md` ataca a estação de trabalho do desenvolvedor pela borda local, o segundo incidente crítico da semana atingiu o coração dos pipelines de produção de IA: a biblioteca e gateway open-source LiteLLM, utilizada por milhares de empresas para padronizar chamadas de API para provedores como OpenAI, Anthropic, Google Vertex AI e AWS Bedrock.

Durante uma janela crítica no dia 21 de outubro de 2026 (entre 11:39 UTC e 13:23 UTC), a versão `1.107.0` do pacote `litellm` publicada no PyPI e as tags correspondentes de containers no Docker Hub e no GitHub Container Registry (GHCR) (`v1.107.0`, `latest`, `main-latest` e `main-stable`) foram envenenadas para distribuir um InfoStealer e um Remote Access Trojan (RAT).

+-------------------------------------------------------------------------+
|     ANATOMIA DO ATAQUE SUPPLY CHAIN NO PIPELINE DO LITELLM v1.107.0     |
+-------------------------------------------------------------------------+
|                                                                         |
|  [ Token OAuth do GitHub CLI Comprometido de Engenheiro Mantenedor ]    |
|                                  |                                      |
|                                  v                                      |
|  [ Criação de Fork Typosquatting: "Berri-AI/litellm" (com hífen) ]      |
|  (Repositório oficial legítimo utiliza "BerriAI/litellm" sem hífen)     |
|                                  |                                      |
|                                  v                                      |
|  [ Acionamento e Aprovação Forjada de Workflow de Release Oficial ]     |
|                                  |                                      |
|          +-----------------------+-----------------------+              |
|          v                                               v              |
|  [ PyPI: litellm==1.107.0 ]             [ Docker Hub / GHCR Images ]    |
|  Injeta hooks ".pth" e                  Contamina tags "v1.107.0",      |
|  "sitecustomize.py" que rodam           "latest", "main-latest" e       |
|  em QUALQUER boot do Python             "main-stable"                   |
|          |                                               |              |
|          +-----------------------+-----------------------+              |
|                                  v                                      |
|  [ EXFILTRAÇÃO TOTAL: Chaves AWS/GCP/Azure, APIs de LLMs e Banco SQL ]  |
+-------------------------------------------------------------------------+

Como os Atacantes Burlaram o Pipeline Oficial?

De acordo com a análise pós-incidente documentada pelo Datadog Security Labs, Cycode e pela própria equipe do LiteLLM:

  • Roubo de Token do GitHub CLI (`gh`): Os invasores obtiveram acesso a tokens OAuth do GitHub CLI pertencentes a engenheiros com privilégio de manutenção no repositório.
  • Abuso de Fork com Hífen (Typosquatting Interno): Utilizando as credenciais roubadas, o grupo malicioso preparou o código adulterado em um fork chamado `Berri-AI/litellm` (diferenciando-se da organização legítima `BerriAI/litellm` por um único hífen) e manipulou o fluxo de publicação para aprovar e empurrar o artefato trojanizado diretamente para os canais oficiais de distribuição no PyPI, Docker Hub e GHCR.

O Perigo dos Hooks `sitecustomize.py` e Arquivos `.pth` no Python

O detalhe técnico mais severo da versão `1.107.0` do LiteLLM — destacado pelos analistas do Cycode e Socket.dev — é o mecanismo de ativação do malware:

  • Em ataques comuns a pacotes Python, o código malicioso só é executado quando a aplicação executa `import nome_do_pacote`.
  • No caso do `litellm==1.107.0`, os atacantes utilizaram arquivos de configuração de caminho (`.pth`) combinados ao módulo `sitecustomize.py` na pasta `site-packages` do ambiente Python.
  • Na arquitetura oficial do interpretador Python, qualquer instrução contida em `sitecustomize.py` ou acionada via linhas `import` dentro de arquivos `.pth` é executada automaticamente toda vez que qualquer processo Python é iniciado naquela máquina ou container, mesmo que o script executado não tenha nenhuma relação com o LiteLLM.
  • Ao ser acionado, o payload executava um InfoStealer programado para varrer variáveis de ambiente, credenciais de nuvem (`AWS_SECRET_ACCESS_KEY`, tokens GCP e Azure), chaves de API de provedores de IA (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`), dados de navegadores locais e as strings de conexão do banco de dados interno do proxy LiteLLM, além de instalar um loader de RAT (backdoor) que consultava um domínio externo (dead-drop) para execução remota de comandos.

---

3. Comparativo Técnico e Indicadores de Comprometimento (IoCs)

Para auxiliar equipes de Blue Team, engenheiros de DevSecOps e praticantes de Ethical Hacking na auditoria imediata de suas estações e clusters de produção, a tabela abaixo consolida os vetores, artefatos e medidas de contenção para ambos os incidentes:

| Vetor / Incidente | Componente / Alvo Afetado | Mecanismo Técnico de Exploração | Indicadores Forenses (IoCs) para Caça a Ameaças | Ação Defensiva e Mitigação Imediata |

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

| Sequestro de Agente via Contexto Local (Campanha MALFEX) | Agentes CLI (`OpenAI Codex`, `Claude Code` e similares) | Drive-by download de arquivo `AGENTS.md` / `CLAUDE.md` na pasta `~/Downloads` com Indirect Prompt Injection | Presença de `AGENTS.md` ou `CLAUDE.md` não autorizados em `~/Downloads` ou `~`; alterações em `~/.codex/config.toml`; tentativa de `npm install function-color` | Nunca iniciar agentes de IA em `~/Downloads` ou `/tmp`; exigir aprovação manual (Human-in-the-Loop) para comandos de shell e edições fora do repositório Git |

| Comprometimento Supply Chain LiteLLM (`v1.107.0`) | Biblioteca Python `litellm` (PyPI) e imagens Docker (`GHCR` / `Docker Hub`) | Token OAuth do GitHub CLI roubado + build via fork `Berri-AI/litellm` injetando hooks `.pth` e `sitecustomize.py` | Pacote `litellm==1.107.0` instalado; imagens Docker baixadas entre `11:39 UTC` e `13:23 UTC` (21/10/2026) nas tags `v1.107.0`, `latest`, `main-latest`, `main-stable` | Fixar (Pin) versão segura `litellm==1.106.2` com hash SHA-256; destruir e recriar containers afetados; rotacionar 100% das chaves de API, nuvem e banco |

| Persistência Silenciosa no Interpretador Python | Ambientes virtuais (`venv`, `conda`) e containers de IA | Execução automática na inicialização do binário `python3` via `site-packages/sitecustomize.py` | Arquivos `.pth` recém-modificados contendo blocos `import os, sys, subprocess` ou `exec(...)` dentro de `lib/python3.*/site-packages/` | Auditar `site-packages` com `find` e `sha256sum`; reconstruir ambientes virtuais do zero a partir de `requirements.txt` ou `poetry.lock` verificados |

---

4. Guia Prático de Auditoria e Blindagem: Como Auditar e Blindar Seu Ambiente de Desenvolvimento e Produção

A lição central ensinada no Ethical Hacking é que conveniência sem isolamento sempre cobra seu preço em segurança. Tanto o ataque via `AGENTS.md` quanto o comprometimento do `LiteLLM v1.107.0` exploram a execução automática sem verificação humana (seja o agente lendo um arquivo Markdown na pasta de downloads e rodando `npm install` sozinho, seja um pipeline de CI/CD puxando a tag `:latest` de um container em produção).

Siga este protocolo técnico de 5 etapas para verificar se sua infraestrutura foi exposta e blindar sua operação:

Passo 1: Varredura Imediata contra Arquivos `AGENTS.md` e `CLAUDE.md` Órfãos

Execute o comando abaixo no terminal da sua estação de trabalho (Linux/macOS) para localizar qualquer arquivo de instrução de agente escondido na sua pasta pessoal, especialmente em `~/Downloads` ou na raiz do usuário (`~`), onde agentes poderiam herdá-lo globalmente:

# Localiza arquivos AGENTS.md e CLAUDE.md fora de repositórios confiáveis
find ~ -maxdepth 3 \( -name "AGENTS.md" -o -name "CLAUDE.md" -o -name ".cursorrules" \) -ls 2>/dev/null

# Verifica se o pacote malicioso function-color (MALFEX) consta em caches ou projetos locais
find ~ -maxdepth 4 -name "package.json" -exec grep -Hn "function-color" {} + 2>/dev/null

Se encontrar qualquer arquivo `AGENTS.md` ou `CLAUDE.md` dentro de `~/Downloads`, inspecione seu conteúdo com `cat` ou `less` antes de excluí-lo e verifique se o arquivo `~/.codex/config.toml` sofreu modificações não reconhecidas.

Passo 2: Auditoria Forense de Versões do LiteLLM e Hooks `.pth` / `sitecustomize.py`

Se a sua empresa utiliza Python ou containers de IA, verifique imediatamente se a versão `1.107.0` do LiteLLM passou por algum servidor ou se existem hooks de inicialização suspeitos nos ambientes virtuais:

# 1. Verifica a versão instalada do litellm em ambientes Python ativos
pip list | grep -i litellm

# 2. Procura por arquivos sitecustomize.py ou usercustomize.py em todo o servidor
find / -name "sitecustomize.py" -o -name "usercustomize.py" 2>/dev/null

# 3. Inspeciona linhas executáveis ("import ") dentro de arquivos .pth no site-packages
grep -rn "^import " /usr/lib/python* /usr/local/lib/python* ~/.local/lib/python* 2>/dev/null

Caso qualquer máquina ou container tenha baixado `litellm==1.107.0` ou utilizado as tags móveis `latest` / `main-latest` / `main-stable` durante a janela do incidente, não basta apenas fazer downgrade do pacote: como o InfoStealer foi desenhado para exfiltrar variáveis de ambiente no primeiro segundo de execução do Python, você deve considerar todas as credenciais daquele ambiente comprometidas e realizar a rotação imediata de chaves da OpenAI, Anthropic, AWS IAM, Google Cloud Service Accounts e senhas de bancos de dados PostgreSQL/Redis conectados ao gateway.

Passo 3: Proibição de Tags Móveis (`:latest`) e Fixação de Digest SHA-256

Em produção, jamais configure arquivos `docker-compose.yml`, manifestos Kubernetes ou pipelines de CI/CD para baixar pacotes sem versão fixa ou imagens com a tag `:latest`.

  • No Python (`requirements.txt`): Utilize `pip-compile` com a flag `--generate-hashes` e instale em produção com `pip install --require-hashes -r requirements.txt`. Além disso, configure um período de quarentena (cooldown de 48 a 72 horas em proxies de artefatos internos como Nexus ou Artifactory) para novas versões publicadas no PyPI, impedindo que sua empresa instale pacotes recém-lançados nas primeiras duas horas de um ataque supply chain.
  • No Docker / Kubernetes: Fixe a versão imutável pelo digest criptográfico da imagem auditada (ex.: `ghcr.io/berriai/litellm@sha256:...`).

Passo 4: Isolamento de Agentes de Codificação IA (Sandboxing e Menor Privilégio)

Nunca execute agentes de codificação autônomos em modo de aprovação cega (`--dangerously-skip-permissions` ou equivalente) diretamente no sistema operacional principal onde residem suas chaves `~/.ssh`, `~/.aws` e cookies de navegador.

  • Inicie agentes de IA exclusivamente dentro da pasta raiz de um repositório Git legítimo e versionado;
  • Configure o navegador web (Chrome/Firefox/Brave) com a opção "Perguntar onde salvar cada arquivo antes de fazer download" ativada, eliminando de vez os drive-by downloads silenciosos na pasta `~/Downloads`;
  • Para análises de código de terceiros ou testes de pacotes desconhecidos, rode o agente dentro de uma DevContainer isolada, máquina virtual ou sandbox sem acesso às credenciais da máquina hospedeira.

---

Perguntas Frequentes (FAQ) sobre o Ataque `AGENTS.md` (MALFEX) e o Incidente LiteLLM `1.107.0`

1. Como um simples arquivo de texto `AGENTS.md` consegue infectar o computador de um desenvolvedor?

O arquivo `AGENTS.md` não é executado sozinho pelo sistema operacional; ele explora a confiança implícita dos agentes de codificação IA (como OpenAI Codex e Claude Code). Quando um site malicioso faz o download silencioso de um `AGENTS.md` na pasta `~/Downloads` e o desenvolvedor posteriormente abre o agente de IA dentro dessa pasta, o agente lê automaticamente o arquivo como se fosse uma instrução legítima de configuração do projeto e executa os comandos embutidos nele (como alterar `~/.codex/config.toml` e rodar `npm install function-color`, instalando o malware da campanha MALFEX).

2. Por que atualizar ou remover o pacote `litellm==1.107.0` não é suficiente se meu servidor baixou essa versão?

Porque o payload malicioso inserido na versão `1.107.0` do LiteLLM utilizava hooks de inicialização do Python (`sitecustomize.py` e arquivos `.pth`) para executar um InfoStealer e um loader de RAT assim que qualquer processo Python iniciava na máquina. Portanto, mesmo que você faça o downgrade para a versão segura `1.106.2`, as chaves de API de LLMs, credenciais AWS/GCP/Azure e senhas de banco de dados presentes nas variáveis de ambiente já podem ter sido enviadas aos servidores dos atacantes, exigindo a revogação e rotação imediata de todos os segredos.

3. Quais são as duas medidas mais rápidas para proteger minha equipe contra esses ataques hoje?

Para proteger as estações dos desenvolvedores contra o golpe do `AGENTS.md`, ative no navegador a opção "Perguntar onde salvar cada arquivo antes de baixar" e proíba a inicialização de agentes de IA fora de repositórios Git dedicados (especialmente em `~/Downloads`). Para proteger servidores contra ataques de cadeia de suprimentos como o do LiteLLM, elimine o uso de tags `:latest` em Docker/Kubernetes, fixe versões exatas com verificação de hash SHA-256 (`--require-hashes`) e utilize ambientes de execução isolados com credenciais de escopo mínimo.