bigbodycobain/shadowbrokerPlataforma OSINT geoespacial em tempo real que agrega mais de 60 feeds públicos de telemetria (ADS-B, AIS, satélites, CCTV) em um mapa unificado com kit de reconhecimento no lado do servidor, canal de agente de IA e comunicações descentralizadas em malha.
Plataforma de Inteligência Geoespacial em Tempo Real — Interceptação Global de Ameaças
ShadowBroker é uma plataforma de inteligência descentralizada que agrega telemetria OSINT multidomínio em tempo real de mais de 60 feeds de inteligência ao vivo em uma única interface de mapa de operações secretas. Aeronaves, navios, satélites, zonas de conflito, redes de CCTV, bloqueio de GPS, dispositivos conectados à Internet, scanners policiais, nós de rádio mesh e eventos geopolíticos de última hora — tudo atualizando em tempo real em uma única tela, além de um protocolo de comunicação ofuscado e infraestrutura de troca de informações.
Construído com Next.js, MapLibre GL, FastAPI e Python. Mais de 40 camadas de dados alternáveis, incluindo detecção de mudanças no solo SAR, OSINT do Telegram (visualizações de canais públicos geoparsadas no mapa), um kit de ferramentas de reconhecimento do lado do servidor (DNS, WHOIS, sanções, BGP, varredura de IP e mais), sobreposições de risco da cadeia de suprimentos e feeds de ameaças cibernéticas de malware/C2 + CISA KEV. Múltiplos modos visuais (DEFAULT / SATELLITE / FLIR / NVG / CRT). Clique com o botão direito em qualquer ponto da Terra para obter um dossiê do país, consulta de chefe de estado, expansão do gráfico de entidades e a foto mais recente do satélite Sentinel-2. ShadowBroker não tem contas, telemetria de produto ou análises; o painel se comunica com seu backend auto-hospedado. Consultas sensíveis de reconhecimento e Shodan nunca chegam a APIs de terceiros a partir do navegador — elas são intermediadas pelo backend com proteções SSRF e autenticação de operador local. O canal de comando de agente OpenClaw expõe os mesmos backends de reconhecimento mais pesquisa completa de telemetria — sem necessidade de integração de API separada.
Projetado para analistas, pesquisadores, operadores de rádio e qualquer pessoa que queira ver como o mundo parece quando todos os sinais públicos estão no mesmo mapa.
Uma quantidade surpreendente de telemetria global já é pública — transmissões ADS-B de aeronaves, sinais AIS marítimos, dados orbitais de satélites, sensores de terremotos, redes de rádio mesh, feeds de scanners policiais, estações de monitoramento ambiental, telemetria de infraestrutura da Internet e muito mais. Esses dados estão espalhados por dezenas de ferramentas e APIs. ShadowBroker combina tudo em uma única interface.
O projeto não introduz novas capacidades de vigilância — ele agrega e visualiza conjuntos de dados públicos já existentes. É totalmente open-source para que qualquer pessoa possa auditar exatamente quais dados são acessados e como. ShadowBroker não inclui telemetria de produto, análises ou contas. As chaves fornecidas pelo operador permanecem em sua implantação local, mas os recursos de OSINT ao vivo necessariamente fazem requisições de saída para os provedores de dados públicos que você ativar ou consultar.
ShadowBroker inclui um conector Shodan opcional para acesso à API fornecido pelo operador (SHODAN_API_KEY) e um painel de Kit de Ferramentas de Reconhecimento para consultas OSINT sem chave. Ambos são executados apenas no lado do servidor: o navegador chama suas rotas /api/osint/* e /api/tools/shodan/* auto-hospedadas; as requisições de saída são feitas pelo backend após validação SSRF. O reconhecimento requer acesso de operador local (mesmo modelo de confiança que alternâncias de camada e rotas de administrador). Os resultados do Shodan são renderizados como uma sobreposição de mapa separada e permanecem sujeitos aos termos de serviço do Shodan.
search_telemetry, search_news), o kit de ferramentas de reconhecimento completo (osint_lookup para IP/DNS/WHOIS/sanções/CVE/etc.), expansão de gráfico de entidades, colocação de pinos, controle de mapa, mudança de solo SAR, redes mesh e entrega de alertas. Ele vê tudo o que o operador vê e pode realizar ações no mapa em tempo real.⚡ Início Rápido (Docker)
git clone https://github.com/bigbodycobain/Shadowbroker.git cd Shadowbroker docker compose pull docker compose up -d
### Do GitLab (usa o GitLab Container Registry)```bash
git clone https://gitlab.com/bigbodycobain/Shadowbroker.git
cd Shadowbroker
docker compose -f docker-compose.yml -f docker-compose.gitlab.yml pull
docker compose -f docker-compose.yml -f docker-compose.gitlab.yml up -d
Ambos os caminhos produzem contêineres idênticos — mesma fonte, mesma CI, mesmas imagens byte por byte. Escolha o ecossistema que você já usa.
Abra http://localhost:3000 para visualizar o painel! (Requer Docker Desktop ou Docker Engine)
Entre no swarm privado da InfoNet (sb-testnet-0): Clique em NODE no painel, ou execute
./meshnode.shpara um participante sem interface. Nenhuma lista de pares manual — as configurações padrão da frota descobrem a semente e puxam o manifesto assinado automaticamente. DefinaMESH_INFONET_FLEET_JOIN=falseno.envpara um nó solo privado.
Porta do backend já em uso? O navegador precisa apenas da porta
3000, mas a API do backend também é publicada na porta8000do host para diagnósticos locais. Se outro aplicativo já usa8000, crie ou edite o.envao lado dodocker-compose.ymle definaBACKEND_PORT=8001, depois executedocker compose up -d.
Notícias/UAP/bases/águas residuais em branco após vários minutos? Verifique reinicializações do backend por OOM com
docker events --since 30m --filter container=shadowbroker-backend --filter event=oom. O arquivo compose padrão dá 4GB ao backend; se seu host tiver menos memória, reduza os feeds ativados ou definaBACKEND_MEMORY_LIMIT=3Ge espere que camadas mais lentas/pesadas aqueçam mais gradualmente.
Usuários do Podman: O Podman funciona, mas
podman composeé um wrapper e ainda precisa de um provedor do Compose instalado. No Windows/WSL, se você virlooking up compose provider failed, instalepodman-composee executepodman-compose pullseguido depodman-compose up -dde dentro da pasta clonadaShadowbroker. Em shells Linux/macOS/WSL você também pode usar./compose.sh --engine podman pulle./compose.sh --engine podman up -d.
🔄 Como Atualizar
O ShadowBroker usa imagens Docker pré-construídas — nenhuma compilação local necessária. A atualização leva segundos:```bash docker compose pull docker compose up -d
É isso. O `pull` baixa as imagens mais recentes, `up -d` reinicia os containers.
> **Está vindo de uma versão mais antiga?** Baixe primeiro o código mais recente do repositório e depois baixe as imagens:
>
> ```bash
> git pull origin main
> docker compose down
> docker compose pull
> docker compose up -d
> ```
>
> Usuários do Podman devem executar o comando equivalente do provedor, por exemplo `podman-compose pull` e `podman-compose up -d`, ou usar `./compose.sh --engine podman pull` e `./compose.sh --engine podman up -d` a partir de um shell compatível com bash.
### Integridade da Atualização
As atualizações do Docker são entregues por meio de registros de contêineres assinados. O auto-atualizador ZIP legado verifica os arquivos de lançamento através desta cadeia, nesta ordem:
* `MESH_UPDATE_SHA256` quando um operador fixa um digest explicitamente.
* `backend/data/release_digests.json` para pins de lançamento agrupados.
* O asset `SHA256SUMS.txt` do lançamento no GitHub quando um pin agrupado não está presente.
Os mantenedores de lançamento devem executar `python backend/scripts/release_helper.py hash <ShadowBroker_vX.Y.Z.zip>` antes de publicar, depois publicar `SHA256SUMS.txt` e atualizar `backend/data/release_digests.json` ao enviar um alvo de atualizador ZIP. O atualizador mantém o caminho de substituição do operador intacto, em vez de falhar fechado em caso de digests agrupados ausentes, para que as instalações existentes não fiquem presas por um erro no processo de lançamento.
### Fortalecimento CSP
O frontend de produção vem com um CSP compatível com hidratação e um CSP estrito somente com nonce em `Content-Security-Policy-Report-Only`. Defina `SHADOWBROKER_STRICT_CSP=1` somente após verificar se a construção exata hidrata corretamente em sua implantação. Fontes Google em tempo de execução não são necessárias; o pipeline de fontes Next agrupado serve a fonte do painel a partir da construção do aplicativo.
### ⚠️ **Preso na versão antiga?**
**Se `git pull` falhar ou `docker compose up` continuar compilando a partir do código fonte em vez de baixar imagens**, seu clone é anterior a uma migração do repositório de março de 2026 que reescreveu o histórico de commits. Um `git pull` normal não consegue corrigir isso. Execute:```bash
# Back up any local config you want to keep (.env, etc.)
cd ..
rm -rf Shadowbroker
git clone https://github.com/bigbodycobain/Shadowbroker.git
cd Shadowbroker
docker compose pull
docker compose up -d
Como saber se você é afetado: Se docker compose up mostra RUN apt-get, RUN npm ci, ou RUN pip install — está compilando a partir do código-fonte em vez de baixar imagens pré-construídas. Você precisa de um clone novo.
Outras soluções de problemas:
docker compose pull --no-cachedocker image prune -fdocker compose logs -f backendPara implantações de alta disponibilidade ou clusters de laboratório doméstico, o ShadowBroker oferece suporte à implantação via Helm. Este chart é baseado no template bjw-s-labs e fornece uma configuração robusta e modular tanto para o backend quanto para o frontend.
1. Adicione o Repositório:```bash helm repo add bjw-s-labs https://bjw-s-labs.github.io/helm-charts/ helm repo update
**2. Instalar o Chart:**```bash
# Default — pulls images from GHCR
helm install shadowbroker ./helm/chart --create-namespace --namespace shadowbroker
# GitLab registry variant
helm install shadowbroker ./helm/chart --create-namespace --namespace shadowbroker \
-f helm/chart/values.yaml \
-f helm/chart/values-gitlab.yaml
3. Funcionalidades Principais:
Agradecimentos especiais ao @chr0n1x por contribuir com a arquitetura Kubernetes inicial.
O ShadowBroker v0.9.7 inclui InfoNet (malha de inteligência descentralizada + economia de governança Shell Soberano), um canal de comando de IA agêntico (suporta OpenClaw e qualquer agente de assinatura HMAC), reprodução instantânea Time Machine e detecção de mudanças no solo por SAR. Esta é uma testnet experimental — não é um mensageiro privado nem um sistema de governança de produção.
A primeira camada de comunicação e governança de inteligência descentralizada construída diretamente em uma plataforma OSINT. Sem contas, sem cadastro, sem identidade necessária. A v0.9.7 promove o InfoNet de uma camada de chat para uma economia de governança completa com um caminho claro para uma plataforma de inteligência descentralizada que preserva a privacidade.
Camada de Comunicação (desde v0.9.6):
send, dm, comandos de mercado, inspeção de estado do gate. Painel arrastável, minimiza para a barra superior. Digite help para ver todos os comandos.Shell Soberano — economia de governança (NOVO na v0.9.7):
O repositório inclui um docker-compose.yml que baixa imagens pré-construídas do GitHub Container Registry.```bash
git clone https://github.com/BigBodyCobain/Shadowbroker.git
cd Shadowbroker
docker compose pull docker compose up -d
Abra `http://localhost:3000` para ver o painel.
> **Implantando publicamente ou em uma LAN?** Nenhuma configuração necessária para a maioria das configurações.
> O frontend faz proxy de todas as chamadas de API através do servidor Next.js para `BACKEND_URL`,
> que por padrão é `http://backend:8000` (rede interna do Docker).
> A porta `8000` do host é publicada apenas para acesso local de API/depuração (`127.0.0.1:8000`
> em `docker-compose.yml`). Se entrar em conflito com outro serviço, defina
> `BACKEND_PORT=8001` no `.env`; deixe `BACKEND_URL` como `http://backend:8000`
> porque essa é a porta interna do Docker.
>
> **Executando o backend fora do Docker** (`cd backend && python main.py`):
> o servidor de desenvolvimento vincula **apenas loopback** (`127.0.0.1:8000`) para que outras máquinas na
> sua LAN não possam acessar rotas de admin/confiança local com um `ADMIN_KEY` vazio. Defina
> `SHADOWBROKER_DEV_BIND_ALL=true` no `.env` apenas quando você deliberadamente precisar
> de `0.0.0.0` e use uma `ADMIN_KEY` forte para qualquer chamador não local.
> O limite de memória do backend é controlado por `BACKEND_MEMORY_LIMIT` e o padrão é
> `4G`. Se o Docker relatar eventos OOM, o backend será reiniciado e as
> camadas lentas podem parecer vazias até que sejam repovoadas.
>
> Se o seu backend estiver em um **host ou porta diferente**, defina `BACKEND_URL` em tempo de execução — nenhuma reconstrução necessária:
>
> ```bash
> # Linux / macOS
> BACKEND_URL=http://myserver.com:9096 docker compose up -d
>
> # Podman (via compose.sh wrapper)
> BACKEND_URL=http://192.168.1.50:9096 ./compose.sh up -d
>
> # Windows (PowerShell)
> $env:BACKEND_URL="http://myserver.com:9096"; docker compose up -d
>
> # Or add to a .env file next to docker-compose.yml:
> # BACKEND_URL=http://myserver.com:9096
> ```
**Usuários do Podman:** Não passe a URL do GitHub para `podman compose pull`; clone o repositório primeiro, `cd Shadowbroker`, depois execute o compose a partir dessa pasta. `podman compose` também requer um provedor de Compose. Se o Podman relatar `looking up compose provider failed`, instale um:```bash
# Linux / macOS / WSL
python3 -m pip install --user podman-compose
podman-compose pull
podman-compose up -d
Não é necessário clonar o repositório. Use as imagens pré-construídas do GitHub Container Registry. As imagens do registro GitLab podem ser usadas como espelho se você as publicar lá.
Crie um docker-compose.yml com o seguinte conteúdo e implante-o diretamente — cole no editor de stacks do Portainer, uncloud deploy ou qualquer host Docker:```yaml
services: backend: image: ghcr.io/bigbodycobain/shadowbroker-backend:latest # image: registry.gitlab.com/bigbodycobain/shadowbroker/backend:latest container_name: shadowbroker-backend ports: - "${BACKEND_PORT:-8000}:8000" environment: - AIS_API_KEY=your_aisstream_key # Required — get one free at aisstream.io - OPENSKY_CLIENT_ID= # Optional — higher flight data rate limits - OPENSKY_CLIENT_SECRET= # Optional — paired with Client ID above - LTA_ACCOUNT_KEY= # Optional — Singapore CCTV cameras - SHODAN_API_KEY= # Optional — Shodan device search overlay - SH_CLIENT_ID= # Optional — Sentinel Hub satellite imagery - SH_CLIENT_SECRET= # Optional — paired with Sentinel Hub ID - CORS_ORIGINS= # Optional — comma-separated allowed origins volumes: - backend_data:/app/data restart: unless-stopped
Todas as 41 camadas podem ser ativadas/desativadas independentemente pelo painel esquerdo:
A plataforma é otimizada para lidar com conjuntos de dados massivos em tempo real:
304 Not Modified ignoram análise JSON redundantesetData()Novos contribuidores podem usar docs/contributor-map.md para um guia de orientação mais curto.``` Shadowbroker/ ├── openclaw-skills/shadowbroker/ # OpenClaw skill — SKILL.md, sb_query.py client, alerts/monitor helpers ├── backend/ │ ├── main.py # FastAPI app, middleware, API routes (~4,000 lines) │ ├── cctv.db # SQLite CCTV camera database (auto-generated) │ ├── config/ │ │ └── news_feeds.json # User-customizable RSS feed list │ ├── services/ │ │ ├── data_fetcher.py # Core scheduler — orchestrates all data sources │ │ ├── ais_stream.py # AIS WebSocket client (25K+ vessels) │ │ ├── carrier_tracker.py # OSINT carrier position estimator (GDELT news scraping) │ │ ├── cctv_pipeline.py # 14-source CCTV camera ingestion pipeline │ │ ├── ssrf_guard.py # SSRF validation for operator recon fetches │ │ ├── sanctions/ofac.py # OpenSanctions OFAC SDN index │ │ ├── osint/lookups.py # Server-side recon lookups (Osiris port) │ │ ├── osint/openclaw_recon.py # OpenClaw dispatch for recon + entity_expand │ │ ├── osint_intel/resolve.py # Entity graph resolver (Wikidata + OFAC) │ │ ├── scm/suppliers.py # Supply-chain risk overlay │ │ ├── intel_feeds/ # Country risk index helpers │ │ ├── fetchers/malware.py # abuse.ch Feodo + URLhaus │ │ ├── fetchers/cyber_status.py # CISA KEV feed │ │ ├── fetchers/telegram_osint.py # Public Telegram channel scrape + geoparse │ │ ├── third_party/osiris/ # MIT attribution for Osiris-derived code │ │ ├── geopolitics.py # GDELT + Ukraine frontline + air alerts │ │ ├── region_dossier.py # Right-click country/city intelligence │ │ ├── radio_intercept.py # Police scanner feeds + OpenMHZ │ │ ├── kiwisdr_fetcher.py # KiwiSDR receiver scraper │ │ ├── sentinel_search.py # Sentinel-2 STAC imagery search │ │ ├── shodan_connector.py # Shodan device search connector │ │ ├── sigint_bridge.py # APRS-IS TCP bridge │ │ ├── network_utils.py # HTTP client with curl fallback │ │ ├── api_settings.py # API key management │ │ ├── news_feed_config.py # RSS feed config manager │ │ ├── fetchers/ │ │ │ ├── flights.py # OpenSky, adsb.lol, GPS jamming, holding patterns │ │ │ ├── geo.py # AIS vessels, carriers, GDELT, fishing activity │ │ │ ├── satellites.py # CelesTrak TLE + SGP4 propagation │ │ │ ├── earth_observation.py # Quakes, fires, volcanoes, air quality, weather │ │ │ ├── infrastructure.py # Data centers, power plants, military bases │ │ │ ├── trains.py # Amtrak + DigiTraffic European rail │ │ │ ├── sigint.py # SatNOGS, TinyGS, APRS, Meshtastic │ │ │ ├── meshtastic_map.py # Meshtastic MQTT + map node aggregation │ │ │ ├── military.py # Military aircraft classification │ │ │ ├── news.py # RSS intelligence feed aggregation │ │ │ ├── financial.py # Global markets data │ │ │ └── ukraine_alerts.py # Ukraine air raid alerts │ │ └── mesh/ # InfoNet / Wormhole protocol stack │ │ ├── mesh_protocol.py # Core mesh protocol + routing │ │ ├── mesh_crypto.py # Ed25519, X25519, AESGCM primitives │ │ ├── mesh_hashchain.py # Hash chain commitment system (~1,400 lines) │ │ ├── mesh_router.py # Multi-transport router (APRS, Meshtastic, WS) │ │ ├── mesh_wormhole_persona.py # Gate persona identity management │ │ ├── mesh_wormhole_dead_drop.py # Dead Drop token-based DM mailbox │ │ ├── mesh_wormhole_ratchet.py # Double-ratchet DM scaffolding │ │ ├── mesh_wormhole_gate_keys.py # Gate key management + rotation │ │ ├── mesh_wormhole_seal.py # Message sealing + unsealing │ │ ├── mesh_merkle.py # Merkle tree proofs for data commitment │ │ ├── mesh_reputation.py # Node reputation scoring │ │ ├── mesh_oracle.py # Oracle consensus protocol │ │ └── mesh_secure_storage.py # Secure credential storage │ ├── routers/ │ │ ├── osint.py # /api/osint/* recon routes (local operator) │ │ ├── entity_graph.py # /api/entity/expand │ │ ├── scm.py # /api/scm-suppliers │ │ └── intel_feeds.py # /api/malware, /api/cyber-threats, /api/telegram-feed, /api/country-risk ├── frontend/ │ ├── public/data/ │ │ └── submarine-cables.json # Static undersea cable GeoJSON │ ├── src/ │ │ ├── app/ │ │ │ └── page.tsx # Main dashboard — state, polling, layout │ │ └── components/ │ │ ├── MaplibreViewer.tsx # Core map — all GeoJSON layers │ │ ├── MeshChat.tsx # InfoNet / Mesh / Dead Drop chat panel │ │ ├── MeshTerminal.tsx # Draggable CLI terminal │ │ ├── NewsFeed.tsx # SIGINT feed + entity detail panels │ │ ├── WorldviewLeftPanel.tsx # Data layer toggles (40+ layers) │ │ ├── ShodanPanel.tsx # Shodan device search overlay │ │ ├── ReconPanel.tsx # Server-side OSINT recon toolkit │ │ ├── ScmPanel.tsx # Supply-chain risk command panel │ │ ├── EntityGraphPanel.tsx # Entity graph on map selection │ │ ├── MaplibreViewer/popups/TelegramOsintPopup.tsx # Threat-intercept styled Telegram pin popups │ │ ├── WorldviewRightPanel.tsx # Search + filter sidebar │ │ ├── AdvancedFilterModal.tsx # Airport/country/owner filtering │ │ ├── MapLegend.tsx # Dynamic legend with all icons │ │ ├── MarketsPanel.tsx # Global financial markets ticker │ │ ├── RadioInterceptPanel.tsx # Scanner-style radio panel │ │ ├── FindLocateBar.tsx # Search/locate bar │ │ ├── ChangelogModal.tsx # Version changelog popup (auto-shows on upgrade) │ │ ├── SettingsPanel.tsx # API Keys + News Feed + Shodan config │ │ ├── ScaleBar.tsx # Map scale indicator │ │ └── ErrorBoundary.tsx # Crash recovery wrapper │ └── package.json
ShadowBroker é construído em público. Estas pessoas enviaram código real:
Esta ferramenta é construída inteiramente com base em dados de inteligência de código aberto (OSINT) disponíveis publicamente. Nenhum dado classificado, restrito ou não público é utilizado. As posições das operadoras são estimativas baseadas em relatórios públicos. A interface de usuário com tema militar é puramente estética.
Este projeto é para fins educacionais e de pesquisa pessoal. Consulte os termos de serviço individuais dos provedores de API para restrições de uso de dados.
Construído com ☕ e chamadas de API demais
t.me/s (OSINTdefender, NEXTA, etc.) raspados a cada hora, classificados por risco, geoparsados para âncoras metropolitanas, e plotados como pins de mapa clicáveis com mídia inline| Canal | Status de Privacidade | Detalhes |
|---|
| Meshtastic / APRS | PÚBLICO | As transmissões de rádio RF são públicas e interceptáveis por design. |
| InfoNet Gate Chat | OFUSCADO | As mensagens são ofuscadas com personas de gate e assinatura de payload canônica, mas NÃO criptografadas ponta a ponta. Metadados não estão ocultos, apesar de serem roteados através de Tor e Reticulum (Trabalho em andamento). |
| Dead Drop DMs | CANAL MAIS FORTE ATUAL | Caixa postal baseada em token com verificação de palavras SAS. Canal mais forte nesta versão, mas ainda não confiantemente privado. |
| Governança Shell Soberano | LEDGER PÚBLICO | Petições, votos, hashes de atualização e apostas em disputas são eventos assinados em uma hashchain pública. Pseudônimo via persona de gate, mas as ações de governança são intencionalmente observáveis. |
| Primitivas de privacidade (RingCT / stealth / DEX) | AINDA NÃO CONECTADAS | Contratos de Protocolo Bloqueado estão em vigor, mas o esquema criptográfico não foi escolhido. O crate Rust de núcleo de privacidade é o alvo de integração para um sprint futuro. |
Não transmita nada sensível em nenhum canal. Trate todos os canais como abertos e públicos por enquanto. A criptografia ponta a ponta e o endurecimento nativo/Tauri mais profundo são os próximos marcos. Se você bifurcar este projeto, mantenha estes rótulos intactos e não faça alegações de privacidade mais fortes do que a implementação suporta.
Para uma imagem completa do que a malha realmente defende e do que não defende, leia o modelo de ameaças e a reconciliação de alegações. Cada frase acima está mapeada para o caminho de código que a aplica (ou não).
UPDATE_PARAM, BATCH_UPDATE_PARAMS, ENABLE_FEATURE e DISABLE_FEATURE. Parâmetros ajustáveis mudam por voto — sem necessidade de implantações de código.repr() do Python, para que os hashes transitem limpos pela cadeia.MappingProxyType.Pista de primitivas de privacidade (NOVO na v0.9.7):
services/infonet/privacy/contracts.py para assinaturas em anel, endereços stealth, compromissos Pedersen, provas de intervalo e correspondência DEX. O crate Rust privacy-core é o alvo de integração — nenhum chamador do módulo de privacidade precisa saber qual esquema está ativo.Testnet Experimental — Sem Garantia de Privacidade: As mensagens do InfoNet são ofuscadas, mas NÃO criptografadas ponta a ponta. A rede Mesh (Meshtastic/APRS) NÃO é privada — as transmissões de rádio são inerentemente públicas. Os contratos de primitivas de privacidade estão esboçados, mas ainda não conectados. Não envie nada sensível em nenhum canal. Trate todos os canais como abertos e públicos por enquanto.
Adaptado da pilha de reconhecimento OSIRIS (MIT) com o modelo de proxy do ShadowBroker. Atribuição: backend/third_party/osiris/NOTICE.md.
Toolkit de Reconhecimento (barra lateral esquerda — apenas operador local):
us_ofac_sdn (CC-BY); verificação cruzada em entidades WHOIS e strings ISP/org de IP/api/osint/sweep/scan geolocaliza um alvo /24–/32 e faz proxy da descoberta de host Shodan InternetDB no servidor (navegador nunca entra em contato com o InternetDB diretamente)Grafo de entidades — Selecione qualquer entidade do mapa para abrir o painel Grafo de Entidades (GET /api/entity/expand). Resolve aeronaves, embarcações, empresas, pessoas, IPs e países em um grafo nó/ligação (Wikidata SPARQL + OFAC + armazenamento em memória de voos/navios).
OpenClaw / acesso de agente — Os mesmos backends de reconhecimento estão disponíveis no canal de comando HMAC (sem gate de operador local do navegador): osint_lookup (IP/DNS/WHOIS/certificados/BGP/sanções/CVE/MAC/GitHub/vazamentos/ameaças passivo), entity_expand (grafo de relacionamentos) e osint_sweep (varredura de sub-rede ativa — apenas nível de acesso total). Chame osint_tools para listar os tipos de consulta suportados. Pacote de habilidade: openclaw-skills/shadowbroker/ (SKILL.md + sb_query.py).
Sobreposição Shodan (inalterado):
sar_pin_click) e mover o mapa do operador para qualquer centro de AOI (sar_focus_aoi) — permitindo fluxos de trabalho analíticos colaborativos.frontend/public/data/submarine-cables.json). Sobreposição de linha opcional./api/cyber-threats e o alternador de camada./api/country-risk.t.me/s/*) de feeds configuráveis de guerra/OSINT. Mesclagem incremental horária (sem re-raspagem redundante), pontuação de risco por palavra-chave, aliases de lugares em cirílico/árabe, geocodificação metro-âncora (separada dos centroides de notícias), foto/vídeo inline via proxy /api/telegram/media. Chave da camada: telegram_osint.Gaza
O ShadowBroker expõe um canal de comando de IA agêntica bidirecional — uma ponte assinada e com acesso por níveis que dá a qualquer agente de IA compatível acesso total de leitura/escrita à plataforma de inteligência. O OpenClaw é o agente de referência, mas o canal é um protocolo aberto: qualquer agente baseado em LLM que assine solicitações com HMAC-SHA256 (Claude Code, GPT, LangChain, clientes Python/TypeScript personalizados ou sua própria integração) pode conectar-se como um analista que vê os mesmos dados que o operador e pode tomar ações no mapa. O ShadowBroker não inclui um LLM, um runtime de agente ou pesos de modelo — ele fornece a superfície; você traz o agente.
A v0.9.7 transforma o ShadowBroker de um painel que um humano observa para uma superfície de inteligência na qual qualquer agente pode atuar.
Transporte do canal (NOVO na v0.9.7):
POST /api/ai/channel/command aceita {cmd, args} e despacha para qualquer ferramenta registrada.POST /api/ai/channel/batch aceita até 20 comandos em uma solicitação. O backend os executa concorrentemente e retorna um mapa de resultados. Reduz a latência do agente em uma ordem de grandeza em comparação com chamadas sequenciais.OPENCLAW_ACCESS_TIER controla quais comandos o agente pode chamar: restricted expõe o conjunto somente leitura, full adiciona gravações e injeção. O endpoint de descoberta retorna available_commands para que o agente possa inspecionar suas próprias capacidades.HMAC-SHA256(secret, METHOD|path|timestamp|nonce|sha256(body)) com proteção contra repetição de timestamp + nonce e integridade da solicitação. Suporta modo local (sem configuração) e modo remoto (agente em uma máquina diferente / VPS).Capacidades:
get_summary → get_layer_slice com since_layer_versions por camada (o push SSE layer_changed informa ao agente exatamente quais camadas foram atualizadas). search_telemetry é o índice de palavras-chave entre camadas no estilo Google. search_news cobre notícias, GDELT, CrowdThreat, LiveUAMap, linhas de frente e postagens do Telegram. entities_near, brief_area, find_flights/find_ships/find_entity e correlate_entity respondem a perguntas direcionadas sem puxar megabytes.osint_lookup executa os mesmos backends protegidos por SSRF que o painel Recon (ip, dns, whois, certs, bgp, sanctions, cve, mac, github, leaks, threats, sweep_init). entity_expand constrói gráficos de relacionamento Wikidata + OFAC. osint_sweep executa descoberta de sub-rede Shodan InternetDB (nível ). Aliases de camada: , /, //, /, /.Conecte um agente: Abra o painel AI Intel na barra lateral esquerda, clique em Connect Agent e copie o segredo HMAC. A partir daí, aponte qualquer agente compatível para o canal — para o OpenClaw, importe ShadowBrokerClient de openclaw-skills/shadowbroker/sb_query.py (veja SKILL.md para exemplos); para qualquer outro agente, use o mesmo contrato HMAC documentado acima (timestamp + nonce + body digest, acesso por nível). Descoberta: GET /api/ai/tools e GET /api/ai/capabilities. O canal é o protocolo, não o agente.
Docker Compose + agentes remotos: A interface do painel se comunica com o backend pela ponte privada do Docker (confiado automaticamente). Um agente OpenClaw rodando no host (fora do contêiner) acessa http://localhost:8000 a partir do IP do gateway Docker — HMAC é necessário lá. Em AI Intel → Connect Agent, clique em Bootstrap depois Reveal, copie SHADOWBROKER_HMAC_SECRET para o env do seu agente e reinicie o backend uma vez para que data/openclaw.env no volume backend_data seja carregado. Teste com:
curl -s -H "Authorization: Bearer $SHADOWBROKER_HMAC_SECRET" \
http://localhost:8000/api/ai/tools | jq .
— Certifique-se de que o agente pode GET /api/ai/tools antes de esperar que funcione.```bash
export SHADOWBROKER_URL=http://127.0.0.1:8000
export SHADOWBROKER_HMAC_SECRET=
python openclaw-skills/shadowbroker/verify_hmac.py
Use a porta do backend (`:8000`), não a porta do dashboard Next.js (`:3000`). Signers feitos à mão devem fazer hash dos bytes exatos do POST: `json.dumps(payload, separators=(",", ":"), sort_keys=True)`.
### ⏱️ Time Machine — Reprodução de Snapshots (NOVO na v0.9.7)
Um transporte no estilo de mídia para todo o feed de telemetria. Trate o mapa ao vivo como uma gravação que pode ser avançada, pausada e reproduzida.
* **Alternância Ao Vivo ↔ Snapshot** — Mudar para o modo snapshot pausa o loop de polling global instantaneamente; voltar para Ao Vivo invalida ETags e força a atualização tanto das camadas rápidas quanto lentas, para que o dashboard se atualize sem oscilação de quadros obsoletos.
* **Índice Horário** — Cada snapshot capturado é indexado por seu bucket de hora com `count`, `latest_id`, `latest_ts` e a lista completa `snapshot_ids`. Pule para qualquer timestamp capturado diretamente do seletor de linha do tempo.
* **Interpolação de Quadros** — Entidades em movimento (aeronaves, navios, satélites, voos militares) interpolam suavemente entre os quadros gravados durante a reprodução, de modo que o movimento permaneça contínuo mesmo quando os snapshots são esparsos.
* **Velocidade de Reprodução Variável** — Avance, reproduza, acelere e retroceda pela telemetria salva em velocidade ajustável.
* **Ciente do Perfil** — Cada snapshot registra o perfil de privacidade que estava ativo quando foi capturado, de modo que a reprodução seja fiel ao que um operador naquele perfil teria visto.
* **Lado do Operador, Não do Servidor** — Os snapshots são armazenados localmente no backend; nenhum terceiro vê a linha do tempo da reprodução.
### 📦 Painel de Chaves de API — Primeiro o Caminho, Somente Leitura (NOVO na v0.9.7)
Configurações → Chaves de API agora é um registro somente leitura. Os valores das chaves nunca chegam ao processo do navegador — nem mesmo um prefixo ofuscado. O painel exibe:
* O caminho absoluto para o arquivo `.env` do backend conforme resolvido por `Path(__file__).resolve()` — funciona em todos os sistemas operacionais, unidades, locais de instalação (Linux `/home/...`, macOS `/Users/...`, Windows em qualquer unidade, contêineres Docker, VMs na nuvem).
* Indicadores `[existe]` / `[será criado no primeiro salvamento]` / `[NÃO GRAVÁVEL — edite manualmente]` no próprio caminho.
* O caminho para o template `.env.example` para que os usuários possam copiá-lo e preencher suas chaves.
* Um badge binário `CONFIGURED` / `NOT CONFIGURED` por chave, mais uma linha env copiável (ex.: `OPENSKY_CLIENT_ID=YOUR_VALUE`) que o usuário pode inserir no arquivo manualmente.
As credenciais da API OpenSky agora são um requisito de ambiente **critical-warn**: a verificação de ambiente na inicialização sinaliza credenciais OAuth2 do OpenSky ausentes com um aviso forte, e o modal de changelog linka diretamente para a página de registro gratuito. Sem elas, a camada de voos recai para cobertura apenas ADS-B com lacunas significativas na África, Ásia e América Latina.
</details>
---
<details>
<summary>🏗️ Arquitetura</summary>
ShadowBroker v0.9.7 é composto por três planos empilhados verticalmente — a **Operator UI**, o **Backend Service Plane** e a **Decentralized Layer (InfoNet)** — mais duas pontes transversais (a **Time Machine** e o **Agentic AI Channel**, que é o protocolo pelo qual o OpenClaw e qualquer outro agente compatível se conecta) e um crate Rust do **Privacy Core** que sustenta tanto a mesh legada quanto o futuro trabalho de moeda blindada / DEX.```
╔═════════════════════════════════════════════════════════════════════════════╗
║ OPERATOR UI (Next.js + MapLibre) ║
║ ║
║ ┌────────────────┐ ┌──────────┐ ┌────────────────┐ ┌────────────────┐ ║
║ │ MapLibre GL │ │ NewsFeed │ │ Sovereign Shell│ │ Mesh Chat │ ║
║ │ WebGL render │ │ SIGINT │ │ Petitions / │ │ + Mesh Term. │ ║
║ │ + clusters │ │ GDELT │ │ Upgrades / │ │ (Infonet / │ ║
║ │ │ │ Threat │ │ Disputes / │ │ Mesh / │ ║
║ │ │ │ │ │ Gates / │ │ Dead Drop) │ ║
║ │ │ │ │ │ Bootstrap / │ │ │ ║
║ │ │ │ │ │ Function Keys │ │ │ ║
║ └──────┬─────────┘ └────┬─────┘ └────────┬───────┘ └────────┬───────┘ ║
║ │ │ │ │ ║
║ ┌──────┴─────────────────┴─────────────────┴───────────────────┴───────┐ ║
║ │ Time Machine ◀── snapshot playback ── snapshotMode toggle ──▶ Live │ ║
║ │ hourly index │ frame interpolation │ profile-aware │ per-tier ETag │ ║
║ └──────────────────────────────────┬───────────────────────────────────┘ ║
║ │ REST + /api/[...path] proxy ║
╠═════════════════════════════════════╪═══════════════════════════════════════╣
║ BACKEND SERVICE PLANE (FastAPI) ║
║ │ ║
║ ┌──────────────────────────────────┴────────────────────────────────────┐ ║
║ │ Data Fetcher (APScheduler — fast / slow tiers) │ ║
║ │ │ ║
║ │ ┌───────────┬───────────┬───────────┬───────────┬───────────┐ │ ║
║ │ │ OpenSky* │ adsb.lol │ CelesTrak │ USGS │ AIS WS │ │ ║
║ │ │ Flights │ Military │ Sats │ Quakes │ Ships │ │ ║
║ │ ├───────────┼───────────┼───────────┼───────────┼───────────┤ │ ║
║ │ │ Carrier │ GDELT │ CCTV (12) │ DeepState │ NASA │ │ ║
║ │ │ Tracker │ Conflict │ Cameras │ Frontline │ FIRMS │ │ ║
║ │ ├───────────┼───────────┼───────────┼───────────┼───────────┤ │ ║
║ │ │ GPS │ KiwiSDR │ Shodan │ Amtrak │ SatNOGS │ │ ║
║ │ │ Jamming │ Radios │ Devices │ DigiTraf │ TinyGS │ │ ║
║ │ ├───────────┼───────────┼───────────┼───────────┼───────────┤ │ ║
║ │ │ Volcanoes │ Weather │ Fishing │ Mil Bases │ IODA │ │ ║
║ │ │ Air Qual │ Alerts │ Activity │ PwrPlants │ Outages │ │ ║
║ │ ├───────────┼───────────┼───────────┼───────────┼───────────┤ │ ║
║ │ │ Sentinel │ MODIS │ VIIRS │ Data │ Meshtastic│ │ ║
║ │ │ Hub/STAC │ Terra │ Nightlts │ Centers │ APRS │ │ ║
║ │ ├───────────┴───────────┴───────────┴───────────┴───────────┤ │ ║
║ │ │ SAR (NEW v0.9.7) │ │ ║
║ │ │ Mode A: ASF Search catalog (free, no account) │ │ ║
║ │ │ Mode B: NASA OPERA / Copernicus EGMS / GFM / EMS / │ │ ║
║ │ │ UNOSAT ground-change anomalies (opt-in) │ │ ║
║ │ └───────────────────────────────────────────────────────────┘ │ ║
║ │ * OpenSky: REQUIRED for global flight coverage │ ║
║ └───────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ┌──────────────────────────────────┴────────────────────────────────────┐ ║
║ │ Snapshot Store (Time Machine source) │ ║
║ │ Hourly index │ per-snapshot layer manifest │ profile metadata │ ║
║ └───────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ ┌───────────────────────────────────────────────────────────────────────┐ ║
║ │ Agentic AI Channel (HMAC-SHA256, tier-gated — OpenClaw + others) │ ║
║ │ │ ║
║ │ POST /api/ai/channel/command → one tool call │ ║
║ │ POST /api/ai/channel/batch → up to 20 concurrent tool calls │ ║
║ │ │ ║
║ │ Tier: restricted (read-only) │ full (read + write + inject) │ ║
║ │ Auth: X-SB-Timestamp + X-SB-Nonce + X-SB-Signature │ ║
║ │ Sig = HMAC-SHA256(secret, METHOD|path|ts|nonce|sha256(body)) │ ║
║ └───────────────────────────────────────────────────────────────────────┘ ║
╠═════════════════════════════════════════════════════════════════════════════╣
║ DECENTRALIZED LAYER (InfoNet Testnet — signed events) ║
║ ║
║ ┌────────────────────────────┐ ┌──────────────────────────────────┐ ║
║ │ Mesh Hashchain │ │ Sovereign Shell Governance │ ║
║ │ │ │ │ ║
║ │ Ed25519 signed events │ │ Petitions (DSL: UPDATE_PARAM, │ ║
║ │ Public-key binding │ │ ENABLE_FEATURE …) │ ║
║ │ Replay / sequence guard │ │ Upgrade-Hash voting (80% / 40% │ ║
║ │ Two-tier finality │ │ quorum / 67% Heavy) │ ║
║ │ ├ Tier 1 (CRDT, fast) │ │ Resolution & Dispute markets │ ║
║ │ └ Tier 2 (epoch finality)│ │ Gate suspend / shutdown / appeal│ ║
║ │ Identity rotation │ │ Bootstrap eligible-node-1-vote │ ║
║ │ Constitutional invariants │ │ (Argon2id PoW, Heavy-Node only)│ ║
║ │ (MappingProxyType) │ │ Function Keys (5 of 6 pieces) │ ║
║ └─────────────┬──────────────┘ └─────────────┬────────────────────┘ ║
║ │ │ ║
║ └──────────────┬──────────────────┘ ║
║ │ ║
║ ┌────────────────────────────┴──────────────────────────────────────┐ ║
║ │ Wormhole / InfoNet Relay (transport layer) │ ║
║ │ Gate personas │ canonical signing │ Dead Drop epoch mailboxes │ ║
║ └───────────────────────────────────────────────────────────────────┘ ║
╠═════════════════════════════════════════════════════════════════════════════╣
║ PRIVACY CORE (Rust crate — locked Protocol contracts) ║
║ ║
║ privacy-core/ ─► Argon2id │ Ed25519/X25519 │ AESGCM │ HKDF ║
║ Ring sigs* │ Stealth addrs* │ Pedersen* │ Bulletproofs*║
║ Blind-sig issuance* (RSA / BBS+ / U-Prove / Idemix) ║
║ ║
║ * = locked Protocol contract; cryptographic primitive lands Sprint 11+ ║
╚═════════════════════════════════════════════════════════════════════════════╝
Distribution
────────────
GitHub (primary): ghcr.io/bigbodycobain/shadowbroker-{backend,frontend}
GitLab (mirror): registry.gitlab.com/bigbodycobain/shadowbroker/{backend,frontend}
Multi-arch: linux/amd64 + linux/arm64 (Raspberry Pi 5 supported)
Desktop: Tauri shell → packaged backend-runtime + Next.js frontend
| Fonte | Dados | Frequência de Atualização | Chave de API Necessária |
|---|
| OpenSky Network | Voos comerciais e privados | ~60s | Sim |
| adsb.lol | Aeronaves militares | ~60s | Não |
| aisstream.io | Posições de embarcações AIS | WebSocket em tempo real | Sim |
| CelesTrak | Posições orbitais de satélites (TLE + SGP4) | ~60s | Não |
| USGS Earthquake | Eventos sísmicos globais | ~60s | Não |
| GDELT Project | Eventos de conflito globais | ~6h | Não |
| DeepState Map | Linha de frente da Ucrânia | ~30min | Não |
| Shodan | Pesquisa de dispositivos conectados à internet | Sob demanda | Sim |
| OpenSanctions | Índice de sanções OFAC SDN (recon + grafo de entidades) | Cache de 24h | Não |
| abuse.ch Feodo + URLhaus | URLs de C2/distribuição de malware | ~5min (camada opt-in) | Não |
| CISA KEV | CVEs conhecidas e exploradas | ~5min (camada opt-in) | Não |
| ip-api.com | Geolocalização de IP (recon, grafo de entidades) | Sob demanda | Não |
| Google Public DNS | Consultas DNS-over-HTTPS (recon) | Sob demanda | Não |
| RDAP.org | Dados de registro de domínio (recon) | Sob demanda | Não |
| crt.sh | Transparência de certificados (recon) | Sob demanda | Não |
| bgpview.io | Roteamento BGP/ASN (recon) | Sob demanda | Não |
| TeleGeography (estático) | Rotas de cabos submarinos | Estático | Não |
| ASFINAG | Câmeras de rodovias da Áustria | ~10min | Não |
| Amtrak | Posições de trens nos EUA | ~60s | Não |
| DigiTraffic | Posições de trens europeus | ~60s | Não |
| Global Fishing Watch | Eventos de atividade de embarcações pesqueiras | ~1h | Sim (GFW_API_TOKEN) |
| Telegram public previews | Postagens de canais de guerra/OSINT (telegram_osint) | ~1h | Não (opcional TELEGRAM_OSINT_CHANNELS) |
| Transport for London, NYC DOT, TxDOT | Câmeras CCTV (Reino Unido, EUA) | ~10min | Não |
| Caltrans, WSDOT, GDOT, IDOT, MDOT | Câmeras CCTV (5 estados dos EUA) | ~10min | Não |
| Spain DGT, Madrid City | Câmeras CCTV (Espanha) | ~10min | Não |
| Singapore LTA | Câmeras de tráfego de Singapura | ~10min | Sim |
| Windy Webcams | Webcams globais | ~10min | Não |
| SatNOGS | Estações terrestres amadoras de satélites | ~30min | Não |
| TinyGS | Estações terrestres amadoras de satélite LoRa | ~30min | Não |
| Meshtastic MQTT | Posições de nós de rádio mesh | Em tempo real | Não |
| APRS-IS | Posições de rádio amador | TCP em tempo real | Não |
| KiwiSDR | Localizações de SDR públicas | ~30min | Não |
| OpenMHZ | Feeds de rádio policial/incêndio | Em tempo real | Não |
| Smithsonian GVP | Vulcões do Holoceno em todo o mundo | Estático (cache) | Não |
| OpenAQ | Estações de qualidade do ar PM2.5 | ~120s | Não |
| NOAA / NWS | Alertas meteorológicos severos e polígonos | ~120s | Não |
| WRI Global Power Plant DB | Mais de 35.000 usinas elétricas | Estático (cache) | Não |
| Conjuntos de dados de bases militares | Instalações militares globais | Estático (cache) | Não |
| NASA FIRMS | Pontos quentes de incêndio/termais NOAA-20 VIIRS | ~120s | Não |
| NOAA SWPC | Índice Kp de clima espacial e eventos solares | ~120s | Não |
| IODA (Georgia Tech) | Alertas regionais de queda de internet | ~120s | Não |
| DC Map (GitHub) | Localizações globais de datacenters | Estático (cache de 7 dias) | Não |
| NASA GIBS | Imagens diárias de satélite MODIS Terra | Diário (atraso de 24-48h) | Não |
| Esri World Imagery | Mapa base de satélite de alta resolução | Estático (atualizado periodicamente) | Não |
| MS Planetary Computer | Cenas Sentinel-2 L2A (clique direito) | Sob demanda | Não |
| Copernicus CDSE | Imagens do Sentinel Hub (API Process) | Sob demanda | Sim (gratuito) |
| VIIRS Nightlights | Detecção de mudanças na luz noturna | Estático | Não |
| RestCountries | Dados de perfil de país | Sob demanda (cache de 24h) | Não |
| Wikidata SPARQL | Dados de chefe de estado | Sob demanda (cache de 24h) | Não |
| Wikipedia API | Resumos de localização e imagens de aeronaves | Sob demanda (cache) | Não |
| OSM Nominatim | Geocodificação de nomes de lugares (barra LOCATE) | Sob demanda | Não |
| CARTO Basemaps | Tiles de mapa escuro | Contínuo | Não |
Privacidade e auditoria de saída (#348–#366): Cada instalação auto-hospedada usa seu próprio IP de backend e identificador User-Agent por instalação. Consulte docs/OUTBOUND_DATA.md para saber o que contata terceiros, controles de adesão/env e compensações aceitas (CCTV Referer, CDN de basemap, LiveUAMap, etc.).
Please provide the Markdown content to translate.```powershell
py -m pip install --user podman-compose podman-compose pull podman-compose up -d
Se você estiver em um shell compatível com bash, o wrapper incluído pode detectar automaticamente o Docker ou o Podman:```bash
./compose.sh --engine podman pull
./compose.sh --engine podman up -d
frontend: image: ghcr.io/bigbodycobain/shadowbroker-frontend:latest # image: registry.gitlab.com/bigbodycobain/shadowbroker/frontend:latest container_name: shadowbroker-frontend ports: - "3000:3000" environment: - BACKEND_URL=http://backend:8000 # Docker internal networking — no rebuild needed depends_on: - backend restart: unless-stopped
volumes: backend_data:
> **Como funciona:** O contêiner frontend faz proxy de todas as requisições `/api/*` através do servidor Next.js para `BACKEND_URL` usando a rede interna do Docker. O navegador se comunica apenas com a porta 3000. A porta host do backend é para acesso local de API/depuração e pode ser alterada com `BACKEND_PORT=8001` sem alterar `BACKEND_URL`.
>
> `BACKEND_URL` é uma variável de ambiente de tempo de execução comum (não é uma `NEXT_PUBLIC_*` de tempo de compilação), então você pode alterá-la no Portainer, Uncloud ou qualquer editor de compose sem reconstruir a imagem. Defina-a para o endereço onde seu backend está acessível de dentro da rede Docker (ex.: `http://backend:8000`, `http://192.168.1.50:8000`).
</details>
---
<details>
<summary>📦 Início Rápido (Sem Necessidade de Código)</summary>
Se você só quer executar o dashboard sem lidar com comandos de terminal:
1. Vá até a guia **[Releases](https://raw.githubusercontent.com/bigbodycobain/releases)** no lado direito da página deste repositório.
2. Baixe o arquivo `.zip` mais recente da release.
3. Extraia a pasta para o seu computador.
4. **Windows:** Clique duas vezes em `start.bat`.
**Mac/Linux:** Abra o terminal, digite `chmod +x start.sh`, `dos2unix start.sh` e execute `./start.sh`.
5. Ele instalará tudo automaticamente e iniciará o dashboard!
Notas sobre o laçador local:
- `start.bat` / `start.sh` executam o aplicativo sem Docker — eles instalam dependências e iniciam ambos os servidores diretamente.
- Se os endpoints de identidade do Wormhole ou de contato DM falharem após uma atualização, verifique a pasta `docs/mesh/` para solução de problemas.
- Para implantação de testemunha raiz DM, transparência e monitoramento de operador, comece com `docs/mesh/wormhole-dm-root-operations-runbook.md`.
- Para exemplos de ativos de ponte de operações raiz DM, veja também `scripts/mesh/poll-dm-root-health-alerts.mjs`, `scripts/mesh/export-dm-root-health-prometheus.mjs`, `scripts/mesh/publish-external-root-witness-package.mjs`, `scripts/mesh/smoke-external-root-witness-flow.mjs`, `scripts/mesh/smoke-root-transparency-publication-flow.mjs`, `scripts/mesh/smoke-dm-root-deployment-flow.mjs`, `scripts/mesh/sync-dm-root-external-assurance.mjs` e `docs/mesh/examples/`.
</details>
---
<details>
<summary>💻 Configuração do Desenvolvedor</summary>
Se você quiser modificar o código ou executar a partir da fonte:
#### Pré-requisitos
* **Node.js** 18+ e **npm** — [nodejs.org](https://nodejs.org/)
* **Python** 3.10, 3.11 ou 3.12 com `pip` — [python.org](https://www.python.org/downloads/) (**marque "Add to PATH"** durante a instalação)
* ⚠️ Python 3.13+ pode ter problemas de compatibilidade com algumas dependências. **Recomenda-se 3.11 ou 3.12.**
* Chaves de API para: `aisstream.io` (obrigatório) e opcionalmente `opensky-network.org` (OAuth2), `lta.gov.sg`
### Instalação
</details>```bash
# Clone the repository
git clone https://github.com/BigBodyCobain/Shadowbroker.git
cd Shadowbroker
# Backend setup
cd backend
python -m venv venv
venv\Scripts\activate # Windows
# source venv/bin/activate # macOS/Linux
pip install .
# Optional helper scripts (creates venv + installs dev deps)
# Windows PowerShell
# .\backend\scripts\setup-venv.ps1
# macOS/Linux
# ./backend/scripts/setup-venv.sh
# Optional env check (prints warnings for missing keys)
# Windows PowerShell
# .\backend\scripts\check-env.ps1
# macOS/Linux
# ./backend/scripts/check-env.sh
# Create .env with your API keys
echo "AIS_API_KEY=your_aisstream_key" >> .env
echo "OPENSKY_CLIENT_ID=your_opensky_client_id" >> .env
echo "OPENSKY_CLIENT_SECRET=your_opensky_secret" >> .env
# Frontend setup
cd ../frontend
npm ci
npm run dev
* **Next.js** frontend em `http://localhost:3000`
* **FastAPI** backend em `http://localhost:8000`
### Pre-commit (Opcional)
Se você usa pre-commit, instale os hooks uma vez a partir da raiz do repositório:```bash
pre-commit install
Você pode alimentar seus próprios dados de navios AIS no ShadowBroker usando um dongle RTL-SDR e o AIS-catcher, um decodificador AIS de código aberto. Isso fornece cobertura em tempo real de embarcações na sua área local — sem necessidade de chave de API.
AIS-catcher decodifica sinais de rádio VHF em 161.975 MHz e 162.025 MHz e envia via POST os dados decodificados das embarcações para o ShadowBroker a cada 10 segundos. Navios detectados pela sua antena SDR aparecem junto com o fluxo global de AIS.
Docker (ARM/Raspberry Pi): Veja docker-shipfeeder para uma imagem Docker pronta para produção otimizada para ARM.
Nota: O alcance do AIS depende da sua antena — normalmente 20-40 milhas náuticas com uma configuração básica, 60+ nm com uma antena VHF marítima em elevação.
| Camada | Padrão | Descrição |
|---|
| Voos Comerciais | ✅ LIGADO | Companhias aéreas, carga, aeronaves de aviação geral |
| Voos Privados | ✅ LIGADO | Aeronaves privadas não comerciais |
| Jatos Particulares | ✅ LIGADO | Bizjets de alto valor com dados do proprietário |
| Voos Militares | ✅ LIGADO | Aeronaves militares e governamentais |
| Aeronaves Rastreadas | ✅ LIGADO | Lista de vigilância de interesse especial |
| Interferência GPS | ✅ LIGADO | Zonas de degradação NAC-P |
| Porta-aviões / Mil / Carga | ✅ LIGADO | Porta-aviões, navios de carga, petroleiros |
| Embarcações Civis | ✅ LIGADO | Iates, pesca, recreio |
| Cruzeiros / Passageiros | ✅ LIGADO | Navios de cruzeiro e ferries |
| Iates Rastreados | ✅ LIGADO | Superiates de bilionários e oligarcas |
| Atividade Pesqueira | ✅ LIGADO | Eventos de embarcações do Global Fishing Watch |
| Trens | ✅ LIGADO | Posições ferroviárias da Amtrak + Europa |
| Satélites | ✅ LIGADO | Ativos orbitais por tipo de missão |
| SatNOGS | ✅ LIGADO | Estações terrestres de satélite amadoras |
| TinyGS | ✅ LIGADO | Estações terrestres de satélite LoRa |
| Terremotos (24h) | ✅ LIGADO | Eventos sísmicos do USGS |
| Pontos de Incêndio (24h) | ✅ LIGADO | Anomalias térmicas VIIRS da NASA FIRMS |
| Vulcões | ✅ LIGADO | Vulcões do Holoceno do Smithsonian |
| Alertas Meteorológicos | ✅ LIGADO | Polígonos de clima severo |
| Qualidade do Ar (PM2.5) | ✅ LIGADO | Estações OpenAQ em todo o mundo |
| Linha de Frente Ucrânia | ✅ LIGADO | Posições ao vivo da frente de guerra |
| Alertas Aéreos Ucrânia | ✅ LIGADO | Alertas regionais de ataque aéreo |
| Incidentes Globais | ✅ LIGADO | Eventos de conflito GDELT |
| Malha CCTV | ✅ LIGADO | Mais de 11.000 câmeras em 13 fontes, 6 países |
| Quedas de Internet | ✅ LIGADO | Alertas regionais de conectividade IODA |
| Data Centers | ✅ LIGADO | Localizações globais de data centers (mais de 2.000) |
| Bases Militares | ✅ LIGADO | Instalações militares globais |
| Receptores KiwiSDR | ✅ LIGADO | Receptores de rádio SDR públicos |
| Nós Meshtastic | ✅ LIGADO | Posições de nós de rádio mesh |
| APRS | ✅ LIGADO | Posicionamento de rádio amador |
| Scanners | ✅ LIGADO | Feeds de scanners policiais/bombeiros |
| Ciclo Dia / Noite | ✅ LIGADO | Sobreposição do terminador solar |
| MODIS Terra (Diário) | ❌ DESLIGADO | Imagens de satélite diárias da NASA GIBS |
| Satélite de Alta Resolução | ❌ DESLIGADO | Imagens de satélite submétricas da Esri |
| Sentinel Hub | ❌ DESLIGADO | API de Processo Copernicus CDSE |
| Luzes Noturnas VIIRS | ❌ DESLIGADO | Detecção de mudanças de luz noturna |
| Usinas de Energia | ❌ DESLIGADO | Mais de 35.000 usinas de energia globais |
| Sobreposição Shodan | ❌ DESLIGADO | Resultados de pesquisa de dispositivos na Internet |
| Tendências de Carga Rodoviária | ❌ DESLIGADO | Tendências de movimento de caminhões Sentinel-2 em rodovias principais (Analise Aqui) |
| Cabos Submarinos | ❌ DESLIGADO | Rotas globais de cabos submarinos (GeoJSON estático) |
| Malware C2 | ❌ DESLIGADO | Pontos de ameaça abuse.ch Feodo + URLhaus |
| Fornecedores SCM | ❌ DESLIGADO | Marcadores de risco de cadeia de suprimentos Tier 1/2 + alertas de painel |
| Ameaças Cibernéticas | ❌ DESLIGADO | Entradas recentes do CISA KEV (estatísticas no payload de nível lento) |
| OSINT Telegram | ✅ LIGADO | Canais públicos de guerra/OSINT do Telegram — raspagem horária, pinos geoparsed |
| SAR | ✅ LIGADO | Catálogo de radar de abertura sintética + alertas de anomalia |
Ferramentas de reconhecimento e entidade (não são camadas do mapa — painel esquerdo / seleção):
| Ferramenta | Acesso ao painel | Comando OpenClaw | Descrição |
|---|---|---|---|
| Recon Toolkit | Operador local (/api/osint/*) | osint_lookup, osint_sweep† | IP, DNS, WHOIS, certificados, BGP, sanções, CVE, MAC, GitHub, vazamentos, ameaças, varredura de sub-rede |
| Entity Graph | Operador local (/api/entity/expand) | entity_expand | Wikidata + OFAC + gráfico de relacionamento de armazenamento ativo |
| Painel de Risco SCM | Operador local (/api/scm-suppliers) | get_layer_slice(["scm_suppliers"]) | Resumo de ameaças de fornecedores + marcadores no mapa |
| Descoberta de ferramentas | — | osint_tools | Lista tipos de consulta de reconhecimento e esquemas de expansão de entidade |
† osint_sweep (varredura ativa do InternetDB) requer OPENCLAW_ACCESS_TIER=full.
</details>
---
<details>
<summary>🔑 Variáveis de Ambiente</summary>
### Backend (`backend/.env`)```env
# Required for airplane telemetry (NEW in v0.9.7 — startup env check flags these as critical)
# Free registration: https://opensky-network.org/index.php?option=com_users&view=registration
OPENSKY_CLIENT_ID=your_opensky_client_id # OAuth2 — global flight state vectors
OPENSKY_CLIENT_SECRET=your_opensky_secret # OAuth2 — paired with Client ID above
# Optional (enhances data quality)
AIS_API_KEY=your_aisstream_key # Maritime vessel tracking (aisstream.io) — ships layer empty without it
LTA_ACCOUNT_KEY=your_lta_key # Singapore CCTV cameras
SHODAN_API_KEY=your_shodan_key # Shodan device search overlay
SH_CLIENT_ID=your_sentinel_hub_id # Copernicus CDSE Sentinel Hub imagery
SH_CLIENT_SECRET=your_sentinel_hub_secret # Paired with Sentinel Hub Client ID
MESH_SAR_EARTHDATA_USER= # NASA Earthdata user (SAR Mode B — OPERA products)
MESH_SAR_EARTHDATA_TOKEN= # NASA Earthdata token (paired with user above)
MESH_SAR_COPERNICUS_USER= # Copernicus Data Space user (SAR Mode B — EGMS / EMS)
MESH_SAR_COPERNICUS_TOKEN= # Copernicus token (paired with user above)
OPENCLAW_ACCESS_TIER=restricted # OpenClaw agent tier: "restricted" (read-only) or "full"
# OPENCLAW_HMAC_SECRET= # Optional; UI Bootstrap persists to data/openclaw.env in Docker
GFW_API_TOKEN=your_gfw_token # Global Fishing Watch — fishing_activity layer (Settings → Maritime)
TELEGRAM_OSINT_ENABLED=true # Telegram OSINT layer (default on)
TELEGRAM_OSINT_CHANNELS=osintdefender,... # Comma-separated public channel slugs (see .env.example)
# Private-lane privacy-core pinning (required when Arti or RNS is enabled)
PRIVACY_CORE_MIN_VERSION=0.1.0
PRIVACY_CORE_ALLOWED_SHA256=your_privacy_core_sha256
# Optional override if you load a non-default shared library path
PRIVACY_CORE_LIB=
Quando MESH_ARTI_ENABLED=true ou MESH_RNS_ENABLED=true, a inicialização do backend agora falha de forma segura a menos que o artefato privacy-core carregado reporte uma versão analisável igual ou superior a PRIVACY_CORE_MIN_VERSION e corresponda a um dos hashes em PRIVACY_CORE_ALLOWED_SHA256.
Gere o hash a partir do artefato que pretende enviar:```powershell Get-FileHash .\privacy-core\target\release\privacy_core.dll -Algorithm SHA256
- [Versão WASM (Rust)]: `wasm-pack build --target web` (a saída estará em `./pkg/`)
- [Exemplo de integração]: Adicionar exemplo: `rustfinity.com`
- [Versão Emscripten (C/C++)]: `emcc file.c -s WASM=1 -o output.html`
- [Suporte Node.js]: Verificar `node --experimental-wasm-modules`
- [Exemplo de runtime WASM]: Use [wasmtime](https://wasmtime.dev/) ou [wasmer](https://wasmer.io/)```bash
sha256sum ./privacy-core/target/release/libprivacy_core.so
Em seguida, confirme que o GET /api/wormhole/status ou GET /api/settings/wormhole-status autenticado mostra os mesmos privacy_core.version, privacy_core.library_path e privacy_core.library_sha256.
| Variável | Onde definir | Propósito |
|---|---|---|
BACKEND_URL | environment no docker-compose.yml ou env do shell | URL que o servidor Next.js usa para fazer proxy de chamadas de API para o backend. Padrão é http://backend:8000. Variável em tempo de execução — sem necessidade de reconstrução. |
BACKEND_PORT | .env na raiz do repositório ou env do shell antes de docker compose up | Porta do host usada para expor a API do backend para diagnósticos locais. Padrão é 8000; defina BACKEND_PORT=8001 se a porta 8000 já estiver em uso. Não altera o BACKEND_URL interno do Docker. |
Como funciona: O frontend faz proxy de todas as requisições /api/* através do servidor Next.js para BACKEND_URL usando a rede interna do Docker. Os navegadores se comunicam apenas com a porta 3000; a porta do host do backend é apenas para diagnósticos locais. Para desenvolvimento local sem Docker, BACKEND_URL padrão é http://localhost:8000.
| Quem | O que | PR |
|---|
| @Alienmajik | Suporte para Raspberry Pi 5 — empacotamento ARM64, notas de implantação headless, ajustes de tempo de execução para hardware classe Pi | — |
| @wa1id | Correção de ingestão CCTV — SQLite com threads, BD persistente, hidratação na inicialização, clicabilidade de cluster | #92 |
| @AlborzNazari | Fontes DGT Espanha + Madrid CCTV, exportação de inteligência de ameaças STIX 2.1 | #91 |
| @adust09 | Camada de usinas elétricas, cobertura de inteligência do Leste Asiático (bases JSDF, enriquecimento ICAO, notícias de Taiwan, classificação militar) | #71, #72, #76, #77, #87 |
| @Xpirix | Melhorias de estilo e interação na LocateBar | #78 |
| @imqdcr | Divisão de alternância de navios (4 categorias) + IDs de entidade MMSI/chamada estáveis | — |
| @csysp | Alertas de ameaças dispensáveis + IDs de entidade estáveis para GDELT e Notícias | #48, #63 |
| @suranyami | Construções Docker multi-arquitetura paralelas (11min → 3min) + correção do BACKEND_URL em tempo de execução | #35, #44 |
| @chr0n1x | Arquitetura Kubernetes / Helm chart para implantações de alta disponibilidade | — |
telegrammalwarebotnetcybercisakevscmsuppliersgfwfishing