🧠 NeuroSploit v4.0.0

Ferramenta autônoma de testes de penetração multimodelo — Rust, somente CLI.
por Joas A Santos & Líderes de Red Team

⭐ Se isso for útil, dê uma estrela no repositório — ajuda muito.

📖 Novo aqui? Leia o Tutorial completo e Guia do Usuário → — cada modo, flag, configuração e exemplo explicado. Mudanças versão por versão ficam em RELEASE.md.

NeuroSploit transforma uma URL, um repositório de código-fonte, um aplicativo em execução ou um host/IP em um engajamento de segurança autônomo. Um harness em Rust (tokio) aciona um pool de LLMs — via chave de API ou assinatura local (Claude Code / Codex / Gemini / Grok) — faz reconhecimento do alvo, seleciona de forma inteligente apenas os agentes que correspondem à superfície descoberta, executa-os em paralelo, encadeia achados em impacto mais profundo e valida cada afirmação por votação entre modelos + fundamentação com recibos de ferramentas antes de relatar. Ele traz 435 agentes markdown e uma TUI do Mission Control.

Modos de engajamento

Destaques

• 🧠 Crença POMDP + valor da informação — o alvo é parcialmente observável, então os achados não são booleanos: uma crença em grafo de propriedades carrega probabilidades, e "escanear mais vs explorar agora" emerge da entropia da crença. A comporta may_assert é uma regra matemática anti-alucinação (não afirme exploração enquanto a crença estiver difusa).
• 🧾 Fundamentação — regra rígida: nenhuma afirmação sem recibo (evidência, não paráfrase). Empírica (saída bruta da ferramenta) para black-box/host/AI, simbólica (file:line no código-fonte revisado — uma citação de código é o recibo) para auditorias SAST white-box e de skills, e qualquer uma para grey-box; afirmações sem fundamentação são rebaixadas.
• 🔬 Sonda HTTP determinística — antes do reconhecimento do modelo, o harness executa uma análise real de requisição/resposta (status/redirecionamentos, cabeçalhos de segurança, flags de cookie, reflexo de CORS, impressão digital de tecnologia, JS vinculado, linha de base 404, caminhos de alto sinal) e alimenta o reconhecimento com esses fatos observados, de modo que a seleção de agentes e as decisões de exploração sejam fundamentadas em evidências — não no palpite do modelo.
• 🔗 Encadeamento de ataques — qualquer primitiva pivota. 13 agentes de cadeia de múltiplos estágios (SQLi→RCE→LPE, SSRF→credenciais na nuvem, upload→LFI→RCE→LPE, CVE→RCE→pivot, …) mais uma doutrina de encadeamento que transforma qualquer ponto de apoio confirmado no próximo passo: reduza-o a uma primitiva (exec / read / write / request-forgery / identidade / segredo) e pivote — upload de arquivo→RCE, SSRF→credenciais de metadata, IDOR→tomada de controle — reutilizando credenciais obtidas e raciocinando sobre lógica de negócio (abuso de pagamento/inquilinato/workflow). Cada estágio comprovado; estritamente não destrutivo (sem perda de dados, sem sobrescrita de BD, sem DoS).
• ☁️ Testes em nuvem — agentes AWS / GCP / Azure que acionam as CLIs dos provedores (aws/gcloud/az). Conecte via creds.yaml: chaves AWS, um JSON de conta de serviço do Google ou um service principal do Azure — veja Credenciais de nuvem.
• 🤖 Red-teaming de LLM — 30 agentes de IA que fazem jailbreak e injeção de prompt em um sistema de IA ao vivo em vários cenários: AdvPrefix, PAIR, TAP, Crescendo, many-shot, persona/DAN, codificação/obfuscação, supressão de recusa; além de injeção indireta (saída de RAG/web/e-mail/ferramenta), sequestro de objetivo, abuso de ferramenta/chamada de função e exfiltração do prompt do sistema. Cada um executa um loop atacante→juiz-LLM (recusa inicial → técnica → veredito) e prova o bypass com um recibo benigno e redigido. Mapeia para OWASP LLM Top 10 (2025), ameaças MCP e OWASP AI Exchange; arquivos Skill/plugin e n8n auditados em white-box.
• 🧰 Caça a misconfigurações & CVEs → exploração, com segurança — um pipeline completo de CVE: impressão digital de versão (fixar versões exatas) → analista de pesquisa (mapear para CVEs NVD/GHSA, julgar alcançabilidade) → localizador de PoC (localizar/avaliar/adaptar um PoC público) → script de exploração (escrever um exploit personalizado quando nenhum existe). Cada PoC é gravado na pasta pocs/ da execução e referenciado no relatório para que os achados sejam reproduzíveis. Além de agentes de misconfiguração absurda (.git/.env expostos, debug/actuator, credenciais padrão, dashboards, CORS) e testes de limite de taxa — tudo sob uma salvaguarda estrita de segurança de dados/PII (sem ações destrutivas ou de alteração de estado; PII comprovada com amostra mascarada, nunca despejada).
• 🎯 Re-testar uma vulnerabilidade — --only <agent> (repetível / separado por vírgula) executa exatamente o(s) agente(s) que você nomear e pula a seleção baseada em reconhecimento — repita o teste de um único achado rapidamente. Funciona em run / whitebox / greybox; neurosploit agents lista os nomes.
• 🔬 White-box permanece white-box — agentes de código executam sob uma doutrina de revisão estática (recibos simbólicos file:line, rastreamento de taint source-to-sink, versão de manifesto→CVE) que proíbe ações de rede ao vivo/black-box alucinadas e pode emitir um PoC de reprodução para pocs/.
• 🗣️ REPL em linguagem natural — na sessão interativa, basta descrever o que você quer, em qualquer idioma: "testa https://loja.com com opus, foco em SQLi, fora de escopo /admin, roda". Um parser híbrido define alvo/modelos/foco/objetivo/fora de escopo e alterna opções (Burp, navegador, votos, profundidade de reconhecimento) e pode iniciar — parse determinístico de zero token para as formas comuns, fallback de modelo para qualquer coisa ambígua. Nenhuma flag para memorizar.
• 🔀 Portão de PR em CI/CD — neurosploit pr <repo> <n> --fail-on critical revisa um pull request e, ao confirmar um achado no limite ou acima dele, reprova o check, define um status de commit neurosploit/security e envia uma review REQUEST_CHANGES — assim a proteção de branch bloqueia o merge. Workflows prontos do GitHub Actions incluídos (portão de PR + um bot de menção @neurosploit que executa uma varredura quando um escritor comenta). Veja Integrações.
• 🎯 Objetivo do engajamento e fora de escopo — forneça a meta/contexto e exclusões rígidas em palavras (/objective, /scope-out, ou --objective / --out-of-scope); ambos orientam o prompt de cada agente.
• 📸 Capturas de tela como prova nos relatórios — os agentes capturam prova visual por achado (evidence/<finding-id>-N.png), incorporada ao lado da respectiva vulnerabilidade nos relatórios Typst/HTML/Markdown.
• 🖥️ Modelos locais, sem censura e somente CPU — ollama: e llamacpp: executam todo o engajamento na sua máquina sem chave de API e sem dados saindo do host. llamacpp: conversa com um endpoint compatível com OpenAI llama-server (LLAMACPP_BASE_URL, padrão localhost:8080); o model é o gguf que você carregou. Ideal para trabalho offline/air-gapped e prompts ofensivos sem filtro.
• 🕵️ Proxy Burp/ZAP — /proxy <url> (ou /burp) roteia o tráfego dos agentes pelo seu proxy interceptador local para que você possa inspecionar e repetir no Burp.
• 🗺️ Grafo de ataque e kill chain — achados mapeados para OWASP / CWE / MITRE ATT&CK / estágio; renderizados como um grafo Mermaid no relatório.
• ✅ Validação entre modelos — um modelo diferente arbitra cada achado; seleção de agentes ponderada por RL e ciente do reconhecimento.
• 🛰️ TUI Mission Control — painéis ao vivo de cabeçalho/feed/achados/alvos + um compositor no qual você pode digitar enquanto a execução está em fluxo (summary, pause, …).
• 💾 Memória por projeto — <cwd>/.neurosploit/ mantém sessão, histórico de execuções e histórico de comandos; o REPL retoma ao reabrir. Nenhum banco de dados necessário.
• 🪙 Telemetria de tokens/custos, atribuição por agente, Ctrl-C gracioso → relatório ou descartar, relatórios Typst/HTML/JSON/MD.

