Vigolium - Scanner de vulnérabilités haute fidélité alliant IA agentique, rapidité native, modularité et précision

Vigolium propose deux modes de scan complémentaires :

• Native Scan (vigolium scan) : Rapide, puissant et flexible. Scan déterministe multi-phases avec 317 modules couvrant la découverte de contenu, le spidering navigateur/SPA, et l'audit actif/passif, couvrant les classes de vulnérabilités d'injection, de contrôle d'accès, de fichier/chemin, d'API/protocole, spécifiques aux frameworks, cloud/infra, et hors bande (OAST).

• Agentic Scan (vigolium agent) : Audite en profondeur votre base de code. Scan piloté par IA qui planifie autonomement les attaques, sélectionne les modules, génère des extensions personnalisées et trie les résultats, combinant un audit approfondi du code source avec un scan de vulnérabilités autonome et ciblé.

Installation

Installation rapide (recommandée)```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'installation npm ci-dessus fonctionne sous Windows. Vous pouvez également télécharger vigolium_<version>_windows_amd64.zip depuis la page des releases, l'extraire, et placer vigolium.exe quelque part dans votre PATH.

Windows n'est disponible qu'en x64 ; sur Windows ARM, il s'exécute sous émulation. L'installateur shell ci-dessus est réservé à POSIX, donc vigolium update n'est pas disponible sous Windows — relancez l'installation npm ou téléchargez le zip plus récent pour mettre à niveau.

### Compiler depuis les sources```bash
git clone https://github.com/vigolium/vigolium.git
cd vigolium
make build         # build and install to $GOPATH/bin

Tableau de bord UI	Tableau de bord du trafic

Rapports statiques	Rapports statiques

Scan natif	Scan agentique

Sponsor

