Vigolium - Escáner de vulnerabilidades de alta fidelidad que fusiona IA agéntica con velocidad nativa, modularidad y precisión

Vigolium ofrece dos modos de escaneo complementarios:

Native Scan (vigolium scan): Rápido, potente y flexible. Escaneo determinista y multifase con 317 módulos que abarcan el descubrimiento de contenido, el rastreo de navegadores/SPA y la auditoría activa/pasiva, cubriendo clases de vulnerabilidades de inyección, control de acceso, archivos/rutas, API/protocolo, específicas de frameworks, nube/infraestructura y fuera de banda (OAST).
Agentic Scan (vigolium agent): Audita exhaustivamente tu base de código. Escaneo impulsado por IA que planifica ataques de forma autónoma, selecciona módulos, genera extensiones personalizadas y clasifica los resultados, combinando la auditoría profunda de código fuente con el escaneo de vulnerabilidades autónomo y dirigido.

Instalación

Instalación 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

La instalación de npm anterior funciona en Windows. Alternativamente, descarga vigolium_<version>_windows_amd64.zip desde la página de releases, extráelo y coloca vigolium.exe en algún lugar de tu PATH.

Windows se distribuye solo como x64; en Windows ARM se ejecuta bajo emulación. El instalador de shell anterior es solo para POSIX, por lo que vigolium update no está disponible en Windows — vuelve a ejecutar la instalación de npm o descarga el zip más reciente para actualizar.

Otro método como Docker o compilar desde el código fuente

Docker```bash

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

### Compilar desde el código fuente```bash
git clone https://github.com/vigolium/vigolium.git
cd vigolium
make build         # build and install to $GOPATH/bin

Requiere Go 1.27+ y bun 1.3.11+. Consulta HACKING.md para los requisitos previos y los detalles de compilación.

Panel de UI	Panel de tráfico

Informes estáticos	Informes estáticos

Escaneo nativo	Escaneo agéntico

Patrocinador

_{Gracias a Daytona por patrocinar la infraestructura de sandbox}

Características principales

Escaneo nativo

323 módulos de escaneo: 207 activos (fuzzing) + 116 pasivos (coincidencia de patrones), cubriendo OWASP Top 10 y más allá
Pruebas fuera de banda (OAST): XSS/SSRF/inyección de comandos ciegos mediante callbacks de interactsh con correlación automática de payloads
Mutación consciente del valor: clasifica los parámetros por tipo semántico (integer, UUID, JWT, email) y muta según la intención
Pipeline multifase: recolección externa, descubrimiento de contenido (Deparos), spidering de navegador/SPA (Spitolas) y auditoría, controlado por presets de estrategia y perfiles de escaneo
Entradas flexibles: URLs, OpenAPI/Swagger, Postman, Burp Suite, cURL, Nuclei JSONL
Autenticación multisession: sesiones inline, archivos de sesión o configuraciones de autenticación completas con flujos de login, extracción de tokens y pruebas IDOR/BOLA
Extensiones JavaScript: módulos y hooks personalizados mediante un motor JS embebido con APIs HTTP conscientes de la sesión
Escalable y reportable: pool de workers concurrente con limitación de tasa por host, cola híbrida en memoria/disco/Redis e informes HTML autocontenidos

Escaneo agéntico

Runtime olium en proceso: cada modo de agente se ejecuta sobre el motor nativo de Go pkg/olium: bucle basado en turnos, registro de herramientas integrado, soporte de skills y drivers de proveedor conectables (sin pools de SDK en subprocesos)
Autopilot: el agente descubre endpoints, ejecuta escaneos y clasifica hallazgos de forma autónoma, con pipeline multi-especialista opcional y reanudación de sesión
Swarm: el agente maestro selecciona módulos, genera extensiones de ataque JS personalizadas, ejecuta auditoría de código + SAST, ejecuta escaneos y clasifica resultados; con alcance dirigido o completo (--discover), con --diff/--last-commits para ejecuciones centradas en cambios
Drivers de auditoría de código fuente: audit, piolium y el despachador unificado audit ejecutan auditorías de código fuente en primer plano compartiendo un único esquema de hallazgos y etiquetado en la base de datos
Modo de consulta: prompts de un solo disparo para revisión de código, descubrimiento de endpoints y detección de secretos
Proveedores conectables: openai-compatible (predeterminado), openai-codex-oauth, openai-api-key, openai-responses, anthropic-api-key, anthropic-oauth, anthropic-cli, anthropic-compatible, anthropic-vertex, google-vertex. Los mismos modos se exponen a través de la API REST con streaming SSE y un endpoint de chat compatible con OpenAI

