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.

* Selecione **Update** (opção 16 do menu principal) para atualizar o sistema operacional e instalar as dependências (`ffuf`, `feroxbuster`, `jq`, etc.).
* Os scanners Dev estão em `dev/` e também são acessíveis a partir da opção do menu principal **15. Dev**.
* Algumas opções exigirão credenciais de root para executar.

### 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

## Autenticação

A autenticação LDAPv3 é suportada.

A autenticação suporta três modos:

- **Simple bind** - Usado para consultas de pesquisa ao definir um alvo.
- **Autenticação NTLM** - Usada se um usuário/senha for definido ao definir um alvo.
- **Autenticação Kerberos** - Usada se um realm Kerberos for definido ao definir um alvo.

A autenticação é definida na configuração do alvo. Atualmente, o blob de autenticação é usado apenas para executar consultas LDAP.```
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: Passivo e Ativo não podem ser executados como root.

RECON PASSIVA

Usa Amass, ARIN, DNSRecon, dnstwist, Metasploit, subfinder,
sublist3r, theHarvester, Whois e vários sites.

* Adquira todas as chaves de API gratuitas para obter resultados máximos com o theHarvester.
* Adicione as chaves de API em $HOME/.theHarvester/api-keys.yaml
* O Passivo gera um relatório HTML em $HOME/data/<domain>/.
* Encontra domínios registrados e atualiza a página registered-domains.htm em um relatório existente.
* O Ativo usa httpx, whatweb e gowitness; uma chave de API NVD opcional acelera o enriquecimento CVSS no relatório Ativo (veja **Chave de API NVD** abaixo).

#### Importar nomes (`import-names.sh`)

Execute após uma varredura passiva quando quiser adicionar ou enriquecer contatos provenientes de pesquisa manual (LinkedIn, sites de empresas, listas telefônicas, etc.).```
Enter the location of your previous passive scan:
/home/user/data/example.com

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

Importações suportadas:

* `firefox` — extrai `pinia/scans` do seu perfil Firefox (varreduras Pentest-Tools gratuitas)
* Exportação Firefox `pinia/scans` (`pinia-scans.json`)
* JSON do Pentest-Tools (pentest-tools-<domain>.json)
* Exportação de texto do Pentest-Tools (pentest-tools.txt)
* Linhas host/IP separadas por tabulação

* Edite `$HOME/data/<domain>/tools/subdomains-import.tsv` para entradas manuais
* Formato: Subdomínio, IP (separados por tabulação; IP opcional)
* Hosts sem IP são resolvidos com `dig` durante a importação
* Reexecute Importar subdomínios sempre que adicionar linhas ou executar uma nova varredura Pentest-Tools

Importar subdomínios mescla com os existentes em `tools/subdomains`, atribui categorias de
`old/subdomain-categories.tsv`, separa IPs privados para `tools/private-subs` e
atualiza `pages/subdomains.htm` apenas com as colunas Subdomínio, Categoria e IP.
Execute **Active** posteriormente para preencher Foto, Status, Servidor Web e Tecnologias.

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

ACTIVE RECON

Execute após uma varredura passiva (e opcionalmente Importar subdomínios) quando quiser verificar
quais hosts públicos respondem via HTTP/HTTPS, identificar tecnologias e capturar
capturas de tela.```
Enter the location of your previous passive scan:
/home/user/data/example.com

**Obtenha uma chave de API gratuita**

1. Solicite uma chave: https://nvd.nist.gov/developers/request-an-api-key
2. Confirme o e-mail que a NIST envia
3. Forneça a chave ao Discover (exportação de shell e/ou `.env` privado — veja abaixo)

**Como o Discover encontra a chave**

Ordem de precedência (valores não vazios mais acima na lista sempre vencem):

1. Ambiente shell — `export NVD_API_KEY=...`
2. `.env` privado na instalação do Discover — `$DISCOVER/.env`
3. `.env` privado na sua configuração home — `~/.discover/.env`

Exemplo de linha `.env` (aspas não são necessárias):```
NVD_API_KEY=your-key-here

