Vigolium - Scanner de vulnerabilidades de alta fidelidade que combina IA agêntica com velocidade nativa, modularidade e precisão

O Vigolium oferece dois modos de varredura complementares:

Varredura Nativa (vigolium scan): Rápida, poderosa e flexível. Varredura determinística em múltiplas fases com 317 módulos em descoberta de conteúdo, rastreamento de navegador/SPA e auditoria ativa/passiva, cobrindo injeção, controle de acesso, arquivo/caminho, API/protocolo, específicos de frameworks, nuvem/infraestrutura e classes de vulnerabilidades fora de banda (OAST).
Varredura Agêntica (vigolium agent): Audita minuciosamente seu código-fonte. Varredura orientada por IA que planeja ataques de forma autônoma, seleciona módulos, gera extensões personalizadas e faz triagem de resultados, combinando auditoria profunda de código-fonte com varredura de vulnerabilidades autônoma e direcionada.

Instalação

Instalação Rápida (Recomendada)```bash

curl -fsSL https://vigolium.com/install.sh | bash

### [npm](https://www.npmjs.com/package/@vigolium/vigolium)```bash
npm install -g @vigolium/vigolium

Windows

A instalação via npm acima funciona no Windows. Alternativamente, baixe vigolium_<version>_windows_amd64.zip da página de releases, extraia-o e coloque vigolium.exe em algum lugar do seu PATH.

O Windows é distribuído apenas em x64; no Windows ARM, ele roda sob emulação. O instalador de shell acima é exclusivo para POSIX, portanto vigolium update não está disponível no Windows — execute novamente a instalação via npm ou baixe o zip mais recente para atualizar.

Outro método, como Docker ou compilar a partir do código-fonte

Docker```bash

docker pull j3ssie/vigolium:latest docker run --rm j3ssie/vigolium:latest scan -h

### Compilar a partir do Código-Fonte```bash
git clone https://github.com/vigolium/vigolium.git
cd vigolium
make build         # build and install to $GOPATH/bin

Requer Go 1.27+ e bun 1.3.11+. Consulte HACKING.md para pré-requisitos e detalhes de compilação.

Painel de UI	Painel de Tráfego

Relatórios Estáticos	Relatórios Estáticos

Scan Nativo	Scan Agêntico

Principais Recursos

Scan Nativo

323 módulos de scanner: 207 ativos (fuzzing) + 116 passivos (correspondência de padrões), cobrindo OWASP Top 10 e além
Testes fora de banda (OAST): XSS cego/SSRF/injeção de comandos via callbacks do interactsh com correlação automática de payloads
Mutação ciente de valor: classifica parâmetros por tipo semântico (inteiro, UUID, JWT, email) e muta conforme a intenção
Pipeline multifásico: coleta externa, descoberta de conteúdo (Deparos), spidering de navegador/SPA (Spitolas) e auditoria, controlados por predefinições de estratégia e perfis de varredura
Entradas flexíveis: URLs, OpenAPI/Swagger, Postman, Burp Suite, cURL, Nuclei JSONL
Autenticação multissessão: sessões inline, arquivos de sessão ou configurações completas de autenticação com fluxos de login, extração de tokens e testes de IDOR/BOLA
Extensões JavaScript: módulos e hooks personalizados via mecanismo JS embutido com APIs HTTP cientes de sessão
Escalável e reportável: pool de workers concorrente com limitação de taxa por host, fila híbrida em memória/disco/Redis e relatórios HTML autocontidos

Scan Agêntico

Runtime olium em processo: cada modo de agente roda no mecanismo Go nativo pkg/olium: loop baseado em turnos, registro de ferramentas integrado, suporte a skills e drivers de provedor plugáveis (sem pools de SDK de subprocessos)
Autopilot: o agente descobre endpoints de forma autônoma, executa varreduras e tria descobertas, com pipeline multi-especialista opcional e retomada de sessão
Swarm: o agente mestre seleciona módulos, gera extensões de ataque JS personalizadas, executa auditoria de código + SAST, realiza varreduras e tria resultados; escopo direcionado ou completo (--discover), com --diff/--last-commits para execuções focadas em mudanças
Drivers de auditoria de código-fonte: audit, piolium e o dispatcher unificado audit executam auditorias de código-fonte em primeiro plano compartilhando um único esquema de descobertas e marcação no banco de dados
Modo de consulta: prompts de uso único para revisão de código, descoberta de endpoints e detecção de segredos
Provedores plugáveis: openai-compatible (padrão), openai-codex-oauth, openai-api-key, openai-responses, anthropic-api-key, anthropic-oauth, anthropic-cli, anthropic-compatible, anthropic-vertex, google-vertex. Os mesmos modos expostos via API REST com streaming SSE e um endpoint de chat compatível com OpenAI

