Vigolium - Scanner di vulnerabilità ad alta fedeltà che unisce AI agentica con velocità nativa, modularità e precisione

Vigolium offre due modalità di scansione complementari:

• Native Scan (vigolium scan): Veloce, potente e flessibile. Scansione deterministica multi-fase con 317 moduli che coprono content discovery, browser/SPA spidering e audit attivo/passivo, includendo classi di vulnerabilità di injection, controllo degli accessi, file/path, API/protocol, specifiche per framework, cloud/infra e out-of-band (OAST).

• Agentic Scan (vigolium agent): Verifica approfonditamente la tua codebase. Scansione guidata dall'AI che pianifica autonomamente gli attacchi, seleziona i moduli, genera estensioni personalizzate e classifica i risultati, combinando audit approfondito del codice sorgente con scansione autonoma e mirata delle vulnerabilità.

Installazione

Installazione Rapida (Consigliata)```bash

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

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

Windows

L'installazione npm sopra funziona su Windows. In alternativa, scarica vigolium_<version>_windows_amd64.zip dalla pagina delle release, estrailo e metti vigolium.exe da qualche parte nel tuo PATH.

Windows è disponibile solo come x64; su Windows ARM viene eseguito tramite emulazione. Lo shell installer sopra è solo POSIX, quindi vigolium update non è disponibile su Windows — riesegui l'installazione npm o scarica lo zip più recente per aggiornare.

### Compilazione dal sorgente```bash
git clone https://github.com/vigolium/vigolium.git
cd vigolium
make build         # build and install to $GOPATH/bin

UI Dashboard	Traffic Dashboard

Static Reports	Static Reports

Native scan	Agentic Scan

Sponsor

