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.

Seleziona **Aggiorna** (opzione 16 del menu principale) per aggiornare il sistema operativo e installare le dipendenze (`ffuf`, `feroxbuster`, `jq`, ecc.).

* Gli scanner di sviluppo si trovano in `dev/` e sono anche raggiungibili dall'opzione del menu principale **15. Dev**.
* Alcune opzioni richiederanno credenziali di root per essere eseguite.

### Menu principale```
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

Please provide the Markdown content to translate.```
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

Nota: Passive e Active non possono essere eseguiti come root.

RICOGNIZIONE PASSIVA

Utilizza Amass, ARIN, DNSRecon, dnstwist, Metasploit, subfinder,
sublist3r, theHarvester, Whois e vari siti web.

* Ottieni tutte le chiavi API gratuite per risultati massimi con theHarvester.
* Aggiungi le chiavi API a $HOME/.theHarvester/api-keys.yaml
* Passive genera un report HTML in $HOME/data/<domain>/.
* Trova domini registrati aggiorna pages/registered-domains.htm in un report esistente.
* Active utilizza httpx, whatweb e gowitness; una chiave API NVD opzionale velocizza l'arricchimento CVSS nel report Active (vedi **Chiave API NVD** di seguito).

#### Importa nomi (`import-names.sh`)

Esegui dopo una scansione passiva quando desideri aggiungere o arricchire i contatti da ricerche manuali (LinkedIn, siti aziendali, elenchi telefonici, ecc.).```
Enter the location of your previous passive scan:
/home/user/data/example.com

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

Imports supportati:

* `firefox` — recupera `pinia/scans` dal tuo profilo Firefox (scansioni Pentest-Tools gratuite)
* Esportazione `pinia/scans` da Firefox (`pinia-scans.json`)
* JSON di Pentest-Tools (`pentest-tools-<dominio>.json`)
* Esportazione testo di Pentest-Tools (`pentest-tools.txt`)
* Righe host/IP separate da tabulazione

* Modifica `$HOME/data/<dominio>/tools/subdomains-import.tsv` per inserimenti manuali
* Formato: Sottodominio, IP (separati da tabulazione; IP opzionale)
* Gli host senza IP vengono risolti con `dig` durante l'importazione
* Esegui di nuovo Importa sottodomini ogni volta che aggiungi righe o esegui una nuova scansione Pentest-Tools

Importa sottodomini unisce con `tools/subdomains` esistenti, assegna categorie da
`old/subdomain-categories.tsv`, separa IP privati in `tools/private-subs`, e
aggiorna `pages/subdomains.htm` con le sole colonne Sottodominio, Categoria e IP.
Esegui **Active** successivamente per popolare Foto, Stato, Server Web e Tecnologie.

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

RICOGNIZIONE ATTIVA

Esegui dopo una scansione passiva (e opzionalmente Importa sottodomini) quando vuoi sondare
quali host pubblici rispondono su HTTP/HTTPS, identificare le tecnologie e acquisire
screenshot.```
Enter the location of your previous passive scan:
/home/user/data/example.com

**Ottieni una chiave API gratuita**

1. Richiedi una chiave: https://nvd.nist.gov/developers/request-an-api-key
2. Conferma l'email che NIST invia
3. Fornisci la chiave a Discover (export di shell e/o `.env` privato — vedi sotto)

**Come Discover trova la chiave**

Ordine di precedenza (i valori non vuoti più in alto nell'elenco vincono sempre):

1. Ambiente shell — `export NVD_API_KEY=...`
2. `.env` privato nell'installazione di Discover — `$DISCOVER/.env`
3. `.env` privato nella configurazione home — `~/.discover/.env`

Esempio di riga `.env` (non sono necessarie virgolette):```
NVD_API_KEY=your-key-here

(ad esempio `~/discover/resource/known_exploited_vulnerabilities.json`)

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