Esta é a distribuição enxuta, somente Rust (neurosploit-rs/ + agents_md/). O motor Python anterior e as GUIs web estão no branch mais antigo v3.4.0.

📦 Instalação (uma linha)

Linux / macOS (x64 & arm64):```bash curl -fsSL https://raw.githubusercontent.com/JoasASantos/NeuroSploit/main/setup.sh | bash

**Windows** (PowerShell, x64 & arm64):```powershell
irm https://raw.githubusercontent.com/JoasASantos/NeuroSploit/main/install.ps1 | iex

Plataformas suportadas

Rust puro + stdlib, então compila nativamente em qualquer lugar onde uma toolchain Rust estável roda. O instalador detecta automaticamente o SO/arquitetura e instala o Rust se estiver ausente. No Windows nativo, use install.ps1; no WSL2 / Git Bash, o one-liner setup.sh também funciona.

O instalador instala o Rust automaticamente se necessário, clona o repositório em ~/.neurosploit, compila o binário de release e vincula neurosploit em ~/.local/bin. Execute-o novamente a qualquer momento para atualizar. Ajuste com variáveis de ambiente: NEUROSPLOIT_REF (branch/tag), NEUROSPLOIT_DIR, PREFIX.

Prefere compilar manualmente?```bash git clone https://github.com/JoasASantos/NeuroSploit && cd NeuroSploit/neurosploit-rs cargo build --release # → target/release/neurosploit

## ⚡ Início rápido (60 segundos)```bash
# easiest path — just run it; the interactive session asks everything:
neurosploit