Início Rápido: Scan Nativo```bash

Scan a single target (default: balanced strategy)

vigolium scan -t https://example.com

Scan with a strategy preset

vigolium scan -t https://example.com --strategy deep

Scan specific modules only

vigolium scan -t https://example.com -m xss-reflected,sqli-error

Scan from an OpenAPI spec

vigolium scan -T openapi.yaml -I openapi

Pipe URLs from stdin

cat urls.txt | vigolium scan

Run a single phase directly

vigolium run discovery -t https://example.com

Generate an HTML report

vigolium scan -t https://example.com --only discovery --format html -o report.html

Consulte a [visão geral da arquitetura](https://docs.vigolium.com/architecture/overview) para ver o pipeline completo e o [guia de estratégias](https://docs.vigolium.com/native-scan/strategies) para estratégias, perfis e configuração de ritmo. Para uma referência rápida de comandos, consulte [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet).

## Modo Servidor```bash
# Start API server with authentication
vigolium server -k my-secret-key

# Enable transparent HTTP proxy for traffic recording
vigolium server -k my-key --ingest-proxy-port 9003

# Auto-scan ingested traffic
vigolium server -k my-key --scan-on-receive

Aqui está a tradução do conteúdo fornecido:

Instalação

Requisitos

Python 3.8 ou superior
pip (gerenciador de pacotes do Python)

Instalação via pip

Para instalar a ferramenta, execute o seguinte comando:

pip install kitploit-tool

Instalação a partir do código-fonte

Se preferir instalar a partir do repositório, clone o projeto e instale as dependências:

git clone https://github.com/example/kitploit-tool.git
cd kitploit-tool
pip install -r requirements.txt

Verificação da instalação

Após a instalação, verifique se a ferramenta foi instalada corretamente:

kitploit-tool --version

Se tudo estiver configurado corretamente, você verá a versão instalada exibida no terminal.

Uso

Comandos básicos

A ferramenta oferece vários comandos para diferentes finalidades. Abaixo estão alguns exemplos de uso comum:

kitploit-tool scan --target example.com
kitploit-tool exploit --module exemplo --payload reverse_shell
kitploit-tool report --format html --output relatorio.html

Opções globais

As seguintes opções podem ser usadas com qualquer comando:

--verbose: Exibe informações detalhadas durante a execução.
--quiet: Suprime a saída não essencial.
--config FILE: Especifica um arquivo de configuração personalizado.

Exemplos

Executar uma varredura básica

kitploit-tool scan --target https://exemplo.com

Usar um módulo específico

kitploit-tool exploit --module exemplo --options "porta=8080,ssl=true"

Gerar um relatório

kitploit-tool report --format pdf --output relatorio.pdf

Configuração

Arquivo de configuração

A ferramenta pode ser configurada por meio de um arquivo YAML ou JSON. O arquivo padrão é config.yaml no diretório atual. Um exemplo de configuração:

alvo:
  url: "https://exemplo.com"
  porta: 443
opcoes:
  verbose: true
  timeout: 30
modulos:
  - nome: "exemplo"
    habilitado: true

Variáveis de ambiente

Algumas opções podem ser definidas por meio de variáveis de ambiente, que têm precedência sobre o arquivo de configuração:

KITPLOIT_TARGET: Define o alvo padrão.
KITPLOIT_TIMEOUT: Define o tempo limite padrão em segundos.
KITPLOIT_VERBOSE: Define se a saída detalhada está habilitada (true ou false).

Solução de problemas

Problemas comuns

Erro de permissão negada

Se você encontrar um erro de permissão ao executar a ferramenta, tente usar sudo (no Linux/macOS) ou execute o terminal como administrador (no Windows).

Dependências ausentes

Se houver dependências ausentes, instale-as manualmente:

pip install -r requirements.txt

Porta já em uso

Se a porta especificada já estiver em uso, altere a porta no arquivo de configuração ou use a opção --porta.

Contribuição

Como contribuir

