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

Siehe die [Architekturübersicht](https://docs.vigolium.com/architecture/overview) für die vollständige Pipeline und den [Strategie-Leitfaden](https://docs.vigolium.com/native-scan/strategies) für Strategien, Profile und Pace-Konfiguration. Eine schnelle Befehlsreferenz finden Sie unter [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet).

## Server-Modus```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

### Voraussetzungen

- **Python 3.8+** – Stellen Sie sicher, dass Python 3.8 oder höher installiert ist.
- **pip** – Der Python-Paketmanager (normalerweise in Python enthalten).
- **Git** – Zum Klonen des Repositorys (optional, aber empfohlen).

### Schnellstart

Klonen Sie das Repository und installieren Sie die Abhängigkeiten:

```bash
git clone https://github.com/example/tool.git
cd tool
pip install -r requirements.txt

pip install tool-name

git clone https://github.com/example/tool.git
cd tool
python setup.py install

docker build -t tool-name .
docker run -it tool-name --help

tool-name --version

# 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
```
Siehe [Ausführen des Servers](https://docs.vigolium.com/server-mode/running-the-server) für die Server-Einrichtung, [Ingestion](https://docs.vigolium.com/server-mode/ingestion) für Ingestion-Workflows und die [API-Übersicht](https://docs.vigolium.com/api-overview) für die vollständige REST-API-Referenz.

> **Proxy-Integrationen**: Leiten Sie Live-Proxy-Traffic an einen laufenden Vigolium-Server weiter – mit der [burp-vigolium](https://github.com/vigolium/burp-vigolium)-Erweiterung für Burp Suite oder dem [caido-vigolium](https://github.com/vigolium/caido-vigolium)-Plugin für Caido. Beide verwenden dasselbe Bridge-Protokoll (`-B/--burp-bridge-url`, Alias `--caido-bridge-url`), und eingelesener Traffic wird mit dem Proxy gekennzeichnet, von dem er stammt.

## Authentifiziertes Scannen

Vigolium unterstützt mehrsitziges authentifiziertes Scannen für IDOR/BOLA-Tests und Privilege-Escalation-Prüfungen:```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"
```
Auth-Dateien unterstützen statische Header, Bearer-Tokens und automatisierte Login-Abläufe mit Token-Extraktion aus Cookies, JSON-Antworten oder Headern. Vordefinierte Beispiele sind in `public/presets/sessions/` verfügbar. Die vollständige Anleitung findest du im [Authentifizierungs-Guide](https://docs.vigolium.com/native-scan/authentication).

> Die Flags `--auth` / `--auth-file` hießen zuvor `--session` / `--session-file`. Die alten Namen funktionieren weiterhin als veraltete Aliase.

## Agentic Scan

KI-gesteuertes Scannen, bei dem Agenten autonom Schwachstellenbewertungen mit der nativen Scan-Engine im Hintergrund planen, ausführen und priorisieren:```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)
```
Agentic-Scan-Modi:
- **Autopilot**: autonomes Scannen. Die CLI ruft `pkg/olium/autopilot.Run` direkt auf; der Server fügt vigolium-audit-Vorbereitung, Auth-Setup und ein eingefrorenes Kontext-Bundle um dieselbe Schleife hinzu
- **Swarm**: KI-gestütztes Schwachstellen-Scannen mit Unterstützung für gezielte Einzelanfragen und vollständigen Scope (`--discover`). Der Master-Agent analysiert Eingaben, wählt Module aus, generiert benutzerdefinierte JS-Erweiterungen, führt Code-Audit und SAST durch, führt Scans aus und priorisiert Ergebnisse
- **Audit**: Quellcode-Audit über `vigolium agent audit` — ein einheitlicher Dispatcher, der die eingebetteten **vigolium-audit** (claude/codex) und/oder **piolium** (Pi-nativ) Harnesses ausführt, ausgewählt mit `--driver {auto|both|audit|piolium}` (Standard `auto`: Preflight des Audit-Teils und Ausführung, wenn die aufgelöste `claude`/`codex`-CLI im PATH ist, die Binärdatei eingebettet ist und die Kette einen audit-unterstützten Modus hat; andernfalls Fallback auf piolium ohne Audit-Start. Ein Audit-Fehler während des Laufs wird angezeigt, anstatt den Treiber zu wechseln). Separate Harnesses; **nicht** über olium leiten. Pro-Treiber-Unterzeilen unter einem übergeordneten AgenticScan mit Deduplizierung der Ergebnisse im Nachgang. Es gibt keinen eigenständigen `agent piolium`-Unterbefehl — piolium läuft über `--driver=piolium`

> **Eigenständige Audit-CLIs**: das agentische Sicherheitsaudit wird auch als eigenständige CLIs ausgeliefert, die du unabhängig von Vigolium ausführen kannst: [vigolium-audit](https://github.com/vigolium/vigolium-audit) (die Harness hinter `vigolium agent audit`) und [piolium](https://github.com/vigolium/piolium) (der Pi-native Treiber hinter `vigolium agent audit --driver=piolium`).

Siehe den [Agent-Modus-Leitfaden](https://docs.vigolium.com/agentic-scan/agent-mode) für den vollständigen Leitfaden.

## ⚡ Vigolium Cloud Console

Eine cloudbasierte Lösung für Teams, die die Leistung von Vigolium nutzen möchten, ohne Infrastruktur zu verwalten. Console ist die **aktualisierte, voll ausgestattete Version von Vigolium**, angeführt von einem **fortschrittlichen autonomen Agenten**, der das gesamte Engagement steuert — über das Ziel nachdenkt, eigene Angriffspfade wählt und bestätigt, was er findet — mit gehostetem Scannen und geteilten Ergebnissen, die auf dem Open-Source-Kern aufbauen, sodass du dich auf das Beheben von Schwachstellen konzentrieren kannst, anstatt Tooling zu warten.

> Interessiert? [Kontaktiere uns für eine Demo](https://www.vigolium.com/request-demo).

## Native Scan-Ebenen

Die native Scan-Pipeline besteht aus modularen Ebenen, die jeweils separat dokumentiert sind:

| Ebene | Beschreibung | Doku |
|-------|-------------|------|
| **Content Discovery (Deparos)** | Adaptive Verzeichnis-/Dateienumeration mit Fingerabdruck-basierter Soft-404-Erkennung | [docs.vigolium.com/native-scan/phases/discovery](https://docs.vigolium.com/native-scan/phases/discovery) |
| **Browser Spider (Spitolas)** | Chromium-gesteuerter Zustandsmaschinen-Crawler mit CDP-Traffic-Erfassung | [docs.vigolium.com/native-scan/phases/spidering](https://docs.vigolium.com/native-scan/phases/spidering) |
| **Audit** | Aktives/passives Schwachstellen-Scannen mit Insertion-Point-Extraktion und DiffScan-Framework | [docs.vigolium.com/native-scan/phases/audit](https://docs.vigolium.com/native-scan/phases/audit) |
| **Scanner-Module** | 207 aktive und 116 passive Module, die OWASP Top 10 und mehr abdecken | [docs.vigolium.com/native-scan/modules-reference](https://docs.vigolium.com/native-scan/modules-reference) |

## Dokumentation

Die vollständige Dokumentation findest du unter [docs.vigolium.com](https://docs.vigolium.com/). Versionshinweise und Versionshistorie findest du im [CHANGELOG](https://github.com/vigolium/vigolium/blob/main/CHANGELOG.md). Schnelllinks:

| Thema | Link |
|-------|------|
| Agents einrichten | [docs.vigolium.com/getting-started/setup-agent](https://docs.vigolium.com/getting-started/setup-agent) |
| Native Scan starten | [docs.vigolium.com/getting-started/native-scan](https://docs.vigolium.com/getting-started/native-scan) |
| Agentic Scan starten | [docs.vigolium.com/getting-started/agentic-scan](https://docs.vigolium.com/getting-started/agentic-scan) |
| Agentic Audit starten | [docs.vigolium.com/getting-started/agentic-security-audit](https://docs.vigolium.com/getting-started/agentic-security-audit) |
| Schnellstart | [docs.vigolium.com/getting-started/quickstart](https://docs.vigolium.com/getting-started/quickstart) |
| Spickzettel | [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet) |
| Server & Ingestion | [docs.vigolium.com/getting-started/server-and-ingestion](https://docs.vigolium.com/getting-started/server-and-ingestion) |
| Erweiterungen schreiben | [docs.vigolium.com/customization/writing-extensions](https://docs.vigolium.com/customization/writing-extensions) |

## JavaScript-Engine

JavaScript/TypeScript-Code direkt ausführen oder benutzerdefinierte Scan-Module und Hooks schreiben, ohne neu zu kompilieren:```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
```
Die JS-Engine stellt session-bewusste HTTP-APIs für authentifizierte Tests bereit:```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" } }
]);
```
Siehe [Erweiterungen schreiben](https://docs.vigolium.com/customization/writing-extensions) für den Leitfaden zur Erstellung von Erweiterungen und `pkg/jsext/vigolium.d.ts` für die vollständigen TypeScript-API-Definitionen.

## CLI-Referenz

<details>
<summary>Die vollständige Referenz zu Befehlen & Flags erweitern</summary>

### Befehle```
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
```
### Flags```
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>

## Repository-Struktur

Das Verzeichnis `platform/` enthält externe Werkzeuge, das UI-Dashboard und ist nicht Teil des Kern-Scanners. Es sollten keine Änderungen daran vorgenommen werden.

## Benchmarks

Vigolium wird kontinuierlich gegen absichtlich verwundbare Anwendungen benchmarkt und zusätzlich umfassend gegen reale Zielsysteme im Rahmen von Bug-Bounty- und verantwortungsvollen Offenlegungsprogrammen getestet.

- **Selbst gehostet (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) (benutzerdefinierte Next.js-App)
- **Extern (gehostet):** [Acunetix TestPHP](http://testphp.vulnweb.com), [Gin & Juice Shop](https://ginandjuice.shop), [Testfire](http://demo.testfire.net)
- **XSS & Multi-Schwachstellen:** [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, Command Injection)

Führe Benchmarks mit `make test-canary` (Docker-Apps) oder `make test-integration` (XSS) aus.

## Entwicklung```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
```
Siehe [HACKING.md](https://github.com/vigolium/vigolium/blob/main/HACKING.md) für die vollständige Build-Anleitung, die Codebase-Übersicht und den Leitfaden zur Modulentwicklung.

## Sicherheit

Vigolium ist ein offensives Sicherheitstool, und zwei Teile davon sind absichtlich permissiv gestaltet: **Der Agentenmodus läuft ohne Sandbox** (die LLM hat vollen Shell-, Datei- und Netzwerkzugriff auf dem Host) und **Erweiterungen können beliebige Befehle ausführen**. Führen Sie den Agentenmodus in einem Wegwerf-Container/einer Wegwerf-VM aus, der/die auf das Engagement beschränkt ist, und behandeln Sie nicht vertrauenswürdige Erweiterungen wie nicht vertrauenswürdigen Code. Siehe [SECURITY.md](https://github.com/vigolium/vigolium/blob/main/SECURITY.md), bevor Sie beginnen, und melden Sie Schwachstellen in Vigolium selbst privat an [[email protected]](mailto:[email protected]).

## Lizenz

Vigolium wird unter der [GNU Affero General Public License v3.0](https://github.com/vigolium/vigolium/blob/main/LICENSE) veröffentlicht. Abgeleitete Werke müssen unter denselben Bedingungen offen bleiben.

Mit ♥ erstellt von [@j3ssie](https://x.com/j3ssie), mit [@theblackturtle](https://github.com/theblackturtle) als zentralem Erstbeitragendem.