(por exemplo, `~/discover/resource/known_exploited_vulnerabilities.json`)

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

Se o download falhar, qualquer catálogo local anterior é mantido. O arquivo está no gitignore (atualizado pelo Update, não commitado).

Na tabela **Versões de Software** ativa, **Top CVE** prefere uma correspondência do CISA KEV quando qualquer um dos CVEs NVD do produto aparece no catálogo KEV (o maior CVSS entre os KEVs vence). Caso contrário, o Top CVE é o resultado NVD com maior CVSS. As seleções KEV exibem um selo **KEV** laranja ao lado do ID do CVE vinculado.

#### Liderança da SEC (página Names)

Para empresas públicas dos EUA, o Discover obtém executivos e diretores da SEC EDGAR antes da etapa de mesclagem de nomes:

1. **DEF 14A** — texto da declaração de procuração e tabelas do conselho para títulos completos
2. **Form 4** — arquivamentos recentes de insiders para complementar diretores e executivos

* Os resultados são gravados em zsec-people e mesclados em tools/names com as colunas existentes Nome, Título, Telefone (telefone em branco).
* Os arquivamentos da SEC não fornecem e-mails de trabalho ou números de telefone por pessoa.
* O layout da página Names permanece inalterado — nenhuma coluna de e-mail é adicionada.
* Substituição manual: tools/sec-people-manual.tsv (separado por tabulação: Nome, Título, Telefone).

#### Sede da empresa (página Summary)

Durante o reconhecimento passivo, o Discover tenta preencher o bloco de endereço e telefone em pages/summary.htm entre o nome da empresa e o domínio.

1. **SEC EDGAR 10-K** — para empresas públicas dos EUA, lê campos do escritório executivo principal do 10-K mais recente (tags inline XBRL `dei:`).
2. **Rodapé do site** — se a SEC não tiver correspondência, verifica o rodapé da página inicial em cache (e páginas de contato) em busca de padrões de endereço/telefone.
3. **Substituição manual** — adicione entradas em tools/company-manual.tsv quando a descoberta estiver errada ou bloqueada.

Os resultados são gravados em tools/company.json e injetados em pages/summary.htm.

#### Mídias sociais (página Summary)

Durante o reconhecimento passivo, o Discover busca a página inicial da empresa e extrai links oficiais de perfis sociais (Facebook, Instagram, LinkedIn, X, YouTube). Em seguida, tenta obter contagens de seguidores de cada perfil.

* Os resultados são gravados em tools/social.tsv e injetados em pages/summary.htm.
* Se uma plataforma bloquear a raspagem, a contagem de seguidores mostra **Bloqueado**.
* Se a página inicial for bloqueada para bots, adicione URLs a tools/social-manual.tsv (separado por tabulação: Plataforma, URL) antes ou depois da varredura.

### Pessoa```
RECON

First name:
Last name:

* Use diferentes ferramentas para criar uma lista de alvos, incluindo Angry IP Scanner, arp-scan, netdiscover e Nmap pingsweep.

### CIDR, Lista, IP, Faixa ou URL```
Type of scan:

1.  External
2.  Internal
3.  Previous menu

### Abrir várias abas no Firefox```
Open multiple tabs in Firefox with:

1.  List
2.  Files in a directory
3.  Directories in robots.txt
4.  Previous menu
```
Exemplos:
* Uma lista contendo múltiplos IPs e/ou URLs.
* Você terminou de escanear vários sites com o Nikto e deseja abrir todos os relatórios .htm localizados em um diretório.
* Use o wget para baixar o arquivo robot.txt de um domínio e depois abra todos os diretórios.

### 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:
```
* Usa sslscan, sslyze e Nmap para verificar problemas de certificado SSL/TLS.

## DIVERSOS
### Analisar XML```
Parse XML to CSV.

1.  Burp (Base64)
2.  Nessus (.nessus)
3.  Nexpose (XML 2.0)
4.  Nmap
5.  Qualys
6.  Previous menu
```
### Gerar uma carga maliciosa```
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
```
### Iniciar um listener do 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
```
### Atualização (opção 16 do menu principal)

