New releaseAug 5, 2026
pentest-ai v1.2.0
Pentester de IA de código aberto que comprova cada descoberta. Oráculos de máquina reexecutam cada exploit; bugs verificados vêm com uma cápsula de prova que você mesmo pode reproduzir.
pentest-ai
A ferramenta de pentest que comprova seus achados. Sem oracle, sem selo.
Site · Instalação · Por que verificação · Documentação · Benchmarks · Agentes · Discord
⚠️ Ferramentas ofensivas, apenas para testes autorizados. Ao instalar, você aceita o AUP e os Termos. Texto completo em Uso responsável ↓
ptai é uma ferramenta de pentest orientada por IA que reexecuta cada exploit para confirmá-lo. Ela executa recon, faz login e encadeia achados em caminhos de ataque de múltiplas etapas, mas não pede que você confie nos resultados. Assim como o TruffleHog confirma um segredo vazado fazendo login com ele, o ptai confirma um achado web reexecutando o exploit: um achado permanece como candidato até que um oracle de máquina o reproduza N de N vezes, e só então ele ganha o selo VERIFIED. A saída de scanners de terceiros (nuclei, nikto, zap) é retida até que um oracle a recomprove. Ruído de scanner é o que treina equipes a ignorar suas ferramentas, então o relatório carrega apenas o que o ptai conseguiu comprovar, cada achado VERIFIED com uma cápsula de prova portátil que você pode reproduzir por conta própria.
Hoje, 14 classes de vulnerabilidade são verificadas por oracle. Em um honeypot de teste deliberadamente vulnerável, 23 achados são verificados nessas classes com 100% de precisão e zero falsos positivos. Em um OWASP Juice Shop padrão, 12 são verificados em um único scan. Roda no seu laptop. Sem nuvem, sem telemetria.
Veja em ação
Escaneando um OWASP Juice Shop padrão: 12 achados verificados por oracle em um único scan. Os achados são reais; o ritmo é ajustado para facilitar a visualização.
Reproduza a ideia central você mesmo em dois minutos, sem precisar de um alvo próprio:```bash pip install ptai && ptai demo
`ptai demo` varre um aplicativo vulnerável incluído e reporta `4 findings, 4 oracle-VERIFIED`, reproduz um ao vivo a partir de uma proof capsule (`replay 3/3`), e então executa as mesmas rotas na versão endurecida e reporta `0 findings`. A única coisa que mudou entre as duas execuções foi a correção, então os findings aparecem e desaparecem junto com a vulnerabilidade, não porque a ferramenta ficou em silêncio. Dois minutos, sem API key, sem alvo próprio. Re-prove qualquer capsule você mesmo com `ptai replay`.
> **Números honestos.** A execução do honeypot (23 verificados em 14 classes, 100% de precisão, zero falsos positivos) e a execução do Juice Shop (12 verificados em uma única varredura) são benchmarks individuais reproduzíveis, não taxas de falsos positivos em campo. O oracle gate compra precisão, não taxa de captura: ele remove falsos positivos, não aumenta a detecção. Juice Shop é o aplicativo vulnerável mais estudado da internet, então leia seu volume bruto como abrangência e a contagem verificada como a história da precisão; o honeypot, com bugs que escrevemos nós mesmos, é o sinal honesto. O harness do honeypot (`tests/honeypot/`) e um gate de zero-FP em aplicativo limpo (`tests/cleanapp/`) estão incluídos no repositório, então as afirmações são reproduzíveis em vez de screenshots.
## O que há de novo na 1.1.0
A cobertura de verificação praticamente dobrou, e uma varredura não reporta mais zero em um alvo que ela derrubou no meio da execução. Todo finding VERIFIED vem de um oracle de máquina nomeado, nunca de uma afirmação de LLM, aplicado em código: um veredito que não consegue nomear seu oracle é rejeitado. Esta versão adiciona:
- **Dez novas classes de oracle (14 no total).** Bypass de trusted header, JWT `alg:none`, envenenamento de host header, XXE, type confusion, XSS armazenado, IDOR sequencial, mass assignment, SSRF não cego e SQLi login-bypass, juntando-se a SQLi (boolean/blind), BOLA/IDOR, XSS refletido, open redirect e path traversal. Cada oracle tem um controle que deve falhar em um alvo seguro, então um aplicativo não vulnerável se abstém em vez de ganhar um badge.
- **Resiliência da verificação.** Uma varredura agressiva poderia derrubar um alvo frágil de contêiner único, após o que a fase de verificação falhava em todos os oracles e reportava 0 apesar de recipes válidos e reproduzíveis. Agora ela espera o alvo responder novamente antes de re-provar, o que levou uma varredura do OWASP Juice Shop de 0 para 12 oracle-verified.
- **Segurança de escopo.** Ferramentas ativas (sqlmap, dalfox) são bloqueadas ao host do alvo do engajamento; a varredura não alimenta mais URLs de terceiros coletados do conteúdo de uma página para ferramentas de ataque.
- **Proof capsules portáveis** com `ptai replay`, uma TUI ao vivo que converte vereditos para VERIFIED na tela, e um gate de CI (`--fail-on verified`) que quebra o build apenas em findings comprovados.
## Em um alvo real: OWASP Juice Shop
Apontado para um OWASP Juice Shop padrão, o ptai **verifica por oracle 12 findings em uma única varredura**: JWT `alg:none` aceito em endpoints protegidos, leituras BOLA entre usuários, IDOR sequencial e type confusion, cada um re-provado por um oracle de máquina, não apenas afirmado. Ele detecta mais do que verifica (bypass de auth SQLi em `/rest/user/login`, SQLi UNION em `/rest/products/search`, XXE divulgando `/etc/passwd`, mass assignment, bypass de redefinição de senha); apenas o subconjunto verificado chega ao relatório. Dirija-o pelo Claude Code via MCP sem API key, ou de forma independente.
> **Ressalva de honestidade.** Juice Shop é o aplicativo vulnerável mais documentado da internet, então tanto o LLM quanto os autores das sondas têm uma vantagem inicial. Contra um alvo novo, a taxa de captura é o que a biblioteca curada de sondas cobre (60+ sondas web hoje, crescendo a cada release); o LLM coordena e raciocina sobre os resultados, ele não substitui as sondas. Um harness honeypot privado em `tests/honeypot/` mede a cobertura contra bugs que escrevemos nós mesmos e é validado em CI (`tests/honeypot/test_mcp_honeypot_e2e.py`); seus números são mais baixos que os do Juice Shop, e é exatamente esse o ponto. Publicamos ambos. Veja o [benchmark completo do Juice Shop vs ZAP / Nuclei / HexStrike](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md).
## Instalação```bash
pip install ptai
Caminho 1: Use-o a partir do Claude Code (sem chave de API)
Se você já paga pelo Claude Pro / Max / Team, sua assinatura É o LLM. Integre o ptai como um servidor MCP:```bash claude mcp add pentest-ai -- ptai mcp
Reinicie o Claude Code e pergunte:
> *"Execute um pentest autenticado contra staging.acme.com. O login está em /login, a senha está em $APP_PASS."*
> **O que vai para a rede**: as ferramentas e sondas do ptai são executadas localmente contra o seu alvo. Seus prompts e a saída das ferramentas que o Claude Code lê passam pela API da Anthropic, como em qualquer sessão do Claude Code. Se precisar de um caminho offline (air-gapped), veja o Caminho 3 (Ollama / LLM on-prem).
O Claude Code controla o ptai por meio destas ferramentas MCP (47 delas hoje):
- `list_tools` / `run_tool`: lista e invoca qualquer uma das mais de 200 ferramentas de segurança incluídas
- `plan_tools` / `ensure_tools_installed`: obtém a lista canônica de ferramentas para um engajamento, instalação em lote
- `list_probes` / `run_probe`: 60 sondas cientes de SPA para classes de bugs do OWASP Top 10
- `http_request`: HTTP bruto sob uma proteção rígida de escopo para cadeias inovadoras
- `start_engagement` / `get_findings` / `get_attack_chains`: o registro do engajamento
- além de `test_web_app`, `test_active_directory`, `test_cloud`, `test_api_security` e o restante
### Caminho 2: Outros clientes MCP (Cursor, VS Code Copilot, Codex, Claude Desktop)```bash
ptai setup --mcp
Detecta automaticamente todos os clientes compatíveis com MCP que você tem instalados e grava os arquivos de configuração deles. Reinicie o cliente e as mesmas 47 ferramentas estarão lá.
Caminho 3: CLI autônoma quando você NÃO tem um cliente MCP
Se você está usando Claude Code, Cursor, Codex ou Claude Desktop, use o Caminho 1 ou 2 acima e pule esta seção. Nenhuma chave de API é necessária lá.
O Caminho 3 é para pipelines de CI/CD, tarefas agendadas em cron, terminais isolados (air-gapped) e usuários sem um cliente MCP. A CLI autônoma não tem LLM próprio, então você fornece um via variável de ambiente:```bash export ANTHROPIC_API_KEY=sk-ant-... # Claude (best results)
or
export OPENAI_API_KEY=sk-... # OpenAI
or, fully local, no cloud
export PENTEST_AI_LLM_PROVIDER=ollama # Ollama (default localhost:11434)
or, any of 300+ models via LiteLLM (OpenRouter, Azure, DeepSeek, Groq, Mistral, ...)
pip install litellm
ptai start https://your-target.com
Acessando um endpoint compatível com OpenAI (DeepSeek cloud, Groq, Together AI, vLLM, etc.)? Defina `OPENAI_BASE_URL` + `PENTEST_AI_MODEL` e use o provedor openai. Receitas completas para cada provedor - incluindo nomes de modelos personalizados, solução de problemas e a lista LiteLLM-300+ - estão em [`docs/llm-providers.md`](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/llm-providers.md).
#### Limite de gastos (somente Path 3)
O loop do agente autônomo usa seu próprio LLM, então loops descontrolados custam dinheiro real. ptai limita o gasto por engajamento a **$10 USD por padrão**. Uma varredura normal de aplicativo web com Sonnet 4.6 com cache de prompt termina muito abaixo disso; uma execução profunda com Opus 4.7 pode ultrapassar esse valor.
Altere-o via variável de ambiente (nenhuma flag de CLI - a variável de ambiente é o único controle):```bash
export PTAI_PRICE_LIMIT=25 # raise to $25
export PTAI_PRICE_LIMIT=0 # unlimited (logs a warning)
unset PTAI_PRICE_LIMIT # back to the $10 default
Se o limite for acionado no meio do engajamento, o engajamento é marcado como aborted_cost_limit e seu checkpoint é preservado. Aumente o limite e retome de onde parou:```bash
export PTAI_PRICE_LIMIT=25
ptai resume <engagement_id>
Os caminhos 1 e 2 (MCP) não usam esse limite - seu cliente de IA (Claude Code, Cursor, etc.) gerencia sua própria cobrança de LLM.
### Instalando ferramentas de segurança
ptai encapsula mais de 200 ferramentas externas. Três maneiras de obtê-las na máquina:```bash
# 1. Zero-config (recommended). At engagement start, the planner predicts
# which tools the LLM will need and asks ONCE to install the missing
# ones. Decline once and the answer persists in
# ~/.pentest-ai/install-preferences.json.
ptai start https://target.example.com
# 2. Batch install upfront. Skips the engagement-time prompt entirely.
ptai setup --tier core # ~6 essentials, ~30s
ptai setup --tier recommended # + fuzzers, crawlers, password tools, ~5m
ptai setup --tier full # everything, ~30m
# 3. Install specific tools by name.
ptai setup --per-tool wpscan,dalfox,paramspider
ptai setup --wizard # interactive picker
Em contextos não interativos (PTAI_NON_INTERACTIVE=1 ou sem TTY), o ptai usa o que está no PATH e registra em log (em vez de solicitar) qualquer item ausente.
Outros caminhos: REST API, composição MCP, teleoperação HITL, workspace em nuvem, benchmarks públicos
HTTP REST API (para dashboards e integrações)```bash
pip install ptai[api] ptai serve --port 8888
Endpoints: `/health`, `/version`, `/agents`, `/tools`, `/engagements` (lista, detalhes, descobertas, cadeias, regras de detecção, exportação SARIF). Endpoints de escrita (`POST /engagements`, `POST /engagements/{id}/abort`) exigem `Authorization: Bearer $PENTEST_AI_API_TOKEN`. Stream de eventos ao vivo em `WS /engagements/{id}/stream`.
### Carregar outros servidores MCP como fontes de ferramentas
Componha com hexstrike ou qualquer outro servidor de segurança compatível com MCP. Edite `~/.pentest-ai/mcp_servers.json`:```json
{
"servers": [
{"name": "hexstrike", "command": "python3 hexstrike_mcp.py", "transport": "stdio"}
]
}
Assumir o controle no meio da execução (teleoperação HITL)
Enquanto um engajamento está em execução, pressione Ctrl+C duas vezes dentro de 600ms para pausar o orquestrador e entrar em um REPL: step, inspect findings, inject <instruction>, skip, resume, abort. Os LLMs atuais não são totalmente autônomos. O operador é quem decide quando importa.
Benchmarks públicos
Medições reproduzíveis de taxa de resolução estão em benchmarks/:```bash
./benchmarks/scripts/run_all.sh # writes JSON per run + RESULTS.md
Spec, harness e resultados, tudo no git. A comparação completa do Juice Shop vs ZAP / Nuclei / HexStrike está em [`docs/benchmarks/juice-shop.md`](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md). Sem alegações de "98,7% de taxa de detecção" que você não possa auditar.
### Workspace em nuvem (Pro / Team / Enterprise)
A CLI é gratuita para sempre e armazena tudo localmente. Se você quiser histórico de engajamentos, relatórios PDF com sua marca prontos para o cliente e colaboração em equipe, vincule a CLI a um workspace do [app.pentestai.xyz](https://app.pentestai.xyz):```bash
# Sign up, then Dashboard -> API Keys -> Generate -> copy ptai_...
ptai auth login # paste the key (hidden prompt)
ptai auth status # confirm link
# or use an env var for CI:
export PENTESTAI_API_KEY=ptai_...
ptai start sincroniza automaticamente as descobertas para o seu workspace na nuvem quando autenticado. Sem nuvem = sem chamadas; a integração fica silenciosamente desativada, a menos que você faça login.
Sem nenhum LLM (launcher interativo)```bash
ptai menu
Navegação numérica por categoria, pesquisa (`/term`), filtragem por tag (`t web`), recomendação baseada em palavras-chave. Engajamentos reais ainda passam por `ptai start` com confirmação completa do escopo.
</details>
## Por que é diferente
| | |
|---|---|
| 🤖 **Coordenado por LLM, não dependente de LLM** | Dezessete agentes cobrem reconhecimento, web, API, AD, nuvem, mobile, wireless, navegador, credenciais, privesc, varredura de vulnerabilidades, encadeamento, PoC, detecção, relatório, engenharia social e red team de LLM. O LLM executa o loop de fases e raciocina sobre os resultados; a detecção de bugs está na biblioteca curada de sondas determinísticas. Sem definir chave de API, as mesmas sondas ainda são executadas. O LLM coordena; não faz varredura. |
| 🔓 **Sem chave de API no caminho MCP** | Usuários do Claude Code / Cursor / Codex conduzem o ptai via MCP usando a assinatura existente deles. Mais de 200 wrappers de ferramentas e 60 sondas podem ser chamados por LLM sem uma chave da Anthropic. A CLI autônoma (`ptai start --agent-mode`) é onde a chave de API importa; esses são os caminhos Codex-sem-MCP, CI e air-gapped. |
| 🔐 **Ele faz login** | A maioria dos scanners morre na página de login. Este mantém uma sessão, renova as credenciais quando elas expiram, e cada ferramenta downstream herda o cookie. Os perfis de autenticação armazenam *referências* (variáveis de ambiente, `op://`, caminhos do Vault, ARNs do AWS Secrets Manager), nunca o valor. |
| 🧪 **Toda descoberta é comprovada** | Uma prova de conceito não destrutiva é executada contra o alvo. Chega de triar 40 incertos de um scanner ruidoso. |
| ⚡ **Nativo de CI** | GitHub Action, limiares de severidade, saída SARIF, comentários em PRs. Coloque-o no seu arquivo de workflow e ele roda no próximo PR. |
| 💾 **Roda no seu laptop** | Licença MIT, sem chamadas de nuvem. Roda offline com Ollama. As descobertas permanecem no seu disco. |
## Como funciona```
┌─────────────────────────────────────────────────────────────┐
│ ptai start <target> │
└─────────────────────────────────────────────────────────────┘
│
┌──────────────────┼──────────────────┐
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌─────────┐
│ recon │ -> │ auth │ -> │ web │
└────────┘ └────────┘ └─────────┘
│
┌────────────────────────────────────┤
▼ ▼
┌────────┐ ┌─────────┐
│ ad │ ┌──────────────────┐ │ cloud │
└────────┘ │ Findings DB │ └─────────┘
│ │ (sqlite + evidence)│ │
└───────▶│ scope-guarded │◀──────┘
│ deduplicated │
└──────────────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
┌──────┐ ┌─────────┐ ┌──────────┐
│chain │ │validate │ │ detect │
└──────┘ └─────────┘ └──────────┘
│
▼
┌──────────┐
│ report │ md · html · pdf · SARIF · JUnit
└──────────┘
Cada agente executa com um LLM quando você definiu uma chave, ou como um loop de ferramentas determinístico quando não definiu. De qualquer forma, a ordem das fases é a mesma.
Agents
| Agent | Phase | Does |
|---|---|---|
recon | 1 | Varredura de portas, enumeração de DNS e subdomínios, fingerprinting de serviços |
web | 2 | Execução autenticada do OWASP Testing Guide v4 |
api_security | 2 | Análise de superfície OpenAPI/GraphQL/REST, OWASP API Top 10 |
browser | 2 | Análise de DOM conduzida por Playwright, captura de XHR, avaliação de cabeçalhos de segurança |
ad | 3 | Enumeração de AD, Kerberoasting, localização de caminhos no BloodHound, abuso de delegação |
cloud | 4 | AWS, Azure, GCP IAM, má configuração, RBAC K8s, serverless |
credential_tester | 4 | Password spraying, credential stuffing, verificações de bypass de MFA |
privesc | 5 | Conselhos de escalonamento de privilégios local e lateral com base no contexto coletado |
vuln_scanner | 5 | Agregação transversal de vulnerabilidades contra o banco de dados de descobertas |
exploit_chain | 6 | Correlaciona descobertas em caminhos de ataque de múltiplas etapas |
poc_validator | 7 | Prova de conceito não destrutiva por descoberta |
detection | 8 | Regras Sigma, SPL e KQL para o blue team |
report | 9 | Markdown, HTML, PDF, SARIF, JUnit, mapas de conformidade |
llm_redteam | opt | Sondas OWASP LLM Top 10 |
social_engineer | opt | Corpus de phishing e geração de pretextos |
mobile | opt | Verificações estáticas + dinâmicas para Android/iOS |
wireless | opt | Reconhecimento wireless e captura de handshake |
Playbooks
Sua metodologia como um arquivo. Salva no git. Compartilhada com sua equipe.```yaml name: internal-ad-pentest inputs: domain: { required: true, prompt: "AD domain" } dc_ip: { required: true, prompt: "DC IP" }
phases:
-
id: recon tools: [nmap, masscan]
-
id: ad-enum depends_on: [recon] condition: "any_finding(type='open_port', port=445)" tools: [enum4linux, ldapsearch, bloodhound-python]
-
id: kerberoast requires_finding: { type: ad_user_enumerated } tools: [impacket-getuserspns] llm_decide: true # let the LLM skip if context says useless
Please provide the Markdown content to translate.```bash
ptai playbook list # show installed playbooks
ptai playbook show web-app-quick # preview before running
ptai playbook run ./my-ad.yaml # execute
Cinco playbooks vêm integrados. Um catálogo da comunidade está a caminho.
Coloque-o no seu CI```yaml
.github/workflows/security.yml
name: Security scan on: [pull_request]
jobs:
ptai:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v4
- run: pip install ptai
- run: |
ptai start ${{ vars.STAGING_URL }}
--ci
--fail-on high
--sarif pentest.sarif
env:
ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
- uses: github/codeql-action/upload-sarif@v3
if: always()
with:
sarif_file: pentest.sarif
Findings post as a PR comment, SARIF uploads to GitHub Code Scanning, and the build fails on gated severity. **GitLab CI and Jenkins** templates plus advanced options (auth profiles in CI, cost gates, scope files) -> [docs/ci-cd.md](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/ci-cd.md).
## Benchmarks
ptai's design is purpose-built for SPA pentesting with curated probe coverage. On OWASP Juice Shop, the published [4-tool matrix](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md) showed:
| Tool | Findings | Critical+High | OWASP Top 10 buckets | FP rate |
|---|---:|---:|---:|---:|
| **ptai 0.13.0** | **88** | **46** | **5** | **0%** |
| ZAP 2.17.0 | 593 | 0 | 1 | 47% |
| Nuclei 3.8.0 | 1 | 0 | 1 | 0% |
| HexStrike v6.0 | 11 | 0 | 1 | - |
n=1 single-rater, single-shot. Methodology + raw artifacts in [`benchmarks/results/2026-05-12/juice-shop/`](https://github.com/0xsteph/pentest-ai/blob/HEAD/benchmarks/results/2026-05-12/juice-shop/). The honest read: ptai is better at SPA web pentests with curated probe coverage. HexStrike is broader (cloud, binary, CTF) and likely beats ptai on traditional crawlable surfaces like WordPress. Future releases will widen the comparison.
Recent research context: fully autonomous LLM-pentest agents finish **21-31%** of tasks end-to-end; human-assisted setups reach **64%** (ARTEMIS, DARPA AICC Atlantis, xOffense). ptai is built for the human-assisted regime: the LLM reasons about results, the curated probes detect, and Ctrl+C twice lets the operator take over.
## vs the field
| | `ptai` | Hexstrike | ZAP | Nuclei | Burp Pro | PentestGPT |
|---|:-:|:-:|:-:|:-:|:-:|:-:|
| LLM-driven via MCP (no API key) | ✓ | ✓ | | | | |
| LLM-synthesized HTTP under scope guard | ✓ | partial | | | | |
| Authenticated scanning via MCP | ✓ | partial | partial | raw HTTP | ✓ | |
| Exploit chaining | ✓ | partial | | | | partial |
| Non-destructive PoC validation | ✓ | | | | partial | |
| Stored injection chains (POST -> GET verify) | ✓ | manual | partial | | manual | |
| Curated probes (specialised, not template-driven) | 60 | tool-wrapper-driven | rule-driven | 8000+ templates | manual + scan | - |
| Wrapped CLI security tools | 200+ | 150+ | - | - | - | - |
| Tool install wizard | core/recommended/full + per-tool | - | n/a | n/a | n/a | - |
| Smart install at engagement start | ✓ | | | | | |
| CI-native (SARIF + severity gates) | ✓ | | partial | partial | partial | |
| LLM red team probes | ✓ | | | | | |
| YAML playbooks | ✓ | | | templates | | |
| License | MIT | MIT | Apache-2.0 | MIT | commercial | MIT |
## What's inside
- **17 agents** across recon, web, API security, AD, cloud, mobile, wireless, browser, credential testing, privilege escalation, vuln scanning, exploit chaining, PoC validation, detection, reporting, LLM red team, social engineering
- **60 curated web probes** covering OWASP Top 10 + API Top 10
- **200+ tool wrappers** with auto-install: nmap, masscan, nuclei, ffuf, sqlmap, gobuster, wapiti, nikto, dalfox, xsstrike, wpscan, hydra, hashcat, enum4linux, bloodhound-python, the impacket suite, trufflehog, gitleaks, kube-hunter, trivy, prowler, scout-suite, and more
- **4000+ Nuclei templates** integrated for atomic vulnerability detection
- **47 MCP tools** for LLM-driven engagements, including `plan_tools` / `ensure_tools_installed` that let the outer LLM batch-install tools without an Anthropic API key
- **300+ LLM models** via the LiteLLM provider (Anthropic, OpenAI, Ollama direct; Azure, OpenRouter, DeepSeek, Groq, Mistral, Together AI, Bedrock, Vertex AI, Cohere via LiteLLM)
- **HTTP REST API + WebSocket** surface (`ptai serve`) for non-MCP integrations
- **Local web dashboard** with live engagement view, findings table, attack chain visualization, SARIF export
- **Browser automation agent** with screenshot capture, DOM analysis, network capture, security header grading (Playwright-driven)
- **Human-In-The-Loop teleoperation** (Ctrl+C twice to take over an engagement mid-run)
- **MCP client** capability to load external MCP servers as tool sources
- **Public reproducible benchmark harness** in `benchmarks/`. Numbers, code, raw artifacts, all in git.
- **6 output formats**: Markdown, HTML, PDF, SARIF 2.1.0, JUnit XML, compliance mappings (OWASP, CWE, CVE, CVSS v3.1)
- **2,400+ tests** with CI on Python 3.10, 3.11, 3.12, 3.13
- **MIT licensed**, 100% yours
## Who uses it for what
**AppSec teams.** Wire `ptai` into your CI. Every PR against staging gets an authenticated scan. The build fails on high-severity findings. The fix -> retest -> confirm loop runs on its own.
**Consultants.** Set up a week-long engagement, point `ptai` at the target list, and spend your time on the parts that need a human: analyzing findings, picking chains to demonstrate, talking to the client. The report writes itself.
**Bug bounty hunters.** Run it over breakfast. Come back to a list of validated findings with PoCs ready to paste into HackerOne.
**Red teamers.** Encode your AD methodology as a YAML playbook. Every new engagement runs it. Same methodology, shared across the team.
**Claude Code / Cursor / Codex users.** Add ptai as an MCP server. Ask your assistant to run a scan in plain English. Your existing subscription pays for the LLM; ptai supplies the tools.
**Developers shipping AI features.** Enable `--enable-llm-redteam` against your chatbot. Get an OWASP LLM Top 10 report in minutes.
## Responsible use
`pentest-ai` is offensive security tooling. It executes real network and host operations against the targets you specify. **You are solely responsible for ensuring you have explicit, written authorization to test every target.**
By installing or running `ptai` you agree to the [Acceptable Use Policy](https://pentestai.xyz/aup) and the [Terms of Service](https://pentestai.xyz/terms). Testing systems you do not own without written authorization may violate the Computer Fraud and Abuse Act, the Computer Misuse Act 1990, GDPR Article 32, and equivalents in your jurisdiction. Misuse is your sole responsibility.
First-run prompts you to confirm AUP acceptance and persists the choice to `~/.pentest-ai/aup-consent.txt`. Set `PENTEST_AI_AUP_ACCEPTED=1` in CI to bypass the prompt non-interactively.
On startup `ptai` loads a scope file. Out-of-scope hosts are refused at tool-invocation time. PoCs are non-destructive by default. Rate limits kick in automatically in stealth mode. Don't be that person.
### Out-of-band callbacks (OAST) - privacy
`ptai` detects blind vulnerability classes (blind SSRF, blind SQLi, blind XXE, blind stored XSS, SSTI, Log4Shell) by emitting payloads that, when fired server-side, ring an out-of-band collaborator. By default, callbacks route to ProjectDiscovery's public `oast.fun` infrastructure.
**What lands on the collaborator and who can read it.** Each engagement generates a fresh RSA-2048 keypair in your local `ptai` process. Interaction payloads (raw HTTP requests, DNS queries, SMTP envelopes received by the collaborator) are AES-CTR-256 encrypted at rest server-side, with the AES key wrapped in RSA-OAEP-SHA256 using your engagement's public key. **Only the holder of the matching private key - your local `ptai` process - can decrypt them.** ProjectDiscovery (or whoever runs the collaborator) cannot read interaction contents. However, **metadata is server-visible**: the fact that an interaction happened, source IP of the calling target, timestamp, and protocol.
**When to self-host.** PortSwigger explicitly forbids public-Burp-Collaborator use in their bug bounty rules of engagement, and large enterprise programs (Meta, Apple, finance) increasingly require that callback infrastructure terminate on tester-controlled hosts. For paid engagements, run your own Interactsh server (Apache-2.0, single Go binary) and point ptai at it:```bash
ptai start http://target --oast-server https://oast.example.com --oast-token <T>
Para desativar completamente o OAST:```bash ptai start http://target --no-oast
Classes de vulnerabilidades cegas não serão detectadas quando o OAST estiver desligado; os caminhos de detecção in-band (delta de tamanho / marcadores de erro SQL / assinaturas de metadados / baseados em tempo) ainda são executados.
## Ecossistema
| Repo | O quê |
|---|---|
| [**pentest-ai**](https://github.com/0xSteph/pentest-ai) | Este repositório. O CLI e o servidor MCP. Produto em Python. |
| [**pentest-ai-agents**](https://github.com/0xSteph/pentest-ai-agents) | Arquivos markdown de subagente do Claude Code independentes. Opcional, funciona sem este CLI. |
Precisa de workspaces compartilhados, relatórios em PDF com sua marca, SSO ou um engajamento gerenciado? O [site](https://pentestai.xyz) tem dashboards Pro / Team / Enterprise e uma opção Launch Engagement de execução única. A ferramenta OSS continua OSS, gratuita para sempre.
## Comunidade
- **Discord:** [entre no servidor](https://discord.gg/6weeTAubJw). Converse, peça ajuda, compartilhe descobertas, apenas observe.
- **Dúvidas, ideias, feedback:** [GitHub Discussions](https://github.com/0xSteph/pentest-ai/discussions)
- **Relatos de bugs:** [GitHub Issues](https://github.com/0xSteph/pentest-ai/issues)
- **Show and tell:** poste a descoberta mais inusitada que o `ptai` te deu em [Show and tell](https://github.com/0xSteph/pentest-ai/discussions/categories/show-and-tell)
## FAQ
**Preciso de uma chave de API?** Não no caminho MCP. Se você usar o ptai pelo Claude Code, Cursor, Codex ou Claude Desktop, sua assinatura existente é o LLM. Você só precisa de uma chave no CLI autônomo (Caminho 3), e mesmo lá pode rodar 100% local com Ollama. Veja [Instalação](#install).
**É realmente autônomo, ou eu fico de babá?** Você permanece no comando. O ptai é coordenado por LLM, não autônomo — as sondas selecionadas fazem a detecção, o LLM raciocina sobre os resultados e a palavra final é sua. Pressione Ctrl+C duas vezes no meio da execução para assumir o controle. Agentes de LLM totalmente autônomos concluem de 21% a 31% das tarefas de pentest de ponta a ponta; configurações com assistência humana chegam a 64%, e o ptai foi feito para esse segundo cenário.
**É seguro apontar para produção?** Somente com autorização por escrito e somente com as salvaguardas ativadas: `intensity=safe` pula sondas que alteram estado, `respect_rate_limits` respeita 429 / Retry-After e `strict_scope` recusa requisições fora do host e para de seguir redirecionamentos. As três vêm desligadas por padrão, então ative-as. Veja [Uso responsável](#responsible-use).
**Por que o número do Juice Shop é alto, mas o do honeypot é menor?** O Juice Shop é o aplicativo vulnerável mais documentado da internet, então tanto o LLM quanto os autores das sondas já saem na frente. O honeypot privado mede bugs que nós mesmos escrevemos, então o número dele é menor — e esse número menor é o sinal honesto. Publicamos ambos. Veja [Benchmarks](#benchmarks).
**Ele faz 'phone home'?** Sem telemetria, e as descobertas ficam no seu disco. No caminho MCP, seus prompts e a saída da ferramenta que seu cliente de IA lê passam pela API desse cliente, como em qualquer sessão. A detecção de vulnerabilidades cegas (OAST) envia callbacks para o público oast.fun por padrão — o conteúdo é criptografado com um par de chaves local, mas o fato de um callback ter ocorrido, além do IP de origem e do timestamp, fica visível para quem opera o servidor colaborador. Auto-hospede o Interactsh ou rode com `--no-oast` para evitar isso. Veja [Uso responsável](#responsible-use).
**Quanto custa para rodar?** No caminho MCP, nada além da sua assinatura de IA, que cuida do próprio faturamento. No CLI autônomo, o ptai limita o gasto em US$ 10 por engajamento por padrão; mude com `PTAI_PRICE_LIMIT`. Veja [Instalação](#install).
**Como isso é diferente de simplesmente usar o Claude ou o PentestGPT?** Uma biblioteca de sondas determinísticas e selecionadas encontra os bugs; o LLM executa o loop de fases e raciocina sobre os resultados, ele não faz a varredura. É por isso que as descobertas se reproduzem e vêm com um PoC funcional em vez de um palpite do LLM. Veja [Por que é diferente](#why-its-different) e [vs a concorrência](#vs-the-field).
## Histórico de estrelas
<a href="https://star-history.com/#0xSteph/pentest-ai&Date">
<img src="https://assets.kitploit.com/production/public/readmes/placeholders/f0fc86cfe65f76d40e15aaec61704ec8220a56dc89d4be03c46f67cb31b9fa8c.svg" alt="Star history chart" width="600">
</a>
## Licença
MIT. Faça o que quiser com ele.
<div align="center">
**Se o `ptai` salvou seu domingo, [dê uma estrela no repositório](https://github.com/0xSteph/pentest-ai). É o único pagamento que peço.**
</div>