Identificación de Tecnologías Web

La identificación de tecnologías web es una fase crítica del reconocimiento pasivo que permite obtener información valiosa sobre la arquitectura, frameworks, servidores y servicios utilizados por una aplicación web objetivo. Esta información es fundamental para:

• Identificar vectores de ataque específicos de cada tecnología
• Buscar vulnerabilidades conocidas (CVEs) en versiones específicas
• Personalizar la estrategia de testing según el stack tecnológico
• Entender la superficie de ataque disponible
• Optimizar herramientas de enumeración y explotación

🔍 Metodología de Identificación

1. Reconocimiento Pasivo

• Análisis de headers HTTP
• Inspección de código fuente HTML
• Identificación de archivos y directorios característicos
• Análisis de errores y páginas de estado

2. Técnicas de Fingerprinting

• Detección de patrones únicos
• Análisis de respuestas del servidor
• Identificación de cookies y sesiones
• Análisis de certificados SSL

3. Correlación de Datos

• Comparación entre múltiples fuentes
• Validación cruzada de información
• Análisis de consistencia

🛠️ Herramientas Principales

WhatWeb

Descripción: Herramienta de línea de comandos que identifica tecnologías web mediante análisis de páginas web.

Instalación:

# Kali Linux / Debian
sudo apt install whatweb

# Desde código fuente
git clone https://github.com/urbanadventurer/WhatWeb.git
cd WhatWeb
sudo make install

Uso Básico:

# Escaneo básico
whatweb https://example.com

# Escaneo con agresividad alta
whatweb -a 3 https://example.com

# Salida en formato JSON
whatweb --output-json=results.json https://example.com

# Escaneo de múltiples URLs
whatweb -i urls.txt

# Escaneo con User-Agent personalizado
whatweb --user-agent "Mozilla/5.0..." https://example.com

Ejemplos Avanzados:

# Escaneo con plugins específicos
whatweb -p apache,nginx,php https://example.com

# Escaneo a través de proxy
whatweb --proxy 127.0.0.1:8080 https://example.com

# Escaneo con cookies
whatweb --cookie "session=abc123" https://example.com

# Escaneo con headers personalizados
whatweb --header "X-Forwarded-For: 192.168.1.1" https://example.com

Wappalyzer

Descripción: Extensión de navegador y herramienta CLI que detecta tecnologías web en tiempo real.

Instalación:

# Extensión para Firefox
# https://addons.mozilla.org/es/firefox/addon/wappalyzer/

# Extensión para Chrome
# https://chrome.google.com/webstore/detail/wappalyzer

# CLI Version
npm install -g wappalyzer

Uso CLI:

# Análisis básico
wappalyzer https://example.com

# Análisis con salida JSON
wappalyzer --output json https://example.com

# Análisis de múltiples URLs
wappalyzer --urls-file urls.txt

Builtwith.com

Descripción: Servicio web que proporciona análisis detallado de tecnologías utilizadas en sitios web.

Características:

• Análisis histórico de tecnologías
• Información sobre popularidad y tendencias
• API disponible para automatización
• Información sobre hosting y CDN

Uso Web: Acceder a https://builtwith.com/ e introducir la URL objetivo.

API Usage:

# Ejemplo con curl
curl "https://api.builtwith.com/v18/api.json?KEY=YOUR_API_KEY&LOOKUP=example.com"

Herramientas CLI Adicionales

Httpx

# Instalación
go install -v github.com/projectdiscovery/httpx/cmd/httpx@latest

# Identificación de tecnologías
echo "example.com" | httpx -tech-detect -status-code -title

# Con headers detallados
echo "example.com" | httpx -tech-detect -web-server -content-type

Webanalyze

# Instalación
go install -v github.com/rverton/webanalyze/cmd/webanalyze@latest

# Uso básico
webanalyze -host https://example.com

# Salida JSON
webanalyze -host https://example.com -output json

🔧 Técnicas Manuales

Análisis de Headers HTTP

# Con curl
curl -I https://example.com

# Con wget
wget --spider --server-response https://example.com

# Headers específicos a buscar:
# Server: Apache/2.4.41, nginx/1.18.0, IIS/10.0
# X-Powered-By: PHP/7.4.3, ASP.NET
# X-Generator: Drupal, WordPress
# Set-Cookie: PHPSESSID, JSESSIONID, ASP.NET_SessionId

Inspección de Código Fuente

# Descargar página completa
curl -s https://example.com | grep -i -E "(generator|powered|built|framework|version)"

