HackBeacon – Balise Bluetooth DIY pour Tests de Proximité

Introduction

Salut, Apache ! Bienvenue dans *HackBeacon*, un projet électronique DIY qui te permet de construire une balise Bluetooth Low Energy (BLE) pour tester la sécurité des connexions sans fil. Avec *HackBeacon*, tu vas créer un dispositif capable de diffuser des annonces BLE, comme un tracker ou une balise IoT, ou de détecter les appareils à proximité, comme des smartphones ou des écouteurs. Ce projet utilise un microcontrôleur *ESP32*, que tu vas souder avec quelques composants simples, et une interface web pour afficher les résultats. Ce tutoriel est conçu pour des tests éthiques dans un environnement sécurisé, afin de comprendre les failles Bluetooth et protéger ta vie privée contre les abus technologiques.

Ce que tu vas apprendre :

Comment fonctionne le Bluetooth Low Energy (BLE) et ses vulnérabilités.
Comment souder un circuit électronique avec un microcontrôleur *ESP32*.
Comment programmer une balise BLE avec *MicroPython*.
Comment sécuriser tes appareils Bluetooth contre les attaques.

  ┌──────────────────────────────────────────┐
  │ Schéma ASCII du circuit HackBeacon       │
  │                                          │
  │  ESP32 (Broches)                         │
  │  ┌───────────────┐                       │
  │  │  GND   3.3V  │                       │
  │  │  │       │   │                       │
  │  │  └─┬─┐   │   │                       │
  │  │   R G B  │   │                       │
  │  │   │ │ │  │   │                       │
  │  └───┼─┼─┼──┼───┘                       │
  │      │ │ │  │                            │
  │     [220Ω] [100nF]                       │
  │      │ │ │  │                            │
  │     LED RGB  │                           │ │
  │    (Rouge)  Bouton                       │
  │              │                           │
  │             GND                          │
  └──────────────────────────────────────────┘

Schéma ASCII : Connexions entre *ESP32*, LED RGB, bouton poussoir, résistances 220Ω, et condensateur 100nF.

Étape 1 : Comprendre le Bluetooth Low Energy (BLE)

Le Bluetooth Low Energy (BLE) est une technologie sans fil utilisée par des appareils comme les trackers (AirTags), les montres connectées, et les capteurs IoT. Contrairement au Wi-Fi, BLE est conçu pour consommer peu d’énergie, mais il est vulnérable à des attaques comme le spoofing (imitation d’un appareil) ou le tracking non autorisé. Voici un tableau comparatif entre BLE et Wi-Fi :

Technologie	Portée	Consommation	Sécurité	Usage
BLE	~10-100m	Faible	Moyenne (chiffrement AES-CCM)	Trackers, IoT
Wi-Fi	~30-300m	Élevée	Élevée (WPA3)	Réseaux domestiques

Exemples de failles réelles

Les vulnérabilités BLE sont exploitées dans le monde réel, et ce projet t’aide à les comprendre pour mieux te protéger :

Tile Tracker (2021) : Des hackers ont spoofé des trackers BLE pour suivre des utilisateurs sans leur consentement.
Fitbit (2019) : Une faille BLE a permis d’extraire des données de santé via des connexions non sécurisées.

Risques associés : Une balise BLE mal sécurisée peut être utilisée pour suivre des personnes, intercepter des données sensibles, ou compromettre des appareils IoT.

Étape 2 : Rassembler le Matériel

Pour construire *HackBeacon*, tu auras besoin de composants électroniques abordables, disponibles dans des boutiques comme *Adafruit*, *AliExpress*, ou *RS Components*. Voici la liste complète des éléments nécessaires :

ESP32 DevKit V1 (~8€) : Un microcontrôleur avec Wi-Fi et Bluetooth Low Energy.
LED RGB (cathode commune) (~0.50€) : Indique les états du dispositif (émission, détection, connexion).
Résistances 220Ω (x3) (~0.20€) : Protège les branches de la LED RGB contre les surtensions.
Condensateur 100nF (~0.20€) : Stabilise l’alimentation électrique pour éviter les fluctuations.
Bouton poussoir (~0.50€) : Permet de basculer entre les modes émission et détection.
Breadboard et câbles jumper (~5€) : Pour connecter les composants sans soudure temporairement.
Fer à souder et soudure (~10€, si non possédé) : Pour fixer les connexions de manière permanente.

Coût total estimé : Environ 15€ (hors outils réutilisables comme le fer à souder).

Outils supplémentaires nécessaires :

