Xalgorix — Pentester de IA de código abierto que demuestra vulnerabilidades

La mayoría de los escáneres detectan. Xalgorix demuestra. Un agente LLM autónomo ejecuta una metodología completa de pentest y, a continuación, un verificador independiente re-explota cada hallazgo antes de que se informe — para que obtengas pruebas, no un montón de "puede ser" que triar. Autoalojado, privado y con tu propio LLM. Construido en Go + TypeScript.

Inicio rápido · Por qué Xalgorix · Características · Casos de uso · Cloud alojado · Documentación

Quick Start

Instalación (una línea):```bash curl -sSL https://www.xalgorix.com/install | bash

Esto descarga el binario precompilado para tu plataforma (Linux amd64/arm64) desde la última versión. Luego apúntalo a tu proveedor de LLM en `~/.xalgorix.env`:```bash
XALGORIX_LLM=minimax/MiniMax-M3
XALGORIX_API_KEY=your_provider_api_key

Inicie el panel y abra http://127.0.0.1:9137:```bash xalgorix --web

**O ejecuta con Docker — baterías incluidas, sin necesidad de cadena de herramientas:**```bash
docker run --rm -p 9137:9137 \
  --privileged \
  -v xalgorix-data:/data \
  xalgord/xalgorix:latest

--privileged le da al conjunto de herramientas el mismo acceso similar al del host que tiene cuando se ejecuta de forma nativa como root. El sandbox predeterminado de Docker elimina capacidades (como NET_ADMIN) y aplica un filtro seccomp, lo que rompe herramientas de bajo nivel (cambios de iptables/route, ARP-spoof/MITM, VPNs tun/tap, depuradores basados en ptrace, ajuste de interfaz de masscan). Dado que una imagen no puede otorgarse estas capacidades a sí misma, deben establecerse en tiempo de ejecución. El contenedor es un sandbox de escaneo desechable, aislado de la red, que se ejecuta como root: privilegiado es la postura prevista; nunca expongas el panel públicamente sin autenticación. ¿Prefieres el menor privilegio? Cambia --privileged por --cap-add=NET_ADMIN --cap-add=NET_RAW --cap-add=SYS_PTRACE --security-opt seccomp=unconfined.

Abre http://localhost:9137. No necesitas una clave de LLM para empezar — el panel se lanza sin una; establece el modelo y la clave de API en Settings → LLM (se guarda en el volumen /data). Si no pasas XALGORIX_USERNAME/XALGORIX_PASSWORD, se genera una contraseña de administrador aleatoria y se imprime en los registros del contenedor en el primer arranque.

La forma más fácil — Docker Compose (mapea el puerto y un volumen persistente por ti):```bash curl -sSLO https://raw.githubusercontent.com/xalgord/xalgorix/main/docker-compose.yml docker compose up -d docker compose logs -f # shows the generated admin password on first start

La imagen incluye un amplio conjunto de herramientas ofensivas de seguridad preinstaladas (nmap, nuclei, httpx, subfinder, katana, ffuf, gobuster, sqlmap, masscan, dalfox, feroxbuster y más) **y** mantiene disponibles todos los gestores de paquetes (apt, go, cargo, pipx, npm) para que el agente pueda autoinstalar cualquier cosa que falte en tiempo de ejecución. Se ejecuta como root dentro del contenedor por diseño: trate el contenedor como un sandbox de escaneo desechable y aislado de la red, y nunca exponga el panel sin autenticación. (Imagen amd64; el instalador anterior cubre arm64).

