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
Cheshire — Plugin de serviço Adaptix C2 que impulsiona a análise de payload LitterBox da interface do operador. | Kitploit
Ferramentas/GitHubGitHub/blacksnufkin/cheshire
Frameworks de Testes de PenetraçãoAnálise EstáticaAnálise Dinâmica (Sandboxing)Frameworks de ExploraçãoAnálise de MalwareComando e ControleRed Teaming
GitHubblacksnufkin/cheshire

Cheshire

Plugin de serviço Adaptix C2 que impulsiona a análise de payload LitterBox da interface do operador.

Ver Repositório
6644há 4 mesesRevisado pelo Kitploit

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 →
Compartilhar

Cheshire Logo

Cheshire

QA de payload pré-voo para Adaptix, alimentado por LitterBox.

Cheshire é um plugin de serviço C2 do Adaptix que conecta o cliente Adaptix a um sandbox LitterBox. De dentro da interface do Adaptix, um operador pode escolher qualquer binário, despachá-lo por toda a cadeia de análise do LitterBox (estática + dinâmica + todos os perfis EDR acessíveis) e ver o veredito se materializar sem nunca sair do Adaptix.

O nome segue a linhagem de mascotes do projeto:

  • Adaptix → camaleão
  • LitterBox → gato rabugento
  • A ponte entre eles → Cheshire (o gato que sorri, aparece e desaparece, e te diz se o caminho à frente é seguro).

O que faz

AçãoPonto(s) de extremidade LitterBoxResultado
Enviar payloadPOST /uploadmd5 + metadados do arquivo
Executar TudoPOST /analyze/static/<md5> + /analyze/dynamic/<md5> + /analyze/edr/<profile>/<md5> (×N perfis) em goroutines paralelasEstática, Dinâmica, cada perfil EDR preenchido à medida que conclui
Apenas estático/analyze/static/<md5>Resultados YARA / CheckPlz / Stringnalyzer
Apenas dinâmico/analyze/dynamic/<md5>Resultados YARA-mem / PE-Sieve / Moneta / Patriot / HSB / RedEdr
EDR (múltiplo)/analyze/edr/<profile>/<md5> por perfil + Consulta Fase 2 em /api/results/edr/<profile>/<md5>Tabela de alertas por perfil + detalhe abrangente do alerta (motivo, MITRE, API, região de memória, pilha de chamadas, módulo de usuário final, processo, pai, respostas EDR)
LimpezaDELETE /file/<md5>Remove pastas de upload + resultados + diretórios de análise por amostra do LitterBox
Sonda da frotaGET /healthStatus da sandbox, inventário de scanners, acessibilidade do agente EDR — controla as caixas de seleção dos Perfis EDR

A consulta da Fase 2 do EDR usa a cadência adaptativa do LitterBox (base de 2s, backoff ×1,5 até 15s quando a contagem de alertas está estável, retorna a 2s em movimento). Cada ciclo de consulta transmite um evento progress para o cliente para que a barra de progresso ao vivo possa mostrar as contagens de alertas aumentando em tempo real.


Layout

root@kitploit:~
Cheshire/
├── README.md
├── setup_cheshire.sh                       script de implantação
└── cheshire_service/
    ├── config.yaml                         manifesto do plugin de serviço + litterbox_url
    ├── go.mod / go.sum
    ├── Makefile                            constrói dist/service_cheshire.so
    ├── pl_main.go                          Plugin de serviço Go (cliente HTTP para LitterBox)
    └── ax_config.axs                       Interface AXScript (o diálogo do painel)

O plugin Go é um relé HTTP sem estado entre o TsServiceSendDataClient do Adaptix e a API REST do LitterBox. O arquivo AXScript é responsável por toda a renderização — banner de veredito, resumo de detecção, sub-abas por scanner, tabela de alertas EDR com clique para detalhes.


Configuração

1. Iniciar o LitterBox

Cheshire requer uma instância do LitterBox em execução (veja o repositório LitterBox para instalação). Confirme a acessibilidade:

root@kitploit:~
curl http://<litterbox-host>:1337/health

2. Configurar Cheshire

Edite cheshire_service/config.yaml e defina litterbox_url:

root@kitploit:~
extender_type: "service"
extender_file: "service_cheshire.so"
ax_file: "ax_config.axs"

service_name: "cheshire"
service_config: |
  litterbox_url: "http://192.168.88.128:1337"

Se litterbox_url estiver faltando, o plugin carrega, mas todo comando do operador retorna "Cheshire is not configured: set litterbox_url in service_config". Não há fallback padrão.

3. Implantar

root@kitploit:~
bash setup_cheshire.sh --ax /path/to/AdaptixC2

Isso:

  1. Copia o código-fonte para AdaptixC2/AdaptixServer/extenders/cheshire_service/.
  2. Adiciona ./extenders/cheshire_service ao workspace Go.
  3. Constrói service_cheshire.so via Makefile.
  4. Copia o .so compilado + config.yaml + ax_config.axs para AdaptixC2/dist/extenders/cheshire_service/.

4. Registrar com o servidor Adaptix

Adicione uma linha em AdaptixC2/dist/profile.yaml sob Teamserver.extenders:

