WhisperPair-PoC-Tool e Pesquisa

Um mergulho profundo no CVE-2025-36911 e nas lacunas de segurança do ecossistema Fast Pair do Google

Resumo Executivo

O Google Fast Pair foi projetado para tornar o emparelhamento Bluetooth perfeito: toque em uma notificação e você está conectado. Mas o que acontece quando essa experiência perfeita se torna um risco de segurança? WhisperPair-PoC-Tool é uma ferramenta de pesquisa em segurança que expõe duas classes críticas de vulnerabilidades que afetam milhões de acessórios Bluetooth: bypass de emparelhamento não autorizado e exploração de rastreamento da rede Find My Device.

Este post detalha o funcionamento interno do WhisperPair-PoC-Tool, as fraquezas de protocolo que ele explora e o que isso significa para o ecossistema de acessórios Bluetooth.

As Vulnerabilidades

CVE-2025-36911: Bypass do Modo de Emparelhamento do Fast Pair

A especificação do Google Fast Pair afirma explicitamente:

"Se o campo opcional de Chave Pública estiver presente: se o dispositivo não estiver no modo de emparelhamento, ignore a escrita e saia."

Especificação do Procedimento GATT do Google Fast Pair

Este é o gate de segurança crítico. Os dispositivos devem responder somente a solicitações de emparelhamento baseado em chave quando o usuário tiver colocado explicitamente o dispositivo no modo de emparelhamento (normalmente mantendo um botão pressionado). Isso garante a intenção do usuário, de modo que você não consiga emparelhar com os fones de ouvido de alguém enquanto a pessoa os estiver usando.

O Problema: muitos fabricantes ignoram essa verificação por completo. Eles processam solicitações de emparelhamento independentemente do estado do modo de emparelhamento, permitindo:

Emparelhamento silencioso sem interação do usuário
Sequestro de acessório em ataques de proximidade
Violações de privacidade ao se conectar aos dispositivos das vítimas

Exposição da Chave de Conta do Find Hub

A rede Find My Device (FMDN) do Google permite rastrear acessórios Bluetooth por meio da rede crowdsourced de dispositivos Android. Isso requer uma Chave de Conta, uma chave simétrica de 16 bytes que vincula o dispositivo a uma conta Google.

O Problema: a característica da Chave de Conta frequentemente aceita escritas sem autenticação:

O atacante pode sobrescrever uma Chave de Conta existente
A integração do Find My Device da vítima quebra
O atacante pode rastrear o dispositivo usando a própria chave
Isso persiste até a redefinição de fábrica

Fundamentos do Protocolo Fast Pair

Antes de mergulhar na exploração, vamos entender o fluxo legítimo do Fast Pair:

Fase de Anúncio

┌─────────────────────────────────────────────────────────────┐
│                    BLE Advertisement                         │
├─────────────────────────────────────────────────────────────┤
│  Service UUID: 0xFE2C (Fast Pair)                           │
│  Service Data:                                               │
│    [Pairing Mode]   → 3 bytes: Model ID only                │
│    [Not Pairing]    → 4+ bytes: 0x00 + Account Key Filter   │
└─────────────────────────────────────────────────────────────┘

O formato do anúncio revela o estado de emparelhamento:

3 bytes = apenas Model ID = dispositivo detectável (modo de emparelhamento)
4+ bytes = byte de versão + dados da Chave de Conta = não está no modo de emparelhamento

Handshake de Emparelhamento Baseado em Chave

