GhostAcademy
Ghost AcademySecLearn// WHATWEB LAB
🌐 unfantasmaenelsistema.com
🔎 RECONOCIMIENTO WEB — FINGERPRINTING — RECON PASIVO / ACTIVO
WhatWeb
Fingerprinting Web de Próxima Generación
1.900+ plugins · CMS · Servidores web · Frameworks · CVEs · Plugins Ruby · Bug Bounty · GhostAcademy
WhatWebFingerprintingWordPressApachePHPReconocimientoBug BountyKali LinuxRuby PluginsOSCP
9EJERCICIOS
1900+PLUGINS
30+COMANDOS
🌐
¿Qué es WhatWeb?
Fingerprinting web: identificar el stack tecnológico completo de cualquier sitio

WhatWeb es una herramienta de reconocimiento web de código abierto escrita en Ruby, incluida por defecto en Kali Linux y referenciada en el temario de certificaciones como OSCP, CEH y CompTIA PenTest+. Su objetivo es identificar las tecnologías utilizadas por un sitio web: CMS (WordPress, Joomla, Drupal), frameworks (React, Angular, Laravel), servidores web (Apache, Nginx, IIS), lenguajes de programación, bibliotecas JavaScript, cabeceras de seguridad, cookies, versiones de software y mucho más.

WhatWeb es fundamentalmente una herramienta de fingerprinting pasivo/activo: analiza las respuestas HTTP de un servidor (cabeceras, cookies, contenido HTML, meta-etiquetas, scripts, URLs) y las compara contra su base de datos de más de 1.900 plugins para identificar el stack tecnológico completo.

Es útil tanto en la fase de reconocimiento de un pentest como para inventariar tu propia infraestructura web desde la perspectiva de un atacante externo.

🛡 HERRAMIENTA DE RECONOCIMIENTO PASIVO/ACTIVOWhatWeb realiza peticiones HTTP normales hacia el objetivo. En el nivel de agresión por defecto (1) no envía ninguna carga maliciosa ni intenta explotar nada: simplemente analiza las respuestas del servidor. Es legal analizar tu propia infraestructura. Para objetivos externos, asegúrate de tener permiso explícito.
⚙
Instalación de WhatWeb
Disponible en Kali Linux, apt, y GitHub
Instalar WhatWeb
# En Kali Linux (preinstalado): whatweb --version # Instalar desde apt si no esta: sudo apt update && sudo apt install whatweb -y # Instalar desde GitHub (version mas reciente): git clone https://github.com/urbanadventurer/WhatWeb.git cd WhatWeb gem install bundler bundle install ./whatweb --version # En macOS con Homebrew: brew install whatweb # Verificar instalacion y ver la version: whatweb --version # WhatWeb version 0.5.5
📌 REQUISITOSWhatWeb requiere Ruby y varias gemas (bibliotecas Ruby). En Kali Linux todo viene preinstalado. En otros sistemas: sudo apt install ruby ruby-dev y luego instalar WhatWeb desde GitHub.
Verificar funcionamiento con un target de prueba
# Probar con un sitio conocido (con permiso): whatweb example.com # Probar con localhost si tienes un servidor local: whatweb http://localhost whatweb http://127.0.0.1:8080 # Para practicar sin salir de tu red: # Levantar un servidor web local con Python: python3 -m http.server 8080 # En otra terminal: whatweb http://localhost:8080
📄
Sintaxis y Opciones Principales
Todos los parámetros de WhatWeb explicados
Sintaxis general y opciones principales
# Sintaxis basica: whatweb [opciones] <URL o archivo o rango> # ── OBJETIVO ── whatweb http://ejemplo.com # URL individual whatweb ejemplo.com # Sin protocolo (asume HTTP) whatweb https://ejemplo.com # HTTPS whatweb 192.168.1.1 # IP directa whatweb 192.168.1.0/24 # Rango CIDR completo whatweb -i urls.txt # Lista de URLs desde archivo # ── AGRESIVIDAD ── whatweb -a 1 ejemplo.com # Nivel 1: sigiloso (default) whatweb -a 3 ejemplo.com # Nivel 3: agresivo (mas peticiones) whatweb -a 4 ejemplo.com # Nivel 4: muy agresivo (fuzzing) # ── SALIDA ── whatweb -v ejemplo.com # Verbose: mostrar todos los detalles whatweb --log-brief=salida.txt # Guardar en formato breve whatweb --log-verbose=salida.txt # Guardar en formato verbose whatweb --log-json=salida.json # Guardar en JSON whatweb --log-xml=salida.xml # Guardar en XML whatweb --log-sql=salida.sql # Guardar en SQL # ── RED ── whatweb --proxy 127.0.0.1:8080 # Usar proxy (Burp Suite) whatweb --user-agent 'Mi-Bot/1.0' # User-Agent personalizado whatweb --header 'Cookie: session=abc' ejemplo.com # Cabeceras personalizadas whatweb -t 20 # 20 hilos paralelos (default: 25) whatweb --wait=2 # Esperar 2s entre peticiones whatweb --open-timeout=10 # Timeout de conexion en segundos # ── PLUGINS ── whatweb --list-plugins # Ver todos los plugins disponibles whatweb --info-plugins=WordPress # Ver informacion de un plugin whatweb --plugins=WordPress,Joomla # Usar solo esos plugins whatweb --plugins-disable=Apache # Deshabilitar un plugin especifico
📊PARÁMETROS MAS UTILIZADOS
ParámetroDescripciónEjemplo
-a NNivel de agresión (1-4)-a 3
-vVerbose: mostrar todos los plugins y detalles-v ejemplo.com
-i archivoLista de URLs desde archivo-i urls.txt
-t NNúmero de hilos paralelos-t 10
--log-json=fGuardar salida en JSON--log-json=out.json
--log-brief=fGuardar salida en texto breve--log-brief=out.txt
--proxyEnviar tráfico por proxy (Burp)--proxy 127.0.0.1:8080
--user-agentPersonalizar el User-Agent--user-agent "Googlebot/2.1"
--colour=neverDeshabilitar colores (para pipes)--colour=never
--no-errorsOcultar errores de conexión--no-errors
--list-pluginsListar todos los pluginswhatweb --list-plugins
--grep=regexFiltrar resultados por regex--grep=WordPress
🔴
Niveles de Agresión
Controlar la cantidad de peticiones y la profundidad del análisis

WhatWeb tiene cuatro niveles de agresión que controlan cuántas peticiones HTTP hace y qué tipo de análisis realiza. A mayor nivel, más información obtiene pero más tráfico genera y más detectable es.

