AIMap

Plateforme de découverte à l'échelle d'Internet et de tests de sécurité pour l'infrastructure d'agents IA exposée.

AIMap découvre, identifie et teste la sécurité des endpoints IA exposés publiquement — serveurs MCP, instances Ollama, proxys vLLM/LiteLLM, chaînes LangServe, applications Gradio, nœuds ComfyUI, et plus encore. Pensez à Shodan, mais spécialement conçu pour la surface d'attaque des agents IA.

Développé par Bishop Fox.

Avertissement Cet outil est destiné uniquement aux tests d'intrusion autorisés et à la recherche en sécurité. Vous devez utiliser AIMap uniquement contre des systèmes que vous possédez ou pour lesquels vous disposez d'une autorisation écrite explicite de test. L'accès non autorisé à des systèmes informatiques est illégal. Bishop Fox décline toute responsabilité et n'est pas responsable de tout usage abusif ou dommage causé par cet outil. Utilisez-le de manière responsable.

Ce qu'il fait

1. Découvrir — Interroge Shodan avec plus de 32 requêtes de recherche soigneusement sélectionnées pour trouver des endpoints IA/ML exposés sur Internet
2. Identifier — Sonde chaque endpoint avec des modèles Nuclei et des vérifications HTTP en direct pour déterminer le protocole, le framework, le statut d'authentification, les outils, les modèles et les prompts système
3. Noter — Calcule un score de risque de 0 à 10 basé sur l'authentification, l'exposition des outils, la politique CORS, le TLS, la fuite de prompt système et les combinaisons dangereuses de capacités
4. Tester — Lance des suites d'attaques spécifiques au protocole (abus d'outils MCP, extraction de modèles Ollama, injection de prompt) avec des résultats diffusés en continu
5. Visualiser — Un globe 3D affichant chaque endpoint découvert, interrogeable avec un langage de requête de type Shodan

Architecture

┌─────────────┐     ┌──────────────┐     ┌───────────┐
│  React SPA  │────▶│  FastAPI      │────▶│  MongoDB  │
│  (Vite)     │ WS  │  Backend      │     │           │
└─────────────┘     └──────┬───────┘     └───────────┘
                           │
              ┌────────────┼────────────┐
              ▼            ▼            ▼
        ┌──────────┐ ┌──────────┐ ┌──────────┐
        │  Shodan  │ │  Nuclei  │ │  Redis   │
        │  API     │ │  Scanner │ │  Streams │
        └──────────┘ └──────────┘ └──────────┘

Backend — Python/FastAPI avec MongoDB asynchrone (Motor), Redis Streams pour la diffusion des journaux d'attaque, et un moteur de découverte qui orchestre le pipeline : requêtes Shodan → vérifications de disponibilité httpx → scans de modèles Nuclei → enrichissement.

Frontend — React 18 + TypeScript + Tailwind CSS + shadcn/ui. Comprend un globe 3D (globe.gl), la diffusion des attaques en temps réel via WebSocket, et une interface de recherche de type Shodan.

Scanning — 5 modèles Nuclei YAML personnalisés pour la détection de serveurs MCP, l'énumération d'outils MCP, la détection d'API compatibles OpenAI, la détection de LangServe et les tests de fuite de prompt.

Protocoles pris en charge

Score de risque

Chaque endpoint reçoit un score de risque de 0 à 10 calculé à partir de :

Mise en place

Prérequis

• Python 3.12+
• Node.js 18+
• MongoDB 7+
• Redis 7+ (optionnel — bascule sur des tampons en mémoire pour le développement local)
• Nuclei (optionnel — nécessaire pour les scans actifs)
• Une clé API Shodan (requise pour les scans de découverte)

Démarrage rapide (Docker Compose)

# 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

Cela démarre 4 services :

• MongoDB sur le port 27017
• Redis sur le port 6379
• Backend sur le port 8000
• Frontend sur le port 80

Ouvrez http://localhost pour accéder à l'interface.

Développement local (sans Docker)

# 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

Assurez-vous que MongoDB s'exécute localement sur le port 27017. Redis est optionnel — le backend bascule sur des tampons en mémoire lorsque Redis est indisponible.

Variables d'environnement

Créez un fichier .env à la racine du projet :

# 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=

Authentification (Clerk)

AIMap utilise Clerk pour l'authentification. Pour l'activer :