Inicio rápido: Escaneo 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

Consulta la [descripción general de la arquitectura](https://docs.vigolium.com/architecture/overview) para conocer el pipeline completo y la [guía de estrategias](https://docs.vigolium.com/native-scan/strategies) para estrategias, perfiles y configuración del ritmo. Para una referencia rápida de comandos, consulta [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

Ejemplos

# Escaneo básico
tool --url https://example.com

# Escaneo con hilos personalizados
tool --url https://example.com --threads 10

# Escaneo con proxy
tool --url https://example.com --proxy http://127.0.0.1:8080

# Escaneo con encabezados personalizados
tool --url https://example.com --header "Authorization: Bearer token"

# Escaneo con cookies
tool --url https://example.com --cookie "session=abc123"

# Escaneo con datos POST
tool --url https://example.com --method POST --data "key=value"

# Escaneo de múltiples objetivos desde un archivo
tool --list targets.txt

# Escaneo con filtrado de resultados
tool --url https://example.com --filter "status==200"

# Escaneo con limitación de velocidad
tool --url https://example.com --rate-limit 5

# Escaneo con User-Agent aleatorio
tool --url https://example.com --random-agent

# Escaneo con seguimiento de redirecciones
tool --url https://example.com --follow-redirects

# Escaneo omitiendo la verificación SSL
tool --url https://example.com --insecure

# Escaneo en modo silencioso
tool --url https://example.com --silent

# Escaneo con salida de depuración
tool --url https://example.com --debug

Configuración

La herramienta se puede configurar mediante un archivo de configuración. La ubicación predeterminada es ~/.config/tool/config.yaml.

# Configuración de ejemplo
url: https://example.com
threads: 10
timeout: 30
retry: 3
output: json
proxy: http://127.0.0.1:8080
user_agent: "Mozilla/5.0"
follow_redirects: true
insecure: false
rate_limit: 5

Solución de problemas

El comando no se encuentra

Asegúrese de que el directorio binario esté en su PATH:

export PATH=$PATH:/usr/local/bin

Permiso denegado

Otorgue permisos de ejecución al binario:

chmod +x /usr/local/bin/tool

Conexión rechazada

Verifique que el objetivo sea accesible y que el firewall no esté bloqueando la conexión:

curl -v https://example.com

Tiempo de espera agotado

Aumente el valor del tiempo de espera:

tool --url https://example.com --timeout 60

Errores de certificado SSL

Utilice la opción --insecure para omitir la verificación del certificado:

tool --url https://example.com --insecure

Contribuir

Agradecemos las contribuciones. Por favor, asegúrese de seguir las siguientes pautas:

Haga un fork del repositorio
Cree una rama de funcionalidad (git checkout -b feature/nueva-funcionalidad)
Confirme sus cambios (git commit -am 'Añadir nueva funcionalidad')
Suba la rama (git push origin feature/nueva-funcionalidad)
Abra una Pull Request

Licencia

Este proyecto está licenciado bajo la Licencia MIT. Consulte el archivo LICENSE para más detalles.

Descargo de responsabilidad

Esta herramienta está destinada únicamente a pruebas de seguridad autorizadas y fines educativos. Los autores no se hacen responsables de ningún uso indebido o daño causado por esta herramienta. Utilícela de manera responsable y solo en sistemas que posea o tenga permiso explícito para probar.

Agradecimientos

Contacto

Sitio web: https://example.com
Twitter: @example
Correo electrónico: [email protected]```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

Consulta [ejecutar el servidor](https://docs.vigolium.com/server-mode/running-the-server) para la configuración del servidor, [ingesta](https://docs.vigolium.com/server-mode/ingestion) para los flujos de trabajo de ingesta, y la [descripción general de la API](https://docs.vigolium.com/api-overview) para la referencia completa de la API REST.

> **Integraciones de proxy**: reenvía el tráfico de proxy en vivo a un servidor Vigolium en ejecución con la extensión [burp-vigolium](https://github.com/vigolium/burp-vigolium) para Burp Suite o el plugin [caido-vigolium](https://github.com/vigolium/caido-vigolium) para Caido. Ambos sirven el mismo protocolo de puente (`-B/--burp-bridge-url`, alias `--caido-bridge-url`), y el tráfico ingestado se etiqueta con el proxy del que proviene.

## Escaneo Autenticado

Vigolium admite escaneo autenticado multisessión para pruebas de IDOR/BOLA y comprobaciones de escalada de privilegios:```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"

Los archivos de autenticación admiten encabezados estáticos, tokens de portador y flujos de inicio de sesión automatizados con extracción de tokens desde cookies, respuestas JSON o encabezados. Hay ejemplos predefinidos disponibles en public/presets/sessions/. Consulta la guía de autenticación para obtener la guía completa.

Los indicadores --auth / --auth-file se llamaban anteriormente --session / --session-file. Los nombres antiguos siguen funcionando como alias obsoletos.

Escaneo agéntico

Escaneo impulsado por IA donde los agentes planifican, ejecutan y clasifican evaluaciones de vulnerabilidad de forma autónoma con el motor de escaneo nativo subyacente:```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 escaneo agéntico:
- **Autopilot**: escaneo autónomo. La CLI llama directamente a `pkg/olium/autopilot.Run`; el servidor añade la preparación de vigolium-audit, la configuración de autenticación y un paquete de contexto congelado alrededor del mismo bucle
- **Swarm**: escaneo de vulnerabilidades guiado por IA que admite solicitud única dirigida y alcance completo (`--discover`). El agente maestro analiza las entradas, selecciona módulos, genera extensiones JS personalizadas, ejecuta auditoría de código y SAST, ejecuta escaneos y clasifica los resultados
- **Audit**: auditoría de código fuente mediante `vigolium agent audit` — un despachador unificado que ejecuta los arneses integrados **vigolium-audit** (claude/codex) y/o **piolium** (nativo de Pi), seleccionados con `--driver {auto|both|audit|piolium}` (predeterminado `auto`: verificación previa de la rama de auditoría y su ejecución cuando la CLI resuelta `claude`/`codex` está en el PATH, el binario está integrado y la cadena tiene un modo compatible con auditoría; de lo contrario, recurre a piolium sin lanzar la auditoría. Un fallo de auditoría a mitad de ejecución se manifiesta en lugar de cambiar de controlador). Arneses separados; **no** enrutar a través de olium. Filas secundarias por controlador bajo un AgenticScan principal con deduplicación de hallazgos posterior a la pasada. No existe un subcomando independiente `agent piolium` — piolium se ejecuta mediante `--driver=piolium`

> **CLIs de auditoría independientes**: la auditoría de seguridad agéntica también se distribuye como CLIs independientes que puedes ejecutar al margen de Vigolium: [vigolium-audit](https://github.com/vigolium/vigolium-audit) (el arnés detrás de `vigolium agent audit`) y [piolium](https://github.com/vigolium/piolium) (el controlador nativo de Pi detrás de `vigolium agent audit --driver=piolium`).

Consulta la [guía del modo agente](https://docs.vigolium.com/agentic-scan/agent-mode) para la guía completa.

## ⚡ Vigolium Cloud Console

Una solución basada en la nube para equipos que quieren el poder de Vigolium sin gestionar infraestructura. Console es la **versión mejorada y con todas las funciones de Vigolium**, liderada por un **agente autónomo avanzado** que dirige todo el compromiso — razonando sobre el objetivo, eligiendo sus propias rutas de ataque y confirmando lo que encuentra — con escaneo alojado y resultados compartidos superpuestos sobre el núcleo de código abierto, para que puedas centrarte en corregir vulnerabilidades en lugar de mantener herramientas.

> ¿Te interesa? [Ponte en contacto para una demo](https://www.vigolium.com/request-demo).

## Capas de escaneo nativo

El pipeline de escaneo nativo se compone de capas modulares, cada una documentada por separado:

| Capa | Descripción | Documentación |
|-------|-------------|------|
| **Content Discovery (Deparos)** | Enumeración adaptativa de directorios/archivos con detección de soft-404 basada en huellas | [docs.vigolium.com/native-scan/phases/discovery](https://docs.vigolium.com/native-scan/phases/discovery) |
| **Browser Spider (Spitolas)** | Rastreador de máquina de estados impulsado por Chromium con captura de tráfico CDP | [docs.vigolium.com/native-scan/phases/spidering](https://docs.vigolium.com/native-scan/phases/spidering) |
| **Audit** | Escaneo de vulnerabilidades activo/pasivo con extracción de puntos de inserción y framework DiffScan | [docs.vigolium.com/native-scan/phases/audit](https://docs.vigolium.com/native-scan/phases/audit) |
| **Scanner Modules** | 207 módulos activos y 116 pasivos que cubren OWASP Top 10 y más allá | [docs.vigolium.com/native-scan/modules-reference](https://docs.vigolium.com/native-scan/modules-reference) |

## Documentación

La documentación completa está en [docs.vigolium.com](https://docs.vigolium.com/). Las notas de la versión y el historial de versiones están en el [CHANGELOG](https://github.com/vigolium/vigolium/blob/main/CHANGELOG.md). Enlaces rápidos:

| Tema | Enlace |
|-------|------|
| Setup Agents | [docs.vigolium.com/getting-started/setup-agent](https://docs.vigolium.com/getting-started/setup-agent) |
| Start a Native Scan | [docs.vigolium.com/getting-started/native-scan](https://docs.vigolium.com/getting-started/native-scan) |
| Start an Agentic Scan | [docs.vigolium.com/getting-started/agentic-scan](https://docs.vigolium.com/getting-started/agentic-scan) |
| Start an Agentic Audit | [docs.vigolium.com/getting-started/agentic-security-audit](https://docs.vigolium.com/getting-started/agentic-security-audit) |
| Quickstart | [docs.vigolium.com/getting-started/quickstart](https://docs.vigolium.com/getting-started/quickstart) |
| Cheat Sheet | [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet) |
| Server & Ingestion | [docs.vigolium.com/getting-started/server-and-ingestion](https://docs.vigolium.com/getting-started/server-and-ingestion) |
| Writing Extensions | [docs.vigolium.com/customization/writing-extensions](https://docs.vigolium.com/customization/writing-extensions) |

## Motor de JavaScript

Ejecuta código JavaScript/TypeScript directamente o escribe módulos y hooks de escaneo personalizados sin 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

El motor JS expone APIs HTTP conscientes de la sesión para pruebas autenticadas:```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" } } ]);

Consulta [writing extensions](https://docs.vigolium.com/customization/writing-extensions) para obtener la guía de creación de extensiones y `pkg/jsext/vigolium.d.ts` para las definiciones completas de la API de TypeScript.

## Referencia de la CLI

<details>
<summary>Expandir la referencia completa de comandos y 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

Banderas```

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>

## Estructura del repositorio

El directorio `platform/` contiene herramientas externas, el panel de control de la interfaz de usuario y no forma parte del escáner principal. No se deben realizar cambios en él.

## Benchmarks

Vigolium se somete continuamente a benchmarks contra aplicaciones intencionalmente vulnerables y también se prueba exhaustivamente contra objetivos del mundo real a través de programas de bug bounty y divulgación responsable.

- **Autoalojado (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) (aplicación Next.js personalizada)
- **Externo (alojado):** [Acunetix TestPHP](http://testphp.vulnweb.com), [Gin & Juice Shop](https://ginandjuice.shop), [Testfire](http://demo.testfire.net)
- **XSS y multuvulnerabilidad:** [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, inyección de comandos)

Ejecute los benchmarks con `make test-canary` (aplicaciones Docker) o `make test-integration` (XSS).

## Desarrollo```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

Consulta HACKING.md para obtener la guía completa de compilación, el mapa del código base y la guía de desarrollo de módulos.

Seguridad

Vigolium es una herramienta de seguridad ofensiva, y dos de sus partes son intencionalmente permisivas: el modo agente se ejecuta sin sandbox (el LLM tiene acceso completo a shell, archivos y red en el host) y las extensiones pueden ejecutar comandos arbitrarios. Ejecuta el modo agente en un contenedor/VM desechable acotado al engagement, y trata las extensiones no confiables como código no confiable. Consulta SECURITY.md antes de empezar, y reporta vulnerabilidades en Vigolium de forma privada a [email protected].

Licencia

Vigolium se publica bajo la GNU Affero General Public License v3.0. Las obras derivadas deben permanecer abiertas bajo los mismos términos.

Creado con ♥ por @j3ssie, con @theblackturtle como contribuidor inicial principal.

vigolium v0.4.4

Categorías