Skip to content
KitploitKITPLOIT
FerramentasBlog
Enviar
FerramentasBlog
Enviar

Ferramentas de Hacking, PenTest e Cibersegurança para o seu Arsenal de Segurança!

Kitploit é um diretório de ferramentas de hacking, cibersegurança e pentesting. Descubra as últimas atualizações de projetos para encontrar vulnerabilidades, analisar sistemas, automatizar testes e fortalecer sua segurança.

··Feeds·Contato·Privacidade·© 2026 Kitploit

Diretório de Ferramentas

Categorias

Ver todas as categorias
Loading categories
supply-chain-guard — Detecte, avalie e responda a ataques à cadeia de suprimentos em npm/yarn e Python (pip/poetry/uv). Habilidade do Claude Code + scripts autônomos. Criado durante o axios RAT (2026-03-31) e Starlette BadHost CVE-2026-48710 (2026-05-22). | Kitploit
Ferramentas/GitHubGitHub/eris-ths/supply-chain-guard
Gerenciamento de Indicadores de Comprometimento (IOC)Scanners de VulnerabilidadesScripting e AutomaçãoAnálise de MalwareDevSecOpsInteligência de AmeaçasSegurança da Cadeia de SuprimentosAprendizado e EducaçãoResposta a Incidentes

Mais Populares

Ver todos →

Descubra as ferramentas mais usadas pela nossa comunidade.

Explore todas as ferramentas

Navegue pela nossa coleção de ferramentas

Ver todas as ferramentas →
GitHuberis-ths/supply-chain-guard

supply-chain-guard

Detecte, avalie e responda a ataques à cadeia de suprimentos em npm/yarn e Python (pip/poetry/uv). Habilidade do Claude Code + scripts autônomos. Criado durante o axios RAT (2026-03-31) e Starlette BadHost CVE-2026-48710 (2026-05-22).

Ver Repositório
311há 2 mesesAinda não revisado
Compartilhar

Supply Chain Guard (SCG)

Um kit de ferramentas de resposta a incidentes para ataques à cadeia de suprimentos npm/yarn e Python (pip/poetry/uv) — gratuito, local, sem dependências.

SCG não é um mecanismo de varredura que compete com ferramentas comerciais em cobertura. É uma habilidade Claude Code e um kit de shell autônomo que faz três coisas bem: (1) oferece uma primeira resposta rápida e repetível quando um incidente específico ocorre ("minha máquina está afetada agora?"), (2) orquestra scanners OSS existentes (npm audit, osv-scanner, pip-audit) em uma passagem estruturada, e (3) documenta lições duramente conquistadas de higiene de design — especialmente para ambientes de desenvolvimento de IA — que scanners genéricos não cobrem.

Foi construído e endurecido durante incidentes reais, incluindo:

  • Incidente RAT [email protected] (2026-03-31) — Assunção de conta de mantenedor npm (UNC1069/DPRK-APT) injetando um RAT de dependência fantasma
  • Starlette BadHost (CVE-2026-48710, 2026-05-22) — Injeção de caminho no cabeçalho Host do framework HTTP Python → SSRF/RCE, afetando FastAPI, vLLM, LiteLLM e o ecossistema mais amplo de agentes de IA

Novidades na v4 (2026-05-27)