# Buscar patrones específicos
curl -s https://example.com | grep -i -E "(wordpress|drupal|joomla|django|rails|laravel)"

# Análisis de meta tags
curl -s https://example.com | grep -i "<meta"

Identificación de Archivos Característicos

# Archivos comunes de frameworks
curl -I https://example.com/wp-admin/          # WordPress
curl -I https://example.com/administrator/     # Joomla
curl -I https://example.com/user/login         # Drupal
curl -I https://example.com/admin/             # Generic admin
curl -I https://example.com/phpmyadmin/        # phpMyAdmin

📋 Scripts de Automatización

Script Bash para Análisis Completo

#!/bin/bash

target=$1
output_dir="tech_analysis_$(date +%Y%m%d_%H%M%S)"
mkdir -p "$output_dir"

echo "[+] Iniciando análisis de tecnologías para: $target"

# WhatWeb
echo "[+] Ejecutando WhatWeb..."
whatweb -a 3 --output-json="$output_dir/whatweb.json" "$target"

# Headers HTTP
echo "[+] Analizando headers HTTP..."
curl -I "$target" > "$output_dir/headers.txt" 2>/dev/null

# Código fuente
echo "[+] Descargando código fuente..."
curl -s "$target" > "$output_dir/source.html"

# Búsqueda de patrones
echo "[+] Buscando patrones tecnológicos..."
grep -i -E "(generator|powered|built|framework|version)" "$output_dir/source.html" > "$output_dir/patterns.txt"

# Archivos característicos
echo "[+] Probando archivos característicos..."
endpoints=(
    "wp-admin/"
    "administrator/"
    "user/login"
    "admin/"
    "phpmyadmin/"
    "robots.txt"
    "sitemap.xml"
    ".well-known/security.txt"
)

for endpoint in "${endpoints[@]}"; do
    status=$(curl -o /dev/null -s -w "%{http_code}" "$target/$endpoint")
    echo "$endpoint: $status" >> "$output_dir/endpoints.txt"
done

echo "[+] Análisis completado. Resultados en: $output_dir"

Script Python para Múltiples Herramientas

#!/usr/bin/env python3
import requests
import json
import subprocess
from urllib.parse import urlparse

def analyze_website(url):
    """Análisis completo de tecnologías web"""
    results = {
        'url': url,
        'headers': {},
        'technologies': [],
        'fingerprinting': {}
    }

    try:
        # Análisis de headers
        response = requests.get(url, timeout=10)
        results['headers'] = dict(response.headers)
        results['status_code'] = response.status_code

        # Identificación básica
        if 'Server' in response.headers:
            results['technologies'].append(f"Server: {response.headers['Server']}")
        if 'X-Powered-By' in response.headers:
            results['technologies'].append(f"Powered-By: {response.headers['X-Powered-By']}")

        # Análisis de contenido
        content = response.text.lower()
        frameworks = {
            'wordpress': ['wp-content', 'wp-includes', 'wordpress'],
            'drupal': ['drupal', 'sites/default'],
            'joomla': ['joomla', 'administrator', 'com_content'],
            'laravel': ['laravel', 'laravel_session'],
            'django': ['django', 'csrfmiddlewaretoken'],
            'react': ['react', 'reactdom'],
            'angular': ['angular', 'ng-app'],
            'vue': ['vue.js', 'vue']
        }

        for framework, patterns in frameworks.items():
            if any(pattern in content for pattern in patterns):
                results['technologies'].append(f"Framework: {framework}")

        # WhatWeb (si está disponible)
        try:
            whatweb_result = subprocess.run(
                ['whatweb', '--output-json=-', url],
                capture_output=True, text=True, timeout=30
            )
            if whatweb_result.returncode == 0:
                results['whatweb'] = json.loads(whatweb_result.stdout)
        except:
            pass

    except Exception as e:
        results['error'] = str(e)

    return results

# Uso del script
if __name__ == "__main__":
    import sys
    if len(sys.argv) != 2:
        print("Uso: python3 tech_analyzer.py <URL>")
        sys.exit(1)

    url = sys.argv[1]
    results = analyze_website(url)
    print(json.dumps(results, indent=2))

🎯 Casos de Uso Específicos

Análisis de E-commerce

# Patrones específicos de e-commerce
curl -s "$target" | grep -i -E "(shopify|magento|woocommerce|prestashop|opencart)"

# Headers específicos
curl -I "$target" | grep -i -E "(X-Shopify|X-Magento|X-Woo)"