**O compilar desde el código fuente** (necesita Go 1.25+ y Node.js):```bash
git clone https://github.com/xalgord/xalgorix.git
cd xalgorix
make build
sudo install -m 755 build/xalgorix /usr/local/bin/xalgorix

[!TIP] ¿Prefieres cero configuración? Una versión totalmente gestionada se encuentra en www.xalgorix.com — clic para escanear, sin instalación ni claves API requeridas.

Revisa pull requests automáticamente — app gratuita de GitHub

¿Quieres una revisión de seguridad en cada pull request sin configuración? Instala la app de GitHub Xalgorix. Lee el diff de cada PR y comenta una revisión de seguridad — inyección, auth/IDOR roto, SSRF, secretos, patrones inseguros — directamente en el pull request. Se actualiza en el sitio con nuevos commits, y puedes comentar @xalgorix review para volver a ejecutarla bajo demanda. Sin archivo de workflow, sin clave API, sin cuenta — y es gratuita.

Para control de merges y pentests completos con verificación de exploits en CI, usa el escáner alojado o la GitHub Action.

[!IMPORTANT] Usa Xalgorix solo en sistemas que te pertenezcan o para los que tengas permiso explícito de prueba.

[!TIP] ¿Prefieres no auto-alojarla? Una versión totalmente gestionada está disponible en www.xalgorix.com — clic para escanear, sin instalación ni claves API requeridas.

Contenido

• Inicio rápido
• Resumen
• Por qué Xalgorix
• Casos de uso
• Capturas de pantalla
• Características
• Instalación
• Configuración
• Actualización desde versiones anteriores
• Ejecución
• Modo servicio
• Flujo de trabajo de la interfaz web
• Modos de escaneo
• Metodología
• Informes
• Ajustes
• Variables de entorno
• Prefijos de proveedores
• Referencia de CLI
• Resumen de API
• Almacenamiento de datos
• Desarrollo
• Notas de seguridad
• Licencia
• Enlaces

Resumen

Xalgorix es una plataforma autoalojada de pruebas de penetración con IA para pruebas de seguridad autorizadas, evaluación de vulnerabilidades y flujos de trabajo de bug bounty. Combina un agente autónomo basado en LLM, automatización de navegador, herramientas de terminal, una metodología integral de prueba de 22 fases, telemetría WebSocket en vivo, gestión de hallazgos con puntuación CVSS, generación de informes PDF con marca e integraciones para AgentMail, Discord y Telegram.

A diferencia de los escáneres DAST solo en la nube, Xalgorix se ejecuta íntegramente en tu máquina. Tú aportas tu propio proveedor de LLM (OpenAI, Anthropic, DeepSeek, Gemini, Groq, Ollama, MiniMax) y controlas el modelo, el esfuerzo de razonamiento, los límites de tasa y la configuración del proxy. Ningún dato de escaneo, clave API o información del objetivo sale de tu infraestructura.

La experiencia predeterminada es la interfaz web. Desde un único panel local puedes iniciar escaneos, supervisar ejecuciones activas, inspeccionar hallazgos, configurar ajustes de modelo/proveedor, gestionar variables de entorno, generar informes PDF con marca y eliminar o reanudar escaneos históricos.

Por qué Xalgorix

La mayoría de los escáneres detectan. Xalgorix prueba. Un agente autónomo recorre una metodología de 22 fases y, después, un verificador independiente vuelve a probar cada hallazgo candidato antes de que se informe; así obtienes resultados verificados mediante exploits con evidencia, no una pared de «quizás» que clasificar.

• 🧠 Un agente de IA, no un motor de plantillas — razona sobre flujos de autenticación, lógica de negocio, IDOR/BOLA y exploits encadenados que los escáneres por firmas pasan por alto.
• ✅ Hallazgos verificados mediante exploits — un verificador independiente reproduce cada hallazgo; los no concluyentes se marcan para revisión, nunca se presentan como confirmados.
• 🔒 Autoalojado y privado — se ejecuta en tu máquina con tu propia clave de LLM; ningún dato del objetivo, clave o hallazgo sale de tu infraestructura.
• 🧩 Trae tu propio LLM — OpenAI, Anthropic, DeepSeek, Gemini, Groq, Ollama o MiniMax — o cualquier puerta de enlace compatible con OpenAI como LiteLLM (GitHub Copilot, Codex, OpenRouter, Azure). Tú controlas el modelo, el esfuerzo de razonamiento y el coste.
• 📄 Informes listos para auditoría — PDF con marca con puntuaciones CVSS, prueba de concepto y remediación.

Cómo se compara

Comparación orientativa: Nuclei y ZAP son excelentes en lo que hacen. Xalgorix añade encima la capa de descubrimiento y verificación de exploits basada en razonamiento.

Si Xalgorix te ahorra un ciclo de triaje, por favor ⭐ da una estrella al repositorio — de verdad ayuda a que otros lo encuentren.

Casos de uso

Capturas de pantalla

Panel de resumen	Detalle del escaneo	Hallazgos

Características

Instalación

Las rutas más rápidas no necesitan ninguna cadena de herramientas.

Instalación en una línea (binario precompilado)```bash

