discover

Custom bash scripts used to automate various penetration testing tasks including recon, scanning, 
enumeration, and malicious payload creation using Metasploit. For use with Kali Linux or Ubuntu.

* Sélectionnez **Update** (option 16 du menu principal) pour mettre à jour le système d'exploitation et installer les dépendances (`ffuf`, `feroxbuster`, `jq`, etc.).
* Les scanners de développement se trouvent dans `dev/` et sont également accessibles depuis l'option **15. Dev** du menu principal.
* Certaines options nécessiteront des identifiants root pour être exécutées.

### Menu principal```
RECON
1.  Domain
2.  Person

SCANNING
3.  Generate target list
4.  CIDR
5.  List
6.  IP, range, or URL
7.  Rerun Nmap scripts and MSF aux

WEB
8.  Insecure direct object reference
9.  Open multiple tabs in Firefox
10. Nikto
11. SSL

MISC
12. Parse XML
13. Generate a malicious payload
14. Start a Metasploit listener
15. Dev
16. Update
17. Exit

- [détection de CVE](https://www.kitploit.com/search/label/CVE) par recherche de motifs
- extraction de toutes les URLs de l'outil
- le framework principal est segmenté en commandes (énumération, exploitation, tests, etc.)
- facilité de contribution avec un système de plugins
- support multi-threading pour des analyses plus rapides
- proxy configurable pour l'anonymat
- journalisation persistante dans des fichiers Markdown pour les rapports

> **Avertissement :** Cet outil est conçu uniquement pour des tests de sécurité autorisés et à des fins éducatives. Une utilisation non autorisée sur des systèmes sans permission explicite est illégale. Les développeurs n'assument aucune responsabilité en cas de mauvaise utilisation ou de dommages.```
dev/
├── api-scanner.sh
├── cloud-scanner.sh
├── container-scanner.sh
├── oauth-jwt-scanner.sh
├── open-redirect.sh
├── sensitive-scanner.sh
├── waf-detect.sh
├── web-api-scanner.sh
├── data/
│   ├── api-paths.txt
│   ├── openredirect-payloads.txt
│   ├── sensitive-denylist.txt
│   ├── sensitive-patterns.tsv
│   ├── sensitive-skip-paths.txt
│   ├── sensitive-web-paths-quick.txt
│   ├── sensitive-web-paths-full.txt
│   ├── waf-aliases.tsv
│   ├── waf-labels.tsv
│   ├── waf-signatures.tsv
│   ├── web-api-phases.tsv
│   ├── web-api-tech-signatures.tsv
│   └── swagger-paths.txt
└── lib/
    ├── api-scanner/
    │   └── common.sh
    ├── cloud-scanner/
    │   ├── common.sh
    │   ├── aws.sh
    │   ├── azure.sh
    │   └── gcp.sh
    ├── container-scanner/
    │   ├── common.sh
    │   ├── docker.sh
    │   └── k8s.sh
    ├── oauth-jwt-scanner/
    │   ├── common.sh
    │   ├── oauth.sh
    │   └── jwt.sh
    ├── open-redirect-scanner/
    │   ├── common.sh
    │   └── engine.py
    ├── sensitive-scanner/
    │   ├── common.sh
    │   ├── files.sh
    │   ├── web.sh
    │   ├── filescan.py
    │   ├── engine.py
    │   ├── fixtures/
    │   └── run-tests.sh
    ├── waf-detect/
    │   ├── common.sh
    │   ├── probe.sh
    │   ├── fixtures/
    │   └── run-tests.sh
    └── web-api-scanner/
        ├── common.sh
        ├── phases.sh
        ├── waf.sh
        ├── targets.sh
        ├── msf.sh
        ├── msf_parse.py
        ├── probe.sh
        ├── fixtures/
        └── run-tests.sh

Note : Passive et Active ne peuvent pas être exécutés en tant que root.

RECON PASSIVE

Utilise Amass, ARIN, DNSRecon, dnstwist, Metasploit, subfinder,
sublist3r, theHarvester, Whois, et plusieurs sites web.

* Acquérez toutes les clés API gratuites pour des résultats optimaux avec theHarvester.
* Ajoutez les clés API à $HOME/.theHarvester/api-keys.yaml
* Passive génère un rapport HTML dans $HOME/data/<domain>/.
* Find registered domains met à jour pages/registered-domains.htm dans un rapport existant.
* Active utilise httpx, whatweb et gowitness ; une clé API NVD optionnelle accélère l'enrichissement CVSS
  sur le rapport Active (voir **Clé API NVD** ci-dessous).

#### Importation des noms (`import-names.sh`)

Exécutez après un scan passif lorsque vous souhaitez ajouter ou enrichir les contacts issus de recherches manuelles
(LinkedIn, sites d'entreprise, annuaires téléphoniques, etc.).```
Enter the location of your previous passive scan:
/home/user/data/example.com

Enter manual contacts file (or press Enter for default):

Importations prises en charge :

* `firefox` — récupère les `pinia/scans` de votre profil Firefox (scans Pentest-Tools gratuits)
* Export `pinia/scans` de Firefox (`pinia-scans.json`)
* JSON Pentest-Tools (`pentest-tools-<domain>.json`)
* Export texte Pentest-Tools (`pentest-tools.txt`)
* Lignes hôte/IP séparées par des tabulations

* Modifiez `$HOME/data/<domain>/tools/subdomains-import.tsv` pour les entrées manuelles
* Format : Sous-domaine, IP (séparés par tabulation ; IP facultatif)
* Les hôtes sans IP sont résolus avec `dig` lors de l'importation
* Réexécutez Importer sous-domaines chaque fois que vous ajoutez des lignes ou lancez un nouveau scan Pentest-Tools

Importer sous-domaines fusionne avec `tools/subdomains` existant, assigne des catégories depuis
`old/subdomain-categories.tsv`, sépare les IP privées vers `tools/private-subs`,
et rafraîchit `pages/subdomains.htm` avec les colonnes Sous-domaine, Catégorie et IP uniquement.
Exécutez **Active** ensuite pour remplir Photo, Statut, Serveur Web et Technologies.

#### Active (`active.sh`)

RECON ACTIVE

Exécutez après un scan passif (et éventuellement Importer sous-domaines) lorsque vous souhaitez sonder
quels hôtes publics répondent sur HTTP/HTTPS, identifier les technologies et capturer
des captures d'écran.```
Enter the location of your previous passive scan:
/home/user/data/example.com

**Obtenez une clé API gratuite**

1. Demandez une clé : https://nvd.nist.gov/developers/request-an-api-key
2. Confirmez l'email envoyé par NIST
3. Fournissez la clé à Discover (export shell et/ou fichier `.env` privé — voir ci-dessous)

**Comment Discover trouve la clé**

Ordre de priorité (les valeurs non vides les plus hautes dans la liste l'emportent toujours) :

1. Environnement shell — `export NVD_API_KEY=...`
2. Fichier `.env` privé dans l'installation de Discover — `$DISCOVER/.env`
3. Fichier `.env` privé dans votre configuration personnelle — `~/.discover/.env`

Exemple de ligne `.env` (pas de guillemets requis) :```
NVD_API_KEY=your-key-here

(p. ex. `~/discover/resource/known_exploited_vulnerabilities.json`)

Source: https://www.cisa.gov/sites/default/files/feeds/known_exploited_vulnerabilities.json  
Catalog: https://www.cisa.gov/known-exploited-vulnerabilities-catalog

Si le téléchargement échoue, tout catalogue local précédent reste en place. Le fichier est
ignoré par git (actualisé par Update, pas commit).

Dans le tableau **Versions logicielles** actif, **Top CVE** privilégie une correspondance CISA KEV
lorsque l'un des CVE NVD du produit apparaît dans le catalogue KEV (le CVSS le plus élevé parmi
les KEV l'emporte). Sinon, Top CVE est le résultat NVD avec le CVSS le plus élevé. Les sélections KEV affichent
un badge **KEV** orange à côté de l'ID CVE lié.

#### Direction de la SEC (page Noms)

Pour les sociétés ouvertes américaines, Discover extrait les dirigeants et administrateurs de la SEC
EDGAR avant l'étape de fusion des noms :

1. **DEF 14A** — texte de la déclaration de procuration et tableaux du conseil pour les titres complets
2. **Formulaire 4** — dépôts récents d'initiés pour compléter les dirigeants et administrateurs

* Les résultats sont écrits dans zsec-people et fusionnés dans tools/names avec les
  colonnes existantes Nom, Titre, Téléphone (téléphone laissé vide).
* Les dépôts SEC ne fournissent pas d'e-mails professionnels ni de numéros de téléphone individuels.
* La disposition de la page Noms reste inchangée — aucune colonne email n'est ajoutée.
* Surcharge manuelle : tools/sec-people-manual.tsv (séparé par tabulation : Nom, Titre, Téléphone).

#### Siège social (page Résumé)

Lors de la reconnaissance passive, Discover tente de remplir le bloc d'adresse et de téléphone sur
pages/summary.htm entre le nom de l'entreprise et le domaine.

1. **SEC EDGAR 10-K** — pour les sociétés ouvertes américaines, lit les champs du bureau exécutif
   principal du dernier 10-K (balises XBRL en ligne `dei:` tags).
2. **Pied de page du site web** — si la SEC ne correspond pas, scanne le pied de page mis en cache de la page d'accueil
   (et les pages de contact) pour les motifs d'adresse/téléphone.
3. **Surcharge manuelle** — ajoutez des entrées à tools/company-manual.tsv lorsque la découverte
   est erronée ou bloquée.

Les résultats sont écrits dans tools/company.json et injectés dans pages/summary.htm.

#### Médias sociaux (page Résumé)

Lors de la reconnaissance passive, Discover récupère la page d'accueil de l'entreprise et extrait
les liens officiels des profils sociaux (Facebook, Instagram, LinkedIn, X, YouTube).
Il tente ensuite d'obtenir le nombre d'abonnés de chaque profil.

* Les résultats sont écrits dans tools/social.tsv et injectés dans pages/summary.htm.
* Si une plateforme bloque le scraping, le nombre d'abonnés affiche **Bloqué**.
* Si la page d'accueil est bloquée par un bot, ajoutez des URL à tools/social-manual.tsv
  (séparé par tabulation : Plateforme, URL) avant ou après l'analyse.

### Person```
RECON

First name:
Last name:

* Utilisez différents outils pour créer une liste de cibles, notamment Angry IP Scanner, arp-scan, netdiscover et Nmap pingsweep.

### CIDR, List, IP, Range, or URL```
Type of scan:

1.  External
2.  Internal
3.  Previous menu

### Ouvrir plusieurs onglets dans Firefox```
Open multiple tabs in Firefox with:

1.  List
2.  Files in a directory
3.  Directories in robots.txt
4.  Previous menu
```
Exemples :
* Une liste contenant plusieurs IP et/ou URLs.
* Vous avez terminé de scanner plusieurs sites web avec Nikto et souhaitez ouvrir chaque rapport htm situé dans un répertoire.
* Utilisez wget pour télécharger le fichier robot.txt d'un domaine, puis ouvrez tous les répertoires.

### Nikto```
This option cannot be ran as root.

Run multiple instances of Nikto in parallel.

1.  List of IPs
2.  List of IP:port
3.  Previous menu
```
### SSL```
Check for SSL certificate issues.

List of IP:port.


Enter the location of your file:
```
* Utilise sslscan, sslyze et Nmap pour vérifier les problèmes de certificats SSL/TLS.

## MISC
### Analyser XML```
Parse XML to CSV.

1.  Burp (Base64)
2.  Nessus (.nessus)
3.  Nexpose (XML 2.0)
4.  Nmap
5.  Qualys
6.  Previous menu
```
### Générer une charge utile malveillante```
Malicious Payloads

1.   android/meterpreter/reverse_tcp         (.apk)
2.   cmd/windows/reverse_powershell          (.bat)
3.   java/jsp_shell_reverse_tcp (Linux)      (.jsp)
4.   java/jsp_shell_reverse_tcp (Windows)    (.jsp)
5.   java/shell_reverse_tcp                  (.war)
6.   linux/x64/meterpreter_reverse_https     (.elf)
7.   linux/x64/meterpreter_reverse_tcp       (.elf)
8.   linux/x64/shell/reverse_tcp             (.elf)
9.   osx/x64/meterpreter_reverse_https       (.macho)
10.  osx/x64/meterpreter_reverse_tcp         (.macho)
11.  php/meterpreter_reverse_tcp             (.php)
12.  python/meterpreter_reverse_https        (.py)
13.  python/meterpreter_reverse_tcp          (.py)
14.  windows/x64/meterpreter_reverse_https   (multi)
15.  windows/x64/meterpreter_reverse_tcp     (multi)
16.  Previous menu
```
### Démarrer un écouteur Metasploit```
Metasploit Listeners

1.   android/meterpreter/reverse_tcp
2.   cmd/windows/reverse_powershell
3.   java/jsp_shell_reverse_tcp
4.   linux/x64/meterpreter_reverse_https
5.   linux/x64/meterpreter_reverse_tcp
6.   linux/x64/shell/reverse_tcp
7.   osx/x64/meterpreter_reverse_https
8.   osx/x64/meterpreter_reverse_tcp
9.   php/meterpreter/reverse_tcp
10.  python/meterpreter_reverse_https
11.  python/meterpreter_reverse_tcp
12.  windows/x64/meterpreter_reverse_https
13.  windows/x64/meterpreter_reverse_tcp
14.  Previous menu
```
### Mise à jour (option 16 du menu principal)

* Met à jour le système d'exploitation, effectue un git pull depuis divers dépôts, et met à jour la base de données locate.
* Installe les outils utilisés par les scanners de dev (par exemple `ffuf`, `feroxbuster`, `jq`, `trivy`).

## DEV

Les résultats des scans sont écrits sous `$HOME/data/` sauf indication contraire. Les scanners de dev produisent des **rapports autonomes** dans leurs propres répertoires de sortie (`api-scan_*`, `cloud-scan_*`, etc.). Ils utilisent `discover.sh` pour les aides de menu et les couleurs si nécessaire, mais **n'écrivent pas** et ne mettent pas à jour le rapport HTML de reconnaissance de Discover (`report.sh`, `$NAME`, `pages/*.htm`).

### Scanner de sécurité API (`dev/api-scanner.sh`)

Découverte et tests de sécurité API par phases. Les aides partagées et les listes de mots se trouvent dans `dev/lib/api-scanner/` et `dev/data/`.

**Menu interactif**```
1. API Discovery and Testing (full)
2. API Quick Scan (discovery + docs)
3. JWT Token Analysis
4. Full API Assessment (orchestrated)
5. Previous menu
```
**CLI** (ignore le menu lorsque `-u` est défini):```
./dev/api-scanner.sh -u https://target.example --quick --authorized
./dev/api-scanner.sh -u https://target.example --full --token 'eyJ…' --authorized
./dev/api-scanner.sh --resume ~/data/api-scan_20260703-1200 -u https://target.example
./dev/api-scanner.sh -u https://target.example --orchestrate --authorized
./dev/api-scanner.sh --help
```
| Drapeau | Objectif |
|------|---------|
| `--quick` | Découverte et documentation uniquement |
| `--full` | Toutes les phases (par défaut) |
| `--orchestrate` | Analyse complète, puis invite pour les scanners associés |
| `--token` | Jeton Bearer pour les requêtes authentifiées |
| `--cookie-file` | Fichier de cookies Netscape |
| `--max-parallel N` | Travailleurs simultanés (par défaut : 3) |
| `--max-endpoints N` | Limite des points d'accès testés après fusion |
| `--skip PHASE` | Ignorer une phase (répétable) |
| `--resume DIR` | Reprendre en utilisant un répertoire de sortie existant |
| `--authorized` | Ignorer la confirmation d'autorisation |
| `--aggressive-http` | Inclure les tests des méthodes TRACE/CONNECT |

**Phases (analyse complète) :** Extraction de liens HTML/JS, fuzzing ffuf/feroxbuster, sondage de chemins, découverte OpenAPI/Swagger, tests GraphQL (introspection, profondeur, regroupement), CORS (GET + preflight), vérifications de méthodes HTTP, pic de limite de débit, analyse JWT.

**Sortie :** `$HOME/data/api-scan_<timestamp>/api_scanner/`

* `report.txt` et `report.md` — résultats locaux du scanner (non fusionnés dans le rapport de reconnaissance Discover)
* `findings.json` — export JSON consolidé de tous les résultats
* `findings_registry.tsv` — journal des résultats séparés par des tabulations (source pour l'export JSON)
* `scan.log` — piste d'audit des requêtes
* `.checkpoint/` — marqueurs de reprise par phase

Nécessite `curl` et `jq`. Utilise `ffuf` ou `feroxbuster` lorsqu'ils sont installés (installez via Discover **Update**). Inclut `discover.sh` lorsqu'il est exécuté directement pour les aides `f_banner` / menu.

### Analyseur de sécurité cloud (`dev/cloud-scanner.sh`)

Audit phasé des mauvaises configurations cloud pour AWS, Azure et GCP. Les aides partagés se trouvent dans `dev/lib/cloud-scanner/`.

**Menu interactif**```
1. AWS (Amazon Web Services)
2. Azure (Microsoft Azure)
3. GCP (Google Cloud Platform)
4. All providers
5. Previous menu
```
**CLI** (ignore le menu lorsque les flags du fournisseur sont définis) :```
./dev/cloud-scanner.sh --aws --quick
./dev/cloud-scanner.sh --azure --gcp --full
./dev/cloud-scanner.sh --aws --output-dir ~/data/cloud-scan_custom
./dev/cloud-scanner.sh --resume ~/data/cloud-scan_20260704-1200 --aws
./dev/cloud-scanner.sh --help
```
| Flag | Purpose |
|------|---------|
| `--aws` / `--azure` / `--gcp` | Exécuter un fournisseur (combiner pour plusieurs) |
| `--quick` | Vérifications axées sur l'exposition (accès public, MFA, entrée ouverte) |
| `--full` | Audit complet incluant une analyse approfondie IAM, EC2/SG multi-région, extras |
| `--output-dir DIR` | Répertoire de sortie personnalisé |
| `--resume DIR` | Reprendre en utilisant un répertoire d'analyse existant (ignore les phases terminées) |
| `-h`, `--help` | Afficher l'utilisation |

Les résultats sont écrits sous `$HOME/data/cloud-scan_YYYYMMDD-HHMM/` (ou `--output-dir`) :

* `findings_registry.tsv` — sévérité, fournisseur, service, ressource, vérification, détail, preuve
* `findings.json` — export JSON consolidé de toutes les conclusions
* `report.txt` / `report.md` — récapitulatif local du scanner (non fusionné dans le rapport de reconnaissance Discover)
* `scan.log` — journal d'activité API et de conclusions
* `.checkpoint/` — marqueurs de phase pour `--resume`

Requiert `jq` et le CLI cloud correspondant (`aws`, `az`, `gcloud`/`gsutil`) avec des identifiants configurés avant l'analyse. Le scanner n'installe pas automatiquement les CLI ni n'exécute `aws configure` / `gcloud init` de manière interactive. Il source `discover.sh` lorsqu'il est exécuté directement pour `f_banner` / les aides de menu.

### Scanner de sécurité des conteneurs (`dev/container-scanner.sh`)

Évaluation complète de la sécurité Docker et Kubernetes à l'aide de Trivy, Docker et kubectl. Sortie autonome sous `$HOME/data/container-scan_*` (ne met pas à jour les rapports HTML de reconnaissance Discover).

* **Docker images** — Analyse Trivy des vulnérabilités/secrets/config, SBOM (mode complet), analyse du Dockerfile
* **Conteneurs Docker** — mode privilégié, montages, capacités, vérifications d'exécution (mode complet)
* **Kubernetes** — RBAC, NetworkPolicies, étiquettes PSS, API obsolètes, sécurité des pods

**Types d'analyse :** `docker-images`, `docker-containers`, `kubernetes`, ou `all` (par défaut lorsqu'exécuté depuis le menu Discover).

**Options CLI :** `--quick`, `--full`, `--output-dir`, `--resume`, `--dockerfile-root`, `--include-ns`, `--exclude-ns`, `--trivy-jobs`, `--menu`, `-h`

**Artéfacts de sortie :** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `container_security_report.txt`

**Dépendances :** `docker`, `kubectl` (analyse kubernetes), `trivy`, `jq`, `numfmt` — installer via Discover Update ; pas d'installation automatique.

**Environnement :** `CONTAINER_OUTPUT_DIR`, `CONTAINER_DOCKERFILE_ROOT`, `CONTAINER_SCAN_MODE`, `CONTAINER_EXCLUDE_NS`

### Scanner de sécurité OAuth et JWT (`dev/oauth-jwt-scanner.sh`)

Découverte OAuth/OIDC, sondes d'autorisation en direct, analyse JWT hors ligne, et vérification en direct optionnelle des jetons. Complète les vérifications JWT de `api-scanner.sh`. Sortie autonome sous `$HOME/data/oauth-jwt-scan_*`.

* **OAuth/OIDC** — métadonnées de découverte, JWKS, sondes redirect_uri/state/PKCE/implicit
* **JWT hors ligne** — alg=none, confusion RS256→HS256, attaques jku/x5u/kid, hygiène des revendications, charges utiles d'escalade de privilèges
* **JWT en direct** — tests Bearer optionnels contre `--jwt-endpoint` (rempli automatiquement depuis userinfo lorsqu'il est découvert)

**Types d'analyse :** `oauth`, `jwt`, ou `all` (combiné).

**Menu :** Test OAuth, test JWT, analyse combinée, ou menu précédent.

**Exemples CLI :**```bash
./dev/oauth-jwt-scanner.sh --target https://app.example.com --full
./dev/oauth-jwt-scanner.sh --jwt 'eyJhbG...' --jwt-endpoint https://app.example.com/api/me
./dev/oauth-jwt-scanner.sh --target https://app.example.com --api-scan-dir ~/data/api-scan_20260101-1200 --all
```
**Options:** `--target`, `--jwt`, `--jwt-file`, `--api-scan-dir`, `--jwt-endpoint`, `--client-id`, `--redirect-uri`, `--quick`, `--full`, `--oauth`, `--jwt-only`, `--all`, `--output-dir`, `--resume`, `--menu`, `-h`

**Sortie:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`

**Dépendances:** `curl`, `jq`

### Scanner de Redirection Ouverte (`dev/open-redirect.sh`)

Fuzz les paramètres de redirection (injecte et mute les paramètres de requête existants) avec des hôtes canaris configurables. Détecte les redirections 3xx `Location` (avec suivi d'un saut), les rafraîchissements meta, et les redirections JavaScript/corps. Le mode complet ajoute des sondes POST et d'en-tête. Le passage de confirmation utilise un second hôte canari pour réduire les faux positifs. Moteur Python: `dev/lib/open-redirect-scanner/engine.py`; charges utiles: `dev/data/openredirect-payloads.txt`. Sortie autonome dans `$HOME/data/openredirect-scan_*`.

**Menu:** URL unique, domaine, fichier d'URL, options avancées, dossier de scan précédent, ou menu précédent.

**Exemples CLI:**```bash
./dev/open-redirect.sh --url https://app.example.com/login?next=/home --full
./dev/open-redirect.sh --domain example.com --quick
./dev/open-redirect.sh --scan-dir ~/data/api-scan_20260101-1200 --crawl --quick
./dev/open-redirect.sh --file ~/targets.txt --max-requests 500 --rps 5
```
**Options:** `--url`, `--domain`, `--file`, `--scan-dir`, `--wordlist`, `--canary-host`, `--quick`, `--full`, `--crawl`, `--workers`, `--delay`, `--rps`, `--max-requests`, `--no-confirm`, `--quiet`, `--output-dir`, `--resume`, `--menu`, `-h`

**Sortie:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `openredirect_engine/results.json`, `openredirect_engine/checkpoint.json`

**Dépendances:** `python3`, `requests` (Discover Update installe `python3-requests`), `jq`

### Scanner d'informations sensibles (`dev/sensitive-scanner.sh`)

Recherche les secrets, identifiants et PII dans les fichiers/répertoires locaux et les chemins web exposés. Orchestration Bash plus moteurs Python : `filescan.py` (scan de fichier en un seul passage) et `engine.py` (sondage web parallèle). Données de motifs : `dev/data/sensitive-patterns.tsv`, `sensitive-denylist.txt`, `sensitive-skip-paths.txt`. Sortie autonome sous `$HOME/data/sensitive-scan_*`.

* **Scan de fichier** — un passage par fichier via `filescan.py` ; denylist, globs à ignorer, filtre d'entropie, validation Luhn/SSN/TC ; `gitleaks` / `trufflehog` optionnel (`--external auto`)
* **Scan web** — workers/RPS parallèles, reprise de point de contrôle par chemin, chemins robots disallow + sitemap, import d'endpoints api-scanner, garde anti-soft-404, détection de listage de répertoire, `filescan.py` approfondi sur les corps HTTP 200
* **Hook api-scanner** — les vérifications de réponse en ligne utilisent `filescan.py` ; l'orchestrateur peut lancer automatiquement `--all` avec un jeton bearer
* **Rapports** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md` dédupliqués ; `--no-store-content` / `--shred-content` pour des artefacts plus sûrs

**Menu :** Fichier ou dossier, URL, fichier/dossier + répertoire de scan précédent, URL + sortie api-scan, ou menu précédent.

**Exemples :**```
./dev/sensitive-scanner.sh --path ./myapp --files --full
./dev/sensitive-scanner.sh --url https://app.example.com --web --quick --workers 8 --rps 5
./dev/sensitive-scanner.sh --url https://app.example.com --scan-dir ~/data/api-scan_20260101-1200 --all --quick --bearer-token "$TOKEN"
./dev/sensitive-scanner.sh --path /var/www/html/config.php --files --external gitleaks
./dev/lib/sensitive-scanner/run-tests.sh
```
**Options:** `--path`, `--url`, `--scan-dir`, `--wordlist`, `--quick`, `--full`, `--workers`, `--delay`, `--rps`, `--max-paths`, `--bearer-token`, `--insecure`, `--no-store-content`, `--shred-content`, `--redact-emails`, `--entropy-min`, `--external`, `--files`, `--web`, `--all`, `--output-dir`, `--resume`, `--quiet`, `--menu`, `-h`

**Sortie:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `sensitive_info/`, `web_sensitive/engine/{results,checkpoint}.json`

**Dépendances:** `python3`, `jq`, `find`; les scans web nécessitent `python3-requests`; optionnel `gitleaks`, `trufflehog`, `rg`

### Détection WAF (`dev/waf-detect.sh`)

Identifie les pare-feu d'applications web et les couches de périphérie CDN devant les cibles. Bibliothèque modulaire: `dev/lib/waf-detect/{common,probe}.sh`, `wafw00f_run.py`; données: `dev/data/waf-signatures.tsv`, `waf-aliases.tsv`, `waf-labels.tsv`. Sortie autonome sous `$HOME/data/waf-detection_*`.

* **Passif réel (par défaut pour le hook api-scanner)** — `--passive` envoie uniquement une requête HTTP GET normale; compare les en-têtes/corps de réponse avec `waf-signatures.tsv`. Pas de wafw00f, pas de déclencheurs SQLi, pas d'injection `X-Forwarded-For`.
* **Mode actif** — wafw00f via `wafw00f_run.py` (principal, haute confiance) plus des sondes supplémentaires de signature/comportementales. Les scans actifs non interactifs nécessitent `--i-understand`.
* **Supplémentaire** — `--supplemental auto` ignore les sondes redondantes après une détection wafw00f fiable; les résultats comportementaux nécessitent une corroboration des en-têtes WAF
* **Résultats consolidés** — une ligne par fournisseur avec la confiance (`high`/`medium`/`low`), la source et le type (`waf`/`cdn`/`both`)
* **Résultats structurés** — `waf_engine/hits.jsonl` et `findings.json` `hits[]` pour les outils en aval
* **Reprise** — `--resume DIR` reprend depuis `waf_engine/checkpoint.json`
* **Rapports** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `waf_results.tsv`

**Menu:** Cible unique, fichier de cibles ou menu précédent (avec choix actif/passif).

**Exemples:**```
./dev/waf-detect.sh --url https://app.example.com --passive
./dev/waf-detect.sh --file ~/targets.txt --passive --delay 2
./dev/waf-detect.sh --url example.com --i-understand --output-dir ~/data/waf-test
./dev/waf-detect.sh --resume ~/data/waf-detection_20260704-1200 --workers 4
./dev/lib/waf-detect/run-tests.sh
```
**Options :** `--url`, `--file`, `--output-dir`, `--resume`, `--passive`, `--i-understand`, `--waf-only`, `--insecure`, `--no-redirect`, `--proxy`, `--delay`, `--max-targets`, `--workers`, `--wafw00f`, `--supplemental`, `--input-format`, `--quiet`, `--menu`, `-h`

**Sortie :** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `waf_results.tsv`, `scan.log`, `waf_engine/{hits.jsonl,checkpoint.json,*.json}`

**Dépendances :** `curl`, `jq`, `grep`, `python3` ; `wafw00f` optionnel (mode actif, recommandé)

**Intégration api-scanner :** `api-scanner.sh --orchestrate` demande à exécuter waf-detect après l'analyse principale (passif par défaut).

### Sécurité Web et API (`dev/web-api-scanner.sh`)

Évaluation Web/API basée sur Metasploit. Bibliothèque modulaire : `dev/lib/web-api-scanner/{common,phases,msf,probe,waf,targets}.sh`, `msf_parse.py` ; données : `dev/data/web-api-{phases,tech-signatures}.tsv`. Sortie autonome dans `$HOME/data/web-api-scan_*`.

* **Niveaux** — `passive` (recon) | `standard`/`--quick` (recon + scanners techniques) | `intrusif` (+ SQLi/bruteforce) | `exploit` (+ vérifications d'exploitation)
* **Contrôle des phases** — `--phases`, `--skip-phases` ; `msfconsole` par phase avec `--phase-timeout`
* **Empreinte technologique** — pondéré `web-api-tech-signatures.tsv` (Laravel, Spring, Swagger, nginx, …)
* **Conscient du WAF** — ignore les phases de bruteforce lorsque WAF/CDN détecté (`--scan-dir` ou signatures d'en-tête)
* **Authentification** — `--bearer-token`, `--cookie-file` pour curl + MSF
* **Intégration api-scanner** — `--scan-dir` charge `api_scanner/all_endpoints.txt` pour les chemins `brute_dirs`
* **Hits structurés** — `msf_parse.py` → `msf_engine/hits.jsonl` + `findings.json` `hits[]`
* **Multi-cibles** — `--file`, `--workers`, `--max-targets`
* **Furtivité** — `--delay`, `--jitter`, `--proxy`, `THREADS` basé sur le niveau
* **Base de données MSF** — vérifications uniquement par défaut ; `--msf-db-bootstrap` pour une configuration optionnelle

**Menu :** Analyser une URL (passif par défaut) ou menu précédent.

**Exemples :**```
./dev/web-api-scanner.sh --url https://app.example.com --passive
./dev/web-api-scanner.sh --url example.com --quick --scan-dir ~/data/api-scan_*/ 
./dev/web-api-scanner.sh --url example.com --tier exploit --i-understand --bearer-token "$TOKEN"
./dev/web-api-scanner.sh --file ~/targets.txt --quick --workers 2 --max-targets 10
WEBAPI_RUN_LIVE_MSF=1 ./dev/lib/web-api-scanner/run-tests.sh
```
**Options :** `--url`, `--file`, `--tier`, `--quick`, `--phases`, `--skip-phases`, `--scan-dir`, `--bearer-token`, `--cookie-file`, `--proxy`, `--phase-timeout`, `--workers`, `--threads`, `--jitter`, `--target-ip`, `--output-dir`, `--resume`, `--passive`, `--i-understand`, `--dry-run`, `--skip-msf-db`, `--msf-db-bootstrap`, `--keep-resources`, `--no-waf-aware`, `--insecure`, `--delay`, `--quiet`, `--menu`, `-h`

**Sortie :** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `msf_engine/`

**Dépendances :** `curl`, `jq`, `grep`, `msfconsole` ; PostgreSQL recommandé pour la base de données MSF (optionnel avec `--skip-msf-db`)

**Intégration api-scanner :** `api-scanner.sh --orchestrate` invite à exécuter web-api-scanner (passif par défaut).

# Dépannage

Certains utilisateurs ont signalé ne pas pouvoir utiliser d'autres options que 3, 4 et 5. 
Rien ne se passe lorsqu'ils choisissent d'autres options (1, 2, 6, etc.).

## Vérifier le hachage du téléchargement

La vérification basée sur le hachage garantit qu'un fichier n'a pas été corrompu en comparant la valeur de hachage du fichier 
à une valeur précédemment calculée. Si ces valeurs correspondent, le fichier est présumé non modifié.

### macOS

1. Ouvrir Terminal
2. shasum -a 256 /path/to/file
3. Comparez la valeur à la somme de contrôle indiquée sur le site Web.

### Windows

1. Ouvrir PowerShell
2. Get-FileHash C:\path\to\file
3. Comparez la valeur à la somme de contrôle indiquée sur le site Web.

## Exécuter Kali sur VirtualBox ou le sous-système Windows pour Linux (WSL)

Certains utilisateurs ont signalé que la solution est d'utiliser l'image VMware au lieu de WSL. 

D'autres utilisateurs ont constaté des problèmes lors de l'exécution d'une image Kali VirtualBox préfabriquée, au lieu d'exécuter 
l'ISO Kali bare metal via VirtualBox. 
(https://www.kali.org/get-kali/#kali-bare-metal)

Si vous ne souhaitez pas ou ne pouvez pas utiliser VMware Workstation pour exécuter Kali, nous vous encourageons à essayer 
d'exécuter une ISO Kali en tant que machine invitée dans VirtualBox.

1. Téléchargez l'ISO bare metal fournie par Kali.
2. Vérifiez le hachage de l'ISO (voir ci-dessus).
3. Démarrez une nouvelle VM Kali dans VirtualBox avec l'ISO Kali bare metal.

Il y aura quelques [instructions d'installation de base](https://www.kali.org/docs/installation/hard-disk-install/) 
que vous devrez remplir lors de l'installation.

Remarque : Si vous rencontrez des problèmes pour accéder à root après avoir configuré une ISO bare metal, veuillez vous référer à : 
https://linuxconfig.org/how-to-reset-kali-linux-root-password