Sparrow-WiFi

Sparrow-WiFi é uma ferramenta de consciência espectral WiFi (2,4 GHz e 5 GHz) e Bluetooth para Linux. Ela integra em uma única plataforma: varredura WiFi, descoberta Bluetooth Low Energy e Classic, análise espectral via rádio definido por software (HackRF, Ubertooth), rastreamento GPS, detecção de drones FAA RemoteID, operações remotas montadas em drone/rover, e indexação ECS 8.17 no Elasticsearch ou OpenSearch. Escrito inteiramente em Python 3.

O projeto inclui quatro componentes que funcionam de forma independente ou em conjunto:

O Sparrow Agent e o Sparrow DroneID expõem APIs REST JSON que permitem que outros aplicativos consultem resultados de varredura, acionem varreduras, recuperem detecções de drones e integrem consciência sem fio/de drones em seus próprios fluxos de trabalho. O Elastic Bridge consome a API REST do agente e envia documentos ECS 8.17 com painéis Kibana agrupados.

Novidades (Abril de 2026)

Esta versão traz três melhorias significativas em relação à versão anterior:

• Sparrow Agent: coalescência de varreduras WiFi single-flight. Quando vários clientes HTTP (o aplicativo DroneID, a ponte Elasticsearch, a GUI) acessam /wireless/networks/<iface> simultaneamente, o agente anteriormente iniciava N chamadas redundantes iw scan que serializavam no bloqueio por interface, multiplicando a latência da varredura pelo número de clientes. Agora, a primeira solicitação é a "líder" que realmente escaneia; as solicitações concorrentes aguardam um threading.Event e compartilham o resultado da líder. Também inclui correção TOCTOU na criação de bloqueios e segurança contra exceções nos bloqueios por interface.
• Sparrow DroneID — novo aplicativo baseado na web para detecção FAA RemoteID via WiFi (ASTM F3411 NAN, IEs de fornecedor de beacon, protocolo proprietário DroneID da DJI) e Bluetooth LE (publicidade BT4/BT5 Legacy). Inclui sobreposições de geozonas, alertas multi-estado com integração Slack, exportação KML, saída Cursor-on-Target, indexação opcional ECS 8.17 para Elasticsearch / OpenSearch (com um namespace personalizado droneid.*) e uma interface web responsiva multi-dispositivo. Veja a seção Sparrow DroneID abaixo.
• Ponte modernizada para Elasticsearch / OpenSearch — a ponte sparrow-elastic.py foi reescrita para produzir documentos ECS 8.17 (era ECS 1.5), agora suporta tanto Elasticsearch 8.x quanto OpenSearch 2.x, inicializa automaticamente modelos de índice componíveis com políticas de ciclo de vida ILM/ISM e aliases de gravação rotativos, realiza enriquecimento de fornecedor OUI e classificação de dispositivos baseada em regras (com fingerprinting opcional Fingerbank), e entrega quatro painéis Kibana agrupados mais seis visualizações legadas preservadas. A ponte ECS 1.5 legada está preservada em legacy/sparrow-elastic.py. Veja .

Sparrow-WiFi (GUI Desktop)

O aplicativo Sparrow original fornece uma GUI abrangente que substitui ferramentas como inSSIDer e LinSSID, com capacidades muito além da varredura básica:

• Varredura WiFi — Descoberta de SSID em 2,4 GHz e 5 GHz, intensidade do sinal, utilização do canal
• Rastreamento de fontes — Modo Hunt com altas taxas de amostragem e janelas de telemetria para localizar fontes WiFi e Bluetooth
• Análise espectral — Sobreposições espectrais em tempo real de 2,4/5 GHz via Ubertooth One ou HackRF One
• Bluetooth — Varredura de anúncios BLE, detecção/publicidade iBeacon, modo promíscuo do Ubertooth para classic + LE
• Agente remoto — Agente headless (sparrowwifiagent.py) para varredura distribuída, operações montadas em drone/rover e implantações em Raspberry Pi
• Integração GPS — gpsd, coordenadas estáticas ou MAVLink (GPS de drone)
• Mapeamento — Visualização no Google Maps / OpenStreetMap dos resultados da varredura com trilhas GPS
• Importar/Exportar — Saída CSV, JSON e iw scan bruta
• Elasticsearch / OpenSearch — Indexação compatível com ECS 8.17 de dados de varredura WiFi e Bluetooth com gerenciamento de ciclo de vida ILM/ISM, classificação de dispositivos, fingerprinting opcional Fingerbank e painéis Kibana agrupados
• Plugin Falcon — Integração com Aircrack-ng para testes de penetração (modo monitor, descoberta de SSID oculto, deauth, captura WEP/WPA)