curl -sSL https://www.xalgorix.com/install | bash

Descarga el binario de la última versión para tu plataforma (Linux `amd64`/`arm64`) y lo instala en `/usr/local/bin` (o `~/.local/bin` sin sudo). Sobrescribe con `XALGORIX_INSTALL_DIR` o fija una versión con `XALGORIX_VERSION=vX.Y.Z`.

### Docker```bash
docker run --rm -p 9137:9137 \
  --privileged \
  -e XALGORIX_LLM=minimax/MiniMax-M3 \
  -e XALGORIX_API_KEY=your_provider_api_key \
  -v xalgorix-data:/data \
  ghcr.io/xalgord/xalgorix:latest

--privileged (o la opción más restringida --cap-add=NET_ADMIN --cap-add=NET_RAW --cap-add=SYS_PTRACE --security-opt seccomp=unconfined) otorga al conjunto de herramientas un acceso similar al del host. El sandbox predeterminado de Docker elimina capacidades y filtra syscalls, lo que rompe herramientas de bajo nivel (cambios de iptables/route/interfaces, ARP-spoof/MITM, VPNs tun/tap, depuradores basados en ptrace). Una imagen no puede otorgarse estas capacidades a sí misma — son una decisión de tiempo de ejecución — así que pasa la bandera, o usa el docker-compose.yml proporcionado, que lo establece por ti.

La imagen viene con todo incluido: un extenso conjunto de herramientas ofensivas de seguridad está preinstalado (nmap, nuclei, httpx, subfinder, dnsx, naabu, katana, ffuf, gobuster, dalfox, feroxbuster, sqlmap, masscan, nikto, whatweb, hydra y más), además de Chromium para DAST asistido por navegador. También mantiene disponible el conjunto completo de gestores de paquetes (apt, go, cargo, pipx, npm), de modo que el agente autoinstala cualquier cosa que falte en tiempo de ejecución. Los datos de escaneo persisten en el volumen /data, y el servidor se enlaza a 0.0.0.0 dentro del contenedor — establece XALGORIX_USERNAME/XALGORIX_PASSWORD antes de exponerlo más allá de localhost.

El contenedor se ejecuta como root por diseño (el motor solo habilita la autoinstalación en tiempo de ejecución para uid 0, y las instalaciones con apt/go/cargo necesitan acceso de escritura al sistema). Trátalo como un sandbox de escaneo desechable y aislado de la red. Está publicado para amd64; usa el instalador de una línea para hosts arm64.

En el primer arranque, si no estableces la autenticación del panel, el contenedor genera una contraseña de administrador aleatoria y la imprime en los registros (la imagen se enlaza a 0.0.0.0, algo que el motor no hará sin autenticación). Establece XALGORIX_USERNAME + XALGORIX_PASSWORD (o XALGORIX_PASSWORD_HASH) para usar las tuyas. El binario nunca se autoactualiza dentro del contenedor (XALGORIX_NO_AUTO_UPDATE=1) — descarga una nueva etiqueta de imagen para actualizar.

Requisitos (compilar desde el código fuente)

Comprueba tu versión de Go:```bash go version

### Compilar desde el código fuente```bash
git clone https://github.com/xalgord/xalgorix.git
cd xalgorix
make build
sudo install -m 755 build/xalgorix /usr/local/bin/xalgorix

make build compila la interfaz web de React en internal/web/static, y luego compila el binario de Go.