# or one-liner (subscription login, no API key needed):
neurosploit run http://testphp.vulnweb.com/ --subscription --model anthropic:claude-opus-4-8 -v

# white-box — review a source repository (SAST agents, file:line evidence):
git clone https://github.com/digininja/DVWA /tmp/DVWA
neurosploit whitebox /tmp/DVWA --subscription --model anthropic:claude-opus-4-8 -v

# grey-box — review the code AND exploit the running app together:
neurosploit greybox /tmp/DVWA --url http://localhost:8080/ --creds creds.yaml \
  --subscription --model anthropic:claude-opus-4-8 --mcp -v

# host / infra — Linux / Windows / Active Directory (SSH/Win creds in creds.yaml):
neurosploit host 10.0.0.10 --creds creds.yaml --subscription --model anthropic:claude-opus-4-8 -v

# 🛰  Mission Control TUI — live panels (header/feed/findings/targets) + a composer
#    you can type in WHILE the run streams (summary · pause · errors · notes):
neurosploit tui http://testphp.vulnweb.com/ --subscription --model anthropic:claude-opus-4-8 --mcp

Passo a passo completo para cada modo (black/white/grey/host) está em TUTORIAL.md.

Sem login? Use uma chave de API em vez disso — veja Autenticação.

🖥️ Console web (NOVO na v4.0.0)