Se il download fallisce, qualsiasi catalogo locale precedente viene lasciato al suo posto. Il file è gitignored (aggiornato da Update, non committato).

Nella tabella attiva **Versioni software**, **Top CVE** preferisce una corrispondenza CISA KEV quando uno qualsiasi dei CVE NVD del prodotto appare nel catalogo KEV (il CVSS più alto tra i KEV vince). Altrimenti Top CVE è il risultato NVD con il CVSS più alto. Le selezioni KEV mostrano un badge **KEV** arancione accanto all'ID CVE collegato.

#### Dirigenza SEC (Pagina Nomi)

Per le società pubbliche statunitensi, Discover estrae dirigenti e amministratori da SEC EDGAR prima della fase di unione dei nomi:

1. **DEF 14A** — testo della dichiarazione di delega e tabelle del consiglio per titoli completi
2. **Form 4** — recenti dichiarazioni di insider per integrare funzionari e amministratori

* I risultati sono scritti in zsec-people e uniti in tools/names con le colonne esistenti Nome, Titolo, Telefono (telefono lasciato vuoto).
* I documenti SEC non forniscono email lavorative o numeri di telefono personali.
* Il layout della pagina Nomi è invariato — nessuna colonna email viene aggiunta.
* Override manuale: tools/sec-people-manual.tsv (separato da tabulazione: Nome, Titolo, Telefono).

#### Sede aziendale (Pagina Riepilogo)

Durante la ricognizione passiva, Discover tenta di riempire il blocco indirizzo e telefono su pages/summary.htm tra il nome dell'azienda e il dominio.

1. **SEC EDGAR 10-K** — per le società pubbliche statunitensi, legge i campi dell'ufficio esecutivo principale dall'ultimo 10-K (tag inline XBRL `dei:`).
2. **Piè di pagina del sito web** — se SEC non ha corrispondenza, scansiona il piè di pagina della home page memorizzata nella cache (e le pagine di contatto) per individuare modelli di indirizzo/telefono.
3. **Override manuale** — aggiungi voci a tools/company-manual.tsv quando la scoperta è errata o bloccata.

I risultati sono scritti in tools/company.json e iniettati in pages/summary.htm.

#### Social media (Pagina Riepilogo)

Durante la ricognizione passiva, Discover recupera la home page dell'azienda ed estrae i link ufficiali dei profili social (facebook, Instagram, LinkedIn, X, YouTube). Successivamente tenta di ottenere il numero di follower da ciascun profilo.

* I risultati sono scritti in tools/social.tsv e iniettati in pages/summary.htm.
* Se una piattaforma blocca lo scraping, il conteggio dei follower mostra **Bloccato**.
* Se la home page è bloccata dai bot, aggiungi URL a tools/social-manual.tsv (separato da tabulazione: Piattaforma, URL) prima o dopo la scansione.

### Persona```
RECON

First name:
Last name:

* Usa strumenti diversi per creare una lista di target inclusi Angry IP Scanner, arp-scan, netdiscover, e Nmap pingsweep.

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

1.  External
2.  Internal
3.  Previous menu

### Aprire più schede in Firefox```
Open multiple tabs in Firefox with:

1.  List
2.  Files in a directory
3.  Directories in robots.txt
4.  Previous menu
```
Esempi:
* Una lista contenente più IP e/o URL.
* Hai terminato la scansione di più siti web con Nikto e vuoi aprire ogni report .htm presente in una directory.
* Usa wget per scaricare il file robot.txt di un dominio, poi apri tutte le directory.

### 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:
```
* Utilizza sslscan, sslyze e Nmap per verificare problemi di certificato SSL/TLS.

## VARIE
### Analisi XML```
Parse XML to CSV.

1.  Burp (Base64)
2.  Nessus (.nessus)
3.  Nexpose (XML 2.0)
4.  Nmap
5.  Qualys
6.  Previous menu
```
### Genera un payload dannoso```
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
```
### Avvia un listener 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
```
### Aggiornamento (opzione 16 del menu principale)

