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 descubrimiento de contenido, rastreo de navegador/SPA y auditoría activa/pasiva, cubriendo clases de vulnerabilidades como inyección, control de acceso, archivos/rutas, API/protocolo, específicas de frameworks, cloud/infraestructura y fuera de banda (OAST).

• Agentic Scan (vigolium agent): Audita a fondo tu código base. Escaneo impulsado por IA que planifica ataques de forma autónoma, selecciona módulos, genera extensiones personalizadas y clasifica los resultados, combinando auditoría profunda del código fuente con 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

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

Panel de UI	Panel de tráfico

Informes estáticos	Informes estáticos

Escaneo nativo	Escaneo agéntico

Características principales

Escaneo nativo

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

Escaneo agéntico

• Runtime de olium en proceso: cada modo de agente se ejecuta en el motor nativo pkg/olium de Go: bucle por turnos, registro de herramientas integrado, soporte de habilidades y controladores de proveedor conectables (sin pools de SDK en subprocesos)
• Autopiloto: el agente descubre endpoints de forma autónoma, ejecuta escaneos y clasifica los hallazgos, con pipeline multi-especialista opcional y reanudación de sesión
• Enjambre: el agente maestro selecciona módulos, genera extensiones de ataque JS personalizadas, ejecuta auditoría de código + SAST, ejecuta escaneos y clasifica los resultados; de alcance específico o completo (--discover), con --diff/--last-commits para ejecuciones centradas en cambios
• Controladores 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 de base de datos
• Modo consulta: prompts de una sola pasada 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

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

