Máquina de dificultad media. En ella utilizaremos técnicas de enumeración, desbordamiento de búfer (buffer overflow) y reverse shell.
Nuestra máquina objetivo tiene la dirección IP 192.168.50.120
 |
| sudo netdiscover -r 192.168.50.0/24 |
Con la herramienta Nmap enumeraré los puertos y servicios que se están ejecutando en la máquina objetivo.
 |
| sudo nmap -n -Pn -p- --min-rate 5000 -sS 192.168.50.120 |
Hay dos puertos abiertos 9999 y 10000. Ahora enumeraré los servicios que se están ejecutando.
 |
| sudo nmap -p 9999,10000 --min-rate 5000 -sV 192.168.50.120 |
En el puerto 10000 se está ejecutando SimpleHTTPServer, que es un módulo de Python que permite crear un servidor web sencillo.
Ahora analizaré lo que se está ejecutando en los servicios web desplegados.
 |
| http://192.168.50.120:10000/ |
 |
| Código Fuente: http://192.168.50.120:10000 |
El servicio web ejecutándose en el puerto 10000 solo despliega una imagen y no muestra ninguna información de interés.
 |
| http://192.168.50.120:9999/ |
 |
| Código Fuente: http://192.168.50.120:9999/ |
Como se muestra en las imágenes anteriores, se despliega un prompt en el cual se solicita una clave de acceso. Dado que no contamos con credenciales para probar, lo que haré será enumerar los directorios que se están almacenando en ambos servicios web.
Para enumerar los archivos almacenados en los servidores web, utilizaré la herramienta Gobuster.
 |
| Enumeración de directorios: servicio web 192.168.50.120:9999 |
Como se muestra en la imagen anterior, la conexión se rompe al ejecutar Gobuster. En cambio, al utilizar Gobuster en el servicio web 192.168.50.120:10000, se logra enumerar el directorio
/bin. |
| Enumeración de directorios: servicio web 192.168.50.120:10000 |
Es probable que este sea el archivo ejecutado por el servicio web en la dirección IP 192.168.50.120:9999. A continuación, lo descargaré para realizar un análisis detallado.
Como se muestra en las imágenes anteriores, brainpan.exe es un archivo ejecutable para la plataforma Windows de 32 bits.
Para analizarlo, desplegaré una máquina virtual con Windows 7 y utilizaré la herramienta Immunity Debugger.
 |
| Máquina Virtual Windowns 7 |
Como parte del uso de Immunity Debugger, es necesario descargar la utilidad mona y agregarla al directorio PyCommands de la herramienta.
Ahora, en nuestra máquina con Windows 7, ejecutaremos brainpan.exe. Como se muestra en la siguiente imagen, este ejecutable lanza un servicio por el puerto 9999.
 |
| Ejecución brainpan.exe Windows 7 |
Aquí se muestra la misma pantalla que se despliega en el servicio web 192.168.50.120:9999.
Como no tenemos credenciales válidas para ingresar, lo que podemos probar es si este ejecutable es vulnerable a un buffer overflow. Primero debemos configurar Immunity Debugger.
Ejecutamos Brainpan.exe y luego abrimos Immunity Debugger, como se muestra en la siguiente imagen.
Ahora debemos adjuntar el proceso de brainpan.exe a Immunity Debugger. Para ello, hacemos clic en File > Attach.
Una vez adjuntado el archivo brainpan.exe, se muestra la ejecución en modo pausado.
Solo queda hacer clic en el botón play para ejecutar el archivo brainpan.exe en modo Debugger.
Ahora realizaré fuzzing enviando bytes de datos para observar en qué intervalo el programa deja de responder (se bloquea). Para esto, utilizaré un scripts en Python 3.
El primer script que vamos a ejecutar es brainpan.py. Este script enviará datos en bloques de 100 bytes. Cuando el script Python ya no envíe más bytes, indicará que el programa brainpan.exe se bloquea.
Ejecución del script brainpan.py.
El valor hexadecimal 41414141 se corresponde al valor AAAA, como se muestra en la siguiente imagen.
Al realizar fuzzing, sabemos que el programa se bloquea entre los bytes 500 y 600. En este punto, me detendré para explicar un concepto fundamental antes de continuar con la configuración de la máquina.
Los ordenadores almacenan todos los programas en memoria mientras se ejecutan. Esta memoria se divide en diferentes segmentos.
 |