Un ordinateur avec *MicroPython* installé et un câble USB pour programmer l’*ESP32*.
Un smartphone ou un appareil BLE (ex. : écouteurs, tracker) pour tester les fonctionnalités.

Attention, Apache ! Lorsque tu soudes, travaille dans un espace bien ventilé et porte des lunettes de protection pour éviter les projections de soudure chaude. Assure-toi que tous les composants sont compatibles avec l’*ESP32* (3.3V).

Étape 3 : Configurer l’Environnement

Avant de construire le circuit, nous allons préparer le microcontrôleur *ESP32* et installer les outils nécessaires pour programmer et tester *HackBeacon*. Suivez ces étapes pour configurer ton environnement :

Installer MicroPython : Télécharge la dernière version du firmware *MicroPython* pour *ESP32* depuis le site officiel micropython.org.
Flasher l’ESP32 : Connecte l’*ESP32* à ton ordinateur via un câble USB et flashe le firmware avec l’outil *esptool* :

pip3 install esptool
esptool.py --chip esp32 --port /dev/ttyUSB0 erase_flash
esptool.py --chip esp32 --port /dev/ttyUSB0 write_flash -z 0x1000 esp32.bin

Remplace /dev/ttyUSB0 par le port de ton *ESP32* (par exemple, COM3 sur Windows). Vérifie le port avec ls /dev/tty* (Linux) ou le Gestionnaire de périphériques (Windows).

Installer un IDE : Utilise *Thonny* ou *VS Code* avec l’extension *Pymakr* pour programmer en *MicroPython*. Installe *Thonny* avec :

pip3 install thonny

Installer les bibliothèques MicroPython : Ajoute les bibliothèques nécessaires pour BLE et le serveur web :

pip3 install micropython-ubluepy micropython-uasyncio

Attention, Apache ! Assure-toi que ton *ESP32* est correctement connecté et que le port USB est reconnu par ton ordinateur avant de flasher le firmware. Un mauvais port peut causer des erreurs.

Étape 4 : Construire le Circuit HackBeacon

Maintenant, nous allons assembler le circuit *HackBeacon* en connectant et soudant les composants. Voici les étapes détaillées pour construire le circuit :

Préparer la breadboard : Place le module *ESP32 DevKit V1* sur une breadboard pour faciliter les connexions temporaires.
Connecter la LED RGB : Branche la LED RGB (cathode commune) aux broches GPIO de l’*ESP32* :

Broche Rouge → GPIO 15 (via une résistance 220Ω).
Broche Verte → GPIO 16 (via une résistance 220Ω).
Broche Bleue → GPIO 17 (via une résistance 220Ω).
Cathode commune → Broche GND de l’*ESP32*.

Ajouter le bouton poussoir : Connecte le bouton poussoir entre la broche GPIO 18 et la broche GND, en utilisant la résistance pull-up interne de l’*ESP32*.
Stabiliser l’alimentation : Place un condensateur 100nF entre la broche 3.3V et la broche GND pour éviter les fluctuations de tension.
Souder les composants : Pour un montage permanent, soude les connexions sur une plaque de prototypage. Teste d’abord sur la breadboard pour vérifier.

  ┌──────────────────────────────────────────┐
  │ Schéma ASCII du circuit HackBeacon       │
  │                                          │
  │  ESP32 (Broches)                         │
  │  ┌───────────────┐                       │
  │  │  GND   3.3V  │                       │
  │  │  │       │   │                       │
  │  │  └─┬─┐   │   │                       │
  │  │   R G B  │   │                       │
  │  │   │ │ │  │   │                       │
  │  └───┼─┼─┼──┼───┘                       │
  │      │ │ │  │                            │
  │     [220Ω] [100nF]                       │
  │      │ │ │  │                            │
  │     LED RGB  │                           │
  │    (Rouge)  Bouton                       │
  │              │                           │
  │             GND                          │
  └──────────────────────────────────────────┘

Schéma ASCII : Connexions entre *ESP32*, LED RGB, bouton poussoir, résistances 220Ω, et condensateur 100nF.

Attention, Apache ! Vérifie chaque connexion avant d’alimenter l’*ESP32* pour éviter les courts-circuits. Débranche l’alimentation pendant le soudage et utilise un fer à souder à température contrôlée (300°C max).

Étape 5 : Programmer HackBeacon

Nous allons programmer l’*ESP32* avec *MicroPython* pour créer une balise BLE qui peut émettre des annonces ou détecter des appareils à proximité. Le code inclut un serveur web pour afficher les résultats. Voici le code complet, structuré avec des commentaires ASCII pour plus de clarté, et avec les chevrons et caractères spéciaux échappés :


