Insanity DockerLabs (Hard)

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 insanity.zip

Nos lo descomprimira y despues montamos la maquina de la siguiente forma.

bash auto_deploy.sh insanity.tar

Info:


                            ##        .         
                      ## ## ##       ==         
                   ## ## ## ##      ===         
               /""""""""""""""""\___/ ===       
          ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
               \______ o          __/           
                 \    \        __/            
                  \____\______/               
                                          
  ___  ____ ____ _  _ ____ ____ _    ____ ___  ____   
  |  \ |  | |    |_/  |___ |__/ |    |__| |__] [__   
  |__/ |__| |___ | \_ |___ |  \ |___ |  | |__] ___]  
                                         
                                     
Desactivando el ASLR para poder resolver el laboratorio...

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 eliminarla

Por 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:

Vemos que cuando nos metemos en la pagina, nos redirige a un dominio llamado insanity.dl por lo que haremos lo siguiente.

Lo guardamos y volvemos a cargar la pagina.

Si inspeccionamos la pagina, abajo del todo veremos lo siguiente en el codigo:

Vamos a probar a buscar alguna de estas cosas, por lo que realizaremos un poco de fuzzing con un diccionario grande, ya que con los medianos no encuentra nada:

Gobuster

Info:

Vemos un directorio interesante llamado /tinyp que si entramos en el veremos 2 archivos:

Por lo que nos lo descargaremos para ver mas en detalle que son.

Si ejecutamos el secret veremos lo siguiente:

Info:

Y si ejecutamos el otro veremos esto:

Info:

Vemos que el archivo secret depende del archivo libcredenciales.so por lo que tendremos que investigar el archivo secret.

Pero no conseguimos mucho, sin embargo si utilizamos ghidra para hacer ingenieria inversa al archivo libcredenciales.so veremos lo siguiente:

Escalate user maci

Ingenieria inversa

Seleccionamos el archivo libcredenciales.so y veremos el codigo en C, por lo que nos vamos a ver que funciones tiene y vemos unas bastante interesantes llamadas a,b y g.

El código sugiere que la función g() utiliza b() y a() para transformar un conjunto de valores almacenados en variables como local_4d8, local_4d4, etc., en una cadena de caracteres que se utiliza como parte de una URL o nombre de archivo. Este flujo sugiere que puede haber una relación entre la transformación y un valor esperado.

Análisis del código:

  1. a(int param_1):

    • Este realiza una transformación condicional:

      • Si el valor está entre 1 y 0x1A, suma 0x60.

      • Si no, hay casos especiales para 0x1B, 0x1C, 0x1D, y 0x1E.

      • Valores que no encajan en ninguna de estas condiciones se convierten a 0x3F.

  2. b(long param_1, int param_2, long param_3):

    • Llama a a() para cada valor en un arreglo de enteros, transformándolos en caracteres que almacena en el espacio apuntado por param_3.

  3. g():

    • Define un arreglo de valores (local_4d8, local_4d4, ..., local_438).

    • Usa b() para convertir estos valores en una cadena almacenada en auStack_528.

    • Construye una URL y ejecuta un comando wget para descargar un archivo.

Por lo que nos vamos a montar un script para poder decodificar eso y a ver a que URL nos manda esto:

decodeLibcredenciales.py

Lo ejecutamos de la siguiente forma:

Info:

Vemos que hay un directorio en la web, si entramos ahi veremos un .txt con una secuencia de numeros 2334645634646.txt dentro de el veremos lo siguiente:

Vemos que hemos obtenido las credenciales del usuario maci, por lo que nos conectaremos a el.

SSH

Metemos como contraseña CrACkEd y veremos que estamos dentro.

Escalate Privileges

Si listamos por los permisos SUID que tenemos:

Info:

Vemos una interesante que esta en el /opt llamado vuln, si la intentamos ejecutar, veremos lo siguiente:

Info:

Y nos vemos nada mas, pero si probamos lo siguiente:

Info:

Vemos que nos da un Segmentation fault por lo que podremos hacerle Buffer Overflow.

Si comprobamos si gdb esta instalado, vemos que si lo esta:

Por lo que podremos hacerlo directamente en la propia maquina victima.

GDB

Dentro del gdb con el binario cargado vamos a probar a realizar una explotación de ret2libc, lo que implica el uso de funciones de la biblioteca estándar de C (como system, execve, o exit) para ejecutar un código malicioso (en este caso, obtener una shell)

Obtener el offset del binario

En nuestro kali nos tendremos que llevar el binario para saber el offset de forma mas sencillita, por lo que abriremos un server de python3 en la maquina y nos lo pasaremos al kali con wget una vez que ya lo tengamos instalaremos la herramienta para el gdb llamada pwndbg, una vez echo todo esto, haremos lo siguiente:

Info:

Dentro del gdb ejecutaremos r e insertaremos el patron que hemos creado anteriormente, por lo que veremos esto:

Y dentificamos que la direccion de memoria es 0x3765413665413565 por lo que obtendremos su offset con la siguiente herramienta:

Info:

Veremos que es de 136.

Ahora de aqui para abajo sera todo dentro de la maquina victima, lo de antes solamente era en la maquina host para sacar el offset.

Buscar la dirección de memoria /bin/sh

Info:

Por lo que veremos la encintramos que estaria en la 0x7ffff7f73031, vamos a ver si es cierto de la siguiente forma:

Info:

Vemos que si, por lo que ya tendriamos la dirección de memoria del sh.

Buscar la dirección de memoria system

Info:

Vemos que la dirección seria 0x7ffff7e29490.

Buscar la dirección de memoria ret

Info:

Vemos que la que nos interesa seria la siguiente linea:

Por lo que seria la dirección 0x0000000000401016.

Buscar la dirección de memoria pop_rdi_ret

Info:

Vemos que la que nos interesa seria 0x000000000040116a.

Esto nos da la dirección del gadget que necesitamos. pop rdi; ret carga el valor de un argumento en el registro rdi (el primero para las funciones como system()) y luego hace un ret para volver a la siguiente instrucción, que normalmente será la ejecución de la función.

Podremos obtener mas informacion acerca de esta tecnica y de como funciona en la siguiente pagina en la que me ayudo bastante para poder realizarla.

URL = Explotacion ret2libc Info

EXPLICACION DE TODO:

¿Qué es la técnica de ret2libc?

La técnica ret2libc es un ataque de desbordamiento de buffer utilizado para ejecutar funciones de la librería estándar de C (libc) sin necesidad de tener que escribir código malicioso como shellcode. En lugar de inyectar código directamente, el atacante redirige la ejecución del programa para llamar funciones ya presentes en la librería del sistema, como system(), que permite ejecutar comandos en el sistema operativo.

En un ataque ret2libc:

  1. Buffer overflow: El atacante provoca un desbordamiento en un buffer, lo que sobrescribe el registro de retorno (el RIP o EIP en arquitecturas modernas) y lo redirige a una función de libc, por ejemplo, system().

  2. Gadget de ROP: Utiliza gadgets que permiten controlar los registros necesarios para invocar funciones en la libc de manera adecuada, como cargar los parámetros requeridos por la función system() (como la dirección de "/bin/sh").

  3. Ejecutar comandos: Esto permite al atacante ejecutar comandos del sistema, como abrir una shell con system("/bin/sh").

Identificación de gadgets útiles:

  • Para realizar un ataque ret2libc, necesitamos gadgets que nos ayuden a preparar los registros para llamar a la función que queremos. En este caso, el gadget necesario es pop rdi; ret, que nos permite poner un argumento en el registro rdi (el primer argumento de una función en la convención de llamada x86_64).

  • Usamos ROPgadget para encontrar estos gadgets. En el caso de nuestro binario, el gadget pop rdi; ret lo encontramos en la dirección 0x40116a.

Encontrar direcciones en la libc:

  • Para poder llamar a system(), necesitamos la dirección de esa función dentro de la memoria. Esta dirección está contenida dentro de la librería libc (una librería estándar que es utilizada por muchos programas).

  • Una forma de encontrar esta dirección es buscar en memoria por la cadena "/bin/sh", que es el argumento que pasa a la función system() para ejecutar un shell. En este caso, la dirección encontrada fue 0x7ffff7f73031.

Obtener la dirección de system():

  • Para realizar el ataque, necesitamos la dirección de la función system(), que es la que ejecutará el comando /bin/sh en el sistema. Usamos pwn para obtener esta dirección desde la librería libc.

Sabiendo toda esta informacion vamos a montarnos un script en python3:

Explicación del payload:

  • Relleno (A * offset): Se coloca un relleno para sobrescribir el registro de retorno (RIP) en la pila. El offset de 136 es obtenido a través de pruebas previas (por ejemplo, con gdb).

  • Gadget pop rdi ; ret: Usamos este gadget para colocar la dirección de "/bin/sh" en el registro rdi, que es el primer argumento para system().

  • Dirección de "/bin/sh": La dirección de la cadena "/bin/sh" se obtiene de la memoria.

  • Gadget ret: A veces es necesario un gadget adicional como ret para garantizar que la pila esté bien alineada antes de llamar a la función.

  • Dirección de system(): Finalmente, usamos la dirección de la función system() para ejecutar el comando "/bin/sh", que debería abrir una shell.

Ahora lo ejecutaremos de la siguiente forma:

Info:

Y como vemos con esto ya seremos root, por lo que habremos terminado la maquina.

PreviousWhereIsMyWebShell DockerLabs (Easy)NextNodeClimb DockerLabs (Easy)

Last updated