* Atualiza o sistema operacional, faz git pull de vários repositórios e atualiza o banco de dados locate.
* Instala ferramentas usadas pelos scanners dev (por exemplo `ffuf`, `feroxbuster`, `jq`, `trivy`).

## DEV

Os resultados da varredura são escritos em `$HOME/data/` a menos que indicado de outra forma. Os scanners dev produzem **relatórios independentes** em seus próprios diretórios de saída (`api-scan_*`, `cloud-scan_*`, etc.). Eles usam `discover.sh` para obter ajudantes de menu e cores quando necessário, mas **não** escrevem nem atualizam o relatório HTML de recon do Discover (`report.sh`, `$NAME`, `pages/*.htm`).

### Scanner de Segurança de API (`dev/api-scanner.sh`)

Descoberta e teste de segurança de API em fases. Ajudantes e listas de palavras compartilhados estão em `dev/lib/api-scanner/` e `dev/data/`.

**Menu interativo**```
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** (pula o menu quando `-u` está definido):```
./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 | Propósito |
|------|---------|
| `--quick` | Apenas descoberta e documentação |
| `--full` | Todas as fases (padrão) |
| `--orchestrate` | Escaneamento completo, depois solicita scanners relacionados |
| `--token` | Token de portador para requisições autenticadas |
| `--cookie-file` | Arquivo de cookies Netscape |
| `--max-parallel N` | Trabalhadores simultâneos (padrão: 3) |
| `--max-endpoints N` | Limitar endpoints testados após mesclagem |
| `--skip PHASE` | Pular uma fase (repetível) |
| `--resume DIR` | Retomar usando um diretório de saída existente |
| `--authorized` | Pular a confirmação de autorização |
| `--aggressive-http` | Incluir testes de métodos TRACE/CONNECT |

**Fases (escaneamento completo):** Extração de links HTML/JS, fuzzing com ffuf/feroxbuster, sondagem de caminhos, descoberta de OpenAPI/Swagger, testes GraphQL (introspecção, profundidade, loteamento), CORS (GET + preflight), verificações de métodos HTTP, rajada de limite de taxa, análise JWT.

**Saída:** `$HOME/data/api-scan_<timestamp>/api_scanner/`

* `report.txt` e `report.md` — descobertas locais do scanner (não mescladas no relatório de reconhecimento do Discover)
* `findings.json` — exportação JSON consolidada de todas as descobertas
* `findings_registry.tsv` — registro de descobertas separado por tabulação (fonte para exportação JSON)
* `scan.log` — trilha de auditoria de requisições
* `.checkpoint/` — marcadores de retomada por fase

Requer `curl` e `jq`. Usa `ffuf` ou `feroxbuster` quando instalado (instale via Discover **Update**). Executa `discover.sh` quando executado diretamente para `f_banner` / ajudantes de menu.

### Scanner de Segurança em Nuvem (`dev/cloud-scanner.sh`)

Auditoria faseada de configuração incorreta em nuvem para AWS, Azure e GCP. Ajudantes compartilhados estão em `dev/lib/cloud-scanner/`.

**Menu interativo**```
1. AWS (Amazon Web Services)
2. Azure (Microsoft Azure)
3. GCP (Google Cloud Platform)
4. All providers
5. Previous menu
```
**CLI** (pula o menu quando as flags do provedor estão definidas):```
./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
```
| Bandeira | Propósito |
|---------|-----------|
| `--aws` / `--azure` / `--gcp` | Executar um provedor (combine para múltiplos) |
| `--quick` | Verificações focadas em exposição (acesso público, MFA, ingresso aberto) |
| `--full` | Auditoria abrangente incluindo análise aprofundada de IAM, EC2/SG multirregião, extras |
| `--output-dir DIR` | Diretório de saída personalizado |
| `--resume DIR` | Retomar usando um diretório de varredura existente (pula fases concluídas) |
| `-h`, `--help` | Mostrar uso |

