xalgorix v4.5.124
Agentes autônomos de pentest com IA — reconhecimento em tempo real, detecção de vulnerabilidades e orquestração de exploração. Go + TypeScript.
Xalgorix — Pentester de IA open-source que comprova vulnerabilidades
A maioria dos scanners detecta. A Xalgorix comprova. Um agente LLM autônomo executa uma metodologia completa de pentest e, em seguida, um verificador independente reexplora cada descoberta antes de ela ser reportada — para que você tenha provas, não uma pilha de incertezas para triar. Auto-hospedado, privado e com suporte a trazer seu próprio LLM. Construído em Go + TypeScript.
🚀 Início Rápido · 💡 Por que a Xalgorix · ✨ Recursos · 🎯 Casos de Uso · ☁️ Nuvem Hospedada · 📖 Documentação
🚀 Início Rápido
Instalação (uma linha):```bash curl -sSL https://www.xalgorix.com/install | bash
Isto descarrega o binário pré-compilado para a sua plataforma (Linux amd64/arm64) a partir da versão mais recente. Depois, execute o assistente de configuração interativo:```bash
xalgorix --setup
Escolha seu provedor, confirme um modelo e insira a chave de API quando solicitado. Para obter melhores resultados, use um modelo de fronteira atual com forte raciocínio, desempenho em contexto longo e chamada de ferramentas confiável — como o modelo GPT, Claude ou Gemini mais recente e capaz disponível para você. Modelos menores ou locais continuam sendo suportados, mas podem exigir mais supervisão durante varreduras autônomas longas. O Xalgorix armazena a chave de forma privada em ~/.xalgorix.env (modo 0600) e pode iniciar o painel para você. O Ollama local não precisa de chave de API.
Se você optar por não iniciar imediatamente, comece mais tarde com xalgorix --web e abra http://127.0.0.1:9137. Você pode alterar provedores ou opções avançadas a qualquer momento em Configurações → LLM, ou executar novamente xalgorix --setup.
Ou execute com Docker — baterias incluídas, sem necessidade de toolchain:```bash
docker run --rm -p 9137:9137
--privileged
-v xalgorix-data:/data
xalgord/xalgorix:latest
`--privileged` dá ao conjunto de ferramentas o mesmo acesso semelhante ao host que ele tem quando executado nativamente como root. O sandbox padrão do Docker remove capabilities (como `NET_ADMIN`) e aplica um filtro seccomp, o que quebra ferramentas de baixo nível (alterações de iptables/rotas, ARP-spoof/MITM, VPNs tun/tap, depuradores baseados em ptrace, ajuste de interface do masscan). Como uma imagem não pode conceder essas permissões a si mesma, elas precisam ser definidas em tempo de execução. O contêiner é um sandbox de varredura descartável e isolado de rede, executado como root — privilegiado é a postura pretendida; nunca exponha o painel publicamente sem autenticação. Prefere privilégio mínimo? Troque `--privileged` por `--cap-add=NET_ADMIN --cap-add=NET_RAW --cap-add=SYS_PTRACE --security-opt seccomp=unconfined`.
Abra `http://localhost:9137`. Você **não precisa de uma chave LLM para começar** — o painel inicia sem uma; defina o modelo + a chave da API em **Settings → LLM** (isso persiste no volume `/data`). Se você não passar `XALGORIX_USERNAME`/`XALGORIX_PASSWORD`, uma senha de administrador aleatória é gerada e impressa nos logs do contêiner na primeira execução.
**Mais fácil — Docker Compose** (mapeia a porta + um volume persistente para você):```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
A imagem inclui um extenso conjunto de ferramentas de segurança ofensiva pré-instaladas (nmap, nuclei, httpx, subfinder, katana, ffuf, gobuster, sqlmap, masscan, dalfox, feroxbuster e outras) e mantém todos os gerenciadores de pacotes (apt, go, cargo, pipx, npm) disponíveis para que o agente ainda possa instalar automaticamente qualquer coisa que esteja faltando em tempo de execução. Ela executa como root dentro do contêiner por design — trate o contêiner como uma sandbox de varredura descartável e isolada de rede e nunca exponha o dashboard sem autenticação. (imagem amd64; o instalador acima cobre arm64.)
Ou compilar a partir do código-fonte (requer Go 1.25+ e 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]
> Prefere configuração zero? Uma versão totalmente gerenciada roda em [www.xalgorix.com](https://www.xalgorix.com/) — clique para escanear, sem instalação ou chaves de API necessárias.
### 🤖 Revise pull requests automaticamente — app GitHub gratuito
Quer uma revisão de segurança em cada pull request com zero configuração? Instale o **[Xalgorix GitHub App](https://github.com/apps/xalgorix)**. Ele lê o diff de cada PR e comenta uma revisão de segurança — injeção, autenticação/IDOR quebrados, SSRF, segredos, padrões inseguros — direto no pull request. Atualiza no lugar a cada novo commit, e você pode comentar **`@xalgorix review`** para executar novamente sob demanda. Sem arquivo de workflow, sem chave de API, sem conta — e é gratuito.
<div align="center">
[**➕ Adicionar Xalgorix ao GitHub →**](https://github.com/apps/xalgorix/installations/new)
</div>
Para controle de merge e pentests completos com exploração verificada em CI, use o [scanner hospedado](https://www.xalgorix.com/) ou a GitHub Action.
> [!IMPORTANT]
> Use o Xalgorix apenas em sistemas seus ou para os quais você tenha permissão explícita para testar.
> [!TIP]
> Prefere não fazer self-host? Uma versão totalmente gerenciada está disponível em [www.xalgorix.com](https://www.xalgorix.com/) — clique para escanear, sem instalação ou chaves de API necessárias.
## 📚 Conteúdo
| | | |
| --- | --- | --- |
| 🚀 [Início Rápido](#-quick-start) | 🔩 [Configuração](#-configuration) | 🧾 [Variáveis de Ambiente](#-environment-variables) |
| 🔎 [Visão Geral](#-overview) | 🆙 [Atualização](#-upgrading-from-previous-versions) | 🔤 [Prefixos de Provedor](#-provider-prefixes) |
| 💡 [Por que Xalgorix](#-why-xalgorix) | 🏃 [Execução](#-running) | 💻 [Referência de CLI](#-cli-reference) |
| 🎯 [Casos de Uso](#-use-cases) | 🧰 [Modo Serviço](#-service-mode) | 📡 [Resumo da API](#-api-summary) |
| 📸 [Capturas de Tela](#-screenshots) | 🔁 [Fluxo da Web UI](#-web-ui-workflow) | 💾 [Armazenamento de Dados](#-data-storage) |
| ✨ [Recursos](#-features) | 🔀 [Modos de Escaneamento](#-scan-modes) | 🧪 [Desenvolvimento](#-development) |
| 📥 [Instalação](#-installation) | 📂 [Escanear Seu Código](#-scan-your-code-no-target-needed) | 🚨 [Notas de Segurança](#-safety-notes) |
| 🧭 [Metodologia](#-methodology) | 📄 [Relatórios](#-reports) | 📜 [Licença](#-license) |
| 🔧 [Configurações](#-settings) | 🔗 [Links](#-links) | |
## 🔎 Visão Geral
O Xalgorix é uma plataforma de teste de penetração com IA auto-hospedada para testes de segurança autorizados, avaliação de vulnerabilidades e fluxos de trabalho de bug bounty. Ele combina um agente autônomo orientado por LLM, automação de navegador, ferramentas de terminal, uma metodologia abrangente de teste em 22 fases, telemetria ao vivo via WebSocket, gerenciamento de achados com pontuação CVSS, geração de relatórios PDF com marca e integrações para AgentMail, Discord e Telegram.
Diferente de scanners DAST exclusivamente em nuvem, o Xalgorix roda inteiramente na sua máquina. Você traz seu próprio provedor de LLM (OpenAI, Anthropic, DeepSeek, Gemini, Groq, Ollama, MiniMax) e controla o modelo, o esforço de raciocínio, os limites de taxa e a configuração de proxy. Nenhum dado de escaneamento, chave de API ou informação do alvo sai da sua infraestrutura.
A experiência padrão é a Web UI. De um único painel local, você pode iniciar escaneamentos, monitorar execuções ativas, inspecionar achados, configurar ajustes de modelo/provedor, gerenciar variáveis de ambiente, gerar relatórios PDF com marca e excluir ou retomar escaneamentos históricos.
## 💡 Por que Xalgorix
A maioria dos scanners **detecta**. O Xalgorix **prova**. Um agente autônomo percorre uma metodologia de 22 fases e, em seguida, um verificador independente re-testa cada achado candidato antes de ser reportado — então você obtém resultados verificados por exploração, com evidências, e não uma parede de "talvez" para triagem.
- 🧠 **Um agente de IA, não um mecanismo de templates** — raciocina sobre fluxos de autenticação, lógica de negócio, IDOR/BOLA e explorações encadeadas que scanners de assinatura não veem.
- ✅ **Achados verificados por exploração** — um verificador separado reproduz independentemente cada achado; os inconclusivos são sinalizados para revisão, nunca apresentados como confirmados.
- 🔒 **Auto-hospedado e privado** — roda na sua máquina com sua própria chave de LLM; nenhum dado do alvo, chave ou achado sai da sua infraestrutura.
- 🧩 **Traga seu próprio LLM** — OpenAI, Anthropic, DeepSeek, Gemini, Groq, Ollama ou MiniMax — ou qualquer gateway compatível com OpenAI como [LiteLLM](#-litellm--openai-compatible-gateways-github-copilot-claude-opus-codex-openrouter-azure-local-models) (GitHub Copilot, Codex, OpenRouter, Azure). Você controla o modelo, o esforço de raciocínio e o custo.
- 📄 **Relatórios prontos para auditoria** — PDFs com marca, pontuações CVSS, prova de conceito e remediação.
### 📊 Como ele se compara
| | **Xalgorix** | Template scanners (e.g. Nuclei) | Crawling scanners (e.g. OWASP ZAP) | Commercial DAST |
| -------------------------------------------- | ------------------------ | ------------------------------- | ---------------------------------- | ---------------------- |
| Abordagem | Agente autônomo de IA | Assinaturas / templates | Spider + regras ativas | Assinaturas + heurísticas |
| Cobertura de lógica de negócio / IDOR / bypass de autenticação | ✅ | Limitado | Limitado | Parcial |
| Verificado por exploração (prova o impacto) | ✅ verificador independente | ❌ | ❌ | Parcial |
| Carga de falsos positivos | Baixa (comprovada) | Depende do template | Alta | Média |
| Auto-hospedado / dados permanecem locais | ✅ | ✅ | ✅ | Geralmente em nuvem |
| Traga seu próprio LLM | ✅ | — | — | ❌ |
| Relatórios PDF com marca | ✅ | ❌ | Básico | ✅ |
| Custo | Código aberto + seu LLM | Gratuito | Gratuito | $$$ |
> Comparação direcional — Nuclei e ZAP são excelentes no que fazem. O Xalgorix adiciona a camada de descoberta com uso intenso de raciocínio e verificação de exploração por cima.
Se o Xalgorix economizar um ciclo de triagem para você, por favor **[⭐ dê uma estrela no repositório](https://github.com/xalgord/xalgorix)** — isso realmente ajuda outras pessoas a encontrá-lo.
## 🎯 Casos de Uso
| Caso de Uso | Como o Xalgorix ajuda |
| -------- | ------------------ |
| **Teste de penetração** | Execute uma metodologia completa de 22 fases contra alvos autorizados. O agente de IA cuida de reconhecimento, descoberta de vulnerabilidades, testes de injeção, SSRF, IDOR, bypass de autenticação, condições de corrida e muito mais — depois verifica os achados antes de reportá-los. |
| **Caça a bug bounty** | Aponte o Xalgorix para um alvo dentro do escopo e deixe o agente enumerar a superfície de ataque, testar classes comuns de vulnerabilidade e trazer à tona achados verificados com pontuações CVSS e evidências de prova de conceito. |
| **Operações de red team** | Use os modos de escaneamento com wildcard e multi-alvo para mapear a superfície de ataque externa de uma organização. O DAST assistido por navegador lida com fluxos de autenticação, formulários e comportamento em tempo de execução que scanners estáticos não veem. |
| **Pesquisa de segurança** | A fase de descoberta de vulnerabilidades novas leva o agente além da correspondência de templates conhecidos. Traga seu próprio LLM (OpenAI, Anthropic, DeepSeek, Gemini, Ollama, MiniMax) para controlar a profundidade de raciocínio e o custo. |
| **Teste contínuo de segurança** | Execute como um serviço de sistema com `xalgorix --start`. Escaneie em um agendamento, transmita achados para o Discord ou Telegram e gere relatórios PDF com marca para as partes interessadas. |
| **Automação de DAST** | Testes orientados por navegador para aplicações web — fluxos de autenticação, formulários, conteúdo renderizado por JavaScript e comportamento em tempo de execução. Integra-se com o Caido para inspeção de tráfego via proxy. |
## 📸 Capturas de Tela
**🖥️ Painel auto-hospedado** — roda localmente em `127.0.0.1:9137`
| Painel de visão geral | Detalhe do escaneamento | Achados |
| ------------------------------------------------------- | ------------------------------------------------ | --------------------------------------------- |
|  |  |  |
**☁️ Painel em nuvem hospedado** — a versão totalmente gerenciada em [www.xalgorix.com](https://www.xalgorix.com/)
<img src="https://assets.kitploit.com/production/public/readmes/7609/c636bd5617cb14a03c76f8406506f7400784bab49bf309a12fb2b630ad0f3adb.png" alt="Painel em nuvem hospedado do Xalgorix mostrando créditos de escaneamento, status do plano, contagens de problemas e escaneamentos recentes" width="860" />
## ✨ Recursos
| Área | Capacidades |
| -------------- | --------------------------------------------------------------------------------------------------------------------------- |
| 📊 Painel | Web UI local em `127.0.0.1:9137` por padrão, gerenciamento de escaneamentos, status ao vivo, ações em massa e recuperação de escaneamentos históricos. |
| 🔍 Escaneamento | Fluxos de alvo único, DAST, wildcard e multi-alvo com fases de metodologia selecionáveis. |
| 📡 Telemetria ao vivo | Chamadas de ferramentas, mensagens do agente, achados, erros, atividade HTTP e atividade de LLM via WebSockets. |
| 🐞 Achados | Páginas de detalhe do escaneamento, filtros de severidade, detalhes de CVSS, índice de achados e fluxos de trabalho de achados verificados. |
| 📄 Relatórios | Relatórios PDF com marca, com nome do alvo/empresa, logotipo enviado, lista de relatórios, ações de abrir/baixar/excluir. |
| 🔔 Integrações | Caixas de entrada de teste do AgentMail, e-mails de verificação, fluxos de OTP, eventos de triagem de e-mail, notificações do Discord e do Telegram. |
| ⚙️ Configuração | Configurações do painel para LLM, AgentMail, Discord, Telegram, proxy, runtime, navegador, autenticação, limites de taxa e recursos. |
| 🛡️ Segurança em runtime | Limites de instância cientes de recursos e vínculo somente em loopback, a menos que o acesso externo seja explicitamente configurado com autenticação. |
## 📥 Instalação
Os caminhos mais rápidos não precisam de nenhuma toolchain.
### ⚡ Instalação em uma linha (binário pré-compilado)```bash
curl -sSL https://www.xalgorix.com/install | bash
Downloads the latest release binary for your platform (Linux amd64/arm64) and installs it to /usr/local/bin (or ~/.local/bin without sudo). Override with XALGORIX_INSTALL_DIR or pin a version with XALGORIX_VERSION=vX.Y.Z.
Complete first-time configuration interactively—no manual environment-file editing required:```bash xalgorix --setup
O assistente preserva as configurações existentes quando executado novamente, oculta a entrada da chave de API em um terminal e, opcionalmente, inicia a Web UI quando terminar.
### 🐳 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 (ou o mais restrito --cap-add=NET_ADMIN --cap-add=NET_RAW --cap-add=SYS_PTRACE --security-opt seccomp=unconfined) dá ao conjunto de ferramentas acesso semelhante ao host. A sandbox padrão do Docker remove capabilities e filtra chamadas de sistema, o que quebra ferramentas de baixo nível (iptables/route/alterações de interface, ARP-spoof/MITM, VPNs tun/tap, depuradores baseados em ptrace). Uma imagem não pode conceder isso a si mesma — é uma decisão de tempo de execução — então passe a flag, ou use o docker-compose.yml fornecido, que define isso para você.
A imagem já vem com tudo incluído: um extenso conjunto de ferramentas ofensivas de segurança vem pré-instalado (nmap, nuclei, httpx, subfinder, dnsx, naabu, katana, ffuf, gobuster, dalfox, feroxbuster, sqlmap, masscan, nikto, whatweb, hydra e outros), além do Chromium para DAST assistido por navegador. Ela também mantém disponível o conjunto completo de gerenciadores de pacotes (apt, go, cargo, pipx, npm), para que o agente instale automaticamente qualquer item ausente em tempo de execução. Os dados de varredura persistem no volume /data, e o servidor vincula 0.0.0.0 dentro do contêiner — defina XALGORIX_USERNAME/XALGORIX_PASSWORD antes de expô-lo além do localhost.
O contêiner é executado como root por design (o mecanismo só permite a instalação automática em tempo de execução para uid 0, e as instalações via apt/go/cargo precisam de acesso de escrita no sistema). Trate-o como uma sandbox de varredura descartável e isolada em rede. Ela é publicada para amd64; use o instalador de uma linha para hosts arm64.
Na primeira execução, se você não definir a autenticação do painel, o contêiner gera uma senha de administrador aleatória e a imprime nos logs (a imagem vincula 0.0.0.0, o que o mecanismo não fará sem autenticação). Defina XALGORIX_USERNAME + XALGORIX_PASSWORD (ou XALGORIX_PASSWORD_HASH) para usar as suas próprias credenciais. O binário nunca se auto-atualiza dentro do contêiner (XALGORIX_NO_AUTO_UPDATE=1) — baixe uma nova tag de imagem para atualizar.
📋 Requisitos (compilar a partir do código-fonte)
| Requisito | Notas |
|---|---|
| Linux | Plataforma principal suportada. |
| Go | 1.25 ou mais recente. |
| Node.js + npm | Necessário ao compilar a interface web React empacotada a partir do código-fonte. |
| Ferramentas de segurança | Instaladas sob demanda somente quando a auto-instalação está habilitada. |
Verifique sua versão do Go:```bash go version
### 🔨 Compilar a partir do código-fonte```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 a interface web React para internal/web/static e, em seguida, compila o binário Go.
📦 Instalar com Go```bash
GOPROXY=direct GOSUMDB=off go install github.com/xalgord/xalgorix/v4/cmd/xalgorix@latest
## 🔩 Configuração
Xalgorix carrega a configuração nesta ordem. Fontes posteriores sobrescrevem as anteriores.
| Ordem | Fonte |
| ----- | -------------------------------------------------------------- |
| 1 | `/etc/xalgorix.env` |
| 2 | `/home/<sudo-user>/.xalgorix.env` quando iniciado via `sudo` |
| 3 | `~/.xalgorix.env` |
| 4 | Variáveis de ambiente já presentes no processo |
Crie o arquivo de ambiente local:```bash
nano ~/.xalgorix.env
🧩 Configuração Mínima
Para obter os resultados mais fortes de varredura autônoma, selecione um modelo de fronteira atual. O ID do modelo abaixo é um exemplo concreto; IDs de modelo compatíveis mais recentes podem ser inseridos sem esperar por um lançamento do Xalgorix.```bash XALGORIX_LLM=openai/gpt-5.6 XALGORIX_API_KEY=your_openai_api_key
### 🔌 Exemplos de Provedores
OpenAI:```bash
XALGORIX_LLM=openai/gpt-5.6
XALGORIX_API_KEY=sk-...
Provedor personalizado compatível com OpenAI:```bash XALGORIX_LLM=custom/security-model XALGORIX_API_BASE=https://your-provider.example/v1 XALGORIX_API_KEY=your_provider_api_key
#### 🌉 Gateways compatíveis com LiteLLM / OpenAI (GitHub Copilot, Claude Opus, Codex, OpenRouter, Azure, modelos locais)
Porque `XALGORIX_API_BASE` aceita qualquer endpoint `/v1/chat/completions` compatível com OpenAI,
Xalgorix funciona com um proxy [LiteLLM](https://docs.litellm.ai/) pronto para uso — sem
alterações necessárias no lado do Xalgorix. O LiteLLM trata a autenticação do provedor upstream (login de dispositivo do Copilot,
chaves do Azure, OpenRouter, Ollama, etc.); Xalgorix apenas fala com o gateway via OpenAI.
Execute o LiteLLM (exemplo `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
Aponte o Xalgorix para ele — use o prefixo custom/ para que o nome do modelo seja enviado literalmente e o
protocolo OpenAI chat-completions seja usado:```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
The same pattern covers GitHub Copilot Business/CLI, Claude Opus, Codex-style models,
OpenRouter, Azure OpenAI, and local Ollama models — anything LiteLLM can route. Keep the
`custom/` (or `openai/`) prefix and a non-Anthropic/Gemini `XALGORIX_API_BASE` so Xalgorix
uses the standard OpenAI request shape that LiteLLM expects.
### 🔔 Integrações Opcionais```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
🔐 Autenticação do Painel```bash
XALGORIX_USERNAME=admin XALGORIX_PASSWORD=change-this-password
> [!TIP]
> Prefira `XALGORIX_PASSWORD_HASH` para implantações de produção.
## 🆙 Atualizando a partir de versões anteriores
Esta versão traz uma passada de estabilidade e isolamento do espaço de trabalho, com uma mudança crítica e alguns novos ajustes que valem a pena conhecer.
### 💥 Mudança crítica: o espaço de trabalho padrão mudou para `~/.xalgorix/data/`
A saída de varreduras, notas, agendamentos e outros artefatos gerados agora ficam em `~/.xalgorix/data/` em vez de `$CWD` (o diretório a partir do qual o binário foi iniciado).
Para manter o comportamento anterior, aponte `XALGORIX_DATA_DIR` para o seu diretório de trabalho atual:```bash
export XALGORIX_DATA_DIR=$(pwd)
Um aviso [MIGRATION] é emitido na inicialização quando marcadores legados (notes.json, _schedules/, vulnerabilities.json ou diretórios YYYY-MM-DD/scan-*) são detectados em $CWD e XALGORIX_DATA_DIR não está definida. O Xalgorix nunca lê, copia ou exclui esses arquivos legados automaticamente; o aviso é apenas informativo e é disparado uma única vez por processo.
🆕 Nova variável de ambiente
| Variable | Default | Description |
|---|---|---|
XALGORIX_LLM_MAX_INFLIGHT | 4 × EffectiveMaxInstances | Limita as chamadas LLM de saída simultâneas em todas as varreduras em execução. Mínimo 1. Esperas canceladas não consomem um slot. |
🩺 Novos contadores do endpoint de saúde
GET /api/status agora expõe:
| Field | Meaning |
|---|---|
panics_recovered | Panics de goroutines, handlers HTTP e ferramentas recuperados sem causar falha. |
path_rejections | Escritas no sistema de arquivos recusadas pelo Path_Policy (fora de data_dir / ~/.xalgorix/ / /tmp). |
watchdog_kills | Subprocessos encerrados pelo watchdog de timeout rígido por ferramenta. |
admission_refusals | Solicitações de admissão de varredura negadas devido ao teto de concorrência. |
llm_inflight_cap | Valor efetivo de XALGORIX_LLM_MAX_INFLIGHT para este processo. |
data_dir | Data_Dir resolvido em uso. |
allow_list | Raízes do sistema de arquivos aceitas pelo Path_Policy. |
🏃 Executando
🪟 Interface Web```bash
xalgorix --web
Abrir:```text
http://127.0.0.1:9137
Use uma porta diferente:```bash xalgorix --web --port 8080
### 🌐 Acesso Externo
Vincule a outra interface somente após habilitar a autenticação do painel:```bash
XALGORIX_USERNAME=admin XALGORIX_PASSWORD=change-this xalgorix --web --bind 0.0.0.0
[!WARNING] O servidor recusa ligação externa sem autenticação no painel.
🏹 Varredura CLI```bash
xalgorix --target https://example.com
Com instruções personalizadas:```bash
xalgorix --target https://app.example.com --instruction "Focus on SQL injection, IDOR, and auth bypass. Avoid destructive tests."
🧰 Modo de Serviço
Instale e inicie como um serviço do sistema:```bash sudo xalgorix --start
Gerencie o serviço:```bash
sudo xalgorix --restart
sudo xalgorix --stop
sudo xalgorix --uninstall
Ver logs:```bash journalctl -u xalgorix -f
### 🌍 Acesso Remoto ao Serviço
Exponha o serviço a navegadores remotos somente após ativar a autenticação do painel:```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
Then open http://<server-ip>:9137.
If the process is listening but the page still does not load remotely, allow TCP port 9137 in the server firewall or cloud security group.
🏠 Escaneando alvos locais/internos
Por padrão, o Xalgorix se recusa a escanear loopback, localhost, intervalos privados ou
endereços de sua própria interface — eles são a máquina onde o Xalgorix é executado, não um
alvo. Em uma máquina auto-hospedada, de locatário único, você pode optar por escanear um
aplicativo de demonstração/staging hospedado localmente:```bash
echo 'XALGORIX_ALLOW_LOCAL_TARGETS=true' | sudo tee -a /root/.xalgorix.env
sudo xalgorix --restart
The dashboard's own listener is **always** protected, even with this enabled.
> **⚠️ Shared / multi-tenant / hosted deployments: keep this OFF.** Enabling it
> would let a user's scan reach the operator's own machine and internal network.
> It is off by default, so no action is needed to stay safe — do not set
> `XALGORIX_ALLOW_LOCAL_TARGETS` (or pin `XALGORIX_ALLOW_LOCAL_TARGETS=false`),
> and don't expose the engine's Settings page to untrusted users.
## 🔁 Fluxo de Trabalho da Interface Web
1. Abra o dashboard em `http://127.0.0.1:9137`.
2. Vá em Configurações e confirme o provedor de LLM, chave de API, limites de taxa e integrações opcionais.
3. Crie uma varredura em Nova Varredura.
4. Escolha um modo de varredura.
5. Selecione as fases da metodologia quando quiser uma execução focada.
6. Defina filtros de severidade quando apenas determinadas severidades devem ser relatadas ao vivo. O filtro afeta apenas o feed do dashboard em tempo real e as notificações; o relatório PDF e `/api/findings` sempre incluem todas as vulnerabilidades que o agente descobriu.
7. Adicione o nome da empresa e envie um logotipo para relatórios com marca.
8. Monitore o progresso em Visão Geral, Detalhes da Varredura ou Feed ao Vivo.
9. Abra os detalhes das descobertas, baixe relatórios ou gerencie varreduras históricas em Varreduras e Relatórios.
## 🔀 Modos de Varredura
| Mode | Best for |
| ---------------- | ------------------------------------------------------------------------------- |
| 🎯 Single target | Testing one known URL or host. |
| 🌐 Wildcard / multi | Enumerating related targets and scanning the discovered attack surface. |
| 🧭 DAST | Browser-assisted testing for web apps, auth flows, forms, and runtime behavior. |
## 📂 Varra Seu Código (sem alvo necessário)
Aponte o Xalgorix para uma base de código — uma URL Git, um caminho local ou um zip enviado — e
ele varre o código-fonte diretamente. Sem URL implantada, sem infraestrutura para configurar.```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
| Modo de scan de código | O que faz | Nível de verificação |
|---|---|---|
review | Lê o código-fonte, rastreia a entrada do usuário do ponto de entrada → sink perigoso e relata vulnerabilidades alcançáveis. Sem alvo ativo. | Verificado no código-fonte — comprovadamente alcançável no código (claramente rotulado como não explorado em runtime). |
provision | Inspeciona o repositório, compila e executa o aplicativo em uma porta loopback e executa DAST guiado por whitebox contra a instância em execução. Retorna ao modo review se o aplicativo não puder ser compilado. | Verificado por exploração — reproduzido contra o aplicativo em execução. |
--sourceaceita uma URL Git (clone raso), um diretório local ou um caminho para um arquivo enviado/extraído. Na interface web / aplicativo hospedado, você também pode enviar um.zipdo seu código (POST /api/upload-source).- Você ainda pode combinar um repositório e um alvo ativo para o aumento whitebox clássico — esse caminho permanece inalterado. Os modos de scan de código são para quando o código-fonte é o assunto inteiro.
O modo provision executa os comandos de build/inicialização do seu aplicativo no sandbox do agente e testa apenas a única porta loopback em que o aplicativo foi colocado no ar — o painel e todo o resto na máquina ficam fora do escopo.
🧭 Metodologia
O Xalgorix organiza o teste autônomo em 22 fases.
| Fase | Foco |
|---|---|
| 1 | Reconhecimento |
| 2 | Descoberta manual de vulnerabilidades |
| 3 | Descoberta de diretórios e arquivos |
| 4 | Análise de CORS e cookies |
| 5 | Testes de autenticação e sessão |
| 6 | Testes de injeção |
| 7 | Testes de SSRF |
| 8 | IDOR e controle de acesso quebrado |
| 9 | Testes de API e GraphQL |
| 10 | Testes de upload de arquivos |
| 11 | Desserialização e RCE |
| 12 | Condições de corrida e lógica de negócios |
| 13 | Tomada de subdomínio |
| 14 | Testes de redirecionamento aberto |
| 15 | Testes de segurança de e-mail |
| 16 | Nuvem e infraestrutura |
| 17 | Testes de WebSocket |
| 18 | Testes específicos de CMS |
| 19 | Sequestro de links quebrados e falsificação de conteúdo |
| 20 | Verificação de exploit |
| 21 | Descoberta de vulnerabilidades novas |
| 22 | Relatório final |
A seleção de fase na interface web permite executar todas as fases ou apenas o subconjunto necessário para um engajamento específico.
📄 Relatórios
Os relatórios são gerados como arquivos PDF e podem incluir:
| Seção | Conteúdo incluído |
|---|---|
| 📌 Resumo | Resumo executivo, metadados do alvo, metadados do scan e visão geral de severidade. |
| 🐞 Descobertas | Descobertas verificadas, detalhes de CVSS, análise técnica e prova de exploração. |
| 🔬 Evidências | Comandos de prova de conceito, scripts, notas de payload e observações de suporte. |
| 🩹 Remediação | Orientação de correção e próximos passos priorizados. |
| 🎨 Marca | Nome da empresa/alvo e logotipo enviado. |
Os relatórios estão disponíveis na página de detalhes do scan e na página de Relatórios. As linhas de relatórios oferecem suporte para abrir, baixar e excluir.
🔧 Configurações
A maioria das configurações operacionais pode ser alterada na interface web, em Configurações.
| Área | Exemplos |
|---|---|
| 🤝 Engajamento | Limites de taxa de requisições do painel |
| 🧠 LLM | Modelo, chave de API, base de API, esforço de raciocínio, tentativas, iterações máximas |
| 📬 AgentMail | Pod e chave de API |
| 🔔 Notificações | Webhook do Discord e severidade mínima, token do bot do Telegram, ID do chat e severidade mínima |
| 🕵️ Proxy | URL do proxy, arquivo de proxy, rotação, verificação TLS |
| 🧱 Runtime | Workspace, caminho do navegador, controles de auto-instalação |
| 🔐 Segurança | Nome de usuário do painel, senha, hash de senha, endereço de bind |
| 📈 Recursos | Limites de CPU/RAM/disco e orçamento de concorrência de scans |
Algumas configurações exigem reinicialização porque afetam a inicialização do processo ou o vínculo do servidor. A interface marca esses campos.
🧾 Variáveis de Ambiente
🧱 Núcleo
| Variável | Padrão | Descrição |
|---|---|---|
XALGORIX_LLM | nenhum | ID do modelo nativo do provedor usado para requisições de LLM. |
XALGORIX_LLM_PROVIDER | nenhum | Provedor selecionado pelo painel, armazenado separadamente do ID do modelo. |
XALGORIX_API_KEY | nenhuma | Chave de API obrigatória do provedor de LLM. |
XALGORIX_API_BASE | padrão do provedor | URL base de API personalizada compatível com OpenAI. |
XALGORIX_REASONING_EFFORT | high | Esforço de raciocínio: none, low, medium, high ou xhigh (xhigh mapeia para high no Ollama). |
XALGORIX_OLLAMA_COMPATIBLE | false | Aplicar semântica de raciocínio do Ollama a um endpoint personalizado em uma porta não padrão. A porta 11434 é detectada automaticamente. |
XALGORIX_LLM_MAX_RETRIES | 5 | Número de tentativas para falhas transitórias de LLM. |
XALGORIX_MEMORY_COMPRESSOR_TIMEOUT | 30 | Tempo limite em segundos para compressão de contexto. |
XALGORIX_MAX_ITERATIONS | 0 | Limite de iterações do agente. 0 significa ilimitado. |
GEMINI_API_KEY | nenhuma | Chave Gemini opcional para enriquecimento de pesquisa na web. |
🔒 Web e Segurança
| Variável | Padrão | Descrição |
|---|---|---|
XALGORIX_BIND | 127.0.0.1 | Endereço de escuta do servidor web. |
XALGORIX_ALLOW_LOCAL_TARGETS | false | Permitir o scan de aplicativos hospedados localmente (localhost / 127.0.0.1 / IPs privados) em uma instalação auto-hospedada. O listener do próprio painel está sempre protegido. Mantenha desativado em implantações compartilhadas/hospedadas. |
XALGORIX_USERNAME | nenhum | Nome de usuário do painel. |
XALGORIX_PASSWORD | nenhuma | Senha do painel. |
XALGORIX_PASSWORD_HASH | nenhum | Hash de senha bcrypt preferido. |
XALGORIX_WORKSPACE | diretório atual | Raiz do workspace para execução de scans. |
🤝 Integrações
| Variável | Padrão | Descrição |
|---|---|---|
AGENTMAIL_POD | nenhum | Identificador do pod AgentMail. |
AGENTMAIL_API_KEY | nenhuma | Chave de API do AgentMail. |
XALGORIX_DISCORD_WEBHOOK | nenhum | Webhook global do Discord. |
XALGORIX_DISCORD_MIN_SEVERITY | nenhuma | Severidade mínima enviada ao Discord. |
XALGORIX_TELEGRAM_BOT_TOKEN | nenhum | Token do bot do Telegram do @BotFather. |
XALGORIX_TELEGRAM_CHAT_ID | nenhum | ID do chat/canal do Telegram (numérico ou @username). |
XALGORIX_TELEGRAM_MIN_SEVERITY | nenhuma | Severidade mínima enviada ao Telegram. |
CAIDO_PORT | 0 | Porta do proxy Caido. 0 significa detecção automática. |
CAIDO_API_TOKEN | nenhum | Token de API do Caido. |
🚦 Limites de Taxa, Proxy e Runtime
| Variável | Padrão | Descrição |
|---|---|---|
XALGORIX_RATE_LIMIT_REQUESTS | 60 | Requisições ao painel por janela. |
XALGORIX_RATE_LIMIT_WINDOW | 60 | Janela de limite de taxa do painel em segundos. |
XALGORIX_RATE_RPS | 10 | Taxa sustentada de requisições de saída. |
XALGORIX_RATE_BURST | 20 | Tamanho da rajada de saída. |
XALGORIX_USE_PROXY | false | Habilitar roteamento via proxy. |
XALGORIX_PROXY_URL | nenhuma | URL de proxy única. Substitui o arquivo de proxy. |
XALGORIX_PROXY_FILE | nenhum | Arquivo contendo um proxy por linha. |
XALGORIX_PROXY_ROTATION | roundrobin | Estratégia de rotação de proxy: roundrobin ou random. |
XALGORIX_TLS_SKIP_VERIFY | false | Ignorar verificação TLS para tráfego de teste. |
XALGORIX_DISABLE_BROWSER | false | Desativar automação de navegador. |
XALGORIX_BROWSER_PATH | automático | Caminho personalizado do executável Chrome/Chromium. |
XALGORIX_ALLOW_AUTO_INSTALL | somente root | Permitir instalação automática de pacotes. |
XALGORIX_AUTO_INSTALL_SUDO | false | Permitir auto-instalações prefixadas com sudo. |
🔤 Prefixos de Provedor
Quando XALGORIX_API_BASE está vazio, o Xalgorix infere os padrões do provedor a partir do prefixo do modelo.
| Prefixo | URL base de API padrão |
|---|---|
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 |
Os nomes de modelos não são fixos nesta lista. A página de Configurações aceita IDs de modelo digitados, para que modelos mais novos do provedor possam ser usados sem esperar por uma atualização do menu suspenso da interface.
💻 Referência da CLI
| Flag | Alias | Descrição |
|---|---|---|
--web | -w | Iniciar a interface web. |
--port <port> | -p | Porta da interface web. Padrão: 9137. |
--bind <addr> | nenhum | Endereço de bind. Padrão: 127.0.0.1. |
--target <target> | -t | URL, host, IP ou caminho do alvo. Repetível. |
--instruction <text> | -i | Instruções personalizadas de scan. |
--model <model> | -m | Substitui XALGORIX_LLM nesta execução. |
--update | -up | Atualizar para a versão mais recente. |
--version | -v | Exibir versão. |
--start | nenhum | Instalar e iniciar o serviço do sistema. |
--stop | nenhum | Parar o serviço do sistema. |
--restart | nenhum | Reiniciar o serviço do sistema. |
--uninstall | nenhum | Remover o serviço do sistema. |
--help | -h | Exibir ajuda. |
📡 Resumo da API
| Método | Endpoint | Finalidade |
|---|---|---|
POST | /api/scan | Iniciar ou salvar um scan. |
POST | /api/stop | Parar todos os scans em execução. |
GET | /api/status | Status global atual. |
GET | /api/scans | Listar scans. |
GET | /api/scans/:id | Obter detalhes do scan. |
DELETE | /api/scans/:id | Excluir um scan e seus dados de relatório. |
GET | /api/findings | Listar todas as descobertas (deduplicadas entre scans). |
GET | /api/findings/summary | Contagem de severidade em todos os scans. |
GET | /api/report/:id | Baixar um relatório em PDF. |
GET | /api/instances | Listar instâncias ativas e históricas. |
GET | /api/instances/:id/events | Obter histórico de eventos em buffer. |
POST | /api/instances/:id/stop | Parar uma instância específica. |
POST | /api/instances/:id/start | Iniciar um scan salvo ou concluído como uma nova execução. |
POST | /api/instances/:id/restart | Reiniciar com a mesma configuração. |
POST | /api/instances/:id/pause | Pausar um scan em execução. |
POST | /api/instances/:id/resume | Retomar um scan pausado. |
POST | /api/upload-logo | Enviar um logotipo de relatório. |
POST | /api/upload-targets | Enviar uma lista de alvos. |
GET | /api/settings/environment | Listar configurações de ambiente editáveis. |
POST | /api/settings/environment | Salvar configurações de ambiente. |
GET | /api/settings/llm | Obter configurações de LLM. |
POST | /api/settings/llm | Salvar configurações de LLM. |
GET | /api/settings/agentmail | Obter configurações do AgentMail. |
POST | /api/settings/agentmail | Salvar configurações do AgentMail. |
GET | /ws | Fluxo de eventos ao vivo via WebSocket. |
💾 Armazenamento de Dados
Os dados de scan do modo web são armazenados em:```text
~/xalgorix-data/
|-- _saved/
|-- logos/
|-- queue_state.json
-- <target>/ -- /
-- <scan-id>/ |-- scan.json -- report.pdf
O servidor mantém registros históricos de varreduras em disco para que a UI possa se recuperar após atualização ou reinício.
## 🧪 Desenvolvimento
| Tarefa | Comando |
| --------------------------- | ----------------------------- |
| 📦 Instalar dependências da Web UI | `make webui-install` |
| 🔨 Compilar tudo | `make build` |
| ✅ Executar testes | `go test ./...` |
| 🖥️ Executar Web UI a partir do código-fonte | `go run ./cmd/xalgorix --web` |
| ⚡ Executar servidor de desenvolvimento do frontend | `make webui-dev` |
## 🚨 Notas de Segurança
- Use o Xalgorix apenas contra alvos autorizados.
- Não execute testes ativos contra sistemas de terceiros sem permissão.
- Revise as instruções de varredura antes de iniciar.
- Configure limites de taxa e configurações de proxy para atender às regras de engajamento.
- Expor o painel externamente exige autenticação.
- A instalação automática está desabilitada por padrão para usuários não root e deve ser habilitada apenas quando você confiar no ambiente.
## 📜 Licença
Xalgorix é distribuído sob a Apache License 2.0. Consulte [LICENSE](https://github.com/xalgord/xalgorix/blob/HEAD/LICENSE).
## 🔗 Links
| Recurso | Link |
| ------------- | -------------------------------------------------------------------------------- |
| ☁️ Hospedado (Cloud) | [www.xalgorix.com](https://www.xalgorix.com/) |
| 📖 Documentação | [docs.xalgorix.com](https://docs.xalgorix.com) |
| 🐛 Issues | [github.com/xalgord/xalgorix/issues](https://github.com/xalgord/xalgorix/issues) |
| ☕ Suporte | [buymeacoffee.com/xalgord](https://buymeacoffee.com/xalgord) |