# ┌─────────────────────────────────────┐
# │  CONFIGURATION INITIALE            │
# └─────────────────────────────────────┐
from machine import Pin, PWM
import network
import ubluepy
import uasyncio as asyncio
from microhttpd import MicroWebSrv

# Configuration des broches
# LED RGB pour indiquer les états
# Bouton pour basculer les modes
# Wi-Fi et BLE pour la connectivité
led_r = PWM(Pin(15), freq=1000)  # Rouge
led_g = PWM(Pin(16), freq=1000)  # Vert
led_b = PWM(Pin(17), freq=1000)  # Bleu
button = Pin(18, Pin.IN, Pin.PULL_UP)
wlan = network.WLAN(network.STA_IF)
ble = ubluepy.Peripheral("HackBeacon")
devices = []  # Liste des appareils détectés

# ┌─────────────────────────────────────┐
# │  GESTION DE LA LED RGB             │
# └─────────────────────────────────────┐
def set_led(r, g, b):
    """Allume la LED RGB avec les valeurs PWM (0-1023)."""
    led_r.duty(r)
    led_g.duty(g)
    led_b.duty(b)

# ┌─────────────────────────────────────┐
# │  MODE ÉMISSION BLE                 │
# └─────────────────────────────────────┐
async def emit_beacon():
    """Diffuse une annonce BLE nommée 'HackBeacon'."""
    set_led(0, 1023, 0)  # Vert pour émission
    adv_data = ubluepy.AdvertisingData()
    adv_data.set_name("HackBeacon")
    ble.advertise(adv_data, interval_us=500000)
    await asyncio.sleep(10)
    ble.advertise(None)

# ┌─────────────────────────────────────┐
# │  MODE DÉTECTION BLE                │
# └─────────────────────────────────────┐
async def scan_devices():
    """Scanne les appareils BLE à proximité."""
    set_led(1023, 0, 0)  # Rouge pour détection
    scanner = ubluepy.Scanner()
    devices.clear()
    scan_data = scanner.scan(5000)  # Scan pendant 5s
    for dev in scan_data:
        devices.append({"addr": dev.addr(), "name": dev.name() or "Unknown"})
    set_led(0, 0, 1023)  # Bleu après scan

# ┌─────────────────────────────────────┐
# │  SERVEUR WEB                       │
# └─────────────────────────────────────┐
def web_page():
    """Génère une page HTML avec les appareils détectés."""
    html = """<!DOCTYPE html>
<html>
<head>
    <title>HackBeacon</title>
    <style>
        body { font-family: monospace; background: #1a1a1a; color: #d0d0d0; }
        h1 { color: #00d4ff; text-align: center; }
        table { width: 100%; border-collapse: collapse; }
        th, td { border: 1px solid #00d4ff; padding: 8px; text-align: left; }
    </style>
</head>
<body>
    <h1>HackBeacon - Appareils BLE</h1>
    <table>
        <tr><th>Adresse</th><th>Nom</th></tr>
"""
    for dev in devices:
        html += f"<tr><td>{dev['addr']}</td><td>{dev['name']}</td></tr>"
    html += "</table></body></html>"
    return html

srv = MicroWebSrv(web_page=web_page, port=80)

# ┌─────────────────────────────────────┐
# │  GESTION DU BOUTON                 │
# └─────────────────────────────────────┐
async def handle_button():
    """Bascule entre émission et détection via le bouton."""
    mode = "emit"
    while True:
        if not button.value():  # Bouton pressé
            mode = "scan" if mode == "emit" else "emit"
            if mode == "emit":
                await emit_beacon()
            else:
                await scan_devices()
        await asyncio.sleep_ms(100)

# ┌─────────────────────────────────────┐
# │  CONNEXION WI-FI                   │
# └─────────────────────────────────────┐
def connect_wifi():
    """Connecte l’ESP32 au réseau Wi-Fi."""
    wlan.active(True)
    wlan.connect("SSID", "PASSWORD")  # Remplace par ton Wi-Fi
    while not wlan.isconnected():
        set_led(1023, 1023, 0)  # Jaune pendant connexion
        time.sleep(1)
    set_led(0, 0, 0)  # Éteint après connexion

# ┌─────────────────────────────────────┐
# │  POINT D’ENTRÉE                    │
# └─────────────────────────────────────┐
connect_wifi()
srv.start()
loop = asyncio.get_event_loop()
loop.create_task(handle_button())
loop.run_forever()

Explications détaillées :