Capturas de tela

Sparrow DroneID (Aplicação Web)

Um sistema independente baseado na web para detecção e rastreamento de drones que decodifica transmissões obrigatórias de Identificação Remota (RemoteID) da FAA. Executa como um servidor HTTP Python com uma interface de navegador acessível de qualquer dispositivo na rede.

Capacidades

• Captura WiFi — Decodifica quadros de ação ASTM F3411 NAN, IEs de fornecedor de beacon e DroneID proprietário da DJI
• Captura Bluetooth LE — Decodifica publicidade ASTM F3411 BT4/BT5 Legacy (UUID 0xFFFA)
• Mapa em tempo real — Mapa baseado em Leaflet com ícones de quadricóptero, indicadores de direção, marcadores de posição do operador e linhas drone-operador
• Rótulos rápidos — ID do operador e altitude AGL exibidos sob cada ícone de drone no mapa
• Popups de detalhes — Clique em um drone para ver número de série, ID de registro, ID do operador, tipo, velocidade, direção, altitude, rumo/distância do receptor, status BVLOS
• Sistema de alertas — Alertas configuráveis para novos drones, violações de altitude, violações de velocidade e perda de sinal com tons de áudio, notificações visuais, notificações webhook Slack e POSTs JSON opcionais com token de portador para uma API genérica externa de ingestão de alertas (veja Alertas Baseados em API abaixo)
• Reconhecimento de alertas — Fluxo de trabalho de três estados (Ativo/Reconhecido/Resolvido) com identidade do operador, compartilhado entre todos os dispositivos conectados
• Geozonas de aeroportos — Download automático e exibição de aeroportos próximos (dados OurAirports) e polígonos de espaço aéreo Proibido/Restrito da FAA, armazenados em cache localmente para operação offline
• GPS — Integração gpsd ou coordenadas estáticas configuráveis
• Histórico e reprodução — Histórico de detecção armazenado em SQLite com reprodução de linha do tempo e exportação KML
• Cursor-on-Target (CoT) — Saída CoT multicast para integração com SA
• Multi-dispositivo — Interface web funciona em desktop, tablet e telefone simultaneamente
• Métrico / Imperial — Suporte completo a preferências de unidades em toda a interface e alertas

A interface web está disponível em http://localhost:8097 após a inicialização. Veja Instalação abaixo para configuração, e a referência da API para acesso programático.

Alertas Baseados em API

Além dos webhooks Slack, o Sparrow DroneID pode enviar cada alerta disparado para um endpoint genérico externo de ingestão de alertas. O canal está desabilitado por padrão; configure-o em Configurações → Alertas → Alertas Baseados em API:

• Ativar — liga/desliga
• Raiz do Endpoint da API — URL raiz completa incluindo qualquer prefixo de caminho, ex.: http://MEU_HOST_DA_API:PORTA/RAIZ_DA_API
• Domínio — string opaca de locatário que a API receptora usa para rotear alertas
• Token de Portador — enviado no cabeçalho Authorization: Bearer ...; mascarado na interface após armazenado
• Verificar TLS — desmarque para endpoints com certificado autoassinado ou CA privada
• Testar Autenticação — chama o endpoint de verificação do receptor e reporta aprovação/reprovação clara
• Enviar Mensagem de Teste — envia um alerta sintético (rule.category: "test", serial TEST-0000) para que o receptor possa ser exercitado de ponta a ponta sem esperar por um drone real

