docs: update all documentation for v0.3.0

Reflect new module architecture, deploy system, Docker support, honeypot dashboard, and tunnel proxy in documentation. Updated French README.
2026-02-28 20:16:16 +01:00 · 2026-02-28 20:16:16 +01:00 · 31c312f085
commit 31c312f085
parent 12b851581a
5 changed files with 187 additions and 139 deletions
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -131,7 +131,7 @@ Thank you for your interest in contributing to Espilon! This document provides g
 - Tests and test infrastructure
 - Security enhancements
 - Translations
- Tool improvements (C2, flasher, etc.)
+- Tool improvements (C2, deploy, etc.)

 **Getting started**:

@ -348,7 +348,8 @@ mypy tools/c2/
 - `chore`: Build system, dependencies, etc.

 **Scope** (optional): Module or component affected
- `core`, `mod_network`, `mod_fakeap`, `c2`, `docs`, etc.
+
+- `core`, `mod_network`, `mod_fakeap`, `mod_tunnel`, `mod_redteam`, `mod_honeypot`, `mod_canbus`, `c2`, `docs`, etc.

 **Examples**:
 ```
@ -589,17 +590,20 @@ epsilon/
 ├── espilon_bot/              # ESP32 firmware
 │   ├── components/           # Modular components
 │   │   ├── core/             # Core functionality
-│   │   ├── command/          # Command system
 │   │   ├── mod_system/       # System module
-│   │   ├── mod_network/      # Network module
+│   │   ├── mod_network/      # Network + Tunnel module
 │   │   ├── mod_fakeAP/       # FakeAP module
-│   │   └── mod_recon/        # Recon module
+│   │   ├── mod_recon/        # Recon module
+│   │   ├── mod_redteam/      # Red Team module
+│   │   ├── mod_honeypot/     # Honeypot module
+│   │   ├── mod_canbus/       # CAN Bus module
+│   │   ├── mod_fallback/     # Fallback connectivity
+│   │   └── mod_ota/          # OTA updates
 │   └── main/                 # Main application
 ├── tools/                    # Supporting tools
 │   ├── C3PO/                 # C2 server (Python)
-│   ├── flasher/              # Multi-flasher tool
-│   ├── provisioning/         # Device key provisioning
-│   └── nan/                  # NanoPB tools
+│   ├── deploy.py             # Unified build, provision & flash
+│   └── nanoPB/               # Protobuf definitions
 ├── docs/                     # Documentation
 │   ├── INSTALL.md
 │   ├── HARDWARE.md
--- a/QUICKSTART.md
+++ b/QUICKSTART.md
@ -112,6 +112,7 @@ Then open http://localhost:8000. Pages available:
 | Page | URL | Description |
 |------|-----|-------------|
 | Dashboard | `/dashboard` | Device list and status |
+| Tunnel | `/tunnel` | SOCKS5 tunnel proxy management |
 | Cameras | `/cameras` | Live camera feeds |
 | MLAT | `/mlat` | Multilateration map |
 | OTA | `/ota` | Firmware build & deploy |
@ -128,6 +129,8 @@ send <id> system_mem              Memory usage
 send <id> ping <host>             ICMP ping
 send <id> arp_scan                Scan local network
 send <id> fakeap_start <ssid>     Start a fake AP (if module enabled)
+send <id> tun_start <ip> 2627    Start SOCKS5 tunnel proxy to C3PO
+send <id> tun_stop               Stop tunnel proxy
 send all system_info              Broadcast to all devices
 group add scanners <id1> <id2>    Create device group
 send group scanners arp_scan      Send to group
--- a/README.fr.md
+++ b/README.fr.md
@ -27,8 +27,13 @@
  - [Network Module](#network-module)
  - [FakeAP Module](#fakeap-module)
  - [Recon Module](#recon-module)
+  - [Red Team Module](#red-team-module)
+  - [Honeypot Module](#honeypot-module)
+  - [Tunnel Module](#tunnel-module-proxy-socks5)
+  - [CAN Bus Module](#can-bus-module-mcp2515)
+  - [OTA Module](#ota-module)
 - [Outils](#outils)
-  - [Multi-Device Flasher](#multi-device-flasher)
+  - [Deploy Tool](#deploy-tool)
  - [C2 Server (C3PO)](#c2-server-c3po)
 - [Sécurité](#sécurité)
  - [Chiffrement](#chiffrement)
@ -57,7 +62,7 @@ La documentation MkDocs inclut :
 - Traduction EN/FR
 - Configuration WiFi et GPRS
 - Référence des modules et commandes
- Guide du flasher multi-device
+- Guide du deploy tool
 - Spécification du protocole C2
 - Exemples et cas d'usage
 ```
