F --> G1[Passive scanners]
F --> G2[Active scanners]

I[template-tool] --> H[CVE templates]
H --> G2

G1 --> J[Findings]
G2 --> J
J --> K[Reporter]
K --> L[Auto Reports]
K --> M[CI/CD Controls]

## Pourquoi ApiHunter ?

### Avantages principaux

- **Architecture orientée API** : conçu spécifiquement pour les API REST/GraphQL, pas adapté de scanners d'applications web
- **Réduction intelligente des faux positifs** :
  - Détection SPA catch-all avec sondes canaries
  - Validation contextuelle des secrets (frontend vs backend)
  - Validation du contenu du corps et vérification du referer
  - Empreintes de réponse pour ignorer les résultats en double
- **Conçu pour être sûr en production** :
  - Concurrence adaptative (AIMD) qui réduit en cas d'erreurs
  - Limitation de débit par hôte avec délais configurables
  - Contrôles de politesse (nouvelles tentatives, délais d'attente, évasion WAF)
  - Mode dry-run pour les contrôles actifs
- **Furtivité et évasion** :
  - Rotation du User-Agent à l'exécution depuis un pool soigneusement sélectionné (assets/user_agents.txt)
  - Délais de requête aléatoires avec jitter
  - Application du délai par hôte (évite les rafales)
  - Logique de nouvelle tentative avec backoff exponentiel
  - Injection d'en-têtes personnalisés pour se fondre dans le trafic légitime
  - Synchronisation adaptative selon les réponses du serveur
  - Aucune empreinte de scanner codée en dur en mode par défaut

### Plongée dans les techniques de furtivité

ApiHunter utilise plusieurs techniques de furtivité pour éviter la détection par les WAF (Web Application Firewall) et les systèmes de protection anti-bots :

#### 1. Rotation du User-Agent
**Ce que ça fait :** Alterne aléatoirement parmi plus de 100 chaînes de User-Agent de navigateurs réels provenant d'un fichier (`assets/user_agents.txt`)

**Pourquoi ça marche :** Les bots utilisent généralement le même User-Agent (comme `curl/7.68.0`). En se faisant passer pour Chrome, Firefox, Safari, etc., vous vous fondez dans le trafic légitime

**Analogie simple :** Comme porter différents déguisements au lieu de toujours porter le même uniforme

#### 2. Synchronisation aléatoire et jitter
**Ce que ça fait :** Ajoute des délais aléatoires entre les requêtes (contrôlés par `--delay-ms`) avec jitter (petites variations aléatoires)

**Pourquoi ça marche :** Les bots envoient des requêtes à intervalles parfaits (exactement 100 ms d'écart). Les humains sont imprévisibles. Une synchronisation aléatoire rend le trafic organique

**Analogie simple :** Marcher à pas irréguliers au lieu de marcher comme un robot

#### 3. Application du délai par hôte
**Ce que ça fait :** Suit le délai séparément pour chaque domaine, pas globalement

**Pourquoi ça marche :** Empêche les rafales où vous frappez un hôte 50 fois instantanément. Chaque hôte voit des requêtes polies et espacées

**Analogie simple :** Prendre tour à tour la parole dans différentes conversations au lieu de crier après une seule personne sans arrêt

#### 4. Concurrence adaptative (AIMD)
**Ce que ça fait :** Ralentit automatiquement en cas d'erreurs 429 (limite de débit) ou 503 (serveur occupé), accélère quand tout réussit

**Pourquoi ça marche :** Réduit la cadence quand il est repéré, imite la façon dont les navigateurs réessaient. Les WAF voient « ce client respecte nos limites »

**Analogie simple :** Ralentir quand le trafic est congestionné, accélérer sur les routes dégagées

#### 5. Nouvelle tentative avec backoff exponentiel
**Ce que ça fait :** Quand une requête échoue, attend 1 s, puis 2 s, puis 4 s avant de réessayer

**Pourquoi ça marche :** Les clients légitimes réessaient avec souplesse. Les bots martèlent immédiatement ou abandonnent

**Analogie simple :** Frapper à une porte, attendre plus longtemps à chaque fois au lieu de tambouriner sans arrêt

#### 6. Aucune empreinte de scanner
**Ce que ça fait :** N'envoie pas d'en-têtes comme `X-Scanner: ApiHunter` ni de motifs prévisibles

**Pourquoi ça marche :** De nombreux outils laissent des signatures (modèles Nuclei, motifs sqlmap). ApiHunter évite les marqueurs évidents

**Analogie simple :** Ne pas porter un badge « Testeur de sécurité »

#### 7. Réutilisation et regroupement des connexions
**Ce que ça fait :** Utilise des pools de clients HTTP par hôte, maintient les connexions actives

**Pourquoi ça marche :** Les navigateurs réutilisent les connexions. Ouvrir/fermer pour chaque requête paraît suspect

**Analogie simple :** Laisser la porte ouverte au lieu de la claquer et de sonner à nouveau

#### 8. Injection d'en-têtes personnalisés
**Ce que ça fait :** Peut ajouter des en-têtes comme `Referer`, `X-Forwarded-For`, des cookies personnalisés

**Pourquoi ça marche :** Rend les requêtes semblables à un flux applicatif légitime (clic sur un lien, présence de cookies de session)

**Analogie simple :** Montrer un billet d'entrée en arrivant dans une salle au lieu de sauter par-dessus la barrière

#### Comparaison de détection

| Technique | Sans évasion | Avec évasion |
|-----------|----------------|-------------|
| **User-Agent** | `python-requests/2.28.0` (bot évident) | `Mozilla/5.0 (Windows NT 10.0; Win64; x64)...` (ressemble à Chrome) |
| **Synchronisation** | Intervalles parfaits de 100 ms → WAF bloque | 120 ms, 95 ms, 180 ms → semble humain |
| **Nouvelles tentatives** | Tentative immédiate → bannissement | Attendre 1 s→2 s→4 s → « client patient » |
| **Concurrence** | 100 frappes parallèles → alarme | Adaptatif 5→10→3 selon la réponse → « navigateur poli » |

#### Quand utiliser `--waf-evasion`

- Tester des API de production derrière Cloudflare/Akamai/AWS WAF
- Éviter les bannissements IP lors de grands scans
- Tests d'intrusion où vous devez rester discret

- **Natif CI/CD** :
  - Différentiel de base (`baseline diffing`) : ne rapporte que les nouveaux résultats
  - Sortie NDJSON en streaming pour un suivi en temps réel
  - SARIF 2.1.0 pour GitHub/GitLab Code Scanning
  - Masque de bits de code de sortie pour le contrôle des pipelines
  - Filtrage par sévérité et seuils d'échec
- **Performances à l'échelle** :
  - Runtime asynchrone Rust (tokio) avec abstractions sans coût
  - Scan concurrent avec parallélisme borné par sémaphores
  - Pools de clients HTTP par hôte pour éviter les goulots de connexion
  - Utilisation mémoire efficace (pas de pauses GC)
- **Prise en charge complète de l'authentification** :
  - Flux d'authentification JSON avec extraction de cookies/en-têtes
  - Tests IDOR/BOLA à double identité
  - Import de fichiers de session (intégration Excalibur)
  - Auth Bearer, Basic, et en-têtes personnalisés
  - Client non authentifié automatique pour les vérifications d'élévation de privilèges

## Modules du scanner

ApiHunter inclut 13 modules de scanner intégrés. Voir [docs/scanners.md](https://github.com/teycir/apihunter/blob/HEAD/docs/scanners.md) pour la logique de détection détaillée.

| Scanner | Type | Ce qu'il détecte |
|---------|------|----------------|
| **CORS** | Passif | Origines génériques (wildcard), origines réfléchies avec identifiants, acceptation de l'origine null, vulnérabilités de contournement regex (attaques par suffixe/préfixe), en-tête `Vary: Origin` manquant, méthodes de préflight non sûres |
| **CSP** | Passif | Content-Security-Policy manquante, directives unsafe-inline/unsafe-eval, sources génériques, hôtes CDN contournables (gadgets JSONP), frame-ancestors manquant |
| **GraphQL** | Passif | Introspection activée, champs de schéma sensibles (types user/password/token), suggestions de champs (fuite de schéma), batching de requêtes, amplification par alias (DoS), exposition GraphiQL/Playground |
| **JWT** | Passif | Jetons alg=none, secrets HS256 faibles (basés sur une liste de mots), expiration absente/excessive, revendications sensibles dans le payload, vulnérabilités de confusion d'algorithme |
| **OpenAPI** | Passif | Schémas de sécurité manquants, opérations sans exigence d'auth, points de terminaison d'upload de fichiers, opérations dépréciées toujours présentes, points de terminaison sensibles non protégés |
| **Versionnement API** | Passif | Divulgation d'en-tête de version, versions d'API anciennes/nouvelles concurrentes, en-têtes de dépréciation, et dérive de réponse entre variantes bénignes de requête/version (plus mode profond via `--response-diff-deep`) |
| **gRPC/Protobuf** | Passif + Actif | Signaux de transport/content-type gRPC, indices de surface protobuf, et sondes facultatives de réflexion/santé |
| **Sécurité API** | Passif + Actif | En-têtes de sécurité manquants (X-Content-Type-Options, X-Frame-Options), divulgation de version serveur, accès non authentifié à des chemins sensibles, énumération de méthodes HTTP, points de terminaison de débogage, motifs d'exposition de secrets, vérifications IDOR/BOLA actives (comparaison du corps + de certains en-têtes), sondes de callback SSRF aveugle, et sondes de signature de passerelle/contournement |
| **Mass Assignment** | Actif | Champs sensibles réfléchis (is_admin, role, permissions), changements d'état persistés, élévation de privilèges par injection de champs |
| **OAuth/OIDC** | Actif | Contournement de validation d'URI de redirection, paramètre state manquant, problèmes de support PKCE (S256 manquant, plain autorisé), flux implicite activé, octroi de mot de passe activé |
| **Rate Limit** | Actif | Limitation de débit absente (sondes en rafale), en-têtes Retry-After manquants, contournement par spoofing d'en-tête IP (X-Forwarded-For) |
| **WebSocket** | Actif | Acceptation de mise à niveau WebSocket sur des chemins courants, validation d'origine manquante, connexions WebSocket non authentifiées |
| **Modèles CVE** | Actif | Détection de CVE pilotée par modèles depuis `assets/cve_templates/*.toml` (168 modèles actuellement), correspondance différentielle baseline vs bypass |

**Les scanners passifs** s'exécutent par défaut et analysent les réponses sans envoyer de requêtes façonnées.  
**Les scanners/vérifications actifs** nécessitent `--active-checks` et envoient des sondes potentiellement invasives (IDOR/BOLA, mutation, tests de contournement).  
IDOR/BOLA se trouve sous le scanner `API Security` (il n'y a pas de drapeau dédié `--no-idor` ; utilisez `--no-api-security` pour le désactiver).

### Notes sur la sortie des modules et les signaux

Ces notes résument comment les résultats sont émis et ce qui génère typiquement du bruit :

| Module | Préfixe / forme du résultat | Faux positifs courants | Faux négatifs courants |
|---------|-------------------------|-------------------------|-------------------------|
| CORS | `cors/*` avec champs origin/evidence | Réflexion sur des routes non sensibles | Vérifications d'origine appliquées seulement sur les routes authentifiées |
| CSP | `csp/*` avec preuve dans la directive | CSP héritée appliquée volontairement pendant une migration | CSP délivrée uniquement sur le chemin de la périphérie CDN de production |
| GraphQL | `graphql/*` avec point de terminaison + signal de capacité | Playground public destiné aux locataires internes/aux tests | Contrôles de schéma activés uniquement après authentification |
| JWT | `jwt/*` avec preuve dans les revendications/en-têtes du jeton | Jetons de test/démo dans des réponses synthétiques | Le jeton n'apparaît jamais dans les réponses scannées |
| OpenAPI | `openapi/*` avec contexte opération/sécurité | La spec inclut intentionnellement des points de terminaison dépréciés mais bloqués | Spec indisponible ou répartie entre plusieurs docs privés |
| Versionnement API | `api_versioning/*` + `response_diff/*` | Plusieurs versions supportées pendant des migrations contrôlées | Chemins versionnés non découvrables depuis le jeu de graines actuel |
| gRPC/Protobuf | `grpc_protobuf/*` avec preuve transport/réflexion | Métadonnées ressemblant à gRPC sur des proxys périphériques sans surface RPC exposée | Points de terminaison gRPC derrière un hôte/chemin séparé non atteints depuis le jeu de graines |
| Sécurité API | `api_security/*` avec preuve en-tête/chemin/méthode | Points de terminaison de débogage/test exposés volontairement hors production | Contrôles appliqués derrière un contexte d'authentification/session |
| Mass Assignment | `mass_assignment/*` avec deltas réfléchis/persistés | Comportement d'écho qui ne persiste pas l'état backend | Mutations rejetées par des règles de validation cachées |
| OAuth/OIDC | `oauth/*` avec preuve redirection/métadonnées | Config IdP non productive avec politiques relâchées | Application dynamique de politiques non visible dans les métadonnées |
| Rate Limit | `rate_limit/*` avec comportement de rafale/429 | Le lissage global du trafic masque le comportement du limiteur applicatif | Limiteurs à longue fenêtre non déclenchés par une courte fenêtre de sonde |
| WebSocket | `websocket/*` avec vérifications d'upgrade/origine | Points de terminaison WS publics volontairement anonymes | Auth requise via en-têtes de handshake non fournis dans la sonde |
| Modèles CVE | `cve/<id>/<check>` avec preuve du modèle | Collision d'empreinte sur des points de terminaison génériques | Chemin/contexte vulnérable non atteint depuis les URL de graines |

Pour le détail check par check et les recommandations de remédiation, voir [docs/scanners.md](https://github.com/teycir/apihunter/blob/HEAD/docs/scanners.md) et [docs/findings.md](https://github.com/teycir/apihunter/blob/HEAD/docs/findings.md).
La documentation du scanner inclut désormais un [catalogue de vérifications de modules](https://github.com/teycir/apihunter/blob/HEAD/docs/scanners.md#module-check-catalog) aligné sur la source et un [modèle d'attente des faux positifs](https://github.com/teycir/apihunter/blob/HEAD/docs/scanners.md#false-positive-expectation-model).

## Fonctionnalités

### Analyse de sécurité passive
- **Détection des erreurs de configuration CORS** :
  - Génération dynamique d'origine basée sur le domaine cible
  - Test de contournement regex (attaques par suffixe/préfixe)
  - Score de sévérité tenant compte des identifiants
  - Détection d'origine générique et null
- **Analyse de politique CSP** :
  - Détection de Content Security Policy manquante/faible
  - Directives inline/eval non sûres
  - Détection de sources génériques
  - Motifs de contournement de politique
- **Sécurité GraphQL** :
  - Détection de requête d'introspection
  - Analyse des noms de types/champs sensibles
  - Détection du support du batching de requêtes
  - Sondage d'amplification par alias (DoS)
  - Fuzzing actif de mutations (`--active-checks`, supporte `--dry-run`)
  - Exposition GraphiQL/Playground
- **Analyse des jetons JWT** :
  - Confusion d'algorithme (alg=none, HS256→RS256)
  - Détection de secret faible (liste de mots soigneusement sélectionnée)
  - Détection de jetons à longue durée de vie (exp absente/excessive)
  - Exposition de revendications sensibles
  - Extraction de jetons depuis les en-têtes et cookies
- **Analyse OpenAPI/Swagger** :
  - Validation des schémas de sécurité
  - Détection des points de terminaison d'upload de fichiers
  - Signalement des opérations dépréciées
  - Définitions de sécurité manquantes
  - Cache de la spec pour la performance
- **Couverture gRPC/Protobuf** :
  - Détection des métadonnées/content-types de réponse gRPC
  - Détection d'indices de surface protobuf depuis les métadonnées/forme des chemins du point de terminaison
  - Sondes actives facultatives de réflexion/santé sur les chemins gRPC connus
- **Détection d'exposition de secrets** :
  - Clés AWS (AKIA*, clés secrètes)
  - Clés API Google (AIza*)
  - Jetons GitHub (ghp_*, github_pat_*)
  - Jetons Slack (xox*)
  - Clés Stripe (sk_live_*, pk_live_*)
  - URLs de base de données, clés privées, jetons bearer
  - Validation contextuelle (réduit les faux positifs)
- **Vérifications de sécurité API** :
  - Énumération de méthodes HTTP
  - Détection de points de terminaison de débogage
  - Exposition de listage de répertoires
  - Présence de security.txt
  - Analyse des en-têtes de réponse (HSTS, X-Frame-Options, etc.)
  - Divulgation de messages d'erreur

### Tests de sécurité actifs (--active-checks)
- **Vérifications IDOR/BOLA de sécurité API** (approche à 3 niveaux) :
  - Test d'accès non authentifié
  - Comparaison des réponses via empreintes du corps plus instantanés d'en-têtes stables
  - Énumération d'ID (parcours de plage ±2)
  - Contournement d'autorisation entre utilisateurs (double identité)
  - Sondage de callback SSRF aveugle via paramètres de requête de type callback (`APIHUNTER_OAST_BASE`, supporte `--dry-run`)
  - Sondage d'empreinte et de contournement de passerelle (`api_security/gateway-*`)
- **Vulnérabilités Mass Assignment** :
  - Injection de champs sensibles réfléchis
  - Détection de changement d'état persisté
  - Vérification Baseline→Mutate→Confirm
  - Élévation de privilèges par injection de champs
- **Sécurité OAuth/OIDC** :
  - Contournement de validation d'URI de redirection
  - Gestion du paramètre state
  - Détection du support PKCE
  - Durcissement de la configuration des métadonnées
  - Détection du flux implicite et de l'octroi de mot de passe
- **Limitation de débit** :
  - Sondage de requêtes en rafale
  - Détection d'absence de limitation de débit
  - Validation de l'en-tête Retry-After
  - Tests de contournement par spoofing d'en-tête IP
- **Sécurité WebSocket** :
  - Acceptation d'upgrade sur des chemins courants
  - Test de validation d'origine
  - Vérifications d'authentification manquante
- **Moteur de modèles CVE** :
  - Catalogue de modèles basé sur TOML
  - Support d'import de YAML Nuclei
  - Correspondance différentielle baseline vs bypass
  - Déduplication hôte+modèle
  - Portails de qualité du chargeur qui ignorent les modèles de requête invalides/non sûrs (par exemple, les placeholders de requête non résolus)
  - Correspondance contextuelle segmentée qui réduit les déclenchements excessifs par sous-chaîne large de chemin
  - Catalogue local actuel : 168 modèles (inclut des vérifications durcies sélectionnées telles que CVE-2022-22947, CVE-2021-29442, CVE-2021-29441, CVE-2020-13945, CVE-2021-45232, CVE-2022-24288)

### Découverte et énumération
- **Découverte de points de terminaison** :
  - Analyse de robots.txt
  - Analyse de sitemap.xml
  - Import de spec OpenAPI/Swagger
  - Import de fichier HAR (intégration Excalibur)
  - Import de collection Postman/Insomnia (`--collection`)
  - Extraction de points de terminaison JavaScript
  - Filtrage par même hôte
- **Pré-filtrage d'accessibilité des URL** :
  - Pré-vérification rapide pour ignorer les points de terminaison morts
  - Délai d'attente configurable
  - Contournement facultatif avec --no-filter

### Performance et fiabilité
- **Concurrence adaptative (AIMD)** :
  - Ajustement automatique du débit selon les erreurs
  - Augmentation additive (toutes les 5 s)
  - Diminution multiplicative sur 429/503/délais d'attente
- **Furtivité et évasion WAF** :
  - Rotation du User-Agent depuis le pool d'exécution (assets/user_agents.txt avec plus de 100 vrais UAs)
  - UAs de secours intégrés si le fichier est indisponible
  - Jitter de délai aléatoire pour éviter les motifs de détection
  - Application de la synchronisation par hôte (pas globale)
  - Logique de nouvelle tentative avec backoff exponentiel
  - Injection d'en-têtes personnalisés (X-Forwarded-For, Referer, etc.)
  - Synchronisation adaptative basée sur les réponses 429/503
  - Mode politesse pour les tests coopératifs
  - Aucune empreinte de scanner dans le User-Agent ou les en-têtes par défaut
- **Gestion des ressources** :
  - Parallélisme borné par sémaphores
  - Pools de clients HTTP par hôte
  - Réutilisation et regroupement des connexions
  - Délais d'attente et nouvelles tentatives configurables
- **Gestion des erreurs** :
  - Récupération de panique via JoinSet
  - Erreurs capturées rapportées séparément
  - Dégradation gracieuse en cas d'échec des scanners

### Sortie et rapports
- **Plusieurs formats de sortie** :
  - JSON joli (lisible par l'humain)
  - NDJSON (streaming, analysable)
  - SARIF 2.1.0 (GitHub/GitLab Code Scanning)
- **Différentiel de base (baseline diffing)** :
  - Générer des instantanés de base
  - Comparer les scans pour ne rapporter que les nouveaux résultats
  - Idéal pour les tests de régression
- **Enregistrement automatique des rapports** (activé par défaut, désactivable avec `--no-auto-report`) :
  - Enregistré dans ~/Documents/ApiHunterReports/<horodatage>/
  - findings.json (résultats structurés)
  - summary.md (rapport Markdown)
  - scan.log (journal d'exécution)
- **Streaming en temps réel** :
  - Diffuse les résultats au fur et à mesure qu'ils sont découverts
  - Format NDJSON pour analyse en direct
  - Suivi de la progression
- **Filtrage par sévérité** :
  - Filtrer par sévérité minimale (info/low/medium/high/critical)
  - Seuil d'échec pour CI/CD
  - Masque de bits de code de sortie (0x01 résultats, 0x02 erreurs)

### Intégration et extensibilité
- **Architecture de scanner enfichable** :
  - Implémenter le trait Scanner pour ajouter des modules
  - Conception async-first
  - Exécution indépendante des scanners
  - Isolation des paniques par scanner
- **Extensibilité basée sur TOML** :
  - Catalogue de modèles CVE dans assets/cve_templates/*.toml
  - Aucun changement de code nécessaire pour ajouter de nouvelles vérifications
  - Détection de vulnérabilités pilotée par modèles
  - Format de modèle partageable par la communauté
- **Import de modèles Nuclei** :
  - Binaire template-tool pour la conversion YAML → TOML
  - Traduction automatique des matchers (status, word, regex, dsl)
  - Extraction sûre des chaînes de requêtes en pré-vol
  - Préserve la logique de détection des modèles en amont
- **Modèle d'extension double** :
  - **Basé sur le code** : écrivez des scanners Rust implémentant le trait Scanner pour une logique complexe
  - **Basé sur des modèles** : écrivez des modèles TOML pour des vérifications par signature (CVE, mauvaises configurations)
  - Le meilleur des deux mondes : performance + flexibilité
- **Outils complémentaires** :
  - Extension de navigateur Excalibur (capture HAR)
  - BurpAPIsecuritysuite (tests manuels)
  - Flux de travail : Capturer → Automatiser → Tester en profondeur

### Configuration et contrôle
- **Entrée flexible** :
  - Listes d'URL basées sur des fichiers
  - stdin (pipe depuis d'autres outils)
  - Import de fichier HAR
  - Import de collection Postman/Insomnia
  - Import de spec OpenAPI
- **Contrôle granulaire des scanners** :
  - Activer/désactiver des scanners individuels
  - Mode actif ou passif
  - Dry-run pour les vérifications actives
  - Configuration par scanner
- **Configuration réseau** :
  - Support de proxy HTTP/HTTPS
  - Contrôle de validation des certificats TLS
  - En-têtes et cookies personnalisés
  - Délais d'attente et nouvelles tentatives configurables
- **Profils de scan** :
  - quickscan.sh (rapide, faible impact)
  - deepscan.sh (complet, vérifications actives)
  - inaccessiblescan.sh (revérifier les cibles auparavant inaccessibles avec des paramètres plus lents)
  - baselinescan.sh (générer une base)
  - diffscan.sh (comparer avec la base)
  - authscan.sh (scan authentifié)
  - sarifscan.sh (intégration CI/CD)
  - scan-and-report.sh (exécuter le scan + afficher le dernier chemin de rapport)
  - split-by-host.sh (répartir les cibles par hôte et, facultativement, lancer des scans en parallèle)

## Comparaison avec d'autres outils| Feature | ApiHunter | Nuclei | ZAP | Burp Suite | ffuf |
|---------|-----------|--------|-----|------------|------|
| **Langage** | Rust | Go | Java | Java | Go |
| **Performance** | ⚡⚡⚡ Async, concurrence adaptative | ⚡⚡ Parallélisme rapide | ⚡ Modérée | ⚡ Modérée | ⚡⚡⚡ Très rapide |
| **Conception API-first** | ✅ Conçu pour les API | ❌ Web général | ⚠️ Hybride | ⚠️ Hybride | ❌ Focus fuzzing |
| **Filtrage des faux positifs** | ✅ Détection SPA, validation du corps, vérifications du referer | ⚠️ Dépend des modèles | ⚠️ Beaucoup de faux positifs | ✅ Bon | N/A |
| **Analyse CORS/CSP** | ✅ Analyse approfondie des politiques | ⚠️ Modèles de base | ✅ Bonne | ✅ Bonne | ❌ |
| **Introspection GraphQL** | ✅ Exposition du schéma + vérifications des champs sensibles | ⚠️ Détection basique | ⚠️ Limitée | ✅ Via extensions | ❌ |
| **OpenAPI/Swagger** | ✅ Analyse des schémas de sécurité | ❌ | ✅ Import uniquement | ✅ Import + scan | ❌ |
| **Analyse JWT** | ✅ alg=none, secrets faibles, expiration | ⚠️ Via des modèles | ⚠️ Limitée | ✅ Via extensions | ❌ |
| **Détection IDOR/BOLA** | ✅ 3 niveaux (non authentifié/plage/entre utilisateurs) | ⚠️ Modèles manuels | ⚠️ Limitée | ✅ Tests manuels | ❌ |
| **Détection de secrets** | ✅ Sensible au contexte (frontend vs backend) | ⚠️ Basé sur des regex | ⚠️ Basique | ⚠️ Basique | ❌ |
| **Vérifications actives** | ✅ En option (IDOR, mass-assignment, OAuth/OIDC, websocket, rate-limit, modèles CVE) | ✅ Basé sur des modèles | ✅ Scan actif | ✅ Scan actif | ✅ Fuzzing |
| **Contournement WAF** | ✅ Rotation UA, délais, nouvelles tentatives, timing adaptatif | ⚠️ Basique | ⚠️ Limité | ✅ Bon | ⚠️ Basique |
| **Intégration CI/CD** | ✅ NDJSON, SARIF, codes de sortie | ✅ JSON, SARIF | ⚠️ Rapports XML | ⚠️ XML/JSON | ✅ JSON |
| **Comparaison de baseline** | ✅ Intégrée | ❌ Outils externes | ❌ | ❌ | ❌ |
| **Flux d'authentification** | ✅ Connexion JSON avant scan | ⚠️ Injection d'en-tête | ✅ Gestion de session | ✅ Gestion de session | ⚠️ Injection d'en-tête |
| **Sortie en continu** | ✅ NDJSON en temps réel | ❌ Uniquement par lot | ❌ | ❌ | ✅ |
| **Utilisation des ressources** | 🟢 Faible (Rust) | 🟢 Faible (Go) | 🟡 Élevée (Java) | 🟡 Élevée (Java) | 🟢 Faible (Go) |
| **Courbe d'apprentissage** | 🟢 CLI simple | 🟢 Syntaxe de modèles | 🟡 Complexité de l'interface graphique | 🔴 Raide | 🟢 Simple |
| **Extensibilité** | ✅ Système de traits Rust | ✅ Modèles YAML | ✅ Modules complémentaires | ✅ Extensions | ⚠️ Limitée |
| **Licence** | MIT (Gratuit) | MIT (Gratuit) | Apache 2.0 (Gratuit) | Commerciale | MIT (Gratuit) |
| **Idéal pour** | Sécurité API dans CI/CD, tests de régression, analyse CORS/GraphQL/JWT | Analyse générale de vulnérabilités, détection CVE | Pentest complet d'applications web | Pentest manuel, workflows complexes | Fuzzing de répertoires/paramètres |

### Principaux différenciateurs

**ApiHunter:** Conception API-first, détection SPA, diffing de baseline, IDOR/BOLA à 3 niveaux, secrets sensibles au contexte, concurrence AIMD, **contournement furtif/WAF (rotation UA, gigue, timing adaptatif)**, **double extensibilité (modèles TOML + modules Rust)**  
**Nuclei:** Couverture CVE élargie, modèles YAML uniquement, évasion basique  
**ZAP/Burp:** Tests manuels, workflows proxy, extensions basées sur l'interface graphique, furtivité limitée  
**ffuf:** Fuzzing pur, découverte de contenu, extensibilité limitée, évasion basique

## Démarrage rapide```bash
cargo build --release

# Scan URLs from a file (newline-delimited)
./target/release/apihunter --urls ./targets/cve-regression-real-public.txt --format ndjson --output ./results.ndjson

# Or scan URLs from stdin
cat ./targets/cve-regression-real-public.txt | ./target/release/apihunter --stdin --min-severity medium

L'entrée de scan desktop prend en charge :
- Saisie manuelle de plusieurs cibles (une URL par ligne ou séparées par des virgules)
- Import CSV via `Load CSV` (max 307 200 octets / 300 Kio)
- Préréglages de scan guidé : `Quick Passive` et `Deep Active`
- Limite stricte : jusqu'à 3 000 cibles par exécution (dédupliquées + validées comme URL `http/https` absolues)
- Contrôles de portée : découverte activée/désactivée, filtrage d'accessibilité + délai d'expiration, nombre maximal de points de terminaison par site
- Contrôles de versionnage d'API : bascule facultative de sondage approfondi des différences de réponse
- Contrôles avancés : proxy, en-têtes, cookies, authentification bearer/basic, bascule TLS pour certificat invalide
- Entrée de corrélation de callback SSRF aveugle (`OAST callback base`) pour les contrôles actifs
- Contrôles de performances : clients par hôte, concurrence adaptative, évasion WAF avec pool d'user-agents personnalisés
- Couverture complète des bascules du scanner, y compris `API Versioning` et `gRPC/Protobuf`
- Sections de scan repliables avec chevrons alignés à droite ; `Safety and Scan Behavior`, `Runtime Limits` et `Scanner toggles` sont réduites par défaut
- Cartes de progression des exécutions parallèles avec instantanés d'achèvement/constatations par cible
- Tableau de bord d'analyse des résultats : carte thermique de sévérité, carte de la pire cible, efficacité du scan, couverture du scanner, principaux chemins vulnérables, répartition de la sévérité des contrôles
- Persistance de session : restauration automatique des derniers résultats de scan au prochain lancement
- Panneau Mode Enrich : charger les constatations NDJSON, exécuter l'enrichissement threat-intel, promouvoir les hôtes à score élevé directement vers Full Scan avec le préréglage Deep Active
- UX d'exportation : libellés de taille + `Save All Reports` + noms de fichiers horodatés par exécution ; les exportations incluent des bundles JSON par cible, NDJSON, SARIF, collection Insomnia et données Insomnia Runner

Voir [HOWTO.md](https://github.com/teycir/apihunter/blob/HEAD/HOWTO.md) pour une utilisation détaillée, [docs/lab-setup.md](https://github.com/teycir/apihunter/blob/HEAD/docs/lab-setup.md) pour les laboratoires de validation CVE basés sur Vulhub, et [docs/](https://github.com/teycir/apihunter/blob/HEAD/docs/) pour les détails internes.

Si vous souhaitez un binaire desktop de version :```bash
cd apps/desktop
npm run tauri build
./src-tauri/target/release/apihunter-desktop

Remarque : le démarrage du dev desktop utilise désormais directement les assets frontend compilés et ne nécessite pas de serveur `localhost:1420` séparé.

Consultez [HOWTO.md](https://github.com/teycir/apihunter/blob/HEAD/HOWTO.md) pour une utilisation détaillée, [docs/lab-setup.md](https://github.com/teycir/apihunter/blob/HEAD/docs/lab-setup.md) pour les laboratoires de validation CVE basés sur Vulhub, et [docs/](https://github.com/teycir/apihunter/blob/HEAD/docs/) pour les détails internes.

### Exemple de résultat NDJSON```json
{
  "url": "https://api.example.com/graphql",
  "check": "graphql/introspection-enabled",
  "title": "GraphQL introspection is enabled",
  "severity": "MEDIUM",
  "detail": "Introspection query returned schema metadata from a public endpoint.",
  "evidence": "POST /graphql -> HTTP 200 with __schema fields in response body",
  "scanner": "graphql",
  "timestamp": "2026-03-19T14:02:11.824Z"
}

**Flux:** CLI args → Config → Runner orchestre Discovery + Scanners → HTTP Client (avec Auth/WAF) → Reports

## Outillage de templates

ApiHunter prend en charge **une double extensibilité** : ajoutez des vérifications via **des templates TOML** (sans code) ou **des modules Rust** (contrôle total).

### Format de template TOML
Créez des vérifications personnalisées dans `assets/cve_templates/*.toml` :```toml
id = "custom-api-check"
name = "Custom API Vulnerability"
severity = "high"

[[requests]]
method = "GET"
path = "/api/vulnerable"

[[requests.matchers]]
type = "status"
values = [200]

[[requests.matchers]]
type = "word"
part = "body"
words = ["sensitive_data", "exposed"]

### Ajouter des scanners Rust personnalisés
Implémentez le trait `Scanner` pour la logique complexe :```rust
#[async_trait]
impl Scanner for MyCustomScanner {
    async fn scan(
        &self,
        url: &str,
        client: &HttpClient,
        config: &Config,
    ) -> (Vec<Finding>, Vec<CapturedError>) {
        // Your custom scanning logic
    }
}

Tous les scripts wrapper sauf `split-by-host.sh` prennent en charge `--stdin` et les indicateurs ApiHunter en fin de ligne.

## Stratégie de test

Les tests d'ApiHunter sont répartis par intention :

- **Tests unitaires** (`tests/*_scanner.rs`, tests du parseur/config) : logique du scanner et cas limites.
- **Tests d'intégration** (`tests/integration_runner.rs`, comportement de démarrage/CLI) : orchestration et câblage d'exécution.
- **Tests de régression sur données de référence** (`tests/cve_templates_real_data.rs`, `tests/cve_templates_upstream_parity.rs`) : rejouent de vrais payloads et comparent avec les modèles amont épinglés.
- **Tests avec serveur simulé** (plusieurs suites de scanners) : vérifications du comportement déterministe sans dépendre de cibles internet.
- **Vérifications sur cible réelle** : uniquement facultatives/manuelles (ne font pas partie du `cargo test` par défaut).

Consultez le [Guide de test](https://github.com/teycir/apihunter/blob/HEAD/docs/testing.md) dédié pour la matrice de tests complète et la carte de couverture.

Lancez les suites ciblées :```bash
cargo test --test cors_scanner
cargo test --test graphql_scanner
cargo test --test cve_templates_runtime_ext
cargo test --test integration_runner

Exécutez la passerelle d'intégration avec des données réelles (fixtures + suites ignorées live) :```bash
# Fixture-backed real payload regression suites
cargo test --test cve_templates_real_data --test cve_templates_upstream_parity --test cve_templates_runtime_ext

# Manual live internet integration suites (ignored by default)
cargo test --test live_vulnerable_apis --test live_real_world_targets -- --ignored

### Artefacts de version précompilés

Les versions taguées (`v*`) publient des binaires `apihunter` précompilés pour :

- Linux (`x86_64-unknown-linux-gnu`, `aarch64-unknown-linux-gnu`)
- macOS (`x86_64-apple-darwin`)
- Windows (`x86_64-pc-windows-msvc`)

Chaque version publie également des artefacts de chaîne d'approvisionnement :

- Fichiers de somme de contrôle SHA256 (`*.sha256`)
- Matériaux de signature sans clé Sigstore (`*.sig`, `*.pem`, `*.sigstore.json`)
- SBOM JSON SPDX (`apihunter-release-assets-sbom.spdx.json`)
- Attestations d'artefacts GitHub (métadonnées d'attestation de provenance et de SBOM)

Téléchargez depuis [GitHub Releases](https://github.com/Teycir/ApiHunter/releases).

### Installation de l'application de bureau (Tauri + React)

Le code source de l'application de bureau se trouve dans `apps/desktop`.

Compilez et exécutez un binaire de bureau de production :```bash
cd apps/desktop
npm install
npm run tauri build
./src-tauri/target/release/apihunter-desktop

Installer une icône de lanceur Linux cliquable :```bash
cd apps/desktop
npm run desktop:install-icon

Lancez un scan à partir des fichiers de votre répertoire courant :```bash
docker run --rm -v "$PWD:/work" apihunter:local \
  --urls /work/targets/cve-regression-real-public.txt \
  --format ndjson \
  --output /work/results.ndjson

**Q : Diffing de référence ?**```bash
./target/release/apihunter --urls targets/cve-regression-real-public.txt --format ndjson --output baseline.ndjson
./target/release/apihunter --urls targets/cve-regression-real-public.txt --baseline baseline.ndjson --format ndjson