```
  • Varredura de cadeia de suprimentos Python — scripts/project-scan-py.sh com detecção de versão sinalizada por CVE / pip-audit / osv-scanner
  • Camada de versão sinalizada por CVE (L3-CVE) — rastreia versões vulneráveis conhecidas de pacotes legítimos com avaliação estrita de especificação semver (BadHost CVE-2026-48710 incluído de fábrica)
  • Diretriz de higiene de design — transporte MCP via stdio em primeiro lugar, disciplina de fixação de versão, endurecimento da SA de editor de computação padrão do GCP (ver SKILL.md §D.7 DesignHygiene)
  • Integração com lente Guild-CLI Devil — invocar SCG como lente Devil a partir de fluxos de trabalho guild-cli (ver "Integração com Guild-CLI Devil" abaixo)

Índice

  • Por que isso existe
  • Como o SCG difere das ferramentas existentes
  • O que o SCG é (e não é)
  • Arquitetura
  • Início rápido
  • Modos de varredura
  • Inteligência de ameaças
  • Framework Devil Gate
  • Scripts autônomos
  • Integração CI/CD
  • Playbook de resposta
  • Referência de IOC
  • Aviso legal
  • Limitações
  • Verificação de integridade
  • Licença

Por que isso existe

Em 31 de março de 2026, o pacote npm axios amplamente utilizado (v1.14.1 e v0.30.4) foi comprometido por meio de uma assunção de conta de mantenedor atribuída a UNC1069/DPRK-APT (de acordo com o Google Threat Intelligence Group). O ataque injetou uma dependência fantasma ([email protected]) que implantou um RAT multiplataforma via scripts postinstall, disfarçado como processos legítimos do sistema.

Supply Chain Guard (SCG) foi construído durante o incidente para fornecer:

  1. Detecção imediata — Minha máquina ou projeto está afetado agora?
  2. Avaliação estruturada — Quão severo é? Qual é o raio de explosão?
  3. Resposta guiada — Remediação passo a passo com confirmações de segurança
  4. Defesa contínua — Um framework de verificação de 8 portões para prevenir recorrência

Como o SCG difere das ferramentas existentes

SCG não substitui ferramentas de segurança existentes. Ele combina múltiplas camadas de detecção com um framework de verificação estruturada e remediação guiada — projetado para uso durante incidentes ativos ou como uma verificação periódica junto com suas ferramentas existentes.

FerramentaO que fazComo o SCG se relaciona
npm auditVerifica o registro em busca de vulnerabilidades conhecidasSCG inclui npm audit como sua camada L1, depois adiciona varredura de IOC no sistema de arquivos/rede, detecção de pacotes maliciosos e um fluxo de trabalho de resposta estruturada
osv-scannerVarre arquivos de bloqueio contra o banco de dados OSV do GoogleSCG inclui OSV como sua camada L2. osv-scanner não verifica artefatos RAT em seu sistema de arquivos ou conexões C2 ativas
Snyk / Socket.devSaaS comercial com monitoramento em tempo real, verificações de PR, varredura de licençasSCG é gratuito, local em primeiro lugar, sem necessidade de conta, sem envio de dados a terceiros. Projetado para resposta imediata a incidentes, em vez de monitoramento contínuo
IR ManualInvestigação ad-hoc com scripts personalizadosSCG fornece um framework repetível (8 portões de verificação, loop de convergência, matriz de severidade) em vez de listas de verificação únicas que variam por incidente

Quando usar SCG:

  • Um incidente de cadeia de suprimentos acaba de ocorrer e você precisa verificar suas máquinas e projetos agora mesmo
  • Você quer um processo estruturado e repetível para verificar se um comprometimento foi totalmente resolvido
  • Você precisa de uma verificação leve que executa localmente sem dependências de SaaS

Quando usar outra coisa:

  • Você precisa de monitoramento contínuo em tempo real → Snyk, Socket.dev
  • Você precisa de varredura de conformidade de licenças → Snyk, FOSSA
  • Você precisa de cobertura além de npm/yarn → osv-scanner (suporta pip, cargo, go, etc.)

O que o SCG é (e não é)

Preferimos ser honestos sobre os limites do que supervalorizar. SCG é três coisas:

  1. Um playbook de resposta a incidentes, como código. Quando um incidente nomeado ocorre (axios RAT, Shai-Hulud, um novo CVE), SCG transforma "estou afetado e, em caso afirmativo, o que fazer?" em uma lista de verificação executável — 8 portões de verificação, uma matriz de severidade e um script de remediação onde cada ação destrutiva precisa de confirmação explícita [y/N]. Este é seu valor principal: a primeira resposta rápida e estruturada para a qual as ferramentas de monitoramento comerciais não são projetadas.

  2. Um orquestrador de scanners OSS existentes. As camadas L1/L2 envolvem npm audit / pip-audit / osv-scanner. A maior parte do poder bruto de detecção é emprestada; a contribuição do SCG é agrupá-los em uma única passagem, adicionar verificações de sistema de arquivos/IOC que as ferramentas de registro não fazem e tornar a saída legível e acionável.

  3. Documentação de lições reais de higiene de design (SKILL.md §D.7) — coisas que realmente encontramos ou investigamos: escolha de transporte MCP, endurecimento de SA padrão do GCP, vetores de execução no momento da instalação e ameaças que visam ferramentas de desenvolvimento de IA (Shai-Hulud lendo .claude/settings.json, SANDWORM_MODE envenenando configurações MCP). Este nicho — higiene de cadeia de suprimentos para desenvolvimento assistido por IA — é onde o SCG é genuinamente diferenciado.

O que o SCG deliberadamente NÃO é

  • Não é um concorrente de cobertura. O banco de dados de ameaças (SKILL.md D.2, as listas estáticas L3) é mantido manualmente — contém os incidentes sobre os quais lemos, não as dezenas de milhares de pacotes maliciosos que um feed comercial ao vivo rastreia. Uma lista curada manualmente não consegue acompanhar o ritmo real de novas ameaças, e não fingimos que consegue.
  • Não é um motor de análise comportamental. SCG corresponde a padrões conhecidos. Payloads ofuscados e verdadeiros zero-days sem aviso público estão fora do escopo por construção.
  • Não é monitoramento contínuo. É uma verificação pontual que você executa durante um incidente ou como uma varredura periódica — não um serviço que observa seu grafo de dependências.

Para onde o SCG está indo

Como um banco de dados curado manualmente não pode vencer em cobertura, estamos investindo intencionalmente onde o SCG é difícil de substituir em vez de onde sempre perderá:

  • Playbooks de resposta a incidentes mais profundos (#1) — melhor ergonomia de primeira resposta, mais modelos de incidentes.
  • Higiene de ambiente de desenvolvimento de IA (#3) — detecção e orientação para ameaças direcionadas a servidores Claude Code / Cursor / MCP e ferramentas similares, que scanners comerciais de cadeia de suprimentos em grande parte não abordam.

O banco de dados estático de ameaças (#2) continuará sendo atualizado quando incidentes notáveis ocorrerem, mas é explicitamente não a direção na qual estamos tentando competir.

Arquitetura

SCG segue uma arquitetura Domain-Driven Design (DDD) com três camadas:``` +-----------------------------------------------------+ | Domain Layer | | Threat models, known threats DB, severity matrix, | | Devil Gate definitions | +-----------------------------------------------------+ | Application Layer | | Use cases, scan pipeline, response protocols, | | Devil execution loop | +-----------------------------------------------------+ | Infrastructure Layer | | Scanner scripts (npm audit, OSV, static list, | | IOC filesystem, network, lockfile integrity) | +-----------------------------------------------------+

