Skip to content
KitploitKITPLOIT
OutilsExploitsBlog
Log in
Soumettre
OutilsExploitsBlog
Soumettre

Outils de Hacking, PenTest et Cybersécurité pour votre Arsenal de Sécurité !

Kitploit est un répertoire d'outils de hacking, de cybersécurité et de pentesting. Découvrez les dernières mises à jour des projets pour trouver des vulnérabilités, analyser des systèmes, automatiser les tests et renforcer votre sécurité.

FluxContactConfidentialité© 2026 Kitploit

Répertoire d'outils

Catégories

Voir toutes les catégories
Loading categories
nightcrawler — Assistant local IA propulsé par IA pour red team sur téléphone | Kitploit
Outils/GitHubGitHub/garagehq/nightcrawler
Cassage de Mots de PasseReconnaissanceAudit Wi-FiAnalyse des VulnérabilitésExploitationÉvasion IDS/IPSTests d'IntrusionCommandement et ContrôleRed TeamingSécurité de l'IA
GitHub
67956121il y a 3 moisVérifié par Kitploit
Partager
garagehq/nightcrawler

nightcrawler

Assistant local IA propulsé par IA pour red team sur téléphone

Voir le dépôt
# 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](https://www.instagram.com/p/DYNXFvVN0c_/)**

### 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

| Terme | Signification |
|------|--------------|
| **Drop box** | Un appareil laissé sur un réseau cible pour effectuer des tests de manière autonome |
| **Périmètre (Scope)** | L'ensemble des réseaux/hôtes que vous êtes autorisé à tester |
| **Règles d'engagement (ROE)** | Un document juridique spécifiant ce que vous êtes autorisé à faire |
| **Furtivité** | Techniques pour éviter la détection par la surveillance réseau (IDS/IPS) |
| **MCP** | Model Context Protocol — une interface standard pour l'utilisation d'outils par l'IA |
| **C2** | Command and Control — le tableau de bord web pour surveiller et diriger l'agent |

## 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](https://github.com/garagehq/nightcrawler/blob/main/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](https://github.com/garagehq/nightcrawler/blob/main/docs/FEATURES.md) pour la référence complète des fonctionnalités.

## Matériel

### Requis
- **Téléphone Android** avec [Kali NetHunter](https://www.kali.org/docs/nethunter/) (testé sur OnePlus 8, Snapdragon 865)
- **Accès root** via [Magisk](https://github.com/topjohnwu/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](https://github.com/garagehq/nightcrawler/blob/main/docs/KERNEL_BUILD_PROMPT.md))
- **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 :

| Modèle | Quantification | Vitesse de prompt | Vitesse de génération |
|-------|-------------|-------------|-----------------|
| **LFM2.5-1.2B-Instruct-Heretic** (production) | Q8_0 | 115 tok/s | 13 tok/s |
| Qwen3.5-0.8B | Q8_0 | 30,5 tok/s | 6,3 tok/s |
| Qwen3.5-4B | Q4_0 | 10,1 tok/s | 2,0 tok/s |

> **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

```bash
# 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)

```bash
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)

```bash
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 :

```yaml
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](https://github.com/garagehq/nightcrawler/blob/main/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

```bash
# 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](https://github.com/garagehq/nightcrawler/blob/main/LICENSE) pour les détails.

## Soutien

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

<a href="https://buymeacoffee.com/cyrilengmann" target="_blank"><img src="https://assets.kitploit.com/production/public/readmes/47403/322a7c99f1dd15a03b3c1b00b0d18ddd87443d80b823d3467a240721ae02357e.webp" alt="Buy Me A Coffee" height="50" width="210"></a>

> **[buymeacoffee.com/cyrilengmann](https://buymeacoffee.com/cyrilengmann)**
Télécharger l’outil

Populaires

Voir tout →

Découvrez les outils les plus utilisés par notre communauté.

  • 1

    OsintHunter

    letox4/osinthunter

    🎯 La boîte à outils OSINT ultime : graphe d'enquête, notation de confiance, familles d'alias, carte, chronologie et rapports. 49 modules, plus de 400 sites, aucune clé API requise.

    994
  • 2

    ghostlock-app

    yukonga/ghostlock-app

    # Application d'exécution en un clic GhostLock (CVE-2026-43499)

    656
  • 3

    looking-glass

    anonghosty/looking-glass

    Plateforme CSIRT qui ingère les rapports Shadowserver dans MongoDB et les rejoue sous forme de cartes interactives, d'analyses, de constats, d'avis et de tableaux de bord exécutifs.

    422
  • 4

    jumpserver

    jumpserver/jumpserver

    JumpServer est une plateforme open-source de Gestion des Accès Privilégiés (PAM) qui offre aux équipes DevOps et IT un accès sécurisé et à la demande aux terminaux SSH, RDP, Kubernetes, bases de données et RemoteApp via un navigateur web.

    389
  • 5

    SafeLine

    chaitin/safeline

    WAF auto-hébergé et proxy inverse qui filtre le trafic HTTP malveillant, bloque les injections SQL, les XSS et les attaques de robots, avec limitation de débit et chiffrement dynamique HTML/JS.

    333
  • 6

    ARTEX

    baarai/artex

    Plateforme autonome de tests d'intrusion multi-agents basée sur des LLM, avec agents planificateur/ouvrier, graphes d'actifs et d'exploration, enregistrement du trafic MITM et retest des vulnérabilités.

    330

Explorer tous les outils

Parcourez notre collection d'outils

Voir tous les outils →