Instalar con Go```bash

GOPROXY=direct GOSUMDB=off go install github.com/xalgord/xalgorix/v4/cmd/xalgorix@latest

## Configuración

Xalgorix carga la configuración en este orden. Las fuentes posteriores sobrescriben a las anteriores.

| Orden | Fuente                                                         |
| ----- | -------------------------------------------------------------- |
| 1     | `/etc/xalgorix.env`                                            |
| 2     | `/home/<sudo-user>/.xalgorix.env` cuando se lanza a través de `sudo` |
| 3     | `~/.xalgorix.env`                                              |
| 4     | Variables de entorno ya presentes en el proceso                 |

Crea el archivo de entorno local:```bash
nano ~/.xalgorix.env

Configuración Mínima```bash

XALGORIX_LLM=minimax/MiniMax-M3 XALGORIX_API_KEY=your_provider_api_key

### Ejemplos de proveedores

OpenAI:```bash
XALGORIX_LLM=openai/gpt-5.4
XALGORIX_API_KEY=sk-...

Proveedor personalizado compatible con OpenAI:```bash XALGORIX_LLM=custom/security-model XALGORIX_API_BASE=https://your-provider.example/v1 XALGORIX_API_KEY=your_provider_api_key

#### Pasarelas compatibles con LiteLLM / OpenAI (GitHub Copilot, Claude Opus, Codex, OpenRouter, Azure, modelos locales)

Debido a que `XALGORIX_API_BASE` acepta cualquier endpoint `/v1/chat/completions` compatible con OpenAI,
Xalgorix funciona con un proxy [LiteLLM](https://docs.litellm.ai/) de serie — no
hacen falta cambios en el lado de Xalgorix. LiteLLM gestiona la autenticación del proveedor upstream (inicio de
sesión de dispositivo de Copilot, claves de Azure, OpenRouter, Ollama, etc.); Xalgorix solo habla OpenAI con la pasarela.

Ejecuta LiteLLM (ejemplo `config.yaml`):```yaml
model_list:
  - model_name: claude-opus-4-8
    litellm_params:
      model: github_copilot/claude-opus-4.8   # or openrouter/…, azure/…, ollama/…
general_settings:
  master_key: sk-local-litellm-key

Apunta Xalgorix hacia él: usa el prefijo custom/ para que el nombre del modelo se envíe tal cual y se use el protocolo de chat-completions de OpenAI:```bash XALGORIX_LLM=custom/claude-opus-4-8 # 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

El mismo patrón cubre GitHub Copilot Business/CLI, Claude Opus, modelos estilo Codex,
OpenRouter, Azure OpenAI y modelos locales de Ollama: cualquier cosa que LiteLLM pueda enrutar. Mantén el
prefijo `custom/` (o `openai/`) y una `XALGORIX_API_BASE` no Anthropic/Gemini para que Xalgorix
use la forma de solicitud estándar de OpenAI que LiteLLM espera.

### Integraciones opcionales```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

Autenticación del Panel```bash

XALGORIX_USERNAME=admin XALGORIX_PASSWORD=change-this-password

> [!TIP]
> Prefiere `XALGORIX_PASSWORD_HASH` para despliegues en producción.

## Actualización desde versiones anteriores

Esta versión incorpora una pasada de estabilidad y aislamiento del espacio de trabajo, con un cambio incompatible y algunos parámetros nuevos que vale la pena conocer.

### Cambio incompatible: el espacio de trabajo predeterminado se ha movido a `~/.xalgorix/data/`

La salida de escaneos, notas, programaciones y otros artefactos generados ahora se encuentran en `~/.xalgorix/data/` en lugar de `$CWD` (el directorio desde el que se lanzó el binario).

Para conservar el comportamiento anterior, apunta `XALGORIX_DATA_DIR` a tu directorio de trabajo actual:```bash
export XALGORIX_DATA_DIR=$(pwd)

Se emite una advertencia [MIGRATION] al inicio cuando se detectan marcadores heredados (notes.json, _schedules/, vulnerabilities.json o directorios YYYY-MM-DD/scan-*) en $CWD y XALGORIX_DATA_DIR no está definido. Xalgorix nunca lee, copia ni elimina esos archivos heredados automáticamente; la advertencia es informativa y solo se activa una vez por proceso.

