Cheshire

Pré-vol QA du payload pour Adaptix, propulsé par LitterBox.

Cheshire est un plugin de service C2 pour Adaptix qui fait le pont entre le client Adaptix et un sandbox LitterBox. Depuis l'interface Adaptix, un opérateur peut sélectionner n'importe quel binaire, le soumettre à la chaîne d'analyse complète de LitterBox (statique + dynamique + chaque profil EDR accessible), et voir le verdict apparaître sans jamais quitter Adaptix.

Le nom suit la lignée des mascottes du projet :

• Adaptix → caméléon
• LitterBox → chat grincheux
• Le pont entre les deux → Cheshire (le chat qui sourit, apparaît et disparaît, et vous dit si la voie à suivre est sûre).

Ce qu'il fait

Le polling Phase 2 EDR utilise la cadence adaptative de LitterBox (base 2s, backoff ×1.5 jusqu'à 15s quand le nombre d'alertes est stable, retour à 2s dès qu'il y a du mouvement). Chaque tick de polling envoie un événement progress au client afin que la bande de progression en direct puisse afficher les compteurs d'alertes qui montent en temps réel.

Structure

Cheshire/
├── README.md
├── setup_cheshire.sh                       deploy script
└── cheshire_service/
    ├── config.yaml                         service plugin manifest + litterbox_url
    ├── go.mod / go.sum
    ├── Makefile                            builds dist/service_cheshire.so
    ├── pl_main.go                          Go service plugin (HTTP client to LitterBox)
    └── ax_config.axs                       AXScript UI (the dashboard dialog)

Le plugin Go est un relais HTTP sans état entre TsServiceSendDataClient d'Adaptix et l'API REST de LitterBox. Le fichier AXScript est responsable de tout le rendu — bannière de verdict, résumé des détections, sous-onglets par scanner, tableau d'alertes EDR avec clic pour le détail.

Installation

1. Démarrer LitterBox

Cheshire nécessite une instance LitterBox en cours d'exécution (voir le dépôt LitterBox pour l'installation). Vérifiez l'accessibilité :

curl http://<litterbox-host>:1337/health

2. Configurer Cheshire

Modifiez cheshire_service/config.yaml et définissez litterbox_url :

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"

Si litterbox_url est absent, le plugin se charge mais chaque commande opérateur renvoie "Cheshire is not configured: set litterbox_url in service_config". Il n'y a pas de valeur par défaut de secours.

3. Déployer

bash setup_cheshire.sh --ax /path/to/AdaptixC2

Ce script :

1. Copie la source vers AdaptixC2/AdaptixServer/extenders/cheshire_service/.
2. Ajoute ./extenders/cheshire_service à l'espace de travail Go.
3. Compile service_cheshire.so via le Makefile.
4. Copie le .so compilé + config.yaml + ax_config.axs vers AdaptixC2/dist/extenders/cheshire_service/.

4. Enregistrer auprès du serveur Adaptix

Ajoutez une ligne à AdaptixC2/dist/profile.yaml sous Teamserver.extenders :

extenders:
  - "extenders/cheshire_service/config.yaml"
  ...

5. Redémarrer le serveur

pkill -f adaptixserver
cd AdaptixC2/dist
./adaptixserver -profile profile.yaml

Vous devriez voir [cheshire] Initialized — LitterBox at http://... dans le journal du serveur, suivi de [+] Service 'cheshire' loaded.

Dans la barre de menus du client Adaptix, Cheshire → Test with Cheshire ouvre le tableau de bord.

Tableau de bord

┌─ 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          │
└─────────────────────────────────────────────────────────────────────────┘

Verdict + portée

• ⏳ RUNNING — N hit(s) so far tant qu'un scanner planifié est en cours d'exécution.
• 🚫 DETECTED — N hit(s) across X Static, Y Dynamic, Z EDR [maxSev] dès que chaque scanner planifié atteint un état terminal.
• ✓ CLEAN — 0 critical/high/medium detections uniquement si aucun scanner ne remonte de vrai hit. Les signaux informatifs (LOW/INFO) sont notés séparément, pas dans le titre.
• (Static only) / (Dynamic + EDR) etc. est ajouté quand l'opérateur lance un scanner individuel au lieu de Run All — le verdict reflète honnêtement ce qui a réellement été exécuté.

Résumé des détections

Agrège toutes les détections de tous les scanners dans un tableau triable. Les lignes sont extraites du JSON réel renvoyé par LitterBox (pas de simples chaînes génériques) :

• Règles YARA / YARA-mem avec sévérité + nom de la menace + identifiant de la première chaîne correspondante
• CheckPlz initial_threat + scan_results.detection_offset
• Compteurs de catégories dangereuses de Stringnalyzer
• PE-Sieve total_suspicious + compteurs par indicateur
• Moneta compteurs d'anomalies total_* non nuls (Private RWX → CRITICAL, etc.)
• Patriot level + type par constatation + les 120 premiers caractères de details
• HSB sévérité + type + identifiant de thread par constatation
• Événements RedEdr Defender filtrés sur category === 'threat'
• Alertes EDR : règle + sévérité + processus + résumé API

Triées par sévérité décroissante, puis par nom de scanner.

Nettoyage automatique

Lorsque la boîte de dialogue se ferme, le md5 de l'échantillon courant est effacé de LitterBox via DELETE /file/<md5>. Aucun échantillon obsolète ne s'accumule entre les engagements.

Architecture

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

Le plugin de service Go exécute chaque envoi de scanner dans sa propre goroutine, donc Run All lance Static + Dynamic + (un POST par profil EDR) en parallèle. Le tableau de bord AXScript se met à jour en direct à mesure que chaque goroutine renvoie des événements progress et de résultat.

Licence

Cheshire suit les conventions de LitterBox / Adaptix. Voir les licences des projets parents pour plus de détails.