Cheshire

Pre-Flight-Payload-QA für Adaptix, unterstützt von LitterBox.

Cheshire ist ein Adaptix C2 Service Plugin, das den Adaptix-Client mit einer LitterBox-Sandbox verbindet. Von innerhalb der Adaptix-Oberfläche kann ein Operator eine beliebige Binärdatei auswählen, sie durch LitterBoxs vollständige Analyse-Kette (statisch + dynamisch + jedes erreichbare EDR-Profil) schicken und das Urteil in Echtzeit beobachten, ohne Adaptix verlassen zu müssen.

Der Name folgt der Linie der Projektmaskottchen:

• Adaptix → Chamäleon
• LitterBox → mürrische Katze
• Die Brücke zwischen ihnen → Cheshire (die Katze, die grinst, auftaucht und verschwindet und dir sagt, ob der Weg vor dir sicher ist).

Was es macht

EDR Phase 2 Polling verwendet den adaptiven Rhythmus von LitterBox (2s Basis, ×1,5 Backoff bis zu 15s, wenn die Alarmzahl stabil ist, Rücksprung auf 2s bei Bewegung). Jeder Poll-Tick streamt ein progress-Ereignis an den Client, sodass der Live-Fortschrittsbalken die hochzählenden Alarmzahlen in Echtzeit anzeigen kann.

Aufbau

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)

Das Go-Plugin ist ein zustandsloses HTTP-Relay zwischen Adaptix' TsServiceSendDataClient und LitterBox' REST-API. Die AXScript-Datei übernimmt die gesamte Darstellung – Urteilsbanner, Erkennungszusammenfassung, pro Scanner Unterregisterkarten, EDR-Alarmtabelle mit Klick-auf-Detail.

Einrichtung

1. LitterBox starten

Cheshire benötigt eine laufende LitterBox-Instanz (siehe LitterBox-Repository für die Installation). Überprüfen Sie die Erreichbarkeit:

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

2. Cheshire konfigurieren

Bearbeiten Sie cheshire_service/config.yaml und setzen Sie 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"

Fehlt litterbox_url, lädt das Plugin zwar, aber jeder Operator-Befehl gibt "Cheshire is not configured: set litterbox_url in service_config" zurück. Es gibt keine Fallback-Standardkonfiguration.

3. Bereitstellen

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

Dies:

1. Kopiert die Quelle nach AdaptixC2/AdaptixServer/extenders/cheshire_service/.
2. Fügt ./extenders/cheshire_service zum Go-Workspace hinzu.
3. Baut service_cheshire.so über das Makefile.
4. Kopiert die gebaute .so + config.yaml + ax_config.axs nach AdaptixC2/dist/extenders/cheshire_service/.

4. Beim Adaptix-Server registrieren

Fügen Sie eine Zeile in AdaptixC2/dist/profile.yaml unter Teamserver.extenders hinzu:

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

5. Server neu starten

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

Sie sollten [cheshire] Initialized — LitterBox at http://... im Server-Log sehen, gefolgt von [+] Service 'cheshire' loaded.

In der Menüleiste des Adaptix-Clients öffnet Cheshire → Test with Cheshire das Dashboard.

Dashboard

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

Urteil + Umfang

• ⏳ LÄUFT — N Treffer bisher während ein geplanter Scanner in Bearbeitung ist.
• 🚫 ERKANNT — N Treffer über X Static, Y Dynamic, Z EDR [maxSev] sobald jeder geplante Scanner einen Endzustand erreicht hat.
• ✓ SAUBER — 0 kritische/hohe/mittlere Erkennungen nur wenn keine echten Treffer bei einem Scanner vorliegen. Informationssignale (NIEDRIG/INFO) werden separat vermerkt, nicht in der Überschrift.
• (Nur statisch) / (Dynamisch + EDR) usw. wird angehängt, wenn der Operator einen einzelnen Scanner anstatt Alle ausführen startet – das Urteil spiegelt ehrlich wider, was tatsächlich ausgeführt wurde.

Erkennungszusammenfassung

Aggregiert jede Erkennung über alle Scanner in einer sortierbaren Tabelle. Die Zeilen werden aus dem tatsächlichen JSON extrahiert, das LitterBox zurückgibt (keine generischen Faktor-Strings):

• YARA / YARA-mem-Regeln mit Schweregrad + Bedrohungsname + erstem übereinstimmenden String-Identifikator
• CheckPlz initial_threat + scan_results.detection_offset
• Stringnalyzer-Zählungen gefährlicher Kategorien
• PE-Sieve total_suspicious + Zählungen pro Indikator
• Moneta Nicht-Null total_*-Anomaliezählungen (Private RWX → KRITISCH, usw.)
• Patriot pro Fund level + type + erste 120 Zeichen von details
• HSB pro Fund Schweregrad + Typ + Thread-ID
• RedEdr Defender-Ereignisse gefiltert nach category === 'threat'
• EDR-Alarme: Regel + Schweregrad + Prozess + API-Zusammenfassung

Sortiert nach Schweregrad absteigend, dann nach Scanner-Name.

Automatische Bereinigung

Wenn der Dialog geschlossen wird, wird die md5 des aktuellen Samples via DELETE /file/<md5> von LitterBox gelöscht. Es sammeln sich keine veralteten Samples zwischen den Einsätzen an.

Architektur

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

Das Go-Service-Plugin führt jeden Scanner-Dispatch in einer eigenen Goroutine aus, sodass Alle ausführen Static + Dynamic + (ein POST pro EDR-Profil) alle parallel ausführt. Das AXScript-Dashboard aktualisiert live, während jede Goroutine progress- und Ergebnisereignisse zurückschickt.

Lizenz

Cheshire folgt den Konventionen von LitterBox / Adaptix. Details entnehmen Sie bitte den Lizenzen der übergeordneten Projekte.