Agradecemos contribuições! Para contribuir com o projeto, siga estas etapas:

Faça um fork do repositório.
Crie um branch para sua funcionalidade (git checkout -b feature/nova-funcionalidade).
Faça commit das suas alterações (git commit -am 'Adiciona nova funcionalidade').
Envie para o branch (git push origin feature/nova-funcionalidade).
Abra um Pull Request.

Diretrizes de desenvolvimento

Siga o estilo de código PEP 8.
Escreva testes para novas funcionalidades.
Atualize a documentação conforme necessário.

Licença

Este projeto é licenciado sob a licença MIT. Consulte o arquivo LICENSE para obter mais detalhes.

Agradecimentos

Agradecemos a todos os colaboradores e à comunidade de segurança cibernética que apoiam este projeto.

---```bash

Ingest traffic to a running server

cat urls.txt | vigolium ingest -s http://localhost:9002

Ingest an OpenAPI spec

vigolium ingest -s http://localhost:9002 -i api.yaml -I openapi

Consulte [execução do servidor](https://docs.vigolium.com/server-mode/running-the-server) para configuração do servidor, [ingestão](https://docs.vigolium.com/server-mode/ingestion) para fluxos de trabalho de ingestão e a [visão geral da API](https://docs.vigolium.com/api-overview) para a referência completa da API REST.

> **Integrações de proxy**: encaminhe tráfego de proxy ao vivo para um servidor Vigolium em execução com a extensão [burp-vigolium](https://github.com/vigolium/burp-vigolium) para Burp Suite ou o plugin [caido-vigolium](https://github.com/vigolium/caido-vigolium) para Caido. Ambos usam o mesmo protocolo de ponte (`-B/--burp-bridge-url`, alias `--caido-bridge-url`), e o tráfego ingerido é rotulado com o proxy de origem.

## Varredura Autenticada

O Vigolium suporta varredura autenticada de múltiplas sessões para testes de IDOR/BOLA e verificações de escalonamento de privilégios:```bash
# Inline session via CLI flag (name:Header:value)
vigolium scan -t https://example.com \
  --auth "admin:Cookie:session_id=abc123" \
  --auth "user:Cookie:session_id=xyz789"

# Load session(s) from a YAML/JSON file
vigolium scan -t https://example.com --auth-file ./admin-session.yaml

# Auth file with an automated login flow (token extraction, etc.)
vigolium scan -t https://example.com --auth-file ./login-flow.yaml

# Add custom headers (works with sessions)
vigolium scan -t https://example.com -H "Authorization: Bearer token123"

Arquivos de autenticação suportam cabeçalhos estáticos, tokens bearer e fluxos de login automatizados com extração de tokens de cookies, respostas JSON ou cabeçalhos. Exemplos predefinidos estão disponíveis em public/presets/sessions/. Consulte o guia de autenticação para o guia completo.

As flags --auth / --auth-file eram anteriormente chamadas de --session / --session-file. Os nomes antigos ainda funcionam como aliases obsoletos.

Varredura Agêntica