Nueva variable de entorno

Nuevos contadores del endpoint de salud

GET /api/status ahora expone:

Running

Web UI```bash

xalgorix --web

Abrir:```text
http://127.0.0.1:9137

Usa un puerto diferente:```bash xalgorix --web --port 8080

### Acceso Externo

Enlazar a otra interfaz solo después de habilitar la autenticación del panel:```bash
XALGORIX_USERNAME=admin XALGORIX_PASSWORD=change-this xalgorix --web --bind 0.0.0.0

[!WARNING] El servidor rechaza el enlace externo sin autenticación del panel.

Escaneo CLI```bash

xalgorix --target https://example.com

Con instrucciones personalizadas:```bash
xalgorix --target https://app.example.com --instruction "Focus on SQL injection, IDOR, and auth bypass. Avoid destructive tests."

Modo de servicio

Instale e inicie como un servicio del sistema:```bash sudo xalgorix --start

Gestione el servicio:```bash
sudo xalgorix --restart
sudo xalgorix --stop
sudo xalgorix --uninstall

Ver registros:```bash journalctl -u xalgorix -f

### Acceso remoto al servicio

Exponga el servicio a navegadores remotos solo después de habilitar la autenticación del panel:```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

Luego abre http://<server-ip>:9137.

Si el proceso está escuchando pero la página aún no carga de forma remota, permite el puerto TCP 9137 en el firewall del servidor o en el grupo de seguridad de la nube.

Escaneo de objetivos locales/internos

Por defecto, Xalgorix se niega a escanear loopback, localhost, rangos privados o las direcciones de su propia interfaz: son la máquina en la que se ejecuta Xalgorix, no un objetivo. En un equipo autohospedado y de un solo inquilino puedes optar por escanear una aplicación de demostración/pruebas alojada localmente:```bash echo 'XALGORIX_ALLOW_LOCAL_TARGETS=true' | sudo tee -a /root/.xalgorix.env sudo xalgorix --restart

El propio listener del panel está **siempre** protegido, incluso con esta opción habilitada.

> **⚠️ Despliegues compartidos / multiinquilino / alojados: mantén esta opción DESACTIVADA.** Habilitarla
> permitiría que el escaneo de un usuario llegara a la máquina del operador y a la red interna.
> Está desactivada por defecto, por lo que no se necesita ninguna acción para mantenerse seguro — no establezcas
> `XALGORIX_ALLOW_LOCAL_TARGETS` (o fija `XALGORIX_ALLOW_LOCAL_TARGETS=false`),
> y no expongas la página de Configuración del motor a usuarios no confiables.

## Flujo de trabajo de la interfaz web

1. Abre el panel en `http://127.0.0.1:9137`.
2. Ve a Configuración y confirma el proveedor de LLM, la clave de API, los límites de tasa y las integraciones opcionales.
3. Crea un escaneo desde Nuevo escaneo.
4. Elige un modo de escaneo.
5. Selecciona las fases de metodología cuando quieras una ejecución enfocada.
6. Establece filtros de severidad cuando solo ciertas severidades deban reportarse en vivo. El filtro afecta únicamente al feed del panel en tiempo real y a las notificaciones; el informe PDF y `/api/findings` siempre incluyen todas las vulnerabilidades que el agente descubrió.
7. Añade el nombre de la empresa y sube un logotipo para informes personalizados.
8. Supervisa el progreso desde Vista general, Detalle del escaneo o Feed en vivo.
9. Abre los detalles de los hallazgos, descarga informes o gestiona escaneos históricos desde Escaneos e informes.

## Modos de escaneo

| Modo             | Ideal para                                                                      |
| ---------------- | ------------------------------------------------------------------------------- |
| Objetivo único   | Prueba de una URL u host conocidos.                                             |
| Wildcard / multi | Enumera objetivos relacionados y escanea la superficie de ataque descubierta.   |
| DAST             | Pruebas asistidas por navegador: apps web, flujos auth, formularios y runtime.  |

## Escanea tu código (no se necesita objetivo)

