Segurança em Conexões Bluetooth no ESP32

Por que a Segurança no Bluetooth é Importante?🔗

O Bluetooth é uma tecnologia amplamente utilizada para comunicação sem fio de curto alcance. No contexto do ESP32, ela permite a troca de dados entre dispositivos, controle remoto e diversas aplicações IoT. Contudo, sem as devidas precauções, essas conexões podem ser vulneráveis a:

• Interceptação de Dados: Atacantes podem capturar informações sensíveis transmitidas entre dispositivos.
• Ataques Man-in-the-Middle (MitM): Um invasor posiciona-se entre dois dispositivos, interceptando e possivelmente alterando a comunicação.
• Acesso Não Autorizado: Dispositivos não confiáveis podem conectar-se e interagir com o ESP32, potencialmente causando danos ou obtendo acesso a informações privadas.

Conceitos Básicos de Segurança no Bluetooth🔗

Antes de mergulharmos nas implementações práticas, é fundamental entender alguns conceitos-chave relacionados à segurança no Bluetooth:

Modo de Segurança e Níveis de Segurança

O Bluetooth define diferentes modos e níveis de segurança para controlar como a autenticação, autorização e criptografia são aplicadas:

• Modo 1: Sem segurança.
• Modo 2: Segurança a nível de serviço; a autorização pode ser aplicada a serviços específicos.
• Modo 3: Segurança a nível de link; a autenticação e a criptografia são exigidas antes do estabelecimento da conexão.

Pairing e Bonding

• Pairing (Emparelhamento): Processo de estabelecimento de uma conexão confiável entre dois dispositivos, incluindo a troca de chaves para criptografia.
• Bonding (Vinculação): Armazenamento das informações de emparelhamento para conexões futuras sem a necessidade de repetir o processo de emparelhamento.

Implementando Segurança no Bluetooth Clássico com ESP32🔗

O ESP32 oferece suporte tanto ao Bluetooth Clássico quanto ao Bluetooth Low Energy (BLE). Vamos iniciar com o Bluetooth Clássico.

Configurando o Modo de Segurança

Para habilitar a segurança no Bluetooth Clássico, é necessário configurar o nível de segurança apropriado. Isso é feito através das APIs fornecidas pelo ESP-IDF ou pela biblioteca do Arduino.

Exemplo de Configuração de Segurança

#include "BluetoothSerial.h"
BluetoothSerial SerialBT;
void setup()
{
  Serial.begin(115200);
  // Inicializa o Bluetooth Serial com um nome
  SerialBT.begin("ESP32_Secure"); 
  // Define um PIN para emparelhamento
  SerialBT.setPin("1234");
}
void loop()
{
  // Código da aplicação
}

No exemplo acima:

• setPin("1234"): Define um PIN para o emparelhamento, adicionando uma camada básica de segurança.

Limitando Dispositivos Conectáveis

Outra medida de segurança é restringir quais dispositivos podem se conectar ao ESP32.

Exemplo de Autorização de Dispositivos

bool deviceAuthorized(const esp_bd_addr_t &bd_addr)
{
  // Lógica para verificar se o endereço do dispositivo é permitido
  // Pode ser uma comparação com uma lista de endereços MAC autorizados
  return true; // Retorna true se autorizado
}
void setup()
{
  // Configurações iniciais
}
void loop()
{
  // Código principal
}

Segurança no Bluetooth Low Energy (BLE) com ESP32🔗

O BLE oferece modos de segurança aprimorados e é geralmente preferido para aplicações que requerem baixa energia.

Níveis de Segurança no BLE

O BLE define quatro níveis de segurança:

• Nível 1: Sem segurança.
• Nível 2: Comunicação não emparelhada com criptografia.
• Nível 3: Comunicação emparelhada com criptografia.
• Nível 4: Comunicação emparelhada com criptografia e proteção contra ataques MitM.

Implementando Segurança no BLE