* Aggiorna il sistema operativo, esegue git pull da vari repos e aggiorna il database locate.
* Installa strumenti usati dagli scanner di sviluppo (ad esempio `ffuf`, `feroxbuster`, `jq`, `trivy`).

## SVILUPPO

I risultati delle scansioni vengono scritti in `$HOME/data/` se non diversamente specificato. Gli scanner di sviluppo producono **report autonomi** nelle proprie directory di output (`api-scan_*`, `cloud-scan_*`, ecc.). Caricano `discover.sh` per helper del menu e colori quando necessario, ma **non** scrivono né aggiornano il report HTML di Discover (`report.sh`, `$NAME`, `pages/*.htm`).

### Scanner API di Sicurezza (`dev/api-scanner.sh`)

Rilevamento API a fasi e test di sicurezza. Gli helper condivisi e le wordlist si trovano in `dev/lib/api-scanner/` e `dev/data/`.

**Menu interattivo**```
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** (salta il menu quando `-u` è impostato):```
./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
```
| Flag | Scopo |
|------|---------|
| `--quick` | Solo discovery e documentazione |
| `--full` | Tutte le fasi (predefinito) |
| `--orchestrate` | Scansione completa, quindi richiede scanner correlati |
| `--token` | Token Bearer per richieste autenticate |
| `--cookie-file` | Archivio cookie Netscape |
| `--max-parallel N` | Lavoratori concorrenti (predefinito: 3) |
| `--max-endpoints N` | Limite endpoint testati dopo l'unione |
| `--skip PHASE` | Salta una fase (ripetibile) |
| `--resume DIR` | Riprendi utilizzando una directory di output esistente |
| `--authorized` | Salta il prompt di conferma autorizzazione |
| `--aggressive-http` | Includi test dei metodi TRACE/CONNECT |

**Fasi (scansione completa):** Estrazione link HTML/JS, fuzzing ffuf/feroxbuster, probing dei path, discovery OpenAPI/Swagger, test GraphQL (introspezione, profondità, batching), CORS (GET + preflight), controlli metodi HTTP, burst rate-limit, analisi JWT.

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

* `report.txt` e `report.md` — risultati locali dello scanner (non uniti nel report di ricognizione Discover)
* `findings.json` — esportazione JSON consolidata di tutti i risultati
* `findings_registry.tsv` — registro risultati separato da tabulazione (fonte per esportazione JSON)
* `scan.log` — traccia di audit delle richieste
* `.checkpoint/` — marcatori di ripresa per fase

Richiede `curl` e `jq`. Utilizza `ffuf` o `feroxbuster` se installati (installazione tramite Discover **Update**). Include `discover.sh` quando eseguito direttamente per `f_banner` / helper del menu.

### Cloud Security Scanner (`dev/cloud-scanner.sh`)

Audit di configurazione errata del cloud a fasi per AWS, Azure e GCP. Gli helper condivisi risiedono in `dev/lib/cloud-scanner/`.

**Menu interattivo**```
1. AWS (Amazon Web Services)
2. Azure (Microsoft Azure)
3. GCP (Google Cloud Platform)
4. All providers
5. Previous menu
```
**CLI** (salta il menu quando i flag del provider sono impostati):```
./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 | Scopo |
|------|---------|
| `--aws` / `--azure` / `--gcp` | Esegui un provider (combina per multipli) |
| `--quick` | Controlli incentrati sull'esposizione (accesso pubblico, MFA, ingresso aperto) |
| `--full` | Audit completo che include analisi approfondita IAM, EC2 multi-regione/SG, extra |
| `--output-dir DIR` | Directory di output personalizzata |
| `--resume DIR` | Riprendi usando una directory di scansione esistente (salta le fasi completate) |
| `-h`, `--help` | Mostra utilizzo |

I risultati vengono scritti in `$HOME/data/cloud-scan_YYYYMMDD-HHMM/` (o `--output-dir`):

