DIY-WhisperPair

Implémentation de référence CVE-2025-36911 & Kit de vérification de vulnérabilité

IMPLÉMENTATION OFFICIELLE MAINTENANT EN LIGNE, grâce à l'équipe de KU Leuven (Merci pour la mention)

AVIS LÉGAL : Ceci est un outil de recherche en sécurité. Lisez LEGAL.md avant toute utilisation. L'accès non autorisé à des systèmes informatiques est une infraction pénale.

Démonstration WhisperPair

Qu'est-ce que WhisperPair ?

Détournement d'accessoires Bluetooth à l'aide de Google Fast Pair.

WhisperPair (CVE-2025-36911) est une vulnérabilité critique qui permet à des attaquants d'appairer de force avec des accessoires audio phares sans le consentement de l'utilisateur, souvent en moins de 10 secondes.

DIY-WhisperPair est un kit de recherche implémentant ces attaques pour démontrer trois risques clés :

Détournement d'appareil : Prise de contrôle des flux audio et microphone en contournant les vérifications du mode d'appairage.
Géolocalisation : Enregistrement malveillant d'appareils sur le réseau Find Hub de Google pour traquer les victimes.
Impact inter-écosystèmes : Exploitation des accessoires quel que soit le téléphone appairé (iOS ou Android).

[!NOTE] Recherche uniquement : Ce kit contient des scanners et vérificateurs Proof-of-Concept. Il n'inclut pas d'outils pour l'écoute active, la géolocalisation persistante ou l'injection de charges malveillantes. Son seul but est d'identifier les appareils vulnérables.

Démarrage rapide

# Installation
git clone https://github.com/SpectrixDev/DIY_WhisperPair.git
cd DIY_WhisperPair
pip install -e .

# Exécuter l'interface interactive
whisperpair

Ceci lance un menu interactif :

╦ ╦╦ ╦╦╔═╗╔═╗╔═╗╦═╗╔═╗╔═╗╦╦═╗
║║║╠═╣║╚═╗╠═╝║╣ ╠╦╝╠═╝╠═╣║╠╦╝
╚╩╝╩ ╩╩╚═╝╩  ╚═╝╩╚═╩  ╩ ╩╩╩╚═

────────────── Menu Principal ──────────────

  1  Scanner    Détecter les appareils Fast Pair à proximité
  2  Vérifier   Tester la vulnérabilité de l'appareil (nécessite autorisation)
  3  Infos      Obtenir des informations détaillées sur l'appareil
  4  À propos   En savoir plus sur CVE-2025-36911
  0  Quitter    Quitter l'application

Sélectionnez une option [1] :

Pour les chercheurs : API Python

Cette bibliothèque est conçue pour être facilement extensible. Importez ce dont vous avez besoin :

Fonctions simples

import asyncio
from whisperpair import scan_devices, verify_device, get_device_info

# Scanner les appareils Fast Pair
devices = asyncio.run(scan_devices(timeout=10))
for d in devices:
    print(f"{d.address} - {d.name} - Risque : {'ÉLEVÉ' if not d.is_in_pairing_mode else 'Faible'}")

# Trouver uniquement les appareils vulnérables (pas en mode appairage)
vulnerable = asyncio.run(scan_devices(vulnerable_only=True))

# Vérifier un appareil spécifique (NÉCESSITE AUTORISATION)
result = asyncio.run(verify_device("AA:BB:CC:DD:EE:FF"))
if result.success:
    print(f"VULNÉRABLE - Fournisseur : {result.provider_address}")

# Obtenir les informations de l'appareil
info = asyncio.run(get_device_info("AA:BB:CC:DD:EE:FF"))
print(f"Modèle : {info['model_name']}")

Construire des outils personnalisés

