New releaseAug 5, 2026
pentest-ai v1.2.0
Pentester AI open-source che dimostra ogni scoperta. Gli oracoli automatici rieseguono ogni exploit; i bug verificati includono una capsula di prova che puoi riprodurre tu stesso.
pentest-ai
Lo strumento di pentest che dimostra i propri risultati. Niente oracle, niente badge.
Sito web · Installazione · Perché la verifica · Documentazione · Benchmark · Agenti · Discord
⚠️ Strumentazione offensiva, solo test autorizzati. Installando accetti l'AUP e i Termini. Testo completo in Uso responsabile ↓
ptai è uno strumento di pentest basato su IA che riesegue ogni exploit per confermarlo. Esegue la ricognizione, effettua l'accesso e collega i finding in percorsi di attacco multi-step, ma non ti chiede di fidarti dei risultati. Allo stesso modo in cui TruffleHog conferma un segreto divulgato accedendovi, ptai conferma un finding web rieseguendo l'exploit: un finding resta un candidato finché un oracle automatizzato non lo riproduce N volte su N, e solo allora ottiene il badge VERIFIED. L'output degli scanner di terze parti (nuclei, nikto, zap) viene trattenuto finché un oracle non lo riprova. Il rumore degli scanner è ciò che insegna ai team a ignorare i propri strumenti, quindi il report contiene solo ciò che ptai è riuscito a dimostrare, ogni finding VERIFIED con una capsula di prova portabile che puoi riprodurre tu stesso.
Oggi 14 classi di vulnerabilità sono verificate tramite oracle. Su un honeypot di test volutamente vulnerabile, 23 finding vengono verificati in queste classi con precisione al 100% e zero falsi positivi. Su un OWASP Juice Shop standard, 12 si verificano in una singola scansione. Gira sul tuo laptop. Nessun cloud, nessuna telemetria.
Guardalo in azione
Scansione di un OWASP Juice Shop standard: 12 finding verificati tramite oracle in una singola scansione. I finding sono reali; la tempistica è calibrata per renderlo guardabile.
Riproduci tu stesso l'idea centrale in due minuti, senza un target tuo:```bash pip install ptai && ptai demo
`ptai demo` esegue la scansione di un'app vulnerabile inclusa e riporta `4 findings, 4 oracle-VERIFIED`, riproduce una prova dal vivo da una capsula di prova (`replay 3/3`), poi esegue le stesse route in versione indurita e riporta `0 findings`. L'unica cosa cambiata tra le due esecuzioni è la correzione, quindi i riscontri compaiono e scompaiono con la vulnerabilità, non perché lo strumento è rimasto in silenzio. Due minuti, nessuna API key, nessun target tuo. Riprova qualsiasi capsula da solo con `ptai replay`.
> **Numeri onesti.** L'esecuzione sull'honeypot (23 verificati su 14 classi, precisione al 100%, zero falsi positivi) e quella su Juice Shop (12 verificati in una singola scansione) sono benchmark individuali riproducibili, non tassi di falsi positivi sul campo. Il gate degli oracle compra precisione, non tasso di rilevamento: elimina i falsi positivi, non aumenta il rilevamento. Juice Shop è l'app vulnerabile più studiata su internet, quindi leggi il suo volume grezzo come ampiezza e il numero di verificati come la storia della precisione; l'honeypot, con bug scritti da noi, è il segnale onesto. L'harness honeypot (`tests/honeypot/`) e un gate zero-FP su app pulita (`tests/cleanapp/`) sono inclusi nel repository, quindi le affermazioni sono riproducibili, non screenshot.
## Novità nella 1.1.0
La copertura di verifica è circa raddoppiata e una scansione non riporta più zero su un target che ha mandato giù durante l'esecuzione. Ogni riscontro VERIFIED proviene da un oracle macchina nominato, mai da un'affermazione LLM, imposto nel codice: un verdetto che non può nominare il proprio oracle viene rifiutato. Questa release aggiunge:
- **Dieci nuove classi di oracle (14 in totale).** Bypass degli header fidati, JWT `alg:none`, avvelenamento dell'host-header, XXE, type confusion, XSS persistente, IDOR sequenziale, mass assignment, SSRF non-cieco e login-bypass SQLi, che si aggiungono a SQLi (boolean/blind), BOLA/IDOR, XSS riflessa, open redirect e path traversal. Ogni oracle ha un controllo che deve fallire su un target sicuro, così un'app non vulnerabile si astiene invece di guadagnarsi un badge.
- **Resilienza della verifica.** Una scansione aggressiva poteva mettere KO un target fragile a contenitore singolo, dopo di che la fase di verifica faceva fallire ogni oracle e riportava 0 nonostante ricette valide e riproducibili. Ora attende che il target risponda di nuovo prima di riprovare, il che ha portato una scansione di OWASP Juice Shop da 0 a 12 verificati da oracle.
- **Sicurezza dello scope.** Gli strumenti attivi (sqlmap, dalfox) sono vincolati all'host del target dell'engagement; la scansione non passa più URL di terze parti estratti dal contenuto di una pagina agli strumenti di attacco.
- **Capsule di prova portabili** con `ptai replay`, una TUI live che trasforma i verdetti in VERIFIED a schermo, e un gate CI (`--fail-on verified`) che interrompe la build solo su risultati provati.
## Su un target reale: OWASP Juice Shop
Su un'istanza standard di OWASP Juice Shop, ptai **verifica con oracle 12 riscontri in una singola scansione**: JWT `alg:none` accettato su endpoint protetti, letture BOLA cross-user, IDOR sequenziale e type confusion, ciascuno riprovato da un oracle macchina, non affermato. Rileva più di quanto verifichi (auth-bypass SQLi su `/rest/user/login`, UNION SQLi su `/rest/products/search`, XXE che divulga `/etc/passwd`, mass assignment, password-reset bypass); solo il sottoinsieme verificato arriva nel report. Puoi guidarlo tramite Claude Code su MCP senza API key, oppure standalone.
> **Avvertenza onesta.** Juice Shop è l'app vulnerabile più documentata su internet, quindi sia l'LLM sia gli autori delle sonde partono avvantaggiati. Contro un target nuovo, il tasso di rilevamento è ciò che copre la libreria di sonde curata (60+ sonde web oggi, in crescita a ogni release); l'LLM coordina e ragiona sui risultati, non sostituisce le sonde. Un harness honeypot privato in `tests/honeypot/` misura la copertura su bug scritti da noi ed è verificato in CI (`tests/honeypot/test_mcp_honeypot_e2e.py`); i suoi numeri sono inferiori a quelli di Juice Shop, ed è proprio questo il punto. Pubblichiamo entrambi. Vedi il benchmark completo [Juice Shop benchmark vs ZAP / Nuclei / HexStrike](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md).
## Installazione```bash
pip install ptai
Percorso 1: Usalo da Claude Code (senza chiave API)
Se già paghi per Claude Pro / Max / Team, il tuo abbonamento È l'LLM. Collega ptai come server MCP:```bash claude mcp add pentest-ai -- ptai mcp
Restart Claude Code, poi chiedi:
> *"Esegui un pentest autenticato contro staging.acme.com. Il login è su /login, la password è in $APP_PASS."*
> **Cosa raggiunge la rete**: gli strumenti e le probe di ptai vengono eseguiti localmente contro il tuo target. I tuoi prompt e l'output degli strumenti che Claude Code legge passano attraverso l'API di Anthropic, come in qualsiasi sessione di Claude Code. Se hai bisogno di un percorso air-gapped, vedi Percorso 3 (Ollama / LLM on-prem).
Claude Code pilota ptai attraverso questi strumenti MCP (47 oggi):
- `list_tools` / `run_tool`: elenca e invoca uno qualsiasi dei 200+ strumenti di sicurezza incapsulati
- `plan_tools` / `ensure_tools_installed`: ottieni l'elenco canonico degli strumenti per un engagement, installazione batch
- `list_probes` / `run_probe`: 60 probe SPA-aware per le classi di bug OWASP Top 10
- `http_request`: HTTP grezzo sotto una rigida protezione di scope per catene di attacco innovative
- `start_engagement` / `get_findings` / `get_attack_chains`: il registro dell'engagement
- più `test_web_app`, `test_active_directory`, `test_cloud`, `test_api_security`, e tutto il resto
### Percorso 2: Altri client MCP (Cursor, VS Code Copilot, Codex, Claude Desktop)```bash
ptai setup --mcp
Auto-rileva ogni client compatibile con MCP che hai installato e scrive i relativi file di configurazione. Riavvia il client e gli stessi 47 strumenti sono lì.
Percorso 3: CLI standalone quando NON hai un client MCP
Se stai usando Claude Code, Cursor, Codex o Claude Desktop, usa il Percorso 1 o 2 qui sopra e salta questa sezione. Lì non serve alcuna chiave API.
Il Percorso 3 è per pipeline CI/CD, job cron pianificati, terminali air-gapped e utenti senza un client MCP. La CLI standalone non ha un LLM proprio, quindi devi fornirne uno tramite variabile d'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
Stai usando un endpoint compatibile con OpenAI (DeepSeek cloud, Groq, Together AI, vLLM, ecc.)? Imposta `OPENAI_BASE_URL` + `PENTEST_AI_MODEL` e usa il provider openai. Ricette complete per ogni provider - inclusi nomi di modelli personalizzati, risoluzione dei problemi e l'elenco LiteLLM-300+ - si trovano in [`docs/llm-providers.md`](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/llm-providers.md).
#### Limite di spesa (solo Path 3)
Il loop dell'agente standalone gestisce il proprio LLM, quindi i loop fuori controllo costano denaro reale. ptai limita la spesa per engagement a **$10 USD di default**. Una normale scansione di app web con Sonnet 4.6 e prompt caching si mantiene ben al di sotto; una run profonda con Opus 4.7 può superarla ampiamente.
Modificalo tramite variabile d'ambiente (nessun flag CLI - la variabile d'ambiente è l'unico controllo):```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 il limite scatta a metà dell'engagement, l'engagement viene contrassegnato come aborted_cost_limit e il suo checkpoint viene preservato. Aumenta il limite e riprendi da dove si era fermato:```bash
export PTAI_PRICE_LIMIT=25
ptai resume <engagement_id>
I Percorsi 1 e 2 (MCP) non usano questo limite - il tuo client AI (Claude Code, Cursor, ecc.) gestisce la propria fatturazione LLM.
### Installazione degli strumenti di sicurezza
ptai include oltre 200 strumenti esterni. Tre modi per installarli sulla macchina:```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
In contesti non interattivi (PTAI_NON_INTERACTIVE=1 o senza TTY) ptai usa ciò che è nel PATH e registra nei log (invece di chiedere) tutto ciò che manca.
Altri percorsi: REST API, composizione MCP, teleoperazione HITL, workspace cloud, benchmark pubblici
HTTP REST API (per dashboard e integrazioni)```bash
pip install ptai[api] ptai serve --port 8888
Endpoint: `/health`, `/version`, `/agents`, `/tools`, `/engagements` (elenco, dettaglio, findings, catene, regole di rilevamento, esportazione SARIF). Gli endpoint di scrittura (`POST /engagements`, `POST /engagements/{id}/abort`) richiedono `Authorization: Bearer $PENTEST_AI_API_TOKEN`. Stream di eventi live su `WS /engagements/{id}/stream`.
### Caricare altri server MCP come fonti di strumenti
Componi con hexstrike o qualsiasi altro server di sicurezza compatibile con MCP. Modifica `~/.pentest-ai/mcp_servers.json`:```json
{
"servers": [
{"name": "hexstrike", "command": "python3 hexstrike_mcp.py", "transport": "stdio"}
]
}
Subentra a metà esecuzione (teleoperazione HITL)
Mentre un engagement è in esecuzione, premi Ctrl+C due volte entro 600 ms per mettere in pausa l'orchestratore e accedere a una REPL: step, inspect findings, inject <instruction>, skip, resume, abort. Gli LLM attuali non sono completamente autonomi. L'operatore mantiene il controllo quando conta.
Benchmark pubblici
Misurazioni riproducibili del tasso di risoluzione si trovano in benchmarks/:```bash
./benchmarks/scripts/run_all.sh # writes JSON per run + RESULTS.md
Spec, harness e risultati sono tutti in git. Il confronto completo di Juice Shop con ZAP / Nuclei / HexStrike è disponibile in [`docs/benchmarks/juice-shop.md`](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md). Niente affermazioni su un "tasso di rilevamento del 98,7%" che non puoi verificare.
### Workspace cloud (Pro / Team / Enterprise)
La CLI è gratuita per sempre e archivia tutto localmente. Se vuoi la cronologia degli engagement, report PDF personalizzati col tuo marchio pronti per i clienti e collaborazione di team, collega la CLI a un workspace [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 sincronizza automaticamente i risultati nel tuo workspace cloud quando sei autenticato. Niente cloud = nessuna chiamata; l'integrazione è disattivata silenziosamente a meno che tu non acceda.
Nessun LLM (launcher interattivo)```bash
ptai menu
Navigation per categoria numerica, ricerca (`/term`), filtro per tag (`t web`), raccomandazione basata su parole chiave. Le attività reali passano ancora da `ptai start` con conferma completa dell'ambito.
</details>
## Perché è diverso
| | |
|---|---|
| 🤖 **Coordinato da LLM, non dipendente da LLM** | Diciassette agenti coprono ricognizione, web, API, AD, cloud, mobile, wireless, browser, credenziali, privesc, scansione vulnerabilità, concatenamento, PoC, rilevamento, report, ingegneria sociale e red team LLM. L'LLM esegue il ciclo delle fasi e ragiona sui risultati; il rilevamento dei bug è nella libreria di probe deterministiche curata. Se non imposti una chiave API, le stesse probe vengono comunque eseguite. L'LLM coordina; non esegue scansioni. |
| 🔓 **Nessuna chiave API nel percorso MCP** | Gli utenti di Claude Code / Cursor / Codex usano ptai tramite MCP con il loro abbonamento esistente. 200+ wrapper di strumenti e 60 probe sono richiamabili da LLM senza una chiave Anthropic. La CLI standalone (`ptai start --agent-mode`) è dove la chiave API conta; sono i percorsi Codex-senza-MCP, CI e air-gapped. |
| 🔐 **Accede** | La maggior parte degli scanner si ferma alla pagina di login. Questo mantiene una sessione, aggiorna le credenziali quando scadono e ogni strumento a valle eredita il cookie. I profili di autenticazione memorizzano *riferimenti* (variabili d'ambiente, `op://`, percorsi Vault, ARN di AWS Secrets Manager), mai il valore. |
| 🧪 **Ogni riscontro è dimostrato** | Una proof of concept non distruttiva viene eseguita contro il target. Niente più triage di 40 forse da uno scanner rumoroso. |
| ⚡ **Nativo per CI** | GitHub Action, gate di severità, output SARIF, commenti sulle PR. Inseriscilo nel tuo file di workflow e verrà eseguito alla prossima PR. |
| 💾 **Funziona sul tuo laptop** | Licenza MIT, nessuna chiamata al cloud. Funziona offline con Ollama. I riscontri restano sul tuo disco. |
## Come funziona```
┌─────────────────────────────────────────────────────────────┐
│ ptai start <target> │
└─────────────────────────────────────────────────────────────┘
│
┌──────────────────┼──────────────────┐
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌─────────┐
│ recon │ -> │ auth │ -> │ web │
└────────┘ └────────┘ └─────────┘
│
┌────────────────────────────────────┤
▼ ▼
┌────────┐ ┌─────────┐
│ ad │ ┌──────────────────┐ │ cloud │
└────────┘ │ Findings DB │ └─────────┘
│ │ (sqlite + evidence)│ │
└───────▶│ scope-guarded │◀──────┘
│ deduplicated │
└──────────────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
┌──────┐ ┌─────────┐ ┌──────────┐
│chain │ │validate │ │ detect │
└──────┘ └─────────┘ └──────────┘
│
▼
┌──────────┐
│ report │ md · html · pdf · SARIF · JUnit
└──────────┘
Each agent runs with an LLM when you've set a key, or as a deterministic tool loop when you haven't. Either way the phase order is the same.
Agenti
| Agente | Fase | Funzione |
|---|---|---|
recon | 1 | Scansione delle porte, enumerazione DNS e sottodomini, fingerprinting dei servizi |
web | 2 | Pass autenticato di OWASP Testing Guide v4 |
api_security | 2 | Analisi della superficie OpenAPI/GraphQL/REST, OWASP API Top 10 |
browser | 2 | Analisi DOM tramite Playwright, cattura XHR, valutazione degli header di sicurezza |
ad | 3 | Enumerazione AD, Kerberoasting, pathfinding con BloodHound, abuso delle deleghe |
cloud | 4 | AWS, Azure, GCP IAM, misconfigurazioni, K8s RBAC, serverless |
credential_tester | 4 | Password spraying, credential stuffing, controlli di bypass MFA |
privesc | 5 | Consigli per l'escalation dei privilegi locale e laterale basati sul contesto raccolto |
vuln_scanner | 5 | Aggregazione trasversale delle vulnerabilità rispetto al database delle rilevazioni |
exploit_chain | 6 | Correla le rilevazioni in percorsi di attacco a più passaggi |
poc_validator | 7 | Prova di concetto non distruttiva per ogni rilevazione |
detection | 8 | Regole Sigma, SPL e KQL per il blue team |
report | 9 | Markdown, HTML, PDF, SARIF, JUnit, mappe di conformità |
llm_redteam | opt | Sonde OWASP LLM Top 10 |
social_engineer | opt | Generazione di corpus di phishing e pretesti |
mobile | opt | Controlli statici e dinamici Android/iOS |
wireless | opt | Ricognizione wireless e cattura dell'handshake |
Playbook
La tua metodologia come file. Salvata in git. Condivisa con il tuo team.```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
I received no input text to translate. Please provide the chunk content.```bash
ptai playbook list # show installed playbooks
ptai playbook show web-app-quick # preview before running
ptai playbook run ./my-ad.yaml # execute
Cinque playbook sono inclusi. Un catalogo della community è in arrivo.
Inseriscilo nella tua 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
Il design di ptai è appositamente costruito per il pentesting di SPA con una copertura di probe curati. Su OWASP Juice Shop, la [matrice a 4 strumenti](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md) pubblicata ha mostrato:
| Tool | Risultati | Critici+Alti | Bucket OWASP Top 10 | Tasso FP |
|---|---:|---:|---:|---:|
| **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, singolo valutatore, singola esecuzione. Metodologia + artefatti grezzi in [`benchmarks/results/2026-05-12/juice-shop/`](https://github.com/0xsteph/pentest-ai/blob/HEAD/benchmarks/results/2026-05-12/juice-shop/). La lettura onesta: ptai è migliore nei pentest web SPA con copertura di probe curati. HexStrike è più ampio (cloud, binari, CTF) e probabilmente supera ptai sulle superfici tradizionali crawlable come WordPress. Le versioni future amplieranno il confronto.
Contesto di ricerca recente: gli agenti LLM-pentest completamente autonomi completano **21-31%** delle attività end-to-end; le configurazioni assistite dall'uomo raggiungono **64%** (ARTEMIS, DARPA AICC Atlantis, xOffense). ptai è costruito per il regime assistito dall'uomo: l'LLM ragiona sui risultati, i probe curati rilevano, e Ctrl+C due volte consente all'operatore di prendere il controllo.
## Confronto con gli altri strumenti
| | `ptai` | Hexstrike | ZAP | Nuclei | Burp Pro | PentestGPT |
|---|:-:|:-:|:-:|:-:|:-:|:-:|
| LLM-driven via MCP (no API key) | ✓ | ✓ | | | | |
| LLM-synthesized HTTP under scope guard | ✓ | parziale | | | | |
| Scansione autenticata via MCP | ✓ | parziale | parziale | HTTP grezzo | ✓ | |
| Concatenamento exploit | ✓ | parziale | | | | parziale |
| Validazione PoC non distruttiva | ✓ | | | | parziale | |
| Catene di injection stoccate (verifica POST -> GET) | ✓ | manuale | parziale | | manuale | |
| Probe curati (specializzati, non guidati da template) | 60 | guidato da wrapper di strumenti | guidato da regole | 8000+ template | manuale + scansione | - |
| Strumenti CLI wrapperizzati | 200+ | 150+ | - | - | - | - |
| Procedura guidata di installazione strumenti | core/recommended/full + per-tool | - | n/a | n/a | n/a | - |
| Installazione intelligente all'avvio dell'engagement | ✓ | | | | | |
| CI-native (SARIF + gate di severità) | ✓ | | parziale | parziale | parziale | |
| Probe di red team LLM | ✓ | | | | | |
| Playbook YAML | ✓ | | | template | | |
| Licenza | MIT | MIT | Apache-2.0 | MIT | commercial | MIT |
## Cosa contiene
- **17 agent** su recon, web, sicurezza API, AD, cloud, mobile, wireless, browser, test delle credenziali, escalation dei privilegi, scansione vulnerabilità, concatenamento exploit, validazione PoC, rilevamento, reporting, red team LLM, ingegneria sociale
- **60 probe web curati** che coprono OWASP Top 10 + API Top 10
- **200+ wrapper per strumenti** con installazione automatica: nmap, masscan, nuclei, ffuf, sqlmap, gobuster, wapiti, nikto, dalfox, xsstrike, wpscan, hydra, hashcat, enum4linux, bloodhound-python, la suite impacket, trufflehog, gitleaks, kube-hunter, trivy, prowler, scout-suite e altri
- **4000+ template Nuclei** integrati per il rilevamento atomico delle vulnerabilità
- **47 strumenti MCP** per engagement guidati da LLM, inclusi `plan_tools` / `ensure_tools_installed` che consentono all'LLM esterno di installare strumenti in batch senza una chiave API Anthropic
- **300+ modelli LLM** tramite il provider LiteLLM (Anthropic, OpenAI, Ollama diretto; Azure, OpenRouter, DeepSeek, Groq, Mistral, Together AI, Bedrock, Vertex AI, Cohere via LiteLLM)
- **Superficie API REST HTTP + WebSocket** (`ptai serve`) per integrazioni non-MCP
- **Dashboard web locale** con vista engagement in tempo reale, tabella dei risultati, visualizzazione della catena di attacco, esportazione SARIF
- **Agente di automazione browser** con acquisizione screenshot, analisi DOM, cattura rete, valutazione header di sicurezza (guidato da Playwright)
- **Teleoperazione Human-In-The-Loop** (Ctrl+C due volte per assumere il controllo di un engagement a metà esecuzione)
- **Capacità client MCP** per caricare server MCP esterni come sorgenti di strumenti
- **Harness di benchmark pubblico e riproducibile** in `benchmarks/`. Numeri, codice, artefatti grezzi, tutto in git.
- **6 formati di output**: Markdown, HTML, PDF, SARIF 2.1.0, JUnit XML, mapping di conformità (OWASP, CWE, CVE, CVSS v3.1)
- **2,400+ test** con CI su Python 3.10, 3.11, 3.12, 3.13
- **Licenza MIT**, 100% tuo
## Chi lo usa e per cosa
**Team AppSec.** Collega `ptai` alla tua CI. Ogni PR verso staging riceve una scansione autenticata. La build fallisce sui gate di severità. Il ciclo fix -> retest -> conferma gira da solo.
**Consulenti.** Imposta un engagement di una settimana, punta `ptai` sulla lista dei target e dedica il tuo tempo alle parti che richiedono un umano: analisi dei risultati, scelta delle catene da dimostrare, colloquio con il cliente. Il report si scrive da solo.
**Cacciatori di bug bounty.** Eseguilo mentre fai colazione. Torna e trova una lista di risultati validati con PoC pronti da incollare su HackerOne.
**Red teamer.** Codifica la tua metodologia AD come playbook YAML. Ogni nuovo engagement lo esegue. Stessa metodologia, condivisa nel team.
**Utenti di Claude Code / Cursor / Codex.** Aggiungi ptai come server MCP. Chiedi al tuo assistente di eseguire una scansione in linguaggio semplice. L'abbonamento esistente paga l'LLM; ptai fornisce gli strumenti.
**Sviluppatori che rilasciano funzionalità AI.** Abilita `--enable-llm-redteam` contro il tuo chatbot. Ottieni un report OWASP LLM Top 10 in pochi minuti.
## Uso responsabile
`pentest-ai` è uno strumento di sicurezza offensiva. Esegue operazioni reali di rete e host contro i target che specifichi. **Sei l'unico responsabile di assicurarti di avere un'autorizzazione esplicita e scritta per testare ogni target.**
Installando o eseguendo `ptai` accetti la [Politica di utilizzo accettabile](https://pentestai.xyz/aup) e i [Termini di servizio](https://pentestai.xyz/terms). Testare sistemi che non possiedi senza autorizzazione scritta può violare il Computer Fraud and Abuse Act, il Computer Misuse Act 1990, l'Articolo 32 del GDPR e le leggi equivalenti nella tua giurisdizione. L'uso improprio è una tua esclusiva responsabilità.
Al primo avvio ti viene chiesto di confermare l'accettazione dell'AUP e la scelta viene salvata in `~/.pentest-ai/aup-consent.txt`. Imposta `PENTEST_AI_AUP_ACCEPTED=1` in CI per saltare il prompt in modo non interattivo.
All'avvio `ptai` carica un file di scope. Gli host fuori scope vengono rifiutati al momento dell'invocazione dello strumento. I PoC sono non distruttivi per impostazione predefinita. I limiti di frequenza scattano automaticamente in modalità stealth. Non essere quel tipo di persona.
### Callback out-of-band (OAST) - privacy
`ptai` rileva classi di vulnerabilità blind (blind SSRF, blind SQLi, blind XXE, blind stored XSS, SSTI, Log4Shell) emettendo payload che, quando vengono eseguiti lato server, attivano un collaborator out-of-band. Per impostazione predefinita, i callback vengono instradati verso l'infrastruttura pubblica `oast.fun` di ProjectDiscovery.
**Cosa finisce sul collaborator e chi può leggerlo.** Ogni engagement genera una nuova coppia di chiavi RSA-2048 nel tuo processo `ptai` locale. I payload di interazione (richieste HTTP grezze, query DNS, envelope SMTP ricevuti dal collaborator) sono crittografati AES-CTR-256 a riposo lato server, con la chiave AES avvolta in RSA-OAEP-SHA256 usando la chiave pubblica del tuo engagement. **Solo il possessore della chiave privata corrispondente - il tuo processo `ptai` locale - può decrittarli.** ProjectDiscovery (o chiunque gestisca il collaborator) non può leggere i contenuti delle interazioni. Tuttavia, **i metadata sono visibili al server**: il fatto che un'interazione sia avvenuta, l'IP sorgente del target chiamante, il timestamp e il protocollo.
**Quando self-hostare.** PortSwigger vieta esplicitamente l'uso del collaborator pubblico di Burp nelle proprie regole di engagement per il bug bounty, e i grandi programmi enterprise (Meta, Apple, finanza) richiedono sempre più spesso che l'infrastruttura dei callback termini su host controllati dal tester. Per gli engagement retribuiti, esegui il tuo server Interactsh (Apache-2.0, singolo binario Go) e puntaci ptai:```bash
ptai start http://target --oast-server https://oast.example.com --oast-token <T>
Per disabilitare completamente OAST:```bash ptai start http://target --no-oast
Le classi di vulnerabilità blind non verranno rilevate quando OAST è disattivato; i percorsi di rilevamento in-band (delta di dimensione / marcatori di errore SQL / firme di metadati / basati sul tempo) vengono comunque eseguiti.
## Ecosistema
| Repo | Cosa |
|---|---|
| [**pentest-ai**](https://github.com/0xSteph/pentest-ai) | Questo repository. Il server CLI e MCP. Prodotto Python. |
| [**pentest-ai-agents**](https://github.com/0xSteph/pentest-ai-agents) | File markdown subagent standalone per Claude Code. Opzionali, funzionano senza questa CLI. |
Servono spazi di lavoro condivisi, report PDF brandizzati, SSO o un engagement gestito? Il [sito web](https://pentestai.xyz) dispone di dashboard Pro / Team / Enterprise e di un'opzione Launch Engagement one-shot. Lo strumento OSS resta OSS, gratuito per sempre.
## Comunità
- **Discord:** [unisciti al server](https://discord.gg/6weeTAubJw). Chatta, ottieni aiuto, condividi i risultati, fai lurking.
- **Domande, idee, feedback:** [GitHub Discussions](https://github.com/0xSteph/pentest-ai/discussions)
- **Segnalazioni di bug:** [GitHub Issues](https://github.com/0xSteph/pentest-ai/issues)
- **Show and tell:** pubblica la scoperta più assurda che `ptai` ti ha dato in [Show and tell](https://github.com/0xSteph/pentest-ai/discussions/categories/show-and-tell)
## FAQ
**Mi serve una chiave API?** No sul percorso MCP. Se usi ptai da Claude Code, Cursor, Codex o Claude Desktop, il tuo abbonamento esistente è il LLM. Ti serve una chiave solo sulla CLI standalone (Percorso 3), e anche lì puoi eseguire tutto in locale con Ollama. Vedi [Installazione](#install).
**È davvero autonomo, o devo stargli dietro?** Tu resti nel loop. ptai è coordinato da LLM, non autonomo - le sonde curate fanno il rilevamento, l'LLM ragiona sui risultati, e la decisione finale è tua. Premi Ctrl+C due volte a metà esecuzione per prendere il controllo. Gli agenti LLM completamente autonomi completano il 21-31% dei task di pentest end-to-end; le configurazioni assistite da umani raggiungono il 64%, e ptai è progettato per questo secondo regime.
**È sicuro puntarlo verso la produzione?** Solo con autorizzazione scritta, e solo con le protezioni attive: `intensity=safe` salta le sonde che mutano lo stato, `respect_rate_limits` rispetta 429 / Retry-After, e `strict_scope` rifiuta le richieste verso host esterni e smette di seguire i redirect. Tutte e tre sono disattivate di default, quindi attivale. Vedi [Uso responsabile](#responsible-use).
**Perché il numero di Juice Shop è alto ma quello dell'honeypot è più basso?** Juice Shop è l'app vulnerabile più documentata su internet, quindi sia l'LLM che gli autori delle sonde partono avvantaggiati. L'honeypot privato misura i bug che abbiamo scritto noi stessi, quindi il suo numero è più basso - e quel numero più basso è il segnale onesto. Pubblichiamo entrambi. Vedi [Benchmark](#benchmarks).
**Telefona a casa?** Nessuna telemetria, e i risultati restano sul tuo disco. Sul percorso MCP, i tuoi prompt e l'output dello strumento che il tuo client AI legge passano attraverso l'API di quel client, come qualsiasi altra sessione. Il rilevamento delle vulnerabilità blind (OAST) invia callback a oast.fun pubblico di default - i contenuti sono crittografati con una coppia di chiavi locale, ma il fatto che sia avvenuto un callback, insieme all'IP di origine e al timestamp, è visibile a chi gestisce il collaborator. Fai self-hosting di Interactsh o esegui con `--no-oast` per evitarlo. Vedi [Uso responsabile](#responsible-use).
**Quanto costa eseguirlo?** Sul percorso MCP, niente oltre al tuo abbonamento AI, che gestisce la propria fatturazione. Sulla CLI standalone, ptai limita la spesa a $10 per engagement di default; puoi modificarlo con `PTAI_PRICE_LIMIT`. Vedi [Installazione](#install).
**In cosa è diverso dal semplice utilizzo di Claude o PentestGPT?** Una libreria curata di sonde deterministiche trova i bug; l'LLM esegue il ciclo delle fasi e ragiona sui risultati, non scansiona. Ecco perché i risultati sono riproducibili e vengono forniti con un PoC funzionante invece di una supposizione dell'LLM. Vedi [Perché è diverso](#why-its-different) e [vs la concorrenza](#vs-the-field).
## Cronologia delle stelle
<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>
## Licenza
MIT. Fanne quello che vuoi.
<div align="center">
**Se `ptai` ti ha salvato una domenica, [metti una stella al repository](https://github.com/0xSteph/pentest-ai). È l'unico pagamento che chiedo.**
</div>