1SILENCIOSOUna sola petición GET a la URL indicada. Analiza cabeceras, cookies y HTML. El modo por defecto. Muy sigiloso.
2AGRESIVO SI COINCIDEHace peticiones adicionales solo si los plugins del nivel 1 han detectado un CMS o framework específico que requiere más pruebas para confirmar la versión.
3AGRESIVOHace peticiones adicionales independientemente de los resultados del nivel 1. Prueba URLs conocidas de cada tecnología (/wp-login.php, /administrator, etc.).
4PESADOHace peticiones a todas las URLs conocidas de todos los plugins. Muy lento, genera mucho tráfico. Solo para análisis exhaustivo de un solo objetivo.
Comparativa de niveles de agresión
# Nivel 1 (default): 1 peticion HTTP whatweb http://ejemplo.com # Nivel 2: peticiones adicionales solo si hay coincidencias whatweb -a 2 http://ejemplo.com # Nivel 3: peticiones adicionales siempre # Comprueba /wp-login.php, /wp-content/, /admin/, etc. whatweb -a 3 http://ejemplo.com # Nivel 4: prueba TODAS las URLs conocidas de todos los plugins # Muy lento pero muy completo (solo targets individuales) whatweb -a 4 http://ejemplo.com # Ver cuantas peticiones hace cada nivel: # Nivel 1: 1 # Nivel 2: 1-10 aprox. # Nivel 3: 10-50 aprox. # Nivel 4: 100+ peticiones
💡 CUÁNDO USAR CADA NIVELEn un pentest con scope amplio (muchos hosts) usa nivel 1 o 2 para el escaneo inicial. Una vez identificados los objetivos más interesantes, usa nivel 3 o 4 para análisis en profundidad de esos hosts concretos.
🔍
Ejercicio 1 — Reconocimiento Básico
Escanear una URL y entender el formato de salida de WhatWeb

El uso más básico de WhatWeb: escanear una URL y ver qué tecnologías utiliza. Perfecto para entender el formato de salida y cómo interpretar los resultados.

1
Escaneo básico de una URLBÁSICO
Escaneo basico
# Escaneo simple con nivel de agresividad 1 (default): whatweb http://testphp.vulnweb.com # Ejemplo de salida: # http://testphp.vulnweb.com [200] # Apache[2.4.7], Bootstrap[3.3.4], Country[UNITED STATES][US], # HTTPServer[Ubuntu Linux][Apache/2.4.7 (Ubuntu)], IP[44.228.249.3], # JQuery[1.7.1], PHP[5.5.9], Script, Title[Home of Acunetix Art] # Con modo verbose (-v) para ver todos los detalles: whatweb -v http://testphp.vulnweb.com
2
Interpretar la salidaINTERPRETACIÓN
http://testphp.vulnweb.com [200]
  [1] Apache[2.4.7]          <- Servidor web y version
  [2] Bootstrap[3.3.4]        <- Framework CSS
  [3] Country[UNITED STATES]  <- Pais del servidor (GeoIP)
  [4] HTTPServer[Apache/2.4.7 (Ubuntu)] <- Banner completo del servidor
  [5] IP[44.228.249.3]        <- IP del servidor
  [6] JQuery[1.7.1]           <- Libreria JS y version
  [7] PHP[5.5.9]              <- Lenguaje backend y version
  [8] Script                  <- Detecta scripts en la pagina
  [9] Title[Home of Acunetix] <- Titulo de la pagina
 [10] X-Powered-By[PHP/5.5.9] <- Cabecera X-Powered-By (info leakage)
💡 El código HTTP al principio ([200], [301], [403]...) te dice si el servidor respondió correctamente. Un [403] con información tecnológica sigue siendo útil.
3
Escaneo verbose para ver cada pluginVERBOSE
Modo verbose: detalles de cada plugin
# -v muestra cada plugin individualmente con su patron de deteccion: whatweb -v http://ejemplo-wordpress.com # Salida verbose: # [1/10] Checking http://ejemplo-wordpress.com # Plugin: WordPress # String match at position 1512 in HTML: '/wp-content/' # Plugin: Apache # String match in headers: 'Server: Apache/2.4.41' # Plugin: PHP # Regex match in headers: 'X-Powered-By: PHP/7.4.3'
❓ Ejercicio práctico
Escanea http://testphp.vulnweb.com (un sitio vulnerable de práctica de Acunetix). ¿Qué versión de PHP usa? ¿Qué versión de Apache? ¿Qué CMS o framework detecta?
💡 Pista: whatweb http://testphp.vulnweb.com -v --- Busca los campos PHP, Apache y cualquier CMS en la salida.
Ver solución
whatweb -v http://testphp.vulnweb.com --- La salida deberia mostrar: PHP[5.5.9], Apache[2.4.7], jQuery[1.7.1], Bootstrap[3.3.4]. No detecta CMS porque es una aplicacion PHP personalizada, no un CMS conocido. Estas versiones son muy antiguas y tienen CVEs conocidos.
📊
Ejercicio 2 — Escaneo de Múltiples Objetivos
Escanear rangos CIDR, listas de URLs y redes completas en paralelo

WhatWeb brilla cuando necesitas escanear muchos objetivos a la vez: un rango de IPs, una lista de dominios de un programa de bug bounty, o toda una red interna. Los hilos paralelos permiten escanear decenas de hosts por segundo.