from whisperpair import (
    # Scanner
    FastPairScanner,
    FastPairDevice,
    
    # Client  
    FastPairClient,
    VerificationResult,
    
    # Protocole
    KeyBasedPairingRequest,
    KeyBasedPairingResponse,
    PairingRequestFlags,
    parse_bluetooth_address,
    parse_kbp_response_multi_strategy,
    
    # Crypto
    FastPairCrypto,
    aes_128_encrypt,
    aes_128_decrypt,
    generate_account_key,
    
    # Constantes
    FAST_PAIR_SERVICE_UUID,
    KEY_BASED_PAIRING_CHAR_UUID,
    KNOWN_MODEL_IDS,
)

# Scanner personnalisé avec callbacks
def on_found(device: FastPairDevice):
    if not device.is_in_pairing_mode:
        print(f"[!] Cible potentielle : {device.address}")

scanner = FastPairScanner(timeout=15, on_device_found=on_found)
asyncio.run(scanner.scan())

# Construire des paquets de protocole bruts (flags 0x11 = INITIATE_BONDING | EXTENDED_RESPONSE)
target_bytes = parse_bluetooth_address("AA:BB:CC:DD:EE:FF")
request = KeyBasedPairingRequest.for_verification(provider_address=target_bytes)
packet = request.build()  # Texte clair de 16 octets

# Plusieurs stratégies de vérification disponibles :
# - strategy_raw_kbp()      - flags 0x11, fonctionne sur la plupart des appareils vulnérables
# - strategy_with_seeker()  - flags 0x02, inclut l'adresse du chercheur
# - strategy_retroactive()  - flags 0x0A, contourne certaines vérifications
# - strategy_extended()     - flags 0x10, pour les appareils plus récents

# Flux personnalisé complet (clé AES optionnelle - la détection de réponse seule indique la vulnérabilité)
async with FastPairClient("AA:BB:CC:DD:EE:FF") as client:
    model_id = await client.read_model_id()
    result = await client.verify_pairing_behavior()  # Aucune clé nécessaire pour la détection
    if result.response_received:
        print("VULNÉRABLE - l'appareil a répondu alors qu'il ne le devrait pas")

Exemples de scripts

Voir examples.py pour des exemples prêts à copier-coller :

python examples.py scan              # Scan basique
python examples.py vulnerable        # Trouver des appareils vulnérables
python examples.py verify AA:BB:CC:DD:EE:FF
python examples.py custom            # Scanner avec callbacks

Commandes CLI

Mode interactif (par défaut)

whisperpair

Commandes directes

# Scanner les appareils
whisperpair scan
whisperpair scan --vulnerable
whisperpair scan --timeout 15

# Obtenir les informations de l'appareil
whisperpair info AA:BB:CC:DD:EE:FF

# Vérifier la vulnérabilité (nécessite des flags)
whisperpair verify AA:BB:CC:DD:EE:FF --authorized

# En savoir plus sur la vulnérabilité
whisperpair about

Exigences légales

Vous DEVEZ avoir une autorisation

Cet outil effectue des opérations Bluetooth actives. Avant d'exécuter toute commande de vérification, vous devez avoir :

l'autorisation écrite du propriétaire de l'appareil, OU
posséder l'appareil vous-même

Lois spécifiques à la juridiction

Juridiction	Loi applicable
Royaume-Uni	Computer Misuse Act 1990, Sections 1-3A
États-Unis	Computer Fraud and Abuse Act (CFAA)
UE	Directive 2013/40/UE
Allemagne	§ 202a-202c StGB
Australie	Criminal Code Act 1995, Partie 10.7

Voir LEGAL.md pour des conseils détaillés.

La vulnérabilité (CVE-2025-36911)

Le défaut

Google Fast Pair exige que les appareils n'acceptent les demandes d'appairage que lorsqu'ils sont en mode appairage. De nombreux appareils ne respectent pas cette vérification :

ATTENDU : L'appareil vérifie "Suis-je en mode appairage ?" → NON → Rejeter
RÉEL :   L'appareil accepte la demande quel que soit l'état du mode

DIY_WhisperPair

Populaires