[No content provided in the INPUT section. Please provide the Markdown text to translate.]```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, [ingestión](https://docs.vigolium.com/server-mode/ingestion) para los flujos de trabajo de ingestión y la [descripción general de la API](https://docs.vigolium.com/api-overview) para la referencia completa de la API REST.

> **Integración con Burp Suite**: reenvía el tráfico en vivo de Burp Suite a un servidor Vigolium en ejecución con la extensión [burp-vigolium](https://github.com/vigolium/burp-vigolium).

## Escaneo autenticado

Vigolium admite escaneo autenticado de múltiples sesiones 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"

Archivos de autenticación admiten cabeceras estáticas, tokens Bearer y flujos de inicio de sesión automatizados con extracción de tokens desde cookies, respuestas JSON o cabeceras. Hay ejemplos predefinidos disponibles en public/presets/sessions/. Consulta la guía de autenticación para la guía completa.

Las banderas --auth / --auth-file se denominaban anteriormente --session / --session-file. Los nombres antiguos siguen funcionando como alias en desuso.

Escaneo agéntico

Escaneo impulsado por IA donde los agentes planifican, ejecutan y priorizan de forma autónoma las evaluaciones de vulnerabilidades, 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 con agentes:
- **Autopilot**: escaneo autónomo. La CLI llama a `pkg/olium/autopilot.Run` directamente; 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 solicitudes únicas dirigidas y alcance completo (`--discover`). El agente maestro analiza las entradas, selecciona módulos, genera extensiones JS personalizadas, ejecuta la auditoría de código y SAST, realiza los escaneos y clasifica los resultados
- **Audit**: auditoría de código fuente a través de `vigolium agent audit` — un despachador unificado que ejecuta los harness integrados **vigolium-audit** (claude/codex) y/o **piolium** (nativo de Pi), seleccionados con `--driver {auto|both|audit|piolium}` (por defecto `auto`: ejecuta la auditoría y recurre a piolium solo si la auditoría falla). Son harness separados; **no** los enrutes a través de olium. Filas hijas por driver bajo un único AgenticScan padre, con deduplicación de hallazgos posteriores al pase. No existe un subcomando `agent piolium` independiente — piolium se ejecuta mediante `--driver=piolium`

> **CLIs de auditoría independientes**: la auditoría de seguridad con agentes también se incluye como CLIs independientes que puedes ejecutar sin depender de Vigolium: [vigolium-audit](https://github.com/vigolium/vigolium-audit) (el harness detrás de `vigolium agent audit`) y [piolium](https://github.com/vigolium/piolium) (el driver 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 obtener la guía completa.

## ⚡ Consola en la nube de Vigolium

Una solución basada en la nube para equipos que quieren la potencia de Vigolium sin gestionar infraestructura. La consola en la nube es la versión **mejorada y con todas las funciones de Vigolium**: escaneo gestionado, informes centralizados, colaboración en equipo y funciones adicionales superpuestas al núcleo de código abierto, para que puedas centrarte en corregir vulnerabilidades en lugar de mantener herramientas.

> Echa un vistazo a la consola en la nube en [console.vigolium.com](https://console.vigolium.com/).

## Capas de escaneo nativas

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

| Capa | Descripción | Documentación |
|-------|-------------|------|
| **Descubrimiento de contenido (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) |
| **Araña del navegador (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) |
| **Auditoría** | 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) |
| **Módulos de escaneo** | 207 módulos activos y 116 pasivos que cubren OWASP Top 10 y más | [docs.vigolium.com/native-scan/modules-reference](https://docs.vigolium.com/native-scan/modules-reference) |

## Documentación

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

| Tema | Enlace |
|-------|------|
| Configurar agentes | [docs.vigolium.com/getting-started/setup-agent](https://docs.vigolium.com/getting-started/setup-agent) |
| Iniciar un escaneo nativo | [docs.vigolium.com/getting-started/native-scan](https://docs.vigolium.com/getting-started/native-scan) |
| Iniciar un escaneo con agentes | [docs.vigolium.com/getting-started/agentic-scan](https://docs.vigolium.com/getting-started/agentic-scan) |
| Iniciar una auditoría con agentes | [docs.vigolium.com/getting-started/agentic-security-audit](https://docs.vigolium.com/getting-started/agentic-security-audit) |
| Inicio rápido | [docs.vigolium.com/getting-started/quickstart](https://docs.vigolium.com/getting-started/quickstart) |
| Hoja de referencia | [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet) |
| Servidor e ingesta | [docs.vigolium.com/getting-started/server-and-ingestion](https://docs.vigolium.com/getting-started/server-and-ingestion) |
| Escribir extensiones | [docs.vigolium.com/customization/writing-extensions](https://docs.vigolium.com/customization/writing-extensions) |

## Motor JavaScript

Ejecuta código JavaScript/TypeScript directamente o escribe módulos de escaneo y hooks 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 API 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 la guía para [escribir extensiones](https://docs.vigolium.com/customization/writing-extensions) 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 banderas</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 / HEADN for change-focused scans --last-commits Shorthand for --diff HEADN --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, un panel de UI y no forma parte del núcleo del escáner. No se deben realizar cambios en él.

## Benchmarks

Vigolium se evalúa continuamente contra aplicaciones intencionalmente vulnerables y también se prueba intensamente contra objetivos del mundo real mediante programas de bug bounty y divulgación responsable.

- **Autoalojados (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)
- **Externos (alojados):** [Acunetix TestPHP](http://testphp.vulnweb.com), [Gin & Juice Shop](https://ginandjuice.shop), [Testfire](http://demo.testfire.net)
- **XSS y multi-vulnerabilidades:** [BruteLogic XSS](https://github.com/vigolium/vigolium/blob/HEAD/test/benchmark/xss_scanner/), [XBOW](https://github.com/vigolium/vigolium/blob/HEAD/test/benchmark/definitions/xbow/) (XSS, SQLi, SSTI, LFI, SSRF, XXE, inyección de comandos)

Ejecuta 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 la guía de compilación completa, 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 intencionadamente 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 limitado al compromiso, y trata las extensiones no confiables como código no confiable. Consulta SECURITY.md antes de empezar, y reporta vulnerabilidades en el propio 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.

Elaborado con ♥ por @j3ssie, con @theblackturtle como colaborador inicial principal.