AIMap

Piattaforma di discovery e test di sicurezza su scala Internet per infrastrutture AI esposte.

AIMap trova, identifica tramite impronte digitali e sottopone a test di sicurezza gli endpoint AI pubblicamente esposti — server MCP, istanze Ollama, proxy vLLM/LiteLLM, catene LangServe, app Gradio, nodi ComfyUI e altro. Pensalo come Shodan, ma costruito appositamente per la superficie d'attacco degli agenti AI.

Creato da Bishop Fox.

Avviso Questo strumento è destinato esclusivamente a test di penetrazione autorizzati e ricerca sulla sicurezza. Devi usare AIMap solo contro sistemi che possiedi o per i quali hai ricevuto esplicito permesso scritto di test. L'accesso non autorizzato ai sistemi informatici è illegale. Bishop Fox non si assume alcuna responsabilità e non è responsabile di usi impropri o danni causati da questo strumento. Usalo in modo responsabile.

Cosa Fa

1. Scoprire — Interroga Shodan con oltre 32 query di ricerca curate per trovare endpoint AI/ML esposti su Internet
2. Identificare — Sonda ogni endpoint con template Nuclei e controlli HTTP live per identificare protocollo, framework, stato dell'autenticazione, strumenti, modelli e prompt di sistema
3. Valutare — Calcola un punteggio di rischio da 0 a 10 basato su autenticazione, esposizione degli strumenti, policy CORS, TLS, fuga del prompt di sistema e combinazioni pericolose di capacità
4. Testare — Lancia suite di attacco specifiche per protocollo (abuso degli strumenti MCP, estrazione dei modelli Ollama, injection di prompt) con risultati in streaming in tempo reale
5. Visualizzare — Globo 3D che mostra ogni endpoint scoperto, ricercabile con un linguaggio di query in stile Shodan

Architettura

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

Backend — Python/FastAPI con MongoDB asincrono (Motor), Redis Streams per lo streaming dei log degli attacchi e un motore di discovery che orchestra query Shodan → controlli di liveness httpx → scansioni dei template Nuclei → pipeline di arricchimento.

Frontend — React 18 + TypeScript + Tailwind CSS + shadcn/ui. Include un globo 3D (globe.gl), streaming degli attacchi in tempo reale via WebSocket e un'interfaccia di ricerca in stile Shodan.

Scanning — 5 template Nuclei YAML personalizzati per il rilevamento di server MCP, enumerazione degli strumenti MCP, rilevamento di API compatibili con OpenAI, rilevamento di LangServe e test di fuga del prompt.

Protocolli Supportati

Punteggio di Rischio

Ogni endpoint riceve un punteggio di rischio da 0 a 10 calcolato da:

Configurazione

Prerequisiti

• Python 3.12+
• Node.js 18+
• MongoDB 7+
• Redis 7+ (opzionale — in caso di sviluppo locale si ripiega sulla memoria)
• Nuclei (opzionale — necessario per la scansione attiva)
• Una chiave API Shodan (richiesta per le scansioni di discovery)