@ -143,7 +148,8 @@ Espilon transforme des microcontrôleurs ESP32 abordables à **~5€** en agents
 │         ↓              ↓                 ↓          │
 │  ┌───────────────────────────────────────────────┐  │
 │  │         Module System (FreeRTOS)              │  │
-│  │  [Network] [FakeAP] [Recon] [Custom...]       │  │
+│  │  [Network] [Tunnel] [FakeAP] [Recon]          │  │
+│  │  [RedTeam] [Honeypot] [CAN Bus] [OTA]         │  │
 │  └───────────────────────────────────────────────┘  │
 └─────────────────────────────────────────────────────┘
                        ↕ Encrypted TCP
@ -151,7 +157,7 @@ Espilon transforme des microcontrôleurs ESP32 abordables à **~5€** en agents
              │   C2 Server (C3PO)   │
              │  - Device Registry   │
              │  - Group Management  │
-              │  - CLI Interface     │
+              │  - TUI + Web UI      │
              └──────────────────────┘
 ```

@ -159,15 +165,14 @@ Espilon transforme des microcontrôleurs ESP32 abordables à **~5€** en agents

 - **Core** : Connexion réseau, ChaCha20-Poly1305 AEAD + dérivation HKDF, protocole nanoPB
 - **Modules** : Système extensible (Network, FakeAP, Recon, etc.)
- **C2 (C3PO)** : Serveur Python asyncio pour contrôle multi-agents
- **C3PO**: Ancien c2 (serveur web - Trilateration + Front affichage caméra)
- **Flasher** : Outil de flash multi-device automatisé
+- **C2 (C3PO)** : Serveur Python asyncio + dashboard web pour contrôle multi-agents
+- **Deploy** : Pipeline unifié build, provision & flash (`tools/deploy.py`)

 ---

 ## Modules Disponibles

-> **Note importante** : Les modules sont **mutuellement exclusifs**. Vous devez choisir **un seul module** lors de la configuration via menuconfig.
+> Les modules s'activent indépendamment via `idf.py menuconfig` → Espilon Bot Configuration → Modules. Plusieurs modules peuvent être actifs simultanément (selon les contraintes flash/RAM).

 ### System Module (Built-in, toujours actif)

@ -179,13 +184,14 @@ Commandes système de base :

 ### Network Module

-Module pour reconnaissance et tests réseau :
+Module pour reconnaissance, tests réseau et proxy tunnel SOCKS5 :

 - `ping <host> [args...]` : Test de connectivité ICMP
 - `arp_scan` : Découverte des hôtes sur le réseau local via ARP
- `proxy_start <ip> <port>` : Démarrer un proxy TCP
- `proxy_stop` : Arrêter le proxy en cours
 - `dos_tcp <ip> <port> <count>` : Test de charge TCP (à usage autorisé uniquement)
+- `tun_start <ip> <port>` : Démarrer le proxy tunnel SOCKS5 vers C3PO (nécessite `CONFIG_MODULE_TUNNEL`)
+- `tun_stop` : Arrêter le tunnel
+- `tun_status` : Statut du tunnel (channels, bytes, mode chiffrement)

 ### FakeAP Module

@ -214,84 +220,108 @@ Module de reconnaissance et collecte de données. Deux modes disponibles :
 - `trilat start <mac> <url> <bearer>` : Démarrer la trilatération BLE avec POST HTTP
 - `trilat stop` : Arrêter la trilatération

+### Red Team Module
+
+Hunt WiFi autonome, attaques de credentials, et mesh relay ESP-NOW :
+
+- `rt_hunt` : Lancer le cycle scan + attaque WiFi autonome
+- `rt_stop` : Arrêter le hunt
+- `rt_status` : Cibles en cours, progression, credentials capturés
+- `rt_scan` : Scan passif des APs (mode promiscuous, sans association)
+- `rt_net_add <ssid> <pass>` / `rt_net_list` : Gérer les réseaux connus
+- `rt_mesh` : Activer le relay ESP-NOW mesh (multi-hop vers C2 hors portée)
+- Stealth : randomisation MAC, scan passif, contrôle puissance TX
+
+### Honeypot Module
+
+Faux services réseau qui loggent les interactions des attaquants :
+
+- `hp_start` / `hp_stop` : Démarrer/arrêter tous les services
+- Services émulés : SSH, Telnet, HTTP, FTP (ports configurables)
+- `hp_wifi_mon_start` / `hp_wifi_mon_stop` : Monitor WiFi (probe, deauth, EAPOL, beacon flood)
+- `hp_net_mon_start` / `hp_net_mon_stop` : Détection anomalies réseau (port scan, SYN flood)
+- Tous les events remontés au C2 au format `EVT|` (dashboard honeypot C3PO)
+
+### Tunnel Module (Proxy SOCKS5)
+
+Proxy tunnel SOCKS5 multiplexé à travers l'ESP32. Utilise n'importe quel outil réseau (`curl`, `nmap`, `proxychains`) pour pivoter à travers le bot sur le réseau cible.
+
+- Le SOCKS5 tourne côté C3PO (port 1080) — l'ESP32 ne gère que des frames binaires
+- Jusqu'à 8 connexions TCP simultanées (configurable via Kconfig)
+- Résolution DNS côté ESP32 (voit les DNS internes du réseau cible)
+- Reconnexion automatique avec backoff exponentiel
+- Chiffrement AEAD ChaCha20-Poly1305 par frame optionnel
+
+**Ports C3PO** : 2626 (commandes C2) + 2627 (données tunnel) + 1080 (SOCKS5, localhost uniquement)
+
+```bash
+# Démarrer le tunnel depuis le C2
+send <device_id> tun_start <c3po_ip> 2627
+
+# Utiliser n'importe quel outil à travers le proxy
+curl --socks5-hostname 127.0.0.1:1080 http://cible-interne.local
+nmap -sT -Pn --proxies socks4://127.0.0.1:1080 192.168.x.0/24
+```
+
+Voir [TUNNEL.md](TUNNEL.md) pour la spécification complète du protocole et le guide de test.
+
+### CAN Bus Module (MCP2515)
+
+CAN bus automobile via contrôleur SPI externe MCP2515 :
+
+- `can_start [bitrate] [mode]` : Init bus (normal/listen/loopback)
+- `can_sniff [duration]` / `can_record` / `can_replay` : Capture et replay
+- `can_send <id> <data>` : Injection de trame
+- UDS : `can_scan_ecu`, `can_uds_read`, `can_uds_dump`, `can_uds_auth`
+- OBD-II : `can_obd <pid>`, `can_obd_vin`, `can_obd_dtc`, `can_obd_monitor`
+- Fuzzing : `can_fuzz_id`, `can_fuzz_data`, `can_fuzz_random`
+
+### OTA Module
+
+Mises à jour firmware over-the-air depuis le serveur C2 :
+
+- Téléchargement firmware HTTPS sécurisé (fallback HTTP optionnel)
+- Schéma dual partition (A/B) pour rollback sécurisé
+- Reporting de progression vers le C2
+
 ---

 **Configuration** : `idf.py menuconfig` → Espilon Bot Configuration → Modules

-Choisissez **un seul module** :
-
- `CONFIG_MODULE_NETWORK` : Active le Network Module
- `CONFIG_MODULE_FAKEAP` : Active le FakeAP Module
- `CONFIG_MODULE_RECON` : Active le Recon Module
-  - Puis choisir : `Camera` ou `BLE Trilateration`
+- `CONFIG_MODULE_NETWORK` : Network Module
+- `CONFIG_MODULE_FAKEAP` : FakeAP Module
+- `CONFIG_MODULE_RECON` : Recon Module (Camera ou BLE Trilateration)
+- `CONFIG_MODULE_REDTEAM` : Red Team Module
+- `CONFIG_MODULE_HONEYPOT` : Honeypot Module
+- `CONFIG_MODULE_TUNNEL` : Proxy Tunnel SOCKS5 (nécessite `CONFIG_MODULE_NETWORK`)
+- `CONFIG_MODULE_CANBUS` : CAN Bus Module (nécessite hardware MCP2515)
+- `CONFIG_ESPILON_OTA_ENABLED` : OTA Updates

 ---

 ## Outils

-### Multi-Device Flasher
+### Deploy Tool

-Flasher automatisé pour configurer plusieurs ESP32 :
+Pipeline unifié pour **build**, **provisionner** (clés crypto), et **flasher** les ESP32 :

 ```bash