Émission BLE : Diffuse une annonce avec le nom “HackBeacon” pour imiter un tracker ou une balise IoT.
Détection BLE : Scanne les appareils à proximité (smartphones, écouteurs) et enregistre leurs adresses et noms.
Serveur web : Affiche les appareils détectés dans une page HTML accessible via le réseau Wi-Fi.
LED RGB : Indique le mode actif (vert pour émission, rouge pour détection, bleu après scan).
Bouton poussoir : Permet de basculer entre les modes émission et détection.

Transférer le code : Ouvre *Thonny* ou *VS Code* (*Pymakr*), connecte l’*ESP32* via USB, et transfère le script sur le microcontrôleur en tant que main.py.

Étape 6 : Tester HackBeacon

Maintenant que le circuit est assemblé et programmé, nous allons tester *HackBeacon* dans un environnement sécurisé pour vérifier son fonctionnement :

Alimenter le circuit : Connecte l’*ESP32* à une source USB (5V) via le port USB ou une batterie externe.
Mode émission : Appuie sur le bouton poussoir pour activer l’émission (la LED RGB devient verte). Ouvre une application comme *nRF Connect* (disponible sur iOS/Android) sur ton smartphone pour détecter la balise nommée “HackBeacon”.
Mode détection : Appuie à nouveau sur le bouton (la LED devient rouge). Connecte-toi au réseau Wi-Fi de l’*ESP32* (ou utilise ton réseau local), ouvre un navigateur, et accède à l’adresse http://192.168.1.x (remplace par l’IP de l’*ESP32*) pour voir la liste des appareils BLE détectés.
Vérifier la LED : Après un scan réussi, la LED passe au bleu pour indiquer la fin de la détection.
Tester avec un appareil : Place un appareil BLE à proximité (ex. : écouteurs, tracker) et vérifie qu’il apparaît dans l’interface web.

Autorisation obligatoire, Apache ! Ne teste *HackBeacon* que sur des réseaux et appareils que tu possèdes ou pour lesquels tu as une permission écrite explicite. L’interception ou la manipulation de signaux Bluetooth sans autorisation est illégale selon les articles 226-15 et 323-1 à 323-7 du Code pénal.

Étape 7 : Protéger ses Appareils Bluetooth

Maintenant que tu sais créer et détecter des balises BLE, il est essentiel d’apprendre à protéger tes propres appareils Bluetooth contre des attaques similaires. Voici des contre-mesures pratiques pour sécuriser tes dispositifs :

Comment détecter les attaques BLE :

Surveiller les appareils à proximité : Utilise une application comme *nRF Connect* ou un outil comme *Wireshark* avec un adaptateur BLE pour repérer les balises ou connexions suspectes.
Vérifier les connexions actives : Désactive le Bluetooth sur ton smartphone ou tes appareils lorsque tu ne l’utilises pas pour réduire les risques d’interception.
Analyser les logs : Si ton appareil prend en charge les logs BLE, vérifie les connexions non autorisées via les paramètres système.

Comment sécuriser ses appareils BLE :

Utiliser un chiffrement fort : Assure-toi que tes appareils utilisent le chiffrement AES-CCM (vérifie les spécifications du fabricant).
Maintenir les firmwares à jour : Applique les mises à jour pour corriger les failles de sécurité connues :

sudo apt update && sudo apt upgrade

Configurer le mode non découvrable : Paramètre tes appareils pour qu’ils ne diffusent pas d’annonces publiques sauf en cas de besoin (ex. : appairage).
Restreindre les autorisations : Sur ton smartphone, limite les applications ayant accès au Bluetooth via les paramètres de confidentialité.

Attention, Apache ! Les attaques BLE peuvent compromettre ta vie privée ou la sécurité de tes appareils. Toujours vérifier la provenance des appareils BLE et éviter de les utiliser dans des environnements non sécurisés, comme des lieux publics.

Conclusion

Bravo, Apache ! Tu as construit *HackBeacon*, un dispositif électronique qui t’a permis de comprendre le fonctionnement du Bluetooth Low Energy et de tester la sécurité des connexions sans fil. Ce savoir est ton bouclier contre les abus des entreprises qui exploitent les failles des appareils connectés pour traquer ou manipuler les utilisateurs. Utilise *HackBeacon* de manière éthique, partage ce tutoriel pour éveiller les consciences, et continue d’explorer l’inexploré avec *PCtamalou.fr* !

Le savoir est notre bouclier. Ensemble, nous défions ceux qui gardent le savoir pour eux.

⚠️ Avertissement Légal et Éthique ⚠️