1
Escanear un rango CIDR completoRANGO CIDR
Escanear subredes completas
# Escanear toda una subred /24: whatweb 192.168.1.0/24 # Con mas hilos para mayor velocidad: whatweb -t 50 192.168.1.0/24 # Guardar resultados en JSON para procesar despues: whatweb --log-json=red_interna.json 192.168.1.0/24 # Solo IPs que respondan (omitir errores de conexion): whatweb --no-errors 192.168.1.0/24 # Escanear rango de IPs especifico: whatweb 10.0.0.1-254 whatweb 10.0.0.1,10.0.0.2,10.0.0.3
2
Escanear lista de URLs desde archivoLISTA DE URLS
Escanear lista de objetivos desde archivo
# Crear archivo con lista de URLs: cat > urls.txt << 'EOF' http://ejemplo1.com http://ejemplo2.com https://ejemplo3.com http://192.168.1.10 http://192.168.1.11:8080 EOF # Escanear la lista: whatweb -i urls.txt # Con nivel de agresividad 2 y guardando JSON: whatweb -i urls.txt -a 2 --log-json=resultados.json # Combinado con resultado de Nmap (hosts con puertos web abiertos): nmap -p 80,443,8080,8443 192.168.1.0/24 --open -oG nmap_web.txt grep '/open/' nmap_web.txt | awk '{print $2}' > hosts_web.txt whatweb -i hosts_web.txt --log-json=whatweb_nmap.json
3
Escaneo rápido con muchos hilosALTA VELOCIDAD
Optimizar el escaneo para velocidad
# Para escaneos grandes, optimizar con: # -t 100 : 100 hilos paralelos # -a 1 : nivel 1 (solo 1 peticion por host, mas rapido) # --no-errors: no mostrar errores de timeout/conexion # --colour=never: sin colores (mas rapido en terminal) whatweb \ -t 100 \ -a 1 \ --no-errors \ --colour=never \ --log-brief=escaneo_rapido.txt \ 192.168.0.0/16 # Para un bug bounty con miles de subdominios: # Generar lista con subfinder/amass y pasarla a WhatWeb: subfinder -d ejemplo.com -silent > subdominios.txt whatweb -i subdominios.txt -t 50 --no-errors --log-json=bugs.json
❓ Ejercicio práctico
Genera un archivo urls.txt con 5 URLs de sitios web públicos diferentes. Escánalos con WhatWeb en paralelo con 10 hilos y guarda el resultado en JSON. ¿Qué CMS es más común entre los 5?
💡 Pista: whatweb -i urls.txt -t 10 --log-json=resultado.json --- Luego: cat resultado.json | python3 -m json.tool
Ver solución
whatweb -i urls.txt -t 10 --no-errors --log-json=resultado.json --- Para ver los CMS detectados: grep -o 'WordPress\|Joomla\|Drupal\|Wix\|Squarespace' resultado.json | sort | uniq -c | sort -rn --- WordPress domina el mercado con mas del 40% de los sitios web mundiales, por lo que aparecera con mas frecuencia.
🌐
Ejercicio 3 — Detección de Tecnologías Web
Identificar CMS, servidores web, frameworks y bibliotecas JavaScript

Una de las principales fortalezas de WhatWeb es su capacidad para identificar el stack tecnológico completo de una web. Entender qué tecnologías usa el objetivo es el primer paso para buscar vulnerabilidades: versiones antiguas, configuraciones por defecto, CVEs conocidos...

1
Identificar el CMSDETECCIÓN CMS
Detectar WordPress, Joomla, Drupal y otros CMS
# WordPress: whatweb -a 3 http://sitio-wordpress.com # Salida: WordPress[6.4.2], woocommerce[8.4.0], Yoast-SEO[22.0] # Joomla: whatweb -a 3 http://sitio-joomla.com # Salida: Joomla[3.9.27] # Drupal: whatweb -a 3 http://sitio-drupal.com # Salida: Drupal[9] # Filtrar solo CMS en resultados de multiples sites: whatweb -i lista.txt --no-errors | \ grep -iE '(WordPress|Joomla|Drupal|Magento|PrestaShop|Wix|Squarespace)' # Ver informacion de los plugins de CMS: whatweb --info-plugins=WordPress whatweb --info-plugins=Joomla
2
Identificar servidores web y versionesSERVIDORES WEB
Detectar Apache, Nginx, IIS y sus versiones
# Ver la version exacta del servidor web: whatweb -v http://ejemplo.com | grep -iE '(Apache|Nginx|IIS|LiteSpeed|Tomcat)' # Comparar con CVEs conocidos de esa version: # Apache 2.4.49 -> CVE-2021-41773 (Path Traversal / RCE) # Apache 2.4.50 -> CVE-2021-42013 (Path Traversal mejorado) # Nginx 1.3.9-1.4.0 -> CVE-2013-2028 (Stack Overflow) # IIS 6.0 -> CVE-2017-7269 (Buffer Overflow, EternalBlue compatible) # Escaneo orientado a detectar versiones vulnerables de Apache: whatweb -i urls.txt --no-errors | \ grep -oP 'Apache\[\K[0-9.]+' | \ sort -V | uniq -c | sort -rn
3
Identificar frameworks y bibliotecas JSSTACK COMPLETO
Detectar el stack tecnologico completo
# Detectar frameworks backend y frontend: whatweb -a 2 http://app-moderna.com # Posible salida para una app moderna: # React, Bootstrap[5.3.2], JQuery[3.7.1], Font-Awesome[6.4] # Node.js, Express, Nginx[1.24.0] # Detectar lenguaje de programacion: # PHP, Python (Django/Flask), Ruby (Rails), Java (Tomcat/Spring) # Buscar informacion de versiones especificas: # JQuery < 1.9.0 -> CVE-2012-6708 (XSS) # Bootstrap < 3.4.0 -> CVE-2018-14042 (XSS) # jQuery < 3.5.0 -> CVE-2020-11022/11023 (XSS) # Exportar solo las tecnologias encontradas en JSON y procesarlas: whatweb --log-json=tech.json http://ejemplo.com python3 -c " import json with open('tech.json') as f: data=json.load(f) for site in data: print(site.get('target',{}).get('site','')) for plugin in site.get('plugins',{}): print(' ', plugin) "
❓ Ejercicio práctico
Escanea con WhatWeb nivel 3 (-a 3) un sitio WordPress conocido. ¿Qué plugins de WordPress detecta además del propio WordPress? ¿Qué versión de WordPress es?
💡 Pista: Con -a 3 WhatWeb prueba URLs como /wp-login.php, /wp-content/, /readme.html para confirmar y extraer la version.
Ver solución
whatweb -a 3 -v http://sitio-wordpress.com --- WhatWeb detecta: la version de WordPress en /readme.html o en los meta-generadores, plugins activos por sus assets en /wp-content/plugins/, y el tema activo. Con -a 3 tambien prueba /wp-json/wp/v2/users para enumerar usuarios via API REST.
📄
Ejercicio 4 — Formatos de Salida y Procesado
JSON, XML, SQL: integrar WhatWeb en workflows automatizados

WhatWeb soporta múltiples formatos de salida que permiten integrar los resultados en workflows automatizados, bases de datos, o herramientas de visualización. El formato JSON es el más versátil para procesado posterior.