# Archivos característicos
curl -I "$target/shop/"
curl -I "$target/catalog/"
curl -I "$target/cart/"

Análisis de CMS

# WordPress
curl -I "$target/wp-json/wp/v2/"
curl -s "$target" | grep "wp-content\|wp-includes"

# Drupal
curl -I "$target/user/login"
curl -s "$target" | grep "Drupal\|sites/default"

# Joomla
curl -I "$target/administrator/"
curl -s "$target" | grep "Joomla\|com_content"

Análisis de APIs

# API endpoints
curl -I "$target/api/"
curl -I "$target/v1/"
curl -I "$target/graphql"

# Headers de API
curl -I "$target" | grep -i -E "(API|GraphQL|REST|SOAP)"

🔒 Técnicas de Evasión

User-Agent Rotation

# Lista de User-Agents
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36"
    "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"
)

for ua in "${user_agents[@]}"; do
    whatweb --user-agent "$ua" "$target"
    sleep 2
done

Proxy y Rate Limiting

# A través de proxy
whatweb --proxy 127.0.0.1:8080 "$target"

# Con delays
whatweb --wait 3 "$target"

# Conexiones limitadas
whatweb --max-threads 1 "$target"

📊 Interpretación de Resultados

Información Crítica

1. Versiones específicas: Buscar CVEs conocidos
2. Frameworks desactualizados: Vulnerabilidades comunes
3. Servicios expuestos: Superficies de ataque adicionales
4. Configuraciones por defecto: Credenciales o configuraciones inseguras

Análisis de Riesgo

# Ejemplo de análisis automático
#!/bin/bash
analyze_risk() {
    local tech_info="$1"

    # Tecnologías de alto riesgo
    if echo "$tech_info" | grep -qi "php.*5\|apache.*2\.4\.[0-9]$\|wordpress.*[1-4]"; then
        echo "HIGH RISK: Versión desactualizada detectada"
    fi

    # Servicios expuestos
    if echo "$tech_info" | grep -qi "phpmyadmin\|adminer\|cpanel"; then
        echo "MEDIUM RISK: Panel administrativo expuesto"
    fi
}

🧪 Laboratorio Práctico

Ejercicio 1: Análisis Completo

# Target de prueba
target="https://testphp.vulnweb.com"

# 1. WhatWeb básico
whatweb "$target"

# 2. Análisis de headers
curl -I "$target"

# 3. Inspección de código fuente
curl -s "$target" | head -50

# 4. Búsqueda de patrones
curl -s "$target" | grep -i -E "(generator|powered|version)"

Ejercicio 2: Comparación de Herramientas

# Comparar resultados entre herramientas
echo "=== WhatWeb ===" > comparison.txt
whatweb "$target" >> comparison.txt

echo -e "\n=== Httpx ===" >> comparison.txt
echo "$target" | httpx -tech-detect >> comparison.txt

echo -e "\n=== Manual ===" >> comparison.txt
curl -I "$target" >> comparison.txt

🛡️ Consideraciones de Seguridad

Aspectos Legales

• Obtener autorización antes del testing
• Respetar robots.txt y términos de uso
• No realizar testing agresivo en sistemas de producción
• Documentar todas las actividades

Mejores Prácticas

• Usar múltiples herramientas para validación cruzada
• Mantener logs detallados de la actividad
• Implementar rate limiting para evitar detección
• Usar proxies y VPN cuando sea apropiado

Detección y Evasión

# Técnicas de sigilo
whatweb --max-threads 1 --wait 5 "$target"
curl -H "X-Forwarded-For: 192.168.1.1" "$target"

🔗 Recursos Adicionales

Herramientas Complementarias

• Nuclei: Templates para detección de tecnologías
• Nmap: Scripts NSE para web technologies
• Burp Suite: Extensiones para fingerprinting
• OWASP ZAP: Passive scanning para tecnologías

Bases de Datos

• Wappalyzer Technologies
• BuiltWith Technology Lookup
• CVE Database
• Exploit Database

Scripts y Automatización

• WhatWeb Plugins
• Nuclei Templates
• Custom Fingerprinting Scripts

---

La identificación de tecnologías web es una habilidad fundamental en el arsenal de cualquier profesional de seguridad. La combinación de múltiples herramientas y técnicas proporciona una visión completa del stack tecnológico objetivo, permitiendo un approach más dirigido y efectivo en las fases posteriores del testing de seguridad.