| Funcionamiento de la memoria de un ordenador. |
Ahora me enfocaré en cómo funcionan los programas en memoria, en particular en cómo utilizan la pila. Primero, debemos entender el concepto de cambio de contexto.
El cambio de contexto hace referencia al proceso en el que un programa pasa de una función a otra.
Nota: No poseo experiencia avanzada en ingeniería inversa ni en lenguaje ensamblador. Sin embargo, he intentado explicar de forma clara el funcionamiento básico de la memoria, conocimiento fundamental para comprender la explotación de la vulnerabilidad buffer overflow.
Continuando con nuestra máquina, generaremos un payload de aproximadamente 1000 bytes para determinar con precisión el punto en que brainpan.exe falla. Para ello, emplearé el script pattern_create.rb, perteneciente al Metasploit Framework.
Ahora, con Brainpan.exe e Immunity Debugger en ejecución en nuestra máquina Windows, enviaremos nuestro payload, creado con el script pattern_create.rb, de la siguiente manera.
El valor del EIP es 35724134. Este valor lo utilizaremos para identificar el offset preciso donde el programa se bloquea. Para obtener el offset, nos apoyaremos en otro script, pattern_offset, que es un módulo de Metasploit Framework, de la siguiente manera.
Ahora conocemos el byte exacto, 524, donde el programa se bloquea. Lo que haremos será enviar un payload de 524 bytes más 4 bytes adicionales. Esos 4 bytes los utilizaremos como marcador; es decir, cuando enviemos el payload, el valor del registro EIP debería coincidir con esos 4 bytes que añadimos.
Ejemplo:
payload = "A" * 524 + "BBBB", donde esas 4 “B” deberían ser el valor del EIP después de enviar el payload.
Para enviar el payload, utilizaré Python para crear y enviarlo, como se muestra en la siguiente imagen.
En Immunity Debugger el valor del registro EIP debería ser 42424242.
Con esto, ya tenemos el control del valor del EIP, así como del byte donde el programa se bloquea: el 524. Ahora debemos identificar los badchars (caracteres malos) antes de crear nuestro payload para inyectar una reverse shell y obtener acceso a la máquina objetivo desde nuestra máquina atacante.
Nota: Los badchars son caracteres que no deben aparecer en el payload (código de explotación) porque pueden provocar errores, truncamientos o modificaciones en la ejecución del exploit.
Para identificar los badchars, nos apoyaremos en el siguiente repositorio de Badchars en GitHub.
Ahora en nuestra máquina Windows crearemos un directorio de trabajo en Immunity Debugger.
 |
| Comando para crear un directorio de trabajo con mona script: !mona config -set workingfolder C:\Users\soporte\Desktop\brainpan\%p |
Ahora me apoyaré en el siguiente script Python para enviar nuestro badchars al brainpan.exe.
Ahora, en Immunity Debugger, utilizaremos el comando !mona bytearray, el cual genera una lista de todos los bytes posibles (desde \x01 hasta \xff) con el fin de detectar badchars.
 |
| Comando para crear una bytearray: !mona bytearray -b "\x00" |
Para volver a la pantalla de ejecución en Immunity Debugger hacemos click en la barra de menú letra c.
Ahora debemos enviar nuestros badchars a brainpan.exe mientras se ejecuta dentro de Immunity Debugger.
Ahora solo queda comparar los badchars enviados con los posibles badchars que pudieran generar problemas al crear nuestro payload malicioso. Para comparar los badchars, utilizaremos el comando: !mona compare -f C:\\Users\\soporte\\Desktop\\brainpan\\brainpan\\bytearray.bin -a ESP
 |
| Comando mona compare: !mona compare -f C:\\Users\\soporte\\Desktop\\brainpan\\brainpan\\bytearray.bin -a ESP |
Como se muestra en la imagen anterior, no se detectó ningún badchar. Ahora solo nos queda averiguar el puntero ESP al que el programa se redirigirá para ejecutar nuestro payload malicioso. Para obtener el puntero ESP, utilizaré el módulo nasm_shell.rb de Metasploit Framework.
Como se muestra en la imagen, el valor del puntero ESP en hexadecimal es FFE4 (\xff\xe4). Ahora, con brainpan.exe y Immunity Debugger en ejecución, utilizaremos el siguiente comando de Mona: !mona find -s "\xff\xe4" -m brainpan.exe
 |