Uma interface de navegador para o mesmo harness — cada ação executa o verdadeiro CLI compilado e faz o parse da sua saída; nada da lógica do harness é reimplementado no navegador.```bash cd neurosploit-rs && cargo build --release # once node web/server.js # → http://localhost:4173

Zero dependências npm (apenas built-ins do Node).

- **Assistente de engajamento em 5 etapas** — Ativo (modo + alvo/repo) → Escopo e Autenticação (objetivo, foco,
  fora de escopo) → Leads (o quadro de 435 agentes abaixo) → Modelo e Execução (seletor de provedor/modelo,
  alternância chave de API vs. assinatura, votos/profundidade de cadeia/recon) → Revisão. Cada engajamento é nomeado
  antecipadamente, para que as execuções sejam identificáveis no histórico em vez de pela string bruta do alvo.
- **Quadro de leads** — todos os 435 agentes auto-categorizados (Lógica de Negócios, Controle de Acesso Quebrado,
  Injeção, Aplicação LLM, Autenticação e Sessão, SSRF e Rede, Nuvem e Infra, …). Alterne um único
  lead, uma categoria inteira (indeterminada quando parcialmente selecionada) ou use **Selecionar tudo / Limpar
  tudo** — respeita o filtro de busca ativo. Deixe tudo desativado para que a própria seleção orientada por recon
  do harness escolha.
- **Lead personalizado → agente real** — "+ Lead personalizado" não apenas adiciona uma dica de texto: ele chama a
  CLI `claude` (Opus, sua assinatura Anthropic) para gerar um arquivo markdown de agente especialista real em
  `agents_md/vulns/`, no mesmo formato usado por todos os agentes integrados, fixável
  imediatamente. Caso o Claude não esteja disponível, volta para uma dica simples de texto de foco.
- **Visualização de execução ao vivo** — fase/progresso transmitidos via SSE a partir do próprio stdout da CLI, uma tabela
  de achados e **Encadeamento Generativo de Caminhos de Ataque**: um grafo de nós/arestas (raiz = alvo, um nó por
  achado confirmado, posicionado por estágio da kill chain, arestas de `chains_from` quando o harness
  define uma) em vez de uma lista plana — clique em qualquer nó ou linha para ver o detalhe completo do achado,
  incluindo qualquer script PoC que o agente explorador escreveu em `pocs/`.
- **Autenticação e Chaves** (um menu) — cabeçalho de auth do alvo + funções nomeadas para testes de IDOR/BOLA/BFLA
  (materializa um `creds.yaml` efêmero para a execução) e chaves de API por provedor mantidas apenas na
  memória do processo do servidor — nunca gravadas em disco.
- Sobrevive ao recarregar a página: uma execução em andamento se reconecta ao mesmo stream ao vivo em vez de
  voltar ao assistente.

Referência completa da API: **[web/API.md](https://github.com/joasasantos/neurosploit/blob/HEAD/web/API.md)** · início rápido: **[web/README.md](https://github.com/joasasantos/neurosploit/blob/HEAD/web/README.md)**.

---

## 🔌 Integrações (GitHub · GitLab · Jira)

Integre o NeuroSploit ao seu SDLC. Ative a partir do REPL (`/integrations`) ou da CLI
(`neurosploit integrations enable github|gitlab|jira`). **Os tokens nunca são armazenados**
— apenas o *nome* da variável de ambiente é salvo; o valor é lido do seu ambiente.```bash
export GITHUB_TOKEN=ghp_...                 # PAT with `repo` scope (private repos)
neurosploit integrations enable github

# Review a Pull Request's code (clones the PR head, white-box) and comment back:
neurosploit pr digininja/DVWA 42 --subscription --model anthropic:claude-opus-4-8 --comment

# Same, but BLOCK the merge on a confirmed critical: fails the check, sets a
# `neurosploit/security` commit status, and posts a REQUEST_CHANGES review.
neurosploit pr digininja/DVWA 42 --model anthropic:claude-opus-4-8 --comment --fail-on critical

# Watch a branch and re-review on every new commit:
neurosploit watch myorg/private-app --branch main --subscription --model anthropic:claude-opus-4-8

# Private GitLab repo (token-injected clone) — works in whitebox/greybox:
export GITLAB_TOKEN=glpat-... ; neurosploit integrations enable gitlab
neurosploit whitebox https://gitlab.com/myorg/private-svc --subscription --model anthropic:claude-opus-4-8

# Open a Jira card per finding (any engagement):
export [email protected] JIRA_API_TOKEN=...      # set base/project once: /integrations setup jira
neurosploit whitebox https://github.com/myorg/app --jira --subscription --model anthropic:claude-opus-4-8

Automações (GitHub Actions)

Dois workflows prontos estão em examples/github-actions/ — copie-os para o seu repositório:

• neurosploit-pr-gate.yml — revisa cada PR e bloqueia o merge em caso de crítico confirmado. Torne-o obrigatório: Configurações → Branches → exija a verificação de status neurosploit-pr-gate (e/ou exija uma revisão para respeitar o REQUEST_CHANGES). Defina ANTHROPIC_API_KEY (ou troque o modelo) nos segredos do Actions; o GITHUB_TOKEN integrado cobre os status/revisões.
• neurosploit-mention.yml — comente @neurosploit em um PR ou issue para acionar uma varredura (somente quem tem permissão de escrita no repositório). O texto após a menção é a instrução (qualquer idioma): @neurosploit focus SQLi and IDOR, ou @neurosploit scan https://staging.app para uma execução black-box.

📖 Configuração passo a passo para cada ferramenta: TUTORIAL-INTEGRATION.md.

☁️ Credenciais de nuvem (AWS/GCP/Azure)

