Extension Burp Suite pour les tests de sécurité des API avec 15 types d'attaques, 108+ payloads, fuzzing intelligent, détection BOLA/IDOR, intégration IA et reconnaissance automatisée. Prend en charge les API REST/GraphQL/SOAP avec Nuclei, Turbo Intruder et intégration d'outils externes. Couverture OWASP API Top 10.
Si ce projet vous aide dans votre travail, soutenez la maintenance continue et les nouvelles fonctionnalités.
Portefeuille de dons ETH
0x11282eE5726B3370c8B480e321b3B2aA13686582
Scannez le code QR ou copiez l'adresse du portefeuille ci-dessus.
Extension Burp Suite de qualité professionnelle pour une reconnaissance d'API complète, un fuzzing intelligent et des tests de sécurité assistés par IA.
BurpAPISecuritySuite regroupe des fonctionnalités qui nécessiteraient typiquement 10 extensions distinctes en une seule extension optimisée. Ce choix architectural offre des avantages significatifs en termes de performances :
Efficacité mémoire : L'exécution simultanée de plusieurs extensions Burp crée une pression mémoire importante. Chaque extension maintient son propre état, ses composants d'interface utilisateur et ses écouteurs d'événements. Une seule extension avec plusieurs onglets partage efficacement les ressources et réduit l'empreinte mémoire globale.
Overhead API réduit : L'API d'extension de Burp traite les callbacks de toutes les extensions chargées. Avec 10 extensions ou plus, chaque requête HTTP déclenche des callbacks sur toutes les extensions, créant un surcoût multiplicatif. Une seule extension signifie une seule chaîne de callbacks, réduisant considérablement les cycles CPU et améliorant la réactivité.
Contexte partagé : Les onglets intégrés partagent les données de trafic capturées, éliminant les traitements redondants. L'onglet Recon capture une fois, et tous les autres onglets (Fuzzer, Auth Replay, Passive Discovery, etc.) opèrent sur le même ensemble de données sans avoir à analyser à nouveau les requêtes.
Démarrage plus rapide : Charger une seule extension est nettement plus rapide que d'en charger 10 ou plus. Burp initialise les composants d'interface utilisateur, enregistre les callbacks et alloue les ressources une fois au lieu de le faire de manière répétée.
Meilleure stabilité : Moins d'extensions signifie moins de conflits potentiels, d'incompatibilités de versions et de problèmes de compatibilité. Une base de code unique est plus facile à tester, déboguer et maintenir.
Cette philosophie de conception privilégie les performances et l'expérience utilisateur tout en offrant des capacités de test de sécurité d'API complètes qui nécessiteraient autrement une configuration complexe avec plusieurs extensions.
Exécuteur de recherche profonde et de complément calibré pour compléter la couverture Nuclei/HTTPX/Katana.
Remarque : ApiHunter est un outil open-source sous licence MIT et un complément important à BurpAPISecuritySuite. Il fournit des capacités de reconnaissance d'API avancées qui comblent les lacunes laissées par d'autres scanners. Voir https://github.com/Teycir/ApiHunter pour l'installation et l'utilisation.
BurpAPISecuritySuite est une boîte à outils complète pour les tests de sécurité d'API qui :
/users/123 → /users/{id})subfinder + dnsx + httpxBurpAPISecuritySuite.pyRecon pour inspecter les points de terminaison capturés et les résultatsPassive Discovery, cliquez sur Exécuter le différentiel pour les vérifications contrefactuelles sans score, ou Exécuter les invariants pour la pile complète de logique profondeRecon, cliquez sur Actualiser les invariants pour rafraîchir les résultats de différentiel + séquence + golden + matrice d'état + lignée de jetons + dérive de parité avant l'exportationRecon, cliquez sur Exporter le bundle IA pour générer le contexte IA de tous les ongletsexcalibur-burp-bridge/v1 (Excalibur est un outil propriétaire : https://github.com/Teycir/Excalibur)outil, méthode, hôte/chemin, statut, taille, type, tags).Mémoire max est dépassée (par défaut 20 000 lignes).on/off).Valeurs Grep..., , et flux de travail regex sauvegardé ( + filtres sauvegardés).Nom: valeurCopier la/les URL (ou clic droit Copier la/les URL sélectionnée(s)) pour copier les URL complètesRésultat pour classer par sévérité, ou utiliser Trier par sévérité pour un CRITIQUE -> ÉLEVÉ -> MOYEN -> OK rapideTous ou par catégorie de vérifications (API3, API4, API5, API6, API9, API10)Tous les points d'accès, Vue filtrée ou la portée de l'hôte actuelPoint d'accès sélectionné, Vue filtrée ou Tous les points d'accès.Capture proxy/en direct, HAR/Rejeu importé ou analyser les deux ensemble.Tous les sensibles API, Secrets et jetons, PII et financier, Identifiants et session, Exposition infrastructure/interne.apihunter (la détection automatique par défaut recherche dans le PATH d'exécution, puis via des sondes shell (bash -lc et bash -ic) avec command -v, et copie le chemin absolu trouvé ; aucun candidat de secours statique)Run ApiHunter, la suite résout à nouveau apihunter depuis le PATH (processus + sonde shell) et met à jour automatiquement le champ vers le chemin absolu résolu lorsqu'il est disponibleRapide (Préréglage Bureau), Équilibré (Préréglage Bureau) (par défaut), Approfondi (Préréglage Bureau)Non authentifié uniquement, , (par défaut). En mode double passage, les URL de base dédupliquées sont divisées en listes de cibles et ; chaque passage s'exécute sur sa propre liste. L'association auth utilise à la fois les en-têtes d'authentification de requête et les signaux d'authentification non-en-tête (, marqueurs de jeton/cookie/session dans les métadonnées de requête).Non authentifié uniquement, Authentifié uniquement, Authentifié + Non authentifié (par défaut). En mode double passage, les URL de base dédupliquées sont divisées en listes de cibles associées à l'authentification et non associées à l'authentification ; chaque passage s'exécute sur sa propre liste. L'association auth utilise à la fois les en-têtes d'authentification de requête et les signaux d'authentification non-en-tête (auth_detected, marqueurs de jeton/cookie/session dans les métadonnées de requête). La dérivation du contexte auth capture le meilleur en-tête Authorization disponible, les meilleurs en-têtes de type auth (X-API-Key, Api-Key, ApiKey, X-Auth-Token, X-Access-Token), et dérive les paires de cookies des en-têtes de la requête.kr.kite local ou un alias Assetnote tel que apiroutes-260227:20000Rapide, Équilibré, Approfondi, avec Équilibré sélectionné par défaut pour une couverture plus large au premier passage ; Rapide conserve un plafond plus serré de 10 minutes pour un triage plus rapide et Approfondi passe un plafond de 15 minutes sur moins d'hôtes avec des scans plus completsCibles personnalisées... au lieu de la portée filtrée par Reconmax 20 entrées, une par ligne) avec un assainissement strict et une normalisation canonique des URL de base ()sqlmap localRapide, Équilibré, Approfondidalfox localRapide, Équilibré, ApprofondiRapide, Équilibré, Approfondi pour subfinder/dnsx/httpxsubfinder → dnsx → httpx pour la découverte d'actifs API vivantsBOLA (Broken Object Level Authorization)
IDOR (Insecure Direct Object Reference)
Injection SQL
XSS (Cross-Site Scripting)
Injection NoSQL
Exploitation JWT
Abus GraphQL
SSTI (Server-Side Template Injection)
Conditions de concurrence
Logique métier
Contournement WAF
{ "metadata": { "timestamp": "20240115_143022", "total_endpoints": 15, "total_requests": 47 }, "endpoints": [ { "endpoint": "GET:/api/users/{id}", "method": "GET", "normalized_path": "/api/users/{id}", "host": "api.example.com", "sample_count": 3, "parameters": { "url": ["id"], "body": [], "cookie": ["session"], "json": [] }, "auth_methods": ["Bearer Token"], "response_codes": [200, 404], "content_types": ["application/json"], "api_patterns": ["REST API", "JSON API", "CRUD: GET"], "sample_requests": [...] } ], "api_structure": { "api_types": ["REST API", "JSON API"], "http_methods": ["GET", "POST", "PUT", "DELETE"], "auth_methods": ["Bearer Token", "API Key"], "base_paths": ["/api/", "/v1/"] }, "security_observations": [ { "type": "Potential IDOR/BOLA", "severity": "Critical", "count": 5, "examples": ["GET:/api/users/{id}", "GET:/api/orders/{id}"], "recommendation": "Implement object-level authorization checks" }, { "type": "Unauthenticated Endpoints", "severity": "High", "count": 3, "examples": ["GET:/api/health", "GET:/api/version"] }, { "type": "Weak Encryption (Base64)", "severity": "High", "count": 2, "examples": [{"endpoint": "POST:/api/auth", "types": ["Base64"]}], "recommendation": "Use proper encryption (AES-256, TLS 1.3)" } ], "llm_prompt": "# API Red Team Extension Generation\n\n..." }
## Données et exportation
### Ce qui est capturé
### Par point d'accès
- Méthode HTTP et chemin normalisé
- Hôte, protocole, port
- Chaîne de requête et tous les types de paramètres (URL, corps, cookie, JSON)
- En-têtes de requête/réponse
- Corps de requête/réponse (tronqués à 20 Ko)
- Codes de statut de réponse
- Types de contenu
- Méthodes d'authentification détectées
- Modèles d'API (REST, GraphQL, SOAP, etc.)
### Analyse
- Vue d'ensemble de la structure de l'API (types, méthodes, auth, chemins de base)
- Observations de sécurité (points d'accès non authentifiés, données sensibles)
- Regroupement et déduplication des points d'accès
- Exemples de requêtes pour chaque point d'accès
## Intégration
### Intégration des prompts LLM
L'exportation inclut des prompts prêts pour l'IA et un contexte qui priorisent :
1. Les chemins d'exploitation des données sensibles (exposition inter-compte/tenant)
2. Les changements d'état non autorisés (abus de workflow/cycle de vie)
3. Les failles logiques non évidentes plutôt que les constats génériques sujets à duplication
4. Les preuves reproductibles de deltas et les requêtes de données manquantes
Artéfacts AI principaux :
- `ai_bundle.json`
- `ai_all_tabs_context.json`
- `ai_openai_request.json`
- `ai_anthropic_request.json`
- `ai_ollama_request.json`
### Workflow du dépôt compagnon (APIPentesting)
`BurpAPISecuritySuite` et `APIPentesting` sont conçus pour être utilisés ensemble :
1. Capturez et analysez le trafic dans BurpAPISecuritySuite.
2. Dans `Recon`, cliquez sur `Export AI Bundle`.
3. Dans APIPentesting, exécutez :
- `./scripts/scan-nuclei-prioritize.sh /path/to/ai_bundle.json <scan-name>`
4. Consultez `Reports/<scan-name>-<timestamp>/priority.json` et `results.jsonl`.
5. Utilisez `scripts/AI_TRIAGE_PROMPT.md` (provenant d'APIPentesting) avec votre interface AI pour un triage priorisant les données sensibles.
Répartition des responsabilités :
- BurpAPISecuritySuite : capture dans Burp, enrichissement, analyse logique approfondie, packaging AI/export.
- APIPentesting : orchestration de scans externes, classement et triage d'exploitation assisté par IA.
## Exemples de workflow
### 1. Génération de payloads assistée par IA```bash
# 1. Capture API traffic in Burp
# 2. (Optional) Run Passive Discovery → "Run Invariants"
# 3. (Optional) In Recon, click "Refresh Invariants"
# 4. In Recon, click "Export AI Bundle"
# 5. Run APIPentesting scan from the exported bundle:
# ./scripts/scan-nuclei-prioritize.sh /path/to/ai_bundle.json burp-ai-scan
# 6. Feed Reports/.../priority.json + results.jsonl to AI with
# scripts/AI_TRIAGE_PROMPT.md for sensitive-data-first exploit triage.
### 3. Burp Intruder avec Auto-Positions```bash
# 1. Generate fuzzing attacks
# 2. Click "Send to Intruder"
# 3. Burp Intruder opens with §markers§ pre-configured
# 4. Load payloads from exported payloads.json
# 5. Launch attack
~/burp_APIRecon/ ├── FullExport_TIMESTAMP/ │ ├── api_analysis.json │ └── excalibur_bridge_bundle.json ├── HostExport_HOSTNAME_TIMESTAMP/ │ ├── api_analysis.json │ └── excalibur_bridge_bundle.json ├── Payloads_TIMESTAMP/ │ └── payloads.json (idor, sqli, xss, nosqli, ssrf, xxe, ssti, deserialization, waf_bypass) ├── AI_Context_TIMESTAMP/ │ ├── ai_context.json │ ├── ai_bundle.json │ ├── ai_all_tabs_context.json │ ├── ai_vulnerability_context.json │ ├── ai_behavioral_analysis.json │ ├── ai_counterfactual_differential_findings.json │ ├── ai_counterfactual_differential_summary.json │ ├── ai_sequence_invariant_findings.json │ ├── ai_sequence_evidence_ledger.json │ ├── ai_golden_ticket_findings.json │ ├── ai_golden_ticket_ledger.json │ ├── ai_state_transition_findings.json │ ├── ai_state_transition_ledger.json │ ├── ai_token_lineage_findings.json │ ├── ai_token_lineage_ledger.json │ ├── ai_parity_drift_findings.json │ ├── ai_parity_drift_ledger.json │ ├── ai_openai_request.json │ ├── ai_anthropic_request.json │ └── ai_ollama_request.json ├── SequenceInvariant_Export_TIMESTAMP/ │ ├── counterfactual_differential_findings.json │ ├── counterfactual_differential_summary.json │ ├── sequence_invariant_findings.json │ ├── sequence_evidence_ledger.json │ ├── golden_ticket_findings.json │ ├── golden_ticket_ledger.json │ ├── state_transition_findings.json │ ├── state_transition_ledger.json │ ├── token_lineage_findings.json │ ├── token_lineage_ledger.json │ ├── parity_drift_findings.json │ └── parity_drift_ledger.json ├── TurboIntruder_TIMESTAMP/ │ ├── race_condition.py │ ├── bola_enum.py │ └── jwt_brute.py ├── VersionScan_Export_TIMESTAMP/ │ └── version_scan.txt ├── ParamMiner_Export_TIMESTAMP/ │ └── param_mining.txt └── NucleiTargets_TIMESTAMP/ └── targets.txt
### Meilleures pratiques
### Phase de reconnaissance
- **Capturer le trafic authentifié** : Connectez-vous d'abord pour capturer les points d'accès protégés
- **Exercer toutes les fonctionnalités** : Parcourez l'ensemble de l'application pour une couverture complète
- **Utiliser plusieurs rôles** : Capturez le trafic en tant qu'admin, utilisateur, invité pour la détection BOLA
- **Examiner les statistiques** : Vérifiez les compteurs Critique/Haute/Moyenne dans le panneau de statistiques
### Phase de fuzzing
- **Commencer par « All »** : Générez d'abord une campagne d'attaque complète
- **Se concentrer sur le risque élevé** : Filtrez par sévérité pour les points d'accès critiques
- **Vérifier les détections** : Passez en revue les attaques générées avant de les envoyer à Intruder
- **Tests par lots** : Utilisez Turbo Intruder pour les conditions de course et l'énumération à grande vitesse
### Intégration IA
- **Exporter le contexte tôt** : Générez le contexte IA après la capture initiale
- **Exécuter + actualiser les invariants avant l'exportation** : Ajoutez des preuves de logique approfondie (Différentiel + Séquence + Golden + Matrice d'état + Lignée de jetons + Dérive de parité) avant d'envoyer les données à l'IA
- **Itérer les payloads** : Utilisez les payloads générés par l'IA, testez, affinez la requête
- **Combiner les techniques** : Fusionnez les payloads IA avec la bibliothèque de payloads intégrée
### Automatisation
- **Intégration Nuclei** : Exécutez Nuclei pour une validation rapide des vulnérabilités
- **Exporter les cibles** : Utilisez les listes de cibles avec ffuf, wfuzz ou des scripts personnalisés
- **Intégration CI/CD** : Automatisez les exportations pour les tests de régression
## Informations techniques
### Détails techniques
- **Normalisation** : Remplace les identifiants numériques, UUID, ObjectID par des placeholders
- **Déduplication** : Suit les points d'accès uniques par méthode + chemin normalisé
- **Troncature** : Corps limités à 20 Ko, échantillons limités à 3 par point d'accès
- **Détection d'authentification** : Identifie Bearer, Basic, Clé API, Cookie de session
- **Correspondance de motifs** : Détection basée sur des regex pour REST, GraphQL, SOAP
### Limitations
- Ne capture pas le trafic WebSocket
- Les réponses binaires ne sont pas entièrement analysées
- Les grandes réponses sont tronquées (limite de 20 Ko)
- Nécessite Jython (syntaxe Python 2.7)
## Cas d'utilisation
- **Test d'intrusion API** : Fuzzing complet avec plus de 108 vecteurs d'attaque
- **Chasse aux bugs** : Détection et exploitation automatisées de BOLA/IDOR
- **Recherche en sécurité** : Techniques d'attaque avancées (conditions de course, JWT, GraphQL)
- **Opérations Red Team** : Scripts Turbo Intruder pour attaques à grande vitesse
- **Tests assistés par IA** : Générez des payloads personnalisés avec ChatGPT/Claude
- **Sécurité CI/CD** : Exportez des cibles pour les tests de régression automatisés
- **Formation et éducation** : Apprenez les vulnérabilités API à travers des exemples concrets
## Documentation
- [Index complet de la documentation](https://github.com/teycir/burpapisecuritysuite/blob/HEAD/docs/DOCUMENTATION-INDEX.md)
- [Vue d'ensemble de l'architecture](https://github.com/teycir/burpapisecuritysuite/blob/HEAD/docs/Architecture.md)
- [Validation du fuzzing GraphQL](https://github.com/teycir/burpapisecuritysuite/blob/HEAD/docs/GRAPHQL_VALIDATION.md)
- [Référence des balises Logger++](https://github.com/teycir/burpapisecuritysuite/blob/HEAD/docs/loggerpp_tags.md)
## FAQ
### Questions générales
**Q : Cela fonctionne-t-il avec Burp Suite Community Edition ?**
R : Oui ! Toutes les fonctionnalités de base fonctionnent avec les éditions Community et Professional. Cependant, certaines fonctionnalités avancées de Burp comme l'intégration Scanner nécessitent Pro.
**Q : Pourquoi l'extension ne capture-t-elle pas le trafic ?**
R : Vérifiez que :
- Le bouton Auto-Capture est activé dans l'onglet Recon
- Vous naviguez via le proxy de Burp
- La cible envoie du trafic HTTP/HTTPS (WebSockets non pris en charge)
- Consultez le journal d'activité pour tout message d'erreur
**Q : Comment installer Jython ?**
R : Téléchargez le JAR autonome Jython depuis https://www.jython.org/download, puis dans Burp : Extender → Options → Python Environment → Select File → Choisissez le fichier jython-standalone-*.jar.
### Performances et limites
**Q : Combien de points d'accès peut-elle gérer ?**
R : L'extension gère efficacement plus de 500 points d'accès avec une rotation automatique lorsque la limite (800) est atteinte. Les points d'accès plus anciens sont automatiquement supprimés.
**Q : Pourquoi les réponses sont-elles tronquées à 20 Ko ?**
R : Pour éviter les problèmes de mémoire avec les grandes réponses tout en préservant un contexte d'analyse utile. La limite de capture de corps par défaut est de 20 Ko.
**Q : Puis-je augmenter la limite d'échantillons par point d'accès ?**
R : Oui, utilisez la liste déroulante « Samples » dans l'onglet Recon (1, 3, 5 ou 10 échantillons par point d'accès).
### Fuzzing et attaques
**Q : Pourquoi ne vois-je pas d'attaques BOLA/Bypass d'authentification ?**
R : Ces attaques nécessitent des points d'accès authentifiés. Assurez-vous de :
- Vous connecter d'abord à l'application
- Capturer le trafic en étant authentifié
- Rechercher les points d'accès avec des jetons Bearer, des clés API ou des cookies de session
**Q : Comment utiliser les attaques générées ?**
R : Trois façons :
1. **Burp Intruder** : Cliquez sur « Send to Intruder » pour des tests automatisés
2. **Turbo Intruder** : Exportez des scripts pour des attaques à grande vitesse
3. **Manuel** : Utilisez « Copy as cURL » pour des tests en ligne de commande
**Q : Quelle est la différence entre « All » et les types d'attaque spécifiques ?**
R : « All » génère des attaques complètes sur tous les types de vulnérabilités. Les types spécifiques (ex. « SQLi ») se concentrent uniquement sur cette classe de vulnérabilité pour des tests ciblés.
**Q : Comment tester efficacement les points d'accès GraphQL ?**
R : Approche à trois volets :
1. **Onglet Fuzzer** : Sélectionnez le type d'attaque « GraphQL » pour plus de 40 payloads spécifiques à GraphQL (introspection, batching, directive overloading, field suggestion)
2. **Onglet Nuclei** : Exécutez avec `-tags graphql` pour plus de 29 modèles couvrant les mauvaises configurations et la détection
3. **Tests manuels** : Utilisez « Copy as cURL » pour tester manuellement l'introspection, le batching et les attaques en profondeur
Le Fuzzer détecte automatiquement les points d'accès GraphQL et génère des attaques pour :
- Extraction de schéma via l'introspection
- Déni de service via le batching (tableau/alias) et les attaques en profondeur
- Suggestion de champs pour la découverte de schéma lorsque l'introspection est désactivée
- Surcharge de directives (abus de @skip, @include)
- Déni de service par fragment circulaire
- Mutations non autorisées
### Outils externes
**Q : Dois-je installer ApiHunter/Nuclei/HTTPX/Katana/FFUF/Kiterunner ?**
R : Uniquement si vous souhaitez utiliser ces onglets spécifiques. L'extension de base fonctionne sans eux. Installez depuis :
- ApiHunter : https://github.com/Teycir/ApiHunter (outil propriétaire - nécessite une installation séparée ou une construction locale dans `~/Repos/ApiHunter`, puis construire `target/release/apihunter`)
- Nuclei : https://github.com/projectdiscovery/nuclei
- HTTPX : https://github.com/projectdiscovery/httpx
- Katana : https://github.com/projectdiscovery/katana
- FFUF : https://github.com/ffuf/ffuf
- Kiterunner : https://github.com/assetnote/kiterunner
**Q : Où dois-je installer ces outils ?**
R : Chemins par défaut :
- `~/Repos/ApiHunter/target/release/apihunter`
- `~/go/bin/nuclei`
- `~/go/bin/httpx`
- `~/go/bin/katana`
- `~/go/bin/ffuf`
- `~/.local/bin/kr`
- Sous Windows, les chemins par défaut courants sont sous `C:\\Users\\<vous>\\go\\bin\\*.exe`
Ou configurez des chemins personnalisés dans chaque onglet.
Les onglets détectent désormais automatiquement les emplacements Go-bin de style Unix et Windows `*.exe` lorsqu'ils sont présents.
**Q : Comment fonctionnent les remplacements de commande personnalisés ?**
R :
- Laissez « Enable Custom » décoché pour utiliser les valeurs par défaut intégrées et sûres.
- Cochez « Enable Custom » pour exécuter exactement ce que vous tapez dans la zone de commande.
- Utilisez « Preset Cmd... » pour remplir rapidement les commandes courantes (toujours en opt-in jusqu'à ce que « Enable Custom » soit coché).
- Cliquez sur « ? » pour voir les placeholders et exemples pour chaque onglet.
- Les commandes personnalisées s'exécutent avec `cmd /c` sous Windows et `bash/sh -lc` sous Linux/macOS.
- Les valeurs par défaut intégrées d'HTTPX et Katana utilisent les indicateurs de fichier liste natifs (`-l` / `-list`) pour une exécution multiplateforme.
### Notes de sécurité
- Le mode de commande personnalisée est intentionnellement strict et **opt-in** (« Enable Custom » doit être coché).
- Les commandes personnalisées rendues sont validées pour les fragments de shell interdits (par exemple, syntaxe de chaînage/redirection/sous-shell).
- Les exécutables sont restreints par des listes d'autorisation par outil en mode personnalisé (par exemple `nuclei`, `httpx`, `katana`, `waybackurls`/`gau`, `apihunter`, `subfinder`).
- Les valeurs de contexte des placeholders sont assainies avant le rendu du modèle, et des variantes entre guillemets sont disponibles (`{targets_file_q}`, `{urls_file_q}`, etc.) pour une interpolation de chemin plus sûre.
- Si votre flux de travail nécessite une logique shell complexe en dehors de cette politique, exécutez cette commande manuellement en dehors de l'extension.
**Q : Pourquoi HTTPX montre-t-il des erreurs d'option invalide ?**
R :
- Assurez-vous d'utiliser ProjectDiscovery `httpx`, pas l'outil CLI Python `httpx`.
- Chemin recommandé : `~/go/bin/httpx`.
- L'extension valide désormais les signatures locales des outils et affiche un indice de correction en cas de discordance.
**Q : Comment remplir rapidement les en-têtes Invité/Utilisateur/Admin pour Auth Replay ?**
R :
- Dans « Auth Replay », cliquez sur « Extract » à côté d'Invite/Utilisateur/Admin.
- Une fenêtre contextuelle consultable s'ouvre avec les en-têtes candidats capturés.
- Filtrez par texte de point d'accès, nom d'en-tête ou fragment de jeton.
- Sélectionnez un élément et cliquez sur « OK » ; le champ est rempli au format « Nom : valeur ».
### Exportation et intégration
**Q : Où sont sauvegardés les fichiers exportés ?**
R : Toutes les exportations vont dans `~/burp_APIRecon/` avec des sous-répertoires horodatés. Consultez le journal d'activité pour les chemins exacts.
**Q : Comment utiliser l'exportation de contexte IA ?**
R :
1. (Facultatif) Exécutez « Passive Discovery » → « Run Invariants »
2. (Facultatif) Dans l'onglet « Recon », cliquez sur « Refresh Invariants »
3. Dans l'onglet « Recon », cliquez sur « Export AI Bundle »
4. Utilisez APIPentesting pour scanner à partir de cette exportation :
- `./scripts/scan-nuclei-prioritize.sh /chemin/vers/ai_bundle.json burp-ai-scan`
5. Transmettez `Reports/.../priority.json` + `results.jsonl` à votre interface IA en utilisant le script `scripts/AI_TRIAGE_PROMPT.md` d'APIPentesting
6. Utilisez `ai_sequence_evidence_ledger.json`, `ai_golden_ticket_ledger.json` et `ai_state_transition_ledger.json` pour prioriser ce qu'il faut valider en premier
**Q : Puis-je importer des données précédemment exportées ?**
R : Oui. « Import » accepte :
- `api_analysis.json` (exportation BurpAPISecuritySuite)
- Exports Excalibur `.har` (Excalibur est un outil propriétaire : https://github.com/Teycir/Excalibur)
- Fichiers sidecar Excalibur `-replay-studio.json` / `-cookies.json` / `-insights.json` (découverts automatiquement à partir du même préfixe de session)
- `excalibur_bridge_bundle.json` (`schema : excalibur-burp-bridge/v1`)
Si des artefacts Excalibur sont détectés, l'outil exécute automatiquement « Refresh Invariants » après l'importation afin que les caches Différentiel + Séquence + Golden + État + Lignée de jetons + Dérive de parité soient immédiatement prêts.
**Q : Puis-je envoyer les requêtes capturées à Postman ou Insomnia ?**
R : Oui. Dans l'onglet Recon, utilisez :
- `Postman` pour exporter `postman_collection.json` (Collection v2.1)
- `Insomnia` pour exporter `insomnia_collection.json` (format d'importation Insomnia)
- Les deux prennent en charge la sélection de portée : « All Endpoints », « Filtered View », ou « Current Host ».
### Dépannage
**Q : Extension chargée mais ne s'affiche pas dans les onglets ?**
R : Vérifiez Burp's Extender → onglet Extensions pour les erreurs. Problèmes courants :
- Jython non configuré correctement
- Erreurs de syntaxe Python 2.7 (l'extension utilise Jython/Python 2.7)
- Mémoire insuffisante (augmentez la taille du tas de Burp)
**Q : Message « No endpoints captured » ?**
R : Assurez-vous de :
- Naviguer activement via le proxy Burp
- L'auto-capture est activée
- La cible fait des requêtes HTTP (pas seulement des fichiers statiques)
- Vérifiez si les points d'accès sont filtrés (les images/polices sont automatiquement filtrées)
**Q : Les analyses Nuclei/HTTPX bloquent ou expirent ?**
R :
- Vérifiez que l'outil est installé et que le chemin est correct
- Vérifiez la connectivité réseau vers les cibles
- Les grandes analyses peuvent encore prendre plusieurs minutes (délai d'attente max par défaut : 15 minutes)
- Utilisez **Target Bases...** avec **Only Base+Derivatives** pour forcer une portée stricte sur une seule cible
- Utilisez le bouton **Stop** dans le même onglet pour annuler les outils externes en cours d'exécution
- Consultez le journal d'activité pour des messages d'erreur détaillés
**Q : Pourquoi certains points d'accès sont-ils marqués comme « Critical » ou « High » ?**
R : La sévérité est basée sur :
- **Critique** : Points d'accès de débogage/admin, IDOR/BOLA non authentifié
- **Haute** : IDOR/BOLA authentifié, exposition de données sensibles, chiffrement faible
- **Moyenne** : Réponses d'erreur, paramètres réfléchis
- **Info** : Points d'accès standard
### Utilisation avancée
**Q : Comment tester les conditions de course ?**
R :
1. Générez des attaques de fuzzing (onglet Fuzzer)
2. Cliquez sur le bouton « Turbo Intruder »
3. Chargez le script `race_condition.py` exporté dans Turbo Intruder de Burp
4. Configurez pour 50+ requêtes parallèles
**Q : Puis-je personnaliser les payloads d'attaque ?**
R : Oui ! Exportez les payloads en JSON, modifiez-les, puis :
- Utilisez-les manuellement dans Burp Intruder
- Transmettez-les à l'IA pour amélioration
- Créez des scripts personnalisés avec la bibliothèque de payloads
**Q : Comment comparer deux versions d'API ?**
R :
1. Exportez les données API de la version 1 (« Export All »)
2. Effacez les données et capturez la version 2
3. Exportez la version 2
4. Utilisez l'onglet Diff → Chargez les deux exportations → Comparez
**Q : Quel est le meilleur flux de travail pour la chasse aux bugs ?**
R :
1. Capturez le trafic authentifié (tous les rôles utilisateur)
2. Examinez d'abord les points d'accès de sévérité Critique/Haute
3. Générez des attaques « All » dans le Fuzzer
4. Concentrez-vous sur les points d'accès BOLA/IDOR
5. Utilisez Version Scanner pour trouver des API héritées
6. Exécutez Param Miner sur les points d'accès à haute valeur
7. Exportez vers Nuclei pour validation automatisée
### Points forts techniques
- **Architecture Jython propre** : Conception modulaire avec logique centrale testable
- **Extraction modulaire** : Flux de travail lourds extraits vers des modules d'aide (`heavy_runners.py`, `ai_prep_layer.py`, `behavior_analysis.py`)
- **Détection intelligente** : Identification des vulnérabilités contextuelle
- **Performances optimisées** : Gère efficacement plus de 500 points d'accès
- **Multiplateforme** : Fonctionne sur Windows, macOS, Linux
- **Extensible** : Facile d'ajouter de nouveaux types d'attaque et payloads
- **Interface utilisateur professionnelle** : Sévérité codée par couleur, interface à onglets, statistiques en temps réel
- **Couverture de rejeu** : Inclut des tests de corpus de rejeu golden pour la détection d'invariants de séquence + sortie de registre de confiance
## 💼 Services professionnels
Besoin d'outils de sécurité personnalisés ou de solutions de test d'API ? Je construis des applications prêtes pour la production et des outils de sécurité.
### Projets en vedette
- **[ApiHunter](https://github.com/Teycir/ApiHunter)** - Outil automatisé de reconnaissance API et de test de sécurité avec découverte intelligente de points d'accès
- **[TimeSeal](https://timeseal.online)** ([GitHub](https://github.com/Teycir/Timeseal)) - Coffre-fort cryptographique à ouverture différée et commutateur de mise à mort avec chiffrement zéro confiance
- **[Ghost Chat](https://ghost-chat.pages.dev)** - Chat sécurisé P2P avec WebRTC, pas de stockage serveur, minuteries d'autodestruction
- **[BurpCopyIssues](https://github.com/Teycir/BurpCopyIssues)** - Extension Burp Suite pour naviguer, copier et exporter les résultats de scan
- **[BurpWpsScan](https://github.com/Teycir/BurpWpsScan)** - Scanner de sécurité WordPress pour Burp Suite avec intégration API WPScan
- **[Excalibur](https://github.com/Teycir/Excalibur)** - Outils de découverte de surface d'attaque API et de workflow de session pour les opérations pratiques de pentest (outil propriétaire)
- **[APIPentesting](https://github.com/Teycir/APIPentesting)** - Flux de travail compagnon de scan externe et de triage d'exploit pour la chasse aux bugs API en premier lieu avec Burp
- **Outils de sécurité personnalisés** - Extensions Burp, frameworks de test d'API, scripts d'automatisation
### Services proposés
- 🔒 **Développement d'outils de sécurité** - Extensions Burp personnalisées, outils de test d'intrusion, frameworks d'automatisation
- 🚀 **Développement d'applications web** - Développement full-stack avec technologies modernes
- 🔧 **Consultation en sécurité API** - Révision d'architecture, évaluation de vulnérabilités, conseil en remédiation
- 🤖 **Intégration IA** - Outils de sécurité alimentés par LLM, génération automatisée de payloads, fuzzing intelligent
**Contactez-moi** : [teycirbensoltane.tn](https://teycirbensoltane.tn) | Disponible pour des projets freelance et du conseil
## Contribution
### Auteur
Développé par [Teycir Ben Soltane](https://teycirbensoltane.tn)
### Licence
Licence MIT - Libre d'utilisation pour les tests de sécurité autorisés et les fins de recherche.
## Journal des modifications
Voir [CHANGELOG.md](https://github.com/teycir/burpapisecuritysuite/blob/HEAD/CHANGELOG.md) pour l'historique complet des versions.
| Fonctionnalité | BurpAPISecuritySuite | Burp Scanner Pro | OWASP ZAP | Postman |
|---|
| Prix | Gratuit | 449 $/an | Gratuit | Gratuit/Payant |
| Focus spécifique API | ✅ Oui | ⚠️ Partiel | ⚠️ Partiel | ✅ Oui |
| Capture et normalisation automatiques | ✅ Oui | ❌ Non | ⚠️ Basique | ❌ Non |
| Détection BOLA/IDOR | ✅ Automatisée | ⚠️ Manuelle | ⚠️ Manuelle | ❌ Non |
| Types d'attaques | 15 types | 100+ (génériques) | 50+ (génériques) | Limité |
| Payloads API | 108+ axés API | Web génériques | Web génériques | Basiques |
| Analyse JWT | ✅ Automatique | ⚠️ Extension nécessaire | ⚠️ Extension nécessaire | ⚠️ Manuelle |
| Tests GraphQL | ✅ Intégré | ❌ Non | ⚠️ Limité | ⚠️ Manuel |
| Tests de conditions de course | ✅ Turbo Intruder | ✅ Turbo Intruder | ❌ Non | ❌ Non |
| Intégration IA | ✅ Export AI Bundle + payloads LLM | ❌ Non | ❌ Non | ❌ Non |
| Version Scanner | ✅ Intégré | ❌ Non | ❌ Non | ❌ Non |
| Paramètre Mining | ✅ Intégré | ⚠️ Extension nécessaire | ❌ Non | ❌ Non |
| Découverte Wayback | ✅ Intégré | ❌ Non | ❌ Non | ❌ Non |
| Intégration d'outils externes | ✅ ApiHunter, Nuclei, SQLMap, Dalfox, HTTPX, Katana, FFUF, Subfinder, DNSX | ❌ Non | ⚠️ Limité | ⚠️ Limité |
| Techniques de contournement WAF | ✅ 20+ méthodes | ⚠️ Quelques-unes | ⚠️ Quelques-unes | ❌ Non |
| Formats d'exportation | JSON, Intruder, Turbo, Nuclei, cURL | XML, HTML | XML, HTML, JSON | JSON, cURL |
| Support Burp Community | ✅ Oui | ❌ Pro uniquement | N/A | N/A |
| Courbe d'apprentissage | Faible | Moyenne | Moyenne | Faible |
| Meilleur pour | Pentest d'API, bug bounty | Tests web complets | Automatisation DAST | Développement d'API |
Règles de tags...Sauvegarder regexAfficher les détails du point de terminaison, Envoyer la sélection à Repeater, Copier les lignes sélectionnées, et sélection groupée.authentification -> accès objet -> changement d'état)abuse_chain_*, proof_mode_packet_sets, spec_guardrails_* et role_delta_*Authentifié uniquementAuthentifié + Non authentifiéassociées à l'authentificationnon associées à l'authentificationauth_detectedNon authentifié uniquement, Authentifié uniquement, Authentifié + Non authentifié (par défaut). En mode double passage, les URL de base dédupliquées sont divisées en listes de cibles associées à l'authentification et non associées à l'authentification ; chaque passage s'exécute sur sa propre liste. L'association auth utilise à la fois les en-têtes d'authentification de requête et les signaux d'authentification non-en-tête (auth_detected, marqueurs de jeton/cookie/session dans les métadonnées de requête).Critique / Élevé / Moyen pour contrôler le bruit du résumé de triageCibles personnalisées... au lieu de la portée filtrée par Reconmax 20 entrées, une par ligne) avec un assainissement strict et une normalisation canonique des URL de base (scheme://host[:port]/), y compris la déduplication et le rejet des lignes invalidesUtiliser des cibles personnalisées est activé, les exécutions échouent rapidement si le contenu de la fenêtre contextuelle est vide, dépasse la limite ou contient des lignes d'URL invalidesscheme://host[:port]/) pour ApiHunterRapide : --no-discovery, --max-endpoints 40, --concurrency 4, --timeout-secs 12, --retries 1, --delay-ms 0, et désactive les scanners lourds (mass-assignment, oauth-oidc, rate-limit, cve-templates, websocket)Équilibré : --no-discovery, --max-endpoints 80, --concurrency 5, --timeout-secs 15, --retries 1, --delay-ms 50Approfondi : --active-checks --response-diff-deep --no-discovery, --max-endpoints 0, --concurrency 6, --timeout-secs 20, --retries 2, --delay-ms 100, --waf-evasion, --per-host-clients, --adaptive-concurrency{apihunter_path}, {targets_file}, {results_file})Auth + Unauth est bloqué ; utilisez Auth Only ou Unauth Only, ou désactivez le mode personnalisé pour une exécution automatique en double passage.Critique / Élevé / Moyen), tandis que les statistiques de sortie du scanner restent complètes.CookieRapide, Équilibré, ApprofondiAuth + Unauth est bloqué ; utilisez Auth Only ou Unauth Only, ou désactivez le mode personnalisé pour une exécution automatique en double passage.nuclei/httpx/katana/ffuf/kiterunner/waybackurls/gau/sqlmap/dalfox/subfinder/dnsxtaskkill sur Windows et pkill (avec repli killall) sur Linux/macOSscheme://host[:port]/Filtrer le bruit de Recon, sélectionné au démarrage, compresse son ensemble de cibles par défautTraversée de chemin
SSRF (Server-Side Request Forgery)
XXE (XML External Entity)
Désérialisation