# DC-9

## Enumeración ### Puertos abiertos Comenzamos enumerando que servicios tiene abiertos la máquina DC-9. ``` nmap -p- --open --min-rate 500 -Pn -n -vvv 192.168.176.209 ```

Un único puerto abierto, el 80. Vamos a ver que se está ejecutando en este servicio. ``` nmap -p80 -Pn -n -sVC -vvv 192.168.176.209 ```

Servicios abiertos: * Puerto 80 -> HTTP -> Apache httpd 2.4.38 ### Enumeración Web Se está ejecutando un servidor Web en la máquina objetivo. Vamos al navegador para ver el contenido del sitio Web.

En "Display All Records" podemos ver todos los registros de información sobre usuarios potenciales.

También parece que podemos buscar usuarios por su nombre.

Otra cosa que vamos a hacer es enumerar los directorios y archivos interesantes.

feroxbuster -u http://192.168.176.209 -s200,301 -x html,txt,php -n

## Explotación ### Explotando la base de datos (sin SQLMap) Si llevamos a cabo una inyección SQL típica, nos proporcionará todos los datos correspondientes a la opción "Visualizar todos los registros". Esta es la inyección SQL que empleé:

Esta inyección nos devuelve la informaciónd de la lista de usuarios sin devolver ningún error. Podemos entender que esta entrada de datos es vulnerable a SQLi. Comenzaremos por listar el número de columnas con las que es posible trabajar. Para listar las columnas, emplearé la consulta "ORDER BY", iniciando con el número 1 e incrementándolo hasta que produzca un error o no proporcione información alguna. Pondremos a prueba esto utilizando el nombre conocido "mary", y la estructura de la consulta se presentará de la siguiente forma: ``` mary' order by 1 -- - ``` Incrementando el número en uno, observamos que al ejecutar "ORDER BY 7", deja de mostrarse información, lo que indica que el total de columnas es 6. Nuestro próximo objetivo es determinar en qué parte se muestra la información de cada columna. Por lo tanto, introduciremos algunos números para reconocer cada columna, y esto se puede llevar a cabo a través de la siguiente consulta: `mary' union all select 1,2,3,4,5,6 -- -`

Observamos la posición de cada columna, identificada por un número. Una vez que conocemos dónde se puede visualizar la información, debemos determinar la versión de la base de datos (asumiendo que sea MySQL) y esto se puede lograr mediante la siguiente consulta: ``` mary' union all selecn,6 -- - ```

La información que conseguimos al identificar la versión nos facilita entender de qué manera efectuaremos las consultas. El próximo paso es listar las bases de datos usando el esquema de información, esta es la pregunta que empleamos para mostrar las bases de datos: ``` mary' union all select 1,2,3,4,schema_name,6 from information_schema.schemata -- - ```

Basándonos en la información proporcionada, la base de datos de "usuarios" nos parece la más intrigante. Por el momento, vamos a listar las tablas para determinar cuál es interesante, y para ello, hemos empleado la consulta siguiente: ``` mary' union select all 1,2,3,4,table_name,6 from information_schema.tables -- - ```

Ahora vamos a listar los nombres de los campos presentes en la tabla con el fin de identificar cuáles de ellos podrían contener información relevante. Para lograr esto, emplearemos la consulta que se muestra a continuación: ``` mary' union all select 1,2,3,4,column_name,6 FROM information_schema.columns where table_name='UserDetails' -- - ```

Existen seis campos en total, pero los que realmente nos importan son los denominados "nombre de usuario" y "contraseña". Para visualizar únicamente estos datos de "UserDetails", situaremos el nombre de usuario en la cuarta columna y las contraseñas en la quinta. La consulta que empleamos es la siguiente: ``` mary' union all select 1,2,3,concat(username),concat(password),6 FROM users.UserDetails -- - ```

Si observamos juntos la tabla de Usuarios, conseguiremos un nombre de usuario correspondiente al administrador y una contraseña cifrada. La consulta para alcanzar este objetivo se muestra de la siguiente manera: ``` mary' union all select 1,2,3,concat(username),concat(password),6 FROM Users -- - ```

Para conseguir la clave a partir del hash, empleamos CrackStation en vez de utilizar herramientas en el equipo, logrando así adquirir la contraseña de forma veloz.

Obtenemos las credenciales del usuario admin: admin:transorbital1 ### Acceso al sistema Accedemos a la zona de administración con estas credenciales y vemos lo siguiente.

