Echtzeit-Geospatial-OSINT-Plattform, die über 60 öffentliche Telemetrie-Feeds (ADS-B, AIS, Satelliten, CCTV) in einer einheitlichen Karte zusammenfasst, mit serverseitigem Recon-Toolkit, KI-Agentenkanal und dezentraler Mesh-Kommunikation.
Global Threat Intercept — Echtzeit-Geodatenplattform für Intelligence
ShadowBroker ist eine dezentralisierte Intelligence-Plattform, die Echtzeit-OSINT-Telemetriedaten aus mehreren Bereichen von über 60 Live-Intelligence-Feeds in einer einzigen Dark-Ops-Kartenoberfläche zusammenführt. Flugzeuge, Schiffe, Satelliten, Konfliktzonen, CCTV-Netzwerke, GPS-Störungen, mit dem Internet verbundene Geräte, Polizeifunk, Mesh-Funkknoten und geopolitische Ereignisse – alles wird in Echtzeit auf einem Bildschirm aktualisiert, zuzüglich eines verschleierten Kommunikationsprotokolls und einer Infrastruktur für Informationsaustausch.
Erstellt mit Next.js, MapLibre GL, FastAPI und Python. Über 40 umschaltbare Datenebenen, darunter SAR-Bodenveränderungserkennung, Telegram-OSINT (Vorschauen öffentlicher Kanäle, geokodiert auf der Karte), ein serverseitiges Recon-Toolkit (DNS, WHOIS, Sanktionen, BGP, IP-Sweep und mehr), Lieferketten-Risikoüberlagerungen sowie Malware-/C2- und CISA-KEV-Cyberbedrohungsfeeds. Mehrere visuelle Modi (DEFAULT / SATELLITE / FLIR / NVG / CRT). Rechtsklick auf einen beliebigen Punkt der Erde liefert ein Länderdossier, Staatschef-Suche, Entity-Graph-Erweiterung und das aktuellste Sentinel-2-Satellitenfoto. ShadowBroker hat keine Konten, Produkttelemetrie oder Analysen; das Dashboard kommuniziert mit Ihrem selbst gehosteten Backend. Sensitive Recon- und Shodan-Abfragen erreichen keine Drittanbieter-APIs aus dem Browser – sie werden über das Backend mit SSRF-Schutz und lokaler Operator-Authentifizierung weitergeleitet. Der OpenClaw / Agent-Command-Channel stellt dieselben Recon-Backends sowie eine vollständige Telemetriesuche bereit – keine separate API-Integration erforderlich.
Konzipiert für Analysten, Forscher, Funkamateure und alle, die sehen möchten, wie die Welt aussieht, wenn jedes öffentliche Signal auf derselben Karte erscheint.
Eine überraschende Menge globaler Telemetrie ist bereits öffentlich zugänglich – Flugzeug-ADS-B-Signale, maritime AIS-Signale, Satellitenbahndaten, Erdbebensensoren, Mesh-Funknetzwerke, Polizeifunk-Feeds, Umweltüberwachungsstationen, Internet-Infrastrukturtelemetrie und mehr. Diese Daten sind über Dutzende von Tools und APIs verstreut. ShadowBroker vereint alles in einer einzigen Oberfläche.
Das Projekt führt keine neuen Überwachungsfähigkeiten ein – es aggregiert und visualisiert vorhandene öffentliche Datensätze. Es ist vollständig Open Source, sodass jeder überprüfen kann, auf welche Daten genau zugegriffen wird und wie. ShadowBroker enthält keine Produkttelemetrie, Analysen oder Konten. Von Operatoren bereitgestellte Schlüssel verbleiben in Ihrer lokalen Bereitstellung, aber Live-OSINT-Funktionen senden zwangsläufig ausgehende Anfragen an die öffentlichen Datenanbieter, die Sie aktivieren oder abfragen.
ShadowBroker enthält einen optionalen Shodan-Connector für vom Operator bereitgestellten API-Zugriff (SHODAN_API_KEY) und ein Recon-Toolkit-Panel für schlüssellose OSINT-Abfragen. Beide laufen nur serverseitig: Der Browser ruft Ihre selbst gehosteten Routen /api/osint/* und /api/tools/shodan/* auf; ausgehende Anfragen werden vom Backend nach SSRF-Validierung durchgeführt. Recon erfordert lokalen Operator-Zugriff (gleiches Vertrauensmodell wie Ebenen-Umschaltungen und Admin-Routen). Shodan-Ergebnisse werden als separate Kartenüberlagerung dargestellt und unterliegen weiterhin den Nutzungsbedingungen von Shodan.
search_telemetry, search_news), das vollständige Recon-Toolkit (osint_lookup für IP/DNS/WHOIS/Sanktionen/CVE usw.), Entity-Graph-Erweiterung, Pin-Platzierung, Kartensteuerung, SAR-Bodenveränderung, Mesh-Netzwerk und Alarmzustellung. Er sieht alles, was der Operator sieht, und kann in Echtzeit Aktionen auf der Karte ausführen.⚡ Quick Start (Docker)
git clone https://github.com/bigbodycobain/Shadowbroker.git cd Shadowbroker docker compose pull docker compose up -d
### Von GitLab (verwendet 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
Beide Pfade erzeugen identische Container – gleiche Quelle, gleiche CI, bildgleiche Images. Wähle das Ökosystem, das du bereits verwendest.
Öffne http://localhost:3000, um das Dashboard zu sehen! (Erfordert Docker Desktop oder Docker Engine)
Trete dem privaten InfoNet-Schwarm (sb-testnet-0) bei: Klicke im Dashboard auf NODE oder führe
./meshnode.shfür einen kopflosen Teilnehmer aus. Keine manuelle Peer-Liste – die Flottenstandards entdecken den Seed und ziehen das signierte Manifest automatisch. SetzeMESH_INFONET_FLEET_JOIN=falsein.envfür einen privaten Solo-Node.
Backend-Port bereits belegt? Der Browser benötigt nur Port
3000, aber die Backend-API wird auch auf Host-Port8000für lokale Diagnose veröffentlicht. Wenn eine andere App bereits8000verwendet, erstelle oder bearbeite.envnebendocker-compose.ymlund setzeBACKEND_PORT=8001, führe danndocker compose up -daus.
Leere Nachrichten/UAP/Stützpunkte/Abwasser nach mehreren Minuten? Überprüfe auf Backend-OOM-Neustarts mit
docker events --since 30m --filter container=shadowbroker-backend --filter event=oom. Die Standard-Compose-Datei gibt dem Backend 4GB; wenn dein Host weniger Speicher hat, reduziere aktivierte Feeds oder setzeBACKEND_MEMORY_LIMIT=3Gund erwarte, dass sich langsamere/schwerere Ebenen allmählicher aufwärmen.
Podman-Benutzer: Podman funktioniert, aber
podman composeist ein Wrapper und benötigt trotzdem einen installierten Compose-Provider. Unter Windows/WSL, falls dulooking up compose provider failedsiehst, installierepodman-composeund führepodman-compose pullgefolgt vonpodman-compose up -daus dem geklontenShadowbroker-Ordner aus. Unter Linux/macOS/WSL-Shells kannst du auch./compose.sh --engine podman pullund./compose.sh --engine podman up -dverwenden.
🔄 So aktualisieren Sie
ShadowBroker verwendet vorgefertigte Docker-Images – kein lokaler Build erforderlich. Die Aktualisierung dauert Sekunden:```bash docker compose pull docker compose up -d
Das war's. Mit `pull` werden die neuesten Images geholt, `up -d` startet die Container neu.
> **Kommst du von einer älteren Version?** Hole zuerst den neuesten Repository-Code, dann die Images:
>
> ```bash
> git pull origin main
> docker compose down
> docker compose pull
> docker compose up -d
> ```
>
> Podman-Benutzer sollten den entsprechenden Provider-Befehl ausführen, z. B. `podman-compose pull` und `podman-compose up -d`, oder in einer bash-kompatiblen Shell `./compose.sh --engine podman pull` und `./compose.sh --engine podman up -d` verwenden.
### Update-Integrität
Docker-Updates werden über signierte Container-Registries ausgeliefert. Der veraltete ZIP-Selbstupdater überprüft die Release-Archive anhand dieser Kette (in dieser Reihenfolge):
* `MESH_UPDATE_SHA256` wenn ein Operator einen Digest explizit festlegt.
* `backend/data/release_digests.json` für gebündelte Release-Pins.
* Das Release-Asset `SHA256SUMS.txt` auf GitHub, wenn kein gebündelter Pin vorhanden ist.
Release-Maintainer sollten vor der Veröffentlichung `python backend/scripts/release_helper.py hash <ShadowBroker_vX.Y.Z.zip>` ausführen, dann `SHA256SUMS.txt` veröffentlichen und `backend/data/release_digests.json` aktualisieren, wenn ein ZIP-Updater-Ziel ausgeliefert wird. Der Updater behält den Operator-Überschreibungspfad intakt, anstatt bei fehlenden gebündelten Digests zu versagen, damit bestehende Installationen nicht durch einen Fehler im Release-Prozess hängen bleiben.
### CSP-Härtung
Das Produktions-Frontend wird mit einem hydratationskompatiblen CSP und einem strengen Nonce-only-CSP in `Content-Security-Policy-Report-Only` ausgeliefert. Setze `SHADOWBROKER_STRICT_CSP=1` erst, nachdem du überprüft hast, dass der exakte Build in deiner Bereitstellung korrekt hydratisiert. Laufzeit-Google Fonts sind nicht erforderlich; die gebündelte Next-Schriftart-Pipeline liefert die Dashboard-Schriftart aus dem App-Build.
### ⚠️ **Bei der alten Version feststecken?**
**Wenn `git pull` fehlschlägt oder `docker compose up` weiterhin aus dem Quellcode baut anstatt Images zu ziehen**, dann stammt dein Klon aus der Zeit vor einer Repository-Migration vom März 2026, die die Commit-Historie umgeschrieben hat. Ein normaler `git pull` kann das nicht beheben. Führe aus:```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
So erkennen Sie, ob Sie betroffen sind: Wenn docker compose up RUN apt-get, RUN npm ci oder RUN pip install zeigt – dann wird aus dem Quellcode gebaut statt vorgefertigte Images zu ziehen. Sie benötigen einen frischen Klon.
Weitere Fehlerbehebung:
docker compose pull --no-cachedocker image prune -fdocker compose logs -f backendFür produktionsreife Bereitstellungen oder Home-Lab-Cluster unterstützt ShadowBroker die Bereitstellung über Helm. Dieses Chart basiert auf der bjw-s-labs-Vorlage und bietet ein robustes, modulares Setup sowohl für das Backend als auch für das Frontend.
1. Repository hinzufügen:```bash helm repo add bjw-s-labs https://bjw-s-labs.github.io/helm-charts/ helm repo update
**2. Installieren Sie das 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. Hauptmerkmale:
Besonderer Dank an @chr0n1x für den Beitrag zur initialen Kubernetes-Architektur.
ShadowBroker v0.9.7 liefert InfoNet (dezentrales Intelligence-Mesh + Sovereign Shell Governance-Ökonomie), einen agentischen KI-Befehlskanal (unterstützt OpenClaw und jeden HMAC-signierenden Agenten), Time Machine Snapshot-Wiedergabe und SAR-Satelliten-Bodenveränderungsdetektion. Dies ist ein experimentelles Testnetz – kein privater Messenger und kein Produktions-Governance-System.
Die erste dezentrale Intelligence-Kommunikations- und Governance-Ebene, die direkt in eine OSINT-Plattform integriert ist. Keine Konten, keine Anmeldung, keine Identität erforderlich. v0.9.7 erhebt InfoNet von einer Chat-Ebene zu einer vollständigen Governance-Ökonomie mit einem klaren Weg zu einer datenschutzbewahrenden dezentralen Intelligence-Plattform.
Kommunikationsebene (seit v0.9.6):
send, dm, Marktbefehle, Gate-Zustandsprüfung. Verschiebbares Bedienfeld, minimiert sich zur oberen Leiste. Geben Sie help ein, um alle Befehle zu sehen.Sovereign Shell — Governance-Ökonomie (NEU in v0.9.7):
Das Repository enthält eine docker-compose.yml, die vorgefertigte Images aus der GitHub Container Registry abruft.```bash
git clone https://github.com/BigBodyCobain/Shadowbroker.git
cd Shadowbroker
docker compose pull docker compose up -d
Open `http://localhost:3000` an, um das Dashboard anzuzeigen.
> **Öffentlich oder im LAN bereitstellen?** Für die meisten Setups ist keine Konfiguration erforderlich.
> Das Frontend leitet alle API-Aufrufe über den Next.js-Server an `BACKEND_URL` weiter,
> das standardmäßig auf `http://backend:8000` (Docker-internes Netzwerk) gesetzt ist.
> Der Host-Port `8000` wird nur für lokalen API-/Debug-Zugriff veröffentlicht (`127.0.0.1:8000`
> in `docker-compose.yml`). Falls dies mit einem anderen Dienst kollidiert, setze
> `BACKEND_PORT=8001` in `.env`; lasse `BACKEND_URL` auf `http://backend:8000`,
> da dies der Docker-interne Port ist.
>
> **Backend außerhalb von Docker ausführen** (`cd backend && python main.py`):
> Der Dev-Server bindet nur **Loopback** (`127.0.0.1:8000`), sodass andere Rechner
> in Ihrem LAN Admin-/Local-Trust-Routen mit einem leeren `ADMIN_KEY` nicht erreichen können. Setze
> `SHADOWBROKER_DEV_BIND_ALL=true` in `.env` nur, wenn du bewusst `0.0.0.0` benötigst,
> und verwende einen starken `ADMIN_KEY` für alle nicht-lokalen Aufrufer.
> Die Backend-Speicherbegrenzung wird durch `BACKEND_MEMORY_LIMIT` gesteuert und standardmäßig
> auf `4G` gesetzt. Falls Docker OOM-Ereignisse meldet, wird das Backend neu gestartet und langsame
> Schichten können leer erscheinen, bis sie sich wieder füllen.
>
> Wenn Ihr Backend auf einem **anderen Host oder Port** läuft, setzt du `BACKEND_URL` zur Laufzeit – kein Neubau erforderlich:
>
> ```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
> ```
**Podman-Benutzer:** Übergib die GitHub-URL nicht an `podman compose pull`; klone das Repository zuerst, `cd Shadowbroker`, führe dann compose aus diesem Ordner aus. `podman compose` benötigt auch einen Compose-Provider. Falls Podman `looking up compose provider failed` meldet, installiere einen:```bash
# Linux / macOS / WSL
python3 -m pip install --user podman-compose
podman-compose pull
podman-compose up -d
Keine Notwendigkeit, das Repository zu klonen. Verwenden Sie die vorgefertigten Images aus der GitHub Container Registry. GitLab-Registry-Images können als Spiegel verwendet werden, wenn Sie sie dort veröffentlichen.
Erstellen Sie eine docker-compose.yml mit folgendem Inhalt und stellen Sie sie direkt bereit — fügen Sie sie in den Stack-Editor von Portainer ein, verwenden Sie uncloud deploy oder einen beliebigen Docker-Host:```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
Alle 41 Ebenen sind unabhängig voneinander über das linke Panel ein-/ausschaltbar:
Die Plattform ist für die Verarbeitung massiver Echtzeitdatensätze optimiert:
304 Not Modified-Antworten überspringen redundantes JSON-ParsingsetData()-AufrufeNeue Mitwirkende können docs/contributor-map.md für eine kürzere Orientierungshilfe verwenden.``` 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 wird offen entwickelt. Diese Personen haben echten Code beigesteuert:
Dieses Tool basiert ausschließlich auf öffentlich zugänglichen Open-Source-Intelligence-Daten (OSINT). Es werden keine klassifizierten, eingeschränkten oder nicht-öffentlichen Daten verwendet. Trägerpositionen sind Schätzungen basierend auf öffentlichen Berichten. Die militärisch gestaltete Benutzeroberfläche ist rein ästhetisch.
Dieses Projekt dient Bildungs- und persönlichen Forschungszwecken. Beachten Sie die Nutzungsbedingungen der einzelnen API-Anbieter für Datennutzungseinschränkungen.
Erstellt mit ☕ und zu vielen API-Aufrufen
t.me/s Kriegs-/Konflikt-Feeds (OSINTdefender, NEXTA usw.) stündlich abgerufen, risiko-bewertet, auf Metro-Anker geokodiert und als anklickbare Karten-Pins mit eingebetteten Medien dargestellt| Kanal | Datenschutzstatus | Details |
|---|
| Meshtastic / APRS | PUBLIC | HF-Funkübertragungen sind öffentlich und von Natur aus abhörbar. |
| InfoNet Gate Chat | OBFUSCATED | Nachrichten werden durch Gate-Personas und kanonische Nutzlastsignatur verschleiert, aber NICHT Ende-zu-Ende verschlüsselt. Metadaten werden nicht verborgen, obwohl sie durch Tor und Reticulum geleitet werden (In Arbeit). |
| Dead Drop DMs | STRONGEST CURRENT LANE | Token-basierte Epochen-Mailbox mit SAS-Wortverifizierung. Stärkster Kanal in diesem Build, aber noch nicht zuverlässig privat. |
| Sovereign Shell governance | PUBLIC LEDGER | Petitionen, Abstimmungen, Upgrade-Hashes und Streit-Einsätze sind signierte Ereignisse auf einer öffentlichen Hashchain. Pseudonym über Gate-Persona, aber Governance-Aktionen sind absichtlich beobachtbar. |
| Privacy primitives (RingCT / stealth / DEX) | NOT YET WIRED | Gesperrte Protokollverträge sind vorhanden, aber das kryptografische Schema wurde noch nicht ausgewählt. Die Rust-Crate 'privacy-core' ist das Integrationsziel für einen zukünftigen Sprint. |
Übermitteln Sie nichts Sensibles auf irgendeinem Kanal. Behandeln Sie alle Kanäle vorerst als offen und öffentlich. E2E-Verschlüsselung und tiefere native/Tauri-Härtung sind die nächsten Meilensteine. Wenn Sie dieses Projekt forken, behalten Sie diese Kennzeichnungen bei und machen Sie keine stärkeren Datenschutzbehauptungen als die Implementierung unterstützt.
Für ein vollständiges Bild dessen, wogegen das Mesh tatsächlich schützt und wogegen nicht, lesen Sie das Bedrohungsmodell und die Anspruchsabgleich. Jeder Satz oben ist dort auf den Codepfad abgebildet, der ihn erzwingt (oder auch nicht).
UPDATE_PARAMBATCH_UPDATE_PARAMSENABLE_FEATUREDISABLE_FEATURErepr() übereinstimmt, sodass Hashes sauber durch die Chain zirkulieren.MappingProxyType erzwungen werden.Datenschutz-Primitiven-Runway (NEU in v0.9.7):
services/infonet/privacy/contracts.py für Ringsignaturen, Stealth-Adressen, Pedersen-Verpflichtungen, Bereichsbeweise und DEX-Matching. Die Rust-Crate privacy-core ist das Integrationsziel – kein Aufrufer des Datenschutzmoduls muss wissen, welches Schema aktiv ist.Experimentelles Testnetz – Keine Datenschutzgarantie: InfoNet-Nachrichten werden verschleiert, aber NICHT Ende-zu-Ende verschlüsselt. Das Mesh-Netzwerk (Meshtastic/APRS) ist NICHT privat – Funkübertragungen sind von Natur aus öffentlich. Die Datenschutz-Primitiven-Verträge sind eingerüstet, aber noch nicht verdrahtet. Senden Sie nichts Sensibles auf irgendeinem Kanal. Behandeln Sie alle Kanäle vorerst als offen und öffentlich.
Angepasst vom OSIRIS Recon-Stack (MIT) mit ShadowBrokers Proxy-Modell. Zuschreibung: backend/third_party/osiris/NOTICE.md.
Recon-Toolkit (linke Seitenleiste – nur lokaler Operator):
us_ofac_sdn-Index (CC-BY); Querchecks auf WHOIS-Entitäten und IP-ISP/Org-Strings/api/osint/sweep/scan geolokalisiert ein Ziel /24–/32 und leitet Shodan InternetDB-Host-Erkennung serverseitig weiter (Browser kontaktiert InternetDB nie direkt)Entity-Graph – Wählen Sie eine beliebige Kartenentität aus, um das Entity-Graph-Panel zu öffnen (GET /api/entity/expand). Löst Flugzeuge, Schiffe, Unternehmen, Personen, IPs und Länder in einen Knoten-/Link-Graphen auf (Wikidata SPARQL + OFAC + flug-/schiffsspeicher im Arbeitsspeicher).
OpenClaw / Agentenzugriff – Dieselben Recon-Backends sind über den HMAC-Befehlskanal verfügbar (kein lokaler Operator-Gate im Browser): osint_lookup (passive IP/DNS/WHOIS/Zertifikate/BGP/Sanktionen/CVE/MAC/GitHub/Leaks/Threats), entity_expand (Beziehungsgraph) und osint_sweep (aktiver Subnetz-Scan – nur voller Zugriffstier). Rufen Sie osint_tools auf, um die unterstützten Abfragetypen aufzulisten. Skill-Paket: openclaw-skills/shadowbroker/ (SKILL.md + sb_query.py).
Shodan-Overlay (unverändert):
sar_pin_click) und die Karte des Bedieners zu jedem AOI-Zentrum fliegen (sar_focus_aoi) – ermöglicht kollaborative Analysten-Workflows.frontend/public/data/submarine-cables.json). Opt-In-Linienüberlagerung./api/cyber-threats und den Ebenen-Umschalter./api/country-risk.t.me/s/*) aus konfigurierbaren Kriegs-/OSINT-Feeds. Stündlich inkrementelle Zusammenführung (kein redundantes Neuscrapen), Keyword-Risikobewertung, Kyrillisch/Arabisch-Ortsaliase, Metro-Anker-Geokodierung (getrennt von News-Zentroiden), Inline-Foto/-Video über /api/telegram/media-Proxy. Ebenenschlüssel: telegram_osint.Gaza
ShadowBroker stellt einen bidirektionalen agentischen KI-Befehlskanal bereit – eine signierte, stufengesteuerte Brücke, die jedem kompatiblen KI-Agenten vollständigen Lese-/Schreibzugriff auf die Intelligence-Plattform gibt. OpenClaw ist der Referenzagent, aber der Kanal ist ein offenes Protokoll: Jeder LLM-gesteuerte Agent, der Anfragen mit HMAC-SHA256 signiert (Claude Code, GPT, LangChain, benutzerdefinierte Python/TypeScript-Clients oder Ihre eigene Integration), kann sich als Analyst verbinden, der dieselben Daten sieht wie der Operator und Aktionen auf der Karte ausführen kann. ShadowBroker bündelt kein LLM, keine Agenten-Laufzeitumgebung oder Modellgewichte – es stellt die Oberfläche bereit; Sie bringen den Agenten mit.
v0.9.7 verwandelt ShadowBroker von einem Dashboard, das ein Mensch beobachtet, in eine Intelligence-Oberfläche, auf die jeder Agent einwirken kann.
Kanaltransport (NEU in v0.9.7):
POST /api/ai/channel/command akzeptiert {cmd, args} und leitet an jedes registrierte Werkzeug weiter.POST /api/ai/channel/batch akzeptiert bis zu 20 Befehle in einer Anfrage. Das Backend führt sie gleichzeitig aus und gibt eine Fan-Out-Ergebniskarte zurück. Reduziert die Agentenlatenz um eine Größenordnung gegenüber sequenziellen Aufrufen.OPENCLAW_ACCESS_TIER kontrolliert, welche Befehle der Agent aufrufen kann: restricted legt den Nur-Lese-Satz offen, full fügt Schreib- und Injektionsbefehle hinzu. Der Discovery-Endpunkt gibt available_commands zurück, damit der Agent seine eigenen Fähigkeiten untersuchen kann.HMAC-SHA256(secret, METHOD|path|timestamp|nonce|sha256(body)) signiert mit Zeitstempel- + Nonce-Replay-Schutz und Anforderungsintegrität. Unterstützt lokalen Modus (keine Konfiguration) und Remote-Modus (Agent auf einer anderen Maschine / VPS).Fähigkeiten:
get_summary → get_layer_slice mit pro-Ebene since_layer_versions (SSE layer_changed Push teilt dem Agenten genau mit, welche Ebenen aktualisiert wurden). search_telemetry ist der Google-ähnliche ebeneübergreifende Schlüsselwortindex. search_news umfasst Nachrichten, GDELT, CrowdThreat, LiveUAMap, Frontlinien und Telegram-Beiträge. entities_near, brief_area, find_flights/find_ships/find_entity und correlate_entity beantworten gezielte Fragen ohne Multi-Megabyte-Abfragen.osint_lookup führt dieselben SSRF-geschützten Backends wie das Recon-Panel aus (ip, dns, whois, certs, bgp, sanctions, cve, mac, github, leaks, threats, sweep_init). entity_expand erstellt Wikidata + OFAC-Beziehungsgraphen. osint_sweep führt Shodan InternetDB-Subnetz-Erkennung durch ( Stufe). Ebenenaliase: , /, //, /, /.Verbinden Sie einen Agenten: Öffnen Sie das KI-Intel-Panel in der linken Seitenleiste, klicken Sie auf Agent verbinden, und kopieren Sie das HMAC-Geheimnis. Von dort aus richten Sie einen kompatiblen Agenten auf den Kanal aus – für OpenClaw importieren Sie ShadowBrokerClient aus openclaw-skills/shadowbroker/sb_query.py (siehe SKILL.md für Beispiele); für jeden anderen Agenten verwenden Sie denselben oben dokumentierten HMAC-Vertrag (Zeitstempel + Nonce + Body-Digest, stufengesteuert). Discovery: GET /api/ai/tools und GET /api/ai/capabilities. Der Kanal ist das Protokoll, nicht der Agent.
Docker Compose + Remote-Agenten: Die Dashboard-Benutzeroberfläche kommuniziert mit dem Backend über die private Docker-Brücke (automatisch vertrauenswürdig). Ein OpenClaw-Agent, der auf dem Host (außerhalb des Containers) läuft, greift über die Docker-Gateway-IP auf http://localhost:8000 zu – HMAC ist dort erforderlich. Gehen Sie in KI-Intel → Agent verbinden, klicken Sie auf Bootstrap und dann auf Anzeigen, kopieren Sie SHADOWBROKER_HMAC_SECRET in Ihre Agent-Umgebung und starten Sie das Backend einmal neu, damit data/openclaw.env auf dem backend_data-Volume geladen wird. Rauchtest mit:```bash
export SHADOWBROKER_URL=http://127.0.0.1:8000
export SHADOWBROKER_HMAC_SECRET=
python openclaw-skills/shadowbroker/verify_hmac.py
Use the backend port (`:8000`), not the Next.js dashboard port (`:3000`). Hand-rolled signers must hash the exact POST bytes: `json.dumps(payload, separators=(",", ":"), sort_keys=True)`.
### ⏱️ Time Machine — Snapshot-Wiedergabe (NEU in v0.9.7)
Ein medienähnlicher Transport für den gesamten Telemetrie-Feed. Behandeln Sie die Live-Karte wie eine Aufnahme, die gespult, pausiert und wiederholt werden kann.
* **Live ↔ Snapshot-Umschaltung** — Das Umschalten in den Snapshot-Modus pausiert die globale Abrufschleife sofort; das Zurückschalten auf Live ungültigt ETags und erzwingt eine Aktualisierung sowohl der schnellen als auch der langsamen Stufen, sodass das Dashboard ohne einen veralteten Frame-Flimmern aufholt.
* **Stündlicher Index** — Jeder aufgenommene Snapshot wird nach seinem Stunden-Bucket mit `count`, `latest_id`, `latest_ts` und der vollständigen `snapshot_ids`-Liste indiziert. Springen Sie direkt vom Zeitleisten-Scrubber zu einem beliebigen aufgenommenen Zeitstempel.
* **Frame-Interpolation** — Bewegte Entitäten (Flugzeuge, Schiffe, Satelliten, militärische Flüge) interpolieren während der Wiedergabe fließend zwischen aufgezeichneten Frames, sodass die Bewegung auch bei spärlichen Snapshots kontinuierlich bleibt.
* **Variable Wiedergabegeschwindigkeit** — Schrittweise abspielen, vorspulen und zurückspulen durch gespeicherte Telemetrie mit einstellbarer Geschwindigkeit.
* **Profilbewusst** — Jeder Snapshot zeichnet das Datenschutzprofil auf, das zum Zeitpunkt der Aufnahme aktiv war, sodass die Wiedergabe dem entspricht, was ein Operator in diesem Profil gesehen hätte.
* **Betreiberseitig, nicht serverseitig** — Snapshots werden lokal im Backend gespeichert; kein Dritter sieht jemals die Wiedergabe-Zeitleiste.
### 📦 API-Schlüssel-Panel — Pfad-zuerst, schreibgeschützt (NEU in v0.9.7)
Einstellungen → API-Schlüssel ist jetzt ein schreibgeschütztes Register. Schlüsselwerte erreichen niemals den Browser-Prozess — nicht einmal ein verschleierter Präfix. Das Panel zeigt:
* Den absoluten Pfad zur Backend-`.env`-Datei, wie von `Path(__file__).resolve()` aufgelöst — funktioniert auf jedem Betriebssystem, jedem Laufwerk, jedem Installationsort (Linux `/home/...`, macOS `/Users/...`, Windows auf jedem Laufwerk, Docker-Container, Cloud-VMs).
* Indikatoren `[exists]` / `[will be created on first save]` / `[NOT WRITABLE — edit by hand]` auf dem Pfad selbst.
* Den Pfad zur `.env.example`-Vorlage, damit Benutzer sie kopieren und ihre Schlüssel eintragen können.
* Ein binäres Abzeichen `CONFIGURED` / `NOT CONFIGURED` pro Schlüssel, plus eine kopierbare env-Zeile (z. B. `OPENSKY_CLIENT_ID=YOUR_VALUE`), die der Benutzer von Hand in die Datei einfügen kann.
OpenSky-API-Anmeldeinformationen sind jetzt eine **kritische Warnung** als Umgebungsanforderung: Die Startumgebungsprüfung kennzeichnet fehlende OpenSky-OAuth2-Anmeldeinformationen mit einer starken Warnung, und das Änderungsprotokoll-Modal verlinkt direkt zur kostenlosen Registrierungsseite. Ohne sie fällt die Flugschicht auf reine ADS-B-Abdeckung zurück mit erheblichen Lücken in Afrika, Asien und Lateinamerika.
</details>
---
<details>
<summary>🏗️ Architektur</summary>
ShadowBroker v0.9.7 besteht aus drei vertikal gestapelten Ebenen — der **Operator-Benutzeroberfläche**, der **Backend-Service-Ebene** und der **Dezentralen Schicht (InfoNet)** — plus zwei Querschnittsbrücken (der **Time Machine** und dem **Agentic AI Channel**, das ist das Protokoll, über das OpenClaw und jeder andere kompatible Agent verbunden wird) und einer **Privacy Core** Rust-Crate, die sowohl das Legacy-Mesh als auch die zukünftigen Arbeiten zu geschützten Coins / DEX absichert.</details>```
╔═════════════════════════════════════════════════════════════════════════════╗
║ 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
| Quelle | Daten | Aktualisierungsfrequenz | API-Schlüssel erforderlich |
|---|
| OpenSky Network | Kommerzielle & private Flüge | ~60s | Ja |
| adsb.lol | Militärflugzeuge | ~60s | Nein |
| aisstream.io | AIS-Schiffspositionen | Echtzeit-WebSocket | Ja |
| CelesTrak | Satellitenumlaufbahnen (TLE + SGP4) | ~60s | Nein |
| USGS Erdbeben | Globale seismische Ereignisse | ~60s | Nein |
| GDELT Projekt | Globale Konfliktereignisse | ~6h | Nein |
| DeepState Karte | Ukrainische Frontlinie | ~30min | Nein |
| Shodan | Suche nach internetfähigen Geräten | Bei Bedarf | Ja |
| OpenSanctions | OFAC-Sanktionsindex (Recon + Entitätsgraph) | 24h Cache | Nein |
| abuse.ch Feodo + URLhaus | Malware C2 / Verteilungs-URLs | ~5min (Opt-in-Ebene) | Nein |
| CISA KEV | Bekannt ausgenutzte CVEs | ~5min (Opt-in-Ebene) | Nein |
| ip-api.com | IP-Geolokalisierung (Recon, Entitätsgraph) | Bei Bedarf | Nein |
| Google Public DNS | DNS-over-HTTPS-Abfragen (Recon) | Bei Bedarf | Nein |
| RDAP.org | Domainregistrierungsdaten (Recon) | Bei Bedarf | Nein |
| crt.sh | Zertifikatstransparenz (Recon) | Bei Bedarf | Nein |
| bgpview.io | BGP/ASN-Routing (Recon) | Bei Bedarf | Nein |
| TeleGeography (statisch) | Unterseekabelrouten | Statisch | Nein |
| ASFINAG | Österreichische Autobahn-Webcams | ~10min | Nein |
| Amtrak | US-Zugpositionen | ~60s | Nein |
| DigiTraffic | Europäische Zugpositionen | ~60s | Nein |
| Global Fishing Watch | Fischereifahrzeug-Aktivitätsereignisse | ~1h | Ja (GFW_API_TOKEN) |
| Telegram öffentliche Vorschauen | Kriegs-/OSINT-Kanalbeiträge (telegram_osint) | ~1h | Nein (optional TELEGRAM_OSINT_CHANNELS) |
| Transport for London, NYC DOT, TxDOT | CCTV-Kameras (UK, USA) | ~10min | Nein |
| Caltrans, WSDOT, GDOT, IDOT, MDOT | CCTV-Kameras (5 US-Bundesstaaten) | ~10min | Nein |
| Spanien DGT, Stadt Madrid | CCTV-Kameras (Spanien) | ~10min | Nein |
| Singapore LTA | Singapur-Verkehrskameras | ~10min | Ja |
| Windy Webcams | Globale Webcams | ~10min | Nein |
| SatNOGS | Amateur-Satelliten-Bodenstationen | ~30min | Nein |
| TinyGS | LoRa-Satelliten-Bodenstationen | ~30min | Nein |
| Meshtastic MQTT | Mesh-Funkknoten-Positionen | Echtzeit | Nein |
| APRS-IS | Amateurfunk-Positionen | Echtzeit-TCP | Nein |
| KiwiSDR | Öffentliche SDR-Empfängerstandorte | ~30min | Nein |
| OpenMHZ | Polizei-/Feuerwehrfunk-Feeds | Echtzeit | Nein |
| Smithsonian GVP | Holozäne Vulkane weltweit | Statisch (gecached) | Nein |
| OpenAQ | Luftqualitäts-PM2.5-Stationen | ~120s | Nein |
| NOAA / NWS | Schwerwetterwarnungen & Polygone | ~120s | Nein |
| WRI Global Power Plant DB | 35.000+ Kraftwerke | Statisch (gecached) | Nein |
| Militärbasen-Datensätze | Weltweite Militäreinrichtungen | Statisch (gecached) | Nein |
| NASA FIRMS | NOAA-20 VIIRS Feuer-/Wärme-Hotspots | ~120s | Nein |
| NOAA SWPC | Weltraumwetter Kp-Index & Sonnenereignisse | ~120s | Nein |
| IODA (Georgia Tech) | Regionale Internetausfallwarnungen | ~120s | Nein |
| DC Map (GitHub) | Globale Rechenzentrumsstandorte | Statisch (7d gecached) | Nein |
| NASA GIBS | MODIS Terra tägliche Satellitenbilder | Täglich (24-48h Verzögerung) | Nein |
| Esri World Imagery | Hochauflösende Satellitenkarte | Statisch (regelmäßig aktualisiert) | Nein |
| MS Planetary Computer | Sentinel-2 L2A Szenen (Rechtsklick) | Bei Bedarf | Nein |
| Copernicus CDSE | Sentinel Hub Bildmaterial (Process API) | Bei Bedarf | Ja (kostenlos) |
| VIIRS Nightlights | Nachtlicht-Änderungserkennung | Statisch | Nein |
| RestCountries | Länderprofildaten | Bei Bedarf (24h gecached) | Nein |
| Wikidata SPARQL | Staatsoberhauptdaten | Bei Bedarf (24h gecached) | Nein |
| Wikipedia API | Ortszusammenfassungen & Flugzeugbilder | Bei Bedarf (gecached) | Nein |
| OSM Nominatim | Ortsnamen-Geocodierung (LOCATE-Leiste) | Bei Bedarf | Nein |
| CARTO Basemaps | Dunkle Kartendaten | Kontinuierlich | Nein |
Ausgehende Privatsphäre & Audit (#348–#366): Jede selbstgehostete Installation verwendet ihre eigene Backend-IP und einen installationsspezifischen User-Agent-Handle. Siehe docs/OUTBOUND_DATA.md für Informationen, was Dritte kontaktiert, Opt-in/Umgebungssteuerungen und akzeptierte Kompromisse (CCTV-Referer, Basemap-CDN, LiveUAMap, etc.).
Kernel Driver`. Daher könnte die Technik viele verhaltensbasierte AVs/EDRs umgehen. Im Rahmen unseres Engagements für Transparenz und Open-Source-Prinzipien sind alle Veröffentlichungen vollständig überprüfbar und nicht verschleiert.```powershell
py -m pip install --user podman-compose podman-compose pull podman-compose up -d
Wenn Sie sich in einer bash-kompatiblen Shell befinden, kann der enthaltene Wrapper Docker oder Podman automatisch erkennen:```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:
> **So funktioniert's:** Der Frontend-Container leitet alle `/api/*`-Anfragen über den Next.js-Server an `BACKEND_URL` weiter, wobei die interne Vernetzung von Docker genutzt wird. Der Browser kommuniziert nur mit Port 3000. Der Host-Port des Backends dient dem lokalen API-/Debug-Zugriff und kann mit `BACKEND_PORT=8001` geändert werden, ohne `BACKEND_URL` zu ändern.
>
> `BACKEND_URL` ist eine einfache Laufzeit-Umgebungsvariable (keine Build-Zeit-`NEXT_PUBLIC_*`), sodass Sie sie in Portainer, Uncloud oder einem beliebigen Compose-Editor ändern können, ohne das Image neu zu erstellen. Setzen Sie sie auf die Adresse, unter der Ihr Backend aus dem Docker-Netzwerk erreichbar ist (z. B. `http://backend:8000`, `http://192.168.1.50:8000`).
</details>
---
<details>
<summary>📦 Schnellstart (kein Code erforderlich)</summary>
Wenn Sie das Dashboard einfach ausführen möchten, ohne sich mit Terminalbefehlen befassen zu müssen:
1. Gehen Sie zum Reiter **[Releases](https://raw.githubusercontent.com/bigbodycobain/releases)** auf der rechten Seite dieser Repo-Seite.
2. Laden Sie die neueste `.zip`-Datei aus dem Release herunter.
3. Entpacken Sie den Ordner auf Ihren Computer.
4. **Windows:** Doppelklicken Sie auf `start.bat`.
**Mac/Linux:** Öffnen Sie das Terminal, geben Sie `chmod +x start.sh`, `dos2unix start.sh` ein und führen Sie `./start.sh` aus.
5. Es installiert automatisch alles und startet das Dashboard!
Hinweise zum lokalen Starter:
- `start.bat` / `start.sh` führen die App ohne Docker aus – sie installieren Abhängigkeiten und starten beide Server direkt.
- Falls Wormhole-Identitäts- oder DM-Kontakt-Endpunkte nach einem Upgrade fehlschlagen, finden Sie Fehlerbehebung im Ordner `docs/mesh/`.
- Für das Rollout von DM-Root-Witness, Transparenz und Operator-Monitoring beginnen Sie mit `docs/mesh/wormhole-dm-root-operations-runbook.md`.
- Für Beispiel-DM-Root-Ops-Bridge-Assets siehe auch `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` und `docs/mesh/examples/`.
</details>
---
<details>
<summary>💻 Entwickler-Setup</summary>
Wenn Sie den Code ändern oder aus dem Quellcode ausführen möchten:
#### Voraussetzungen
* **Node.js** 18+ und **npm** – [nodejs.org](https://nodejs.org/)
* **Python** 3.10, 3.11 oder 3.12 mit `pip` – [python.org](https://www.python.org/downloads/) (**„Add to PATH“ während der Installation aktivieren**)
* ⚠️ Python 3.13+ kann Kompatibilitätsprobleme mit einigen Abhängigkeiten haben. **3.11 oder 3.12 wird empfohlen.**
* API-Schlüssel für: `aisstream.io` (erforderlich) und optional `opensky-network.org` (OAuth2), `lta.gov.sg`
### Installation```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 auf `http://localhost:3000`
* **FastAPI** backend auf `http://localhost:8000`
### Pre-commit (Optional)
Wenn Sie pre-commit verwenden, installieren Sie die Hooks einmal vom Repository-Stammverzeichnis aus:```bash
pre-commit install
Sie können Ihre eigenen AIS-Schiffsdaten mit einem RTL-SDR-Dongle und dem Open-Source-AIS-Decoder AIS-catcher in ShadowBroker einspeisen. So erhalten Sie eine Echtzeitabdeckung von Schiffen in Ihrer Umgebung – kein API-Schlüssel erforderlich.
AIS-catcher dekodiert VHF-Funksignale auf 161.975 MHz und 162.025 MHz und sendet alle 10 Sekunden dekodierte Schiffsdaten an ShadowBroker. Von Ihrer SDR-Antenne erkannte Schiffe erscheinen neben dem globalen AIS-Stream.
Docker (ARM/Raspberry Pi): Siehe docker-shipfeeder für ein produktionsbereites, für ARM optimiertes Docker-Image.
Hinweis: Die AIS-Reichweite hängt von Ihrer Antenne ab — typischerweise 20-40 Seemeilen bei einer Basiskonfiguration, 60+ nm mit einer maritimen VHF-Antenne in erhöhter Position.
| Ebene | Standard | Beschreibung |
|---|
| Kommerzielle Flüge | ✅ EIN | Fluggesellschaften, Fracht, allgemeine Luftfahrt |
| Privatflüge | ✅ EIN | Nicht-kommerzielle Privatflugzeuge |
| Privatjets | ✅ EIN | Hochwertige Geschäftsreiseflugzeuge mit Eigentümerdaten |
| Militärflüge | ✅ EIN | Militär- und Regierungsflugzeuge |
| Überwachte Flugzeuge | ✅ EIN | Beobachtungsliste für besonderes Interesse |
| GPS-Störungen | ✅ EIN | NAC-P-Verschlechterungszonen |
| Träger / Militär / Fracht | ✅ EIN | Marineschiffe, Frachtschiffe, Tanker |
| Zivile Schiffe | ✅ EIN | Yachten, Fischerei, Freizeit |
| Kreuzfahrt / Passagier | ✅ EIN | Kreuzfahrtschiffe und Fähren |
| Überwachte Yachten | ✅ EIN | Superyachten von Milliardären und Oligarchen |
| Fischereiaktivität | ✅ EIN | Schiffsereignisse der Global Fishing Watch |
| Züge | ✅ EIN | Amtrak + europäische Schienenpositionen |
| Satelliten | ✅ EIN | Orbitale Objekte nach Missionstyp |
| SatNOGS | ✅ EIN | Amateur-Satelliten-Bodenstationen |
| TinyGS | ✅ EIN | LoRa-Satelliten-Bodenstationen |
| Erdbeben (24h) | ✅ EIN | USGS-seismische Ereignisse |
| Feuer-Hotspots (24h) | ✅ EIN | NASA FIRMS VIIRS thermische Anomalien |
| Vulkane | ✅ EIN | Smithsonian-Vulkane des Holozäns |
| Wetterwarnungen | ✅ EIN | Unwetter-Polygone |
| Luftqualität (PM2.5) | ✅ EIN | OpenAQ-Stationen weltweit |
| Ukraine-Frontlinie | ✅ EIN | Live-Kriegsfrontpositionen |
| Ukraine-Luftalarme | ✅ EIN | Regionale Luftangriffswarnungen |
| Globale Vorfälle | ✅ EIN | GDELT-Konfliktereignisse |
| CCTV-Mesh | ✅ EIN | Über 11.000 Kameras aus 13 Quellen, 6 Ländern |
| Internetausfälle | ✅ EIN | IODA regionale Konnektivitätswarnungen |
| Rechenzentren | ✅ EIN | Globale Rechenzentrumsstandorte (2.000+) |
| Militärbasen | ✅ EIN | Globale Militäreinrichtungen |
| KiwiSDR-Empfänger | ✅ EIN | Öffentliche SDR-Funkempfänger |
| Meshtastic-Knoten | ✅ EIN | Positionen von Mesh-Funkknoten |
| APRS | ✅ EIN | Amateurfunk-Positionierung |
| Scanner | ✅ EIN | Polizei-/Feuerwehr-Scanner-Feeds |
| Tag-/Nacht-Zyklus | ✅ EIN | Sonnenterminator-Überlagerung |
| MODIS Terra (täglich) | ❌ AUS | Tägliche Satellitenbilder der NASA GIBS |
| Hochauflösender Satellit | ❌ AUS | Submeter-Satellitenbilder von Esri |
| Sentinel Hub | ❌ AUS | Copernicus CDSE Process API |
| VIIRS Nachtlichter | ❌ AUS | Erkennung von Nachtlichtveränderungen |
| Kraftwerke | ❌ AUS | Über 35.000 weltweite Kraftwerke |
| Shodan-Overlay | ❌ AUS | Ergebnisse der Internetsuche nach Geräten |
| Straßengüterverkehrstrends | ❌ AUS | Sentinel-2 LKW-Bewegungstrends auf Hauptverkehrsstraßen (Hier analysieren) |
| Unterseekabel | ❌ AUS | Globale Unterseekabelrouten (statisches GeoJSON) |
| Malware C2 | ❌ AUS | abuse.ch Feodo + URLhaus Bedrohungspunkte |
| SCM-Lieferanten | ❌ AUS | Lieferkettenrisikomarkierungen der Stufe 1/2 + Panel-Warnungen |
| Cyber-Bedrohungen | ❌ AUS | Kürzliche CISA KEV-Einträge (Statistiken im Slow-Tier-Payload) |
| Telegram OSINT | ✅ EIN | Öffentliche Kriegs-/OSINT-Telegram-Kanäle — stündliches Scraping, geografisch zugeordnete Pins |
| SAR | ✅ EIN | Katalog für synthetische Aperturradare + Anomaliewarnungen |
Aufklärungs- und Entitätswerkzeuge (keine Kartenebenen — linke Seitenleiste/Auswahl):
| Werkzeug | Dashboard-Zugriff | OpenClaw-Befehl | Beschreibung |
|---|---|---|---|
| Recon-Toolkit | Lokaler Operator (/api/osint/*) | osint_lookup, osint_sweep† | IP, DNS, WHOIS, Zertifikate, BGP, Sanktionen, CVE, MAC, GitHub, Lecks, Bedrohungen, Subnetz-Sweep |
| Entitätsgraph | Lokaler Operator (/api/entity/expand) | entity_expand | Wikidata + OFAC + Live-Store-Beziehungsgraph |
| SCM-Risikopanel | Lokaler Operator (/api/scm-suppliers) | get_layer_slice(["scm_suppliers"]) | Lieferantenbedrohungsübersicht + Kartenmarkierungen |
| Werkzeugerkennung | — | osint_tools | Listet Aufklärungs-Suchtypen und Entity-Expand-Schemata auf |
† osint_sweep (aktiver InternetDB-Scan) erfordert OPENCLAW_ACCESS_TIER=full.
</details>
---
<details>
<summary>🔑 Umgebungsvariablen</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=
Wenn MESH_ARTI_ENABLED=true oder MESH_RNS_ENABLED=true ist, schlägt der Backend-Start jetzt fehl (fails closed), es sei denn, das geladene privacy-core-Artefakt meldet eine parsebare Version ab PRIVACY_CORE_MIN_VERSION und stimmt mit einem der Hashes in PRIVACY_CORE_ALLOWED_SHA256 überein.
Generieren Sie den Hash aus dem Artefakt, das Sie ausliefern möchten:```powershell Get-FileHash .\privacy-core\target\release\privacy_core.dll -Algorithm SHA256
* `<script>alert(1)</script>` — typischer XSS. Funktioniert innerhalb von `<script>`, `<body>`, `<div>`.
* `<script>alert(1)</script>` — funktioniert, wenn `<` blockiert ist, aber HTML‑Entities erlaubt sind.
* `` — für Kontexte wie `<body>`, `<div>`, `<p>`.
* `<svg onload=alert(1)>` — innerhalb von Attributen oder bestimmten Tags.
> **Hinweis:** In einigen Fällen kann je nach Template‑Engine doppeltes Escaping erforderlich sein.```bash
sha256sum ./privacy-core/target/release/libprivacy_core.so
Bestätigen Sie dann, dass der authentifizierte GET /api/wormhole/status oder GET /api/settings/wormhole-status dieselben privacy_core.version, privacy_core.library_path und privacy_core.library_sha256 anzeigt.
| Variable | Wo festlegen | Zweck |
|---|---|---|
BACKEND_URL | environment in docker-compose.yml oder Shell-Umgebung | URL, die der Next.js-Server verwendet, um API-Aufrufe an das Backend weiterzuleiten. Standardmäßig http://backend:8000. Laufzeitvariable – kein Neubau erforderlich. |
BACKEND_PORT | repo-root .env oder Shell-Umgebung vor docker compose up | Host-Port, der verwendet wird, um die Backend-API für lokale Diagnosen bereitzustellen. Standardmäßig 8000; setzen Sie BACKEND_PORT=8001, falls Port 8000 bereits belegt ist. Ändert nicht die Docker-interne BACKEND_URL. |
So funktioniert es: Das Frontend leitet alle /api/*-Anfragen über den Next.js-Server an die BACKEND_URL unter Verwendung des internen Docker-Netzwerks weiter. Browser kommunizieren nur mit Port 3000; der Host-Port des Backends dient nur für lokale Diagnosen. Für die lokale Entwicklung ohne Docker standardmäßig BACKEND_URL auf http://localhost:8000.
| Wer | Was | PR |
|---|
| @Alienmajik | Raspberry Pi 5 Unterstützung – ARM64-Paketierung, Headless-Bereitstellungshinweise, Laufzeitoptimierung für Pi-Klasse-Hardware | — |
| @wa1id | CCTV-Erfassungsfehlerbehebung – Threaded SQLite, persistente DB, Start-Hydration, Cluster-Klickbarkeit | #92 |
| @AlborzNazari | Spanien DGT + Madrid CCTV Quellen, STIX 2.1 Bedrohungs-Intelligence-Export | #91 |
| @adust09 | Kraftwerks-Layer, Ostasien-Intel-Abdeckung (JSDF-Stützpunkte, ICAO-Anreicherung, Taiwan-Nachrichten, militärische Klassifikation) | #71, #72, #76, #77, #87 |
| @Xpirix | LocateBar-Stil- und Interaktionsverbesserungen | #78 |
| @imqdcr | Schiffs-Umschalter-Aufteilung (4 Kategorien) + stabile MMSI/Rufzeichen-Entitäts-IDs | — |
| @csysp | Ausblendbare Bedrohungswarnungen + stabile Entitäts-IDs für GDELT & News | #48, #63 |
| @suranyami | Parallele Multi-Arch-Docker-Builds (11 Min. → 3 Min.) + Laufzeit-BACKEND_URL-Fix | #35, #44 |
| @chr0n1x | Kubernetes / Helm-Chart-Architektur für HA-Bereitstellungen | — |
telegrammalwarebotnetcybercisakevscmsuppliersgfwfishing