Nightcrawler

Un agent de test d'intrusion autonome qui fonctionne entièrement sur un smartphone. Déposez le téléphone sur un réseau, éloignez-vous, et il découvre les hôtes, cartographie les services, trouve les vulnérabilités et génère un rapport de pentest — le tout sans connexion cloud.

 ░█▄░█ █ █▀▀ █░█ ▀█▀ █▀▀ █▀█ ▄▀█ █░█░█ █░░ █▀▀ █▀█
 ░█░▀█ █ █▄█ █▀█ ░█░ █▄▄ █▀▄ █▀█ ▀▄▀▄▀ █▄▄ ██▄ █▀▄  v0.1.0

 AUTONOMOUS MOBILE PENTEST AGENT
 OnePlus 8 · NetHunter · LFM2.5-1.2B · OpenCL GPU

Qu'est-ce que c'est ?

Le test d'intrusion (pentest) est la pratique qui consiste à tester la sécurité d'un réseau informatique en simulant une attaque — avec l'autorisation explicite du propriétaire du réseau. Les pentesters professionnels sont engagés pour trouver les vulnérabilités avant que de vrais attaquants ne le fassent.

Nightcrawler automatise ce processus sur un téléphone. Il utilise un petit modèle d'IA (LFM2.5-1.2B-Instruct-Heretic, 1,2 milliard de paramètres) exécuté localement sur le GPU du téléphone pour décider de la prochaine action — quel hôte sonder, quel outil utiliser, quoi chercher. Aucune connexion Internet ni API cloud requise.

Démo

▶️ Regardez Nightcrawler en action sur Instagram

Comment ça fonctionne

1. Brèche WiFi (optionnel) — Si déposé sans WiFi, il peut craquer de manière autonome les réseaux WPA2 à l'aide d'un adaptateur WiFi USB externe
2. Reconnaissance — Découvre les appareils sur le réseau à l'aide de scans furtifs
3. Énumération — Sonde les services découverts (serveurs web, partages de fichiers, SSH, DNS, etc.)
4. Exploitation — Teste les vulnérabilités connues et les identifiants par défaut
5. Rapport — Génère un rapport de pentest structuré avec les constatations et les recommandations de remédiation

L'agent fonctionne comme un pentester humain patient — il alterne entre les hôtes, effectue une petite action par tour et accumule des connaissances progressivement sur des heures. Cela le rend beaucoup plus difficile à détecter que les scanners de vulnérabilités traditionnels qui bombardent tous les hôtes à la fois.

Concepts clés

Architecture

┌──────────────────────────────────────────────────────────┐
│                   PHONE (OnePlus 8)                       │
│                                                           │
│  ┌─────────────┐     ┌──────────────────┐                │
│  │  LFM2.5     │     │  Agent Loop      │                │
│  │  1.2B model │◄───►│  (main.py)       │                │
│  │  on GPU     │     │  Decides what     │                │
│  │  (:8080)    │     │  to do next       │                │
│  └─────────────┘     └────────┬─────────┘                │
│                               │                           │
│                      ┌────────▼─────────┐                │
│                      │  Scope Proxy     │  ← Safety layer │
│                      │  Validates every │    Blocks out-  │
│                      │  command before  │    of-scope     │
│                      │  execution       │    actions      │
│                      └────────┬─────────┘                │
│                               │                           │
│                      ┌────────▼─────────┐                │
│                      │  Kali MCP Server │  ← Runs the    │
│                      │  nmap, curl,     │    actual       │
│                      │  smbclient, ...  │    commands     │
│                      └──────────────────┘                │
│                                                           │
│  ┌──────────────────┐  ┌──────────────────┐              │
│  │  Web Dashboard   │  │  SQLite DB       │              │
│  │  (:8888)         │  │  Hosts, vulns,   │              │
│  │  Monitor & steer │  │  creds, commands │              │
│  └──────────────────┘  └──────────────────┘              │
└──────────────────────────────────────────────────────────┘

Pour la conception complète du système, voir docs/ARCHITECTURE.md.

Fonctionnalités

• Entièrement autonome — aucun humain dans la boucle pendant le fonctionnement
• Inférence 100 % locale — l'IA s'exécute sur le GPU du téléphone, aucun cloud requis
• Périmètre imposé — défense à deux couches empêchant les actions hors périmètre
• Furtivité d'abord — taux de scan lents, rotation des hôtes, trafic de couverture, nmap -T2 uniquement
• 27 playbooks d'exploitation — chaînes d'attaque en plusieurs étapes qui s'exécutent automatiquement
• Base de données CVE de 24 956 entrées — correspondance des vulnérabilités selon les versions
• Tableau de bord web — surveillance en temps réel, gestion des hôtes, contrôles C2
• Mode brèche WiFi — craquage WPA2 autonome avec adaptateur USB (inspiré de Pwnagotchi)
• Découverte passive — capture en arrière-plan des diffusions mDNS/NBNS/DHCP/ARP
• Multi-réseau — données isolées par réseau, survit aux changements DHCP via des hôtes indexés par MAC
• Auto-réparation — détection des déchets, réinitialisation du contexte, chiens de garde, détection de blocage
• Capture d'entraînement — journalise les interactions réussies pour un futur affinage du modèle
• Génération de rapports — rapport de pentest téléchargeable avec vulnérabilités, chaînes d'exploitation, remédiation

