Autonome KI-Pentesting-Agenten — Echtzeit-Aufklärung, Schwachstellenerkennung und Exploit-Orchestrierung. Go + TypeScript.
<div align="center">
<img src="https://raw.githubusercontent.com/xalgord/xalgorix/main/assets/banner.png?v=4.6.133" alt="Xalgorix — KI-gestützte autonome Penetration-Testing-Plattform" width="860" />
<br />
[](https://go.dev)
[](LICENSE)
[](#-installation)
[](https://www.xalgorix.com/)
[](https://github.com/xalgorix/xalgorix/stargazers)
[](https://github.com/xalgorix/xalgorix/network/members)
[](https://github.com/xalgorix/xalgorix/releases)
[](https://deepwiki.com/xalgorix/xalgorix)
</div>
<h1 align="center">Xalgorix — Open-Source-KI-Pentester, der Schwachstellen <em>beweist</em></h1>
<p align="center">
<strong>Die meisten Scanner erkennen. Xalgorix beweist.</strong> Ein autonomer LLM-Agent arbeitet eine vollständige Pentest-Methodik ab, dann <strong>re-exploitet ein unabhängiger Verifizierer jeden Fund</strong>, bevor er gemeldet wird — so erhalten Sie Beweise statt eines Haufens von Vielleichts zum Triagieren. Selbst gehostet, privat und Bring-Your-Own-LLM. Entwickelt in Go + TypeScript.
</p>
<p align="center">
<a href="#-quick-start">🚀 Schnellstart</a> ·
<a href="#-why-xalgorix">💡 Warum Xalgorix</a> ·
<a href="#-features">✨ Funktionen</a> ·
<a href="#-use-cases">🎯 Anwendungsfälle</a> ·
<a href="https://www.xalgorix.com/">☁️ Hosted Cloud</a> ·
<a href="https://docs.xalgorix.com">📖 Docs</a>
</p>
---
## 🎬 Launch-Überblick
<div align="center">
[](https://youtu.be/B23boh51u8A)
**▶️ [Sehen Sie das 50-sekündige Launch-Video](https://youtu.be/B23boh51u8A)** — Xalgorix in Aktion: autonomes Scannen und exploit-verifizierte Funde in unter einer Minute.
</div>
---
## 📸 Screenshots
**🖥️ Selbst gehostetes Dashboard** — läuft lokal auf `127.0.0.1:9137`
| Übersichts-Dashboard | Scan-Detail | Funde |
| ------------------------------------------------------- | ------------------------------------------------ | --------------------------------------------- |
|  |  |  |
**☁️ Hosted-Cloud-Dashboard** — die vollständig verwaltete Version unter [www.xalgorix.com](https://www.xalgorix.com/)
<img src="https://raw.githubusercontent.com/xalgord/xalgorix/main/assets/SaaS-dashboard.png?v=4.5.154" alt="Xalgorix Hosted-Cloud-Dashboard mit Sicherheitsbewertung, Schwachstellentrends, Behebungsmetriken und offenen Problemen nach Kategorie" width="860" />
---
## 🤝 Sponsoren
Dank an **[Swiftproxy](https://www.swiftproxy.net/?ref=xalgorix)** für das Sponsoring von Xalgorix.
<a href="https://www.swiftproxy.net/?ref=xalgorix">
<img src="https://raw.githubusercontent.com/xalgord/xalgorix/main/assets/swiftproxy_xalgorix.webp" alt="Swiftproxy sponsert Xalgorix — Residential-Proxies für autorisiertes Testen über verschiedene Standorte hinweg" width="860" />
</a>
Ihre App kann sich je nach Herkunft einer Anfrage unterschiedlich verhalten. Für Xalgorix-Nutzer, die ihre eigenen Anwendungen über verschiedene Regionen hinweg prüfen, bietet Swiftproxy **Location-Targeting**, um regionales Verhalten zu überprüfen, und **Sticky Sessions**, um während einer Testsitzung eine konsistente IP beizubehalten. Es unterstützt **HTTP(S) und SOCKS5**, dieselben Proxy-Protokolle, die Xalgorix unterstützt.
Residential-Proxies ab **0,70 $/GB**. **Kostenloses Testen ist verfügbar**, und Xalgorix-Nutzer erhalten **10 % Rabatt** mit dem Code **`PROXY90`**.
[**Swiftproxy entdecken und einen kostenlosen Test anfordern →**](https://www.swiftproxy.net/?ref=xalgorix)
---
## 🚀 Schnellstart
**Installation (eine Zeile):**
```bash
curl -sSL https://www.xalgorix.com/install | bash
```
Dies lädt die vorgefertigte Binärdatei für deine Plattform (Linux oder macOS, amd64/arm64) aus dem neuesten Release herunter.
**Oder installiere mit Go 1.26 oder neuer:**
```bash
go install github.com/xalgord/xalgorix/v4/cmd/xalgorix@latest
```
Stelle sicher, dass `$(go env GOPATH)/bin` (oder dein `GOBIN`) in deinem `PATH` enthalten ist, bevor du `xalgorix` ausführst.
Führe dann den interaktiven Einrichtungsassistenten aus:
```bash
xalgorix --setup
```
Wählen Sie Ihren Anbieter, bestätigen Sie ein Modell und geben Sie den API-Schlüssel ein, wenn Sie dazu aufgefordert werden. Für beste Ergebnisse verwenden Sie ein aktuelles Frontier-Modell mit starker Reasoning-Fähigkeit, langer Kontextleistung und zuverlässigem Tool-Calling – wie das neueste verfügbare leistungsfähige GPT-, Claude- oder Gemini-Modell. Kleinere oder lokale Modelle werden weiterhin unterstützt, erfordern jedoch möglicherweise mehr Aufsicht während langer autonomer Scans. Xalgorix speichert den Schlüssel privat in `~/.xalgorix.env` (Modus `0600`) und kann das Dashboard für Sie starten. Lokales Ollama benötigt keinen API-Schlüssel.
Wenn Sie sich entscheiden, nicht sofort zu starten, starten Sie später mit `xalgorix --web` und öffnen Sie `http://127.0.0.1:9137`. Sie können Anbieter oder erweiterte Optionen jederzeit unter **Settings → LLM** ändern oder `xalgorix --setup` erneut ausführen.
**Oder mit Docker ausführen – alles inklusive, keine Toolchain erforderlich:**
```bash
docker run --rm -p 9137:9137 \
--privileged \
-v xalgorix-data:/data \
xalgord/xalgorix:latest
```
`--privileged` gibt dem Toolset denselben hostähnlichen Zugriff, den es hat, wenn es nativ als root ausgeführt wird. Die Standard-Sandbox von Docker entzieht Capabilities (wie `NET_ADMIN`) und wendet einen seccomp-Filter an, was Low-Level-Tools beeinträchtigt (iptables/route-Änderungen, ARP-Spoofing/MITM, tun/tap-VPNs, ptrace-basierte Debugger, masscan-Interface-Tuning). Da ein Image sich diese nicht selbst gewähren kann, müssen sie zur Laufzeit gesetzt werden. Der Container ist eine wegwerfbare, netzwerkisolierte Scanning-Sandbox, die als root läuft — privileged ist die beabsichtigte Konfiguration; stelle das Dashboard niemals ohne Authentifizierung öffentlich bereit. Bevorzugst du Least Privilege? Ersetze `--privileged` durch `--cap-add=NET_ADMIN --cap-add=NET_RAW --cap-add=SYS_PTRACE --security-opt seccomp=unconfined`.
Öffne `http://localhost:9137`. Du **benötigst keinen LLM-Schlüssel zum Starten** — das Dashboard startet ohne einen; setze das Modell + den API-Schlüssel unter **Settings → LLM** (er wird im `/data`-Volume persistiert). Wenn du `XALGORIX_USERNAME`/`XALGORIX_PASSWORD` nicht übergibst, wird ein zufälliges Admin-Passwort generiert und beim ersten Start in den Container-Logs ausgegeben.
**Maschine-zu-Maschine-API-Zugriff** — gib Automatisierung (deinem eigenen Backend, CI, Skripten) ein dediziertes `Authorization: Bearer`-Token anstelle von Dashboard-Anmeldedaten: setze `XALGORIX_API_TOKEN` (oder `XALGORIX_API_TOKENS` für ein kommagetrenntes Rotations-Set). Maschinen-Token autorisieren nur `/api/*`-Routen und den Scan-Event-WebSocket — niemals die Dashboard-UI oder operator-exklusive Einstellungsrouten — erzeugen niemals Browser-Sitzungen, interagieren niemals mit dem Login-Rate-Limiter des Dashboards und werden gegen gespeicherte SHA-256-Digests mit konstantzeitlichem Vergleich abgeglichen. Der menschliche Dashboard-Login (`XALGORIX_USERNAME` + `XALGORIX_PASSWORD_HASH`) funktioniert unverändert daneben weiter.
**Am einfachsten — Docker Compose** (mappt den Port + ein persistentes Volume für dich):
```bash
curl -sSLO https://raw.githubusercontent.com/xalgorix/xalgorix/main/docker-compose.yml
docker compose up -d
docker compose logs -f # shows the generated admin password on first start
```
Das Image enthält ein umfangreiches, vorinstalliertes Offensive-Security-Toolset (nmap, nuclei, httpx, subfinder, katana, ffuf, gobuster, sqlmap, masscan, dalfox, feroxbuster und mehr) **und** hält jeden Paketmanager (apt, go, cargo, pipx, npm) verfügbar, damit der Agent fehlende Komponenten zur Laufzeit weiterhin automatisch installieren kann. Es läuft konstruktionsbedingt als root innerhalb des Containers — behandle den Container als wegwerfbare, netzwerkisolierte Scanning-Sandbox und setze das Dashboard niemals ohne Authentifizierung exponiert ein. Images werden sowohl für amd64 als auch für arm64 veröffentlicht.
**Oder aus dem Quellcode bauen** (benötigt Go 1.26+ und Node.js):
```bash
git clone https://github.com/xalgorix/xalgorix.git
cd xalgorix
make build
sudo install -m 755 build/xalgorix /usr/local/bin/xalgorix
```
> [!TIP]
> Bevorzugst du Zero-Setup? Eine vollständig verwaltete Version läuft unter [www.xalgorix.com](https://www.xalgorix.com/) — Click-to-Scan, keine Installation oder API-Schlüssel erforderlich.
### 🤖 Pull Requests automatisch überprüfen — kostenlose GitHub App
Möchtest du bei jedem Pull Request ein Security-Review ohne Setup? Installiere die **[Xalgorix GitHub App](https://github.com/apps/xalgorix)**. Sie liest den Diff jedes PRs und kommentiert ein Security-Review — Injection, Broken Auth/IDOR, SSRF, Secrets, unsichere Muster — direkt am Pull Request. Aktualisiert sich bei neuen Commits an Ort und Stelle, und du kannst **`@xalgorix review`** kommentieren, um bei Bedarf erneut auszuführen. Keine Workflow-Datei, kein API-Schlüssel, kein Konto — und es ist kostenlos.
<div align="center">
[**➕ Xalgorix zu GitHub hinzufügen →**](https://github.com/apps/xalgorix/installations/new)
</div>
Für Merge-Gating und vollständig exploit-verifizierte Pentests in CI verwende den [gehosteten Scanner](https://www.xalgorix.com/) oder die GitHub Action.
> [!IMPORTANT]
> Verwende Xalgorix nur auf Systemen, die dir gehören oder für die du ausdrückliche Testgenehmigung hast.
> [!TIP]
> Bevorzugst du kein Self-Hosting? Eine vollständig verwaltete Version ist unter [www.xalgorix.com](https://www.xalgorix.com/) verfügbar — Click-to-Scan, keine Installation oder API-Schlüssel erforderlich.
## 📚 Inhalt
| | | |
| --- | --- | --- |
| 📸 [Screenshots](#-screenshots) | 🔩 [Konfiguration](#-configuration) | 🧾 [Umgebungsvariablen](#-environment-variables) |
| 🎬 [Launch-Übersicht](#-launch-overview) | 🚀 [Schnellstart](#-quick-start) | 🆙 [Upgrade](#-upgrading-from-previous-versions) |
| 🔎 [Übersicht](#-overview) | 🏃 [Ausführung](#-running) | 🔤 [Provider-Präfixe](#-provider-prefixes) |
| 💡 [Warum Xalgorix](#-why-xalgorix) | 🧰 [Service-Modus](#-service-mode) | 💻 [CLI-Referenz](#-cli-reference) |
| 🎯 [Anwendungsfälle](#-use-cases) | 🔁 [Web-UI-Workflow](#-web-ui-workflow) | 📡 [API-Übersicht](#-api-summary) |
| 🎯 [Anwendungsfälle](#-use-cases) | 🔁 [Web-UI-Workflow](#-web-ui-workflow) | 💾 [Datenspeicherung](#-data-storage) |
| ✨ [Funktionen](#-features) | 🔀 [Scan-Modi](#-scan-modes) | 🧪 [Entwicklung](#-development) |
| 📥 [Installation](#-installation) | 📂 [Deinen Code scannen](#-scan-your-code-no-target-needed) | 🚨 [Sicherheitshinweise](#-safety-notes) |
| 🧭 [Methodik](#-methodology) | 📄 [Berichte](#-reports) | 📜 [Lizenz](#-license) |
| 🔧 [Einstellungen](#-settings) | 🔗 [Links](#-links) | 🤝 [Sponsoren](#-sponsors) |
## 🔎 Übersicht
Xalgorix ist eine selbst gehostete KI-Penetrationstest-Plattform für autorisierte Sicherheitstests, Schwachstellenbewertung und Bug-Bounty-Workflows. Sie kombiniert einen LLM-gesteuerten autonomen Agenten, Browser-Automatisierung, Terminal-Tooling, eine umfassende 22-Phasen-Testmethodik, Live-WebSocket-Telemetrie, Finding-Management mit CVSS-Bewertung, markengerechte PDF-Berichtsgenerierung und Integrationen für AgentMail, Discord und Telegram.
Anders als reine Cloud-DAST-Scanner läuft Xalgorix vollständig auf deiner Maschine. Du bringst deinen eigenen LLM-Provider mit (OpenAI, Anthropic, DeepSeek, Gemini, Groq, Ollama, MiniMax) und kontrollierst Modell, Reasoning-Aufwand, Rate-Limits und Proxy-Konfiguration. Keine Scan-Daten, API-Schlüssel oder Zielinformationen verlassen deine Infrastruktur.
Die Standarderfahrung ist die Web-UI. Von einem lokalen Dashboard aus kannst du Scans starten, aktive Läufe überwachen, Findings inspizieren, Modell-/Provider-Einstellungen konfigurieren, Umgebungsvariablen verwalten, markengerechte PDF-Berichte generieren und historische Scans löschen oder fortsetzen.
## 💡 Warum Xalgorix
Die meisten Scanner **erkennen**. Xalgorix **beweist**. Ein autonomer Agent arbeitet eine 22-Phasen-Methodik durch, dann testet ein unabhängiger Verifizierer jedes Kandidaten-Finding erneut, bevor es gemeldet wird — so erhältst du exploit-verifizierte Ergebnisse mit Belegen, nicht eine Wand von „Vielleichts" zum Triagieren.
- 🧠 **Ein KI-Agent, keine Template-Engine** — argumentiert über Auth-Flows, Business-Logik, IDOR/BOLA und verkettete Exploits, die Signatur-Scanner übersehen.
- ✅ **Exploit-verifizierte Findings** — ein separater Verifizierer reproduziert jedes Finding unabhängig; unschlüssige werden zur Überprüfung markiert, niemals als bestätigt dargestellt.
- 🔒 **Selbst gehostet und privat** — läuft auf deiner Maschine mit deinem eigenen LLM-Schlüssel; keine Zieldaten, Schlüssel oder Findings verlassen deine Infrastruktur.
- 🧩 **Bring dein eigenes LLM mit** — OpenAI, Anthropic, DeepSeek, Gemini, Groq, Ollama oder MiniMax — oder jedes OpenAI-kompatible Gateway wie [LiteLLM](#-litellm--openai-compatible-gateways-github-copilot-claude-opus-codex-openrouter-azure-local-models) (GitHub Copilot, Codex, OpenRouter, Azure). Du kontrollierst Modell, Reasoning-Aufwand und Kosten.
- 📄 **Audit-taugliche Berichte** — markengerechte PDFs mit CVSS-Scores, Proof-of-Concept und Behebung.
### 📊 Wie es sich vergleicht
| | **Xalgorix** | Template-Scanner (z. B. Nuclei) | Crawling-Scanner (z. B. OWASP ZAP) | Kommerzielles DAST |
| -------------------------------------------- | ------------------------ | ------------------------------- | ---------------------------------- | ---------------------- |
| Ansatz | Autonomer KI-Agent | Signaturen / Templates | Spider + aktive Regeln | Signaturen + Heuristiken |
| Abdeckung von Business-Logik / IDOR / Auth-Bypass | ✅ | Begrenzt | Begrenzt | Teilweise |
| Exploit-verifiziert (beweist Auswirkung) | ✅ unabhängiger Verifizierer | ❌ | ❌ | Teilweise |
| False-Positive-Last | Niedrig (bewiesen) | Template-abhängig | Hoch | Mittel |
| Selbst gehostet / Daten bleiben lokal | ✅ | ✅ | ✅ | Meist Cloud |
| Bring-your-own LLM | ✅ | — | — | ❌ |
| Markengerechte PDF-Berichte | ✅ | ❌ | Basis | ✅ |
| Kosten | Open Source + dein LLM | Kostenlos | Kostenlos | $$$ |
> Richtungsweisender Vergleich — Nuclei und ZAP sind hervorragend in dem, was sie tun. Xalgorix fügt die reasoning-lastige Discovery- und Exploit-Verifizierungsschicht obendrauf hinzu.
### ☁️ Selbst gehostet vs. gehostete Cloud
Xalgorix ist kostenlos und Open Source — hoste es für immer selbst, ohne Bedingungen. Die [gehostete Cloud](https://www.xalgorix.com/) betreibt die **gleiche** exploit-verifizierte Engine; sie existiert für Leute, die lieber keine API-Schlüssel, Infrastruktur und unvorhersehbare LLM-Rechnungen verwalten möchten. Beide sind erstklassig — wähle, was passt.
| | **Selbst gehostet** (dieses Repo) | **[Gehostete Cloud](https://www.xalgorix.com/)** |
| ---------------------------------- | ---------------------------------------- | ----------------------------------------------- |
| Preis zum Start | Kostenlose Engine, Apache-2.0 | [Credit-Pakete oder Abonnements](https://www.xalgorix.com/pricing) |
| LLM-API-Schlüssel | Bring & manage your own | Inklusive — nichts zu verwalten |
| Kosten pro Scan | Rohe LLM-Tokens — variabel, kann steigen | Credit-basiert; siehe [aktuelle Preisgestaltung](https://www.xalgorix.com/pricing) |
| Setup & Betrieb | Du installierst, aktualisierst & betreibst die Toolchain | Nichts zu betreiben — Scan in ~60s |
| Out-of-Band-Infrastruktur (SSRF/Blind RCE) | Eigenen OOB-Server aufsetzen | Managed OOB inklusive |
| Planung | Integrierter Scheduler auf deiner Infrastruktur | Verwaltete tägliche / stündliche Zeitpläne |
| Team · RBAC · geteilte Credits | Single-Operator-Instanz | Organisations-Workspaces bei Teams / Enterprise |
| Updates | `git pull` + Rebuild | Immer auf der neuesten Engine |
| Datenresidenz / Offline | ✅ bleibt auf deiner Infrastruktur · Air-Gap OK | Läuft auf unserer Infrastruktur (DPA verfügbar) |
**Selbst hosten, wenn** Daten in deinem Netzwerk bleiben müssen, du volle Kontrolle willst oder offline/air-gapped betreiben wirst — genau dafür ist es gedacht. **Nutze die Cloud, wenn** du API-Schlüssel, Infrastruktur und überraschende Token-Rechnungen überspringen und nur für die Live-Hosts zahlen möchtest, die du tatsächlich scannst.
<div align="center">
[**☁️ Gehostete Cloud-Pläne entdecken →**](https://www.xalgorix.com/pricing) · [**⚖️ Cloud und Self-Hosting vergleichen →**](https://www.xalgorix.com/hosted-vs-self-hosted)
</div>
Wenn Xalgorix dir einen Triage-Zyklus erspart, bitte **[⭐ starre das Repo](https://github.com/xalgorix/xalgorix)** — es hilft wirklich anderen, es zu finden.
## 🎯 Anwendungsfälle
| Anwendungsfall | Wie Xalgorix hilft |
| -------- | ------------------ |
| **Penetrationstests** | Führe eine vollständige 22-Phasen-Methodik gegen autorisierte Ziele aus. Der KI-Agent übernimmt Reconnaissance, Schwachstellenerkennung, Injection-Tests, SSRF, IDOR, Auth-Bypass, Race Conditions und mehr — und verifiziert dann Findings vor der Meldung. |
| **Bug-Bounty-Jagd** | Richte Xalgorix auf ein In-Scope-Ziel und lass den Agenten die Angriffsfläche enumerieren, auf gängige Schwachstellenklassen testen und verifizierte Findings mit CVSS-Scores und Proof-of-Concept-Belegen aufdecken. |
| **Red-Team-Operationen** | Verwende Wildcard- und Multi-Target-Scan-Modi, um die externe Angriffsfläche einer Organisation zu kartieren. Browser-gestütztes DAST behandelt Auth-Flows, Formulare und Laufzeitverhalten, die statische Scanner übersehen. |
| **Sicherheitsforschung** | Die Phase zur Entdeckung neuartiger Schwachstellen treibt den Agenten über bekanntes Template-Matching hinaus. Bring dein eigenes LLM mit (OpenAI, Anthropic, DeepSeek, Gemini, Ollama, MiniMax), um Reasoning-Tiefe und Kosten zu kontrollieren. |
| **Kontinuierliche Sicherheitstests** | Läuft als Systemdienst mit `xalgorix --start`. Scanne nach Zeitplan, streame Findings zu Discord oder Telegram und generiere markengerechte PDF-Berichte für Stakeholder. |
| **DAST-Automatisierung** | Browser-gesteuerte Tests für Webanwendungen — Auth-Flows, Formulare, JavaScript-gerenderte Inhalte und Laufzeitverhalten. Integriert sich mit Caido zur Proxy-Traffic-Inspektion. |
## ✨ Funktionen
| Bereich | Fähigkeiten |
| -------------- | --------------------------------------------------------------------------------------------------------------------------- |
| 📊 Dashboard | Lokale Web-UI standardmäßig auf `127.0.0.1:9137`, Scan-Management, Live-Status, Bulk-Scan-Aktionen und Wiederherstellung historischer Scans. |
| 🔍 Scannen | Einzelziel-, DAST-, Wildcard- und Multi-Target-Flows mit auswählbaren Methodik-Phasen. |
| 📡 Live-Telemetrie | Tool-Aufrufe, Agent-Nachrichten, Findings, Fehler, HTTP-Aktivität und LLM-Aktivität über WebSockets. |
| 🐞 Findings | Scan-Detailseiten, Schweregrad-Filter, CVSS-Details, Finding-Index und verifizierte Finding-Workflows. |
| 📄 Berichterstattung | Markengerechte PDF-Berichte mit Ziel-/Firmenname, hochgeladenem Logo, Berichtsliste, Öffnen/Herunterladen/Löschen-Aktionen. |
| 🔔 Integrationen | AgentMail-Test-Postfächer, Verifizierungs-E-Mails, OTP-Flows, E-Mail-Triage-Events, Discord- und Telegram-Benachrichtigungen. |
| ⚙️ Konfiguration | Dashboard-Einstellungen für LLM, AgentMail, Discord, Telegram, Proxy, Laufzeit, Browser, Auth, Rate-Limits und Ressourcen. |
| 🛡️ Laufzeitsicherheit | Ressourcenbewusste Instanzlimits und Loopback-only-Bindung, es sei denn, externer Zugriff wird explizit mit Auth konfiguriert. |
## 📥 Installation
Verwende ein vorgefertigtes Binary, Go oder einen Container.
### ⚡ Einzeilige Installation (vorgefertigtes Binary)
```bash
curl -sSL https://www.xalgorix.com/install | bash
```
Lädt die neueste Release-Binary für deine Plattform herunter (Linux oder macOS, `amd64`/`arm64`) und installiert sie nach `/usr/local/bin` (oder `~/.local/bin` ohne sudo). Überschreibe dies mit `XALGORIX_INSTALL_DIR` oder lege eine Version mit `XALGORIX_VERSION=vX.Y.Z` fest.
Führe die erstmalige Konfiguration interaktiv durch – keine manuelle Bearbeitung der Umgebungsdatei erforderlich:
```bash
xalgorix --setup
```
Der Assistent behält vorhandene Einstellungen bei erneuter Ausführung bei, verbirgt die API-Schlüssel-Eingabe in einem Terminal und startet optional die Web-UI, wenn er fertig ist.
### 📦 Installation mit Go
Mit Go 1.26 oder neuer:
```bash
go install github.com/xalgord/xalgorix/v4/cmd/xalgorix@latest
```
Go installiert die Binärdatei nach `GOBIN` oder nach `$(go env GOPATH)/bin`, wenn `GOBIN` nicht gesetzt ist. Füge dieses Verzeichnis zu deinem `PATH` hinzu und führe dann `xalgorix --setup` aus.
### 🐳 Docker
```bash
docker run --rm -p 9137:9137 \
--privileged \
-e XALGORIX_LLM=openai/gpt-5.6 \
-e XALGORIX_API_KEY=your_openai_api_key \
-v xalgorix-data:/data \
ghcr.io/xalgord/xalgorix:latest
```
`--privileged` (oder die engere Variante `--cap-add=NET_ADMIN --cap-add=NET_RAW --cap-add=SYS_PTRACE --security-opt seccomp=unconfined`) verleiht dem Toolset hostähnlichen Zugriff. Dockers Standard-Sandbox entfernt Capabilities und filtert Syscalls, was Low-Level-Tooling beeinträchtigt (iptables/route/Interface-Änderungen, ARP-Spoofing/MITM, tun/tap-VPNs, ptrace-basierte Debugger). Ein Image kann sich diese nicht selbst gewähren — sie sind eine Laufzeitentscheidung — also das Flag übergeben oder die mitgelieferte `docker-compose.yml` verwenden, die es für dich setzt.
Das Image ist **batteries-included**: Ein umfangreiches Offensive-Security-Toolset ist vorinstalliert (nmap, nuclei, httpx, subfinder, dnsx, naabu, katana, ffuf, gobuster, dalfox, feroxbuster, sqlmap, masscan, nikto, whatweb, hydra und mehr), plus Chromium für browserunterstütztes DAST. Es hält außerdem den vollständigen Paketmanager-Satz (apt, go, cargo, pipx, npm) verfügbar, sodass der Agent alles Fehlende zur Laufzeit automatisch installiert. Scandaten werden im `/data`-Volume persistiert, und der Server bindet `0.0.0.0` innerhalb des Containers — setze `XALGORIX_USERNAME`/`XALGORIX_PASSWORD`, bevor du ihn über localhost hinaus exponierst.
Der Container läuft konstruktionsbedingt als root (die Engine aktiviert die automatische Laufzeitinstallation nur für uid 0, und apt/go/cargo-Installationen benötigen System-Schreibzugriff). Behandle ihn als wegwerfbare, netzwerkisolierte Scanning-Sandbox. Dieselben Tags veröffentlichen ein Multi-Plattform-Manifest für `linux/amd64` und `linux/arm64`, sodass Docker automatisch das native Image auswählt.
Beim ersten Start, wenn du keine Dashboard-Authentifizierung setzt, **generiert der Container ein zufälliges Admin-Passwort und gibt es in den Logs aus** (das Image bindet `0.0.0.0`, was die Engine ohne Authentifizierung nicht tun würde). Setze `XALGORIX_USERNAME` + `XALGORIX_PASSWORD` (oder `XALGORIX_PASSWORD_HASH`), um deine eigenen zu verwenden. Die Binary aktualisiert sich niemals selbst innerhalb des Containers (`XALGORIX_NO_AUTO_UPDATE=1`) — ziehe einen neuen Image-Tag, um zu aktualisieren. Die **nuclei**-Engine und ihre Vuln-Templates werden bei jedem Image-Build auf den neuesten Stand gebracht (die Release-CI und `redeploy.sh` erzwingen dies); übergib `--build-arg NUCLEI_VERSION=vX.Y.Z`, um die Engine zu pinnen, oder `NUCLEI_REFRESH=0 ./redeploy.sh`, um Dockers Cache wiederzuverwenden.
### ☸️ Kubernetes (Helm)
Ein Helm-Chart ist im Repository unter [`deploy/chart`](https://github.com/xalgord/xalgorix/blob/main/deploy/chart) enthalten. Es gibt kein gehostetes Chart-Repository, also installiere aus einem Git-Checkout:
```bash
git clone https://github.com/xalgorix/xalgorix.git
cd xalgorix
helm install xalgorix deploy/chart \
--namespace xalgorix --create-namespace \
--set auth.username=admin \
--set auth.password=change-me \
--set env.secret.XALGORIX_LLM=openai/gpt-5.6 \
--set env.secret.XALGORIX_API_KEY=your_openai_api_key
```
- Das Dashboard lauscht auf Port `9137`. Stelle es über `ingress.enabled` (Ingress-Controller) oder `httproute.enabled` (Gateway API) bereit – niemals ohne Dashboard-Authentifizierung.
- Scandaten und persistierte Dashboard-Einstellungen liegen auf einem PVC, das unter `/data` eingebunden ist (siehe `persistence` in `values.yaml`). Einstellungen, die in der Settings-UI des Dashboards geändert werden, werden in `/data/.xalgorix.env` geschrieben und haben beim Neustart Vorrang vor den vom Chart bereitgestellten Umgebungsvariablen.
- Jede `XALGORIX_*`-Variable kann über `env.raw`, `env.config` oder `env.secret` übergeben werden. Dashboard-Anmeldedaten gehören in `auth`, oder verweise mit `auth.existingSecret` auf ein Secret, das `XALGORIX_USERNAME`/`XALGORIX_PASSWORD` enthält.
- Das mitgelieferte Toolset erwartet dieselben erhöhten Berechtigungen wie der Docker-Lauf (`NET_ADMIN`, `NET_RAW`, `SYS_PTRACE`, seccomp `Unconfined`) – siehe die `securityContext`-Beispiele in `values.yaml`.
### 📋 Anforderungen (Build aus dem Quellcode)
| Anforderung | Hinweise |
| -------------- | ------------------------------------------------------------ |
| OS | Linux oder macOS (`amd64`/`arm64`). |
| Go | `1.26` oder neuer. |
| Node.js + npm | Erforderlich, wenn die mitgelieferte React-Web-UI aus dem Quellcode gebaut wird. |
| Sicherheitstools | Werden nur bei Bedarf installiert, wenn die automatische Installation aktiviert ist. |
Überprüfe deine Go-Version:
```bash
go version
```
### 🔨 Aus dem Quellcode bauen
```bash
git clone https://github.com/xalgorix/xalgorix.git
cd xalgorix
make build
sudo install -m 755 build/xalgorix /usr/local/bin/xalgorix
```
`make build` baut die React Web UI in `internal/web/static` ein und kompiliert anschließend das Go-Binary.
## 🔩 Konfiguration
Xalgorix lädt die Konfiguration in dieser Reihenfolge. Spätere Quellen überschreiben frühere.
| Reihenfolge | Quelle |
| ----- | -------------------------------------------------------------- |
| 1 | `/etc/xalgorix.env` |
| 2 | `/home/<sudo-user>/.xalgorix.env` beim Start über `sudo` |
| 3 | `~/.xalgorix.env` |
| 4 | Bereits im Prozess vorhandene Umgebungsvariablen |
Erstelle die lokale Umgebungsdatei:
```bash
nano ~/.xalgorix.env
```
### 🧩 Minimale Konfiguration
Für die stärksten autonomen Scan-Ergebnisse wählen Sie ein aktuelles Frontier-Modell. Die untenstehende Modell-ID ist ein konkretes Beispiel; neuere kompatible Modell-IDs können eingegeben werden, ohne auf ein Xalgorix-Release zu warten.
```bash
XALGORIX_LLM=openai/gpt-5.6
XALGORIX_API_KEY=your_openai_api_key
```
### 🔌 Provider-Beispiele
OpenAI:
```bash
XALGORIX_LLM=openai/gpt-5.6
XALGORIX_API_KEY=sk-...
```
Benutzerdefinierter OpenAI-kompatibler Anbieter:
```bash
XALGORIX_LLM=custom/security-model
XALGORIX_API_BASE=https://your-provider.example/v1
XALGORIX_API_KEY=your_provider_api_key
```
#### 🌉 LiteLLM / OpenAI-kompatible Gateways (GitHub Copilot, Claude Opus, Codex, OpenRouter, Azure, lokale Modelle)
Da `XALGORIX_API_BASE` jeden OpenAI-kompatiblen `/v1/chat/completions`-Endpunkt akzeptiert,
funktioniert Xalgorix ohne Weiteres mit einem [LiteLLM](https://docs.litellm.ai/)-Proxy — es
sind keine Änderungen auf Xalgorix-Seite erforderlich. LiteLLM übernimmt die Authentifizierung
beim Upstream-Anbieter (Copilot-Geräte-Login, Azure-Schlüssel, OpenRouter, Ollama usw.);
Xalgorix spricht einfach OpenAI mit dem Gateway.
LiteLLM ausführen (Beispiel `config.yaml`):
```yaml
model_list:
- model_name: claude-opus-5
litellm_params:
model: github_copilot/claude-opus-5 # or openrouter/…, azure/…, ollama/…
general_settings:
master_key: sk-local-litellm-key
```
Richte Xalgorix darauf aus — verwende das Präfix `custom/`, damit der Modellname wörtlich übermittelt wird und das OpenAI-Chat-Completions-Protokoll verwendet wird:
```bash
XALGORIX_LLM=custom/claude-opus-5 # the LiteLLM model_name
XALGORIX_API_BASE=http://localhost:4000/v1 # your LiteLLM proxy
XALGORIX_API_KEY=sk-local-litellm-key # LiteLLM master_key / virtual key
```
Das gleiche Muster deckt GitHub Copilot Business/CLI, Claude Opus, Codex-artige Modelle,
OpenRouter, Azure OpenAI und lokale Ollama-Modelle ab — alles, was LiteLLM routen kann. Behalte
das Präfix `custom/` (oder `openai/`) und eine Nicht-Anthropic/Gemini-`XALGORIX_API_BASE` bei, damit Xalgorix
die standardmäßige OpenAI-Anfrageform verwendet, die LiteLLM erwartet.
### 🔔 Optionale Integrationen
```bash
GEMINI_API_KEY=AIza...
AGENTMAIL_POD=am_us_pod_47
AGENTMAIL_API_KEY=ak_...
XALGORIX_DISCORD_WEBHOOK=https://discord.com/api/webhooks/...
XALGORIX_DISCORD_MIN_SEVERITY=high
```
### 🔐 Dashboard-Authentifizierung
```bash
XALGORIX_USERNAME=admin
XALGORIX_PASSWORD=change-this-password
```
> [!TIP]
> Bevorzuge `XALGORIX_PASSWORD_HASH` für Produktions-Deployments.
## 🆙 Upgrade von früheren Versionen
Dieses Release enthält einen Stabilitäts- und Workspace-Isolations-Durchlauf mit einer Breaking Change und einigen neuen Einstellungen, die es zu kennen gilt.
### 💥 Breaking Change: Standard-Workspace verschoben nach `~/.xalgorix/data/`
Scan-Ausgaben, Notizen, Zeitpläne und andere generierte Artefakte liegen jetzt unter `~/.xalgorix/data/` statt unter `$CWD` (das Verzeichnis, aus dem die Binary gestartet wurde).
Um das vorherige Verhalten beizubehalten, richte `XALGORIX_DATA_DIR` auf dein aktuelles Arbeitsverzeichnis aus:
```bash
export XALGORIX_DATA_DIR=$(pwd)
```
Eine `[MIGRATION]`-Warnung wird beim Start ausgegeben, wenn Legacy-Marker (`notes.json`, `_schedules/`, `vulnerabilities.json` oder `YYYY-MM-DD/scan-*`-Verzeichnisse) in `$CWD` erkannt werden und `XALGORIX_DATA_DIR` nicht gesetzt ist. Xalgorix liest, kopiert oder löscht diese Legacy-Dateien niemals automatisch; die Warnung ist informativ und wird nur einmal pro Prozess ausgegeben.
### 🆕 Neue Umgebungsvariable
| Variable | Standardwert | Beschreibung |
| ---------------------------- | ----------------------------- | -------------------------------------------------------------------------------------------------------- |
| `XALGORIX_LLM_MAX_INFLIGHT` | `4 × EffectiveMaxInstances` | Begrenzt gleichzeitige ausgehende LLM-Aufrufe über alle laufenden Scans hinweg. Minimum `1`. Abgebrochene Wartende verbrauchen keinen Slot. |
### 🩺 Neue Health-Endpoint-Zähler
`GET /api/status` stellt nun bereit:
| Feld | Bedeutung |
| --------------------- | ------------------------------------------------------------------------------------ |
| `panics_recovered` | Goroutine-, HTTP-Handler- und Tool-Panics, die ohne Absturz abgefangen wurden. |
| `path_rejections` | Dateisystem-Schreibvorgänge, die von der Path_Policy abgelehnt wurden (außerhalb von `data_dir` / `~/.xalgorix/` / `/tmp`). |
| `watchdog_kills` | Subprozesse, die durch den Hard-Timeout-Watchdog pro Tool beendet wurden. |
| `admission_refusals` | Scan-Admission-Anfragen, die aufgrund der Nebenläufigkeitsobergrenze abgelehnt wurden. |
| `llm_inflight_cap` | Effektiver `XALGORIX_LLM_MAX_INFLIGHT`-Wert für diesen Prozess. |
| `data_dir` | Aufgelöstes Data_Dir, das verwendet wird. |
| `allow_list` | Dateisystem-Wurzeln, die von der Path_Policy akzeptiert werden. |
## 🏃 Ausführung
### 🪟 Web-UI
```bash
xalgorix --web
```
Öffnen:
```text
http://127.0.0.1:9137
```
Verwenden Sie einen anderen Port:
```bash
xalgorix --web --port 8080
```
### 🌐 Externer Zugriff
Binden Sie nur dann an eine andere Schnittstelle, nachdem Sie die Dashboard-Authentifizierung aktiviert haben:
```bash
XALGORIX_USERNAME=admin XALGORIX_PASSWORD=change-this xalgorix --web --bind 0.0.0.0
```
> [!WARNING]
> Der Server verweigert externes Binding ohne Dashboard-Authentifizierung.
### 🏹 CLI-Scan
```bash
xalgorix --target https://example.com
```
Mit benutzerdefinierten Anweisungen:
```bash
xalgorix --target https://app.example.com --instruction "Focus on SQL injection, IDOR, and auth bypass. Avoid destructive tests."
```
## 🧰 Service-Modus
Als Systemdienst installieren und starten:
```bash
sudo xalgorix --start
```
Dienst verwalten:
```bash
sudo xalgorix --restart
sudo xalgorix --stop
sudo xalgorix --uninstall
```
Logs anzeigen:
```bash
journalctl -u xalgorix -f
```
Für eine stille Erkennung oder einen pausierten Scan siehe [Diagnose von Scan-Wartezeiten](https://github.com/xalgord/xalgorix/blob/main/docs/SCAN_WAITS.md).
### 🌍 Remote-Dienstzugriff
Stellen Sie den Dienst nur dann für entfernte Browser bereit, nachdem Sie die Dashboard-Authentifizierung aktiviert haben:
```bash
sudo tee -a /root/.xalgorix.env >/dev/null <<'EOF'
XALGORIX_BIND=0.0.0.0
XALGORIX_USERNAME=admin
XALGORIX_PASSWORD=change-this
EOF
sudo xalgorix --restart
```
Dann öffne `http://<server-ip>:9137`.
Wenn der Prozess lauscht, aber die Seite trotzdem nicht remote geladen wird, erlaube TCP-Port `9137` in der Server-Firewall oder der Cloud-Sicherheitsgruppe.
#### 🏠 Scannen lokaler/interner Ziele
Standardmäßig verweigert Xalgorix das Scannen von Loopback-, `localhost`-, Private-Range- oder eigenen Interface-Adressen — sie sind der Rechner, auf dem Xalgorix läuft, kein Ziel. Auf einer **selbst gehosteten, Single-Tenant**-Maschine kannst du dich dafür entscheiden, eine lokal gehostete Demo-/Staging-App zu scannen:
```bash
echo 'XALGORIX_ALLOW_LOCAL_TARGETS=true' | sudo tee -a /root/.xalgorix.env
sudo xalgorix --restart
```
Der eigene Listener des Dashboards ist **immer** geschützt, auch wenn dies aktiviert ist.
> **⚠️ Shared-/Multi-Tenant-/Hosted-Deployments: lassen Sie dies AUS.** Wenn Sie es aktivieren,
> könnte der Scan eines Benutzers den eigenen Rechner des Betreibers und das interne Netzwerk erreichen.
> Es ist standardmäßig deaktiviert, es sind also keine Maßnahmen erforderlich, um sicher zu bleiben — setzen Sie
> `XALGORIX_ALLOW_LOCAL_TARGETS` nicht (oder pinnen Sie `XALGORIX_ALLOW_LOCAL_TARGETS=false`),
> und stellen Sie die Settings-Seite der Engine nicht für nicht vertrauenswürdige Benutzer bereit.
## 🔁 Web-UI-Workflow
1. Öffnen Sie das Dashboard unter `http://127.0.0.1:9137`.
2. Gehen Sie zu Settings und bestätigen Sie den LLM-Anbieter, den API-Schlüssel, die Rate Limits und optionale Integrationen.
3. Erstellen Sie einen Scan über New Scan.
4. Wählen Sie einen Scan-Modus.
5. Wählen Sie Methodik-Phasen aus, wenn Sie einen fokussierten Durchlauf wünschen.
6. Legen Sie Severity-Filter fest, wenn nur bestimmte Schweregrade live gemeldet werden sollen. Der Filter wirkt sich nur auf den Echtzeit-Dashboard-Feed und die Benachrichtigungen aus; der PDF-Bericht und `/api/findings` enthalten immer jede vom Agenten entdeckte Schwachstelle.
7. Fügen Sie den Firmennamen hinzu und laden Sie ein Logo für gebrandete Berichte hoch.
8. Überwachen Sie den Fortschritt über Overview, Scan Detail oder Live Feed.
9. Öffnen Sie Finding-Details, laden Sie Berichte herunter oder verwalten Sie historische Scans über Scans und Reports.
## 🔀 Scan-Modi
| Modus | Am besten geeignet |
| ---------------- | ------------------------------------------------------------------------------- |
| 🎯 Einzelnes Ziel | Testen einer bekannten URL oder eines Hosts. |
| 🌐 Wildcard / Multi | Aufzählen verwandter Ziele und Scannen der entdeckten Angriffsfläche. |
| 🧭 DAST | Browserunterstütztes Testen für Web-Apps, Auth-Flows, Formulare und Laufzeitverhalten. |
## 📂 Scannen Sie Ihren Code (kein Ziel erforderlich)
Richten Sie Xalgorix auf eine Codebasis — eine Git-URL, einen lokalen Pfad oder eine hochgeladene Zip-Datei — und
es scannt die Quelle direkt. Keine bereitgestellte URL, keine Infrastruktur, die aufgebaut werden muss.
```bash
# Source review (SAST): audit the code, no running target required
xalgorix --source ./my-app --code-scan review
# Provision + DAST: build & run the app locally, then pentest the running instance
xalgorix --source https://github.com/org/app.git --code-scan provision
```
| Code-Scan-Modus | Was er tut | Verifizierungsstufe |
| -------------- | ------------ | ------------------ |
| `review` | Liest den Quellcode, verfolgt Benutzereingaben vom Einstiegspunkt → gefährliche Senke und meldet erreichbare Schwachstellen. Kein Live-Ziel. | **Quellcode-verifiziert** — im Code als erreichbar nachgewiesen (klar gekennzeichnet als nicht zur Laufzeit ausgenutzt). |
| `provision` | Untersucht das Repo, baut und startet die App auf einem Loopback-Port und führt dann whitebox-gesteuertes DAST gegen die laufende Instanz aus. Fällt auf `review` zurück, wenn die App nicht gebaut werden kann. | **Exploit-verifiziert** — gegen die laufende App reproduziert. |
- `--source` akzeptiert eine Git-URL (shallow-geklont), ein lokales Verzeichnis oder einen Pfad zu
einem hochgeladenen/entpackten Archiv. In der Web-UI / gehosteten App kannst du auch ein
`.zip` deiner Codebasis hochladen (`POST /api/upload-source`).
- Du kannst weiterhin ein Repo **und** ein Live-Ziel für klassische Whitebox-
Augmentierung kombinieren — dieser Pfad ist unverändert. Code-Scan-Modi sind für Fälle, in denen
die Codebasis das gesamte Untersuchungsobjekt ist.
> Der Provision-Modus führt die Build-/Start-Befehle deiner App in der Sandbox des Agenten aus und
> pentestet nur den einzelnen Loopback-Port, auf dem er die App gestartet hat — das Dashboard
> und alles andere auf der Maschine bleiben außerhalb des Geltungsbereichs.
## 🧭 Methodik
Xalgorix organisiert autonomes Testen in 22 Phasen.
| Phase | Fokus |
| ----: | ------------------------------------------ |
| 1 | Reconnaissance |
| 2 | Manuelle Schwachstellensuche |
| 3 | Verzeichnis- und Dateisuche |
| 4 | CORS- und Cookie-Analyse |
| 5 | Authentifizierungs- und Session-Tests |
| 6 | Injection-Tests |
| 7 | SSRF-Tests |
| 8 | IDOR und fehlerhafte Zugriffskontrolle |
| 9 | API- und GraphQL-Tests |
| 10 | Datei-Upload-Tests |
| 11 | Deserialisierung und RCE |
| 12 | Race Conditions und Geschäftslogik |
| 13 | Subdomain-Übernahme |
| 14 | Open-Redirect-Tests |
| 15 | E-Mail-Sicherheitstests |
| 16 | Cloud und Infrastruktur |
| 17 | WebSocket-Tests |
| 18 | CMS-spezifische Tests |
| 19 | Broken-Link-Hijacking und Content-Spoofing |
| 20 | Exploit-Verifizierung |
| 21 | Entdeckung neuartiger Schwachstellen |
| 22 | Abschlussbericht |
Die Phasenauswahl in der Web-UI ermöglicht es dir, jede Phase oder nur die für ein bestimmtes Engagement benötigte Teilmenge auszuführen.
## 📄 Berichte
Berichte werden als PDF-Dateien generiert und können Folgendes enthalten:
| Abschnitt | Enthaltener Inhalt |
| ----------- | ------------------------------------------------------------------------------- |
| 📌 Zusammenfassung | Management Summary, Ziel-Metadaten, Scan-Metadaten und Schweregrad-Übersicht. |
| 🐞 Befunde | Verifizierte Befunde, CVSS-Details, technische Analyse und Exploit-Nachweis. |
| 🔬 Beweise | Proof-of-Concept-Befehle, Skripte, Payload-Notizen und unterstützende Beobachtungen. |
| 🩹 Behebung | Korrekturhinweise und priorisierte nächste Schritte. |
| 🎨 Branding | Firmen-/Zielname und hochgeladenes Logo. |
Berichte sind auf der Scan-Detailseite und der Berichte-Seite verfügbar. Berichtszeilen unterstützen Öffnen, Herunterladen und Löschen.
## 🔧 Einstellungen
Die meisten betrieblichen Einstellungen können in der Web-UI unter Einstellungen geändert werden.
| Bereich | Beispiele |
| ------------- | ------------------------------------------------------------------- |
| 🤝 Engagement | Dashboard-Anfrage-Ratenlimits |
| 🧠 LLM | Modell, API-Schlüssel, API-Basis, Reasoning-Aufwand, Wiederholungen, maximale Iterationen |
| 📬 AgentMail | Pod und API-Schlüssel |
| 🔔 Benachrichtigungen | Discord-Webhook und Mindestschweregrad, Telegram-Bot-Token, Chat-ID, Mindestschweregrad und Opt-in-Zusammenfassungen bei Scan-Abschluss |
| 🕵️ Proxy | Proxy-URL, Proxy-Datei, Rotation, TLS-Verifizierung |
| 🧱 Laufzeit | Workspace, Browser-Pfad, Auto-Install-Steuerung |
| 🔐 Sicherheit | Dashboard-Benutzername, Passwort, Passwort-Hash, Bind-Adresse |
| 📈 Ressourcen | CPU/RAM/Disk-Schwellenwerte und Scan-Nebenläufigkeitsbudget |
Einige Einstellungen erfordern einen Neustart, da sie den Prozessstart oder die Server-Bindung beeinflussen. Die UI markiert diese Felder.
## 🧾 Umgebungsvariablen
### 🧱 Kern
| Variable | Standard | Beschreibung |
| ------------------------------------ | ---------------- | ------------------------------------------------------ |
| `XALGORIX_LLM` | keine | Anbieter-native Modell-ID für LLM-Anfragen. |
| `XALGORIX_LLM_PROVIDER` | keine | Vom Dashboard ausgewählter Anbieter, getrennt von der Modell-ID gespeichert. |
| `XALGORIX_API_KEY` | keine | Erforderlicher API-Schlüssel des LLM-Anbieters. |
| `XALGORIX_API_BASE` | Anbieter-Standard | Benutzerdefinierte OpenAI-kompatible API-Basis-URL. |
| `XALGORIX_REASONING_EFFORT` | `high` | Reasoning-Aufwand: `none`, `low`, `medium`, `high` oder `xhigh` (`xhigh` wird für Ollama auf `high` abgebildet). |
| `XALGORIX_LANGUAGE` | `en` | Ausgabesprache für KI-generierte Prosa (Agenten-Reasoning, Notizen, Befunde, Berichtsinhalt, Post-Scan-Chat). `en` oder `zh-CN`. Technische Tokens (Payloads, Befehle, URLs, CVE/CWE-IDs) bleiben immer in ihrer ursprünglichen Form. Nicht-lateinische Sprachen werden im Dashboard und HTML-Bericht automatisch gerendert. |
| `XALGORIX_PDF_CJK_FONT` | keine | Absoluter Pfad zu einer TrueType-Schriftart (`.ttf`) mit CJK-Glyphen, die zum Rendern nicht-lateinischer Sprachen (z. B. vereinfachtes Chinesisch) im exportierten **PDF**-Bericht verwendet wird. Nur `.ttf` wird unterstützt (nicht `.ttc`/`.otf`). Ohne sie fällt das PDF auf Kernschriftarten zurück und nicht-lateinische Glyphen werden nicht gerendert (der HTML-Bericht ist nicht betroffen). |
| `XALGORIX_OLLAMA_COMPATIBLE` | `false` | Wendet Ollama-Reasoning-Semantik auf einen benutzerdefinierten Endpunkt auf einem nicht-standardmäßigen Port an. Port `11434` wird automatisch erkannt. |
| `XALGORIX_LLM_MAX_RETRIES` | `5` | Wiederholungsanzahl für vorübergehende LLM-Fehler. |
| `XALGORIX_MEMORY_COMPRESSOR_TIMEOUT` | `30` | Timeout in Sekunden für die Kontextkomprimierung. |
| `XALGORIX_MAX_ITERATIONS` | `0` | Iterationsobergrenze des Agenten. `0` bedeutet unbegrenzt. |
| `XALGORIX_PPROF_ADDR` | keine | Opt-in-Go-Profiler. Wenn gesetzt (z. B. `127.0.0.1:6060`), startet er einen eigenständigen pprof-Server unter `/debug/pprof/` auf dieser Adresse für CPU-/Heap-Diagnose. Standardmäßig deaktiviert. Legt Prozessinterna offen — binde an Loopback und erreiche ihn über einen SSH-Tunnel; niemals öffentlich exponieren. |
| `GEMINI_API_KEY` | keine | Optionaler Gemini-Schlüssel für Web-Search-Anreicherung. |
### 🔒 Web und Sicherheit
| Variable | Standard | Beschreibung |
| ------------------------ | ----------------- | ---------------------------------- |
| `XALGORIX_BIND` | `127.0.0.1` | Listen-Adresse des Webservers. |
| `XALGORIX_ALLOW_LOCAL_TARGETS` | `false` | Erlaubt das Scannen lokal gehosteter Apps (localhost / 127.0.0.1 / private IPs) bei einer selbst gehosteten Installation. Der eigene Listener des Dashboards ist immer geschützt. Bei geteilten/gehosteten Deployments deaktiviert lassen. |
| `XALGORIX_DISABLE_AUTO_DELEGATE` | `false` | Überspringt die Spezialisten-Welle vollständig. Der Root-Agent führt alle Tests selbst durch (tiefer, langsamer). |
| `XALGORIX_CHECKLIST` | `full` | Methodik-Tiefe: `full` (umfassende 22-Phasen, Standard) oder `professional` (kompakt). Die vollständige Checkliste findet deutlich mehr Schwachstellen. |
| `XALGORIX_USERNAME` | keine | Dashboard-Benutzername. |
| `XALGORIX_PASSWORD` | keine | Dashboard-Passwort. |
| `XALGORIX_PASSWORD_HASH` | keine | Bevorzugter bcrypt-Passwort-Hash. |
| `XALGORIX_WORKSPACE` | aktuelles Verzeichnis | Workspace-Wurzel für die Scan-Ausführung. |
### 🤝 Integrationen
| Variable | Standard | Beschreibung |
| ------------------------------- | ------- | ---------------------------------------- |
| `AGENTMAIL_POD` | keine | AgentMail-Pod-Identifikator. |
| `AGENTMAIL_API_KEY` | keine | AgentMail-API-Schlüssel. |
| `XALGORIX_DISCORD_WEBHOOK` | keine | Globaler Discord-Webhook. |
| `XALGORIX_DISCORD_MIN_SEVERITY` | keine | Mindestschweregrad, der an Discord gesendet wird. |
| `XALGORIX_TELEGRAM_BOT_TOKEN` | keine | Telegram-Bot-Token von @BotFather. |
| `XALGORIX_TELEGRAM_CHAT_ID` | keine | Telegram-Chat-/Kanal-ID (numerisch oder @username). |
| `XALGORIX_TELEGRAM_MIN_SEVERITY`| keine | Mindestschweregrad, der an Telegram gesendet wird. |
| `XALGORIX_NOTIFY_SCAN_COMPLETE` | `false` | Sendet Zusammenfassungen am Scan-Ende an konfigurierte Discord-/Telegram-Ziele. Dies ist Opt-in und beeinflusst keine Warnungen pro Schwachstelle. |
| `CAIDO_PORT` | `0` | Caido-Proxy-Port. `0` bedeutet automatische Erkennung. |
| `CAIDO_API_TOKEN` | keine | Caido-API-Token. |
### 🚦 Ratenlimits, Proxy und Laufzeit
| Variable | Standard | Beschreibung |
| ------------------------------ | ------------ | -------------------------------------------------- |
| `XALGORIX_RATE_LIMIT_REQUESTS` | `60` | Dashboard-Anfragen pro Fenster. |
| `XALGORIX_RATE_LIMIT_WINDOW` | `60` | Dashboard-Ratenlimit-Fenster in Sekunden. |
| `XALGORIX_RATE_RPS` | `10` | Anhaltende ausgehende Anfragrate. |
| `XALGORIX_RATE_BURST` | `20` | Ausgehende Burst-Größe. |
| `XALGORIX_USE_PROXY` | `false` | Proxy-Routing aktivieren. |
| `XALGORIX_PROXY_REQUIRED` | `false` | Erfordert einen Upstream-Proxy für Ziel-HTTP-/Browser-Pfade ohne direkten Fallback. |
| `XALGORIX_PROXY_URL` | keine | Einzelne Proxy-URL. Überschreibt Proxy-Datei. |
| `XALGORIX_PROXY_FILE` | keine | Datei mit einem Proxy pro Zeile. |
| `XALGORIX_PROXY_ROTATION` | `roundrobin` | Proxy-Rotationsstrategie: `roundrobin` oder `random`. |
| `XALGORIX_TLS_SKIP_VERIFY` | `false` | TLS-Verifizierung für Testverkehr überspringen. |
| `XALGORIX_DISABLE_BROWSER` | `false` | Browser-Automatisierung deaktivieren. |
| `XALGORIX_BROWSER_PATH` | auto | Benutzerdefinierter Chrome/Chromium-Ausführungspfad. |
| `XALGORIX_ALLOW_AUTO_INSTALL` | nur root | Automatische Paketinstallation erlauben. |
| `XALGORIX_AUTO_INSTALL_SUDO` | `false` | Sudo-präfixierte Auto-Installationen erlauben. |
## 🔤 Anbieter-Präfixe
Wenn `XALGORIX_API_BASE` leer ist, leitet Xalgorix Anbieter-Standardwerte aus dem Modellpräfix ab.
| Präfix | Standard-API-Basis |
| ------------ | ---------------------------------------------- |
| `openai/` | `https://api.openai.com/v1` |
| `anthropic/` | `https://api.anthropic.com` |
| `deepseek/` | `https://api.deepseek.com/v1` |
| `groq/` | `https://api.groq.com/openai/v1` |
| `google/` | `https://generativelanguage.googleapis.com/v1` |
| `gemini/` | `https://generativelanguage.googleapis.com/v1` |
| `ollama/` | `http://localhost:11434/v1` |
| `minimax/` | `https://api.minimax.io/v1` |
Modellnamen sind nicht auf diese Liste fest codiert. Die Einstellungsseite akzeptiert eingegebene Modell-IDs, sodass neuere Anbietermodelle verwendet werden können, ohne auf ein UI-Dropdown-Update zu warten.
## 💻 CLI-Referenz
| Flag | Alias | Beschreibung |
| ---------------------- | ----- | ------------------------------------------ |
| `--web` | `-w` | Startet die Web-UI. |
| `--port <port>` | `-p` | Web-UI-Port. Standard: `9137`. |
| `--bind <addr>` | keine | Bind-Adresse. Standard: `127.0.0.1`. |
| `--target <target>` | `-t` | Ziel-URL, Host, IP oder Pfad. Wiederholbar. |
| `--instruction <text>` | `-i` | Benutzerdefinierte Scan-Anweisungen. |
| `--model <model>` | `-m` | Überschreibt `XALGORIX_LLM` für diesen Lauf. |
| `--update` | `-up` | Aktualisiert auf die neueste Version. |
| `--version` | `-v` | Gibt die Version aus. |
| `--start` | keine | Installiert und startet den Systemdienst. |
| `--stop` | keine | Stoppt den Systemdienst. |
| `--restart` | keine | Startet den Systemdienst neu. |
| `--uninstall` | keine | Entfernt den Systemdienst. |
| `--help` | `-h` | Zeigt Hilfe an. |
## 📡 API-Übersicht
| Methode | Endpunkt | Zweck |
| -------- | ---------------------------- | --------------------------------------------- |
| `POST` | `/api/scan` | Startet oder speichert einen Scan. |
| `POST` | `/api/stop` | Stoppt alle laufenden Scans. |
| `GET` | `/api/status` | Aktueller globaler Status. |
| `GET` | `/api/scans` | Listet Scans auf. |
| `GET` | `/api/scans/:id` | Ruft Scan-Details ab. |
| `DELETE` | `/api/scans/:id` | Löscht einen Scan und seine Berichtsdaten. |
| `GET` | `/api/findings` | Listet alle Befunde auf (über Scans hinweg dedupliziert). |
| `GET` | `/api/findings/summary` | Schweregrad-Zählung über alle Scans. |
| `GET` | `/api/report/:id` | Lädt einen PDF-Bericht herunter. |
| `GET` | `/api/instances` | Listet Live- und historische Instanzen auf. |
| `GET` | `/api/instances/:id/events` | Ruft gepufferte Ereignishistorie ab. |
| `POST` | `/api/instances/:id/stop` | Stoppt eine bestimmte Instanz. |
| `POST` | `/api/instances/:id/start` | Startet einen gespeicherten oder abgeschlossenen Scan als neuen Lauf. |
| `POST` | `/api/instances/:id/restart` | Startet mit derselben Konfiguration neu. |
| `POST` | `/api/instances/:id/pause` | Pausiert einen laufenden Scan. |
| `POST` | `/api/instances/:id/resume` | Setzt einen pausierten Scan fort. |
| `POST` | `/api/upload-logo` | Lädt ein Berichtslogo hoch. |
| `POST` | `/api/upload-targets` | Lädt eine Zielliste hoch. |
| `GET` | `/api/settings/environment` | Listet bearbeitbare Umgebungseinstellungen auf. |
| `POST` | `/api/settings/environment` | Speichert Umgebungseinstellungen. |
| `GET` | `/api/settings/llm` | Ruft LLM-Einstellungen ab. |
| `POST` | `/api/settings/llm` | Speichert LLM-Einstellungen. |
| `GET` | `/api/settings/agentmail` | Ruft AgentMail-Einstellungen ab. |
| `POST` | `/api/settings/agentmail` | Speichert AgentMail-Einstellungen. |
| `GET` | `/ws` | WebSocket-Live-Ereignisstrom. |
## 💾 Datenspeicherung
Scan-Daten im Web-Modus werden gespeichert unter:
```text
~/xalgorix-data/
|-- _saved/
|-- logos/
|-- queue_state.json
`-- <target>/
`-- <date>/
`-- <scan-id>/
|-- scan.json
`-- report.pdf
```
Der Server speichert historische Scan-Datensätze auf der Festplatte, damit die UI nach einem Refresh oder Neustart wiederhergestellt werden kann.
Im Docker-Image und im Helm-Chart ist dieses Verzeichnis das `/data`-Volume (`XALGORIX_DATA_DIR=/data`), das in einem benannten Volume oder einem PVC persistiert wird.
## 🧪 Entwicklung
| Aufgabe | Befehl |
| --------------------------- | ----------------------------- |
| 📦 Web-UI-Abhängigkeiten installieren | `make webui-install` |
| 🔨 Alles bauen | `make build` |
| ✅ Tests ausführen | `go test ./...` |
| 🖥️ Web-UI aus dem Quellcode ausführen | `go run ./cmd/xalgorix --web` |
| ⚡ Frontend-Entwicklungsserver ausführen | `make webui-dev` |
## 🚨 Sicherheitshinweise
- Verwende Xalgorix nur gegen autorisierte Ziele.
- Führe keine aktiven Tests gegen Systeme Dritter ohne Genehmigung durch.
- Überprüfe die Scan-Anweisungen vor dem Start.
- Konfiguriere Ratenbegrenzungen und Proxy-Einstellungen entsprechend den Engagement-Regeln.
- Das externe Bereitstellen des Dashboards erfordert Authentifizierung.
- Die automatische Installation ist standardmäßig für Nicht-Root-Benutzer deaktiviert und sollte nur aktiviert werden, wenn du der Umgebung vertraust.
## 📜 Lizenz
Xalgorix wird unter der Apache License 2.0 veröffentlicht. Siehe [LICENSE](https://github.com/xalgord/xalgorix/blob/main/LICENSE).
## 🔗 Links
| Ressource | Link |
| ------------- | -------------------------------------------------------------------------------- |
| ☁️ Gehostet (Cloud) | [www.xalgorix.com](https://www.xalgorix.com/) |
| 📖 Dokumentation | [docs.xalgorix.com](https://docs.xalgorix.com) |
| 🐛 Issues | [github.com/xalgorix/xalgorix/issues](https://github.com/xalgorix/xalgorix/issues) |
| ☕ Unterstützung | [buymeacoffee.com/xalgord](https://buymeacoffee.com/xalgord) |