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.

* Selecciona **Update** (opción 16 del menú principal) para actualizar el sistema operativo e instalar las dependencias (`ffuf`, `feroxbuster`, `jq`, etc.).
* Los escáneres de desarrollo están en `dev/` y también son accesibles desde la opción del menú principal **15. Dev**.
* Algunas opciones requerirán credenciales de root para ejecutarse.

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

## 🛠️ Recursos

| Recurso | Enlace |
|-----------|-----------|
| Opción de PowerShell Profiler para PowerShell 7 | [Enlace](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_profiles?view=powershell-7.4&WT.mc_id=DT-MVP-5003978#the-profile-scripts) |
| PowerShellHelper, parche para OMIGOD CVE-2021-38647 | [Enlace](https://github.com/WhoIsRequest/PowerShellHelper) |

### 🛡️ Relacionado con Defender y Hardening

| Recurso | Enlace |
|-----------|-----------|
| Defender BoxedApp para VBS Enclave | [Enlace](https://learn.microsoft.com/en-us/windows/win32/win_srv/boxedapp) |
| HardeningKitty | [Enlace](https://github.com/0x6d69636b/HardeningKitty) |

### 💡 Ideas y Tutoriales

| Recurso | Enlace |
|-----------|-----------|
| Mi Blog (MGC) | [Enlace](https://blog.marceloforclark.net) |
| Desarrollo de Malware Pt. 1 | [Enlace](https://0xpat.github.io/Malware_development_part_1/) |
| Desarrollo de Malware Pt. 2 | [Enlace](https://0xpat.github.io/Malware_development_part_2/) |```
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 y Active no pueden ejecutarse como root.

RECONOCIMIENTO PASIVO

Utiliza Amass, ARIN, DNSRecon, dnstwist, Metasploit, subfinder,
sublist3r, theHarvester, Whois y múltiples sitios web.

* Adquiera todas las claves API gratuitas para obtener resultados máximos con theHarvester.
* Agregue las claves API a $HOME/.theHarvester/api-keys.yaml
* Passive genera un informe HTML en $HOME/data/<dominio>/.
* Encontrar dominios registrados actualiza pages/registered-domains.htm en un informe existente.
* Active utiliza httpx, whatweb y gowitness; la clave API opcional de NVD acelera el
  enriquecimiento CVSS en el informe Active (consulte **Clave API de NVD** más abajo).

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

Ejecute después de un escaneo pasivo cuando desee agregar o enriquecer contactos a partir de investigación manual
(LinkedIn, sitios de empresas, directorios telefónicos, etc.).```
Enter the location of your previous passive scan:
/home/user/data/example.com

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

Importaciones compatibles:

* `firefox` — extraer `pinia/scans` de tu perfil de Firefox (escaneos gratuitos de Pentest-Tools)
* Exportación de `pinia/scans` de Firefox (`pinia-scans.json`)
* JSON de Pentest-Tools (`pentest-tools-<domain>.json`)
* Exportación de texto de Pentest-Tools (`pentest-tools.txt`)
* Filas de host/IP separadas por tabulaciones

* Edite `$HOME/data/<domain>/tools/subdomains-import.tsv` para entradas manuales
* Formato: Subdominio, IP (separado por tabulaciones; IP opcional)
* Los hosts sin IP se resuelven con `dig` durante la importación
* Vuelva a ejecutar Importar subdominios cada vez que agregue filas o ejecute un nuevo escaneo de Pentest-Tools

Importar subdominios se fusiona con `tools/subdomains` existente, asigna categorías desde `old/subdomain-categories.tsv`, separa IPs privadas en `tools/private-subs` y actualiza `pages/subdomains.htm` solo con las columnas Subdominio, Categoría e IP.
Ejecute **Active** después para poblar Foto, Estado, Servidor Web y Tecnologías.

#### Activo (`active.sh`)

RECONOCIMIENTO ACTIVO

Ejecutar después de un escaneo pasivo (y opcionalmente Importar subdominios) cuando quieras probar qué hosts públicos responden a través de HTTP/HTTPS, identificar tecnologías y capturar capturas de pantalla.```
Enter the location of your previous passive scan:
/home/user/data/example.com

**Obtén una clave API gratuita**

1. Solicita una clave: https://nvd.nist.gov/developers/request-an-api-key
2. Confirma el correo electrónico que NIST envía
3. Proporciona la clave a Discover (exportación de shell y/o `.env` privado — ver más abajo)

**Cómo encuentra Discover la clave**

Orden de precedencia (los valores no vacíos más arriba en la lista siempre ganan):

1. Entorno de shell — `export NVD_API_KEY=...`
2. `.env` privado en la instalación de Discover — `$DISCOVER/.env`
3. `.env` privado en tu configuración de inicio — `~/.discover/.env`

Ejemplo de línea `.env` (no se requieren comillas):```
NVD_API_KEY=your-key-here

(p. ej. `~/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 la descarga falla, cualquier catálogo local anterior se deja en su lugar. El archivo está en gitignore (se actualiza con Update, no se commitea).

En la tabla **Active Software versions**, **Top CVE** prefiere una coincidencia de CISA KEV cuando algún CVE del NVD del producto aparece en el catálogo KEV (gana el CVSS más alto entre los KEV). De lo contrario, Top CVE es el resultado NVD con CVSS más alto. Las selecciones KEV muestran una insignia **KEV** naranja junto al ID de CVE enlazado.

#### SEC leadership (Names page)

Para empresas públicas estadounidenses, Discover extrae ejecutivos y directores de SEC EDGAR antes del paso de fusión de nombres:

1. **DEF 14A** — texto de la declaración de poder y tablas de la junta para títulos completos
2. **Formulario 4** — presentaciones recientes de información privilegiada para complementar a los funcionarios y directores

* Los resultados se escriben en zsec-people y se fusionan en tools/names con las columnas Name, Title, Phone (teléfono en blanco).
* Las presentaciones de la SEC no proporcionan correos electrónicos laborales ni números de teléfono por persona.
* El diseño de la página Names no cambia — no se añade columna de email.
* Anulación manual: tools/sec-people-manual.tsv (separado por tabulaciones: Name, Title, Phone).

#### Company HQ (Summary page)

Durante el reconocimiento pasivo, Discover intenta llenar el bloque de dirección y teléfono en pages/summary.htm entre el nombre de la empresa y el dominio.

1. **SEC EDGAR 10-K** — para empresas públicas estadounidenses, lee los campos de la oficina ejecutiva principal del último 10-K (etiquetas `dei:` XBRL inline).
2. **Pie de página del sitio web** — si la SEC no tiene coincidencia, escanea el pie de página de la página de inicio en caché (y las páginas de contacto) en busca de patrones de dirección/teléfono.
3. **Anulación manual** — añadir entradas a tools/company-manual.tsv cuando el descubrimiento es incorrecto o está bloqueado.

Los resultados se escriben en tools/company.json y se inyectan en pages/summary.htm.

#### Social media (Summary page)

Durante el reconocimiento pasivo, Discover obtiene la página de inicio de la empresa y extrae enlaces oficiales a perfiles sociales (facebook, Instagram, LinkedIn, X, YouTube). Luego intenta obtener el número de seguidores de cada perfil.

* Los resultados se escriben en tools/social.tsv y se inyectan en pages/summary.htm.
* Si una plataforma bloquea el scraping, el número de seguidores muestra **Blocked**.
* Si la página de inicio está bloqueada para bots, añada URLs a tools/social-manual.tsv (separado por tabulaciones: Platform, URL) antes o después del escaneo.

### Persona```
RECON

First name:
Last name:

* Usa diferentes herramientas para crear una lista de objetivos que incluye Angry IP Scanner, arp-scan, netdiscover y Nmap pingsweep.

### CIDR, Lista, IP, Rango o URL```
Type of scan:

1.  External
2.  Internal
3.  Previous menu

### Abrir varias pestañas en Firefox```
Open multiple tabs in Firefox with:

1.  List
2.  Files in a directory
3.  Directories in robots.txt
4.  Previous menu
```
* Ejemplos:
* Una lista que contiene múltiples IPs y/o URLs.
* Terminaste de escanear múltiples sitios web con Nikto y deseas abrir cada informe htm ubicado en un directorio.
* Usa wget para descargar el archivo robot.txt de un dominio, luego abre todos los directorios.

### 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 y Nmap para verificar problemas de certificados SSL/TLS.

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

1.  Burp (Base64)
2.  Nessus (.nessus)
3.  Nexpose (XML 2.0)
4.  Nmap
5.  Qualys
6.  Previous menu
```
### Generar un payload malicioso```
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 un listener de 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
```
### Actualización (opción 16 del menú principal)

* Actualiza el sistema operativo, git pull de varios repositorios, y actualiza la base de datos locate.
* Instala herramientas utilizadas por los escáneres de desarrollo (por ejemplo `ffuf`, `feroxbuster`, `jq`, `trivy`).

## DEV

Los resultados de los escaneos se escriben en `$HOME/data/` a menos que se indique lo contrario. Los escáneres de desarrollo producen **informes independientes** en sus propios directorios de salida (`api-scan_*`, `cloud-scan_*`, etc.). Utilizan `discover.sh` para obtener ayudas del menú y colores cuando sea necesario, pero **no** escriben ni actualizan el informe HTML de reconocimiento de Discover (`report.sh`, `$NAME`, `pages/*.htm`).

### Escáner de Seguridad de API (`dev/api-scanner.sh`)

Descubrimiento y pruebas de seguridad de API por fases. Los ayudantes y listas de palabras compartidos están en `dev/lib/api-scanner/` y `dev/data/`.

**Menú interactivo**```
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** (omite el menú cuando se establece `-u`):```
./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` | Solo descubrimiento y documentación |
| `--full` | Todas las fases (predeterminado) |
| `--orchestrate` | Escaneo completo, luego solicita escáneres relacionados |
| `--token` | Token Bearer para solicitudes autenticadas |
| `--cookie-file` | Archivo de cookies de Netscape |
| `--max-parallel N` | Trabajadores concurrentes (predeterminado: 3) |
| `--max-endpoints N` | Límite de endpoints probados después de la fusión |
| `--skip PHASE` | Saltar una fase (repetible) |
| `--resume DIR` | Reanudar usando un directorio de salida existente |
| `--authorized` | Saltar la solicitud de confirmación de autorización |
| `--aggressive-http` | Incluir pruebas de métodos TRACE/CONNECT |

**Fases (escaneo completo):** Extracción de enlaces HTML/JS, fuzzing con ffuf/feroxbuster, sondeo de rutas, descubrimiento de OpenAPI/Swagger, pruebas GraphQL (introspección, profundidad, lotes), CORS (GET + preflight), verificación de métodos HTTP, ráfaga de límite de tasa, análisis JWT.

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

* `report.txt` y `report.md` — hallazgos locales del escáner (no fusionados en el informe de reconocimiento de Discover)
* `findings.json` — exportación JSON consolidada de todos los hallazgos
* `findings_registry.tsv` — registro de hallazgos separado por tabulaciones (fuente para exportación JSON)
* `scan.log` — rastro de auditoría de solicitudes
* `.checkpoint/` — marcadores de reanudación por fase

Requiere `curl` y `jq`. Usa `ffuf` o `feroxbuster` cuando están instalados (instalar a través de Discover **Update**). Incluye `discover.sh` cuando se ejecuta directamente para los ayudantes `f_banner` / menú.

### Escáner de Seguridad en la Nube (`dev/cloud-scanner.sh`)

Auditoría por fases de configuraciones incorrectas en la nube para AWS, Azure y GCP. Los ayudantes compartidos se encuentran en `dev/lib/cloud-scanner/`.

**Menú interactivo**```
1. AWS (Amazon Web Services)
2. Azure (Microsoft Azure)
3. GCP (Google Cloud Platform)
4. All providers
5. Previous menu
```
**CLI** (omite el menú cuando se establecen los indicadores del proveedor):```
./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
```
| Bandera | Propósito |
|------|---------|
| `--aws` / `--azure` / `--gcp` | Ejecutar un proveedor (combinar para múltiples) |
| `--quick` | Verificaciones centradas en exposición (acceso público, MFA, ingress abierto) |
| `--full` | Auditoría completa incluyendo análisis profundo de IAM, EC2/SG multirregión, extras |
| `--output-dir DIR` | Directorio de salida personalizado |
| `--resume DIR` | Reanudar usando un directorio de escaneo existente (salta fases completadas) |
| `-h`, `--help` | Mostrar uso |

Los resultados se escriben en `$HOME/data/cloud-scan_YYYYMMDD-HHMM/` (o `--output-dir`):

* `findings_registry.tsv` — severidad, proveedor, servicio, recurso, verificación, detalle, evidencia
* `findings.json` — exportación JSON consolidada de todos los hallazgos
* `report.txt` / `report.md` — resumen local del escáner (no fusionado en el informe de reconocimiento de Discover)
* `scan.log` — actividad de API y registro de hallazgos
* `.checkpoint/` — marcadores de fase para `--resume`

Requiere `jq` y la CLI de nube correspondiente (`aws`, `az`, `gcloud`/`gsutil`) con credenciales configuradas antes de escanear. El escáner no instala automáticamente las CLI ni ejecuta `aws configure` / `gcloud init` interactivo. Carga `discover.sh` cuando se ejecuta directamente para `f_banner` / ayudantes del menú.

### Container Security Scanner (`dev/container-scanner.sh`)

Evaluación completa de seguridad de Docker y Kubernetes usando Trivy, Docker y kubectl. Salida independiente en `$HOME/data/container-scan_*` (no actualiza los informes HTML de reconocimiento de Discover).

* **Docker images** — Escaneo de vulnerabilidades/secretos/configuración con Trivy, SBOM (modo completo), análisis de Dockerfile
* **Docker containers** — modo privilegiado, montajes, capacidades, verificaciones en tiempo de ejecución (modo completo)
* **Kubernetes** — RBAC, NetworkPolicies, etiquetas PSS, APIs obsoletas, seguridad de pods

**Tipos de escaneo:** `docker-images`, `docker-containers`, `kubernetes` o `all` (predeterminado cuando se ejecuta desde el menú de Discover).

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

**Artefactos de salida:** `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `scan.log`, `container_security_report.txt`

**Dependencias:** `docker`, `kubectl` (escaneo de kubernetes), `trivy`, `jq`, `numfmt` — instalar a través de Discover Update; sin instalación automática.

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

### OAuth and JWT Security Scanner (`dev/oauth-jwt-scanner.sh`)

Descubrimiento de OAuth/OIDC, sondas de autorización en vivo, análisis JWT sin conexión y verificación opcional de tokens en vivo. Complementa las verificaciones JWT de `api-scanner.sh`. Salida independiente en `$HOME/data/oauth-jwt-scan_*`.

* **OAuth/OIDC** — metadatos de descubrimiento, JWKS, sondas redirect_uri/state/PKCE/implicit
* **JWT offline** — alg=none, confusión RS256→HS256, ataques jku/x5u/kid, higiene de claims, cargas de escalada de privilegios
* **JWT live** — pruebas Bearer opcionales contra `--jwt-endpoint` (autocompletado desde userinfo cuando se descubre)

**Tipos de escaneo:** `oauth`, `jwt` o `all` (combinado).

**Menú:** Prueba OAuth, prueba JWT, escaneo combinado o menú anterior.

**CLI examples:**```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
```
**Opciones:** `--target`, `--jwt`, `--jwt-file`, `--api-scan-dir`, `--jwt-endpoint`, `--client-id`, `--redirect-uri`, `--quick`, `--full`, `--oauth`, `--jwt-only`, `--all`, `--output-dir`, `--resume`, `--menu`, `-h`

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

**Dependencias:** `curl`, `jq`

### Escáner de Redirección Abierta (`dev/open-redirect.sh`)

Fuzzea parámetros de redirección (inyecta y muta los parámetros de consulta existentes) con hosts canary configurables. Detecta ubicaciones 3xx (con seguimiento de un salto), meta refresh y redirecciones JavaScript/body. El modo completo añade sondas POST y de cabeceras. La pasada de confirmación utiliza un segundo host canary para reducir falsos positivos. Motor Python: `dev/lib/open-redirect-scanner/engine.py`; payloads: `dev/data/openredirect-payloads.txt`. Salida independiente en `$HOME/data/openredirect-scan_*`.

**Menú:** URL única, dominio, archivo de URLs, opciones avanzadas, directorio de escaneo anterior o menú anterior.

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

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

**Dependencias:** `python3`, `requests` (Discover Update instala `python3-requests`), `jq`

### Escáner de Información Sensible (`dev/sensitive-scanner.sh`)

Busca secretos, credenciales e información de identificación personal (PII) en archivos/directorios locales y rutas web expuestas. Orquestación Bash más motores Python: `filescan.py` (escaneo de archivos de una sola pasada) y `engine.py` (sondeo web paralelo). Datos de patrones: `dev/data/sensitive-patterns.tsv`, `sensitive-denylist.txt`, `sensitive-skip-paths.txt`. Salida independiente en `$HOME/data/sensitive-scan_*`.

* **Escaneo de archivos** — una pasada por archivo a través de `filescan.py`; lista de bloqueo, patrones globales de omisión, filtro de entropía, validación Luhn/SSN/TC; `gitleaks` / `trufflehog` opcional (`--external auto`)
* **Escaneo web** — trabajadores/RPS paralelos, reanudación de punto de control por ruta, rutas de desautorización de robots + sitemap, importación de puntos finales de api-scanner, protección contra soft-404, detección de listado de directorios, escaneo profundo con `filescan.py` en cuerpos HTTP 200
* **Enlace api-scanner** — las comprobaciones de respuesta en línea usan `filescan.py`; el orquestador puede lanzar automáticamente `--all` con token de portador
* **Informes** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md` deduplicados; `--no-store-content` / `--shred-content` para artefactos más seguros

**Menú:** Archivo o carpeta, URL, archivo/carpeta + directorio de escaneo anterior, URL + salida de api-scan, o menú anterior.

**Ejemplos:**```
./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`; las exploraciones web necesitan `python3-requests`; opcional `gitleaks`, `trufflehog`, `rg`

### Detección de WAF (`dev/waf-detect.sh`)

Identifica firewalls de aplicaciones web y capas perimetrales de CDN frente a los objetivos. Biblioteca modular: `dev/lib/waf-detect/{common,probe}.sh`, `wafw00f_run.py`; datos: `dev/data/waf-signatures.tsv`, `waf-aliases.tsv`, `waf-labels.tsv`. Salida independiente en `$HOME/data/waf-detection_*`.

* **Pasivo real (predeterminado para el hook de api-scanner)** — `--passive` envía solo una solicitud HTTP GET normal; compara los encabezados/cuerpo de la respuesta con `waf-signatures.tsv`. Sin wafw00f, sin disparadores de SQLi, sin inyección de `X-Forwarded-For`.
* **Modo activo** — wafw00f a través de `wafw00f_run.py` (principal, alta confianza) más sondas suplementarias de firmas/comportamiento. Las exploraciones activas no interactivas requieren `--i-understand`.
* **Suplementario** — `--supplemental auto` omite sondas redundantes después de un acierto confiable de wafw00f; los hallazgos de comportamiento requieren corroboración del encabezado WAF
* **Hallazgos consolidados** — una fila por proveedor con confianza (`high`/`medium`/`low`), fuente y tipo (`waf`/`cdn`/`both`)
* **Aciertos estructurados** — `waf_engine/hits.jsonl` y `findings.json` `hits[]` para herramientas posteriores
* **Reanudar** — `--resume DIR` continúa desde `waf_engine/checkpoint.json`
* **Informes** — `findings_registry.tsv`, `findings.json`, `report.txt`, `report.md`, `waf_results.tsv`

**Menú:** Objetivo único, archivo de objetivos o menú anterior (con elección activo/pasivo).

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

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

**Dependencias:** `curl`, `jq`, `grep`, `python3`; opcional `wafw00f` (modo activo, recomendado)

**Integración con api-scanner:** `api-scanner.sh --orchestrate` solicita ejecutar waf-detect después del escaneo principal (pasivo por defecto).

### Seguridad Web y de API (`dev/web-api-scanner.sh`)

Evaluación web/API basada en Metasploit. Biblioteca modular: `dev/lib/web-api-scanner/{common,phases,msf,probe,waf,targets}.sh`, `msf_parse.py`; datos: `dev/data/web-api-{phases,tech-signatures}.tsv`. Salida independiente en `$HOME/data/web-api-scan_*`.

* **Niveles** — `passive` (reconocimiento) | `standard`/`--quick` (reconocimiento + escáneres tecnológicos) | `intrusive` (+ SQLi/brute) | `exploit` (+ comprobaciones de exploit)
* **Control de fases** — `--phases`, `--skip-phases`; `msfconsole` por fase con `--phase-timeout`
* **Huella tecnológica** — `web-api-tech-signatures.tsv` ponderado (Laravel, Spring, Swagger, nginx, …)
* **Consciente de WAF** — omite fases de fuerza bruta cuando se detecta WAF/CDN (`--scan-dir` o firmas de encabezado)
* **Autenticación** — `--bearer-token`, `--cookie-file` para curl + MSF
* **Integración con api-scanner** — `--scan-dir` carga `api_scanner/all_endpoints.txt` para rutas de `brute_dirs`
* **Resultados estructurados** — `msf_parse.py` → `msf_engine/hits.jsonl` + `findings.json` `hits[]`
* **Multiobjetivo** — `--file`, `--workers`, `--max-targets`
* **Sigilo** — `--delay`, `--jitter`, `--proxy`, `THREADS` basado en niveles
* **Base de datos de MSF** — solo verificaciones por defecto; `--msf-db-bootstrap` para configuración opcional

**Menú:** Escanear URL (pasivo por defecto) o menú anterior.

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

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

**Dependencias:** `curl`, `jq`, `grep`, `msfconsole`; PostgreSQL recomendado para MSF DB (opcional con `--skip-msf-db`)

**Integración con api-scanner:** `api-scanner.sh --orchestrate` solicita ejecutar web-api-scanner (pasivo por defecto).

# Solución de problemas

Algunos usuarios han informado que no pueden usar ninguna opción excepto 3, 4 y 5. 
No sucede nada al elegir otras opciones (1, 2, 6, etc.).

## Verificar el hash de descarga

La verificación basada en hash asegura que un archivo no ha sido corrompido comparando el valor hash del archivo 
con un valor previamente calculado. Si estos valores coinciden, se presume que el archivo no ha sido modificado.

### macOS

1. Abra Terminal
2. shasum -a 256 /path/to/file
3. Compare el valor con el checksum en el sitio web.

### Windows

1. Abra PowerShell
2. Get-FileHash C:\path\to\file
3. Compare el valor con el checksum en el sitio web.

## Ejecutando Kali en VirtualBox o Subsistema de Windows para Linux (WSL)

Algunos usuarios han informado que la solución es usar la imagen de VMware en lugar de WSL. 

Otros usuarios han notado problemas al ejecutar una imagen pre-hecha de Kali en VirtualBox, en lugar de ejecutar la 
ISO de Kali bare metal a través de VirtualBox. 
(https://www.kali.org/get-kali/#kali-bare-metal)

Si no está dispuesto o no puede usar VMware Workstation para ejecutar Kali, le recomendamos intentar ejecutar 
una ISO de Kali como VM invitada en VirtualBox.

1. Descargue la ISO bare metal proporcionada por Kali.
2. Verifique el hash de la ISO (ver arriba).
3. Inicie una nueva VM de Kali en VirtualBox con la ISO bare metal de Kali.

Habrá algunas [instrucciones básicas de instalación](https://www.kali.org/docs/installation/hard-disk-install/) 
que deberá completar durante la instalación.

Nota: Si tiene problemas para acceder a root después de configurar una ISO bare metal, consulte: 
https://linuxconfig.org/how-to-reset-kali-linux-root-password