-cd tools/flasher
-python3 flash.py --config devices.json
+cd tools
+
+# Assistant interactif
+python3 deploy.py
+
+# Un seul device
+python3 deploy.py -p /dev/ttyUSB0 -d mon-device \
+    --wifi MonSSID MonMotDePasse --srv 192.168.1.100
+
+# Deploy batch
+python3 deploy.py --config deploy.example.json
 ```

-**devices.json** :
+Chaque deploy génère une **master key 256-bit** par device, l'écrit en factory NVS, et l'enregistre dans le keystore C2 (`keys.json`).

-```json
-{
-  "project": "/home/user/epsilon/espilon_bot",
-  "devices": [
-    ## WiFi AGENT ##
-    {
-      "device_id": "ce4f626b",
-      "port": "/dev/ttyUSB0",
-      "srv_ip": "192.168.1.13",
-      "srv_port": 2626,
-      "network_mode": "wifi",
-      "wifi_ssid": "MyWiFi",
-      "wifi_pass": "MyPassword123",
-      "hostname": "pixel-8-pro",
-      "module_network": true,
-      "module_recon": false,
-      "module_fakeap": false,
-      "recon_camera": false,
-      "recon_ble_trilat": false,
-    },
-
-    ## GPRS AGENT ##
-    {
-      "device_id": "a91dd021",
-      "port": "/dev/ttyUSB1",
-      "srv_ip": "203.0.113.10",
-      "srv_port": 2626,
-      "network_mode": "gprs",
-      "gprs_apn": "sl2sfr",
-      "hostname": "galaxy-s24-ultra",
-      "module_network": true,
-      "module_recon": false,
-      "module_fakeap": false
-    }
-  ]
-}
-```
-
-Voir [tools/flasher/README.md](tools/flasher/README.md) pour la documentation complète.
-
-### Provisioning des Devices
-
-Chaque device nécessite une master key unique flashée dans sa partition factory NVS :
-
-```bash
-cd tools/provisioning
-python3 provision.py --device-id mon-device --port /dev/ttyUSB0
-```
-
-Génère une clé aléatoire de 32 bytes, l'écrit en factory NVS, et la sauvegarde dans le keystore C2 (`keys.json`).
-
-Voir [tools/provisioning/](tools/provisioning/) pour les détails.
+Voir [tools/README.md](tools/README.md) pour la documentation complète (modes, batch config, OTA vs non-OTA, flash map).

 ### C2 Server (C3PO)

@ -317,7 +347,7 @@ Documentation complète et liste des commandes : voir [tools/C3PO/README.md](too
 - **Master keys per-device** stockées en partition factory NVS (read-only)
 - **Protocol Buffers (nanoPB)** pour la sérialisation

-Provisionner chaque device avec une master key unique via `tools/provisioning/provision.py`. Les clés ne sont jamais hardcodées dans le firmware.
+Provisionner chaque device avec une master key unique via `tools/deploy.py`. Les clés ne sont jamais hardcodées dans le firmware.

 ### Usage Responsable

@ -356,22 +386,26 @@ Espilon doit être utilisé uniquement pour :

 ## Roadmap

-### V2.0 (En cours)
+### V2.0 (Complet)

 - [x] Upgrade crypto ChaCha20-Poly1305 AEAD + HKDF
 - [x] Provisioning per-device factory NVS
 - [x] Réécriture C3PO avec crypto per-device
- [ ] Mesh networking (BLE/WiFi)
- [ ] OTA updates
- [ ] Multilatération collaborative
- [ ] Optimisation mémoire
+- [x] OTA firmware updates
+- [x] Module Red Team (hunt WiFi autonome)
+- [x] Module Honeypot (faux services + monitoring)
+- [x] Module CAN Bus (MCP2515 — sniff, inject, UDS, OBD-II, fuzzing)
+- [x] Web dashboard avec gestion devices, caméra, MLAT, OTA, CAN
+- [x] Proxy tunnel SOCKS5 (pivot multiplexé à travers l'ESP32)

 ### Future

+- [ ] Module BLE (scan, GATT enum, beacon spoofing)
+- [ ] Module Sub-GHz (CC1101 — 433/868/915 MHz)
+- [ ] Module BadUSB (ESP32-S2/S3 HID injection)
 - [ ] PCB custom Espilon
 - [ ] Support ESP32-S3/C3
 - [ ] Module SDK pour extensions tierces
- [ ] Web UI pour C2

 ---

@ -415,7 +449,7 @@ Contributions bienvenues ! Voir [CONTRIBUTING.md](CONTRIBUTING.md).
 - **[Documentation complète](https://docs.espilon.net)**
 - **[ESP-IDF Documentation](https://docs.espressif.com/projects/esp-idf/)**
 - **[LilyGO T-Call](https://github.com/Xinyuan-LilyGO/LilyGO-T-Call-SIM800)**
- **English README** : [README.en.md](README.en.md)
+- **English README** : [README.md](README.md)

 ---

--- a/README.md
+++ b/README.md
@ -31,10 +31,11 @@
  - [Recon Module](#recon-module)
  - [Red Team Module](#red-team-module)
  - [Honeypot Module](#honeypot-module)
+  - [Tunnel Module](#tunnel-module-socks5-proxy)
  - [CAN Bus Module](#can-bus-module-mcp2515)
  - [OTA Module](#ota-module)
 - [Tools](#tools)
-  - [Multi-Device Flasher](#multi-device-flasher)
+  - [Deploy Tool](#deploy-tool)
  - [C2 Server (C3PO)](#c2-server-c3po)
 - [Security](#security)
  - [Encryption](#encryption)
@ -63,7 +64,7 @@ The MkDocs documentation includes:
 - Translate EN/FR
 - WiFi and GPRS configuration
 - Module and command reference
- Multi-device flasher guide
+- Deploy tool guide
 - C2 protocol specification
 - Examples and use cases
 ```