Contrato do endpoint

O Sparrow DroneID faz duas chamadas contra a URL raiz configurada:

Ambas as chamadas enviam Authorization: Bearer <token> e Content-Type: application/json.

Formato do payload```json

{ "domain": "", "alert": { "message": "", "observer": { "name": "<operator_name or 'Sparrow DroneID'>", "type": "drone-sensor", "geo": {"location": {"lat": 0.0, "lon": 0.0}} }, "rule": {"name": "", "category": "drone_detection"}, "event": { "severity": 40, "category": "network", "action": "new_drone" }, "labels": { "serial": "", "vendor": "", "ua_type": "", "alert_type": "new_drone | altitude_max | speed_max | signal_lost" }, "source": {"geo": {"location": {"lat": 0.0, "lon": 0.0}}}, "details": { "operator_id": "...", "registration_id": "...", "self_id_text": "...", "mac_address": "...", "protocol": "...", "rssi": -68, "range_m": 1234.5, "bearing_deg": 215.0, "bearing_cardinal": "SW", "speed_mps": 5.2, "direction_deg": 240.0, "altitude_m_agl": 42.0, "detail": "..." } } }

`observer.geo.location` é incluída quando o receptor tem fixação GPS; `source.geo.location` é incluída quando o drone está transmitindo uma posição. A severidade segue a convenção ECS (menor = mais urgente): avisos (`new_drone`, `altitude_max`, `speed_max`) são `40`, eventos informativos (`signal_lost`) são `70`. Drones marcados como amigáveis não disparam alertas quando o alternador "Alert on Friendly drones" do lado do operador está desligado, portanto, eles também não atingem este endpoint.

Alertas de teste sintéticos emitidos pelo botão **Send Test Message** usam `rule.category: "test"`, `event.action: "test"`, `event.severity: 70`, e serial `TEST-0000` para que o receptor possa reconhecê-los e excluí-los dos painéis operacionais.

---

## Requisitos do Sistema

| Requisito | Sparrow-WiFi (GUI) | Sparrow DroneID (Web) |
|-------------|-------------------|----------------------|
| **SO** | Ubuntu 20.04+, Kali 2020.3+, Debian 11+ | Ubuntu 20.04+, Kali, Debian 11+, Raspberry Pi OS |
| **Python** | 3.8+ | 3.8+ |
| **Root** | Necessário (iw scan) | Necessário (modo monitor, BLE) |
| **Adaptador WiFi** | Qualquer um com suporte a `iw` | Capaz de modo monitor (ex.: rtl8812au, Intel AX200) |
| **Bluetooth** | Opcional (adaptador hci, Ubertooth) | Opcional (qualquer adaptador compatível com BLE para RemoteID) |
| **GPS** | Opcional (gpsd) | Opcional (gpsd ou coordenadas estáticas) |
| **Display** | Desktop X11/Wayland | Headless OK (navegador web em qualquer dispositivo) |

---

## Instalação

### Sparrow-WiFi (GUI de Desktop)```bash
git clone https://github.com/ghostop14/sparrow-wifi
cd sparrow-wifi

Pacotes do sistema (Ubuntu 22.04+ / Debian 12+ / Kali rolling):```bash sudo apt install python3-pip python3-pyqt5 python3-pyqt5.qtchart
gpsd gpsd-clients python3-tk python3-setuptools

> **Usuários do Kali:** PyQt5, PyQtChart e aircrack-ng (para o plugin Falcon) geralmente vêm pré-instalados. Você basicamente só precisará do `gpsd`, `gpsd-clients` e das dependências Python abaixo.

Dependências Python — escolha uma das abordagens:

**Opção A: Instalação em todo o sistema com `--break-system-packages`** — a mais simples, adequada para como a GUI/agente são iniciados (scripts pertencentes ao root):```bash
# Modern systems (Ubuntu 24.04+, Kali rolling 2023+, Debian 12+) require this
# flag because Python is marked externally-managed (PEP 668). Sparrow runs as
# root anyway, so system-wide install is consistent with how it executes.
sudo pip3 install --break-system-packages -r requirements.txt

