New releaseAug 5, 2026
pentest-ai v1.2.0
Pentester IA open source qui prouve chaque découverte. Des oracles machine réexécutent chaque exploit ; les bugs vérifiés livrent une capsule de preuve que vous pouvez rejouer vous-même.
pentest-ai
L'outil de pentest qui prouve ses découvertes. Ni oracle, ni badge.
Site web · Installation · Pourquoi la vérification · Documentation · Benchmarks · Agents · Discord
⚠️ Outillage offensif, tests autorisés uniquement. En installant, vous acceptez la AUP et les Conditions. Texte complet dans Utilisation responsable ↓
ptai est un outil de pentest piloté par l'IA qui ré-exécute chaque exploit pour le confirmer. Il effectue la reconnaissance, se connecte et enchaîne les découvertes en chemins d'attaque multi-étapes, mais il ne vous demande pas de faire confiance aux résultats. De la même manière que TruffleHog confirme un secret divulgué en s'y connectant, ptai confirme une découverte web en ré-exécutant l'exploit : une découverte reste un candidat jusqu'à ce qu'un oracle machine la reproduise N sur N, et c'est seulement à ce moment qu'elle obtient le badge VERIFIED. Les résultats des scanners tiers (nuclei, nikto, zap) sont retenus jusqu'à ce qu'un oracle les re-prouve. Le bruit des scanners est ce qui habitue les équipes à ignorer leurs outils ; le rapport ne contient donc que ce que ptai a pu prouver, chaque découverte VERIFIED accompagnée d'une capsule de preuve portable que vous pouvez rejouer vous-même.
Aujourd'hui, 14 classes de vulnérabilités sont vérifiées par oracle. Sur un honeypot de test volontairement vulnérable, 23 découvertes sont vérifiées dans ces classes avec 100 % de précision et zéro faux positif. Sur un OWASP Juice Shop standard, 12 sont vérifiées en un seul scan. Fonctionne sur votre ordinateur portable. Pas de cloud, pas de télémétrie.
Voyez-le en action
Scan d'un OWASP Juice Shop standard : 12 découvertes vérifiées par oracle en un seul scan. Les découvertes sont réelles ; le rythme est ajusté pour la lisibilité.
Reproduisez vous-même l'idée principale en deux minutes, sans cible personnelle :```bash pip install ptai && ptai demo
`ptai demo` analyse une application vulnérable fournie et signale `4 findings, 4 oracle-VERIFIED`, en rejoue un en direct depuis une capsule de preuve (`replay 3/3`), puis exécute les mêmes routes durcies et signale `0 findings`. La seule différence entre les deux exécutions est le correctif : les résultats apparaissent et disparaissent avec la vulnérabilité, pas parce que l’outil se tait. Deux minutes, aucune clé API, aucune cible personnelle. Re-prouvez vous-même n’importe quelle capsule avec `ptai replay`.
> **Des chiffres honnêtes.** L’exécution du honeypot (23 vérifiés sur 14 classes, précision de 100 %, zéro faux positif) et l’exécution Juice Shop (12 vérifiés en un seul scan) sont des benchmarks reproductibles individuels, pas des taux de faux positifs observés sur le terrain. La validation par oracle garantit la précision, pas le taux de détection : elle supprime les faux positifs, elle n’augmente pas la détection. Juice Shop est l’application vulnérable la plus étudiée d’Internet : lisez donc son volume brut comme une mesure d’étendue et le nombre de résultats vérifiés comme l’histoire de la précision ; le honeypot, avec des bugs que nous avons écrits nous-mêmes, est le signal honnête. Le banc de test honeypot (`tests/honeypot/`) et un contrôle zéro faux positif sur application saine (`tests/cleanapp/`) sont inclus dans le dépôt, de sorte que ces affirmations sont reproductibles plutôt que de simples captures d’écran.
## Nouveautés de la version 1.1.0
La couverture de vérification a environ doublé, et un scan ne signale plus zéro sur une cible qu’il a fait tomber en cours de route. Chaque résultat VERIFIED provient d’un oracle machine nommé, jamais d’une affirmation de LLM, appliqué dans le code : un verdict qui ne peut pas nommer son oracle est rejeté. Cette version ajoute :
- **Dix nouvelles classes d’oracles (14 au total).** Contournement d’en-tête de confiance, JWT `alg:none`, empoisonnement de l’en-tête Host, XXE, confusion de types, XSS stocké, IDOR séquentiel, affectation massive, SSRF non aveugle et contournement de connexion SQLi, qui rejoignent SQLi (booléen/aveugle), BOLA/IDOR, XSS réfléchi, redirection ouverte et traversée de chemin. Chaque oracle dispose d’un contrôle qui doit échouer sur une cible sûre, de sorte qu’une application non vulnérable s’abstient au lieu de gagner un badge.
- **Résilience de la vérification.** Un balayage agressif pouvait faire tomber une cible fragile à conteneur unique, après quoi la phase de vérification échouait pour chaque oracle et rapportait 0 malgré des recettes valides et rejouables. Elle attend désormais que la cible réponde à nouveau avant de re-prouver, ce qui a fait passer un scan OWASP Juice Shop de 0 à 12 résultats vérifiés par oracle.
- **Sécurité du périmètre.** Les outils actifs (sqlmap, dalfox) sont verrouillés sur l’hôte de la cible de l’engagement ; le scan ne transmet plus aux outils d’attaque les URL tierces extraites du contenu d’une page.
- **Capsules de preuve portables** avec `ptai replay`, une TUI en direct qui bascule les verdicts en VERIFIED à l’écran, et un contrôle CI (`--fail-on verified`) qui casse le build uniquement sur des résultats prouvés.
## Sur une cible réelle : OWASP Juice Shop
Pointé sur une instance standard d’OWASP Juice Shop, ptai **vérifie par oracle 12 résultats en un seul scan** : JWT `alg:none` accepté sur les endpoints protégés, lectures BOLA inter-utilisateurs, IDOR séquentiel et confusion de types, chacun re-prouvé par un oracle machine, pas simplement affirmé. Il détecte plus qu’il ne vérifie (contournement d’authentification SQLi sur `/rest/user/login`, SQLi UNION sur `/rest/products/search`, XXE divulguant `/etc/passwd`, affectation massive, contournement de la réinitialisation du mot de passe) ; seul le sous-ensemble vérifié atteint le rapport. Pilotez-le via Claude Code sur MCP sans clé API, ou en mode autonome.
> **Avertissement d’honnêteté.** Juice Shop est l’application vulnérable la plus documentée d’Internet, donc le LLM et les auteurs des sondes partent tous deux avec une longueur d’avance. Face à une nouvelle cible, le taux de détection se limite à ce que couvre la bibliothèque de sondes sélectionnée (plus de 60 sondes web aujourd’hui, qui s’enrichit à chaque version) ; le LLM coordonne et raisonne sur les résultats, il ne remplace pas les sondes. Un banc de test honeypot privé dans `tests/honeypot/` mesure la couverture contre des bugs que nous avons écrits nous-mêmes et est validé en CI (`tests/honeypot/test_mcp_honeypot_e2e.py`) ; ses chiffres sont inférieurs à ceux de Juice Shop, et c’est là tout l’intérêt. Nous publions les deux. Voir la référence complète [benchmark Juice Shop vs ZAP / Nuclei / HexStrike](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md).
## Installation```bash
pip install ptai
Chemin 1 : Pilotez-le depuis Claude Code (sans clé API)
Si vous payez déjà pour Claude Pro / Max / Team, votre abonnement EST le LLM. Branchez ptai en tant que serveur MCP :```bash claude mcp add pentest-ai -- ptai mcp
Redémarrez Claude Code, puis demandez:
> *"Exécutez un test d'intrusion authentifié contre staging.acme.com. La connexion se trouve sur /login, le mot de passe est dans $APP_PASS."*
> **Ce qui touche le réseau** : les outils et sondes de ptai s'exécutent localement contre votre cible. Vos invites et la sortie d'outils que Claude Code lit passent par l'API d'Anthropic, comme pour toute session Claude Code. Si vous avez besoin d'un chemin air-gapped, voir Chemin 3 (Ollama / LLM sur site).
Claude Code pilote ptai via ces outils MCP (47 aujourd'hui) :
- `list_tools` / `run_tool` : lister et invoquer n'importe lequel des 200+ outils de sécurité encapsulés
- `plan_tools` / `ensure_tools_installed` : obtenir la liste canonique des outils pour une mission, installation groupée
- `list_probes` / `run_probe` : 60 sondes compatibles SPA pour les classes de bugs OWASP Top 10
- `http_request` : HTTP brut sous une garde de périmètre stricte pour des chaînes inédites
- `start_engagement` / `get_findings` / `get_attack_chains` : l'enregistrement de la mission
- plus `test_web_app`, `test_active_directory`, `test_cloud`, `test_api_security`, et le reste
### Chemin 2: Autres clients MCP (Cursor, VS Code Copilot, Codex, Claude Desktop)```bash
ptai setup --mcp
Détecte automatiquement chaque client compatible MCP que vous avez installé et écrit leurs fichiers de configuration. Redémarrez le client et les mêmes 47 outils sont là.
Chemin 3 : CLI autonome lorsque vous n'avez pas de client MCP
Si vous utilisez Claude Code, Cursor, Codex ou Claude Desktop, utilisez le Chemin 1 ou 2 ci-dessus et ignorez cette section. Aucune clé API n'est nécessaire dans ce cas.
Le Chemin 3 est destiné aux pipelines CI/CD, aux tâches cron planifiées, aux terminaux hors ligne et aux utilisateurs sans client MCP. La CLI autonome n'a pas de LLM propre, vous devez donc en fournir un via une variable d'environnement :```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
Vous ciblez un endpoint compatible OpenAI (DeepSeek cloud, Groq, Together AI, vLLM, etc.) ? Définissez `OPENAI_BASE_URL` + `PENTEST_AI_MODEL` et utilisez le provider openai. Des recettes complètes pour chaque provider - y compris les noms de modèles personnalisés, le dépannage et la liste LiteLLM-300+ - se trouvent dans [`docs/llm-providers.md`](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/llm-providers.md).
#### Plafond de dépenses (chemin 3 uniquement)
La boucle d'agent autonome pilote son propre LLM, donc les boucles incontrôlées coûtent de l'argent réel. ptai plafonne les dépenses par engagement à **10 $ USD par défaut**. Un balayage d'application web normal avec Sonnet 4.6 et mise en cache des invites se termine bien en dessous ; une exécution approfondie avec Opus 4.7 peut le dépasser.
Modifiez-le via la variable d'environnement (pas de flag CLI - la variable d'environnement est le seul réglage) :```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
Si le plafond se déclenche en cours d'engagement, l'engagement est marqué aborted_cost_limit et son point de contrôle est préservé. Relevez le plafond et reprenez là où il s'est arrêté :```bash
export PTAI_PRICE_LIMIT=25
ptai resume <engagement_id>
Les chemins 1 et 2 (MCP) n'utilisent pas ce plafond - votre client IA (Claude Code, Cursor, etc.) gère sa propre facturation LLM.
### Installation des outils de sécurité
ptai encapsule plus de 200 outils externes. Trois façons de les installer sur la machine :```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
Dans les contextes non interactifs (PTAI_NON_INTERACTIVE=1 ou pas de TTY), ptai utilise ce qui se trouve dans PATH et journalise (plutôt que de demander) pour tout élément manquant.
Autres voies: API REST, composition MCP, téléopération HITL, espace de travail cloud, benchmarks publics
API REST HTTP (pour les tableaux de bord et les intégrations)```bash
pip install ptai[api] ptai serve --port 8888
Points de terminaison : `/health`, `/version`, `/agents`, `/tools`, `/engagements` (liste, détail, constatations, chaînes, règles de détection, export SARIF). Les points de terminaison en écriture (`POST /engagements`, `POST /engagements/{id}/abort`) requièrent `Authorization: Bearer $PENTEST_AI_API_TOKEN`. Flux d'événements en direct sur `WS /engagements/{id}/stream`.
### Charger d'autres serveurs MCP comme sources d'outils
Composez avec hexstrike ou tout autre serveur de sécurité compatible MCP. Modifiez `~/.pentest-ai/mcp_servers.json` :```json
{
"servers": [
{"name": "hexstrike", "command": "python3 hexstrike_mcp.py", "transport": "stdio"}
]
}
Prendre le contrôle en cours de route (téléopération HITL)
Pendant qu'un engagement est en cours, appuyez deux fois sur Ctrl+C en l'espace de 600 ms pour mettre l'orchestrateur en pause et basculer dans un REPL : step, inspect findings, inject <instruction>, skip, resume, abort. Les LLM actuels ne sont pas entièrement autonomes. L'opérateur garde la main quand c'est important.
Benchmarks publics
Les mesures reproductibles du taux de résolution se trouvent dans benchmarks/ :```bash
./benchmarks/scripts/run_all.sh # writes JSON per run + RESULTS.md
Spec, harnais, résultats : tout est dans git. La comparaison complète Juice Shop vs ZAP / Nuclei / HexStrike se trouve dans [`docs/benchmarks/juice-shop.md`](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md). Pas de revendications d'un « taux de détection de 98,7 % » que vous ne pouvez pas vérifier.
### Espace de travail cloud (Pro / Team / Enterprise)
La CLI est gratuite pour toujours et stocke tout en local. Si vous voulez l'historique des engagements, des rapports PDF personnalisés prêts pour les clients et la collaboration en équipe, liez la CLI à un espace de travail [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 synchronise automatiquement les résultats vers votre espace de travail cloud lorsque vous êtes authentifié. Pas de cloud = aucun appel ; l'intégration est silencieusement désactivée à moins que vous ne vous connectiez.
Aucun LLM du tout (lanceur interactif)```bash
ptai menu
Numeric category navigation, search (`/term`), tag filtering (`t web`), keyword-based recommendation. Real engagements still go through `ptai start` with full scope confirmation.
</details>
## Pourquoi c'est différent
| | |
|---|---|
| 🤖 **Coordonné par LLM, pas dépendant du LLM** | Dix-sept agents couvrent recon, web, API, AD, cloud, mobile, wireless, browser, credentials, privesc, vuln scan, chaining, PoC, detection, report, social engineering et LLM red team. Le LLM exécute la boucle de phases et raisonne sur les résultats ; la détection de bugs se trouve dans la bibliothèque de sondes déterministes organisée. Sans clé API, les mêmes sondes s'exécutent. Le LLM coordonne ; il ne scanne pas. |
| 🔓 **Pas de clé API sur le chemin MCP** | Les utilisateurs de Claude Code / Cursor / Codex pilotent ptai via MCP avec leur abonnement existant. Plus de 200 wrappers d'outils et 60 sondes sont appelables par LLM sans clé Anthropic. La CLI autonome (`ptai start --agent-mode`) est là où la clé API compte ; ce sont les chemins Codex-sans-MCP, CI et air-gapped. |
| 🔐 **Il se connecte** | La plupart des scanners échouent à la page de connexion. Celui-ci maintient une session, actualise les identifiants à leur expiration, et chaque outil en aval hérite du cookie. Les profils d'authentification stockent des *références* (variables d'environnement, `op://`, chemins Vault, ARN AWS Secrets Manager), jamais la valeur. |
| 🧪 **Chaque résultat est prouvé** | Une preuve de concept non destructive s'exécute contre la cible. Fini le tri de 40 « peut-être » d'un scanner bruyant. |
| ⚡ **Natif CI** | GitHub Action, seuils de gravité, sortie SARIF, commentaires de PR. Déposez-le dans votre fichier de workflow et il s'exécutera à la prochaine PR. |
| 💾 **S'exécute sur votre ordinateur portable** | Licence MIT, aucun appel cloud. Fonctionne hors ligne avec Ollama. Les résultats restent sur votre disque. |
## Comment ça fonctionne```
┌─────────────────────────────────────────────────────────────┐
│ ptai start <target> │
└─────────────────────────────────────────────────────────────┘
│
┌──────────────────┼──────────────────┐
▼ ▼ ▼
┌────────┐ ┌────────┐ ┌─────────┐
│ recon │ -> │ auth │ -> │ web │
└────────┘ └────────┘ └─────────┘
│
┌────────────────────────────────────┤
▼ ▼
┌────────┐ ┌─────────┐
│ ad │ ┌──────────────────┐ │ cloud │
└────────┘ │ Findings DB │ └─────────┘
│ │ (sqlite + evidence)│ │
└───────▶│ scope-guarded │◀──────┘
│ deduplicated │
└──────────────────┘
│
┌────────────┼────────────┐
▼ ▼ ▼
┌──────┐ ┌─────────┐ ┌──────────┐
│chain │ │validate │ │ detect │
└──────┘ └─────────┘ └──────────┘
│
▼
┌──────────┐
│ report │ md · html · pdf · SARIF · JUnit
└──────────┘
Chaque agent s'exécute avec un LLM lorsque vous avez défini une clé, ou comme une boucle d'outils déterministe dans le cas contraire. Dans les deux cas, l'ordre des phases est le même.
Agents
| Agent | Phase | Fonction |
|---|---|---|
recon | 1 | Scan de ports, énumération DNS et de sous-domaines, empreinte de services |
web | 2 | Passage authentifié du guide de test OWASP v4 |
api_security | 2 | Analyse de surface OpenAPI/GraphQL/REST, OWASP API Top 10 |
browser | 2 | Analyse DOM pilotée par Playwright, capture XHR, évaluation des en-têtes de sécurité |
ad | 3 | Énumération AD, Kerberoasting, recherche de chemins BloodHound, abus de délégation |
cloud | 4 | AWS, Azure, GCP IAM, mauvaise configuration, RBAC K8s, serverless |
credential_tester | 4 | Password spraying, credential stuffing, vérifications de contournement MFA |
privesc | 5 | Conseils d'élévation de privilèges locale et latérale à partir du contexte collecté |
vuln_scanner | 5 | Agrégation transversale des vulnérabilités face à la base de données des constats |
exploit_chain | 6 | Corrèle les constats en chemins d'attaque multi-étapes |
poc_validator | 7 | Preuve de concept non destructive par constat |
detection | 8 | Règles Sigma, SPL, KQL pour l'équipe bleue |
report | 9 | Markdown, HTML, PDF, SARIF, JUnit, cartographies de conformité |
llm_redteam | opt | Sondes OWASP LLM Top 10 |
social_engineer | opt | Corpus de phishing et génération de prétextes |
mobile | opt | Vérifications statiques + dynamiques Android/iOS |
wireless | opt | Reconnaissance sans fil et capture de handshake |
Playbooks
Votre méthodologie sous forme de fichier. Versionnée dans git. Partagée avec votre équipe.```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
[No content provided in the INPUT section. Please provide the Markdown text 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
Cinq playbooks sont inclus par défaut. Un catalogue communautaire arrive.
Intégrez-le à votre 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
Les résultats sont publiés en commentaire de PR, les exports SARIF sont téléversés vers GitHub Code Scanning, et la build échoue en cas de sévérité bloquante. **GitLab CI et Jenkins** : modèles et options avancées (profils d'authentification en CI, seuils de coût, fichiers de périmètre) -> [docs/ci-cd.md](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/ci-cd.md).
## Comparatifs
La conception de ptai est spécialement dédiée au pentest de SPA avec une couverture de sondes organisée. Sur OWASP Juice Shop, la [matrice de 4 outils](https://github.com/0xsteph/pentest-ai/blob/HEAD/docs/benchmarks/juice-shop.md) publiée a montré :
| Outil | Résultats | Critique+Haute | Catégories OWASP Top 10 | Taux de faux positifs |
|---|---:|---:|---:|---:|
| **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 : un seul évaluateur, un seul essai. Méthodologie et artefacts bruts dans [`benchmarks/results/2026-05-12/juice-shop/`](https://github.com/0xsteph/pentest-ai/blob/HEAD/benchmarks/results/2026-05-12/juice-shop/). Lecture honnête : ptai est plus performant sur les pentests web SPA avec une couverture de sondes organisée. HexStrike est plus large (cloud, binaire, CTF) et bat probablement ptai sur les surfaces traditionnelles explorables par crawling, comme WordPress. Les versions futures élargiront la comparaison.
Contexte de recherche récent : les agents de pentest LLM entièrement autonomes terminent **21-31 %** des tâches de bout en bout ; les configurations assistées par un humain atteignent **64 %** (ARTEMIS, DARPA AICC Atlantis, xOffense). ptai est conçu pour le mode assisté par un humain : le LLM raisonne sur les résultats, les sondes organisées détectent, et un double Ctrl+C permet à l'opérateur de reprendre la main.
## Face à la concurrence
| | `ptai` | Hexstrike | ZAP | Nuclei | Burp Pro | PentestGPT |
|---|:-:|:-:|:-:|:-:|:-:|:-:|
| Piloté par LLM via MCP (sans clé API) | ✓ | ✓ | | | | |
| HTTP synthétisé par LLM sous garde-fou de périmètre | ✓ | partiel | | | | |
| Scan authentifié via MCP | ✓ | partiel | partiel | HTTP brut | ✓ | |
| Chaînage d'exploits | ✓ | partiel | | | | partiel |
| Validation de PoC non destructive | ✓ | | | | partiel | |
| Chaînes d'injection stockées (vérification POST -> GET) | ✓ | manuel | partiel | | manuel | |
| Sondes organisées (spécialisées, non pilotées par des templates) | 60 | piloté par wrappers d'outils | piloté par règles | 8000+ templates | manuel + scan | - |
| Outils CLI de sécurité enveloppés | 200+ | 150+ | - | - | - | - |
| Assistant d'installation d'outils | core/recommended/full + par outil | - | n/a | n/a | n/a | - |
| Installation intelligente au début de la mission | ✓ | | | | | |
| Natif CI (SARIF + seuils de sévérité) | ✓ | | partiel | partiel | partiel | |
| Sondes red team LLM | ✓ | | | | | |
| Playbooks YAML | ✓ | | | templates | | |
| Licence | MIT | MIT | Apache-2.0 | MIT | commerciale | MIT |
## Contenu
- **17 agents** couvrant la reconnaissance, le web, la sécurité des API, l'AD, le cloud, le mobile, le sans-fil, le navigateur, le test de mots de passe, l'élévation de privilèges, le scan de vulnérabilités, le chaînage d'exploits, la validation de PoC, la détection, le reporting, la red team LLM et l'ingénierie sociale.
- **60 sondes web organisées** couvrant l'OWASP Top 10 et l'API Top 10.
- **200+ wrappers d'outils** avec installation automatique : 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, et plus encore.
- **4000+ templates Nuclei** intégrés pour la détection atomique de vulnérabilités.
- **47 outils MCP** pour les engagements pilotés par LLM, notamment `plan_tools` / `ensure_tools_installed` qui permettent au LLM externe d'installer des outils par lots sans clé API Anthropic.
- **300+ modèles LLM** via le fournisseur LiteLLM (Anthropic, OpenAI, Ollama en direct ; Azure, OpenRouter, DeepSeek, Groq, Mistral, Together AI, Bedrock, Vertex AI, Cohere via LiteLLM).
- Surface **HTTP REST API + WebSocket** (`ptai serve`) pour les intégrations non-MCP.
- **Tableau de bord web local** avec vue de mission en direct, table des résultats, visualisation des chaînes d'attaque, export SARIF.
- **Agent d'automatisation de navigateur** avec capture d'écran, analyse du DOM, capture réseau, notation des en-têtes de sécurité (piloté par Playwright).
- **Téléopération Human-In-The-Loop** (double Ctrl+C pour reprendre une mission en cours d'exécution).
- **Capacité client MCP** pour charger des serveurs MCP externes comme sources d'outils.
- **Banc de test comparatif public et reproductible** dans `benchmarks/`. Chiffres, code, artefacts bruts, tout dans git.
- **6 formats de sortie** : Markdown, HTML, PDF, SARIF 2.1.0, JUnit XML, correspondances de conformité (OWASP, CWE, CVE, CVSS v3.1).
- **2 400+ tests** avec CI sur Python 3.10, 3.11, 3.12, 3.13.
- **Sous licence MIT**, 100 % vôtre.
## Qui l'utilise et pour quoi
**Équipes AppSec.** Intégrez `ptai` dans votre CI. Chaque PR ciblant la staging reçoit un scan authentifié. La build échoue en cas de résultats de sévérité élevée. La boucle correction -> re-test -> confirmation s'exécute toute seule.
**Consultants.** Préparez une mission d'une semaine, pointez `ptai` sur la liste de cibles, et consacrez votre temps aux parties qui nécessitent un humain : analyser les résultats, choisir les chaînes à démontrer, parler au client. Le rapport s'écrit tout seul.
**Chasseurs de bug bounty.** Lancez-le pendant le petit-déjeuner. Revenez avec une liste de résultats validés avec des PoC prêts à coller dans HackerOne.
**Red teamers.** Encodez votre méthodologie AD sous forme de playbook YAML. Chaque nouvelle mission l'exécute. Même méthodologie, partagée au sein de l'équipe.
**Utilisateurs de Claude Code / Cursor / Codex.** Ajoutez ptai comme serveur MCP. Demandez à votre assistant d'exécuter un scan en anglais simple. Votre abonnement existant paie le LLM ; ptai fournit les outils.
**Développeurs qui livrent des fonctionnalités IA.** Activez `--enable-llm-redteam` contre votre chatbot. Obtenez un rapport OWASP LLM Top 10 en quelques minutes.
## Utilisation responsable
`pentest-ai` est un outil de sécurité offensive. Il exécute de véritables opérations réseau et hôte contre les cibles que vous spécifiez. **Vous êtes seul responsable de vous assurer que vous disposez d'une autorisation écrite explicite pour tester chaque cible.**
En installant ou en exécutant `ptai`, vous acceptez la [Politique d'utilisation acceptable](https://pentestai.xyz/aup) et les [Conditions d'utilisation](https://pentestai.xyz/terms). Tester des systèmes que vous ne possédez pas sans autorisation écrite peut violer le Computer Fraud and Abuse Act, le Computer Misuse Act 1990, l'article 32 du RGPD et les équivalents dans votre juridiction. Une utilisation abusive relève de votre seule responsabilité.
Au premier lancement, il vous demande de confirmer l'acceptation de l'AUP et enregistre ce choix dans `~/.pentest-ai/aup-consent.txt`. Définissez `PENTEST_AI_AUP_ACCEPTED=1` dans le CI pour contourner l'invite de manière non interactive.
Au démarrage, `ptai` charge un fichier de périmètre. Les hôtes hors périmètre sont refusés au moment de l'invocation de l'outil. Les PoC sont non destructifs par défaut. Les limites de débit s'activent automatiquement en mode furtif. Ne soyez pas cette personne.
### Rappels hors bande (OAST) - confidentialité
`ptai` détecte les classes de vulnérabilités aveugles (SSRF aveugle, SQLi aveugle, XXE aveugle, XSS stockée aveugle, SSTI, Log4Shell) en émettant des payloads qui, lorsqu'ils se déclenchent côté serveur, contactent un collaborateur hors bande. Par défaut, les rappels sont routés vers l'infrastructure publique `oast.fun` de ProjectDiscovery.
**Ce qui arrive sur le collaborateur et qui peut le lire.** Chaque engagement génère une paire de clés RSA-2048 fraîche dans votre processus `ptai` local. Les payloads d'interaction (requêtes HTTP brutes, requêtes DNS, enveloppes SMTP reçues par le collaborateur) sont chiffrés en AES-CTR-256 au repos côté serveur, la clé AES étant enveloppée en RSA-OAEP-SHA256 à l'aide de la clé publique de votre engagement. **Seul le détenteur de la clé privée correspondante - votre processus `ptai` local - peut les déchiffrer.** ProjectDiscovery (ou quiconque exécute le collaborateur) ne peut pas lire le contenu des interactions. Cependant, **les métadonnées sont visibles côté serveur** : le fait qu'une interaction a eu lieu, l'IP source de la cible appelante, l'horodatage et le protocole.
**Quand s'auto-héberger.** PortSwigger interdit explicitement l'utilisation du Burp Collaborator public dans ses règles d'engagement des programmes de bug bounty, et les grands programmes d'entreprise (Meta, Apple, finance) exigent de plus en plus que l'infrastructure de rappel aboutisse sur des hôtes contrôlés par le testeur. Pour les engagements rémunérés, exécutez votre propre serveur Interactsh (Apache-2.0, binaire Go unique) et pointez ptai dessus :```bash
ptai start http://target --oast-server https://oast.example.com --oast-token <T>
Pour désactiver complètement OAST :```bash ptai start http://target --no-oast
Les classes de vulnérabilités aveugles ne seront pas détectées lorsque OAST est désactivé ; les voies de détection in-band (delta de taille / marqueurs d'erreur SQL / signatures de métadonnées / basées sur le temps) continuent de fonctionner.
## Écosystème
| Dépôt | Description |
|---|---|
| [**pentest-ai**](https://github.com/0xSteph/pentest-ai) | Ce dépôt. Le serveur CLI et MCP. Produit Python. |
| [**pentest-ai-agents**](https://github.com/0xSteph/pentest-ai-agents) | Fichiers markdown autonomes de sous-agent Claude Code. Optionnel, fonctionne sans cette CLI. |
Besoin d'espaces de travail partagés, de rapports PDF personnalisés, de SSO ou d'un engagement géré ? Le [site web](https://pentestai.xyz) propose des tableaux de bord Pro / Team / Enterprise et une option Launch Engagement ponctuelle. L'outil OSS reste OSS, gratuit pour toujours.
## Communauté
- **Discord :** [rejoignez le serveur](https://discord.gg/6weeTAubJw). Discutez, obtenez de l'aide, partagez vos résultats, ou restez en simple observateur.
- **Questions, idées, retours :** [GitHub Discussions](https://github.com/0xSteph/pentest-ai/discussions)
- **Rapports de bugs :** [GitHub Issues](https://github.com/0xSteph/pentest-ai/issues)
- **Show and tell :** publiez la découverte la plus dingue que `ptai` vous a donnée dans [Show and tell](https://github.com/0xSteph/pentest-ai/discussions/categories/show-and-tell)
## FAQ
**Ai-je besoin d'une clé API ?** Non, pas sur le chemin MCP. Si vous utilisez ptai depuis Claude Code, Cursor, Codex ou Claude Desktop, votre abonnement existant fait office de LLM. Vous n'avez besoin d'une clé que sur la CLI autonome (chemin 3), et même là, vous pouvez tout exécuter en local avec Ollama. Voir [Installation](#install).
**Est-ce vraiment autonome, ou dois-je le surveiller en permanence ?** Vous restez dans la boucle. ptai est coordonné par LLM, pas autonome — les sondes soigneusement sélectionnées font la détection, le LLM raisonne sur les résultats, et la décision finale vous appartient. Appuyez deux fois sur Ctrl+C en cours d'exécution pour reprendre la main. Les agents LLM entièrement autonomes terminent 21 à 31 % des tâches de pentest de bout en bout ; les configurations assistées par un humain atteignent 64 %, et ptai est conçu pour ce second régime.
**Est-il sûr de le pointer vers la production ?** Uniquement avec une autorisation écrite, et uniquement avec les garde-fous activés : `intensity=safe` ignore les sondes qui modifient l'état, `respect_rate_limits` respecte les réponses 429 / Retry-After, et `strict_scope` refuse les requêtes hors hôte et cesse de suivre les redirections. Les trois sont désactivés par défaut, alors activez-les. Voir [Utilisation responsable](#responsible-use).
**Pourquoi le chiffre de Juice Shop est-il élevé mais celui du honeypot plus bas ?** Juice Shop est l'application vulnérable la plus documentée d'Internet, donc le LLM et les auteurs des sondes partent tous deux avec une longueur d'avance. Le honeypot privé mesure des bugs que nous avons écrits nous-mêmes, donc son chiffre est plus bas — et ce chiffre plus bas est le signal honnête. Nous publions les deux. Voir [Benchmarks](#benchmarks).
**Est-ce qu'il fait du phone home ?** Aucune télémétrie, et les résultats restent sur votre disque. Sur le chemin MCP, vos prompts et la sortie de l'outil que votre client IA lit passent par l'API de ce client, comme pour n'importe quelle session. La détection des vulnérabilités aveugles (OAST) envoie des callbacks au service public oast.fun par défaut — le contenu est chiffré à l'aide d'une paire de clés locale, mais le fait qu'un callback ait eu lieu, ainsi que l'IP source et l'horodatage, est visible par celui qui exécute le serveur collaborateur. Auto-hébergez Interactsh ou lancez avec `--no-oast` pour éviter cela. Voir [Utilisation responsable](#responsible-use).
**Combien cela coûte-t-il à faire tourner ?** Sur le chemin MCP, rien au-delà de votre abonnement IA, qui gère sa propre facturation. Sur la CLI autonome, ptai plafonne les dépenses à 10 $ par engagement par défaut ; modifiez-le avec `PTAI_PRICE_LIMIT`. Voir [Installation](#install).
**En quoi est-ce différent du simple fait d'utiliser Claude ou PentestGPT ?** Une bibliothèque de sondes déterministes soigneusement sélectionnées trouve les bugs ; le LLM exécute la boucle de phases et raisonne sur les résultats, il ne scanne pas. C'est pourquoi les résultats sont reproductibles et livrés avec un PoC fonctionnel au lieu d'une supposition du LLM. Voir [Pourquoi c'est différent](#why-its-different) et [vs le reste](#vs-the-field).
## Historique des étoiles
<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>
## Licence
MIT. Faites-en ce que vous voulez.
<div align="center">
**Si `ptai` vous a épargné un dimanche, [mettez une étoile au dépôt](https://github.com/0xSteph/pentest-ai). C'est le seul paiement que je demande.**
</div>