Avvio Rapido (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

Questo avvia 4 servizi:

• MongoDB sulla porta 27017
• Redis sulla porta 6379
• Backend sulla porta 8000
• Frontend sulla porta 80

Apri http://localhost per accedere all'interfaccia.

Sviluppo Locale (senza 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

Assicurati che MongoDB sia in esecuzione localmente sulla porta 27017. Redis è opzionale — il backend utilizza buffer in memoria quando Redis non è disponibile.

Variabili d'Ambiente

Crea un file .env nella radice del progetto:

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

Autenticazione (Clerk)

AIMap usa Clerk per l'autenticazione. Per abilitarla:

1. Crea un'applicazione Clerk su clerk.com
2. Imposta l'URL dell'issuer del backend:
   root@kitploit:~

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

3. Imposta la chiave pubblicabile del frontend:
   root@kitploit:~

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

Per disabilitare l'autenticazione (sviluppo locale, demo): lascia CLERK_ISSUER vuoto o non impostato. Il backend accetterà tutte le richieste con un'identità utente sintetica local.

Utilizzo

Eseguire una Scansione di Discovery

1. Vai su Scans nella barra laterale
2. Clicca su New Scan
3. Seleziona i preset di query (es. ollama, mcp_protocol, vllm) oppure inserisci una query Shodan personalizzata
4. Eventualmente limita l'ambito a un range CIDR (l'orchestratore antepone net:<cidr> a ogni query)
5. Clicca su Run — la pipeline di scansione esegue:
   • Shodan search — recupera gli host corrispondenti
   • httpx sweep — verifica che gli host siano attivi
   • Nuclei scan — esegue i template personalizzati sugli host attivi
   • Enrichment — rilevamento del framework, sondaggio dell'autenticazione, punteggio di rischio
6. Monitora l'avanzamento tramite la barra di stato WebSocket in tempo reale o interrogando la pagina di dettaglio della scansione

Ricerca degli Endpoint

Usa la barra di ricerca con la sintassi delle query in stile 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

Combina i filtri liberamente:

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

Qualsiasi testo che non corrisponde a un pattern key:value viene trattato come ricerca a testo libero su tutti i campi indicizzati.

Avvio dei Test di Attacco

1. Vai alla pagina di dettaglio di un endpoint
2. Clicca su Attack per aprire il pannello dei test
3. Seleziona un profilo di attacco — il sistema seleziona automaticamente il motore in base al protocollo:
   • MCP → Enumerazione degli strumenti, invocazione non autorizzata degli strumenti, injection di prompt tramite descrizioni degli strumenti
   • Ollama → Elenco dei modelli, estrazione dei pesi dei modelli, injection di prompt
   • OpenAI-compatible → Enumerazione dei modelli, abuso delle completion, estrazione del prompt di sistema
4. Osserva i risultati in streaming in tempo reale via WebSocket
5. I risultati includono livelli di gravità, coppie grezze richiesta/risposta e indicazioni di rimedio

Esplorare il Globo

La pagina iniziale include un globo 3D interattivo che mostra tutti gli endpoint scoperti:

• Colore del pin = tipo di protocollo (blu = MCP, verde = Ollama, viola = OpenAI-compat, ecc.)
• Altezza del pin = punteggio di rischio
• Passa il mouse per un riepilogo dell'endpoint (IP, porta, protocollo, rischio, autenticazione, strumenti, modello, posizione)
• Clicca per passare alla pagina di dettaglio dell'endpoint
• Trascina il mouse per ruotare, scorri per zoomare

Template Nuclei

Template personalizzati nella directory templates/:

Riferimento API

Tutti gli endpoint hanno il prefisso /api/.

Struttura del Progetto

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

Limiti di Concorrenza

La piattaforma applica limiti di concorrenza globali per prevenire abusi:

• Massimo 3 scansioni concorrenti — le scansioni aggiuntive ricevono HTTP 429
• Massimo 5 attacchi concorrenti — gli attacchi aggiuntivi ricevono HTTP 429
• Limitazione della frequenza — 10 richieste/minuto sugli endpoint di creazione di scansioni e attacchi

Quando si usa Docker Compose, questi limiti vengono applicati tramite contatori Redis (cross-container). In modalità di sviluppo locale, si ripiega su asyncio.Semaphore (single-process).

Opzionale: Modal Serverless

Per carichi di scansione pesanti, scansioni e attacchi possono essere inviati a contenitori Modal:

MODAL_ENABLED=true

Quando abilitato, POST /scans/{id}/run e POST /attack chiameranno modal.Function.from_name("aimap", "run_scan_task") / run_attack_task invece di eseguire localmente. Se l'invio a Modal fallisce, si ripiega sull'esecuzione locale.

Licenza

Licenza MIT. Vedi LICENSE per i dettagli.

Questo progetto è mantenuto da Bishop Fox.