root@kitploit:~
extenders:
  - "extenders/cheshire_service/config.yaml"
  ...

5. Reiniciar o servidor

root@kitploit:~
pkill -f adaptixserver
cd AdaptixC2/dist
./adaptixserver -profile profile.yaml

Você deve ver [cheshire] Initialized — LitterBox at http://... no log do servidor, seguido por [+] Service 'cheshire' loaded.

Na barra de menu do cliente Adaptix, Cheshire → Testar com Cheshire abre o painel.


Painel

root@kitploit:~
┌─ Payload ───────────────────────────────────────────────────────────────┐
│  [Browse...]  /home/op/payloads/beacon.exe                              │
├─ EDR Profiles ──────────────────────────────────────────────────────────┤
│  ☑ Elastic Defend   ● reachable     elastic · WIN-VM01 · nightcity      │
│  ☐ Fibratus         ● not reachable fibratus                            │
├─ Dynamic Analysis Args ─────────────────────────────────────────────────┤
│  --quiet -p 4444                                                        │
├─────────────────────────────────────────────────────────────────────────┤
│  [Run All] | [Static] [Dynamic] [EDR] | [Cleanup]    Uploaded: ...      │
├─────────────────────────────────────────────────────────────────────────┤
│  🚫 DETECTED — 5 hit(s) across 2 Static, 1 Dynamic [CRITICAL]           │
│                                              ✓ Static  ✓ Dynamic  🔄 elastic (2) │
├─ Detection Summary ─────────────────────────────────────────────────────┤
│  Severity  | Scanner             | Detection         | Detail           │
│  CRITICAL  | Static · CheckPlz   | Trojan:Win64/...  | offset 0x20EF    │
│  CRITICAL  | Static · YARA       | mimikatz_strings  | matched $sek...  │
│  HIGH      | Dynamic · PE-Sieve  | 3 modifications   | 3 IAT hooks      │
│  ...                                                                    │
├─ Static | Dynamic | EDR ────────────────────────────────────────────────┤
│  per-scanner sub-tabs with stat strip + bordered finding cards          │
└─────────────────────────────────────────────────────────────────────────┘

Veredito + escopo

  • ⏳ RUNNING — N hit(s) so far enquanto qualquer scanner agendado estiver em execução.
  • 🚫 DETECTED — N hit(s) across X Static, Y Dynamic, Z EDR [maxSev] assim que todos os scanners agendados atingirem um estado terminal.
  • ✓ CLEAN — 0 critical/high/medium detections apenas se não houver hits reais em nenhum scanner. Sinais informacionais (LOW/INFO) são anotados separadamente, não no título.
  • (Static only) / (Dynamic + EDR) etc. são anexados quando o operador executa um scanner individual em vez de Executar Tudo — o veredito reflete honestamente o que foi realmente executado.

Resumo de Detecção

Agrega todas as detecções de todos os scanners em uma tabela classificável. As linhas são extraídas do JSON real que o LitterBox retorna (não strings de fator genéricas):

  • Regras YARA / YARA-mem com gravidade + nome da ameaça + identificador da primeira string correspondida
  • CheckPlz initial_threat + scan_results.detection_offset
  • Contagens de categorias perigosas do Stringnalyzer
  • PE-Sieve total_suspicious + contagens por indicador
  • Moneta contagens de anomalias total_* não zero (Private RWX → CRITICAL, etc.)
  • Patriot por descoberta level + type + primeiros 120 caracteres de details
  • HSB por descoberta gravidade + tipo + id da thread
  • Eventos do RedEdr Defender filtrados por category === 'threat'
  • Alertas EDR: regra + gravidade + processo + resumo da API

Ordenado por gravidade decrescente, depois nome do scanner.

Limpeza automática

Quando o diálogo é fechado, o md5 da amostra atual é apagado do LitterBox via DELETE /file/<md5>. Nenhuma amostra obsoleta se acumula entre as operações.


Arquitetura

root@kitploit:~
Adaptix Client (Qt) ──┐
                      │ AXScript service_command("cheshire", "run_all", {...})
                      ▼
Adaptix Server  ──→  service_cheshire.so  ──HTTP──→  LitterBox  ──→  EDR VM
  │                                                       │              │
  │                    streams progress events        Static / Dynamic   │
  │                    + results back via             scanners run on    │
  │                    TsServiceSendDataClient        the LitterBox host │
  ▼                                                       │              │
Adaptix Client renders verdict, detection summary,        │     EDR profile
progress strip, per-scanner detail panels.                ▼     dispatches
                                                  /analyze/edr/<P>/<md5>
                                                  Phase 1: exec on EDR VM
                                                  Phase 2: poll Elastic
                                                          for alerts

O plugin de serviço Go executa cada despacho de scanner em sua própria goroutine, então Executar Tudo emite Estática + Dinâmica + (um POST por perfil EDR) tudo em paralelo. O painel AXScript é atualizado ao vivo à medida que cada goroutine transmite de volta eventos progress e resultados.


Licença

Cheshire segue as convenções do LitterBox / Adaptix. Consulte as licenças dos projetos pais para detalhes.

Baixar ferramenta