Una vez que hemos iniciado sesión, observamos en la parte de abajo un mensaje que indica "El archivo no existe", dando la impresión de que busca un archivo. Esto nos lleva a creer que la página está intentando obtener un archivo y mostrarlo. A través de prueba y error, podemos descubrir una vulnerabilidad LFI al incluir un parámetro de archivo. Simplemente incluimos ?file= en la barra de URL.

Básicamente, todos los usuarios que vimos anteriormente tienen acceso a la máquina y las contraseñas que obtuvimos podrían permitirnos ingresar a la máquina, pero del informe nmap sabemos que el puerto SSH está siendo filtrado, esto podría significar que está restringido por IP tal vez o estamos lidiando con un "port knocking". Aprovechando el LFI, intentamos leer un archivo knockd.conf si estaba disponible y pudimos obtener información de dicho archivo.

Estupendo, ahora todo lo que tenemos que hacer es eliminar la secuencia de puertos que se muestran desde el archivo utilizando nmap. La llamada de puerto con nmap usando esos números de puerto se puede lograr con el siguiente comando: ``` nmap -p 7469,8475,9842 --max-retries 0 192.168.176.209 ```

Volvemos a escanear los servicios de esta máquina.

Ya está abierto el puerto 22 en la máquina DC-9. Ahora el siguiente paso podría realizar un ataque de fuerza bruta sobre el puerto 22 (SSH) para determinar que usuario está en el sistema y su contraseña. ¿Como extraemos estos nombres de usuario? Recordamos que durante la explotación de la base de datos, utilizamos consultas de MySQL para ir extrayendo información. Pues ahora igual, debemos construir una consulta que nos devuelva únicamente nombres de usuario y contraseña de forma concatenada. ``` mary' union select group_concat(username,":",password),2,3,4,5,6 from users.UserDetails-- -) ```

Copiamos esta línea en un documento de texto, y extraemos de ella una lista de nombre de usuarios y otra de contraseñas. ``` awk -F: '{print $1}' sshUsers | sort -r | tee sshUsersUsername awk -F: '{print $2}' sshUsers | sort -r | tee sshUsersPassword ```

Ahora que tenemos las dos listas, con hydra vamos a realizar el ataque de fuerza bruta de la siguiente manera: ``` hydra -L sshUsersUsername -P sshUsersPassword 192.168.176.209 ssh ```

Había tres credenciales válidas que funcionaban con SSH, así que simplemente usamos SSH como usuario de chandlerb.

En el directorio del usuario "chandler", no encontramos información interesante así que pivotamos a otros usuarios. Para ello, volvemos a utilizar las credenciales encontradas durante la fuerza bruta.

Enumeramos dentro del directorio de este usuario.

Encontramos nuevas contraseñas. Vamos a añadirlas al archivo de passwords que generamos anteriormente y volvemos a ejecutar hydra.

Obtenemos unas credenciales nuevas para el usuario "fredf". Vamos a iniciar sesión con estas credenciales.

Enumerando en el directorio del usuario "fredf" encontramos la flag local.txt.

## Elevación de privilegios Una vez que hayamos iniciado sesión como fredf, podemos verificar si tiene algún permiso de sudo usando el comando `sudo -l`.

Nos dirigimos juntos a la ubicación donde observamos que se encuentra almacenada el archivo test.py. Al examinarlo con más atención, nos damos cuenta de que se trata de un programa sencillo para añadir datos. Aceptará dos archivos como parámetros y luego agregará el contenido del primer archivo dentro del segundo archivo.

¿Cómo podemos utilizar este archivo? Crearemos un nuevo usuario con acceso de root y añadiremos la entrada del usuario en el archivo /etc/passwd utilizando el script test.py. Crearemos un usuario y su hash de contraseña. Llevaremos a cabo esta tarea usando openssl. Aquí, crearemos un usuario llamado securiters con la contraseña securiters. Una vez obtenido nuestro hash, pasaremos a la máquina objetivo. ``` openssl passwd -1 -salt securiters securiters ```

Añadimos el nombre de usuario, seguido de dos puntos (:) y ":0:0::" para crear una entrada que podría funcionar como usuario "root". Luego, empleamos el comando echo para generar un archivo llamado "securiters" en el directorio /tmp. Posteriormente, utilizamos el script test.py que descubrimos antes con el archivo "securiters" e incluimos el hash del usuario que acabamos de crear dentro del archivo /etc/passwd. Después de eso, iniciamos sesión como el usuario securiters que hemos creado. Ingresamos la contraseña y obtenemos acceso de root en la máquina.

Ya tenemos privilegios máximos dentro de la máquina objetivo. Ahora a por la flag proof.txt para finalizar la resolución.

{% embed url="" %}