root@kitploit:~
### Pipeline de Varredura

O mesmo pipeline de 5 camadas se aplica a ambos os ecossistemas com scanners específicos de cada ecossistema em cada camada:```
L1 ──→ L2 ──→ L3 ──→ IOC ──→ LF ──→ assess(SeverityMatrix) ──→ VERDICT
Camadanpm/yarn (project-scan.sh)Python (project-scan-py.sh)
L1npm auditpip-audit
L2osv-scanner / API OSV.devosv-scanner
L3Lista estática (maliciosos + typosquat)Lista estática (maliciosos / typosquat + versões sinalizadas por CVE)
IOCArtefatos de sistema de arquivos + redeArtefatos de sistema de arquivos + processo (variante Python)
LFnpm ci --dry-run + contagem de integridadeIntegridade do lockfile (uv.lock / poetry.lock / requirements*.txt)

Ambos os pipelines alimentam a mesma SeverityMatrix e Devil Gate Framework.

Início Rápido

Como uma Habilidade do Claude Code

Copie SKILL.md para o diretório de habilidades do Claude Code:```bash

Global (all projects)

cp SKILL.md ~/.claude/skills/supply-chain-guard.md

Or project-specific

mkdir -p .claude/skills cp SKILL.md .claude/skills/supply-chain-guard.md

root@kitploit:~
Em seguida, invoque no Claude Code:```
> /supply-chain-guard
> "Check this project for supply chain issues"
> "Is my machine affected by the axios compromise?"

Como Scripts Autônomos```bash

Environment-wide scan (IOC + all projects) [READ-ONLY]

./scripts/env-scan.sh

npm/yarn project scan (requires package.json in cwd) [READ-ONLY]

./scripts/project-scan.sh

Python project scan (requires pyproject.toml / requirements*.txt / poetry.lock / uv.lock in cwd) [READ-ONLY, added in v4]

./scripts/project-scan-py.sh

IOC-only scan (filesystem + network artifacts) [READ-ONLY]

./scripts/ioc-scan.sh

Remediation (interactive, every action requires confirmation)

./scripts/respond.sh --critical # Full RAT cleanup (npm + Python) ./scripts/respond.sh --high axios 1.14.0 # Pin npm package to safe version ./scripts/respond.sh --high urllib3 2.7.0 # Pin Python package (auto-detects pip/poetry/uv)

root@kitploit:~
> **A remediação do Python é conservadora por design.** Para npm, `--high` aplica a
> substituição automaticamente. Para Python, ela *orienta*: detecta seu gerenciador
> (pip/poetry/uv), exibe o comando exato de pinning e aplica apenas a etapa segura —
> comandos de mutação do lockfile e reconstrução do venv são mostrados para você executar. Isso evita
> que um falso positivo dispare uma reinstalação forçada colateral no fragmentado
> ecossistema de empacotamento Python.

Para um repositório poliglota (npm + Python), execute ambos os scanners de projeto sequencialmente a partir dos subdiretórios relevantes.

> **Design de segurança:** Todos os scripts de varredura são estritamente somente leitura — eles nunca modificam, excluem ou instalam nada. O script de remediação (`respond.sh`) é o único script que realiza operações destrutivas, e **cada ação individual requer confirmação explícita `[y/N]`** com padrão NÃO.

---

## Modos de Varredura

### Varredura de Ambiente (`env_scan`)

Escaneia toda a sua máquina de desenvolvimento em busca de indicadores de comprometimento.

| Verificação | Descrição |
|-------------|-----------|
| **IOC: Sistema de Arquivos** | Binários RAT, mecanismos de persistência, arquivos de preparação |
| **IOC: Rede** | Conexões C2 ativas (IP + domínio) |
| **IOC: Processo** | Processos maliciosos em execução |
| **Entre projetos** | Todos os arquivos `package-lock.json` varridos em busca de versões comprometidas |
| **Pacotes maliciosos** | Nomes de pacotes maliciosos conhecidos em qualquer lockfile |

**Gatilhos:** "this PC", "environment check", "machine-wide"

### Varredura de Projeto — npm/yarn (`project_scan`)

Varredura profunda de um único projeto npm/yarn. Execute a partir de um diretório contendo `package.json`.