1
Formatos de salida disponiblesFORMATOS
Todos los formatos de log de WhatWeb
# Formato brief (texto compacto, uno por linea): whatweb --log-brief=resultados.txt http://ejemplo.com # Formato verbose (texto detallado): whatweb --log-verbose=resultados_verbose.txt http://ejemplo.com # Formato JSON (el mas util para procesado automatico): whatweb --log-json=resultados.json http://ejemplo.com # Formato XML: whatweb --log-xml=resultados.xml http://ejemplo.com # Formato SQL (para importar en base de datos): whatweb --log-sql=resultados.sql http://ejemplo.com # Formato Mongo (para MongoDB): whatweb --log-mongo-db=whatweb http://ejemplo.com # Combinacion: guardar en JSON Y mostrar en pantalla: whatweb --log-json=out.json http://ejemplo.com
2
Procesar la salida JSON con PythonJSON PROCESSING
Analizar resultados WhatWeb con Python
#!/usr/bin/env python3 # Procesar salida JSON de WhatWeb para extraer informacion import json import sys def analizar_whatweb(archivo_json): with open(archivo_json) as f: datos = json.load(f) for sitio in datos: target = sitio.get('target', {}) url = target.get('site', 'desconocido') http_status = target.get('http_status', '?') plugins = sitio.get('plugins', {}) print(f'\nURL: {url} [{http_status}]') # Extraer tecnologias importantes for plugin_name, plugin_data in plugins.items(): version = plugin_data.get('version', []) string = plugin_data.get('string', []) if version: print(f' {plugin_name}: {version[0]}') elif string: print(f' {plugin_name}: {string[0]}') else: print(f' {plugin_name}') if __name__ == '__main__': analizar_whatweb(sys.argv[1] if len(sys.argv) > 1 else 'resultados.json') # Uso: # python3 analizar_whatweb.py resultados.json
3
Filtrar y buscar tecnologias especificasFILTRADO
grep y jq para filtrar resultados
# Buscar solo sitios con WordPress: cat resultados.json | python3 -m json.tool | grep -i wordpress # Con jq (procesador JSON en CLI): jq '.[] | select(.plugins.WordPress != null) | .target.site' resultados.json # Extraer version de Apache de todos los sitios: jq '.[] | .target.site + ": " + (.plugins.Apache.version[0] // "no-apache")' resultados.json # Encontrar sitios con PHP < 7.0 (vulnerable): jq '.[] | select(.plugins.PHP.version[0] < "7.0") | .target.site' resultados.json # Contar sitios por CMS: for cms in WordPress Joomla Drupal Magento Wix; do count=$(jq "[.[] | select(.plugins.$cms != null)] | length" resultados.json 2>/dev/null) echo "$cms: $count sitios" done
❓ Ejercicio práctico
Escanea 10 sitios web con WhatWeb y guarda el resultado en JSON. Luego usa Python o jq para extraer solo los sitios que usan WordPress y su versión. ¿Cuántos hay?
💡 Pista: whatweb -i urls.txt --log-json=out.json -- luego: jq '[.[] | select(.plugins.WordPress != null)]' out.json
Ver solución
whatweb -i urls.txt --no-errors --log-json=out.json --- jq '[.[] | select(.plugins.WordPress != null) | {url: .target.site, version: .plugins.WordPress.version[0]}]' out.json --- Esto devuelve un array JSON con los sitios WordPress y sus versiones. Para el conteo: jq '[.[] | select(.plugins.WordPress != null)] | length' out.json
⚙
Ejercicio 5 — Cookies, Cabeceras y Proxy
Escanear áreas autenticadas y enrutar por Burp Suite

WhatWeb puede personalizar las peticiones HTTP que envía: cabeceras personalizadas, cookies de sesión autenticada, User-Agent específico y envío a través de un proxy como Burp Suite. Esto permite analizar aplicaciones web que requieren autenticación o que tienen WAF.

1
Enviar cookies de sesión autenticadaAUTENTICACIÓN
Escanear areas autenticadas con cookies
# Enviar una cookie de sesion para escanear areas privadas: whatweb --header 'Cookie: PHPSESSID=abc123def456' \ http://app.com/dashboard # Multiples cabeceras: whatweb \ --header 'Cookie: session=abc; token=xyz' \ --header 'Authorization: Bearer eyJhbGciOiJIUzI1NiJ9...' \ http://api.ejemplo.com/admin # Con autenticacion HTTP Basic: whatweb --user admin:password http://ejemplo.com/admin # Obtener la cookie primero con curl y usarla: # 1. Login y guardar cookie: curl -c cookies.txt -X POST http://app.com/login \ -d 'user=admin&pass=Password123' # 2. Usar la cookie en WhatWeb: cookie=$(grep -oP 'PHPSESSID\s+\K\S+' cookies.txt) whatweb --header "Cookie: PHPSESSID=$cookie" http://app.com/dashboard
2
User-Agent personalizadoUSER-AGENT
Personalizar el User-Agent para evadir controles basicos
# User-Agent por defecto de WhatWeb: # WhatWeb/0.5.5 (https://www.morningstarsecurity.com/research/whatweb) # Simular Googlebot: whatweb --user-agent 'Googlebot/2.1 (+http://www.google.com/bot.html)' http://ejemplo.com # Simular Chrome real: whatweb --user-agent 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36' http://ejemplo.com # Simular iPhone: whatweb --user-agent 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_2 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Mobile/15E148 Safari/604.1' http://ejemplo.com
3
Usar Burp Suite como proxyPROXY / BURP
Enrutar WhatWeb a traves de Burp Suite para ver las peticiones
# 1. Iniciar Burp Suite con el proxy en 127.0.0.1:8080 # 2. Ejecutar WhatWeb con el proxy de Burp: whatweb --proxy 127.0.0.1:8080 http://ejemplo.com # Para HTTPS (necesitas instalar el certificado de Burp): whatweb --proxy 127.0.0.1:8080 https://ejemplo.com # Proxy SOCKS5 (para usar con Tor o tuneles SSH): whatweb --proxy socks5://127.0.0.1:1080 http://ejemplo.com # Ver las peticiones en Burp en tiempo real mientras WhatWeb escanea # Util para: # - Entender exactamente que peticiones hace WhatWeb # - Modificar peticiones manualmente despues de verlas # - Capturar respuestas completas
❓ Ejercicio práctico
Levanta un servidor web local con python3 -m http.server 8080 y escanea http://localhost:8080 con WhatWeb a través del proxy de Burp Suite (127.0.0.1:8080). ¿Qué peticiones HTTP hace WhatWeb?
💡 Pista: whatweb --proxy 127.0.0.1:8080 http://localhost:8080 --- Observa en Burp el historial de peticiones.
Ver solución
whatweb --proxy 127.0.0.1:8080 http://localhost:8080 --- En Burp veras: 1 peticion GET a / con el User-Agent de WhatWeb. Con -a 3 veras peticiones adicionales a rutas como /robots.txt, /sitemap.xml, etc. Esto te permite ver exactamente con que cabeceras HTTP llega WhatWeb al servidor.
📊
Ejercicio 6 — Análisis de Versiones y CVEs
Del fingerprinting a los CVEs: identificar versiones vulnerables

