Hacking Ético desde 0 - Parte 5: Análisis de Vulnerabilidades y Exploits

🎯 Introducción

¡Bienvenidos a la quinta entrega de nuestra serie “Hacking Ético desde 0”! Después de dominar el escaneo de red y enumeración, es momento de dar el siguiente paso crítico: identificar y analizar vulnerabilidades.

En este tutorial aprenderemos a usar scanners de vulnerabilidades profesionales, interpretar resultados, buscar exploits y preparar vectores de ataque de manera ética y metodológica.

🔍 ¿Qué son las Vulnerabilidades?

Una vulnerabilidad es una debilidad en un sistema, aplicación o configuración que puede ser explotada por un atacante para comprometer la seguridad.

Tipos de Vulnerabilidades:

• CVE (Common Vulnerabilities and Exposures): Vulnerabilidades conocidas públicamente
• Zero-day: Vulnerabilidades no conocidas públicamente
• Configuración: Errores en configuración de servicios
• Lógica de aplicación: Fallas en el diseño del software
• Humanas: Errores del factor humano

Sistema de Puntuación CVSS

Severidad CVSS:
- 0.0: None
- 0.1-3.9: Low
- 4.0-6.9: Medium  
- 7.0-8.9: High
- 9.0-10.0: Critical

🛠️ Herramientas de Análisis de Vulnerabilidades

1. OpenVAS - Scanner Gratuito

Instalación en Kali Linux:

# Actualizar sistema
sudo apt update && sudo apt upgrade -y

# Instalar OpenVAS
sudo apt install openvas -y

# Configuración inicial
sudo gvm-setup

# Verificar instalación
sudo gvm-check-setup

# Crear usuario admin
sudo runuser -u _gvm -- gvmd --create-user=admin --password=admin123

# Iniciar servicios
sudo gvm-start

# Acceder via web: https://127.0.0.1:9392

Configuración Básica:

# Actualizar feeds de vulnerabilidades
sudo greenbone-feed-sync --type GVMD_DATA
sudo greenbone-feed-sync --type SCAP
sudo greenbone-feed-sync --type CERT

# Verificar status
sudo gvm-check-setup

2. Nessus - Scanner Profesional

Instalación:

# Descargar desde Tenable (versión Home es gratuita para 16 IPs)
wget https://www.tenable.com/downloads/api/v1/public/pages/nessus/downloads/[ID]/download?i_agree_to_tenable_license_agreement=true

# Instalar .deb
sudo dpkg -i Nessus-[version]-debian6_amd64.deb

# Iniciar servicio
sudo systemctl start nessusd
sudo systemctl enable nessusd

# Acceder: https://localhost:8834

3. Nuclei - Scanner Moderno y Rápido

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

# O usando package manager
sudo apt install nuclei

# Actualizar templates
nuclei -update-templates

# Escaneo básico
nuclei -u https://target.com

# Escaneo con severidad específica
nuclei -u https://target.com -severity critical,high,medium

# Escaneo masivo desde archivo
nuclei -l targets.txt -o results.txt

4. Nikto - Scanner Web

# Instalación (viene en Kali)
sudo apt install nikto

# Escaneo básico
nikto -h http://target.com

# Escaneo completo con todos los plugins
nikto -h http://target.com -Plugins @@ALL

# Escaneo con authentication
nikto -h http://target.com -id username:password

# Output a archivo
nikto -h http://target.com -o report.html -Format html

🔬 Metodología de Análisis de Vulnerabilidades

Fase 1: Preparación del Target

#!/bin/bash
# prep_target.sh - Preparación de target para scanning

TARGET=$1
SCAN_DIR="vuln_scan_$(date +%Y%m%d_%H%M%S)"

if [ -z "$TARGET" ]; then
    echo "Uso: $0 <target>"
    exit 1
fi

mkdir -p $SCAN_DIR
cd $SCAN_DIR

echo "[+] Preparando escaneo de vulnerabilidades para: $TARGET"

# Crear archivo de target
echo $TARGET > targets.txt

# Port scan rápido para identificar servicios
echo "[+] Escaneando puertos abiertos..."
nmap -sS -T4 --top-ports 1000 $TARGET -oN port_scan.txt