Configurando a Segurança no Servidor BLE

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
void setup()
{
  Serial.begin(115200);
  BLEDevice::init("ESP32_BLE_Secure");
  BLEServer *pServer = BLEDevice::createServer();
  // Configurações de segurança
  BLESecurity *pSecurity = new BLESecurity();
  // Define o modo de segurança
  pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_MITM_BOND);
  // Define o nível de chave de criptografia
  pSecurity->setKeySize(16);
  // Habilita o emparelhamento e vinculação
  pSecurity->setCapability(ESP_IO_CAP_OUT);
  pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
}
void loop()
{
  // Código da aplicação
}

No exemplo acima:

• ESP_LE_AUTH_REQ_SC_MITM_BOND: Requer emparelhamento com proteção contra ataques MitM e permite vinculação (bonding).
• setKeySize(16): Define o tamanho da chave de criptografia para 16 bytes.
• setCapability(ESP_IO_CAP_OUT): Configura as capacidades de E/S para o emparelhamento.

Utilizando Passkey para Mitigar Ataques MitM

O uso de um Passkey (código PIN) durante o emparelhamento adiciona uma camada extra de segurança.

uint32_t passKey = 123456; // Deve ser um número de 6 dígitos
void setSecurityParameters()
{
  BLESecurity *pSecurity = new BLESecurity();
  pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_MITM_BOND);
  pSecurity->setCapability(ESP_IO_CAP_OUT);
  pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
  pSecurity->setKeySize(16);
  pSecurity->setStaticPIN(passKey);
}

Boas Práticas para Segurança no Bluetooth com ESP32🔗

Use Criptografia Forte

• Utilize o maior tamanho de chave possível (por exemplo, 16 bytes).
• Certifique-se de que a criptografia está habilitada em todas as conexões.

Implementar Autenticação e Autorização

• Exija autenticação para todos os dispositivos que tentam se conectar.
• Utilize listas brancas para permitir apenas dispositivos confiáveis.

Evite PINs e Senhas Padrão

• Nunca use PINs como "0000" ou "1234" em aplicações reais.
• Implemente mecanismos para alterar o PIN periodicamente ou conforme necessário.

Mantenha o Firmware Atualizado

• Atualizações de firmware frequentemente contêm correções de segurança.
• Verifique regularmente por atualizações do ESP-IDF ou das bibliotecas do Arduino.

Desabilite Serviços Desnecessários

• Mantenha apenas os serviços e características BLE necessários para a aplicação.
• Reduza a superfície de ataque removendo funcionalidades não utilizadas.

Protegendo-se contra Ataques Comuns🔗

Ataques Man-in-the-Middle (MitM)

Para proteger-se contra ataques MitM:

• Utilize emparelhamento seguro com proteção contra MitM, como Just Works, Passkey Entry ou Numeric Comparison.
• Habilite a Secure Connections Only Mode, que força o uso de modos de emparelhamento seguros.

Sniffing e Escuta Clandestina

• Sempre habilite a criptografia nas conexões Bluetooth.
• Utilize chaves de criptografia fortes e de tamanho adequado.

Exemplo Prático: Implementando Segurança em uma Aplicação BLE🔗

Vamos construir um exemplo simples onde um ESP32 atua como servidor BLE seguro, transmitindo dados somente para dispositivos emparelhados e vinculados.

Passo 1: Configurar o Servidor BLE Seguro