_{Grazie a Daytona per aver sponsorizzato l'infrastruttura sandbox}

Funzionalità principali

Native Scan

• 323 moduli scanner: 207 attivi (fuzzing) + 116 passivi (pattern matching), che coprono OWASP Top 10 e oltre
• Out-of-band testing (OAST): blind XSS/SSRF/command injection tramite callback interactsh con correlazione automatica dei payload
• Value-aware mutation: classifica i parametri per tipo semantico (integer, UUID, JWT, email) e li muta in base all'intento
• Pipeline multi-fase: external harvesting, content discovery (Deparos), browser/SPA spidering (Spitolas) e audit, controllati da preset di strategia e profili di scansione
• Input flessibili: URL, OpenAPI/Swagger, Postman, Burp Suite, cURL, Nuclei JSONL
• Autenticazione multi-sessione: sessioni inline, file di sessione o configurazioni di autenticazione complete con flussi di login, estrazione dei token e test IDOR/BOLA
• Estensioni JavaScript: moduli e hook personalizzati tramite motore JS integrato con API HTTP session-aware
• Scalabile e reportizzabile: pool di worker concorrenti con rate limiting per host, coda ibrida in-memory/disk/Redis e report HTML autonomi

Agentic Scan

• Runtime olium in-process: ogni modalità agente gira sul motore nativo Go pkg/olium: loop a turni, registro di tool integrati, supporto alle skill e driver provider pluggable (nessun pool di SDK in subprocess)
• Autopilot: l'agente scopre autonomamente gli endpoint, esegue scansioni e classifica i finding, con pipeline multi-specialista opzionale e ripresa della sessione
• Swarm: l'agente master seleziona i moduli, genera estensioni di attacco JS personalizzate, esegue code audit + SAST, esegue scansioni e classifica i risultati; mirato o a scope completo (--discover), con --diff/--last-commits per esecuzioni focalizzate sulle modifiche
• Driver di source-audit: audit, piolium e il dispatcher unificato audit eseguono audit del codice sorgente in foreground condividendo un unico schema di finding e tagging del DB
• Modalità query: prompt single-shot per code review, endpoint discovery e secret detection
• Provider pluggable: openai-compatible (predefinito), openai-codex-oauth, openai-api-key, openai-responses, anthropic-api-key, anthropic-oauth, anthropic-cli, anthropic-compatible, anthropic-vertex, google-vertex. Le stesse modalità sono esposte tramite REST API con streaming SSE e un endpoint chat compatibile con OpenAI

Quick Start: Native Scan```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 [panoramica dell'architettura](https://docs.vigolium.com/architecture/overview) per la pipeline completa e la [guida alle strategie](https://docs.vigolium.com/native-scan/strategies) per strategie, profili e configurazione del ritmo. Per un riferimento rapido dei comandi, consulta [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet).

## Modalità Server```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

Installazione

Installazione automatica (consigliata)

# Clona il repository
git clone https://github.com/yourusername/kitploit-tool.git
cd kitploit-tool

# Esegui lo script di installazione
chmod +x install.sh
./install.sh

Lo script di installazione:

• Verifica i prerequisiti di sistema
• Installa le dipendenze Python richieste
• Configura le variabili d'ambiente
• Imposta i permessi appropriati
• Crea la configurazione predefinita

Installazione manuale

# Installa le dipendenze
pip install -r requirements.txt

# Rendi eseguibile lo script principale
chmod +x tool.py

# Copia la configurazione di esempio
cp config.example.yaml config.yaml

# Modifica la configurazione secondo le tue esigenze
nano config.yaml

Installazione tramite Docker

# Compila l'immagine Docker
docker build -t kitploit-tool .

# Esegui il container
docker run -it --rm \
  -v $(pwd)/config.yaml:/app/config.yaml \
  -v $(pwd)/output:/app/output \
  kitploit-tool

Requisiti di sistema

Risoluzione dei problemi

Errore: ModuleNotFoundError: No module named 'xyz'

Assicurati che tutte le dipendenze siano installate:

pip install -r requirements.txt --upgrade

Errore: Permission denied durante l'esecuzione dello script

Imposta i permessi di esecuzione corretti:

chmod +x tool.py install.sh

Errore: conflitto di porte durante l'esecuzione di Docker

Modifica il mapping delle porte nel comando docker run:

docker run -it --rm -p 8080:8080 kitploit-tool
``````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 running the server per la configurazione del server, ingestion per i flussi di lavoro di ingestion, e la API overview per il riferimento completo dell'API REST.

Integrazioni proxy: inoltra il traffico proxy live a un server Vigolium in esecuzione con l'estensione burp-vigolium per Burp Suite o il plugin caido-vigolium per Caido. Entrambi utilizzano lo stesso protocollo bridge (-B/--burp-bridge-url, alias --caido-bridge-url), e il traffico acquisito viene etichettato con il proxy da cui proviene.

Scansione Autenticata

Vigolium supporta la scansione autenticata multi-sessione per i test IDOR/BOLA e i controlli di escalation dei privilegi:```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"

I file di autenticazione supportano header statici, bearer token e flussi di login automatizzati con estrazione del token da cookie, risposte JSON o header. Esempi predefiniti sono disponibili in `public/presets/sessions/`. Consulta la [guida all'autenticazione](https://docs.vigolium.com/native-scan/authentication) per la guida completa.

> I flag `--auth` / `--auth-file` erano precedentemente denominati `--session` / `--session-file`. I vecchi nomi funzionano ancora come alias deprecati.

## Scansione Agentica

Scansione guidata dall'IA in cui gli agenti pianificano, eseguono e classificano autonomamente le valutazioni delle vulnerabilità con il motore di scansione nativo sottostante:```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)

Modalità di scansione agentica:

• Autopilot: scansione autonoma. La CLI chiama direttamente pkg/olium/autopilot.Run; il server aggiunge la preparazione di vigolium-audit, la configurazione dell'autenticazione e un bundle di contesto congelato attorno allo stesso loop
• Swarm: scansione delle vulnerabilità guidata dall'IA che supporta richieste singole mirate e ambito completo (--discover). L'agente master analizza gli input, seleziona i moduli, genera estensioni JS personalizzate, esegue l'audit del codice e SAST, esegue le scansioni e classifica i risultati
• Audit: audit del codice sorgente tramite vigolium agent audit — un dispatcher unificato che esegue gli harness integrati vigolium-audit (claude/codex) e/o piolium (Pi-native), selezionati con --driver {auto|both|audit|piolium} (predefinito auto: esegue il preflight del ramo audit e lo esegue quando la CLI risolta claude/codex è nel PATH, il binario è integrato e la catena ha una modalità supportata dall'audit; altrimenti ripiega su piolium senza avviare l'audit. Un errore dell'audit a metà esecuzione viene segnalato invece di cambiare driver). Harness separati; non passare attraverso olium. Righe figlie per driver sotto un unico AgenticScan padre con deduplicazione dei risultati post-pass. Non esiste un sottocomando standalone agent piolium — piolium viene eseguito tramite --driver=piolium

CLI di audit standalone: l'audit di sicurezza agentico è disponibile anche come CLI standalone eseguibili indipendentemente da Vigolium: vigolium-audit (l'harness dietro vigolium agent audit) e piolium (il driver Pi-native dietro vigolium agent audit --driver=piolium).