Varredura orientada por IA, onde agentes planejam, executam e fazem triagem de avaliações de vulnerabilidades de forma autônoma, com o mecanismo de varredura nativo por baixo:```bash

Autopilot: autonomous AI-driven scanning (in-process olium engine)

vigolium agent autopilot -t https://example.com vigolium agent autopilot -t https://example.com --source ./src --prompt "focus on auth bypass" vigolium agent autopilot -t https://example.com --diff main...feature/auth # diff-focused vigolium agent autopilot -t https://example.com --intensity deep # preset bundle

Swarm: AI-guided targeted or full-scope vulnerability scanning

vigolium agent swarm -t https://example.com/api/users --vuln-type sqli vigolium agent swarm -t https://example.com --discover # full-scope vigolium agent swarm -t https://example.com --source ./src --discover # source-aware full-scope vigolium agent swarm --input "curl -X POST https://example.com/api/login -d '{"user":"admin"}'"

Source-audit drivers (separate harness, do not route through olium)

vigolium agent audit --source ./src # default: auto (audit, fall back to piolium) vigolium agent audit --source ./src --driver audit --mode deep # vigolium-audit only (claude/codex) vigolium agent audit --source ./src --driver piolium --mode balanced # Pi-native (pi extension) only vigolium agent audit --source ./src --driver both # audit then piolium, back-to-back vigolium agent audit --source ./src --modes deep,confirm # chain modes (same as --intensity deep) vigolium agent audit --source ./src -S --output-dir ./audit-out # throwaway DB + bundled HTML report vigolium audit --source ./src # top-level alias

Direct olium access (TUI or headless)

vigolium ol # launch the olium TUI vigolium ol --prompt "..." # one-shot prompt (-p implies headless)

Modos de varredura agêntica:
- **Autopilot**: varredura autônoma. A CLI chama `pkg/olium/autopilot.Run` diretamente; o servidor adiciona preparação de auditoria vigolium-audit, configuração de autenticação e um pacote de contexto congelado em torno do mesmo loop
- **Swarm**: varredura de vulnerabilidades guiada por IA com suporte a solicitação única direcionada e escopo completo (`--discover`). O agente mestre analisa entradas, seleciona módulos, gera extensões JS personalizadas, executa auditoria de código e SAST, realiza varreduras e faz triagem dos resultados
- **Audit**: auditoria de código-fonte via `vigolium agent audit` — um despachante unificado que executa os harnesses embutidos **vigolium-audit** (claude/codex) e/ou **piolium** (nativo Pi), selecionados com `--driver {auto|both|audit|piolium}` (padrão `auto`: faz pré-verificação da etapa de auditoria e a executa quando a CLI `claude`/`codex` resolvida está no PATH, o binário está embutido e a cadeia tem um modo compatível com auditoria; caso contrário, recorre ao piolium sem iniciar a auditoria. Uma falha de auditoria no meio da execução é exibida em vez de trocar de driver). Harnesses separados; **não** roteie pelo olium. Linhas filhas por driver sob um único AgenticScan pai com deduplicação de achados pós-processamento. Não existe subcomando `agent piolium` autônomo — o piolium é executado via `--driver=piolium`

> **CLIs de auditoria autônomas**: a auditoria de segurança agêntica também é fornecida como CLIs autônomas que você pode executar independentemente do Vigolium: [vigolium-audit](https://github.com/vigolium/vigolium-audit) (o harness por trás de `vigolium agent audit`) e [piolium](https://github.com/vigolium/piolium) (o driver nativo Pi por trás de `vigolium agent audit --driver=piolium`).

Consulte o [guia de modo agente](https://docs.vigolium.com/agentic-scan/agent-mode) para o guia completo.

## ⚡ Vigolium Cloud Console

Uma solução baseada em nuvem para equipes que desejam o poder do Vigolium sem gerenciar infraestrutura. O Console é a **versão atualizada e completa do Vigolium**, liderada por um **agente autônomo avançado** que conduz todo o engajamento — raciocinando sobre o alvo, escolhendo seus próprios caminhos de ataque e confirmando o que encontra — com varredura hospedada e resultados compartilhados sobrepostos ao núcleo de código aberto, para que você possa se concentrar em corrigir vulnerabilidades em vez de manter ferramentas.

> Interessado? [Entre em contato para uma demonstração](https://www.vigolium.com/request-demo).

## Camadas de Varredura Nativas

O pipeline de varredura nativa é composto por camadas modulares, cada uma documentada separadamente:

| Camada | Descrição | Docs |
|-------|-------------|------|
| **Descoberta de Conteúdo (Deparos)** | Enumeração adaptativa de diretórios/arquivos com detecção de soft-404 baseada em fingerprint | [docs.vigolium.com/native-scan/phases/discovery](https://docs.vigolium.com/native-scan/phases/discovery) |
| **Spider de Navegador (Spitolas)** | Rastreador de máquina de estados orientado por Chromium com captura de tráfego CDP | [docs.vigolium.com/native-scan/phases/spidering](https://docs.vigolium.com/native-scan/phases/spidering) |
| **Auditoria** | Varredura de vulnerabilidades ativa/passiva com extração de pontos de inserção e framework DiffScan | [docs.vigolium.com/native-scan/phases/audit](https://docs.vigolium.com/native-scan/phases/audit) |
| **Módulos de Scanner** | 207 módulos ativos e 116 passivos cobrindo OWASP Top 10 e além | [docs.vigolium.com/native-scan/modules-reference](https://docs.vigolium.com/native-scan/modules-reference) |

## Documentação

A documentação completa está em [docs.vigolium.com](https://docs.vigolium.com/). Notas de versão e histórico de versões estão no [CHANGELOG](https://github.com/vigolium/vigolium/blob/main/CHANGELOG.md). Links rápidos:

| Tópico | Link |
|-------|------|
| Configurar Agentes | [docs.vigolium.com/getting-started/setup-agent](https://docs.vigolium.com/getting-started/setup-agent) |
| Iniciar uma Varredura Nativa | [docs.vigolium.com/getting-started/native-scan](https://docs.vigolium.com/getting-started/native-scan) |
| Iniciar uma Varredura Agêntica | [docs.vigolium.com/getting-started/agentic-scan](https://docs.vigolium.com/getting-started/agentic-scan) |
| Iniciar uma Auditoria Agêntica | [docs.vigolium.com/getting-started/agentic-security-audit](https://docs.vigolium.com/getting-started/agentic-security-audit) |
| Início Rápido | [docs.vigolium.com/getting-started/quickstart](https://docs.vigolium.com/getting-started/quickstart) |
| Folha de Referência | [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet) |
| Servidor e Ingestão | [docs.vigolium.com/getting-started/server-and-ingestion](https://docs.vigolium.com/getting-started/server-and-ingestion) |
| Escrevendo Extensões | [docs.vigolium.com/customization/writing-extensions](https://docs.vigolium.com/customization/writing-extensions) |

## Mecanismo JavaScript

Execute código JavaScript/TypeScript diretamente ou escreva módulos de varredura e hooks personalizados sem recompilar:```bash
# Execute inline JavaScript
vigolium js --code 'let r = vigolium.http.get(TARGET); console.log(r.status)' -t https://example.com