Opção B: Ambiente virtual — isolado, sem avisos do pip do sistema, preferido por alguns operadores:```bash python3 -m venv venv source venv/bin/activate pip install -r requirements.txt

Run with sudo using the venv interpreter:

sudo venv/bin/python3 ./sparrow-wifi.py

De qualquer forma, execute:```bash
sudo ./sparrow-wifi.py

Sparrow DroneID (Aplicação Web)```bash

cd sparrow-droneid

System tools — tcpdump for WiFi monitor mode, bluez for BLE RemoteID

sudo apt install tcpdump bluez

Python dependencies — pick one of:

sudo pip3 install --break-system-packages -r sparrow_droneid/requirements.txt

or:

python3 -m venv venv && source venv/bin/activate && pip install -r sparrow_droneid/requirements.txt

Run (either entry point works):

sudo python3 sparrow_droneid/app.py

or: sudo python3 -m sparrow_droneid

Abra `http://localhost:8097` num navegador. Configure a interface de monitoramento e o GPS nas Configurações, depois clique em Iniciar.

### Ponte Elasticsearch / OpenSearch (opcional)```bash
sudo pip3 install --break-system-packages -r requirements-elastic.txt
# or via venv as above

See Elasticsearch / OpenSearch Integration below.

Notas sobre Adaptadores WiFi

A maioria dos adaptadores WiFi funciona para varredura básica. O Sparrow-WiFi suporta múltiplos backends de enumeração de interfaces (iw, iwconfig, nmcli) para funcionar em sistemas que podem não ter o iw instalado (ex.: RHEL/Fedora apenas com NetworkManager).

Para o modo monitor (necessário para o Sparrow DroneID e o plugin Falcon), o suporte do adaptador e do driver varia:

• Recomendado: Alfa AWUS036ACH (rtl8812au), Alfa AWUS036AXML (mt7921au)
• Funciona bem: Intel AX200/AX210 (iwlwifi) para varredura; a entrega de quadros no modo monitor varia conforme a versão do firmware
• Teste primeiro: iw phy <phy> info | grep monitor ou iwconfig <iface> para verificar as capacidades

Para o Sparrow DroneID especificamente, o adaptador deve entregar quadros 802.11 brutos no modo monitor. Alguns adaptadores Intel reportam suporte ao modo monitor, mas descartam quadros silenciosamente no nível do firmware. A aplicação detecta isso e avisa você.

Bluetooth

O Sparrow-WiFi suporta vários modos de varredura Bluetooth:

Um adaptador Bluetooth padrão embutido ou USB é suficiente para varredura de anúncios BLE e detecção de drones RemoteID. Teste seu adaptador com bluetoothctl scan on.

Para descoberta promíscua completa de dispositivos Classic e BLE, você precisará de um Ubertooth One e Blue Hydra instalados em /opt/bluetooth/blue_hydra. Isso é opcional e não é necessário para varredura básica de BLE ou RemoteID.

Análise Espectral

Sobreposições espectrais em tempo real sobre visualizações de canais WiFi:

Ubertooth One

• Apenas 2,4 GHz, resolução de 1 MHz
• Teste com: ubertooth-specan-ui

HackRF One

• 2,4 GHz (resolução de 0,5 MHz) e 5 GHz (resolução de 2 MHz)
• Uma banda de cada vez; combine com o Ubertooth para banda dupla simultânea
• Use uma antena dual-band apropriada (a antena padrão do HackRF é classificada apenas para 1 GHz)
• Nota: adaptador RP-SMA para SMA necessário para a maioria das antenas WiFi
• Teste com: hackrf_sweep

GPS