* `findings_registry.tsv` — gravità, fornitore, servizio, risorsa, controllo, dettaglio, evidenza
* `findings.json` — esportazione JSON consolidata di tutti i risultati
* `report.txt` / `report.md` — riepilogo locale dello scanner (non unito nel report di ricognizione Discover)
* `scan.log` — registro attività API e risultati
* `.checkpoint/` — marcatori di fase per `--resume`

Richiede `jq` e il CLI cloud pertinente (`aws`, `az`, `gcloud`/`gsutil`) con credenziali configurate prima della scansione. Lo scanner non installa automaticamente i CLI né esegue `aws configure` / `gcloud init` interattivi. Sorgente `discover.sh` quando eseguito direttamente per gli helper `f_banner` / menu.

### Scanner Di Sicurezza dei Container (`dev/container-scanner.sh`)

Valutazione completa della sicurezza di Docker e Kubernetes utilizzando Trivy, Docker e kubectl. Output autonomo in `$HOME/data/container-scan_*` (non aggiorna i report HTML di ricognizione Discover).

* **Immagini Docker** — scansione vulnerabilità/secret/config di Trivy, SBOM (modalità completa), analisi Dockerfile
* **Container Docker** — modalità privilegiata, mount, capacità, controlli runtime (modalità completa)
* **Kubernetes** — RBAC, NetworkPolicies, etichette PSS, API deprecate, sicurezza dei pod

**Tipi di scansione:** `docker-images`, `docker-containers`, `kubernetes` o `all` (predefinito quando eseguito dal menu Discover).

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

**Artefatti di output:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `container_security_report.txt`

**Dipendenze:** `docker`, `kubectl` (scansione kubernetes), `trivy`, `jq`, `numfmt` — installa tramite Discover Update; nessuna auto-installazione.

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

### Scanner di Sicurezza OAuth e JWT (`dev/oauth-jwt-scanner.sh`)

Scoperta OAuth/OIDC, sonde di autorizzazione live, analisi JWT offline e verifica live facoltativa dei token. Complementa i controlli JWT di `api-scanner.sh`. Output autonomo in `$HOME/data/oauth-jwt-scan_*`.

* **OAuth/OIDC** — metadati di discovery, JWKS, sonde redirect_uri/state/PKCE/implicit
* **JWT offline** — alg=none, confusione RS256→HS256, attacchi jku/x5u/kid, igiene dei claim, payload di escalation dei privilegi
* **JWT live** — test Bearer facoltativi contro `--jwt-endpoint` (compilato automaticamente da userinfo quando scoperto)

**Tipi di scansione:** `oauth`, `jwt` o `all` (combinato).

**Menu:** test OAuth, test JWT, scansione combinata o menu precedente.

**Esempi 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`

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

**Dependencies:** `curl`, `jq`

### Scanner di Reindirizzamento Aperto (`dev/open-redirect.sh`)

Effettua fuzzing dei parametri di reindirizzamento (iniettando e mutando i parametri della query esistenti) con host canarini configurabili. Rileva redirect 3xx `Location` (con follow a un hop), meta refresh e redirect JavaScript/body. La modalità completa aggiunge sonde POST e di intestazione. Un passaggio di conferma utilizza un secondo host canarino per ridurre i falsi positivi. Motore Python: `dev/lib/open-redirect-scanner/engine.py`; payload: `dev/data/openredirect-payloads.txt`. Output autonomo in `$HOME/data/openredirect-scan_*`.

**Menu:** URL singola, dominio, file di URL, opzioni avanzate, directory di scansione precedente o menu precedente.

**Esempi 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
```
**Opzioni:** `--url`, `--domain`, `--file`, `--scan-dir`, `--wordlist`, `--canary-host`, `--quick`, `--full`, `--crawl`, `--workers`, `--delay`, `--rps`, `--max-requests`, `--no-confirm`, `--quiet`, `--output-dir`, `--resume`, `--menu`, `-h`

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