El valor más práctico de WhatWeb en un pentest es identificar versiones concretas de software y correlacionarlas con vulnerabilidades conocidas (CVEs). Una versión de WordPress, PHP, Apache o jQuery detectada con WhatWeb puede revelar directamente un vector de ataque explotable.

1
Extraer versiones y buscar CVEsCVE LOOKUP
Del fingerprinting al CVE: flujo completo
# 1. Escanear y guardar resultado: whatweb -a 2 --log-json=tech.json http://objetivo.com # 2. Extraer versiones detectadas: jq '.[] | .plugins | to_entries[] | select(.value.version != null) | {plugin: .key, version: .value.version[0]}' tech.json # Resultado ejemplo: # {"plugin": "WordPress", "version": "5.8.1"} # {"plugin": "PHP", "version": "7.2.34"} # {"plugin": "Apache", "version": "2.4.49"} # {"plugin": "jQuery", "version": "1.12.4"} # 3. Buscar CVEs con searchsploit: searchsploit Apache 2.4.49 searchsploit WordPress 5.8 searchsploit jQuery 1.12 # 4. Buscar en la NVD: # https://nvd.nist.gov/vuln/search?query=Apache+2.4.49 # https://nvd.nist.gov/vuln/search?query=WordPress+5.8.1
2
Automatizar la búsqueda de CVEsAUTOMATIZACIÓN
Script Python: WhatWeb + searchsploit automatico
#!/usr/bin/env python3 # Combinar WhatWeb con searchsploit para buscar CVEs automaticamente import json import subprocess import sys def buscar_exploits(plugin, version): query = f'{plugin} {version}' result = subprocess.run( ['searchsploit', '--json', query], capture_output=True, text=True ) try: data = json.loads(result.stdout) exploits = data.get('RESULTS_EXPLOIT', []) return exploits[:3] # Primeros 3 resultados except: return [] with open(sys.argv[1]) as f: whatweb_data = json.load(f) for sitio in whatweb_data: url = sitio.get('target', {}).get('site', '') plugins = sitio.get('plugins', {}) print(f'\n=== {url} ===') for nombre, datos in plugins.items(): versiones = datos.get('version', []) if versiones: version = versiones[0] exploits = buscar_exploits(nombre, version) if exploits: print(f' [!] {nombre} {version} - {len(exploits)} exploit(s):') for exp in exploits: print(f' - {exp.get("Title","")} | {exp.get("Path","")}') # Uso: # python3 whatweb_cve.py tech.json
3
Cabeceras de seguridad: detectar su ausenciaSECURITY HEADERS
Identificar cabeceras de seguridad faltantes
# WhatWeb detecta (o la ausencia de) cabeceras de seguridad: # Ejecutar con verbose para ver cabeceras: whatweb -v http://ejemplo.com | grep -iE '(X-Frame-Options|X-XSS|Content-Security|HSTS|X-Content-Type)' # Las cabeceras que WhatWeb detecta incluyen: # Strict-Transport-Security (HSTS) # X-Frame-Options (clickjacking) # X-Content-Type-Options # Content-Security-Policy (CSP) # X-XSS-Protection # Referrer-Policy # Si NO aparecen en el output, estan ausentes -> vulnerabilidad # Complementar con securityheaders.com para un analisis completo # o con curl: curl -s -I http://ejemplo.com | grep -iE '(X-Frame|X-Content|Strict|Content-Security|X-XSS)'
❓ Ejercicio práctico
Escanea un sitio con WhatWeb y extrae las versiones de todas las tecnologías detectadas. Luego busca en searchsploit si alguna tiene exploits públicos. ¿Qué CVE más grave encuentras?
💡 Pista: jq para extraer versiones + searchsploit para buscar. Presta atencion a Apache, PHP y jQuery.
Ver solución
whatweb -a 2 --log-json=tech.json http://objetivo.com --- jq '.[] | .plugins | to_entries[] | select(.value.version != null) | {p: .key, v: .value.version[0]}' tech.json --- Para cada version: searchsploit PLUGIN VERSION --- PHP 5.x tiene multiples CVEs criticos (EoL desde 2018). Apache 2.4.49 tiene CVE-2021-41773 (RCE). jQuery < 3.5.0 tiene CVE-2020-11022 (XSS).
🛠
Ejercicio 7 — Escribir un Plugin Personalizado
Extender WhatWeb con plugins Ruby para detectar tecnologías propias

WhatWeb es completamente extensible mediante plugins escritos en Ruby. Cada plugin define patrones de detección (strings, regex, cabeceras, cookies...) y WhatWeb los comprueba en cada respuesta HTTP. Escribir plugins propios es sencillo y permite detectar tecnologías propietarias o versiones específicas no cubiertas por los 1.900 plugins incluidos.