| Comando mona find: !mona find -s "\xff\xe4" -m brainpan.exe |
El opcode FFE4, correspondiente a la instrucción JMP ESP, se encuentra en la dirección hexadecimal 0x311712f3. Este valor es crucial, ya que nos permite redirigir el flujo de ejecución del programa hacia nuestro payload malicioso.
Ahora solo queda crear el payload, que será una reverse shell. Para ello, nos apoyaremos en la herramienta msfvenom, que es un módulo del Metasploit Framework.
Una vez generado el payload con msfvenom, usaré un script en Python al que copiaré únicamente los valores hexadecimales (shellcode) producidos por la herramienta.
Como se muestra en la imagen, solo queda configurar nuestro payload. En la variable retn debemos declarar el valor "\xf3\x12\x17\x31", el cual debe estar en formato little endian, es decir, los bytes en orden inverso. En la variable payload copiamos los valores hexadecimales generados por msfvenom. Por último, en la variable padding declaramos el valor \x90, que representa un NOP (“No Operation”). Esto se utiliza para darle un tiempo al payload para que se cargue en memoria donde el payload pueda cargarse y ejecutarse correctamente.
Si todo está bien configurado, al enviar nuestro payload malicioso deberíamos recibir una conexión desde la máquina objetivo hacia nuestra máquina atacante.
Como se muestra en la imagen anterior, pudimos explotar la vulnerabilidad de buffer overflow. Ahora debemos ejecutar el exploit contra la máquina objetivo real. Recordemos que hasta este punto hemos trabajado sobre un sistema Windows para analizar y preparar el entorno de explotación.
Ahora probaremos nuestro exploit contra la máquina objetivo. Antes de hacerlo, debemos cambiar la variable IP en nuestro script en Python para que esta apunte correctamente a la máquina objetivo.
Si ejecutamos nuestro script deberíamos obtener una conexión desde la máquina objetivo a nuestra máquina atacante.
Obtuvimos una conexión desde la máquina objetiva real a nuestra máquina atacante. La unidad Z:\ es utilizada por WineHQ, WineHQ es una capa de compatibilidad que permite ejecutar aplicaciones y juegos desarrollados para Microsoft Windows en sistemas operativos tipo Unix, como Linux. Por lo tanto, solo logramos obtener acceso al subsistema Windows que se está ejecutando en la máquina objetivo.
Ahora crearé un payload tipo reverse shell para Linux y lo enviaré nuevamente. En teoría, deberíamos obtener una conexión desde la máquina objetivo hacia nuestra máquina atacante, pero esta vez desde el sistema Linux, no desde el subsistema Windows que corre bajo WineHQ en la máquina Linux.
Nuevamente me apoyaré de un script de Python para enviar nuestro payload malicioso.
Solo debemos modificar la variable payload con los valores hexadecimales generados por msfvenom.
Como se muestra en la imagen anterior obtuvimos una conexión desde la maquina objetivo a nuestra máquina atacante.
Ahora configuraremos una tty operativa, ejecutando los siguientes comando:
- script /dev/null -c bash
- ctrl + z
- stty rwa - echo; fg
- reset xterm
- export TERM=xterm
- stty rows 41 columns 167
Somo el usuario puck con el comando sudo - l nos mostrará los privilegios de sudo que tiene el usuario actual.
El usuario puck puede ejecutar anansi_util como sudo. por lo tanto lo ejecutaremos de la siguiente manera sudo /home/anansi/bin/anansi_util.
Al parecer, se trata de un script que ejecuta varios comandos: muestra las interfaces de red, lista los procesos y despliega el manual de un comando en Linux. Este último nos interesa, ya que Linux presenta el manual a través del paginador less, el cual permite ejecutar comandos del sistema operativo.
Como se muestra en las dos imágenes anteriores, al ejecutar el script anansi_util manual ls, se despliega el manual del comando ls de Linux mediante el paginador less.
Ahora ejecutaremos el siguiente comando: !/bin/sh. Dado que estamos ejecutando el script anansi_util con privilegios de sudo, deberíamos obtener una shell con privilegios de root.
Al ejecutar el comando !/bin/sh se ejecuta una shell con privilegio de root.
Ahora solo queda encontrar la flag de la máquina.
Nuestra flag esta ubicada en el directorio /root en un archivo llamado b.txt.
Happy Hack!!!
Comentarios
Publicar un comentario