@ -95,7 +96,7 @@ cd ~
 git clone https://github.com/Espilon-Net/epsilon-source.git
 cd Espilon-Net/espilon_bot

-# 3. Configure with menuconfig or tools/flasher/devices.json
+# 3. Configure with menuconfig or tools/deploy.py
 idf.py menuconfig

 # 4. Build and flash
@ -149,8 +150,8 @@ Espilon transforms affordable ESP32 microcontrollers (~$5) into powerful network
 |         |              |                 |              |
 |  +-----------------------------------------------------+|
 |  |           Module System (FreeRTOS)                  ||
-|  |  [Network] [FakeAP] [Recon] [RedTeam] [Honeypot]   ||
-|  |  [CAN Bus] [OTA] [Custom...]                        ||
+|  |  [Network] [Tunnel] [FakeAP] [Recon] [RedTeam]     ||
+|  |  [Honeypot] [CAN Bus] [OTA] [Custom...]             ||
 |  +-----------------------------------------------------+|
 +---------------------------------------------------------+
                        | Encrypted TCP
@ -158,7 +159,7 @@ Espilon transforms affordable ESP32 microcontrollers (~$5) into powerful network
              |   C2 Server (C3PO)  |
              |  - Device Registry  |
              |  - Group Management |
-              |  - CLI Interface    |
+              |  - TUI + Web UI     |
              +---------------------+
 ```

@ -167,7 +168,7 @@ Espilon transforms affordable ESP32 microcontrollers (~$5) into powerful network
 - **Core**: Network connection, ChaCha20-Poly1305 AEAD + HKDF key derivation, nanoPB protocol
 - **Modules**: Extensible system (Network, FakeAP, Recon, etc.)
 - **C2 (C3PO)**: Python asyncio server for multi-agent control
- **Flasher**: Automated multi-device flashing tool
+- **Deploy**: Unified build, provision & flash pipeline (`tools/deploy.py`)

 ---

@ -186,13 +187,14 @@ Basic system commands:

 ### Network Module

-Network reconnaissance and testing:
+Network reconnaissance, testing, and SOCKS5 tunnel proxy:

 - `ping <host> [args...]`: ICMP connectivity test
 - `arp_scan`: Discover hosts on local network via ARP
- `proxy_start <ip> <port>`: Start a TCP proxy
- `proxy_stop`: Stop the running proxy
 - `dos_tcp <ip> <port> <count>`: TCP load test (authorized use only)
+- `tun_start <ip> <port>`: Start SOCKS5 tunnel proxy to C3PO (requires `CONFIG_MODULE_TUNNEL`)
+- `tun_stop`: Stop the tunnel
+- `tun_status`: Tunnel status (channels, bytes, encryption mode)

 ### FakeAP Module

@ -238,6 +240,29 @@ Fake network services that log attacker interactions:
 - Network anomaly detection: ARP spoofing, port scanning alerts
 - All events streamed to C2 with attacker fingerprints

+### Tunnel Module (SOCKS5 Proxy)
+
+Multiplexed SOCKS5 tunnel proxy through the ESP32. Use any network tool (`curl`, `nmap`, `proxychains`) to pivot through the bot onto the target network.
+
+- SOCKS5 runs on C3PO (port 1080) — the ESP32 only handles binary frames
+- Up to 8 concurrent TCP connections (configurable via Kconfig)
+- DNS resolution on the ESP32 side (sees internal DNS of the target network)
+- Auto-reconnect with exponential backoff if C3PO connection drops
+- Optional per-frame ChaCha20-Poly1305 AEAD encryption
+
+**C3PO ports**: 2626 (C2 commands) + 2627 (tunnel data) + 1080 (SOCKS5, localhost only)
+
+```bash
+# Start tunnel from C2
+send <device_id> tun_start <c3po_ip> 2627
+
+# Use any tool through the proxy
+curl --socks5-hostname 127.0.0.1:1080 http://target-internal.local
+nmap -sT -Pn --proxies socks4://127.0.0.1:1080 192.168.x.0/24
+```
+
+See [TUNNEL.md](TUNNEL.md) for full protocol specification and testing guide.
+
 ### CAN Bus Module (MCP2515)

 Automotive CAN bus: sniff, inject, UDS diagnostics, OBD-II, and fuzzing via external MCP2515 SPI controller.
@ -268,6 +293,7 @@ Over-the-air firmware updates from C2 server:
 - `CONFIG_MODULE_RECON`: Recon Module (Camera or BLE Trilateration)
 - `CONFIG_MODULE_REDTEAM`: Red Team Module
 - `CONFIG_MODULE_HONEYPOT`: Honeypot Module
+- `CONFIG_MODULE_TUNNEL`: SOCKS5 Tunnel Proxy (requires `CONFIG_MODULE_NETWORK`)
 - `CONFIG_MODULE_CANBUS`: CAN Bus Module (requires MCP2515 hardware)
 - `CONFIG_ESPILON_OTA_ENABLED`: OTA Updates

@ -275,47 +301,27 @@ Over-the-air firmware updates from C2 server:

 ## Tools

-### Multi-Device Flasher
+### Deploy Tool

-Automated flasher to configure multiple ESP32s:
+Unified pipeline to **build**, **provision** (crypto keys), and **flash** ESP32 devices:

 ```bash