| Camada | Scanner | Descrição |
|--------|---------|-----------|
| **L1** | `npm audit` | Vulnerabilidades conhecidas via registro npm |
| **L2** | `osv-scanner` / API OSV.dev | Banco de dados de Vulnerabilidades de Código Aberto do Google |
| **L3** | Lista estática | Verificação de pacotes maliciosos conhecidos embutidos em código |
| **IOC** | Sistema de Arquivos + Rede | Detecção de artefatos RAT |
| **LF** | Integridade do lockfile | `npm ci --dry-run` + contagem de hash de integridade |

**Gatilhos:** "this project", "npm audit", ou `package.json` presente no diretório atual

### Varredura de Projeto — Python (`project_scan_py`, adicionado na v4)

Varredura profunda de um único projeto Python. Execute a partir de um diretório contendo `pyproject.toml`, `requirements*.txt`, `poetry.lock` ou `uv.lock`.

| Camada | Scanner | Descrição |
|--------|---------|-----------|
| **L1** | `pip-audit` | Vulnerabilidades conhecidas via Banco de Dados de Avisos PyPI (opcional — PULA se não instalado; `pip install pip-audit` recomendado) |
| **L2** | `osv-scanner` | Banco de dados de Vulnerabilidades de Código Aberto do Google contra `uv.lock` / `poetry.lock` / `requirements*.txt` (opcional — PULA se não instalado) |
| **L3-MAL** | Lista estática maliciosa (`_L3_LIST`) | Nomes de pacotes sequestrados / typosquat conhecidos. Corresponde à lista PEP 621, Poetry inline e declarações estilo requirements (veja [PR #4](https://github.com/eris-ths/supply-chain-guard/pull/4)). FALHA em acerto |
| **L3-CVE** | Lista estática de versões sinalizadas por CVE (`_L3_CVE_LIST`) | Versões vulneráveis conhecidas de pacotes legítimos (ex.: `starlette<1.0.1` para [BadHost CVE-2026-48710](https://cryptobriefing.com/starlette-badhost-vulnerability-ai-agents/)). Avaliação estrita de semver-spec via biblioteca `packaging` do Python. FALHA em correspondência confirmada. Avisa se um pacote é declarado mas nenhum lockfile está presente (não é possível avaliar a versão) |
| **IOC** | Sistema de Arquivos + Processo | Verificação de artefatos com sabor Python (scripts maliciosos, processos suspeitos) |
| **LF** | Integridade do lockfile | Verifica se `uv.lock` / `poetry.lock` / `requirements*.txt` analisa corretamente e contém versões fixadas |

**Gatilhos:** "this project" com arquivos Python presentes, ou qualquer um de `pyproject.toml` / `requirements*.txt` / `poetry.lock` / `uv.lock` no diretório atual

> **Nota sobre dependências:** L1 (`pip-audit`) e L2 (`osv-scanner`) pulam graciosamente com uma dica quando suas respectivas CLIs estão ausentes. L3 é a camada sempre ativa e não requer nenhuma ferramenta externa, mas a avaliação precisa de L3-CVE precisa de `pip install packaging`.

---

## Inteligência de Ameaças

### Banco de Dados de Ameaças Conhecidas

| ID | Data | Pacote | Ator de Ameaça | Vetor |
|----|------|--------|----------------|-------|
| **T001** | 2026-03-31 | `[email protected]`, `[email protected]` | UNC1069/DPRK-APT | Comprometimento do mantenedor → dep fantasma → RAT |
| **T002** | 2018-11 | `[email protected]` | Desconhecido | Injeção de dependência → roubo de criptomoedas |
| **T003** | Em andamento | `crossenv`, `loadsh`, `crypto-js-esm` | Vários | Typosquatting → exfiltração pós-instalação |

### Cadeia de Ataque T001 (axios RAT)```
Credential theft → npm publish (bypass CI) → Inject phantom dep (plain-crypto-js)
    → postinstall exec → RAT drop → C2 beacon (sfrclak.com:8000) → Persist

Versões Seguras

PacoteSeguraComprometida
axios (última)1.14.0 (exata) ou >=1.14.21.14.1
axios (legado)0.30.3 (exata)0.30.4

IDs de Avisos

  • GHSA-fw8c-xr5c-95f9
  • MAL-2026-2306

Devil Gate Framework

O SCG utiliza um framework de verificação de 8 gates organizado em 4 categorias, executado como uma cadeia serial com laço de convergência.

Gates

#GateCategoriaPergunta
G1Dependência DiretaEnvenenamento de DependênciaAlguma dependência direta está em uma versão comprometida?
G2Dependência TransitivaEnvenenamento de DependênciaAlguma dependência transitiva (indireta) está comprometida?
G3Artefatos RATComprometimento em Tempo de ExecuçãoExistem vestígios de RAT no sistema de arquivos?
G4Scripts de Pós-instalaçãoComprometimento em Tempo de ExecuçãoExistem scripts postinstall suspeitos?
G5Integridade do LockfileIntegridadeO lockfile foi adulterado?
G6ProveniênciaIntegridadeO pacote é de uma fonte/mantenedor legítimo?
G7RedeAmbienteExistem conexões de saída suspeitas?
G8Endurecimento CI/CDAmbienteO CI/CD ignora o postinstall / impõe lockfile congelado?

Execução em Cadeia```

S1: Dependency (G1+G2) → S2: Runtime (G3+G4) → S3: Integrity (G5+G6) → S4: Environment (G7+G8) → Any fail? → Fix → Re-run entire chain → All pass? → "No concerns" → Done → 3 rounds without convergence? → Escalate to user

root@kitploit:~
### Matriz de Gravidade

| Nível | Condição | Ação |
|-------|-----------|--------|
| **CRÍTICO** | Artefato RAT encontrado OU pacote malicioso instalado | Isolar rede → Matar processo → Remover persistência → Reinstalar |
| **ALTO** | Versão comprometida em uso | Fixar versão segura → Substituir → `npm ci` → Verificar |
| **MÉDIO** | Script postinstall suspeito | Revisão manual → Incluir na lista de permissões ou remover |
| **BAIXO** | Deriva do lockfile | Ressincronizar com `npm ci` |
| **LIMPO** | Todas as verificações passaram | Nenhuma ação necessária |

> **Segurança:** Respostas CRÍTICO/ALTO envolvem operações destrutivas. O SCG sempre apresenta descobertas e solicita confirmação explícita do usuário antes de executar a remediação.

---

## Scripts Autônomos

### `scripts/env-scan.sh`

Varredura completa do ambiente. Verifica artefatos IOC, escaneia todos os lockfiles em `$HOME` (configurável) e relata pacotes comprometidos.```bash
./scripts/env-scan.sh [scan_root_dir]
# Default: $HOME

scripts/project-scan.sh

Análise a nível de projeto. Execute a partir de um diretório que contenha package.json.```bash cd my-project /path/to/scripts/project-scan.sh

root@kitploit:~
### `scripts/ioc-scan.sh`

Verificação apenas de IOC. Verifica artefatos do sistema de arquivos, processos em execução e conexões de rede contra indicadores C2 conhecidos. Multiplataforma (macOS/Linux/Windows via PowerShell).```bash
./scripts/ioc-scan.sh

scripts/respond.sh

Remediação interativa. Toda ação destrutiva requer confirmação [y/N] (padrão: NÃO).```bash

CRITICAL: Full RAT cleanup (kill → remove → reinstall)

./scripts/respond.sh --critical

HIGH: Pin compromised package to safe version

./scripts/respond.sh --high axios 1.14.0 # npm ./scripts/respond.sh --high event-stream 3.3.5 # npm ./scripts/respond.sh --high urllib3 2.7.0 # python (pip/poetry/uv auto-detected)

root@kitploit:~
Etapas no modo `--critical`:
1. Isolamento de rede (bloquear domínio C2 via `/etc/hosts`)
2. Matar processos RAT
3. Remover persistência (LaunchAgents / crontab / tarefas agendadas)
4. Excluir `node_modules` e lockfile, limpar cache do npm
   - **4b (Python):** limpar cache do pip (seguro, automático); reconstrução do venv mostrada como etapas manuais
5. Reinstalar dependências
6. Solicitar verificação de varredura (`project-scan.sh` e/ou `project-scan-py.sh`)

Cada etapa verifica se a ação é realmente necessária (por exemplo, pula "matar" se nenhum processo RAT estiver em execução) e mostra exatamente o que será executado antes de pedir confirmação.

Para o modo **HIGH**, o npm aplica a substituição automaticamente; Python é guiado (detectar gerenciador → exibir comando pin → aplicar apenas a etapa segura). Consulte a nota de correção do Python em [Quick Start](#quick-start).

---

## Integração CI/CD

### GitHub Actions```yaml
name: Supply Chain Guard
on:
  pull_request:
    paths:
      - 'package.json'
      - 'package-lock.json'
      - 'yarn.lock'

jobs:
  scg-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'

      - name: Install dependencies (hardened)
        run: npm ci --ignore-scripts

      - name: Run SCG project scan
        run: |
          chmod +x ./scripts/project-scan.sh
          ./scripts/project-scan.sh

      - name: Run IOC scan
        run: |
          chmod +x ./scripts/ioc-scan.sh
          ./scripts/ioc-scan.sh

Recomendações de Endurecimento```bash

Always use in CI:

npm ci --ignore-scripts # Block postinstall execution

npm ci already enforces lockfile integrity by design (errors on mismatch)

Yarn equivalent:

yarn install --frozen-lockfile --ignore-scripts

root@kitploit:~
> **Fixar ações pelo SHA, não pela tag.** O exemplo acima usa `actions/checkout@v4` para legibilidade, mas as tags podem ser movidas. Em produção, fixe pelo SHA completo do commit para prevenir ataques à cadeia de suprimentos de ações:
> ```yaml
> - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683  # v4.2.2
> - uses: actions/setup-node@39370e3970a6d050c480ffad4ff0ed4d3fdee5af  # v4.1.0
> ```

---

## Playbook de Resposta

### Se CRÍTICO (RAT detectado)

> **Não entre em pânico.** Siga estes passos em ordem. Cada passo requer sua confirmação explícita.

1. **Isolar Rede** — Bloquear domínio C2 via `/etc/hosts`
2. **Matar Processos** — Encerrar processos RAT (`com.apple.act.mond`, `ld.py`, `wt.exe`)
3. **Remover Persistência** — Excluir LaunchAgents, crontabs, tarefas agendadas
4. **Limpar npm** — Remover `node_modules` e `package-lock.json`, limpar cache npm
5. **Reinstalar** — `npm install && npm ci` novamente
6. **Reexaminar** — Executar novamente o pipeline completo, esperar CLEAR

### Se ALTO (versão comprometida instalada)

1. **Fixar versão segura** usando respond.sh:   ```bash
   ./scripts/respond.sh --high axios 1.14.0

Isso adiciona overrides (npm) ou resolutions (yarn) ao package.json, reinstala e solicita verificação.

  1. Ou manualmente no package.json: ```json { "overrides": { "axios": "1.14.0" } }
    root@kitploit:~

Yarn: { "resolutions": { "axios": "1.14.0" } }

  1. Reinstalar: npm ci
  2. Verificar: Reexecutar a varredura

Referência de IOC

Artefatos do Sistema de Arquivos

PlataformaCaminhoTipo
macOS/Library/Caches/com.apple.act.mondBinário do RAT
macOS~/Library/LaunchAgents/com.apple.act.mond.plistPersistência
Windows%PROGRAMDATA%\wt.exeBinário do RAT (disfarçado como Terminal do Windows)
Windows%TEMP%\6202033.vbsDropper
Windows%TEMP%\6202033.ps1Dropper
Linux/tmp/ld.pyScript do RAT
Linux/tmp/.npm-cache/Diretório de preparação

Mecanismos de Persistência

PlataformaMecanismoIdentificador
macOSLaunchAgentcom.apple.act.mond
WindowsTarefa AgendadaWindowsTerminalUpdate
LinuxEntrada CrontabReferencia ld.py ou .npm-cache

Indicadores de Rede

TipoValor
Domínio C2sfrclak.com
IP C2142.11.206.73
Porta C28000

Técnicas de Disfarce

PlataformaDisfarçado Como
macOSProcesso do sistema Apple (com.apple.act.mond)
WindowsTerminal do Windows (wt.exe no ProgramData)

Formato de Saída```

SCG ────────────────────────────────── [L1:audit] CLEAR|!!sev [L2:osv] CLEAR|!!vuln-ids [L3:static] CLEAR|!!pkg [IOC:fs] CLEAR|!!C:artifact [IOC:net] CLEAR|!!C:c2 [LF:integ] CLEAR|!!drift ─── Devil Gate(8) ──────────────────── G1:direct_dep G2:transitive G3:rat_fs G4:postinstall G5:lockfile G6:provenance G7:network G8:cicd ─── Devil Chain(R.N) ───────────────── S1:dependency → S2:runtime → S3:integrity → S4:environment ─── Loop ───────────────────────────── R.N → converge|continue [VERDICT] CLEAR|HIGH|CRITICAL ───────────────────────────────────────

root@kitploit:~
---

## Referências

| Fonte | Descrição |
|--------|-------------|
| [Zenn (JP)](https://zenn.dev/gunta/articles/0152eadf05d173) | Relatório inicial japonês |
| [Elastic Security Labs](https://elastic.co/security-labs/axios-one-rat-to-rule-them-all) | Análise técnica (desmontagem do RAT, protocolo C2, cronograma) |
| [SANS](https://sans.org/blog/axios-npm-supply-chain-compromise-malicious-packages-remote-access-trojan) | Procedimentos de resposta a incidentes empresariais |
| [Huntress](https://huntress.com/blog/supply-chain-compromise-axios-npm-package) | Assinaturas YARA |
| [Elastic Detections](https://elastic.co/security-labs/axios-supply-chain-compromise-detections) | Regras de detecção SIEM (YARA/osquery/KQL) |
| [Semgrep](https://semgrep.dev/blog/2026/axios-supply-chain-incident-indicators-of-compromise-and-how-to-contain-the-threat/) | Regras de análise estática, guia de contenção |
| [SOCRadar](https://socradar.io/blog/axios-npm-supply-chain-attack-2026-ciso-guide/) | Guia CISO com linha do tempo de IOCs |
| [Wiz](https://wiz.io/blog/axios-npm-compromised-in-supply-chain-attack) | Análise de impacto na nuvem, varredura de contêineres |
| [NVD CVE-2026-48710](https://nvd.nist.gov/vuln/detail/CVE-2026-48710) | **Primário** — Entrada canônica do NVD (publicado em 2026-05-26, CVSS 3.1 base 6.5 MEDIUM, AV:N/AC:L/PR:N/UI:N/S:U/C:L/I:L/A:N) |
| [GHSA-86qp-5c8j-p5mr](https://github.com/Kludex/starlette/security/advisories/GHSA-86qp-5c8j-p5mr) | **Primário** — Aviso de Segurança do GitHub em `Kludex/starlette` (publicado em 2026-05-21): "A validação ausente do cabeçalho Host envenena request.url.path, contornando verificações de segurança baseadas em caminho" |
| [Notas de lançamento do Starlette v1.0.1](https://github.com/Kludex/starlette/releases/tag/1.0.1) | **Primário** — lançamento de correção (publicado em 2026-05-21). Fixe `starlette>=1.0.1` (e `fastapi>=0.119` para resolução transitiva) |
| [Cobertura Starlette BadHost (KuCoin)](https://kucoin.com/news/flash/starlette-vulnerability-exposes-millions-of-ai-agents-to-hackers) | Secundário — impacto no ecossistema Python, enquadramento de agentes de IA |
| [Análise do agente de IA BadHost (CryptoBriefing)](https://cryptobriefing.com/starlette-badhost-vulnerability-ai-agents/) | Secundário — enquadramento de impacto downstream em FastAPI / vLLM / LiteLLM |

---

## Integração com o Guild-CLI Devil

Se você usa o [guild-cli](https://github.com/eris-ths/guild-cli) (ou qualquer projeto que exponha um fluxo de trabalho do Devil lense), o SCG pode ser invocado como uma das lentes de segurança durante uma passagem de revisão.

### Padrão de invocação recomendado```bash
# Inside a guild-cli review session, in the project root:
~/path/to/supply-chain-guard/scripts/project-scan.sh       # for npm/yarn projects
~/path/to/supply-chain-guard/scripts/project-scan-py.sh    # for Python projects

# Capture the scan output as evidence for a judgment:
SCG_OUTPUT=$(~/path/to/supply-chain-guard/scripts/project-scan.sh 2>&1 || true)

# (a) Record it as a new judgment (fast-track — no prior review needed):
gate fast-track --from "$USER" \
  --action "SCG supply-chain scan (Devil lense)" \
  --reason "$SCG_OUTPUT"

# (b) Or attach it as the Devil lense on an existing review request <id>:
gate review <id> --lense devil --verdict concern --note "$SCG_OUTPUT"

Notas sobre flags (verificado com guild-cli): gate review requer um <id> existente, --lense (guild-cli escreve "lense") e --verdict (ok / concern / reject). Não possui a flag --area. Para registrar uma nova descoberta sem objeto de revisão anterior, use gate fast-track como em (a).

Por que parear SCG com Devil

Devil's Advocate ("壊しにいく") e SCG compartilham a mesma postura: assumir o pior, escanear sistematicamente, depois convergir. SCG fornece a dimensão da cadeia de suprimentos de uma passada do Devil — o que as dependências do projeto podem estar fazendo nas suas costas — junto com outras lentes (segurança / correção / arquitetura / usuário / operações).

Limitações do pareamento com Devil

  • SCG executa em modo somente leitura; a lente Devil não aplicará correções. Use respond.sh separadamente quando a remediação for necessária (com confirmação explícita do usuário)
  • A saída do SCG pode exceder os orçamentos de contexto do Devil em repositórios grandes; canalize via tail -50 se necessário
  • Para repositórios poliglotas, execute tanto project-scan.sh quanto project-scan-py.sh e mescle as descobertas

Aviso de Isenção

SCG é uma ferramenta de detecção, não uma garantia de segurança. Ser transparente sobre o que ela pode e não pode fazer faz parte do design.

Este software é fornecido "como está", sem garantia de qualquer tipo. Ao usar o Supply Chain Guard, você reconhece e concorda com o seguinte:

  • Não substitui segurança profissional. SCG é uma ferramenta de detecção suplementar, não uma solução de segurança abrangente. Ela não substitui resposta a incidentes profissional, software de detecção e resposta de endpoints (EDR) ou auditorias de segurança.
  • Não garante detecção. Um veredito CLEAR significa que nenhuma correspondência foi encontrada contra os padrões de ameaça conhecidos da ferramenta. Isso não significa que seu sistema ou projeto esteja livre de comprometimento. Ataques novos, desconhecidos ou modificados podem não ser detectados.
  • Não garante remediação. As etapas de remediação fornecidas (respond.sh) tratam indicadores conhecidos de ameaças específicas. Elas podem não remover completamente todos os vestígios de um comprometimento sofisticado. Se você suspeitar de comprometimento ativo, contate uma equipe profissional de resposta a incidentes.
  • Use por sua conta e risco. Os autores não são responsáveis por quaisquer danos, perda de dados ou incidentes de segurança decorrentes do uso ou da incapacidade de usar esta ferramenta. Isso inclui, mas não se limita a: falsos negativos (detecções perdidas), falsos positivos (detecções incorretas) ou consequências não intencionais da execução de scripts de remediação.
  • Não é aconselhamento jurídico ou de conformidade. Esta ferramenta não satisfaz requisitos regulatórios, de conformidade ou legais para varredura de segurança. Consulte profissionais apropriados para necessidades de conformidade.

Limitações

Entender o que o SCG não pode fazer é tão importante quanto saber o que ele pode.

Limites de Detecção

O que SCG verificaO que SCG NÃO verifica
Versões conhecidas de pacotes comprometidos (banco de dados fixo)Ataques de cadeia de suprimentos zero-day sem aviso público
Nomes conhecidos de pacotes maliciososTyposquats ainda não na lista estática
Caminhos específicos de IOC para ameaças conhecidasMalware arbitrário descartado em caminhos não padrão
Endereços IP e domínios C2 específicosInfraestrutura C2 que foi rotacionada ou alterada
Scripts postinstall em dependências diretasCódigo malicioso ofuscado dentro de scripts de aparência legítima

Atualização do Banco de Dados de Ameaças

O banco de dados de Ameaças Conhecidas (D.2 em SKILL.md) é mantido manualmente. Não está conectado a nenhum feed de ameaças ao vivo. Existe latência inerente entre a descoberta de um novo incidente na cadeia de suprimentos e a atualização deste banco de dados.

  • Última atualização: 2026-05-27 (v4: suporte a Python, adicionado BadHost CVE-2026-48710)
  • Cobertura: 3 famílias de ameaças npm (T001-T003) + 4 entradas de pacotes Python sequestrados/typosquat + 1 entrada de versão Python sinalizada por CVE (BadHost)
  • Escopo da cobertura Python (v4): principalmente varredura baseada em lockfile (uv.lock / poetry.lock / requirements.txt). A camada de versão sinalizada por CVE é de melhor esforço — ela sinaliza apenas pacotes que correspondem a entradas _L3_CVE_LIST com avaliação estrita de semver, e depende da instalação de packaging para correspondência precisa de versões

Sempre faça referência cruzada com fontes ao vivo, como npm advisories, OSV.dev e blogs de segurança de fornecedores listados na seção Referências.

Risco de Falso Positivo

Os seguintes caminhos de IOC podem, em casos raros, conflitar com software legítimo:

Caminho IOCPossível Falso Positivo
/tmp/.npm-cache/Cache npm legítimo em configurações não padrão
/tmp/ld.pyScripts Python não relacionados com o mesmo nome de arquivo
Nome do processo wt.exeWindows Terminal legítimo se localizado em ProgramData

Sempre verifique as descobertas de IOC antes de executar a remediação. O script ioc-scan.sh relata descobertas para revisão humana — ele não toma nenhuma ação. O script respond.sh requer confirmação explícita para cada ação destrutiva (padrão: NÃO) precisamente por causa desse risco.

Limitações da Varredura de Rede

  • As verificações de rede baseadas em lsof detectam apenas conexões atualmente ativas. Um beacon C2 que se conecta intermitentemente pode não estar ativo no momento da varredura.
  • As verificações de cache DNS são de melhor esforço e dependentes do SO. Caches limpos não mostrarão conexões históricas.
  • O tráfego C2 criptografado ou tunelado não pode ser detectado apenas pela correspondência de porta/IP.

Escopo

  • npm/yarn e Python (pip/poetry/uv). Não abrange cargo, go modules ou outros ecossistemas de pacotes.
  • Apenas ameaças conhecidas. Esta é uma ferramenta de correspondência de padrões, não um mecanismo de análise comportamental.
  • Varredura pontual. Os resultados refletem o estado no momento da execução. O monitoramento contínuo requer execução repetida ou integração com CI/CD.

Verificação de Integridade

Verifique se sua cópia do SCG não foi adulterada. Compare esses checksums SHA-256 com seus arquivos locais:

67ac6216cbe18fdf7050fd267bce4157c016e5c60cd4f84f63b8cf71e80ae3b9 scripts/env-scan.sh da01f8362563b55b1553f923a748f07d24f24522366e0545e6ba0c09801f8e54 scripts/project-scan.sh 77e7ebba6d44ea020e511a49bc2cbc974d01495de40d35e8dfb7fcc93008954b scripts/project-scan-py.sh 82aaa4ed898ce354addc064ccf84cca9a498ef4e90fe58613e1110146577609f scripts/ioc-scan.sh 72ed333838b5584c3b1faf889edc81b0e3195c27396c3b36c62aaebf5f952117 scripts/ioc-scan.ps1 0e6b30e57c959180e22e0ba16f860e9fdc7304045947995084703fb14381d12e scripts/respond.sh a44be79d909058c9d216e7cbc5cca736cf8816a492c8d35a6b90c74c042abf5b SKILL.md

root@kitploit:~
<!-- CHECKSUMS-END -->

Para verificar:```bash
shasum -a 256 scripts/*.sh scripts/*.ps1 SKILL.md

Nota: Estas somas de verificação correspondem à versão mais recente. Se você modificou algum arquivo localmente, as somas serão diferentes. Quando o SCG é atualizado, esta seção é atualizada juntamente com as alterações de código.

Licença

MIT

Construído por Eris — porque suas dependências não devem ser a superfície de ataque de outra pessoa.

Baixar ferramenta