Apunta Xalgorix a una base de código — una URL de Git, una ruta local o un zip subido — y
escanea el código fuente directamente. Sin URL desplegada, sin infraestructura que levantar.```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

• --source acepta una URL de Git (clonado superficial), un directorio local o una ruta a un archivo subido/extraído. En la Web UI / aplicación alojada también puedes subir un .zip de tu código base (POST /api/upload-source).
• Aún puedes combinar un repositorio y un objetivo en vivo para la aumentación clásica de whitebox — esa ruta no cambia. Los modos de escaneo de código son para cuando el código base es todo el sujeto.

El modo provision ejecuta los comandos de compilación/inicio de tu aplicación en el sandbox del agente y solo pentesta el único puerto de loopback en el que levantó la aplicación — el dashboard y todo lo demás en la máquina quedan fuera del alcance.

Metodología

Xalgorix organiza las pruebas autónomas en 22 fases.

La selección de fases en la Web UI te permite ejecutar todas las fases o solo el subconjunto necesario para un encargo específico.

Informes

Los informes se generan como archivos PDF y pueden incluir:

Los informes están disponibles desde la página de detalle del escaneo y la página de Informes. Las filas de informes admiten abrir, descargar y eliminar.

Configuración

La mayoría de los ajustes operativos se pueden cambiar desde la Web UI en Configuración.

Algunos ajustes requieren un reinicio porque afectan el inicio del proceso o el enlace del servidor. La UI marca esos campos.

Variables de Entorno

Núcleo

Web y Seguridad

Integraciones

Límites de Tasa, Proxy y Runtime

Prefijos de Proveedor

Cuando XALGORIX_API_BASE está vacío, Xalgorix infiere los valores predeterminados del proveedor a partir del prefijo del modelo.

Los nombres de modelo no están codificados en esta lista. La página de Configuración acepta IDs de modelo escritos, por lo que los modelos más nuevos del proveedor se pueden usar sin esperar a que se actualice el desplegable de la UI.

Referencia de CLI

Resumen de la API

Almacenamiento de Datos

Los datos de escaneo en modo web se almacenan en:```text ~/xalgorix-data/ |-- _saved/ |-- logos/ |-- queue_state.json -- <target>/ -- / -- <scan-id>/ |-- scan.json -- report.pdf

El servidor guarda registros históricos de escaneos en disco para que la interfaz pueda recuperarse tras una actualización o reinicio.

## Desarrollo

| Tarea                                           | Comando                       |
| ----------------------------------------------- | ------------------------------ |
| Instalar dependencias de la Web UI               | `make webui-install`          |
| Compilar todo                                    | `make build`                  |
| Ejecutar pruebas                                 | `go test ./...`               |
| Ejecutar la Web UI desde el código fuente        | `go run ./cmd/xalgorix --web` |
| Ejecutar el servidor de desarrollo del frontend  | `make webui-dev`              |

## Notas de seguridad

- Utilice Xalgorix únicamente contra objetivos autorizados.
- No realice pruebas activas contra sistemas de terceros sin permiso.
- Revise las instrucciones de escaneo antes de iniciarlo.
- Configure los límites de velocidad y los ajustes de proxy para cumplir con las reglas del compromiso.
- Exponer el panel de control externamente requiere autenticación.
- La autoinstalación está deshabilitada por defecto para usuarios no root y solo debe habilitarse cuando confíe en el entorno.

## Licencia

Xalgorix se distribuye bajo la Licencia Apache 2.0. Consulte [LICENSE](https://github.com/xalgord/xalgorix/blob/HEAD/LICENSE).

## Enlaces

| Recurso       | Enlace                                                                           |
| ------------- | -------------------------------------------------------------------------------- |
| Alojado (nube) | [www.xalgorix.com](https://www.xalgorix.com/)                                   |
| Documentación | [docs.xalgorix.com](https://docs.xalgorix.com)                                   |
| Incidencias   | [github.com/xalgord/xalgorix/issues](https://github.com/xalgord/xalgorix/issues) |
| Soporte       | [buymeacoffee.com/xalgord](https://buymeacoffee.com/xalgord)                     |