Os resultados são gravados em `$HOME/data/cloud-scan_YYYYMMDD-HHMM/` (ou `--output-dir`):

* `findings_registry.tsv` — severidade, provedor, serviço, recurso, verificação, detalhe, evidência
* `findings.json` — exportação JSON consolidada de todas as descobertas
* `report.txt` / `report.md` — resumo local do scanner (não mesclado no relatório de reconhecimento do Discover)
* `scan.log` — registro de atividade da API e descobertas
* `.checkpoint/` — marcadores de fase para `--resume`

Requer `jq` e a CLI de nuvem relevante (`aws`, `az`, `gcloud`/`gsutil`) com credenciais configuradas antes da varredura. O scanner não instala automaticamente CLIs nem executa `aws configure` / `gcloud init` interativos. Origina `discover.sh` quando executado diretamente para `f_banner` / ajudantes de menu.

### Scanner de Segurança de Contêiner (`dev/container-scanner.sh`)

Avaliação abrangente de segurança do Docker e Kubernetes usando Trivy, Docker e kubectl. Saída independente em `$HOME/data/container-scan_*` (não atualiza os relatórios HTML de reconhecimento do Discover).

* **Imagens Docker** — Trivy vulnerabilidade/segredo/configuração, SBOM (modo completo), análise de Dockerfile
* **Contêineres Docker** — modo privilegiado, montagens, capacidades, verificações de tempo de execução (modo completo)
* **Kubernetes** — RBAC, NetworkPolicies, rótulos PSS, APIs obsoletas, segurança de pods

**Tipos de varredura:** `docker-images`, `docker-containers`, `kubernetes` ou `all` (padrão quando executado a partir do menu Discover).

**Opções de CLI:** `--quick`, `--full`, `--output-dir`, `--resume`, `--dockerfile-root`, `--include-ns`, `--exclude-ns`, `--trivy-jobs`, `--menu`, `-h`

**Artefatos de saída:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `container_security_report.txt`

**Dependências:** `docker`, `kubectl` (varredura kubernetes), `trivy`, `jq`, `numfmt` — instale via Discover Update; sem instalação automática.

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

### Scanner de Segurança OAuth e JWT (`dev/oauth-jwt-scanner.sh`)

Descoberta OAuth/OIDC, testes de autorização ao vivo, análise JWT offline e verificação opcional de token ao vivo. Complementa as verificações JWT do `api-scanner.sh`. Saída independente em `$HOME/data/oauth-jwt-scan_*`.

* **OAuth/OIDC** — metadados de descoberta, JWKS, testes de redirect_uri/state/PKCE/implícito
* **JWT offline** — alg=none, confusão RS256→HS256, ataques jku/x5u/kid, higiene de claims, cargas de escalonamento de privilégios
* **JWT ao vivo** — testes Bearer opcionais contra `--jwt-endpoint` (preenchido automaticamente a partir de userinfo quando descoberto)

**Tipos de varredura:** `oauth`, `jwt` ou `all` (combinado).

**Menu:** Teste OAuth, teste JWT, varredura combinada ou menu anterior.

**Exemplos de 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
```
**Opções:** `--target`, `--jwt`, `--jwt-file`, `--api-scan-dir`, `--jwt-endpoint`, `--client-id`, `--redirect-uri`, `--quick`, `--full`, `--oauth`, `--jwt-only`, `--all`, `--output-dir`, `--resume`, `--menu`, `-h`

**Saída:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`

**Dependências:** `curl`, `jq`

### Scanner de Redirecionamento Aberto (`dev/open-redirect.sh`)

Realiza fuzzing em parâmetros de redirecionamento (injeção + mutação de parâmetros de consulta existentes) com hosts canários configuráveis. Detecta `Location` 3xx (com seguimento de um salto), meta refresh e redirecionamentos JavaScript/corpo. O modo completo adiciona sondagens POST e cabeçalho. Uma passagem de confirmação usa um segundo host canário para reduzir falsos positivos. Mecanismo Python: `dev/lib/open-redirect-scanner/engine.py`; payloads: `dev/data/openredirect-payloads.txt`. Saída independente em `$HOME/data/openredirect-scan_*`.