# Service detection
echo "[+] Detectando servicios..."
nmap -sV -sC $TARGET -oN service_scan.txt

echo "[+] Preparación completa. Directorio: $SCAN_DIR"

Fase 2: Escaneo de Vulnerabilidades

Con Nuclei:

# Templates por categoría
nuclei -u https://target.com -tags cve
nuclei -u https://target.com -tags exposure
nuclei -u https://target.com -tags misconfiguration
nuclei -u https://target.com -tags rce

# Por tecnología específica
nuclei -u https://target.com -tags apache
nuclei -u https://target.com -tags nginx
nuclei -u https://target.com -tags wordpress

# Workflow completo
nuclei -u https://target.com -w workflows/wordpress-workflow.yaml

Con Scripts Nmap:

# Scripts de vulnerabilidades
nmap --script vuln target.com

# Scripts específicos por servicio
nmap --script http-vuln-* target.com -p 80,443
nmap --script smb-vuln-* target.com -p 445
nmap --script ssh-vuln-* target.com -p 22

# CVE específicos
nmap --script http-vuln-cve2017-5638 target.com
nmap --script smb-vuln-ms17-010 target.com

Fase 3: Verificación Manual

# Verificar SSL/TLS
sslscan target.com
testssl.sh target.com

# Verificar headers de seguridad
curl -I https://target.com
python3 -c "
import requests
import json
r = requests.get('https://target.com')
for header, value in r.headers.items():
    print(f'{header}: {value}')
"

# Verificar tecnologías web
whatweb target.com
wafw00f target.com

🎯 Búsqueda y Análisis de Exploits

1. Searchsploit - Base de Datos Local

# Actualizar base de datos
sudo searchsploit -u

# Buscar por software/versión
searchsploit apache 2.4.41
searchsploit openssh 8.2
searchsploit wordpress 5.7

# Buscar por CVE
searchsploit CVE-2021-44228

# Examinar exploit
searchsploit -x exploits/linux/remote/12345.py

# Copiar exploit al directorio actual
searchsploit -m exploits/linux/remote/12345.py

2. Bases de Datos Online

Exploit-DB:

# Script para buscar en exploit-db
#!/bin/bash
# exploit_search.sh

SEARCH_TERM=$1

if [ -z "$SEARCH_TERM" ]; then
    echo "Uso: $0 <termino_busqueda>"
    exit 1
fi

echo "[+] Buscando exploits para: $SEARCH_TERM"

# Searchsploit local
echo "=== SEARCHSPLOIT LOCAL ==="
searchsploit "$SEARCH_TERM"

# CVE Details (requiere curl/wget)
echo "=== BUSCANDO CVE ==="
curl -s "https://cve.mitre.org/cgi-bin/cvekey.cgi?keyword=$SEARCH_TERM" | grep -i CVE

Metasploit Framework:

# Buscar exploits en Metasploit
msfconsole -q -x "search $TARGET_SERVICE; exit"

# Buscar por CVE
msfconsole -q -x "search cve:2021-44228; exit"

# Buscar por platform
msfconsole -q -x "search platform:linux; exit"

3. GitHub y Repositorios

# Script para buscar exploits en GitHub
#!/bin/bash
# github_exploit_search.sh

VULNERABILITY=$1
API_URL="https://api.github.com/search/repositories"

curl -s "$API_URL?q=$VULNERABILITY+exploit&sort=stars&order=desc" | \
jq -r '.items[] | "\(.name): \(.html_url)"' | head -10

🛡️ Análisis de Riesgo y Priorización

Matriz de Riesgo

#!/usr/bin/env python3
# risk_analyzer.py - Analizador de riesgo de vulnerabilidades

import json
import sys

def calculate_risk_score(cvss_score, exploitability, exposure):
    """
    Calcula puntuación de riesgo basada en múltiples factores
    """
    # CVSS base score (0-10)
    cvss_weight = cvss_score * 0.4
    
    # Exploitability (1-5)
    # 1: Teórico, 2: Proof of concept, 3: Funcional, 4: High, 5: Weaponized
    exploit_weight = exploitability * 0.3
    
    # Exposure (1-5)  
    # 1: Interno, 2: Autenticado, 3: Red local, 4: DMZ, 5: Internet
    exposure_weight = exposure * 0.3
    
    total_score = cvss_weight + exploit_weight + exposure_weight
    return min(total_score, 10.0)