# Run a JS file with timeout
vigolium js --code-file ./my-script.js -t https://example.com --timeout 60s

# Manage extensions
vigolium ext ls                # list loaded extensions
vigolium ext docs --example    # browse API with code examples
vigolium ext preset            # install starter scripts

O motor JS expõe APIs HTTP com reconhecimento de sessão para testes autenticados:```javascript // Create a persistent session with shared cookie jar. // post() takes a string body — serialize objects yourself. let session = vigolium.http.session(); session.post( "https://app.example.com/login", JSON.stringify({ user: "admin", pass: "secret" }), { headers: { "Content-Type": "application/json" } } ); session.get("https://app.example.com/dashboard"); // cookies auto-sent

// Automated login flow with token extraction let authed = vigolium.http.login({ url: "https://app.example.com/api/auth", method: "POST", body: JSON.stringify({ username: "admin", password: "pass" }), extract: [{ source: "json", path: "$.token", apply_as: "Authorization: Bearer {value}" }] });

// IDOR/BOLA testing across multiple sessions let results = vigolium.http.authTest({ sessions: { admin: adminSession, user: userSession }, requests: [{ method: "GET", url: "https://app.example.com/api/users/1" }] });

// Multi-step authentication sequences let result = vigolium.http.sequence([ { url: "/csrf", extract: [{ source: "cookie", name: "csrf_token", as: "token" }] }, { url: "/login", method: "POST", body: "csrf={token}&user=admin" } ]);

// Parallel request batching (race conditions, IDOR) let responses = vigolium.http.batch([req1, req2, req3], { concurrency: 10 });

// CSRF token extraction let csrf = vigolium.http.csrf("https://app.example.com/form");

// HTTP request replay with variations let varied = vigolium.http.replay(rawRequest, [ { headers: { "Authorization": "Bearer admin_token" } }, { headers: { "Authorization": "Bearer user_token" } } ]);

Consulte o [guia de escrita de extensões](https://docs.vigolium.com/customization/writing-extensions) e o `pkg/jsext/vigolium.d.ts` para as definições completas da API TypeScript.

## Referência da CLI

<details>
<summary>Expandir a referência completa de comandos e flags</summary>

### Comandos```
Scanning:
  vigolium scan                Run a native scan (deterministic multi-phase vulnerability scanning)
  vigolium run <phase>         Run a single native scan phase (alias for scan --only <phase>)
  vigolium scan-url <url>      Quick native scan of a single URL
  vigolium scan-request        Native scan from a raw HTTP request

Agentic scan (in-process olium engine):
  vigolium agent autopilot     Autonomous AI-driven vulnerability scanning
  vigolium agent swarm         AI-guided targeted or full-scope vulnerability scanning
  vigolium agent query         Single-shot prompt (code review, endpoint discovery)
  vigolium agent olium         Direct olium TUI (or one-shot non-interactive via -p)
  vigolium agent audit         Unified driver dispatcher (vigolium-audit and/or piolium, --driver=auto|both|audit|piolium)
  vigolium agent session       Browse/replay agent session artifacts
  vigolium olium | vigolium ol Top-level alias for `vigolium agent olium`