-cd tools/flasher
-python3 flash.py --config devices.json
+cd tools
+
+# Interactive wizard
+python3 deploy.py
+
+# Single device
+python3 deploy.py -p /dev/ttyUSB0 -d my-device \
+    --wifi MySSID MyPassword --srv 192.168.1.100
+
+# Batch deploy
+python3 deploy.py --config deploy.example.json
 ```

-**devices.json**:
+Each deploy generates a **256-bit master key** per device, writes it to the factory NVS partition, and registers it in the C2 keystore (`keys.json`).

-```json
-{
-  "project": "/path/to/espilon_bot",
-  "devices": [
-    {
-      "device_id": "esp001",
-      "port": "/dev/ttyUSB0",
-      "network_mode": "wifi",
-      "wifi_ssid": "MyNetwork",
-      "wifi_pass": "MyPassword",
-      "srv_ip": "192.168.1.100"
-    }
-  ]
-}
-```
-
-See [tools/flasher/README.md](tools/flasher/README.md) for complete documentation.
-
-### Device Provisioning
-
-Each device needs a unique master key flashed into its factory NVS partition before first use:
-
-```bash
-cd tools/provisioning
-python3 provision.py --device-id my-device --port /dev/ttyUSB0
-```
-
-This generates a 32-byte random master key, writes it to the factory NVS partition, and saves it to the C2 keystore (`keys.json`).
-
-See [tools/provisioning/](tools/provisioning/) for details.
+See [tools/README.md](tools/README.md) for complete documentation (modes, batch config, OTA vs non-OTA, flash map).

 ### C2 Server (C3PO)

@ -341,7 +347,7 @@ Full C2 documentation and command list: see [tools/C3PO/README.md](tools/C3PO/RE
 - **Per-device master keys** stored in factory NVS partition (read-only)
 - **Protocol Buffers (nanoPB)** for serialization

-Provision each device with a unique master key using `tools/provisioning/provision.py`. Keys are never hardcoded in firmware.
+Provision each device with a unique master key using `tools/deploy.py`. Keys are never hardcoded in firmware.

 ### Responsible Use

@ -390,6 +396,7 @@ Espilon should only be used for:
 - [x] Honeypot module (fake services + monitoring)
 - [x] CAN Bus module (MCP2515 — sniff, inject, UDS, OBD-II, fuzzing)
 - [x] Web dashboard with device management, camera, MLAT, OTA, CAN
+- [x] SOCKS5 tunnel proxy (multiplexed pivot through ESP32)

 ### Future

@ -443,7 +450,7 @@ Contributions welcome! See [CONTRIBUTING.md](CONTRIBUTING.md).
 - **[Full documentation](https://docs.espilon.net)**
 - **[ESP-IDF Documentation](https://docs.espressif.com/projects/esp-idf/)**
 - **[LilyGO T-Call](https://github.com/Xinyuan-LilyGO/LilyGO-T-Call-SIM800)**
- **French README**: [README.md](README.md)
+- **French README**: [README.fr.md](README.fr.md)

 ---

--- a/tools/C3PO/README.md
+++ b/tools/C3PO/README.md
@ -354,7 +354,7 @@ tools/C3PO/

 ## Troubleshooting

- `Base64 decode failed` or `Decrypt failed`: verify the device was provisioned with `tools/provisioning/provision.py` and that `keys.json` contains the correct master key for the device ID
+- `Base64 decode failed` or `Decrypt failed`: verify the device was provisioned with `tools/deploy.py` and that `keys.json` contains the correct master key for the device ID
 - `TUI not available`: install `textual`
 - No camera frames: check `CAMERA_SECRET_TOKEN` and `UDP_PORT`
 - Web not reachable: check `WEB_HOST`, `WEB_PORT`, firewall
@ -364,7 +364,7 @@ tools/C3PO/

 ## Security Notes

- Each device must be provisioned with a unique master key via `tools/provisioning/provision.py`
+- Each device must be provisioned with a unique master key via `tools/deploy.py`
 - Master keys are stored in `keys.json` — keep this file secure and never commit it to version control
 - The C2 derives per-device encryption keys using HKDF-SHA256 (master_key + device_id salt)
 - All C2 communications use ChaCha20-Poly1305 AEAD with random 12-byte nonces