Voir docs/FEATURES.md pour la référence complète des fonctionnalités.

Matériel

Requis

• Téléphone Android avec Kali NetHunter (testé sur OnePlus 8, Snapdragon 865)
• Accès root via Magisk
• 12 Go+ de RAM (le modèle utilise ~1,3 Go, Android ~4 Go, le reste pour les outils)

Optionnel

• Adaptateur WiFi USB pour le mode brèche WiFi hors ligne (Ralink RT3572 recommandé)
• Kernel personnalisé avec MAC80211 pour le mode moniteur (guide de compilation)
• NVIDIA AGX pour décharger vers un modèle plus grand via Tailscale

Performances GPU

Toute l'inférence via OpenCL sur GPU Adreno 650 :

Remarque : Android limite le GPU sur batterie (ralentissement x6). Nightcrawler inclut un démon de régulation GPU qui force les performances maximales et réduit automatiquement à ≤15 % de batterie.

Démarrage rapide

# 1. Installation (dans le chroot Kali NetHunter)
bash INSTALL.sh

# 2. Attendre le démarrage de llama-server (~5 min après le boot)
curl -s http://127.0.0.1:8080/health  # Doit renvoyer {"status":"ok"}

# 3. Démarrer tous les services
bash scripts/run-36h.sh

# 4. Ouvrir le tableau de bord web (depuis n'importe quel appareil de votre réseau Tailscale)
# https://<votre-nom-dhote-tailscale>:8888

Essai à sec (aucune commande réelle exécutée)

NC_DRY_RUN=1 python3 main.py

Ceci utilise un serveur Kali simulé pour tester la boucle de l'agent sans exécuter de véritables commandes réseau.