Adicione um bloco de nuvem ao creds.yaml e o harness exporta as variáveis de ambiente corretas para que os agentes AWS/GCP/Azure possam usar aws / gcloud / az. Os segredos permanecem no seu arquivo/gerenciador de segredos; os agentes fazem primeiro a enumeração somente leitura, nunca destrutiva.```yaml

--- AWS: static keys (or a named profile) ---

aws: access_key_id: AKIA... secret_access_key: ...

session_token: ... # if using temporary creds

region: us-east-1

profile: my-sso-profile # alternative to keys

--- GCP: service-account JSON (path recommended; inline single-line also works) ---

gcp: service_account_json: /path/to/sa.json project: my-project-id

--- Azure: service principal (recommended for automation) ---

azure: tenant_id: ... client_id: ... client_secret: ... subscription_id: ...

No input content was provided to translate. Please supply the chunk text.```bash
neurosploit host my-cloud-account --creds creds.yaml \
  --subscription --model anthropic:claude-opus-4-8 -v

Agentes abrangem escalada de privilégios em IAM, exposição de armazenamento (S3/GCS/Blob), exposição de computação e rede, segredos (Secrets Manager / Secret Manager / Key Vault), abuso de contas de serviço/SP e enumeração de identidades (Entra ID). Autenticação recomendada: AWS chaves de acesso ou perfil; GCP um JSON de conta de serviço (GOOGLE_APPLICATION_CREDENTIALS); Azure um principal de serviço (az login --service-principal).

👥 Múltiplas identidades — teste de controle de acesso (IDOR / BOLA / BFLA)

Dê ao NeuroSploit dois ou mais papéis nomeados em creds.yaml e ele autentica como cada um e testa o acesso entre papéis (um papel de baixo privilégio alcançando o objeto de outro usuário ou uma função de administrador é um achado):```yaml admin: jwt: eyJ... # per role: jwt | header (raw) | cookie | apikey | login+username+password user: apikey: abc123 # → X-Api-Key: abc123 victim: cookie: "session=deadbeef"

(no content provided)```bash
neurosploit run https://app.example --creds creds.yaml \
  --subscription --model anthropic:claude-opus-4-8 -v

Cada descoberta é comprovada com o par de requisições autorizado vs não autorizado, sob a salvaguarda de segurança de dados (somente leitura, PII mascarado).

🏷️ Identificação e atribuição (anti-plágio)

Cada requisição é marcada com um User-Agent identificador (padrão NeuroSploit/<ver> …, altere com /ua ou NEUROSPLOIT_UA) além de um cabeçalho X-NeuroSploit-Scan, e cada descoberta é carimbada com "Identified and validated by NeuroSploit" — para que a proveniência viaje no tráfego, no texto da descoberta, no findings.json e no rodapé do relatório.

Build```bash

cd neurosploit-rs cargo build --release # → target/release/neurosploit

Requer uma toolchain Rust (`rustup`). **Recomendado: executar no Kali Linux** (ou na
imagem Docker do Kali) para que as ferramentas ofensivas que os agentes usam já estejam presentes:```bash
docker run -it --rm kalilinux/kali-rolling
apt update && apt install -y curl nmap ffuf nodejs npm
# rustscan (faster port scan): cargo install rustscan   (or grab a release from GitHub)

Os agentes degradam-se graciosamente: se rustscan não estiver instalado, usam nmap; se nenhum dos dois, eles sondam com curl. Se um navegador Playwright MCP estiver disponível, eles o usam para páginas com muito JavaScript; caso contrário, recorrem ao curl.

Uso

Execute sem argumentos para obter um assistente interativo:```bash ./target/release/neurosploit

Ou execute-o diretamente:```bash
# Black-box — subscription (no API key), Opus, browser via Playwright if present, verbose
./target/release/neurosploit run http://testphp.vulnweb.com/ \
    --subscription --model anthropic:claude-opus-4-8 --mcp -v

# Black-box — API keys, multi-model voting panel (1st finds, others adjudicate)
./target/release/neurosploit run http://testphp.vulnweb.com/ \
    --model anthropic:claude-opus-4-8 --model openai:gpt-5.1 --vote-n 3

# White-box — clone a vulnerable app and review its source
git clone https://github.com/digininja/DVWA /tmp/DVWA
./target/release/neurosploit whitebox /tmp/DVWA \
    --subscription --model anthropic:claude-opus-4-8 -v