1
Anatomia de un plugin WhatWebESTRUCTURA
Estructura basica de un plugin WhatWeb en Ruby
# Todos los plugins estan en: # /usr/share/whatweb/plugins/ # o en WhatWeb/plugins/ si instalaste desde GitHub # Ver un plugin existente como ejemplo: cat /usr/share/whatweb/plugins/WordPress.rb | head -50 # Estructura minima de un plugin: # Plugin.define 'NombrePlugin' do # author 'Tu Nombre' # version '0.1' # description 'Descripcion del plugin' # # matches [ # { :string => 'texto a buscar en la respuesta' }, # { :regexp => /patron regex/ }, # { :ghdb => 'google hack dork' }, # ] # end
2
Escribir un plugin personalizadoDESARROLLO
Plugin personalizado: detectar una aplicacion propia
# Crear un plugin para detectar una app con firma especifica # Guardar como: /usr/share/whatweb/plugins/mi-app.rb cat > /usr/share/whatweb/plugins/mi-app.rb << 'EOF' # Plugin WhatWeb personalizado # Detecta la aplicacion interna "MiApp" por sus firmas Plugin.define 'MiApp' do author 'GhostAcademy' version '1.0' description 'Detecta la aplicacion MiApp por firmas en HTML y cabeceras' website 'https://www.unfantasmaenelsistema.com' matches [ # Detectar por string en el HTML { :string => '<meta name="generator" content="MiApp"' }, # Detectar por regex (con captura de version) { :regexp => /MiApp\/([\d.]+)/, :offset => 0 }, # Detectar por cabecera HTTP especifica { :name => 'Powered-By MiApp', :headers => { 'X-Powered-By' => /MiApp/ } }, # Detectar por cookie especifica { :name => 'MiApp Session Cookie', :cookies => { 'miapp_session' => // } }, # Detectar por URL especifica (archivo de firma) { :string => 'miapp/assets/logo.png', :url => '/' }, ] end EOF # Verificar que el plugin se carga correctamente: whatweb --info-plugins=MiApp # Probar el plugin: whatweb http://localhost:8080
3
Tipos de patrones de detecciónPATRONES
Todos los tipos de match disponibles en plugins WhatWeb
# 1. STRING: texto literal en el cuerpo de la respuesta { :string => 'wp-content' } # 2. REGEXP: expresion regular con captura de version { :regexp => /WordPress\/([\d.]+)/ } # 3. HEADERS: cabecera HTTP especifica { :headers => { 'Server' => /Apache\/([\d.]+)/ } } # 4. COOKIES: nombre y/o valor de cookie { :cookies => { 'PHPSESSID' => // } } # 5. URL: ruta a verificar (WhatWeb hace GET a esa URL) { :url => '/wp-login.php', :string => 'WordPress' } # 6. GHDB: Google Hacking Database dork { :ghdb => 'inurl:wp-content/plugins' } # 7. TAGPATTERN: patron en etiquetas HTML { :tagpattern => 'input[name=wp-nonce]' } # 8. STATUS: codigo HTTP especifico { :status => 403 } # La version se extrae del primer grupo de captura de la regex: { :regexp => /Joomla\/([\d.]+)/ } # Captura la version
❓ Ejercicio práctico
Escribe un plugin WhatWeb que detecte si un servidor usa el servidor HTTP de Python (SimpleHTTP/0.6) leyendo la cabecera Server. Pruebalo contra python3 -m http.server.
💡 Pista: Mira la estructura de un plugin existente y usa :headers para detectar el campo Server.
Ver solución
Plugin.define 'PythonSimpleHTTP' do --- matches [ --- { :headers => { 'Server' => /SimpleHTTP\/([\d.]+)/ } } --- ] --- end --- Guardar en /usr/share/whatweb/plugins/python-simplehttp.rb --- whatweb http://localhost:8000 --- Debe detectar: PythonSimpleHTTP[0.6] en la salida.
💻
Ejercicio 8 — Integración en Pipelines
Combinar WhatWeb con Subfinder, Nmap y httpx en workflows automatizados

WhatWeb se integra perfectamente en pipelines de reconocimiento automatizados. Una cadena típica combina: descubrimiento de subdominios (Subfinder/Amass) + detección de puertos web (Nmap) + fingerprinting (WhatWeb) + exportación a base de datos para análisis.

💻PIPELINE COMPLETO DE RECONOCIMIENTO WEB
Pipeline: Subfinder + httpx + WhatWeb + jq
#!/bin/bash # Pipeline completo de reconocimiento web # Requiere: subfinder, httpx, whatweb, jq DOMINIO=${1:-"ejemplo.com"} OUTPUT_DIR="recon_${DOMINIO}" mkdir -p "$OUTPUT_DIR" echo "[1] Descubriendo subdominios de $DOMINIO..." subfinder -d "$DOMINIO" -silent -o "$OUTPUT_DIR/subdominios.txt" echo " Encontrados: $(wc -l < $OUTPUT_DIR/subdominios.txt) subdominios" echo "[2] Verificando subdominios activos con httpx..." cat "$OUTPUT_DIR/subdominios.txt" | \ httpx -silent -status-code -o "$OUTPUT_DIR/activos.txt" echo " Activos: $(wc -l < $OUTPUT_DIR/activos.txt)" echo "[3] Fingerprinting con WhatWeb..." cat "$OUTPUT_DIR/activos.txt" | awk '{print $1}' > "$OUTPUT_DIR/urls.txt" whatweb \ -i "$OUTPUT_DIR/urls.txt" \ -t 50 \ -a 1 \ --no-errors \ --log-json="$OUTPUT_DIR/whatweb.json" echo "[4] Extrayendo resumen de tecnologias..." jq -r '.[] | [.target.site, (.plugins | keys | join(","))] | @tsv' \ "$OUTPUT_DIR/whatweb.json" > "$OUTPUT_DIR/tech_summary.tsv" echo "[5] Buscando WordPress desactualizado..." jq -r '.[] | select(.plugins.WordPress != null) | \ [.target.site, (.plugins.WordPress.version[0] // "version-desconocida")] | @tsv' \ "$OUTPUT_DIR/whatweb.json" > "$OUTPUT_DIR/wordpress_sites.tsv" echo "Completado. Resultados en $OUTPUT_DIR/" echo "Sitios WordPress: $(wc -l < $OUTPUT_DIR/wordpress_sites.tsv)"
Integracion con Nmap: escanear solo hosts con puertos web
# 1. Nmap: encontrar hosts con puertos web abiertos: nmap -p 80,443,8080,8443,8000,3000 192.168.1.0/24 \ --open -oG nmap_web.txt # 2. Extraer solo las IPs que tienen puertos web: grep 'open' nmap_web.txt | awk '{print $2}' > hosts_con_web.txt # 3. Crear URLs para WhatWeb: while read ip; do echo "http://$ip" echo "https://$ip" done < hosts_con_web.txt > urls_para_whatweb.txt # 4. Escanear con WhatWeb: whatweb -i urls_para_whatweb.txt \ -t 30 \ --no-errors \ --log-json=whatweb_nmap.json # 5. Resumen rapido: jq -r '.[] | .target.site + ": " + (.plugins | keys | join(", "))' whatweb_nmap.json
❓ Ejercicio práctico
Crea un script de bash que: (1) acepte un dominio como argumento, (2) use WhatWeb para escanear ese dominio con nivel 2, (3) extraiga las tecnologías detectadas y las muestre en formato limpio. Ejecútalo con un sitio de práctica.
💡 Pista: whatweb -a 2 --log-json=out.json DOMINIO --- jq para extraer plugins del JSON.
Ver solución
#!/bin/bash --- DOMAIN=$1 --- whatweb -a 2 --no-errors --log-json=/tmp/ww_$DOMAIN.json "http://$DOMAIN" --- echo 'Tecnologias detectadas en' $DOMAIN: --- jq -r '.[0].plugins | keys[]' /tmp/ww_$DOMAIN.json --- Guardar como recon.sh, chmod +x recon.sh, ./recon.sh testphp.vulnweb.com
🎓
Ejercicio 9 — WhatWeb en Bug Bounty
Reconocimiento y priorización de objetivos en programas de bug bounty