Démarrage manuel (si vous n'utilisez pas le lanceur tmux)

kali-server-mcp --port 5000 &
python3 scope_proxy.py --config config.yaml --port 8800 --upstream http://127.0.0.1:5000 &
bash scripts/webui-daemon.sh start
python3 main.py &

Configuration

Modifiez config.yaml avant le déploiement :

mission:
  id: "CLIENT-YYYY-XXX"           # Votre ID d'engagement
  scope:
    networks: ["auto"]             # "auto" = détecter depuis wlan0 au démarrage
    excluded_hosts: ["auto"]       # "auto" = passerelle + IP propre
    excluded_ports: [502, 503]     # Ports SCADA/ICS à ne jamais toucher
  authorization: "ROE-YYYY-XXX.pdf"
  max_runtime_hours: 0             # 0 = aucune limite

model:
  local:
    ctx_size: 8192
    port: 8080

La détection dynamique du périmètre signifie zéro changement de configuration lors des déplacements entre réseaux — l'agent lit le sous-réseau actuel depuis wlan0 au démarrage.

Structure du projet

nightcrawler/
├── main.py                  # Point d'entrée
├── config.yaml              # Périmètre de mission + configuration du modèle
├── scope_proxy.py           # Proxy d'application du périmètre
├── INSTALL.sh               # Installateur
│
├── agent/                   # Logique centrale de l'agent
│   ├── loop.py              # Boucle de décision + récupération d'erreurs
│   ├── planner.py           # Machine à états de phase (recon → exploit)
│   ├── llm_client.py        # Client API LLM (llama.cpp / distant)
│   ├── db.py                # Backend SQLite (hôtes, vulns, identifiants)
│   ├── host_memory.py       # Observations par hôte + auto-étiquetage
│   ├── cve_db.py            # Base de données CVE de 24 956 entrées
│   ├── attack_planner.py    # Directives stratégiques pour la phase d'exploitation
│   ├── output_parser.py     # Extraction de données structurées depuis la sortie des outils
│   ├── offline_manager.py   # Machine à états du pipeline de brèche WiFi
│   ├── net_detect.py        # Auto-détection du réseau depuis wlan0
│   ├── cover_traffic.py     # Mélange furtif avec trafic web réaliste
│   ├── passive_capture.py   # tcpdump en arrière-plan pour le trafic de diffusion
│   └── ...
│
├── proxy/                   # Composants d'application du périmètre
│   ├── scope.py             # Validation IP/port/hôte
│   ├── rate_limiter.py      # Limitation du débit de commandes + gigue
│   └── command_filter.py    # Liste noire des commandes destructrices
│
├── webui/                   # Tableau de bord web (Flask)
│   ├── server.py            # API + middleware furtif
│   └── templates/index.html # Interface du tableau de bord
│
├── data/                    # Fichiers de données statiques
│   ├── cve_exploits.json    # Mappages CVE→commandes d'exploitation
│   └── playbooks.json       # 27 playbooks d'attaque en plusieurs étapes
│
├── prompts/                 # Modèles de prompts LLM (rechargeables à chaud)
├── scripts/                 # Scripts opérationnels (démarrage, arrêt, chiens de garde)
├── tests/                   # Suites de tests (API, UI, mode hors ligne)
├── kernels/                 # Modules de pilotes WiFi + documentation kernel
├── simulation/              # Serveur simulé pour essai à sec
├── docs/                    # Architecture, configuration GPU, fonctionnalités
├── logs/                    # Données d'exécution (ignorées par git)
└── models/                  # Fichiers de modèles (ignorés par git)

Comment l'agent raisonne

L'agent utilise une boucle simple mais efficace :

1. Choisir une cible — sélection aléatoire pondérée (70 % d'hôtes avec ports connus, 30 % de nouvelle découverte)
2. Construire le contexte — injecter la mémoire de l'hôte, les observations réseau, les directives de phase dans le prompt
3. Interroger le LLM — le modèle produit REASONING: ... COMMAND: ...
4. Valider — le proxy de périmètre vérifie que la commande est dans le périmètre et non destructrice
5. Exécuter — la commande s'exécute via le serveur Kali MCP
6. Apprendre — l'analyseur de sortie extrait les constatations, met à jour la mémoire de l'hôte
7. Réinitialiser le contexte — effacer la conversation, conserver la mémoire persistante, répéter

Le modèle de 1,2 B a un taux de réussite de commandes d'environ 50 % (inhérent à sa taille). L'agent compense avec :

• Détection des déchets — réinitialisation après 5 échecs avec exemples few-shot variés
• Détection des doublons — force la diversification des outils/cibles
• Détection de blocage basée sur le temps — filet de sécurité de 5 minutes forçant la réinitialisation du contexte
• Exécution directe des playbooks — les attaques en plusieurs étapes contournent entièrement le LLM

Tableau de bord web

Le tableau de bord sur :8888 fournit une surveillance et un contrôle en temps réel :

• Flux en direct — chaque commande, constatation et décision de l'agent
• Cartes d'hôtes — cartes cliquables montrant les ports, services, vulnérabilités
• Carte réseau — graphe interactif à force dirigée (glisser, zoomer, déplacer)
• Détails des vulnérabilités — balises CVE, chaînes d'exploitation, étapes de remédiation
• Contrôles C2 — favoriser/mettre sur liste noire des hôtes, forcer la phase, pause/reprise, injecter des commandes
• Mode hors ligne — interface d'attaque WiFi inspirée de Pwnagotchi avec visage animé

Le tableau de bord est filtré pour la furtivité : il usurpe les en-têtes nginx et renvoie des 404 vides aux connexions provenant du réseau cible.

Résultats testés

Issus de plus de 72 heures d'opération autonome sur plusieurs réseaux :

• 30+ hôtes découverts par réseau
• 2 000+ commandes exécutées de manière autonome
• 10+ vulnérabilités trouvées sur plusieurs services
• 6+ playbooks exécutés via exécution directe
• Mémoire de l'agent stable à 35-50 Mo tout au long (aucune fuite)

Contribuer

Les contributions sont les bienvenues ! Voir CONTRIBUTING.md pour les directives.

Domaines où l'aide est nécessaire

• Affinage du modèle — améliorer la conformité du format de commande de ~50 % à 85 %+
• Nouveaux playbooks — ajouter des chaînes d'exploitation pour plus de services
• Base de données CVE — étendre la couverture au-delà des 24 956 entrées actuelles
• Support des adaptateurs — tests avec plus de chipsets WiFi USB
• Documentation — tutoriels, guides d'installation pour différents téléphones
• Tests — plus de couverture de tests, en particulier pour les cas limites

Configuration de développement

# Cloner le dépôt
git clone https://github.com/garagehq/nightcrawler.git
cd nightcrawler

# Mode essai à sec (aucune commande réelle, aucun matériel requis)
NC_DRY_RUN=1 python3 main.py

# Exécuter les tests
python3 -m pytest tests/

Légal

Cet outil est destiné uniquement aux tests d'intrusion autorisés. Vous devez disposer d'une autorisation écrite (Règles d'engagement) du propriétaire du réseau avant de déployer Nightcrawler. Toute utilisation non autorisée contre des réseaux que vous ne possédez pas ou pour lesquels vous n'avez pas la permission de tester est illégale.

Licence

MIT — voir LICENSE pour les détails.

Soutien

Si vous appréciez ce projet, vous pouvez m'offrir un café ☕ :

buymeacoffee.com/cyrilengmann