# Offline pipeline self-test (no keys/login needed)
./target/release/neurosploit run http://testphp.vulnweb.com/ --offline

# Utilities
./target/release/neurosploit agents     # library counts
./target/release/neurosploit models      # providers & models
./target/release/neurosploit --help        # full help with examples

Opções (run / whitebox)

Autenticação — execute via chave de API ou assinatura

Você pode executar o NeuroSploit de duas formas. Elas são independentes: escolha por execução.

1) Via API (chave de API do provedor)

Exporte a(s) chave(s) dos provedores no seu painel de modelos e execute sem --subscription. Qualquer provedor compatível com OpenAI funciona.```bash

pick one or more, depending on the models you select

export ANTHROPIC_API_KEY=sk-ant-... # anthropic:claude-* export OPENAI_API_KEY=sk-... # openai:gpt-* export GEMINI_API_KEY=AIza... # gemini:gemini-* export XAI_API_KEY=xai-... # xai:grok-* export NVIDIA_NIM_API_KEY=nvapi-... # nvidia_nim:* export DEEPSEEK_API_KEY=... # deepseek:* export MISTRAL_API_KEY=... # mistral:* export DASHSCOPE_API_KEY=... # qwen:* (Alibaba DashScope) export GROQ_API_KEY=... # groq:* export TOGETHER_API_KEY=... # together:* export MOONSHOT_API_KEY=... # moonshot:* (Kimi K3/K2) export OPENROUTER_API_KEY=... # openrouter:* export OPENCODE_API_KEY=... # opencode:* (OpenCode Zen gateway) export NOUS_API_KEY=... # nous:* (Nous Portal — Hermes) export LITELLM_API_KEY=... # litellm:* (your LiteLLM proxy) export AZURE_OPENAI_API_KEY=... # azure: (also set AZURE_OPENAI_ENDPOINT)

ollama / llamacpp need no key (local)

then run via API (note: NO --subscription)

./target/release/neurosploit run http://testphp.vulnweb.com/
--model anthropic:claude-opus-4-8 --vote-n 3 -v

multi-provider voting panel via API (1st finds, the others adjudicate)

./target/release/neurosploit run http://testphp.vulnweb.com/
--model anthropic:claude-opus-4-8 --model openai:gpt-5.1 --model gemini:gemini-2.5-pro

Ou coloque as chaves em um `.env` e carregue-o (`cp .env.example .env`; edite; `set -a; . ./.env; set +a`).

**Provedor → var de ambiente → endpoint** (todos compatíveis com OpenAI):

| `--model` prefix | Var de ambiente | URL base |
|------------------|---------|----------|
| `anthropic:` | `ANTHROPIC_API_KEY` | api.anthropic.com |
| `openai:` | `OPENAI_API_KEY` | api.openai.com |
| `gemini:` | `GEMINI_API_KEY` | generativelanguage.googleapis.com |
| `xai:` | `XAI_API_KEY` | api.x.ai |
| `nvidia_nim:` | `NVIDIA_NIM_API_KEY` | integrate.api.nvidia.com |
| `deepseek:` | `DEEPSEEK_API_KEY` | api.deepseek.com |
| `mistral:` | `MISTRAL_API_KEY` | api.mistral.ai |
| `qwen:` | `DASHSCOPE_API_KEY` | dashscope-intl.aliyuncs.com |
| `groq:` | `GROQ_API_KEY` | api.groq.com |
| `together:` | `TOGETHER_API_KEY` | api.together.xyz |
| `moonshot:` | `MOONSHOT_API_KEY` | api.moonshot.ai |
| `openrouter:` | `OPENROUTER_API_KEY` | openrouter.ai |
| `opencode:` | `OPENCODE_API_KEY` | opencode.ai/zen (gateway OpenCode Zen) |
| `nous:` | `NOUS_API_KEY` | inference-api.nousresearch.com (Hermes 4) |
| `litellm:` | `LITELLM_API_KEY` | seu proxy LiteLLM (`LITELLM_BASE_URL`, padrão localhost:4000) |
| `azure:` | `AZURE_OPENAI_API_KEY` | seu recurso Azure OpenAI (`AZURE_OPENAI_ENDPOINT`) |
| `ollama:` | _(nenhuma)_ | localhost:11434 |
| `llamacpp:` | _(nenhuma)_ | localhost:8080 |

Execute `./target/release/neurosploit models` para obter a lista completa de provedores/modelos.

> **Local, sem censura e somente CPU** — `ollama:` e `llamacpp:` executam inteiramente na
> sua máquina, sem chave de API e sem que dados saiam do host. `llamacpp:` tem como alvo um
> endpoint compatível com OpenAI do [`llama-server`](https://github.com/ggml-org/llama.cpp)
> (substituível com `LLAMACPP_BASE_URL`); o `model` é qualquer gguf que você
> carregou. Ideal para engajamentos offline e prompts ofensivos sem filtro.

#### 2) Via assinatura (sem chave de API)

`--subscription` controla o login do seu CLI agêntico local em vez de uma chave de API — instale e faça login em um dos CLIs primeiro:

| `--model` prefix | CLI usado | Login |
|------------------|----------|-------|
| `anthropic:` | `claude` (Claude Code) | `claude` depois `/login` |
| `openai:` | `codex` | `codex` login |
| `gemini:` | `gemini` | `gemini` login |
| `xai:` | `grok` | `grok` login |
| `opencode:` | `opencode` | `opencode auth login` (ou `/connect` na TUI) — conta Zen/plan |
| `nous:` | `hermes` | `hermes setup --portal` — Nous Portal OAuth |

`opencode:` também recebe o Playwright MCP (`--mcp`) assim como anthropic/openai. `nous:` em vez disso, depende dos próprios conjuntos de ferramentas integrados do Hermes (web/terminal/computer-use) — ele não tem hook de MCP no nível de CLI.```bash
./target/release/neurosploit run http://testphp.vulnweb.com/ \
    --subscription --model anthropic:claude-opus-4-8 --mcp -v