Seeker (Phone)                              Provider (Accessory)
      │                                              │
      │───── GATT Connect ──────────────────────────>│
      │                                              │
      │───── Discover Services ─────────────────────>│
      │<──── Service: 0xFE2C ────────────────────────│
      │                                              │
      │───── Enable Notifications (0xFE2C1234) ─────>│
      │                                              │
      │───── Write Key-Based Pairing Request ───────>│
      │      [16-byte encrypted block]               │
      │      [64-byte ECDH Public Key] (optional)    │
      │                                              │
      │      ┌────────────────────────────────────┐  │
      │      │ SECURITY CHECK:                    │  │
      │      │ If Public Key present AND          │  │
      │      │ device NOT in pairing mode:        │  │
      │      │   → IGNORE and EXIT                │  │
      │      │ Else:                              │  │
      │      │   → Process request                │  │
      │      └────────────────────────────────────┘  │
      │                                              │
      │<──── Notification: Encrypted Response ───────│
      │      [Provider's BR/EDR Address]             │
      │                                              │
      │═══════ Bluetooth Classic Pairing ═══════════>│

A vulnerabilidade ocorre quando os dispositivos pulam completamente a caixa "SECURITY CHECK".

Como o WhisperPair-PoC-Tool Funciona

O WhisperPair-PoC-Tool é uma ferramenta de pesquisa em segurança baseada em Python, construída sobre a biblioteca BLE Bleak. Ele opera em várias fases:

Visão Geral da Arquitetura

┌────────────────────────────────────────────────────────────────┐
│                        WhisperPair-PoC-Tool                          │
├────────────────────────────────────────────────────────────────┤
│  CLI Layer                                                      │
│  ├── Argument parsing (--target-name, --scan-duration)         │
│  ├── TargetPolicy construction                                  │
│  └── REPL initialization                                        │
├────────────────────────────────────────────────────────────────┤
│  Discovery Engine                                               │
│  ├── BLE scanning via Bleak                                    │
│  ├── Advertisement parsing                                      │
│  ├── Protocol detection (Fast Pair, FMDN, Swift Pair)          │
│  └── Device fingerprinting (Model ID, OUI lookup)              │
├────────────────────────────────────────────────────────────────┤
│  Check Engines                                                  │
│  ├── FastPairCheckEngine (passive advertisement analysis)      │
│  ├── FastPairBypass (active CVE-2025-36911 testing)           │
│  ├── FindHubCheckEngine (Account Key status detection)         │
│  └── RiskScorer (composite vulnerability assessment)           │
├────────────────────────────────────────────────────────────────┤
│  Connection Manager                                             │
│  ├── GATT connect with MTU negotiation                         │
│  ├── Service/characteristic discovery                          │
│  ├── Read/Write/Notify operations                              │
│  └── Error handling and retry logic                            │
├────────────────────────────────────────────────────────────────┤
│  Exploitation Modules                                           │
│  ├── ring_device() - Trigger locator sound                     │
│  ├── set_account_key() - Write Account Key                     │
│  └── Response parsing (BR/EDR address extraction)              │
└────────────────────────────────────────────────────────────────┘

Componentes Principais

1. Mecanismo de Descoberta (`discovery.py`)

O scanner usa os callbacks de detecção do Bleak para capturar anúncios BLE:

async def _detection_callback(
    self, device: BLEDevice, advertisement_data: AdvertisementData
) -> None:
    """Process each detected BLE advertisement."""
    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

Para cada dispositivo, a ferramenta extrai:

UUIDs de serviço (detectando Fast Pair 0xFE2C, FMDN 0xFD44, etc.)
Dados do fabricante (Google 0x00E0, Apple 0x004C)
Dados de serviço (analisados em busca de Model ID e estado de emparelhamento)

2. Inferência do Modo de Emparelhamento (`fastpair.py`)

O modo de emparelhamento é determinado pela análise do anúncio do dispositivo:

def _analyze_service_data(self, evidence: FastPairEvidence) -> None:
    """Analyze Fast Pair service data to infer pairing mode."""
    data = evidence.service_data_bytes
    
    # 3 bytes = Model ID only = Pairing Mode (discoverable)
    if len(data) == 3:
        evidence.inferred_pairing_mode = PairingModeState.IN_PAIRING_MODE
        return
    
    # 4+ bytes with version 0x00 = Not in pairing mode
    if data[0] == 0x00:
        akd_byte = data[1]
        akd_type = akd_byte & 0x0F  # Lower 4 bits
        # Type 0x00 = Show UI, Type 0x02 = Hide UI
        # Both indicate NOT in pairing mode
        evidence.inferred_pairing_mode = PairingModeState.NOT_IN_PAIRING_MODE

Isso é crucial: se um dispositivo for considerado como não estando no modo de emparelhamento e ainda assim responder à solicitação de emparelhamento, ele é vulnerável.

3. Detecção de Vulnerabilidades (`fastpair_attack.py`)

O teste principal de vulnerabilidade envia solicitações de emparelhamento baseado em chave e monitora as respostas:

async def check_vulnerability(self, device: DiscoveredDevice) -> BypassCheckResult:
    """Test if device responds to pairing requests when not in pairing mode."""
    
    # Enable notifications to receive response
    await self.connection_manager.start_notify(
        KEY_BASED_PAIRING_CHAR,
        self._notification_handler,
    )
    
    # Build and send request (multiple strategies)
    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,
        )
        
        # Wait for response
        try:
            await asyncio.wait_for(
                self._response_received.wait(),
                timeout=self.response_timeout,
            )
            # Response received = VULNERABLE
            return BypassCheckResult(result=BypassResult.VULNERABLE, ...)
        except asyncio.TimeoutError:
            # No response = Device correctly ignored request
            continue
    
    return BypassCheckResult(result=BypassResult.NOT_VULNERABLE, ...)