def categorize_risk(score):
    """Categoriza el riesgo según la puntuación"""
    if score >= 9.0:
        return "CRÍTICO"
    elif score >= 7.0:
        return "ALTO"
    elif score >= 4.0:
        return "MEDIO"
    elif score >= 1.0:
        return "BAJO"
    else:
        return "INFORMATIVO"

# Ejemplo de uso
vulnerabilities = [
    {"name": "CVE-2021-44228", "cvss": 10.0, "exploitability": 5, "exposure": 5},
    {"name": "CVE-2021-34527", "cvss": 8.8, "exploitability": 4, "exposure": 3},
    {"name": "Weak SSL Cipher", "cvss": 5.3, "exploitability": 2, "exposure": 4}
]

print("=== ANÁLISIS DE RIESGO ===")
for vuln in vulnerabilities:
    risk_score = calculate_risk_score(vuln['cvss'], vuln['exploitability'], vuln['exposure'])
    category = categorize_risk(risk_score)
    print(f"{vuln['name']}: {risk_score:.1f} - {category}")

Template de Reporte de Vulnerabilidades

# Reporte de Vulnerabilidad

## Información General
- **CVE**: CVE-YYYY-XXXXX
- **Severidad CVSS**: X.X (ALTA/MEDIA/BAJA)
- **Categoría**: [RCE/SQLi/XSS/etc.]
- **Fecha descubrimiento**: DD/MM/YYYY

## Descripción Técnica
[Descripción detallada de la vulnerabilidad]

## Sistemas Afectados
- Sistema 1: IP/Hostname - Puerto - Servicio
- Sistema 2: IP/Hostname - Puerto - Servicio

## Evidencia
- Screenshots
- Comandos ejecutados
- Respuestas del sistema

## Impacto
- **Confidencialidad**: [ALTO/MEDIO/BAJO]
- **Integridad**: [ALTO/MEDIO/BAJO]  
- **Disponibilidad**: [ALTO/MEDIO/BAJO]

## Explotabilidad
- **Complejidad de ataque**: [BAJA/MEDIA/ALTA]
- **Vectores de ataque**: [RED/LOCAL/FÍSICO]
- **Interacción del usuario**: [REQUERIDA/NO REQUERIDA]

## Recomendaciones
1. Parche/Actualización disponible
2. Configuraciones de mitigación
3. Controles compensatorios