Ambas as aplicações usam gpsd para GPS. Configuração rápida:```bash

Install

sudo apt install gpsd gpsd-clients

Test with a USB GPS receiver

sudo gpsd -D 2 -N /dev/ttyUSB0

Verify

xgps # or: cgps -s

Para produção, configure `/etc/default/gpsd` com o caminho do seu dispositivo e reinicie o serviço.

O Sparrow DroneID também suporta coordenadas estáticas (configuradas em Configurações) para instalações em locais fixos sem um receptor GPS.

---

## Agente Remoto e Integração de API

O agente Sparrow (`sparrowwifiagent.py`) é um servidor HTTP headless que expõe todas as capacidades de varredura Wi-Fi e Bluetooth do Sparrow como uma API REST baseada em JSON. É assim que a interface gráfica Sparrow-WiFi se comunica com sensores remotos, mas a API está aberta para qualquer aplicação utilizar.

**Casos de uso:**
- Implante em um Raspberry Pi, drone ou rover para varredura remota/móvel
- Integre a consciência situacional Wi-Fi e Bluetooth em suas próprias aplicações
- Alimente dados de varredura em SIEM, painéis ou pipelines de alerta
- Automatize varreduras com scripts (dispare varreduras, obtenha resultados via curl/Python/etc.)

O Sparrow DroneID também possui sua própria API REST ([referência da API](https://github.com/ghostop14/sparrow-wifi/blob/HEAD/sparrow-droneid/sparrow_drone_id_api.md)), fornecendo acesso programático a detecções de drones, gerenciamento de alertas, geozonas e configuração do sistema.

### Executando o Agente```bash
sudo ./sparrowwifiagent.py

Escuta na porta 8020 por padrão. Opções principais:

Veja --help para a lista completa.

Exemplos de chamadas de API```bash

List wireless interfaces the agent can scan

curl http://sensor:8020/wireless/interfaces

Trigger a WiFi scan and pull results (multiple concurrent callers

get coalesced into a single iw scan; first caller is the leader)

curl http://sensor:8020/wireless/networks/wlan0

Filter to specific frequencies

curl "http://sensor:8020/wireless/networks/wlan0?frequencies=2412,2437,2462"

Query GPS status

curl http://sensor:8020/gps/status

Start a Bluetooth Low Energy advertisement scan

curl http://sensor:8020/bluetooth/discoverystarta

Pull current BT discovery results

curl http://sensor:8020/bluetooth/discoverystatus

Para Sparrow DroneID, consulte a [referência de API dedicada](https://github.com/ghostop14/sparrow-wifi/blob/HEAD/sparrow-droneid/sparrow_drone_id_api.md).

> **Nota de produção:** o agente escuta em todas as interfaces por padrão. Para implantações fora de uma rede confiável, use `--allowedips` para restringir chamadores, execute atrás de um proxy reverso com TLS, ou vincule a uma interface privada apenas.

---

## Falcon / Aircrack-ng Plugin

Integração avançada de testes de penetração sem fio. Fornece acesso por clique a:

- Descoberta de SSID oculto via airodump-ng
- Enumeração de estações cliente (AP conectado, SSIDs sondados)
- Desautenticação direcionada e de broadcast
- Captura de IV WEP
- Captura de handshake WPA com extração automática de hash (requer JTR `wpapcap2john`)

### Pré-requisitos```bash
# Kali users: aircrack-ng + JTR are usually pre-installed.
# Ubuntu / Debian / Raspberry Pi OS:
sudo apt install aircrack-ng john

Verifique se airmon-ng, airodump-ng e wpapcap2john estão no seu PATH após a instalação.

Aviso

Testes de penetração ativos estão sujeitos a regulamentações legais. É sua responsabilidade obter autorização apropriada antes de usar estas ferramentas.

Integração com Elasticsearch / OpenSearch

O pacote sparrow_elastic fornece uma ponte ECS 8.17 que consulta o agente Sparrow WiFi e faz indexação em lote de observações WiFi e Bluetooth no Elasticsearch 8.x ou OpenSearch 2.x. Ele inicializa automaticamente templates de índice compostos, políticas de ciclo de vida ILM/ISM e aliases de escrita de rollover; realiza enriquecimento de fornecedor OUI e classificação de dispositivos baseada em regras (com impressão digital opcional do Fingerbank); e fornece dashboards pré-construídos do Kibana.