**Menu:** URL única, domínio, arquivo de URLs, opções avançadas, diretório de varredura anterior ou menu anterior.

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

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

**Dependências:** `python3`, `requests` (Discover Update instala `python3-requests`), `jq`

### Scanner de Informações Sensíveis (`dev/sensitive-scanner.sh`)

Caça por segredos, credenciais e PII em arquivos/diretórios locais e caminhos web expostos. Orquestração Bash com motores Python: `filescan.py` (escaneamento de arquivo em passagem única) e `engine.py` (sondagem web paralela). Dados de padrões: `dev/data/sensitive-patterns.tsv`, `sensitive-denylist.txt`, `sensitive-skip-paths.txt`. Saída independente em `$HOME/data/sensitive-scan_*`.

* **Escaneamento de arquivos** — uma passagem por arquivo via `filescan.py`; denylist, globs de ignorar, filtro de entropia, validação Luhn/SSN/TC; opcional `gitleaks` / `trufflehog` (`--external auto`)
* **Escaneamento web** — trabalhadores/RPS paralelos, retomada de checkpoint por caminho, caminhos de desautorização do robots + sitemap, importação de endpoints do api-scanner, proteção contra soft-404, detecção de listagem de diretórios, `filescan.py` profundo em corpos HTTP 200
* **Hook do api-scanner** — verificações de resposta inline usam `filescan.py`; orquestrador pode iniciar automaticamente `--all` com token de portador
* **Relatórios** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md` desduplicados; `--no-store-content` / `--shred-content` para artefatos mais seguros

**Menu:** Arquivo ou pasta, URL, arquivo/pasta + diretório de escaneamento anterior, URL + saída do api-scan, ou menu anterior.

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

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

**Dependencies:** `python3`, `jq`, `find`; web scans need `python3-requests`; optional `gitleaks`, `trufflehog`, `rg`

### Detecção de WAF (`dev/waf-detect.sh`)

Identifica firewalls de aplicação web e camadas de borda CDN na frente dos alvos. Biblioteca modular: `dev/lib/waf-detect/{common,probe}.sh`, `wafw00f_run.py`; dados: `dev/data/waf-signatures.tsv`, `waf-aliases.tsv`, `waf-labels.tsv`. Saída independente em `$HOME/data/waf-detection_*`.

* **Passivo verdadeiro (padrão para o hook api-scanner)** — `--passive` envia apenas um HTTP GET normal; corresponde cabeçalhos/corpo da resposta contra `waf-signatures.tsv`. Sem wafw00f, sem triggers SQLi, sem injeção `X-Forwarded-For`.
* **Modo ativo** — wafw00f via `wafw00f_run.py` (primário, alta confiança) mais sondas suplementares de assinatura/comportamento. Escaneamentos ativos não interativos requerem `--i-understand`.
* **Suplementar** — `--supplemental auto` pula sondas redundantes após um acerto confiante do wafw00f; achados comportamentais exigem corroboração de cabeçalho WAF.
* **Achados consolidados** — uma linha por fornecedor com confiança (`alta`/`média`/`baixa`), fonte e tipo (`waf`/`cdn`/`ambos`).
* **Hits estruturados** — `waf_engine/hits.jsonl` e `findings.json` `hits[]` para ferramentas downstream.
* **Retomada** — `--resume DIR` continua a partir de `waf_engine/checkpoint.json`.
* **Relatórios** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `waf_results.tsv`.

**Menu:** Alvo único, arquivo de alvos ou menu anterior (com escolha ativo/passivo).

**Exemplos:**```
./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
```
**Opções:** `--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`

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

**Dependências:** `curl`, `jq`, `grep`, `python3`; opcional `wafw00f` (modo ativo, recomendado)

**Integração com api-scanner:** `api-scanner.sh --orchestrate` solicita a execução do waf-detect após a varredura principal (passivo por padrão).

### Segurança Web e API (`dev/web-api-scanner.sh`)

Avaliação web/API baseada em Metasploit. Biblioteca modular: `dev/lib/web-api-scanner/{common,phases,msf,probe,waf,targets}.sh`, `msf_parse.py`; dados: `dev/data/web-api-{phases,tech-signatures}.tsv`. Saída independente em `$HOME/data/web-api-scan_*`.

* **Níveis** — `passive` (reconhecimento) | `standard`/`--quick` (reconhecimento + scanners de tecnologia) | `intrusive` (+ SQLi/força bruta) | `exploit` (+ verificações de exploit)
* **Controle de fase** — `--phases`, `--skip-phases`; `msfconsole` por fase com `--phase-timeout`
* **Identificação de tecnologia** — `web-api-tech-signatures.tsv` ponderado (Laravel, Spring, Swagger, nginx, …)
* **Ciente de WAF** — ignora fases de força bruta quando WAF/CDN é detectado (`--scan-dir` ou assinaturas de cabeçalho)
* **Autenticação** — `--bearer-token`, `--cookie-file` para curl + MSF
* **Integração com api-scanner** — `--scan-dir` carrega `api_scanner/all_endpoints.txt` para caminhos `brute_dirs`
* **Hits estruturados** — `msf_parse.py` → `msf_engine/hits.jsonl` + `findings.json` `hits[]`
* **Múltiplos alvos** — `--file`, `--workers`, `--max-targets`
* **Furtividade** — `--delay`, `--jitter`, `--proxy`, `THREADS` baseado no nível
* **Banco de dados MSF** — apenas verificações por padrão; `--msf-db-bootstrap` para configuração opcional

**Menu:** Escanear URL (passivo padrão) ou menu anterior.

**Exemplos:**```
./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
```
**Opções:** `--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`

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

**Dependências:** `curl`, `jq`, `grep`, `msfconsole`; PostgreSQL recomendado para o banco de dados do MSF (opcional com `--skip-msf-db`)

**Integração com api-scanner:** `api-scanner.sh --orchestrate` solicita a execução do web-api-scanner (passivo por padrão).

# Resolução de problemas

Alguns usuários relataram não conseguir usar nenhuma opção além de 3, 4 e 5. 
Nada acontece ao escolher outras opções (1, 2, 6, etc.).

## Verificar o hash do download

A verificação baseada em hash garante que um arquivo não foi corrompido, comparando o valor do hash do arquivo 
com um valor calculado anteriormente. Se esses valores coincidirem, presume-se que o arquivo não foi modificado.

### macOS

1. Abra o Terminal
2. shasum -a 256 /caminho/para/o/arquivo
3. Compare o valor com o checksum no site.

### Windows

1. Abra o PowerShell
2. Get-FileHash C:\caminho\para\arquivo
3. Compare o valor com o checksum no site.

## Executando Kali no VirtualBox ou Subsistema Windows para Linux (WSL)

Alguns usuários relataram que a solução é usar a imagem VMware em vez de WSL. 

Outros usuários notaram problemas ao executar uma imagem VirtualBox Kali pré-criada, em vez de executar a 
ISO Kali bare metal através do VirtualBox. 
(https://www.kali.org/get-kali/#kali-bare-metal)

Se você não puder ou não quiser usar o VMware Workstation para executar o Kali, encorajamos você a tentar 
executar uma ISO Kali como uma VM convidada no VirtualBox.

1. Baixe a ISO bare metal fornecida pelo Kali.
2. Verifique o hash da ISO (veja acima).
3. Inicie uma nova VM Kali dentro do VirtualBox com a ISO Kali bare metal.

Haverá algumas [instruções básicas de instalação](https://www.kali.org/docs/installation/hard-disk-install/) 
que você precisará preencher durante a instalação.

Nota: Se você tiver problemas para acessar o root após configurar uma ISO bare metal, consulte: 
https://linuxconfig.org/how-to-reset-kali-linux-root-password