Vigolium - Hochpräziser Schwachstellen-Scanner, der agentische KI mit nativer Geschwindigkeit, Modularität und Präzision vereint

Vigolium bietet zwei komplementäre Scan-Modi:

• Native Scan (vigolium scan): Schnell, leistungsstark und flexibel. Deterministisches, mehrphasiges Scannen mit 317 Modulen über Content Discovery, Browser-/SPA-Spidering und aktives/passives Audit, das Injection-, Zugriffskontroll-, Datei-/Pfad-, API-/Protokoll-, framework-spezifische, Cloud-/Infra- und Out-of-Band-(OAST-)Schwachstellenklassen abdeckt.

• Agentic Scan (vigolium agent): Prüft Ihre Codebasis gründlich. KI-gesteuertes Scannen, das autonom Angriffe plant, Module auswählt, benutzerdefinierte Erweiterungen generiert und Ergebnisse triagiert, wobei es tiefgehende Quellcode-Prüfung mit autonomem und gezieltem Schwachstellen-Scanning kombiniert.

Installation

Schnellinstallation (Empfohlen)```bash

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

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

Windows

Die obige npm-Installation funktioniert unter Windows. Alternativ können Sie vigolium_<version>_windows_amd64.zip von der Releases-Seite herunterladen, es entpacken und vigolium.exe irgendwo in Ihren PATH legen.

Windows wird nur als x64-Version ausgeliefert; unter Windows ARM läuft es unter Emulation. Der obige Shell- Installer ist nur für POSIX, daher ist vigolium update unter Windows nicht verfügbar — führen Sie die npm-Installation erneut aus oder laden Sie die neuere Zip-Datei herunter, um zu aktualisieren.

### Aus dem Quellcode erstellen```bash
git clone https://github.com/vigolium/vigolium.git
cd vigolium
make build         # build and install to $GOPATH/bin

UI-Dashboard	Traffic-Dashboard

Statische Berichte	Statische Berichte

Native Scan	Agentic Scan

Sponsor

_{Vielen Dank an Daytona für das Sponsoring der Sandbox-Infrastruktur}

Hauptfunktionen

Native Scan

• 324 Scanner-Module: 207 aktiv (Fuzzing) + 117 passiv (Pattern Matching), Abdeckung von OWASP Top 10 und darüber hinaus
• Out-of-band-Testing (OAST): Blind-XSS/SSRF/Command-Injection über interactsh-Callbacks mit automatischer Payload-Korrelation
• Wertbewusste Mutation: klassifiziert Parameter nach semantischem Typ (Integer, UUID, JWT, E-Mail) und mutiert je nach Absicht
• Mehrphasige Pipeline: externes Harvesting, Content Discovery (Deparos), Browser-/SPA-Spidering (Spitolas) und Audit, gesteuert durch Strategie-Presets und Scan-Profile
• Flexible Eingaben: URLs, OpenAPI/Swagger, Postman, Burp Suite, cURL, Nuclei JSONL
• Multi-Session-Authentifizierung: Inline-Sessions, Session-Dateien oder vollständige Auth-Konfigurationen mit Login-Flows, Token-Extraktion und IDOR/BOLA-Testing
• JavaScript-Erweiterungen: benutzerdefinierte Module und Hooks über eingebettete JS-Engine mit session-bewussten HTTP-APIs
• Skalierbar & berichtsfähig: nebenläufiger Worker-Pool mit Rate Limiting pro Host, hybride In-Memory-/Disk-/Redis-Queue und eigenständige HTML-Berichte

Agentic Scan

• In-Process-olium-Runtime: jeder Agent-Modus läuft auf der nativen Go-Engine pkg/olium: turn-basierte Schleife, integrierte Tool-Registry, Skill-Unterstützung und austauschbare Provider-Treiber (keine Subprozess-SDK-Pools)
• Autopilot: Agent entdeckt autonom Endpunkte, führt Scans aus und triagiert Findings, mit optionaler Multi-Spezialisten-Pipeline und Session-Fortsetzung
• Swarm: Master-Agent wählt Module aus, generiert benutzerdefinierte JS-Angriffserweiterungen, führt Code-Audit + SAST aus, führt Scans durch und triagiert Ergebnisse; gezielt oder im vollen Umfang (--discover), mit --diff/--last-commits für änderungsfokussierte Läufe
• Source-Audit-Treiber: audit, piolium und der vereinheitlichte audit-Dispatcher führen Vordergrund-Quellcode-Audits aus, die ein gemeinsames Finding-Schema und DB-Tagging verwenden
• Query-Modus: Single-Shot-Prompts für Code-Review, Endpunkt-Entdeckung und Secret-Erkennung
• Austauschbare Provider: openai-compatible (Standard), openai-codex-oauth, openai-api-key, openai-responses, anthropic-api-key, anthropic-oauth, anthropic-cli, anthropic-compatible, anthropic-vertex, google-vertex. Dieselben Modi werden über die REST-API mit SSE-Streaming und einem OpenAI-kompatiblen Chat-Endpunkt bereitgestellt