WhatWeb es una herramienta ideal para la fase inicial de reconocimiento en programas de bug bounty. Permite identificar rápidamente el stack tecnológico de todos los activos del programa y priorizar cuáles analizar en profundidad según las tecnologías detectadas.

1
Reconocimiento inicial del programaRECONOCIMIENTO
Flujo de trabajo para bug bounty con WhatWeb
# FASE 1: Obtener el scope del programa # (leer las reglas del programa en HackerOne / Bugcrowd) # Ejemplo de scope: *.empresa.com # FASE 2: Descubrir subdominios del scope: subfinder -d empresa.com -silent | \ httpx -silent -status-code > activos.txt # FASE 3: Fingerprinting con WhatWeb: awk '{print $1}' activos.txt | \ whatweb -i /dev/stdin \ -t 30 -a 1 --no-errors \ --log-json=whatweb_empresa.json # FASE 4: Priorizar objetivos interesantes: # a) Sitios con versiones de WordPress antiguas jq -r '.[] | select(.plugins.WordPress.version[0] < "6.0") | .target.site' whatweb_empresa.json # b) Sitios con PHP antiguo (< 7.4) jq -r '.[] | select(.plugins.PHP.version[0] | . != null and . < "7.4") | .target.site' whatweb_empresa.json # c) Sitios con Tomcat (tipicamente con credenciales por defecto) jq -r '.[] | select(.plugins.Tomcat != null) | .target.site' whatweb_empresa.json # d) Sitios con paneles de admin detectados jq -r '.[] | select(.plugins | keys[] | test("Admin|Panel|Login"; "i")) | .target.site' whatweb_empresa.json
2
Identificar tecnologías de alto valorPRIORIZACIÓN
Tecnologias de alto interes en bug bounty
# Tecnologias con mayor probabilidad de tener vulnerabilidades: # Apache Tomcat (paneles /manager con credenciales por defecto): jq -r '.[] | select(.plugins.Apache_Tomcat != null) | .target.site' whatweb_empresa.json # phpMyAdmin (acceso directo a base de datos): jq -r '.[] | select(.plugins.phpMyAdmin != null) | .target.site' whatweb_empresa.json # Elasticsearch (sin autenticacion si es < 7.0): jq -r '.[] | select(.plugins.Elasticsearch != null) | .target.site' whatweb_empresa.json # CMS con versiones antiguas: jq -r '.[] | select(.plugins.Drupal.version[0] < "9.0") | .target.site' whatweb_empresa.json # Jenkins (paneles de CI/CD frecuentemente expuestos): jq -r '.[] | select(.plugins.Jenkins != null) | .target.site' whatweb_empresa.json # Magento (alto valor por datos de tarjetas de credito): jq -r '.[] | select(.plugins.Magento != null) | .target.site' whatweb_empresa.json
3
Documentar hallazgos para el informeINFORME
Generar un resumen automatico de tecnologias
#!/usr/bin/env python3 # Generar informe de tecnologias para bug bounty import json with open('whatweb_empresa.json') as f: data = json.load(f) prioridad_alta = [] prioridad_media = [] prioridad_normal = [] tecnologias_riesgo = { 'phpMyAdmin': 'ALTA - Acceso a base de datos', 'Apache_Tomcat': 'ALTA - Panel de administracion', 'Jenkins': 'ALTA - Panel CI/CD', 'Magento': 'ALTA - E-commerce con datos de pago', 'Elasticsearch': 'MEDIA - Posible base de datos expuesta', 'WordPress': 'MEDIA - CMS popular con muchos plugins vulnerables', 'Joomla': 'MEDIA - CMS con historial de vulnerabilidades', 'Drupal': 'MEDIA - Drupalgeddon 2/3 si version antigua', } for sitio in data: url = sitio.get('target',{}).get('site','') plugins = sitio.get('plugins',{}) for tech, riesgo in tecnologias_riesgo.items(): if tech in plugins: version = plugins[tech].get('version', ['?'])[0] if riesgo.startswith('ALTA'): prioridad_alta.append(f'{url} - {tech}[{version}] - {riesgo}') else: prioridad_media.append(f'{url} - {tech}[{version}] - {riesgo}') print('=== PRIORIDAD ALTA ===') for item in prioridad_alta: print(f' {item}') print('\n=== PRIORIDAD MEDIA ===') for item in prioridad_media: print(f' {item}')
🔧
Catálogo de Plugins Principales
Los 1.900+ plugins de WhatWeb: los más relevantes para un pentest

WhatWeb incluye más de 1.900 plugins. Aquí están los más relevantes para un pentest:

📄WordPressCMS + version + plugins instalados
📄JoomlaCMS Joomla y version
📄DrupalCMS Drupal y version
📄MagentoE-commerce Magento
⚙ApacheServidor web y version
⚙NginxServidor Nginx y version
⚙IISMicrosoft IIS y version
⚙Apache_TomcatServidor Java Tomcat
📊PHPVersion de PHP backend
📊ASPASP / ASP.NET de Microsoft
📊Ruby-on-RailsFramework Ruby on Rails
📊DjangoFramework Python Django
📊LaravelFramework PHP Laravel
💻jQueryVersion libreria jQuery
💻BootstrapVersion Bootstrap CSS
💻ReactLibreria React.js
💻AngularFramework Angular
🔒Cookie-FlagsFlags HttpOnly/Secure en cookies
🔒HSTSHTTP Strict Transport Security
🔒X-Frame-OptionsProtección contra clickjacking
🔒CSPContent Security Policy
🔎phpMyAdminPanel de administracion MySQL
🔎JenkinsServidor CI/CD Jenkins
🔎CloudflareCDN/WAF Cloudflare activo
Trabajar con plugins especificos
# Ver todos los plugins disponibles: whatweb --list-plugins | wc -l # ~1900 plugins # Ver informacion detallada de un plugin: whatweb --info-plugins=WordPress whatweb --info-plugins=Apache # Usar solo plugins especificos (mas rapido): whatweb --plugins=WordPress,PHP,Apache http://ejemplo.com # Buscar plugins por nombre: whatweb --list-plugins | grep -i 'cms' whatweb --list-plugins | grep -i 'framework' # Deshabilitar un plugin que genera falsos positivos: whatweb --plugins-disable=Country http://ejemplo.com # Ver el codigo fuente de un plugin: cat /usr/share/whatweb/plugins/WordPress.rb
📚
Cheatsheet Completo de WhatWeb
Referencia rápida de todos los comandos
WhatWeb Cheatsheet completo
# ── ESCANEO BASICO ────────────────────────────────── whatweb http://ejemplo.com # Escaneo simple whatweb -v http://ejemplo.com # Verbose whatweb -a 3 http://ejemplo.com # Agresivo whatweb -a 1 --no-errors http://ejemplo.com # Silencioso # ── MULTIPLES OBJETIVOS ───────────────────────────── whatweb 192.168.1.0/24 # Subred entera whatweb -i urls.txt # Lista de URLs whatweb -t 50 192.168.1.0/24 # 50 hilos paralelos whatweb 10.0.0.1-254 # Rango de IPs # ── SALIDA Y LOGGING ──────────────────────────────── whatweb --log-brief=out.txt http://ejem.com # Texto compacto whatweb --log-json=out.json http://ejem.com # JSON whatweb --log-xml=out.xml http://ejem.com # XML whatweb --log-verbose=out.txt http://ejem.com # Verbose a archivo # ── AUTENTICACION Y CABECERAS ─────────────────────── whatweb --user admin:pass http://ejem.com # HTTP Basic Auth whatweb --header 'Cookie: sess=abc' http://.. # Con cookie whatweb --user-agent 'Mozilla/5.0...' http:// # User-Agent custom whatweb --proxy 127.0.0.1:8080 http://.. # Via proxy (Burp) # ── PLUGINS ───────────────────────────────────────── whatweb --list-plugins # Listar todos whatweb --info-plugins=WordPress # Info de un plugin whatweb --plugins=WordPress,PHP http://.. # Solo esos plugins whatweb --plugins-disable=Country http://.. # Deshabilitar plugin # ── PROCESADO DE RESULTADOS ───────────────────────── # Extraer solo CMS detectados: whatweb -i urls.txt | grep -oE '(WordPress|Joomla|Drupal)\[[^]]+\]' # Extraer versiones de PHP con jq: jq -r '.[] | [.target.site, (.plugins.PHP.version[0] // "")] | @tsv' out.json # Combinar con Nmap: nmap -p 80,443 192.168.1.0/24 --open -oG - | \ awk '/open/{print $2}' | \ xargs -I{} whatweb -a 1 --no-errors {}
🛡
Defensas contra Fingerprinting Web
Cómo reducir la información que WhatWeb (y los atacantes) pueden obtener

Si WhatWeb puede identificar fácilmente el stack tecnológico de tu aplicación, un atacante real también puede hacerlo. Reducir la información expuesta es una capa de defensa importante (aunque no es suficiente por sí sola).

🛡CÓMO DIFICULTAR EL FINGERPRINTING WEB
Información expuestaRiesgoMitigación
Cabecera Server: Apache/2.4.49Revela servidor y versión exactaConfigurar ServerTokens Prod en Apache (oculta version)
Cabecera X-Powered-By: PHP/7.2Revela lenguaje y versionexpose_php = Off en php.ini
Generador WordPress en HTMLRevela CMS y versionEliminar remove_action( "wp_head", "wp_generator" )
/wp-content/ en URLsConfirma WordPressCambiar la URL del contenido (complejo, no muy efectivo)
Version en nombre de archivos JSRevela versiones de libsEliminar querystrings de version ?ver=6.4
Cookies con nombre de tecnologiaPHPSESSID revela PHPRenombrar la cookie de sesión
README.html de WordPressMuestra version exactaEliminar o bloquear acceso a README.html
Configurar Apache para ocultar informacion de version
# En /etc/apache2/conf-enabled/security.conf o httpd.conf: # Ocultar la version del servidor: ServerTokens Prod # Resultado: Server: Apache (sin version) # Ocultar la signature en paginas de error: ServerSignature Off # En Nginx, editar nginx.conf: # server_tokens off; # En PHP, editar php.ini: # expose_php = Off # session.name = SESS # Cambiar nombre de cookie # Verificar el resultado con curl: curl -s -I http://localhost | grep -i server # Server: Apache <- Bien (sin version) # Server: Apache/2.4.49 <- Mal (version expuesta)
💡 SEGURIDAD POR OSCURIDAD NO ES SUFICIENTEOcultar la versión del servidor dificulta el reconocimiento automático pero no es una defensa real: un atacante experimentado puede determinar la versión por el comportamiento del servidor aunque esté oculta. La verdadera defensa es mantener el software actualizado y aplicar el principio de mínimo privilegio. Ocultar la versión es una capa adicional, no la principal.
📈
WhatWeb vs Otras Herramientas
Comparativa: cuándo usar WhatWeb frente a Wappalyzer, Nikto, Nuclei...
📈WHATWEB VS OTRAS HERRAMIENTAS DE FINGERPRINTING
HerramientaTipoFuerte enDébil enMejor uso
WhatWebCLI, Ruby1.900+ plugins, rangos CIDR, formatos de salida, extensibleNo escanea vulnerabilidades, necesita acceso HTTPFingerprinting masivo, inventario tecnológico
WappalyzerBrowser ext, APIIntegrado en el navegador, UI gráfica, muy precisoSin CLI nativa, limitado en automatizaciónAnálisis puntual en el navegador
NiktoCLI, PerlDetecta vulnerabilidades, archivos peligrososMuy ruidoso, mas lento que WhatWebEscaneo de vulnerabilidades web
Nmap NSECLI, LuaScripts http-headers, banner grabbing integrado con escaneo de puertosMenos plugins web que WhatWebCuando ya usas Nmap para reconocimiento
NucleiCLI, GoTemplates, CVEs, muy rapido, actualizado constantementeMas orientado a vulnerabilidades que a fingerprintingEscaneo de CVEs con templates
curl + grepCLIControl total, sin dependenciasManual, sin plugins, lento para escalaVerificación puntual de cabeceras
✓ CONCLUSIÓNWhatWeb es la herramienta de referencia para fingerprinting web masivo en pentesting. Con sus 1.900+ plugins cubre prácticamente cualquier tecnología web moderna, soporta escaneo en paralelo de rangos CIDR completos, exporta en múltiples formatos para análisis posterior, y es completamente extensible con plugins Ruby. Es el primer paso en cualquier reconocimiento web y se integra perfectamente con Subfinder, Nmap, Burp Suite y cualquier pipeline de automatización.
✓ Copiado