bigbodycobain/shadowbrokerPiattaforma OSINT geospaziale in tempo reale che aggrega oltre 60 feed di telemetria pubblici (ADS-B, AIS, satelliti, CCTV) in una mappa unificata con toolkit di ricognizione lato server, canale dell'agente IA e comunicazioni mesh decentralizzate.
Intercettazione Globale delle Minacce — Piattaforma di Intelligenza Geospaziale in Tempo Reale
ShadowBroker è una piattaforma di intelligence decentralizzata che aggrega telemetria OSINT multi-dominio in tempo reale da oltre 60 feed di intelligence live in un'unica interfaccia mappa dark-ops. Aeromobili, navi, satelliti, zone di conflitto, reti CCTV, jamming GPS, dispositivi connessi a Internet, scanner della polizia, nodi radio mesh ed eventi geopolitici di rilievo — tutti aggiornati in tempo reale su un unico schermo, oltre a un protocollo di comunicazione offuscato e un'infrastruttura di scambio informazioni.
Costruito con Next.js, MapLibre GL, FastAPI e Python. 40+ livelli di dati attivabili/disattivabili, inclusi rilevamento di cambiamenti al suolo SAR, Telegram OSINT (anteprime dei canali pubblici geoparsate sulla mappa), un toolkit di ricognizione lato server (DNS, WHOIS, sanzioni, BGP, scansione IP e altro), overlay di rischio della supply chain e feed di minacce informatiche malware/C2 + CISA KEV. Molteplici modalità visive (DEFAULT / SATELLITE / FLIR / NVG / CRT). Fai clic destro su qualsiasi punto della Terra per un dossier paese, ricerca del capo di stato, espansione del grafo entità e l'ultima foto satellitare Sentinel-2. ShadowBroker non ha account, telemetria del prodotto o analytics; la dashboard comunica con il tuo backend self-hosted. Le query di ricognizione sensibili e Shodan non raggiungono mai API di terze parti dal browser — vengono proxyate attraverso il backend con protezioni SSRF e autenticazione operatore locale. Il canale di comando OpenClaw / agente espone gli stessi backend di ricognizione più la ricerca completa di telemetria — nessuna integrazione API separata richiesta.
Progettato per analisti, ricercatori, operatori radio e chiunque voglia vedere come appare il mondo quando ogni segnale pubblico è sulla stessa mappa.
Una quantità sorprendente di telemetria globale è già pubblica — trasmissioni ADS-B di aeromobili, segnali AIS marittimi, dati orbitali satellitari, sensori sismici, reti radio mesh, feed di scanner della polizia, stazioni di monitoraggio ambientale, telemetria dell'infrastruttura Internet e altro. Questi dati sono sparsi in dozzine di strumenti e API. ShadowBroker li combina tutti in un'unica interfaccia.
Il progetto non introduce nuove capacità di sorveglianza — aggrega e visualizza dataset pubblici esistenti. È completamente open-source, così chiunque può verificare esattamente quali dati vengono accessi e come. ShadowBroker non include telemetria del prodotto, analytics o account. Le chiavi fornite dall'operatore restano nella tua installazione locale, ma le funzionalità OSINT live effettuano necessariamente richieste in uscita ai fornitori di dati pubblici che abiliti o interroghi.
ShadowBroker include un connettore Shodan opzionale per l'accesso API fornito dall'operatore (SHODAN_API_KEY) e un pannello Recon Toolkit per ricerche OSINT senza chiave. Entrambi funzionano solo lato server: il browser chiama le route self-hosted /api/osint/* e /api/tools/shodan/*; le richieste in uscita sono effettuate dal backend dopo validazione SSRF. La ricognizione richiede accesso operatore locale (stesso modello di fiducia dei toggle dei layer e delle route admin). I risultati Shodan vengono renderizzati come overlay separato e rimangono soggetti ai termini di servizio di Shodan.
search_telemetry, search_news), l'intero toolkit di ricognizione (osint_lookup per IP/DNS/WHOIS/sanzioni/CVE/ecc.), espansione del grafo entità, posizionamento pin, controllo mappa, cambiamento al suolo SAR, mesh networking e consegna allerte. Vede tutto ciò che vede l'operatore e può intraprendere azioni sulla mappa in tempo reale.⚡ Avvio Veloce (Docker)
git clone https://github.com/bigbodycobain/Shadowbroker.git cd Shadowbroker docker compose pull docker compose up -d
### Da GitLab (usa 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
Entrambi i percorsi producono contenitori identici — stessa origine, stessa CI, stesse immagini byte per byte. Scegli l'ecosistema che già utilizzi.
Apri http://localhost:3000 per visualizzare la dashboard! (Richiede Docker Desktop o Docker Engine)
Unisciti allo swarm privato InfoNet (sb-testnet-0): Clicca su NODE nella dashboard, oppure esegui
./meshnode.shper un partecipante headless. Nessuna lista peer manuale — le impostazioni predefinite della flotta scoprono il seed e scaricano automaticamente il manifest firmato. ImpostaMESH_INFONET_FLEET_JOIN=falsein.envper un nodo solitario privato.
La porta del backend è già in uso? Il browser necessita solo della porta
3000, ma l'API backend è anche pubblicata sulla porta host8000per diagnostica locale. Se un'altra app utilizza già la8000, crea o modifica.envaccanto adocker-compose.ymle impostaBACKEND_PORT=8001, quindi eseguidocker compose up -d.
Schermate vuote per news/UAP/basi/wastewater dopo diversi minuti? Controlla se ci sono riavvii OOM del backend con
docker events --since 30m --filter container=shadowbroker-backend --filter event=oom. Il file compose predefinito assegna 4 GB al backend; se il tuo host ha meno memoria, riduci i feed abilitati o impostaBACKEND_MEMORY_LIMIT=3Ge aspettati che i layer più lenti/pesanti si riscaldino più gradualmente.
Utenti Podman: Podman funziona, ma
podman composeè un wrapper e necessita comunque di un provider Compose installato. Su Windows/WSL, se vedilooking up compose provider failed, installapodman-composeed eseguipodman-compose pullseguito dapodman-compose up -ddalla cartella clonataShadowbroker. Su shell Linux/macOS/WSL puoi anche usare./compose.sh --engine podman pulle./compose.sh --engine podman up -d.
🔄 Come Aggiornare
ShadowBroker utilizza immagini Docker pre-costruite — nessuna compilazione locale richiesta. L'aggiornamento richiede secondi:```bash docker compose pull docker compose up -d
Tutto qui. `pull` recupera le ultime immagini, `up -d` riavvia i container.
> **Provieni da una versione precedente?** Recupera prima il codice più recente del repository, poi tira le immagini:
>
> ```bash
> git pull origin main
> docker compose down
> docker compose pull
> docker compose up -d
> ```
>
> Gli utenti Podman dovrebbero eseguire il comando equivalente del provider, ad esempio `podman-compose pull` e `podman-compose up -d`, oppure usare `./compose.sh --engine podman pull` e `./compose.sh --engine podman up -d` da una shell compatibile con bash.
### Integrità degli aggiornamenti
Gli aggiornamenti Docker vengono distribuiti tramite registry di container firmati. Il vecchio auto-aggiornatore ZIP verifica gli archivi di rilascio attraverso questa catena, in ordine:
* `MESH_UPDATE_SHA256` quando un operatore fissa esplicitamente un digest.
* `backend/data/release_digests.json` per i pin di rilascio inclusi nel bundle.
* L'asset `SHA256SUMS.txt` del rilascio su GitHub quando non è presente un pin bundled.
I manutentori delle release dovrebbero eseguire `python backend/scripts/release_helper.py hash <ShadowBroker_vX.Y.Z.zip>` prima di pubblicare, quindi pubblicare `SHA256SUMS.txt` e aggiornare `backend/data/release_digests.json` quando distribuiscono un target di aggiornamento ZIP. L'aggiornatore mantiene intatto il percorso di override dell'operatore invece di fallire chiuso su digest bundled mancanti, in modo che le installazioni esistenti non rimangano bloccate a causa di un errore nel processo di rilascio.
### Rafforzamento CSP
Il frontend di produzione include un CSP compatibile con l'idratazione e un CSP rigoroso solo nonce in `Content-Security-Policy-Report-Only`. Imposta `SHADOWBROKER_STRICT_CSP=1` solo dopo aver verificato che la build esatta si idrati correttamente nel tuo deployment. I Google Fonts in runtime non sono richiesti; la pipeline di font Next inclusa serve il font della dashboard dalla build dell'app.
### ⚠️ **Bloccato sulla vecchia versione?**
**Se `git pull` fallisce o `docker compose up` continua a compilare dal sorgente invece di tirare le immagini**, il tuo clone è precedente a una migrazione del repository di marzo 2026 che ha riscritto la cronologia dei commit. Un normale `git pull` non può risolvere il problema. Esegui:```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
Come capire se sei affetto: Se docker compose up mostra RUN apt-get, RUN npm ci, o RUN pip install — sta compilando dal sorgente invece di scaricare immagini pre-costruite. Hai bisogno di un clone fresco.
Altre soluzioni:
docker compose pull --no-cachedocker image prune -fdocker compose logs -f backendPer distribuzioni ad alta disponibilità o cluster home-lab, ShadowBroker supporta il deployment tramite Helm. Questo chart è basato sul template bjw-s-labs e offre una configurazione robusta e modulare sia per il backend che per il frontend.
1. Aggiungi il repository:```bash helm repo add bjw-s-labs https://bjw-s-labs.github.io/helm-charts/ helm repo update
**2. Installa il 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. Caratteristiche principali:
Un ringraziamento speciale a @chr0n1x per aver contribuito all'architettura iniziale di Kubernetes.
ShadowBroker v0.9.7 include InfoNet (maglia di intelligence decentralizzata + economia di governance Sovereign Shell), un canale di comando AI agentico (supporta OpenClaw e qualsiasi agente con firma HMAC), riproduzione di snapshot Time Machine, e rilevamento di cambiamenti al suolo da satellite SAR. Questo è un testnet sperimentale — non un messenger privato e non un sistema di governance di produzione.
Il primo strato di comunicazione e governance di intelligence decentralizzato costruito direttamente in una piattaforma OSINT. Nessun account, nessuna registrazione, nessuna identità richiesta. v0.9.7 promuove InfoNet da un livello di chat a un'economia di governance completa con un percorso chiaro verso una piattaforma di intelligence decentralizzata che preserva la privacy.
Livello di comunicazione (dalla v0.9.6):
send, dm, comandi di mercato, ispezione dello stato gate. Pannello trascinabile, si minimizza alla barra superiore. Digita help per vedere tutti i comandi.Sovereign Shell — economia di governance (NUOVO in v0.9.7):
ShadowBroker v0.9.7 è composto da tre piani impilati verticalmente — la Operator UI, il Backend Service Plane e il Decentralized Layer (InfoNet) — più due ponti trasversali (la Time Machine e il Agentic AI Channel, che è il protocollo attraverso cui si connettono OpenClaw e qualsiasi altro agente compatibile) e un crate Rust Privacy Core che sostiene sia la mesh legacy che il futuro lavoro su moneta schermata / 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+ ║ ╚═════════════════════════════════════════════════════════════════════════════╝
Se vuoi solo eseguire la dashboard senza usare comandi da terminale:
.zip dalla release.start.bat.
Mac/Linux: Apri il terminale, digita chmod +x start.sh, dos2unix start.sh, ed esegui ./start.sh.Note sul launcher locale:
start.bat / start.sh eseguono l'app senza Docker: installano le dipendenze e avviano entrambi i server direttamente.docs/mesh/ per la risoluzione dei problemi.docs/mesh/wormhole-dm-root-operations-runbook.md.Se vuoi modificare il codice o eseguire dal sorgente:
pip — python.org (spunta "Add to PATH" durante l'installazione)
aisstream.io (obbligatorio), e opzionalmente opensky-network.org (OAuth2), lta.gov.sggit clone https://github.com/BigBodyCobain/Shadowbroker.git cd Shadowbroker
cd backend python -m venv venv venv\Scripts\activate # Windows
Tutti i 41 strati possono essere attivati/disattivati indipendentemente dal pannello di sinistra:
La piattaforma è ottimizzata per gestire enormi set di dati in tempo reale:
304 Not Modified saltano il parsing JSON ridondantesetData() diretteI nuovi contributori possono utilizzare docs/contributor-map.md per una guida di orientamento più breve.``` 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 è costruito in modalità aperta. Queste persone hanno inviato codice reale:
Questo strumento è costruito interamente su dati di intelligence open source (OSINT) pubblicamente disponibili. Non vengono utilizzati dati classificati, riservati o non pubblici. Le posizioni dei vettori sono stime basate su report pubblici. L'interfaccia utente a tema militare è puramente estetica.
Questo progetto è per scopi educativi e di ricerca personale. Consulta i termini di servizio dei singoli provider API per le restrizioni sull'uso dei dati.
Costruito con ☕ e troppe chiamate API
t.me/s (OSINTdefender, NEXTA, ecc.) scrapati ogni ora, con punteggio di rischio, geoparsati verso ancore metropolitane e tracciati come pin cliccabili sulla mappa con media inline| Canale | Stato Privacy | Dettagli |
|---|
| Meshtastic / APRS | PUBBLICO | Le trasmissioni radio RF sono pubbliche e intercettabili per progettazione. |
| Chat Gate InfoNet | OFFUSCATO | I messaggi sono offuscati con persona gate e firma canonica del payload, ma NON sono crittografati end-to-end. I metadati non sono nascosti nonostante siano progettati attraverso Tor e Reticulum (Lavori in corso). |
| DM Dead Drop | CANALE ATTUALE PIÙ FORTE | Casella postale di epoch basata su token con verifica di parole SAS. Canale più forte in questa build, ma non ancora privatamente affidabile. |
| Governance Sovereign Shell | REGISTRO PUBBLICO | Petizioni, voti, hash di aggiornamento e puntate in controversia sono eventi firmati su una catena di hash pubblica. Pseudonimo tramite persona gate, ma le azioni di governance sono intenzionalmente osservabili. |
| Primitive di privacy (RingCT / stealth / DEX) | NON ANCORA COLLEGATO | I contratti di Protocollo Bloccato sono in atto, ma lo schema crittografico non è stato scelto. La crate Rust privacy-core è l'obiettivo di integrazione per uno sprint futuro. |
Non trasmettere nulla di sensibile su alcun canale. Tratta tutti i canali come aperti e pubblici per ora. La crittografia E2E e un indurimento nativo/Tauri più profondo sono i prossimi traguardi. Se fai il fork di questo progetto, mantieni queste etichette intatte e non fare affermazioni di privacy più forti di quelle supportate dall'implementazione.
Per un quadro completo di ciò contro cui la maglia effettivamente difende e ciò che non difende, leggi il modello di minaccia e la riconciliazione delle affermazioni. Ogni frase sopra è mappata lì al percorso di codice che la applica (o non la applica).
UPDATE_PARAM, BATCH_UPDATE_PARAMS, ENABLE_FEATURE, e DISABLE_FEATURE. Manopole regolabili cambiano tramite voto — nessun deploy di codice richiesto.repr() di Python, così gli hash viaggiano pulitamente attraverso la catena.MappingProxyType.Pista per primitive di privacy (NUOVO in v0.9.7):
services/infonet/privacy/contracts.py per firme ad anello, indirizzi stealth, impegni di Pedersen, prove di intervallo e matching DEX. La crate Rust privacy-core è l'obiettivo di integrazione — nessun chiamante del modulo privacy ha bisogno di sapere quale schema è attivo.Testnet Sperimentale — Nessuna Garanzia di Privacy: I messaggi InfoNet sono offuscati ma NON crittografati end-to-end. La rete Mesh (Meshtastic/APRS) NON è privata — le trasmissioni radio sono intrinsecamente pubbliche. I contratti delle primitive di privacy sono impostati ma non ancora collegati. Non inviare nulla di sensibile su alcun canale. Tratta tutti i canali come aperti e pubblici per ora.
Adattato dallo stack di ricognizione OSIRIS (MIT) con il modello proxy di ShadowBroker. Attribuzione: backend/third_party/osiris/NOTICE.md.
Toolkit di Ricognizione (barra laterale sinistra — solo operatore locale):
us_ofac_sdn (CC-BY); controlli incrociati su entità WHOIS e stringhe ISP/org IP/api/osint/sweep/scan geolocalizza un target /24–/32 e fa da proxy per la scoperta host di Shodan InternetDB lato server (il browser non contatta mai InternetDB direttamente)Grafico delle entità — Seleziona qualsiasi entità sulla mappa per aprire il pannello Grafico delle entità (GET /api/entity/expand). Risolve aeromobili, navi, aziende, persone, IP e paesi in un grafico nodi/collegamenti (Wikidata SPARQL + OFAC + archivio in memoria di voli/navi).
Accesso OpenClaw / agente — Gli stessi backend di ricognizione sono disponibili sul canale di comando HMAC (nessun gate operatore locale del browser): osint_lookup (IP/DNS/WHOIS/certificati/BGP/sanzioni/CVE/MAC/GitHub/fughe/minacce passivi), entity_expand (grafico delle relazioni) e osint_sweep (scansione di sottorete attiva — solo livello di accesso completo). Chiama osint_tools per elencare i tipi di ricerca supportati. Pacchetto di skill: openclaw-skills/shadowbroker/ (SKILL.md + sb_query.py).
Overlay Shodan (invariato):
sar_pin_click) e far volare la mappa dell'operatore su qualsiasi centro AOI (sar_focus_aoi) — abilitando flussi di lavoro collaborativi per analisti.frontend/public/data/submarine-cables.json). Sovrapposizione di linea opzionale./api/cyber-threats e il toggle del layer./api/country-risk.t.me/s/*) da feed guerra/OSINT configurabili. Unione incrementale oraria (nessun re-scraping ridondante), punteggio di rischio per parole chiave, alias di luoghi in cirillico/arabo, geocodifica metro-anchor (separata dai centroidi delle notizie), foto/video in linea tramite proxy /api/telegram/media. Chiave layer: telegram_osint.Gaza
ShadowBroker espone un canale comandi AI agente bidirezionale — un ponte firmato e a livelli che dà a qualsiasi agente AI compatibile accesso completo in lettura/scrittura alla piattaforma di intelligence. OpenClaw è l'agente di riferimento, ma il canale è un protocollo aperto: qualsiasi agente guidato da LLM che firma le richieste con HMAC-SHA256 (Claude Code, GPT, LangChain, client Python/TypeScript personalizzati o la tua integrazione) può connettersi come analista che vede gli stessi dati dell'operatore e può eseguire azioni sulla mappa. ShadowBroker non include un LLM, un runtime agente o pesi del modello — fornisce la superficie; tu porti l'agente.
v0.9.7 trasforma ShadowBroker da una dashboard che un umano osserva in una superficie di intelligence su cui qualsiasi agente può agire.
Trasporto canale (NUOVO in v0.9.7):
POST /api/ai/channel/command accetta {cmd, args} e lo invia a qualsiasi strumento registrato.POST /api/ai/channel/batch accetta fino a 20 comandi in una singola richiesta. Il backend li esegue concorrentemente e restituisce una mappa di risultati fan-out. Riduce la latenza dell'agente di un ordine di grandezza rispetto alle chiamate sequenziali.OPENCLAW_ACCESS_TIER controlla quali comandi l'agente può chiamare: restricted espone il set di sola lettura, full aggiunge scritture e iniezioni. L'endpoint di scoperta restituisce available_commands in modo che l'agente possa introspezionare le proprie capacità.HMAC-SHA256(secret, METHOD|path|timestamp|nonce|sha256(body)) con protezione da replay tramite timestamp + nonce e integrità della richiesta. Supporta modalità locale (nessuna configurazione) e remota (agente su macchina diversa / VPS).Capacità:
get_summary → get_layer_slice con since_layer_versions per layer (la push SSE layer_changed dice all'agente esattamente quali layer sono stati aggiornati). search_telemetry è l'indice keyword cross-layer in stile Google. search_news copre notizie, GDELT, CrowdThreat, LiveUAMap, fronti e post Telegram. entities_near, brief_area, find_flights/find_ships/find_entity e correlate_entity rispondono a domande mirate senza pull multi-megabyte.osint_lookup esegue gli stessi backend protetti da SSRF del pannello Recon (ip, dns, whois, certs, bgp, sanctions, cve, mac, github, leaks, threats, sweep_init). entity_expand costruisce grafi di relazione Wikidata + OFAC. osint_sweep esegue scoperta di sottoreti Shodan InternetDB (livello ). Alias dei layer: , /, //, /, /.Connetti un agente: Apri il pannello AI Intel nella barra laterale sinistra, clicca Connect Agent e copia il segreto HMAC. Da lì, punta qualsiasi agente compatibile al canale — per OpenClaw, importa ShadowBrokerClient da openclaw-skills/shadowbroker/sb_query.py (vedi SKILL.md per esempi); per qualsiasi altro agente, usa lo stesso contratto HMAC documentato sopra (timestamp + nonce + digest del corpo, regolato dal livello). Scoperta: GET /api/ai/tools e GET /api/ai/capabilities. Il canale è il protocollo, non l'agente.
Docker Compose + agenti remoti: La UI della dashboard comunica con il backend attraverso il bridge privato di Docker (fidato automaticamente). Un agente OpenClaw in esecuzione sull'host (fuori dal container) colpisce http://localhost:8000 dall'IP del gateway Docker — HMAC è richiesto lì. In AI Intel → Connect Agent, clicca Bootstrap poi Reveal, copia SHADOWBROKER_HMAC_SECRET nell'environ dell'agente e riavvia il backend una volta così che data/openclaw.env sul volume backend_data venga caricato. Testa con:
curl -s http://localhost:8000/api/ai/tools | jq .available_commands
``````bash
export SHADOWBROKER_URL=http://127.0.0.1:8000
export SHADOWBROKER_HMAC_SECRET=<from Connect Agent modal>
python openclaw-skills/shadowbroker/verify_hmac.py
Usa la porta del backend (:8000), non la porta della dashboard Next.js (:3000). I signer personalizzati devono fare l'hash esatto dei byte POST: json.dumps(payload, separators=(",", ":"), sort_keys=True).
Un trasporto in stile multimediale per l'intero feed di telemetria. Tratta la mappa live come una registrazione che può essere scorsa, messa in pausa e riprodotta.
count, latest_id, latest_ts e l'intera lista snapshot_ids. Salta a qualsiasi timestamp catturato direttamente dal cursore della timeline.Impostazioni → Chiavi API è ora un registro di sola lettura. I valori delle chiavi non arrivano mai al processo del browser — nemmeno un prefisso offuscato. Il pannello mostra:
.env del backend come risolto da Path(__file__).resolve() — funziona su qualsiasi sistema operativo, qualsiasi unità, qualsiasi percorso di installazione (Linux /home/..., macOS /Users/..., Windows su qualsiasi unità, container Docker, VM cloud).[exists] / [will be created on first save] / [NOT WRITABLE — edit by hand] sul percorso stesso..env.example in modo che gli utenti possano copiarlo e inserire le proprie chiavi.CONFIGURED / NOT CONFIGURED per chiave, più una riga env copiabile (es. OPENSKY_CLIENT_ID=YOUR_VALUE) che l'utente può inserire manualmente nel file.Le credenziali API OpenSky sono ora un requisito ambientale critical-warn: il controllo dell'ambiente all'avvio segnala la mancanza delle credenziali OAuth2 di OpenSky con un forte avviso, e la modale del changelog collega direttamente alla pagina di registrazione gratuita. Senza di esse, il layer dei voli torna alla copertura solo ADS-B con significative lacune in Africa, Asia e America Latina.
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
</details>
---
<details>
<summary>📊 Fonti dati e API</summary>
| Fonte | Dati | Frequenza aggiornamento | API Key richiesta |
|---|---|---|---|
| [OpenSky Network](https://opensky-network.org) | Voli commerciali e privati | ~60s | **Sì** |
| [adsb.lol](https://adsb.lol) | Aeromobili militari | ~60s | No |
| [aisstream.io](https://aisstream.io) | Posizioni navi AIS | WebSocket in tempo reale | **Sì** |
| [CelesTrak](https://celestrak.org) | Posizioni orbitali satellitari (TLE + SGP4) | ~60s | No |
| [USGS Earthquake](https://earthquake.usgs.gov) | Eventi sismici globali | ~60s | No |
| [GDELT Project](https://www.gdeltproject.org) | Eventi di conflitto globali | ~6h | No |
| [DeepState Map](https://deepstatemap.live) | Fronte ucraino | ~30min | No |
| [Shodan](https://www.shodan.io) | Ricerca dispositivi connessi a Internet | On-demand | **Sì** |
| [OpenSanctions](https://www.opensanctions.org) | Indice sanzioni OFAC SDN (ricognizione + grafo entità) | Cache 24h | No |
| [abuse.ch Feodo + URLhaus](https://abuse.ch) | URL di distribuzione / C2 malware | ~5min (layer opt-in) | No |
| [CISA KEV](https://www.cisa.gov/known-exploited-vulnerabilities-catalog) | CVE conosciute sfruttate | ~5min (layer opt-in) | No |
| [ip-api.com](https://ip-api.com) | Geolocalizzazione IP (ricognizione, grafo entità) | On-demand | No |
| [Google Public DNS](https://dns.google) | Ricerche DNS-over-HTTPS (ricognizione) | On-demand | No |
| [RDAP.org](https://rdap.org) | Dati registrazione domini (ricognizione) | On-demand | No |
| [crt.sh](https://crt.sh) | Trasparenza certificati (ricognizione) | On-demand | No |
| [bgpview.io](https://bgpview.io) | Routing BGP/ASN (ricognizione) | On-demand | No |
| TeleGeography (statica) | Rotta cavi sottomarini | Statico | No |
| [ASFINAG](https://www.asfinag.at) | Webcam autostrade Austria | ~10min | No |
| [Amtrak](https://www.amtrak.com) | Posizioni treni USA | ~60s | No |
| [DigiTraffic](https://www.digitraffic.fi) | Posizioni treni europei | ~60s | No |
| [Global Fishing Watch](https://globalfishingwatch.org) | Attività pescherecci | ~1hr | **Sì** (`GFW_API_TOKEN`) |
| [Anteprime pubbliche Telegram](https://t.me/s) | Post canali guerra/OSINT (`telegram_osint`) | ~1hr | No (opzionale `TELEGRAM_OSINT_CHANNELS`) |
| Transport for London, NYC DOT, TxDOT | Telecamere CCTV (Regno Unito, USA) | ~10min | No |
| Caltrans, WSDOT, GDOT, IDOT, MDOT | Telecamere CCTV (5 stati USA) | ~10min | No |
| Spain DGT, Madrid City | Telecamere CCTV (Spagna) | ~10min | No |
| [Singapore LTA](https://datamall.lta.gov.sg) | Telecamere traffico Singapore | ~10min | **Sì** |
| [Windy Webcams](https://www.windy.com) | Webcam globali | ~10min | No |
| [SatNOGS](https://satnogs.org) | Stazioni terra satellitari amatoriali | ~30min | No |
| [TinyGS](https://tinygs.com) | Stazioni terra satellitari LoRa | ~30min | No |
| [Meshtastic MQTT](https://meshtastic.org) | Posizioni nodi radio mesh | In tempo reale | No |
| [APRS-IS](https://www.aprs-is.net) | Posizioni radioamatori | TCP in tempo reale | No |
| [KiwiSDR](https://kiwisdr.com) | Posizioni ricevitori SDR pubblici | ~30min | No |
| [OpenMHZ](https://openmhz.com) | Flussi scanner polizia/vigili del fuoco | In tempo reale | No |
| [Smithsonian GVP](https://vulcano.si.edu) | Vulcani olocenici mondiali | Statico (cached) | No |
| [OpenAQ](https://openaq.org) | Stazioni qualità aria PM2.5 | ~120s | No |
| NOAA / NWS | Allerte meteorologiche severe e poligoni | ~120s | No |
| [WRI Global Power Plant DB](https://datasets.wri.org) | Oltre 35.000 centrali elettriche | Statico (cached) | No |
| Dataset basi militari | Installazioni militari globali | Statico (cached) | No |
| [NASA FIRMS](https://firms.modaps.eosdis.nasa.gov) | Hotspot termici/incendi NOAA-20 VIIRS | ~120s | No |
| [NOAA SWPC](https://services.swpc.noaa.gov) | Indice Kp meteorologia spaziale ed eventi solari | ~120s | No |
| [IODA (Georgia Tech)](https://ioda.inetintel.cc.gatech.edu) | Avvisi interruzione Internet regionale | ~120s | No |
| [DC Map (GitHub)](https://github.com/Ringmast4r/Data-Center-Map---Global) | Posizioni data center globali | Statico (cached 7d) | No |
| [NASA GIBS](https://gibs.earthdata.nasa.gov) | Immagini satellitari quotidiane MODIS Terra | Giornaliero (ritardo 24-48h) | No |
| [Esri World Imagery](https://www.arcgis.com) | Mappa base satellitare ad alta risoluzione | Statico (aggiornato periodicamente) | No |
| [MS Planetary Computer](https://planetarycomputer.microsoft.com) | Scene Sentinel-2 L2A (clic destro) | On-demand | No |
| [Copernicus CDSE](https://dataspace.copernicus.eu) | Immagini Sentinel Hub (API Process) | On-demand | **Sì** (gratuita) |
| [VIIRS Nightlights](https://eogdata.mines.edu) | Rilevamento cambiamento luci notturne | Statico | No |
| [RestCountries](https://restcountries.com) | Dati profilo paesi | On-demand (cached 24h) | No |
| [Wikidata SPARQL](https://query.wikidata.org) | Dati capi di stato | On-demand (cached 24h) | No |
| [Wikipedia API](https://en.wikipedia.org/api) | Riepiloghi località e immagini aeromobili | On-demand (cached) | No |
| [OSM Nominatim](https://nominatim.openstreetmap.org) | Geocodifica nomi di luogo (barra LOCALIZZA) | On-demand | No |
| [CARTO Basemaps](https://carto.com) | Tile mappa scure | Continuo | No |
**Privacy e audit in uscita (#348–#366):** Ogni installazione self-hosted utilizza il proprio IP backend e un handle User-Agent per installazione. Vedi [docs/OUTBOUND_DATA.md](https://github.com/bigbodycobain/shadowbroker/blob/HEAD/docs/OUTBOUND_DATA.md) per cosa contatta terze parti, controlli opt-in/env e compromessi accettati (Referer CCTV, CDN mappe base, LiveUAMap, ecc.).
</details>
---
<details>
<summary>🚀 Per iniziare</summary>
### 🐳 Configurazione Docker (consigliata per self-hosting)
Il repository include un file `docker-compose.yml` che scarica immagini precompilate da GitHub Container Registry.```bash
git clone https://github.com/BigBodyCobain/Shadowbroker.git
cd Shadowbroker
# Add your API keys in a repo-root .env file (optional — see Environment Variables below)
docker compose pull
docker compose up -d
Apri http://localhost:3000 per visualizzare la dashboard.
Distribuzione pubblica o su LAN? Nessuna configurazione necessaria per la maggior parte degli allestimenti. Il frontend inoltra tutte le chiamate API attraverso il server Next.js a
BACKEND_URL, che per impostazione predefinita èhttp://backend:8000(rete interna di Docker). La porta host8000è pubblicata solo per accesso API/debug locale (127.0.0.1:8000indocker-compose.yml). Se entra in conflitto con un altro servizio, impostaBACKEND_PORT=8001in.env; lasciaBACKEND_URLcomehttp://backend:8000perché quella è la porta interna di Docker.Esecuzione del backend fuori da Docker (
cd backend && python main.py): il server di sviluppo si lega solo al loopback (127.0.0.1:8000) quindi altre macchine sulla tua LAN non possono raggiungere le route admin/local-trust con unADMIN_KEYvuoto. ImpostaSHADOWBROKER_DEV_BIND_ALL=truein.envsolo quando hai deliberatamente bisogno di0.0.0.0e usa unADMIN_KEYforte per qualsiasi chiamante non locale. Il limite di memoria del backend è controllato daBACKEND_MEMORY_LIMITe per impostazione predefinita è4G. Se Docker segnala eventi OOM, il backend si riavvierà e i layer lenti possono apparire vuoti finché non si ripopolano.Se il tuo backend è in esecuzione su un host o porta diversa, imposta
BACKEND_URLin fase di esecuzione — nessuna ricostruzione necessaria:# 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
Utenti Podman: Non passare l'URL di GitHub a podman compose pull; clona prima il repository, cd Shadowbroker, poi esegui compose da quella cartella. podman compose richiede anche un provider Compose. Se Podman segnala looking up compose provider failed, installane uno:```bash
python3 -m pip install --user podman-compose podman-compose pull podman-compose up -d
## Come Funziona
- Gli script PowerShell sono organizzati in moduli basati su funzioni per riusabilità e chiarezza. Ogni modulo corrisponde a una specifica capacità operativa, come:
- `C2/Junk/Exfil.ps1`: Gestisce le operazioni di esfiltrazione dei dati.
- `C2/Junk/Payloads.ps1`: Gestisce i meccanismi di consegna dei payload.
- `C2/Phishery/Scripts/Phish.ps1`: Distribuisce senza soluzione di continuità l'infrastruttura di phishing. 🎣
- La coerenza del codice viene mantenuta tramite un approccio basato su hook nel repository GitHub, che formatta automaticamente gli script PowerShell durante i commit.
- Un file `setup.bat` semplifica il processo di inizializzazione, garantendo che tutte le dipendenze necessarie siano installate e le configurazioni applicate automaticamente.```powershell
# Windows PowerShell
py -m pip install --user podman-compose
podman-compose pull
podman-compose up -d
Se ti trovi in una shell compatibile con bash, il wrapper incluso può rilevare automaticamente Docker o Podman:```bash ./compose.sh --engine podman pull ./compose.sh --engine podman up -d
</details>
---
<details>
<summary>🐋 Deploy Standalone (Portainer, Uncloud, NAS, ecc.)</summary>
Non è necessario clonare il repository. Utilizza le immagini precompilate da GitHub Container Registry. Le immagini del registro GitLab possono essere utilizzate come mirror se le pubblichi lì.
Crea un file `docker-compose.yml` con il seguente contenuto e distribuiscilo direttamente — incollalo nell'editor di stack di Portainer, `uncloud deploy`, o su qualsiasi host Docker:```yaml
## Image registry — uncomment ONE line per service:
## GitHub (primary): ghcr.io/bigbodycobain/shadowbroker-backend:latest
## GitLab (mirror): registry.gitlab.com/bigbodycobain/shadowbroker/backend:latest
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
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:
Come funziona: Il container frontend inoltra tutte le richieste
/api/*tramite il server Next.js aBACKEND_URLusando la rete interna di Docker. Il browser comunica solo con la porta 3000. La porta host del backend è per l'accesso locale all'API/debug e può essere modificata conBACKEND_PORT=8001senza cambiareBACKEND_URL.
BACKEND_URLè una semplice variabile d'ambiente runtime (non una build-timeNEXT_PUBLIC_*), quindi puoi cambiarla in Portainer, Uncloud o qualsiasi editor compose senza ricostruire l'immagine. Impostala sull'indirizzo in cui il backend è raggiungibile dall'interno della rete Docker (es.http://backend:8000,http://192.168.1.50:8000).
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/.pip install .
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
cd ../frontend npm ci
### Esecuzione```bash
# From the frontend directory — starts both frontend & backend concurrently
npm run dev
http://localhost:3000http://localhost:8000Se usi pre-commit, installa gli hook una volta dalla root del repository:```bash pre-commit install
### Ricevitore AIS Locale (Opzionale)
Puoi inserire i tuoi dati AIS delle navi in ShadowBroker utilizzando un dongle RTL-SDR e [AIS-catcher](https://github.com/jvde-github/AIS-catcher), un decoder AIS open-source. Questo ti fornisce copertura in tempo reale delle imbarcazioni nella tua zona — nessuna chiave API necessaria.
1. Collega un dongle RTL-SDR
2. Installa AIS-catcher ([releases](https://github.com/jvde-github/AIS-catcher/releases)) o usa l'immagine Docker: ```bash
docker run -d --device /dev/bus/usb \
ghcr.io/jvde-github/ais-catcher -H http://host.docker.internal:4000/api/ais/feed interval 10
AIS-catcher decodifica segnali radio VHF su 161.975 MHz e 162.025 MHz e invia i dati decodificati delle imbarcazioni a ShadowBroker ogni 10 secondi. Le navi rilevate dalla tua antenna SDR appaiono insieme al flusso globale AIS.
Docker (ARM/Raspberry Pi): Vedi docker-shipfeeder per un'immagine Docker pronta per la produzione ottimizzata per ARM.
Nota: La portata AIS dipende dalla tua antenna — tipicamente 20-40 miglia nautiche con una configurazione base, 60+ nm con un'antenna VHF marina in altura.
| Layer | Default | Descrizione |
|---|
| Commercial Flights | ✅ ON | Compagnie aeree, cargo, aeromobili dell'aviazione generale |
| Private Flights | ✅ ON | Aeromobili privati non commerciali |
| Private Jets | ✅ ON | Business jet di alto valore con dati del proprietario |
| Military Flights | ✅ ON | Aeromobili militari e governativi |
| Tracked Aircraft | ✅ ON | Lista di sorveglianza di interesse speciale |
| GPS Jamming | ✅ ON | Zone di degrado NAC-P |
| Carriers / Mil / Cargo | ✅ ON | Portaerei, navi cargo, petroliere |
| Civilian Vessels | ✅ ON | Yacht, pescherecci, imbarcazioni da diporto |
| Cruise / Passenger | ✅ ON | Navi da crociera e traghetti |
| Tracked Yachts | ✅ ON | Superyacht di miliardari e oligarchi |
| Fishing Activity | ✅ ON | Eventi di imbarcazioni Global Fishing Watch |
| Trains | ✅ ON | Posizioni ferroviarie Amtrak + europee |
| Satellites | ✅ ON | Asset orbitali per tipo di missione |
| SatNOGS | ✅ ON | Stazioni di terra satellitari amatoriali |
| TinyGS | ✅ ON | Stazioni di terra satellitari LoRa |
| Earthquakes (24h) | ✅ ON | Eventi sismici USGS |
| Fire Hotspots (24h) | ✅ ON | Anomalie termiche VIIRS NASA FIRMS |
| Volcanoes | ✅ ON | Vulcani dell'Olocene Smithsonian |
| Weather Alerts | ✅ ON | Poligoni di maltempo |
| Air Quality (PM2.5) | ✅ ON | Stazioni OpenAQ in tutto il mondo |
| Ukraine Frontline | ✅ ON | Posizioni del fronte di guerra in tempo reale |
| Ukraine Air Alerts | ✅ ON | Allarmi aerei regionali |
| Global Incidents | ✅ ON | Eventi di conflitto GDELT |
| CCTV Mesh | ✅ ON | Oltre 11.000 telecamere da 13 fonti, 6 paesi |
| Internet Outages | ✅ ON | Avvisi di connettività regionale IODA |
| Data Centers | ✅ ON | Posizioni globali dei data center (oltre 2.000) |
| Military Bases | ✅ ON | Installazioni militari globali |
| KiwiSDR Receivers | ✅ ON | Ricevitori radio SDR pubblici |
| Meshtastic Nodes | ✅ ON | Posizioni dei nodi radio mesh |
| APRS | ✅ ON | Posizionamento radioamatoriale |
| Scanners | ✅ ON | Feed scanner polizia/vigili del fuoco |
| Day / Night Cycle | ✅ ON | Sovrapposizione del terminatore solare |
| MODIS Terra (Daily) | ❌ OFF | Immagini satellitari giornaliere NASA GIBS |
| High-Res Satellite | ❌ OFF | Immagini satellitari submetriche Esri |
| Sentinel Hub | ❌ OFF | API Process CDSE Copernicus |
| VIIRS Nightlights | ❌ OFF | Rilevamento cambiamenti luce notturna |
| Power Plants | ❌ OFF | Oltre 35.000 centrali elettriche globali |
| Shodan Overlay | ❌ OFF | Risultati di ricerca dispositivi Internet |
| Road Freight Trends | ❌ OFF | Tendenze movimento camion su autostrade principali da Sentinel-2 (Analizza Qui) |
| Submarine Cables | ❌ OFF | Rotta dei cavi sottomarini globali (GeoJSON statico) |
| Malware C2 | ❌ OFF | Punti di minaccia abuse.ch Feodo + URLhaus |
| SCM Suppliers | ❌ OFF | Marcatori di rischio catena di fornitura Tier 1/2 + avvisi pannello |
| Cyber Threats | ❌ OFF | Voci recenti CISA KEV (statistiche nel payload slow-tier) |
| Telegram OSINT | ✅ ON | Canali Telegram OSINT/di guerra pubblici — scraping orario, pin geoanalizzati |
| SAR | ✅ ON | Catalogo radar ad apertura sintetica + avvisi anomalie |
Strumenti di ricognizione ed entità (non layer della mappa — barra laterale sinistra / selezione):
| Tool | Accesso dashboard | Comando OpenClaw | Descrizione |
|---|---|---|---|
| Recon Toolkit | Operatore locale (/api/osint/*) | osint_lookup, osint_sweep† | IP, DNS, WHOIS, certificati, BGP, sanzioni, CVE, MAC, GitHub, fughe di dati, minacce, scansione subnet |
| Entity Graph | Operatore locale (/api/entity/expand) | entity_expand | Grafo relazionale Wikidata + OFAC + archivio live |
| SCM Risk panel | Operatore locale (/api/scm-suppliers) | get_layer_slice(["scm_suppliers"]) | Riepilogo minacce fornitore + marcatori mappa |
| Tool discovery | — | osint_tools | Elenca i tipi di lookup di ricognizione e gli schemi di espansione entità |
† osint_sweep (scansione InternetDB attiva) richiede OPENCLAW_ACCESS_TIER=full.
</details>
---
<details>
<summary>🔑 Variabili d'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 o MESH_RNS_ENABLED=true, l'avvio del backend ora fallisce in modo chiuso a meno che l'artefatto privacy-core caricato riporti una versione analizzabile pari o superiore a PRIVACY_CORE_MIN_VERSION e corrisponda a uno degli hash in PRIVACY_CORE_ALLOWED_SHA256.
Genera l'hash dall'artefatto che intendi distribuire:```powershell Get-FileHash .\privacy-core\target\release\privacy_core.dll -Algorithm SHA256
| **S3/S4** | Attacchi di impersonificazione su bucket S3/S4. I dati possono includere informazioni di fatturazione, PII, cartelle cliniche, ecc. |
| **Scalefusion** | Leggere file arbitrari dal bucket S3 di Scalefusion MDM. I dati possono includere fatture, backup dei dispositivi, ecc. |
| **SharePoint** | Leggere file arbitrari dai tenant di SharePoint Online. |
| **Slack** | Leggere messaggi dagli spazi di lavoro Slack. |
| **SmarterMail** | Leggere email dalle installazioni di SmarterMail. |
| **SolarWinds** | Combinare una CVE di SolarWinds Serv-U con una chiave passport cablata per ottenere RCE. |
| **Splunk** | Leggere file arbitrari dalle istanze di Splunk SOAR. |
| **Spring Cloud** | Bypassare l'autenticazione per la configurazione e il service discovery di Spring Cloud. I dati possono includere configurazioni eureka, chiavi API, ecc. |
| **Strapi** | Reimpostare le password ed escalare ad amministratore di Strapi. |
| **TeamCity** | Accedere come qualsiasi utente non registrato, bypassando il plugin OIDC di TeamCity. |
| **TeamPass** | Accedere alle password, alle chiavi e ad altri segreti di una cartella TeamPass. |
| **Teradata** | Leggere dati arbitrari dai database Teradata. |
| **Terraform** | Leggere file arbitrari dagli spazi di lavoro TFC/E. I dati possono includere chiavi API, IaC, ecc. |
| **Thinkst Canary** | Leggere file arbitrari dalle istanze di Thinkst Canary. |```bash
sha256sum ./privacy-core/target/release/libprivacy_core.so
Quindi conferma che le richieste autenticate GET /api/wormhole/status o GET /api/settings/wormhole-status mostrano gli stessi privacy_core.version, privacy_core.library_path e privacy_core.library_sha256.
| Variabile | Dove impostare | Scopo |
|---|---|---|
BACKEND_URL | environment in docker-compose.yml, o variabile d'ambiente shell | URL che il server Next.js usa per fare da proxy alle chiamate API verso il backend. Predefinito: http://backend:8000. Variabile runtime — nessuna ricostruzione necessaria. |
BACKEND_PORT | .env nella root del repo o variabile d'ambiente shell prima di docker compose up | Porta host usata per esporre l'API backend per diagnostica locale. Predefinito: 8000; imposta BACKEND_PORT=8001 se la porta 8000 è già in uso. Non modifica BACKEND_URL interno a Docker. |
Come funziona: Il frontend fa da proxy per tutte le richieste /api/* attraverso il server Next.js verso BACKEND_URL usando la rete interna di Docker. I browser comunicano solo con la porta 3000; la porta host del backend è solo per diagnostica locale. Per sviluppo locale senza Docker, BACKEND_URL viene impostato su http://localhost:8000.
| Chi | Cosa | PR |
|---|
| @Alienmajik | Supporto Raspberry Pi 5 — pacchettizzazione ARM64, note per deployment headless, ottimizzazione runtime per hardware di classe Pi | — |
| @wa1id | Correzione acquisizione CCTV — SQLite threaded, DB persistente, idratazione all'avvio, cluster cliccabili | #92 |
| @AlborzNazari | Fonti DGT Spagna e CCTV Madrid, esportazione threat intel STIX 2.1 | #91 |
| @adust09 | Livello centrali elettriche, copertura intelligence Asia orientale (basi JSDF, arricchimento ICAO, notizie Taiwan, classificazione militare) | #71, #72, #76, #77, #87 |
| @Xpirix | Miglioramenti stile e interazione LocateBar | #78 |
| @imqdcr | Suddivisione attivazione navi (4 categorie) + ID entità MMSI/callsign stabili | — |
| @csysp | Avvisi di minaccia eliminabili + ID entità stabili per GDELT e News | #48, #63 |
| @suranyami | Build Docker parallele multi-arch (11 min → 3 min) + correzione runtime BACKEND_URL | #35, #44 |
| @chr0n1x | Architettura Kubernetes / Helm chart per deployment HA | — |
telegrammalwarebotnetcybercisakevscmsuppliersgfwfishing