Schnellstart: 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

Eine Übersicht über die vollständige Pipeline findest du in der [Architekturübersicht](https://docs.vigolium.com/architecture/overview) und im [Strategieleitfaden](https://docs.vigolium.com/native-scan/strategies) findest du Informationen zu Strategien, Profilen und der Pace-Konfiguration. Eine kurze Befehlsreferenz findest du unter [docs.vigolium.com/getting-started/cheat-sheet](https://docs.vigolium.com/getting-started/cheat-sheet).

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

| -s | --server | Server URL (default: http://localhost:8080) | | -t | --token | API token for authentication | | -o | --output | Output format: text, json, yaml (default: text) | | -v | --verbose | Enable verbose output | | -q | --quiet | Suppress non-essential output | | -h | --help | Show help message | | -V | --version | Show version information |

Beispiele

# Grundlegende Verwendung
kitploit-cli scan --target example.com

# Mit Authentifizierung
kitploit-cli scan --target example.com --token YOUR_API_TOKEN

# JSON-Ausgabe
kitploit-cli scan --target example.com --output json

# Verbose-Modus
kitploit-cli scan --target example.com --verbose

Konfiguration

Die Konfigurationsdatei befindet sich unter ~/.config/kitploit/config.yaml:

server:
  url: "http://localhost:8080"
  timeout: 30

auth:
  token: "your-api-token"

output:
  format: "text"
  color: true
  verbose: false

scan:
  threads: 10
  timeout: 60
  retries: 3

Umgebungsvariablen

API-Referenz

Authentifizierung

Alle API-Anfragen erfordern einen gültigen API-Token im Authorization-Header:

curl -H "Authorization: Bearer YOUR_API_TOKEN" \
     http://localhost:8080/api/v1/scans

Endpunkte

Scans

Ziele

Berichte

Beispielanfragen

Scan erstellen

curl -X POST http://localhost:8080/api/v1/scans \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "target": "example.com",
    "type": "full",
    "options": {
      "threads": 10,
      "timeout": 60
    }
  }'

Scan-Ergebnisse abrufen

curl -H "Authorization: Bearer YOUR_API_TOKEN" \
     http://localhost:8080/api/v1/scans/12345/results

Docker

Dockerfile

FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8080

CMD ["python", "-m", "kitploit"]

Docker Compose

version: '3.8'

services:
  kitploit:
    build: .
    ports:
      - "8080:8080"
    environment:
      - KITPLOIT_SERVER_URL=http://0.0.0.0:8080
      - KITPLOIT_API_TOKEN=${KITPLOIT_API_TOKEN}
    volumes:
      - ./data:/app/data
      - ./config:/app/config
    restart: unless-stopped

Container ausführen

# Image erstellen
docker build -t kitploit .

# Container ausführen
docker run -d \
  --name kitploit \
  -p 8080:8080 \
  -e KITPLOIT_API_TOKEN=YOUR_API_TOKEN \
  -v $(pwd)/data:/app/data \
  kitploit

Entwicklung

Voraussetzungen

• Python 3.8 oder höher
• pip
• Git
• Docker (optional)

Einrichtung

# Repository klonen
git clone https://github.com/kitploit/kitploit.git
cd kitploit

# Virtuelle Umgebung erstellen
python -m venv venv
source venv/bin/activate  # Unter Windows: venv\Scripts\activate

# Abhängigkeiten installieren
pip install -r requirements.txt
pip install -r requirements-dev.txt

# Umgebungsvariablen konfigurieren
cp .env.example .env
# .env nach Bedarf bearbeiten

Tests ausführen

# Alle Tests ausführen
pytest

# Mit Coverage
pytest --cov=kitploit --cov-report=html

# Bestimmte Testdatei ausführen
pytest tests/test_scanner.py

# Bestimmten Test ausführen
pytest tests/test_scanner.py::test_scan_target

Code-Qualität

# Linting
flake8 kitploit/

# Typprüfung
mypy kitploit/

# Formatierung
black kitploit/

# Import-Sortierung
isort kitploit/

Beitragen

1. Repository forken
2. Feature-Branch erstellen (git checkout -b feature/amazing-feature)
3. Änderungen committen (git commit -m 'Add amazing feature')
4. Branch pushen (git push origin feature/amazing-feature)
5. Pull Request erstellen

Fehlerbehebung

Häufige Probleme

Verbindung zum Server nicht möglich

Error: Connection refused

Lösung: Stellen Sie sicher, dass der Server läuft und die URL korrekt ist.

# Server-Status prüfen
curl http://localhost:8080/health

# Server starten
kitploit-cli server start

Ungültiger API-Token

Error: 401 Unauthorized

Lösung: Überprüfen Sie Ihren API-Token und stellen Sie sicher, dass er gültig ist.

# Token in der Konfiguration prüfen
cat ~/.config/kitploit/config.yaml | grep token

# Token über Umgebungsvariable setzen
export KITPLOIT_API_TOKEN=your-valid-token

Scan-Timeout

Error: Scan timed out after 60 seconds

Lösung: Erhöhen Sie den Timeout-Wert in der Konfiguration oder verwenden Sie das --timeout-Flag.

# Timeout erhöhen
kitploit-cli scan --target example.com --timeout 120

Debug-Modus

Aktivieren Sie den Debug-Modus für detaillierte Protokollausgaben:

# Debug-Modus aktivieren
kitploit-cli --debug scan --target example.com

# Oder über Umgebungsvariable
export KITPLOIT_DEBUG=true
kitploit-cli scan --target example.com

Logs

Logs werden standardmäßig in ~/.local/share/kitploit/logs/ gespeichert:

# Logs anzeigen
tail -f ~/.local/share/kitploit/logs/kitploit.log

# Log-Level ändern
export KITPLOIT_LOG_LEVEL=DEBUG

FAQ

Allgemeine Fragen

F: Was ist Kitploit?

A: Kitploit ist ein umfassendes Toolkit für Sicherheitsforschung und Penetrationstests.

F: Ist Kitploit kostenlos?

A: Ja, Kitploit ist Open Source und unter der MIT-Lizenz verfügbar.

F: Welche Python-Versionen werden unterstützt?

A: Kitploit unterstützt Python 3.8 und höher.

F: Kann ich Kitploit kommerziell nutzen?

A: Ja, die MIT-Lizenz erlaubt kommerzielle Nutzung.

Technische Fragen

F: Wie füge ich benutzerdefinierte Module hinzu?

A: Erstellen Sie ein neues Modul im Verzeichnis kitploit/modules/ und registrieren Sie es in kitploit/modules/__init__.py.

F: Wie konfiguriere ich einen Proxy?

A: Fügen Sie die Proxy-Einstellungen zur Konfigurationsdatei hinzu:

proxy:
  http: "http://proxy.example.com:8080"
  https: "https://proxy.example.com:8080"

F: Wie exportiere ich Ergebnisse?

A: Verwenden Sie das --output-Flag oder die API:

# In JSON exportieren
kitploit-cli scan --target example.com --output json > results.json

# In YAML exportieren
kitploit-cli scan --target example.com --output yaml > results.yaml

Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – siehe die Datei LICENSE für Details.

Danksagungen

• Contributors
• Open Source Community
• Security Researchers

Support

• Documentation
• GitHub Issues
• Discord Community
• Email Support

Hinweis: Dieses Tool ist nur für autorisierte Sicherheitstests und Bildungszwecke bestimmt. Stellen Sie stets sicher, dass Sie die entsprechenden Berechtigungen besitzen, bevor Sie Tests an einem Ziel durchführen.```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

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-Verkehr 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 an einen laufenden Vigolium-Server weiter. Beide bedienen dasselbe Bridge-Protokoll (`-B/--burp-bridge-url`, Alias `--caido-bridge-url`), und ingestierter Verkehr wird mit dem Proxy gekennzeichnet, von dem er stammt.

## Authentifiziertes Scannen

Vigolium unterstützt authentifiziertes Scannen mit mehreren Sitzungen für IDOR/BOLA-Tests und Prüfungen auf Rechteausweitung:```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-Token und automatisierte Login-Flows mit Token-Extraktion aus Cookies, JSON-Antworten oder Headern. Vordefinierte Beispiele sind in public/presets/sessions/ verfügbar. Siehe den Authentifizierungsleitfaden für die vollständige Anleitung.

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

Agentischer Scan

KI-gesteuertes Scannen, bei dem Agenten autonom Schwachstellenbewertungen planen, ausführen und triagieren, mit der nativen Scan-Engine darunter:```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)

Agentische Scan-Modi:
- **Autopilot**: autonomes Scannen. Die CLI ruft `pkg/olium/autopilot.Run` direkt auf; der Server ergänzt vigolium-audit-Vorbereitung, Auth-Setup und ein eingefrorenes Kontext-Bundle um dieselbe Schleife
- **Swarm**: KI-gesteuertes Schwachstellen-Scanning 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 aus, startet Scans und triagiert Ergebnisse
- **Audit**: Quellcode-Audit über `vigolium agent audit` — ein einheitlicher Dispatcher, der die eingebetteten **vigolium-audit**- (claude/codex) und/oder **piolium**- (Pi-native) Harnesses ausführt, ausgewählt mit `--driver {auto|both|audit|piolium}` (Standard `auto`: Preflight des Audit-Zweigs und Ausführung, wenn die aufgelöste `claude`/`codex`-CLI im PATH liegt, die Binary eingebettet ist und die Chain einen audit-unterstützten Modus hat; andernfalls Rückfall auf piolium ohne Start des Audits. Ein Audit-Fehler während der Ausführung wird sichtbar gemacht, statt den Treiber zu wechseln). Getrennte Harnesses; **nicht** über olium leiten. Pro-Treiber-Kindzeilen unter einem übergeordneten AgenticScan mit Deduplizierung der Findings im Nachgang. Es gibt kein eigenständiges `agent piolium`-Unterkommando — piolium läuft über `--driver=piolium`

> **Eigenständige Audit-CLIs**: Das agentische Sicherheitsaudit wird auch als eigenständige CLIs ausgeliefert, die unabhängig von Vigolium ausgeführt werden können: [vigolium-audit](https://github.com/vigolium/vigolium-audit) (das 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 die vollständige Anleitung.

## ⚡ Vigolium Cloud Console

Eine cloudbasierte Lösung für Teams, die die Leistungsfähigkeit von Vigolium nutzen möchten, ohne Infrastruktur verwalten zu müssen. Console ist die **erweiterte, voll ausgestattete Version von Vigolium**, angeführt von einem **fortschrittlichen autonomen Agenten**, der das gesamte Engagement steuert — er denkt über das Ziel nach, wählt seine eigenen Angriffspfade und bestätigt, was er findet — mit gehostetem Scanning und geteilten Ergebnissen, die auf dem Open-Source-Kern aufsetzen, damit Sie sich auf die Behebung von Schwachstellen konzentrieren können, statt Tooling zu warten.

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

## Native Scan Layers

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

| Layer | Beschreibung | Docs |
|-------|-------------|------|
| **Content Discovery (Deparos)** | Adaptive Verzeichnis-/Datei-Enumeration mit fingerprint-basierter Soft-404-Erkennung | [docs.vigolium.com/native-scan/phases/discovery](https://docs.vigolium.com/native-scan/phases/discovery) |
| **Browser Spider (Spitolas)** | Chromium-gesteuerter State-Machine-Crawler mit CDP-Traffic-Erfassung | [docs.vigolium.com/native-scan/phases/spidering](https://docs.vigolium.com/native-scan/phases/spidering) |
| **Audit** | Aktives/passives Schwachstellen-Scanning 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 117 passive Module, die 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 finden Sie unter [docs.vigolium.com](https://docs.vigolium.com/). Versionshinweise und Versionshistorie stehen im [CHANGELOG](https://github.com/vigolium/vigolium/blob/main/CHANGELOG.md). Schnellzugriffe:

| Thema | Link |
|-------|------|
| Setup Agents | [docs.vigolium.com/getting-started/setup-agent](https://docs.vigolium.com/getting-started/setup-agent) |
| Start a Native Scan | [docs.vigolium.com/getting-started/native-scan](https://docs.vigolium.com/getting-started/native-scan) |
| Start an Agentic Scan | [docs.vigolium.com/getting-started/agentic-scan](https://docs.vigolium.com/getting-started/agentic-scan) |
| Start an Agentic Audit | [docs.vigolium.com/getting-started/agentic-security-audit](https://docs.vigolium.com/getting-started/agentic-security-audit) |
| Quickstart | [docs.vigolium.com/getting-started/quickstart](https://docs.vigolium.com/getting-started/quickstart) |
| Cheat Sheet | [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) |
| Writing Extensions | [docs.vigolium.com/customization/writing-extensions](https://docs.vigolium.com/customization/writing-extensions) |

## JavaScript Engine

Führen Sie JavaScript/TypeScript-Code direkt aus oder schreiben Sie benutzerdefinierte Scan-Module und Hooks ohne Neukompilierung:```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 sitzungsbewusste 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 [writing extensions](https://docs.vigolium.com/customization/writing-extensions) für den Leitfaden zum Erstellen von Erweiterungen und `pkg/jsext/vigolium.d.ts` für die vollständigen TypeScript-API-Definitionen.

## CLI-Referenz

<details>
<summary>Vollständige Referenz der Befehle & 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: 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 / HEADN for change-focused scans --last-commits Shorthand for --diff HEADN --code-audit Enable AI code audit (default: on with --source) --discover Run discovery+spidering before planning (swarm) --audit vigolium-audit mode: lite, balanced, deep, mock, off --piolium Piolium audit mode (empty = auto-pick) --resume Resume a durable-autopilot run by agentic-scan UUID --session-dir Pin the session dir for this run's debug artifacts --transcript Copy transcript.jsonl out after the run --max-iterations Max triage-rescan iterations --max-commands Cap on agent tool calls --token-budget Cap on aggregate tokens --max-duration Max agent wall-clock time (0 = no limit) --only / --skip / --start-from Phase control (swarm)

Source audit (vigolium agent audit / vigolium audit): --driver auto (default), both, audit, piolium --intensity Preset: quick, balanced, deep (deep = modes deep,confirm) --mode Mode override: lite, balanced, deep, revisit, confirm, merge, ... --modes Chain modes back-to-back (e.g. deep,confirm) --list-modes Print the audit mode graph and exit --agent Coding agent for the audit leg: claude or codex --keep-raw Keep raw output under /vigolium-results/ (on by default) --clean-raw Remove the source-tree raw copy after the run -S, --stateless Run into a throwaway DB and auto-render an HTML report --output-dir Bundle the HTML report + raw results into one folder (needs -S) --no-dedup Skip the post-pass project-wide findings dedup --no-preflight Skip the pre-audit auth/model roundtrip checks -i, --interactive Drive the audit yourself in the coding agent (audit driver only)

JavaScript: --code Inline JavaScript to execute --code-file Path to JS/TS file to execute --timeout Execution timeout (default: 30s)

Output: -j, --json Compact, token-aware JSON output (read/query commands) --format Output format (comma-separated for multiple): console, jsonl, html, sqlite (needs -S), fs (flat traffic/finding tree) -o, --output Output file path --silent Suppress all output except findings -v, --verbose Verbose logging

</details>

## Repository-Layout

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

## Benchmarks

Vigolium wird kontinuierlich gegen absichtlich verwundbare Anwendungen gebenchmarkt und zudem intensiv gegen reale Ziele durch Bug-Bounty- und Responsible-Disclosure-Programme 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-Vuln:** [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ühren Sie 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 für die vollständige Build-Anleitung, die Codebasis-Übersicht und den Leitfaden zur Modulentwicklung.

Sicherheit

Vigolium ist ein Offensive-Security-Tool, und zwei Teile davon sind absichtlich permissiv: Der Agent-Modus läuft ohne Sandbox (das LLM hat vollen Shell-, Datei- und Netzwerkzugriff auf dem Host) und Erweiterungen können beliebige Befehle ausführen. Führen Sie den Agent-Modus in einem wegwerfbaren Container/VM aus, der auf das Engagement beschränkt ist, und behandeln Sie nicht vertrauenswürdige Erweiterungen wie nicht vertrauenswürdigen Code. Lesen Sie SECURITY.md, bevor Sie beginnen, und melden Sie Schwachstellen in Vigolium selbst vertraulich an [email protected].

Lizenz

Vigolium wird unter der MIT-Lizenz veröffentlicht.

Mit ♥ erstellt von @j3ssie, mit @theblackturtle als einem der ursprünglichen Kern-Mitwirkenden.