bishopfox/aimapExponierte KI-Dienste entdecken
# AIMap
**Erkennungs- und Sicherheitstest-Plattform im Internet-Maßstab für exponierte KI-Agenten-Infrastruktur.**
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/7484/57dac8dcd2d53ead26c2d6a0f8a2c1b2d51e53ad4ded4ae46a0f9bf30d5bbdd5.gif" alt="AIMap UI Tour" width="800" />
</p>
AIMap findet, identifiziert und testet öffentlich exponierte KI-Endpunkte auf Sicherheit – MCP-Server, Ollama-Instanzen, vLLM/LiteLLM-Proxys, LangServe-Ketten, Gradio-Apps, ComfyUI-Knoten und mehr. Stellen Sie sich Shodan vor, aber gezielt für die Angriffsfläche von KI-Agenten entwickelt.
Entwickelt von [Bishop Fox](https://bishopfox.com).
> **Warnung**
> Dieses Tool ist ausschließlich für **autorisierte Penetrationstests und Sicherheitsforschung** bestimmt. Verwenden Sie AIMap nur gegen Systeme, die Ihnen gehören oder für die Sie eine ausdrückliche schriftliche Genehmigung zum Testen haben. Unbefugter Zugriff auf Computersysteme ist illegal. Bishop Fox übernimmt keine Haftung und ist nicht verantwortlich für Missbrauch oder Schäden, die durch dieses Tool verursacht werden. Nutzen Sie es verantwortungsbewusst.
---
## Was es tut
1. **Entdecken** – Fragt Shodan mit über 32 kuratierten Suchabfragen ab, um exponierte KI-/ML-Endpunkte im Internet zu finden
2. **Identifizieren** – Untersucht jeden Endpunkt mit Nuclei-Templates und Live-HTTP-Prüfungen, um Protokoll, Framework, Authentifizierungsstatus, Tools, Modelle und Systemprompts zu ermitteln
3. **Bewerten** – Berechnet einen Risikowert von 0–10 basierend auf Authentifizierung, Tool-Exposition, CORS-Richtlinie, TLS, Systemprompt-Leakage und gefährlichen Kombinationen von Fähigkeiten
4. **Testen** – Startet protokollspezifische Angriffssuiten (MCP-Tool-Missbrauch, Ollama-Modellextraktion, Prompt-Injection) mit Echtzeit-Streaming der Ergebnisse
5. **Visualisieren** – 3D-Globus, der jeden entdeckten Endpunkt anzeigt, durchsuchbar mit einer Shodan-artigen Abfragesprache
---
## Architektur
```
┌─────────────┐ ┌──────────────┐ ┌───────────┐
│ React SPA │────▶│ FastAPI │────▶│ MongoDB │
│ (Vite) │ WS │ Backend │ │ │
└─────────────┘ └──────┬───────┘ └───────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
┌──────────┐ ┌──────────┐ ┌──────────┐
│ Shodan │ │ Nuclei │ │ Redis │
│ API │ │ Scanner │ │ Streams │
└──────────┘ └──────────┘ └──────────┘
```
**Backend** – Python/FastAPI mit asynchronem MongoDB (Motor), Redis Streams zum Streaming von Angriffsprotokollen und einer Discovery-Engine, die Shodan-Abfragen → httpx-Erreichbarkeitsprüfungen → Nuclei-Template-Scans → Anreicherungspipeline orchestriert.
**Frontend** – React 18 + TypeScript + Tailwind CSS + shadcn/ui. Bietet einen 3D-Globus (globe.gl), Echtzeit-Angriffs-Streaming über WebSocket und eine Shodan-artige Suchoberfläche.
**Scannen** – 5 benutzerdefinierte Nuclei-YAML-Templates für die Erkennung von MCP-Servern, die Aufzählung von MCP-Tools, die Erkennung OpenAI-kompatibler APIs, die LangServe-Erkennung und Prompt-Leak-Tests.
---
## Unterstützte Protokolle
| Protokoll | Erkennungsmethode | Shodan-Abfragen |
|----------|-----------------|----------------|
| **MCP** (Model Context Protocol) | SSE-Transport, JSON-RPC, `/mcp/sse`-Pfade | 4 Abfragen |
| **Ollama** | Standardport 11434, Produkt-Fingerprint | 3 Abfragen |
| **vLLM / LiteLLM / LocalAI** | `/v1/models`-, `/v1/chat/completions`-Endpunkte | 4 Abfragen |
| **LangServe / LangChain** | Playground-Endpunkte, LangServe-Marker | 2 Abfragen |
| **OpenClaw / Clawdbot** | Kontroll-Dashboard, Port 18789 | 3 Abfragen |
| **Open WebUI / LibreChat** | Erkennung anhand des Titels | 2 Abfragen |
| **Gradio** | Titel, Fußzeilen-Wasserzeichen, Favicon-Hash | 3 Abfragen |
| **Streamlit** | Titel, Favicon-Hash | 2 Abfragen |
| **ComfyUI / Stable Diffusion** | Titel, Port-basierte Erkennung | 4 Abfragen |
| **HuggingFace TGI** | HTML-Marker | 1 Abfrage |
| **Allgemeine Inferenz** | `/api/generate`-, `/api/tags`-Pfade | 2 Abfragen |
---
## Risikobewertung
Jeder Endpunkt erhält einen Risikowert von 0–10, der sich aus folgenden Faktoren zusammensetzt:
| Faktor | Auswirkung auf den Wert |
|--------|-------------|
| Keine Authentifizierung | +4.0 |
| Unbekannter Authentifizierungsstatus | +1.0 |
| 10+ exponierte Tools | +2.0 |
| 5+ exponierte Tools | +1.0 |
| Tool mit kritischem Risiko (z. B. `exec_code`, `run_shell`) | jeweils +1.0 |
| Tool mit hohem Risiko (z. B. `query_db`, `file_read`) | jeweils +0.5 |
| Offenes CORS (`*`) | +1.0 |
| Kein TLS | +0.5 |
| Systemprompt geleakt | +0.5 |
| Modelle exponiert | +1.0 |
| Unzensiertes Modell erkannt | +2.0 |
| Registrierung aktiviert (keine Einladung erforderlich) | +1.5 |
| Gefährliche Kombination (z. B. keine Authentifizierung + Code-Ausführungs-Tool) | jeweils +1.0 |
---
## Einrichtung
### Voraussetzungen
- Python 3.12+
- Node.js 18+
- MongoDB 7+
- Redis 7+ (optional – weicht für die lokale Entwicklung auf In-Memory-Speicher aus)
- [Nuclei](https://github.com/projectdiscovery/nuclei) (optional – für aktive Scans erforderlich)
- Ein [Shodan-API-Schlüssel](https://account.shodan.io/) (für Discovery-Scans erforderlich)
### Schnellstart (Docker Compose)
```bash
# Clone
git clone [email protected]:BishopFox/aimap.git
cd aimap
# Configure
cp .env.example .env
# Edit .env — at minimum set SHODAN_API_KEY
# Launch
docker compose up --build
```
Dadurch werden 4 Dienste gestartet:
- **MongoDB** auf Port 27017
- **Redis** auf Port 6379
- **Backend** auf Port 8000
- **Frontend** auf Port 80
Öffnen Sie `http://localhost`, um auf die Benutzeroberfläche zuzugreifen.
### Lokale Entwicklung (ohne Docker)
```bash
# Backend
cd backend
python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
uvicorn app.main:app --reload --port 8000
# Frontend (separate terminal)
cd frontend
npm install
npm run dev # starts on http://localhost:5173
```
Stellen Sie sicher, dass MongoDB lokal auf Port 27017 läuft. Redis ist optional – das Backend weicht auf In-Memory-Puffer aus, wenn Redis nicht verfügbar ist.
### Umgebungsvariablen
Erstellen Sie eine `.env`-Datei im Projektstamm:
```bash
# Required
SHODAN_API_KEY=your_shodan_api_key
# Optional — Censys as an additional discovery source
CENSYS_API_ID=
CENSYS_API_SECRET=
# Optional — enables AI-powered attack analysis
ANTHROPIC_API_KEY=
# MongoDB (defaults work for local dev)
MONGODB_URI=mongodb://localhost:27017
MONGODB_DB=aimap
# Redis (defaults work for local dev; optional)
REDIS_URL=redis://localhost:6379/0
# CORS (default allows all origins)
CORS_ORIGINS=*
# Modal serverless (dispatches scans/attacks to Modal containers)
MODAL_ENABLED=false
# Clerk auth — see below
CLERK_ISSUER=
```
### Authentifizierung (Clerk)
AIMap verwendet [Clerk](https://clerk.com) für die Authentifizierung. So aktivieren Sie sie:
1. Erstellen Sie eine Clerk-Anwendung auf [clerk.com](https://clerk.com)
2. Legen Sie die Backend-Issuer-URL fest:
```bash
# .env (project root)
CLERK_ISSUER=https://your-app.clerk.accounts.dev
```
3. Legen Sie den veröffentlichbaren Frontend-Schlüssel fest:
```bash
# frontend/.env.local
VITE_CLERK_PUBLISHABLE_KEY=pk_test_...
```
**So deaktivieren Sie die Authentifizierung** (lokale Entwicklung, Demos): Lassen Sie `CLERK_ISSUER` leer oder nicht gesetzt. Das Backend akzeptiert dann alle Anfragen mit einer synthetischen Benutzeridentität `local`.
---
## Verwendung
### Ausführen eines Discovery-Scans
1. Navigieren Sie in der Seitenleiste zu **Scans**
2. Klicken Sie auf **Neuer Scan**
3. Wählen Sie Abfrage-Presets (z. B. `ollama`, `mcp_protocol`, `vllm`) oder geben Sie eine benutzerdefinierte Shodan-Abfrage ein
4. Begrenzen Sie optional auf einen CIDR-Bereich (der Orchestrator stellt jeder Abfrage `net:<cidr>` voran)
5. Klicken Sie auf **Ausführen** – die Scan-Pipeline führt Folgendes aus:
- **Shodan-Suche** – ruft passende Hosts ab
- **httpx-Sweep** – prüft, ob Hosts erreichbar sind
- **Nuclei-Scan** – führt benutzerdefinierte Templates gegen Live-Hosts aus
- **Anreicherung** – Framework-Erkennung, Auth-Probing, Risikobewertung
6. Überwachen Sie den Fortschritt über die Echtzeit-WebSocket-Statusleiste oder durch Abfragen der Scan-Detailseite
### Endpunkte durchsuchen
Verwenden Sie die Suchleiste mit der Shodan-artigen Abfragesyntax:
```
protocol:mcp # MCP servers
auth:none # No authentication
risk:critical # Risk score >= 9.0
risk:high # Risk score 7.0 – 8.9
risk:medium # Risk score 4.0 – 6.9
risk:low # Risk score 1.0 – 3.9
tool:query_db # Endpoints exposing a specific tool
country:US # By country code
port:11434 # By port number
org:"Amazon AWS" # By hosting organization (quote multi-word values)
has:system_prompt # Endpoints with leaked system prompts
```
Kombinieren Sie Filter frei:
```
protocol:mcp auth:none country:US # Unauthenticated MCP servers in the US
risk:critical tool:exec_code # Critical endpoints with code execution tools
protocol:ollama port:11434 # Ollama on default port
```
Jeder Text, der keinem `key:value`-Muster entspricht, wird als Freitextsuche über alle indexierten Felder behandelt.
### Angriffstests starten
1. Navigieren Sie zur Detailseite eines Endpunkts
2. Klicken Sie auf **Angriff**, um das Testpanel zu öffnen
3. Wählen Sie ein Angriffsprofil – das System wählt das passende Modul basierend auf dem Protokoll automatisch aus:
- **MCP** → Tool-Aufzählung, unbefugte Tool-Aufrufe, Prompt-Injection über Tool-Beschreibungen
- **Ollama** → Modellauflistung, Extraktion von Modellgewichten, Prompt-Injection
- **OpenAI-kompatibel** → Modell-Aufzählung, Missbrauch von Completions, Extraktion von Systemprompts
4. Beobachten Sie die Ergebnisse in Echtzeit per WebSocket-Stream
5. Die Ergebnisse enthalten Schweregrade, rohe Anforderungs-/Antwortpaare und Empfehlungen zur Behebung
### Den Globus erkunden
Die Startseite enthält einen interaktiven 3D-Globus mit allen entdeckten Endpunkten:
- **Pin-Farbe** = Protokolltyp (blau = MCP, grün = Ollama, lila = OpenAI-kompatibel usw.)
- **Pin-Höhe** = Risikowert
- **Hover** für eine Endpunkt-Zusammenfassung (IP, Port, Protokoll, Risiko, Auth, Tools, Modell, Standort)
- **Klick** zum Navigieren zur Endpunkt-Detailseite
- Mit der Maus ziehen zum Drehen, scrollen zum Zoomen
---
## Nuclei-Templates
Benutzerdefinierte Templates im Verzeichnis `templates/`:
| Template | Zweck |
|----------|---------|
| `mcp-server-detect.yaml` | Erkennt MCP-Server über SSE-Transport und JSON-RPC-Fähigkeitenantwort |
| `mcp-tool-enum.yaml` | Zählt Tools auf, die von MCP-Servern exponiert werden (Namen, Beschreibungen, Eingabeschemata) |
| `openai-compat-detect.yaml` | Erkennt OpenAI-kompatible Endpunkte über `/v1/models` |
| `langserve-detect.yaml` | Erkennt LangServe-Bereitstellungen mit exponiertem Playground |
| `prompt-leak.yaml` | Versucht die Extraktion von Systemprompts über gängige Injection-Techniken |
---
## API-Referenz
Alle Endpunkte haben das Präfix `/api/`.
| Methode | Pfad | Beschreibung |
|--------|------|-------------|
| `GET` | `/health` | Gesundheitsprüfung |
| `GET` | `/endpoints` | Endpunkte auflisten (paginiert, filterbar) |
| `POST` | `/endpoints/search` | Erweiterte Suche mit Abfragesyntax |
| `GET` | `/endpoints/globe` | Geodaten für den 3D-Globus |
| `GET` | `/endpoints/stats` | Aggregierte Statistiken |
| `GET` | `/endpoints/{id}` | Endpunkt-Details |
| `POST` | `/endpoints/{id}/enrich` | Anreicherung für einen Endpunkt auslösen |
| `POST` | `/endpoints/enrich-all` | Stapelverarbeitung der Anreicherung |
| `GET` | `/scans` | Scans auflisten |
| `POST` | `/scans` | Scan erstellen |
| `POST` | `/scans/{id}/run` | Scan ausführen |
| `GET` | `/scans/query-presets` | Verfügbare Shodan-Abfrage-Presets |
| `WS` | `/scans/{id}/progress` | Live-Scan-Fortschritt |
| `POST` | `/attack` | Angriffstest starten |
| `WS` | `/attack/{id}/stream` | Live-Stream der Angriffsprotokolle |
| `GET` | `/attack/{id}/status` | Angriffsstatus |
---
## Projektstruktur
```
aimap/
├── backend/
│ ├── app/
│ │ ├── main.py # FastAPI app, lifespan, CORS, routers
│ │ ├── config.py # Pydantic settings from env
│ │ ├── auth.py # Clerk JWT verification (bypass when CLERK_ISSUER empty)
│ │ ├── database.py # Async MongoDB (Motor) connection
│ │ ├── limiter.py # SlowAPI rate limiting
│ │ ├── routes/
│ │ │ ├── endpoints.py # CRUD + search + globe + enrichment
│ │ │ ├── scans.py # Scan lifecycle + execution + WebSocket
│ │ │ └── attack.py # Attack dispatch + Redis Streams + WebSocket
│ │ ├── discovery/
│ │ │ ├── orchestrator.py # Scan pipeline: Shodan → httpx → Nuclei → ingest
│ │ │ ├── shodan_adapter.py # 32 curated Shodan queries + result normalization
│ │ │ ├── nuclei_runner.py # Nuclei subprocess runner + finding parser
│ │ │ └── base.py # SourceAdapter abstract base
│ │ └── services/
│ │ ├── attack_mcp.py # MCP protocol attack engine
│ │ ├── attack_ollama.py # Ollama attack engine
│ │ ├── attack_openclaw.py # OpenClaw/Clawdbot attack engine
│ │ ├── enrichment.py # Shodan/Nuclei enrichment + risk scoring
│ │ ├── live_probe.py # HTTP probing for model/tool enumeration
│ │ ├── search.py # Shodan-style query parser → MongoDB filters
│ │ ├── redis_client.py # Async Redis singleton with fallback
│ │ └── concurrency.py # Semaphore + Redis-based slot limiting
│ ├── Dockerfile
│ └── requirements.txt
├── frontend/
│ ├── src/
│ │ ├── App.tsx # Routes + Clerk auth wrapper
│ │ ├── pages/
│ │ │ ├── Marketing.tsx # Public landing page with 3D globe
│ │ │ ├── Landing.tsx # Authenticated dashboard with globe
│ │ │ ├── Search.tsx # Endpoint search with query syntax
│ │ │ ├── Explore.tsx # Browse/filter all endpoints
│ │ │ ├── AgentDetail.tsx # Single endpoint deep-dive
│ │ │ ├── TestAgent.tsx # Attack test launcher
│ │ │ ├── Scans.tsx # Scan management
│ │ │ └── Ranges.tsx # CIDR range management
│ │ ├── components/
│ │ │ ├── GlobeVisualization.tsx # globe.gl 3D globe + legend
│ │ │ ├── Layout.tsx # App shell (sidebar + navbar)
│ │ │ └── ui/ # shadcn/ui components
│ │ ├── hooks/useApi.ts # SWR hooks for all API endpoints
│ │ └── lib/api-client.ts # Fetch wrapper with Clerk token injection
│ ├── Dockerfile
│ ├── nginx.conf
│ └── tailwind.config.js
├── templates/ # Nuclei YAML templates
├── docs/ # GitHub Pages static site
├── docker-compose.yml
├── .env.example
└── README.md
```
---
## Nebenläufigkeitsgrenzen
Die Plattform erzwingt globale Nebenläufigkeitsgrenzen, um Missbrauch zu verhindern:
- **Max. 3 gleichzeitige Scans** – weitere Scans erhalten HTTP 429
- **Max. 5 gleichzeitige Angriffe** – weitere Angriffe erhalten HTTP 429
- **Ratenbegrenzung** – 10 Anfragen/Minute auf den Endpunkten zum Erstellen von Scans und Angriffen
Bei Verwendung von Docker Compose werden diese Grenzen über Redis-Zähler (containerübergreifend) durchgesetzt. Im lokalen Entwicklungsmodus fallen sie auf `asyncio.Semaphore` (Einzelprozess) zurück.
---
## Optional: Modal Serverless
Für umfangreiche Scan-Workloads können Scans und Angriffe an [Modal](https://modal.com)-Container übergeben werden:
```bash
MODAL_ENABLED=true
```
Wenn aktiviert, rufen `POST /scans/{id}/run` und `POST /attack` `modal.Function.from_name("aimap", "run_scan_task")` / `run_attack_task` auf, anstatt lokal zu laufen. Fällt auf lokale Ausführung zurück, wenn die Modal-Übergabe fehlschlägt.
---
## Lizenz
MIT-Lizenz. Einzelheiten finden Sie in der [LICENSE](https://github.com/bishopfox/aimap/blob/main/LICENSE).
Dieses Projekt wird von [Bishop Fox](https://bishopfox.com) gepflegt.