#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
BLEServer *pServer = NULL;
BLECharacteristic *pCharacteristic = NULL;
bool deviceConnected = false;
void setup()
{
  Serial.begin(115200);
  BLEDevice::init("ESP32_Secure_BLE");
  pServer = BLEDevice::createServer();
  // Configurações de segurança
  BLESecurity *pSecurity = new BLESecurity();
  pSecurity->setAuthenticationMode(ESP_LE_AUTH_REQ_SC_MITM_BOND);
  pSecurity->setCapability(ESP_IO_CAP_IO);
  pSecurity->setInitEncryptionKey(ESP_BLE_ENC_KEY_MASK | ESP_BLE_ID_KEY_MASK);
  pSecurity->setKeySize(16);
  // Cria um serviço BLE
  BLEService *pService = pServer->createService(SERVICE_UUID);
  // Cria uma característica BLE
  pCharacteristic = pService->createCharacteristic(
                      CHARACTERISTIC_UUID,
                      BLECharacteristic::PROPERTY_READ |
                      BLECharacteristic::PROPERTY_NOTIFY
                    );
  pCharacteristic->addDescriptor(new BLE2902());
  // Inicia o serviço
  pService->start();
  // Inicia a publicidade
  pServer->getAdvertising()->start();
  Serial.println("Servidor BLE Seguro iniciado");
}
void loop()
{
  // Código da aplicação
  if (deviceConnected)
  {
    // Envia dados para o dispositivo conectado
    pCharacteristic->setValue("Dados Seguros");
    pCharacteristic->notify();
  }
}

Passo 2: Configurar as Callbacks para Conexão e Segurança

class MyServerCallbacks : public BLEServerCallbacks
{
  void onConnect(BLEServer *pServer)
  {
    deviceConnected = true;
    Serial.println("Dispositivo conectado");
  }
  void onDisconnect(BLEServer *pServer)
  {
    deviceConnected = false;
    Serial.println("Dispositivo desconectado");
  }
};
class MySecurity : public BLESecurityCallbacks
{
  uint32_t onPassKeyRequest()
  {
    Serial.println("Solicitação de PassKey");
    return passKey; // Retorna o PassKey previamente definido
  }
  void onPassKeyNotify(uint32_t pass_key)
  {
    Serial.printf("PassKey para inserir: %d\n", pass_key);
  }
  bool onConfirmPIN(uint32_t pass_key)
  {
    Serial.printf("Confirmação do PIN: %d\n", pass_key);
    return true; // Retorna true para confirmar o PIN
  }
  bool onSecurityRequest()
  {
    return true;
  }
  void onAuthenticationComplete(esp_ble_auth_cmpl_t cmpl)
  {
    if (cmpl.success)
    {
      Serial.println("Emparelhamento bem-sucedido");
    }
    else
    {
      Serial.println("Emparelhamento falhou");
    }
  }
};
void setup()
{
  // Configurações iniciais...
  pServer->setCallbacks(new MyServerCallbacks());
  pSecurity->setCallbacks(new MySecurity());
  // Continua configuração...
}

Considerações Finais🔗

Garantir a segurança em conexões Bluetooth com o ESP32 é vital para o desenvolvimento de aplicações confiáveis e protegidas. Ao implementar as práticas e técnicas discutidas neste artigo, você estará no caminho certo para criar soluções que não apenas atendam às necessidades funcionais, mas também protejam os dados e a privacidade dos usuários.

Lembre-se sempre de:

• Manter-se Atualizado: A segurança é um alvo em movimento. Novas vulnerabilidades podem surgir, e é essencial estar informado sobre as últimas recomendações.
• Testar Rigorosamente: Realize testes de segurança em suas aplicações, incluindo tentativas de conexão não autorizadas e possíveis ataques.
• Educação Contínua: A segurança é um campo amplo. Continuar aprendendo sobre criptografia, protocolos de segurança e melhores práticas será benéfico para seus projetos futuros.

Ao seguir essas diretrizes, você pode explorar todo o potencial do ESP32 e do Bluetooth em suas aplicações, com a confiança de que está tomando as medidas necessárias para proteger seus dispositivos e usuários.

Referências🔗

• Arduino IDE Official Website arduino.cc
• Documentação da Espressif docs.espressif.com
• Documentação de Apresentação do ESP32 espressif.com/en/products/socs/esp32
• Documentação do ESP32 Arduino Core docs.espressif.com/projects/arduino-esp32
• Guia de Programação ESP-IDF docs.espressif.com/projects/esp-idf