Consulta la guida alla modalità agente per la guida completa.

⚡ Vigolium Cloud Console

Una soluzione basata su cloud per i team che desiderano la potenza di Vigolium senza gestire l'infrastruttura. Console è la versione aggiornata e completa di Vigolium, guidata da un agente autonomo avanzato che gestisce l'intero ingaggio — ragionando sul target, scegliendo i propri percorsi di attacco e confermando ciò che trova — con scansione ospitata e risultati condivisi sovrapposti al core open-source, così puoi concentrarti sulla correzione delle vulnerabilità invece di mantenere il tooling.

Interessato? Contattaci per una demo.

Livelli di scansione nativi

La pipeline di scansione nativa è composta da livelli modulari, ciascuno documentato separatamente:

Documentazione

La documentazione completa è disponibile su docs.vigolium.com. Le note di rilascio e la cronologia delle versioni sono nel CHANGELOG. Link rapidi:

Motore JavaScript

Esegui codice JavaScript/TypeScript direttamente o scrivi moduli e hook di scansione personalizzati senza ricompilare:```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

Il motore JS espone API HTTP consapevoli della sessione per i test autenticati:```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" } }
]);

Vedi writing extensions per la guida alla scrittura delle estensioni e pkg/jsext/vigolium.d.ts per le definizioni complete dell'API TypeScript.

Riferimento CLI

### Flag```
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 <source>/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

Struttura del Repository

La directory platform/ contiene strumenti esterni, la Dashboard UI e non fa parte dello scanner principale. Non dovrebbero essere apportate modifiche ad essa.

Benchmark

Vigolium viene costantemente sottoposto a benchmark contro applicazioni intenzionalmente vulnerabili e testato approfonditamente anche contro target reali attraverso programmi di bug bounty e responsible disclosure.

• Self-hosted (Docker): DVWA, OWASP Juice Shop, VAmPI, crAPI, Vulnerable Java App, Vulnerable Nginx, OopsSec Store (app Next.js personalizzata)
• Esterni (hosted): Acunetix TestPHP, Gin & Juice Shop, Testfire
• XSS e multi-vuln: BruteLogic XSS, XBOW (XSS, SQLi, SSTI, LFI, SSRF, XXE, command injection)

Esegui i benchmark con make test-canary (app Docker) o make test-integration (XSS).

Sviluppo```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](https://github.com/vigolium/vigolium/blob/main/HACKING.md) per la guida completa alla build, la mappa del codebase e la guida allo sviluppo dei moduli.

## Sicurezza

Vigolium è uno strumento di sicurezza offensiva, e due sue parti sono intenzionalmente permissive: **la modalità agente viene eseguita senza sandbox** (l'LLM ha accesso completo a shell, file e rete sull'host) e **le estensioni possono eseguire comandi arbitrari**. Esegui la modalità agente in un container/VM usa e getta circoscritto all'engagement, e tratta le estensioni non attendibili come codice non attendibile. Consulta [SECURITY.md](https://github.com/vigolium/vigolium/blob/main/SECURITY.md) prima di iniziare, e segnala privatamente le vulnerabilità in Vigolium stesso a [[email protected]](mailto:[email protected]).

## Licenza

Vigolium è rilasciato sotto la [GNU Affero General Public License v3.0](https://github.com/vigolium/vigolium/blob/main/LICENSE). Le opere derivate devono rimanere aperte secondo gli stessi termini.

Creato con ♥ da [@j3ssie](https://x.com/j3ssie), con [@theblackturtle](https://github.com/theblackturtle) come contributore iniziale principale.