1. Créez une application Clerk sur clerk.com
2. Définissez l'URL de l'émetteur du backend :
   root@kitploit:~

   # .env (project root)
   CLERK_ISSUER=https://your-app.clerk.accounts.dev
   

3. Définissez la clé publiable du frontend :
   root@kitploit:~

   # frontend/.env.local
   VITE_CLERK_PUBLISHABLE_KEY=pk_test_...
   

Pour désactiver l'authentification (développement local, démos) : laissez CLERK_ISSUER vide ou non défini. Le backend acceptera toutes les requêtes avec une identité utilisateur local synthétique.

Utilisation

Lancer un scan de découverte

1. Accédez à Scans dans la barre latérale
2. Cliquez sur Nouveau scan
3. Sélectionnez des requêtes prédéfinies (p. ex. ollama, mcp_protocol, vllm) ou saisissez une requête Shodan personnalisée
4. Limitez éventuellement le périmètre à une plage CIDR (l'orchestrateur préfixe chaque requête avec net:<cidr>)
5. Cliquez sur Exécuter — le pipeline de scan s'exécute :
   • Recherche Shodan — récupère les hôtes correspondants
   • Balayage httpx — vérifie que les hôtes sont actifs
   • Scan Nuclei — exécute les modèles personnalisés sur les hôtes actifs
   • Enrichissement — détection du framework, test d'authentification, score de risque
6. Surveillez la progression via la barre d'état WebSocket en temps réel ou en interrogeant la page de détail du scan

Rechercher des endpoints

Utilisez la barre de recherche avec la syntaxe de requête de type Shodan :

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

Combinez librement les filtres :

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

Tout texte qui ne correspond pas à un motif key:value est traité comme une recherche en texte libre dans tous les champs indexés.

Lancer des tests d'attaque

1. Accédez à la page de détail d'un endpoint
2. Cliquez sur Attaque pour ouvrir le panneau de test
3. Sélectionnez un profil d'attaque — le système sélectionne automatiquement le moteur en fonction du protocole :
   • MCP → Énumération des outils, invocation non autorisée d'outils, injection de prompt via les descriptions d'outils
   • Ollama → Liste des modèles, extraction des poids du modèle, injection de prompt
   • OpenAI-compatible → Énumération des modèles, abus de complétion, extraction du prompt système
4. Regardez les résultats défiler en temps réel via WebSocket
5. Les résultats incluent les niveaux de sévérité, les paires requête/réponse brutes et des recommandations de remédiation

Explorer le globe

La page d'accueil présente un globe 3D interactif affichant tous les endpoints découverts :

• Couleur de l'épingle = type de protocole (bleu = MCP, vert = Ollama, violet = OpenAI-compat, etc.)
• Hauteur de l'épingle = score de risque
• Survolez pour afficher le résumé de l'endpoint (IP, port, protocole, risque, authentification, outils, modèle, emplacement)
• Cliquez pour accéder à la page de détail de l'endpoint
• Faites glisser la souris pour pivoter, utilisez la molette pour zoomer

Modèles Nuclei

Modèles personnalisés dans le répertoire templates/ :

Référence de l'API

Tous les endpoints sont préfixés par /api/.

Structure du projet

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

Limites de concurrence

La plateforme applique des limites de concurrence globales pour prévenir les abus :

• 3 scans simultanés maximum — les scans supplémentaires reçoivent une erreur HTTP 429
• 5 attaques simultanées maximum — les attaques supplémentaires reçoivent une erreur HTTP 429
• Limitation de débit — 10 requêtes/minute sur les endpoints de création de scan et d'attaque

Avec Docker Compose, ces limites sont appliquées via des compteurs Redis (inter-conteneurs). En mode développement local, elles basculent sur asyncio.Semaphore (mono-processus).

Optionnel : Modal Serverless

Pour les charges de scan importantes, les scans et les attaques peuvent être envoyés vers des conteneurs Modal :

MODAL_ENABLED=true

Lorsque cette option est activée, POST /scans/{id}/run et POST /attack appelleront modal.Function.from_name("aimap", "run_scan_task") / run_attack_task au lieu de s'exécuter localement. Un retour à l'exécution locale est effectué si l'envoi vers Modal échoue.

Licence

Licence MIT. Voir LICENSE pour plus de détails.

Ce projet est maintenu par Bishop Fox.