Início rápido```bash

1. Start the remote agent (it provides scan data via HTTP)

sudo ./sparrowwifiagent.py

2. Install bridge dependencies

sudo pip3 install --break-system-packages -r requirements-elastic.txt

3. Run the bridge

./sparrow-elastic.py --elasticserver http://user:pass@host:9200 --wifiinterface wlan1

4. (Optional) Import the bundled Kibana dashboards

python3 install_dashboards.py --kibana-url http://kibana:5601
--username elastic --password ''

> **Higiene de credenciais:** incorporar `user:pass@` em `--elasticserver` é conveniente, mas a URL fica visível em `ps`, `journalctl` e no histórico do shell. Para produção, utilize os flags `--username`/`--password`, variáveis de ambiente (`SPARROW_ES_USERNAME`, `SPARROW_ES_PASSWORD`) ou o padrão `EnvironmentFile=` no exemplo de unidade systemd incluído.

### O que a ponte fornece

- **5 dashboards do Kibana** — Consciência Situacional, Padrão de Vida, Deteção de Novos Dispositivos, Planeamento de Espectro (com mapa de calor de intensidade do sinal SSID × Canal) e Consciência Situacional Bluetooth (com painel Vega de dispositivos verdadeiramente novos e tabela de proximidade de distância estimada)
- **6 visualizações preservadas legadas** — clones renomeados de campos das visualizações originais `Sparrow*` para que a memória muscular antiga continue a funcionar
- **Classificador de dispositivos** — tabela inicial com 64 regras cobrindo controladores de drones (DJI/Autel/Skydio/Parrot/Yuneec), Classe de Dispositivo BT, Aparência GAP, subtipos Apple Continuity e heurísticas de fornecedor OUI
- **Atualização de dados de referência** — `manuf` do Wireshark, IDs de empresas da BT SIG, UUIDs de serviço, valores de aparência GAP e tabelas de subtipo Apple Continuity incluídos, com uma thread de fundo de auto-atualização a cada 30/90 dias
- **Verificação de compatibilidade pré-voo** &mdah; recusa escrever em índices legados ECS 1.5 e imprime instruções de correção claras em vez de corromper silenciosamente os dados

Para documentação completa do operador (seleção de motor, modos de autenticação, importação de dashboards, dados de referência, referência completa da CLI) consulte [sparrow_elastic/README.md](https://github.com/ghostop14/sparrow-wifi/blob/HEAD/sparrow_elastic/README.md).

Os ficheiros de configuração de exemplo estão na raiz do repositório e em `init.d_scripts/`:

- `sparrow-elastic.conf.example` — configuração estilo INI com todas as chaves suportadas
- `sparrow-elastic.env.example` — ficheiro de ambiente formato shell para deployments systemd
- `init.d_scripts/sparrow-elastic.service.example` — template de unidade systemd

### Migração a partir da ponte legada ECS 1.5

A ponte pré-2026 escrevia documentos ECS 1.5 em índices nomeados pelo operador via `--wifiindex` / `--btindex`. A nova ponte escreve documentos ECS 8.17 em aliases de escrita geridos por rollover (por defeito `sparrow-wifi` / `sparrow-bt`).

**O script legado está preservado em `legacy/sparrow-elastic.py`** juntamente com o seu template `.txt` e ficheiros de política ILM. Executá-lo ainda requer o ambiente legado (template manual + configuração ILM).

**Alterações de flags (com retrocompatibilidade):**

| Flag legada        | Nova flag           | Notas                                                  |
|--------------------|---------------------|--------------------------------------------------------|
| `--wifiindex NAME` | `--wifi-alias NAME` | A grafia legada ainda é aceite como um alias obsoleto. |
| `--btindex NAME`   | `--bt-alias NAME`   | A grafia legada ainda é aceite como um alias obsoleto. |
| `--dont-create-indices` | inalterado      | Ignora o bootstrap.                                    |
| `--elasticserver`, `--sparrowagent`, `--sparrowport`, `--wifiinterface`, `--scandelay` | inalterado | |

Uma invocação legada como:```bash
./sparrow-elastic.py --elasticserver=http://user:pass@host:9200 \
                     --wifiinterface=wlan1 \
                     --wifiindex=sparrowwifi-home \
                     --btindex=sparrowbt-home