_{Merci à Daytona pour le parrainage de l'infrastructure de sandbox}

Fonctionnalités clés

Scan natif

• 324 modules de scan : 207 actifs (fuzzing) + 117 passifs (correspondance de motifs), couvrant l'OWASP Top 10 et au-delà
• Tests hors bande (OAST) : XSS/SSRF/injection de commandes en aveugle via des callbacks interactsh avec corrélation automatique des payloads
• Mutation sensible à la valeur : classe les paramètres par type sémantique (entier, UUID, JWT, email) et mute selon l'intention
• Pipeline multi-phases : collecte externe, découverte de contenu (Deparos), exploration navigateur/SPA (Spitolas) et audit, contrôlés par des préréglages de stratégie et des profils de scan
• Entrées flexibles : URLs, OpenAPI/Swagger, Postman, Burp Suite, cURL, Nuclei JSONL
• Authentification multi-sessions : sessions en ligne, fichiers de session ou configurations d'authentification complètes avec flux de connexion, extraction de jetons et tests IDOR/BOLA
• Extensions JavaScript : modules et hooks personnalisés via un moteur JS embarqué avec des API HTTP sensibles à la session
• Évolutif et rapportable : pool de workers concurrents avec limitation de débit par hôte, file d'attente hybride en mémoire/disque/Redis et rapports HTML autonomes

Scan agentique

• Runtime olium in-process : chaque mode d'agent s'exécute sur le moteur Go natif pkg/olium : boucle par tours, registre d'outils intégré, prise en charge des compétences et pilotes de fournisseurs enfichables (pas de pools de SDK en sous-processus)
• Autopilot : l'agent découvre de manière autonome les endpoints, exécute des scans et trie les résultats, avec un pipeline multi-spécialistes optionnel et la reprise de session
• Swarm : l'agent maître sélectionne les modules, génère des extensions d'attaque JS personnalisées, exécute l'audit de code + SAST, lance les scans et trie les résultats ; ciblé ou à portée complète (--discover), avec --diff/--last-commits pour des exécutions axées sur les changements
• Pilotes d'audit de source : audit, piolium et le répartiteur unifié audit exécutent des audits de code source au premier plan partageant un même schéma de résultats et un étiquetage DB
• Mode requête : invites à tir unique pour la revue de code, la découverte d'endpoints et la détection de secrets
• Fournisseurs enfichables : openai-compatible (par défaut), openai-codex-oauth, openai-api-key, openai-responses, anthropic-api-key, anthropic-oauth, anthropic-cli, anthropic-compatible, anthropic-vertex, google-vertex. Les mêmes modes sont exposés via l'API REST avec streaming SSE et un endpoint de chat compatible OpenAI

Démarrage rapide : Scan natif```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

Consultez la [présentation de l'architecture](https://docs.vigolium.com/architecture/overview) pour le pipeline complet et le [guide des stratégies](https://docs.vigolium.com/native-scan/strategies) pour les stratégies, les profils et la configuration du rythme. Pour une référence rapide des commandes, consultez [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet).

## Mode serveur```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

| --proxy | string | Proxy URL (e.g., http://127.0.0.1:8080) | | --timeout | int | Request timeout in seconds (default: 10) | | --user-agent | string | Custom User-Agent header | | --headers | string | Additional headers (format: Key:Value,Key2:Value2) | | --follow-redirects | bool | Follow HTTP redirects (default: true) | | --insecure | bool | Skip TLS certificate verification | | --rate-limit | int | Max requests per second (default: 0 = unlimited) | | --concurrency | int | Number of concurrent workers (default: 10) | | --output | string | Output file path | | --format | string | Output format: json, csv, text (default: text) | | --verbose | bool | Enable verbose logging | | --silent | bool | Suppress all output except results |

Examples

Basic scan against a single target:

./tool -u https://example.com

Scan multiple targets from a file with increased concurrency:

./tool -l targets.txt -c 50 --timeout 30

Export results to JSON with verbose logging:

./tool -u https://example.com -o results.json -f json -v

Using a proxy with custom headers:

./tool -u https://example.com --proxy http://127.0.0.1:8080 --headers "Authorization:Bearer token,X-Custom:value"

Configuration File

The tool supports a YAML configuration file for persistent settings. By default, it looks for config.yaml in the current directory, or you can specify a custom path with --config.

# config.yaml
timeout: 15
concurrency: 20
follow_redirects: true
insecure: false
rate_limit: 5
user_agent: "CustomAgent/1.0"
headers:
  Authorization: "Bearer YOUR_TOKEN"
  X-Custom-Header: "value"
output:
  format: json
  path: ./output/results.json

Output Formats

Text (default)

Human-readable output, one result per line:

[+] https://example.com - 200 OK (1.23s)
[+] https://example.com/admin - 403 Forbidden (0.45s)
[-] https://example.com/missing - 404 Not Found (0.32s)

JSON

Structured output suitable for further processing:

{
  "target": "https://example.com",
  "results": [
    {
      "url": "https://example.com",
      "status": 200,
      "status_text": "OK",
      "response_time": 1.23,
      "content_length": 1256,
      "headers": {
        "server": "nginx/1.18.0",
        "content-type": "text/html; charset=UTF-8"
      }
    }
  ]
}

CSV

Tabular output for spreadsheet analysis:

url,status,status_text,response_time,content_length
https://example.com,200,OK,1.23,1256
https://example.com/admin,403,Forbidden,0.45,512
``````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

Voir exécution du serveur pour la configuration du serveur, ingestion pour les workflows d'ingestion, et l'aperçu de l'API pour la référence complète de l'API REST.

Intégrations proxy : transférez le trafic proxy en direct vers un serveur Vigolium en cours d'exécution avec l'extension burp-vigolium pour Burp Suite ou le plugin caido-vigolium pour Caido. Les deux utilisent le même protocole de pont (-B/--burp-bridge-url, alias --caido-bridge-url), et le trafic ingéré est étiqueté avec le proxy dont il provient.

Analyse authentifiée

Vigolium prend en charge l'analyse authentifiée multi-session pour les tests IDOR/BOLA et les vérifications d'escalade de privilèges :```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"

Les fichiers d'authentification prennent en charge les en-têtes statiques, les jetons bearer et les flux de connexion automatisés avec extraction de jetons à partir de cookies, de réponses JSON ou d'en-têtes. Des exemples prédéfinis sont disponibles dans `public/presets/sessions/`. Consultez le [guide d'authentification](https://docs.vigolium.com/native-scan/authentication) pour le guide complet.

> Les options `--auth` / `--auth-file` étaient auparavant nommées `--session` / `--session-file`. Les anciens noms fonctionnent toujours comme alias obsolètes.

## Analyse agentique

Analyse pilotée par IA où les agents planifient, exécutent et trient de manière autonome les évaluations de vulnérabilités avec le moteur d'analyse natif en dessous :```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)

Modes de scan agentiques :

• Autopilot : scan autonome. Le CLI appelle directement pkg/olium/autopilot.Run ; le serveur ajoute la préparation vigolium-audit, la configuration de l'authentification et un bundle de contexte figé autour de la même boucle
• Swarm : scan de vulnérabilités guidé par IA prenant en charge la requête unique ciblée et la portée complète (--discover). L'agent maître analyse les entrées, sélectionne les modules, génère des extensions JS personnalisées, exécute l'audit de code et le SAST, lance les scans et trie les résultats
• Audit : audit de code source via vigolium agent audit — un répartiteur unifié qui exécute les harnais embarqués vigolium-audit (claude/codex) et/ou piolium (natif Pi), sélectionnés avec --driver {auto|both|audit|piolium} (par défaut auto : pré-vérification du volet audit et exécution lorsque le CLI claude/codex résolu est dans le PATH, que le binaire est embarqué et que la chaîne dispose d'un mode compatible avec l'audit ; sinon, repli sur piolium sans lancer l'audit. Une défaillance d'audit en cours d'exécution est signalée plutôt que de changer de pilote). Harnais séparés ; ne pas passer par olium. Lignes enfants par pilote sous un parent AgenticScan unique avec déduplication des résultats après passe. Il n'existe pas de sous-commande autonome agent piolium — piolium s'exécute via --driver=piolium

CLI d'audit autonomes : l'audit de sécurité agentique est également fourni sous forme de CLI autonomes que vous pouvez exécuter indépendamment de Vigolium : vigolium-audit (le harnais derrière vigolium agent audit) et piolium (le pilote natif Pi derrière vigolium agent audit --driver=piolium).

Consultez le guide du mode agent pour le guide complet.

⚡ Console Cloud Vigolium

Une solution cloud pour les équipes qui veulent la puissance de Vigolium sans gérer l'infrastructure. Console est la version améliorée et complète de Vigolium, pilotée par un agent autonome avancé qui mène tout l'engagement — raisonnant sur la cible, choisissant ses propres chemins d'attaque et confirmant ce qu'il trouve — avec le scan hébergé et les résultats partagés ajoutés par-dessus le cœur open-source, afin que vous puissiez vous concentrer sur la correction des vulnérabilités plutôt que sur la maintenance des outils.

Intéressé ? Contactez-nous pour une démo.

Couches de scan natives

Le pipeline de scan natif est composé de couches modulaires, chacune documentée séparément :

Documentation

La documentation complète se trouve sur docs.vigolium.com. Les notes de version et l'historique des versions sont dans le CHANGELOG. Liens rapides :

Moteur JavaScript

Exécutez du code JavaScript/TypeScript directement ou écrivez des modules et hooks de scan personnalisés sans recompiler :```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

Le moteur JS expose des API HTTP sensibles à la session pour les tests authentifiés :```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" } }
]);

