xalgorix v4.6.78
Agenti autonomi di pentesting AI — ricognizione in tempo reale, rilevamento delle vulnerabilità e orchestrazione dello sfruttamento. Go + TypeScript.
Xalgorix — Pentester AI open-source che dimostra le vulnerabilità
La maggior parte degli scanner rileva. Xalgorix dimostra. Un agente LLM autonomo segue una metodologia completa di pentest, poi un verificatore indipendente riesegue lo sfruttamento di ogni risultato prima che venga segnalato — così ottieni prove, non un mucchio di incertezze da analizzare. Self-hosted, privato e con il tuo LLM. Sviluppato in Go + TypeScript.
🚀 Avvio Rapido · 💡 Perché Xalgorix · ✨ Funzionalità · 🎯 Casi d'Uso · ☁️ Cloud Ospitato · 📖 Documentazione
📸 Screenshot
🖥️ Dashboard self-hosted — viene eseguita localmente su 127.0.0.1:9137
| Dashboard panoramica | Dettaglio scansione | Risultati |
|---|---|---|
 |  |  |
☁️ Dashboard cloud ospitata — la versione completamente gestita su www.xalgorix.com
🚀 Avvio Rapido
Installazione (una riga):```bash curl -sSL https://www.xalgorix.com/install | bash
Questo scarica il binario precompilato per la tua piattaforma (Linux o macOS, amd64/arm64) dall'ultima release. Poi esegui la procedura guidata di configurazione interattiva:```bash
xalgorix --setup
Scegli il tuo provider, conferma un modello e inserisci la chiave API quando richiesto. Per ottenere i migliori risultati, utilizza un modello frontier attuale con solide capacità di ragionamento, prestazioni su contesti lunghi e chiamata affidabile degli strumenti—come l'ultimo modello GPT, Claude o Gemini capace disponibile. I modelli più piccoli o locali rimangono supportati, ma potrebbero richiedere maggiore supervisione durante le scansioni autonome prolungate. Xalgorix memorizza la chiave privatamente in ~/.xalgorix.env (modalità 0600) e può avviare la dashboard per te. Ollama locale non necessita di chiave API.
Se scegli di non avviare immediatamente, avvia in seguito con xalgorix --web e apri http://127.0.0.1:9137. Puoi cambiare provider o opzioni avanzate in qualsiasi momento in Settings → LLM, oppure rieseguire xalgorix --setup.
Oppure esegui con Docker — tutto incluso, nessun toolchain necessario:```bash
docker run --rm -p 9137:9137
--privileged
-v xalgorix-data:/data
xalgord/xalgorix:latest
`--privileged` fornisce al toolset lo stesso accesso simile all'host che ha quando viene eseguito nativamente come root. La sandbox predefinita di Docker rimuove le capability (come `NET_ADMIN`) e applica un filtro seccomp, il che rompe gli strumenti di basso livello (modifiche iptables/route, ARP-spoof/MITM, VPN tun/tap, debugger basati su ptrace, tuning dell'interfaccia masscan). Poiché un'immagine non può concedersi queste cose da sola, devono essere impostate in fase di esecuzione. Il container è una sandbox di scansione usa e getta, isolata dalla rete, in esecuzione come root — privileged è la postura prevista; non esporre mai la dashboard pubblicamente senza autenticazione. Preferisci il privilegio minimo? Sostituisci `--privileged` con `--cap-add=NET_ADMIN --cap-add=NET_RAW --cap-add=SYS_PTRACE --security-opt seccomp=unconfined`.
Apri `http://localhost:9137`. **Non hai bisogno di una chiave LLM per iniziare** — la dashboard si avvia senza; imposta il modello + la chiave API in **Settings → LLM** (persiste nel volume `/data`). Se non passi `XALGORIX_USERNAME`/`XALGORIX_PASSWORD`, viene generata una password admin casuale e stampata nei log del container al primo avvio.
**Il modo più semplice — Docker Compose** (mappa la porta + un volume persistente per te):```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
L'immagine include un ampio set di strumenti di offensive-security preinstallati (nmap, nuclei, httpx, subfinder, katana, ffuf, gobuster, sqlmap, masscan, dalfox, feroxbuster e altri) e mantiene disponibili tutti i package manager (apt, go, cargo, pipx, npm) in modo che l'agente possa comunque installare automaticamente qualsiasi cosa manchi a runtime. Viene eseguita come root all'interno del container per scelta progettuale — considera il container come una sandbox di scansione usa-e-getta e isolata dalla rete e non esporre mai la dashboard senza autenticazione. Le immagini sono pubblicate sia per amd64 che per arm64.
Oppure compila dal sorgente (richiede Go 1.26+ e 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]
> Preferisci zero configurazione? Una versione completamente gestita è disponibile su [www.xalgorix.com](https://www.xalgorix.com/) — click-to-scan, nessuna installazione o chiave API richiesta.
### 🤖 Revisiona automaticamente le pull request — GitHub App gratuita
Vuoi una revisione di sicurezza su ogni pull request senza alcuna configurazione? Installa la **[Xalgorix GitHub App](https://github.com/apps/xalgorix)**. Legge il diff di ogni PR e commenta una revisione di sicurezza — injection, autenticazione compromessa/IDOR, SSRF, segreti, pattern non sicuri — direttamente sulla pull request. Si aggiorna sul posto con i nuovi commit, e puoi commentare **`@xalgorix review`** per rieseguire su richiesta. Nessun file di workflow, nessuna chiave API, nessun account — ed è gratuita.
<div align="center">
[**➕ Aggiungi Xalgorix a GitHub →**](https://github.com/apps/xalgorix/installations/new)
</div>
Per il merge gating e pentest completi con exploit verificati in CI, usa lo [scanner hosted](https://www.xalgorix.com/) o la GitHub Action.
> [!IMPORTANT]
> Usa Xalgorix solo su sistemi di tua proprietà o per cui hai esplicita autorizzazione al test.
> [!TIP]
> Preferisci non ospitarlo autonomamente? Una versione completamente gestita è disponibile su [www.xalgorix.com](https://www.xalgorix.com/) — click-to-scan, nessuna installazione o chiave API richiesta.
## 📚 Indice
| | | |
| --- | --- | --- |
| 📸 [Screenshot](#-screenshots) | 🔩 [Configurazione](#-configuration) | 🧾 [Variabili d'ambiente](#-environment-variables) |
| 🚀 [Avvio rapido](#-quick-start) | 🆙 [Aggiornamento](#-upgrading-from-previous-versions) | 🔤 [Prefissi dei provider](#-provider-prefixes) |
| 🔎 [Panoramica](#-overview) | 🏃 [Esecuzione](#-running) | 💻 [Riferimento CLI](#-cli-reference) |
| 💡 [Perché Xalgorix](#-why-xalgorix) | 🧰 [Modalità servizio](#-service-mode) | 📡 [Riepilogo API](#-api-summary) |
| 🎯 [Casi d'uso](#-use-cases) | 🔁 [Flusso di lavoro Web UI](#-web-ui-workflow) | 💾 [Archiviazione dati](#-data-storage) |
| ✨ [Funzionalità](#-features) | 🔀 [Modalità di scansione](#-scan-modes) | 🧪 [Sviluppo](#-development) |
| 📥 [Installazione](#-installation) | 📂 [Scansiona il tuo codice](#-scan-your-code-no-target-needed) | 🚨 [Note di sicurezza](#-safety-notes) |
| 🧭 [Metodologia](#-methodology) | 📄 [Report](#-reports) | 📜 [Licenza](#-license) |
| 🔧 [Impostazioni](#-settings) | 🔗 [Link](#-links) | |
## 🔎 Panoramica
Xalgorix è una piattaforma self-hosted di AI penetration testing per test di sicurezza autorizzati, valutazione delle vulnerabilità e flussi di lavoro di bug bounty. Combina un agente autonomo guidato da LLM, automazione del browser, strumenti da terminale, una metodologia di test completa in 22 fasi, telemetria WebSocket in tempo reale, gestione dei finding con scoring CVSS, generazione di report PDF brandizzati e integrazioni per AgentMail, Discord e Telegram.
A differenza degli scanner DAST solo cloud, Xalgorix viene eseguito interamente sulla tua macchina. Porti il tuo provider LLM (OpenAI, Anthropic, DeepSeek, Gemini, Groq, Ollama, MiniMax) e controlli il modello, lo sforzo di ragionamento, i limiti di velocità e la configurazione del proxy. Nessun dato di scansione, chiave API o informazione sul target lascia la tua infrastruttura.
L'esperienza predefinita è la Web UI. Da un'unica dashboard locale puoi avviare scansioni, monitorare le esecuzioni attive, ispezionare i finding, configurare le impostazioni di modello/provider, gestire le variabili d'ambiente, generare report PDF brandizzati ed eliminare o riprendere scansioni storiche.
## 💡 Perché Xalgorix
La maggior parte degli scanner **rileva**. Xalgorix **dimostra**. Un agente autonomo lavora attraverso una metodologia in 22 fasi, poi un verificatore indipendente ritesta ogni finding candidato prima che venga segnalato — così ottieni risultati con exploit verificati e prove, non un muro di "forse" da triage.
- 🧠 **Un agente AI, non un motore di template** — ragiona su flussi di autenticazione, logica di business, IDOR/BOLA ed exploit concatenati che gli scanner a firma non vedono.
- ✅ **Finding con exploit verificati** — un verificatore separato riproduce indipendentemente ogni finding; quelli inconcludenti vengono segnalati per revisione, mai spacciati per confermati.
- 🔒 **Self-hosted e privato** — viene eseguito sulla tua macchina con la tua chiave LLM; nessun dato del target, chiave o finding lascia la tua infrastruttura.
- 🧩 **Porta il tuo LLM** — OpenAI, Anthropic, DeepSeek, Gemini, Groq, Ollama o MiniMax — o qualsiasi gateway compatibile OpenAI come [LiteLLM](#-litellm--openai-compatible-gateways-github-copilot-claude-opus-codex-openrouter-azure-local-models) (GitHub Copilot, Codex, OpenRouter, Azure). Controlli modello, sforzo di ragionamento e costo.
- 📄 **Report pronti per l'audit** — PDF brandizzati con punteggi CVSS, proof-of-concept e remediation.
### 📊 Come si confronta
| | **Xalgorix** | Scanner a template (es. Nuclei) | Scanner con crawling (es. OWASP ZAP) | DAST commerciale |
| -------------------------------------------- | ------------------------ | ------------------------------- | ---------------------------------- | ---------------------- |
| Approccio | Agente AI autonomo | Firme / template | Spider + regole attive | Firme + euristiche |
| Copertura logica di business / IDOR / auth-bypass | ✅ | Limitata | Limitata | Parziale |
| Exploit verificato (dimostra l'impatto) | ✅ verificatore indipendente | ❌ | ❌ | Parziale |
| Carico di falsi positivi | Basso (dimostrato) | Dipendente dal template | Alto | Medio |
| Self-hosted / dati restano locali | ✅ | ✅ | ✅ | Di solito cloud |
| Bring-your-own LLM | ✅ | — | — | ❌ |
| Report PDF brandizzati | ✅ | ❌ | Base | ✅ |
| Costo | Open source + il tuo LLM | Gratuito | Gratuito | $$$ |
> Confronto indicativo — Nuclei e ZAP sono eccellenti in ciò che fanno. Xalgorix aggiunge il livello di scoperta ad alto ragionamento e verifica degli exploit.
### ☁️ Self-hosted vs Cloud hosted
Xalgorix è gratuito e open source — ospitalo autonomamente per sempre, senza vincoli. Il [cloud hosted](https://www.xalgorix.com/) esegue lo **stesso** motore con exploit verificati; esiste per chi preferisce non gestire chiavi API, infrastruttura e bollette LLM imprevedibili. Entrambi sono di prima classe — scegli quello che fa per te.
| | **Self-hosted** (questo repo) | **[Cloud hosted](https://www.xalgorix.com/)** |
| ---------------------------------- | ---------------------------------------- | ----------------------------------------------- |
| Prezzo per iniziare | Gratuito, Apache-2.0 | Piano gratuito · una scansione completa da $1 |
| Chiave API LLM | Porti e gestisci la tua | Inclusa — nessuna da gestire |
| Costo per scansione | Token LLM grezzi — variabile, può impennarsi | 1 credito per host live — prevedibile |
| Setup e operazioni | Installi, aggiorni ed esegui tu la toolchain | Nulla da eseguire — scansione in ~60s |
| Infrastruttura out-of-band (SSRF/blind RCE) | Metti in piedi il tuo server OOB | OOB gestito incluso |
| Pianificazione · team · RBAC | Fai da te | Integrati |
| Aggiornamenti | `git pull` + rebuild | Sempre sul motore più recente |
| Residenza dei dati / offline | ✅ resta sulla tua infrastruttura · air-gap OK | Viene eseguito sulla nostra infrastruttura (DPA disponibile) |
**Self-host se** i dati devono restare sulla tua rete, vuoi il pieno controllo, o eseguirai offline/air-gapped — è esattamente per questo che esiste. **Usa il cloud se** preferisci saltare chiavi API, infrastruttura e bollette a sorpresa sui token, e pagare solo per gli host live che scansionerai effettivamente.
<div align="center">
[**☁️ Prova il cloud hosted — gratis →**](https://www.xalgorix.com/) · [**⚖️ Confronta il costo reale (calcolatore) →**](https://www.xalgorix.com/hosted-vs-self-hosted)
</div>
Se Xalgorix ti fa risparmiare un ciclo di triage, per favore **[⭐ metti una stella al repo](https://github.com/xalgorix/xalgorix)** — aiuta davvero gli altri a trovarlo.
## 🎯 Casi d'uso
| Caso d'uso | Come Xalgorix aiuta |
| -------- | ------------------ |
| **Penetration testing** | Esegui una metodologia completa in 22 fasi contro target autorizzati. L'agente AI gestisce ricognizione, scoperta di vulnerabilità, test di injection, SSRF, IDOR, bypass di autenticazione, race condition e altro — poi verifica i finding prima di segnalarli. |
| **Bug bounty hunting** | Punta Xalgorix su un target in scope e lascia che l'agente enumeri la superficie d'attacco, testi le classi di vulnerabilità comuni ed emerga finding verificati con punteggi CVSS e prove proof-of-concept. |
| **Operazioni red team** | Usa le modalità di scansione wildcard e multi-target per mappare la superficie d'attacco esterna di un'organizzazione. Il DAST assistito dal browser gestisce flussi di autenticazione, form e comportamenti runtime che gli scanner statici non vedono. |
| **Ricerca sulla sicurezza** | La fase di scoperta di vulnerabilità nuove spinge l'agente oltre il matching di template noti. Porta il tuo LLM (OpenAI, Anthropic, DeepSeek, Gemini, Ollama, MiniMax) per controllare profondità di ragionamento e costo. |
| **Test di sicurezza continuo** | Esegui come servizio di sistema con `xalgorix --start`. Scansiona secondo una pianificazione, trasmetti i finding a Discord o Telegram e genera report PDF brandizzati per gli stakeholder. |
| **Automazione DAST** | Test guidati dal browser per applicazioni web — flussi di autenticazione, form, contenuti renderizzati in JavaScript e comportamenti runtime. Si integra con Caido per l'ispezione del traffico proxy. |
## ✨ Funzionalità
| Area | Capacità |
| -------------- | --------------------------------------------------------------------------------------------------------------------------- |
| 📊 Dashboard | Web UI locale su `127.0.0.1:9137` per impostazione predefinita, gestione delle scansioni, stato in tempo reale, azioni di scansione in blocco e recupero delle scansioni storiche. |
| 🔍 Scansione | Target singolo, DAST, wildcard e flussi multi-target con fasi metodologiche selezionabili. |
| 📡 Telemetria in tempo reale | Chiamate agli strumenti, messaggi dell'agente, finding, errori, attività HTTP e attività LLM tramite WebSocket. |
| 🐞 Finding | Pagine di dettaglio della scansione, filtri di severità, dettagli CVSS, indice dei finding e flussi di lavoro dei finding verificati. |
| 📄 Report | Report PDF brandizzati con nome del target/azienda, logo caricato, elenco dei report, azioni di apertura/download/eliminazione. |
| 🔔 Integrazioni | Caselle di test AgentMail, email di verifica, flussi OTP, eventi di triage email, notifiche Discord e Telegram. |
| ⚙️ Configurazione | Impostazioni della dashboard per LLM, AgentMail, Discord, Telegram, proxy, runtime, browser, autenticazione, limiti di velocità e risorse. |
| 🛡️ Sicurezza runtime | Limiti di istanze consapevoli delle risorse e binding solo su loopback a meno che l'accesso esterno sia configurato esplicitamente con autenticazione. |
## 📥 Installazione
I percorsi più rapidi non richiedono alcuna toolchain.
### ⚡ Installazione con una riga (binario precompilato)```bash
curl -sSL https://www.xalgorix.com/install | bash
Scarica il binario dell'ultima release per la tua piattaforma (Linux o macOS, amd64/arm64) e lo installa in /usr/local/bin (o ~/.local/bin senza sudo). Sovrascrivi con XALGORIX_INSTALL_DIR o fissa una versione con XALGORIX_VERSION=vX.Y.Z.
Completa la configurazione iniziale in modo interattivo—non è richiesta la modifica manuale del file di ambiente:```bash xalgorix --setup
Il wizard preserva le impostazioni esistenti quando viene rieseguito, nasconde l'input della chiave API in un terminale e, facoltativamente, avvia la Web UI al termine.
### 🐳 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 (o le più restrittive --cap-add=NET_ADMIN --cap-add=NET_RAW --cap-add=SYS_PTRACE --security-opt seccomp=unconfined) concede al toolset un accesso simile a quello dell'host. La sandbox predefinita di Docker rimuove le capability e filtra le syscall, il che compromette gli strumenti di basso livello (modifiche a iptables/route/interfacce, ARP-spoof/MITM, VPN tun/tap, debugger basati su ptrace). Un'immagine non può concedersi questi privilegi da sola — sono una decisione presa a runtime — quindi passa il flag, oppure usa il docker-compose.yml fornito, che lo imposta per te.
L'immagine è batteries-included: un ampio toolset di sicurezza offensiva è preinstallato (nmap, nuclei, httpx, subfinder, dnsx, naabu, katana, ffuf, gobuster, dalfox, feroxbuster, sqlmap, masscan, nikto, whatweb, hydra e altri), più Chromium per il DAST assistito dal browser. Mantiene inoltre disponibile l'intero set di package manager (apt, go, cargo, pipx, npm), così l'agente installa automaticamente qualsiasi cosa manchi a runtime. I dati delle scansioni persistono nel volume /data, e il server si associa a 0.0.0.0 all'interno del container — imposta XALGORIX_USERNAME/XALGORIX_PASSWORD prima di esporlo oltre localhost.
Il container viene eseguito come root per scelta progettuale (il motore abilita l'auto-installazione a runtime solo per uid 0, e le installazioni apt/go/cargo richiedono accesso in scrittura al sistema). Trattalo come una sandbox di scansione usa e getta e isolata dalla rete. Gli stessi tag pubblicano un manifest multi-piattaforma per linux/amd64 e linux/arm64, quindi Docker seleziona automaticamente l'immagine nativa.
Al primo avvio, se non imposti l'autenticazione della dashboard, il container genera una password admin casuale e la stampa nei log (l'immagine si associa a 0.0.0.0, cosa che il motore non farebbe senza autenticazione). Imposta XALGORIX_USERNAME + XALGORIX_PASSWORD (o XALGORIX_PASSWORD_HASH) per usarne di tuoi. Il binario non si auto-aggiorna mai all'interno del container (XALGORIX_NO_AUTO_UPDATE=1) — scarica un nuovo tag immagine per aggiornare. Il motore nuclei e i suoi template di vulnerabilità vengono aggiornati all'ultima versione a ogni build dell'immagine (la CI di release e redeploy.sh lo forzano); passa --build-arg NUCLEI_VERSION=vX.Y.Z per fissare il motore, oppure NUCLEI_REFRESH=0 ./redeploy.sh per riutilizzare la cache di Docker.
📋 Requisiti (build da sorgente)
| Requisito | Note |
|---|---|
| OS | Linux o macOS (amd64/arm64). |
| Go | 1.26 o successivo. |
| Node.js + npm | Richiesto quando si compila la React Web UI inclusa da sorgente. |
| Security tools | Installati su richiesta solo quando l'auto-installazione è abilitata. |
Verifica la tua versione di Go:```bash go version
### 🔨 Compilazione dal codice sorgente```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 compila la React Web UI in internal/web/static, poi compila il binario Go.
📦 Installazione con Go```bash
GOPROXY=direct GOSUMDB=off go install github.com/xalgord/xalgorix/v4/cmd/xalgorix@latest
## 🔩 Configurazione
Xalgorix carica la configurazione in questo ordine. Le fonti successive sovrascrivono quelle precedenti.
| Ordine | Fonte |
| ------ | -------------------------------------------------------------- |
| 1 | `/etc/xalgorix.env` |
| 2 | `/home/<sudo-user>/.xalgorix.env` quando avviato tramite `sudo` |
| 3 | `~/.xalgorix.env` |
| 4 | Variabili d'ambiente già presenti nel processo |
Crea il file di ambiente locale:```bash
nano ~/.xalgorix.env
🧩 Configurazione Minima
Per ottenere i migliori risultati di scansione autonoma, seleziona un modello frontier attuale. L'ID del modello riportato di seguito è un esempio concreto; ID di modelli compatibili più recenti possono essere inseriti senza attendere una release di Xalgorix.```bash XALGORIX_LLM=openai/gpt-5.6 XALGORIX_API_KEY=your_openai_api_key
### 🔌 Esempi di Provider
OpenAI:```bash
XALGORIX_LLM=openai/gpt-5.6
XALGORIX_API_KEY=sk-...
Provider OpenAI-compatibile personalizzato:```bash XALGORIX_LLM=custom/security-model XALGORIX_API_BASE=https://your-provider.example/v1 XALGORIX_API_KEY=your_provider_api_key
#### 🌉 Gateway LiteLLM / compatibili con OpenAI (GitHub Copilot, Claude Opus, Codex, OpenRouter, Azure, modelli locali)
Poiché `XALGORIX_API_BASE` accetta qualsiasi endpoint `/v1/chat/completions` compatibile con OpenAI,
Xalgorix funziona con un proxy [LiteLLM](https://docs.litellm.ai/) fin da subito — nessuna
modifica lato Xalgorix necessaria. LiteLLM gestisce l'autenticazione del provider upstream (login
device di Copilot, chiavi Azure, OpenRouter, Ollama, ecc.); Xalgorix parla semplicemente OpenAI verso il gateway.
Esegui LiteLLM (esempio `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
Punta Xalgorix verso di esso — usa il prefisso custom/ in modo che il nome del modello venga inviato letteralmente e venga utilizzato il protocollo OpenAI chat-completions:```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
Lo stesso schema copre GitHub Copilot Business/CLI, Claude Opus, modelli in stile Codex,
OpenRouter, Azure OpenAI e modelli Ollama locali — qualsiasi cosa LiteLLM possa instradare. Mantieni il
prefisso `custom/` (o `openai/`) e un `XALGORIX_API_BASE` non-Anthropic/Gemini affinché Xalgorix
utilizzi la forma di richiesta OpenAI standard che LiteLLM si aspetta.
### 🔔 Integrazioni Opzionali```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
🔐 Autenticazione della Dashboard```bash
XALGORIX_USERNAME=admin XALGORIX_PASSWORD=change-this-password
> [!TIP]
> Preferisci `XALGORIX_PASSWORD_HASH` per i deployment in produzione.
## 🆙 Aggiornamento dalle versioni precedenti
Questa release introduce un passaggio di stabilità e isolamento del workspace con una breaking change e alcune nuove opzioni degne di nota.
### 💥 Breaking change: workspace predefinito spostato in `~/.xalgorix/data/`
L'output delle scansioni, le note, le pianificazioni e gli altri artefatti generati ora risiedono in `~/.xalgorix/data/` invece che in `$CWD` (la directory da cui è stato avviato il binario).
Per mantenere il comportamento precedente, punta `XALGORIX_DATA_DIR` alla tua directory di lavoro corrente:```bash
export XALGORIX_DATA_DIR=$(pwd)
Un avviso [MIGRATION] viene emesso all'avvio quando vengono rilevati marker legacy (notes.json, _schedules/, vulnerabilities.json, o directory YYYY-MM-DD/scan-*) in $CWD e XALGORIX_DATA_DIR non è impostato. Xalgorix non legge, copia o elimina mai automaticamente quei file legacy; l'avviso è informativo e viene emesso una sola volta per processo.
🆕 Nuova variabile d'ambiente
| Variabile | Default | Descrizione |
|---|---|---|
XALGORIX_LLM_MAX_INFLIGHT | 4 × EffectiveMaxInstances | Limita le chiamate LLM in uscita simultanee su tutte le scansioni in esecuzione. Minimo 1. I waiter annullati non consumano uno slot. |
🩺 Nuovi contatori dell'endpoint di health
GET /api/status ora espone:
| Campo | Significato |
|---|---|
panics_recovered | Panic di goroutine, handler HTTP e tool che sono stati recuperati senza crash. |
path_rejections | Scritture su filesystem rifiutate da Path_Policy (fuori da data_dir / ~/.xalgorix/ / /tmp). |
watchdog_kills | Sottoprocessi terminati dal watchdog di hard-timeout per-tool. |
admission_refusals | Richieste di ammissione alla scansione negate a causa del limite di concorrenza. |
llm_inflight_cap | Valore effettivo di XALGORIX_LLM_MAX_INFLIGHT per questo processo. |
data_dir | Data_Dir risolta in uso. |
allow_list | Root del filesystem accettate da Path_Policy. |
🏃 Esecuzione
🪟 Web UI```bash
xalgorix --web
Apri:```text
http://127.0.0.1:9137
Usa una porta diversa:```bash xalgorix --web --port 8080
### 🌐 Accesso Esterno
Associa a un'altra interfaccia solo dopo aver abilitato l'autenticazione della dashboard:```bash
XALGORIX_USERNAME=admin XALGORIX_PASSWORD=change-this xalgorix --web --bind 0.0.0.0
[!WARNING] Il server rifiuta il binding esterno senza autenticazione alla dashboard.
🏹 Scansione CLI```bash
xalgorix --target https://example.com
Con istruzioni personalizzate:```bash
xalgorix --target https://app.example.com --instruction "Focus on SQL injection, IDOR, and auth bypass. Avoid destructive tests."
🧰 Modalità Servizio
Installa e avvia come servizio di sistema:```bash sudo xalgorix --start
Gestisci il servizio:```bash
sudo xalgorix --restart
sudo xalgorix --stop
sudo xalgorix --uninstall
Visualizza i log:```bash journalctl -u xalgorix -f
### 🌍 Accesso Remoto al Servizio
Esponi il servizio ai browser remoti solo dopo aver abilitato l'autenticazione della dashboard:```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
Poi apri http://<server-ip>:9137.
Se il processo è in ascolto ma la pagina ancora non si carica da remoto, consenti la porta TCP 9137 nel firewall del server o nel security group del cloud.
🏠 Scansione di target locali/interni
Per impostazione predefinita Xalgorix rifiuta di scansionare loopback, localhost, range privati o i propri indirizzi di interfaccia — sono la macchina su cui gira Xalgorix, non un target. Su una macchina self-hosted, single-tenant puoi optare per scansionare un'app demo/staging ospitata localmente:```bash
echo 'XALGORIX_ALLOW_LOCAL_TARGETS=true' | sudo tee -a /root/.xalgorix.env
sudo xalgorix --restart
Il listener del dashboard stesso è **sempre** protetto, anche con questa opzione abilitata.
> **⚠️ Deployment condivisi / multi-tenant / hosted: mantenere questa opzione DISATTIVATA.** Abilitarla
> consentirebbe alla scansione di un utente di raggiungere la macchina dell'operatore e la rete interna.
> È disattivata per impostazione predefinita, quindi non è necessaria alcuna azione per rimanere al sicuro — non impostare
> `XALGORIX_ALLOW_LOCAL_TARGETS` (o fissa `XALGORIX_ALLOW_LOCAL_TARGETS=false`),
> e non esporre la pagina Settings del motore a utenti non attendibili.
## 🔁 Flusso di lavoro della Web UI
1. Apri il dashboard all'indirizzo `http://127.0.0.1:9137`.
2. Vai su Settings e conferma il provider LLM, la chiave API, i limiti di frequenza e le integrazioni opzionali.
3. Crea una scansione da New Scan.
4. Scegli una modalità di scansione.
5. Seleziona le fasi della metodologia quando desideri un'esecuzione mirata.
6. Imposta i filtri di severità quando solo determinate severità devono essere segnalate in tempo reale. Il filtro influisce solo sul feed del dashboard in tempo reale e sulle notifiche; il report PDF e `/api/findings` includono sempre ogni vulnerabilità scoperta dall'agente.
7. Aggiungi il nome dell'azienda e carica un logo per report personalizzati.
8. Monitora i progressi da Overview, Scan Detail o Live Feed.
9. Apri i dettagli dei finding, scarica i report o gestisci le scansioni storiche da Scans e Reports.
## 🔀 Modalità di scansione
| Modalità | Ideale per |
| ---------------- | ------------------------------------------------------------------------------- |
| 🎯 Target singolo | Testare un URL o host noto. |
| 🌐 Wildcard / multi | Enumerare target correlati e scansionare la superficie di attacco scoperta. |
| 🧭 DAST | Test assistito dal browser per app web, flussi di autenticazione, form e comportamento a runtime. |
## 📂 Scansiona il tuo codice (nessun target necessario)
Indirizza Xalgorix verso una codebase — un URL Git, un percorso locale o uno zip caricato — e
scansiona direttamente il codice sorgente. Nessun URL distribuito, nessuna infrastruttura da predisporre.```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
| Modalità code-scan | Cosa fa | Livello di verifica |
|---|---|---|
review | Legge il codice sorgente, traccia l'input utente dal punto di ingresso → sink pericoloso e segnala le vulnerabilità raggiungibili. Nessun target live. | Verificato sul sorgente — provato raggiungibile nel codice (chiaramente etichettato come non sfruttato a runtime). |
provision | Ispeziona il repository, compila ed esegue l'app su una porta di loopback, quindi esegue DAST guidato whitebox contro l'istanza in esecuzione. Torna a review se l'app non può essere compilata. | Verificato con exploit — riprodotto contro l'app in esecuzione. |
--sourceaccetta un URL Git (clonato in modo superficiale), una directory locale o un percorso a un archivio caricato/estratto. Nella Web UI / app ospitata puoi anche caricare un.zipdel tuo codebase (POST /api/upload-source).- Puoi comunque combinare un repository e un target live per il classico arricchimento whitebox — quel percorso è invariato. Le modalità code-scan servono quando il codebase è l'intero oggetto.
La modalità provision esegue i comandi di build/avvio della tua app nella sandbox dell'agente e testa solo la singola porta di loopback su cui ha avviato l'app — la dashboard e tutto il resto sulla macchina restano fuori scope.
🧭 Metodologia
Xalgorix organizza il testing autonomo in 22 fasi.
| Fase | Focus |
|---|---|
| 1 | Ricognizione |
| 2 | Scoperta manuale delle vulnerabilità |
| 3 | Scoperta di directory e file |
| 4 | Analisi CORS e cookie |
| 5 | Test di autenticazione e sessione |
| 6 | Test di injection |
| 7 | Test SSRF |
| 8 | IDOR e controllo degli accessi non corretto |
| 9 | Test API e GraphQL |
| 10 | Test di upload file |
| 11 | Deserializzazione e RCE |
| 12 | Race condition e logica di business |
| 13 | Subdomain takeover |
| 14 | Test di open redirect |
| 15 | Test di sicurezza email |
| 16 | Cloud e infrastruttura |
| 17 | Test WebSocket |
| 18 | Test specifici per CMS |
| 19 | Broken link hijacking e content spoofing |
| 20 | Verifica degli exploit |
| 21 | Scoperta di vulnerabilità nuove |
| 22 | Report finale |
La selezione delle fasi nella Web UI ti consente di eseguire tutte le fasi o solo il sottoinsieme necessario per un ingaggio specifico.
📄 Report
I report vengono generati come file PDF e possono includere:
| Sezione | Contenuto incluso |
|---|---|
| 📌 Riepilogo | Riepilogo esecutivo, metadati del target, metadati della scansione e panoramica della severità. |
| 🐞 Riscontri | Riscontri verificati, dettagli CVSS, analisi tecnica e prova di sfruttamento. |
| 🔬 Evidenze | Comandi proof of concept, script, note sui payload e osservazioni di supporto. |
| 🩹 Remediation | Indicazioni di correzione e prossimi passi prioritizzati. |
| 🎨 Branding | Nome azienda/target e logo caricato. |
I report sono disponibili dalla pagina di dettaglio della scansione e dalla pagina Report. Le righe dei report supportano apertura, download ed eliminazione.
🔧 Impostazioni
La maggior parte delle impostazioni operative può essere modificata dalla Web UI sotto Impostazioni.
| Area | Esempi |
|---|---|
| 🤝 Ingaggio | Limiti di frequenza delle richieste della dashboard |
| 🧠 LLM | Modello, chiave API, base API, sforzo di ragionamento, tentativi, iterazioni massime |
| 📬 AgentMail | Pod e chiave API |
| 🔔 Notifiche | Webhook Discord e severità minima, token bot Telegram, chat ID, severità minima e riepiloghi opt-in di completamento scansione |
| 🕵️ Proxy | URL proxy, file proxy, rotazione, verifica TLS |
| 🧱 Runtime | Workspace, percorso browser, controlli di installazione automatica |
| 🔐 Sicurezza | Nome utente dashboard, password, hash password, indirizzo di bind |
| 📈 Risorse | Soglie CPU/RAM/disco e budget di concorrenza delle scansioni |
Alcune impostazioni richiedono un riavvio perché influenzano l'avvio del processo o il binding del server. La UI contrassegna quei campi.
🧾 Variabili d'ambiente
🧱 Core
| Variabile | Predefinito | Descrizione |
|---|---|---|
XALGORIX_LLM | nessuno | ID modello nativo del provider usato per le richieste LLM. |
XALGORIX_LLM_PROVIDER | nessuno | Provider selezionato dalla dashboard, memorizzato separatamente dall'ID modello. |
XALGORIX_API_KEY | nessuno | Chiave API del provider LLM richiesta. |
XALGORIX_API_BASE | predefinito del provider | URL base API personalizzato compatibile con OpenAI. |
XALGORIX_REASONING_EFFORT | high | Sforzo di ragionamento: none, low, medium, high o xhigh (xhigh viene mappato a high per Ollama). |
XALGORIX_LANGUAGE | en | Lingua di output per il testo generato dall'AI (ragionamento dell'agente, note, riscontri, contenuto del report, chat post-scansione). en o zh-CN. I token tecnici (payload, comandi, URL, ID CVE/CWE) restano sempre nella loro forma originale. Le lingue non latine vengono renderizzate automaticamente nella dashboard e nel report HTML. |
XALGORIX_PDF_CJK_FONT | nessuno | Percorso assoluto a un font TrueType (.ttf) con glifi CJK, usato per renderizzare lingue non latine (es. cinese semplificato) nel report PDF esportato. È supportato solo .ttf (non .ttc/.otf). Senza di esso, il PDF torna ai font core e i glifi non latini non verranno renderizzati (il report HTML non è interessato). |
XALGORIX_OLLAMA_COMPATIBLE | false | Applica la semantica di ragionamento di Ollama a un endpoint personalizzato su una porta non standard. La porta 11434 viene rilevata automaticamente. |
XALGORIX_LLM_MAX_RETRIES | 5 | Numero di tentativi per fallimenti LLM transitori. |
XALGORIX_MEMORY_COMPRESSOR_TIMEOUT | 30 | Timeout in secondi per la compressione del contesto. |
XALGORIX_MAX_ITERATIONS | 0 | Limite di iterazioni dell'agente. 0 significa illimitato. |
XALGORIX_PPROF_ADDR | nessuno | Profiler Go opt-in. Quando impostato (es. 127.0.0.1:6060), avvia un server pprof standalone su /debug/pprof/ a quell'indirizzo per la diagnosi CPU/heap. Disabilitato per impostazione predefinita. Espone le parti interne del processo — esegui il bind su loopback e raggiungilo tramite un tunnel SSH; non esporlo mai pubblicamente. |
GEMINI_API_KEY | nessuno | Chiave Gemini opzionale per l'arricchimento della ricerca web. |
🔒 Web e Sicurezza
| Variabile | Predefinito | Descrizione |
|---|---|---|
XALGORIX_BIND | 127.0.0.1 | Indirizzo di ascolto del server web. |
XALGORIX_ALLOW_LOCAL_TARGETS | false | Consenti la scansione di app ospitate localmente (localhost / 127.0.0.1 / IP privati) su un'installazione self-hosted. Il listener della dashboard stessa è sempre protetto. Lascia disattivato su deployment condivisi/ospitati. |
XALGORIX_USERNAME | nessuno | Nome utente della dashboard. |
XALGORIX_PASSWORD | nessuno | Password della dashboard. |
XALGORIX_PASSWORD_HASH | nessuno | Hash password bcrypt preferito. |
XALGORIX_WORKSPACE | directory corrente | Root del workspace per l'esecuzione delle scansioni. |
🤝 Integrazioni
| Variabile | Predefinito | Descrizione |
|---|---|---|
AGENTMAIL_POD | nessuno | Identificatore del pod AgentMail. |
AGENTMAIL_API_KEY | nessuno | Chiave API AgentMail. |
XALGORIX_DISCORD_WEBHOOK | nessuno | Webhook Discord globale. |
XALGORIX_DISCORD_MIN_SEVERITY | nessuno | Severità minima inviata a Discord. |
XALGORIX_TELEGRAM_BOT_TOKEN | nessuno | Token bot Telegram da @BotFather. |
XALGORIX_TELEGRAM_CHAT_ID | nessuno | ID chat/canale Telegram (numerico o @username). |
XALGORIX_TELEGRAM_MIN_SEVERITY | nessuno | Severità minima inviata a Telegram. |
XALGORIX_NOTIFY_SCAN_COMPLETE | false | Invia riepiloghi di fine scansione alle destinazioni Discord/Telegram configurate. È opt-in e non influisce sugli avvisi per singola vulnerabilità. |
CAIDO_PORT | 0 | Porta del proxy Caido. 0 significa rilevamento automatico. |
CAIDO_API_TOKEN | nessuno | Token API Caido. |
🚦 Limiti di frequenza, Proxy e Runtime
| Variabile | Predefinito | Descrizione |
|---|---|---|
XALGORIX_RATE_LIMIT_REQUESTS | 60 | Richieste della dashboard per finestra. |
XALGORIX_RATE_LIMIT_WINDOW | 60 | Finestra del limite di frequenza della dashboard in secondi. |
XALGORIX_RATE_RPS | 10 | Frequenza sostenuta delle richieste in uscita. |
XALGORIX_RATE_BURST | 20 | Dimensione del burst in uscita. |
XALGORIX_USE_PROXY | false | Abilita il routing tramite proxy. |
XALGORIX_PROXY_URL | nessuno | URL proxy singolo. Sovrascrive il file proxy. |
XALGORIX_PROXY_FILE | nessuno | File contenente un proxy per riga. |
XALGORIX_PROXY_ROTATION | roundrobin | Strategia di rotazione del proxy: roundrobin o random. |
XALGORIX_TLS_SKIP_VERIFY | false | Salta la verifica TLS per il traffico di test. |
XALGORIX_DISABLE_BROWSER | false | Disabilita l'automazione del browser. |
XALGORIX_BROWSER_PATH | auto | Percorso eseguibile Chrome/Chromium personalizzato. |
XALGORIX_ALLOW_AUTO_INSTALL | solo root | Consenti l'installazione automatica dei pacchetti. |
XALGORIX_AUTO_INSTALL_SUDO | false | Consenti installazioni automatiche con prefisso sudo. |
🔤 Prefissi dei Provider
Quando XALGORIX_API_BASE è vuoto, Xalgorix deduce i valori predefiniti del provider dal prefisso del modello.
| Prefisso | Base API predefinita |
|---|---|
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 |
I nomi dei modelli non sono hard-coded a questa lista. La pagina Impostazioni accetta ID modello digitati, così i modelli più recenti dei provider possono essere usati senza attendere un aggiornamento del menu a tendina della UI.
💻 Riferimento CLI
| Flag | Alias | Descrizione |
|---|---|---|
--web | -w | Avvia la Web UI. |
--port <port> | -p | Porta della Web UI. Predefinito: 9137. |
--bind <addr> | nessuno | Indirizzo di bind. Predefinito: 127.0.0.1. |
--target <target> | -t | URL, host, IP o percorso del target. Ripetibile. |
--instruction <text> | -i | Istruzioni di scansione personalizzate. |
--model <model> | -m | Sovrascrive XALGORIX_LLM per questa esecuzione. |
--update | -up | Aggiorna all'ultima release. |
--version | -v | Stampa la versione. |
--start | nessuno | Installa e avvia il servizio di sistema. |
--stop | nessuno | Ferma il servizio di sistema. |
--restart | nessuno | Riavvia il servizio di sistema. |
--uninstall | nessuno | Rimuove il servizio di sistema. |
--help | -h | Mostra l'aiuto. |
📡 Riepilogo API
| Metodo | Endpoint | Scopo |
|---|---|---|
POST | /api/scan | Avvia o salva una scansione. |
POST | /api/stop | Ferma tutte le scansioni in esecuzione. |
GET | /api/status | Stato globale corrente. |
GET | /api/scans | Elenca le scansioni. |
GET | /api/scans/:id | Ottieni il dettaglio della scansione. |
DELETE | /api/scans/:id | Elimina una scansione e i suoi dati di report. |
GET | /api/findings | Elenca tutti i riscontri (deduplicati tra le scansioni). |
GET | /api/findings/summary | Conteggio per severità su tutte le scansioni. |
GET | /api/report/:id | Scarica un report PDF. |
GET | /api/instances | Elenca le istanze live e storiche. |
GET | /api/instances/:id/events | Ottieni la cronologia degli eventi memorizzata. |
POST | /api/instances/:id/stop | Ferma un'istanza specifica. |
POST | /api/instances/:id/start | Avvia una scansione salvata o completata come nuova esecuzione. |
POST | /api/instances/:id/restart | Riavvia con la stessa configurazione. |
POST | /api/instances/:id/pause | Metti in pausa una scansione in esecuzione. |
POST | /api/instances/:id/resume | Riprendi una scansione in pausa. |
POST | /api/upload-logo | Carica un logo per il report. |
POST | /api/upload-targets | Carica una lista di target. |
GET | /api/settings/environment | Elenca le impostazioni d'ambiente modificabili. |
POST | /api/settings/environment | Salva le impostazioni d'ambiente. |
GET | /api/settings/llm | Ottieni le impostazioni LLM. |
POST | /api/settings/llm | Salva le impostazioni LLM. |
GET | /api/settings/agentmail | Ottieni le impostazioni AgentMail. |
POST | /api/settings/agentmail | Salva le impostazioni AgentMail. |
GET | /ws | Stream di eventi live WebSocket. |
💾 Archiviazione dei Dati
I dati delle scansioni in modalità web sono archiviati sotto:```text
~/xalgorix-data/
|-- _saved/
|-- logos/
|-- queue_state.json
-- <target>/ -- /
-- <scan-id>/ |-- scan.json -- report.pdf
Il server conserva i record storici delle scansioni su disco, così l'interfaccia utente può recuperarli dopo un aggiornamento o un riavvio.
## 🧪 Sviluppo
| Attività | Comando |
| --------------------------- | ----------------------------- |
| 📦 Installa le dipendenze della Web UI | `make webui-install` |
| 🔨 Compila tutto | `make build` |
| ✅ Esegui i test | `go test ./...` |
| 🖥️ Esegui la Web UI dal sorgente | `go run ./cmd/xalgorix --web` |
| ⚡ Esegui il server di sviluppo frontend | `make webui-dev` |
## 🚨 Note di sicurezza
- Usa Xalgorix solo contro target autorizzati.
- Non eseguire test attivi contro sistemi di terze parti senza autorizzazione.
- Rivedi le istruzioni di scansione prima di avviare.
- Configura i limiti di velocità e le impostazioni del proxy in base alle regole dell'incarico.
- L'esposizione della dashboard all'esterno richiede l'autenticazione.
- L'installazione automatica è disabilitata per impostazione predefinita per gli utenti non root e dovrebbe essere abilitata solo quando ci si fida dell'ambiente.
## 📜 Licenza
Xalgorix è rilasciato sotto la Apache License 2.0. Vedi [LICENSE](https://github.com/xalgord/xalgorix/blob/main/LICENSE).
## 🔗 Link
| Risorsa | Link |
| ------------- | -------------------------------------------------------------------------------- |
| ☁️ Ospitato (Cloud) | [www.xalgorix.com](https://www.xalgorix.com/) |
| 📖 Documentazione | [docs.xalgorix.com](https://docs.xalgorix.com) |
| 🐛 Problemi | [github.com/xalgorix/xalgorix/issues](https://github.com/xalgorix/xalgorix/issues) |
| ☕ Supporto | [buymeacoffee.com/xalgord](https://buymeacoffee.com/xalgord) |