Como funciona```

target ─▶ recon (curl/nmap/…) ─▶ INTELLIGENT agent selection (recon-aware) ─▶ parallel exploitation ─▶ cross-model validation vote ─▶ severity/score ─▶ report (HTML + Typst PDF) ─▶ RL reward update

Cada execução grava uma pasta autocontida `runs/ns-<ts>-<target>/`:

| Arquivo | Conteúdo |
|------|----------|
| `status.json` | `running` → `complete` com um resumo |
| `recon.json` / `recon.md` | superfície de ataque mapeada |
| `exploitation.md` | transcrição bruta por agente |
| `findings.json` / `findings.md` | descobertas validadas (reutilizáveis por outras ferramentas/IAs) |
| `report.html`, `report.typ`, `report.pdf` | relatório final (PDF via o mecanismo Typst) |

Um armazenamento de recompensas de aprendizado por reforço (`data/rl_state_rs.json`) influencia a seleção de agentes em execuções futuras.

## Biblioteca de agentes — `agents_md/` (435)

| Categoria | Quantidade | Finalidade |
|----------|-------|---------|
| `vulns/` | 245 | Explorar uma classe específica de vulnerabilidade (web/API) |
| `code/` | 78 | Revisão de código-fonte white-box (SAST) |
| `ai/` | 30 | Red-teaming de IA/LLM, jailbreaks, ameaças MCP |
| `infra/` | 34 | Host/nuvem: Linux, Windows, AD, AWS/GCP/Azure |
| `meta/` | 23 | Orquestrador, validador, pontuadores, relator, RL |
| `chains/` | 13 | Cadeias de ataque em vários estágios (SQLi→RCE→LPE, SSRF→nuvem, …) |
| `recon/` | 12 | Coleta de informações / superfície de ataque |

Cada agente é um playbook markdown autocontido (metodologia `## User Prompt` + regras rigorosas `## System Prompt` anti-falsos-positivos). Coloque um novo `.md` na pasta correspondente — ou gere um a partir do "+ Custom lead" do console web (veja acima) — e o harness o reconhece; `neurosploit agents` mostra contagens em tempo real.

---

## Segurança

Somente para testes **autorizados**. Os agentes são instruídos a permanecer no escopo, nunca executar ações destrutivas/DoS e exigir prova de exploração. Você é responsável por ter permissão para qualquer alvo.

## Créditos

**Joas A Santos** e **Líderes de Red Team**.

## Licença

MIT.