ainda analisa e executa — mas a bridge agora se recusa a escrever em um índice pré-existente cujo mapeamento não carrega o marcador de esquema ECS 8.17, encerrando com três opções de remediação (use um alias diferente, limpe e re-bootstrap, ou execute a bridge legada). Para uma instalação limpa, basta remover --wifiindex / --btindex e aceitar os novos padrões.

Operações de Drone / Rover

O agente remoto pode ser implantado em um Raspberry Pi montado em um drone ou rover para levantamento sem fio móvel. Testado em um drone Solo 3DR com integração GPS via MAVLink.

Gravação Autônoma```bash

On the Pi: auto-start, pull drone GPS, record to local files

sudo python3 ./sparrowwifiagent.py --userpileds --sendannounce --mavlinkgps 3dr --recordinterface wlan0

Indicadores LED (Raspberry Pi):
1. Ambos apagados — Inicializando
2. Batimento cardíaco vermelho — GPS presente, não sincronizado
3. Vermelho contínuo — GPS sincronizado
4. Verde contínuo — Agente pronto, atendendo requisições

Gravações podem ser recuperadas através da interface de gerenciamento de agentes do Sparrow-WiFi GUI.

### Notas de Configuração do Pi

- Use Raspberry Pi OS (Bookworm ou superior) com Python 3.8+
- Desative o WiFi integrado para permitir varredura de 5 GHz com adaptadores USB: adicione `dtoverlay=disable-wifi` ao `/boot/firmware/config.txt` no Bookworm e posteriores, ou `/boot/config.txt` em versões anteriores
- Instale os pré-requisitos: `sudo pip3 install --break-system-packages -r requirements.txt` (ou use um venv conforme a seção [Instalação](#installation))

---

## Estrutura do Projeto```
sparrow-wifi/
  sparrow-wifi.py            # Desktop GUI entry point
  sparrowwifiagent.py        # Headless remote agent
  sparrow-elastic.py         # Elasticsearch / OpenSearch bridge (ECS 8.17)
  install_dashboards.py      # One-shot Kibana dashboard installer
  requirements.txt           # Python dependencies (GUI)
  requirements-elastic.txt   # Python dependencies (Elasticsearch bridge)
  wirelessengine.py          # WiFi scan engine (iw)
  sparrowbluetooth.py        # Bluetooth scan engine
  sparrowhackrf.py           # HackRF spectrum engine
  sparrowmap.py              # Map generation
  plugins/                   # Falcon and other plugins
  sparrow_elastic/           # ES/OS bridge package
    *.py                     # Client abstraction, document builder, classifier...
    templates/               # Composable index templates (ES + OS variants)
    policies/                # ILM (ES) and ISM (OS) lifecycle policy JSON
    dashboards/              # Kibana NDJSON: 5 dashboards + legacy-preserved
    data/                    # Bundled reference data (manuf, BT SIG, classifier rules)
    README.md                # Full bridge operator documentation
  legacy/                    # Pre-2026 ECS 1.5 bridge, frozen for reference
    sparrow-elastic.py       # Legacy bridge (still runnable)
    sparrow_elastic_*.txt    # Legacy index templates and ILM policy
  sparrow-droneid/           # DroneID web application
    sparrow_droneid/
      app.py                 # Entry point (sudo python3 app.py)
      __main__.py            # Allows: sudo python3 -m sparrow_droneid
      requirements.txt       # Python dependencies (DroneID)
      backend/               # API server, capture engine, database
      frontend/              # HTML, JS, CSS (served by backend)
    sparrow_drone_id_api.md  # REST API reference

Licença

Este projeto está licenciado sob os termos incluídos no repositório. Consulte o arquivo LICENSE para mais detalhes.