Politician

Une bibliothèque sophistiquée d'audit WiFi pour microcontrôleurs ESP32

Politician est une bibliothèque C++ embarquée conçue pour l'audit de sécurité WiFi sur les plateformes ESP32. Elle fournit une API propre et moderne pour capturer les handshakes WPA/WPA2/WPA3 et récolter des identifiants d'entreprise en utilisant des techniques avancées du protocole 802.11.

Capacités clés

• Capture PMKID : Extraire les PMKID des réponses d'association sans déconnexion du client
• Injection CSA (Channel Switch Announcement) : Alternative moderne aux attaques par désauthentification
• Récolte d'identifiants d'entreprise : Capturer les trames EAP-Identity des réseaux 802.1X
• Découverte de réseaux cachés : Dévoilement automatique des SSID via l'interception des réponses aux sondes
• Empreinte d'appareils : Identifier passivement plus de 150 marques grand public IoT/maison intelligente via les signatures MAC OUI et IE sans association réseau
• Stimulation de clients : Réveiller les appareils mobiles en veille à l'aide de trames QoS Null Data
• Détection WPA3/PMF : Filtrage intelligent pour ignorer les réseaux activant les Protected Management Frames
• Formats d'exportation : Fichiers de capture PCAPNG ; export texte HC22000 optionnel pour ingestion directe par Hashcat

Architecture

La bibliothèque est construite autour d'une machine à états non bloquante qui gère le saut de canaux, la sélection des cibles, l'exécution des attaques et le traitement des captures. Toutes les opérations sont contenues dans l'espace de noms politician.

Composants principaux

Composant	Description
Politician	Classe moteur principale gérant le cycle de vie de l'audit
PoliticianFormat	Sérialisation des captures PCAPNG ; export texte HC22000 auxiliaire
PoliticianStorage	Journalisation optionnelle sur carte SD et persistance NVS
PoliticianStress	Livraison découplée de charges utiles DoS/perturbation (optionnel)
PoliticianTypes	Structures de données et énumérations de base

Modes d'attaque

Les attaques traditionnelles par désauthentification sont inefficaces contre les réseaux modernes WPA3 et WPA2 avec Protected Management Frames (PMF/802.11w). Politician implémente des alternatives modernes :

Mode	Description	Efficacité
ATTACK_PMKID	Extraire PMKID via authentification factice	Fonctionne sur tous les WPA2/WPA3-Transition
ATTACK_CSA	Injection d'annonce de changement de canal	Contourne les protections PMF
ATTACK_DEAUTH	Désauthentification héritée (Raison 7)	WPA2 sans PMF uniquement
ATTACK_STIMULATE	Données QoS Null pour clients en veille	Réveil non intrusif du client
ATTACK_PASSIVE	Mode écoute uniquement	Zéro transmission
ATTACK_ALL	Activer tous les vecteurs d'attaque actifs	Aggression maximale

Installation

PlatformIO

Ajoutez à votre platformio.ini :```ini [env:myboard] platform = espressif32 board = esp32dev framework = arduino lib_deps = Politician

Ou clonez directement dans le répertoire `lib/` de votre projet :```bash
cd lib/
git clone https://github.com/0ldev/Politician.git

Arduino IDE

1. Téléchargez la bibliothèque sous forme de fichier ZIP
2. Dans l'IDE Arduino : Croquis → Inclure une bibliothèque → Ajouter une bibliothèque .ZIP
3. Sélectionnez le fichier ZIP téléchargé

ESP-IDF

Clonez le dépôt dans le répertoire components/ de votre projet :```bash cd components/ git clone https://github.com/0ldev/Politician.git

Créez un descripteur de composant `components/Politician/CMakeLists.txt` :```cmake
idf_component_register(
    SRCS
        "src/Politician.cpp"
        "src/PoliticianFormat.cpp"
        "src/PoliticianStress.cpp"
    INCLUDE_DIRS "src"
)

PoliticianStorage.h n'est pas disponible sous ESP-IDF — il émet un #error à la compilation s'il est inclus en dehors d'Arduino. Utilisez directement les API VFS et nvs_flash d'ESP-IDF pour toute persistance nécessaire.

Démarrage rapide

Capture de poignée de main basique```cpp

#include <Arduino.h> #include <SD.h> #include <Politician.h> #include <PoliticianStorage.h>

using namespace politician; using namespace politician::storage;

Politician engine;

void onHandshake(const HandshakeRecord &rec) { Serial.printf("\n[✓] Captured: %s ch%d rssi=%d type=%d\n", rec.ssid, rec.channel, rec.rssi, rec.type); // Primary output: PCAPNG — open in Wireshark or convert with hcxpcapngtool PcapngFileLogger::append(SD, "/captures.pcapng", rec); }

void setup() { Serial.begin(115200); SD.begin();

engine.setEapolCallback(onHandshake);

Config cfg;
engine.begin(cfg);
engine.setAttackMask(ATTACK_ALL);

}

void loop() { engine.tick(); }

### Démarrage rapide avec ESP-IDF nu

Sous ESP-IDF, `begin()` appelle `esp_wifi_init()` en interne mais s'attend à ce que NVS et la boucle d'événements par défaut soient déjà initialisés. Appelez-les avant `begin()`, puis pilotez le moteur depuis une tâche FreeRTOS.```cpp
#include <nvs_flash.h>
#include <esp_event.h>
#include <freertos/FreeRTOS.h>
#include <freertos/task.h>
#include <Politician.h>

using namespace politician;

static Politician engine;

static void on_handshake(const HandshakeRecord &rec) {
    printf("[+] Captured: %s  ch%d  rssi=%d  type=%d\n",
           rec.ssid, rec.channel, rec.rssi, rec.type);
}

static void audit_task(void *) {
    Config cfg;
    engine.setEapolCallback(on_handshake);

    if (engine.begin(cfg) != OK) {
        printf("[!] WiFi init failed\n");
        vTaskDelete(nullptr);
        return;
    }

    engine.setAttackMask(ATTACK_ALL);

    for (;;) {
        engine.tick();
        vTaskDelay(pdMS_TO_TICKS(1));
    }
}

extern "C" void app_main(void) {
    nvs_flash_init();
    esp_event_loop_create_default();

    xTaskCreate(audit_task, "politician", 8192, nullptr, 5, nullptr);
}

Référence API

Classe Politician

La classe moteur principale. Vous devez appeler tick() dans votre boucle principale.

Initialisation```cpp

Error begin(const Config& cfg = Config());

Initialize the engine. Returns `OK` on success or an `Error` code on failure. Must be called before any other method.