## Referencias
- [CVE Details](https://cve.mitre.org/)
- [Vendor Advisory](link)
- [Exploit PoC](link)

🧪 Laboratorio Práctico

Ejercicio 1: Escaneo con OpenVAS

# 1. Configurar target en OpenVAS
# 2. Crear nueva tarea de escaneo
# 3. Seleccionar configuración "Full and fast"
# 4. Ejecutar escaneo
# 5. Analizar resultados por severidad

Ejercicio 2: Verificación Manual con Nmap

# Ejemplo: Vulnerable a EternalBlue (MS17-010)
nmap --script smb-vuln-ms17-010 192.168.1.100

# Si es vulnerable:
# Nmap scan report for 192.168.1.100
# PORT    STATE SERVICE
# 445/tcp open  microsoft-ds
# |_smb-vuln-ms17-010: VULNERABLE

Ejercicio 3: Búsqueda de Exploits

# 1. Identificar versión de Apache
nmap -sV target.com -p 80

# 2. Buscar exploits conocidos
searchsploit apache 2.4.41

# 3. Verificar CVE asociados

🔧 Scripts de Automatización

Scanner Completo de Vulnerabilidades

#!/bin/bash
# vuln_scanner.sh - Scanner automatizado de vulnerabilidades

TARGET=$1
OUTPUT_DIR="vuln_scan_$(date +%Y%m%d_%H%M%S)"

if [ -z "$TARGET" ]; then
    echo "Uso: $0 <target>"
    exit 1
fi

mkdir -p $OUTPUT_DIR
cd $OUTPUT_DIR

echo "[+] Iniciando escaneo de vulnerabilidades: $TARGET"

# Escaneo con Nuclei
echo "[+] Ejecutando Nuclei..."
nuclei -u $TARGET -severity critical,high,medium -o nuclei_results.txt

# Escaneo con Nmap NSE
echo "[+] Ejecutando Nmap scripts..."
nmap --script vuln $TARGET -oN nmap_vuln.txt

# Web vulnerability scan
if [[ $TARGET =~ ^https?:// ]]; then
    echo "[+] Ejecutando Nikto..."
    nikto -h $TARGET -o nikto_results.txt
fi

# SSL/TLS analysis
if [[ $TARGET =~ ^https ]]; then
    echo "[+] Analizando SSL/TLS..."
    sslscan ${TARGET#https://} > sslscan_results.txt
fi

# Generate summary
echo "[+] Generando resumen..."
cat > summary.md << EOF
# Resumen de Vulnerabilidades - $TARGET

## Fecha: $(date)

### Herramientas utilizadas:
- Nuclei
- Nmap NSE scripts
- Nikto (si aplicable)
- SSLScan (si aplicable)

### Archivos generados:
- nuclei_results.txt
- nmap_vuln.txt
- nikto_results.txt (si aplicable)
- sslscan_results.txt (si aplicable)

### Próximos pasos:
1. Revisar vulnerabilidades críticas y altas
2. Verificar manualmente los falsos positivos
3. Buscar exploits disponibles
4. Priorizar por riesgo e impacto
EOF

echo "[+] Escaneo completado. Resultados en: $OUTPUT_DIR"

📊 Interpretación de Resultados

Falsos Positivos Comunes

# Verificar manualmente vulnerabilidades reportadas
# Ejemplo: XSS reflected

curl -v "http://target.com/search?q=<script>alert(1)</script>"

# Si no se ejecuta el script, es falso positivo
# Si se ejecuta, confirmar vulnerabilidad

Correlación de Datos

#!/usr/bin/env python3
# correlate_vulns.py - Correlacionar vulnerabilidades entre herramientas

import re
import json

def parse_nuclei_results(file_path):
    """Parse Nuclei results"""
    vulnerabilities = []
    with open(file_path, 'r') as f:
        for line in f:
            if '[' in line and ']' in line:
                # Extract info from Nuclei output
                match = re.search(r'\[([^\]]+)\] \[([^\]]+)\] ([^\[]+)', line)
                if match:
                    vulnerabilities.append({
                        'severity': match.group(1),
                        'type': match.group(2),
                        'description': match.group(3).strip()
                    })
    return vulnerabilities

def generate_report(nuclei_vulns, nmap_vulns):
    """Generate consolidated report"""
    print("=== REPORTE CONSOLIDADO DE VULNERABILIDADES ===\n")
    
    print("VULNERABILIDADES CRÍTICAS:")
    for vuln in nuclei_vulns:
        if vuln['severity'].lower() == 'critical':
            print(f"- {vuln['description']}")
    
    print("\nVULNERABILIDADES ALTAS:")
    for vuln in nuclei_vulns:
        if vuln['severity'].lower() == 'high':
            print(f"- {vuln['description']}")

# Uso del script sería llamar las funciones con los archivos de resultados

🎯 Próximos Pasos

En el próximo tutorial de la serie abordaremos:

1. Explotación de Servicios Comunes
2. Uso de Metasploit Framework
3. Desarrollo de exploits personalizados
4. Técnicas de escalada de privilegios
5. Post-explotación básica

📚 Recursos Adicionales

• NIST National Vulnerability Database
• MITRE CVE Database
• Exploit Database
• Nuclei Templates
• OWASP Testing Guide

🎓 Conclusión

El análisis de vulnerabilidades es un arte que combina herramientas automatizadas con verificación manual y criterio profesional. La clave está en:

1. Usar múltiples herramientas para cobertura completa
2. Verificar manualmente los resultados
3. Priorizar por riesgo real no solo por CVSS
4. Documentar meticulosamente todos los hallazgos
5. Mantenerse actualizado con nuevas vulnerabilidades

Un pentester experimentado no solo encuentra vulnerabilidades, sino que entiende su impacto real en el contexto del negocio y puede comunicar efectivamente los riesgos a diferentes audiencias.

En la próxima entrega, ¡pondremos en práctica todo lo aprendido y comenzaremos la fase de explotación!

---

Andrés Nuñez - t4ifi