Server & ingestion:
  vigolium server              Start the API server with traffic ingestion
  vigolium ingest              Ingest traffic to a running server
  vigolium storage             Interact with cloud object storage (uploads, downloads)

Data & projects:
  vigolium db                  Database operations (list, stats, export, clean, seed)
  vigolium finding             Browse and manage findings (load, tui)
  vigolium traffic             Browse and replay HTTP records (tui, replay)
  vigolium replay              Mutate a stored/supplied HTTP request and diff baseline vs replay
  vigolium project             Manage projects (create, list, use, config)
  vigolium scope               Manage scope rules
  vigolium import              Import findings/data from external sources
  vigolium export              Export scan results

Extensions & auth:
  vigolium js                  Execute JavaScript/TypeScript code
  vigolium ext                 Manage JavaScript extensions (eval, lint)
  vigolium auth                Manage authentication sessions (list, load, lint, totp)

Setup & introspection:
  vigolium init                Initialize a Vigolium workspace
  vigolium config              Manage configuration (ls, set, path, clean)
  vigolium strategy            Inspect scanning strategies and phases
  vigolium module              Inspect/enable scanner modules
  vigolium doctor              Diagnose environment & dependencies
  vigolium version             Show version info

Sinalizadores```

Native Scan (vigolium scan / run): -t, --target Target URL -T, --target-file File containing target URLs -i, --input Input file path (- for stdin) -I, --input-mode Input format: urls, openapi, swagger, burp, curl, nuclei, har -m, --modules Modules to run (comma-separated or 'all') --strategy Strategy preset: lite, balanced, deep --scanning-profile Scanning profile name or YAML path --only Phases to run (comma-separated): ingestion, discovery (deparos), external-harvest, spidering (spitolas), known-issue-scan, dynamic-assessment, extension --skip Phases to skip (repeatable, same names as --only) -S, --stateless Use a throwaway temp database, discarded after the scan --fail-on Exit non-zero when a finding at/above this severity is present

Authentication: --auth Inline session definition (name:Header:value, repeatable) --auth-file Session YAML/JSON file path, supports login flows (repeatable) -H, --header Custom HTTP header (repeatable)

Performance: -c, --concurrency Concurrent workers (default: 50) -r, --rate-limit Max requests/sec (default: 0 = unlimited) --max-per-host Per-host concurrency cap (default: 2) --proxy HTTP/SOCKS5 proxy URL --timeout HTTP request timeout (default: 15s)

Agentic Scan (vigolium agent autopilot / swarm / query): --source Path to source code for source-aware scanning --files Specific files to include relative to --source --source-label Label for source code ingestion --provider Olium provider: openai-compatible (default), openai-codex-oauth, openai-api-key, openai-responses, anthropic-api-key, anthropic-oauth, anthropic-cli, anthropic-compatible, anthropic-claude-sdk-bridge, anthropic-vertex, google-vertex --model Model ID override --oauth-token OAuth bearer token (anthropic-oauth) --oauth-cred OAuth/SA file path (openai-codex-oauth, anthropic-vertex, google-vertex) --llm-api-key API key (anthropic-api-key, openai-api-key) --vuln-type Vulnerability type focus (sqli, xss, ssrf, ...) --prompt Free-text task guidance (same as the positional [prompt]) --plan-file Plan file mixing guidance + raw seed HTTP request(s) --knowledge-base File/dir describing the app; prose is distilled, traffic exports (HAR/Burp/curl/OpenAPI/Postman) are ingested --prior-context Front-load existing project traffic/findings: auto, summary, off --intensity Preset bundle: quick, balanced, deep --diff Diff range / PR URL / HEAD~~N for change-focused scans --last-commits Shorthand for --diff HEAD~~N --code-audit Enable AI code audit (default: on with --source) --discover Run discovery+spidering before planning (swarm) --audit vigolium-audit mode: lite, balanced, deep, mock, off --piolium Piolium audit mode (empty = auto-pick) --resume Resume a durable-autopilot run by agentic-scan UUID --session-dir Pin the session dir for this run's debug artifacts --transcript Copy transcript.jsonl out after the run --max-iterations Max triage-rescan iterations --max-commands Cap on agent tool calls --token-budget Cap on aggregate tokens --max-duration Max agent wall-clock time (0 = no limit) --only / --skip / --start-from Phase control (swarm)

Source audit (vigolium agent audit / vigolium audit): --driver auto (default), both, audit, piolium --intensity Preset: quick, balanced, deep (deep = modes deep,confirm) --mode Mode override: lite, balanced, deep, revisit, confirm, merge, ... --modes Chain modes back-to-back (e.g. deep,confirm) --list-modes Print the audit mode graph and exit --agent Coding agent for the audit leg: claude or codex --keep-raw Keep raw output under /vigolium-results/ (on by default) --clean-raw Remove the source-tree raw copy after the run -S, --stateless Run into a throwaway DB and auto-render an HTML report --output-dir Bundle the HTML report + raw results into one folder (needs -S) --no-dedup Skip the post-pass project-wide findings dedup --no-preflight Skip the pre-audit auth/model roundtrip checks -i, --interactive Drive the audit yourself in the coding agent (audit driver only)

JavaScript: --code Inline JavaScript to execute --code-file Path to JS/TS file to execute --timeout Execution timeout (default: 30s)

Output: -j, --json Compact, token-aware JSON output (read/query commands) --format Output format (comma-separated for multiple): console, jsonl, html, sqlite (needs -S), fs (flat traffic/finding tree) -o, --output Output file path --silent Suppress all output except findings -v, --verbose Verbose logging

</details>

## Layout do Repositório

O diretório `platform/` contém ferramentas externas, o Dashboard de UI e não faz parte do scanner principal. Nenhuma alteração deve ser feita nele.

## Benchmarks

O Vigolium é continuamente avaliado contra aplicações intencionalmente vulneráveis e também amplamente testado contra alvos do mundo real por meio de programas de bug bounty e divulgação responsável.

- **Auto-hospedado (Docker):** [DVWA](https://github.com/digininja/DVWA), [OWASP Juice Shop](https://github.com/juice-shop/juice-shop), [VAmPI](https://github.com/erev0s/VAmPI), [crAPI](https://github.com/OWASP/crAPI), [Vulnerable Java App](https://github.com/DataDog/vulnerable-java-application), [Vulnerable Nginx](https://github.com/detectify/vulnerable-nginx), [OopsSec Store](https://github.com/kOaDT/oss-oopssec-store) (aplicativo Next.js personalizado)
- **Externo (hospedado):** [Acunetix TestPHP](http://testphp.vulnweb.com), [Gin & Juice Shop](https://ginandjuice.shop), [Testfire](http://demo.testfire.net)
- **XSS e múltiplas vulnerabilidades:** [BruteLogic XSS](https://github.com/vigolium/vigolium/blob/main/test/benchmark/xss_scanner), [XBOW](https://github.com/vigolium/vigolium/blob/main/test/benchmark/definitions/xbow) (XSS, SQLi, SSTI, LFI, SSRF, XXE, injeção de comandos)

Execute os benchmarks com `make test-canary` (aplicativos Docker) ou `make test-integration` (XSS).

## Desenvolvimento```bash
make build          # build and install
make test           # run all tests (auto-installs gotestsum)
make test-unit      # fast unit tests (-short, no external deps)
make test-e2e       # E2E tests (requires Docker)
make lint           # run linter
make fmt            # format code

Consulte o HACKING.md para o guia completo de build, o mapa do código-fonte e o guia de desenvolvimento de módulos.

Segurança

O Vigolium é uma ferramenta de segurança ofensiva, e duas partes dela são intencionalmente permissivas: o modo agente executa sem sandbox (o LLM tem acesso total ao shell, arquivos e rede no host) e as extensões podem executar comandos arbitrários. Execute o modo agente em um contêiner/VM descartável limitado ao escopo do engajamento e trate extensões não confiáveis como código não confiável. Consulte o SECURITY.md antes de começar e relate vulnerabilidades no próprio Vigolium de forma privada para [email protected].

Licença

O Vigolium é distribuído sob a GNU Affero General Public License v3.0. Trabalhos derivados devem permanecer abertos sob os mesmos termos.

Feito com ♥ por @j3ssie, com @theblackturtle como contribuidor inicial principal.

Ler mais

vigolium v0.4.4

Categorias