bigbodycobain/shadowbrokerPlataforma OSINT geoespacial en tiempo real que agrega más de 60 fuentes de telemetría pública (ADS-B, AIS, satélites, CCTV) en un mapa unificado con un kit de reconocimiento del lado del servidor, un canal de agente de IA y comunicaciones descentralizadas en malla.
Intercepción Global de Amenazas — Plataforma de Inteligencia Geoespacial en Tiempo Real
ShadowBroker es una plataforma de inteligencia descentralizada que agrega telemetría OSINT en tiempo real de múltiples dominios desde más de 60 fuentes de inteligencia en vivo en una única interfaz de mapa de operaciones oscuras. Aeronaves, barcos, satélites, zonas de conflicto, redes CCTV, interferencias GPS, dispositivos conectados a internet, escáneres policiales, nodos de radio mesh y eventos geopolíticos de última hora — todo actualizándose en tiempo real en una sola pantalla, así como un protocolo de comunicaciones ofuscado e infraestructura de intercambio de información.
Construido con Next.js, MapLibre GL, FastAPI y Python. Más de 40 capas de datos alternables, incluyendo detección de cambios en el suelo mediante SAR, Telegram OSINT (vistas previas de canales públicos georreferenciadas en el mapa), un kit de herramientas de reconocimiento del lado del servidor (DNS, WHOIS, sanciones, BGP, barrido de IP y más), superposiciones de riesgo de cadena de suministro, y feeds de amenazas cibernéticas de malware/C2 + CISA KEV. Múltiples modos visuales (DEFAULT / SATELLITE / FLIR / NVG / CRT). Haga clic derecho en cualquier punto de la Tierra para obtener un dossier del país, un resumen del jefe de estado, una expansión del grafo de entidades y la última foto satelital Sentinel-2. ShadowBroker no tiene cuentas, telemetría de producto ni analíticas; el panel se comunica con su backend autoalojado. Las consultas sensibles de reconocimiento y Shodan nunca llegan a APIs de terceros desde el navegador; se enrutan a través del backend con protecciones SSRF y autenticación del operador local. El canal de comandos de agente OpenClaw expone los mismos backends de reconocimiento más la búsqueda completa de telemetría — no se requiere integración API separada.
Diseñado para analistas, investigadores, operadores de radio y cualquier persona que quiera ver cómo se ve el mundo cuando todas las señales públicas están en el mismo mapa.
Una cantidad sorprendente de telemetría global ya es pública — transmisiones ADS-B de aeronaves, señales AIS marítimas, datos orbitales de satélites, sensores sísmicos, redes de radio mesh, feeds de escáneres policiales, estaciones de monitoreo ambiental, telemetría de infraestructura de internet y más. Estos datos están dispersos en docenas de herramientas y APIs. ShadowBroker combina todo en una sola interfaz.
El proyecto no introduce nuevas capacidades de vigilancia — agrega y visualiza conjuntos de datos públicos existentes. Es completamente de código abierto para que cualquiera pueda auditar exactamente qué datos se acceden y cómo. ShadowBroker no incluye telemetría de producto, analíticas ni cuentas. Las claves proporcionadas por el operador permanecen en su implementación local, pero las funciones OSINT en vivo necesariamente realizan solicitudes salientes a los proveedores de datos públicos que habilite o consulte.
ShadowBroker incluye un conector Shodan opcional para acceso API proporcionado por el operador (SHODAN_API_KEY) y un panel de Kit de Herramientas de Reconocimiento para búsquedas OSINT sin clave. Ambos se ejecutan solo en el lado del servidor: el navegador llama a sus rutas autoalojadas /api/osint/* y /api/tools/shodan/*; las solicitudes salientes son realizadas por el backend después de la validación SSRF. El reconocimiento requiere acceso de operador local (mismo modelo de confianza que las alternancias de capas y rutas de administración). Los resultados de Shodan se renderizan como una superposición de mapa separada y siguen sujetos a los términos de servicio de Shodan.
search_telemetry, search_news), el kit de herramientas de reconocimiento completo (osint_lookup para IP/DNS/WHOIS/sanciones/CVE/etc.), expansión de grafos de entidades, colocación de pines, control del mapa, cambio de suelo SAR, redes mesh y entrega de alertas. Ve todo lo que el operador ve y puede tomar acciones en el mapa en tiempo real.⚡ Inicio Rápido (Docker)
git clone https://github.com/bigbodycobain/Shadowbroker.git cd Shadowbroker docker compose pull docker compose up -d
### De 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
Ambos caminos producen contenedores idénticos: misma fuente, mismo CI, mismas imágenes byte por byte. Elige el ecosistema que ya uses.
Abre http://localhost:3000 para ver el panel de control! (Requiere Docker Desktop o Docker Engine)
Únete al enjambre privado InfoNet (sb-testnet-0): Haz clic en NODE en el panel, o ejecuta
./meshnode.shpara un participante sin interfaz. Sin lista manual de pares — la flota por defecto descubre la semilla y obtiene el manifiesto firmado automáticamente. EstableceMESH_INFONET_FLEET_JOIN=falseen.envpara un nodo privado solitario.
¿Puerto del backend ya en uso? El navegador solo necesita el puerto
3000, pero la API del backend también se publica en el puerto del host8000para diagnósticos locales. Si otra aplicación ya usa8000, crea o edita.envjunto adocker-compose.ymly estableceBACKEND_PORT=8001, luego ejecutadocker compose up -d.
¿Noticias/UAP/bases/aguas residuales en blanco después de varios minutos? Verifica reinicios OOM del backend con
docker events --since 30m --filter container=shadowbroker-backend --filter event=oom. El archivo compose predeterminado asigna al backend 4GB; si tu host tiene menos memoria, reduce los feeds habilitados o estableceBACKEND_MEMORY_LIMIT=3Gy espera que las capas más lentas/pesadas se calienten más gradualmente.
Usuarios de Podman: Podman funciona, pero
podman composees un envoltorio y aún necesita un proveedor de Compose instalado. En Windows/WSL, si veslooking up compose provider failed, instalapodman-composey ejecutapodman-compose pullseguido depodman-compose up -ddesde dentro de la carpeta clonadaShadowbroker. En shells de Linux/macOS/WSL también puedes usar./compose.sh --engine podman pully./compose.sh --engine podman up -d.
🔄 Cómo Actualizar
ShadowBroker usa imágenes Docker preconstruidas — no requiere compilación local. La actualización toma segundos:```bash docker compose pull docker compose up -d
Eso es todo. `pull` obtiene las últimas imágenes, `up -d` reinicia los contenedores.
> **¿Vienes de una versión anterior?** Primero obtén el código del repositorio más reciente y luego las imágenes:
>
> ```bash
> git pull origin main
> docker compose down
> docker compose pull
> docker compose up -d
> ```
>
> Los usuarios de Podman deben ejecutar el comando equivalente de su proveedor, por ejemplo `podman-compose pull` y `podman-compose up -d`, o usar `./compose.sh --engine podman pull` y `./compose.sh --engine podman up -d` desde un shell compatible con bash.
### Integridad de las Actualizaciones
Las actualizaciones de Docker se entregan a través de registros de contenedores firmados. El actualizador automático ZIP heredado verifica los archivos de lanzamiento a través de esta cadena, en orden:
* `MESH_UPDATE_SHA256` cuando un operador fija un resumen explícitamente.
* `backend/data/release_digests.json` para pines de lanzamiento incluidos.
* El activo `SHA256SUMS.txt` del lanzamiento en GitHub cuando no hay un pin incluido.
Los mantenedores de versiones deben ejecutar `python backend/scripts/release_helper.py hash <ShadowBroker_vX.Y.Z.zip>` antes de publicar, luego publicar `SHA256SUMS.txt` y actualizar `backend/data/release_digests.json` al enviar un objetivo de actualización ZIP. El actualizador mantiene intacta la ruta de anulación del operador en lugar de fallar de forma cerrada ante la ausencia de resúmenes incluidos, de modo que las instalaciones existentes no queden varadas por un error en el proceso de lanzamiento.
### Endurecimiento de CSP
El frontend de producción se distribuye con un CSP compatible con hidratación y un CSP estricto solo con nonce en `Content-Security-Policy-Report-Only`. Establezca `SHADOWBROKER_STRICT_CSP=1` solo después de verificar que la compilación exacta se hidrata correctamente en su implementación. Las fuentes de Google en tiempo de ejecución no son necesarias; el pipeline de fuentes Next incluido sirve la fuente del panel desde la compilación de la aplicación.
### ⚠️ **¿Atascado en la versión anterior?**
**Si `git pull` falla o `docker compose up` sigue compilando desde el código fuente en lugar de obtener imágenes**, su clonación es anterior a una migración del repositorio de marzo de 2026 que reescribió el historial de commits. Un `git pull` normal no puede solucionarlo. Ejecute:```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
Cómo saber si estás afectado: Si docker compose up muestra RUN apt-get, RUN npm ci, o RUN pip install — está compilando desde el código fuente en lugar de descargar imágenes precompiladas. Necesitas un clon nuevo.
Otras soluciones de problemas:
docker compose pull --no-cachedocker image prune -fdocker compose logs -f backendPara despliegues de alta disponibilidad o clústeres de laboratorio en casa, ShadowBroker soporta el despliegue mediante Helm. Este chart está basado en la plantilla bjw-s-labs y proporciona una configuración robusta y modular tanto para el backend como para el frontend.
1. Añadir el Repositorio:```bash helm repo add bjw-s-labs https://bjw-s-labs.github.io/helm-charts/ helm repo update
**2. Instalar el 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. Características Clave:
Agradecimientos especiales a @chr0n1x por contribuir con la arquitectura inicial de Kubernetes.
ShadowBroker v0.9.7 incluye InfoNet (malla de inteligencia descentralizada + economía de gobernanza Sovereign Shell), un canal de comandos de IA agéntica (compatible con OpenClaw y cualquier agente con firma HMAC), reproducción instantánea de Time Machine y detección de cambios terrestres por satélite SAR. Esta es una red de pruebas experimental — no es un mensajero privado ni un sistema de gobernanza en producción.
La primera capa de comunicación y gobernanza de inteligencia descentralizada construida directamente en una plataforma OSINT. Sin cuentas, sin registro, sin identidad requerida. v0.9.7 promueve InfoNet de una capa de chat a una economía de gobernanza completa con un camino claro hacia una plataforma de inteligencia descentralizada que preserva la privacidad.
Capa de comunicación (desde v0.9.6):
send, dm, comandos de mercado, inspección de estado de puerta. Panel arrastrable, se minimiza a la barra superior. Escriba help para ver todos los comandos.Sovereign Shell — economía de gobernanza (NUEVO en v0.9.7):
El repositorio incluye un docker-compose.yml que descarga imágenes preconstruidas desde GitHub Container Registry.```bash
git clone https://github.com/BigBodyCobain/Shadowbroker.git
cd Shadowbroker
docker compose pull docker compose up -d
Abre `http://localhost:3000` para ver el panel de control.
> **¿Desplegando públicamente o en una LAN?** No se necesita configuración para la mayoría de los casos.
> El frontend redirige todas las llamadas API a través del servidor Next.js a `BACKEND_URL`,
> que por defecto es `http://backend:8000` (red interna de Docker).
> El puerto `8000` del host está publicado solo para acceso local a la API/depuración (`127.0.0.1:8000`
> en `docker-compose.yml`). Si entra en conflicto con otro servicio, establece
> `BACKEND_PORT=8001` en `.env`; deja `BACKEND_URL` como `http://backend:8000`
> porque ese es el puerto interno de Docker.
>
> **Ejecutando el backend fuera de Docker** (`cd backend && python main.py`):
> el servidor de desarrollo se vincula **solo a loopback** (`127.0.0.1:8000`) por lo que otras máquinas en
> tu LAN no pueden acceder a rutas de administrador/confianza local con un `ADMIN_KEY` vacío. Establece
> `SHADOWBROKER_DEV_BIND_ALL=true` en `.env` solo cuando deliberadamente necesites
> `0.0.0.0` y uses un `ADMIN_KEY` fuerte para cualquier llamador no local.
> El límite de memoria del backend se controla mediante `BACKEND_MEMORY_LIMIT` y por defecto es
> `4G`. Si Docker reporta eventos OOM, el backend se reiniciará y las capas lentas
> pueden verse vacías hasta que se vuelvan a poblar.
>
> Si tu backend se ejecuta en un **host o puerto diferente**, establece `BACKEND_URL` en tiempo de ejecución — no se necesita reconstruir:
>
> ```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
> ```
**Usuarios de Podman:** No pases la URL de GitHub a `podman compose pull`; clona el repositorio primero, `cd Shadowbroker`, luego ejecuta compose desde esa carpeta. `podman compose` también requiere un proveedor de Compose. Si Podman informa `looking up compose provider failed`, instala uno:```bash
# Linux / macOS / WSL
python3 -m pip install --user podman-compose
podman-compose pull
podman-compose up -d
Si solo quieres ejecutar el panel sin usar comandos de terminal:
.zip de la versión.start.bat.
Mac/Linux: Abre la terminal, escribe chmod +x start.sh, dos2unix start.sh y ejecuta ./start.sh.Notas sobre el lanzador local:
start.bat / start.sh ejecutan la aplicación sin Docker: instalan dependencias e inician ambos servidores directamente.docs/mesh/ para solucionar problemas.docs/mesh/wormhole-dm-root-operations-runbook.md.Si deseas modificar el código o ejecutar desde el código fuente:
pip — python.org (marca "Agregar a PATH" durante la instalación)
aisstream.io (obligatorio) y opcionalmente 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
Las 41 capas se pueden activar/desactivar de forma independiente desde el panel izquierdo:
La plataforma está optimizada para manejar conjuntos de datos masivos en tiempo real:
304 Not Modified evitan el análisis redundante de JSONsetData()Los nuevos colaboradores pueden usar docs/contributor-map.md para una guía de orientación más 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 se construye en abierto. Estas personas enviaron código real:
Esta herramienta está construida enteramente con datos de inteligencia de código abierto (OSINT) disponibles públicamente. No se utilizan datos clasificados, restringidos o no públicos. Las posiciones de los portadores son estimaciones basadas en informes públicos. La interfaz de usuario con temática militar es puramente estética.
Este proyecto es para fines educativos y de investigación personal. Consulta los términos de servicio de cada proveedor de API para conocer las restricciones de uso de datos.
Construido con ☕ y demasiadas llamadas API
t.me/s de guerra/conflicto (OSINTdefender, NEXTA, etc.) raspados cada hora, puntuados por riesgo, georreferenciados a anclas de metro y trazados como pines de mapa cliqueables con medios en línea.| Canal | Estado de Privacidad | Detalles |
|---|
| Meshtastic / APRS | PÚBLICO | Las transmisiones de radio RF son públicas e interceptables por diseño. |
| InfoNet Gate Chat | OFUSCADO | Los mensajes se ofuscan con personas de puerta y firma canónica de carga útil, pero NO están cifrados de extremo a extremo. Los metadatos no están ocultos a pesar de estar diseñados a través de Tor y Reticulum (Trabajo en progreso). |
| Dead Drop DMs | CANAL MÁS FUERTE ACTUALMENTE | Buzón de correo de época basado en tokens con verificación de palabras SAS. El canal más fuerte en esta compilación, pero aún no confiadamente privado. |
| Gobernanza de Sovereign Shell | LIBRO MAYOR PÚBLICO | Peticiones, votos, hashes de actualización y apuestas de disputa son eventos firmados en una cadena de hash pública. Seudónimo a través de persona de puerta, pero las acciones de gobernanza son intencionalmente observables. |
| Primitivas de privacidad (RingCT / sigilo / DEX) | AÚN NO CONECTADAS | Los contratos de protocolo bloqueados están en su lugar, pero el esquema criptográfico no ha sido elegido. La crate Rust de núcleo de privacidad es el objetivo de integración para un sprint futuro. |
No transmita nada sensible en ningún canal. Trate todos los canales como abiertos y públicos por ahora. El cifrado de extremo a extremo y un endurecimiento nativo/Tauri más profundo son los próximos hitos. Si bifurca este proyecto, mantenga estas etiquetas intactas y no haga afirmaciones de privacidad más fuertes de las que soporta la implementación.
Para una imagen completa de lo que la malla realmente defiende y lo que no, lea el modelo de amenazas y la conciliación de afirmaciones. Cada oración anterior está mapeada allí a la ruta de código que la aplica (o no).
UPDATE_PARAM, BATCH_UPDATE_PARAMS, ENABLE_FEATURE y DISABLE_FEATURE. Los parámetros ajustables cambian por voto — no se requieren despliegues de código.repr() de Python, por lo que los hashes circulan limpiamente a través de la cadena.MappingProxyType.Pista de primitivas de privacidad (NUEVO en v0.9.7):
services/infonet/privacy/contracts.py para firmas de anillo, direcciones sigilosas, compromisos Pedersen, pruebas de rango y coincidencia DEX. La crate Rust privacy-core es el objetivo de integración — ningún llamante del módulo de privacidad necesita saber qué esquema está activo.Red de Pruebas Experimental — Sin Garantía de Privacidad: Los mensajes de InfoNet están ofuscados pero NO cifrados de extremo a extremo. La red Mesh (Meshtastic/APRS) NO es privada — las transmisiones de radio son inherentemente públicas. Los contratos de primitivas de privacidad están andamiados pero aún no conectados. No envíe nada sensible en ningún canal. Trate todos los canales como abiertos y públicos por ahora.
Adaptado de la pila de reconocimiento OSIRIS (MIT) con el modelo proxy de ShadowBroker. Atribución: backend/third_party/osiris/NOTICE.md.
Kit de Herramientas de Reconocimiento (barra lateral izquierda — solo operador local):
us_ofac_sdn de OpenSanctions (CC-BY); comprobaciones cruzadas en entidades WHOIS y cadenas ISP/org de IP/api/osint/sweep/scan geolocaliza un objetivo /24–/32 y proxy el descubrimiento de host Shodan InternetDB del lado del servidor (el navegador nunca contacta InternetDB directamente)Grafo de entidad — Seleccione cualquier entidad del mapa para abrir el panel de Grafo de Entidad (GET /api/entity/expand). Resuelve aeronaves, embarcaciones, empresas, personas, IPs y países en un grafo de nodo/enlace (Wikidata SPARQL + OFAC + almacén en memoria de vuelos/barcos).
OpenClaw / acceso de agente — Los mismos backends de reconocimiento están disponibles en el canal de comandos HMAC (sin puerta de operador local del navegador): osint_lookup (IP/DNS/WHOIS/certs/BGP/sanciones/CVE/MAC/GitHub/filtraciones/amenazas pasivas), entity_expand (grafo de relaciones) y osint_sweep (escaneo de subred activo — solo nivel de acceso completo). Llame a osint_tools para listar los tipos de búsqueda compatibles. Paquete de habilidades: openclaw-skills/shadowbroker/ (SKILL.md + sb_query.py).
Superposición Shodan (sin cambios):
sar_pin_click) y volar el mapa del operador a cualquier centro de AOI (sar_focus_aoi) — permitiendo flujos de trabajo de analista colaborativos.frontend/public/data/submarine-cables.json). Superposición de líneas opcional./api/cyber-threats y el alternador de capa./api/country-risk.t.me/s/*) de fuentes configurables de guerra/OSINT. Fusión incremental por hora (sin re-raspado redundante), puntuación de riesgo por palabras clave, alias de lugares en cirílico/árabe, geocodificación con anclaje de metro (separada de los centroides de noticias), foto/video en línea a través del proxy /api/telegram/media. Clave de capa: telegram_osint.Gaza
ShadowBroker expone un canal de comandos de IA agéntica bidireccional — un puente firmado y con niveles de acceso que otorga a cualquier agente de IA compatible acceso completo de lectura/escritura a la plataforma de inteligencia. OpenClaw es el agente de referencia, pero el canal es un protocolo abierto: cualquier agente impulsado por LLM que firme solicitudes con HMAC-SHA256 (Claude Code, GPT, LangChain, clientes personalizados de Python/TypeScript, o su propia integración) puede conectarse como un analista que ve los mismos datos que el operador y puede realizar acciones en el mapa. ShadowBroker no incluye un LLM, un entorno de ejecución de agente o pesos de modelo — proporciona la superficie; usted trae el agente.
v0.9.7 convierte a ShadowBroker de un panel que un humano observa en una superficie de inteligencia sobre la que cualquier agente puede actuar.
Transporte del canal (NUEVO en v0.9.7):
POST /api/ai/channel/command acepta {cmd, args} y lo envía a cualquier herramienta registrada.POST /api/ai/channel/batch acepta hasta 20 comandos en una sola solicitud. El backend los ejecuta concurrentemente y devuelve un mapa de resultados en abanico. Reduce la latencia del agente en un orden de magnitud en comparación con llamadas secuenciales.OPENCLAW_ACCESS_TIER controla qué comandos puede llamar el agente: restricted expone el conjunto de solo lectura, full añade escrituras e inyección. El endpoint de descubrimiento devuelve available_commands para que el agente pueda inspeccionar sus propias capacidades.HMAC-SHA256(secret, METHOD|path|timestamp|nonce|sha256(body)) con protección de repetición por timestamp + nonce e integridad de solicitud. Soporta modo local (sin configuración) y modo remoto (agente en una máquina diferente / VPS).Capacidades:
get_summary → get_layer_slice con since_layer_versions por capa (el push SSE layer_changed le dice al agente exactamente qué capas se actualizaron). search_telemetry es el índice de palabras clave entre capas al estilo Google. search_news cubre noticias, GDELT, CrowdThreat, LiveUAMap, frentes de batalla y publicaciones de Telegram. entities_near, brief_area, find_flights/find_ships/find_entity y correlate_entity responden preguntas específicas sin descargas de varios megabytes.osint_lookup ejecuta los mismos backends protegidos contra SSRF que el panel de Recon (ip, dns, whois, certs, bgp, sanctions, cve, mac, github, leaks, threats, sweep_init). entity_expand construye gráficos de relaciones de Wikidata + OFAC. osint_sweep ejecuta descubrimiento de subredes de Shodan InternetDB (nivel ). Alias de capa: , /, //, /, /.Conecta un agente: Abre el panel de AI Intel en la barra lateral izquierda, haz clic en Conectar Agente y copia el secreto HMAC. Desde allí, apunta cualquier agente compatible al canal — para OpenClaw, importa ShadowBrokerClient desde openclaw-skills/shadowbroker/sb_query.py (consulta SKILL.md para ejemplos); para cualquier otro agente, usa el mismo contrato HMAC documentado anteriormente (timestamp + nonce + digest del cuerpo, controlado por nivel). Descubrimiento: GET /api/ai/tools y GET /api/ai/capabilities. El canal es el protocolo, no el agente.
Docker Compose + agentes remotos: La interfaz del panel se comunica con el backend a través del puente privado de Docker (confianza automática). Un agente OpenClaw ejecutándose en el host (fuera del contenedor) accede a http://localhost:8000 desde la IP de la puerta de enlace de Docker — HMAC es requerido allí. En AI Intel → Conectar Agente, haz clic en Bootstrap luego Revelar, copia SHADOWBROKER_HMAC_SECRET en el entorno de tu agente, y reinicia el backend una vez para que data/openclaw.env en el volumen backend_data se cargue. Prueba rápida con:
curl -s -X POST 'http://localhost:8000/api/ai/channel/command' \
-H 'X-HMAC-Signature: ...' \
-H 'Content-Type: application/json' \
-d '{"cmd":"ping","args":{}}'
Deberías ver {"status":"ok","message":"pong"} como respuesta. Si obtienes 401 o 403, vuelve a verificar tu secreto HMAC y los registros del backend.```bash
export SHADOWBROKER_URL=http://127.0.0.1:8000
export SHADOWBROKER_HMAC_SECRET=
python openclaw-skills/shadowbroker/verify_hmac.py
Usa el puerto del backend (`:8000`), no el puerto del panel de Next.js (`:3000`). Los firmantes hechos a mano deben hashear los bytes exactos del POST: `json.dumps(payload, separators=(",", ":"), sort_keys=True)`.
### ⏱️ Máquina del Tiempo — Reproducción de Instantáneas (NUEVO en v0.9.7)
Un transporte al estilo multimedia para todo el flujo de telemetría. Trata el mapa en vivo como una grabación que se puede adelantar, pausar y reproducir.
* **Alternancia En Vivo ↔ Instantánea** — Cambiar al modo instantánea pausa el bucle de sondeo global al instante; volver a En Vivo invalida los ETags y fuerza la actualización de los niveles rápido y lento para que el panel se ponga al día sin parpadeo de fotogramas obsoletos.
* **Índice por Hora** — Cada instantánea capturada se indexa por su bloque horario con `count`, `latest_id`, `latest_ts` y la lista completa de `snapshot_ids`. Salta a cualquier marca de tiempo capturada directamente desde el control de línea de tiempo.
* **Interpolación de Fotogramas** — Las entidades en movimiento (aeronaves, barcos, satélites, vuelos militares) se interpolan suavemente entre los fotogramas grabados durante la reproducción para que el movimiento se mantenga continuo incluso cuando las instantáneas son escasas.
* **Velocidad de Reproducción Variable** — Avance paso a paso, reproducción, avance rápido y retroceso a través de la telemetría guardada a velocidad ajustable.
* **Consciente del Perfil** — Cada instantánea registra el perfil de privacidad que estaba activo cuando se capturó, por lo que la reproducción es fiel a lo que un operador con ese perfil habría visto.
* **Del Lado del Operador, No del Servidor** — Las instantáneas se almacenan localmente en el backend; ningún tercero ve nunca la línea de tiempo de reproducción.
### 📦 Panel de Claves API — Primero la Ruta, Solo Lectura (NUEVO en v0.9.7)
Configuración → Claves API ahora es un registro de solo lectura. Los valores de las claves nunca llegan al proceso del navegador — ni siquiera un prefijo ofuscado. El panel muestra:
* La ruta absoluta al archivo `.env` del backend según la resuelve `Path(__file__).resolve()` — funciona en todos los SO, todas las unidades, todas las ubicaciones de instalación (Linux `/home/...`, macOS `/Users/...`, Windows en cualquier unidad, contenedores Docker, VMs en la nube).
* Indicadores `[exists]` / `[will be created on first save]` / `[NOT WRITABLE — edit by hand]` en la ruta misma.
* La ruta a la plantilla `.env.example` para que los usuarios puedan copiarla y completar sus claves.
* Una insignia binaria `CONFIGURED` / `NOT CONFIGURED` por clave, más una línea de env copiable (ej. `OPENSKY_CLIENT_ID=YOUR_VALUE`) que el usuario puede insertar manualmente en el archivo.
Las credenciales de la API de OpenSky ahora son un requisito de entorno **critical-warn**: la verificación de entorno al inicio marca las credenciales OAuth2 de OpenSky faltantes con una advertencia fuerte, y el modal de registro de cambios enlaza directamente a la página de registro gratuito. Sin ellas, la capa de vuelos recurre a cobertura solo ADS-B con vacíos significativos en África, Asia y Latinoamérica.
</details>
---
<details>
<summary>🏗️ Arquitectura</summary>
ShadowBroker v0.9.7 se compone de tres planos apilados verticalmente — la **Interfaz de Usuario del Operador**, el **Plano de Servicio Backend** y la **Capa Descentralizada (InfoNet)** — más dos puentes transversales (la **Máquina del Tiempo** y el **Canal de IA Agéntica**, que es el protocolo a través del cual se conectan OpenClaw y cualquier otro agente compatible) y un **Núcleo de Privacidad** (crate Rust) que respalda tanto la malla heredada como el futuro trabajo de monedas protegidas / DEX.```
╔═════════════════════════════════════════════════════════════════════════════╗
║ OPERATOR UI (Next.js + MapLibre) ║
║ ║
║ ┌────────────────┐ ┌──────────┐ ┌────────────────┐ ┌────────────────┐ ║
║ │ MapLibre GL │ │ NewsFeed │ │ Sovereign Shell│ │ Mesh Chat │ ║
║ │ WebGL render │ │ SIGINT │ │ Petitions / │ │ + Mesh Term. │ ║
║ │ + clusters │ │ GDELT │ │ Upgrades / │ │ (Infonet / │ ║
║ │ │ │ Threat │ │ Disputes / │ │ Mesh / │ ║
║ │ │ │ │ │ Gates / │ │ Dead Drop) │ ║
║ │ │ │ │ │ Bootstrap / │ │ │ ║
║ │ │ │ │ │ Function Keys │ │ │ ║
║ └──────┬─────────┘ └────┬─────┘ └────────┬───────┘ └────────┬───────┘ ║
║ │ │ │ │ ║
║ ┌──────┴─────────────────┴─────────────────┴───────────────────┴───────┐ ║
║ │ Time Machine ◀── snapshot playback ── snapshotMode toggle ──▶ Live │ ║
║ │ hourly index │ frame interpolation │ profile-aware │ per-tier ETag │ ║
║ └──────────────────────────────────┬───────────────────────────────────┘ ║
║ │ REST + /api/[...path] proxy ║
╠═════════════════════════════════════╪═══════════════════════════════════════╣
║ BACKEND SERVICE PLANE (FastAPI) ║
║ │ ║
║ ┌──────────────────────────────────┴────────────────────────────────────┐ ║
║ │ Data Fetcher (APScheduler — fast / slow tiers) │ ║
║ │ │ ║
║ │ ┌───────────┬───────────┬───────────┬───────────┬───────────┐ │ ║
║ │ │ OpenSky* │ adsb.lol │ CelesTrak │ USGS │ AIS WS │ │ ║
║ │ │ Flights │ Military │ Sats │ Quakes │ Ships │ │ ║
║ │ ├───────────┼───────────┼───────────┼───────────┼───────────┤ │ ║
║ │ │ Carrier │ GDELT │ CCTV (12) │ DeepState │ NASA │ │ ║
║ │ │ Tracker │ Conflict │ Cameras │ Frontline │ FIRMS │ │ ║
║ │ ├───────────┼───────────┼───────────┼───────────┼───────────┤ │ ║
║ │ │ GPS │ KiwiSDR │ Shodan │ Amtrak │ SatNOGS │ │ ║
║ │ │ Jamming │ Radios │ Devices │ DigiTraf │ TinyGS │ │ ║
║ │ ├───────────┼───────────┼───────────┼───────────┼───────────┤ │ ║
║ │ │ Volcanoes │ Weather │ Fishing │ Mil Bases │ IODA │ │ ║
║ │ │ Air Qual │ Alerts │ Activity │ PwrPlants │ Outages │ │ ║
║ │ ├───────────┼───────────┼───────────┼───────────┼───────────┤ │ ║
║ │ │ Sentinel │ MODIS │ VIIRS │ Data │ Meshtastic│ │ ║
║ │ │ Hub/STAC │ Terra │ Nightlts │ Centers │ APRS │ │ ║
║ │ ├───────────┴───────────┴───────────┴───────────┴───────────┤ │ ║
║ │ │ SAR (NEW v0.9.7) │ │ ║
║ │ │ Mode A: ASF Search catalog (free, no account) │ │ ║
║ │ │ Mode B: NASA OPERA / Copernicus EGMS / GFM / EMS / │ │ ║
║ │ │ UNOSAT ground-change anomalies (opt-in) │ │ ║
║ │ └───────────────────────────────────────────────────────────┘ │ ║
║ │ * OpenSky: REQUIRED for global flight coverage │ ║
║ └───────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ┌──────────────────────────────────┴────────────────────────────────────┐ ║
║ │ Snapshot Store (Time Machine source) │ ║
║ │ Hourly index │ per-snapshot layer manifest │ profile metadata │ ║
║ └───────────────────────────────────────────────────────────────────────┘ ║
║ ║
║ ┌───────────────────────────────────────────────────────────────────────┐ ║
║ │ Agentic AI Channel (HMAC-SHA256, tier-gated — OpenClaw + others) │ ║
║ │ │ ║
║ │ POST /api/ai/channel/command → one tool call │ ║
║ │ POST /api/ai/channel/batch → up to 20 concurrent tool calls │ ║
║ │ │ ║
║ │ Tier: restricted (read-only) │ full (read + write + inject) │ ║
║ │ Auth: X-SB-Timestamp + X-SB-Nonce + X-SB-Signature │ ║
║ │ Sig = HMAC-SHA256(secret, METHOD|path|ts|nonce|sha256(body)) │ ║
║ └───────────────────────────────────────────────────────────────────────┘ ║
╠═════════════════════════════════════════════════════════════════════════════╣
║ DECENTRALIZED LAYER (InfoNet Testnet — signed events) ║
║ ║
║ ┌────────────────────────────┐ ┌──────────────────────────────────┐ ║
║ │ Mesh Hashchain │ │ Sovereign Shell Governance │ ║
║ │ │ │ │ ║
║ │ Ed25519 signed events │ │ Petitions (DSL: UPDATE_PARAM, │ ║
║ │ Public-key binding │ │ ENABLE_FEATURE …) │ ║
║ │ Replay / sequence guard │ │ Upgrade-Hash voting (80% / 40% │ ║
║ │ Two-tier finality │ │ quorum / 67% Heavy) │ ║
║ │ ├ Tier 1 (CRDT, fast) │ │ Resolution & Dispute markets │ ║
║ │ └ Tier 2 (epoch finality)│ │ Gate suspend / shutdown / appeal│ ║
║ │ Identity rotation │ │ Bootstrap eligible-node-1-vote │ ║
║ │ Constitutional invariants │ │ (Argon2id PoW, Heavy-Node only)│ ║
║ │ (MappingProxyType) │ │ Function Keys (5 of 6 pieces) │ ║
║ └─────────────┬──────────────┘ └─────────────┬────────────────────┘ ║
║ │ │ ║
║ └──────────────┬──────────────────┘ ║
║ │ ║
║ ┌────────────────────────────┴──────────────────────────────────────┐ ║
║ │ Wormhole / InfoNet Relay (transport layer) │ ║
║ │ Gate personas │ canonical signing │ Dead Drop epoch mailboxes │ ║
║ └───────────────────────────────────────────────────────────────────┘ ║
╠═════════════════════════════════════════════════════════════════════════════╣
║ PRIVACY CORE (Rust crate — locked Protocol contracts) ║
║ ║
║ privacy-core/ ─► Argon2id │ Ed25519/X25519 │ AESGCM │ HKDF ║
║ Ring sigs* │ Stealth addrs* │ Pedersen* │ Bulletproofs*║
║ Blind-sig issuance* (RSA / BBS+ / U-Prove / Idemix) ║
║ ║
║ * = locked Protocol contract; cryptographic primitive lands Sprint 11+ ║
╚═════════════════════════════════════════════════════════════════════════════╝
Distribution
────────────
GitHub (primary): ghcr.io/bigbodycobain/shadowbroker-{backend,frontend}
GitLab (mirror): registry.gitlab.com/bigbodycobain/shadowbroker/{backend,frontend}
Multi-arch: linux/amd64 + linux/arm64 (Raspberry Pi 5 supported)
Desktop: Tauri shell → packaged backend-runtime + Next.js frontend
| Fuente | Datos | Frecuencia de actualización | ¿Requiere clave API? |
|---|
| OpenSky Network | Vuelos comerciales y privados | ~60s | Sí |
| adsb.lol | Aeronaves militares | ~60s | No |
| aisstream.io | Posiciones de buques AIS | WebSocket en tiempo real | Sí |
| CelesTrak | Posiciones orbitales de satélites (TLE + SGP4) | ~60s | No |
| USGS Earthquake | Eventos sísmicos globales | ~60s | No |
| GDELT Project | Eventos de conflicto global | ~6h | No |
| DeepState Map | Línea del frente en Ucrania | ~30min | No |
| Shodan | Búsqueda de dispositivos conectados a Internet | Bajo demanda | Sí |
| OpenSanctions | Índice de sanciones OFAC SDN (reconocimiento + grafo de entidades) | Caché de 24h | No |
| abuse.ch Feodo + URLhaus | URLs de C2/distribución de malware | ~5min (capa opt-in) | No |
| CISA KEV | CVEs explotados conocidos | ~5min (capa opt-in) | No |
| ip-api.com | Geolocalización IP (reconocimiento, grafo de entidades) | Bajo demanda | No |
| Google Public DNS | Consultas DNS sobre HTTPS (reconocimiento) | Bajo demanda | No |
| RDAP.org | Datos de registro de dominios (reconocimiento) | Bajo demanda | No |
| crt.sh | Transparencia de certificados (reconocimiento) | Bajo demanda | No |
| bgpview.io | Enrutamiento BGP/ASN (reconocimiento) | Bajo demanda | No |
| TeleGeography (estático) | Rutas de cables submarinos | Estático | No |
| ASFINAG | Webcams de autopistas en Austria | ~10min | No |
| Amtrak | Posiciones de trenes en EE. UU. | ~60s | No |
| DigiTraffic | Posiciones de trenes europeos | ~60s | No |
| Global Fishing Watch | Eventos de actividad de buques pesqueros | ~1h | Sí (GFW_API_TOKEN) |
| Vistas previas públicas de Telegram | Publicaciones de canales de guerra/OSINT (telegram_osint) | ~1h | No (opcional TELEGRAM_OSINT_CHANNELS) |
| Transport for London, NYC DOT, TxDOT | Cámaras CCTV (Reino Unido, EE. UU.) | ~10min | No |
| Caltrans, WSDOT, GDOT, IDOT, MDOT | Cámaras CCTV (5 estados de EE. UU.) | ~10min | No |
| Spain DGT, Madrid City | Cámaras CCTV (España) | ~10min | No |
| Singapore LTA | Cámaras de tráfico en Singapur | ~10min | Sí |
| Windy Webcams | Webcams globales | ~10min | No |
| SatNOGS | Estaciones terrestres de satélites amateur | ~30min | No |
| TinyGS | Estaciones terrestres de satélites LoRa | ~30min | No |
| Meshtastic MQTT | Posiciones de nodos de radio mesh | En tiempo real | No |
| APRS-IS | Posiciones de radio amateur | TCP en tiempo real | No |
| KiwiSDR | Ubicaciones de receptores SDR públicos | ~30min | No |
| OpenMHZ | Transmisiones de escáner policial/bomberos | En tiempo real | No |
| Smithsonian GVP | Volcanes del Holoceno en todo el mundo | Estático (en caché) | No |
| OpenAQ | Estaciones de calidad del aire PM2.5 | ~120s | No |
| NOAA / NWS | Alertas meteorológicas severas y polígonos | ~120s | No |
| WRI Global Power Plant DB | Más de 35.000 centrales eléctricas | Estático (en caché) | No |
| Conjuntos de datos de bases militares | Instalaciones militares globales | Estático (en caché) | No |
| NASA FIRMS | Puntos calientes de incendios/térmicos NOAA-20 VIIRS | ~120s | No |
| NOAA SWPC | Índice Kp de clima espacial y eventos solares | ~120s | No |
| IODA (Georgia Tech) | Alertas regionales de cortes de Internet | ~120s | No |
| DC Map (GitHub) | Ubicaciones globales de centros de datos | Estático (caché de 7d) | No |
| NASA GIBS | Imágenes diarias de satélite MODIS Terra | Diario (retraso de 24-48h) | No |
| Esri World Imagery | Mapa base satelital de alta resolución | Estático (actualizado periódicamente) | No |
| MS Planetary Computer | Escenas Sentinel-2 L2A (clic derecho) | Bajo demanda | No |
| Copernicus CDSE | Imágenes de Sentinel Hub (API Process) | Bajo demanda | Sí (gratuito) |
| VIIRS Nightlights | Detección de cambios en luces nocturnas | Estático | No |
| RestCountries | Datos de perfil de países | Bajo demanda (caché 24h) | No |
| Wikidata SPARQL | Datos de jefes de estado | Bajo demanda (caché 24h) | No |
| API de Wikipedia | Resúmenes de ubicaciones e imágenes de aeronaves | Bajo demanda (en caché) | No |
| OSM Nominatim | Geocodificación de nombres de lugares (barra LOCALIZAR) | Bajo demanda | No |
| CARTO Basemaps | Azulejos de mapa oscuro | Continuo | No |
Privacidad y auditoría de salida (#348–#366): Cada instalación autoalojada utiliza su propia IP de backend y un identificador User-Agent por instalación. Consulte docs/OUTBOUND_DATA.md para conocer qué contacta a terceros, controles opt-in/env y las compensaciones aceptadas (Referer de CCTV, CDN de mapas base, LiveUAMap, etc.).
./certman eca -ca
Este comando genera el certificado y la clave privada de la CA raíz, almacenando ambos en la carpeta certs.
Luego, el script ofrece la opción de mantener la clave privada de la CA en la carpeta certs o moverla a una ubicación más segura.
Los usuarios pueden volver a ejecutar ./certman eca -ca en cualquier momento para regenerar la CA con nuevos valores.
./certman eca -ca -cn blog.internal -o server
La bandera -common-name (-cn) establece el Nombre Común (CN) para el certificado. Si no se especifica, su valor predeterminado es root.
En el ejemplo del certificado de servidor, el CN es blog.internal. La bandera -o define el nombre del archivo de salida del certificado, mientras que la bandera -type especifica su uso previsto como certificado server.
./certman rvk -ca -cn blog.internal
Este comando revoca el certificado asociado con el Nombre Común especificado (blog.internal).
Importante: Si la CA está comprometida, puedes revocar toda la CA, invalidando todos los certificados firmados por ella.
También puedes revocar certificados individuales manteniendo la CA intacta, lo que proporciona un control granular sobre la validez de los certificados.
./certman gen rsa
Esto genera una clave privada RSA y la almacena en la carpeta keys.
./certman gen ecdsa
Esto genera una clave privada ECDSA y la almacena en la carpeta keys.
./certman gen ssh
``````powershell
# Windows PowerShell
py -m pip install --user podman-compose
podman-compose pull
podman-compose up -d
Si estás en una shell compatible con bash, el wrapper incluido puede detectar automáticamente Docker o Podman:```bash ./compose.sh --engine podman pull ./compose.sh --engine podman up -d
</details>
---
<details>
<summary>🐋 Despliegue Independiente (Portainer, Uncloud, NAS, etc.)</summary>
No es necesario clonar el repositorio. Usa las imágenes preconstruidas de GitHub Container Registry. Las imágenes del registro de GitLab pueden usarse como espejo si las publicas allí.
Crea un archivo `docker-compose.yml` con el siguiente contenido y despliégalo directamente — pégalo en el stack editor de Portainer, `uncloud deploy`, o cualquier host de 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:
Cómo funciona: El contenedor frontend envía todas las solicitudes
/api/*a través del servidor Next.js aBACKEND_URLutilizando la red interna de Docker. El navegador solo se comunica con el puerto 3000. El puerto host del backend es para acceso local de API/depuración y se puede cambiar conBACKEND_PORT=8001sin modificarBACKEND_URL.
BACKEND_URLes una variable de entorno en tiempo de ejecución (no es una variable de compilaciónNEXT_PUBLIC_*), por lo que puedes cambiarla en Portainer, Uncloud o cualquier editor de compose sin reconstruir la imagen. Establécelo en la dirección donde tu backend sea accesible desde dentro de la red de Docker (ej.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 y 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
### Ejecutando```bash
# From the frontend directory — starts both frontend & backend concurrently
npm run dev
http://localhost:3000http://localhost:8000Si usas pre-commit, instala los hooks una vez desde la raíz del repositorio:```bash pre-commit install
### Receptor AIS Local (Opcional)
Puedes alimentar tus propios datos de barcos AIS a ShadowBroker usando un dongle RTL-SDR y [AIS-catcher](https://github.com/jvde-github/AIS-catcher), un decodificador AIS de código abierto. Esto te brinda cobertura en tiempo real de embarcaciones en tu área local, sin necesidad de clave API.
1. Conecta un dongle RTL-SDR
2. Instala AIS-catcher ([lanzamientos](https://github.com/jvde-github/AIS-catcher/releases)) o usa la imagen Docker:
docker run -d --restart unless-stopped --name ais-catcher --device /dev/bus/usb ghcr.io/jvde-github/ais-catcher:latest
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
3. O ejecutar de forma nativa: ```bash
AIS-catcher -H http://localhost:4000/api/ais/feed interval 10
AIS-catcher decodifica señales de radio VHF en 161.975 MHz y 162.025 MHz y envía mediante POST los datos decodificados de embarcaciones a ShadowBroker cada 10 segundos. Los barcos detectados por tu antena SDR aparecen junto al flujo global de AIS.
Docker (ARM/Raspberry Pi): Consulta docker-shipfeeder para una imagen Docker lista para producción optimizada para ARM.
Nota: El alcance del AIS depende de tu antena — típicamente 20-40 millas náuticas con una configuración básica, 60+ mn con una antena VHF marina en altura.
| Capa | Predeterminado | Descripción |
|---|
| Vuelos comerciales | ✅ ON | Aerolíneas, carga, aeronaves de aviación general |
| Vuelos privados | ✅ ON | Aeronaves privadas no comerciales |
| Jets privados | ✅ ON | Jets ejecutivos de alto valor con datos del propietario |
| Vuelos militares | ✅ ON | Aeronaves militares y gubernamentales |
| Aeronaves rastreadas | ✅ ON | Lista de vigilancia de interés especial |
| Interferencia GPS | ✅ ON | Zonas de degradación NAC-P |
| Portaaviones / Mil / Carga | ✅ ON | Portaaviones, buques de carga, petroleros |
| Embarcaciones civiles | ✅ ON | Yates, pesca, recreativos |
| Cruceros / Pasajeros | ✅ ON | Cruceros y ferris |
| Yates rastreados | ✅ ON | Superyates de multimillonarios y oligarcas |
| Actividad pesquera | ✅ ON | Eventos de embarcaciones de Global Fishing Watch |
| Trenes | ✅ ON | Amtrak + posiciones ferroviarias europeas |
| Satélites | ✅ ON | Activos orbitales por tipo de misión |
| SatNOGS | ✅ ON | Estaciones terrestres de satélites amateur |
| TinyGS | ✅ ON | Estaciones terrestres de satélites LoRa |
| Terremotos (24h) | ✅ ON | Eventos sísmicos del USGS |
| Puntos calientes de incendios (24h) | ✅ ON | Anomalías térmicas VIIRS de NASA FIRMS |
| Volcanes | ✅ ON | Volcanes del Holoceno del Smithsonian |
| Alertas meteorológicas | ✅ ON | Polígonos de clima severo |
| Calidad del aire (PM2.5) | ✅ ON | Estaciones OpenAQ en todo el mundo |
| Frente de Ucrania | ✅ ON | Posiciones en vivo del frente de guerra |
| Alertas aéreas de Ucrania | ✅ ON | Alertas regionales de ataques aéreos |
| Incidentes globales | ✅ ON | Eventos de conflicto GDELT |
| Malla CCTV | ✅ ON | Más de 11,000 cámaras en 13 fuentes, 6 países |
| Cortes de Internet | ✅ ON | Alertas regionales de conectividad IODA |
| Centros de datos | ✅ ON | Ubicaciones globales de centros de datos (más de 2,000) |
| Bases militares | ✅ ON | Instalaciones militares globales |
| Receptores KiwiSDR | ✅ ON | Receptores de radio SDR públicos |
| Nodos Meshtastic | ✅ ON | Posiciones de nodos de radio malla |
| APRS | ✅ ON | Posicionamiento de radioaficionados |
| Escáneres | ✅ ON | Transmisiones de escáneres policiales/bomberos |
| Ciclo día / noche | ✅ ON | Superposición del terminador solar |
| MODIS Terra (Diario) | ❌ OFF | Imágenes satelitales diarias de NASA GIBS |
| Satélite de alta resolución | ❌ OFF | Imágenes satelitales submétricas de Esri |
| Sentinel Hub | ❌ OFF | API de Proceso CDSE de Copernicus |
| Luces nocturnas VIIRS | ❌ OFF | Detección de cambios de luz nocturna |
| Plantas de energía | ❌ OFF | Más de 35,000 plantas de energía globales |
| Superposición Shodan | ❌ OFF | Resultados de búsqueda de dispositivos de Internet |
| Tendencias de carga por carretera | ❌ OFF | Tendencias de movimiento de camiones Sentinel-2 en autopistas principales (Analizar aquí) |
| Cables submarinos | ❌ OFF | Rutas globales de cables submarinos (GeoJSON estático) |
| C2 de malware | ❌ OFF | Puntos de amenaza de abuse.ch Feodo + URLhaus |
| Proveedores SCM | ❌ OFF | Marcadores de riesgo de cadena de suministro de nivel 1/2 + alertas de panel |
| Amenazas cibernéticas | ❌ OFF | Entradas recientes de CISA KEV (estadísticas en payload de nivel lento) |
| Telegram OSINT | ✅ ON | Canales públicos de Telegram de guerra/OSINT — raspado por hora, pines geolocalizados |
| SAR | ✅ ON | Catálogo de radar de apertura sintética + alertas de anomalía |
Herramientas de reconocimiento y entidades (no son capas del mapa — barra lateral izquierda / selección):
| Herramienta | Acceso desde el panel | Comando OpenClaw | Descripción |
|---|---|---|---|
| Kit de Reconocimiento | Operador local (/api/osint/*) | osint_lookup, osint_sweep† | IP, DNS, WHOIS, certificados, BGP, sanciones, CVE, MAC, GitHub, filtraciones, amenazas, barrido de subred |
| Grafo de Entidades | Operador local (/api/entity/expand) | entity_expand | Wikidata + OFAC + grafo de relaciones en almacén en vivo |
| Panel de Riesgo SCM | Operador local (/api/scm-suppliers) | get_layer_slice(["scm_suppliers"]) | Resumen de amenazas de proveedores + marcadores de mapa |
| Descubrimiento de Herramientas | — | osint_tools | Enumera tipos de búsqueda de reconocimiento y esquemas de expansión de entidades |
† osint_sweep (escaneo activo de InternetDB) requiere OPENCLAW_ACCESS_TIER=full.
</details>
---
<details>
<summary>🔑 Variables de Entorno</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=
Cuando MESH_ARTI_ENABLED=true o MESH_RNS_ENABLED=true, el inicio del backend ahora falla cerrado a menos que el artefacto privacy-core cargado reporte una versión analizable igual o superior a PRIVACY_CORE_MIN_VERSION y coincida con uno de los hashes en PRIVACY_CORE_ALLOWED_SHA256.
Genera el hash del artefacto que planeas distribuir:```powershell Get-FileHash .\privacy-core\target\release\privacy_core.dll -Algorithm SHA256
---```bash
sha256sum ./privacy-core/target/release/libprivacy_core.so
Luego confirma que las solicitudes autenticadas GET /api/wormhole/status o GET /api/settings/wormhole-status muestran los mismos valores: privacy_core.version, privacy_core.library_path y privacy_core.library_sha256.
| Variable | Dónde configurar | Propósito |
|---|---|---|
BACKEND_URL | environment en docker-compose.yml, o variable de entorno del shell | URL que el servidor Next.js usa para redirigir llamadas API al backend. Por defecto http://backend:8000. Variable en tiempo de ejecución — no requiere reconstrucción. |
BACKEND_PORT | .env en la raíz del repositorio o variable de entorno del shell antes de docker compose up | Puerto del host usado para exponer la API del backend para diagnósticos locales. Por defecto 8000; establece BACKEND_PORT=8001 si el puerto 8000 ya está en uso. No cambia BACKEND_URL interno de Docker. |
Cómo funciona: El frontend redirige todas las solicitudes /api/* a través del servidor Next.js hacia BACKEND_URL usando la red interna de Docker. Los navegadores solo se comunican con el puerto 3000; el puerto del host del backend es solo para diagnósticos locales. Para desarrollo local sin Docker, BACKEND_URL predetermina a http://localhost:8000.
| Quién | Qué | PR |
|---|
| @Alienmajik | Soporte para Raspberry Pi 5 — empaquetado ARM64, notas de despliegue headless, ajuste de tiempo de ejecución para hardware clase Pi | — |
| @wa1id | Corrección de ingesta CCTV — SQLite con hilos, base de datos persistente, hidratación al inicio, clicabilidad del clúster | #92 |
| @AlborzNazari | Fuentes DGT de España + CCTV de Madrid, exportación de inteligencia de amenazas STIX 2.1 | #91 |
| @adust09 | Capa de plantas de energía, cobertura de inteligencia de Asia Oriental (bases JSDF, enriquecimiento ICAO, noticias de Taiwán, clasificación militar) | #71, #72, #76, #77, #87 |
| @Xpirix | Mejoras de estilo e interacción de LocateBar | #78 |
| @imqdcr | División del interruptor de barcos (4 categorías) + IDs de entidad MMSI/indicativo estables | — |
| @csysp | Alertas de amenazas descartables + IDs de entidad estables para GDELT y Noticias | #48, #63 |
| @suranyami | Compilaciones Docker multiarquitectura en paralelo (11min → 3min) + corrección de BACKEND_URL en tiempo de ejecución | #35, #44 |
| @chr0n1x | Arquitectura de Helm chart para Kubernetes para despliegues de alta disponibilidad | — |
telegrammalwarebotnetcybercisakevscmsuppliersgfwfishing