AIMap

Plataforma de descoberta e testes de segurança em escala de internet para infraestrutura exposta de agentes de IA.

O AIMap encontra, identifica por impressão digital e testa a segurança de endpoints de IA publicamente expostos — servidores MCP, instâncias Ollama, proxies vLLM/LiteLLM, cadeias LangServe, aplicativos Gradio, nós ComfyUI e muito mais. Pense no Shodan, mas criado especificamente para a superfície de ataque de agentes de IA.

Criado pela Bishop Fox.

Aviso Esta ferramenta destina-se exclusivamente a testes de penetração autorizados e pesquisa de segurança. Você deve usar o AIMap apenas contra sistemas que possui ou para os quais tem permissão explícita por escrito para testar. O acesso não autorizado a sistemas de computador é ilegal. A Bishop Fox não assume nenhuma responsabilidade e não se responsabiliza por qualquer uso indevido ou dano causado por esta ferramenta. Use com responsabilidade.

O que a ferramenta faz

1. Descobrir — Consulta o Shodan com mais de 32 consultas de busca selecionadas para encontrar endpoints de IA/ML expostos na internet
2. Identificar — Sonda cada endpoint com templates do Nuclei e verificações HTTP ao vivo para identificar o protocolo, framework, status de autenticação, ferramentas, modelos e prompts de sistema
3. Pontuar — Calcula uma pontuação de risco de 0 a 10 com base em autenticação, exposição de ferramentas, política de CORS, TLS, vazamento de prompt de sistema e combinações perigosas de capacidades
4. Testar — Executa suítes de ataque específicas por protocolo (abuso de ferramentas MCP, extração de modelos Ollama, injeção de prompt) com resultados transmitidos em tempo real
5. Visualizar — Globo 3D mostrando todos os endpoints descobertos, pesquisável com uma linguagem de consulta no estilo Shodan

Arquitetura

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

Backend — Python/FastAPI com MongoDB assíncrono (Motor), Redis Streams para transmissão de logs de ataque e um mecanismo de descoberta que orquestra consultas Shodan → verificações de disponibilidade httpx → varreduras de templates Nuclei → pipeline de enriquecimento.

Frontend — React 18 + TypeScript + Tailwind CSS + shadcn/ui. Inclui um globo 3D (globe.gl), transmissão de ataques em tempo real via WebSocket e uma interface de busca no estilo Shodan.

Varredura — 5 templates YAML personalizados do Nuclei para detecção de servidores MCP, enumeração de ferramentas MCP, detecção de APIs compatíveis com OpenAI, detecção de LangServe e teste de vazamento de prompt.

Protocolos Suportados

Pontuação de Risco

Cada endpoint recebe uma pontuação de risco de 0 a 10 calculada a partir de:

Configuração

Pré-requisitos

• Python 3.12+
• Node.js 18+
• MongoDB 7+
• Redis 7+ (opcional — usa fallback em memória para desenvolvimento local)
• Nuclei (opcional — necessário para varredura ativa)
• Uma chave da API do Shodan (necessária para varreduras de descoberta)

Início Rápido (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

Isso inicia 4 serviços:

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

Abra http://localhost para acessar a interface.

Desenvolvimento Local (sem 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

Certifique-se de que o MongoDB esteja rodando localmente na porta 27017. O Redis é opcional — o backend usa buffers em memória quando o Redis não está disponível.

Variáveis de Ambiente

Crie um arquivo .env na raiz do projeto:

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

Autenticação (Clerk)

O AIMap usa Clerk para autenticação. Para habilitar:

1. Crie um aplicativo Clerk em clerk.com
2. Defina a URL do emissor no backend:
   root@kitploit:~

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

3. Defina a chave publicável do frontend:
   root@kitploit:~

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

Para desabilitar a autenticação (desenvolvimento local, demonstrações): deixe CLERK_ISSUER vazio ou não definido. O backend aceitará todas as requisições com uma identidade de usuário sintética local.

Uso

Executando uma Varredura de Descoberta

1. Navegue até Scans na barra lateral
2. Clique em New Scan
3. Selecione predefinições de consulta (ex.: ollama, mcp_protocol, vllm) ou insira uma consulta personalizada do Shodan
4. Opcionalmente, restrinja a um intervalo CIDR (o orquestrador adiciona net:<cidr> no início de cada consulta)
5. Clique em Run — o pipeline da varredura executa:
   • Busca Shodan — obtém os hosts correspondentes
   • Varredura httpx — verifica se os hosts estão ativos
   • Varredura Nuclei — executa templates personalizados nos hosts ativos
   • Enriquecimento — detecção de framework, sondagem de autenticação, pontuação de risco
6. Monitore o progresso pela barra de status WebSocket em tempo real ou consultando a página de detalhes da varredura

Pesquisando Endpoints

Use a barra de busca com a sintaxe de consulta no estilo 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

Combine filtros livremente:

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

Qualquer texto que não corresponda a um padrão key:value é tratado como uma busca de texto livre em todos os campos indexados.

Executando Testes de Ataque

1. Navegue até a página de detalhes de um endpoint
2. Clique em Attack para abrir o painel de teste
3. Selecione um perfil de ataque — o sistema seleciona automaticamente o mecanismo com base no protocolo:
   • MCP → Enumeração de ferramentas, invocação não autorizada de ferramentas, injeção de prompt via descrições de ferramentas
   • Ollama → Listagem de modelos, extração de pesos de modelos, injeção de prompt
   • Compatível com OpenAI → Enumeração de modelos, abuso de completions, extração de prompt de sistema
4. Acompanhe os resultados em tempo real via WebSocket
5. Os resultados incluem classificações de gravidade, pares brutos de requisição/resposta e orientações de correção

Explorando o Globo

A página inicial apresenta um globo 3D interativo mostrando todos os endpoints descobertos:

• Cor do pino = tipo de protocolo (azul = MCP, verde = Ollama, roxo = compatível com OpenAI, etc.)
• Altura do pino = pontuação de risco
• Passe o mouse para ver o resumo do endpoint (IP, porta, protocolo, risco, autenticação, ferramentas, modelo, localização)
• Clique para navegar até a página de detalhes do endpoint
• Arraste o mouse para girar, role para ampliar

Templates do Nuclei

Templates personalizados no diretório templates/:

Referência da API

Todos os endpoints são prefixados com /api/.

Estrutura do Projeto

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 Concorrência

A plataforma aplica limites globais de concorrência para evitar abuso:

• Máximo de 3 varreduras simultâneas — varreduras adicionais recebem HTTP 429
• Máximo de 5 ataques simultâneos — ataques adicionais recebem HTTP 429
• Limitação de taxa — 10 requisições/minuto nos endpoints de criação de varredura e ataque

Ao usar o Docker Compose, esses limites são aplicados por meio de contadores Redis (entre contêineres). No modo de desenvolvimento local, eles usam fallback para asyncio.Semaphore (processo único).

Opcional: Modal Serverless

Para cargas de trabalho pesadas de varredura, varreduras e ataques podem ser despachados para contêineres Modal:

MODAL_ENABLED=true

Quando habilitado, POST /scans/{id}/run e POST /attack chamarão modal.Function.from_name("aimap", "run_scan_task") / run_attack_task em vez de executar localmente. Usa fallback para execução local se o despacho no Modal falhar.

Licença

Licença MIT. Consulte LICENSE para obter detalhes.

Este projeto é mantido pela Bishop Fox.