Voir écriture d'extensions pour le guide de création d'extensions et pkg/jsext/vigolium.d.ts pour les définitions complètes de l'API TypeScript.

Référence CLI

### Options```
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: 25)
  -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

Organisation du dépôt

Le répertoire platform/ contient l'outillage externe, le tableau de bord UI et ne fait pas partie du scanner principal. Aucune modification ne doit y être apportée.

Benchmarks

Vigolium est continuellement évalué par rapport à des applications intentionnellement vulnérables et également testé de manière intensive sur des cibles réelles via des programmes de bug bounty et de divulgation responsable.

• Auto-hébergé (Docker) : DVWA, OWASP Juice Shop, VAmPI, crAPI, Vulnerable Java App, Vulnerable Nginx, OopsSec Store (application Next.js personnalisée)
• Externe (hébergé) : Acunetix TestPHP, Gin & Juice Shop, Testfire
• XSS et multi-vulnérabilités : BruteLogic XSS, XBOW (XSS, SQLi, SSTI, LFI, SSRF, XXE, injection de commandes)

Exécutez les benchmarks avec make test-canary (applications Docker) ou make test-integration (XSS).

Développement```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

Consultez [HACKING.md](https://github.com/vigolium/vigolium/blob/main/HACKING.md) pour le guide de compilation complet, la carte du code source et le guide de développement de modules.

## Sécurité

Vigolium est un outil de sécurité offensive, et deux de ses parties sont intentionnellement permissives : **le mode agent s'exécute sans sandbox** (le LLM dispose d'un accès complet au shell, aux fichiers et au réseau sur l'hôte) et **les extensions peuvent exécuter des commandes arbitraires**. Exécutez le mode agent dans un conteneur/VM jetable limité au périmètre de l'engagement, et traitez les extensions non fiables comme du code non fiable. Consultez [SECURITY.md](https://github.com/vigolium/vigolium/blob/main/SECURITY.md) avant de commencer, et signalez les vulnérabilités de Vigolium lui-même en privé à [[email protected]](mailto:[email protected]).

## Licence

Vigolium est publié sous la [MIT License](https://github.com/vigolium/vigolium/blob/main/LICENSE).

Créé avec ♥ par [@j3ssie](https://x.com/j3ssie), avec [@theblackturtle](https://github.com/theblackturtle) comme contributeur initial principal.