Stack DockerLabs (Intermediate)
Instalación
Cuando obtenemos el .zip nos lo pasamos al entorno en el que vamos a empezar a hackear la maquina y haremos lo siguiente.
unzip stack.zipNos lo descomprimira y despues montamos la maquina de la siguiente forma.
bash auto_deploy.sh stack.tarInfo:
## .
## ## ## ==
## ## ## ## ===
/""""""""""""""""\___/ ===
~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ / ===- ~~~
\______ o __/
\ \ __/
\____\______/
___ ____ ____ _ _ ____ ____ _ ____ ___ ____
| \ | | | |_/ |___ |__/ | |__| |__] [__
|__/ |__| |___ | \_ |___ | \ |___ | | |__] ___]
Estamos desplegando la máquina vulnerable, espere un momento.
Máquina desplegada, su dirección IP es --> 172.17.0.2
Presiona Ctrl+C cuando termines con la máquina para eliminarlaPor lo que cuando terminemos de hackearla, le damos a Ctrl+C y nos eliminara la maquina para que no se queden archivos basura.
Escaneo de puertos
Info:
Si entramos en la pagina web que tiene subida en el puerto 80 no veremos mucho a simple vista, pero si inspeccionamos el codigo veremos un comentario en el que pone lo siguiente:
Por lo que esto nos servira para mas adelante...
Vamos hacer un poco de fuzzing a ver que encontramos.
Gobuster
Info:
Vemos que hay varias cosas interesantes, si entramos a note.txt veremos lo siguiente:
Por lo que vemos nos comenta que habia una vulnerabilidad de LFI, por lo que veremos si realmente ya no esta, fuzzeando probando con diferentes parametros intentando leer el passwd de la siguiente forma.
Lo haremos en el apartado de file.php ya que es el unico que podria tener esta vulnerabilidad ya que tiene un PHP.
Escalate user bob
FUZZ
Info:
Despues de estar un rato probando varias formas de realizar el LFI vemos que si hacemos ese Bypass podremos ver que funciono con el parametro file, por lo que haremos lo siguiente:
Info:
Veremos que obtuvimos el passwd de la maquina, pero recordemos que anteriormente la contraseña de bob estaba en la siguiente ruta /usr/share/bob/password.txt asi que vamos a intentar leerlo:
Info:
Podremos ver la contraseña de bob, por lo que nos conectaremos por ssh:
Metemos como contraseña llv6ox3lx300 y veremos que estamos dentro.
Escalate Privileges
Si vemos los permisos SUID que tenemos...
Info:
Podremos ver uno interesante en el /opt:
Vemos que si ejecutamos el binario:
Info:
Veremos que aparentemente no hace nada en especial, pero vamos a ver si es vulnerable a un Buffer Overflow:
Info:
Vemos que nos pone segmentation fault por lo que si es vulnerable...
Vamos a pasarnos el archivo a nuestro host de la siguiente forma.
Host
Y con esto ya obtendremos el archivo.
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...
Pero si diera error por las versiones, podremos instalar esta otra herramienta que es mas poderosa:
Y si iniciamos gdb veremos lo siguiente:
Info:
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:
Info:
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:
Vemos esta parte de aqui:
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:
Info:
Esto indica que el offset es de 88 bytes.
NOTA:
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.
Vamos a crear un pequeño script que nos automatice todo esto de crear caracteres:
overflowCreate.py
Por lo que vamos a crear lo siguiente:
Info:
Y ahora ese patron se lo vamos a insertar en el GDB de la aplicacion, ejecutando run, si pegamos todo esto, veremos lo siguiente:
Vemos que esta escribiendo bien el RIP con las B que hemos metido que se representan en hexadecimal con el 42424242 y las A con el 4141414141414141, por lo que se esta escribiendo todo correctamente.
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.
Info:
Vemos que la key se esta llenando de B(42) despues de los 76 caracteres, por lo que hemos encontrado el offset real, ahora vamos a crearnos un mini script, para automatizar todo esto...
Rellenando la key con dead
deadSabiendo que la direccion de memoria es 0xdead la que tiene que rellenar la key, podremos crear el siguiente script, para ver si se rellena bien:
exploit.py
Si lo ejecutamos vemos lo siguiente:
Info:
Por lo que vemos funciona correctamente, por lo que ahora vamos automatizar el que envie un comando tambien de la siguiente forma:
exploit.py
Si lo ejecutamos vemos lo siguiente:
Info:
Ejecución de comando
Vemos que se esta ejecutando como root ya que el binario esta con permisos SUID por lo que vamos hacer lo siguiente para ser root:
exploit.py
Si lo ejecutamos vemos lo siguiente:
Info:
Vamos a ver si ha funcionado listando los permisos de la bash:
Info:
Vemos que efectivamente a funcionado, por lo que haremos lo siguiente:
Y con esto seremos root, por lo que ya habremos terminado.
Last updated