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

Voir la [vue d'ensemble 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, voir [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

## 📦 Installation

### Option 1: Install via pip

```bash
pip install kitploit

git clone https://github.com/kitploit/kitploit.git
cd kitploit
pip install -r requirements.txt
python setup.py install

docker pull kitploit/kitploit
docker run -it --rm kitploit/kitploit

kitploit --help

kitploit search nmap

kitploit info metasploit

kitploit search "web scanner"
kitploit search "password cracking"
kitploit search "network analysis"

kitploit info burpsuite
kitploit info sqlmap
kitploit info wireshark

kitploit list

kitploit update

# Kitploit configuration file
database:
  path: ~/.kitploit/database.db
  auto_update: true

search:
  default_limit: 20
  case_sensitive: false

cache:
  enabled: true
  ttl: 3600

logging:
  level: INFO
  file: ~/.kitploit/kitploit.log

kitploit search "exploit" --category web --language python
kitploit search "scanner" --min-stars 100 --sort stars

kitploit search "vulnerability scanner" --format json
kitploit search "network tool" --format csv

kitploit batch install --file tools.txt
kitploit batch update --all

git clone https://github.com/kitploit/kitploit.git
cd kitploit
pip install -e ".[dev]"
pytest tests/

# 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](https://docs.vigolium.com/server-mode/running-the-server) pour la configuration du serveur, [ingestion](https://docs.vigolium.com/server-mode/ingestion) pour les flux de travail d'ingestion, et la [vue d'ensemble de l'API](https://docs.vigolium.com/api-overview) pour la référence complète de l'API REST.

> **Intégrations de proxy** : transmettez le trafic proxy en direct à un serveur Vigolium en cours d'exécution avec l'extension [burp-vigolium](https://github.com/vigolium/burp-vigolium) pour Burp Suite ou le plugin [caido-vigolium](https://github.com/vigolium/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-sessions pour les tests IDOR/BOLA et les vérifications d'élévation 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.

## Scan Agentique

Analyse pilotée par l'IA où des agents planifient, exécutent et trient de manière autonome les évaluations de vulnérabilités avec le moteur de scan natif en arrière-plan :```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 agentique :
- **Autopilot** : scan autonome. La CLI appelle directement `pkg/olium/autopilot.Run` ; le serveur ajoute la préparation de l'audit vigolium-audit, la configuration d'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 les requêtes uniques ciblées et le périmètre complet (`--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 la 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 intégrés **vigolium-audit** (claude/codex) et/ou **piolium** (natif Pi), sélectionnés avec `--driver {auto|both|audit|piolium}` (par défaut `auto` : pré-vol de la branche d'audit et exécution lorsque la CLI `claude`/`codex` résolue est dans le PATH, le binaire est intégré et la chaîne dispose d'un mode compatible audit ; sinon repli sur piolium sans lancer l'audit. Un échec d'audit en cours d'exécution est signalé plutôt que de changer de pilote). Harnais séparés ; **ne pas** router via olium. Lignes enfants par pilote sous un seul AgenticScan parent avec déduplication des résultats de post-traitement. 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](https://github.com/vigolium/vigolium-audit) (le harnais derrière `vigolium agent audit`) et [piolium](https://github.com/vigolium/piolium) (le pilote natif Pi derrière `vigolium agent audit --driver=piolium`).

Consultez le [guide du mode agent](https://docs.vigolium.com/agentic-scan/agent-mode) pour le guide complet.

## ⚡ Vigolium Cloud Console

Une solution cloud pour les équipes qui souhaitent 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 toute l'opération — raisonnant sur la cible, choisissant ses propres chemins d'attaque et confirmant ce qu'il trouve — avec un scan hébergé et des résultats partagés superposés au 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](https://www.vigolium.com/request-demo).

## Couches de scan natives

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

| Couche | Description | Docs |
|-------|-------------|------|
| **Découverte de contenu (Deparos)** | Énumération adaptative de répertoires/fichiers avec détection de soft-404 basée sur les empreintes | [docs.vigolium.com/native-scan/phases/discovery](https://docs.vigolium.com/native-scan/phases/discovery) |
| **Spider navigateur (Spitolas)** | Crawler à machine à états piloté par Chromium avec capture du trafic CDP | [docs.vigolium.com/native-scan/phases/spidering](https://docs.vigolium.com/native-scan/phases/spidering) |
| **Audit** | Scan de vulnérabilités actif/passif avec extraction de points d'insertion et framework DiffScan | [docs.vigolium.com/native-scan/phases/audit](https://docs.vigolium.com/native-scan/phases/audit) |
| **Modules de scan** | 207 modules actifs et 116 modules passifs couvrant l'OWASP Top 10 et au-delà | [docs.vigolium.com/native-scan/modules-reference](https://docs.vigolium.com/native-scan/modules-reference) |

## Documentation

La documentation complète se trouve sur [docs.vigolium.com](https://docs.vigolium.com/). Les notes de version et l'historique des versions sont dans le [CHANGELOG](https://github.com/vigolium/vigolium/blob/main/CHANGELOG.md). Liens rapides :

| Sujet | Lien |
|-------|------|
| Configurer les agents | [docs.vigolium.com/getting-started/setup-agent](https://docs.vigolium.com/getting-started/setup-agent) |
| Démarrer un scan natif | [docs.vigolium.com/getting-started/native-scan](https://docs.vigolium.com/getting-started/native-scan) |
| Démarrer un scan agentique | [docs.vigolium.com/getting-started/agentic-scan](https://docs.vigolium.com/getting-started/agentic-scan) |
| Démarrer un audit agentique | [docs.vigolium.com/getting-started/agentic-security-audit](https://docs.vigolium.com/getting-started/agentic-security-audit) |
| Démarrage rapide | [docs.vigolium.com/getting-started/quickstart](https://docs.vigolium.com/getting-started/quickstart) |
| Aide-mémoire | [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet) |
| Serveur et ingestion | [docs.vigolium.com/getting-started/server-and-ingestion](https://docs.vigolium.com/getting-started/server-and-ingestion) |
| Écrire des extensions | [docs.vigolium.com/customization/writing-extensions](https://docs.vigolium.com/customization/writing-extensions) |

## Moteur JavaScript

Exécutez du code JavaScript/TypeScript directement ou écrivez des modules de scan et des hooks 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
```
The JS engine exposes session-aware HTTP APIs for authenticated testing:```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 [écrire des extensions](https://docs.vigolium.com/customization/writing-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

<details>
<summary>Développer la référence complète des commandes et des options</summary>

### Commandes```
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
```
### Indicateurs```
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
```
</details>

## Structure du dépôt

Le répertoire `platform/` contient des outils externes, 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 volontairement vulnérables et également testé de manière approfondie contre des cibles réelles via des programmes de bug bounty et de divulgation responsable.

- **Auto-hébergé (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) (application Next.js personnalisée)
- **Externe (hébergé) :** [Acunetix TestPHP](http://testphp.vulnweb.com), [Gin & Juice Shop](https://ginandjuice.shop), [Testfire](http://demo.testfire.net)
- **XSS et multi-vulnérabilités :** [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, 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
```
Voir [HACKING.md](https://github.com/vigolium/vigolium/blob/main/HACKING.md) pour le guide de build complet, la carte du codebase et le guide de développement des modules.

## Sécurité

Vigolium est un outil de sécurité offensif, et deux de ses parties sont volontairement 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é à 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 [GNU Affero General Public License v3.0](https://github.com/vigolium/vigolium/blob/main/LICENSE). Les œuvres dérivées doivent rester ouvertes sous les mêmes conditions.

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