**Dipendenze:** `python3`, `requests` (Discover Update installa `python3-requests`), `jq`

### Scanner di Informazioni Sensibili (`dev/sensitive-scanner.sh`)

Caccia a segreti, credenziali e PII in file/directory locali e percorsi web esposti. Orchestrazione Bash più motori Python: `filescan.py` (scansione file a passaggio singolo) e `engine.py` (sondaggio web parallelo). Dati pattern: `dev/data/sensitive-patterns.tsv`, `sensitive-denylist.txt`, `sensitive-skip-paths.txt`. Output standalone in `$HOME/data/sensitive-scan_*`.

* **File scan** — un passaggio per file tramite `filescan.py`; denylist, skip globs, filtro di entropia, validazione Luhn/SSN/TC; opzionale `gitleaks` / `trufflehog` (`--external auto`)
* **Web scan** — workers/RPS paralleli, ripresa per percorso con checkpoint, percorsi robots disallow + sitemap, importazione endpoint api-scanner, soft-404 guard, rilevamento elenchi di directory, `filescan.py` approfondito su corpi HTTP 200
* **api-scanner hook** — controlli di risposta inline usano `filescan.py`; l'orchestratore può avviare automaticamente `--all` con bearer token
* **Reports** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md` deduplicati; `--no-store-content` / `--shred-content` per artefatti più sicuri

**Menu:** File o cartella, URL, file/cartella + directory di scansione precedente, URL + output api-scan, o menu precedente.

**Esempi:**```
./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
```
**Opzioni:** `--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`

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

**Dipendenze:** `python3`, `jq`, `find`; le scansioni web necessitano di `python3-requests`; opzionali `gitleaks`, `trufflehog`, `rg`

### Rilevamento WAF (`dev/waf-detect.sh`)

Identifica firewall per applicazioni web e layer edge CDN davanti ai target. Libreria modulare: `dev/lib/waf-detect/{common,probe}.sh`, `wafw00f_run.py`; dati: `dev/data/waf-signatures.tsv`, `waf-aliases.tsv`, `waf-labels.tsv`. Output autonomo in `$HOME/data/waf-detection_*`.

* **Passivo reale (predefinito per l'hook api-scanner)** — `--passive` invia solo una normale richiesta HTTP GET; confronta header/body della risposta con `waf-signatures.tsv`. Nessun wafw00f, nessun trigger SQLi, nessuna iniezione di `X-Forwarded-For`.
* **Modalità attiva** — wafw00f tramite `wafw00f_run.py` (primaria, alta confidenza) più sonde supplementari basate su firme/comportamento. Le scansioni attive non interattive richiedono `--i-understand`.
* **Supplementare** — `--supplemental auto` salta sonde ridondanti dopo un riscontro wafw00f affidabile; i risultati comportamentali necessitano di corroborazione dell'header WAF
* **Risultati consolidati** — una riga per vendor con confidenza (`alta`/`media`/`bassa`), sorgente e tipo (`waf`/`cdn`/`entrambi`)
* **Hits strutturati** — `waf_engine/hits.jsonl` e `findings.json` `hits[]` per tool downstream
* **Ripresa** — `--resume DIR` riprende da `waf_engine/checkpoint.json`
* **Report** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `waf_results.tsv`

**Menu:** Singolo target, file di target o menu precedente (con scelta attivo/passivo).

**Esempi:**```
./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
```
**Opzioni:** `--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`

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

**Dipendenze:** `curl`, `jq`, `grep`, `python3`; opzionale `wafw00f` (modalità attiva, consigliata)

**Integrazione api-scanner:** `api-scanner.sh --orchestrate` chiede di eseguire waf-detect dopo la scansione principale (passivo per impostazione predefinita).

### Sicurezza Web e API (`dev/web-api-scanner.sh`)

Basato su Metasploit per la valutazione web/API. Libreria modulare: `dev/lib/web-api-scanner/{common,phases,msf,probe,waf,targets}.sh`, `msf_parse.py`; dati: `dev/data/web-api-{phases,tech-signatures}.tsv`. Output autonomo in `$HOME/data/web-api-scan_*`.

* **Livelli** — `passive` (ricognizione) | `standard`/`--quick` (ricognizione + scanner tecnologici) | `intrusive` (+ SQLi/brute) | `exploit` (+ controlli exploit)
* **Controllo delle fasi** — `--phases`, `--skip-phases`; `msfconsole` per fase con `--phase-timeout`
* **Impronta tecnologica** — `web-api-tech-signatures.tsv` pesato (Laravel, Spring, Swagger, nginx, …)
* **Consapevole del WAF** — salta le fasi brute quando viene rilevato WAF/CDN (`--scan-dir` o firme header)
* **Autenticazione** — `--bearer-token`, `--cookie-file` per curl + MSF
* **Integrazione api-scanner** — `--scan-dir` carica `api_scanner/all_endpoints.txt` per i percorsi `brute_dirs`
* **Risultati strutturati** — `msf_parse.py` → `msf_engine/hits.jsonl` + `findings.json` `hits[]`
* **Multi-target** — `--file`, `--workers`, `--max-targets`
* **Stealth** — `--delay`, `--jitter`, `--proxy`, `THREADS` basati sul livello
* **MSF DB** — solo controlli per impostazione predefinita; `--msf-db-bootstrap` per configurazione facoltativa

**Menu:** Scansiona URL (passivo predefinito) o menu precedente.

**Esempi:**```
./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
```
**Opzioni:** `--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`

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

**Dipendenze:** `curl`, `jq`, `grep`, `msfconsole`; PostgreSQL raccomandato per MSF DB (opzionale con `--skip-msf-db`)

**Integrazione api-scanner:** `api-scanner.sh --orchestrate` richiede di eseguire web-api-scanner (passivo per impostazione predefinita).

# Risoluzione dei problemi

Alcuni utenti hanno segnalato di non riuscire a utilizzare opzioni diverse da 3, 4 e 5.
Non succede nulla quando si scelgono altre opzioni (1, 2, 6, ecc.).

## Verifica l'hash del download

La verifica basata su hash garantisce che un file non sia stato danneggiato confrontando il valore hash del file
con un valore precedentemente calcolato. Se questi valori corrispondono, si presume che il file non sia stato modificato.

### macOS

1. Apri Terminale
2. shasum -a 256 /percorso/del/file
3. Confronta il valore con il checksum sul sito web.

### Windows

1. Apri PowerShell
2. Get-FileHash C:\percorso\del\file
3. Confronta il valore con il checksum sul sito web.

## Esecuzione di Kali su VirtualBox o Windows Subsystem for Linux (WSL)

Alcuni utenti hanno segnalato che la soluzione è utilizzare l'immagine VMware invece di WSL.

Altri utenti hanno notato problemi quando eseguono un'immagine preconfigurata di Kali su VirtualBox, invece di eseguire
l'ISO nativo di Kali tramite VirtualBox.
(https://www.kali.org/get-kali/#kali-bare-metal)

Se non vuoi o non puoi utilizzare VMware Workstation per eseguire Kali, ti invitiamo a provare a eseguire
un ISO di Kali come macchina virtuale guest in VirtualBox.

1. Scarica l'ISO nativo fornito da Kali.
2. Verifica l'hash dell'ISO (vedi sopra).
3. Avvia una nuova VM Kali all'interno di VirtualBox con l'ISO nativo di Kali.

Durante l'installazione ti verrà chiesto di compilare alcune [istruzioni di installazione di base](https://www.kali.org/docs/installation/hard-disk-install/).

Nota: Se hai problemi ad accedere come root dopo aver configurato un ISO nativo, consulta:
https://linuxconfig.org/how-to-reset-kali-linux-root-password