A ferramenta implementa múltiplas estratégias de solicitação, pois dispositivos diferentes respondem a diferentes combinações de flags:

4. Análise da Resposta

Quando um dispositivo vulnerável responde, a ferramenta extrai o endereço BR/EDR (Bluetooth Classic):

def _parse_response(self, response_data: bytes) -> str | None:
    """Extract provider's BR/EDR address from response."""
    
    # Strategy 1: Standard response (type 0x01)
    if response_data[0] == 0x01:
        return self._extract_address(response_data, offset=1)
    
    # Strategy 2: Extended response (type 0x02)
    if response_data[0] == 0x02:
        addr_count = response_data[2]
        return self._extract_address(response_data, offset=3)
    
    # Strategy 3: Brute force pattern matching
    for offset in range(len(response_data) - 5):
        addr = self._extract_address(response_data, offset)
        if self._is_valid_mac(addr):
            return addr

Esse endereço BR/EDR poderia ser usado para iniciar o emparelhamento Bluetooth Classic (embora o WhisperPair-PoC-Tool pare na detecção).

A Superfície de Ataque

O Que Torna os Dispositivos Vulneráveis?

A pesquisa identificou falhas comuns de implementação:

1. Verificação Ausente do Modo de Emparelhamento

O problema mais comum: os fabricantes simplesmente não implementam a verificação:

// VULNERABLE: No pairing mode check
void handle_kbp_write(uint8_t* data, size_t len) {
    if (len >= 80 && has_public_key(data)) {
        // Should check: if (!is_in_pairing_mode()) return;
        process_pairing_request(data);  // Processes regardless
    }
}

2. Escritas Não Protegidas da Chave de Conta

A característica da Chave de Conta deveria exigir autenticação:

// VULNERABLE: No authentication required
void handle_account_key_write(uint8_t* key, size_t len) {
    if (len == 16) {
        store_account_key(key);  // Accepts any key from anyone
    }
}

// SECURE: Verify caller knows existing key
void handle_account_key_write_secure(uint8_t* encrypted_key, size_t len) {
    if (!verify_encrypted_with_existing_key(encrypted_key)) {
        return;  // Reject unauthorized writes
    }
    store_account_key(decrypt(encrypted_key));
}

3. Vazamento de Anúncio

Dispositivos que anunciam dados de serviço do Fast Pair quando não estão no modo de emparelhamento revelam:

Que suportam Fast Pair (identificação da superfície de ataque)
O filtro da Chave de Conta (pode ser usado para fingerprinting de dispositivos)
Potencialmente o Model ID (identifica o modelo exato do dispositivo)

Metodologia de Detecção

O WhisperPair-PoC-Tool usa uma abordagem de detecção em camadas:

Camada 1: Análise Passiva de Anúncios

Nenhuma conexão necessária. A ferramenta analisa o que o dispositivo anuncia:

┌─────────────────────────────────────────────────────────────┐
│  Passive Checks                                              │
├─────────────────────────────────────────────────────────────┤
│  ✓ Fast Pair service UUID present (0xFE2C)                  │
│  ✓ FMDN service UUID present (0xFD44)                       │
│  ✓ Pairing mode inferred from service data length           │
│  ✓ Model ID extracted (when in pairing mode)                │
│  ✓ Account Key Filter detected (when not in pairing mode)   │
│  ✓ Address type analysis (static vs. random)                │
└─────────────────────────────────────────────────────────────┘

Result: "Device advertising Fast Pair data while NOT in pairing mode"
        → Potential gating violation (needs active test to confirm)

Camada 2: Sondagem Ativa de GATT

Requer conexão. A ferramenta interage com os serviços GATT:

┌─────────────────────────────────────────────────────────────┐
│  Active Checks                                               │
├─────────────────────────────────────────────────────────────┤
│  1. Connect to device via BLE                               │
│  2. Discover Fast Pair service (0xFE2C)                     │
│  3. Locate Key-Based Pairing characteristic (0xFE2C1234)    │
│  4. Enable notifications                                     │
│  5. Write Key-Based Pairing request                         │
│  6. Wait for response (with timeout)                        │
│  7. Response received → VULNERABLE                          │
│     Timeout/Rejected → NOT VULNERABLE                       │
└─────────────────────────────────────────────────────────────┘

Camada 3: Pontuação de Risco

Uma pontuação de risco composta é calculada:

Níveis de Risco:

BAIXO (≤0): Nenhum problema significativo detectado
MÉDIO (1-2): Alguns sinais preocupantes
ALTO (≥3): Múltiplas vulnerabilidades confirmadas

Capacidades de Exploração

O WhisperPair-PoC-Tool inclui recursos controlados de exploração para demonstrar o impacto:

1. Toque do Dispositivo (comando `ring`)

Aciona a característica FMDN Beacon Actions para reproduzir o som de localização:

SUPRIMIDO PARA DIVULGAÇÃO

Impacto: o atacante pode assediar a vítima acionando o som repetidamente, ou usá-lo para localizar um dispositivo que deseja roubar.

2. Manipulação da Chave de Conta (comando `set account-key`)

Grava uma nova Chave de Conta no dispositivo:

SUPRIMIDO PARA DIVULGAÇÃO

Impacto:

Quebra a integração do Find My Device da vítima
O atacante pode rastrear o dispositivo usando a chave que conhece
Somente recuperável via redefinição de fábrica

O Que Não Foi Implementado

O WhisperPair-PoC-Tool intencionalmente para antes da exploração completa:

Orientações de Remediação

Para Fabricantes de Dispositivos

Implemente a verificação do modo de emparelhamento:

if (has_public_key(request) && !is_in_pairing_mode()) {
    return;  // Ignore request per spec
}

Exija autenticação para escritas da Chave de Conta:
- Criptografe a nova chave com a chave existente
- Verifique antes de armazenar
Minimize a exposição de anúncios:
- Anuncie o UUID do Fast Pair somente quando estiver no modo de emparelhamento
- Use endereços rotativos quando possível
Mecanismo de atualização de firmware:
- Envie correções para os dispositivos afetados em campo

Para Usuários Finais

Mantenha o firmware atualizado em acessórios Bluetooth
Faça uma redefinição de fábrica se suspeitar de comprometimento
Seja cauteloso com dispositivos que emparelham automaticamente sem pressionar um botão
Verifique as configurações do Find My Device periodicamente

Uso Pretendido

Esta ferramenta destina-se a:

✅ Pesquisadores de segurança que avaliam implementações de acessórios
✅ Engenheiros de QA testando os produtos de suas empresas
✅ Proprietários de dispositivos verificando seus próprios acessórios
❌ NÃO para acesso não autorizado a dispositivos de terceiros

Conclusão

O WhisperPair-PoC-Tool demonstra que a experiência "perfeita" do Fast Pair vem acompanhada de trade-offs de segurança que muitos fabricantes deixam de resolver. A verificação do modo de emparelhamento é uma única condicional que separa um dispositivo seguro de um vulnerável, e ainda assim é frequentemente omitida.

O modelo de confiança do Fast Pair pressupõe que os dispositivos farão valer a intenção do usuário. Quando não o fazem, os atacantes obtêm emparelhamento silencioso, capacidades de rastreamento e vetores de negação de serviço contra os dispositivos das vítimas.

Esta ferramenta visa ajudar o ecossistema a identificar e remediar esses problemas, tornando os acessórios Bluetooth mais seguros para todos.

Referências

O WhisperPair-PoC-Tool é disponibilizado apenas para pesquisa de segurança autorizada. Nenhuma responsabilidade é assumida pelo uso indevido desta ferramenta.

`RAW_KBP`	`0x11`	INITIATE_BONDING \| EXTENDED_RESPONSE
`WITH_PUBLIC_KEY`	`0x11`	Solicitação de 80 bytes com chave pública ECDH
`RETROACTIVE`	`0x0A`	Contorna algumas verificações do fabricante
`EXTENDED`	`0x10`	Para firmware de dispositivos mais novos

Violação de gate (passiva)	+2	Anunciando FP quando não está no modo de emparelhamento
Bypass confirmado (ativo)	+2	Respondeu ao KBP quando não estava no modo de emparelhamento
FMDN sem Chave de Conta	+2	Rastreável pela rede Find My
Endereço BLE estático	+1	Dispositivo é persistentemente rastreável
Rotação de endereço observada	-1	Comportamento que preserva a privacidade

Detecção de vulnerabilidades	✅ Sim	Propósito principal
Extração de endereço BR/EDR	✅ Sim	Coleta de evidências
Emparelhamento Bluetooth Classic	❌ Não	Requer código específico de plataforma
Sequestro de áudio HFP	❌ Não	Fora do escopo da ferramenta BLE
Implante persistente	❌ Não	Capacidade maliciosa

whisperpair-poc-tool

Mais Populares